diff --git a/.cargo/config.toml b/.cargo/config.toml
index 810054d3158..f6795e3c6ec 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,7 +1,3 @@
-[alias]
-# Warnings create a lot of noise, we only print errors.
-check-clippy = "clippy --no-deps -- --allow warnings"
-
 # Can be safely removed once Cargo's sparse protocol (see
 # https://blog.rust-lang.org/2023/03/09/Rust-1.68.0.html#cargos-sparse-protocol)
 # becomes the default.
diff --git a/.config/nextest.toml b/.config/nextest.toml
new file mode 100644
index 00000000000..3fa8a93aced
--- /dev/null
+++ b/.config/nextest.toml
@@ -0,0 +1,15 @@
+[[profile.default.overrides]]
+filter = 'package(graphman-server)'
+priority = -1
+threads-required = 'num-test-threads' # Global mutex
+
+[[profile.default.overrides]]
+filter = 'package(test-store)'
+priority = -2
+threads-required = 'num-test-threads' # Global mutex
+
+[[profile.default.overrides]]
+filter = 'package(graph-tests)'
+priority = -3
+threads-required = 'num-test-threads' # Global mutex
+slow-timeout = { period = "300s", terminate-after = 4 }
diff --git a/.github/workflows/audit.yml b/.github/workflows/audit.yml
index 102a8b53e78..96fa5ba1cb8 100644
--- a/.github/workflows/audit.yml
+++ b/.github/workflows/audit.yml
@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/audit-check@v1
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4
+      - uses: rustsec/audit-check@69366f33c96575abad1ee0dba8212993eecbe998 #v2.0.0
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1b400f1fbd7..59bbd6ce598 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,21 +1,30 @@
 name: Continuous Integration
-
 on:
   push:
     branches: [master]
   pull_request:
-    types: [opened, synchronize, reopened]
+    branches: [master]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  cancel-in-progress: true
+  group: ${{ github.workflow }}-${{ github.ref }}
 
 env:
   CARGO_TERM_COLOR: always
   RUST_BACKTRACE: full
-  THEGRAPH_STORE_POSTGRES_DIESEL_URL: "postgresql://postgres:postgres@localhost:5432/graph_node_test"
+  RUSTFLAGS: "-C link-arg=-fuse-ld=lld -D warnings"
+  THEGRAPH_STORE_POSTGRES_DIESEL_URL: "postgresql://graph:graph@localhost:5432/graph-test"
+  GRAPH_STORE_CONNECTION_TIMEOUT: "30000"
 
 jobs:
   unit-tests:
     name: Run unit tests
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
+    runs-on: nscloud-ubuntu-22.04-amd64-16x32
+    timeout-minutes: 20
     services:
       ipfs:
         image: ipfs/go-ipfs:v0.10.0
@@ -24,91 +33,104 @@ jobs:
       postgres:
         image: postgres
         env:
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: graph_node_test
-          POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C"
+          POSTGRES_USER: graph
+          POSTGRES_PASSWORD: graph
+          POSTGRES_DB: graph-test
+          POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C -c max_connections=1000 -c shared_buffers=2GB"
         options: >-
-          --health-cmd pg_isready
+          --health-cmd "pg_isready -U graph"
           --health-interval 10s
           --health-timeout 5s
           --health-retries 5
+          --name postgres
         ports:
           - 5432:5432
-    env:
-      RUSTFLAGS: "-C link-arg=-fuse-ld=lld -D warnings"
     steps:
-      - name: Tune GitHub hosted runner to reduce flakiness
-        # https://github.com/smorimoto/tune-github-hosted-runner-network/blob/main/action.yml
-        run: sudo ethtool -K eth0 tx off rx off
-      - name: Checkout sources
-        uses: actions/checkout@v2
-      - uses: Swatinem/rust-cache@v2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+
+      - name: Setup dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y lld protobuf-compiler
 
-      - name: Install lld
-        run: sudo apt-get install -y lld protobuf-compiler
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48 # v1
 
-      - name: Run unit tests
-        uses: actions-rs/cargo@v1
+      - name: Setup just
+        uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff # v3
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda # v4
+
+      - name: Install Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
         with:
-          command: test
-          args: --verbose --workspace --exclude graph-tests -- --nocapture
+          node-version: 20
+          cache: pnpm
+
+      - name: Install Node.js dependencies
+        run: pnpm install
+
+      - name: Run unit tests
+        run: just test-unit
 
   runner-tests:
     name: Subgraph Runner integration tests
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
+    runs-on: nscloud-ubuntu-22.04-amd64-16x32
+    timeout-minutes: 20
     services:
       ipfs:
         image: ipfs/go-ipfs:v0.10.0
         ports:
           - 5001:5001
       postgres:
-        image: bitnami/postgresql
+        image: postgres
         env:
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: graph_node_test
-          POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C"
-          POSTGRESQL_EXTRA_FLAGS: "-c max_connections=1000"
+          POSTGRES_USER: graph
+          POSTGRES_PASSWORD: graph
+          POSTGRES_DB: graph-test
+          POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C -c max_connections=1000 -c shared_buffers=2GB"
         options: >-
-          --health-cmd "pg_isready -U postgres"
+          --health-cmd "pg_isready -U graph"
           --health-interval 10s
           --health-timeout 5s
-          --health-retries 10
+          --health-retries 5
+          --name postgres
         ports:
           - 5432:5432
-    env:
-      RUSTFLAGS: "-C link-arg=-fuse-ld=lld -D warnings"
-      RUNNER_TESTS_WAIT_FOR_SYNC_SECS: "600"
     steps:
-      - name: Tune GitHub hosted runner to reduce flakiness
-        # https://github.com/smorimoto/tune-github-hosted-runner-network/blob/main/action.yml
-        run: sudo ethtool -K eth0 tx off rx off
-      - name: Checkout sources
-        uses: actions/checkout@v2
-
-      - name: Install Node 20
-        uses: actions/setup-node@v3
-        with:
-          node-version: "20"
-          cache: yarn
-          cache-dependency-path: "tests/runner-tests/yarn.lock"
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
 
-      - uses: Swatinem/rust-cache@v2
+      - name: Setup dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y lld protobuf-compiler
 
-      - name: Install lld
-        run: sudo apt-get install -y lld protobuf-compiler
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48 # v1
 
-      - name: Run runner tests
-        id: runner-tests-1
-        uses: actions-rs/cargo@v1
+      - name: Setup just
+        uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff # v3
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda # v4
+
+      - name: Install Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
         with:
-          command: test
-          args: --package graph-tests --test runner_tests
+          node-version: 20
+          cache: pnpm
+
+      - name: Install Node.js dependencies
+        run: pnpm install
+
+      - name: Run runner tests
+        run: just test-runner
 
   integration-tests:
     name: Run integration tests
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
+    runs-on: nscloud-ubuntu-22.04-amd64-16x32
+    timeout-minutes: 20
     services:
       ipfs:
         image: ipfs/go-ipfs:v0.10.0
@@ -120,60 +142,61 @@ jobs:
           POSTGRES_USER: graph-node
           POSTGRES_PASSWORD: let-me-in
           POSTGRES_DB: graph-node
-          POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C"
+          POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C -c max_connections=1000 -c shared_buffers=2GB"
         options: >-
-          --health-cmd pg_isready
+          --health-cmd "pg_isready -U graph-node"
           --health-interval 10s
           --health-timeout 5s
           --health-retries 5
+          --name postgres
         ports:
           - 3011:5432
-    env:
-      RUSTFLAGS: "-C link-arg=-fuse-ld=lld -D warnings"
     steps:
-      - name: Tune GitHub hosted runner to reduce flakiness
-        # https://github.com/smorimoto/tune-github-hosted-runner-network/blob/main/action.yml
-        run: sudo ethtool -K eth0 tx off rx off
-      - name: Checkout sources
-        uses: actions/checkout@v2
-      - uses: Swatinem/rust-cache@v2
-
-      - name: Install Node 20
-        uses: actions/setup-node@v3
-        with:
-          node-version: "20"
-          cache: yarn
-          cache-dependency-path: "tests/integration-tests/yarn.lock"
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+
+      - name: Setup dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y lld protobuf-compiler
 
-      - name: Install lld and jq
-        run: sudo apt-get install -y lld jq protobuf-compiler
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48 # v1
+
+      - name: Setup just
+        uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff # v3
 
       - name: Install Foundry
-        uses: foundry-rs/foundry-toolchain@v1
-      - name: Start anvil
-        run: anvil --gas-limit 100000000000 --base-fee 1 --block-time 2 --port 3021 &
+        uses: foundry-rs/foundry-toolchain@82dee4ba654bd2146511f85f0d013af94670c4de # v1
+        with:
+          version: v1.4.0
 
-      - name: Install graph CLI
-        run: curl -sSL http://cli.thegraph.com/install.sh | sudo bash
+      - name: Install pnpm
+        uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda # v4
 
-      - name: Build graph-node
-        uses: actions-rs/cargo@v1
+      - name: Install Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
         with:
-          command: build
-          args: --bin graph-node --test integration_tests
+          node-version: 20
+          cache: pnpm
+
+      - name: Install Node.js dependencies
+        run: pnpm install
+
+      - name: Start anvil
+        run: anvil --gas-limit 100000000000 --base-fee 1 --timestamp 1743944919 --port 3021 &
+
+      - name: Build graph-node
+        run: just build --test integration_tests
 
       - name: Run integration tests
-        id: integration-tests-1
-        uses: actions-rs/cargo@v1
-        env:
-          # Basically, unlimted concurrency
-          N_CONCURRENT_TESTS: "1000"
-        with:
-          command: test
-          args: --test integration_tests -- --nocapture
+        run: |
+          export PATH="${{ github.workspace }}/node_modules/.bin:$PATH"
+          just test-integration
+
       - name: Cat graph-node.log
         if: always()
         run: cat tests/integration-tests/graph-node.log || echo "No graph-node.log"
+
   rustfmt:
     name: Check rustfmt style
     runs-on: ubuntu-latest
@@ -181,45 +204,55 @@ jobs:
     env:
       RUSTFLAGS: "-D warnings"
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48 # v1
+
+      - name: Setup just
+        uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff # v3
 
       - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
+        run: just format --check
 
   clippy:
     name: Clippy linting
     runs-on: ubuntu-latest
-    timeout-minutes: 60
+    timeout-minutes: 10
+    env:
+      RUSTFLAGS: "-D warnings"
     steps:
-      - uses: actions/checkout@v2
-      # Unlike rustfmt, Clippy actually compiles stuff so it benefits from
-      # caching.
-      - uses: Swatinem/rust-cache@v2
-      - name: Install deps
-        run: sudo apt-get install -y protobuf-compiler
-      - name: Run Clippy
-        uses: actions-rs/cargo@v1
-        with:
-          command: check-clippy
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+      - name: Setup dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y protobuf-compiler
+
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48 # v1
+
+      - name: Setup just
+        uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff # v3
+
+      - name: Run linting
+        run: just lint
 
   release-check:
     name: Build in release mode
     runs-on: ubuntu-latest
-    timeout-minutes: 60
+    timeout-minutes: 10
     env:
       RUSTFLAGS: "-D warnings"
     steps:
-      - uses: actions/checkout@v2
-      - uses: Swatinem/rust-cache@v2
-      - name: Install dependencies
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+      - name: Setup dependencies
         run: |
           sudo apt-get update
-          sudo apt-get -y install libpq-dev protobuf-compiler
+          sudo apt-get install -y protobuf-compiler
+
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48 # v1
+
+      - name: Setup just
+        uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff # v3
+
       - name: Cargo check (release)
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --release
\ No newline at end of file
+        run: just check --release
diff --git a/.github/workflows/code-coverage.yml b/.github/workflows/code-coverage.yml
deleted file mode 100644
index 5ca14794035..00000000000
--- a/.github/workflows/code-coverage.yml
+++ /dev/null
@@ -1,74 +0,0 @@
-name: Code coverage
-
-on:
-  workflow_dispatch:
-  schedule:
-    # Run it every 3 days.
-    - cron: "0 3 * * *"
-
-env:
-  CARGO_TERM_COLOR: always
-  RUST_BACKTRACE: full
-  THEGRAPH_STORE_POSTGRES_DIESEL_URL: "postgresql://postgres:postgres@localhost:5432/graph_node_test"
-  RUSTFLAGS: "-C link-arg=-fuse-ld=lld -D warnings"
-  N_CONCURRENT_TESTS: "4"
-  TESTS_GANACHE_HARD_WAIT_SECONDS: "30"
-
-jobs:
-  # Heavily inspired from <https://github.com/taiki-e/cargo-llvm-cov#continuous-integration>.
-  coverage:
-    name: Code coverage of integration tests
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    services:
-      ipfs:
-        image: ipfs/go-ipfs:v0.10.0
-        ports:
-          - 5001:5001
-      postgres:
-        image: postgres
-        env:
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: graph_node_test
-          POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C"
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 5432:5432
-    steps:
-      - uses: actions/checkout@v3
-      - uses: Swatinem/rust-cache@v2
-      - name: Install Node 14
-        uses: actions/setup-node@v3
-        with:
-          node-version: "14"
-          cache: yarn
-          cache-dependency-path: "tests/integration-tests/yarn.lock"
-      - name: Install lld
-        run: sudo apt-get install -y lld jq protobuf-compiler
-      - uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-llvm-cov
-
-      - name: Build graph-node
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --bin graph-node
-
-      - name: Generate code coverage
-        run: cargo llvm-cov --package graph-tests --lcov --output-path lcov.info -- --nocapture
-      - uses: actions/upload-artifact@v3
-        with:
-          name: code-coverage-info
-          path: lcov.info
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3
-        with:
-          # No token needed, because the repo is public.
-          files: lcov.info
-          fail_ci_if_error: true
diff --git a/.github/workflows/gnd-binary-build.yml b/.github/workflows/gnd-binary-build.yml
new file mode 100644
index 00000000000..237de3342b5
--- /dev/null
+++ b/.github/workflows/gnd-binary-build.yml
@@ -0,0 +1,355 @@
+name: Build gnd Binaries
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        description: 'Existing release tag to upload binaries to and publish as on npm (e.g. v0.44.0). Leave empty to only build artifacts.'
+        type: string
+        default: ''
+      dry_run:
+        description: 'Dry-run npm publish (no actual publish)'
+        type: boolean
+        default: false
+
+jobs:
+  build:
+    name: Build gnd for ${{ matrix.target }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: x86_64-unknown-linux-gnu
+            runner: ubuntu-22.04
+            asset_name: gnd-linux-x86_64
+          - target: aarch64-unknown-linux-gnu
+            runner: ubuntu-22.04
+            asset_name: gnd-linux-aarch64
+          - target: x86_64-apple-darwin
+            runner: macos-14
+            asset_name: gnd-macos-x86_64
+          - target: aarch64-apple-darwin
+            runner: macos-latest
+            asset_name: gnd-macos-aarch64
+          - target: x86_64-pc-windows-msvc
+            runner: windows-latest
+            asset_name: gnd-windows-x86_64.exe
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Cache built binary
+        id: bin-cache
+        uses: actions/cache@v5
+        with:
+          path: |
+            ${{ matrix.asset_name }}.gz
+            ${{ matrix.asset_name }}.zip
+          key: gnd-${{ matrix.target }}-${{ hashFiles('Cargo.lock', '**/Cargo.toml', '**/*.rs') }}
+
+      - name: Install Rust toolchain
+        if: steps.bin-cache.outputs.cache-hit != 'true'
+        run: |
+          rustup toolchain install stable
+          rustup target add ${{ matrix.target }}
+          rustup default stable
+
+      - name: Rust Cache
+        if: steps.bin-cache.outputs.cache-hit != 'true'
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ matrix.target }}
+
+      - name: Install dependencies (Ubuntu)
+        if: steps.bin-cache.outputs.cache-hit != 'true' && startsWith(matrix.runner, 'ubuntu')
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y protobuf-compiler musl-tools
+          if [ "${{ matrix.target }}" = "aarch64-unknown-linux-gnu" ]; then
+            sudo apt-get install -y gcc-aarch64-linux-gnu
+          fi
+
+      - name: Install dependencies (macOS)
+        if: steps.bin-cache.outputs.cache-hit != 'true' && startsWith(matrix.runner, 'macos')
+        run: |
+          brew install protobuf
+
+      - name: Install protobuf (Windows)
+        if: steps.bin-cache.outputs.cache-hit != 'true' && startsWith(matrix.runner, 'windows')
+        run: choco install protoc
+
+      - name: Build gnd binary (Unix/Mac)
+        if: steps.bin-cache.outputs.cache-hit != 'true' && !startsWith(matrix.runner, 'windows')
+        run: cargo build --bin gnd --release --target ${{ matrix.target }}
+        env:
+          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
+
+      - name: Build gnd binary (Windows)
+        if: steps.bin-cache.outputs.cache-hit != 'true' && startsWith(matrix.runner, 'windows')
+        run: cargo build --bin gnd --release --target ${{ matrix.target }}
+
+      - name: Sign macOS binary
+        if: steps.bin-cache.outputs.cache-hit != 'true' && startsWith(matrix.runner, 'macos')
+        uses: lando/code-sign-action@v3
+        with:
+          file: target/${{ matrix.target }}/release/gnd
+          certificate-data: ${{ secrets.APPLE_CERT_DATA }}
+          certificate-password: ${{ secrets.APPLE_CERT_PASSWORD }}
+          certificate-id: ${{ secrets.APPLE_TEAM_ID }}
+          options: --options runtime --entitlements entitlements.plist
+
+      - name: Notarize macOS binary
+        if: steps.bin-cache.outputs.cache-hit != 'true' && startsWith(matrix.runner, 'macos')
+        uses: lando/notarize-action@v2
+        with:
+          product-path: target/${{ matrix.target }}/release/gnd
+          appstore-connect-username: ${{ secrets.NOTARIZATION_USERNAME }}
+          appstore-connect-password: ${{ secrets.NOTARIZATION_PASSWORD }}
+          appstore-connect-team-id: ${{ secrets.APPLE_TEAM_ID }}
+
+      - name: Prepare binary (Unix)
+        if: steps.bin-cache.outputs.cache-hit != 'true' && !startsWith(matrix.runner, 'windows')
+        run: |
+          cp target/${{ matrix.target }}/release/gnd ${{ matrix.asset_name }}
+          chmod +x ${{ matrix.asset_name }}
+          gzip ${{ matrix.asset_name }}
+
+      - name: Prepare binary (Windows)
+        if: steps.bin-cache.outputs.cache-hit != 'true' && startsWith(matrix.runner, 'windows')
+        run: |
+          copy target\${{ matrix.target }}\release\gnd.exe ${{ matrix.asset_name }}
+          7z a -tzip ${{ matrix.asset_name }}.zip ${{ matrix.asset_name }}
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ matrix.asset_name }}
+          path: |
+            ${{ matrix.asset_name }}.gz
+            ${{ matrix.asset_name }}.zip
+          if-no-files-found: error
+
+  release:
+    name: Create Release
+    needs: build
+    if: startsWith(github.ref, 'refs/tags/') || inputs.release_tag != ''
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Setup GitHub CLI
+        run: |
+          # GitHub CLI is pre-installed on GitHub-hosted runners
+          gh --version
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v8
+        with:
+          path: artifacts
+
+      - name: Display structure of downloaded artifacts
+        run: ls -R artifacts
+
+      - name: Upload Assets to Release
+        run: |
+          VERSION="${{ inputs.release_tag != '' && inputs.release_tag || github.ref_name }}"
+
+          gh release upload $VERSION --clobber --repo $GITHUB_REPOSITORY \
+            artifacts/gnd-linux-x86_64/gnd-linux-x86_64.gz \
+            artifacts/gnd-linux-aarch64/gnd-linux-aarch64.gz \
+            artifacts/gnd-macos-x86_64/gnd-macos-x86_64.gz \
+            artifacts/gnd-macos-aarch64/gnd-macos-aarch64.gz \
+            artifacts/gnd-windows-x86_64.exe/gnd-windows-x86_64.exe.zip
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  publish-npm:
+    name: Publish npm package for ${{ matrix.platform }}
+    needs: release
+    if: startsWith(github.ref, 'refs/tags/') || inputs.release_tag != ''
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: linux-x64
+            asset: gnd-linux-x86_64.gz
+            os_field: linux
+            cpu_field: x64
+            extract: gunzip
+          - platform: linux-arm64
+            asset: gnd-linux-aarch64.gz
+            os_field: linux
+            cpu_field: arm64
+            extract: gunzip
+          - platform: darwin-x64
+            asset: gnd-macos-x86_64.gz
+            os_field: darwin
+            cpu_field: x64
+            extract: gunzip
+          - platform: darwin-arm64
+            asset: gnd-macos-aarch64.gz
+            os_field: darwin
+            cpu_field: arm64
+            extract: gunzip
+          - platform: win32-x64
+            asset: gnd-windows-x86_64.exe.zip
+            os_field: win32
+            cpu_field: x64
+            extract: unzip
+    steps:
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+
+      - name: Download gnd binary
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release download "${{ inputs.release_tag != '' && inputs.release_tag || github.ref_name }}" \
+            --repo "${{ github.repository }}" \
+            --pattern "${{ matrix.asset }}" \
+            --output ./binary-archive
+
+      - name: Extract binary
+        run: |
+          mkdir -p pkg/bin
+          if [ "${{ matrix.extract }}" = "gunzip" ]; then
+            gunzip -c ./binary-archive > pkg/bin/gnd
+            chmod +x pkg/bin/gnd
+          else
+            unzip ./binary-archive -d pkg/bin
+            mv pkg/bin/*.exe pkg/bin/gnd.exe
+          fi
+
+      - name: Determine version and npm tag
+        id: version
+        shell: bash
+        run: |
+          VERSION="${{ inputs.release_tag != '' && inputs.release_tag || github.ref_name }}"
+          VERSION="${VERSION#v}"
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          # Prerelease versions (e.g. 0.42.2-dev.1) need an explicit --tag
+          if [[ "$VERSION" == *-* ]]; then
+            # Extract prerelease identifier (e.g. "dev" from "0.42.2-dev.1")
+            PRE="${VERSION#*-}"
+            TAG="${PRE%%.*}"
+            echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          else
+            echo "tag=latest" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Create package.json
+        shell: bash
+        run: |
+          if [ "${{ matrix.os_field }}" = "win32" ]; then
+            BIN_PATH="./bin/gnd.exe"
+          else
+            BIN_PATH="./bin/gnd"
+          fi
+
+          cat > pkg/package.json << EOF
+          {
+            "name": "@graphprotocol/gnd-${{ matrix.platform }}",
+            "version": "${{ steps.version.outputs.version }}",
+            "description": "gnd binary for ${{ matrix.platform }}",
+            "os": ["${{ matrix.os_field }}"],
+            "cpu": ["${{ matrix.cpu_field }}"],
+            "bin": {
+              "gnd": "${BIN_PATH}"
+            },
+            "publishConfig": {
+              "access": "public",
+              "provenance": true
+            },
+            "license": "(Apache-2.0 OR MIT)",
+            "repository": {
+              "type": "git",
+              "url": "https://github.com/graphprotocol/graph-node.git"
+            }
+          }
+          EOF
+
+      - name: Publish
+        run: npm publish --provenance --access public --tag ${{ steps.version.outputs.tag }} ${{ inputs.dry_run && '--dry-run' || '' }}
+        working-directory: pkg
+
+  publish-npm-wrapper:
+    name: Publish @graphprotocol/gnd wrapper
+    needs: publish-npm
+    if: startsWith(github.ref, 'refs/tags/') || inputs.release_tag != ''
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 24
+
+      - name: Determine version and npm tag
+        id: version
+        shell: bash
+        run: |
+          VERSION="${{ inputs.release_tag != '' && inputs.release_tag || github.ref_name }}"
+          VERSION="${VERSION#v}"
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          if [[ "$VERSION" == *-* ]]; then
+            PRE="${VERSION#*-}"
+            TAG="${PRE%%.*}"
+            echo "tag=${TAG}" >> $GITHUB_OUTPUT
+          else
+            echo "tag=latest" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Create wrapper package
+        shell: bash
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+
+          mkdir -p pkg/bin
+          cp gnd/npm/bin/gnd.js pkg/bin/gnd.js
+          cp gnd/npm/README.md pkg/README.md
+
+          cat > pkg/package.json << EOF
+          {
+            "name": "@graphprotocol/gnd",
+            "version": "${VERSION}",
+            "description": "Graph Node Development CLI",
+            "bin": {
+              "gnd": "./bin/gnd.js"
+            },
+            "optionalDependencies": {
+              "@graphprotocol/gnd-darwin-arm64": "${VERSION}",
+              "@graphprotocol/gnd-darwin-x64": "${VERSION}",
+              "@graphprotocol/gnd-linux-arm64": "${VERSION}",
+              "@graphprotocol/gnd-linux-x64": "${VERSION}",
+              "@graphprotocol/gnd-win32-x64": "${VERSION}"
+            },
+            "publishConfig": {
+              "access": "public",
+              "provenance": true
+            },
+            "license": "(Apache-2.0 OR MIT)",
+            "repository": {
+              "type": "git",
+              "url": "https://github.com/graphprotocol/graph-node.git"
+            }
+          }
+          EOF
+
+      - name: Publish
+        run: npm publish --provenance --access public --tag ${{ steps.version.outputs.tag }} ${{ inputs.dry_run && '--dry-run' || '' }}
+        working-directory: pkg
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 15ad2465251..0480ebcf19b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,14 +22,20 @@ lcov.info
 
 /tests/**/build
 /tests/**/generated
-/tests/**/node_modules
-/tests/**/yarn-error.log
-/tests/**/pnpm-lock.yaml
 
-# Built solidity contracts.
-/tests/**/bin
-/tests/**/truffle_output
+# Node dependencies
+node_modules/
+.pnpm-store/
 
 # Docker volumes and debug logs
 .postgres
-logfile
\ No newline at end of file
+logfile
+
+# Nix related files
+.direnv
+.envrc
+.data
+
+# Local claude settings
+.claude/settings.local.json
+.claude/ralph-loop.local.md
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index dcaabb18e56..00000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,87 +0,0 @@
-dist: bionic
-language: rust
-# This line would cache cargo-audit once installed,
-# but instead will fail from the 10 minute timeout after
-# printing the line "creating directory /home/travis/.cache/sccache"
-#cache: cargo
-rust:
-  - stable
-  - beta
-
-# Select pre-installed services
-addons:
-  postgresql: "10"
-  apt:
-    packages:
-      - postgresql-10
-      - postgresql-client-10
-services:
-  - postgresql
-  - docker
-
-before_install:
-  # Install Node.js 11.x
-  - nvm install 11 && nvm use 11
-  # Install IPFS
-  - wget "https://dist.ipfs.io/go-ipfs/v0.10.0/go-ipfs_v0.10.0_linux-amd64.tar.gz" -O /tmp/ipfs.tar.gz
-  - pushd . && cd $HOME/bin && tar -xzvf /tmp/ipfs.tar.gz && popd
-  - export PATH="$HOME/bin/go-ipfs:$PATH"
-  - ipfs init
-
-matrix:
-  fast_finish: true
-  include:
-    # Some env var is always necessary to differentiate included builds
-    # Check coding style
-    - env: CHECK_FORMATTING=true
-      rust: stable
-      script:
-        - rustup component add rustfmt
-        - cargo fmt --all -- --check
-
-    # Make sure release builds compile
-    - env: CHECK_RELEASE=true
-      rust: stable
-      script:
-        - cargo check --release
-
-    # Check for warnings
-    - env: RUSTFLAGS="-D warnings"
-      rust: stable
-      script:
-        - cargo check --tests
-
-    # Build tagged commits in release mode
-    - env: RELEASE=true
-      if: tag IS present
-      script:
-        - cargo build -p graph-node --release
-        - mv target/release/graph-node target/release/graph-node-$TRAVIS_OS_NAME
-
-env:
-  global:
-    - PGPORT=5432
-    - THEGRAPH_STORE_POSTGRES_DIESEL_URL=postgresql://travis:travis@localhost:5432/graph_node_test
-    # Added because https://nodejs.org/dist/ had issues
-    - NVM_NODEJS_ORG_MIRROR=https://cnpmjs.org/mirrors/node/
-
-# Test pipeline
-before_script:
-  - psql -c "ALTER USER travis WITH PASSWORD 'travis';"
-  - psql -c 'create database graph_node_test;' -U travis
-
-script:
-  # Run tests
-  - ipfs daemon &> /dev/null &
-  - RUST_BACKTRACE=1 cargo test --verbose --all -- --nocapture
-  - killall ipfs
-
-deploy:
-  provider: releases
-  api_key:
-    secure: ygpZedRG+/Qg/lPhifyNQ+4rExjZ4nGyJjB4DYT1fuePMyKXfiCPGicaWRGR3ZnZGNRjdKaIkF97vBsZ0aHwW+AykwOxlXrkAFvCKA0Tb82vaYqCLrBs/Y5AEhuCWLFDz5cXDPMkptf+uLX/s3JCF0Mxo5EBN2JfBQ8vS6ScKEwqn2TiLLBQKTQ4658TFM4H5KiXktpyVVdlRvpoS3pRIPMqNU/QpGPQigaiKyYD5+azCrAXeaKT9bBS1njVbxI69Go4nraWZn7wIhZCrwJ+MxGNTOxwasypsWm/u1umhRVLM1rL2i7RRqkIvzwn22YMaU7FZKCx8huXcj0cB8NtHZSw7GhJDDDv3e7puZxl3m/c/7ks76UF95syLzoM/9FWEFew8Ti+5MApzKQj5YWHOCIEzBWPeqAcA8Y+Az7w2h1ZgNbjDgSvjGAFSpE8m+SM0A2TOOZ1g/t/yfbEl8CWO6Y8v2x1EONkp7X0CqJgASMp+h8kzKCbuYyRnghlToY+5wYuh4M9Qg9UeJCt9dOblRBVJwW5CFr62kgE/gso8F9tXXHkRTv3hfk5madZR1Vn5A7KadEO8epfV4IQNsd+VHfoxoJSprx5f77Q2bLMBD1GT/qMqECgSznoTkU5ajkKJRqUw4AwLTohrYir76j61eQfxOhXExY/EM8xvlxpd1w=
-  file: target/release/graph-node-$TRAVIS_OS_NAME
-  repo: graphprotocol/graph-node
-  on:
-    tags: true
-  skip_cleanup: true
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000000..b8ec983428b
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,288 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Graph Node is a Rust-based decentralized blockchain indexing protocol that enables efficient querying of blockchain data through GraphQL. It's the core component of The Graph protocol, written as a Cargo workspace with multiple crates organized by functionality.
+
+## Essential Development Commands
+
+### Testing Workflow
+
+⚠️ **Only run integration tests when explicitly requested or when changes require full system testing**
+
+Use unit tests for regular development and only run integration tests when:
+
+- Explicitly asked to do so
+- Making changes to integration/end-to-end functionality
+- Debugging issues that require full system testing
+- Preparing releases or major changes
+
+### Unit Tests
+
+Unit tests are inlined with source code.
+
+**Prerequisites:**
+
+1. PostgreSQL running on localhost:5432 (with initialised `graph-test` database)
+2. IPFS running on localhost:5001
+3. PNPM
+4. Foundry (for smart contract compilation)
+5. Environment variable `THEGRAPH_STORE_POSTGRES_DIESEL_URL` set to `postgresql://graph:graph@127.0.0.1:5432/graph-test`
+
+The environment dependencies and environment setup are operated by the human.
+
+**Running Unit Tests:**
+
+```bash
+# Run unit tests
+just test-unit
+
+# Run specific tests (e.g. `data_source::common::tests`)
+just test-unit data_source::common::tests
+```
+
+**⚠️ Test Verification Requirements:**
+When filtering for specific tests, ensure the intended test name(s) appear in the output.
+
+### Runner Tests (Integration Tests)
+
+**Prerequisites:**
+
+1. PostgreSQL running on localhost:5432 (with initialised `graph-test` database)
+2. IPFS running on localhost:5001
+3. PNPM
+4. Foundry (for smart contract compilation)
+5. Environment variable `THEGRAPH_STORE_POSTGRES_DIESEL_URL` set to `postgresql://graph:graph@127.0.0.1:5432/graph-test`
+
+**Running Runner Tests:**
+
+```bash
+# Run runner tests.
+just test-runner
+
+# Run specific tests (e.g. `block_handlers`)
+just test-runner block_handlers
+```
+
+**⚠️ Test Verification Requirements:**
+When filtering for specific tests, ensure the intended test name(s) appear in the output.
+
+**Important Notes:**
+
+- Runner tests take moderate time (10-20 seconds)
+- Tests automatically reset the database between runs
+- Some tests can pass without IPFS, but tests involving file data sources require it
+
+### Integration Tests
+
+**Prerequisites:**
+
+1. PostgreSQL running on localhost:3011 (with initialised `graph-node` database)
+2. IPFS running on localhost:3001
+3. Anvil running on localhost:3021
+4. PNPM
+5. Foundry (for smart contract compilation)
+
+The environment dependencies and environment setup are operated by the human.
+
+**Running Integration Tests:**
+
+```bash
+# Run all integration tests (automatically builds graph-node and gnd)
+just test-integration
+
+# Run a specific integration test case (e.g., "grafted" test case)
+TEST_CASE=grafted just test-integration
+
+# (Optional) Use graph-cli instead of gnd for compatibility testing
+GRAPH_CLI=node_modules/.bin/graph just test-integration
+
+# Override ports if using different service ports (e.g., for local development)
+POSTGRES_TEST_PORT=5432 ETHEREUM_TEST_PORT=8545 IPFS_TEST_PORT=5001 just test-integration
+```
+
+**⚠️ Test Verification Requirements:**
+
+- **ALWAYS verify tests actually ran** - Check the output for "test result: ok. X passed" where X > 0
+- **If output shows "0 passed" or "0 tests run"**, the TEST_CASE variable or filter was wrong - fix and re-run
+- **Never trust exit code 0 alone** - Cargo can exit successfully even when no tests matched your filter
+
+**Important Notes:**
+
+- Integration tests take significant time (several minutes)
+- Tests automatically reset the database between runs
+- Logs are written to `tests/integration-tests/graph-node.log`
+- **If a test hangs for >10 minutes**, it's likely stuck - kill with `pkill -9 integration_tests` and check logs
+- CI uses the default ports (3011, 3021, 3001) - local development can override with environment variables
+
+### Code Quality
+
+```bash
+# 🚨 MANDATORY: Format all code IMMEDIATELY after any .rs file edit
+just format
+
+# 🚨 MANDATORY: Check code for warnings and errors - MUST have zero warnings
+just lint
+
+# 🚨 MANDATORY: Check in release mode to catch linking/optimization issues that cargo check misses
+just check --release
+```
+
+🚨 **CRITICAL REQUIREMENTS for ANY implementation**:
+
+- **🚨 MANDATORY**: `cargo fmt --all` MUST be run before any commit
+- **🚨 MANDATORY**: `just lint` MUST show zero warnings before any commit
+- **🚨 MANDATORY**: `cargo check --release` MUST complete successfully before any commit
+- **🚨 MANDATORY**: The unit test suite MUST pass before any commit
+
+Forgetting any of these means you failed to follow instructions. Before any commit or PR, ALL of the above MUST be satisfied! No exceptions!
+
+## High-Level Architecture
+
+### Core Components
+
+- **`graph/`**: Core abstractions, traits, and shared types
+- **`node/`**: Main executable and CLI (graphman)
+- **`chain/`**: Blockchain-specific adapters (ethereum, near, substreams)
+- **`runtime/`**: WebAssembly runtime for subgraph execution
+- **`store/`**: PostgreSQL-based storage layer
+- **`graphql/`**: GraphQL query execution engine
+- **`server/`**: HTTP/WebSocket APIs
+
+### Data Flow
+
+```
+Blockchain → Chain Adapter → Block Stream → Trigger Processing → Runtime → Store → GraphQL API
+```
+
+1. **Chain Adapters** connect to blockchain nodes and convert data to standardized formats
+2. **Block Streams** provide event-driven streaming of blockchain blocks
+3. **Trigger Processing** matches blockchain events to subgraph handlers
+4. **Runtime** executes subgraph code in WebAssembly sandbox
+5. **Store** persists entities with block-level granularity
+6. **GraphQL** processes queries and returns results
+
+### Key Abstractions
+
+- **`Blockchain`** trait: Core blockchain interface
+- **`Store`** trait: Storage abstraction with read/write variants
+- **`RuntimeHost`**: WASM execution environment
+- **`TriggerData`**: Standardized blockchain events
+- **`EventConsumer`/`EventProducer`**: Component communication
+
+### Architecture Patterns
+
+- **Event-driven**: Components communicate through async streams and channels
+- **Trait-based**: Extensive use of traits for abstraction and modularity
+- **Async/await**: Tokio-based async runtime throughout
+- **Multi-shard**: Database sharding for scalability
+- **Sandboxed execution**: WASM runtime with gas metering
+
+## Development Guidelines
+
+### Commit Convention
+
+Use format: `{crate-name}: {description}`
+
+- Single crate: `store: Support 'Or' filters`
+- Multiple crates: `core, graphql: Add event source to store`
+- All crates: `all: {description}`
+
+### Git Workflow
+
+- Rebase on master (don't merge master into feature branch)
+- Keep commits logical and atomic
+- Squash commits to clean up history before merging
+
+## Crate Structure
+
+### Core Crates
+
+- **`graph`**: Shared types, traits, and utilities
+- **`node`**: Main binary and component wiring
+- **`core`**: Business logic and subgraph management
+
+### Blockchain Integration
+
+- **`chain/ethereum`**: Ethereum chain support
+- **`chain/near`**: NEAR protocol support
+- **`chain/substreams`**: Substreams data source support
+
+### Infrastructure
+
+- **`store/postgres`**: PostgreSQL storage implementation
+- **`runtime/wasm`**: WebAssembly runtime and host functions
+- **`graphql`**: Query processing and execution
+- **`server/`**: HTTP/WebSocket servers
+
+### Key Dependencies
+
+- **`diesel`**: PostgreSQL ORM
+- **`tokio`**: Async runtime
+- **`tonic`**: gRPC framework
+- **`wasmtime`**: WebAssembly runtime
+- **`web3`**: Ethereum interaction
+
+## Test Environment Requirements
+
+### Process Compose Setup (Recommended)
+
+The repository includes a process-compose-flake setup that provides native, declarative service management.
+
+Currently, the human is required to operate the service dependencies as illustrated below.
+
+**Unit Tests:**
+
+```bash
+# Human: Start PostgreSQL + IPFS for unit tests in a separate terminal
+# PostgreSQL: localhost:5432, IPFS: localhost:5001
+nix run .#unit
+
+# Claude: Run unit tests
+just test-unit
+```
+
+**Runner Tests:**
+
+```bash
+# Human: Start PostgreSQL + IPFS for runner tests in a separate terminal
+# PostgreSQL: localhost:5432, IPFS: localhost:5001
+nix run .#unit # NOTE: Runner tests are using the same nix services stack as the unit test
+
+# Claude: Run runner tests
+just test-runner
+```
+
+**Integration Tests:**
+
+```bash
+# Human: Start all services for integration tests in a separate terminal
+# PostgreSQL: localhost:3011, IPFS: localhost:3001, Anvil: localhost:3021
+nix run .#integration
+
+# Claude: Run integration tests (automatically builds graph-node and gnd)
+just test-integration
+```
+
+**Services Configuration:**
+The services are configured to use the test suite default ports for unit- and integration tests respectively.
+
+| Service          | Unit Tests Port | Integration Tests Port | Database/Config                                 |
+| ---------------- | --------------- | ---------------------- | ----------------------------------------------- |
+| PostgreSQL       | 5432            | 3011                   | `graph-test` / `graph-node`                     |
+| IPFS             | 5001            | 3001                   | Data in `./.data/unit` or `./.data/integration` |
+| Anvil (Ethereum) | -               | 3021                   | Deterministic test chain                        |
+
+**Service Configuration:**
+The setup combines built-in services-flake services with custom multiService modules:
+
+**Built-in Services:**
+
+- **PostgreSQL**: Uses services-flake's postgres service with a helper function (`mkPostgresConfig`) that provides graph-specific defaults including required extensions.
+
+**Custom Services** (located in `./nix`):
+
+- `ipfs.nix`: IPFS (kubo) with automatic initialization and configurable ports
+- `anvil.nix`: Ethereum test chain with deterministic configuration
diff --git a/Cargo.lock b/Cargo.lock
index cf3392a9fa7..5e204e6ad4d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "Inflector"
@@ -14,5755 +14,10318 @@ dependencies = [
 
 [[package]]
 name = "addr2line"
-version = "0.15.2"
+version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7a2e47a1fbe209ee101dd6d61285226744c6c8d3c21c8dc878ba6cb9f467f3a"
+checksum = "59317f77929f0e679d39364702289274de2f0f0b22cbf50b2b8cff2169a0b27a"
 dependencies = [
- "gimli 0.24.0",
+ "gimli",
 ]
 
 [[package]]
-name = "addr2line"
-version = "0.16.0"
+name = "adler2"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e61f2b7f93d2c7d2b08263acaa4a363b3e276806c68af6134c44f523bf1aacd"
-dependencies = [
- "gimli 0.25.0",
-]
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
-name = "adler"
-version = "1.0.2"
+name = "ahash"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "const-random",
+ "getrandom 0.3.1",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
 
 [[package]]
 name = "aho-corasick"
-version = "0.7.18"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "android-tzdata"
-version = "0.1.1"
+name = "alloc-no-stdlib"
+version = "2.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
 
 [[package]]
-name = "android_system_properties"
-version = "0.1.5"
+name = "alloc-stdlib"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
 dependencies = [
- "libc",
+ "alloc-no-stdlib",
 ]
 
 [[package]]
-name = "anyhow"
-version = "1.0.75"
+name = "allocator-api2"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
-name = "arc-swap"
-version = "1.3.0"
+name = "alloy"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e906254e445520903e7fc9da4f709886c84ae4bc4ddaf0e093188d66df4dc820"
+checksum = "5e1e915a830ea2ee123c9d3886bfec3302a7ddcd73a973ab165ed45aca2e42c3"
+dependencies = [
+ "alloy-consensus",
+ "alloy-contract",
+ "alloy-core",
+ "alloy-eips",
+ "alloy-genesis",
+ "alloy-json-rpc",
+ "alloy-network",
+ "alloy-provider",
+ "alloy-pubsub",
+ "alloy-rpc-client",
+ "alloy-rpc-types",
+ "alloy-serde",
+ "alloy-signer",
+ "alloy-signer-local",
+ "alloy-transport",
+ "alloy-transport-http",
+ "alloy-transport-ipc",
+ "alloy-transport-ws",
+ "alloy-trie",
+]
 
 [[package]]
-name = "arrayref"
-version = "0.3.6"
+name = "alloy-chains"
+version = "0.2.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
+checksum = "ef3a72a2247c34a8545ee99e562b1b9b69168e5000567257ae51e91b4e6b1193"
+dependencies = [
+ "alloy-primitives",
+ "num_enum",
+ "strum 0.27.2",
+]
 
 [[package]]
-name = "arrayvec"
-version = "0.5.2"
+name = "alloy-consensus"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83447eeb17816e172f1dfc0db1f9dc0b7c5d069bd1f7cecbecceb382bf931015"
+dependencies = [
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "alloy-trie",
+ "alloy-tx-macros",
+ "arbitrary",
+ "auto_impl",
+ "borsh",
+ "c-kzg",
+ "derive_more",
+ "either",
+ "k256",
+ "once_cell",
+ "rand 0.8.6",
+ "secp256k1 0.30.0",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "alloy-consensus-any"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
+checksum = "5406343e306856dc2be762700e98a16904de45dee14a07f233e742ce68daff2f"
+dependencies = [
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "arbitrary",
+ "serde",
+]
 
 [[package]]
-name = "arrayvec"
-version = "0.7.4"
+name = "alloy-contract"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "3ae8b60d71b92824e095b4003ff01fd2bc923017b7568997c5f459240e83499c"
+dependencies = [
+ "alloy-consensus",
+ "alloy-dyn-abi",
+ "alloy-json-abi",
+ "alloy-network",
+ "alloy-network-primitives",
+ "alloy-primitives",
+ "alloy-provider",
+ "alloy-pubsub",
+ "alloy-rpc-types-eth",
+ "alloy-sol-types",
+ "alloy-transport",
+ "futures 0.3.31",
+ "futures-util",
+ "serde_json",
+ "thiserror 2.0.18",
+ "tracing",
+]
 
 [[package]]
-name = "ascii"
-version = "0.9.3"
+name = "alloy-core"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eab1c04a571841102f5345a8fc0f6bb3d31c315dec879b5c6e42e40ce7ffa34e"
+checksum = "62ddde5968de6044d67af107ad835bc0069a7ca245870b94c5958a7d8712b184"
+dependencies = [
+ "alloy-dyn-abi",
+ "alloy-json-abi",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-sol-types",
+]
 
 [[package]]
-name = "assert-json-diff"
-version = "2.0.2"
+name = "alloy-dyn-abi"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12"
+checksum = "a475bb02d9cef2dbb99065c1664ab3fe1f9352e21d6d5ed3f02cdbfc06ed1abc"
 dependencies = [
+ "alloy-json-abi",
+ "alloy-primitives",
+ "alloy-sol-type-parser",
+ "alloy-sol-types",
+ "arbitrary",
+ "itoa",
+ "proptest",
  "serde",
  "serde_json",
+ "winnow 1.0.0",
 ]
 
 [[package]]
-name = "async-recursion"
-version = "1.0.5"
+name = "alloy-eip2124"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fd55a5ba1179988837d24ab4c7cc8ed6efdeff578ede0416b4225a5fca35bd0"
+checksum = "741bdd7499908b3aa0b159bba11e71c8cddd009a2c2eb7a06e825f1ec87900a5"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.48",
+ "alloy-primitives",
+ "alloy-rlp",
+ "arbitrary",
+ "crc",
+ "rand 0.8.6",
+ "serde",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "async-stream"
-version = "0.3.5"
+name = "alloy-eip2930"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd56dd203fef61ac097dd65721a419ddccb106b2d2b70ba60a6b529f03961a51"
+checksum = "9441120fa82df73e8959ae0e4ab8ade03de2aaae61be313fbf5746277847ce25"
 dependencies = [
- "async-stream-impl",
- "futures-core",
- "pin-project-lite",
+ "alloy-primitives",
+ "alloy-rlp",
+ "arbitrary",
+ "borsh",
+ "rand 0.8.6",
+ "serde",
 ]
 
 [[package]]
-name = "async-stream-impl"
-version = "0.3.5"
+name = "alloy-eip7702"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193"
+checksum = "2919c5a56a1007492da313e7a3b6d45ef5edc5d33416fdec63c0d7a2702a0d20"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.48",
+ "alloy-primitives",
+ "alloy-rlp",
+ "arbitrary",
+ "borsh",
+ "k256",
+ "rand 0.8.6",
+ "serde",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "async-trait"
-version = "0.1.51"
+name = "alloy-eip7928"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44318e776df68115a881de9a8fd1b9e53368d7a4a5ce4cc48517da3393233a5e"
+checksum = "d3231de68d5d6e75332b7489cfcc7f4dfabeba94d990a10e4b923af0e6623540"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "alloy-primitives",
+ "alloy-rlp",
+ "arbitrary",
+ "borsh",
+ "serde",
 ]
 
 [[package]]
-name = "atomic_refcell"
-version = "0.1.13"
+name = "alloy-eips"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41e67cd8309bbd06cd603a9e693a784ac2e5d1e955f11286e355089fcab3047c"
+checksum = "0dca4c89ace90684b4b77366d00631ed498c9af962079af2a5dbc593a0618a77"
+dependencies = [
+ "alloy-eip2124",
+ "alloy-eip2930",
+ "alloy-eip7702",
+ "alloy-eip7928",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "arbitrary",
+ "auto_impl",
+ "borsh",
+ "c-kzg",
+ "derive_more",
+ "either",
+ "serde",
+ "serde_with",
+ "sha2 0.10.9",
+]
 
 [[package]]
-name = "atty"
-version = "0.2.14"
+name = "alloy-genesis"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+checksum = "ab0e0fe9e6d1120ad7bb9254c3fc2b9bc80a8df42a033fb626be6559c13d5153"
 dependencies = [
- "hermit-abi 0.1.19",
- "libc",
- "winapi",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-serde",
+ "alloy-trie",
+ "borsh",
+ "serde",
+ "serde_with",
 ]
 
 [[package]]
-name = "autocfg"
-version = "1.1.0"
+name = "alloy-json-abi"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "7c36c9d7f9021601b04bfef14a4b64849f6d73116a4e91e071d7fbfe10247901"
+dependencies = [
+ "alloy-primitives",
+ "alloy-sol-type-parser",
+ "serde",
+ "serde_json",
+]
 
 [[package]]
-name = "axum"
-version = "0.6.1"
+name = "alloy-json-rpc"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08b108ad2665fa3f6e6a517c3d80ec3e77d224c47d605167aefaa5d7ef97fa48"
+checksum = "ec0a82e56b1843bce483942d54fcadea92e676f1bde162e93c7d3b621fabc4e1"
 dependencies = [
- "async-trait",
- "axum-core",
- "bitflags 1.3.1",
- "bytes",
- "futures-util",
- "http",
- "http-body",
- "hyper",
- "itoa",
- "matchit",
- "memchr",
- "mime",
- "percent-encoding",
- "pin-project-lite",
- "rustversion",
+ "alloy-primitives",
+ "alloy-sol-types",
+ "http 1.4.2",
  "serde",
- "sync_wrapper",
- "tower 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "tower-http",
- "tower-layer 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "tower-service 0.3.1",
+ "serde_json",
+ "thiserror 2.0.18",
+ "tracing",
 ]
 
 [[package]]
-name = "axum-core"
-version = "0.3.0"
+name = "alloy-network"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79b8558f5a0581152dc94dcd289132a1d377494bdeafcd41869b3258e3e2ad92"
+checksum = "a7db7b095b0b1db1d18ce7e91dcd2e82007f2d52bfb8125e6b64633a74a06bc3"
 dependencies = [
+ "alloy-consensus",
+ "alloy-consensus-any",
+ "alloy-eips",
+ "alloy-json-rpc",
+ "alloy-network-primitives",
+ "alloy-primitives",
+ "alloy-rpc-types-any",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
+ "alloy-signer",
+ "alloy-sol-types",
  "async-trait",
- "bytes",
- "futures-util",
- "http",
- "http-body",
- "mime",
- "rustversion",
- "tower-layer 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "tower-service 0.3.1",
+ "auto_impl",
+ "derive_more",
+ "futures-utils-wasm",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "backtrace"
-version = "0.3.61"
+name = "alloy-network-primitives"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7a905d892734eea339e896738c14b9afce22b5318f64b951e70bf3844419b01"
+checksum = "cd28d9bfd11729037d194f2b1d43db8642eb3f342032691f4ca96bb745479c3c"
 dependencies = [
- "addr2line 0.16.0",
- "cc",
- "cfg-if 1.0.0",
- "libc",
- "miniz_oxide 0.4.4",
- "object 0.26.0",
- "rustc-demangle",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-serde",
+ "serde",
 ]
 
 [[package]]
-name = "base-x"
-version = "0.2.11"
+name = "alloy-primitives"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cbbc9d0964165b47557570cce6c952866c2678457aca742aafc9fb771d30270"
+checksum = "4885c1409b6936c4898e646ef58baf6ec54edaf6d8179f79df805a7b85b7cf3e"
+dependencies = [
+ "alloy-rlp",
+ "arbitrary",
+ "bytes",
+ "cfg-if",
+ "const-hex",
+ "derive_more",
+ "foldhash 0.2.0",
+ "hashbrown 0.17.0",
+ "indexmap 2.14.0",
+ "itoa",
+ "k256",
+ "keccak-asm",
+ "paste",
+ "proptest",
+ "proptest-derive 0.8.0",
+ "rand 0.9.3",
+ "rapidhash",
+ "ruint",
+ "rustc-hash",
+ "secp256k1 0.31.1",
+ "serde",
+ "sha3",
+]
 
 [[package]]
-name = "base64"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+name = "alloy-provider"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8955ab30418343de57b356de2ea60200f9fb8016a7ea3bc7f5c6176f01a8b1cf"
+dependencies = [
+ "alloy-chains",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-json-rpc",
+ "alloy-network",
+ "alloy-network-primitives",
+ "alloy-primitives",
+ "alloy-pubsub",
+ "alloy-rpc-client",
+ "alloy-rpc-types-anvil",
+ "alloy-rpc-types-debug",
+ "alloy-rpc-types-eth",
+ "alloy-rpc-types-trace",
+ "alloy-rpc-types-txpool",
+ "alloy-signer",
+ "alloy-sol-types",
+ "alloy-transport",
+ "alloy-transport-http",
+ "alloy-transport-ipc",
+ "alloy-transport-ws",
+ "async-stream",
+ "async-trait",
+ "auto_impl",
+ "dashmap",
+ "either",
+ "futures 0.3.31",
+ "futures-utils-wasm",
+ "lru",
+ "parking_lot",
+ "pin-project",
+ "reqwest 0.13.2",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "url",
+ "wasmtimer",
+]
 
 [[package]]
-name = "base64"
-version = "0.20.0"
+name = "alloy-pubsub"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ea22880d78093b0cbe17c89f64a7d457941e65759157ec6cb31a31d652b05e5"
+checksum = "7cd85cfea1fa8ebd20d3475e961fe3a3624c0eb4659ea137715c0c83c8aeaff0"
+dependencies = [
+ "alloy-json-rpc",
+ "alloy-primitives",
+ "alloy-transport",
+ "auto_impl",
+ "bimap",
+ "futures 0.3.31",
+ "parking_lot",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-stream",
+ "tower 0.5.2",
+ "tracing",
+ "wasmtimer",
+]
 
 [[package]]
-name = "base64"
-version = "0.21.0"
+name = "alloy-rlp"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
+checksum = "5f70d83b765fdc080dbcd4f4db70d8d23fe4761f2f02ebfa9146b833900634b4"
+dependencies = [
+ "alloy-rlp-derive",
+ "arrayvec",
+ "bytes",
+]
 
 [[package]]
-name = "base64-url"
-version = "2.0.2"
+name = "alloy-rlp-derive"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb9fb9fb058cc3063b5fc88d9a21eefa2735871498a04e1650da76ed511c8569"
+checksum = "64b728d511962dda67c1bc7ea7c03736ec275ed2cf4c35d9585298ac9ccf3b73"
 dependencies = [
- "base64 0.21.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "beef"
-version = "0.5.2"
+name = "alloy-rpc-client"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
+checksum = "24f461f091dc8f657e73b5dea18fd63d5c7049720cd252f1eade4a7ebed6a7e1"
 dependencies = [
+ "alloy-json-rpc",
+ "alloy-primitives",
+ "alloy-pubsub",
+ "alloy-transport",
+ "alloy-transport-http",
+ "alloy-transport-ipc",
+ "alloy-transport-ws",
+ "futures 0.3.31",
+ "pin-project",
+ "reqwest 0.13.2",
  "serde",
+ "serde_json",
+ "tokio",
+ "tokio-stream",
+ "tower 0.5.2",
+ "tracing",
+ "url",
+ "wasmtimer",
 ]
 
 [[package]]
-name = "bigdecimal"
-version = "0.1.2"
+name = "alloy-rpc-types"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1374191e2dd25f9ae02e3aa95041ed5d747fc77b3c102b49fe2dd9a8117a6244"
+checksum = "052c031d1f7c5611997056bbcb8814e5cbf20f7efeee8c3de690555172038cf2"
 dependencies = [
- "num-bigint 0.2.6",
- "num-integer",
- "num-traits",
+ "alloy-primitives",
+ "alloy-rpc-types-anvil",
+ "alloy-rpc-types-debug",
+ "alloy-rpc-types-engine",
+ "alloy-rpc-types-eth",
+ "alloy-rpc-types-trace",
+ "alloy-rpc-types-txpool",
+ "alloy-serde",
  "serde",
 ]
 
 [[package]]
-name = "bigdecimal"
-version = "0.3.1"
+name = "alloy-rpc-types-anvil"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6773ddc0eafc0e509fb60e48dff7f450f8e674a0686ae8605e8d9901bd5eefa"
+checksum = "2ff111a54268dc0bbd3b17f98571a7e27cc661dc081ad2999d91888647eb2e11"
 dependencies = [
- "num-bigint 0.4.4",
- "num-integer",
- "num-traits",
+ "alloy-primitives",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
+ "serde",
 ]
 
 [[package]]
-name = "bincode"
-version = "1.3.3"
+name = "alloy-rpc-types-any"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+checksum = "0a6561ed4759c974d9c144500a59e3fb8c1d87327a12900d5ce455c0cae6dcb6"
 dependencies = [
+ "alloy-consensus-any",
+ "alloy-network-primitives",
+ "alloy-primitives",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
  "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "bitflags"
-version = "1.3.1"
+name = "alloy-rpc-types-debug"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2da1976d75adbe5fbc88130ecd119529cf1cc6a93ae1546d8696ee66f0d21af1"
+checksum = "48b9ad6eee93dd35a9ec0a6c1c6b180892a900ee17a6ed6500921552dd71e846"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "derive_more",
+ "serde",
+ "serde_with",
+]
 
 [[package]]
-name = "bitflags"
-version = "2.4.0"
+name = "alloy-rpc-types-engine"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
+checksum = "7eba59e1c069f168a01982f42a57797736923b76aa854194df4930be17867e1c"
+dependencies = [
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "arbitrary",
+ "derive_more",
+ "rand 0.8.6",
+ "serde",
+ "strum 0.27.2",
+]
 
 [[package]]
-name = "bitvec"
-version = "1.0.0"
+name = "alloy-rpc-types-eth"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1489fcb93a5bb47da0462ca93ad252ad6af2145cce58d10d46a83931ba9f016b"
+checksum = "175a2a5b6017d7f61b5e4b800d21215fe8e94fe729d00828e13bb6d93dcf3492"
 dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
+ "alloy-consensus",
+ "alloy-consensus-any",
+ "alloy-eips",
+ "alloy-network-primitives",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "alloy-sol-types",
+ "arbitrary",
+ "itertools 0.13.0",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "blake3"
-version = "0.3.8"
+name = "alloy-rpc-types-trace"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b64485778c4f16a6a5a9d335e80d449ac6c70cdd6a06d2af18a6f6f775a125b3"
+checksum = "514b4b1ce3354f65067b4fc7eb75358e0f2ec8be3340c96dea65d6894f9ca435"
 dependencies = [
- "arrayref",
- "arrayvec 0.5.2",
- "cc",
- "cfg-if 0.1.10",
- "constant_time_eq 0.1.5",
- "crypto-mac 0.8.0",
- "digest 0.9.0",
+ "alloy-primitives",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "blake3"
-version = "1.5.0"
+name = "alloy-rpc-types-txpool"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0231f06152bf547e9c2b5194f247cd97aacf6dcd8b15d8e5ec0663f64580da87"
+checksum = "76e34a42ebb4a71ab0bfdebc6d2f3c7bf809f01edf154d08fed159d10d1ef1d4"
 dependencies = [
- "arrayref",
- "arrayvec 0.7.4",
- "cc",
- "cfg-if 1.0.0",
- "constant_time_eq 0.3.0",
+ "alloy-primitives",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
+ "serde",
 ]
 
 [[package]]
-name = "block-buffer"
-version = "0.9.0"
+name = "alloy-serde"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
+checksum = "cc21a8772af7d78bba286726aa245bd2ff81cd9abe230afea2e91578996831c9"
 dependencies = [
- "generic-array",
+ "alloy-primitives",
+ "arbitrary",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "block-buffer"
-version = "0.10.2"
+name = "alloy-signer"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bf7fe51849ea569fd452f37822f606a5cabb684dc918707a0193fd4664ff324"
+checksum = "8ffbce94c50dd9d4d1f83e044c5595bbd3ada981bd3057ce28b3a5470e77385d"
 dependencies = [
- "generic-array",
+ "alloy-primitives",
+ "async-trait",
+ "auto_impl",
+ "either",
+ "elliptic-curve",
+ "k256",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "bs58"
-version = "0.4.0"
+name = "alloy-signer-local"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
+checksum = "e48366d2c42b8d95ef951101bafa28486590f21b7a1e68b6b2d069746557bbe3"
+dependencies = [
+ "alloy-consensus",
+ "alloy-network",
+ "alloy-primitives",
+ "alloy-signer",
+ "async-trait",
+ "k256",
+ "rand 0.8.6",
+ "thiserror 2.0.18",
+]
 
 [[package]]
-name = "bstr"
-version = "0.2.16"
+name = "alloy-sol-macro"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90682c8d613ad3373e66de8c6411e0ae2ab2571e879d2efbf73558cc66f21279"
+checksum = "840128ed2b2971d6d4668a553fe403a82683d3acc646c73e75887e7157408033"
 dependencies = [
- "memchr",
+ "alloy-sol-macro-expander",
+ "alloy-sol-macro-input",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "bumpalo"
-version = "3.12.0"
+name = "alloy-sol-macro-expander"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
+checksum = "63ec265e5d65d725175f6ca7711c970824c90ef9c0d1f1973711d4150ee612dd"
+dependencies = [
+ "alloy-json-abi",
+ "alloy-sol-macro-input",
+ "const-hex",
+ "heck 0.5.0",
+ "indexmap 2.14.0",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "sha3",
+ "syn 2.0.118",
+ "syn-solidity",
+]
 
 [[package]]
-name = "byte-slice-cast"
-version = "1.2.0"
+name = "alloy-sol-macro-input"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d30c751592b77c499e7bce34d99d67c2c11bdc0574e9a488ddade14150a4698"
+checksum = "89bf01077f18650876cfa682eb1f949967b5cde03f1a51c955c469d2c9b4aa67"
+dependencies = [
+ "alloy-json-abi",
+ "const-hex",
+ "dunce",
+ "heck 0.5.0",
+ "macro-string",
+ "proc-macro2",
+ "quote",
+ "serde_json",
+ "syn 2.0.118",
+ "syn-solidity",
+]
 
 [[package]]
-name = "byteorder"
-version = "1.4.3"
+name = "alloy-sol-type-parser"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "857b470ecdd2ed38beaf82ad1a38c516a8ff75266750f38b9eeed001d575241b"
+dependencies = [
+ "serde",
+ "winnow 1.0.0",
+]
 
 [[package]]
-name = "bytes"
-version = "1.2.1"
+name = "alloy-sol-types"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec8a7b6a70fde80372154c65702f00a0f56f3e1c36abbc6c440484be248856db"
+checksum = "384cf252de0db2dec52821eac037a7f57e2aa33fe5b900ce6fe39973402341f1"
+dependencies = [
+ "alloy-json-abi",
+ "alloy-primitives",
+ "alloy-sol-macro",
+ "serde",
+]
 
 [[package]]
-name = "cc"
-version = "1.0.69"
+name = "alloy-transport"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
+checksum = "86052fdcec72d37ca4aa4b66254601e7453c45a6e1c70aa4561033d002fb80cc"
 dependencies = [
- "jobserver",
+ "alloy-json-rpc",
+ "auto_impl",
+ "base64",
+ "derive_more",
+ "futures 0.3.31",
+ "futures-utils-wasm",
+ "parking_lot",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+ "tokio",
+ "tower 0.5.2",
+ "tracing",
+ "url",
+ "wasmtimer",
 ]
 
 [[package]]
-name = "cfg-if"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
+name = "alloy-transport-http"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "b273587487921274f4f5d0ef2c7ef36944dcbb75a4e2318e69eae822bd263f91"
+dependencies = [
+ "alloy-json-rpc",
+ "alloy-transport",
+ "itertools 0.13.0",
+ "reqwest 0.13.2",
+ "serde_json",
+ "tower 0.5.2",
+ "tracing",
+ "url",
+]
 
 [[package]]
-name = "chrono"
-version = "0.4.31"
+name = "alloy-transport-ipc"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38"
+checksum = "bfb89df168b24773ef603af14f2449c05a7d3f27d05d3eceaea6bf96cccae168"
 dependencies = [
- "android-tzdata",
- "iana-time-zone",
- "js-sys",
- "num-traits",
- "wasm-bindgen",
- "windows-targets 0.48.0",
+ "alloy-json-rpc",
+ "alloy-pubsub",
+ "alloy-transport",
+ "bytes",
+ "futures 0.3.31",
+ "interprocess",
+ "pin-project",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-util",
+ "tracing",
 ]
 
 [[package]]
-name = "cid"
-version = "0.11.0"
+name = "alloy-transport-ws"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "472ac98592f38dfd48f188d5713a328422ed22fa39eb52b8bca495370134762a"
+checksum = "33e32e0b47d3b3bf5770b7c132090c614b008d307c5e1544f1925f5b7e9e9af6"
 dependencies = [
- "core2",
- "multibase",
- "multihash 0.19.1",
- "unsigned-varint 0.8.0",
+ "alloy-pubsub",
+ "alloy-transport",
+ "futures 0.3.31",
+ "http 1.4.2",
+ "rustls",
+ "serde_json",
+ "tokio",
+ "tokio-tungstenite 0.28.0",
+ "tracing",
+ "url",
+ "ws_stream_wasm",
 ]
 
 [[package]]
-name = "clap"
-version = "3.2.25"
+name = "alloy-trie"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ea181bf566f71cb9a5d17a59e1871af638180a18fb0035c92ae62b705207123"
+checksum = "428aa0f0e0658ff091f8f667c406e034b431cb10abd39de4f507520968acc499"
 dependencies = [
- "atty",
- "bitflags 1.3.1",
- "clap_derive",
- "clap_lex",
- "indexmap 1.9.3",
- "once_cell",
- "strsim",
- "termcolor",
- "textwrap",
+ "alloy-primitives",
+ "alloy-rlp",
+ "arbitrary",
+ "arrayvec",
+ "derive_arbitrary",
+ "derive_more",
+ "nybbles",
+ "proptest",
+ "proptest-derive 0.5.1",
+ "serde",
+ "smallvec",
+ "tracing",
 ]
 
 [[package]]
-name = "clap_derive"
-version = "3.2.25"
+name = "alloy-tx-macros"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae6371b8bdc8b7d3959e9cf7b22d4435ef3e79e138688421ec654acf8c81b008"
+checksum = "01a0035943b75fe1e249f52e688492d7a1b1826bc2d19b8e1d5d3c24a2ad8f50"
 dependencies = [
- "heck",
- "proc-macro-error",
+ "darling 0.23.0",
  "proc-macro2",
  "quote",
- "syn 1.0.107",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "clap_lex"
-version = "0.2.2"
+name = "android_system_properties"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5538cd660450ebeb4234cfecf8f2284b844ffc4c50531e66d584ad5b91293613"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
 dependencies = [
- "os_str_bytes",
+ "libc",
 ]
 
 [[package]]
-name = "combine"
-version = "3.8.1"
+name = "anstream"
+version = "0.6.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da3da6baa321ec19e1cc41d31bf599f00c783d0517095cdaf0332e3fe8d20680"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
 dependencies = [
- "ascii",
- "byteorder",
- "either",
- "memchr",
- "unreachable",
+ "anstyle",
+ "anstyle-parse 0.2.4",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
 ]
 
 [[package]]
-name = "common-multipart-rfc7578"
-version = "0.6.0"
+name = "anstream"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5baee326bc603965b0f26583e1ecd7c111c41b49bd92a344897476a352798869"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
 dependencies = [
- "bytes",
- "futures-core",
- "futures-util",
- "http",
- "mime",
- "mime_guess",
- "rand",
- "thiserror",
+ "anstyle",
+ "anstyle-parse 1.0.0",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
 ]
 
 [[package]]
-name = "console"
-version = "0.13.0"
+name = "anstyle"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a50aab2529019abfabfa93f1e6c41ef392f91fbf179b347a7e96abb524884a08"
-dependencies = [
- "encode_unicode",
- "lazy_static",
- "libc",
- "regex",
- "terminal_size",
- "unicode-width",
- "winapi",
- "winapi-util",
-]
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
 
 [[package]]
-name = "constant_time_eq"
-version = "0.1.5"
+name = "anstyle-parse"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
+checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
+dependencies = [
+ "utf8parse",
+]
 
 [[package]]
-name = "constant_time_eq"
-version = "0.3.0"
+name = "anstyle-parse"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
 
 [[package]]
-name = "convert_case"
-version = "0.4.0"
+name = "anstyle-query"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391"
+dependencies = [
+ "windows-sys 0.52.0",
+]
 
 [[package]]
-name = "core-foundation"
-version = "0.9.1"
+name = "anstyle-wincon"
+version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a89e2ae426ea83155dccf10c0fa6b1463ef6d5fcb44cee0b224a408fa640a62"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
- "core-foundation-sys",
- "libc",
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
-name = "core-foundation-sys"
-version = "0.8.3"
+name = "anyhow"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+checksum = "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3"
 
 [[package]]
-name = "core2"
-version = "0.4.0"
+name = "arbitrary"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
 dependencies = [
- "memchr",
+ "derive_arbitrary",
 ]
 
 [[package]]
-name = "cpp_demangle"
-version = "0.3.3"
+name = "arc-swap"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ea47428dc9d2237f3c6bc134472edfd63ebba0af932e783506dcfd66f10d18a"
+checksum = "6a3a1fd6f75306b68087b831f025c712524bcb19aad54e557b1129cfa0a2b207"
 dependencies = [
- "cfg-if 1.0.0",
+ "rustversion",
 ]
 
 [[package]]
-name = "cpufeatures"
-version = "0.1.5"
+name = "arcstr"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"
+
+[[package]]
+name = "ark-ff"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66c99696f6c9dd7f35d486b9d04d7e6e202aa3e8c40d553f2fdf5e7e0c6a71ef"
+checksum = "6b3235cc41ee7a12aaaf2c575a2ad7b46713a8a50bda2fc3b003a04845c05dd6"
 dependencies = [
- "libc",
+ "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 0.4.6",
+ "num-traits",
+ "paste",
+ "rustc_version 0.3.3",
+ "zeroize",
 ]
 
 [[package]]
-name = "cpufeatures"
-version = "0.2.2"
+name = "ark-ff"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59a6001667ab124aebae2a495118e11d30984c3a653e99d86d58971708cf5e4b"
+checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba"
 dependencies = [
- "libc",
+ "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 0.4.6",
+ "num-traits",
+ "paste",
+ "rustc_version 0.4.0",
+ "zeroize",
 ]
 
 [[package]]
-name = "cranelift-bforest"
-version = "0.74.0"
+name = "ark-ff"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8ca3560686e7c9c7ed7e0fe77469f2410ba5d7781b1acaa9adc8d8deea28e3e"
+checksum = "a177aba0ed1e0fbb62aa9f6d0502e9b46dad8c2eab04c14258a1212d2557ea70"
 dependencies = [
- "cranelift-entity",
+ "ark-ff-asm 0.5.0",
+ "ark-ff-macros 0.5.0",
+ "ark-serialize 0.5.0",
+ "ark-std 0.5.0",
+ "arrayvec",
+ "digest 0.10.7",
+ "educe",
+ "itertools 0.13.0",
+ "num-bigint 0.4.6",
+ "num-traits",
+ "paste",
+ "zeroize",
 ]
 
 [[package]]
-name = "cranelift-codegen"
-version = "0.74.0"
+name = "ark-ff-asm"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf9bf1ffffb6ce3d2e5ebc83549bd2436426c99b31cc550d521364cbe35d276"
+checksum = "db02d390bf6643fb404d3d22d31aee1c4bc4459600aef9113833d17e786c6e44"
 dependencies = [
- "cranelift-bforest",
- "cranelift-codegen-meta",
- "cranelift-codegen-shared",
- "cranelift-entity",
- "gimli 0.24.0",
- "log",
- "regalloc",
- "serde",
- "smallvec",
- "target-lexicon",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
-name = "cranelift-codegen-meta"
-version = "0.74.0"
+name = "ark-ff-asm"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cc21936a5a6d07e23849ffe83e5c1f6f50305c074f4b2970ca50c13bf55b821"
+checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348"
 dependencies = [
- "cranelift-codegen-shared",
- "cranelift-entity",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
-name = "cranelift-codegen-shared"
-version = "0.74.0"
+name = "ark-ff-asm"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca5b6ffaa87560bebe69a5446449da18090b126037920b0c1c6d5945f72faf6b"
+checksum = "62945a2f7e6de02a31fe400aa489f0e0f5b2502e69f95f853adb82a96c7a6b60"
 dependencies = [
- "serde",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "cranelift-entity"
-version = "0.74.0"
+name = "ark-ff-macros"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d6b4a8bef04f82e4296782646f733c641d09497df2fabf791323fefaa44c64c"
+checksum = "db2fd794a08ccb318058009eefdf15bcaaaaf6f8161eb3345f907222bac38b20"
 dependencies = [
- "serde",
+ "num-bigint 0.4.6",
+ "num-traits",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
-name = "cranelift-frontend"
-version = "0.74.0"
+name = "ark-ff-macros"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c31b783b351f966fce33e3c03498cb116d16d97a8f9978164a60920bd0d3a99c"
+checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565"
 dependencies = [
- "cranelift-codegen",
- "log",
- "smallvec",
- "target-lexicon",
+ "num-bigint 0.4.6",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
-name = "cranelift-native"
-version = "0.74.0"
+name = "ark-ff-macros"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a77c88d3dd48021ff1e37e978a00098524abd3513444ae252c08d37b310b3d2a"
+checksum = "09be120733ee33f7693ceaa202ca41accd5653b779563608f1234f78ae07c4b3"
 dependencies = [
- "cranelift-codegen",
- "target-lexicon",
+ "num-bigint 0.4.6",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "cranelift-wasm"
-version = "0.74.0"
+name = "ark-serialize"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edb6d408e2da77cdbbd65466298d44c86ae71c1785d2ab0d8657753cdb4d9d89"
+checksum = "1d6c2b318ee6e10f8c2853e73a83adc0ccb88995aa978d8a3408d492ab2ee671"
 dependencies = [
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-frontend",
- "itertools 0.10.5",
- "log",
- "serde",
- "smallvec",
- "thiserror",
- "wasmparser",
+ "ark-std 0.3.0",
+ "digest 0.9.0",
 ]
 
 [[package]]
-name = "crc32fast"
-version = "1.2.1"
+name = "ark-serialize"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81156fece84ab6a9f2afdb109ce3ae577e42b1228441eded99bd77f627953b1a"
+checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5"
 dependencies = [
- "cfg-if 1.0.0",
+ "ark-std 0.4.0",
+ "digest 0.10.7",
+ "num-bigint 0.4.6",
 ]
 
 [[package]]
-name = "crossbeam"
-version = "0.8.2"
+name = "ark-serialize"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2801af0d36612ae591caa9568261fddce32ce6e08a7275ea334a06a4ad021a2c"
+checksum = "3f4d068aaf107ebcd7dfb52bc748f8030e0fc930ac8e360146ca54c1203088f7"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-epoch",
- "crossbeam-queue",
- "crossbeam-utils",
+ "ark-std 0.5.0",
+ "arrayvec",
+ "digest 0.10.7",
+ "num-bigint 0.4.6",
 ]
 
 [[package]]
-name = "crossbeam-channel"
-version = "0.5.7"
+name = "ark-std"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf2b3e8478797446514c91ef04bafcb59faba183e621ad488df88983cc14128c"
+checksum = "1df2c09229cbc5a028b1d70e00fdb2acee28b1055dfb5ca73eea49c5a25c4e7c"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
+ "num-traits",
+ "rand 0.8.6",
 ]
 
 [[package]]
-name = "crossbeam-deque"
-version = "0.8.1"
+name = "ark-std"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
+checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-epoch",
- "crossbeam-utils",
+ "num-traits",
+ "rand 0.8.6",
 ]
 
 [[package]]
-name = "crossbeam-epoch"
-version = "0.9.5"
+name = "ark-std"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
+checksum = "246a225cc6131e9ee4f24619af0f19d67761fff15d7ccc22e42b80846e69449a"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
- "lazy_static",
- "memoffset",
- "scopeguard",
+ "num-traits",
+ "rand 0.8.6",
 ]
 
 [[package]]
-name = "crossbeam-queue"
-version = "0.3.2"
+name = "arrayvec"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b10ddc024425c88c2ad148c1b0fd53f4c6d38db9697c9f1588381212fa657c9"
+checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
+ "serde",
 ]
 
 [[package]]
-name = "crossbeam-utils"
-version = "0.8.8"
+name = "arrow"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bf124c720b7686e3c2663cf54062ab0f68a88af2fb6a030e87e30bf721fcb38"
+checksum = "ffaaa3e009861fd829d0a24dd6f115aa8e4634324bb092147d43baafe69ca4a7"
 dependencies = [
- "cfg-if 1.0.0",
- "lazy_static",
+ "arrow-arith",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-csv",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-json",
+ "arrow-ord",
+ "arrow-row",
+ "arrow-schema",
+ "arrow-select",
+ "arrow-string",
 ]
 
 [[package]]
-name = "crunchy"
-version = "0.2.2"
+name = "arrow-arith"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+checksum = "3ac95125e1d71c4a252b5a9c729aef111e80418f08aaa6dbabd1ba66918247fc"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "num-traits",
+]
 
 [[package]]
-name = "crypto-common"
-version = "0.1.3"
+name = "arrow-array"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8"
+checksum = "0c60c79628e9a97cb90d7a0dc3e944f216a902f837d4ecabc14d524bddbbc137"
 dependencies = [
- "generic-array",
- "typenum",
+ "ahash",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "hashbrown 0.17.0",
+ "num-complex",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
-name = "crypto-mac"
-version = "0.8.0"
+name = "arrow-buffer"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b584a330336237c1eecd3e94266efb216c56ed91225d634cb2991c5f3fd1aeab"
+checksum = "6026f638c400e9878c1b1cc05c3cfd46fbf381285916ab408678701c1df46c1a"
 dependencies = [
- "generic-array",
- "subtle",
+ "bytes",
+ "half",
+ "num-bigint 0.4.6",
+ "num-traits",
 ]
 
 [[package]]
-name = "crypto-mac"
-version = "0.10.1"
+name = "arrow-cast"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff07008ec701e8028e2ceb8f83f0e4274ee62bd2dbdc4fefff2e9a91824081a"
+checksum = "c82c236c3caf8df5664284f3f1fbe89938852163998c3fdbf37e84ac220445e9"
 dependencies = [
- "generic-array",
- "subtle",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
+ "atoi",
+ "base64",
+ "chrono",
+ "half",
+ "lexical-core",
+ "num-traits",
+ "ryu",
 ]
 
 [[package]]
-name = "data-encoding"
-version = "2.3.2"
+name = "arrow-csv"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ee2393c4a91429dffb4bedf19f4d6abf27d8a732c8ce4980305d782e5426d57"
+checksum = "12714e5fb7954159af1e26d4e0d37108bcf1a2ad5ee5c5bf02a944d564d588b7"
+dependencies = [
+ "arrow-array",
+ "arrow-cast",
+ "arrow-schema",
+ "chrono",
+ "csv",
+ "csv-core",
+ "regex",
+]
 
 [[package]]
-name = "data-encoding-macro"
-version = "0.1.12"
+name = "arrow-data"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86927b7cd2fe88fa698b87404b287ab98d1a0063a34071d92e575b72d3029aca"
+checksum = "7bd568aa70c4ec5947027b0d5caee94877433b661a0bb9e8ddceeeb5f0c9b1ab"
 dependencies = [
- "data-encoding",
- "data-encoding-macro-internal",
+ "arrow-buffer",
+ "arrow-schema",
+ "half",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
-name = "data-encoding-macro-internal"
-version = "0.1.10"
+name = "arrow-flight"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5bbed42daaa95e780b60a50546aa345b8413a1e46f9a40a12907d3598f038db"
+checksum = "68365401e834743d708094927e2ca727a32d639fe900df04b936e07a36701b74"
 dependencies = [
- "data-encoding",
- "syn 1.0.107",
+ "arrow-arith",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-ord",
+ "arrow-row",
+ "arrow-schema",
+ "arrow-select",
+ "arrow-string",
+ "base64",
+ "bytes",
+ "futures 0.3.31",
+ "once_cell",
+ "paste",
+ "prost",
+ "prost-types",
+ "tonic",
+ "tonic-prost",
 ]
 
 [[package]]
-name = "defer"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "647605a6345d5e89c3950a36a638c56478af9b414c55c6f2477c73b115f9acde"
-
-[[package]]
-name = "derive_more"
-version = "0.99.17"
+name = "arrow-ipc"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
+checksum = "e57ee4d470eab1a021bc4b63fa2b2c15d572892bf227b0a982d3b755a6c662b5"
 dependencies = [
- "convert_case",
- "proc-macro2",
- "quote",
- "rustc_version",
- "syn 1.0.107",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+ "flatbuffers",
 ]
 
 [[package]]
-name = "diesel"
-version = "1.4.8"
+name = "arrow-json"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b28135ecf6b7d446b43e27e225622a038cc4e2930a1022f51cdb97ada19b8e4d"
+checksum = "38f47e0e7a284e1f3707a780dc8cd5451b1614e9e398ea2d9ca03c7a2fe9a9ed"
 dependencies = [
- "bigdecimal 0.1.2",
- "bitflags 1.3.1",
- "byteorder",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
  "chrono",
- "diesel_derives",
- "num-bigint 0.2.6",
- "num-integer",
+ "half",
+ "indexmap 2.14.0",
+ "itoa",
+ "lexical-core",
+ "memchr",
  "num-traits",
- "pq-sys",
- "r2d2",
+ "ryu",
+ "serde_core",
  "serde_json",
+ "simdutf8",
 ]
 
 [[package]]
-name = "diesel-derive-enum"
-version = "1.1.2"
+name = "arrow-ord"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8910921b014e2af16298f006de12aa08af894b71f0f49a486ab6d74b17bbed"
+checksum = "a79cf73ad2eba8686ec2aa9bbf8671208e509025f166afc040cedbd94ffe4983"
 dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
 ]
 
 [[package]]
-name = "diesel-dynamic-schema"
-version = "1.0.0"
-source = "git+https://github.com/diesel-rs/diesel-dynamic-schema?rev=a8ec4fb1#a8ec4fb11de6242488ba3698d74406f4b5073dc4"
+name = "arrow-row"
+version = "59.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cea0f7d8ed6182f14952761e2c0f989852d5aa334fcbc49f73a9f2247c25b879"
 dependencies = [
- "diesel",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "half",
 ]
 
 [[package]]
-name = "diesel_derives"
-version = "1.4.1"
+name = "arrow-schema"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45f5098f628d02a7a0f68ddba586fb61e80edec3bdc1be3b921f4ceec60858d3"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
+checksum = "80b3e786a0dd9103acd583a6fb486dbf2f3268466cc0bd571dcf34cef231c1f1"
 
 [[package]]
-name = "diesel_migrations"
-version = "1.4.0"
+name = "arrow-select"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf3cde8413353dc7f5d72fa8ce0b99a560a359d2c5ef1e5817ca731cd9008f4c"
+checksum = "067a67e0361f6c31f4a7248759f36ca4ca71b187a941ed4d49da1c7d3d4db624"
 dependencies = [
- "migrations_internals",
- "migrations_macros",
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "num-traits",
 ]
 
 [[package]]
-name = "diff"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
-
-[[package]]
-name = "difflib"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
-
-[[package]]
-name = "digest"
-version = "0.9.0"
+name = "arrow-string"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+checksum = "99bc95847f3ff62a2b03d6f8ce2e3e78f01362060549a2a311898dd442f6256d"
 dependencies = [
- "generic-array",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+ "memchr",
+ "num-traits",
+ "regex",
+ "regex-syntax",
 ]
 
 [[package]]
-name = "digest"
-version = "0.10.7"
+name = "ascii_utils"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer 0.10.2",
- "crypto-common",
-]
+checksum = "71938f30533e4d95a6d17aa530939da3842c2ab6f4f84b9dae68447e4129f74a"
 
 [[package]]
-name = "directories-next"
-version = "2.0.0"
+name = "assert-json-diff"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "339ee130d97a610ea5a5872d2bbb130fdf68884ff09d3028b81bec8a1ac23bbc"
+checksum = "47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12"
 dependencies = [
- "cfg-if 1.0.0",
- "dirs-sys-next",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "dirs"
-version = "4.0.0"
+name = "async-compression"
+version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
+checksum = "ddb939d66e4ae03cee6091612804ba446b12878410cfa17f785f4dd67d4014e8"
 dependencies = [
- "dirs-sys",
+ "brotli",
+ "flate2",
+ "futures-core",
+ "memchr",
+ "pin-project-lite",
+ "tokio",
 ]
 
 [[package]]
-name = "dirs-next"
-version = "2.0.0"
+name = "async-graphql"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+checksum = "1057a9f7ccf2404d94571dec3451ade1cb524790df6f1ada0d19c2a49f6b0f40"
 dependencies = [
- "cfg-if 1.0.0",
- "dirs-sys-next",
+ "async-graphql-derive",
+ "async-graphql-parser",
+ "async-graphql-value",
+ "async-io",
+ "async-trait",
+ "asynk-strim",
+ "base64",
+ "bytes",
+ "chrono",
+ "fast_chemail",
+ "fnv",
+ "futures-util",
+ "handlebars",
+ "http 1.4.2",
+ "indexmap 2.14.0",
+ "mime",
+ "multer",
+ "num-traits",
+ "pin-project-lite",
+ "regex",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "static_assertions_next",
+ "tempfile",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "dirs-sys"
-version = "0.3.7"
+name = "async-graphql-axum"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
+checksum = "a1e37c5532e4b686acf45e7162bc93da91fc2c702fb0d465efc2c20c8f973795"
 dependencies = [
- "libc",
- "redox_users",
- "winapi",
+ "async-graphql",
+ "axum",
+ "bytes",
+ "futures-util",
+ "serde_json",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
-name = "dirs-sys-next"
-version = "0.1.2"
+name = "async-graphql-derive"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+checksum = "2e6cbeadc8515e66450fba0985ce722192e28443697799988265d86304d7cc68"
 dependencies = [
- "libc",
- "redox_users",
- "winapi",
+ "Inflector",
+ "async-graphql-parser",
+ "darling 0.23.0",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "strum 0.27.2",
+ "syn 2.0.118",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "either"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
-
-[[package]]
-name = "encode_unicode"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
-
-[[package]]
-name = "encoding_rs"
-version = "0.8.28"
+name = "async-graphql-parser"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80df024fbc5ac80f87dfef0d9f5209a252f2a497f7f42944cff24d8253cac065"
+checksum = "e64ef70f77a1c689111e52076da1cd18f91834bcb847de0a9171f83624b07fbf"
 dependencies = [
- "cfg-if 1.0.0",
+ "async-graphql-value",
+ "pest",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "env_logger"
-version = "0.7.1"
+name = "async-graphql-value"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+checksum = "3e3ef112905abea9dea592fc868a6873b10ebd3f983e83308f995d6284e9ba41"
 dependencies = [
- "atty",
- "humantime 1.3.0",
- "log",
- "regex",
- "termcolor",
+ "bytes",
+ "indexmap 2.14.0",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "env_logger"
-version = "0.10.1"
+name = "async-io"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95b3f3e67048839cb0d0781f445682a35113da7121f7c949db0e2be96a4fbece"
+checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
 dependencies = [
- "humantime 2.1.0",
- "is-terminal",
- "log",
- "regex",
- "termcolor",
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite",
+ "parking",
+ "polling",
+ "rustix 1.1.4",
+ "slab",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "envconfig"
-version = "0.10.0"
+name = "async-lock"
+version = "3.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea81cc7e21f55a9d9b1efb6816904978d0bfbe31a50347cb24b2e75564bcac9b"
+checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
 dependencies = [
- "envconfig_derive",
+ "event-listener",
+ "event-listener-strategy",
+ "pin-project-lite",
 ]
 
 [[package]]
-name = "envconfig_derive"
-version = "0.10.0"
+name = "async-recursion"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dfca278e5f84b45519acaaff758ebfa01f18e96998bc24b8f1b722dd804b9bf"
+checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.107",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "equivalent"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88bffebc5d80432c9b140ee17875ff173a8ab62faad5b257da912bd2f6c1c0a1"
-
-[[package]]
-name = "errno"
-version = "0.2.7"
+name = "async-stream"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa68f2fb9cae9d37c9b2b3584aba698a2e97f72d7aef7b9f7aa71d8b54ce46fe"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
 dependencies = [
- "errno-dragonfly",
- "libc",
- "winapi",
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
 ]
 
 [[package]]
-name = "errno"
-version = "0.3.0"
+name = "async-stream-impl"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d6a0976c999d473fe89ad888d5a284e55366d9dc9038b1ba2aa15128c4afa0"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
 dependencies = [
- "errno-dragonfly",
- "libc",
- "windows-sys 0.45.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "errno-dragonfly"
-version = "0.1.1"
+name = "async-trait"
+version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14ca354e36190500e1e1fb267c647932382b54053c50b14970856c0b00a35067"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
- "gcc",
- "libc",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "ethabi"
-version = "17.2.0"
+name = "async_io_stream"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4966fba78396ff92db3b817ee71143eccd98acf0f876b8d600e585a670c5d1b"
+checksum = "b6d7b9decdf35d8908a7e3ef02f64c5e9b1695e230154c0e8de3969142d9b94c"
 dependencies = [
- "ethereum-types",
- "hex",
- "once_cell",
- "regex",
- "serde",
- "serde_json",
- "sha3",
- "thiserror",
- "uint 0.9.1",
+ "futures 0.3.31",
+ "pharos",
+ "rustc_version 0.4.0",
 ]
 
 [[package]]
-name = "ethbloom"
-version = "0.12.1"
+name = "asynk-strim"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11da94e443c60508eb62cf256243a64da87304c2802ac2528847f79d750007ef"
+checksum = "52697735bdaac441a29391a9e97102c74c6ef0f9b60a40cf109b1b404e29d2f6"
 dependencies = [
- "crunchy",
- "fixed-hash",
- "impl-rlp",
- "impl-serde",
- "tiny-keccak 2.0.2",
+ "futures-core",
+ "pin-project-lite",
 ]
 
 [[package]]
-name = "ethereum-types"
-version = "0.13.1"
+name = "atoi"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2827b94c556145446fcce834ca86b7abf0c39a805883fe20e72c5bfdb5a0dc6"
+checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
 dependencies = [
- "ethbloom",
- "fixed-hash",
- "impl-rlp",
- "impl-serde",
- "primitive-types",
- "uint 0.9.1",
+ "num-traits",
 ]
 
 [[package]]
-name = "fallible-iterator"
-version = "0.2.0"
+name = "atomic-waker"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
-name = "fallible-iterator"
-version = "0.3.0"
+name = "atomic_refcell"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+checksum = "21e4227379beff4205943696e6c3e0cd809bacdf3f0edd6e3dd153e2269571a4"
 
 [[package]]
-name = "file-per-thread-logger"
-version = "0.1.4"
+name = "auto_impl"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fdbe0d94371f9ce939b555dd342d0686cc4c0cadbcd4b61d70af5ff97eb4126"
+checksum = "ffdcb70bdbc4d478427380519163274ac86e52916e10f0a8889adf0f96d3fee7"
 dependencies = [
- "env_logger 0.7.1",
- "log",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "firestorm"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31586bda1b136406162e381a3185a506cdfc1631708dd40cba2f6628d8634499"
-
-[[package]]
-name = "firestorm"
-version = "0.5.0"
+name = "autocfg"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d3d6188b8804df28032815ea256b6955c9625c24da7525f387a7af02fbb8f01"
+checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
 [[package]]
-name = "fixed-hash"
-version = "0.7.0"
+name = "aws-lc-rs"
+version = "1.16.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfcf0ed7fe52a17a03854ec54a9f76d6d84508d1c0e66bc1793301c73fc8493c"
+checksum = "0ec6fb3fe69024a75fa7e1bfb48aa6cf59706a101658ea01bfd33b2b248a038f"
 dependencies = [
- "byteorder",
- "rand",
- "rustc-hex",
- "static_assertions",
+ "aws-lc-sys",
+ "zeroize",
 ]
 
 [[package]]
-name = "fixedbitset"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "398ea4fabe40b9b0d885340a2a991a44c8a645624075ad966d21f88688e2b69e"
-
-[[package]]
-name = "flate2"
-version = "1.0.25"
+name = "aws-lc-sys"
+version = "0.40.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8a2db397cb1c8772f31494cb8917e48cd1e64f0fa7efac59fbd741a0a8ce841"
+checksum = "f50037ee5e1e41e7b8f9d161680a725bd1626cb6f8c7e901f91f942850852fe7"
 dependencies = [
- "crc32fast",
- "miniz_oxide 0.6.2",
+ "cc",
+ "cmake",
+ "dunce",
+ "fs_extra",
 ]
 
 [[package]]
-name = "fnv"
-version = "1.0.7"
+name = "axum"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
-[[package]]
-name = "foreign-types"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+checksum = "31b698c5f9a010f6573133b09e0de5408834d0c82f8d7475a89fc1867a71cd90"
 dependencies = [
- "foreign-types-shared",
+ "axum-core",
+ "base64",
+ "bytes",
+ "form_urlencoded",
+ "futures-util",
+ "http 1.4.2",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde_core",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_urlencoded",
+ "sha1 0.10.6",
+ "sync_wrapper",
+ "tokio",
+ "tokio-tungstenite 0.29.0",
+ "tower 0.5.2",
+ "tower-layer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tracing",
 ]
 
 [[package]]
-name = "foreign-types-shared"
-version = "0.1.1"
+name = "axum-core"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+checksum = "59446ce19cd142f8833f856eb31f3eb097812d1479ab224f54d72428ca21ea22"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http 1.4.2",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tower-layer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tracing",
+]
 
 [[package]]
-name = "form_urlencoded"
-version = "1.2.1"
+name = "backon"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+checksum = "cffb0e931875b666fc4fcb20fee52e9bbd1ef836fd9e9e04ec21555f9f85f7ef"
 dependencies = [
- "percent-encoding",
+ "fastrand",
 ]
 
 [[package]]
-name = "funty"
-version = "2.0.0"
+name = "base-x"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+checksum = "4cbbc9d0964165b47557570cce6c952866c2678457aca742aafc9fb771d30270"
 
 [[package]]
-name = "futures"
-version = "0.1.31"
+name = "base16ct"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
 
 [[package]]
-name = "futures"
-version = "0.3.16"
+name = "base64"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1adc00f486adfc9ce99f77d717836f0c5aa84965eb0b4f051f4e83f7cab53f8b"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-io",
- "futures-sink",
- "futures-task",
- "futures-util",
-]
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
-name = "futures-channel"
-version = "0.3.26"
+name = "base64ct"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d809780667f4410e7c41b07f52439b94d2bdf8528eeedc287fa38d3b7f95d82"
+
+[[package]]
+name = "bigdecimal"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e5317663a9089767a1ec00a487df42e0ca174b61b4483213ac24448e4664df5"
+checksum = "1374191e2dd25f9ae02e3aa95041ed5d747fc77b3c102b49fe2dd9a8117a6244"
 dependencies = [
- "futures-core",
- "futures-sink",
+ "num-bigint 0.2.6",
+ "num-integer",
+ "num-traits",
+ "serde",
 ]
 
 [[package]]
-name = "futures-core"
-version = "0.3.26"
+name = "bimap"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec90ff4d0fe1f57d600049061dc6bb68ed03c7d2fbd697274c41805dcb3f8608"
+checksum = "230c5f1ca6a325a32553f8640d31ac9b49f2411e901e427570154868b46da4f7"
 
 [[package]]
-name = "futures-executor"
-version = "0.3.16"
+name = "bit-set"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d0d535a57b87e1ae31437b892713aee90cd2d7b0ee48727cd11fc72ef54761c"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
 dependencies = [
- "futures-core",
- "futures-task",
- "futures-util",
+ "bit-vec",
 ]
 
 [[package]]
-name = "futures-io"
-version = "0.3.26"
+name = "bit-vec"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfb8371b6fb2aeb2d280374607aeabfc99d95c72edfe51692e42d3d7f0d08531"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
 
 [[package]]
-name = "futures-macro"
-version = "0.3.26"
+name = "bitcoin-io"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dee39a0ee5b4095224a0cfc6bf4cc1baf0f9624b96b367e53b66d974e51d953"
+
+[[package]]
+name = "bitcoin_hashes"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95a73af87da33b5acf53acfebdc339fe592ecf5357ac7c0a7734ab9d8c876a70"
+checksum = "26ec84b80c482df901772e931a9a681e26a1b9ee2302edeff23cb30328745c8b"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "bitcoin-io",
+ "hex-conservative",
 ]
 
 [[package]]
-name = "futures-sink"
-version = "0.3.26"
+name = "bitflags"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f310820bb3e8cfd46c80db4d7fb8353e15dfff853a127158425f31e0be6c8364"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
-name = "futures-task"
-version = "0.3.26"
+name = "bitflags"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcf79a1bf610b10f42aea489289c5a2c478a786509693b80cd39c44ccd936366"
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
 [[package]]
-name = "futures-timer"
-version = "3.0.2"
+name = "bitvec"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
 
 [[package]]
-name = "futures-util"
-version = "0.3.26"
+name = "blake3"
+version = "1.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c1d6de3acfef38d2be4b1f543f553131788603495be83da675e180c8d6b7bd1"
+checksum = "6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae"
 dependencies = [
- "futures 0.1.31",
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-macro",
- "futures-sink",
- "futures-task",
- "memchr",
- "pin-project-lite",
- "pin-utils",
- "slab",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+ "cpufeatures 0.3.0",
 ]
 
 [[package]]
-name = "gcc"
-version = "0.3.55"
+name = "block-buffer"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f5f3913fa0bfe7ee1fd8248b6b9f42a5af4b9d65ec2dd2c3c26132b950ecfc2"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
 
 [[package]]
-name = "generic-array"
-version = "0.14.4"
+name = "block-buffer"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
+checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be"
 dependencies = [
- "typenum",
- "version_check",
+ "hybrid-array",
 ]
 
 [[package]]
-name = "getrandom"
-version = "0.2.10"
+name = "blst"
+version = "0.3.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
+checksum = "dcdb4c7013139a150f9fc55d123186dbfaba0d912817466282c73ac49e71fb45"
 dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "wasi",
+ "cc",
+ "glob",
+ "threadpool",
+ "zeroize",
 ]
 
 [[package]]
-name = "gimli"
-version = "0.24.0"
+name = "borsh"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e4075386626662786ddb0ec9081e7c7eeb1ba31951f447ca780ef9f5d568189"
+checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f"
 dependencies = [
- "fallible-iterator 0.2.0",
- "indexmap 1.9.3",
- "stable_deref_trait",
+ "borsh-derive",
+ "cfg_aliases",
 ]
 
 [[package]]
-name = "gimli"
-version = "0.25.0"
+name = "borsh-derive"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0a01e0497841a3b2db4f8afa483cce65f7e96a3498bd6c541734792aeac8fe7"
+checksum = "0686c856aa6aac0c4498f936d7d6a02df690f614c03e4d906d1018062b5c5e2c"
+dependencies = [
+ "once_cell",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
 
 [[package]]
-name = "git-testament"
-version = "0.2.5"
+name = "brotli"
+version = "8.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "710c78d2b68e46e62f5ba63ba0a7a2986640f37f9ecc07903b9ad4e7b2dbfc8e"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
 dependencies = [
- "git-testament-derive",
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
 ]
 
 [[package]]
-name = "git-testament-derive"
-version = "0.2.0"
+name = "brotli-decompressor"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b31494efbbe1a6730f6943759c21b92c8dc431cb4df177e6f2a6429c3c96842"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
 dependencies = [
- "log",
- "proc-macro2",
- "quote",
- "syn 2.0.48",
- "time",
+ "alloc-no-stdlib",
+ "alloc-stdlib",
 ]
 
 [[package]]
-name = "globset"
-version = "0.4.8"
+name = "bs58"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
+
+[[package]]
+name = "bs58"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
 dependencies = [
- "aho-corasick",
- "bstr",
- "fnv",
- "log",
- "regex",
+ "tinyvec",
 ]
 
 [[package]]
-name = "graph"
-version = "0.34.0"
+name = "bstr"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706"
 dependencies = [
- "Inflector",
- "anyhow",
- "async-stream",
- "async-trait",
- "atomic_refcell",
- "bigdecimal 0.1.2",
- "bytes",
- "chrono",
- "cid",
- "clap",
- "defer",
- "diesel",
- "diesel_derives",
- "envconfig",
- "ethabi",
- "futures 0.1.31",
- "futures 0.3.16",
- "graphql-parser",
- "hex",
- "hex-literal 0.4.1",
- "http",
- "humantime 2.1.0",
- "isatty",
- "itertools 0.12.0",
- "lazy_static",
- "maplit",
- "num-bigint 0.2.6",
- "num-traits",
- "num_cpus",
- "parking_lot 0.12.1",
- "petgraph",
- "priority-queue",
- "prometheus",
- "prost",
- "prost-types",
- "rand",
- "regex",
- "reqwest",
- "semver",
+ "memchr",
  "serde",
- "serde_derive",
- "serde_json",
- "serde_plain",
- "serde_regex",
- "serde_yaml",
- "slog",
- "slog-async",
- "slog-envlogger",
- "slog-term",
- "stable-hash 0.3.4",
- "stable-hash 0.4.4",
- "strum",
- "strum_macros",
- "thiserror",
- "tiny-keccak 1.5.0",
- "tokio",
- "tokio-retry",
- "tokio-stream",
- "toml 0.8.8",
- "tonic",
- "tonic-build",
- "url",
- "wasmparser",
- "web3",
 ]
 
 [[package]]
-name = "graph-chain-arweave"
-version = "0.34.0"
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 dependencies = [
- "base64-url",
- "diesel",
- "graph",
- "graph-runtime-derive",
- "graph-runtime-wasm",
- "prost",
- "prost-types",
- "serde",
- "sha2 0.10.8",
- "tonic-build",
+ "allocator-api2",
 ]
 
 [[package]]
-name = "graph-chain-common"
-version = "0.34.0"
+name = "byte-slice-cast"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 dependencies = [
- "anyhow",
- "heck",
- "protobuf 3.3.0",
- "protobuf-parse",
+ "serde",
 ]
 
 [[package]]
-name = "graph-chain-cosmos"
-version = "0.34.0"
+name = "c-kzg"
+version = "2.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e00bf4b112b07b505472dbefd19e37e53307e2bfed5a79e0cc161d58ccd0e687"
 dependencies = [
- "anyhow",
- "graph",
- "graph-chain-common",
- "graph-runtime-derive",
- "graph-runtime-wasm",
- "prost",
- "prost-types",
- "semver",
+ "arbitrary",
+ "blst",
+ "cc",
+ "glob",
+ "hex",
+ "libc",
+ "once_cell",
  "serde",
- "tonic-build",
 ]
 
 [[package]]
-name = "graph-chain-ethereum"
-version = "0.34.0"
+name = "cc"
+version = "1.2.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
 dependencies = [
- "anyhow",
- "base64 0.20.0",
- "dirs-next",
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cfg-if"
+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 = "chacha20"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "rand_core 0.10.0",
+]
+
+[[package]]
+name = "chrono"
+version = "0.4.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "serde",
+ "wasm-bindgen",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "cid"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21a304f95f84d169a6f31c4d0a30d784643aaa0bbc9c1e449a2c23e963ec4971"
+dependencies = [
+ "multibase",
+ "multihash",
+ "unsigned-varint",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84b3edb18336f4df585bc9aa31dd99c036dfa5dc5e9a2939a722a188f3a8970d"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1c09dd5ada6c6c78075d6fd0da3f90d8080651e2d6cc8eb2f1aaa4034ced708"
+dependencies = [
+ "anstream 0.6.21",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+ "terminal_size",
+]
+
+[[package]]
+name = "clap_complete"
+version = "4.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b4be9c4c4b1f30b78d8a750e0822b6a6102d97e62061c583a6c1dea2dfb33ae"
+dependencies = [
+ "clap",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bac35c6dafb060fd4d275d9a4ffae97917c13a6327903a8be2153cd964f7085"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b82cf0babdbd58558212896d1a4272303a57bdb245c2bf1147185fb45640e70"
+
+[[package]]
+name = "cmake"
+version = "0.1.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "cobs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "colorchoice"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "memchr",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "console"
+version = "0.15.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "unicode-width",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "console"
+version = "0.16.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fe5f465a4f6fee88fad41b85d990f84c835335e85b5d9e6e63e0d06d28cba7c"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "unicode-width",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "const-hex"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3bb320cac8a0750d7f25280aa97b09c26edfe161164238ecbbb31092b079e735"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.12",
+ "proptest",
+ "serde_core",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
+[[package]]
+name = "const-random"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
+dependencies = [
+ "const-random-macro",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+dependencies = [
+ "getrandom 0.2.15",
+ "once_cell",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
+
+[[package]]
+name = "convert_case"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b55271e5c8c478ad3f38ad24ef34923091e0548492a266d19b3c0b4d82574c63"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpp_demangle"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96e58d342ad113c2b878f16d5d034c03be492ae460cdbc02b7f0f2284d310c7d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cranelift-assembler-x64"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e06aeba2c965fc446d13c56a6ccb2631b78445d7544543dd9a25289977630914"
+dependencies = [
+ "cranelift-assembler-x64-meta",
+]
+
+[[package]]
+name = "cranelift-assembler-x64-meta"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee2d2dde4ec1352715595b5cfa6fe2e5b8ebb9da3457b3ee8db0aa2808c069aa"
+dependencies = [
+ "cranelift-srcgen",
+]
+
+[[package]]
+name = "cranelift-bforest"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03b4982ef9fa54ec9eee841e891e7ddc5434be1250e88de31572e000c888f30b"
+dependencies = [
+ "cranelift-entity",
+ "wasmtime-internal-core",
+]
+
+[[package]]
+name = "cranelift-bitset"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "529143118c4eeb58c39ecb02319557d512be6c61348486422974ab8e3906b8a8"
+dependencies = [
+ "serde",
+ "serde_derive",
+ "wasmtime-internal-core",
+]
+
+[[package]]
+name = "cranelift-codegen"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7780677247ad3577e3a6a3ebf43f39b325a11d6393db72b2c9968a910d4d13d"
+dependencies = [
+ "bumpalo",
+ "cranelift-assembler-x64",
+ "cranelift-bforest",
+ "cranelift-bitset",
+ "cranelift-codegen-meta",
+ "cranelift-codegen-shared",
+ "cranelift-control",
+ "cranelift-entity",
+ "cranelift-isle",
+ "gimli",
+ "hashbrown 0.17.0",
+ "libm",
+ "log",
+ "postcard",
+ "pulley-interpreter",
+ "regalloc2",
+ "rustc-hash",
+ "serde",
+ "serde_derive",
+ "sha2 0.10.9",
+ "smallvec",
+ "target-lexicon",
+ "wasmtime-internal-core",
+]
+
+[[package]]
+name = "cranelift-codegen-meta"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac9645250416cbf92454fe61160e17e026e0ce405906a54500b114f923ddffc9"
+dependencies = [
+ "cranelift-assembler-x64-meta",
+ "cranelift-codegen-shared",
+ "cranelift-srcgen",
+ "heck 0.5.0",
+ "pulley-interpreter",
+]
+
+[[package]]
+name = "cranelift-codegen-shared"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20ee8d222ff0fd3681791979afbf88586ac9f49010d3db96b3cbe4c96759aee3"
+
+[[package]]
+name = "cranelift-control"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "591abe6f5312bd2c4220f1b3bead56c2ad00257c52668015ba013b85dcf2a17a"
+dependencies = [
+ "arbitrary",
+]
+
+[[package]]
+name = "cranelift-entity"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5300c49cf940526fe771517b3b3eabd5d0ff164ee61698579cf403fe8d3af3c"
+dependencies = [
+ "cranelift-bitset",
+ "serde",
+ "serde_derive",
+ "wasmtime-internal-core",
+]
+
+[[package]]
+name = "cranelift-frontend"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da4adbf760207fdbbe130f1191cce01cdef66831a9f648b1f39ff2800d126d45"
+dependencies = [
+ "cranelift-codegen",
+ "hashbrown 0.17.0",
+ "log",
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-isle"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8315b21ff018226a42a60a4702c2dd75f6447cac26e9bca622e14c22088c2ff5"
+
+[[package]]
+name = "cranelift-native"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d506ef23a60715bde451b06620b14402166ded3b648454fccbf04f3e46a4aa70"
+dependencies = [
+ "cranelift-codegen",
+ "libc",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-srcgen"
+version = "0.133.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48ed47e602652e3410f9387fc0db70fefadcee4d78a78881421aabcab4e26b89"
+
+[[package]]
+name = "crc"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
+
+[[package]]
+name = "crc32fast"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crossbeam"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-epoch",
+ "crossbeam-queue",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+
+[[package]]
+name = "crossterm"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
+dependencies = [
+ "bitflags 2.11.1",
+ "crossterm_winapi",
+ "derive_more",
+ "document-features",
+ "mio",
+ "parking_lot",
+ "rustix 1.1.4",
+ "signal-hook",
+ "signal-hook-mio",
+ "winapi",
+]
+
+[[package]]
+name = "crossterm_winapi"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
+dependencies = [
+ "generic-array",
+ "rand_core 0.6.4",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77727bb15fa921304124b128af125e7e3b968275d1b108b379190264f4423710"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "csv"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde_core",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "darling"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
+dependencies = [
+ "darling_core 0.20.10",
+ "darling_macro 0.20.10",
+]
+
+[[package]]
+name = "darling"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
+dependencies = [
+ "darling_core 0.21.3",
+ "darling_macro 0.21.3",
+]
+
+[[package]]
+name = "darling"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"
+dependencies = [
+ "darling_core 0.23.0",
+ "darling_macro 0.23.0",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"
+dependencies = [
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "strsim",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
+dependencies = [
+ "darling_core 0.20.10",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
+dependencies = [
+ "darling_core 0.21.3",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
+dependencies = [
+ "darling_core 0.23.0",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "dashmap"
+version = "6.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
+
+[[package]]
+name = "data-encoding-macro"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1559b6cba622276d6d63706db152618eeb15b89b3e4041446b05876e352e639"
+dependencies = [
+ "data-encoding",
+ "data-encoding-macro-internal",
+]
+
+[[package]]
+name = "data-encoding-macro-internal"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "332d754c0af53bc87c108fed664d121ecf59207ec4196041f04d6ab9002ad33f"
+dependencies = [
+ "data-encoding",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "deadpool"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0be2b1d1d6ec8d846f05e137292d0b89133caf95ef33695424c09568bdd39b1b"
+dependencies = [
+ "deadpool-runtime 0.1.4",
+ "lazy_static",
+ "num_cpus",
+ "tokio",
+]
+
+[[package]]
+name = "deadpool"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "883466cb8db62725aee5f4a6011e8a5d42912b42632df32aad57fc91127c6e04"
+dependencies = [
+ "deadpool-runtime 0.3.1",
+ "num_cpus",
+ "tokio",
+]
+
+[[package]]
+name = "deadpool-runtime"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b"
+
+[[package]]
+name = "deadpool-runtime"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2657f61fb1dd8bf37a8d51093cc7cee4e77125b22f7753f49b289f831bec2bae"
+dependencies = [
+ "tokio",
+]
+
+[[package]]
+name = "debugid"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef552e6f588e446098f6ba40d89ac146c8c7b64aade83c051ee00bb5d2bc18d"
+dependencies = [
+ "uuid",
+]
+
+[[package]]
+name = "defer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "930c7171c8df9fb1782bdf9b918ed9ed2d33d1d22300abb754f9085bc48bf8e8"
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid 0.9.6",
+ "zeroize",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
+dependencies = [
+ "powerfmt",
+ "serde_core",
+]
+
+[[package]]
+name = "derivative"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[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.118",
+]
+
+[[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.118",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version 0.4.0",
+ "syn 2.0.118",
+ "unicode-xid",
+]
+
+[[package]]
+name = "diesel"
+version = "2.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9940fb8467a0a06312218ed384185cb8536aa10d8ec017d0ce7fad2c1bd882d5"
+dependencies = [
+ "bigdecimal",
+ "bitflags 2.11.1",
+ "byteorder",
+ "chrono",
+ "diesel_derives",
+ "downcast-rs",
+ "itoa",
+ "num-bigint 0.2.6",
+ "num-integer",
+ "num-traits",
+ "pq-sys",
+ "r2d2",
+ "serde_json",
+]
+
+[[package]]
+name = "diesel-async"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd39af30158d444884f166fe4c58f35dc40ad71ad017bb59408a3448526ff4bd"
+dependencies = [
+ "deadpool 0.13.0",
+ "diesel",
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "tokio",
+ "tokio-postgres",
+]
+
+[[package]]
+name = "diesel-derive-enum"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81c5131a2895ef64741dad1d483f358c2a229a3a2d1b256778cdc5e146db64d4"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "diesel-dynamic-schema"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "030a2287b125235908614c5f32f9b3bdc43c4d639846853d66e8a68c75a02756"
+dependencies = [
+ "diesel",
+]
+
+[[package]]
+name = "diesel_derives"
+version = "2.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1817b7f4279b947fc4cafddec12b0e5f8727141706561ce3ac94a60bddd1cf5"
+dependencies = [
+ "diesel_table_macro_syntax",
+ "dsl_auto_type",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "diesel_migrations"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d0f4a98124ba6d4ca75da535f65984badec16a003b6e2f94a01e31a79490b8"
+dependencies = [
+ "diesel",
+ "migrations_internals",
+ "migrations_macros",
+]
+
+[[package]]
+name = "diesel_table_macro_syntax"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe2444076b48641147115697648dc743c2c00b61adade0f01ce67133c7babe8c"
+dependencies = [
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
+[[package]]
+name = "difflib"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+
+[[package]]
+name = "digest"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer 0.10.4",
+ "const-oid 0.9.6",
+ "crypto-common 0.1.6",
+ "subtle",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4850db49bf08e663084f7fb5c87d202ef91a3907271aff24a94eb97ff039153c"
+dependencies = [
+ "block-buffer 0.12.0",
+ "const-oid 0.10.2",
+ "crypto-common 0.2.1",
+]
+
+[[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"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+dependencies = [
+ "cfg-if",
+ "dirs-sys-next",
+]
+
+[[package]]
+name = "dirs-sys"
+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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "doctest-file"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aac81fa3e28d21450aa4d2ac065992ba96a1d7303efbce51a95f4fd175b67562"
+
+[[package]]
+name = "document-features"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
+dependencies = [
+ "litrs",
+]
+
+[[package]]
+name = "downcast-rs"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "117240f60069e65410b3ae1bb213295bd828f707b5bec6596a1afc8793ce0cbc"
+
+[[package]]
+name = "dsl_auto_type"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd122633e4bef06db27737f21d3738fb89c8f6d5360d6d9d7635dda142a7757e"
+dependencies = [
+ "darling 0.21.3",
+ "either",
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
+[[package]]
+name = "ecdsa"
+version = "0.16.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
+dependencies = [
+ "der",
+ "digest 0.10.7",
+ "elliptic-curve",
+ "rfc6979",
+ "serdect",
+ "signature",
+ "spki",
+]
+
+[[package]]
+name = "educe"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7bc049e1bd8cdeb31b68bbd586a9464ecf9f3944af3958a7a9d0f8b9799417"
+dependencies = [
+ "enum-ordinalize",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "digest 0.10.7",
+ "ff",
+ "generic-array",
+ "group",
+ "pkcs8",
+ "rand_core 0.6.4",
+ "sec1",
+ "serdect",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "embedded-io"
+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 = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "enum-ordinalize"
+version = "4.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a1091a7bb1f8f2c4b28f1fe2cef4980ca2d410a3d727d67ecc3178c9b0800f0"
+dependencies = [
+ "enum-ordinalize-derive",
+]
+
+[[package]]
+name = "enum-ordinalize-derive"
+version = "4.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ca9601fb2d62598ee17836250842873a413586e5d7ed88b356e38ddbb0ec631"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "env_filter"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "900d271a03799a1ee8d1ca9b19893b48ca674a9284fefcfb85f05e74ed314217"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de671bd27a75a797dc9ae289ba1e77276e75e2026408aab65185384e2d5cd3f6"
+dependencies = [
+ "anstream 1.0.0",
+ "anstyle",
+ "env_filter",
+ "jiff",
+ "log",
+]
+
+[[package]]
+name = "envconfig"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2934d78aeb06e54961db5b96cfca2b01f5cb01cf11c34f7b088932fd48233ac6"
+dependencies = [
+ "envconfig_derive",
+]
+
+[[package]]
+name = "envconfig_derive"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "452c458dfb890a2fea64e4c894f83daad61689fb9bbe84c382e1ce6d7536710b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
+[[package]]
+name = "erased-serde"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c138974f9d5e7fe373eb04df7cae98833802ae4b11c24ac7039a21d5af4b26c"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cea14ef9355e3beab063703aa9dab15afd25f0667c341310c1e5274bb1d0da18"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "event-listener"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "fallible-iterator"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fast_chemail"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "495a39d30d624c2caabe6312bfead73e7717692b44e0b32df168c275a2e8e9e4"
+dependencies = [
+ "ascii_utils",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
+[[package]]
+name = "fastrlp"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139834ddba373bbdd213dffe02c8d110508dcf1726c2be27e8d1f7d7e1856418"
+dependencies = [
+ "arrayvec",
+ "auto_impl",
+ "bytes",
+]
+
+[[package]]
+name = "fastrlp"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce8dba4714ef14b8274c371879b175aa55b16b30f269663f19d576f380018dc4"
+dependencies = [
+ "arrayvec",
+ "auto_impl",
+ "bytes",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
+dependencies = [
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "firestorm"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31586bda1b136406162e381a3185a506cdfc1631708dd40cba2f6628d8634499"
+
+[[package]]
+name = "firestorm"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c5f6c2c942da57e2aaaa84b8a521489486f14e75e7fa91dab70aba913975f98"
+
+[[package]]
+name = "fixed-hash"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534"
+dependencies = [
+ "byteorder",
+ "rand 0.8.6",
+ "rustc-hex",
+ "static_assertions",
+]
+
+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
+[[package]]
+name = "flatbuffers"
+version = "25.12.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35f6839d7b3b98adde531effaf34f0c2badc6f4735d26fe74709d8e513a96ef3"
+dependencies = [
+ "bitflags 2.11.1",
+ "rustc_version 0.4.0",
+]
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+ "zlib-rs",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
+[[package]]
+name = "fsevent-sys"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "futures"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
+
+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+
+[[package]]
+name = "futures-lite"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures 0.1.31",
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "futures-utils-wasm"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42012b0f064e01aa58b545fe3727f90f7dd4020f4a3ea735b50344965f5a57e9"
+
+[[package]]
+name = "fuzzy-matcher"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54614a3312934d066701a80f20f15fa3b56d67ac7722b39eea5b4c9dd1d66c94"
+dependencies = [
+ "thread_local",
+]
+
+[[package]]
+name = "fxprof-processed-profile"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25234f20a3ec0a962a61770cfe39ecf03cb529a6e474ad8cff025ed497eda557"
+dependencies = [
+ "bitflags 2.11.1",
+ "debugid",
+ "rustc-hash",
+ "serde",
+ "serde_derive",
+ "serde_json",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi 0.13.3+wasi-0.2.2",
+ "wasm-bindgen",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "rand_core 0.10.0",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "gimli"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf7f043f89559805f8c7cacc432749b2fa0d0a0a9ee46ce47164ed5ba7f126c"
+dependencies = [
+ "fnv",
+ "hashbrown 0.16.1",
+ "indexmap 2.14.0",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "git-testament"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a74999c921479f919c87a9d2e6922a79a18683f18105344df8e067149232e51"
+dependencies = [
+ "git-testament-derive",
+]
+
+[[package]]
+name = "git-testament-derive"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbeac967e71eb3dc1656742fc7521ec7cd3b6b88738face65bf1fddf702bc4c0"
+dependencies = [
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "time",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "globset"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "log",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "gnd"
+version = "0.45.0"
+dependencies = [
+ "Inflector",
+ "anyhow",
+ "async-trait",
+ "clap",
+ "clap_complete",
+ "console 0.16.4",
+ "env_logger",
+ "git-testament",
+ "globset",
+ "graph",
+ "graph-chain-ethereum",
+ "graph-core",
+ "graph-graphql",
+ "graph-node",
+ "graph-store-postgres",
+ "graphql-tools",
+ "hex",
+ "indicatif",
+ "inquire",
+ "lazy_static",
+ "notify",
+ "open",
+ "pgtemp",
+ "pq-sys",
+ "regex",
+ "reqwest 0.12.23",
+ "semver 1.0.28",
+ "serde",
+ "serde_json",
+ "serde_yaml",
+ "sha1 0.11.0",
+ "similar",
+ "tempfile",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-util",
+ "tower 0.5.2",
+ "url",
+ "walkdir",
+ "wasmparser 0.118.2",
+]
+
+[[package]]
+name = "graph"
+version = "0.45.0"
+dependencies = [
+ "Inflector",
+ "ahash",
+ "alloy",
+ "anyhow",
+ "arrow",
+ "arrow-flight",
+ "async-stream",
+ "async-trait",
+ "atomic_refcell",
+ "base64",
+ "bigdecimal",
+ "bs58 0.5.1",
+ "bytes",
+ "chrono",
+ "cid",
+ "clap",
+ "csv",
+ "defer",
+ "derive_more",
+ "diesel",
+ "diesel_derives",
+ "envconfig",
+ "futures 0.1.31",
+ "futures 0.3.31",
+ "graph_derive",
+ "graphql-tools",
+ "half",
+ "hex",
+ "hex-literal",
+ "http 0.2.12",
+ "http 1.4.2",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "indoc",
+ "itertools 0.15.0",
+ "lazy-regex",
+ "lazy_static",
+ "lru_time_cache",
+ "maplit",
+ "num-bigint 0.2.6",
+ "num-integer",
+ "num-traits",
+ "object_store",
+ "parking_lot",
+ "petgraph 0.8.3",
+ "portable-atomic",
+ "priority-queue",
+ "prometheus",
+ "prost",
+ "prost-types",
+ "rand 0.9.3",
+ "redis",
+ "regex",
+ "reqwest 0.12.23",
+ "rustls",
+ "semver 1.0.28",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "serde_plain",
+ "serde_regex",
+ "serde_yaml",
+ "sha2 0.11.0",
+ "slog",
+ "slog-async",
+ "slog-envlogger",
+ "slog-term",
+ "sqlparser 0.57.0",
+ "sqlparser 0.62.0",
+ "stable-hash 0.3.4",
+ "stable-hash 0.4.4",
+ "strum_macros 0.28.0",
+ "tempfile",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-retry",
+ "tokio-stream",
+ "tokio-util",
+ "toml 1.1.2+spec-1.1.0",
+ "tonic",
+ "tonic-prost",
+ "tonic-prost-build",
+ "url",
+ "wasmparser 0.118.2",
+ "wiremock",
+]
+
+[[package]]
+name = "graph-chain-common"
+version = "0.45.0"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "protobuf",
+ "protobuf-parse",
+]
+
+[[package]]
+name = "graph-chain-ethereum"
+version = "0.45.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "base64",
  "envconfig",
- "futures 0.1.31",
+ "futures 0.3.31",
+ "graph",
+ "graph-runtime-derive",
+ "graph-runtime-wasm",
+ "hex",
+ "itertools 0.15.0",
+ "jsonrpc-core",
+ "prost",
+ "prost-types",
+ "semver 1.0.28",
+ "serde",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-stream",
+ "tonic-prost-build",
+ "tower 0.5.2",
+]
+
+[[package]]
+name = "graph-chain-near"
+version = "0.45.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "diesel",
+ "graph",
+ "graph-runtime-derive",
+ "graph-runtime-wasm",
+ "prost",
+ "prost-types",
+ "serde",
+ "tokio",
+ "tonic-prost-build",
+]
+
+[[package]]
+name = "graph-core"
+version = "0.45.0"
+dependencies = [
+ "alloy",
+ "anyhow",
+ "arrow",
+ "async-trait",
+ "bytes",
+ "chrono",
+ "futures 0.3.31",
+ "graph",
+ "graph-chain-ethereum",
+ "graph-chain-near",
+ "graph-runtime-wasm",
+ "indoc",
+ "itertools 0.15.0",
+ "parking_lot",
+ "prometheus",
+ "serde_yaml",
+ "slog",
+ "strum 0.28.0",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-retry",
+ "tokio-util",
+ "tower 0.5.3",
+ "tower-test",
+ "wiremock",
+]
+
+[[package]]
+name = "graph-graphql"
+version = "0.45.0"
+dependencies = [
+ "anyhow",
+ "async-recursion",
+ "async-trait",
+ "crossbeam",
+ "graph",
+ "graphql-tools",
+ "lazy_static",
+ "parking_lot",
+ "stable-hash 0.3.4",
+ "stable-hash 0.4.4",
+]
+
+[[package]]
+name = "graph-node"
+version = "0.45.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "console 0.16.4",
+ "diesel",
+ "diesel-async",
+ "env_logger",
+ "git-testament",
+ "graph",
+ "graph-chain-ethereum",
+ "graph-chain-near",
+ "graph-core",
+ "graph-graphql",
+ "graph-server-http",
+ "graph-server-index-node",
+ "graph-server-json-rpc",
+ "graph-server-metrics",
+ "graph-store-postgres",
+ "graphman",
+ "graphman-server",
+ "indicatif",
+ "itertools 0.15.0",
+ "json-structural-diff",
+ "lazy_static",
+ "prometheus",
+ "serde",
+ "shellexpand",
+ "termcolor",
+ "tokio",
+ "tokio-util",
+ "url",
+]
+
+[[package]]
+name = "graph-runtime-derive"
+version = "0.45.0"
+dependencies = [
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "graph-runtime-test"
+version = "0.45.0"
+dependencies = [
+ "async-trait",
+ "graph",
+ "graph-chain-ethereum",
+ "graph-runtime-wasm",
+ "rand 0.9.3",
+ "semver 1.0.28",
+ "test-store",
+ "wasmtime",
+]
+
+[[package]]
+name = "graph-runtime-wasm"
+version = "0.45.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "bs58 0.4.0",
+ "graph",
+ "graph-runtime-derive",
+ "hex",
+ "never",
+ "parity-wasm",
+ "semver 1.0.28",
+ "serde_yaml",
+ "wasm-instrument",
+ "wasmtime",
+]
+
+[[package]]
+name = "graph-server-http"
+version = "0.45.0"
+dependencies = [
+ "async-trait",
+ "graph",
+ "graph-core",
+ "graph-graphql",
+ "serde",
+]
+
+[[package]]
+name = "graph-server-index-node"
+version = "0.45.0"
+dependencies = [
+ "async-trait",
+ "blake3",
+ "git-testament",
+ "graph",
+ "graph-chain-ethereum",
+ "graph-chain-near",
+ "graph-graphql",
+]
+
+[[package]]
+name = "graph-server-json-rpc"
+version = "0.45.0"
+dependencies = [
+ "axum",
+ "graph",
+ "serde",
+ "serde_json",
+ "slog",
+ "thiserror 2.0.18",
+ "tokio",
+]
+
+[[package]]
+name = "graph-server-metrics"
+version = "0.45.0"
+dependencies = [
+ "graph",
+]
+
+[[package]]
+name = "graph-store-postgres"
+version = "0.45.0"
+dependencies = [
+ "Inflector",
+ "anyhow",
+ "arrow",
+ "async-trait",
+ "blake3",
+ "chrono",
+ "clap",
+ "deadpool 0.13.0",
+ "derive_more",
+ "diesel",
+ "diesel-async",
+ "diesel-derive-enum",
+ "diesel-dynamic-schema",
+ "diesel_derives",
+ "diesel_migrations",
+ "fallible-iterator 0.3.0",
+ "git-testament",
+ "graph",
+ "graphman-store",
+ "hex",
+ "itertools 0.15.0",
+ "lazy_static",
+ "lru_time_cache",
+ "openssl",
+ "parquet",
+ "postgres",
+ "postgres-openssl",
+ "pretty_assertions",
+ "rand 0.9.3",
+ "serde",
+ "serde_json",
+ "serde_yaml",
+ "sqlparser 0.62.0",
+ "stable-hash 0.3.4",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-stream",
+]
+
+[[package]]
+name = "graph-tests"
+version = "0.45.0"
+dependencies = [
+ "anyhow",
+ "assert-json-diff",
+ "async-stream",
+ "async-trait",
+ "graph",
+ "graph-chain-ethereum",
+ "graph-core",
+ "graph-graphql",
+ "graph-node",
+ "graph-runtime-wasm",
+ "graph-server-index-node",
+ "graph-store-postgres",
+ "serde",
+ "serde_yaml",
+ "slog",
+ "slog-async",
+ "slog-term",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+]
+
+[[package]]
+name = "graph_derive"
+version = "0.45.0"
+dependencies = [
+ "proc-macro-utils",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "graphman"
+version = "0.45.0"
+dependencies = [
+ "anyhow",
+ "diesel",
+ "diesel-async",
  "graph",
- "graph-runtime-derive",
- "graph-runtime-wasm",
- "hex",
- "http",
- "itertools 0.12.0",
- "jsonrpc-core",
+ "graph-store-postgres",
+ "graphman-store",
+ "itertools 0.15.0",
+ "thiserror 2.0.18",
+ "tokio",
+]
+
+[[package]]
+name = "graphman-server"
+version = "0.45.0"
+dependencies = [
+ "anyhow",
+ "async-graphql",
+ "async-graphql-axum",
+ "axum",
+ "chrono",
+ "diesel",
+ "diesel-async",
+ "graph",
+ "graph-store-postgres",
+ "graphman",
+ "graphman-store",
  "lazy_static",
- "prost",
- "prost-types",
- "semver",
+ "reqwest 0.12.23",
+ "serde",
+ "serde_json",
+ "slog",
+ "test-store",
+ "thiserror 2.0.18",
+ "tokio",
+ "tower-http 0.7.0",
+]
+
+[[package]]
+name = "graphman-store"
+version = "0.45.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "chrono",
+ "diesel",
+ "strum 0.28.0",
+]
+
+[[package]]
+name = "graphql-tools"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b1ae57fa544e67a661c97805be3e36b97e7d15d65d67bb34beac24d940f987e"
+dependencies = [
+ "combine",
+ "itoa",
+ "lazy_static",
+ "ryu",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "h2"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "171fefbc92fe4a4de27e0698d6a5b392d6a0e333506bc49133760b3bcf948733"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http 1.4.2",
+ "indexmap 2.14.0",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "num-traits",
+ "zerocopy",
+]
+
+[[package]]
+name = "handlebars"
+version = "6.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b3f9296c208515b87bd915a2f5d1163d4b3f863ba83337d7713cf478055948e"
+dependencies = [
+ "derive_builder",
+ "log",
+ "num-order",
+ "pest",
+ "pest_derive",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
+dependencies = [
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+dependencies = [
+ "foldhash 0.2.0",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "hdrhistogram"
+version = "7.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "765c9198f173dd59ce26ff9f95ef0aafd0a0fe01fb9d72841bc5066a4c06511d"
+dependencies = [
+ "byteorder",
+ "num-traits",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hex-conservative"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fda06d18ac606267c40c04e41b9947729bf8b9efe74bd4e82b61a5f26a510b9f"
+dependencies = [
+ "arrayvec",
+]
+
+[[package]]
+name = "hex-literal"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e712f64ec3850b98572bffac52e2c6f282b29fe6c5fa6d42334b30be438d95c1"
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "home"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "http"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6970f50e31d6fc17d3fa27329444bfa74e196cf62e95052a3f6fee181dba6425"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643"
+dependencies = [
+ "bytes",
+ "http 1.4.2",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http 1.4.2",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fcc0b4a115bf80b728eb8ea024ad5bd707b615bfed49e0665b6e0f86fd082d9"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "humantime"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a79f2aff40c18ab8615ddc5caa9eb5b96314aef18fe5823090f204ad988e813"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "hyper"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55281c53a1894c864990125767da440a4e630446785086f52523b20033b74498"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "h2",
+ "http 1.4.2",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee4be2c948921a1a5320b629c4193916ed787a7f7f293fd3f7f5a6c9de74155"
+dependencies = [
+ "futures-util",
+ "http 1.4.2",
+ "hyper",
+ "hyper-util",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "hyper-timeout"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0"
+dependencies = [
+ "hyper",
+ "hyper-util",
+ "pin-project-lite",
+ "tokio",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "hyper-tls"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
+dependencies = [
+ "bytes",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http 1.4.2",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2",
+ "system-configuration",
+ "tokio",
+ "tower-layer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tracing",
+ "windows-registry",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "ibig"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1fcc7f316b2c079dde77564a1360639c1a956a23fa96122732e416cb10717bb"
+dependencies = [
+ "cfg-if",
+ "num-traits",
+ "rand 0.8.6",
+ "static_assertions",
+]
+
+[[package]]
+name = "icu_collections"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_locid_transform_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e"
+
+[[package]]
+name = "icu_normalizer"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516"
+
+[[package]]
+name = "icu_properties"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locid_transform",
+ "icu_properties_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569"
+
+[[package]]
+name = "icu_provider"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_provider_macros",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_provider_macros"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "impl-codec"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba6a270039626615617f3f36d15fc827041df3b78c439da2cadfa47455a77f2f"
+dependencies = [
+ "parity-scale-codec",
+]
+
+[[package]]
+name = "impl-trait-for-tuples"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "arbitrary",
+ "equivalent",
+ "hashbrown 0.17.0",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "indicatif"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "993f007684f2e9727160da8b960ec161264703bfd1af084fd2e34d040c9a0dd4"
+dependencies = [
+ "console 0.16.4",
+ "portable-atomic",
+ "unicode-width",
+ "unit-prefix",
+ "web-time",
+]
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "inotify"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f37dccff2791ab604f9babef0ba14fbe0be30bd368dc541e2b08d07c8aa908f3"
+dependencies = [
+ "bitflags 2.11.1",
+ "inotify-sys",
+ "libc",
+]
+
+[[package]]
+name = "inotify-sys"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "inquire"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6654738b8024300cf062d04a1c13c10c8e2cea598ec1c47dc9b6641159429756"
+dependencies = [
+ "bitflags 2.11.1",
+ "crossterm",
+ "dyn-clone",
+ "fuzzy-matcher",
+ "unicode-segmentation",
+ "unicode-width",
+]
+
+[[package]]
+name = "interprocess"
+version = "2.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d941b405bd2322993887859a8ee6ac9134945a24ec5ec763a8a962fc64dfec2d"
+dependencies = [
+ "doctest-file",
+ "futures-core",
+ "libc",
+ "recvmsg",
+ "tokio",
+ "widestring",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
+
+[[package]]
+name = "is-docker"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "is-terminal"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+dependencies = [
+ "hermit-abi 0.3.9",
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "is-wsl"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
+dependencies = [
+ "is-docker",
+ "once_cell",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800"
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+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 = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "ittapi"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b996fe614c41395cdaedf3cf408a9534851090959d90d54a535f675550b64b1"
+dependencies = [
+ "anyhow",
+ "ittapi-sys",
+ "log",
+]
+
+[[package]]
+name = "ittapi-sys"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52f5385394064fa2c886205dba02598013ce83d3e92d33dbdc0c52fe0e7bf4fc"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "jiff"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a3546dc96b6d42c5f24902af9e2538e82e39ad350b0c766eb3fbf2d8f3d8359"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys 0.3.1",
+ "log",
+ "thiserror 1.0.61",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"
+dependencies = [
+ "jni-sys 0.4.1",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
+dependencies = [
+ "jni-sys-macros",
+]
+
+[[package]]
+name = "jni-sys-macros"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
+dependencies = [
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "jobserver"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03d04c30968dffe80775bd4d7fb676131cd04a1fb46d2686dbffbaec2d9dfd31"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "json-structural-diff"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e878e36a8a44c158505c2c818abdc1350413ad83dcb774a0459f6a7ef2b65cbf"
+dependencies = [
+ "console 0.15.11",
+ "difflib",
+ "regex",
+ "serde_json",
+]
+
+[[package]]
+name = "jsonrpc-core"
+version = "18.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb"
+dependencies = [
+ "futures 0.3.31",
+ "futures-executor",
+ "futures-util",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b"
+dependencies = [
+ "cfg-if",
+ "ecdsa",
+ "elliptic-curve",
+ "once_cell",
+ "serdect",
+ "sha2 0.10.9",
+]
+
+[[package]]
+name = "keccak"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e24a010dd405bd7ed803e5253182815b41bf2e6a80cc3bfc066658e03a198aa"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+]
+
+[[package]]
+name = "keccak-asm"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1766b89733097006f3a1388a02849865d6bc98c89273cb622e29fdd209922183"
+dependencies = [
+ "digest 0.10.7",
+ "sha3-asm",
+]
+
+[[package]]
+name = "kqueue"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eac30106d7dce88daf4a3fcb4879ea939476d5074a9b7ddd0fb97fa4bed5596a"
+dependencies = [
+ "kqueue-sys",
+ "libc",
+]
+
+[[package]]
+name = "kqueue-sys"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed9625ffda8729b85e45cf04090035ac368927b8cebc34898e7c120f52e4838b"
+dependencies = [
+ "bitflags 1.3.2",
+ "libc",
+]
+
+[[package]]
+name = "lazy-regex"
+version = "3.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bae91019476d3ec7147de9aa291cadb6d870abf2f3015d2da73a90325ac1496"
+dependencies = [
+ "lazy-regex-proc_macros",
+ "once_cell",
+ "regex",
+]
+
+[[package]]
+name = "lazy-regex-proc_macros"
+version = "3.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4de9c1e1439d8b7b3061b2d209809f447ca33241733d9a3c01eabf2dc8d94358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "regex",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "leb128"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "lexical-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594"
+dependencies = [
+ "lexical-parse-float",
+ "lexical-parse-integer",
+ "lexical-util",
+ "lexical-write-float",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-parse-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56"
+dependencies = [
+ "lexical-parse-integer",
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-parse-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-util"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17"
+
+[[package]]
+name = "lexical-write-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361"
+dependencies = [
+ "lexical-util",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-write-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags 2.11.1",
+ "libc",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23fb14cb19457329c82206317a5663005a4d404783dc74f4252769b0d5f42856"
+
+[[package]]
+name = "litrs"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "lru"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1dc47f592c06f33f8e3aea9591776ec7c9f9e4124778ff8a3c3b87159f7e593"
+dependencies = [
+ "hashbrown 0.16.1",
+]
+
+[[package]]
+name = "lru-slab"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+
+[[package]]
+name = "lru_time_cache"
+version = "0.11.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9106e1d747ffd48e6be5bb2d97fa706ed25b144fbee4d5c02eae110cd8d6badd"
+
+[[package]]
+name = "lz4_flex"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db9a0d582c2874f68138a16ce1867e0ffde6c0bb0a0df85e1f36d04146db488a"
+dependencies = [
+ "twox-hash",
+]
+
+[[package]]
+name = "mach2"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b"
+
+[[package]]
+name = "macro-string"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59a9dbbfc75d2688ed057456ce8a3ee3f48d12eec09229f560f3643b9f275653"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "maplit"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
+
+[[package]]
+name = "matchit"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
+
+[[package]]
+name = "md-5"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
+dependencies = [
+ "cfg-if",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "memfd"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad38eb12aea514a0466ea40a80fd8cc83637065948eb4a426e4aa46261175227"
+dependencies = [
+ "rustix 1.1.4",
+]
+
+[[package]]
+name = "migrations_internals"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36c791ecdf977c99f45f23280405d7723727470f6689a5e6dbf513ac547ae10d"
+dependencies = [
+ "serde",
+ "toml 0.9.12+spec-1.1.0",
+]
+
+[[package]]
+name = "migrations_macros"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36fc5ac76be324cfd2d3f2cf0fdf5d5d3c4f14ed8aaebadb09e304ba42282703"
+dependencies = [
+ "migrations_internals",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
+dependencies = [
+ "libc",
+ "log",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "multer"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83e87776546dc87511aa5ee218730c92b666d7264ab6ed41f9d215af9cd5224b"
+dependencies = [
+ "bytes",
+ "encoding_rs",
+ "futures-util",
+ "http 1.4.2",
+ "httparse",
+ "memchr",
+ "mime",
+ "spin",
+ "version_check",
+]
+
+[[package]]
+name = "multibase"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b3539ec3c1f04ac9748a260728e855f261b4977f5c3406612c884564f329404"
+dependencies = [
+ "base-x",
+ "data-encoding",
+ "data-encoding-macro",
+]
+
+[[package]]
+name = "multihash"
+version = "0.19.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "577c63b00ad74d57e8c9aa870b5fccebf2fd64a308a5aee9f1bb88e4aea19447"
+dependencies = [
+ "unsigned-varint",
+]
+
+[[package]]
+name = "multimap"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
+
+[[package]]
+name = "native-tls"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework 2.11.0",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "never"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c96aba5aa877601bb3f6dd6a63a969e1f82e60646e81e71b14496995e9853c91"
+
+[[package]]
+name = "nix"
+version = "0.31.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d"
+dependencies = [
+ "bitflags 2.11.1",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "notify"
+version = "8.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d3d07927151ff8575b7087f245456e549fea62edf0ec4e565a5ee50c8402bc3"
+dependencies = [
+ "bitflags 2.11.1",
+ "fsevent-sys",
+ "inotify",
+ "kqueue",
+ "libc",
+ "log",
+ "mio",
+ "notify-types",
+ "walkdir",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "notify-types"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e0826a989adedc2a244799e823aece04662b66609d96af8dff7ac6df9a8925d"
+
+[[package]]
+name = "num-bigint"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "090c7f9998ee0ff65aa5b723e4009f7b217707f1fb5ea551329cc4d6231fb304"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+ "serde",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-modular"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17bb261bf36fa7d83f4c294f834e91256769097b3cb505d44831e0a179ac647f"
+
+[[package]]
+name = "num-order"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "537b596b97c40fcf8056d153049eb22f481c17ebce72a513ec9286e4986d1bb6"
+dependencies = [
+ "num-modular",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+dependencies = [
+ "hermit-abi 0.3.9",
+ "libc",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "nybbles"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5676b5c379cf5b03da1df2b3061c4a4e2aa691086a56ac923e08c143f53f59"
+dependencies = [
+ "alloy-rlp",
+ "arbitrary",
+ "cfg-if",
+ "proptest",
+ "ruint",
  "serde",
- "tiny-keccak 1.5.0",
- "tonic-build",
- "uuid",
+ "smallvec",
+]
+
+[[package]]
+name = "object"
+version = "0.39.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e5a6c098c7a3b6547378093f5cc30bc54fd361ce711e05293a5cc589562739b"
+dependencies = [
+ "crc32fast",
+ "hashbrown 0.17.0",
+ "indexmap 2.14.0",
+ "memchr",
+]
+
+[[package]]
+name = "object_store"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "765784b4390c6bcf80316e5a22f4e3661b639c9d8c83246856643c27d8ce9dbe"
+dependencies = [
+ "async-trait",
+ "aws-lc-rs",
+ "base64",
+ "bytes",
+ "chrono",
+ "form_urlencoded",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "http 1.4.2",
+ "http-body-util",
+ "humantime",
+ "hyper",
+ "itertools 0.15.0",
+ "nix",
+ "parking_lot",
+ "percent-encoding",
+ "quick-xml",
+ "rand 0.10.1",
+ "reqwest 0.13.2",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "url",
+ "walkdir",
+ "wasm-bindgen-futures",
+ "web-time",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "open"
+version = "5.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd8d3b65c44123a56e0133d2cd06ce4361bd3ca99d41198b2f25e3c3db9b8b4a"
+dependencies = [
+ "is-wsl",
+ "libc",
+]
+
+[[package]]
+name = "openssl"
+version = "0.10.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77823a27f0babb03091cb9ed9ef80af3b39dbc82f97e8fa530374b7dafd87a45"
+dependencies = [
+ "bitflags 2.11.1",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+
+[[package]]
+name = "openssl-src"
+version = "300.5.0+3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8ce546f549326b0e6052b649198487d91320875da901e7bd11a06d1ee3f9c2f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b47e7e6bb2c38cd930d25a23b40fa52e068c10e85f3e03a7f5ba5aaca5713695"
+dependencies = [
+ "cc",
+ "libc",
+ "openssl-src",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "parity-scale-codec"
+version = "3.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "306800abfa29c7f16596b5970a588435e3d5b3149683d00c12b699cc19f895ee"
+dependencies = [
+ "arrayvec",
+ "bitvec",
+ "byte-slice-cast",
+ "impl-trait-for-tuples",
+ "parity-scale-codec-derive",
+ "serde",
+]
+
+[[package]]
+name = "parity-scale-codec-derive"
+version = "3.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d830939c76d294956402033aee57a6da7b438f2294eb94864c37b0569053a42c"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "parity-wasm"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1ad0aff30c1da14b1254fcb2af73e1fa9a28670e584a626f53a369d0e157304"
+
+[[package]]
+name = "parking"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall 0.5.2",
+ "smallvec",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "parquet"
+version = "59.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "970dff83e97d953c827ae8176f6bf4e9f77bf62daacc01ec5df348ec5eacd913"
+dependencies = [
+ "ahash",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-schema",
+ "arrow-select",
+ "base64",
+ "brotli",
+ "bytes",
+ "chrono",
+ "flate2",
+ "half",
+ "hashbrown 0.17.0",
+ "lz4_flex",
+ "num-bigint 0.4.6",
+ "num-integer",
+ "num-traits",
+ "paste",
+ "seq-macro",
+ "simdutf8",
+ "snap",
+ "twox-hash",
+ "zstd",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pest"
+version = "2.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd53dff83f26735fdc1ca837098ccf133605d794cdae66acfc2bfac3ec809d95"
+dependencies = [
+ "memchr",
+ "thiserror 1.0.61",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a548d2beca6773b1c244554d36fcf8548a8a58e74156968211567250e48e49a"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c93a82e8d145725dcbaf44e5ea887c8a869efdcc28706df2d08c69e17077183"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a941429fea7e08bedec25e4f6785b6ffaacc6b755da98df5ef3e7dcf4a124c4f"
+dependencies = [
+ "once_cell",
+ "pest",
+ "sha2 0.10.9",
+]
+
+[[package]]
+name = "petgraph"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
+dependencies = [
+ "fixedbitset 0.4.2",
+ "indexmap 2.14.0",
+]
+
+[[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset 0.5.7",
+ "hashbrown 0.15.2",
+ "indexmap 2.14.0",
+ "serde",
+]
+
+[[package]]
+name = "pgtemp"
+version = "0.6.0"
+source = "git+https://github.com/graphprotocol/pgtemp?branch=initdb-args#08a95d441d74ce0a50b6e0a55dbf96d8362d8fb7"
+dependencies = [
+ "libc",
+ "tempfile",
+ "tokio",
+ "url",
+]
+
+[[package]]
+name = "pharos"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9567389417feee6ce15dd6527a8a1ecac205ef62c2932bcf3d9f6fc5b78b414"
+dependencies = [
+ "futures 0.3.31",
+ "rustc_version 0.4.0",
+]
+
+[[package]]
+name = "phf"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
+dependencies = [
+ "phf_shared",
+ "serde",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
+dependencies = [
+ "siphasher",
 ]
 
 [[package]]
-name = "graph-chain-near"
-version = "0.34.0"
+name = "pin-project"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
 dependencies = [
- "anyhow",
- "base64 0.20.0",
- "diesel",
- "graph",
- "graph-runtime-derive",
- "graph-runtime-wasm",
- "prost",
- "prost-types",
- "serde",
- "tonic-build",
- "trigger-filters",
+ "pin-project-internal",
 ]
 
 [[package]]
-name = "graph-chain-starknet"
-version = "0.34.0"
+name = "pin-project-internal"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
 dependencies = [
- "graph",
- "graph-runtime-derive",
- "graph-runtime-wasm",
- "hex",
- "prost",
- "prost-types",
- "serde",
- "sha3",
- "tonic-build",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "graph-chain-substreams"
-version = "0.34.0"
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
 dependencies = [
- "anyhow",
- "async-stream",
- "base64 0.20.0",
- "dirs-next",
- "envconfig",
- "futures 0.1.31",
- "graph",
- "graph-runtime-wasm",
- "hex",
- "http",
- "itertools 0.12.0",
- "jsonrpc-core",
- "lazy_static",
- "prost",
- "prost-types",
- "semver",
+ "der",
+ "spki",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+
+[[package]]
+name = "polling"
+version = "3.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi 0.5.2",
+ "pin-project-lite",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "postcard"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+dependencies = [
+ "cobs",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
  "serde",
- "tiny-keccak 1.5.0",
+]
+
+[[package]]
+name = "postgres"
+version = "0.19.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c48ece1c6cda0db61b058c1721378da76855140e9214339fa1317decacb176"
+dependencies = [
+ "bytes",
+ "fallible-iterator 0.2.0",
+ "futures-util",
+ "log",
  "tokio",
- "tonic-build",
+ "tokio-postgres",
 ]
 
 [[package]]
-name = "graph-core"
-version = "0.34.0"
+name = "postgres-openssl"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06743eefaa1a5c0ef2ccb6d9abf6528790a229eabd62ddcabf9b2a3aeff09fa4"
 dependencies = [
- "anyhow",
- "async-stream",
- "async-trait",
- "atomic_refcell",
+ "openssl",
+ "tokio",
+ "tokio-openssl",
+ "tokio-postgres",
+]
+
+[[package]]
+name = "postgres-protocol"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbef655056b916eb868048276cfd5d6a7dea4f81560dfd047f97c8c6fe3fcfd4"
+dependencies = [
+ "base64",
+ "byteorder",
  "bytes",
- "cid",
- "futures 0.1.31",
- "futures 0.3.16",
- "graph",
- "graph-chain-arweave",
- "graph-chain-cosmos",
- "graph-chain-ethereum",
- "graph-chain-near",
- "graph-chain-starknet",
- "graph-chain-substreams",
- "graph-runtime-wasm",
- "ipfs-api",
- "ipfs-api-backend-hyper",
- "lazy_static",
- "lru_time_cache",
- "semver",
+ "fallible-iterator 0.2.0",
+ "hmac",
+ "md-5",
+ "memchr",
+ "rand 0.9.3",
+ "sha2 0.10.9",
+ "stringprep",
+]
+
+[[package]]
+name = "postgres-types"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef4605b7c057056dd35baeb6ac0c0338e4975b1f2bef0f65da953285eb007095"
+dependencies = [
+ "bytes",
+ "fallible-iterator 0.2.0",
+ "postgres-protocol",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "pq-src"
+version = "0.3.10+libpq-18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56ef39ce621f4993d6084fdcd4cbf1e01c84bdba53109cfad095d2cf441b85b9"
+dependencies = [
+ "cc",
+ "openssl-sys",
+]
+
+[[package]]
+name = "pq-sys"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "574ddd6a267294433f140b02a726b0640c43cf7c6f717084684aaa3b285aba61"
+dependencies = [
+ "libc",
+ "pkg-config",
+ "pq-src",
+ "vcpkg",
+]
+
+[[package]]
+name = "pretty_assertions"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
+dependencies = [
+ "diff",
+ "yansi",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "primitive-types"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2"
+dependencies = [
+ "fixed-hash",
+ "impl-codec",
+ "uint 0.9.5",
+]
+
+[[package]]
+name = "priority-queue"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93980406f12d9f8140ed5abe7155acb10bb1e69ea55c88960b9c2f117445ef96"
+dependencies = [
+ "equivalent",
+ "indexmap 2.14.0",
  "serde",
- "serde_json",
- "serde_yaml",
- "tower 0.4.13 (git+https://github.com/tower-rs/tower.git)",
- "tower-test",
- "uuid",
 ]
 
 [[package]]
-name = "graph-graphql"
-version = "0.34.0"
+name = "proc-macro-crate"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284"
 dependencies = [
- "Inflector",
- "anyhow",
- "async-recursion",
- "crossbeam",
- "graph",
- "graphql-parser",
- "graphql-tools",
- "indexmap 2.1.0",
- "lazy_static",
- "parking_lot 0.12.1",
- "stable-hash 0.3.4",
- "stable-hash 0.4.4",
+ "toml_edit",
 ]
 
 [[package]]
-name = "graph-node"
-version = "0.34.0"
+name = "proc-macro-error-attr2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
 dependencies = [
- "clap",
- "diesel",
- "env_logger 0.10.1",
- "futures 0.3.16",
- "git-testament",
- "graph",
- "graph-chain-arweave",
- "graph-chain-cosmos",
- "graph-chain-ethereum",
- "graph-chain-near",
- "graph-chain-starknet",
- "graph-chain-substreams",
- "graph-core",
- "graph-graphql",
- "graph-runtime-wasm",
- "graph-server-http",
- "graph-server-index-node",
- "graph-server-json-rpc",
- "graph-server-metrics",
- "graph-server-websocket",
- "graph-store-postgres",
- "graphql-parser",
- "http",
- "json-structural-diff",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "proc-macro-error2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+dependencies = [
+ "proc-macro-error-attr2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "proc-macro-utils"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eeaf08a13de400bc215877b5bdc088f241b12eb42f0a548d3390dc1c56bb7071"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "smallvec",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "prometheus"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ca5326d8d0b950a9acd87e6a3f94745394f62e4dae1b1ee22b2bc0c394af43a"
+dependencies = [
+ "cfg-if",
+ "fnv",
  "lazy_static",
- "prometheus",
- "serde",
- "shellexpand",
- "termcolor",
- "url",
+ "libc",
+ "memchr",
+ "parking_lot",
+ "protobuf",
+ "reqwest 0.12.23",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "graph-runtime-derive"
-version = "0.34.0"
+name = "proptest"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee689443a2bd0a16ab0348b52ee43e3b2d1b1f931c8aa5c9f8de4c86fbe8c40"
+dependencies = [
+ "bit-set",
+ "bit-vec",
+ "bitflags 2.11.1",
+ "num-traits",
+ "rand 0.9.3",
+ "rand_chacha 0.9.0",
+ "rand_xorshift",
+ "regex-syntax",
+ "rusty-fork",
+ "tempfile",
+ "unarray",
+]
+
+[[package]]
+name = "proptest-derive"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ee1c9ac207483d5e7db4940700de86a9aae46ef90c48b57f99fe7edb8345e49"
 dependencies = [
- "heck",
  "proc-macro2",
  "quote",
- "syn 1.0.107",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "graph-runtime-test"
-version = "0.34.0"
+name = "proptest-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c57924a81864dddafba92e1bf92f9bf82f97096c44489548a60e888e1547549b"
 dependencies = [
- "graph",
- "graph-chain-ethereum",
- "graph-core",
- "graph-runtime-derive",
- "graph-runtime-wasm",
- "rand",
- "semver",
- "test-store",
- "wasmtime",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "graph-runtime-wasm"
-version = "0.34.0"
+name = "prost"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "528ac67416ff8646872a3c02cad9cc4ee5dc9f9540c9b10771855c95cb2e5ae1"
 dependencies = [
- "anyhow",
- "async-trait",
- "atomic_refcell",
- "bs58",
  "bytes",
- "defer",
- "ethabi",
- "futures 0.1.31",
- "graph",
- "graph-runtime-derive",
- "hex",
- "lazy_static",
- "never",
- "parity-wasm",
- "semver",
- "strum",
- "strum_macros",
- "uuid",
- "wasm-instrument",
- "wasmtime",
+ "prost-derive",
 ]
 
 [[package]]
-name = "graph-server-http"
-version = "0.34.0"
+name = "prost-build"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "343d3bd7056eda839b03204e68deff7d1b13aba7af2b2fd16890697274262ee7"
 dependencies = [
- "futures 0.1.31",
- "graph",
- "graph-core",
- "graph-graphql",
- "graphql-parser",
- "http",
- "hyper",
- "serde",
+ "heck 0.5.0",
+ "itertools 0.13.0",
+ "log",
+ "multimap",
+ "petgraph 0.8.3",
+ "prettyplease",
+ "prost",
+ "prost-types",
+ "pulldown-cmark",
+ "pulldown-cmark-to-cmark",
+ "regex",
+ "syn 2.0.118",
+ "tempfile",
 ]
 
 [[package]]
-name = "graph-server-index-node"
-version = "0.34.0"
+name = "prost-derive"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf"
 dependencies = [
- "blake3 1.5.0",
- "either",
- "futures 0.3.16",
- "git-testament",
- "graph",
- "graph-chain-arweave",
- "graph-chain-cosmos",
- "graph-chain-ethereum",
- "graph-chain-near",
- "graph-chain-starknet",
- "graph-chain-substreams",
- "graph-graphql",
- "graphql-parser",
- "http",
- "hyper",
- "lazy_static",
- "serde",
+ "anyhow",
+ "itertools 0.13.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "graph-server-json-rpc"
-version = "0.34.0"
+name = "prost-types"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f94967dc7688f3054c7fac87473ffae4cc4c3904800e2d9f5b857246d8963b0a"
 dependencies = [
- "graph",
- "jsonrpsee",
- "serde",
+ "prost",
 ]
 
 [[package]]
-name = "graph-server-metrics"
-version = "0.34.0"
+name = "protobuf"
+version = "3.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d65a1d4ddae7d8b5de68153b48f6aa3bba8cb002b243dbdbc55a5afbc98f99f4"
 dependencies = [
- "graph",
- "hyper",
+ "once_cell",
+ "protobuf-support",
+ "thiserror 1.0.61",
 ]
 
 [[package]]
-name = "graph-server-websocket"
-version = "0.34.0"
+name = "protobuf-parse"
+version = "3.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4aeaa1f2460f1d348eeaeed86aea999ce98c1bded6f089ff8514c9d9dbdc973"
 dependencies = [
  "anyhow",
- "futures 0.1.31",
- "graph",
- "graphql-parser",
- "http",
- "lazy_static",
- "serde",
- "serde_derive",
- "tokio-tungstenite",
- "uuid",
+ "indexmap 2.14.0",
+ "log",
+ "protobuf",
+ "protobuf-support",
+ "tempfile",
+ "thiserror 1.0.61",
+ "which",
 ]
 
 [[package]]
-name = "graph-store-postgres"
-version = "0.34.0"
+name = "protobuf-support"
+version = "3.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e36c2f31e0a47f9280fb347ef5e461ffcd2c52dd520d8e216b52f93b0b0d7d6"
 dependencies = [
- "Inflector",
- "anyhow",
- "async-trait",
- "blake3 1.5.0",
- "clap",
- "derive_more",
- "diesel",
- "diesel-derive-enum",
- "diesel-dynamic-schema",
- "diesel_derives",
- "diesel_migrations",
- "fallible-iterator 0.3.0",
- "git-testament",
- "graph",
- "graphql-parser",
- "hex",
- "itertools 0.12.0",
- "lazy_static",
- "lru_time_cache",
- "maybe-owned",
- "openssl",
- "pin-utils",
- "postgres",
- "postgres-openssl",
- "pretty_assertions",
- "rand",
- "serde",
- "stable-hash 0.3.4",
- "uuid",
+ "thiserror 1.0.61",
 ]
 
 [[package]]
-name = "graph-tests"
-version = "0.34.0"
+name = "psm"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5787f7cda34e3033a72192c018bc5883100330f362ef279a8cbccfce8bb4e874"
 dependencies = [
- "anyhow",
- "assert-json-diff",
- "async-stream",
- "futures 0.3.16",
- "graph",
- "graph-chain-ethereum",
- "graph-chain-substreams",
- "graph-core",
- "graph-graphql",
- "graph-node",
- "graph-runtime-wasm",
- "graph-server-index-node",
- "graph-store-postgres",
- "graphql-parser",
- "hyper",
- "secp256k1",
- "serde",
- "serde_yaml",
- "slog",
- "termcolor",
- "tokio",
- "tokio-stream",
+ "cc",
 ]
 
 [[package]]
-name = "graphql-parser"
-version = "0.4.0"
+name = "pulldown-cmark"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2ebc8013b4426d5b81a4364c419a95ed0b404af2b82e2457de52d9348f0e474"
+checksum = "1e8bbe1a966bd2f362681a44f6edce3c2310ac21e4d5067a6e7ec396297a6ea0"
 dependencies = [
- "combine",
- "thiserror",
+ "bitflags 2.11.1",
+ "memchr",
+ "unicase",
 ]
 
 [[package]]
-name = "graphql-tools"
-version = "0.2.1"
+name = "pulldown-cmark-to-cmark"
+version = "22.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bc3a979aca9d796ff03ff71f4013e203a1f69bf1f37899ae4a8e676bb236608"
+checksum = "50793def1b900256624a709439404384204a5dc3a6ec580281bfaac35e882e90"
 dependencies = [
- "graphql-parser",
- "lazy_static",
- "serde",
- "serde_json",
+ "pulldown-cmark",
 ]
 
 [[package]]
-name = "h2"
-version = "0.3.17"
+name = "pulley-interpreter"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66b91535aa35fea1523ad1b86cb6b53c28e0ae566ba4a460f4457e936cad7c6f"
+checksum = "38b92604caae1a1899b6a5b54967289dd538177c626004c91accf9d0ec7e4a12"
 dependencies = [
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http",
- "indexmap 1.9.3",
- "slab",
- "tokio",
- "tokio-util 0.7.1",
- "tracing",
+ "cranelift-bitset",
+ "log",
+ "pulley-macros",
+ "wasmtime-internal-core",
 ]
 
 [[package]]
-name = "hashbrown"
-version = "0.12.1"
+name = "pulley-macros"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db0d4cf898abf0081f964436dc980e96670a0f36863e4b83aaacdb65c9d7ccc3"
+checksum = "5a7ac85c0bb3fb351f10d531230aaa5e366b46d7c4e5328e5f02801d6dac1165"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
 
 [[package]]
-name = "hashbrown"
-version = "0.14.1"
+name = "quick-error"
+version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dfda62a12f55daeae5015f81b0baea145391cb4520f86c248fc615d72640d12"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 
 [[package]]
-name = "hdrhistogram"
-version = "7.5.2"
+name = "quick-xml"
+version = "0.40.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f19b9f54f7c7f55e31401bb647626ce0cf0f67b0004982ce815b3ee72a02aa8"
+checksum = "2474bd2e5029e7ccb6abb2ba48cf2383a333851dedf495901544281590c7da7f"
 dependencies = [
- "byteorder",
- "num-traits",
+ "memchr",
+ "serde",
 ]
 
 [[package]]
-name = "headers"
-version = "0.3.5"
+name = "quinn"
+version = "0.11.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4c4eb0471fcb85846d8b0690695ef354f9afb11cb03cac2e1d7c9253351afb0"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
 dependencies = [
- "base64 0.13.1",
- "bitflags 1.3.1",
  "bytes",
- "headers-core",
- "http",
- "httpdate",
- "mime",
- "sha-1 0.9.7",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash",
+ "rustls",
+ "socket2",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "web-time",
 ]
 
 [[package]]
-name = "headers-core"
-version = "0.2.0"
+name = "quinn-proto"
+version = "0.11.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7f66481bfee273957b1f20485a4ff3362987f85b2c236580d81b4eb7a326429"
+checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
 dependencies = [
- "http",
+ "aws-lc-rs",
+ "bytes",
+ "getrandom 0.3.1",
+ "lru-slab",
+ "rand 0.9.3",
+ "ring",
+ "rustc-hash",
+ "rustls",
+ "rustls-pki-types",
+ "slab",
+ "thiserror 2.0.18",
+ "tinyvec",
+ "tracing",
+ "web-time",
 ]
 
 [[package]]
-name = "heck"
-version = "0.4.1"
+name = "quinn-udp"
+version = "0.5.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+dependencies = [
+ "cfg_aliases",
+ "libc",
+ "once_cell",
+ "socket2",
+ "tracing",
+ "windows-sys 0.60.2",
+]
 
 [[package]]
-name = "hermit-abi"
-version = "0.1.19"
+name = "quote"
+version = "1.0.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
 dependencies = [
- "libc",
+ "proc-macro2",
 ]
 
 [[package]]
-name = "hermit-abi"
-version = "0.3.1"
+name = "r-efi"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
 [[package]]
-name = "hex"
-version = "0.4.3"
+name = "r2d2"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+checksum = "51de85fb3fb6524929c8a2eb85e6b6d363de4e8c48f9e2c2eac4944abc181c93"
 dependencies = [
- "serde",
+ "log",
+ "parking_lot",
+ "scheduled-thread-pool",
 ]
 
 [[package]]
-name = "hex-literal"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
-
-[[package]]
-name = "hex-literal"
-version = "0.4.1"
+name = "radium"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
 [[package]]
-name = "hmac"
-version = "0.10.1"
+name = "rand"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1441c6b1e930e2817404b5046f1f989899143a12bf92de603b69f4e0aee1e15"
+checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"
 dependencies = [
- "crypto-mac 0.10.1",
- "digest 0.9.0",
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+ "serde",
 ]
 
 [[package]]
-name = "http"
-version = "0.2.8"
+name = "rand"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75f43d41e26995c17e71ee126451dd3941010b0514a81a9d11f3b341debc2399"
+checksum = "7ec095654a25171c2124e9e3393a930bddbffdc939556c914957a4c3e0a87166"
 dependencies = [
- "bytes",
- "fnv",
- "itoa",
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
+ "serde",
 ]
 
 [[package]]
-name = "http-body"
-version = "0.4.5"
+name = "rand"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
+checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
 dependencies = [
- "bytes",
- "http",
- "pin-project-lite",
+ "chacha20",
+ "getrandom 0.4.2",
+ "rand_core 0.10.0",
 ]
 
 [[package]]
-name = "http-range-header"
-version = "0.3.0"
+name = "rand_chacha"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bfe8eed0a9285ef776bb792479ea3834e8b94e13d615c2f66d03dd50a435a29"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
 
 [[package]]
-name = "httparse"
-version = "1.7.1"
+name = "rand_chacha"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "496ce29bb5a52785b44e0f7ca2847ae0bb839c9bd28f69acac9b99d461c0c04c"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
+]
 
 [[package]]
-name = "httpdate"
-version = "1.0.1"
+name = "rand_core"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6456b8a6c8f33fee7d958fcd1b60d55b11940a79e63ae87013e6d22e26034440"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.15",
+]
 
 [[package]]
-name = "humantime"
-version = "1.3.0"
+name = "rand_core"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
 dependencies = [
- "quick-error",
+ "getrandom 0.3.1",
+ "serde",
 ]
 
 [[package]]
-name = "humantime"
-version = "2.1.0"
+name = "rand_core"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba"
 
 [[package]]
-name = "hyper"
-version = "0.14.18"
+name = "rand_xorshift"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b26ae0a80afebe130861d90abf98e3814a4f28a4c6ffeb5ab8ebb2be311e0ef2"
+checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
 dependencies = [
- "bytes",
- "futures-channel",
- "futures-core",
- "futures-util",
- "h2",
- "http",
- "http-body",
- "httparse",
- "httpdate",
- "itoa",
- "pin-project-lite",
- "socket2 0.4.9",
- "tokio",
- "tower-service 0.3.1",
- "tracing",
- "want",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
-name = "hyper-multipart-rfc7578"
-version = "0.8.0"
+name = "rapidhash"
+version = "4.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0eb2cf73e96e9925f4bed948e763aa2901c2f1a3a5f713ee41917433ced6671"
+checksum = "5d8b5b858a440a0bc02625b62dd95131b9201aa9f69f411195dd4a7cfb1de3d7"
 dependencies = [
- "bytes",
- "common-multipart-rfc7578",
- "futures-core",
- "http",
- "hyper",
+ "rustversion",
 ]
 
 [[package]]
-name = "hyper-rustls"
-version = "0.23.2"
+name = "rayon"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1788965e61b367cd03a62950836d5cd41560c3577d90e40e0819373194d1661c"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
 dependencies = [
- "http",
- "hyper",
- "log",
- "rustls",
- "rustls-native-certs",
- "tokio",
- "tokio-rustls",
+ "either",
+ "rayon-core",
 ]
 
 [[package]]
-name = "hyper-timeout"
-version = "0.4.1"
+name = "rayon-core"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
 dependencies = [
- "hyper",
- "pin-project-lite",
- "tokio",
- "tokio-io-timeout",
+ "crossbeam-deque",
+ "crossbeam-utils",
 ]
 
 [[package]]
-name = "hyper-tls"
-version = "0.5.0"
+name = "recursive"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
+checksum = "0786a43debb760f491b1bc0269fe5e84155353c67482b9e60d0cfb596054b43e"
 dependencies = [
- "bytes",
- "hyper",
- "native-tls",
- "tokio",
- "tokio-native-tls",
+ "recursive-proc-macro-impl",
+ "stacker",
 ]
 
 [[package]]
-name = "iana-time-zone"
-version = "0.1.47"
+name = "recursive-proc-macro-impl"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c495f162af0bf17656d0014a0eded5f3cd2f365fdd204548c2869db89359dc7"
+checksum = "76009fbe0614077fc1a2ce255e3a1881a2e3a3527097d5dc6d8212c585e7e38b"
 dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "js-sys",
- "once_cell",
- "wasm-bindgen",
- "winapi",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "ibig"
-version = "0.3.5"
+name = "recvmsg"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7d04a53d0ca4a37b47741ff98dd517a0e1e6a0ec22a72c748e50197052d595b"
-dependencies = [
- "cfg-if 1.0.0",
- "num-traits",
- "rand",
- "static_assertions",
-]
+checksum = "d3edd4d5d42c92f0a659926464d4cce56b562761267ecf0f469d85b7de384175"
 
 [[package]]
-name = "idna"
-version = "0.2.3"
+name = "redis"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+checksum = "a12e6b5f4d8ef33944e833e2b1859ad478deab6e431d7337b30ee2efe21f7543"
 dependencies = [
- "matches",
- "unicode-bidi",
- "unicode-normalization",
+ "arc-swap",
+ "arcstr",
+ "async-lock",
+ "backon",
+ "bytes",
+ "cfg-if",
+ "combine",
+ "futures-channel",
+ "futures-util",
+ "itoa",
+ "num-bigint 0.4.6",
+ "percent-encoding",
+ "pin-project-lite",
+ "ryu",
+ "sha1_smol",
+ "socket2",
+ "tokio",
+ "tokio-util",
+ "url",
+ "xxhash-rust",
 ]
 
 [[package]]
-name = "idna"
-version = "0.5.0"
+name = "redox_syscall"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "bitflags 1.3.2",
 ]
 
 [[package]]
-name = "impl-codec"
-version = "0.6.0"
+name = "redox_syscall"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba6a270039626615617f3f36d15fc827041df3b78c439da2cadfa47455a77f2f"
+checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
 dependencies = [
- "parity-scale-codec",
+ "bitflags 2.11.1",
 ]
 
 [[package]]
-name = "impl-rlp"
-version = "0.3.0"
+name = "redox_users"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f28220f89297a075ddc7245cd538076ee98b01f2a9c23a53a4f1105d5a322808"
+checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
 dependencies = [
- "rlp",
+ "getrandom 0.2.15",
+ "libredox",
+ "thiserror 1.0.61",
 ]
 
 [[package]]
-name = "impl-serde"
-version = "0.3.2"
+name = "ref-cast"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4551f042f3438e64dbd6226b20527fc84a6e1fe65688b58746a2f53623f25f5c"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
 dependencies = [
- "serde",
+ "ref-cast-impl",
 ]
 
 [[package]]
-name = "impl-trait-for-tuples"
-version = "0.2.1"
+name = "ref-cast-impl"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5dacb10c5b3bb92d46ba347505a9041e676bb20ad220101326bffb0c93031ee"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.107",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "indexmap"
-version = "1.9.3"
+name = "regalloc2"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+checksum = "de2c52737737f8609e94f975dee22854a2d5c125772d4b1cf292120f4d45c186"
 dependencies = [
- "autocfg",
- "hashbrown 0.12.1",
+ "allocator-api2",
+ "bumpalo",
+ "hashbrown 0.17.0",
+ "log",
+ "rustc-hash",
  "serde",
+ "smallvec",
 ]
 
 [[package]]
-name = "indexmap"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d530e1a18b1cb4c484e6e34556a0d948706958449fca0cab753d649f2bce3d1f"
-dependencies = [
- "equivalent",
- "hashbrown 0.14.1",
-]
-
-[[package]]
-name = "instant"
-version = "0.1.10"
+name = "regex"
+version = "1.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bee0328b1209d157ef001c94dd85b4f8f64139adb0eac2659f4b08382b2f474d"
+checksum = "f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba"
 dependencies = [
- "cfg-if 1.0.0",
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
 ]
 
 [[package]]
-name = "io-lifetimes"
-version = "1.0.9"
+name = "regex-automata"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09270fd4fa1111bc614ed2246c7ef56239a3063d5be0d1ec3b589c505d400aeb"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 dependencies = [
- "hermit-abi 0.3.1",
- "libc",
- "windows-sys 0.45.0",
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
 ]
 
 [[package]]
-name = "ipfs-api"
-version = "0.17.0"
+name = "regex-syntax"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d8cc57cf12ae4af611e53dd04053e1cfb815917c51c410aa30399bf377046ab"
-dependencies = [
- "ipfs-api-backend-hyper",
-]
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
-name = "ipfs-api-backend-hyper"
-version = "0.6.0"
+name = "reqwest"
+version = "0.12.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9d131b408b4caafe1e7c00d410a09ad3eb7e3ab68690cf668e86904b2176b4"
+checksum = "d429f34c8092b2d42c7c93cec323bb4adeb7c67698f70839adec842ec10c7ceb"
 dependencies = [
- "async-trait",
- "base64 0.13.1",
+ "async-compression",
+ "base64",
  "bytes",
- "futures 0.3.16",
- "http",
+ "encoding_rs",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http 1.4.2",
+ "http-body",
+ "http-body-util",
  "hyper",
- "hyper-multipart-rfc7578",
  "hyper-rustls",
- "ipfs-api-prelude",
- "thiserror",
+ "hyper-tls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "mime",
+ "mime_guess",
+ "native-tls",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tokio-native-tls",
+ "tokio-util",
+ "tower 0.5.2",
+ "tower-http 0.6.11",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams 0.4.0",
+ "web-sys",
 ]
 
 [[package]]
-name = "ipfs-api-prelude"
-version = "0.6.0"
+name = "reqwest"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b74065805db266ba2c6edbd670b23c4714824a955628472b2e46cc9f3a869cb"
+checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
 dependencies = [
- "async-trait",
+ "base64",
  "bytes",
- "cfg-if 1.0.0",
- "common-multipart-rfc7578",
- "dirs",
- "futures 0.3.16",
- "http",
- "multiaddr",
- "multibase",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http 1.4.2",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls",
+ "rustls-pki-types",
+ "rustls-platform-verifier",
  "serde",
  "serde_json",
- "serde_urlencoded",
- "thiserror",
+ "sync_wrapper",
  "tokio",
- "tokio-util 0.7.1",
- "tracing",
- "typed-builder",
- "walkdir",
+ "tokio-rustls",
+ "tokio-util",
+ "tower 0.5.2",
+ "tower-http 0.6.11",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams 0.5.0",
+ "web-sys",
 ]
 
 [[package]]
-name = "ipnet"
-version = "2.3.1"
+name = "rfc6979"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68f2d64f2edebec4ce84ad108148e67e1064789bee435edc5b60ad398714a3a9"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac",
+ "subtle",
+]
 
 [[package]]
-name = "is-terminal"
-version = "0.4.6"
+name = "ring"
+version = "0.17.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "256017f749ab3117e93acb91063009e1f1bb56d03965b14c2c8df4eb02c524d8"
+checksum = "70ac5d832aa16abd7d1def883a8545280c20a60f523a370aa3a9617c2b8550ee"
 dependencies = [
- "hermit-abi 0.3.1",
- "io-lifetimes",
- "rustix",
- "windows-sys 0.45.0",
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.15",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "isatty"
-version = "0.1.9"
+name = "rlp"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e31a8281fc93ec9693494da65fbf28c0c2aa60a2eaec25dc58e2f31952e95edc"
+checksum = "bb919243f34364b6bd2fc10ef797edbfa75f33c252e7998527479c6d6b47e1ec"
 dependencies = [
- "cfg-if 0.1.10",
- "libc",
- "redox_syscall 0.1.57",
- "winapi",
+ "bytes",
+ "rustc-hex",
 ]
 
 [[package]]
-name = "itertools"
-version = "0.10.5"
+name = "ruint"
+version = "1.17.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+checksum = "c141e807189ad38a07276942c6623032d3753c8859c146104ac2e4d68865945a"
 dependencies = [
- "either",
+ "alloy-rlp",
+ "arbitrary",
+ "ark-ff 0.3.0",
+ "ark-ff 0.4.2",
+ "ark-ff 0.5.0",
+ "bytes",
+ "fastrlp 0.3.1",
+ "fastrlp 0.4.0",
+ "num-bigint 0.4.6",
+ "num-integer",
+ "num-traits",
+ "parity-scale-codec",
+ "primitive-types",
+ "proptest",
+ "rand 0.8.6",
+ "rand 0.9.3",
+ "rlp",
+ "ruint-macro",
+ "serde_core",
+ "valuable",
+ "zeroize",
 ]
 
 [[package]]
-name = "itertools"
-version = "0.12.0"
+name = "ruint-macro"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48fd7bd8a6377e15ad9d42a8ec25371b94ddc67abe7c8b9127bec79bebaaae18"
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25db6b064527c5d482d0423354fcd07a89a2dfe07b67892e62411946db7f07b0"
-dependencies = [
- "either",
-]
+checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
 
 [[package]]
-name = "itoa"
-version = "1.0.1"
+name = "rustc-hash"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
-name = "jobserver"
-version = "0.1.23"
+name = "rustc-hex"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5ca711fd837261e14ec9e674f092cbb931d3fa1482b017ae59328ddc6f3212b"
-dependencies = [
- "libc",
-]
+checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6"
 
 [[package]]
-name = "js-sys"
-version = "0.3.59"
+name = "rustc_version"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "258451ab10b34f8af53416d1fdab72c22e805f0c92a1136d59470ec0b11138b2"
+checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee"
 dependencies = [
- "wasm-bindgen",
+ "semver 0.11.0",
 ]
 
 [[package]]
-name = "json-structural-diff"
-version = "0.1.0"
+name = "rustc_version"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25c7940d3c84d2079306c176c7b2b37622b6bc5e43fbd1541b1e4a4e1fd02045"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
- "console",
- "difflib",
- "regex",
- "serde_json",
+ "semver 1.0.28",
 ]
 
 [[package]]
-name = "jsonrpc-core"
-version = "18.0.0"
+name = "rustix"
+version = "0.38.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb"
+checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
 dependencies = [
- "futures 0.3.16",
- "futures-executor",
- "futures-util",
- "log",
- "serde",
- "serde_derive",
- "serde_json",
+ "bitflags 2.11.1",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.14",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "jsonrpsee"
-version = "0.15.1"
+name = "rustix"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bd0d559d5e679b1ab2f869b486a11182923863b1b3ee8b421763cdd707b783a"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
- "jsonrpsee-core",
- "jsonrpsee-http-server",
- "jsonrpsee-types",
+ "bitflags 2.11.1",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.12.1",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "jsonrpsee-core"
-version = "0.15.1"
+name = "rustls"
+version = "0.23.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3dc3e9cf2ba50b7b1d7d76a667619f82846caa39e8e8daa8a4962d74acaddca"
+checksum = "6b92b125634d9b795e7beca796cc790df15a7fb38323bf3196fda83292d06b1f"
 dependencies = [
- "anyhow",
- "arrayvec 0.7.4",
- "async-trait",
- "beef",
- "futures-channel",
- "futures-util",
- "globset",
- "http",
- "hyper",
- "jsonrpsee-types",
- "lazy_static",
- "parking_lot 0.12.1",
- "rand",
- "rustc-hash",
- "serde",
- "serde_json",
- "thiserror",
- "tokio",
- "tracing",
- "unicase",
+ "aws-lc-rs",
+ "log",
+ "once_cell",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "jsonrpsee-http-server"
-version = "0.15.1"
+name = "rustls-native-certs"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03802f0373a38c2420c70b5144742d800b509e2937edc4afb116434f07120117"
+checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
 dependencies = [
- "futures-channel",
- "futures-util",
- "hyper",
- "jsonrpsee-core",
- "jsonrpsee-types",
- "serde",
- "serde_json",
- "tokio",
- "tracing",
- "tracing-futures",
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework 3.7.0",
 ]
 
 [[package]]
-name = "jsonrpsee-types"
-version = "0.15.1"
+name = "rustls-pki-types"
+version = "1.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e290bba767401b646812f608c099b922d8142603c9e73a50fb192d3ac86f4a0d"
+checksum = "30a7197ae7eb376e574fe940d068c30fe0462554a3ddbe4eca7838e049c937a9"
 dependencies = [
- "anyhow",
- "beef",
- "serde",
- "serde_json",
- "thiserror",
- "tracing",
+ "web-time",
+ "zeroize",
 ]
 
 [[package]]
-name = "keccak"
-version = "0.1.4"
+name = "rustls-platform-verifier"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940"
+checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
 dependencies = [
- "cpufeatures 0.2.2",
+ "core-foundation 0.10.0",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki",
+ "security-framework 3.7.0",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "lazy_static"
-version = "1.4.0"
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
-name = "leb128"
-version = "0.2.4"
+name = "rustls-webpki"
+version = "0.103.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3576a87f2ba00f6f106fdfcd16db1d698d648a26ad8e0573cad8537c3c362d2a"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+dependencies = [
+ "aws-lc-rs",
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
 
 [[package]]
-name = "libc"
-version = "0.2.150"
+name = "rustversion"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c"
+checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
 
 [[package]]
-name = "linux-raw-sys"
+name = "rusty-fork"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d59d8c75012853d2e872fb56bc8a2e53718e2cafe1a4c823143141c6d90c322f"
-
-[[package]]
-name = "lock_api"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b"
+checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2"
 dependencies = [
- "scopeguard",
-]
-
-[[package]]
-name = "log"
-version = "0.4.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
-dependencies = [
- "cfg-if 1.0.0",
+ "fnv",
+ "quick-error",
+ "tempfile",
+ "wait-timeout",
 ]
 
 [[package]]
-name = "lru_time_cache"
-version = "0.11.11"
+name = "ryu"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9106e1d747ffd48e6be5bb2d97fa706ed25b144fbee4d5c02eae110cd8d6badd"
+checksum = "a50f4cf475b65d88e057964e0e9bb1f0aa9bbb2036dc65c64596b42932536984"
 
 [[package]]
-name = "mach"
-version = "0.3.2"
+name = "same-file"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
 dependencies = [
- "libc",
+ "winapi-util",
 ]
 
 [[package]]
-name = "maplit"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
-
-[[package]]
-name = "matches"
-version = "0.1.8"
+name = "schannel"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
+checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
+dependencies = [
+ "windows-sys 0.52.0",
+]
 
 [[package]]
-name = "matchit"
-version = "0.7.0"
+name = "scheduled-thread-pool"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b87248edafb776e59e6ee64a79086f65890d3510f2c656c000bf2a7e8a0aea40"
+checksum = "3cbc66816425a074528352f5789333ecff06ca41b36b0b0efdfbb29edc391a19"
+dependencies = [
+ "parking_lot",
+]
 
 [[package]]
-name = "maybe-owned"
-version = "0.3.4"
+name = "schemars"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4facc753ae494aeb6e3c22f839b158aebd4f9270f55cd3c79906c45476c47ab4"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
 
 [[package]]
-name = "md-5"
-version = "0.9.1"
+name = "schemars"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b5a279bb9607f9f53c22d496eade00d138d1bdcccd07d74650387cf94942a15"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
 dependencies = [
- "block-buffer 0.9.0",
- "digest 0.9.0",
- "opaque-debug",
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "memchr"
-version = "2.5.0"
+name = "scopeguard"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
-name = "memoffset"
-version = "0.6.4"
+name = "sec1"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
 dependencies = [
- "autocfg",
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "serdect",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "migrations_internals"
-version = "1.4.1"
+name = "secp256k1"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b4fc84e4af020b837029e017966f86a1c2d5e83e64b589963d5047525995860"
+checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
 dependencies = [
- "diesel",
+ "bitcoin_hashes",
+ "rand 0.8.6",
+ "secp256k1-sys 0.10.1",
+ "serde",
 ]
 
 [[package]]
-name = "migrations_macros"
-version = "1.4.2"
+name = "secp256k1"
+version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9753f12909fd8d923f75ae5c3258cae1ed3c8ec052e1b38c93c21a6d157f789c"
+checksum = "2c3c81b43dc2d8877c216a3fccf76677ee1ebccd429566d3e67447290d0c42b2"
 dependencies = [
- "migrations_internals",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "bitcoin_hashes",
+ "rand 0.9.3",
+ "secp256k1-sys 0.11.0",
 ]
 
 [[package]]
-name = "mime"
-version = "0.3.16"
+name = "secp256k1-sys"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
+checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
+dependencies = [
+ "cc",
+]
 
 [[package]]
-name = "mime_guess"
-version = "2.0.3"
+name = "secp256k1-sys"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2684d4c2e97d99848d30b324b00c8fcc7e5c897b7cbb5819b09e7c90e8baf212"
+checksum = "dcb913707158fadaf0d8702c2db0e857de66eb003ccfdda5924b5f5ac98efb38"
 dependencies = [
- "mime",
- "unicase",
+ "cc",
 ]
 
 [[package]]
-name = "miniz_oxide"
-version = "0.4.4"
+name = "security-framework"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
+checksum = "c627723fd09706bacdb5cf41499e95098555af3c3c29d014dc3c458ef6be11c0"
 dependencies = [
- "adler",
- "autocfg",
+ "bitflags 2.11.1",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
 ]
 
 [[package]]
-name = "miniz_oxide"
-version = "0.6.2"
+name = "security-framework"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
- "adler",
+ "bitflags 2.11.1",
+ "core-foundation 0.10.0",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
 ]
 
 [[package]]
-name = "mio"
-version = "0.8.9"
+name = "security-framework-sys"
+version = "2.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dce281c5e46beae905d4de1870d8b1509a9142b62eedf18b443b011ca8343d0"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
 dependencies = [
+ "core-foundation-sys",
  "libc",
- "wasi",
- "windows-sys 0.48.0",
 ]
 
 [[package]]
-name = "more-asserts"
-version = "0.2.1"
+name = "semver"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0debeb9fcf88823ea64d64e4a815ab1643f33127d995978e099942ce38f25238"
+checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
+dependencies = [
+ "semver-parser",
+]
 
 [[package]]
-name = "multiaddr"
-version = "0.17.1"
+name = "semver"
+version = "1.0.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b36f567c7099511fa8612bbbb52dda2419ce0bdbacf31714e3a5ffdb766d3bd"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 dependencies = [
- "arrayref",
- "byteorder",
- "data-encoding",
- "log",
- "multibase",
- "multihash 0.17.0",
- "percent-encoding",
  "serde",
- "static_assertions",
- "unsigned-varint 0.7.1",
- "url",
+ "serde_core",
 ]
 
 [[package]]
-name = "multibase"
-version = "0.9.1"
+name = "semver-parser"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b3539ec3c1f04ac9748a260728e855f261b4977f5c3406612c884564f329404"
+checksum = "9900206b54a3527fdc7b8a938bffd94a568bac4f4aa8113b209df75a09c0dec2"
 dependencies = [
- "base-x",
- "data-encoding",
- "data-encoding-macro",
+ "pest",
 ]
 
 [[package]]
-name = "multihash"
-version = "0.17.0"
+name = "send_wrapper"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "835d6ff01d610179fbce3de1694d007e500bf33a7f29689838941d6bf783ae40"
-dependencies = [
- "core2",
- "multihash-derive",
- "unsigned-varint 0.7.1",
-]
+checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
 
 [[package]]
-name = "multihash"
-version = "0.19.1"
+name = "seq-macro"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "076d548d76a0e2a0d4ab471d0b1c36c577786dfc4471242035d97a12a735c492"
-dependencies = [
- "core2",
- "unsigned-varint 0.7.1",
-]
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
 
 [[package]]
-name = "multihash-derive"
-version = "0.8.0"
+name = "serde"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc076939022111618a5026d3be019fd8b366e76314538ff9a1b59ffbcbf98bcd"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
- "proc-macro-crate",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
- "synstructure",
+ "serde_core",
+ "serde_derive",
 ]
 
 [[package]]
-name = "multimap"
-version = "0.8.3"
+name = "serde_core"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
 
 [[package]]
-name = "native-tls"
-version = "0.2.11"
+name = "serde_derive"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
- "lazy_static",
- "libc",
- "log",
- "openssl",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "security-framework",
- "security-framework-sys",
- "tempfile",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "never"
-version = "0.1.0"
+name = "serde_json"
+version = "1.0.150"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c96aba5aa877601bb3f6dd6a63a969e1f82e60646e81e71b14496995e9853c91"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
 
 [[package]]
-name = "num-bigint"
-version = "0.2.6"
+name = "serde_path_to_error"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "090c7f9998ee0ff65aa5b723e4009f7b217707f1fb5ea551329cc4d6231fb304"
+checksum = "af99884400da37c88f5e9146b7f1fd0fbcae8f6eec4e9da38b67d05486f814a6"
 dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
+ "itoa",
  "serde",
 ]
 
 [[package]]
-name = "num-bigint"
-version = "0.4.4"
+name = "serde_plain"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+checksum = "9ce1fc6db65a611022b23a0dec6975d63fb80a302cb3388835ff02c097258d50"
 dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
+ "serde",
 ]
 
 [[package]]
-name = "num-integer"
-version = "0.1.45"
+name = "serde_regex"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+checksum = "bafc8d0c5330cecff10f16b459b479fd9acaa5b4acd7167301414e21b0057012"
 dependencies = [
- "autocfg",
- "num-traits",
+ "regex",
+ "serde",
 ]
 
 [[package]]
-name = "num-traits"
-version = "0.2.17"
+name = "serde_spanned"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
 dependencies = [
- "autocfg",
+ "serde_core",
 ]
 
 [[package]]
-name = "num_cpus"
-version = "1.16.0"
+name = "serde_urlencoded"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
 dependencies = [
- "hermit-abi 0.3.1",
- "libc",
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
 ]
 
 [[package]]
-name = "object"
-version = "0.24.0"
+name = "serde_with"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a5b3dd1c072ee7963717671d1ca129f1048fda25edea6b752bfc71ac8854170"
+checksum = "76a5c54c7310e7b8b9577c286d7e399ddd876c3e12b3ed917a8aabc4b96e9e8c"
 dependencies = [
- "crc32fast",
+ "base64",
+ "bs58 0.5.1",
+ "chrono",
+ "hex",
  "indexmap 1.9.3",
+ "indexmap 2.14.0",
+ "schemars 0.9.0",
+ "schemars 1.2.1",
+ "serde_core",
+ "serde_json",
+ "serde_with_macros",
+ "time",
 ]
 
 [[package]]
-name = "object"
-version = "0.26.0"
+name = "serde_with_macros"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c55827317fb4c08822499848a14237d2874d6f139828893017237e7ab93eb386"
+checksum = "84d57bc0c8b9a17920c178daa6bb924850d54a9c97ab45194bb8c17ad66bb660"
 dependencies = [
- "memchr",
+ "darling 0.23.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "once_cell"
-version = "1.13.1"
+name = "serde_yaml"
+version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "074864da206b4973b84eb91683020dbefd6a8c3f0f38e054d93954e891935e4e"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap 2.14.0",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
 
 [[package]]
-name = "opaque-debug"
-version = "0.3.0"
+name = "serdect"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
+checksum = "a84f14a19e9a014bb9f4512488d9829a68e04ecabffb0f9904cd1ace94598177"
+dependencies = [
+ "base16ct",
+ "serde",
+]
 
 [[package]]
-name = "openssl"
-version = "0.10.60"
+name = "sha1"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79a4c6c3a2b158f7f8f2a2fc5a969fa3a068df6fc9dbb4a43845436e3af7c800"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 dependencies = [
- "bitflags 2.4.0",
- "cfg-if 1.0.0",
- "foreign-types",
- "libc",
- "once_cell",
- "openssl-macros",
- "openssl-sys",
+ "cfg-if",
+ "cpufeatures 0.2.12",
+ "digest 0.10.7",
 ]
 
 [[package]]
-name = "openssl-macros"
-version = "0.1.0"
+name = "sha1"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b501e44f11665960c7e7fcf062c7d96a14ade4aa98116c004b2e37b5be7d736c"
+checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "digest 0.11.2",
 ]
 
 [[package]]
-name = "openssl-probe"
-version = "0.1.4"
+name = "sha1_smol"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a"
+checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d"
 
 [[package]]
-name = "openssl-sys"
-version = "0.9.96"
+name = "sha2"
+version = "0.10.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3812c071ba60da8b5677cc12bcb1d42989a65553772897a7e0355545a819838f"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
+ "cfg-if",
+ "cpufeatures 0.2.12",
+ "digest 0.10.7",
 ]
 
 [[package]]
-name = "os_str_bytes"
-version = "6.0.0"
+name = "sha2"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "digest 0.11.2",
+]
 
 [[package]]
-name = "pad"
-version = "0.1.6"
+name = "sha3"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2ad9b889f1b12e0b9ee24db044b5129150d5eada288edc800f789928dc8c0e3"
+checksum = "be176f1a57ce4e3d31c1a166222d9768de5954f811601fb7ca06fc8203905ce1"
 dependencies = [
- "unicode-width",
+ "digest 0.11.2",
+ "keccak",
 ]
 
 [[package]]
-name = "parity-scale-codec"
-version = "3.0.0"
+name = "sha3-asm"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a7f3fcf5e45fc28b84dcdab6b983e77f197ec01f325a33f404ba6855afd1070"
+checksum = "9f3f15d4e239ebe08413eed880e0f9b5af4b40ee0472543320efa91d488e96a7"
 dependencies = [
- "arrayvec 0.7.4",
- "bitvec",
- "byte-slice-cast",
- "impl-trait-for-tuples",
- "parity-scale-codec-derive",
- "serde",
+ "cc",
+ "cfg-if",
 ]
 
 [[package]]
-name = "parity-scale-codec-derive"
-version = "3.0.0"
+name = "shellexpand"
+version = "3.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6e626dc84025ff56bf1476ed0e30d10c84d7f89a475ef46ebabee1095a8fba"
+checksum = "32824fab5e16e6c4d86dc1ba84489390419a39f97699852b66480bb87d297ed8"
 dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "dirs",
 ]
 
 [[package]]
-name = "parity-wasm"
-version = "0.45.0"
+name = "shlex"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1ad0aff30c1da14b1254fcb2af73e1fa9a28670e584a626f53a369d0e157304"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
-name = "parking_lot"
-version = "0.11.2"
+name = "signal-hook"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
 dependencies = [
- "instant",
- "lock_api",
- "parking_lot_core 0.8.5",
+ "libc",
+ "signal-hook-registry",
 ]
 
 [[package]]
-name = "parking_lot"
-version = "0.12.1"
+name = "signal-hook-mio"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
 dependencies = [
- "lock_api",
- "parking_lot_core 0.9.1",
+ "libc",
+ "mio",
+ "signal-hook",
 ]
 
 [[package]]
-name = "parking_lot_core"
-version = "0.8.5"
+name = "signal-hook-registry"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216"
+checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
 dependencies = [
- "cfg-if 1.0.0",
- "instant",
  "libc",
- "redox_syscall 0.2.10",
- "smallvec",
- "winapi",
 ]
 
 [[package]]
-name = "parking_lot_core"
-version = "0.9.1"
+name = "signature"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28141e0cc4143da2443301914478dc976a61ffdb3f043058310c70df2fed8954"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
 dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "redox_syscall 0.2.10",
- "smallvec",
- "windows-sys 0.32.0",
+ "digest 0.10.7",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
-name = "paste"
-version = "1.0.5"
+name = "simd-adler32"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acbf547ad0c65e31259204bd90935776d1c693cec2f4ff7abb7a1bbbd40dfe58"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
 [[package]]
-name = "percent-encoding"
-version = "2.3.1"
+name = "simdutf8"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
 [[package]]
-name = "petgraph"
-version = "0.6.4"
+name = "similar"
+version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
+checksum = "e6505efef05804732ed8a3f2d4f279429eb485bd69d5b0cc6b19cc02005cda16"
 dependencies = [
- "fixedbitset",
- "indexmap 2.1.0",
+ "bstr",
 ]
 
 [[package]]
-name = "phf"
-version = "0.8.0"
+name = "siphasher"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12"
-dependencies = [
- "phf_shared",
-]
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
-name = "phf_shared"
-version = "0.8.0"
+name = "slab"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
 dependencies = [
- "siphasher",
+ "autocfg",
 ]
 
 [[package]]
-name = "pin-project"
-version = "1.0.12"
+name = "slog"
+version = "2.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad29a609b6bcd67fee905812e544992d216af9d755757c05ed2d0e15a74c6ecc"
+checksum = "9b3b8565691b22d2bdfc066426ed48f837fc0c5f2c8cad8d9718f7f99d6995c1"
 dependencies = [
- "pin-project-internal",
+ "anyhow",
+ "erased-serde",
+ "rustversion",
+ "serde_core",
 ]
 
 [[package]]
-name = "pin-project-internal"
-version = "1.0.12"
+name = "slog-async"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "069bdb1e05adc7a8990dce9cc75370895fbe4e3d58b9b73bf1aee56359344a55"
+checksum = "72c8038f898a2c79507940990f05386455b3a317d8f18d4caea7cbc3d5096b84"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "crossbeam-channel",
+ "slog",
+ "take_mut",
+ "thread_local",
 ]
 
 [[package]]
-name = "pin-project-lite"
-version = "0.2.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12cc1b0bf1727a77a54b6654e7b5f1af8604923edc8b81885f8ec92f9e3f0a05"
-
-[[package]]
-name = "pin-utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
-
-[[package]]
-name = "pkg-config"
-version = "0.3.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c"
-
-[[package]]
-name = "postgres"
-version = "0.19.1"
+name = "slog-envlogger"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7871ee579860d8183f542e387b176a25f2656b9fb5211e045397f745a68d1c2"
+checksum = "906a1a0bc43fed692df4b82a5e2fbfc3733db8dad8bb514ab27a4f23ad04f5c0"
 dependencies = [
- "bytes",
- "fallible-iterator 0.2.0",
- "futures 0.3.16",
  "log",
- "tokio",
- "tokio-postgres",
+ "regex",
+ "slog",
+ "slog-async",
+ "slog-scope",
+ "slog-stdlog",
+ "slog-term",
 ]
 
 [[package]]
-name = "postgres-openssl"
-version = "0.5.0"
+name = "slog-scope"
+version = "4.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1de0ea6504e07ca78355a6fb88ad0f36cafe9e696cbc6717f16a207f3a60be72"
+checksum = "2f95a4b4c3274cd2869549da82b57ccc930859bdbf5bcea0424bc5f140b3c786"
 dependencies = [
- "futures 0.3.16",
- "openssl",
- "tokio",
- "tokio-openssl",
- "tokio-postgres",
+ "arc-swap",
+ "lazy_static",
+ "slog",
 ]
 
 [[package]]
-name = "postgres-protocol"
-version = "0.6.1"
+name = "slog-stdlog"
+version = "4.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff3e0f70d32e20923cabf2df02913be7c1842d4c772db8065c00fcfdd1d1bff3"
+checksum = "6706b2ace5bbae7291d3f8d2473e2bfab073ccd7d03670946197aec98471fa3e"
 dependencies = [
- "base64 0.13.1",
- "byteorder",
- "bytes",
- "fallible-iterator 0.2.0",
- "hmac",
- "md-5",
- "memchr",
- "rand",
- "sha2 0.9.5",
- "stringprep",
+ "log",
+ "slog",
+ "slog-scope",
 ]
 
 [[package]]
-name = "postgres-types"
-version = "0.2.1"
+name = "slog-term"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "430f4131e1b7657b0cd9a2b0c3408d77c9a43a042d300b8c77f981dffcc43a2f"
+checksum = "b6e022d0b998abfe5c3782c1f03551a596269450ccd677ea51c56f8b214610e8"
 dependencies = [
- "bytes",
- "fallible-iterator 0.2.0",
- "postgres-protocol",
+ "is-terminal",
+ "slog",
+ "term",
+ "thread_local",
+ "time",
 ]
 
 [[package]]
-name = "ppv-lite86"
-version = "0.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
-
-[[package]]
-name = "pq-sys"
-version = "0.4.6"
+name = "smallvec"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ac25eee5a0582f45a67e837e350d784e7003bd29a5f460796772061ca49ffda"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 dependencies = [
- "vcpkg",
+ "arbitrary",
+ "serde",
 ]
 
 [[package]]
-name = "pretty_assertions"
-version = "1.4.0"
+name = "snap"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
-dependencies = [
- "diff",
- "yansi",
-]
+checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b"
 
 [[package]]
-name = "prettyplease"
-version = "0.1.10"
+name = "socket2"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9e07e3a46d0771a8a06b5f4441527802830b43e679ba12f44960f48dd4c6803"
+checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807"
 dependencies = [
- "proc-macro2",
- "syn 1.0.107",
+ "libc",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
-name = "primitive-types"
-version = "0.11.1"
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+
+[[package]]
+name = "spki"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e28720988bff275df1f51b171e1b2a18c30d194c4d2b61defdacecd625a5d94a"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
 dependencies = [
- "fixed-hash",
- "impl-codec",
- "impl-rlp",
- "impl-serde",
- "uint 0.9.1",
+ "base64ct",
+ "der",
 ]
 
 [[package]]
-name = "priority-queue"
-version = "0.7.0"
+name = "sqlparser"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a03dfae8e64d4aa651415e2a4321f9f09f2e388a2f8bec36bed03bc22c0b687"
+checksum = "07c5f081b292a3d19637f0b32a79e28ff14a9fd23ef47bd7fce08ff5de221eca"
 dependencies = [
- "indexmap 1.9.3",
- "take_mut",
+ "log",
+ "recursive",
+ "sqlparser_derive 0.3.0",
 ]
 
 [[package]]
-name = "proc-macro-crate"
-version = "1.1.0"
+name = "sqlparser"
+version = "0.62.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ebace6889caf889b4d3f76becee12e90353f2b8c7d875534a71e5742f8f6f83"
+checksum = "13c6d1b651dc4edf07eead2a0c6c78016ce971bc2c10da5266861b13f25e7cec"
 dependencies = [
- "thiserror",
- "toml 0.5.11",
+ "log",
+ "recursive",
+ "sqlparser_derive 0.5.0",
 ]
 
 [[package]]
-name = "proc-macro-error"
-version = "1.0.4"
+name = "sqlparser_derive"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+checksum = "da5fc6819faabb412da764b99d3b713bb55083c11e7e0c00144d386cd6a1939c"
 dependencies = [
- "proc-macro-error-attr",
  "proc-macro2",
  "quote",
- "syn 1.0.107",
- "version_check",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "proc-macro-error-attr"
-version = "1.0.4"
+name = "sqlparser_derive"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+checksum = "a6dd45d8fc1c79299bfbb7190e42ccbbdf6a5f52e4a6ad98d92357ea965bd289"
 dependencies = [
  "proc-macro2",
  "quote",
- "version_check",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "proc-macro2"
-version = "1.0.76"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c"
+name = "stable-hash"
+version = "0.3.4"
+source = "git+https://github.com/graphprotocol/stable-hash?rev=42b85d936c6b9f1b7a4b8385d2f081d5564daa69#42b85d936c6b9f1b7a4b8385d2f081d5564daa69"
 dependencies = [
- "unicode-ident",
+ "blake3",
+ "firestorm 0.4.6",
+ "ibig",
+ "lazy_static",
+ "leb128",
+ "num-traits",
 ]
 
 [[package]]
-name = "prometheus"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "449811d15fbdf5ceb5c1144416066429cf82316e2ec8ce0c1f6f8a02e7bbcf8c"
+name = "stable-hash"
+version = "0.4.4"
+source = "git+https://github.com/graphprotocol/stable-hash?rev=70300f974e61529675aef3f20803f26a23f0e0ea#70300f974e61529675aef3f20803f26a23f0e0ea"
 dependencies = [
- "cfg-if 1.0.0",
- "fnv",
+ "blake3",
+ "firestorm 0.5.1",
+ "ibig",
  "lazy_static",
- "libc",
- "memchr",
- "parking_lot 0.12.1",
- "protobuf 2.25.0",
- "reqwest",
- "thiserror",
+ "leb128",
+ "num-traits",
+ "uint 0.10.1",
+ "xxhash-rust",
 ]
 
 [[package]]
-name = "prost"
-version = "0.11.9"
+name = "stable_deref_trait"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd"
-dependencies = [
- "bytes",
- "prost-derive",
-]
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
-name = "prost-build"
-version = "0.11.5"
+name = "stacker"
+version = "0.1.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb5320c680de74ba083512704acb90fe00f28f79207286a848e730c45dd73ed6"
+checksum = "e1f8b29fb42aafcea4edeeb6b2f2d7ecd0d969c48b4cf0d2e64aafc471dd6e59"
 dependencies = [
- "bytes",
- "heck",
- "itertools 0.10.5",
- "lazy_static",
- "log",
- "multimap",
- "petgraph",
- "prettyplease",
- "prost",
- "prost-types",
- "regex",
- "syn 1.0.107",
- "tempfile",
- "which",
+ "cc",
+ "cfg-if",
+ "libc",
+ "psm",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
-name = "prost-derive"
-version = "0.11.9"
+name = "static_assertions"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4"
-dependencies = [
- "anyhow",
- "itertools 0.10.5",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
-name = "prost-types"
-version = "0.11.9"
+name = "static_assertions_next"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7beae5182595e9a8b683fa98c4317f956c9a2dec3b9716990d20023cc60c766"
+
+[[package]]
+name = "stringprep"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "213622a1460818959ac1181aaeb2dc9c7f63df720db7d788b3e24eacd1983e13"
+checksum = "7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1"
 dependencies = [
- "prost",
+ "unicode-bidi",
+ "unicode-normalization",
+ "unicode-properties",
 ]
 
 [[package]]
-name = "protobuf"
-version = "2.25.0"
+name = "strsim"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "020f86b07722c5c4291f7c723eac4676b3892d47d9a7708dc2779696407f039b"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
-name = "protobuf"
-version = "3.3.0"
+name = "strum"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b65f4a8ec18723a734e5dc09c173e0abf9690432da5340285d536edcb4dac190"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
 dependencies = [
- "once_cell",
- "protobuf-support",
- "thiserror",
+ "strum_macros 0.27.2",
 ]
 
 [[package]]
-name = "protobuf-parse"
-version = "3.3.0"
+name = "strum"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77d6fbd6697c9e531873e81cec565a85e226b99a0f10e1acc079be057fe2fcba"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
 dependencies = [
- "anyhow",
- "indexmap 1.9.3",
- "log",
- "protobuf 3.3.0",
- "protobuf-support",
- "tempfile",
- "thiserror",
- "which",
+ "strum_macros 0.28.0",
 ]
 
 [[package]]
-name = "protobuf-support"
-version = "3.3.0"
+name = "strum_macros"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6872f4d4f4b98303239a2b5838f5bbbb77b01ffc892d627957f37a22d7cfe69c"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
 dependencies = [
- "thiserror",
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "psm"
-version = "0.1.14"
+name = "strum_macros"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14ce37fa8c0428a37307d163292add09b3aedc003472e6b3622486878404191d"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
 dependencies = [
- "cc",
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "quick-error"
-version = "1.2.3"
+name = "subtle"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
-name = "quote"
-version = "1.0.35"
+name = "syn"
+version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
 dependencies = [
  "proc-macro2",
+ "quote",
+ "unicode-ident",
 ]
 
 [[package]]
-name = "r2d2"
-version = "0.8.9"
+name = "syn"
+version = "2.0.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "545c5bc2b880973c9c10e4067418407a0ccaa3091781d1671d46eb35107cb26f"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
 dependencies = [
- "log",
- "parking_lot 0.11.2",
- "scheduled-thread-pool",
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
 ]
 
 [[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
+name = "syn-solidity"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+checksum = "ec005042c7d952febc1a3ef5b0f6674e9054aa836877a31c90b20e25b3d31744"
 dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
+ "paste",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "rand_chacha"
-version = "0.3.1"
+name = "sync_wrapper"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
 dependencies = [
- "ppv-lite86",
- "rand_core",
+ "futures-core",
 ]
 
 [[package]]
-name = "rand_core"
-version = "0.6.3"
+name = "synstructure"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
- "getrandom",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "rayon"
-version = "1.5.1"
+name = "system-configuration"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
+checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
 dependencies = [
- "autocfg",
- "crossbeam-deque",
- "either",
- "rayon-core",
+ "bitflags 2.11.1",
+ "core-foundation 0.9.4",
+ "system-configuration-sys",
 ]
 
 [[package]]
-name = "rayon-core"
-version = "1.9.1"
+name = "system-configuration-sys"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
 dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-utils",
- "lazy_static",
- "num_cpus",
+ "core-foundation-sys",
+ "libc",
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.1.57"
+name = "take_mut"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
+checksum = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60"
 
 [[package]]
-name = "redox_syscall"
-version = "0.2.10"
+name = "tap"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
-dependencies = [
- "bitflags 1.3.1",
-]
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
-name = "redox_users"
-version = "0.4.0"
+name = "target-lexicon"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"
-dependencies = [
- "getrandom",
- "redox_syscall 0.2.10",
-]
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
-name = "regalloc"
-version = "0.0.31"
+name = "tempfile"
+version = "3.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "571f7f397d61c4755285cd37853fe8e03271c243424a907415909379659381c5"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
- "log",
- "rustc-hash",
- "serde",
- "smallvec",
+ "fastrand",
+ "getrandom 0.4.2",
+ "once_cell",
+ "rustix 1.1.4",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "regex"
-version = "1.5.5"
+name = "term"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a11647b6b25ff05a515cb92c365cec08801e83423a235b51e231e1808747286"
+checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
 dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
+ "dirs-next",
+ "rustversion",
+ "winapi",
 ]
 
 [[package]]
-name = "regex-syntax"
-version = "0.6.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
-
-[[package]]
-name = "region"
-version = "2.2.0"
+name = "termcolor"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877e54ea2adcd70d80e9179344c97f93ef0dffd6b03e1f4529e6e83ab2fa9ae0"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
 dependencies = [
- "bitflags 1.3.1",
- "libc",
- "mach",
- "winapi",
+ "winapi-util",
 ]
 
 [[package]]
-name = "remove_dir_all"
-version = "0.5.3"
+name = "terminal_size"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7"
 dependencies = [
- "winapi",
+ "rustix 0.38.34",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
-name = "reqwest"
-version = "0.11.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cde824a14b7c14f85caff81225f411faacc04a2013f41670f41443742b1c1c55"
+name = "test-store"
+version = "0.45.0"
 dependencies = [
- "base64 0.21.0",
- "bytes",
- "encoding_rs",
- "futures-core",
- "futures-util",
- "h2",
- "http",
- "http-body",
- "hyper",
- "hyper-tls",
- "ipnet",
- "js-sys",
- "log",
- "mime",
- "mime_guess",
- "native-tls",
- "once_cell",
- "percent-encoding",
- "pin-project-lite",
- "serde",
+ "async-trait",
+ "diesel",
+ "diesel-async",
+ "graph",
+ "graph-chain-ethereum",
+ "graph-graphql",
+ "graph-node",
+ "graph-store-postgres",
+ "hex",
+ "hex-literal",
+ "lazy_static",
+ "pretty_assertions",
+ "prost-types",
  "serde_json",
- "serde_urlencoded",
  "tokio",
- "tokio-native-tls",
- "tokio-util 0.7.1",
- "tower-service 0.3.1",
- "url",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-streams",
- "web-sys",
- "winreg",
 ]
 
 [[package]]
-name = "ring"
-version = "0.16.20"
+name = "thiserror"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
 dependencies = [
- "cc",
- "libc",
- "once_cell",
- "spin",
- "untrusted",
- "web-sys",
- "winapi",
+ "thiserror-impl 1.0.61",
 ]
 
 [[package]]
-name = "rlp"
-version = "0.5.1"
+name = "thiserror"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "999508abb0ae792aabed2460c45b89106d97fe4adac593bdaef433c2605847b5"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
 dependencies = [
- "bytes",
- "rustc-hex",
+ "thiserror-impl 2.0.18",
 ]
 
 [[package]]
-name = "rustc-demangle"
-version = "0.1.20"
+name = "thiserror-impl"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dead70b0b5e03e9c814bcb6b01e03e68f7c57a80aa48c72ec92152ab3e818d49"
+checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
 
 [[package]]
-name = "rustc-hash"
-version = "1.1.0"
+name = "thiserror-impl"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
 
 [[package]]
-name = "rustc-hex"
-version = "2.1.0"
+name = "thread_local"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6"
+checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+]
 
 [[package]]
-name = "rustc_version"
-version = "0.4.0"
+name = "threadpool"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
 dependencies = [
- "semver",
+ "num_cpus",
 ]
 
 [[package]]
-name = "rustix"
-version = "0.37.7"
+name = "time"
+version = "0.3.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aae838e49b3d63e9274e1c01833cc8139d3fec468c3b84688c628f44b1ae11d"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
 dependencies = [
- "bitflags 1.3.1",
- "errno 0.3.0",
- "io-lifetimes",
- "libc",
- "linux-raw-sys",
- "windows-sys 0.45.0",
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
 ]
 
 [[package]]
-name = "rustls"
-version = "0.20.4"
+name = "time-core"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+
+[[package]]
+name = "time-macros"
+version = "0.2.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fbfeb8d0ddb84706bc597a5574ab8912817c52a397f819e5b614e2265206921"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
 dependencies = [
- "log",
- "ring",
- "sct",
- "webpki",
+ "num-conv",
+ "time-core",
 ]
 
 [[package]]
-name = "rustls-native-certs"
-version = "0.6.2"
+name = "tiny-keccak"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0167bac7a9f490495f3c33013e7722b53cb087ecbe082fb0c6387c96f634ea50"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
 dependencies = [
- "openssl-probe",
- "rustls-pemfile",
- "schannel",
- "security-framework",
+ "crunchy",
 ]
 
 [[package]]
-name = "rustls-pemfile"
-version = "1.0.0"
+name = "tinystr"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7522c9de787ff061458fe9a829dc790a3f5b22dc571694fc5883f448b94d9a9"
+checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
 dependencies = [
- "base64 0.13.1",
+ "displaydoc",
+ "zerovec",
 ]
 
 [[package]]
-name = "rustversion"
-version = "1.0.11"
+name = "tinyvec"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5583e89e108996506031660fe09baa5011b9dd0341b89029313006d1fb508d70"
+checksum = "ce6b6a2fb3a985e99cebfaefa9faa3024743da73304ca1c683a36429613d3d22"
+dependencies = [
+ "tinyvec_macros",
+]
 
 [[package]]
-name = "ryu"
-version = "1.0.5"
+name = "tinyvec_macros"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
-name = "same-file"
-version = "1.0.6"
+name = "tokio"
+version = "1.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
 dependencies = [
- "winapi-util",
+ "bytes",
+ "libc",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "schannel"
-version = "0.1.19"
+name = "tokio-macros"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
 dependencies = [
- "lazy_static",
- "winapi",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "scheduled-thread-pool"
-version = "0.2.5"
+name = "tokio-native-tls"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc6f74fd1204073fa02d5d5d68bec8021be4c38690b61264b2fdb48083d0e7d7"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
 dependencies = [
- "parking_lot 0.11.2",
+ "native-tls",
+ "tokio",
 ]
 
 [[package]]
-name = "scopeguard"
-version = "1.1.0"
+name = "tokio-openssl"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+checksum = "6ffab79df67727f6acf57f1ff743091873c24c579b1e2ce4d8f53e47ded4d63d"
+dependencies = [
+ "futures-util",
+ "openssl",
+ "openssl-sys",
+ "tokio",
+]
 
 [[package]]
-name = "scroll"
-version = "0.10.2"
+name = "tokio-postgres"
+version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fda28d4b4830b807a8b43f7b0e6b5df875311b3e7621d84577188c175b6ec1ec"
+checksum = "2b40d66d9b2cfe04b628173409368e58247e8eddbbd3b0e6c6ba1d09f20f6c9e"
 dependencies = [
- "scroll_derive",
+ "async-trait",
+ "byteorder",
+ "bytes",
+ "fallible-iterator 0.2.0",
+ "futures-channel",
+ "futures-util",
+ "log",
+ "parking_lot",
+ "percent-encoding",
+ "phf",
+ "pin-project-lite",
+ "postgres-protocol",
+ "postgres-types",
+ "rand 0.9.3",
+ "socket2",
+ "tokio",
+ "tokio-util",
+ "whoami",
 ]
 
 [[package]]
-name = "scroll_derive"
-version = "0.10.5"
+name = "tokio-retry"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaaae8f38bb311444cfb7f1979af0bc9240d95795f75f9ceddf6a59b79ceffa0"
+checksum = "4a129d95275ebf4c493ec53bf0f8cd95f5ac161bc4f381700809a54f595d4470"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "pin-project-lite",
+ "rand 0.10.1",
+ "tokio",
 ]
 
 [[package]]
-name = "sct"
-version = "0.7.0"
+name = "tokio-rustls"
+version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
- "ring",
- "untrusted",
+ "rustls",
+ "tokio",
 ]
 
 [[package]]
-name = "secp256k1"
-version = "0.21.3"
+name = "tokio-stream"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c42e6f1735c5f00f51e43e28d6634141f2bcad10931b2609ddd74a86d751260"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
 dependencies = [
- "secp256k1-sys",
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
 ]
 
 [[package]]
-name = "secp256k1-sys"
-version = "0.4.2"
+name = "tokio-test"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "957da2573cde917463ece3570eab4a0b3f19de6f1646cde62e6fd3868f566036"
+checksum = "2468baabc3311435b55dd935f702f42cd1b8abb7e754fb7dfb16bd36aa88f9f7"
 dependencies = [
- "cc",
+ "async-stream",
+ "bytes",
+ "futures-core",
+ "tokio",
+ "tokio-stream",
 ]
 
 [[package]]
-name = "security-framework"
-version = "2.3.1"
+name = "tokio-tungstenite"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23a2ac85147a3a11d77ecf1bc7166ec0b92febfa4461c37944e180f319ece467"
+checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
 dependencies = [
- "bitflags 1.3.1",
- "core-foundation",
- "core-foundation-sys",
- "libc",
- "security-framework-sys",
+ "futures-util",
+ "log",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite 0.28.0",
+ "webpki-roots 0.26.11",
 ]
 
 [[package]]
-name = "security-framework-sys"
-version = "2.3.0"
+name = "tokio-tungstenite"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e4effb91b4b8b6fb7732e670b6cee160278ff8e6bf485c7805d9e319d76e284"
+checksum = "8f72a05e828585856dacd553fba484c242c46e391fb0e58917c942ee9202915c"
 dependencies = [
- "core-foundation-sys",
- "libc",
+ "futures-util",
+ "log",
+ "tokio",
+ "tungstenite 0.29.0",
 ]
 
 [[package]]
-name = "semver"
-version = "1.0.21"
+name = "tokio-util"
+version = "0.7.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97ed7a9823b74f99c7742f5336af7be5ecd3eeafcb1507d1fa93347b1d589b0"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
 dependencies = [
- "serde",
+ "bytes",
+ "futures-core",
+ "futures-io",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
 ]
 
 [[package]]
-name = "serde"
-version = "1.0.195"
+name = "toml"
+version = "0.9.12+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
 dependencies = [
- "serde_derive",
+ "indexmap 2.14.0",
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime 0.7.5+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 0.7.13",
 ]
 
 [[package]]
-name = "serde_derive"
-version = "1.0.195"
+name = "toml"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c"
+checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.48",
+ "indexmap 2.14.0",
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime 1.1.1+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 1.0.0",
 ]
 
 [[package]]
-name = "serde_json"
-version = "1.0.107"
+name = "toml_datetime"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
 dependencies = [
- "itoa",
- "ryu",
- "serde",
+ "serde_core",
 ]
 
 [[package]]
-name = "serde_plain"
-version = "1.0.2"
+name = "toml_datetime"
+version = "1.1.1+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce1fc6db65a611022b23a0dec6975d63fb80a302cb3388835ff02c097258d50"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
-name = "serde_regex"
-version = "1.1.0"
+name = "toml_edit"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8136f1a4ea815d7eac4101cfd0b16dc0cb5e1fe1b8609dfd728058656b7badf"
+checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
 dependencies = [
- "regex",
- "serde",
+ "indexmap 2.14.0",
+ "toml_datetime 0.6.6",
+ "winnow 0.5.40",
 ]
 
 [[package]]
-name = "serde_spanned"
-version = "0.6.4"
+name = "toml_parser"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12022b835073e5b11e90a14f86838ceb1c8fb0325b72416845c487ac0fa95e80"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
 dependencies = [
- "serde",
+ "winnow 1.0.0",
 ]
 
 [[package]]
-name = "serde_urlencoded"
-version = "0.7.1"
+name = "toml_writer"
+version = "1.1.1+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
+
+[[package]]
+name = "tonic"
+version = "0.14.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac2a5518c70fa84342385732db33fb3f44bc4cc748936eb5833d2df34d6445ef"
 dependencies = [
- "form_urlencoded",
- "itoa",
- "ryu",
- "serde",
+ "async-trait",
+ "axum",
+ "base64",
+ "bytes",
+ "flate2",
+ "h2",
+ "http 1.4.2",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-timeout",
+ "hyper-util",
+ "percent-encoding",
+ "pin-project",
+ "rustls-native-certs",
+ "socket2",
+ "sync_wrapper",
+ "tokio",
+ "tokio-rustls",
+ "tokio-stream",
+ "tower 0.5.2",
+ "tower-layer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tracing",
 ]
 
 [[package]]
-name = "serde_yaml"
-version = "0.9.21"
+name = "tonic-build"
+version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9d684e3ec7de3bf5466b32bd75303ac16f0736426e5a4e0d6e489559ce1249c"
+checksum = "c68f61875ac5293cf72e6c8cf0158086428c82c37229e98c840878f1706b0322"
 dependencies = [
- "indexmap 1.9.3",
- "itoa",
- "ryu",
- "serde",
- "unsafe-libyaml",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "sha-1"
-version = "0.9.7"
+name = "tonic-prost"
+version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a0c8611594e2ab4ebbf06ec7cbbf0a99450b8570e96cbf5188b5d5f6ef18d81"
+checksum = "50849f68853be452acf590cde0b146665b8d507b3b8af17261df47e02c209ea0"
 dependencies = [
- "block-buffer 0.9.0",
- "cfg-if 1.0.0",
- "cpufeatures 0.1.5",
- "digest 0.9.0",
- "opaque-debug",
+ "bytes",
+ "prost",
+ "tonic",
 ]
 
 [[package]]
-name = "sha-1"
-version = "0.10.0"
+name = "tonic-prost-build"
+version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "028f48d513f9678cda28f6e4064755b3fbb2af6acd672f2c209b62323f7aea0f"
+checksum = "654e5643eff75d7f8c99197ce1440ed19a3474eada74c12bbac488b2cafdae27"
 dependencies = [
- "cfg-if 1.0.0",
- "cpufeatures 0.2.2",
- "digest 0.10.7",
+ "prettyplease",
+ "proc-macro2",
+ "prost-build",
+ "prost-types",
+ "quote",
+ "syn 2.0.118",
+ "tempfile",
+ "tonic-build",
 ]
 
 [[package]]
-name = "sha2"
-version = "0.9.5"
+name = "tower"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b362ae5752fd2137731f9fa25fd4d9058af34666ca1966fb969119cc35719f12"
+checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
 dependencies = [
- "block-buffer 0.9.0",
- "cfg-if 1.0.0",
- "cpufeatures 0.1.5",
- "digest 0.9.0",
- "opaque-debug",
+ "futures-core",
+ "futures-util",
+ "hdrhistogram",
+ "indexmap 2.14.0",
+ "pin-project-lite",
+ "slab",
+ "sync_wrapper",
+ "tokio",
+ "tokio-util",
+ "tower-layer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tracing",
 ]
 
 [[package]]
-name = "sha2"
-version = "0.10.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+name = "tower"
+version = "0.5.3"
+source = "git+https://github.com/tower-rs/tower.git#df06d70dbea345facbffb5881fe8647f53bf424d"
 dependencies = [
- "cfg-if 1.0.0",
- "cpufeatures 0.2.2",
- "digest 0.10.7",
+ "futures-core",
+ "futures-util",
+ "hdrhistogram",
+ "indexmap 2.14.0",
+ "pin-project-lite",
+ "slab",
+ "sync_wrapper",
+ "tokio",
+ "tokio-util",
+ "tower-layer 0.3.3 (git+https://github.com/tower-rs/tower.git)",
+ "tower-service 0.3.3 (git+https://github.com/tower-rs/tower.git)",
+ "tracing",
 ]
 
 [[package]]
-name = "sha3"
-version = "0.10.8"
+name = "tower-http"
+version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
+checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"
 dependencies = [
- "digest 0.10.7",
- "keccak",
+ "bitflags 2.11.1",
+ "bytes",
+ "futures-util",
+ "http 1.4.2",
+ "http-body",
+ "pin-project-lite",
+ "tower 0.5.2",
+ "tower-layer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url",
 ]
 
 [[package]]
-name = "shellexpand"
-version = "3.1.0"
+name = "tower-http"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da03fa3b94cc19e3ebfc88c4229c49d8f08cdbd1228870a45f0ffdf84988e14b"
+checksum = "b11f75e912b0c2be01b63d8cf8057b8c3f97cf34abb3d431a3a4c8675498e233"
 dependencies = [
- "dirs",
+ "bitflags 2.11.1",
+ "bytes",
+ "http 1.4.2",
+ "percent-encoding",
+ "pin-project-lite",
+ "tower-layer 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tower-service 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
-name = "signal-hook-registry"
-version = "1.4.0"
+name = "tower-layer"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
-dependencies = [
- "libc",
-]
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
 
 [[package]]
-name = "siphasher"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "729a25c17d72b06c68cb47955d44fda88ad2d3e7d77e025663fdd69b93dd71a1"
+name = "tower-layer"
+version = "0.3.3"
+source = "git+https://github.com/tower-rs/tower.git#df06d70dbea345facbffb5881fe8647f53bf424d"
 
 [[package]]
-name = "slab"
-version = "0.4.4"
+name = "tower-service"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c307a32c1c5c437f38c7fd45d753050587732ba8628319fbdf12a7e289ccc590"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
-name = "slog"
-version = "2.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8347046d4ebd943127157b94d63abb990fcf729dc4e9978927fdf4ac3c998d06"
+name = "tower-service"
+version = "0.3.3"
+source = "git+https://github.com/tower-rs/tower.git#df06d70dbea345facbffb5881fe8647f53bf424d"
 
 [[package]]
-name = "slog-async"
-version = "2.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "766c59b252e62a34651412870ff55d8c4e6d04df19b43eecb2703e417b097ffe"
+name = "tower-test"
+version = "0.4.1"
+source = "git+https://github.com/tower-rs/tower.git#df06d70dbea345facbffb5881fe8647f53bf424d"
 dependencies = [
- "crossbeam-channel",
- "slog",
- "take_mut",
- "thread_local",
+ "pin-project-lite",
+ "tokio",
+ "tokio-test",
+ "tower-layer 0.3.3 (git+https://github.com/tower-rs/tower.git)",
+ "tower-service 0.3.3 (git+https://github.com/tower-rs/tower.git)",
 ]
 
 [[package]]
-name = "slog-envlogger"
-version = "2.2.0"
+name = "tracing"
+version = "0.1.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "906a1a0bc43fed692df4b82a5e2fbfc3733db8dad8bb514ab27a4f23ad04f5c0"
+checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
 dependencies = [
  "log",
- "regex",
- "slog",
- "slog-async",
- "slog-scope",
- "slog-stdlog",
- "slog-term",
-]
-
-[[package]]
-name = "slog-scope"
-version = "4.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f95a4b4c3274cd2869549da82b57ccc930859bdbf5bcea0424bc5f140b3c786"
-dependencies = [
- "arc-swap",
- "lazy_static",
- "slog",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
 ]
 
 [[package]]
-name = "slog-stdlog"
-version = "4.1.1"
+name = "tracing-attributes"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6706b2ace5bbae7291d3f8d2473e2bfab073ccd7d03670946197aec98471fa3e"
+checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
- "log",
- "slog",
- "slog-scope",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "slog-term"
-version = "2.8.0"
+name = "tracing-core"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95c1e7e5aab61ced6006149ea772770b84a0d16ce0f7885def313e4829946d76"
+checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
 dependencies = [
- "atty",
- "chrono",
- "slog",
- "term",
- "thread_local",
+ "once_cell",
 ]
 
 [[package]]
-name = "smallvec"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
-
-[[package]]
-name = "socket2"
-version = "0.4.9"
+name = "try-lock"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
-dependencies = [
- "libc",
- "winapi",
-]
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
-name = "socket2"
-version = "0.5.5"
+name = "tungstenite"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9"
+checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
 dependencies = [
- "libc",
- "windows-sys 0.48.0",
+ "bytes",
+ "data-encoding",
+ "http 1.4.2",
+ "httparse",
+ "log",
+ "rand 0.9.3",
+ "rustls",
+ "rustls-pki-types",
+ "sha1 0.10.6",
+ "thiserror 2.0.18",
+ "utf-8",
 ]
 
 [[package]]
-name = "soketto"
-version = "0.7.1"
+name = "tungstenite"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d1c5305e39e09653383c2c7244f2f78b3bcae37cf50c64cb4789c9f5096ec2"
+checksum = "6c01152af293afb9c7c2a57e4b559c5620b421f6d133261c60dd2d0cdb38e6b8"
 dependencies = [
- "base64 0.13.1",
  "bytes",
- "futures 0.3.16",
+ "data-encoding",
+ "http 1.4.2",
  "httparse",
  "log",
- "rand",
- "sha-1 0.9.7",
+ "rand 0.9.3",
+ "sha1 0.10.6",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "spin"
-version = "0.5.2"
+name = "twox-hash"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
 
 [[package]]
-name = "stable-hash"
-version = "0.3.4"
-source = "git+https://github.com/graphprotocol/stable-hash?branch=old#7af76261e8098c58bfadd5b7c31810e1c0fdeccb"
-dependencies = [
- "blake3 0.3.8",
- "firestorm 0.4.6",
- "ibig",
- "lazy_static",
- "leb128",
- "num-traits",
-]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 
 [[package]]
-name = "stable-hash"
-version = "0.4.4"
-source = "git+https://github.com/graphprotocol/stable-hash?branch=main#e50aabef55b8c4de581ca5c4ffa7ed8beed7e998"
+name = "ucd-trie"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
+
+[[package]]
+name = "uint"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76f64bba2c53b04fcab63c01a7d7427eadc821e3bc48c34dc9ba29c501164b52"
 dependencies = [
- "blake3 0.3.8",
- "firestorm 0.5.0",
- "ibig",
- "lazy_static",
- "leb128",
- "num-traits",
- "uint 0.8.5",
- "xxhash-rust",
+ "byteorder",
+ "crunchy",
+ "hex",
+ "static_assertions",
 ]
 
 [[package]]
-name = "stable_deref_trait"
-version = "1.2.0"
+name = "uint"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+checksum = "6f9227a75a5a540a464c832ad4a4195dbdbecd8787610a56262721fde6f04f90"
+dependencies = [
+ "byteorder",
+ "crunchy",
+ "hex",
+ "static_assertions",
+]
 
 [[package]]
-name = "static_assertions"
-version = "1.1.0"
+name = "unarray"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
 [[package]]
-name = "stringprep"
-version = "0.1.2"
+name = "unicase"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ee348cb74b87454fff4b551cbf727025810a004f88aeacae7f85b87f4e9a1c1"
+checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "version_check",
 ]
 
 [[package]]
-name = "strsim"
-version = "0.10.0"
+name = "unicode-bidi"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
 
 [[package]]
-name = "strum"
-version = "0.21.0"
+name = "unicode-ident"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaf86bbcfd1fa9670b7a129f64fc0c9fcbbfe4f1bc4210e9e98fe71ffc12cde2"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
 [[package]]
-name = "strum_macros"
-version = "0.25.3"
+name = "unicode-normalization"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0"
+checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
 dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.48",
+ "tinyvec",
 ]
 
 [[package]]
-name = "substreams"
-version = "0.5.12"
+name = "unicode-properties"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e3524a4e2931ff6cd58783e62adbd7e44f461752eca0c423793cfb462351f24"
-dependencies = [
- "anyhow",
- "bigdecimal 0.3.1",
- "hex",
- "hex-literal 0.3.4",
- "num-bigint 0.4.4",
- "num-integer",
- "num-traits",
- "pad",
- "prost",
- "prost-build",
- "prost-types",
- "substreams-macro",
- "thiserror",
-]
+checksum = "e4259d9d4425d9f0661581b804cb85fe66a4c631cadd8f490d1c13a35d5d9291"
 
 [[package]]
-name = "substreams-entity-change"
-version = "1.3.1"
+name = "unicode-segmentation"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e07421917bd53518cb65b03e03671ecda0653995c71e5a2be815c3c755ea23c0"
-dependencies = [
- "base64 0.13.1",
- "prost",
- "prost-types",
- "substreams",
-]
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
 [[package]]
-name = "substreams-head-tracker"
-version = "1.0.0"
+name = "unicode-width"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
 
 [[package]]
-name = "substreams-macro"
-version = "0.5.12"
+name = "unicode-xid"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63c2b15adf5b4d7a6d1a73c73df951a6b2df6fbb4f0b41304dc28c5550ce0ed0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
- "thiserror",
-]
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
 [[package]]
-name = "substreams-near-core"
-version = "0.10.1"
+name = "unit-prefix"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9922f437e6cb86b62cfd8bdede93937def710616ac2825ffff06b8770bbd06df"
-dependencies = [
- "bs58",
- "prost",
- "prost-build",
- "prost-types",
-]
+checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3"
 
 [[package]]
-name = "substreams-trigger-filter"
-version = "0.34.0"
-dependencies = [
- "anyhow",
- "hex",
- "prost",
- "substreams",
- "substreams-entity-change",
- "substreams-near-core",
- "tonic-build",
- "trigger-filters",
-]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
 
 [[package]]
-name = "subtle"
-version = "2.4.1"
+name = "unsigned-varint"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+checksum = "eb066959b24b5196ae73cb057f45598450d2c5f71460e98c49b738086eff9c06"
 
 [[package]]
-name = "syn"
-version = "1.0.107"
+name = "untrusted"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
-name = "syn"
-version = "2.0.48"
+name = "url"
+version = "2.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
 dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+ "serde_derive",
 ]
 
 [[package]]
-name = "sync_wrapper"
-version = "0.1.1"
+name = "utf-8"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20518fe4a4c9acf048008599e464deb21beeae3d3578418951a189c235a7a9a8"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
 
 [[package]]
-name = "synstructure"
-version = "0.12.5"
+name = "utf16_iter"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "474aaa926faa1603c40b7885a9eaea29b444d1cb2850cb7c0e37bb1a4182f4fa"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
- "unicode-xid",
-]
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
 
 [[package]]
-name = "take_mut"
-version = "0.2.2"
+name = "utf8_iter"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
 [[package]]
-name = "tap"
-version = "1.0.1"
+name = "utf8parse"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
-name = "target-lexicon"
-version = "0.12.1"
+name = "uuid"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0652da4c4121005e9ed22b79f6c5f2d9e2752906b53a33e9490489ba421a6fb"
+checksum = "e0f540e3240398cce6128b64ba83fdbdd86129c16a3aa1a3a252efd66eb3d587"
 
 [[package]]
-name = "tempfile"
-version = "3.2.0"
+name = "valuable"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "rand",
- "redox_syscall 0.2.10",
- "remove_dir_all",
- "winapi",
-]
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
 [[package]]
-name = "term"
-version = "0.7.0"
+name = "vcpkg"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
-dependencies = [
- "dirs-next",
- "rustversion",
- "winapi",
-]
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
-name = "termcolor"
-version = "1.4.0"
+name = "version_check"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff1bc3d3f05aff0403e8ac0d92ced918ec05b666a43f83297ccef5bea8a3d449"
-dependencies = [
- "winapi-util",
-]
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
-name = "terminal_size"
-version = "0.1.17"
+name = "wait-timeout"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
 dependencies = [
  "libc",
- "winapi",
 ]
 
 [[package]]
-name = "test-store"
-version = "0.34.0"
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
 dependencies = [
- "diesel",
- "graph",
- "graph-chain-ethereum",
- "graph-core",
- "graph-graphql",
- "graph-node",
- "graph-store-postgres",
- "graphql-parser",
- "hex",
- "hex-literal 0.4.1",
- "lazy_static",
- "pretty_assertions",
- "prost-types",
- "serde",
+ "same-file",
+ "winapi-util",
 ]
 
 [[package]]
-name = "textwrap"
-version = "0.16.0"
+name = "want"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
 
 [[package]]
-name = "thiserror"
-version = "1.0.31"
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd829fe32373d27f76265620b5309d0340cb8550f523c1dda251d6298069069a"
-dependencies = [
- "thiserror-impl",
-]
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
-name = "thiserror-impl"
-version = "1.0.31"
+name = "wasi"
+version = "0.13.3+wasi-0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0396bc89e626244658bef819e22d0cc459e795a5ebe878e6ec336d1674a8d79a"
+checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "wit-bindgen-rt",
 ]
 
 [[package]]
-name = "thread_local"
-version = "1.1.4"
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
 dependencies = [
- "once_cell",
+ "wit-bindgen",
 ]
 
 [[package]]
-name = "time"
-version = "0.3.17"
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a561bf4617eebd33bca6434b988f39ed798e527f51a1e797d0ee4f61c0a38376"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
 dependencies = [
- "itoa",
- "serde",
- "time-core",
- "time-macros",
+ "wit-bindgen",
 ]
 
 [[package]]
-name = "time-core"
+name = "wasite"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
-
-[[package]]
-name = "time-macros"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d967f99f534ca7e495c575c62638eebc2898a8c84c119b89e250477bc4ba16b2"
-dependencies = [
- "time-core",
-]
+checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
-name = "tiny-keccak"
-version = "1.5.0"
+name = "wasm-bindgen"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d8a021c69bb74a44ccedb824a046447e2c84a01df9e5c20779750acb38e11b2"
+checksum = "8ddb3f79143bced6de84270411622a2699cee572fc0875aeaf1e7867cf9fca1a"
 dependencies = [
- "crunchy",
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
 ]
 
 [[package]]
-name = "tiny-keccak"
-version = "2.0.2"
+name = "wasm-bindgen-futures"
+version = "0.4.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+checksum = "503b14d284f2c8dac03b819967e155ea753f573586193b2b2c95990cb5d69280"
 dependencies = [
- "crunchy",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "tinyvec"
-version = "1.3.1"
+name = "wasm-bindgen-macro"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "848a1e1181b9f6753b5e96a092749e29b11d19ede67dfbbd6c7dc7e0f49b5338"
+checksum = "4e21a184b13fb19e157296e2c46056aec9092264fab83e4ba59e68c61b323c3d"
 dependencies = [
- "tinyvec_macros",
+ "quote",
+ "wasm-bindgen-macro-support",
 ]
 
 [[package]]
-name = "tinyvec_macros"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
-
-[[package]]
-name = "tokio"
-version = "1.35.1"
+name = "wasm-bindgen-macro-support"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c89b4efa943be685f629b149f53829423f8f5531ea21249408e8e2f8671ec104"
+checksum = "fecefd9c35bd935a20fc3fc344b5f29138961e4f47fb03297d88f2587afb5ebd"
 dependencies = [
- "backtrace",
- "bytes",
- "libc",
- "mio",
- "num_cpus",
- "parking_lot 0.12.1",
- "pin-project-lite",
- "signal-hook-registry",
- "socket2 0.5.5",
- "tokio-macros",
- "windows-sys 0.48.0",
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "wasm-bindgen-shared",
 ]
 
 [[package]]
-name = "tokio-io-timeout"
-version = "1.1.1"
+name = "wasm-bindgen-shared"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90c49f106be240de154571dd31fbe48acb10ba6c6dd6f6517ad603abffa42de9"
+checksum = "23939e44bb9a5d7576fa2b563dc2e136628f1224e88a8deed09e04858b77871f"
 dependencies = [
- "pin-project-lite",
- "tokio",
+ "unicode-ident",
 ]
 
 [[package]]
-name = "tokio-macros"
-version = "2.2.0"
+name = "wasm-compose"
+version = "0.251.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
+checksum = "b089037d7eb453ed57b560fe7833de0707411c8b9fdc429745ced77e2a1bacb9"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.48",
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.14.0",
+ "log",
+ "petgraph 0.6.5",
+ "smallvec",
+ "wasm-encoder 0.251.0",
+ "wasmparser 0.251.0",
+ "wat",
 ]
 
 [[package]]
-name = "tokio-native-tls"
-version = "0.3.0"
+name = "wasm-encoder"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d995660bd2b7f8c1568414c1126076c13fbb725c40112dc0120b78eb9b717b"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
 dependencies = [
- "native-tls",
- "tokio",
+ "leb128fmt",
+ "wasmparser 0.244.0",
 ]
 
 [[package]]
-name = "tokio-openssl"
-version = "0.6.3"
+name = "wasm-encoder"
+version = "0.251.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08f9ffb7809f1b20c1b398d92acf4cc719874b3b2b2d9ea2f09b4a80350878a"
+checksum = "5a879a421bd17c528b74721b2abf4c62e8f1d1889c2ba8c3c50d02deaf2ce395"
 dependencies = [
- "futures-util",
- "openssl",
- "openssl-sys",
- "tokio",
+ "leb128fmt",
+ "wasmparser 0.251.0",
 ]
 
 [[package]]
-name = "tokio-postgres"
-version = "0.7.2"
+name = "wasm-encoder"
+version = "0.252.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d2b1383c7e4fb9a09e292c7c6afb7da54418d53b045f1c1fac7a911411a2b8b"
+checksum = "8185ae345fa5687c054626ff9a50e7089797a343d9904d1dc9820eb4c4d3196f"
 dependencies = [
- "async-trait",
- "byteorder",
- "bytes",
- "fallible-iterator 0.2.0",
- "futures 0.3.16",
- "log",
- "parking_lot 0.11.2",
- "percent-encoding",
- "phf",
- "pin-project-lite",
- "postgres-protocol",
- "postgres-types",
- "socket2 0.4.9",
- "tokio",
- "tokio-util 0.6.7",
+ "leb128fmt",
+ "wasmparser 0.252.0",
 ]
 
 [[package]]
-name = "tokio-retry"
-version = "0.3.0"
+name = "wasm-instrument"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f57eb36ecbe0fc510036adff84824dd3c24bb781e21bfa67b69d556aa85214f"
+checksum = "2a47ecb37b9734d1085eaa5ae1a81e60801fd8c28d4cabdd8aedb982021918bc"
 dependencies = [
- "pin-project",
- "rand",
- "tokio",
+ "parity-wasm",
 ]
 
 [[package]]
-name = "tokio-rustls"
-version = "0.23.3"
+name = "wasm-metadata"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4151fda0cf2798550ad0b34bcfc9b9dcc2a9d2471c895c68f3a8818e54f2389e"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
 dependencies = [
- "rustls",
- "tokio",
- "webpki",
+ "anyhow",
+ "indexmap 2.14.0",
+ "wasm-encoder 0.244.0",
+ "wasmparser 0.244.0",
 ]
 
 [[package]]
-name = "tokio-stream"
-version = "0.1.14"
+name = "wasm-streams"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842"
+checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
 dependencies = [
- "futures-core",
- "pin-project-lite",
- "tokio",
- "tokio-util 0.7.1",
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
-name = "tokio-test"
-version = "0.4.2"
+name = "wasm-streams"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53474327ae5e166530d17f2d956afcb4f8a004de581b3cae10f12006bc8163e3"
+checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"
 dependencies = [
- "async-stream",
- "bytes",
- "futures-core",
- "tokio",
- "tokio-stream",
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
-name = "tokio-tungstenite"
-version = "0.17.2"
+name = "wasmparser"
+version = "0.118.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f714dd15bead90401d77e04243611caec13726c2408afd5b31901dfcdcb3b181"
+checksum = "77f1154f1ab868e2a01d9834a805faca7bf8b50d041b4ca714d005d0dab1c50c"
 dependencies = [
- "futures-util",
- "log",
- "tokio",
- "tungstenite",
+ "indexmap 2.14.0",
+ "semver 1.0.28",
 ]
 
 [[package]]
-name = "tokio-util"
-version = "0.6.7"
+name = "wasmparser"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1caa0b0c8d94a049db56b5acf8cba99dc0623aab1b26d5b5f5e2d945846b3592"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
 dependencies = [
- "bytes",
- "futures-core",
- "futures-io",
- "futures-sink",
- "log",
- "pin-project-lite",
- "tokio",
+ "bitflags 2.11.1",
+ "hashbrown 0.15.2",
+ "indexmap 2.14.0",
+ "semver 1.0.28",
 ]
 
 [[package]]
-name = "tokio-util"
-version = "0.7.1"
+name = "wasmparser"
+version = "0.251.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0edfdeb067411dba2044da6d1cb2df793dd35add7888d73c16e3381ded401764"
+checksum = "437970b35b1a85cfde9c74b2398352d8d653f3bd8e3a3db0c063ea8f5b4b36ff"
 dependencies = [
- "bytes",
- "futures-core",
- "futures-sink",
- "pin-project-lite",
- "tokio",
- "tracing",
+ "bitflags 2.11.1",
+ "hashbrown 0.17.0",
+ "indexmap 2.14.0",
+ "semver 1.0.28",
+ "serde",
 ]
 
 [[package]]
-name = "toml"
-version = "0.5.11"
+name = "wasmparser"
+version = "0.252.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+checksum = "d3eb099dcadcde5be9eef55e3a337128efd4e44b4c93122487e4d2e4e1c6627c"
 dependencies = [
- "serde",
+ "bitflags 2.11.1",
+ "indexmap 2.14.0",
+ "semver 1.0.28",
 ]
 
 [[package]]
-name = "toml"
-version = "0.8.8"
+name = "wasmprinter"
+version = "0.251.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1a195ec8c9da26928f773888e0742ca3ca1040c6cd859c919c9f59c1954ab35"
+checksum = "8798c1a699bd25648b6708eefe94d97c6f9891febb94b42cca1f7a4b086ea64e"
 dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit",
+ "anyhow",
+ "termcolor",
+ "wasmparser 0.251.0",
 ]
 
 [[package]]
-name = "toml_datetime"
-version = "0.6.5"
+name = "wasmtime"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
+checksum = "c4213d2f019a5e44aa8a61d8826dd33a505bff79f749b14a8bafd67321cb9351"
 dependencies = [
+ "addr2line",
+ "async-trait",
+ "bitflags 2.11.1",
+ "bumpalo",
+ "cc",
+ "cfg-if",
+ "encoding_rs",
+ "futures 0.3.31",
+ "fxprof-processed-profile",
+ "gimli",
+ "ittapi",
+ "libc",
+ "log",
+ "mach2",
+ "memfd",
+ "object",
+ "once_cell",
+ "postcard",
+ "pulley-interpreter",
+ "rayon",
+ "rustix 1.1.4",
+ "semver 1.0.28",
  "serde",
+ "serde_derive",
+ "serde_json",
+ "smallvec",
+ "target-lexicon",
+ "tempfile",
+ "wasm-compose",
+ "wasm-encoder 0.251.0",
+ "wasmparser 0.251.0",
+ "wasmtime-environ",
+ "wasmtime-internal-cache",
+ "wasmtime-internal-component-macro",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-core",
+ "wasmtime-internal-cranelift",
+ "wasmtime-internal-fiber",
+ "wasmtime-internal-jit-debug",
+ "wasmtime-internal-jit-icache-coherence",
+ "wasmtime-internal-unwinder",
+ "wasmtime-internal-versioned-export-macros",
+ "wat",
+ "windows-sys 0.61.2",
+ "wit-parser 0.251.0",
 ]
 
 [[package]]
-name = "toml_edit"
-version = "0.21.0"
+name = "wasmtime-environ"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34d383cd00a163b4a5b85053df514d45bc330f6de7737edfe0a93311d1eaa03"
+checksum = "d45863de41977ec6453e859cf843d456fa3fcb45a659b66d16e794f90ec4f5b7"
 dependencies = [
- "indexmap 2.1.0",
+ "anyhow",
+ "cpp_demangle",
+ "cranelift-bforest",
+ "cranelift-bitset",
+ "cranelift-entity",
+ "gimli",
+ "hashbrown 0.17.0",
+ "indexmap 2.14.0",
+ "log",
+ "object",
+ "postcard",
+ "rustc-demangle",
+ "semver 1.0.28",
  "serde",
- "serde_spanned",
- "toml_datetime",
- "winnow",
+ "serde_derive",
+ "sha2 0.10.9",
+ "smallvec",
+ "target-lexicon",
+ "wasm-encoder 0.251.0",
+ "wasmparser 0.251.0",
+ "wasmprinter",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-core",
 ]
 
 [[package]]
-name = "tonic"
-version = "0.8.3"
+name = "wasmtime-internal-cache"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f219fad3b929bef19b1f86fbc0358d35daed8f2cac972037ac0dc10bbb8d5fb"
+checksum = "438bc7dc45fb75297d75f79a9a0ce852345d13ebc6a6863f6f688f013836a9dd"
 dependencies = [
- "async-stream",
- "async-trait",
- "axum",
- "base64 0.13.1",
- "bytes",
- "flate2",
- "futures-core",
- "futures-util",
- "h2",
- "http",
- "http-body",
- "hyper",
- "hyper-timeout",
- "percent-encoding",
- "pin-project",
- "prost",
- "prost-derive",
- "rustls-native-certs",
- "rustls-pemfile",
- "tokio",
- "tokio-rustls",
- "tokio-stream",
- "tokio-util 0.7.1",
- "tower 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "tower-layer 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "tower-service 0.3.1",
- "tracing",
- "tracing-futures",
+ "base64",
+ "directories-next",
+ "log",
+ "postcard",
+ "rustix 1.1.4",
+ "serde",
+ "serde_derive",
+ "sha2 0.10.9",
+ "toml 0.9.12+spec-1.1.0",
+ "wasmtime-environ",
+ "windows-sys 0.61.2",
+ "zstd",
 ]
 
 [[package]]
-name = "tonic-build"
-version = "0.8.4"
+name = "wasmtime-internal-component-macro"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bf5e9b9c0f7e0a7c027dcfaba7b2c60816c7049171f679d99ee2ff65d0de8c4"
+checksum = "f1e48f8d4966d62a10b6d70722bc432c1e163890be2801d3b5784589ad36ffc3"
 dependencies = [
- "prettyplease",
+ "anyhow",
  "proc-macro2",
- "prost-build",
  "quote",
- "syn 1.0.107",
+ "syn 2.0.118",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-wit-bindgen",
+ "wit-parser 0.251.0",
 ]
 
 [[package]]
-name = "tower"
-version = "0.4.13"
+name = "wasmtime-internal-component-util"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
-dependencies = [
- "futures-core",
- "futures-util",
- "indexmap 1.9.3",
- "pin-project",
- "pin-project-lite",
- "rand",
- "slab",
- "tokio",
- "tokio-util 0.7.1",
- "tower-layer 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "tower-service 0.3.1",
- "tracing",
-]
+checksum = "819ad5abd5822a22dbf4014475cdfd1fe790707761cd732d74aaa3ba4d5ba489"
 
 [[package]]
-name = "tower"
-version = "0.4.13"
-source = "git+https://github.com/tower-rs/tower.git#39adf5c509a1b2141f679654d8317524ca96b58b"
+name = "wasmtime-internal-core"
+version = "46.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fc28372e36eaf8cf70faa83b5779137f7e99c8d18569a125d1580e735cc9e4d"
 dependencies = [
- "futures-core",
- "futures-util",
- "hdrhistogram",
- "indexmap 1.9.3",
- "pin-project-lite",
- "slab",
- "sync_wrapper",
- "tokio",
- "tokio-util 0.7.1",
- "tower-layer 0.3.2 (git+https://github.com/tower-rs/tower.git)",
- "tower-service 0.3.2",
- "tracing",
+ "anyhow",
+ "hashbrown 0.17.0",
+ "libm",
+ "serde",
 ]
 
 [[package]]
-name = "tower-http"
-version = "0.3.2"
+name = "wasmtime-internal-cranelift"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e980386f06883cf4d0578d6c9178c81f68b45d77d00f2c2c1bc034b3439c2c56"
+checksum = "a433efc6e35112a5457e1dc8bc4d8d39820ac7722267e89bc04e5df641f32124"
 dependencies = [
- "bitflags 1.3.1",
- "bytes",
- "futures-core",
- "futures-util",
- "http",
- "http-body",
- "http-range-header",
- "pin-project-lite",
- "tower 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "tower-layer 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "tower-service 0.3.1",
+ "cfg-if",
+ "cranelift-codegen",
+ "cranelift-control",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "cranelift-native",
+ "gimli",
+ "itertools 0.14.0",
+ "log",
+ "object",
+ "pulley-interpreter",
+ "smallvec",
+ "target-lexicon",
+ "thiserror 2.0.18",
+ "wasmparser 0.251.0",
+ "wasmtime-environ",
+ "wasmtime-internal-core",
+ "wasmtime-internal-unwinder",
+ "wasmtime-internal-versioned-export-macros",
 ]
 
 [[package]]
-name = "tower-layer"
-version = "0.3.2"
+name = "wasmtime-internal-fiber"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+checksum = "18a1d3a39d0d210f6b8574ee96a4315e0a14c67f3a1fc3cd5372cb10d2fb4422"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "libc",
+ "rustix 1.1.4",
+ "wasmtime-environ",
+ "wasmtime-internal-versioned-export-macros",
+ "windows-sys 0.61.2",
+]
 
 [[package]]
-name = "tower-layer"
-version = "0.3.2"
-source = "git+https://github.com/tower-rs/tower.git#39adf5c509a1b2141f679654d8317524ca96b58b"
+name = "wasmtime-internal-jit-debug"
+version = "46.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f667288cb4dfa68a4639ffac4d5628535dda64ebdc2b990526efb12b30ba803"
+dependencies = [
+ "cc",
+ "object",
+ "rustix 1.1.4",
+ "wasmtime-internal-versioned-export-macros",
+]
 
 [[package]]
-name = "tower-service"
-version = "0.3.1"
+name = "wasmtime-internal-jit-icache-coherence"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"
+checksum = "eba651d44ab0faad4c58106b3adb45068189fb65ef50f0c404b6d9e3bf81a357"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasmtime-internal-core",
+ "windows-sys 0.61.2",
+]
 
 [[package]]
-name = "tower-service"
-version = "0.3.2"
-source = "git+https://github.com/tower-rs/tower.git#39adf5c509a1b2141f679654d8317524ca96b58b"
+name = "wasmtime-internal-unwinder"
+version = "46.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ecc52563b0558af2a7487eb710de07cc4532564b55528876129238e83118cb1"
+dependencies = [
+ "cfg-if",
+ "cranelift-codegen",
+ "log",
+ "object",
+ "wasmtime-environ",
+]
 
 [[package]]
-name = "tower-test"
-version = "0.4.0"
-source = "git+https://github.com/tower-rs/tower.git#39adf5c509a1b2141f679654d8317524ca96b58b"
+name = "wasmtime-internal-versioned-export-macros"
+version = "46.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e747f4a074699ba1b4e4d841fb263f9b7df5bd1555181c4752bf5990d21ba676"
 dependencies = [
- "futures-util",
- "pin-project-lite",
- "tokio",
- "tokio-test",
- "tower-layer 0.3.2 (git+https://github.com/tower-rs/tower.git)",
- "tower-service 0.3.2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "tracing"
-version = "0.1.36"
+name = "wasmtime-internal-wit-bindgen"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fce9567bd60a67d08a16488756721ba392f24f29006402881e43b19aac64307"
+checksum = "80009f46991622814196d96fac6fc0a938f46b5cba737a8f4e21e24e5a03856f"
 dependencies = [
- "cfg-if 1.0.0",
- "log",
- "pin-project-lite",
- "tracing-attributes",
- "tracing-core",
+ "anyhow",
+ "bitflags 2.11.1",
+ "heck 0.5.0",
+ "indexmap 2.14.0",
+ "wit-parser 0.251.0",
 ]
 
 [[package]]
-name = "tracing-attributes"
-version = "0.1.22"
+name = "wasmtimer"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11c75893af559bc8e10716548bdef5cb2b983f8e637db9d0e15126b61b484ee2"
+checksum = "1c598d6b99ea013e35844697fc4670d08339d5cda15588f193c6beedd12f644b"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "futures 0.3.31",
+ "js-sys",
+ "parking_lot",
+ "pin-utils",
+ "slab",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "tracing-core"
-version = "0.1.29"
+name = "wast"
+version = "252.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aeea4303076558a00714b823f9ad67d58a3bbda1df83d8827d21193156e22f7"
+checksum = "942a3449d6a593fccc111a6241c8df52bda168af30e40bf9580d4394d7374c65"
 dependencies = [
- "once_cell",
+ "bumpalo",
+ "leb128fmt",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder 0.252.0",
 ]
 
 [[package]]
-name = "tracing-futures"
-version = "0.2.5"
+name = "wat"
+version = "1.252.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
+checksum = "c72a4ba7088f7bac94cf516e49882bdf97068904a563768cf249efc839ec42cb"
 dependencies = [
- "pin-project",
- "tracing",
+ "wast",
 ]
 
 [[package]]
-name = "trigger-filters"
-version = "0.34.0"
+name = "web-sys"
+version = "0.3.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6430a72df5eb332242960fe84b3002a241163998241eb596d4f739b9757061d"
 dependencies = [
- "anyhow",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "try-lock"
-version = "0.2.3"
+name = "web-time"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
 
 [[package]]
-name = "tungstenite"
-version = "0.17.3"
+name = "webpki-root-certs"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e27992fd6a8c29ee7eef28fc78349aa244134e10ad447ce3b9f0ac0ed0fa4ce0"
+checksum = "f31141ce3fc3e300ae89b78c0dd67f9708061d1d2eda54b8209346fd6be9a92c"
 dependencies = [
- "base64 0.13.1",
- "byteorder",
- "bytes",
- "http",
- "httparse",
- "log",
- "rand",
- "sha-1 0.10.0",
- "thiserror",
- "url",
- "utf-8",
+ "rustls-pki-types",
 ]
 
 [[package]]
-name = "typed-builder"
-version = "0.10.0"
+name = "webpki-roots"
+version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89851716b67b937e393b3daa8423e67ddfc4bbbf1654bcf05488e95e0828db0c"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
+ "webpki-roots 1.0.5",
 ]
 
 [[package]]
-name = "typenum"
-version = "1.15.0"
+name = "webpki-roots"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c"
+dependencies = [
+ "rustls-pki-types",
+]
 
 [[package]]
-name = "uint"
-version = "0.8.5"
+name = "which"
+version = "4.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9db035e67dfaf7edd9aebfe8676afcd63eed53c8a4044fed514c8cccf1835177"
+checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7"
 dependencies = [
- "byteorder",
- "crunchy",
- "rustc-hex",
- "static_assertions",
+ "either",
+ "home",
+ "once_cell",
+ "rustix 0.38.34",
 ]
 
 [[package]]
-name = "uint"
-version = "0.9.1"
+name = "whoami"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6470ab50f482bde894a037a57064480a246dbfdd5960bd65a44824693f08da5f"
+checksum = "a44ab49fad634e88f55bf8f9bb3abd2f27d7204172a112c7c9987e01c1c94ea9"
 dependencies = [
- "byteorder",
- "crunchy",
- "hex",
- "static_assertions",
+ "redox_syscall 0.4.1",
+ "wasite",
+ "web-sys",
 ]
 
 [[package]]
-name = "unicase"
-version = "2.6.0"
+name = "widestring"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
+checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
 dependencies = [
- "version_check",
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
 ]
 
 [[package]]
-name = "unicode-bidi"
-version = "0.3.13"
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"
+checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+dependencies = [
+ "windows-sys 0.52.0",
+]
 
 [[package]]
-name = "unicode-ident"
-version = "1.0.1"
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
-name = "unicode-normalization"
-version = "0.1.22"
+name = "windows-core"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "tinyvec",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
-name = "unicode-width"
-version = "0.1.8"
+name = "windows-link"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
 
 [[package]]
-name = "unicode-xid"
-version = "0.2.2"
+name = "windows-link"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
-name = "unreachable"
-version = "1.0.0"
+name = "windows-registry"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
+checksum = "b3bab093bdd303a1240bb99b8aba8ea8a69ee19d34c9e2ef9594e708a4878820"
 dependencies = [
- "void",
+ "windows-link 0.1.3",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
-name = "unsafe-libyaml"
-version = "0.2.8"
+name = "windows-result"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1865806a559042e51ab5414598446a5871b561d21b6764f2eabb0dd481d880a6"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link 0.1.3",
+]
 
 [[package]]
-name = "unsigned-varint"
-version = "0.7.1"
+name = "windows-strings"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d86a8dc7f45e4c1b0d30e43038c38f274e77af056aa5f74b93c2cf9eb3c1c836"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link 0.1.3",
+]
 
 [[package]]
-name = "unsigned-varint"
-version = "0.8.0"
+name = "windows-sys"
+version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb066959b24b5196ae73cb057f45598450d2c5f71460e98c49b738086eff9c06"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
 
 [[package]]
-name = "untrusted"
-version = "0.7.1"
+name = "windows-sys"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
 
 [[package]]
-name = "url"
-version = "2.5.0"
+name = "windows-sys"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "form_urlencoded",
- "idna 0.5.0",
- "percent-encoding",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
-name = "utf-8"
-version = "0.7.6"
+name = "windows-sys"
+version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
 
 [[package]]
-name = "uuid"
-version = "1.6.1"
+name = "windows-sys"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e395fcf16a7a3d8127ec99782007af141946b4795001f876d54fb0d55978560"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
 dependencies = [
- "getrandom",
+ "windows-targets 0.53.3",
 ]
 
 [[package]]
-name = "vcpkg"
-version = "0.2.15"
+name = "windows-sys"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
 
 [[package]]
-name = "version_check"
-version = "0.9.3"
+name = "windows-targets"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+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",
+]
 
 [[package]]
-name = "void"
-version = "1.0.2"
+name = "windows-targets"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
 
 [[package]]
-name = "walkdir"
-version = "2.3.3"
+name = "windows-targets"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36df944cda56c7d8d8b7496af378e6b16de9284591917d307c9b4d313c44e698"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "same-file",
- "winapi-util",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "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 = "want"
-version = "0.3.0"
+name = "windows-targets"
+version = "0.53.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
+checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91"
 dependencies = [
- "log",
- "try-lock",
+ "windows-link 0.1.3",
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
 ]
 
 [[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 
 [[package]]
-name = "wasm-bindgen"
-version = "0.2.82"
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc7652e3f6c4706c8d9cd54832c4a4ccb9b5336e2c3bd154d5cccfbf1c1f5f7d"
-dependencies = [
- "cfg-if 1.0.0",
- "wasm-bindgen-macro",
-]
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.82"
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "662cd44805586bd52971b9586b1df85cdbbd9112e4ef4d8f41559c334dc6ac3f"
-dependencies = [
- "bumpalo",
- "log",
- "once_cell",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
- "wasm-bindgen-shared",
-]
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
-name = "wasm-bindgen-futures"
-version = "0.4.25"
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16646b21c3add8e13fdb8f20172f8a28c3dbf62f45406bcff0233188226cfe0c"
-dependencies = [
- "cfg-if 1.0.0",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
 
 [[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.82"
+name = "windows_aarch64_msvc"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b260f13d3012071dfb1512849c033b1925038373aea48ced3012c09df952c602"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
 [[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.82"
+name = "windows_aarch64_msvc"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be8e654bdd9b79216c2929ab90721aa82faf65c48cdf08bdc4e7f51357b80da"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.82"
+name = "windows_aarch64_msvc"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6598dd0bd3c7d51095ff6531a5b23e02acdc81804e30d8f07afb77b7215a140a"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
-name = "wasm-instrument"
-version = "0.2.0"
+name = "windows_aarch64_msvc"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bca81f5279342b38b17d9acbf007a46ddeb73144e2bd5f0a21bfa9fc5d4ab3e"
-dependencies = [
- "parity-wasm",
-]
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
 
 [[package]]
-name = "wasm-streams"
-version = "0.2.3"
+name = "windows_i686_gnu"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bbae3363c08332cadccd13b67db371814cd214c2524020932f0804b8cf7c078"
-dependencies = [
- "futures-util",
- "js-sys",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
-]
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 
 [[package]]
-name = "wasmparser"
-version = "0.78.2"
+name = "windows_i686_gnu"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52144d4c78e5cf8b055ceab8e5fa22814ce4315d6002ad32cfd914f37c12fd65"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
-name = "wasmtime"
-version = "0.27.0"
+name = "windows_i686_gnu"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b310b9d20fcf59385761d1ade7a3ef06aecc380e3d3172035b919eaf7465d9f7"
-dependencies = [
- "anyhow",
- "backtrace",
- "bincode",
- "cfg-if 1.0.0",
- "cpp_demangle",
- "indexmap 1.9.3",
- "lazy_static",
- "libc",
- "log",
- "paste",
- "psm",
- "region",
- "rustc-demangle",
- "serde",
- "smallvec",
- "target-lexicon",
- "wasmparser",
- "wasmtime-cache",
- "wasmtime-environ",
- "wasmtime-fiber",
- "wasmtime-jit",
- "wasmtime-profiling",
- "wasmtime-runtime",
- "wat",
- "winapi",
-]
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
 [[package]]
-name = "wasmtime-cache"
-version = "0.27.0"
+name = "windows_i686_gnu"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d14d500d5c3dc5f5c097158feee123d64b3097f0d836a2a27dff9c761c73c843"
-dependencies = [
- "anyhow",
- "base64 0.13.1",
- "bincode",
- "directories-next",
- "errno 0.2.7",
- "file-per-thread-logger",
- "libc",
- "log",
- "serde",
- "sha2 0.9.5",
- "toml 0.5.11",
- "winapi",
- "zstd",
-]
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
 
 [[package]]
-name = "wasmtime-cranelift"
-version = "0.27.0"
+name = "windows_i686_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c525b39f062eada7db3c1298287b96dcb6e472b9f6b22501300b28d9fa7582f6"
-dependencies = [
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-frontend",
- "cranelift-wasm",
- "target-lexicon",
- "wasmparser",
- "wasmtime-environ",
-]
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
-name = "wasmtime-debug"
-version = "0.27.0"
+name = "windows_i686_gnullvm"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5d2a763e7a6fc734218e0e463196762a4f409c483063d81e0e85f96343b2e0a"
-dependencies = [
- "anyhow",
- "gimli 0.24.0",
- "more-asserts",
- "object 0.24.0",
- "target-lexicon",
- "thiserror",
- "wasmparser",
- "wasmtime-environ",
-]
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
 
 [[package]]
-name = "wasmtime-environ"
-version = "0.27.0"
+name = "windows_i686_msvc"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f64d0c2d881c31b0d65c1f2695e022d71eb60b9fbdd336aacca28208b58eac90"
-dependencies = [
- "cfg-if 1.0.0",
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-wasm",
- "gimli 0.24.0",
- "indexmap 1.9.3",
- "log",
- "more-asserts",
- "serde",
- "thiserror",
- "wasmparser",
-]
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
 
 [[package]]
-name = "wasmtime-fiber"
-version = "0.27.0"
+name = "windows_i686_msvc"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a089d44cd7e2465d41a53b840a5b4fca1bf6d1ecfebc970eac9592b34ea5f0b3"
-dependencies = [
- "cc",
- "libc",
- "winapi",
-]
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
-name = "wasmtime-jit"
-version = "0.27.0"
+name = "windows_i686_msvc"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4539ea734422b7c868107e2187d7746d8affbcaa71916d72639f53757ad707"
-dependencies = [
- "addr2line 0.15.2",
- "anyhow",
- "cfg-if 1.0.0",
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-frontend",
- "cranelift-native",
- "cranelift-wasm",
- "gimli 0.24.0",
- "log",
- "more-asserts",
- "object 0.24.0",
- "rayon",
- "region",
- "serde",
- "target-lexicon",
- "thiserror",
- "wasmparser",
- "wasmtime-cranelift",
- "wasmtime-debug",
- "wasmtime-environ",
- "wasmtime-obj",
- "wasmtime-profiling",
- "wasmtime-runtime",
- "winapi",
-]
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
-name = "wasmtime-obj"
-version = "0.27.0"
+name = "windows_i686_msvc"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e1a8ff85246d091828e2225af521a6208ed28c997bb5c39eb697366dc2e2f2b"
-dependencies = [
- "anyhow",
- "more-asserts",
- "object 0.24.0",
- "target-lexicon",
- "wasmtime-debug",
- "wasmtime-environ",
-]
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
 
 [[package]]
-name = "wasmtime-profiling"
-version = "0.27.0"
+name = "windows_x86_64_gnu"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e24364d522dcd67c897c8fffc42e5bdfc57207bbb6d7eeade0da9d4a7d70105b"
-dependencies = [
- "anyhow",
- "cfg-if 1.0.0",
- "gimli 0.24.0",
- "lazy_static",
- "libc",
- "object 0.24.0",
- "scroll",
- "serde",
- "target-lexicon",
- "wasmtime-environ",
- "wasmtime-runtime",
-]
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
 
 [[package]]
-name = "wasmtime-runtime"
-version = "0.27.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c51e57976e8a19a18a18e002c6eb12e5769554204238e47ff155fda1809ef0f7"
-dependencies = [
- "anyhow",
- "backtrace",
- "cc",
- "cfg-if 1.0.0",
- "indexmap 1.9.3",
- "lazy_static",
- "libc",
- "log",
- "mach",
- "memoffset",
- "more-asserts",
- "rand",
- "region",
- "thiserror",
- "wasmtime-environ",
- "wasmtime-fiber",
- "winapi",
-]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
-name = "wast"
-version = "37.0.0"
+name = "windows_x86_64_gnu"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bc7b9a76845047ded00e031754ff410afee0d50fbdf62b55bdeecd245063d68"
-dependencies = [
- "leb128",
-]
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
-name = "wat"
-version = "1.0.39"
+name = "windows_x86_64_gnu"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab2cc8d9a69d1ab28a41d9149bb06bb927aba8fc9d56625f8b597a564c83f50"
-dependencies = [
- "wast",
-]
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
 
 [[package]]
-name = "web-sys"
-version = "0.3.52"
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01c70a82d842c9979078c772d4a1344685045f1a5628f677c2b2eab4dd7d2696"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 
 [[package]]
-name = "web3"
-version = "0.19.0-graph"
-source = "git+https://github.com/graphprotocol/rust-web3?branch=graph-patches-onto-0.18#7f8eb6dfcc13a4186f9b42f91de950646bc4a833"
-dependencies = [
- "arrayvec 0.7.4",
- "base64 0.13.1",
- "bytes",
- "derive_more",
- "ethabi",
- "ethereum-types",
- "futures 0.3.16",
- "futures-timer",
- "headers",
- "hex",
- "idna 0.2.3",
- "jsonrpc-core",
- "log",
- "once_cell",
- "parking_lot 0.12.1",
- "pin-project",
- "reqwest",
- "rlp",
- "secp256k1",
- "serde",
- "serde_json",
- "soketto",
- "tiny-keccak 2.0.2",
- "tokio",
- "tokio-stream",
- "tokio-util 0.6.7",
- "url",
- "web3-async-native-tls",
-]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
-name = "web3-async-native-tls"
-version = "0.4.0"
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f6d8d1636b2627fe63518d5a9b38a569405d9c9bc665c43c9c341de57227ebb"
-dependencies = [
- "native-tls",
- "thiserror",
- "tokio",
- "url",
-]
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
-name = "webpki"
-version = "0.22.2"
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07ecc0cd7cac091bf682ec5efa18b1cff79d617b84181f38b3951dbe135f607f"
-dependencies = [
- "ring",
- "untrusted",
-]
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
 
 [[package]]
-name = "which"
-version = "4.2.2"
+name = "windows_x86_64_msvc"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea187a8ef279bc014ec368c27a920da2024d2a711109bfbe3440585d5cf27ad9"
-dependencies = [
- "either",
- "lazy_static",
- "libc",
-]
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 
 [[package]]
-name = "winapi"
-version = "0.3.9"
+name = "windows_x86_64_msvc"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
+name = "windows_x86_64_msvc"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
-name = "winapi-util"
-version = "0.1.5"
+name = "windows_x86_64_msvc"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
 dependencies = [
- "winapi",
+ "memchr",
 ]
 
 [[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
+name = "winnow"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 
 [[package]]
-name = "windows-sys"
-version = "0.32.0"
+name = "winnow"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3df6e476185f92a12c072be4a189a0210dcdcf512a1891d6dff9edb874deadc6"
+checksum = "a90e88e4667264a994d34e6d1ab2d26d398dcdca8b7f52bec8668957517fc7d8"
 dependencies = [
- "windows_aarch64_msvc 0.32.0",
- "windows_i686_gnu 0.32.0",
- "windows_i686_msvc 0.32.0",
- "windows_x86_64_gnu 0.32.0",
- "windows_x86_64_msvc 0.32.0",
+ "memchr",
 ]
 
 [[package]]
-name = "windows-sys"
-version = "0.45.0"
+name = "wiremock"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+checksum = "08db1edfb05d9b3c1542e521aea074442088292f00b5f28e435c714a98f85031"
 dependencies = [
- "windows-targets 0.42.2",
+ "assert-json-diff",
+ "base64",
+ "deadpool 0.12.3",
+ "futures 0.3.31",
+ "http 1.4.2",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "log",
+ "once_cell",
+ "regex",
+ "serde",
+ "serde_json",
+ "tokio",
+ "url",
 ]
 
 [[package]]
-name = "windows-sys"
-version = "0.48.0"
+name = "wit-bindgen"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 dependencies = [
- "windows-targets 0.48.0",
+ "wit-bindgen-rust-macro",
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.42.2"
+name = "wit-bindgen-core"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
 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",
+ "anyhow",
+ "heck 0.5.0",
+ "wit-parser 0.244.0",
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.48.0"
+name = "wit-bindgen-rt"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
+checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
 dependencies = [
- "windows_aarch64_gnullvm 0.48.0",
- "windows_aarch64_msvc 0.48.0",
- "windows_i686_gnu 0.48.0",
- "windows_i686_msvc 0.48.0",
- "windows_x86_64_gnu 0.48.0",
- "windows_x86_64_gnullvm 0.48.0",
- "windows_x86_64_msvc 0.48.0",
+ "bitflags 2.11.1",
 ]
 
 [[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.0"
+name = "wit-bindgen-rust"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.14.0",
+ "prettyplease",
+ "syn 2.0.118",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
 
 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.32.0"
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8e92753b1c443191654ec532f14c199742964a061be25d77d7a96f09db20bf5"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
 
 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.2"
+name = "wit-component"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.1",
+ "indexmap 2.14.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder 0.244.0",
+ "wasm-metadata",
+ "wasmparser 0.244.0",
+ "wit-parser 0.244.0",
+]
 
 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.0"
+name = "wit-parser"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.14.0",
+ "log",
+ "semver 1.0.28",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.244.0",
+]
 
 [[package]]
-name = "windows_i686_gnu"
-version = "0.32.0"
+name = "wit-parser"
+version = "0.251.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a711c68811799e017b6038e0922cb27a5e2f43a2ddb609fe0b6f3eeda9de615"
+checksum = "e960732e824fab95099971a09e638979347c94ca48568d3c854c945729196947"
+dependencies = [
+ "anyhow",
+ "hashbrown 0.17.0",
+ "id-arena",
+ "indexmap 2.14.0",
+ "log",
+ "semver 1.0.28",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.251.0",
+]
 
 [[package]]
-name = "windows_i686_gnu"
-version = "0.42.2"
+name = "write16"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
 
 [[package]]
-name = "windows_i686_gnu"
-version = "0.48.0"
+name = "writeable"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
+checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
 
 [[package]]
-name = "windows_i686_msvc"
-version = "0.32.0"
+name = "ws_stream_wasm"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "146c11bb1a02615db74680b32a68e2d61f553cc24c4eb5b4ca10311740e44172"
+checksum = "6c173014acad22e83f16403ee360115b38846fe754e735c5d9d3803fe70c6abc"
+dependencies = [
+ "async_io_stream",
+ "futures 0.3.31",
+ "js-sys",
+ "log",
+ "pharos",
+ "rustc_version 0.4.0",
+ "send_wrapper",
+ "thiserror 2.0.18",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
 
 [[package]]
-name = "windows_i686_msvc"
-version = "0.42.2"
+name = "wyz"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
 
 [[package]]
-name = "windows_i686_msvc"
-version = "0.48.0"
+name = "xxhash-rust"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
+checksum = "63658493314859b4dfdf3fb8c1defd61587839def09582db50b8a4e93afca6bb"
 
 [[package]]
-name = "windows_x86_64_gnu"
-version = "0.32.0"
+name = "yansi"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c912b12f7454c6620635bbff3450962753834be2a594819bd5e945af18ec64bc"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
 [[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.2"
+name = "yoke"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
 
 [[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.0"
+name = "yoke-derive"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
+checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "synstructure",
+]
 
 [[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.2"
+name = "zerocopy"
+version = "0.8.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+checksum = "668f5168d10b9ee831de31933dc111a459c97ec93225beb307aed970d1372dfd"
+dependencies = [
+ "zerocopy-derive",
+]
 
 [[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.0"
+name = "zerocopy-derive"
+version = "0.8.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
+checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
 
 [[package]]
-name = "windows_x86_64_msvc"
-version = "0.32.0"
+name = "zerofrom"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "504a2476202769977a040c6364301a3f65d0cc9e3fb08600b2bda150a0488316"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
 
 [[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.2"
+name = "zerofrom-derive"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "synstructure",
+]
 
 [[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.0"
+name = "zeroize"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
+dependencies = [
+ "zeroize_derive",
+]
 
 [[package]]
-name = "winnow"
-version = "0.5.17"
+name = "zeroize_derive"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3b801d0e0a6726477cc207f60162da452f3a95adb368399bef20a946e06f65c"
+checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
 dependencies = [
- "memchr",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "winreg"
-version = "0.10.1"
+name = "zerovec"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
+checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
 dependencies = [
- "winapi",
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
 ]
 
 [[package]]
-name = "wyz"
-version = "0.5.0"
+name = "zerovec-derive"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30b31594f29d27036c383b53b59ed3476874d518f0efb151b27a4c275141390e"
+checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
 dependencies = [
- "tap",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "xxhash-rust"
-version = "0.8.5"
+name = "zlib-rs"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "074914ea4eec286eb8d1fd745768504f420a1f7b7919185682a4a267bed7d2e7"
+checksum = "c745c48e1007337ed136dc99df34128b9faa6ed542d80a1c673cf55a6d7236c8"
 
 [[package]]
-name = "yansi"
-version = "0.5.1"
+name = "zmij"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
 
 [[package]]
 name = "zstd"
-version = "0.6.1+zstd.1.4.9"
+version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5de55e77f798f205d8561b8fe2ef57abfb6e0ff2abe7fd3c089e119cdb5631a3"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
 dependencies = [
  "zstd-safe",
 ]
 
 [[package]]
 name = "zstd-safe"
-version = "3.0.1+zstd.1.4.9"
+version = "7.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1387cabcd938127b30ce78c4bf00b30387dddf704e3f0881dbc4ff62b5566f8c"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
 dependencies = [
- "libc",
  "zstd-sys",
 ]
 
 [[package]]
 name = "zstd-sys"
-version = "1.4.20+zstd.1.4.9"
+version = "2.0.15+zstd.1.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebd5b733d7cf2d9447e2c3e76a5589b4f5e5ae065c22a2bc0b023cbc331b6c8e"
+checksum = "eb81183ddd97d0c74cedf1d50d85c8d08c1b8b68ee863bdee9e706eedba1a237"
 dependencies = [
  "cc",
- "libc",
+ "pkg-config",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index c8dd5cf1999..a956a514a95 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,20 +1,33 @@
 [workspace]
+resolver = "2"
 members = [
     "core",
-    "chain/*",
+    "core/graphman",
+    "core/graphman_store",
+    "chain/common",
+    "chain/ethereum",
+    "chain/near",
+    "gnd",
     "graphql",
     "node",
-    "runtime/*",
-    "server/*",
-    "store/*",
-    "substreams/*",
+    "runtime/derive",
+    "runtime/test",
+    "runtime/wasm",
+    "server/graphman",
+    "server/http",
+    "server/index-node",
+    "server/json-rpc",
+    "server/metrics",
+    "store/postgres",
+    "store/test-store",
     "graph",
     "tests",
+    "graph/derive",
 ]
 
 [workspace.package]
-version = "0.34.0"
-edition = "2021"
+version = "0.45.0"
+edition = "2024"
 authors = ["The Graph core developers & contributors"]
 readme = "README.md"
 homepage = "https://thegraph.com"
@@ -22,20 +35,107 @@ repository = "https://github.com/graphprotocol/graph-node"
 license = "MIT OR Apache-2.0"
 
 [workspace.dependencies]
-prost = "0.11.9"
-prost-types = "0.11.9"
-tonic = { version = "0.8.3", features = ["tls-roots", "gzip"] }
-tonic-build = { version = "0.8.4", features = ["prost"] }
+alloy = { version = "2.0.5", features = ["dyn-abi", "json-abi", "full", "arbitrary", "json-rpc", "serde"] }
+alloy-rpc-types = "2.0.0"
+# rustls is pulled in transitively by alloy (aws_lc_rs) and object_store via
+# reqwest (ring). With both providers linked, rustls 0.23 requires an explicit
+# default provider to be installed before any TLS use. We install aws_lc_rs
+# explicitly in each binary/test entry point.
+rustls = { version = "0.23", default-features = false, features = ["aws_lc_rs"] }
+anyhow = "1.0"
+async-graphql = { version = "7.2.1", features = ["chrono"] }
+async-graphql-axum = "7.2.1"
+async-trait = "0.1.74"
+axum = "0.8.9"
+chrono = "0.4.44"
+bs58 = "0.5.1"
+clap = { version = "4.5.4", features = ["derive", "env", "wrap_help"] }
+clap_complete = "4"
+console = "0.16"
+derive_more = { version = "2.1.1", default-features = false }
+diesel = { version = "2.2.7", features = [
+    "postgres",
+    "serde_json",
+    "numeric",
+    "r2d2",
+    "chrono",
+    "i-implement-a-third-party-backend-and-opt-into-breaking-changes",
+] }
+diesel-async = { version = "0.9.0", features = ["deadpool", "async-connection-wrapper", "tokio", "postgres"] }
+diesel-derive-enum = { version = "2.1.0", features = ["postgres"] }
+diesel-dynamic-schema = { version = "0.2.3", features = ["postgres"] }
+diesel_derives = "2.3.9"
+diesel_migrations = "2.3.2"
+env_logger = "0.11.10"
+envconfig = "0.11.1"
+git-testament = "0.2"
+graph = { path = "./graph" }
+graph-core = { path = "./core" }
+graph-store-postgres = { path = "./store/postgres" }
+graphman-server = { path = "./server/graphman" }
+graphman = { path = "./core/graphman" }
+graphman-store = { path = "./core/graphman_store" }
+graphql-tools = "0.5.1"
+indicatif = "0.18"
+Inflector = "0.11.3"
+itertools = "0.15.0"
+lazy_static = "1.5.0"
+prost = "0.14"
+prost-types = "0.14"
+redis = { version = "1.2.2", features = [
+    "aio",
+    "connection-manager",
+    "tokio-comp",
+] }
+regex = "1.5.4"
+reqwest = "0.12.23"
+semver = { version = "1", features = ["serde"] }
+serde = { version = "1.0.126", features = ["rc"] }
+serde_derive = "1.0.125"
+serde_json = { version = "1.0", features = ["arbitrary_precision"] }
+serde_regex = "1.1.0"
+serde_yaml = "0.9.21"
+slog = { version = "2.8.2", features = ["release_max_level_trace", "max_level_trace"] }
+slog-async = "2.5.0"
+slog-term = "2.7.0"
+sqlparser = { version = "0.62.0", features = ["visitor"] }
+strum = { version = "0.28", features = ["derive"] }
+syn = { version = "2.0.117", features = ["full"] }
+test-store = { path = "./store/test-store" }
+thiserror = "2.0.18"
+deadpool = { version = "0.13", features = ["rt_tokio_1", "managed"] }
+tokio = { version = "1.50.0", features = ["full"] }
+tokio-stream = { version = "0.1.18", features = ["sync"] }
+tokio-retry = "0.3.0"
 
-# Incremental compilation on Rust 1.58 causes an ICE on build. As soon as graph node builds again, these can be removed.
-[profile.test]
-incremental = false
+tonic = { version = "0.14", features = ["tls-native-roots", "gzip"] }
+tonic-prost = "0.14"
+tonic-prost-build = "0.14"
+tower-http = { version = "0.7.0", features = ["cors"] }
+tower = { version = "0.5.1", features = ["full"] }
+wasmparser = "0.118.1"
+wasmtime = { version = "46.0.0", features = ["async"] }
+rand = { version = "0.9.2", features = ["os_rng"] }
+prometheus = "0.14.0"
+url = "2.5.8"
 
-[profile.dev]
-incremental = false
+# Dependencies related to Amp subgraphs
+ahash = "0.8.11"
+arrow = { version = "=59.0.0" }
+arrow-flight = { version = "=59.0.0", features = ["flight-sql-experimental"] }
+parquet = { version = "=59.0.0" }
+futures = "0.3.31"
+half = "2.7.1"
+indoc = "2.0.7"
+lazy-regex = "3.6.0"
+parking_lot = "0.12.4"
+sqlparser-latest = { version = "0.57.0", package = "sqlparser", features = ["visitor"] }
+tokio-util = "0.7.15"
+
+[workspace.lints.clippy]
+too_many_arguments = "allow"
+type_complexity = "allow"
 
 [profile.release]
-lto = true
 opt-level = 's'
 strip = "debuginfo"
-
diff --git a/NEWS.md b/NEWS.md
index 1470de669b2..8068ecbc9fa 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,6 +1,523 @@
 # NEWS
 
-## Unreleased
+## v0.45.0
+
+```
+$ docker pull graphprotocol/graph-node:v0.45.0
+```
+
+### Breaking Changes
+
+- **`GRAPH_GETH_ETH_CALL_ERRORS` renamed to `GRAPH_RPC_ETH_CALL_ERRORS`.** The env var (and internal config field) controlling which `eth_call` error messages are treated as reverts is renamed for provider-neutral naming. Update it before upgrading, or the setting is silently ignored and defaults apply. ([#6487](https://github.com/graphprotocol/graph-node/pull/6487))
+
+### What's New
+
+- **Postponed attribute index creation re-enabled, now built in the background.** `GRAPH_POSTPONE_ATTRIBUTE_INDEX_CREATION` (introduced in v0.44.0 but inert — hardcoded off) now actually defers non-critical attribute indexes until a new deployment nears chain head (`GRAPH_POSTPONE_INDEXES_CREATION_THRESHOLD`, default 10000 blocks from head). Index creation now runs in a background task instead of blocking block processing, and interrupted `CREATE INDEX CONCURRENTLY` runs are detected and rebuilt on retry instead of being silently skipped. ([#6608](https://github.com/graphprotocol/graph-node/pull/6608))
+- **`ethereum.decodeParams` host function.** Decodes calldata/event data whose top-level type is a dynamic tuple (e.g. Gnosis Safe's `execTransaction`), which `ethereum.decode` cannot handle since it expects a single ABI value with a leading offset word. Gated behind apiVersion 0.0.10; `ethereum.decode` itself is unchanged. ([#6649](https://github.com/graphprotocol/graph-node/pull/6649))
+
+### Bug Fixes
+
+- Fixed `EthereumLogFilter` merging per-handler `receipt` flags with overwrite instead of OR semantics, so a handler declaring `receipt: true` could silently run with `event.receipt == null` if another handler on the same filter key declared `receipt: false`. ([#6558](https://github.com/graphprotocol/graph-node/pull/6558))
+- Fixed grafts silently succeeding when the graft block was below the base deployment's earliest available block, leaving the destination missing pre-graft entity versions and producing `unexpected null in handler` errors on every event; `Graft::validate` now rejects these upfront. ([#6610](https://github.com/graphprotocol/graph-node/pull/6610))
+- Fixed `_logs` queries returning an empty result (indistinguishable from a subgraph producing no logs) when no log store is configured; now returns a `NotSupported` error. ([#6637](https://github.com/graphprotocol/graph-node/pull/6637))
+- Fixed startup panicking when a shard is configured with `pool_size = 0`; such shards' chains are now skipped instead of erroring. ([#6648](https://github.com/graphprotocol/graph-node/pull/6648))
+- Fixed the Firehose extended-blocks check matching on `optimism-mainnet` instead of the `optimism` chain ID used by Firehose endpoints, so Optimism's extended block data went undetected. ([#6662](https://github.com/graphprotocol/graph-node/pull/6662))
+- Fixed fulltext (`tsvector`) search columns being silently dropped when copying or grafting a subgraph, leaving the destination's fulltext index empty. ([#6687](https://github.com/graphprotocol/graph-node/pull/6687))
+- Fixed Reth `StackUnderflow`/`StackOverflow`/`OpcodeNotFound` EVM halts being misclassified as non-deterministic — Reth surfaces them via its `Debug` format (e.g. `EVM error: StackUnderflow`), which didn't match graph-node's space-separated deterministic-error patterns, so subgraphs indexing via Reth-backed RPC providers stalled and retried instead of recording a deterministic revert. ([#6645](https://github.com/graphprotocol/graph-node/pull/6645))
+
+### Graphman
+
+- Fixed `graphman dump` panicking on tables with more than ~2 GiB in a single string/binary column; batches are now split into byte-bounded slices before conversion to Arrow. ([#6646](https://github.com/graphprotocol/graph-node/pull/6646))
+
+### gnd (Graph Node Dev)
+
+- Fixed `gnd add` producing a subgraph that failed `codegen`/`build` because it never wrote new event entities to `schema.graphql`; unified `add` and `init` onto one scaffolding path, which also fixes event-name collisions across data sources, overloaded-event disambiguation, small-integer type mapping, and reserved-word parameter names. ([#6660](https://github.com/graphprotocol/graph-node/pull/6660))
+
+### Upgrade Notes
+
+- If you set `GRAPH_GETH_ETH_CALL_ERRORS`, rename it to `GRAPH_RPC_ETH_CALL_ERRORS` before upgrading. ([#6487](https://github.com/graphprotocol/graph-node/pull/6487))
+- `GRAPH_POSTPONE_ATTRIBUTE_INDEX_CREATION` now actually takes effect (it was a no-op in v0.44.0). If you already set it expecting no behavior change, be aware new deployments will now defer some attribute indexes until near chain head. ([#6608](https://github.com/graphprotocol/graph-node/pull/6608))
+- If a subgraph was grafted from a base block below the base deployment's earliest available block before this release, it may be missing pre-graft entity versions; re-create the graft from a valid earliest block. ([#6610](https://github.com/graphprotocol/graph-node/pull/6610))
+
+### Contributors
+
+Thanks to all contributors for this release: @cargopete, @dimitrovmaksim, @fordN, @incrypto32, @lutter, @YaroShkvorets
+
+**Full Changelog**: https://github.com/graphprotocol/graph-node/compare/v0.44.0...v0.45.0
+
+## v0.44.0
+
+```
+$ docker pull graphprotocol/graph-node:v0.44.0
+```
+
+### Critical Fix
+
+- **`EntityCache::load_related` returned wrong derived-collection membership on same-block parent reassignment.** Membership was decided against intermediate cache layers rather than the entity's final state, so entities reassigned to a new parent within the same block could be left in the old collection, omitted from the new one, or wrongly retained after a cross-handler revert. See Upgrade Notes. ([#6548](https://github.com/graphprotocol/graph-node/pull/6548))
+
+### Breaking Changes
+
+- **Elasticsearch CLI flags removed.** `--elasticsearch-url`, `--elasticsearch-user`, `--elasticsearch-password` (and the matching `ELASTICSEARCH_*` env vars) are gone. Configure Elasticsearch under the new `[log_store]` section in `graph-node.toml`. See Upgrade Notes. ([#6278](https://github.com/graphprotocol/graph-node/pull/6278))
+
+### What's New
+
+- **Query subgraph logs over GraphQL.** A new `_logs` field exposes subgraph-emitted logs (mapping `log.*` calls, runtime, system) with filters for level, timestamp range, and text search, plus pagination and `orderDirection`. The old Elasticsearch sink for subgraph logs is replaced by a unified `LogStore` abstraction with three backends configured under a new `[log_store]` section in `graph-node.toml`: File (JSON Lines), Loki, or Elasticsearch. Omit `[log_store]` to disable; logs still go to stdout/stderr. ([#6278](https://github.com/graphprotocol/graph-node/pull/6278))
+
+<!--
+TODO(next release): re-add the postponed-index-creation entry once #6608 is verified in the hosted service.
+The implementation (#6434, #6583) is in this release but disabled via `graph: Disable postponed index creation`
+(`postpone_attribute_index_creation` hardcoded to false). Suggested bullet:
+
+- **Postponed index creation extended to syncing subgraphs.** `GRAPH_POSTPONE_ATTRIBUTE_INDEX_CREATION` previously only deferred indexes during copies. It now also postpones indexes during the initial sync of any subgraph, with a new `GRAPH_POSTPONE_INDEXES_CREATION_THRESHOLD` (default 10000) controlling how close to chain head the deployment must get before they're created. Tracked per-deployment so creation runs at most once, even if indexes are manually dropped later. ([#6434](https://github.com/graphprotocol/graph-node/pull/6434) [#6583](https://github.com/graphprotocol/graph-node/pull/6583))
+-->
+
+
+### Improvements
+
+- Revert entity versions during copy instead of in a separate post-copy pass, speeding up subgraph copy and graft. ([#6472](https://github.com/graphprotocol/graph-node/pull/6472))
+
+### Bug Fixes
+
+- Fixed `trace_filter` deserialization failing on providers that omit `result.output` (notably Sonic), which caused repeated trace ingestion retries. Fixed upstream in alloy 2.0.5 ([alloy#3931](https://github.com/alloy-rs/alloy/pull/3931)) and picked up via the bump in this release. ([#6576](https://github.com/graphprotocol/graph-node/pull/6576))
+- Fixed runner panics on out-of-range `BigInt` values: `to_signed_u256` replaced by fallible `to_i256`, and `to_unsigned_u256` now errors on values `>= 2^256` instead of panicking. ([#6560](https://github.com/graphprotocol/graph-node/pull/6560))
+- Fixed `graphman chain change-shard` failing with a duplicate-key error on revert to the original shard. Backups now use unique names and revert reuses the existing `<chain>-old`. ([#6199](https://github.com/graphprotocol/graph-node/pull/6199))
+
+### Upgrade Notes
+
+- v0.44.0 changes `EntityCache::load_related` results for same-block parent-reassignment edge cases ([#6548](https://github.com/graphprotocol/graph-node/pull/6548)). Subgraphs that read derived fields within handlers may diverge in POI from v0.43.0 on blocks exhibiting this pattern; resync from before the affected blocks if affected. The v0.44.0 result is canonical.
+- If you set `--elasticsearch-*` flags or `ELASTICSEARCH_*` env vars, migrate to a `[log_store]` section in `graph-node.toml` before upgrading. See `docs/log-store.md`. ([#6278](https://github.com/graphprotocol/graph-node/pull/6278))
+
+### Contributors
+
+Thanks to all contributors for this release: @erayack, @fordN, @incrypto32, @lutter
+
+**Full Changelog**: https://github.com/graphprotocol/graph-node/compare/v0.43.0...v0.44.0
+
+## v0.43.0
+
+### What's New
+
+- **`skipDuplicates` for immutable entities.** A new `skipDuplicates` parameter on the `@entity` directive (`@entity(immutable: true, skipDuplicates: true)`) silently skips duplicate inserts instead of failing the subgraph. This unblocks subgraph composition on Amp-powered subgraphs where SQL queries can produce the same entities across block ranges. ([#6458](https://github.com/graphprotocol/graph-node/pull/6458))
+- **Per-chain RPC settings via TOML config.** Chain-specific tuning parameters (`json_rpc_timeout`, `request_retries`, `max_block_range_size`, `polling_interval`, `block_batch_size`, etc.) can now be set per chain in `config.toml` instead of relying on global environment variables. Fully backwards compatible — env vars remain the fallback. ([#6459](https://github.com/graphprotocol/graph-node/pull/6459))
+- **RPC provider failover for block ingestor.** When the current RPC provider becomes unreachable during block ingestion polling, graph-node now automatically switches to a healthy alternative provider. ([#6430](https://github.com/graphprotocol/graph-node/pull/6430))
+- Warn on startup when running a debug build, with `[DEBUG-BUILD]` prefix on all log lines. ([#6488](https://github.com/graphprotocol/graph-node/pull/6488))
+
+### Improvements
+
+- **Call cache eviction rewrite.** Replaced the old per-contract iteration approach with ctid-based join deletes against the `call_meta` table, significantly faster on large `call_cache` tables. The old `--ttl-max-contracts` flag has been replaced by `--max-contracts`, which computes an effective TTL cutoff instead of limiting per-invocation iteration. Eviction now also returns stats on the number of contracts and entries removed. ([#6476](https://github.com/graphprotocol/graph-node/pull/6476)) ([#6477](https://github.com/graphprotocol/graph-node/pull/6477))
+- Reduced unnecessary `eth_getBlockByHash` and `eth_getBlockByNumber` RPC calls by checking the block cache first in `block_pointer_from_number` and `fetch_full_block_with_rpc`. ([#6491](https://github.com/graphprotocol/graph-node/pull/6491), partially reverted by [#6537](https://github.com/graphprotocol/graph-node/pull/6537))
+- Header-only `ChainStore` query methods (`ancestor_block_ptr`, `block_parent_ptr`) skip deserializing the full block `data` JSONB column when only hash/number/parent are needed. ([#6456](https://github.com/graphprotocol/graph-node/pull/6456))
+- Batch checking for update attempts on immutable entities, reducing per-entity overhead.
+- Node name is now used as the PostgreSQL `application_name` when `PGAPPNAME` is not set, making it easier to identify graph-node connections in `pg_stat_activity`.
+
+### Bug Fixes
+
+- Fixed dropped block trigger when `once` and `polling` filters match the same block — only one trigger type was firing. ([#6530](https://github.com/graphprotocol/graph-node/pull/6530))
+- Fixed block stream ignoring configured `endBlock` in two cases: the block-skip optimization bypassing the `max_end_block` check, and `max_end_block` being set to `None` when multiple data sources share the same `endBlock`. ([#6474](https://github.com/graphprotocol/graph-node/pull/6474))
+- Fixed GraphQL introspection not returning `isDeprecated: false` for `__InputValue`, which caused some client libraries to fail. ([#6475](https://github.com/graphprotocol/graph-node/pull/6475))
+- Fixed IPC provider connections failing when configured with `ipc://` or `file://` URLs — the URL was passed directly to the transport instead of extracting the file path. ([#6443](https://github.com/graphprotocol/graph-node/pull/6443))
+- Fixed `graphman config pools` not working due to hardcoded pool size override. ([#6444](https://github.com/graphprotocol/graph-node/pull/6444))
+- Fixed unfail retry mechanism stopping after the first attempt when the deployment head was still behind the error block. ([#6529](https://github.com/graphprotocol/graph-node/pull/6529))
+
+### Note on `ethereum.decode()` whitespace handling
+
+The migration from `ethabi` to `alloy` in v0.42.0 ([#6063](https://github.com/graphprotocol/graph-node/pull/6063)) incidentally fixed a long-standing parsing bug in `ethabi` where type strings containing whitespace before a type name (e.g. `" address"` with a leading space) were silently decoded as `Uint(8)` instead of the intended type. `alloy` parses these correctly.
+
+Subgraphs that relied on the incorrect `Uint(8)` decoding to subsequently call `.toBigInt()` on what is actually an `Address` value will abort on v0.42.0+ with:
+
+```
+Mapping aborted ... Ethereum value is not an int or uint.
+```
+
+This is not a graph-node regression. Recompile the subgraph with the correct accessor (`.toAddress()` for addresses) to fix. See [#6461](https://github.com/graphprotocol/graph-node/issues/6461) for details.
+
+### gnd (Graph Node Dev)
+
+- `gnd indexer` command that delegates to `graph-indexer`, allowing indexer management (allocations, rules, cost models, status) directly through gnd. ([#6492](https://github.com/graphprotocol/graph-node/pull/6492))
+- `gnd deploy` now prompts for `--version-label` in interactive mode and requires it in non-interactive mode. ([#6532](https://github.com/graphprotocol/graph-node/pull/6532))
+- Test framework improvements: partial receipt.logs support, mock IPFS/Arweave clients for file data source testing. ([#6442](https://github.com/graphprotocol/graph-node/pull/6442))
+
+### Contributors
+
+Thanks to all contributors for this release: @aayushbaluni, @dimitrovmaksim, @incrypto32, @isum, @lutter, @suntzu
+
+**Full Changelog**: https://github.com/graphprotocol/graph-node/compare/v0.42.1...v0.43.0
+
+## v0.42.1
+
+### Bug Fixes
+
+- Fixed multi-shard deployments becoming unresponsive due to `mirror_primary_tables` holding locks indefinitely, exhausting the connection pool. Added `statement_timeout` and `lock_timeout` to prevent stuck queries from cascading into a full lockup. ([#6446](https://github.com/graphprotocol/graph-node/pull/6446))
+- Fixed the `ingestor` setting in `[chains.*]` config sections having no effect — block ingestion ran regardless of its value. ([#6447](https://github.com/graphprotocol/graph-node/pull/6447))
+
+## v0.42.0
+
+### Breaking Changes
+
+- **Substreams support removed.** Substreams have been unsupported on the network for some time. All substreams-related code has been removed, simplifying the codebase significantly. Substreams-based subgraphs will no longer work. ([#6261](https://github.com/graphprotocol/graph-node/pull/6261))
+- **Migrated from rust-web3 to alloy.** The Ethereum RPC layer now uses the alloy crate instead of rust-web3. This should be transparent to most users, but chains that do not return EIP-2718 typed transaction fields may need the `no_eip2718` provider feature flag. ([#6063](https://github.com/graphprotocol/graph-node/pull/6063)) ([#6317](https://github.com/graphprotocol/graph-node/pull/6317))
+
+### What's New
+
+- **Amp-powered subgraphs (experimental).** A new kind of subgraph powered by [Amp](https://github.com/edgeandnode/amp), the blockchain native database. Amp-powered subgraphs index data directly from Amp servers instead of processing blocks individually, reducing indexing time from days/weeks to minutes/hours. See `docs/amp-powered-subgraphs.md` for details. ([#6218](https://github.com/graphprotocol/graph-node/pull/6218)) ([#6293](https://github.com/graphprotocol/graph-node/pull/6293)) ([#6369](https://github.com/graphprotocol/graph-node/pull/6369))
+- **SQL query interface (experimental).** A new experimental SQL query interface allows querying subgraph data using SQL syntax via GraphQL. Documentation in `docs/implementation/sql-interface.md`. ([#6172](https://github.com/graphprotocol/graph-node/pull/6172))
+- **Async store.** All store and database interactions are now fully async using `diesel_async`, eliminating blocking database calls from tokio tasks. This improves throughput and reduces the risk of thread starvation under heavy load. ([#6194](https://github.com/graphprotocol/graph-node/pull/6194)) ([#6185](https://github.com/graphprotocol/graph-node/pull/6185))
+- **RPC request compression.** Configurable compression for outgoing JSON-RPC requests to upstream providers, supporting gzip, brotli, and deflate. Configured via provider `features` in the config file. ([#6084](https://github.com/graphprotocol/graph-node/pull/6084))
+- Query the current (partially filled) aggregation bucket with `current: include` in GraphQL requests. ([#6293](https://github.com/graphprotocol/graph-node/pull/6293))
+- Extended `first` and `last` aggregation support to `String`, `Bytes`, and entity reference types. ([#6225](https://github.com/graphprotocol/graph-node/pull/6225))
+- Automated account-like table optimization — an optional background job that detects and marks tables with high entity update ratios as account-like. Enabled via `GRAPH_STORE_ACCOUNT_LIKE_SCAN_INTERVAL_HOURS`, `GRAPH_STORE_ACCOUNT_LIKE_MIN_VERSIONS_COUNT`, and `GRAPH_STORE_ACCOUNT_LIKE_MAX_UNIQUE_RATIO`. ([#6209](https://github.com/graphprotocol/graph-node/pull/6209))
+- Subgraph table sizes and row counts are now exposed in `SubgraphIndexingStatus` via the index-node API. ([#6201](https://github.com/graphprotocol/graph-node/pull/6201))
+- Configurable database setup timeout via `GRAPH_STORE_SETUP_TIMEOUT`.
+- Option to disable the store call cache via `GRAPH_STORE_DISABLE_CALL_CACHE`, useful for indexers with locally hosted RPC nodes. ([#6214](https://github.com/graphprotocol/graph-node/pull/6214))
+- Docker: added profiling support to the `graph-node-debug` image with frame pointers and `linux-perf`. ([#6418](https://github.com/graphprotocol/graph-node/pull/6418))
+
+### Improvements
+
+- Optimized WASM trigger instantiation by caching linker and compilation artifacts, reducing per-trigger overhead. ([#6364](https://github.com/graphprotocol/graph-node/pull/6364))
+- Optimized log filter matching and trigger allocation, reducing CPU usage during block processing. ([#6419](https://github.com/graphprotocol/graph-node/pull/6419))
+- Reduced unnecessary entity clones during block processing. ([#6362](https://github.com/graphprotocol/graph-node/pull/6362))
+- Replaced `std::sync::RwLock` with `parking_lot::RwLock` across multiple components for better performance under contention.
+- Deadlock prevention under heavy load, especially during index node startup — connection pool and store semaphore improvements. ([#6224](https://github.com/graphprotocol/graph-node/pull/6224))
+- Raw subgraph manifests are now loaded from the store cache during startup, reducing IPFS dependency. ([#6223](https://github.com/graphprotocol/graph-node/pull/6223))
+- Deployment hashes are now logged when removing a subgraph. ([#6405](https://github.com/graphprotocol/graph-node/pull/6405))
+
+### Bug Fixes
+
+- Fixed duplicate VID when multiple offchain triggers (file/IPFS data sources) fire in the same block, causing unique constraint violations. Also fixed in `ipfs.map()` callbacks. ([#6336](https://github.com/graphprotocol/graph-node/pull/6336)) ([#6416](https://github.com/graphprotocol/graph-node/pull/6416))
+- Fixed incorrect `nocase` filter generation for non-String types (e.g., `Bytes`), which caused SQL errors like `operator does not exist: bytea ~~* bytea`. ([#6351](https://github.com/graphprotocol/graph-node/pull/6351))
+- Fixed `can_copy_from` failures not fully rolling back deployment creation, leaving orphaned records. ([#6228](https://github.com/graphprotocol/graph-node/pull/6228))
+- Fixed multi-column index validation bug where column order mismatch caused valid indexes to be silently dropped during subgraph copy/graft. ([#6341](https://github.com/graphprotocol/graph-node/pull/6341))
+- Fixed grafting failure ("Unexpected null for non-null column") when source tables have too few rows for PostgreSQL to generate `histogram_bounds` statistics. ([#6275](https://github.com/graphprotocol/graph-node/pull/6275))
+- Fixed panic when converting a negative number to `U256` in the runtime — now returns an error instead. ([#6219](https://github.com/graphprotocol/graph-node/pull/6219))
+- Fixed `graphman copy` copying pruned `earliest_block_number` from source, which could leave the destination deployment in an invalid state. ([#6384](https://github.com/graphprotocol/graph-node/pull/6384))
+- Fixed calls returning `0x` being incorrectly cached in the call cache, preventing stale empty results from persisting. ([#6187](https://github.com/graphprotocol/graph-node/pull/6187))
+
+### Graphman
+
+- **`graphman dump` and `graphman restore` (experimental).** New commands for exporting and importing subgraph data in Parquet format, enabling backup and migration of deployment data across shards. Supports incremental dumps and progress reporting. See `docs/dump.md` for details. ([#6397](https://github.com/graphprotocol/graph-node/pull/6397))
+- `graphman chain call-cache remove` now supports `--ttl-days` to remove stale call cache entries that haven't been accessed within a specified number of days. ([#6186](https://github.com/graphprotocol/graph-node/pull/6186))
+
+### gnd (Graph Node Dev)
+
+- **[experimental]** Major expansion of `gnd` as a drop-in replacement for `graph-cli`: `init`, `add`, `codegen`, `build`, `publish`, `deploy`, `create`, `remove`, `auth`, `clean`, and `test` commands. ([#6282](https://github.com/graphprotocol/graph-node/pull/6282))
+
+### Contributors
+
+Thanks to all contributors for this release: @DaMandal0rian, @dimitrovmaksim, @fubhy, @hudsonhrh, @incrypto32, @isum, @lutter, @shiyasmohd
+
+**Full Changelog**: https://github.com/graphprotocol/graph-node/compare/v0.41.2...v0.42.0
+
+## v0.41.2
+
+### Bug Fixes
+
+- Fixed entity corruption after rewinding pruned subgraphs — rewinding a subgraph with `history_blocks` (pruning) enabled could leave frequently-updated entities with no open version, causing deterministic `unexpected null` errors and making the subgraph unrecoverable without a full re-index ([#6340](https://github.com/graphprotocol/graph-node/pull/6340))
+- Fixed `graphman rewind` and `graphman truncate` targeting the wrong deployment when multiple instances of the same subgraph exist ([#6299](https://github.com/graphprotocol/graph-node/pull/6299))
+- Fixed batch write memoization bug where entity lookups could incorrectly return `None`, causing missed entity updates during indexing ([#6314](https://github.com/graphprotocol/graph-node/pull/6314))
+- Expanded deterministic RPC error handling for Reth and Erigon — added `vm execution error`, `invalidjump`, `notactivated`, and `invalidfeopcode` to recognized deterministic errors. Indexers using these clients no longer need to set `GRAPH_GETH_ETH_CALL_ERRORS` manually for these cases ([#6355](https://github.com/graphprotocol/graph-node/pull/6355))
+
+**Full changelog:** <https://github.com/graphprotocol/graph-node/compare/v0.41.1...v0.41.2>
+
+## v0.41.1
+
+### Bug Fixes
+
+- Fixed a regression in v0.41.0 where the indexing status endpoint would return an empty list when querying all subgraphs without specific deployment filters ([#6210](https://github.com/graphprotocol/graph-node/pull/6210))
+
+**Full changelog:** <https://github.com/graphprotocol/graph-node/compare/v0.41.0...v0.41.1>
+
+## v0.41.0
+
+### Bug Fixes
+
+- Fix non-deterministic handling of transaction receipts in event handlers; receipts are only processed when explicitly declared ([#6200](https://github.com/graphprotocol/graph-node/pull/6200))
+
+### New Features
+
+- Added support for struct field access in declarative calls — enables accessing nested struct fields by field name using dot notation in manifest call declarations ([#6099](https://github.com/graphprotocol/graph-node/pull/6099))
+- New standalone `gnd` (Graph Node Dev) crate — a graph-node binary optimized for local development with minimal setup required ([#6167](https://github.com/graphprotocol/graph-node/pull/6167))
+- Extended IPFS usage metrics and logging capabilities ([#6058](https://github.com/graphprotocol/graph-node/pull/6058))
+- Extended support for additional IPFS content path formats ([#6058](https://github.com/graphprotocol/graph-node/pull/6058))
+
+### Improvements
+
+- Deferred IPFS manifest fetching when starting subgraphs — fixes issue where slow IPFS responses could block assignment event processing ([#6170](https://github.com/graphprotocol/graph-node/pull/6170))
+- Added Content Identifier (CID) to IPFS retry logs for better debugging ([#6144](https://github.com/graphprotocol/graph-node/pull/6144))
+- Fixed handling of empty arrays in indexing status queries ([#6143](https://github.com/graphprotocol/graph-node/pull/6143))
+- Fixed case-insensitive array inputs in queries ([#6075](https://github.com/graphprotocol/graph-node/pull/6075))
+- Fixed panic when handling empty lists in `list_values` ([#6100](https://github.com/graphprotocol/graph-node/pull/6100))
+- Enhanced logging for subgraph assignment processing ([#6169](https://github.com/graphprotocol/graph-node/pull/6169))
+- Added logging for `MAX_BLOCKING_THREADS` configuration setting ([#6161](https://github.com/graphprotocol/graph-node/pull/6161))
+
+**Full changelog:** <https://github.com/graphprotocol/graph-node/compare/v0.40.1...v0.41.0>
+
+## v0.40.1
+
+### Improvements
+
+- Enhanced IPFS logging to include Content Identifiers (CIDs) in operation names for better debugging
+
+**Full changelog:** <https://github.com/graphprotocol/graph-node/compare/v0.40.0...v0.40.1>
+
+## v0.40.0
+
+### Critical Bugfix
+
+- Fixed GraphQL query panic with empty arrays: Resolved a critical bug where GraphQL queries using `_in` filters with empty arrays would cause the graph-node to panic ([#6100](https://github.com/graphprotocol/graph-node/pull/6100))
+
+### New Features
+
+- IPFS files can now be cached to disk using `GRAPH_IPFS_CACHE_LOCATION` — reduces IPFS requests after restarts ([#6031](https://github.com/graphprotocol/graph-node/pull/6031))
+
+### Improvements
+
+- Speed up appending changes to batch operations ([#6025](https://github.com/graphprotocol/graph-node/pull/6025))
+- Improved backoff strategy for offchain data sources, configurable via `GRAPH_FDS_MAX_BACKOFF` ([#6043](https://github.com/graphprotocol/graph-node/pull/6043))
+- Better error messages for OR operator usage with column filters ([#6078](https://github.com/graphprotocol/graph-node/pull/6078))
+- Update Wasmtime version for improved WebAssembly performance ([#6050](https://github.com/graphprotocol/graph-node/pull/6050))
+
+### Bug Fixes
+
+- Fixed subgraph composition sync failures with different ID types ([#6080](https://github.com/graphprotocol/graph-node/pull/6080))
+- Fixed pruning status reporting accuracy ([#6062](https://github.com/graphprotocol/graph-node/pull/6062))
+
+**Full changelog:** <https://github.com/graphprotocol/graph-node/compare/v0.39.1...v0.40.0>
+
+## v0.39.1
+
+### Critical Fix
+
+- Reverted `event.transactionLogIndex` behavior change from v0.38.0 that caused subgraph failures with duplicate ID errors and POI divergence between indexers ([#6042](https://github.com/graphprotocol/graph-node/pull/6042))
+
+**Full changelog:** <https://github.com/graphprotocol/graph-node/compare/v0.39.0...v0.39.1>
+
+## v0.39.0
+
+### Breaking Changes
+
+- **Database schema migration**: `subgraphs.subgraph_deployment` table split into `subgraphs.head` and `subgraphs.deployment`. External tools accessing this table will need updates. See [documentation](https://github.com/graphprotocol/graph-node/blob/master/docs/implementation/metadata.md#subgraphshead) ([#6003](https://github.com/graphprotocol/graph-node/pull/6003))
+- **Arweave blockchain support removed** — Arweave subgraphs are no longer supported (file data sources remain unaffected) ([#5951](https://github.com/graphprotocol/graph-node/pull/5951))
+- **`graphman drop` removed** — Use `graphman remove` followed by `graphman unused record && graphman unused remove` ([#5974](https://github.com/graphprotocol/graph-node/pull/5974))
+- **Failed subgraphs are now paused instead of unassigned** ([#5971](https://github.com/graphprotocol/graph-node/pull/5971))
+
+### New Features
+
+- Pruning status tracking with new graphman commands: `prune status`, `prune run`, `prune set` ([#5949](https://github.com/graphprotocol/graph-node/pull/5949))
+- Pruning timeout protection via `GRAPH_STORE_BATCH_TIMEOUT` ([#6002](https://github.com/graphprotocol/graph-node/pull/6002))
+- `graphman chain ingest` for manually ingesting specific blocks ([#5945](https://github.com/graphprotocol/graph-node/pull/5945))
+- Configurable IPFS retry limits via `GRAPH_IPFS_MAX_ATTEMPTS` and `GRAPH_IPFS_REQUEST_TIMEOUT` ([#5998](https://github.com/graphprotocol/graph-node/pull/5998))
+
+### Bug Fixes
+
+- Fixed VID sequence naming to comply with PostgreSQL 63-character limit
+- Fixed pruning of tables with VID sequences using CASCADE drops ([#5968](https://github.com/graphprotocol/graph-node/pull/5968))
+- Fixed numerical precision issues with large VID values ([#5970](https://github.com/graphprotocol/graph-node/pull/5970))
+
+**Full changelog:** <https://github.com/graphprotocol/graph-node/compare/v0.38.0...v0.39.0>
+
+## v0.38.0
+
+### What's new
+
+- A new `deployment_synced` metric is added [(#5816)](https://github.com/graphprotocol/graph-node/pull/5816)
+  that indicates whether a deployment has reached the chain head since it was deployed.
+
+  **Possible values for the metric:**
+    - `0` - means that the deployment is not synced;
+    - `1` - means that the deployment is synced;
+
+  _If a deployment is not running, the metric reports no value for that deployment._
+
+## v0.37.0
+
+### What's new
+
+- A new `deployment_status` metric is added [(#5720)](https://github.com/graphprotocol/graph-node/pull/5720) with the
+  following behavior:
+    - Once graph-node has figured out that it should index a deployment, `deployment_status` is set to `1` _(starting)_;
+    - When the block stream is created and blocks are ready to be processed, `deployment_status` is set to `2` _(
+      running)_;
+    - When a deployment is unassigned, `deployment_status` is set to `3` _(stopped)_;
+    - If a temporary or permanent failure occurs, `deployment_status` is set to `4` _(failed)_;
+        - If indexing manages to recover from a temporary failure, the `deployment_status` is set back to `2` _(
+          running)_;
+
+### Breaking changes
+
+- The `deployment_failed` metric is removed and the failures are reported by the new `deployment_status`
+  metric. [(#5720)](https://github.com/graphprotocol/graph-node/pull/5720)
+
+## v0.36.0
+
+### Note on Firehose Extended Block Details
+
+By default, all Firehose providers are required to support extended block details, as this is the
+safest option for a graph-node operator. Firehose providers that do not support extended block
+details for enabled chains are considered invalid and will not be used.
+
+To disable checks for one or more chains, simply specify their names
+in `GRAPH_NODE_FIREHOSE_DISABLE_EXTENDED_BLOCKS_FOR_CHAINS` as a comma separated list of chain
+names. Graph Node defaults to an empty list, which means that this feature is enabled for all
+chains.
+
+### What's new
+
+- Add support for substreams using 'index modules', 'block filters', 'store:sum_set'. [(#5463)](https://github.com/graphprotocol/graph-node/pull/5463)
+- Implement new IPFS client [(#5600)](https://github.com/graphprotocol/graph-node/pull/5600)
+- Add `timestamp` support to substreams. [(#5641)](https://github.com/graphprotocol/graph-node/pull/5641)
+- Add graph-indexed header to query responses. [(#5710)](https://github.com/graphprotocol/graph-node/pull/5710)
+- Use the new Firehose info endpoint. [(#5672)](https://github.com/graphprotocol/graph-node/pull/5672)
+- Store `synced_at_block_number` when a deployment syncs. [(#5610)](https://github.com/graphprotocol/graph-node/pull/5610)
+- Create nightly docker builds from master branch. [(#5400)](https://github.com/graphprotocol/graph-node/pull/5400)
+- Make sure `transact_block_operations` does not go backwards. [(#5419)](https://github.com/graphprotocol/graph-node/pull/5419)
+- Improve error message when store write fails. [(#5420)](https://github.com/graphprotocol/graph-node/pull/5420)
+- Allow generating map of section nesting in debug builds. [(#5279)](https://github.com/graphprotocol/graph-node/pull/5279)
+- Ensure substream module name is valid. [(#5424)](https://github.com/graphprotocol/graph-node/pull/5424)
+- Improve error message when resolving references. [(#5385)](https://github.com/graphprotocol/graph-node/pull/5385)
+- Check if subgraph head exists before trying to unfail. [(#5409)](https://github.com/graphprotocol/graph-node/pull/5409)
+- Check for EIP 1898 support when checking block receipts support. [(#5406)](https://github.com/graphprotocol/graph-node/pull/5406)
+- Use latest block hash for `check_block_receipts`. [(#5427)](https://github.com/graphprotocol/graph-node/pull/5427)
+- Handle null blocks from Lotus. [(#5294)](https://github.com/graphprotocol/graph-node/pull/5294)
+- Increase firehose grpc max decode size. [(#5483)](https://github.com/graphprotocol/graph-node/pull/5483)
+- Improve Environment variable docs, rename `GRAPH_ETHEREUM_BLOCK_RECEIPTS_TIMEOUT` to `GRAPH_ETHEREUM_BLOCK_RECEIPTS_CHECK_TIMEOUT`. [(#5468)](https://github.com/graphprotocol/graph-node/pull/5468)
+- Remove provider checks at startup. [(#5337)](https://github.com/graphprotocol/graph-node/pull/5337)
+- Track more features in subgraph features table. [(#5479)](https://github.com/graphprotocol/graph-node/pull/5479)
+- Implement is_duplicate_of for substreams. [(#5482)](https://github.com/graphprotocol/graph-node/pull/5482)
+- Add docs for `GRAPH_POSTPONE_ATTRIBUTE_INDEX_CREATION`. [(#5515)](https://github.com/graphprotocol/graph-node/pull/5515)
+- Improve error message for missing template during grafting. [(#5464)](https://github.com/graphprotocol/graph-node/pull/5464)
+- Enable "hard-coded" values in declarative eth_calls. [(#5498)](https://github.com/graphprotocol/graph-node/pull/5498)
+- Respect causality region in derived fields. [(#5488)](https://github.com/graphprotocol/graph-node/pull/5488)
+- Improve net_identifiers call with timeout. [(#5549)](https://github.com/graphprotocol/graph-node/pull/5549)
+- Add arbitrum-sepolia chain ID to GRAPH_ETH_CALL_NO_GAS default value. [(#5504)](https://github.com/graphprotocol/graph-node/pull/5504)
+- Disable genesis validation by default. [(#5565)](https://github.com/graphprotocol/graph-node/pull/5565)
+- Timeout when trying to get `net_identifiers` at startup. [(#5568)](https://github.com/graphprotocol/graph-node/pull/5568)
+- Only start substreams if no other block investor is available. [(#5569)](https://github.com/graphprotocol/graph-node/pull/5569)
+- Allow running a single test case for integration tests. [(#5577)](https://github.com/graphprotocol/graph-node/pull/5577)
+- Store timestamp when marking subgraph as synced. [(#5566)](https://github.com/graphprotocol/graph-node/pull/5566)
+- Document missing env vars. [(#5580)](https://github.com/graphprotocol/graph-node/pull/5580)
+- Return more features in status API. [(#5582)](https://github.com/graphprotocol/graph-node/pull/5582)
+- Respect substreams datasource `startBlock`. [(#5617)](https://github.com/graphprotocol/graph-node/pull/5617)
+- Update flagged dependencies. [(#5659)](https://github.com/graphprotocol/graph-node/pull/5659)
+- Add more debug logs when subgraph is marked unhealthy. [(#5662)](https://github.com/graphprotocol/graph-node/pull/5662)
+- Add config option for cache stores. [(#5716)](https://github.com/graphprotocol/graph-node/pull/5716)
+
+### Bug fixes
+
+- Add safety check when rewinding. [(#5423)](https://github.com/graphprotocol/graph-node/pull/5423)
+- Fix rewind for deployments with multiple names. [(#5502)](https://github.com/graphprotocol/graph-node/pull/5502)
+- Improve `graphman copy` performance [(#5425)](https://github.com/graphprotocol/graph-node/pull/5425)
+- Fix retrieving chain info with graphman for some edge cases. [(#5516)](https://github.com/graphprotocol/graph-node/pull/5516)
+- Improve `graphman restart` to handle multiple subgraph names for a deployment. [(#5674)](https://github.com/graphprotocol/graph-node/pull/5674)
+- Improve adapter startup. [(#5503)](https://github.com/graphprotocol/graph-node/pull/5503)
+- Detect Nethermind eth_call reverts. [(#5533)](https://github.com/graphprotocol/graph-node/pull/5533)
+- Fix genesis block fetching for substreams. [(#5548)](https://github.com/graphprotocol/graph-node/pull/5548)
+- Fix subgraph_resume being mislabelled as pause. [(#5588)](https://github.com/graphprotocol/graph-node/pull/5588)
+- Make `SubgraphIndexingStatus.paused` nullable. [(#5551)](https://github.com/graphprotocol/graph-node/pull/5551)
+- Fix a count aggregation bug. [(#5639)](https://github.com/graphprotocol/graph-node/pull/5639)
+- Fix prost generated file. [(#5450)](https://github.com/graphprotocol/graph-node/pull/5450)
+- Fix `deployment_head` metrics not progressing for substreams. [(#5522)](https://github.com/graphprotocol/graph-node/pull/5522)
+- Enable graft validation checks in debug builds. [(#5584)](https://github.com/graphprotocol/graph-node/pull/5584)
+- Use correct store when loading indexes for graft base. [(#5616)](https://github.com/graphprotocol/graph-node/pull/5616)
+- Sanitise columns in SQL. [(#5578)](https://github.com/graphprotocol/graph-node/pull/5578)
+- Truncate `subgraph_features` table before migrating. [(#5505)](https://github.com/graphprotocol/graph-node/pull/5505)
+- Consistently apply max decode size. [(#5520)](https://github.com/graphprotocol/graph-node/pull/5520)
+- Various docker packaging improvements [(#5709)](https://github.com/graphprotocol/graph-node/pull/5709) [(#5711)](https://github.com/graphprotocol/graph-node/pull/5711) [(#5712)](https://github.com/graphprotocol/graph-node/pull/5712) [(#5620)](https://github.com/graphprotocol/graph-node/pull/5620) [(#5621)](https://github.com/graphprotocol/graph-node/pull/5621)
+- Retry IPFS requests on Cloudflare 521 Web Server Down. [(#5687)](https://github.com/graphprotocol/graph-node/pull/5687)
+- Optimize IPFS retries. [(#5698)](https://github.com/graphprotocol/graph-node/pull/5698)
+- Exclude full-text search columns from entity queries. [(#5693)](https://github.com/graphprotocol/graph-node/pull/5693)
+- Do not allow multiple active runners for a subgraph. [(#5715)](https://github.com/graphprotocol/graph-node/pull/5715)
+- Stop subgraphs passing max endBlock. [(#5583)](https://github.com/graphprotocol/graph-node/pull/5583)
+- Do not repeat a rollup after restart in some corner cases. [(#5675)](https://github.com/graphprotocol/graph-node/pull/5675)
+
+### Graphman
+
+- Add command to update genesis block for a chain and to check genesis information against all providers. [(#5517)](https://github.com/graphprotocol/graph-node/pull/5517)
+- Create GraphQL API to execute commands [(#5554)](https://github.com/graphprotocol/graph-node/pull/5554)
+- Add graphman create/remove commands to GraphQL API. [(#5685)](https://github.com/graphprotocol/graph-node/pull/5685)
+
+### Contributors
+
+Thanks to all contributors for this release: @dwerner, @encalypto, @incrypto32, @isum, @leoyvens, @lutter, @mangas, @sduchesneau, @Shiyasmohd, @shuaibbapputty, @YaroShkvorets, @ziyadonji, @zorancv
+
+**Full Changelog**: https://github.com/graphprotocol/graph-node/compare/v0.35.1...v0.36.0
+
+## v0.35.0
+### What's new
+
+- **Aggregations** - Declarative aggregations defined in the subgraph schema allow the developer to aggregate values on specific intervals using flexible aggregation functions. [(#5082)](https://github.com/graphprotocol/graph-node/pull/5082) [(#5184)](https://github.com/graphprotocol/graph-node/pull/5184) [(#5209)](https://github.com/graphprotocol/graph-node/pull/5209) [(#5242)](https://github.com/graphprotocol/graph-node/pull/5242) [(#5208)](https://github.com/graphprotocol/graph-node/pull/5208)
+- **Add pause and resume to admin JSON-RPC API** - Adds support for explicit pausing and resuming of subgraph deployments with a field tracking the paused state in `indexerStatuses`. [(#5190)](https://github.com/graphprotocol/graph-node/pull/5190)
+- **Support eth_getBalance calls in subgraph mappings** - Enables fetching the Eth balance of an address from the mappings using `ethereum.getBalance(address)`. [(#5202)](https://github.com/graphprotocol/graph-node/pull/5202)
+- **Add parentHash to _meta query** - Particularly useful when polling for data each block to verify the sequence of blocks. [(#5232)](https://github.com/graphprotocol/graph-node/pull/5232)
+- **Parallel execution of all top-level queries in a single query body** [(#5273)](https://github.com/graphprotocol/graph-node/pull/5273)
+- The ElasticSearch index to which `graph-node` logs can now be configured with the `GRAPH_ELASTIC_SEARCH_INDEX` environment variable which defaults to `subgraph`. [(#5210)](https://github.com/graphprotocol/graph-node/pull/5210)
+- Some small prefetch simplifications. [(#5132)](https://github.com/graphprotocol/graph-node/pull/5132)
+- Migration changing the type of health column to text. [(#5077)](https://github.com/graphprotocol/graph-node/pull/5077)
+- Disable eth_call_execution_time metric by default. [(#5164)](https://github.com/graphprotocol/graph-node/pull/5164)
+- Call revert_state_to whenever blockstream is restarted. [(#5187)](https://github.com/graphprotocol/graph-node/pull/5187)
+- Pruning performance improvement: only analyze when rebuilding. [(#5186)](https://github.com/graphprotocol/graph-node/pull/5186)
+- Disallow grafts within the reorg threshold. [(#5135)](https://github.com/graphprotocol/graph-node/pull/5135)
+- Optimize subgraph synced check-less. [(#5198)](https://github.com/graphprotocol/graph-node/pull/5198)
+- Improve error log. [(#5217)](https://github.com/graphprotocol/graph-node/pull/5217)
+- Update provider docs. [(#5216)](https://github.com/graphprotocol/graph-node/pull/5216)
+- Downgrade 'Entity cache statistics' log to trace. [(#5241)](https://github.com/graphprotocol/graph-node/pull/5241)
+- Do not clone MappingEventHandlers in match_and_decode. [(#5244)](https://github.com/graphprotocol/graph-node/pull/5244)
+- Make batching conditional on caught-up status. [(#5252)](https://github.com/graphprotocol/graph-node/pull/5252)
+- Remove hack in chain_head_listener. [(#5240)](https://github.com/graphprotocol/graph-node/pull/5240)
+- Increase sleep time in write queue processing. [(#5266)](https://github.com/graphprotocol/graph-node/pull/5266)
+- Memoize Batch.indirect_weight. [(#5276)](https://github.com/graphprotocol/graph-node/pull/5276) 
+- Optionally track detailed indexing gas metrics in csv. [(#5215)](https://github.com/graphprotocol/graph-node/pull/5215)
+- store: Do not use prefix comparisons for primary keys. [(#5289)](https://github.com/graphprotocol/graph-node/pull/5289)
+
+### Graphman
+
+- Add ability to list removed unused deployment by id. [(#5152)](https://github.com/graphprotocol/graph-node/pull/5152)
+- Add command to change block cache shard. [(#5169)](https://github.com/graphprotocol/graph-node/pull/5169)
+
+### Firehose and Substreams
+
+- **Add key-based authentication for Firehose/Substreams providers.** [(#5259)](https://github.com/graphprotocol/graph-node/pull/5259)
+- Increase blockstream buffer size for substreams. [(#5182)](https://github.com/graphprotocol/graph-node/pull/5182)
+- Improve substreams error handling. [(#5160)](https://github.com/graphprotocol/graph-node/pull/5160)
+- Reset substreams/firehose block ingestor backoff. [(#5047)](https://github.com/graphprotocol/graph-node/pull/5047)
+
+### Bug Fixes
+
+- Fix graphiql issue when querying subgraph names with multiple path segments. [(#5136)](https://github.com/graphprotocol/graph-node/pull/5136)
+- Fix change_health_column migration for sharded setup. [(#5183)](https://github.com/graphprotocol/graph-node/pull/5183)
+- Fix conversion of BlockTime for NEAR. [(#5206)](https://github.com/graphprotocol/graph-node/pull/5206)
+- Call revert_state_to to last good block instead of current block. [(#5195)](https://github.com/graphprotocol/graph-node/pull/5195)
+- Fix Action::block_finished. [(#5218)](https://github.com/graphprotocol/graph-node/pull/5218)
+- Fix runtime timeouts. [(#5236)](https://github.com/graphprotocol/graph-node/pull/5236)
+- Remove panic from rewind and truncate. [(#5233)](https://github.com/graphprotocol/graph-node/pull/5233)
+- Fix version stats for huge number of versions. [(#5261)](https://github.com/graphprotocol/graph-node/pull/5261)
+- Fix _meta query failure due to incorrect selection set use. [(#5265)](https://github.com/graphprotocol/graph-node/pull/5265)
+
+### Major dependency upgrades
+
+- Update to diesel 2. [(#5002)](https://github.com/graphprotocol/graph-node/pull/5002)
+- bump rust version. [(#4985)](https://github.com/graphprotocol/graph-node/pull/4985)
+
+### Contributors
+
+Thank you to all the contributors! `@incrypto32`, `@mangas`, `@lutter`, `@leoyvens`, `@zorancv`, `@YaroShkvorets`, `@seem-less`
+
+**Full Changelog**: https://github.com/graphprotocol/graph-node/compare/v0.34.1...v0.35.0
+
+<!--
+Not relevant
+* chore: fix typos by @vuittont60. [(#5214)](https://github.com/graphprotocol/graph-node/pull/5214)
+* bump openssl from 0.10.60 to 0.10.63 by @dependabot. [(#5154)](https://github.com/graphprotocol/graph-node/pull/5154)
+* bump h2 from 0.3.17 to 0.3.24 by @dependabot. [(#5150)](https://github.com/graphprotocol/graph-node/pull/5150)
+* bump crossbeam from 0.8.2 to 0.8.4 by @dependabot. [(#5145)](https://github.com/graphprotocol/graph-node/pull/5145)
+* bump termcolor from 1.4.0 to 1.4.1 by @dependabot. [(#5143)](https://github.com/graphprotocol/graph-node/pull/5143)
+* bump unsafe-libyaml from 0.2.8 to 0.2.10 by @dependabot. [(#5089)](https://github.com/graphprotocol/graph-node/pull/5089)
+* bump anyhow from 1.0.75 to 1.0.79 by @dependabot. [(#5142)](https://github.com/graphprotocol/graph-node/pull/5142)
+-->
+
+## v0.34.1
+## Bug fixes
+- Fixed an issue that caused an increase in data size of /metrics endpoint of graph-node. [(#5161)](https://github.com/graphprotocol/graph-node/issues/5161)
+- Fixed an issue that caused subgraphs with file data sources to skip non-deterministic errors that occurred in a file data source mapping handler.
 
 ## v0.34.0
 ### What's New
@@ -23,7 +540,7 @@
 
 - Addressed a bug in the deduplication logic for Cosmos events, ensuring all distinct events are properly indexed and handled, especially when similar but not identical events occur within the same block. [(#5112)](https://github.com/graphprotocol/graph-node/pull/5112)
 - Fixed compatibility issues with ElasticSearch 8.X, ensuring proper log functionality. [(#5013)](https://github.com/graphprotocol/graph-node/pull/5013)
-- Resolved an issue when rewinding data sources across multiple blocks. In rare cases, when a subgraph had been rewound by multiple blocks, data sources 'from the future' could have been left behind. This release adds a database migration that fixes that. With very unlucky timing this migration might miss some subgraphs, which will later lead to an error `assertion failed: self.hosts.last().and_then(|h| h.creation_block_number()) <= data_source.creation_block()`. Should that happen, the [migration script](https://github.com/graphprotocol/graph-node/blob/master/store/postgres/migrations/2024-01-05-170000_ds_corruption_fix_up/up.sql) should be rerun against the affected shard. [(#5083)](https://github.com/graphprotocol/graph-node/pull/5083)
+  - Resolved an issue when rewinding data sources across multiple blocks. In rare cases, when a subgraph had been rewound by multiple blocks, data sources 'from the future' could have been left behind. This release adds a database migration that fixes that. With very unlucky timing this migration might miss some subgraphs, which will later lead to an error `assertion failed: self.hosts.last().and_then(|h| h.creation_block_number()) <= data_source.creation_block()`. Should that happen, the [migration script](https://github.com/graphprotocol/graph-node/blob/master/store/postgres/migrations/2024-01-05-170000_ds_corruption_fix_up/up.sql) should be rerun against the affected shard. [(#5083)](https://github.com/graphprotocol/graph-node/pull/5083)
 - Increased the base backoff time for RPC, enhancing stability and reliability under load. [(#4984)](https://github.com/graphprotocol/graph-node/pull/4984)
 - Resolved an issue related to spawning offchain data sources from existing offchain data source mappings. [(#5051)](https://github.com/graphprotocol/graph-node/pull/5051)[(#5092)](https://github.com/graphprotocol/graph-node/pull/5092)
 - Resolved an issue where eth-call results for reverted calls were being cached in call cache. [(#4879)](https://github.com/graphprotocol/graph-node/pull/4879)
@@ -244,8 +761,8 @@ Not Relevant
 <!--
 Not relevant
 * graph-chain-ethereum: Avoid adapters with errors by @mangas in https://github.com/graphprotocol/graph-node/pull/4468
-* Limit stack depth of asc_get by @leoyvens in https://gitub.com/graphprotocol/graph-node/pull/4576
-* core: Log how many entries the cache had at each block by @lutter in https://ithub.com/graphprotocol/graph-node/pull/4541
+* Limit stack depth of asc_get by @leoyvens in https://github.com/graphprotocol/graph-node/pull/4576
+* core: Log how many entries the cache had at each block by @lutter in https://github.com/graphprotocol/graph-node/pull/4541
 * store: Remove ability to recount entities by @lutter in https://github.com/graphprotocol/graph-node/pull/4406
 -->
 
@@ -953,7 +1470,7 @@ storage](./docs/config.md) and spread subgraph deployments, and the load
 coming from indexing and querying them across multiple independent Postgres
 databases.
 
-**This feature is considered experimenatal. We encourage users to try this
+**This feature is considered experimental. We encourage users to try this
 out in a test environment, but do not recommend it yet for production use**
 In particular, the details of how sharding is configured may change in
 backwards-incompatible ways in the future.
diff --git a/README.md b/README.md
index ff31fdad758..667c606a045 100644
--- a/README.md
+++ b/README.md
@@ -1,195 +1,157 @@
 # Graph Node
 
 [![Build Status](https://github.com/graphprotocol/graph-node/actions/workflows/ci.yml/badge.svg)](https://github.com/graphprotocol/graph-node/actions/workflows/ci.yml?query=branch%3Amaster)
-[![Getting Started Docs](https://img.shields.io/badge/docs-getting--started-brightgreen.svg)](docs/getting-started.md)
+[![Docs](https://img.shields.io/badge/docs-graph--node-green.svg)](docs/)
+[![Subgraphs](https://img.shields.io/badge/docs-subgraphs-green.svg)](https://thegraph.com/docs/en/subgraphs/quick-start/)
 
-[The Graph](https://thegraph.com/) is a protocol for building decentralized applications (dApps) quickly on Ethereum and IPFS using GraphQL.
+## Overview
 
-Graph Node is an open source Rust implementation that event sources the Ethereum blockchain to deterministically update a data store that can be queried via the GraphQL endpoint.
+[The Graph](https://thegraph.com/) is a decentralized protocol that organizes and distributes blockchain data across the leading Web3 networks. A key component of The Graph's tech stack is Graph Node.
 
-For detailed instructions and more context, check out the [Getting Started Guide](docs/getting-started.md).
+Before using `graph-node,` it is highly recommended that you read the [official Graph documentation](https://thegraph.com/docs/en/subgraphs/quick-start/) to understand Subgraphs, which are the central mechanism for extracting and organizing blockchain data.
 
-## Quick Start
+This guide is for:
 
-### Prerequisites
-
-To build and run this project you need to have the following installed on your system:
-
-- Rust (latest stable) – [How to install Rust](https://www.rust-lang.org/en-US/install.html)
-  - Note that `rustfmt`, which is part of the default Rust installation, is a build-time requirement.
-- PostgreSQL – [PostgreSQL Downloads](https://www.postgresql.org/download/)
-- IPFS – [Installing IPFS](https://docs.ipfs.io/install/)
-- Profobuf Compiler - [Installing Protobuf](https://grpc.io/docs/protoc-installation/)
-
-For Ethereum network data, you can either run your own Ethereum node or use an Ethereum node provider of your choice.
+1. Subgraph developers who want to run `graph-node` locally to test their Subgraphs during development
+2. Contributors who want to add features or fix bugs to `graph-node` itself
 
-**Minimum Hardware Requirements:**
+## Running `graph-node` from Docker images
 
-- To build graph-node with `cargo`, 8GB RAM are required.
+For subgraph developers, it is highly recommended to use prebuilt Docker
+images to set up a local `graph-node` environment. Please read [these
+instructions](./docker/README.md) to learn how to do that.
 
-### Docker
+## Running `graph-node` from source
 
-The easiest way to run a Graph Node is to use the official Docker compose setup. This will start a Postgres database, IPFS node, and Graph Node.
-[Follow the instructions here](./docker/README.md).
+This is usually only needed for developers who want to contribute to `graph-node`.
 
-### Running a Local Graph Node
+### Prerequisites
 
-This is a quick example to show a working Graph Node. It is a [subgraph for Gravatars](https://github.com/graphprotocol/example-subgraph).
+To build and run this project, you need to have the following installed on your system:
 
-1. Install IPFS and run `ipfs init` followed by `ipfs daemon`.
-2. Install PostgreSQL and run `initdb -D .postgres -E UTF8 --locale=C` followed by `pg_ctl -D .postgres -l logfile start` and `createdb graph-node`.
-3. If using Ubuntu, you may need to install additional packages:
-   - `sudo apt-get install -y clang libpq-dev libssl-dev pkg-config`
-4. In the terminal, clone https://github.com/graphprotocol/example-subgraph, and install dependencies and generate types for contract ABIs:
+- Rust (latest stable): Follow [How to install
+  Rust](https://rust-lang.org/tools/install/). Run `rustup install
+stable` in _this directory_ to make sure all required components are
+  installed. The `graph-node` code assumes that the latest available
+  `stable` compiler is used.
+- PostgreSQL: [PostgreSQL Downloads](https://www.postgresql.org/download/) lists
+  downloads for almost all operating systems.
+  - For OSX: We highly recommend [Postgres.app](https://postgresapp.com/).
+  - For Linux: Use the Postgres version that comes with the distribution.
+- IPFS: [Installing IPFS](https://docs.ipfs.io/install/)
+- Protobuf Compiler: [Installing Protobuf](https://grpc.io/docs/protoc-installation/)
 
-```
-yarn
-yarn codegen
-```
-
-5. In the terminal, clone https://github.com/graphprotocol/graph-node, and run `cargo build`.
+For Ethereum network data, you can either run your own Ethereum node or use an Ethereum node provider of your choice.
 
-Once you have all the dependencies set up, you can run the following:
+### Create a database
 
-```
-cargo run -p graph-node --release -- \
-  --postgres-url postgresql://USERNAME[:PASSWORD]@localhost:5432/graph-node \
-  --ethereum-rpc NETWORK_NAME:[CAPABILITIES]:URL \
-  --ipfs 127.0.0.1:5001
-```
+Once Postgres is running, you need to issue the following commands to create a database
+and configure it for use with `graph-node`.
 
-Try your OS username as `USERNAME` and `PASSWORD`. For details on setting
-the connection string, check the [Postgres
-documentation](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING).
-`graph-node` uses a few Postgres extensions. If the Postgres user with which
-you run `graph-node` is a superuser, `graph-node` will enable these
-extensions when it initializes the database. If the Postgres user is not a
-superuser, you will need to create the extensions manually since only
-superusers are allowed to do that. To create them you need to connect as a
-superuser, which in many installations is the `postgres` user:
+The name of the `SUPERUSER` depends on your installation, but is usually `postgres` or your username.
 
 ```bash
-    psql -q -X -U <SUPERUSER> graph-node <<EOF
+psql -U <SUPERUSER> <<EOF
+create user graph with password '<password>';
+create database "graph-node" with owner=graph template=template0 encoding='UTF8' locale='C';
 create extension pg_trgm;
-create extension pg_stat_statements;
 create extension btree_gist;
 create extension postgres_fdw;
-grant usage on foreign data wrapper postgres_fdw to <USERNAME>;
+grant usage on foreign data wrapper postgres_fdw to graph;
 EOF
-
 ```
 
-This will also spin up a GraphiQL interface at `http://127.0.0.1:8000/`.
-
-6.  With this Gravatar example, to get the subgraph working locally run:
+For convenience, set the connection string to the database in an environment
+variable, and save it, e.g., in `~/.bashrc`:
 
-```
-yarn create-local
+```bash
+export POSTGRES_URL=postgresql://graph:<password>@localhost:5432/graph-node
 ```
 
-Then you can deploy the subgraph:
+Use the `POSTGRES_URL` from above to have `graph-node` connect to the
+database. If you ever need to manually inspect the contents of your
+database, you can do that by running `psql $POSTGRES_URL`. Running this
+command is also a convenient way to check that the database is up and
+running and that the connection string is correct.
 
-```
-yarn deploy-local
+### Build and Run `graph-node`
+
+Clone this repository and run this command at the root of the repository:
+
+```bash
+export GRAPH_LOG=debug
+cargo run -p graph-node --release -- \
+  --postgres-url $POSTGRES_URL \
+  --ethereum-rpc NETWORK_NAME:[CAPABILITIES]:URL \
+  --ipfs 127.0.0.1:5001
 ```
 
-This will build and deploy the subgraph to the Graph Node. It should start indexing the subgraph immediately.
+The argument for `--ethereum-rpc` contains a network name (e.g. `mainnet`) and
+a list of provider capabilities (e.g. `archive,traces`). The URL is the address
+of the Ethereum node you want to connect to, usually a `https` URL, so that the
+entire argument might be `mainnet:archive,traces:https://provider.io/some/path`.
 
-### Command-Line Interface
+When `graph-node` starts, it prints the various ports that it is listening on.
+The most important of these is the GraphQL HTTP server, which by default
+is at `http://localhost:8000`. You can use routes like `/subgraphs/name/<subgraph-name>`
+and `/subgraphs/id/<IPFS hash>` to query subgraphs once you have deployed them.
 
-```
-USAGE:
-    graph-node [FLAGS] [OPTIONS] --ethereum-ipc <NETWORK_NAME:FILE> --ethereum-rpc <NETWORK_NAME:URL> --ethereum-ws <NETWORK_NAME:URL> --ipfs <HOST:PORT> --postgres-url <URL>
+### Deploying a Subgraph
 
-FLAGS:
-        --debug      Enable debug logging
-    -h, --help       Prints help information
-    -V, --version    Prints version information
+Follow the [Subgraph deployment
+guide](https://thegraph.com/docs/en/subgraphs/developing/introduction/).
+After setting up `graph-cli` as described, you can deploy a Subgraph to your
+local Graph Node instance.
 
-OPTIONS:
-        --admin-port <PORT>                           Port for the JSON-RPC admin server [default: 8020]
-        --elasticsearch-password <PASSWORD>
-            Password to use for Elasticsearch logging [env: ELASTICSEARCH_PASSWORD]
+### Advanced Configuration
 
-        --elasticsearch-url <URL>
-            Elasticsearch service to write subgraph logs to [env: ELASTICSEARCH_URL=]
+The command line arguments generally are all that is needed to run a
+`graph-node` instance. For advanced uses, various aspects of `graph-node`
+can further be configured through [environment
+variables](https://github.com/graphprotocol/graph-node/blob/master/docs/environment-variables.md).
 
-        --elasticsearch-user <USER>                   User to use for Elasticsearch logging [env: ELASTICSEARCH_USER=]
-        --ethereum-ipc <NETWORK_NAME:[CAPABILITIES]:FILE>
-            Ethereum network name (e.g. 'mainnet'), optional comma-separated capabilities (eg full,archive), and an Ethereum IPC pipe, separated by a ':'
+Very large `graph-node` instances can also be configured using a
+[configuration file](./docs/config.md) That is usually only necessary when
+the `graph-node` needs to connect to multiple chains or if the work of
+indexing and querying needs to be split across [multiple databases](./docs/config.md).
 
-        --ethereum-polling-interval <MILLISECONDS>
-            How often to poll the Ethereum node for new blocks [env: ETHEREUM_POLLING_INTERVAL=]  [default: 500]
+#### Log Storage
 
-        --ethereum-rpc <NETWORK_NAME:[CAPABILITIES]:URL>
-            Ethereum network name (e.g. 'mainnet'), optional comma-separated capabilities (eg 'full,archive'), and an Ethereum RPC URL, separated by a ':'
+`graph-node` supports storing and querying subgraph logs through multiple backends:
 
-        --ethereum-ws <NETWORK_NAME:[CAPABILITIES]:URL>
-            Ethereum network name (e.g. 'mainnet'), optional comma-separated capabilities (eg `full,archive), and an Ethereum WebSocket URL, separated by a ':'
+- **File**: Local JSON Lines files (recommended for local development)
+- **Elasticsearch**: Enterprise-grade search and analytics (for production)
+- **Loki**: Grafana's log aggregation system (for production)
+- **Disabled**: No log storage (default)
 
-        --node-id <NODE_ID>
-            A unique identifier for this node instance. Should have the same value between consecutive node restarts [default: default]
+**Quick example (file-based logs for local development):**
+```bash
+mkdir -p ./graph-logs
 
-        --http-port <PORT>                            Port for the GraphQL HTTP server [default: 8000]
-        --ipfs <HOST:PORT>                            HTTP address of an IPFS node
-        --postgres-url <URL>                          Location of the Postgres database used for storing entities
-        --subgraph <[NAME:]IPFS_HASH>                 Name and IPFS hash of the subgraph manifest
-        --ws-port <PORT>                              Port for the GraphQL WebSocket server [default: 8001]
+cargo run -p graph-node --release -- \
+  --postgres-url $POSTGRES_URL \
+  --ethereum-rpc mainnet:archive:https://... \
+  --ipfs 127.0.0.1:5001 \
+  --log-store-backend file \
+  --log-store-file-dir ./graph-logs
 ```
 
-### Advanced Configuration
-
-The command line arguments generally are all that is needed to run a
-`graph-node` instance. For advanced uses, various aspects of `graph-node`
-can further be configured through [environment
-variables](https://github.com/graphprotocol/graph-node/blob/master/docs/environment-variables.md). Very
-large `graph-node` instances can also split the work of querying and
-indexing across [multiple databases](./docs/config.md).
-
-## Project Layout
-
-- `node` — A local Graph Node.
-- `graph` — A library providing traits for system components and types for
-  common data.
-- `core` — A library providing implementations for core components, used by all
-  nodes.
-- `chain/ethereum` — A library with components for obtaining data from
-  Ethereum.
-- `graphql` — A GraphQL implementation with API schema generation,
-  introspection, and more.
-- `mock` — A library providing mock implementations for all system components.
-- `runtime/wasm` — A library for running WASM data-extraction scripts.
-- `server/http` — A library providing a GraphQL server over HTTP.
-- `store/postgres` — A Postgres store with a GraphQL-friendly interface
-  and audit logs.
-
-## Roadmap
-
-🔨 = In Progress
-
-🛠 = Feature complete. Additional testing required.
-
-✅ = Feature complete
-
-
-| Feature |  Status |
-| ------- |  :------: |
-| **Ethereum** |    |
-| Indexing smart contract events | ✅ |
-| Handle chain reorganizations | ✅ |
-| **Mappings** |    |
-| WASM-based mappings| ✅ |
-| TypeScript-to-WASM toolchain | ✅ |
-| Autogenerated TypeScript types | ✅ |
-| **GraphQL** |     |
-| Query entities by ID | ✅ |
-| Query entity collections | ✅ |
-| Pagination | ✅ |
-| Filtering | ✅ |
-| Block-based Filtering | ✅ |
-| Entity relationships | ✅ |
-| Subscriptions | ✅ |
+Logs are queried via GraphQL at `http://localhost:8000/graphql`:
+```graphql
+query {
+  _logs(subgraphId: "QmYourSubgraphHash", level: ERROR, first: 10) {
+    timestamp
+    level
+    text
+  }
+}
+```
 
+**For complete documentation**, see the **[Log Store Guide](./docs/log-store.md)**, which covers:
+- How to configure each backend (Elasticsearch, Loki, File)
+- Complete GraphQL query examples
+- Choosing the right backend for your use case
+- Performance considerations and best practices
 
 ## Contributing
 
diff --git a/chain/arweave/.gitignore b/chain/arweave/.gitignore
deleted file mode 100644
index 97442b5f148..00000000000
--- a/chain/arweave/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-google.protobuf.rs
\ No newline at end of file
diff --git a/chain/arweave/Cargo.toml b/chain/arweave/Cargo.toml
deleted file mode 100644
index f8b20147af9..00000000000
--- a/chain/arweave/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "graph-chain-arweave"
-version.workspace = true
-edition.workspace = true
-
-[build-dependencies]
-tonic-build = { workspace = true }
-
-[dependencies]
-base64-url = "2.0.2"
-graph = { path = "../../graph" }
-prost = { workspace = true }
-prost-types = { workspace = true }
-serde = "1.0"
-sha2 = "0.10.8"
-
-graph-runtime-wasm = { path = "../../runtime/wasm" }
-graph-runtime-derive = { path = "../../runtime/derive" }
-
-[dev-dependencies]
-diesel = { version = "1.4.7", features = ["postgres", "serde_json", "numeric", "r2d2"] }
diff --git a/chain/arweave/build.rs b/chain/arweave/build.rs
deleted file mode 100644
index ea8153e7bd1..00000000000
--- a/chain/arweave/build.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-fn main() {
-    println!("cargo:rerun-if-changed=proto");
-    tonic_build::configure()
-        .out_dir("src/protobuf")
-        .compile(&["proto/arweave.proto"], &["proto"])
-        .expect("Failed to compile Firehose Arweave proto(s)");
-}
diff --git a/chain/arweave/proto/arweave.proto b/chain/arweave/proto/arweave.proto
deleted file mode 100644
index b3a41a4a56a..00000000000
--- a/chain/arweave/proto/arweave.proto
+++ /dev/null
@@ -1,108 +0,0 @@
-syntax = "proto3";
-
-package sf.arweave.type.v1;
-
-option go_package = "github.com/ChainSafe/firehose-arweave/pb/sf/arweave/type/v1;pbcodec";
-
-message BigInt {
-  bytes bytes = 1;
-}
-
-message Block {
-  // Firehose block version (unrelated to Arweave block version)
-  uint32 ver = 1;
-  // The block identifier
-  bytes indep_hash = 2;
-  // The nonce chosen to solve the mining problem
-  bytes nonce = 3;
-  // `indep_hash` of the previous block in the weave
-  bytes previous_block = 4;
-  // POSIX time of block discovery
-  uint64 timestamp = 5;
-  // POSIX time of the last difficulty retarget
-  uint64 last_retarget = 6;
-  // Mining difficulty; the number `hash` must be greater than.
-  BigInt diff = 7;
-  // How many blocks have passed since the genesis block
-  uint64 height = 8;
-  // Mining solution hash of the block; must satisfy the mining difficulty
-  bytes hash = 9;
-  // Merkle root of the tree of Merkle roots of block's transactions' data.
-  bytes tx_root = 10;
-  // Transactions contained within this block
-  repeated Transaction txs = 11;
-  // The root hash of the Merkle Patricia Tree containing
-  // all wallet (account) balances and the identifiers
-  // of the last transactions posted by them; if any.
-  bytes wallet_list = 12;
-  // (string or) Address of the account to receive the block rewards. Can also be unclaimed which is encoded as a null byte
-  bytes reward_addr = 13;
-  // Tags that a block producer can add to a block
-  repeated Tag tags = 14;
-  // Size of reward pool
-  BigInt reward_pool = 15;
-  // Size of the weave in bytes
-  BigInt weave_size = 16;
-  // Size of this block in bytes
-  BigInt block_size = 17;
-  // Required after the version 1.8 fork. Zero otherwise.
-  // The sum of the average number of hashes computed
-  // by the network to produce the past blocks including this one.
-  BigInt cumulative_diff = 18;
-  // Required after the version 1.8 fork. Null byte otherwise.
-  // The Merkle root of the block index - the list of {`indep_hash`; `weave_size`; `tx_root`} triplets
-  bytes hash_list_merkle = 20;
-  // The proof of access; Used after v2.4 only; set as defaults otherwise
-  ProofOfAccess poa = 21;
-}
-
-// A succinct proof of access to a recall byte found in a TX
-message ProofOfAccess {
-  // The recall byte option chosen; global offset of index byte
-  string option = 1;
-  // The path through the Merkle tree of transactions' `data_root`s;
-  // from the `data_root` being proven to the corresponding `tx_root`
-  bytes tx_path = 2;
-  // The path through the Merkle tree of identifiers of chunks of the
-  // corresponding transaction; from the chunk being proven to the
-  // corresponding `data_root`.
-  bytes data_path = 3;
-  // The data chunk.
-  bytes chunk = 4;
-}
-
-message Transaction {
-  // 1 or 2 for v1 or v2 transactions. More allowable in the future
-  uint32 format = 1;
-  // The transaction identifier.
-  bytes id = 2; 	 
-  // Either the identifier of the previous transaction from the same
-  // wallet or the identifier of one of the last ?MAX_TX_ANCHOR_DEPTH blocks.
-  bytes last_tx = 3;   
-  // The public key the transaction is signed with.
-  bytes owner = 4;   
-  // A list of arbitrary key-value pairs
-  repeated Tag tags = 5; 	 
-  // The address of the recipient; if any. The SHA2-256 hash of the public key.
-  bytes target = 6;    
-  // The amount of Winstons to send to the recipient; if any.
-  BigInt quantity = 7;   
-  // The data to upload; if any. For v2 transactions; the field is optional
-  // - a fee is charged based on the `data_size` field;
-  //   data may be uploaded any time later in chunks.
-  bytes data = 8;       	 
-  // Size in bytes of the transaction data.
-  BigInt data_size = 9;
-  // The Merkle root of the Merkle tree of data chunks.
-  bytes data_root = 10;
-  // The signature.
-  bytes signature = 11;
-  // The fee in Winstons.
-  BigInt reward = 12;
-}
-
-
-message Tag {
-  bytes name = 1;
-  bytes value = 2;
-}
diff --git a/chain/arweave/src/adapter.rs b/chain/arweave/src/adapter.rs
deleted file mode 100644
index 9b25016b4c6..00000000000
--- a/chain/arweave/src/adapter.rs
+++ /dev/null
@@ -1,262 +0,0 @@
-use crate::{data_source::DataSource, Chain};
-use graph::blockchain as bc;
-use graph::prelude::*;
-use sha2::{Digest, Sha256};
-use std::collections::HashSet;
-
-const MATCH_ALL_WILDCARD: &str = "";
-// Size of sha256(pubkey)
-const SHA256_LEN: usize = 32;
-
-#[derive(Clone, Debug, Default)]
-pub struct TriggerFilter {
-    pub(crate) block_filter: ArweaveBlockFilter,
-    pub(crate) transaction_filter: ArweaveTransactionFilter,
-}
-
-impl bc::TriggerFilter<Chain> for TriggerFilter {
-    fn extend<'a>(&mut self, data_sources: impl Iterator<Item = &'a DataSource> + Clone) {
-        let TriggerFilter {
-            block_filter,
-            transaction_filter,
-        } = self;
-
-        block_filter.extend(ArweaveBlockFilter::from_data_sources(data_sources.clone()));
-        transaction_filter.extend(ArweaveTransactionFilter::from_data_sources(data_sources));
-    }
-
-    fn node_capabilities(&self) -> bc::EmptyNodeCapabilities<Chain> {
-        bc::EmptyNodeCapabilities::default()
-    }
-
-    fn extend_with_template(
-        &mut self,
-        _data_source: impl Iterator<Item = <Chain as bc::Blockchain>::DataSourceTemplate>,
-    ) {
-    }
-
-    fn to_firehose_filter(self) -> Vec<prost_types::Any> {
-        vec![]
-    }
-}
-
-/// ArweaveBlockFilter will match every block regardless of source being set.
-/// see docs: https://thegraph.com/docs/en/supported-networks/arweave/
-#[derive(Clone, Debug, Default)]
-pub(crate) struct ArweaveTransactionFilter {
-    owners_pubkey: HashSet<Vec<u8>>,
-    owners_sha: HashSet<Vec<u8>>,
-    match_all: bool,
-}
-
-impl ArweaveTransactionFilter {
-    pub fn matches(&self, owner: &[u8]) -> bool {
-        if self.match_all {
-            return true;
-        }
-
-        if owner.len() == SHA256_LEN {
-            return self.owners_sha.contains(owner);
-        }
-
-        self.owners_pubkey.contains(owner) || self.owners_sha.contains(&sha256(owner))
-    }
-
-    pub fn from_data_sources<'a>(iter: impl IntoIterator<Item = &'a DataSource>) -> Self {
-        let owners: Vec<Vec<u8>> = iter
-            .into_iter()
-            .filter(|data_source| {
-                data_source.source.owner.is_some()
-                    && !data_source.mapping.transaction_handlers.is_empty()
-            })
-            .map(|ds| match &ds.source.owner {
-                Some(str) if MATCH_ALL_WILDCARD.eq(str) => MATCH_ALL_WILDCARD.as_bytes().to_owned(),
-                owner => base64_url::decode(&owner.clone().unwrap_or_default()).unwrap_or_default(),
-            })
-            .collect();
-
-        let (owners_sha, long) = owners
-            .into_iter()
-            .partition::<Vec<Vec<u8>>, _>(|owner| owner.len() == SHA256_LEN);
-
-        let (owners_pubkey, wildcard) = long
-            .into_iter()
-            .partition::<Vec<Vec<u8>>, _>(|long| long.len() != MATCH_ALL_WILDCARD.len());
-
-        let match_all = !wildcard.is_empty();
-
-        let owners_sha: Vec<Vec<u8>> = owners_sha
-            .into_iter()
-            .chain::<Vec<Vec<u8>>>(owners_pubkey.iter().map(|long| sha256(long)).collect())
-            .collect();
-
-        Self {
-            match_all,
-            owners_pubkey: HashSet::from_iter(owners_pubkey),
-            owners_sha: HashSet::from_iter(owners_sha),
-        }
-    }
-
-    pub fn extend(&mut self, other: ArweaveTransactionFilter) {
-        let ArweaveTransactionFilter {
-            owners_pubkey,
-            owners_sha,
-            match_all,
-        } = self;
-
-        owners_pubkey.extend(other.owners_pubkey);
-        owners_sha.extend(other.owners_sha);
-        *match_all = *match_all || other.match_all;
-    }
-}
-
-/// ArweaveBlockFilter will match every block regardless of source being set.
-/// see docs: https://thegraph.com/docs/en/supported-networks/arweave/
-#[derive(Clone, Debug, Default)]
-pub(crate) struct ArweaveBlockFilter {
-    pub trigger_every_block: bool,
-}
-
-impl ArweaveBlockFilter {
-    pub fn from_data_sources<'a>(iter: impl IntoIterator<Item = &'a DataSource>) -> Self {
-        Self {
-            trigger_every_block: iter
-                .into_iter()
-                .any(|data_source| !data_source.mapping.block_handlers.is_empty()),
-        }
-    }
-
-    pub fn extend(&mut self, other: ArweaveBlockFilter) {
-        self.trigger_every_block = self.trigger_every_block || other.trigger_every_block;
-    }
-}
-
-fn sha256(bs: &[u8]) -> Vec<u8> {
-    let mut hasher = Sha256::new();
-    hasher.update(bs);
-    let res = hasher.finalize();
-    res.to_vec()
-}
-
-#[cfg(test)]
-mod test {
-    use std::sync::Arc;
-
-    use graph::{prelude::Link, semver::Version};
-
-    use crate::data_source::{DataSource, Mapping, Source, TransactionHandler};
-
-    use super::{ArweaveTransactionFilter, MATCH_ALL_WILDCARD};
-
-    const ARWEAVE_PUBKEY_EXAMPLE: &str = "x-62w7g2yKACOgP_d04bhG8IX-AWgPrxHl2JgZBDdNLfAsidiiAaoIZPeM8K5gGvl7-8QVk79YV4OC878Ey0gXi7Atj5BouRyXnFMjJcPVXVyBoYCBuG7rJDDmh4_Ilon6vVOuHVIZ47Vb0tcgsxgxdvVFC2mn9N_SBl23pbeICNJZYOH57kf36gicuV_IwYSdqlQ0HQ_psjmg8EFqO7xzvAMP5HKW3rqTrYZxbCew2FkM734ysWckT39TpDBPx3HrFOl6obUdQWkHNOeKyzcsKFDywNgVWZOb89CYU7JFYlwX20io39ZZv0UJUOEFNjtVHkT_s0_A2O9PltsrZLLlQXZUuYASdbAPD2g_qXfhmPBZ0SXPWCDY-UVwVN1ncwYmk1F_i35IA8kAKsajaltD2wWDQn9g5mgJAWWn2xhLqkbwGbdwQMRD0-0eeuy1uzCooJQCC_bPJksoqkYwB9SGOjkayf4r4oZ2QDY4FicCsswz4Od_gud30ZWyHjWgqGzSFYFzawDBS1Gr_nu_q5otFrv20ZGTxYqGsLHWq4VHs6KjsQvzgBjfyb0etqHQEPJJmbQmY3LSogR4bxdReUHhj2EK9xIB-RKzDvDdL7fT5K0V9MjbnC2uktA0VjLlvwJ64_RhbQhxdp_zR39r-zyCXT-brPEYW1-V7Ey9K3XUE";
-    const ARWEAVE_SHA_EXAMPLE: &str = "ahLxjCMCHr1ZE72VDDoaK4IKiLUUpeuo8t-M6y23DXw";
-
-    #[test]
-    fn transaction_filter_wildcard_matches_all() {
-        let dss = vec![
-            new_datasource(None, 10),
-            new_datasource(Some(base64_url::encode(MATCH_ALL_WILDCARD)), 10),
-            new_datasource(Some(base64_url::encode("owner")), 10),
-            new_datasource(Some(ARWEAVE_PUBKEY_EXAMPLE.into()), 10),
-        ];
-
-        let dss: Vec<&DataSource> = dss.iter().collect();
-
-        let filter = ArweaveTransactionFilter::from_data_sources(dss);
-        assert_eq!(true, filter.matches("asdas".as_bytes()))
-    }
-
-    #[test]
-    fn transaction_filter_match() {
-        let dss = vec![
-            new_datasource(None, 10),
-            new_datasource(Some(ARWEAVE_PUBKEY_EXAMPLE.into()), 10),
-        ];
-
-        let dss: Vec<&DataSource> = dss.iter().collect();
-
-        let filter = ArweaveTransactionFilter::from_data_sources(dss);
-        assert_eq!(false, filter.matches("asdas".as_bytes()));
-        assert_eq!(
-            true,
-            filter.matches(
-                &base64_url::decode(ARWEAVE_SHA_EXAMPLE).expect("failed to parse sha example")
-            )
-        );
-        assert_eq!(
-            true,
-            filter.matches(
-                &base64_url::decode(ARWEAVE_PUBKEY_EXAMPLE).expect("failed to parse PK example")
-            )
-        )
-    }
-
-    #[test]
-    fn transaction_filter_extend_match() {
-        let dss = vec![
-            new_datasource(None, 10),
-            new_datasource(Some(ARWEAVE_SHA_EXAMPLE.into()), 10),
-        ];
-
-        let dss: Vec<&DataSource> = dss.iter().collect();
-
-        let filter = ArweaveTransactionFilter::from_data_sources(dss);
-        assert_eq!(false, filter.matches("asdas".as_bytes()));
-        assert_eq!(
-            true,
-            filter.matches(
-                &base64_url::decode(ARWEAVE_SHA_EXAMPLE).expect("failed to parse sha example")
-            )
-        );
-        assert_eq!(
-            true,
-            filter.matches(
-                &base64_url::decode(ARWEAVE_PUBKEY_EXAMPLE).expect("failed to parse PK example")
-            )
-        )
-    }
-
-    #[test]
-    fn transaction_filter_extend_wildcard_matches_all() {
-        let dss = vec![
-            new_datasource(None, 10),
-            new_datasource(Some(MATCH_ALL_WILDCARD.into()), 10),
-            new_datasource(Some("owner".into()), 10),
-        ];
-
-        let dss: Vec<&DataSource> = dss.iter().collect();
-
-        let mut filter = ArweaveTransactionFilter::default();
-
-        filter.extend(ArweaveTransactionFilter::from_data_sources(dss));
-        assert_eq!(true, filter.matches("asdas".as_bytes()));
-        assert_eq!(true, filter.matches(ARWEAVE_PUBKEY_EXAMPLE.as_bytes()));
-        assert_eq!(true, filter.matches(ARWEAVE_SHA_EXAMPLE.as_bytes()))
-    }
-
-    fn new_datasource(owner: Option<String>, start_block: i32) -> DataSource {
-        DataSource {
-            kind: "".into(),
-            network: None,
-            name: "".into(),
-            source: Source {
-                owner,
-                start_block,
-                end_block: None,
-            },
-            mapping: Mapping {
-                api_version: Version::new(1, 2, 3),
-                language: "".into(),
-                entities: vec![],
-                block_handlers: vec![],
-                transaction_handlers: vec![TransactionHandler {
-                    handler: "my_handler".into(),
-                }],
-                runtime: Arc::new(vec![]),
-                link: Link { link: "".into() },
-            },
-            context: Arc::new(None),
-            creation_block: None,
-        }
-    }
-}
diff --git a/chain/arweave/src/chain.rs b/chain/arweave/src/chain.rs
deleted file mode 100644
index b827c78948a..00000000000
--- a/chain/arweave/src/chain.rs
+++ /dev/null
@@ -1,374 +0,0 @@
-use graph::anyhow;
-use graph::blockchain::client::ChainClient;
-use graph::blockchain::firehose_block_ingestor::FirehoseBlockIngestor;
-use graph::blockchain::{
-    BasicBlockchainBuilder, Block, BlockIngestor, BlockchainBuilder, BlockchainKind,
-    EmptyNodeCapabilities, NoopRuntimeAdapter,
-};
-use graph::cheap_clone::CheapClone;
-use graph::components::store::DeploymentCursorTracker;
-use graph::data::subgraph::UnifiedMappingApiVersion;
-use graph::env::EnvVars;
-use graph::firehose::FirehoseEndpoint;
-use graph::prelude::MetricsRegistry;
-use graph::substreams::Clock;
-use graph::{
-    blockchain::{
-        block_stream::{
-            BlockStreamEvent, BlockWithTriggers, FirehoseError,
-            FirehoseMapper as FirehoseMapperTrait, TriggersAdapter as TriggersAdapterTrait,
-        },
-        firehose_block_stream::FirehoseBlockStream,
-        BlockHash, BlockPtr, Blockchain, IngestorError, RuntimeAdapter as RuntimeAdapterTrait,
-    },
-    components::store::DeploymentLocator,
-    firehose::{self as firehose, ForkStep},
-    prelude::{async_trait, o, BlockNumber, ChainStore, Error, Logger, LoggerFactory},
-};
-use prost::Message;
-use std::sync::Arc;
-
-use crate::adapter::TriggerFilter;
-use crate::data_source::{DataSourceTemplate, UnresolvedDataSourceTemplate};
-use crate::trigger::{self, ArweaveTrigger};
-use crate::{
-    codec,
-    data_source::{DataSource, UnresolvedDataSource},
-};
-use graph::blockchain::block_stream::{BlockStream, BlockStreamMapper, FirehoseCursor};
-
-pub struct Chain {
-    logger_factory: LoggerFactory,
-    name: String,
-    client: Arc<ChainClient<Self>>,
-    chain_store: Arc<dyn ChainStore>,
-    metrics_registry: Arc<MetricsRegistry>,
-}
-
-impl std::fmt::Debug for Chain {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "chain: arweave")
-    }
-}
-
-impl BlockchainBuilder<Chain> for BasicBlockchainBuilder {
-    fn build(self, _config: &Arc<EnvVars>) -> Chain {
-        Chain {
-            logger_factory: self.logger_factory,
-            name: self.name,
-            client: Arc::new(ChainClient::<Chain>::new_firehose(self.firehose_endpoints)),
-            chain_store: self.chain_store,
-            metrics_registry: self.metrics_registry,
-        }
-    }
-}
-
-#[async_trait]
-impl Blockchain for Chain {
-    const KIND: BlockchainKind = BlockchainKind::Arweave;
-
-    type Client = ();
-    type Block = codec::Block;
-
-    type DataSource = DataSource;
-
-    type UnresolvedDataSource = UnresolvedDataSource;
-
-    type DataSourceTemplate = DataSourceTemplate;
-
-    type UnresolvedDataSourceTemplate = UnresolvedDataSourceTemplate;
-
-    type TriggerData = crate::trigger::ArweaveTrigger;
-
-    type MappingTrigger = crate::trigger::ArweaveTrigger;
-
-    type TriggerFilter = crate::adapter::TriggerFilter;
-
-    type NodeCapabilities = EmptyNodeCapabilities<Self>;
-
-    fn triggers_adapter(
-        &self,
-        _loc: &DeploymentLocator,
-        _capabilities: &Self::NodeCapabilities,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Arc<dyn TriggersAdapterTrait<Self>>, Error> {
-        let adapter = TriggersAdapter {};
-        Ok(Arc::new(adapter))
-    }
-
-    fn is_refetch_block_required(&self) -> bool {
-        false
-    }
-
-    async fn refetch_firehose_block(
-        &self,
-        _logger: &Logger,
-        _cursor: FirehoseCursor,
-    ) -> Result<codec::Block, Error> {
-        unimplemented!("This chain does not support Dynamic Data Sources. is_refetch_block_required always returns false, this shouldn't be called.")
-    }
-
-    async fn new_block_stream(
-        &self,
-        deployment: DeploymentLocator,
-        store: impl DeploymentCursorTracker,
-        start_blocks: Vec<BlockNumber>,
-        filter: Arc<Self::TriggerFilter>,
-        unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        let adapter = self
-            .triggers_adapter(
-                &deployment,
-                &EmptyNodeCapabilities::default(),
-                unified_api_version,
-            )
-            .unwrap_or_else(|_| panic!("no adapter for network {}", self.name));
-
-        let logger = self
-            .logger_factory
-            .subgraph_logger(&deployment)
-            .new(o!("component" => "FirehoseBlockStream"));
-
-        let firehose_mapper = Arc::new(FirehoseMapper { adapter, filter });
-
-        Ok(Box::new(FirehoseBlockStream::new(
-            deployment.hash,
-            self.chain_client(),
-            store.block_ptr(),
-            store.firehose_cursor(),
-            firehose_mapper,
-            start_blocks,
-            logger,
-            self.metrics_registry.clone(),
-        )))
-    }
-
-    fn chain_store(&self) -> Arc<dyn ChainStore> {
-        self.chain_store.clone()
-    }
-
-    async fn block_pointer_from_number(
-        &self,
-        logger: &Logger,
-        number: BlockNumber,
-    ) -> Result<BlockPtr, IngestorError> {
-        self.client
-            .firehose_endpoint()?
-            .block_ptr_for_number::<codec::Block>(logger, number)
-            .await
-            .map_err(Into::into)
-    }
-
-    fn runtime_adapter(&self) -> Arc<dyn RuntimeAdapterTrait<Self>> {
-        Arc::new(NoopRuntimeAdapter::default())
-    }
-
-    fn chain_client(&self) -> Arc<ChainClient<Self>> {
-        self.client.clone()
-    }
-
-    fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>> {
-        let ingestor = FirehoseBlockIngestor::<crate::Block, Self>::new(
-            self.chain_store.cheap_clone(),
-            self.chain_client(),
-            self.logger_factory
-                .component_logger("ArweaveFirehoseBlockIngestor", None),
-            self.name.clone(),
-        );
-        Ok(Box::new(ingestor))
-    }
-}
-
-pub struct TriggersAdapter {}
-
-#[async_trait]
-impl TriggersAdapterTrait<Chain> for TriggersAdapter {
-    async fn scan_triggers(
-        &self,
-        _from: BlockNumber,
-        _to: BlockNumber,
-        _filter: &TriggerFilter,
-    ) -> Result<Vec<BlockWithTriggers<Chain>>, Error> {
-        panic!("Should never be called since not used by FirehoseBlockStream")
-    }
-
-    async fn triggers_in_block(
-        &self,
-        logger: &Logger,
-        block: codec::Block,
-        filter: &TriggerFilter,
-    ) -> Result<BlockWithTriggers<Chain>, Error> {
-        // TODO: Find the best place to introduce an `Arc` and avoid this clone.
-        let shared_block = Arc::new(block.clone());
-
-        let TriggerFilter {
-            block_filter,
-            transaction_filter,
-        } = filter;
-
-        let txs = block
-            .clone()
-            .txs
-            .into_iter()
-            .filter(|tx| transaction_filter.matches(&tx.owner))
-            .map(|tx| trigger::TransactionWithBlockPtr {
-                tx: Arc::new(tx),
-                block: shared_block.clone(),
-            })
-            .collect::<Vec<_>>();
-
-        let mut trigger_data: Vec<_> = txs
-            .into_iter()
-            .map(|tx| ArweaveTrigger::Transaction(Arc::new(tx)))
-            .collect();
-
-        if block_filter.trigger_every_block {
-            trigger_data.push(ArweaveTrigger::Block(shared_block.cheap_clone()));
-        }
-
-        Ok(BlockWithTriggers::new(block, trigger_data, logger))
-    }
-
-    async fn is_on_main_chain(&self, _ptr: BlockPtr) -> Result<bool, Error> {
-        panic!("Should never be called since not used by FirehoseBlockStream")
-    }
-
-    async fn ancestor_block(
-        &self,
-        _ptr: BlockPtr,
-        _offset: BlockNumber,
-    ) -> Result<Option<codec::Block>, Error> {
-        panic!("Should never be called since FirehoseBlockStream cannot resolve it")
-    }
-
-    /// Panics if `block` is genesis.
-    /// But that's ok since this is only called when reverting `block`.
-    async fn parent_ptr(&self, block: &BlockPtr) -> Result<Option<BlockPtr>, Error> {
-        // FIXME (Arweave):  Might not be necessary for Arweave support for now
-        Ok(Some(BlockPtr {
-            hash: BlockHash::from(vec![0xff; 48]),
-            number: block.number.saturating_sub(1),
-        }))
-    }
-}
-
-pub struct FirehoseMapper {
-    adapter: Arc<dyn TriggersAdapterTrait<Chain>>,
-    filter: Arc<TriggerFilter>,
-}
-
-#[async_trait]
-impl BlockStreamMapper<Chain> for FirehoseMapper {
-    fn decode_block(&self, output: Option<&[u8]>) -> Result<Option<codec::Block>, Error> {
-        let block = match output {
-            Some(block) => codec::Block::decode(block)?,
-            None => anyhow::bail!("Arweave mapper is expected to always have a block"),
-        };
-
-        Ok(Some(block))
-    }
-
-    async fn block_with_triggers(
-        &self,
-        logger: &Logger,
-        block: codec::Block,
-    ) -> Result<BlockWithTriggers<Chain>, Error> {
-        self.adapter
-            .triggers_in_block(logger, block, self.filter.as_ref())
-            .await
-    }
-    async fn handle_substreams_block(
-        &self,
-        _logger: &Logger,
-        _clock: Clock,
-        _cursor: FirehoseCursor,
-        _block: Vec<u8>,
-    ) -> Result<BlockStreamEvent<Chain>, Error> {
-        unimplemented!()
-    }
-}
-
-#[async_trait]
-impl FirehoseMapperTrait<Chain> for FirehoseMapper {
-    fn trigger_filter(&self) -> &TriggerFilter {
-        self.filter.as_ref()
-    }
-
-    async fn to_block_stream_event(
-        &self,
-        logger: &Logger,
-        response: &firehose::Response,
-    ) -> Result<BlockStreamEvent<Chain>, FirehoseError> {
-        let step = ForkStep::from_i32(response.step).unwrap_or_else(|| {
-            panic!(
-                "unknown step i32 value {}, maybe you forgot update & re-regenerate the protobuf definitions?",
-                response.step
-            )
-        });
-
-        let any_block = response
-            .block
-            .as_ref()
-            .expect("block payload information should always be present");
-
-        // Right now, this is done in all cases but in reality, with how the BlockStreamEvent::Revert
-        // is defined right now, only block hash and block number is necessary. However, this information
-        // is not part of the actual bstream::BlockResponseV2 payload. As such, we need to decode the full
-        // block which is useless.
-        //
-        // Check about adding basic information about the block in the bstream::BlockResponseV2 or maybe
-        // define a slimmed down stuct that would decode only a few fields and ignore all the rest.
-        // unwrap: Input cannot be None so output will be error or block.
-        let block = self.decode_block(Some(&any_block.value.as_ref()))?.unwrap();
-
-        use ForkStep::*;
-        match step {
-            StepNew => Ok(BlockStreamEvent::ProcessBlock(
-                self.block_with_triggers(&logger, block).await?,
-                FirehoseCursor::from(response.cursor.clone()),
-            )),
-
-            StepUndo => {
-                let parent_ptr = block
-                    .parent_ptr()
-                    .expect("Genesis block should never be reverted");
-
-                Ok(BlockStreamEvent::Revert(
-                    parent_ptr,
-                    FirehoseCursor::from(response.cursor.clone()),
-                ))
-            }
-
-            StepFinal => {
-                panic!("irreversible step is not handled and should not be requested in the Firehose request")
-            }
-
-            StepUnset => {
-                panic!("unknown step should not happen in the Firehose response")
-            }
-        }
-    }
-
-    async fn block_ptr_for_number(
-        &self,
-        logger: &Logger,
-        endpoint: &Arc<FirehoseEndpoint>,
-        number: BlockNumber,
-    ) -> Result<BlockPtr, Error> {
-        endpoint
-            .block_ptr_for_number::<codec::Block>(logger, number)
-            .await
-    }
-
-    // # FIXME
-    //
-    // the final block of arweave is itself in the current implementation
-    async fn final_block_ptr_for(
-        &self,
-        _logger: &Logger,
-        _endpoint: &Arc<FirehoseEndpoint>,
-        block: &codec::Block,
-    ) -> Result<BlockPtr, Error> {
-        Ok(block.ptr())
-    }
-}
diff --git a/chain/arweave/src/codec.rs b/chain/arweave/src/codec.rs
deleted file mode 100644
index 3df276f309b..00000000000
--- a/chain/arweave/src/codec.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-#[rustfmt::skip]
-#[path = "protobuf/sf.arweave.r#type.v1.rs"]
-mod pbcodec;
-
-use graph::{
-    blockchain::Block as BlockchainBlock,
-    blockchain::{BlockPtr, BlockTime},
-    prelude::BlockNumber,
-};
-
-pub use pbcodec::*;
-
-impl BlockchainBlock for Block {
-    fn number(&self) -> i32 {
-        BlockNumber::try_from(self.height).unwrap()
-    }
-
-    fn ptr(&self) -> BlockPtr {
-        BlockPtr {
-            hash: self.indep_hash.clone().into(),
-            number: self.number(),
-        }
-    }
-
-    fn parent_ptr(&self) -> Option<BlockPtr> {
-        if self.height == 0 {
-            return None;
-        }
-
-        Some(BlockPtr {
-            hash: self.previous_block.clone().into(),
-            number: self.number().saturating_sub(1),
-        })
-    }
-
-    fn timestamp(&self) -> BlockTime {
-        BlockTime::since_epoch(i64::try_from(self.timestamp).unwrap(), 0)
-    }
-}
-
-impl AsRef<[u8]> for BigInt {
-    fn as_ref(&self) -> &[u8] {
-        self.bytes.as_ref()
-    }
-}
diff --git a/chain/arweave/src/data_source.rs b/chain/arweave/src/data_source.rs
deleted file mode 100644
index b5db65ee096..00000000000
--- a/chain/arweave/src/data_source.rs
+++ /dev/null
@@ -1,407 +0,0 @@
-use graph::anyhow::Context;
-use graph::blockchain::{Block, TriggerWithHandler};
-use graph::components::store::StoredDynamicDataSource;
-use graph::data::subgraph::DataSourceContext;
-use graph::prelude::SubgraphManifestValidationError;
-use graph::{
-    anyhow::{anyhow, Error},
-    blockchain::{self, Blockchain},
-    prelude::{
-        async_trait, BlockNumber, CheapClone, DataSourceTemplateInfo, Deserialize, Link,
-        LinkResolver, Logger,
-    },
-    semver,
-};
-use std::collections::HashSet;
-use std::sync::Arc;
-
-use crate::chain::Chain;
-use crate::trigger::ArweaveTrigger;
-
-pub const ARWEAVE_KIND: &str = "arweave";
-const BLOCK_HANDLER_KIND: &str = "block";
-const TRANSACTION_HANDLER_KIND: &str = "transaction";
-/// Runtime representation of a data source.
-#[derive(Clone, Debug)]
-pub struct DataSource {
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub(crate) source: Source,
-    pub mapping: Mapping,
-    pub context: Arc<Option<DataSourceContext>>,
-    pub creation_block: Option<BlockNumber>,
-}
-
-impl blockchain::DataSource<Chain> for DataSource {
-    fn from_template_info(_info: DataSourceTemplateInfo<Chain>) -> Result<Self, Error> {
-        Err(anyhow!("Arweave subgraphs do not support templates"))
-    }
-
-    // FIXME
-    //
-    // need to decode the base64url encoding?
-    fn address(&self) -> Option<&[u8]> {
-        self.source.owner.as_ref().map(String::as_bytes)
-    }
-
-    fn start_block(&self) -> BlockNumber {
-        self.source.start_block
-    }
-
-    fn handler_kinds(&self) -> HashSet<&str> {
-        let mut kinds = HashSet::new();
-
-        if self.handler_for_block().is_some() {
-            kinds.insert(BLOCK_HANDLER_KIND);
-        }
-
-        if self.handler_for_transaction().is_some() {
-            kinds.insert(TRANSACTION_HANDLER_KIND);
-        }
-
-        kinds
-    }
-
-    fn end_block(&self) -> Option<BlockNumber> {
-        self.source.end_block
-    }
-
-    fn match_and_decode(
-        &self,
-        trigger: &<Chain as Blockchain>::TriggerData,
-        block: &Arc<<Chain as Blockchain>::Block>,
-        _logger: &Logger,
-    ) -> Result<Option<TriggerWithHandler<Chain>>, Error> {
-        if self.source.start_block > block.number() {
-            return Ok(None);
-        }
-
-        let handler = match trigger {
-            // A block trigger matches if a block handler is present.
-            ArweaveTrigger::Block(_) => match self.handler_for_block() {
-                Some(handler) => &handler.handler,
-                None => return Ok(None),
-            },
-            // A transaction trigger matches if a transaction handler is present.
-            ArweaveTrigger::Transaction(_) => match self.handler_for_transaction() {
-                Some(handler) => &handler.handler,
-                None => return Ok(None),
-            },
-        };
-
-        Ok(Some(TriggerWithHandler::<Chain>::new(
-            trigger.cheap_clone(),
-            handler.clone(),
-            block.ptr(),
-            block.timestamp(),
-        )))
-    }
-
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn kind(&self) -> &str {
-        &self.kind
-    }
-
-    fn network(&self) -> Option<&str> {
-        self.network.as_deref()
-    }
-
-    fn context(&self) -> Arc<Option<DataSourceContext>> {
-        self.context.cheap_clone()
-    }
-
-    fn creation_block(&self) -> Option<BlockNumber> {
-        self.creation_block
-    }
-
-    fn is_duplicate_of(&self, other: &Self) -> bool {
-        let DataSource {
-            kind,
-            network,
-            name,
-            source,
-            mapping,
-            context,
-
-            // The creation block is ignored for detection duplicate data sources.
-            // Contract ABI equality is implicit in `source` and `mapping.abis` equality.
-            creation_block: _,
-        } = self;
-
-        // mapping_request_sender, host_metrics, and (most of) host_exports are operational structs
-        // used at runtime but not needed to define uniqueness; each runtime host should be for a
-        // unique data source.
-        kind == &other.kind
-            && network == &other.network
-            && name == &other.name
-            && source == &other.source
-            && mapping.block_handlers == other.mapping.block_handlers
-            && context == &other.context
-    }
-
-    fn as_stored_dynamic_data_source(&self) -> StoredDynamicDataSource {
-        // FIXME (Arweave): Implement me!
-        todo!()
-    }
-
-    fn from_stored_dynamic_data_source(
-        _template: &DataSourceTemplate,
-        _stored: StoredDynamicDataSource,
-    ) -> Result<Self, Error> {
-        // FIXME (Arweave): Implement me correctly
-        todo!()
-    }
-
-    fn validate(&self) -> Vec<Error> {
-        let mut errors = Vec::new();
-
-        if self.kind != ARWEAVE_KIND {
-            errors.push(anyhow!(
-                "data source has invalid `kind`, expected {} but found {}",
-                ARWEAVE_KIND,
-                self.kind
-            ))
-        }
-
-        // Validate that there is a `source` address if there are transaction handlers
-        let no_source_address = self.address().is_none();
-        let has_transaction_handlers = !self.mapping.transaction_handlers.is_empty();
-        if no_source_address && has_transaction_handlers {
-            errors.push(SubgraphManifestValidationError::SourceAddressRequired.into());
-        };
-
-        // Validate that there are no more than one of both block handlers and transaction handlers
-        if self.mapping.block_handlers.len() > 1 {
-            errors.push(anyhow!("data source has duplicated block handlers"));
-        }
-        if self.mapping.transaction_handlers.len() > 1 {
-            errors.push(anyhow!("data source has duplicated transaction handlers"));
-        }
-
-        errors
-    }
-
-    fn api_version(&self) -> semver::Version {
-        self.mapping.api_version.clone()
-    }
-
-    fn runtime(&self) -> Option<Arc<Vec<u8>>> {
-        Some(self.mapping.runtime.cheap_clone())
-    }
-}
-
-impl DataSource {
-    fn from_manifest(
-        kind: String,
-        network: Option<String>,
-        name: String,
-        source: Source,
-        mapping: Mapping,
-        context: Option<DataSourceContext>,
-    ) -> Result<Self, Error> {
-        // Data sources in the manifest are created "before genesis" so they have no creation block.
-        let creation_block = None;
-
-        Ok(DataSource {
-            kind,
-            network,
-            name,
-            source,
-            mapping,
-            context: Arc::new(context),
-            creation_block,
-        })
-    }
-
-    fn handler_for_block(&self) -> Option<&MappingBlockHandler> {
-        self.mapping.block_handlers.first()
-    }
-
-    fn handler_for_transaction(&self) -> Option<&TransactionHandler> {
-        self.mapping.transaction_handlers.first()
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
-pub struct UnresolvedDataSource {
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub(crate) source: Source,
-    pub mapping: UnresolvedMapping,
-    pub context: Option<DataSourceContext>,
-}
-
-#[async_trait]
-impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
-    async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-        _manifest_idx: u32,
-    ) -> Result<DataSource, Error> {
-        let UnresolvedDataSource {
-            kind,
-            network,
-            name,
-            source,
-            mapping,
-            context,
-        } = self;
-
-        let mapping = mapping.resolve(resolver, logger).await.with_context(|| {
-            format!(
-                "failed to resolve data source {} with source_address {:?} and start_block {}",
-                name,
-                base64_url::encode(&source.owner.clone().unwrap_or_default()),
-                source.start_block
-            )
-        })?;
-
-        DataSource::from_manifest(kind, network, name, source, mapping, context)
-    }
-}
-
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
-pub struct BaseDataSourceTemplate<M> {
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub mapping: M,
-}
-
-pub type UnresolvedDataSourceTemplate = BaseDataSourceTemplate<UnresolvedMapping>;
-pub type DataSourceTemplate = BaseDataSourceTemplate<Mapping>;
-
-#[async_trait]
-impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTemplate {
-    async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-        _manifest_idx: u32,
-    ) -> Result<DataSourceTemplate, Error> {
-        let UnresolvedDataSourceTemplate {
-            kind,
-            network,
-            name,
-            mapping,
-        } = self;
-
-        let mapping = mapping
-            .resolve(resolver, logger)
-            .await
-            .with_context(|| format!("failed to resolve data source template {}", name))?;
-
-        Ok(DataSourceTemplate {
-            kind,
-            network,
-            name,
-            mapping,
-        })
-    }
-}
-
-impl blockchain::DataSourceTemplate<Chain> for DataSourceTemplate {
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn api_version(&self) -> semver::Version {
-        self.mapping.api_version.clone()
-    }
-
-    fn runtime(&self) -> Option<Arc<Vec<u8>>> {
-        Some(self.mapping.runtime.cheap_clone())
-    }
-
-    fn manifest_idx(&self) -> u32 {
-        unreachable!("arweave does not support dynamic data sources")
-    }
-
-    fn kind(&self) -> &str {
-        &self.kind
-    }
-}
-
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct UnresolvedMapping {
-    pub api_version: String,
-    pub language: String,
-    pub entities: Vec<String>,
-    #[serde(default)]
-    pub block_handlers: Vec<MappingBlockHandler>,
-    #[serde(default)]
-    pub transaction_handlers: Vec<TransactionHandler>,
-    pub file: Link,
-}
-
-impl UnresolvedMapping {
-    pub async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-    ) -> Result<Mapping, Error> {
-        let UnresolvedMapping {
-            api_version,
-            language,
-            entities,
-            block_handlers,
-            transaction_handlers,
-            file: link,
-        } = self;
-
-        let api_version = semver::Version::parse(&api_version)?;
-
-        let module_bytes = resolver
-            .cat(logger, &link)
-            .await
-            .with_context(|| format!("failed to resolve mapping {}", link.link))?;
-
-        Ok(Mapping {
-            api_version,
-            language,
-            entities,
-            block_handlers,
-            transaction_handlers,
-            runtime: Arc::new(module_bytes),
-            link,
-        })
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Mapping {
-    pub api_version: semver::Version,
-    pub language: String,
-    pub entities: Vec<String>,
-    pub block_handlers: Vec<MappingBlockHandler>,
-    pub transaction_handlers: Vec<TransactionHandler>,
-    pub runtime: Arc<Vec<u8>>,
-    pub link: Link,
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
-pub struct MappingBlockHandler {
-    pub handler: String,
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
-pub struct TransactionHandler {
-    pub handler: String,
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct Source {
-    // A data source that does not have an owner can only have block handlers.
-    pub(crate) owner: Option<String>,
-    #[serde(default)]
-    pub(crate) start_block: BlockNumber,
-    pub(crate) end_block: Option<BlockNumber>,
-}
diff --git a/chain/arweave/src/lib.rs b/chain/arweave/src/lib.rs
deleted file mode 100644
index 77e63bc51ab..00000000000
--- a/chain/arweave/src/lib.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-mod adapter;
-mod chain;
-mod codec;
-mod data_source;
-mod runtime;
-mod trigger;
-
-pub use crate::chain::Chain;
-pub use codec::Block;
diff --git a/chain/arweave/src/protobuf/sf.arweave.r#type.v1.rs b/chain/arweave/src/protobuf/sf.arweave.r#type.v1.rs
deleted file mode 100644
index fba41614f1b..00000000000
--- a/chain/arweave/src/protobuf/sf.arweave.r#type.v1.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BigInt {
-    #[prost(bytes = "vec", tag = "1")]
-    pub bytes: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Block {
-    /// Firehose block version (unrelated to Arweave block version)
-    #[prost(uint32, tag = "1")]
-    pub ver: u32,
-    /// The block identifier
-    #[prost(bytes = "vec", tag = "2")]
-    pub indep_hash: ::prost::alloc::vec::Vec<u8>,
-    /// The nonce chosen to solve the mining problem
-    #[prost(bytes = "vec", tag = "3")]
-    pub nonce: ::prost::alloc::vec::Vec<u8>,
-    /// `indep_hash` of the previous block in the weave
-    #[prost(bytes = "vec", tag = "4")]
-    pub previous_block: ::prost::alloc::vec::Vec<u8>,
-    /// POSIX time of block discovery
-    #[prost(uint64, tag = "5")]
-    pub timestamp: u64,
-    /// POSIX time of the last difficulty retarget
-    #[prost(uint64, tag = "6")]
-    pub last_retarget: u64,
-    /// Mining difficulty; the number `hash` must be greater than.
-    #[prost(message, optional, tag = "7")]
-    pub diff: ::core::option::Option<BigInt>,
-    /// How many blocks have passed since the genesis block
-    #[prost(uint64, tag = "8")]
-    pub height: u64,
-    /// Mining solution hash of the block; must satisfy the mining difficulty
-    #[prost(bytes = "vec", tag = "9")]
-    pub hash: ::prost::alloc::vec::Vec<u8>,
-    /// Merkle root of the tree of Merkle roots of block's transactions' data.
-    #[prost(bytes = "vec", tag = "10")]
-    pub tx_root: ::prost::alloc::vec::Vec<u8>,
-    /// Transactions contained within this block
-    #[prost(message, repeated, tag = "11")]
-    pub txs: ::prost::alloc::vec::Vec<Transaction>,
-    /// The root hash of the Merkle Patricia Tree containing
-    /// all wallet (account) balances and the identifiers
-    /// of the last transactions posted by them; if any.
-    #[prost(bytes = "vec", tag = "12")]
-    pub wallet_list: ::prost::alloc::vec::Vec<u8>,
-    /// (string or) Address of the account to receive the block rewards. Can also be unclaimed which is encoded as a null byte
-    #[prost(bytes = "vec", tag = "13")]
-    pub reward_addr: ::prost::alloc::vec::Vec<u8>,
-    /// Tags that a block producer can add to a block
-    #[prost(message, repeated, tag = "14")]
-    pub tags: ::prost::alloc::vec::Vec<Tag>,
-    /// Size of reward pool
-    #[prost(message, optional, tag = "15")]
-    pub reward_pool: ::core::option::Option<BigInt>,
-    /// Size of the weave in bytes
-    #[prost(message, optional, tag = "16")]
-    pub weave_size: ::core::option::Option<BigInt>,
-    /// Size of this block in bytes
-    #[prost(message, optional, tag = "17")]
-    pub block_size: ::core::option::Option<BigInt>,
-    /// Required after the version 1.8 fork. Zero otherwise.
-    /// The sum of the average number of hashes computed
-    /// by the network to produce the past blocks including this one.
-    #[prost(message, optional, tag = "18")]
-    pub cumulative_diff: ::core::option::Option<BigInt>,
-    /// Required after the version 1.8 fork. Null byte otherwise.
-    /// The Merkle root of the block index - the list of {`indep_hash`; `weave_size`; `tx_root`} triplets
-    #[prost(bytes = "vec", tag = "20")]
-    pub hash_list_merkle: ::prost::alloc::vec::Vec<u8>,
-    /// The proof of access; Used after v2.4 only; set as defaults otherwise
-    #[prost(message, optional, tag = "21")]
-    pub poa: ::core::option::Option<ProofOfAccess>,
-}
-/// A succinct proof of access to a recall byte found in a TX
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ProofOfAccess {
-    /// The recall byte option chosen; global offset of index byte
-    #[prost(string, tag = "1")]
-    pub option: ::prost::alloc::string::String,
-    /// The path through the Merkle tree of transactions' `data_root`s;
-    /// from the `data_root` being proven to the corresponding `tx_root`
-    #[prost(bytes = "vec", tag = "2")]
-    pub tx_path: ::prost::alloc::vec::Vec<u8>,
-    /// The path through the Merkle tree of identifiers of chunks of the
-    /// corresponding transaction; from the chunk being proven to the
-    /// corresponding `data_root`.
-    #[prost(bytes = "vec", tag = "3")]
-    pub data_path: ::prost::alloc::vec::Vec<u8>,
-    /// The data chunk.
-    #[prost(bytes = "vec", tag = "4")]
-    pub chunk: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Transaction {
-    /// 1 or 2 for v1 or v2 transactions. More allowable in the future
-    #[prost(uint32, tag = "1")]
-    pub format: u32,
-    /// The transaction identifier.
-    #[prost(bytes = "vec", tag = "2")]
-    pub id: ::prost::alloc::vec::Vec<u8>,
-    /// Either the identifier of the previous transaction from the same
-    /// wallet or the identifier of one of the last ?MAX_TX_ANCHOR_DEPTH blocks.
-    #[prost(bytes = "vec", tag = "3")]
-    pub last_tx: ::prost::alloc::vec::Vec<u8>,
-    /// The public key the transaction is signed with.
-    #[prost(bytes = "vec", tag = "4")]
-    pub owner: ::prost::alloc::vec::Vec<u8>,
-    /// A list of arbitrary key-value pairs
-    #[prost(message, repeated, tag = "5")]
-    pub tags: ::prost::alloc::vec::Vec<Tag>,
-    /// The address of the recipient; if any. The SHA2-256 hash of the public key.
-    #[prost(bytes = "vec", tag = "6")]
-    pub target: ::prost::alloc::vec::Vec<u8>,
-    /// The amount of Winstons to send to the recipient; if any.
-    #[prost(message, optional, tag = "7")]
-    pub quantity: ::core::option::Option<BigInt>,
-    /// The data to upload; if any. For v2 transactions; the field is optional
-    /// - a fee is charged based on the `data_size` field;
-    ///    data may be uploaded any time later in chunks.
-    #[prost(bytes = "vec", tag = "8")]
-    pub data: ::prost::alloc::vec::Vec<u8>,
-    /// Size in bytes of the transaction data.
-    #[prost(message, optional, tag = "9")]
-    pub data_size: ::core::option::Option<BigInt>,
-    /// The Merkle root of the Merkle tree of data chunks.
-    #[prost(bytes = "vec", tag = "10")]
-    pub data_root: ::prost::alloc::vec::Vec<u8>,
-    /// The signature.
-    #[prost(bytes = "vec", tag = "11")]
-    pub signature: ::prost::alloc::vec::Vec<u8>,
-    /// The fee in Winstons.
-    #[prost(message, optional, tag = "12")]
-    pub reward: ::core::option::Option<BigInt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Tag {
-    #[prost(bytes = "vec", tag = "1")]
-    pub name: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "2")]
-    pub value: ::prost::alloc::vec::Vec<u8>,
-}
diff --git a/chain/arweave/src/runtime/abi.rs b/chain/arweave/src/runtime/abi.rs
deleted file mode 100644
index 616cfa70b8c..00000000000
--- a/chain/arweave/src/runtime/abi.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-use crate::codec;
-use crate::trigger::TransactionWithBlockPtr;
-use graph::runtime::gas::GasCounter;
-use graph::runtime::{asc_new, AscHeap, AscPtr, HostExportError, ToAscObj};
-use graph_runtime_wasm::asc_abi::class::{Array, Uint8Array};
-
-pub(crate) use super::generated::*;
-
-impl ToAscObj<AscTag> for codec::Tag {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscTag, HostExportError> {
-        Ok(AscTag {
-            name: asc_new(heap, self.name.as_slice(), gas)?,
-            value: asc_new(heap, self.value.as_slice(), gas)?,
-        })
-    }
-}
-
-impl ToAscObj<AscTransactionArray> for Vec<Vec<u8>> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscTransactionArray, HostExportError> {
-        let content = self
-            .iter()
-            .map(|x| asc_new(heap, x.as_slice(), gas))
-            .collect::<Result<Vec<AscPtr<Uint8Array>>, _>>()?;
-        Ok(AscTransactionArray(Array::new(&content, heap, gas)?))
-    }
-}
-
-impl ToAscObj<AscTagArray> for Vec<codec::Tag> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscTagArray, HostExportError> {
-        let content = self
-            .iter()
-            .map(|x| asc_new(heap, x, gas))
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(AscTagArray(Array::new(&content, heap, gas)?))
-    }
-}
-
-impl ToAscObj<AscProofOfAccess> for codec::ProofOfAccess {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscProofOfAccess, HostExportError> {
-        Ok(AscProofOfAccess {
-            option: asc_new(heap, &self.option, gas)?,
-            tx_path: asc_new(heap, self.tx_path.as_slice(), gas)?,
-            data_path: asc_new(heap, self.data_path.as_slice(), gas)?,
-            chunk: asc_new(heap, self.chunk.as_slice(), gas)?,
-        })
-    }
-}
-
-impl ToAscObj<AscTransaction> for codec::Transaction {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscTransaction, HostExportError> {
-        Ok(AscTransaction {
-            format: self.format,
-            id: asc_new(heap, self.id.as_slice(), gas)?,
-            last_tx: asc_new(heap, self.last_tx.as_slice(), gas)?,
-            owner: asc_new(heap, self.owner.as_slice(), gas)?,
-            tags: asc_new(heap, &self.tags, gas)?,
-            target: asc_new(heap, self.target.as_slice(), gas)?,
-            quantity: asc_new(
-                heap,
-                self.quantity
-                    .as_ref()
-                    .map(|b| b.as_ref())
-                    .unwrap_or_default(),
-                gas,
-            )?,
-            data: asc_new(heap, self.data.as_slice(), gas)?,
-            data_size: asc_new(
-                heap,
-                self.data_size
-                    .as_ref()
-                    .map(|b| b.as_ref())
-                    .unwrap_or_default(),
-                gas,
-            )?,
-            data_root: asc_new(heap, self.data_root.as_slice(), gas)?,
-            signature: asc_new(heap, self.signature.as_slice(), gas)?,
-            reward: asc_new(
-                heap,
-                self.reward.as_ref().map(|b| b.as_ref()).unwrap_or_default(),
-                gas,
-            )?,
-        })
-    }
-}
-
-impl ToAscObj<AscBlock> for codec::Block {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscBlock, HostExportError> {
-        Ok(AscBlock {
-            indep_hash: asc_new(heap, self.indep_hash.as_slice(), gas)?,
-            nonce: asc_new(heap, self.nonce.as_slice(), gas)?,
-            previous_block: asc_new(heap, self.previous_block.as_slice(), gas)?,
-            timestamp: self.timestamp,
-            last_retarget: self.last_retarget,
-            diff: asc_new(
-                heap,
-                self.diff.as_ref().map(|b| b.as_ref()).unwrap_or_default(),
-                gas,
-            )?,
-            height: self.height,
-            hash: asc_new(heap, self.hash.as_slice(), gas)?,
-            tx_root: asc_new(heap, self.tx_root.as_slice(), gas)?,
-            txs: asc_new(
-                heap,
-                &self
-                    .txs
-                    .iter()
-                    .map(|tx| tx.id.clone())
-                    .collect::<Vec<Vec<u8>>>(),
-                gas,
-            )?,
-            wallet_list: asc_new(heap, self.wallet_list.as_slice(), gas)?,
-            reward_addr: asc_new(heap, self.reward_addr.as_slice(), gas)?,
-            tags: asc_new(heap, &self.tags, gas)?,
-            reward_pool: asc_new(
-                heap,
-                self.reward_pool
-                    .as_ref()
-                    .map(|b| b.as_ref())
-                    .unwrap_or_default(),
-                gas,
-            )?,
-            weave_size: asc_new(
-                heap,
-                self.weave_size
-                    .as_ref()
-                    .map(|b| b.as_ref())
-                    .unwrap_or_default(),
-                gas,
-            )?,
-            block_size: asc_new(
-                heap,
-                self.block_size
-                    .as_ref()
-                    .map(|b| b.as_ref())
-                    .unwrap_or_default(),
-                gas,
-            )?,
-            cumulative_diff: asc_new(
-                heap,
-                self.cumulative_diff
-                    .as_ref()
-                    .map(|b| b.as_ref())
-                    .unwrap_or_default(),
-                gas,
-            )?,
-            hash_list_merkle: asc_new(heap, self.hash_list_merkle.as_slice(), gas)?,
-            poa: self
-                .poa
-                .as_ref()
-                .map(|poa| asc_new(heap, poa, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-        })
-    }
-}
-
-impl ToAscObj<AscTransactionWithBlockPtr> for TransactionWithBlockPtr {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscTransactionWithBlockPtr, HostExportError> {
-        Ok(AscTransactionWithBlockPtr {
-            tx: asc_new(heap, &self.tx.as_ref(), gas)?,
-            block: asc_new(heap, self.block.as_ref(), gas)?,
-        })
-    }
-}
diff --git a/chain/arweave/src/runtime/generated.rs b/chain/arweave/src/runtime/generated.rs
deleted file mode 100644
index e8a10fdb158..00000000000
--- a/chain/arweave/src/runtime/generated.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use graph::runtime::{AscIndexId, AscPtr, AscType, DeterministicHostError, IndexForAscTypeId};
-use graph::semver::Version;
-use graph_runtime_derive::AscType;
-use graph_runtime_wasm::asc_abi::class::{Array, AscString, Uint8Array};
-
-#[repr(C)]
-#[derive(AscType, Default)]
-pub struct AscBlock {
-    pub timestamp: u64,
-    pub last_retarget: u64,
-    pub height: u64,
-    pub indep_hash: AscPtr<Uint8Array>,
-    pub nonce: AscPtr<Uint8Array>,
-    pub previous_block: AscPtr<Uint8Array>,
-    pub diff: AscPtr<Uint8Array>,
-    pub hash: AscPtr<Uint8Array>,
-    pub tx_root: AscPtr<Uint8Array>,
-    pub txs: AscPtr<AscTransactionArray>,
-    pub wallet_list: AscPtr<Uint8Array>,
-    pub reward_addr: AscPtr<Uint8Array>,
-    pub tags: AscPtr<AscTagArray>,
-    pub reward_pool: AscPtr<Uint8Array>,
-    pub weave_size: AscPtr<Uint8Array>,
-    pub block_size: AscPtr<Uint8Array>,
-    pub cumulative_diff: AscPtr<Uint8Array>,
-    pub hash_list_merkle: AscPtr<Uint8Array>,
-    pub poa: AscPtr<AscProofOfAccess>,
-}
-
-impl AscIndexId for AscBlock {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArweaveBlock;
-}
-
-#[repr(C)]
-#[derive(AscType)]
-pub struct AscProofOfAccess {
-    pub option: AscPtr<AscString>,
-    pub tx_path: AscPtr<Uint8Array>,
-    pub data_path: AscPtr<Uint8Array>,
-    pub chunk: AscPtr<Uint8Array>,
-}
-
-impl AscIndexId for AscProofOfAccess {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArweaveProofOfAccess;
-}
-
-#[repr(C)]
-#[derive(AscType)]
-pub struct AscTransaction {
-    pub format: u32,
-    pub id: AscPtr<Uint8Array>,
-    pub last_tx: AscPtr<Uint8Array>,
-    pub owner: AscPtr<Uint8Array>,
-    pub tags: AscPtr<AscTagArray>,
-    pub target: AscPtr<Uint8Array>,
-    pub quantity: AscPtr<Uint8Array>,
-    pub data: AscPtr<Uint8Array>,
-    pub data_size: AscPtr<Uint8Array>,
-    pub data_root: AscPtr<Uint8Array>,
-    pub signature: AscPtr<Uint8Array>,
-    pub reward: AscPtr<Uint8Array>,
-}
-
-impl AscIndexId for AscTransaction {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArweaveTransaction;
-}
-
-#[repr(C)]
-#[derive(AscType)]
-pub struct AscTag {
-    pub name: AscPtr<Uint8Array>,
-    pub value: AscPtr<Uint8Array>,
-}
-
-impl AscIndexId for AscTag {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArweaveTag;
-}
-
-#[repr(C)]
-pub struct AscTransactionArray(pub(crate) Array<AscPtr<Uint8Array>>);
-
-impl AscType for AscTransactionArray {
-    fn to_asc_bytes(&self) -> Result<Vec<u8>, DeterministicHostError> {
-        self.0.to_asc_bytes()
-    }
-
-    fn from_asc_bytes(
-        asc_obj: &[u8],
-        api_version: &Version,
-    ) -> Result<Self, DeterministicHostError> {
-        Ok(Self(Array::from_asc_bytes(asc_obj, api_version)?))
-    }
-}
-
-impl AscIndexId for AscTransactionArray {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArweaveTransactionArray;
-}
-
-#[repr(C)]
-pub struct AscTagArray(pub(crate) Array<AscPtr<AscTag>>);
-
-impl AscType for AscTagArray {
-    fn to_asc_bytes(&self) -> Result<Vec<u8>, DeterministicHostError> {
-        self.0.to_asc_bytes()
-    }
-
-    fn from_asc_bytes(
-        asc_obj: &[u8],
-        api_version: &Version,
-    ) -> Result<Self, DeterministicHostError> {
-        Ok(Self(Array::from_asc_bytes(asc_obj, api_version)?))
-    }
-}
-
-impl AscIndexId for AscTagArray {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArweaveTagArray;
-}
-
-#[repr(C)]
-#[derive(AscType)]
-pub struct AscTransactionWithBlockPtr {
-    pub tx: AscPtr<AscTransaction>,
-    pub block: AscPtr<AscBlock>,
-}
-
-impl AscIndexId for AscTransactionWithBlockPtr {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArweaveTransactionWithBlockPtr;
-}
diff --git a/chain/arweave/src/runtime/mod.rs b/chain/arweave/src/runtime/mod.rs
deleted file mode 100644
index 31e18de7dd8..00000000000
--- a/chain/arweave/src/runtime/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod abi;
-
-mod generated;
diff --git a/chain/arweave/src/trigger.rs b/chain/arweave/src/trigger.rs
deleted file mode 100644
index 871dd5e11dd..00000000000
--- a/chain/arweave/src/trigger.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use graph::blockchain::Block;
-use graph::blockchain::MappingTriggerTrait;
-use graph::blockchain::TriggerData;
-use graph::cheap_clone::CheapClone;
-use graph::prelude::web3::types::H256;
-use graph::prelude::BlockNumber;
-use graph::runtime::asc_new;
-use graph::runtime::gas::GasCounter;
-use graph::runtime::AscHeap;
-use graph::runtime::AscPtr;
-use graph::runtime::HostExportError;
-use graph_runtime_wasm::module::ToAscPtr;
-use std::{cmp::Ordering, sync::Arc};
-
-use crate::codec;
-
-// Logging the block is too verbose, so this strips the block from the trigger for Debug.
-impl std::fmt::Debug for ArweaveTrigger {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        #[derive(Debug)]
-        pub enum MappingTriggerWithoutBlock {
-            Block,
-            Transaction(Arc<codec::Transaction>),
-        }
-
-        let trigger_without_block = match self {
-            ArweaveTrigger::Block(_) => MappingTriggerWithoutBlock::Block,
-            ArweaveTrigger::Transaction(tx) => {
-                MappingTriggerWithoutBlock::Transaction(tx.tx.clone())
-            }
-        };
-
-        write!(f, "{:?}", trigger_without_block)
-    }
-}
-
-impl ToAscPtr for ArweaveTrigger {
-    fn to_asc_ptr<H: AscHeap>(
-        self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscPtr<()>, HostExportError> {
-        Ok(match self {
-            ArweaveTrigger::Block(block) => asc_new(heap, block.as_ref(), gas)?.erase(),
-            ArweaveTrigger::Transaction(tx) => asc_new(heap, tx.as_ref(), gas)?.erase(),
-        })
-    }
-}
-
-#[derive(Clone)]
-pub enum ArweaveTrigger {
-    Block(Arc<codec::Block>),
-    Transaction(Arc<TransactionWithBlockPtr>),
-}
-
-impl CheapClone for ArweaveTrigger {
-    fn cheap_clone(&self) -> ArweaveTrigger {
-        match self {
-            ArweaveTrigger::Block(block) => ArweaveTrigger::Block(block.cheap_clone()),
-            ArweaveTrigger::Transaction(tx) => ArweaveTrigger::Transaction(tx.cheap_clone()),
-        }
-    }
-}
-
-impl PartialEq for ArweaveTrigger {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::Block(a_ptr), Self::Block(b_ptr)) => a_ptr == b_ptr,
-            (Self::Transaction(a_tx), Self::Transaction(b_tx)) => a_tx.tx.id == b_tx.tx.id,
-            _ => false,
-        }
-    }
-}
-
-impl Eq for ArweaveTrigger {}
-
-impl ArweaveTrigger {
-    pub fn block_number(&self) -> BlockNumber {
-        match self {
-            ArweaveTrigger::Block(block) => block.number(),
-            ArweaveTrigger::Transaction(tx) => tx.block.number(),
-        }
-    }
-
-    pub fn block_hash(&self) -> H256 {
-        match self {
-            ArweaveTrigger::Block(block) => block.ptr().hash_as_h256(),
-            ArweaveTrigger::Transaction(tx) => tx.block.ptr().hash_as_h256(),
-        }
-    }
-
-    fn error_context(&self) -> std::string::String {
-        match self {
-            ArweaveTrigger::Block(..) => {
-                format!("Block #{} ({})", self.block_number(), self.block_hash())
-            }
-            ArweaveTrigger::Transaction(tx) => {
-                format!(
-                    "Tx #{}, block #{}({})",
-                    base64_url::encode(&tx.tx.id),
-                    self.block_number(),
-                    self.block_hash()
-                )
-            }
-        }
-    }
-}
-
-impl Ord for ArweaveTrigger {
-    fn cmp(&self, other: &Self) -> Ordering {
-        match (self, other) {
-            // Keep the order when comparing two block triggers
-            (Self::Block(..), Self::Block(..)) => Ordering::Equal,
-
-            // Block triggers always come last
-            (Self::Block(..), _) => Ordering::Greater,
-            (_, Self::Block(..)) => Ordering::Less,
-
-            // Execution outcomes have no intrinsic ordering information so we keep the order in
-            // which they are included in the `txs` field of `Block`.
-            (Self::Transaction(..), Self::Transaction(..)) => Ordering::Equal,
-        }
-    }
-}
-
-impl PartialOrd for ArweaveTrigger {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl TriggerData for ArweaveTrigger {
-    fn error_context(&self) -> String {
-        self.error_context()
-    }
-
-    fn address_match(&self) -> Option<&[u8]> {
-        None
-    }
-}
-
-impl MappingTriggerTrait for ArweaveTrigger {
-    fn error_context(&self) -> String {
-        self.error_context()
-    }
-}
-
-pub struct TransactionWithBlockPtr {
-    // REVIEW: Do we want to actually also have those two below behind an `Arc` wrapper?
-    pub tx: Arc<codec::Transaction>,
-    pub block: Arc<codec::Block>,
-}
diff --git a/chain/common/Cargo.toml b/chain/common/Cargo.toml
index cd2e2775960..1f945ea984e 100644
--- a/chain/common/Cargo.toml
+++ b/chain/common/Cargo.toml
@@ -7,6 +7,9 @@ edition.workspace = true
 
 [dependencies]
 protobuf = "3.0.2"
-protobuf-parse = "3.3.0"
+protobuf-parse = "3.7.2"
 anyhow = "1"
-heck = "0.4"
+heck = "0.5"
+
+[lints]
+workspace = true
diff --git a/chain/common/src/lib.rs b/chain/common/src/lib.rs
index b8f2ae47eb4..395dd440c84 100644
--- a/chain/common/src/lib.rs
+++ b/chain/common/src/lib.rs
@@ -2,13 +2,13 @@ use std::collections::HashMap;
 use std::fmt::Debug;
 
 use anyhow::Error;
-use protobuf::descriptor::field_descriptor_proto::Label;
-use protobuf::descriptor::field_descriptor_proto::Type;
+use protobuf::Message;
+use protobuf::UnknownValueRef;
 use protobuf::descriptor::DescriptorProto;
 use protobuf::descriptor::FieldDescriptorProto;
 use protobuf::descriptor::OneofDescriptorProto;
-use protobuf::Message;
-use protobuf::UnknownValueRef;
+use protobuf::descriptor::field_descriptor_proto::Label;
+use protobuf::descriptor::field_descriptor_proto::Type;
 use std::convert::From;
 use std::path::Path;
 
diff --git a/chain/common/tests/test-acme.rs b/chain/common/tests/test-acme.rs
index 554e4ecbd5c..2945fea337e 100644
--- a/chain/common/tests/test-acme.rs
+++ b/chain/common/tests/test-acme.rs
@@ -7,8 +7,8 @@ fn check_repeated_type_ok() {
     let types = parse_proto_file(PROTO_FILE).expect("Unable to read proto file!");
 
     let array_types = types
-        .iter()
-        .flat_map(|(_, t)| t.fields.iter())
+        .values()
+        .flat_map(|t| t.fields.iter())
         .filter(|t| t.is_array)
         .map(|t| t.type_name.clone())
         .collect::<std::collections::HashSet<_>>();
@@ -63,7 +63,7 @@ fn required_ok() {
                 !f.required,
                 "Transaction.events field should NOT be required!"
             ),
-            _ => assert!(false, "Unexpected message field [{}]!", f.name),
+            _ => panic!("Unexpected message field [{}]!", f.name),
         };
     });
 }
diff --git a/chain/cosmos/Cargo.toml b/chain/cosmos/Cargo.toml
deleted file mode 100644
index d1a4e219866..00000000000
--- a/chain/cosmos/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-name = "graph-chain-cosmos"
-version.workspace = true
-edition = "2018"
-
-[build-dependencies]
-tonic-build = { workspace = true }
-graph-chain-common = { path = "../common" }
-
-[dependencies]
-graph = { path = "../../graph" }
-prost = { workspace = true }
-prost-types = { workspace = true }
-serde = "1.0"
-anyhow = "1.0"
-semver = "1.0.21"
-
-graph-runtime-wasm = { path = "../../runtime/wasm" }
-graph-runtime-derive = { path = "../../runtime/derive" }
diff --git a/chain/cosmos/build.rs b/chain/cosmos/build.rs
deleted file mode 100644
index c618d3b466d..00000000000
--- a/chain/cosmos/build.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-const PROTO_FILE: &str = "proto/cosmos.proto";
-
-fn main() {
-    println!("cargo:rerun-if-changed=proto");
-
-    let types =
-        graph_chain_common::parse_proto_file(PROTO_FILE).expect("Unable to parse proto file!");
-
-    let array_types = types
-        .iter()
-        .flat_map(|(_, t)| t.fields.iter())
-        .filter(|t| t.is_array)
-        .map(|t| t.type_name.clone())
-        .collect::<std::collections::HashSet<_>>();
-
-    let mut builder = tonic_build::configure().out_dir("src/protobuf");
-
-    for (name, ptype) in types {
-        //generate Asc<Type>
-        builder = builder.type_attribute(
-            name.clone(),
-            format!(
-                "#[graph_runtime_derive::generate_asc_type({})]",
-                ptype.fields().unwrap_or_default()
-            ),
-        );
-
-        //generate data index id
-        builder = builder.type_attribute(
-            name.clone(),
-            "#[graph_runtime_derive::generate_network_type_id(Cosmos)]",
-        );
-
-        //generate conversion from rust type to asc
-        builder = builder.type_attribute(
-            name.clone(),
-            format!(
-                "#[graph_runtime_derive::generate_from_rust_type({})]",
-                ptype.fields().unwrap_or_default()
-            ),
-        );
-
-        if array_types.contains(&ptype.name) {
-            builder = builder.type_attribute(
-                name.clone(),
-                "#[graph_runtime_derive::generate_array_type(Cosmos)]",
-            );
-        }
-    }
-
-    builder
-        .compile(&[PROTO_FILE], &["proto"])
-        .expect("Failed to compile Firehose Cosmos proto(s)");
-}
diff --git a/chain/cosmos/proto/cosmos.proto b/chain/cosmos/proto/cosmos.proto
deleted file mode 100644
index c32502da1e9..00000000000
--- a/chain/cosmos/proto/cosmos.proto
+++ /dev/null
@@ -1,368 +0,0 @@
-syntax = "proto3";
-
-package sf.cosmos.type.v1;
-
-option go_package = "github.com/figment-networks/proto-cosmos/pb/sf/cosmos/type/v1;pbcosmos";
-
-import "google/protobuf/descriptor.proto";
-import "google/protobuf/any.proto";
-import "gogoproto/gogo.proto";
-import "cosmos_proto/cosmos.proto";
-import "firehose/annotations.proto";
-
-message Block {
-  Header header = 1 [(firehose.required) = true, (gogoproto.nullable) = false];
-  EvidenceList evidence = 2 [(gogoproto.nullable) = false];
-  Commit last_commit = 3;
-  ResponseBeginBlock result_begin_block = 4 [(firehose.required) = true];
-  ResponseEndBlock result_end_block = 5 [(firehose.required) = true];
-  repeated TxResult transactions = 7;
-  repeated Validator validator_updates = 8;
-}
-
-// HeaderOnlyBlock is a standard [Block] structure where all other fields are
-// removed so that hydrating that object from a [Block] bytes payload will
-// drastically reduce allocated memory required to hold the full block.
-//
-// This can be used to unpack a [Block] when only the [Header] information
-// is required and greatly reduce required memory.
-message HeaderOnlyBlock {
-  Header header = 1 [(firehose.required) = true, (gogoproto.nullable) = false];
-}
-
-message EventData {
-  Event event = 1 [(firehose.required) = true];
-  HeaderOnlyBlock block = 2 [(firehose.required) = true];
-  TransactionContext tx = 3;
-}
-
-message TransactionData {
-  TxResult tx = 1 [(firehose.required) = true];
-  HeaderOnlyBlock block = 2 [(firehose.required) = true];
-}
-
-message MessageData {
-  google.protobuf.Any message = 1 [(firehose.required) = true];
-  HeaderOnlyBlock block = 2 [(firehose.required) = true];
-  TransactionContext tx = 3 [(firehose.required) = true];
-}
-
-message TransactionContext {
-  bytes hash = 1;
-  uint32 index = 2;
-  uint32 code = 3;
-  int64 gas_wanted = 4;
-  int64 gas_used = 5;
-}
-
-message Header {
-  Consensus version = 1 [(gogoproto.nullable) = false];
-  string chain_id = 2 [(gogoproto.customname) = "ChainID"];
-  uint64 height = 3;
-  Timestamp time = 4 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
-  BlockID last_block_id = 5 [(firehose.required) = true, (gogoproto.nullable) = false];
-  bytes last_commit_hash = 6;
-  bytes data_hash = 7;
-  bytes validators_hash = 8;
-  bytes next_validators_hash = 9;
-  bytes consensus_hash = 10;
-  bytes app_hash = 11;
-  bytes last_results_hash = 12;
-  bytes evidence_hash = 13;
-  bytes proposer_address = 14;
-  bytes hash = 15;
-}
-
-message Consensus {
-  option (gogoproto.equal) = true;
-
-  uint64 block = 1;
-  uint64 app = 2;
-}
-
-message Timestamp {
-  int64 seconds = 1;
-  int32 nanos = 2;
-}
-
-message BlockID {
-  bytes hash = 1;
-  PartSetHeader part_set_header = 2 [(gogoproto.nullable) = false];
-}
-
-message PartSetHeader {
-  uint32 total = 1;
-  bytes hash = 2;
-}
-
-message EvidenceList {
-  repeated Evidence evidence = 1 [(gogoproto.nullable) = false];
-}
-
-message Evidence {
-  oneof sum {
-    DuplicateVoteEvidence duplicate_vote_evidence = 1;
-    LightClientAttackEvidence light_client_attack_evidence = 2;
-  }
-}
-
-message DuplicateVoteEvidence {
-  EventVote vote_a = 1;
-  EventVote vote_b = 2;
-  int64 total_voting_power = 3;
-  int64 validator_power = 4;
-  Timestamp timestamp = 5 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
-}
-
-message EventVote {
-  SignedMsgType event_vote_type = 1 [json_name = "type"];
-  uint64 height = 2;
-  int32 round = 3;
-  BlockID block_id = 4 [(gogoproto.nullable) = false, (gogoproto.customname) = "BlockID"];
-  Timestamp timestamp = 5 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
-  bytes validator_address = 6;
-  int32 validator_index = 7;
-  bytes signature = 8;
-}
-
-enum SignedMsgType {
-  option (gogoproto.goproto_enum_stringer) = true;
-  option (gogoproto.goproto_enum_prefix) = false;
-
-  SIGNED_MSG_TYPE_UNKNOWN = 0 [(gogoproto.enumvalue_customname) = "UnknownType"];
-  SIGNED_MSG_TYPE_PREVOTE = 1 [(gogoproto.enumvalue_customname) = "PrevoteType"];
-  SIGNED_MSG_TYPE_PRECOMMIT = 2 [(gogoproto.enumvalue_customname) = "PrecommitType"];
-  SIGNED_MSG_TYPE_PROPOSAL = 32 [(gogoproto.enumvalue_customname) = "ProposalType"];
-}
-
-message LightClientAttackEvidence {
-  LightBlock conflicting_block = 1;
-  int64 common_height = 2;
-  repeated Validator byzantine_validators = 3;
-  int64 total_voting_power = 4;
-  Timestamp timestamp = 5 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
-}
-
-message LightBlock {
-  SignedHeader signed_header = 1;
-  ValidatorSet validator_set = 2;
-}
-
-message SignedHeader {
-  Header header = 1;
-  Commit commit = 2;
-}
-
-message Commit {
-  int64 height = 1;
-  int32 round = 2;
-  BlockID block_id = 3 [(gogoproto.nullable) = false, (gogoproto.customname) = "BlockID"];
-  repeated CommitSig signatures = 4 [(gogoproto.nullable) = false];
-}
-
-message CommitSig {
-  BlockIDFlag block_id_flag = 1;
-  bytes validator_address = 2;
-  Timestamp timestamp = 3 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
-  bytes signature = 4;
-}
-
-enum BlockIDFlag {
-  option (gogoproto.goproto_enum_stringer) = true;
-  option (gogoproto.goproto_enum_prefix) = false;
-
-  BLOCK_ID_FLAG_UNKNOWN = 0 [(gogoproto.enumvalue_customname) = "BlockIDFlagUnknown"];
-  BLOCK_ID_FLAG_ABSENT = 1 [(gogoproto.enumvalue_customname) = "BlockIDFlagAbsent"];
-  BLOCK_ID_FLAG_COMMIT = 2 [(gogoproto.enumvalue_customname) = "BlockIDFlagCommit"];
-  BLOCK_ID_FLAG_NIL = 3 [(gogoproto.enumvalue_customname) = "BlockIDFlagNil"];
-}
-
-message ValidatorSet {
-  repeated Validator validators = 1;
-  Validator proposer = 2;
-  int64 total_voting_power = 3;
-}
-
-message Validator {
-  bytes address = 1;
-  PublicKey pub_key = 2 [(gogoproto.nullable) = false];
-  int64 voting_power = 3;
-  int64 proposer_priority = 4;
-}
-
-message PublicKey {
-  option (gogoproto.compare) = true;
-  option (gogoproto.equal) = true;
-
-  oneof sum {
-    bytes ed25519 = 1;
-    bytes secp256k1 = 2;
-  }
-}
-
-message ResponseBeginBlock {
-  repeated Event events = 1 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"];
-}
-
-message Event {
-  string event_type = 1 [json_name = "type"];
-  repeated EventAttribute attributes = 2 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "attributes,omitempty"];
-}
-
-message EventAttribute {
-  string key = 1;
-  string value = 2;
-  bool index = 3;
-}
-
-message ResponseEndBlock {
-  repeated ValidatorUpdate validator_updates = 1;
-  ConsensusParams consensus_param_updates = 2;
-  repeated Event events = 3;
-}
-
-message ValidatorUpdate {
-  bytes address = 1;
-  PublicKey pub_key = 2 [(gogoproto.nullable) = false];
-  int64 power = 3;
-}
-
-message ConsensusParams {
-  BlockParams block = 1 [(gogoproto.nullable) = false];
-  EvidenceParams evidence = 2 [(gogoproto.nullable) = false];
-  ValidatorParams validator = 3 [(gogoproto.nullable) = false];
-  VersionParams version = 4 [(gogoproto.nullable) = false];
-}
-
-message BlockParams {
-  int64 max_bytes = 1;
-  int64 max_gas = 2;
-}
-
-message EvidenceParams {
-  int64 max_age_num_blocks = 1;
-  Duration max_age_duration = 2 [(gogoproto.nullable) = false, (gogoproto.stdduration) = true];
-  int64 max_bytes = 3;
-}
-
-message Duration {
-  int64 seconds = 1;
-  int32 nanos = 2;
-}
-
-message ValidatorParams {
-  option (gogoproto.populate) = true;
-  option (gogoproto.equal) = true;
-
-  repeated string pub_key_types = 1;
-}
-
-message VersionParams {
-  option (gogoproto.populate) = true;
-  option (gogoproto.equal) = true;
-
-  uint64 app_version = 1;
-}
-
-message TxResult {
-  uint64 height = 1;
-  uint32 index = 2;
-  Tx tx = 3 [(firehose.required) = true];
-  ResponseDeliverTx result = 4 [(firehose.required) = true];
-  bytes hash = 5;
-}
-
-message Tx {
-  TxBody body = 1 [(firehose.required) = true];
-  AuthInfo auth_info = 2;
-  repeated bytes signatures = 3;
-}
-
-message TxBody {
-  repeated google.protobuf.Any messages = 1;
-  string memo = 2;
-  uint64 timeout_height = 3;
-  repeated google.protobuf.Any extension_options = 1023;
-  repeated google.protobuf.Any non_critical_extension_options = 2047;
-}
-
-message Any {
-  string type_url = 1;
-  bytes value = 2;
-}
-
-message AuthInfo {
-  repeated SignerInfo signer_infos = 1;
-  Fee fee = 2;
-  Tip tip = 3;
-}
-
-message SignerInfo {
-  google.protobuf.Any public_key = 1;
-  ModeInfo mode_info = 2;
-  uint64 sequence = 3;
-}
-
-message ModeInfo {
-  oneof sum {
-    ModeInfoSingle single = 1;
-    ModeInfoMulti multi = 2;
-  }
-}
-
-message ModeInfoSingle {
-  SignMode mode = 1;
-}
-
-enum SignMode {
-  SIGN_MODE_UNSPECIFIED = 0;
-  SIGN_MODE_DIRECT = 1;
-  SIGN_MODE_TEXTUAL = 2;
-  SIGN_MODE_LEGACY_AMINO_JSON = 127;
-}
-
-message ModeInfoMulti {
-  CompactBitArray bitarray = 1;
-  repeated ModeInfo mode_infos = 2;
-}
-
-message CompactBitArray {
-  option (gogoproto.goproto_stringer) = false;
-
-  uint32 extra_bits_stored = 1;
-  bytes elems = 2;
-}
-
-message Fee {
-  repeated Coin amount = 1 [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"];
-  uint64 gas_limit = 2;
-  string payer = 3 [(cosmos_proto.scalar) = "cosmos.AddressString"];
-  string granter = 4 [(cosmos_proto.scalar) = "cosmos.AddressString"];
-}
-
-message Coin {
-  option (gogoproto.equal) = true;
-
-  string denom = 1;
-  string amount = 2 [(gogoproto.customtype) = "Int", (gogoproto.nullable) = false];
-}
-
-message Tip {
-  repeated Coin amount = 1 [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"];
-  string tipper = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"];
-}
-
-message ResponseDeliverTx {
-  uint32 code = 1;
-  bytes data = 2;
-  string log = 3;
-  string info = 4;
-  int64 gas_wanted = 5;
-  int64 gas_used = 6;
-  repeated Event events = 7 [(gogoproto.nullable) = false, (gogoproto.jsontag) = "events,omitempty"];
-  string codespace = 8;
-}
-
-message ValidatorSetUpdates {
-  repeated Validator validator_updates = 1;
-}
diff --git a/chain/cosmos/proto/cosmos_proto/cosmos.proto b/chain/cosmos/proto/cosmos_proto/cosmos.proto
deleted file mode 100644
index 5c63b86f063..00000000000
--- a/chain/cosmos/proto/cosmos_proto/cosmos.proto
+++ /dev/null
@@ -1,97 +0,0 @@
-syntax = "proto3";
-package cosmos_proto;
-
-import "google/protobuf/descriptor.proto";
-
-option go_package = "github.com/cosmos/cosmos-proto;cosmos_proto";
-
-extend google.protobuf.MessageOptions {
-
-    // implements_interface is used to indicate the type name of the interface
-    // that a message implements so that it can be used in google.protobuf.Any
-    // fields that accept that interface. A message can implement multiple
-    // interfaces. Interfaces should be declared using a declare_interface
-    // file option.
-    repeated string implements_interface = 93001;
-}
-
-extend google.protobuf.FieldOptions {
-
-    // accepts_interface is used to annotate that a google.protobuf.Any
-    // field accepts messages that implement the specified interface.
-    // Interfaces should be declared using a declare_interface file option.
-    string accepts_interface = 93001;
-
-    // scalar is used to indicate that this field follows the formatting defined
-    // by the named scalar which should be declared with declare_scalar. Code
-    // generators may choose to use this information to map this field to a
-    // language-specific type representing the scalar.
-    string scalar = 93002;
-}
-
-extend google.protobuf.FileOptions {
-
-    // declare_interface declares an interface type to be used with
-    // accepts_interface and implements_interface. Interface names are
-    // expected to follow the following convention such that their declaration
-    // can be discovered by tools: for a given interface type a.b.C, it is
-    // expected that the declaration will be found in a protobuf file named
-    // a/b/interfaces.proto in the file descriptor set.
-    repeated InterfaceDescriptor declare_interface = 793021;
-
-    // declare_scalar declares a scalar type to be used with
-    // the scalar field option. Scalar names are
-    // expected to follow the following convention such that their declaration
-    // can be discovered by tools: for a given scalar type a.b.C, it is
-    // expected that the declaration will be found in a protobuf file named
-    // a/b/scalars.proto in the file descriptor set.
-    repeated ScalarDescriptor declare_scalar = 793022;
-}
-
-// InterfaceDescriptor describes an interface type to be used with
-// accepts_interface and implements_interface and declared by declare_interface.
-message InterfaceDescriptor {
-
-    // name is the name of the interface. It should be a short-name (without
-    // a period) such that the fully qualified name of the interface will be
-    // package.name, ex. for the package a.b and interface named C, the
-    // fully-qualified name will be a.b.C.
-    string name = 1;
-
-    // description is a human-readable description of the interface and its
-    // purpose.
-    string description = 2;
-}
-
-// ScalarDescriptor describes an scalar type to be used with
-// the scalar field option and declared by declare_scalar.
-// Scalars extend simple protobuf built-in types with additional
-// syntax and semantics, for instance to represent big integers.
-// Scalars should ideally define an encoding such that there is only one
-// valid syntactical representation for a given semantic meaning,
-// i.e. the encoding should be deterministic.
-message ScalarDescriptor {
-
-    // name is the name of the scalar. It should be a short-name (without
-    // a period) such that the fully qualified name of the scalar will be
-    // package.name, ex. for the package a.b and scalar named C, the
-    // fully-qualified name will be a.b.C.
-    string name = 1;
-
-    // description is a human-readable description of the scalar and its
-    // encoding format. For instance a big integer or decimal scalar should
-    // specify precisely the expected encoding format.
-    string description = 2;
-
-    // field_type is the type of field with which this scalar can be used.
-    // Scalars can be used with one and only one type of field so that
-    // encoding standards and simple and clear. Currently only string and
-    // bytes fields are supported for scalars.
-    repeated ScalarType field_type = 3;
-}
-
-enum ScalarType {
-    SCALAR_TYPE_UNSPECIFIED = 0;
-    SCALAR_TYPE_STRING = 1;
-    SCALAR_TYPE_BYTES = 2;
-}
diff --git a/chain/cosmos/proto/firehose/annotations.proto b/chain/cosmos/proto/firehose/annotations.proto
deleted file mode 100644
index 1476c1ab08d..00000000000
--- a/chain/cosmos/proto/firehose/annotations.proto
+++ /dev/null
@@ -1,11 +0,0 @@
-syntax = "proto3";
-
-package firehose;
-
-option go_package = "github.com/streamingfast/pbgo/sf/firehose/v1;pbfirehose";
-
-import "google/protobuf/descriptor.proto";
-
-extend google.protobuf.FieldOptions {
-  optional bool required = 77001;
-}
diff --git a/chain/cosmos/proto/gogoproto/gogo.proto b/chain/cosmos/proto/gogoproto/gogo.proto
deleted file mode 100644
index 49e78f99fe5..00000000000
--- a/chain/cosmos/proto/gogoproto/gogo.proto
+++ /dev/null
@@ -1,145 +0,0 @@
-// Protocol Buffers for Go with Gadgets
-//
-// Copyright (c) 2013, The GoGo Authors. All rights reserved.
-// http://github.com/gogo/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto2";
-package gogoproto;
-
-import "google/protobuf/descriptor.proto";
-
-option java_package = "com.google.protobuf";
-option java_outer_classname = "GoGoProtos";
-option go_package = "github.com/gogo/protobuf/gogoproto";
-
-extend google.protobuf.EnumOptions {
-	optional bool goproto_enum_prefix = 62001;
-	optional bool goproto_enum_stringer = 62021;
-	optional bool enum_stringer = 62022;
-	optional string enum_customname = 62023;
-	optional bool enumdecl = 62024;
-}
-
-extend google.protobuf.EnumValueOptions {
-	optional string enumvalue_customname = 66001;
-}
-
-extend google.protobuf.FileOptions {
-	optional bool goproto_getters_all = 63001;
-	optional bool goproto_enum_prefix_all = 63002;
-	optional bool goproto_stringer_all = 63003;
-	optional bool verbose_equal_all = 63004;
-	optional bool face_all = 63005;
-	optional bool gostring_all = 63006;
-	optional bool populate_all = 63007;
-	optional bool stringer_all = 63008;
-	optional bool onlyone_all = 63009;
-
-	optional bool equal_all = 63013;
-	optional bool description_all = 63014;
-	optional bool testgen_all = 63015;
-	optional bool benchgen_all = 63016;
-	optional bool marshaler_all = 63017;
-	optional bool unmarshaler_all = 63018;
-	optional bool stable_marshaler_all = 63019;
-
-	optional bool sizer_all = 63020;
-
-	optional bool goproto_enum_stringer_all = 63021;
-	optional bool enum_stringer_all = 63022;
-
-	optional bool unsafe_marshaler_all = 63023;
-	optional bool unsafe_unmarshaler_all = 63024;
-
-	optional bool goproto_extensions_map_all = 63025;
-	optional bool goproto_unrecognized_all = 63026;
-	optional bool gogoproto_import = 63027;
-	optional bool protosizer_all = 63028;
-	optional bool compare_all = 63029;
-    optional bool typedecl_all = 63030;
-    optional bool enumdecl_all = 63031;
-
-	optional bool goproto_registration = 63032;
-	optional bool messagename_all = 63033;
-
-	optional bool goproto_sizecache_all = 63034;
-	optional bool goproto_unkeyed_all = 63035;
-}
-
-extend google.protobuf.MessageOptions {
-	optional bool goproto_getters = 64001;
-	optional bool goproto_stringer = 64003;
-	optional bool verbose_equal = 64004;
-	optional bool face = 64005;
-	optional bool gostring = 64006;
-	optional bool populate = 64007;
-	optional bool stringer = 67008;
-	optional bool onlyone = 64009;
-
-	optional bool equal = 64013;
-	optional bool description = 64014;
-	optional bool testgen = 64015;
-	optional bool benchgen = 64016;
-	optional bool marshaler = 64017;
-	optional bool unmarshaler = 64018;
-	optional bool stable_marshaler = 64019;
-
-	optional bool sizer = 64020;
-
-	optional bool unsafe_marshaler = 64023;
-	optional bool unsafe_unmarshaler = 64024;
-
-	optional bool goproto_extensions_map = 64025;
-	optional bool goproto_unrecognized = 64026;
-
-	optional bool protosizer = 64028;
-	optional bool compare = 64029;
-
-	optional bool typedecl = 64030;
-
-	optional bool messagename = 64033;
-
-	optional bool goproto_sizecache = 64034;
-	optional bool goproto_unkeyed = 64035;
-}
-
-extend google.protobuf.FieldOptions {
-	optional bool nullable = 65001;
-	optional bool embed = 65002;
-	optional string customtype = 65003;
-	optional string customname = 65004;
-	optional string jsontag = 65005;
-	optional string moretags = 65006;
-	optional string casttype = 65007;
-	optional string castkey = 65008;
-	optional string castvalue = 65009;
-
-	optional bool stdtime = 65010;
-	optional bool stdduration = 65011;
-	optional bool wktpointer = 65012;
-
-	optional string castrepeated = 65013;
-}
diff --git a/chain/cosmos/src/adapter.rs b/chain/cosmos/src/adapter.rs
deleted file mode 100644
index 746c91e2e07..00000000000
--- a/chain/cosmos/src/adapter.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-use std::collections::HashSet;
-
-use prost::Message;
-use prost_types::Any;
-
-use crate::{data_source::DataSource, Chain};
-use graph::blockchain as bc;
-use graph::firehose::EventTypeFilter;
-use graph::prelude::*;
-
-const EVENT_TYPE_FILTER_TYPE_URL: &str =
-    "type.googleapis.com/sf.cosmos.transform.v1.EventTypeFilter";
-
-#[derive(Clone, Debug, Default)]
-pub struct TriggerFilter {
-    pub(crate) event_type_filter: CosmosEventTypeFilter,
-    pub(crate) block_filter: CosmosBlockFilter,
-}
-
-impl bc::TriggerFilter<Chain> for TriggerFilter {
-    fn extend<'a>(&mut self, data_sources: impl Iterator<Item = &'a DataSource> + Clone) {
-        self.event_type_filter
-            .extend_from_data_sources(data_sources.clone());
-        self.block_filter.extend_from_data_sources(data_sources);
-    }
-
-    fn node_capabilities(&self) -> bc::EmptyNodeCapabilities<Chain> {
-        bc::EmptyNodeCapabilities::default()
-    }
-
-    fn extend_with_template(
-        &mut self,
-        _data_source: impl Iterator<Item = <Chain as bc::Blockchain>::DataSourceTemplate>,
-    ) {
-    }
-
-    fn to_firehose_filter(self) -> Vec<prost_types::Any> {
-        if self.block_filter.trigger_every_block {
-            return vec![];
-        }
-
-        if self.event_type_filter.event_types.is_empty() {
-            return vec![];
-        }
-
-        let filter = EventTypeFilter {
-            event_types: Vec::from_iter(self.event_type_filter.event_types),
-        };
-
-        vec![Any {
-            type_url: EVENT_TYPE_FILTER_TYPE_URL.to_string(),
-            value: filter.encode_to_vec(),
-        }]
-    }
-}
-
-pub type EventType = String;
-
-#[derive(Clone, Debug, Default)]
-pub(crate) struct CosmosEventTypeFilter {
-    pub event_types: HashSet<EventType>,
-}
-
-impl CosmosEventTypeFilter {
-    pub(crate) fn matches(&self, event_type: &EventType) -> bool {
-        self.event_types.contains(event_type)
-    }
-
-    fn extend_from_data_sources<'a>(&mut self, data_sources: impl Iterator<Item = &'a DataSource>) {
-        self.event_types.extend(
-            data_sources.flat_map(|data_source| data_source.events().map(ToString::to_string)),
-        );
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub(crate) struct CosmosBlockFilter {
-    pub trigger_every_block: bool,
-}
-
-impl CosmosBlockFilter {
-    fn extend_from_data_sources<'a>(
-        &mut self,
-        mut data_sources: impl Iterator<Item = &'a DataSource>,
-    ) {
-        if !self.trigger_every_block {
-            self.trigger_every_block = data_sources.any(DataSource::has_block_handler);
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use graph::blockchain::TriggerFilter as _;
-
-    use super::*;
-
-    #[test]
-    fn test_trigger_filters() {
-        let cases = [
-            (TriggerFilter::test_new(false, &[]), None),
-            (TriggerFilter::test_new(true, &[]), None),
-            (TriggerFilter::test_new(true, &["event_1", "event_2"]), None),
-            (
-                TriggerFilter::test_new(false, &["event_1", "event_2", "event_3"]),
-                Some(event_type_filter_with(&["event_1", "event_2", "event_3"])),
-            ),
-        ];
-
-        for (trigger_filter, expected_filter) in cases {
-            let firehose_filter = trigger_filter.to_firehose_filter();
-            let decoded_filter = decode_filter(firehose_filter);
-
-            assert_eq!(decoded_filter.is_some(), expected_filter.is_some());
-
-            if let (Some(mut expected_filter), Some(mut decoded_filter)) =
-                (expected_filter, decoded_filter)
-            {
-                // event types may be in different order
-                expected_filter.event_types.sort();
-                decoded_filter.event_types.sort();
-
-                assert_eq!(decoded_filter, expected_filter);
-            }
-        }
-    }
-
-    impl TriggerFilter {
-        pub(crate) fn test_new(trigger_every_block: bool, event_types: &[&str]) -> TriggerFilter {
-            TriggerFilter {
-                event_type_filter: CosmosEventTypeFilter {
-                    event_types: event_types.iter().map(ToString::to_string).collect(),
-                },
-                block_filter: CosmosBlockFilter {
-                    trigger_every_block,
-                },
-            }
-        }
-    }
-
-    fn event_type_filter_with(event_types: &[&str]) -> EventTypeFilter {
-        EventTypeFilter {
-            event_types: event_types.iter().map(ToString::to_string).collect(),
-        }
-    }
-
-    fn decode_filter(proto_filters: Vec<Any>) -> Option<EventTypeFilter> {
-        assert!(proto_filters.len() <= 1);
-
-        let proto_filter = proto_filters.get(0)?;
-
-        assert_eq!(proto_filter.type_url, EVENT_TYPE_FILTER_TYPE_URL);
-
-        let firehose_filter = EventTypeFilter::decode(&*proto_filter.value)
-            .expect("Could not decode EventTypeFilter from protobuf Any");
-
-        Some(firehose_filter)
-    }
-}
diff --git a/chain/cosmos/src/chain.rs b/chain/cosmos/src/chain.rs
deleted file mode 100644
index 5cc1a6f9b1b..00000000000
--- a/chain/cosmos/src/chain.rs
+++ /dev/null
@@ -1,677 +0,0 @@
-use graph::blockchain::firehose_block_ingestor::FirehoseBlockIngestor;
-use graph::blockchain::BlockIngestor;
-use graph::env::EnvVars;
-use graph::prelude::MetricsRegistry;
-use graph::substreams::Clock;
-use std::sync::Arc;
-
-use graph::blockchain::block_stream::{BlockStreamMapper, FirehoseCursor};
-use graph::blockchain::client::ChainClient;
-use graph::blockchain::{BasicBlockchainBuilder, BlockchainBuilder, NoopRuntimeAdapter};
-use graph::cheap_clone::CheapClone;
-use graph::components::store::DeploymentCursorTracker;
-use graph::data::subgraph::UnifiedMappingApiVersion;
-use graph::{
-    blockchain::{
-        block_stream::{
-            BlockStream, BlockStreamEvent, BlockWithTriggers, FirehoseError,
-            FirehoseMapper as FirehoseMapperTrait, TriggersAdapter as TriggersAdapterTrait,
-        },
-        firehose_block_stream::FirehoseBlockStream,
-        Block as _, BlockHash, BlockPtr, Blockchain, BlockchainKind, EmptyNodeCapabilities,
-        IngestorError, RuntimeAdapter as RuntimeAdapterTrait,
-    },
-    components::store::DeploymentLocator,
-    firehose::{self, FirehoseEndpoint, ForkStep},
-    prelude::{async_trait, o, BlockNumber, ChainStore, Error, Logger, LoggerFactory},
-};
-use prost::Message;
-
-use crate::data_source::{
-    DataSource, DataSourceTemplate, EventOrigin, UnresolvedDataSource, UnresolvedDataSourceTemplate,
-};
-use crate::trigger::CosmosTrigger;
-use crate::{codec, TriggerFilter};
-
-pub struct Chain {
-    logger_factory: LoggerFactory,
-    name: String,
-    client: Arc<ChainClient<Self>>,
-    chain_store: Arc<dyn ChainStore>,
-    metrics_registry: Arc<MetricsRegistry>,
-}
-
-impl std::fmt::Debug for Chain {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "chain: cosmos")
-    }
-}
-
-impl BlockchainBuilder<Chain> for BasicBlockchainBuilder {
-    fn build(self, _config: &Arc<EnvVars>) -> Chain {
-        Chain {
-            logger_factory: self.logger_factory,
-            name: self.name,
-            client: Arc::new(ChainClient::new_firehose(self.firehose_endpoints)),
-            chain_store: self.chain_store,
-            metrics_registry: self.metrics_registry,
-        }
-    }
-}
-
-#[async_trait]
-impl Blockchain for Chain {
-    const KIND: BlockchainKind = BlockchainKind::Cosmos;
-
-    type Client = ();
-    type Block = codec::Block;
-
-    type DataSource = DataSource;
-
-    type UnresolvedDataSource = UnresolvedDataSource;
-
-    type DataSourceTemplate = DataSourceTemplate;
-
-    type UnresolvedDataSourceTemplate = UnresolvedDataSourceTemplate;
-
-    type TriggerData = CosmosTrigger;
-
-    type MappingTrigger = CosmosTrigger;
-
-    type TriggerFilter = TriggerFilter;
-
-    type NodeCapabilities = EmptyNodeCapabilities<Self>;
-
-    fn is_refetch_block_required(&self) -> bool {
-        false
-    }
-    async fn refetch_firehose_block(
-        &self,
-        _logger: &Logger,
-        _cursor: FirehoseCursor,
-    ) -> Result<codec::Block, Error> {
-        unimplemented!("This chain does not support Dynamic Data Sources. is_refetch_block_required always returns false, this shouldn't be called.")
-    }
-
-    fn triggers_adapter(
-        &self,
-        _loc: &DeploymentLocator,
-        _capabilities: &Self::NodeCapabilities,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Arc<dyn TriggersAdapterTrait<Self>>, Error> {
-        let adapter = TriggersAdapter {};
-        Ok(Arc::new(adapter))
-    }
-
-    async fn new_block_stream(
-        &self,
-        deployment: DeploymentLocator,
-        store: impl DeploymentCursorTracker,
-        start_blocks: Vec<BlockNumber>,
-        filter: Arc<Self::TriggerFilter>,
-        unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        let adapter = self
-            .triggers_adapter(
-                &deployment,
-                &EmptyNodeCapabilities::default(),
-                unified_api_version,
-            )
-            .unwrap_or_else(|_| panic!("no adapter for network {}", self.name));
-
-        let logger = self
-            .logger_factory
-            .subgraph_logger(&deployment)
-            .new(o!("component" => "FirehoseBlockStream"));
-
-        let firehose_mapper = Arc::new(FirehoseMapper { adapter, filter });
-
-        Ok(Box::new(FirehoseBlockStream::new(
-            deployment.hash,
-            self.chain_client(),
-            store.block_ptr(),
-            store.firehose_cursor(),
-            firehose_mapper,
-            start_blocks,
-            logger,
-            self.metrics_registry.clone(),
-        )))
-    }
-
-    fn chain_store(&self) -> Arc<dyn ChainStore> {
-        self.chain_store.cheap_clone()
-    }
-
-    async fn block_pointer_from_number(
-        &self,
-        logger: &Logger,
-        number: BlockNumber,
-    ) -> Result<BlockPtr, IngestorError> {
-        let firehose_endpoint = self.client.firehose_endpoint()?;
-
-        firehose_endpoint
-            .block_ptr_for_number::<codec::HeaderOnlyBlock>(logger, number)
-            .await
-            .map_err(Into::into)
-    }
-
-    fn runtime_adapter(&self) -> Arc<dyn RuntimeAdapterTrait<Self>> {
-        Arc::new(NoopRuntimeAdapter::default())
-    }
-
-    fn chain_client(&self) -> Arc<ChainClient<Self>> {
-        self.client.clone()
-    }
-
-    fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>> {
-        let ingestor = FirehoseBlockIngestor::<crate::Block, Self>::new(
-            self.chain_store.cheap_clone(),
-            self.chain_client(),
-            self.logger_factory
-                .component_logger("CosmosFirehoseBlockIngestor", None),
-            self.name.clone(),
-        );
-        Ok(Box::new(ingestor))
-    }
-}
-
-pub struct TriggersAdapter {}
-
-#[async_trait]
-impl TriggersAdapterTrait<Chain> for TriggersAdapter {
-    async fn ancestor_block(
-        &self,
-        _ptr: BlockPtr,
-        _offset: BlockNumber,
-    ) -> Result<Option<codec::Block>, Error> {
-        panic!("Should never be called since not used by FirehoseBlockStream")
-    }
-
-    async fn scan_triggers(
-        &self,
-        _from: BlockNumber,
-        _to: BlockNumber,
-        _filter: &TriggerFilter,
-    ) -> Result<Vec<BlockWithTriggers<Chain>>, Error> {
-        panic!("Should never be called since not used by FirehoseBlockStream")
-    }
-
-    async fn triggers_in_block(
-        &self,
-        logger: &Logger,
-        block: codec::Block,
-        filter: &TriggerFilter,
-    ) -> Result<BlockWithTriggers<Chain>, Error> {
-        let shared_block = Arc::new(block.clone());
-
-        let header_only_block = codec::HeaderOnlyBlock::from(&block);
-
-        let mut triggers: Vec<_> = shared_block
-            .begin_block_events()?
-            .cloned()
-            // FIXME (Cosmos): Optimize. Should use an Arc instead of cloning the
-            // block. This is not currently possible because EventData is automatically
-            // generated.
-            .filter_map(|event| {
-                filter_event_trigger(
-                    filter,
-                    event,
-                    &header_only_block,
-                    None,
-                    EventOrigin::BeginBlock,
-                )
-            })
-            .chain(shared_block.transactions().flat_map(|tx| {
-                tx.result
-                    .as_ref()
-                    .unwrap()
-                    .events
-                    .iter()
-                    .filter_map(|e| {
-                        filter_event_trigger(
-                            filter,
-                            e.clone(),
-                            &header_only_block,
-                            Some(build_tx_context(tx)),
-                            EventOrigin::DeliverTx,
-                        )
-                    })
-                    .collect::<Vec<_>>()
-            }))
-            .chain(
-                shared_block
-                    .end_block_events()?
-                    .cloned()
-                    .filter_map(|event| {
-                        filter_event_trigger(
-                            filter,
-                            event,
-                            &header_only_block,
-                            None,
-                            EventOrigin::EndBlock,
-                        )
-                    }),
-            )
-            .collect();
-
-        triggers.extend(shared_block.transactions().cloned().flat_map(|tx_result| {
-            let mut triggers: Vec<_> = Vec::new();
-            if let Some(tx) = tx_result.tx.clone() {
-                if let Some(tx_body) = tx.body {
-                    triggers.extend(tx_body.messages.into_iter().map(|message| {
-                        CosmosTrigger::with_message(
-                            message,
-                            header_only_block.clone(),
-                            build_tx_context(&tx_result),
-                        )
-                    }));
-                }
-            }
-            triggers.push(CosmosTrigger::with_transaction(
-                tx_result,
-                header_only_block.clone(),
-            ));
-            triggers
-        }));
-
-        if filter.block_filter.trigger_every_block {
-            triggers.push(CosmosTrigger::Block(shared_block.cheap_clone()));
-        }
-
-        Ok(BlockWithTriggers::new(block, triggers, logger))
-    }
-
-    async fn is_on_main_chain(&self, _ptr: BlockPtr) -> Result<bool, Error> {
-        panic!("Should never be called since not used by FirehoseBlockStream")
-    }
-
-    /// Panics if `block` is genesis.
-    /// But that's ok since this is only called when reverting `block`.
-    async fn parent_ptr(&self, block: &BlockPtr) -> Result<Option<BlockPtr>, Error> {
-        Ok(Some(BlockPtr {
-            hash: BlockHash::from(vec![0xff; 32]),
-            number: block.number.saturating_sub(1),
-        }))
-    }
-}
-
-/// Returns a new event trigger only if the given event matches the event filter.
-fn filter_event_trigger(
-    filter: &TriggerFilter,
-    event: codec::Event,
-    block: &codec::HeaderOnlyBlock,
-    tx_context: Option<codec::TransactionContext>,
-    origin: EventOrigin,
-) -> Option<CosmosTrigger> {
-    if filter.event_type_filter.matches(&event.event_type) {
-        Some(CosmosTrigger::with_event(
-            event,
-            block.clone(),
-            tx_context,
-            origin,
-        ))
-    } else {
-        None
-    }
-}
-
-fn build_tx_context(tx: &codec::TxResult) -> codec::TransactionContext {
-    codec::TransactionContext {
-        hash: tx.hash.clone(),
-        index: tx.index,
-        code: tx.result.as_ref().unwrap().code,
-        gas_wanted: tx.result.as_ref().unwrap().gas_wanted,
-        gas_used: tx.result.as_ref().unwrap().gas_used,
-    }
-}
-
-pub struct FirehoseMapper {
-    adapter: Arc<dyn TriggersAdapterTrait<Chain>>,
-    filter: Arc<TriggerFilter>,
-}
-
-#[async_trait]
-impl BlockStreamMapper<Chain> for FirehoseMapper {
-    fn decode_block(&self, output: Option<&[u8]>) -> Result<Option<crate::Block>, Error> {
-        let block = match output {
-            Some(block) => crate::Block::decode(block)?,
-            None => anyhow::bail!("cosmos mapper is expected to always have a block"),
-        };
-
-        Ok(Some(block))
-    }
-
-    async fn block_with_triggers(
-        &self,
-        logger: &Logger,
-        block: crate::Block,
-    ) -> Result<BlockWithTriggers<Chain>, Error> {
-        self.adapter
-            .triggers_in_block(logger, block, self.filter.as_ref())
-            .await
-    }
-
-    async fn handle_substreams_block(
-        &self,
-        _logger: &Logger,
-        _clock: Clock,
-        _cursor: FirehoseCursor,
-        _block: Vec<u8>,
-    ) -> Result<BlockStreamEvent<Chain>, Error> {
-        unimplemented!()
-    }
-}
-
-#[async_trait]
-impl FirehoseMapperTrait<Chain> for FirehoseMapper {
-    fn trigger_filter(&self) -> &TriggerFilter {
-        self.filter.as_ref()
-    }
-
-    async fn to_block_stream_event(
-        &self,
-        logger: &Logger,
-        response: &firehose::Response,
-    ) -> Result<BlockStreamEvent<Chain>, FirehoseError> {
-        let step = ForkStep::from_i32(response.step).unwrap_or_else(|| {
-            panic!(
-                "unknown step i32 value {}, maybe you forgot update & re-regenerate the protobuf definitions?",
-                response.step
-            )
-        });
-
-        let any_block = response
-            .block
-            .as_ref()
-            .expect("block payload information should always be present");
-
-        // Right now, this is done in all cases but in reality, with how the BlockStreamEvent::Revert
-        // is defined right now, only block hash and block number is necessary. However, this information
-        // is not part of the actual bstream::BlockResponseV2 payload. As such, we need to decode the full
-        // block which is useless.
-        //
-        // Check about adding basic information about the block in the bstream::BlockResponseV2 or maybe
-        // define a slimmed down struct that would decode only a few fields and ignore all the rest.
-        // unwrap: Input cannot be None so output will be error or block.
-        let block = self.decode_block(Some(any_block.value.as_ref()))?.unwrap();
-
-        match step {
-            ForkStep::StepNew => Ok(BlockStreamEvent::ProcessBlock(
-                self.block_with_triggers(logger, block).await?,
-                FirehoseCursor::from(response.cursor.clone()),
-            )),
-
-            ForkStep::StepUndo => {
-                let parent_ptr = block
-                    .parent_ptr()
-                    .map_err(FirehoseError::from)?
-                    .expect("Genesis block should never be reverted");
-
-                Ok(BlockStreamEvent::Revert(
-                    parent_ptr,
-                    FirehoseCursor::from(response.cursor.clone()),
-                ))
-            }
-
-            ForkStep::StepFinal => {
-                panic!(
-                    "final step is not handled and should not be requested in the Firehose request"
-                )
-            }
-
-            ForkStep::StepUnset => {
-                panic!("unknown step should not happen in the Firehose response")
-            }
-        }
-    }
-
-    async fn block_ptr_for_number(
-        &self,
-        logger: &Logger,
-        endpoint: &Arc<FirehoseEndpoint>,
-        number: BlockNumber,
-    ) -> Result<BlockPtr, Error> {
-        endpoint
-            .block_ptr_for_number::<codec::HeaderOnlyBlock>(logger, number)
-            .await
-    }
-
-    async fn final_block_ptr_for(
-        &self,
-        logger: &Logger,
-        endpoint: &Arc<FirehoseEndpoint>,
-        block: &codec::Block,
-    ) -> Result<BlockPtr, Error> {
-        // Cosmos provides instant block finality.
-        self.block_ptr_for_number(logger, endpoint, block.number())
-            .await
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use graph::prelude::{
-        slog::{o, Discard, Logger},
-        tokio,
-    };
-
-    use super::*;
-
-    use codec::{
-        Block, Event, Header, HeaderOnlyBlock, ResponseBeginBlock, ResponseDeliverTx,
-        ResponseEndBlock, TxResult,
-    };
-
-    #[tokio::test]
-    async fn test_trigger_filters() {
-        let adapter = TriggersAdapter {};
-        let logger = Logger::root(Discard, o!());
-
-        let block_with_events = Block::test_with_event_types(
-            vec!["begin_event_1", "begin_event_2", "begin_event_3"],
-            vec!["tx_event_1", "tx_event_2", "tx_event_3"],
-            vec!["end_event_1", "end_event_2", "end_event_3"],
-        );
-
-        let header_only_block = HeaderOnlyBlock::from(&block_with_events);
-
-        let cases = [
-            (
-                Block::test_new(),
-                TriggerFilter::test_new(false, &[]),
-                vec![],
-            ),
-            (
-                Block::test_new(),
-                TriggerFilter::test_new(true, &[]),
-                vec![CosmosTrigger::Block(Arc::new(Block::test_new()))],
-            ),
-            (
-                Block::test_new(),
-                TriggerFilter::test_new(false, &["event_1", "event_2", "event_3"]),
-                vec![],
-            ),
-            (
-                block_with_events.clone(),
-                TriggerFilter::test_new(false, &["begin_event_3", "tx_event_3", "end_event_3"]),
-                vec![
-                    CosmosTrigger::with_event(
-                        Event::test_with_type("begin_event_3"),
-                        header_only_block.clone(),
-                        None,
-                        EventOrigin::BeginBlock,
-                    ),
-                    CosmosTrigger::with_event(
-                        Event::test_with_type("tx_event_3"),
-                        header_only_block.clone(),
-                        Some(build_tx_context(&block_with_events.transactions[2])),
-                        EventOrigin::DeliverTx,
-                    ),
-                    CosmosTrigger::with_event(
-                        Event::test_with_type("end_event_3"),
-                        header_only_block.clone(),
-                        None,
-                        EventOrigin::EndBlock,
-                    ),
-                    CosmosTrigger::with_transaction(
-                        TxResult::test_with_event_type("tx_event_1"),
-                        header_only_block.clone(),
-                    ),
-                    CosmosTrigger::with_transaction(
-                        TxResult::test_with_event_type("tx_event_2"),
-                        header_only_block.clone(),
-                    ),
-                    CosmosTrigger::with_transaction(
-                        TxResult::test_with_event_type("tx_event_3"),
-                        header_only_block.clone(),
-                    ),
-                ],
-            ),
-            (
-                block_with_events.clone(),
-                TriggerFilter::test_new(true, &["begin_event_3", "tx_event_2", "end_event_1"]),
-                vec![
-                    CosmosTrigger::Block(Arc::new(block_with_events.clone())),
-                    CosmosTrigger::with_event(
-                        Event::test_with_type("begin_event_3"),
-                        header_only_block.clone(),
-                        None,
-                        EventOrigin::BeginBlock,
-                    ),
-                    CosmosTrigger::with_event(
-                        Event::test_with_type("tx_event_2"),
-                        header_only_block.clone(),
-                        Some(build_tx_context(&block_with_events.transactions[1])),
-                        EventOrigin::DeliverTx,
-                    ),
-                    CosmosTrigger::with_event(
-                        Event::test_with_type("end_event_1"),
-                        header_only_block.clone(),
-                        None,
-                        EventOrigin::EndBlock,
-                    ),
-                    CosmosTrigger::with_transaction(
-                        TxResult::test_with_event_type("tx_event_1"),
-                        header_only_block.clone(),
-                    ),
-                    CosmosTrigger::with_transaction(
-                        TxResult::test_with_event_type("tx_event_2"),
-                        header_only_block.clone(),
-                    ),
-                    CosmosTrigger::with_transaction(
-                        TxResult::test_with_event_type("tx_event_3"),
-                        header_only_block.clone(),
-                    ),
-                ],
-            ),
-        ];
-
-        for (block, trigger_filter, expected_triggers) in cases {
-            let triggers = adapter
-                .triggers_in_block(&logger, block, &trigger_filter)
-                .await
-                .expect("failed to get triggers in block");
-
-            assert_eq!(
-                triggers.trigger_data.len(),
-                expected_triggers.len(),
-                "Expected trigger list to contain exactly {:?}, but it didn't: {:?}",
-                expected_triggers,
-                triggers.trigger_data
-            );
-
-            // they may not be in the same order
-            for trigger in expected_triggers {
-                assert!(
-                    triggers.trigger_data.contains(&trigger),
-                    "Expected trigger list to contain {:?}, but it only contains: {:?}",
-                    trigger,
-                    triggers.trigger_data
-                );
-            }
-        }
-    }
-
-    impl Block {
-        fn test_new() -> Block {
-            Block::test_with_event_types(vec![], vec![], vec![])
-        }
-
-        fn test_with_event_types(
-            begin_event_types: Vec<&str>,
-            tx_event_types: Vec<&str>,
-            end_event_types: Vec<&str>,
-        ) -> Block {
-            Block {
-                header: Some(Header {
-                    version: None,
-                    chain_id: "test".to_string(),
-                    height: 1,
-                    time: None,
-                    last_block_id: None,
-                    last_commit_hash: vec![],
-                    data_hash: vec![],
-                    validators_hash: vec![],
-                    next_validators_hash: vec![],
-                    consensus_hash: vec![],
-                    app_hash: vec![],
-                    last_results_hash: vec![],
-                    evidence_hash: vec![],
-                    proposer_address: vec![],
-                    hash: vec![],
-                }),
-                evidence: None,
-                last_commit: None,
-                result_begin_block: Some(ResponseBeginBlock {
-                    events: begin_event_types
-                        .into_iter()
-                        .map(Event::test_with_type)
-                        .collect(),
-                }),
-                result_end_block: Some(ResponseEndBlock {
-                    validator_updates: vec![],
-                    consensus_param_updates: None,
-                    events: end_event_types
-                        .into_iter()
-                        .map(Event::test_with_type)
-                        .collect(),
-                }),
-                transactions: tx_event_types
-                    .into_iter()
-                    .map(TxResult::test_with_event_type)
-                    .collect(),
-                validator_updates: vec![],
-            }
-        }
-    }
-
-    impl Event {
-        fn test_with_type(event_type: &str) -> Event {
-            Event {
-                event_type: event_type.to_string(),
-                attributes: vec![],
-            }
-        }
-    }
-
-    impl TxResult {
-        fn test_with_event_type(event_type: &str) -> TxResult {
-            TxResult {
-                height: 1,
-                index: 1,
-                tx: None,
-                result: Some(ResponseDeliverTx {
-                    code: 1,
-                    data: vec![],
-                    log: "".to_string(),
-                    info: "".to_string(),
-                    gas_wanted: 1,
-                    gas_used: 1,
-                    codespace: "".to_string(),
-                    events: vec![Event::test_with_type(event_type)],
-                }),
-                hash: vec![],
-            }
-        }
-    }
-}
diff --git a/chain/cosmos/src/codec.rs b/chain/cosmos/src/codec.rs
deleted file mode 100644
index bdc05c1b820..00000000000
--- a/chain/cosmos/src/codec.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-pub(crate) use crate::protobuf::pbcodec::*;
-
-use graph::blockchain::{Block as BlockchainBlock, BlockTime};
-use graph::{
-    blockchain::BlockPtr,
-    prelude::{anyhow::anyhow, BlockNumber, Error},
-};
-
-use std::convert::TryFrom;
-
-impl Block {
-    pub fn header(&self) -> Result<&Header, Error> {
-        self.header
-            .as_ref()
-            .ok_or_else(|| anyhow!("block data missing header field"))
-    }
-
-    pub fn begin_block_events(&self) -> Result<impl Iterator<Item = &Event>, Error> {
-        let events = self
-            .result_begin_block
-            .as_ref()
-            .ok_or_else(|| anyhow!("block data missing result_begin_block field"))?
-            .events
-            .iter();
-
-        Ok(events)
-    }
-
-    pub fn end_block_events(&self) -> Result<impl Iterator<Item = &Event>, Error> {
-        let events = self
-            .result_end_block
-            .as_ref()
-            .ok_or_else(|| anyhow!("block data missing result_end_block field"))?
-            .events
-            .iter();
-
-        Ok(events)
-    }
-
-    pub fn transactions(&self) -> impl Iterator<Item = &TxResult> {
-        self.transactions.iter()
-    }
-
-    pub fn parent_ptr(&self) -> Result<Option<BlockPtr>, Error> {
-        let header = self.header()?;
-
-        Ok(header
-            .last_block_id
-            .as_ref()
-            .map(|last_block_id| BlockPtr::from((last_block_id.hash.clone(), header.height - 1))))
-    }
-}
-
-impl TryFrom<Block> for BlockPtr {
-    type Error = Error;
-
-    fn try_from(b: Block) -> Result<BlockPtr, Error> {
-        BlockPtr::try_from(&b)
-    }
-}
-
-impl<'a> TryFrom<&'a Block> for BlockPtr {
-    type Error = Error;
-
-    fn try_from(b: &'a Block) -> Result<BlockPtr, Error> {
-        let header = b.header()?;
-        Ok(BlockPtr::from((header.hash.clone(), header.height)))
-    }
-}
-
-impl BlockchainBlock for Block {
-    fn number(&self) -> i32 {
-        BlockNumber::try_from(self.header().unwrap().height).unwrap()
-    }
-
-    fn ptr(&self) -> BlockPtr {
-        BlockPtr::try_from(self).unwrap()
-    }
-
-    fn parent_ptr(&self) -> Option<BlockPtr> {
-        self.parent_ptr().unwrap()
-    }
-
-    fn timestamp(&self) -> BlockTime {
-        let time = self.header().unwrap().time.as_ref().unwrap();
-        BlockTime::since_epoch(time.seconds, time.nanos as u32)
-    }
-}
-
-impl HeaderOnlyBlock {
-    pub fn header(&self) -> Result<&Header, Error> {
-        self.header
-            .as_ref()
-            .ok_or_else(|| anyhow!("block data missing header field"))
-    }
-
-    pub fn parent_ptr(&self) -> Result<Option<BlockPtr>, Error> {
-        let header = self.header()?;
-
-        Ok(header
-            .last_block_id
-            .as_ref()
-            .map(|last_block_id| BlockPtr::from((last_block_id.hash.clone(), header.height - 1))))
-    }
-}
-
-impl From<&Block> for HeaderOnlyBlock {
-    fn from(b: &Block) -> HeaderOnlyBlock {
-        HeaderOnlyBlock {
-            header: b.header.clone(),
-        }
-    }
-}
-
-impl TryFrom<HeaderOnlyBlock> for BlockPtr {
-    type Error = Error;
-
-    fn try_from(b: HeaderOnlyBlock) -> Result<BlockPtr, Error> {
-        BlockPtr::try_from(&b)
-    }
-}
-
-impl<'a> TryFrom<&'a HeaderOnlyBlock> for BlockPtr {
-    type Error = Error;
-
-    fn try_from(b: &'a HeaderOnlyBlock) -> Result<BlockPtr, Error> {
-        let header = b.header()?;
-
-        Ok(BlockPtr::from((header.hash.clone(), header.height)))
-    }
-}
-
-impl BlockchainBlock for HeaderOnlyBlock {
-    fn number(&self) -> i32 {
-        BlockNumber::try_from(self.header().unwrap().height).unwrap()
-    }
-
-    fn ptr(&self) -> BlockPtr {
-        BlockPtr::try_from(self).unwrap()
-    }
-
-    fn parent_ptr(&self) -> Option<BlockPtr> {
-        self.parent_ptr().unwrap()
-    }
-
-    fn timestamp(&self) -> BlockTime {
-        let time = self.header().unwrap().time.as_ref().unwrap();
-        BlockTime::since_epoch(time.seconds, time.nanos as u32)
-    }
-}
-
-impl EventData {
-    pub fn event(&self) -> Result<&Event, Error> {
-        self.event
-            .as_ref()
-            .ok_or_else(|| anyhow!("event data missing event field"))
-    }
-    pub fn block(&self) -> Result<&HeaderOnlyBlock, Error> {
-        self.block
-            .as_ref()
-            .ok_or_else(|| anyhow!("event data missing block field"))
-    }
-}
-
-impl TransactionData {
-    pub fn tx_result(&self) -> Result<&TxResult, Error> {
-        self.tx
-            .as_ref()
-            .ok_or_else(|| anyhow!("transaction data missing tx field"))
-    }
-
-    pub fn response_deliver_tx(&self) -> Result<&ResponseDeliverTx, Error> {
-        self.tx_result()?
-            .result
-            .as_ref()
-            .ok_or_else(|| anyhow!("transaction data missing result field"))
-    }
-
-    pub fn block(&self) -> Result<&HeaderOnlyBlock, Error> {
-        self.block
-            .as_ref()
-            .ok_or_else(|| anyhow!("transaction data missing block field"))
-    }
-}
-
-impl MessageData {
-    pub fn message(&self) -> Result<&prost_types::Any, Error> {
-        self.message
-            .as_ref()
-            .ok_or_else(|| anyhow!("message data missing message field"))
-    }
-
-    pub fn block(&self) -> Result<&HeaderOnlyBlock, Error> {
-        self.block
-            .as_ref()
-            .ok_or_else(|| anyhow!("message data missing block field"))
-    }
-}
diff --git a/chain/cosmos/src/data_source.rs b/chain/cosmos/src/data_source.rs
deleted file mode 100644
index f8827cefba3..00000000000
--- a/chain/cosmos/src/data_source.rs
+++ /dev/null
@@ -1,722 +0,0 @@
-use std::collections::{HashMap, HashSet};
-use std::sync::Arc;
-
-use anyhow::{Context, Error, Result};
-
-use graph::{
-    blockchain::{self, Block, Blockchain, TriggerWithHandler},
-    components::store::StoredDynamicDataSource,
-    data::subgraph::DataSourceContext,
-    prelude::{
-        anyhow, async_trait, BlockNumber, CheapClone, DataSourceTemplateInfo, Deserialize, Link,
-        LinkResolver, Logger,
-    },
-};
-
-use crate::chain::Chain;
-use crate::codec;
-use crate::trigger::CosmosTrigger;
-
-pub const COSMOS_KIND: &str = "cosmos";
-const BLOCK_HANDLER_KIND: &str = "block";
-const EVENT_HANDLER_KIND: &str = "event";
-const TRANSACTION_HANDLER_KIND: &str = "transaction";
-const MESSAGE_HANDLER_KIND: &str = "message";
-
-const DYNAMIC_DATA_SOURCE_ERROR: &str = "Cosmos subgraphs do not support dynamic data sources";
-const TEMPLATE_ERROR: &str = "Cosmos subgraphs do not support templates";
-
-/// Runtime representation of a data source.
-// Note: Not great for memory usage that this needs to be `Clone`, considering how there may be tens
-// of thousands of data sources in memory at once.
-#[derive(Clone, Debug)]
-pub struct DataSource {
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub source: Source,
-    pub mapping: Mapping,
-    pub context: Arc<Option<DataSourceContext>>,
-    pub creation_block: Option<BlockNumber>,
-}
-
-impl blockchain::DataSource<Chain> for DataSource {
-    fn from_template_info(_template_info: DataSourceTemplateInfo<Chain>) -> Result<Self, Error> {
-        Err(anyhow!(TEMPLATE_ERROR))
-    }
-
-    fn address(&self) -> Option<&[u8]> {
-        None
-    }
-
-    fn start_block(&self) -> BlockNumber {
-        self.source.start_block
-    }
-
-    fn handler_kinds(&self) -> HashSet<&str> {
-        let mut kinds = HashSet::new();
-
-        let Mapping {
-            block_handlers,
-            event_handlers,
-            transaction_handlers,
-            message_handlers,
-            ..
-        } = &self.mapping;
-
-        if !block_handlers.is_empty() {
-            kinds.insert(BLOCK_HANDLER_KIND);
-        }
-
-        if !event_handlers.is_empty() {
-            kinds.insert(EVENT_HANDLER_KIND);
-        }
-
-        if !transaction_handlers.is_empty() {
-            kinds.insert(TRANSACTION_HANDLER_KIND);
-        }
-
-        if !message_handlers.is_empty() {
-            kinds.insert(MESSAGE_HANDLER_KIND);
-        }
-
-        kinds
-    }
-
-    fn end_block(&self) -> Option<BlockNumber> {
-        self.source.end_block
-    }
-
-    fn match_and_decode(
-        &self,
-        trigger: &<Chain as Blockchain>::TriggerData,
-        block: &Arc<<Chain as Blockchain>::Block>,
-        _logger: &Logger,
-    ) -> Result<Option<TriggerWithHandler<Chain>>> {
-        if self.source.start_block > block.number() {
-            return Ok(None);
-        }
-
-        let handler = match trigger {
-            CosmosTrigger::Block(_) => match self.handler_for_block() {
-                Some(handler) => handler.handler,
-                None => return Ok(None),
-            },
-
-            CosmosTrigger::Event { event_data, origin } => {
-                match self.handler_for_event(event_data.event()?, *origin) {
-                    Some(handler) => handler.handler,
-                    None => return Ok(None),
-                }
-            }
-
-            CosmosTrigger::Transaction(_) => match self.handler_for_transaction() {
-                Some(handler) => handler.handler,
-                None => return Ok(None),
-            },
-
-            CosmosTrigger::Message(message_data) => {
-                match self.handler_for_message(message_data.message()?) {
-                    Some(handler) => handler.handler,
-                    None => return Ok(None),
-                }
-            }
-        };
-
-        Ok(Some(TriggerWithHandler::<Chain>::new(
-            trigger.cheap_clone(),
-            handler,
-            block.ptr(),
-            block.timestamp(),
-        )))
-    }
-
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn kind(&self) -> &str {
-        &self.kind
-    }
-
-    fn network(&self) -> Option<&str> {
-        self.network.as_deref()
-    }
-
-    fn context(&self) -> Arc<Option<DataSourceContext>> {
-        self.context.cheap_clone()
-    }
-
-    fn creation_block(&self) -> Option<BlockNumber> {
-        self.creation_block
-    }
-
-    fn is_duplicate_of(&self, other: &Self) -> bool {
-        let DataSource {
-            kind,
-            network,
-            name,
-            source,
-            mapping,
-            context,
-
-            // The creation block is ignored for detection duplicate data sources.
-            // Contract ABI equality is implicit in `source` and `mapping.abis` equality.
-            creation_block: _,
-        } = self;
-
-        // mapping_request_sender, host_metrics, and (most of) host_exports are operational structs
-        // used at runtime but not needed to define uniqueness; each runtime host should be for a
-        // unique data source.
-        kind == &other.kind
-            && network == &other.network
-            && name == &other.name
-            && source == &other.source
-            && mapping.block_handlers == other.mapping.block_handlers
-            && mapping.event_handlers == other.mapping.event_handlers
-            && mapping.transaction_handlers == other.mapping.transaction_handlers
-            && mapping.message_handlers == other.mapping.message_handlers
-            && context == &other.context
-    }
-
-    fn as_stored_dynamic_data_source(&self) -> StoredDynamicDataSource {
-        unimplemented!("{}", DYNAMIC_DATA_SOURCE_ERROR);
-    }
-
-    fn from_stored_dynamic_data_source(
-        _template: &DataSourceTemplate,
-        _stored: StoredDynamicDataSource,
-    ) -> Result<Self> {
-        Err(anyhow!(DYNAMIC_DATA_SOURCE_ERROR))
-    }
-
-    fn validate(&self) -> Vec<Error> {
-        let mut errors = Vec::new();
-
-        if self.kind != COSMOS_KIND {
-            errors.push(anyhow!(
-                "data source has invalid `kind`, expected {} but found {}",
-                COSMOS_KIND,
-                self.kind
-            ))
-        }
-
-        // Ensure there is only one block handler
-        if self.mapping.block_handlers.len() > 1 {
-            errors.push(anyhow!("data source has duplicated block handlers"));
-        }
-
-        // Ensure there is only one transaction handler
-        if self.mapping.transaction_handlers.len() > 1 {
-            errors.push(anyhow!("data source has duplicated transaction handlers"));
-        }
-
-        // Ensure that each event type + origin filter combination has only one handler
-
-        // group handler origin filters by event type
-        let mut event_types = HashMap::with_capacity(self.mapping.event_handlers.len());
-        for event_handler in self.mapping.event_handlers.iter() {
-            let origins = event_types
-                .entry(&event_handler.event)
-                // 3 is the maximum number of valid handlers for an event type (1 for each origin)
-                .or_insert(HashSet::with_capacity(3));
-
-            // insert returns false if value was already in the set
-            if !origins.insert(event_handler.origin) {
-                errors.push(multiple_origin_err(
-                    &event_handler.event,
-                    event_handler.origin,
-                ))
-            }
-        }
-
-        // Ensure each event type either has:
-        // 1 handler with no origin filter
-        // OR
-        // 1 or more handlers with origin filter
-        for (event_type, origins) in event_types.iter() {
-            if origins.len() > 1 && !origins.iter().all(Option::is_some) {
-                errors.push(combined_origins_err(event_type))
-            }
-        }
-
-        // Ensure each message handlers is unique
-        let mut message_type_urls = HashSet::with_capacity(self.mapping.message_handlers.len());
-        for message_handler in self.mapping.message_handlers.iter() {
-            if !message_type_urls.insert(message_handler.message.clone()) {
-                errors.push(duplicate_url_type(&message_handler.message))
-            }
-        }
-
-        errors
-    }
-
-    fn api_version(&self) -> semver::Version {
-        self.mapping.api_version.clone()
-    }
-
-    fn runtime(&self) -> Option<Arc<Vec<u8>>> {
-        Some(self.mapping.runtime.cheap_clone())
-    }
-}
-
-impl DataSource {
-    fn from_manifest(
-        kind: String,
-        network: Option<String>,
-        name: String,
-        source: Source,
-        mapping: Mapping,
-        context: Option<DataSourceContext>,
-    ) -> Result<Self> {
-        // Data sources in the manifest are created "before genesis" so they have no creation block.
-        let creation_block = None;
-
-        Ok(DataSource {
-            kind,
-            network,
-            name,
-            source,
-            mapping,
-            context: Arc::new(context),
-            creation_block,
-        })
-    }
-
-    fn handler_for_block(&self) -> Option<MappingBlockHandler> {
-        self.mapping.block_handlers.first().cloned()
-    }
-
-    fn handler_for_transaction(&self) -> Option<MappingTransactionHandler> {
-        self.mapping.transaction_handlers.first().cloned()
-    }
-
-    fn handler_for_message(&self, message: &::prost_types::Any) -> Option<MappingMessageHandler> {
-        self.mapping
-            .message_handlers
-            .iter()
-            .find(|handler| handler.message == message.type_url)
-            .cloned()
-    }
-
-    fn handler_for_event(
-        &self,
-        event: &codec::Event,
-        event_origin: EventOrigin,
-    ) -> Option<MappingEventHandler> {
-        self.mapping
-            .event_handlers
-            .iter()
-            .find(|handler| {
-                let event_type_matches = event.event_type == handler.event;
-
-                if let Some(handler_origin) = handler.origin {
-                    event_type_matches && event_origin == handler_origin
-                } else {
-                    event_type_matches
-                }
-            })
-            .cloned()
-    }
-
-    pub(crate) fn has_block_handler(&self) -> bool {
-        !self.mapping.block_handlers.is_empty()
-    }
-
-    /// Return an iterator over all event types from event handlers.
-    pub(crate) fn events(&self) -> impl Iterator<Item = &str> {
-        self.mapping
-            .event_handlers
-            .iter()
-            .map(|handler| handler.event.as_str())
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
-pub struct UnresolvedDataSource {
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub source: Source,
-    pub mapping: UnresolvedMapping,
-    pub context: Option<DataSourceContext>,
-}
-
-#[async_trait]
-impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
-    async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-        _manifest_idx: u32,
-    ) -> Result<DataSource> {
-        let UnresolvedDataSource {
-            kind,
-            network,
-            name,
-            source,
-            mapping,
-            context,
-        } = self;
-
-        let mapping = mapping.resolve(resolver, logger).await.with_context(|| {
-            format!(
-                "failed to resolve data source {} with source {}",
-                name, source.start_block
-            )
-        })?;
-
-        DataSource::from_manifest(kind, network, name, source, mapping, context)
-    }
-}
-
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
-pub struct BaseDataSourceTemplate<M> {
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub mapping: M,
-}
-
-pub type UnresolvedDataSourceTemplate = BaseDataSourceTemplate<UnresolvedMapping>;
-pub type DataSourceTemplate = BaseDataSourceTemplate<Mapping>;
-
-#[async_trait]
-impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTemplate {
-    async fn resolve(
-        self,
-        _resolver: &Arc<dyn LinkResolver>,
-        _logger: &Logger,
-        _manifest_idx: u32,
-    ) -> Result<DataSourceTemplate> {
-        Err(anyhow!(TEMPLATE_ERROR))
-    }
-}
-
-impl blockchain::DataSourceTemplate<Chain> for DataSourceTemplate {
-    fn name(&self) -> &str {
-        unimplemented!("{}", TEMPLATE_ERROR);
-    }
-
-    fn api_version(&self) -> semver::Version {
-        unimplemented!("{}", TEMPLATE_ERROR);
-    }
-
-    fn runtime(&self) -> Option<Arc<Vec<u8>>> {
-        unimplemented!("{}", TEMPLATE_ERROR);
-    }
-
-    fn manifest_idx(&self) -> u32 {
-        unimplemented!("{}", TEMPLATE_ERROR);
-    }
-
-    fn kind(&self) -> &str {
-        &self.kind
-    }
-}
-
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct UnresolvedMapping {
-    pub api_version: String,
-    pub language: String,
-    pub entities: Vec<String>,
-    #[serde(default)]
-    pub block_handlers: Vec<MappingBlockHandler>,
-    #[serde(default)]
-    pub event_handlers: Vec<MappingEventHandler>,
-    #[serde(default)]
-    pub transaction_handlers: Vec<MappingTransactionHandler>,
-    #[serde(default)]
-    pub message_handlers: Vec<MappingMessageHandler>,
-    pub file: Link,
-}
-
-impl UnresolvedMapping {
-    pub async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-    ) -> Result<Mapping> {
-        let UnresolvedMapping {
-            api_version,
-            language,
-            entities,
-            block_handlers,
-            event_handlers,
-            transaction_handlers,
-            message_handlers,
-            file: link,
-        } = self;
-
-        let api_version = semver::Version::parse(&api_version)?;
-
-        let module_bytes = resolver
-            .cat(logger, &link)
-            .await
-            .with_context(|| format!("failed to resolve mapping {}", link.link))?;
-
-        Ok(Mapping {
-            api_version,
-            language,
-            entities,
-            block_handlers: block_handlers.clone(),
-            event_handlers: event_handlers.clone(),
-            transaction_handlers: transaction_handlers.clone(),
-            message_handlers: message_handlers.clone(),
-            runtime: Arc::new(module_bytes),
-            link,
-        })
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Mapping {
-    pub api_version: semver::Version,
-    pub language: String,
-    pub entities: Vec<String>,
-    pub block_handlers: Vec<MappingBlockHandler>,
-    pub event_handlers: Vec<MappingEventHandler>,
-    pub transaction_handlers: Vec<MappingTransactionHandler>,
-    pub message_handlers: Vec<MappingMessageHandler>,
-    pub runtime: Arc<Vec<u8>>,
-    pub link: Link,
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
-pub struct MappingBlockHandler {
-    pub handler: String,
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
-pub struct MappingEventHandler {
-    pub event: String,
-    pub origin: Option<EventOrigin>,
-    pub handler: String,
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
-pub struct MappingTransactionHandler {
-    pub handler: String,
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
-pub struct MappingMessageHandler {
-    pub message: String,
-    pub handler: String,
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Source {
-    #[serde(default)]
-    pub start_block: BlockNumber,
-    pub(crate) end_block: Option<BlockNumber>,
-}
-
-#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Deserialize)]
-pub enum EventOrigin {
-    BeginBlock,
-    DeliverTx,
-    EndBlock,
-}
-
-fn multiple_origin_err(event_type: &str, origin: Option<EventOrigin>) -> Error {
-    let origin_err_name = match origin {
-        Some(origin) => format!("{:?}", origin),
-        None => "no".to_string(),
-    };
-
-    anyhow!(
-        "data source has multiple {} event handlers with {} origin",
-        event_type,
-        origin_err_name,
-    )
-}
-
-fn combined_origins_err(event_type: &str) -> Error {
-    anyhow!(
-        "data source has combined origin and no-origin {} event handlers",
-        event_type
-    )
-}
-
-fn duplicate_url_type(message: &str) -> Error {
-    anyhow!(
-        "data source has more than one message handler for message {} ",
-        message
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use graph::blockchain::DataSource as _;
-
-    #[test]
-    fn test_event_handlers_origin_validation() {
-        let cases = [
-            (
-                DataSource::with_event_handlers(vec![
-                    MappingEventHandler::with_origin("event_1", None),
-                    MappingEventHandler::with_origin("event_2", None),
-                    MappingEventHandler::with_origin("event_3", None),
-                ]),
-                vec![],
-            ),
-            (
-                DataSource::with_event_handlers(vec![
-                    MappingEventHandler::with_origin("event_1", Some(EventOrigin::BeginBlock)),
-                    MappingEventHandler::with_origin("event_2", Some(EventOrigin::BeginBlock)),
-                    MappingEventHandler::with_origin("event_1", Some(EventOrigin::DeliverTx)),
-                    MappingEventHandler::with_origin("event_1", Some(EventOrigin::EndBlock)),
-                    MappingEventHandler::with_origin("event_2", Some(EventOrigin::DeliverTx)),
-                    MappingEventHandler::with_origin("event_2", Some(EventOrigin::EndBlock)),
-                ]),
-                vec![],
-            ),
-            (
-                DataSource::with_event_handlers(vec![
-                    MappingEventHandler::with_origin("event_1", None),
-                    MappingEventHandler::with_origin("event_1", None),
-                    MappingEventHandler::with_origin("event_2", None),
-                    MappingEventHandler::with_origin("event_2", Some(EventOrigin::BeginBlock)),
-                    MappingEventHandler::with_origin("event_3", Some(EventOrigin::EndBlock)),
-                    MappingEventHandler::with_origin("event_3", Some(EventOrigin::EndBlock)),
-                ]),
-                vec![
-                    multiple_origin_err("event_1", None),
-                    combined_origins_err("event_2"),
-                    multiple_origin_err("event_3", Some(EventOrigin::EndBlock)),
-                ],
-            ),
-        ];
-
-        for (data_source, errors) in &cases {
-            let validation_errors = data_source.validate();
-
-            assert_eq!(errors.len(), validation_errors.len());
-
-            for error in errors.iter() {
-                assert!(
-                    validation_errors
-                        .iter()
-                        .any(|validation_error| validation_error.to_string() == error.to_string()),
-                    r#"expected "{}" to be in validation errors, but it wasn't"#,
-                    error
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn test_message_handlers_duplicate() {
-        let cases = [
-            (
-                DataSource::with_message_handlers(vec![
-                    MappingMessageHandler {
-                        handler: "handler".to_string(),
-                        message: "message_0".to_string(),
-                    },
-                    MappingMessageHandler {
-                        handler: "handler".to_string(),
-                        message: "message_1".to_string(),
-                    },
-                ]),
-                vec![],
-            ),
-            (
-                DataSource::with_message_handlers(vec![
-                    MappingMessageHandler {
-                        handler: "handler".to_string(),
-                        message: "message_0".to_string(),
-                    },
-                    MappingMessageHandler {
-                        handler: "handler".to_string(),
-                        message: "message_0".to_string(),
-                    },
-                ]),
-                vec![duplicate_url_type("message_0")],
-            ),
-        ];
-
-        for (data_source, errors) in &cases {
-            let validation_errors = data_source.validate();
-
-            assert_eq!(errors.len(), validation_errors.len());
-
-            for error in errors.iter() {
-                assert!(
-                    validation_errors
-                        .iter()
-                        .any(|validation_error| validation_error.to_string() == error.to_string()),
-                    r#"expected "{}" to be in validation errors, but it wasn't"#,
-                    error
-                );
-            }
-        }
-    }
-
-    impl DataSource {
-        fn with_event_handlers(event_handlers: Vec<MappingEventHandler>) -> DataSource {
-            DataSource {
-                kind: "cosmos".to_string(),
-                network: None,
-                name: "Test".to_string(),
-                source: Source {
-                    start_block: 1,
-                    end_block: None,
-                },
-                mapping: Mapping {
-                    api_version: semver::Version::new(0, 0, 0),
-                    language: "".to_string(),
-                    entities: vec![],
-                    block_handlers: vec![],
-                    event_handlers,
-                    transaction_handlers: vec![],
-                    message_handlers: vec![],
-                    runtime: Arc::new(vec![]),
-                    link: "test".to_string().into(),
-                },
-                context: Arc::new(None),
-                creation_block: None,
-            }
-        }
-
-        fn with_message_handlers(message_handlers: Vec<MappingMessageHandler>) -> DataSource {
-            DataSource {
-                kind: "cosmos".to_string(),
-                network: None,
-                name: "Test".to_string(),
-                source: Source {
-                    start_block: 1,
-                    end_block: None,
-                },
-                mapping: Mapping {
-                    api_version: semver::Version::new(0, 0, 0),
-                    language: "".to_string(),
-                    entities: vec![],
-                    block_handlers: vec![],
-                    event_handlers: vec![],
-                    transaction_handlers: vec![],
-                    message_handlers,
-                    runtime: Arc::new(vec![]),
-                    link: "test".to_string().into(),
-                },
-                context: Arc::new(None),
-                creation_block: None,
-            }
-        }
-    }
-
-    impl MappingEventHandler {
-        fn with_origin(event_type: &str, origin: Option<EventOrigin>) -> MappingEventHandler {
-            MappingEventHandler {
-                event: event_type.to_string(),
-                origin,
-                handler: "handler".to_string(),
-            }
-        }
-    }
-}
diff --git a/chain/cosmos/src/lib.rs b/chain/cosmos/src/lib.rs
deleted file mode 100644
index 5d0bf16d050..00000000000
--- a/chain/cosmos/src/lib.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-mod adapter;
-pub mod chain;
-pub mod codec;
-mod data_source;
-mod protobuf;
-pub mod runtime;
-mod trigger;
-
-// ETHDEP: These concrete types should probably not be exposed.
-pub use data_source::{DataSource, DataSourceTemplate};
-
-pub use crate::adapter::TriggerFilter;
-pub use crate::chain::Chain;
-
-pub use protobuf::pbcodec;
-pub use protobuf::pbcodec::Block;
diff --git a/chain/cosmos/src/protobuf/.gitignore b/chain/cosmos/src/protobuf/.gitignore
deleted file mode 100644
index 96786948080..00000000000
--- a/chain/cosmos/src/protobuf/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-/google.protobuf.rs
-/gogoproto.rs
-/cosmos_proto.rs
-/firehose.rs
diff --git a/chain/cosmos/src/protobuf/mod.rs b/chain/cosmos/src/protobuf/mod.rs
deleted file mode 100644
index c3292e66c4b..00000000000
--- a/chain/cosmos/src/protobuf/mod.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#[rustfmt::skip]
-#[path = "sf.cosmos.r#type.v1.rs"]
-pub mod pbcodec;
-
-pub use graph_runtime_wasm::asc_abi::class::{Array, AscEnum, AscString, Uint8Array};
-
-pub use crate::runtime::abi::*;
-pub use pbcodec::*;
diff --git a/chain/cosmos/src/protobuf/sf.cosmos.r#type.v1.rs b/chain/cosmos/src/protobuf/sf.cosmos.r#type.v1.rs
deleted file mode 100644
index d60de8086b1..00000000000
--- a/chain/cosmos/src/protobuf/sf.cosmos.r#type.v1.rs
+++ /dev/null
@@ -1,838 +0,0 @@
-#[graph_runtime_derive::generate_asc_type(
-    __required__{header:Header,
-    result_begin_block:ResponseBeginBlock,
-    result_end_block:ResponseEndBlock}
-)]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(
-    __required__{header:Header,
-    result_begin_block:ResponseBeginBlock,
-    result_end_block:ResponseEndBlock}
-)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Block {
-    #[prost(message, optional, tag = "1")]
-    pub header: ::core::option::Option<Header>,
-    #[prost(message, optional, tag = "2")]
-    pub evidence: ::core::option::Option<EvidenceList>,
-    #[prost(message, optional, tag = "3")]
-    pub last_commit: ::core::option::Option<Commit>,
-    #[prost(message, optional, tag = "4")]
-    pub result_begin_block: ::core::option::Option<ResponseBeginBlock>,
-    #[prost(message, optional, tag = "5")]
-    pub result_end_block: ::core::option::Option<ResponseEndBlock>,
-    #[prost(message, repeated, tag = "7")]
-    pub transactions: ::prost::alloc::vec::Vec<TxResult>,
-    #[prost(message, repeated, tag = "8")]
-    pub validator_updates: ::prost::alloc::vec::Vec<Validator>,
-}
-/// HeaderOnlyBlock is a standard \[Block\] structure where all other fields are
-/// removed so that hydrating that object from a \[Block\] bytes payload will
-/// drastically reduce allocated memory required to hold the full block.
-///
-/// This can be used to unpack a \[Block\] when only the \[Header\] information
-/// is required and greatly reduce required memory.
-#[graph_runtime_derive::generate_asc_type(__required__{header:Header})]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(__required__{header:Header})]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct HeaderOnlyBlock {
-    #[prost(message, optional, tag = "1")]
-    pub header: ::core::option::Option<Header>,
-}
-#[graph_runtime_derive::generate_asc_type(
-    __required__{event:Event,
-    block:HeaderOnlyBlock}
-)]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(
-    __required__{event:Event,
-    block:HeaderOnlyBlock}
-)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EventData {
-    #[prost(message, optional, tag = "1")]
-    pub event: ::core::option::Option<Event>,
-    #[prost(message, optional, tag = "2")]
-    pub block: ::core::option::Option<HeaderOnlyBlock>,
-    #[prost(message, optional, tag = "3")]
-    pub tx: ::core::option::Option<TransactionContext>,
-}
-#[graph_runtime_derive::generate_asc_type(
-    __required__{tx:TxResult,
-    block:HeaderOnlyBlock}
-)]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(
-    __required__{tx:TxResult,
-    block:HeaderOnlyBlock}
-)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TransactionData {
-    #[prost(message, optional, tag = "1")]
-    pub tx: ::core::option::Option<TxResult>,
-    #[prost(message, optional, tag = "2")]
-    pub block: ::core::option::Option<HeaderOnlyBlock>,
-}
-#[graph_runtime_derive::generate_asc_type(
-    __required__{message:Any,
-    block:HeaderOnlyBlock,
-    tx:TransactionContext}
-)]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(
-    __required__{message:Any,
-    block:HeaderOnlyBlock,
-    tx:TransactionContext}
-)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MessageData {
-    #[prost(message, optional, tag = "1")]
-    pub message: ::core::option::Option<::prost_types::Any>,
-    #[prost(message, optional, tag = "2")]
-    pub block: ::core::option::Option<HeaderOnlyBlock>,
-    #[prost(message, optional, tag = "3")]
-    pub tx: ::core::option::Option<TransactionContext>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TransactionContext {
-    #[prost(bytes = "vec", tag = "1")]
-    pub hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(uint32, tag = "2")]
-    pub index: u32,
-    #[prost(uint32, tag = "3")]
-    pub code: u32,
-    #[prost(int64, tag = "4")]
-    pub gas_wanted: i64,
-    #[prost(int64, tag = "5")]
-    pub gas_used: i64,
-}
-#[graph_runtime_derive::generate_asc_type(__required__{last_block_id:BlockID})]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(__required__{last_block_id:BlockID})]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Header {
-    #[prost(message, optional, tag = "1")]
-    pub version: ::core::option::Option<Consensus>,
-    #[prost(string, tag = "2")]
-    pub chain_id: ::prost::alloc::string::String,
-    #[prost(uint64, tag = "3")]
-    pub height: u64,
-    #[prost(message, optional, tag = "4")]
-    pub time: ::core::option::Option<Timestamp>,
-    #[prost(message, optional, tag = "5")]
-    pub last_block_id: ::core::option::Option<BlockId>,
-    #[prost(bytes = "vec", tag = "6")]
-    pub last_commit_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "7")]
-    pub data_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "8")]
-    pub validators_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "9")]
-    pub next_validators_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "10")]
-    pub consensus_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "11")]
-    pub app_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "12")]
-    pub last_results_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "13")]
-    pub evidence_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "14")]
-    pub proposer_address: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "15")]
-    pub hash: ::prost::alloc::vec::Vec<u8>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Consensus {
-    #[prost(uint64, tag = "1")]
-    pub block: u64,
-    #[prost(uint64, tag = "2")]
-    pub app: u64,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Timestamp {
-    #[prost(int64, tag = "1")]
-    pub seconds: i64,
-    #[prost(int32, tag = "2")]
-    pub nanos: i32,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockId {
-    #[prost(bytes = "vec", tag = "1")]
-    pub hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "2")]
-    pub part_set_header: ::core::option::Option<PartSetHeader>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PartSetHeader {
-    #[prost(uint32, tag = "1")]
-    pub total: u32,
-    #[prost(bytes = "vec", tag = "2")]
-    pub hash: ::prost::alloc::vec::Vec<u8>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EvidenceList {
-    #[prost(message, repeated, tag = "1")]
-    pub evidence: ::prost::alloc::vec::Vec<Evidence>,
-}
-#[graph_runtime_derive::generate_asc_type(
-    sum{duplicate_vote_evidence:DuplicateVoteEvidence,
-    light_client_attack_evidence:LightClientAttackEvidence}
-)]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(
-    sum{duplicate_vote_evidence:DuplicateVoteEvidence,
-    light_client_attack_evidence:LightClientAttackEvidence}
-)]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Evidence {
-    #[prost(oneof = "evidence::Sum", tags = "1, 2")]
-    pub sum: ::core::option::Option<evidence::Sum>,
-}
-/// Nested message and enum types in `Evidence`.
-pub mod evidence {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Sum {
-        #[prost(message, tag = "1")]
-        DuplicateVoteEvidence(super::DuplicateVoteEvidence),
-        #[prost(message, tag = "2")]
-        LightClientAttackEvidence(super::LightClientAttackEvidence),
-    }
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DuplicateVoteEvidence {
-    #[prost(message, optional, tag = "1")]
-    pub vote_a: ::core::option::Option<EventVote>,
-    #[prost(message, optional, tag = "2")]
-    pub vote_b: ::core::option::Option<EventVote>,
-    #[prost(int64, tag = "3")]
-    pub total_voting_power: i64,
-    #[prost(int64, tag = "4")]
-    pub validator_power: i64,
-    #[prost(message, optional, tag = "5")]
-    pub timestamp: ::core::option::Option<Timestamp>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EventVote {
-    #[prost(enumeration = "SignedMsgType", tag = "1")]
-    pub event_vote_type: i32,
-    #[prost(uint64, tag = "2")]
-    pub height: u64,
-    #[prost(int32, tag = "3")]
-    pub round: i32,
-    #[prost(message, optional, tag = "4")]
-    pub block_id: ::core::option::Option<BlockId>,
-    #[prost(message, optional, tag = "5")]
-    pub timestamp: ::core::option::Option<Timestamp>,
-    #[prost(bytes = "vec", tag = "6")]
-    pub validator_address: ::prost::alloc::vec::Vec<u8>,
-    #[prost(int32, tag = "7")]
-    pub validator_index: i32,
-    #[prost(bytes = "vec", tag = "8")]
-    pub signature: ::prost::alloc::vec::Vec<u8>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LightClientAttackEvidence {
-    #[prost(message, optional, tag = "1")]
-    pub conflicting_block: ::core::option::Option<LightBlock>,
-    #[prost(int64, tag = "2")]
-    pub common_height: i64,
-    #[prost(message, repeated, tag = "3")]
-    pub byzantine_validators: ::prost::alloc::vec::Vec<Validator>,
-    #[prost(int64, tag = "4")]
-    pub total_voting_power: i64,
-    #[prost(message, optional, tag = "5")]
-    pub timestamp: ::core::option::Option<Timestamp>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LightBlock {
-    #[prost(message, optional, tag = "1")]
-    pub signed_header: ::core::option::Option<SignedHeader>,
-    #[prost(message, optional, tag = "2")]
-    pub validator_set: ::core::option::Option<ValidatorSet>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SignedHeader {
-    #[prost(message, optional, tag = "1")]
-    pub header: ::core::option::Option<Header>,
-    #[prost(message, optional, tag = "2")]
-    pub commit: ::core::option::Option<Commit>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Commit {
-    #[prost(int64, tag = "1")]
-    pub height: i64,
-    #[prost(int32, tag = "2")]
-    pub round: i32,
-    #[prost(message, optional, tag = "3")]
-    pub block_id: ::core::option::Option<BlockId>,
-    #[prost(message, repeated, tag = "4")]
-    pub signatures: ::prost::alloc::vec::Vec<CommitSig>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CommitSig {
-    #[prost(enumeration = "BlockIdFlag", tag = "1")]
-    pub block_id_flag: i32,
-    #[prost(bytes = "vec", tag = "2")]
-    pub validator_address: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "3")]
-    pub timestamp: ::core::option::Option<Timestamp>,
-    #[prost(bytes = "vec", tag = "4")]
-    pub signature: ::prost::alloc::vec::Vec<u8>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ValidatorSet {
-    #[prost(message, repeated, tag = "1")]
-    pub validators: ::prost::alloc::vec::Vec<Validator>,
-    #[prost(message, optional, tag = "2")]
-    pub proposer: ::core::option::Option<Validator>,
-    #[prost(int64, tag = "3")]
-    pub total_voting_power: i64,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Validator {
-    #[prost(bytes = "vec", tag = "1")]
-    pub address: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "2")]
-    pub pub_key: ::core::option::Option<PublicKey>,
-    #[prost(int64, tag = "3")]
-    pub voting_power: i64,
-    #[prost(int64, tag = "4")]
-    pub proposer_priority: i64,
-}
-#[graph_runtime_derive::generate_asc_type(sum{ed25519:Vec<u8>, secp256k1:Vec<u8>})]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(sum{ed25519:Vec<u8>, secp256k1:Vec<u8>})]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PublicKey {
-    #[prost(oneof = "public_key::Sum", tags = "1, 2")]
-    pub sum: ::core::option::Option<public_key::Sum>,
-}
-/// Nested message and enum types in `PublicKey`.
-pub mod public_key {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Sum {
-        #[prost(bytes, tag = "1")]
-        Ed25519(::prost::alloc::vec::Vec<u8>),
-        #[prost(bytes, tag = "2")]
-        Secp256k1(::prost::alloc::vec::Vec<u8>),
-    }
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ResponseBeginBlock {
-    #[prost(message, repeated, tag = "1")]
-    pub events: ::prost::alloc::vec::Vec<Event>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Event {
-    #[prost(string, tag = "1")]
-    pub event_type: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "2")]
-    pub attributes: ::prost::alloc::vec::Vec<EventAttribute>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EventAttribute {
-    #[prost(string, tag = "1")]
-    pub key: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub value: ::prost::alloc::string::String,
-    #[prost(bool, tag = "3")]
-    pub index: bool,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ResponseEndBlock {
-    #[prost(message, repeated, tag = "1")]
-    pub validator_updates: ::prost::alloc::vec::Vec<ValidatorUpdate>,
-    #[prost(message, optional, tag = "2")]
-    pub consensus_param_updates: ::core::option::Option<ConsensusParams>,
-    #[prost(message, repeated, tag = "3")]
-    pub events: ::prost::alloc::vec::Vec<Event>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ValidatorUpdate {
-    #[prost(bytes = "vec", tag = "1")]
-    pub address: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "2")]
-    pub pub_key: ::core::option::Option<PublicKey>,
-    #[prost(int64, tag = "3")]
-    pub power: i64,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ConsensusParams {
-    #[prost(message, optional, tag = "1")]
-    pub block: ::core::option::Option<BlockParams>,
-    #[prost(message, optional, tag = "2")]
-    pub evidence: ::core::option::Option<EvidenceParams>,
-    #[prost(message, optional, tag = "3")]
-    pub validator: ::core::option::Option<ValidatorParams>,
-    #[prost(message, optional, tag = "4")]
-    pub version: ::core::option::Option<VersionParams>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockParams {
-    #[prost(int64, tag = "1")]
-    pub max_bytes: i64,
-    #[prost(int64, tag = "2")]
-    pub max_gas: i64,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EvidenceParams {
-    #[prost(int64, tag = "1")]
-    pub max_age_num_blocks: i64,
-    #[prost(message, optional, tag = "2")]
-    pub max_age_duration: ::core::option::Option<Duration>,
-    #[prost(int64, tag = "3")]
-    pub max_bytes: i64,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Duration {
-    #[prost(int64, tag = "1")]
-    pub seconds: i64,
-    #[prost(int32, tag = "2")]
-    pub nanos: i32,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ValidatorParams {
-    #[prost(string, repeated, tag = "1")]
-    pub pub_key_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct VersionParams {
-    #[prost(uint64, tag = "1")]
-    pub app_version: u64,
-}
-#[graph_runtime_derive::generate_asc_type(__required__{tx:Tx, result:ResponseDeliverTx})]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(
-    __required__{tx:Tx,
-    result:ResponseDeliverTx}
-)]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TxResult {
-    #[prost(uint64, tag = "1")]
-    pub height: u64,
-    #[prost(uint32, tag = "2")]
-    pub index: u32,
-    #[prost(message, optional, tag = "3")]
-    pub tx: ::core::option::Option<Tx>,
-    #[prost(message, optional, tag = "4")]
-    pub result: ::core::option::Option<ResponseDeliverTx>,
-    #[prost(bytes = "vec", tag = "5")]
-    pub hash: ::prost::alloc::vec::Vec<u8>,
-}
-#[graph_runtime_derive::generate_asc_type(__required__{body:TxBody})]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(__required__{body:TxBody})]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Tx {
-    #[prost(message, optional, tag = "1")]
-    pub body: ::core::option::Option<TxBody>,
-    #[prost(message, optional, tag = "2")]
-    pub auth_info: ::core::option::Option<AuthInfo>,
-    #[prost(bytes = "vec", repeated, tag = "3")]
-    pub signatures: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TxBody {
-    #[prost(message, repeated, tag = "1")]
-    pub messages: ::prost::alloc::vec::Vec<::prost_types::Any>,
-    #[prost(string, tag = "2")]
-    pub memo: ::prost::alloc::string::String,
-    #[prost(uint64, tag = "3")]
-    pub timeout_height: u64,
-    #[prost(message, repeated, tag = "1023")]
-    pub extension_options: ::prost::alloc::vec::Vec<::prost_types::Any>,
-    #[prost(message, repeated, tag = "2047")]
-    pub non_critical_extension_options: ::prost::alloc::vec::Vec<::prost_types::Any>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Any {
-    #[prost(string, tag = "1")]
-    pub type_url: ::prost::alloc::string::String,
-    #[prost(bytes = "vec", tag = "2")]
-    pub value: ::prost::alloc::vec::Vec<u8>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AuthInfo {
-    #[prost(message, repeated, tag = "1")]
-    pub signer_infos: ::prost::alloc::vec::Vec<SignerInfo>,
-    #[prost(message, optional, tag = "2")]
-    pub fee: ::core::option::Option<Fee>,
-    #[prost(message, optional, tag = "3")]
-    pub tip: ::core::option::Option<Tip>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SignerInfo {
-    #[prost(message, optional, tag = "1")]
-    pub public_key: ::core::option::Option<::prost_types::Any>,
-    #[prost(message, optional, tag = "2")]
-    pub mode_info: ::core::option::Option<ModeInfo>,
-    #[prost(uint64, tag = "3")]
-    pub sequence: u64,
-}
-#[graph_runtime_derive::generate_asc_type(
-    sum{single:ModeInfoSingle,
-    multi:ModeInfoMulti}
-)]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type(
-    sum{single:ModeInfoSingle,
-    multi:ModeInfoMulti}
-)]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ModeInfo {
-    #[prost(oneof = "mode_info::Sum", tags = "1, 2")]
-    pub sum: ::core::option::Option<mode_info::Sum>,
-}
-/// Nested message and enum types in `ModeInfo`.
-pub mod mode_info {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Sum {
-        #[prost(message, tag = "1")]
-        Single(super::ModeInfoSingle),
-        #[prost(message, tag = "2")]
-        Multi(super::ModeInfoMulti),
-    }
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ModeInfoSingle {
-    #[prost(enumeration = "SignMode", tag = "1")]
-    pub mode: i32,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ModeInfoMulti {
-    #[prost(message, optional, tag = "1")]
-    pub bitarray: ::core::option::Option<CompactBitArray>,
-    #[prost(message, repeated, tag = "2")]
-    pub mode_infos: ::prost::alloc::vec::Vec<ModeInfo>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CompactBitArray {
-    #[prost(uint32, tag = "1")]
-    pub extra_bits_stored: u32,
-    #[prost(bytes = "vec", tag = "2")]
-    pub elems: ::prost::alloc::vec::Vec<u8>,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Fee {
-    #[prost(message, repeated, tag = "1")]
-    pub amount: ::prost::alloc::vec::Vec<Coin>,
-    #[prost(uint64, tag = "2")]
-    pub gas_limit: u64,
-    #[prost(string, tag = "3")]
-    pub payer: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub granter: ::prost::alloc::string::String,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[graph_runtime_derive::generate_array_type(Cosmos)]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Coin {
-    #[prost(string, tag = "1")]
-    pub denom: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub amount: ::prost::alloc::string::String,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Tip {
-    #[prost(message, repeated, tag = "1")]
-    pub amount: ::prost::alloc::vec::Vec<Coin>,
-    #[prost(string, tag = "2")]
-    pub tipper: ::prost::alloc::string::String,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ResponseDeliverTx {
-    #[prost(uint32, tag = "1")]
-    pub code: u32,
-    #[prost(bytes = "vec", tag = "2")]
-    pub data: ::prost::alloc::vec::Vec<u8>,
-    #[prost(string, tag = "3")]
-    pub log: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub info: ::prost::alloc::string::String,
-    #[prost(int64, tag = "5")]
-    pub gas_wanted: i64,
-    #[prost(int64, tag = "6")]
-    pub gas_used: i64,
-    #[prost(message, repeated, tag = "7")]
-    pub events: ::prost::alloc::vec::Vec<Event>,
-    #[prost(string, tag = "8")]
-    pub codespace: ::prost::alloc::string::String,
-}
-#[graph_runtime_derive::generate_asc_type()]
-#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-#[graph_runtime_derive::generate_from_rust_type()]
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ValidatorSetUpdates {
-    #[prost(message, repeated, tag = "1")]
-    pub validator_updates: ::prost::alloc::vec::Vec<Validator>,
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum SignedMsgType {
-    Unknown = 0,
-    Prevote = 1,
-    Precommit = 2,
-    Proposal = 32,
-}
-impl SignedMsgType {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            SignedMsgType::Unknown => "SIGNED_MSG_TYPE_UNKNOWN",
-            SignedMsgType::Prevote => "SIGNED_MSG_TYPE_PREVOTE",
-            SignedMsgType::Precommit => "SIGNED_MSG_TYPE_PRECOMMIT",
-            SignedMsgType::Proposal => "SIGNED_MSG_TYPE_PROPOSAL",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "SIGNED_MSG_TYPE_UNKNOWN" => Some(Self::Unknown),
-            "SIGNED_MSG_TYPE_PREVOTE" => Some(Self::Prevote),
-            "SIGNED_MSG_TYPE_PRECOMMIT" => Some(Self::Precommit),
-            "SIGNED_MSG_TYPE_PROPOSAL" => Some(Self::Proposal),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum BlockIdFlag {
-    Unknown = 0,
-    Absent = 1,
-    Commit = 2,
-    Nil = 3,
-}
-impl BlockIdFlag {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            BlockIdFlag::Unknown => "BLOCK_ID_FLAG_UNKNOWN",
-            BlockIdFlag::Absent => "BLOCK_ID_FLAG_ABSENT",
-            BlockIdFlag::Commit => "BLOCK_ID_FLAG_COMMIT",
-            BlockIdFlag::Nil => "BLOCK_ID_FLAG_NIL",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "BLOCK_ID_FLAG_UNKNOWN" => Some(Self::Unknown),
-            "BLOCK_ID_FLAG_ABSENT" => Some(Self::Absent),
-            "BLOCK_ID_FLAG_COMMIT" => Some(Self::Commit),
-            "BLOCK_ID_FLAG_NIL" => Some(Self::Nil),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum SignMode {
-    Unspecified = 0,
-    Direct = 1,
-    Textual = 2,
-    LegacyAminoJson = 127,
-}
-impl SignMode {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            SignMode::Unspecified => "SIGN_MODE_UNSPECIFIED",
-            SignMode::Direct => "SIGN_MODE_DIRECT",
-            SignMode::Textual => "SIGN_MODE_TEXTUAL",
-            SignMode::LegacyAminoJson => "SIGN_MODE_LEGACY_AMINO_JSON",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "SIGN_MODE_UNSPECIFIED" => Some(Self::Unspecified),
-            "SIGN_MODE_DIRECT" => Some(Self::Direct),
-            "SIGN_MODE_TEXTUAL" => Some(Self::Textual),
-            "SIGN_MODE_LEGACY_AMINO_JSON" => Some(Self::LegacyAminoJson),
-            _ => None,
-        }
-    }
-}
diff --git a/chain/cosmos/src/runtime/abi.rs b/chain/cosmos/src/runtime/abi.rs
deleted file mode 100644
index af9260b63be..00000000000
--- a/chain/cosmos/src/runtime/abi.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use crate::protobuf::*;
-use graph::runtime::HostExportError;
-pub use graph::semver::Version;
-
-pub use graph::runtime::{
-    asc_new, gas::GasCounter, AscHeap, AscIndexId, AscPtr, AscType, AscValue,
-    DeterministicHostError, IndexForAscTypeId, ToAscObj,
-};
-/*
-TODO: AscBytesArray seem to be generic to all chains, but AscIndexId pins it to Cosmos
-****************** this can be moved to runtime graph/runtime/src/asc_heap.rs, but  IndexForAscTypeId::CosmosBytesArray ******
-*/
-pub struct AscBytesArray(pub Array<AscPtr<Uint8Array>>);
-
-impl ToAscObj<AscBytesArray> for Vec<Vec<u8>> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscBytesArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self
-            .iter()
-            .map(|x| asc_new(heap, &graph_runtime_wasm::asc_abi::class::Bytes(x), gas))
-            .collect();
-
-        Ok(AscBytesArray(Array::new(&content?, heap, gas)?))
-    }
-}
-
-//this can be moved to runtime
-impl AscType for AscBytesArray {
-    fn to_asc_bytes(&self) -> Result<Vec<u8>, DeterministicHostError> {
-        self.0.to_asc_bytes()
-    }
-
-    fn from_asc_bytes(
-        asc_obj: &[u8],
-        api_version: &Version,
-    ) -> Result<Self, DeterministicHostError> {
-        Ok(Self(Array::from_asc_bytes(asc_obj, api_version)?))
-    }
-}
-
-//we will have to keep this chain specific (Inner/Outer)
-impl AscIndexId for AscBytesArray {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::CosmosBytesArray;
-}
-
-/************************************************************************** */
-// this can be moved to runtime - prost_types::Any
-impl ToAscObj<AscAny> for prost_types::Any {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscAny, HostExportError> {
-        Ok(AscAny {
-            type_url: asc_new(heap, &self.type_url, gas)?,
-            value: asc_new(
-                heap,
-                &graph_runtime_wasm::asc_abi::class::Bytes(&self.value),
-                gas,
-            )?,
-            ..Default::default()
-        })
-    }
-}
-
-//this can be moved to runtime - prost_types::Any
-impl ToAscObj<AscAnyArray> for Vec<prost_types::Any> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscAnyArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-
-        Ok(AscAnyArray(Array::new(&content?, heap, gas)?))
-    }
-}
diff --git a/chain/cosmos/src/runtime/mod.rs b/chain/cosmos/src/runtime/mod.rs
deleted file mode 100644
index 78d10d4d7d3..00000000000
--- a/chain/cosmos/src/runtime/mod.rs
+++ /dev/null
@@ -1,348 +0,0 @@
-pub mod abi;
-
-#[cfg(test)]
-mod test {
-    use crate::protobuf::*;
-
-    use graph::semver::Version;
-
-    /// A macro that takes an ASC struct value definition and calls AscBytes methods to check that
-    /// memory layout is padded properly.
-    macro_rules! assert_asc_bytes {
-        ($struct_name:ident {
-            $($field:ident : $field_value:expr),+
-            $(,)? // trailing
-        }) => {
-            let value = $struct_name {
-                $($field: $field_value),+
-            };
-
-            // just call the function. it will panic on misalignments
-            let asc_bytes = value.to_asc_bytes().unwrap();
-
-            let value_004 = $struct_name::from_asc_bytes(&asc_bytes, &Version::new(0, 0, 4)).unwrap();
-            let value_005 = $struct_name::from_asc_bytes(&asc_bytes, &Version::new(0, 0, 5)).unwrap();
-
-            // turn the values into bytes again to verify that they are the same as the original
-            // because these types usually don't implement PartialEq
-            assert_eq!(
-                asc_bytes,
-                value_004.to_asc_bytes().unwrap(),
-                "Expected {} v0.0.4 asc bytes to be the same",
-                stringify!($struct_name)
-            );
-            assert_eq!(
-                asc_bytes,
-                value_005.to_asc_bytes().unwrap(),
-                "Expected {} v0.0.5 asc bytes to be the same",
-                stringify!($struct_name)
-            );
-        };
-    }
-
-    #[test]
-    fn test_asc_type_alignment() {
-        // TODO: automatically generate these tests for each struct in derive(AscType) macro
-
-        assert_asc_bytes!(AscBlock {
-            header: new_asc_ptr(),
-            evidence: new_asc_ptr(),
-            last_commit: new_asc_ptr(),
-            result_begin_block: new_asc_ptr(),
-            result_end_block: new_asc_ptr(),
-            transactions: new_asc_ptr(),
-            validator_updates: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscHeaderOnlyBlock {
-            header: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscEventData {
-            event: new_asc_ptr(),
-            block: new_asc_ptr(),
-            tx: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscTransactionData {
-            tx: new_asc_ptr(),
-            block: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscMessageData {
-            message: new_asc_ptr(),
-            block: new_asc_ptr(),
-            tx: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscTransactionContext {
-            hash: new_asc_ptr(),
-            index: 20,
-            code: 20,
-            gas_wanted: 20,
-            gas_used: 20,
-        });
-
-        assert_asc_bytes!(AscHeader {
-            version: new_asc_ptr(),
-            chain_id: new_asc_ptr(),
-            height: 20,
-            time: new_asc_ptr(),
-            last_block_id: new_asc_ptr(),
-            last_commit_hash: new_asc_ptr(),
-            data_hash: new_asc_ptr(),
-            validators_hash: new_asc_ptr(),
-            next_validators_hash: new_asc_ptr(),
-            consensus_hash: new_asc_ptr(),
-            app_hash: new_asc_ptr(),
-            last_results_hash: new_asc_ptr(),
-            evidence_hash: new_asc_ptr(),
-            proposer_address: new_asc_ptr(),
-            hash: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscConsensus { block: 0, app: 0 });
-
-        assert_asc_bytes!(AscTimestamp {
-            seconds: 20,
-            nanos: 20,
-        });
-
-        assert_asc_bytes!(AscBlockId {
-            hash: new_asc_ptr(),
-            part_set_header: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscPartSetHeader {
-            total: 20,
-            hash: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscEvidenceList {
-            evidence: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscEvidence {
-            duplicate_vote_evidence: new_asc_ptr(),
-            light_client_attack_evidence: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscDuplicateVoteEvidence {
-            vote_a: new_asc_ptr(),
-            vote_b: new_asc_ptr(),
-            total_voting_power: 20,
-            validator_power: 20,
-            timestamp: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscEventVote {
-            event_vote_type: 20,
-            height: 20,
-            round: 20,
-            block_id: new_asc_ptr(),
-            timestamp: new_asc_ptr(),
-            validator_address: new_asc_ptr(),
-            validator_index: 20,
-            signature: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscLightClientAttackEvidence {
-            conflicting_block: new_asc_ptr(),
-            common_height: 20,
-            total_voting_power: 20,
-            byzantine_validators: new_asc_ptr(),
-            timestamp: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscLightBlock {
-            signed_header: new_asc_ptr(),
-            validator_set: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscSignedHeader {
-            header: new_asc_ptr(),
-            commit: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscCommit {
-            height: 20,
-            round: 20,
-            block_id: new_asc_ptr(),
-            signatures: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscCommitSig {
-            block_id_flag: 20,
-            validator_address: new_asc_ptr(),
-            timestamp: new_asc_ptr(),
-            signature: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscValidatorSet {
-            validators: new_asc_ptr(),
-            proposer: new_asc_ptr(),
-            total_voting_power: 20,
-        });
-
-        assert_asc_bytes!(AscValidator {
-            address: new_asc_ptr(),
-            pub_key: new_asc_ptr(),
-            voting_power: 20,
-            proposer_priority: 20,
-        });
-
-        assert_asc_bytes!(AscPublicKey {
-            ed25519: new_asc_ptr(),
-            secp256k1: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscResponseBeginBlock {
-            events: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscEvent {
-            event_type: new_asc_ptr(),
-            attributes: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscEventAttribute {
-            key: new_asc_ptr(),
-            value: new_asc_ptr(),
-            index: true,
-        });
-
-        assert_asc_bytes!(AscResponseEndBlock {
-            validator_updates: new_asc_ptr(),
-            consensus_param_updates: new_asc_ptr(),
-            events: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscValidatorUpdate {
-            address: new_asc_ptr(),
-            pub_key: new_asc_ptr(),
-            power: 20,
-        });
-
-        assert_asc_bytes!(AscConsensusParams {
-            block: new_asc_ptr(),
-            evidence: new_asc_ptr(),
-            validator: new_asc_ptr(),
-            version: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscBlockParams {
-            max_bytes: 20,
-            max_gas: 20,
-        });
-
-        assert_asc_bytes!(AscEvidenceParams {
-            max_age_num_blocks: 20,
-            max_age_duration: new_asc_ptr(),
-            max_bytes: 20,
-        });
-
-        assert_asc_bytes!(AscDuration {
-            seconds: 20,
-            nanos: 20,
-        });
-
-        assert_asc_bytes!(AscValidatorParams {
-            pub_key_types: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscVersionParams { app_version: 20 });
-
-        assert_asc_bytes!(AscTxResult {
-            height: 20,
-            index: 20,
-            tx: new_asc_ptr(),
-            result: new_asc_ptr(),
-            hash: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscTx {
-            body: new_asc_ptr(),
-            auth_info: new_asc_ptr(),
-            signatures: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscTxBody {
-            messages: new_asc_ptr(),
-            memo: new_asc_ptr(),
-            timeout_height: 20,
-            extension_options: new_asc_ptr(),
-            non_critical_extension_options: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscAny {
-            type_url: new_asc_ptr(),
-            value: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscAuthInfo {
-            signer_infos: new_asc_ptr(),
-            fee: new_asc_ptr(),
-            tip: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscSignerInfo {
-            public_key: new_asc_ptr(),
-            mode_info: new_asc_ptr(),
-            sequence: 20,
-        });
-
-        assert_asc_bytes!(AscModeInfo {
-            single: new_asc_ptr(),
-            multi: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscModeInfoSingle { mode: 20 });
-
-        assert_asc_bytes!(AscModeInfoMulti {
-            bitarray: new_asc_ptr(),
-            mode_infos: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscCompactBitArray {
-            extra_bits_stored: 20,
-            elems: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscFee {
-            amount: new_asc_ptr(),
-            gas_limit: 20,
-            payer: new_asc_ptr(),
-            granter: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscCoin {
-            denom: new_asc_ptr(),
-            amount: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscTip {
-            amount: new_asc_ptr(),
-            tipper: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscResponseDeliverTx {
-            code: 20,
-            data: new_asc_ptr(),
-            log: new_asc_ptr(),
-            info: new_asc_ptr(),
-            gas_wanted: 20,
-            gas_used: 20,
-            events: new_asc_ptr(),
-            codespace: new_asc_ptr(),
-        });
-
-        assert_asc_bytes!(AscValidatorSetUpdates {
-            validator_updates: new_asc_ptr(),
-        });
-    }
-
-    // non-null AscPtr
-    fn new_asc_ptr<T>() -> AscPtr<T> {
-        AscPtr::new(12)
-    }
-}
diff --git a/chain/cosmos/src/trigger.rs b/chain/cosmos/src/trigger.rs
deleted file mode 100644
index 0f692a695f9..00000000000
--- a/chain/cosmos/src/trigger.rs
+++ /dev/null
@@ -1,365 +0,0 @@
-use std::{cmp::Ordering, sync::Arc};
-
-use graph::blockchain::{Block, BlockHash, MappingTriggerTrait, TriggerData};
-use graph::cheap_clone::CheapClone;
-use graph::prelude::{BlockNumber, Error};
-use graph::runtime::HostExportError;
-use graph::runtime::{asc_new, gas::GasCounter, AscHeap, AscPtr};
-use graph_runtime_wasm::module::ToAscPtr;
-
-use crate::codec;
-use crate::data_source::EventOrigin;
-
-// Logging the block is too verbose, so this strips the block from the trigger for Debug.
-impl std::fmt::Debug for CosmosTrigger {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        #[derive(Debug)]
-        pub enum MappingTriggerWithoutBlock<'e> {
-            Block,
-            Event {
-                event_type: &'e str,
-                origin: EventOrigin,
-            },
-            Transaction,
-            Message,
-        }
-
-        let trigger_without_block = match self {
-            CosmosTrigger::Block(_) => MappingTriggerWithoutBlock::Block,
-            CosmosTrigger::Event { event_data, origin } => MappingTriggerWithoutBlock::Event {
-                event_type: &event_data.event().map_err(|_| std::fmt::Error)?.event_type,
-                origin: *origin,
-            },
-            CosmosTrigger::Transaction(_) => MappingTriggerWithoutBlock::Transaction,
-            CosmosTrigger::Message(_) => MappingTriggerWithoutBlock::Message,
-        };
-
-        write!(f, "{:?}", trigger_without_block)
-    }
-}
-
-impl ToAscPtr for CosmosTrigger {
-    fn to_asc_ptr<H: AscHeap>(
-        self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscPtr<()>, HostExportError> {
-        Ok(match self {
-            CosmosTrigger::Block(block) => asc_new(heap, block.as_ref(), gas)?.erase(),
-            CosmosTrigger::Event { event_data, .. } => {
-                asc_new(heap, event_data.as_ref(), gas)?.erase()
-            }
-            CosmosTrigger::Transaction(transaction_data) => {
-                asc_new(heap, transaction_data.as_ref(), gas)?.erase()
-            }
-            CosmosTrigger::Message(message_data) => {
-                asc_new(heap, message_data.as_ref(), gas)?.erase()
-            }
-        })
-    }
-}
-
-#[derive(Clone)]
-pub enum CosmosTrigger {
-    Block(Arc<codec::Block>),
-    Event {
-        event_data: Arc<codec::EventData>,
-        origin: EventOrigin,
-    },
-    Transaction(Arc<codec::TransactionData>),
-    Message(Arc<codec::MessageData>),
-}
-
-impl CheapClone for CosmosTrigger {}
-
-impl PartialEq for CosmosTrigger {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::Block(a_ptr), Self::Block(b_ptr)) => a_ptr == b_ptr,
-            (
-                Self::Event {
-                    event_data: a_event_data,
-                    origin: a_origin,
-                },
-                Self::Event {
-                    event_data: b_event_data,
-                    origin: b_origin,
-                },
-            ) => {
-                if let (Ok(a_event), Ok(b_event)) = (a_event_data.event(), b_event_data.event()) {
-                    let mut attributes_a = a_event.attributes.clone();
-                    attributes_a.sort_by(|a, b| a.key.cmp(&b.key));
-
-                    let mut attributes_b = b_event.attributes.clone();
-                    attributes_b.sort_by(|a, b| a.key.cmp(&b.key));
-
-                    a_event.event_type == b_event.event_type
-                        && a_origin == b_origin
-                        && attributes_a == attributes_b
-                } else {
-                    false
-                }
-            }
-            (Self::Transaction(a_ptr), Self::Transaction(b_ptr)) => a_ptr == b_ptr,
-            (Self::Message(a_ptr), Self::Message(b_ptr)) => a_ptr == b_ptr,
-            _ => false,
-        }
-    }
-}
-
-impl Eq for CosmosTrigger {}
-
-impl CosmosTrigger {
-    pub(crate) fn with_event(
-        event: codec::Event,
-        block: codec::HeaderOnlyBlock,
-        tx_context: Option<codec::TransactionContext>,
-        origin: EventOrigin,
-    ) -> CosmosTrigger {
-        CosmosTrigger::Event {
-            event_data: Arc::new(codec::EventData {
-                event: Some(event),
-                block: Some(block),
-                tx: tx_context,
-            }),
-            origin,
-        }
-    }
-
-    pub(crate) fn with_transaction(
-        tx_result: codec::TxResult,
-        block: codec::HeaderOnlyBlock,
-    ) -> CosmosTrigger {
-        CosmosTrigger::Transaction(Arc::new(codec::TransactionData {
-            tx: Some(tx_result),
-            block: Some(block),
-        }))
-    }
-
-    pub(crate) fn with_message(
-        message: ::prost_types::Any,
-        block: codec::HeaderOnlyBlock,
-        tx_context: codec::TransactionContext,
-    ) -> CosmosTrigger {
-        CosmosTrigger::Message(Arc::new(codec::MessageData {
-            message: Some(message),
-            block: Some(block),
-            tx: Some(tx_context),
-        }))
-    }
-
-    pub fn block_number(&self) -> Result<BlockNumber, Error> {
-        match self {
-            CosmosTrigger::Block(block) => Ok(block.number()),
-            CosmosTrigger::Event { event_data, .. } => event_data.block().map(|b| b.number()),
-            CosmosTrigger::Transaction(transaction_data) => {
-                transaction_data.block().map(|b| b.number())
-            }
-            CosmosTrigger::Message(message_data) => message_data.block().map(|b| b.number()),
-        }
-    }
-
-    pub fn block_hash(&self) -> Result<BlockHash, Error> {
-        match self {
-            CosmosTrigger::Block(block) => Ok(block.hash()),
-            CosmosTrigger::Event { event_data, .. } => event_data.block().map(|b| b.hash()),
-            CosmosTrigger::Transaction(transaction_data) => {
-                transaction_data.block().map(|b| b.hash())
-            }
-            CosmosTrigger::Message(message_data) => message_data.block().map(|b| b.hash()),
-        }
-    }
-
-    fn error_context(&self) -> std::string::String {
-        match self {
-            CosmosTrigger::Block(..) => {
-                if let (Ok(block_number), Ok(block_hash)) = (self.block_number(), self.block_hash())
-                {
-                    format!("block #{block_number}, hash {block_hash}")
-                } else {
-                    "block".to_string()
-                }
-            }
-            CosmosTrigger::Event { event_data, origin } => {
-                if let (Ok(event), Ok(block_number), Ok(block_hash)) =
-                    (event_data.event(), self.block_number(), self.block_hash())
-                {
-                    format!(
-                        "event type {}, origin: {:?}, block #{block_number}, hash {block_hash}",
-                        event.event_type, origin,
-                    )
-                } else {
-                    "event".to_string()
-                }
-            }
-            CosmosTrigger::Transaction(transaction_data) => {
-                if let (Ok(block_number), Ok(block_hash), Ok(response_deliver_tx)) = (
-                    self.block_number(),
-                    self.block_hash(),
-                    transaction_data.response_deliver_tx(),
-                ) {
-                    format!(
-                        "block #{block_number}, hash {block_hash}, transaction log: {}",
-                        response_deliver_tx.log
-                    )
-                } else {
-                    "transaction".to_string()
-                }
-            }
-            CosmosTrigger::Message(message_data) => {
-                if let (Ok(message), Ok(block_number), Ok(block_hash)) = (
-                    message_data.message(),
-                    self.block_number(),
-                    self.block_hash(),
-                ) {
-                    format!(
-                        "message type {}, block #{block_number}, hash {block_hash}",
-                        message.type_url,
-                    )
-                } else {
-                    "message".to_string()
-                }
-            }
-        }
-    }
-}
-
-impl Ord for CosmosTrigger {
-    fn cmp(&self, other: &Self) -> Ordering {
-        match (self, other) {
-            // Events have no intrinsic ordering information, so we keep the order in
-            // which they are included in the `events` field
-            (Self::Event { .. }, Self::Event { .. }) => Ordering::Equal,
-
-            // Keep the order when comparing two message triggers
-            (Self::Message(..), Self::Message(..)) => Ordering::Equal,
-
-            // Transactions are ordered by their index inside the block
-            (Self::Transaction(a), Self::Transaction(b)) => {
-                if let (Ok(a_tx_result), Ok(b_tx_result)) = (a.tx_result(), b.tx_result()) {
-                    a_tx_result.index.cmp(&b_tx_result.index)
-                } else {
-                    Ordering::Equal
-                }
-            }
-
-            // Keep the order when comparing two block triggers
-            (Self::Block(..), Self::Block(..)) => Ordering::Equal,
-
-            // Event triggers always come first
-            (Self::Event { .. }, _) => Ordering::Greater,
-            (_, Self::Event { .. }) => Ordering::Less,
-
-            // Block triggers always come last
-            (Self::Block(..), _) => Ordering::Less,
-            (_, Self::Block(..)) => Ordering::Greater,
-
-            // Message triggers before Transaction triggers
-            (Self::Message(..), Self::Transaction(..)) => Ordering::Greater,
-            (Self::Transaction(..), Self::Message(..)) => Ordering::Less,
-        }
-    }
-}
-
-impl PartialOrd for CosmosTrigger {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl TriggerData for CosmosTrigger {
-    fn error_context(&self) -> String {
-        self.error_context()
-    }
-
-    fn address_match(&self) -> Option<&[u8]> {
-        None
-    }
-}
-
-impl MappingTriggerTrait for CosmosTrigger {
-    fn error_context(&self) -> String {
-        self.error_context()
-    }
-}
-#[cfg(test)]
-mod tests {
-    use crate::codec::TxResult;
-
-    use super::*;
-
-    #[test]
-    fn test_cosmos_trigger_ordering() {
-        let event_trigger = CosmosTrigger::Event {
-            event_data: Arc::<codec::EventData>::new(codec::EventData {
-                ..Default::default()
-            }),
-            origin: EventOrigin::BeginBlock,
-        };
-        let other_event_trigger = CosmosTrigger::Event {
-            event_data: Arc::<codec::EventData>::new(codec::EventData {
-                ..Default::default()
-            }),
-            origin: EventOrigin::BeginBlock,
-        };
-        let message_trigger =
-            CosmosTrigger::Message(Arc::<codec::MessageData>::new(codec::MessageData {
-                ..Default::default()
-            }));
-        let other_message_trigger =
-            CosmosTrigger::Message(Arc::<codec::MessageData>::new(codec::MessageData {
-                ..Default::default()
-            }));
-        let transaction_trigger = CosmosTrigger::Transaction(Arc::<codec::TransactionData>::new(
-            codec::TransactionData {
-                block: None,
-                tx: Some(TxResult {
-                    index: 1,
-                    ..Default::default()
-                }),
-            },
-        ));
-        let other_transaction_trigger = CosmosTrigger::Transaction(
-            Arc::<codec::TransactionData>::new(codec::TransactionData {
-                block: None,
-                tx: Some(TxResult {
-                    index: 2,
-                    ..Default::default()
-                }),
-            }),
-        );
-        let block_trigger = CosmosTrigger::Block(Arc::<codec::Block>::new(codec::Block {
-            ..Default::default()
-        }));
-        let other_block_trigger = CosmosTrigger::Block(Arc::<codec::Block>::new(codec::Block {
-            ..Default::default()
-        }));
-
-        assert_eq!(event_trigger.cmp(&block_trigger), Ordering::Greater);
-        assert_eq!(event_trigger.cmp(&transaction_trigger), Ordering::Greater);
-        assert_eq!(event_trigger.cmp(&message_trigger), Ordering::Greater);
-        assert_eq!(event_trigger.cmp(&other_event_trigger), Ordering::Equal);
-
-        assert_eq!(message_trigger.cmp(&block_trigger), Ordering::Greater);
-        assert_eq!(message_trigger.cmp(&transaction_trigger), Ordering::Greater);
-        assert_eq!(message_trigger.cmp(&other_message_trigger), Ordering::Equal);
-        assert_eq!(message_trigger.cmp(&event_trigger), Ordering::Less);
-
-        assert_eq!(transaction_trigger.cmp(&block_trigger), Ordering::Greater);
-        assert_eq!(
-            transaction_trigger.cmp(&other_transaction_trigger),
-            Ordering::Less
-        );
-        assert_eq!(
-            other_transaction_trigger.cmp(&transaction_trigger),
-            Ordering::Greater
-        );
-        assert_eq!(transaction_trigger.cmp(&message_trigger), Ordering::Less);
-        assert_eq!(transaction_trigger.cmp(&event_trigger), Ordering::Less);
-
-        assert_eq!(block_trigger.cmp(&other_block_trigger), Ordering::Equal);
-        assert_eq!(block_trigger.cmp(&transaction_trigger), Ordering::Less);
-        assert_eq!(block_trigger.cmp(&message_trigger), Ordering::Less);
-        assert_eq!(block_trigger.cmp(&event_trigger), Ordering::Less);
-    }
-}
diff --git a/chain/ethereum/Cargo.toml b/chain/ethereum/Cargo.toml
index 84bb1192903..a9c9d42a124 100644
--- a/chain/ethereum/Cargo.toml
+++ b/chain/ethereum/Cargo.toml
@@ -4,29 +4,32 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-envconfig = "0.10.0"
-futures = "0.1.21"
-http = "0.2.4"
+async-trait = { workspace = true }
+envconfig = { workspace = true }
 jsonrpc-core = "18.0.0"
 graph = { path = "../../graph" }
-lazy_static = "1.2.0"
-serde = "1.0"
+serde = { workspace = true }
 prost = { workspace = true }
 prost-types = { workspace = true }
-dirs-next = "2.0"
 anyhow = "1.0"
-tiny-keccak = "1.5.0"
 hex = "0.4.3"
-semver = "1.0.21"
+semver = { workspace = true }
+thiserror = { workspace = true }
+futures = { workspace = true }
+tokio = { workspace = true }
+tokio-stream = { workspace = true }
+tower = { workspace = true }
 
-itertools = "0.12.0"
+itertools = "0.15.0"
 
 graph-runtime-wasm = { path = "../../runtime/wasm" }
 graph-runtime-derive = { path = "../../runtime/derive" }
 
 [dev-dependencies]
-base64 = "0.20.0"
-uuid = { version = "1.6.1", features = ["v4"] }
+base64 = "0"
 
 [build-dependencies]
-tonic-build = { workspace = true }
+tonic-prost-build = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/chain/ethereum/build.rs b/chain/ethereum/build.rs
index 8ccae67aa92..f9d8eb0101b 100644
--- a/chain/ethereum/build.rs
+++ b/chain/ethereum/build.rs
@@ -1,8 +1,9 @@
 fn main() {
     println!("cargo:rerun-if-changed=proto");
 
-    tonic_build::configure()
+    tonic_prost_build::configure()
         .out_dir("src/protobuf")
-        .compile(&["proto/ethereum.proto"], &["proto"])
+        .protoc_arg("--experimental_allow_proto3_optional")
+        .compile_protos(&["proto/ethereum.proto"], &["proto"])
         .expect("Failed to compile Firehose Ethereum proto(s)");
 }
diff --git a/chain/ethereum/examples/firehose.rs b/chain/ethereum/examples/firehose.rs
index fbdfaa1f141..3dd21859653 100644
--- a/chain/ethereum/examples/firehose.rs
+++ b/chain/ethereum/examples/firehose.rs
@@ -2,14 +2,14 @@ use anyhow::Error;
 use graph::{
     endpoint::EndpointMetrics,
     env::env_var,
-    firehose::SubgraphLimit,
+    firehose::{self, FirehoseEndpoint, SubgraphLimit},
     log::logger,
-    prelude::{prost, tokio, tonic, MetricsRegistry},
-    {firehose, firehose::FirehoseEndpoint},
+    prelude::{MetricsRegistry, prost, tokio, tonic},
 };
 use graph_chain_ethereum::codec;
 use hex::ToHex;
 use prost::Message;
+use std::slice;
 use std::sync::Arc;
 use tonic::Streaming;
 
@@ -26,7 +26,7 @@ async fn main() -> Result<(), Error> {
     let host = "https://api.streamingfast.io:443".to_string();
     let metrics = Arc::new(EndpointMetrics::new(
         logger,
-        &[host.clone()],
+        slice::from_ref(&host),
         Arc::new(MetricsRegistry::mock()),
     ));
 
@@ -34,6 +34,7 @@ async fn main() -> Result<(), Error> {
         "firehose",
         &host,
         token,
+        None,
         false,
         false,
         SubgraphLimit::Unlimited,
@@ -44,16 +45,19 @@ async fn main() -> Result<(), Error> {
         println!("Connecting to the stream!");
         let mut stream: Streaming<firehose::Response> = match firehose
             .clone()
-            .stream_blocks(firehose::Request {
-                start_block_num: 12369739,
-                stop_block_num: 12369739,
-                cursor: match &cursor {
-                    Some(c) => c.clone(),
-                    None => String::from(""),
+            .stream_blocks(
+                firehose::Request {
+                    start_block_num: 12369739,
+                    stop_block_num: 12369739,
+                    cursor: match &cursor {
+                        Some(c) => c.clone(),
+                        None => String::from(""),
+                    },
+                    final_blocks_only: false,
+                    ..Default::default()
                 },
-                final_blocks_only: false,
-                ..Default::default()
-            })
+                &firehose::ConnectionHeaders::new(),
+            )
             .await
         {
             Ok(s) => s,
diff --git a/chain/ethereum/proto/ethereum.proto b/chain/ethereum/proto/ethereum.proto
index 3c9f7378c7d..50c10f921f0 100644
--- a/chain/ethereum/proto/ethereum.proto
+++ b/chain/ethereum/proto/ethereum.proto
@@ -2,64 +2,144 @@ syntax = "proto3";
 
 package sf.ethereum.type.v2;
 
-option go_package = "github.com/streamingfast/sf-ethereum/types/pb/sf/ethereum/type/v2;pbeth";
+option go_package = "github.com/streamingfast/firehose-ethereum/types/pb/sf/ethereum/type/v2;pbeth";
 
 import "google/protobuf/timestamp.proto";
 
+// Block is the representation of the tracing of a block in the Ethereum
+// blockchain. A block is a collection of [TransactionTrace] that are grouped
+// together and processed as an atomic unit. Each [TransactionTrace] is composed
+// of a series of [Call] (a.k.a internal transactions) and there is also at
+// least one call per transaction a.k.a the root call which essentially has the
+// same parameters as the transaction itself (e.g. `from`, `to`, `gas`, `value`,
+// etc.).
+//
+// The exact tracing method used to build the block must be checked against
+// [DetailLevel] field. There is two levels of details available, `BASE` and
+// `EXTENDED`. The `BASE` level has been extracted using archive node RPC calls
+// and will contain only the block header, transaction receipts and event logs.
+// Refers to the Firehose service provider to know which blocks are offered on
+// each network.
+//
+// The `EXTENDED` level has been extracted using the Firehose tracer and all
+// fields are available in this Protobuf.
+//
+// The Ethereum block model is used across many chains which means that it
+// happen that certain fields are not available in one chain but are available
+// in another. Each field should be documented when necesssary if it's available
+// on a subset of chains.
+//
+// One major concept to get about the Block is the concept of 'ordinal'. The
+// ordinal is a number that is used to globally order every element of execution
+// that happened throughout the processing of the block like
+// [TransactionTracer], [Call], [Log], [BalanceChange], [StateChange], etc.
+// Element that have a start and end interval, [Transaction] and [Call], will
+// have two ordinals: `begin_ordinal` and `end_ordinal`. Element that are
+// executed as "point in time" [Log], [BalanceChange], [StateChange], etc. will
+// have only one ordinal named `ordinal`. If you take all of the message in the
+// Block that have an 'ordinal' field in an array and you sort each element
+// against the `ordinal` field, you will get the exact order of execution of
+// each element in the block.
+//
+// All the 'ordinal' fields in a block are globally unique for the given block,
+// it is **not** a chain-wide global ordering. Furthermore, caution must be take
+// with reverted elements due to execution failure. For anything attached to a
+// [Call] that has a `state_reverted` field set to `true`, the `ordinal` field
+// is not reliable and should not be used to order the element against other
+// elements in the block as those element might have 0 as the ordinal. Only
+// successful calls have a reliable `ordinal` field.
 message Block {
-  int32 ver = 1;
+  // Hash is the block's hash.
   bytes hash = 2;
+  // Number is the block's height at which this block was mined.
   uint64 number = 3;
+  // Size is the size in bytes of the RLP encoding of the block according to Ethereum
+  // rules.
   uint64 size = 4;
+  // Header contain's the block's header information like its parent hash, the merkel root hash
+  // and all other information the form a block.
   BlockHeader header = 5;
 
-  // Uncles represents block produced with a valid solution but were not actually choosen
+  // Uncles represents block produced with a valid solution but were not actually chosen
   // as the canonical block for the given height so they are mostly "forked" blocks.
   //
   // If the Block has been produced using the Proof of Stake consensus algorithm, this
   // field will actually be always empty.
   repeated BlockHeader uncles = 6;
 
+  // TransactionTraces hold the execute trace of all the transactions that were executed
+  // in this block. In in there that you will find most of the Ethereum data model.
+  //
+  // They are ordered by the order of execution of the transaction in the block.
   repeated TransactionTrace transaction_traces = 10;
+
+  // BalanceChanges here is the array of ETH transfer that happened at the block level
+  // outside of the normal transaction flow of a block. The best example of this is mining
+  // reward for the block mined, the transfer of ETH to the miner happens outside the normal
+  // transaction flow of the chain and is recorded as a `BalanceChange` here since we cannot
+  // attached it to any transaction.
+  //
+  // Only available in DetailLevel: EXTENDED
   repeated BalanceChange balance_changes = 11;
-  repeated CodeChange code_changes = 20;
 
-  reserved 40; // bool filtering_applied = 40 [deprecated = true];
-  reserved 41; // string filtering_include_filter_expr = 41 [deprecated = true];
-  reserved 42; // string filtering_exclude_filter_expr = 42 [deprecated = true];
-}
+  enum DetailLevel{
+    DETAILLEVEL_EXTENDED = 0;
+    // DETAILLEVEL_TRACE = 1; // TBD
+    DETAILLEVEL_BASE = 2;
+  }
 
-// HeaderOnlyBlock is used to optimally unpack the [Block] structure (note the
-// corresponding message number for the `header` field) while consuming less
-// memory, when only the `header` is desired.
-//
-// WARN: this is a client-side optimization pattern and should be moved in the
-// consuming code.
-message HeaderOnlyBlock {
-  BlockHeader header = 5;
-}
+  // DetailLevel affects the data available in this block.
+  //
+  // ## DetailLevel_EXTENDED
+  //
+  // Describes the most complete block, with traces, balance changes, storage
+  // changes. It is extracted during the execution of the block.
+  //
+  // ## DetailLevel_BASE
+  //
+  // Describes a block that contains only the block header, transaction receipts
+  // and event logs: everything that can be extracted using the base JSON-RPC
+  // interface
+  // (https://ethereum.org/en/developers/docs/apis/json-rpc/#json-rpc-methods)
+  // Furthermore, the eth_getTransactionReceipt call has been avoided because it
+  // brings only minimal improvements at the cost of requiring an archive node
+  // or a full node with complete transaction index.
+  DetailLevel detail_level = 12;
+
+  // CodeChanges here is the array of smart code change that happened that happened at the block level
+  // outside of the normal transaction flow of a block. Some Ethereum's fork like BSC and Polygon
+  // has some capabilities to upgrade internal smart contracts used usually to track the validator
+  // list.
+  //
+  // On hard fork, some procedure runs to upgrade the smart contract code to a new version. In those
+  // network, a `CodeChange` for each modified smart contract on upgrade would be present here. Note
+  // that this happen rarely, so the vast majority of block will have an empty list here.
+  //
+  // Only available in DetailLevel: EXTENDED
+  repeated CodeChange code_changes = 20;
 
-// BlockWithRefs is a lightweight block, with traces and transactions
-// purged from the `block` within, and only.  It is used in transports
-// to pass block data around.
-message BlockWithRefs {
-  string id = 1;
-  Block block = 2;
-  TransactionRefs transaction_trace_refs = 3;
-  bool irreversible = 4;
-}
+  // System calls are introduced in Cancun, along with blobs. They are executed outside of transactions but affect the state.
+  //
+  // Only available in DetailLevel: EXTENDED
+  repeated Call system_calls = 21;
 
-message TransactionRefs {
-  repeated bytes hashes = 1;
-}
+  // Withdrawals represents the list of validator balance withdrawals processed in this block.
+  // Introduced in the Shanghai hard fork (EIP-4895).
+  //
+  // This field has been added because Geth blocks include withdrawals after Shanghai fork,
+  // but our previous Firehose model didn't capture this data. Currently experimental -
+  // NOT ready for production use yet as we validate the tracing implementation.
+  //
+  // Only available when Shanghai fork is active on the chain.
+  repeated Withdrawal withdrawals = 22;
 
-message UnclesHeaders {
-  repeated BlockHeader uncles = 1;
-}
+  reserved 40; // bool filtering_applied = 40 [deprecated = true];
+  reserved 41; // string filtering_include_filter_expr = 41 [deprecated = true];
+  reserved 42; // string filtering_exclude_filter_expr = 42 [deprecated = true];
 
-message BlockRef {
-  bytes hash = 1;
-  uint64 number = 2;
+  // Ver represents that data model version of the block, it is used internally by Firehose on Ethereum
+  // as a validation that we are reading the correct version.
+  int32 ver = 1;
 }
 
 message BlockHeader {
@@ -84,13 +164,10 @@ message BlockHeader {
   // consensus algorithm, this field will actually be constant and set to `0x00`.
   BigInt difficulty = 8;
 
-  // TotalDifficulty is the sum of all previous blocks difficulty including this block difficulty.
+  // TotalDifficulty used to be the sum of all previous blocks difficulty including this block difficulty.
   //
-  // If the Block containing this `BlockHeader` has been produced using the Proof of Stake
-  // consensus algorithm, this field will actually be constant and set to the terminal total difficulty
-  // that was required to transition to Proof of Stake algorithm, which varies per network. It is set to
-  // 58 750 000 000 000 000 000 000 on Ethereum Mainnet and to 10 790 000 on Ethereum Testnet Goerli.
-  BigInt total_difficulty = 17;
+  // It has been deprecated in geth v1.15.0 but was already removed from the JSON-RPC interface for a while
+  BigInt total_difficulty = 17 [deprecated = true];
 
   uint64 number = 9;
   uint64 gas_limit = 10;
@@ -134,19 +211,84 @@ message BlockHeader {
   //    extra_data,
   //    mix_hash,
   //    nonce,
-  //    base_fee_per_gas
+  //    base_fee_per_gas (to be included only if London fork is active)
+  //    withdrawals_root (to be included only if Shangai fork is active)
+  //    blob_gas_used (to be included only if Cancun fork is active)
+  //    excess_blob_gas (to be included only if Cancun fork is active)
+  //    parent_beacon_root (to be included only if Cancun fork is active)
+  //    requests_hash (to be included only if Prague fork is active)
   //  ]))
   //
   bytes hash = 16;
 
   // Base fee per gas according to EIP-1559 (e.g. London Fork) rules, only set if London is present/active on the chain.
   BigInt base_fee_per_gas = 18;
+
+  // Withdrawals root hash according to EIP-4895 (e.g. Shangai Fork) rules, only set if Shangai is present/active on the chain.
+  //
+  // Only available in DetailLevel: EXTENDED
+  bytes withdrawals_root = 19;
+
+  // TxDependency is list of transaction indexes that are dependent on each other in the block
+  // header. This is metadata only that was used by the internal Polygon parallel execution engine.
+  //
+  // This field was available in a few versions on Polygon Mainnet and Polygon Mumbai chains. It was actually
+  // removed and is not populated anymore. It's now embedded in the `extraData` field, refer to Polygon source
+  // code to determine how to extract it if you need it.
+  //
+  // Only available in DetailLevel: EXTENDED
+  Uint64NestedArray tx_dependency = 20;
+
+	// BlobGasUsed was added by EIP-4844 and is ignored in legacy headers.
+	optional uint64 blob_gas_used = 22;
+
+	// ExcessBlobGas was added by EIP-4844 and is ignored in legacy headers.
+	optional uint64 excess_blob_gas = 23;
+
+	// ParentBeaconRoot was added by EIP-4788 and is ignored in legacy headers.
+	bytes parent_beacon_root = 24;
+
+  // RequestsHash was added by EIP-7685 and is ignored in legacy headers.
+  bytes requests_hash = 25;
+}
+
+message Uint64NestedArray {
+    repeated Uint64Array val = 1;
+}
+
+message Uint64Array {
+    repeated uint64 val = 1;
 }
 
 message BigInt {
   bytes bytes = 1;
 }
 
+// TransactionTrace is full trace of execution of the transaction when the
+// it actually executed on chain.
+//
+// It contains all the transaction details like `from`, `to`, `gas`, etc.
+// as well as all the internal calls that were made during the transaction.
+//
+// The `calls` vector contains Call objects which have balance changes, events
+// storage changes, etc.
+//
+// If ordering is important between elements, almost each message like `Log`,
+// `Call`, `StorageChange`, etc. have an ordinal field that is represents "execution"
+// order of the said element against all other elements in this block.
+//
+// Due to how the call tree works doing "naively", looping through all calls then
+// through a Call's element like `logs` while not yielding the elements in the order
+// they were executed on chain. A log in call could have been done before or after
+// another in another call depending on the actual call tree.
+//
+// The `calls` are ordered by creation order and the call tree can be re-computing
+// using fields found in `Call` object (parent/child relationship).
+//
+// Another important thing to note is that even if a transaction succeed, some calls
+// within it could have been reverted internally, if this is important to you, you must
+// check the field `state_reverted` on the `Call` to determine if it was fully committed
+// to the chain or not.
 message TransactionTrace {
   // consensus
   bytes to = 1;
@@ -192,19 +334,47 @@ message TransactionTrace {
     // All transactions that ever existed prior Berlin fork before EIP-2718 was implemented.
     TRX_TYPE_LEGACY = 0;
 
-    // Field that specifies an access list of contract/storage_keys that is going to be used
+    // Transaction that specicy an access list of contract/storage_keys that is going to be used
     // in this transaction.
     //
     // Added in Berlin fork (EIP-2930).
     TRX_TYPE_ACCESS_LIST = 1;
 
-    // Transaction that specifies an access list just like TRX_TYPE_ACCESS_LIST but in addition defines the
+    // Transaction that specifis an access list just like TRX_TYPE_ACCESS_LIST but in addition defines the
     // max base gas gee and max priority gas fee to pay for this transaction. Transaction's of those type are
     // executed against EIP-1559 rules which dictates a dynamic gas cost based on the congestion of the network.
     TRX_TYPE_DYNAMIC_FEE = 2;
+
+    // Transaction which contain a large amount of data that cannot be accessed by EVM execution, but whose commitment
+    // can be accessed. The format is intended to be fully compatible with the format that will be used in full sharding.
+    //
+    // Transaction that defines an access list just like TRX_TYPE_ACCESS_LIST and enables dynamic fee just like
+    // TRX_TYPE_DYNAMIC_FEE but in addition defines the fields 'max_fee_per_data_gas' of type 'uint256' and the fields
+    // 'blob_versioned_hashes' which represents a list of hash outputs from 'kzg_to_versioned_hash'.
+    //
+    // Activated in Cancun fork (EIP-4844)
+    TRX_TYPE_BLOB = 3;
+
+    // Transaction that sets code to an EOA (Externally Owned Accounts)
+    //
+    // Activated in Prague (EIP-7702)
+    TRX_TYPE_SET_CODE = 4;
+
+    // Arbitrum-specific transactions
+    TRX_TYPE_ARBITRUM_DEPOSIT = 100;
+    TRX_TYPE_ARBITRUM_UNSIGNED = 101;
+    TRX_TYPE_ARBITRUM_CONTRACT = 102;
+    TRX_TYPE_ARBITRUM_RETRY = 104;
+    TRX_TYPE_ARBITRUM_SUBMIT_RETRYABLE = 105;
+    TRX_TYPE_ARBITRUM_INTERNAL = 106;
+    TRX_TYPE_ARBITRUM_LEGACY = 120;
+
+    // OPTIMISM-specific transactions
+    TRX_TYPE_OPTIMISM_DEPOSIT = 126;
+
   }
 
-  // AcccessList represents the storage access this transaction has agreed to do in which case those storage
+  // AccessList represents the storage access this transaction has agreed to do in which case those storage
   // access cost less gas unit per access.
   //
   // This will is populated only if `TransactionTrace.Type == TRX_TYPE_ACCESS_LIST || TRX_TYPE_DYNAMIC_FEE` which
@@ -215,6 +385,8 @@ message TransactionTrace {
   //
   // This will is populated only if `TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE` which is possible only
   // if London fork is active on the chain.
+  //
+  // Only available in DetailLevel: EXTENDED
   BigInt max_fee_per_gas = 11;
 
   // MaxPriorityFeePerGas is priority fee per gas the user to pay in extra to the miner on top of the block's
@@ -222,22 +394,106 @@ message TransactionTrace {
   //
   // This will is populated only if `TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE` which is possible only
   // if London fork is active on the chain.
+  //
+  // Only available in DetailLevel: EXTENDED
   BigInt max_priority_fee_per_gas = 13;
 
   // meta
   uint32 index = 20;
   bytes hash = 21;
   bytes from = 22;
+
+  // Only available in DetailLevel: EXTENDED
+  // Known Issues
+  // - Version 3:
+  //    Field not populated. It will be empty.
+  //
+  //    Fixed in `Version 4`, see https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model for information about block versions.
   bytes return_data = 23;
+
+  // Only available in DetailLevel: EXTENDED
   bytes public_key = 24;
+
+  // The block's global ordinal when the transaction started executing, refer to
+  // [Block] documentation for further information about ordinals and total ordering.
   uint64 begin_ordinal = 25;
+
+  // The block's global ordinal when the transaction finished executing, refer to
+  // [Block] documentation for further information about ordinals and total ordering.
   uint64 end_ordinal = 26;
 
+  // TransactionTraceStatus is the status of the transaction execution and will let you know if the transaction
+  // was successful or not.
+  //
+  // ## Explanation relevant only for blocks with `DetailLevel: EXTENDED`
+  //
+  // A successful transaction has been recorded to the blockchain's state for calls in it that were successful.
+  // This means it's possible only a subset of the calls were properly recorded, refer to [calls[].state_reverted] field
+  // to determine which calls were reverted.
+  //
+  // A quirks of the Ethereum protocol is that a transaction `FAILED` or `REVERTED` still affects the blockchain's
+  // state for **some** of the state changes. Indeed, in those cases, the transactions fees are still paid to the miner
+  // which means there is a balance change for the transaction's emitter (e.g. `from`) to pay the gas fees, an optional
+  // balance change for gas refunded to the transaction's emitter (e.g. `from`) and a balance change for the miner who
+  // received the transaction fees. There is also a nonce change for the transaction's emitter (e.g. `from`).
+  //
+  // This means that to properly record the state changes for a transaction, you need to conditionally procees the
+  // transaction's status.
+  //
+  // For a `SUCCEEDED` transaction, you iterate over the `calls` array and record the state changes for each call for
+  // which `state_reverted == false` (if a transaction succeeded, the call at #0 will always `state_reverted == false`
+  // because it aligns with the transaction).
+  //
+  // For a `FAILED` or `REVERTED` transaction, you iterate over the root call (e.g. at #0, will always exist) for
+  // balance changes you process those where `reason` is either `REASON_GAS_BUY`, `REASON_GAS_REFUND` or
+  // `REASON_REWARD_TRANSACTION_FEE` and for nonce change, still on the root call, you pick the nonce change which the
+  // smallest ordinal (if more than one).
   TransactionTraceStatus status = 30;
+
   TransactionReceipt receipt = 31;
+
+  // Only available in DetailLevel: EXTENDED
   repeated Call calls = 32;
-}
 
+  // BlobGas is the amount of gas the transaction is going to pay for the blobs, this is a computed value
+  // equivalent to `self.blob_gas_fee_cap * len(self.blob_hashes)` and provided in the model for convenience.
+  //
+  // This is specified by https://eips.ethereum.org/EIPS/eip-4844
+  //
+  // This will is populated only if `TransactionTrace.Type == TRX_TYPE_BLOB` which is possible only
+  // if Cancun fork is active on the chain.
+  optional uint64 blob_gas = 33;
+
+  // BlobGasFeeCap is the maximum fee per data gas the user is willing to pay for the data gas used.
+  //
+  // This is specified by https://eips.ethereum.org/EIPS/eip-4844
+  //
+  // This will is populated only if `TransactionTrace.Type == TRX_TYPE_BLOB` which is possible only
+  // if Cancun fork is active on the chain.
+  optional BigInt blob_gas_fee_cap = 34;
+
+  // BlobHashes field represents a list of hash outputs from 'kzg_to_versioned_hash' which
+  // essentially is a version byte + the sha256 hash of the blob commitment (e.g.
+  // `BLOB_COMMITMENT_VERSION_KZG + sha256(commitment)[1:]`.
+  //
+  // This is specified by https://eips.ethereum.org/EIPS/eip-4844
+  //
+  // This will is populated only if `TransactionTrace.Type == TRX_TYPE_BLOB` which is possible only
+  // if Cancun fork is active on the chain.
+  repeated bytes blob_hashes = 35;
+
+  // SetCodeAuthorizations represents the authorizations of a transaction to set code to an EOA (Externally Owned Accounts)
+  // as defined in EIP-7702. The list will contain all the authorizations as they were specified in the
+  // transaction itself regardless of their validity. If you need to determined if a given authorization was
+  // correctly applied on chain's state, refer to [SetCodeAuthorization.discarded] field that records
+  // if the authorization was discarded or not by the chain due to invalidity.
+  //
+  // This is specified by https://eips.ethereum.org/EIPS/eip-7702
+  //
+  // This will is populated only if `TransactionTrace.Type == TRX_TYPE_SET_CODE` which is possible only
+  // if Prague fork is active on the chain.
+  repeated SetCodeAuthorization set_code_authorizations = 36;
+}
 
 // AccessTuple represents a list of storage keys for a given contract's address and is used
 // for AccessList construction.
@@ -246,10 +502,64 @@ message AccessTuple {
   repeated bytes storage_keys = 2;
 }
 
-// TransactionTraceWithBlockRef
-message TransactionTraceWithBlockRef {
-  TransactionTrace trace = 1;
-  BlockRef block_ref = 2;
+// SetCodeAuthorization represents the authorization of a transaction to set code of an EOA (Externally Owned Account)
+// as defined in EIP-7702.
+//
+// The 'authority' field is the address that is authorizing the delegation mechanism. The 'authority' value is computed
+// from the signature contained in the message using the computation
+// `authority = ecrecover(keccak(MAGIC || rlp([chain_id, address, nonce])), y_parity, r, s)`
+// where `MAGIC` is `0x5`, `||` is the bytes concatenation operator, `ecrecover` is the Ethereum signature recovery
+// and `y_parity` is the recovery ID value denoted `v` in the message below. Checking the go-ethereum implementation
+// at https://github.com/ethereum/go-ethereum/blob/v1.15.0/core/types/tx_setcode.go#L117 might prove easier to "read".
+//
+// We do extract the 'authority' value from the signature in the message and store it in the 'authority' field for
+// convenience so you don't need to perform the computation yourself.
+message SetCodeAuthorization {
+  // Discarded determines if this authorization was skipped due to being invalid. As EIP-7702 states,
+  // if the authorization is invalid (invalid signature, nonce mismatch, etc.) it must be simply
+  // discarded and the transaction is processed as if the authorization was not present in the
+  // authorization list.
+  //
+  // This boolean records if the authorization was discarded or not by the chain due to invalidity.
+  bool discarded = 1;
+
+  // ChainID is the chain ID of the chain where the transaction was executed, used
+  // to recover the authority from the signature.
+  bytes chain_id = 2;
+
+  // Address contains the address this account is delegating to. This address usually
+  // contain code that this account essentially "delegates" to.
+  //
+  // Note: This was missing when EIP-7702 was first activated on Holesky, Sepolia, BSC Chapel,
+  // BSC Mainnet and Arbitrum Sepolia but was ready for Ethereum Mainnet hard fork. We will backfill
+  // those missing values in the near future at which point we will remove this note.
+  bytes address = 8;
+
+  // Nonce is the nonce of the account that is authorizing delegation mechanism, EIP-7702 rules
+  // states that nonce should be verified using this rule:
+  //
+  // - Verify the nonce of authority is equal to nonce. In case authority does not exist in the trie,
+  // verify that nonce is equal to 0.
+  //
+  // Read SetCodeAuthorization to know how to recover the `authority` value.
+  uint64 nonce = 3;
+
+  // V is the recovery ID value for the signature Y point. While it's defined as a
+  // `uint32`, it's actually bounded by a `uint8` data type withing the Ethereum protocol.
+  uint32 v = 4;
+
+  // R is the signature's X point on the elliptic curve (32 bytes).
+  bytes r = 5;
+
+  // S is the signature's Y point on the elliptic curve (32 bytes).
+  bytes s = 6;
+
+  // Authority is the address of the account that is authorizing delegation mechanism, it
+  // is computed from the signature contained in the message and stored for convenience.
+  //
+  // If the authority cannot be recovered from the signature, this field will be empty and
+  // the `discarded` field will be set to `true`.
+  optional bytes authority = 7;
 }
 
 enum TransactionTraceStatus {
@@ -263,9 +573,7 @@ message TransactionReceipt {
   // State root is an intermediate state_root hash, computed in-between transactions to make
   // **sure** you could build a proof and point to state in the middle of a block. Geth client
   // uses `PostState + root + PostStateOrStatus`` while Parity used `status_code, root...`` this piles
-  // hardforks, see (read the EIPs first):
-  // - https://github.com/eoscanada/go-ethereum-private/blob/deep-mind/core/types/receipt.go#L147
-  // - https://github.com/eoscanada/go-ethereum-private/blob/deep-mind/core/types/receipt.go#L50-L86
+  // hard forks, see (read the EIPs first):
   // - https://github.com/ethereum/EIPs/blob/master/EIPS/eip-658.md
   //
   // Moreover, the notion of `Outcome`` in parity, which segregates the two concepts, which are
@@ -277,6 +585,23 @@ message TransactionReceipt {
   uint64 cumulative_gas_used = 2;
   bytes logs_bloom = 3;
   repeated Log logs = 4;
+
+  // BlobGasUsed is the amount of blob gas that has been used within this transaction. At time
+  // of writing, this is equal to `self.blob_gas_fee_cap * len(self.blob_hashes)`.
+  //
+  // This is specified by https://eips.ethereum.org/EIPS/eip-4844
+  //
+  // This will is populated only if `TransactionTrace.Type == TRX_TYPE_BLOB` which is possible only
+  // if Cancun fork is active on the chain.
+  optional uint64 blob_gas_used = 5;
+
+  // BlobGasPrice is the amount to pay per blob item in the transaction.
+  //
+  // This is specified by https://eips.ethereum.org/EIPS/eip-4844
+  //
+  // This will is populated only if `TransactionTrace.Type == TRX_TYPE_BLOB` which is possible only
+  // if Cancun fork is active on the chain.
+  optional BigInt blob_gas_price = 6;
 }
 
 message Log {
@@ -285,8 +610,10 @@ message Log {
   bytes data = 3;
 
   // Index is the index of the log relative to the transaction. This index
-  // is always populated regardless of the state revertion of the the call
+  // is always populated regardless of the state reversion of the the call
   // that emitted this log.
+  //
+  // Only available in DetailLevel: EXTENDED
   uint32 index = 4;
 
   // BlockIndex represents the index of the log relative to the Block.
@@ -306,6 +633,8 @@ message Log {
   // the `blockIndex` value will always be 0.
   uint32 blockIndex = 6;
 
+  // The block's global ordinal when the log was recorded, refer to [Block]
+  // documentation for further information about ordinals and total ordering.
   uint64 ordinal = 7;
 }
 
@@ -316,32 +645,83 @@ message Call {
   CallType call_type = 4;
   bytes caller = 5;
   bytes address = 6;
+
+  // AddressDelegatesTo contains the address from which the actual code to execute will be loaded
+  // as defined per EIP-7702 rules. If the Call's address value resolves to a code
+  // that delegates to another address, this field will be populated with the address
+  // that the call is delegated to. It will be empty in all other situations.
+  //
+  // Assumes that a 'SetCode' transaction set address `0xA` to delegates to address `0xB`,
+  // then when a call is made to `0xA`, the Call object would have:
+  //
+  // - caller = <from>
+  // - address = 0xA
+  // - address_delegates_to = 0xB
+  //
+  // Again, it's important to emphasize that this field relates to EIP-7702, if the call is
+  // a DELEGATE or CALLCODE type, this field will not be populated and will remain empty.
+  //
+  // It will be populated only if EIP-7702 is active on the chain (Prague fork) and if the
+  // 'address' of the call was pointing to another address at time of execution.
+  optional bytes address_delegates_to = 34;
+
   BigInt value = 7;
   uint64 gas_limit = 8;
   uint64 gas_consumed = 9;
   bytes return_data = 13;
+
+  // Known Issues
+  // - Version 3:
+  //    When call is `CREATE` or `CREATE2`, this field is not populated. A couple of suggestions:
+  //      1. You can get the contract's code in the `code_changes` field.
+  //      2. In the root `CREATE` call, you can directly use the `TransactionTrace`'s input field.
+  //
+  //    Fixed in `Version 4`, see https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model for information about block versions.
   bytes input = 14;
+
+  // Indicates whether the call executed code.
+  //
+  // Known Issues
+  // - Version 3:
+  //    This may be incorrectly set to `false` for accounts with code handling native value transfers,
+  //    as well as for certain precompiles with no input.
+  //    The value is initially set based on `call.type != CREATE && len(call.input) > 0`
+  //    and later adjusted if the tracer detects an account without code.
+  //
+  //    Fixed in `Version 4`, see https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model for information about block versions.
   bool executed_code = 15;
   bool suicide = 16;
 
   /* hex representation of the hash -> preimage */
   map<string, string> keccak_preimages = 20;
+
+  // Known Issues
+  // - Version 3:
+  //    The data might be not be in order.
+  //
+  //    Fixed in `Version 4`, see https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model for information about block versions.
   repeated StorageChange storage_changes = 21;
   repeated BalanceChange balance_changes = 22;
   repeated NonceChange nonce_changes = 24;
   repeated Log logs = 25;
   repeated CodeChange code_changes = 26;
-
   // Deprecated: repeated bytes created_accounts
   reserved 27;
 
+  // Known Issues
+  // - Version 3:
+  //    Some gas changes are not correctly tracked:
+  //      1. Gas refunded due to data returned to the chain (occurs at the end of a transaction, before buyback).
+  //      2. Initial gas allocation (0 -> GasLimit) at the start of a call.
+  //      3. Final gas deduction (LeftOver -> 0) at the end of a call (if applicable).
+  //    Fixed in `Version 4`, see https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model for information about block versions.
   repeated GasChange gas_changes = 28;
 
   // Deprecated: repeated GasEvent gas_events
   reserved 29;
 
   // In Ethereum, a call can be either:
-  // - Successfull, execution passes without any problem encountered
+  // - Successful, execution passes without any problem encountered
   // - Failed, execution failed, and remaining gas should be consumed
   // - Reverted, execution failed, but only gas consumed so far is billed, remaining gas is refunded
   //
@@ -355,7 +735,7 @@ message Call {
   // see above for details about those flags.
   string failure_reason = 11;
 
-  // This field represents wheter or not the state changes performed
+  // This field represents whether or not the state changes performed
   // by this call were correctly recorded by the blockchain.
   //
   // On Ethereum, a transaction can record state changes even if some
@@ -375,13 +755,44 @@ message Call {
   // ```
   //
   // In the transaction above, while Call #2 and Call #3 would have the
-  // status `EXECUTED`
+  // status `EXECUTED`.
+  //
+  // If you check all calls and check only `state_reverted` flag, you might be missing
+  // some balance changes and nonce changes. This is because when a full transaction fails
+  // in ethereum (e.g. `calls.all(x.state_reverted == true)`), there is still the transaction
+  // fee that are recorded to the chain.
+  //
+  // Refer to [TransactionTrace#status] field for more details about the handling you must
+  // perform.
   bool state_reverted = 30;
 
+  // Known Issues
+  // - Version 3:
+  //    1. The block's global ordinal when the call started executing, refer to
+  //      [Block] documentation for further information about ordinals and total ordering.
+  //    2. The transaction root call `begin_ordial` is always `0` (also in the GENESIS block), which can cause issues
+  //      when sorting by this field. To ensure proper execution order, set it as follows:
+  //      `trx.Calls[0].BeginOrdinal = trx.BeginOrdinal`.
+  //
+  //    Fixed in `Version 4`, see https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model for information about block versions.
   uint64 begin_ordinal = 31;
+
+  // Known Issues
+  // - Version 3:
+  //    1. The block's global ordinal when the call finished executing, refer to
+  //     [Block] documentation for further information about ordinals and total ordering.
+  //    2. The root call of the GENESIS block is always `0`. To fix it, you can set it as follows:
+  //     `rx.Calls[0].EndOrdinal = max.Uint64`.
+  //
+  //    Fixed in `Version 4`, see https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model for information about block versions.
   uint64 end_ordinal = 32;
 
-  repeated AccountCreation account_creations = 33;
+  // Known Issues
+  // - Version 4:
+  //    AccountCreations are NOT SUPPORTED anymore. DO NOT rely on them.
+  repeated AccountCreation account_creations = 33 [deprecated = true];
+
+  // The identifier 34 is taken by 'address_delegates_to' field above.
 
   reserved 50; // repeated ERC20BalanceChange erc20_balance_changes = 50 [deprecated = true];
   reserved 51; // repeated ERC20TransferEvent erc20_transfer_events = 51 [deprecated = true];
@@ -403,20 +814,42 @@ message StorageChange {
   bytes old_value = 3;
   bytes new_value = 4;
 
+  // The block's global ordinal when the storage change was recorded, refer to [Block]
+  // documentation for further information about ordinals and total ordering.
   uint64 ordinal = 5;
 }
 
 message BalanceChange {
+  // Address is the address of the account that has changed balance.
   bytes address = 1;
+
+  // OldValue is the balance of the address before the change. This value
+  // can be **nil/null/None** if there was no previous balance for the address.
+  // It is safe in those case(s) to consider the balance as being 0.
+  //
+  // If you consume this from a Substreams, you can safely use:
+  //
+  // ```ignore
+  //     let old_value = old_value.unwrap_or_default();
+  // ```
   BigInt old_value = 2;
-  BigInt new_value = 3;
-  Reason reason = 4;
 
-  // Obtain all balanche change reasons under deep mind repository:
+  // NewValue is the balance of the address after the change. This value
+  // can be **nil/null/None** if there was no previous balance for the address
+  // after the change. It is safe in those case(s) to consider the balance as being
+  // 0.
   //
-  // ```shell
-  // ack -ho 'BalanceChangeReason\(".*"\)' | grep -Eo '".*"' | sort | uniq
+  // If you consume this from a Substreams, you can safely use:
+  //
+  // ```ignore
+  //     let new_value = new_value.unwrap_or_default();
   // ```
+  BigInt new_value = 3;
+
+  // Reason is the reason why the balance has changed. This is useful to determine
+  // why the balance has changed and what is the context of the change.
+  Reason reason = 4;
+
   enum Reason {
     REASON_UNKNOWN = 0;
     REASON_REWARD_MINE_UNCLE = 1;
@@ -435,8 +868,20 @@ message BalanceChange {
     REASON_CALL_BALANCE_OVERRIDE = 12;
     // Used on chain(s) where some Ether burning happens
     REASON_BURN = 15;
+    REASON_WITHDRAWAL = 16;
+
+    // Rewards for Blob processing on BNB chain added in Tycho hard-fork, refers
+    // to BNB documentation to check the timestamp at which it was activated.
+    REASON_REWARD_BLOB_FEE = 17;
+
+    // This reason is used only on Optimism chain.
+    REASON_INCREASE_MINT = 18;
+    // This reason is used only on Optimism chain.
+    REASON_REVERT = 19;
   }
 
+  // The block's global ordinal when the balance change was recorded, refer to [Block]
+  // documentation for further information about ordinals and total ordering.
   uint64 ordinal = 5;
 }
 
@@ -444,11 +889,17 @@ message NonceChange {
   bytes address = 1;
   uint64 old_value = 2;
   uint64 new_value = 3;
+
+  // The block's global ordinal when the nonce change was recorded, refer to [Block]
+  // documentation for further information about ordinals and total ordering.
   uint64 ordinal = 4;
 }
 
 message AccountCreation {
   bytes account = 1;
+
+  // The block's global ordinal when the account creation was recorded, refer to [Block]
+  // documentation for further information about ordinals and total ordering.
   uint64 ordinal = 2;
 }
 
@@ -459,6 +910,8 @@ message CodeChange {
   bytes new_hash = 4;
   bytes new_code = 5;
 
+  // The block's global ordinal when the code change was recorded, refer to [Block]
+  // documentation for further information about ordinals and total ordering.
   uint64 ordinal = 6;
 }
 
@@ -473,36 +926,148 @@ message GasChange {
   uint64 new_value = 2;
   Reason reason = 3;
 
-  // Obtain all gas change reasons under deep mind repository:
-  //
-  // ```shell
-  // ack -ho 'GasChangeReason\(".*"\)' | grep -Eo '".*"' | sort | uniq
-  // ```
   enum Reason {
     REASON_UNKNOWN = 0;
+    // REASON_CALL is the amount of gas that will be charged for a 'CALL' opcode executed by the EVM
     REASON_CALL = 1;
+    // REASON_CALL_CODE is the amount of gas that will be charged for a 'CALLCODE' opcode executed by the EVM
     REASON_CALL_CODE = 2;
+    // REASON_CALL_DATA_COPY is the amount of gas that will be charged for a 'CALLDATACOPY' opcode executed by the EVM
     REASON_CALL_DATA_COPY = 3;
+    // REASON_CODE_COPY is the amount of gas that will be charged for a 'CALLDATACOPY' opcode executed by the EVM
     REASON_CODE_COPY = 4;
+    // REASON_CODE_STORAGE is the amount of gas that will be charged for code storage
     REASON_CODE_STORAGE = 5;
+    // REASON_CONTRACT_CREATION is the amount of gas that will be charged for a 'CREATE' opcode executed by the EVM and for the gas
+    // burned for a CREATE, today controlled by EIP150 rules
     REASON_CONTRACT_CREATION = 6;
+    // REASON_CONTRACT_CREATION2 is the amount of gas that will be charged for a 'CREATE2' opcode executed by the EVM and for the gas
+    // burned for a CREATE2, today controlled by EIP150 rules
     REASON_CONTRACT_CREATION2 = 7;
+    // REASON_DELEGATE_CALL is the amount of gas that will be charged for a 'DELEGATECALL' opcode executed by the EVM
     REASON_DELEGATE_CALL = 8;
+    // REASON_EVENT_LOG is the amount of gas that will be charged for a 'LOG<N>' opcode executed by the EVM
     REASON_EVENT_LOG = 9;
+    // REASON_EXT_CODE_COPY is the amount of gas that will be charged for a 'LOG<N>' opcode executed by the EVM
     REASON_EXT_CODE_COPY = 10;
+    // REASON_FAILED_EXECUTION is the burning of the remaining gas when the execution failed without a revert
     REASON_FAILED_EXECUTION = 11;
+    // REASON_INTRINSIC_GAS is the amount of gas that will be charged for the intrinsic cost of the transaction, there is
+    // always exactly one of those per transaction
     REASON_INTRINSIC_GAS = 12;
+    // GasChangePrecompiledContract is the amount of gas that will be charged for a precompiled contract execution
     REASON_PRECOMPILED_CONTRACT = 13;
+    // REASON_REFUND_AFTER_EXECUTION is the amount of gas that will be refunded to the caller after the execution of the call,
+    // if there is left over at the end of execution
     REASON_REFUND_AFTER_EXECUTION = 14;
+    // REASON_RETURN is the amount of gas that will be charged for a 'RETURN' opcode executed by the EVM
     REASON_RETURN = 15;
+    // REASON_RETURN_DATA_COPY is the amount of gas that will be charged for a 'RETURNDATACOPY' opcode executed by the EVM
     REASON_RETURN_DATA_COPY = 16;
+    // REASON_REVERT is the amount of gas that will be charged for a 'REVERT' opcode executed by the EVM
     REASON_REVERT = 17;
+    // REASON_SELF_DESTRUCT is the amount of gas that will be charged for a 'SELFDESTRUCT' opcode executed by the EVM
     REASON_SELF_DESTRUCT = 18;
+    // REASON_STATIC_CALL is the amount of gas that will be charged for a 'STATICALL' opcode executed by the EVM
     REASON_STATIC_CALL = 19;
 
+    // REASON_STATE_COLD_ACCESS is the amount of gas that will be charged for a cold storage access as controlled by EIP2929 rules
+    //
     // Added in Berlin fork (Geth 1.10+)
     REASON_STATE_COLD_ACCESS = 20;
+
+    // REASON_TX_INITIAL_BALANCE is the initial balance for the call which will be equal to the gasLimit of the call
+    //
+    // Added as new tracing reason in Geth, available only on some chains
+    REASON_TX_INITIAL_BALANCE = 21;
+    // REASON_TX_REFUNDS is the sum of all refunds which happened during the tx execution (e.g. storage slot being cleared)
+	  // this generates an increase in gas. There is only one such gas change per transaction.
+    //
+    // Added as new tracing reason in Geth, available only on some chains
+    REASON_TX_REFUNDS = 22;
+    // REASON_TX_LEFT_OVER_RETURNED is the amount of gas left over at the end of transaction's execution that will be returned
+    // to the chain. This change will always be a negative change as we "drain" left over gas towards 0. If there was no gas
+    // left at the end of execution, no such even will be emitted. The returned gas's value in Wei is returned to caller.
+    // There is at most one of such gas change per transaction.
+    //
+    // Added as new tracing reason in Geth, available only on some chains
+    REASON_TX_LEFT_OVER_RETURNED = 23;
+
+    // REASON_CALL_INITIAL_BALANCE is the initial balance for the call which will be equal to the gasLimit of the call. There is only
+	  // one such gas change per call.
+    //
+    // Added as new tracing reason in Geth, available only on some chains
+    REASON_CALL_INITIAL_BALANCE = 24;
+    // REASON_CALL_LEFT_OVER_RETURNED is the amount of gas left over that will be returned to the caller, this change will always
+    // be a negative change as we "drain" left over gas towards 0. If there was no gas left at the end of execution, no such even
+    // will be emitted.
+    REASON_CALL_LEFT_OVER_RETURNED = 25;
+
+    // REASON_WITNESS_CONTRACT_INIT flags the event of adding to the witness during the contract creation initialization step.
+    REASON_WITNESS_CONTRACT_INIT = 26;
+
+    // REASON_WITNESS_CONTRACT_CREATION flags the event of adding to the witness during the contract creation finalization step.
+    REASON_WITNESS_CONTRACT_CREATION = 27;
+    // REASON_WITNESS_CODE_CHUNK flags the event of adding one or more contract code chunks to the witness.
+    REASON_WITNESS_CODE_CHUNK = 28;
+    // REASON_WITNESS_CONTRACT_COLLISION_CHECK flags the event of adding to the witness when checking for contract address collision.
+    REASON_WITNESS_CONTRACT_COLLISION_CHECK = 29;
+    // REASON_TX_DATA_FLOOR is the amount of extra gas the transaction has to pay to reach the minimum gas requirement for the
+    // transaction data. This change will always be a negative change.
+    REASON_TX_DATA_FLOOR = 30;
   }
 
+  // The block's global ordinal when the gas change was recorded, refer to [Block]
+  // documentation for further information about ordinals and total ordering.
   uint64 ordinal = 4;
+}
+
+// HeaderOnlyBlock is used to optimally unpack the [Block] structure (note the
+// corresponding message number for the `header` field) while consuming less
+// memory, when only the `header` is desired.
+//
+// WARN: this is a client-side optimization pattern and should be moved in the
+// consuming code.
+message HeaderOnlyBlock {
+  BlockHeader header = 5;
+}
+
+// BlockWithRefs is a lightweight block, with traces and transactions
+// purged from the `block` within, and only.  It is used in transports
+// to pass block data around.
+message BlockWithRefs {
+  string id = 1;
+  Block block = 2;
+  TransactionRefs transaction_trace_refs = 3;
+  bool irreversible = 4;
+}
+
+message TransactionTraceWithBlockRef {
+  TransactionTrace trace = 1;
+  BlockRef block_ref = 2;
+}
+
+message TransactionRefs {
+  repeated bytes hashes = 1;
+}
+
+message BlockRef {
+  bytes hash = 1;
+  uint64 number = 2;
+}
+
+// Withdrawal represents a validator withdrawal from the beacon chain to the EVM.
+// Introduced in EIP-4895 (Shanghai hard fork).
+message Withdrawal {
+  // Index is the monotonically increasing identifier of the withdrawal
+  uint64 index = 1;
+
+  // ValidatorIndex is the index of the validator that is withdrawing
+  uint64 validator_index = 2;
+
+  // Address is the Ethereum address receiving the withdrawn funds
+  bytes address = 3;
+
+  // Amount is the value of the withdrawal in gwei (1 gwei = 1e9 wei)
+  uint64 amount = 4;
 }
\ No newline at end of file
diff --git a/chain/ethereum/src/adapter.rs b/chain/ethereum/src/adapter.rs
index db607a40233..d37d5ba81f7 100644
--- a/chain/ethereum/src/adapter.rs
+++ b/chain/ethereum/src/adapter.rs
@@ -1,20 +1,26 @@
 use anyhow::Error;
-use ethabi::{Error as ABIError, Function, ParamType, Token};
-use futures::Future;
+use async_trait::async_trait;
+use graph::abi;
 use graph::blockchain::ChainIdentifier;
+use graph::components::ethereum::AnyBlock;
+use graph::components::subgraph::MappingError;
+use graph::data::store::ethereum::call;
+use graph::data_source::common::ContractCall;
 use graph::firehose::CallToFilter;
 use graph::firehose::CombinedFilter;
 use graph::firehose::LogFilter;
+use graph::prelude::alloy::primitives::keccak256;
+use graph::prelude::alloy::primitives::{Address, B256};
+use graph::prelude::alloy::rpc::types::Log;
+use graph::prelude::alloy::transports::{RpcError, TransportErrorKind};
 use itertools::Itertools;
 use prost::Message;
 use prost_types::Any;
 use std::cmp;
 use std::collections::{HashMap, HashSet};
 use std::fmt;
-use std::marker::Unpin;
+use std::hash::Hash;
 use thiserror::Error;
-use tiny_keccak::keccak256;
-use web3::types::{Address, Log, H256};
 
 use graph::prelude::*;
 use graph::{
@@ -23,40 +29,115 @@ use graph::{
     petgraph::{self, graphmap::GraphMap},
 };
 
+use graph::blockchain::BlockPtr;
+
 const COMBINED_FILTER_TYPE_URL: &str =
     "type.googleapis.com/sf.ethereum.transform.v1.CombinedFilter";
 
 use crate::capabilities::NodeCapabilities;
 use crate::data_source::{BlockHandlerFilter, DataSource};
-use crate::{Chain, Mapping, ENV_VARS};
+use crate::{Chain, ENV_VARS, Mapping};
 
-pub type EventSignature = H256;
+pub type EventSignature = B256;
 pub type FunctionSelector = [u8; 4];
 
-#[derive(Clone, Debug)]
-pub struct EthereumContractCall {
-    pub address: Address,
-    pub block_ptr: BlockPtr,
-    pub function: Function,
-    pub args: Vec<Token>,
-    pub gas: Option<u32>,
+/// `EventSignatureWithTopics` is used to match events with
+/// indexed arguments when they are defined in the subgraph
+/// manifest.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventSignatureWithTopics {
+    pub address: Option<Address>,
+    pub signature: B256,
+    pub topic1: Option<Vec<B256>>,
+    pub topic2: Option<Vec<B256>>,
+    pub topic3: Option<Vec<B256>>,
+}
+
+impl EventSignatureWithTopics {
+    pub fn new(
+        address: Option<Address>,
+        signature: B256,
+        topic1: Option<Vec<B256>>,
+        topic2: Option<Vec<B256>>,
+        topic3: Option<Vec<B256>>,
+    ) -> Self {
+        EventSignatureWithTopics {
+            address,
+            signature,
+            topic1,
+            topic2,
+            topic3,
+        }
+    }
+
+    /// Checks if an event matches the `EventSignatureWithTopics`
+    /// If self.address is None, it's considered a wildcard match.
+    /// Otherwise, it must match the provided address.
+    /// It must also match the topics if they are Some
+    pub fn matches(&self, address: Option<&Address>, sig: B256, topics: &[B256]) -> bool {
+        // If self.address is None, it's considered a wildcard match. Otherwise, it must match the provided address.
+        let address_matches = match self.address {
+            Some(ref self_addr) => address == Some(self_addr),
+            None => true, // self.address is None, so it matches any address.
+        };
+
+        address_matches
+            && self.signature == sig
+            && self
+                .topic1
+                .as_ref()
+                .is_none_or(|t1| topics.get(1).is_some_and(|topic| t1.contains(topic)))
+            && self
+                .topic2
+                .as_ref()
+                .is_none_or(|t2| topics.get(2).is_some_and(|topic| t2.contains(topic)))
+            && self
+                .topic3
+                .as_ref()
+                .is_none_or(|t3| topics.get(3).is_some_and(|topic| t3.contains(topic)))
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum EthereumRpcError {
+    #[error("call error: {0}")]
+    AlloyError(RpcError<TransportErrorKind>),
+    #[error("ethereum node took too long to perform call")]
+    Timeout,
 }
 
 #[derive(Error, Debug)]
-pub enum EthereumContractCallError {
-    #[error("ABI error: {0}")]
-    ABIError(#[from] ABIError),
-    /// `Token` is not of expected `ParamType`
-    #[error("type mismatch, token {0:?} is not of kind {1:?}")]
-    TypeError(Token, ParamType),
-    #[error("error encoding input call data: {0}")]
-    EncodingError(ethabi::Error),
+pub enum ContractCallError {
+    #[error("ABI error: {0:#}")]
+    ABIError(anyhow::Error),
+    #[error("type mismatch, decoded value {0:?} is not of kind {1:?}")]
+    TypeError(abi::DynSolValue, abi::DynSolType),
+    #[error("error encoding input call data: {0:#}")]
+    EncodingError(anyhow::Error),
     #[error("call error: {0}")]
-    Web3Error(web3::Error),
-    #[error("call reverted: {0}")]
-    Revert(String),
+    AlloyError(RpcError<TransportErrorKind>),
     #[error("ethereum node took too long to perform call")]
     Timeout,
+    #[error("internal error: {0}")]
+    Internal(String),
+}
+
+impl From<ContractCallError> for MappingError {
+    fn from(e: ContractCallError) -> Self {
+        match e {
+            // Any error reported by the Ethereum node could be due to the block no longer being on
+            // the main chain. This is very unespecific but we don't want to risk failing a
+            // subgraph due to a transient error such as a reorg.
+            ContractCallError::AlloyError(e) => MappingError::PossibleReorg(anyhow::anyhow!(
+                "Ethereum node returned an error for an eth_call: {e}"
+            )),
+            // Also retry on timeouts.
+            ContractCallError::Timeout => MappingError::PossibleReorg(anyhow::anyhow!(
+                "Ethereum node did not respond in time to eth_call"
+            )),
+            e => MappingError::Unknown(anyhow::anyhow!("Error when making an eth_call: {e}")),
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]
@@ -69,44 +150,104 @@ enum LogFilterNode {
 #[derive(Clone, Debug)]
 pub struct EthGetLogsFilter {
     pub contracts: Vec<Address>,
-    pub event_signatures: Vec<EventSignature>,
+    pub event_signatures: Vec<B256>,
+    pub topic1: Option<Vec<B256>>,
+    pub topic2: Option<Vec<B256>>,
+    pub topic3: Option<Vec<B256>>,
 }
 
 impl EthGetLogsFilter {
+    /// Convert to alloy Filter for the given block range
+    pub fn to_alloy_filter(&self, from: BlockNumber, to: BlockNumber) -> alloy::rpc::types::Filter {
+        let mut filter_builder = alloy::rpc::types::Filter::new()
+            .from_block(alloy::rpc::types::BlockNumberOrTag::Number(from as u64))
+            .to_block(alloy::rpc::types::BlockNumberOrTag::Number(to as u64))
+            .address(self.contracts.clone())
+            .event_signature(self.event_signatures.clone());
+
+        if let Some(ref topic1) = self.topic1 {
+            filter_builder = filter_builder.topic1(topic1.clone());
+        }
+        if let Some(ref topic2) = self.topic2 {
+            filter_builder = filter_builder.topic2(topic2.clone());
+        }
+        if let Some(ref topic3) = self.topic3 {
+            filter_builder = filter_builder.topic3(topic3.clone());
+        }
+
+        filter_builder
+    }
+
     fn from_contract(address: Address) -> Self {
         EthGetLogsFilter {
             contracts: vec![address],
             event_signatures: vec![],
+            topic1: None,
+            topic2: None,
+            topic3: None,
         }
     }
 
-    fn from_event(event: EventSignature) -> Self {
+    fn from_event(event: B256) -> Self {
         EthGetLogsFilter {
             contracts: vec![],
             event_signatures: vec![event],
+            topic1: None,
+            topic2: None,
+            topic3: None,
+        }
+    }
+
+    fn from_event_with_topics(event: EventSignatureWithTopics) -> Self {
+        EthGetLogsFilter {
+            contracts: event.address.map_or(vec![], |a| vec![a]),
+            event_signatures: vec![event.signature],
+            topic1: event.topic1,
+            topic2: event.topic2,
+            topic3: event.topic3,
         }
     }
 }
 
 impl fmt::Display for EthGetLogsFilter {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.contracts.len() == 1 {
-            write!(
-                f,
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let base_msg = if self.contracts.len() == 1 {
+            format!(
                 "contract {:?}, {} events",
                 self.contracts[0],
                 self.event_signatures.len()
             )
         } else if self.event_signatures.len() == 1 {
-            write!(
-                f,
+            format!(
                 "event {:?}, {} contracts",
                 self.event_signatures[0],
                 self.contracts.len()
             )
         } else {
-            write!(f, "unreachable")
-        }
+            "unspecified filter".to_string()
+        };
+
+        // Helper to format topics as strings
+        let format_topics = |topics: &Option<Vec<B256>>| -> String {
+            topics.as_ref().map_or_else(
+                || "None".to_string(),
+                |ts| {
+                    let signatures: Vec<String> = ts.iter().map(|t| format!("{:?}", t)).collect();
+                    signatures.join(", ")
+                },
+            )
+        };
+
+        // Constructing topic strings
+        let topics_msg = format!(
+            ", topic1: [{}], topic2: [{}], topic3: [{}]",
+            format_topics(&self.topic1),
+            format_topics(&self.topic2),
+            format_topics(&self.topic3),
+        );
+
+        // Combine the base message with topic information
+        write!(f, "{}{}", base_msg, topics_msg)
     }
 }
 
@@ -178,6 +319,11 @@ impl bc::TriggerFilter<Chain> for TriggerFilter {
             trigger_every_block,
         } = self.block.clone();
 
+        // If polling_intervals is empty this will return true, else it will be true only if all intervals are 0
+        // ie: All triggers are initialization handlers. We do not need firehose to send all block headers for
+        // initialization handlers
+        let has_initilization_triggers_only = polling_intervals.iter().all(|(_, i)| *i == 0);
+
         let log_filters: Vec<LogFilter> = self.log.into();
         let mut call_filters: Vec<CallToFilter> = self.call.into();
         call_filters.extend(Into::<Vec<CallToFilter>>::into(self.block));
@@ -189,7 +335,9 @@ impl bc::TriggerFilter<Chain> for TriggerFilter {
         let combined_filter = CombinedFilter {
             log_filters,
             call_filters,
-            send_all_block_headers: trigger_every_block || !polling_intervals.is_empty(),
+            // We need firehose to send all block headers when `trigger_every_block` is true and when
+            // We have polling triggers which are not from initiallization handlers
+            send_all_block_headers: trigger_every_block || !has_initilization_triggers_only,
         };
 
         vec![Any {
@@ -204,29 +352,131 @@ pub struct EthereumLogFilter {
     /// Log filters can be represented as a bipartite graph between contracts and events. An edge
     /// exists between a contract and an event if a data source for the contract has a trigger for
     /// the event.
-    /// Edges are of `bool` type and indicates when a trigger requires a transaction receipt.
-    contracts_and_events_graph: GraphMap<LogFilterNode, bool, petgraph::Undirected>,
+    /// Edge weights are booleans indicating whether the trigger requires a transaction receipt.
+    contracts_and_events_graph: MergeGraph,
 
     /// Event sigs with no associated address, matching on all addresses.
-    /// Maps to a boolean representing if a trigger requires a transaction receipt.
-    wildcard_events: HashMap<EventSignature, bool>,
+    /// Values are booleans indicating whether the trigger requires a transaction receipt.
+    wildcard_events: MergeMap<EventSignature>,
+    /// Events with any of the topic filters set.
+    /// Values are booleans indicating whether the trigger requires a transaction receipt.
+    events_with_topic_filters: MergeMap<EventSignatureWithTopics>,
+}
+
+/// `HashMap<K, bool>` wrapper whose values are OR-merged on every write.
+///
+/// The only mutator that writes values is [`MergeMap::or_insert`] — the inner
+/// `HashMap` is private so callers cannot bypass the merge via
+/// `HashMap::insert`. Used by `EthereumLogFilter` to track per-key receipt
+/// requirements where any handler asking for a receipt at a given key forces
+/// receipt fetching.
+#[derive(Clone, Debug)]
+struct MergeMap<K: Eq + Hash>(HashMap<K, bool>);
+
+impl<K: Eq + Hash> Default for MergeMap<K> {
+    fn default() -> Self {
+        Self(HashMap::new())
+    }
+}
+
+impl<K: Eq + Hash> MergeMap<K> {
+    fn or_insert(&mut self, k: K, v: bool) {
+        self.0.entry(k).and_modify(|e| *e |= v).or_insert(v);
+    }
+
+    fn get(&self, k: &K) -> Option<&bool> {
+        self.0.get(k)
+    }
+
+    fn contains_key(&self, k: &K) -> bool {
+        self.0.contains_key(k)
+    }
+
+    fn iter(&self) -> impl Iterator<Item = (&K, &bool)> + '_ {
+        self.0.iter()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl<K: Eq + Hash> IntoIterator for MergeMap<K> {
+    type Item = (K, bool);
+    type IntoIter = std::collections::hash_map::IntoIter<K, bool>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+/// `GraphMap<LogFilterNode, bool, _>` wrapper that OR-merges edge weights on
+/// every write.
+///
+/// The only mutator that writes edge weights is [`MergeGraph::or_add_edge`] —
+/// the inner `GraphMap` is private so callers cannot bypass the merge via
+/// `GraphMap::add_edge`.
+#[derive(Clone, Debug)]
+struct MergeGraph(GraphMap<LogFilterNode, bool, petgraph::Undirected>);
+
+impl Default for MergeGraph {
+    fn default() -> Self {
+        Self(GraphMap::new())
+    }
+}
+
+impl MergeGraph {
+    fn or_add_edge(&mut self, a: LogFilterNode, b: LogFilterNode, v: bool) {
+        // Short-circuit on `v == true`: a `true` weight always wins over any
+        // prior weight, so we can skip the edge_weight lookup entirely.
+        let merged = v || self.0.edge_weight(a, b).copied().unwrap_or(false);
+        self.0.add_edge(a, b, merged);
+    }
+
+    fn edge_weight(&self, a: LogFilterNode, b: LogFilterNode) -> Option<&bool> {
+        self.0.edge_weight(a, b)
+    }
+
+    fn contains_edge(&self, a: LogFilterNode, b: LogFilterNode) -> bool {
+        self.0.contains_edge(a, b)
+    }
+
+    fn edge_count(&self) -> usize {
+        self.0.edge_count()
+    }
+
+    fn nodes(&self) -> impl Iterator<Item = LogFilterNode> + '_ {
+        self.0.nodes()
+    }
+
+    fn neighbors(&self, n: LogFilterNode) -> impl Iterator<Item = LogFilterNode> + '_ {
+        self.0.neighbors(n)
+    }
+
+    fn remove_node(&mut self, n: LogFilterNode) -> bool {
+        self.0.remove_node(n)
+    }
+
+    fn all_edges(&self) -> impl Iterator<Item = (LogFilterNode, LogFilterNode, &bool)> {
+        self.0.all_edges()
+    }
 }
 
 impl From<EthereumLogFilter> for Vec<LogFilter> {
     fn from(val: EthereumLogFilter) -> Self {
-        val.eth_get_logs_filters()
+        val.eth_get_logs_filters(ENV_VARS.get_logs_max_contracts)
             .map(
                 |EthGetLogsFilter {
                      contracts,
                      event_signatures,
+                     .. // TODO: Handle events with topic filters for firehose
                  }| LogFilter {
                     addresses: contracts
                         .iter()
-                        .map(|addr| addr.to_fixed_bytes().to_vec())
+                        .map(|addr| addr.to_vec())
                         .collect_vec(),
                     event_signatures: event_signatures
                         .iter()
-                        .map(|sig| sig.to_fixed_bytes().to_vec())
+                        .map(|sig| sig.to_vec())
                         .collect_vec(),
                 },
             )
@@ -238,19 +488,22 @@ impl EthereumLogFilter {
     /// Check if this filter matches the specified `Log`.
     pub fn matches(&self, log: &Log) -> bool {
         // First topic should be event sig
-        match log.topics.first() {
+        match log.topics().first() {
             None => false,
 
             Some(sig) => {
                 // The `Log` matches the filter either if the filter contains
                 // a (contract address, event signature) pair that matches the
                 // `Log`, or if the filter contains wildcard event that matches.
-                let contract = LogFilterNode::Contract(log.address);
+                let contract = LogFilterNode::Contract(log.address());
                 let event = LogFilterNode::Event(*sig);
                 self.contracts_and_events_graph
-                    .all_edges()
-                    .any(|(s, t, _)| (s == contract && t == event) || (t == contract && s == event))
+                    .contains_edge(contract, event)
                     || self.wildcard_events.contains_key(sig)
+                    || self
+                        .events_with_topic_filters
+                        .iter()
+                        .any(|(e, _)| e.matches(Some(&log.address()), *sig, log.topics()))
             }
         }
     }
@@ -258,22 +511,43 @@ impl EthereumLogFilter {
     /// Similar to [`matches`], checks if a transaction receipt is required for this log filter.
     pub fn requires_transaction_receipt(
         &self,
-        event_signature: &H256,
+        event_signature: &B256,
         contract_address: Option<&Address>,
+        topics: &[B256],
     ) -> bool {
-        if let Some(true) = self.wildcard_events.get(event_signature) {
-            true
-        } else if let Some(address) = contract_address {
-            let contract = LogFilterNode::Contract(*address);
-            let event = LogFilterNode::Event(*event_signature);
-            self.contracts_and_events_graph
-                .all_edges()
-                .any(|(s, t, r)| {
-                    *r && (s == contract && t == event) || (t == contract && s == event)
-                })
-        } else {
-            false
+        // Check for wildcard events first.
+        if self.wildcard_events.get(event_signature) == Some(&true) {
+            return true;
+        }
+
+        // Next, check events with topic filters.
+        if self
+            .events_with_topic_filters
+            .iter()
+            .any(|(event_with_topics, &requires_receipt)| {
+                requires_receipt
+                    && event_with_topics.matches(contract_address, *event_signature, topics)
+            })
+        {
+            return true;
+        }
+
+        // Finally, check the contracts_and_events_graph if a contract address is specified.
+        if let Some(address) = contract_address {
+            let contract_node = LogFilterNode::Contract(*address);
+            let event_node = LogFilterNode::Event(*event_signature);
+
+            if self
+                .contracts_and_events_graph
+                .edge_weight(contract_node, event_node)
+                == Some(&true)
+            {
+                return true;
+            }
         }
+
+        // If none of the conditions above match, return false.
+        false
     }
 
     pub fn from_data_sources<'a>(iter: impl IntoIterator<Item = &'a DataSource>) -> Self {
@@ -282,16 +556,42 @@ impl EthereumLogFilter {
             for event_handler in ds.mapping.event_handlers.iter() {
                 let event_sig = event_handler.topic0();
                 match ds.address {
-                    Some(contract) => {
-                        this.contracts_and_events_graph.add_edge(
+                    Some(contract) if !event_handler.has_additional_topics() => {
+                        this.contracts_and_events_graph.or_add_edge(
                             LogFilterNode::Contract(contract),
                             LogFilterNode::Event(event_sig),
                             event_handler.receipt,
                         );
                     }
-                    None => {
+                    Some(contract) => {
+                        this.events_with_topic_filters.or_insert(
+                            EventSignatureWithTopics::new(
+                                Some(contract),
+                                event_sig,
+                                event_handler.topic1.clone(),
+                                event_handler.topic2.clone(),
+                                event_handler.topic3.clone(),
+                            ),
+                            event_handler.receipt,
+                        );
+                    }
+
+                    None if (!event_handler.has_additional_topics()) => {
                         this.wildcard_events
-                            .insert(event_sig, event_handler.receipt);
+                            .or_insert(event_sig, event_handler.receipt);
+                    }
+
+                    None => {
+                        this.events_with_topic_filters.or_insert(
+                            EventSignatureWithTopics::new(
+                                ds.address,
+                                event_sig,
+                                event_handler.topic1.clone(),
+                                event_handler.topic2.clone(),
+                                event_handler.topic3.clone(),
+                            ),
+                            event_handler.receipt,
+                        );
                     }
                 }
             }
@@ -304,12 +604,18 @@ impl EthereumLogFilter {
         for event_handler in &mapping.event_handlers {
             let signature = event_handler.topic0();
             this.wildcard_events
-                .insert(signature, event_handler.receipt);
+                .or_insert(signature, event_handler.receipt);
         }
         this
     }
 
     /// Extends this log filter with another one.
+    ///
+    /// The `receipt` flag stored at each filter key is OR-combined across the
+    /// two filters: a key whose receipt requirement is `true` in either filter
+    /// stays `true` in the merged result. Overwriting with the incoming value
+    /// would drop a prior `true` and silently downgrade receipt fetching for
+    /// any handler that declared `receipt: true` at that key.
     pub fn extend(&mut self, other: EthereumLogFilter) {
         if other.is_empty() {
             return;
@@ -319,11 +625,17 @@ impl EthereumLogFilter {
         let EthereumLogFilter {
             contracts_and_events_graph,
             wildcard_events,
+            events_with_topic_filters,
         } = other;
         for (s, t, e) in contracts_and_events_graph.all_edges() {
-            self.contracts_and_events_graph.add_edge(s, t, *e);
+            self.contracts_and_events_graph.or_add_edge(s, t, *e);
+        }
+        for (k, v) in wildcard_events {
+            self.wildcard_events.or_insert(k, v);
+        }
+        for (k, v) in events_with_topic_filters {
+            self.events_with_topic_filters.or_insert(k, v);
         }
-        self.wildcard_events.extend(wildcard_events);
     }
 
     /// An empty filter is one that never matches.
@@ -332,20 +644,35 @@ impl EthereumLogFilter {
         let EthereumLogFilter {
             contracts_and_events_graph,
             wildcard_events,
+            events_with_topic_filters,
         } = self;
-        contracts_and_events_graph.edge_count() == 0 && wildcard_events.is_empty()
+        contracts_and_events_graph.edge_count() == 0
+            && wildcard_events.is_empty()
+            && events_with_topic_filters.is_empty()
     }
 
     /// Filters for `eth_getLogs` calls. The filters will not return false positives. This attempts
     /// to balance between having granular filters but too many calls and having few calls but too
     /// broad filters causing the Ethereum endpoint to timeout.
-    pub fn eth_get_logs_filters(self) -> impl Iterator<Item = EthGetLogsFilter> {
+    pub fn eth_get_logs_filters(
+        self,
+        get_logs_max_contracts: usize,
+    ) -> impl Iterator<Item = EthGetLogsFilter> {
+        let mut filters = Vec::new();
+
         // Start with the wildcard event filters.
-        let mut filters = self
-            .wildcard_events
-            .into_keys()
-            .map(EthGetLogsFilter::from_event)
-            .collect_vec();
+        filters.extend(
+            self.wildcard_events
+                .into_iter()
+                .map(|(k, _)| EthGetLogsFilter::from_event(k)),
+        );
+
+        // Handle events with topic filters.
+        filters.extend(
+            self.events_with_topic_filters
+                .into_iter()
+                .map(|(k, _)| EthGetLogsFilter::from_event_with_topics(k)),
+        );
 
         // The current algorithm is to repeatedly find the maximum cardinality vertex and turn all
         // of its edges into a filter. This is nice because it is neutral between filtering by
@@ -380,7 +707,7 @@ impl EthereumLogFilter {
             for neighbor in g.neighbors(max_vertex) {
                 match neighbor {
                     LogFilterNode::Contract(address) => {
-                        if filter.contracts.len() == ENV_VARS.get_logs_max_contracts {
+                        if filter.contracts.len() == get_logs_max_contracts {
                             // The batch size was reached, register the filter and start a new one.
                             let event = filter.event_signatures[0];
                             push_filter(filter);
@@ -419,21 +746,21 @@ pub struct EthereumCallFilter {
     pub wildcard_signatures: HashSet<FunctionSelector>,
 }
 
-impl Into<Vec<CallToFilter>> for EthereumCallFilter {
-    fn into(self) -> Vec<CallToFilter> {
-        if self.is_empty() {
+impl From<EthereumCallFilter> for Vec<CallToFilter> {
+    fn from(val: EthereumCallFilter) -> Self {
+        if val.is_empty() {
             return Vec::new();
         }
 
         let EthereumCallFilter {
             contract_addresses_function_signatures,
             wildcard_signatures,
-        } = self;
+        } = val;
 
         let mut filters: Vec<CallToFilter> = contract_addresses_function_signatures
             .into_iter()
             .map(|(addr, (_, sigs))| CallToFilter {
-                addresses: vec![addr.to_fixed_bytes().to_vec()],
+                addresses: vec![addr.to_vec()],
                 signatures: sigs.into_iter().map(|x| x.to_vec()).collect_vec(),
             })
             .collect();
@@ -574,16 +901,13 @@ impl FromIterator<(BlockNumber, Address, FunctionSelector)> for EthereumCallFilt
         let mut lookup: HashMap<Address, (BlockNumber, HashSet<FunctionSelector>)> = HashMap::new();
         iter.into_iter()
             .for_each(|(start_block, address, function_signature)| {
-                lookup
+                let entry = lookup
                     .entry(address)
                     .or_insert((start_block, HashSet::default()));
-                lookup.get_mut(&address).map(|set| {
-                    if set.0 > start_block {
-                        set.0 = start_block
-                    }
-                    set.1.insert(function_signature);
-                    set
-                });
+                if entry.0 > start_block {
+                    entry.0 = start_block;
+                }
+                entry.1.insert(function_signature);
             });
         EthereumCallFilter {
             contract_addresses_function_signatures: lookup,
@@ -615,15 +939,15 @@ pub struct EthereumBlockFilter {
     pub trigger_every_block: bool,
 }
 
-impl Into<Vec<CallToFilter>> for EthereumBlockFilter {
-    fn into(self) -> Vec<CallToFilter> {
-        self.contract_addresses
+impl From<EthereumBlockFilter> for Vec<CallToFilter> {
+    fn from(val: EthereumBlockFilter) -> Self {
+        val.contract_addresses
             .into_iter()
             .map(|(_, addr)| addr)
             .sorted()
             .dedup_by(|x, y| x == y)
             .map(|addr| CallToFilter {
-                addresses: vec![addr.to_fixed_bytes().to_vec()],
+                addresses: vec![addr.to_vec()],
                 signatures: vec![],
             })
             .collect_vec()
@@ -652,9 +976,8 @@ impl EthereumBlockFilter {
                     .block_handlers
                     .clone()
                     .into_iter()
-                    .any(|block_handler| match block_handler.filter {
-                        Some(BlockHandlerFilter::Call) => true,
-                        _ => false,
+                    .any(|block_handler| {
+                        matches!(block_handler.filter, Some(BlockHandlerFilter::Call))
                     });
 
                 let has_block_handler_without_filter = data_source
@@ -861,13 +1184,13 @@ impl SubgraphEthRpcMetrics {
 
     pub fn observe_request(&self, duration: f64, method: &str, provider: &str) {
         self.request_duration
-            .with_label_values(&[&self.deployment, method, provider])
+            .with_label_values(&[self.deployment.as_str(), method, provider])
             .set(duration);
     }
 
     pub fn add_error(&self, method: &str, provider: &str) {
         self.errors
-            .with_label_values(&[&self.deployment, method, provider])
+            .with_label_values(&[self.deployment.as_str(), method, provider])
             .inc();
     }
 }
@@ -885,23 +1208,8 @@ pub trait EthereumAdapter: Send + Sync + 'static {
     /// connected to.
     async fn net_identifiers(&self) -> Result<ChainIdentifier, Error>;
 
-    /// Get the latest block, including full transactions.
-    fn latest_block(
-        &self,
-        logger: &Logger,
-    ) -> Box<dyn Future<Item = LightEthereumBlock, Error = bc::IngestorError> + Send + Unpin>;
-
     /// Get the latest block, with only the header and transaction hashes.
-    fn latest_block_header(
-        &self,
-        logger: &Logger,
-    ) -> Box<dyn Future<Item = web3::types::Block<H256>, Error = bc::IngestorError> + Send>;
-
-    fn load_block(
-        &self,
-        logger: &Logger,
-        block_hash: H256,
-    ) -> Box<dyn Future<Item = LightEthereumBlock, Error = Error> + Send>;
+    async fn latest_block_ptr(&self, logger: &Logger) -> Result<BlockPtr, bc::IngestorError>;
 
     /// Load Ethereum blocks in bulk, returning results as they come back as a Stream.
     /// May use the `chain_store` as a cache.
@@ -909,74 +1217,93 @@ pub trait EthereumAdapter: Send + Sync + 'static {
         &self,
         logger: Logger,
         chain_store: Arc<dyn ChainStore>,
-        block_hashes: HashSet<H256>,
-    ) -> Box<dyn Stream<Item = Arc<LightEthereumBlock>, Error = Error> + Send>;
+        block_hashes: HashSet<B256>,
+    ) -> Result<Vec<Arc<LightEthereumBlock>>, Error>;
 
     /// Find a block by its hash.
-    fn block_by_hash(
+    async fn block_by_hash(
         &self,
         logger: &Logger,
-        block_hash: H256,
-    ) -> Box<dyn Future<Item = Option<LightEthereumBlock>, Error = Error> + Send>;
+        block_hash: B256,
+    ) -> Result<Option<AnyBlock>, Error>;
 
-    fn block_by_number(
+    async fn block_by_number(
         &self,
         logger: &Logger,
         block_number: BlockNumber,
-    ) -> Box<dyn Future<Item = Option<LightEthereumBlock>, Error = Error> + Send>;
+    ) -> Result<Option<AnyBlock>, Error>;
 
     /// Load full information for the specified `block` (in particular, transaction receipts).
-    fn load_full_block(
+    async fn load_full_block(
         &self,
         logger: &Logger,
-        block: LightEthereumBlock,
-    ) -> Pin<Box<dyn std::future::Future<Output = Result<EthereumBlock, bc::IngestorError>> + Send>>;
+        block: AnyBlock,
+    ) -> Result<EthereumBlock, bc::IngestorError>;
 
-    /// Load block pointer for the specified `block number`.
-    fn block_pointer_from_number(
+    /// Finds the hash and number of the lowest non-null block with height greater than or equal to
+    /// the given number.
+    ///
+    /// Note that the same caveats on reorgs apply as for `block_hash_by_block_number`, and must
+    /// also be considered for the resolved block, in case it is higher than the requested number.
+    async fn next_existing_ptr_to_number(
         &self,
         logger: &Logger,
         block_number: BlockNumber,
-    ) -> Box<dyn Future<Item = BlockPtr, Error = bc::IngestorError> + Send>;
+    ) -> Result<BlockPtr, Error>;
 
-    /// Find a block by its number, according to the Ethereum node.
-    ///
-    /// Careful: don't use this function without considering race conditions.
-    /// Chain reorgs could happen at any time, and could affect the answer received.
-    /// Generally, it is only safe to use this function with blocks that have received enough
-    /// confirmations to guarantee no further reorgs, **and** where the Ethereum node is aware of
-    /// those confirmations.
-    /// If the Ethereum node is far behind in processing blocks, even old blocks can be subject to
-    /// reorgs.
-    fn block_hash_by_block_number(
+    /// Call the function of a smart contract. A return of `None` indicates
+    /// that the call reverted. The returned `CallSource` indicates where
+    /// the result came from for accounting purposes
+    async fn contract_call(
         &self,
         logger: &Logger,
-        block_number: BlockNumber,
-    ) -> Box<dyn Future<Item = Option<H256>, Error = Error> + Send>;
+        call: &ContractCall,
+        cache: Arc<dyn EthereumCallCache>,
+    ) -> Result<(Option<Vec<abi::DynSolValue>>, call::Source), ContractCallError>;
 
-    /// Call the function of a smart contract.
-    fn contract_call(
+    /// Make multiple contract calls in a single batch. The returned `Vec`
+    /// has results in the same order as the calls in `calls` on input. The
+    /// calls must all be for the same block
+    async fn contract_calls(
         &self,
         logger: &Logger,
-        call: EthereumContractCall,
+        calls: &[&ContractCall],
         cache: Arc<dyn EthereumCallCache>,
-    ) -> Box<dyn Future<Item = Vec<Token>, Error = EthereumContractCallError> + Send>;
+    ) -> Result<Vec<(Option<Vec<abi::DynSolValue>>, call::Source)>, ContractCallError>;
+
+    async fn get_balance(
+        &self,
+        logger: &Logger,
+        address: Address,
+        block_ptr: BlockPtr,
+    ) -> Result<alloy::primitives::U256, EthereumRpcError>;
+
+    // Returns the compiled bytecode of a smart contract
+    async fn get_code(
+        &self,
+        logger: &Logger,
+        address: Address,
+        block_ptr: BlockPtr,
+    ) -> Result<alloy::primitives::Bytes, EthereumRpcError>;
+
+    /// Returns a boolean indicating whether the adapter can reach
+    /// the RPC provider it is configured to use.
+    /// This is used to determine if a provider should be considered healthy.
+    async fn is_reachable(&self) -> bool;
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::adapter::{FunctionSelector, COMBINED_FILTER_TYPE_URL};
+    use crate::adapter::{COMBINED_FILTER_TYPE_URL, FunctionSelector};
 
     use super::{EthereumBlockFilter, LogFilterNode};
     use super::{EthereumCallFilter, EthereumLogFilter, TriggerFilter};
 
+    use base64::prelude::*;
     use graph::blockchain::TriggerFilter as _;
     use graph::firehose::{CallToFilter, CombinedFilter, LogFilter, MultiLogFilter};
-    use graph::petgraph::graphmap::GraphMap;
-    use graph::prelude::ethabi::ethereum_types::H256;
-    use graph::prelude::web3::types::Address;
-    use graph::prelude::web3::types::Bytes;
     use graph::prelude::EthereumCall;
+    use graph::prelude::alloy::primitives::{Address, B256, Bytes, U256};
     use hex::ToHex;
     use itertools::Itertools;
     use prost::Message;
@@ -1002,7 +1329,7 @@ mod tests {
             .map(|addr| {
                 format!(
                     "0x{}",
-                    H256::from_str(addr)
+                    B256::from_str(addr)
                         .expect("unable to parse addr")
                         .encode_hex::<String>()
                 )
@@ -1013,16 +1340,11 @@ mod tests {
 
         let sigs = event_sigs
             .iter()
-            .map(|addr| {
-                H256::from_str(addr)
-                    .expect("unable to parse addr")
-                    .to_fixed_bytes()
-                    .to_vec()
-            })
+            .map(|addr| B256::from_str(addr).expect("unable to parse addr").to_vec())
             .collect_vec();
 
         let filter = LogFilter {
-            addresses: vec![address.to_fixed_bytes().to_vec()],
+            addresses: vec![address.to_vec()],
             event_signatures: sigs,
         };
         // This base64 was provided by Streamingfast as a binding example of the expected encoded for the
@@ -1033,7 +1355,7 @@ mod tests {
             log_filters: vec![filter],
         };
 
-        let output = base64::encode(filter.encode_to_vec());
+        let output = BASE64_STANDARD.encode(filter.encode_to_vec());
         assert_eq!(expected_base64, output);
     }
 
@@ -1049,10 +1371,11 @@ mod tests {
         assert_eq!(sig, actual_sig);
 
         let filter = LogFilter {
-            addresses: vec![Address::from_str(hex_addr)
-                .expect("failed to parse address")
-                .to_fixed_bytes()
-                .to_vec()],
+            addresses: vec![
+                Address::from_str(hex_addr)
+                    .expect("failed to parse address")
+                    .to_vec(),
+            ],
             event_signatures: vec![fs.to_vec()],
         };
 
@@ -1060,19 +1383,15 @@ mod tests {
         // addresses and signatures above.
         let expected_base64 = "ChTu0rd1bilakwDlPdBJrrB1GJm64xIEqQWcuw==";
 
-        let output = base64::encode(filter.encode_to_vec());
+        let output = BASE64_STANDARD.encode(filter.encode_to_vec());
         assert_eq!(expected_base64, output);
     }
 
     #[test]
     fn ethereum_trigger_filter_to_firehose() {
-        let address = Address::from_low_u64_be;
-        let sig = H256::from_low_u64_le;
+        let sig = |value: u64| B256::from(U256::from(value));
         let mut filter = TriggerFilter {
-            log: EthereumLogFilter {
-                contracts_and_events_graph: GraphMap::new(),
-                wildcard_events: HashMap::new(),
-            },
+            log: EthereumLogFilter::default(),
             call: EthereumCallFilter {
                 contract_addresses_function_signatures: HashMap::from_iter(vec![
                     (address(0), (0, HashSet::from_iter(vec![[0u8; 4]]))),
@@ -1096,42 +1415,42 @@ mod tests {
 
         let expected_call_filters = vec![
             CallToFilter {
-                addresses: vec![address(0).to_fixed_bytes().to_vec()],
+                addresses: vec![address(0).to_vec()],
                 signatures: vec![[0u8; 4].to_vec()],
             },
             CallToFilter {
-                addresses: vec![address(1).to_fixed_bytes().to_vec()],
+                addresses: vec![address(1).to_vec()],
                 signatures: vec![[1u8; 4].to_vec()],
             },
             CallToFilter {
-                addresses: vec![address(2).to_fixed_bytes().to_vec()],
+                addresses: vec![address(2).to_vec()],
                 signatures: vec![],
             },
             CallToFilter {
-                addresses: vec![address(1000).to_fixed_bytes().to_vec()],
+                addresses: vec![address(1000).to_vec()],
                 signatures: vec![],
             },
             CallToFilter {
-                addresses: vec![address(2000).to_fixed_bytes().to_vec()],
+                addresses: vec![address(2000).to_vec()],
                 signatures: vec![],
             },
             CallToFilter {
-                addresses: vec![address(3000).to_fixed_bytes().to_vec()],
+                addresses: vec![address(3000).to_vec()],
                 signatures: vec![],
             },
         ];
 
-        filter.log.contracts_and_events_graph.add_edge(
+        filter.log.contracts_and_events_graph.or_add_edge(
             LogFilterNode::Contract(address(10)),
             LogFilterNode::Event(sig(100)),
             false,
         );
-        filter.log.contracts_and_events_graph.add_edge(
+        filter.log.contracts_and_events_graph.or_add_edge(
             LogFilterNode::Contract(address(10)),
             LogFilterNode::Event(sig(101)),
             false,
         );
-        filter.log.contracts_and_events_graph.add_edge(
+        filter.log.contracts_and_events_graph.or_add_edge(
             LogFilterNode::Contract(address(20)),
             LogFilterNode::Event(sig(100)),
             false,
@@ -1139,15 +1458,12 @@ mod tests {
 
         let expected_log_filters = vec![
             LogFilter {
-                addresses: vec![address(10).to_fixed_bytes().to_vec()],
-                event_signatures: vec![sig(101).to_fixed_bytes().to_vec()],
+                addresses: vec![address(10).to_vec()],
+                event_signatures: vec![sig(101).to_vec()],
             },
             LogFilter {
-                addresses: vec![
-                    address(10).to_fixed_bytes().to_vec(),
-                    address(20).to_fixed_bytes().to_vec(),
-                ],
-                event_signatures: vec![sig(100).to_fixed_bytes().to_vec()],
+                addresses: vec![address(10).to_vec(), address(20).to_vec()],
+                event_signatures: vec![sig(100).to_vec()],
             },
         ];
 
@@ -1186,18 +1502,15 @@ mod tests {
             filter.event_signatures.sort();
         }
         assert_eq!(expected_log_filters, actual_log_filters);
-        assert_eq!(true, actual_send_all_block_headers);
+        assert!(actual_send_all_block_headers);
     }
 
     #[test]
     fn ethereum_trigger_filter_to_firehose_every_block_plus_logfilter() {
-        let address = Address::from_low_u64_be;
-        let sig = H256::from_low_u64_le;
+        let address = |value: u64| Address::left_padding_from(&value.to_le_bytes());
+        let sig = |value: u64| B256::left_padding_from(&value.to_le_bytes());
         let mut filter = TriggerFilter {
-            log: EthereumLogFilter {
-                contracts_and_events_graph: GraphMap::new(),
-                wildcard_events: HashMap::new(),
-            },
+            log: EthereumLogFilter::default(),
             call: EthereumCallFilter {
                 contract_addresses_function_signatures: HashMap::new(),
                 wildcard_signatures: HashSet::new(),
@@ -1209,15 +1522,15 @@ mod tests {
             },
         };
 
-        filter.log.contracts_and_events_graph.add_edge(
+        filter.log.contracts_and_events_graph.or_add_edge(
             LogFilterNode::Contract(address(10)),
             LogFilterNode::Event(sig(101)),
             false,
         );
 
         let expected_log_filters = vec![LogFilter {
-            addresses: vec![address(10).to_fixed_bytes().to_vec()],
-            event_signatures: vec![sig(101).to_fixed_bytes().to_vec()],
+            addresses: vec![address(10).to_vec()],
+            event_signatures: vec![sig(101).to_vec()],
         }];
 
         let firehose_filter = filter.clone().to_firehose_filter();
@@ -1252,7 +1565,7 @@ mod tests {
         }
         assert_eq!(expected_log_filters, actual_log_filters);
 
-        assert_eq!(true, actual_send_all_block_headers);
+        assert!(actual_send_all_block_headers);
     }
 
     #[test]
@@ -1279,76 +1592,63 @@ mod tests {
             wildcard_signatures: HashSet::from_iter(vec![[11u8; 4]]),
         };
 
-        assert_eq!(
-            false,
-            filter.matches(&call(address(2), vec![])),
+        assert!(
+            !filter.matches(&call(address(2), vec![])),
             "call with empty bytes are always ignore, whatever the condition"
         );
 
-        assert_eq!(
-            false,
-            filter.matches(&call(address(4), vec![1; 36])),
+        assert!(
+            !filter.matches(&call(address(4), vec![1; 36])),
             "call with incorrect address should be ignored"
         );
 
-        assert_eq!(
-            true,
+        assert!(
             filter.matches(&call(address(1), vec![1; 36])),
             "call with correct address & signature should match"
         );
 
-        assert_eq!(
-            true,
+        assert!(
             filter.matches(&call(address(1), vec![1; 32])),
             "call with correct address & signature, but with incorrect input size should match"
         );
 
-        assert_eq!(
-            false,
-            filter.matches(&call(address(1), vec![4u8; 36])),
+        assert!(
+            !filter.matches(&call(address(1), vec![4u8; 36])),
             "call with correct address but incorrect signature for a specific contract filter (i.e. matches some signatures) should be ignored"
         );
 
-        assert_eq!(
-            false,
-            filter.matches(&call(address(0), vec![11u8; 36])),
+        assert!(
+            !filter.matches(&call(address(0), vec![11u8; 36])),
             "this signature should not match filter1, this avoid false passes if someone changes the code"
         );
-        assert_eq!(
-            false,
-            filter2.matches(&call(address(1), vec![10u8; 36])),
+        assert!(
+            !filter2.matches(&call(address(1), vec![10u8; 36])),
             "this signature should not match filter2 because the address is not the expected one"
         );
-        assert_eq!(
-            true,
+        assert!(
             filter2.matches(&call(address(0), vec![10u8; 36])),
             "this signature should match filter2 on the non wildcard clause"
         );
-        assert_eq!(
-            true,
+        assert!(
             filter2.matches(&call(address(0), vec![11u8; 36])),
             "this signature should match filter2 on the wildcard clause"
         );
 
         // extend filter1 and test the filter 2 stuff again
         filter.extend(filter2);
-        assert_eq!(
-            true,
+        assert!(
             filter.matches(&call(address(0), vec![11u8; 36])),
             "this signature should not match filter1, this avoid false passes if someone changes the code"
         );
-        assert_eq!(
-            false,
-            filter.matches(&call(address(1), vec![10u8; 36])),
+        assert!(
+            !filter.matches(&call(address(1), vec![10u8; 36])),
             "this signature should not match filter2 because the address is not the expected one"
         );
-        assert_eq!(
-            true,
+        assert!(
             filter.matches(&call(address(0), vec![10u8; 36])),
             "this signature should match filter2 on the non wildcard clause"
         );
-        assert_eq!(
-            true,
+        assert!(
             filter.matches(&call(address(0), vec![11u8; 36])),
             "this signature should match filter2 on the wildcard clause"
         );
@@ -1448,12 +1748,12 @@ mod tests {
 
         base.extend(extension);
 
-        assert_eq!(true, base.trigger_every_block);
+        assert!(base.trigger_every_block);
     }
 
     #[test]
-    fn extending_ethereum_block_filter_every_block_in_base_and_merge_contract_addresses_and_polling_intervals(
-    ) {
+    fn extending_ethereum_block_filter_every_block_in_base_and_merge_contract_addresses_and_polling_intervals()
+     {
         let mut base = EthereumBlockFilter {
             polling_intervals: HashSet::from_iter(vec![(10, 3)]),
             contract_addresses: HashSet::from_iter(vec![(10, address(2))]),
@@ -1468,7 +1768,7 @@ mod tests {
 
         base.extend(extension);
 
-        assert_eq!(true, base.trigger_every_block);
+        assert!(base.trigger_every_block);
         assert_eq!(
             HashSet::from_iter(vec![(10, address(2))]),
             base.contract_addresses,
@@ -1492,7 +1792,7 @@ mod tests {
 
         base.extend(extension);
 
-        assert_eq!(true, base.trigger_every_block);
+        assert!(base.trigger_every_block);
         assert_eq!(
             HashSet::from_iter(vec![(10, address(2)), (10, address(1))]),
             base.contract_addresses,
@@ -1507,51 +1807,36 @@ mod tests {
     fn extending_ethereum_call_filter() {
         let mut base = EthereumCallFilter {
             contract_addresses_function_signatures: HashMap::from_iter(vec![
-                (
-                    Address::from_low_u64_be(0),
-                    (0, HashSet::from_iter(vec![[0u8; 4]])),
-                ),
-                (
-                    Address::from_low_u64_be(1),
-                    (1, HashSet::from_iter(vec![[1u8; 4]])),
-                ),
+                (address(0), (0, HashSet::from_iter(vec![[0u8; 4]]))),
+                (address(1), (1, HashSet::from_iter(vec![[1u8; 4]]))),
             ]),
             wildcard_signatures: HashSet::new(),
         };
         let extension = EthereumCallFilter {
             contract_addresses_function_signatures: HashMap::from_iter(vec![
-                (
-                    Address::from_low_u64_be(0),
-                    (2, HashSet::from_iter(vec![[2u8; 4]])),
-                ),
-                (
-                    Address::from_low_u64_be(3),
-                    (3, HashSet::from_iter(vec![[3u8; 4]])),
-                ),
+                (address(0), (2, HashSet::from_iter(vec![[2u8; 4]]))),
+                (address(3), (3, HashSet::from_iter(vec![[3u8; 4]]))),
             ]),
             wildcard_signatures: HashSet::new(),
         };
         base.extend(extension);
 
         assert_eq!(
-            base.contract_addresses_function_signatures
-                .get(&Address::from_low_u64_be(0)),
+            base.contract_addresses_function_signatures.get(&address(0)),
             Some(&(0, HashSet::from_iter(vec![[0u8; 4], [2u8; 4]])))
         );
         assert_eq!(
-            base.contract_addresses_function_signatures
-                .get(&Address::from_low_u64_be(3)),
+            base.contract_addresses_function_signatures.get(&address(3)),
             Some(&(3, HashSet::from_iter(vec![[3u8; 4]])))
         );
         assert_eq!(
-            base.contract_addresses_function_signatures
-                .get(&Address::from_low_u64_be(1)),
+            base.contract_addresses_function_signatures.get(&address(1)),
             Some(&(1, HashSet::from_iter(vec![[1u8; 4]])))
         );
     }
 
-    fn address(id: u64) -> Address {
-        Address::from_low_u64_be(id)
+    fn address(value: u64) -> Address {
+        Address::left_padding_from(&value.to_be_bytes())
     }
 
     fn bytes(value: Vec<u8>) -> Bytes {
@@ -1567,16 +1852,16 @@ fn complete_log_filter() {
 
     // Test a few combinations of complete graphs.
     for i in [1, 2] {
-        let events: BTreeSet<_> = (0..i).map(H256::from_low_u64_le).collect();
+        let events: BTreeSet<_> = (0..i).map(|n| B256::from([n as u8; 32])).collect();
 
         for j in [1, 1000, 2000, 3000] {
-            let contracts: BTreeSet<_> = (0..j).map(Address::from_low_u64_le).collect();
+            let contracts: BTreeSet<_> = (0..j).map(|n| Address::from([n as u8; 20])).collect();
 
             // Construct the complete bipartite graph with i events and j contracts.
-            let mut contracts_and_events_graph = GraphMap::new();
+            let mut filter = EthereumLogFilter::default();
             for &contract in &contracts {
                 for &event in &events {
-                    contracts_and_events_graph.add_edge(
+                    filter.contracts_and_events_graph.or_add_edge(
                         LogFilterNode::Contract(contract),
                         LogFilterNode::Event(event),
                         false,
@@ -1585,12 +1870,9 @@ fn complete_log_filter() {
             }
 
             // Run `eth_get_logs_filters`, which is what we want to test.
-            let logs_filters: Vec<_> = EthereumLogFilter {
-                contracts_and_events_graph,
-                wildcard_events: HashMap::new(),
-            }
-            .eth_get_logs_filters()
-            .collect();
+            let logs_filters: Vec<_> = filter
+                .eth_get_logs_filters(ENV_VARS.get_logs_max_contracts)
+                .collect();
 
             // Assert that a contract or event is filtered on iff it was present in the graph.
             assert_eq!(
@@ -1618,27 +1900,46 @@ fn complete_log_filter() {
     }
 }
 
+#[test]
+fn test_call_filter_first_signature_not_lost() {
+    use crate::adapter::{EthereumCallFilter, FunctionSelector};
+    use alloy::primitives::Address;
+
+    let addr = Address::left_padding_from(&1u64.to_be_bytes());
+    let sig1: FunctionSelector = [0xaa, 0xbb, 0xcc, 0xdd];
+    let sig2: FunctionSelector = [0x11, 0x22, 0x33, 0x44];
+
+    let filter: EthereumCallFilter = vec![(100i32, addr, sig1), (100i32, addr, sig2)]
+        .into_iter()
+        .collect();
+
+    let (_, sigs) = filter
+        .contract_addresses_function_signatures
+        .get(&addr)
+        .unwrap();
+    assert_eq!(sigs.len(), 2);
+    assert!(sigs.contains(&sig1));
+    assert!(sigs.contains(&sig2));
+}
+
 #[test]
 fn log_filter_require_transacion_receipt_method() {
+    let address = |value: u64| Address::left_padding_from(&value.to_be_bytes());
+    let b256 = |value: u64| B256::left_padding_from(&value.to_be_bytes());
+
     // test data
-    let event_signature_a = H256::zero();
-    let event_signature_b = H256::from_low_u64_be(1);
-    let event_signature_c = H256::from_low_u64_be(2);
-    let contract_a = Address::from_low_u64_be(3);
-    let contract_b = Address::from_low_u64_be(4);
-    let contract_c = Address::from_low_u64_be(5);
-
-    let wildcard_event_with_receipt = H256::from_low_u64_be(6);
-    let wildcard_event_without_receipt = H256::from_low_u64_be(7);
-    let wildcard_events = [
-        (wildcard_event_with_receipt, true),
-        (wildcard_event_without_receipt, false),
-    ]
-    .into_iter()
-    .collect();
-
-    let alien_event_signature = H256::from_low_u64_be(8); // those will not be inserted in the graph
-    let alien_contract_address = Address::from_low_u64_be(9);
+    let event_signature_a = b256(0);
+    let event_signature_b = b256(1);
+    let event_signature_c = b256(2);
+    let contract_a = address(3);
+    let contract_b = address(4);
+    let contract_c = address(5);
+
+    let wildcard_event_with_receipt = b256(6);
+    let wildcard_event_without_receipt = b256(7);
+
+    let alien_event_signature = b256(8); // those will not be inserted in the graph
+    let alien_contract_address = address(9);
 
     // test graph nodes
     let event_a_node = LogFilterNode::Event(event_signature_a);
@@ -1663,51 +1964,376 @@ fn log_filter_require_transacion_receipt_method() {
     //     event_b -- contract_a [ receipt=false ]
     // }
     // ```
-    let mut contracts_and_events_graph = GraphMap::new();
-
-    let event_a_id = contracts_and_events_graph.add_node(event_a_node);
-    let event_b_id = contracts_and_events_graph.add_node(event_b_node);
-    let event_c_id = contracts_and_events_graph.add_node(event_c_node);
-    let contract_a_id = contracts_and_events_graph.add_node(contract_a_node);
-    let contract_b_id = contracts_and_events_graph.add_node(contract_b_node);
-    let contract_c_id = contracts_and_events_graph.add_node(contract_c_node);
-    contracts_and_events_graph.add_edge(event_a_id, contract_a_id, true);
-    contracts_and_events_graph.add_edge(event_b_id, contract_b_id, true);
-    contracts_and_events_graph.add_edge(event_a_id, contract_b_id, false);
-    contracts_and_events_graph.add_edge(event_b_id, contract_a_id, false);
-    contracts_and_events_graph.add_edge(event_c_id, contract_c_id, true);
-
-    let filter = EthereumLogFilter {
-        contracts_and_events_graph,
-        wildcard_events,
-    };
+    let mut filter = EthereumLogFilter::default();
+    filter
+        .contracts_and_events_graph
+        .or_add_edge(event_a_node, contract_a_node, true);
+    filter
+        .contracts_and_events_graph
+        .or_add_edge(event_b_node, contract_b_node, true);
+    filter
+        .contracts_and_events_graph
+        .or_add_edge(event_a_node, contract_b_node, false);
+    filter
+        .contracts_and_events_graph
+        .or_add_edge(event_b_node, contract_a_node, false);
+    filter
+        .contracts_and_events_graph
+        .or_add_edge(event_c_node, contract_c_node, true);
+    filter
+        .wildcard_events
+        .or_insert(wildcard_event_with_receipt, true);
+    filter
+        .wildcard_events
+        .or_insert(wildcard_event_without_receipt, false);
+
+    let empty_vec: Vec<B256> = vec![];
 
     // connected contracts and events graph
-    assert!(filter.requires_transaction_receipt(&event_signature_a, Some(&contract_a)));
-    assert!(filter.requires_transaction_receipt(&event_signature_b, Some(&contract_b)));
-    assert!(filter.requires_transaction_receipt(&event_signature_c, Some(&contract_c)));
-    assert!(!filter.requires_transaction_receipt(&event_signature_a, Some(&contract_b)));
-    assert!(!filter.requires_transaction_receipt(&event_signature_b, Some(&contract_a)));
+    assert!(filter.requires_transaction_receipt(&event_signature_a, Some(&contract_a), &empty_vec));
+    assert!(filter.requires_transaction_receipt(&event_signature_b, Some(&contract_b), &empty_vec));
+    assert!(filter.requires_transaction_receipt(&event_signature_c, Some(&contract_c), &empty_vec));
+    assert!(!filter.requires_transaction_receipt(
+        &event_signature_a,
+        Some(&contract_b),
+        &empty_vec
+    ));
+    assert!(!filter.requires_transaction_receipt(
+        &event_signature_b,
+        Some(&contract_a),
+        &empty_vec
+    ));
 
     // Event C and Contract C are not connected to the other events and contracts
-    assert!(!filter.requires_transaction_receipt(&event_signature_a, Some(&contract_c)));
-    assert!(!filter.requires_transaction_receipt(&event_signature_b, Some(&contract_c)));
-    assert!(!filter.requires_transaction_receipt(&event_signature_c, Some(&contract_a)));
-    assert!(!filter.requires_transaction_receipt(&event_signature_c, Some(&contract_b)));
+    assert!(!filter.requires_transaction_receipt(
+        &event_signature_a,
+        Some(&contract_c),
+        &empty_vec
+    ));
+    assert!(!filter.requires_transaction_receipt(
+        &event_signature_b,
+        Some(&contract_c),
+        &empty_vec
+    ));
+    assert!(!filter.requires_transaction_receipt(
+        &event_signature_c,
+        Some(&contract_a),
+        &empty_vec
+    ));
+    assert!(!filter.requires_transaction_receipt(
+        &event_signature_c,
+        Some(&contract_b),
+        &empty_vec
+    ));
 
     // Wildcard events
-    assert!(filter.requires_transaction_receipt(&wildcard_event_with_receipt, None));
-    assert!(!filter.requires_transaction_receipt(&wildcard_event_without_receipt, None));
+    assert!(filter.requires_transaction_receipt(&wildcard_event_with_receipt, None, &empty_vec));
+    assert!(!filter.requires_transaction_receipt(
+        &wildcard_event_without_receipt,
+        None,
+        &empty_vec
+    ));
 
     // Alien events and contracts always return false
-    assert!(
-        !filter.requires_transaction_receipt(&alien_event_signature, Some(&alien_contract_address))
+    assert!(!filter.requires_transaction_receipt(
+        &alien_event_signature,
+        Some(&alien_contract_address),
+        &empty_vec
+    ));
+    assert!(!filter.requires_transaction_receipt(&alien_event_signature, None, &empty_vec),);
+    assert!(!filter.requires_transaction_receipt(
+        &alien_event_signature,
+        Some(&contract_a),
+        &empty_vec
+    ));
+    assert!(!filter.requires_transaction_receipt(
+        &alien_event_signature,
+        Some(&contract_b),
+        &empty_vec
+    ));
+    assert!(!filter.requires_transaction_receipt(
+        &alien_event_signature,
+        Some(&contract_c),
+        &empty_vec
+    ));
+    assert!(!filter.requires_transaction_receipt(
+        &event_signature_a,
+        Some(&alien_contract_address),
+        &empty_vec
+    ));
+    assert!(!filter.requires_transaction_receipt(
+        &event_signature_b,
+        Some(&alien_contract_address),
+        &empty_vec
+    ));
+    assert!(!filter.requires_transaction_receipt(
+        &event_signature_c,
+        Some(&alien_contract_address),
+        &empty_vec
+    ));
+}
+
+// Tests that `EthereumLogFilter` OR-merges per-handler `receipt` flags across
+// every insertion site (`from_data_sources`, `from_mapping`, `extend`).
+
+#[cfg(test)]
+fn receipt_merge_test_addr(n: u64) -> Address {
+    Address::left_padding_from(&n.to_be_bytes())
+}
+
+#[cfg(test)]
+fn receipt_merge_test_sig(n: u64) -> B256 {
+    B256::left_padding_from(&n.to_be_bytes())
+}
+
+#[cfg(test)]
+fn receipt_merge_test_mock_abi() -> std::sync::Arc<graph::data_source::common::MappingABI> {
+    std::sync::Arc::new(graph::data_source::common::MappingABI {
+        name: "mock_abi".to_string(),
+        contract: abi::JsonAbi::new(),
+    })
+}
+
+#[cfg(test)]
+fn receipt_merge_test_event_handler(
+    sig: B256,
+    topic1: Option<Vec<B256>>,
+    topic2: Option<Vec<B256>>,
+    topic3: Option<Vec<B256>>,
+    receipt: bool,
+) -> crate::data_source::MappingEventHandler {
+    crate::data_source::MappingEventHandler {
+        event: "Event()".to_string(),
+        topic0: Some(sig),
+        topic1,
+        topic2,
+        topic3,
+        handler: "handleEvent".to_string(),
+        receipt,
+        calls: graph::data_source::common::CallDecls::default(),
+    }
+}
+
+#[cfg(test)]
+fn receipt_merge_test_mapping(
+    handlers: Vec<crate::data_source::MappingEventHandler>,
+) -> crate::Mapping {
+    crate::Mapping {
+        kind: "ethereum/events".to_string(),
+        api_version: semver::Version::new(0, 0, 7),
+        language: "wasm/assemblyscript".to_string(),
+        entities: vec![],
+        abis: vec![receipt_merge_test_mock_abi()],
+        block_handlers: vec![],
+        call_handlers: vec![],
+        event_handlers: handlers,
+        runtime: std::sync::Arc::new(vec![]),
+        link: graph::prelude::Link {
+            link: "test".to_string(),
+        },
+    }
+}
+
+#[cfg(test)]
+fn receipt_merge_test_data_source(
+    address: Option<Address>,
+    handlers: Vec<crate::data_source::MappingEventHandler>,
+) -> crate::data_source::DataSource {
+    crate::data_source::DataSource {
+        kind: "ethereum/contract".to_string(),
+        network: Some("test".to_string()),
+        name: "Test".to_string(),
+        manifest_idx: 0,
+        address,
+        start_block: 0,
+        end_block: None,
+        mapping: receipt_merge_test_mapping(handlers),
+        context: std::sync::Arc::new(None),
+        creation_block: None,
+        contract_abi: receipt_merge_test_mock_abi(),
+    }
+}
+
+/// Run two data sources with `receipt: true` and `receipt: false` at the
+/// same effective filter key through `from_data_sources` and assert the
+/// merged filter still requires a transaction receipt. Runs both
+/// declaration orders so order-independence is verified per variant.
+#[cfg(test)]
+fn assert_from_data_sources_or_merges(
+    label: &str,
+    address: Option<Address>,
+    topic1: Option<Vec<B256>>,
+    log_topics: &[B256],
+) {
+    let event_sig = receipt_merge_test_sig(100);
+    let ds_yes = receipt_merge_test_data_source(
+        address,
+        vec![receipt_merge_test_event_handler(
+            event_sig,
+            topic1.clone(),
+            None,
+            None,
+            true,
+        )],
     );
-    assert!(!filter.requires_transaction_receipt(&alien_event_signature, None));
-    assert!(!filter.requires_transaction_receipt(&alien_event_signature, Some(&contract_a)));
-    assert!(!filter.requires_transaction_receipt(&alien_event_signature, Some(&contract_b)));
-    assert!(!filter.requires_transaction_receipt(&alien_event_signature, Some(&contract_c)));
-    assert!(!filter.requires_transaction_receipt(&event_signature_a, Some(&alien_contract_address)));
-    assert!(!filter.requires_transaction_receipt(&event_signature_b, Some(&alien_contract_address)));
-    assert!(!filter.requires_transaction_receipt(&event_signature_c, Some(&alien_contract_address)));
+    let ds_no = receipt_merge_test_data_source(
+        address,
+        vec![receipt_merge_test_event_handler(
+            event_sig,
+            topic1.clone(),
+            None,
+            None,
+            false,
+        )],
+    );
+
+    for (order, dss) in [("yes,no", [&ds_yes, &ds_no]), ("no,yes", [&ds_no, &ds_yes])] {
+        let filter = EthereumLogFilter::from_data_sources(dss);
+        assert!(
+            filter.requires_transaction_receipt(&event_sig, address.as_ref(), log_topics),
+            "{label} ({order}): receipt:true must survive a later receipt:false",
+        );
+    }
+}
+
+/// Build two filters via `from_data_sources`, each with one handler at the
+/// same effective key but with opposite receipt flags, then merge them via
+/// `extend` and assert the merged filter still requires a transaction
+/// receipt. Runs both extend directions so order-independence is verified
+/// per variant.
+#[cfg(test)]
+fn assert_extend_or_merges(
+    label: &str,
+    address: Option<Address>,
+    topic1: Option<Vec<B256>>,
+    log_topics: &[B256],
+) {
+    let event_sig = receipt_merge_test_sig(105);
+    let ds_yes = receipt_merge_test_data_source(
+        address,
+        vec![receipt_merge_test_event_handler(
+            event_sig,
+            topic1.clone(),
+            None,
+            None,
+            true,
+        )],
+    );
+    let ds_no = receipt_merge_test_data_source(
+        address,
+        vec![receipt_merge_test_event_handler(
+            event_sig,
+            topic1.clone(),
+            None,
+            None,
+            false,
+        )],
+    );
+
+    for (order, base, ext) in [
+        ("yes.extend(no)", &ds_yes, &ds_no),
+        ("no.extend(yes)", &ds_no, &ds_yes),
+    ] {
+        let mut filter = EthereumLogFilter::from_data_sources([base]);
+        filter.extend(EthereumLogFilter::from_data_sources([ext]));
+        assert!(
+            filter.requires_transaction_receipt(&event_sig, address.as_ref(), log_topics),
+            "{label} ({order}): extend must OR-merge",
+        );
+    }
+}
+
+#[test]
+fn from_data_sources_or_merges_at_every_insertion_site() {
+    let contract = receipt_merge_test_addr(1);
+    let event_sig = receipt_merge_test_sig(100);
+    let topic = receipt_merge_test_sig(200);
+    let with_topic = vec![event_sig, topic];
+
+    // Each case maps to one arm of the `match ds.address` in `from_data_sources`.
+    assert_from_data_sources_or_merges("graph edge", Some(contract), None, &[]);
+    assert_from_data_sources_or_merges(
+        "addressed topics",
+        Some(contract),
+        Some(vec![topic]),
+        &with_topic,
+    );
+    assert_from_data_sources_or_merges("wildcard", None, None, &[]);
+    assert_from_data_sources_or_merges("wildcard topics", None, Some(vec![topic]), &with_topic);
+}
+
+#[test]
+fn from_mapping_or_merges_via_extend() {
+    // Two templates handling the same event signature with different receipt
+    // flags merged via `from_mapping` + `extend`.
+    let event_sig = receipt_merge_test_sig(104);
+
+    let mapping_yes = receipt_merge_test_mapping(vec![receipt_merge_test_event_handler(
+        event_sig, None, None, None, true,
+    )]);
+    let mapping_no = receipt_merge_test_mapping(vec![receipt_merge_test_event_handler(
+        event_sig, None, None, None, false,
+    )]);
+
+    let mut filter = EthereumLogFilter::from_mapping(&mapping_yes);
+    filter.extend(EthereumLogFilter::from_mapping(&mapping_no));
+
+    assert!(filter.requires_transaction_receipt(&event_sig, None, &[]));
+}
+
+#[test]
+fn extend_or_merges_at_every_collection() {
+    let contract = receipt_merge_test_addr(5);
+    let event_sig = receipt_merge_test_sig(105);
+    let topic = receipt_merge_test_sig(203);
+    let with_topic = vec![event_sig, topic];
+
+    assert_extend_or_merges("graph edge", Some(contract), None, &[]);
+    assert_extend_or_merges(
+        "addressed topics",
+        Some(contract),
+        Some(vec![topic]),
+        &with_topic,
+    );
+    assert_extend_or_merges("wildcard", None, None, &[]);
+    assert_extend_or_merges("wildcard topics", None, Some(vec![topic]), &with_topic);
+}
+
+#[test]
+fn requires_transaction_receipt_has_or_semantics_across_handlers() {
+    // `requires_transaction_receipt` must return true iff at least one handler
+    // at the key declared `receipt: true`, regardless of declaration order.
+    let event_sig = receipt_merge_test_sig(108);
+
+    for flags in [
+        vec![false],
+        vec![true],
+        vec![true, false],
+        vec![false, true],
+        vec![false, false, true],
+        vec![true, false, false],
+        vec![false, true, false],
+        vec![true, true, false],
+        vec![false, false, false],
+    ] {
+        let dss: Vec<_> = flags
+            .iter()
+            .map(|&r| {
+                receipt_merge_test_data_source(
+                    None,
+                    vec![receipt_merge_test_event_handler(
+                        event_sig, None, None, None, r,
+                    )],
+                )
+            })
+            .collect();
+        let filter = EthereumLogFilter::from_data_sources(dss.iter());
+
+        let any_requires_receipt = flags.iter().any(|&r| r);
+        assert_eq!(
+            filter.requires_transaction_receipt(&event_sig, None, &[]),
+            any_requires_receipt,
+            "flag sequence {flags:?}",
+        );
+    }
 }
diff --git a/chain/ethereum/src/buffered_call_cache.rs b/chain/ethereum/src/buffered_call_cache.rs
new file mode 100644
index 00000000000..29aa84e90ab
--- /dev/null
+++ b/chain/ethereum/src/buffered_call_cache.rs
@@ -0,0 +1,146 @@
+use std::{
+    collections::HashMap,
+    sync::{Arc, Mutex},
+};
+
+use async_trait::async_trait;
+use graph::{
+    cheap_clone::CheapClone,
+    components::store::EthereumCallCache,
+    data::store::ethereum::call,
+    prelude::{BlockPtr, CachedEthereumCall},
+    slog::{Logger, error},
+};
+
+/// A wrapper around an Ethereum call cache that buffers call results in
+/// memory for the duration of a block. If `get_call` or `set_call` are
+/// called with a different block pointer than the one used in the previous
+/// call, the buffer is cleared.
+pub struct BufferedCallCache {
+    call_cache: Arc<dyn EthereumCallCache>,
+    buffer: Arc<Mutex<HashMap<call::Request, call::Retval>>>,
+    block: Arc<Mutex<Option<BlockPtr>>>,
+}
+
+impl BufferedCallCache {
+    pub fn new(call_cache: Arc<dyn EthereumCallCache>) -> Self {
+        Self {
+            call_cache,
+            buffer: Arc::new(Mutex::new(HashMap::new())),
+            block: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    fn check_block(&self, block: &BlockPtr) {
+        let mut self_block = self.block.lock().unwrap();
+        if self_block.as_ref() != Some(block) {
+            *self_block = Some(block.clone());
+            self.buffer.lock().unwrap().clear();
+        }
+    }
+
+    fn get(&self, call: &call::Request) -> Option<call::Response> {
+        let buffer = self.buffer.lock().unwrap();
+        buffer.get(call).map(|retval| {
+            call.cheap_clone()
+                .response(retval.clone(), call::Source::Memory)
+        })
+    }
+}
+
+#[async_trait]
+impl EthereumCallCache for BufferedCallCache {
+    async fn get_call(
+        &self,
+        call: &call::Request,
+        block: BlockPtr,
+    ) -> Result<Option<call::Response>, graph::prelude::Error> {
+        self.check_block(&block);
+
+        if let Some(value) = self.get(call) {
+            return Ok(Some(value));
+        }
+
+        let result = self.call_cache.get_call(call, block).await?;
+
+        let mut buffer = self.buffer.lock().unwrap();
+        if let Some(call::Response {
+            retval,
+            req: _,
+            source: _,
+        }) = &result
+        {
+            buffer.insert(call.cheap_clone(), retval.clone());
+        }
+        Ok(result)
+    }
+
+    async fn get_calls(
+        &self,
+        reqs: &[call::Request],
+        block: BlockPtr,
+    ) -> Result<(Vec<call::Response>, Vec<call::Request>), graph::prelude::Error> {
+        self.check_block(&block);
+
+        let mut missing = Vec::new();
+        let mut resps = Vec::new();
+
+        for call in reqs {
+            match self.get(call) {
+                Some(resp) => resps.push(resp),
+                None => missing.push(call.cheap_clone()),
+            }
+        }
+
+        let (stored, calls) = self.call_cache.get_calls(&missing, block).await?;
+
+        {
+            let mut buffer = self.buffer.lock().unwrap();
+            for resp in &stored {
+                buffer.insert(resp.req.cheap_clone(), resp.retval.clone());
+            }
+        }
+
+        resps.extend(stored);
+        Ok((resps, calls))
+    }
+
+    async fn get_calls_in_block(
+        &self,
+        block: BlockPtr,
+    ) -> Result<Vec<CachedEthereumCall>, graph::prelude::Error> {
+        self.call_cache.get_calls_in_block(block).await
+    }
+
+    async fn set_call(
+        self: Arc<Self>,
+        logger: &Logger,
+        call: call::Request,
+        block: BlockPtr,
+        return_value: call::Retval,
+    ) -> Result<(), graph::prelude::Error> {
+        self.check_block(&block);
+
+        // Enter the call into the in-memory cache immediately so that
+        // handlers will find it, but add it to the underlying cache in the
+        // background so we do not have to wait for that as it will be a
+        // cache backed by the database
+        {
+            let mut buffer = self.buffer.lock().unwrap();
+            buffer.insert(call.cheap_clone(), return_value.clone());
+        }
+
+        let cache = self.call_cache.cheap_clone();
+        let logger = logger.cheap_clone();
+        if let Err(e) = cache
+            .set_call(&logger, call.cheap_clone(), block, return_value)
+            .await
+        {
+            error!(logger, "BufferedCallCache: call cache set error";
+                            "contract_address" => format!("{:?}", call.address),
+                            "error" => e.to_string())
+        }
+
+        Ok(())
+    }
+}
diff --git a/chain/ethereum/src/call_helper.rs b/chain/ethereum/src/call_helper.rs
new file mode 100644
index 00000000000..8a1216b58c5
--- /dev/null
+++ b/chain/ethereum/src/call_helper.rs
@@ -0,0 +1,156 @@
+use crate::{ContractCallError, ENV_VARS};
+use graph::{
+    abi,
+    data::store::ethereum::call,
+    prelude::{
+        Logger,
+        alloy::transports::{RpcError, TransportErrorKind},
+        serde_json,
+    },
+    slog::info,
+};
+
+// ------------------------------------------------------------------
+// Constants and helper utilities used across eth_call handling
+// ------------------------------------------------------------------
+
+// Try to check if the call was reverted. The JSON-RPC response for reverts is
+// not standardized, so we have ad-hoc checks for each Ethereum client.
+
+// 0xfe is the "designated bad instruction" of the EVM, and Solidity uses it for
+// asserts.
+const PARITY_BAD_INSTRUCTION_FE: &str = "Bad instruction fe";
+
+// 0xfd is REVERT, but on some contracts, and only on older blocks,
+// this happens. Makes sense to consider it a revert as well.
+const PARITY_BAD_INSTRUCTION_FD: &str = "Bad instruction fd";
+
+const PARITY_BAD_JUMP_PREFIX: &str = "Bad jump";
+const PARITY_STACK_LIMIT_PREFIX: &str = "Out of stack";
+
+// See f0af4ab0-6b7c-4b68-9141-5b79346a5f61.
+const PARITY_OUT_OF_GAS: &str = "Out of gas";
+
+// Also covers Nethermind reverts
+const PARITY_VM_EXECUTION_ERROR: i64 = -32015;
+const PARITY_REVERT_PREFIX: &str = "revert";
+
+const XDAI_REVERT: &str = "revert";
+
+// Deterministic RPC execution errors. We might need to expand this as
+// subgraphs come across other errors. See
+// https://github.com/ethereum/go-ethereum/blob/cd57d5cd38ef692de8fbedaa56598b4e9fbfbabc/core/vm/errors.go
+const RPC_EXECUTION_ERRORS: &[&str] = &[
+    // The "revert" substring covers a few known error messages, including:
+    // Hardhat: "error: transaction reverted",
+    // Ganache and Moonbeam: "vm exception while processing transaction: revert",
+    // Geth: "execution reverted"
+    // And others.
+    "revert",
+    "invalid jump destination",
+    "invalid opcode",
+    // Ethereum says 1024 is the stack sizes limit, so this is deterministic.
+    "stack limit reached 1024",
+    // See f0af4ab0-6b7c-4b68-9141-5b79346a5f61 for why the gas limit is considered deterministic.
+    "out of gas",
+    "stack underflow",
+    "vm execution error",
+    "invalidjump",
+    "notactivated",
+    "invalidfeopcode",
+    // Reth surfaces EVM halts via `EvmHalt(HaltReason)`, formatted with the
+    // reason's `Debug` repr (`"EVM error: {0:?}"`). revm's `HaltReason`
+    // variants are CamelCase with no spaces, so e.g. a stack underflow arrives
+    // as "EVM error: StackUnderflow", which the space-separated "stack
+    // underflow" above does not match. "invalidjump"/"invalidfeopcode" already
+    // cover the matching variants; these add the rest. Reth's OutOfGas is
+    // handled before EvmHalt and rendered as "out of gas: ...", so it is
+    // already covered above. See https://github.com/streamingfast/eth-go/pull/10.
+    "stackunderflow",
+    "stackoverflow",
+    "opcodenotfound",
+];
+
+/// Helper that checks if a RPC error message corresponds to a revert.
+fn is_rpc_revert_message(message: &str) -> bool {
+    let env_rpc_call_errors = ENV_VARS.rpc_eth_call_errors.iter();
+    let mut execution_errors = RPC_EXECUTION_ERRORS
+        .iter()
+        .copied()
+        .chain(env_rpc_call_errors.map(|s| s.as_str()));
+    execution_errors.any(|e| message.to_lowercase().contains(e))
+}
+
+/// Decode a Solidity revert(reason) payload, returning the reason string when possible.
+fn as_solidity_revert_reason(bytes: &[u8]) -> Option<String> {
+    let selector = &graph::prelude::alloy::primitives::keccak256(b"Error(string)")[..4];
+    if bytes.len() >= 4 && &bytes[..4] == selector {
+        abi::DynSolType::String
+            .abi_decode(&bytes[4..])
+            .ok()
+            .and_then(|val| val.clone().as_str().map(ToOwned::to_owned))
+    } else {
+        None
+    }
+}
+
+/// Interpret the error returned by `eth_call`, distinguishing genuine failures from
+/// EVM reverts. Returns `Ok(Null)` for reverts or a proper error otherwise.
+pub fn interpret_eth_call_error(
+    logger: &Logger,
+    err: RpcError<TransportErrorKind>,
+) -> Result<call::Retval, ContractCallError> {
+    fn reverted(logger: &Logger, reason: &str) -> Result<call::Retval, ContractCallError> {
+        info!(logger, "Contract call reverted"; "reason" => reason);
+        Ok(call::Retval::Null)
+    }
+
+    if let RpcError::ErrorResp(rpc_error) = &err
+        && is_rpc_revert_message(&rpc_error.message)
+    {
+        return reverted(logger, &rpc_error.message);
+    }
+
+    if let RpcError::ErrorResp(rpc_error) = &err {
+        let code = rpc_error.code;
+        let data: Option<String> = rpc_error
+            .data
+            .as_ref()
+            .and_then(|d| serde_json::from_str(d.get()).ok());
+
+        if code == PARITY_VM_EXECUTION_ERROR
+            && let Some(data) = data
+            && is_parity_revert(&data)
+        {
+            return reverted(logger, &parity_revert_reason(&data));
+        }
+    }
+
+    Err(ContractCallError::AlloyError(err))
+}
+
+fn is_parity_revert(data: &str) -> bool {
+    data.to_lowercase().starts_with(PARITY_REVERT_PREFIX)
+        || data.starts_with(PARITY_BAD_JUMP_PREFIX)
+        || data.starts_with(PARITY_STACK_LIMIT_PREFIX)
+        || data == PARITY_BAD_INSTRUCTION_FE
+        || data == PARITY_BAD_INSTRUCTION_FD
+        || data == PARITY_OUT_OF_GAS
+        || data == XDAI_REVERT
+}
+
+/// Checks if the given data corresponds to a Parity / Nethermind style EVM
+/// revert and, if so, tries to extract a human-readable revert reason. Returns `Some`
+/// with the reason when the error is identified as a revert, otherwise `None`.
+fn parity_revert_reason(data: &str) -> String {
+    if data == PARITY_BAD_INSTRUCTION_FE {
+        return PARITY_BAD_INSTRUCTION_FE.to_owned();
+    }
+
+    // Otherwise try to decode a Solidity revert reason payload.
+    let payload = data.trim_start_matches(PARITY_REVERT_PREFIX);
+    hex::decode(payload)
+        .ok()
+        .and_then(|decoded| as_solidity_revert_reason(&decoded))
+        .unwrap_or_else(|| "no reason".to_owned())
+}
diff --git a/chain/ethereum/src/chain.rs b/chain/ethereum/src/chain.rs
index 32697c15dd2..405c3123bdc 100644
--- a/chain/ethereum/src/chain.rs
+++ b/chain/ethereum/src/chain.rs
@@ -1,38 +1,44 @@
-use anyhow::{anyhow, bail, Result};
 use anyhow::{Context, Error};
+use anyhow::{Result, anyhow, bail};
+use async_trait::async_trait;
 use graph::blockchain::client::ChainClient;
 use graph::blockchain::firehose_block_ingestor::{FirehoseBlockIngestor, Transforms};
-use graph::blockchain::{BlockIngestor, BlockTime, BlockchainKind, TriggersAdapterSelector};
-use graph::components::store::DeploymentCursorTracker;
+use graph::blockchain::{
+    BlockIngestor, BlockTime, BlockchainKind, ChainIdentifier, ExtendedBlockPtr,
+    TriggerFilterWrapper, TriggersAdapterSelector,
+};
+use graph::components::network_provider::ChainName;
+use graph::components::store::{DeploymentCursorTracker, SourceableStore};
 use graph::data::subgraph::UnifiedMappingApiVersion;
-use graph::firehose::{FirehoseEndpoint, ForkStep};
+use graph::firehose::{FirehoseEndpoint, FirehoseEndpoints, ForkStep};
+use graph::futures03::TryStreamExt;
 use graph::prelude::{
     BlockHash, ComponentLoggerConfig, ElasticComponentLoggerConfig, EthereumBlock,
-    EthereumCallCache, LightEthereumBlock, LightEthereumBlockExt, MetricsRegistry,
+    EthereumCallCache, LightEthereumBlock, LightEthereumBlockExt, MetricsRegistry, StoreError,
+    retry,
 };
-use graph::schema::InputSchema;
-use graph::substreams::Clock;
+use graph::slog::{debug, error, trace, warn};
 use graph::{
     blockchain::{
+        Block, BlockPtr, Blockchain, ChainHeadUpdateListener, IngestorError,
+        RuntimeAdapter as RuntimeAdapterTrait, TriggerFilter as _,
         block_stream::{
             BlockRefetcher, BlockStreamEvent, BlockWithTriggers, FirehoseError,
             FirehoseMapper as FirehoseMapperTrait, TriggersAdapter as TriggersAdapterTrait,
         },
         firehose_block_stream::FirehoseBlockStream,
-        polling_block_stream::PollingBlockStream,
-        Block, BlockPtr, Blockchain, ChainHeadUpdateListener, IngestorError,
-        RuntimeAdapter as RuntimeAdapterTrait, TriggerFilter as _,
     },
     cheap_clone::CheapClone,
     components::store::DeploymentLocator,
     firehose,
     prelude::{
-        async_trait, o, serde_json as json, BlockNumber, ChainStore, EthereumBlockWithCalls,
-        Future01CompatExt, Logger, LoggerFactory, NodeId,
+        BlockNumber, ChainStore, EthereumBlockWithCalls, Logger, LoggerFactory, o,
+        serde_json as json,
     },
 };
 use prost::Message;
-use std::collections::HashSet;
+use std::collections::{BTreeSet, HashSet};
+use std::future::Future;
 use std::iter::FromIterator;
 use std::sync::Arc;
 use std::time::Duration;
@@ -42,9 +48,11 @@ use crate::data_source::DataSourceTemplate;
 use crate::data_source::UnresolvedDataSourceTemplate;
 use crate::ingestor::PollingBlockIngestor;
 use crate::network::EthereumNetworkAdapters;
-use crate::EthereumAdapter;
-use crate::NodeCapabilities;
+use crate::polling_block_stream::PollingBlockStream;
+use crate::runtime::runtime_adapter::eth_call_gas;
+use crate::{BufferedCallCache, NodeCapabilities};
 use crate::{
+    ENV_VARS, SubgraphEthRpcMetrics, TriggerFilter,
     adapter::EthereumAdapter as _,
     codec,
     data_source::{DataSource, UnresolvedDataSource},
@@ -52,15 +60,53 @@ use crate::{
         blocks_with_triggers, get_calls, parse_block_triggers, parse_call_triggers,
         parse_log_triggers,
     },
-    SubgraphEthRpcMetrics, TriggerFilter, ENV_VARS,
 };
+use crate::{EthereumAdapter, RuntimeAdapter};
 use graph::blockchain::block_stream::{
-    BlockStream, BlockStreamBuilder, BlockStreamMapper, FirehoseCursor,
+    BlockStream, BlockStreamBuilder, BlockStreamError, BlockStreamMapper, FirehoseCursor,
+    TriggersAdapterWrapper,
 };
-
 /// Celo Mainnet: 42220, Testnet Alfajores: 44787, Testnet Baklava: 62320
 const CELO_CHAIN_IDS: [u64; 3] = [42220, 44787, 62320];
 
+/// Resolved per-chain settings. Populated at chain initialisation from the config file (with
+/// ENV_VAR fallbacks) and stored on [`Chain`] and [`crate::EthereumAdapter`].
+#[derive(Clone, Debug)]
+pub struct ChainSettings {
+    pub polling_interval: Duration,
+    pub json_rpc_timeout: Duration,
+    pub request_retries: usize,
+    pub max_block_range_size: BlockNumber,
+    pub block_batch_size: usize,
+    pub block_ptr_batch_size: usize,
+    pub max_event_only_range: BlockNumber,
+    pub target_triggers_per_block_range: u64,
+    pub get_logs_max_contracts: usize,
+    pub block_ingestor_max_concurrent_json_rpc_calls: usize,
+    pub genesis_block_number: u64,
+}
+
+impl ChainSettings {
+    /// Constructs a [`ChainSettings`] from environment variable defaults.
+    /// Used in tests and for firehose-only chains that have no RPC config.
+    pub fn from_env_defaults() -> Self {
+        ChainSettings {
+            polling_interval: graph::env::ENV_VARS.ingestor_polling_interval,
+            json_rpc_timeout: ENV_VARS.json_rpc_timeout,
+            request_retries: ENV_VARS.request_retries,
+            max_block_range_size: ENV_VARS.max_block_range_size,
+            block_batch_size: ENV_VARS.block_batch_size,
+            block_ptr_batch_size: ENV_VARS.block_ptr_batch_size,
+            max_event_only_range: ENV_VARS.max_event_only_range,
+            target_triggers_per_block_range: ENV_VARS.target_triggers_per_block_range,
+            get_logs_max_contracts: ENV_VARS.get_logs_max_contracts,
+            block_ingestor_max_concurrent_json_rpc_calls: ENV_VARS
+                .block_ingestor_max_concurrent_json_rpc_calls,
+            genesis_block_number: ENV_VARS.genesis_block_number,
+        }
+    }
+}
+
 pub struct EthereumStreamBuilder {}
 
 #[async_trait]
@@ -104,16 +150,26 @@ impl BlockStreamBuilder<Chain> for EthereumStreamBuilder {
         )))
     }
 
-    async fn build_substreams(
+    async fn build_subgraph_block_stream(
         &self,
-        _chain: &Chain,
-        _schema: InputSchema,
-        _deployment: DeploymentLocator,
-        _block_cursor: FirehoseCursor,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<<Chain as Blockchain>::TriggerFilter>,
+        chain: &Chain,
+        deployment: DeploymentLocator,
+        start_blocks: Vec<BlockNumber>,
+        source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
+        subgraph_current_block: Option<BlockPtr>,
+        filter: Arc<TriggerFilterWrapper<Chain>>,
+        unified_api_version: UnifiedMappingApiVersion,
     ) -> Result<Box<dyn BlockStream<Chain>>> {
-        unimplemented!()
+        self.build_polling(
+            chain,
+            deployment,
+            start_blocks,
+            source_subgraph_stores,
+            subgraph_current_block,
+            filter,
+            unified_api_version,
+        )
+        .await
     }
 
     async fn build_polling(
@@ -121,60 +177,75 @@ impl BlockStreamBuilder<Chain> for EthereumStreamBuilder {
         chain: &Chain,
         deployment: DeploymentLocator,
         start_blocks: Vec<BlockNumber>,
+        source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
         subgraph_current_block: Option<BlockPtr>,
-        filter: Arc<<Chain as Blockchain>::TriggerFilter>,
+        filter: Arc<TriggerFilterWrapper<Chain>>,
         unified_api_version: UnifiedMappingApiVersion,
     ) -> Result<Box<dyn BlockStream<Chain>>> {
-        let requirements = filter.node_capabilities();
-        let adapter = chain
-            .triggers_adapter(&deployment, &requirements, unified_api_version.clone())
-            .unwrap_or_else(|_| {
-                panic!(
-                    "no adapter for network {} with capabilities {}",
-                    chain.name, requirements
-                )
-            });
+        let requirements = filter.chain_filter.node_capabilities();
+        let is_using_subgraph_composition = !source_subgraph_stores.is_empty();
+        let adapter = TriggersAdapterWrapper::new(
+            chain
+                .triggers_adapter(&deployment, &requirements, unified_api_version.clone())
+                .unwrap_or_else(|_| {
+                    panic!(
+                        "no adapter for network {} with capabilities {}",
+                        chain.name, requirements
+                    )
+                }),
+            source_subgraph_stores,
+        );
 
         let logger = chain
             .logger_factory
             .subgraph_logger(&deployment)
             .new(o!("component" => "BlockStream"));
-        let chain_store = chain.chain_store();
         let chain_head_update_stream = chain
             .chain_head_update_listener
-            .subscribe(chain.name.clone(), logger.clone());
+            .subscribe(chain.name.to_string(), logger.clone());
 
         // Special case: Detect Celo and set the threshold to 0, so that eth_getLogs is always used.
         // This is ok because Celo blocks are always final. And we _need_ to do this because
         // some events appear only in eth_getLogs but not in transaction receipts.
         // See also ca0edc58-0ec5-4c89-a7dd-2241797f5e50.
-        let chain_id = match chain.chain_client().as_ref() {
+        let reorg_threshold = match chain.chain_client().as_ref() {
             ChainClient::Rpc(adapter) => {
-                adapter
+                let chain_id = adapter
                     .cheapest()
+                    .await
                     .ok_or(anyhow!("unable to get eth adapter for chan_id call"))?
                     .chain_id()
-                    .await?
+                    .await?;
+
+                if CELO_CHAIN_IDS.contains(&chain_id) {
+                    0
+                } else {
+                    chain.reorg_threshold
+                }
             }
-            _ => panic!("expected rpc when using polling blockstream"),
+            _ if is_using_subgraph_composition => chain.reorg_threshold,
+            _ => panic!(
+                "expected rpc when using polling blockstream : {}",
+                is_using_subgraph_composition
+            ),
         };
-        let reorg_threshold = match CELO_CHAIN_IDS.contains(&chain_id) {
-            false => chain.reorg_threshold,
-            true => 0,
+
+        let max_block_range_size = if is_using_subgraph_composition {
+            chain.settings.max_block_range_size * 10
+        } else {
+            chain.settings.max_block_range_size
         };
 
         Ok(Box::new(PollingBlockStream::new(
-            chain_store,
             chain_head_update_stream,
-            adapter,
-            chain.node_id.clone(),
+            Arc::new(adapter),
             deployment.hash,
             filter,
             start_blocks,
             reorg_threshold,
             logger,
-            ENV_VARS.max_block_range_size,
-            ENV_VARS.target_triggers_per_block_range,
+            max_block_range_size,
+            chain.settings.target_triggers_per_block_range,
             unified_api_version,
             subgraph_current_block,
         )))
@@ -195,7 +266,7 @@ impl BlockRefetcher<Chain> for EthereumBlockRefetcher {
         logger: &Logger,
         cursor: FirehoseCursor,
     ) -> Result<BlockFinality, Error> {
-        let endpoint = chain.chain_client().firehose_endpoint()?;
+        let endpoint: Arc<FirehoseEndpoint> = chain.chain_client().firehose_endpoint().await?;
         let block = endpoint.get_block::<codec::Block>(cursor, logger).await?;
         let ethereum_block: EthereumBlockWithCalls = (&block).try_into()?;
         Ok(BlockFinality::NonFinal(ethereum_block))
@@ -207,6 +278,7 @@ pub struct EthereumAdapterSelector {
     client: Arc<ChainClient<Chain>>,
     registry: Arc<MetricsRegistry>,
     chain_store: Arc<dyn ChainStore>,
+    eth_adapters: Arc<EthereumNetworkAdapters>,
 }
 
 impl EthereumAdapterSelector {
@@ -215,12 +287,14 @@ impl EthereumAdapterSelector {
         client: Arc<ChainClient<Chain>>,
         registry: Arc<MetricsRegistry>,
         chain_store: Arc<dyn ChainStore>,
+        eth_adapters: Arc<EthereumNetworkAdapters>,
     ) -> Self {
         Self {
             logger_factory,
             client,
             registry,
             chain_store,
+            eth_adapters,
         }
     }
 }
@@ -246,27 +320,57 @@ impl TriggersAdapterSelector<Chain> for EthereumAdapterSelector {
             chain_store: self.chain_store.cheap_clone(),
             unified_api_version,
             capabilities: *capabilities,
+            eth_adapters: self.eth_adapters.cheap_clone(),
         };
         Ok(Arc::new(adapter))
     }
 }
 
+/// We need this so that the runner tests can use a `NoopRuntimeAdapter`
+/// instead of the `RuntimeAdapter` from this crate to avoid needing
+/// ethereum adapters
+pub trait RuntimeAdapterBuilder: Send + Sync + 'static {
+    fn build(
+        &self,
+        eth_adapters: Arc<EthereumNetworkAdapters>,
+        call_cache: Arc<dyn EthereumCallCache>,
+        chain_identifier: Arc<ChainIdentifier>,
+    ) -> Arc<dyn RuntimeAdapterTrait<Chain>>;
+}
+
+pub struct EthereumRuntimeAdapterBuilder {}
+
+impl RuntimeAdapterBuilder for EthereumRuntimeAdapterBuilder {
+    fn build(
+        &self,
+        eth_adapters: Arc<EthereumNetworkAdapters>,
+        call_cache: Arc<dyn EthereumCallCache>,
+        chain_identifier: Arc<ChainIdentifier>,
+    ) -> Arc<dyn RuntimeAdapterTrait<Chain>> {
+        Arc::new(RuntimeAdapter {
+            eth_adapters,
+            call_cache,
+            chain_identifier,
+        })
+    }
+}
+
 pub struct Chain {
     logger_factory: LoggerFactory,
-    name: String,
-    node_id: NodeId,
+    pub name: ChainName,
     registry: Arc<MetricsRegistry>,
     client: Arc<ChainClient<Self>>,
     chain_store: Arc<dyn ChainStore>,
     call_cache: Arc<dyn EthereumCallCache>,
     chain_head_update_listener: Arc<dyn ChainHeadUpdateListener>,
     reorg_threshold: BlockNumber,
-    polling_ingestor_interval: Duration,
     pub is_ingestible: bool,
     block_stream_builder: Arc<dyn BlockStreamBuilder<Self>>,
     block_refetcher: Arc<dyn BlockRefetcher<Self>>,
     adapter_selector: Arc<dyn TriggersAdapterSelector<Self>>,
-    runtime_adapter: Arc<dyn RuntimeAdapterTrait<Self>>,
+    runtime_adapter_builder: Arc<dyn RuntimeAdapterBuilder>,
+    eth_adapters: Arc<EthereumNetworkAdapters>,
+    pub settings: Arc<ChainSettings>,
 }
 
 impl std::fmt::Debug for Chain {
@@ -275,12 +379,43 @@ impl std::fmt::Debug for Chain {
     }
 }
 
+/// Walk back from a block pointer by following parent pointers.
+/// This is the core logic used as a fallback when the cache doesn't have ancestor block.
+///
+async fn walk_back_ancestor<F, Fut, E>(
+    start_ptr: BlockPtr,
+    offset: BlockNumber,
+    root: Option<BlockHash>,
+    mut parent_getter: F,
+) -> Result<Option<BlockPtr>, E>
+where
+    F: FnMut(BlockPtr) -> Fut,
+    Fut: std::future::Future<Output = Result<Option<BlockPtr>, E>>,
+{
+    let mut current_ptr = start_ptr;
+
+    for _ in 0..offset {
+        match parent_getter(current_ptr.clone()).await? {
+            Some(parent) => {
+                if let Some(root_hash) = &root
+                    && parent.hash == *root_hash
+                {
+                    break;
+                }
+                current_ptr = parent;
+            }
+            None => return Ok(None),
+        }
+    }
+
+    Ok(Some(current_ptr))
+}
+
 impl Chain {
     /// Creates a new Ethereum [`Chain`].
     pub fn new(
         logger_factory: LoggerFactory,
-        name: String,
-        node_id: NodeId,
+        name: ChainName,
         registry: Arc<MetricsRegistry>,
         chain_store: Arc<dyn ChainStore>,
         call_cache: Arc<dyn EthereumCallCache>,
@@ -289,15 +424,15 @@ impl Chain {
         block_stream_builder: Arc<dyn BlockStreamBuilder<Self>>,
         block_refetcher: Arc<dyn BlockRefetcher<Self>>,
         adapter_selector: Arc<dyn TriggersAdapterSelector<Self>>,
-        runtime_adapter: Arc<dyn RuntimeAdapterTrait<Self>>,
+        runtime_adapter_builder: Arc<dyn RuntimeAdapterBuilder>,
+        eth_adapters: Arc<EthereumNetworkAdapters>,
         reorg_threshold: BlockNumber,
-        polling_ingestor_interval: Duration,
         is_ingestible: bool,
+        settings: Arc<ChainSettings>,
     ) -> Self {
         Chain {
             logger_factory,
             name,
-            node_id,
             registry,
             client,
             chain_store,
@@ -306,10 +441,11 @@ impl Chain {
             block_stream_builder,
             block_refetcher,
             adapter_selector,
-            runtime_adapter,
+            runtime_adapter_builder,
+            eth_adapters,
             reorg_threshold,
             is_ingestible,
-            polling_ingestor_interval,
+            settings,
         }
     }
 
@@ -318,15 +454,22 @@ impl Chain {
         self.call_cache.clone()
     }
 
+    pub async fn block_number(
+        &self,
+        hash: &BlockHash,
+    ) -> Result<Option<(String, BlockNumber, Option<u64>, Option<BlockHash>)>, StoreError> {
+        self.chain_store.block_number(hash).await
+    }
+
     // TODO: This is only used to build the block stream which could prolly
     // be moved to the chain itself and return a block stream future that the
     // caller can spawn.
-    pub fn cheapest_adapter(&self) -> Arc<EthereumAdapter> {
+    pub async fn cheapest_adapter(&self) -> Arc<EthereumAdapter> {
         let adapters = match self.client.as_ref() {
             ChainClient::Firehose(_) => panic!("no adapter with firehose"),
             ChainClient::Rpc(adapter) => adapter,
         };
-        adapters.cheapest().unwrap()
+        adapters.cheapest().await.unwrap()
     }
 }
 
@@ -354,6 +497,8 @@ impl Blockchain for Chain {
 
     type NodeCapabilities = crate::capabilities::NodeCapabilities;
 
+    type DecoderHook = crate::data_source::DecoderHook;
+
     fn triggers_adapter(
         &self,
         loc: &DeploymentLocator,
@@ -369,10 +514,27 @@ impl Blockchain for Chain {
         deployment: DeploymentLocator,
         store: impl DeploymentCursorTracker,
         start_blocks: Vec<BlockNumber>,
-        filter: Arc<Self::TriggerFilter>,
+        source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
+        filter: Arc<TriggerFilterWrapper<Self>>,
         unified_api_version: UnifiedMappingApiVersion,
     ) -> Result<Box<dyn BlockStream<Self>>, Error> {
         let current_ptr = store.block_ptr();
+
+        if !filter.subgraph_filter.is_empty() {
+            return self
+                .block_stream_builder
+                .build_subgraph_block_stream(
+                    self,
+                    deployment,
+                    start_blocks,
+                    source_subgraph_stores,
+                    current_ptr,
+                    filter,
+                    unified_api_version,
+                )
+                .await;
+        }
+
         match self.chain_client().as_ref() {
             ChainClient::Rpc(_) => {
                 self.block_stream_builder
@@ -380,6 +542,7 @@ impl Blockchain for Chain {
                         self,
                         deployment,
                         start_blocks,
+                        source_subgraph_stores,
                         current_ptr,
                         filter,
                         unified_api_version,
@@ -394,7 +557,7 @@ impl Blockchain for Chain {
                         store.firehose_cursor(),
                         start_blocks,
                         current_ptr,
-                        filter,
+                        filter.chain_filter.clone(),
                         unified_api_version,
                     )
                     .await
@@ -402,8 +565,8 @@ impl Blockchain for Chain {
         }
     }
 
-    fn chain_store(&self) -> Arc<dyn ChainStore> {
-        self.chain_store.clone()
+    async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error> {
+        self.chain_store.cheap_clone().chain_head_ptr().await
     }
 
     async fn block_pointer_from_number(
@@ -413,20 +576,34 @@ impl Blockchain for Chain {
     ) -> Result<BlockPtr, IngestorError> {
         match self.client.as_ref() {
             ChainClient::Firehose(endpoints) => endpoints
-                .endpoint()?
+                .endpoint()
+                .await?
                 .block_ptr_for_number::<HeaderOnlyBlock>(logger, number)
                 .await
                 .map_err(IngestorError::Unknown),
             ChainClient::Rpc(adapters) => {
+                let cached = self
+                    .chain_store
+                    .cheap_clone()
+                    .block_ptrs_by_numbers(vec![number])
+                    .await
+                    .unwrap_or_default();
+                if let Some(ptrs) = cached.get(&number)
+                    && ptrs.len() == 1
+                {
+                    return Ok(BlockPtr::new(ptrs[0].hash.clone(), ptrs[0].number));
+                }
+
                 let adapter = adapters
                     .cheapest()
+                    .await
                     .with_context(|| format!("no adapter for chain {}", self.name))?
                     .clone();
 
                 adapter
-                    .block_pointer_from_number(logger, number)
-                    .compat()
+                    .next_existing_ptr_to_number(logger, number)
                     .await
+                    .map_err(From::from)
             }
         }
     }
@@ -443,19 +620,37 @@ impl Blockchain for Chain {
         self.block_refetcher.get_block(self, logger, cursor).await
     }
 
-    fn runtime_adapter(&self) -> Arc<dyn RuntimeAdapterTrait<Self>> {
-        self.runtime_adapter.clone()
+    async fn runtime(
+        &self,
+    ) -> anyhow::Result<(Arc<dyn RuntimeAdapterTrait<Self>>, Self::DecoderHook)> {
+        let call_cache = Arc::new(BufferedCallCache::new(self.call_cache.cheap_clone()));
+        let chain_ident = self.chain_store.chain_identifier().await?;
+
+        let builder = self.runtime_adapter_builder.build(
+            self.eth_adapters.cheap_clone(),
+            call_cache.cheap_clone(),
+            Arc::new(chain_ident.clone()),
+        );
+        let eth_call_gas = eth_call_gas(&chain_ident);
+
+        let decoder_hook = crate::data_source::DecoderHook::new(
+            self.eth_adapters.cheap_clone(),
+            call_cache,
+            eth_call_gas,
+        );
+
+        Ok((builder, decoder_hook))
     }
 
     fn chain_client(&self) -> Arc<ChainClient<Self>> {
         self.client.clone()
     }
 
-    fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>> {
+    async fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>> {
         let ingestor: Box<dyn BlockIngestor> = match self.chain_client().as_ref() {
             ChainClient::Firehose(_) => {
                 let ingestor = FirehoseBlockIngestor::<HeaderOnlyBlock, Self>::new(
-                    self.chain_store.cheap_clone(),
+                    self.chain_store.cheap_clone().as_head_store(),
                     self.chain_client(),
                     self.logger_factory
                         .component_logger("EthereumFirehoseBlockIngestor", None),
@@ -465,10 +660,7 @@ impl Blockchain for Chain {
 
                 Box::new(ingestor)
             }
-            ChainClient::Rpc(rpc) => {
-                let eth_adapter = rpc
-                    .cheapest()
-                    .ok_or_else(|| anyhow!("unable to get adapter for ethereum block ingestor"))?;
+            ChainClient::Rpc(_) => {
                 let logger = self
                     .logger_factory
                     .component_logger(
@@ -479,7 +671,7 @@ impl Blockchain for Chain {
                             }),
                         }),
                     )
-                    .new(o!("provider" => eth_adapter.provider().to_string()));
+                    .new(o!());
 
                 if !self.is_ingestible {
                     bail!(
@@ -493,10 +685,10 @@ impl Blockchain for Chain {
                 // present in the DB.
                 Box::new(PollingBlockIngestor::new(
                     logger,
-                    graph::env::ENV_VARS.reorg_threshold,
-                    eth_adapter,
-                    self.chain_store().cheap_clone(),
-                    self.polling_ingestor_interval,
+                    graph::env::ENV_VARS.reorg_threshold(),
+                    self.chain_client(),
+                    self.chain_store.cheap_clone(),
+                    self.settings.polling_interval,
                     self.name.clone(),
                 )?)
             }
@@ -516,6 +708,8 @@ pub enum BlockFinality {
 
     // If a block may still be reorged, we need to work with more local data.
     NonFinal(EthereumBlockWithCalls),
+
+    Ptr(Arc<ExtendedBlockPtr>),
 }
 
 impl Default for BlockFinality {
@@ -529,15 +723,7 @@ impl BlockFinality {
         match self {
             BlockFinality::Final(block) => block,
             BlockFinality::NonFinal(block) => &block.ethereum_block.block,
-        }
-    }
-}
-
-impl<'a> From<&'a BlockFinality> for BlockPtr {
-    fn from(block: &'a BlockFinality) -> BlockPtr {
-        match block {
-            BlockFinality::Final(b) => BlockPtr::from(&**b),
-            BlockFinality::NonFinal(b) => BlockPtr::from(&b.ethereum_block),
+            BlockFinality::Ptr(_) => unreachable!("light_block called on HeaderOnly"),
         }
     }
 }
@@ -547,6 +733,7 @@ impl Block for BlockFinality {
         match self {
             BlockFinality::Final(block) => block.block_ptr(),
             BlockFinality::NonFinal(block) => block.ethereum_block.block.block_ptr(),
+            BlockFinality::Ptr(block) => BlockPtr::new(block.hash.clone(), block.number),
         }
     }
 
@@ -554,6 +741,9 @@ impl Block for BlockFinality {
         match self {
             BlockFinality::Final(block) => block.parent_ptr(),
             BlockFinality::NonFinal(block) => block.ethereum_block.block.parent_ptr(),
+            BlockFinality::Ptr(block) => {
+                Some(BlockPtr::new(block.parent_hash.clone(), block.number - 1))
+            }
         }
     }
 
@@ -586,16 +776,22 @@ impl Block for BlockFinality {
                 json::to_value(eth_block)
             }
             BlockFinality::NonFinal(block) => json::to_value(&block.ethereum_block),
+            BlockFinality::Ptr(_) => Ok(json::Value::Null),
         }
     }
 
     fn timestamp(&self) -> BlockTime {
-        let ts = match self {
-            BlockFinality::Final(block) => block.timestamp,
-            BlockFinality::NonFinal(block) => block.ethereum_block.block.timestamp,
-        };
-        let ts = i64::try_from(ts.as_u64()).unwrap();
-        BlockTime::since_epoch(ts, 0)
+        match self {
+            BlockFinality::Final(block) => {
+                let ts = i64::try_from(block.timestamp_u64()).unwrap();
+                BlockTime::since_epoch(ts, 0)
+            }
+            BlockFinality::NonFinal(block) => {
+                let ts = i64::try_from(block.ethereum_block.block.timestamp_u64()).unwrap();
+                BlockTime::since_epoch(ts, 0)
+            }
+            BlockFinality::Ptr(block) => block.timestamp,
+        }
     }
 }
 
@@ -608,6 +804,104 @@ pub struct TriggersAdapter {
     chain_client: Arc<ChainClient<Chain>>,
     capabilities: NodeCapabilities,
     unified_api_version: UnifiedMappingApiVersion,
+    eth_adapters: Arc<EthereumNetworkAdapters>,
+}
+
+/// Fetches blocks from the cache based on block numbers, excluding duplicates
+/// (i.e., multiple blocks for the same number), and identifying missing blocks that
+/// need to be fetched via RPC/Firehose. Returns a tuple of the found blocks and the missing block numbers.
+async fn fetch_unique_blocks_from_cache(
+    logger: &Logger,
+    chain_store: Arc<dyn ChainStore>,
+    block_numbers: BTreeSet<BlockNumber>,
+) -> (Vec<Arc<ExtendedBlockPtr>>, Vec<i32>) {
+    // Load blocks from the cache
+    let blocks_map = chain_store
+        .cheap_clone()
+        .block_ptrs_by_numbers(block_numbers.iter().copied().collect::<Vec<_>>())
+        .await
+        .map_err(|e| {
+            error!(logger, "Error accessing block cache {}", e);
+            e
+        })
+        .unwrap_or_default();
+
+    // Collect blocks and filter out ones with multiple entries
+    let blocks: Vec<Arc<ExtendedBlockPtr>> = blocks_map
+        .into_values()
+        .filter_map(|values| {
+            if values.len() == 1 {
+                Some(Arc::new(values[0].clone()))
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    // Identify missing blocks
+    let missing_blocks: Vec<i32> = block_numbers
+        .into_iter()
+        .filter(|&number| !blocks.iter().any(|block| block.block_number() == number))
+        .collect();
+
+    if !missing_blocks.is_empty() {
+        debug!(
+            logger,
+            "Loading {} block(s) not in the block cache",
+            missing_blocks.len()
+        );
+        trace!(logger, "Missing blocks {:?}", missing_blocks.len());
+    }
+
+    (blocks, missing_blocks)
+}
+
+// This is used to load blocks from the RPC.
+async fn load_blocks_with_rpc(
+    logger: &Logger,
+    adapter: Arc<EthereumAdapter>,
+    chain_store: Arc<dyn ChainStore>,
+    block_numbers: BTreeSet<BlockNumber>,
+) -> Result<Vec<BlockFinality>> {
+    let logger_clone = logger.clone();
+    load_blocks(
+        logger,
+        chain_store,
+        block_numbers,
+        |missing_numbers| async move {
+            adapter
+                .load_block_ptrs_by_numbers_rpc(logger_clone, missing_numbers)
+                .try_collect()
+                .await
+        },
+    )
+    .await
+}
+
+/// Fetches blocks by their numbers, first attempting to load from cache.
+/// Missing blocks are retrieved from an external source, with all blocks sorted and converted to `BlockFinality` format.
+async fn load_blocks<F, Fut>(
+    logger: &Logger,
+    chain_store: Arc<dyn ChainStore>,
+    block_numbers: BTreeSet<BlockNumber>,
+    fetch_missing: F,
+) -> Result<Vec<BlockFinality>>
+where
+    F: FnOnce(Vec<BlockNumber>) -> Fut,
+    Fut: Future<Output = Result<Vec<Arc<ExtendedBlockPtr>>>>,
+{
+    // Fetch cached blocks and identify missing ones
+    let (mut cached_blocks, missing_block_numbers) =
+        fetch_unique_blocks_from_cache(logger, chain_store, block_numbers).await;
+
+    // Fetch missing blocks if any
+    if !missing_block_numbers.is_empty() {
+        let missing_blocks = fetch_missing(missing_block_numbers).await?;
+        cached_blocks.extend(missing_blocks);
+        cached_blocks.sort_by_key(|block| block.number);
+    }
+
+    Ok(cached_blocks.into_iter().map(BlockFinality::Ptr).collect())
 }
 
 #[async_trait]
@@ -617,9 +911,12 @@ impl TriggersAdapterTrait<Chain> for TriggersAdapter {
         from: BlockNumber,
         to: BlockNumber,
         filter: &TriggerFilter,
-    ) -> Result<Vec<BlockWithTriggers<Chain>>, Error> {
+    ) -> Result<(Vec<BlockWithTriggers<Chain>>, BlockNumber), Error> {
         blocks_with_triggers(
-            self.chain_client.rpc()?.cheapest_with(&self.capabilities)?,
+            self.chain_client
+                .rpc()?
+                .cheapest_with(&self.capabilities)
+                .await?,
             self.logger.clone(),
             self.chain_store.clone(),
             self.ethrpc_metrics.clone(),
@@ -631,6 +928,100 @@ impl TriggersAdapterTrait<Chain> for TriggersAdapter {
         .await
     }
 
+    async fn load_block_ptrs_by_numbers(
+        &self,
+        logger: Logger,
+        block_numbers: BTreeSet<BlockNumber>,
+    ) -> Result<Vec<BlockFinality>> {
+        match &*self.chain_client {
+            ChainClient::Firehose(endpoints) => {
+                // If the force_rpc_for_block_ptrs flag is set, we will use the RPC to load the blocks
+                // even if the firehose is available. If no adapter is available, we will log an error.
+                // And then fallback to the firehose.
+                if ENV_VARS.force_rpc_for_block_ptrs {
+                    trace!(
+                        logger,
+                        "Loading blocks from RPC (force_rpc_for_block_ptrs is set)";
+                        "block_numbers" => format!("{:?}", block_numbers)
+                    );
+                    match self.eth_adapters.cheapest_with(&self.capabilities).await {
+                        Ok(adapter) => {
+                            match load_blocks_with_rpc(
+                                &logger,
+                                adapter,
+                                self.chain_store.clone(),
+                                block_numbers.clone(),
+                            )
+                            .await
+                            {
+                                Ok(blocks) => return Ok(blocks),
+                                Err(e) => {
+                                    warn!(logger, "Error loading blocks from RPC: {}", e);
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            warn!(logger, "Error getting cheapest adapter: {}", e);
+                        }
+                    }
+                }
+
+                trace!(
+                    logger,
+                    "Loading blocks from firehose";
+                    "block_numbers" => format!("{:?}", block_numbers)
+                );
+
+                let endpoint = endpoints.endpoint().await?;
+                let chain_store = self.chain_store.clone();
+                let logger_clone = logger.clone();
+
+                load_blocks(
+                    &logger,
+                    chain_store,
+                    block_numbers,
+                    |missing_numbers| async move {
+                        let blocks = endpoint
+                            .load_blocks_by_numbers::<codec::Block>(
+                                missing_numbers.iter().map(|&n| n as u64).collect(),
+                                &logger_clone,
+                            )
+                            .await?
+                            .into_iter()
+                            .map(|block| {
+                                Arc::new(ExtendedBlockPtr {
+                                    hash: block.hash(),
+                                    number: block.number(),
+                                    parent_hash: block.parent_hash().unwrap_or_default(),
+                                    timestamp: block.timestamp(),
+                                })
+                            })
+                            .collect::<Vec<_>>();
+                        Ok(blocks)
+                    },
+                )
+                .await
+            }
+
+            ChainClient::Rpc(eth_adapters) => {
+                trace!(
+                    logger,
+                    "Loading blocks from RPC";
+                    "block_numbers" => format!("{:?}", block_numbers)
+                );
+
+                let adapter = eth_adapters.cheapest_with(&self.capabilities).await?;
+                load_blocks_with_rpc(&logger, adapter, self.chain_store.clone(), block_numbers)
+                    .await
+            }
+        }
+    }
+
+    async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error> {
+        let chain_store = self.chain_store.clone();
+        chain_store.chain_head_ptr().await
+    }
+
     async fn triggers_in_block(
         &self,
         logger: &Logger,
@@ -649,9 +1040,13 @@ impl TriggersAdapterTrait<Chain> for TriggersAdapter {
 
         match &block {
             BlockFinality::Final(_) => {
-                let adapter = self.chain_client.rpc()?.cheapest_with(&self.capabilities)?;
+                let adapter = self
+                    .chain_client
+                    .rpc()?
+                    .cheapest_with(&self.capabilities)
+                    .await?;
                 let block_number = block.number() as BlockNumber;
-                let blocks = blocks_with_triggers(
+                let (blocks, _) = blocks_with_triggers(
                     adapter,
                     logger.clone(),
                     self.chain_store.clone(),
@@ -675,69 +1070,232 @@ impl TriggersAdapterTrait<Chain> for TriggersAdapter {
                 triggers.append(&mut parse_block_triggers(&filter.block, full_block));
                 Ok(BlockWithTriggers::new(block, triggers, logger))
             }
+            BlockFinality::Ptr(_) => unreachable!("triggers_in_block called on HeaderOnly"),
         }
     }
 
     async fn is_on_main_chain(&self, ptr: BlockPtr) -> Result<bool, Error> {
-        self.chain_client
-            .rpc()?
-            .cheapest()
-            .ok_or(anyhow!("unable to get adapter for is_on_main_chain"))?
-            .is_on_main_chain(&self.logger, ptr.clone())
-            .await
+        // It is tempting to use the block cache here; but that can go wrong
+        // when graph-node gets shut down and some of its nonfinal blocks
+        // then are reorged; when graph-node gets started again when those
+        // block numbers have become final, it might consider a reorged
+        // block as canonical; allowing the use of the block cache here
+        // would require us to also track the finality of blocks.
+        match &*self.chain_client {
+            ChainClient::Firehose(endpoints) => {
+                let endpoint = endpoints.endpoint().await?;
+                let block = endpoint
+                    .get_block_by_number_with_retry::<codec::Block>(ptr.number as u64, &self.logger)
+                    .await
+                    .context(format!(
+                        "Failed to fetch block {} from firehose",
+                        ptr.number
+                    ))?;
+                Ok(block.hash() == ptr.hash)
+            }
+            ChainClient::Rpc(adapter) => {
+                let adapter = adapter
+                    .cheapest()
+                    .await
+                    .ok_or_else(|| anyhow!("unable to get adapter for is_on_main_chain"))?;
+
+                adapter.is_on_main_chain(&self.logger, ptr).await
+            }
+        }
     }
 
+    // Find an ancestor block at the specified offset from the given block pointer.
+    // Primarily used for reorg detection to verify if the indexed position remains
+    // on the main chain.
+    //
+    // Parameters:
+    // - ptr: Starting block pointer from which to walk backwards (typically the chain head)
+    // - offset: Number of blocks to traverse backwards (0 returns ptr, 1 returns parent, etc.)
+    // - root: Optional block hash that serves as a boundary for traversal. This is ESSENTIAL
+    //         for chains with skipped blocks (e.g., Filecoin EVM) where block numbers are not
+    //         consecutive. When provided, traversal stops upon reaching the child of root,
+    //         ensuring correct ancestor relationships even with gaps in block numbers.
+    //
+    // The function attempts to use the database cache first for performance,
+    // with RPC fallback implemented to handle cases where the cache is unavailable.
     async fn ancestor_block(
         &self,
         ptr: BlockPtr,
         offset: BlockNumber,
+        root: Option<BlockHash>,
     ) -> Result<Option<BlockFinality>, Error> {
-        let block: Option<EthereumBlock> = self
+        let ptr_for_log = ptr.clone();
+        let cached = self
             .chain_store
             .cheap_clone()
-            .ancestor_block(ptr, offset)
-            .await?
-            .map(json::from_value)
-            .transpose()?;
-        Ok(block.map(|block| {
-            BlockFinality::NonFinal(EthereumBlockWithCalls {
-                ethereum_block: block,
-                calls: None,
-            })
-        }))
+            .ancestor_block(ptr.clone(), offset, root.clone())
+            .await?;
+
+        // Use full blocks (with receipts) directly from cache.
+        // Light blocks (no receipts) need to be fetched from Firehose/RPC.
+        let block_ptr = match cached {
+            Some((cached_block, ptr)) => match cached_block.into_full_block() {
+                Some(block) => {
+                    return Ok(Some(BlockFinality::NonFinal(EthereumBlockWithCalls {
+                        ethereum_block: block,
+                        calls: None,
+                    })));
+                }
+                None => {
+                    trace!(
+                        self.logger,
+                        "Cached block #{} {} is light (no receipts). Falling back to Firehose/RPC.",
+                        ptr.number,
+                        ptr.hash_hex(),
+                    );
+                    ptr
+                }
+            },
+            None => {
+                // Cache miss - fall back to walking the chain via parent_ptr() calls.
+                // This provides resilience when the block cache is empty (e.g., after truncation).
+                debug!(
+                    self.logger,
+                    "ancestor_block cache miss for {} at offset {}, walking back via parent_ptr",
+                    ptr_for_log.hash_hex(),
+                    offset
+                );
+
+                match walk_back_ancestor(
+                    ptr.clone(),
+                    offset,
+                    root.clone(),
+                    |block_ptr| async move { self.parent_ptr(&block_ptr).await },
+                )
+                .await?
+                {
+                    Some(ptr) => ptr,
+                    None => return Ok(None),
+                }
+            }
+        };
+
+        // Fetch the actual block data for the identified block pointer.
+        // This path is taken for both cache misses and deserialization failures.
+        match self.chain_client.as_ref() {
+            ChainClient::Firehose(endpoints) => {
+                let block = self
+                    .fetch_block_with_firehose(endpoints, &block_ptr)
+                    .await?;
+                let ethereum_block: EthereumBlockWithCalls = (&block).try_into()?;
+                Ok(Some(BlockFinality::NonFinal(ethereum_block)))
+            }
+            ChainClient::Rpc(adapters) => {
+                match self.fetch_full_block_with_rpc(adapters, &block_ptr).await? {
+                    Some(ethereum_block) => {
+                        Ok(Some(BlockFinality::NonFinal(EthereumBlockWithCalls {
+                            ethereum_block,
+                            calls: None,
+                        })))
+                    }
+                    None => Ok(None),
+                }
+            }
+        }
     }
 
     async fn parent_ptr(&self, block: &BlockPtr) -> Result<Option<BlockPtr>, Error> {
-        use futures::stream::Stream;
         use graph::prelude::LightEthereumBlockExt;
 
         let block = match self.chain_client.as_ref() {
-            ChainClient::Firehose(_) => Some(BlockPtr {
-                hash: BlockHash::from(vec![0xff; 32]),
-                number: block.number.saturating_sub(1),
-            }),
-            ChainClient::Rpc(adapters) => {
-                let blocks = adapters
-                    .cheapest_with(&self.capabilities)?
-                    .load_blocks(
-                        self.logger.cheap_clone(),
-                        self.chain_store.cheap_clone(),
-                        HashSet::from_iter(Some(block.hash_as_h256())),
-                    )
-                    .await
-                    .collect()
-                    .compat()
-                    .await?;
-                assert_eq!(blocks.len(), 1);
+            ChainClient::Firehose(endpoints) => {
+                let chain_store = self.chain_store.cheap_clone();
+                // First try to get the parent pointer from the store header columns
+                if let Ok(Some(parent)) = chain_store.block_parent_ptr(&block.hash).await {
+                    return Ok(Some(parent));
+                }
 
-                blocks[0].parent_ptr()
+                // If not in store, fetch from Firehose
+                self.fetch_block_with_firehose(endpoints, block)
+                    .await?
+                    .parent_ptr()
             }
+            ChainClient::Rpc(adapters) => self
+                .fetch_light_block_with_rpc(adapters, block)
+                .await?
+                .expect("block must exist for parent_ptr")
+                .parent_ptr(),
         };
 
         Ok(block)
     }
 }
 
+impl TriggersAdapter {
+    async fn fetch_block_with_firehose(
+        &self,
+        endpoints: &FirehoseEndpoints,
+        block_ptr: &BlockPtr,
+    ) -> Result<codec::Block, Error> {
+        let endpoint = endpoints.endpoint().await?;
+        let logger = self.logger.clone();
+        let retry_log_message = format!("fetch_block_with_firehose {}", block_ptr);
+        let block_ptr = block_ptr.clone();
+
+        let block = retry(retry_log_message, &logger)
+            .limit(ENV_VARS.request_retries)
+            .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
+            .run(move || {
+                let endpoint = endpoint.cheap_clone();
+                let logger = logger.cheap_clone();
+                let block_ptr = block_ptr.clone();
+                async move {
+                    endpoint
+                        .get_block_by_ptr::<codec::Block>(&block_ptr, &logger)
+                        .await
+                        .context(format!("Failed to fetch block {} from firehose", block_ptr))
+                }
+            })
+            .await?;
+
+        Ok(block)
+    }
+
+    async fn fetch_light_block_with_rpc(
+        &self,
+        adapters: &EthereumNetworkAdapters,
+        block_ptr: &BlockPtr,
+    ) -> Result<Option<Arc<LightEthereumBlock>>, Error> {
+        let blocks = adapters
+            .cheapest_with(&self.capabilities)
+            .await?
+            .load_blocks(
+                self.logger.cheap_clone(),
+                self.chain_store.cheap_clone(),
+                HashSet::from_iter(Some(block_ptr.hash.as_b256())),
+            )
+            .await?;
+
+        Ok(blocks.into_iter().next())
+    }
+
+    async fn fetch_full_block_with_rpc(
+        &self,
+        adapters: &EthereumNetworkAdapters,
+        block_ptr: &BlockPtr,
+    ) -> Result<Option<EthereumBlock>, Error> {
+        // Use the cache-aware light block fetch first; it checks recent_blocks_cache
+        // and the DB before falling back to eth_getBlockByHash.
+        let light_block = self.fetch_light_block_with_rpc(adapters, block_ptr).await?;
+        match light_block {
+            Some(light_block) => {
+                let adapter = adapters.cheapest_with(&self.capabilities).await?;
+                let ethereum_block = adapter
+                    .load_full_block(&self.logger, light_block.inner().clone())
+                    .await
+                    .map_err(|e| anyhow!("Failed to load full block: {}", e))?;
+                Ok(Some(ethereum_block))
+            }
+            None => Ok(None),
+        }
+    }
+}
+
 pub struct FirehoseMapper {
     adapter: Arc<dyn TriggersAdapterTrait<Chain>>,
     filter: Arc<TriggerFilter>,
@@ -745,10 +1303,15 @@ pub struct FirehoseMapper {
 
 #[async_trait]
 impl BlockStreamMapper<Chain> for FirehoseMapper {
-    fn decode_block(&self, output: Option<&[u8]>) -> Result<Option<BlockFinality>, Error> {
+    fn decode_block(
+        &self,
+        output: Option<&[u8]>,
+    ) -> Result<Option<BlockFinality>, BlockStreamError> {
         let block = match output {
             Some(block) => codec::Block::decode(block)?,
-            None => anyhow::bail!("ethereum mapper is expected to always have a block"),
+            None => Err(anyhow::anyhow!(
+                "ethereum mapper is expected to always have a block"
+            ))?,
         };
 
         // See comment(437a9f17-67cc-478f-80a3-804fe554b227) ethereum_block.calls is always Some even if calls
@@ -762,20 +1325,11 @@ impl BlockStreamMapper<Chain> for FirehoseMapper {
         &self,
         logger: &Logger,
         block: BlockFinality,
-    ) -> Result<BlockWithTriggers<Chain>, Error> {
+    ) -> Result<BlockWithTriggers<Chain>, BlockStreamError> {
         self.adapter
             .triggers_in_block(logger, block, &self.filter)
             .await
-    }
-
-    async fn handle_substreams_block(
-        &self,
-        _logger: &Logger,
-        _clock: Clock,
-        _cursor: FirehoseCursor,
-        _block: Vec<u8>,
-    ) -> Result<BlockStreamEvent<Chain>, Error> {
-        unimplemented!()
+            .map_err(BlockStreamError::from)
     }
 }
 
@@ -790,7 +1344,7 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
         logger: &Logger,
         response: &firehose::Response,
     ) -> Result<BlockStreamEvent<Chain>, FirehoseError> {
-        let step = ForkStep::from_i32(response.step).unwrap_or_else(|| {
+        let step = ForkStep::try_from(response.step).unwrap_or_else(|_| {
             panic!(
                 "unknown step i32 value {}, maybe you forgot update & re-regenerate the protobuf definitions?",
                 response.step
@@ -835,7 +1389,9 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
             }
 
             StepFinal => {
-                unreachable!("irreversible step is not handled and should not be requested in the Firehose request")
+                unreachable!(
+                    "irreversible step is not handled and should not be requested in the Firehose request"
+                )
             }
 
             StepUnset => {
@@ -873,3 +1429,251 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
             .await
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use graph::blockchain::mock::MockChainStore;
+    use graph::slog;
+
+    use super::*;
+    use std::sync::Arc;
+
+    // Helper function to create test blocks
+    fn create_test_block(number: BlockNumber, hash: &str) -> ExtendedBlockPtr {
+        let hash = BlockHash(hash.as_bytes().to_vec().into_boxed_slice());
+        let ptr = BlockPtr::new(hash.clone(), number);
+        ExtendedBlockPtr {
+            hash,
+            number,
+            parent_hash: BlockHash(vec![0; 32].into_boxed_slice()),
+            timestamp: BlockTime::for_test(&ptr),
+        }
+    }
+
+    #[graph::test]
+    async fn test_fetch_unique_blocks_single_block() {
+        let logger = Logger::root(slog::Discard, o!());
+        let mut chain_store = MockChainStore::default();
+
+        // Add a single block
+        let block = create_test_block(1, "block1");
+        chain_store.blocks.insert(1, vec![block.clone()]);
+
+        let block_numbers: BTreeSet<_> = vec![1].into_iter().collect();
+
+        let (blocks, missing) =
+            fetch_unique_blocks_from_cache(&logger, Arc::new(chain_store), block_numbers).await;
+
+        assert_eq!(blocks.len(), 1);
+        assert_eq!(blocks[0].number, 1);
+        assert!(missing.is_empty());
+    }
+
+    #[graph::test]
+    async fn test_fetch_unique_blocks_duplicate_blocks() {
+        let logger = Logger::root(slog::Discard, o!());
+        let mut chain_store = MockChainStore::default();
+
+        // Add multiple blocks for the same number
+        let block1 = create_test_block(1, "block1a");
+        let block2 = create_test_block(1, "block1b");
+        chain_store
+            .blocks
+            .insert(1, vec![block1.clone(), block2.clone()]);
+
+        let block_numbers: BTreeSet<_> = vec![1].into_iter().collect();
+
+        let (blocks, missing) =
+            fetch_unique_blocks_from_cache(&logger, Arc::new(chain_store), block_numbers).await;
+
+        // Should filter out the duplicate block
+        assert!(blocks.is_empty());
+        assert_eq!(missing, vec![1]);
+        assert_eq!(missing[0], 1);
+    }
+
+    #[graph::test]
+    async fn test_fetch_unique_blocks_missing_blocks() {
+        let logger = Logger::root(slog::Discard, o!());
+        let mut chain_store = MockChainStore::default();
+
+        // Add block number 1 but not 2
+        let block = create_test_block(1, "block1");
+        chain_store.blocks.insert(1, vec![block.clone()]);
+
+        let block_numbers: BTreeSet<_> = vec![1, 2].into_iter().collect();
+
+        let (blocks, missing) =
+            fetch_unique_blocks_from_cache(&logger, Arc::new(chain_store), block_numbers).await;
+
+        assert_eq!(blocks.len(), 1);
+        assert_eq!(blocks[0].number, 1);
+        assert_eq!(missing, vec![2]);
+    }
+
+    #[graph::test]
+    async fn test_fetch_unique_blocks_multiple_valid_blocks() {
+        let logger = Logger::root(slog::Discard, o!());
+        let mut chain_store = MockChainStore::default();
+
+        // Add multiple valid blocks
+        let block1 = create_test_block(1, "block1");
+        let block2 = create_test_block(2, "block2");
+        chain_store.blocks.insert(1, vec![block1.clone()]);
+        chain_store.blocks.insert(2, vec![block2.clone()]);
+
+        let block_numbers: BTreeSet<_> = vec![1, 2].into_iter().collect();
+
+        let (blocks, missing) =
+            fetch_unique_blocks_from_cache(&logger, Arc::new(chain_store), block_numbers).await;
+
+        assert_eq!(blocks.len(), 2);
+        assert!(blocks.iter().any(|b| b.number == 1));
+        assert!(blocks.iter().any(|b| b.number == 2));
+        assert!(missing.is_empty());
+    }
+
+    #[graph::test]
+    async fn test_fetch_unique_blocks_mixed_scenario() {
+        let logger = Logger::root(slog::Discard, o!());
+        let mut chain_store = MockChainStore::default();
+
+        // Add a mix of scenarios:
+        // - Block 1: Single valid block
+        // - Block 2: Multiple blocks (duplicate)
+        // - Block 3: Missing
+        let block1 = create_test_block(1, "block1");
+        let block2a = create_test_block(2, "block2a");
+        let block2b = create_test_block(2, "block2b");
+
+        chain_store.blocks.insert(1, vec![block1.clone()]);
+        chain_store
+            .blocks
+            .insert(2, vec![block2a.clone(), block2b.clone()]);
+
+        let block_numbers: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
+
+        let (blocks, missing) =
+            fetch_unique_blocks_from_cache(&logger, Arc::new(chain_store), block_numbers).await;
+
+        assert_eq!(blocks.len(), 1);
+        assert_eq!(blocks[0].number, 1);
+        assert_eq!(missing.len(), 2);
+        assert!(missing.contains(&2));
+        assert!(missing.contains(&3));
+    }
+
+    #[tokio::test]
+    async fn test_walk_back_ancestor() {
+        use std::collections::HashMap;
+
+        let block_100_hash = BlockHash("block100".as_bytes().to_vec().into_boxed_slice());
+        let block_101_hash = BlockHash("block101".as_bytes().to_vec().into_boxed_slice());
+        let block_102_hash = BlockHash("block102".as_bytes().to_vec().into_boxed_slice());
+        let block_103_hash = BlockHash("block103".as_bytes().to_vec().into_boxed_slice());
+        let block_104_hash = BlockHash("block104".as_bytes().to_vec().into_boxed_slice());
+        let block_105_hash = BlockHash("block105".as_bytes().to_vec().into_boxed_slice());
+
+        let block_105 = BlockPtr::new(block_105_hash.clone(), 105);
+        let block_104 = BlockPtr::new(block_104_hash.clone(), 104);
+        let block_103 = BlockPtr::new(block_103_hash.clone(), 103);
+        let block_102 = BlockPtr::new(block_102_hash.clone(), 102);
+        let block_101 = BlockPtr::new(block_101_hash.clone(), 101);
+        let block_100 = BlockPtr::new(block_100_hash.clone(), 100);
+
+        let mut parent_map = HashMap::new();
+        parent_map.insert(block_105_hash.clone(), block_104.clone());
+        parent_map.insert(block_104_hash.clone(), block_103.clone());
+        parent_map.insert(block_103_hash.clone(), block_102.clone());
+        parent_map.insert(block_102_hash.clone(), block_101.clone());
+        parent_map.insert(block_101_hash.clone(), block_100.clone());
+
+        let result = super::walk_back_ancestor(block_105.clone(), 2, None, |block_ptr| {
+            let parent = parent_map.get(&block_ptr.hash).cloned();
+            async move { Ok::<_, std::convert::Infallible>(parent) }
+        })
+        .await
+        .unwrap();
+        assert_eq!(result, Some(block_103.clone()));
+
+        let result = super::walk_back_ancestor(
+            block_105.clone(),
+            10,
+            Some(block_102_hash.clone()),
+            |block_ptr| {
+                let parent = parent_map.get(&block_ptr.hash).cloned();
+                async move { Ok::<_, std::convert::Infallible>(parent) }
+            },
+        )
+        .await
+        .unwrap();
+        assert_eq!(
+            result,
+            Some(block_103.clone()),
+            "Should stop at child of root"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_walk_back_ancestor_skipped_blocks_with_root() {
+        use std::collections::HashMap;
+
+        let block_100_hash = BlockHash("block100".as_bytes().to_vec().into_boxed_slice());
+        let block_101_hash = BlockHash("block101".as_bytes().to_vec().into_boxed_slice());
+        let block_102_hash = BlockHash("block102".as_bytes().to_vec().into_boxed_slice());
+        let block_110_hash = BlockHash("block110".as_bytes().to_vec().into_boxed_slice());
+        let block_111_hash = BlockHash("block111".as_bytes().to_vec().into_boxed_slice());
+        let block_112_hash = BlockHash("block112".as_bytes().to_vec().into_boxed_slice());
+        let block_120_hash = BlockHash("block120".as_bytes().to_vec().into_boxed_slice());
+
+        let block_120 = BlockPtr::new(block_120_hash.clone(), 120);
+        let block_112 = BlockPtr::new(block_112_hash.clone(), 112);
+        let block_111 = BlockPtr::new(block_111_hash.clone(), 111);
+        let block_110 = BlockPtr::new(block_110_hash.clone(), 110);
+        let block_102 = BlockPtr::new(block_102_hash.clone(), 102);
+        let block_101 = BlockPtr::new(block_101_hash.clone(), 101);
+        let block_100 = BlockPtr::new(block_100_hash.clone(), 100);
+
+        let mut parent_map = HashMap::new();
+        parent_map.insert(block_120_hash.clone(), block_112.clone());
+        parent_map.insert(block_112_hash.clone(), block_111.clone());
+        parent_map.insert(block_111_hash.clone(), block_110.clone());
+        parent_map.insert(block_110_hash.clone(), block_102.clone());
+        parent_map.insert(block_102_hash.clone(), block_101.clone());
+        parent_map.insert(block_101_hash.clone(), block_100.clone());
+
+        let result = super::walk_back_ancestor(
+            block_120.clone(),
+            10,
+            Some(block_110_hash.clone()),
+            |block_ptr| {
+                let parent = parent_map.get(&block_ptr.hash).cloned();
+                async move { Ok::<_, std::convert::Infallible>(parent) }
+            },
+        )
+        .await
+        .unwrap();
+        assert_eq!(
+            result,
+            Some(block_111.clone()),
+            "root=110: should stop at 111 (child of root)"
+        );
+
+        let result = super::walk_back_ancestor(
+            block_120.clone(),
+            10,
+            Some(block_101_hash.clone()),
+            |block_ptr| {
+                let parent = parent_map.get(&block_ptr.hash).cloned();
+                async move { Ok::<_, std::convert::Infallible>(parent) }
+            },
+        )
+        .await
+        .unwrap();
+        assert_eq!(
+            result,
+            Some(block_102.clone()),
+            "root=101: should stop at 102 (child of root, across skip)"
+        );
+    }
+}
diff --git a/chain/ethereum/src/codec.rs b/chain/ethereum/src/codec.rs
index 347dd615406..b40bcd11910 100644
--- a/chain/ethereum/src/codec.rs
+++ b/chain/ethereum/src/codec.rs
@@ -1,4 +1,5 @@
 #[rustfmt::skip]
+#[allow(clippy::doc_lazy_continuation, clippy::doc_overindented_list_items)]
 #[path = "protobuf/sf.ethereum.r#type.v2.rs"]
 mod pbcodec;
 
@@ -7,11 +8,19 @@ use graph::{
     blockchain::{
         self, Block as BlockchainBlock, BlockPtr, BlockTime, ChainStoreBlock, ChainStoreData,
     },
+    components::ethereum::{
+        AnyBlock, AnyHeader, AnyRpcHeader, AnyTransactionReceiptBare, AnyTxEnvelope,
+    },
     prelude::{
-        web3,
-        web3::types::{Bytes, H160, H2048, H256, H64, U256, U64},
         BlockNumber, Error, EthereumBlock, EthereumBlockWithCalls, EthereumCall,
         LightEthereumBlock,
+        alloy::{
+            self,
+            consensus::{ReceiptWithBloom, TxEnvelope, TxType},
+            network::AnyReceiptEnvelope,
+            primitives::{Address, B256, Bloom, Bytes, LogData, U256, aliases::B2048},
+            rpc::types::{self as alloy_rpc_types, AccessList, AccessListItem, Transaction},
+        },
     },
 };
 use std::sync::Arc;
@@ -34,13 +43,13 @@ where
     }
 }
 
-impl TryDecodeProto<[u8; 256], H2048> for &[u8] {}
-impl TryDecodeProto<[u8; 32], H256> for &[u8] {}
-impl TryDecodeProto<[u8; 20], H160> for &[u8] {}
+impl TryDecodeProto<[u8; 32], B256> for &[u8] {}
+impl TryDecodeProto<[u8; 256], B2048> for &[u8] {}
+impl TryDecodeProto<[u8; 20], Address> for &[u8] {}
 
-impl From<&BigInt> for web3::types::U256 {
+impl From<&BigInt> for U256 {
     fn from(val: &BigInt) -> Self {
-        web3::types::U256::from_big_endian(&val.bytes)
+        U256::from_be_slice(&val.bytes)
     }
 }
 
@@ -68,9 +77,9 @@ impl<'a> TryInto<EthereumCall> for CallAt<'a> {
                 .value
                 .as_ref()
                 .map_or_else(|| U256::from(0), |v| v.into()),
-            gas_used: U256::from(self.call.gas_consumed),
-            input: Bytes(self.call.input.clone()),
-            output: Bytes(self.call.return_data.clone()),
+            gas_used: self.call.gas_consumed,
+            input: Bytes::from(self.call.input.clone()),
+            output: Bytes::from(self.call.return_data.clone()),
             block_hash: self.block.hash.try_decode_proto("call block hash")?,
             block_number: self.block.number as i32,
             transaction_hash: Some(self.trace.hash.try_decode_proto("call transaction hash")?),
@@ -79,41 +88,6 @@ impl<'a> TryInto<EthereumCall> for CallAt<'a> {
     }
 }
 
-impl TryInto<web3::types::Call> for Call {
-    type Error = Error;
-
-    fn try_into(self) -> Result<web3::types::Call, Self::Error> {
-        Ok(web3::types::Call {
-            from: self.caller.try_decode_proto("call from address")?,
-            to: self.address.try_decode_proto("call to address")?,
-            value: self
-                .value
-                .as_ref()
-                .map_or_else(|| U256::from(0), |v| v.into()),
-            gas: U256::from(self.gas_limit),
-            input: Bytes::from(self.input.clone()),
-            call_type: CallType::from_i32(self.call_type)
-                .ok_or_else(|| format_err!("invalid call type: {}", self.call_type,))?
-                .into(),
-        })
-    }
-}
-
-impl From<CallType> for web3::types::CallType {
-    fn from(val: CallType) -> Self {
-        match val {
-            CallType::Unspecified => web3::types::CallType::None,
-            CallType::Call => web3::types::CallType::Call,
-            CallType::Callcode => web3::types::CallType::CallCode,
-            CallType::Delegate => web3::types::CallType::DelegateCall,
-            CallType::Static => web3::types::CallType::StaticCall,
-
-            // FIXME (SF): Really not sure what this should map to, we are using None for now, need to revisit
-            CallType::Create => web3::types::CallType::None,
-        }
-    }
-}
-
 pub struct LogAt<'a> {
     log: &'a Log,
     block: &'a Block,
@@ -126,51 +100,38 @@ impl<'a> LogAt<'a> {
     }
 }
 
-impl<'a> TryInto<web3::types::Log> for LogAt<'a> {
+impl<'a> TryInto<alloy::rpc::types::Log> for LogAt<'a> {
     type Error = Error;
 
-    fn try_into(self) -> Result<web3::types::Log, Self::Error> {
-        Ok(web3::types::Log {
-            address: self.log.address.try_decode_proto("log address")?,
-            topics: self
-                .log
-                .topics
-                .iter()
-                .map(|t| t.try_decode_proto("topic"))
-                .collect::<Result<Vec<H256>, Error>>()?,
-            data: Bytes::from(self.log.data.clone()),
+    fn try_into(self) -> Result<alloy::rpc::types::Log, Self::Error> {
+        let topics = self
+            .log
+            .topics
+            .iter()
+            .map(|t| t.try_decode_proto("topic"))
+            .collect::<Result<Vec<B256>, Error>>()?;
+
+        Ok(alloy::rpc::types::Log {
+            inner: alloy::primitives::Log {
+                address: self.log.address.try_decode_proto("log address")?,
+                data: LogData::new(topics, self.log.data.clone().into())
+                    .ok_or_else(|| format_err!("invalid log data"))?,
+            },
             block_hash: Some(self.block.hash.try_decode_proto("log block hash")?),
-            block_number: Some(U64::from(self.block.number)),
+            block_number: Some(self.block.number),
             transaction_hash: Some(self.trace.hash.try_decode_proto("log transaction hash")?),
-            transaction_index: Some(U64::from(self.trace.index as u64)),
-            log_index: Some(U256::from(self.log.block_index)),
-            transaction_log_index: Some(U256::from(self.log.index)),
-            log_type: None,
-            removed: None,
+            transaction_index: Some(self.trace.index as u64),
+            log_index: Some(self.log.block_index as u64),
+            removed: false,
+            block_timestamp: self
+                .block
+                .header
+                .as_ref()
+                .and_then(|h| h.timestamp.as_ref().map(|t| t.seconds as u64)),
         })
     }
 }
 
-impl From<TransactionTraceStatus> for web3::types::U64 {
-    fn from(val: TransactionTraceStatus) -> Self {
-        let status: Option<web3::types::U64> = val.into();
-        status.unwrap_or_else(|| web3::types::U64::from(0))
-    }
-}
-
-impl Into<Option<web3::types::U64>> for TransactionTraceStatus {
-    fn into(self) -> Option<web3::types::U64> {
-        match self {
-            Self::Unknown => {
-                panic!("Got a transaction trace with status UNKNOWN, datasource is broken")
-            }
-            Self::Succeeded => Some(web3::types::U64::from(1)),
-            Self::Failed => Some(web3::types::U64::from(0)),
-            Self::Reverted => Some(web3::types::U64::from(0)),
-        }
-    }
-}
-
 pub struct TransactionTraceAt<'a> {
     trace: &'a TransactionTrace,
     block: &'a Block,
@@ -182,46 +143,323 @@ impl<'a> TransactionTraceAt<'a> {
     }
 }
 
-impl<'a> TryInto<web3::types::Transaction> for TransactionTraceAt<'a> {
+impl<'a> TryInto<Transaction<AnyTxEnvelope>> for TransactionTraceAt<'a> {
     type Error = Error;
 
-    fn try_into(self) -> Result<web3::types::Transaction, Self::Error> {
-        Ok(web3::types::Transaction {
-            hash: self.trace.hash.try_decode_proto("transaction hash")?,
-            nonce: U256::from(self.trace.nonce),
-            block_hash: Some(self.block.hash.try_decode_proto("transaction block hash")?),
-            block_number: Some(U64::from(self.block.number)),
-            transaction_index: Some(U64::from(self.trace.index as u64)),
-            from: Some(
-                self.trace
-                    .from
-                    .try_decode_proto("transaction from address")?,
-            ),
-            to: match self.trace.calls.len() {
-                0 => Some(self.trace.to.try_decode_proto("transaction to address")?),
-                _ => {
-                    match CallType::from_i32(self.trace.calls[0].call_type).ok_or_else(|| {
-                        format_err!("invalid call type: {}", self.trace.calls[0].call_type,)
-                    })? {
-                        CallType::Create => {
-                            None // we don't want the 'to' address on a transaction that creates the contract, to align with RPC behavior
-                        }
-                        _ => Some(self.trace.to.try_decode_proto("transaction to")?),
-                    }
-                }
+    fn try_into(self) -> Result<Transaction<AnyTxEnvelope>, Self::Error> {
+        use alloy::{
+            consensus::transaction::Recovered,
+            consensus::{
+                Signed, TxEip1559, TxEip2930, TxEip4844, TxEip4844Variant, TxEip7702, TxLegacy,
             },
-            value: self.trace.value.as_ref().map_or(U256::zero(), |x| x.into()),
-            gas_price: self.trace.gas_price.as_ref().map(|x| x.into()),
-            gas: U256::from(self.trace.gas_limit),
-            input: Bytes::from(self.trace.input.clone()),
-            v: None,
-            r: None,
-            s: None,
-            raw: None,
-            access_list: None,
-            max_fee_per_gas: None,
-            max_priority_fee_per_gas: None,
-            transaction_type: None,
+            network::{AnyTxEnvelope, AnyTxType, UnknownTxEnvelope, UnknownTypedTransaction},
+            primitives::{Bytes, TxKind, U256},
+            rpc::types::Transaction as AlloyTransaction,
+            serde::OtherFields,
+        };
+        use std::collections::BTreeMap;
+
+        // Extract data from trace and block
+        let block_hash = self.block.hash.try_decode_proto("transaction block hash")?;
+        let block_number = self.block.number;
+        let block_timestamp = self
+            .block
+            .header
+            .as_ref()
+            .and_then(|h| h.timestamp.as_ref().map(|t| t.seconds as u64));
+        let transaction_index = Some(self.trace.index as u64);
+        let from_address = self
+            .trace
+            .from
+            .try_decode_proto("transaction from address")?;
+        let to = get_to_address(self.trace)?;
+        let value = self.trace.value.as_ref().map_or(U256::ZERO, |x| x.into());
+        let gas_price = self.trace.gas_price.as_ref().map_or(0u128, |x| {
+            let val: U256 = x.into();
+            val.to::<u128>()
+        });
+        let gas_limit = self.trace.gas_limit;
+        let input = Bytes::from(self.trace.input.clone());
+
+        let tx_type_u64 = u64::try_from(self.trace.r#type).map_err(|_| {
+            format_err!(
+                "Invalid transaction type value {} in transaction trace. Transaction type must be a valid u64.",
+                self.trace.r#type
+            )
+        })?;
+
+        // Try to convert to known Ethereum transaction type
+        let tx_type_result = TxType::try_from(tx_type_u64);
+
+        // If this is an unknown transaction type, create an UnknownTxEnvelope
+        if tx_type_result.is_err() {
+            let mut fields_map = BTreeMap::new();
+
+            fields_map.insert(
+                "nonce".to_string(),
+                jsonrpc_core::serde_json::json!(format!("0x{:x}", self.trace.nonce)),
+            );
+            fields_map.insert(
+                "from".to_string(),
+                jsonrpc_core::serde_json::json!(format!("{:?}", from_address)),
+            );
+            if let Some(to_addr) = to {
+                fields_map.insert(
+                    "to".to_string(),
+                    jsonrpc_core::serde_json::json!(format!("{:?}", to_addr)),
+                );
+            }
+            fields_map.insert(
+                "value".to_string(),
+                jsonrpc_core::serde_json::json!(format!("0x{:x}", value)),
+            );
+            fields_map.insert(
+                "gas".to_string(),
+                jsonrpc_core::serde_json::json!(format!("0x{:x}", gas_limit)),
+            );
+            fields_map.insert(
+                "gasPrice".to_string(),
+                jsonrpc_core::serde_json::json!(format!("0x{:x}", gas_price)),
+            );
+            fields_map.insert(
+                "input".to_string(),
+                jsonrpc_core::serde_json::json!(format!("0x{}", hex::encode(&input))),
+            );
+
+            let fields = OtherFields::new(fields_map);
+            let unknown_tx = UnknownTypedTransaction {
+                ty: AnyTxType(tx_type_u64 as u8),
+                fields,
+                memo: Default::default(),
+            };
+
+            let tx_hash = self.trace.hash.try_decode_proto("transaction hash")?;
+            let unknown_envelope = UnknownTxEnvelope {
+                hash: tx_hash,
+                inner: unknown_tx,
+            };
+
+            let any_envelope = AnyTxEnvelope::Unknown(unknown_envelope);
+            let recovered = Recovered::new_unchecked(any_envelope, from_address);
+
+            return Ok(AlloyTransaction {
+                inner: recovered,
+                block_hash: Some(block_hash),
+                block_number: Some(block_number),
+                block_timestamp,
+                transaction_index,
+                effective_gas_price: if gas_price > 0 { Some(gas_price) } else { None },
+            });
+        }
+
+        let tx_type = tx_type_result.unwrap();
+        let nonce = self.trace.nonce;
+
+        // Extract EIP-1559 fee fields from trace
+        let max_fee_per_gas_u128 = self.trace.max_fee_per_gas.as_ref().map_or(gas_price, |x| {
+            let val: U256 = x.into();
+            val.to::<u128>()
+        });
+
+        let max_priority_fee_per_gas_u128 =
+            self.trace
+                .max_priority_fee_per_gas
+                .as_ref()
+                .map_or(0u128, |x| {
+                    let val: U256 = x.into();
+                    val.to::<u128>()
+                });
+
+        // Extract access list from trace
+        let access_list: AccessList = self
+            .trace
+            .access_list
+            .iter()
+            .map(|access_tuple| -> Result<_, Error> {
+                let address = access_tuple
+                    .address
+                    .try_decode_proto("access tuple address")?;
+                let storage_keys = access_tuple
+                    .storage_keys
+                    .iter()
+                    .map(|key| key.try_decode_proto("storage key"))
+                    .collect::<Result<Vec<_>, _>>()?;
+                Ok(AccessListItem {
+                    address,
+                    storage_keys,
+                })
+            })
+            .collect::<Result<Vec<_>, Error>>()?
+            .into();
+
+        // Extract actual signature components from trace
+        let signature = extract_signature_from_trace(self.trace, tx_type)?;
+
+        let to_kind = match to {
+            Some(addr) => TxKind::Call(addr),
+            None => TxKind::Create,
+        };
+
+        let envelope = match tx_type {
+            TxType::Legacy => {
+                let tx = TxLegacy {
+                    chain_id: None,
+                    nonce,
+                    gas_price,
+                    gas_limit,
+                    to: to_kind,
+                    value,
+                    input: input.clone(),
+                };
+                let signed_tx = Signed::new_unchecked(
+                    tx,
+                    signature,
+                    self.trace.hash.try_decode_proto("transaction hash")?,
+                );
+                TxEnvelope::Legacy(signed_tx)
+            }
+            TxType::Eip2930 => {
+                let tx = TxEip2930 {
+                    // Firehose protobuf doesn't provide chain_id for transactions.
+                    // Using 0 as placeholder since the transaction has already been validated on-chain.
+                    chain_id: 0,
+                    nonce,
+                    gas_price,
+                    gas_limit,
+                    to: to_kind,
+                    value,
+                    access_list: access_list.clone(), // Use actual access list from trace
+                    input: input.clone(),
+                };
+                let signed_tx = Signed::new_unchecked(
+                    tx,
+                    signature,
+                    self.trace.hash.try_decode_proto("transaction hash")?,
+                );
+                TxEnvelope::Eip2930(signed_tx)
+            }
+            TxType::Eip1559 => {
+                let tx = TxEip1559 {
+                    // Firehose protobuf doesn't provide chain_id for transactions.
+                    // Using 0 as placeholder since the transaction has already been validated on-chain.
+                    chain_id: 0,
+                    nonce,
+                    gas_limit,
+                    max_fee_per_gas: max_fee_per_gas_u128,
+                    max_priority_fee_per_gas: max_priority_fee_per_gas_u128,
+                    to: to_kind,
+                    value,
+                    access_list: access_list.clone(), // Use actual access list from trace
+                    input: input.clone(),
+                };
+                let signed_tx = Signed::new_unchecked(
+                    tx,
+                    signature,
+                    self.trace.hash.try_decode_proto("transaction hash")?,
+                );
+                TxEnvelope::Eip1559(signed_tx)
+            }
+            TxType::Eip4844 => {
+                let to_address = to.ok_or_else(|| {
+                    format_err!("EIP-4844 transactions cannot be contract creation transactions. The 'to' field must contain a valid address.")
+                })?;
+
+                let blob_versioned_hashes: Vec<B256> = self
+                    .trace
+                    .blob_hashes
+                    .iter()
+                    .map(|hash| hash.try_decode_proto("blob hash"))
+                    .collect::<Result<Vec<_>, _>>()?;
+
+                let max_fee_per_blob_gas_u128 =
+                    self.trace.blob_gas_fee_cap.as_ref().map_or(0u128, |x| {
+                        let val: U256 = x.into();
+                        val.to::<u128>()
+                    });
+
+                let tx_eip4844 = TxEip4844 {
+                    // Firehose protobuf doesn't provide chain_id for transactions.
+                    // Using 0 as placeholder since the transaction has already been validated on-chain.
+                    chain_id: 0,
+                    nonce,
+                    gas_limit,
+                    max_fee_per_gas: max_fee_per_gas_u128,
+                    max_priority_fee_per_gas: max_priority_fee_per_gas_u128,
+                    to: to_address,
+                    value,
+                    access_list: access_list.clone(), // Use actual access list from trace
+                    blob_versioned_hashes,
+                    max_fee_per_blob_gas: max_fee_per_blob_gas_u128,
+                    input: input.clone(),
+                };
+                let tx = TxEip4844Variant::TxEip4844(tx_eip4844);
+                let signed_tx = Signed::new_unchecked(
+                    tx,
+                    signature,
+                    self.trace.hash.try_decode_proto("transaction hash")?,
+                );
+                TxEnvelope::Eip4844(signed_tx)
+            }
+            TxType::Eip7702 => {
+                let to_address = to.ok_or_else(|| {
+                    format_err!("EIP-7702 transactions cannot be contract creation transactions. The 'to' field must contain a valid address.")
+                })?;
+
+                // Convert set_code_authorizations to alloy authorization list
+                let authorization_list: Vec<alloy::eips::eip7702::SignedAuthorization> = self
+                    .trace
+                    .set_code_authorizations
+                    .iter()
+                    .map(|auth| -> Result<_, Error> {
+                        let inner = alloy::eips::eip7702::Authorization {
+                            chain_id: U256::from_be_slice(&auth.chain_id),
+                            address: auth.address.try_decode_proto("authorization address")?,
+                            nonce: auth.nonce,
+                        };
+
+                        let r = U256::from_be_slice(&auth.r);
+                        let s = U256::from_be_slice(&auth.s);
+                        let y_parity = auth.v as u8;
+
+                        Ok(alloy::eips::eip7702::SignedAuthorization::new_unchecked(
+                            inner, y_parity, r, s,
+                        ))
+                    })
+                    .collect::<Result<Vec<_>, Error>>()?;
+
+                let tx = TxEip7702 {
+                    // Firehose protobuf doesn't provide chain_id for transactions.
+                    // Using 0 as placeholder since the transaction has already been validated on-chain.
+                    chain_id: 0,
+                    nonce,
+                    gas_limit,
+                    max_fee_per_gas: max_fee_per_gas_u128,
+                    max_priority_fee_per_gas: max_priority_fee_per_gas_u128,
+                    to: to_address,
+                    value,
+                    access_list: access_list.clone(), // Use actual access list from trace
+                    authorization_list,
+                    input: input.clone(),
+                };
+                let signed_tx = Signed::new_unchecked(
+                    tx,
+                    signature,
+                    self.trace.hash.try_decode_proto("transaction hash")?,
+                );
+                TxEnvelope::Eip7702(signed_tx)
+            }
+        };
+
+        let any_envelope = AnyTxEnvelope::Ethereum(envelope);
+        let recovered = Recovered::new_unchecked(any_envelope, from_address);
+
+        Ok(AlloyTransaction {
+            inner: recovered,
+            block_hash: Some(block_hash),
+            block_number: Some(block_number),
+            block_timestamp,
+            transaction_index,
+            effective_gas_price: if gas_price > 0 { Some(gas_price) } else { None }, // gas_price already contains effective gas price per protobuf spec
         })
     }
 }
@@ -234,143 +472,131 @@ impl TryInto<BlockFinality> for &Block {
     }
 }
 
+impl TryInto<AnyBlock> for &Block {
+    type Error = Error;
+
+    fn try_into(self) -> Result<AnyBlock, Self::Error> {
+        let header = self.header();
+
+        let block_hash = self.hash.try_decode_proto("block hash")?;
+        let consensus_header = alloy::consensus::Header {
+            number: header.number,
+            beneficiary: header.coinbase.try_decode_proto("author / coinbase")?,
+            parent_hash: header.parent_hash.try_decode_proto("parent hash")?,
+            ommers_hash: header.uncle_hash.try_decode_proto("uncle hash")?,
+            state_root: header.state_root.try_decode_proto("state root")?,
+            transactions_root: header
+                .transactions_root
+                .try_decode_proto("transactions root")?,
+            receipts_root: header.receipt_root.try_decode_proto("receipt root")?,
+            gas_used: header.gas_used,
+            gas_limit: header.gas_limit,
+            base_fee_per_gas: header.base_fee_per_gas.as_ref().map(|v| {
+                let val: U256 = v.into();
+                val.to::<u64>()
+            }),
+            extra_data: Bytes::from(header.extra_data.clone()),
+            logs_bloom: if header.logs_bloom.is_empty() {
+                Bloom::ZERO
+            } else {
+                Bloom::try_from(header.logs_bloom.as_slice())?
+            },
+            timestamp: header.timestamp.as_ref().map_or(0, |v| v.seconds as u64),
+            difficulty: header
+                .difficulty
+                .as_ref()
+                .map_or_else(|| U256::ZERO, |v| v.into()),
+
+            mix_hash: header.mix_hash.try_decode_proto("mix hash")?,
+            nonce: header.nonce.into(),
+
+            withdrawals_root: if header.withdrawals_root.is_empty() {
+                None
+            } else {
+                Some(
+                    header
+                        .withdrawals_root
+                        .try_decode_proto("withdrawals root")?,
+                )
+            },
+            blob_gas_used: header.blob_gas_used,
+            excess_blob_gas: header.excess_blob_gas,
+            parent_beacon_block_root: if header.parent_beacon_root.is_empty() {
+                None
+            } else {
+                Some(
+                    header
+                        .parent_beacon_root
+                        .try_decode_proto("parent beacon root")?,
+                )
+            },
+            requests_hash: if header.requests_hash.is_empty() {
+                None
+            } else {
+                Some(header.requests_hash.try_decode_proto("requests hash")?)
+            },
+            block_access_list_hash: None,
+            slot_number: None,
+        };
+
+        let rpc_header = alloy::rpc::types::Header {
+            hash: block_hash,
+            inner: consensus_header,
+            total_difficulty: {
+                #[allow(deprecated)]
+                let total_difficulty = &header.total_difficulty;
+                total_difficulty.as_ref().map(|v| v.into())
+            },
+            size: Some(U256::from(self.size)),
+        };
+
+        let transactions = self
+            .transaction_traces
+            .iter()
+            .map(|t| TransactionTraceAt::new(t, self).try_into())
+            .collect::<Result<Vec<Transaction<AnyTxEnvelope>>, Error>>()?;
+
+        let uncles = self
+            .uncles
+            .iter()
+            .map(|u| u.hash.try_decode_proto("uncle hash"))
+            .collect::<Result<Vec<B256>, _>>()?;
+
+        use alloy::rpc::types::Block;
+
+        let any_header: AnyRpcHeader = rpc_header.map(AnyHeader::from);
+
+        Ok(Block {
+            header: any_header,
+            transactions: alloy::rpc::types::BlockTransactions::Full(transactions),
+            uncles,
+            withdrawals: None,
+        })
+    }
+}
+
 impl TryInto<EthereumBlockWithCalls> for &Block {
     type Error = Error;
 
     fn try_into(self) -> Result<EthereumBlockWithCalls, Self::Error> {
-        let header = self
-            .header
-            .as_ref()
-            .expect("block header should always be present from gRPC Firehose");
+        let alloy_block: AnyBlock = self.try_into()?;
+
+        let transaction_receipts = self
+            .transaction_traces
+            .iter()
+            .filter_map(|t| transaction_trace_to_alloy_txn_reciept(t, self).transpose())
+            .collect::<Result<Vec<_>, Error>>()?
+            .into_iter()
+            // Transaction receipts will be shared along the code, so we put them into an
+            // Arc here to avoid excessive cloning.
+            .map(Arc::new)
+            .collect();
 
+        #[allow(unreachable_code)]
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(LightEthereumBlock {
-                    hash: Some(self.hash.try_decode_proto("block hash")?),
-                    number: Some(U64::from(self.number)),
-                    author: header.coinbase.try_decode_proto("author / coinbase")?,
-                    parent_hash: header.parent_hash.try_decode_proto("parent hash")?,
-                    uncles_hash: header.uncle_hash.try_decode_proto("uncle hash")?,
-                    state_root: header.state_root.try_decode_proto("state root")?,
-                    transactions_root: header
-                        .transactions_root
-                        .try_decode_proto("transactions root")?,
-                    receipts_root: header.receipt_root.try_decode_proto("receipt root")?,
-                    gas_used: U256::from(header.gas_used),
-                    gas_limit: U256::from(header.gas_limit),
-                    base_fee_per_gas: Some(
-                        header
-                            .base_fee_per_gas
-                            .as_ref()
-                            .map_or_else(U256::default, |v| v.into()),
-                    ),
-                    extra_data: Bytes::from(header.extra_data.clone()),
-                    logs_bloom: match &header.logs_bloom.len() {
-                        0 => None,
-                        _ => Some(header.logs_bloom.try_decode_proto("logs bloom")?),
-                    },
-                    timestamp: header
-                        .timestamp
-                        .as_ref()
-                        .map_or_else(U256::default, |v| U256::from(v.seconds)),
-                    difficulty: header
-                        .difficulty
-                        .as_ref()
-                        .map_or_else(U256::default, |v| v.into()),
-                    total_difficulty: Some(
-                        header
-                            .total_difficulty
-                            .as_ref()
-                            .map_or_else(U256::default, |v| v.into()),
-                    ),
-                    // FIXME (SF): Firehose does not have seal fields, are they really used? Might be required for POA chains only also, I've seen that stuff on xDai (is this important?)
-                    seal_fields: vec![],
-                    uncles: self
-                        .uncles
-                        .iter()
-                        .map(|u| u.hash.try_decode_proto("uncle hash"))
-                        .collect::<Result<Vec<H256>, _>>()?,
-                    transactions: self
-                        .transaction_traces
-                        .iter()
-                        .map(|t| TransactionTraceAt::new(t, self).try_into())
-                        .collect::<Result<Vec<web3::types::Transaction>, Error>>()?,
-                    size: Some(U256::from(self.size)),
-                    mix_hash: Some(header.mix_hash.try_decode_proto("mix hash")?),
-                    nonce: Some(H64::from_low_u64_be(header.nonce)),
-                }),
-                transaction_receipts: self
-                    .transaction_traces
-                    .iter()
-                    .filter_map(|t| {
-                        t.receipt.as_ref().map(|r| {
-                            Ok(web3::types::TransactionReceipt {
-                                transaction_hash: t.hash.try_decode_proto("transaction hash")?,
-                                transaction_index: U64::from(t.index),
-                                block_hash: Some(
-                                    self.hash.try_decode_proto("transaction block hash")?,
-                                ),
-                                block_number: Some(U64::from(self.number)),
-                                cumulative_gas_used: U256::from(r.cumulative_gas_used),
-                                // FIXME (SF): What is the rule here about gas_used being None, when it's 0?
-                                gas_used: Some(U256::from(t.gas_used)),
-                                contract_address: {
-                                    match t.calls.len() {
-                                        0 => None,
-                                        _ => {
-                                            match CallType::from_i32(t.calls[0].call_type)
-                                                .ok_or_else(|| {
-                                                    format_err!(
-                                                        "invalid call type: {}",
-                                                        t.calls[0].call_type,
-                                                    )
-                                                })? {
-                                                CallType::Create => {
-                                                    Some(t.calls[0].address.try_decode_proto(
-                                                        "transaction contract address",
-                                                    )?)
-                                                }
-                                                _ => None,
-                                            }
-                                        }
-                                    }
-                                },
-                                logs: r
-                                    .logs
-                                    .iter()
-                                    .map(|l| LogAt::new(l, self, t).try_into())
-                                    .collect::<Result<Vec<_>, Error>>()?,
-                                status: TransactionTraceStatus::from_i32(t.status)
-                                    .ok_or_else(|| {
-                                        format_err!(
-                                            "invalid transaction trace status: {}",
-                                            t.status
-                                        )
-                                    })?
-                                    .into(),
-                                root: match r.state_root.len() {
-                                    0 => None, // FIXME (SF): should this instead map to [0;32]?
-                                    // FIXME (SF): if len < 32, what do we do?
-                                    _ => Some(
-                                        r.state_root.try_decode_proto("transaction state root")?,
-                                    ),
-                                },
-                                logs_bloom: r
-                                    .logs_bloom
-                                    .try_decode_proto("transaction logs bloom")?,
-                                from: t.from.try_decode_proto("transaction from")?,
-                                to: Some(t.to.try_decode_proto("transaction to")?),
-                                transaction_type: None,
-                                effective_gas_price: None,
-                            })
-                        })
-                    })
-                    .collect::<Result<Vec<_>, Error>>()?
-                    .into_iter()
-                    // Transaction receipts will be shared along the code, so we put them into an
-                    // Arc here to avoid excessive cloning.
-                    .map(Arc::new)
-                    .collect(),
+                block: Arc::new(LightEthereumBlock::new(alloy_block)),
+                transaction_receipts,
             },
             // Comment (437a9f17-67cc-478f-80a3-804fe554b227): This Some() will avoid calls in the triggers_in_block
             // TODO: Refactor in a way that this is no longer needed.
@@ -393,12 +619,118 @@ impl TryInto<EthereumBlockWithCalls> for &Block {
     }
 }
 
+fn transaction_trace_to_alloy_txn_reciept(
+    t: &TransactionTrace,
+    block: &Block,
+) -> Result<Option<AnyTransactionReceiptBare>, Error> {
+    use alloy::consensus::{Eip658Value, Receipt};
+    let r = t.receipt.as_ref();
+
+    if r.is_none() {
+        return Ok(None);
+    }
+
+    let r = r.unwrap();
+
+    let contract_address = match t.calls.len() {
+        0 => None,
+        _ => {
+            match CallType::try_from(t.calls[0].call_type).map_err(|_| {
+                graph::anyhow::anyhow!("invalid call type: {}", t.calls[0].call_type)
+            })? {
+                CallType::Create => Some(
+                    t.calls[0]
+                        .address
+                        .try_decode_proto("transaction contract address")?,
+                ),
+                _ => None,
+            }
+        }
+    };
+
+    let state_root = match &r.state_root {
+        b if b.is_empty() => None,
+        _ => Some(r.state_root.try_decode_proto("transaction state root")?),
+    };
+
+    let status = match TransactionTraceStatus::try_from(t.status)
+        .map_err(|_| format_err!("invalid transaction trace status: {}", t.status))?
+    {
+        TransactionTraceStatus::Unknown => {
+            return Err(format_err!(
+                "Transaction trace has UNKNOWN status; datasource is broken"
+            ));
+        }
+        TransactionTraceStatus::Succeeded => true,
+        TransactionTraceStatus::Failed | TransactionTraceStatus::Reverted => false,
+    };
+
+    // [EIP-658]: https://eips.ethereum.org/EIPS/eip-658
+    // Before EIP-658, the state root field was used to indicate the status of the transaction.
+    // After EIP-658, the status field is used to indicate the status of the transaction.
+    let status = match state_root {
+        Some(root) => Eip658Value::PostState(root),
+        None => Eip658Value::Eip658(status),
+    };
+
+    let logs: Vec<alloy::rpc::types::Log> = r
+        .logs
+        .iter()
+        .map(|l| LogAt::new(l, block, t).try_into())
+        .collect::<Result<Vec<_>, Error>>()?;
+
+    let core_receipt = Receipt {
+        status,
+        cumulative_gas_used: r.cumulative_gas_used,
+        logs,
+    };
+
+    let logs_bloom = Bloom::try_from(r.logs_bloom.as_slice())?;
+
+    let receipt_with_bloom = ReceiptWithBloom::new(core_receipt, logs_bloom);
+
+    let tx_type_u64 = u64::try_from(t.r#type).map_err(|_| {
+        format_err!(
+            "Invalid transaction type value {} in transaction receipt. Transaction type must be a valid u64.",
+            t.r#type
+        )
+    })?;
+
+    let any_envelope = AnyReceiptEnvelope {
+        inner: receipt_with_bloom,
+        r#type: tx_type_u64 as u8,
+    };
+
+    let receipt = alloy_rpc_types::TransactionReceipt {
+        transaction_hash: t.hash.try_decode_proto("transaction hash")?,
+        transaction_index: Some(t.index as u64),
+        block_hash: Some(block.hash.try_decode_proto("transaction block hash")?),
+        block_number: Some(block.number),
+        gas_used: t.gas_used,
+        contract_address,
+        from: t.from.try_decode_proto("transaction from")?,
+        to: get_to_address(t)?,
+        effective_gas_price: t.gas_price.as_ref().map_or(0u128, |x| {
+            let val: U256 = x.into();
+            val.to::<u128>()
+        }), // gas_price already contains effective gas price per protobuf spec
+        blob_gas_used: r.blob_gas_used,
+        blob_gas_price: r.blob_gas_price.as_ref().map(|x| {
+            let val: U256 = x.into();
+            val.to::<u128>()
+        }),
+        inner: any_envelope,
+    };
+
+    Ok(Some(receipt))
+}
+
 impl BlockHeader {
     pub fn parent_ptr(&self) -> Option<BlockPtr> {
         match self.parent_hash.len() {
             0 => None,
             _ => Some(BlockPtr::from((
-                H256::from_slice(self.parent_hash.as_ref()),
+                B256::from_slice(self.parent_hash.as_ref()),
                 self.number - 1,
             ))),
         }
@@ -407,13 +739,13 @@ impl BlockHeader {
 
 impl<'a> From<&'a BlockHeader> for BlockPtr {
     fn from(b: &'a BlockHeader) -> BlockPtr {
-        BlockPtr::from((H256::from_slice(b.hash.as_ref()), b.number))
+        BlockPtr::from((B256::from_slice(b.hash.as_ref()), b.number))
     }
 }
 
 impl<'a> From<&'a Block> for BlockPtr {
     fn from(b: &'a Block) -> BlockPtr {
-        BlockPtr::from((H256::from_slice(b.hash.as_ref()), b.number))
+        BlockPtr::from((B256::from_slice(b.hash.as_ref()), b.number))
     }
 }
 
@@ -516,6 +848,33 @@ impl BlockchainBlock for HeaderOnlyBlock {
     }
 }
 
+fn extract_signature_from_trace(
+    _trace: &TransactionTrace,
+    _tx_type: TxType,
+) -> Result<alloy::signers::Signature, Error> {
+    use alloy::primitives::{Signature as PrimitiveSignature, U256};
+
+    // Create a dummy signature with r = 0, s = 0 and even y-parity (false)
+    let dummy = PrimitiveSignature::new(U256::ZERO, U256::ZERO, false);
+
+    Ok(dummy)
+}
+
+fn get_to_address(trace: &TransactionTrace) -> Result<Option<Address>, Error> {
+    // Try to detect contract creation transactions, which have no 'to' address
+    let is_contract_creation = trace.to.is_empty()
+        || trace
+            .calls
+            .first()
+            .is_some_and(|call| CallType::try_from(call.call_type) == Ok(CallType::Create));
+
+    if is_contract_creation {
+        Ok(None)
+    } else {
+        Ok(Some(trace.to.try_decode_proto("transaction to address")?))
+    }
+}
+
 #[cfg(test)]
 mod test {
     use graph::{blockchain::Block as _, prelude::chrono::Utc};
@@ -528,14 +887,19 @@ mod test {
     #[test]
     fn ensure_block_serialization() {
         let now = Utc::now().timestamp();
-        let mut block = Block::default();
-        let mut header = BlockHeader::default();
-        header.timestamp = Some(Timestamp {
-            seconds: now,
-            nanos: 0,
-        });
 
-        block.header = Some(header);
+        let header = BlockHeader {
+            timestamp: Some(Timestamp {
+                seconds: now,
+                nanos: 0,
+            }),
+            ..Default::default()
+        };
+
+        let block = Block {
+            header: Some(header.clone()),
+            ..Default::default()
+        };
 
         let str_block = block.data().unwrap().to_string();
 
@@ -545,4 +909,116 @@ mod test {
             format!(r#"{{"block":{{"data":null,"timestamp":"{}"}}}}"#, now)
         );
     }
+
+    #[test]
+    fn test_unknown_transaction_type_conversion() {
+        use super::TransactionTraceAt;
+        use crate::codec::TransactionTrace;
+        use graph::prelude::alloy::network::AnyTxEnvelope;
+        use graph::prelude::alloy::primitives::B256;
+
+        let header = BlockHeader {
+            number: 123456,
+            timestamp: Some(Timestamp {
+                seconds: 1234567890,
+                nanos: 0,
+            }),
+            ..Default::default()
+        };
+        let block = Block {
+            header: Some(header),
+            number: 123456,
+            hash: vec![0u8; 32],
+            ..Default::default()
+        };
+
+        let trace = TransactionTrace {
+            r#type: 126, // 0x7e Optimism deposit transaction
+            hash: vec![1u8; 32],
+            from: vec![2u8; 20],
+            to: vec![3u8; 20],
+            nonce: 42,
+            gas_limit: 21000,
+            index: 0,
+            ..Default::default()
+        };
+
+        let trace_at = TransactionTraceAt::new(&trace, &block);
+        let result: Result<
+            graph::prelude::alloy::rpc::types::Transaction<AnyTxEnvelope>,
+            graph::prelude::Error,
+        > = trace_at.try_into();
+
+        assert!(
+            result.is_ok(),
+            "Should successfully convert unknown transaction type"
+        );
+
+        let tx = result.unwrap();
+
+        match tx.inner.inner() {
+            AnyTxEnvelope::Unknown(unknown_envelope) => {
+                assert_eq!(unknown_envelope.inner.ty.0, 126);
+                assert_eq!(unknown_envelope.hash, B256::from_slice(&trace.hash));
+                assert!(
+                    !unknown_envelope.inner.fields.is_empty(),
+                    "OtherFields should contain transaction data"
+                );
+            }
+            _ => panic!("Expected AnyTxEnvelope::Unknown, got Ethereum variant"),
+        }
+
+        assert_eq!(tx.block_number, Some(123456));
+        assert_eq!(tx.transaction_index, Some(0));
+        assert_eq!(tx.block_hash, Some(B256::from_slice(&block.hash)));
+    }
+
+    #[test]
+    fn test_unknown_receipt_type_conversion() {
+        use super::transaction_trace_to_alloy_txn_reciept;
+        use crate::codec::TransactionTrace;
+
+        let header = BlockHeader {
+            number: 123456,
+            ..Default::default()
+        };
+        let block = Block {
+            header: Some(header),
+            hash: vec![0u8; 32],
+            ..Default::default()
+        };
+
+        let receipt = super::TransactionReceipt {
+            cumulative_gas_used: 21000,
+            logs_bloom: vec![0u8; 256],
+            ..Default::default()
+        };
+        let trace = TransactionTrace {
+            r#type: 126, // 0x7e Optimism deposit transaction
+            hash: vec![1u8; 32],
+            from: vec![2u8; 20],
+            to: vec![3u8; 20],
+            index: 0,
+            gas_used: 21000,
+            status: 1,
+            receipt: Some(receipt),
+            ..Default::default()
+        };
+
+        let result = transaction_trace_to_alloy_txn_reciept(&trace, &block);
+
+        assert!(
+            result.is_ok(),
+            "Should successfully convert receipt with unknown transaction type"
+        );
+
+        let receipt_opt = result.unwrap();
+        assert!(receipt_opt.is_some(), "Receipt should be present");
+
+        let receipt = receipt_opt.unwrap();
+
+        assert_eq!(receipt.inner.r#type, 126);
+        assert_eq!(receipt.gas_used, 21000);
+        assert_eq!(receipt.transaction_index, Some(0));
+    }
 }
diff --git a/chain/ethereum/src/data_source.rs b/chain/ethereum/src/data_source.rs
index 47abc96649d..709884496e8 100644
--- a/chain/ethereum/src/data_source.rs
+++ b/chain/ethereum/src/data_source.rs
@@ -1,37 +1,61 @@
-use anyhow::{anyhow, Error};
-use anyhow::{ensure, Context};
-use graph::blockchain::TriggerWithHandler;
-use graph::components::store::StoredDynamicDataSource;
-use graph::data_source::CausalityRegion;
-use graph::prelude::ethabi::ethereum_types::H160;
-use graph::prelude::ethabi::StateMutability;
-use graph::prelude::futures03::future::try_join;
-use graph::prelude::futures03::stream::FuturesOrdered;
-use graph::prelude::{Link, SubgraphManifestValidationError};
-use graph::slog::{o, trace};
+use anyhow::{Context, ensure};
+use anyhow::{Error, anyhow};
+use async_trait::async_trait;
+use graph::abi;
+use graph::abi::EventExt;
+use graph::abi::FunctionExt;
+use graph::blockchain::{BlockPtr, TriggerWithHandler};
+use graph::components::ethereum::AnyTransaction;
+use graph::components::link_resolver::LinkResolverContext;
+use graph::components::metrics::subgraph::SubgraphInstanceMetrics;
+use graph::components::store::{EthereumCallCache, StoredDynamicDataSource};
+use graph::components::subgraph::{HostMetrics, InstanceDSTemplateInfo, MappingError};
+use graph::components::trigger_processor::RunnableTriggers;
+use graph::data::subgraph::DeploymentHash;
+use graph::data_source::common::{
+    AbiJson, CallDecls, DeclaredCall, FindMappingABI, MappingABI, UnresolvedCallDecls,
+    UnresolvedMappingABI,
+};
+use graph::data_source::{CausalityRegion, MappingTrigger as MappingTriggerType};
+use graph::env::ENV_VARS;
+use graph::futures03::TryStreamExt;
+use graph::futures03::future::try_join;
+use graph::futures03::stream::FuturesOrdered;
+use graph::prelude::alloy::primitives::keccak256;
+use graph::prelude::alloy::{
+    consensus::{TxEnvelope, TxLegacy},
+    network::TransactionResponse,
+    primitives::{Address, B256, U256},
+    rpc::types::Log,
+};
+use graph::prelude::{Link, SubgraphManifestValidationError, alloy};
+use graph::slog::{debug, error, o, trace};
+use itertools::Itertools;
+use serde::de::Error as ErrorD;
+use serde::{Deserialize, Deserializer};
 use std::collections::HashSet;
 use std::num::NonZeroU32;
 use std::str::FromStr;
 use std::sync::Arc;
-use tiny_keccak::{keccak256, Keccak};
+use std::time::{Duration, Instant};
 
 use graph::{
     blockchain::{self, Blockchain},
     prelude::{
-        async_trait,
-        ethabi::{Address, Contract, Event, Function, LogParam, ParamType, RawLog},
-        serde_json, warn,
-        web3::types::{Log, Transaction, H256},
-        BlockNumber, CheapClone, DataSourceTemplateInfo, Deserialize, EthereumCall,
-        LightEthereumBlock, LightEthereumBlockExt, LinkResolver, Logger, TryStreamExt,
+        BlockNumber, CheapClone, EthereumCall, LightEthereumBlock, LightEthereumBlockExt,
+        LinkResolver, Logger, serde_json, warn,
     },
 };
 
 use graph::data::subgraph::{
-    calls_host_fn, DataSourceContext, Source, MIN_SPEC_VERSION, SPEC_VERSION_0_0_8,
+    DataSourceContext, MIN_SPEC_VERSION, SPEC_VERSION_0_0_8, SPEC_VERSION_1_2_0, Source,
+    calls_host_fn,
 };
 
+use crate::NodeCapabilities;
+use crate::adapter::EthereumAdapter as _;
 use crate::chain::Chain;
+use crate::network::EthereumNetworkAdapters;
 use crate::trigger::{EthereumBlockTriggerType, EthereumTrigger, MappingTrigger};
 
 // The recommended kind is `ethereum`, `ethereum/contract` is accepted for backwards compatibility.
@@ -59,20 +83,26 @@ pub struct DataSource {
 }
 
 impl blockchain::DataSource<Chain> for DataSource {
-    fn from_template_info(info: DataSourceTemplateInfo<Chain>) -> Result<Self, Error> {
-        let DataSourceTemplateInfo {
-            template,
+    fn from_template_info(
+        info: InstanceDSTemplateInfo,
+        ds_template: &graph::data_source::DataSourceTemplate<Chain>,
+    ) -> Result<Self, Error> {
+        // Note: There clearly is duplication between the data in `ds_template and the `template`
+        // field here. Both represent a template definition, would be good to unify them.
+        let InstanceDSTemplateInfo {
+            template: _,
             params,
             context,
             creation_block,
         } = info;
-        let template = template.into_onchain().ok_or(anyhow!(
+
+        let template = ds_template.as_onchain().ok_or(anyhow!(
             "Cannot create onchain data source from offchain template"
         ))?;
 
         // Obtain the address from the parameters
         let string = params
-            .get(0)
+            .first()
             .with_context(|| {
                 format!(
                     "Failed to create data source from template `{}`: address parameter is missing",
@@ -94,14 +124,14 @@ impl blockchain::DataSource<Chain> for DataSource {
             .with_context(|| format!("template `{}`", template.name))?;
 
         Ok(DataSource {
-            kind: template.kind,
-            network: template.network,
-            name: template.name,
+            kind: template.kind.clone(),
+            network: template.network.clone(),
+            name: template.name.clone(),
             manifest_idx: template.manifest_idx,
             address: Some(address),
             start_block: creation_block,
             end_block: None,
-            mapping: template.mapping,
+            mapping: template.mapping.clone(),
             context: Arc::new(context),
             creation_block: Some(creation_block),
             contract_abi,
@@ -109,7 +139,14 @@ impl blockchain::DataSource<Chain> for DataSource {
     }
 
     fn address(&self) -> Option<&[u8]> {
-        self.address.as_ref().map(|x| x.as_bytes())
+        self.address.as_ref().map(|x| x.as_slice())
+    }
+
+    fn has_declared_calls(&self) -> bool {
+        self.mapping
+            .event_handlers
+            .iter()
+            .any(|handler| !handler.calls.decls.is_empty())
     }
 
     fn handler_kinds(&self) -> HashSet<&str> {
@@ -206,7 +243,7 @@ impl blockchain::DataSource<Chain> for DataSource {
     }
 
     fn as_stored_dynamic_data_source(&self) -> StoredDynamicDataSource {
-        let param = self.address.map(|addr| addr.0.into());
+        let param = self.address.map(|addr| addr.as_slice().into());
         StoredDynamicDataSource {
             manifest_idx: self.manifest_idx,
             param,
@@ -245,7 +282,7 @@ impl blockchain::DataSource<Chain> for DataSource {
 
         let contract_abi = template.mapping.find_abi(&template.source.abi)?;
 
-        let address = param.map(|x| H160::from_slice(&x));
+        let address = param.map(|x| Address::from_slice(&x));
         Ok(DataSource {
             kind: template.kind.to_string(),
             network: template.network.as_ref().map(|s| s.to_string()),
@@ -261,7 +298,7 @@ impl blockchain::DataSource<Chain> for DataSource {
         })
     }
 
-    fn validate(&self) -> Vec<Error> {
+    fn validate(&self, spec_version: &semver::Version) -> Vec<Error> {
         let mut errors = vec![];
 
         if !ETHEREUM_KINDS.contains(&self.kind.as_str()) {
@@ -340,6 +377,33 @@ impl blockchain::DataSource<Chain> for DataSource {
             }
         }
 
+        if spec_version < &SPEC_VERSION_1_2_0 {
+            for handler in &self.mapping.event_handlers {
+                if !handler.calls.decls.is_empty() {
+                    errors.push(anyhow!(
+                        "handler {}: declaring eth calls on handlers is only supported for specVersion >= 1.2.0", handler.event
+                    ));
+                    break;
+                }
+            }
+        }
+
+        for handler in &self.mapping.event_handlers {
+            for call in handler.calls.decls.as_ref() {
+                match self.mapping.find_abi(&call.expr.abi) {
+                    // TODO: Handle overloaded functions by passing a signature
+                    Ok(abi) => match abi.function(&call.expr.abi, &call.expr.func, None) {
+                        Ok(_) => {}
+                        Err(e) => {
+                            errors.push(e);
+                        }
+                    },
+                    Err(e) => {
+                        errors.push(e);
+                    }
+                }
+            }
+        }
         errors
     }
 
@@ -348,17 +412,24 @@ impl blockchain::DataSource<Chain> for DataSource {
     }
 
     fn min_spec_version(&self) -> semver::Version {
-        self.mapping
-            .block_handlers
-            .iter()
-            .fold(MIN_SPEC_VERSION, |mut min, handler| {
-                min = match handler.filter {
-                    Some(BlockHandlerFilter::Polling { every: _ }) => SPEC_VERSION_0_0_8,
-                    Some(BlockHandlerFilter::Once) => SPEC_VERSION_0_0_8,
-                    _ => min,
-                };
-                min
-            })
+        let mut min_version = MIN_SPEC_VERSION;
+
+        for handler in &self.mapping.block_handlers {
+            match handler.filter {
+                Some(BlockHandlerFilter::Polling { every: _ }) | Some(BlockHandlerFilter::Once) => {
+                    min_version = std::cmp::max(min_version, SPEC_VERSION_0_0_8);
+                }
+                _ => {}
+            }
+        }
+
+        for handler in &self.mapping.event_handlers {
+            if handler.has_additional_topics() {
+                min_version = std::cmp::max(min_version, SPEC_VERSION_1_2_0);
+            }
+        }
+
+        min_version
     }
 
     fn runtime(&self) -> Option<Arc<Vec<u8>>> {
@@ -366,6 +437,43 @@ impl blockchain::DataSource<Chain> for DataSource {
     }
 }
 
+/// Generic function that creates a mock legacy Transaction from ANY log
+fn create_dummy_transaction(
+    block_number: u64,
+    block_hash: B256,
+    transaction_index: Option<u64>,
+    transaction_hash: Option<B256>,
+) -> Result<AnyTransaction, anyhow::Error> {
+    use graph::components::ethereum::AnyTxEnvelope;
+    use graph::prelude::alloy::{
+        consensus::Signed, consensus::transaction::Recovered, primitives::Signature,
+        rpc::types::Transaction,
+    };
+
+    let tx = TxLegacy::default();
+
+    // Create a dummy signature
+    let signature = Signature::new(U256::ZERO, U256::ZERO, false);
+
+    let tx_hash = transaction_hash.ok_or(anyhow!("Log has no transaction hash"))?;
+    let signed_tx = Signed::new_unchecked(tx, signature, tx_hash);
+    let eth_envelope = TxEnvelope::Legacy(signed_tx);
+
+    // Wrap in AnyTxEnvelope
+    let any_envelope = AnyTxEnvelope::Ethereum(eth_envelope);
+
+    let recovered = Recovered::new_unchecked(any_envelope, Address::ZERO);
+
+    Ok(Transaction {
+        inner: recovered,
+        block_hash: Some(block_hash),
+        block_number: Some(block_number),
+        block_timestamp: None,
+        transaction_index,
+        effective_gas_price: None,
+    })
+}
+
 impl DataSource {
     fn from_manifest(
         kind: String,
@@ -397,23 +505,16 @@ impl DataSource {
         })
     }
 
-    fn handlers_for_log(&self, log: &Log) -> Vec<MappingEventHandler> {
-        // Get signature from the log
-        let topic0 = match log.topics.get(0) {
-            Some(topic0) => topic0,
-            // Events without a topic should just be be ignored
-            None => return vec![],
-        };
-
+    fn handlers_for_log(&self, log: &alloy::rpc::types::Log) -> Vec<MappingEventHandler> {
         self.mapping
             .event_handlers
             .iter()
-            .filter(|handler| *topic0 == handler.topic0())
+            .filter(|handler| handler.matches(log))
             .cloned()
             .collect::<Vec<_>>()
     }
 
-    fn handler_for_call(&self, call: &EthereumCall) -> Result<Option<MappingCallHandler>, Error> {
+    fn handler_for_call(&self, call: &EthereumCall) -> Result<Option<&MappingCallHandler>, Error> {
         // First four bytes of the input for the call are the first four
         // bytes of hash of the function signature
         ensure!(
@@ -423,80 +524,73 @@ impl DataSource {
 
         let target_method_id = &call.input.0[..4];
 
-        Ok(self
-            .mapping
-            .call_handlers
-            .iter()
-            .find(move |handler| {
-                let fhash = keccak256(handler.function.as_bytes());
-                let actual_method_id = [fhash[0], fhash[1], fhash[2], fhash[3]];
-                target_method_id == actual_method_id
-            })
-            .cloned())
+        Ok(self.mapping.call_handlers.iter().find(move |handler| {
+            let fhash = keccak256(handler.function.as_bytes());
+            let actual_method_id = [fhash[0], fhash[1], fhash[2], fhash[3]];
+            target_method_id == actual_method_id
+        }))
     }
 
     fn handler_for_block(
         &self,
         trigger_type: &EthereumBlockTriggerType,
         block: BlockNumber,
-    ) -> Option<MappingBlockHandler> {
+    ) -> Option<&MappingBlockHandler> {
         match trigger_type {
             // Start matches only initialization handlers with a `once` filter
-            EthereumBlockTriggerType::Start => self
-                .mapping
-                .block_handlers
-                .iter()
-                .find(move |handler| match handler.filter {
-                    Some(BlockHandlerFilter::Once) => block == self.start_block,
-                    _ => false,
-                })
-                .cloned(),
+            EthereumBlockTriggerType::Start => {
+                self.mapping
+                    .block_handlers
+                    .iter()
+                    .find(move |handler| match handler.filter {
+                        Some(BlockHandlerFilter::Once) => block == self.start_block,
+                        _ => false,
+                    })
+            }
             // End matches all handlers without a filter or with a `polling` filter
-            EthereumBlockTriggerType::End => self
-                .mapping
-                .block_handlers
-                .iter()
-                .find(move |handler| match handler.filter {
-                    Some(BlockHandlerFilter::Polling { every }) => {
-                        let start_block = self.start_block;
-                        let should_trigger = (block - start_block) % every.get() as i32 == 0;
-                        should_trigger
-                    }
-                    None => true,
-                    _ => false,
-                })
-                .cloned(),
+            EthereumBlockTriggerType::End => {
+                self.mapping
+                    .block_handlers
+                    .iter()
+                    .find(move |handler| match handler.filter {
+                        Some(BlockHandlerFilter::Polling { every }) => {
+                            let start_block = self.start_block;
+                            (block - start_block) % every.get() as i32 == 0
+                        }
+                        None => true,
+                        _ => false,
+                    })
+            }
             EthereumBlockTriggerType::WithCallTo(_address) => self
                 .mapping
                 .block_handlers
                 .iter()
-                .find(move |handler| handler.filter == Some(BlockHandlerFilter::Call))
-                .cloned(),
+                .find(move |handler| handler.filter == Some(BlockHandlerFilter::Call)),
         }
     }
 
-    /// Returns the contract event with the given signature, if it exists. A an event from the ABI
+    /// Returns the contract event with the given signature, if it exists. An event from the ABI
     /// will be matched if:
     /// 1. An event signature is equal to `signature`.
     /// 2. There are no equal matches, but there is exactly one event that equals `signature` if all
     ///    `indexed` modifiers are removed from the parameters.
-    fn contract_event_with_signature(&self, signature: &str) -> Option<&Event> {
+    fn contract_event_with_signature(&self, signature: &str) -> Option<&abi::Event> {
         // Returns an `Event(uint256,address)` signature for an event, without `indexed` hints.
-        fn ambiguous_event_signature(event: &Event) -> String {
+        fn ambiguous_event_signature(event: &abi::Event) -> String {
             format!(
                 "{}({})",
                 event.name,
                 event
                     .inputs
                     .iter()
-                    .map(|input| event_param_type_signature(&input.kind))
+                    .map(|input| input.selector_type().into_owned())
                     .collect::<Vec<_>>()
                     .join(",")
             )
         }
 
         // Returns an `Event(indexed uint256,address)` type signature for an event.
-        fn event_signature(event: &Event) -> String {
+        fn event_signature(event: &abi::Event) -> String {
             format!(
                 "{}({})",
                 event.name,
@@ -506,40 +600,13 @@ impl DataSource {
                     .map(|input| format!(
                         "{}{}",
                         if input.indexed { "indexed " } else { "" },
-                        event_param_type_signature(&input.kind)
+                        input.selector_type()
                     ))
                     .collect::<Vec<_>>()
                     .join(",")
             )
         }
 
-        // Returns the signature of an event parameter type (e.g. `uint256`).
-        fn event_param_type_signature(kind: &ParamType) -> String {
-            use ParamType::*;
-
-            match kind {
-                Address => "address".into(),
-                Bytes => "bytes".into(),
-                Int(size) => format!("int{}", size),
-                Uint(size) => format!("uint{}", size),
-                Bool => "bool".into(),
-                String => "string".into(),
-                Array(inner) => format!("{}[]", event_param_type_signature(inner)),
-                FixedBytes(size) => format!("bytes{}", size),
-                FixedArray(inner, size) => {
-                    format!("{}[{}]", event_param_type_signature(inner), size)
-                }
-                Tuple(components) => format!(
-                    "({})",
-                    components
-                        .iter()
-                        .map(event_param_type_signature)
-                        .collect::<Vec<_>>()
-                        .join(",")
-                ),
-            }
-        }
-
         self.contract_abi
             .contract
             .events()
@@ -578,7 +645,9 @@ impl DataSource {
             })
     }
 
-    fn contract_function_with_signature(&self, target_signature: &str) -> Option<&Function> {
+    fn contract_function_with_signature(&self, target_signature: &str) -> Option<&abi::Function> {
+        use abi::StateMutability;
+
         self.contract_abi
             .contract
             .functions()
@@ -592,13 +661,13 @@ impl DataSource {
                 let mut arguments = function
                     .inputs
                     .iter()
-                    .map(|input| format!("{}", input.kind))
+                    .map(|input| input.selector_type().into_owned())
                     .collect::<Vec<String>>()
                     .join(",");
                 // `address,uint256,bool)
                 arguments.push(')');
                 // `operation(address,uint256,bool)`
-                let actual_signature = vec![function.name.clone(), arguments].join("(");
+                let actual_signature = [function.name.clone(), arguments].join("(");
                 target_signature == actual_signature
             })
     }
@@ -642,7 +711,7 @@ impl DataSource {
                     MappingTrigger::Block {
                         block: block.cheap_clone(),
                     },
-                    handler.handler,
+                    handler.handler.clone(),
                     block.block_ptr(),
                     block.timestamp(),
                 )))
@@ -682,11 +751,7 @@ impl DataSource {
                     .into_iter()
                     .filter_map(|(event_handler, event_abi)| {
                         event_abi
-                            .parse_log(RawLog {
-                                topics: log.topics.clone(),
-                                data: log.data.clone().0,
-                            })
-                            .map(|log| log.params)
+                            .decode_log(&log)
                             .map_err(|e| {
                                 trace!(
                                     logger,
@@ -723,36 +788,47 @@ impl DataSource {
                 // associated transaction and instead have `transaction_hash == block.hash`,
                 // in which case we pass a dummy transaction to the mappings.
                 // See also ca0edc58-0ec5-4c89-a7dd-2241797f5e50.
-                let transaction = if log.transaction_hash != block.hash {
+                // There is another special case in zkSync-era, where the transaction hash in this case would be zero
+                // See https://docs.zksync.io/zk-stack/concepts/blocks.html#fictive-l2-block-finalizing-the-batch
+                let transaction = if log.transaction_hash == Some(block.hash())
+                    || log.transaction_hash == Some(B256::ZERO)
+                {
+                    create_dummy_transaction(
+                        block.number_u64(),
+                        block.hash(),
+                        log.transaction_index,
+                        log.transaction_hash,
+                    )?
+                } else {
+                    // This is the general case where the log's transaction hash does not match the block's hash
+                    // and is not a special zero hash, implying a real transaction associated with this log.
                     block
                         .transaction_for_log(&log)
                         .context("Found no transaction for event")?
-                } else {
-                    // Infer some fields from the log and fill the rest with zeros.
-                    Transaction {
-                        hash: log.transaction_hash.unwrap(),
-                        block_hash: block.hash,
-                        block_number: block.number,
-                        transaction_index: log.transaction_index,
-                        from: Some(H160::zero()),
-                        ..Transaction::default()
-                    }
                 };
 
                 let logging_extras = Arc::new(o! {
                     "signature" => event_handler.event.to_string(),
-                    "address" => format!("{}", &log.address),
-                    "transaction" => format!("{}", &transaction.hash),
+                    "address" => format!("{}", &log.address()),
+                    "transaction" => format!("{}", &transaction.tx_hash()),
                 });
+                let handler = event_handler.handler.clone();
+                let calls = DeclaredCall::from_log_trigger_with_event(
+                    &self.mapping,
+                    &event_handler.calls,
+                    &log,
+                    &params,
+                )?;
                 Ok(Some(TriggerWithHandler::<Chain>::new_with_logging_extras(
                     MappingTrigger::Log {
                         block: block.cheap_clone(),
                         transaction: Arc::new(transaction),
-                        log: log,
+                        log,
                         params,
                         receipt: receipt.map(|r| r.cheap_clone()),
+                        calls,
                     },
-                    event_handler.handler,
+                    handler,
                     block.block_ptr(),
                     block.timestamp(),
                     logging_extras,
@@ -778,20 +854,15 @@ impl DataSource {
                         )
                     })?;
 
-                // Parse the inputs
-                //
-                // Take the input for the call, chop off the first 4 bytes, then call
-                // `function.decode_input` to get a vector of `Token`s. Match the `Token`s
-                // with the `Param`s in `function.inputs` to create a `Vec<LogParam>`.
-                let tokens = match function_abi.decode_input(&call.input.0[4..]).with_context(
-                    || {
+                let values = match function_abi
+                    .abi_decode_input(&call.input.0[4..])
+                    .with_context(|| {
                         format!(
                             "Generating function inputs for the call {:?} failed, raw input: {}",
                             &function_abi,
                             hex::encode(&call.input.0)
                         )
-                    },
-                ) {
+                    }) {
                     Ok(val) => val,
                     // See also 280b0108-a96e-4738-bb37-60ce11eeb5bf
                     Err(err) => {
@@ -801,27 +872,22 @@ impl DataSource {
                 };
 
                 ensure!(
-                    tokens.len() == function_abi.inputs.len(),
+                    values.len() == function_abi.inputs.len(),
                     "Number of arguments in call does not match \
                     number of inputs in function signature."
                 );
 
-                let inputs = tokens
+                let inputs = values
                     .into_iter()
                     .enumerate()
-                    .map(|(i, token)| LogParam {
+                    .map(|(i, value)| abi::DynSolParam {
                         name: function_abi.inputs[i].name.clone(),
-                        value: token,
+                        value,
                     })
                     .collect::<Vec<_>>();
 
-                // Parse the outputs
-                //
-                // Take the output for the call, then call `function.decode_output` to
-                // get a vector of `Token`s. Match the `Token`s with the `Param`s in
-                // `function.outputs` to create a `Vec<LogParam>`.
-                let tokens = function_abi
-                    .decode_output(&call.output.0)
+                let values = function_abi
+                    .abi_decode_output(&call.output.0)
                     .with_context(|| {
                         format!(
                             "Decoding function outputs for the call {:?} failed, raw output: {}",
@@ -831,17 +897,17 @@ impl DataSource {
                     })?;
 
                 ensure!(
-                    tokens.len() == function_abi.outputs.len(),
+                    values.len() == function_abi.outputs.len(),
                     "Number of parameters in the call output does not match \
                         number of outputs in the function signature."
                 );
 
-                let outputs = tokens
+                let outputs = values
                     .into_iter()
                     .enumerate()
-                    .map(|(i, token)| LogParam {
+                    .map(|(i, value)| abi::DynSolParam {
                         name: function_abi.outputs[i].name.clone(),
-                        value: token,
+                        value,
                     })
                     .collect::<Vec<_>>();
 
@@ -853,7 +919,7 @@ impl DataSource {
                 let logging_extras = Arc::new(o! {
                     "function" => handler.function.to_string(),
                     "to" => format!("{}", &call.to),
-                    "transaction" => format!("{}", &transaction.hash),
+                    "transaction" => format!("{}", &transaction.tx_hash()),
                 });
                 Ok(Some(TriggerWithHandler::<Chain>::new_with_logging_extras(
                     MappingTrigger::Call {
@@ -863,7 +929,7 @@ impl DataSource {
                         inputs,
                         outputs,
                     },
-                    handler.handler,
+                    handler.handler.clone(),
                     block.block_ptr(),
                     block.timestamp(),
                     logging_extras,
@@ -873,6 +939,256 @@ impl DataSource {
     }
 }
 
+pub struct DecoderHook {
+    eth_adapters: Arc<EthereumNetworkAdapters>,
+    call_cache: Arc<dyn EthereumCallCache>,
+    eth_call_gas: Option<u32>,
+}
+
+impl DecoderHook {
+    pub fn new(
+        eth_adapters: Arc<EthereumNetworkAdapters>,
+        call_cache: Arc<dyn EthereumCallCache>,
+        eth_call_gas: Option<u32>,
+    ) -> Self {
+        Self {
+            eth_adapters,
+            call_cache,
+            eth_call_gas,
+        }
+    }
+}
+
+impl DecoderHook {
+    /// Perform a batch of eth_calls, observing the execution time of each
+    /// call. Returns a list of the call labels for which we received a
+    /// `None` response, indicating a revert
+    async fn eth_calls(
+        &self,
+        logger: &Logger,
+        block_ptr: &BlockPtr,
+        calls_and_metrics: Vec<(Arc<HostMetrics>, DeclaredCall)>,
+    ) -> Result<Vec<String>, MappingError> {
+        // This check is not just to speed things up, but is also needed to
+        // make sure the runner tests don't fail; they don't have declared
+        // eth calls, but without this check we try to get an eth adapter
+        // even when there are no calls, which fails in the runner test
+        // setup
+        if calls_and_metrics.is_empty() {
+            return Ok(vec![]);
+        }
+
+        let start = Instant::now();
+
+        let (metrics, calls): (Vec<_>, Vec<_>) = calls_and_metrics.into_iter().unzip();
+
+        let (calls, labels): (Vec<_>, Vec<_>) = calls
+            .into_iter()
+            .map(|call| call.as_eth_call(block_ptr.clone(), self.eth_call_gas))
+            .unzip();
+
+        let eth_adapter = self.eth_adapters.call_or_cheapest(Some(&NodeCapabilities {
+            archive: true,
+            traces: false,
+        }))?;
+
+        let call_refs = calls.iter().collect::<Vec<_>>();
+        let results = eth_adapter
+            .contract_calls(logger, &call_refs, self.call_cache.cheap_clone())
+            .await
+            .map_err(|e| {
+                // An error happened, everybody gets charged
+                let elapsed = start.elapsed().as_secs_f64() / call_refs.len() as f64;
+                for (metrics, call) in metrics.iter().zip(call_refs) {
+                    metrics.observe_eth_call_execution_time(
+                        elapsed,
+                        &call.contract_name,
+                        &call.function.name,
+                    );
+                }
+                MappingError::from(e)
+            })?;
+
+        // We don't have time measurements for each call (though that would be nice)
+        // Use the average time of all calls that we want to observe as the time for
+        // each call
+        let to_observe = results
+            .iter()
+            .filter(|(_, source)| source.observe())
+            .count() as f64;
+        let elapsed = start.elapsed().as_secs_f64() / to_observe;
+
+        results
+            .iter()
+            .zip(metrics)
+            .zip(calls)
+            .for_each(|(((_, source), metrics), call)| {
+                if source.observe() {
+                    metrics.observe_eth_call_execution_time(
+                        elapsed,
+                        &call.contract_name,
+                        &call.function.name,
+                    );
+                }
+            });
+
+        let labels = results
+            .iter()
+            .zip(labels)
+            .filter_map(|((res, _), label)| if res.is_none() { Some(label) } else { None })
+            .map(|s| s.to_string())
+            .collect();
+        Ok(labels)
+    }
+
+    fn collect_declared_calls<'a>(
+        &self,
+        runnables: &Vec<RunnableTriggers<'a, Chain>>,
+    ) -> Vec<(Arc<HostMetrics>, DeclaredCall)> {
+        // Extract all hosted triggers from runnables
+        let all_triggers = runnables
+            .iter()
+            .flat_map(|runnable| &runnable.hosted_triggers);
+
+        // Collect calls from both onchain and subgraph triggers
+        let mut all_calls = Vec::new();
+
+        for trigger in all_triggers {
+            let host_metrics = trigger.host.host_metrics();
+
+            match &trigger.mapping_trigger.trigger {
+                MappingTriggerType::Onchain(t) => {
+                    if let MappingTrigger::Log { calls, .. } = t {
+                        for call in calls.clone() {
+                            all_calls.push((host_metrics.cheap_clone(), call));
+                        }
+                    }
+                }
+                MappingTriggerType::Subgraph(t) => {
+                    for call in t.calls.clone() {
+                        // Convert subgraph call to the expected DeclaredCall type if needed
+                        // or handle differently based on the types
+                        all_calls.push((host_metrics.cheap_clone(), call));
+                    }
+                }
+                MappingTriggerType::Offchain(_) => {}
+            }
+        }
+
+        all_calls
+    }
+
+    /// Deduplicate calls. Unfortunately, we can't get `DeclaredCall` to
+    /// implement `Hash` or `Ord` easily, so we can only deduplicate by
+    /// comparing the whole call not with a `HashSet` or `BTreeSet`.
+    /// Since that can be inefficient, we don't deduplicate if we have an
+    /// enormous amount of calls; in that case though, things will likely
+    /// blow up because of the amount of I/O that many calls cause.
+    /// Cutting off at 1000 is fairly arbitrary
+    fn deduplicate_calls(
+        &self,
+        calls: Vec<(Arc<HostMetrics>, DeclaredCall)>,
+    ) -> Vec<(Arc<HostMetrics>, DeclaredCall)> {
+        if calls.len() >= 1000 {
+            return calls;
+        }
+
+        let mut uniq_calls = Vec::new();
+        for (metrics, call) in calls {
+            if !uniq_calls.iter().any(|(_, c)| c == &call) {
+                uniq_calls.push((metrics, call));
+            }
+        }
+        uniq_calls
+    }
+
+    /// Log information about failed eth calls. 'Failure' here simply
+    /// means that the call was reverted; outright errors lead to a real
+    /// error. For reverted calls, `self.eth_calls` returns the label
+    /// from the manifest for that call.
+    ///
+    /// One reason why declared calls can fail is if they are attached
+    /// to the wrong handler, or if arguments are specified incorrectly.
+    /// Calls that revert every once in a while might be ok and what the
+    /// user intended, but we want to clearly log so that users can spot
+    /// mistakes in their manifest, which will lead to unnecessary eth
+    /// calls
+    fn log_declared_call_results(
+        logger: &Logger,
+        failures: &[String],
+        calls_count: usize,
+        trigger_count: usize,
+        elapsed: Duration,
+    ) {
+        let fail_count = failures.len();
+
+        if fail_count > 0 {
+            let mut counts: Vec<_> = failures.iter().counts().into_iter().collect();
+            counts.sort_by_key(|(label, _)| *label);
+
+            let failure_summary = counts
+                .into_iter()
+                .map(|(label, count)| {
+                    let times = if count == 1 { "time" } else { "times" };
+                    format!("{label} ({count} {times})")
+                })
+                .join(", ");
+
+            error!(logger, "Declared calls failed";
+                "triggers" => trigger_count,
+                "calls_count" => calls_count,
+                "fail_count" => fail_count,
+                "calls_ms" => elapsed.as_millis(),
+                "failures" => format!("[{}]", failure_summary)
+            );
+        } else {
+            debug!(logger, "Declared calls";
+                "triggers" => trigger_count,
+                "calls_count" => calls_count,
+                "calls_ms" => elapsed.as_millis()
+            );
+        }
+    }
+}
+
+#[async_trait]
+impl blockchain::DecoderHook<Chain> for DecoderHook {
+    async fn after_decode<'a>(
+        &self,
+        logger: &Logger,
+        block_ptr: &BlockPtr,
+        runnables: Vec<RunnableTriggers<'a, Chain>>,
+        metrics: &Arc<SubgraphInstanceMetrics>,
+    ) -> Result<Vec<RunnableTriggers<'a, Chain>>, MappingError> {
+        if ENV_VARS.mappings.disable_declared_calls {
+            return Ok(runnables);
+        }
+
+        let _section = metrics.stopwatch.start_section("declared_ethereum_call");
+
+        let start = Instant::now();
+        // Collect and process declared calls
+        let calls = self.collect_declared_calls(&runnables);
+        let deduplicated_calls = self.deduplicate_calls(calls);
+
+        // Execute calls and log results
+        let calls_count = deduplicated_calls.len();
+        let results = self
+            .eth_calls(logger, block_ptr, deduplicated_calls)
+            .await?;
+
+        Self::log_declared_call_results(
+            logger,
+            &results,
+            calls_count,
+            runnables.len(),
+            start.elapsed(),
+        );
+
+        Ok(runnables)
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
 pub struct UnresolvedDataSource {
     pub kind: String,
@@ -887,9 +1203,11 @@ pub struct UnresolvedDataSource {
 impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
     async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         logger: &Logger,
         manifest_idx: u32,
+        spec_version: &semver::Version,
     ) -> Result<DataSource, anyhow::Error> {
         let UnresolvedDataSource {
             kind,
@@ -900,7 +1218,7 @@ impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
             context,
         } = self;
 
-        let mapping = mapping.resolve(resolver, logger).await.with_context(|| {
+        let mapping = mapping.resolve(deployment_hash, resolver, logger, spec_version).await.with_context(|| {
             format!(
                 "failed to resolve data source {} with source_address {:?} and source_start_block {}",
                 name, source.address, source.start_block
@@ -911,7 +1229,7 @@ impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
     }
 }
 
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)]
 pub struct UnresolvedDataSourceTemplate {
     pub kind: String,
     pub network: Option<String>,
@@ -934,9 +1252,11 @@ pub struct DataSourceTemplate {
 impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTemplate {
     async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         logger: &Logger,
         manifest_idx: u32,
+        spec_version: &semver::Version,
     ) -> Result<DataSourceTemplate, anyhow::Error> {
         let UnresolvedDataSourceTemplate {
             kind,
@@ -947,7 +1267,7 @@ impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTem
         } = self;
 
         let mapping = mapping
-            .resolve(resolver, logger)
+            .resolve(deployment_hash, resolver, logger, spec_version)
             .await
             .with_context(|| format!("failed to resolve data source template {}", name))?;
 
@@ -984,7 +1304,7 @@ impl blockchain::DataSourceTemplate<Chain> for DataSourceTemplate {
     }
 }
 
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct UnresolvedMapping {
     pub kind: String,
@@ -997,7 +1317,7 @@ pub struct UnresolvedMapping {
     #[serde(default)]
     pub call_handlers: Vec<MappingCallHandler>,
     #[serde(default)]
-    pub event_handlers: Vec<MappingEventHandler>,
+    pub event_handlers: Vec<UnresolvedMappingEventHandler>,
     pub file: Link,
 }
 
@@ -1029,8 +1349,10 @@ impl Mapping {
             .iter()
             .any(|handler| matches!(handler.filter, Some(BlockHandlerFilter::Call)))
     }
+}
 
-    pub fn find_abi(&self, abi_name: &str) -> Result<Arc<MappingABI>, Error> {
+impl FindMappingABI for Mapping {
+    fn find_abi(&self, abi_name: &str) -> Result<Arc<MappingABI>, Error> {
         Ok(self
             .abis
             .iter()
@@ -1043,8 +1365,10 @@ impl Mapping {
 impl UnresolvedMapping {
     pub async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         logger: &Logger,
+        spec_version: &semver::Version,
     ) -> Result<Mapping, anyhow::Error> {
         let UnresolvedMapping {
             kind,
@@ -1064,67 +1388,57 @@ impl UnresolvedMapping {
             // resolve each abi
             abis.into_iter()
                 .map(|unresolved_abi| async {
-                    Result::<_, Error>::Ok(Arc::new(
-                        unresolved_abi.resolve(resolver, logger).await?,
-                    ))
+                    unresolved_abi
+                        .resolve(deployment_hash, resolver, logger)
+                        .await
                 })
                 .collect::<FuturesOrdered<_>>()
                 .try_collect::<Vec<_>>(),
             async {
-                let module_bytes = resolver.cat(logger, &link).await?;
+                let module_bytes = resolver
+                    .cat(&LinkResolverContext::new(deployment_hash, logger), &link)
+                    .await?;
                 Ok(Arc::new(module_bytes))
             },
         )
         .await
         .with_context(|| format!("failed to resolve mapping {}", link.link))?;
 
+        // Resolve event handlers with ABI context
+        let resolved_event_handlers = event_handlers
+            .into_iter()
+            .map(|unresolved_handler| {
+                // Find the ABI for this event handler
+                let (_, abi_json) = abis.first().ok_or_else(|| {
+                    anyhow!(
+                        "No ABI found for event '{}' in event handler '{}'",
+                        unresolved_handler.event,
+                        unresolved_handler.handler
+                    )
+                })?;
+
+                unresolved_handler.resolve(abi_json, spec_version)
+            })
+            .collect::<Result<Vec<_>, anyhow::Error>>()?;
+
+        // Extract just the MappingABIs for the final Mapping struct
+        let mapping_abis = abis.into_iter().map(|(abi, _)| Arc::new(abi)).collect();
+
         Ok(Mapping {
             kind,
             api_version,
             language,
             entities,
-            abis,
+            abis: mapping_abis,
             block_handlers: block_handlers.clone(),
             call_handlers: call_handlers.clone(),
-            event_handlers: event_handlers.clone(),
+            event_handlers: resolved_event_handlers,
             runtime,
             link,
         })
     }
 }
 
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
-pub struct UnresolvedMappingABI {
-    pub name: String,
-    pub file: Link,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct MappingABI {
-    pub name: String,
-    pub contract: Contract,
-}
-
-impl UnresolvedMappingABI {
-    pub async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-    ) -> Result<MappingABI, anyhow::Error> {
-        let contract_bytes = resolver.cat(logger, &self.file).await.with_context(|| {
-            format!(
-                "failed to resolve ABI {} from {}",
-                self.name, self.file.link
-            )
-        })?;
-        let contract = Contract::load(&*contract_bytes)?;
-        Ok(MappingABI {
-            name: self.name,
-            contract,
-        })
-    }
-}
-
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
 pub struct MappingBlockHandler {
     pub handler: String,
@@ -1162,34 +1476,121 @@ pub struct MappingCallHandler {
     pub handler: String,
 }
 
-#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
-pub struct MappingEventHandler {
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
+pub struct UnresolvedMappingEventHandler {
     pub event: String,
-    pub topic0: Option<H256>,
+    pub topic0: Option<B256>,
+    #[serde(deserialize_with = "deserialize_b256_vec", default)]
+    pub topic1: Option<Vec<B256>>,
+    #[serde(deserialize_with = "deserialize_b256_vec", default)]
+    pub topic2: Option<Vec<B256>>,
+    #[serde(deserialize_with = "deserialize_b256_vec", default)]
+    pub topic3: Option<Vec<B256>>,
     pub handler: String,
     #[serde(default)]
     pub receipt: bool,
+    #[serde(default)]
+    pub calls: UnresolvedCallDecls,
+}
+
+impl UnresolvedMappingEventHandler {
+    pub fn resolve(
+        self,
+        abi_json: &AbiJson,
+        spec_version: &semver::Version,
+    ) -> Result<MappingEventHandler, anyhow::Error> {
+        let resolved_calls = self
+            .calls
+            .resolve(abi_json, Some(&self.event), spec_version)?;
+
+        Ok(MappingEventHandler {
+            event: self.event,
+            topic0: self.topic0,
+            topic1: self.topic1,
+            topic2: self.topic2,
+            topic3: self.topic3,
+            handler: self.handler,
+            receipt: self.receipt,
+            calls: resolved_calls,
+        })
+    }
+}
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub struct MappingEventHandler {
+    pub event: String,
+    pub topic0: Option<B256>,
+    pub topic1: Option<Vec<B256>>,
+    pub topic2: Option<Vec<B256>>,
+    pub topic3: Option<Vec<B256>>,
+    pub handler: String,
+    pub receipt: bool,
+    pub calls: CallDecls,
+}
+
+// Custom deserializer for B256 fields that removes the '0x' prefix before parsing
+fn deserialize_b256_vec<'de, D>(deserializer: D) -> Result<Option<Vec<B256>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s: Option<Vec<String>> = Option::deserialize(deserializer)?;
+
+    match s {
+        Some(vec) => {
+            let mut b256_vec = Vec::new();
+            for hex_str in vec {
+                // Remove '0x' prefix if present
+                let clean_hex_str = hex_str.trim_start_matches("0x");
+                // Ensure the hex string is 64 characters long, after removing '0x'
+                let padded_hex_str = format!("{:0>64}", clean_hex_str);
+                // Parse the padded string into H256, handling potential errors
+                b256_vec.push(
+                    B256::from_str(&padded_hex_str)
+                        .map_err(|e| D::Error::custom(format!("Failed to parse B256: {}", e)))?,
+                );
+            }
+            Ok(Some(b256_vec))
+        }
+        None => Ok(None),
+    }
 }
 
 impl MappingEventHandler {
-    pub fn topic0(&self) -> H256 {
+    pub fn topic0(&self) -> B256 {
         self.topic0
-            .unwrap_or_else(|| string_to_h256(&self.event.replace("indexed ", "")))
+            .unwrap_or_else(|| string_to_b256(&self.event.replace("indexed ", "")))
+    }
+
+    pub fn matches(&self, log: &Log) -> bool {
+        let matches_topic = |index: usize, topic_opt: &Option<Vec<B256>>| -> bool {
+            topic_opt.as_ref().is_none_or(|topic_vec| {
+                log.topics()
+                    .get(index)
+                    .is_some_and(|log_topic| topic_vec.contains(log_topic))
+            })
+        };
+
+        if let Some(topic0) = log.topics().first() {
+            return self.topic0() == *topic0
+                && matches_topic(1, &self.topic1)
+                && matches_topic(2, &self.topic2)
+                && matches_topic(3, &self.topic3);
+        }
+
+        // Logs without topic0 should simply be skipped
+        false
+    }
+
+    pub fn has_additional_topics(&self) -> bool {
+        self.topic1.as_ref().is_some_and(|v| !v.is_empty())
+            || self.topic2.as_ref().is_some_and(|v| !v.is_empty())
+            || self.topic3.as_ref().is_some_and(|v| !v.is_empty())
     }
 }
 
-/// Hashes a string to a H256 hash.
-fn string_to_h256(s: &str) -> H256 {
-    let mut result = [0u8; 32];
-    let data = s.replace(' ', "").into_bytes();
-    let mut sponge = Keccak::new_keccak256();
-    sponge.update(&data);
-    sponge.finalize(&mut result);
-
-    // This was deprecated but the replacement seems to not be available in the
-    // version web3 uses.
-    #[allow(deprecated)]
-    H256::from_slice(&result)
+/// Hashes a string to a B256 hash.
+fn string_to_b256(s: &str) -> B256 {
+    keccak256(s.replace(' ', "").as_bytes())
 }
 
 #[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
diff --git a/chain/ethereum/src/env.rs b/chain/ethereum/src/env.rs
index c4b0a263049..b15ee0ee018 100644
--- a/chain/ethereum/src/env.rs
+++ b/chain/ethereum/src/env.rs
@@ -1,6 +1,6 @@
 use envconfig::Envconfig;
 use graph::env::EnvVarBoolean;
-use graph::prelude::{envconfig, lazy_static, BlockNumber};
+use graph::prelude::{BlockNumber, envconfig, lazy_static};
 use std::fmt;
 use std::time::Duration;
 
@@ -13,9 +13,9 @@ lazy_static! {
 pub struct EnvVars {
     /// Additional deterministic errors that have not yet been hardcoded.
     ///
-    /// Set by the environment variable `GRAPH_GETH_ETH_CALL_ERRORS`, separated
+    /// Set by the environment variable `GRAPH_RPC_ETH_CALL_ERRORS`, separated
     /// by `;`.
-    pub geth_eth_call_errors: Vec<String>,
+    pub rpc_eth_call_errors: Vec<String>,
     /// Set by the environment variable `GRAPH_ETH_GET_LOGS_MAX_CONTRACTS`. The
     /// default value is 2000.
     pub get_logs_max_contracts: usize,
@@ -33,6 +33,9 @@ pub struct EnvVars {
     /// Set by the environment variable `ETHEREUM_BLOCK_BATCH_SIZE`. The
     /// default value is 10 blocks.
     pub block_batch_size: usize,
+    /// Set by the environment variable `ETHEREUM_BLOCK_PTR_BATCH_SIZE`. The
+    /// default value is 10 blocks.
+    pub block_ptr_batch_size: usize,
     /// Maximum number of blocks to request in each chunk.
     ///
     /// Set by the environment variable `GRAPH_ETHEREUM_MAX_BLOCK_RANGE_SIZE`.
@@ -46,6 +49,10 @@ pub struct EnvVars {
     /// Set by the environment variable `GRAPH_ETHEREUM_JSON_RPC_TIMEOUT`
     /// (expressed in seconds). The default value is 180s.
     pub json_rpc_timeout: Duration,
+
+    /// Set by the environment variable `GRAPH_ETHEREUM_BLOCK_RECEIPTS_CHECK_TIMEOUT`
+    /// (expressed in seconds). The default value is 10s.
+    pub block_receipts_check_timeout: Duration,
     /// This is used for requests that will not fail the subgraph if the limit
     /// is reached, but will simply restart the syncing step, so it can be low.
     /// This limit guards against scenarios such as requesting a block hash that
@@ -84,6 +91,10 @@ pub struct EnvVars {
     /// This is a comma separated list of chain ids for which the gas field will not be set
     /// when calling `eth_call`.
     pub eth_call_no_gas: Vec<String>,
+    /// Set by the flag `GRAPH_ETHEREUM_FORCE_RPC_FOR_BLOCK_PTRS`. On by default.
+    /// When enabled, forces the use of RPC instead of Firehose for loading block pointers by numbers.
+    /// This is used in composable subgraphs. Firehose can be slow for loading block pointers by numbers.
+    pub force_rpc_for_block_ptrs: bool,
 }
 
 // This does not print any values avoid accidentally leaking any sensitive env vars
@@ -103,8 +114,8 @@ impl From<Inner> for EnvVars {
     fn from(x: Inner) -> Self {
         Self {
             get_logs_max_contracts: x.get_logs_max_contracts,
-            geth_eth_call_errors: x
-                .geth_eth_call_errors
+            rpc_eth_call_errors: x
+                .rpc_eth_call_errors
                 .split(';')
                 .filter(|s| !s.is_empty())
                 .map(str::to_string)
@@ -112,8 +123,12 @@ impl From<Inner> for EnvVars {
             trace_stream_step_size: x.trace_stream_step_size,
             max_event_only_range: x.max_event_only_range,
             block_batch_size: x.block_batch_size,
+            block_ptr_batch_size: x.block_ptr_batch_size,
             max_block_range_size: x.max_block_range_size,
             json_rpc_timeout: Duration::from_secs(x.json_rpc_timeout_in_secs),
+            block_receipts_check_timeout: Duration::from_secs(
+                x.block_receipts_check_timeout_in_seccs,
+            ),
             request_retries: x.request_retries,
             block_ingestor_max_concurrent_json_rpc_calls: x
                 .block_ingestor_max_concurrent_json_rpc_calls,
@@ -130,6 +145,7 @@ impl From<Inner> for EnvVars {
                 .filter(|s| !s.is_empty())
                 .map(str::to_string)
                 .collect(),
+            force_rpc_for_block_ptrs: x.force_rpc_for_block_ptrs.0,
         }
     }
 }
@@ -142,8 +158,8 @@ impl Default for EnvVars {
 
 #[derive(Clone, Debug, Envconfig)]
 struct Inner {
-    #[envconfig(from = "GRAPH_GETH_ETH_CALL_ERRORS", default = "")]
-    geth_eth_call_errors: String,
+    #[envconfig(from = "GRAPH_RPC_ETH_CALL_ERRORS", default = "")]
+    rpc_eth_call_errors: String,
     #[envconfig(from = "GRAPH_ETH_GET_LOGS_MAX_CONTRACTS", default = "2000")]
     get_logs_max_contracts: usize,
 
@@ -153,10 +169,14 @@ struct Inner {
     max_event_only_range: BlockNumber,
     #[envconfig(from = "ETHEREUM_BLOCK_BATCH_SIZE", default = "10")]
     block_batch_size: usize,
+    #[envconfig(from = "ETHEREUM_BLOCK_PTR_BATCH_SIZE", default = "100")]
+    block_ptr_batch_size: usize,
     #[envconfig(from = "GRAPH_ETHEREUM_MAX_BLOCK_RANGE_SIZE", default = "2000")]
     max_block_range_size: BlockNumber,
     #[envconfig(from = "GRAPH_ETHEREUM_JSON_RPC_TIMEOUT", default = "180")]
     json_rpc_timeout_in_secs: u64,
+    #[envconfig(from = "GRAPH_ETHEREUM_BLOCK_RECEIPTS_CHECK_TIMEOUT", default = "10")]
+    block_receipts_check_timeout_in_seccs: u64,
     #[envconfig(from = "GRAPH_ETHEREUM_REQUEST_RETRIES", default = "10")]
     request_retries: usize,
     #[envconfig(
@@ -175,6 +195,8 @@ struct Inner {
     target_triggers_per_block_range: u64,
     #[envconfig(from = "GRAPH_ETHEREUM_GENESIS_BLOCK_NUMBER", default = "0")]
     genesis_block_number: u64,
-    #[envconfig(from = "GRAPH_ETH_CALL_NO_GAS", default = "421613")]
+    #[envconfig(from = "GRAPH_ETH_CALL_NO_GAS", default = "421613,421614")]
     eth_call_no_gas: String,
+    #[envconfig(from = "GRAPH_ETHEREUM_FORCE_RPC_FOR_BLOCK_PTRS", default = "true")]
+    force_rpc_for_block_ptrs: EnvVarBoolean,
 }
diff --git a/chain/ethereum/src/ethereum_adapter.rs b/chain/ethereum/src/ethereum_adapter.rs
index b699b7370db..9c85f0ac551 100644
--- a/chain/ethereum/src/ethereum_adapter.rs
+++ b/chain/ethereum/src/ethereum_adapter.rs
@@ -1,39 +1,56 @@
-use futures::future;
-use futures::prelude::*;
+use async_trait::async_trait;
 use futures03::{future::BoxFuture, stream::FuturesUnordered};
-use graph::blockchain::client::ChainClient;
+use graph::abi;
+use graph::abi::DynSolValueExt;
+use graph::abi::FunctionExt;
 use graph::blockchain::BlockHash;
 use graph::blockchain::ChainIdentifier;
+use graph::blockchain::ExtendedBlockPtr;
+use graph::blockchain::client::ChainClient;
+use graph::components::ethereum::*;
 use graph::components::transaction_receipt::LightTransactionReceipt;
-use graph::data::subgraph::UnifiedMappingApiVersion;
+use graph::data::store::ethereum::call;
+use graph::data::store::scalar;
 use graph::data::subgraph::API_VERSION_0_0_7;
-use graph::prelude::ethabi::ParamType;
-use graph::prelude::ethabi::Token;
-use graph::prelude::tokio::try_join;
-use graph::slog::o;
-use graph::{
-    blockchain::{block_stream::BlockWithTriggers, BlockPtr, IngestorError},
-    prelude::{
-        anyhow::{self, anyhow, bail, ensure, Context},
-        async_trait, debug, error, ethabi,
-        futures03::{self, compat::Future01CompatExt, FutureExt, StreamExt, TryStreamExt},
-        hex, info, retry, serde_json as json, stream, tiny_keccak, trace, warn,
-        web3::{
-            self,
-            types::{
-                Address, BlockId, BlockNumber as Web3BlockNumber, Bytes, CallRequest, Filter,
-                FilterBuilder, Log, Transaction, TransactionReceipt, H256,
+use graph::data::subgraph::UnifiedMappingApiVersion;
+use graph::data_source::common::ContractCall;
+use graph::derive::CheapClone;
+use graph::futures01::Future;
+use graph::futures01::Stream;
+use graph::futures01::stream;
+use graph::futures03::future::try_join_all;
+use graph::futures03::{
+    self, FutureExt, StreamExt, TryFutureExt, TryStreamExt, compat::Future01CompatExt,
+};
+use graph::prelude::{
+    alloy::{
+        self,
+        network::TransactionResponse,
+        primitives::{Address, B256},
+        providers::{
+            Identity, Provider, RootProvider,
+            ext::TraceApi,
+            fillers::{
+                BlobGasFiller, ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller,
             },
         },
-        BlockNumber, ChainStore, CheapClone, DynTryFuture, Error, EthereumCallCache, Logger,
-        TimeoutError, TryFutureExt,
+        rpc::types::{
+            TransactionInput, TransactionRequest,
+            trace::{filter::TraceFilter as AlloyTraceFilter, parity::LocalizedTransactionTrace},
+        },
+        transports::{RpcError, TransportErrorKind},
     },
+    tokio::try_join,
 };
+use graph::slog::o;
 use graph::{
-    components::ethereum::*,
-    prelude::web3::api::Web3,
-    prelude::web3::transports::Batch,
-    prelude::web3::types::{Trace, TraceFilter, TraceFilterBuilder, H160},
+    blockchain::{BlockPtr, IngestorError, block_stream::BlockWithTriggers},
+    prelude::{
+        BlockNumber, ChainStore, CheapClone, DynTryFuture, Error, EthereumCallCache, Logger,
+        TimeoutError,
+        anyhow::{self, Context, anyhow, bail, ensure},
+        debug, error, hex, info, retry, trace, warn,
+    },
 };
 use itertools::Itertools;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
@@ -41,32 +58,64 @@ use std::convert::TryFrom;
 use std::iter::FromIterator;
 use std::pin::Pin;
 use std::sync::Arc;
-use std::time::Instant;
+use std::time::{Duration, Instant};
+use tokio::sync::RwLock;
+use tokio::time::timeout;
 
-use crate::adapter::ProviderStatus;
-use crate::chain::BlockFinality;
-use crate::trigger::LogRef;
 use crate::Chain;
 use crate::NodeCapabilities;
+use crate::TriggerFilter;
+use crate::adapter::EthGetLogsFilter;
+use crate::adapter::EthereumRpcError;
+use crate::adapter::ProviderStatus;
+use crate::call_helper::interpret_eth_call_error;
+use crate::chain::BlockFinality;
+use crate::chain::ChainSettings;
+use crate::trigger::{LogPosition, LogRef};
 use crate::{
+    ENV_VARS,
     adapter::{
-        EthGetLogsFilter, EthereumAdapter as EthereumAdapterTrait, EthereumBlockFilter,
-        EthereumCallFilter, EthereumContractCall, EthereumContractCallError, EthereumLogFilter,
-        ProviderEthRpcMetrics, SubgraphEthRpcMetrics,
+        ContractCallError, EthereumAdapter as EthereumAdapterTrait, EthereumBlockFilter,
+        EthereumCallFilter, EthereumLogFilter, ProviderEthRpcMetrics, SubgraphEthRpcMetrics,
     },
     transport::Transport,
     trigger::{EthereumBlockTriggerType, EthereumTrigger},
-    TriggerFilter, ENV_VARS,
 };
 
-#[derive(Debug, Clone)]
+type AlloyProvider = FillProvider<
+    JoinFill<
+        Identity,
+        JoinFill<GasFiller, JoinFill<BlobGasFiller, JoinFill<NonceFiller, ChainIdFiller>>>,
+    >,
+    RootProvider<AnyNetworkBare>,
+    AnyNetworkBare,
+>;
+
+#[derive(Clone)]
 pub struct EthereumAdapter {
     logger: Logger,
     provider: String,
-    web3: Arc<Web3<Transport>>,
+    alloy: Arc<AlloyProvider>,
     metrics: Arc<ProviderEthRpcMetrics>,
     supports_eip_1898: bool,
     call_only: bool,
+    supports_block_receipts: Arc<RwLock<Option<bool>>>,
+    pub(crate) settings: Arc<ChainSettings>,
+}
+
+impl std::fmt::Debug for EthereumAdapter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("EthereumAdapter")
+            .field("logger", &self.logger)
+            .field("provider", &self.provider)
+            .field("alloy", &"<Provider>")
+            .field("metrics", &self.metrics)
+            .field("supports_eip_1898", &self.supports_eip_1898)
+            .field("call_only", &self.call_only)
+            .field("supports_block_receipts", &self.supports_block_receipts)
+            .field("settings", &self.settings)
+            .finish()
+    }
 }
 
 impl CheapClone for EthereumAdapter {
@@ -74,19 +123,44 @@ impl CheapClone for EthereumAdapter {
         Self {
             logger: self.logger.clone(),
             provider: self.provider.clone(),
-            web3: self.web3.cheap_clone(),
+            alloy: self.alloy.clone(),
             metrics: self.metrics.cheap_clone(),
             supports_eip_1898: self.supports_eip_1898,
             call_only: self.call_only,
+            supports_block_receipts: self.supports_block_receipts.cheap_clone(),
+            settings: self.settings.clone(),
         }
     }
 }
 
+/// Logger with provider context. Internal methods should take this type
+/// to ensure provider info is always included in logs.
+#[derive(Clone, CheapClone)]
+struct ProviderLogger(Logger);
+
+impl ProviderLogger {
+    fn new(logger: &Logger, provider: &str) -> Self {
+        Self(Logger::new(logger, o!("provider" => provider.to_string())))
+    }
+}
+
+impl std::ops::Deref for ProviderLogger {
+    type Target = Logger;
+    fn deref(&self) -> &Logger {
+        &self.0
+    }
+}
+
 impl EthereumAdapter {
     pub fn is_call_only(&self) -> bool {
         self.call_only
     }
 
+    /// Returns a logger with provider context added
+    fn provider_logger(&self, logger: &Logger) -> ProviderLogger {
+        ProviderLogger::new(logger, &self.provider)
+    }
+
     pub async fn new(
         logger: Logger,
         provider: String,
@@ -94,106 +168,68 @@ impl EthereumAdapter {
         provider_metrics: Arc<ProviderEthRpcMetrics>,
         supports_eip_1898: bool,
         call_only: bool,
+        settings: Arc<ChainSettings>,
     ) -> Self {
-        let web3 = Arc::new(Web3::new(transport));
-
-        // Use the client version to check if it is ganache. For compatibility with unit tests, be
-        // are lenient with errors, defaulting to false.
-        let is_ganache = web3
-            .web3()
-            .client_version()
-            .await
-            .map(|s| s.contains("TestRPC"))
-            .unwrap_or(false);
+        let alloy = match &transport {
+            Transport::RPC(client) => Arc::new(
+                alloy::providers::ProviderBuilder::<_, _, AnyNetworkBare>::default()
+                    .network::<AnyNetworkBare>()
+                    .connect_client(client.clone()),
+            ),
+            Transport::IPC(ipc_connect) => Arc::new(
+                alloy::providers::ProviderBuilder::<_, _, AnyNetworkBare>::default()
+                    .network::<AnyNetworkBare>()
+                    .connect_ipc(ipc_connect.clone())
+                    .await
+                    .expect("Failed to connect to Ethereum IPC"),
+            ),
+            Transport::WS(ws_connect) => Arc::new(
+                alloy::providers::ProviderBuilder::<_, _, AnyNetworkBare>::default()
+                    .network::<AnyNetworkBare>()
+                    .connect_ws(ws_connect.clone())
+                    .await
+                    .expect("Failed to connect to Ethereum WS"),
+            ),
+        };
 
         EthereumAdapter {
             logger,
             provider,
-            web3,
+            alloy,
             metrics: provider_metrics,
-            supports_eip_1898: supports_eip_1898 && !is_ganache,
+            supports_eip_1898,
             call_only,
+            supports_block_receipts: Arc::new(RwLock::new(None)),
+            settings,
         }
     }
 
     async fn traces(
         self,
-        logger: Logger,
+        logger: ProviderLogger,
         subgraph_metrics: Arc<SubgraphEthRpcMetrics>,
         from: BlockNumber,
         to: BlockNumber,
-        addresses: Vec<H160>,
-    ) -> Result<Vec<Trace>, Error> {
+        addresses: Vec<Address>,
+    ) -> Result<Vec<LocalizedTransactionTrace>, Error> {
         assert!(!self.call_only);
 
-        let eth = self.clone();
         let retry_log_message =
             format!("trace_filter RPC call for block range: [{}..{}]", from, to);
+        let eth = self.clone();
+
         retry(retry_log_message, &logger)
-            .limit(ENV_VARS.request_retries)
-            .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
+            .redact_log_urls(true)
+            .limit(self.settings.request_retries)
+            .timeout_secs(self.settings.json_rpc_timeout.as_secs())
             .run(move || {
-                let trace_filter: TraceFilter = match addresses.len() {
-                    0 => TraceFilterBuilder::default()
-                        .from_block(from.into())
-                        .to_block(to.into())
-                        .build(),
-                    _ => TraceFilterBuilder::default()
-                        .from_block(from.into())
-                        .to_block(to.into())
-                        .to_address(addresses.clone())
-                        .build(),
-                };
-
-                let eth = eth.cheap_clone();
-                let logger_for_triggers = logger.clone();
-                let logger_for_error = logger.clone();
-                let start = Instant::now();
+                let eth = eth.clone();
+                let logger = logger.clone();
                 let subgraph_metrics = subgraph_metrics.clone();
-                let provider_metrics = eth.metrics.clone();
-                let provider = self.provider.clone();
-
+                let addresses = addresses.clone();
                 async move {
-                    let result = eth
-                        .web3
-                        .trace()
-                        .filter(trace_filter)
+                    eth.execute_trace_filter_request(logger, subgraph_metrics, from, to, addresses)
                         .await
-                        .map(move |traces| {
-                            if !traces.is_empty() {
-                                if to == from {
-                                    debug!(
-                                        logger_for_triggers,
-                                        "Received {} traces for block {}",
-                                        traces.len(),
-                                        to
-                                    );
-                                } else {
-                                    debug!(
-                                        logger_for_triggers,
-                                        "Received {} traces for blocks [{}, {}]",
-                                        traces.len(),
-                                        from,
-                                        to
-                                    );
-                                }
-                            }
-                            traces
-                        })
-                        .map_err(Error::from);
-
-                    let elapsed = start.elapsed().as_secs_f64();
-                    provider_metrics.observe_request(elapsed, "trace_filter", &provider);
-                    subgraph_metrics.observe_request(elapsed, "trace_filter", &provider);
-                    if let Err(e) = &result {
-                        provider_metrics.add_error("trace_filter", &provider);
-                        subgraph_metrics.add_error("trace_filter", &provider);
-                        debug!(
-                            logger_for_error,
-                            "Error querying traces error = {:#} from = {} to = {}", e, from, to
-                        );
-                    }
-                    result
                 }
             })
             .map_err(move |e| {
@@ -209,28 +245,177 @@ impl EthereumAdapter {
             .await
     }
 
+    async fn execute_trace_filter_request(
+        &self,
+        logger: ProviderLogger,
+        subgraph_metrics: Arc<SubgraphEthRpcMetrics>,
+        from: BlockNumber,
+        to: BlockNumber,
+        addresses: Vec<Address>,
+    ) -> Result<Vec<LocalizedTransactionTrace>, Error> {
+        let alloy_trace_filter = Self::build_trace_filter(from, to, &addresses);
+        let start = Instant::now();
+
+        let result = self.alloy.trace_filter(&alloy_trace_filter).await;
+
+        if let Ok(traces) = &result {
+            self.log_trace_results(&logger, from, to, traces.len());
+        }
+
+        self.record_trace_metrics(
+            &subgraph_metrics,
+            start.elapsed().as_secs_f64(),
+            &result,
+            from,
+            to,
+            &logger,
+        );
+
+        result.map_err(Error::from)
+    }
+
+    fn build_trace_filter(
+        from: BlockNumber,
+        to: BlockNumber,
+        addresses: &[Address],
+    ) -> AlloyTraceFilter {
+        let filter = AlloyTraceFilter::default()
+            .from_block(from as u64)
+            .to_block(to as u64);
+
+        if !addresses.is_empty() {
+            filter.to_address(addresses.to_vec())
+        } else {
+            filter
+        }
+    }
+
+    fn log_trace_results(
+        &self,
+        logger: &ProviderLogger,
+        from: BlockNumber,
+        to: BlockNumber,
+        trace_len: usize,
+    ) {
+        if trace_len > 0 {
+            if to == from {
+                debug!(logger, "Received {} traces for block {}", trace_len, to);
+            } else {
+                debug!(
+                    logger,
+                    "Received {} traces for blocks [{}, {}]", trace_len, from, to
+                );
+            }
+        }
+    }
+
+    fn record_trace_metrics(
+        &self,
+        subgraph_metrics: &Arc<SubgraphEthRpcMetrics>,
+        elapsed: f64,
+        result: &Result<Vec<LocalizedTransactionTrace>, RpcError<TransportErrorKind>>,
+        from: BlockNumber,
+        to: BlockNumber,
+        logger: &ProviderLogger,
+    ) {
+        self.metrics
+            .observe_request(elapsed, "trace_filter", &self.provider);
+        subgraph_metrics.observe_request(elapsed, "trace_filter", &self.provider);
+
+        if let Err(e) = result {
+            self.metrics.add_error("trace_filter", &self.provider);
+            subgraph_metrics.add_error("trace_filter", &self.provider);
+            debug!(
+                logger,
+                "Error querying traces error = {:#} from = {} to = {}", e, from, to
+            );
+        }
+    }
+
+    // This is a lazy check for block receipt support. It is only called once and then the result is
+    // cached. The result is not used for anything critical, so it is fine to be lazy.
+    async fn check_block_receipt_support_and_update_cache(
+        &self,
+        alloy: Arc<AlloyProvider>,
+        block_hash: B256,
+        supports_eip_1898: bool,
+        call_only: bool,
+        logger: ProviderLogger,
+    ) -> bool {
+        // This is the lazy part. If the result is already in `supports_block_receipts`, we don't need
+        // to check again.
+        {
+            let supports_block_receipts = self.supports_block_receipts.read().await;
+            if let Some(supports_block_receipts) = *supports_block_receipts {
+                return supports_block_receipts;
+            }
+        }
+
+        info!(logger, "Checking eth_getBlockReceipts support");
+        let result = timeout(
+            ENV_VARS.block_receipts_check_timeout,
+            check_block_receipt_support(alloy, block_hash, supports_eip_1898, call_only),
+        )
+        .await;
+
+        let result = match result {
+            Ok(Ok(_)) => {
+                info!(logger, "Provider supports block receipts");
+                true
+            }
+            Ok(Err(err)) => {
+                warn!(logger, "Skipping use of block receipts, reason: {}", err);
+                false
+            }
+            Err(_) => {
+                warn!(
+                    logger,
+                    "Skipping use of block receipts, reason: Timeout after {} seconds",
+                    ENV_VARS.block_receipts_check_timeout.as_secs()
+                );
+                false
+            }
+        };
+
+        // We set the result in `self.supports_block_receipts` so that the next time this function is called, we don't
+        // need to check again.
+        let mut supports_block_receipts = self.supports_block_receipts.write().await;
+        if supports_block_receipts.is_none() {
+            *supports_block_receipts = Some(result);
+        }
+
+        result
+    }
+
+    /// Alloy-exclusive version of logs_with_sigs using alloy types and methods
     async fn logs_with_sigs(
         &self,
-        logger: Logger,
+        logger: ProviderLogger,
         subgraph_metrics: Arc<SubgraphEthRpcMetrics>,
         from: BlockNumber,
         to: BlockNumber,
         filter: Arc<EthGetLogsFilter>,
         too_many_logs_fingerprints: &'static [&'static str],
-    ) -> Result<Vec<Log>, TimeoutError<web3::error::Error>> {
+    ) -> Result<
+        Vec<alloy::rpc::types::Log>,
+        TimeoutError<RpcError<alloy::transports::TransportErrorKind>>,
+    > {
         assert!(!self.call_only);
 
         let eth_adapter = self.clone();
         let retry_log_message = format!("eth_getLogs RPC call for block range: [{}..{}]", from, to);
         retry(retry_log_message, &logger)
-            .when(move |res: &Result<_, web3::error::Error>| match res {
-                Ok(_) => false,
-                Err(e) => !too_many_logs_fingerprints
-                    .iter()
-                    .any(|f| e.to_string().contains(f)),
-            })
-            .limit(ENV_VARS.request_retries)
-            .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
+            .redact_log_urls(true)
+            .when(
+                move |res: &Result<_, RpcError<alloy::transports::TransportErrorKind>>| match res {
+                    Ok(_) => false,
+                    Err(e) => !too_many_logs_fingerprints
+                        .iter()
+                        .any(|f| e.to_string().contains(f)),
+                },
+            )
+            .limit(self.settings.request_retries)
+            .timeout_secs(self.settings.json_rpc_timeout.as_secs())
             .run(move || {
                 let eth_adapter = eth_adapter.cheap_clone();
                 let subgraph_metrics = subgraph_metrics.clone();
@@ -241,16 +426,9 @@ impl EthereumAdapter {
                 async move {
                     let start = Instant::now();
 
-                    // Create a log filter
-                    let log_filter: Filter = FilterBuilder::default()
-                        .from_block(from.into())
-                        .to_block(to.into())
-                        .address(filter.contracts.clone())
-                        .topics(Some(filter.event_signatures.clone()), None, None, None)
-                        .build();
+                    let alloy_filter = filter.to_alloy_filter(from, to);
 
-                    // Request logs from client
-                    let result = eth_adapter.web3.eth().logs(log_filter).boxed().await;
+                    let result = eth_adapter.alloy.get_logs(&alloy_filter).await;
                     let elapsed = start.elapsed().as_secs_f64();
                     provider_metrics.observe_request(elapsed, "eth_getLogs", &provider);
                     subgraph_metrics.observe_request(elapsed, "eth_getLogs", &provider);
@@ -266,12 +444,12 @@ impl EthereumAdapter {
 
     fn trace_stream(
         self,
-        logger: &Logger,
+        logger: ProviderLogger,
         subgraph_metrics: Arc<SubgraphEthRpcMetrics>,
         from: BlockNumber,
         to: BlockNumber,
-        addresses: Vec<H160>,
-    ) -> impl Stream<Item = Trace, Error = Error> + Send {
+        addresses: Vec<Address>,
+    ) -> impl futures03::Stream<Item = Result<LocalizedTransactionTrace, Error>> + Send {
         if from > to {
             panic!(
                 "Can not produce a call stream on a backwards block range: from = {}, to = {}",
@@ -285,52 +463,57 @@ impl EthereumAdapter {
             true => 1,
         };
 
-        let eth = self;
-        let logger = logger.clone();
-        stream::unfold(from, move |start| {
-            if start > to {
-                return None;
+        let ranges: Vec<(BlockNumber, BlockNumber)> = {
+            let mut ranges = Vec::new();
+            let mut start = from;
+            while start <= to {
+                let end = (start + step_size - 1).min(to);
+                ranges.push((start, end));
+                start = end + 1;
             }
-            let end = (start + step_size - 1).min(to);
-            let new_start = end + 1;
-            if start == end {
-                debug!(logger, "Requesting traces for block {}", start);
-            } else {
-                debug!(logger, "Requesting traces for blocks [{}, {}]", start, end);
+            ranges
+        };
+
+        let block_batch_size = self.settings.block_batch_size;
+        let eth = self;
+
+        futures03::stream::iter(ranges.into_iter().map(move |(start, end)| {
+            let eth = eth.clone();
+            let logger = logger.clone();
+            let subgraph_metrics = subgraph_metrics.clone();
+            let addresses = addresses.clone();
+
+            async move {
+                if start == end {
+                    debug!(logger, "Requesting traces for block {}", start);
+                } else {
+                    debug!(logger, "Requesting traces for blocks [{}, {}]", start, end);
+                }
+
+                eth.traces(logger, subgraph_metrics, start, end, addresses)
+                    .await
             }
-            Some(futures::future::ok((
-                eth.clone()
-                    .traces(
-                        logger.cheap_clone(),
-                        subgraph_metrics.clone(),
-                        start,
-                        end,
-                        addresses.clone(),
-                    )
-                    .boxed()
-                    .compat(),
-                new_start,
-            )))
-        })
-        .buffered(ENV_VARS.block_batch_size)
-        .map(stream::iter_ok)
-        .flatten()
+        }))
+        .buffered(block_batch_size)
+        .map_ok(|traces| futures03::stream::iter(traces.into_iter().map(Ok)))
+        .try_flatten()
     }
 
     fn log_stream(
         &self,
-        logger: Logger,
+        logger: ProviderLogger,
         subgraph_metrics: Arc<SubgraphEthRpcMetrics>,
         from: BlockNumber,
         to: BlockNumber,
         filter: EthGetLogsFilter,
-    ) -> DynTryFuture<'static, Vec<Log>, Error> {
+    ) -> DynTryFuture<'static, Vec<alloy::rpc::types::Log>, Error> {
         // Codes returned by Ethereum node providers if an eth_getLogs request is too heavy.
-        // The first one is for Infura when it hits the log limit, the rest for Alchemy timeouts.
         const TOO_MANY_LOGS_FINGERPRINTS: &[&str] = &[
-            "ServerError(-32005)",
-            "503 Service Unavailable",
-            "ServerError(-32000)",
+            "ServerError(-32005)",       // Infura
+            "503 Service Unavailable",   // Alchemy
+            "ServerError(-32000)",       // Alchemy
+            "Try with this block range", // zKSync era
+            "block range too large",     // Monad
         ];
 
         if from > to {
@@ -347,7 +530,7 @@ impl EthereumAdapter {
         let step = match filter.contracts.is_empty() {
             // `to - from + 1`  blocks will be scanned.
             false => to - from,
-            true => (to - from).min(ENV_VARS.max_event_only_range - 1),
+            true => (to - from).min(self.settings.max_event_only_range - 1),
         };
 
         // Typically this will loop only once and fetch the entire range in one request. But if the
@@ -410,194 +593,257 @@ impl EthereumAdapter {
         .boxed()
     }
 
-    fn call(
+    fn block_ptr_to_id(&self, block_ptr: &BlockPtr) -> alloy::rpc::types::BlockId {
+        if !self.supports_eip_1898 {
+            alloy::rpc::types::BlockId::number(block_ptr.number as u64)
+        } else {
+            alloy::rpc::types::BlockId::hash(block_ptr.hash.as_b256())
+        }
+    }
+
+    async fn code(
         &self,
-        logger: Logger,
-        contract_address: Address,
-        call_data: Bytes,
+        logger: ProviderLogger,
+        address: Address,
         block_ptr: BlockPtr,
-        gas: Option<u32>,
-    ) -> impl Future<Item = Bytes, Error = EthereumContractCallError> + Send {
-        let web3 = self.web3.clone();
-        let logger = Logger::new(&logger, o!("provider" => self.provider.clone()));
-
-        // Ganache does not support calls by block hash.
-        // See https://github.com/trufflesuite/ganache-cli/issues/973
-        let block_id = if !self.supports_eip_1898 {
-            BlockId::Number(block_ptr.number.into())
-        } else {
-            BlockId::Hash(block_ptr.hash_as_h256())
-        };
-        let retry_log_message = format!("eth_call RPC call for block {}", block_ptr);
+    ) -> Result<alloy::primitives::Bytes, EthereumRpcError> {
+        let alloy = self.alloy.clone();
+
+        let block_id = self.block_ptr_to_id(&block_ptr);
+        let retry_log_message = format!("eth_getCode RPC call for block {}", block_ptr);
+
         retry(retry_log_message, &logger)
-            .when(|result| match result {
-                Ok(_) | Err(EthereumContractCallError::Revert(_)) => false,
-                Err(_) => true,
-            })
-            .limit(ENV_VARS.request_retries)
-            .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
+            .redact_log_urls(true)
+            .when(|result| result.is_err())
+            .limit(self.settings.request_retries)
+            .timeout_secs(self.settings.json_rpc_timeout.as_secs())
             .run(move || {
-                let call_data = call_data.clone();
-                let web3 = web3.cheap_clone();
+                let alloy = alloy.cheap_clone();
                 async move {
-                    let req = CallRequest {
-                        to: Some(contract_address),
-                        gas: gas.map(|val| web3::types::U256::from(val)),
-                        data: Some(call_data.clone()),
-                        from: None,
-                        gas_price: None,
-                        value: None,
-                        access_list: None,
-                        max_fee_per_gas: None,
-                        max_priority_fee_per_gas: None,
-                        transaction_type: None,
-                    };
-                    let result = web3.eth().call(req, Some(block_id)).boxed().await;
-
-                    // Try to check if the call was reverted. The JSON-RPC response for reverts is
-                    // not standardized, so we have ad-hoc checks for each Ethereum client.
-
-                    // 0xfe is the "designated bad instruction" of the EVM, and Solidity uses it for
-                    // asserts.
-                    const PARITY_BAD_INSTRUCTION_FE: &str = "Bad instruction fe";
-
-                    // 0xfd is REVERT, but on some contracts, and only on older blocks,
-                    // this happens. Makes sense to consider it a revert as well.
-                    const PARITY_BAD_INSTRUCTION_FD: &str = "Bad instruction fd";
-
-                    const PARITY_BAD_JUMP_PREFIX: &str = "Bad jump";
-                    const PARITY_STACK_LIMIT_PREFIX: &str = "Out of stack";
-
-                    // See f0af4ab0-6b7c-4b68-9141-5b79346a5f61.
-                    const PARITY_OUT_OF_GAS: &str = "Out of gas";
-
-                    const PARITY_VM_EXECUTION_ERROR: i64 = -32015;
-                    const PARITY_REVERT_PREFIX: &str = "Reverted 0x";
-                    const XDAI_REVERT: &str = "revert";
-
-                    // Deterministic Geth execution errors. We might need to expand this as
-                    // subgraphs come across other errors. See
-                    // https://github.com/ethereum/go-ethereum/blob/cd57d5cd38ef692de8fbedaa56598b4e9fbfbabc/core/vm/errors.go
-                    const GETH_EXECUTION_ERRORS: &[&str] = &[
-                        // The "revert" substring covers a few known error messages, including:
-                        // Hardhat: "error: transaction reverted",
-                        // Ganache and Moonbeam: "vm exception while processing transaction: revert",
-                        // Geth: "execution reverted"
-                        // And others.
-                        "revert",
-                        "invalid jump destination",
-                        "invalid opcode",
-                        // Ethereum says 1024 is the stack sizes limit, so this is deterministic.
-                        "stack limit reached 1024",
-                        // See f0af4ab0-6b7c-4b68-9141-5b79346a5f61 for why the gas limit is considered deterministic.
-                        "out of gas",
-                        "stack underflow",
-                    ];
-
-                    let env_geth_call_errors = ENV_VARS.geth_eth_call_errors.iter();
-                    let mut geth_execution_errors = GETH_EXECUTION_ERRORS
-                        .iter()
-                        .copied()
-                        .chain(env_geth_call_errors.map(|s| s.as_str()));
-
-                    let as_solidity_revert_with_reason = |bytes: &[u8]| {
-                        let solidity_revert_function_selector =
-                            &tiny_keccak::keccak256(b"Error(string)")[..4];
-
-                        match bytes.len() >= 4 && &bytes[..4] == solidity_revert_function_selector {
-                            false => None,
-                            true => ethabi::decode(&[ParamType::String], &bytes[4..])
-                                .ok()
-                                .and_then(|tokens| tokens[0].clone().into_string()),
-                        }
-                    };
+                    let result = alloy.get_code_at(address).block_id(block_id).await;
+                    match result {
+                        Ok(code) => Ok(code),
+                        Err(err) => Err(EthereumRpcError::AlloyError(err)),
+                    }
+                }
+            })
+            .await
+            .map_err(|e| e.into_inner().unwrap_or(EthereumRpcError::Timeout))
+    }
+
+    async fn balance(
+        &self,
+        logger: ProviderLogger,
+        address: Address,
+        block_ptr: BlockPtr,
+    ) -> Result<alloy::primitives::U256, EthereumRpcError> {
+        let alloy = self.alloy.clone();
 
+        let block_id = self.block_ptr_to_id(&block_ptr);
+        let retry_log_message = format!("eth_getBalance RPC call for block {}", block_ptr);
+
+        retry(retry_log_message, &logger)
+            .redact_log_urls(true)
+            .when(|result| result.is_err())
+            .limit(self.settings.request_retries)
+            .timeout_secs(self.settings.json_rpc_timeout.as_secs())
+            .run(move || {
+                let alloy = alloy.cheap_clone();
+                async move {
+                    let result = alloy.get_balance(address).block_id(block_id).await;
                     match result {
-                        // A successful response.
-                        Ok(bytes) => Ok(bytes),
+                        Ok(balance) => Ok(balance),
+                        Err(err) => Err(EthereumRpcError::AlloyError(err)),
+                    }
+                }
+            })
+            .await
+            .map_err(|e| e.into_inner().unwrap_or(EthereumRpcError::Timeout))
+    }
 
-                        // Check for Geth revert.
-                        Err(web3::Error::Rpc(rpc_error))
-                            if geth_execution_errors
-                                .any(|e| rpc_error.message.to_lowercase().contains(e)) =>
-                        {
-                            Err(EthereumContractCallError::Revert(rpc_error.message))
-                        }
+    async fn call(
+        &self,
+        logger: ProviderLogger,
+        call_data: call::Request,
+        block_ptr: BlockPtr,
+        gas: Option<u32>,
+    ) -> Result<call::Retval, ContractCallError> {
+        let alloy = self.alloy.clone();
 
-                        // Check for Parity revert.
-                        Err(web3::Error::Rpc(ref rpc_error))
-                            if rpc_error.code.code() == PARITY_VM_EXECUTION_ERROR =>
-                        {
-                            match rpc_error.data.as_ref().and_then(|d| d.as_str()) {
-                                Some(data)
-                                    if data.starts_with(PARITY_REVERT_PREFIX)
-                                        || data.starts_with(PARITY_BAD_JUMP_PREFIX)
-                                        || data.starts_with(PARITY_STACK_LIMIT_PREFIX)
-                                        || data == PARITY_BAD_INSTRUCTION_FE
-                                        || data == PARITY_BAD_INSTRUCTION_FD
-                                        || data == PARITY_OUT_OF_GAS
-                                        || data == XDAI_REVERT =>
-                                {
-                                    let reason = if data == PARITY_BAD_INSTRUCTION_FE {
-                                        PARITY_BAD_INSTRUCTION_FE.to_owned()
-                                    } else {
-                                        let payload = data.trim_start_matches(PARITY_REVERT_PREFIX);
-                                        hex::decode(payload)
-                                            .ok()
-                                            .and_then(|payload| {
-                                                as_solidity_revert_with_reason(&payload)
-                                            })
-                                            .unwrap_or("no reason".to_owned())
-                                    };
-                                    Err(EthereumContractCallError::Revert(reason))
-                                }
+        let alloy_block_id = self.block_ptr_to_id(&block_ptr);
+        let retry_log_message = format!("eth_call RPC call for block {}", block_ptr);
+        retry(retry_log_message, &logger)
+            .redact_log_urls(true)
+            .limit(self.settings.request_retries)
+            .timeout_secs(self.settings.json_rpc_timeout.as_secs())
+            .run(move || {
+                let call_data = call_data.clone();
+                let alloy = alloy.cheap_clone();
+                let logger = logger.cheap_clone();
+                async move {
+                    let mut req = TransactionRequest::default()
+                        .input(TransactionInput::both(alloy::primitives::Bytes::from(
+                            call_data.encoded_call.to_vec(),
+                        )))
+                        .to(call_data.address);
 
-                                // The VM execution error was not identified as a revert.
-                                _ => Err(EthereumContractCallError::Web3Error(web3::Error::Rpc(
-                                    rpc_error.clone(),
-                                ))),
-                            }
-                        }
+                    if let Some(gas) = gas {
+                        req = req.gas_limit(gas as u64);
+                    }
 
-                        // The error was not identified as a revert.
-                        Err(err) => Err(EthereumContractCallError::Web3Error(err)),
+                    let result = alloy.call(req.into()).block(alloy_block_id).await;
+
+                    match result {
+                        Ok(bytes) => Ok(call::Retval::Value(scalar::Bytes::from(bytes))),
+                        Err(err) => interpret_eth_call_error(&logger, err),
                     }
                 }
             })
-            .map_err(|e| e.into_inner().unwrap_or(EthereumContractCallError::Timeout))
-            .boxed()
-            .compat()
+            .await
+            .map_err(|e| e.into_inner().unwrap_or(ContractCallError::Timeout))
     }
 
+    async fn call_and_cache(
+        &self,
+        logger: &ProviderLogger,
+        call: &ContractCall,
+        req: call::Request,
+        cache: Arc<dyn EthereumCallCache>,
+    ) -> Result<call::Response, ContractCallError> {
+        let result = self
+            .call(
+                logger.clone(),
+                req.cheap_clone(),
+                call.block_ptr.clone(),
+                call.gas,
+            )
+            .await?;
+        if let Err(e) = cache
+            .set_call(
+                logger,
+                req.cheap_clone(),
+                call.block_ptr.cheap_clone(),
+                result.clone(),
+            )
+            .await
+        {
+            error!(logger, "EthereumAdapter: call cache set error";
+                        "contract_address" => format!("{:?}", req.address),
+                        "error" => e.to_string());
+        }
+
+        Ok(req.response(result, call::Source::Rpc))
+    }
     /// Request blocks by hash through JSON-RPC.
     fn load_blocks_rpc(
         &self,
         logger: Logger,
-        ids: Vec<H256>,
-    ) -> impl Stream<Item = Arc<LightEthereumBlock>, Error = Error> + Send {
-        let web3 = self.web3.clone();
-
-        stream::iter_ok::<_, Error>(ids.into_iter().map(move |hash| {
-            let web3 = web3.clone();
-            retry(format!("load block {}", hash), &logger)
-                .limit(ENV_VARS.request_retries)
-                .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
-                .run(move || {
-                    Box::pin(web3.eth().block_with_txs(BlockId::Hash(hash)))
-                        .compat()
-                        .from_err::<Error>()
-                        .and_then(move |block| {
-                            block.map(Arc::new).ok_or_else(|| {
-                                anyhow::anyhow!("Ethereum node did not find block {:?}", hash)
-                            })
+        ids: Vec<B256>,
+    ) -> impl futures03::Stream<Item = Result<Arc<LightEthereumBlock>, Error>> + Send {
+        let alloy = self.alloy.clone();
+        let request_retries = self.settings.request_retries;
+        let json_rpc_timeout_secs = self.settings.json_rpc_timeout.as_secs();
+
+        futures03::stream::iter(ids.into_iter().map(move |hash| {
+            let alloy = alloy.clone();
+            let logger = logger.clone();
+
+            async move {
+                retry(format!("load block {}", hash), &logger)
+                    .redact_log_urls(true)
+                    .limit(request_retries)
+                    .timeout_secs(json_rpc_timeout_secs)
+                    .run(move || {
+                        let alloy = alloy.cheap_clone();
+                        async move {
+                            alloy
+                                .get_block_by_hash(hash)
+                                .full()
+                                .await
+                                .map_err(Error::from)
+                                .and_then(|block| {
+                                    block
+                                        .map(|b| Arc::new(LightEthereumBlock::new(b)))
+                                        .ok_or_else(|| {
+                                            anyhow::anyhow!(
+                                                "Ethereum node did not find block {:?}",
+                                                hash
+                                            )
+                                        })
+                                })
+                        }
+                    })
+                    .await
+                    .map_err(|e| {
+                        e.into_inner().unwrap_or_else(|| {
+                            anyhow::anyhow!("Ethereum node took too long to return block {}", hash)
                         })
-                        .compat()
-                })
-                .boxed()
-                .compat()
-                .from_err()
+                    })
+            }
         }))
-        .buffered(ENV_VARS.block_batch_size)
+        .buffered(self.settings.block_batch_size)
+    }
+
+    /// Request blocks by number through JSON-RPC.
+    pub fn load_block_ptrs_by_numbers_rpc(
+        &self,
+        logger: Logger,
+        numbers: Vec<BlockNumber>,
+    ) -> impl futures03::Stream<Item = Result<Arc<ExtendedBlockPtr>, Error>> + Send {
+        let alloy = self.alloy.clone();
+        let request_retries = self.settings.request_retries;
+        let json_rpc_timeout_secs = self.settings.json_rpc_timeout.as_secs();
+
+        futures03::stream::iter(numbers.into_iter().map(move |number| {
+            let alloy = alloy.clone();
+            let logger = logger.clone();
+
+            async move {
+                retry(format!("load block {}", number), &logger)
+                    .redact_log_urls(true)
+                    .limit(request_retries)
+                    .timeout_secs(json_rpc_timeout_secs)
+                    .run(move || {
+                        let alloy = alloy.cheap_clone();
+
+                        async move {
+                            let block_result = alloy
+                                .get_block_by_number(alloy::rpc::types::BlockNumberOrTag::Number(
+                                    number as u64,
+                                ))
+                                .await;
+
+                            match block_result {
+                                Ok(Some(block)) => {
+                                    let ptr = ExtendedBlockPtr::try_from((
+                                        block.header.hash,
+                                        i32::try_from(block.header.number).unwrap(),
+                                        block.header.parent_hash,
+                                        block.header.timestamp,
+                                    ))
+                                    .map_err(|e| {
+                                        anyhow::anyhow!("Failed to convert block: {}", e)
+                                    })?;
+                                    Ok(Arc::new(ptr))
+                                }
+                                Ok(None) => Err(anyhow::anyhow!(
+                                    "Ethereum node did not find block with number {:?}",
+                                    number
+                                )),
+                                Err(e) => Err(anyhow::anyhow!("Failed to fetch block: {}", e)),
+                            }
+                        }
+                    })
+                    .await
+                    .map_err(|e| match e {
+                        TimeoutError::Elapsed => {
+                            anyhow::anyhow!("Timeout while fetching block {}", number)
+                        }
+                        TimeoutError::Inner(e) => e,
+                    })
+            }
+        }))
+        .buffered(self.settings.block_ptr_batch_size)
     }
 
     /// Request blocks ptrs for numbers through JSON-RPC.
@@ -608,20 +854,23 @@ impl EthereumAdapter {
         logger: Logger,
         block_nums: Vec<BlockNumber>,
     ) -> impl Stream<Item = BlockPtr, Error = Error> + Send {
-        let web3 = self.web3.clone();
+        let alloy = self.alloy.clone();
+        let json_rpc_timeout_secs = self.settings.json_rpc_timeout.as_secs();
 
         stream::iter_ok::<_, Error>(block_nums.into_iter().map(move |block_num| {
-            let web3 = web3.clone();
+            let alloy = alloy.clone();
             retry(format!("load block ptr {}", block_num), &logger)
+                .redact_log_urls(true)
+                .when(|res| !res.is_ok() && !detect_null_block(res))
                 .no_limit()
-                .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
+                .timeout_secs(json_rpc_timeout_secs)
                 .run(move || {
-                    let web3 = web3.clone();
+                    let alloy = alloy.cheap_clone();
                     async move {
-                        let block = web3
-                            .eth()
-                            .block(BlockId::Number(Web3BlockNumber::Number(block_num.into())))
-                            .boxed()
+                        let block = alloy
+                            .get_block_by_number(alloy::rpc::types::BlockNumberOrTag::Number(
+                                block_num as u64,
+                            ))
                             .await?;
 
                         block.ok_or_else(|| {
@@ -632,9 +881,17 @@ impl EthereumAdapter {
                 .boxed()
                 .compat()
                 .from_err()
+                .then(|res| {
+                    if detect_null_block(&res) {
+                        Ok(None)
+                    } else {
+                        Some(res).transpose()
+                    }
+                })
         }))
-        .buffered(ENV_VARS.block_batch_size)
-        .map(|b| b.into())
+        .buffered(self.settings.block_batch_size)
+        .filter_map(|b| b)
+        .map(|b| BlockPtr::from((b.header.hash, b.header.number)))
     }
 
     /// Check if `block_ptr` refers to a block that is on the main chain, according to the Ethereum
@@ -652,13 +909,12 @@ impl EthereumAdapter {
         logger: &Logger,
         block_ptr: BlockPtr,
     ) -> Result<bool, Error> {
-        let block_hash = self
-            .block_hash_by_block_number(logger, block_ptr.number)
-            .compat()
+        // TODO: This considers null blocks, but we could instead bail if we encounter one as a
+        // small optimization.
+        let canonical_block = self
+            .next_existing_ptr_to_number(logger, block_ptr.number)
             .await?;
-        block_hash
-            .ok_or_else(|| anyhow!("Ethereum node is missing block #{}", block_ptr.number))
-            .map(|block_hash| block_hash == block_ptr.hash_as_h256())
+        Ok(canonical_block == block_ptr)
     }
 
     pub(crate) fn logs_in_block_range(
@@ -668,21 +924,26 @@ impl EthereumAdapter {
         from: BlockNumber,
         to: BlockNumber,
         log_filter: EthereumLogFilter,
-    ) -> DynTryFuture<'static, Vec<Log>, Error> {
+    ) -> DynTryFuture<'static, Vec<alloy::rpc::types::Log>, Error> {
         let eth: Self = self.cheap_clone();
-        let logger = logger.clone();
-
-        futures03::stream::iter(log_filter.eth_get_logs_filters().map(move |filter| {
-            eth.cheap_clone().log_stream(
-                logger.cheap_clone(),
-                subgraph_metrics.cheap_clone(),
-                from,
-                to,
-                filter,
-            )
-        }))
+        let logger = self.provider_logger(logger);
+
+        let max_contracts = eth.settings.get_logs_max_contracts;
+        futures03::stream::iter(
+            log_filter
+                .eth_get_logs_filters(max_contracts)
+                .map(move |filter| {
+                    eth.cheap_clone().log_stream(
+                        logger.cheap_clone(),
+                        subgraph_metrics.cheap_clone(),
+                        from,
+                        to,
+                        filter,
+                    )
+                }),
+        )
         // Real limits on the number of parallel requests are imposed within the adapter.
-        .buffered(ENV_VARS.block_ingestor_max_concurrent_json_rpc_calls)
+        .buffered(self.settings.block_ingestor_max_concurrent_json_rpc_calls)
         .try_concat()
         .boxed()
     }
@@ -696,19 +957,20 @@ impl EthereumAdapter {
         call_filter: &'a EthereumCallFilter,
     ) -> Box<dyn Stream<Item = EthereumCall, Error = Error> + Send + 'a> {
         let eth = self.clone();
+        let logger = self.provider_logger(logger);
 
         let EthereumCallFilter {
             contract_addresses_function_signatures,
             wildcard_signatures,
         } = call_filter;
 
-        let mut addresses: Vec<H160> = contract_addresses_function_signatures
+        let mut addresses: Vec<Address> = contract_addresses_function_signatures
             .iter()
             .filter(|(_addr, (start_block, _fsigs))| start_block <= &to)
             .map(|(addr, (_start_block, _fsigs))| *addr)
-            .collect::<HashSet<H160>>()
+            .collect::<HashSet<Address>>()
             .into_iter()
-            .collect::<Vec<H160>>();
+            .collect::<Vec<Address>>();
 
         if addresses.is_empty() && wildcard_signatures.is_empty() {
             // The filter has no started data sources in the requested range, nothing to do.
@@ -725,14 +987,13 @@ impl EthereumAdapter {
 
         Box::new(
             eth.trace_stream(logger, subgraph_metrics, from, to, addresses)
-                .filter_map(|trace| EthereumCall::try_from_trace(&trace))
-                .filter(move |call| {
-                    // `trace_filter` can only filter by calls `to` an address and
-                    // a block range. Since subgraphs are subscribing to calls
-                    // for a specific contract function an additional filter needs
-                    // to be applied
-                    call_filter.matches(call)
-                }),
+                .try_filter_map(move |trace| {
+                    let maybe_call = EthereumCall::try_from_trace(&trace)
+                        .filter(|call| call_filter.matches(call));
+                    futures03::future::ready(Ok(maybe_call))
+                })
+                .boxed()
+                .compat(),
         )
     }
 
@@ -751,54 +1012,38 @@ impl EthereumAdapter {
     ) -> Pin<
         Box<
             dyn std::future::Future<Output = Result<Vec<EthereumTrigger>, anyhow::Error>>
-                + std::marker::Send,
+                + std::marker::Send
+                + '_,
         >,
     > {
-        // Create a HashMap of block numbers to Vec<EthereumBlockTriggerType>
+        // Create a HashMap of block numbers to Vec<EthereumBlockTriggerType>.
         let matching_blocks = (from..=to)
             .filter_map(|block_number| {
-                filter
-                    .polling_intervals
-                    .iter()
-                    .find_map(|(start_block, interval)| {
-                        let has_once_trigger = (*interval == 0) && (block_number == *start_block);
-                        let has_polling_trigger = block_number >= *start_block
-                            && *interval > 0
-                            && ((block_number - start_block) % *interval) == 0;
-
-                        if has_once_trigger || has_polling_trigger {
-                            let mut triggers = Vec::new();
-                            if has_once_trigger {
-                                triggers.push(EthereumBlockTriggerType::Start);
-                            }
-                            if has_polling_trigger {
-                                triggers.push(EthereumBlockTriggerType::End);
-                            }
-                            Some((block_number, triggers))
-                        } else {
-                            None
-                        }
-                    })
+                let triggers =
+                    block_trigger_types_from_intervals(block_number, &filter.polling_intervals);
+                if triggers.is_empty() {
+                    None
+                } else {
+                    Some((block_number, triggers))
+                }
             })
             .collect::<HashMap<_, _>>();
 
         let blocks_matching_polling_filter = self.load_ptrs_for_blocks(
             logger.clone(),
-            matching_blocks.iter().map(|(k, _)| *k).collect_vec(),
+            matching_blocks.keys().cloned().collect_vec(),
         );
 
         let block_futures = blocks_matching_polling_filter.map(move |ptrs| {
             ptrs.into_iter()
                 .flat_map(|ptr| {
-                    let triggers = matching_blocks
+                    matching_blocks
                         .get(&ptr.number)
                         // Safe to unwrap since we are iterating over ptrs which was created from
                         // the keys of matching_blocks
                         .unwrap()
                         .iter()
-                        .map(move |trigger| EthereumTrigger::Block(ptr.clone(), trigger.clone()));
-
-                    triggers
+                        .map(move |trigger| EthereumTrigger::Block(ptr.clone(), trigger.clone()))
                 })
                 .collect::<Vec<_>>()
         });
@@ -811,11 +1056,12 @@ impl EthereumAdapter {
         logger: &Logger,
         subgraph_metrics: Arc<SubgraphEthRpcMetrics>,
         block_number: BlockNumber,
-        block_hash: H256,
+        block_hash: alloy::primitives::B256,
     ) -> Result<Vec<EthereumCall>, Error> {
         let eth = self.clone();
+        let logger = self.provider_logger(logger);
         let addresses = Vec::new();
-        let traces = eth
+        let traces: Vec<LocalizedTransactionTrace> = eth
             .trace_stream(
                 logger,
                 subgraph_metrics.clone(),
@@ -823,8 +1069,7 @@ impl EthereumAdapter {
                 block_number,
                 addresses,
             )
-            .collect()
-            .compat()
+            .try_collect()
             .await?;
 
         // `trace_stream` returns all of the traces for the block, and this
@@ -842,7 +1087,7 @@ impl EthereumAdapter {
         // all the traces for the block, we need to ensure that the
         // block hash for the traces is equal to the desired block hash.
         // Assume all traces are for the same block.
-        if traces.iter().nth(0).unwrap().block_hash != block_hash {
+        if traces.first().unwrap().block_hash != Some(block_hash) {
             return Err(anyhow!(
                 "Trace stream returned traces for an unexpected block: \
                          number = `{}`, hash = `{}`",
@@ -863,7 +1108,7 @@ impl EthereumAdapter {
         logger: Logger,
         from: BlockNumber,
         to: BlockNumber,
-    ) -> Box<dyn Future<Item = Vec<BlockPtr>, Error = Error> + Send> {
+    ) -> Box<dyn Future<Item = Vec<BlockPtr>, Error = Error> + Send + '_> {
         // Currently we can't go to the DB for this because there might be duplicate entries for
         // the same block number.
         debug!(&logger, "Requesting hashes for blocks [{}, {}]", from, to);
@@ -877,7 +1122,7 @@ impl EthereumAdapter {
         &self,
         logger: Logger,
         blocks: Vec<BlockNumber>,
-    ) -> Box<dyn Future<Item = Vec<BlockPtr>, Error = Error> + Send> {
+    ) -> Box<dyn Future<Item = Vec<BlockPtr>, Error = Error> + Send + '_> {
         // Currently we can't go to the DB for this because there might be duplicate entries for
         // the same block number.
         debug!(&logger, "Requesting hashes for blocks {:?}", blocks);
@@ -886,18 +1131,27 @@ impl EthereumAdapter {
 
     pub async fn chain_id(&self) -> Result<u64, Error> {
         let logger = self.logger.clone();
-        let web3 = self.web3.clone();
-        u64::try_from(
-            retry("chain_id RPC call", &logger)
-                .no_limit()
-                .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
-                .run(move || {
-                    let web3 = web3.cheap_clone();
-                    async move { web3.eth().chain_id().await }
-                })
-                .await?,
-        )
-        .map_err(Error::msg)
+        let alloy = self.alloy.clone();
+        retry("chain_id RPC call", &logger)
+            .redact_log_urls(true)
+            .no_limit()
+            .timeout_secs(self.settings.json_rpc_timeout.as_secs())
+            .run(move || {
+                let alloy = alloy.cheap_clone();
+                async move { alloy.get_chain_id().await.map_err(Error::from) }
+            })
+            .await
+            .map_err(|e| e.into_inner().unwrap_or(EthereumRpcError::Timeout.into()))
+    }
+}
+
+// Detects null blocks as can occur on Filecoin EVM chains, by checking for the FEVM-specific
+// error returned when requesting such a null round. Ideally there should be a defined reponse or
+// message for this case, or a check that is less dependent on the Filecoin implementation.
+fn detect_null_block<T>(res: &Result<T, Error>) -> bool {
+    match res {
+        Ok(_) => false,
+        Err(e) => e.to_string().contains("requested epoch was a null round"),
     }
 }
 
@@ -910,18 +1164,19 @@ impl EthereumAdapterTrait for EthereumAdapter {
     async fn net_identifiers(&self) -> Result<ChainIdentifier, Error> {
         let logger = self.logger.clone();
 
-        let web3 = self.web3.clone();
+        let alloy = self.alloy.clone();
         let metrics = self.metrics.clone();
         let provider = self.provider().to_string();
         let net_version_future = retry("net_version RPC call", &logger)
+            .redact_log_urls(true)
             .no_limit()
             .timeout_secs(20)
             .run(move || {
-                let web3 = web3.cheap_clone();
+                let alloy = alloy.cheap_clone();
                 let metrics = metrics.cheap_clone();
                 let provider = provider.clone();
                 async move {
-                    web3.net().version().await.map_err(|e| {
+                    alloy.get_net_version().await.map_err(|e| {
                         metrics.set_status(ProviderStatus::VersionFail, &provider);
                         e.into()
                     })
@@ -934,31 +1189,32 @@ impl EthereumAdapterTrait for EthereumAdapter {
             })
             .boxed();
 
-        let web3 = self.web3.clone();
+        let alloy_provider = self.alloy.clone();
         let metrics = self.metrics.clone();
         let provider = self.provider().to_string();
+        let genesis_block_number = self.settings.genesis_block_number;
         let retry_log_message = format!(
             "eth_getBlockByNumber({}, false) RPC call",
-            ENV_VARS.genesis_block_number
+            genesis_block_number
         );
         let gen_block_hash_future = retry(retry_log_message, &logger)
+            .redact_log_urls(true)
             .no_limit()
             .timeout_secs(30)
             .run(move || {
-                let web3 = web3.cheap_clone();
+                let alloy_genesis = alloy_provider.cheap_clone();
                 let metrics = metrics.cheap_clone();
                 let provider = provider.clone();
                 async move {
-                    web3.eth()
-                        .block(BlockId::Number(Web3BlockNumber::Number(
-                            ENV_VARS.genesis_block_number.into(),
-                        )))
+                    alloy_genesis
+                        .get_block_by_number(alloy::rpc::types::BlockNumberOrTag::Number(
+                            genesis_block_number,
+                        ))
                         .await
-                        .map_err(|e| {
+                        .inspect_err(|_| {
                             metrics.set_status(ProviderStatus::GenesisFail, &provider);
-                            e
                         })?
-                        .and_then(|gen_block| gen_block.hash.map(BlockHash::from))
+                        .map(|gen_block| BlockHash::from(gen_block.header.hash))
                         .ok_or_else(|| anyhow!("Ethereum node could not find genesis block"))
                 }
             })
@@ -977,7 +1233,7 @@ impl EthereumAdapterTrait for EthereumAdapter {
             })?;
 
         let ident = ChainIdentifier {
-            net_version,
+            net_version: net_version.to_string(),
             genesis_block_hash,
         };
 
@@ -986,362 +1242,412 @@ impl EthereumAdapterTrait for EthereumAdapter {
         Ok(ident)
     }
 
-    fn latest_block_header(
-        &self,
-        logger: &Logger,
-    ) -> Box<dyn Future<Item = web3::types::Block<H256>, Error = IngestorError> + Send> {
-        let web3 = self.web3.clone();
-        Box::new(
-            retry("eth_getBlockByNumber(latest) no txs RPC call", logger)
-                .no_limit()
-                .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
-                .run(move || {
-                    let web3 = web3.cheap_clone();
-                    async move {
-                        let block_opt = web3
-                            .eth()
-                            .block(Web3BlockNumber::Latest.into())
-                            .await
-                            .map_err(|e| {
-                                anyhow!("could not get latest block from Ethereum: {}", e)
-                            })?;
+    async fn latest_block_ptr(&self, logger: &Logger) -> Result<BlockPtr, IngestorError> {
+        let alloy = self.alloy.clone();
+        retry("eth_getBlockByNumber(latest) no txs RPC call", logger)
+            .redact_log_urls(true)
+            .limit(ENV_VARS.request_retries)
+            .timeout_secs(self.settings.json_rpc_timeout.as_secs())
+            .run(move || {
+                let alloy = alloy.cheap_clone();
+                async move {
+                    let block_opt = alloy
+                        .get_block_by_number(alloy::rpc::types::BlockNumberOrTag::Latest)
+                        .await
+                        .map_err(|e| anyhow!("could not get latest block from Ethereum: {}", e))?;
 
-                        block_opt
-                            .ok_or_else(|| anyhow!("no latest block returned from Ethereum").into())
-                    }
-                })
-                .map_err(move |e| {
-                    e.into_inner().unwrap_or_else(move || {
-                        anyhow!("Ethereum node took too long to return latest block").into()
-                    })
-                })
-                .boxed()
-                .compat(),
-        )
-    }
+                    let block = block_opt
+                        .ok_or_else(|| anyhow!("no latest block returned from Ethereum"))?;
 
-    fn latest_block(
-        &self,
-        logger: &Logger,
-    ) -> Box<dyn Future<Item = LightEthereumBlock, Error = IngestorError> + Send + Unpin> {
-        let web3 = self.web3.clone();
-        Box::new(
-            retry("eth_getBlockByNumber(latest) with txs RPC call", logger)
-                .no_limit()
-                .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
-                .run(move || {
-                    let web3 = web3.cheap_clone();
-                    async move {
-                        let block_opt = web3
-                            .eth()
-                            .block_with_txs(Web3BlockNumber::Latest.into())
-                            .await
-                            .map_err(|e| {
-                                anyhow!("could not get latest block from Ethereum: {}", e)
-                            })?;
-                        block_opt
-                            .ok_or_else(|| anyhow!("no latest block returned from Ethereum").into())
-                    }
-                })
-                .map_err(move |e| {
-                    e.into_inner().unwrap_or_else(move || {
-                        anyhow!("Ethereum node took too long to return latest block").into()
-                    })
+                    Ok(BlockPtr::from((block.header.hash, block.header.number)))
+                }
+            })
+            .map_err(move |e| {
+                e.into_inner().unwrap_or_else(move || {
+                    anyhow!("Ethereum node took too long to return latest block").into()
                 })
-                .boxed()
-                .compat(),
-        )
+            })
+            .await
     }
 
-    fn load_block(
-        &self,
-        logger: &Logger,
-        block_hash: H256,
-    ) -> Box<dyn Future<Item = LightEthereumBlock, Error = Error> + Send> {
-        Box::new(
-            self.block_by_hash(logger, block_hash)
-                .and_then(move |block_opt| {
-                    block_opt.ok_or_else(move || {
-                        anyhow!(
-                            "Ethereum node could not find block with hash {}",
-                            block_hash
-                        )
-                    })
-                }),
-        )
+    async fn is_reachable(&self) -> bool {
+        let alloy = self.alloy.clone();
+        tokio::time::timeout(Duration::from_secs(10), alloy.get_block_number())
+            .await
+            .map(|r| r.is_ok())
+            .unwrap_or(false)
     }
 
-    fn block_by_hash(
+    async fn block_by_hash(
         &self,
         logger: &Logger,
-        block_hash: H256,
-    ) -> Box<dyn Future<Item = Option<LightEthereumBlock>, Error = Error> + Send> {
-        let web3 = self.web3.clone();
+        block_hash: B256,
+    ) -> Result<Option<AnyBlock>, Error> {
+        let alloy = self.alloy.clone();
         let logger = logger.clone();
         let retry_log_message = format!(
             "eth_getBlockByHash RPC call for block hash {:?}",
             block_hash
         );
-        Box::new(
-            retry(retry_log_message, &logger)
-                .limit(ENV_VARS.request_retries)
-                .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
-                .run(move || {
-                    Box::pin(web3.eth().block_with_txs(BlockId::Hash(block_hash)))
-                        .compat()
-                        .from_err()
-                        .compat()
-                })
-                .map_err(move |e| {
-                    e.into_inner().unwrap_or_else(move || {
-                        anyhow!("Ethereum node took too long to return block {}", block_hash)
-                    })
+
+        retry(retry_log_message, &logger)
+            .redact_log_urls(true)
+            .limit(self.settings.request_retries)
+            .timeout_secs(self.settings.json_rpc_timeout.as_secs())
+            .run(move || {
+                let alloy = alloy.cheap_clone();
+                async move {
+                    alloy
+                        .get_block_by_hash(block_hash)
+                        .full()
+                        .await
+                        .map_err(Error::from)
+                }
+            })
+            .map_err(move |e| {
+                e.into_inner().unwrap_or_else(move || {
+                    anyhow!("Ethereum node took too long to return block {}", block_hash)
                 })
-                .boxed()
-                .compat(),
-        )
+            })
+            .await
     }
 
-    fn block_by_number(
+    async fn block_by_number(
         &self,
         logger: &Logger,
         block_number: BlockNumber,
-    ) -> Box<dyn Future<Item = Option<LightEthereumBlock>, Error = Error> + Send> {
-        let web3 = self.web3.clone();
+    ) -> Result<Option<AnyBlock>, Error> {
+        let alloy = self.alloy.clone();
         let logger = logger.clone();
         let retry_log_message = format!(
             "eth_getBlockByNumber RPC call for block number {}",
             block_number
         );
-        Box::new(
-            retry(retry_log_message, &logger)
-                .no_limit()
-                .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
-                .run(move || {
-                    let web3 = web3.cheap_clone();
-                    async move {
-                        web3.eth()
-                            .block_with_txs(BlockId::Number(block_number.into()))
-                            .await
-                            .map_err(Error::from)
-                    }
-                })
-                .map_err(move |e| {
-                    e.into_inner().unwrap_or_else(move || {
-                        anyhow!(
-                            "Ethereum node took too long to return block {}",
-                            block_number
-                        )
-                    })
+        retry(retry_log_message, &logger)
+            .redact_log_urls(true)
+            .no_limit()
+            .timeout_secs(self.settings.json_rpc_timeout.as_secs())
+            .run(move || {
+                let alloy = alloy.clone();
+                async move {
+                    alloy
+                        .get_block_by_number(alloy::rpc::types::BlockNumberOrTag::Number(
+                            block_number as u64,
+                        ))
+                        .full()
+                        .await
+                        .map_err(Error::from)
+                }
+            })
+            .map_err(move |e| {
+                e.into_inner().unwrap_or_else(move || {
+                    anyhow!(
+                        "Ethereum node took too long to return block {}",
+                        block_number
+                    )
                 })
-                .boxed()
-                .compat(),
-        )
+            })
+            .await
     }
 
-    fn load_full_block(
+    async fn load_full_block(
         &self,
         logger: &Logger,
-        block: LightEthereumBlock,
-    ) -> Pin<Box<dyn std::future::Future<Output = Result<EthereumBlock, IngestorError>> + Send>>
-    {
-        let web3 = Arc::clone(&self.web3);
-        let logger = logger.clone();
-        let block_hash = block.hash.expect("block is missing block hash");
+        block: AnyBlock,
+    ) -> Result<EthereumBlock, IngestorError> {
+        let alloy = self.alloy.clone();
+        let logger = self.provider_logger(logger);
+        let block_hash = block.header.hash;
 
         // The early return is necessary for correctness, otherwise we'll
         // request an empty batch which is not valid in JSON-RPC.
         if block.transactions.is_empty() {
             trace!(logger, "Block {} contains no transactions", block_hash);
-            return Box::pin(std::future::ready(Ok(EthereumBlock {
-                block: Arc::new(block),
+            return Ok(EthereumBlock {
+                block: Arc::new(LightEthereumBlock::new(block)),
                 transaction_receipts: Vec::new(),
-            })));
+            });
         }
-        let hashes: Vec<_> = block.transactions.iter().map(|txn| txn.hash).collect();
-        let receipts_future = if ENV_VARS.fetch_receipts_in_batches {
-            // Deprecated batching retrieval of transaction receipts.
-            fetch_transaction_receipts_in_batch_with_retry(web3, hashes, block_hash, logger).boxed()
-        } else {
-            let hash_stream = graph::tokio_stream::iter(hashes);
-            let receipt_stream = graph::tokio_stream::StreamExt::map(hash_stream, move |tx_hash| {
-                fetch_transaction_receipt_with_retry(
-                    web3.cheap_clone(),
-                    tx_hash,
-                    block_hash,
-                    logger.cheap_clone(),
-                )
-            })
-            .buffered(ENV_VARS.block_ingestor_max_concurrent_json_rpc_calls);
-            graph::tokio_stream::StreamExt::collect::<
-                Result<Vec<Arc<TransactionReceipt>>, IngestorError>,
-            >(receipt_stream)
-            .boxed()
-        };
+        let hashes: Vec<_> = block.transactions.hashes().collect();
 
-        let block_future =
-            futures03::TryFutureExt::map_ok(receipts_future, move |transaction_receipts| {
-                EthereumBlock {
-                    block: Arc::new(block),
-                    transaction_receipts,
-                }
-            });
+        let supports_block_receipts = self
+            .check_block_receipt_support_and_update_cache(
+                alloy.clone(),
+                block_hash,
+                self.supports_eip_1898,
+                self.call_only,
+                logger.clone(),
+            )
+            .await;
 
-        Box::pin(block_future)
+        fetch_receipts_with_retry(
+            alloy,
+            hashes,
+            block_hash,
+            logger,
+            supports_block_receipts,
+            &self.settings,
+        )
+        .await
+        .map(|transaction_receipts| EthereumBlock {
+            block: Arc::new(LightEthereumBlock::new(block)),
+            transaction_receipts,
+        })
     }
 
-    fn block_pointer_from_number(
+    async fn get_balance(
         &self,
         logger: &Logger,
-        block_number: BlockNumber,
-    ) -> Box<dyn Future<Item = BlockPtr, Error = IngestorError> + Send> {
-        Box::new(
-            self.block_hash_by_block_number(logger, block_number)
-                .and_then(move |block_hash_opt| {
-                    block_hash_opt.ok_or_else(|| {
-                        anyhow!(
-                            "Ethereum node could not find start block hash by block number {}",
-                            &block_number
-                        )
-                    })
-                })
-                .from_err()
-                .map(move |block_hash| BlockPtr::from((block_hash, block_number))),
-        )
+        address: Address,
+        block_ptr: BlockPtr,
+    ) -> Result<alloy::primitives::U256, EthereumRpcError> {
+        let logger = self.provider_logger(logger);
+        debug!(
+            logger, "eth_getBalance";
+            "address" => format!("{}", address),
+            "block" => format!("{}", block_ptr)
+        );
+        self.balance(logger, address, block_ptr).await
     }
 
-    fn block_hash_by_block_number(
+    async fn get_code(
         &self,
         logger: &Logger,
-        block_number: BlockNumber,
-    ) -> Box<dyn Future<Item = Option<H256>, Error = Error> + Send> {
-        let web3 = self.web3.clone();
-        let retry_log_message = format!(
-            "eth_getBlockByNumber RPC call for block number {}",
-            block_number
+        address: Address,
+        block_ptr: BlockPtr,
+    ) -> Result<alloy::primitives::Bytes, EthereumRpcError> {
+        let logger = self.provider_logger(logger);
+        debug!(
+            logger, "eth_getCode";
+            "address" => format!("{}", address),
+            "block" => format!("{}", block_ptr)
         );
-        Box::new(
-            retry(retry_log_message, logger)
+        self.code(logger, address, block_ptr).await
+    }
+
+    async fn next_existing_ptr_to_number(
+        &self,
+        logger: &Logger,
+        block_number: BlockNumber,
+    ) -> Result<BlockPtr, Error> {
+        let mut next_number = block_number;
+        loop {
+            let retry_log_message = format!(
+                "eth_getBlockByNumber RPC call for block number {}",
+                next_number
+            );
+            let alloy = self.alloy.clone();
+            let logger = logger.clone();
+            let res = retry(retry_log_message, &logger)
+                .redact_log_urls(true)
+                .when(|res| !res.is_ok() && !detect_null_block(res))
                 .no_limit()
-                .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
+                .timeout_secs(self.settings.json_rpc_timeout.as_secs())
                 .run(move || {
-                    let web3 = web3.cheap_clone();
+                    let alloy = alloy.cheap_clone();
                     async move {
-                        web3.eth()
-                            .block(BlockId::Number(block_number.into()))
+                        alloy
+                            .get_block_by_number(alloy::rpc::types::BlockNumberOrTag::Number(
+                                next_number as u64,
+                            ))
                             .await
-                            .map(|block_opt| block_opt.and_then(|block| block.hash))
+                            .map(|block_opt| {
+                                block_opt.map(|block| BlockHash::from(block.header.hash.0.to_vec()))
+                            })
                             .map_err(Error::from)
                     }
                 })
-                .boxed()
-                .compat()
+                .await
                 .map_err(move |e| {
                     e.into_inner().unwrap_or_else(move || {
                         anyhow!(
                             "Ethereum node took too long to return data for block #{}",
-                            block_number
+                            next_number
                         )
                     })
-                }),
-        )
+                });
+            if detect_null_block(&res) {
+                next_number += 1;
+                continue;
+            }
+            return match res {
+                Ok(Some(hash)) => Ok(BlockPtr::new(hash, next_number)),
+                Ok(None) => Err(anyhow!("Block {} does not contain hash", next_number)),
+                Err(e) => Err(e),
+            };
+        }
     }
 
-    fn contract_call(
+    async fn contract_call(
         &self,
         logger: &Logger,
-        call: EthereumContractCall,
+        inp_call: &ContractCall,
         cache: Arc<dyn EthereumCallCache>,
-    ) -> Box<dyn Future<Item = Vec<Token>, Error = EthereumContractCallError> + Send> {
-        // Emit custom error for type mismatches.
-        for (token, kind) in call
-            .args
-            .iter()
-            .zip(call.function.inputs.iter().map(|p| &p.kind))
-        {
-            if !token.type_check(kind) {
-                return Box::new(future::err(EthereumContractCallError::TypeError(
-                    token.clone(),
-                    kind.clone(),
-                )));
+    ) -> Result<(Option<Vec<abi::DynSolValue>>, call::Source), ContractCallError> {
+        let mut result = self.contract_calls(logger, &[inp_call], cache).await?;
+        // unwrap: self.contract_calls returns as many results as there were calls
+        Ok(result.pop().unwrap())
+    }
+
+    async fn contract_calls(
+        &self,
+        logger: &Logger,
+        calls: &[&ContractCall],
+        cache: Arc<dyn EthereumCallCache>,
+    ) -> Result<Vec<(Option<Vec<abi::DynSolValue>>, call::Source)>, ContractCallError> {
+        fn as_req(
+            logger: &ProviderLogger,
+            call: &ContractCall,
+            index: u32,
+        ) -> Result<call::Request, ContractCallError> {
+            // Emit custom error for type mismatches.
+            for (val, kind) in call
+                .args
+                .iter()
+                .zip(call.function.inputs.iter().map(|p| p.selector_type()))
+            {
+                let kind: abi::DynSolType = kind.parse().map_err(|err| {
+                    ContractCallError::ABIError(anyhow!(
+                        "failed to parse function input type '{kind}': {err}"
+                    ))
+                })?;
+
+                if !val.type_check(&kind) {
+                    return Err(ContractCallError::TypeError(val.clone(), kind.clone()));
+                }
+            }
+
+            // Encode the call parameters according to the ABI
+            let req = {
+                let encoded_call = call
+                    .function
+                    .abi_encode_input(&call.args)
+                    .map_err(ContractCallError::EncodingError)?;
+                call::Request::new(call.address, encoded_call, index)
+            };
+
+            trace!(logger, "eth_call";
+                "fn" => &call.function.name,
+                "address" => hex::encode(call.address),
+                "data" => hex::encode(req.encoded_call.as_ref()),
+                "block_hash" => call.block_ptr.hash_hex(),
+                "block_number" => call.block_ptr.block_number()
+            );
+            Ok(req)
+        }
+
+        fn decode(
+            logger: &ProviderLogger,
+            resp: call::Response,
+            call: &ContractCall,
+        ) -> (Option<Vec<abi::DynSolValue>>, call::Source) {
+            let call::Response {
+                retval,
+                source,
+                req: _,
+            } = resp;
+            match retval {
+                call::Retval::Value(output) => match call.function.abi_decode_output(&output) {
+                    Ok(tokens) => (Some(tokens), source),
+                    Err(e) => {
+                        // Decode failures are reverts. The reasoning is that if Solidity fails to
+                        // decode an argument, that's a revert, so the same goes for the output.
+                        let reason = format!("failed to decode output: {}", e);
+                        info!(logger, "Contract call reverted"; "reason" => reason);
+                        (None, call::Source::Rpc)
+                    }
+                },
+                call::Retval::Null => {
+                    // We got a `0x` response. For old Geth, this can mean a revert. It can also be
+                    // that the contract actually returned an empty response. A view call is meant
+                    // to return something, so we treat empty responses the same as reverts.
+                    info!(logger, "Contract call reverted"; "reason" => "empty response");
+                    (None, call::Source::Rpc)
+                }
+            }
+        }
+
+        fn log_call_error(logger: &ProviderLogger, e: &ContractCallError, call: &ContractCall) {
+            match e {
+                ContractCallError::AlloyError(e) => error!(
+                    logger,
+                    "Ethereum node returned an error when calling function \"{}\" of contract \"{}\": {}",
+                    call.function.name,
+                    call.contract_name,
+                    e
+                ),
+                ContractCallError::Timeout => error!(
+                    logger,
+                    "Ethereum node did not respond when calling function \"{}\" of contract \"{}\"",
+                    call.function.name,
+                    call.contract_name
+                ),
+                _ => error!(
+                    logger,
+                    "Failed to call function \"{}\" of contract \"{}\": {}",
+                    call.function.name,
+                    call.contract_name,
+                    e
+                ),
             }
         }
 
-        // Encode the call parameters according to the ABI
-        let call_data = match call.function.encode_input(&call.args) {
-            Ok(data) => data,
-            Err(e) => return Box::new(future::err(EthereumContractCallError::EncodingError(e))),
-        };
+        let logger = self.provider_logger(logger);
 
-        debug!(logger, "eth_call";
-            "address" => hex::encode(call.address),
-            "data" => hex::encode(&call_data),
-            "block_hash" => call.block_ptr.hash_hex(),
-            "block_number" => call.block_ptr.block_number()
-        );
+        if calls.is_empty() {
+            return Ok(Vec::new());
+        }
 
-        // Check if we have it cached, if not do the call and cache.
-        Box::new(
-            match cache
-                .get_call(call.address, &call_data, call.block_ptr.clone())
-                .map_err(|e| error!(logger, "call cache get error"; "error" => e.to_string()))
-                .ok()
-                .flatten()
-            {
-                Some(result) => {
-                    Box::new(future::ok(result)) as Box<dyn Future<Item = _, Error = _> + Send>
-                }
-                None => {
-                    let cache = cache.clone();
-                    let call = call.clone();
-                    let logger = logger.clone();
-                    Box::new(
-                        self.call(
-                            logger.clone(),
-                            call.address,
-                            Bytes(call_data.clone()),
-                            call.block_ptr.clone(),
-                            call.gas,
-                        )
-                        .map(move |result| {
-                            // Don't block handler execution on writing to the cache.
-                            let for_cache = result.0.clone();
-                            if !result.0.is_empty() {
-                                let _ = graph::spawn_blocking_allow_panic(move || {
-                                    cache
-                                        .set_call(
-                                            call.address,
-                                            &call_data,
-                                            call.block_ptr,
-                                            &for_cache,
-                                        )
-                                        .map_err(|e| {
-                                            error!(logger, "call cache set error";
-                                                       "error" => e.to_string())
-                                        })
-                                });
-                            }
-                            result.0
-                        }),
-                    )
+        let block_ptr = calls.first().unwrap().block_ptr.clone();
+        if calls.iter().any(|call| call.block_ptr != block_ptr) {
+            return Err(ContractCallError::Internal(
+                "all calls must have the same block pointer".to_string(),
+            ));
+        }
+
+        let reqs: Vec<_> = calls
+            .iter()
+            .enumerate()
+            .map(|(index, call)| as_req(&logger, call, index as u32))
+            .collect::<Result<_, _>>()?;
+
+        let (mut resps, missing) = cache
+            .get_calls(&reqs, block_ptr)
+            .await
+            .map_err(|e| error!(logger, "call cache get error"; "error" => e.to_string()))
+            .unwrap_or_else(|_| (Vec::new(), reqs));
+
+        let futs = missing.into_iter().map(|req| {
+            let cache = cache.clone();
+            let logger = logger.clone();
+            async move {
+                let call = calls[req.index as usize];
+                match self.call_and_cache(&logger, call, req, cache.clone()).await {
+                    Ok(resp) => Ok(resp),
+                    Err(e) => {
+                        log_call_error(&logger, &e, call);
+                        Err(e)
+                    }
                 }
             }
-            // Decode the return values according to the ABI
-            .and_then(move |output| {
-                if output.is_empty() {
-                    // We got a `0x` response. For old Geth, this can mean a revert. It can also be
-                    // that the contract actually returned an empty response. A view call is meant
-                    // to return something, so we treat empty responses the same as reverts.
-                    Err(EthereumContractCallError::Revert("empty response".into()))
-                } else {
-                    // Decode failures are reverts. The reasoning is that if Solidity fails to
-                    // decode an argument, that's a revert, so the same goes for the output.
-                    call.function.decode_output(&output).map_err(|e| {
-                        EthereumContractCallError::Revert(format!("failed to decode output: {}", e))
-                    })
-                }
-            }),
-        )
+        });
+        resps.extend(try_join_all(futs).await?);
+
+        // If we make it here, we have a response for every call.
+        debug_assert_eq!(resps.len(), calls.len());
+
+        // Bring the responses into the same order as the calls
+        resps.sort_by_key(|resp| resp.req.index);
+
+        let decoded: Vec<_> = resps
+            .into_iter()
+            .map(|res| {
+                let call = &calls[res.req.index as usize];
+                decode(&logger, res, call)
+            })
+            .collect();
+
+        Ok(decoded)
     }
 
     /// Load Ethereum blocks in bulk, returning results as they come back as a Stream.
@@ -1349,56 +1655,53 @@ impl EthereumAdapterTrait for EthereumAdapter {
         &self,
         logger: Logger,
         chain_store: Arc<dyn ChainStore>,
-        block_hashes: HashSet<H256>,
-    ) -> Box<dyn Stream<Item = Arc<LightEthereumBlock>, Error = Error> + Send> {
+        block_hashes: HashSet<B256>,
+    ) -> Result<Vec<Arc<LightEthereumBlock>>, Error> {
         let block_hashes: Vec<_> = block_hashes.iter().cloned().collect();
         // Search for the block in the store first then use json-rpc as a backup.
-        let mut blocks: Vec<Arc<LightEthereumBlock>> = chain_store
+        let mut blocks: Vec<_> = chain_store
             .cheap_clone()
             .blocks(block_hashes.iter().map(|&b| b.into()).collect::<Vec<_>>())
             .await
             .map_err(|e| error!(&logger, "Error accessing block cache {}", e))
             .unwrap_or_default()
-            .into_iter()
-            .filter_map(|value| json::from_value(value).ok())
-            .map(Arc::new)
+            .iter()
+            .map(|b| b.to_light_block())
             .collect();
 
         let missing_blocks = Vec::from_iter(
             block_hashes
                 .into_iter()
-                .filter(|hash| !blocks.iter().any(|b| b.hash == Some(*hash))),
+                .filter(|hash| !blocks.iter().any(|b| b.hash() == *hash)),
         );
 
         // Return a stream that lazily loads batches of blocks.
         debug!(logger, "Requesting {} block(s)", missing_blocks.len());
-        Box::new(
-            self.load_blocks_rpc(logger.clone(), missing_blocks)
-                .collect()
-                .map(move |new_blocks| {
-                    let upsert_blocks: Vec<_> = new_blocks
-                        .iter()
-                        .map(|block| BlockFinality::Final(block.clone()))
-                        .collect();
-                    let block_refs: Vec<_> = upsert_blocks
-                        .iter()
-                        .map(|block| block as &dyn graph::blockchain::Block)
-                        .collect();
-                    if let Err(e) = chain_store.upsert_light_blocks(block_refs.as_slice()) {
-                        error!(logger, "Error writing to block cache {}", e);
-                    }
-                    blocks.extend(new_blocks);
-                    blocks.sort_by_key(|block| block.number);
-                    stream::iter_ok(blocks)
-                })
-                .flatten_stream(),
-        )
+        let new_blocks: Vec<_> = self
+            .load_blocks_rpc(logger.clone(), missing_blocks)
+            .try_collect()
+            .await?;
+        let upsert_blocks: Vec<_> = new_blocks
+            .iter()
+            .map(|block| BlockFinality::Final(block.clone()))
+            .collect();
+        let block_refs: Vec<_> = upsert_blocks
+            .iter()
+            .map(|block| block as &dyn graph::blockchain::Block)
+            .collect();
+        if let Err(e) = chain_store.upsert_light_blocks(block_refs.as_slice()).await {
+            error!(logger, "Error writing to block cache {}", e);
+        }
+        blocks.extend(new_blocks);
+        blocks.sort_by_key(|block| block.number());
+        Ok(blocks)
     }
 }
 
-/// Returns blocks with triggers, corresponding to the specified range and filters.
+/// Returns blocks with triggers, corresponding to the specified range and filters; and the resolved
+/// `to` block, which is the nearest non-null block greater than or equal to the passed `to` block.
 /// If a block contains no triggers, there may be no corresponding item in the stream.
-/// However the `to` block will always be present, even if triggers are empty.
+/// However the (resolved) `to` block will always be present, even if triggers are empty.
 ///
 /// Careful: don't use this function without considering race conditions.
 /// Chain reorgs could happen at any time, and could affect the answer received.
@@ -1418,22 +1721,31 @@ pub(crate) async fn blocks_with_triggers(
     to: BlockNumber,
     filter: &TriggerFilter,
     unified_api_version: UnifiedMappingApiVersion,
-) -> Result<Vec<BlockWithTriggers<crate::Chain>>, Error> {
+) -> Result<(Vec<BlockWithTriggers<crate::Chain>>, BlockNumber), Error> {
     // Each trigger filter needs to be queried for the same block range
     // and the blocks yielded need to be deduped. If any error occurs
     // while searching for a trigger type, the entire operation fails.
     let eth = adapter.clone();
     let call_filter = EthereumCallFilter::from(&filter.block);
+    let logger = ProviderLogger::new(&logger, eth.provider());
 
     // Scan the block range to find relevant triggers
     let trigger_futs: FuturesUnordered<BoxFuture<Result<Vec<EthereumTrigger>, anyhow::Error>>> =
         FuturesUnordered::new();
 
+    // Resolve the nearest non-null "to" block
+    debug!(logger, "Finding nearest valid `to` block to {}", to);
+
+    let to_ptr = eth.next_existing_ptr_to_number(&logger, to).await?;
+    let to_hash = to_ptr.hash.as_b256();
+    let to = to_ptr.block_number();
+
     // This is for `start` triggers which can be initialization handlers which needs to be run
     // before all other triggers
     if filter.block.trigger_every_block {
+        let logger = logger.clone();
         let block_future = eth
-            .block_range_to_ptrs(logger.clone(), from, to)
+            .block_range_to_ptrs((*logger).clone(), from, to)
             .map(move |ptrs| {
                 ptrs.into_iter()
                     .flat_map(|ptr| {
@@ -1449,7 +1761,7 @@ pub(crate) async fn blocks_with_triggers(
         trigger_futs.push(block_future)
     } else if !filter.block.polling_intervals.is_empty() {
         let block_futures_matching_once_filter =
-            eth.blocks_matching_polling_intervals(logger.clone(), from, to, &filter.block);
+            eth.blocks_matching_polling_intervals((*logger).clone(), from, to, &filter.block);
         trigger_futs.push(block_futures_matching_once_filter);
     }
 
@@ -1457,7 +1769,7 @@ pub(crate) async fn blocks_with_triggers(
     if !filter.log.is_empty() {
         let logs_future = get_logs_and_transactions(
             &eth,
-            &logger,
+            logger.clone(),
             subgraph_metrics.clone(),
             from,
             to,
@@ -1497,31 +1809,16 @@ pub(crate) async fn blocks_with_triggers(
         trigger_futs.push(block_future)
     }
 
-    // Get hash for "to" block
-    let to_hash_fut = eth
-        .block_hash_by_block_number(&logger, to)
-        .and_then(|hash| match hash {
-            Some(hash) => Ok(hash),
-            None => {
-                warn!(logger,
-                      "Ethereum endpoint is behind";
-                      "url" => eth.provider()
-                );
-                bail!("Block {} not found in the chain", to)
-            }
-        })
-        .compat();
-
-    // Join on triggers and block hash resolution
-    let (triggers, to_hash) = futures03::join!(trigger_futs.try_concat(), to_hash_fut);
-
-    // Unpack and handle possible errors in the previously joined futures
-    let triggers =
-        triggers.with_context(|| format!("Failed to obtain triggers for block {}", to))?;
-    let to_hash = to_hash.with_context(|| format!("Failed to infer hash for block {}", to))?;
+    // Join on triggers, unpack and handle possible errors
+    let triggers = trigger_futs
+        .try_concat()
+        .await
+        .with_context(|| format!("Failed to obtain triggers for block {}", to))?;
 
-    let mut block_hashes: HashSet<H256> =
-        triggers.iter().map(EthereumTrigger::block_hash).collect();
+    let mut block_hashes: HashSet<B256> = triggers
+        .iter()
+        .map(|trigger| trigger.block_hash())
+        .collect();
     let mut triggers_by_block: HashMap<BlockNumber, Vec<EthereumTrigger>> =
         triggers.into_iter().fold(HashMap::new(), |mut map, t| {
             map.entry(t.block_number()).or_default().push(t);
@@ -1536,11 +1833,12 @@ pub(crate) async fn blocks_with_triggers(
 
     let logger2 = logger.cheap_clone();
 
-    let blocks = eth
-        .load_blocks(logger.cheap_clone(), chain_store.clone(), block_hashes)
-        .await
-        .and_then(
-            move |block| match triggers_by_block.remove(&(block.number() as BlockNumber)) {
+    let blocks: Vec<_> = eth
+        .load_blocks((*logger).cheap_clone(), chain_store.clone(), block_hashes)
+        .await?
+        .into_iter()
+        .map(
+            move |block| match triggers_by_block.remove(&(block.number())) {
                 Some(triggers) => Ok(BlockWithTriggers::new(
                     BlockFinality::Final(block),
                     triggers,
@@ -1552,9 +1850,7 @@ pub(crate) async fn blocks_with_triggers(
                 )),
             },
         )
-        .collect()
-        .compat()
-        .await?;
+        .collect::<Result<_, _>>()?;
 
     // Filter out call triggers that come from unsuccessful transactions
     let futures = blocks.into_iter().map(|block| {
@@ -1583,7 +1879,7 @@ pub(crate) async fn blocks_with_triggers(
         ));
     }
 
-    Ok(blocks)
+    Ok((blocks, to))
 }
 
 pub(crate) async fn get_calls(
@@ -1612,13 +1908,13 @@ pub(crate) async fn get_calls(
             } else {
                 client
                     .rpc()?
-                    .cheapest_with(capabilities)?
+                    .cheapest_with(capabilities)
+                    .await?
                     .calls_in_block(
                         &logger,
                         subgraph_metrics.clone(),
-                        BlockNumber::try_from(ethereum_block.block.number.unwrap().as_u64())
-                            .unwrap(),
-                        ethereum_block.block.hash.unwrap(),
+                        ethereum_block.block.number(),
+                        ethereum_block.block.hash(),
                     )
                     .await?
             };
@@ -1627,6 +1923,9 @@ pub(crate) async fn get_calls(
                 calls: Some(calls),
             }))
         }
+        BlockFinality::Ptr(_) => {
+            unreachable!("get_calls called with BlockFinality::Ptr")
+        }
     }
 }
 
@@ -1638,15 +1937,36 @@ pub(crate) fn parse_log_triggers(
         return vec![];
     }
 
-    block
+    let total_logs: usize = block
         .transaction_receipts
         .iter()
-        .flat_map(move |receipt| {
-            receipt.logs.iter().enumerate().map(move |(index, _)| {
-                EthereumTrigger::Log(LogRef::LogPosition(index, receipt.cheap_clone()))
-            })
-        })
-        .collect()
+        .map(|r| r.logs().len())
+        .sum();
+    let mut triggers = Vec::with_capacity(total_logs);
+
+    for receipt in &block.transaction_receipts {
+        for (index, log) in receipt.logs().iter().enumerate() {
+            let requires_transaction_receipt = log
+                .topics()
+                .first()
+                .map(|signature| {
+                    log_filter.requires_transaction_receipt(
+                        signature,
+                        Some(&log.address()),
+                        log.topics(),
+                    )
+                })
+                .unwrap_or(false);
+
+            triggers.push(EthereumTrigger::Log(LogRef::LogPosition(LogPosition {
+                index,
+                receipt: receipt.cheap_clone(),
+                requires_transaction_receipt,
+            })));
+        }
+    }
+
+    triggers
 }
 
 pub(crate) fn parse_call_triggers(
@@ -1674,6 +1994,36 @@ pub(crate) fn parse_call_triggers(
     }
 }
 
+/// For a given `block_number`, return the block trigger types that fire
+/// based on the rules in `polling_intervals`. Each entry is `(start_block,
+/// interval)` where `interval == 0` encodes a `once` rule and `interval > 0`
+/// encodes a `polling every interval` rule. Both rule kinds can fire at the
+/// same block (e.g. a once and polling rule sharing a `start_block`), so the
+/// returned Vec may contain `Start`, `End`, both, or neither.
+pub(crate) fn block_trigger_types_from_intervals(
+    block_number: i32,
+    polling_intervals: &HashSet<(i32, i32)>,
+) -> Vec<EthereumBlockTriggerType> {
+    let has_once_trigger = polling_intervals
+        .iter()
+        .any(|(start_block, interval)| *interval == 0 && block_number == *start_block);
+
+    let has_polling_trigger = polling_intervals.iter().any(|(start_block, interval)| {
+        *interval > 0
+            && block_number >= *start_block
+            && (block_number - start_block) % *interval == 0
+    });
+
+    let mut triggers = Vec::new();
+    if has_once_trigger {
+        triggers.push(EthereumBlockTriggerType::Start);
+    }
+    if has_polling_trigger {
+        triggers.push(EthereumBlockTriggerType::End);
+    }
+    triggers
+}
+
 /// This method does not parse block triggers with `once` filters.
 /// This is because it is to be run before any other triggers are run.
 /// So we have `parse_initialization_triggers` for that.
@@ -1685,7 +2035,7 @@ pub(crate) fn parse_block_triggers(
         return vec![];
     }
 
-    let block_ptr = BlockPtr::from(&block.ethereum_block);
+    let block_ptr = block.ethereum_block.block.block_ptr();
     let trigger_every_block = block_filter.trigger_every_block;
     let call_filter = EthereumCallFilter::from(block_filter);
     let block_ptr2 = block_ptr.cheap_clone();
@@ -1715,38 +2065,12 @@ pub(crate) fn parse_block_triggers(
             EthereumBlockTriggerType::End,
         ));
     } else if !block_filter.polling_intervals.is_empty() {
-        let has_polling_trigger =
-            &block_filter
-                .polling_intervals
-                .iter()
-                .any(|(start_block, interval)| match interval {
-                    0 => false,
-                    _ => {
-                        block_number >= *start_block
-                            && (block_number - *start_block) % *interval == 0
-                    }
-                });
-
-        let has_once_trigger =
-            &block_filter
-                .polling_intervals
-                .iter()
-                .any(|(start_block, interval)| match interval {
-                    0 => block_number == *start_block,
-                    _ => false,
-                });
-
-        if *has_once_trigger {
-            triggers.push(EthereumTrigger::Block(
-                block_ptr3.clone(),
-                EthereumBlockTriggerType::Start,
-            ));
-        }
-
-        if *has_polling_trigger {
+        for trigger_type in
+            block_trigger_types_from_intervals(block_number, &block_filter.polling_intervals)
+        {
             triggers.push(EthereumTrigger::Block(
-                block_ptr3,
-                EthereumBlockTriggerType::End,
+                block_ptr3.cheap_clone(),
+                trigger_type,
             ));
         }
     }
@@ -1755,9 +2079,9 @@ pub(crate) fn parse_block_triggers(
 
 async fn fetch_receipt_from_ethereum_client(
     eth: &EthereumAdapter,
-    transaction_hash: &H256,
-) -> anyhow::Result<TransactionReceipt> {
-    match eth.web3.eth().transaction_receipt(*transaction_hash).await {
+    transaction_hash: B256,
+) -> anyhow::Result<AnyTransactionReceiptBare> {
+    match eth.alloy.get_transaction_receipt(transaction_hash).await {
         Ok(Some(receipt)) => Ok(receipt),
         Ok(None) => bail!("Could not find transaction receipt"),
         Err(error) => bail!("Failed to fetch transaction receipt: {}", error),
@@ -1768,7 +2092,7 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
     mut block: BlockWithTriggers<crate::Chain>,
     eth: &EthereumAdapter,
     chain_store: &Arc<dyn ChainStore>,
-    logger: &Logger,
+    logger: &ProviderLogger,
 ) -> anyhow::Result<BlockWithTriggers<crate::Chain>> {
     // Return early if there is no trigger data
     if block.trigger_data.is_empty() {
@@ -1778,14 +2102,14 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
     let initial_number_of_triggers = block.trigger_data.len();
 
     // Get the transaction hash from each call trigger
-    let transaction_hashes: BTreeSet<H256> = block
+    let transaction_hashes: BTreeSet<B256> = block
         .trigger_data
         .iter()
-        .filter_map(|trigger| match trigger {
-            EthereumTrigger::Call(call_trigger) => Some(call_trigger.transaction_hash),
+        .filter_map(|trigger| match trigger.as_chain() {
+            Some(EthereumTrigger::Call(call_trigger)) => Some(call_trigger.transaction_hash),
             _ => None,
         })
-        .collect::<Option<BTreeSet<H256>>>()
+        .collect::<Option<BTreeSet<B256>>>()
         .ok_or(anyhow!(
             "failed to obtain transaction hash from call triggers"
         ))?;
@@ -1796,18 +2120,24 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
     }
 
     // And obtain all Transaction values for the calls in this block.
-    let transactions: Vec<&Transaction> = {
+    let transactions: Vec<&AnyTransaction> = {
         match &block.block {
-            BlockFinality::Final(ref block) => block
-                .transactions
+            BlockFinality::Final(block) => block
+                .transactions()
+                .ok_or_else(|| anyhow!("Block transactions not available"))?
                 .iter()
-                .filter(|transaction| transaction_hashes.contains(&transaction.hash))
+                .filter(|transaction| transaction_hashes.contains(&transaction.tx_hash()))
                 .collect(),
             BlockFinality::NonFinal(_block_with_calls) => {
                 unreachable!(
                     "this function should not be called when dealing with non-final blocks"
                 )
             }
+            BlockFinality::Ptr(_block) => {
+                unreachable!(
+                    "this function should not be called when dealing with header-only blocks"
+                )
+            }
         }
     };
 
@@ -1818,21 +2148,21 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
 
     // We'll also need the receipts for those transactions. In this step we collect all receipts
     // we have in store for the current block.
-    let mut receipts = chain_store
-        .transaction_receipts_in_block(&block.ptr().hash_as_h256())
+    let mut receipts: BTreeMap<B256, LightTransactionReceipt> = chain_store
+        .transaction_receipts_in_block(&block.ptr().hash.as_b256())
         .await?
         .into_iter()
         .map(|receipt| (receipt.transaction_hash, receipt))
-        .collect::<BTreeMap<H256, LightTransactionReceipt>>();
+        .collect::<BTreeMap<B256, LightTransactionReceipt>>();
 
     // Do we have a receipt for each transaction under analysis?
-    let mut receipts_and_transactions: Vec<(&Transaction, LightTransactionReceipt)> = Vec::new();
-    let mut transactions_without_receipt: Vec<&Transaction> = Vec::new();
+    let mut receipts_and_transactions: Vec<(&AnyTransaction, LightTransactionReceipt)> = Vec::new();
+    let mut transactions_without_receipt: Vec<&AnyTransaction> = Vec::new();
     for transaction in transactions.iter() {
-        if let Some(receipt) = receipts.remove(&transaction.hash) {
-            receipts_and_transactions.push((transaction, receipt));
+        if let Some(receipt) = receipts.remove(&transaction.tx_hash()) {
+            receipts_and_transactions.push((*transaction, receipt));
         } else {
-            transactions_without_receipt.push(transaction);
+            transactions_without_receipt.push(*transaction);
         }
     }
 
@@ -1840,7 +2170,7 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
     let futures = transactions_without_receipt
         .iter()
         .map(|transaction| async move {
-            fetch_receipt_from_ethereum_client(eth, &transaction.hash)
+            fetch_receipt_from_ethereum_client(eth, transaction.tx_hash())
                 .await
                 .map(|receipt| (transaction, receipt))
         });
@@ -1855,12 +2185,9 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
     // additional Ethereum API calls for future scans on this block.
 
     // With all transactions and receipts in hand, we can evaluate the success of each transaction
-    let mut transaction_success: BTreeMap<&H256, bool> = BTreeMap::new();
+    let mut transaction_success: BTreeMap<B256, bool> = BTreeMap::new();
     for (transaction, receipt) in receipts_and_transactions.into_iter() {
-        transaction_success.insert(
-            &transaction.hash,
-            evaluate_transaction_status(receipt.status),
-        );
+        transaction_success.insert(transaction.tx_hash(), receipt.status);
     }
 
     // Confidence check: Did we inspect the status of all transactions?
@@ -1873,7 +2200,7 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
 
     // Filter call triggers from unsuccessful transactions
     block.trigger_data.retain(|trigger| {
-        if let EthereumTrigger::Call(call_trigger) = trigger {
+        if let Some(EthereumTrigger::Call(call_trigger)) = trigger.as_chain() {
             // Unwrap: We already checked that those values exist
             transaction_success[&call_trigger.transaction_hash.unwrap()]
         } else {
@@ -1902,75 +2229,242 @@ async fn filter_call_triggers_from_unsuccessful_transactions(
 
 /// Deprecated. Wraps the [`fetch_transaction_receipts_in_batch`] in a retry loop.
 async fn fetch_transaction_receipts_in_batch_with_retry(
-    web3: Arc<Web3<Transport>>,
-    hashes: Vec<H256>,
-    block_hash: H256,
-    logger: Logger,
-) -> Result<Vec<Arc<TransactionReceipt>>, IngestorError> {
+    alloy: Arc<AlloyProvider>,
+    hashes: Vec<B256>,
+    block_hash: B256,
+    logger: ProviderLogger,
+    settings: &ChainSettings,
+) -> Result<Vec<Arc<AnyTransactionReceiptBare>>, IngestorError> {
     let retry_log_message = format!(
         "batch eth_getTransactionReceipt RPC call for block {:?}",
         block_hash
     );
     retry(retry_log_message, &logger)
-        .limit(ENV_VARS.request_retries)
+        .redact_log_urls(true)
+        .limit(settings.request_retries)
         .no_logging()
-        .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
+        .timeout_secs(settings.json_rpc_timeout.as_secs())
         .run(move || {
-            let web3 = web3.cheap_clone();
+            let alloy = alloy.cheap_clone();
             let hashes = hashes.clone();
             let logger = logger.cheap_clone();
-            fetch_transaction_receipts_in_batch(web3, hashes, block_hash, logger).boxed()
+            fetch_transaction_receipts_in_batch(alloy, hashes, block_hash, logger).boxed()
         })
         .await
         .map_err(|_timeout| anyhow!(block_hash).into())
 }
 
-/// Deprecated. Attempts to fetch multiple transaction receipts in a batching contex.
+/// Deprecated. Attempts to fetch multiple transaction receipts in a batching context.
 async fn fetch_transaction_receipts_in_batch(
-    web3: Arc<Web3<Transport>>,
-    hashes: Vec<H256>,
-    block_hash: H256,
-    logger: Logger,
-) -> Result<Vec<Arc<TransactionReceipt>>, IngestorError> {
-    let batching_web3 = Web3::new(Batch::new(web3.transport().clone()));
-    let eth = batching_web3.eth();
-    let receipt_futures = hashes
-        .into_iter()
-        .map(move |hash| {
-            let logger = logger.cheap_clone();
-            eth.transaction_receipt(hash)
-                .map_err(IngestorError::from)
-                .and_then(move |some_receipt| async move {
-                    resolve_transaction_receipt(some_receipt, hash, block_hash, logger)
-                })
+    alloy: Arc<AlloyProvider>,
+    hashes: Vec<B256>,
+    block_hash: B256,
+    logger: ProviderLogger,
+) -> Result<Vec<Arc<AnyTransactionReceiptBare>>, IngestorError> {
+    // Use the batch method to get all receipts at once
+    let receipts = batch_get_transaction_receipts(alloy, hashes.clone())
+        .await
+        .map_err(|e| {
+            IngestorError::Unknown(anyhow::anyhow!("Batch receipt fetch failed: {}", e))
+        })?;
+
+    let mut result = Vec::new();
+    for (receipt, hash) in receipts.into_iter().zip(hashes.iter()) {
+        if let Some(receipt) = receipt {
+            let validated_receipt = resolve_transaction_receipt(
+                Some(receipt),
+                *hash,
+                block_hash,
+                logger.cheap_clone(),
+            )?;
+            result.push(Arc::new(validated_receipt));
+        } else {
+            return Err(IngestorError::ReceiptUnavailable(block_hash, *hash));
+        }
+    }
+
+    Ok(result)
+}
+
+async fn batch_get_transaction_receipts(
+    provider: Arc<AlloyProvider>,
+    tx_hashes: Vec<B256>,
+) -> Result<Vec<Option<AnyTransactionReceiptBare>>, Box<dyn std::error::Error>> {
+    let mut batch = alloy::rpc::client::BatchRequest::new(provider.client());
+    let mut receipt_futures = Vec::new();
+
+    // Add all receipt requests to batch
+    for tx_hash in &tx_hashes {
+        let receipt_future = batch.add_call::<(B256,), Option<AnyTransactionReceiptBare>>(
+            "eth_getTransactionReceipt",
+            &(*tx_hash,),
+        )?;
+        receipt_futures.push(receipt_future);
+    }
+
+    // Execute batch
+    batch.send().await?;
+
+    // Collect results in order
+    let mut results = Vec::new();
+    for receipt_future in receipt_futures {
+        let receipt = receipt_future.await?;
+        results.push(receipt);
+    }
+
+    Ok(results)
+}
+
+pub(crate) async fn check_block_receipt_support(
+    alloy: Arc<AlloyProvider>,
+    block_hash: B256,
+    supports_eip_1898: bool,
+    call_only: bool,
+) -> Result<(), Error> {
+    use alloy::rpc::types::BlockId;
+    if call_only {
+        return Err(anyhow!("Provider is call-only"));
+    }
+
+    if !supports_eip_1898 {
+        return Err(anyhow!("Provider does not support EIP 1898"));
+    }
+
+    // Fetch block receipts from the provider for the latest block.
+    let block_receipts_result = alloy.get_block_receipts(BlockId::from(block_hash)).await;
+
+    // Determine if the provider supports block receipts based on the fetched result.
+    match block_receipts_result {
+        Ok(Some(receipts)) if !receipts.is_empty() => Ok(()),
+        Ok(_) => Err(anyhow!("Block receipts are empty")),
+        Err(err) => Err(anyhow!("Error fetching block receipts: {}", err)),
+    }
+}
+
+// Fetches transaction receipts with retries. This function acts as a dispatcher
+// based on whether block receipts are supported or individual transaction receipts
+// need to be fetched.
+async fn fetch_receipts_with_retry(
+    alloy: Arc<AlloyProvider>,
+    hashes: Vec<B256>,
+    block_hash: B256,
+    logger: ProviderLogger,
+    supports_block_receipts: bool,
+    settings: &ChainSettings,
+) -> Result<Vec<Arc<AnyTransactionReceiptBare>>, IngestorError> {
+    if supports_block_receipts {
+        return fetch_block_receipts_with_retry(alloy, hashes, block_hash, logger, settings).await;
+    }
+    fetch_individual_receipts_with_retry(alloy, hashes, block_hash, logger, settings).await
+}
+
+// Fetches receipts for each transaction in the block individually.
+async fn fetch_individual_receipts_with_retry(
+    alloy: Arc<AlloyProvider>,
+    hashes: Vec<B256>,
+    block_hash: B256,
+    logger: ProviderLogger,
+    settings: &ChainSettings,
+) -> Result<Vec<Arc<AnyTransactionReceiptBare>>, IngestorError> {
+    if ENV_VARS.fetch_receipts_in_batches {
+        return fetch_transaction_receipts_in_batch_with_retry(
+            alloy, hashes, block_hash, logger, settings,
+        )
+        .await;
+    }
+
+    let request_retries = settings.request_retries;
+    let json_rpc_timeout = settings.json_rpc_timeout;
+    let concurrent_requests = settings.block_ingestor_max_concurrent_json_rpc_calls;
+
+    // Use a stream to fetch receipts individually
+    let hash_stream = tokio_stream::iter(hashes);
+    let receipt_stream = hash_stream
+        .map(move |tx_hash| {
+            fetch_transaction_receipt_with_retry(
+                alloy.cheap_clone(),
+                tx_hash,
+                block_hash,
+                logger.cheap_clone(),
+                request_retries,
+                json_rpc_timeout,
+            )
         })
-        .collect::<Vec<_>>();
+        .buffered(concurrent_requests);
 
-    batching_web3.transport().submit_batch().await?;
+    tokio_stream::StreamExt::collect::<Result<Vec<Arc<AnyTransactionReceiptBare>>, IngestorError>>(
+        receipt_stream,
+    )
+    .await
+}
 
-    let mut collected = vec![];
-    for receipt in receipt_futures.into_iter() {
-        collected.push(Arc::new(receipt.await?))
+/// Fetches transaction receipts of all transactions in a block with `eth_getBlockReceipts` call.
+async fn fetch_block_receipts_with_retry(
+    alloy: Arc<AlloyProvider>,
+    hashes: Vec<B256>,
+    block_hash: B256,
+    logger: ProviderLogger,
+    settings: &ChainSettings,
+) -> Result<Vec<Arc<AnyTransactionReceiptBare>>, IngestorError> {
+    use graph::prelude::alloy::rpc::types::BlockId;
+    let retry_log_message = format!("eth_getBlockReceipts RPC call for block {:?}", block_hash);
+
+    // Perform the retry operation
+    let receipts_option = retry(retry_log_message, &logger)
+        .redact_log_urls(true)
+        .limit(settings.request_retries)
+        .timeout_secs(settings.json_rpc_timeout.as_secs())
+        .run(move || alloy.get_block_receipts(BlockId::from(block_hash)).boxed())
+        .await
+        .map_err(|_timeout| -> IngestorError { anyhow!(block_hash).into() })?;
+
+    // Check if receipts are available, and transform them if they are
+    match receipts_option {
+        Some(receipts) => {
+            // Create a HashSet from the transaction hashes of the receipts
+            let receipt_hashes_set: HashSet<_> =
+                receipts.iter().map(|r| r.transaction_hash).collect();
+
+            // Check if the set contains all the hashes and has the same length as the hashes vec
+            if hashes.len() == receipt_hashes_set.len()
+                && hashes.iter().all(|hash| receipt_hashes_set.contains(hash))
+            {
+                let transformed_receipts = receipts.into_iter().map(Arc::new).collect();
+                Ok(transformed_receipts)
+            } else {
+                // If there's a mismatch in numbers or a missing hash, return an error
+                Err(IngestorError::BlockReceiptsMismatched(block_hash))
+            }
+        }
+        None => {
+            // If no receipts are found, return an error
+            Err(IngestorError::BlockReceiptsUnavailable(block_hash))
+        }
     }
-    Ok(collected)
 }
 
-/// Retries fetching a single transaction receipt.
+/// Retries fetching a single transaction receipt using alloy, then converts to web3 format.
 async fn fetch_transaction_receipt_with_retry(
-    web3: Arc<Web3<Transport>>,
-    transaction_hash: H256,
-    block_hash: H256,
-    logger: Logger,
-) -> Result<Arc<TransactionReceipt>, IngestorError> {
-    let logger = logger.cheap_clone();
+    alloy: Arc<AlloyProvider>,
+    transaction_hash: B256,
+    block_hash: B256,
+    logger: ProviderLogger,
+    request_retries: usize,
+    json_rpc_timeout: Duration,
+) -> Result<Arc<AnyTransactionReceiptBare>, IngestorError> {
     let retry_log_message = format!(
         "eth_getTransactionReceipt RPC call for transaction {:?}",
         transaction_hash
     );
+
     retry(retry_log_message, &logger)
-        .limit(ENV_VARS.request_retries)
-        .timeout_secs(ENV_VARS.json_rpc_timeout.as_secs())
-        .run(move || web3.eth().transaction_receipt(transaction_hash).boxed())
+        .redact_log_urls(true)
+        .limit(request_retries)
+        .timeout_secs(json_rpc_timeout.as_secs())
+        .run(move || {
+            let alloy_clone = alloy.clone();
+            async move { alloy_clone.get_transaction_receipt(transaction_hash).await }.boxed()
+        })
         .await
         .map_err(|_timeout| anyhow!(block_hash).into())
         .and_then(move |some_receipt| {
@@ -1980,11 +2474,11 @@ async fn fetch_transaction_receipt_with_retry(
 }
 
 fn resolve_transaction_receipt(
-    transaction_receipt: Option<TransactionReceipt>,
-    transaction_hash: H256,
-    block_hash: H256,
-    logger: Logger,
-) -> Result<TransactionReceipt, IngestorError> {
+    transaction_receipt: Option<AnyTransactionReceiptBare>,
+    transaction_hash: B256,
+    block_hash: B256,
+    logger: ProviderLogger,
+) -> Result<AnyTransactionReceiptBare, IngestorError> {
     match transaction_receipt {
         // A receipt might be missing because the block was uncled, and the transaction never
         // made it back into the main chain.
@@ -2037,7 +2531,7 @@ fn resolve_transaction_receipt(
 /// Retrieves logs and the associated transaction receipts, if required by the [`EthereumLogFilter`].
 async fn get_logs_and_transactions(
     adapter: &Arc<EthereumAdapter>,
-    logger: &Logger,
+    logger: ProviderLogger,
     subgraph_metrics: Arc<SubgraphEthRpcMetrics>,
     from: BlockNumber,
     to: BlockNumber,
@@ -2047,7 +2541,7 @@ async fn get_logs_and_transactions(
     // Obtain logs externally
     let logs = adapter
         .logs_in_block_range(
-            logger,
+            &logger,
             subgraph_metrics.cheap_clone(),
             from,
             to,
@@ -2057,12 +2551,16 @@ async fn get_logs_and_transactions(
 
     // Not all logs have associated transaction hashes, nor do all triggers require them.
     // We also restrict receipts retrieval for some api versions.
-    let transaction_hashes_by_block: HashMap<H256, HashSet<H256>> = logs
+    let transaction_hashes_by_block: HashMap<B256, HashSet<B256>> = logs
         .iter()
         .filter(|_| unified_api_version.equal_or_greater_than(&API_VERSION_0_0_7))
         .filter(|log| {
-            if let Some(signature) = log.topics.first() {
-                log_filter.requires_transaction_receipt(signature, Some(&log.address))
+            if let Some(signature) = log.topics().first() {
+                log_filter.requires_transaction_receipt(
+                    signature,
+                    Some(&log.address()),
+                    log.topics(),
+                )
             } else {
                 false
             }
@@ -2077,7 +2575,7 @@ async fn get_logs_and_transactions(
             }
         })
         .fold(
-            HashMap::<H256, HashSet<H256>>::new(),
+            HashMap::<B256, HashSet<B256>>::new(),
             |mut acc, (block_hash, txn_hash)| {
                 acc.entry(block_hash).or_default().insert(txn_hash);
                 acc
@@ -2099,6 +2597,7 @@ async fn get_logs_and_transactions(
         let optional_receipt = log
             .transaction_hash
             .and_then(|txn| transaction_receipts_by_hash.get(&txn).cloned());
+
         let value = EthereumTrigger::Log(LogRef::FullLog(Arc::new(log), optional_receipt));
         log_triggers.push(value);
     }
@@ -2109,13 +2608,13 @@ async fn get_logs_and_transactions(
 /// Tries to retrive all transaction receipts for a set of transaction hashes.
 async fn get_transaction_receipts_for_transaction_hashes(
     adapter: &EthereumAdapter,
-    transaction_hashes_by_block: &HashMap<H256, HashSet<H256>>,
+    transaction_hashes_by_block: &HashMap<B256, HashSet<B256>>,
     subgraph_metrics: Arc<SubgraphEthRpcMetrics>,
-    logger: Logger,
-) -> Result<HashMap<H256, Arc<TransactionReceipt>>, anyhow::Error> {
+    logger: ProviderLogger,
+) -> Result<HashMap<B256, Arc<AnyTransactionReceiptBare>>, anyhow::Error> {
     use std::collections::hash_map::Entry::Vacant;
 
-    let mut receipts_by_hash: HashMap<H256, Arc<TransactionReceipt>> = HashMap::new();
+    let mut receipts_by_hash: HashMap<B256, Arc<AnyTransactionReceiptBare>> = HashMap::new();
 
     // Return early if input set is empty
     if transaction_hashes_by_block.is_empty() {
@@ -2124,20 +2623,22 @@ async fn get_transaction_receipts_for_transaction_hashes(
 
     // Keep a record of all unique transaction hashes for which we'll request receipts. We will
     // later use this to check if we have collected the receipts from all required transactions.
-    let mut unique_transaction_hashes: HashSet<&H256> = HashSet::new();
+    let mut unique_transaction_hashes: HashSet<&B256> = HashSet::new();
 
     // Request transaction receipts concurrently
     let receipt_futures = FuturesUnordered::new();
 
-    let web3 = Arc::clone(&adapter.web3);
+    let alloy = Arc::clone(&adapter.alloy);
     for (block_hash, transaction_hashes) in transaction_hashes_by_block {
         for transaction_hash in transaction_hashes {
             unique_transaction_hashes.insert(transaction_hash);
             let receipt_future = fetch_transaction_receipt_with_retry(
-                web3.cheap_clone(),
+                alloy.cheap_clone(),
                 *transaction_hash,
                 *block_hash,
                 logger.cheap_clone(),
+                adapter.settings.request_retries,
+                adapter.settings.json_rpc_timeout,
             );
             receipt_futures.push(receipt_future)
         }
@@ -2191,24 +2692,28 @@ mod tests {
 
     use crate::trigger::{EthereumBlockTriggerType, EthereumTrigger};
 
-    use super::{parse_block_triggers, EthereumBlock, EthereumBlockFilter, EthereumBlockWithCalls};
+    use super::{
+        EthereumBlock, EthereumBlockFilter, EthereumBlockWithCalls,
+        block_trigger_types_from_intervals, check_block_receipt_support, parse_block_triggers,
+    };
     use graph::blockchain::BlockPtr;
-    use graph::prelude::ethabi::ethereum_types::U64;
-    use graph::prelude::web3::types::{Address, Block, Bytes, H256};
-    use graph::prelude::EthereumCall;
+    use graph::components::ethereum::AnyNetworkBare;
+    use graph::prelude::alloy::primitives::{Address, B256, Bytes};
+    use graph::prelude::alloy::providers::ProviderBuilder;
+    use graph::prelude::alloy::providers::mock::Asserter;
+    use graph::prelude::{EthereumCall, LightEthereumBlock, create_minimal_block_for_test};
+    use jsonrpc_core::serde_json::{self, Value};
     use std::collections::HashSet;
     use std::iter::FromIterator;
     use std::sync::Arc;
 
     #[test]
     fn parse_block_triggers_every_block() {
+        let block = create_minimal_block_for_test(2, hash(2));
+
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(Block {
-                    hash: Some(hash(2)),
-                    number: Some(U64::from(2)),
-                    ..Default::default()
-                }),
+                block: Arc::new(LightEthereumBlock::new(block)),
                 ..Default::default()
             },
             calls: Some(vec![EthereumCall {
@@ -2238,15 +2743,121 @@ mod tests {
         );
     }
 
+    #[graph::test]
+    async fn test_check_block_receipts_support() {
+        let json_receipts = r#"[{
+            "blockHash": "0x23f785604642e91613881fc3c9d16740ee416e340fd36f3fa2239f203d68fd33",
+            "blockNumber": "0x12f7f81",
+            "contractAddress": null,
+            "cumulativeGasUsed": "0x26f66",
+            "effectiveGasPrice": "0x140a1bd03",
+            "from": "0x56fc0708725a65ebb633efdaec931c0600a9face",
+            "gasUsed": "0x26f66",
+            "logs": [],
+            "logsBloom": "0x00000000010000000000000000000000000000000000000000000000040000000000000000000000000008000000000002000000080020000000040000000000000000000000000808000008000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000010000800000000000000000000000000000000000000000000010000000000000000000000000000000000200000000000000000000000000000000000002000000008000000000002000000000000000000000000000000000400000000000000000000000000200000000000000010000000000000000000000000000000000000000000",
+            "status": "0x1",
+            "to": "0x51c72848c68a965f66fa7a88855f9f7784502a7f",
+            "transactionHash": "0xabfe9e82d71c843a91251fd1272b0dd80bc0b8d94661e3a42c7bb9e7f55789cf",
+            "transactionIndex": "0x0",
+            "type": "0x2"
+        }]"#;
+
+        let json_empty = r#"[]"#;
+
+        // Helper function to run a single test case
+        async fn run_test_case(
+            json_response: &str,
+            expected_err: Option<&str>,
+            supports_eip_1898: bool,
+            call_only: bool,
+        ) -> Result<(), anyhow::Error> {
+            let json_value: Value = serde_json::from_str(json_response).unwrap();
+
+            let asserter = Asserter::new();
+            let provider = ProviderBuilder::<_, _, AnyNetworkBare>::default()
+                .network::<AnyNetworkBare>()
+                .connect_mocked_client(asserter.clone());
+
+            asserter.push_success(&json_value);
+
+            let result = check_block_receipt_support(
+                Arc::new(provider),
+                B256::ZERO,
+                supports_eip_1898,
+                call_only,
+            )
+            .await;
+
+            match expected_err {
+                Some(err_msg) => match result {
+                    Ok(_) => panic!("Expected error but got Ok"),
+                    Err(e) => {
+                        assert!(e.to_string().contains(err_msg));
+                    }
+                },
+                None => match result {
+                    Ok(_) => (),
+                    Err(e) => {
+                        eprintln!("Error: {}", e);
+                        panic!("Unexpected error: {}", e);
+                    }
+                },
+            }
+            Ok(())
+        }
+
+        // Test case 1: Valid block receipts
+        run_test_case(json_receipts, None, true, false)
+            .await
+            .unwrap();
+
+        // Test case 2: Empty block receipts
+        run_test_case(json_empty, Some("Block receipts are empty"), true, false)
+            .await
+            .unwrap();
+
+        // Test case 3: Null response
+        run_test_case("null", Some("Block receipts are empty"), true, false)
+            .await
+            .unwrap();
+
+        // Test case 3: Simulating an RPC error
+        // Note: In the context of this test, we cannot directly simulate an RPC error.
+        // Instead, we simulate a response that would cause a decoding error, such as an unexpected key("error").
+        // The function should handle this as an error case.
+        run_test_case(
+            r#"{"error":"RPC Error"}"#,
+            Some("Error fetching block receipts:"),
+            true,
+            false,
+        )
+        .await
+        .unwrap();
+
+        // Test case 5: Does not support EIP-1898
+        run_test_case(
+            json_receipts,
+            Some("Provider does not support EIP 1898"),
+            false,
+            false,
+        )
+        .await
+        .unwrap();
+
+        // Test case 5: Does not support Call only adapters
+        run_test_case(json_receipts, Some("Provider is call-only"), true, true)
+            .await
+            .unwrap();
+    }
+
     #[test]
     fn parse_block_triggers_specific_call_not_found() {
+        let block = create_minimal_block_for_test(2, hash(2));
+
+        #[allow(unreachable_code)]
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(Block {
-                    hash: Some(hash(2)),
-                    number: Some(U64::from(2)),
-                    ..Default::default()
-                }),
+                block: Arc::new(LightEthereumBlock::new(block)),
                 ..Default::default()
             },
             calls: Some(vec![EthereumCall {
@@ -2272,13 +2883,12 @@ mod tests {
 
     #[test]
     fn parse_block_triggers_specific_call_found() {
+        let block = create_minimal_block_for_test(2, hash(2));
+
+        #[allow(unreachable_code)]
         let block = EthereumBlockWithCalls {
             ethereum_block: EthereumBlock {
-                block: Arc::new(Block {
-                    hash: Some(hash(2)),
-                    number: Some(U64::from(2)),
-                    ..Default::default()
-                }),
+                block: Arc::new(LightEthereumBlock::new(block)),
                 ..Default::default()
             },
             calls: Some(vec![EthereumCall {
@@ -2305,12 +2915,121 @@ mod tests {
         );
     }
 
+    #[test]
+    fn block_trigger_types_once_only() {
+        let intervals = HashSet::from_iter(vec![(100, 0)]);
+
+        assert_eq!(
+            vec![EthereumBlockTriggerType::Start],
+            block_trigger_types_from_intervals(100, &intervals),
+            "once rule fires Start at start_block"
+        );
+        assert_eq!(
+            Vec::<EthereumBlockTriggerType>::new(),
+            block_trigger_types_from_intervals(99, &intervals),
+            "once rule does not fire before start_block"
+        );
+        assert_eq!(
+            Vec::<EthereumBlockTriggerType>::new(),
+            block_trigger_types_from_intervals(101, &intervals),
+            "once rule does not fire after start_block"
+        );
+    }
+
+    #[test]
+    fn block_trigger_types_polling_only() {
+        let intervals = HashSet::from_iter(vec![(100, 10)]);
+
+        assert_eq!(
+            vec![EthereumBlockTriggerType::End],
+            block_trigger_types_from_intervals(100, &intervals),
+            "polling rule fires End at start_block"
+        );
+        assert_eq!(
+            vec![EthereumBlockTriggerType::End],
+            block_trigger_types_from_intervals(110, &intervals),
+            "polling rule fires End at start_block + interval"
+        );
+        assert_eq!(
+            Vec::<EthereumBlockTriggerType>::new(),
+            block_trigger_types_from_intervals(105, &intervals),
+            "polling rule does not fire off-interval"
+        );
+        assert_eq!(
+            Vec::<EthereumBlockTriggerType>::new(),
+            block_trigger_types_from_intervals(90, &intervals),
+            "polling rule does not fire before start_block"
+        );
+    }
+
+    #[test]
+    fn block_trigger_types_once_and_polling_same_start_block() {
+        // A single data source with both a `once` handler and a `polling` handler
+        // contributes both entries at its start_block. Both must fire at start_block.
+        let intervals = HashSet::from_iter(vec![(100, 0), (100, 10)]);
+
+        assert_eq!(
+            vec![
+                EthereumBlockTriggerType::Start,
+                EthereumBlockTriggerType::End,
+            ],
+            block_trigger_types_from_intervals(100, &intervals),
+            "both Start and End should fire when once and polling rules share start_block"
+        );
+        assert_eq!(
+            vec![EthereumBlockTriggerType::End],
+            block_trigger_types_from_intervals(110, &intervals),
+            "only polling fires at later interval matches"
+        );
+    }
+
+    #[test]
+    fn block_trigger_types_cross_datasource_collision() {
+        // Two data sources: DS-A with once at 100, DS-B with polling every 10 from 50.
+        // Block 100 satisfies DS-A's once rule and also (100-50) % 10 == 0, so both fire.
+        let intervals = HashSet::from_iter(vec![(100, 0), (50, 10)]);
+
+        assert_eq!(
+            vec![
+                EthereumBlockTriggerType::Start,
+                EthereumBlockTriggerType::End,
+            ],
+            block_trigger_types_from_intervals(100, &intervals),
+            "both triggers fire when a once rule and an unrelated polling rule collide"
+        );
+        assert_eq!(
+            vec![EthereumBlockTriggerType::End],
+            block_trigger_types_from_intervals(60, &intervals),
+            "only polling fires at a block where only the polling rule matches"
+        );
+    }
+
+    #[test]
+    fn block_trigger_types_no_match() {
+        let intervals = HashSet::from_iter(vec![(100, 0), (100, 10)]);
+        assert_eq!(
+            Vec::<EthereumBlockTriggerType>::new(),
+            block_trigger_types_from_intervals(99, &intervals),
+            "no triggers when block matches neither rule"
+        );
+    }
+
+    #[test]
+    fn block_trigger_types_empty_intervals() {
+        let intervals: HashSet<(i32, i32)> = HashSet::new();
+        assert_eq!(
+            Vec::<EthereumBlockTriggerType>::new(),
+            block_trigger_types_from_intervals(100, &intervals),
+            "empty intervals yields no triggers"
+        );
+    }
+
     fn address(id: u64) -> Address {
-        Address::from_low_u64_be(id)
+        Address::left_padding_from(&id.to_be_bytes())
     }
 
-    fn hash(id: u8) -> H256 {
-        H256::from([id; 32])
+    fn hash(id: u8) -> B256 {
+        B256::from_slice(&[id; 32])
     }
 
     fn bytes(value: Vec<u8>) -> Bytes {
diff --git a/chain/ethereum/src/ingestor.rs b/chain/ethereum/src/ingestor.rs
index 94c8c6a7d55..dcbcc42c6f8 100644
--- a/chain/ethereum/src/ingestor.rs
+++ b/chain/ethereum/src/ingestor.rs
@@ -1,10 +1,19 @@
-use crate::{chain::BlockFinality, EthereumAdapter, EthereumAdapterTrait, ENV_VARS};
+use crate::{ENV_VARS, chain::BlockFinality};
+use crate::{EthereumAdapter, EthereumAdapterTrait as _};
+use async_trait::async_trait;
+use futures::future::select_ok;
+use graph::blockchain::BlockchainKind;
+use graph::blockchain::client::ChainClient;
+use graph::components::network_provider::ChainName;
+use graph::prelude::alloy::primitives::B256;
+use graph::slog::o;
+use graph::util::backoff::ExponentialBackoff;
 use graph::{
     blockchain::{BlockHash, BlockIngestor, BlockPtr, IngestorError},
     cheap_clone::CheapClone,
     prelude::{
-        async_trait, error, ethabi::ethereum_types::H256, info, tokio, trace, warn, ChainStore,
-        Error, EthereumBlockWithCalls, Future01CompatExt, LogCode, Logger,
+        ChainStore, Error, EthereumBlockWithCalls, LogCode, Logger, debug, error, info, tokio,
+        trace, warn,
     },
 };
 use std::{sync::Arc, time::Duration};
@@ -12,33 +21,37 @@ use std::{sync::Arc, time::Duration};
 pub struct PollingBlockIngestor {
     logger: Logger,
     ancestor_count: i32,
-    eth_adapter: Arc<EthereumAdapter>,
+    chain_client: Arc<ChainClient<crate::chain::Chain>>,
     chain_store: Arc<dyn ChainStore>,
     polling_interval: Duration,
-    network_name: String,
+    network_name: ChainName,
 }
 
 impl PollingBlockIngestor {
     pub fn new(
         logger: Logger,
         ancestor_count: i32,
-        eth_adapter: Arc<EthereumAdapter>,
+        chain_client: Arc<ChainClient<crate::chain::Chain>>,
         chain_store: Arc<dyn ChainStore>,
         polling_interval: Duration,
-        network_name: String,
+        network_name: ChainName,
     ) -> Result<PollingBlockIngestor, Error> {
         Ok(PollingBlockIngestor {
             logger,
             ancestor_count,
-            eth_adapter,
+            chain_client,
             chain_store,
             polling_interval,
             network_name,
         })
     }
 
-    fn cleanup_cached_blocks(&self) {
-        match self.chain_store.cleanup_cached_blocks(self.ancestor_count) {
+    async fn cleanup_cached_blocks(&self) {
+        match self
+            .chain_store
+            .cleanup_cached_blocks(self.ancestor_count)
+            .await
+        {
             Ok(Some((min_block, count))) => {
                 if count > 0 {
                     info!(
@@ -58,8 +71,12 @@ impl PollingBlockIngestor {
         }
     }
 
-    async fn do_poll(&self) -> Result<(), IngestorError> {
-        trace!(self.logger, "BlockIngestor::do_poll");
+    async fn do_poll(
+        &self,
+        logger: &Logger,
+        eth_adapter: Arc<EthereumAdapter>,
+    ) -> Result<(), IngestorError> {
+        trace!(&logger, "BlockIngestor::do_poll");
 
         // Get chain head ptr from store
         let head_block_ptr_opt = self.chain_store.cheap_clone().chain_head_ptr().await?;
@@ -67,7 +84,7 @@ impl PollingBlockIngestor {
         // To check if there is a new block or not, fetch only the block header since that's cheaper
         // than the full block. This is worthwhile because most of the time there won't be a new
         // block, as we expect the poll interval to be much shorter than the block time.
-        let latest_block = self.latest_block().await?;
+        let latest_block = self.latest_block(logger, &eth_adapter).await?;
 
         if let Some(head_block) = head_block_ptr_opt.as_ref() {
             // If latest block matches head block in store, nothing needs to be done
@@ -79,7 +96,7 @@ impl PollingBlockIngestor {
                 // An ingestor might wait or move forward, but it never
                 // wavers and goes back. More seriously, this keeps us from
                 // later trying to ingest a block with the same number again
-                warn!(self.logger,
+                warn!(&logger,
                     "Provider went backwards - ignoring this latest block";
                     "current_block_head" => head_block.number,
                     "latest_block_head" => latest_block.number);
@@ -91,7 +108,7 @@ impl PollingBlockIngestor {
         match head_block_ptr_opt {
             None => {
                 info!(
-                    self.logger,
+                    &logger,
                     "Downloading latest blocks from Ethereum, this may take a few minutes..."
                 );
             }
@@ -107,7 +124,7 @@ impl PollingBlockIngestor {
                 };
                 if distance > 0 {
                     info!(
-                        self.logger,
+                    &logger,
                         "Syncing {} blocks from Ethereum",
                         blocks_needed;
                         "current_block_head" => head_number,
@@ -124,7 +141,9 @@ impl PollingBlockIngestor {
         // Might be a no-op if latest block is one that we have seen.
         // ingest_blocks will return a (potentially incomplete) list of blocks that are
         // missing.
-        let mut missing_block_hash = self.ingest_block(&latest_block.hash).await?;
+        let mut missing_block_hash = self
+            .ingest_block(logger, &eth_adapter, &latest_block.hash)
+            .await?;
 
         // Repeatedly fetch missing parent blocks, and ingest them.
         // ingest_blocks will continue to tell us about more missing parent
@@ -145,29 +164,25 @@ impl PollingBlockIngestor {
         //   iteration will have at most block number N-1.
         // - Therefore, the loop will iterate at most ancestor_count times.
         while let Some(hash) = missing_block_hash {
-            missing_block_hash = self.ingest_block(&hash).await?;
+            missing_block_hash = self.ingest_block(logger, &eth_adapter, &hash).await?;
         }
         Ok(())
     }
 
     async fn ingest_block(
         &self,
+        logger: &Logger,
+        eth_adapter: &Arc<EthereumAdapter>,
         block_hash: &BlockHash,
     ) -> Result<Option<BlockHash>, IngestorError> {
-        // TODO: H256::from_slice can panic
-        let block_hash = H256::from_slice(block_hash.as_slice());
+        let block_hash = B256::from_slice(block_hash.as_slice());
 
         // Get the fully populated block
-        let block = self
-            .eth_adapter
-            .block_by_hash(&self.logger, block_hash)
-            .compat()
+        let block = eth_adapter
+            .block_by_hash(logger, block_hash)
             .await?
             .ok_or(IngestorError::BlockUnavailable(block_hash))?;
-        let ethereum_block = self
-            .eth_adapter
-            .load_full_block(&self.logger, block)
-            .await?;
+        let ethereum_block = eth_adapter.load_full_block(logger, block).await?;
 
         // We need something that implements `Block` to store the block; the
         // store does not care whether the block is final or not
@@ -187,44 +202,428 @@ impl PollingBlockIngestor {
             .await
             .map(|missing| missing.map(|h256| h256.into()))
             .map_err(|e| {
-                error!(self.logger, "failed to update chain head");
+                error!(logger, "failed to update chain head");
                 IngestorError::Unknown(e)
             })
     }
 
-    async fn latest_block(&self) -> Result<BlockPtr, IngestorError> {
-        self.eth_adapter
-            .latest_block_header(&self.logger)
-            .compat()
-            .await
-            .map(|block| block.into())
+    async fn latest_block(
+        &self,
+        logger: &Logger,
+        eth_adapter: &Arc<EthereumAdapter>,
+    ) -> Result<BlockPtr, IngestorError> {
+        eth_adapter.latest_block_ptr(logger).await
+    }
+
+    /// Executes one polling iteration. On failure delegates to `on_poll_failure` for
+    /// probe+switch logic.
+    async fn poll_once(
+        &self,
+        providers: &[Arc<EthereumAdapter>],
+        current_provider: &mut Option<String>,
+    ) {
+        // Resolve by name; resets to first provider if the tracked one left the list.
+        let eth_adapter = resolve_provider(providers, current_provider, &self.logger).clone();
+        // Pin the name so the next iteration knows which provider is active.
+        let provider_name = eth_adapter.provider().to_string();
+        let logger = self.logger.new(o!("provider" => provider_name.clone()));
+        *current_provider = Some(provider_name);
+
+        if let Err(err) = self.do_poll(&logger, eth_adapter).await {
+            error!(logger, "Trying again after block polling failed: {}", err);
+            on_poll_failure(providers, current_provider, &self.logger).await;
+        }
+    }
+}
+
+/// Returns the currently-tracked provider from `providers`.
+///
+/// If the tracked provider is no longer in the list (it became invalid and was removed by
+/// `ProviderManager`), logs a warning, resets the state, and returns the first available
+/// provider.
+fn resolve_provider<'a, A: crate::EthereumAdapterTrait>(
+    providers: &'a [Arc<A>],
+    current_provider: &mut Option<String>,
+    logger: &Logger,
+) -> &'a Arc<A> {
+    if let Some(name) = current_provider.as_ref() {
+        if let Some(found) = providers.iter().find(|p| p.provider() == name) {
+            return found;
+        }
+        warn!(
+            logger,
+            "Current RPC provider is no longer available, resetting to first provider";
+            "provider" => name,
+        );
+        *current_provider = None;
+    }
+    &providers[0]
+}
+
+async fn on_poll_failure<A: crate::EthereumAdapterTrait>(
+    providers: &[Arc<A>],
+    current_provider: &mut Option<String>,
+    logger: &Logger,
+) {
+    if providers.len() <= 1 {
+        return;
+    }
+
+    let current_name = match current_provider.as_ref() {
+        Some(name) => name.clone(),
+        None => return,
+    };
+
+    // Probe the current provider before trying alternatives. do_poll() can fail for
+    // reasons unrelated to RPC availability (e.g. DB errors from chain_head_ptr or
+    // attempt_chain_head_update, or a BlockUnavailable from a chain reorg). All of
+    // these surface as IngestorError::Unknown, indistinguishable from an RPC failure
+    // at the match level. If the current provider responds to eth_blockNumber, the
+    // failure was not caused by provider unavailability — switching cannot help.
+    let current = providers.iter().find(|p| p.provider() == current_name);
+    if let Some(current) = current
+        && current.is_reachable().await
+    {
+        return;
+    }
+
+    // Probe all alternatives in parallel; switch to the first that responds.
+    let futs = providers
+        .iter()
+        .filter(|p| p.provider() != current_name)
+        .map(|p| {
+            let name = p.provider().to_string();
+            debug!(logger, "Trying RPC provider"; "provider" => &name);
+            Box::pin(async move {
+                if p.is_reachable().await {
+                    Ok(name)
+                } else {
+                    Err(())
+                }
+            })
+        });
+
+    match select_ok(futs).await {
+        Ok((next_name, _)) => {
+            warn!(
+                logger,
+                "Switching RPC provider for block ingestor";
+                "from" => &current_name,
+                "to" => &next_name,
+            );
+            *current_provider = Some(next_name);
+        }
+        Err(_) => {
+            warn!(
+                logger,
+                "All RPC providers unreachable, continuing on current provider";
+                "provider" => &current_name,
+            );
+        }
     }
 }
 
 #[async_trait]
 impl BlockIngestor for PollingBlockIngestor {
     async fn run(self: Box<Self>) {
+        let mut backoff =
+            ExponentialBackoff::new(Duration::from_millis(250), Duration::from_secs(30));
+        // Name of the provider currently in use. `None` until the first poll.
+        let mut current_provider: Option<String> = None;
+
         loop {
-            match self.do_poll().await {
-                // Some polls will fail due to transient issues
-                Err(err) => {
-                    error!(
-                        self.logger,
-                        "Trying again after block polling failed: {}", err
-                    );
-                }
-                Ok(()) => (),
+            let providers = self
+                .chain_client
+                .rpc()
+                .expect("PollingBlockIngestor is only created for RPC chains")
+                .all_cheapest()
+                .await;
+
+            if providers.is_empty() {
+                error!(self.logger, "No RPC providers available for block ingestor");
+                backoff.sleep_async().await;
+                continue;
             }
+            backoff.reset();
+
+            self.poll_once(&providers, &mut current_provider).await;
 
             if ENV_VARS.cleanup_blocks {
-                self.cleanup_cached_blocks()
+                self.cleanup_cached_blocks().await;
             }
 
             tokio::time::sleep(self.polling_interval).await;
         }
     }
 
-    fn network_name(&self) -> String {
+    fn network_name(&self) -> ChainName {
         self.network_name.clone()
     }
+
+    fn kind(&self) -> BlockchainKind {
+        BlockchainKind::Ethereum
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::on_poll_failure;
+    use super::*;
+    use crate::adapter::{
+        ContractCallError, EthereumAdapter as EthereumAdapterTrait, EthereumRpcError,
+    };
+    use async_trait::async_trait;
+    use graph::blockchain::{BlockPtr, ChainIdentifier};
+    use graph::components::ethereum::AnyBlock;
+    use graph::components::ethereum::LightEthereumBlock;
+    use graph::data::store::ethereum::call;
+    use graph::data_source::common::ContractCall;
+    use graph::prelude::alloy::primitives::{Address, B256, Bytes, U256};
+    use graph::prelude::{BlockNumber, Error, EthereumCallCache, Logger};
+    use graph::slog::Discard;
+    use std::collections::HashSet;
+    use std::sync::Arc;
+
+    struct MockEthAdapter {
+        provider_name: String,
+        reachable: bool,
+    }
+
+    impl MockEthAdapter {
+        fn new(name: &str, reachable: bool) -> Arc<Self> {
+            Arc::new(Self {
+                provider_name: name.to_string(),
+                reachable,
+            })
+        }
+    }
+
+    #[async_trait]
+    impl EthereumAdapterTrait for MockEthAdapter {
+        fn provider(&self) -> &str {
+            &self.provider_name
+        }
+
+        async fn is_reachable(&self) -> bool {
+            self.reachable
+        }
+
+        async fn net_identifiers(&self) -> Result<ChainIdentifier, Error> {
+            unimplemented!()
+        }
+        async fn latest_block_ptr(
+            &self,
+            _: &Logger,
+        ) -> Result<BlockPtr, graph::blockchain::IngestorError> {
+            unimplemented!()
+        }
+        async fn load_blocks(
+            &self,
+            _: Logger,
+            _: Arc<dyn graph::prelude::ChainStore>,
+            _: HashSet<B256>,
+        ) -> Result<Vec<Arc<LightEthereumBlock>>, Error> {
+            unimplemented!()
+        }
+        async fn block_by_hash(&self, _: &Logger, _: B256) -> Result<Option<AnyBlock>, Error> {
+            unimplemented!()
+        }
+        async fn block_by_number(
+            &self,
+            _: &Logger,
+            _: BlockNumber,
+        ) -> Result<Option<AnyBlock>, Error> {
+            unimplemented!()
+        }
+        async fn load_full_block(
+            &self,
+            _: &Logger,
+            _: AnyBlock,
+        ) -> Result<graph::prelude::EthereumBlock, graph::blockchain::IngestorError> {
+            unimplemented!()
+        }
+        async fn next_existing_ptr_to_number(
+            &self,
+            _: &Logger,
+            _: BlockNumber,
+        ) -> Result<BlockPtr, Error> {
+            unimplemented!()
+        }
+        async fn contract_call(
+            &self,
+            _: &Logger,
+            _: &ContractCall,
+            _: Arc<dyn EthereumCallCache>,
+        ) -> Result<(Option<Vec<graph::abi::DynSolValue>>, call::Source), ContractCallError>
+        {
+            unimplemented!()
+        }
+        async fn contract_calls(
+            &self,
+            _: &Logger,
+            _: &[&ContractCall],
+            _: Arc<dyn EthereumCallCache>,
+        ) -> Result<Vec<(Option<Vec<graph::abi::DynSolValue>>, call::Source)>, ContractCallError>
+        {
+            unimplemented!()
+        }
+        async fn get_balance(
+            &self,
+            _: &Logger,
+            _: Address,
+            _: BlockPtr,
+        ) -> Result<U256, EthereumRpcError> {
+            unimplemented!()
+        }
+        async fn get_code(
+            &self,
+            _: &Logger,
+            _: Address,
+            _: BlockPtr,
+        ) -> Result<Bytes, EthereumRpcError> {
+            unimplemented!()
+        }
+    }
+
+    fn discard_logger() -> Logger {
+        Logger::root(Discard, o!())
+    }
+
+    #[test]
+    fn test_current_provider_unavailable_resets_to_first() {
+        // p0 left the validated list; only p1 and p2 remain (p1 is now at index 0).
+        let providers: Vec<Arc<MockEthAdapter>> = vec![
+            MockEthAdapter::new("p1", true),
+            MockEthAdapter::new("p2", true),
+        ];
+        let mut current_provider = Some("p0".to_string());
+        let resolved = resolve_provider(&providers, &mut current_provider, &discard_logger());
+        assert_eq!(resolved.provider(), "p1");
+        assert_eq!(current_provider, None);
+    }
+
+    #[tokio::test]
+    async fn test_current_reachable_no_switch() {
+        // Current provider is reachable: on_poll_failure should return early without
+        // switching, even if alternatives are also reachable.
+        let providers: Vec<Arc<MockEthAdapter>> = vec![
+            MockEthAdapter::new("p0", true),
+            MockEthAdapter::new("p1", true),
+        ];
+        let mut current_provider = Some("p0".to_string());
+        on_poll_failure(&providers, &mut current_provider, &discard_logger()).await;
+        assert_eq!(current_provider, Some("p0".to_string()));
+    }
+
+    #[tokio::test]
+    async fn test_successful_probe_switches_provider() {
+        let providers: Vec<Arc<MockEthAdapter>> = vec![
+            MockEthAdapter::new("p0", false),
+            MockEthAdapter::new("p1", true),
+        ];
+        let mut current_provider = Some("p0".to_string());
+        on_poll_failure(&providers, &mut current_provider, &discard_logger()).await;
+        assert_eq!(current_provider, Some("p1".to_string()));
+    }
+
+    #[tokio::test]
+    async fn test_all_unreachable_stays_on_current() {
+        let providers: Vec<Arc<MockEthAdapter>> = vec![
+            MockEthAdapter::new("p0", false),
+            MockEthAdapter::new("p1", false),
+        ];
+        let mut current_provider = Some("p0".to_string());
+        on_poll_failure(&providers, &mut current_provider, &discard_logger()).await;
+        assert_eq!(current_provider, Some("p0".to_string()));
+    }
+
+    #[tokio::test]
+    async fn test_single_provider_no_switch() {
+        let providers: Vec<Arc<MockEthAdapter>> = vec![MockEthAdapter::new("p0", true)];
+        let mut current_provider = Some("p0".to_string());
+        on_poll_failure(&providers, &mut current_provider, &discard_logger()).await;
+        assert_eq!(current_provider, Some("p0".to_string()));
+    }
+
+    // --- Provider-list churn tests ---
+    //
+    // These tests simulate the state carried across loop iterations where
+    // all_cheapest() returns a different subset each time.
+
+    /// Current provider survives a list shrink; its index shifts but identity is preserved.
+    ///
+    /// Before: [p0, p1, p2], active = p1 (index 1)
+    /// After:  [p1, p2],     active = p1 (index 0)
+    ///
+    /// With index-based tracking this would silently move to p2. Name-based tracking
+    /// must keep us on p1.
+    #[test]
+    fn test_list_shrinks_current_provider_index_remaps() {
+        let providers: Vec<Arc<MockEthAdapter>> = vec![
+            MockEthAdapter::new("p1", true),
+            MockEthAdapter::new("p2", true),
+        ];
+        let mut current_provider = Some("p1".to_string());
+        let resolved = resolve_provider(&providers, &mut current_provider, &discard_logger());
+        // p1 is now at index 0 — must not drift to p2
+        assert_eq!(resolved.provider(), "p1");
+        assert_eq!(current_provider, Some("p1".to_string()));
+    }
+
+    /// After failing over to p1, p1 itself disappears from the validated list in the
+    /// next iteration. The ingestor must fall back to the first available provider (p0).
+    ///
+    /// Iteration 1: [p0(unreachable), p1(reachable)] — p0 fails, switch to p1
+    /// Iteration 2: [p0(reachable), p2(reachable)]   — p1 gone, reset to p0
+    #[tokio::test]
+    async fn test_failover_target_then_disappears_resets_to_first() {
+        let logger = discard_logger();
+
+        // Iteration 1: p0 fails, switch to p1.
+        let providers_iter1: Vec<Arc<MockEthAdapter>> = vec![
+            MockEthAdapter::new("p0", false),
+            MockEthAdapter::new("p1", true),
+        ];
+        let mut current_provider = Some("p0".to_string());
+        on_poll_failure(&providers_iter1, &mut current_provider, &logger).await;
+        assert_eq!(current_provider, Some("p1".to_string()));
+
+        // Iteration 2: p1 has dropped from the validated list.
+        let providers_iter2: Vec<Arc<MockEthAdapter>> = vec![
+            MockEthAdapter::new("p0", true),
+            MockEthAdapter::new("p2", true),
+        ];
+        let resolved = resolve_provider(&providers_iter2, &mut current_provider, &logger);
+        assert_eq!(resolved.provider(), "p0"); // reset to first
+        assert_eq!(current_provider, None);
+    }
+
+    /// After failing over to p1, the original provider p0 reappears in the list.
+    /// The ingestor must stay on p1 — there is no proactive return to p0.
+    ///
+    /// Iteration 1: [p0(unreachable), p1(reachable)] — switch to p1
+    /// Iteration 2: [p0(reachable), p1(reachable)]   — p0 is back; must stay on p1
+    #[tokio::test]
+    async fn test_original_provider_reappears_no_involuntary_return() {
+        let logger = discard_logger();
+
+        // Iteration 1: switch to p1.
+        let providers_iter1: Vec<Arc<MockEthAdapter>> = vec![
+            MockEthAdapter::new("p0", false),
+            MockEthAdapter::new("p1", true),
+        ];
+        let mut current_provider = Some("p0".to_string());
+        on_poll_failure(&providers_iter1, &mut current_provider, &logger).await;
+        assert_eq!(current_provider, Some("p1".to_string()));
+
+        // Iteration 2: p0 is back in the validated list alongside p1.
+        let providers_iter2: Vec<Arc<MockEthAdapter>> = vec![
+            MockEthAdapter::new("p0", true),
+            MockEthAdapter::new("p1", true),
+        ];
+        let resolved = resolve_provider(&providers_iter2, &mut current_provider, &logger);
+        // Must resolve to p1, not drift back to p0.
+        assert_eq!(resolved.provider(), "p1");
+        assert_eq!(current_provider, Some("p1".to_string()));
+    }
 }
diff --git a/chain/ethereum/src/lib.rs b/chain/ethereum/src/lib.rs
index cc9c24e79a4..b21eb4717ae 100644
--- a/chain/ethereum/src/lib.rs
+++ b/chain/ethereum/src/lib.rs
@@ -1,22 +1,29 @@
 mod adapter;
+mod buffered_call_cache;
+mod call_helper;
 mod capabilities;
 pub mod codec;
 mod data_source;
 mod env;
 mod ethereum_adapter;
 mod ingestor;
+mod polling_block_stream;
 pub mod runtime;
 mod transport;
 
 pub use self::capabilities::NodeCapabilities;
 pub use self::ethereum_adapter::EthereumAdapter;
 pub use self::runtime::RuntimeAdapter;
-pub use self::transport::Transport;
+pub use self::transport::{Compression, Transport};
 pub use env::ENV_VARS;
 
+pub use buffered_call_cache::BufferedCallCache;
+
 // ETHDEP: These concrete types should probably not be exposed.
 pub use data_source::{
-    BlockHandlerFilter, DataSource, DataSourceTemplate, Mapping, MappingABI, TemplateSource,
+    BlockHandlerFilter, DataSource, DataSourceTemplate, Mapping, MappingBlockHandler,
+    MappingCallHandler, TemplateSource, UnresolvedDataSource, UnresolvedDataSourceTemplate,
+    UnresolvedMapping, UnresolvedMappingEventHandler,
 };
 
 pub mod chain;
@@ -25,11 +32,10 @@ pub mod network;
 pub mod trigger;
 
 pub use crate::adapter::{
-    EthereumAdapter as EthereumAdapterTrait, EthereumContractCall, EthereumContractCallError,
-    ProviderEthRpcMetrics, SubgraphEthRpcMetrics, TriggerFilter,
+    ContractCallError, EthereumAdapter as EthereumAdapterTrait, ProviderEthRpcMetrics,
+    SubgraphEthRpcMetrics, TriggerFilter,
 };
 pub use crate::chain::Chain;
-pub use crate::network::EthereumNetworks;
 pub use graph::blockchain::BlockIngestor;
 
 #[cfg(test)]
diff --git a/chain/ethereum/src/network.rs b/chain/ethereum/src/network.rs
index 747a55e8886..ad9cd0a83c0 100644
--- a/chain/ethereum/src/network.rs
+++ b/chain/ethereum/src/network.rs
@@ -1,19 +1,23 @@
 use anyhow::{anyhow, bail};
-use graph::cheap_clone::CheapClone;
+use async_trait::async_trait;
+use graph::blockchain::ChainIdentifier;
+use graph::components::network_provider::ChainName;
+use graph::components::network_provider::NetworkDetails;
+use graph::components::network_provider::ProviderManager;
+use graph::components::network_provider::ProviderName;
 use graph::endpoint::EndpointMetrics;
 use graph::firehose::{AvailableCapacity, SubgraphLimit};
 use graph::prelude::rand::seq::IteratorRandom;
 use graph::prelude::rand::{self, Rng};
-use std::cmp::Ordering;
-use std::collections::HashMap;
+use itertools::Itertools;
 use std::sync::Arc;
 
 pub use graph::impl_slog_value;
 use graph::prelude::Error;
 
+use crate::EthereumAdapter;
 use crate::adapter::EthereumAdapter as _;
 use crate::capabilities::NodeCapabilities;
-use crate::EthereumAdapter;
 
 pub const DEFAULT_ADAPTER_ERROR_RETEST_PERCENT: f64 = 0.2;
 
@@ -29,7 +33,37 @@ pub struct EthereumNetworkAdapter {
     limit: SubgraphLimit,
 }
 
+#[async_trait]
+impl NetworkDetails for EthereumNetworkAdapter {
+    fn provider_name(&self) -> ProviderName {
+        self.adapter.provider().into()
+    }
+
+    async fn chain_identifier(&self) -> Result<ChainIdentifier, Error> {
+        self.adapter.net_identifiers().await
+    }
+
+    async fn provides_extended_blocks(&self) -> Result<bool, Error> {
+        Ok(true)
+    }
+}
+
 impl EthereumNetworkAdapter {
+    pub fn new(
+        endpoint_metrics: Arc<EndpointMetrics>,
+        capabilities: NodeCapabilities,
+        adapter: Arc<EthereumAdapter>,
+        limit: SubgraphLimit,
+    ) -> Self {
+        Self {
+            endpoint_metrics,
+            capabilities,
+            adapter,
+            limit,
+        }
+    }
+
+    #[cfg(debug_assertions)]
     fn is_call_only(&self) -> bool {
         self.adapter.is_call_only()
     }
@@ -48,64 +82,130 @@ impl EthereumNetworkAdapter {
 
 #[derive(Debug, Clone)]
 pub struct EthereumNetworkAdapters {
-    pub adapters: Vec<EthereumNetworkAdapter>,
+    chain_id: ChainName,
+    manager: ProviderManager<EthereumNetworkAdapter>,
     call_only_adapters: Vec<EthereumNetworkAdapter>,
     // Percentage of request that should be used to retest errored adapters.
     retest_percent: f64,
 }
 
-impl Default for EthereumNetworkAdapters {
-    fn default() -> Self {
-        Self::new(None)
-    }
-}
-
 impl EthereumNetworkAdapters {
-    pub fn new(retest_percent: Option<f64>) -> Self {
+    pub fn empty_for_testing() -> Self {
         Self {
-            adapters: vec![],
+            chain_id: "".into(),
+            manager: ProviderManager::default(),
             call_only_adapters: vec![],
-            retest_percent: retest_percent.unwrap_or(DEFAULT_ADAPTER_ERROR_RETEST_PERCENT),
+            retest_percent: DEFAULT_ADAPTER_ERROR_RETEST_PERCENT,
         }
     }
 
-    pub fn push_adapter(&mut self, adapter: EthereumNetworkAdapter) {
-        if adapter.is_call_only() {
-            self.call_only_adapters.push(adapter);
-        } else {
-            self.adapters.push(adapter);
+    #[cfg(debug_assertions)]
+    pub async fn for_testing(
+        mut adapters: Vec<EthereumNetworkAdapter>,
+        call_only: Vec<EthereumNetworkAdapter>,
+    ) -> Self {
+        use std::cmp::Ordering;
+
+        use graph::components::network_provider::ProviderCheckStrategy;
+        use graph::slog::{Discard, Logger, o};
+
+        let chain_id: ChainName = "testing".into();
+        adapters.sort_by(|a, b| {
+            a.capabilities
+                .partial_cmp(&b.capabilities)
+                .unwrap_or(Ordering::Equal)
+        });
+
+        let provider = ProviderManager::new(
+            Logger::root(Discard, o!()),
+            vec![(chain_id.clone(), adapters)],
+            ProviderCheckStrategy::MarkAsValid,
+        );
+
+        Self::new(chain_id, provider, call_only, None)
+    }
+
+    pub fn new(
+        chain_id: ChainName,
+        manager: ProviderManager<EthereumNetworkAdapter>,
+        call_only_adapters: Vec<EthereumNetworkAdapter>,
+        retest_percent: Option<f64>,
+    ) -> Self {
+        #[cfg(debug_assertions)]
+        call_only_adapters.iter().for_each(|a| {
+            a.is_call_only();
+        });
+
+        Self {
+            chain_id,
+            manager,
+            call_only_adapters,
+            retest_percent: retest_percent.unwrap_or(DEFAULT_ADAPTER_ERROR_RETEST_PERCENT),
         }
     }
-    pub fn all_cheapest_with(
-        &self,
+
+    fn available_with_capabilities<'a>(
+        input: Vec<&'a EthereumNetworkAdapter>,
         required_capabilities: &NodeCapabilities,
-    ) -> impl Iterator<Item = &EthereumNetworkAdapter> + '_ {
-        let cheapest_sufficient_capability = self
-            .adapters
+    ) -> impl Iterator<Item = &'a EthereumNetworkAdapter> + 'a {
+        let cheapest_sufficient_capability = input
             .iter()
             .find(|adapter| &adapter.capabilities >= required_capabilities)
             .map(|adapter| &adapter.capabilities);
 
-        self.adapters
-            .iter()
+        input
+            .into_iter()
             .filter(move |adapter| Some(&adapter.capabilities) == cheapest_sufficient_capability)
             .filter(|adapter| adapter.get_capacity() > AvailableCapacity::Unavailable)
     }
 
-    pub fn cheapest_with(
+    /// returns all the available adapters that meet the required capabilities
+    /// if no adapters are available at the time or none that meet the capabilities then
+    /// an empty iterator is returned.
+    pub async fn all_cheapest_with(
         &self,
         required_capabilities: &NodeCapabilities,
+    ) -> impl Iterator<Item = &EthereumNetworkAdapter> + '_ {
+        let all = self
+            .manager
+            .providers(&self.chain_id)
+            .await
+            .map(|adapters| adapters.collect_vec())
+            .unwrap_or_default();
+
+        Self::available_with_capabilities(all, required_capabilities)
+    }
+
+    // get all the adapters, don't trigger the ProviderManager's validations because we want
+    // this function to remain sync. If no adapters are available an empty iterator is returned.
+    pub(crate) fn all_unverified_cheapest_with(
+        &self,
+        required_capabilities: &NodeCapabilities,
+    ) -> impl Iterator<Item = &EthereumNetworkAdapter> + '_ {
+        let all = self
+            .manager
+            .providers_unchecked(&self.chain_id)
+            .collect_vec();
+
+        Self::available_with_capabilities(all, required_capabilities)
+    }
+
+    // handle adapter selection from a list, implements the availability checking with an abstracted
+    // source of the adapter list.
+    fn cheapest_from(
+        input: Vec<&EthereumNetworkAdapter>,
+        required_capabilities: &NodeCapabilities,
+        retest_percent: f64,
     ) -> Result<Arc<EthereumAdapter>, Error> {
-        let retest_rng: f64 = (&mut rand::thread_rng()).gen();
-        let cheapest = self
-            .all_cheapest_with(required_capabilities)
-            .choose_multiple(&mut rand::thread_rng(), 3);
+        let retest_rng: f64 = rand::rng().random();
+
+        let cheapest = input.into_iter().choose_multiple(&mut rand::rng(), 3);
         let cheapest = cheapest.iter();
 
         // If request falls below the retest threshold, use this request to try and
         // reset the failed adapter. If a request succeeds the adapter will be more
         // likely to be selected afterwards.
-        if retest_rng < self.retest_percent {
+        if retest_rng < retest_percent {
             cheapest.max_by_key(|adapter| adapter.current_error_count())
         } else {
             // The assumption here is that most RPC endpoints will not have limits
@@ -123,19 +223,54 @@ impl EthereumNetworkAdapters {
         ))
     }
 
-    pub fn cheapest(&self) -> Option<Arc<EthereumAdapter>> {
+    pub(crate) fn unverified_cheapest_with(
+        &self,
+        required_capabilities: &NodeCapabilities,
+    ) -> Result<Arc<EthereumAdapter>, Error> {
+        let cheapest = self.all_unverified_cheapest_with(required_capabilities);
+
+        Self::cheapest_from(
+            cheapest.choose_multiple(&mut rand::rng(), 3),
+            required_capabilities,
+            self.retest_percent,
+        )
+    }
+
+    /// This is the public entry point and should always use verified adapters
+    pub async fn cheapest_with(
+        &self,
+        required_capabilities: &NodeCapabilities,
+    ) -> Result<Arc<EthereumAdapter>, Error> {
+        let cheapest = self
+            .all_cheapest_with(required_capabilities)
+            .await
+            .choose_multiple(&mut rand::rng(), 3);
+
+        Self::cheapest_from(cheapest, required_capabilities, self.retest_percent)
+    }
+
+    /// Returns all validated providers. Unvalidated providers are excluded.
+    pub async fn all_cheapest(&self) -> Vec<Arc<EthereumAdapter>> {
+        self.manager
+            .providers(&self.chain_id)
+            .await
+            .map(|adapters| adapters.map(|a| a.adapter.clone()).collect())
+            .unwrap_or_default()
+    }
+
+    pub async fn cheapest(&self) -> Option<Arc<EthereumAdapter>> {
         // EthereumAdapters are sorted by their NodeCapabilities when the EthereumNetworks
         // struct is instantiated so they do not need to be sorted here
-        self.adapters
-            .first()
+        self.manager
+            .providers(&self.chain_id)
+            .await
+            .map(|mut adapters| adapters.next())
+            .unwrap_or_default()
             .map(|ethereum_network_adapter| ethereum_network_adapter.adapter.clone())
     }
 
-    pub fn remove(&mut self, provider: &str) {
-        self.adapters
-            .retain(|adapter| adapter.adapter.provider() != provider);
-    }
-
+    /// call_or_cheapest will bypass ProviderManagers' validation in order to remain non async.
+    /// ideally this should only be called for already validated providers.
     pub fn call_or_cheapest(
         &self,
         capabilities: Option<&NodeCapabilities>,
@@ -145,11 +280,13 @@ impl EthereumNetworkAdapters {
         // so we will ignore this error and return whatever comes out of `cheapest_with`
         match self.call_only_adapter() {
             Ok(Some(adapter)) => Ok(adapter),
-            _ => self.cheapest_with(capabilities.unwrap_or(&NodeCapabilities {
-                // Archive is required for call_only
-                archive: true,
-                traces: false,
-            })),
+            _ => {
+                self.unverified_cheapest_with(capabilities.unwrap_or(&NodeCapabilities {
+                    // Archive is required for call_only
+                    archive: true,
+                    traces: false,
+                }))
+            }
         }
     }
 
@@ -179,115 +316,33 @@ impl EthereumNetworkAdapters {
     }
 }
 
-#[derive(Clone)]
-pub struct EthereumNetworks {
-    pub metrics: Arc<EndpointMetrics>,
-    pub networks: HashMap<String, EthereumNetworkAdapters>,
-}
-
-impl EthereumNetworks {
-    pub fn new(metrics: Arc<EndpointMetrics>) -> EthereumNetworks {
-        EthereumNetworks {
-            networks: HashMap::new(),
-            metrics,
-        }
-    }
-
-    pub fn insert_empty(&mut self, name: String) {
-        self.networks.entry(name).or_default();
-    }
-
-    pub fn insert(
-        &mut self,
-        name: String,
-        capabilities: NodeCapabilities,
-        adapter: Arc<EthereumAdapter>,
-        limit: SubgraphLimit,
-    ) {
-        let network_adapters = self.networks.entry(name).or_default();
-
-        network_adapters.push_adapter(EthereumNetworkAdapter {
-            capabilities,
-            adapter,
-            limit,
-            endpoint_metrics: self.metrics.cheap_clone(),
-        });
-    }
-
-    pub fn remove(&mut self, name: &str, provider: &str) {
-        if let Some(adapters) = self.networks.get_mut(name) {
-            adapters.remove(provider);
-        }
-    }
-
-    pub fn extend(&mut self, other_networks: EthereumNetworks) {
-        self.networks.extend(other_networks.networks);
-    }
-
-    pub fn flatten(&self) -> Vec<(String, NodeCapabilities, Arc<EthereumAdapter>)> {
-        self.networks
-            .iter()
-            .flat_map(|(network_name, network_adapters)| {
-                network_adapters
-                    .adapters
-                    .iter()
-                    .map(move |network_adapter| {
-                        (
-                            network_name.clone(),
-                            network_adapter.capabilities,
-                            network_adapter.adapter.clone(),
-                        )
-                    })
-            })
-            .collect()
-    }
-
-    pub fn sort(&mut self) {
-        for adapters in self.networks.values_mut() {
-            adapters.adapters.sort_by(|a, b| {
-                a.capabilities
-                    .partial_cmp(&b.capabilities)
-                    // We can't define a total ordering over node capabilities,
-                    // so incomparable items are considered equal and end up
-                    // near each other.
-                    .unwrap_or(Ordering::Equal)
-            })
-        }
-    }
-
-    pub fn adapter_with_capabilities(
-        &self,
-        network_name: String,
-        requirements: &NodeCapabilities,
-    ) -> Result<Arc<EthereumAdapter>, Error> {
-        self.networks
-            .get(&network_name)
-            .ok_or(anyhow!("network not supported: {}", &network_name))
-            .and_then(|adapters| adapters.cheapest_with(requirements))
-    }
-}
-
 #[cfg(test)]
 mod tests {
+    use graph::cheap_clone::CheapClone;
+    use graph::components::network_provider::ProviderCheckStrategy;
+    use graph::components::network_provider::ProviderManager;
+    use graph::components::network_provider::ProviderName;
+    use graph::data::value::Word;
+
+    use graph::http::HeaderMap;
     use graph::{
-        endpoint::{EndpointMetrics, Provider},
+        endpoint::EndpointMetrics,
         firehose::SubgraphLimit,
         prelude::MetricsRegistry,
-        slog::{o, Discard, Logger},
-        tokio,
+        slog::{Discard, Logger, o},
         url::Url,
     };
-    use http::HeaderMap;
     use std::sync::Arc;
-    use uuid::Uuid;
 
     use crate::{
-        EthereumAdapter, EthereumAdapterTrait, EthereumNetworks, ProviderEthRpcMetrics, Transport,
+        Compression, EthereumAdapter, EthereumAdapterTrait, ProviderEthRpcMetrics, Transport,
+        chain::ChainSettings,
     };
 
     use super::{EthereumNetworkAdapter, EthereumNetworkAdapters, NodeCapabilities};
 
     #[test]
+    #[allow(clippy::neg_cmp_op_on_partial_ord)]
     fn ethereum_capabilities_comparison() {
         let archive = NodeCapabilities {
             archive: true,
@@ -311,41 +366,40 @@ mod tests {
         };
 
         // Test all real combinations of capability comparisons
-        assert_eq!(false, &full >= &archive);
-        assert_eq!(false, &full >= &traces);
-        assert_eq!(false, &full >= &archive_traces);
-        assert_eq!(true, &full >= &full);
-        assert_eq!(false, &full >= &full_traces);
-
-        assert_eq!(true, &archive >= &archive);
-        assert_eq!(false, &archive >= &traces);
-        assert_eq!(false, &archive >= &archive_traces);
-        assert_eq!(true, &archive >= &full);
-        assert_eq!(false, &archive >= &full_traces);
-
-        assert_eq!(false, &traces >= &archive);
-        assert_eq!(true, &traces >= &traces);
-        assert_eq!(false, &traces >= &archive_traces);
-        assert_eq!(true, &traces >= &full);
-        assert_eq!(true, &traces >= &full_traces);
-
-        assert_eq!(true, &archive_traces >= &archive);
-        assert_eq!(true, &archive_traces >= &traces);
-        assert_eq!(true, &archive_traces >= &archive_traces);
-        assert_eq!(true, &archive_traces >= &full);
-        assert_eq!(true, &archive_traces >= &full_traces);
-
-        assert_eq!(false, &full_traces >= &archive);
-        assert_eq!(true, &full_traces >= &traces);
-        assert_eq!(false, &full_traces >= &archive_traces);
-        assert_eq!(true, &full_traces >= &full);
-        assert_eq!(true, &full_traces >= &full_traces);
+        assert!(!(full >= archive));
+        assert!(!(full >= traces));
+        assert!(!(full >= archive_traces));
+        assert!(full >= full);
+        assert!(!(full >= full_traces));
+
+        assert!(archive >= archive);
+        assert!(!(archive >= traces));
+        assert!(!(archive >= archive_traces));
+        assert!(archive >= full);
+        assert!(!(archive >= full_traces));
+
+        assert!(!(traces >= archive));
+        assert!(traces >= traces);
+        assert!(!(traces >= archive_traces));
+        assert!(traces >= full);
+        assert!(traces >= full_traces);
+
+        assert!(archive_traces >= archive);
+        assert!(archive_traces >= traces);
+        assert!(archive_traces >= archive_traces);
+        assert!(archive_traces >= full);
+        assert!(archive_traces >= full_traces);
+
+        assert!(!(full_traces >= archive));
+        assert!(full_traces >= traces);
+        assert!(!(full_traces >= archive_traces));
+        assert!(full_traces >= full);
+        assert!(full_traces >= full_traces);
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn adapter_selector_selects_eth_call() {
         let metrics = Arc::new(EndpointMetrics::mock());
-        let chain = "mainnet".to_string();
         let logger = graph::log::logger(true);
         let mock_registry = Arc::new(MetricsRegistry::mock());
         let transport = Transport::new_rpc(
@@ -353,6 +407,8 @@ mod tests {
             HeaderMap::new(),
             metrics.clone(),
             "",
+            false,
+            Compression::None,
         );
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
 
@@ -364,6 +420,7 @@ mod tests {
                 provider_metrics.clone(),
                 true,
                 true,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
@@ -376,44 +433,47 @@ mod tests {
                 provider_metrics.clone(),
                 true,
                 false,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
 
-        let mut adapters = {
-            let mut ethereum_networks = EthereumNetworks::new(metrics);
-            ethereum_networks.insert(
-                chain.clone(),
+        let mut adapters: EthereumNetworkAdapters = EthereumNetworkAdapters::for_testing(
+            vec![EthereumNetworkAdapter::new(
+                metrics.cheap_clone(),
                 NodeCapabilities {
                     archive: true,
                     traces: false,
                 },
-                eth_call_adapter.clone(),
+                eth_adapter.clone(),
                 SubgraphLimit::Limit(3),
-            );
-            ethereum_networks.insert(
-                chain.clone(),
+            )],
+            vec![EthereumNetworkAdapter::new(
+                metrics.cheap_clone(),
                 NodeCapabilities {
                     archive: true,
                     traces: false,
                 },
-                eth_adapter.clone(),
+                eth_call_adapter.clone(),
                 SubgraphLimit::Limit(3),
-            );
-            ethereum_networks.networks.get(&chain).unwrap().clone()
-        };
+            )],
+        )
+        .await;
         // one reference above and one inside adapters struct
         assert_eq!(Arc::strong_count(&eth_call_adapter), 2);
         assert_eq!(Arc::strong_count(&eth_adapter), 2);
 
         {
             // Not Found
-            assert!(adapters
-                .cheapest_with(&NodeCapabilities {
-                    archive: false,
-                    traces: true,
-                })
-                .is_err());
+            assert!(
+                adapters
+                    .cheapest_with(&NodeCapabilities {
+                        archive: false,
+                        traces: true,
+                    })
+                    .await
+                    .is_err()
+            );
 
             // Check cheapest is not call only
             let adapter = adapters
@@ -421,18 +481,16 @@ mod tests {
                     archive: true,
                     traces: false,
                 })
+                .await
                 .unwrap();
-            assert_eq!(adapter.is_call_only(), false);
+            assert!(!adapter.is_call_only());
         }
 
         // Check limits
         {
             let adapter = adapters.call_or_cheapest(None).unwrap();
             assert!(adapter.is_call_only());
-            assert_eq!(
-                adapters.call_or_cheapest(None).unwrap().is_call_only(),
-                false
-            );
+            assert!(!adapters.call_or_cheapest(None).unwrap().is_call_only());
         }
 
         // Check empty falls back to call only
@@ -444,14 +502,13 @@ mod tests {
                     traces: false,
                 }))
                 .unwrap();
-            assert_eq!(adapter.is_call_only(), false);
+            assert!(!adapter.is_call_only());
         }
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn adapter_selector_unlimited() {
         let metrics = Arc::new(EndpointMetrics::mock());
-        let chain = "mainnet".to_string();
         let logger = graph::log::logger(true);
         let mock_registry = Arc::new(MetricsRegistry::mock());
         let transport = Transport::new_rpc(
@@ -459,6 +516,8 @@ mod tests {
             HeaderMap::new(),
             metrics.clone(),
             "",
+            false,
+            Compression::None,
         );
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
 
@@ -470,6 +529,7 @@ mod tests {
                 provider_metrics.clone(),
                 true,
                 true,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
@@ -482,47 +542,48 @@ mod tests {
                 provider_metrics.clone(),
                 true,
                 false,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
 
-        let adapters = {
-            let mut ethereum_networks = EthereumNetworks::new(metrics);
-            ethereum_networks.insert(
-                chain.clone(),
+        let adapters: EthereumNetworkAdapters = EthereumNetworkAdapters::for_testing(
+            vec![EthereumNetworkAdapter::new(
+                metrics.cheap_clone(),
                 NodeCapabilities {
                     archive: true,
                     traces: false,
                 },
                 eth_call_adapter.clone(),
                 SubgraphLimit::Unlimited,
-            );
-            ethereum_networks.insert(
-                chain.clone(),
+            )],
+            vec![EthereumNetworkAdapter::new(
+                metrics.cheap_clone(),
                 NodeCapabilities {
                     archive: true,
                     traces: false,
                 },
                 eth_adapter.clone(),
-                SubgraphLimit::Limit(3),
-            );
-            ethereum_networks.networks.get(&chain).unwrap().clone()
-        };
+                SubgraphLimit::Limit(2),
+            )],
+        )
+        .await;
         // one reference above and one inside adapters struct
         assert_eq!(Arc::strong_count(&eth_call_adapter), 2);
         assert_eq!(Arc::strong_count(&eth_adapter), 2);
 
-        let keep: Vec<Arc<EthereumAdapter>> = vec![0; 10]
+        // verify that after all call_only were exhausted, we can still
+        // get normal adapters
+        let keep: Vec<Arc<EthereumAdapter>> = [0; 10]
             .iter()
             .map(|_| adapters.call_or_cheapest(None).unwrap())
             .collect();
-        assert_eq!(keep.iter().any(|a| !a.is_call_only()), false);
+        assert!(!keep.iter().any(|a| !a.is_call_only()));
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn adapter_selector_disable_call_only_fallback() {
         let metrics = Arc::new(EndpointMetrics::mock());
-        let chain = "mainnet".to_string();
         let logger = graph::log::logger(true);
         let mock_registry = Arc::new(MetricsRegistry::mock());
         let transport = Transport::new_rpc(
@@ -530,6 +591,8 @@ mod tests {
             HeaderMap::new(),
             metrics.clone(),
             "",
+            false,
+            Compression::None,
         );
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
 
@@ -541,6 +604,7 @@ mod tests {
                 provider_metrics.clone(),
                 true,
                 true,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
@@ -553,45 +617,41 @@ mod tests {
                 provider_metrics.clone(),
                 true,
                 false,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
 
-        let adapters = {
-            let mut ethereum_networks = EthereumNetworks::new(metrics);
-            ethereum_networks.insert(
-                chain.clone(),
+        let adapters: EthereumNetworkAdapters = EthereumNetworkAdapters::for_testing(
+            vec![EthereumNetworkAdapter::new(
+                metrics.cheap_clone(),
                 NodeCapabilities {
                     archive: true,
                     traces: false,
                 },
                 eth_call_adapter.clone(),
                 SubgraphLimit::Disabled,
-            );
-            ethereum_networks.insert(
-                chain.clone(),
+            )],
+            vec![EthereumNetworkAdapter::new(
+                metrics.cheap_clone(),
                 NodeCapabilities {
                     archive: true,
                     traces: false,
                 },
                 eth_adapter.clone(),
                 SubgraphLimit::Limit(3),
-            );
-            ethereum_networks.networks.get(&chain).unwrap().clone()
-        };
+            )],
+        )
+        .await;
         // one reference above and one inside adapters struct
         assert_eq!(Arc::strong_count(&eth_call_adapter), 2);
         assert_eq!(Arc::strong_count(&eth_adapter), 2);
-        assert_eq!(
-            adapters.call_or_cheapest(None).unwrap().is_call_only(),
-            false
-        );
+        assert!(!adapters.call_or_cheapest(None).unwrap().is_call_only());
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn adapter_selector_no_call_only_fallback() {
         let metrics = Arc::new(EndpointMetrics::mock());
-        let chain = "mainnet".to_string();
         let logger = graph::log::logger(true);
         let mock_registry = Arc::new(MetricsRegistry::mock());
         let transport = Transport::new_rpc(
@@ -599,6 +659,8 @@ mod tests {
             HeaderMap::new(),
             metrics.clone(),
             "",
+            false,
+            Compression::None,
         );
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
 
@@ -610,64 +672,59 @@ mod tests {
                 provider_metrics.clone(),
                 true,
                 false,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
 
-        let adapters = {
-            let mut ethereum_networks = EthereumNetworks::new(metrics);
-            ethereum_networks.insert(
-                chain.clone(),
+        let adapters: EthereumNetworkAdapters = EthereumNetworkAdapters::for_testing(
+            vec![EthereumNetworkAdapter::new(
+                metrics.cheap_clone(),
                 NodeCapabilities {
                     archive: true,
                     traces: false,
                 },
                 eth_adapter.clone(),
                 SubgraphLimit::Limit(3),
-            );
-            ethereum_networks.networks.get(&chain).unwrap().clone()
-        };
+            )],
+            vec![],
+        )
+        .await;
         // one reference above and one inside adapters struct
         assert_eq!(Arc::strong_count(&eth_adapter), 2);
-        assert_eq!(
-            adapters.call_or_cheapest(None).unwrap().is_call_only(),
-            false
-        );
+        assert!(!adapters.call_or_cheapest(None).unwrap().is_call_only());
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn eth_adapter_selection_multiple_adapters() {
         let logger = Logger::root(Discard, o!());
-        let unavailable_provider = Uuid::new_v4().to_string();
-        let error_provider = Uuid::new_v4().to_string();
-        let no_error_provider = Uuid::new_v4().to_string();
+        let unavailable_provider = "unavailable-provider";
+        let error_provider = "error-provider";
+        let no_error_provider = "no-error-provider";
 
         let mock_registry = Arc::new(MetricsRegistry::mock());
         let metrics = Arc::new(EndpointMetrics::new(
             logger,
-            &[
-                unavailable_provider.clone(),
-                error_provider.clone(),
-                no_error_provider.clone(),
-            ],
+            &[unavailable_provider, error_provider, no_error_provider],
             mock_registry.clone(),
         ));
         let logger = graph::log::logger(true);
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
+        let chain_id: Word = "chain_id".into();
 
-        let adapters = vec![
+        let adapters = [
             fake_adapter(
                 &logger,
-                &unavailable_provider,
+                unavailable_provider,
                 &provider_metrics,
                 &metrics,
                 false,
             )
             .await,
-            fake_adapter(&logger, &error_provider, &provider_metrics, &metrics, false).await,
+            fake_adapter(&logger, error_provider, &provider_metrics, &metrics, false).await,
             fake_adapter(
                 &logger,
-                &no_error_provider,
+                no_error_provider,
                 &provider_metrics,
                 &metrics,
                 false,
@@ -676,10 +733,11 @@ mod tests {
         ];
 
         // Set errors
-        metrics.report_for_test(&Provider::from(error_provider.clone()), false);
+        metrics.report_for_test(&ProviderName::from(error_provider), false);
+
+        let mut no_retest_adapters = vec![];
+        let mut always_retest_adapters = vec![];
 
-        let mut no_retest_adapters = EthereumNetworkAdapters::new(Some(0f64));
-        let mut always_retest_adapters = EthereumNetworkAdapters::new(Some(1f64));
         adapters.iter().cloned().for_each(|adapter| {
             let limit = if adapter.provider() == unavailable_provider {
                 SubgraphLimit::Disabled
@@ -687,7 +745,7 @@ mod tests {
                 SubgraphLimit::Unlimited
             };
 
-            no_retest_adapters.adapters.push(EthereumNetworkAdapter {
+            no_retest_adapters.push(EthereumNetworkAdapter {
                 endpoint_metrics: metrics.clone(),
                 capabilities: NodeCapabilities {
                     archive: true,
@@ -696,18 +754,35 @@ mod tests {
                 adapter: adapter.clone(),
                 limit: limit.clone(),
             });
-            always_retest_adapters
-                .adapters
-                .push(EthereumNetworkAdapter {
-                    endpoint_metrics: metrics.clone(),
-                    capabilities: NodeCapabilities {
-                        archive: true,
-                        traces: false,
-                    },
-                    adapter,
-                    limit,
-                });
+            always_retest_adapters.push(EthereumNetworkAdapter {
+                endpoint_metrics: metrics.clone(),
+                capabilities: NodeCapabilities {
+                    archive: true,
+                    traces: false,
+                },
+                adapter,
+                limit,
+            });
         });
+        let manager = ProviderManager::<EthereumNetworkAdapter>::new(
+            logger,
+            vec![(
+                chain_id.clone(),
+                no_retest_adapters
+                    .iter()
+                    .cloned()
+                    .chain(always_retest_adapters.iter().cloned())
+                    .collect(),
+            )]
+            .into_iter(),
+            ProviderCheckStrategy::MarkAsValid,
+        );
+
+        let no_retest_adapters =
+            EthereumNetworkAdapters::new(chain_id.clone(), manager.clone(), vec![], Some(0f64));
+
+        let always_retest_adapters =
+            EthereumNetworkAdapters::new(chain_id, manager.clone(), vec![], Some(1f64));
 
         assert_eq!(
             no_retest_adapters
@@ -715,6 +790,7 @@ mod tests {
                     archive: true,
                     traces: false,
                 })
+                .await
                 .unwrap()
                 .provider(),
             no_error_provider
@@ -725,89 +801,111 @@ mod tests {
                     archive: true,
                     traces: false,
                 })
+                .await
                 .unwrap()
                 .provider(),
             error_provider
         );
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn eth_adapter_selection_single_adapter() {
         let logger = Logger::root(Discard, o!());
-        let unavailable_provider = Uuid::new_v4().to_string();
-        let error_provider = Uuid::new_v4().to_string();
-        let no_error_provider = Uuid::new_v4().to_string();
+        let unavailable_provider = "unavailable-provider";
+        let error_provider = "error-provider";
+        let no_error_provider = "no-error-provider";
 
         let mock_registry = Arc::new(MetricsRegistry::mock());
         let metrics = Arc::new(EndpointMetrics::new(
             logger,
-            &[
-                unavailable_provider,
-                error_provider.clone(),
-                no_error_provider.clone(),
-            ],
+            &[unavailable_provider, error_provider, no_error_provider],
             mock_registry.clone(),
         ));
+        let chain_id: Word = "chain_id".into();
         let logger = graph::log::logger(true);
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
 
         // Set errors
-        metrics.report_for_test(&Provider::from(error_provider.clone()), false);
+        metrics.report_for_test(&ProviderName::from(error_provider), false);
 
-        let mut no_retest_adapters = EthereumNetworkAdapters::new(Some(0f64));
-        no_retest_adapters.adapters.push(EthereumNetworkAdapter {
+        let mut no_retest_adapters = vec![];
+        no_retest_adapters.push(EthereumNetworkAdapter {
             endpoint_metrics: metrics.clone(),
             capabilities: NodeCapabilities {
                 archive: true,
                 traces: false,
             },
-            adapter: fake_adapter(&logger, &error_provider, &provider_metrics, &metrics, false)
+            adapter: fake_adapter(&logger, error_provider, &provider_metrics, &metrics, false)
                 .await,
             limit: SubgraphLimit::Unlimited,
         });
+
+        let mut always_retest_adapters = vec![];
+        always_retest_adapters.push(EthereumNetworkAdapter {
+            endpoint_metrics: metrics.clone(),
+            capabilities: NodeCapabilities {
+                archive: true,
+                traces: false,
+            },
+            adapter: fake_adapter(
+                &logger,
+                no_error_provider,
+                &provider_metrics,
+                &metrics,
+                false,
+            )
+            .await,
+            limit: SubgraphLimit::Unlimited,
+        });
+        let manager = ProviderManager::<EthereumNetworkAdapter>::new(
+            logger.clone(),
+            always_retest_adapters
+                .iter()
+                .cloned()
+                .map(|a| (chain_id.clone(), vec![a])),
+            ProviderCheckStrategy::MarkAsValid,
+        );
+
+        let always_retest_adapters =
+            EthereumNetworkAdapters::new(chain_id.clone(), manager.clone(), vec![], Some(1f64));
+
         assert_eq!(
-            no_retest_adapters
+            always_retest_adapters
                 .cheapest_with(&NodeCapabilities {
                     archive: true,
                     traces: false,
                 })
+                .await
                 .unwrap()
                 .provider(),
-            error_provider
+            no_error_provider
         );
 
-        let mut always_retest_adapters = EthereumNetworkAdapters::new(Some(1f64));
-        always_retest_adapters
-            .adapters
-            .push(EthereumNetworkAdapter {
-                endpoint_metrics: metrics.clone(),
-                capabilities: NodeCapabilities {
-                    archive: true,
-                    traces: false,
-                },
-                adapter: fake_adapter(
-                    &logger,
-                    &no_error_provider,
-                    &provider_metrics,
-                    &metrics,
-                    false,
-                )
-                .await,
-                limit: SubgraphLimit::Unlimited,
-            });
+        let manager = ProviderManager::<EthereumNetworkAdapter>::new(
+            logger.clone(),
+            no_retest_adapters
+                .iter()
+                .cloned()
+                .map(|a| (chain_id.clone(), vec![a])),
+            ProviderCheckStrategy::MarkAsValid,
+        );
+
+        let no_retest_adapters =
+            EthereumNetworkAdapters::new(chain_id.clone(), manager, vec![], Some(0f64));
         assert_eq!(
-            always_retest_adapters
+            no_retest_adapters
                 .cheapest_with(&NodeCapabilities {
                     archive: true,
                     traces: false,
                 })
+                .await
                 .unwrap()
                 .provider(),
-            no_error_provider
+            error_provider
         );
 
-        let mut no_available_adapter = EthereumNetworkAdapters::default();
-        no_available_adapter.adapters.push(EthereumNetworkAdapter {
+        let mut no_available_adapter = vec![];
+        no_available_adapter.push(EthereumNetworkAdapter {
             endpoint_metrics: metrics.clone(),
             capabilities: NodeCapabilities {
                 archive: true,
@@ -815,7 +913,7 @@ mod tests {
             },
             adapter: fake_adapter(
                 &logger,
-                &no_error_provider,
+                no_error_provider,
                 &provider_metrics,
                 &metrics,
                 false,
@@ -823,10 +921,19 @@ mod tests {
             .await,
             limit: SubgraphLimit::Disabled,
         });
-        let res = no_available_adapter.cheapest_with(&NodeCapabilities {
-            archive: true,
-            traces: false,
-        });
+        let manager = ProviderManager::new(
+            logger,
+            vec![(chain_id.clone(), no_available_adapter.to_vec())].into_iter(),
+            ProviderCheckStrategy::MarkAsValid,
+        );
+
+        let no_available_adapter = EthereumNetworkAdapters::new(chain_id, manager, vec![], None);
+        let res = no_available_adapter
+            .cheapest_with(&NodeCapabilities {
+                archive: true,
+                traces: false,
+            })
+            .await;
         assert!(res.is_err(), "{:?}", res);
     }
 
@@ -838,10 +945,12 @@ mod tests {
         call_only: bool,
     ) -> Arc<EthereumAdapter> {
         let transport = Transport::new_rpc(
-            Url::parse(&"http://127.0.0.1").unwrap(),
+            Url::parse("http://127.0.0.1").unwrap(),
             HeaderMap::new(),
             endpoint_metrics.clone(),
             "",
+            false,
+            Compression::None,
         );
 
         Arc::new(
@@ -852,6 +961,7 @@ mod tests {
                 provider_metrics.clone(),
                 true,
                 call_only,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         )
diff --git a/graph/src/blockchain/polling_block_stream.rs b/chain/ethereum/src/polling_block_stream.rs
similarity index 84%
rename from graph/src/blockchain/polling_block_stream.rs
rename to chain/ethereum/src/polling_block_stream.rs
index a9c52294c18..339386207f1 100644
--- a/graph/src/blockchain/polling_block_stream.rs
+++ b/chain/ethereum/src/polling_block_stream.rs
@@ -1,5 +1,4 @@
-use anyhow::Error;
-use futures03::{stream::Stream, Future, FutureExt};
+use anyhow::{Error, anyhow};
 use std::cmp;
 use std::collections::VecDeque;
 use std::pin::Pin;
@@ -7,23 +6,24 @@ use std::sync::Arc;
 use std::task::{Context, Poll};
 use std::time::Duration;
 
-use super::block_stream::{
-    BlockStream, BlockStreamEvent, BlockWithTriggers, ChainHeadUpdateStream, FirehoseCursor,
-    TriggersAdapter, BUFFERED_BLOCK_STREAM_SIZE,
+use graph::blockchain::block_stream::{
+    BUFFERED_BLOCK_STREAM_SIZE, BlockStream, BlockStreamError, BlockStreamEvent, BlockWithTriggers,
+    ChainHeadUpdateStream, FirehoseCursor, TriggersAdapterWrapper,
 };
-use super::{Block, BlockPtr, Blockchain};
+use graph::blockchain::{Block, BlockPtr, TriggerFilterWrapper};
+use graph::futures03::{Future, FutureExt, stream::Stream};
+use graph::prelude::{BLOCK_NUMBER_MAX, DeploymentHash};
+use graph::slog::{Logger, info, trace, warn};
 
-use crate::components::store::BlockNumber;
-use crate::data::subgraph::UnifiedMappingApiVersion;
-use crate::prelude::*;
+use graph::components::store::BlockNumber;
+use graph::data::subgraph::UnifiedMappingApiVersion;
+
+use crate::Chain;
 
 // A high number here forces a slow start.
 const STARTING_PREVIOUS_TRIGGERS_PER_BLOCK: f64 = 1_000_000.0;
 
-enum BlockStreamState<C>
-where
-    C: Blockchain,
-{
+enum BlockStreamState {
     /// Starting or restarting reconciliation.
     ///
     /// Valid next states: Reconciliation
@@ -32,13 +32,13 @@ where
     /// The BlockStream is reconciling the subgraph store state with the chain store state.
     ///
     /// Valid next states: YieldingBlocks, Idle, BeginReconciliation (in case of revert)
-    Reconciliation(Pin<Box<dyn Future<Output = Result<NextBlocks<C>, Error>> + Send>>),
+    Reconciliation(Pin<Box<dyn Future<Output = Result<NextBlocks, Error>> + Send>>),
 
     /// The BlockStream is emitting blocks that must be processed in order to bring the subgraph
     /// store up to date with the chain store.
     ///
     /// Valid next states: BeginReconciliation
-    YieldingBlocks(Box<VecDeque<BlockWithTriggers<C>>>),
+    YieldingBlocks(VecDeque<BlockWithTriggers<Chain>>),
 
     /// The BlockStream experienced an error and is pausing before attempting to produce
     /// blocks again.
@@ -55,16 +55,13 @@ where
 
 /// A single next step to take in reconciling the state of the subgraph store with the state of the
 /// chain store.
-enum ReconciliationStep<C>
-where
-    C: Blockchain,
-{
+enum ReconciliationStep {
     /// Revert(to) the block the subgraph should be reverted to, so it becomes the new subgraph
     /// head.
     Revert(BlockPtr),
 
     /// Move forwards, processing one or more blocks. Second element is the block range size.
-    ProcessDescendantBlocks(Vec<BlockWithTriggers<C>>, BlockNumber),
+    ProcessDescendantBlocks(Vec<BlockWithTriggers<Chain>>, BlockNumber),
 
     /// This step is a no-op, but we need to check again for a next step.
     Retry,
@@ -74,18 +71,13 @@ where
     Done,
 }
 
-struct PollingBlockStreamContext<C>
-where
-    C: Blockchain,
-{
-    chain_store: Arc<dyn ChainStore>,
-    adapter: Arc<dyn TriggersAdapter<C>>,
-    node_id: NodeId,
+struct PollingBlockStreamContext {
+    adapter: Arc<TriggersAdapterWrapper<Chain>>,
     subgraph_id: DeploymentHash,
     // This is not really a block number, but the (unsigned) difference
     // between two block numbers
     reorg_threshold: BlockNumber,
-    filter: Arc<C::TriggerFilter>,
+    filter: Arc<TriggerFilterWrapper<Chain>>,
     start_blocks: Vec<BlockNumber>,
     logger: Logger,
     previous_triggers_per_block: f64,
@@ -98,12 +90,10 @@ where
     current_block: Option<BlockPtr>,
 }
 
-impl<C: Blockchain> Clone for PollingBlockStreamContext<C> {
+impl Clone for PollingBlockStreamContext {
     fn clone(&self) -> Self {
         Self {
-            chain_store: self.chain_store.cheap_clone(),
             adapter: self.adapter.clone(),
-            node_id: self.node_id.clone(),
             subgraph_id: self.subgraph_id.clone(),
             reorg_threshold: self.reorg_threshold,
             filter: self.filter.clone(),
@@ -119,37 +109,29 @@ impl<C: Blockchain> Clone for PollingBlockStreamContext<C> {
     }
 }
 
-pub struct PollingBlockStream<C: Blockchain> {
-    state: BlockStreamState<C>,
+pub struct PollingBlockStream {
+    state: BlockStreamState,
     consecutive_err_count: u32,
     chain_head_update_stream: ChainHeadUpdateStream,
-    ctx: PollingBlockStreamContext<C>,
+    ctx: PollingBlockStreamContext,
 }
 
 // This is the same as `ReconciliationStep` but without retries.
-enum NextBlocks<C>
-where
-    C: Blockchain,
-{
+enum NextBlocks {
     /// Blocks and range size
-    Blocks(VecDeque<BlockWithTriggers<C>>, BlockNumber),
+    Blocks(VecDeque<BlockWithTriggers<Chain>>, BlockNumber),
 
     // The payload is block the subgraph should be reverted to, so it becomes the new subgraph head.
     Revert(BlockPtr),
     Done,
 }
 
-impl<C> PollingBlockStream<C>
-where
-    C: Blockchain,
-{
+impl PollingBlockStream {
     pub fn new(
-        chain_store: Arc<dyn ChainStore>,
         chain_head_update_stream: ChainHeadUpdateStream,
-        adapter: Arc<dyn TriggersAdapter<C>>,
-        node_id: NodeId,
+        adapter: Arc<TriggersAdapterWrapper<Chain>>,
         subgraph_id: DeploymentHash,
-        filter: Arc<C::TriggerFilter>,
+        filter: Arc<TriggerFilterWrapper<Chain>>,
         start_blocks: Vec<BlockNumber>,
         reorg_threshold: BlockNumber,
         logger: Logger,
@@ -164,9 +146,7 @@ where
             chain_head_update_stream,
             ctx: PollingBlockStreamContext {
                 current_block: start_block,
-                chain_store,
                 adapter,
-                node_id,
                 subgraph_id,
                 reorg_threshold,
                 logger,
@@ -182,12 +162,9 @@ where
     }
 }
 
-impl<C> PollingBlockStreamContext<C>
-where
-    C: Blockchain,
-{
+impl PollingBlockStreamContext {
     /// Perform reconciliation steps until there are blocks to yield or we are up-to-date.
-    async fn next_blocks(&self) -> Result<NextBlocks<C>, Error> {
+    async fn next_blocks(&self) -> Result<NextBlocks, Error> {
         let ctx = self.clone();
 
         loop {
@@ -205,20 +182,20 @@ where
                     return Ok(NextBlocks::Done);
                 }
                 ReconciliationStep::Revert(parent_ptr) => {
-                    return Ok(NextBlocks::Revert(parent_ptr))
+                    return Ok(NextBlocks::Revert(parent_ptr));
                 }
             }
         }
     }
 
     /// Determine the next reconciliation step. Does not modify Store or ChainStore.
-    async fn get_next_step(&self) -> Result<ReconciliationStep<C>, Error> {
+    async fn get_next_step(&self) -> Result<ReconciliationStep, Error> {
         let ctx = self.clone();
         let start_blocks = self.start_blocks.clone();
         let max_block_range_size = self.max_block_range_size;
 
         // Get pointers from database for comparison
-        let head_ptr_opt = ctx.chain_store.chain_head_ptr().await?;
+        let head_ptr_opt = ctx.adapter.chain_head_ptr().await?;
         let subgraph_ptr = self.current_block.clone();
 
         // If chain head ptr is not set yet
@@ -247,10 +224,10 @@ where
 
         // Only continue if the subgraph block ptr is behind the head block ptr.
         // subgraph_ptr > head_ptr shouldn't happen, but if it does, it's safest to just stop.
-        if let Some(ptr) = &subgraph_ptr {
-            if ptr.number >= head_ptr.number {
-                return Ok(ReconciliationStep::Done);
-            }
+        if let Some(ptr) = &subgraph_ptr
+            && ptr.number >= head_ptr.number
+        {
+            return Ok(ReconciliationStep::Done);
         }
 
         // Subgraph ptr is behind head ptr.
@@ -363,22 +340,41 @@ where
             //   1000 triggers found, 2 per block, range_size = 1000 / 2 = 500
             let range_size_upper_limit =
                 max_block_range_size.min(ctx.previous_block_range_size * 10);
-            let range_size = if ctx.previous_triggers_per_block == 0.0 {
+            let target_range_size = if ctx.previous_triggers_per_block == 0.0 {
                 range_size_upper_limit
             } else {
                 (self.target_triggers_per_block_range as f64 / ctx.previous_triggers_per_block)
                     .max(1.0)
                     .min(range_size_upper_limit as f64) as BlockNumber
             };
-            let to = cmp::min(from + range_size - 1, to_limit);
+            let to = cmp::min(from + target_range_size - 1, to_limit);
 
             info!(
                 ctx.logger,
                 "Scanning blocks [{}, {}]", from, to;
-                "range_size" => range_size
+                "target_range_size" => target_range_size
             );
 
-            let blocks = self.adapter.scan_triggers(from, to, &self.filter).await?;
+            // Update with actually scanned range, to account for any skipped null blocks.
+            let (blocks, to) = self
+                .adapter
+                .scan_triggers(&self.logger, from, to, &self.filter)
+                .await?;
+            let range_size = to - from + 1;
+
+            // If the target block (`to`) is within the reorg threshold, indicating no non-null finalized blocks are
+            // greater than or equal to `to`, we retry later. This deferment allows the chain head to advance,
+            // ensuring the target block range becomes finalized. It effectively minimizes the risk of chain reorg
+            // affecting the processing by waiting for a more stable set of blocks.
+            if to > head_ptr.number - reorg_threshold {
+                return Ok(ReconciliationStep::Retry);
+            }
+
+            info!(
+                ctx.logger,
+                "Scanned blocks [{}, {}]", from, to;
+                "range_size" => range_size
+            );
 
             Ok(ReconciliationStep::ProcessDescendantBlocks(
                 blocks, range_size,
@@ -406,6 +402,7 @@ where
             // block number, and checking to see if the block we found matches the
             // subgraph_ptr.
 
+            #[allow(clippy::unnecessary_unwrap)]
             let subgraph_ptr =
                 subgraph_ptr.expect("subgraph block pointer should not be `None` here");
 
@@ -415,7 +412,10 @@ where
 
             // In principle this block should be in the store, but we have seen this error for deep
             // reorgs in ropsten.
-            let head_ancestor_opt = self.adapter.ancestor_block(head_ptr, offset).await?;
+            let head_ancestor_opt = self
+                .adapter
+                .ancestor_block(head_ptr, offset, Some(subgraph_ptr.hash.clone()))
+                .await?;
 
             match head_ancestor_opt {
                 None => {
@@ -427,6 +427,15 @@ where
                     Ok(ReconciliationStep::Retry)
                 }
                 Some(head_ancestor) => {
+                    // Check if there was an interceding skipped (null) block.
+                    if head_ancestor.number() != subgraph_ptr.number + 1 {
+                        warn!(
+                            ctx.logger,
+                            "skipped block detected: {}",
+                            subgraph_ptr.number + 1
+                        );
+                    }
+
                     // We stopped one block short, so we'll compare the parent hash to the
                     // subgraph ptr.
                     if head_ancestor.parent_hash().as_ref() == Some(&subgraph_ptr.hash) {
@@ -463,14 +472,14 @@ where
     }
 }
 
-impl<C: Blockchain> BlockStream<C> for PollingBlockStream<C> {
+impl BlockStream<Chain> for PollingBlockStream {
     fn buffer_size_hint(&self) -> usize {
         BUFFERED_BLOCK_STREAM_SIZE
     }
 }
 
-impl<C: Blockchain> Stream for PollingBlockStream<C> {
-    type Item = Result<BlockStreamEvent<C>, Error>;
+impl Stream for PollingBlockStream {
+    type Item = Result<BlockStreamEvent<Chain>, BlockStreamError>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         let result = loop {
@@ -503,15 +512,17 @@ impl<C: Blockchain> Stream for PollingBlockStream<C> {
                                     total_triggers as f64 / block_range_size as f64;
                                 self.ctx.previous_block_range_size = block_range_size;
                                 if total_triggers > 0 {
-                                    debug!(
+                                    info!(
                                         self.ctx.logger,
-                                        "Processing {} triggers", total_triggers
+                                        "Found {} triggers in {} blocks with a block range of {}",
+                                        total_triggers,
+                                        next_blocks.len(),
+                                        block_range_size
                                     );
                                 }
 
                                 // Switch to yielding state until next_blocks is depleted
-                                self.state =
-                                    BlockStreamState::YieldingBlocks(Box::new(next_blocks));
+                                self.state = BlockStreamState::YieldingBlocks(next_blocks);
 
                                 // Yield the first block in next_blocks
                                 continue;
@@ -558,7 +569,7 @@ impl<C: Blockchain> Stream for PollingBlockStream<C> {
                 }
 
                 // Yielding blocks from reconciliation process
-                BlockStreamState::YieldingBlocks(ref mut next_blocks) => {
+                BlockStreamState::YieldingBlocks(next_blocks) => {
                     match next_blocks.pop_front() {
                         // Yield one block
                         Some(next_block) => {
@@ -578,7 +589,7 @@ impl<C: Blockchain> Stream for PollingBlockStream<C> {
                 }
 
                 // Pausing after an error, before looking for more blocks
-                BlockStreamState::RetryAfterDelay(ref mut delay) => match delay.as_mut().poll(cx) {
+                BlockStreamState::RetryAfterDelay(delay) => match delay.as_mut().poll(cx) {
                     Poll::Ready(Ok(..)) | Poll::Ready(Err(_)) => {
                         self.state = BlockStreamState::BeginReconciliation;
                     }
@@ -599,8 +610,8 @@ impl<C: Blockchain> Stream for PollingBlockStream<C> {
                         // Chain head update stream ended
                         Poll::Ready(None) => {
                             // Should not happen
-                            return Poll::Ready(Some(Err(anyhow::anyhow!(
-                                "chain head update stream ended unexpectedly"
+                            return Poll::Ready(Some(Err(BlockStreamError::from(
+                                anyhow::anyhow!("chain head update stream ended unexpectedly"),
                             ))));
                         }
 
@@ -610,6 +621,6 @@ impl<C: Blockchain> Stream for PollingBlockStream<C> {
             }
         };
 
-        result
+        result.map_err(BlockStreamError::from)
     }
 }
diff --git a/chain/ethereum/src/protobuf/sf.ethereum.r#type.v2.rs b/chain/ethereum/src/protobuf/sf.ethereum.r#type.v2.rs
index 1e6b7841c8d..4c4d8be6c90 100644
--- a/chain/ethereum/src/protobuf/sf.ethereum.r#type.v2.rs
+++ b/chain/ethereum/src/protobuf/sf.ethereum.r#type.v2.rs
@@ -1,84 +1,179 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
+// This file is @generated by prost-build.
+/// Block is the representation of the tracing of a block in the Ethereum
+/// blockchain. A block is a collection of \[TransactionTrace\] that are grouped
+/// together and processed as an atomic unit. Each \[TransactionTrace\] is composed
+/// of a series of \[Call\] (a.k.a internal transactions) and there is also at
+/// least one call per transaction a.k.a the root call which essentially has the
+/// same parameters as the transaction itself (e.g. `from`, `to`, `gas`, `value`,
+/// etc.).
+///
+/// The exact tracing method used to build the block must be checked against
+/// \[DetailLevel\] field. There is two levels of details available, `BASE` and
+/// `EXTENDED`. The `BASE` level has been extracted using archive node RPC calls
+/// and will contain only the block header, transaction receipts and event logs.
+/// Refers to the Firehose service provider to know which blocks are offered on
+/// each network.
+///
+/// The `EXTENDED` level has been extracted using the Firehose tracer and all
+/// fields are available in this Protobuf.
+///
+/// The Ethereum block model is used across many chains which means that it
+/// happen that certain fields are not available in one chain but are available
+/// in another. Each field should be documented when necesssary if it's available
+/// on a subset of chains.
+///
+/// One major concept to get about the Block is the concept of 'ordinal'. The
+/// ordinal is a number that is used to globally order every element of execution
+/// that happened throughout the processing of the block like
+/// \[TransactionTracer\], \[Call\], \[Log\], \[BalanceChange\], \[StateChange\], etc.
+/// Element that have a start and end interval, \[Transaction\] and \[Call\], will
+/// have two ordinals: `begin_ordinal` and `end_ordinal`. Element that are
+/// executed as "point in time" \[Log\], \[BalanceChange\], \[StateChange\], etc. will
+/// have only one ordinal named `ordinal`. If you take all of the message in the
+/// Block that have an 'ordinal' field in an array and you sort each element
+/// against the `ordinal` field, you will get the exact order of execution of
+/// each element in the block.
+///
+/// All the 'ordinal' fields in a block are globally unique for the given block,
+/// it is **not** a chain-wide global ordering. Furthermore, caution must be take
+/// with reverted elements due to execution failure. For anything attached to a
+/// \[Call\] that has a `state_reverted` field set to `true`, the `ordinal` field
+/// is not reliable and should not be used to order the element against other
+/// elements in the block as those element might have 0 as the ordinal. Only
+/// successful calls have a reliable `ordinal` field.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Block {
-    #[prost(int32, tag = "1")]
-    pub ver: i32,
+    /// Hash is the block's hash.
     #[prost(bytes = "vec", tag = "2")]
     pub hash: ::prost::alloc::vec::Vec<u8>,
+    /// Number is the block's height at which this block was mined.
     #[prost(uint64, tag = "3")]
     pub number: u64,
+    /// Size is the size in bytes of the RLP encoding of the block according to Ethereum
+    /// rules.
     #[prost(uint64, tag = "4")]
     pub size: u64,
+    /// Header contain's the block's header information like its parent hash, the merkel root hash
+    /// and all other information the form a block.
     #[prost(message, optional, tag = "5")]
     pub header: ::core::option::Option<BlockHeader>,
-    /// Uncles represents block produced with a valid solution but were not actually choosen
+    /// Uncles represents block produced with a valid solution but were not actually chosen
     /// as the canonical block for the given height so they are mostly "forked" blocks.
     ///
     /// If the Block has been produced using the Proof of Stake consensus algorithm, this
     /// field will actually be always empty.
     #[prost(message, repeated, tag = "6")]
     pub uncles: ::prost::alloc::vec::Vec<BlockHeader>,
+    /// TransactionTraces hold the execute trace of all the transactions that were executed
+    /// in this block. In in there that you will find most of the Ethereum data model.
+    ///
+    /// They are ordered by the order of execution of the transaction in the block.
     #[prost(message, repeated, tag = "10")]
     pub transaction_traces: ::prost::alloc::vec::Vec<TransactionTrace>,
+    /// BalanceChanges here is the array of ETH transfer that happened at the block level
+    /// outside of the normal transaction flow of a block. The best example of this is mining
+    /// reward for the block mined, the transfer of ETH to the miner happens outside the normal
+    /// transaction flow of the chain and is recorded as a `BalanceChange` here since we cannot
+    /// attached it to any transaction.
+    ///
+    /// Only available in DetailLevel: EXTENDED
     #[prost(message, repeated, tag = "11")]
     pub balance_changes: ::prost::alloc::vec::Vec<BalanceChange>,
+    /// DetailLevel affects the data available in this block.
+    ///
+    /// ## DetailLevel_EXTENDED
+    ///
+    /// Describes the most complete block, with traces, balance changes, storage
+    /// changes. It is extracted during the execution of the block.
+    ///
+    /// ## DetailLevel_BASE
+    ///
+    /// Describes a block that contains only the block header, transaction receipts
+    /// and event logs: everything that can be extracted using the base JSON-RPC
+    /// interface
+    /// (<https://ethereum.org/en/developers/docs/apis/json-rpc/#json-rpc-methods>)
+    /// Furthermore, the eth_getTransactionReceipt call has been avoided because it
+    /// brings only minimal improvements at the cost of requiring an archive node
+    /// or a full node with complete transaction index.
+    #[prost(enumeration = "block::DetailLevel", tag = "12")]
+    pub detail_level: i32,
+    /// CodeChanges here is the array of smart code change that happened that happened at the block level
+    /// outside of the normal transaction flow of a block. Some Ethereum's fork like BSC and Polygon
+    /// has some capabilities to upgrade internal smart contracts used usually to track the validator
+    /// list.
+    ///
+    /// On hard fork, some procedure runs to upgrade the smart contract code to a new version. In those
+    /// network, a `CodeChange` for each modified smart contract on upgrade would be present here. Note
+    /// that this happen rarely, so the vast majority of block will have an empty list here.
+    ///
+    /// Only available in DetailLevel: EXTENDED
     #[prost(message, repeated, tag = "20")]
     pub code_changes: ::prost::alloc::vec::Vec<CodeChange>,
+    /// System calls are introduced in Cancun, along with blobs. They are executed outside of transactions but affect the state.
+    ///
+    /// Only available in DetailLevel: EXTENDED
+    #[prost(message, repeated, tag = "21")]
+    pub system_calls: ::prost::alloc::vec::Vec<Call>,
+    /// Withdrawals represents the list of validator balance withdrawals processed in this block.
+    /// Introduced in the Shanghai hard fork (EIP-4895).
+    ///
+    /// This field has been added because Geth blocks include withdrawals after Shanghai fork,
+    /// but our previous Firehose model didn't capture this data. Currently experimental -
+    /// NOT ready for production use yet as we validate the tracing implementation.
+    ///
+    /// Only available when Shanghai fork is active on the chain.
+    #[prost(message, repeated, tag = "22")]
+    pub withdrawals: ::prost::alloc::vec::Vec<Withdrawal>,
+    /// Ver represents that data model version of the block, it is used internally by Firehose on Ethereum
+    /// as a validation that we are reading the correct version.
+    #[prost(int32, tag = "1")]
+    pub ver: i32,
 }
-/// HeaderOnlyBlock is used to optimally unpack the \[Block\] structure (note the
-/// corresponding message number for the `header` field) while consuming less
-/// memory, when only the `header` is desired.
-///
-/// WARN: this is a client-side optimization pattern and should be moved in the
-/// consuming code.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct HeaderOnlyBlock {
-    #[prost(message, optional, tag = "5")]
-    pub header: ::core::option::Option<BlockHeader>,
-}
-/// BlockWithRefs is a lightweight block, with traces and transactions
-/// purged from the `block` within, and only.  It is used in transports
-/// to pass block data around.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockWithRefs {
-    #[prost(string, tag = "1")]
-    pub id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "2")]
-    pub block: ::core::option::Option<Block>,
-    #[prost(message, optional, tag = "3")]
-    pub transaction_trace_refs: ::core::option::Option<TransactionRefs>,
-    #[prost(bool, tag = "4")]
-    pub irreversible: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TransactionRefs {
-    #[prost(bytes = "vec", repeated, tag = "1")]
-    pub hashes: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct UnclesHeaders {
-    #[prost(message, repeated, tag = "1")]
-    pub uncles: ::prost::alloc::vec::Vec<BlockHeader>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockRef {
-    #[prost(bytes = "vec", tag = "1")]
-    pub hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(uint64, tag = "2")]
-    pub number: u64,
+/// Nested message and enum types in `Block`.
+pub mod block {
+    #[derive(
+        Clone,
+        Copy,
+        Debug,
+        PartialEq,
+        Eq,
+        Hash,
+        PartialOrd,
+        Ord,
+        ::prost::Enumeration
+    )]
+    #[repr(i32)]
+    pub enum DetailLevel {
+        DetaillevelExtended = 0,
+        /// DETAILLEVEL_TRACE = 1; // TBD
+        DetaillevelBase = 2,
+    }
+    impl DetailLevel {
+        /// String value of the enum field names used in the ProtoBuf definition.
+        ///
+        /// The values are not transformed in any way and thus are considered stable
+        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+        pub fn as_str_name(&self) -> &'static str {
+            match self {
+                Self::DetaillevelExtended => "DETAILLEVEL_EXTENDED",
+                Self::DetaillevelBase => "DETAILLEVEL_BASE",
+            }
+        }
+        /// Creates an enum from field names used in the ProtoBuf definition.
+        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+            match value {
+                "DETAILLEVEL_EXTENDED" => Some(Self::DetaillevelExtended),
+                "DETAILLEVEL_BASE" => Some(Self::DetaillevelBase),
+                _ => None,
+            }
+        }
+    }
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BlockHeader {
     #[prost(bytes = "vec", tag = "1")]
     pub parent_hash: ::prost::alloc::vec::Vec<u8>,
-    /// Uncle hash of the block, some reference it as `sha3Uncles`, but `sha3`` is badly worded, so we prefer `uncle_hash`, also
-    /// referred as `ommers` in EIP specification.
+    /// Uncle hash of the block, some reference it as `sha3Uncles`, but ```sha3`` is badly worded, so we prefer ```uncle_hash`, also  referred as `ommers\` in EIP specification.
     ///
     /// If the Block containing this `BlockHeader` has been produced using the Proof of Stake
     /// consensus algorithm, this field will actually be constant and set to `0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347`.
@@ -100,12 +195,10 @@ pub struct BlockHeader {
     /// consensus algorithm, this field will actually be constant and set to `0x00`.
     #[prost(message, optional, tag = "8")]
     pub difficulty: ::core::option::Option<BigInt>,
-    /// TotalDifficulty is the sum of all previous blocks difficulty including this block difficulty.
+    /// TotalDifficulty used to be the sum of all previous blocks difficulty including this block difficulty.
     ///
-    /// If the Block containing this `BlockHeader` has been produced using the Proof of Stake
-    /// consensus algorithm, this field will actually be constant and set to the terminal total difficulty
-    /// that was required to transition to Proof of Stake algorithm, which varies per network. It is set to
-    /// 58 750 000 000 000 000 000 000 on Ethereum Mainnet and to 10 790 000 on Ethereum Testnet Goerli.
+    /// It has been deprecated in geth v1.15.0 but was already removed from the JSON-RPC interface for a while
+    #[deprecated]
     #[prost(message, optional, tag = "17")]
     pub total_difficulty: ::core::option::Option<BigInt>,
     #[prost(uint64, tag = "9")]
@@ -121,7 +214,7 @@ pub struct BlockHeader {
     /// forks are using bigger values to carry special consensus data.
     ///
     /// If the Block containing this `BlockHeader` has been produced using the Proof of Stake
-    /// consensus algorithm, this field is strictly enforced to be <= 32 bytes.
+    /// consensus algorithm, this field is strictly enforced to be \<= 32 bytes.
     #[prost(bytes = "vec", tag = "13")]
     pub extra_data: ::prost::alloc::vec::Vec<u8>,
     /// MixHash is used to prove, when combined with the `nonce` that sufficient amount of computation has been
@@ -137,38 +230,102 @@ pub struct BlockHeader {
     pub nonce: u64,
     /// Hash is the hash of the block which is actually the computation:
     ///
-    ///   Keccak256(rlp([
-    ///     parent_hash,
-    ///     uncle_hash,
-    ///     coinbase,
-    ///     state_root,
-    ///     transactions_root,
-    ///     receipt_root,
-    ///     logs_bloom,
-    ///     difficulty,
-    ///     number,
-    ///     gas_limit,
-    ///     gas_used,
-    ///     timestamp,
-    ///     extra_data,
-    ///     mix_hash,
-    ///     nonce,
-    ///     base_fee_per_gas
-    ///   ]))
-    ///
+    /// Keccak256(rlp(\[
+    /// parent_hash,
+    /// uncle_hash,
+    /// coinbase,
+    /// state_root,
+    /// transactions_root,
+    /// receipt_root,
+    /// logs_bloom,
+    /// difficulty,
+    /// number,
+    /// gas_limit,
+    /// gas_used,
+    /// timestamp,
+    /// extra_data,
+    /// mix_hash,
+    /// nonce,
+    /// base_fee_per_gas (to be included only if London fork is active)
+    /// withdrawals_root (to be included only if Shangai fork is active)
+    /// blob_gas_used (to be included only if Cancun fork is active)
+    /// excess_blob_gas (to be included only if Cancun fork is active)
+    /// parent_beacon_root (to be included only if Cancun fork is active)
+    /// requests_hash (to be included only if Prague fork is active)
+    /// \]))
     #[prost(bytes = "vec", tag = "16")]
     pub hash: ::prost::alloc::vec::Vec<u8>,
     /// Base fee per gas according to EIP-1559 (e.g. London Fork) rules, only set if London is present/active on the chain.
     #[prost(message, optional, tag = "18")]
     pub base_fee_per_gas: ::core::option::Option<BigInt>,
+    /// Withdrawals root hash according to EIP-4895 (e.g. Shangai Fork) rules, only set if Shangai is present/active on the chain.
+    ///
+    /// Only available in DetailLevel: EXTENDED
+    #[prost(bytes = "vec", tag = "19")]
+    pub withdrawals_root: ::prost::alloc::vec::Vec<u8>,
+    /// TxDependency is list of transaction indexes that are dependent on each other in the block
+    /// header. This is metadata only that was used by the internal Polygon parallel execution engine.
+    ///
+    /// This field was available in a few versions on Polygon Mainnet and Polygon Mumbai chains. It was actually
+    /// removed and is not populated anymore. It's now embedded in the `extraData` field, refer to Polygon source
+    /// code to determine how to extract it if you need it.
+    ///
+    /// Only available in DetailLevel: EXTENDED
+    #[prost(message, optional, tag = "20")]
+    pub tx_dependency: ::core::option::Option<Uint64NestedArray>,
+    /// BlobGasUsed was added by EIP-4844 and is ignored in legacy headers.
+    #[prost(uint64, optional, tag = "22")]
+    pub blob_gas_used: ::core::option::Option<u64>,
+    /// ExcessBlobGas was added by EIP-4844 and is ignored in legacy headers.
+    #[prost(uint64, optional, tag = "23")]
+    pub excess_blob_gas: ::core::option::Option<u64>,
+    /// ParentBeaconRoot was added by EIP-4788 and is ignored in legacy headers.
+    #[prost(bytes = "vec", tag = "24")]
+    pub parent_beacon_root: ::prost::alloc::vec::Vec<u8>,
+    /// RequestsHash was added by EIP-7685 and is ignored in legacy headers.
+    #[prost(bytes = "vec", tag = "25")]
+    pub requests_hash: ::prost::alloc::vec::Vec<u8>,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Uint64NestedArray {
+    #[prost(message, repeated, tag = "1")]
+    pub val: ::prost::alloc::vec::Vec<Uint64Array>,
+}
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct Uint64Array {
+    #[prost(uint64, repeated, tag = "1")]
+    pub val: ::prost::alloc::vec::Vec<u64>,
+}
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct BigInt {
     #[prost(bytes = "vec", tag = "1")]
     pub bytes: ::prost::alloc::vec::Vec<u8>,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
+/// TransactionTrace is full trace of execution of the transaction when the
+/// it actually executed on chain.
+///
+/// It contains all the transaction details like `from`, `to`, `gas`, etc.
+/// as well as all the internal calls that were made during the transaction.
+///
+/// The `calls` vector contains Call objects which have balance changes, events
+/// storage changes, etc.
+///
+/// If ordering is important between elements, almost each message like `Log`,
+/// `Call`, `StorageChange`, etc. have an ordinal field that is represents "execution"
+/// order of the said element against all other elements in this block.
+///
+/// Due to how the call tree works doing "naively", looping through all calls then
+/// through a Call's element like `logs` while not yielding the elements in the order
+/// they were executed on chain. A log in call could have been done before or after
+/// another in another call depending on the actual call tree.
+///
+/// The `calls` are ordered by creation order and the call tree can be re-computing
+/// using fields found in `Call` object (parent/child relationship).
+///
+/// Another important thing to note is that even if a transaction succeed, some calls
+/// within it could have been reverted internally, if this is important to you, you must
+/// check the field `state_reverted` on the `Call` to determine if it was fully committed
+/// to the chain or not.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct TransactionTrace {
     /// consensus
@@ -213,7 +370,7 @@ pub struct TransactionTrace {
     /// The value is always set even for transaction before Berlin fork because those before the fork are still legacy transactions.
     #[prost(enumeration = "transaction_trace::Type", tag = "12")]
     pub r#type: i32,
-    /// AcccessList represents the storage access this transaction has agreed to do in which case those storage
+    /// AccessList represents the storage access this transaction has agreed to do in which case those storage
     /// access cost less gas unit per access.
     ///
     /// This will is populated only if `TransactionTrace.Type == TRX_TYPE_ACCESS_LIST || TRX_TYPE_DYNAMIC_FEE` which
@@ -224,6 +381,8 @@ pub struct TransactionTrace {
     ///
     /// This will is populated only if `TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE` which is possible only
     /// if London fork is active on the chain.
+    ///
+    /// Only available in DetailLevel: EXTENDED
     #[prost(message, optional, tag = "11")]
     pub max_fee_per_gas: ::core::option::Option<BigInt>,
     /// MaxPriorityFeePerGas is priority fee per gas the user to pay in extra to the miner on top of the block's
@@ -231,6 +390,8 @@ pub struct TransactionTrace {
     ///
     /// This will is populated only if `TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE` which is possible only
     /// if London fork is active on the chain.
+    ///
+    /// Only available in DetailLevel: EXTENDED
     #[prost(message, optional, tag = "13")]
     pub max_priority_fee_per_gas: ::core::option::Option<BigInt>,
     /// meta
@@ -240,20 +401,98 @@ pub struct TransactionTrace {
     pub hash: ::prost::alloc::vec::Vec<u8>,
     #[prost(bytes = "vec", tag = "22")]
     pub from: ::prost::alloc::vec::Vec<u8>,
+    /// Only available in DetailLevel: EXTENDED
+    /// Known Issues
+    ///
+    /// * Version 3:
+    ///   Field not populated. It will be empty.
+    ///
+    ///   Fixed in `Version 4`, see <https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model> for information about block versions.
     #[prost(bytes = "vec", tag = "23")]
     pub return_data: ::prost::alloc::vec::Vec<u8>,
+    /// Only available in DetailLevel: EXTENDED
     #[prost(bytes = "vec", tag = "24")]
     pub public_key: ::prost::alloc::vec::Vec<u8>,
+    /// The block's global ordinal when the transaction started executing, refer to
+    /// \[Block\] documentation for further information about ordinals and total ordering.
     #[prost(uint64, tag = "25")]
     pub begin_ordinal: u64,
+    /// The block's global ordinal when the transaction finished executing, refer to
+    /// \[Block\] documentation for further information about ordinals and total ordering.
     #[prost(uint64, tag = "26")]
     pub end_ordinal: u64,
+    /// TransactionTraceStatus is the status of the transaction execution and will let you know if the transaction
+    /// was successful or not.
+    ///
+    /// ## Explanation relevant only for blocks with `DetailLevel: EXTENDED`
+    ///
+    /// A successful transaction has been recorded to the blockchain's state for calls in it that were successful.
+    /// This means it's possible only a subset of the calls were properly recorded, refer to \[calls\[\].state_reverted\] field
+    /// to determine which calls were reverted.
+    ///
+    /// A quirks of the Ethereum protocol is that a transaction `FAILED` or `REVERTED` still affects the blockchain's
+    /// state for **some** of the state changes. Indeed, in those cases, the transactions fees are still paid to the miner
+    /// which means there is a balance change for the transaction's emitter (e.g. `from`) to pay the gas fees, an optional
+    /// balance change for gas refunded to the transaction's emitter (e.g. `from`) and a balance change for the miner who
+    /// received the transaction fees. There is also a nonce change for the transaction's emitter (e.g. `from`).
+    ///
+    /// This means that to properly record the state changes for a transaction, you need to conditionally procees the
+    /// transaction's status.
+    ///
+    /// For a `SUCCEEDED` transaction, you iterate over the `calls` array and record the state changes for each call for
+    /// which `state_reverted == false` (if a transaction succeeded, the call at #0 will always `state_reverted == false`
+    /// because it aligns with the transaction).
+    ///
+    /// For a `FAILED` or `REVERTED` transaction, you iterate over the root call (e.g. at #0, will always exist) for
+    /// balance changes you process those where `reason` is either `REASON_GAS_BUY`, `REASON_GAS_REFUND` or
+    /// `REASON_REWARD_TRANSACTION_FEE` and for nonce change, still on the root call, you pick the nonce change which the
+    /// smallest ordinal (if more than one).
     #[prost(enumeration = "TransactionTraceStatus", tag = "30")]
     pub status: i32,
     #[prost(message, optional, tag = "31")]
     pub receipt: ::core::option::Option<TransactionReceipt>,
+    /// Only available in DetailLevel: EXTENDED
     #[prost(message, repeated, tag = "32")]
     pub calls: ::prost::alloc::vec::Vec<Call>,
+    /// BlobGas is the amount of gas the transaction is going to pay for the blobs, this is a computed value
+    /// equivalent to `self.blob_gas_fee_cap * len(self.blob_hashes)` and provided in the model for convenience.
+    ///
+    /// This is specified by <https://eips.ethereum.org/EIPS/eip-4844>
+    ///
+    /// This will is populated only if `TransactionTrace.Type == TRX_TYPE_BLOB` which is possible only
+    /// if Cancun fork is active on the chain.
+    #[prost(uint64, optional, tag = "33")]
+    pub blob_gas: ::core::option::Option<u64>,
+    /// BlobGasFeeCap is the maximum fee per data gas the user is willing to pay for the data gas used.
+    ///
+    /// This is specified by <https://eips.ethereum.org/EIPS/eip-4844>
+    ///
+    /// This will is populated only if `TransactionTrace.Type == TRX_TYPE_BLOB` which is possible only
+    /// if Cancun fork is active on the chain.
+    #[prost(message, optional, tag = "34")]
+    pub blob_gas_fee_cap: ::core::option::Option<BigInt>,
+    /// BlobHashes field represents a list of hash outputs from 'kzg_to_versioned_hash' which
+    /// essentially is a version byte + the sha256 hash of the blob commitment (e.g.
+    /// `BLOB_COMMITMENT_VERSION_KZG + sha256(commitment)\[1:\]`.
+    ///
+    /// This is specified by <https://eips.ethereum.org/EIPS/eip-4844>
+    ///
+    /// This will is populated only if `TransactionTrace.Type == TRX_TYPE_BLOB` which is possible only
+    /// if Cancun fork is active on the chain.
+    #[prost(bytes = "vec", repeated, tag = "35")]
+    pub blob_hashes: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
+    /// SetCodeAuthorizations represents the authorizations of a transaction to set code to an EOA (Externally Owned Accounts)
+    /// as defined in EIP-7702. The list will contain all the authorizations as they were specified in the
+    /// transaction itself regardless of their validity. If you need to determined if a given authorization was
+    /// correctly applied on chain's state, refer to \[SetCodeAuthorization.discarded\] field that records
+    /// if the authorization was discarded or not by the chain due to invalidity.
+    ///
+    /// This is specified by <https://eips.ethereum.org/EIPS/eip-7702>
+    ///
+    /// This will is populated only if `TransactionTrace.Type == TRX_TYPE_SET_CODE` which is possible only
+    /// if Prague fork is active on the chain.
+    #[prost(message, repeated, tag = "36")]
+    pub set_code_authorizations: ::prost::alloc::vec::Vec<SetCodeAuthorization>,
 }
 /// Nested message and enum types in `TransactionTrace`.
 pub mod transaction_trace {
@@ -272,15 +511,38 @@ pub mod transaction_trace {
     pub enum Type {
         /// All transactions that ever existed prior Berlin fork before EIP-2718 was implemented.
         TrxTypeLegacy = 0,
-        /// Field that specifies an access list of contract/storage_keys that is going to be used
+        /// Transaction that specicy an access list of contract/storage_keys that is going to be used
         /// in this transaction.
         ///
         /// Added in Berlin fork (EIP-2930).
         TrxTypeAccessList = 1,
-        /// Transaction that specifies an access list just like TRX_TYPE_ACCESS_LIST but in addition defines the
+        /// Transaction that specifis an access list just like TRX_TYPE_ACCESS_LIST but in addition defines the
         /// max base gas gee and max priority gas fee to pay for this transaction. Transaction's of those type are
         /// executed against EIP-1559 rules which dictates a dynamic gas cost based on the congestion of the network.
         TrxTypeDynamicFee = 2,
+        /// Transaction which contain a large amount of data that cannot be accessed by EVM execution, but whose commitment
+        /// can be accessed. The format is intended to be fully compatible with the format that will be used in full sharding.
+        ///
+        /// Transaction that defines an access list just like TRX_TYPE_ACCESS_LIST and enables dynamic fee just like
+        /// TRX_TYPE_DYNAMIC_FEE but in addition defines the fields 'max_fee_per_data_gas' of type 'uint256' and the fields
+        /// 'blob_versioned_hashes' which represents a list of hash outputs from 'kzg_to_versioned_hash'.
+        ///
+        /// Activated in Cancun fork (EIP-4844)
+        TrxTypeBlob = 3,
+        /// Transaction that sets code to an EOA (Externally Owned Accounts)
+        ///
+        /// Activated in Prague (EIP-7702)
+        TrxTypeSetCode = 4,
+        /// Arbitrum-specific transactions
+        TrxTypeArbitrumDeposit = 100,
+        TrxTypeArbitrumUnsigned = 101,
+        TrxTypeArbitrumContract = 102,
+        TrxTypeArbitrumRetry = 104,
+        TrxTypeArbitrumSubmitRetryable = 105,
+        TrxTypeArbitrumInternal = 106,
+        TrxTypeArbitrumLegacy = 120,
+        /// OPTIMISM-specific transactions
+        TrxTypeOptimismDeposit = 126,
     }
     impl Type {
         /// String value of the enum field names used in the ProtoBuf definition.
@@ -289,9 +551,21 @@ pub mod transaction_trace {
         /// (if the ProtoBuf definition does not change) and safe for programmatic use.
         pub fn as_str_name(&self) -> &'static str {
             match self {
-                Type::TrxTypeLegacy => "TRX_TYPE_LEGACY",
-                Type::TrxTypeAccessList => "TRX_TYPE_ACCESS_LIST",
-                Type::TrxTypeDynamicFee => "TRX_TYPE_DYNAMIC_FEE",
+                Self::TrxTypeLegacy => "TRX_TYPE_LEGACY",
+                Self::TrxTypeAccessList => "TRX_TYPE_ACCESS_LIST",
+                Self::TrxTypeDynamicFee => "TRX_TYPE_DYNAMIC_FEE",
+                Self::TrxTypeBlob => "TRX_TYPE_BLOB",
+                Self::TrxTypeSetCode => "TRX_TYPE_SET_CODE",
+                Self::TrxTypeArbitrumDeposit => "TRX_TYPE_ARBITRUM_DEPOSIT",
+                Self::TrxTypeArbitrumUnsigned => "TRX_TYPE_ARBITRUM_UNSIGNED",
+                Self::TrxTypeArbitrumContract => "TRX_TYPE_ARBITRUM_CONTRACT",
+                Self::TrxTypeArbitrumRetry => "TRX_TYPE_ARBITRUM_RETRY",
+                Self::TrxTypeArbitrumSubmitRetryable => {
+                    "TRX_TYPE_ARBITRUM_SUBMIT_RETRYABLE"
+                }
+                Self::TrxTypeArbitrumInternal => "TRX_TYPE_ARBITRUM_INTERNAL",
+                Self::TrxTypeArbitrumLegacy => "TRX_TYPE_ARBITRUM_LEGACY",
+                Self::TrxTypeOptimismDeposit => "TRX_TYPE_OPTIMISM_DEPOSIT",
             }
         }
         /// Creates an enum from field names used in the ProtoBuf definition.
@@ -300,6 +574,18 @@ pub mod transaction_trace {
                 "TRX_TYPE_LEGACY" => Some(Self::TrxTypeLegacy),
                 "TRX_TYPE_ACCESS_LIST" => Some(Self::TrxTypeAccessList),
                 "TRX_TYPE_DYNAMIC_FEE" => Some(Self::TrxTypeDynamicFee),
+                "TRX_TYPE_BLOB" => Some(Self::TrxTypeBlob),
+                "TRX_TYPE_SET_CODE" => Some(Self::TrxTypeSetCode),
+                "TRX_TYPE_ARBITRUM_DEPOSIT" => Some(Self::TrxTypeArbitrumDeposit),
+                "TRX_TYPE_ARBITRUM_UNSIGNED" => Some(Self::TrxTypeArbitrumUnsigned),
+                "TRX_TYPE_ARBITRUM_CONTRACT" => Some(Self::TrxTypeArbitrumContract),
+                "TRX_TYPE_ARBITRUM_RETRY" => Some(Self::TrxTypeArbitrumRetry),
+                "TRX_TYPE_ARBITRUM_SUBMIT_RETRYABLE" => {
+                    Some(Self::TrxTypeArbitrumSubmitRetryable)
+                }
+                "TRX_TYPE_ARBITRUM_INTERNAL" => Some(Self::TrxTypeArbitrumInternal),
+                "TRX_TYPE_ARBITRUM_LEGACY" => Some(Self::TrxTypeArbitrumLegacy),
+                "TRX_TYPE_OPTIMISM_DEPOSIT" => Some(Self::TrxTypeOptimismDeposit),
                 _ => None,
             }
         }
@@ -307,36 +593,84 @@ pub mod transaction_trace {
 }
 /// AccessTuple represents a list of storage keys for a given contract's address and is used
 /// for AccessList construction.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct AccessTuple {
     #[prost(bytes = "vec", tag = "1")]
     pub address: ::prost::alloc::vec::Vec<u8>,
     #[prost(bytes = "vec", repeated, tag = "2")]
     pub storage_keys: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
 }
-/// TransactionTraceWithBlockRef
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TransactionTraceWithBlockRef {
-    #[prost(message, optional, tag = "1")]
-    pub trace: ::core::option::Option<TransactionTrace>,
-    #[prost(message, optional, tag = "2")]
-    pub block_ref: ::core::option::Option<BlockRef>,
+/// SetCodeAuthorization represents the authorization of a transaction to set code of an EOA (Externally Owned Account)
+/// as defined in EIP-7702.
+///
+/// The 'authority' field is the address that is authorizing the delegation mechanism. The 'authority' value is computed
+/// from the signature contained in the message using the computation
+/// `authority = ecrecover(keccak(MAGIC || rlp(\[chain_id, address, nonce\])), y_parity, r, s)`
+/// where `MAGIC` is `0x5`, `||` is the bytes concatenation operator, `ecrecover` is the Ethereum signature recovery
+/// and `y_parity` is the recovery ID value denoted `v` in the message below. Checking the go-ethereum implementation
+/// at <https://github.com/ethereum/go-ethereum/blob/v1.15.0/core/types/tx_setcode.go#L117> might prove easier to "read".
+///
+/// We do extract the 'authority' value from the signature in the message and store it in the 'authority' field for
+/// convenience so you don't need to perform the computation yourself.
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct SetCodeAuthorization {
+    /// Discarded determines if this authorization was skipped due to being invalid. As EIP-7702 states,
+    /// if the authorization is invalid (invalid signature, nonce mismatch, etc.) it must be simply
+    /// discarded and the transaction is processed as if the authorization was not present in the
+    /// authorization list.
+    ///
+    /// This boolean records if the authorization was discarded or not by the chain due to invalidity.
+    #[prost(bool, tag = "1")]
+    pub discarded: bool,
+    /// ChainID is the chain ID of the chain where the transaction was executed, used
+    /// to recover the authority from the signature.
+    #[prost(bytes = "vec", tag = "2")]
+    pub chain_id: ::prost::alloc::vec::Vec<u8>,
+    /// Address contains the address this account is delegating to. This address usually
+    /// contain code that this account essentially "delegates" to.
+    ///
+    /// Note: This was missing when EIP-7702 was first activated on Holesky, Sepolia, BSC Chapel,
+    /// BSC Mainnet and Arbitrum Sepolia but was ready for Ethereum Mainnet hard fork. We will backfill
+    /// those missing values in the near future at which point we will remove this note.
+    #[prost(bytes = "vec", tag = "8")]
+    pub address: ::prost::alloc::vec::Vec<u8>,
+    /// Nonce is the nonce of the account that is authorizing delegation mechanism, EIP-7702 rules
+    /// states that nonce should be verified using this rule:
+    ///
+    /// * Verify the nonce of authority is equal to nonce. In case authority does not exist in the trie,
+    ///   verify that nonce is equal to 0.
+    ///
+    /// Read SetCodeAuthorization to know how to recover the `authority` value.
+    #[prost(uint64, tag = "3")]
+    pub nonce: u64,
+    /// V is the recovery ID value for the signature Y point. While it's defined as a
+    /// `uint32`, it's actually bounded by a `uint8` data type withing the Ethereum protocol.
+    #[prost(uint32, tag = "4")]
+    pub v: u32,
+    /// R is the signature's X point on the elliptic curve (32 bytes).
+    #[prost(bytes = "vec", tag = "5")]
+    pub r: ::prost::alloc::vec::Vec<u8>,
+    /// S is the signature's Y point on the elliptic curve (32 bytes).
+    #[prost(bytes = "vec", tag = "6")]
+    pub s: ::prost::alloc::vec::Vec<u8>,
+    /// Authority is the address of the account that is authorizing delegation mechanism, it
+    /// is computed from the signature contained in the message and stored for convenience.
+    ///
+    /// If the authority cannot be recovered from the signature, this field will be empty and
+    /// the `discarded` field will be set to `true`.
+    #[prost(bytes = "vec", optional, tag = "7")]
+    pub authority: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct TransactionReceipt {
     /// State root is an intermediate state_root hash, computed in-between transactions to make
     /// **sure** you could build a proof and point to state in the middle of a block. Geth client
-    /// uses `PostState + root + PostStateOrStatus`` while Parity used `status_code, root...`` this piles
-    /// hardforks, see (read the EIPs first):
-    /// - <https://github.com/eoscanada/go-ethereum-private/blob/deep-mind/core/types/receipt.go#L147>
-    /// - <https://github.com/eoscanada/go-ethereum-private/blob/deep-mind/core/types/receipt.go#L50-L86>
-    /// - <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-658.md>
-    ///
-    /// Moreover, the notion of `Outcome`` in parity, which segregates the two concepts, which are
-    /// stored in the same field `status_code`` can be computed based on such a hack of the `state_root`
+    /// uses ```PostState + root + PostStateOrStatus`` while Parity used ```status_code, root...\`` this piles
+    /// hard forks, see (read the EIPs first):
+    ///
+    /// * <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-658.md>
+    ///
+    /// Moreover, the notion of ```Outcome`` in parity, which segregates the two concepts, which are  stored in the same field ```status_code\`` can be computed based on such a hack of the `state_root`
     /// field, following `EIP-658`.
     ///
     /// Before Byzantinium hard fork, this field is always empty.
@@ -348,9 +682,25 @@ pub struct TransactionReceipt {
     pub logs_bloom: ::prost::alloc::vec::Vec<u8>,
     #[prost(message, repeated, tag = "4")]
     pub logs: ::prost::alloc::vec::Vec<Log>,
+    /// BlobGasUsed is the amount of blob gas that has been used within this transaction. At time
+    /// of writing, this is equal to `self.blob_gas_fee_cap * len(self.blob_hashes)`.
+    ///
+    /// This is specified by <https://eips.ethereum.org/EIPS/eip-4844>
+    ///
+    /// This will is populated only if `TransactionTrace.Type == TRX_TYPE_BLOB` which is possible only
+    /// if Cancun fork is active on the chain.
+    #[prost(uint64, optional, tag = "5")]
+    pub blob_gas_used: ::core::option::Option<u64>,
+    /// BlobGasPrice is the amount to pay per blob item in the transaction.
+    ///
+    /// This is specified by <https://eips.ethereum.org/EIPS/eip-4844>
+    ///
+    /// This will is populated only if `TransactionTrace.Type == TRX_TYPE_BLOB` which is possible only
+    /// if Cancun fork is active on the chain.
+    #[prost(message, optional, tag = "6")]
+    pub blob_gas_price: ::core::option::Option<BigInt>,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct Log {
     #[prost(bytes = "vec", tag = "1")]
     pub address: ::prost::alloc::vec::Vec<u8>,
@@ -359,8 +709,10 @@ pub struct Log {
     #[prost(bytes = "vec", tag = "3")]
     pub data: ::prost::alloc::vec::Vec<u8>,
     /// Index is the index of the log relative to the transaction. This index
-    /// is always populated regardless of the state revertion of the the call
+    /// is always populated regardless of the state reversion of the the call
     /// that emitted this log.
+    ///
+    /// Only available in DetailLevel: EXTENDED
     #[prost(uint32, tag = "4")]
     pub index: u32,
     /// BlockIndex represents the index of the log relative to the Block.
@@ -369,8 +721,9 @@ pub struct Log {
     /// that emitted the log has been reverted by the chain.
     ///
     /// Currently, there is two locations where a Log can be obtained:
-    /// - block.transaction_traces\[].receipt.logs[\]
-    /// - block.transaction_traces\[].calls[].logs[\]
+    ///
+    /// * block.transaction_traces\[\].receipt.logs\[\]
+    /// * block.transaction_traces\[\].calls\[\].logs\[\]
     ///
     /// In the `receipt` case, the logs will be populated only when the call
     /// that emitted them has not been reverted by the chain and when in this
@@ -380,10 +733,11 @@ pub struct Log {
     /// the `blockIndex` value will always be 0.
     #[prost(uint32, tag = "6")]
     pub block_index: u32,
+    /// The block's global ordinal when the log was recorded, refer to \[Block\]
+    /// documentation for further information about ordinals and total ordering.
     #[prost(uint64, tag = "7")]
     pub ordinal: u64,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Call {
     #[prost(uint32, tag = "1")]
@@ -398,6 +752,25 @@ pub struct Call {
     pub caller: ::prost::alloc::vec::Vec<u8>,
     #[prost(bytes = "vec", tag = "6")]
     pub address: ::prost::alloc::vec::Vec<u8>,
+    /// AddressDelegatesTo contains the address from which the actual code to execute will be loaded
+    /// as defined per EIP-7702 rules. If the Call's address value resolves to a code
+    /// that delegates to another address, this field will be populated with the address
+    /// that the call is delegated to. It will be empty in all other situations.
+    ///
+    /// Assumes that a 'SetCode' transaction set address `0xA` to delegates to address `0xB`,
+    /// then when a call is made to `0xA`, the Call object would have:
+    ///
+    /// * caller = <from>
+    /// * address = 0xA
+    /// * address_delegates_to = 0xB
+    ///
+    /// Again, it's important to emphasize that this field relates to EIP-7702, if the call is
+    /// a DELEGATE or CALLCODE type, this field will not be populated and will remain empty.
+    ///
+    /// It will be populated only if EIP-7702 is active on the chain (Prague fork) and if the
+    /// 'address' of the call was pointing to another address at time of execution.
+    #[prost(bytes = "vec", optional, tag = "34")]
+    pub address_delegates_to: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
     #[prost(message, optional, tag = "7")]
     pub value: ::core::option::Option<BigInt>,
     #[prost(uint64, tag = "8")]
@@ -406,8 +779,27 @@ pub struct Call {
     pub gas_consumed: u64,
     #[prost(bytes = "vec", tag = "13")]
     pub return_data: ::prost::alloc::vec::Vec<u8>,
+    /// Known Issues
+    ///
+    /// * Version 3:
+    ///   When call is `CREATE` or `CREATE2`, this field is not populated. A couple of suggestions:
+    ///
+    ///   1. You can get the contract's code in the `code_changes` field.
+    ///   1. In the root `CREATE` call, you can directly use the `TransactionTrace`'s input field.
+    ///   Fixed in `Version 4`, see <https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model> for information about block versions.
     #[prost(bytes = "vec", tag = "14")]
     pub input: ::prost::alloc::vec::Vec<u8>,
+    /// Indicates whether the call executed code.
+    ///
+    /// Known Issues
+    ///
+    /// * Version 3:
+    ///   This may be incorrectly set to `false` for accounts with code handling native value transfers,
+    ///   as well as for certain precompiles with no input.
+    ///   The value is initially set based on `call.type != CREATE && len(call.input) > 0`
+    ///   and later adjusted if the tracer detects an account without code.
+    ///
+    ///   Fixed in `Version 4`, see <https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model> for information about block versions.
     #[prost(bool, tag = "15")]
     pub executed_code: bool,
     #[prost(bool, tag = "16")]
@@ -418,6 +810,12 @@ pub struct Call {
         ::prost::alloc::string::String,
         ::prost::alloc::string::String,
     >,
+    /// Known Issues
+    ///
+    /// * Version 3:
+    ///   The data might be not be in order.
+    ///
+    ///   Fixed in `Version 4`, see <https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model> for information about block versions.
     #[prost(message, repeated, tag = "21")]
     pub storage_changes: ::prost::alloc::vec::Vec<StorageChange>,
     #[prost(message, repeated, tag = "22")]
@@ -428,12 +826,21 @@ pub struct Call {
     pub logs: ::prost::alloc::vec::Vec<Log>,
     #[prost(message, repeated, tag = "26")]
     pub code_changes: ::prost::alloc::vec::Vec<CodeChange>,
+    /// Known Issues
+    ///
+    /// * Version 3:
+    ///   Some gas changes are not correctly tracked:
+    ///   1. Gas refunded due to data returned to the chain (occurs at the end of a transaction, before buyback).
+    ///   1. Initial gas allocation (0 -> GasLimit) at the start of a call.
+    ///   1. Final gas deduction (LeftOver -> 0) at the end of a call (if applicable).
+    ///      Fixed in `Version 4`, see <https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model> for information about block versions.
     #[prost(message, repeated, tag = "28")]
     pub gas_changes: ::prost::alloc::vec::Vec<GasChange>,
     /// In Ethereum, a call can be either:
-    /// - Successfull, execution passes without any problem encountered
-    /// - Failed, execution failed, and remaining gas should be consumed
-    /// - Reverted, execution failed, but only gas consumed so far is billed, remaining gas is refunded
+    ///
+    /// * Successful, execution passes without any problem encountered
+    /// * Failed, execution failed, and remaining gas should be consumed
+    /// * Reverted, execution failed, but only gas consumed so far is billed, remaining gas is refunded
     ///
     /// When a call is either `failed` or `reverted`, the `status_failed` field
     /// below is set to `true`. If the status is `reverted`, then both `status_failed`
@@ -446,7 +853,7 @@ pub struct Call {
     /// see above for details about those flags.
     #[prost(string, tag = "11")]
     pub failure_reason: ::prost::alloc::string::String,
-    /// This field represents wheter or not the state changes performed
+    /// This field represents whether or not the state changes performed
     /// by this call were correctly recorded by the blockchain.
     ///
     /// On Ethereum, a transaction can record state changes even if some
@@ -456,28 +863,59 @@ pub struct Call {
     /// has a status of `SUCCESS`, the chain might have reverted all the state
     /// changes it performed.
     ///
-    /// ```text
-    ///    Trx 1
-    ///     Call #1 <Failed>
-    ///       Call #2 <Execution Success>
-    ///       Call #3 <Execution Success>
-    ///       |--- Failure here
-    ///     Call #4
+    /// ```text,text
+    ///   Trx 1
+    ///    Call #1 <Failed>
+    ///      Call #2 <Execution Success>
+    ///      Call #3 <Execution Success>
+    ///      |--- Failure here
+    ///    Call #4
     /// ```
     ///
     /// In the transaction above, while Call #2 and Call #3 would have the
-    /// status `EXECUTED`
+    /// status `EXECUTED`.
+    ///
+    /// If you check all calls and check only `state_reverted` flag, you might be missing
+    /// some balance changes and nonce changes. This is because when a full transaction fails
+    /// in ethereum (e.g. `calls.all(x.state_reverted == true)`), there is still the transaction
+    /// fee that are recorded to the chain.
+    ///
+    /// Refer to \[TransactionTrace#status\] field for more details about the handling you must
+    /// perform.
     #[prost(bool, tag = "30")]
     pub state_reverted: bool,
+    /// Known Issues
+    ///
+    /// * Version 3:
+    ///
+    ///   1. The block's global ordinal when the call started executing, refer to
+    ///      \[Block\] documentation for further information about ordinals and total ordering.
+    ///   1. The transaction root call `begin_ordial` is always `0` (also in the GENESIS block), which can cause issues
+    ///      when sorting by this field. To ensure proper execution order, set it as follows:
+    ///      `trx.Calls\[0\].BeginOrdinal = trx.BeginOrdinal`.
+    ///   Fixed in `Version 4`, see <https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model> for information about block versions.
     #[prost(uint64, tag = "31")]
     pub begin_ordinal: u64,
+    /// Known Issues
+    ///
+    /// * Version 3:
+    ///
+    ///   1. The block's global ordinal when the call finished executing, refer to
+    ///      \[Block\] documentation for further information about ordinals and total ordering.
+    ///   1. The root call of the GENESIS block is always `0`. To fix it, you can set it as follows:
+    ///      `rx.Calls\[0\].EndOrdinal = max.Uint64`.
+    ///   Fixed in `Version 4`, see <https://docs.substreams.dev/reference-material/chains-and-endpoints/ethereum-data-model> for information about block versions.
     #[prost(uint64, tag = "32")]
     pub end_ordinal: u64,
+    /// Known Issues
+    ///
+    /// * Version 4:
+    ///   AccountCreations are NOT SUPPORTED anymore. DO NOT rely on them.
+    #[deprecated]
     #[prost(message, repeated, tag = "33")]
     pub account_creations: ::prost::alloc::vec::Vec<AccountCreation>,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct StorageChange {
     #[prost(bytes = "vec", tag = "1")]
     pub address: ::prost::alloc::vec::Vec<u8>,
@@ -487,30 +925,50 @@ pub struct StorageChange {
     pub old_value: ::prost::alloc::vec::Vec<u8>,
     #[prost(bytes = "vec", tag = "4")]
     pub new_value: ::prost::alloc::vec::Vec<u8>,
+    /// The block's global ordinal when the storage change was recorded, refer to \[Block\]
+    /// documentation for further information about ordinals and total ordering.
     #[prost(uint64, tag = "5")]
     pub ordinal: u64,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct BalanceChange {
+    /// Address is the address of the account that has changed balance.
     #[prost(bytes = "vec", tag = "1")]
     pub address: ::prost::alloc::vec::Vec<u8>,
+    /// OldValue is the balance of the address before the change. This value
+    /// can be **nil/null/None** if there was no previous balance for the address.
+    /// It is safe in those case(s) to consider the balance as being 0.
+    ///
+    /// If you consume this from a Substreams, you can safely use:
+    ///
+    /// ```text,ignore
+    ///     let old_value = old_value.unwrap_or_default();
+    /// ```
     #[prost(message, optional, tag = "2")]
     pub old_value: ::core::option::Option<BigInt>,
+    /// NewValue is the balance of the address after the change. This value
+    /// can be **nil/null/None** if there was no previous balance for the address
+    /// after the change. It is safe in those case(s) to consider the balance as being
+    /// 0.
+    ///
+    /// If you consume this from a Substreams, you can safely use:
+    ///
+    /// ```text,ignore
+    ///     let new_value = new_value.unwrap_or_default();
+    /// ```
     #[prost(message, optional, tag = "3")]
     pub new_value: ::core::option::Option<BigInt>,
+    /// Reason is the reason why the balance has changed. This is useful to determine
+    /// why the balance has changed and what is the context of the change.
     #[prost(enumeration = "balance_change::Reason", tag = "4")]
     pub reason: i32,
+    /// The block's global ordinal when the balance change was recorded, refer to \[Block\]
+    /// documentation for further information about ordinals and total ordering.
     #[prost(uint64, tag = "5")]
     pub ordinal: u64,
 }
 /// Nested message and enum types in `BalanceChange`.
 pub mod balance_change {
-    /// Obtain all balanche change reasons under deep mind repository:
-    ///
-    /// ```shell
-    /// ack -ho 'BalanceChangeReason\(".*"\)' | grep -Eo '".*"' | sort | uniq
-    /// ```
     #[derive(
         Clone,
         Copy,
@@ -541,6 +999,14 @@ pub mod balance_change {
         CallBalanceOverride = 12,
         /// Used on chain(s) where some Ether burning happens
         Burn = 15,
+        Withdrawal = 16,
+        /// Rewards for Blob processing on BNB chain added in Tycho hard-fork, refers
+        /// to BNB documentation to check the timestamp at which it was activated.
+        RewardBlobFee = 17,
+        /// This reason is used only on Optimism chain.
+        IncreaseMint = 18,
+        /// This reason is used only on Optimism chain.
+        Revert = 19,
     }
     impl Reason {
         /// String value of the enum field names used in the ProtoBuf definition.
@@ -549,22 +1015,26 @@ pub mod balance_change {
         /// (if the ProtoBuf definition does not change) and safe for programmatic use.
         pub fn as_str_name(&self) -> &'static str {
             match self {
-                Reason::Unknown => "REASON_UNKNOWN",
-                Reason::RewardMineUncle => "REASON_REWARD_MINE_UNCLE",
-                Reason::RewardMineBlock => "REASON_REWARD_MINE_BLOCK",
-                Reason::DaoRefundContract => "REASON_DAO_REFUND_CONTRACT",
-                Reason::DaoAdjustBalance => "REASON_DAO_ADJUST_BALANCE",
-                Reason::Transfer => "REASON_TRANSFER",
-                Reason::GenesisBalance => "REASON_GENESIS_BALANCE",
-                Reason::GasBuy => "REASON_GAS_BUY",
-                Reason::RewardTransactionFee => "REASON_REWARD_TRANSACTION_FEE",
-                Reason::RewardFeeReset => "REASON_REWARD_FEE_RESET",
-                Reason::GasRefund => "REASON_GAS_REFUND",
-                Reason::TouchAccount => "REASON_TOUCH_ACCOUNT",
-                Reason::SuicideRefund => "REASON_SUICIDE_REFUND",
-                Reason::SuicideWithdraw => "REASON_SUICIDE_WITHDRAW",
-                Reason::CallBalanceOverride => "REASON_CALL_BALANCE_OVERRIDE",
-                Reason::Burn => "REASON_BURN",
+                Self::Unknown => "REASON_UNKNOWN",
+                Self::RewardMineUncle => "REASON_REWARD_MINE_UNCLE",
+                Self::RewardMineBlock => "REASON_REWARD_MINE_BLOCK",
+                Self::DaoRefundContract => "REASON_DAO_REFUND_CONTRACT",
+                Self::DaoAdjustBalance => "REASON_DAO_ADJUST_BALANCE",
+                Self::Transfer => "REASON_TRANSFER",
+                Self::GenesisBalance => "REASON_GENESIS_BALANCE",
+                Self::GasBuy => "REASON_GAS_BUY",
+                Self::RewardTransactionFee => "REASON_REWARD_TRANSACTION_FEE",
+                Self::RewardFeeReset => "REASON_REWARD_FEE_RESET",
+                Self::GasRefund => "REASON_GAS_REFUND",
+                Self::TouchAccount => "REASON_TOUCH_ACCOUNT",
+                Self::SuicideRefund => "REASON_SUICIDE_REFUND",
+                Self::SuicideWithdraw => "REASON_SUICIDE_WITHDRAW",
+                Self::CallBalanceOverride => "REASON_CALL_BALANCE_OVERRIDE",
+                Self::Burn => "REASON_BURN",
+                Self::Withdrawal => "REASON_WITHDRAWAL",
+                Self::RewardBlobFee => "REASON_REWARD_BLOB_FEE",
+                Self::IncreaseMint => "REASON_INCREASE_MINT",
+                Self::Revert => "REASON_REVERT",
             }
         }
         /// Creates an enum from field names used in the ProtoBuf definition.
@@ -586,13 +1056,16 @@ pub mod balance_change {
                 "REASON_SUICIDE_WITHDRAW" => Some(Self::SuicideWithdraw),
                 "REASON_CALL_BALANCE_OVERRIDE" => Some(Self::CallBalanceOverride),
                 "REASON_BURN" => Some(Self::Burn),
+                "REASON_WITHDRAWAL" => Some(Self::Withdrawal),
+                "REASON_REWARD_BLOB_FEE" => Some(Self::RewardBlobFee),
+                "REASON_INCREASE_MINT" => Some(Self::IncreaseMint),
+                "REASON_REVERT" => Some(Self::Revert),
                 _ => None,
             }
         }
     }
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct NonceChange {
     #[prost(bytes = "vec", tag = "1")]
     pub address: ::prost::alloc::vec::Vec<u8>,
@@ -600,19 +1073,21 @@ pub struct NonceChange {
     pub old_value: u64,
     #[prost(uint64, tag = "3")]
     pub new_value: u64,
+    /// The block's global ordinal when the nonce change was recorded, refer to \[Block\]
+    /// documentation for further information about ordinals and total ordering.
     #[prost(uint64, tag = "4")]
     pub ordinal: u64,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct AccountCreation {
     #[prost(bytes = "vec", tag = "1")]
     pub account: ::prost::alloc::vec::Vec<u8>,
+    /// The block's global ordinal when the account creation was recorded, refer to \[Block\]
+    /// documentation for further information about ordinals and total ordering.
     #[prost(uint64, tag = "2")]
     pub ordinal: u64,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct CodeChange {
     #[prost(bytes = "vec", tag = "1")]
     pub address: ::prost::alloc::vec::Vec<u8>,
@@ -624,6 +1099,8 @@ pub struct CodeChange {
     pub new_hash: ::prost::alloc::vec::Vec<u8>,
     #[prost(bytes = "vec", tag = "5")]
     pub new_code: ::prost::alloc::vec::Vec<u8>,
+    /// The block's global ordinal when the code change was recorded, refer to \[Block\]
+    /// documentation for further information about ordinals and total ordering.
     #[prost(uint64, tag = "6")]
     pub ordinal: u64,
 }
@@ -633,8 +1110,7 @@ pub struct CodeChange {
 ///
 /// Hence, we only index some of them, those that are costy like all the calls
 /// one, log events, return data, etc.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct GasChange {
     #[prost(uint64, tag = "1")]
     pub old_value: u64,
@@ -642,16 +1118,13 @@ pub struct GasChange {
     pub new_value: u64,
     #[prost(enumeration = "gas_change::Reason", tag = "3")]
     pub reason: i32,
+    /// The block's global ordinal when the gas change was recorded, refer to \[Block\]
+    /// documentation for further information about ordinals and total ordering.
     #[prost(uint64, tag = "4")]
     pub ordinal: u64,
 }
 /// Nested message and enum types in `GasChange`.
 pub mod gas_change {
-    /// Obtain all gas change reasons under deep mind repository:
-    ///
-    /// ```shell
-    /// ack -ho 'GasChangeReason\(".*"\)' | grep -Eo '".*"' | sort | uniq
-    /// ```
     #[derive(
         Clone,
         Copy,
@@ -666,27 +1139,88 @@ pub mod gas_change {
     #[repr(i32)]
     pub enum Reason {
         Unknown = 0,
+        /// REASON_CALL is the amount of gas that will be charged for a 'CALL' opcode executed by the EVM
         Call = 1,
+        /// REASON_CALL_CODE is the amount of gas that will be charged for a 'CALLCODE' opcode executed by the EVM
         CallCode = 2,
+        /// REASON_CALL_DATA_COPY is the amount of gas that will be charged for a 'CALLDATACOPY' opcode executed by the EVM
         CallDataCopy = 3,
+        /// REASON_CODE_COPY is the amount of gas that will be charged for a 'CALLDATACOPY' opcode executed by the EVM
         CodeCopy = 4,
+        /// REASON_CODE_STORAGE is the amount of gas that will be charged for code storage
         CodeStorage = 5,
+        /// REASON_CONTRACT_CREATION is the amount of gas that will be charged for a 'CREATE' opcode executed by the EVM and for the gas
+        /// burned for a CREATE, today controlled by EIP150 rules
         ContractCreation = 6,
+        /// REASON_CONTRACT_CREATION2 is the amount of gas that will be charged for a 'CREATE2' opcode executed by the EVM and for the gas
+        /// burned for a CREATE2, today controlled by EIP150 rules
         ContractCreation2 = 7,
+        /// REASON_DELEGATE_CALL is the amount of gas that will be charged for a 'DELEGATECALL' opcode executed by the EVM
         DelegateCall = 8,
+        /// REASON_EVENT_LOG is the amount of gas that will be charged for a 'LOG<N>' opcode executed by the EVM
         EventLog = 9,
+        /// REASON_EXT_CODE_COPY is the amount of gas that will be charged for a 'LOG<N>' opcode executed by the EVM
         ExtCodeCopy = 10,
+        /// REASON_FAILED_EXECUTION is the burning of the remaining gas when the execution failed without a revert
         FailedExecution = 11,
+        /// REASON_INTRINSIC_GAS is the amount of gas that will be charged for the intrinsic cost of the transaction, there is
+        /// always exactly one of those per transaction
         IntrinsicGas = 12,
+        /// GasChangePrecompiledContract is the amount of gas that will be charged for a precompiled contract execution
         PrecompiledContract = 13,
+        /// REASON_REFUND_AFTER_EXECUTION is the amount of gas that will be refunded to the caller after the execution of the call,
+        /// if there is left over at the end of execution
         RefundAfterExecution = 14,
+        /// REASON_RETURN is the amount of gas that will be charged for a 'RETURN' opcode executed by the EVM
         Return = 15,
+        /// REASON_RETURN_DATA_COPY is the amount of gas that will be charged for a 'RETURNDATACOPY' opcode executed by the EVM
         ReturnDataCopy = 16,
+        /// REASON_REVERT is the amount of gas that will be charged for a 'REVERT' opcode executed by the EVM
         Revert = 17,
+        /// REASON_SELF_DESTRUCT is the amount of gas that will be charged for a 'SELFDESTRUCT' opcode executed by the EVM
         SelfDestruct = 18,
+        /// REASON_STATIC_CALL is the amount of gas that will be charged for a 'STATICALL' opcode executed by the EVM
         StaticCall = 19,
+        /// REASON_STATE_COLD_ACCESS is the amount of gas that will be charged for a cold storage access as controlled by EIP2929 rules
+        ///
         /// Added in Berlin fork (Geth 1.10+)
         StateColdAccess = 20,
+        /// REASON_TX_INITIAL_BALANCE is the initial balance for the call which will be equal to the gasLimit of the call
+        ///
+        /// Added as new tracing reason in Geth, available only on some chains
+        TxInitialBalance = 21,
+        /// REASON_TX_REFUNDS is the sum of all refunds which happened during the tx execution (e.g. storage slot being cleared)
+        /// this generates an increase in gas. There is only one such gas change per transaction.
+        ///
+        /// Added as new tracing reason in Geth, available only on some chains
+        TxRefunds = 22,
+        /// REASON_TX_LEFT_OVER_RETURNED is the amount of gas left over at the end of transaction's execution that will be returned
+        /// to the chain. This change will always be a negative change as we "drain" left over gas towards 0. If there was no gas
+        /// left at the end of execution, no such even will be emitted. The returned gas's value in Wei is returned to caller.
+        /// There is at most one of such gas change per transaction.
+        ///
+        /// Added as new tracing reason in Geth, available only on some chains
+        TxLeftOverReturned = 23,
+        /// REASON_CALL_INITIAL_BALANCE is the initial balance for the call which will be equal to the gasLimit of the call. There is only
+        /// one such gas change per call.
+        ///
+        /// Added as new tracing reason in Geth, available only on some chains
+        CallInitialBalance = 24,
+        /// REASON_CALL_LEFT_OVER_RETURNED is the amount of gas left over that will be returned to the caller, this change will always
+        /// be a negative change as we "drain" left over gas towards 0. If there was no gas left at the end of execution, no such even
+        /// will be emitted.
+        CallLeftOverReturned = 25,
+        /// REASON_WITNESS_CONTRACT_INIT flags the event of adding to the witness during the contract creation initialization step.
+        WitnessContractInit = 26,
+        /// REASON_WITNESS_CONTRACT_CREATION flags the event of adding to the witness during the contract creation finalization step.
+        WitnessContractCreation = 27,
+        /// REASON_WITNESS_CODE_CHUNK flags the event of adding one or more contract code chunks to the witness.
+        WitnessCodeChunk = 28,
+        /// REASON_WITNESS_CONTRACT_COLLISION_CHECK flags the event of adding to the witness when checking for contract address collision.
+        WitnessContractCollisionCheck = 29,
+        /// REASON_TX_DATA_FLOOR is the amount of extra gas the transaction has to pay to reach the minimum gas requirement for the
+        /// transaction data. This change will always be a negative change.
+        TxDataFloor = 30,
     }
     impl Reason {
         /// String value of the enum field names used in the ProtoBuf definition.
@@ -695,27 +1229,39 @@ pub mod gas_change {
         /// (if the ProtoBuf definition does not change) and safe for programmatic use.
         pub fn as_str_name(&self) -> &'static str {
             match self {
-                Reason::Unknown => "REASON_UNKNOWN",
-                Reason::Call => "REASON_CALL",
-                Reason::CallCode => "REASON_CALL_CODE",
-                Reason::CallDataCopy => "REASON_CALL_DATA_COPY",
-                Reason::CodeCopy => "REASON_CODE_COPY",
-                Reason::CodeStorage => "REASON_CODE_STORAGE",
-                Reason::ContractCreation => "REASON_CONTRACT_CREATION",
-                Reason::ContractCreation2 => "REASON_CONTRACT_CREATION2",
-                Reason::DelegateCall => "REASON_DELEGATE_CALL",
-                Reason::EventLog => "REASON_EVENT_LOG",
-                Reason::ExtCodeCopy => "REASON_EXT_CODE_COPY",
-                Reason::FailedExecution => "REASON_FAILED_EXECUTION",
-                Reason::IntrinsicGas => "REASON_INTRINSIC_GAS",
-                Reason::PrecompiledContract => "REASON_PRECOMPILED_CONTRACT",
-                Reason::RefundAfterExecution => "REASON_REFUND_AFTER_EXECUTION",
-                Reason::Return => "REASON_RETURN",
-                Reason::ReturnDataCopy => "REASON_RETURN_DATA_COPY",
-                Reason::Revert => "REASON_REVERT",
-                Reason::SelfDestruct => "REASON_SELF_DESTRUCT",
-                Reason::StaticCall => "REASON_STATIC_CALL",
-                Reason::StateColdAccess => "REASON_STATE_COLD_ACCESS",
+                Self::Unknown => "REASON_UNKNOWN",
+                Self::Call => "REASON_CALL",
+                Self::CallCode => "REASON_CALL_CODE",
+                Self::CallDataCopy => "REASON_CALL_DATA_COPY",
+                Self::CodeCopy => "REASON_CODE_COPY",
+                Self::CodeStorage => "REASON_CODE_STORAGE",
+                Self::ContractCreation => "REASON_CONTRACT_CREATION",
+                Self::ContractCreation2 => "REASON_CONTRACT_CREATION2",
+                Self::DelegateCall => "REASON_DELEGATE_CALL",
+                Self::EventLog => "REASON_EVENT_LOG",
+                Self::ExtCodeCopy => "REASON_EXT_CODE_COPY",
+                Self::FailedExecution => "REASON_FAILED_EXECUTION",
+                Self::IntrinsicGas => "REASON_INTRINSIC_GAS",
+                Self::PrecompiledContract => "REASON_PRECOMPILED_CONTRACT",
+                Self::RefundAfterExecution => "REASON_REFUND_AFTER_EXECUTION",
+                Self::Return => "REASON_RETURN",
+                Self::ReturnDataCopy => "REASON_RETURN_DATA_COPY",
+                Self::Revert => "REASON_REVERT",
+                Self::SelfDestruct => "REASON_SELF_DESTRUCT",
+                Self::StaticCall => "REASON_STATIC_CALL",
+                Self::StateColdAccess => "REASON_STATE_COLD_ACCESS",
+                Self::TxInitialBalance => "REASON_TX_INITIAL_BALANCE",
+                Self::TxRefunds => "REASON_TX_REFUNDS",
+                Self::TxLeftOverReturned => "REASON_TX_LEFT_OVER_RETURNED",
+                Self::CallInitialBalance => "REASON_CALL_INITIAL_BALANCE",
+                Self::CallLeftOverReturned => "REASON_CALL_LEFT_OVER_RETURNED",
+                Self::WitnessContractInit => "REASON_WITNESS_CONTRACT_INIT",
+                Self::WitnessContractCreation => "REASON_WITNESS_CONTRACT_CREATION",
+                Self::WitnessCodeChunk => "REASON_WITNESS_CODE_CHUNK",
+                Self::WitnessContractCollisionCheck => {
+                    "REASON_WITNESS_CONTRACT_COLLISION_CHECK"
+                }
+                Self::TxDataFloor => "REASON_TX_DATA_FLOOR",
             }
         }
         /// Creates an enum from field names used in the ProtoBuf definition.
@@ -742,11 +1288,84 @@ pub mod gas_change {
                 "REASON_SELF_DESTRUCT" => Some(Self::SelfDestruct),
                 "REASON_STATIC_CALL" => Some(Self::StaticCall),
                 "REASON_STATE_COLD_ACCESS" => Some(Self::StateColdAccess),
+                "REASON_TX_INITIAL_BALANCE" => Some(Self::TxInitialBalance),
+                "REASON_TX_REFUNDS" => Some(Self::TxRefunds),
+                "REASON_TX_LEFT_OVER_RETURNED" => Some(Self::TxLeftOverReturned),
+                "REASON_CALL_INITIAL_BALANCE" => Some(Self::CallInitialBalance),
+                "REASON_CALL_LEFT_OVER_RETURNED" => Some(Self::CallLeftOverReturned),
+                "REASON_WITNESS_CONTRACT_INIT" => Some(Self::WitnessContractInit),
+                "REASON_WITNESS_CONTRACT_CREATION" => Some(Self::WitnessContractCreation),
+                "REASON_WITNESS_CODE_CHUNK" => Some(Self::WitnessCodeChunk),
+                "REASON_WITNESS_CONTRACT_COLLISION_CHECK" => {
+                    Some(Self::WitnessContractCollisionCheck)
+                }
+                "REASON_TX_DATA_FLOOR" => Some(Self::TxDataFloor),
                 _ => None,
             }
         }
     }
 }
+/// HeaderOnlyBlock is used to optimally unpack the \[Block\] structure (note the
+/// corresponding message number for the `header` field) while consuming less
+/// memory, when only the `header` is desired.
+///
+/// WARN: this is a client-side optimization pattern and should be moved in the
+/// consuming code.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct HeaderOnlyBlock {
+    #[prost(message, optional, tag = "5")]
+    pub header: ::core::option::Option<BlockHeader>,
+}
+/// BlockWithRefs is a lightweight block, with traces and transactions
+/// purged from the `block` within, and only.  It is used in transports
+/// to pass block data around.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct BlockWithRefs {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "2")]
+    pub block: ::core::option::Option<Block>,
+    #[prost(message, optional, tag = "3")]
+    pub transaction_trace_refs: ::core::option::Option<TransactionRefs>,
+    #[prost(bool, tag = "4")]
+    pub irreversible: bool,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TransactionTraceWithBlockRef {
+    #[prost(message, optional, tag = "1")]
+    pub trace: ::core::option::Option<TransactionTrace>,
+    #[prost(message, optional, tag = "2")]
+    pub block_ref: ::core::option::Option<BlockRef>,
+}
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct TransactionRefs {
+    #[prost(bytes = "vec", repeated, tag = "1")]
+    pub hashes: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
+}
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct BlockRef {
+    #[prost(bytes = "vec", tag = "1")]
+    pub hash: ::prost::alloc::vec::Vec<u8>,
+    #[prost(uint64, tag = "2")]
+    pub number: u64,
+}
+/// Withdrawal represents a validator withdrawal from the beacon chain to the EVM.
+/// Introduced in EIP-4895 (Shanghai hard fork).
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct Withdrawal {
+    /// Index is the monotonically increasing identifier of the withdrawal
+    #[prost(uint64, tag = "1")]
+    pub index: u64,
+    /// ValidatorIndex is the index of the validator that is withdrawing
+    #[prost(uint64, tag = "2")]
+    pub validator_index: u64,
+    /// Address is the Ethereum address receiving the withdrawn funds
+    #[prost(bytes = "vec", tag = "3")]
+    pub address: ::prost::alloc::vec::Vec<u8>,
+    /// Amount is the value of the withdrawal in gwei (1 gwei = 1e9 wei)
+    #[prost(uint64, tag = "4")]
+    pub amount: u64,
+}
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
 pub enum TransactionTraceStatus {
@@ -762,10 +1381,10 @@ impl TransactionTraceStatus {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            TransactionTraceStatus::Unknown => "UNKNOWN",
-            TransactionTraceStatus::Succeeded => "SUCCEEDED",
-            TransactionTraceStatus::Failed => "FAILED",
-            TransactionTraceStatus::Reverted => "REVERTED",
+            Self::Unknown => "UNKNOWN",
+            Self::Succeeded => "SUCCEEDED",
+            Self::Failed => "FAILED",
+            Self::Reverted => "REVERTED",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -798,12 +1417,12 @@ impl CallType {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            CallType::Unspecified => "UNSPECIFIED",
-            CallType::Call => "CALL",
-            CallType::Callcode => "CALLCODE",
-            CallType::Delegate => "DELEGATE",
-            CallType::Static => "STATIC",
-            CallType::Create => "CREATE",
+            Self::Unspecified => "UNSPECIFIED",
+            Self::Call => "CALL",
+            Self::Callcode => "CALLCODE",
+            Self::Delegate => "DELEGATE",
+            Self::Static => "STATIC",
+            Self::Create => "CREATE",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
diff --git a/chain/ethereum/src/runtime/abi.rs b/chain/ethereum/src/runtime/abi.rs
index d88bf2b22d7..4311fed3c48 100644
--- a/chain/ethereum/src/runtime/abi.rs
+++ b/chain/ethereum/src/runtime/abi.rs
@@ -2,15 +2,18 @@ use super::runtime_adapter::UnresolvedContractCall;
 use crate::trigger::{
     EthereumBlockData, EthereumCallData, EthereumEventData, EthereumTransactionData,
 };
+use anyhow::anyhow;
+use async_trait::async_trait;
+use graph::abi;
+use graph::prelude::alloy;
+use graph::prelude::alloy::consensus::TxReceipt;
+use graph::prelude::alloy::network::ReceiptResponse;
+use graph::prelude::alloy::rpc::types::{Log, TransactionReceipt};
 use graph::{
-    prelude::{
-        ethabi,
-        web3::types::{Log, TransactionReceipt, H256},
-        BigInt,
-    },
+    prelude::BigInt,
     runtime::{
-        asc_get, asc_new, gas::GasCounter, AscHeap, AscIndexId, AscPtr, AscType,
-        DeterministicHostError, FromAscObj, HostExportError, IndexForAscTypeId, ToAscObj,
+        AscHeap, AscIndexId, AscPtr, AscType, DeterministicHostError, FromAscObj, HostExportError,
+        IndexForAscTypeId, ToAscObj, asc_get, asc_new, asc_new_or_null, gas::GasCounter,
     },
 };
 use graph_runtime_derive::AscType;
@@ -20,7 +23,7 @@ use graph_runtime_wasm::asc_abi::class::{
 };
 use semver::Version;
 
-type AscH256 = Uint8Array;
+type AscB256 = Uint8Array;
 type AscH2048 = Uint8Array;
 
 pub struct AscLogParamArray(Array<AscPtr<AscLogParam>>);
@@ -37,15 +40,18 @@ impl AscType for AscLogParamArray {
     }
 }
 
-impl ToAscObj<AscLogParamArray> for Vec<ethabi::LogParam> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl ToAscObj<AscLogParamArray> for &[abi::DynSolParam] {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscLogParamArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscLogParamArray(Array::new(&content, heap, gas)?))
+        let mut content = Vec::with_capacity(self.len());
+        for x in *self {
+            content.push(asc_new(heap, x, gas).await?);
+        }
+        Ok(AscLogParamArray(Array::new(&content, heap, gas).await?))
     }
 }
 
@@ -53,7 +59,7 @@ impl AscIndexId for AscLogParamArray {
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArrayEventParam;
 }
 
-pub struct AscTopicArray(Array<AscPtr<AscH256>>);
+pub struct AscTopicArray(Array<AscPtr<AscB256>>);
 
 impl AscType for AscTopicArray {
     fn to_asc_bytes(&self) -> Result<Vec<u8>, DeterministicHostError> {
@@ -68,22 +74,23 @@ impl AscType for AscTopicArray {
     }
 }
 
-impl ToAscObj<AscTopicArray> for Vec<H256> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl ToAscObj<AscTopicArray> for &[alloy::primitives::B256] {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscTopicArray, HostExportError> {
-        let topics = self
-            .iter()
-            .map(|topic| asc_new(heap, topic, gas))
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(AscTopicArray(Array::new(&topics, heap, gas)?))
+        let mut topics = Vec::with_capacity(self.len());
+        for topic in *self {
+            topics.push(asc_new(heap, topic, gas).await?);
+        }
+        Ok(AscTopicArray(Array::new(&topics, heap, gas).await?))
     }
 }
 
 impl AscIndexId for AscTopicArray {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArrayH256;
+    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArrayB256;
 }
 
 pub struct AscLogArray(Array<AscPtr<AscEthereumLog>>);
@@ -101,17 +108,19 @@ impl AscType for AscLogArray {
     }
 }
 
-impl ToAscObj<AscLogArray> for Vec<Log> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl ToAscObj<AscLogArray> for &[Log] {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscLogArray, HostExportError> {
-        let logs = self
-            .iter()
-            .map(|log| asc_new(heap, &log, gas))
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(AscLogArray(Array::new(&logs, heap, gas)?))
+        let mut logs = Vec::with_capacity(self.len());
+        for log in *self {
+            logs.push(asc_new(heap, log, gas).await?);
+        }
+
+        Ok(AscLogArray(Array::new(&logs, heap, gas).await?))
     }
 }
 
@@ -121,6 +130,7 @@ impl AscIndexId for AscLogArray {
 
 #[repr(C)]
 #[derive(AscType)]
+#[allow(non_camel_case_types)]
 pub struct AscUnresolvedContractCall_0_0_4 {
     pub contract_name: AscPtr<AscString>,
     pub contract_address: AscPtr<AscAddress>,
@@ -179,13 +189,13 @@ impl FromAscObj<AscUnresolvedContractCall> for UnresolvedContractCall {
 #[repr(C)]
 #[derive(AscType)]
 pub(crate) struct AscEthereumBlock {
-    pub hash: AscPtr<AscH256>,
-    pub parent_hash: AscPtr<AscH256>,
-    pub uncles_hash: AscPtr<AscH256>,
+    pub hash: AscPtr<AscB256>,
+    pub parent_hash: AscPtr<AscB256>,
+    pub uncles_hash: AscPtr<AscB256>,
     pub author: AscPtr<AscH160>,
-    pub state_root: AscPtr<AscH256>,
-    pub transactions_root: AscPtr<AscH256>,
-    pub receipts_root: AscPtr<AscH256>,
+    pub state_root: AscPtr<AscB256>,
+    pub transactions_root: AscPtr<AscB256>,
+    pub receipts_root: AscPtr<AscB256>,
     pub number: AscPtr<AscBigInt>,
     pub gas_used: AscPtr<AscBigInt>,
     pub gas_limit: AscPtr<AscBigInt>,
@@ -201,14 +211,15 @@ impl AscIndexId for AscEthereumBlock {
 
 #[repr(C)]
 #[derive(AscType)]
+#[allow(non_camel_case_types)]
 pub(crate) struct AscEthereumBlock_0_0_6 {
-    pub hash: AscPtr<AscH256>,
-    pub parent_hash: AscPtr<AscH256>,
-    pub uncles_hash: AscPtr<AscH256>,
+    pub hash: AscPtr<AscB256>,
+    pub parent_hash: AscPtr<AscB256>,
+    pub uncles_hash: AscPtr<AscB256>,
     pub author: AscPtr<AscH160>,
-    pub state_root: AscPtr<AscH256>,
-    pub transactions_root: AscPtr<AscH256>,
-    pub receipts_root: AscPtr<AscH256>,
+    pub state_root: AscPtr<AscB256>,
+    pub transactions_root: AscPtr<AscB256>,
+    pub receipts_root: AscPtr<AscB256>,
     pub number: AscPtr<AscBigInt>,
     pub gas_used: AscPtr<AscBigInt>,
     pub gas_limit: AscPtr<AscBigInt>,
@@ -225,8 +236,9 @@ impl AscIndexId for AscEthereumBlock_0_0_6 {
 
 #[repr(C)]
 #[derive(AscType)]
+#[allow(non_camel_case_types)]
 pub(crate) struct AscEthereumTransaction_0_0_1 {
-    pub hash: AscPtr<AscH256>,
+    pub hash: AscPtr<AscB256>,
     pub index: AscPtr<AscBigInt>,
     pub from: AscPtr<AscH160>,
     pub to: AscPtr<AscH160>,
@@ -241,8 +253,9 @@ impl AscIndexId for AscEthereumTransaction_0_0_1 {
 
 #[repr(C)]
 #[derive(AscType)]
+#[allow(non_camel_case_types)]
 pub(crate) struct AscEthereumTransaction_0_0_2 {
-    pub hash: AscPtr<AscH256>,
+    pub hash: AscPtr<AscB256>,
     pub index: AscPtr<AscBigInt>,
     pub from: AscPtr<AscH160>,
     pub to: AscPtr<AscH160>,
@@ -258,8 +271,9 @@ impl AscIndexId for AscEthereumTransaction_0_0_2 {
 
 #[repr(C)]
 #[derive(AscType)]
+#[allow(non_camel_case_types)]
 pub(crate) struct AscEthereumTransaction_0_0_6 {
-    pub hash: AscPtr<AscH256>,
+    pub hash: AscPtr<AscB256>,
     pub index: AscPtr<AscBigInt>,
     pub from: AscPtr<AscH160>,
     pub to: AscPtr<AscH160>,
@@ -308,9 +322,9 @@ pub(crate) struct AscEthereumLog {
     pub address: AscPtr<AscAddress>,
     pub topics: AscPtr<AscTopicArray>,
     pub data: AscPtr<Uint8Array>,
-    pub block_hash: AscPtr<AscH256>,
-    pub block_number: AscPtr<AscH256>,
-    pub transaction_hash: AscPtr<AscH256>,
+    pub block_hash: AscPtr<AscB256>,
+    pub block_number: AscPtr<AscB256>,
+    pub transaction_hash: AscPtr<AscB256>,
     pub transaction_index: AscPtr<AscBigInt>,
     pub log_index: AscPtr<AscBigInt>,
     pub transaction_log_index: AscPtr<AscBigInt>,
@@ -325,16 +339,16 @@ impl AscIndexId for AscEthereumLog {
 #[repr(C)]
 #[derive(AscType)]
 pub(crate) struct AscEthereumTransactionReceipt {
-    pub transaction_hash: AscPtr<AscH256>,
+    pub transaction_hash: AscPtr<AscB256>,
     pub transaction_index: AscPtr<AscBigInt>,
-    pub block_hash: AscPtr<AscH256>,
+    pub block_hash: AscPtr<AscB256>,
     pub block_number: AscPtr<AscBigInt>,
     pub cumulative_gas_used: AscPtr<AscBigInt>,
     pub gas_used: AscPtr<AscBigInt>,
     pub contract_address: AscPtr<AscAddress>,
     pub logs: AscPtr<AscLogArray>,
     pub status: AscPtr<AscBigInt>,
-    pub root: AscPtr<AscH256>,
+    pub root: AscPtr<AscB256>,
     pub logs_bloom: AscPtr<AscH2048>,
 }
 
@@ -346,6 +360,7 @@ impl AscIndexId for AscEthereumTransactionReceipt {
 /// `receipt` field.
 #[repr(C)]
 #[derive(AscType)]
+#[allow(non_camel_case_types)]
 pub(crate) struct AscEthereumEvent_0_0_7<T, B>
 where
     T: AscType,
@@ -392,6 +407,7 @@ impl AscIndexId for AscEthereumCall {
 
 #[repr(C)]
 #[derive(AscType)]
+#[allow(non_camel_case_types)]
 pub(crate) struct AscEthereumCall_0_0_3<T, B>
 where
     T: AscType,
@@ -413,181 +429,173 @@ where
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::EthereumCall;
 }
 
-impl ToAscObj<AscEthereumBlock> for EthereumBlockData {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl<'a> ToAscObj<AscEthereumBlock> for EthereumBlockData<'a> {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEthereumBlock, HostExportError> {
+        let size = asc_new_or_null_u256(heap, self.size(), gas).await?;
+
         Ok(AscEthereumBlock {
-            hash: asc_new(heap, &self.hash, gas)?,
-            parent_hash: asc_new(heap, &self.parent_hash, gas)?,
-            uncles_hash: asc_new(heap, &self.uncles_hash, gas)?,
-            author: asc_new(heap, &self.author, gas)?,
-            state_root: asc_new(heap, &self.state_root, gas)?,
-            transactions_root: asc_new(heap, &self.transactions_root, gas)?,
-            receipts_root: asc_new(heap, &self.receipts_root, gas)?,
-            number: asc_new(heap, &BigInt::from(self.number), gas)?,
-            gas_used: asc_new(heap, &BigInt::from_unsigned_u256(&self.gas_used), gas)?,
-            gas_limit: asc_new(heap, &BigInt::from_unsigned_u256(&self.gas_limit), gas)?,
-            timestamp: asc_new(heap, &BigInt::from_unsigned_u256(&self.timestamp), gas)?,
-            difficulty: asc_new(heap, &BigInt::from_unsigned_u256(&self.difficulty), gas)?,
+            hash: asc_new(heap, self.hash(), gas).await?,
+            parent_hash: asc_new(heap, self.parent_hash(), gas).await?,
+            uncles_hash: asc_new(heap, self.uncles_hash(), gas).await?,
+            author: asc_new(heap, self.author(), gas).await?,
+            state_root: asc_new(heap, self.state_root(), gas).await?,
+            transactions_root: asc_new(heap, self.transactions_root(), gas).await?,
+            receipts_root: asc_new(heap, self.receipts_root(), gas).await?,
+            number: asc_new(heap, &BigInt::from(self.number()), gas).await?,
+            gas_used: asc_new(heap, &BigInt::from(self.gas_used()), gas).await?,
+            gas_limit: asc_new(heap, &BigInt::from(self.gas_limit()), gas).await?,
+            timestamp: asc_new(heap, &BigInt::from(self.timestamp()), gas).await?,
+            difficulty: asc_new(heap, &BigInt::from_unsigned_u256(self.difficulty()), gas).await?,
             total_difficulty: asc_new(
                 heap,
-                &BigInt::from_unsigned_u256(&self.total_difficulty),
+                &BigInt::from_unsigned_u256(self.total_difficulty()),
                 gas,
-            )?,
-            size: self
-                .size
-                .map(|size| asc_new(heap, &BigInt::from_unsigned_u256(&size), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
+            )
+            .await?,
+            size,
         })
     }
 }
 
-impl ToAscObj<AscEthereumBlock_0_0_6> for EthereumBlockData {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl<'a> ToAscObj<AscEthereumBlock_0_0_6> for EthereumBlockData<'a> {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEthereumBlock_0_0_6, HostExportError> {
+        let size = asc_new_or_null_u256(heap, self.size(), gas).await?;
+        let base_fee_per_block = asc_new_or_null_u64(heap, self.base_fee_per_gas(), gas).await?;
+
         Ok(AscEthereumBlock_0_0_6 {
-            hash: asc_new(heap, &self.hash, gas)?,
-            parent_hash: asc_new(heap, &self.parent_hash, gas)?,
-            uncles_hash: asc_new(heap, &self.uncles_hash, gas)?,
-            author: asc_new(heap, &self.author, gas)?,
-            state_root: asc_new(heap, &self.state_root, gas)?,
-            transactions_root: asc_new(heap, &self.transactions_root, gas)?,
-            receipts_root: asc_new(heap, &self.receipts_root, gas)?,
-            number: asc_new(heap, &BigInt::from(self.number), gas)?,
-            gas_used: asc_new(heap, &BigInt::from_unsigned_u256(&self.gas_used), gas)?,
-            gas_limit: asc_new(heap, &BigInt::from_unsigned_u256(&self.gas_limit), gas)?,
-            timestamp: asc_new(heap, &BigInt::from_unsigned_u256(&self.timestamp), gas)?,
-            difficulty: asc_new(heap, &BigInt::from_unsigned_u256(&self.difficulty), gas)?,
+            hash: asc_new(heap, self.hash(), gas).await?,
+            parent_hash: asc_new(heap, self.parent_hash(), gas).await?,
+            uncles_hash: asc_new(heap, self.uncles_hash(), gas).await?,
+            author: asc_new(heap, self.author(), gas).await?,
+            state_root: asc_new(heap, self.state_root(), gas).await?,
+            transactions_root: asc_new(heap, self.transactions_root(), gas).await?,
+            receipts_root: asc_new(heap, self.receipts_root(), gas).await?,
+            number: asc_new(heap, &BigInt::from(self.number()), gas).await?,
+            gas_used: asc_new(heap, &BigInt::from(self.gas_used()), gas).await?,
+            gas_limit: asc_new(heap, &BigInt::from(self.gas_limit()), gas).await?,
+            timestamp: asc_new(heap, &BigInt::from(self.timestamp()), gas).await?,
+            difficulty: asc_new(heap, &BigInt::from_unsigned_u256(self.difficulty()), gas).await?,
             total_difficulty: asc_new(
                 heap,
-                &BigInt::from_unsigned_u256(&self.total_difficulty),
+                &BigInt::from_unsigned_u256(self.total_difficulty()),
                 gas,
-            )?,
-            size: self
-                .size
-                .map(|size| asc_new(heap, &BigInt::from_unsigned_u256(&size), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            base_fee_per_block: self
-                .base_fee_per_gas
-                .map(|base_fee| asc_new(heap, &BigInt::from_unsigned_u256(&base_fee), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
+            )
+            .await?,
+            size,
+            base_fee_per_block,
         })
     }
 }
 
-impl ToAscObj<AscEthereumTransaction_0_0_1> for EthereumTransactionData {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl<'a> ToAscObj<AscEthereumTransaction_0_0_1> for EthereumTransactionData<'a> {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEthereumTransaction_0_0_1, HostExportError> {
         Ok(AscEthereumTransaction_0_0_1 {
-            hash: asc_new(heap, &self.hash, gas)?,
-            index: asc_new(heap, &BigInt::from_unsigned_u128(self.index), gas)?,
-            from: asc_new(heap, &self.from, gas)?,
-            to: self
-                .to
-                .map(|to| asc_new(heap, &to, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            value: asc_new(heap, &BigInt::from_unsigned_u256(&self.value), gas)?,
-            gas_limit: asc_new(heap, &BigInt::from_unsigned_u256(&self.gas_limit), gas)?,
-            gas_price: asc_new(heap, &BigInt::from_unsigned_u256(&self.gas_price), gas)?,
+            hash: asc_new(heap, &self.hash(), gas).await?,
+            index: asc_new(heap, &BigInt::from(self.index()), gas).await?,
+            from: asc_new(heap, &self.from(), gas).await?,
+            to: asc_new_or_null(heap, &self.to(), gas).await?,
+            value: asc_new(heap, &BigInt::from_unsigned_u256(&self.value()), gas).await?,
+            gas_limit: asc_new(heap, &BigInt::from(self.gas_limit()), gas).await?,
+            gas_price: asc_new(heap, &BigInt::from(self.gas_price()), gas).await?,
         })
     }
 }
 
-impl ToAscObj<AscEthereumTransaction_0_0_2> for EthereumTransactionData {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl<'a> ToAscObj<AscEthereumTransaction_0_0_2> for EthereumTransactionData<'a> {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEthereumTransaction_0_0_2, HostExportError> {
         Ok(AscEthereumTransaction_0_0_2 {
-            hash: asc_new(heap, &self.hash, gas)?,
-            index: asc_new(heap, &BigInt::from_unsigned_u128(self.index), gas)?,
-            from: asc_new(heap, &self.from, gas)?,
-            to: self
-                .to
-                .map(|to| asc_new(heap, &to, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            value: asc_new(heap, &BigInt::from_unsigned_u256(&self.value), gas)?,
-            gas_limit: asc_new(heap, &BigInt::from_unsigned_u256(&self.gas_limit), gas)?,
-            gas_price: asc_new(heap, &BigInt::from_unsigned_u256(&self.gas_price), gas)?,
-            input: asc_new(heap, &*self.input, gas)?,
+            hash: asc_new(heap, &self.hash(), gas).await?,
+            index: asc_new(heap, &BigInt::from(self.index()), gas).await?,
+            from: asc_new(heap, &self.from(), gas).await?,
+            to: asc_new_or_null(heap, &self.to(), gas).await?,
+            value: asc_new(heap, &BigInt::from_unsigned_u256(&self.value()), gas).await?,
+            gas_limit: asc_new(heap, &BigInt::from(self.gas_limit()), gas).await?,
+            gas_price: asc_new(heap, &BigInt::from(self.gas_price()), gas).await?,
+            input: asc_new(heap, self.input(), gas).await?,
         })
     }
 }
 
-impl ToAscObj<AscEthereumTransaction_0_0_6> for EthereumTransactionData {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl<'a> ToAscObj<AscEthereumTransaction_0_0_6> for EthereumTransactionData<'a> {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEthereumTransaction_0_0_6, HostExportError> {
         Ok(AscEthereumTransaction_0_0_6 {
-            hash: asc_new(heap, &self.hash, gas)?,
-            index: asc_new(heap, &BigInt::from_unsigned_u128(self.index), gas)?,
-            from: asc_new(heap, &self.from, gas)?,
-            to: self
-                .to
-                .map(|to| asc_new(heap, &to, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            value: asc_new(heap, &BigInt::from_unsigned_u256(&self.value), gas)?,
-            gas_limit: asc_new(heap, &BigInt::from_unsigned_u256(&self.gas_limit), gas)?,
-            gas_price: asc_new(heap, &BigInt::from_unsigned_u256(&self.gas_price), gas)?,
-            input: asc_new(heap, &*self.input, gas)?,
-            nonce: asc_new(heap, &BigInt::from_unsigned_u256(&self.nonce), gas)?,
+            hash: asc_new(heap, &self.hash(), gas).await?,
+            index: asc_new(heap, &BigInt::from(self.index()), gas).await?,
+            from: asc_new(heap, &self.from(), gas).await?,
+            to: asc_new_or_null(heap, &self.to(), gas).await?,
+            value: asc_new(heap, &BigInt::from_unsigned_u256(&self.value()), gas).await?,
+            gas_limit: asc_new(heap, &BigInt::from(self.gas_limit()), gas).await?,
+            gas_price: asc_new(heap, &BigInt::from(self.gas_price()), gas).await?,
+            input: asc_new(heap, self.input(), gas).await?,
+            nonce: asc_new(heap, &BigInt::from(self.nonce()), gas).await?,
         })
     }
 }
 
-impl<T, B> ToAscObj<AscEthereumEvent<T, B>> for EthereumEventData
+#[async_trait]
+impl<'a, T, B> ToAscObj<AscEthereumEvent<T, B>> for EthereumEventData<'a>
 where
-    T: AscType + AscIndexId,
-    B: AscType + AscIndexId,
-    EthereumTransactionData: ToAscObj<T>,
-    EthereumBlockData: ToAscObj<B>,
+    T: AscType + AscIndexId + Send,
+    B: AscType + AscIndexId + Send,
+    EthereumTransactionData<'a>: ToAscObj<T>,
+    EthereumBlockData<'a>: ToAscObj<B>,
 {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEthereumEvent<T, B>, HostExportError> {
         Ok(AscEthereumEvent {
-            address: asc_new(heap, &self.address, gas)?,
-            log_index: asc_new(heap, &BigInt::from_unsigned_u256(&self.log_index), gas)?,
-            transaction_log_index: asc_new(
-                heap,
-                &BigInt::from_unsigned_u256(&self.transaction_log_index),
-                gas,
-            )?,
-            log_type: self
-                .log_type
-                .clone()
-                .map(|log_type| asc_new(heap, &log_type, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            block: asc_new::<B, EthereumBlockData, _>(heap, &self.block, gas)?,
-            transaction: asc_new::<T, EthereumTransactionData, _>(heap, &self.transaction, gas)?,
-            params: asc_new(heap, &self.params, gas)?,
+            address: asc_new(heap, self.address(), gas).await?,
+            log_index: asc_new(heap, &BigInt::from(self.log_index()), gas).await?,
+            transaction_log_index: asc_new(heap, &BigInt::from(self.transaction_log_index()), gas)
+                .await?,
+            log_type: asc_new_or_null(heap, &self.log_type().as_ref(), gas).await?,
+            block: asc_new::<B, EthereumBlockData, _>(heap, &self.block, gas).await?,
+            transaction: asc_new::<T, EthereumTransactionData, _>(heap, &self.transaction, gas)
+                .await?,
+            params: asc_new(heap, &self.params, gas).await?,
         })
     }
 }
 
-impl<T, B> ToAscObj<AscEthereumEvent_0_0_7<T, B>>
-    for (EthereumEventData, Option<&TransactionReceipt>)
+#[async_trait]
+impl<'a, T, B, Inner> ToAscObj<AscEthereumEvent_0_0_7<T, B>>
+    for (EthereumEventData<'a>, Option<&TransactionReceipt<Inner>>)
 where
-    T: AscType + AscIndexId,
-    B: AscType + AscIndexId,
-    EthereumTransactionData: ToAscObj<T>,
-    EthereumBlockData: ToAscObj<B>,
+    T: AscType + AscIndexId + Send,
+    B: AscType + AscIndexId + Send,
+    EthereumTransactionData<'a>: ToAscObj<T>,
+    EthereumBlockData<'a>: ToAscObj<B>,
+    Inner: Send + Sync,
+    TransactionReceipt<Inner>: ToAscObj<AscEthereumTransactionReceipt>,
 {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -601,9 +609,9 @@ where
             block,
             transaction,
             params,
-        } = event_data.to_asc_obj(heap, gas)?;
+        } = event_data.to_asc_obj(heap, gas).await?;
         let receipt = if let Some(receipt_data) = optional_receipt {
-            asc_new(heap, receipt_data, gas)?
+            asc_new(heap, receipt_data, gas).await?
         } else {
             AscPtr::null()
         };
@@ -620,117 +628,115 @@ where
     }
 }
 
+async fn asc_new_or_null_u256<H: AscHeap + ?Sized>(
+    heap: &mut H,
+    value: &Option<alloy::primitives::U256>,
+    gas: &GasCounter,
+) -> Result<AscPtr<AscBigInt>, HostExportError> {
+    match value {
+        Some(value) => asc_new(heap, &BigInt::from_unsigned_u256(value), gas).await,
+        None => Ok(AscPtr::null()),
+    }
+}
+
+async fn asc_new_or_null_u64<H: AscHeap + ?Sized>(
+    heap: &mut H,
+    value: &Option<u64>,
+    gas: &GasCounter,
+) -> Result<AscPtr<AscBigInt>, HostExportError> {
+    match value {
+        Some(value) => asc_new(heap, &BigInt::from(*value), gas).await,
+        None => Ok(AscPtr::null()),
+    }
+}
+
+#[async_trait]
 impl ToAscObj<AscEthereumLog> for Log {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEthereumLog, HostExportError> {
         Ok(AscEthereumLog {
-            address: asc_new(heap, &self.address, gas)?,
-            topics: asc_new(heap, &self.topics, gas)?,
-            data: asc_new(heap, self.data.0.as_slice(), gas)?,
-            block_hash: self
-                .block_hash
-                .map(|block_hash| asc_new(heap, &block_hash, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            block_number: self
-                .block_number
-                .map(|block_number| asc_new(heap, &BigInt::from(block_number), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            transaction_hash: self
-                .transaction_hash
-                .map(|txn_hash| asc_new(heap, &txn_hash, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            transaction_index: self
-                .transaction_index
-                .map(|txn_index| asc_new(heap, &BigInt::from(txn_index), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            log_index: self
-                .log_index
-                .map(|log_index| asc_new(heap, &BigInt::from_unsigned_u256(&log_index), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            transaction_log_index: self
-                .transaction_log_index
-                .map(|index| asc_new(heap, &BigInt::from_unsigned_u256(&index), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            log_type: self
-                .log_type
-                .as_ref()
-                .map(|log_type| asc_new(heap, &log_type, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            removed: self
-                .removed
-                .map(|removed| asc_new(heap, &AscWrapped { inner: removed }, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
+            address: asc_new(heap, &self.address(), gas).await?,
+            topics: asc_new(heap, &self.topics(), gas).await?,
+            data: asc_new(heap, self.data().data.as_ref(), gas).await?,
+            block_hash: asc_new_or_null(heap, &self.block_hash, gas).await?,
+            block_number: asc_new_or_null_u64(heap, &self.block_number, gas).await?,
+            transaction_hash: asc_new_or_null(heap, &self.transaction_hash, gas).await?,
+            transaction_index: asc_new_or_null_u64(heap, &self.transaction_index, gas).await?,
+            log_index: asc_new_or_null_u64(heap, &self.log_index, gas).await?,
+            transaction_log_index: AscPtr::null(), // Non-standard field, not available in alloy
+            log_type: AscPtr::null(),              // Non-standard field, not available in alloy
+            removed: asc_new(
+                heap,
+                &AscWrapped {
+                    inner: self.removed,
+                },
+                gas,
+            )
+            .await?,
         })
     }
 }
 
-impl ToAscObj<AscEthereumTransactionReceipt> for &TransactionReceipt {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl ToAscObj<AscEthereumTransactionReceipt>
+    for TransactionReceipt<alloy::network::AnyReceiptEnvelope<Log>>
+{
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEthereumTransactionReceipt, HostExportError> {
+        let transaction_index = self
+            .transaction_index
+            .ok_or(HostExportError::Unknown(anyhow!(
+                "Transaction index is missing"
+            )))?;
+        let status = match self.inner.status_or_post_state().as_eip658() {
+            Some(success) => asc_new(heap, &BigInt::from(success as u64), gas).await?,
+            None => AscPtr::null(), // Pre-EIP-658 (pre-Byzantium) receipt
+        };
         Ok(AscEthereumTransactionReceipt {
-            transaction_hash: asc_new(heap, &self.transaction_hash, gas)?,
-            transaction_index: asc_new(heap, &BigInt::from(self.transaction_index), gas)?,
-            block_hash: self
-                .block_hash
-                .map(|block_hash| asc_new(heap, &block_hash, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            block_number: self
-                .block_number
-                .map(|block_number| asc_new(heap, &BigInt::from(block_number), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            cumulative_gas_used: asc_new(
-                heap,
-                &BigInt::from_unsigned_u256(&self.cumulative_gas_used),
-                gas,
-            )?,
-            gas_used: self
-                .gas_used
-                .map(|gas_used| asc_new(heap, &BigInt::from_unsigned_u256(&gas_used), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            contract_address: self
-                .contract_address
-                .map(|contract_address| asc_new(heap, &contract_address, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            logs: asc_new(heap, &self.logs, gas)?,
-            status: self
-                .status
-                .map(|status| asc_new(heap, &BigInt::from(status), gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            root: self
-                .root
-                .map(|root| asc_new(heap, &root, gas))
-                .unwrap_or(Ok(AscPtr::null()))?,
-            logs_bloom: asc_new(heap, self.logs_bloom.as_bytes(), gas)?,
+            transaction_hash: asc_new(heap, &self.transaction_hash, gas).await?,
+            transaction_index: asc_new(heap, &BigInt::from(transaction_index), gas).await?,
+            block_hash: asc_new_or_null(heap, &self.block_hash, gas).await?,
+            block_number: asc_new_or_null_u64(heap, &self.block_number, gas).await?,
+            cumulative_gas_used: asc_new(heap, &BigInt::from(self.cumulative_gas_used()), gas)
+                .await?,
+            gas_used: asc_new(heap, &BigInt::from(self.gas_used), gas).await?,
+            contract_address: asc_new_or_null(heap, &self.contract_address, gas).await?,
+            logs: asc_new(heap, &self.logs(), gas).await?,
+            status,
+            root: asc_new_or_null(heap, &self.state_root(), gas).await?,
+            logs_bloom: asc_new(heap, self.inner.bloom().as_slice(), gas).await?,
         })
     }
 }
 
-impl ToAscObj<AscEthereumCall> for EthereumCallData {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl<'a> ToAscObj<AscEthereumCall> for EthereumCallData<'a> {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEthereumCall, HostExportError> {
         Ok(AscEthereumCall {
-            address: asc_new(heap, &self.to, gas)?,
-            block: asc_new(heap, &self.block, gas)?,
-            transaction: asc_new(heap, &self.transaction, gas)?,
-            inputs: asc_new(heap, &self.inputs, gas)?,
-            outputs: asc_new(heap, &self.outputs, gas)?,
+            address: asc_new(heap, self.to(), gas).await?,
+            block: asc_new(heap, &self.block, gas).await?,
+            transaction: asc_new(heap, &self.transaction, gas).await?,
+            inputs: asc_new(heap, &self.inputs, gas).await?,
+            outputs: asc_new(heap, &self.outputs, gas).await?,
         })
     }
 }
 
-impl ToAscObj<AscEthereumCall_0_0_3<AscEthereumTransaction_0_0_2, AscEthereumBlock>>
-    for EthereumCallData
+#[async_trait]
+impl<'a> ToAscObj<AscEthereumCall_0_0_3<AscEthereumTransaction_0_0_2, AscEthereumBlock>>
+    for EthereumCallData<'a>
 {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -739,20 +745,21 @@ impl ToAscObj<AscEthereumCall_0_0_3<AscEthereumTransaction_0_0_2, AscEthereumBlo
         HostExportError,
     > {
         Ok(AscEthereumCall_0_0_3 {
-            to: asc_new(heap, &self.to, gas)?,
-            from: asc_new(heap, &self.from, gas)?,
-            block: asc_new(heap, &self.block, gas)?,
-            transaction: asc_new(heap, &self.transaction, gas)?,
-            inputs: asc_new(heap, &self.inputs, gas)?,
-            outputs: asc_new(heap, &self.outputs, gas)?,
+            to: asc_new(heap, self.to(), gas).await?,
+            from: asc_new(heap, self.from(), gas).await?,
+            block: asc_new(heap, &self.block, gas).await?,
+            transaction: asc_new(heap, &self.transaction, gas).await?,
+            inputs: asc_new(heap, &self.inputs, gas).await?,
+            outputs: asc_new(heap, &self.outputs, gas).await?,
         })
     }
 }
 
-impl ToAscObj<AscEthereumCall_0_0_3<AscEthereumTransaction_0_0_6, AscEthereumBlock_0_0_6>>
-    for EthereumCallData
+#[async_trait]
+impl<'a> ToAscObj<AscEthereumCall_0_0_3<AscEthereumTransaction_0_0_6, AscEthereumBlock_0_0_6>>
+    for EthereumCallData<'a>
 {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -761,25 +768,26 @@ impl ToAscObj<AscEthereumCall_0_0_3<AscEthereumTransaction_0_0_6, AscEthereumBlo
         HostExportError,
     > {
         Ok(AscEthereumCall_0_0_3 {
-            to: asc_new(heap, &self.to, gas)?,
-            from: asc_new(heap, &self.from, gas)?,
-            block: asc_new(heap, &self.block, gas)?,
-            transaction: asc_new(heap, &self.transaction, gas)?,
-            inputs: asc_new(heap, &self.inputs, gas)?,
-            outputs: asc_new(heap, &self.outputs, gas)?,
+            to: asc_new(heap, self.to(), gas).await?,
+            from: asc_new(heap, self.from(), gas).await?,
+            block: asc_new(heap, &self.block, gas).await?,
+            transaction: asc_new(heap, &self.transaction, gas).await?,
+            inputs: asc_new(heap, &self.inputs, gas).await?,
+            outputs: asc_new(heap, &self.outputs, gas).await?,
         })
     }
 }
 
-impl ToAscObj<AscLogParam> for ethabi::LogParam {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl ToAscObj<AscLogParam> for abi::DynSolParam {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscLogParam, HostExportError> {
         Ok(AscLogParam {
-            name: asc_new(heap, self.name.as_str(), gas)?,
-            value: asc_new(heap, &self.value, gas)?,
+            name: asc_new(heap, self.name.as_str(), gas).await?,
+            value: asc_new(heap, &self.value, gas).await?,
         })
     }
 }
diff --git a/chain/ethereum/src/runtime/runtime_adapter.rs b/chain/ethereum/src/runtime/runtime_adapter.rs
index 3ba3d3235df..a5d68a761a7 100644
--- a/chain/ethereum/src/runtime/runtime_adapter.rs
+++ b/chain/ethereum/src/runtime/runtime_adapter.rs
@@ -1,29 +1,34 @@
 use std::{sync::Arc, time::Instant};
 
-use crate::data_source::MappingABI;
+use crate::adapter::EthereumRpcError;
 use crate::{
-    capabilities::NodeCapabilities, network::EthereumNetworkAdapters, Chain, DataSource,
-    EthereumAdapter, EthereumAdapterTrait, EthereumContractCall, EthereumContractCallError,
-    ENV_VARS,
+    Chain, ContractCallError, ENV_VARS, EthereumAdapter, EthereumAdapterTrait,
+    capabilities::NodeCapabilities, network::EthereumNetworkAdapters,
 };
-use anyhow::{Context, Error};
+use anyhow::{Context, Error, anyhow};
 use blockchain::HostFn;
+use graph::abi;
+use graph::abi::DynSolValueExt;
 use graph::blockchain::ChainIdentifier;
 use graph::components::subgraph::HostMetrics;
+use graph::data::store::ethereum::call;
+use graph::data::store::scalar::BigInt;
+use graph::data::subgraph::{API_VERSION_0_0_4, API_VERSION_0_0_9};
+use graph::data_source;
+use graph::data_source::common::{ContractCall, MappingABI};
 use graph::runtime::gas::Gas;
 use graph::runtime::{AscIndexId, IndexForAscTypeId};
+use graph::slog::debug;
 use graph::{
     blockchain::{self, BlockPtr, HostFnCtx},
     cheap_clone::CheapClone,
-    prelude::{
-        ethabi::{self, Address, Token},
-        EthereumCallCache, Future01CompatExt,
-    },
-    runtime::{asc_get, asc_new, AscPtr, HostExportError},
-    semver::Version,
-    slog::{info, trace, Logger},
+    futures03::FutureExt,
+    prelude::{EthereumCallCache, alloy::primitives::Address},
+    runtime::{AscPtr, HostExportError, asc_get, asc_new},
+    slog::Logger,
 };
-use graph_runtime_wasm::asc_abi::class::{AscEnumArray, EthereumValueKind};
+use graph_runtime_wasm::asc_abi::class::{AscBigInt, AscEnumArray, AscWrapped, EthereumValueKind};
+use itertools::Itertools;
 
 use super::abi::{AscUnresolvedContractCall, AscUnresolvedContractCall_0_0_4};
 
@@ -47,56 +52,143 @@ const ETH_CALL_GAS: u32 = 50_000_000;
 // [1] - https://www.sciencedirect.com/science/article/abs/pii/S0166531620300900
 pub const ETHEREUM_CALL: Gas = Gas::new(5_000_000_000);
 
+// TODO: Determine the appropriate gas cost for `ETH_GET_BALANCE`, initially aligned with `ETHEREUM_CALL`.
+pub const ETH_GET_BALANCE: Gas = Gas::new(5_000_000_000);
+
+// TODO: Determine the appropriate gas cost for `ETH_HAS_CODE`, initially aligned with `ETHEREUM_CALL`.
+pub const ETH_HAS_CODE: Gas = Gas::new(5_000_000_000);
+
 pub struct RuntimeAdapter {
     pub eth_adapters: Arc<EthereumNetworkAdapters>,
     pub call_cache: Arc<dyn EthereumCallCache>,
     pub chain_identifier: Arc<ChainIdentifier>,
 }
 
+pub fn eth_call_gas(chain_identifier: &ChainIdentifier) -> Option<u32> {
+    // Check if the current network version is in the eth_call_no_gas list
+    let should_skip_gas = ENV_VARS
+        .eth_call_no_gas
+        .contains(&chain_identifier.net_version);
+
+    if should_skip_gas {
+        None
+    } else {
+        Some(ETH_CALL_GAS)
+    }
+}
+
 impl blockchain::RuntimeAdapter<Chain> for RuntimeAdapter {
-    fn host_fns(&self, ds: &DataSource) -> Result<Vec<HostFn>, Error> {
-        let abis = ds.mapping.abis.clone();
-        let call_cache = self.call_cache.cheap_clone();
-        let eth_adapters = self.eth_adapters.cheap_clone();
-        let archive = ds.mapping.requires_archive()?;
-
-        // Check if the current network version is in the eth_call_no_gas list
-        let should_skip_gas = ENV_VARS
-            .eth_call_no_gas
-            .contains(&self.chain_identifier.net_version);
-
-        let eth_call_gas = if should_skip_gas {
-            None
-        } else {
-            Some(ETH_CALL_GAS)
-        };
+    fn host_fns(&self, ds: &data_source::DataSource<Chain>) -> Result<Vec<HostFn>, Error> {
+        fn create_host_fns(
+            abis: Arc<Vec<Arc<MappingABI>>>, // Use Arc to ensure `'static` lifetimes.
+            archive: bool,
+            call_cache: Arc<dyn EthereumCallCache>,
+            eth_adapters: Arc<EthereumNetworkAdapters>,
+            eth_call_gas: Option<u32>,
+        ) -> Vec<HostFn> {
+            vec![
+                HostFn {
+                    name: "ethereum.call",
+                    func: Arc::new({
+                        let eth_adapters = eth_adapters.clone();
+                        let call_cache = call_cache.clone();
+                        let abis = abis.clone();
+                        move |ctx, wasm_ptr| {
+                            let eth_adapters = eth_adapters.cheap_clone();
+                            let call_cache = call_cache.cheap_clone();
+                            let abis = abis.cheap_clone();
+                            async move {
+                                let eth_adapter =
+                                    eth_adapters.call_or_cheapest(Some(&NodeCapabilities {
+                                        archive,
+                                        traces: false,
+                                    }))?;
+                                ethereum_call(
+                                    &eth_adapter,
+                                    call_cache.clone(),
+                                    ctx,
+                                    wasm_ptr,
+                                    &abis,
+                                    eth_call_gas,
+                                )
+                                .await
+                                .map(|ptr| ptr.wasm_ptr())
+                            }
+                            .boxed()
+                        }
+                    }),
+                },
+                HostFn {
+                    name: "ethereum.getBalance",
+                    func: Arc::new({
+                        let eth_adapters = eth_adapters.clone();
+                        move |ctx, wasm_ptr| {
+                            let eth_adapters = eth_adapters.cheap_clone();
+                            async move {
+                                let eth_adapter =
+                                    eth_adapters.unverified_cheapest_with(&NodeCapabilities {
+                                        archive,
+                                        traces: false,
+                                    })?;
+                                eth_get_balance(&eth_adapter, ctx, wasm_ptr)
+                                    .await
+                                    .map(|ptr| ptr.wasm_ptr())
+                            }
+                            .boxed()
+                        }
+                    }),
+                },
+                HostFn {
+                    name: "ethereum.hasCode",
+                    func: Arc::new({
+                        move |ctx, wasm_ptr| {
+                            let eth_adapters = eth_adapters.cheap_clone();
+                            async move {
+                                let eth_adapter =
+                                    eth_adapters.unverified_cheapest_with(&NodeCapabilities {
+                                        archive,
+                                        traces: false,
+                                    })?;
+                                eth_has_code(&eth_adapter, ctx, wasm_ptr)
+                                    .await
+                                    .map(|ptr| ptr.wasm_ptr())
+                            }
+                            .boxed()
+                        }
+                    }),
+                },
+            ]
+        }
 
-        let ethereum_call = HostFn {
-            name: "ethereum.call",
-            func: Arc::new(move |ctx, wasm_ptr| {
-                // Ethereum calls should prioritise call-only adapters if one is available.
-                let eth_adapter = eth_adapters.call_or_cheapest(Some(&NodeCapabilities {
-                    archive,
-                    traces: false,
-                }))?;
-                ethereum_call(
-                    &eth_adapter,
-                    call_cache.cheap_clone(),
-                    ctx,
-                    wasm_ptr,
-                    &abis,
-                    eth_call_gas,
-                )
-                .map(|ptr| ptr.wasm_ptr())
-            }),
+        let host_fns = match ds {
+            data_source::DataSource::Onchain(onchain_ds) => {
+                let abis = Arc::new(onchain_ds.mapping.abis.clone());
+                let archive = onchain_ds.mapping.requires_archive()?;
+                let call_cache = self.call_cache.cheap_clone();
+                let eth_adapters = self.eth_adapters.cheap_clone();
+                let eth_call_gas = eth_call_gas(&self.chain_identifier);
+
+                create_host_fns(abis, archive, call_cache, eth_adapters, eth_call_gas)
+            }
+            data_source::DataSource::Subgraph(subgraph_ds) => {
+                let abis = Arc::new(subgraph_ds.mapping.abis.clone());
+                let archive = subgraph_ds.mapping.requires_archive()?;
+                let call_cache = self.call_cache.cheap_clone();
+                let eth_adapters = self.eth_adapters.cheap_clone();
+                let eth_call_gas = eth_call_gas(&self.chain_identifier);
+
+                create_host_fns(abis, archive, call_cache, eth_adapters, eth_call_gas)
+            }
+            data_source::DataSource::Offchain(_) => vec![],
+            data_source::DataSource::Amp(_) => vec![],
         };
 
-        Ok(vec![ethereum_call])
+        Ok(host_fns)
     }
 }
 
 /// function ethereum.call(call: SmartContractCall): Array<Token> | null
-fn ethereum_call(
+async fn ethereum_call(
     eth_adapter: &EthereumAdapter,
     call_cache: Arc<dyn EthereumCallCache>,
     ctx: HostFnCtx<'_>,
@@ -110,7 +202,7 @@ fn ethereum_call(
     // For apiVersion >= 0.0.4 the call passed from the mapping includes the
     // function signature; subgraphs using an apiVersion < 0.0.4 don't pass
     // the signature along with the call.
-    let call: UnresolvedContractCall = if ctx.heap.api_version() >= Version::new(0, 0, 4) {
+    let call: UnresolvedContractCall = if ctx.heap.api_version() >= &API_VERSION_0_0_4 {
         asc_get::<_, AscUnresolvedContractCall_0_0_4, _>(ctx.heap, wasm_ptr.into(), &ctx.gas, 0)?
     } else {
         asc_get::<_, AscUnresolvedContractCall, _>(ctx.heap, wasm_ptr.into(), &ctx.gas, 0)?
@@ -125,15 +217,86 @@ fn ethereum_call(
         abis,
         eth_call_gas,
         ctx.metrics.cheap_clone(),
-    )?;
+    )
+    .await?;
     match result {
-        Some(tokens) => Ok(asc_new(ctx.heap, tokens.as_slice(), &ctx.gas)?),
+        Some(tokens) => Ok(asc_new(ctx.heap, tokens.as_slice(), &ctx.gas).await?),
         None => Ok(AscPtr::null()),
     }
 }
 
+async fn eth_get_balance(
+    eth_adapter: &EthereumAdapter,
+    ctx: HostFnCtx<'_>,
+    wasm_ptr: u32,
+) -> Result<AscPtr<AscBigInt>, HostExportError> {
+    ctx.gas
+        .consume_host_fn_with_metrics(ETH_GET_BALANCE, "eth_get_balance")?;
+
+    if ctx.heap.api_version() < &API_VERSION_0_0_9 {
+        return Err(HostExportError::Deterministic(anyhow!(
+            "ethereum.getBalance call is not supported before API version 0.0.9"
+        )));
+    }
+
+    let logger = &ctx.logger;
+    let block_ptr = &ctx.block_ptr;
+
+    let address: Address = asc_get(ctx.heap, wasm_ptr.into(), &ctx.gas, 0)?;
+
+    let result = eth_adapter
+        .get_balance(logger, address, block_ptr.clone())
+        .await;
+
+    match result {
+        Ok(v) => {
+            let bigint = BigInt::from_unsigned_u256(&v);
+            Ok(asc_new(ctx.heap, &bigint, &ctx.gas).await?)
+        }
+        // Retry on any kind of error
+        Err(EthereumRpcError::AlloyError(e)) => Err(HostExportError::PossibleReorg(e.into())),
+        Err(EthereumRpcError::Timeout) => Err(HostExportError::PossibleReorg(
+            EthereumRpcError::Timeout.into(),
+        )),
+    }
+}
+
+async fn eth_has_code(
+    eth_adapter: &EthereumAdapter,
+    ctx: HostFnCtx<'_>,
+    wasm_ptr: u32,
+) -> Result<AscPtr<AscWrapped<bool>>, HostExportError> {
+    ctx.gas
+        .consume_host_fn_with_metrics(ETH_HAS_CODE, "eth_has_code")?;
+
+    if ctx.heap.api_version() < &API_VERSION_0_0_9 {
+        return Err(HostExportError::Deterministic(anyhow!(
+            "ethereum.hasCode call is not supported before API version 0.0.9"
+        )));
+    }
+
+    let logger = &ctx.logger;
+    let block_ptr = &ctx.block_ptr;
+
+    let address: Address = asc_get(ctx.heap, wasm_ptr.into(), &ctx.gas, 0)?;
+
+    let result = eth_adapter
+        .get_code(logger, address, block_ptr.clone())
+        .await
+        .map(|v| !v.0.is_empty());
+
+    match result {
+        Ok(v) => Ok(asc_new(ctx.heap, &AscWrapped { inner: v }, &ctx.gas).await?),
+        // Retry on any kind of error
+        Err(EthereumRpcError::AlloyError(e)) => Err(HostExportError::PossibleReorg(e.into())),
+        Err(EthereumRpcError::Timeout) => Err(HostExportError::PossibleReorg(
+            EthereumRpcError::Timeout.into(),
+        )),
+    }
+}
+
 /// Returns `Ok(None)` if the call was reverted.
-fn eth_call(
+async fn eth_call(
     eth_adapter: &EthereumAdapter,
     call_cache: Arc<dyn EthereumCallCache>,
     logger: &Logger,
@@ -142,11 +305,11 @@ fn eth_call(
     abis: &[Arc<MappingABI>],
     eth_call_gas: Option<u32>,
     metrics: Arc<HostMetrics>,
-) -> Result<Option<Vec<Token>>, HostExportError> {
+) -> Result<Option<Vec<abi::DynSolValue>>, HostExportError> {
     let start_time = Instant::now();
 
     // Obtain the path to the contract ABI
-    let contract = abis
+    let abi = abis
         .iter()
         .find(|abi| abi.name == unresolved_call.contract_name)
         .with_context(|| {
@@ -156,51 +319,18 @@ fn eth_call(
                 unresolved_call.contract_name
             )
         })
-        .map_err(HostExportError::Deterministic)?
-        .contract
-        .clone();
-
-    let function = match unresolved_call.function_signature {
-        // Behavior for apiVersion < 0.0.4: look up function by name; for overloaded
-        // functions this always picks the same overloaded variant, which is incorrect
-        // and may lead to encoding/decoding errors
-        None => contract
-            .function(unresolved_call.function_name.as_str())
-            .with_context(|| {
-                format!(
-                    "Unknown function \"{}::{}\" called from WASM runtime",
-                    unresolved_call.contract_name, unresolved_call.function_name
-                )
-            })
-            .map_err(HostExportError::Deterministic)?,
-
-        // Behavior for apiVersion >= 0.0.04: look up function by signature of
-        // the form `functionName(uint256,string) returns (bytes32,string)`; this
-        // correctly picks the correct variant of an overloaded function
-        Some(ref function_signature) => contract
-            .functions_by_name(unresolved_call.function_name.as_str())
-            .with_context(|| {
-                format!(
-                    "Unknown function \"{}::{}\" called from WASM runtime",
-                    unresolved_call.contract_name, unresolved_call.function_name
-                )
-            })
-            .map_err(HostExportError::Deterministic)?
-            .iter()
-            .find(|f| function_signature == &f.signature())
-            .with_context(|| {
-                format!(
-                    "Unknown function \"{}::{}\" with signature `{}` \
-                         called from WASM runtime",
-                    unresolved_call.contract_name,
-                    unresolved_call.function_name,
-                    function_signature,
-                )
-            })
-            .map_err(HostExportError::Deterministic)?,
-    };
+        .map_err(HostExportError::Deterministic)?;
+
+    let function = abi
+        .function(
+            &unresolved_call.contract_name,
+            &unresolved_call.function_name,
+            unresolved_call.function_signature.as_deref(),
+        )
+        .map_err(HostExportError::Deterministic)?;
 
-    let call = EthereumContractCall {
+    let call = ContractCall {
+        contract_name: unresolved_call.contract_name.clone(),
         address: unresolved_call.contract_address,
         block_ptr: block_ptr.cheap_clone(),
         function: function.clone(),
@@ -211,55 +341,70 @@ fn eth_call(
     // Run Ethereum call in tokio runtime
     let logger1 = logger.clone();
     let call_cache = call_cache.clone();
-    let result = match graph::block_on(
-            eth_adapter.contract_call(&logger1, call, call_cache).compat()
-        ) {
-            Ok(tokens) => Ok(Some(tokens)),
-            Err(EthereumContractCallError::Revert(reason)) => {
-                info!(logger, "Contract call reverted"; "reason" => reason);
-                Ok(None)
-            }
+    let (result, source) = match eth_adapter.contract_call(&logger1, &call, call_cache).await {
+        Ok((result, source)) => (Ok(result), source),
+        Err(e) => (Err(e), call::Source::Rpc),
+    };
+    let result = match result {
+        Ok(res) => Ok(res),
 
-            // Any error reported by the Ethereum node could be due to the block no longer being on
-            // the main chain. This is very unespecific but we don't want to risk failing a
-            // subgraph due to a transient error such as a reorg.
-            Err(EthereumContractCallError::Web3Error(e)) => Err(HostExportError::PossibleReorg(anyhow::anyhow!(
+        // Any error reported by the Ethereum node could be due to the block no longer being on
+        // the main chain. This is very unespecific but we don't want to risk failing a
+        // subgraph due to a transient error such as a reorg.
+        Err(ContractCallError::AlloyError(e)) => {
+            Err(HostExportError::PossibleReorg(anyhow::anyhow!(
                 "Ethereum node returned an error when calling function \"{}\" of contract \"{}\": {}",
                 unresolved_call.function_name,
                 unresolved_call.contract_name,
                 e
-            ))),
+            )))
+        }
 
-            // Also retry on timeouts.
-            Err(EthereumContractCallError::Timeout) => Err(HostExportError::PossibleReorg(anyhow::anyhow!(
-                "Ethereum node did not respond when calling function \"{}\" of contract \"{}\"",
-                unresolved_call.function_name,
-                unresolved_call.contract_name,
-            ))),
+        // Also retry on timeouts.
+        Err(ContractCallError::Timeout) => Err(HostExportError::PossibleReorg(anyhow::anyhow!(
+            "Ethereum node did not respond when calling function \"{}\" of contract \"{}\"",
+            unresolved_call.function_name,
+            unresolved_call.contract_name,
+        ))),
 
-            Err(e) => Err(HostExportError::Unknown(anyhow::anyhow!(
-                "Failed to call function \"{}\" of contract \"{}\": {}",
-                unresolved_call.function_name,
-                unresolved_call.contract_name,
-                e
-            ))),
-        };
+        Err(e) => Err(HostExportError::Unknown(anyhow::anyhow!(
+            "Failed to call function \"{}\" of contract \"{}\": {}",
+            unresolved_call.function_name,
+            unresolved_call.contract_name,
+            e
+        ))),
+    };
 
     let elapsed = start_time.elapsed();
 
-    metrics.observe_eth_call_execution_time(
-        elapsed.as_secs_f64(),
-        &unresolved_call.contract_name,
-        &unresolved_call.contract_address.to_string(),
-        &unresolved_call.function_name,
-    );
+    if source.observe() {
+        metrics.observe_eth_call_execution_time(
+            elapsed.as_secs_f64(),
+            &unresolved_call.contract_name,
+            &unresolved_call.function_name,
+        );
+    }
 
-    trace!(logger, "Contract call finished";
-              "address" => &unresolved_call.contract_address.to_string(),
-              "contract" => &unresolved_call.contract_name,
-              "function" => &unresolved_call.function_name,
-              "function_signature" => &unresolved_call.function_signature,
-              "time" => format!("{}ms", elapsed.as_millis()));
+    let args_as_string = format!("[{}]", values_to_string(&unresolved_call.function_args));
+
+    let result_as_string = match &result {
+        Ok(Some(values)) => format!("({})", values_to_string(values)),
+        Ok(None) => "none".to_owned(),
+        Err(_err) => "error".to_owned(),
+    };
+
+    debug!(
+        logger, "Contract call finished";
+        "address" => format!("0x{:x}", &unresolved_call.contract_address),
+        "contract" => &unresolved_call.contract_name,
+        "signature" => &unresolved_call.function_signature,
+        "args" => args_as_string,
+        "time_ms" => format!("{}ms", elapsed.as_millis()),
+        "result" => result_as_string,
+        "block_hash" => block_ptr.hash_hex(),
+        "block_number" => block_ptr.block_number(),
+        "source" => source.to_string(),
+    );
 
     result
 }
@@ -270,9 +415,18 @@ pub struct UnresolvedContractCall {
     pub contract_address: Address,
     pub function_name: String,
     pub function_signature: Option<String>,
-    pub function_args: Vec<ethabi::Token>,
+    pub function_args: Vec<abi::DynSolValue>,
 }
 
 impl AscIndexId for AscUnresolvedContractCall {
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::SmartContractCall;
 }
+
+#[inline]
+fn values_to_string(values: &[abi::DynSolValue]) -> String {
+    values
+        .iter()
+        .map(|x| x.to_string())
+        .collect_vec()
+        .join(", ")
+}
diff --git a/chain/ethereum/src/tests.rs b/chain/ethereum/src/tests.rs
index 455a7c07432..a5f0a17bff0 100644
--- a/chain/ethereum/src/tests.rs
+++ b/chain/ethereum/src/tests.rs
@@ -1,12 +1,17 @@
 use std::sync::Arc;
 
 use graph::{
-    blockchain::{block_stream::BlockWithTriggers, BlockPtr},
+    blockchain::{BlockPtr, Trigger, block_stream::BlockWithTriggers},
     prelude::{
-        web3::types::{Address, Bytes, Log, H160, H256, U64},
         EthereumCall, LightEthereumBlock,
+        alloy::{
+            self,
+            primitives::{Address, B256, Bytes, LogData},
+            rpc::types::{Block, Log},
+        },
+        rand::{self, Rng},
     },
-    slog::{self, o, Logger},
+    slog::{self, Logger, o},
 };
 
 use crate::{
@@ -14,54 +19,86 @@ use crate::{
     trigger::{EthereumBlockTriggerType, EthereumTrigger, LogRef},
 };
 
+pub trait Random {
+    fn random() -> Self;
+}
+
+impl Random for B256 {
+    fn random() -> Self {
+        let mut rng = rand::rng();
+        let mut bytes = [0u8; 32];
+        rng.fill(&mut bytes);
+        Self::from(bytes)
+    }
+}
+
+impl Random for Address {
+    fn random() -> Self {
+        let mut rng = rand::rng();
+        let mut bytes = [0u8; 20];
+        rng.fill(&mut bytes);
+        Self::from(bytes)
+    }
+}
+
+fn create_log(tx_index: u64, log_index: u64) -> Arc<Log> {
+    let log = Log {
+        inner: alloy::primitives::Log {
+            address: Address::default(),
+            data: LogData::new_unchecked(vec![], Bytes::from(vec![])),
+        },
+        block_hash: Some(B256::ZERO),
+        block_number: Some(0),
+        block_timestamp: Some(0),
+        transaction_hash: Some(B256::ZERO),
+        transaction_index: Some(tx_index),
+        log_index: Some(log_index),
+        removed: false,
+    };
+
+    Arc::new(log)
+}
+
 #[test]
 fn test_trigger_ordering() {
     let block1 = EthereumTrigger::Block(
-        BlockPtr::from((H256::random(), 1u64)),
+        BlockPtr::from((B256::random(), 1u64)),
         EthereumBlockTriggerType::End,
     );
 
     let block2 = EthereumTrigger::Block(
-        BlockPtr::from((H256::random(), 0u64)),
+        BlockPtr::from((B256::random(), 0u64)),
         EthereumBlockTriggerType::WithCallTo(Address::random()),
     );
 
-    let mut call1 = EthereumCall::default();
-    call1.transaction_index = 1;
+    let call1 = EthereumCall {
+        transaction_index: 1,
+        ..Default::default()
+    };
     let call1 = EthereumTrigger::Call(Arc::new(call1));
 
-    let mut call2 = EthereumCall::default();
-    call2.transaction_index = 2;
-    call2.input = Bytes(vec![0]);
+    let call2 = EthereumCall {
+        transaction_index: 2,
+        input: Bytes::from(vec![0]),
+        ..Default::default()
+    };
     let call2 = EthereumTrigger::Call(Arc::new(call2));
 
-    let mut call3 = EthereumCall::default();
-    call3.transaction_index = 3;
+    let call3 = EthereumCall {
+        transaction_index: 3,
+        ..Default::default()
+    };
     let call3 = EthereumTrigger::Call(Arc::new(call3));
 
     // Call with the same tx index as call2
-    let mut call4 = EthereumCall::default();
-    call4.transaction_index = 2;
     // different than call2 so they don't get mistaken as the same
-    call4.input = Bytes(vec![1]);
+    let call4 = EthereumCall {
+        transaction_index: 2,
+        input: Bytes::from(vec![1]),
+        ..Default::default()
+    };
     let call4 = EthereumTrigger::Call(Arc::new(call4));
 
-    fn create_log(tx_index: u64, log_index: u64) -> Arc<Log> {
-        Arc::new(Log {
-            address: H160::default(),
-            topics: vec![],
-            data: Bytes::default(),
-            block_hash: Some(H256::zero()),
-            block_number: Some(U64::zero()),
-            transaction_hash: Some(H256::zero()),
-            transaction_index: Some(tx_index.into()),
-            log_index: Some(log_index.into()),
-            transaction_log_index: Some(log_index.into()),
-            log_type: Some("".into()),
-            removed: Some(false),
-        })
-    }
-
     // Event with transaction_index 1 and log_index 0;
     // should be the first element after sorting
     let log1 = EthereumTrigger::Log(LogRef::FullLog(create_log(1, 0), None));
@@ -92,13 +129,9 @@ fn test_trigger_ordering() {
 
     let logger = Logger::root(slog::Discard, o!());
 
-    let mut b: LightEthereumBlock = Default::default();
+    let b = Block::default();
 
-    // This is necessary because inside of BlockWithTriggers::new
-    // there's a log for both fields. So just using Default above
-    // gives None on them.
-    b.number = Some(Default::default());
-    b.hash = Some(Default::default());
+    let b = LightEthereumBlock::new(graph::components::ethereum::AnyBlock::from(b));
 
     // Test that `BlockWithTriggers` sorts the triggers.
     let block_with_triggers = BlockWithTriggers::<crate::Chain>::new(
@@ -107,60 +140,54 @@ fn test_trigger_ordering() {
         &logger,
     );
 
-    assert_eq!(
-        block_with_triggers.trigger_data,
-        vec![log1, log2, call1, log3, call2, call4, call3, block2, block1]
-    );
+    let expected = vec![log1, log2, call1, log3, call2, call4, call3, block2, block1]
+        .into_iter()
+        .map(Trigger::Chain)
+        .collect::<Vec<_>>();
+
+    assert_eq!(block_with_triggers.trigger_data, expected);
 }
 
 #[test]
 fn test_trigger_dedup() {
     let block1 = EthereumTrigger::Block(
-        BlockPtr::from((H256::random(), 1u64)),
+        BlockPtr::from((B256::random(), 1u64)),
         EthereumBlockTriggerType::End,
     );
 
     let block2 = EthereumTrigger::Block(
-        BlockPtr::from((H256::random(), 0u64)),
+        BlockPtr::from((B256::random(), 0u64)),
         EthereumBlockTriggerType::WithCallTo(Address::random()),
     );
 
     // duplicate block2
     let block3 = block2.clone();
 
-    let mut call1 = EthereumCall::default();
-    call1.transaction_index = 1;
+    let call1 = EthereumCall {
+        transaction_index: 1,
+        ..Default::default()
+    };
     let call1 = EthereumTrigger::Call(Arc::new(call1));
 
-    let mut call2 = EthereumCall::default();
-    call2.transaction_index = 2;
+    let call2 = EthereumCall {
+        transaction_index: 2,
+        ..Default::default()
+    };
     let call2 = EthereumTrigger::Call(Arc::new(call2));
 
-    let mut call3 = EthereumCall::default();
-    call3.transaction_index = 3;
+    let call3 = EthereumCall {
+        transaction_index: 3,
+        ..Default::default()
+    };
     let call3 = EthereumTrigger::Call(Arc::new(call3));
 
     // duplicate call2
-    let mut call4 = EthereumCall::default();
-    call4.transaction_index = 2;
+    let call4 = EthereumCall {
+        transaction_index: 2,
+        ..Default::default()
+    };
     let call4 = EthereumTrigger::Call(Arc::new(call4));
 
-    fn create_log(tx_index: u64, log_index: u64) -> Arc<Log> {
-        Arc::new(Log {
-            address: H160::default(),
-            topics: vec![],
-            data: Bytes::default(),
-            block_hash: Some(H256::zero()),
-            block_number: Some(U64::zero()),
-            transaction_hash: Some(H256::zero()),
-            transaction_index: Some(tx_index.into()),
-            log_index: Some(log_index.into()),
-            transaction_log_index: Some(log_index.into()),
-            log_type: Some("".into()),
-            removed: Some(false),
-        })
-    }
-
     let log1 = EthereumTrigger::Log(LogRef::FullLog(create_log(1, 0), None));
     let log2 = EthereumTrigger::Log(LogRef::FullLog(create_log(1, 1), None));
     let log3 = EthereumTrigger::Log(LogRef::FullLog(create_log(2, 5), None));
@@ -188,13 +215,11 @@ fn test_trigger_dedup() {
 
     let logger = Logger::root(slog::Discard, o!());
 
-    let mut b: LightEthereumBlock = Default::default();
+    #[allow(unused_variables)]
+    let b = Block::default();
 
-    // This is necessary because inside of BlockWithTriggers::new
-    // there's a log for both fields. So just using Default above
-    // gives None on them.
-    b.number = Some(Default::default());
-    b.hash = Some(Default::default());
+    #[allow(unreachable_code)]
+    let b = LightEthereumBlock::new(graph::components::ethereum::AnyBlock::from(b));
 
     // Test that `BlockWithTriggers` sorts the triggers.
     let block_with_triggers = BlockWithTriggers::<crate::Chain>::new(
@@ -203,8 +228,10 @@ fn test_trigger_dedup() {
         &logger,
     );
 
-    assert_eq!(
-        block_with_triggers.trigger_data,
-        vec![log1, log2, call1, log3, call2, call3, block2, block1]
-    );
+    let expected = vec![log1, log2, call1, log3, call2, call3, block2, block1]
+        .into_iter()
+        .map(Trigger::Chain)
+        .collect::<Vec<_>>();
+
+    assert_eq!(block_with_triggers.trigger_data, expected);
 }
diff --git a/chain/ethereum/src/transport.rs b/chain/ethereum/src/transport.rs
index f19b45dc3df..5b5414c4a5d 100644
--- a/chain/ethereum/src/transport.rs
+++ b/chain/ethereum/src/transport.rs
@@ -1,140 +1,305 @@
-use graph::endpoint::{EndpointMetrics, Provider, RequestLabels};
-use jsonrpc_core::types::Call;
-use jsonrpc_core::Value;
-
-use web3::transports::{http, ipc, ws};
-use web3::RequestId;
-
+use alloy::transports::{TransportError, TransportErrorKind, TransportFut};
+use graph::components::ethereum::json_patch;
+use graph::components::network_provider::ProviderName;
+use graph::endpoint::{ConnectionType, EndpointMetrics, RequestLabels};
+use graph::prelude::alloy::rpc::json_rpc::{RequestPacket, ResponsePacket};
+use graph::prelude::alloy::transports::{ipc::IpcConnect, ws::WsConnect};
 use graph::prelude::*;
 use graph::url::Url;
-use std::future::Future;
+use serde_json::Value;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+use tower::Service;
+
+/// Compression method for RPC requests.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Compression {
+    #[default]
+    None,
+    Gzip,
+    Brotli,
+    Deflate,
+}
+
+impl std::fmt::Display for Compression {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Compression::None => write!(f, "none"),
+            Compression::Gzip => write!(f, "gzip"),
+            Compression::Brotli => write!(f, "brotli"),
+            Compression::Deflate => write!(f, "deflate"),
+        }
+    }
+}
 
-/// Abstraction over the different web3 transports.
+/// Abstraction over different transport types for Alloy providers.
 #[derive(Clone, Debug)]
 pub enum Transport {
-    RPC {
-        client: http::Http,
-        metrics: Arc<EndpointMetrics>,
-        provider: Provider,
-    },
-    IPC(ipc::Ipc),
-    WS(ws::WebSocket),
+    RPC(alloy::rpc::client::RpcClient),
+    IPC(IpcConnect<String>),
+    WS(WsConnect),
 }
 
 impl Transport {
     /// Creates an IPC transport.
+    ///
+    /// Accepts both a raw file path (`/tmp/geth.ipc`) and an `ipc://` URL
+    /// (`ipc:///tmp/geth.ipc`). When a URL is provided the file path is
+    /// extracted so that the underlying IPC connector receives a plain path.
     #[cfg(unix)]
     pub async fn new_ipc(ipc: &str) -> Self {
-        ipc::Ipc::new(ipc)
-            .await
-            .map(Transport::IPC)
-            .expect("Failed to connect to Ethereum IPC")
+        let path = Url::parse(ipc)
+            .ok()
+            .map(|u| u.path().to_string())
+            .unwrap_or_else(|| ipc.to_string());
+        let transport = IpcConnect::new(path);
+
+        Transport::IPC(transport)
+    }
+
+    #[cfg(not(unix))]
+    pub async fn new_ipc(_ipc: &str) -> Self {
+        panic!("IPC connections are not supported on non-Unix platforms")
     }
 
     /// Creates a WebSocket transport.
     pub async fn new_ws(ws: &str) -> Self {
-        ws::WebSocket::new(ws)
-            .await
-            .map(Transport::WS)
-            .expect("Failed to connect to Ethereum WS")
+        let transport = WsConnect::new(ws.to_string());
+
+        Transport::WS(transport)
     }
 
     /// Creates a JSON-RPC over HTTP transport.
     ///
-    /// Note: JSON-RPC over HTTP doesn't always support subscribing to new
-    /// blocks (one such example is Infura's HTTP endpoint).
+    /// Set `no_eip2718` to true for chains that don't return the `type` field
+    /// in transaction receipts (pre-EIP-2718 chains). Use provider feature `no_eip2718`.
     pub fn new_rpc(
         rpc: Url,
-        headers: ::http::HeaderMap,
+        headers: graph::http::HeaderMap,
         metrics: Arc<EndpointMetrics>,
         provider: impl AsRef<str>,
+        no_eip2718: bool,
+        compression: Compression,
     ) -> Self {
-        // Unwrap: This only fails if something is wrong with the system's TLS config.
-        let client = reqwest::Client::builder()
-            .default_headers(headers)
-            .build()
-            .unwrap();
-
-        Transport::RPC {
-            client: http::Http::with_client(client, rpc),
-            metrics,
-            provider: provider.as_ref().into(),
+        let mut client_builder = reqwest::Client::builder().default_headers(headers);
+
+        match compression {
+            Compression::None => {}
+            Compression::Gzip => {
+                client_builder = client_builder.gzip(true);
+            }
+            Compression::Brotli => {
+                client_builder = client_builder.brotli(true);
+            }
+            Compression::Deflate => {
+                client_builder = client_builder.deflate(true);
+            }
         }
+
+        let client = client_builder.build().expect("Failed to build HTTP client");
+
+        let patching_transport = PatchingHttp::new(client, rpc, no_eip2718);
+        let metrics_transport =
+            MetricsHttp::new(patching_transport, metrics, provider.as_ref().into());
+        let rpc_client = alloy::rpc::client::RpcClient::new(metrics_transport, false);
+
+        Transport::RPC(rpc_client)
     }
 }
 
-impl web3::Transport for Transport {
-    type Out = Pin<Box<dyn Future<Output = Result<Value, web3::error::Error>> + Send + 'static>>;
+/// Custom HTTP transport wrapper that collects metrics
+#[derive(Clone)]
+pub struct MetricsHttp {
+    inner: PatchingHttp,
+    metrics: Arc<EndpointMetrics>,
+    provider: ProviderName,
+}
 
-    fn prepare(&self, method: &str, params: Vec<Value>) -> (RequestId, Call) {
-        match self {
-            Transport::RPC {
-                client,
-                metrics: _,
-                provider: _,
-            } => client.prepare(method, params),
-            Transport::IPC(ipc) => ipc.prepare(method, params),
-            Transport::WS(ws) => ws.prepare(method, params),
+impl MetricsHttp {
+    pub fn new(inner: PatchingHttp, metrics: Arc<EndpointMetrics>, provider: ProviderName) -> Self {
+        Self {
+            inner,
+            metrics,
+            provider,
         }
     }
+}
+
+// Implement tower::Service trait for MetricsHttp to intercept RPC calls
+impl Service<RequestPacket> for MetricsHttp {
+    type Response = ResponsePacket;
+    type Error = TransportError;
+    type Future = TransportFut<'static>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx)
+    }
 
-    fn send(&self, id: RequestId, request: Call) -> Self::Out {
-        match self {
-            Transport::RPC {
-                client,
-                metrics,
+    fn call(&mut self, request: RequestPacket) -> Self::Future {
+        let metrics = self.metrics.clone();
+        let provider = self.provider.clone();
+        let mut inner = self.inner.clone();
+
+        Box::pin(async move {
+            // Extract method name from request
+            let method = match &request {
+                RequestPacket::Single(req) => req.method().to_string(),
+                RequestPacket::Batch(reqs) => reqs
+                    .first()
+                    .map(|r| r.method().to_string())
+                    .unwrap_or_else(|| "batch".to_string()),
+            };
+
+            let labels = RequestLabels {
                 provider,
-            } => {
-                let metrics = metrics.cheap_clone();
-                let client = client.clone();
-                let method = match request {
-                    Call::MethodCall(ref m) => m.method.as_str(),
-                    _ => "unknown",
-                };
-
-                let labels = RequestLabels {
-                    provider: provider.clone(),
-                    req_type: method.into(),
-                    conn_type: graph::endpoint::ConnectionType::Rpc,
-                };
-                let out = async move {
-                    let labels = labels;
-                    let out = client.send(id, request).await;
-                    match out {
-                        Ok(_) => metrics.success(&labels),
-                        Err(_) => metrics.failure(&labels),
-                    }
-
-                    out
-                };
-
-                Box::pin(out)
+                req_type: method.into(),
+                conn_type: ConnectionType::Rpc,
+            };
+
+            // Call inner transport and track metrics
+            let result = inner.call(request).await;
+
+            match &result {
+                Ok(_) => metrics.success(&labels),
+                Err(_) => metrics.failure(&labels),
             }
-            Transport::IPC(ipc) => Box::pin(ipc.send(id, request)),
-            Transport::WS(ws) => Box::pin(ws.send(id, request)),
-        }
+
+            result
+        })
     }
 }
 
-impl web3::BatchTransport for Transport {
-    type Batch = Box<
-        dyn Future<Output = Result<Vec<Result<Value, web3::error::Error>>, web3::error::Error>>
-            + Send
-            + Unpin,
-    >;
-
-    fn send_batch<T>(&self, requests: T) -> Self::Batch
-    where
-        T: IntoIterator<Item = (RequestId, Call)>,
-    {
-        match self {
-            Transport::RPC {
-                client,
-                metrics: _,
-                provider: _,
-            } => Box::new(client.send_batch(requests)),
-            Transport::IPC(ipc) => Box::new(ipc.send_batch(requests)),
-            Transport::WS(ws) => Box::new(ws.send_batch(requests)),
+/// HTTP transport that patches receipts for chains that don't support EIP-2718 (typed transactions).
+/// When `no_eip2718` is set, adds missing `type` field to receipts.
+#[derive(Clone)]
+pub struct PatchingHttp {
+    client: reqwest::Client,
+    url: Url,
+    no_eip2718: bool,
+}
+
+impl PatchingHttp {
+    pub fn new(client: reqwest::Client, url: Url, no_eip2718: bool) -> Self {
+        Self {
+            client,
+            url,
+            no_eip2718,
+        }
+    }
+
+    fn is_receipt_method(method: &str) -> bool {
+        method == "eth_getTransactionReceipt" || method == "eth_getBlockReceipts"
+    }
+
+    fn patch_rpc_response(response: &mut Value) -> bool {
+        response
+            .get_mut("result")
+            .map(json_patch::patch_receipts)
+            .unwrap_or(false)
+    }
+
+    fn patch_response(body: &[u8]) -> Option<Vec<u8>> {
+        let mut json: Value = serde_json::from_slice(body).ok()?;
+
+        let patched = match &mut json {
+            Value::Object(_) => Self::patch_rpc_response(&mut json),
+            Value::Array(batch) => {
+                let mut patched = false;
+                for r in batch {
+                    patched |= Self::patch_rpc_response(r);
+                }
+                patched
+            }
+            _ => false,
+        };
+
+        if patched {
+            serde_json::to_vec(&json).ok()
+        } else {
+            None
         }
     }
 }
+
+impl Service<RequestPacket> for PatchingHttp {
+    type Response = ResponsePacket;
+    type Error = TransportError;
+    type Future = TransportFut<'static>;
+
+    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, request: RequestPacket) -> Self::Future {
+        let client = self.client.clone();
+        let url = self.url.clone();
+        let no_eip2718 = self.no_eip2718;
+
+        let should_patch = if no_eip2718 {
+            match &request {
+                RequestPacket::Single(req) => Self::is_receipt_method(req.method()),
+                RequestPacket::Batch(reqs) => {
+                    reqs.iter().any(|r| Self::is_receipt_method(r.method()))
+                }
+            }
+        } else {
+            false
+        };
+
+        Box::pin(async move {
+            let resp = client
+                .post(url)
+                .json(&request)
+                .headers(request.headers())
+                .send()
+                .await
+                .map_err(TransportErrorKind::custom)?;
+
+            let status = resp.status();
+            let body = resp.bytes().await.map_err(TransportErrorKind::custom)?;
+
+            if !status.is_success() {
+                return Err(TransportErrorKind::http_error(
+                    status.as_u16(),
+                    String::from_utf8_lossy(&body).into_owned(),
+                ));
+            }
+
+            if should_patch && let Some(patched) = Self::patch_response(&body) {
+                return serde_json::from_slice(&patched).map_err(|err| {
+                    TransportError::deser_err(err, String::from_utf8_lossy(&patched))
+                });
+            }
+            serde_json::from_slice(&body)
+                .map_err(|err| TransportError::deser_err(err, String::from_utf8_lossy(&body)))
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn patch_response_single() {
+        let body = br#"{"jsonrpc":"2.0","id":1,"result":{"status":"0x1"}}"#;
+        let patched = PatchingHttp::patch_response(body).unwrap();
+        let json: Value = serde_json::from_slice(&patched).unwrap();
+        assert_eq!(json["result"]["type"], "0x0");
+    }
+
+    #[test]
+    fn patch_response_returns_none_when_type_exists() {
+        let body = br#"{"jsonrpc":"2.0","id":1,"result":{"status":"0x1","type":"0x2"}}"#;
+        assert!(PatchingHttp::patch_response(body).is_none());
+    }
+
+    #[test]
+    fn patch_response_batch() {
+        let body = br#"[{"jsonrpc":"2.0","id":1,"result":{"status":"0x1"}},{"jsonrpc":"2.0","id":2,"result":{"status":"0x1"}}]"#;
+        let patched = PatchingHttp::patch_response(body).unwrap();
+        let json: Value = serde_json::from_slice(&patched).unwrap();
+        assert_eq!(json[0]["result"]["type"], "0x0");
+        assert_eq!(json[1]["result"]["type"], "0x0");
+    }
+}
diff --git a/chain/ethereum/src/trigger.rs b/chain/ethereum/src/trigger.rs
index a57f4c8410f..b5d51d9a379 100644
--- a/chain/ethereum/src/trigger.rs
+++ b/chain/ethereum/src/trigger.rs
@@ -1,31 +1,28 @@
+use async_trait::async_trait;
+use graph::abi;
 use graph::blockchain::MappingTriggerTrait;
 use graph::blockchain::TriggerData;
+use graph::components::ethereum::AnyTransaction;
+use graph::components::ethereum::AnyTransactionReceiptBare as AlloyTransactionReceipt;
 use graph::data::subgraph::API_VERSION_0_0_2;
 use graph::data::subgraph::API_VERSION_0_0_6;
 use graph::data::subgraph::API_VERSION_0_0_7;
-use graph::prelude::ethabi::ethereum_types::H160;
-use graph::prelude::ethabi::ethereum_types::H256;
-use graph::prelude::ethabi::ethereum_types::U128;
-use graph::prelude::ethabi::ethereum_types::U256;
-use graph::prelude::ethabi::ethereum_types::U64;
-use graph::prelude::ethabi::Address;
-use graph::prelude::ethabi::Bytes;
-use graph::prelude::ethabi::LogParam;
-use graph::prelude::web3::types::Block;
-use graph::prelude::web3::types::Log;
-use graph::prelude::web3::types::Transaction;
-use graph::prelude::web3::types::TransactionReceipt;
+use graph::data_source::common::DeclaredCall;
 use graph::prelude::BlockNumber;
 use graph::prelude::BlockPtr;
+use graph::prelude::LightEthereumBlock;
+use graph::prelude::alloy::consensus::Transaction as TransactionTrait;
+use graph::prelude::alloy::network::TransactionResponse;
+use graph::prelude::alloy::primitives::{Address, B256, U256};
+use graph::prelude::alloy::rpc::types::Log;
 use graph::prelude::{CheapClone, EthereumCall};
-use graph::runtime::asc_new;
-use graph::runtime::gas::GasCounter;
 use graph::runtime::AscHeap;
 use graph::runtime::AscPtr;
 use graph::runtime::HostExportError;
+use graph::runtime::asc_new;
+use graph::runtime::gas::GasCounter;
 use graph::semver::Version;
 use graph_runtime_wasm::module::ToAscPtr;
-use std::ops::Deref;
 use std::{cmp::Ordering, sync::Arc};
 
 use crate::runtime::abi::AscEthereumBlock;
@@ -38,23 +35,23 @@ use crate::runtime::abi::AscEthereumTransaction_0_0_1;
 use crate::runtime::abi::AscEthereumTransaction_0_0_2;
 use crate::runtime::abi::AscEthereumTransaction_0_0_6;
 
-// ETHDEP: This should be defined in only one place.
-type LightEthereumBlock = Block<Transaction>;
+static U256_DEFAULT: U256 = U256::ZERO;
 
 pub enum MappingTrigger {
     Log {
         block: Arc<LightEthereumBlock>,
-        transaction: Arc<Transaction>,
+        transaction: Arc<AnyTransaction>,
         log: Arc<Log>,
-        params: Vec<LogParam>,
-        receipt: Option<Arc<TransactionReceipt>>,
+        params: Vec<abi::DynSolParam>,
+        receipt: Option<Arc<AlloyTransactionReceipt>>,
+        calls: Vec<DeclaredCall>,
     },
     Call {
         block: Arc<LightEthereumBlock>,
-        transaction: Arc<Transaction>,
+        transaction: Arc<AnyTransaction>,
         call: Arc<EthereumCall>,
-        inputs: Vec<LogParam>,
-        outputs: Vec<LogParam>,
+        inputs: Vec<abi::DynSolParam>,
+        outputs: Vec<abi::DynSolParam>,
     },
     Block {
         block: Arc<LightEthereumBlock>,
@@ -62,7 +59,7 @@ pub enum MappingTrigger {
 }
 
 impl MappingTriggerTrait for MappingTrigger {
-    fn error_context(&self) -> std::string::String {
+    fn error_context(&self) -> String {
         let transaction_id = match self {
             MappingTrigger::Log { log, .. } => log.transaction_hash,
             MappingTrigger::Call { call, .. } => call.transaction_hash,
@@ -82,15 +79,15 @@ impl std::fmt::Debug for MappingTrigger {
         #[derive(Debug)]
         enum MappingTriggerWithoutBlock {
             Log {
-                _transaction: Arc<Transaction>,
+                _transaction: Arc<AnyTransaction>,
                 _log: Arc<Log>,
-                _params: Vec<LogParam>,
+                _params: Vec<abi::DynSolParam>,
             },
             Call {
-                _transaction: Arc<Transaction>,
+                _transaction: Arc<AnyTransaction>,
                 _call: Arc<EthereumCall>,
-                _inputs: Vec<LogParam>,
-                _outputs: Vec<LogParam>,
+                _inputs: Vec<abi::DynSolParam>,
+                _outputs: Vec<abi::DynSolParam>,
             },
             Block,
         }
@@ -102,6 +99,7 @@ impl std::fmt::Debug for MappingTrigger {
                 log,
                 params,
                 receipt: _,
+                calls: _,
             } => MappingTriggerWithoutBlock::Log {
                 _transaction: transaction.cheap_clone(),
                 _log: log.cheap_clone(),
@@ -126,8 +124,9 @@ impl std::fmt::Debug for MappingTrigger {
     }
 }
 
+#[async_trait]
 impl ToAscPtr for MappingTrigger {
-    fn to_asc_ptr<H: AscHeap>(
+    async fn to_asc_ptr<H: AscHeap>(
         self,
         heap: &mut H,
         gas: &GasCounter,
@@ -139,18 +138,16 @@ impl ToAscPtr for MappingTrigger {
                 log,
                 params,
                 receipt,
+                calls: _,
             } => {
                 let api_version = heap.api_version();
-                let ethereum_event_data = EthereumEventData {
-                    block: EthereumBlockData::from(block.as_ref()),
-                    transaction: EthereumTransactionData::from(transaction.deref()),
-                    address: log.address,
-                    log_index: log.log_index.unwrap_or(U256::zero()),
-                    transaction_log_index: log.log_index.unwrap_or(U256::zero()),
-                    log_type: log.log_type.clone(),
-                    params,
-                };
-                if api_version >= API_VERSION_0_0_7 {
+                let ethereum_event_data = EthereumEventData::new(
+                    block.as_ref(),
+                    transaction.as_ref(),
+                    log.as_ref(),
+                    &params,
+                );
+                if api_version >= &API_VERSION_0_0_7 {
                     asc_new::<
                         AscEthereumEvent_0_0_7<
                             AscEthereumTransaction_0_0_6,
@@ -158,28 +155,31 @@ impl ToAscPtr for MappingTrigger {
                         >,
                         _,
                         _,
-                    >(heap, &(ethereum_event_data, receipt.as_deref()), gas)?
+                    >(heap, &(ethereum_event_data, receipt.as_deref()), gas)
+                    .await?
                     .erase()
-                } else if api_version >= API_VERSION_0_0_6 {
+                } else if api_version >= &API_VERSION_0_0_6 {
                     asc_new::<
                         AscEthereumEvent<AscEthereumTransaction_0_0_6, AscEthereumBlock_0_0_6>,
                         _,
                         _,
-                    >(heap, &ethereum_event_data, gas)?
+                    >(heap, &ethereum_event_data, gas)
+                    .await?
                     .erase()
-                } else if api_version >= API_VERSION_0_0_2 {
+                } else if api_version >= &API_VERSION_0_0_2 {
                     asc_new::<
                             AscEthereumEvent<AscEthereumTransaction_0_0_2, AscEthereumBlock>,
                             _,
                             _,
-                        >(heap, &ethereum_event_data, gas)?
+                        >(heap, &ethereum_event_data, gas)
+                        .await?
                         .erase()
                 } else {
                     asc_new::<
                         AscEthereumEvent<AscEthereumTransaction_0_0_1, AscEthereumBlock>,
                         _,
                         _,
-                    >(heap, &ethereum_event_data, gas)?
+                    >(heap, &ethereum_event_data, gas).await?
                     .erase()
                 }
             }
@@ -190,87 +190,107 @@ impl ToAscPtr for MappingTrigger {
                 inputs,
                 outputs,
             } => {
-                let call = EthereumCallData {
-                    to: call.to,
-                    from: call.from,
-                    block: EthereumBlockData::from(block.as_ref()),
-                    transaction: EthereumTransactionData::from(transaction.deref()),
-                    inputs,
-                    outputs,
-                };
-                if heap.api_version() >= Version::new(0, 0, 6) {
+                let call = EthereumCallData::new(&block, &transaction, &call, &inputs, &outputs);
+                if heap.api_version() >= &Version::new(0, 0, 6) {
                     asc_new::<
                         AscEthereumCall_0_0_3<AscEthereumTransaction_0_0_6, AscEthereumBlock_0_0_6>,
                         _,
                         _,
-                    >(heap, &call, gas)?
+                    >(heap, &call, gas)
+                    .await?
                     .erase()
-                } else if heap.api_version() >= Version::new(0, 0, 3) {
+                } else if heap.api_version() >= &Version::new(0, 0, 3) {
                     asc_new::<
                         AscEthereumCall_0_0_3<AscEthereumTransaction_0_0_2, AscEthereumBlock>,
                         _,
                         _,
-                    >(heap, &call, gas)?
+                    >(heap, &call, gas)
+                    .await?
                     .erase()
                 } else {
-                    asc_new::<AscEthereumCall, _, _>(heap, &call, gas)?.erase()
+                    asc_new::<AscEthereumCall, _, _>(heap, &call, gas)
+                        .await?
+                        .erase()
                 }
             }
             MappingTrigger::Block { block } => {
                 let block = EthereumBlockData::from(block.as_ref());
-                if heap.api_version() >= Version::new(0, 0, 6) {
-                    asc_new::<AscEthereumBlock_0_0_6, _, _>(heap, &block, gas)?.erase()
+                if heap.api_version() >= &Version::new(0, 0, 6) {
+                    asc_new::<AscEthereumBlock_0_0_6, _, _>(heap, &block, gas)
+                        .await?
+                        .erase()
                 } else {
-                    asc_new::<AscEthereumBlock, _, _>(heap, &block, gas)?.erase()
+                    asc_new::<AscEthereumBlock, _, _>(heap, &block, gas)
+                        .await?
+                        .erase()
                 }
             }
         })
     }
 }
 
+#[derive(Clone, Debug)]
+pub struct LogPosition {
+    pub index: usize,
+    pub receipt: Arc<AlloyTransactionReceipt>,
+    pub requires_transaction_receipt: bool,
+}
+
 #[derive(Clone, Debug)]
 pub enum LogRef {
-    FullLog(Arc<Log>, Option<Arc<TransactionReceipt>>),
-    LogPosition(usize, Arc<TransactionReceipt>),
+    FullLog(Arc<Log>, Option<Arc<AlloyTransactionReceipt>>),
+    LogPosition(LogPosition),
 }
 
 impl LogRef {
     pub fn log(&self) -> &Log {
         match self {
             LogRef::FullLog(log, _) => log.as_ref(),
-            LogRef::LogPosition(index, receipt) => receipt.logs.get(*index).unwrap(),
+            LogRef::LogPosition(pos) => pos.receipt.logs().get(pos.index).unwrap(),
         }
     }
 
-    pub fn receipt(&self) -> Option<&Arc<TransactionReceipt>> {
+    /// Returns the transaction receipt if it's available and required.
+    ///
+    /// For `FullLog` variants, returns the receipt if present.
+    /// For `LogPosition` variants, only returns the receipt if the
+    /// `requires_transaction_receipt` flag is true, otherwise returns None
+    /// even though the receipt is stored internally.
+    pub fn receipt(&self) -> Option<&Arc<AlloyTransactionReceipt>> {
         match self {
             LogRef::FullLog(_, receipt) => receipt.as_ref(),
-            LogRef::LogPosition(_, receipt) => Some(receipt),
+            LogRef::LogPosition(pos) => {
+                if pos.requires_transaction_receipt {
+                    Some(&pos.receipt)
+                } else {
+                    None
+                }
+            }
         }
     }
 
-    pub fn log_index(&self) -> Option<U256> {
+    pub fn log_index(&self) -> Option<u64> {
         self.log().log_index
     }
 
-    pub fn transaction_index(&self) -> Option<U64> {
+    pub fn transaction_index(&self) -> Option<u64> {
         self.log().transaction_index
     }
 
-    fn transaction_hash(&self) -> Option<H256> {
+    fn transaction_hash(&self) -> Option<B256> {
         self.log().transaction_hash
     }
 
-    pub fn block_hash(&self) -> Option<H256> {
+    pub fn block_hash(&self) -> Option<B256> {
         self.log().block_hash
     }
 
-    pub fn block_number(&self) -> Option<U64> {
+    pub fn block_number(&self) -> Option<u64> {
         self.log().block_number
     }
 
-    pub fn address(&self) -> &H160 {
-        &self.log().address
+    pub fn address(&self) -> &Address {
+        &self.log().inner.address
     }
 }
 
@@ -313,14 +333,14 @@ impl EthereumTrigger {
             EthereumTrigger::Block(block_ptr, _) => block_ptr.number,
             EthereumTrigger::Call(call) => call.block_number,
             EthereumTrigger::Log(log_ref) => {
-                i32::try_from(log_ref.block_number().unwrap().as_u64()).unwrap()
+                i32::try_from(log_ref.block_number().unwrap()).unwrap()
             }
         }
     }
 
-    pub fn block_hash(&self) -> H256 {
+    pub fn block_hash(&self) -> B256 {
         match self {
-            EthereumTrigger::Block(block_ptr, _) => block_ptr.hash_as_h256(),
+            EthereumTrigger::Block(block_ptr, _) => block_ptr.hash.as_b256(),
             EthereumTrigger::Call(call) => call.block_hash,
             EthereumTrigger::Log(log_ref) => log_ref.block_hash().unwrap(),
         }
@@ -333,7 +353,7 @@ impl EthereumTrigger {
                 Some(address)
             }
             EthereumTrigger::Call(call) => Some(&call.to),
-            EthereumTrigger::Log(log_ref) => Some(&log_ref.address()),
+            EthereumTrigger::Log(log_ref) => Some(log_ref.address()),
             // Unfiltered block triggers match any data source address.
             EthereumTrigger::Block(_, EthereumBlockTriggerType::End) => None,
             EthereumTrigger::Block(_, EthereumBlockTriggerType::Start) => None,
@@ -364,23 +384,21 @@ impl Ord for EthereumTrigger {
             // Calls vs. events are logged by their tx index;
             // if they are from the same transaction, events come first
             (Self::Call(a), Self::Log(b))
-                if a.transaction_index == b.transaction_index().unwrap().as_u64() =>
+                if a.transaction_index == b.transaction_index().unwrap() =>
             {
                 Ordering::Greater
             }
             (Self::Log(a), Self::Call(b))
-                if a.transaction_index().unwrap().as_u64() == b.transaction_index =>
+                if a.transaction_index().unwrap() == b.transaction_index =>
             {
                 Ordering::Less
             }
-            (Self::Call(a), Self::Log(b)) => a
-                .transaction_index
-                .cmp(&b.transaction_index().unwrap().as_u64()),
-            (Self::Log(a), Self::Call(b)) => a
-                .transaction_index()
-                .unwrap()
-                .as_u64()
-                .cmp(&b.transaction_index),
+            (Self::Call(a), Self::Log(b)) => {
+                a.transaction_index.cmp(&b.transaction_index().unwrap())
+            }
+            (Self::Log(a), Self::Call(b)) => {
+                a.transaction_index().unwrap().cmp(&b.transaction_index)
+            }
         }
     }
 }
@@ -411,104 +429,223 @@ impl TriggerData for EthereumTrigger {
     }
 
     fn address_match(&self) -> Option<&[u8]> {
-        self.address().map(|address| address.as_bytes())
+        self.address().map(|address| address.as_slice())
     }
 }
 
 /// Ethereum block data.
-#[derive(Clone, Debug, Default)]
-pub struct EthereumBlockData {
-    pub hash: H256,
-    pub parent_hash: H256,
-    pub uncles_hash: H256,
-    pub author: H160,
-    pub state_root: H256,
-    pub transactions_root: H256,
-    pub receipts_root: H256,
-    pub number: U64,
-    pub gas_used: U256,
-    pub gas_limit: U256,
-    pub timestamp: U256,
-    pub difficulty: U256,
-    pub total_difficulty: U256,
-    pub size: Option<U256>,
-    pub base_fee_per_gas: Option<U256>,
+#[derive(Clone, Debug)]
+pub struct EthereumBlockData<'a> {
+    block: &'a LightEthereumBlock,
 }
 
-impl<'a, T> From<&'a Block<T>> for EthereumBlockData {
-    fn from(block: &'a Block<T>) -> EthereumBlockData {
-        EthereumBlockData {
-            hash: block.hash.unwrap(),
-            parent_hash: block.parent_hash,
-            uncles_hash: block.uncles_hash,
-            author: block.author,
-            state_root: block.state_root,
-            transactions_root: block.transactions_root,
-            receipts_root: block.receipts_root,
-            number: block.number.unwrap(),
-            gas_used: block.gas_used,
-            gas_limit: block.gas_limit,
-            timestamp: block.timestamp,
-            difficulty: block.difficulty,
-            total_difficulty: block.total_difficulty.unwrap_or_default(),
-            size: block.size,
-            base_fee_per_gas: block.base_fee_per_gas,
-        }
+impl<'a> From<&'a LightEthereumBlock> for EthereumBlockData<'a> {
+    fn from(block: &'a LightEthereumBlock) -> EthereumBlockData<'a> {
+        EthereumBlockData { block }
+    }
+}
+
+impl<'a> EthereumBlockData<'a> {
+    pub fn hash(&self) -> &B256 {
+        &self.block.inner().header.hash
+    }
+
+    pub fn parent_hash(&self) -> &B256 {
+        &self.block.inner().header.parent_hash
+    }
+
+    pub fn uncles_hash(&self) -> &B256 {
+        &self.block.inner().header.ommers_hash
+    }
+
+    pub fn author(&self) -> &Address {
+        &self.block.inner().header.beneficiary
+    }
+
+    pub fn state_root(&self) -> &B256 {
+        &self.block.inner().header.state_root
+    }
+
+    pub fn transactions_root(&self) -> &B256 {
+        &self.block.inner().header.transactions_root
+    }
+
+    pub fn receipts_root(&self) -> &B256 {
+        &self.block.inner().header.receipts_root
+    }
+
+    pub fn number(&self) -> u64 {
+        self.block.number_u64()
+    }
+
+    pub fn gas_used(&self) -> u64 {
+        self.block.inner().header.gas_used
+    }
+
+    pub fn gas_limit(&self) -> u64 {
+        self.block.inner().header.gas_limit
+    }
+
+    pub fn timestamp(&self) -> u64 {
+        self.block.inner().header.timestamp
+    }
+
+    pub fn difficulty(&self) -> &U256 {
+        &self.block.inner().header.difficulty
+    }
+
+    pub fn total_difficulty(&self) -> &U256 {
+        self.block
+            .inner()
+            .header
+            .total_difficulty
+            .as_ref()
+            .unwrap_or(&U256_DEFAULT)
+    }
+
+    pub fn size(&self) -> &Option<U256> {
+        &self.block.inner().header.size
+    }
+
+    pub fn base_fee_per_gas(&self) -> &Option<u64> {
+        &self.block.inner().header.base_fee_per_gas
     }
 }
 
 /// Ethereum transaction data.
 #[derive(Clone, Debug)]
-pub struct EthereumTransactionData {
-    pub hash: H256,
-    pub index: U128,
-    pub from: H160,
-    pub to: Option<H160>,
-    pub value: U256,
-    pub gas_limit: U256,
-    pub gas_price: U256,
-    pub input: Bytes,
-    pub nonce: U256,
+pub struct EthereumTransactionData<'a> {
+    tx: &'a AnyTransaction,
+    base_fee_per_gas: Option<u64>,
 }
 
-impl From<&'_ Transaction> for EthereumTransactionData {
-    fn from(tx: &Transaction) -> EthereumTransactionData {
-        // unwrap: this is always `Some` for txns that have been mined
-        //         (see https://github.com/tomusdrw/rust-web3/pull/407)
-        let from = tx.from.unwrap();
+impl<'a> EthereumTransactionData<'a> {
+    // We don't implement `From` because it causes confusion with the `from`
+    // accessor method
+    fn new(tx: &'a AnyTransaction, base_fee_per_gas: Option<u64>) -> EthereumTransactionData<'a> {
         EthereumTransactionData {
-            hash: tx.hash,
-            index: tx.transaction_index.unwrap().as_u64().into(),
-            from,
-            to: tx.to,
-            value: tx.value,
-            gas_limit: tx.gas,
-            gas_price: tx.gas_price.unwrap_or(U256::zero()), // EIP-1559 made this optional.
-            input: tx.input.0.clone(),
-            nonce: tx.nonce,
+            tx,
+            base_fee_per_gas,
         }
     }
+
+    pub fn hash(&self) -> B256 {
+        self.tx.tx_hash()
+    }
+
+    pub fn index(&self) -> u64 {
+        self.tx.transaction_index.unwrap()
+    }
+
+    pub fn from(&self) -> Address {
+        self.tx.from()
+    }
+
+    pub fn to(&self) -> Option<Address> {
+        self.tx.to()
+    }
+
+    pub fn value(&self) -> U256 {
+        self.tx.value()
+    }
+
+    pub fn gas_limit(&self) -> u64 {
+        self.tx.gas_limit()
+    }
+
+    pub fn gas_price(&self) -> u128 {
+        self.tx.effective_gas_price(self.base_fee_per_gas)
+    }
+
+    pub fn input(&self) -> &[u8] {
+        self.tx.input()
+    }
+
+    pub fn nonce(&self) -> u64 {
+        self.tx.nonce()
+    }
 }
 
 /// An Ethereum event logged from a specific contract address and block.
 #[derive(Debug, Clone)]
-pub struct EthereumEventData {
-    pub address: Address,
-    pub log_index: U256,
-    pub transaction_log_index: U256,
-    pub log_type: Option<String>,
-    pub block: EthereumBlockData,
-    pub transaction: EthereumTransactionData,
-    pub params: Vec<LogParam>,
+pub struct EthereumEventData<'a> {
+    pub block: EthereumBlockData<'a>,
+    pub transaction: EthereumTransactionData<'a>,
+    pub params: &'a [abi::DynSolParam],
+    log: &'a Log,
+}
+
+impl<'a> EthereumEventData<'a> {
+    pub fn new(
+        block: &'a LightEthereumBlock,
+        tx: &'a AnyTransaction,
+        log: &'a Log,
+        params: &'a [abi::DynSolParam],
+    ) -> Self {
+        EthereumEventData {
+            block: EthereumBlockData::from(block),
+            transaction: EthereumTransactionData::new(tx, block.base_fee_per_gas()),
+            log,
+            params,
+        }
+    }
+
+    pub fn address(&self) -> &Address {
+        &self.log.inner.address
+    }
+
+    pub fn log_index(&self) -> u64 {
+        self.log.log_index.unwrap_or(0)
+    }
+
+    pub fn transaction_log_index(&self) -> u64 {
+        // We purposely use the `log_index` here. Geth does not support
+        // `transaction_log_index`, and subgraphs that use it only care that
+        // it identifies the log, the specific value is not important. Still
+        // this will change the output of subgraphs that use this field.
+        //
+        // This was initially changed in commit b95c6953
+        self.log.log_index.unwrap_or(0)
+    }
+
+    pub fn log_type(&self) -> Option<String> {
+        // This field was present in old rust-web3 Block, but alloy doesn't have it.
+        None
+    }
 }
 
 /// An Ethereum call executed within a transaction within a block to a contract address.
 #[derive(Debug, Clone)]
-pub struct EthereumCallData {
-    pub from: Address,
-    pub to: Address,
-    pub block: EthereumBlockData,
-    pub transaction: EthereumTransactionData,
-    pub inputs: Vec<LogParam>,
-    pub outputs: Vec<LogParam>,
+pub struct EthereumCallData<'a> {
+    pub block: EthereumBlockData<'a>,
+    pub transaction: EthereumTransactionData<'a>,
+    pub inputs: &'a [abi::DynSolParam],
+    pub outputs: &'a [abi::DynSolParam],
+    call: &'a EthereumCall,
+}
+
+impl<'a> EthereumCallData<'a> {
+    fn new(
+        block: &'a LightEthereumBlock,
+        transaction: &'a AnyTransaction,
+        call: &'a EthereumCall,
+        inputs: &'a [abi::DynSolParam],
+        outputs: &'a [abi::DynSolParam],
+    ) -> EthereumCallData<'a> {
+        EthereumCallData {
+            block: EthereumBlockData::from(block),
+            transaction: EthereumTransactionData::new(transaction, block.base_fee_per_gas()),
+            inputs,
+            outputs,
+            call,
+        }
+    }
+
+    pub fn from(&self) -> &Address {
+        &self.call.from
+    }
+
+    pub fn to(&self) -> &Address {
+        &self.call.to
+    }
 }
diff --git a/chain/near/Cargo.toml b/chain/near/Cargo.toml
index 9f43c90a44e..d21f3755d0e 100644
--- a/chain/near/Cargo.toml
+++ b/chain/near/Cargo.toml
@@ -4,19 +4,19 @@ version.workspace = true
 edition.workspace = true
 
 [build-dependencies]
-tonic-build = { workspace = true }
+tonic-prost-build = { workspace = true }
 
 [dependencies]
-base64 = "0.20"
+async-trait = { workspace = true }
 graph = { path = "../../graph" }
 prost = { workspace = true }
 prost-types = { workspace = true }
-serde = "1.0"
+serde = { workspace = true }
 anyhow = "1"
 
 graph-runtime-wasm = { path = "../../runtime/wasm" }
 graph-runtime-derive = { path = "../../runtime/derive" }
 
 [dev-dependencies]
-diesel = { version = "1.4.7", features = ["postgres", "serde_json", "numeric", "r2d2"] }
-trigger-filters.path = "../../substreams/trigger-filters" 
+diesel = { workspace = true }
+tokio = { workspace = true }
diff --git a/chain/near/build.rs b/chain/near/build.rs
index 611f861baf2..feafe4718f9 100644
--- a/chain/near/build.rs
+++ b/chain/near/build.rs
@@ -1,11 +1,8 @@
 fn main() {
     println!("cargo:rerun-if-changed=proto");
-    tonic_build::configure()
+    tonic_prost_build::configure()
         .out_dir("src/protobuf")
         .extern_path(".sf.near.codec.v1", "crate::codec::pbcodec")
-        .compile(
-            &["proto/near.proto", "proto/substreams-triggers.proto"],
-            &["proto"],
-        )
+        .compile_protos(&["proto/near.proto"], &["proto"])
         .expect("Failed to compile Firehose NEAR proto(s)");
 }
diff --git a/chain/near/proto/substreams-triggers.proto b/chain/near/proto/substreams-triggers.proto
deleted file mode 100644
index 947052a2566..00000000000
--- a/chain/near/proto/substreams-triggers.proto
+++ /dev/null
@@ -1,12 +0,0 @@
-syntax = "proto3";
-
-import "near.proto";
-
-package receipts.v1;
-
-message BlockAndReceipts {
-    sf.near.codec.v1.Block block = 1;
-    repeated sf.near.codec.v1.ExecutionOutcomeWithId outcome = 2;
-    repeated sf.near.codec.v1.Receipt receipt = 3;
-}
-
diff --git a/chain/near/src/adapter.rs b/chain/near/src/adapter.rs
index 4d6151aa5ca..31c7dca7c97 100644
--- a/chain/near/src/adapter.rs
+++ b/chain/near/src/adapter.rs
@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 
 use crate::data_source::PartialAccounts;
-use crate::{data_source::DataSource, Chain};
+use crate::{Chain, data_source::DataSource};
 use graph::blockchain as bc;
 use graph::firehose::{BasicReceiptFilter, PrefixSuffixPair};
 use graph::itertools::Itertools;
@@ -251,14 +251,13 @@ mod test {
     use std::collections::HashSet;
 
     use super::NearBlockFilter;
-    use crate::adapter::{NearReceiptFilter, TriggerFilter, BASIC_RECEIPT_FILTER_TYPE_URL};
+    use crate::adapter::{BASIC_RECEIPT_FILTER_TYPE_URL, TriggerFilter};
     use graph::{
         blockchain::TriggerFilter as _,
         firehose::{BasicReceiptFilter, PrefixSuffixPair},
     };
     use prost::Message;
     use prost_types::Any;
-    use trigger_filters::NearFilter;
 
     #[test]
     fn near_trigger_empty_filter() {
@@ -340,7 +339,7 @@ mod test {
         let firehose_filter = decode_filter(filter);
         assert_eq!(firehose_filter.accounts, vec![String::from("acc1"),],);
 
-        let expected_pairs = vec![
+        let expected_pairs = [
             PrefixSuffixPair {
                 prefix: "acc3".to_string(),
                 suffix: "acc4".to_string(),
@@ -357,132 +356,13 @@ mod test {
 
         let pairs = firehose_filter.prefix_and_suffix_pairs;
         assert_eq!(pairs.len(), 3);
-        assert_eq!(
-            true,
+        assert!(
             expected_pairs.iter().all(|x| pairs.contains(x)),
             "{:?}",
             pairs
         );
     }
 
-    #[test]
-    fn test_near_filter_params_serialization() -> anyhow::Result<()> {
-        struct Case<'a> {
-            name: &'a str,
-            input: NearReceiptFilter,
-            expected: NearFilter<'a>,
-        }
-
-        let cases = vec![
-            Case {
-                name: "empty",
-                input: NearReceiptFilter::default(),
-                expected: NearFilter::default(),
-            },
-            Case {
-                name: "only full matches",
-                input: super::NearReceiptFilter {
-                    accounts: HashSet::from_iter(vec!["acc1".into()]),
-                    partial_accounts: HashSet::new(),
-                },
-                expected: NearFilter {
-                    accounts: HashSet::from_iter(vec!["acc1"]),
-                    partial_accounts: HashSet::default(),
-                },
-            },
-            Case {
-                name: "only partial matches",
-                input: super::NearReceiptFilter {
-                    accounts: HashSet::new(),
-                    partial_accounts: HashSet::from_iter(vec![(Some("acc1".into()), None)]),
-                },
-                expected: NearFilter {
-                    accounts: HashSet::default(),
-                    partial_accounts: HashSet::from_iter(vec![(Some("acc1"), None)]),
-                },
-            },
-            Case {
-                name: "both 1len matches",
-                input: super::NearReceiptFilter {
-                    accounts: HashSet::from_iter(vec!["acc1".into()]),
-                    partial_accounts: HashSet::from_iter(vec![(Some("s1".into()), None)]),
-                },
-                expected: NearFilter {
-                    accounts: HashSet::from_iter(vec!["acc1"]),
-                    partial_accounts: HashSet::from_iter(vec![(Some("s1"), None)]),
-                },
-            },
-            Case {
-                name: "more partials matches",
-                input: super::NearReceiptFilter {
-                    accounts: HashSet::from_iter(vec!["acc1".into()]),
-                    partial_accounts: HashSet::from_iter(vec![
-                        (Some("s1".into()), None),
-                        (None, Some("s3".into())),
-                        (Some("s2".into()), Some("s2".into())),
-                    ]),
-                },
-                expected: NearFilter {
-                    accounts: HashSet::from_iter(vec!["acc1"]),
-                    partial_accounts: HashSet::from_iter(vec![
-                        (Some("s1"), None),
-                        (None, Some("s3")),
-                        (Some("s2"), Some("s2")),
-                    ]),
-                },
-            },
-            Case {
-                name: "both matches",
-                input: NearReceiptFilter {
-                    accounts: HashSet::from_iter(vec![
-                        "acc1".into(),
-                        "=12-30786jhasdgmasd".into(),
-                        "^&%^&^$".into(),
-                        "acc3".into(),
-                    ]),
-                    partial_accounts: HashSet::from_iter(vec![
-                        (Some("1.2.2.3.45.5".into()), None),
-                        (None, Some("kjysdfoiua6sd".into())),
-                        (Some("120938pokasd".into()), Some("102938poai[sd]".into())),
-                    ]),
-                },
-                expected: NearFilter {
-                    accounts: HashSet::from_iter(vec![
-                        "acc1",
-                        "=12-30786jhasdgmasd",
-                        "^&%^&^$",
-                        "acc3",
-                    ]),
-                    partial_accounts: HashSet::from_iter(vec![
-                        (Some("1.2.2.3.45.5"), None),
-                        (None, Some("kjysdfoiua6sd")),
-                        (Some("120938pokasd"), Some("102938poai[sd]")),
-                    ]),
-                },
-            },
-        ];
-
-        for case in cases.into_iter() {
-            let tf = TriggerFilter {
-                block_filter: NearBlockFilter::default(),
-                receipt_filter: case.input,
-            };
-            let param = tf.to_module_params();
-            let filter = NearFilter::try_from(param.as_str()).expect(&format!(
-                "case: {}, the filter to parse params correctly",
-                case.name
-            ));
-
-            assert_eq!(
-                filter, case.expected,
-                "case {},param:\n{}",
-                case.name, param
-            );
-        }
-
-        Ok(())
-    }
-
     fn decode_filter(firehose_filter: Vec<Any>) -> BasicReceiptFilter {
         let firehose_filter = firehose_filter[0].clone();
         assert_eq!(
diff --git a/chain/near/src/chain.rs b/chain/near/src/chain.rs
index e8925c89366..5698301b5e8 100644
--- a/chain/near/src/chain.rs
+++ b/chain/near/src/chain.rs
@@ -1,38 +1,37 @@
-use anyhow::anyhow;
+use async_trait::async_trait;
 use graph::blockchain::client::ChainClient;
 use graph::blockchain::firehose_block_ingestor::FirehoseBlockIngestor;
-use graph::blockchain::substreams_block_stream::SubstreamsBlockStream;
 use graph::blockchain::{
-    BasicBlockchainBuilder, BlockIngestor, BlockchainBuilder, BlockchainKind, NoopRuntimeAdapter,
+    BlockIngestor, BlockchainKind, NoopDecoderHook, NoopRuntimeAdapter, TriggerFilterWrapper,
 };
 use graph::cheap_clone::CheapClone;
-use graph::components::store::DeploymentCursorTracker;
+use graph::components::network_provider::ChainName;
+use graph::components::store::{ChainHeadStore, DeploymentCursorTracker, SourceableStore};
 use graph::data::subgraph::UnifiedMappingApiVersion;
-use graph::env::EnvVars;
-use graph::firehose::FirehoseEndpoint;
-use graph::prelude::{MetricsRegistry, TryFutureExt};
-use graph::schema::InputSchema;
-use graph::substreams::{Clock, Package};
+use graph::firehose::{FirehoseEndpoint, FirehoseEndpoints};
+use graph::futures03::TryFutureExt;
+use graph::prelude::MetricsRegistry;
 use graph::{
     anyhow::Result,
     blockchain::{
+        BlockHash, BlockPtr, Blockchain, EmptyNodeCapabilities, IngestorError,
+        RuntimeAdapter as RuntimeAdapterTrait,
         block_stream::{
             BlockStreamEvent, BlockWithTriggers, FirehoseError,
             FirehoseMapper as FirehoseMapperTrait, TriggersAdapter as TriggersAdapterTrait,
         },
         firehose_block_stream::FirehoseBlockStream,
-        BlockHash, BlockPtr, Blockchain, EmptyNodeCapabilities, IngestorError,
-        RuntimeAdapter as RuntimeAdapterTrait,
     },
     components::store::DeploymentLocator,
     firehose::{self as firehose, ForkStep},
-    prelude::{async_trait, o, BlockNumber, ChainStore, Error, Logger, LoggerFactory},
+    prelude::{BlockNumber, Error, Logger, LoggerFactory, o},
 };
 use prost::Message;
+use std::collections::BTreeSet;
 use std::sync::Arc;
 
 use crate::adapter::TriggerFilter;
-use crate::codec::substreams_triggers::BlockAndReceipts;
+use crate::codec::Block;
 use crate::data_source::{DataSourceTemplate, UnresolvedDataSourceTemplate};
 use crate::trigger::{self, NearTrigger};
 use crate::{
@@ -40,72 +39,13 @@ use crate::{
     data_source::{DataSource, UnresolvedDataSource},
 };
 use graph::blockchain::block_stream::{
-    BlockStream, BlockStreamBuilder, BlockStreamMapper, FirehoseCursor,
+    BlockStream, BlockStreamBuilder, BlockStreamError, BlockStreamMapper, FirehoseCursor,
 };
 
-const NEAR_FILTER_MODULE_NAME: &str = "near_filter";
-const SUBSTREAMS_TRIGGER_FILTER_BYTES: &[u8; 510162] = include_bytes!(
-    "../../../substreams/substreams-trigger-filter/substreams-trigger-filter-v0.1.0.spkg"
-);
-
 pub struct NearStreamBuilder {}
 
 #[async_trait]
 impl BlockStreamBuilder<Chain> for NearStreamBuilder {
-    async fn build_substreams(
-        &self,
-        chain: &Chain,
-        _schema: InputSchema,
-        deployment: DeploymentLocator,
-        block_cursor: FirehoseCursor,
-        subgraph_current_block: Option<BlockPtr>,
-        filter: Arc<<Chain as Blockchain>::TriggerFilter>,
-    ) -> Result<Box<dyn BlockStream<Chain>>> {
-        let mapper = Arc::new(FirehoseMapper {
-            adapter: Arc::new(TriggersAdapter {}),
-            filter,
-        });
-        let mut package =
-            Package::decode(SUBSTREAMS_TRIGGER_FILTER_BYTES.to_vec().as_ref()).unwrap();
-        match package.modules.as_mut() {
-            Some(modules) => modules
-                .modules
-                .iter_mut()
-                .find(|module| module.name == NEAR_FILTER_MODULE_NAME)
-                .map(|module| {
-                    graph::substreams::patch_module_params(
-                        mapper.filter.to_module_params(),
-                        module,
-                    );
-                    module
-                }),
-            None => None,
-        };
-
-        let logger = chain
-            .logger_factory
-            .subgraph_logger(&deployment)
-            .new(o!("component" => "SubstreamsBlockStream"));
-        let start_block = subgraph_current_block
-            .as_ref()
-            .map(|b| b.number)
-            .unwrap_or_default();
-
-        Ok(Box::new(SubstreamsBlockStream::new(
-            deployment.hash,
-            chain.chain_client(),
-            subgraph_current_block,
-            block_cursor.as_ref().clone(),
-            mapper,
-            package.modules.clone(),
-            NEAR_FILTER_MODULE_NAME.to_string(),
-            vec![start_block],
-            vec![],
-            logger,
-            chain.metrics_registry.clone(),
-        )))
-    }
-
     async fn build_firehose(
         &self,
         chain: &Chain,
@@ -148,8 +88,9 @@ impl BlockStreamBuilder<Chain> for NearStreamBuilder {
         _chain: &Chain,
         _deployment: DeploymentLocator,
         _start_blocks: Vec<BlockNumber>,
+        _source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
         _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<<Chain as Blockchain>::TriggerFilter>,
+        _filter: Arc<TriggerFilterWrapper<Chain>>,
         _unified_api_version: UnifiedMappingApiVersion,
     ) -> Result<Box<dyn BlockStream<Chain>>> {
         todo!()
@@ -158,12 +99,11 @@ impl BlockStreamBuilder<Chain> for NearStreamBuilder {
 
 pub struct Chain {
     logger_factory: LoggerFactory,
-    name: String,
+    name: ChainName,
     client: Arc<ChainClient<Self>>,
-    chain_store: Arc<dyn ChainStore>,
+    chain_head_store: Arc<dyn ChainHeadStore>,
     metrics_registry: Arc<MetricsRegistry>,
     block_stream_builder: Arc<dyn BlockStreamBuilder<Self>>,
-    prefer_substreams: bool,
 }
 
 impl std::fmt::Debug for Chain {
@@ -172,16 +112,21 @@ impl std::fmt::Debug for Chain {
     }
 }
 
-impl BlockchainBuilder<Chain> for BasicBlockchainBuilder {
-    fn build(self, config: &Arc<EnvVars>) -> Chain {
+impl Chain {
+    pub fn new(
+        logger_factory: LoggerFactory,
+        name: ChainName,
+        chain_head_store: Arc<dyn ChainHeadStore>,
+        firehose_endpoints: FirehoseEndpoints,
+        metrics_registry: Arc<MetricsRegistry>,
+    ) -> Self {
         Chain {
-            logger_factory: self.logger_factory,
-            name: self.name,
-            chain_store: self.chain_store,
-            client: Arc::new(ChainClient::new_firehose(self.firehose_endpoints)),
-            metrics_registry: self.metrics_registry,
+            logger_factory,
+            name,
+            chain_head_store,
+            client: Arc::new(ChainClient::new_firehose(firehose_endpoints)),
+            metrics_registry,
             block_stream_builder: Arc::new(NearStreamBuilder {}),
-            prefer_substreams: config.prefer_substreams_block_streams,
         }
     }
 }
@@ -209,6 +154,8 @@ impl Blockchain for Chain {
 
     type NodeCapabilities = EmptyNodeCapabilities<Chain>;
 
+    type DecoderHook = NoopDecoderHook;
+
     fn triggers_adapter(
         &self,
         _loc: &DeploymentLocator,
@@ -224,23 +171,10 @@ impl Blockchain for Chain {
         deployment: DeploymentLocator,
         store: impl DeploymentCursorTracker,
         start_blocks: Vec<BlockNumber>,
-        filter: Arc<Self::TriggerFilter>,
+        _source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
+        filter: Arc<TriggerFilterWrapper<Self>>,
         unified_api_version: UnifiedMappingApiVersion,
     ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        if self.prefer_substreams {
-            return self
-                .block_stream_builder
-                .build_substreams(
-                    self,
-                    store.input_schema(),
-                    deployment,
-                    store.firehose_cursor(),
-                    store.block_ptr(),
-                    filter,
-                )
-                .await;
-        }
-
         self.block_stream_builder
             .build_firehose(
                 self,
@@ -248,7 +182,7 @@ impl Blockchain for Chain {
                 store.firehose_cursor(),
                 start_blocks,
                 store.block_ptr(),
-                filter,
+                filter.chain_filter.clone(),
                 unified_api_version,
             )
             .await
@@ -263,11 +197,13 @@ impl Blockchain for Chain {
         _logger: &Logger,
         _cursor: FirehoseCursor,
     ) -> Result<codec::Block, Error> {
-        unimplemented!("This chain does not support Dynamic Data Sources. is_refetch_block_required always returns false, this shouldn't be called.")
+        unimplemented!(
+            "This chain does not support Dynamic Data Sources. is_refetch_block_required always returns false, this shouldn't be called."
+        )
     }
 
-    fn chain_store(&self) -> Arc<dyn ChainStore> {
-        self.chain_store.clone()
+    async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error> {
+        self.chain_head_store.cheap_clone().chain_head_ptr().await
     }
 
     async fn block_pointer_from_number(
@@ -275,7 +211,7 @@ impl Blockchain for Chain {
         logger: &Logger,
         number: BlockNumber,
     ) -> Result<BlockPtr, IngestorError> {
-        let firehose_endpoint = self.client.firehose_endpoint()?;
+        let firehose_endpoint = self.client.firehose_endpoint().await?;
 
         firehose_endpoint
             .block_ptr_for_number::<codec::HeaderOnlyBlock>(logger, number)
@@ -283,17 +219,19 @@ impl Blockchain for Chain {
             .await
     }
 
-    fn runtime_adapter(&self) -> Arc<dyn RuntimeAdapterTrait<Self>> {
-        Arc::new(NoopRuntimeAdapter::default())
+    async fn runtime(
+        &self,
+    ) -> anyhow::Result<(Arc<dyn RuntimeAdapterTrait<Self>>, Self::DecoderHook)> {
+        Ok((Arc::new(NoopRuntimeAdapter::default()), NoopDecoderHook))
     }
 
     fn chain_client(&self) -> Arc<ChainClient<Self>> {
         self.client.clone()
     }
 
-    fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>> {
+    async fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>> {
         let ingestor = FirehoseBlockIngestor::<crate::HeaderOnlyBlock, Self>::new(
-            self.chain_store.cheap_clone(),
+            self.chain_head_store.cheap_clone(),
             self.chain_client(),
             self.logger_factory
                 .component_logger("NearFirehoseBlockIngestor", None),
@@ -312,10 +250,22 @@ impl TriggersAdapterTrait<Chain> for TriggersAdapter {
         _from: BlockNumber,
         _to: BlockNumber,
         _filter: &TriggerFilter,
-    ) -> Result<Vec<BlockWithTriggers<Chain>>, Error> {
+    ) -> Result<(Vec<BlockWithTriggers<Chain>>, BlockNumber), Error> {
         panic!("Should never be called since not used by FirehoseBlockStream")
     }
 
+    async fn load_block_ptrs_by_numbers(
+        &self,
+        _logger: Logger,
+        _block_numbers: BTreeSet<BlockNumber>,
+    ) -> Result<Vec<Block>> {
+        unimplemented!()
+    }
+
+    async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error> {
+        unimplemented!()
+    }
+
     async fn triggers_in_block(
         &self,
         logger: &Logger,
@@ -386,6 +336,7 @@ impl TriggersAdapterTrait<Chain> for TriggersAdapter {
         &self,
         _ptr: BlockPtr,
         _offset: BlockNumber,
+        _root: Option<BlockHash>,
     ) -> Result<Option<codec::Block>, Error> {
         panic!("Should never be called since FirehoseBlockStream cannot resolve it")
     }
@@ -408,10 +359,18 @@ pub struct FirehoseMapper {
 
 #[async_trait]
 impl BlockStreamMapper<Chain> for FirehoseMapper {
-    fn decode_block(&self, output: Option<&[u8]>) -> Result<Option<codec::Block>, Error> {
+    fn decode_block(
+        &self,
+        output: Option<&[u8]>,
+    ) -> Result<Option<codec::Block>, BlockStreamError> {
         let block = match output {
             Some(block) => codec::Block::decode(block)?,
-            None => anyhow::bail!("near mapper is expected to always have a block"),
+            None => {
+                return Err(anyhow::anyhow!(
+                    "near mapper is expected to always have a block"
+                ))
+                .map_err(BlockStreamError::from);
+            }
         };
 
         Ok(Some(block))
@@ -421,46 +380,11 @@ impl BlockStreamMapper<Chain> for FirehoseMapper {
         &self,
         logger: &Logger,
         block: codec::Block,
-    ) -> Result<BlockWithTriggers<Chain>, Error> {
+    ) -> Result<BlockWithTriggers<Chain>, BlockStreamError> {
         self.adapter
             .triggers_in_block(logger, block, self.filter.as_ref())
             .await
-    }
-
-    async fn handle_substreams_block(
-        &self,
-        _logger: &Logger,
-        _clock: Clock,
-        cursor: FirehoseCursor,
-        message: Vec<u8>,
-    ) -> Result<BlockStreamEvent<Chain>, Error> {
-        let BlockAndReceipts {
-            block,
-            outcome,
-            receipt,
-        } = BlockAndReceipts::decode(message.as_ref())?;
-        let block = block.ok_or_else(|| anyhow!("near block is mandatory on substreams"))?;
-        let arc_block = Arc::new(block.clone());
-
-        let trigger_data = outcome
-            .into_iter()
-            .zip(receipt.into_iter())
-            .map(|(outcome, receipt)| {
-                NearTrigger::Receipt(Arc::new(trigger::ReceiptWithOutcome {
-                    outcome,
-                    receipt,
-                    block: arc_block.clone(),
-                }))
-            })
-            .collect();
-
-        Ok(BlockStreamEvent::ProcessBlock(
-            BlockWithTriggers {
-                block,
-                trigger_data,
-            },
-            cursor,
-        ))
+            .map_err(BlockStreamError::from)
     }
 }
 
@@ -475,7 +399,7 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
         logger: &Logger,
         response: &firehose::Response,
     ) -> Result<BlockStreamEvent<Chain>, FirehoseError> {
-        let step = ForkStep::from_i32(response.step).unwrap_or_else(|| {
+        let step = ForkStep::try_from(response.step).unwrap_or_else(|_| {
             panic!(
                 "unknown step i32 value {}, maybe you forgot update & re-regenerate the protobuf definitions?",
                 response.step
@@ -517,7 +441,9 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
             }
 
             StepFinal => {
-                panic!("irreversible step is not handled and should not be requested in the Firehose request")
+                panic!(
+                    "irreversible step is not handled and should not be requested in the Firehose request"
+                )
             }
 
             StepUnset => {
@@ -555,22 +481,23 @@ mod test {
     use std::{collections::HashSet, sync::Arc, vec};
 
     use graph::{
-        blockchain::{block_stream::BlockWithTriggers, DataSource as _, TriggersAdapter as _},
-        prelude::{tokio, Link},
+        blockchain::{DataSource as _, TriggersAdapter as _, block_stream::BlockWithTriggers},
+        data::subgraph::LATEST_VERSION,
+        prelude::Link,
         semver::Version,
-        slog::{self, o, Logger},
+        slog::{self, Logger, o},
     };
 
     use crate::{
+        Chain,
         adapter::{NearReceiptFilter, TriggerFilter},
         codec::{
-            self, execution_outcome, receipt, Block, BlockHeader, DataReceiver, ExecutionOutcome,
-            ExecutionOutcomeWithId, IndexerExecutionOutcomeWithReceipt, IndexerShard,
-            ReceiptAction, SuccessValueExecutionStatus,
+            self, Block, BlockHeader, DataReceiver, ExecutionOutcome, ExecutionOutcomeWithId,
+            IndexerExecutionOutcomeWithReceipt, IndexerShard, ReceiptAction,
+            SuccessValueExecutionStatus, execution_outcome, receipt,
         },
-        data_source::{DataSource, Mapping, PartialAccounts, ReceiptHandler, NEAR_KIND},
+        data_source::{DataSource, Mapping, NEAR_KIND, PartialAccounts, ReceiptHandler},
         trigger::{NearTrigger, ReceiptWithOutcome},
-        Chain,
     };
 
     use super::TriggersAdapter;
@@ -578,7 +505,7 @@ mod test {
     #[test]
     fn validate_empty() {
         let ds = new_data_source(None, None);
-        let errs = ds.validate();
+        let errs = ds.validate(LATEST_VERSION);
         assert_eq!(errs.len(), 1, "{:?}", ds);
         assert_eq!(errs[0].to_string(), "subgraph source address is required");
     }
@@ -586,7 +513,7 @@ mod test {
     #[test]
     fn validate_empty_account_none_partial() {
         let ds = new_data_source(None, Some(PartialAccounts::default()));
-        let errs = ds.validate();
+        let errs = ds.validate(LATEST_VERSION);
         assert_eq!(errs.len(), 1, "{:?}", ds);
         assert_eq!(errs[0].to_string(), "subgraph source address is required");
     }
@@ -600,7 +527,7 @@ mod test {
                 suffixes: vec!["x.near".to_string()],
             }),
         );
-        let errs = ds.validate();
+        let errs = ds.validate(LATEST_VERSION);
         assert_eq!(errs.len(), 0, "{:?}", ds);
     }
 
@@ -614,18 +541,17 @@ mod test {
             }),
         );
         let errs: Vec<String> = ds
-            .validate()
+            .validate(LATEST_VERSION)
             .into_iter()
             .map(|err| err.to_string())
             .collect();
         assert_eq!(errs.len(), 2, "{:?}", ds);
 
-        let expected_errors = vec![
+        let expected_errors = [
             "partial account prefixes can't have empty values".to_string(),
             "partial account suffixes can't have empty values".to_string(),
         ];
-        assert_eq!(
-            true,
+        assert!(
             expected_errors.iter().all(|err| errs.contains(err)),
             "{:?}",
             errs
@@ -635,7 +561,7 @@ mod test {
     #[test]
     fn validate_empty_partials() {
         let ds = new_data_source(Some("x.near".to_string()), None);
-        let errs = ds.validate();
+        let errs = ds.validate(LATEST_VERSION);
         assert_eq!(errs.len(), 0, "{:?}", ds);
     }
 
@@ -711,8 +637,7 @@ mod test {
                 case.name,
                 receipt.partial_accounts,
             );
-            assert_eq!(
-                true,
+            assert!(
                 case.expected
                     .iter()
                     .all(|x| receipt.partial_accounts.contains(x)),
@@ -880,7 +805,7 @@ mod test {
         }
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn test_trigger_filter_empty() {
         let account1: String = "account1".into();
 
@@ -898,7 +823,7 @@ mod test {
         assert_eq!(block_with_triggers.trigger_count(), 0);
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn test_trigger_filter_every_block() {
         let account1: String = "account1".into();
 
@@ -924,7 +849,7 @@ mod test {
         assert_eq!(height, vec![1]);
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn test_trigger_filter_every_receipt() {
         let account1: String = "account1".into();
 
@@ -956,14 +881,14 @@ mod test {
             .trigger_data
             .clone()
             .into_iter()
-            .filter_map(|x| match x {
-                crate::trigger::NearTrigger::Block(b) => b.header.clone().map(|x| x.height),
+            .filter_map(|x| match x.as_chain() {
+                Some(crate::trigger::NearTrigger::Block(b)) => b.header.clone().map(|x| x.height),
                 _ => None,
             })
             .collect()
     }
 
-    fn new_success_block(height: u64, receiver_id: &String) -> codec::Block {
+    fn new_success_block(height: u64, receiver_id: &str) -> codec::Block {
         codec::Block {
             header: Some(BlockHeader {
                 height,
@@ -975,12 +900,12 @@ mod test {
                     receipt: Some(crate::codec::Receipt {
                         receipt: Some(receipt::Receipt::Action(ReceiptAction {
                             output_data_receivers: vec![DataReceiver {
-                                receiver_id: receiver_id.clone(),
+                                receiver_id: receiver_id.to_string(),
                                 ..Default::default()
                             }],
                             ..Default::default()
                         })),
-                        receiver_id: receiver_id.clone(),
+                        receiver_id: receiver_id.to_string(),
                         ..Default::default()
                     }),
                     execution_outcome: Some(ExecutionOutcomeWithId {
@@ -1030,7 +955,7 @@ mod test {
         }
     }
 
-    fn new_receipt_with_outcome(receiver_id: &String, block: Arc<Block>) -> ReceiptWithOutcome {
+    fn new_receipt_with_outcome(receiver_id: &str, block: Arc<Block>) -> ReceiptWithOutcome {
         ReceiptWithOutcome {
             outcome: ExecutionOutcomeWithId {
                 outcome: Some(ExecutionOutcome {
@@ -1045,12 +970,12 @@ mod test {
             receipt: codec::Receipt {
                 receipt: Some(receipt::Receipt::Action(ReceiptAction {
                     output_data_receivers: vec![DataReceiver {
-                        receiver_id: receiver_id.clone(),
+                        receiver_id: receiver_id.to_string(),
                         ..Default::default()
                     }],
                     ..Default::default()
                 })),
-                receiver_id: receiver_id.clone(),
+                receiver_id: receiver_id.to_string(),
                 ..Default::default()
             },
             block,
diff --git a/chain/near/src/codec.rs b/chain/near/src/codec.rs
index bfabce649c4..569e8cf5243 100644
--- a/chain/near/src/codec.rs
+++ b/chain/near/src/codec.rs
@@ -2,23 +2,18 @@
 #[path = "protobuf/sf.near.codec.v1.rs"]
 pub mod pbcodec;
 
-#[rustfmt::skip]
-#[path = "protobuf/receipts.v1.rs"]
-pub mod substreams_triggers;
-
 use graph::{
-    blockchain::Block as BlockchainBlock,
-    blockchain::{BlockPtr, BlockTime},
-    prelude::{hex, web3::types::H256, BlockNumber},
+    blockchain::{Block as BlockchainBlock, BlockPtr, BlockTime},
+    prelude::{BlockNumber, alloy::primitives::B256, hex},
 };
 use std::convert::TryFrom;
 use std::fmt::LowerHex;
 
 pub use pbcodec::*;
 
-impl From<&CryptoHash> for H256 {
+impl From<&CryptoHash> for B256 {
     fn from(input: &CryptoHash) -> Self {
-        H256::from_slice(&input.bytes)
+        B256::from_slice(&input.bytes)
     }
 }
 
@@ -31,7 +26,7 @@ impl LowerHex for &CryptoHash {
 impl BlockHeader {
     pub fn parent_ptr(&self) -> Option<BlockPtr> {
         match (self.prev_hash.as_ref(), self.prev_height) {
-            (Some(hash), number) => Some(BlockPtr::from((H256::from(hash), number))),
+            (Some(hash), number) => Some(BlockPtr::from((B256::from(hash), number))),
             _ => None,
         }
     }
@@ -39,7 +34,7 @@ impl BlockHeader {
 
 impl<'a> From<&'a BlockHeader> for BlockPtr {
     fn from(b: &'a BlockHeader) -> BlockPtr {
-        BlockPtr::from((H256::from(b.hash.as_ref().unwrap()), b.height))
+        BlockPtr::from((B256::from(b.hash.as_ref().unwrap()), b.height))
     }
 }
 
@@ -77,8 +72,7 @@ impl BlockchainBlock for Block {
     }
 
     fn timestamp(&self) -> BlockTime {
-        let ts = i64::try_from(self.header().timestamp).unwrap();
-        BlockTime::since_epoch(ts, 0)
+        block_time_from_header(self.header())
     }
 }
 
@@ -108,8 +102,7 @@ impl BlockchainBlock for HeaderOnlyBlock {
     }
 
     fn timestamp(&self) -> BlockTime {
-        let ts = i64::try_from(self.header().timestamp).unwrap();
-        BlockTime::since_epoch(ts, 0)
+        block_time_from_header(self.header())
     }
 }
 
@@ -122,3 +115,25 @@ impl execution_outcome::Status {
         }
     }
 }
+
+fn block_time_from_header(header: &BlockHeader) -> BlockTime {
+    // The timstamp is in ns since the epoch
+    let ts = i64::try_from(header.timestamp_nanosec).unwrap();
+    let secs = ts / 1_000_000_000;
+    let ns: u32 = (ts % 1_000_000_000) as u32;
+    BlockTime::since_epoch(secs, ns)
+}
+
+#[test]
+fn timestamp_conversion() {
+    // 2020-07-21T21:50:10Z in ns
+    let ts = 1_595_368_210_762_782_796;
+    let header = BlockHeader {
+        timestamp_nanosec: ts,
+        ..Default::default()
+    };
+    assert_eq!(
+        1595368210,
+        block_time_from_header(&header).as_secs_since_epoch()
+    );
+}
diff --git a/chain/near/src/data_source.rs b/chain/near/src/data_source.rs
index 86f5a784322..01484905a58 100644
--- a/chain/near/src/data_source.rs
+++ b/chain/near/src/data_source.rs
@@ -1,15 +1,15 @@
+use async_trait::async_trait;
 use graph::anyhow::Context;
 use graph::blockchain::{Block, TriggerWithHandler};
+use graph::components::link_resolver::LinkResolverContext;
 use graph::components::store::StoredDynamicDataSource;
-use graph::data::subgraph::DataSourceContext;
+use graph::components::subgraph::InstanceDSTemplateInfo;
+use graph::data::subgraph::{DataSourceContext, DeploymentHash};
 use graph::prelude::SubgraphManifestValidationError;
 use graph::{
-    anyhow::{anyhow, Error},
+    anyhow::{Error, anyhow},
     blockchain::{self, Blockchain},
-    prelude::{
-        async_trait, BlockNumber, CheapClone, DataSourceTemplateInfo, Deserialize, Link,
-        LinkResolver, Logger,
-    },
+    prelude::{BlockNumber, CheapClone, Deserialize, Link, LinkResolver, Logger},
     semver,
 };
 use std::collections::HashSet;
@@ -35,7 +35,10 @@ pub struct DataSource {
 }
 
 impl blockchain::DataSource<Chain> for DataSource {
-    fn from_template_info(_template_info: DataSourceTemplateInfo<Chain>) -> Result<Self, Error> {
+    fn from_template_info(
+        _info: InstanceDSTemplateInfo,
+        _template: &graph::data_source::DataSourceTemplate<Chain>,
+    ) -> Result<Self, Error> {
         Err(anyhow!("Near subgraphs do not support templates"))
 
         // How this might be implemented if/when Near gets support for templates:
@@ -225,7 +228,7 @@ impl blockchain::DataSource<Chain> for DataSource {
         todo!()
     }
 
-    fn validate(&self) -> Vec<Error> {
+    fn validate(&self, _: &semver::Version) -> Vec<Error> {
         let mut errors = Vec::new();
 
         if self.kind != NEAR_KIND {
@@ -329,9 +332,11 @@ pub struct UnresolvedDataSource {
 impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
     async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         logger: &Logger,
         _manifest_idx: u32,
+        _spec_version: &semver::Version,
     ) -> Result<DataSource, Error> {
         let UnresolvedDataSource {
             kind,
@@ -342,7 +347,7 @@ impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
             context,
         } = self;
 
-        let mapping = mapping.resolve(resolver, logger).await.with_context(|| {
+        let mapping = mapping.resolve(deployment_hash, resolver, logger).await.with_context(|| {
             format!(
                 "failed to resolve data source {} with source_account {:?} and source_start_block {}",
                 name, source.account, source.start_block
@@ -368,9 +373,11 @@ pub type DataSourceTemplate = BaseDataSourceTemplate<Mapping>;
 impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTemplate {
     async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         logger: &Logger,
         _manifest_idx: u32,
+        _spec_version: &semver::Version,
     ) -> Result<DataSourceTemplate, Error> {
         let UnresolvedDataSourceTemplate {
             kind,
@@ -380,7 +387,7 @@ impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTem
         } = self;
 
         let mapping = mapping
-            .resolve(resolver, logger)
+            .resolve(deployment_hash, resolver, logger)
             .await
             .with_context(|| format!("failed to resolve data source template {}", name))?;
 
@@ -431,6 +438,7 @@ pub struct UnresolvedMapping {
 impl UnresolvedMapping {
     pub async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         logger: &Logger,
     ) -> Result<Mapping, Error> {
@@ -446,7 +454,7 @@ impl UnresolvedMapping {
         let api_version = semver::Version::parse(&api_version)?;
 
         let module_bytes = resolver
-            .cat(logger, &link)
+            .cat(&LinkResolverContext::new(deployment_hash, logger), &link)
             .await
             .with_context(|| format!("failed to resolve mapping {}", link.link))?;
 
diff --git a/chain/near/src/protobuf/receipts.v1.rs b/chain/near/src/protobuf/receipts.v1.rs
deleted file mode 100644
index 5b648d84e90..00000000000
--- a/chain/near/src/protobuf/receipts.v1.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockAndReceipts {
-    #[prost(message, optional, tag = "1")]
-    pub block: ::core::option::Option<crate::codec::pbcodec::Block>,
-    #[prost(message, repeated, tag = "2")]
-    pub outcome: ::prost::alloc::vec::Vec<crate::codec::pbcodec::ExecutionOutcomeWithId>,
-    #[prost(message, repeated, tag = "3")]
-    pub receipt: ::prost::alloc::vec::Vec<crate::codec::pbcodec::Receipt>,
-}
diff --git a/chain/near/src/runtime/abi.rs b/chain/near/src/runtime/abi.rs
index 252a4ffa49f..b74d8f5f7ff 100644
--- a/chain/near/src/runtime/abi.rs
+++ b/chain/near/src/runtime/abi.rs
@@ -1,124 +1,137 @@
 use crate::codec;
 use crate::trigger::ReceiptWithOutcome;
+use async_trait::async_trait;
 use graph::anyhow::anyhow;
 use graph::runtime::gas::GasCounter;
-use graph::runtime::{asc_new, AscHeap, AscPtr, DeterministicHostError, HostExportError, ToAscObj};
+use graph::runtime::{AscHeap, AscPtr, DeterministicHostError, HostExportError, ToAscObj, asc_new};
 use graph_runtime_wasm::asc_abi::class::{Array, AscEnum, EnumPayload, Uint8Array};
 
 pub(crate) use super::generated::*;
 
+#[async_trait]
 impl ToAscObj<AscBlock> for codec::Block {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscBlock, HostExportError> {
         Ok(AscBlock {
-            author: asc_new(heap, &self.author, gas)?,
-            header: asc_new(heap, self.header(), gas)?,
-            chunks: asc_new(heap, &self.chunk_headers, gas)?,
+            author: asc_new(heap, &self.author, gas).await?,
+            header: asc_new(heap, self.header(), gas).await?,
+            chunks: asc_new(heap, &self.chunk_headers, gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscBlockHeader> for codec::BlockHeader {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscBlockHeader, HostExportError> {
-        let chunk_mask = Array::new(self.chunk_mask.as_ref(), heap, gas)?;
+        let chunk_mask = Array::new(self.chunk_mask.as_ref(), heap, gas).await?;
 
         Ok(AscBlockHeader {
             height: self.height,
             prev_height: self.prev_height,
-            epoch_id: asc_new(heap, self.epoch_id.as_ref().unwrap(), gas)?,
-            next_epoch_id: asc_new(heap, self.next_epoch_id.as_ref().unwrap(), gas)?,
-            hash: asc_new(heap, self.hash.as_ref().unwrap(), gas)?,
-            prev_hash: asc_new(heap, self.prev_hash.as_ref().unwrap(), gas)?,
-            prev_state_root: asc_new(heap, self.prev_state_root.as_ref().unwrap(), gas)?,
-            chunk_receipts_root: asc_new(heap, self.chunk_receipts_root.as_ref().unwrap(), gas)?,
-            chunk_headers_root: asc_new(heap, self.chunk_headers_root.as_ref().unwrap(), gas)?,
-            chunk_tx_root: asc_new(heap, self.chunk_tx_root.as_ref().unwrap(), gas)?,
-            outcome_root: asc_new(heap, self.outcome_root.as_ref().unwrap(), gas)?,
+            epoch_id: asc_new(heap, self.epoch_id.as_ref().unwrap(), gas).await?,
+            next_epoch_id: asc_new(heap, self.next_epoch_id.as_ref().unwrap(), gas).await?,
+            hash: asc_new(heap, self.hash.as_ref().unwrap(), gas).await?,
+            prev_hash: asc_new(heap, self.prev_hash.as_ref().unwrap(), gas).await?,
+            prev_state_root: asc_new(heap, self.prev_state_root.as_ref().unwrap(), gas).await?,
+            chunk_receipts_root: asc_new(heap, self.chunk_receipts_root.as_ref().unwrap(), gas)
+                .await?,
+            chunk_headers_root: asc_new(heap, self.chunk_headers_root.as_ref().unwrap(), gas)
+                .await?,
+            chunk_tx_root: asc_new(heap, self.chunk_tx_root.as_ref().unwrap(), gas).await?,
+            outcome_root: asc_new(heap, self.outcome_root.as_ref().unwrap(), gas).await?,
             chunks_included: self.chunks_included,
-            challenges_root: asc_new(heap, self.challenges_root.as_ref().unwrap(), gas)?,
+            challenges_root: asc_new(heap, self.challenges_root.as_ref().unwrap(), gas).await?,
             timestamp_nanosec: self.timestamp_nanosec,
-            random_value: asc_new(heap, self.random_value.as_ref().unwrap(), gas)?,
-            validator_proposals: asc_new(heap, &self.validator_proposals, gas)?,
-            chunk_mask: AscPtr::alloc_obj(chunk_mask, heap, gas)?,
-            gas_price: asc_new(heap, self.gas_price.as_ref().unwrap(), gas)?,
+            random_value: asc_new(heap, self.random_value.as_ref().unwrap(), gas).await?,
+            validator_proposals: asc_new(heap, &self.validator_proposals, gas).await?,
+            chunk_mask: AscPtr::alloc_obj(chunk_mask, heap, gas).await?,
+            gas_price: asc_new(heap, self.gas_price.as_ref().unwrap(), gas).await?,
             block_ordinal: self.block_ordinal,
-            total_supply: asc_new(heap, self.total_supply.as_ref().unwrap(), gas)?,
-            challenges_result: asc_new(heap, &self.challenges_result, gas)?,
-            last_final_block: asc_new(heap, self.last_final_block.as_ref().unwrap(), gas)?,
-            last_ds_final_block: asc_new(heap, self.last_ds_final_block.as_ref().unwrap(), gas)?,
-            next_bp_hash: asc_new(heap, self.next_bp_hash.as_ref().unwrap(), gas)?,
-            block_merkle_root: asc_new(heap, self.block_merkle_root.as_ref().unwrap(), gas)?,
-            epoch_sync_data_hash: asc_new(heap, self.epoch_sync_data_hash.as_slice(), gas)?,
-            approvals: asc_new(heap, &self.approvals, gas)?,
-            signature: asc_new(heap, &self.signature.as_ref().unwrap(), gas)?,
+            total_supply: asc_new(heap, self.total_supply.as_ref().unwrap(), gas).await?,
+            challenges_result: asc_new(heap, &self.challenges_result, gas).await?,
+            last_final_block: asc_new(heap, self.last_final_block.as_ref().unwrap(), gas).await?,
+            last_ds_final_block: asc_new(heap, self.last_ds_final_block.as_ref().unwrap(), gas)
+                .await?,
+            next_bp_hash: asc_new(heap, self.next_bp_hash.as_ref().unwrap(), gas).await?,
+            block_merkle_root: asc_new(heap, self.block_merkle_root.as_ref().unwrap(), gas).await?,
+            epoch_sync_data_hash: asc_new(heap, self.epoch_sync_data_hash.as_slice(), gas).await?,
+            approvals: asc_new(heap, &self.approvals, gas).await?,
+            signature: asc_new(heap, &self.signature.as_ref().unwrap(), gas).await?,
             latest_protocol_version: self.latest_protocol_version,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscChunkHeader> for codec::ChunkHeader {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscChunkHeader, HostExportError> {
         Ok(AscChunkHeader {
-            chunk_hash: asc_new(heap, self.chunk_hash.as_slice(), gas)?,
-            signature: asc_new(heap, &self.signature.as_ref().unwrap(), gas)?,
-            prev_block_hash: asc_new(heap, self.prev_block_hash.as_slice(), gas)?,
-            prev_state_root: asc_new(heap, self.prev_state_root.as_slice(), gas)?,
-            encoded_merkle_root: asc_new(heap, self.encoded_merkle_root.as_slice(), gas)?,
+            chunk_hash: asc_new(heap, self.chunk_hash.as_slice(), gas).await?,
+            signature: asc_new(heap, &self.signature.as_ref().unwrap(), gas).await?,
+            prev_block_hash: asc_new(heap, self.prev_block_hash.as_slice(), gas).await?,
+            prev_state_root: asc_new(heap, self.prev_state_root.as_slice(), gas).await?,
+            encoded_merkle_root: asc_new(heap, self.encoded_merkle_root.as_slice(), gas).await?,
             encoded_length: self.encoded_length,
             height_created: self.height_created,
             height_included: self.height_included,
             shard_id: self.shard_id,
             gas_used: self.gas_used,
             gas_limit: self.gas_limit,
-            balance_burnt: asc_new(heap, self.balance_burnt.as_ref().unwrap(), gas)?,
-            outgoing_receipts_root: asc_new(heap, self.outgoing_receipts_root.as_slice(), gas)?,
-            tx_root: asc_new(heap, self.tx_root.as_slice(), gas)?,
-            validator_proposals: asc_new(heap, &self.validator_proposals, gas)?,
+            balance_burnt: asc_new(heap, self.balance_burnt.as_ref().unwrap(), gas).await?,
+            outgoing_receipts_root: asc_new(heap, self.outgoing_receipts_root.as_slice(), gas)
+                .await?,
+            tx_root: asc_new(heap, self.tx_root.as_slice(), gas).await?,
+            validator_proposals: asc_new(heap, &self.validator_proposals, gas).await?,
 
             _padding: 0,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscChunkHeaderArray> for Vec<codec::ChunkHeader> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscChunkHeaderArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscChunkHeaderArray(Array::new(&content, heap, gas)?))
+        let mut content = Vec::new();
+        for x in self {
+            content.push(asc_new(heap, x, gas).await?);
+        }
+        Ok(AscChunkHeaderArray(Array::new(&content, heap, gas).await?))
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscReceiptWithOutcome> for ReceiptWithOutcome {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscReceiptWithOutcome, HostExportError> {
         Ok(AscReceiptWithOutcome {
-            outcome: asc_new(heap, &self.outcome, gas)?,
-            receipt: asc_new(heap, &self.receipt, gas)?,
-            block: asc_new(heap, self.block.as_ref(), gas)?,
+            outcome: asc_new(heap, &self.outcome, gas).await?,
+            receipt: asc_new(heap, &self.receipt, gas).await?,
+            block: asc_new(heap, self.block.as_ref(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscActionReceipt> for codec::Receipt {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -133,21 +146,23 @@ impl ToAscObj<AscActionReceipt> for codec::Receipt {
         };
 
         Ok(AscActionReceipt {
-            id: asc_new(heap, &self.receipt_id.as_ref().unwrap(), gas)?,
-            predecessor_id: asc_new(heap, &self.predecessor_id, gas)?,
-            receiver_id: asc_new(heap, &self.receiver_id, gas)?,
-            signer_id: asc_new(heap, &action.signer_id, gas)?,
-            signer_public_key: asc_new(heap, action.signer_public_key.as_ref().unwrap(), gas)?,
-            gas_price: asc_new(heap, action.gas_price.as_ref().unwrap(), gas)?,
-            output_data_receivers: asc_new(heap, &action.output_data_receivers, gas)?,
-            input_data_ids: asc_new(heap, &action.input_data_ids, gas)?,
-            actions: asc_new(heap, &action.actions, gas)?,
+            id: asc_new(heap, &self.receipt_id.as_ref().unwrap(), gas).await?,
+            predecessor_id: asc_new(heap, &self.predecessor_id, gas).await?,
+            receiver_id: asc_new(heap, &self.receiver_id, gas).await?,
+            signer_id: asc_new(heap, &action.signer_id, gas).await?,
+            signer_public_key: asc_new(heap, action.signer_public_key.as_ref().unwrap(), gas)
+                .await?,
+            gas_price: asc_new(heap, action.gas_price.as_ref().unwrap(), gas).await?,
+            output_data_receivers: asc_new(heap, &action.output_data_receivers, gas).await?,
+            input_data_ids: asc_new(heap, &action.input_data_ids, gas).await?,
+            actions: asc_new(heap, &action.actions, gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscActionEnum> for codec::Action {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -155,35 +170,35 @@ impl ToAscObj<AscActionEnum> for codec::Action {
         let (kind, payload) = match self.action.as_ref().unwrap() {
             codec::action::Action::CreateAccount(action) => (
                 AscActionKind::CreateAccount,
-                asc_new(heap, action, gas)?.to_payload(),
+                asc_new(heap, action, gas).await?.to_payload(),
             ),
             codec::action::Action::DeployContract(action) => (
                 AscActionKind::DeployContract,
-                asc_new(heap, action, gas)?.to_payload(),
+                asc_new(heap, action, gas).await?.to_payload(),
             ),
             codec::action::Action::FunctionCall(action) => (
                 AscActionKind::FunctionCall,
-                asc_new(heap, action, gas)?.to_payload(),
+                asc_new(heap, action, gas).await?.to_payload(),
             ),
             codec::action::Action::Transfer(action) => (
                 AscActionKind::Transfer,
-                asc_new(heap, action, gas)?.to_payload(),
+                asc_new(heap, action, gas).await?.to_payload(),
             ),
             codec::action::Action::Stake(action) => (
                 AscActionKind::Stake,
-                asc_new(heap, action, gas)?.to_payload(),
+                asc_new(heap, action, gas).await?.to_payload(),
             ),
             codec::action::Action::AddKey(action) => (
                 AscActionKind::AddKey,
-                asc_new(heap, action, gas)?.to_payload(),
+                asc_new(heap, action, gas).await?.to_payload(),
             ),
             codec::action::Action::DeleteKey(action) => (
                 AscActionKind::DeleteKey,
-                asc_new(heap, action, gas)?.to_payload(),
+                asc_new(heap, action, gas).await?.to_payload(),
             ),
             codec::action::Action::DeleteAccount(action) => (
                 AscActionKind::DeleteAccount,
-                asc_new(heap, action, gas)?.to_payload(),
+                asc_new(heap, action, gas).await?.to_payload(),
             ),
         };
 
@@ -195,20 +210,24 @@ impl ToAscObj<AscActionEnum> for codec::Action {
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscActionEnumArray> for Vec<codec::Action> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscActionEnumArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscActionEnumArray(Array::new(&content, heap, gas)?))
+        let mut content = Vec::new();
+        for x in self {
+            content.push(asc_new(heap, x, gas).await?);
+        }
+        Ok(AscActionEnumArray(Array::new(&content, heap, gas).await?))
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscCreateAccountAction> for codec::CreateAccountAction {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         _heap: &mut H,
         _gas: &GasCounter,
@@ -217,88 +236,95 @@ impl ToAscObj<AscCreateAccountAction> for codec::CreateAccountAction {
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscDeployContractAction> for codec::DeployContractAction {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscDeployContractAction, HostExportError> {
         Ok(AscDeployContractAction {
-            code: asc_new(heap, self.code.as_slice(), gas)?,
+            code: asc_new(heap, self.code.as_slice(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscFunctionCallAction> for codec::FunctionCallAction {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscFunctionCallAction, HostExportError> {
         Ok(AscFunctionCallAction {
-            method_name: asc_new(heap, &self.method_name, gas)?,
-            args: asc_new(heap, self.args.as_slice(), gas)?,
+            method_name: asc_new(heap, &self.method_name, gas).await?,
+            args: asc_new(heap, self.args.as_slice(), gas).await?,
             gas: self.gas,
-            deposit: asc_new(heap, self.deposit.as_ref().unwrap(), gas)?,
+            deposit: asc_new(heap, self.deposit.as_ref().unwrap(), gas).await?,
             _padding: 0,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscTransferAction> for codec::TransferAction {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscTransferAction, HostExportError> {
         Ok(AscTransferAction {
-            deposit: asc_new(heap, self.deposit.as_ref().unwrap(), gas)?,
+            deposit: asc_new(heap, self.deposit.as_ref().unwrap(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscStakeAction> for codec::StakeAction {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscStakeAction, HostExportError> {
         Ok(AscStakeAction {
-            stake: asc_new(heap, self.stake.as_ref().unwrap(), gas)?,
-            public_key: asc_new(heap, self.public_key.as_ref().unwrap(), gas)?,
+            stake: asc_new(heap, self.stake.as_ref().unwrap(), gas).await?,
+            public_key: asc_new(heap, self.public_key.as_ref().unwrap(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscAddKeyAction> for codec::AddKeyAction {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscAddKeyAction, HostExportError> {
         Ok(AscAddKeyAction {
-            public_key: asc_new(heap, self.public_key.as_ref().unwrap(), gas)?,
-            access_key: asc_new(heap, self.access_key.as_ref().unwrap(), gas)?,
+            public_key: asc_new(heap, self.public_key.as_ref().unwrap(), gas).await?,
+            access_key: asc_new(heap, self.access_key.as_ref().unwrap(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscAccessKey> for codec::AccessKey {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscAccessKey, HostExportError> {
         Ok(AscAccessKey {
             nonce: self.nonce,
-            permission: asc_new(heap, self.permission.as_ref().unwrap(), gas)?,
+            permission: asc_new(heap, self.permission.as_ref().unwrap(), gas).await?,
             _padding: 0,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscAccessKeyPermissionEnum> for codec::AccessKeyPermission {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -306,11 +332,11 @@ impl ToAscObj<AscAccessKeyPermissionEnum> for codec::AccessKeyPermission {
         let (kind, payload) = match self.permission.as_ref().unwrap() {
             codec::access_key_permission::Permission::FunctionCall(permission) => (
                 AscAccessKeyPermissionKind::FunctionCall,
-                asc_new(heap, permission, gas)?.to_payload(),
+                asc_new(heap, permission, gas).await?.to_payload(),
             ),
             codec::access_key_permission::Permission::FullAccess(permission) => (
                 AscAccessKeyPermissionKind::FullAccess,
-                asc_new(heap, permission, gas)?.to_payload(),
+                asc_new(heap, permission, gas).await?.to_payload(),
             ),
         };
 
@@ -322,8 +348,9 @@ impl ToAscObj<AscAccessKeyPermissionEnum> for codec::AccessKeyPermission {
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscFunctionCallPermission> for codec::FunctionCallPermission {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -331,17 +358,18 @@ impl ToAscObj<AscFunctionCallPermission> for codec::FunctionCallPermission {
         Ok(AscFunctionCallPermission {
             // The `allowance` field is one of the few fields that can actually be None for real
             allowance: match self.allowance.as_ref() {
-                Some(allowance) => asc_new(heap, allowance, gas)?,
+                Some(allowance) => asc_new(heap, allowance, gas).await?,
                 None => AscPtr::null(),
             },
-            receiver_id: asc_new(heap, &self.receiver_id, gas)?,
-            method_names: asc_new(heap, &self.method_names, gas)?,
+            receiver_id: asc_new(heap, &self.receiver_id, gas).await?,
+            method_names: asc_new(heap, &self.method_names, gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscFullAccessPermission> for codec::FullAccessPermission {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         _heap: &mut H,
         _gas: &GasCounter,
@@ -350,57 +378,64 @@ impl ToAscObj<AscFullAccessPermission> for codec::FullAccessPermission {
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscDeleteKeyAction> for codec::DeleteKeyAction {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscDeleteKeyAction, HostExportError> {
         Ok(AscDeleteKeyAction {
-            public_key: asc_new(heap, self.public_key.as_ref().unwrap(), gas)?,
+            public_key: asc_new(heap, self.public_key.as_ref().unwrap(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscDeleteAccountAction> for codec::DeleteAccountAction {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscDeleteAccountAction, HostExportError> {
         Ok(AscDeleteAccountAction {
-            beneficiary_id: asc_new(heap, &self.beneficiary_id, gas)?,
+            beneficiary_id: asc_new(heap, &self.beneficiary_id, gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscDataReceiver> for codec::DataReceiver {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscDataReceiver, HostExportError> {
         Ok(AscDataReceiver {
-            data_id: asc_new(heap, self.data_id.as_ref().unwrap(), gas)?,
-            receiver_id: asc_new(heap, &self.receiver_id, gas)?,
+            data_id: asc_new(heap, self.data_id.as_ref().unwrap(), gas).await?,
+            receiver_id: asc_new(heap, &self.receiver_id, gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscDataReceiverArray> for Vec<codec::DataReceiver> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscDataReceiverArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscDataReceiverArray(Array::new(&content, heap, gas)?))
+        let mut content = Vec::new();
+        for x in self {
+            content.push(asc_new(heap, x, gas).await?);
+        }
+        Ok(AscDataReceiverArray(Array::new(&content, heap, gas).await?))
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscExecutionOutcome> for codec::ExecutionOutcomeWithId {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -408,21 +443,22 @@ impl ToAscObj<AscExecutionOutcome> for codec::ExecutionOutcomeWithId {
         let outcome = self.outcome.as_ref().unwrap();
 
         Ok(AscExecutionOutcome {
-            proof: asc_new(heap, &self.proof.as_ref().unwrap().path, gas)?,
-            block_hash: asc_new(heap, self.block_hash.as_ref().unwrap(), gas)?,
-            id: asc_new(heap, self.id.as_ref().unwrap(), gas)?,
-            logs: asc_new(heap, &outcome.logs, gas)?,
-            receipt_ids: asc_new(heap, &outcome.receipt_ids, gas)?,
+            proof: asc_new(heap, &self.proof.as_ref().unwrap().path, gas).await?,
+            block_hash: asc_new(heap, self.block_hash.as_ref().unwrap(), gas).await?,
+            id: asc_new(heap, self.id.as_ref().unwrap(), gas).await?,
+            logs: asc_new(heap, &outcome.logs, gas).await?,
+            receipt_ids: asc_new(heap, &outcome.receipt_ids, gas).await?,
             gas_burnt: outcome.gas_burnt,
-            tokens_burnt: asc_new(heap, outcome.tokens_burnt.as_ref().unwrap(), gas)?,
-            executor_id: asc_new(heap, &outcome.executor_id, gas)?,
-            status: asc_new(heap, outcome.status.as_ref().unwrap(), gas)?,
+            tokens_burnt: asc_new(heap, outcome.tokens_burnt.as_ref().unwrap(), gas).await?,
+            executor_id: asc_new(heap, &outcome.executor_id, gas).await?,
+            status: asc_new(heap, outcome.status.as_ref().unwrap(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscSuccessStatusEnum> for codec::execution_outcome::Status {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -433,12 +469,14 @@ impl ToAscObj<AscSuccessStatusEnum> for codec::execution_outcome::Status {
 
                 (
                     AscSuccessStatusKind::Value,
-                    asc_new(heap, bytes.as_slice(), gas)?.to_payload(),
+                    asc_new(heap, bytes.as_slice(), gas).await?.to_payload(),
                 )
             }
             codec::execution_outcome::Status::SuccessReceiptId(receipt_id) => (
                 AscSuccessStatusKind::ReceiptId,
-                asc_new(heap, receipt_id.id.as_ref().unwrap(), gas)?.to_payload(),
+                asc_new(heap, receipt_id.id.as_ref().unwrap(), gas)
+                    .await?
+                    .to_payload(),
             ),
             codec::execution_outcome::Status::Failure(_) => {
                 return Err(DeterministicHostError::from(anyhow!(
@@ -462,14 +500,15 @@ impl ToAscObj<AscSuccessStatusEnum> for codec::execution_outcome::Status {
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscMerklePathItem> for codec::MerklePathItem {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscMerklePathItem, HostExportError> {
         Ok(AscMerklePathItem {
-            hash: asc_new(heap, self.hash.as_ref().unwrap(), gas)?,
+            hash: asc_new(heap, self.hash.as_ref().unwrap(), gas).await?,
             direction: match self.direction {
                 0 => AscDirection::Left,
                 1 => AscDirection::Right,
@@ -478,27 +517,33 @@ impl ToAscObj<AscMerklePathItem> for codec::MerklePathItem {
                         "Invalid direction value {}",
                         x
                     ))
-                    .into())
+                    .into());
                 }
             },
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscMerklePathItemArray> for Vec<codec::MerklePathItem> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscMerklePathItemArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscMerklePathItemArray(Array::new(&content, heap, gas)?))
+        let mut content = Vec::new();
+        for x in self {
+            content.push(asc_new(heap, x, gas).await?);
+        }
+        Ok(AscMerklePathItemArray(
+            Array::new(&content, heap, gas).await?,
+        ))
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscSignature> for codec::Signature {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -512,28 +557,32 @@ impl ToAscObj<AscSignature> for codec::Signature {
                         "Invalid signature type {}",
                         value,
                     ))
-                    .into())
+                    .into());
                 }
             },
-            bytes: asc_new(heap, self.bytes.as_slice(), gas)?,
+            bytes: asc_new(heap, self.bytes.as_slice(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscSignatureArray> for Vec<codec::Signature> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscSignatureArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscSignatureArray(Array::new(&content, heap, gas)?))
+        let mut content = Vec::new();
+        for x in self {
+            content.push(asc_new(heap, x, gas).await?);
+        }
+        Ok(AscSignatureArray(Array::new(&content, heap, gas).await?))
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscPublicKey> for codec::PublicKey {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -547,89 +596,106 @@ impl ToAscObj<AscPublicKey> for codec::PublicKey {
                         "Invalid public key type {}",
                         value,
                     ))
-                    .into())
+                    .into());
                 }
             },
-            bytes: asc_new(heap, self.bytes.as_slice(), gas)?,
+            bytes: asc_new(heap, self.bytes.as_slice(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscValidatorStake> for codec::ValidatorStake {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscValidatorStake, HostExportError> {
         Ok(AscValidatorStake {
-            account_id: asc_new(heap, &self.account_id, gas)?,
-            public_key: asc_new(heap, self.public_key.as_ref().unwrap(), gas)?,
-            stake: asc_new(heap, self.stake.as_ref().unwrap(), gas)?,
+            account_id: asc_new(heap, &self.account_id, gas).await?,
+            public_key: asc_new(heap, self.public_key.as_ref().unwrap(), gas).await?,
+            stake: asc_new(heap, self.stake.as_ref().unwrap(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscValidatorStakeArray> for Vec<codec::ValidatorStake> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscValidatorStakeArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscValidatorStakeArray(Array::new(&content, heap, gas)?))
+        let mut content = Vec::new();
+        for x in self {
+            content.push(asc_new(heap, x, gas).await?);
+        }
+        Ok(AscValidatorStakeArray(
+            Array::new(&content, heap, gas).await?,
+        ))
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscSlashedValidator> for codec::SlashedValidator {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscSlashedValidator, HostExportError> {
         Ok(AscSlashedValidator {
-            account_id: asc_new(heap, &self.account_id, gas)?,
+            account_id: asc_new(heap, &self.account_id, gas).await?,
             is_double_sign: self.is_double_sign,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscSlashedValidatorArray> for Vec<codec::SlashedValidator> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscSlashedValidatorArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscSlashedValidatorArray(Array::new(&content, heap, gas)?))
+        let mut content = Vec::new();
+        for x in self {
+            content.push(asc_new(heap, x, gas).await?);
+        }
+        Ok(AscSlashedValidatorArray(
+            Array::new(&content, heap, gas).await?,
+        ))
     }
 }
 
+#[async_trait]
 impl ToAscObj<Uint8Array> for codec::CryptoHash {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscCryptoHash, HostExportError> {
-        self.bytes.to_asc_obj(heap, gas)
+        self.bytes.to_asc_obj(heap, gas).await
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscCryptoHashArray> for Vec<codec::CryptoHash> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscCryptoHashArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscCryptoHashArray(Array::new(&content, heap, gas)?))
+        let mut content = Vec::new();
+        for x in self {
+            content.push(asc_new(heap, x, gas).await?);
+        }
+        Ok(AscCryptoHashArray(Array::new(&content, heap, gas).await?))
     }
 }
 
+#[async_trait]
 impl ToAscObj<Uint8Array> for codec::BigInt {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -637,6 +703,6 @@ impl ToAscObj<Uint8Array> for codec::BigInt {
         // Bytes are reversed to align with BigInt bytes endianess
         let reversed: Vec<u8> = self.bytes.iter().rev().copied().collect();
 
-        reversed.to_asc_obj(heap, gas)
+        reversed.to_asc_obj(heap, gas).await
     }
 }
diff --git a/chain/near/src/runtime/generated.rs b/chain/near/src/runtime/generated.rs
index 153eb8b5ab5..d8fe2937f43 100644
--- a/chain/near/src/runtime/generated.rs
+++ b/chain/near/src/runtime/generated.rs
@@ -227,20 +227,15 @@ impl AscIndexId for AscSignature {
 }
 
 #[repr(u32)]
-#[derive(AscType, Copy, Clone)]
+#[derive(AscType, Copy, Clone, Default)]
 pub(crate) enum AscAccessKeyPermissionKind {
+    #[default]
     FunctionCall,
     FullAccess,
 }
 
 impl AscValue for AscAccessKeyPermissionKind {}
 
-impl Default for AscAccessKeyPermissionKind {
-    fn default() -> Self {
-        Self::FunctionCall
-    }
-}
-
 #[repr(C)]
 #[derive(AscType)]
 pub(crate) struct AscFunctionCallPermission {
@@ -293,8 +288,9 @@ impl AscIndexId for AscDataReceiver {
 }
 
 #[repr(u32)]
-#[derive(AscType, Copy, Clone)]
+#[derive(AscType, Copy, Clone, Default)]
 pub(crate) enum AscActionKind {
+    #[default]
     CreateAccount,
     DeployContract,
     FunctionCall,
@@ -307,12 +303,6 @@ pub(crate) enum AscActionKind {
 
 impl AscValue for AscActionKind {}
 
-impl Default for AscActionKind {
-    fn default() -> Self {
-        Self::CreateAccount
-    }
-}
-
 #[repr(C)]
 #[derive(AscType)]
 pub(crate) struct AscCreateAccountAction {}
@@ -424,20 +414,15 @@ impl AscIndexId for AscActionReceipt {
 }
 
 #[repr(u32)]
-#[derive(AscType, Copy, Clone)]
+#[derive(AscType, Copy, Clone, Default)]
 pub(crate) enum AscSuccessStatusKind {
+    #[default]
     Value,
     ReceiptId,
 }
 
 impl AscValue for AscSuccessStatusKind {}
 
-impl Default for AscSuccessStatusKind {
-    fn default() -> Self {
-        Self::Value
-    }
-}
-
 pub struct AscSuccessStatusEnum(pub(crate) AscEnum<AscSuccessStatusKind>);
 
 impl AscType for AscSuccessStatusEnum {
@@ -458,20 +443,15 @@ impl AscIndexId for AscSuccessStatusEnum {
 }
 
 #[repr(u32)]
-#[derive(AscType, Copy, Clone)]
+#[derive(AscType, Copy, Clone, Default)]
 pub(crate) enum AscDirection {
+    #[default]
     Left,
     Right,
 }
 
 impl AscValue for AscDirection {}
 
-impl Default for AscDirection {
-    fn default() -> Self {
-        Self::Left
-    }
-}
-
 #[repr(C)]
 #[derive(AscType)]
 pub(crate) struct AscMerklePathItem {
diff --git a/chain/near/src/trigger.rs b/chain/near/src/trigger.rs
index 22cd8b1eb96..bf9794d2b20 100644
--- a/chain/near/src/trigger.rs
+++ b/chain/near/src/trigger.rs
@@ -1,12 +1,13 @@
+use async_trait::async_trait;
 use graph::blockchain::Block;
 use graph::blockchain::MappingTriggerTrait;
 use graph::blockchain::TriggerData;
-use graph::cheap_clone::CheapClone;
-use graph::prelude::hex;
-use graph::prelude::web3::types::H256;
+use graph::derive::CheapClone;
 use graph::prelude::BlockNumber;
+use graph::prelude::alloy::primitives::B256;
+use graph::prelude::hex;
 use graph::runtime::HostExportError;
-use graph::runtime::{asc_new, gas::GasCounter, AscHeap, AscPtr};
+use graph::runtime::{AscHeap, AscPtr, asc_new, gas::GasCounter};
 use graph_runtime_wasm::module::ToAscPtr;
 use std::{cmp::Ordering, sync::Arc};
 
@@ -15,6 +16,7 @@ use crate::codec;
 // Logging the block is too verbose, so this strips the block from the trigger for Debug.
 impl std::fmt::Debug for NearTrigger {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        #[allow(unused)]
         #[derive(Debug)]
         pub enum MappingTriggerWithoutBlock<'a> {
             Block,
@@ -37,34 +39,26 @@ impl std::fmt::Debug for NearTrigger {
     }
 }
 
+#[async_trait]
 impl ToAscPtr for NearTrigger {
-    fn to_asc_ptr<H: AscHeap>(
+    async fn to_asc_ptr<H: AscHeap>(
         self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscPtr<()>, HostExportError> {
         Ok(match self {
-            NearTrigger::Block(block) => asc_new(heap, block.as_ref(), gas)?.erase(),
-            NearTrigger::Receipt(receipt) => asc_new(heap, receipt.as_ref(), gas)?.erase(),
+            NearTrigger::Block(block) => asc_new(heap, block.as_ref(), gas).await?.erase(),
+            NearTrigger::Receipt(receipt) => asc_new(heap, receipt.as_ref(), gas).await?.erase(),
         })
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 pub enum NearTrigger {
     Block(Arc<codec::Block>),
     Receipt(Arc<ReceiptWithOutcome>),
 }
 
-impl CheapClone for NearTrigger {
-    fn cheap_clone(&self) -> NearTrigger {
-        match self {
-            NearTrigger::Block(block) => NearTrigger::Block(block.cheap_clone()),
-            NearTrigger::Receipt(receipt) => NearTrigger::Receipt(receipt.cheap_clone()),
-        }
-    }
-}
-
 impl PartialEq for NearTrigger {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
@@ -86,10 +80,10 @@ impl NearTrigger {
         }
     }
 
-    pub fn block_hash(&self) -> H256 {
+    pub fn block_hash(&self) -> B256 {
         match self {
-            NearTrigger::Block(block) => block.ptr().hash_as_h256(),
-            NearTrigger::Receipt(receipt) => receipt.block.ptr().hash_as_h256(),
+            NearTrigger::Block(block) => block.ptr().hash.as_b256(),
+            NearTrigger::Receipt(receipt) => receipt.block.ptr().hash.as_b256(),
         }
     }
 
@@ -158,30 +152,30 @@ pub struct ReceiptWithOutcome {
 
 #[cfg(test)]
 mod tests {
-    use std::convert::TryFrom;
-
     use super::*;
 
     use graph::{
         anyhow::anyhow,
         components::metrics::gas::GasMetrics,
         data::subgraph::API_VERSION_0_0_5,
-        prelude::{hex, BigInt},
-        runtime::{gas::GasCounter, DeterministicHostError, HostExportError},
+        prelude::{BigInt, hex},
+        runtime::{DeterministicHostError, HostExportError, gas::GasCounter},
         util::mem::init_slice,
     };
 
-    #[test]
-    fn block_trigger_to_asc_ptr() {
+    #[graph::test]
+    async fn block_trigger_to_asc_ptr() {
         let mut heap = BytesHeap::new(API_VERSION_0_0_5);
         let trigger = NearTrigger::Block(Arc::new(block()));
 
-        let result = trigger.to_asc_ptr(&mut heap, &GasCounter::new(GasMetrics::mock()));
+        let result = trigger
+            .to_asc_ptr(&mut heap, &GasCounter::new(GasMetrics::mock()))
+            .await;
         assert!(result.is_ok());
     }
 
-    #[test]
-    fn receipt_trigger_to_asc_ptr() {
+    #[graph::test]
+    async fn receipt_trigger_to_asc_ptr() {
         let mut heap = BytesHeap::new(API_VERSION_0_0_5);
         let trigger = NearTrigger::Receipt(Arc::new(ReceiptWithOutcome {
             block: Arc::new(block()),
@@ -189,7 +183,9 @@ mod tests {
             receipt: receipt().unwrap(),
         }));
 
-        let result = trigger.to_asc_ptr(&mut heap, &GasCounter::new(GasMetrics::mock()));
+        let result = trigger
+            .to_asc_ptr(&mut heap, &GasCounter::new(GasMetrics::mock()))
+            .await;
         assert!(result.is_ok());
     }
 
@@ -409,8 +405,7 @@ mod tests {
     }
 
     fn big_int(input: u64) -> Option<codec::BigInt> {
-        let value =
-            BigInt::try_from(input).unwrap_or_else(|_| panic!("Invalid BigInt value {}", input));
+        let value = BigInt::from(input);
         let bytes = value.to_signed_bytes_le();
 
         Some(codec::BigInt { bytes })
@@ -452,8 +447,9 @@ mod tests {
         }
     }
 
+    #[async_trait]
     impl AscHeap for BytesHeap {
-        fn raw_new(
+        async fn raw_new(
             &mut self,
             bytes: &[u8],
             _gas: &GasCounter,
@@ -505,11 +501,11 @@ mod tests {
             Ok(init_slice(src, buffer))
         }
 
-        fn api_version(&self) -> graph::semver::Version {
-            self.api_version.clone()
+        fn api_version(&self) -> &graph::semver::Version {
+            &self.api_version
         }
 
-        fn asc_type_id(
+        async fn asc_type_id(
             &mut self,
             type_id_index: graph::runtime::IndexForAscTypeId,
         ) -> Result<u32, HostExportError> {
diff --git a/chain/starknet/Cargo.toml b/chain/starknet/Cargo.toml
deleted file mode 100644
index 3a8ebeac8c9..00000000000
--- a/chain/starknet/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-name = "graph-chain-starknet"
-version.workspace = true
-edition.workspace = true
-
-[build-dependencies]
-tonic-build = { workspace = true }
-
-[dependencies]
-graph = { path = "../../graph" }
-hex = { version = "0.4.3", features = ["serde"] }
-prost = { workspace = true }
-prost-types = { workspace = true }
-serde = "1.0"
-sha3 = "0.10.8"
-
-graph-runtime-wasm = { path = "../../runtime/wasm" }
-graph-runtime-derive = { path = "../../runtime/derive" }
diff --git a/chain/starknet/build.rs b/chain/starknet/build.rs
deleted file mode 100644
index 8a67809dfca..00000000000
--- a/chain/starknet/build.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-fn main() {
-    println!("cargo:rerun-if-changed=proto");
-    tonic_build::configure()
-        .out_dir("src/protobuf")
-        .compile(&["proto/starknet.proto"], &["proto"])
-        .expect("Failed to compile Firehose StarkNet proto(s)");
-}
diff --git a/chain/starknet/proto/starknet.proto b/chain/starknet/proto/starknet.proto
deleted file mode 100644
index 073b8c2c569..00000000000
--- a/chain/starknet/proto/starknet.proto
+++ /dev/null
@@ -1,37 +0,0 @@
-syntax = "proto3";
-
-package zklend.starknet.type.v1;
-
-option go_package = "github.com/starknet-graph/firehose-starknet/types/pb/zklend/starknet/type/v1;pbacme";
-
-// This file only contains the bare minimum types for the POC. It's far from a complete
-// representation of a StarkNet network's history as required by the Firehose protocol. As a result,
-// any future changes to this schema would require a full re-sync of the StarkNet node.
-
-message Block {
-  uint64 height = 1;
-  bytes hash = 2;
-  bytes prevHash = 3;
-  uint64 timestamp = 4;
-  repeated Transaction transactions = 5;
-}
-
-message Transaction {
-  TransactionType type = 1;
-  bytes hash = 2;
-  repeated Event events = 3;
-}
-
-enum TransactionType {
-  DEPLOY = 0;
-  INVOKE_FUNCTION = 1;
-  DECLARE = 2;
-  L1_HANDLER = 3;
-  DEPLOY_ACCOUNT = 4;
-}
-
-message Event {
-  bytes fromAddr = 1;
-  repeated bytes keys = 2;
-  repeated bytes data = 3;
-}
diff --git a/chain/starknet/src/adapter.rs b/chain/starknet/src/adapter.rs
deleted file mode 100644
index e04df8e979c..00000000000
--- a/chain/starknet/src/adapter.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use graph::blockchain::{EmptyNodeCapabilities, TriggerFilter as TriggerFilterTrait};
-
-use crate::{
-    data_source::{DataSource, DataSourceTemplate},
-    Chain,
-};
-
-#[derive(Default, Clone)]
-pub struct TriggerFilter;
-
-impl TriggerFilterTrait<Chain> for TriggerFilter {
-    #[allow(unused)]
-    fn extend_with_template(&mut self, data_source: impl Iterator<Item = DataSourceTemplate>) {
-        todo!()
-    }
-
-    #[allow(unused)]
-    fn extend<'a>(&mut self, data_sources: impl Iterator<Item = &'a DataSource> + Clone) {}
-
-    fn node_capabilities(&self) -> EmptyNodeCapabilities<Chain> {
-        todo!()
-    }
-
-    fn to_firehose_filter(self) -> Vec<prost_types::Any> {
-        todo!()
-    }
-}
diff --git a/chain/starknet/src/chain.rs b/chain/starknet/src/chain.rs
deleted file mode 100644
index 060a502d80d..00000000000
--- a/chain/starknet/src/chain.rs
+++ /dev/null
@@ -1,499 +0,0 @@
-use graph::{
-    anyhow::Result,
-    blockchain::{
-        block_stream::{
-            BlockStream, BlockStreamBuilder, BlockStreamEvent, BlockWithTriggers, FirehoseCursor,
-            FirehoseError, FirehoseMapper as FirehoseMapperTrait,
-            TriggersAdapter as TriggersAdapterTrait,
-        },
-        client::ChainClient,
-        firehose_block_ingestor::FirehoseBlockIngestor,
-        firehose_block_stream::FirehoseBlockStream,
-        BasicBlockchainBuilder, Block, BlockIngestor, BlockPtr, Blockchain, BlockchainBuilder,
-        BlockchainKind, EmptyNodeCapabilities, IngestorError, NoopRuntimeAdapter,
-        RuntimeAdapter as RuntimeAdapterTrait,
-    },
-    cheap_clone::CheapClone,
-    components::store::{DeploymentCursorTracker, DeploymentLocator},
-    data::subgraph::UnifiedMappingApiVersion,
-    env::EnvVars,
-    firehose::{self, FirehoseEndpoint, ForkStep},
-    prelude::{
-        async_trait, BlockHash, BlockNumber, ChainStore, Error, Logger, LoggerFactory,
-        MetricsRegistry, TryFutureExt,
-    },
-    schema::InputSchema,
-    slog::o,
-};
-use prost::Message;
-use std::sync::Arc;
-
-use crate::{
-    adapter::TriggerFilter,
-    codec,
-    data_source::{
-        DataSource, DataSourceTemplate, UnresolvedDataSource, UnresolvedDataSourceTemplate,
-    },
-    trigger::{StarknetBlockTrigger, StarknetEventTrigger, StarknetTrigger},
-};
-
-pub struct Chain {
-    logger_factory: LoggerFactory,
-    name: String,
-    client: Arc<ChainClient<Self>>,
-    chain_store: Arc<dyn ChainStore>,
-    metrics_registry: Arc<MetricsRegistry>,
-    block_stream_builder: Arc<dyn BlockStreamBuilder<Self>>,
-}
-
-pub struct StarknetStreamBuilder;
-
-pub struct FirehoseMapper {
-    adapter: Arc<dyn TriggersAdapterTrait<Chain>>,
-    filter: Arc<TriggerFilter>,
-}
-
-pub struct TriggersAdapter;
-
-impl BlockchainBuilder<Chain> for BasicBlockchainBuilder {
-    fn build(self, _config: &Arc<EnvVars>) -> Chain {
-        Chain {
-            logger_factory: self.logger_factory,
-            name: self.name,
-            chain_store: self.chain_store,
-            client: Arc::new(ChainClient::new_firehose(self.firehose_endpoints)),
-            metrics_registry: self.metrics_registry,
-            block_stream_builder: Arc::new(StarknetStreamBuilder {}),
-        }
-    }
-}
-
-impl std::fmt::Debug for Chain {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "chain: starknet")
-    }
-}
-
-#[async_trait]
-impl Blockchain for Chain {
-    const KIND: BlockchainKind = BlockchainKind::Starknet;
-
-    type Client = ();
-    type Block = codec::Block;
-    type DataSource = DataSource;
-    type UnresolvedDataSource = UnresolvedDataSource;
-
-    type DataSourceTemplate = DataSourceTemplate;
-    type UnresolvedDataSourceTemplate = UnresolvedDataSourceTemplate;
-
-    type TriggerData = crate::trigger::StarknetTrigger;
-
-    type MappingTrigger = crate::trigger::StarknetTrigger;
-
-    type TriggerFilter = crate::adapter::TriggerFilter;
-
-    type NodeCapabilities = EmptyNodeCapabilities<Self>;
-
-    fn triggers_adapter(
-        &self,
-        _log: &DeploymentLocator,
-        _capabilities: &Self::NodeCapabilities,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Arc<dyn TriggersAdapterTrait<Self>>, Error> {
-        Ok(Arc::new(TriggersAdapter))
-    }
-
-    async fn new_block_stream(
-        &self,
-        deployment: DeploymentLocator,
-        store: impl DeploymentCursorTracker,
-        start_blocks: Vec<BlockNumber>,
-        filter: Arc<Self::TriggerFilter>,
-        unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        self.block_stream_builder
-            .build_firehose(
-                self,
-                deployment,
-                store.firehose_cursor(),
-                start_blocks,
-                store.block_ptr(),
-                filter,
-                unified_api_version,
-            )
-            .await
-    }
-
-    fn is_refetch_block_required(&self) -> bool {
-        false
-    }
-
-    async fn refetch_firehose_block(
-        &self,
-        _logger: &Logger,
-        _cursor: FirehoseCursor,
-    ) -> Result<codec::Block, Error> {
-        unimplemented!("This chain does not support Dynamic Data Sources. is_refetch_block_required always returns false, this shouldn't be called.")
-    }
-
-    fn chain_store(&self) -> Arc<dyn ChainStore> {
-        self.chain_store.clone()
-    }
-
-    async fn block_pointer_from_number(
-        &self,
-        logger: &Logger,
-        number: BlockNumber,
-    ) -> Result<BlockPtr, IngestorError> {
-        let firehose_endpoint = self.client.firehose_endpoint()?;
-
-        firehose_endpoint
-            .block_ptr_for_number::<codec::Block>(logger, number)
-            .map_err(Into::into)
-            .await
-    }
-
-    fn runtime_adapter(&self) -> Arc<dyn RuntimeAdapterTrait<Self>> {
-        Arc::new(NoopRuntimeAdapter::default())
-    }
-
-    fn chain_client(&self) -> Arc<ChainClient<Self>> {
-        self.client.clone()
-    }
-
-    fn block_ingestor(&self) -> Result<Box<dyn BlockIngestor>> {
-        let ingestor = FirehoseBlockIngestor::<crate::Block, Self>::new(
-            self.chain_store.cheap_clone(),
-            self.chain_client(),
-            self.logger_factory
-                .component_logger("StarknetFirehoseBlockIngestor", None),
-            self.name.clone(),
-        );
-        Ok(Box::new(ingestor))
-    }
-}
-
-#[async_trait]
-impl BlockStreamBuilder<Chain> for StarknetStreamBuilder {
-    async fn build_substreams(
-        &self,
-        _chain: &Chain,
-        _schema: InputSchema,
-        _deployment: DeploymentLocator,
-        _block_cursor: FirehoseCursor,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<<Chain as Blockchain>::TriggerFilter>,
-    ) -> Result<Box<dyn BlockStream<Chain>>> {
-        unimplemented!()
-    }
-
-    async fn build_firehose(
-        &self,
-        chain: &Chain,
-        deployment: DeploymentLocator,
-        block_cursor: FirehoseCursor,
-        start_blocks: Vec<BlockNumber>,
-        subgraph_current_block: Option<BlockPtr>,
-        filter: Arc<TriggerFilter>,
-        unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Chain>>> {
-        let adapter = chain
-            .triggers_adapter(
-                &deployment,
-                &EmptyNodeCapabilities::default(),
-                unified_api_version,
-            )
-            .unwrap_or_else(|_| panic!("no adapter for network {}", chain.name));
-
-        let logger = chain
-            .logger_factory
-            .subgraph_logger(&deployment)
-            .new(o!("component" => "FirehoseBlockStream"));
-
-        let firehose_mapper = Arc::new(FirehoseMapper { adapter, filter });
-
-        Ok(Box::new(FirehoseBlockStream::new(
-            deployment.hash,
-            chain.chain_client(),
-            subgraph_current_block,
-            block_cursor,
-            firehose_mapper,
-            start_blocks,
-            logger,
-            chain.metrics_registry.clone(),
-        )))
-    }
-
-    async fn build_polling(
-        &self,
-        _chain: &Chain,
-        _deployment: DeploymentLocator,
-        _start_blocks: Vec<BlockNumber>,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<TriggerFilter>,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Chain>>> {
-        panic!("StarkNet does not support polling block stream")
-    }
-}
-
-#[async_trait]
-impl FirehoseMapperTrait<Chain> for FirehoseMapper {
-    fn trigger_filter(&self) -> &TriggerFilter {
-        self.filter.as_ref()
-    }
-
-    async fn to_block_stream_event(
-        &self,
-        logger: &Logger,
-        response: &firehose::Response,
-    ) -> Result<BlockStreamEvent<Chain>, FirehoseError> {
-        let step = ForkStep::from_i32(response.step).unwrap_or_else(|| {
-            panic!(
-                "unknown step i32 value {}, maybe you forgot update & re-regenerate the protobuf definitions?",
-                response.step
-            )
-        });
-
-        let any_block = response
-            .block
-            .as_ref()
-            .expect("block payload information should always be present");
-
-        // Right now, this is done in all cases but in reality, with how the BlockStreamEvent::Revert
-        // is defined right now, only block hash and block number is necessary. However, this information
-        // is not part of the actual bstream::BlockResponseV2 payload. As such, we need to decode the full
-        // block which is useless.
-        //
-        // Check about adding basic information about the block in the bstream::BlockResponseV2 or maybe
-        // define a slimmed down stuct that would decode only a few fields and ignore all the rest.
-        let block = codec::Block::decode(any_block.value.as_ref())?;
-
-        use ForkStep::*;
-        match step {
-            StepNew => Ok(BlockStreamEvent::ProcessBlock(
-                self.adapter
-                    .triggers_in_block(logger, block, &self.filter)
-                    .await?,
-                FirehoseCursor::from(response.cursor.clone()),
-            )),
-
-            StepUndo => {
-                let parent_ptr = block
-                    .parent_ptr()
-                    .expect("Genesis block should never be reverted");
-
-                Ok(BlockStreamEvent::Revert(
-                    parent_ptr,
-                    FirehoseCursor::from(response.cursor.clone()),
-                ))
-            }
-
-            StepFinal => {
-                panic!("irreversible step is not handled and should not be requested in the Firehose request")
-            }
-
-            StepUnset => {
-                panic!("unknown step should not happen in the Firehose response")
-            }
-        }
-    }
-
-    /// Returns the [BlockPtr] value for this given block number. This is the block pointer
-    /// of the longuest according to Firehose view of the blockchain state.
-    ///
-    /// This is a thin wrapper around [FirehoseEndpoint#block_ptr_for_number] to make
-    /// it chain agnostic and callable from chain agnostic [FirehoseBlockStream].
-    async fn block_ptr_for_number(
-        &self,
-        logger: &Logger,
-        endpoint: &Arc<FirehoseEndpoint>,
-        number: BlockNumber,
-    ) -> Result<BlockPtr, Error> {
-        endpoint
-            .block_ptr_for_number::<codec::Block>(logger, number)
-            .await
-    }
-
-    /// Returns the closest final block ptr to the block ptr received.
-    /// On probablitics chain like Ethereum, final is determined by
-    /// the confirmations threshold configured for the Firehose stack (currently
-    /// hard-coded to 200).
-    ///
-    /// On some other chain like NEAR, the actual final block number is determined
-    /// from the block itself since it contains information about which block number
-    /// is final against the current block.
-    ///
-    /// To take an example, assuming we are on Ethereum, the final block pointer
-    /// for block #10212 would be the determined final block #10012 (10212 - 200 = 10012).
-    async fn final_block_ptr_for(
-        &self,
-        logger: &Logger,
-        endpoint: &Arc<FirehoseEndpoint>,
-        block: &codec::Block,
-    ) -> Result<BlockPtr, Error> {
-        // Firehose for Starknet has an hard-coded confirmations for finality sets to 100 block
-        // behind the current block. The magic value 100 here comes from this hard-coded Firehose
-        // value.
-        let final_block_number = match block.number() {
-            x if x >= 100 => x - 100,
-            _ => 0,
-        };
-
-        self.block_ptr_for_number(logger, endpoint, final_block_number)
-            .await
-    }
-}
-
-#[async_trait]
-impl TriggersAdapterTrait<Chain> for TriggersAdapter {
-    // Return the block that is `offset` blocks before the block pointed to
-    // by `ptr` from the local cache. An offset of 0 means the block itself,
-    // an offset of 1 means the block's parent etc. If the block is not in
-    // the local cache, return `None`
-    async fn ancestor_block(
-        &self,
-        _ptr: BlockPtr,
-        _offset: BlockNumber,
-    ) -> Result<Option<codec::Block>, Error> {
-        panic!("Should never be called since FirehoseBlockStream cannot resolve it")
-    }
-
-    // Returns a sequence of blocks in increasing order of block number.
-    // Each block will include all of its triggers that match the given `filter`.
-    // The sequence may omit blocks that contain no triggers,
-    // but all returned blocks must part of a same chain starting at `chain_base`.
-    // At least one block will be returned, even if it contains no triggers.
-    // `step_size` is the suggested number blocks to be scanned.
-    async fn scan_triggers(
-        &self,
-        _from: BlockNumber,
-        _to: BlockNumber,
-        _filter: &crate::adapter::TriggerFilter,
-    ) -> Result<Vec<BlockWithTriggers<Chain>>, Error> {
-        panic!("Should never be called since not used by FirehoseBlockStream")
-    }
-
-    #[allow(unused)]
-    async fn triggers_in_block(
-        &self,
-        logger: &Logger,
-        block: codec::Block,
-        filter: &crate::adapter::TriggerFilter,
-    ) -> Result<BlockWithTriggers<Chain>, Error> {
-        let shared_block = Arc::new(block.clone());
-
-        let mut triggers: Vec<_> = shared_block
-            .transactions
-            .iter()
-            .flat_map(|transaction| -> Vec<StarknetTrigger> {
-                let transaction = Arc::new(transaction.clone());
-                transaction
-                    .events
-                    .iter()
-                    .map(|event| {
-                        StarknetTrigger::Event(StarknetEventTrigger {
-                            event: Arc::new(event.clone()),
-                            block: shared_block.clone(),
-                            transaction: transaction.clone(),
-                        })
-                    })
-                    .collect()
-            })
-            .collect();
-
-        triggers.push(StarknetTrigger::Block(StarknetBlockTrigger {
-            block: shared_block,
-        }));
-
-        Ok(BlockWithTriggers::new(block, triggers, logger))
-    }
-
-    /// Return `true` if the block with the given hash and number is on the
-    /// main chain, i.e., the chain going back from the current chain head.
-    async fn is_on_main_chain(&self, _ptr: BlockPtr) -> Result<bool, Error> {
-        panic!("Should never be called since not used by FirehoseBlockStream")
-    }
-
-    /// Get pointer to parent of `block`. This is called when reverting `block`.
-    async fn parent_ptr(&self, block: &BlockPtr) -> Result<Option<BlockPtr>, Error> {
-        // Panics if `block` is genesis.
-        // But that's ok since this is only called when reverting `block`.
-        Ok(Some(BlockPtr {
-            hash: BlockHash::from(vec![0xff; 32]),
-            number: block.number.saturating_sub(1),
-        }))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use graph::blockchain::DataSource as _;
-
-    use crate::{
-        data_source::{
-            DataSource, Mapping, MappingBlockHandler, MappingEventHandler, STARKNET_KIND,
-        },
-        felt::Felt,
-    };
-
-    #[test]
-    fn validate_no_handler() {
-        let ds = new_data_source(None);
-
-        let errs = ds.validate();
-        assert_eq!(errs.len(), 1, "{:?}", ds);
-        assert_eq!(
-            errs[0].to_string(),
-            "data source does not define any handler"
-        );
-    }
-
-    #[test]
-    fn validate_address_without_event_handler() {
-        let mut ds = new_data_source(Some([1u8; 32].into()));
-        ds.mapping.block_handler = Some(MappingBlockHandler {
-            handler: "asdf".into(),
-        });
-
-        let errs = ds.validate();
-        assert_eq!(errs.len(), 1, "{:?}", ds);
-        assert_eq!(
-            errs[0].to_string(),
-            "data source cannot have source address without event handlers"
-        );
-    }
-
-    #[test]
-    fn validate_no_address_with_event_handler() {
-        let mut ds = new_data_source(None);
-        ds.mapping.event_handlers.push(MappingEventHandler {
-            handler: "asdf".into(),
-            event_selector: [2u8; 32].into(),
-        });
-
-        let errs = ds.validate();
-        assert_eq!(errs.len(), 1, "{:?}", ds);
-        assert_eq!(errs[0].to_string(), "subgraph source address is required");
-    }
-
-    fn new_data_source(address: Option<Felt>) -> DataSource {
-        DataSource {
-            kind: STARKNET_KIND.to_string(),
-            network: "starknet-mainnet".into(),
-            name: "asd".to_string(),
-            source: crate::data_source::Source {
-                start_block: 10,
-                end_block: None,
-                address,
-            },
-            mapping: Mapping {
-                block_handler: None,
-                event_handlers: vec![],
-                runtime: Arc::new(vec![]),
-            },
-        }
-    }
-}
diff --git a/chain/starknet/src/codec.rs b/chain/starknet/src/codec.rs
deleted file mode 100644
index 4d029c8c01d..00000000000
--- a/chain/starknet/src/codec.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#[rustfmt::skip]
-#[path = "protobuf/zklend.starknet.r#type.v1.rs"]
-mod pbcodec;
-
-use graph::blockchain::{Block as BlockchainBlock, BlockHash, BlockPtr};
-
-pub use pbcodec::*;
-
-impl BlockchainBlock for Block {
-    fn number(&self) -> i32 {
-        self.height as i32
-    }
-
-    fn ptr(&self) -> BlockPtr {
-        BlockPtr {
-            hash: BlockHash(self.hash.clone().into_boxed_slice()),
-            number: self.height as i32,
-        }
-    }
-
-    fn parent_ptr(&self) -> Option<BlockPtr> {
-        if self.height == 0 {
-            None
-        } else {
-            Some(BlockPtr {
-                hash: BlockHash(self.prev_hash.clone().into_boxed_slice()),
-                number: (self.height - 1) as i32,
-            })
-        }
-    }
-
-    fn timestamp(&self) -> graph::blockchain::BlockTime {
-        graph::blockchain::BlockTime::since_epoch(self.timestamp as i64, 0)
-    }
-}
diff --git a/chain/starknet/src/data_source.rs b/chain/starknet/src/data_source.rs
deleted file mode 100644
index 34daac0f3cc..00000000000
--- a/chain/starknet/src/data_source.rs
+++ /dev/null
@@ -1,401 +0,0 @@
-use graph::{
-    anyhow::{anyhow, Error},
-    blockchain::{self, Block as BlockchainBlock, TriggerWithHandler},
-    components::{link_resolver::LinkResolver, store::StoredDynamicDataSource},
-    data::subgraph::{DataSourceContext, SubgraphManifestValidationError},
-    prelude::{async_trait, BlockNumber, DataSourceTemplateInfo, Deserialize, Link, Logger},
-    semver,
-};
-use sha3::{Digest, Keccak256};
-use std::{collections::HashSet, sync::Arc};
-
-use crate::{
-    chain::Chain,
-    codec,
-    felt::Felt,
-    trigger::{StarknetEventTrigger, StarknetTrigger},
-};
-
-pub const STARKNET_KIND: &str = "starknet";
-const BLOCK_HANDLER_KIND: &str = "block";
-const EVENT_HANDLER_KIND: &str = "event";
-
-#[derive(Debug, Clone)]
-pub struct DataSource {
-    pub kind: String,
-    pub network: String,
-    pub name: String,
-    pub source: Source,
-    pub mapping: Mapping,
-}
-
-#[derive(Debug, Clone)]
-pub struct Mapping {
-    pub block_handler: Option<MappingBlockHandler>,
-    pub event_handlers: Vec<MappingEventHandler>,
-    pub runtime: Arc<Vec<u8>>,
-}
-
-#[derive(Deserialize)]
-pub struct UnresolvedDataSource {
-    pub kind: String,
-    pub network: String,
-    pub name: String,
-    pub source: Source,
-    pub mapping: UnresolvedMapping,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Source {
-    pub start_block: BlockNumber,
-    pub end_block: Option<BlockNumber>,
-    #[serde(default)]
-    pub address: Option<Felt>,
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct UnresolvedMapping {
-    #[serde(default)]
-    pub block_handler: Option<MappingBlockHandler>,
-    #[serde(default)]
-    pub event_handlers: Vec<UnresolvedMappingEventHandler>,
-    pub file: Link,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
-pub struct MappingBlockHandler {
-    pub handler: String,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
-pub struct MappingEventHandler {
-    pub handler: String,
-    pub event_selector: Felt,
-}
-
-#[derive(Clone, Deserialize)]
-pub struct UnresolvedMappingEventHandler {
-    pub handler: String,
-    pub event: String,
-}
-
-#[derive(Debug, Clone)]
-pub struct DataSourceTemplate;
-
-#[derive(Clone, Default, Deserialize)]
-pub struct UnresolvedDataSourceTemplate;
-
-impl blockchain::DataSource<Chain> for DataSource {
-    fn from_template_info(_template_info: DataSourceTemplateInfo<Chain>) -> Result<Self, Error> {
-        Err(anyhow!("StarkNet subgraphs do not support templates"))
-    }
-
-    fn address(&self) -> Option<&[u8]> {
-        self.source.address.as_ref().map(|addr| addr.as_ref())
-    }
-
-    fn start_block(&self) -> BlockNumber {
-        self.source.start_block
-    }
-
-    fn end_block(&self) -> Option<BlockNumber> {
-        self.source.end_block
-    }
-
-    fn handler_kinds(&self) -> HashSet<&str> {
-        let mut kinds = HashSet::new();
-
-        let Mapping {
-            block_handler,
-            event_handlers,
-            ..
-        } = &self.mapping;
-
-        if block_handler.is_some() {
-            kinds.insert(BLOCK_HANDLER_KIND);
-        }
-        if !event_handlers.is_empty() {
-            kinds.insert(EVENT_HANDLER_KIND);
-        }
-
-        kinds
-    }
-
-    fn match_and_decode(
-        &self,
-        trigger: &StarknetTrigger,
-        block: &Arc<codec::Block>,
-        _logger: &Logger,
-    ) -> Result<Option<TriggerWithHandler<Chain>>, Error> {
-        if self.start_block() > block.number() {
-            return Ok(None);
-        }
-
-        let handler = match trigger {
-            StarknetTrigger::Block(_) => match &self.mapping.block_handler {
-                Some(handler) => handler.handler.clone(),
-                None => return Ok(None),
-            },
-            StarknetTrigger::Event(event) => match self.handler_for_event(event) {
-                Some(handler) => handler.handler,
-                None => return Ok(None),
-            },
-        };
-
-        Ok(Some(TriggerWithHandler::<Chain>::new(
-            trigger.clone(),
-            handler,
-            block.ptr(),
-            block.timestamp(),
-        )))
-    }
-
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn kind(&self) -> &str {
-        &self.kind
-    }
-
-    fn network(&self) -> Option<&str> {
-        Some(&self.network)
-    }
-
-    fn context(&self) -> Arc<Option<DataSourceContext>> {
-        Arc::new(None)
-    }
-
-    fn creation_block(&self) -> Option<BlockNumber> {
-        None
-    }
-
-    fn is_duplicate_of(&self, other: &Self) -> bool {
-        let DataSource {
-            kind,
-            network,
-            name,
-            source,
-            mapping,
-        } = self;
-
-        kind == &other.kind
-            && network == &other.network
-            && name == &other.name
-            && source == &other.source
-            && mapping.event_handlers == other.mapping.event_handlers
-            && mapping.block_handler == other.mapping.block_handler
-    }
-
-    fn as_stored_dynamic_data_source(&self) -> StoredDynamicDataSource {
-        // FIXME (Starknet): Implement me!
-        todo!()
-    }
-
-    fn from_stored_dynamic_data_source(
-        _template: &DataSourceTemplate,
-        _stored: StoredDynamicDataSource,
-    ) -> Result<Self, Error> {
-        // FIXME (Starknet): Implement me correctly
-        todo!()
-    }
-
-    fn validate(&self) -> Vec<Error> {
-        let mut errors = Vec::new();
-
-        if self.kind != STARKNET_KIND {
-            errors.push(anyhow!(
-                "data source has invalid `kind`, expected {} but found {}",
-                STARKNET_KIND,
-                self.kind
-            ))
-        }
-
-        // Validate that there's at least one handler of any kind
-        if self.mapping.block_handler.is_none() && self.mapping.event_handlers.is_empty() {
-            errors.push(anyhow!("data source does not define any handler"));
-        }
-
-        // Validate that `source` address must not be present if there's no event handler
-        if self.mapping.event_handlers.is_empty() && self.address().is_some() {
-            errors.push(anyhow!(
-                "data source cannot have source address without event handlers"
-            ));
-        }
-
-        // Validate that `source` address must be present when there's at least 1 event handler
-        if !self.mapping.event_handlers.is_empty() && self.address().is_none() {
-            errors.push(SubgraphManifestValidationError::SourceAddressRequired.into());
-        }
-
-        errors
-    }
-
-    fn api_version(&self) -> semver::Version {
-        semver::Version::new(0, 0, 5)
-    }
-
-    fn runtime(&self) -> Option<Arc<Vec<u8>>> {
-        Some(self.mapping.runtime.clone())
-    }
-}
-
-impl DataSource {
-    /// Returns event trigger if an event.key matches the handler.key and optionally
-    /// if event.fromAddr matches the source address. Note this only supports the default
-    /// Starknet behavior of one key per event.
-    fn handler_for_event(&self, event: &StarknetEventTrigger) -> Option<MappingEventHandler> {
-        let event_key: Felt = Self::pad_to_32_bytes(event.event.keys.first()?)?.into();
-
-        // Always padding first here seems fine as we expect most sources to define an address
-        // filter anyways. Alternatively we can use lazy init here, which seems unnecessary.
-        let event_from_addr: Felt = Self::pad_to_32_bytes(&event.event.from_addr)?.into();
-
-        return self
-            .mapping
-            .event_handlers
-            .iter()
-            .find(|handler| {
-                // No need to compare address if selector doesn't match
-                if handler.event_selector != event_key {
-                    return false;
-                }
-
-                match &self.source.address {
-                    Some(addr_filter) => addr_filter == &event_from_addr,
-                    None => true,
-                }
-            })
-            .cloned();
-    }
-
-    /// We need to pad incoming event selectors and addresses to 32 bytes as our data source uses
-    /// padded 32 bytes.
-    fn pad_to_32_bytes(slice: &[u8]) -> Option<[u8; 32]> {
-        if slice.len() > 32 {
-            None
-        } else {
-            let mut buffer = [0u8; 32];
-            buffer[(32 - slice.len())..].copy_from_slice(slice);
-            Some(buffer)
-        }
-    }
-}
-
-#[async_trait]
-impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
-    async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-        _manifest_idx: u32,
-    ) -> Result<DataSource, Error> {
-        let module_bytes = resolver.cat(logger, &self.mapping.file).await?;
-
-        Ok(DataSource {
-            kind: self.kind,
-            network: self.network,
-            name: self.name,
-            source: self.source,
-            mapping: Mapping {
-                block_handler: self.mapping.block_handler,
-                event_handlers: self
-                    .mapping
-                    .event_handlers
-                    .into_iter()
-                    .map(|handler| {
-                        Ok(MappingEventHandler {
-                            handler: handler.handler,
-                            event_selector: get_selector_from_name(&handler.event)?,
-                        })
-                    })
-                    .collect::<Result<Vec<_>, Error>>()?,
-                runtime: Arc::new(module_bytes),
-            },
-        })
-    }
-}
-
-impl blockchain::DataSourceTemplate<Chain> for DataSourceTemplate {
-    fn api_version(&self) -> semver::Version {
-        todo!()
-    }
-
-    fn runtime(&self) -> Option<Arc<Vec<u8>>> {
-        todo!()
-    }
-
-    fn name(&self) -> &str {
-        todo!()
-    }
-
-    fn manifest_idx(&self) -> u32 {
-        todo!()
-    }
-
-    fn kind(&self) -> &str {
-        todo!()
-    }
-}
-
-#[async_trait]
-impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTemplate {
-    #[allow(unused)]
-    async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-        manifest_idx: u32,
-    ) -> Result<DataSourceTemplate, Error> {
-        todo!()
-    }
-}
-
-// Adapted from:
-//   https://github.com/xJonathanLEI/starknet-rs/blob/f16271877c9dbf08bc7bf61e4fc72decc13ff73d/starknet-core/src/utils.rs#L110-L121
-fn get_selector_from_name(func_name: &str) -> graph::anyhow::Result<Felt> {
-    const DEFAULT_ENTRY_POINT_NAME: &str = "__default__";
-    const DEFAULT_L1_ENTRY_POINT_NAME: &str = "__l1_default__";
-
-    if func_name == DEFAULT_ENTRY_POINT_NAME || func_name == DEFAULT_L1_ENTRY_POINT_NAME {
-        Ok([0u8; 32].into())
-    } else {
-        let name_bytes = func_name.as_bytes();
-        if name_bytes.is_ascii() {
-            Ok(starknet_keccak(name_bytes).into())
-        } else {
-            Err(anyhow!("the provided name contains non-ASCII characters"))
-        }
-    }
-}
-
-// Adapted from:
-//   https://github.com/xJonathanLEI/starknet-rs/blob/f16271877c9dbf08bc7bf61e4fc72decc13ff73d/starknet-core/src/utils.rs#L98-L108
-fn starknet_keccak(data: &[u8]) -> [u8; 32] {
-    let mut hasher = Keccak256::new();
-    hasher.update(data);
-    let mut hash = hasher.finalize();
-
-    // Remove the first 6 bits
-    hash[0] &= 0b00000011;
-
-    hash.into()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_starknet_keccak() {
-        let expected_hash: [u8; 32] =
-            hex::decode("016c11b0b5b808960df26f5bfc471d04c1995b0ffd2055925ad1be28d6baadfd")
-                .unwrap()
-                .try_into()
-                .unwrap();
-
-        assert_eq!(starknet_keccak("Hello world".as_bytes()), expected_hash);
-    }
-}
diff --git a/chain/starknet/src/felt.rs b/chain/starknet/src/felt.rs
deleted file mode 100644
index 7c0e6b6496d..00000000000
--- a/chain/starknet/src/felt.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use std::{
-    fmt::{Debug, Formatter},
-    str::FromStr,
-};
-
-use graph::anyhow;
-use serde::{de::Visitor, Deserialize};
-
-/// Represents the primitive `FieldElement` type used in Starknet. Each `FieldElement` is 252-bit
-/// in size.
-#[derive(Clone, PartialEq, Eq)]
-pub struct Felt([u8; 32]);
-
-struct FeltVisitor;
-
-impl Debug for Felt {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "0x{}", hex::encode(self.0))
-    }
-}
-
-impl From<[u8; 32]> for Felt {
-    fn from(value: [u8; 32]) -> Self {
-        Self(value)
-    }
-}
-
-impl AsRef<[u8]> for Felt {
-    fn as_ref(&self) -> &[u8] {
-        &self.0
-    }
-}
-
-impl FromStr for Felt {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let hex_str = s.trim_start_matches("0x");
-        if hex_str.len() % 2 == 0 {
-            Ok(Felt(decode_even_hex_str(hex_str)?))
-        } else {
-            // We need to manually pad it as the `hex` crate does not allow odd hex length
-            let mut padded_string = String::from("0");
-            padded_string.push_str(hex_str);
-
-            Ok(Felt(decode_even_hex_str(&padded_string)?))
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for Felt {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        deserializer.deserialize_any(FeltVisitor)
-    }
-}
-
-impl<'de> Visitor<'de> for FeltVisitor {
-    type Value = Felt;
-
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(formatter, "string")
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        Felt::from_str(v).map_err(|_| {
-            serde::de::Error::invalid_value(serde::de::Unexpected::Str(v), &"valid Felt value")
-        })
-    }
-}
-
-/// Attempts to decode a even-length hex string into a padded 32-byte array.
-pub fn decode_even_hex_str(hex_str: &str) -> anyhow::Result<[u8; 32]> {
-    let byte_len = hex_str.len() / 2;
-    if byte_len > 32 {
-        anyhow::bail!("length exceeds 32 bytes");
-    }
-
-    let mut buffer = [0u8; 32];
-    hex::decode_to_slice(hex_str, &mut buffer[(32 - byte_len)..])?;
-
-    Ok(buffer)
-}
diff --git a/chain/starknet/src/lib.rs b/chain/starknet/src/lib.rs
deleted file mode 100644
index a2d71dbb626..00000000000
--- a/chain/starknet/src/lib.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-mod adapter;
-mod chain;
-pub mod codec;
-mod data_source;
-mod felt;
-mod runtime;
-mod trigger;
-
-pub use crate::chain::{Chain, StarknetStreamBuilder};
-pub use codec::Block;
diff --git a/chain/starknet/src/protobuf/zklend.starknet.r#type.v1.rs b/chain/starknet/src/protobuf/zklend.starknet.r#type.v1.rs
deleted file mode 100644
index e580ad30143..00000000000
--- a/chain/starknet/src/protobuf/zklend.starknet.r#type.v1.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Block {
-    #[prost(uint64, tag = "1")]
-    pub height: u64,
-    #[prost(bytes = "vec", tag = "2")]
-    pub hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "3")]
-    pub prev_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(uint64, tag = "4")]
-    pub timestamp: u64,
-    #[prost(message, repeated, tag = "5")]
-    pub transactions: ::prost::alloc::vec::Vec<Transaction>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Transaction {
-    #[prost(enumeration = "TransactionType", tag = "1")]
-    pub r#type: i32,
-    #[prost(bytes = "vec", tag = "2")]
-    pub hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, repeated, tag = "3")]
-    pub events: ::prost::alloc::vec::Vec<Event>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Event {
-    #[prost(bytes = "vec", tag = "1")]
-    pub from_addr: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", repeated, tag = "2")]
-    pub keys: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
-    #[prost(bytes = "vec", repeated, tag = "3")]
-    pub data: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum TransactionType {
-    Deploy = 0,
-    InvokeFunction = 1,
-    Declare = 2,
-    L1Handler = 3,
-    DeployAccount = 4,
-}
-impl TransactionType {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            TransactionType::Deploy => "DEPLOY",
-            TransactionType::InvokeFunction => "INVOKE_FUNCTION",
-            TransactionType::Declare => "DECLARE",
-            TransactionType::L1Handler => "L1_HANDLER",
-            TransactionType::DeployAccount => "DEPLOY_ACCOUNT",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "DEPLOY" => Some(Self::Deploy),
-            "INVOKE_FUNCTION" => Some(Self::InvokeFunction),
-            "DECLARE" => Some(Self::Declare),
-            "L1_HANDLER" => Some(Self::L1Handler),
-            "DEPLOY_ACCOUNT" => Some(Self::DeployAccount),
-            _ => None,
-        }
-    }
-}
diff --git a/chain/starknet/src/runtime/abi.rs b/chain/starknet/src/runtime/abi.rs
deleted file mode 100644
index b306d9eb5f8..00000000000
--- a/chain/starknet/src/runtime/abi.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-use graph::{
-    prelude::BigInt,
-    runtime::{asc_new, gas::GasCounter, AscHeap, HostExportError, ToAscObj},
-};
-use graph_runtime_wasm::asc_abi::class::{Array, AscEnum, EnumPayload};
-
-use crate::{
-    codec,
-    trigger::{StarknetBlockTrigger, StarknetEventTrigger},
-};
-
-pub(crate) use super::generated::*;
-
-impl ToAscObj<AscBlock> for codec::Block {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscBlock, HostExportError> {
-        Ok(AscBlock {
-            number: asc_new(heap, &BigInt::from(self.height), gas)?,
-            hash: asc_new(heap, self.hash.as_slice(), gas)?,
-            prev_hash: asc_new(heap, self.prev_hash.as_slice(), gas)?,
-            timestamp: asc_new(heap, &BigInt::from(self.timestamp), gas)?,
-        })
-    }
-}
-
-impl ToAscObj<AscTransaction> for codec::Transaction {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscTransaction, HostExportError> {
-        Ok(AscTransaction {
-            r#type: asc_new(
-                heap,
-                &codec::TransactionType::from_i32(self.r#type)
-                    .expect("invalid TransactionType value"),
-                gas,
-            )?,
-            hash: asc_new(heap, self.hash.as_slice(), gas)?,
-        })
-    }
-}
-
-impl ToAscObj<AscTransactionTypeEnum> for codec::TransactionType {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        _heap: &mut H,
-        _gas: &GasCounter,
-    ) -> Result<AscTransactionTypeEnum, HostExportError> {
-        Ok(AscTransactionTypeEnum(AscEnum {
-            kind: match self {
-                codec::TransactionType::Deploy => AscTransactionType::Deploy,
-                codec::TransactionType::InvokeFunction => AscTransactionType::InvokeFunction,
-                codec::TransactionType::Declare => AscTransactionType::Declare,
-                codec::TransactionType::L1Handler => AscTransactionType::L1Handler,
-                codec::TransactionType::DeployAccount => AscTransactionType::DeployAccount,
-            },
-            _padding: 0,
-            payload: EnumPayload(0),
-        }))
-    }
-}
-
-impl ToAscObj<AscBytesArray> for Vec<Vec<u8>> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscBytesArray, HostExportError> {
-        let content: Result<Vec<_>, _> = self
-            .iter()
-            .map(|x| asc_new(heap, x.as_slice(), gas))
-            .collect();
-
-        Ok(AscBytesArray(Array::new(&content?, heap, gas)?))
-    }
-}
-
-impl ToAscObj<AscBlock> for StarknetBlockTrigger {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscBlock, HostExportError> {
-        self.block.to_asc_obj(heap, gas)
-    }
-}
-
-impl ToAscObj<AscEvent> for StarknetEventTrigger {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscEvent, HostExportError> {
-        Ok(AscEvent {
-            from_addr: asc_new(heap, self.event.from_addr.as_slice(), gas)?,
-            keys: asc_new(heap, &self.event.keys, gas)?,
-            data: asc_new(heap, &self.event.data, gas)?,
-            block: asc_new(heap, self.block.as_ref(), gas)?,
-            transaction: asc_new(heap, self.transaction.as_ref(), gas)?,
-        })
-    }
-}
diff --git a/chain/starknet/src/runtime/generated.rs b/chain/starknet/src/runtime/generated.rs
deleted file mode 100644
index 59932ae576e..00000000000
--- a/chain/starknet/src/runtime/generated.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-use graph::runtime::{
-    AscIndexId, AscPtr, AscType, AscValue, DeterministicHostError, IndexForAscTypeId,
-};
-use graph::semver::Version;
-use graph_runtime_derive::AscType;
-use graph_runtime_wasm::asc_abi::class::{Array, AscBigInt, AscEnum, Uint8Array};
-
-pub struct AscBytesArray(pub(crate) Array<AscPtr<Uint8Array>>);
-
-impl AscType for AscBytesArray {
-    fn to_asc_bytes(&self) -> Result<Vec<u8>, DeterministicHostError> {
-        self.0.to_asc_bytes()
-    }
-
-    fn from_asc_bytes(
-        asc_obj: &[u8],
-        api_version: &Version,
-    ) -> Result<Self, DeterministicHostError> {
-        Ok(Self(Array::from_asc_bytes(asc_obj, api_version)?))
-    }
-}
-
-impl AscIndexId for AscBytesArray {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::StarknetArrayBytes;
-}
-
-pub struct AscTransactionTypeEnum(pub(crate) AscEnum<AscTransactionType>);
-
-impl AscType for AscTransactionTypeEnum {
-    fn to_asc_bytes(&self) -> Result<Vec<u8>, DeterministicHostError> {
-        self.0.to_asc_bytes()
-    }
-
-    fn from_asc_bytes(
-        asc_obj: &[u8],
-        api_version: &Version,
-    ) -> Result<Self, DeterministicHostError> {
-        Ok(Self(AscEnum::from_asc_bytes(asc_obj, api_version)?))
-    }
-}
-
-impl AscIndexId for AscTransactionTypeEnum {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::StarknetTransactionTypeEnum;
-}
-
-#[repr(C)]
-#[derive(AscType)]
-pub(crate) struct AscBlock {
-    pub number: AscPtr<AscBigInt>,
-    pub hash: AscPtr<Uint8Array>,
-    pub prev_hash: AscPtr<Uint8Array>,
-    pub timestamp: AscPtr<AscBigInt>,
-}
-
-impl AscIndexId for AscBlock {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::StarknetBlock;
-}
-
-#[repr(C)]
-#[derive(AscType)]
-pub(crate) struct AscTransaction {
-    pub r#type: AscPtr<AscTransactionTypeEnum>,
-    pub hash: AscPtr<Uint8Array>,
-}
-
-impl AscIndexId for AscTransaction {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::StarknetTransaction;
-}
-
-#[repr(u32)]
-#[derive(AscType, Copy, Clone)]
-pub(crate) enum AscTransactionType {
-    Deploy,
-    InvokeFunction,
-    Declare,
-    L1Handler,
-    DeployAccount,
-}
-
-impl AscValue for AscTransactionType {}
-
-impl Default for AscTransactionType {
-    fn default() -> Self {
-        Self::Deploy
-    }
-}
-
-#[repr(C)]
-#[derive(AscType)]
-pub(crate) struct AscEvent {
-    pub from_addr: AscPtr<Uint8Array>,
-    pub keys: AscPtr<AscBytesArray>,
-    pub data: AscPtr<AscBytesArray>,
-    pub block: AscPtr<AscBlock>,
-    pub transaction: AscPtr<AscTransaction>,
-}
-
-impl AscIndexId for AscEvent {
-    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::StarknetEvent;
-}
diff --git a/chain/starknet/src/runtime/mod.rs b/chain/starknet/src/runtime/mod.rs
deleted file mode 100644
index 31e18de7dd8..00000000000
--- a/chain/starknet/src/runtime/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod abi;
-
-mod generated;
diff --git a/chain/starknet/src/trigger.rs b/chain/starknet/src/trigger.rs
deleted file mode 100644
index 690c4c5c719..00000000000
--- a/chain/starknet/src/trigger.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use graph::{
-    blockchain::{MappingTriggerTrait, TriggerData},
-    runtime::{asc_new, gas::GasCounter, AscPtr, HostExportError},
-};
-use graph_runtime_wasm::module::ToAscPtr;
-use std::{cmp::Ordering, sync::Arc};
-
-use crate::codec;
-
-#[derive(Debug, Clone)]
-pub enum StarknetTrigger {
-    Block(StarknetBlockTrigger),
-    Event(StarknetEventTrigger),
-}
-
-#[derive(Debug, Clone)]
-pub struct StarknetBlockTrigger {
-    pub(crate) block: Arc<codec::Block>,
-}
-
-#[derive(Debug, Clone)]
-pub struct StarknetEventTrigger {
-    pub(crate) event: Arc<codec::Event>,
-    pub(crate) block: Arc<codec::Block>,
-    pub(crate) transaction: Arc<codec::Transaction>,
-}
-
-impl PartialEq for StarknetTrigger {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::Block(l), Self::Block(r)) => l.block == r.block,
-            (Self::Event(l), Self::Event(r)) => {
-                // Without event index we can't really tell if they're the same
-                // TODO: implement add event index to trigger data
-                l.block.hash == r.block.hash
-                    && l.transaction.hash == r.transaction.hash
-                    && l.event == r.event
-            }
-            _ => false,
-        }
-    }
-}
-
-impl Eq for StarknetTrigger {}
-
-impl PartialOrd for StarknetTrigger {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for StarknetTrigger {
-    fn cmp(&self, other: &Self) -> Ordering {
-        match (self, other) {
-            (Self::Block(l), Self::Block(r)) => l.block.height.cmp(&r.block.height),
-
-            // Block triggers always come last
-            (Self::Block(..), _) => Ordering::Greater,
-            (_, Self::Block(..)) => Ordering::Less,
-
-            // Keep the order when comparing two event triggers
-            // TODO: compare block hash, tx index, and event index
-            (Self::Event(..), Self::Event(..)) => Ordering::Equal,
-        }
-    }
-}
-
-impl TriggerData for StarknetTrigger {
-    fn error_context(&self) -> String {
-        match self {
-            Self::Block(block) => format!("block #{}", block.block.height),
-            Self::Event(event) => {
-                format!("event from 0x{}", hex::encode(&event.event.from_addr),)
-            }
-        }
-    }
-
-    fn address_match(&self) -> Option<&[u8]> {
-        None
-    }
-}
-
-impl ToAscPtr for StarknetTrigger {
-    fn to_asc_ptr<H: graph::runtime::AscHeap>(
-        self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<AscPtr<()>, HostExportError> {
-        Ok(match self {
-            StarknetTrigger::Block(block) => asc_new(heap, &block, gas)?.erase(),
-            StarknetTrigger::Event(event) => asc_new(heap, &event, gas)?.erase(),
-        })
-    }
-}
-
-impl MappingTriggerTrait for StarknetTrigger {
-    fn error_context(&self) -> String {
-        match self {
-            Self::Block(block) => format!("block #{}", block.block.height),
-            Self::Event(event) => {
-                format!("event from 0x{}", hex::encode(&event.event.from_addr))
-            }
-        }
-    }
-}
diff --git a/chain/substreams/Cargo.toml b/chain/substreams/Cargo.toml
deleted file mode 100644
index a636bab047b..00000000000
--- a/chain/substreams/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-[package]
-name = "graph-chain-substreams"
-version.workspace = true
-edition.workspace = true
-
-[build-dependencies]
-tonic-build = { workspace = true }
-
-[dependencies]
-async-stream = "0.3"
-envconfig = "0.10.0"
-futures = "0.1.21"
-http = "0.2.4"
-jsonrpc-core = "18.0.0"
-graph = { path = "../../graph" }
-graph-runtime-wasm = { path = "../../runtime/wasm" }
-lazy_static = "1.2.0"
-serde = "1.0"
-prost = { workspace = true }
-prost-types = { workspace = true }
-dirs-next = "2.0"
-anyhow = "1.0"
-tiny-keccak = "1.5.0"
-hex = "0.4.3"
-semver = "1.0.21"
-base64 = "0.20.0"
-
-itertools = "0.12.0"
-
-[dev-dependencies]
-tokio = { version = "1", features = ["full"] }
diff --git a/chain/substreams/build.rs b/chain/substreams/build.rs
deleted file mode 100644
index 8cccc11fe3a..00000000000
--- a/chain/substreams/build.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-fn main() {
-    println!("cargo:rerun-if-changed=proto");
-    tonic_build::configure()
-        .protoc_arg("--experimental_allow_proto3_optional")
-        .out_dir("src/protobuf")
-        .compile(&["proto/codec.proto"], &["proto"])
-        .expect("Failed to compile Substreams entity proto(s)");
-}
diff --git a/chain/substreams/examples/README.md b/chain/substreams/examples/README.md
deleted file mode 100644
index afd1882b337..00000000000
--- a/chain/substreams/examples/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-## Substreams example
-
-1. Set environmental variables
-```bash
-$> export SUBSTREAMS_API_TOKEN=your_sf_token
-$> export SUBSTREAMS_ENDPOINT=your_sf_endpoint # you can also not define this one and use the default specified endpoint
-$> export SUBSTREAMS_PACKAGE=path_to_your_spkg
-```
-
-2. Run `substreams` example
-```bash
-cargo run -p graph-chain-substreams --example substreams [module_name] # for graph entities run `graph_out`
-```
diff --git a/chain/substreams/examples/substreams.rs b/chain/substreams/examples/substreams.rs
deleted file mode 100644
index fbf245856ac..00000000000
--- a/chain/substreams/examples/substreams.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use anyhow::{format_err, Context, Error};
-use graph::blockchain::block_stream::BlockStreamEvent;
-use graph::blockchain::client::ChainClient;
-use graph::blockchain::substreams_block_stream::SubstreamsBlockStream;
-use graph::endpoint::EndpointMetrics;
-use graph::firehose::{FirehoseEndpoints, SubgraphLimit};
-use graph::prelude::{info, tokio, DeploymentHash, MetricsRegistry, Registry};
-use graph::tokio_stream::StreamExt;
-use graph::{env::env_var, firehose::FirehoseEndpoint, log::logger, substreams};
-use graph_chain_substreams::mapper::Mapper;
-use prost::Message;
-use std::env;
-use std::sync::Arc;
-
-#[tokio::main]
-async fn main() -> Result<(), Error> {
-    let module_name = env::args().nth(1).unwrap();
-
-    let token_env = env_var("SUBSTREAMS_API_TOKEN", "".to_string());
-    let mut token: Option<String> = None;
-    if !token_env.is_empty() {
-        token = Some(token_env);
-    }
-
-    let endpoint = env_var(
-        "SUBSTREAMS_ENDPOINT",
-        "https://api.streamingfast.io".to_string(),
-    );
-
-    let package_file = env_var("SUBSTREAMS_PACKAGE", "".to_string());
-    if package_file.is_empty() {
-        panic!("Environment variable SUBSTREAMS_PACKAGE must be set");
-    }
-
-    let package = read_package(&package_file)?;
-
-    let logger = logger(true);
-    // Set up Prometheus registry
-    let prometheus_registry = Arc::new(Registry::new());
-    let metrics_registry = Arc::new(MetricsRegistry::new(
-        logger.clone(),
-        prometheus_registry.clone(),
-    ));
-
-    let endpoint_metrics = EndpointMetrics::new(
-        logger.clone(),
-        &[endpoint.clone()],
-        Arc::new(MetricsRegistry::mock()),
-    );
-
-    let firehose = Arc::new(FirehoseEndpoint::new(
-        "substreams",
-        &endpoint,
-        token,
-        false,
-        false,
-        SubgraphLimit::Unlimited,
-        Arc::new(endpoint_metrics),
-    ));
-
-    let client = Arc::new(ChainClient::new_firehose(FirehoseEndpoints::from(vec![
-        firehose,
-    ])));
-
-    let mut stream: SubstreamsBlockStream<graph_chain_substreams::Chain> =
-        SubstreamsBlockStream::new(
-            DeploymentHash::new("substreams".to_string()).unwrap(),
-            client,
-            None,
-            None,
-            Arc::new(Mapper {
-                schema: None,
-                skip_empty_blocks: false,
-            }),
-            package.modules.clone(),
-            module_name.to_string(),
-            vec![12369621],
-            vec![],
-            logger.clone(),
-            metrics_registry,
-        );
-
-    loop {
-        match stream.next().await {
-            None => {
-                break;
-            }
-            Some(event) => match event {
-                Err(_) => {}
-                Ok(block_stream_event) => match block_stream_event {
-                    BlockStreamEvent::ProcessWasmBlock(_, _, _, _, _) => {
-                        unreachable!("Cannot happen with this mapper")
-                    }
-                    BlockStreamEvent::Revert(_, _) => {}
-                    BlockStreamEvent::ProcessBlock(block_with_trigger, _) => {
-                        for change in block_with_trigger.block.changes.entity_changes {
-                            for field in change.fields {
-                                info!(&logger, "field: {:?}", field);
-                            }
-                        }
-                    }
-                },
-            },
-        }
-    }
-
-    Ok(())
-}
-
-fn read_package(file: &str) -> Result<substreams::Package, anyhow::Error> {
-    let content = std::fs::read(file).context(format_err!("read package {}", file))?;
-    substreams::Package::decode(content.as_ref()).context("decode command")
-}
diff --git a/chain/substreams/proto/codec.proto b/chain/substreams/proto/codec.proto
deleted file mode 100644
index 5529cd774af..00000000000
--- a/chain/substreams/proto/codec.proto
+++ /dev/null
@@ -1,47 +0,0 @@
-syntax = "proto3";
-
-package substreams.entity.v1;
-
-message EntityChanges {
-  repeated EntityChange entity_changes = 5;
-}
-
-message EntityChange {
-  string entity = 1;
-  string id = 2;
-  uint64 ordinal = 3;
-  enum Operation {
-    UNSET = 0;    // Protobuf default should not be used, this is used so that the consume can ensure that the value was actually specified
-    CREATE = 1;
-    UPDATE = 2;
-    DELETE = 3;
-  }
-  Operation operation = 4;
-  repeated Field fields = 5;
-}
-
-message Value {
-  oneof typed {
-    int32 int32 = 1;
-    string bigdecimal = 2;
-    string bigint = 3;
-    string string = 4;
-    bytes bytes = 5;
-    bool bool = 6;
-
-    //reserved 7 to 9;  // For future types
-
-    Array array = 10;
-  }
-}
-
-message Array {
-  repeated Value value = 1;
-}
-
-message Field {
-  string name = 1;
-  optional Value new_value = 3;
-  optional Value old_value = 5;
-}
-
diff --git a/chain/substreams/src/block_ingestor.rs b/chain/substreams/src/block_ingestor.rs
deleted file mode 100644
index 520e98dd461..00000000000
--- a/chain/substreams/src/block_ingestor.rs
+++ /dev/null
@@ -1,173 +0,0 @@
-use std::{sync::Arc, time::Duration};
-
-use crate::mapper::Mapper;
-use anyhow::{Context, Error};
-use graph::blockchain::{
-    client::ChainClient, substreams_block_stream::SubstreamsBlockStream, BlockIngestor,
-};
-use graph::prelude::MetricsRegistry;
-use graph::slog::trace;
-use graph::substreams::Package;
-use graph::tokio_stream::StreamExt;
-use graph::{
-    blockchain::block_stream::BlockStreamEvent,
-    cheap_clone::CheapClone,
-    components::store::ChainStore,
-    prelude::{async_trait, error, info, DeploymentHash, Logger},
-    util::backoff::ExponentialBackoff,
-};
-use prost::Message;
-
-const SUBSTREAMS_HEAD_TRACKER_BYTES: &[u8; 89935] = include_bytes!(
-    "../../../substreams/substreams-head-tracker/substreams-head-tracker-v1.0.0.spkg"
-);
-
-pub struct SubstreamsBlockIngestor {
-    chain_store: Arc<dyn ChainStore>,
-    client: Arc<ChainClient<super::Chain>>,
-    logger: Logger,
-    chain_name: String,
-    metrics: Arc<MetricsRegistry>,
-}
-
-impl SubstreamsBlockIngestor {
-    pub fn new(
-        chain_store: Arc<dyn ChainStore>,
-        client: Arc<ChainClient<super::Chain>>,
-        logger: Logger,
-        chain_name: String,
-        metrics: Arc<MetricsRegistry>,
-    ) -> SubstreamsBlockIngestor {
-        SubstreamsBlockIngestor {
-            chain_store,
-            client,
-            logger,
-            chain_name,
-            metrics,
-        }
-    }
-
-    async fn fetch_head_cursor(&self) -> String {
-        let mut backoff =
-            ExponentialBackoff::new(Duration::from_millis(250), Duration::from_secs(30));
-        loop {
-            match self.chain_store.clone().chain_head_cursor() {
-                Ok(cursor) => return cursor.unwrap_or_default(),
-                Err(e) => {
-                    error!(self.logger, "Fetching chain head cursor failed: {:#}", e);
-
-                    backoff.sleep_async().await;
-                }
-            }
-        }
-    }
-
-    /// Consumes the incoming stream of blocks infinitely until it hits an error. In which case
-    /// the error is logged right away and the latest available cursor is returned
-    /// upstream for future consumption.
-    async fn process_blocks(
-        &self,
-        cursor: String,
-        mut stream: SubstreamsBlockStream<super::Chain>,
-    ) -> String {
-        let mut latest_cursor = cursor;
-
-        while let Some(message) = stream.next().await {
-            let (block, cursor) = match message {
-                Ok(BlockStreamEvent::ProcessWasmBlock(
-                    _block_ptr,
-                    _block_time,
-                    _data,
-                    _handler,
-                    _cursor,
-                )) => {
-                    unreachable!("Block ingestor should never receive raw blocks");
-                }
-                Ok(BlockStreamEvent::ProcessBlock(triggers, cursor)) => {
-                    (Arc::new(triggers.block), cursor)
-                }
-                Ok(BlockStreamEvent::Revert(_ptr, _cursor)) => {
-                    trace!(self.logger, "Received undo block to ingest, skipping");
-                    continue;
-                }
-                Err(e) => {
-                    info!(
-                        self.logger,
-                        "An error occurred while streaming blocks: {}", e
-                    );
-                    break;
-                }
-            };
-
-            let res = self.process_new_block(block, cursor.to_string()).await;
-            if let Err(e) = res {
-                error!(self.logger, "Process block failed: {:#}", e);
-                break;
-            }
-
-            latest_cursor = cursor.to_string()
-        }
-
-        error!(
-            self.logger,
-            "Stream blocks complete unexpectedly, expecting stream to always stream blocks"
-        );
-        latest_cursor
-    }
-
-    async fn process_new_block(
-        &self,
-        block: Arc<super::Block>,
-        cursor: String,
-    ) -> Result<(), Error> {
-        trace!(self.logger, "Received new block to ingest {:?}", block);
-
-        self.chain_store
-            .clone()
-            .set_chain_head(block, cursor)
-            .await
-            .context("Updating chain head")?;
-
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl BlockIngestor for SubstreamsBlockIngestor {
-    async fn run(self: Box<Self>) {
-        let mapper = Arc::new(Mapper {
-            schema: None,
-            skip_empty_blocks: false,
-        });
-        let mut latest_cursor = self.fetch_head_cursor().await;
-        let mut backoff =
-            ExponentialBackoff::new(Duration::from_millis(250), Duration::from_secs(30));
-        let package = Package::decode(SUBSTREAMS_HEAD_TRACKER_BYTES.to_vec().as_ref()).unwrap();
-
-        loop {
-            let stream = SubstreamsBlockStream::<super::Chain>::new(
-                DeploymentHash::default(),
-                self.client.cheap_clone(),
-                None,
-                Some(latest_cursor.clone()),
-                mapper.cheap_clone(),
-                package.modules.clone(),
-                "map_blocks".to_string(),
-                vec![-1],
-                vec![],
-                self.logger.cheap_clone(),
-                self.metrics.cheap_clone(),
-            );
-
-            // Consume the stream of blocks until an error is hit
-            latest_cursor = self.process_blocks(latest_cursor, stream).await;
-
-            // If we reach this point, we must wait a bit before retrying
-            backoff.sleep_async().await;
-        }
-    }
-
-    fn network_name(&self) -> String {
-        self.chain_name.clone()
-    }
-}
diff --git a/chain/substreams/src/block_stream.rs b/chain/substreams/src/block_stream.rs
deleted file mode 100644
index 4cdb8fdf895..00000000000
--- a/chain/substreams/src/block_stream.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use anyhow::Result;
-use std::sync::Arc;
-
-use graph::{
-    blockchain::{
-        block_stream::{
-            BlockStream, BlockStreamBuilder as BlockStreamBuilderTrait, FirehoseCursor,
-        },
-        substreams_block_stream::SubstreamsBlockStream,
-        Blockchain,
-    },
-    components::store::DeploymentLocator,
-    data::subgraph::UnifiedMappingApiVersion,
-    prelude::{async_trait, BlockNumber, BlockPtr},
-    schema::InputSchema,
-    slog::o,
-};
-
-use crate::{
-    mapper::{Mapper, WasmBlockMapper},
-    Chain, TriggerFilter,
-};
-
-pub struct BlockStreamBuilder {}
-
-impl BlockStreamBuilder {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-#[async_trait]
-/// Substreams doesn't actually use Firehose, the configuration for firehose and the grpc substream
-/// is very similar, so we can re-use the configuration and the builder for it.
-/// This is probably something to improve but for now it works.
-impl BlockStreamBuilderTrait<Chain> for BlockStreamBuilder {
-    async fn build_substreams(
-        &self,
-        chain: &Chain,
-        schema: InputSchema,
-        deployment: DeploymentLocator,
-        block_cursor: FirehoseCursor,
-        subgraph_current_block: Option<BlockPtr>,
-        filter: Arc<<Chain as Blockchain>::TriggerFilter>,
-    ) -> Result<Box<dyn BlockStream<Chain>>> {
-        let logger = chain
-            .logger_factory
-            .subgraph_logger(&deployment)
-            .new(o!("component" => "SubstreamsBlockStream"));
-
-        let stream = match &filter.mapping_handler {
-            Some(handler) => SubstreamsBlockStream::new(
-                deployment.hash,
-                chain.chain_client(),
-                subgraph_current_block,
-                block_cursor.as_ref().clone(),
-                Arc::new(WasmBlockMapper {
-                    handler: handler.clone(),
-                }),
-                filter.modules.clone(),
-                filter.module_name.clone(),
-                filter.start_block.map(|x| vec![x]).unwrap_or_default(),
-                vec![],
-                logger,
-                chain.metrics_registry.clone(),
-            ),
-
-            None => SubstreamsBlockStream::new(
-                deployment.hash,
-                chain.chain_client(),
-                subgraph_current_block,
-                block_cursor.as_ref().clone(),
-                Arc::new(Mapper {
-                    schema: Some(schema),
-                    skip_empty_blocks: true,
-                }),
-                filter.modules.clone(),
-                filter.module_name.clone(),
-                filter.start_block.map(|x| vec![x]).unwrap_or_default(),
-                vec![],
-                logger,
-                chain.metrics_registry.clone(),
-            ),
-        };
-
-        Ok(Box::new(stream))
-    }
-
-    async fn build_firehose(
-        &self,
-        _chain: &Chain,
-        _deployment: DeploymentLocator,
-        _block_cursor: FirehoseCursor,
-        _start_blocks: Vec<BlockNumber>,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<TriggerFilter>,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Chain>>> {
-        unimplemented!()
-    }
-
-    async fn build_polling(
-        &self,
-        _chain: &Chain,
-        _deployment: DeploymentLocator,
-        _start_blocks: Vec<BlockNumber>,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<TriggerFilter>,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Chain>>> {
-        unimplemented!("polling block stream is not support for substreams")
-    }
-}
diff --git a/chain/substreams/src/chain.rs b/chain/substreams/src/chain.rs
deleted file mode 100644
index 1dad1764707..00000000000
--- a/chain/substreams/src/chain.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-use crate::block_ingestor::SubstreamsBlockIngestor;
-use crate::{data_source::*, EntityChanges, TriggerData, TriggerFilter, TriggersAdapter};
-use anyhow::Error;
-use graph::blockchain::client::ChainClient;
-use graph::blockchain::{
-    BasicBlockchainBuilder, BlockIngestor, BlockTime, EmptyNodeCapabilities, NoopRuntimeAdapter,
-};
-use graph::components::store::DeploymentCursorTracker;
-use graph::env::EnvVars;
-use graph::firehose::FirehoseEndpoints;
-use graph::prelude::{BlockHash, CheapClone, Entity, LoggerFactory, MetricsRegistry};
-use graph::schema::EntityKey;
-use graph::{
-    blockchain::{
-        self,
-        block_stream::{BlockStream, BlockStreamBuilder, FirehoseCursor},
-        BlockPtr, Blockchain, BlockchainKind, IngestorError, RuntimeAdapter as RuntimeAdapterTrait,
-    },
-    components::store::DeploymentLocator,
-    data::subgraph::UnifiedMappingApiVersion,
-    prelude::{async_trait, BlockNumber, ChainStore},
-    slog::Logger,
-};
-
-use std::sync::Arc;
-
-// ParsedChanges are an internal representation of the equivalent operations defined on the
-// graph-out format used by substreams.
-// Unset serves as a sentinel value, if for some reason an unknown value is sent or the value
-// was empty then it's probably an unintended behaviour. This code was moved here for performance
-// reasons, but the validation is still performed during trigger processing so while Unset will
-// very likely just indicate an error somewhere, as far as the stream is concerned we just pass
-// that along and let the downstream components deal with it.
-#[derive(Debug, Clone)]
-pub enum ParsedChanges {
-    Unset,
-    Delete(EntityKey),
-    Upsert { key: EntityKey, entity: Entity },
-}
-
-#[derive(Default, Debug, Clone)]
-pub struct Block {
-    pub hash: BlockHash,
-    pub number: BlockNumber,
-    pub changes: EntityChanges,
-    pub parsed_changes: Vec<ParsedChanges>,
-}
-
-impl blockchain::Block for Block {
-    fn ptr(&self) -> BlockPtr {
-        BlockPtr {
-            hash: self.hash.clone(),
-            number: self.number,
-        }
-    }
-
-    fn parent_ptr(&self) -> Option<BlockPtr> {
-        None
-    }
-
-    fn timestamp(&self) -> BlockTime {
-        BlockTime::NONE
-    }
-}
-
-pub struct Chain {
-    chain_store: Arc<dyn ChainStore>,
-    block_stream_builder: Arc<dyn BlockStreamBuilder<Self>>,
-
-    pub(crate) logger_factory: LoggerFactory,
-    pub(crate) client: Arc<ChainClient<Self>>,
-    pub(crate) metrics_registry: Arc<MetricsRegistry>,
-}
-
-impl Chain {
-    pub fn new(
-        logger_factory: LoggerFactory,
-        firehose_endpoints: FirehoseEndpoints,
-        metrics_registry: Arc<MetricsRegistry>,
-        chain_store: Arc<dyn ChainStore>,
-        block_stream_builder: Arc<dyn BlockStreamBuilder<Self>>,
-    ) -> Self {
-        Self {
-            logger_factory,
-            client: Arc::new(ChainClient::new_firehose(firehose_endpoints)),
-            metrics_registry,
-            chain_store,
-            block_stream_builder,
-        }
-    }
-}
-
-impl std::fmt::Debug for Chain {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "chain: substreams")
-    }
-}
-
-#[async_trait]
-impl Blockchain for Chain {
-    const KIND: BlockchainKind = BlockchainKind::Substreams;
-
-    type Client = ();
-    type Block = Block;
-    type DataSource = DataSource;
-    type UnresolvedDataSource = UnresolvedDataSource;
-
-    type DataSourceTemplate = NoopDataSourceTemplate;
-    type UnresolvedDataSourceTemplate = NoopDataSourceTemplate;
-
-    /// Trigger data as parsed from the triggers adapter.
-    type TriggerData = TriggerData;
-
-    /// Decoded trigger ready to be processed by the mapping.
-    /// New implementations should have this be the same as `TriggerData`.
-    type MappingTrigger = TriggerData;
-
-    /// Trigger filter used as input to the triggers adapter.
-    type TriggerFilter = TriggerFilter;
-
-    type NodeCapabilities = EmptyNodeCapabilities<Self>;
-
-    fn triggers_adapter(
-        &self,
-        _log: &DeploymentLocator,
-        _capabilities: &Self::NodeCapabilities,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Arc<dyn blockchain::TriggersAdapter<Self>>, Error> {
-        Ok(Arc::new(TriggersAdapter {}))
-    }
-
-    async fn new_block_stream(
-        &self,
-        deployment: DeploymentLocator,
-        store: impl DeploymentCursorTracker,
-        _start_blocks: Vec<BlockNumber>,
-        filter: Arc<Self::TriggerFilter>,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        self.block_stream_builder
-            .build_substreams(
-                self,
-                store.input_schema(),
-                deployment,
-                store.firehose_cursor(),
-                store.block_ptr(),
-                filter,
-            )
-            .await
-    }
-
-    fn is_refetch_block_required(&self) -> bool {
-        false
-    }
-    async fn refetch_firehose_block(
-        &self,
-        _logger: &Logger,
-        _cursor: FirehoseCursor,
-    ) -> Result<Block, Error> {
-        unimplemented!("This chain does not support Dynamic Data Sources. is_refetch_block_required always returns false, this shouldn't be called.")
-    }
-
-    fn chain_store(&self) -> Arc<dyn ChainStore> {
-        self.chain_store.clone()
-    }
-
-    async fn block_pointer_from_number(
-        &self,
-        _logger: &Logger,
-        number: BlockNumber,
-    ) -> Result<BlockPtr, IngestorError> {
-        // This is the same thing TriggersAdapter does, not sure if it's going to work but
-        // we also don't yet have a good way of getting this value until we sort out the
-        // chain store.
-        // TODO(filipe): Fix this once the chain_store is correctly setup for substreams.
-        Ok(BlockPtr {
-            hash: BlockHash::from(vec![0xff; 32]),
-            number,
-        })
-    }
-    fn runtime_adapter(&self) -> Arc<dyn RuntimeAdapterTrait<Self>> {
-        Arc::new(NoopRuntimeAdapter::default())
-    }
-
-    fn chain_client(&self) -> Arc<ChainClient<Self>> {
-        self.client.clone()
-    }
-
-    fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>> {
-        Ok(Box::new(SubstreamsBlockIngestor::new(
-            self.chain_store.cheap_clone(),
-            self.client.cheap_clone(),
-            self.logger_factory.component_logger("", None),
-            "substreams".to_string(),
-            self.metrics_registry.cheap_clone(),
-        )))
-    }
-}
-
-impl blockchain::BlockchainBuilder<super::Chain> for BasicBlockchainBuilder {
-    fn build(self, _config: &Arc<EnvVars>) -> Chain {
-        let BasicBlockchainBuilder {
-            logger_factory,
-            name: _,
-            chain_store,
-            firehose_endpoints,
-            metrics_registry,
-        } = self;
-
-        Chain {
-            chain_store,
-            block_stream_builder: Arc::new(crate::BlockStreamBuilder::new()),
-            logger_factory,
-            client: Arc::new(ChainClient::new_firehose(firehose_endpoints)),
-            metrics_registry,
-        }
-    }
-}
diff --git a/chain/substreams/src/codec.rs b/chain/substreams/src/codec.rs
deleted file mode 100644
index 31781baa201..00000000000
--- a/chain/substreams/src/codec.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#[rustfmt::skip]
-#[path = "protobuf/substreams.entity.v1.rs"]
-mod pbsubstreamsentity;
-
-pub use pbsubstreamsentity::*;
diff --git a/chain/substreams/src/data_source.rs b/chain/substreams/src/data_source.rs
deleted file mode 100644
index dba85695f88..00000000000
--- a/chain/substreams/src/data_source.rs
+++ /dev/null
@@ -1,664 +0,0 @@
-use std::{collections::HashSet, sync::Arc};
-
-use anyhow::{anyhow, Context, Error};
-use graph::{
-    blockchain,
-    cheap_clone::CheapClone,
-    components::link_resolver::LinkResolver,
-    prelude::{async_trait, BlockNumber, DataSourceTemplateInfo, Link},
-    slog::Logger,
-};
-
-use prost::Message;
-use serde::Deserialize;
-
-use crate::{chain::Chain, Block, TriggerData};
-
-pub const SUBSTREAMS_KIND: &str = "substreams";
-
-const DYNAMIC_DATA_SOURCE_ERROR: &str = "Substreams do not support dynamic data sources";
-const TEMPLATE_ERROR: &str = "Substreams do not support templates";
-
-const ALLOWED_MAPPING_KIND: [&str; 1] = ["substreams/graph-entities"];
-const SUBSTREAMS_HANDLER_KIND: &str = "substreams";
-#[derive(Clone, Debug, PartialEq)]
-/// Represents the DataSource portion of the manifest once it has been parsed
-/// and the substream spkg has been downloaded + parsed.
-pub struct DataSource {
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub(crate) source: Source,
-    pub mapping: Mapping,
-    pub context: Arc<Option<graph::prelude::DataSourceContext>>,
-    pub initial_block: Option<BlockNumber>,
-}
-
-impl blockchain::DataSource<Chain> for DataSource {
-    fn from_template_info(_template_info: DataSourceTemplateInfo<Chain>) -> Result<Self, Error> {
-        Err(anyhow!("Substreams does not support templates"))
-    }
-
-    fn address(&self) -> Option<&[u8]> {
-        None
-    }
-
-    fn start_block(&self) -> BlockNumber {
-        self.initial_block.unwrap_or(0)
-    }
-
-    fn end_block(&self) -> Option<BlockNumber> {
-        None
-    }
-
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn kind(&self) -> &str {
-        &self.kind
-    }
-
-    fn network(&self) -> Option<&str> {
-        self.network.as_deref()
-    }
-
-    fn context(&self) -> Arc<Option<graph::prelude::DataSourceContext>> {
-        self.context.cheap_clone()
-    }
-
-    fn creation_block(&self) -> Option<BlockNumber> {
-        None
-    }
-
-    fn api_version(&self) -> semver::Version {
-        self.mapping.api_version.clone()
-    }
-
-    fn runtime(&self) -> Option<Arc<Vec<u8>>> {
-        self.mapping.handler.as_ref().map(|h| h.runtime.clone())
-    }
-
-    fn handler_kinds(&self) -> HashSet<&str> {
-        // This is placeholder, substreams do not have a handler kind.
-        vec![SUBSTREAMS_HANDLER_KIND].into_iter().collect()
-    }
-
-    // match_and_decode only seems to be used on the default trigger processor which substreams
-    // bypasses so it should be fine to leave it unimplemented.
-    fn match_and_decode(
-        &self,
-        _trigger: &TriggerData,
-        _block: &Arc<Block>,
-        _logger: &Logger,
-    ) -> Result<Option<blockchain::TriggerWithHandler<Chain>>, Error> {
-        unimplemented!()
-    }
-
-    fn is_duplicate_of(&self, _other: &Self) -> bool {
-        todo!()
-    }
-
-    fn as_stored_dynamic_data_source(&self) -> graph::components::store::StoredDynamicDataSource {
-        unimplemented!("{}", DYNAMIC_DATA_SOURCE_ERROR)
-    }
-
-    fn validate(&self) -> Vec<Error> {
-        let mut errs = vec![];
-
-        if &self.kind != SUBSTREAMS_KIND {
-            errs.push(anyhow!(
-                "data source has invalid `kind`, expected {} but found {}",
-                SUBSTREAMS_KIND,
-                self.kind
-            ))
-        }
-
-        if self.name.is_empty() {
-            errs.push(anyhow!("name cannot be empty"));
-        }
-
-        if !ALLOWED_MAPPING_KIND.contains(&self.mapping.kind.as_str()) {
-            errs.push(anyhow!(
-                "mapping kind has to be one of {:?}, found {}",
-                ALLOWED_MAPPING_KIND,
-                self.mapping.kind
-            ))
-        }
-
-        errs
-    }
-
-    fn from_stored_dynamic_data_source(
-        _template: &<Chain as blockchain::Blockchain>::DataSourceTemplate,
-        _stored: graph::components::store::StoredDynamicDataSource,
-    ) -> Result<Self, Error> {
-        Err(anyhow!(DYNAMIC_DATA_SOURCE_ERROR))
-    }
-}
-
-#[derive(Clone, Debug, Default, PartialEq)]
-/// Module name comes from the manifest, package is the parsed spkg file.
-pub struct Source {
-    pub module_name: String,
-    pub package: graph::substreams::Package,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Mapping {
-    pub api_version: semver::Version,
-    pub kind: String,
-    pub handler: Option<MappingHandler>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct MappingHandler {
-    pub handler: String,
-    pub runtime: Arc<Vec<u8>>,
-}
-
-#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
-/// Raw representation of the data source for deserialization purposes.
-pub struct UnresolvedDataSource {
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub(crate) source: UnresolvedSource,
-    pub mapping: UnresolvedMapping,
-}
-
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
-#[serde(rename_all = "camelCase")]
-/// Text api_version, before parsing and validation.
-pub struct UnresolvedMapping {
-    pub api_version: String,
-    pub kind: String,
-    pub handler: Option<String>,
-    pub file: Option<Link>,
-}
-
-#[async_trait]
-impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
-    async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-        _manifest_idx: u32,
-    ) -> Result<DataSource, Error> {
-        let content = resolver.cat(logger, &self.source.package.file).await?;
-
-        let mut package = graph::substreams::Package::decode(content.as_ref())?;
-
-        let module = match package.modules.as_mut() {
-            Some(modules) => modules
-                .modules
-                .iter_mut()
-                .find(|module| module.name == self.source.package.module_name)
-                .map(|module| {
-                    if let Some(params) = self.source.package.params {
-                        graph::substreams::patch_module_params(params, module);
-                    }
-                    module
-                }),
-            None => None,
-        };
-
-        let initial_block: Option<u64> = match module {
-            Some(module) => match &module.kind {
-                Some(graph::substreams::module::Kind::KindMap(_)) => Some(module.initial_block),
-                _ => {
-                    return Err(anyhow!(
-                        "Substreams module {} must be of 'map' kind",
-                        module.name
-                    ))
-                }
-            },
-            None => {
-                return Err(anyhow!(
-                    "Substreams module {} does not exist",
-                    self.source.package.module_name
-                ))
-            }
-        };
-
-        let initial_block: Option<i32> = initial_block
-            .map_or(Ok(None), |x: u64| TryInto::<i32>::try_into(x).map(Some))
-            .map_err(anyhow::Error::from)?;
-
-        let handler = match (self.mapping.handler, self.mapping.file) {
-            (Some(handler), Some(file)) => {
-                let module_bytes = resolver
-                    .cat(logger, &file)
-                    .await
-                    .with_context(|| format!("failed to resolve mapping {}", file.link))?;
-
-                Some(MappingHandler {
-                    handler,
-                    runtime: Arc::new(module_bytes),
-                })
-            }
-            _ => None,
-        };
-
-        Ok(DataSource {
-            kind: SUBSTREAMS_KIND.into(),
-            network: self.network,
-            name: self.name,
-            source: Source {
-                module_name: self.source.package.module_name,
-                package,
-            },
-            mapping: Mapping {
-                api_version: semver::Version::parse(&self.mapping.api_version)?,
-                kind: self.mapping.kind,
-                handler,
-            },
-            context: Arc::new(None),
-            initial_block,
-        })
-    }
-}
-
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
-#[serde(rename_all = "camelCase")]
-/// Source is a part of the manifest and this is needed for parsing.
-pub struct UnresolvedSource {
-    #[serde(rename = "startBlock", default)]
-    start_block: Option<BlockNumber>,
-    package: UnresolvedPackage,
-}
-
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
-#[serde(rename_all = "camelCase")]
-/// The unresolved Package section of the manifest.
-pub struct UnresolvedPackage {
-    pub module_name: String,
-    pub file: Link,
-    pub params: Option<String>,
-}
-
-#[derive(Debug, Clone, Default, Deserialize)]
-/// This is necessary for the Blockchain trait associated types, substreams do not support
-/// data source templates so this is a noop and is not expected to be called.
-pub struct NoopDataSourceTemplate {}
-
-impl blockchain::DataSourceTemplate<Chain> for NoopDataSourceTemplate {
-    fn name(&self) -> &str {
-        unimplemented!("{}", TEMPLATE_ERROR);
-    }
-
-    fn api_version(&self) -> semver::Version {
-        unimplemented!("{}", TEMPLATE_ERROR);
-    }
-
-    fn runtime(&self) -> Option<Arc<Vec<u8>>> {
-        unimplemented!("{}", TEMPLATE_ERROR);
-    }
-
-    fn manifest_idx(&self) -> u32 {
-        todo!()
-    }
-
-    fn kind(&self) -> &str {
-        unimplemented!("{}", TEMPLATE_ERROR);
-    }
-}
-
-#[async_trait]
-impl blockchain::UnresolvedDataSourceTemplate<Chain> for NoopDataSourceTemplate {
-    async fn resolve(
-        self,
-        _resolver: &Arc<dyn LinkResolver>,
-        _logger: &Logger,
-        _manifest_idx: u32,
-    ) -> Result<NoopDataSourceTemplate, anyhow::Error> {
-        unimplemented!("{}", TEMPLATE_ERROR)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::{str::FromStr, sync::Arc};
-
-    use anyhow::Error;
-    use graph::{
-        blockchain::{DataSource as _, UnresolvedDataSource as _},
-        components::link_resolver::LinkResolver,
-        prelude::{async_trait, serde_yaml, JsonValueStream, Link},
-        slog::{o, Discard, Logger},
-        substreams::module::{Kind, KindMap, KindStore},
-        substreams::{
-            module::input::{Input, Params},
-            Module, Modules, Package,
-        },
-    };
-    use prost::Message;
-
-    use crate::{DataSource, Mapping, UnresolvedDataSource, UnresolvedMapping, SUBSTREAMS_KIND};
-
-    #[test]
-    fn parse_data_source() {
-        let ds: UnresolvedDataSource = serde_yaml::from_str(TEMPLATE_DATA_SOURCE).unwrap();
-        let expected = UnresolvedDataSource {
-            kind: SUBSTREAMS_KIND.into(),
-            network: Some("mainnet".into()),
-            name: "Uniswap".into(),
-            source: crate::UnresolvedSource {
-                package: crate::UnresolvedPackage {
-                    module_name: "output".into(),
-                    file: Link {
-                        link: "/ipfs/QmbHnhUFZa6qqqRyubUYhXntox1TCBxqryaBM1iNGqVJzT".into(),
-                    },
-                    params: None,
-                },
-                start_block: None,
-            },
-            mapping: UnresolvedMapping {
-                api_version: "0.0.7".into(),
-                kind: "substreams/graph-entities".into(),
-                handler: None,
-                file: None,
-            },
-        };
-        assert_eq!(ds, expected);
-    }
-
-    #[test]
-    fn parse_data_source_with_params() {
-        let ds: UnresolvedDataSource =
-            serde_yaml::from_str(TEMPLATE_DATA_SOURCE_WITH_PARAMS).unwrap();
-        let expected = UnresolvedDataSource {
-            kind: SUBSTREAMS_KIND.into(),
-            network: Some("mainnet".into()),
-            name: "Uniswap".into(),
-            source: crate::UnresolvedSource {
-                package: crate::UnresolvedPackage {
-                    module_name: "output".into(),
-                    file: Link {
-                        link: "/ipfs/QmbHnhUFZa6qqqRyubUYhXntox1TCBxqryaBM1iNGqVJzT".into(),
-                    },
-                    params: Some("x\ny\n123\n".into()),
-                },
-                start_block: None,
-            },
-            mapping: UnresolvedMapping {
-                api_version: "0.0.7".into(),
-                kind: "substreams/graph-entities".into(),
-                handler: None,
-                file: None,
-            },
-        };
-        assert_eq!(ds, expected);
-    }
-
-    #[tokio::test]
-    async fn data_source_conversion() {
-        let ds: UnresolvedDataSource = serde_yaml::from_str(TEMPLATE_DATA_SOURCE).unwrap();
-        let link_resolver: Arc<dyn LinkResolver> = Arc::new(NoopLinkResolver {});
-        let logger = Logger::root(Discard, o!());
-        let ds: DataSource = ds.resolve(&link_resolver, &logger, 0).await.unwrap();
-        let expected = DataSource {
-            kind: SUBSTREAMS_KIND.into(),
-            network: Some("mainnet".into()),
-            name: "Uniswap".into(),
-            source: crate::Source {
-                module_name: "output".into(),
-                package: gen_package(),
-            },
-            mapping: Mapping {
-                api_version: semver::Version::from_str("0.0.7").unwrap(),
-                kind: "substreams/graph-entities".into(),
-                handler: None,
-            },
-            context: Arc::new(None),
-            initial_block: Some(123),
-        };
-        assert_eq!(ds, expected);
-    }
-
-    #[tokio::test]
-    async fn data_source_conversion_override_params() {
-        let mut package = gen_package();
-        let mut modules = package.modules.unwrap();
-        modules.modules.get_mut(0).map(|module| {
-            module.inputs = vec![graph::substreams::module::Input {
-                input: Some(Input::Params(Params {
-                    value: "x\ny\n123\n".into(),
-                })),
-            }]
-        });
-        package.modules = Some(modules);
-
-        let ds: UnresolvedDataSource =
-            serde_yaml::from_str(TEMPLATE_DATA_SOURCE_WITH_PARAMS).unwrap();
-        let link_resolver: Arc<dyn LinkResolver> = Arc::new(NoopLinkResolver {});
-        let logger = Logger::root(Discard, o!());
-        let ds: DataSource = ds.resolve(&link_resolver, &logger, 0).await.unwrap();
-        let expected = DataSource {
-            kind: SUBSTREAMS_KIND.into(),
-            network: Some("mainnet".into()),
-            name: "Uniswap".into(),
-            source: crate::Source {
-                module_name: "output".into(),
-                package,
-            },
-            mapping: Mapping {
-                api_version: semver::Version::from_str("0.0.7").unwrap(),
-                kind: "substreams/graph-entities".into(),
-                handler: None,
-            },
-            context: Arc::new(None),
-            initial_block: Some(123),
-        };
-        assert_eq!(ds, expected);
-    }
-
-    #[test]
-    fn data_source_validation() {
-        let mut ds = gen_data_source();
-        assert_eq!(true, ds.validate().is_empty());
-
-        ds.network = None;
-        assert_eq!(true, ds.validate().is_empty());
-
-        ds.kind = "asdasd".into();
-        ds.name = "".into();
-        ds.mapping.kind = "asdasd".into();
-        let errs: Vec<String> = ds.validate().into_iter().map(|e| e.to_string()).collect();
-        assert_eq!(
-            errs,
-            vec![
-                "data source has invalid `kind`, expected substreams but found asdasd",
-                "name cannot be empty",
-                "mapping kind has to be one of [\"substreams/graph-entities\"], found asdasd"
-            ]
-        );
-    }
-
-    #[test]
-    fn parse_data_source_with_maping() {
-        let ds: UnresolvedDataSource =
-            serde_yaml::from_str(TEMPLATE_DATA_SOURCE_WITH_MAPPING).unwrap();
-
-        let expected = UnresolvedDataSource {
-            kind: SUBSTREAMS_KIND.into(),
-            network: Some("mainnet".into()),
-            name: "Uniswap".into(),
-            source: crate::UnresolvedSource {
-                package: crate::UnresolvedPackage {
-                    module_name: "output".into(),
-                    file: Link {
-                        link: "/ipfs/QmbHnhUFZa6qqqRyubUYhXntox1TCBxqryaBM1iNGqVJzT".into(),
-                    },
-                    params: Some("x\ny\n123\n".into()),
-                },
-                start_block: None,
-            },
-            mapping: UnresolvedMapping {
-                api_version: "0.0.7".into(),
-                kind: "substreams/graph-entities".into(),
-                handler: Some("bananas".to_string()),
-                file: Some(Link {
-                    link: "./src/mappings.ts".to_string(),
-                }),
-            },
-        };
-        assert_eq!(ds, expected);
-    }
-
-    fn gen_package() -> Package {
-        Package {
-            proto_files: vec![],
-            version: 0,
-            modules: Some(Modules {
-                modules: vec![
-                    Module {
-                        name: "output".into(),
-                        initial_block: 123,
-                        binary_entrypoint: "output".into(),
-                        binary_index: 0,
-                        kind: Some(Kind::KindMap(KindMap {
-                            output_type: "proto".into(),
-                        })),
-                        inputs: vec![],
-                        output: None,
-                    },
-                    Module {
-                        name: "store_mod".into(),
-                        initial_block: 0,
-                        binary_entrypoint: "store_mod".into(),
-                        binary_index: 0,
-                        kind: Some(Kind::KindStore(KindStore {
-                            update_policy: 1,
-                            value_type: "proto1".into(),
-                        })),
-                        inputs: vec![],
-                        output: None,
-                    },
-                    Module {
-                        name: "map_mod".into(),
-                        initial_block: 123456,
-                        binary_entrypoint: "other2".into(),
-                        binary_index: 0,
-                        kind: Some(Kind::KindMap(KindMap {
-                            output_type: "proto2".into(),
-                        })),
-                        inputs: vec![],
-                        output: None,
-                    },
-                ],
-                binaries: vec![],
-            }),
-            module_meta: vec![],
-            package_meta: vec![],
-            sink_config: None,
-            network: "".into(),
-            sink_module: "".into(),
-        }
-    }
-
-    fn gen_data_source() -> DataSource {
-        DataSource {
-            kind: SUBSTREAMS_KIND.into(),
-            network: Some("mainnet".into()),
-            name: "Uniswap".into(),
-            source: crate::Source {
-                module_name: "".to_string(),
-                package: gen_package(),
-            },
-            mapping: Mapping {
-                api_version: semver::Version::from_str("0.0.7").unwrap(),
-                kind: "substreams/graph-entities".into(),
-                handler: None,
-            },
-            context: Arc::new(None),
-            initial_block: None,
-        }
-    }
-
-    const TEMPLATE_DATA_SOURCE: &str = r#"
-        kind: substreams
-        name: Uniswap
-        network: mainnet
-        source:
-          package:
-            moduleName: output
-            file:
-              /: /ipfs/QmbHnhUFZa6qqqRyubUYhXntox1TCBxqryaBM1iNGqVJzT
-              # This IPFs path would be generated from a local path at deploy time
-        mapping:
-          kind: substreams/graph-entities
-          apiVersion: 0.0.7
-    "#;
-
-    const TEMPLATE_DATA_SOURCE_WITH_MAPPING: &str = r#"
-        kind: substreams
-        name: Uniswap
-        network: mainnet
-        source:
-          package:
-            moduleName: output
-            file:
-              /: /ipfs/QmbHnhUFZa6qqqRyubUYhXntox1TCBxqryaBM1iNGqVJzT
-              # This IPFs path would be generated from a local path at deploy time
-            params: |
-                x
-                y
-                123
-        mapping:
-          kind: substreams/graph-entities
-          apiVersion: 0.0.7
-          file:
-            /: ./src/mappings.ts
-          handler: bananas
-    "#;
-
-    const TEMPLATE_DATA_SOURCE_WITH_PARAMS: &str = r#"
-        kind: substreams
-        name: Uniswap
-        network: mainnet
-        source:
-          package:
-            moduleName: output
-            file:
-              /: /ipfs/QmbHnhUFZa6qqqRyubUYhXntox1TCBxqryaBM1iNGqVJzT
-              # This IPFs path would be generated from a local path at deploy time
-            params: |
-                x
-                y
-                123
-        mapping:
-          kind: substreams/graph-entities
-          apiVersion: 0.0.7
-    "#;
-
-    #[derive(Debug)]
-    struct NoopLinkResolver {}
-
-    #[async_trait]
-    impl LinkResolver for NoopLinkResolver {
-        fn with_timeout(&self, _timeout: std::time::Duration) -> Box<dyn LinkResolver> {
-            unimplemented!()
-        }
-
-        fn with_retries(&self) -> Box<dyn LinkResolver> {
-            unimplemented!()
-        }
-
-        async fn cat(&self, _logger: &Logger, _link: &Link) -> Result<Vec<u8>, Error> {
-            Ok(gen_package().encode_to_vec())
-        }
-
-        async fn get_block(&self, _logger: &Logger, _link: &Link) -> Result<Vec<u8>, Error> {
-            unimplemented!()
-        }
-
-        async fn json_stream(
-            &self,
-            _logger: &Logger,
-            _link: &Link,
-        ) -> Result<JsonValueStream, Error> {
-            unimplemented!()
-        }
-    }
-}
diff --git a/chain/substreams/src/lib.rs b/chain/substreams/src/lib.rs
deleted file mode 100644
index 664ceab6d65..00000000000
--- a/chain/substreams/src/lib.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-mod block_stream;
-mod chain;
-mod codec;
-mod data_source;
-mod trigger;
-
-pub mod block_ingestor;
-pub mod mapper;
-
-pub use crate::chain::Chain;
-pub use block_stream::BlockStreamBuilder;
-pub use chain::*;
-pub use codec::EntityChanges;
-pub use data_source::*;
-pub use trigger::*;
-
-pub use codec::Field;
diff --git a/chain/substreams/src/mapper.rs b/chain/substreams/src/mapper.rs
deleted file mode 100644
index f08fedb462e..00000000000
--- a/chain/substreams/src/mapper.rs
+++ /dev/null
@@ -1,398 +0,0 @@
-use std::collections::HashMap;
-use std::str::FromStr;
-
-use crate::codec::{entity_change, EntityChanges};
-use anyhow::{anyhow, Error};
-use graph::blockchain::block_stream::{
-    BlockStreamEvent, BlockStreamMapper, BlockWithTriggers, FirehoseCursor, SubstreamsError,
-};
-use graph::blockchain::BlockTime;
-use graph::data::store::scalar::Bytes;
-use graph::data::store::IdType;
-use graph::data::value::Word;
-use graph::data_source::CausalityRegion;
-use graph::prelude::{async_trait, BigInt, BlockHash, BlockNumber, Logger, Value};
-use graph::prelude::{BigDecimal, BlockPtr};
-use graph::schema::InputSchema;
-use graph::slog::error;
-use graph::substreams::Clock;
-use prost::Message;
-
-use crate::{Block, Chain, ParsedChanges, TriggerData};
-
-// WasmBlockMapper will not perform any transformation to the block and cannot make assumptions
-// about the block format. This mode just works a passthrough from the block stream to the subgraph
-// mapping which will do the decoding and store actions.
-pub struct WasmBlockMapper {
-    pub handler: String,
-}
-
-#[async_trait]
-impl BlockStreamMapper<Chain> for WasmBlockMapper {
-    fn decode_block(&self, _output: Option<&[u8]>) -> Result<Option<crate::Block>, Error> {
-        unreachable!("WasmBlockMapper does not do block decoding")
-    }
-
-    async fn block_with_triggers(
-        &self,
-        _logger: &Logger,
-        _block: crate::Block,
-    ) -> Result<BlockWithTriggers<Chain>, Error> {
-        unreachable!("WasmBlockMapper does not do trigger decoding")
-    }
-
-    async fn handle_substreams_block(
-        &self,
-        logger: &Logger,
-        clock: Clock,
-        cursor: FirehoseCursor,
-        block: Vec<u8>,
-    ) -> Result<BlockStreamEvent<Chain>, Error> {
-        let Clock {
-            id,
-            number,
-            timestamp,
-        } = clock;
-
-        let block_ptr = BlockPtr {
-            hash: BlockHash::from(id.into_bytes()),
-            number: BlockNumber::from(TryInto::<i32>::try_into(number)?),
-        };
-
-        let block_data = block.into_boxed_slice();
-
-        // `timestamp` is an `Option`, but it should always be set
-        let timestamp = match timestamp {
-            None => {
-                error!(logger,
-                    "Substream block is missing a timestamp";
-                    "cursor" => cursor.to_string(),
-                    "number" => number,
-                );
-                return Err(anyhow!(
-                    "Substream block is missing a timestamp at cursor {cursor}, block number {number}"
-                ));
-            }
-            Some(ts) => BlockTime::since_epoch(ts.seconds, ts.nanos as u32),
-        };
-
-        Ok(BlockStreamEvent::ProcessWasmBlock(
-            block_ptr,
-            timestamp,
-            block_data,
-            self.handler.clone(),
-            cursor,
-        ))
-    }
-}
-
-// Mapper will transform the proto content coming from substreams in the graph-out format
-// into the internal Block representation. If schema is passed then additional transformation
-// into from the substreams block representation is performed into the Entity model used by
-// the store. If schema is None then only the original block is passed. This None should only
-// be used for block ingestion where entity content is empty and gets discarded.
-pub struct Mapper {
-    pub schema: Option<InputSchema>,
-    // Block ingestors need the block to be returned so they can populate the cache
-    // block streams, however, can shave some time by just skipping.
-    pub skip_empty_blocks: bool,
-}
-
-#[async_trait]
-impl BlockStreamMapper<Chain> for Mapper {
-    fn decode_block(&self, output: Option<&[u8]>) -> Result<Option<Block>, Error> {
-        let changes: EntityChanges = match output {
-            Some(msg) => Message::decode(msg).map_err(SubstreamsError::DecodingError)?,
-            None => EntityChanges {
-                entity_changes: [].to_vec(),
-            },
-        };
-
-        let parsed_changes = match self.schema.as_ref() {
-            Some(schema) => parse_changes(&changes, schema)?,
-            None if self.skip_empty_blocks => return Ok(None),
-            None => vec![],
-        };
-
-        let hash = BlockHash::zero();
-        let number = BlockNumber::MIN;
-        let block = Block {
-            hash,
-            number,
-            changes,
-            parsed_changes,
-        };
-
-        Ok(Some(block))
-    }
-
-    async fn block_with_triggers(
-        &self,
-        logger: &Logger,
-        block: Block,
-    ) -> Result<BlockWithTriggers<Chain>, Error> {
-        let mut triggers = vec![];
-        if block.changes.entity_changes.len() >= 1 {
-            triggers.push(TriggerData {});
-        }
-
-        Ok(BlockWithTriggers::new(block, triggers, logger))
-    }
-
-    async fn handle_substreams_block(
-        &self,
-        logger: &Logger,
-        clock: Clock,
-        cursor: FirehoseCursor,
-        block: Vec<u8>,
-    ) -> Result<BlockStreamEvent<Chain>, Error> {
-        let block_number: BlockNumber = clock.number.try_into()?;
-        let block_hash = clock.id.as_bytes().to_vec().try_into()?;
-
-        let block = self
-            .decode_block(Some(&block))?
-            .ok_or_else(|| anyhow!("expected block to not be empty"))?;
-
-        let block = self.block_with_triggers(logger, block).await.map(|bt| {
-            let mut block = bt;
-
-            block.block.number = block_number;
-            block.block.hash = block_hash;
-            block
-        })?;
-
-        Ok(BlockStreamEvent::ProcessBlock(block, cursor))
-    }
-}
-
-fn parse_changes(
-    changes: &EntityChanges,
-    schema: &InputSchema,
-) -> anyhow::Result<Vec<ParsedChanges>> {
-    let mut parsed_changes = vec![];
-    for entity_change in changes.entity_changes.iter() {
-        let mut parsed_data: HashMap<Word, Value> = HashMap::default();
-        let entity_type = schema.entity_type(&entity_change.entity)?;
-
-        // Make sure that the `entity_id` gets set to a value
-        // that is safe for roundtrips through the database. In
-        // particular, if the type of the id is `Bytes`, we have
-        // to make sure that the `entity_id` starts with `0x` as
-        // that will be what the key for such an entity have
-        // when it is read from the database.
-        //
-        // Needless to say, this is a very ugly hack, and the
-        // real fix is what's described in [this
-        // issue](https://github.com/graphprotocol/graph-node/issues/4663)
-        let entity_id: String = match entity_type.id_type()? {
-            IdType::String | IdType::Int8 => entity_change.id.clone(),
-            IdType::Bytes => {
-                if entity_change.id.starts_with("0x") {
-                    entity_change.id.clone()
-                } else {
-                    format!("0x{}", entity_change.id)
-                }
-            }
-        };
-        // Substreams don't currently support offchain data
-        let key = entity_type.parse_key_in(Word::from(entity_id), CausalityRegion::ONCHAIN)?;
-
-        let id = key.id_value();
-        parsed_data.insert(Word::from("id"), id);
-
-        let changes = match entity_change.operation() {
-            entity_change::Operation::Create | entity_change::Operation::Update => {
-                for field in entity_change.fields.iter() {
-                    let new_value: &crate::codec::value::Typed = match &field.new_value {
-                        Some(crate::codec::Value {
-                            typed: Some(new_value),
-                        }) => &new_value,
-                        _ => continue,
-                    };
-
-                    let value: Value = decode_value(new_value)?;
-                    *parsed_data
-                        .entry(Word::from(field.name.as_str()))
-                        .or_insert(Value::Null) = value;
-                }
-                let entity = schema
-                    .make_entity(parsed_data)
-                    .map_err(anyhow::Error::from)?;
-
-                ParsedChanges::Upsert { key, entity }
-            }
-            entity_change::Operation::Delete => ParsedChanges::Delete(key),
-            entity_change::Operation::Unset => ParsedChanges::Unset,
-        };
-        parsed_changes.push(changes);
-    }
-
-    Ok(parsed_changes)
-}
-
-fn decode_value(value: &crate::codec::value::Typed) -> anyhow::Result<Value> {
-    use crate::codec::value::Typed;
-
-    match value {
-        Typed::Int32(new_value) => Ok(Value::Int(*new_value)),
-
-        Typed::Bigdecimal(new_value) => BigDecimal::from_str(new_value)
-            .map(Value::BigDecimal)
-            .map_err(|err| anyhow::Error::from(err)),
-
-        Typed::Bigint(new_value) => BigInt::from_str(new_value)
-            .map(Value::BigInt)
-            .map_err(|err| anyhow::Error::from(err)),
-
-        Typed::String(new_value) => {
-            let mut string = new_value.clone();
-
-            // Strip null characters since they are not accepted by Postgres.
-            if string.contains('\u{0000}') {
-                string = string.replace('\u{0000}', "");
-            }
-            Ok(Value::String(string))
-        }
-
-        Typed::Bytes(new_value) => base64::decode(new_value)
-            .map(|bs| Value::Bytes(Bytes::from(bs)))
-            .map_err(|err| anyhow::Error::from(err)),
-
-        Typed::Bool(new_value) => Ok(Value::Bool(*new_value)),
-
-        Typed::Array(arr) => arr
-            .value
-            .iter()
-            .filter_map(|item| item.typed.as_ref().map(decode_value))
-            .collect::<anyhow::Result<Vec<Value>>>()
-            .map(Value::List),
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::{ops::Add, str::FromStr};
-
-    use super::decode_value;
-    use crate::codec::value::Typed;
-    use crate::codec::{Array, Value};
-    use graph::{
-        data::store::scalar::Bytes,
-        prelude::{BigDecimal, BigInt, Value as GraphValue},
-    };
-
-    #[test]
-    fn validate_substreams_field_types() {
-        struct Case {
-            name: String,
-            value: Value,
-            expected_value: GraphValue,
-        }
-
-        let cases = vec![
-            Case {
-                name: "string value".to_string(),
-                value: Value {
-                    typed: Some(Typed::String(
-                        "d4325ee72c39999e778a9908f5fb0803f78e30c441a5f2ce5c65eee0e0eba59d"
-                            .to_string(),
-                    )),
-                },
-                expected_value: GraphValue::String(
-                    "d4325ee72c39999e778a9908f5fb0803f78e30c441a5f2ce5c65eee0e0eba59d".to_string(),
-                ),
-            },
-            Case {
-                name: "bytes value".to_string(),
-                value: Value {
-                    typed: Some(Typed::Bytes(
-                        base64::encode(
-                            hex::decode(
-                                "445247fe150195bd866516594e087e1728294aa831613f4d48b8ec618908519f",
-                            )
-                            .unwrap(),
-                        )
-                        .into_bytes(),
-                    )),
-                },
-                expected_value: GraphValue::Bytes(
-                    Bytes::from_str(
-                        "0x445247fe150195bd866516594e087e1728294aa831613f4d48b8ec618908519f",
-                    )
-                    .unwrap(),
-                ),
-            },
-            Case {
-                name: "int value for block".to_string(),
-                value: Value {
-                    typed: Some(Typed::Int32(12369760)),
-                },
-                expected_value: GraphValue::Int(12369760),
-            },
-            Case {
-                name: "negative int value".to_string(),
-                value: Value {
-                    typed: Some(Typed::Int32(-12369760)),
-                },
-                expected_value: GraphValue::Int(-12369760),
-            },
-            Case {
-                name: "big int".to_string(),
-                value: Value {
-                    typed: Some(Typed::Bigint("123".to_string())),
-                },
-                expected_value: GraphValue::BigInt(BigInt::from(123u64)),
-            },
-            Case {
-                name: "big int > u64".to_string(),
-                value: Value {
-                    typed: Some(Typed::Bigint(
-                        BigInt::from(u64::MAX).add(BigInt::from(1)).to_string(),
-                    )),
-                },
-                expected_value: GraphValue::BigInt(BigInt::from(u64::MAX).add(BigInt::from(1))),
-            },
-            Case {
-                name: "big decimal value".to_string(),
-                value: Value {
-                    typed: Some(Typed::Bigdecimal("3133363633312e35".to_string())),
-                },
-                expected_value: GraphValue::BigDecimal(BigDecimal::new(
-                    BigInt::from(3133363633312u64),
-                    35,
-                )),
-            },
-            Case {
-                name: "bool value".to_string(),
-                value: Value {
-                    typed: Some(Typed::Bool(true)),
-                },
-                expected_value: GraphValue::Bool(true),
-            },
-            Case {
-                name: "string array".to_string(),
-                value: Value {
-                    typed: Some(Typed::Array(Array {
-                        value: vec![
-                            Value {
-                                typed: Some(Typed::String("1".to_string())),
-                            },
-                            Value {
-                                typed: Some(Typed::String("2".to_string())),
-                            },
-                            Value {
-                                typed: Some(Typed::String("3".to_string())),
-                            },
-                        ],
-                    })),
-                },
-                expected_value: GraphValue::List(vec!["1".into(), "2".into(), "3".into()]),
-            },
-        ];
-
-        for case in cases.into_iter() {
-            let value: GraphValue = decode_value(&case.value.typed.unwrap()).unwrap();
-            assert_eq!(case.expected_value, value, "failed case: {}", case.name)
-        }
-    }
-}
diff --git a/chain/substreams/src/protobuf/substreams.entity.v1.rs b/chain/substreams/src/protobuf/substreams.entity.v1.rs
deleted file mode 100644
index 47368e25fba..00000000000
--- a/chain/substreams/src/protobuf/substreams.entity.v1.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EntityChanges {
-    #[prost(message, repeated, tag = "5")]
-    pub entity_changes: ::prost::alloc::vec::Vec<EntityChange>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EntityChange {
-    #[prost(string, tag = "1")]
-    pub entity: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub id: ::prost::alloc::string::String,
-    #[prost(uint64, tag = "3")]
-    pub ordinal: u64,
-    #[prost(enumeration = "entity_change::Operation", tag = "4")]
-    pub operation: i32,
-    #[prost(message, repeated, tag = "5")]
-    pub fields: ::prost::alloc::vec::Vec<Field>,
-}
-/// Nested message and enum types in `EntityChange`.
-pub mod entity_change {
-    #[derive(
-        Clone,
-        Copy,
-        Debug,
-        PartialEq,
-        Eq,
-        Hash,
-        PartialOrd,
-        Ord,
-        ::prost::Enumeration
-    )]
-    #[repr(i32)]
-    pub enum Operation {
-        /// Protobuf default should not be used, this is used so that the consume can ensure that the value was actually specified
-        Unset = 0,
-        Create = 1,
-        Update = 2,
-        Delete = 3,
-    }
-    impl Operation {
-        /// String value of the enum field names used in the ProtoBuf definition.
-        ///
-        /// The values are not transformed in any way and thus are considered stable
-        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-        pub fn as_str_name(&self) -> &'static str {
-            match self {
-                Operation::Unset => "UNSET",
-                Operation::Create => "CREATE",
-                Operation::Update => "UPDATE",
-                Operation::Delete => "DELETE",
-            }
-        }
-        /// Creates an enum from field names used in the ProtoBuf definition.
-        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-            match value {
-                "UNSET" => Some(Self::Unset),
-                "CREATE" => Some(Self::Create),
-                "UPDATE" => Some(Self::Update),
-                "DELETE" => Some(Self::Delete),
-                _ => None,
-            }
-        }
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Value {
-    #[prost(oneof = "value::Typed", tags = "1, 2, 3, 4, 5, 6, 10")]
-    pub typed: ::core::option::Option<value::Typed>,
-}
-/// Nested message and enum types in `Value`.
-pub mod value {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Typed {
-        #[prost(int32, tag = "1")]
-        Int32(i32),
-        #[prost(string, tag = "2")]
-        Bigdecimal(::prost::alloc::string::String),
-        #[prost(string, tag = "3")]
-        Bigint(::prost::alloc::string::String),
-        #[prost(string, tag = "4")]
-        String(::prost::alloc::string::String),
-        #[prost(bytes, tag = "5")]
-        Bytes(::prost::alloc::vec::Vec<u8>),
-        #[prost(bool, tag = "6")]
-        Bool(bool),
-        #[prost(message, tag = "10")]
-        Array(super::Array),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Array {
-    #[prost(message, repeated, tag = "1")]
-    pub value: ::prost::alloc::vec::Vec<Value>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Field {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "3")]
-    pub new_value: ::core::option::Option<Value>,
-    #[prost(message, optional, tag = "5")]
-    pub old_value: ::core::option::Option<Value>,
-}
diff --git a/chain/substreams/src/trigger.rs b/chain/substreams/src/trigger.rs
deleted file mode 100644
index 0e42eb7734a..00000000000
--- a/chain/substreams/src/trigger.rs
+++ /dev/null
@@ -1,251 +0,0 @@
-use std::sync::Arc;
-
-use anyhow::Error;
-use graph::{
-    blockchain::{
-        self, block_stream::BlockWithTriggers, BlockPtr, EmptyNodeCapabilities, MappingTriggerTrait,
-    },
-    components::{
-        store::{DeploymentLocator, SubgraphFork},
-        subgraph::{MappingError, ProofOfIndexingEvent, SharedProofOfIndexing},
-    },
-    data_source,
-    prelude::{
-        anyhow, async_trait, BlockHash, BlockNumber, BlockState, CheapClone, RuntimeHostBuilder,
-    },
-    slog::Logger,
-    substreams::Modules,
-};
-use graph_runtime_wasm::module::ToAscPtr;
-use lazy_static::__Deref;
-
-use crate::{Block, Chain, NoopDataSourceTemplate, ParsedChanges};
-
-#[derive(Eq, PartialEq, PartialOrd, Ord, Debug)]
-pub struct TriggerData {}
-
-impl MappingTriggerTrait for TriggerData {
-    fn error_context(&self) -> String {
-        "Failed to process substreams block".to_string()
-    }
-}
-
-impl blockchain::TriggerData for TriggerData {
-    // TODO(filipe): Can this be improved with some data from the block?
-    fn error_context(&self) -> String {
-        "Failed to process substreams block".to_string()
-    }
-
-    fn address_match(&self) -> Option<&[u8]> {
-        None
-    }
-}
-
-impl ToAscPtr for TriggerData {
-    // substreams doesn't rely on wasm on the graph-node so this is not needed.
-    fn to_asc_ptr<H: graph::runtime::AscHeap>(
-        self,
-        _heap: &mut H,
-        _gas: &graph::runtime::gas::GasCounter,
-    ) -> Result<graph::runtime::AscPtr<()>, graph::runtime::HostExportError> {
-        unimplemented!()
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct TriggerFilter {
-    pub(crate) modules: Option<Modules>,
-    pub(crate) module_name: String,
-    pub(crate) start_block: Option<BlockNumber>,
-    pub(crate) data_sources_len: u8,
-    // the handler to call for subgraph mappings, if this is set then the binary block content
-    // should be passed to the mappings.
-    pub(crate) mapping_handler: Option<String>,
-}
-
-#[cfg(debug_assertions)]
-impl TriggerFilter {
-    pub fn modules(&self) -> &Option<Modules> {
-        &self.modules
-    }
-
-    pub fn module_name(&self) -> &str {
-        &self.module_name
-    }
-
-    pub fn start_block(&self) -> &Option<BlockNumber> {
-        &self.start_block
-    }
-
-    pub fn data_sources_len(&self) -> u8 {
-        self.data_sources_len
-    }
-}
-
-// TriggerFilter should bypass all triggers and just rely on block since all the data received
-// should already have been processed.
-impl blockchain::TriggerFilter<Chain> for TriggerFilter {
-    fn extend_with_template(&mut self, _data_source: impl Iterator<Item = NoopDataSourceTemplate>) {
-    }
-
-    /// this function is not safe to call multiple times, only one DataSource is supported for
-    ///
-    fn extend<'a>(
-        &mut self,
-        mut data_sources: impl Iterator<Item = &'a crate::DataSource> + Clone,
-    ) {
-        let Self {
-            modules,
-            module_name,
-            start_block,
-            data_sources_len,
-            mapping_handler,
-        } = self;
-
-        if *data_sources_len >= 1 {
-            return;
-        }
-
-        if let Some(ds) = data_sources.next() {
-            *data_sources_len = 1;
-            *modules = ds.source.package.modules.clone();
-            *module_name = ds.source.module_name.clone();
-            *start_block = ds.initial_block;
-            *mapping_handler = ds.mapping.handler.as_ref().map(|h| h.handler.clone());
-        }
-    }
-
-    fn node_capabilities(&self) -> EmptyNodeCapabilities<Chain> {
-        EmptyNodeCapabilities::default()
-    }
-
-    fn to_firehose_filter(self) -> Vec<prost_types::Any> {
-        unimplemented!("this should never be called for this type")
-    }
-}
-
-pub struct TriggersAdapter {}
-
-#[async_trait]
-impl blockchain::TriggersAdapter<Chain> for TriggersAdapter {
-    async fn ancestor_block(
-        &self,
-        _ptr: BlockPtr,
-        _offset: BlockNumber,
-    ) -> Result<Option<Block>, Error> {
-        unimplemented!()
-    }
-
-    async fn scan_triggers(
-        &self,
-        _from: BlockNumber,
-        _to: BlockNumber,
-        _filter: &TriggerFilter,
-    ) -> Result<Vec<BlockWithTriggers<Chain>>, Error> {
-        unimplemented!()
-    }
-
-    async fn triggers_in_block(
-        &self,
-        _logger: &Logger,
-        _block: Block,
-        _filter: &TriggerFilter,
-    ) -> Result<BlockWithTriggers<Chain>, Error> {
-        unimplemented!()
-    }
-
-    async fn is_on_main_chain(&self, _ptr: BlockPtr) -> Result<bool, Error> {
-        unimplemented!()
-    }
-
-    async fn parent_ptr(&self, block: &BlockPtr) -> Result<Option<BlockPtr>, Error> {
-        // This seems to work for a lot of the firehose chains.
-        Ok(Some(BlockPtr {
-            hash: BlockHash::from(vec![0xff; 32]),
-            number: block.number.saturating_sub(1),
-        }))
-    }
-}
-
-fn write_poi_event(
-    proof_of_indexing: &SharedProofOfIndexing,
-    poi_event: &ProofOfIndexingEvent,
-    causality_region: &str,
-    logger: &Logger,
-) {
-    if let Some(proof_of_indexing) = proof_of_indexing {
-        let mut proof_of_indexing = proof_of_indexing.deref().borrow_mut();
-        proof_of_indexing.write(logger, causality_region, poi_event);
-    }
-}
-
-pub struct TriggerProcessor {
-    pub locator: DeploymentLocator,
-}
-
-impl TriggerProcessor {
-    pub fn new(locator: DeploymentLocator) -> Self {
-        Self { locator }
-    }
-}
-
-#[async_trait]
-impl<T> graph::prelude::TriggerProcessor<Chain, T> for TriggerProcessor
-where
-    T: RuntimeHostBuilder<Chain>,
-{
-    async fn process_trigger(
-        &self,
-        logger: &Logger,
-        _: Box<dyn Iterator<Item = &T::Host> + Send + '_>,
-        block: &Arc<Block>,
-        _trigger: &data_source::TriggerData<Chain>,
-        mut state: BlockState<Chain>,
-        proof_of_indexing: &SharedProofOfIndexing,
-        causality_region: &str,
-        _debug_fork: &Option<Arc<dyn SubgraphFork>>,
-        _subgraph_metrics: &Arc<graph::prelude::SubgraphInstanceMetrics>,
-        _instrument: bool,
-    ) -> Result<BlockState<Chain>, MappingError> {
-        for parsed_change in block.parsed_changes.clone().into_iter() {
-            match parsed_change {
-                ParsedChanges::Unset => {
-                    // Potentially an issue with the server side or
-                    // we are running an outdated version. In either case we should abort.
-                    return Err(MappingError::Unknown(anyhow!("Detected UNSET entity operation, either a server error or there's a new type of operation and we're running an outdated protobuf")));
-                }
-                ParsedChanges::Upsert { key, entity } => {
-                    write_poi_event(
-                        proof_of_indexing,
-                        &ProofOfIndexingEvent::SetEntity {
-                            entity_type: key.entity_type.as_str(),
-                            id: &key.entity_id.to_string(),
-                            data: &entity,
-                        },
-                        causality_region,
-                        logger,
-                    );
-
-                    state.entity_cache.set(key, entity)?;
-                }
-                ParsedChanges::Delete(entity_key) => {
-                    let entity_type = entity_key.entity_type.cheap_clone();
-                    let id = entity_key.entity_id.clone();
-                    state.entity_cache.remove(entity_key);
-
-                    write_poi_event(
-                        proof_of_indexing,
-                        &ProofOfIndexingEvent::RemoveEntity {
-                            entity_type: entity_type.as_str(),
-                            id: &id.to_string(),
-                        },
-                        causality_region,
-                        logger,
-                    );
-                }
-            }
-        }
-
-        Ok(state)
-    }
-}
diff --git a/core/Cargo.toml b/core/Cargo.toml
index 1c2175ca38f..a4b38367213 100644
--- a/core/Cargo.toml
+++ b/core/Cargo.toml
@@ -4,37 +4,36 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-async-trait = "0.1.50"
-atomic_refcell = "0.1.13"
-async-stream = "0.3"
+async-trait = { workspace = true}
 bytes = "1.0"
-futures01 = { package = "futures", version = "0.1.31" }
-futures = { version = "0.3.4", features = ["compat"] }
 graph = { path = "../graph" }
-# This dependency is temporary. The multiblockchain refactoring is not
-# finished as long as this dependency exists
-graph-chain-arweave = { path = "../chain/arweave" }
 graph-chain-ethereum = { path = "../chain/ethereum" }
 graph-chain-near = { path = "../chain/near" }
-graph-chain-cosmos = { path = "../chain/cosmos" }
-graph-chain-substreams = { path = "../chain/substreams" }
-graph-chain-starknet = { path = "../chain/starknet" }
-lazy_static = "1.2.0"
-lru_time_cache = "0.11"
-semver = "1.0.21"
-serde = "1.0"
-serde_json = "1.0"
-serde_yaml = "0.9.21"
+graph-runtime-wasm = { path = "../runtime/wasm" }
+serde_yaml = { workspace = true }
+tokio = { workspace = true }
+tokio-retry = { workspace = true }
 # Switch to crates.io once tower 0.5 is released
 tower = { git = "https://github.com/tower-rs/tower.git", features = ["full"] }
-graph-runtime-wasm = { path = "../runtime/wasm" }
-cid = "0.11.0"
+thiserror = { workspace = true }
 anyhow = "1.0"
 
+# Dependencies related to Amp subgraphs
+alloy.workspace = true
+arrow.workspace = true
+chrono.workspace = true
+futures.workspace = true
+indoc.workspace = true
+itertools.workspace = true
+parking_lot.workspace = true
+prometheus.workspace = true
+slog.workspace = true
+strum.workspace = true
+tokio-util.workspace = true
+
 [dev-dependencies]
 tower-test = { git = "https://github.com/tower-rs/tower.git" }
-ipfs-api-backend-hyper = "0.6"
-ipfs-api = { version = "0.17.0", features = [
-    "with-hyper-rustls",
-], default-features = false }
-uuid = { version = "1.6.1", features = ["v4"] }
+wiremock = "0.6.5"
+
+[lints]
+workspace = true
diff --git a/core/graphman/Cargo.toml b/core/graphman/Cargo.toml
new file mode 100644
index 00000000000..858cc1b9012
--- /dev/null
+++ b/core/graphman/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "graphman"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+diesel = { workspace = true }
+diesel-async = { workspace = true }
+graph = { workspace = true }
+graph-store-postgres = { workspace = true }
+graphman-store = { workspace = true }
+itertools = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
diff --git a/core/graphman/src/commands/deployment/info.rs b/core/graphman/src/commands/deployment/info.rs
new file mode 100644
index 00000000000..155a821d715
--- /dev/null
+++ b/core/graphman/src/commands/deployment/info.rs
@@ -0,0 +1,82 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use graph::blockchain::BlockPtr;
+use graph::components::store::BlockNumber;
+use graph::components::store::DeploymentId;
+use graph::components::store::StatusStore;
+use graph::data::subgraph::schema::SubgraphHealth;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::Store;
+use itertools::Itertools;
+
+use crate::GraphmanError;
+use crate::deployment::Deployment;
+use crate::deployment::DeploymentSelector;
+use crate::deployment::DeploymentVersionSelector;
+
+#[derive(Clone, Debug)]
+pub struct DeploymentStatus {
+    pub is_paused: Option<bool>,
+    pub is_synced: bool,
+    pub health: SubgraphHealth,
+    pub earliest_block_number: BlockNumber,
+    pub latest_block: Option<BlockPtr>,
+    pub chain_head_block: Option<BlockPtr>,
+}
+
+pub async fn load_deployments(
+    primary_pool: ConnectionPool,
+    deployment: &DeploymentSelector,
+    version: &DeploymentVersionSelector,
+) -> Result<Vec<Deployment>, GraphmanError> {
+    let mut primary_conn = primary_pool.get().await?;
+
+    crate::deployment::load_deployments(&mut primary_conn, deployment, version).await
+}
+
+pub async fn load_deployment_statuses(
+    store: Arc<Store>,
+    deployments: &[Deployment],
+) -> Result<HashMap<i32, DeploymentStatus>, GraphmanError> {
+    use graph::data::subgraph::status::Filter;
+
+    let deployment_ids = deployments
+        .iter()
+        .map(|deployment| DeploymentId::new(deployment.id))
+        .collect_vec();
+
+    let deployment_statuses = store
+        .status(Filter::DeploymentIds(deployment_ids))
+        .await?
+        .into_iter()
+        .map(|status| {
+            let id = status.id.0;
+
+            let chain = status
+                .chains
+                .first()
+                .ok_or_else(|| {
+                    GraphmanError::Store(anyhow!(
+                        "deployment status has no chains on deployment '{id}'"
+                    ))
+                })?
+                .to_owned();
+
+            Ok((
+                id,
+                DeploymentStatus {
+                    is_paused: status.paused,
+                    is_synced: status.synced,
+                    health: status.health,
+                    earliest_block_number: chain.earliest_block_number.to_owned(),
+                    latest_block: chain.latest_block.map(|x| x.to_ptr()),
+                    chain_head_block: chain.chain_head_block.map(|x| x.to_ptr()),
+                },
+            ))
+        })
+        .collect::<Result<_, GraphmanError>>()?;
+
+    Ok(deployment_statuses)
+}
diff --git a/core/graphman/src/commands/deployment/mod.rs b/core/graphman/src/commands/deployment/mod.rs
new file mode 100644
index 00000000000..4cac2277bbe
--- /dev/null
+++ b/core/graphman/src/commands/deployment/mod.rs
@@ -0,0 +1,5 @@
+pub mod info;
+pub mod pause;
+pub mod reassign;
+pub mod resume;
+pub mod unassign;
diff --git a/core/graphman/src/commands/deployment/pause.rs b/core/graphman/src/commands/deployment/pause.rs
new file mode 100644
index 00000000000..e2405b5f68b
--- /dev/null
+++ b/core/graphman/src/commands/deployment/pause.rs
@@ -0,0 +1,91 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use graph::components::store::DeploymentLocator;
+use graph::components::store::StoreEvent;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graph_store_postgres::command_support::catalog;
+use graph_store_postgres::command_support::catalog::Site;
+use thiserror::Error;
+
+use crate::GraphmanError;
+use crate::deployment::DeploymentSelector;
+use crate::deployment::DeploymentVersionSelector;
+
+pub struct ActiveDeployment {
+    locator: DeploymentLocator,
+    site: Site,
+}
+
+#[derive(Debug, Error)]
+pub enum PauseDeploymentError {
+    #[error("deployment '{0}' is already paused")]
+    AlreadyPaused(String),
+
+    #[error(transparent)]
+    Common(#[from] GraphmanError),
+}
+
+impl ActiveDeployment {
+    pub fn locator(&self) -> &DeploymentLocator {
+        &self.locator
+    }
+}
+
+pub async fn load_active_deployment(
+    primary_pool: ConnectionPool,
+    deployment: &DeploymentSelector,
+) -> Result<ActiveDeployment, PauseDeploymentError> {
+    let mut primary_conn = primary_pool
+        .get_permitted()
+        .await
+        .map_err(GraphmanError::from)?;
+
+    let locator = crate::deployment::load_deployment_locator(
+        &mut primary_conn,
+        deployment,
+        &DeploymentVersionSelector::All,
+    )
+    .await?;
+
+    let mut catalog_conn = catalog::Connection::new(primary_conn);
+
+    let site = catalog_conn
+        .locate_site(locator.clone())
+        .await
+        .map_err(GraphmanError::from)?
+        .ok_or_else(|| {
+            GraphmanError::Store(anyhow!("deployment site not found for '{locator}'"))
+        })?;
+
+    let (_, is_paused) = catalog_conn
+        .assignment_status(&site)
+        .await
+        .map_err(GraphmanError::from)?
+        .ok_or_else(|| {
+            GraphmanError::Store(anyhow!("assignment status not found for '{locator}'"))
+        })?;
+
+    if is_paused {
+        return Err(PauseDeploymentError::AlreadyPaused(locator.to_string()));
+    }
+
+    Ok(ActiveDeployment { locator, site })
+}
+
+pub async fn pause_active_deployment(
+    primary_pool: ConnectionPool,
+    notification_sender: Arc<NotificationSender>,
+    active_deployment: ActiveDeployment,
+) -> Result<(), GraphmanError> {
+    let primary_conn = primary_pool.get_permitted().await?;
+    let mut catalog_conn = catalog::Connection::new(primary_conn);
+
+    let changes = catalog_conn.pause_subgraph(&active_deployment.site).await?;
+    catalog_conn
+        .send_store_event(&notification_sender, &StoreEvent::new(changes))
+        .await?;
+
+    Ok(())
+}
diff --git a/core/graphman/src/commands/deployment/reassign.rs b/core/graphman/src/commands/deployment/reassign.rs
new file mode 100644
index 00000000000..f4279946917
--- /dev/null
+++ b/core/graphman/src/commands/deployment/reassign.rs
@@ -0,0 +1,145 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use graph::components::store::DeploymentLocator;
+use graph::components::store::StoreEvent;
+use graph::prelude::AssignmentChange;
+use graph::prelude::NodeId;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graph_store_postgres::command_support::catalog;
+use graph_store_postgres::command_support::catalog::Site;
+use thiserror::Error;
+
+use crate::GraphmanError;
+use crate::deployment::DeploymentSelector;
+use crate::deployment::DeploymentVersionSelector;
+
+pub struct Deployment {
+    locator: DeploymentLocator,
+    site: Site,
+}
+
+impl Deployment {
+    pub fn locator(&self) -> &DeploymentLocator {
+        &self.locator
+    }
+
+    pub async fn assigned_node(
+        &self,
+        primary_pool: ConnectionPool,
+    ) -> Result<Option<NodeId>, GraphmanError> {
+        let primary_conn = primary_pool
+            .get_permitted()
+            .await
+            .map_err(GraphmanError::from)?;
+        let mut catalog_conn = catalog::Connection::new(primary_conn);
+        let node = catalog_conn
+            .assigned_node(&self.site)
+            .await
+            .map_err(GraphmanError::from)?;
+        Ok(node)
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum ReassignDeploymentError {
+    #[error("deployment '{0}' is already assigned to '{1}'")]
+    AlreadyAssigned(String, String),
+
+    #[error(transparent)]
+    Common(#[from] GraphmanError),
+}
+
+#[derive(Clone, Debug)]
+pub enum ReassignResult {
+    Ok,
+    CompletedWithWarnings(Vec<String>),
+}
+
+pub async fn load_deployment(
+    primary_pool: ConnectionPool,
+    deployment: &DeploymentSelector,
+) -> Result<Deployment, ReassignDeploymentError> {
+    let mut primary_conn = primary_pool
+        .get_permitted()
+        .await
+        .map_err(GraphmanError::from)?;
+
+    let locator = crate::deployment::load_deployment_locator(
+        &mut primary_conn,
+        deployment,
+        &DeploymentVersionSelector::All,
+    )
+    .await?;
+
+    let mut catalog_conn = catalog::Connection::new(primary_conn);
+
+    let site = catalog_conn
+        .locate_site(locator.clone())
+        .await
+        .map_err(GraphmanError::from)?
+        .ok_or_else(|| {
+            GraphmanError::Store(anyhow!("deployment site not found for '{locator}'"))
+        })?;
+
+    Ok(Deployment { locator, site })
+}
+
+pub async fn reassign_deployment(
+    primary_pool: ConnectionPool,
+    notification_sender: Arc<NotificationSender>,
+    deployment: &Deployment,
+    node: &NodeId,
+    curr_node: Option<NodeId>,
+) -> Result<ReassignResult, ReassignDeploymentError> {
+    let primary_conn = primary_pool
+        .get_permitted()
+        .await
+        .map_err(GraphmanError::from)?;
+    let mut catalog_conn = catalog::Connection::new(primary_conn);
+    let changes: Vec<AssignmentChange> = match &curr_node {
+        Some(curr) => {
+            if curr == node {
+                vec![]
+            } else {
+                catalog_conn
+                    .reassign_subgraph(&deployment.site, node)
+                    .await
+                    .map_err(GraphmanError::from)?
+            }
+        }
+        None => catalog_conn
+            .assign_subgraph(&deployment.site, node)
+            .await
+            .map_err(GraphmanError::from)?,
+    };
+
+    if changes.is_empty() {
+        return Err(ReassignDeploymentError::AlreadyAssigned(
+            deployment.locator.to_string(),
+            node.to_string(),
+        ));
+    }
+
+    catalog_conn
+        .send_store_event(&notification_sender, &StoreEvent::new(changes))
+        .await
+        .map_err(GraphmanError::from)?;
+
+    let mirror = catalog::Mirror::primary_only(primary_pool);
+    let count = mirror
+        .assignments(node)
+        .await
+        .map_err(GraphmanError::from)?
+        .len();
+    if count == 1 {
+        let warning_msg = format!(
+            "This is the only deployment assigned to '{}'. Please make sure that the node ID is spelled correctly.",
+            node.as_str()
+        );
+        Ok(ReassignResult::CompletedWithWarnings(vec![warning_msg]))
+    } else {
+        Ok(ReassignResult::Ok)
+    }
+}
diff --git a/core/graphman/src/commands/deployment/resume.rs b/core/graphman/src/commands/deployment/resume.rs
new file mode 100644
index 00000000000..4fa0162f83e
--- /dev/null
+++ b/core/graphman/src/commands/deployment/resume.rs
@@ -0,0 +1,93 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use graph::components::store::DeploymentLocator;
+use graph::prelude::StoreEvent;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graph_store_postgres::command_support::catalog;
+use graph_store_postgres::command_support::catalog::Site;
+use thiserror::Error;
+
+use crate::GraphmanError;
+use crate::deployment::DeploymentSelector;
+use crate::deployment::DeploymentVersionSelector;
+
+pub struct PausedDeployment {
+    locator: DeploymentLocator,
+    site: Site,
+}
+
+#[derive(Debug, Error)]
+pub enum ResumeDeploymentError {
+    #[error("deployment '{0}' is not paused")]
+    NotPaused(String),
+
+    #[error(transparent)]
+    Common(#[from] GraphmanError),
+}
+
+impl PausedDeployment {
+    pub fn locator(&self) -> &DeploymentLocator {
+        &self.locator
+    }
+}
+
+pub async fn load_paused_deployment(
+    primary_pool: ConnectionPool,
+    deployment: &DeploymentSelector,
+) -> Result<PausedDeployment, ResumeDeploymentError> {
+    let mut primary_conn = primary_pool
+        .get_permitted()
+        .await
+        .map_err(GraphmanError::from)?;
+
+    let locator = crate::deployment::load_deployment_locator(
+        &mut primary_conn,
+        deployment,
+        &DeploymentVersionSelector::All,
+    )
+    .await?;
+
+    let mut catalog_conn = catalog::Connection::new(primary_conn);
+
+    let site = catalog_conn
+        .locate_site(locator.clone())
+        .await
+        .map_err(GraphmanError::from)?
+        .ok_or_else(|| {
+            GraphmanError::Store(anyhow!("deployment site not found for '{locator}'"))
+        })?;
+
+    let (_, is_paused) = catalog_conn
+        .assignment_status(&site)
+        .await
+        .map_err(GraphmanError::from)?
+        .ok_or_else(|| {
+            GraphmanError::Store(anyhow!("assignment status not found for '{locator}'"))
+        })?;
+
+    if !is_paused {
+        return Err(ResumeDeploymentError::NotPaused(locator.to_string()));
+    }
+
+    Ok(PausedDeployment { locator, site })
+}
+
+pub async fn resume_paused_deployment(
+    primary_pool: ConnectionPool,
+    notification_sender: Arc<NotificationSender>,
+    paused_deployment: PausedDeployment,
+) -> Result<(), GraphmanError> {
+    let primary_conn = primary_pool.get_permitted().await?;
+    let mut catalog_conn = catalog::Connection::new(primary_conn);
+
+    let changes = catalog_conn
+        .resume_subgraph(&paused_deployment.site)
+        .await?;
+    catalog_conn
+        .send_store_event(&notification_sender, &StoreEvent::new(changes))
+        .await?;
+
+    Ok(())
+}
diff --git a/core/graphman/src/commands/deployment/unassign.rs b/core/graphman/src/commands/deployment/unassign.rs
new file mode 100644
index 00000000000..cef72e947f1
--- /dev/null
+++ b/core/graphman/src/commands/deployment/unassign.rs
@@ -0,0 +1,88 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use graph::components::store::DeploymentLocator;
+use graph::components::store::StoreEvent;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graph_store_postgres::command_support::catalog;
+use graph_store_postgres::command_support::catalog::Site;
+use thiserror::Error;
+
+use crate::GraphmanError;
+use crate::deployment::DeploymentSelector;
+use crate::deployment::DeploymentVersionSelector;
+
+pub struct AssignedDeployment {
+    locator: DeploymentLocator,
+    site: Site,
+}
+
+impl AssignedDeployment {
+    pub fn locator(&self) -> &DeploymentLocator {
+        &self.locator
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum UnassignDeploymentError {
+    #[error("deployment '{0}' is already unassigned")]
+    AlreadyUnassigned(String),
+
+    #[error(transparent)]
+    Common(#[from] GraphmanError),
+}
+
+pub async fn load_assigned_deployment(
+    primary_pool: ConnectionPool,
+    deployment: &DeploymentSelector,
+) -> Result<AssignedDeployment, UnassignDeploymentError> {
+    let mut primary_conn = primary_pool
+        .get_permitted()
+        .await
+        .map_err(GraphmanError::from)?;
+
+    let locator = crate::deployment::load_deployment_locator(
+        &mut primary_conn,
+        deployment,
+        &DeploymentVersionSelector::All,
+    )
+    .await?;
+
+    let mut catalog_conn = catalog::Connection::new(primary_conn);
+
+    let site = catalog_conn
+        .locate_site(locator.clone())
+        .await
+        .map_err(GraphmanError::from)?
+        .ok_or_else(|| {
+            GraphmanError::Store(anyhow!("deployment site not found for '{locator}'"))
+        })?;
+
+    match catalog_conn
+        .assigned_node(&site)
+        .await
+        .map_err(GraphmanError::from)?
+    {
+        Some(_) => Ok(AssignedDeployment { locator, site }),
+        None => Err(UnassignDeploymentError::AlreadyUnassigned(
+            locator.to_string(),
+        )),
+    }
+}
+
+pub async fn unassign_deployment(
+    primary_pool: ConnectionPool,
+    notification_sender: Arc<NotificationSender>,
+    deployment: AssignedDeployment,
+) -> Result<(), GraphmanError> {
+    let primary_conn = primary_pool.get_permitted().await?;
+    let mut catalog_conn = catalog::Connection::new(primary_conn);
+
+    let changes = catalog_conn.unassign_subgraph(&deployment.site).await?;
+    catalog_conn
+        .send_store_event(&notification_sender, &StoreEvent::new(changes))
+        .await?;
+
+    Ok(())
+}
diff --git a/core/graphman/src/commands/mod.rs b/core/graphman/src/commands/mod.rs
new file mode 100644
index 00000000000..98629027b58
--- /dev/null
+++ b/core/graphman/src/commands/mod.rs
@@ -0,0 +1 @@
+pub mod deployment;
diff --git a/core/graphman/src/deployment.rs b/core/graphman/src/deployment.rs
new file mode 100644
index 00000000000..6538017edaa
--- /dev/null
+++ b/core/graphman/src/deployment.rs
@@ -0,0 +1,157 @@
+use anyhow::anyhow;
+use diesel::BoolExpressionMethods;
+use diesel::ExpressionMethods;
+use diesel::JoinOnDsl;
+use diesel::NullableExpressionMethods;
+use diesel::PgTextExpressionMethods;
+use diesel::QueryDsl;
+use diesel::Queryable;
+use diesel::dsl::sql;
+use diesel::sql_types::Text;
+use diesel_async::RunQueryDsl;
+use graph::components::store::DeploymentId;
+use graph::components::store::DeploymentLocator;
+use graph::data::subgraph::DeploymentHash;
+use graph_store_postgres::AsyncPgConnection;
+use graph_store_postgres::command_support::catalog;
+use itertools::Itertools;
+
+use crate::GraphmanError;
+
+#[derive(Clone, Debug, Queryable)]
+pub struct Deployment {
+    pub id: i32,
+    pub hash: String,
+    pub namespace: String,
+    pub name: String,
+    pub node_id: Option<String>,
+    pub shard: String,
+    pub chain: String,
+    pub version_status: String,
+    pub is_active: bool,
+}
+
+#[derive(Clone, Debug)]
+pub enum DeploymentSelector {
+    Name(String),
+    Subgraph { hash: String, shard: Option<String> },
+    Schema(String),
+    All,
+}
+
+#[derive(Clone, Debug)]
+pub enum DeploymentVersionSelector {
+    Current,
+    Pending,
+    Used,
+    All,
+}
+
+impl Deployment {
+    pub fn locator(&self) -> DeploymentLocator {
+        DeploymentLocator::new(
+            DeploymentId::new(self.id),
+            DeploymentHash::new(self.hash.clone()).unwrap(),
+        )
+    }
+}
+
+pub(crate) async fn load_deployments(
+    primary_conn: &mut AsyncPgConnection,
+    deployment: &DeploymentSelector,
+    version: &DeploymentVersionSelector,
+) -> Result<Vec<Deployment>, GraphmanError> {
+    use catalog::deployment_schemas as ds;
+    use catalog::subgraph as sg;
+    use catalog::subgraph_deployment_assignment as sgda;
+    use catalog::subgraph_version as sgv;
+
+    let mut query = ds::table
+        .inner_join(sgv::table.on(sgv::deployment.eq(ds::subgraph)))
+        .inner_join(sg::table.on(sgv::subgraph.eq(sg::id)))
+        .left_outer_join(sgda::table.on(sgda::id.eq(ds::id)))
+        .select((
+            ds::id,
+            sgv::deployment,
+            ds::name,
+            sg::name,
+            sgda::node_id.nullable(),
+            ds::shard,
+            ds::network,
+            sql::<Text>(
+                "(
+                    case
+                        when subgraphs.subgraph.pending_version = subgraphs.subgraph_version.id
+                            then 'pending'
+                        when subgraphs.subgraph.current_version = subgraphs.subgraph_version.id
+                            then 'current'
+                    else
+                        'unused'
+                    end
+                 ) status",
+            ),
+            ds::active,
+        ))
+        .into_boxed();
+
+    match deployment {
+        DeploymentSelector::Name(name) => {
+            let pattern = format!("%{}%", name.replace("%", ""));
+            query = query.filter(sg::name.ilike(pattern));
+        }
+        DeploymentSelector::Subgraph { hash, shard } => {
+            query = query.filter(ds::subgraph.eq(hash));
+
+            if let Some(shard) = shard {
+                query = query.filter(ds::shard.eq(shard));
+            }
+        }
+        DeploymentSelector::Schema(name) => {
+            query = query.filter(ds::name.eq(name));
+        }
+        DeploymentSelector::All => {
+            // No query changes required.
+        }
+    };
+
+    let current_version_filter = sg::current_version.eq(sgv::id.nullable());
+    let pending_version_filter = sg::pending_version.eq(sgv::id.nullable());
+
+    match version {
+        DeploymentVersionSelector::Current => {
+            query = query.filter(current_version_filter);
+        }
+        DeploymentVersionSelector::Pending => {
+            query = query.filter(pending_version_filter);
+        }
+        DeploymentVersionSelector::Used => {
+            query = query.filter(current_version_filter.or(pending_version_filter));
+        }
+        DeploymentVersionSelector::All => {
+            // No query changes required.
+        }
+    }
+
+    query.load(primary_conn).await.map_err(Into::into)
+}
+
+pub(crate) async fn load_deployment_locator(
+    primary_conn: &mut AsyncPgConnection,
+    deployment: &DeploymentSelector,
+    version: &DeploymentVersionSelector,
+) -> Result<DeploymentLocator, GraphmanError> {
+    let deployment_locator = load_deployments(primary_conn, deployment, version)
+        .await?
+        .into_iter()
+        .map(|deployment| deployment.locator())
+        .unique()
+        .exactly_one()
+        .map_err(|err| {
+            let count = err.into_iter().count();
+            GraphmanError::Store(anyhow!(
+                "expected exactly one deployment for '{deployment:?}', found {count}"
+            ))
+        })?;
+
+    Ok(deployment_locator)
+}
diff --git a/core/graphman/src/error.rs b/core/graphman/src/error.rs
new file mode 100644
index 00000000000..731b2574f0e
--- /dev/null
+++ b/core/graphman/src/error.rs
@@ -0,0 +1,19 @@
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum GraphmanError {
+    #[error("store error: {0:#}")]
+    Store(#[source] anyhow::Error),
+}
+
+impl From<graph::components::store::StoreError> for GraphmanError {
+    fn from(err: graph::components::store::StoreError) -> Self {
+        Self::Store(err.into())
+    }
+}
+
+impl From<diesel::result::Error> for GraphmanError {
+    fn from(err: diesel::result::Error) -> Self {
+        Self::Store(err.into())
+    }
+}
diff --git a/core/graphman/src/execution_tracker.rs b/core/graphman/src/execution_tracker.rs
new file mode 100644
index 00000000000..806d78defed
--- /dev/null
+++ b/core/graphman/src/execution_tracker.rs
@@ -0,0 +1,86 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::Result;
+use graphman_store::ExecutionId;
+use graphman_store::GraphmanStore;
+use tokio::sync::Notify;
+
+/// The execution status is updated at this interval.
+const DEFAULT_HEARTBEAT_INTERVAL: Duration = Duration::from_secs(20);
+
+/// Used with long-running command executions to maintain their status as active.
+pub struct GraphmanExecutionTracker<S> {
+    id: ExecutionId,
+    heartbeat_stopper: Arc<Notify>,
+    store: Arc<S>,
+}
+
+impl<S> GraphmanExecutionTracker<S>
+where
+    S: GraphmanStore + Send + Sync + 'static,
+{
+    /// Creates a new execution tracker that spawns a separate background task that keeps
+    /// the execution active by periodically updating its status.
+    pub fn new(store: Arc<S>, id: ExecutionId) -> Self {
+        let heartbeat_stopper = Arc::new(Notify::new());
+
+        let tracker = Self {
+            id,
+            store,
+            heartbeat_stopper,
+        };
+
+        tracker.spawn_heartbeat();
+        tracker
+    }
+
+    fn spawn_heartbeat(&self) {
+        let id = self.id;
+        let heartbeat_stopper = self.heartbeat_stopper.clone();
+        let store = self.store.clone();
+
+        graph::spawn(async move {
+            store.mark_execution_as_running(id).await.unwrap();
+
+            let stop_heartbeat = heartbeat_stopper.notified();
+            tokio::pin!(stop_heartbeat);
+
+            loop {
+                tokio::select! {
+                    biased;
+
+                    _ = &mut stop_heartbeat => {
+                        break;
+                    },
+
+                    _ = tokio::time::sleep(DEFAULT_HEARTBEAT_INTERVAL) => {
+                        store.mark_execution_as_running(id).await.unwrap();
+                    },
+                }
+            }
+        });
+    }
+
+    /// Completes the execution with an error.
+    pub async fn track_failure(self, error_message: String) -> Result<()> {
+        self.heartbeat_stopper.notify_one();
+
+        self.store
+            .mark_execution_as_failed(self.id, error_message)
+            .await
+    }
+
+    /// Completes the execution with a success.
+    pub async fn track_success(self) -> Result<()> {
+        self.heartbeat_stopper.notify_one();
+
+        self.store.mark_execution_as_succeeded(self.id).await
+    }
+}
+
+impl<S> Drop for GraphmanExecutionTracker<S> {
+    fn drop(&mut self) {
+        self.heartbeat_stopper.notify_one();
+    }
+}
diff --git a/core/graphman/src/lib.rs b/core/graphman/src/lib.rs
new file mode 100644
index 00000000000..71f8e77a848
--- /dev/null
+++ b/core/graphman/src/lib.rs
@@ -0,0 +1,15 @@
+//! This crate contains graphman commands that can be executed via
+//! the GraphQL API as well as via the CLI.
+//!
+//! Each command is broken into small execution steps to allow different interfaces to perform
+//! some additional interface-specific operations between steps. An example of this is printing
+//! intermediate information to the user in the CLI, or prompting for additional input.
+
+mod error;
+
+pub mod commands;
+pub mod deployment;
+pub mod execution_tracker;
+
+pub use self::error::GraphmanError;
+pub use self::execution_tracker::GraphmanExecutionTracker;
diff --git a/core/graphman_store/Cargo.toml b/core/graphman_store/Cargo.toml
new file mode 100644
index 00000000000..fee9daff663
--- /dev/null
+++ b/core/graphman_store/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "graphman-store"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+chrono = { workspace = true }
+diesel = { workspace = true }
+strum = { workspace = true }
diff --git a/core/graphman_store/src/lib.rs b/core/graphman_store/src/lib.rs
new file mode 100644
index 00000000000..8b1965df7cd
--- /dev/null
+++ b/core/graphman_store/src/lib.rs
@@ -0,0 +1,129 @@
+//! This crate allows graphman commands to store data in a persistent storage.
+//!
+//! Note: The trait is extracted as a separate crate to avoid cyclic dependencies between graphman
+//!       commands and store implementations.
+
+use anyhow::Result;
+use async_trait::async_trait;
+use chrono::DateTime;
+use chrono::Utc;
+use diesel::AsExpression;
+use diesel::FromSqlRow;
+use diesel::Queryable;
+use diesel::deserialize::FromSql;
+use diesel::pg::Pg;
+use diesel::pg::PgValue;
+use diesel::serialize::Output;
+use diesel::serialize::ToSql;
+use diesel::sql_types::BigSerial;
+use diesel::sql_types::Varchar;
+use strum::Display;
+use strum::EnumString;
+use strum::IntoStaticStr;
+
+/// Describes all the capabilities that graphman commands need from a persistent storage.
+///
+/// The primary use case for this is background execution of commands.
+#[async_trait]
+pub trait GraphmanStore {
+    /// Creates a new pending execution of the specified type.
+    /// The implementation is expected to manage execution IDs and return unique IDs on each call.
+    ///
+    /// Creating a new execution does not mean that a command is actually running or will run.
+    async fn new_execution(&self, kind: CommandKind) -> Result<ExecutionId>;
+
+    /// Returns all stored execution data.
+    async fn load_execution(&self, id: ExecutionId) -> Result<Execution>;
+
+    /// When an execution begins to make progress, this method is used to update its status.
+    ///
+    /// For long-running commands, it is expected that this method will be called at some interval
+    /// to show that the execution is still making progress.
+    ///
+    /// The implementation is expected to not allow updating the status of completed executions.
+    async fn mark_execution_as_running(&self, id: ExecutionId) -> Result<()>;
+
+    /// This is a finalizing operation and is expected to be called only once,
+    /// when an execution fails.
+    ///
+    /// The implementation is not expected to prevent overriding the final state of an execution.
+    async fn mark_execution_as_failed(&self, id: ExecutionId, error_message: String) -> Result<()>;
+
+    /// This is a finalizing operation and is expected to be called only once,
+    /// when an execution succeeds.
+    ///
+    /// The implementation is not expected to prevent overriding the final state of an execution.
+    async fn mark_execution_as_succeeded(&self, id: ExecutionId) -> Result<()>;
+}
+
+/// Data stored about a command execution.
+#[derive(Clone, Debug, Queryable)]
+pub struct Execution {
+    pub id: ExecutionId,
+    pub kind: CommandKind,
+    pub status: ExecutionStatus,
+    pub error_message: Option<String>,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: Option<DateTime<Utc>>,
+    pub completed_at: Option<DateTime<Utc>>,
+}
+
+/// A unique ID of a command execution.
+#[derive(Clone, Copy, Debug, AsExpression, FromSqlRow)]
+#[diesel(sql_type = BigSerial)]
+pub struct ExecutionId(pub i64);
+
+/// Types of commands that can store data about their execution.
+#[derive(Clone, Copy, Debug, AsExpression, FromSqlRow, Display, IntoStaticStr, EnumString)]
+#[diesel(sql_type = Varchar)]
+#[strum(serialize_all = "snake_case")]
+pub enum CommandKind {
+    RestartDeployment,
+}
+
+/// All possible states of a command execution.
+#[derive(Clone, Copy, Debug, AsExpression, FromSqlRow, Display, IntoStaticStr, EnumString)]
+#[diesel(sql_type = Varchar)]
+#[strum(serialize_all = "snake_case")]
+pub enum ExecutionStatus {
+    Initializing,
+    Running,
+    Failed,
+    Succeeded,
+}
+
+impl FromSql<BigSerial, Pg> for ExecutionId {
+    fn from_sql(bytes: PgValue) -> diesel::deserialize::Result<Self> {
+        Ok(ExecutionId(i64::from_sql(bytes)?))
+    }
+}
+
+impl ToSql<BigSerial, Pg> for ExecutionId {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
+        <i64 as ToSql<BigSerial, Pg>>::to_sql(&self.0, &mut out.reborrow())
+    }
+}
+
+impl FromSql<Varchar, Pg> for CommandKind {
+    fn from_sql(bytes: PgValue) -> diesel::deserialize::Result<Self> {
+        Ok(std::str::from_utf8(bytes.as_bytes())?.parse()?)
+    }
+}
+
+impl ToSql<Varchar, Pg> for CommandKind {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
+        <str as ToSql<Varchar, Pg>>::to_sql(self.into(), &mut out.reborrow())
+    }
+}
+
+impl FromSql<Varchar, Pg> for ExecutionStatus {
+    fn from_sql(bytes: PgValue) -> diesel::deserialize::Result<Self> {
+        Ok(std::str::from_utf8(bytes.as_bytes())?.parse()?)
+    }
+}
+
+impl ToSql<Varchar, Pg> for ExecutionStatus {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
+        <str as ToSql<Varchar, Pg>>::to_sql(self.into(), &mut out.reborrow())
+    }
+}
diff --git a/core/src/amp_subgraph/manager.rs b/core/src/amp_subgraph/manager.rs
new file mode 100644
index 00000000000..61ec421ca17
--- /dev/null
+++ b/core/src/amp_subgraph/manager.rs
@@ -0,0 +1,171 @@
+use std::sync::Arc;
+
+use alloy::primitives::BlockNumber;
+use anyhow::Context;
+use async_trait::async_trait;
+use graph::{
+    amp,
+    components::{
+        link_resolver::{LinkResolver, LinkResolverContext},
+        metrics::MetricsRegistry,
+        store::{DeploymentLocator, SubgraphStore},
+        subgraph::SubgraphInstanceManager,
+    },
+    env::EnvVars,
+    log::factory::LoggerFactory,
+    prelude::CheapClone,
+};
+use slog::{debug, error};
+use tokio_util::sync::CancellationToken;
+
+use super::{Metrics, Monitor, runner};
+
+/// Manages Amp subgraph runner futures.
+///
+/// Creates and schedules Amp subgraph runner futures for execution on demand.
+/// Also handles stopping previously started Amp subgraph runners.
+pub struct Manager<SS, NC> {
+    logger_factory: LoggerFactory,
+    metrics_registry: Arc<MetricsRegistry>,
+    env_vars: Arc<EnvVars>,
+    monitor: Monitor,
+    subgraph_store: Arc<SS>,
+    link_resolver: Arc<dyn LinkResolver>,
+    amp_client: Arc<NC>,
+}
+
+impl<SS, NC> Manager<SS, NC>
+where
+    SS: SubgraphStore,
+    NC: amp::Client,
+{
+    /// Creates a new Amp subgraph manager.
+    pub fn new(
+        logger_factory: &LoggerFactory,
+        metrics_registry: Arc<MetricsRegistry>,
+        env_vars: Arc<EnvVars>,
+        cancel_token: &CancellationToken,
+        subgraph_store: Arc<SS>,
+        link_resolver: Arc<dyn LinkResolver>,
+        amp_client: Arc<NC>,
+    ) -> Self {
+        let logger = logger_factory.component_logger("AmpSubgraphManager", None);
+        let logger_factory = logger_factory.with_parent(logger);
+
+        let monitor = Monitor::new(&logger_factory, cancel_token);
+
+        Self {
+            logger_factory,
+            metrics_registry,
+            env_vars,
+            monitor,
+            subgraph_store,
+            link_resolver,
+            amp_client,
+        }
+    }
+}
+
+#[async_trait]
+impl<SS, NC> SubgraphInstanceManager for Manager<SS, NC>
+where
+    SS: SubgraphStore,
+    NC: amp::Client + Send + Sync + 'static,
+{
+    async fn start_subgraph(
+        self: Arc<Self>,
+        deployment: DeploymentLocator,
+        stop_block: Option<i32>,
+    ) {
+        let manager = self.cheap_clone();
+
+        self.monitor.start(
+            deployment.cheap_clone(),
+            Box::new(move |cancel_token| {
+                Box::pin(async move {
+                    let logger = manager.logger_factory.subgraph_logger(&deployment);
+
+                    let store = manager
+                        .subgraph_store
+                        .cheap_clone()
+                        .writable(logger.cheap_clone(), deployment.id, Vec::new().into())
+                        .await
+                        .context("failed to create writable store")?;
+
+                    let metrics = Metrics::new(
+                        &logger,
+                        manager.metrics_registry.cheap_clone(),
+                        store.cheap_clone(),
+                        deployment.hash.cheap_clone(),
+                    );
+
+                    let link_resolver = manager
+                        .link_resolver
+                        .for_manifest(&deployment.hash.to_string())
+                        .context("failed to create link resolver")?;
+
+                    let manifest_bytes = link_resolver
+                        .cat(
+                            &LinkResolverContext::new(&deployment.hash, &logger),
+                            &deployment.hash.to_ipfs_link(),
+                        )
+                        .await
+                        .context("failed to load subgraph manifest")?;
+
+                    let raw_manifest = serde_yaml::from_slice(&manifest_bytes)
+                        .context("failed to parse subgraph manifest")?;
+
+                    let mut manifest = amp::Manifest::resolve::<graph_chain_ethereum::Chain, _>(
+                        &logger,
+                        manager.link_resolver.cheap_clone(),
+                        manager.amp_client.cheap_clone(),
+                        manager.env_vars.max_spec_version.cheap_clone(),
+                        deployment.hash.cheap_clone(),
+                        raw_manifest,
+                    )
+                    .await?;
+
+                    if let Some(stop_block) = stop_block {
+                        for data_source in manifest.data_sources.iter_mut() {
+                            data_source.source.end_block = stop_block as BlockNumber;
+                        }
+                    }
+
+                    store
+                        .start_subgraph_deployment(&logger)
+                        .await
+                        .context("failed to start subgraph deployment")?;
+
+                    let runner_context = runner::Context::new(
+                        &logger,
+                        &manager.env_vars.amp,
+                        manager.amp_client.cheap_clone(),
+                        store,
+                        deployment.hash.cheap_clone(),
+                        manifest,
+                        metrics,
+                    );
+
+                    let runner_result = runner::new_runner(runner_context, cancel_token).await;
+
+                    match manager.subgraph_store.stop_subgraph(&deployment).await {
+                        Ok(()) => {
+                            debug!(logger, "Subgraph writer stopped");
+                        }
+                        Err(e) => {
+                            error!(logger, "Failed to stop subgraph writer";
+                                "e" => ?e
+                            );
+                        }
+                    }
+
+                    runner_result
+                })
+            }),
+        );
+    }
+
+    async fn stop_subgraph(&self, deployment: DeploymentLocator) {
+        self.monitor.stop(deployment);
+    }
+}
diff --git a/core/src/amp_subgraph/metrics.rs b/core/src/amp_subgraph/metrics.rs
new file mode 100644
index 00000000000..7088cf9a48f
--- /dev/null
+++ b/core/src/amp_subgraph/metrics.rs
@@ -0,0 +1,267 @@
+use std::{sync::Arc, time::Duration};
+
+use alloy::primitives::BlockNumber;
+use graph::{
+    cheap_clone::CheapClone,
+    components::{
+        metrics::{MetricsRegistry, stopwatch::StopwatchMetrics},
+        store::WritableStore,
+    },
+    prelude::DeploymentHash,
+};
+use indoc::indoc;
+use prometheus::{IntCounter, IntGauge};
+use slog::Logger;
+
+/// Contains metrics specific to a deployment.
+pub(super) struct Metrics {
+    pub(super) deployment_status: DeploymentStatus,
+    pub(super) deployment_head: DeploymentHead,
+    pub(super) deployment_target: DeploymentTarget,
+    pub(super) deployment_synced: DeploymentSynced,
+    pub(super) indexing_duration: IndexingDuration,
+    pub(super) blocks_processed: BlocksProcessed,
+    pub(super) stopwatch: StopwatchMetrics,
+}
+
+impl Metrics {
+    /// Creates new deployment specific metrics.
+    pub(super) fn new(
+        logger: &Logger,
+        metrics_registry: Arc<MetricsRegistry>,
+        store: Arc<dyn WritableStore>,
+        deployment: DeploymentHash,
+    ) -> Self {
+        let stopwatch = StopwatchMetrics::new(
+            logger.cheap_clone(),
+            deployment.cheap_clone(),
+            "process",
+            metrics_registry.cheap_clone(),
+            store.shard().to_string(),
+        );
+
+        let const_labels = [
+            ("deployment", deployment.to_string()),
+            ("shard", store.shard().to_string()),
+        ];
+
+        Self {
+            deployment_status: DeploymentStatus::new(&metrics_registry, const_labels.clone()),
+            deployment_head: DeploymentHead::new(&metrics_registry, const_labels.clone()),
+            deployment_target: DeploymentTarget::new(&metrics_registry, const_labels.clone()),
+            deployment_synced: DeploymentSynced::new(&metrics_registry, const_labels.clone()),
+            indexing_duration: IndexingDuration::new(&metrics_registry, const_labels.clone()),
+            blocks_processed: BlocksProcessed::new(&metrics_registry, const_labels.clone()),
+            stopwatch,
+        }
+    }
+}
+
+/// Reports the current indexing status of a deployment.
+pub(super) struct DeploymentStatus(IntGauge);
+
+impl DeploymentStatus {
+    const STATUS_STARTING: i64 = 1;
+    const STATUS_RUNNING: i64 = 2;
+    const STATUS_STOPPED: i64 = 3;
+    const STATUS_FAILED: i64 = 4;
+
+    fn new(
+        metrics_registry: &MetricsRegistry,
+        const_labels: impl IntoIterator<Item = (impl ToString, impl ToString)>,
+    ) -> Self {
+        let int_gauge = metrics_registry
+            .new_int_gauge(
+                "deployment_status",
+                indoc!(
+                    "
+                    Indicates the current indexing status of a deployment.
+                    Possible values:
+                    1 - graph-node is preparing to start indexing;
+                    2 - deployment is being indexed;
+                    3 - indexing is stopped by request;
+                    4 - indexing failed;
+                    "
+                ),
+                const_labels,
+            )
+            .expect("failed to register `deployment_status` gauge");
+
+        Self(int_gauge)
+    }
+
+    /// Records that the graph-node is preparing to start indexing.
+    pub fn starting(&self) {
+        self.0.set(Self::STATUS_STARTING);
+    }
+
+    /// Records that the deployment is being indexed.
+    pub fn running(&self) {
+        self.0.set(Self::STATUS_RUNNING);
+    }
+
+    /// Records that the indexing stopped by request.
+    pub fn stopped(&self) {
+        self.0.set(Self::STATUS_STOPPED);
+    }
+
+    /// Records that the indexing failed.
+    pub fn failed(&self) {
+        self.0.set(Self::STATUS_FAILED);
+    }
+}
+
+/// Tracks the most recent block number processed by a deployment.
+pub(super) struct DeploymentHead(IntGauge);
+
+impl DeploymentHead {
+    fn new(
+        metrics_registry: &MetricsRegistry,
+        const_labels: impl IntoIterator<Item = (impl ToString, impl ToString)>,
+    ) -> Self {
+        let int_gauge = metrics_registry
+            .new_int_gauge(
+                "deployment_head",
+                "Tracks the most recent block number processed by a deployment",
+                const_labels
+                    .into_iter()
+                    .map(|(k, v)| (k.to_string(), v.to_string()))
+                    // TODO: Pass the network from the Amp manifest
+                    .chain([("network".to_string(), "".to_string())]),
+            )
+            .expect("failed to register `deployment_head` gauge");
+
+        Self(int_gauge)
+    }
+
+    /// Updates the most recent block number processed by this deployment.
+    pub(super) fn update(&self, new_most_recent_block_number: BlockNumber) {
+        self.0.set(
+            i64::try_from(new_most_recent_block_number)
+                .expect("new most recent block number does not fit into `i64`"),
+        );
+    }
+}
+
+/// Tracks the maximum block number currently available for indexing within a deployment.
+pub(super) struct DeploymentTarget(IntGauge);
+
+impl DeploymentTarget {
+    fn new(
+        metrics_registry: &MetricsRegistry,
+        const_labels: impl IntoIterator<Item = (impl ToString, impl ToString)>,
+    ) -> Self {
+        let int_gauge = metrics_registry
+            .new_int_gauge(
+                "deployment_target",
+                "Tracks the maximum block number currently available for indexing within a deployment",
+                const_labels,
+            )
+            .expect("failed to register `amp_deployment_target` gauge");
+
+        Self(int_gauge)
+    }
+
+    /// Updates the target block number of this deployment.
+    pub(super) fn update(&self, new_target_block_number: BlockNumber) {
+        self.0.set(
+            i64::try_from(new_target_block_number)
+                .expect("new target block number does not fit into `i64`"),
+        );
+    }
+}
+
+/// Indicates whether a deployment has reached the chain head or the end block since it was deployed.
+pub(super) struct DeploymentSynced(IntGauge);
+
+impl DeploymentSynced {
+    const NOT_SYNCED: i64 = 0;
+    const SYNCED: i64 = 1;
+
+    pub fn new(
+        metrics_registry: &MetricsRegistry,
+        const_labels: impl IntoIterator<Item = (impl ToString, impl ToString)>,
+    ) -> Self {
+        let int_gauge = metrics_registry
+            .new_int_gauge(
+                "deployment_synced",
+                indoc!(
+                    "
+                    Indicates whether a deployment has reached the chain head or the end block since it was deployed.
+                    Possible values:
+                    0 - deployment is not synced;
+                    1 - deployment is synced;
+                    "
+                ),
+                const_labels,
+            )
+            .expect("failed to register `deployment_synced` gauge");
+
+        Self(int_gauge)
+    }
+
+    /// Records the current sync status of this deployment.
+    pub fn record(&self, synced: bool) {
+        self.0.set(if synced {
+            Self::SYNCED
+        } else {
+            Self::NOT_SYNCED
+        });
+    }
+}
+
+/// Tracks the total duration in seconds of deployment indexing.
+#[derive(Clone)]
+pub(super) struct IndexingDuration(IntCounter);
+
+impl IndexingDuration {
+    fn new(
+        metrics_registry: &MetricsRegistry,
+        const_labels: impl IntoIterator<Item = (impl ToString, impl ToString)>,
+    ) -> Self {
+        let int_counter = metrics_registry
+            .new_int_counter(
+                "deployment_indexing_duration_seconds",
+                "Tracks the total duration in seconds of deployment indexing",
+                const_labels,
+            )
+            .expect("failed to register `amp_deployment_indexing_duration_seconds` counter");
+
+        Self(int_counter)
+    }
+
+    /// Records a new indexing duration of this deployment.
+    pub(super) fn record(&self, duration: Duration) {
+        self.0.inc_by(duration.as_secs())
+    }
+}
+
+/// Tracks the total number of blocks processed by a deployment.
+pub(super) struct BlocksProcessed(IntCounter);
+
+impl BlocksProcessed {
+    fn new(
+        metrics_registry: &MetricsRegistry,
+        const_labels: impl IntoIterator<Item = (impl ToString, impl ToString)>,
+    ) -> Self {
+        let int_counter = metrics_registry
+            .new_int_counter(
+                "deployment_blocks_processed_count",
+                "Tracks the total number of blocks processed by a deployment",
+                const_labels,
+            )
+            .expect("failed to register `deployment_blocks_processed_count` counter");
+
+        Self(int_counter)
+    }
+
+    /// Records a new processed block.
+    pub(super) fn record_one(&self) {
+        self.record(1);
+    }
+
+    /// Records the new processed blocks.
+    pub(super) fn record(&self, number_of_blocks_processed: usize) {
+        self.0.inc_by(number_of_blocks_processed as u64);
+    }
+}
diff --git a/core/src/amp_subgraph/mod.rs b/core/src/amp_subgraph/mod.rs
new file mode 100644
index 00000000000..3d3846742aa
--- /dev/null
+++ b/core/src/amp_subgraph/mod.rs
@@ -0,0 +1,8 @@
+mod manager;
+mod metrics;
+mod monitor;
+mod runner;
+
+use self::{metrics::Metrics, monitor::Monitor};
+
+pub use self::manager::Manager;
diff --git a/core/src/amp_subgraph/monitor.rs b/core/src/amp_subgraph/monitor.rs
new file mode 100644
index 00000000000..314f464c0d1
--- /dev/null
+++ b/core/src/amp_subgraph/monitor.rs
@@ -0,0 +1,563 @@
+//! This module is responsible for executing subgraph runner futures.
+//!
+//! # Terminology used in this module
+//!
+//! `active subgraph` - A subgraph that was started and is still kept in memory in the list of started subgraphs.
+//! `running subgraph` - A subgraph that has an instance that is making progress or stopping.
+//! `subgraph instance` - A background task that executes the subgraph runner future.
+
+use std::{
+    collections::{HashMap, hash_map::Entry},
+    fmt,
+    sync::{
+        Arc,
+        atomic::{AtomicU32, Ordering::SeqCst},
+    },
+    time::Duration,
+};
+
+use anyhow::Result;
+use futures::future::BoxFuture;
+use graph::{
+    cheap_clone::CheapClone, components::store::DeploymentLocator, log::factory::LoggerFactory,
+};
+use slog::{Logger, debug, error, info, warn};
+use tokio::{
+    sync::mpsc::{self, error::SendError},
+    task::JoinHandle,
+    time::timeout,
+};
+use tokio_util::sync::CancellationToken;
+
+/// Represents the maximum amount of time a subgraph instance is allowed to run
+/// after it receives a cancel signal.
+///
+/// If a subgraph instance does not complete its execution in this amount of time
+/// it is considered unresponsive and is aborted.
+const SUBGRAPH_INSTANCE_GRACE_PERIOD: Duration = {
+    if cfg!(test) {
+        Duration::from_millis(300)
+    } else if cfg!(debug_assertions) {
+        Duration::from_secs(30)
+    } else {
+        Duration::from_secs(300)
+    }
+};
+
+/// Represents the subgraph runner future.
+///
+/// This is the future that performs the subgraph indexing.
+/// It is expected to return only on deterministic failures or when indexing is completed.
+/// All retry functionality must be handled internally by this future.
+pub(super) type BoxRunner =
+    Box<dyn FnOnce(CancellationToken) -> BoxFuture<'static, Result<()>> + Send + 'static>;
+
+/// Manages the lifecycle of subgraph runners.
+///
+/// Ensures that there is at most one subgraph instance running
+/// for any subgraph deployment at any point in time.
+/// Handles starting, stopping and restarting subgraphs.
+pub(super) struct Monitor {
+    logger_factory: Arc<LoggerFactory>,
+
+    /// Every subgraph instance is assigned a cancel token derived from this token.
+    ///
+    /// This means that the `Monitor` can send cancel signals to all subgraph instances at once,
+    /// and to each subgraph instance individually.
+    cancel_token: CancellationToken,
+
+    /// The channel that is used to send subgraph commands.
+    ///
+    /// Every subgraph start and stop request results in a command that is sent to the
+    /// background task that manages the subgraph instances.
+    command_tx: mpsc::UnboundedSender<Command>,
+
+    /// When a subgraph starts it is assigned a sequential ID.
+    /// The ID is then kept in memory in the list of active subgraphs.
+    ///
+    /// When the subgraph completes execution it should be removed from the
+    /// list of active subgraphs, so that it can be restarted.
+    ///
+    /// This ID is required to be able to check if the active subgraph
+    /// is the same subgraph instance that was stopped.
+    ///
+    /// If the IDs do not match, it means that the subgraph was force restarted,
+    /// ignoring the state of the previous subgraph instance, or that the subgraph
+    /// was restarted after the previous subgraph instance completed its execution
+    /// but before the remove request was processed.
+    subgraph_instance_id: Arc<AtomicU32>,
+}
+
+impl Monitor {
+    /// Creates a new subgraph monitor.
+    ///
+    /// Spawns a background task that manages the subgraph start and stop requests.
+    ///
+    /// A new cancel token is derived from the `cancel_token` and only the derived token is used by the
+    /// subgraph monitor and its background task.
+    pub(super) fn new(logger_factory: &LoggerFactory, cancel_token: &CancellationToken) -> Self {
+        let logger = logger_factory.component_logger("AmpSubgraphMonitor", None);
+        let logger_factory = Arc::new(logger_factory.with_parent(logger));
+
+        // A derived token makes sure it is not possible to accidentally cancel the parent token
+        let cancel_token = cancel_token.child_token();
+
+        // It is safe to use an unbounded channel here, because it's pretty much unrealistic that the
+        // command processor will fall behind so much that the channel buffer will take up all the memory.
+        // The command processor is non-blocking and delegates long-running processes to detached tasks.
+        let (command_tx, command_rx) = mpsc::unbounded_channel::<Command>();
+
+        tokio::spawn(Self::command_processor(
+            logger_factory.cheap_clone(),
+            cancel_token.cheap_clone(),
+            command_tx.clone(),
+            command_rx,
+        ));
+
+        Self {
+            logger_factory,
+            cancel_token,
+            command_tx,
+            subgraph_instance_id: Arc::new(AtomicU32::new(0)),
+        }
+    }
+
+    /// Starts a subgraph.
+    ///
+    /// Sends a subgraph start request to this subgraph monitor that
+    /// eventually starts the subgraph.
+    ///
+    /// # Behaviour
+    ///
+    /// - If the subgraph is not active, it starts when the request is processed
+    /// - If the subgraph is active, it stops, and then restarts
+    /// - Ensures that there is only one subgraph instance for this subgraph deployment
+    /// - Multiple consecutive calls in a short time period force restart the subgraph,
+    ///   aborting the active subgraph instance
+    pub(super) fn start(&self, deployment: DeploymentLocator, runner: BoxRunner) {
+        let logger = self
+            .logger_factory
+            .subgraph_logger(&deployment)
+            .new(slog::o!("method" => "start"));
+
+        info!(logger, "Starting subgraph");
+        log_send_error(
+            &logger,
+            self.command_tx.send(Command::Start {
+                id: self.subgraph_instance_id.fetch_add(1, SeqCst),
+                deployment,
+                runner,
+            }),
+        );
+    }
+
+    /// Stops the subgraph.
+    ///
+    /// Sends a subgraph stop request to this subgraph monitor that
+    /// eventually stops the subgraph.
+    ///
+    /// # Behaviour
+    ///
+    /// - If the subgraph is not active does nothing
+    /// - If the subgraph is active, sends a cancel signal that gracefully stops the subgraph
+    /// - If the subgraph fails to stop after an extended period of time it aborts
+    pub(super) fn stop(&self, deployment: DeploymentLocator) {
+        let logger = self
+            .logger_factory
+            .subgraph_logger(&deployment)
+            .new(slog::o!("method" => "stop"));
+
+        info!(logger, "Stopping subgraph");
+        log_send_error(&logger, self.command_tx.send(Command::Stop { deployment }));
+    }
+
+    /// Processes commands sent through the command channel.
+    ///
+    /// Tracks active subgraphs and keeps a list of pending start commands.
+    /// Pending start commands are start commands that execute after the related subgraph stops.
+    async fn command_processor(
+        logger_factory: Arc<LoggerFactory>,
+        cancel_token: CancellationToken,
+        command_tx: mpsc::UnboundedSender<Command>,
+        mut command_rx: mpsc::UnboundedReceiver<Command>,
+    ) {
+        let logger = logger_factory.component_logger("CommandProcessor", None);
+        let mut subgraph_instances: HashMap<DeploymentLocator, SubgraphInstance> = HashMap::new();
+        let mut pending_start_commands: HashMap<DeploymentLocator, Command> = HashMap::new();
+
+        loop {
+            tokio::select! {
+                Some(command) = command_rx.recv() => {
+                    match &command {
+                        Command::Start { .. } => {
+                            Self::process_start_command(
+                                &logger_factory,
+                                &cancel_token,
+                                &mut subgraph_instances,
+                                &mut pending_start_commands,
+                                &command_tx,
+                                command
+                            );
+                        },
+                        Command::Stop { .. } => {
+                            Self::process_stop_command(
+                                &logger_factory,
+                                &mut subgraph_instances,
+                                &mut pending_start_commands,
+                                command
+                            );
+                        },
+                        Command::Clear { .. } => {
+                            Self::process_clear_command(
+                                &logger_factory,
+                                &mut subgraph_instances,
+                                &mut pending_start_commands,
+                                &command_tx,
+                                command
+                            );
+                        },
+                    }
+                },
+                _ = cancel_token.cancelled() => {
+                    debug!(logger, "Stopping command processor");
+
+                    // All active subgraphs will shutdown gracefully
+                    // because their cancel tokens are derived from this cancelled token.
+                    return;
+                }
+            }
+        }
+    }
+
+    /// Starts a subgraph.
+    ///
+    /// # Behaviour
+    ///
+    /// - If the subgraph is not active, it starts right away
+    /// - If the subgraph is active, a cancel signal is sent to the active subgraph instance
+    ///   and this start request is stored in the list of pending start commands
+    /// - If the subgraph is active and there is already a pending start command,
+    ///   the active subgraph instance aborts, and the subgraph force restarts right away
+    /// - If the subgraph is active, but its instance is not actually running,
+    ///   the subgraph starts right away
+    fn process_start_command(
+        logger_factory: &LoggerFactory,
+        cancel_token: &CancellationToken,
+        subgraph_instances: &mut HashMap<DeploymentLocator, SubgraphInstance>,
+        pending_start_commands: &mut HashMap<DeploymentLocator, Command>,
+        command_tx: &mpsc::UnboundedSender<Command>,
+        command: Command,
+    ) {
+        let Command::Start {
+            id,
+            deployment,
+            runner,
+        } = command
+        else {
+            unreachable!();
+        };
+
+        let logger = logger_factory.subgraph_logger(&deployment);
+        let command_logger = logger.new(slog::o!("command" => "start"));
+
+        let cancel_token = cancel_token.child_token();
+        let pending_start_command = pending_start_commands.remove(&deployment);
+
+        match subgraph_instances.entry(deployment.cheap_clone()) {
+            Entry::Vacant(entry) => {
+                debug!(command_logger, "Subgraph is not active, starting");
+
+                let subgraph_instance = Self::start_subgraph(
+                    logger,
+                    cancel_token,
+                    id,
+                    deployment,
+                    runner,
+                    command_tx.clone(),
+                );
+
+                entry.insert(subgraph_instance);
+            }
+            Entry::Occupied(mut entry) => {
+                let subgraph_instance = entry.get_mut();
+                subgraph_instance.cancel_token.cancel();
+
+                if pending_start_command.is_some() {
+                    debug!(command_logger, "Subgraph is active, force restarting");
+
+                    subgraph_instance.handle.abort();
+
+                    *subgraph_instance = Self::start_subgraph(
+                        logger,
+                        cancel_token,
+                        id,
+                        deployment,
+                        runner,
+                        command_tx.clone(),
+                    );
+
+                    return;
+                }
+
+                if subgraph_instance.handle.is_finished() {
+                    debug!(command_logger, "Subgraph is not running, starting");
+
+                    *subgraph_instance = Self::start_subgraph(
+                        logger,
+                        cancel_token,
+                        id,
+                        deployment,
+                        runner,
+                        command_tx.clone(),
+                    );
+
+                    return;
+                }
+
+                debug!(command_logger, "Gracefully restarting subgraph");
+
+                pending_start_commands.insert(
+                    deployment.cheap_clone(),
+                    Command::Start {
+                        id,
+                        deployment,
+                        runner,
+                    },
+                );
+            }
+        }
+    }
+
+    /// Stops a subgraph.
+    ///
+    /// # Behaviour
+    ///
+    /// - If the subgraph is not active, does nothing
+    /// - If the subgraph is active, sends a cancel signal to the active subgraph instance
+    fn process_stop_command(
+        logger_factory: &LoggerFactory,
+        subgraph_instances: &mut HashMap<DeploymentLocator, SubgraphInstance>,
+        pending_start_commands: &mut HashMap<DeploymentLocator, Command>,
+        command: Command,
+    ) {
+        let Command::Stop { deployment } = command else {
+            unreachable!();
+        };
+
+        let logger = logger_factory
+            .subgraph_logger(&deployment)
+            .new(slog::o!("command" => "stop"));
+
+        if let Some(subgraph_instance) = subgraph_instances.get(&deployment) {
+            debug!(logger, "Sending cancel signal");
+            subgraph_instance.cancel_token.cancel();
+        } else {
+            debug!(logger, "Subgraph is not active");
+        }
+
+        pending_start_commands.remove(&deployment);
+    }
+
+    /// Removes a subgraph from the list of active subgraphs allowing the subgraph to be restarted.
+    fn process_clear_command(
+        logger_factory: &LoggerFactory,
+        subgraph_instances: &mut HashMap<DeploymentLocator, SubgraphInstance>,
+        pending_start_commands: &mut HashMap<DeploymentLocator, Command>,
+        command_tx: &mpsc::UnboundedSender<Command>,
+        command: Command,
+    ) {
+        let Command::Clear { id, deployment } = command else {
+            unreachable!();
+        };
+
+        let logger = logger_factory
+            .subgraph_logger(&deployment)
+            .new(slog::o!("command" => "clear"));
+
+        match subgraph_instances.get(&deployment) {
+            Some(subgraph_instance) if subgraph_instance.id == id => {
+                debug!(logger, "Removing active subgraph");
+                subgraph_instances.remove(&deployment);
+            }
+            Some(_subgraph_instance) => {
+                debug!(logger, "Active subgraph does not need to be removed");
+                return;
+            }
+            None => {
+                debug!(logger, "Subgraph is not active");
+            }
+        }
+
+        if let Some(pending_start_command) = pending_start_commands.remove(&deployment) {
+            debug!(logger, "Resending a pending start command");
+            log_send_error(&logger, command_tx.send(pending_start_command));
+        }
+    }
+
+    /// Spawns a background task that executes the subgraph runner future.
+    ///
+    /// An additional background task is spawned to handle the graceful shutdown of the subgraph runner,
+    /// and to ensure correct behaviour even if the subgraph runner panics.
+    fn start_subgraph(
+        logger: Logger,
+        cancel_token: CancellationToken,
+        id: u32,
+        deployment: DeploymentLocator,
+        runner: BoxRunner,
+        command_tx: mpsc::UnboundedSender<Command>,
+    ) -> SubgraphInstance {
+        let mut runner_handle = tokio::spawn({
+            let logger = logger.new(slog::o!("process" => "subgraph_runner"));
+            let cancel_token = cancel_token.cheap_clone();
+
+            async move {
+                info!(logger, "Subgraph started");
+
+                match runner(cancel_token).await {
+                    Ok(()) => {
+                        info!(logger, "Subgraph stopped");
+                    }
+                    Err(e) => {
+                        error!(logger, "Subgraph failed";
+                            "error" => ?e
+                        );
+                    }
+                }
+            }
+        });
+
+        let supervisor_handle = tokio::spawn({
+            let logger = logger.new(slog::o!("process" => "subgraph_supervisor"));
+            let cancel_token = cancel_token.cheap_clone();
+
+            fn handle_runner_result(logger: &Logger, result: Result<(), tokio::task::JoinError>) {
+                match result {
+                    Ok(()) => {
+                        debug!(logger, "Subgraph completed execution");
+                    }
+                    Err(e) if e.is_panic() => {
+                        error!(logger, "Subgraph panicked";
+                            "error" => ?e
+                        );
+                    }
+                    Err(e) => {
+                        error!(logger, "Subgraph failed";
+                            "error" => ?e
+                        );
+                    }
+                }
+            }
+
+            async move {
+                debug!(logger, "Subgraph supervisor started");
+
+                tokio::select! {
+                    _ = cancel_token.cancelled() => {
+                        debug!(logger, "Received cancel signal, waiting for subgraph to stop");
+
+                        match timeout(SUBGRAPH_INSTANCE_GRACE_PERIOD, &mut runner_handle).await {
+                            Ok(result) => {
+                                handle_runner_result(&logger, result);
+                            },
+                            Err(_) => {
+                                warn!(logger, "Subgraph did not stop after grace period, aborting");
+
+                                runner_handle.abort();
+                                let _ = runner_handle.await;
+
+                                warn!(logger, "Subgraph aborted");
+                            }
+                        }
+                    },
+                    result = &mut runner_handle => {
+                        handle_runner_result(&logger, result);
+                        cancel_token.cancel();
+                    }
+                }
+
+                debug!(logger, "Sending clear command");
+                log_send_error(&logger, command_tx.send(Command::Clear { id, deployment }));
+            }
+        });
+
+        SubgraphInstance {
+            id,
+            handle: supervisor_handle,
+            cancel_token,
+        }
+    }
+}
+
+impl Drop for Monitor {
+    fn drop(&mut self) {
+        // Send cancel signals to all active subgraphs so that they don't remain without an associated monitor
+        self.cancel_token.cancel();
+    }
+}
+
+/// Represents a background task that executes the subgraph runner future.
+struct SubgraphInstance {
+    id: u32,
+    handle: JoinHandle<()>,
+    cancel_token: CancellationToken,
+}
+
+/// Every command used by the subgraph monitor.
+enum Command {
+    /// A request to start executing the subgraph runner future.
+    Start {
+        id: u32,
+        deployment: DeploymentLocator,
+        runner: BoxRunner,
+    },
+
+    /// A request to stop executing the subgraph runner future.
+    Stop { deployment: DeploymentLocator },
+
+    /// A request to remove the subgraph from the list of active subgraphs.
+    Clear {
+        id: u32,
+        deployment: DeploymentLocator,
+    },
+}
+
+impl fmt::Debug for Command {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Start {
+                id,
+                deployment,
+                runner: _,
+            } => f
+                .debug_struct("Start")
+                .field("id", id)
+                .field("deployment", deployment)
+                .finish_non_exhaustive(),
+            Self::Stop { deployment } => f
+                .debug_struct("Stop")
+                .field("deployment", deployment)
+                .finish(),
+            Self::Clear { id, deployment } => f
+                .debug_struct("Clear")
+                .field("id", id)
+                .field("deployment", deployment)
+                .finish(),
+        }
+    }
+}
+
+fn log_send_error(logger: &Logger, result: Result<(), SendError<Command>>) {
+    match result {
+        Ok(()) => {
+            // No need to log anything
+        }
+
+        // This should only happen if the parent cancel token of the subgraph monitor was cancelled
+        Err(e) => {
+            error!(logger, "Failed to send command";
+                "command" => ?e.0,
+                "error" => ?e
+            );
+        }
+    }
+}
diff --git a/core/src/amp_subgraph/runner/compat.rs b/core/src/amp_subgraph/runner/compat.rs
new file mode 100644
index 00000000000..f7152965cf3
--- /dev/null
+++ b/core/src/amp_subgraph/runner/compat.rs
@@ -0,0 +1,52 @@
+//! This is a temporary compatibility module until the graph-node is fully migrated to `alloy`.
+
+use alloy::primitives::{BlockHash, BlockNumber};
+use chrono::{DateTime, Utc};
+
+mod legacy {
+    pub(super) use graph::{
+        blockchain::{BlockHash, BlockPtr, BlockTime},
+        components::store::BlockNumber,
+        data::store::scalar::Timestamp,
+    };
+}
+
+pub(super) trait Compat<T> {
+    fn compat(&self) -> T;
+}
+
+impl Compat<legacy::BlockNumber> for BlockNumber {
+    fn compat(&self) -> legacy::BlockNumber {
+        (*self).try_into().unwrap()
+    }
+}
+
+impl Compat<BlockNumber> for legacy::BlockNumber {
+    fn compat(&self) -> BlockNumber {
+        (*self).try_into().unwrap()
+    }
+}
+
+impl Compat<legacy::BlockHash> for BlockHash {
+    fn compat(&self) -> legacy::BlockHash {
+        legacy::BlockHash(self.0.into())
+    }
+}
+
+impl Compat<BlockHash> for legacy::BlockHash {
+    fn compat(&self) -> BlockHash {
+        BlockHash::from_slice(&self.0)
+    }
+}
+
+impl Compat<legacy::BlockTime> for DateTime<Utc> {
+    fn compat(&self) -> legacy::BlockTime {
+        legacy::Timestamp(*self).into()
+    }
+}
+
+impl Compat<legacy::BlockPtr> for (BlockNumber, BlockHash) {
+    fn compat(&self) -> legacy::BlockPtr {
+        legacy::BlockPtr::new(self.1.compat(), self.0.compat())
+    }
+}
diff --git a/core/src/amp_subgraph/runner/context.rs b/core/src/amp_subgraph/runner/context.rs
new file mode 100644
index 00000000000..d8b5b7b638e
--- /dev/null
+++ b/core/src/amp_subgraph/runner/context.rs
@@ -0,0 +1,97 @@
+use std::sync::Arc;
+
+use alloy::primitives::{BlockHash, BlockNumber};
+use graph::{
+    amp::{Codec, Manifest, log::Logger as _},
+    cheap_clone::CheapClone,
+    components::store::WritableStore,
+    data::subgraph::DeploymentHash,
+    env::AmpEnv,
+    util::backoff::ExponentialBackoff,
+};
+use slog::Logger;
+
+use super::Compat;
+use crate::amp_subgraph::Metrics;
+
+pub(in super::super) struct Context<AC> {
+    pub(super) logger: Logger,
+    pub(super) client: Arc<AC>,
+    pub(super) store: Arc<dyn WritableStore>,
+    pub(super) buffer_size: usize,
+    pub(super) block_range: usize,
+    pub(super) backoff: ExponentialBackoff,
+    pub(super) deployment: DeploymentHash,
+    pub(super) manifest: Manifest,
+    pub(super) metrics: Metrics,
+    pub(super) codec: Codec,
+}
+
+impl<AC> Context<AC> {
+    pub(in super::super) fn new(
+        logger: &Logger,
+        env: &AmpEnv,
+        client: Arc<AC>,
+        store: Arc<dyn WritableStore>,
+        deployment: DeploymentHash,
+        manifest: Manifest,
+        metrics: Metrics,
+    ) -> Self {
+        let logger = logger.component("AmpSubgraphRunner");
+        let backoff = ExponentialBackoff::new(env.query_retry_min_delay, env.query_retry_max_delay);
+        let codec = Codec::new(manifest.schema.cheap_clone());
+
+        Self {
+            logger,
+            client,
+            store,
+            buffer_size: env.buffer_size,
+            block_range: env.block_range,
+            backoff,
+            deployment,
+            manifest,
+            metrics,
+            codec,
+        }
+    }
+
+    pub(super) fn indexing_completed(&self) -> bool {
+        let Some(last_synced_block) = self.latest_synced_block() else {
+            return false;
+        };
+
+        self.manifest
+            .data_sources
+            .iter()
+            .all(|data_source| last_synced_block >= data_source.source.end_block)
+    }
+
+    pub(super) fn latest_synced_block(&self) -> Option<BlockNumber> {
+        self.latest_synced_block_ptr()
+            .map(|(block_number, _)| block_number)
+    }
+
+    pub(super) fn latest_synced_block_ptr(&self) -> Option<(BlockNumber, BlockHash)> {
+        self.store
+            .block_ptr()
+            .map(|block_ptr| (block_ptr.number.compat(), block_ptr.hash.compat()))
+    }
+
+    pub(super) fn start_block(&self) -> BlockNumber {
+        self.manifest
+            .data_sources
+            .iter()
+            .map(|data_source| data_source.source.start_block)
+            .min()
+            .unwrap()
+    }
+
+    pub(super) fn end_block(&self) -> BlockNumber {
+        self.manifest
+            .data_sources
+            .iter()
+            .map(|data_source| data_source.source.end_block)
+            .max()
+            .unwrap()
+    }
+}
diff --git a/core/src/amp_subgraph/runner/data_processing.rs b/core/src/amp_subgraph/runner/data_processing.rs
new file mode 100644
index 00000000000..d5bf991d505
--- /dev/null
+++ b/core/src/amp_subgraph/runner/data_processing.rs
@@ -0,0 +1,267 @@
+use std::sync::Arc;
+
+use alloy::primitives::{BlockHash, BlockNumber};
+use anyhow::anyhow;
+use arrow::array::RecordBatch;
+use chrono::{DateTime, Utc};
+use graph::{
+    amp::{
+        codec::{DecodeOutput, DecodedEntity, Decoder, utils::auto_block_timestamp_decoder},
+        stream_aggregator::{RecordBatchGroup, RecordBatchGroups, StreamRecordBatch},
+    },
+    blockchain::block_stream::FirehoseCursor,
+    cheap_clone::CheapClone,
+    components::store::{EntityCache, EntityLfuCache, ModificationsAndCache, SeqGenerator},
+};
+use slog::{debug, trace};
+
+use super::{Compat, Context, Error, data_stream::TablePtr};
+
+pub(super) async fn process_record_batch_groups<AC>(
+    cx: &mut Context<AC>,
+    mut entity_lfu_cache: EntityLfuCache,
+    record_batch_groups: RecordBatchGroups,
+    stream_table_ptr: Arc<[TablePtr]>,
+    latest_block: BlockNumber,
+) -> Result<EntityLfuCache, Error> {
+    if record_batch_groups.is_empty() {
+        debug!(cx.logger, "Received no record batch groups");
+        return Ok(entity_lfu_cache);
+    }
+
+    let from_block = record_batch_groups
+        .first_key_value()
+        .map(|((block, _), _)| *block)
+        .unwrap();
+
+    let to_block = record_batch_groups
+        .last_key_value()
+        .map(|((block, _), _)| *block)
+        .unwrap();
+
+    debug!(cx.logger, "Processing record batch groups";
+        "from_block" => from_block,
+        "to_block" => to_block
+    );
+
+    for ((block_number, block_hash), record_batch_group) in record_batch_groups {
+        trace!(cx.logger, "Processing record batch group";
+            "block" => block_number,
+            "record_batches_count" => record_batch_group.record_batches.len()
+        );
+
+        entity_lfu_cache = process_record_batch_group(
+            cx,
+            entity_lfu_cache,
+            block_number,
+            block_hash,
+            record_batch_group,
+            &stream_table_ptr,
+            latest_block,
+        )
+        .await
+        .map_err(|e| {
+            e.context(format!(
+                "failed to process record batch group at block '{block_number}'"
+            ))
+        })?;
+
+        cx.metrics.deployment_head.update(block_number);
+        cx.metrics.blocks_processed.record_one();
+
+        trace!(cx.logger, "Completed processing record batch group";
+            "block" => block_number
+        );
+    }
+
+    debug!(cx.logger, "Completed processing record batch groups";
+        "from_block" => from_block,
+        "to_block" => to_block
+    );
+
+    Ok(entity_lfu_cache)
+}
+
+async fn process_record_batch_group<AC>(
+    cx: &mut Context<AC>,
+    entity_lfu_cache: EntityLfuCache,
+    block_number: BlockNumber,
+    block_hash: BlockHash,
+    record_batch_group: RecordBatchGroup,
+    stream_table_ptr: &[TablePtr],
+    latest_block: BlockNumber,
+) -> Result<EntityLfuCache, Error> {
+    let _section = cx
+        .metrics
+        .stopwatch
+        .start_section("process_record_batch_group");
+
+    let RecordBatchGroup { record_batches } = record_batch_group;
+
+    if record_batches.is_empty() {
+        debug!(cx.logger, "Record batch group is empty");
+        return Ok(entity_lfu_cache);
+    }
+
+    let mut entity_cache = EntityCache::with_current(
+        cx.store.cheap_clone(),
+        entity_lfu_cache,
+        SeqGenerator::new(block_number.compat()),
+    );
+
+    let block_timestamp = if cx.manifest.schema.has_aggregations() {
+        decode_block_timestamp(&record_batches)
+            .map_err(|e| e.context("failed to decode block timestamp"))?
+    } else {
+        // TODO: Block timestamp is only required for subgraph aggregations.
+        //       Make it optional at the store level.
+        DateTime::<Utc>::MIN_UTC
+    };
+
+    for record_batch in record_batches {
+        let StreamRecordBatch {
+            stream_index,
+            record_batch,
+        } = record_batch;
+
+        process_record_batch(
+            cx,
+            &mut entity_cache,
+            record_batch,
+            stream_table_ptr[stream_index],
+        )
+        .await
+        .map_err(|e| {
+            e.context(format!(
+                "failed to process record batch for stream '{stream_index}'"
+            ))
+        })?;
+    }
+
+    let section = cx.metrics.stopwatch.start_section("as_modifications");
+    let ModificationsAndCache {
+        modifications,
+        entity_lfu_cache,
+        evict_stats: _,
+    } = entity_cache
+        .as_modifications(block_number.compat(), &cx.metrics.stopwatch)
+        .await
+        .map_err(Error::from)
+        .map_err(|e| e.context("failed to extract entity modifications from the state"))?;
+    section.end();
+
+    let _section = cx.metrics.stopwatch.start_section("transact_block");
+    let is_close_to_chain_head = latest_block.saturating_sub(block_number) <= 100;
+
+    cx.store
+        .transact_block_operations(
+            (block_number, block_hash).compat(),
+            block_timestamp.compat(),
+            FirehoseCursor::None,
+            modifications,
+            &cx.metrics.stopwatch,
+            Vec::new(),
+            Vec::new(),
+            Vec::new(),
+            false,
+            is_close_to_chain_head,
+        )
+        .await
+        .map_err(Error::from)
+        .map_err(|e| e.context("failed to transact block operations"))?;
+
+    if is_close_to_chain_head {
+        cx.metrics.deployment_synced.record(true);
+    }
+
+    Ok(entity_lfu_cache)
+}
+
+async fn process_record_batch<AC>(
+    cx: &mut Context<AC>,
+    entity_cache: &mut EntityCache,
+    record_batch: RecordBatch,
+    (i, j): TablePtr,
+) -> Result<(), Error> {
+    let _section = cx.metrics.stopwatch.start_section("process_record_batch");
+
+    let table = &cx.manifest.data_sources[i].transformer.tables[j];
+    let entity_name = &table.name;
+
+    let DecodeOutput {
+        entity_type,
+        id_type,
+        decoded_entities,
+    } = cx
+        .codec
+        .decode(record_batch, entity_name.as_str())
+        .map_err(|e| {
+            Error::Deterministic(
+                e.context(format!("failed to decode entities of type '{entity_name}'")),
+            )
+        })?;
+
+    for decoded_entity in decoded_entities {
+        let DecodedEntity {
+            key,
+            mut entity_data,
+        } = decoded_entity;
+
+        let key = match key {
+            Some(key) => key,
+            None => {
+                let entity_id = entity_cache.seq_gen.id(id_type).map_err(|e| {
+                    Error::Deterministic(e.context(format!(
+                        "failed to generate a new id for an entity of type '{entity_name}'"
+                    )))
+                })?;
+
+                entity_data.push(("id".into(), entity_id.clone().into()));
+                entity_type.key(entity_id)
+            }
+        };
+
+        let entity_id = key.entity_id.clone();
+        let entity = cx.manifest.schema.make_entity(entity_data).map_err(|e| {
+            Error::Deterministic(anyhow!(e).context(format!(
+                "failed to create a new entity of type '{entity_name}' with id '{entity_id}'"
+            )))
+        })?;
+
+        entity_cache.set(key, entity, None).await.map_err(|e| {
+            Error::Deterministic(e.context(format!(
+                "failed to store a new entity of type '{entity_name}' with id '{entity_id}'"
+            )))
+        })?;
+    }
+
+    Ok(())
+}
+
+/// Decodes the block timestamp from the first matching column in `record_batches`.
+///
+/// Iterates through the provided record batches and returns the timestamp from
+/// the first batch that contains a valid block timestamp column.
+///
+/// # Preconditions
+///
+/// All entries in `record_batches` must belong to the same record batch group.
+fn decode_block_timestamp(record_batches: &[StreamRecordBatch]) -> Result<DateTime<Utc>, Error> {
+    let mut last_error: Option<Error> = None;
+
+    for record_batch in record_batches {
+        match auto_block_timestamp_decoder(&record_batch.record_batch) {
+            Ok((_, decoder)) => {
+                return decoder
+                    .decode(0)
+                    .map_err(Error::Deterministic)?
+                    .ok_or_else(|| Error::Deterministic(anyhow!("block timestamp is empty")));
+            }
+            Err(e) => {
+                last_error = Some(Error::Deterministic(e));
+            }
+        }
+    }
+
+    Err(last_error.unwrap())
+}
diff --git a/core/src/amp_subgraph/runner/data_stream.rs b/core/src/amp_subgraph/runner/data_stream.rs
new file mode 100644
index 00000000000..693ae9384a7
--- /dev/null
+++ b/core/src/amp_subgraph/runner/data_stream.rs
@@ -0,0 +1,232 @@
+use std::{collections::HashMap, ops::RangeInclusive, sync::Arc};
+
+use alloy::primitives::BlockNumber;
+use anyhow::anyhow;
+use futures::{
+    StreamExt, TryStreamExt,
+    stream::{self, BoxStream},
+};
+use graph::{
+    amp::{
+        Client,
+        client::ResponseBatch,
+        error::IsDeterministic,
+        manifest::DataSource,
+        stream_aggregator::{RecordBatchGroups, StreamAggregator},
+    },
+    cheap_clone::CheapClone,
+    prelude::StopwatchMetrics,
+};
+use slog::{debug, warn};
+
+use super::{Context, Error};
+
+pub(super) type TablePtr = (usize, usize);
+
+pub(super) fn new_data_stream<AC>(
+    cx: &Context<AC>,
+    latest_block: BlockNumber,
+) -> BoxStream<'static, Result<(RecordBatchGroups, Arc<[TablePtr]>), Error>>
+where
+    AC: Client + Send + Sync + 'static,
+{
+    let logger = cx.logger.new(slog::o!("process" => "new_data_stream"));
+    let client = cx.client.cheap_clone();
+    let manifest = cx.manifest.clone();
+    let buffer_size = cx.buffer_size;
+    let block_range = cx.block_range;
+    let stopwatch = cx.metrics.stopwatch.cheap_clone();
+
+    debug!(logger, "Creating data stream";
+        "from_block" => cx.latest_synced_block().unwrap_or(BlockNumber::MIN),
+        "to_block" => latest_block,
+        "start_block" => cx.start_block(),
+        "block_range" => block_range,
+    );
+
+    // State: (latest_queried_block, end_block, is_first)
+    let initial_state = (cx.latest_synced_block(), BlockNumber::MIN, true);
+
+    stream::unfold(
+        initial_state,
+        move |(latest_queried_block, mut end_block, is_first)| {
+            let block_ranges = next_block_ranges(
+                &manifest.data_sources,
+                block_range,
+                latest_queried_block,
+                latest_block,
+            );
+
+            if block_ranges.is_empty() {
+                if is_first {
+                    warn!(logger, "There are no unprocessed block ranges");
+                }
+                return futures::future::ready(None);
+            }
+
+            let start_block = block_ranges.values().map(|r| *r.start()).min().unwrap();
+            end_block = end_block.max(block_ranges.values().map(|r| *r.end()).max().unwrap());
+
+            let (query_streams, table_ptrs) =
+                build_query_streams(&*client, &logger, &manifest.data_sources, &block_ranges);
+
+            let data_stream = build_data_stream(
+                &logger,
+                query_streams,
+                table_ptrs,
+                buffer_size,
+                &stopwatch,
+                start_block,
+            );
+
+            debug!(logger, "Created a new data stream";
+                "latest_queried_block" => latest_queried_block,
+                "start_block" => start_block,
+                "end_block" => end_block,
+            );
+            futures::future::ready(Some((data_stream, (Some(end_block), end_block, false))))
+        },
+    )
+    .flatten()
+    .boxed()
+}
+
+fn build_query_streams<AC: Client>(
+    client: &AC,
+    logger: &slog::Logger,
+    data_sources: &[DataSource],
+    block_ranges: &HashMap<usize, RangeInclusive<BlockNumber>>,
+) -> (
+    Vec<(String, BoxStream<'static, Result<ResponseBatch, AC::Error>>)>,
+    Arc<[TablePtr]>,
+) {
+    let total_queries: usize = data_sources
+        .iter()
+        .map(|ds| ds.transformer.tables.len())
+        .sum();
+
+    let mut query_streams = Vec::with_capacity(total_queries);
+    let mut table_ptrs = Vec::with_capacity(total_queries);
+
+    for (i, data_source) in data_sources.iter().enumerate() {
+        let Some(block_range) = block_ranges.get(&i) else {
+            continue;
+        };
+
+        for (j, table) in data_source.transformer.tables.iter().enumerate() {
+            let query = table.query.build_with_block_range(block_range);
+            let stream = client.query(logger, query, None);
+            let stream_name = format!("{}.{}", data_source.name, table.name);
+
+            query_streams.push((stream_name, stream));
+            table_ptrs.push((i, j));
+        }
+    }
+
+    (query_streams, table_ptrs.into())
+}
+
+fn build_data_stream<E>(
+    logger: &slog::Logger,
+    query_streams: Vec<(String, BoxStream<'static, Result<ResponseBatch, E>>)>,
+    table_ptrs: Arc<[TablePtr]>,
+    buffer_size: usize,
+    stopwatch: &StopwatchMetrics,
+    start_block: BlockNumber,
+) -> BoxStream<'static, Result<(RecordBatchGroups, Arc<[TablePtr]>), Error>>
+where
+    E: std::error::Error + IsDeterministic + Send + Sync + 'static,
+{
+    let mut start_block_checked = false;
+    let mut load_first_record_batch_group_section =
+        Some(stopwatch.start_section("load_first_record_batch_group"));
+
+    StreamAggregator::new(logger, query_streams, buffer_size)
+        .map_ok(move |response| (response, table_ptrs.cheap_clone()))
+        .map_err(Error::from)
+        .map(move |result| {
+            if load_first_record_batch_group_section.is_some() {
+                let _section = load_first_record_batch_group_section.take();
+            }
+
+            match result {
+                Ok(response) => {
+                    if !start_block_checked {
+                        if let Some(((first_block, _), _)) = response.0.first_key_value()
+                            && *first_block < start_block
+                        {
+                            return Err(Error::NonDeterministic(anyhow!("chain reorg")));
+                        }
+
+                        start_block_checked = true;
+                    }
+
+                    Ok(response)
+                }
+                Err(e) => Err(e),
+            }
+        })
+        .boxed()
+}
+
+fn next_block_ranges(
+    data_sources: &[DataSource],
+    block_range: usize,
+    latest_queried_block: Option<BlockNumber>,
+    latest_block: BlockNumber,
+) -> HashMap<usize, RangeInclusive<BlockNumber>> {
+    let block_ranges = data_sources
+        .iter()
+        .enumerate()
+        .filter_map(|(i, data_source)| {
+            next_block_range(block_range, data_source, latest_queried_block, latest_block)
+                .map(|block_range| (i, block_range))
+        })
+        .collect::<HashMap<_, _>>();
+
+    let Some(min_block_range) = block_ranges
+        .iter()
+        .min_by_key(|(_, block_range)| *block_range.start())
+        .map(|(_, min_block_range)| min_block_range.clone())
+    else {
+        return HashMap::new();
+    };
+
+    block_ranges
+        .into_iter()
+        .filter(|(_, block_range)| block_range.start() <= min_block_range.end())
+        .collect()
+}
+
+fn next_block_range(
+    block_range: usize,
+    data_source: &DataSource,
+    latest_queried_block: Option<BlockNumber>,
+    latest_block: BlockNumber,
+) -> Option<RangeInclusive<BlockNumber>> {
+    let start_block = match latest_queried_block {
+        Some(latest_queried_block) => {
+            if latest_queried_block >= data_source.source.end_block {
+                return None;
+            }
+
+            latest_queried_block + 1
+        }
+        None => data_source.source.start_block,
+    };
+
+    let end_block = [
+        start_block.saturating_add(block_range as BlockNumber),
+        data_source.source.end_block,
+        latest_block,
+    ]
+    .into_iter()
+    .min()
+    .unwrap();
+
+    if start_block > end_block {
+        return None;
+    }
+
+    Some(start_block..=end_block)
+}
diff --git a/core/src/amp_subgraph/runner/error.rs b/core/src/amp_subgraph/runner/error.rs
new file mode 100644
index 00000000000..8c7077e1c68
--- /dev/null
+++ b/core/src/amp_subgraph/runner/error.rs
@@ -0,0 +1,43 @@
+use graph::amp::error::IsDeterministic;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub(super) enum Error {
+    #[error("runner failed with a non-deterministic error: {0:#}")]
+    NonDeterministic(#[source] anyhow::Error),
+
+    #[error("runner failed with a deterministic error: {0:#}")]
+    Deterministic(#[source] anyhow::Error),
+}
+
+impl Error {
+    pub(super) fn context<C>(self, context: C) -> Self
+    where
+        C: std::fmt::Display + Send + Sync + 'static,
+    {
+        match self {
+            Self::NonDeterministic(e) => Self::NonDeterministic(e.context(context)),
+            Self::Deterministic(e) => Self::Deterministic(e.context(context)),
+        }
+    }
+
+    pub(super) fn is_deterministic(&self) -> bool {
+        match self {
+            Self::Deterministic(_) => true,
+            Self::NonDeterministic(_) => false,
+        }
+    }
+}
+
+impl<T> From<T> for Error
+where
+    T: std::error::Error + IsDeterministic + Send + Sync + 'static,
+{
+    fn from(e: T) -> Self {
+        if e.is_deterministic() {
+            Self::Deterministic(e.into())
+        } else {
+            Self::NonDeterministic(e.into())
+        }
+    }
+}
diff --git a/core/src/amp_subgraph/runner/latest_blocks.rs b/core/src/amp_subgraph/runner/latest_blocks.rs
new file mode 100644
index 00000000000..17bdc23dd29
--- /dev/null
+++ b/core/src/amp_subgraph/runner/latest_blocks.rs
@@ -0,0 +1,180 @@
+use alloy::primitives::BlockNumber;
+use anyhow::anyhow;
+use arrow::array::RecordBatch;
+use futures::{StreamExt, TryFutureExt, future::try_join_all, stream::BoxStream};
+use graph::amp::{
+    Client,
+    client::ResponseBatch,
+    codec::{Decoder, utils::block_number_decoder},
+    error::IsDeterministic,
+    manifest::DataSource,
+};
+use itertools::Itertools;
+use slog::debug;
+
+use super::{Context, Error};
+
+pub(super) type TablePtr = (usize, usize);
+
+pub(super) struct LatestBlocks(Vec<(TablePtr, BlockNumber)>);
+
+impl LatestBlocks {
+    pub(super) async fn load<AC>(cx: &Context<AC>) -> Result<Self, Error>
+    where
+        AC: Client,
+    {
+        debug!(cx.logger, "Loading latest blocks");
+        let _section = cx.metrics.stopwatch.start_section("load_latest_blocks");
+
+        let latest_block_futs = cx
+            .manifest
+            .data_sources
+            .iter()
+            .enumerate()
+            .flat_map(|(i, data_source)| {
+                data_source
+                    .source
+                    .tables
+                    .iter()
+                    .enumerate()
+                    .map(move |(j, table)| ((i, j), &data_source.source.dataset, table))
+            })
+            .unique_by(|(_, dataset, table)| (dataset.to_string(), table.to_string()))
+            .map(|(table_ptr, dataset, table)| {
+                latest_block(cx, dataset, table)
+                    .map_ok(move |latest_block| (table_ptr, latest_block))
+                    .map_err(move |e| {
+                        e.context(format!(
+                            "failed to load latest block for '{dataset}.{table}'"
+                        ))
+                    })
+            });
+
+        try_join_all(latest_block_futs).await.map(Self)
+    }
+
+    pub(super) fn filter_completed<AC>(self, cx: &Context<AC>) -> Self
+    where
+        AC: Client,
+    {
+        let latest_synced_block = cx.latest_synced_block();
+
+        Self(
+            self.0
+                .into_iter()
+                .filter(|((i, _), _)| {
+                    !indexing_completed(&cx.manifest.data_sources[*i], &latest_synced_block)
+                })
+                .collect(),
+        )
+    }
+
+    pub(super) fn min(&self) -> BlockNumber {
+        self.0
+            .iter()
+            .min_by_key(|(_, latest_block)| *latest_block)
+            .map(|(_, latest_block)| *latest_block)
+            .unwrap()
+    }
+
+    pub(super) async fn changed<AC>(self, cx: &Context<AC>) -> Result<(), Error>
+    where
+        AC: Client,
+    {
+        debug!(cx.logger, "Waiting for new blocks");
+        let _section = cx.metrics.stopwatch.start_section("latest_blocks_changed");
+
+        let min_latest_block = self.min();
+        let latest_synced_block = cx.latest_synced_block();
+
+        let latest_block_changed_futs = self
+            .0
+            .into_iter()
+            .filter(|(_, latest_block)| *latest_block == min_latest_block)
+            .filter(|((i, _), _)| {
+                !indexing_completed(&cx.manifest.data_sources[*i], &latest_synced_block)
+            })
+            .map(|((i, j), latest_block)| {
+                let source = &cx.manifest.data_sources[i].source;
+                let dataset = &source.dataset;
+                let table = &source.tables[j];
+
+                latest_block_changed(cx, dataset, table, latest_block).map_err(move |e| {
+                    e.context(format!(
+                        "failed to check if the latest block changed in '{dataset}.{table}'"
+                    ))
+                })
+            });
+
+        let _response = try_join_all(latest_block_changed_futs).await?;
+
+        Ok(())
+    }
+
+    pub(super) fn iter(&self) -> impl Iterator<Item = &(TablePtr, BlockNumber)> {
+        self.0.iter()
+    }
+}
+
+fn indexing_completed(data_source: &DataSource, latest_synced_block: &Option<BlockNumber>) -> bool {
+    latest_synced_block
+        .as_ref()
+        .is_some_and(|latest_synced_block| *latest_synced_block >= data_source.source.end_block)
+}
+
+async fn latest_block<AC>(
+    cx: &Context<AC>,
+    dataset: &str,
+    table: &str,
+) -> Result<BlockNumber, Error>
+where
+    AC: Client,
+{
+    let query = format!("SELECT MAX(_block_num) FROM {dataset}.{table}");
+    let stream = cx.client.query(&cx.logger, query, None);
+    let record_batch = read_once(stream).await?;
+
+    let latest_block = block_number_decoder(&record_batch, 0)
+        .map_err(Error::Deterministic)?
+        .decode(0)
+        .map_err(Error::Deterministic)?
+        .ok_or_else(|| Error::NonDeterministic(anyhow!("table is empty")))?;
+
+    Ok(latest_block)
+}
+
+async fn latest_block_changed<AC>(
+    cx: &Context<AC>,
+    dataset: &str,
+    table: &str,
+    latest_block: BlockNumber,
+) -> Result<(), Error>
+where
+    AC: Client,
+{
+    let query = format!(
+        "SELECT _block_num FROM {dataset}.{table} WHERE _block_num > {latest_block} SETTINGS stream = true"
+    );
+    let stream = cx.client.query(&cx.logger, query, None);
+    let _record_batch = read_once(stream).await?;
+
+    Ok(())
+}
+
+async fn read_once<E>(
+    mut stream: BoxStream<'static, Result<ResponseBatch, E>>,
+) -> Result<RecordBatch, Error>
+where
+    E: std::error::Error + IsDeterministic + Send + Sync + 'static,
+{
+    let response = stream
+        .next()
+        .await
+        .ok_or_else(|| Error::NonDeterministic(anyhow!("stream is empty")))?
+        .map_err(Error::from)?;
+
+    match response {
+        ResponseBatch::Batch { data } => Ok(data),
+        _ => Err(Error::NonDeterministic(anyhow!("response is empty"))),
+    }
+}
diff --git a/core/src/amp_subgraph/runner/mod.rs b/core/src/amp_subgraph/runner/mod.rs
new file mode 100644
index 00000000000..4e0e85294b6
--- /dev/null
+++ b/core/src/amp_subgraph/runner/mod.rs
@@ -0,0 +1,190 @@
+mod compat;
+mod context;
+mod data_processing;
+mod data_stream;
+mod error;
+mod latest_blocks;
+mod reorg_handler;
+
+use std::time::{Duration, Instant};
+
+use anyhow::Result;
+use futures::StreamExt;
+use graph::{
+    amp::Client, cheap_clone::CheapClone, components::store::EntityLfuCache,
+    data::subgraph::schema::SubgraphError, util::lfu_cache::LfuCache,
+};
+use slog::{debug, error, warn};
+use tokio_util::sync::CancellationToken;
+
+use self::{
+    compat::Compat, data_processing::process_record_batch_groups, data_stream::new_data_stream,
+    error::Error, latest_blocks::LatestBlocks, reorg_handler::check_and_handle_reorg,
+};
+
+pub(super) use self::context::Context;
+
+pub(super) async fn new_runner<AC>(
+    mut cx: Context<AC>,
+    cancel_token: CancellationToken,
+) -> Result<()>
+where
+    AC: Client + Send + Sync + 'static,
+{
+    let indexing_duration_handle = tokio::spawn({
+        let mut instant = Instant::now();
+        let indexing_duration = cx.metrics.indexing_duration.clone();
+
+        async move {
+            loop {
+                tokio::time::sleep(Duration::from_secs(1)).await;
+
+                let prev_instant = std::mem::replace(&mut instant, Instant::now());
+                indexing_duration.record(prev_instant.elapsed());
+            }
+        }
+    });
+
+    let result = cancel_token
+        .run_until_cancelled(run_indexing_with_retries(&mut cx))
+        .await;
+
+    indexing_duration_handle.abort();
+
+    match result {
+        Some(result) => result?,
+        None => {
+            debug!(cx.logger, "Processed cancel signal");
+        }
+    }
+
+    cx.metrics.deployment_status.stopped();
+
+    debug!(cx.logger, "Waiting for the store to finish processing");
+    cx.store.flush().await?;
+    Ok(())
+}
+
+async fn run_indexing<AC>(cx: &mut Context<AC>) -> Result<(), Error>
+where
+    AC: Client + Send + Sync + 'static,
+{
+    cx.metrics.deployment_status.starting();
+
+    if let Some(latest_synced_block) = cx.latest_synced_block() {
+        cx.metrics.deployment_head.update(latest_synced_block);
+    }
+
+    cx.metrics
+        .deployment_synced
+        .record(cx.store.is_deployment_synced());
+
+    loop {
+        cx.metrics.deployment_status.running();
+
+        debug!(cx.logger, "Running indexing";
+            "latest_synced_block_ptr" => ?cx.latest_synced_block_ptr()
+        );
+
+        let mut latest_blocks = LatestBlocks::load(cx).await?;
+        check_and_handle_reorg(cx, &latest_blocks).await?;
+
+        if cx.indexing_completed() {
+            cx.metrics.deployment_synced.record(true);
+
+            debug!(cx.logger, "Indexing completed");
+            return Ok(());
+        }
+
+        latest_blocks = latest_blocks.filter_completed(cx);
+        let latest_block = latest_blocks.min();
+
+        cx.metrics
+            .deployment_target
+            .update(latest_block.min(cx.end_block()));
+
+        let mut deployment_is_failed = cx.store.health().await?.is_failed();
+        let mut entity_lfu_cache: EntityLfuCache = LfuCache::new();
+        let mut stream = new_data_stream(cx, latest_block);
+
+        while let Some(result) = stream.next().await {
+            let (record_batch_groups, stream_table_ptr) = result?;
+
+            entity_lfu_cache = process_record_batch_groups(
+                cx,
+                entity_lfu_cache,
+                record_batch_groups,
+                stream_table_ptr,
+                latest_block,
+            )
+            .await?;
+
+            if deployment_is_failed && let Some(block_ptr) = cx.store.block_ptr() {
+                cx.store.unfail_non_deterministic_error(&block_ptr).await?;
+                deployment_is_failed = false;
+            }
+        }
+
+        // Check if the Amp Flight server has data covering through every data
+        // source's endBlock. This handles the case where endBlock has no entity
+        // data — the persisted block pointer never advances to endBlock, but the
+        // server's latest block confirms all queries have been served.
+        if latest_block >= cx.end_block() {
+            cx.metrics.deployment_synced.record(true);
+
+            debug!(cx.logger, "Indexing completed; endBlock reached via server latest block";
+                "latest_block" => latest_block,
+                "end_block" => cx.end_block()
+            );
+            return Ok(());
+        }
+
+        debug!(cx.logger, "Completed indexing iteration";
+            "latest_synced_block_ptr" => ?cx.latest_synced_block_ptr()
+        );
+
+        latest_blocks.changed(cx).await?;
+        cx.backoff.reset();
+    }
+}
+
+async fn run_indexing_with_retries<AC>(cx: &mut Context<AC>) -> Result<()>
+where
+    AC: Client + Send + Sync + 'static,
+{
+    loop {
+        match run_indexing(cx).await {
+            Ok(()) => return Ok(()),
+            Err(e) => {
+                cx.metrics.deployment_status.failed();
+
+                let deterministic = e.is_deterministic();
+
+                cx.store
+                    .fail_subgraph(SubgraphError {
+                        subgraph_id: cx.deployment.cheap_clone(),
+                        message: format!("{e:#}"),
+                        block_ptr: None, // TODO: Find a way to propagate the block ptr here
+                        handler: None,
+                        deterministic,
+                    })
+                    .await?;
+
+                if deterministic {
+                    error!(cx.logger, "Subgraph failed with a deterministic error";
+                        "e" => ?e
+                    );
+                    return Err(e.into());
+                }
+
+                warn!(cx.logger, "Subgraph failed with a non-deterministic error";
+                    "e" => ?e,
+                    "retry_delay_seconds" => cx.backoff.delay().as_secs()
+                );
+
+                cx.backoff.sleep_async().await;
+                debug!(cx.logger, "Restarting indexing");
+            }
+        }
+    }
+}
diff --git a/core/src/amp_subgraph/runner/reorg_handler.rs b/core/src/amp_subgraph/runner/reorg_handler.rs
new file mode 100644
index 00000000000..8f59169304b
--- /dev/null
+++ b/core/src/amp_subgraph/runner/reorg_handler.rs
@@ -0,0 +1,163 @@
+use alloy::primitives::{BlockHash, BlockNumber};
+use anyhow::anyhow;
+use futures::{StreamExt, TryFutureExt, future::try_join_all};
+use graph::{
+    amp::{
+        Client,
+        client::{LatestBlockBeforeReorg, RequestMetadata, ResponseBatch, ResumeStreamingQuery},
+    },
+    blockchain::block_stream::FirehoseCursor,
+};
+use itertools::Itertools;
+use slog::debug;
+
+use super::{Compat, Context, Error, LatestBlocks};
+
+pub(super) async fn check_and_handle_reorg<AC>(
+    cx: &Context<AC>,
+    latest_blocks: &LatestBlocks,
+) -> Result<(), Error>
+where
+    AC: Client,
+{
+    let logger = cx
+        .logger
+        .new(slog::o!("process" => "check_and_handle_reorg"));
+
+    let Some((latest_synced_block_number, latest_synced_block_hash)) = cx.latest_synced_block_ptr()
+    else {
+        debug!(logger, "There are no synced blocks; Skipping reorg check");
+        return Ok(());
+    };
+
+    debug!(logger, "Running reorg check");
+
+    let Some(latest_block_before_reorg) = detect_deepest_reorg(
+        cx,
+        latest_blocks,
+        latest_synced_block_number,
+        latest_synced_block_hash,
+    )
+    .await?
+    else {
+        debug!(logger, "Successfully checked for reorg: No reorg detected";
+            "latest_synced_block" => latest_synced_block_number
+        );
+        return Ok(());
+    };
+
+    let _section = cx.metrics.stopwatch.start_section("handle_reorg");
+
+    debug!(logger, "Handling reorg";
+        "latest_synced_block" => latest_synced_block_number,
+        "latest_block_before_reorg" => ?latest_block_before_reorg.block_number
+    );
+
+    let (block_number, block_hash) = match (
+        latest_block_before_reorg.block_number,
+        latest_block_before_reorg.block_hash,
+    ) {
+        (Some(block_number), Some(block_hash)) => (block_number, block_hash),
+        (_, _) => {
+            // TODO: Handle reorgs to the genesis block
+            return Err(Error::Deterministic(anyhow!(
+                "invalid reorg: rewind to the genesis block not supported"
+            )));
+        }
+    };
+
+    if block_number > latest_synced_block_number {
+        return Err(Error::Deterministic(anyhow!(
+            "invalid reorg: latest block before reorg cannot be higher than the invalidated block"
+        )));
+    } else if block_number == latest_synced_block_number && block_hash == latest_synced_block_hash {
+        return Err(Error::Deterministic(anyhow!(
+            "invalid reorg: latest block before reorg cannot be equal to the invalidated block"
+        )));
+    }
+
+    cx.store
+        .revert_block_operations((block_number, block_hash).compat(), FirehoseCursor::None)
+        .await
+        .map_err(Error::from)?;
+
+    Ok(())
+}
+
+async fn detect_deepest_reorg<AC>(
+    cx: &Context<AC>,
+    latest_blocks: &LatestBlocks,
+    latest_synced_block_number: BlockNumber,
+    latest_synced_block_hash: BlockHash,
+) -> Result<Option<LatestBlockBeforeReorg>, Error>
+where
+    AC: Client,
+{
+    let detect_reorg_futs = latest_blocks
+        .iter()
+        .filter(|(_, latest_block)| *latest_block >= latest_synced_block_number)
+        .map(|((i, j), _)| {
+            let data_source = &cx.manifest.data_sources[*i];
+            let network = &data_source.network;
+            let dataset = &data_source.source.dataset;
+            let table = &data_source.source.tables[*j];
+
+            detect_reorg(
+                cx,
+                network,
+                dataset,
+                table,
+                latest_synced_block_number,
+                latest_synced_block_hash,
+            )
+            .map_err(move |e| e.context(format!("failed to detect reorg in '{dataset}.{table}'")))
+        });
+
+    let deepest_reorg = try_join_all(detect_reorg_futs)
+        .await?
+        .into_iter()
+        .flatten()
+        .min_by_key(|latest_block_before_reorg| latest_block_before_reorg.block_number);
+
+    Ok(deepest_reorg)
+}
+
+async fn detect_reorg<AC>(
+    cx: &Context<AC>,
+    network: &str,
+    dataset: &str,
+    table: &str,
+    latest_synced_block_number: BlockNumber,
+    latest_synced_block_hash: BlockHash,
+) -> Result<Option<LatestBlockBeforeReorg>, Error>
+where
+    AC: Client,
+{
+    let query = format!("SELECT _block_num FROM {dataset}.{table} SETTINGS stream = true");
+    let mut stream = cx.client.query(
+        &cx.logger,
+        query,
+        Some(RequestMetadata {
+            resume_streaming_query: Some(vec![ResumeStreamingQuery {
+                network: network.to_string(),
+                block_number: latest_synced_block_number,
+                block_hash: latest_synced_block_hash,
+            }]),
+        }),
+    );
+
+    let response = stream
+        .next()
+        .await
+        .ok_or_else(|| Error::NonDeterministic(anyhow!("stream is empty")))?
+        .map_err(Error::from)?;
+
+    match response {
+        ResponseBatch::Batch { .. } => Ok(None),
+        ResponseBatch::Reorg(reorg) => reorg
+            .into_iter()
+            .exactly_one()
+            .map_err(|_e| Error::Deterministic(anyhow!("multi-chain datasets are not supported")))
+            .map(Some),
+    }
+}
diff --git a/core/src/lib.rs b/core/src/lib.rs
index 2236519bf3f..118ce3ebaae 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -1,10 +1,6 @@
-pub mod polling_monitor;
-
-mod link_resolver;
-mod subgraph;
+mod subgraph_manifest;
 
-pub use crate::link_resolver::LinkResolver;
-pub use crate::subgraph::{
-    SubgraphAssignmentProvider, SubgraphInstanceManager, SubgraphRegistrar, SubgraphRunner,
-    SubgraphTriggerProcessor,
-};
+pub mod amp_subgraph;
+pub mod polling_monitor;
+pub mod subgraph;
+pub mod subgraph_provider;
diff --git a/core/src/link_resolver.rs b/core/src/link_resolver.rs
deleted file mode 100644
index 364dbd76f10..00000000000
--- a/core/src/link_resolver.rs
+++ /dev/null
@@ -1,406 +0,0 @@
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-use anyhow::anyhow;
-use async_trait::async_trait;
-use bytes::BytesMut;
-use futures01::{stream::poll_fn, try_ready};
-use futures03::stream::FuturesUnordered;
-use graph::env::EnvVars;
-use graph::util::futures::RetryConfigNoTimeout;
-use lru_time_cache::LruCache;
-use serde_json::Value;
-
-use graph::{
-    ipfs_client::{IpfsClient, StatApi},
-    prelude::{LinkResolver as LinkResolverTrait, *},
-};
-
-fn retry_policy<I: Send + Sync>(
-    always_retry: bool,
-    op: &'static str,
-    logger: &Logger,
-) -> RetryConfigNoTimeout<I, graph::prelude::reqwest::Error> {
-    // Even if retries were not requested, networking errors are still retried until we either get
-    // a valid HTTP response or a timeout.
-    if always_retry {
-        retry(op, logger).no_limit()
-    } else {
-        retry(op, logger)
-            .no_limit()
-            .when(|res: &Result<_, reqwest::Error>| match res {
-                Ok(_) => false,
-                Err(e) => !(e.is_status() || e.is_timeout()),
-            })
-    }
-    .no_timeout() // The timeout should be set in the internal future.
-}
-
-/// The IPFS APIs don't have a quick "do you have the file" function. Instead, we
-/// just rely on whether an API times out. That makes sense for IPFS, but not for
-/// our application. We want to be able to quickly select from a potential list
-/// of clients where hopefully one already has the file, and just get the file
-/// from that.
-///
-/// The strategy here then is to use a stat API as a proxy for "do you have the
-/// file". Whichever client has or gets the file first wins. This API is a good
-/// choice, because it doesn't involve us actually starting to download the file
-/// from each client, which would be wasteful of bandwidth and memory in the
-/// case multiple clients respond in a timely manner. In addition, we may make
-/// good use of the stat returned.
-async fn select_fastest_client_with_stat(
-    clients: Arc<Vec<IpfsClient>>,
-    logger: Logger,
-    api: StatApi,
-    path: String,
-    timeout: Duration,
-    do_retry: bool,
-) -> Result<(u64, IpfsClient), Error> {
-    let mut err: Option<Error> = None;
-
-    let mut stats: FuturesUnordered<_> = clients
-        .iter()
-        .enumerate()
-        .map(|(i, c)| {
-            let c = c.cheap_clone();
-            let path = path.clone();
-            retry_policy(do_retry, "IPFS stat", &logger).run(move || {
-                let path = path.clone();
-                let c = c.cheap_clone();
-                async move {
-                    c.stat_size(api, path, timeout)
-                        .map_ok(move |s| (s, i))
-                        .await
-                }
-            })
-        })
-        .collect();
-
-    while let Some(result) = stats.next().await {
-        match result {
-            Ok((stat, index)) => {
-                return Ok((stat, clients[index].cheap_clone()));
-            }
-            Err(e) => err = Some(e.into()),
-        }
-    }
-
-    Err(err.unwrap_or_else(|| {
-        anyhow!(
-            "No IPFS clients were supplied to handle the call to object.stat. File: {}",
-            path
-        )
-    }))
-}
-
-// Returns an error if the stat is bigger than `max_file_bytes`
-fn restrict_file_size(path: &str, size: u64, max_file_bytes: usize) -> Result<(), Error> {
-    if size > max_file_bytes as u64 {
-        return Err(anyhow!(
-            "IPFS file {} is too large. It can be at most {} bytes but is {} bytes",
-            path,
-            max_file_bytes,
-            size
-        ));
-    }
-    Ok(())
-}
-
-#[derive(Clone)]
-pub struct LinkResolver {
-    clients: Arc<Vec<IpfsClient>>,
-    cache: Arc<Mutex<LruCache<String, Vec<u8>>>>,
-    timeout: Duration,
-    retry: bool,
-    env_vars: Arc<EnvVars>,
-}
-
-impl LinkResolver {
-    pub fn new(clients: Vec<IpfsClient>, env_vars: Arc<EnvVars>) -> Self {
-        Self {
-            clients: Arc::new(clients.into_iter().collect()),
-            cache: Arc::new(Mutex::new(LruCache::with_capacity(
-                env_vars.mappings.max_ipfs_cache_size as usize,
-            ))),
-            timeout: env_vars.mappings.ipfs_timeout,
-            retry: false,
-            env_vars,
-        }
-    }
-}
-
-impl Debug for LinkResolver {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("LinkResolver")
-            .field("timeout", &self.timeout)
-            .field("retry", &self.retry)
-            .field("env_vars", &self.env_vars)
-            .finish()
-    }
-}
-
-impl CheapClone for LinkResolver {
-    fn cheap_clone(&self) -> Self {
-        self.clone()
-    }
-}
-
-#[async_trait]
-impl LinkResolverTrait for LinkResolver {
-    fn with_timeout(&self, timeout: Duration) -> Box<dyn LinkResolverTrait> {
-        let mut s = self.cheap_clone();
-        s.timeout = timeout;
-        Box::new(s)
-    }
-
-    fn with_retries(&self) -> Box<dyn LinkResolverTrait> {
-        let mut s = self.cheap_clone();
-        s.retry = true;
-        Box::new(s)
-    }
-
-    /// Supports links of the form `/ipfs/ipfs_hash` or just `ipfs_hash`.
-    async fn cat(&self, logger: &Logger, link: &Link) -> Result<Vec<u8>, Error> {
-        // Discard the `/ipfs/` prefix (if present) to get the hash.
-        let path = link.link.trim_start_matches("/ipfs/").to_owned();
-
-        if let Some(data) = self.cache.lock().unwrap().get(&path) {
-            trace!(logger, "IPFS cache hit"; "hash" => &path);
-            return Ok(data.clone());
-        }
-        trace!(logger, "IPFS cache miss"; "hash" => &path);
-
-        let (size, client) = select_fastest_client_with_stat(
-            self.clients.cheap_clone(),
-            logger.cheap_clone(),
-            StatApi::Files,
-            path.clone(),
-            self.timeout,
-            self.retry,
-        )
-        .await?;
-
-        let max_cache_file_size = self.env_vars.mappings.max_ipfs_cache_file_size;
-        let max_file_size = self.env_vars.mappings.max_ipfs_file_bytes;
-        restrict_file_size(&path, size, max_file_size)?;
-
-        let req_path = path.clone();
-        let timeout = self.timeout;
-        let data = retry_policy(self.retry, "ipfs.cat", logger)
-            .run(move || {
-                let path = req_path.clone();
-                let client = client.clone();
-                async move { Ok(client.cat_all(&path, timeout).await?.to_vec()) }
-            })
-            .await?;
-
-        // The size reported by `files/stat` is not guaranteed to be exact, so check the limit again.
-        restrict_file_size(&path, data.len() as u64, max_file_size)?;
-
-        // Only cache files if they are not too large
-        if data.len() <= max_cache_file_size {
-            let mut cache = self.cache.lock().unwrap();
-            if !cache.contains_key(&path) {
-                cache.insert(path.clone(), data.clone());
-            }
-        } else {
-            debug!(logger, "File too large for cache";
-                        "path" => path,
-                        "size" => data.len()
-            );
-        }
-
-        Ok(data)
-    }
-
-    async fn get_block(&self, logger: &Logger, link: &Link) -> Result<Vec<u8>, Error> {
-        trace!(logger, "IPFS block get"; "hash" => &link.link);
-        let (size, client) = select_fastest_client_with_stat(
-            self.clients.cheap_clone(),
-            logger.cheap_clone(),
-            StatApi::Block,
-            link.link.clone(),
-            self.timeout,
-            self.retry,
-        )
-        .await?;
-
-        let max_file_size = self.env_vars.mappings.max_ipfs_file_bytes;
-        restrict_file_size(&link.link, size, max_file_size)?;
-
-        let link = link.link.clone();
-        let data = retry_policy(self.retry, "ipfs.getBlock", logger)
-            .run(move || {
-                let link = link.clone();
-                let client = client.clone();
-                async move {
-                    let data = client.get_block(link.clone()).await?.to_vec();
-                    Result::<Vec<u8>, reqwest::Error>::Ok(data)
-                }
-            })
-            .await?;
-
-        Ok(data)
-    }
-
-    async fn json_stream(&self, logger: &Logger, link: &Link) -> Result<JsonValueStream, Error> {
-        // Discard the `/ipfs/` prefix (if present) to get the hash.
-        let path = link.link.trim_start_matches("/ipfs/");
-
-        let (size, client) = select_fastest_client_with_stat(
-            self.clients.cheap_clone(),
-            logger.cheap_clone(),
-            StatApi::Files,
-            path.to_string(),
-            self.timeout,
-            self.retry,
-        )
-        .await?;
-
-        let max_file_size = self.env_vars.mappings.max_ipfs_map_file_size;
-        restrict_file_size(path, size, max_file_size)?;
-
-        let mut stream = client.cat(path, None).await?.fuse().boxed().compat();
-
-        let mut buf = BytesMut::with_capacity(1024);
-
-        // Count the number of lines we've already successfully deserialized.
-        // We need that to adjust the line number in error messages from serde_json
-        // to translate from line numbers in the snippet we are deserializing
-        // to the line number in the overall file
-        let mut count = 0;
-
-        let stream: JsonValueStream = Box::pin(
-            poll_fn(move || -> Poll<Option<JsonStreamValue>, Error> {
-                loop {
-                    if let Some(offset) = buf.iter().position(|b| *b == b'\n') {
-                        let line_bytes = buf.split_to(offset + 1);
-                        count += 1;
-                        if line_bytes.len() > 1 {
-                            let line = std::str::from_utf8(&line_bytes)?;
-                            let res = match serde_json::from_str::<Value>(line) {
-                                Ok(v) => Ok(Async::Ready(Some(JsonStreamValue {
-                                    value: v,
-                                    line: count,
-                                }))),
-                                Err(e) => {
-                                    // Adjust the line number in the serde error. This
-                                    // is fun because we can only get at the full error
-                                    // message, and not the error message without line number
-                                    let msg = e.to_string();
-                                    let msg = msg.split(" at line ").next().unwrap();
-                                    Err(anyhow!(
-                                        "{} at line {} column {}: '{}'",
-                                        msg,
-                                        e.line() + count - 1,
-                                        e.column(),
-                                        line
-                                    ))
-                                }
-                            };
-                            return res;
-                        }
-                    } else {
-                        // We only get here if there is no complete line in buf, and
-                        // it is therefore ok to immediately pass an Async::NotReady
-                        // from stream through.
-                        // If we get a None from poll, but still have something in buf,
-                        // that means the input was not terminated with a newline. We
-                        // add that so that the last line gets picked up in the next
-                        // run through the loop.
-                        match try_ready!(stream.poll().map_err(|e| anyhow::anyhow!("{}", e))) {
-                            Some(b) => buf.extend_from_slice(&b),
-                            None if !buf.is_empty() => buf.extend_from_slice(&[b'\n']),
-                            None => return Ok(Async::Ready(None)),
-                        }
-                    }
-                }
-            })
-            .compat(),
-        );
-
-        Ok(stream)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use graph::env::EnvVars;
-    use serde_json::json;
-
-    #[tokio::test]
-    async fn max_file_size() {
-        let mut env_vars = EnvVars::default();
-        env_vars.mappings.max_ipfs_file_bytes = 200;
-
-        let file: &[u8] = &[0u8; 201];
-        let client = IpfsClient::localhost();
-        let resolver = super::LinkResolver::new(vec![client.clone()], Arc::new(env_vars));
-
-        let logger = Logger::root(slog::Discard, o!());
-
-        let link = client.add(file.into()).await.unwrap().hash;
-        let err = LinkResolver::cat(&resolver, &logger, &Link { link: link.clone() })
-            .await
-            .unwrap_err();
-        assert_eq!(
-            err.to_string(),
-            format!(
-                "IPFS file {} is too large. It can be at most 200 bytes but is 212 bytes",
-                link
-            )
-        );
-    }
-
-    async fn json_round_trip(text: &'static str, env_vars: EnvVars) -> Result<Vec<Value>, Error> {
-        let client = IpfsClient::localhost();
-        let resolver = super::LinkResolver::new(vec![client.clone()], Arc::new(env_vars));
-
-        let logger = Logger::root(slog::Discard, o!());
-        let link = client.add(text.as_bytes().into()).await.unwrap().hash;
-
-        let stream = LinkResolver::json_stream(&resolver, &logger, &Link { link }).await?;
-        stream.map_ok(|sv| sv.value).try_collect().await
-    }
-
-    #[tokio::test]
-    async fn read_json_stream() {
-        let values = json_round_trip("\"with newline\"\n", EnvVars::default()).await;
-        assert_eq!(vec![json!("with newline")], values.unwrap());
-
-        let values = json_round_trip("\"without newline\"", EnvVars::default()).await;
-        assert_eq!(vec![json!("without newline")], values.unwrap());
-
-        let values = json_round_trip("\"two\" \n \"things\"", EnvVars::default()).await;
-        assert_eq!(vec![json!("two"), json!("things")], values.unwrap());
-
-        let values = json_round_trip(
-            "\"one\"\n  \"two\" \n [\"bad\" \n \"split\"]",
-            EnvVars::default(),
-        )
-        .await;
-        assert_eq!(
-            "EOF while parsing a list at line 4 column 0: ' [\"bad\" \n'",
-            values.unwrap_err().to_string()
-        );
-    }
-
-    #[tokio::test]
-    async fn ipfs_map_file_size() {
-        let file = "\"small test string that trips the size restriction\"";
-        let mut env_vars = EnvVars::default();
-        env_vars.mappings.max_ipfs_map_file_size = file.len() - 1;
-
-        let err = json_round_trip(file, env_vars).await.unwrap_err();
-
-        assert!(err.to_string().contains(" is too large"));
-
-        env_vars = EnvVars::default();
-        let values = json_round_trip(file, env_vars).await;
-        assert_eq!(
-            vec!["small test string that trips the size restriction"],
-            values.unwrap()
-        );
-    }
-}
diff --git a/core/src/polling_monitor/arweave_service.rs b/core/src/polling_monitor/arweave_service.rs
index f1d77dae197..cc42f7af5ea 100644
--- a/core/src/polling_monitor/arweave_service.rs
+++ b/core/src/polling_monitor/arweave_service.rs
@@ -1,25 +1,24 @@
 use anyhow::Error;
 use bytes::Bytes;
-use futures::future::BoxFuture;
+use graph::futures03::future::BoxFuture;
 use graph::{
-    components::link_resolver::{ArweaveClient, ArweaveResolver, FileSizeLimit},
+    components::link_resolver::{ArweaveResolver, FileSizeLimit},
     data_source::offchain::Base64,
+    derive::CheapClone,
     prelude::CheapClone,
 };
 use std::{sync::Arc, time::Duration};
-use tower::{buffer::Buffer, ServiceBuilder, ServiceExt};
+use tower::{ServiceBuilder, ServiceExt, buffer::Buffer};
 
 pub type ArweaveService = Buffer<Base64, BoxFuture<'static, Result<Option<Bytes>, Error>>>;
 
 pub fn arweave_service(
-    client: Arc<ArweaveClient>,
-    timeout: Duration,
+    client: Arc<dyn ArweaveResolver>,
     rate_limit: u16,
     max_file_size: FileSizeLimit,
 ) -> ArweaveService {
     let arweave = ArweaveServiceInner {
         client,
-        timeout,
         max_file_size,
     };
 
@@ -33,23 +32,12 @@ pub fn arweave_service(
     Buffer::new(svc, u32::MAX as usize)
 }
 
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 struct ArweaveServiceInner {
-    client: Arc<ArweaveClient>,
-    timeout: Duration,
+    client: Arc<dyn ArweaveResolver>,
     max_file_size: FileSizeLimit,
 }
 
-impl CheapClone for ArweaveServiceInner {
-    fn cheap_clone(&self) -> Self {
-        Self {
-            client: self.client.cheap_clone(),
-            timeout: self.timeout,
-            max_file_size: self.max_file_size.cheap_clone(),
-        }
-    }
-}
-
 impl ArweaveServiceInner {
     async fn call_inner(self, req: Base64) -> Result<Option<Bytes>, Error> {
         self.client
diff --git a/core/src/polling_monitor/ipfs_service.rs b/core/src/polling_monitor/ipfs_service.rs
index 5364e77c252..6847bb82acd 100644
--- a/core/src/polling_monitor/ipfs_service.rs
+++ b/core/src/polling_monitor/ipfs_service.rs
@@ -1,28 +1,32 @@
-use anyhow::{anyhow, Error};
-use bytes::Bytes;
-use futures::future::BoxFuture;
-use graph::{
-    ipfs_client::{CidFile, IpfsClient, StatApi},
-    prelude::CheapClone,
-};
+use std::sync::Arc;
 use std::time::Duration;
-use tower::{buffer::Buffer, ServiceBuilder, ServiceExt};
 
-const CLOUDFLARE_TIMEOUT: u16 = 524;
-const GATEWAY_TIMEOUT: u16 = 504;
+use anyhow::Error;
+use anyhow::anyhow;
+use bytes::Bytes;
+use graph::futures03::future::BoxFuture;
+use graph::ipfs::{ContentPath, IpfsClient, IpfsContext, RetryPolicy};
+use graph::{derive::CheapClone, prelude::CheapClone};
+use tower::{ServiceBuilder, ServiceExt, buffer::Buffer};
+
+pub type IpfsService = Buffer<IpfsRequest, BoxFuture<'static, Result<Option<Bytes>, Error>>>;
 
-pub type IpfsService = Buffer<CidFile, BoxFuture<'static, Result<Option<Bytes>, Error>>>;
+#[derive(Debug, Clone, CheapClone)]
+pub struct IpfsRequest {
+    pub ctx: IpfsContext,
+    pub path: ContentPath,
+}
 
 pub fn ipfs_service(
-    client: IpfsClient,
-    max_file_size: u64,
+    client: Arc<dyn IpfsClient>,
+    max_file_size: usize,
     timeout: Duration,
     rate_limit: u16,
 ) -> IpfsService {
     let ipfs = IpfsServiceInner {
         client,
-        max_file_size,
         timeout,
+        max_file_size,
     };
 
     let svc = ServiceBuilder::new()
@@ -35,63 +39,42 @@ pub fn ipfs_service(
     Buffer::new(svc, u32::MAX as usize)
 }
 
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 struct IpfsServiceInner {
-    client: IpfsClient,
-    max_file_size: u64,
+    client: Arc<dyn IpfsClient>,
     timeout: Duration,
-}
-
-impl CheapClone for IpfsServiceInner {
-    fn cheap_clone(&self) -> Self {
-        Self {
-            client: self.client.cheap_clone(),
-            max_file_size: self.max_file_size,
-            timeout: self.timeout,
-        }
-    }
+    max_file_size: usize,
 }
 
 impl IpfsServiceInner {
-    async fn call_inner(self, req: CidFile) -> Result<Option<Bytes>, Error> {
-        let CidFile { cid, path } = req;
-        let multihash = cid.hash().code();
+    async fn call_inner(
+        self,
+        IpfsRequest { ctx, path }: IpfsRequest,
+    ) -> Result<Option<Bytes>, Error> {
+        let multihash = path.cid().hash().code();
         if !SAFE_MULTIHASHES.contains(&multihash) {
             return Err(anyhow!("CID multihash {} is not allowed", multihash));
         }
 
-        let cid_str = match path {
-            Some(path) => format!("{}/{}", cid, path),
-            None => cid.to_string(),
-        };
-
-        let size = match self
+        let res = self
             .client
-            .stat_size(StatApi::Files, cid_str.clone(), self.timeout)
-            .await
-        {
-            Ok(size) => size,
-            Err(e) => match e.status().map(|e| e.as_u16()) {
-                Some(GATEWAY_TIMEOUT) | Some(CLOUDFLARE_TIMEOUT) => return Ok(None),
-                _ if e.is_timeout() => return Ok(None),
-                _ => return Err(e.into()),
-            },
-        };
-
-        if size > self.max_file_size {
-            return Err(anyhow!(
-                "IPFS file {} is too large. It can be at most {} bytes but is {} bytes",
-                cid_str,
+            .cat(
+                &ctx,
+                &path,
                 self.max_file_size,
-                size
-            ));
+                Some(self.timeout),
+                RetryPolicy::None,
+            )
+            .await;
+
+        match res {
+            Ok(file_bytes) => Ok(Some(file_bytes)),
+            Err(err) if err.is_timeout() => {
+                // Timeouts in IPFS mean that the content is not available, so we return `None`.
+                Ok(None)
+            }
+            Err(err) => Err(err.into()),
         }
-
-        Ok(self
-            .client
-            .cat_all(&cid_str, self.timeout)
-            .await
-            .map(Some)?)
     }
 }
 
@@ -118,56 +101,67 @@ const SAFE_MULTIHASHES: [u64; 15] = [
 
 #[cfg(test)]
 mod test {
-    use ipfs::IpfsApi;
-    use ipfs_api as ipfs;
-    use std::{fs, str::FromStr, time::Duration};
-    use tower::ServiceExt;
+    use std::time::Duration;
 
-    use cid::Cid;
-    use graph::{
-        components::link_resolver::{ArweaveClient, ArweaveResolver},
-        data::value::Word,
-        ipfs_client::IpfsClient,
-        tokio,
-    };
+    use graph::components::link_resolver::ArweaveClient;
+    use graph::data::value::Word;
+    use graph::ipfs::test_utils::add_files_to_local_ipfs_node_for_testing;
+    use graph::ipfs::{IpfsContext, IpfsMetrics, IpfsRpcClient, ServerAddress};
+    use graph::log::discard;
+    use tower::ServiceExt;
+    use wiremock::Mock;
+    use wiremock::MockServer;
+    use wiremock::ResponseTemplate;
+    use wiremock::matchers as m;
 
-    use uuid::Uuid;
+    use super::*;
 
-    #[tokio::test]
+    #[graph::test]
     async fn cat_file_in_folder() {
-        let path = "./tests/fixtures/ipfs_folder";
-        let uid = Uuid::new_v4().to_string();
-        fs::write(format!("{}/random.txt", path), &uid).unwrap();
-
-        let cl: ipfs::IpfsClient = ipfs::IpfsClient::default();
-
-        let rsp = cl.add_path(path).await.unwrap();
+        let random_bytes = "One morning, when Gregor Samsa woke \
+          from troubled dreams, he found himself transformed in his bed \
+          into a horrible vermin"
+            .as_bytes()
+            .to_vec();
+        let ipfs_file = ("dir/file.txt", random_bytes.clone());
+
+        let add_resp = add_files_to_local_ipfs_node_for_testing([ipfs_file])
+            .await
+            .unwrap();
 
-        let ipfs_folder = rsp.iter().find(|rsp| rsp.name == "ipfs_folder").unwrap();
+        let dir_cid = add_resp.into_iter().find(|x| x.name == "dir").unwrap().hash;
 
-        let local = IpfsClient::localhost();
-        let cid = Cid::from_str(&ipfs_folder.hash).unwrap();
-        let file = "random.txt".to_string();
+        let client = IpfsRpcClient::new_unchecked(
+            ServerAddress::test_rpc_api(),
+            IpfsMetrics::test(),
+            &graph::log::discard(),
+        )
+        .unwrap();
 
-        let svc = super::ipfs_service(local, 100000, Duration::from_secs(5), 10);
+        let svc = ipfs_service(Arc::new(client), 100000, Duration::from_secs(30), 10);
 
+        let path = ContentPath::new(format!("{dir_cid}/file.txt")).unwrap();
         let content = svc
-            .oneshot(super::CidFile {
-                cid,
-                path: Some(file),
+            .oneshot(IpfsRequest {
+                ctx: IpfsContext::test(),
+                path,
             })
             .await
             .unwrap()
             .unwrap();
-        assert_eq!(content.to_vec(), uid.as_bytes().to_vec());
+
+        assert_eq!(content.to_vec(), random_bytes);
     }
 
-    #[tokio::test]
+    // Ignored because arweave.net is unreliable right now
+    #[graph::test]
+    #[ignore]
     async fn arweave_get() {
         const ID: &str = "8APeQ5lW0-csTcBaGdPBDLAL2ci2AT9pTn2tppGPU_8";
 
-        let cl = ArweaveClient::default();
-        let body = cl.get(&Word::from(ID)).await.unwrap();
+        let Some(body) = ArweaveClient::get_test(&Word::from(ID)).await else {
+            return;
+        };
         let body = String::from_utf8(body).unwrap();
 
         let expected = r#"
@@ -175,4 +169,41 @@ mod test {
         "#.trim_start().trim_end();
         assert_eq!(expected, body);
     }
+
+    #[graph::test]
+    async fn no_client_retries_to_allow_polling_monitor_to_handle_retries_internally() {
+        const CID: &str = "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn";
+
+        let server = MockServer::start().await;
+        let ipfs_client =
+            IpfsRpcClient::new_unchecked(server.uri(), IpfsMetrics::test(), &discard()).unwrap();
+        let ipfs_service = ipfs_service(Arc::new(ipfs_client), 10, Duration::from_secs(1), 1);
+        let path = ContentPath::new(CID).unwrap();
+
+        Mock::given(m::method("POST"))
+            .and(m::path("/api/v0/cat"))
+            .and(m::query_param("arg", CID))
+            .respond_with(ResponseTemplate::new(500))
+            .up_to_n_times(1)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        Mock::given(m::method("POST"))
+            .and(m::path("/api/v0/cat"))
+            .and(m::query_param("arg", CID))
+            .respond_with(ResponseTemplate::new(200))
+            .expect(..=1)
+            .mount(&server)
+            .await;
+
+        // This means that we never reached the successful response.
+        ipfs_service
+            .oneshot(IpfsRequest {
+                ctx: IpfsContext::test(),
+                path,
+            })
+            .await
+            .unwrap_err();
+    }
 }
diff --git a/core/src/polling_monitor/mod.rs b/core/src/polling_monitor/mod.rs
index 3f43254dcad..f8a24db97d7 100644
--- a/core/src/polling_monitor/mod.rs
+++ b/core/src/polling_monitor/mod.rs
@@ -1,6 +1,7 @@
 mod arweave_service;
 mod ipfs_service;
 mod metrics;
+mod request;
 
 use std::collections::HashMap;
 use std::fmt::Display;
@@ -9,28 +10,29 @@ use std::sync::Arc;
 use std::task::Poll;
 use std::time::Duration;
 
-use futures::future::BoxFuture;
-use futures::stream::StreamExt;
-use futures::{stream, Future, FutureExt, TryFutureExt};
 use graph::cheap_clone::CheapClone;
+use graph::env::ENV_VARS;
+use graph::futures03::future::BoxFuture;
+use graph::futures03::stream::StreamExt;
+use graph::futures03::{Future, FutureExt, TryFutureExt, stream};
 use graph::parking_lot::Mutex;
 use graph::prelude::tokio;
 use graph::prometheus::{Counter, Gauge};
-use graph::slog::{debug, Logger};
+use graph::slog::{Logger, debug};
 use graph::util::monitored::MonitoredVecDeque as VecDeque;
 use tokio::sync::{mpsc, watch};
 use tower::retry::backoff::{Backoff, ExponentialBackoff, ExponentialBackoffMaker, MakeBackoff};
 use tower::util::rng::HasherRng;
 use tower::{Service, ServiceExt};
 
+use self::request::RequestId;
+
 pub use self::metrics::PollingMonitorMetrics;
-pub use arweave_service::{arweave_service, ArweaveService};
-pub use ipfs_service::{ipfs_service, IpfsService};
+pub use arweave_service::{ArweaveService, arweave_service};
+pub use ipfs_service::{IpfsRequest, IpfsService, ipfs_service};
 
 const MIN_BACKOFF: Duration = Duration::from_secs(5);
 
-const MAX_BACKOFF: Duration = Duration::from_secs(600);
-
 struct Backoffs<ID> {
     backoff_maker: ExponentialBackoffMaker,
     backoffs: HashMap<ID, ExponentialBackoff>,
@@ -42,7 +44,7 @@ impl<ID: Eq + Hash> Backoffs<ID> {
         Self {
             backoff_maker: ExponentialBackoffMaker::new(
                 MIN_BACKOFF,
-                MAX_BACKOFF,
+                ENV_VARS.mappings.fds_max_backoff,
                 1.0,
                 HasherRng::new(),
             )
@@ -51,7 +53,7 @@ impl<ID: Eq + Hash> Backoffs<ID> {
         }
     }
 
-    fn next_backoff(&mut self, id: ID) -> impl Future<Output = ()> {
+    fn next_backoff(&mut self, id: ID) -> impl Future<Output = ()> + Send + use<ID> {
         self.backoffs
             .entry(id)
             .or_insert_with(|| self.backoff_maker.make_backoff())
@@ -98,15 +100,15 @@ impl<T> Queue<T> {
 ///
 /// The service returns the request ID along with errors or responses. The response is an
 /// `Option`, to represent the object not being found.
-pub fn spawn_monitor<ID, S, E, Res: Send + 'static>(
+pub fn spawn_monitor<Req, S, E, Res: Send + 'static>(
     service: S,
-    response_sender: mpsc::UnboundedSender<(ID, Res)>,
+    response_sender: mpsc::UnboundedSender<(Req, Res)>,
     logger: Logger,
     metrics: Arc<PollingMonitorMetrics>,
-) -> PollingMonitor<ID>
+) -> PollingMonitor<Req>
 where
-    S: Service<ID, Response = Option<Res>, Error = E> + Send + 'static,
-    ID: Display + Clone + Default + Eq + Send + Sync + Hash + 'static,
+    S: Service<Req, Response = Option<Res>, Error = E> + Send + 'static,
+    Req: RequestId + Clone + Send + Sync + 'static,
     E: Display + Send + 'static,
     S::Future: Send,
 {
@@ -126,13 +128,13 @@ where
                         break None;
                     }
 
-                    let id = queue.pop_front();
-                    match id {
-                        Some(id) => break Some((id, ())),
+                    let req = queue.pop_front();
+                    match req {
+                        Some(req) => break Some((req, ())),
 
                         // Nothing on the queue, wait for a queue wake up or cancellation.
                         None => {
-                            futures::future::select(
+                            graph::futures03::future::select(
                                 // Unwrap: `queue` holds a sender.
                                 queue_woken.changed().map(|r| r.unwrap()).boxed(),
                                 cancel_check.closed().boxed(),
@@ -155,39 +157,39 @@ where
                 // the `CallAll` from being polled. This can cause starvation as those requests may
                 // be holding on to resources such as slots for concurrent calls.
                 match response {
-                    Ok((id, Some(response))) => {
-                        backoffs.remove(&id);
-                        let send_result = response_sender.send((id, response));
+                    Ok((req, Some(response))) => {
+                        backoffs.remove(req.request_id());
+                        let send_result = response_sender.send((req, response));
                         if send_result.is_err() {
                             // The receiver has been dropped, cancel this task.
                             break;
                         }
                     }
 
-                    // Object not found, push the id to the back of the queue.
-                    Ok((id, None)) => {
-                        debug!(logger, "not found on polling"; "object_id" => id.to_string());
-
+                    // Object not found, push the request to the back of the queue.
+                    Ok((req, None)) => {
+                        debug!(logger, "not found on polling"; "object_id" => req.request_id().to_string());
                         metrics.not_found.inc();
-                        queue.push_back(id);
+
+                        // We'll try again after a backoff.
+                        backoff(req, &queue, &mut backoffs);
                     }
 
-                    // Error polling, log it and push the id to the back of the queue.
-                    Err((id, e)) => {
-                        debug!(logger, "error polling";
-                                    "error" => format!("{:#}", e),
-                                    "object_id" => id.to_string());
+                    // Error polling, log it and push the request to the back of the queue.
+                    Err((Some(req), e)) => {
+                        debug!(logger, "error polling"; "error" => format!("{:#}", e), "object_id" => req.request_id().to_string());
                         metrics.errors.inc();
 
                         // Requests that return errors could mean there is a permanent issue with
                         // fetching the given item, or could signal the endpoint is overloaded.
                         // Either way a backoff makes sense.
-                        let queue = queue.cheap_clone();
-                        let backoff = backoffs.next_backoff(id.clone());
-                        graph::spawn(async move {
-                            backoff.await;
-                            queue.push_back(id);
-                        });
+                        backoff(req, &queue, &mut backoffs);
+                    }
+
+                    // poll_ready call failure
+                    Err((None, e)) => {
+                        debug!(logger, "error polling"; "error" => format!("{:#}", e));
+                        metrics.errors.inc();
                     }
                 }
             }
@@ -197,16 +199,28 @@ where
     PollingMonitor { queue }
 }
 
+fn backoff<Req>(req: Req, queue: &Arc<Queue<Req>>, backoffs: &mut Backoffs<Req::Id>)
+where
+    Req: RequestId + Send + Sync + 'static,
+{
+    let queue = queue.cheap_clone();
+    let backoff = backoffs.next_backoff(req.request_id().clone());
+    graph::spawn(async move {
+        backoff.await;
+        queue.push_back(req);
+    });
+}
+
 /// Handle for adding objects to be monitored.
-pub struct PollingMonitor<ID> {
-    queue: Arc<Queue<ID>>,
+pub struct PollingMonitor<Req> {
+    queue: Arc<Queue<Req>>,
 }
 
-impl<ID> PollingMonitor<ID> {
-    /// Add an object id to the polling queue. New requests have priority and are pushed to the
+impl<Req> PollingMonitor<Req> {
+    /// Add a request to the polling queue. New requests have priority and are pushed to the
     /// front of the queue.
-    pub fn monitor(&self, id: ID) {
-        self.queue.push_front(id);
+    pub fn monitor(&self, req: Req) {
+        self.queue.push_front(req);
     }
 }
 
@@ -217,17 +231,16 @@ struct ReturnRequest<S> {
 impl<S, Req> Service<Req> for ReturnRequest<S>
 where
     S: Service<Req>,
-    Req: Clone + Default + Send + Sync + 'static,
+    Req: Clone + Send + Sync + 'static,
     S::Error: Send,
     S::Future: Send + 'static,
 {
     type Response = (Req, S::Response);
-    type Error = (Req, S::Error);
+    type Error = (Option<Req>, S::Error);
     type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>;
 
     fn poll_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
-        // `Req::default` is a value that won't be used since if `poll_ready` errors, the service is shot anyways.
-        self.service.poll_ready(cx).map_err(|e| (Req::default(), e))
+        self.service.poll_ready(cx).map_err(|e| (None, e))
     }
 
     fn call(&mut self, req: Req) -> Self::Future {
@@ -235,7 +248,7 @@ where
         self.service
             .call(req.clone())
             .map_ok(move |x| (req, x))
-            .map_err(move |e| (req1, e))
+            .map_err(move |e| (Some(req1), e))
             .boxed()
     }
 }
@@ -268,7 +281,7 @@ mod tests {
         (handle, monitor, rx)
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn polling_monitor_shared_svc() {
         let (svc, mut handle) = mock::pair();
         let shared_svc = tower::buffer::Buffer::new(tower::limit::ConcurrencyLimit::new(svc, 1), 1);
@@ -290,7 +303,7 @@ mod tests {
         assert_eq!(rx1.recv().await, Some(("req-0", "res-0")));
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn polling_monitor_simple() {
         let (mut handle, monitor, mut rx) = setup();
 
@@ -300,7 +313,7 @@ mod tests {
         assert_eq!(rx.recv().await, Some(("req-0", "res-0")));
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn polling_monitor_unordered() {
         let (mut handle, monitor, mut rx) = setup();
 
@@ -317,7 +330,7 @@ mod tests {
         assert_eq!(rx.recv().await, Some(("req-1", "res-1")));
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn polling_monitor_failed_push_to_back() {
         let (mut handle, monitor, mut rx) = setup();
 
@@ -341,8 +354,10 @@ mod tests {
         assert_eq!(rx.recv().await, Some(("req-1", "res-1")));
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn polling_monitor_cancelation() {
+        const REQ: &str = "req-0";
+
         // Cancelation on receiver drop, no pending request.
         let (mut handle, _monitor, rx) = setup();
         drop(rx);
@@ -350,9 +365,20 @@ mod tests {
 
         // Cancelation on receiver drop, with pending request.
         let (mut handle, monitor, rx) = setup();
-        monitor.monitor("req-0");
+        monitor.monitor(REQ);
         drop(rx);
-        assert!(handle.next_request().await.is_none());
+        let mut next = handle.next_request().await;
+        if let Some((req, responder)) = next {
+            // The request may or may not have been pulled from the queue
+            // before cancelation.
+            assert_eq!(REQ, req);
+            // Explicitly complete the request so the monitor task can process it
+            // and detect the cancellation. Dropping the responder without responding
+            // is racy in a multi-threaded runtime.
+            responder.send_error(anyhow!("cancelled"));
+            next = handle.next_request().await;
+        }
+        assert!(next.is_none());
 
         // Cancelation on receiver drop, while queue is waiting.
         let (mut handle, _monitor, rx) = setup();
diff --git a/core/src/polling_monitor/request.rs b/core/src/polling_monitor/request.rs
new file mode 100644
index 00000000000..42375fb38fb
--- /dev/null
+++ b/core/src/polling_monitor/request.rs
@@ -0,0 +1,39 @@
+use std::fmt::Display;
+use std::hash::Hash;
+
+use graph::{data_source::offchain::Base64, ipfs::ContentPath};
+
+use crate::polling_monitor::ipfs_service::IpfsRequest;
+
+/// Request ID is used to create backoffs on request failures.
+pub trait RequestId {
+    type Id: Clone + Display + Eq + Hash + Send + Sync + 'static;
+
+    /// Returns the ID of the request.
+    fn request_id(&self) -> &Self::Id;
+}
+
+impl RequestId for IpfsRequest {
+    type Id = ContentPath;
+
+    fn request_id(&self) -> &ContentPath {
+        &self.path
+    }
+}
+
+impl RequestId for Base64 {
+    type Id = Base64;
+
+    fn request_id(&self) -> &Base64 {
+        self
+    }
+}
+
+#[cfg(debug_assertions)]
+impl RequestId for &'static str {
+    type Id = &'static str;
+
+    fn request_id(&self) -> &Self::Id {
+        self
+    }
+}
diff --git a/core/src/subgraph/context/instance/hosts.rs b/core/src/subgraph/context/instance/hosts.rs
index 73701fadb29..9c18e12ce1e 100644
--- a/core/src/subgraph/context/instance/hosts.rs
+++ b/core/src/subgraph/context/instance/hosts.rs
@@ -57,7 +57,7 @@ impl<C: Blockchain, T: RuntimeHostBuilder<C>> OnchainHosts<C, T> {
     }
 
     pub fn push(&mut self, host: Arc<T::Host>) {
-        assert!(host.data_source().as_onchain().is_some());
+        assert!(host.data_source().is_chain_based());
 
         self.hosts.push(host.cheap_clone());
         let idx = self.hosts.len() - 1;
@@ -194,7 +194,7 @@ impl<C: Blockchain, T: RuntimeHostBuilder<C>> OffchainHosts<C, T> {
     pub fn matches_by_address<'a>(
         &'a self,
         address: Option<&[u8]>,
-    ) -> Box<dyn Iterator<Item = &T::Host> + Send + 'a> {
+    ) -> Box<dyn Iterator<Item = &'a T::Host> + Send + 'a> {
         let Some(address) = address else {
             return Box::new(self.by_block.values().flatten().map(|host| host.as_ref()));
         };
diff --git a/core/src/subgraph/context/instance/mod.rs b/core/src/subgraph/context/instance/mod.rs
index 26ccad08efa..494ae227e97 100644
--- a/core/src/subgraph/context/instance/mod.rs
+++ b/core/src/subgraph/context/instance/mod.rs
@@ -1,19 +1,19 @@
 mod hosts;
 
 use anyhow::ensure;
-use futures01::sync::mpsc::Sender;
+use graph::futures01::sync::mpsc::Sender;
 use graph::{
     blockchain::{Blockchain, TriggerData as _},
     data_source::{
-        causality_region::CausalityRegionSeq, offchain, CausalityRegion, DataSource,
-        DataSourceTemplate, TriggerData,
+        CausalityRegion, DataSource, DataSourceTemplate, TriggerData,
+        causality_region::CausalityRegionSeq, offchain,
     },
     prelude::*,
 };
 use hosts::{OffchainHosts, OnchainHosts};
 use std::collections::HashMap;
 
-pub(super) struct SubgraphInstance<C: Blockchain, T: RuntimeHostBuilder<C>> {
+pub(crate) struct SubgraphInstance<C: Blockchain, T: RuntimeHostBuilder<C>> {
     subgraph_id: DeploymentHash,
     network: String,
     host_builder: T,
@@ -22,13 +22,17 @@ pub(super) struct SubgraphInstance<C: Blockchain, T: RuntimeHostBuilder<C>> {
     pub(super) static_data_sources: Arc<Vec<DataSource<C>>>,
     host_metrics: Arc<HostMetrics>,
 
-    /// The hosts represent the data sources in the subgraph. There is one host per data source.
+    /// The hosts represent the onchain data sources in the subgraph. There is one host per data source.
     /// Data sources with no mappings (e.g. direct substreams) have no host.
     ///
     /// Onchain hosts must be created in increasing order of block number. `fn hosts_for_trigger`
     /// will return the onchain hosts in the same order as they were inserted.
     onchain_hosts: OnchainHosts<C, T>,
 
+    /// `subgraph_hosts` represent subgraph data sources declared in the manifest. These are a special
+    /// kind of data source that depends on the data from another source subgraph.
+    subgraph_hosts: OnchainHosts<C, T>,
+
     offchain_hosts: OffchainHosts<C, T>,
 
     /// Maps the hash of a module to a channel to the thread in which the module is instantiated.
@@ -79,6 +83,7 @@ where
             network,
             static_data_sources: Arc::new(manifest.data_sources),
             onchain_hosts: OnchainHosts::new(),
+            subgraph_hosts: OnchainHosts::new(),
             offchain_hosts: OffchainHosts::new(),
             module_cache: HashMap::new(),
             templates,
@@ -95,11 +100,11 @@ where
     ) -> Result<Option<Arc<T::Host>>, Error> {
         let module_bytes = match &data_source.runtime() {
             None => return Ok(None),
-            Some(ref module_bytes) => module_bytes.cheap_clone(),
+            Some(module_bytes) => module_bytes.cheap_clone(),
         };
 
         let mapping_request_sender = {
-            let module_hash = tiny_keccak::keccak256(module_bytes.as_ref());
+            let module_hash = alloy::primitives::keccak256(module_bytes.as_ref()).0;
             if let Some(sender) = self.module_cache.get(&module_hash) {
                 sender.clone()
             } else {
@@ -138,33 +143,46 @@ where
             );
         }
 
-        let is_onchain = data_source.is_onchain();
-        let Some(host) = self.new_host(logger.clone(), data_source)? else { return Ok(None) };
+        let Some(host) = self.new_host(logger.clone(), data_source)? else {
+            return Ok(None);
+        };
 
         // Check for duplicates and add the host.
-        if is_onchain {
-            // `onchain_hosts` will remain ordered by the creation block.
-            // See also 8f1bca33-d3b7-4035-affc-fd6161a12448.
-            ensure!(
-                self.onchain_hosts
-                    .last()
-                    .and_then(|h| h.creation_block_number())
-                    <= host.data_source().creation_block(),
-            );
+        match host.data_source() {
+            DataSource::Onchain(_) => {
+                // `onchain_hosts` will remain ordered by the creation block.
+                // See also 8f1bca33-d3b7-4035-affc-fd6161a12448.
+                ensure!(
+                    self.onchain_hosts
+                        .last()
+                        .and_then(|h| h.creation_block_number())
+                        <= host.data_source().creation_block(),
+                );
 
-            if self.onchain_hosts.contains(&host) {
-                Ok(None)
-            } else {
-                self.onchain_hosts.push(host.cheap_clone());
-                Ok(Some(host))
+                if self.onchain_hosts.contains(&host) {
+                    Ok(None)
+                } else {
+                    self.onchain_hosts.push(host.cheap_clone());
+                    Ok(Some(host))
+                }
             }
-        } else {
-            if self.offchain_hosts.contains(&host) {
-                Ok(None)
-            } else {
-                self.offchain_hosts.push(host.cheap_clone());
-                Ok(Some(host))
+            DataSource::Offchain(_) => {
+                if self.offchain_hosts.contains(&host) {
+                    Ok(None)
+                } else {
+                    self.offchain_hosts.push(host.cheap_clone());
+                    Ok(Some(host))
+                }
+            }
+            DataSource::Subgraph(_) => {
+                if self.subgraph_hosts.contains(&host) {
+                    Ok(None)
+                } else {
+                    self.subgraph_hosts.push(host.cheap_clone());
+                    Ok(Some(host))
+                }
             }
+            DataSource::Amp(_) => unreachable!(),
         }
     }
 
@@ -223,7 +241,10 @@ where
                 .matches_by_address(trigger.address_match()),
             TriggerData::Offchain(trigger) => self
                 .offchain_hosts
-                .matches_by_address(trigger.source.address().as_ref().map(|a| a.as_slice())),
+                .matches_by_address(trigger.source.address().as_deref()),
+            TriggerData::Subgraph(trigger) => self
+                .subgraph_hosts
+                .matches_by_address(Some(trigger.source.to_bytes().as_slice())),
         }
     }
 
@@ -234,8 +255,4 @@ where
     pub fn hosts_len(&self) -> usize {
         self.onchain_hosts.len() + self.offchain_hosts.len()
     }
-
-    pub fn first_host(&self) -> Option<&Arc<T::Host>> {
-        self.onchain_hosts.hosts().first()
-    }
 }
diff --git a/core/src/subgraph/context/mod.rs b/core/src/subgraph/context/mod.rs
index 51238411d4a..affbc09aa0f 100644
--- a/core/src/subgraph/context/mod.rs
+++ b/core/src/subgraph/context/mod.rs
@@ -1,44 +1,42 @@
 mod instance;
 
 use crate::polling_monitor::{
-    spawn_monitor, ArweaveService, IpfsService, PollingMonitor, PollingMonitorMetrics,
+    ArweaveService, IpfsRequest, IpfsService, PollingMonitor, PollingMonitorMetrics, spawn_monitor,
 };
 use anyhow::{self, Error};
 use bytes::Bytes;
 use graph::{
-    blockchain::{BlockTime, Blockchain},
-    components::{
-        store::{DeploymentId, SubgraphFork},
-        subgraph::{HostMetrics, MappingError, RuntimeHost as _, SharedProofOfIndexing},
-    },
+    blockchain::Blockchain,
+    components::{store::DeploymentId, subgraph::HostMetrics},
     data::subgraph::SubgraphManifest,
     data_source::{
+        CausalityRegion, DataSource, DataSourceTemplate,
         causality_region::CausalityRegionSeq,
         offchain::{self, Base64},
-        CausalityRegion, DataSource, DataSourceTemplate, TriggerData,
     },
-    ipfs_client::CidFile,
+    derive::CheapClone,
+    ipfs::IpfsContext,
     prelude::{
-        BlockNumber, BlockPtr, BlockState, CancelGuard, CheapClone, DeploymentHash,
-        MetricsRegistry, RuntimeHostBuilder, SubgraphCountMetric, SubgraphInstanceMetrics,
-        TriggerProcessor,
+        BlockNumber, CancelGuard, CheapClone, DeploymentHash, MetricsRegistry, RuntimeHostBuilder,
+        SubgraphCountMetric, TriggerProcessor,
     },
     slog::Logger,
-    tokio::sync::mpsc,
 };
-use std::sync::{Arc, RwLock};
-use std::{collections::HashMap, time::Instant};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use graph::parking_lot::RwLock;
+use tokio::sync::mpsc;
 
 use self::instance::SubgraphInstance;
+use super::Decoder;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, CheapClone, Debug)]
 pub struct SubgraphKeepAlive {
     alive_map: Arc<RwLock<HashMap<DeploymentId, CancelGuard>>>,
     sg_metrics: Arc<SubgraphCountMetric>,
 }
 
-impl CheapClone for SubgraphKeepAlive {}
-
 impl SubgraphKeepAlive {
     pub fn new(sg_metrics: Arc<SubgraphCountMetric>) -> Self {
         Self {
@@ -48,15 +46,19 @@ impl SubgraphKeepAlive {
     }
 
     pub fn remove(&self, deployment_id: &DeploymentId) {
-        self.alive_map.write().unwrap().remove(deployment_id);
+        self.alive_map.write().remove(deployment_id);
         self.sg_metrics.running_count.dec();
     }
     pub fn insert(&self, deployment_id: DeploymentId, guard: CancelGuard) {
-        let old = self.alive_map.write().unwrap().insert(deployment_id, guard);
+        let old = self.alive_map.write().insert(deployment_id, guard);
         if old.is_none() {
             self.sg_metrics.running_count.inc();
         }
     }
+
+    pub fn contains(&self, deployment_id: &DeploymentId) -> bool {
+        self.alive_map.read().contains_key(deployment_id)
+    }
 }
 
 // The context keeps track of mutable in-memory state that is retained across blocks.
@@ -69,11 +71,11 @@ where
     T: RuntimeHostBuilder<C>,
     C: Blockchain,
 {
-    instance: SubgraphInstance<C, T>,
+    pub(crate) instance: SubgraphInstance<C, T>,
     pub instances: SubgraphKeepAlive,
     pub offchain_monitor: OffchainMonitor,
-    pub filter: Option<C::TriggerFilter>,
-    trigger_processor: Box<dyn TriggerProcessor<C, T>>,
+    pub(crate) trigger_processor: Box<dyn TriggerProcessor<C, T>>,
+    pub(crate) decoder: Box<Decoder<C, T>>,
 }
 
 impl<C: Blockchain, T: RuntimeHostBuilder<C>> IndexingContext<C, T> {
@@ -85,6 +87,7 @@ impl<C: Blockchain, T: RuntimeHostBuilder<C>> IndexingContext<C, T> {
         instances: SubgraphKeepAlive,
         offchain_monitor: OffchainMonitor,
         trigger_processor: Box<dyn TriggerProcessor<C, T>>,
+        decoder: Box<Decoder<C, T>>,
     ) -> Self {
         let instance = SubgraphInstance::new(
             manifest,
@@ -97,127 +100,11 @@ impl<C: Blockchain, T: RuntimeHostBuilder<C>> IndexingContext<C, T> {
             instance,
             instances,
             offchain_monitor,
-            filter: None,
             trigger_processor,
+            decoder,
         }
     }
 
-    pub async fn process_trigger(
-        &self,
-        logger: &Logger,
-        block: &Arc<C::Block>,
-        trigger: &TriggerData<C>,
-        state: BlockState<C>,
-        proof_of_indexing: &SharedProofOfIndexing,
-        causality_region: &str,
-        debug_fork: &Option<Arc<dyn SubgraphFork>>,
-        subgraph_metrics: &Arc<SubgraphInstanceMetrics>,
-        instrument: bool,
-    ) -> Result<BlockState<C>, MappingError> {
-        self.process_trigger_in_hosts(
-            logger,
-            self.instance.hosts_for_trigger(trigger),
-            block,
-            trigger,
-            state,
-            proof_of_indexing,
-            causality_region,
-            debug_fork,
-            subgraph_metrics,
-            instrument,
-        )
-        .await
-    }
-
-    pub async fn process_block(
-        &self,
-        logger: &Logger,
-        block_ptr: BlockPtr,
-        block_time: BlockTime,
-        block_data: Box<[u8]>,
-        handler: String,
-        mut state: BlockState<C>,
-        proof_of_indexing: &SharedProofOfIndexing,
-        causality_region: &str,
-        debug_fork: &Option<Arc<dyn SubgraphFork>>,
-        subgraph_metrics: &Arc<SubgraphInstanceMetrics>,
-        instrument: bool,
-    ) -> Result<BlockState<C>, MappingError> {
-        let error_count = state.deterministic_errors.len();
-
-        if let Some(proof_of_indexing) = proof_of_indexing {
-            proof_of_indexing
-                .borrow_mut()
-                .start_handler(causality_region);
-        }
-
-        let start = Instant::now();
-
-        // This flow is expected to have a single data source(and a corresponding host) which
-        // gets executed every block.
-        state = self
-            .instance
-            .first_host()
-            .expect("Expected this flow to have exactly one host")
-            .process_block(
-                logger,
-                block_ptr,
-                block_time,
-                block_data,
-                handler,
-                state,
-                proof_of_indexing.cheap_clone(),
-                debug_fork,
-                instrument,
-            )
-            .await?;
-
-        let elapsed = start.elapsed().as_secs_f64();
-        subgraph_metrics.observe_trigger_processing_duration(elapsed);
-
-        if let Some(proof_of_indexing) = proof_of_indexing {
-            if state.deterministic_errors.len() != error_count {
-                assert!(state.deterministic_errors.len() == error_count + 1);
-
-                // If a deterministic error has happened, write a new
-                // ProofOfIndexingEvent::DeterministicError to the SharedProofOfIndexing.
-                proof_of_indexing
-                    .borrow_mut()
-                    .write_deterministic_error(logger, causality_region);
-            }
-        }
-
-        Ok(state)
-    }
-    pub async fn process_trigger_in_hosts(
-        &self,
-        logger: &Logger,
-        hosts: Box<dyn Iterator<Item = &T::Host> + Send + '_>,
-        block: &Arc<C::Block>,
-        trigger: &TriggerData<C>,
-        state: BlockState<C>,
-        proof_of_indexing: &SharedProofOfIndexing,
-        causality_region: &str,
-        debug_fork: &Option<Arc<dyn SubgraphFork>>,
-        subgraph_metrics: &Arc<SubgraphInstanceMetrics>,
-        instrument: bool,
-    ) -> Result<BlockState<C>, MappingError> {
-        self.trigger_processor
-            .process_trigger(
-                logger,
-                hosts,
-                block,
-                trigger,
-                state,
-                proof_of_indexing,
-                causality_region,
-                debug_fork,
-                subgraph_metrics,
-                instrument,
-            )
-            .await
-    }
-
     /// Removes data sources hosts with a creation block greater or equal to `reverted_block`, so
     /// that they are no longer candidates for `process_trigger`.
     ///
@@ -227,12 +114,12 @@ impl<C: Blockchain, T: RuntimeHostBuilder<C>> IndexingContext<C, T> {
     /// `process_trigger`.
     ///
     /// File data sources that have been marked not done during this process will get re-queued
-    pub fn revert_data_sources(&mut self, reverted_block: BlockNumber) -> Result<(), Error> {
+    pub fn revert_data_sources(&mut self, reverted_block: BlockNumber) {
         let removed = self.instance.revert_data_sources(reverted_block);
 
         removed
             .into_iter()
-            .try_for_each(|source| self.offchain_monitor.add_source(source))
+            .for_each(|source| self.offchain_monitor.add_source(source))
     }
 
     pub fn add_dynamic_data_source(
@@ -245,12 +132,12 @@ impl<C: Blockchain, T: RuntimeHostBuilder<C>> IndexingContext<C, T> {
             .map(|ds| (ds.source.clone(), ds.is_processed()));
         let host = self.instance.add_dynamic_data_source(logger, data_source)?;
 
-        if host.is_some() {
-            if let Some((source, is_processed)) = offchain_fields {
-                // monitor data source only if it has not yet been processed.
-                if !is_processed {
-                    self.offchain_monitor.add_source(source)?;
-                }
+        if host.is_some()
+            && let Some((source, is_processed)) = offchain_fields
+        {
+            // monitor data source only if it has not yet been processed.
+            if !is_processed {
+                self.offchain_monitor.add_source(source);
             }
         }
 
@@ -279,10 +166,12 @@ impl<C: Blockchain, T: RuntimeHostBuilder<C>> IndexingContext<C, T> {
 }
 
 pub struct OffchainMonitor {
-    ipfs_monitor: PollingMonitor<CidFile>,
-    ipfs_monitor_rx: mpsc::UnboundedReceiver<(CidFile, Bytes)>,
+    ipfs_monitor: PollingMonitor<IpfsRequest>,
+    ipfs_monitor_rx: mpsc::UnboundedReceiver<(IpfsRequest, Bytes)>,
     arweave_monitor: PollingMonitor<Base64>,
     arweave_monitor_rx: mpsc::UnboundedReceiver<(Base64, Bytes)>,
+    deployment_hash: DeploymentHash,
+    logger: Logger,
 }
 
 impl OffchainMonitor {
@@ -306,31 +195,41 @@ impl OffchainMonitor {
             metrics.cheap_clone(),
         );
 
-        let arweave_monitor = spawn_monitor(arweave_service, arweave_monitor_tx, logger, metrics);
+        let arweave_monitor = spawn_monitor(
+            arweave_service,
+            arweave_monitor_tx,
+            logger.cheap_clone(),
+            metrics,
+        );
+
         Self {
             ipfs_monitor,
             ipfs_monitor_rx,
             arweave_monitor,
             arweave_monitor_rx,
+            deployment_hash: subgraph_hash.to_owned(),
+            logger,
         }
     }
 
-    fn add_source(&mut self, source: offchain::Source) -> Result<(), Error> {
+    fn add_source(&mut self, source: offchain::Source) {
         match source {
-            offchain::Source::Ipfs(cid_file) => self.ipfs_monitor.monitor(cid_file),
+            offchain::Source::Ipfs(path) => self.ipfs_monitor.monitor(IpfsRequest {
+                ctx: IpfsContext::new(&self.deployment_hash, &self.logger),
+                path,
+            }),
             offchain::Source::Arweave(base64) => self.arweave_monitor.monitor(base64),
         };
-        Ok(())
     }
 
     pub fn ready_offchain_events(&mut self) -> Result<Vec<offchain::TriggerData>, Error> {
-        use graph::tokio::sync::mpsc::error::TryRecvError;
+        use tokio::sync::mpsc::error::TryRecvError;
 
         let mut triggers = vec![];
         loop {
             match self.ipfs_monitor_rx.try_recv() {
-                Ok((cid_file, data)) => triggers.push(offchain::TriggerData {
-                    source: offchain::Source::Ipfs(cid_file),
+                Ok((req, data)) => triggers.push(offchain::TriggerData {
+                    source: offchain::Source::Ipfs(req.path),
                     data: Arc::new(data),
                 }),
                 Err(TryRecvError::Disconnected) => {
diff --git a/core/src/subgraph/error.rs b/core/src/subgraph/error.rs
index b3131255aed..00413acb258 100644
--- a/core/src/subgraph/error.rs
+++ b/core/src/subgraph/error.rs
@@ -1,28 +1,191 @@
 use graph::data::subgraph::schema::SubgraphError;
-use graph::prelude::{thiserror, Error, StoreError};
+use graph::env::ENV_VARS;
+use graph::prelude::{Error, StoreError, anyhow, thiserror};
 
+pub trait DeterministicError: std::fmt::Debug + std::fmt::Display + Send + Sync + 'static {}
+
+impl DeterministicError for SubgraphError {}
+
+impl DeterministicError for StoreError {}
+
+impl DeterministicError for anyhow::Error {}
+
+/// Classification of processing errors for unified error handling.
+///
+/// This enum provides a consistent way to categorize errors and determine
+/// the appropriate response. The error handling invariants are:
+///
+/// - **Deterministic**: Stop processing the current block, persist PoI only.
+///   The subgraph will be marked as failed. These errors are reproducible
+///   and indicate a bug in the subgraph or a permanent data issue.
+///
+/// - **NonDeterministic**: Retry with exponential backoff. These errors are
+///   transient (network issues, temporary database problems) and may succeed
+///   on retry.
+///
+/// - **PossibleReorg**: Restart the block stream cleanly without persisting.
+///   The block stream needs to be restarted to detect and handle a potential
+///   blockchain reorganization.
+///
+/// - **Canceled**: The subgraph was canceled (unassigned or shut down).
+///   No error should be recorded; this is a clean shutdown.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProcessingErrorKind {
+    /// Error is deterministic - stop processing, persist PoI only
+    Deterministic,
+    /// Error is non-deterministic - retry with backoff
+    NonDeterministic,
+    /// Possible blockchain reorg detected - restart block stream cleanly
+    PossibleReorg,
+    /// Processing was canceled - clean shutdown
+    Canceled,
+}
+
+/// An error happened during processing and we need to classify errors into
+/// deterministic and non-deterministic errors. This struct holds the result
+/// of that classification
 #[derive(thiserror::Error, Debug)]
-pub enum BlockProcessingError {
+pub enum ProcessingError {
     #[error("{0:#}")]
-    Unknown(#[from] Error),
+    Unknown(Error),
 
     // The error had a deterministic cause but, for a possibly non-deterministic reason, we chose to
     // halt processing due to the error.
     #[error("{0}")]
-    Deterministic(SubgraphError),
+    Deterministic(Box<dyn DeterministicError>),
+
+    /// A possible blockchain reorganization was detected.
+    /// The block stream should be restarted to detect and handle the reorg.
+    #[error("possible reorg detected: {0:#}")]
+    PossibleReorg(Error),
 
     #[error("subgraph stopped while processing triggers")]
     Canceled,
 }
 
-impl BlockProcessingError {
+impl ProcessingError {
+    /// Classify the error into one of the defined error kinds.
+    ///
+    /// This method provides a unified way to determine how to handle an error:
+    /// - `Deterministic`: Stop processing, persist PoI only
+    /// - `NonDeterministic`: Retry with backoff
+    /// - `PossibleReorg`: Restart block stream cleanly
+    /// - `Canceled`: Clean shutdown, no error recording
+    pub fn kind(&self) -> ProcessingErrorKind {
+        match self {
+            ProcessingError::Unknown(_) => ProcessingErrorKind::NonDeterministic,
+            ProcessingError::Deterministic(_) => ProcessingErrorKind::Deterministic,
+            ProcessingError::PossibleReorg(_) => ProcessingErrorKind::PossibleReorg,
+            ProcessingError::Canceled => ProcessingErrorKind::Canceled,
+        }
+    }
+
+    #[allow(dead_code)]
     pub fn is_deterministic(&self) -> bool {
-        matches!(self, BlockProcessingError::Deterministic(_))
+        matches!(self.kind(), ProcessingErrorKind::Deterministic)
+    }
+
+    /// Returns true if this error should stop processing the current block.
+    ///
+    /// Deterministic errors stop processing because continuing would produce
+    /// incorrect results. The PoI is still persisted for debugging purposes.
+    #[allow(dead_code)]
+    pub fn should_stop_processing(&self) -> bool {
+        matches!(self.kind(), ProcessingErrorKind::Deterministic)
+    }
+
+    /// Returns true if this error requires a clean restart of the block stream.
+    ///
+    /// Possible reorgs require restarting to allow the block stream to detect
+    /// and properly handle the reorganization. No state should be persisted
+    /// in this case.
+    #[allow(dead_code)]
+    pub fn should_restart(&self) -> bool {
+        matches!(self.kind(), ProcessingErrorKind::PossibleReorg)
+    }
+
+    /// Returns true if this error is retryable with exponential backoff.
+    ///
+    /// Non-deterministic errors (network issues, temporary failures) may
+    /// succeed on retry and should not immediately fail the subgraph.
+    #[allow(dead_code)]
+    pub fn is_retryable(&self) -> bool {
+        matches!(self.kind(), ProcessingErrorKind::NonDeterministic)
+    }
+
+    /// Returns true if processing was canceled (clean shutdown).
+    ///
+    /// Canceled errors indicate the subgraph was unassigned or shut down
+    /// intentionally and should not be treated as failures.
+    #[allow(dead_code)]
+    pub fn is_canceled(&self) -> bool {
+        matches!(self.kind(), ProcessingErrorKind::Canceled)
     }
+
+    pub fn detail(self, ctx: &str) -> ProcessingError {
+        match self {
+            ProcessingError::Unknown(e) => {
+                let x = e.context(ctx.to_string());
+                ProcessingError::Unknown(x)
+            }
+            ProcessingError::Deterministic(e) => {
+                ProcessingError::Deterministic(Box::new(anyhow!("{e}").context(ctx.to_string())))
+            }
+            ProcessingError::PossibleReorg(e) => {
+                ProcessingError::PossibleReorg(e.context(ctx.to_string()))
+            }
+            ProcessingError::Canceled => ProcessingError::Canceled,
+        }
+    }
+}
+
+/// Similar to `anyhow::Context`, but for `Result<T, ProcessingError>`. We
+/// call the method `detail` to avoid ambiguity with anyhow's `context`
+/// method
+pub trait DetailHelper<T, E> {
+    fn detail(self, ctx: &str) -> Result<T, ProcessingError>;
+}
+
+impl<T> DetailHelper<T, ProcessingError> for Result<T, ProcessingError> {
+    fn detail(self, ctx: &str) -> Result<T, ProcessingError> {
+        self.map_err(|e| e.detail(ctx))
+    }
+}
+
+/// Implement this for errors that are always non-deterministic.
+pub(crate) trait NonDeterministicErrorHelper<T, E> {
+    fn non_deterministic(self) -> Result<T, ProcessingError>;
+}
+
+impl<T> NonDeterministicErrorHelper<T, anyhow::Error> for Result<T, anyhow::Error> {
+    fn non_deterministic(self) -> Result<T, ProcessingError> {
+        self.map_err(ProcessingError::Unknown)
+    }
+}
+
+impl<T> NonDeterministicErrorHelper<T, StoreError> for Result<T, StoreError> {
+    fn non_deterministic(self) -> Result<T, ProcessingError> {
+        self.map_err(|e| ProcessingError::Unknown(Error::from(e)))
+    }
+}
+
+/// Implement this for errors where it depends on the details whether they
+/// are deterministic or not.
+pub(crate) trait ClassifyErrorHelper<T, E> {
+    fn classify(self) -> Result<T, ProcessingError>;
 }
 
-impl From<StoreError> for BlockProcessingError {
-    fn from(e: StoreError) -> Self {
-        BlockProcessingError::Unknown(e.into())
+impl<T> ClassifyErrorHelper<T, StoreError> for Result<T, StoreError> {
+    fn classify(self) -> Result<T, ProcessingError> {
+        self.map_err(|e| {
+            if ENV_VARS.mappings.store_errors_are_nondeterministic {
+                // Old behavior, just in case the new behavior causes issues
+                ProcessingError::Unknown(Error::from(e))
+            } else if e.is_deterministic() {
+                ProcessingError::Deterministic(Box::new(e))
+            } else {
+                ProcessingError::Unknown(Error::from(e))
+            }
+        })
     }
 }
diff --git a/core/src/subgraph/inputs.rs b/core/src/subgraph/inputs.rs
index b2e95c753f5..03a8cec29bc 100644
--- a/core/src/subgraph/inputs.rs
+++ b/core/src/subgraph/inputs.rs
@@ -1,7 +1,7 @@
 use graph::{
-    blockchain::{Blockchain, TriggersAdapter},
+    blockchain::{Blockchain, block_stream::TriggersAdapterWrapper},
     components::{
-        store::{DeploymentLocator, SubgraphFork, WritableStore},
+        store::{DeploymentLocator, SourceableStore, SubgraphFork, WritableStore},
         subgraph::ProofOfIndexingVersion,
     },
     data::subgraph::{SubgraphFeature, UnifiedMappingApiVersion},
@@ -16,10 +16,12 @@ pub struct IndexingInputs<C: Blockchain> {
     pub features: BTreeSet<SubgraphFeature>,
     pub start_blocks: Vec<BlockNumber>,
     pub end_blocks: BTreeSet<BlockNumber>,
+    pub source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
     pub stop_block: Option<BlockNumber>,
+    pub max_end_block: Option<BlockNumber>,
     pub store: Arc<dyn WritableStore>,
     pub debug_fork: Option<Arc<dyn SubgraphFork>>,
-    pub triggers_adapter: Arc<dyn TriggersAdapter<C>>,
+    pub triggers_adapter: Arc<TriggersAdapterWrapper<C>>,
     pub chain: Arc<C>,
     pub templates: Arc<Vec<DataSourceTemplate<C>>>,
     pub unified_api_version: UnifiedMappingApiVersion,
@@ -39,7 +41,9 @@ impl<C: Blockchain> IndexingInputs<C> {
             features,
             start_blocks,
             end_blocks,
+            source_subgraph_stores,
             stop_block,
+            max_end_block,
             store: _,
             debug_fork,
             triggers_adapter,
@@ -56,7 +60,9 @@ impl<C: Blockchain> IndexingInputs<C> {
             features: features.clone(),
             start_blocks: start_blocks.clone(),
             end_blocks: end_blocks.clone(),
-            stop_block: stop_block.clone(),
+            source_subgraph_stores: source_subgraph_stores.clone(),
+            stop_block: *stop_block,
+            max_end_block: *max_end_block,
             store,
             debug_fork: debug_fork.clone(),
             triggers_adapter: triggers_adapter.clone(),
@@ -69,4 +75,12 @@ impl<C: Blockchain> IndexingInputs<C> {
             instrument: *instrument,
         }
     }
+
+    pub fn errors_are_non_fatal(&self) -> bool {
+        self.features.contains(&SubgraphFeature::NonFatalErrors)
+    }
+
+    pub fn errors_are_fatal(&self) -> bool {
+        !self.features.contains(&SubgraphFeature::NonFatalErrors)
+    }
 }
diff --git a/core/src/subgraph/instance_manager.rs b/core/src/subgraph/instance_manager.rs
index d0176238013..ea301ffc723 100644
--- a/core/src/subgraph/instance_manager.rs
+++ b/core/src/subgraph/instance_manager.rs
@@ -1,28 +1,38 @@
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
+
 use crate::polling_monitor::{ArweaveService, IpfsService};
+use crate::subgraph::Decoder;
 use crate::subgraph::context::{IndexingContext, SubgraphKeepAlive};
 use crate::subgraph::inputs::IndexingInputs;
 use crate::subgraph::loader::load_dynamic_data_sources;
 use std::collections::BTreeSet;
 
 use crate::subgraph::runner::SubgraphRunner;
-use graph::blockchain::block_stream::BlockStreamMetrics;
+use async_trait::async_trait;
+use graph::amp;
+use graph::blockchain::block_stream::{BlockStreamMetrics, TriggersAdapterWrapper};
 use graph::blockchain::{Blockchain, BlockchainKind, DataSource, NodeCapabilities};
 use graph::components::metrics::gas::GasMetrics;
+use graph::components::metrics::subgraph::DeploymentStatusMetric;
+use graph::components::store::SourceableStore;
 use graph::components::subgraph::ProofOfIndexingVersion;
-use graph::data::subgraph::{UnresolvedSubgraphManifest, SPEC_VERSION_0_0_6};
+use graph::data::subgraph::{SPEC_VERSION_0_0_6, UnresolvedSubgraphManifest};
+use graph::data::value::Word;
 use graph::data_source::causality_region::CausalityRegionSeq;
 use graph::env::EnvVars;
 use graph::prelude::{SubgraphInstanceManager as SubgraphInstanceManagerTrait, *};
 use graph::{blockchain::BlockchainMap, components::store::DeploymentLocator};
-use graph_runtime_wasm::module::ToAscPtr;
 use graph_runtime_wasm::RuntimeHostBuilder;
+use graph_runtime_wasm::module::ToAscPtr;
 use tokio::task;
 
-use super::context::OffchainMonitor;
 use super::SubgraphTriggerProcessor;
+use super::context::OffchainMonitor;
+use crate::{subgraph::runner::SubgraphRunnerError, subgraph_manifest};
 
 #[derive(Clone)]
-pub struct SubgraphInstanceManager<S: SubgraphStore> {
+pub struct SubgraphInstanceManager<S: SubgraphStore, AC> {
     logger_factory: LoggerFactory,
     subgraph_store: Arc<S>,
     chains: Arc<BlockchainMap>,
@@ -31,107 +41,87 @@ pub struct SubgraphInstanceManager<S: SubgraphStore> {
     link_resolver: Arc<dyn LinkResolver>,
     ipfs_service: IpfsService,
     arweave_service: ArweaveService,
+    amp_client: Option<Arc<AC>>,
     static_filters: bool,
     env_vars: Arc<EnvVars>,
+
+    /// By design, there should be only one subgraph runner process per subgraph, but the current
+    /// implementation does not completely prevent multiple runners from being active at the same
+    /// time, and we have already had a [bug][0] due to this limitation. Investigating the problem
+    /// was quite complicated because there was no way to know that the logs were coming from two
+    /// different processes because all the logs looked the same. Ideally, the implementation
+    /// should be refactored to make it more strict, but until then, we keep this counter, which
+    /// is incremented each time a new runner is started, and the previous count is embedded in
+    /// each log of the started runner, to make debugging future issues easier.
+    ///
+    /// [0]: https://github.com/graphprotocol/graph-node/issues/5452
+    subgraph_start_counter: Arc<AtomicU64>,
 }
 
 #[async_trait]
-impl<S: SubgraphStore> SubgraphInstanceManagerTrait for SubgraphInstanceManager<S> {
+impl<S: SubgraphStore, NC> SubgraphInstanceManagerTrait for SubgraphInstanceManager<S, NC>
+where
+    NC: amp::Client + Send + Sync + 'static,
+{
     async fn start_subgraph(
         self: Arc<Self>,
         loc: DeploymentLocator,
-        manifest: serde_yaml::Mapping,
         stop_block: Option<BlockNumber>,
     ) {
+        let runner_index = self.subgraph_start_counter.fetch_add(1, Ordering::SeqCst);
+
         let logger = self.logger_factory.subgraph_logger(&loc);
+        let logger = logger.new(o!("runner_index" => runner_index));
+
         let err_logger = logger.clone();
         let instance_manager = self.cheap_clone();
 
-        let subgraph_start_future = async move {
-            match BlockchainKind::from_manifest(&manifest)? {
-                BlockchainKind::Arweave => {
-                    let runner = instance_manager
-                        .build_subgraph_runner::<graph_chain_arweave::Chain>(
-                            logger.clone(),
-                            self.env_vars.cheap_clone(),
-                            loc.clone(),
-                            manifest,
-                            stop_block,
-                            Box::new(SubgraphTriggerProcessor {}),
-                        )
-                        .await?;
-
-                    self.start_subgraph_inner(logger, loc, runner).await
-                }
-                BlockchainKind::Ethereum => {
-                    let runner = instance_manager
-                        .build_subgraph_runner::<graph_chain_ethereum::Chain>(
-                            logger.clone(),
-                            self.env_vars.cheap_clone(),
-                            loc.clone(),
-                            manifest,
-                            stop_block,
-                            Box::new(SubgraphTriggerProcessor {}),
-                        )
-                        .await?;
-
-                    self.start_subgraph_inner(logger, loc, runner).await
-                }
-                BlockchainKind::Near => {
-                    let runner = instance_manager
-                        .build_subgraph_runner::<graph_chain_near::Chain>(
-                            logger.clone(),
-                            self.env_vars.cheap_clone(),
-                            loc.clone(),
-                            manifest,
-                            stop_block,
-                            Box::new(SubgraphTriggerProcessor {}),
-                        )
-                        .await?;
-
-                    self.start_subgraph_inner(logger, loc, runner).await
-                }
-                BlockchainKind::Cosmos => {
-                    let runner = instance_manager
-                        .build_subgraph_runner::<graph_chain_cosmos::Chain>(
-                            logger.clone(),
-                            self.env_vars.cheap_clone(),
-                            loc.clone(),
-                            manifest,
-                            stop_block,
-                            Box::new(SubgraphTriggerProcessor {}),
-                        )
-                        .await?;
-
-                    self.start_subgraph_inner(logger, loc, runner).await
-                }
-                BlockchainKind::Substreams => {
-                    let runner = instance_manager
-                        .build_subgraph_runner::<graph_chain_substreams::Chain>(
-                            logger.clone(),
-                            self.env_vars.cheap_clone(),
-                            loc.cheap_clone(),
-                            manifest,
-                            stop_block,
-                            Box::new(graph_chain_substreams::TriggerProcessor::new(loc.clone())),
-                        )
-                        .await?;
-
-                    self.start_subgraph_inner(logger, loc, runner).await
-                }
-                BlockchainKind::Starknet => {
-                    let runner = instance_manager
-                        .build_subgraph_runner::<graph_chain_starknet::Chain>(
-                            logger.clone(),
-                            self.env_vars.cheap_clone(),
-                            loc.clone(),
-                            manifest,
-                            stop_block,
-                            Box::new(SubgraphTriggerProcessor {}),
-                        )
-                        .await?;
-
-                    self.start_subgraph_inner(logger, loc, runner).await
+        let deployment_status_metric = self.new_deployment_status_metric(&loc);
+        deployment_status_metric.starting();
+
+        let subgraph_start_future = {
+            let deployment_status_metric = deployment_status_metric.clone();
+
+            async move {
+                let raw_manifest = subgraph_manifest::load_raw_subgraph_manifest(
+                    &logger,
+                    &*instance_manager.subgraph_store,
+                    &*instance_manager.link_resolver,
+                    &loc.hash,
+                )
+                .await?;
+
+                match BlockchainKind::from_manifest(&raw_manifest)? {
+                    BlockchainKind::Ethereum => {
+                        let runner = instance_manager
+                            .build_subgraph_runner::<graph_chain_ethereum::Chain>(
+                                logger.clone(),
+                                self.env_vars.cheap_clone(),
+                                loc.clone(),
+                                raw_manifest,
+                                stop_block,
+                                Box::new(SubgraphTriggerProcessor {}),
+                                deployment_status_metric,
+                            )
+                            .await?;
+
+                        self.start_subgraph_inner(logger, loc, runner).await
+                    }
+                    BlockchainKind::Near => {
+                        let runner = instance_manager
+                            .build_subgraph_runner::<graph_chain_near::Chain>(
+                                logger.clone(),
+                                self.env_vars.cheap_clone(),
+                                loc.clone(),
+                                raw_manifest,
+                                stop_block,
+                                Box::new(SubgraphTriggerProcessor {}),
+                                deployment_status_metric,
+                            )
+                            .await?;
+
+                        self.start_subgraph_inner(logger, loc, runner).await
+                    }
                 }
             }
         };
@@ -144,12 +134,16 @@ impl<S: SubgraphStore> SubgraphInstanceManagerTrait for SubgraphInstanceManager<
         graph::spawn(async move {
             match subgraph_start_future.await {
                 Ok(()) => {}
-                Err(err) => error!(
-                    err_logger,
-                    "Failed to start subgraph";
-                    "error" => format!("{:#}", err),
-                    "code" => LogCode::SubgraphStartFailure
-                ),
+                Err(err) => {
+                    deployment_status_metric.failed();
+
+                    error!(
+                        err_logger,
+                        "Failed to start subgraph";
+                        "error" => format!("{:#}", err),
+                        "code" => LogCode::SubgraphStartFailure
+                    );
+                }
             }
         });
     }
@@ -170,7 +164,7 @@ impl<S: SubgraphStore> SubgraphInstanceManagerTrait for SubgraphInstanceManager<
     }
 }
 
-impl<S: SubgraphStore> SubgraphInstanceManager<S> {
+impl<S: SubgraphStore, AC: amp::Client> SubgraphInstanceManager<S, AC> {
     pub fn new(
         logger_factory: &LoggerFactory,
         env_vars: Arc<EnvVars>,
@@ -181,6 +175,7 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         link_resolver: Arc<dyn LinkResolver>,
         ipfs_service: IpfsService,
         arweave_service: ArweaveService,
+        amp_client: Option<Arc<AC>>,
         static_filters: bool,
     ) -> Self {
         let logger = logger_factory.component_logger("SubgraphInstanceManager", None);
@@ -194,20 +189,76 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
             instances: SubgraphKeepAlive::new(sg_metrics),
             link_resolver,
             ipfs_service,
+            amp_client,
             static_filters,
             env_vars,
             arweave_service,
+            subgraph_start_counter: Arc::new(AtomicU64::new(0)),
         }
     }
 
+    pub async fn get_sourceable_stores<C: Blockchain>(
+        &self,
+        hashes: Vec<DeploymentHash>,
+        is_runner_test: bool,
+    ) -> anyhow::Result<Vec<Arc<dyn SourceableStore>>> {
+        if is_runner_test {
+            return Ok(Vec::new());
+        }
+
+        let mut sourceable_stores = Vec::new();
+        let subgraph_store = self.subgraph_store.clone();
+
+        for hash in hashes {
+            let loc = subgraph_store
+                .active_locator(&hash)
+                .await?
+                .ok_or_else(|| anyhow!("no active deployment for hash {}", hash))?;
+
+            let sourceable_store = subgraph_store.clone().sourceable(loc.id).await?;
+            sourceable_stores.push(sourceable_store);
+        }
+
+        Ok(sourceable_stores)
+    }
+
     pub async fn build_subgraph_runner<C>(
         &self,
         logger: Logger,
         env_vars: Arc<EnvVars>,
         deployment: DeploymentLocator,
-        manifest: serde_yaml::Mapping,
+        raw_manifest: serde_yaml::Mapping,
         stop_block: Option<BlockNumber>,
         tp: Box<dyn TriggerProcessor<C, RuntimeHostBuilder<C>>>,
+        deployment_status_metric: DeploymentStatusMetric,
+    ) -> anyhow::Result<SubgraphRunner<C, RuntimeHostBuilder<C>>>
+    where
+        C: Blockchain,
+        <C as Blockchain>::MappingTrigger: ToAscPtr,
+    {
+        self.build_subgraph_runner_inner(
+            logger,
+            env_vars,
+            deployment,
+            raw_manifest,
+            stop_block,
+            tp,
+            deployment_status_metric,
+            false,
+        )
+        .await
+    }
+
+    pub async fn build_subgraph_runner_inner<C>(
+        &self,
+        logger: Logger,
+        env_vars: Arc<EnvVars>,
+        deployment: DeploymentLocator,
+        raw_manifest: serde_yaml::Mapping,
+        stop_block: Option<BlockNumber>,
+        tp: Box<dyn TriggerProcessor<C, RuntimeHostBuilder<C>>>,
+        deployment_status_metric: DeploymentStatusMetric,
+        is_runner_test: bool,
     ) -> anyhow::Result<SubgraphRunner<C, RuntimeHostBuilder<C>>>
     where
         C: Blockchain,
@@ -216,28 +267,28 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         let subgraph_store = self.subgraph_store.cheap_clone();
         let registry = self.metrics_registry.cheap_clone();
 
-        let raw_yaml = serde_yaml::to_string(&manifest).unwrap();
-        let manifest = UnresolvedSubgraphManifest::parse(deployment.hash.cheap_clone(), manifest)?;
+        let manifest =
+            UnresolvedSubgraphManifest::parse(deployment.hash.cheap_clone(), raw_manifest)?;
 
         // Allow for infinite retries for subgraph definition files.
-        let link_resolver = Arc::from(self.link_resolver.with_retries());
+        let link_resolver = Arc::from(
+            self.link_resolver
+                .for_manifest(&deployment.hash.to_string())
+                .map_err(SubgraphRegistrarError::Unknown)?
+                .with_retries(),
+        );
 
-        // Make sure the `raw_yaml` is present on both this subgraph and the graft base.
-        self.subgraph_store
-            .set_manifest_raw_yaml(&deployment.hash, raw_yaml)
+        if let Some(graft) = &manifest.graft
+            && self.subgraph_store.is_deployed(&graft.base).await?
+        {
+            // Makes sure the raw manifest is cached in the subgraph store
+            let _raw_manifest = subgraph_manifest::load_raw_subgraph_manifest(
+                &logger,
+                &*self.subgraph_store,
+                &*self.link_resolver,
+                &graft.base,
+            )
             .await?;
-        if let Some(graft) = &manifest.graft {
-            if self.subgraph_store.is_deployed(&graft.base)? {
-                let file_bytes = self
-                    .link_resolver
-                    .cat(&logger, &graft.base.to_ipfs_link())
-                    .await?;
-                let yaml = String::from_utf8(file_bytes)?;
-
-                self.subgraph_store
-                    .set_manifest_raw_yaml(&graft.base, yaml)
-                    .await?;
-            }
         }
 
         info!(logger, "Resolve subgraph files using IPFS";
@@ -246,7 +297,13 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         );
 
         let manifest = manifest
-            .resolve(&link_resolver, &logger, ENV_VARS.max_spec_version.clone())
+            .resolve(
+                &deployment.hash,
+                &link_resolver,
+                self.amp_client.cheap_clone(),
+                &logger,
+                ENV_VARS.max_spec_version.clone(),
+            )
             .await?;
 
         {
@@ -281,7 +338,8 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         // Write it to the database
         let deployment_features = manifest.deployment_features();
         self.subgraph_store
-            .create_subgraph_features(deployment_features)?;
+            .create_subgraph_features(deployment_features)
+            .await?;
 
         // Start the subgraph deployment before reading dynamic data
         // sources; if the subgraph is a graft or a copy, starting it will
@@ -305,8 +363,18 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
             .filter_map(|d| d.as_onchain().cloned())
             .collect::<Vec<_>>();
 
+        let subgraph_data_sources = data_sources
+            .iter()
+            .filter_map(|d| d.as_subgraph())
+            .collect::<Vec<_>>();
+
+        let subgraph_ds_source_deployments = subgraph_data_sources
+            .iter()
+            .map(|d| d.source.address())
+            .collect::<Vec<_>>();
+
         let required_capabilities = C::NodeCapabilities::from_data_sources(&onchain_data_sources);
-        let network = manifest.network_name();
+        let network: Word = manifest.network_name().into();
 
         let chain = self
             .chains
@@ -316,25 +384,42 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
 
         let start_blocks: Vec<BlockNumber> = data_sources
             .iter()
-            .filter_map(|d| d.as_onchain().map(|d: &C::DataSource| d.start_block()))
+            .filter_map(|d| d.start_block())
             .collect();
 
         let end_blocks: BTreeSet<BlockNumber> = manifest
             .data_sources
             .iter()
-            .filter_map(|d| {
-                d.as_onchain()
-                    .map(|d: &C::DataSource| d.end_block())
-                    .flatten()
-            })
+            .filter_map(|d| d.as_onchain().and_then(|d: &C::DataSource| d.end_block()))
             .collect();
 
+        // We can set `max_end_block` to the maximum of `end_blocks` and stop the subgraph
+        // only when there are no dynamic data sources and no offchain data sources present. This is because:
+        // - Dynamic data sources do not have a defined `end_block`, so we can't determine
+        //   when to stop processing them.
+        // - Offchain data sources might require processing beyond the end block of
+        //   onchain data sources, so the subgraph needs to continue.
+        //
+        // Note: we explicitly check each data source rather than comparing lengths, because
+        // `end_blocks` is a BTreeSet and deduplicates equal values, which would cause the
+        // length comparison to fail when multiple data sources share the same `end_block`.
+        let max_end_block: Option<BlockNumber> = if data_sources.iter().all(|d| {
+            d.as_onchain()
+                .and_then(|d: &C::DataSource| d.end_block())
+                .is_some()
+        }) {
+            end_blocks.iter().max().cloned()
+        } else {
+            None
+        };
+
         let templates = Arc::new(manifest.templates.clone());
 
         // Obtain the debug fork from the subgraph store
         let debug_fork = self
             .subgraph_store
-            .debug_fork(&deployment.hash, logger.clone())?;
+            .debug_fork(&deployment.hash, logger.clone())
+            .await?;
 
         // Create a subgraph instance from the manifest; this moves
         // ownership of the manifest and host builder into the new instance
@@ -366,6 +451,7 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
             registry.cheap_clone(),
             deployment.hash.as_str(),
             stopwatch_metrics.clone(),
+            deployment_status_metric,
         ));
 
         let block_stream_metrics = Arc::new(BlockStreamMetrics::new(
@@ -389,8 +475,9 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         let deployment_head = store.block_ptr().map(|ptr| ptr.number).unwrap_or(0) as f64;
         block_stream_metrics.deployment_head.set(deployment_head);
 
+        let (runtime_adapter, decoder_hook) = chain.runtime().await?;
         let host_builder = graph_runtime_wasm::RuntimeHostBuilder::new(
-            chain.runtime_adapter(),
+            runtime_adapter,
             self.link_resolver.cheap_clone(),
             subgraph_store.ens_lookup(),
         );
@@ -406,14 +493,27 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         let causality_region_seq =
             CausalityRegionSeq::from_current(store.causality_region_curr_val().await?);
 
-        let instrument = self.subgraph_store.instrument(&deployment)?;
+        let instrument = self.subgraph_store.instrument(&deployment).await?;
+
+        let decoder = Box::new(Decoder::new(decoder_hook));
+
+        let subgraph_data_source_stores = self
+            .get_sourceable_stores::<C>(subgraph_ds_source_deployments, is_runner_test)
+            .await?;
+
+        let triggers_adapter = Arc::new(TriggersAdapterWrapper::new(
+            triggers_adapter,
+            subgraph_data_source_stores.clone(),
+        ));
 
         let inputs = IndexingInputs {
             deployment: deployment.clone(),
             features,
             start_blocks,
             end_blocks,
+            source_subgraph_stores: subgraph_data_source_stores,
             stop_block,
+            max_end_block,
             store,
             debug_fork,
             triggers_adapter,
@@ -422,7 +522,7 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
             unified_api_version,
             static_filters: self.static_filters,
             poi_version,
-            network,
+            network: network.to_string(),
             instrument,
         };
 
@@ -438,6 +538,7 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
                 self.instances.cheap_clone(),
                 offchain_monitor,
                 tp,
+                decoder,
             );
             for data_source in data_sources {
                 ctx.add_dynamic_data_source(&logger, data_source)?;
@@ -470,7 +571,7 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         <C as Blockchain>::MappingTrigger: ToAscPtr,
     {
         let registry = self.metrics_registry.cheap_clone();
-        let subgraph_metrics_unregister = runner.metrics.subgraph.cheap_clone();
+        let subgraph_metrics = runner.metrics.subgraph.cheap_clone();
 
         // Keep restarting the subgraph until it terminates. The subgraph
         // will usually only run once, but is restarted whenever a block
@@ -486,16 +587,31 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         // it has a dedicated OS thread so the OS will handle the preemption. See
         // https://github.com/tokio-rs/tokio/issues/3493.
         graph::spawn_thread(deployment.to_string(), move || {
-            if let Err(e) = graph::block_on(task::unconstrained(runner.run())) {
-                error!(
-                    &logger,
-                    "Subgraph instance failed to run: {}",
-                    format!("{:#}", e)
-                );
+            match graph::block_on(task::unconstrained(runner.run())) {
+                Ok(()) => {
+                    subgraph_metrics.deployment_status.stopped();
+                }
+                Err(SubgraphRunnerError::Duplicate) => {
+                    // We do not need to unregister metrics because they are unique per subgraph
+                    // and another runner is still active.
+                    return;
+                }
+                Err(err) => {
+                    error!(&logger, "Subgraph instance failed to run: {:#}", err);
+                    subgraph_metrics.deployment_status.failed();
+                }
             }
-            subgraph_metrics_unregister.unregister(registry);
+
+            subgraph_metrics.unregister(registry);
         });
 
         Ok(())
     }
+
+    pub fn new_deployment_status_metric(
+        &self,
+        deployment: &DeploymentLocator,
+    ) -> DeploymentStatusMetric {
+        DeploymentStatusMetric::register(&self.metrics_registry, deployment)
+    }
 }
diff --git a/core/src/subgraph/mod.rs b/core/src/subgraph/mod.rs
index 45f8d5b98ef..8f6bc932daa 100644
--- a/core/src/subgraph/mod.rs
+++ b/core/src/subgraph/mod.rs
@@ -3,7 +3,6 @@ mod error;
 mod inputs;
 mod instance_manager;
 mod loader;
-mod provider;
 mod registrar;
 mod runner;
 mod state;
@@ -11,7 +10,6 @@ mod stream;
 mod trigger_processor;
 
 pub use self::instance_manager::SubgraphInstanceManager;
-pub use self::provider::SubgraphAssignmentProvider;
 pub use self::registrar::SubgraphRegistrar;
 pub use self::runner::SubgraphRunner;
 pub use self::trigger_processor::*;
diff --git a/core/src/subgraph/provider.rs b/core/src/subgraph/provider.rs
deleted file mode 100644
index 00d379db01f..00000000000
--- a/core/src/subgraph/provider.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-use std::collections::HashSet;
-use std::sync::Mutex;
-
-use async_trait::async_trait;
-
-use graph::{
-    components::store::{DeploymentId, DeploymentLocator},
-    prelude::{SubgraphAssignmentProvider as SubgraphAssignmentProviderTrait, *},
-};
-
-#[derive(Debug)]
-struct DeploymentRegistry {
-    subgraphs_deployed: Arc<Mutex<HashSet<DeploymentId>>>,
-    subgraph_metrics: Arc<SubgraphCountMetric>,
-}
-
-impl DeploymentRegistry {
-    fn new(subgraph_metrics: Arc<SubgraphCountMetric>) -> Self {
-        Self {
-            subgraphs_deployed: Arc::new(Mutex::new(HashSet::new())),
-            subgraph_metrics,
-        }
-    }
-
-    fn insert(&self, id: DeploymentId) -> bool {
-        if !self.subgraphs_deployed.lock().unwrap().insert(id) {
-            return false;
-        }
-
-        self.subgraph_metrics.deployment_count.inc();
-        true
-    }
-
-    fn remove(&self, id: &DeploymentId) -> bool {
-        if !self.subgraphs_deployed.lock().unwrap().remove(id) {
-            return false;
-        }
-
-        self.subgraph_metrics.deployment_count.dec();
-        true
-    }
-}
-
-pub struct SubgraphAssignmentProvider<I> {
-    logger_factory: LoggerFactory,
-    deployment_registry: DeploymentRegistry,
-    link_resolver: Arc<dyn LinkResolver>,
-    instance_manager: Arc<I>,
-}
-
-impl<I: SubgraphInstanceManager> SubgraphAssignmentProvider<I> {
-    pub fn new(
-        logger_factory: &LoggerFactory,
-        link_resolver: Arc<dyn LinkResolver>,
-        instance_manager: I,
-        subgraph_metrics: Arc<SubgraphCountMetric>,
-    ) -> Self {
-        let logger = logger_factory.component_logger("SubgraphAssignmentProvider", None);
-        let logger_factory = logger_factory.with_parent(logger.clone());
-
-        // Create the subgraph provider
-        SubgraphAssignmentProvider {
-            logger_factory,
-            link_resolver: link_resolver.with_retries().into(),
-            instance_manager: Arc::new(instance_manager),
-            deployment_registry: DeploymentRegistry::new(subgraph_metrics),
-        }
-    }
-}
-
-#[async_trait]
-impl<I: SubgraphInstanceManager> SubgraphAssignmentProviderTrait for SubgraphAssignmentProvider<I> {
-    async fn start(
-        &self,
-        loc: DeploymentLocator,
-        stop_block: Option<BlockNumber>,
-    ) -> Result<(), SubgraphAssignmentProviderError> {
-        let logger = self.logger_factory.subgraph_logger(&loc);
-
-        // If subgraph ID already in set
-        if !self.deployment_registry.insert(loc.id) {
-            info!(logger, "Subgraph deployment is already running");
-
-            return Err(SubgraphAssignmentProviderError::AlreadyRunning(
-                loc.hash.clone(),
-            ));
-        }
-
-        let file_bytes = self
-            .link_resolver
-            .cat(&logger, &loc.hash.to_ipfs_link())
-            .await
-            .map_err(SubgraphAssignmentProviderError::ResolveError)?;
-
-        let raw: serde_yaml::Mapping = serde_yaml::from_slice(&file_bytes)
-            .map_err(|e| SubgraphAssignmentProviderError::ResolveError(e.into()))?;
-
-        self.instance_manager
-            .cheap_clone()
-            .start_subgraph(loc, raw, stop_block)
-            .await;
-
-        Ok(())
-    }
-
-    async fn stop(
-        &self,
-        deployment: DeploymentLocator,
-    ) -> Result<(), SubgraphAssignmentProviderError> {
-        // If subgraph ID was in set
-        if self.deployment_registry.remove(&deployment.id) {
-            // Shut down subgraph processing
-            self.instance_manager.stop_subgraph(deployment).await;
-        }
-        Ok(())
-    }
-}
diff --git a/core/src/subgraph/registrar.rs b/core/src/subgraph/registrar.rs
index 9404b415d20..e9422671e25 100644
--- a/core/src/subgraph/registrar.rs
+++ b/core/src/subgraph/registrar.rs
@@ -1,41 +1,45 @@
 use std::collections::HashSet;
-use std::time::Instant;
 
 use async_trait::async_trait;
-use graph::blockchain::Blockchain;
-use graph::blockchain::BlockchainKind;
-use graph::blockchain::BlockchainMap;
-use graph::components::store::{DeploymentId, DeploymentLocator, SubscriptionManager};
-use graph::components::subgraph::Settings;
-use graph::data::subgraph::schema::DeploymentCreate;
-use graph::data::subgraph::Graft;
-use graph::prelude::{
-    CreateSubgraphResult, SubgraphAssignmentProvider as SubgraphAssignmentProviderTrait,
-    SubgraphRegistrar as SubgraphRegistrarTrait, *,
+use graph::amp;
+use graph::blockchain::{Blockchain, BlockchainKind, BlockchainMap};
+use graph::components::{
+    link_resolver::LinkResolverContext,
+    network_provider::AmpChainNames,
+    store::{DeploymentId, DeploymentLocator, SubscriptionManager},
+    subgraph::Settings,
 };
-use graph::tokio_retry::Retry;
-use graph::util::futures::retry_strategy;
-use graph::util::futures::RETRY_DEFAULT_LIMIT;
+use graph::data::{
+    subgraph::{Graft, schema::DeploymentCreate},
+    value::Word,
+};
+use graph::futures03::{self, Stream, StreamExt, future::TryFutureExt};
+use graph::prelude::{CreateSubgraphResult, SubgraphRegistrar as SubgraphRegistrarTrait, *};
+use graph::util::futures::{RETRY_DEFAULT_LIMIT, retry_strategy};
+use tokio_retry::Retry;
 
-pub struct SubgraphRegistrar<P, S, SM> {
+pub struct SubgraphRegistrar<P, S, SM, AC> {
     logger: Logger,
     logger_factory: LoggerFactory,
     resolver: Arc<dyn LinkResolver>,
     provider: Arc<P>,
     store: Arc<S>,
     subscription_manager: Arc<SM>,
+    amp_client: Option<Arc<AC>>,
     chains: Arc<BlockchainMap>,
     node_id: NodeId,
     version_switching_mode: SubgraphVersionSwitchingMode,
     assignment_event_stream_cancel_guard: CancelGuard, // cancels on drop
     settings: Arc<Settings>,
+    amp_chain_names: Arc<AmpChainNames>,
 }
 
-impl<P, S, SM> SubgraphRegistrar<P, S, SM>
+impl<P, S, SM, AC> SubgraphRegistrar<P, S, SM, AC>
 where
-    P: SubgraphAssignmentProviderTrait,
+    P: graph::components::subgraph::SubgraphInstanceManager,
     S: SubgraphStore,
     SM: SubscriptionManager,
+    AC: amp::Client + Send + Sync + 'static,
 {
     pub fn new(
         logger_factory: &LoggerFactory,
@@ -43,10 +47,12 @@ where
         provider: Arc<P>,
         store: Arc<S>,
         subscription_manager: Arc<SM>,
+        amp_client: Option<Arc<AC>>,
         chains: Arc<BlockchainMap>,
         node_id: NodeId,
         version_switching_mode: SubgraphVersionSwitchingMode,
         settings: Arc<Settings>,
+        amp_chain_names: Arc<AmpChainNames>,
     ) -> Self {
         let logger = logger_factory.component_logger("SubgraphRegistrar", None);
         let logger_factory = logger_factory.with_parent(logger.clone());
@@ -60,22 +66,17 @@ where
             provider,
             store,
             subscription_manager,
+            amp_client,
             chains,
             node_id,
             version_switching_mode,
             assignment_event_stream_cancel_guard: CancelGuard::new(),
             settings,
+            amp_chain_names,
         }
     }
 
-    pub fn start(&self) -> impl Future<Item = (), Error = Error> {
-        let logger_clone1 = self.logger.clone();
-        let logger_clone2 = self.logger.clone();
-        let provider = self.provider.clone();
-        let node_id = self.node_id.clone();
-        let assignment_event_stream_cancel_handle =
-            self.assignment_event_stream_cancel_guard.handle();
-
+    pub async fn start(self: Arc<Self>) -> Result<(), Error> {
         // The order of the following three steps is important:
         // - Start assignment event stream
         // - Read assignments table and start assigned subgraphs
@@ -90,185 +91,153 @@ where
         //
         // The discrepancy between the start time of the event stream and the table read can result
         // in some extraneous events on start up. Examples:
-        // - The event stream sees an Add event for subgraph A, but the table query finds that
+        // - The event stream sees an 'set' event for subgraph A, but the table query finds that
         //   subgraph A is already in the table.
-        // - The event stream sees a Remove event for subgraph B, but the table query finds that
+        // - The event stream sees a 'removed' event for subgraph B, but the table query finds that
         //   subgraph B has already been removed.
-        // The `handle_assignment_events` function handles these cases by ignoring AlreadyRunning
-        // (on subgraph start) which makes the operations idempotent. Subgraph stop is already idempotent.
+        // The `change_assignment` function handles these cases by ignoring
+        // such cases which makes the operations idempotent
 
         // Start event stream
-        let assignment_event_stream = self.assignment_events();
+        let assignment_event_stream = self.cheap_clone().assignment_events().await;
 
         // Deploy named subgraphs found in store
-        self.start_assigned_subgraphs().and_then(move |()| {
-            // Spawn a task to handle assignment events.
-            // Blocking due to store interactions. Won't be blocking after #905.
-            graph::spawn_blocking(
-                assignment_event_stream
-                    .compat()
-                    .map_err(SubgraphAssignmentProviderError::Unknown)
-                    .map_err(CancelableError::Error)
-                    .cancelable(&assignment_event_stream_cancel_handle, || {
-                        Err(CancelableError::Cancel)
-                    })
-                    .compat()
-                    .for_each(move |assignment_event| {
-                        assert_eq!(assignment_event.node_id(), &node_id);
-                        handle_assignment_event(
-                            assignment_event,
-                            provider.clone(),
-                            logger_clone1.clone(),
-                        )
-                        .boxed()
-                        .compat()
-                    })
-                    .map_err(move |e| match e {
-                        CancelableError::Cancel => panic!("assignment event stream canceled"),
-                        CancelableError::Error(e) => {
-                            error!(logger_clone2, "Assignment event stream failed: {}", e);
-                            panic!("assignment event stream failed: {}", e);
-                        }
-                    })
-                    .compat(),
-            );
+        self.start_assigned_subgraphs().await?;
+
+        let cancel_handle = self.assignment_event_stream_cancel_guard.handle();
+
+        // Spawn a task to handle assignment events.
+        let fut = assignment_event_stream.for_each({
+            move |event| {
+                // The assignment stream should run forever. If it gets
+                // cancelled, that probably indicates a serious problem and
+                // we panic
+                if cancel_handle.is_canceled() {
+                    panic!("assignment event stream canceled");
+                }
 
-            Ok(())
-        })
+                let this = self.cheap_clone();
+                async move {
+                    this.change_assignment(event).await;
+                }
+            }
+        });
+
+        graph::spawn(fut);
+        Ok(())
     }
 
-    pub fn assignment_events(&self) -> impl Stream<Item = AssignmentEvent, Error = Error> + Send {
-        let store = self.store.clone();
-        let node_id = self.node_id.clone();
-        let logger = self.logger.clone();
+    /// Start/stop subgraphs as needed, considering the current assignment
+    /// state in the database, ignoring changes that do not affect this
+    /// node, do not require anything to change, or for which we can not
+    /// find the assignment status from the database
+    async fn change_assignment(&self, change: AssignmentChange) {
+        let (deployment, operation) = change.into_parts();
 
-        self.subscription_manager
-            .subscribe(FromIterator::from_iter([SubscriptionFilter::Assignment]))
-            .map_err(|()| anyhow!("Entity change stream failed"))
-            .map(|event| {
-                // We're only interested in the SubgraphDeploymentAssignment change; we
-                // know that there is at least one, as that is what we subscribed to
-                let filter = SubscriptionFilter::Assignment;
-                let assignments = event
-                    .changes
-                    .iter()
-                    .filter(|change| filter.matches(change))
-                    .map(|change| match change {
-                        EntityChange::Data { .. } => unreachable!(),
-                        EntityChange::Assignment {
-                            deployment,
-                            operation,
-                        } => (deployment.clone(), operation.clone()),
-                    })
-                    .collect::<Vec<_>>();
-                stream::iter_ok(assignments)
-            })
-            .flatten()
-            .and_then(
-                move |(deployment, operation)| -> Result<Box<dyn Stream<Item = _, Error = _> + Send>, _> {
-                    trace!(logger, "Received assignment change";
-                                   "deployment" => %deployment,
-                                   "operation" => format!("{:?}", operation),
-                                );
-
-                    match operation {
-                        EntityChangeOperation::Set => {
-                            store
-                                .assignment_status(&deployment)
-                                .map_err(|e| {
-                                    anyhow!("Failed to get subgraph assignment entity: {}", e)
-                                })
-                                .map(|assigned| -> Box<dyn Stream<Item = _, Error = _> + Send> {
-                                    if let Some((assigned,is_paused)) = assigned {
-                                        if assigned == node_id {
-
-                                            if is_paused{
-                                                // Subgraph is paused, so we don't start it
-                                                debug!(logger, "Deployment assignee is this node, but it is paused, so we don't start it"; "assigned_to" => assigned, "node_id" => &node_id,"paused" => is_paused);
-                                                return Box::new(stream::empty());
-                                            }
-
-                                            // Start subgraph on this node
-                                            debug!(logger, "Deployment assignee is this node, broadcasting add event"; "assigned_to" => assigned, "node_id" => &node_id);
-                                            Box::new(stream::once(Ok(AssignmentEvent::Add {
-                                                deployment,
-                                                node_id: node_id.clone(),
-                                            })))
-                                        } else {
-                                            // Ensure it is removed from this node
-                                            debug!(logger, "Deployment assignee is not this node, broadcasting remove event"; "assigned_to" => assigned, "node_id" => &node_id);
-                                            Box::new(stream::once(Ok(AssignmentEvent::Remove {
-                                                deployment,
-                                                node_id: node_id.clone(),
-                                            })))
-                                        }
-                                    } else {
-                                        // Was added/updated, but is now gone.
-                                        debug!(logger, "Deployment has not assignee, we will get a separate remove event later"; "node_id" => &node_id);
-                                        Box::new(stream::empty())
-                                    }
-                                })
-                        }
-                        EntityChangeOperation::Removed => {
-                            // Send remove event without checking node ID.
-                            // If node ID does not match, then this is a no-op when handled in
-                            // assignment provider.
-                            Ok(Box::new(stream::once(Ok(AssignmentEvent::Remove {
-                                deployment,
-                                node_id: node_id.clone(),
-                            }))))
+        trace!(self.logger, "Received assignment change";
+           "deployment" => %deployment,
+           "operation" => format!("{:?}", operation),
+        );
+
+        match operation {
+            AssignmentOperation::Set => {
+                let assigned = match self.store.assignment_status(&deployment).await {
+                    Ok(assigned) => assigned,
+                    Err(e) => {
+                        error!(
+                            self.logger,
+                            "Failed to get subgraph assignment entity"; "deployment" => deployment, "error" => e.to_string()
+                        );
+                        return;
+                    }
+                };
+
+                let logger = self.logger.new(o!("subgraph_id" => deployment.hash.to_string(), "node_id" => self.node_id.to_string()));
+                if let Some((assigned, is_paused)) = assigned {
+                    if assigned == self.node_id {
+                        if is_paused {
+                            // Subgraph is paused, so we don't start it
+                            debug!(logger, "Deployment assignee is this node"; "assigned_to" => assigned, "paused" => is_paused, "action" => "ignore");
+                            return;
                         }
+
+                        // Start subgraph on this node
+                        debug!(logger, "Deployment assignee is this node"; "assigned_to" => assigned, "action" => "add");
+                        self.provider
+                            .cheap_clone()
+                            .start_subgraph(deployment, None)
+                            .await;
+                    } else {
+                        // Ensure it is removed from this node
+                        debug!(logger, "Deployment assignee is not this node"; "assigned_to" => assigned, "action" => "remove");
+                        self.provider.stop_subgraph(deployment).await
                     }
-                },
-            )
+                } else {
+                    // Was added/updated, but is now gone.
+                    debug!(self.logger, "Deployment assignee not found in database"; "action" => "ignore");
+                }
+            }
+            AssignmentOperation::Removed => {
+                self.provider.stop_subgraph(deployment).await;
+            }
+        }
+    }
+
+    pub async fn assignment_events(self: Arc<Self>) -> impl Stream<Item = AssignmentChange> + Send {
+        self.subscription_manager
+            .subscribe()
+            .map(|event| futures03::stream::iter(event.changes.clone()))
             .flatten()
     }
 
-    fn start_assigned_subgraphs(&self) -> impl Future<Item = (), Error = Error> {
-        let provider = self.provider.clone();
+    async fn start_assigned_subgraphs(&self) -> Result<(), Error> {
         let logger = self.logger.clone();
         let node_id = self.node_id.clone();
 
-        future::result(self.store.active_assignments(&self.node_id))
-            .map_err(|e| anyhow!("Error querying subgraph assignments: {}", e))
-            .and_then(move |deployments| {
-                // This operation should finish only after all subgraphs are
-                // started. We wait for the spawned tasks to complete by giving
-                // each a `sender` and waiting for all of them to be dropped, so
-                // the receiver terminates without receiving anything.
-                let deployments = HashSet::<DeploymentLocator>::from_iter(deployments);
-                let deployments_len = deployments.len();
-                let (sender, receiver) = futures01::sync::mpsc::channel::<()>(1);
-                for id in deployments {
-                    let sender = sender.clone();
-                    let logger = logger.clone();
-
-                    graph::spawn(
-                        start_subgraph(id, provider.clone(), logger).map(move |()| drop(sender)),
-                    );
-                }
-                drop(sender);
-                receiver.collect().then(move |_| {
-                    info!(logger, "Started all assigned subgraphs";
-                                  "count" => deployments_len, "node_id" => &node_id);
-                    future::ok(())
-                })
-            })
+        let deployments = self
+            .store
+            .active_assignments(&self.node_id)
+            .await
+            .map_err(|e| anyhow!("Error querying subgraph assignments: {}", e))?;
+        // This operation should finish only after all subgraphs are
+        // started. We wait for the spawned tasks to complete by giving
+        // each a `sender` and waiting for all of them to be dropped, so
+        // the receiver terminates without receiving anything.
+        let deployments = HashSet::<DeploymentLocator>::from_iter(deployments);
+        let deployments_len = deployments.len();
+        debug!(logger, "Starting all assigned subgraphs";
+                    "count" => deployments_len, "node_id" => &node_id);
+        let (sender, receiver) = futures03::channel::mpsc::channel::<()>(1);
+        for id in deployments {
+            let sender = sender.clone();
+            let provider = self.provider.cheap_clone();
+
+            graph::spawn(async move {
+                provider.start_subgraph(id, None).await;
+                drop(sender)
+            });
+        }
+        drop(sender);
+        let _: Vec<_> = receiver.collect().await;
+        info!(logger, "Started all assigned subgraphs";
+                    "count" => deployments_len, "node_id" => &node_id);
+        Ok(())
     }
 }
 
 #[async_trait]
-impl<P, S, SM> SubgraphRegistrarTrait for SubgraphRegistrar<P, S, SM>
+impl<P, S, SM, AC> SubgraphRegistrarTrait for SubgraphRegistrar<P, S, SM, AC>
 where
-    P: SubgraphAssignmentProviderTrait,
+    P: graph::components::subgraph::SubgraphInstanceManager,
     S: SubgraphStore,
     SM: SubscriptionManager,
+    AC: amp::Client + Send + Sync + 'static,
 {
     async fn create_subgraph(
         &self,
         name: SubgraphName,
     ) -> Result<CreateSubgraphResult, SubgraphRegistrarError> {
-        let id = self.store.create_subgraph(name.clone())?;
+        let id = self.store.create_subgraph(name.clone()).await?;
 
         debug!(self.logger, "Created subgraph"; "subgraph_name" => name.to_string());
 
@@ -284,6 +253,7 @@ where
         start_block_override: Option<BlockPtr>,
         graft_block_override: Option<BlockPtr>,
         history_blocks: Option<i32>,
+        ignore_graft_base: bool,
     ) -> Result<DeploymentLocator, SubgraphRegistrarError> {
         // We don't have a location for the subgraph yet; that will be
         // assigned when we deploy for real. For logging purposes, make up a
@@ -292,19 +262,35 @@ where
             .logger_factory
             .subgraph_logger(&DeploymentLocator::new(DeploymentId(0), hash.clone()));
 
-        let raw: serde_yaml::Mapping = {
-            let file_bytes = self
-                .resolver
-                .cat(&logger, &hash.to_ipfs_link())
-                .await
-                .map_err(|e| {
-                    SubgraphRegistrarError::ResolveError(
-                        SubgraphManifestResolveError::ResolveError(e),
+        let resolver: Arc<dyn LinkResolver> = Arc::from(
+            self.resolver
+                .for_manifest(&hash.to_string())
+                .map_err(SubgraphRegistrarError::Unknown)?,
+        );
+
+        let raw = {
+            let mut raw: serde_yaml::Mapping = {
+                let file_bytes = resolver
+                    .cat(
+                        &LinkResolverContext::new(&hash, &logger),
+                        &hash.to_ipfs_link(),
                     )
-                })?;
+                    .await
+                    .map_err(|e| {
+                        SubgraphRegistrarError::ResolveError(
+                            SubgraphManifestResolveError::ResolveError(e),
+                        )
+                    })?;
+
+                serde_yaml::from_slice(&file_bytes)
+                    .map_err(|e| SubgraphRegistrarError::ResolveError(e.into()))?
+            };
 
-            serde_yaml::from_slice(&file_bytes)
-                .map_err(|e| SubgraphRegistrarError::ResolveError(e.into()))?
+            if ignore_graft_base {
+                raw.remove("graft");
+            }
+
+            raw
         };
 
         let kind = BlockchainKind::from_manifest(&raw).map_err(|e| {
@@ -316,26 +302,8 @@ where
             history_blocks.or(self.settings.for_name(&name).map(|c| c.history_blocks));
 
         let deployment_locator = match kind {
-            BlockchainKind::Arweave => {
-                create_subgraph_version::<graph_chain_arweave::Chain, _>(
-                    &logger,
-                    self.store.clone(),
-                    self.chains.cheap_clone(),
-                    name.clone(),
-                    hash.cheap_clone(),
-                    start_block_override,
-                    graft_block_override,
-                    raw,
-                    node_id,
-                    debug_fork,
-                    self.version_switching_mode,
-                    &self.resolver,
-                    history_blocks,
-                )
-                .await?
-            }
             BlockchainKind::Ethereum => {
-                create_subgraph_version::<graph_chain_ethereum::Chain, _>(
+                create_subgraph_version::<graph_chain_ethereum::Chain, _, _>(
                     &logger,
                     self.store.clone(),
                     self.chains.cheap_clone(),
@@ -347,13 +315,15 @@ where
                     node_id,
                     debug_fork,
                     self.version_switching_mode,
-                    &self.resolver,
+                    &resolver,
+                    self.amp_client.cheap_clone(),
                     history_blocks,
+                    &self.amp_chain_names,
                 )
                 .await?
             }
             BlockchainKind::Near => {
-                create_subgraph_version::<graph_chain_near::Chain, _>(
+                create_subgraph_version::<graph_chain_near::Chain, _, _>(
                     &logger,
                     self.store.clone(),
                     self.chains.cheap_clone(),
@@ -365,62 +335,10 @@ where
                     node_id,
                     debug_fork,
                     self.version_switching_mode,
-                    &self.resolver,
-                    history_blocks,
-                )
-                .await?
-            }
-            BlockchainKind::Cosmos => {
-                create_subgraph_version::<graph_chain_cosmos::Chain, _>(
-                    &logger,
-                    self.store.clone(),
-                    self.chains.cheap_clone(),
-                    name.clone(),
-                    hash.cheap_clone(),
-                    start_block_override,
-                    graft_block_override,
-                    raw,
-                    node_id,
-                    debug_fork,
-                    self.version_switching_mode,
-                    &self.resolver,
-                    history_blocks,
-                )
-                .await?
-            }
-            BlockchainKind::Substreams => {
-                create_subgraph_version::<graph_chain_substreams::Chain, _>(
-                    &logger,
-                    self.store.clone(),
-                    self.chains.cheap_clone(),
-                    name.clone(),
-                    hash.cheap_clone(),
-                    start_block_override,
-                    graft_block_override,
-                    raw,
-                    node_id,
-                    debug_fork,
-                    self.version_switching_mode,
-                    &self.resolver,
-                    history_blocks,
-                )
-                .await?
-            }
-            BlockchainKind::Starknet => {
-                create_subgraph_version::<graph_chain_starknet::Chain, _>(
-                    &logger,
-                    self.store.clone(),
-                    self.chains.cheap_clone(),
-                    name.clone(),
-                    hash.cheap_clone(),
-                    start_block_override,
-                    graft_block_override,
-                    raw,
-                    node_id,
-                    debug_fork,
-                    self.version_switching_mode,
-                    &self.resolver,
+                    &resolver,
+                    self.amp_client.cheap_clone(),
                     history_blocks,
+                    &self.amp_chain_names,
                 )
                 .await?
             }
@@ -437,9 +355,12 @@ where
     }
 
     async fn remove_subgraph(&self, name: SubgraphName) -> Result<(), SubgraphRegistrarError> {
-        self.store.clone().remove_subgraph(name.clone())?;
+        use itertools::Itertools;
 
-        debug!(self.logger, "Removed subgraph"; "subgraph_name" => name.to_string());
+        let hashes = self.store.clone().remove_subgraph(name.clone()).await?;
+        let hashes = hashes.into_iter().join(", ");
+
+        debug!(self.logger, "Removed subgraph"; "subgraph_name" => name.to_string(), "deployments" => format!("[{}]", hashes));
 
         Ok(())
     }
@@ -453,73 +374,33 @@ where
         hash: &DeploymentHash,
         node_id: &NodeId,
     ) -> Result<(), SubgraphRegistrarError> {
-        let locator = self.store.active_locator(hash)?;
+        let locator = self.store.active_locator(hash).await?;
         let deployment =
             locator.ok_or_else(|| SubgraphRegistrarError::DeploymentNotFound(hash.to_string()))?;
 
-        self.store.reassign_subgraph(&deployment, node_id)?;
+        self.store.reassign_subgraph(&deployment, node_id).await?;
 
         Ok(())
     }
-}
 
-async fn handle_assignment_event(
-    event: AssignmentEvent,
-    provider: Arc<impl SubgraphAssignmentProviderTrait>,
-    logger: Logger,
-) -> Result<(), CancelableError<SubgraphAssignmentProviderError>> {
-    let logger = logger.clone();
+    async fn pause_subgraph(&self, hash: &DeploymentHash) -> Result<(), SubgraphRegistrarError> {
+        let locator = self.store.active_locator(hash).await?;
+        let deployment =
+            locator.ok_or_else(|| SubgraphRegistrarError::DeploymentNotFound(hash.to_string()))?;
 
-    debug!(logger, "Received assignment event: {:?}", event);
+        self.store.pause_subgraph(&deployment).await?;
 
-    match event {
-        AssignmentEvent::Add {
-            deployment,
-            node_id: _,
-        } => {
-            start_subgraph(deployment, provider.clone(), logger).await;
-            Ok(())
-        }
-        AssignmentEvent::Remove {
-            deployment,
-            node_id: _,
-        } => match provider.stop(deployment).await {
-            Ok(()) => Ok(()),
-            Err(e) => Err(CancelableError::Error(e)),
-        },
+        Ok(())
     }
-}
-
-async fn start_subgraph(
-    deployment: DeploymentLocator,
-    provider: Arc<impl SubgraphAssignmentProviderTrait>,
-    logger: Logger,
-) {
-    let logger = logger
-        .new(o!("subgraph_id" => deployment.hash.to_string(), "sgd" => deployment.id.to_string()));
 
-    trace!(logger, "Start subgraph");
-
-    let start_time = Instant::now();
-    let result = provider.start(deployment.clone(), None).await;
+    async fn resume_subgraph(&self, hash: &DeploymentHash) -> Result<(), SubgraphRegistrarError> {
+        let locator = self.store.active_locator(hash).await?;
+        let deployment =
+            locator.ok_or_else(|| SubgraphRegistrarError::DeploymentNotFound(hash.to_string()))?;
 
-    debug!(
-        logger,
-        "Subgraph started";
-        "start_ms" => start_time.elapsed().as_millis()
-    );
+        self.store.resume_subgraph(&deployment).await?;
 
-    match result {
-        Ok(()) => (),
-        Err(SubgraphAssignmentProviderError::AlreadyRunning(_)) => (),
-        Err(e) => {
-            // Errors here are likely an issue with the subgraph.
-            error!(
-                logger,
-                "Subgraph instance failed to start";
-                "error" => e.to_string()
-            );
-        }
+        Ok(())
     }
 }
 
@@ -539,9 +420,9 @@ async fn resolve_start_block(
         .expect("cannot identify minimum start block because there are no data sources")
     {
         0 => Ok(None),
-        min_start_block => Retry::spawn(retry_strategy(Some(2), RETRY_DEFAULT_LIMIT), move || {
+        min_start_block => Retry::start(retry_strategy(Some(2), RETRY_DEFAULT_LIMIT), move || {
             chain
-                .block_pointer_from_number(&logger, min_start_block - 1)
+                .block_pointer_from_number(logger, min_start_block - 1)
                 .inspect_err(move |e| warn!(&logger, "Failed to get block number: {}", e))
         })
         .await
@@ -573,7 +454,7 @@ async fn resolve_graft_block(
         })
 }
 
-async fn create_subgraph_version<C: Blockchain, S: SubgraphStore>(
+async fn create_subgraph_version<C: Blockchain, S: SubgraphStore, AC: amp::Client>(
     logger: &Logger,
     store: Arc<S>,
     chains: Arc<BlockchainMap>,
@@ -586,24 +467,27 @@ async fn create_subgraph_version<C: Blockchain, S: SubgraphStore>(
     debug_fork: Option<DeploymentHash>,
     version_switching_mode: SubgraphVersionSwitchingMode,
     resolver: &Arc<dyn LinkResolver>,
+    amp_client: Option<Arc<AC>>,
     history_blocks_override: Option<i32>,
+    amp_chain_names: &AmpChainNames,
 ) -> Result<DeploymentLocator, SubgraphRegistrarError> {
     let raw_string = serde_yaml::to_string(&raw).unwrap();
+
     let unvalidated = UnvalidatedSubgraphManifest::<C>::resolve(
         deployment.clone(),
         raw,
         resolver,
+        amp_client,
         logger,
         ENV_VARS.max_spec_version.clone(),
     )
     .map_err(SubgraphRegistrarError::ResolveError)
     .await?;
-
     // Determine if the graft_base should be validated.
     // Validate the graft_base if there is a pending graft, ensuring its presence.
     // If the subgraph is new (indicated by DeploymentNotFound), the graft_base should be validated.
     // If the subgraph already exists and there is no pending graft, graft_base validation is not required.
-    let should_validate = match store.graft_pending(&deployment) {
+    let should_validate = match store.graft_pending(&deployment).await {
         Ok(graft_pending) => graft_pending,
         Err(StoreError::DeploymentNotFound(_)) => true,
         Err(e) => return Err(SubgraphRegistrarError::StoreError(e)),
@@ -613,10 +497,11 @@ async fn create_subgraph_version<C: Blockchain, S: SubgraphStore>(
         .await
         .map_err(SubgraphRegistrarError::ManifestValidationError)?;
 
-    let network_name = manifest.network_name();
+    let network_name: Word = manifest.network_name().into();
+    let resolved_name = amp_chain_names.resolve(&network_name);
 
     let chain = chains
-        .get::<C>(network_name.clone())
+        .get::<C>(resolved_name.clone())
         .map_err(SubgraphRegistrarError::NetworkNotSupported)?
         .cheap_clone();
 
@@ -624,7 +509,7 @@ async fn create_subgraph_version<C: Blockchain, S: SubgraphStore>(
     let store = store.clone();
     let deployment_store = store.clone();
 
-    if !store.subgraph_exists(&name)? {
+    if !store.subgraph_exists(&name).await? {
         debug!(
             logger,
             "Subgraph not found, could not create_subgraph_version";
@@ -696,8 +581,9 @@ async fn create_subgraph_version<C: Blockchain, S: SubgraphStore>(
             &manifest.schema,
             deployment,
             node_id,
-            network_name,
+            resolved_name.into(),
             version_switching_mode,
         )
+        .await
         .map_err(SubgraphRegistrarError::SubgraphDeploymentError)
 }
diff --git a/core/src/subgraph/runner.rs b/core/src/subgraph/runner.rs
deleted file mode 100644
index 2bc03f37214..00000000000
--- a/core/src/subgraph/runner.rs
+++ /dev/null
@@ -1,1545 +0,0 @@
-use crate::subgraph::context::IndexingContext;
-use crate::subgraph::error::BlockProcessingError;
-use crate::subgraph::inputs::IndexingInputs;
-use crate::subgraph::state::IndexingState;
-use crate::subgraph::stream::new_block_stream;
-use atomic_refcell::AtomicRefCell;
-use graph::blockchain::block_stream::{BlockStreamEvent, BlockWithTriggers, FirehoseCursor};
-use graph::blockchain::{Block, BlockTime, Blockchain, DataSource as _, TriggerFilter as _};
-use graph::components::store::{EmptyStore, GetScope, ReadStore, StoredDynamicDataSource};
-use graph::components::{
-    store::ModificationsAndCache,
-    subgraph::{MappingError, PoICausalityRegion, ProofOfIndexing, SharedProofOfIndexing},
-};
-use graph::data::store::scalar::Bytes;
-use graph::data::subgraph::{
-    schema::{SubgraphError, SubgraphHealth},
-    SubgraphFeature,
-};
-use graph::data_source::{
-    offchain, CausalityRegion, DataSource, DataSourceCreationError, DataSourceTemplate, TriggerData,
-};
-use graph::env::EnvVars;
-use graph::prelude::*;
-use graph::schema::EntityKey;
-use graph::util::{backoff::ExponentialBackoff, lfu_cache::LfuCache};
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-
-const MINUTE: Duration = Duration::from_secs(60);
-
-const SKIP_PTR_UPDATES_THRESHOLD: Duration = Duration::from_secs(60 * 5);
-const HANDLE_REVERT_SECTION_NAME: &str = "handle_revert";
-const PROCESS_BLOCK_SECTION_NAME: &str = "process_block";
-const PROCESS_WASM_BLOCK_SECTION_NAME: &str = "process_wasm_block";
-const PROCESS_TRIGGERS_SECTION_NAME: &str = "process_triggers";
-const HANDLE_CREATED_DS_SECTION_NAME: &str = "handle_new_data_sources";
-
-pub struct SubgraphRunner<C, T>
-where
-    C: Blockchain,
-    T: RuntimeHostBuilder<C>,
-{
-    ctx: IndexingContext<C, T>,
-    state: IndexingState,
-    inputs: Arc<IndexingInputs<C>>,
-    logger: Logger,
-    pub metrics: RunnerMetrics,
-}
-
-impl<C, T> SubgraphRunner<C, T>
-where
-    C: Blockchain,
-    T: RuntimeHostBuilder<C>,
-{
-    pub fn new(
-        inputs: IndexingInputs<C>,
-        ctx: IndexingContext<C, T>,
-        logger: Logger,
-        metrics: RunnerMetrics,
-        env_vars: Arc<EnvVars>,
-    ) -> Self {
-        Self {
-            inputs: Arc::new(inputs),
-            ctx,
-            state: IndexingState {
-                should_try_unfail_non_deterministic: true,
-                synced: false,
-                skip_ptr_updates_timer: Instant::now(),
-                backoff: ExponentialBackoff::with_jitter(
-                    (MINUTE * 2).min(env_vars.subgraph_error_retry_ceil),
-                    env_vars.subgraph_error_retry_ceil,
-                    env_vars.subgraph_error_retry_jitter,
-                ),
-                entity_lfu_cache: LfuCache::new(),
-                cached_head_ptr: None,
-            },
-            logger,
-            metrics,
-        }
-    }
-
-    /// Revert the state to a previous block. When handling revert operations
-    /// or failed block processing, it is necessary to remove part of the existing
-    /// in-memory state to keep it constent with DB changes.
-    /// During block processing new dynamic data sources are added directly to the
-    /// IndexingContext of the runner. This means that if, for whatever reason,
-    /// the changes don;t complete then the remnants of that block processing must
-    /// be removed. The same thing also applies to the block cache.
-    /// This function must be called before continuing to process in order to avoid
-    /// duplicated host insertion and POI issues with dirty entity changes.
-    fn revert_state_to(&mut self, block_number: BlockNumber) -> Result<(), Error> {
-        self.state.entity_lfu_cache = LfuCache::new();
-
-        // 1. Revert all hosts(created by DDS) at a block higher than `block_number`.
-        // 2. Unmark any offchain data sources that were marked done on the blocks being removed.
-        // When no offchain datasources are present, 2. should be a noop.
-        self.ctx.revert_data_sources(block_number + 1)?;
-        Ok(())
-    }
-
-    #[cfg(debug_assertions)]
-    pub fn context(&self) -> &IndexingContext<C, T> {
-        &self.ctx
-    }
-
-    #[cfg(debug_assertions)]
-    pub async fn run_for_test(self, break_on_restart: bool) -> Result<Self, Error> {
-        self.run_inner(break_on_restart).await
-    }
-
-    fn build_filter(&self) -> C::TriggerFilter {
-        let current_ptr = self.inputs.store.block_ptr();
-        let static_filters =
-            self.inputs.static_filters || self.ctx.hosts_len() > ENV_VARS.static_filters_threshold;
-
-        // Filter out data sources that have reached their end block
-        let end_block_filter = |ds: &&C::DataSource| match current_ptr.as_ref() {
-            // We filter out datasources for which the current block is at or past their end block.
-            Some(block) => ds.end_block().map_or(true, |end| block.number < end),
-            // If there is no current block, we keep all datasources.
-            None => true,
-        };
-
-        // if static_filters is not enabled we just stick to the filter based on all the data sources.
-        if !static_filters {
-            return C::TriggerFilter::from_data_sources(
-                self.ctx.onchain_data_sources().filter(end_block_filter),
-            );
-        }
-
-        // if static_filters is enabled, build a minimal filter with the static data sources and
-        // add the necessary filters based on templates.
-        // This specifically removes dynamic data sources based filters because these can be derived
-        // from templates AND this reduces the cost of egress traffic by making the payloads smaller.
-
-        if !self.inputs.static_filters {
-            info!(self.logger, "forcing subgraph to use static filters.")
-        }
-
-        let data_sources = self.ctx.static_data_sources();
-
-        let mut filter = C::TriggerFilter::from_data_sources(
-            data_sources
-                .iter()
-                .filter_map(|ds| ds.as_onchain())
-                // Filter out data sources that have reached their end block if the block is final.
-                .filter(end_block_filter),
-        );
-
-        let templates = self.ctx.templates();
-
-        filter.extend_with_template(templates.iter().filter_map(|ds| ds.as_onchain()).cloned());
-
-        filter
-    }
-
-    #[cfg(debug_assertions)]
-    pub fn build_filter_for_test(&self) -> C::TriggerFilter {
-        self.build_filter()
-    }
-
-    pub async fn run(self) -> Result<(), Error> {
-        self.run_inner(false).await.map(|_| ())
-    }
-
-    async fn run_inner(mut self, break_on_restart: bool) -> Result<Self, Error> {
-        // If a subgraph failed for deterministic reasons, before start indexing, we first
-        // revert the deployment head. It should lead to the same result since the error was
-        // deterministic.
-        if let Some(current_ptr) = self.inputs.store.block_ptr() {
-            if let Some(parent_ptr) = self
-                .inputs
-                .triggers_adapter
-                .parent_ptr(&current_ptr)
-                .await?
-            {
-                // This reverts the deployment head to the parent_ptr if
-                // deterministic errors happened.
-                //
-                // There's no point in calling it if we have no current or parent block
-                // pointers, because there would be: no block to revert to or to search
-                // errors from (first execution).
-                //
-                // We attempt to unfail deterministic errors to mitigate deterministic
-                // errors caused by wrong data being consumed from the providers. It has
-                // been a frequent case in the past so this helps recover on a larger scale.
-                let _outcome = self
-                    .inputs
-                    .store
-                    .unfail_deterministic_error(&current_ptr, &parent_ptr)
-                    .await?;
-            }
-        }
-
-        loop {
-            debug!(self.logger, "Starting or restarting subgraph");
-
-            let block_stream_canceler = CancelGuard::new();
-            let block_stream_cancel_handle = block_stream_canceler.handle();
-            // TriggerFilter needs to be rebuilt eveytime the blockstream is restarted
-            self.ctx.filter = Some(self.build_filter());
-
-            let mut block_stream = new_block_stream(
-                &self.inputs,
-                self.ctx.filter.as_ref().unwrap(), // Safe to unwrap as we just called `build_filter` in the previous line
-                &self.metrics.subgraph,
-            )
-            .await?
-            .map_err(CancelableError::Error)
-            .cancelable(&block_stream_canceler, || Err(CancelableError::Cancel));
-
-            // Keep the stream's cancel guard around to be able to shut it down when the subgraph
-            // deployment is unassigned
-            self.ctx
-                .instances
-                .insert(self.inputs.deployment.id, block_stream_canceler);
-
-            debug!(self.logger, "Starting block stream");
-
-            // Process events from the stream as long as no restart is needed
-            loop {
-                let event = {
-                    let _section = self.metrics.stream.stopwatch.start_section("scan_blocks");
-
-                    block_stream.next().await
-                };
-
-                // TODO: move cancel handle to the Context
-                // This will require some code refactor in how the BlockStream is created
-                let block_start = Instant::now();
-                match self
-                    .handle_stream_event(event, &block_stream_cancel_handle)
-                    .await
-                    .map(|res| {
-                        self.metrics
-                            .subgraph
-                            .observe_block_processed(block_start.elapsed(), res.block_finished());
-                        res
-                    })? {
-                    Action::Continue => continue,
-                    Action::Stop => {
-                        info!(self.logger, "Stopping subgraph");
-                        self.inputs.store.flush().await?;
-                        return Ok(self);
-                    }
-                    Action::Restart if break_on_restart => {
-                        info!(self.logger, "Stopping subgraph on break");
-                        self.inputs.store.flush().await?;
-                        return Ok(self);
-                    }
-                    Action::Restart => {
-                        // Restart the store to clear any errors that it
-                        // might have encountered and use that from now on
-                        let store = self.inputs.store.cheap_clone();
-                        if let Some(store) = store.restart().await? {
-                            let last_good_block =
-                                store.block_ptr().map(|ptr| ptr.number).unwrap_or(0);
-                            self.revert_state_to(last_good_block)?;
-                            self.inputs = Arc::new(self.inputs.with_store(store));
-                            self.state.synced = self.inputs.store.is_deployment_synced().await?;
-                        }
-                        break;
-                    }
-                };
-            }
-        }
-    }
-
-    /// Processes a block and returns the updated context and a boolean flag indicating
-    /// whether new dynamic data sources have been added to the subgraph.
-    async fn process_block(
-        &mut self,
-        block_stream_cancel_handle: &CancelHandle,
-        block: BlockWithTriggers<C>,
-        firehose_cursor: FirehoseCursor,
-    ) -> Result<Action, BlockProcessingError> {
-        let triggers = block.trigger_data;
-        let block = Arc::new(block.block);
-        let block_ptr = block.ptr();
-
-        let logger = self.logger.new(o!(
-                "block_number" => format!("{:?}", block_ptr.number),
-                "block_hash" => format!("{}", block_ptr.hash)
-        ));
-
-        debug!(logger, "Start processing block";
-               "triggers" => triggers.len());
-
-        let proof_of_indexing = if self.inputs.store.supports_proof_of_indexing().await? {
-            Some(Arc::new(AtomicRefCell::new(ProofOfIndexing::new(
-                block_ptr.number,
-                self.inputs.poi_version,
-            ))))
-        } else {
-            None
-        };
-
-        // Causality region for onchain triggers.
-        let causality_region = PoICausalityRegion::from_network(&self.inputs.network);
-
-        let mut block_state = {
-            let _section = self
-                .metrics
-                .stream
-                .stopwatch
-                .start_section(PROCESS_TRIGGERS_SECTION_NAME);
-
-            // Process events one after the other, passing in entity operations
-            // collected previously to every new event being processed
-            match self
-                .process_triggers(
-                    &proof_of_indexing,
-                    &block,
-                    triggers.into_iter().map(TriggerData::Onchain),
-                    &causality_region,
-                )
-                .await
-            {
-                // Triggers processed with no errors or with only deterministic errors.
-                Ok(block_state) => block_state,
-
-                // Some form of unknown or non-deterministic error ocurred.
-                Err(MappingError::Unknown(e)) => return Err(BlockProcessingError::Unknown(e)),
-                Err(MappingError::PossibleReorg(e)) => {
-                    info!(logger,
-                        "Possible reorg detected, retrying";
-                        "error" => format!("{:#}", e),
-                    );
-
-                    // In case of a possible reorg, we want this function to do nothing and restart the
-                    // block stream so it has a chance to detect the reorg.
-                    //
-                    // The state is unchanged at this point, except for having cleared the entity cache.
-                    // Losing the cache is a bit annoying but not an issue for correctness.
-                    //
-                    // See also b21fa73b-6453-4340-99fb-1a78ec62efb1.
-                    return Ok(Action::Restart);
-                }
-            }
-        };
-
-        // Check if there are any datasources that have expired in this block. ie: the end_block
-        // of that data source is equal to the block number of the current block.
-        let has_expired_data_sources = self.inputs.end_blocks.contains(&block_ptr.number);
-
-        // If new onchain data sources have been created, and static filters are not in use, it is necessary
-        // to restart the block stream with the new filters.
-        let created_data_sources_needs_restart =
-            !self.inputs.static_filters && block_state.has_created_on_chain_data_sources();
-
-        // Determine if the block stream needs to be restarted due to newly created on-chain data sources
-        // or data sources that have reached their end block.
-        let needs_restart = created_data_sources_needs_restart || has_expired_data_sources;
-
-        {
-            let _section = self
-                .metrics
-                .stream
-                .stopwatch
-                .start_section(HANDLE_CREATED_DS_SECTION_NAME);
-
-            // This loop will:
-            // 1. Instantiate created data sources.
-            // 2. Process those data sources for the current block.
-            // Until no data sources are created or MAX_DATA_SOURCES is hit.
-
-            // Note that this algorithm processes data sources spawned on the same block _breadth
-            // first_ on the tree implied by the parent-child relationship between data sources. Only a
-            // very contrived subgraph would be able to observe this.
-            while block_state.has_created_data_sources() {
-                // Instantiate dynamic data sources, removing them from the block state.
-                let (data_sources, runtime_hosts) =
-                    self.create_dynamic_data_sources(block_state.drain_created_data_sources())?;
-
-                let filter = C::TriggerFilter::from_data_sources(
-                    data_sources.iter().filter_map(DataSource::as_onchain),
-                );
-
-                let block: Arc<C::Block> = if self.inputs.chain.is_refetch_block_required() {
-                    let cur = firehose_cursor.clone();
-                    let log = logger.cheap_clone();
-                    let chain = self.inputs.chain.cheap_clone();
-                    Arc::new(
-                        retry(
-                            "refetch firehose block after dynamic datasource was added",
-                            &logger,
-                        )
-                        .limit(5)
-                        .no_timeout()
-                        .run(move || {
-                            let cur = cur.clone();
-                            let log = log.cheap_clone();
-                            let chain = chain.cheap_clone();
-                            async move { chain.refetch_firehose_block(&log, cur).await }
-                        })
-                        .await?,
-                    )
-                } else {
-                    block.cheap_clone()
-                };
-
-                // Reprocess the triggers from this block that match the new data sources
-                let block_with_triggers = self
-                    .inputs
-                    .triggers_adapter
-                    .triggers_in_block(&logger, block.as_ref().clone(), &filter)
-                    .await?;
-
-                let triggers = block_with_triggers.trigger_data;
-
-                if triggers.len() == 1 {
-                    info!(
-                        &logger,
-                        "1 trigger found in this block for the new data sources"
-                    );
-                } else if triggers.len() > 1 {
-                    info!(
-                        &logger,
-                        "{} triggers found in this block for the new data sources",
-                        triggers.len()
-                    );
-                }
-
-                // Add entity operations for the new data sources to the block state
-                // and add runtimes for the data sources to the subgraph instance.
-                self.persist_dynamic_data_sources(&mut block_state, data_sources);
-
-                // Process the triggers in each host in the same order the
-                // corresponding data sources have been created.
-                for trigger in triggers {
-                    block_state = self
-                        .ctx
-                        .process_trigger_in_hosts(
-                            &logger,
-                            Box::new(runtime_hosts.iter().map(|host| host.as_ref())),
-                            &block,
-                            &TriggerData::Onchain(trigger),
-                            block_state,
-                            &proof_of_indexing,
-                            &causality_region,
-                            &self.inputs.debug_fork,
-                            &self.metrics.subgraph,
-                            self.inputs.instrument,
-                        )
-                        .await
-                        .map_err(|e| {
-                            // This treats a `PossibleReorg` as an ordinary error which will fail the subgraph.
-                            // This can cause an unnecessary subgraph failure, to fix it we need to figure out a
-                            // way to revert the effect of `create_dynamic_data_sources` so we may return a
-                            // clean context as in b21fa73b-6453-4340-99fb-1a78ec62efb1.
-                            match e {
-                                MappingError::PossibleReorg(e) | MappingError::Unknown(e) => {
-                                    BlockProcessingError::Unknown(e)
-                                }
-                            }
-                        })?;
-                }
-            }
-        }
-
-        let has_errors = block_state.has_errors();
-        let is_non_fatal_errors_active = self
-            .inputs
-            .features
-            .contains(&SubgraphFeature::NonFatalErrors);
-
-        // Apply entity operations and advance the stream
-
-        // Avoid writing to store if block stream has been canceled
-        if block_stream_cancel_handle.is_canceled() {
-            return Err(BlockProcessingError::Canceled);
-        }
-
-        if let Some(proof_of_indexing) = proof_of_indexing {
-            let proof_of_indexing = Arc::try_unwrap(proof_of_indexing).unwrap().into_inner();
-            update_proof_of_indexing(
-                proof_of_indexing,
-                block.timestamp(),
-                &self.metrics.host.stopwatch,
-                &mut block_state.entity_cache,
-            )
-            .await?;
-        }
-
-        let section = self
-            .metrics
-            .host
-            .stopwatch
-            .start_section("as_modifications");
-        let ModificationsAndCache {
-            modifications: mut mods,
-            entity_lfu_cache: cache,
-            evict_stats,
-        } = block_state
-            .entity_cache
-            .as_modifications(block.number())
-            .map_err(|e| BlockProcessingError::Unknown(e.into()))?;
-        section.end();
-
-        debug!(self.logger, "Entity cache statistics";
-            "weight" => evict_stats.new_weight,
-            "evicted_weight" => evict_stats.evicted_weight,
-            "count" => evict_stats.new_count,
-            "evicted_count" => evict_stats.evicted_count,
-            "stale_update" => evict_stats.stale_update,
-            "hit_rate" => format!("{:.0}%", evict_stats.hit_rate_pct()),
-            "accesses" => evict_stats.accesses,
-            "evict_time_ms" => evict_stats.evict_time.as_millis());
-
-        // Check for offchain events and process them, including their entity modifications in the
-        // set to be transacted.
-        let offchain_events = self.ctx.offchain_monitor.ready_offchain_events()?;
-        let (offchain_mods, processed_offchain_data_sources, persisted_off_chain_data_sources) =
-            self.handle_offchain_triggers(offchain_events, &block)
-                .await?;
-        mods.extend(offchain_mods);
-
-        // Put the cache back in the state, asserting that the placeholder cache was not used.
-        assert!(self.state.entity_lfu_cache.is_empty());
-        self.state.entity_lfu_cache = cache;
-
-        if !mods.is_empty() {
-            info!(&logger, "Applying {} entity operation(s)", mods.len());
-        }
-
-        let err_count = block_state.deterministic_errors.len();
-        for (i, e) in block_state.deterministic_errors.iter().enumerate() {
-            let message = format!("{:#}", e).replace('\n', "\t");
-            error!(&logger, "Subgraph error {}/{}", i + 1, err_count;
-                "error" => message,
-                "code" => LogCode::SubgraphSyncingFailure
-            );
-        }
-
-        // Transact entity operations into the store and update the
-        // subgraph's block stream pointer
-        let _section = self.metrics.host.stopwatch.start_section("transact_block");
-        let start = Instant::now();
-
-        let store = &self.inputs.store;
-
-        // If a deterministic error has happened, make the PoI to be the only entity that'll be stored.
-        if has_errors && !is_non_fatal_errors_active {
-            let is_poi_entity =
-                |entity_mod: &EntityModification| entity_mod.key().entity_type.is_poi();
-            mods.retain(is_poi_entity);
-            // Confidence check
-            assert!(
-                mods.len() == 1,
-                "There should be only one PoI EntityModification"
-            );
-        }
-
-        let BlockState {
-            deterministic_errors,
-            mut persisted_data_sources,
-            ..
-        } = block_state;
-
-        let first_error = deterministic_errors.first().cloned();
-
-        persisted_data_sources.extend(persisted_off_chain_data_sources);
-        store
-            .transact_block_operations(
-                block_ptr,
-                block.timestamp(),
-                firehose_cursor,
-                mods,
-                &self.metrics.host.stopwatch,
-                persisted_data_sources,
-                deterministic_errors,
-                processed_offchain_data_sources,
-                is_non_fatal_errors_active,
-            )
-            .await
-            .context("Failed to transact block operations")?;
-
-        // For subgraphs with `nonFatalErrors` feature disabled, we consider
-        // any error as fatal.
-        //
-        // So we do an early return to make the subgraph stop processing blocks.
-        //
-        // In this scenario the only entity that is stored/transacted is the PoI,
-        // all of the others are discarded.
-        if has_errors && !is_non_fatal_errors_active {
-            // Only the first error is reported.
-            return Err(BlockProcessingError::Deterministic(first_error.unwrap()));
-        }
-
-        let elapsed = start.elapsed().as_secs_f64();
-        self.metrics
-            .subgraph
-            .block_ops_transaction_duration
-            .observe(elapsed);
-
-        // To prevent a buggy pending version from replacing a current version, if errors are
-        // present the subgraph will be unassigned.
-        if has_errors && !ENV_VARS.disable_fail_fast && !store.is_deployment_synced().await? {
-            store
-                .unassign_subgraph()
-                .map_err(|e| BlockProcessingError::Unknown(e.into()))?;
-
-            // Use `Canceled` to avoiding setting the subgraph health to failed, an error was
-            // just transacted so it will be already be set to unhealthy.
-            return Err(BlockProcessingError::Canceled);
-        }
-
-        match needs_restart {
-            true => Ok(Action::Restart),
-            false => Ok(Action::Continue),
-        }
-    }
-
-    async fn process_triggers(
-        &mut self,
-        proof_of_indexing: &SharedProofOfIndexing,
-        block: &Arc<C::Block>,
-        triggers: impl Iterator<Item = TriggerData<C>>,
-        causality_region: &str,
-    ) -> Result<BlockState<C>, MappingError> {
-        let mut block_state = BlockState::new(
-            self.inputs.store.clone(),
-            std::mem::take(&mut self.state.entity_lfu_cache),
-        );
-
-        for trigger in triggers {
-            block_state = self
-                .ctx
-                .process_trigger(
-                    &self.logger,
-                    block,
-                    &trigger,
-                    block_state,
-                    proof_of_indexing,
-                    causality_region,
-                    &self.inputs.debug_fork,
-                    &self.metrics.subgraph,
-                    self.inputs.instrument,
-                )
-                .await
-                .map_err(move |mut e| {
-                    let error_context = trigger.error_context();
-                    if !error_context.is_empty() {
-                        e = e.context(error_context);
-                    }
-                    e.context("failed to process trigger".to_string())
-                })?;
-        }
-        Ok(block_state)
-    }
-    async fn process_wasm_block(
-        &mut self,
-        proof_of_indexing: &SharedProofOfIndexing,
-        block_ptr: BlockPtr,
-        block_time: BlockTime,
-        block_data: Box<[u8]>,
-        handler: String,
-        causality_region: &str,
-    ) -> Result<BlockState<C>, MappingError> {
-        let block_state = BlockState::new(
-            self.inputs.store.clone(),
-            std::mem::take(&mut self.state.entity_lfu_cache),
-        );
-
-        self.ctx
-            .process_block(
-                &self.logger,
-                block_ptr,
-                block_time,
-                block_data,
-                handler,
-                block_state,
-                proof_of_indexing,
-                causality_region,
-                &self.inputs.debug_fork,
-                &self.metrics.subgraph,
-                self.inputs.instrument,
-            )
-            .await
-    }
-
-    fn create_dynamic_data_sources(
-        &mut self,
-        created_data_sources: Vec<DataSourceTemplateInfo<C>>,
-    ) -> Result<(Vec<DataSource<C>>, Vec<Arc<T::Host>>), Error> {
-        let mut data_sources = vec![];
-        let mut runtime_hosts = vec![];
-
-        for info in created_data_sources {
-            // Try to instantiate a data source from the template
-
-            let data_source = {
-                let res = match info.template {
-                    DataSourceTemplate::Onchain(_) => C::DataSource::from_template_info(info)
-                        .map(DataSource::Onchain)
-                        .map_err(DataSourceCreationError::from),
-                    DataSourceTemplate::Offchain(_) => offchain::DataSource::from_template_info(
-                        info,
-                        self.ctx.causality_region_next_value(),
-                    )
-                    .map(DataSource::Offchain),
-                };
-                match res {
-                    Ok(ds) => ds,
-                    Err(e @ DataSourceCreationError::Ignore(..)) => {
-                        warn!(self.logger, "{}", e.to_string());
-                        continue;
-                    }
-                    Err(DataSourceCreationError::Unknown(e)) => return Err(e),
-                }
-            };
-
-            // Try to create a runtime host for the data source
-            let host = self
-                .ctx
-                .add_dynamic_data_source(&self.logger, data_source.clone())?;
-
-            match host {
-                Some(host) => {
-                    data_sources.push(data_source);
-                    runtime_hosts.push(host);
-                }
-                None => {
-                    warn!(
-                        self.logger,
-                        "no runtime host created, there is already a runtime host instantiated for \
-                        this data source";
-                        "name" => &data_source.name(),
-                        "address" => &data_source.address()
-                        .map(hex::encode)
-                        .unwrap_or("none".to_string()),
-                    )
-                }
-            }
-        }
-
-        Ok((data_sources, runtime_hosts))
-    }
-
-    async fn handle_action(
-        &mut self,
-        start: Instant,
-        block_ptr: BlockPtr,
-        action: Result<Action, BlockProcessingError>,
-    ) -> Result<Action, Error> {
-        self.state.skip_ptr_updates_timer = Instant::now();
-
-        let elapsed = start.elapsed().as_secs_f64();
-        self.metrics
-            .subgraph
-            .block_processing_duration
-            .observe(elapsed);
-
-        match action {
-            Ok(action) => {
-                // Once synced, no need to try to update the status again.
-                if !self.state.synced
-                    && close_to_chain_head(
-                        &block_ptr,
-                        self.inputs.chain.chain_store().chain_head_ptr().await?,
-                        // We consider a subgraph synced when it's at most 1 block behind the
-                        // chain head.
-                        1,
-                    )
-                {
-                    // Updating the sync status is an one way operation.
-                    // This state change exists: not synced -> synced
-                    // This state change does NOT: synced -> not synced
-                    self.inputs.store.deployment_synced()?;
-
-                    // Stop trying to update the sync status.
-                    self.state.synced = true;
-
-                    // Stop recording time-to-sync metrics.
-                    self.metrics.stream.stopwatch.disable();
-                }
-
-                // Keep trying to unfail subgraph for everytime it advances block(s) until it's
-                // health is not Failed anymore.
-                if self.state.should_try_unfail_non_deterministic {
-                    // If the deployment head advanced, we can unfail
-                    // the non-deterministic error (if there's any).
-                    let outcome = self
-                        .inputs
-                        .store
-                        .unfail_non_deterministic_error(&block_ptr)?;
-
-                    if let UnfailOutcome::Unfailed = outcome {
-                        // Stop trying to unfail.
-                        self.state.should_try_unfail_non_deterministic = false;
-                        self.metrics.stream.deployment_failed.set(0.0);
-                        self.state.backoff.reset();
-                    }
-                }
-
-                if let Some(stop_block) = &self.inputs.stop_block {
-                    if block_ptr.number >= *stop_block {
-                        info!(self.logger, "stop block reached for subgraph");
-                        return Ok(Action::Stop);
-                    }
-                }
-
-                return Ok(action);
-            }
-            Err(BlockProcessingError::Canceled) => {
-                debug!(self.logger, "Subgraph block stream shut down cleanly");
-                return Ok(Action::Stop);
-            }
-
-            // Handle unexpected stream errors by marking the subgraph as failed.
-            Err(e) => {
-                self.metrics.stream.deployment_failed.set(1.0);
-
-                let message = format!("{:#}", e).replace('\n', "\t");
-                let err = anyhow!("{}, code: {}", message, LogCode::SubgraphSyncingFailure);
-                let deterministic = e.is_deterministic();
-
-                let error = SubgraphError {
-                    subgraph_id: self.inputs.deployment.hash.clone(),
-                    message,
-                    block_ptr: Some(block_ptr),
-                    handler: None,
-                    deterministic,
-                };
-
-                match deterministic {
-                    true => {
-                        // Fail subgraph:
-                        // - Change status/health.
-                        // - Save the error to the database.
-                        self.inputs
-                            .store
-                            .fail_subgraph(error)
-                            .await
-                            .context("Failed to set subgraph status to `failed`")?;
-
-                        return Err(err);
-                    }
-                    false => {
-                        // Shouldn't fail subgraph if it's already failed for non-deterministic
-                        // reasons.
-                        //
-                        // If we don't do this check we would keep adding the same error to the
-                        // database.
-                        let should_fail_subgraph =
-                            self.inputs.store.health().await? != SubgraphHealth::Failed;
-
-                        if should_fail_subgraph {
-                            // Fail subgraph:
-                            // - Change status/health.
-                            // - Save the error to the database.
-                            self.inputs
-                                .store
-                                .fail_subgraph(error)
-                                .await
-                                .context("Failed to set subgraph status to `failed`")?;
-                        }
-
-                        // Retry logic below:
-
-                        let message = format!("{:#}", e).replace('\n', "\t");
-                        error!(self.logger, "Subgraph failed with non-deterministic error: {}", message;
-                            "attempt" => self.state.backoff.attempt,
-                            "retry_delay_s" => self.state.backoff.delay().as_secs());
-
-                        // Sleep before restarting.
-                        self.state.backoff.sleep_async().await;
-
-                        self.state.should_try_unfail_non_deterministic = true;
-
-                        // And restart the subgraph.
-                        return Ok(Action::Restart);
-                    }
-                }
-            }
-        }
-    }
-
-    fn persist_dynamic_data_sources(
-        &mut self,
-        block_state: &mut BlockState<C>,
-        data_sources: Vec<DataSource<C>>,
-    ) {
-        if !data_sources.is_empty() {
-            debug!(
-                self.logger,
-                "Creating {} dynamic data source(s)",
-                data_sources.len()
-            );
-        }
-
-        // Add entity operations to the block state in order to persist
-        // the dynamic data sources
-        for data_source in data_sources.iter() {
-            debug!(
-                self.logger,
-                "Persisting data_source";
-                "name" => &data_source.name(),
-                "address" => &data_source.address().map(hex::encode).unwrap_or("none".to_string()),
-            );
-            block_state.persist_data_source(data_source.as_stored_dynamic_data_source());
-        }
-    }
-}
-
-impl<C, T> SubgraphRunner<C, T>
-where
-    C: Blockchain,
-    T: RuntimeHostBuilder<C>,
-{
-    async fn handle_stream_event(
-        &mut self,
-        event: Option<Result<BlockStreamEvent<C>, CancelableError<Error>>>,
-        cancel_handle: &CancelHandle,
-    ) -> Result<Action, Error> {
-        let action = match event {
-            Some(Ok(BlockStreamEvent::ProcessWasmBlock(
-                block_ptr,
-                block_time,
-                data,
-                handler,
-                cursor,
-            ))) => {
-                let _section = self
-                    .metrics
-                    .stream
-                    .stopwatch
-                    .start_section(PROCESS_WASM_BLOCK_SECTION_NAME);
-                self.handle_process_wasm_block(
-                    block_ptr,
-                    block_time,
-                    data,
-                    handler,
-                    cursor,
-                    cancel_handle,
-                )
-                .await?
-            }
-            Some(Ok(BlockStreamEvent::ProcessBlock(block, cursor))) => {
-                let _section = self
-                    .metrics
-                    .stream
-                    .stopwatch
-                    .start_section(PROCESS_BLOCK_SECTION_NAME);
-                self.handle_process_block(block, cursor, cancel_handle)
-                    .await?
-            }
-            Some(Ok(BlockStreamEvent::Revert(revert_to_ptr, cursor))) => {
-                let _section = self
-                    .metrics
-                    .stream
-                    .stopwatch
-                    .start_section(HANDLE_REVERT_SECTION_NAME);
-                self.handle_revert(revert_to_ptr, cursor).await?
-            }
-            // Log and drop the errors from the block_stream
-            // The block stream will continue attempting to produce blocks
-            Some(Err(e)) => self.handle_err(e, cancel_handle).await?,
-            // If the block stream ends, that means that there is no more indexing to do.
-            // Typically block streams produce indefinitely, but tests are an example of finite block streams.
-            None => Action::Stop,
-        };
-
-        Ok(action)
-    }
-
-    async fn handle_offchain_triggers(
-        &mut self,
-        triggers: Vec<offchain::TriggerData>,
-        block: &Arc<C::Block>,
-    ) -> Result<
-        (
-            Vec<EntityModification>,
-            Vec<StoredDynamicDataSource>,
-            Vec<StoredDynamicDataSource>,
-        ),
-        Error,
-    > {
-        let mut mods = vec![];
-        let mut processed_data_sources = vec![];
-        let mut persisted_data_sources = vec![];
-
-        for trigger in triggers {
-            // Using an `EmptyStore` and clearing the cache for each trigger is a makeshift way to
-            // get causality region isolation.
-            let schema = ReadStore::input_schema(&self.inputs.store);
-            let mut block_state = BlockState::<C>::new(EmptyStore::new(schema), LfuCache::new());
-
-            // PoI ignores offchain events.
-            // See also: poi-ignores-offchain
-            let proof_of_indexing = None;
-            let causality_region = "";
-
-            block_state = self
-                .ctx
-                .process_trigger(
-                    &self.logger,
-                    block,
-                    &TriggerData::Offchain(trigger),
-                    block_state,
-                    &proof_of_indexing,
-                    causality_region,
-                    &self.inputs.debug_fork,
-                    &self.metrics.subgraph,
-                    self.inputs.instrument,
-                )
-                .await
-                .map_err(move |err| {
-                    let err = match err {
-                        // Ignoring `PossibleReorg` isn't so bad since the subgraph will retry
-                        // non-deterministic errors.
-                        MappingError::PossibleReorg(e) | MappingError::Unknown(e) => e,
-                    };
-                    err.context("failed to process trigger".to_string())
-                })?;
-
-            anyhow::ensure!(
-                !block_state.has_created_on_chain_data_sources(),
-                "Attempted to create on-chain data source in offchain data source handler. This is not yet supported.",
-            );
-
-            let (data_sources, _) =
-                self.create_dynamic_data_sources(block_state.drain_created_data_sources())?;
-
-            // Add entity operations for the new data sources to the block state
-            // and add runtimes for the data sources to the subgraph instance.
-            self.persist_dynamic_data_sources(&mut block_state, data_sources);
-
-            // This propagates any deterministic error as a non-deterministic one. Which might make
-            // sense considering offchain data sources are non-deterministic.
-            if let Some(err) = block_state.deterministic_errors.into_iter().next() {
-                return Err(anyhow!("{}", err.to_string()));
-            }
-
-            mods.extend(
-                block_state
-                    .entity_cache
-                    .as_modifications(block.number())?
-                    .modifications,
-            );
-            processed_data_sources.extend(block_state.processed_data_sources);
-            persisted_data_sources.extend(block_state.persisted_data_sources)
-        }
-
-        Ok((mods, processed_data_sources, persisted_data_sources))
-    }
-}
-
-#[derive(Debug)]
-enum Action {
-    Continue,
-    Stop,
-    Restart,
-}
-
-impl Action {
-    /// Return `true` if the action indicates that we are done with a block
-    fn block_finished(&self) -> bool {
-        match self {
-            Action::Continue | Action::Restart => false,
-            Action::Stop => true,
-        }
-    }
-}
-
-#[async_trait]
-trait StreamEventHandler<C: Blockchain> {
-    async fn handle_process_wasm_block(
-        &mut self,
-        block_ptr: BlockPtr,
-        block_time: BlockTime,
-        block_data: Box<[u8]>,
-        handler: String,
-        cursor: FirehoseCursor,
-        cancel_handle: &CancelHandle,
-    ) -> Result<Action, Error>;
-    async fn handle_process_block(
-        &mut self,
-        block: BlockWithTriggers<C>,
-        cursor: FirehoseCursor,
-        cancel_handle: &CancelHandle,
-    ) -> Result<Action, Error>;
-    async fn handle_revert(
-        &mut self,
-        revert_to_ptr: BlockPtr,
-        cursor: FirehoseCursor,
-    ) -> Result<Action, Error>;
-    async fn handle_err(
-        &mut self,
-        err: CancelableError<Error>,
-        cancel_handle: &CancelHandle,
-    ) -> Result<Action, Error>;
-    fn needs_restart(&self, revert_to_ptr: BlockPtr, subgraph_ptr: BlockPtr) -> bool;
-}
-
-#[async_trait]
-impl<C, T> StreamEventHandler<C> for SubgraphRunner<C, T>
-where
-    C: Blockchain,
-    T: RuntimeHostBuilder<C>,
-{
-    async fn handle_process_wasm_block(
-        &mut self,
-        block_ptr: BlockPtr,
-        block_time: BlockTime,
-        block_data: Box<[u8]>,
-        handler: String,
-        cursor: FirehoseCursor,
-        cancel_handle: &CancelHandle,
-    ) -> Result<Action, Error> {
-        let logger = self.logger.new(o!(
-                "block_number" => format!("{:?}", block_ptr.number),
-                "block_hash" => format!("{}", block_ptr.hash)
-        ));
-
-        debug!(logger, "Start processing wasm block";);
-
-        let proof_of_indexing = if self.inputs.store.supports_proof_of_indexing().await? {
-            Some(Arc::new(AtomicRefCell::new(ProofOfIndexing::new(
-                block_ptr.number,
-                self.inputs.poi_version,
-            ))))
-        } else {
-            None
-        };
-
-        // Causality region for onchain triggers.
-        let causality_region = PoICausalityRegion::from_network(&self.inputs.network);
-
-        let mut block_state = {
-            match self
-                .process_wasm_block(
-                    &proof_of_indexing,
-                    block_ptr.clone(),
-                    block_time,
-                    block_data,
-                    handler,
-                    &causality_region,
-                )
-                .await
-            {
-                // Triggers processed with no errors or with only deterministic errors.
-                Ok(block_state) => block_state,
-
-                // Some form of unknown or non-deterministic error ocurred.
-                Err(MappingError::Unknown(e)) => {
-                    return Err(BlockProcessingError::Unknown(e).into())
-                }
-                Err(MappingError::PossibleReorg(e)) => {
-                    info!(logger,
-                        "Possible reorg detected, retrying";
-                        "error" => format!("{:#}", e),
-                    );
-
-                    // In case of a possible reorg, we want this function to do nothing and restart the
-                    // block stream so it has a chance to detect the reorg.
-                    //
-                    // The state is unchanged at this point, except for having cleared the entity cache.
-                    // Losing the cache is a bit annoying but not an issue for correctness.
-                    //
-                    // See also b21fa73b-6453-4340-99fb-1a78ec62efb1.
-                    return Ok(Action::Restart);
-                }
-            }
-        };
-
-        let has_errors = block_state.has_errors();
-        let is_non_fatal_errors_active = self
-            .inputs
-            .features
-            .contains(&SubgraphFeature::NonFatalErrors);
-
-        // Apply entity operations and advance the stream
-
-        // Avoid writing to store if block stream has been canceled
-        if cancel_handle.is_canceled() {
-            return Err(BlockProcessingError::Canceled.into());
-        }
-
-        if let Some(proof_of_indexing) = proof_of_indexing {
-            let proof_of_indexing = Arc::try_unwrap(proof_of_indexing).unwrap().into_inner();
-            update_proof_of_indexing(
-                proof_of_indexing,
-                block_time,
-                &self.metrics.host.stopwatch,
-                &mut block_state.entity_cache,
-            )
-            .await?;
-        }
-
-        let section = self
-            .metrics
-            .host
-            .stopwatch
-            .start_section("as_modifications");
-        let ModificationsAndCache {
-            modifications: mut mods,
-            entity_lfu_cache: cache,
-            evict_stats,
-        } = block_state
-            .entity_cache
-            .as_modifications(block_ptr.number)
-            .map_err(|e| BlockProcessingError::Unknown(e.into()))?;
-        section.end();
-
-        debug!(self.logger, "Entity cache statistics";
-            "weight" => evict_stats.new_weight,
-            "evicted_weight" => evict_stats.evicted_weight,
-            "count" => evict_stats.new_count,
-            "evicted_count" => evict_stats.evicted_count,
-            "stale_update" => evict_stats.stale_update,
-            "hit_rate" => format!("{:.0}%", evict_stats.hit_rate_pct()),
-            "accesses" => evict_stats.accesses,
-            "evict_time_ms" => evict_stats.evict_time.as_millis());
-
-        // Put the cache back in the state, asserting that the placeholder cache was not used.
-        assert!(self.state.entity_lfu_cache.is_empty());
-        self.state.entity_lfu_cache = cache;
-
-        if !mods.is_empty() {
-            info!(&logger, "Applying {} entity operation(s)", mods.len());
-        }
-
-        let err_count = block_state.deterministic_errors.len();
-        for (i, e) in block_state.deterministic_errors.iter().enumerate() {
-            let message = format!("{:#}", e).replace('\n', "\t");
-            error!(&logger, "Subgraph error {}/{}", i + 1, err_count;
-                "error" => message,
-                "code" => LogCode::SubgraphSyncingFailure
-            );
-        }
-
-        // Transact entity operations into the store and update the
-        // subgraph's block stream pointer
-        let _section = self.metrics.host.stopwatch.start_section("transact_block");
-        let start = Instant::now();
-
-        let store = &self.inputs.store;
-
-        // If a deterministic error has happened, make the PoI to be the only entity that'll be stored.
-        if has_errors && !is_non_fatal_errors_active {
-            let is_poi_entity =
-                |entity_mod: &EntityModification| entity_mod.key().entity_type.is_poi();
-            mods.retain(is_poi_entity);
-            // Confidence check
-            assert!(
-                mods.len() == 1,
-                "There should be only one PoI EntityModification"
-            );
-        }
-
-        let BlockState {
-            deterministic_errors,
-            ..
-        } = block_state;
-
-        let first_error = deterministic_errors.first().cloned();
-
-        store
-            .transact_block_operations(
-                block_ptr,
-                block_time,
-                cursor,
-                mods,
-                &self.metrics.host.stopwatch,
-                vec![],
-                deterministic_errors,
-                vec![],
-                is_non_fatal_errors_active,
-            )
-            .await
-            .context("Failed to transact block operations")?;
-
-        // For subgraphs with `nonFatalErrors` feature disabled, we consider
-        // any error as fatal.
-        //
-        // So we do an early return to make the subgraph stop processing blocks.
-        //
-        // In this scenario the only entity that is stored/transacted is the PoI,
-        // all of the others are discarded.
-        if has_errors && !is_non_fatal_errors_active {
-            // Only the first error is reported.
-            return Err(BlockProcessingError::Deterministic(first_error.unwrap()).into());
-        }
-
-        let elapsed = start.elapsed().as_secs_f64();
-        self.metrics
-            .subgraph
-            .block_ops_transaction_duration
-            .observe(elapsed);
-
-        // To prevent a buggy pending version from replacing a current version, if errors are
-        // present the subgraph will be unassigned.
-        if has_errors && !ENV_VARS.disable_fail_fast && !store.is_deployment_synced().await? {
-            store
-                .unassign_subgraph()
-                .map_err(|e| BlockProcessingError::Unknown(e.into()))?;
-
-            // Use `Canceled` to avoiding setting the subgraph health to failed, an error was
-            // just transacted so it will be already be set to unhealthy.
-            return Err(BlockProcessingError::Canceled.into());
-        };
-
-        Ok(Action::Continue)
-    }
-
-    async fn handle_process_block(
-        &mut self,
-        block: BlockWithTriggers<C>,
-        cursor: FirehoseCursor,
-        cancel_handle: &CancelHandle,
-    ) -> Result<Action, Error> {
-        let block_ptr = block.ptr();
-        self.metrics
-            .stream
-            .deployment_head
-            .set(block_ptr.number as f64);
-
-        if block.trigger_count() > 0 {
-            self.metrics
-                .subgraph
-                .block_trigger_count
-                .observe(block.trigger_count() as f64);
-        }
-
-        if block.trigger_count() == 0
-            && self.state.skip_ptr_updates_timer.elapsed() <= SKIP_PTR_UPDATES_THRESHOLD
-            && !self.state.synced
-            && !close_to_chain_head(
-                &block_ptr,
-                self.inputs.chain.chain_store().chain_head_ptr().await?,
-                // The "skip ptr updates timer" is ignored when a subgraph is at most 1000 blocks
-                // behind the chain head.
-                1000,
-            )
-        {
-            return Ok(Action::Continue);
-        } else {
-            self.state.skip_ptr_updates_timer = Instant::now();
-        }
-
-        let start = Instant::now();
-
-        let res = self.process_block(cancel_handle, block, cursor).await;
-
-        self.handle_action(start, block_ptr, res).await
-    }
-
-    async fn handle_revert(
-        &mut self,
-        revert_to_ptr: BlockPtr,
-        cursor: FirehoseCursor,
-    ) -> Result<Action, Error> {
-        // Current deployment head in the database / WritableAgent Mutex cache.
-        //
-        // Safe unwrap because in a Revert event we're sure the subgraph has
-        // advanced at least once.
-        let subgraph_ptr = self.inputs.store.block_ptr().unwrap();
-        if revert_to_ptr.number >= subgraph_ptr.number {
-            info!(&self.logger, "Block to revert is higher than subgraph pointer, nothing to do"; "subgraph_ptr" => &subgraph_ptr, "revert_to_ptr" => &revert_to_ptr);
-            return Ok(Action::Continue);
-        }
-
-        info!(&self.logger, "Reverting block to get back to main chain"; "subgraph_ptr" => &subgraph_ptr, "revert_to_ptr" => &revert_to_ptr);
-
-        if let Err(e) = self
-            .inputs
-            .store
-            .revert_block_operations(revert_to_ptr.clone(), cursor)
-            .await
-        {
-            error!(&self.logger, "Could not revert block. Retrying"; "error" => %e);
-
-            // Exit inner block stream consumption loop and go up to loop that restarts subgraph
-            return Ok(Action::Restart);
-        }
-
-        self.metrics
-            .stream
-            .reverted_blocks
-            .set(subgraph_ptr.number as f64);
-        self.metrics
-            .stream
-            .deployment_head
-            .set(subgraph_ptr.number as f64);
-
-        self.revert_state_to(revert_to_ptr.number)?;
-
-        let needs_restart: bool = self.needs_restart(revert_to_ptr, subgraph_ptr);
-
-        let action = if needs_restart {
-            Action::Restart
-        } else {
-            Action::Continue
-        };
-
-        Ok(action)
-    }
-
-    async fn handle_err(
-        &mut self,
-        err: CancelableError<Error>,
-        cancel_handle: &CancelHandle,
-    ) -> Result<Action, Error> {
-        if cancel_handle.is_canceled() {
-            debug!(&self.logger, "Subgraph block stream shut down cleanly");
-            return Ok(Action::Stop);
-        }
-
-        debug!(
-            &self.logger,
-            "Block stream produced a non-fatal error";
-            "error" => format!("{}", err),
-        );
-
-        Ok(Action::Continue)
-    }
-
-    /// Determines if the subgraph needs to be restarted.
-    /// Currently returns true when there are data sources that have reached their end block
-    /// in the range between `revert_to_ptr` and `subgraph_ptr`.
-    fn needs_restart(&self, revert_to_ptr: BlockPtr, subgraph_ptr: BlockPtr) -> bool {
-        self.inputs
-            .end_blocks
-            .range(revert_to_ptr.number..=subgraph_ptr.number)
-            .next()
-            .is_some()
-    }
-}
-
-/// Transform the proof of indexing changes into entity updates that will be
-/// inserted when as_modifications is called.
-async fn update_proof_of_indexing(
-    proof_of_indexing: ProofOfIndexing,
-    block_time: BlockTime,
-    stopwatch: &StopwatchMetrics,
-    entity_cache: &mut EntityCache,
-) -> Result<(), Error> {
-    // Helper to store the digest as a PoI entity in the cache
-    fn store_poi_entity(
-        entity_cache: &mut EntityCache,
-        key: EntityKey,
-        digest: Bytes,
-        block_time: BlockTime,
-    ) -> Result<(), Error> {
-        let digest_name = entity_cache.schema.poi_digest();
-        let mut data = vec![
-            (
-                graph::data::store::ID.clone(),
-                Value::from(key.entity_id.to_string()),
-            ),
-            (digest_name, Value::from(digest)),
-        ];
-        if entity_cache.schema.has_aggregations() {
-            let block_time = Value::Int8(block_time.as_secs_since_epoch() as i64);
-            data.push((entity_cache.schema.poi_block_time(), block_time));
-        }
-        let poi = entity_cache.make_entity(data)?;
-        entity_cache.set(key, poi)
-    }
-
-    let _section_guard = stopwatch.start_section("update_proof_of_indexing");
-
-    let mut proof_of_indexing = proof_of_indexing.take();
-
-    for (causality_region, stream) in proof_of_indexing.drain() {
-        // Create the special POI entity key specific to this causality_region
-        // There are two things called causality regions here, one is the causality region for
-        // the poi which is a string and the PoI entity id. The other is the data source
-        // causality region to which the PoI belongs as an entity. Currently offchain events do
-        // not affect PoI so it is assumed to be `ONCHAIN`.
-        // See also: poi-ignores-offchain
-        let entity_key = entity_cache
-            .schema
-            .poi_type()
-            .key_in(causality_region, CausalityRegion::ONCHAIN);
-
-        // Grab the current digest attribute on this entity
-        let poi_digest = entity_cache.schema.poi_digest().clone();
-        let prev_poi = entity_cache
-            .get(&entity_key, GetScope::Store)
-            .map_err(Error::from)?
-            .map(|entity| match entity.get(poi_digest.as_str()) {
-                Some(Value::Bytes(b)) => b.clone(),
-                _ => panic!("Expected POI entity to have a digest and for it to be bytes"),
-            });
-
-        // Finish the POI stream, getting the new POI value.
-        let updated_proof_of_indexing = stream.pause(prev_poi.as_deref());
-        let updated_proof_of_indexing: Bytes = (&updated_proof_of_indexing[..]).into();
-
-        // Put this onto an entity with the same digest attribute
-        // that was expected before when reading.
-        store_poi_entity(
-            entity_cache,
-            entity_key,
-            updated_proof_of_indexing,
-            block_time,
-        )?;
-    }
-
-    Ok(())
-}
-
-/// Checks if the Deployment BlockPtr is at least X blocks behind to the chain head.
-fn close_to_chain_head(
-    deployment_head_ptr: &BlockPtr,
-    chain_head_ptr: Option<BlockPtr>,
-    n: BlockNumber,
-) -> bool {
-    matches!((deployment_head_ptr, &chain_head_ptr), (b1, Some(b2)) if b1.number >= (b2.number - n))
-}
-
-#[test]
-fn test_close_to_chain_head() {
-    let offset = 1;
-
-    let block_0 = BlockPtr::try_from((
-        "bd34884280958002c51d3f7b5f853e6febeba33de0f40d15b0363006533c924f",
-        0,
-    ))
-    .unwrap();
-    let block_1 = BlockPtr::try_from((
-        "8511fa04b64657581e3f00e14543c1d522d5d7e771b54aa3060b662ade47da13",
-        1,
-    ))
-    .unwrap();
-    let block_2 = BlockPtr::try_from((
-        "b98fb783b49de5652097a989414c767824dff7e7fd765a63b493772511db81c1",
-        2,
-    ))
-    .unwrap();
-
-    assert!(!close_to_chain_head(&block_0, None, offset));
-    assert!(!close_to_chain_head(&block_2, None, offset));
-
-    assert!(!close_to_chain_head(
-        &block_0,
-        Some(block_2.clone()),
-        offset
-    ));
-
-    assert!(close_to_chain_head(&block_1, Some(block_2.clone()), offset));
-    assert!(close_to_chain_head(&block_2, Some(block_2.clone()), offset));
-}
diff --git a/core/src/subgraph/runner/mod.rs b/core/src/subgraph/runner/mod.rs
new file mode 100644
index 00000000000..026be3dfc27
--- /dev/null
+++ b/core/src/subgraph/runner/mod.rs
@@ -0,0 +1,1822 @@
+mod state;
+mod trigger_runner;
+
+use crate::subgraph::context::IndexingContext;
+use crate::subgraph::error::{
+    ClassifyErrorHelper as _, DetailHelper as _, NonDeterministicErrorHelper as _, ProcessingError,
+    ProcessingErrorKind,
+};
+use crate::subgraph::inputs::IndexingInputs;
+use crate::subgraph::state::IndexingState;
+use crate::subgraph::stream::new_block_stream;
+use anyhow::Context as _;
+use graph::blockchain::block_stream::{
+    BlockStream, BlockStreamEvent, BlockWithTriggers, FirehoseCursor,
+};
+use graph::blockchain::{
+    Block, BlockTime, Blockchain, DataSource as _, SubgraphFilter, Trigger, TriggerFilter as _,
+    TriggerFilterWrapper,
+};
+use graph::components::store::{
+    EmptyStore, GetScope, ReadStore, SeqGenerator, StoredDynamicDataSource,
+};
+use graph::components::subgraph::InstanceDSTemplate;
+use graph::components::trigger_processor::RunnableTriggers;
+use graph::components::{
+    store::ModificationsAndCache,
+    subgraph::{MappingError, PoICausalityRegion, ProofOfIndexing, SharedProofOfIndexing},
+};
+use graph::data::store::scalar::Bytes;
+use graph::data::subgraph::schema::SubgraphError;
+use graph::data_source::{
+    CausalityRegion, DataSource, DataSourceCreationError, TriggerData, offchain,
+};
+use graph::env::EnvVars;
+use graph::ext::futures::Cancelable;
+use graph::futures03::stream::StreamExt;
+use graph::prelude::{
+    BlockNumber, BlockPtr, BlockState, CancelGuard, CancelHandle, CancelToken as _,
+    CheapClone as _, ENV_VARS, EntityCache, EntityModification, Error, InstanceDSTemplateInfo,
+    LogCode, RunnerMetrics, RuntimeHostBuilder, StopwatchMetrics, StoreError, StreamExtension,
+    UnfailOutcome, Value, anyhow, hex, retry, thiserror,
+};
+use graph::schema::EntityKey;
+use graph::slog::{Logger, debug, error, info, o, trace, warn};
+use graph::util::lfu_cache::EvictStats;
+use graph::util::{backoff::ExponentialBackoff, lfu_cache::LfuCache};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use std::vec;
+
+use self::state::{RestartReason, RunnerState, StopReason};
+use self::trigger_runner::TriggerRunner;
+
+const MINUTE: Duration = Duration::from_secs(60);
+
+const SKIP_PTR_UPDATES_THRESHOLD: Duration = Duration::from_secs(60 * 5);
+const HANDLE_REVERT_SECTION_NAME: &str = "handle_revert";
+const PROCESS_BLOCK_SECTION_NAME: &str = "process_block";
+const PROCESS_TRIGGERS_SECTION_NAME: &str = "process_triggers";
+const HANDLE_CREATED_DS_SECTION_NAME: &str = "handle_new_data_sources";
+
+pub struct SubgraphRunner<C, T>
+where
+    C: Blockchain,
+    T: RuntimeHostBuilder<C>,
+{
+    ctx: IndexingContext<C, T>,
+    state: IndexingState,
+    inputs: Arc<IndexingInputs<C>>,
+    logger: Logger,
+    pub metrics: RunnerMetrics,
+    cancel_handle: Option<CancelHandle>,
+    /// The current state in the runner's state machine.
+    /// This field drives the main loop of the runner.
+    runner_state: RunnerState<C>,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum SubgraphRunnerError {
+    #[error("subgraph runner terminated because a newer one was active")]
+    Duplicate,
+
+    #[error(transparent)]
+    Unknown(#[from] Error),
+}
+
+impl<C, T> SubgraphRunner<C, T>
+where
+    C: Blockchain,
+    T: RuntimeHostBuilder<C>,
+{
+    pub fn new(
+        inputs: IndexingInputs<C>,
+        ctx: IndexingContext<C, T>,
+        logger: Logger,
+        metrics: RunnerMetrics,
+        env_vars: Arc<EnvVars>,
+    ) -> Self {
+        Self {
+            inputs: Arc::new(inputs),
+            ctx,
+            state: IndexingState {
+                should_try_unfail_non_deterministic: true,
+                skip_ptr_updates_timer: Instant::now(),
+                backoff: ExponentialBackoff::with_jitter(
+                    (MINUTE * 2).min(env_vars.subgraph_error_retry_ceil),
+                    env_vars.subgraph_error_retry_ceil,
+                    env_vars.subgraph_error_retry_jitter,
+                ),
+                entity_lfu_cache: LfuCache::new(),
+                cached_head_ptr: None,
+                postponed_indexes_created: false,
+            },
+            logger,
+            metrics,
+            cancel_handle: None,
+            runner_state: RunnerState::Initializing,
+        }
+    }
+
+    /// Revert the state to a previous block. When handling revert operations
+    /// or failed block processing, it is necessary to remove part of the existing
+    /// in-memory state to keep it constent with DB changes.
+    /// During block processing new dynamic data sources are added directly to the
+    /// IndexingContext of the runner. This means that if, for whatever reason,
+    /// the changes don;t complete then the remnants of that block processing must
+    /// be removed. The same thing also applies to the block cache.
+    /// This function must be called before continuing to process in order to avoid
+    /// duplicated host insertion and POI issues with dirty entity changes.
+    fn revert_state_to(&mut self, block_number: BlockNumber) {
+        self.state.entity_lfu_cache = LfuCache::new();
+
+        // 1. Revert all hosts(created by DDS) at a block higher than `block_number`.
+        // 2. Unmark any offchain data sources that were marked done on the blocks being removed.
+        // When no offchain datasources are present, 2. should be a noop.
+        self.ctx.revert_data_sources(block_number + 1);
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn context(&self) -> &IndexingContext<C, T> {
+        &self.ctx
+    }
+
+    #[cfg(debug_assertions)]
+    pub async fn run_for_test(self, break_on_restart: bool) -> Result<Self, Error> {
+        self.run_inner(break_on_restart).await.map_err(Into::into)
+    }
+
+    fn is_static_filters_enabled(&self) -> bool {
+        self.inputs.static_filters || self.ctx.hosts_len() > ENV_VARS.static_filters_threshold
+    }
+
+    fn build_filter(&self) -> TriggerFilterWrapper<C> {
+        let current_ptr = self.inputs.store.block_ptr();
+        let static_filters = self.is_static_filters_enabled();
+
+        // Filter out data sources that have reached their end block
+        let end_block_filter = |ds: &&C::DataSource| match current_ptr.as_ref() {
+            // We filter out datasources for which the current block is at or past their end block.
+            Some(block) => ds.end_block().is_none_or(|end| block.number < end),
+            // If there is no current block, we keep all datasources.
+            None => true,
+        };
+
+        let data_sources = self.ctx.static_data_sources();
+
+        let subgraph_filter = data_sources
+            .iter()
+            .filter_map(|ds| ds.as_subgraph())
+            .map(|ds| SubgraphFilter {
+                subgraph: ds.source.address(),
+                start_block: ds.source.start_block,
+                entities: ds
+                    .mapping
+                    .handlers
+                    .iter()
+                    .map(|handler| handler.entity.clone())
+                    .collect(),
+                manifest_idx: ds.manifest_idx,
+            })
+            .collect::<Vec<_>>();
+
+        // if static_filters is not enabled we just stick to the filter based on all the data sources.
+        if !static_filters {
+            return TriggerFilterWrapper::new(
+                C::TriggerFilter::from_data_sources(
+                    self.ctx.onchain_data_sources().filter(end_block_filter),
+                ),
+                subgraph_filter,
+            );
+        }
+
+        // if static_filters is enabled, build a minimal filter with the static data sources and
+        // add the necessary filters based on templates.
+        // This specifically removes dynamic data sources based filters because these can be derived
+        // from templates AND this reduces the cost of egress traffic by making the payloads smaller.
+
+        if !self.inputs.static_filters {
+            info!(self.logger, "forcing subgraph to use static filters.")
+        }
+
+        let data_sources = self.ctx.static_data_sources();
+
+        let mut filter = C::TriggerFilter::from_data_sources(
+            data_sources
+                .iter()
+                .filter_map(|ds| ds.as_onchain())
+                // Filter out data sources that have reached their end block if the block is final.
+                .filter(end_block_filter),
+        );
+
+        let templates = self.ctx.templates();
+
+        filter.extend_with_template(templates.iter().filter_map(|ds| ds.as_onchain()).cloned());
+
+        TriggerFilterWrapper::new(filter, subgraph_filter)
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn build_filter_for_test(&self) -> TriggerFilterWrapper<C> {
+        self.build_filter()
+    }
+
+    async fn start_block_stream(&mut self) -> Result<Cancelable<Box<dyn BlockStream<C>>>, Error> {
+        let block_stream_canceler = CancelGuard::new();
+        let block_stream_cancel_handle = block_stream_canceler.handle();
+        // TriggerFilter needs to be rebuilt eveytime the blockstream is restarted
+        let filter = self.build_filter();
+
+        let block_stream = new_block_stream(&self.inputs, filter, &self.metrics.subgraph)
+            .await?
+            .cancelable(&block_stream_canceler);
+
+        self.cancel_handle = Some(block_stream_cancel_handle);
+
+        // Keep the stream's cancel guard around to be able to shut it down when the subgraph
+        // deployment is unassigned
+        self.ctx
+            .instances
+            .insert(self.inputs.deployment.id, block_stream_canceler);
+
+        Ok(block_stream)
+    }
+
+    fn is_canceled(&self) -> bool {
+        if let Some(ref cancel_handle) = self.cancel_handle {
+            cancel_handle.is_canceled()
+        } else {
+            false
+        }
+    }
+
+    /// Initialize the runner by performing pre-loop setup.
+    ///
+    /// This method handles:
+    /// - Updating the deployment synced metric
+    /// - Attempting to unfail deterministic errors from the previous run
+    /// - Checking if the subgraph has already reached its max end block
+    ///
+    /// Returns the next state to transition to:
+    /// - `Restarting` to start the block stream (normal case)
+    /// - `Stopped` if the max end block was already reached
+    async fn initialize(&self) -> Result<RunnerState<C>, SubgraphRunnerError> {
+        self.update_deployment_synced_metric();
+
+        // If a subgraph failed for deterministic reasons, before start indexing, we first
+        // revert the deployment head. It should lead to the same result since the error was
+        // deterministic.
+        if let Some(current_ptr) = self.inputs.store.block_ptr() {
+            if let Some(parent_ptr) = self
+                .inputs
+                .triggers_adapter
+                .parent_ptr(&current_ptr)
+                .await?
+            {
+                // This reverts the deployment head to the parent_ptr if
+                // deterministic errors happened.
+                //
+                // There's no point in calling it if we have no current or parent block
+                // pointers, because there would be: no block to revert to or to search
+                // errors from (first execution).
+                //
+                // We attempt to unfail deterministic errors to mitigate deterministic
+                // errors caused by wrong data being consumed from the providers. It has
+                // been a frequent case in the past so this helps recover on a larger scale.
+                let _outcome = self
+                    .inputs
+                    .store
+                    .unfail_deterministic_error(&current_ptr, &parent_ptr)
+                    .await?;
+            }
+
+            // Stop subgraph when we reach maximum endblock.
+            if let Some(max_end_block) = self.inputs.max_end_block
+                && max_end_block <= current_ptr.block_number()
+            {
+                info!(self.logger, "Stopping subgraph as we reached maximum endBlock";
+                                "max_end_block" => max_end_block,
+                                "current_block" => current_ptr.block_number());
+                self.inputs.store.flush().await?;
+                return Ok(RunnerState::Stopped {
+                    reason: StopReason::MaxEndBlockReached,
+                });
+            }
+        }
+
+        // Normal case: proceed to start the block stream
+        Ok(RunnerState::Restarting {
+            reason: RestartReason::StoreError, // Initial start uses the same path as restart
+        })
+    }
+
+    /// Await the next block stream event and transition to the appropriate state.
+    ///
+    /// This method waits for the next event from the block stream and determines
+    /// which state the runner should transition to:
+    /// - `ProcessingBlock` for new blocks to process
+    /// - `Reverting` for revert events
+    /// - `Stopped` when the stream ends or is canceled
+    /// - Returns back to `AwaitingBlock` for non-fatal errors that allow continuation
+    async fn await_block(
+        &mut self,
+        mut block_stream: Cancelable<Box<dyn BlockStream<C>>>,
+    ) -> Result<RunnerState<C>, SubgraphRunnerError> {
+        let event = {
+            let _section = self.metrics.stream.stopwatch.start_section("scan_blocks");
+            block_stream.next().await
+        };
+
+        if self.is_canceled() {
+            return self.cancel();
+        }
+
+        match event {
+            Some(Ok(BlockStreamEvent::ProcessBlock(block, cursor))) => {
+                Ok(RunnerState::ProcessingBlock {
+                    block_stream,
+                    block,
+                    cursor,
+                })
+            }
+            Some(Ok(BlockStreamEvent::Revert(to_ptr, cursor))) => Ok(RunnerState::Reverting {
+                block_stream,
+                to_ptr,
+                cursor,
+            }),
+            // Log and drop the errors from the block_stream
+            // The block stream will continue attempting to produce blocks
+            Some(Err(e)) => {
+                // Log error and continue waiting for blocks
+                debug!(
+                    &self.logger,
+                    "Block stream produced a non-fatal error";
+                    "error" => format!("{}", e),
+                );
+                Ok(RunnerState::AwaitingBlock { block_stream })
+            }
+            // If the block stream ends, that means that there is no more indexing to do.
+            None => Ok(RunnerState::Stopped {
+                reason: StopReason::StreamEnded,
+            }),
+        }
+    }
+
+    fn cancel(&mut self) -> Result<RunnerState<C>, SubgraphRunnerError> {
+        if self.ctx.instances.contains(&self.inputs.deployment.id) {
+            warn!(
+                self.logger,
+                "Terminating the subgraph runner because a newer one is active. \
+                     Possible reassignment detected while the runner was in a non-cancellable pending state",
+            );
+            return Err(SubgraphRunnerError::Duplicate);
+        }
+        warn!(
+            self.logger,
+            "Terminating the subgraph runner because subgraph was unassigned",
+        );
+        Ok(RunnerState::Stopped {
+            reason: StopReason::Unassigned,
+        })
+    }
+
+    /// Construct a SubgraphError and mark the subgraph as failed in the store.
+    async fn fail_subgraph(
+        &mut self,
+        message: String,
+        block_ptr: Option<BlockPtr>,
+        deterministic: bool,
+    ) -> Result<(), SubgraphRunnerError> {
+        let error = SubgraphError {
+            subgraph_id: self.inputs.deployment.hash.clone(),
+            message,
+            block_ptr,
+            handler: None,
+            deterministic,
+        };
+        self.inputs
+            .store
+            .fail_subgraph(error)
+            .await
+            .context("Failed to set subgraph status to `failed`")?;
+        Ok(())
+    }
+
+    /// Handle a restart by potentially restarting the store and starting a new block stream.
+    ///
+    /// This method handles:
+    /// - Restarting the store if there were errors (to clear error state)
+    /// - Reverting state to the last good block if the store was restarted
+    /// - Starting a new block stream with updated filters
+    ///
+    /// Returns the next state to transition to:
+    /// - `AwaitingBlock` with the new block stream (normal case)
+    async fn restart(
+        &mut self,
+        reason: RestartReason,
+    ) -> Result<RunnerState<C>, SubgraphRunnerError> {
+        debug!(self.logger, "Starting or restarting subgraph"; "reason" => ?reason);
+
+        // If restarting due to store error, try to restart the store
+        if matches!(reason, RestartReason::StoreError) {
+            let store = self.inputs.store.cheap_clone();
+            if let Some(store) = store.restart().await? {
+                let last_good_block = store.block_ptr().map(|ptr| ptr.number).unwrap_or(0);
+                self.revert_state_to(last_good_block);
+                self.inputs = Arc::new(self.inputs.with_store(store));
+            }
+        }
+
+        let block_stream = self.start_block_stream().await?;
+
+        debug!(self.logger, "Started block stream");
+        self.metrics.subgraph.deployment_status.running();
+        self.update_deployment_synced_metric();
+
+        Ok(RunnerState::AwaitingBlock { block_stream })
+    }
+
+    /// Finalize the runner when it reaches a terminal state.
+    ///
+    /// This method handles cleanup tasks when the runner stops:
+    /// - Flushing the store to ensure all changes are persisted
+    /// - Logging the stop reason
+    async fn finalize(self, reason: StopReason) -> Result<Self, SubgraphRunnerError> {
+        match reason {
+            StopReason::MaxEndBlockReached => {
+                info!(self.logger, "Stopping subgraph - max end block reached");
+            }
+            StopReason::Canceled => {
+                info!(self.logger, "Stopping subgraph - canceled");
+            }
+            StopReason::Unassigned => {
+                info!(self.logger, "Stopping subgraph - unassigned");
+            }
+            StopReason::StreamEnded => {
+                info!(self.logger, "Stopping subgraph - stream ended");
+            }
+        }
+
+        self.inputs.store.flush().await?;
+        Ok(self)
+    }
+
+    pub async fn run(self) -> Result<(), SubgraphRunnerError> {
+        self.run_inner(false).await.map(|_| ())
+    }
+
+    /// Main state machine loop for the subgraph runner.
+    ///
+    /// This method drives the runner through its state machine, transitioning
+    /// between states based on events and actions. The state machine replaces
+    /// the previous nested loop structure with explicit state transitions.
+    ///
+    /// ## State Machine
+    ///
+    /// The runner starts in `Initializing` and transitions through states:
+    /// - `Initializing` → `Restarting` (or `Stopped` if max end block reached)
+    /// - `Restarting` → `AwaitingBlock`
+    /// - `AwaitingBlock` → `ProcessingBlock`, `Reverting`, or `Stopped`
+    /// - `ProcessingBlock` → `AwaitingBlock` or `Restarting`
+    /// - `Reverting` → `AwaitingBlock` or `Restarting`
+    /// - `Stopped` → terminal (returns)
+    async fn run_inner(mut self, break_on_restart: bool) -> Result<Self, SubgraphRunnerError> {
+        // Start in Initializing state
+        self.runner_state = RunnerState::Initializing;
+
+        // Track whether we've started processing blocks (not just initialized).
+        // This is used for break_on_restart logic - we should only stop on restart
+        // after we've actually started processing, not on the initial "restart"
+        // which is really the first start of the block stream.
+        let mut has_processed_blocks = false;
+
+        loop {
+            self.runner_state = match std::mem::take(&mut self.runner_state) {
+                RunnerState::Initializing => self.initialize().await?,
+
+                RunnerState::Restarting { reason } => {
+                    if break_on_restart && has_processed_blocks {
+                        // In test mode, stop on restart after first block processing
+                        info!(self.logger, "Stopping subgraph on break");
+                        RunnerState::Stopped {
+                            reason: StopReason::Canceled,
+                        }
+                    } else {
+                        self.restart(reason).await?
+                    }
+                }
+
+                RunnerState::AwaitingBlock { block_stream } => {
+                    self.await_block(block_stream).await?
+                }
+
+                RunnerState::ProcessingBlock {
+                    block_stream,
+                    block,
+                    cursor,
+                } => {
+                    has_processed_blocks = true;
+                    self.process_block_state(block_stream, block, cursor)
+                        .await?
+                }
+
+                RunnerState::Reverting {
+                    block_stream,
+                    to_ptr,
+                    cursor,
+                } => self.handle_revert_state(block_stream, to_ptr, cursor).await,
+
+                RunnerState::Stopped { reason } => {
+                    return self.finalize(reason).await;
+                }
+            };
+        }
+    }
+
+    /// Process a block and determine the next state.
+    ///
+    /// This is the state machine wrapper around `process_block` that handles
+    /// the block processing action and determines state transitions.
+    async fn process_block_state(
+        &mut self,
+        block_stream: Cancelable<Box<dyn BlockStream<C>>>,
+        block: BlockWithTriggers<C>,
+        cursor: FirehoseCursor,
+    ) -> Result<RunnerState<C>, SubgraphRunnerError> {
+        let block_ptr = block.ptr();
+        self.metrics
+            .stream
+            .deployment_head
+            .set(block_ptr.number as f64);
+
+        if block.trigger_count() > 0 {
+            self.metrics
+                .subgraph
+                .block_trigger_count
+                .observe(block.trigger_count() as f64);
+        }
+
+        // Check if we should skip this block (optimization for blocks without triggers).
+        // Do not skip if max_end_block has been reached — fall through to process_block so the
+        // block pointer is persisted and the existing max_end_block check in handle_action fires.
+        let max_end_block_reached = self
+            .inputs
+            .max_end_block
+            .is_some_and(|max| block_ptr.number >= max);
+        if block.trigger_count() == 0
+            && self.state.skip_ptr_updates_timer.elapsed() <= SKIP_PTR_UPDATES_THRESHOLD
+            && !self.inputs.store.is_deployment_synced()
+            && !close_to_chain_head(&block_ptr, &self.inputs.chain.chain_head_ptr().await?, 1000)
+            && !max_end_block_reached
+        {
+            // Skip this block and continue with the same stream
+            return Ok(RunnerState::AwaitingBlock { block_stream });
+        } else {
+            self.state.skip_ptr_updates_timer = Instant::now();
+        }
+
+        let block_start = Instant::now();
+
+        let action = {
+            let stopwatch = &self.metrics.stream.stopwatch;
+            let _section = stopwatch.start_section(PROCESS_BLOCK_SECTION_NAME);
+            self.process_block(block, cursor).await
+        };
+
+        let action = self.handle_action(block_start, block_ptr, action).await?;
+
+        self.update_deployment_synced_metric();
+
+        if self.is_canceled() {
+            return self.cancel();
+        }
+
+        self.metrics
+            .subgraph
+            .observe_block_processed(block_start.elapsed(), action.block_finished());
+
+        // Convert Action to RunnerState
+        match action {
+            Action::Continue => Ok(RunnerState::AwaitingBlock { block_stream }),
+            Action::Restart => Ok(RunnerState::Restarting {
+                reason: RestartReason::DynamicDataSourceCreated,
+            }),
+            Action::Stop => Ok(RunnerState::Stopped {
+                reason: StopReason::MaxEndBlockReached,
+            }),
+        }
+    }
+
+    /// Handle a revert event and determine the next state.
+    ///
+    /// This is the state machine wrapper around `handle_revert` that handles
+    /// the revert action and determines state transitions.
+    async fn handle_revert_state(
+        &mut self,
+        block_stream: Cancelable<Box<dyn BlockStream<C>>>,
+        revert_to_ptr: BlockPtr,
+        cursor: FirehoseCursor,
+    ) -> RunnerState<C> {
+        let stopwatch = &self.metrics.stream.stopwatch;
+        let _section = stopwatch.start_section(HANDLE_REVERT_SECTION_NAME);
+
+        let action = self.handle_revert(revert_to_ptr, cursor).await;
+
+        match action {
+            Action::Continue => RunnerState::AwaitingBlock { block_stream },
+            Action::Restart => RunnerState::Restarting {
+                reason: RestartReason::StoreError,
+            },
+            Action::Stop => RunnerState::Stopped {
+                reason: StopReason::Canceled,
+            },
+        }
+    }
+
+    async fn transact_block_state(
+        &mut self,
+        logger: &Logger,
+        block_ptr: BlockPtr,
+        firehose_cursor: FirehoseCursor,
+        block_time: BlockTime,
+        block_state: BlockState,
+        proof_of_indexing: SharedProofOfIndexing,
+        offchain_mods: Vec<EntityModification>,
+        processed_offchain_data_sources: Vec<StoredDynamicDataSource>,
+    ) -> Result<(), ProcessingError> {
+        fn log_evict_stats(logger: &Logger, evict_stats: &EvictStats) {
+            trace!(logger, "Entity cache statistics";
+                "weight" => evict_stats.new_weight,
+                "evicted_weight" => evict_stats.evicted_weight,
+                "count" => evict_stats.new_count,
+                "evicted_count" => evict_stats.evicted_count,
+                "stale_update" => evict_stats.stale_update,
+                "hit_rate" => format!("{:.0}%", evict_stats.hit_rate_pct()),
+                "accesses" => evict_stats.accesses,
+                "evict_time_ms" => evict_stats.evict_time.as_millis());
+        }
+
+        let BlockState {
+            deterministic_errors,
+            persisted_data_sources,
+            metrics: block_state_metrics,
+            mut entity_cache,
+            ..
+        } = block_state;
+        let first_error = deterministic_errors.first().cloned();
+        let has_errors = first_error.is_some();
+
+        // Avoid writing to store if block stream has been canceled
+        if self.is_canceled() {
+            return Err(ProcessingError::Canceled);
+        }
+
+        if let Some(proof_of_indexing) = proof_of_indexing.into_inner() {
+            update_proof_of_indexing(
+                proof_of_indexing,
+                block_time,
+                &self.metrics.host.stopwatch,
+                &mut entity_cache,
+            )
+            .await
+            .non_deterministic()?;
+        }
+
+        let section = self
+            .metrics
+            .host
+            .stopwatch
+            .start_section("as_modifications");
+        let ModificationsAndCache {
+            modifications: mut mods,
+            entity_lfu_cache: cache,
+            evict_stats,
+        } = entity_cache
+            .as_modifications(block_ptr.number, &self.metrics.host.stopwatch)
+            .await
+            .classify()?;
+        section.end();
+
+        log_evict_stats(&self.logger, &evict_stats);
+
+        mods.extend(offchain_mods);
+
+        // Put the cache back in the state, asserting that the placeholder cache was not used.
+        assert!(self.state.entity_lfu_cache.is_empty());
+        self.state.entity_lfu_cache = cache;
+
+        if !mods.is_empty() {
+            info!(&logger, "Applying {} entity operation(s)", mods.len());
+        }
+
+        let err_count = deterministic_errors.len();
+        for (i, e) in deterministic_errors.iter().enumerate() {
+            let message = format!("{:#}", e).replace('\n', "\t");
+            error!(&logger, "Subgraph error {}/{}", i + 1, err_count;
+                "error" => message,
+                "code" => LogCode::SubgraphSyncingFailure
+            );
+        }
+
+        // Transact entity operations into the store and update the
+        // subgraph's block stream pointer
+        let _section = self.metrics.host.stopwatch.start_section("transact_block");
+        let start = Instant::now();
+
+        // If a deterministic error has happened, make the PoI to be the only entity that'll be stored.
+        if has_errors && self.inputs.errors_are_fatal() {
+            let is_poi_entity =
+                |entity_mod: &EntityModification| entity_mod.key().entity_type.is_poi();
+            mods.retain(is_poi_entity);
+            // Confidence check
+            assert!(
+                mods.len() == 1,
+                "There should be only one PoI EntityModification"
+            );
+        }
+
+        let is_caught_up = self.is_caught_up(&block_ptr).await.non_deterministic()?;
+
+        if !self.state.postponed_indexes_created
+            && close_to_chain_head(
+                &block_ptr,
+                &self.state.cached_head_ptr,
+                ENV_VARS.postpone_indexes_creation_threshold,
+            )
+        {
+            self.state.postponed_indexes_created = true;
+            self.inputs
+                .store
+                .create_postponed_indexes()
+                .await
+                .non_deterministic()?;
+        }
+
+        self.inputs
+            .store
+            .transact_block_operations(
+                block_ptr.clone(),
+                block_time,
+                firehose_cursor,
+                mods,
+                &self.metrics.host.stopwatch,
+                persisted_data_sources,
+                deterministic_errors,
+                processed_offchain_data_sources,
+                self.inputs.errors_are_non_fatal(),
+                is_caught_up,
+            )
+            .await
+            .classify()
+            .detail("Failed to transact block operations")?;
+
+        // For subgraphs with `nonFatalErrors` feature disabled, we consider
+        // any error as fatal.
+        //
+        // So we do an early return to make the subgraph stop processing blocks.
+        //
+        // In this scenario the only entity that is stored/transacted is the PoI,
+        // all of the others are discarded.
+        if has_errors && self.inputs.errors_are_fatal() {
+            if let Err(e) = self.inputs.store.flush().await {
+                error!(logger, "Failed to flush store after fatal errors"; "error" => format!("{:#}", e));
+            }
+            // Only the first error is reported.
+            return Err(ProcessingError::Deterministic(Box::new(
+                first_error.unwrap(),
+            )));
+        }
+
+        let elapsed = start.elapsed().as_secs_f64();
+        self.metrics
+            .subgraph
+            .block_ops_transaction_duration
+            .observe(elapsed);
+
+        block_state_metrics
+            .flush_metrics_to_store(logger, block_ptr, self.inputs.deployment.id)
+            .non_deterministic()?;
+
+        if has_errors {
+            self.maybe_cancel().await?;
+        }
+
+        Ok(())
+    }
+
+    /// Cancel the subgraph if `disable_fail_fast` is not set and it is not
+    /// synced
+    async fn maybe_cancel(&self) -> Result<(), ProcessingError> {
+        // To prevent a buggy pending version from replacing a current version, if errors are
+        // present the subgraph will be unassigned.
+        let store = &self.inputs.store;
+        if !ENV_VARS.disable_fail_fast && !store.is_deployment_synced() {
+            store
+                .pause_subgraph()
+                .await
+                .map_err(|e| ProcessingError::Unknown(e.into()))?;
+
+            // Use `Canceled` to avoiding setting the subgraph health to failed, an error was
+            // just transacted so it will be already be set to unhealthy.
+            Err(ProcessingError::Canceled)
+        } else {
+            Ok(())
+        }
+    }
+
+    async fn match_and_decode_many<'a, F>(
+        &'a self,
+        logger: &Logger,
+        block: &Arc<C::Block>,
+        triggers: Vec<Trigger<C>>,
+        hosts_filter: F,
+    ) -> Result<Vec<RunnableTriggers<'a, C>>, MappingError>
+    where
+        F: Fn(&TriggerData<C>) -> Box<dyn Iterator<Item = &'a T::Host> + Send + 'a>,
+    {
+        let triggers = triggers.into_iter().map(|t| match t {
+            Trigger::Chain(t) => TriggerData::Onchain(t),
+            Trigger::Subgraph(t) => TriggerData::Subgraph(t),
+        });
+
+        self.ctx
+            .decoder
+            .match_and_decode_many(
+                logger,
+                block,
+                triggers,
+                hosts_filter,
+                &self.metrics.subgraph,
+            )
+            .await
+    }
+
+    // =========================================================================
+    // Pipeline Stage Methods
+    // =========================================================================
+    //
+    // The following methods implement the block processing pipeline stages.
+    // Each stage handles a specific phase of block processing:
+    //
+    // 1. match_triggers: Match and decode triggers against hosts
+    // 2. execute_triggers: Execute the matched triggers
+    // 3. process_dynamic_data_sources: Handle dynamically created data sources
+    // 4. (process_offchain_triggers): Existing handle_offchain_triggers method
+    // 5. (persist_block_state): Existing transact_block_state method
+    //
+    // =========================================================================
+
+    /// Pipeline Stage 1: Match triggers to hosts and decode them.
+    ///
+    /// Takes raw triggers from a block and matches them against all registered
+    /// hosts, returning runnable triggers ready for execution.
+    async fn match_triggers<'a>(
+        &'a self,
+        logger: &Logger,
+        block: &Arc<C::Block>,
+        triggers: Vec<Trigger<C>>,
+    ) -> Result<Vec<RunnableTriggers<'a, C>>, MappingError> {
+        let hosts_filter = |trigger: &TriggerData<C>| self.ctx.instance.hosts_for_trigger(trigger);
+        self.match_and_decode_many(logger, block, triggers, hosts_filter)
+            .await
+    }
+
+    /// Pipeline Stage 2: Execute matched triggers.
+    ///
+    /// Takes runnable triggers and executes them using the TriggerRunner,
+    /// accumulating state changes in the block state.
+    async fn execute_triggers(
+        &self,
+        block: &Arc<C::Block>,
+        runnables: Vec<RunnableTriggers<'_, C>>,
+        block_state: BlockState,
+        proof_of_indexing: &SharedProofOfIndexing,
+        causality_region: &str,
+    ) -> Result<BlockState, MappingError> {
+        let trigger_runner = TriggerRunner::new(
+            self.ctx.trigger_processor.as_ref(),
+            &self.logger,
+            &self.metrics.subgraph,
+            &self.inputs.debug_fork,
+            self.inputs.instrument,
+        );
+        trigger_runner
+            .execute(
+                block,
+                runnables,
+                block_state,
+                proof_of_indexing,
+                causality_region,
+            )
+            .await
+    }
+
+    /// Pipeline Stage 3: Process dynamically created data sources.
+    ///
+    /// This loop processes data sources created during trigger execution:
+    /// 1. Instantiate the created data sources
+    /// 2. Reprocess triggers from this block that match the new data sources
+    /// 3. Repeat until no more data sources are created
+    ///
+    /// Note: This algorithm processes data sources spawned on the same block
+    /// _breadth first_ on the tree implied by the parent-child relationship
+    /// between data sources.
+    async fn process_dynamic_data_sources(
+        &mut self,
+        logger: &Logger,
+        block: &Arc<C::Block>,
+        firehose_cursor: &FirehoseCursor,
+        mut block_state: BlockState,
+        proof_of_indexing: &SharedProofOfIndexing,
+        causality_region: &str,
+    ) -> Result<BlockState, ProcessingError> {
+        fn log_triggers_found<C: Blockchain>(logger: &Logger, triggers: &[Trigger<C>]) {
+            if triggers.len() == 1 {
+                info!(logger, "1 trigger found in this block");
+            } else if triggers.len() > 1 {
+                info!(logger, "{} triggers found in this block", triggers.len());
+            }
+        }
+
+        let _section = self
+            .metrics
+            .stream
+            .stopwatch
+            .start_section(HANDLE_CREATED_DS_SECTION_NAME);
+
+        while block_state.has_created_data_sources() {
+            // Instantiate dynamic data sources, removing them from the block state.
+            let (data_sources, runtime_hosts) =
+                self.create_dynamic_data_sources(block_state.drain_created_data_sources())?;
+
+            let filter = &Arc::new(TriggerFilterWrapper::new(
+                C::TriggerFilter::from_data_sources(
+                    data_sources.iter().filter_map(DataSource::as_onchain),
+                ),
+                vec![],
+            ));
+
+            // TODO: We have to pass a reference to `block` to
+            // `refetch_block`, otherwise the call to
+            // handle_offchain_triggers below gets an error that `block`
+            // has moved. That is extremely fishy since it means that
+            // `handle_offchain_triggers` uses the non-refetched block
+            //
+            // It's also not clear why refetching needs to happen inside
+            // the loop; will firehose really return something diffrent
+            // each time even though the cursor doesn't change?
+            let block = self.refetch_block(logger, block, firehose_cursor).await?;
+
+            // Reprocess the triggers from this block that match the new data sources
+            let block_with_triggers = self
+                .inputs
+                .triggers_adapter
+                .triggers_in_block(logger, block.as_ref().clone(), filter)
+                .await
+                .non_deterministic()?;
+
+            let triggers = block_with_triggers.trigger_data;
+            log_triggers_found::<C>(logger, &triggers);
+
+            // Add entity operations for the new data sources to the block state
+            // and add runtimes for the data sources to the subgraph instance.
+            self.persist_dynamic_data_sources(&mut block_state, data_sources);
+
+            // Process the triggers in each host in the same order the
+            // corresponding data sources have been created.
+            let hosts_filter = |_: &'_ TriggerData<C>| -> Box<dyn Iterator<Item = _> + Send> {
+                Box::new(runtime_hosts.iter().map(Arc::as_ref))
+            };
+            let runnables = self
+                .match_and_decode_many(logger, &block, triggers, hosts_filter)
+                .await;
+
+            let trigger_runner = TriggerRunner::new(
+                self.ctx.trigger_processor.as_ref(),
+                &self.logger,
+                &self.metrics.subgraph,
+                &self.inputs.debug_fork,
+                self.inputs.instrument,
+            );
+            let res = match runnables {
+                Ok(runnables) => {
+                    trigger_runner
+                        .execute(
+                            &block,
+                            runnables,
+                            block_state,
+                            proof_of_indexing,
+                            causality_region,
+                        )
+                        .await
+                }
+                Err(e) => Err(e),
+            };
+
+            block_state = res.map_err(|e| {
+                // This treats a `PossibleReorg` as an ordinary error which will fail the subgraph.
+                // This can cause an unnecessary subgraph failure, to fix it we need to figure out a
+                // way to revert the effect of `create_dynamic_data_sources` so we may return a
+                // clean context as in b21fa73b-6453-4340-99fb-1a78ec62efb1.
+                match e {
+                    MappingError::PossibleReorg(e) | MappingError::Unknown(e) => {
+                        ProcessingError::Unknown(e)
+                    }
+                }
+            })?;
+        }
+
+        Ok(block_state)
+    }
+
+    /// Pipeline Stage 4: Process offchain triggers.
+    ///
+    /// Retrieves ready offchain events and processes them, returning entity
+    /// modifications and processed data sources to be included in the transaction.
+    async fn process_offchain_triggers(
+        &mut self,
+        block: &Arc<C::Block>,
+        block_state: &mut BlockState,
+    ) -> Result<(Vec<EntityModification>, Vec<StoredDynamicDataSource>), ProcessingError> {
+        let offchain_events = self
+            .ctx
+            .offchain_monitor
+            .ready_offchain_events()
+            .non_deterministic()?;
+
+        let vid_gen = block_state.seq_gen();
+        let (offchain_mods, processed_offchain_data_sources, persisted_off_chain_data_sources) =
+            self.handle_offchain_triggers(offchain_events, block, vid_gen)
+                .await
+                .non_deterministic()?;
+
+        block_state
+            .persisted_data_sources
+            .extend(persisted_off_chain_data_sources);
+
+        Ok((offchain_mods, processed_offchain_data_sources))
+    }
+
+    /// Processes a block and returns the updated context and a boolean flag indicating
+    /// whether new dynamic data sources have been added to the subgraph.
+    ///
+    /// ## Pipeline Stages
+    ///
+    /// Block processing follows a pipeline of stages:
+    /// 1. **match_triggers**: Match and decode triggers against hosts
+    /// 2. **execute_triggers**: Execute the matched triggers via TriggerRunner
+    /// 3. **process_dynamic_data_sources**: Handle dynamically created data sources
+    /// 4. **process_offchain_triggers**: Process offchain events
+    /// 5. **persist_block**: Persist block state to the store
+    async fn process_block(
+        &mut self,
+        block: BlockWithTriggers<C>,
+        firehose_cursor: FirehoseCursor,
+    ) -> Result<Action, ProcessingError> {
+        let triggers = block.trigger_data;
+        let block = Arc::new(block.block);
+        let block_ptr = block.ptr();
+
+        let logger = self.logger.new(o!(
+                "block_number" => format!("{:?}", block_ptr.number),
+                "block_hash" => format!("{}", block_ptr.hash)
+        ));
+
+        info!(logger, "Start processing block";
+               "triggers" => triggers.len());
+
+        let proof_of_indexing =
+            SharedProofOfIndexing::new(block_ptr.number, self.inputs.poi_version);
+
+        // Causality region for onchain triggers.
+        let causality_region = PoICausalityRegion::from_network(&self.inputs.network);
+
+        let vid_gen = SeqGenerator::new(block_ptr.number);
+        let mut block_state = BlockState::new(
+            self.inputs.store.clone(),
+            std::mem::take(&mut self.state.entity_lfu_cache),
+            vid_gen,
+        );
+
+        let _section = self
+            .metrics
+            .stream
+            .stopwatch
+            .start_section(PROCESS_TRIGGERS_SECTION_NAME);
+
+        // Stage 1: Match triggers to hosts and decode
+        let runnables = self.match_triggers(&logger, &block, triggers).await;
+
+        // Stage 2: Execute triggers
+        let res = match runnables {
+            Ok(runnables) => {
+                self.execute_triggers(
+                    &block,
+                    runnables,
+                    block_state,
+                    &proof_of_indexing,
+                    &causality_region,
+                )
+                .await
+            }
+            Err(e) => Err(e),
+        };
+
+        match res {
+            // Triggers processed with no errors or with only deterministic errors.
+            Ok(state) => block_state = state,
+
+            // Some form of unknown or non-deterministic error ocurred.
+            Err(MappingError::Unknown(e)) => return Err(ProcessingError::Unknown(e)),
+
+            // Possible blockchain reorg detected - signal restart via ProcessingError::PossibleReorg.
+            // See also b21fa73b-6453-4340-99fb-1a78ec62efb1.
+            Err(MappingError::PossibleReorg(e)) => return Err(ProcessingError::PossibleReorg(e)),
+        }
+
+        // Check if there are any datasources that have expired in this block. ie: the end_block
+        // of that data source is equal to the block number of the current block.
+        let has_expired_data_sources = self.inputs.end_blocks.contains(&block_ptr.number);
+
+        // If new onchain data sources have been created, and static filters are not in use, it is necessary
+        // to restart the block stream with the new filters.
+        let created_data_sources_needs_restart =
+            !self.is_static_filters_enabled() && block_state.has_created_on_chain_data_sources();
+
+        // Determine if the block stream needs to be restarted due to newly created on-chain data sources
+        // or data sources that have reached their end block.
+        let needs_restart = created_data_sources_needs_restart || has_expired_data_sources;
+
+        // Checkpoint before dynamic DS processing for potential rollback scenarios.
+        // This captures the current state so it can be restored if dynamic data source
+        // processing fails in a way that requires partial rollback.
+        let _checkpoint = block_state.checkpoint();
+
+        // Stage 3: Process dynamic data sources
+        block_state = self
+            .process_dynamic_data_sources(
+                &logger,
+                &block,
+                &firehose_cursor,
+                block_state,
+                &proof_of_indexing,
+                &causality_region,
+            )
+            .await?;
+
+        // Stage 4: Process offchain triggers
+        let (offchain_mods, processed_offchain_data_sources) = self
+            .process_offchain_triggers(&block, &mut block_state)
+            .await?;
+
+        // Stage 5: Persist block state
+        self.transact_block_state(
+            &logger,
+            block_ptr,
+            firehose_cursor,
+            block.timestamp(),
+            block_state,
+            proof_of_indexing,
+            offchain_mods,
+            processed_offchain_data_sources,
+        )
+        .await?;
+
+        match needs_restart {
+            true => Ok(Action::Restart),
+            false => Ok(Action::Continue),
+        }
+    }
+
+    /// Refetch the block if it that is needed. Otherwise return the block as is.
+    async fn refetch_block(
+        &mut self,
+        logger: &Logger,
+        block: &Arc<C::Block>,
+        firehose_cursor: &FirehoseCursor,
+    ) -> Result<Arc<C::Block>, ProcessingError> {
+        if !self.inputs.chain.is_refetch_block_required() {
+            return Ok(block.cheap_clone());
+        }
+
+        let cur = firehose_cursor.clone();
+        let log = logger.cheap_clone();
+        let chain = self.inputs.chain.cheap_clone();
+        let block = retry(
+            "refetch firehose block after dynamic datasource was added",
+            logger,
+        )
+        .limit(5)
+        .no_timeout()
+        .run(move || {
+            let cur = cur.clone();
+            let log = log.cheap_clone();
+            let chain = chain.cheap_clone();
+            async move { chain.refetch_firehose_block(&log, cur).await }
+        })
+        .await
+        .non_deterministic()?;
+        Ok(Arc::new(block))
+    }
+
+    fn create_dynamic_data_sources(
+        &mut self,
+        created_data_sources: Vec<InstanceDSTemplateInfo>,
+    ) -> Result<(Vec<DataSource<C>>, Vec<Arc<T::Host>>), ProcessingError> {
+        let mut data_sources = vec![];
+        let mut runtime_hosts = vec![];
+
+        for info in created_data_sources {
+            let manifest_idx = info
+                .template
+                .manifest_idx()
+                .ok_or_else(|| anyhow!("Expected template to have an idx"))
+                .non_deterministic()?;
+            let created_ds_template = self
+                .inputs
+                .templates
+                .iter()
+                .find(|t| t.manifest_idx() == manifest_idx)
+                .ok_or_else(|| anyhow!("Expected to find a template for this dynamic data source"))
+                .non_deterministic()?;
+
+            // Try to instantiate a data source from the template
+            let data_source = {
+                let res = match info.template {
+                    InstanceDSTemplate::Onchain(_) => {
+                        C::DataSource::from_template_info(info, created_ds_template)
+                            .map(DataSource::Onchain)
+                            .map_err(DataSourceCreationError::from)
+                    }
+                    InstanceDSTemplate::Offchain(_) => offchain::DataSource::from_template_info(
+                        info,
+                        self.ctx.causality_region_next_value(),
+                    )
+                    .map(DataSource::Offchain),
+                };
+                match res {
+                    Ok(ds) => ds,
+                    Err(e @ DataSourceCreationError::Ignore(..)) => {
+                        warn!(self.logger, "{}", e.to_string());
+                        continue;
+                    }
+                    Err(DataSourceCreationError::Unknown(e)) => return Err(e).non_deterministic(),
+                }
+            };
+
+            // Try to create a runtime host for the data source
+            let host = self
+                .ctx
+                .add_dynamic_data_source(&self.logger, data_source.clone())
+                .non_deterministic()?;
+
+            match host {
+                Some(host) => {
+                    data_sources.push(data_source);
+                    runtime_hosts.push(host);
+                }
+                None => {
+                    warn!(
+                        self.logger,
+                        "no runtime host created, there is already a runtime host instantiated for \
+                        this data source";
+                        "name" => &data_source.name(),
+                        "address" => &data_source.address()
+                        .map(hex::encode)
+                        .unwrap_or("none".to_string()),
+                    )
+                }
+            }
+        }
+
+        Ok((data_sources, runtime_hosts))
+    }
+
+    async fn handle_action(
+        &mut self,
+        start: Instant,
+        block_ptr: BlockPtr,
+        action: Result<Action, ProcessingError>,
+    ) -> Result<Action, Error> {
+        self.state.skip_ptr_updates_timer = Instant::now();
+
+        let elapsed = start.elapsed().as_secs_f64();
+        self.metrics
+            .subgraph
+            .block_processing_duration
+            .observe(elapsed);
+
+        match action {
+            Ok(action) => {
+                // Keep trying to unfail subgraph for everytime it advances block(s) until it's
+                // health is not Failed anymore.
+                if self.state.should_try_unfail_non_deterministic {
+                    // If the deployment head advanced, we can unfail
+                    // the non-deterministic error (if there's any).
+                    let outcome = self
+                        .inputs
+                        .store
+                        .unfail_non_deterministic_error(&block_ptr)
+                        .await?;
+
+                    // Stop trying unless we're still behind the error block.
+                    if outcome != UnfailOutcome::BehindErrorBlock {
+                        self.state.should_try_unfail_non_deterministic = false;
+
+                        if outcome == UnfailOutcome::Unfailed {
+                            self.metrics.subgraph.deployment_status.running();
+                            self.state.backoff.reset();
+                        }
+                    }
+                }
+
+                if let Some(stop_block) = self.inputs.stop_block
+                    && block_ptr.number >= stop_block
+                {
+                    info!(self.logger, "Stop block reached for subgraph");
+                    return Ok(Action::Stop);
+                }
+
+                if let Some(max_end_block) = self.inputs.max_end_block
+                    && block_ptr.number >= max_end_block
+                {
+                    info!(
+                        self.logger,
+                        "Stopping subgraph as maximum endBlock reached";
+                        "max_end_block" => max_end_block,
+                        "current_block" => block_ptr.number
+                    );
+                    return Ok(Action::Stop);
+                }
+
+                Ok(action)
+            }
+            // Handle errors based on their kind using the unified error classification.
+            //
+            // Error handling invariants:
+            // - Deterministic: Stop processing, persist PoI only, fail subgraph
+            // - NonDeterministic: Retry with backoff, may succeed on retry
+            // - PossibleReorg: Restart cleanly without persisting (don't fail subgraph)
+            // - Canceled: Clean shutdown, no error recording
+            Err(e) => match e.kind() {
+                ProcessingErrorKind::Canceled => {
+                    debug!(self.logger, "Subgraph block stream shut down cleanly");
+                    Ok(Action::Stop)
+                }
+
+                ProcessingErrorKind::PossibleReorg => {
+                    // Possible reorg detected - restart the block stream cleanly.
+                    // Don't persist anything and don't mark subgraph as failed.
+                    // The block stream restart will allow detection of the actual reorg.
+                    info!(self.logger,
+                        "Possible reorg detected, restarting block stream";
+                        "error" => format!("{:#}", e),
+                    );
+
+                    // Revert in-memory state to last good block but don't touch the store
+                    let last_good_block = self
+                        .inputs
+                        .store
+                        .block_ptr()
+                        .map(|ptr| ptr.number)
+                        .unwrap_or(0);
+                    self.revert_state_to(last_good_block);
+
+                    Ok(Action::Restart)
+                }
+
+                ProcessingErrorKind::Deterministic => {
+                    // Deterministic error - fail the subgraph permanently.
+                    self.metrics.subgraph.deployment_status.failed();
+                    let last_good_block = self
+                        .inputs
+                        .store
+                        .block_ptr()
+                        .map(|ptr| ptr.number)
+                        .unwrap_or(0);
+                    self.revert_state_to(last_good_block);
+
+                    let message = format!("{:#}", e).replace('\n', "\t");
+                    let err = anyhow!("{}, code: {}", message, LogCode::SubgraphSyncingFailure);
+
+                    self.fail_subgraph(message, Some(block_ptr), true).await?;
+
+                    Err(err)
+                }
+
+                ProcessingErrorKind::NonDeterministic => {
+                    // Non-deterministic error - retry with backoff.
+                    self.metrics.subgraph.deployment_status.failed();
+                    let last_good_block = self
+                        .inputs
+                        .store
+                        .block_ptr()
+                        .map(|ptr| ptr.number)
+                        .unwrap_or(0);
+                    self.revert_state_to(last_good_block);
+
+                    let message = format!("{:#}", e).replace('\n', "\t");
+
+                    error!(self.logger, "Subgraph failed with non-deterministic error: {}", message;
+                        "attempt" => self.state.backoff.attempt,
+                        "retry_delay_s" => self.state.backoff.delay().as_secs());
+
+                    // Shouldn't fail subgraph if it's already failed for non-deterministic
+                    // reasons.
+                    //
+                    // If we don't do this check we would keep adding the same error to the
+                    // database.
+                    if !self.inputs.store.health().await?.is_failed() {
+                        self.fail_subgraph(message, Some(block_ptr), false).await?;
+                    }
+
+                    // Sleep before restarting.
+                    self.state.backoff.sleep_async().await;
+
+                    self.state.should_try_unfail_non_deterministic = true;
+
+                    // And restart the subgraph.
+                    Ok(Action::Restart)
+                }
+            },
+        }
+    }
+
+    fn persist_dynamic_data_sources(
+        &mut self,
+        block_state: &mut BlockState,
+        data_sources: Vec<DataSource<C>>,
+    ) {
+        if !data_sources.is_empty() {
+            debug!(
+                self.logger,
+                "Creating {} dynamic data source(s)",
+                data_sources.len()
+            );
+        }
+
+        // Add entity operations to the block state in order to persist
+        // the dynamic data sources
+        for data_source in data_sources.iter() {
+            debug!(
+                self.logger,
+                "Persisting data_source";
+                "name" => &data_source.name(),
+                "address" => &data_source.address().map(hex::encode).unwrap_or("none".to_string()),
+            );
+            block_state.persist_data_source(data_source.as_stored_dynamic_data_source());
+        }
+    }
+
+    /// We consider a subgraph caught up when it's at most 10 blocks behind the chain head.
+    async fn is_caught_up(&mut self, block_ptr: &BlockPtr) -> Result<bool, Error> {
+        const CAUGHT_UP_DISTANCE: BlockNumber = 10;
+
+        // Ensure that `state.cached_head_ptr` has a value since it could be `None` on the first
+        // iteration of loop. If the deployment head has caught up to the `cached_head_ptr`, update
+        // it so that we are up to date when checking if synced.
+        let cached_head_ptr = self.state.cached_head_ptr.cheap_clone();
+        if cached_head_ptr.is_none()
+            || close_to_chain_head(block_ptr, &cached_head_ptr, CAUGHT_UP_DISTANCE)
+        {
+            self.state.cached_head_ptr = self.inputs.chain.chain_head_ptr().await?;
+        }
+        let is_caught_up =
+            close_to_chain_head(block_ptr, &self.state.cached_head_ptr, CAUGHT_UP_DISTANCE);
+        if is_caught_up {
+            // Stop recording time-to-sync metrics.
+            self.metrics.stream.stopwatch.disable();
+        }
+        Ok(is_caught_up)
+    }
+}
+
+impl<C, T> SubgraphRunner<C, T>
+where
+    C: Blockchain,
+    T: RuntimeHostBuilder<C>,
+{
+    async fn handle_offchain_triggers(
+        &mut self,
+        triggers: Vec<offchain::TriggerData>,
+        block: &Arc<C::Block>,
+        vid_gen: SeqGenerator,
+    ) -> Result<
+        (
+            Vec<EntityModification>,
+            Vec<StoredDynamicDataSource>,
+            Vec<StoredDynamicDataSource>,
+        ),
+        Error,
+    > {
+        let mut mods = vec![];
+        let mut processed_data_sources = vec![];
+        let mut persisted_data_sources = vec![];
+
+        for trigger in triggers {
+            // Using an `EmptyStore` and clearing the cache for each trigger is a makeshift way to
+            // get causality region isolation.
+            let schema = ReadStore::input_schema(&self.inputs.store);
+            let mut block_state = BlockState::new(
+                EmptyStore::new(schema),
+                LfuCache::new(),
+                vid_gen.cheap_clone(),
+            );
+
+            // PoI ignores offchain events.
+            // See also: poi-ignores-offchain
+            let proof_of_indexing = SharedProofOfIndexing::ignored();
+            let causality_region = "";
+
+            let trigger = TriggerData::Offchain(trigger);
+            let process_res = {
+                let hosts = self.ctx.instance.hosts_for_trigger(&trigger);
+                let triggers_res = self.ctx.decoder.match_and_decode(
+                    &self.logger,
+                    block,
+                    trigger,
+                    hosts,
+                    &self.metrics.subgraph,
+                );
+                match triggers_res {
+                    Ok(runnable) => {
+                        self.ctx
+                            .trigger_processor
+                            .process_trigger(
+                                &self.logger,
+                                runnable.hosted_triggers,
+                                block,
+                                block_state,
+                                &proof_of_indexing,
+                                causality_region,
+                                &self.inputs.debug_fork,
+                                &self.metrics.subgraph,
+                                self.inputs.instrument,
+                            )
+                            .await
+                    }
+                    Err(e) => Err(e),
+                }
+            };
+            match process_res {
+                Ok(state) => block_state = state,
+                Err(err) => {
+                    let err = match err {
+                        // Ignoring `PossibleReorg` isn't so bad since the subgraph will retry
+                        // non-deterministic errors.
+                        MappingError::PossibleReorg(e) | MappingError::Unknown(e) => e,
+                    };
+                    return Err(err.context("failed to process trigger".to_string()));
+                }
+            }
+
+            anyhow::ensure!(
+                !block_state.has_created_on_chain_data_sources(),
+                "Attempted to create on-chain data source in offchain data source handler. This is not yet supported.",
+            );
+
+            let (data_sources, _) =
+                self.create_dynamic_data_sources(block_state.drain_created_data_sources())?;
+
+            // Add entity operations for the new data sources to the block state
+            // and add runtimes for the data sources to the subgraph instance.
+            self.persist_dynamic_data_sources(&mut block_state, data_sources);
+
+            // This propagates any deterministic error as a non-deterministic one. Which might make
+            // sense considering offchain data sources are non-deterministic.
+            if let Some(err) = block_state.deterministic_errors.into_iter().next() {
+                return Err(anyhow!("{}", err));
+            }
+
+            mods.extend(
+                block_state
+                    .entity_cache
+                    .as_modifications(block.number(), &self.metrics.subgraph.stopwatch)
+                    .await?
+                    .modifications,
+            );
+            processed_data_sources.extend(block_state.processed_data_sources);
+            persisted_data_sources.extend(block_state.persisted_data_sources)
+        }
+
+        Ok((mods, processed_data_sources, persisted_data_sources))
+    }
+
+    fn update_deployment_synced_metric(&self) {
+        self.metrics
+            .subgraph
+            .deployment_synced
+            .record(self.inputs.store.is_deployment_synced());
+    }
+}
+
+#[derive(Debug)]
+enum Action {
+    Continue,
+    Stop,
+    Restart,
+}
+
+impl Action {
+    /// Return `true` if the action indicates that we are done with a block
+    fn block_finished(&self) -> bool {
+        match self {
+            Action::Restart => false,
+            Action::Continue | Action::Stop => true,
+        }
+    }
+}
+
+impl<C, T> SubgraphRunner<C, T>
+where
+    C: Blockchain,
+    T: RuntimeHostBuilder<C>,
+{
+    async fn handle_revert(&mut self, revert_to_ptr: BlockPtr, cursor: FirehoseCursor) -> Action {
+        // Current deployment head in the database / WritableAgent Mutex cache.
+        //
+        // Safe unwrap because in a Revert event we're sure the subgraph has
+        // advanced at least once.
+        let subgraph_ptr = self.inputs.store.block_ptr().unwrap();
+        if revert_to_ptr.number >= subgraph_ptr.number {
+            info!(&self.logger, "Block to revert is higher than subgraph pointer, nothing to do"; "subgraph_ptr" => &subgraph_ptr, "revert_to_ptr" => &revert_to_ptr);
+            return Action::Continue;
+        }
+
+        info!(&self.logger, "Reverting block to get back to main chain"; "subgraph_ptr" => &subgraph_ptr, "revert_to_ptr" => &revert_to_ptr);
+
+        if let Err(e) = self
+            .inputs
+            .store
+            .revert_block_operations(revert_to_ptr.clone(), cursor)
+            .await
+        {
+            error!(&self.logger, "Could not revert block. Retrying"; "error" => %e);
+
+            // Exit inner block stream consumption loop and go up to loop that restarts subgraph
+            return Action::Restart;
+        }
+
+        self.metrics
+            .stream
+            .reverted_blocks
+            .set(subgraph_ptr.number as f64);
+        self.metrics
+            .stream
+            .deployment_head
+            .set(subgraph_ptr.number as f64);
+
+        self.revert_state_to(revert_to_ptr.number);
+
+        let needs_restart: bool = self.needs_restart(revert_to_ptr, subgraph_ptr);
+
+        if needs_restart {
+            Action::Restart
+        } else {
+            Action::Continue
+        }
+    }
+
+    /// Determines if the subgraph needs to be restarted.
+    /// Currently returns true when there are data sources that have reached their end block
+    /// in the range between `revert_to_ptr` and `subgraph_ptr`.
+    fn needs_restart(&self, revert_to_ptr: BlockPtr, subgraph_ptr: BlockPtr) -> bool {
+        self.inputs
+            .end_blocks
+            .range(revert_to_ptr.number..=subgraph_ptr.number)
+            .next()
+            .is_some()
+    }
+}
+
+impl From<StoreError> for SubgraphRunnerError {
+    fn from(err: StoreError) -> Self {
+        Self::Unknown(err.into())
+    }
+}
+
+/// Transform the proof of indexing changes into entity updates that will be
+/// inserted when as_modifications is called.
+async fn update_proof_of_indexing(
+    proof_of_indexing: ProofOfIndexing,
+    block_time: BlockTime,
+    stopwatch: &StopwatchMetrics,
+    entity_cache: &mut EntityCache,
+) -> Result<(), Error> {
+    // Helper to store the digest as a PoI entity in the cache
+    async fn store_poi_entity(
+        entity_cache: &mut EntityCache,
+        key: EntityKey,
+        digest: Bytes,
+        block_time: BlockTime,
+    ) -> Result<(), Error> {
+        let digest_name = entity_cache.schema.poi_digest();
+        let mut data = vec![
+            (
+                graph::data::store::ID.clone(),
+                Value::from(key.entity_id.to_string()),
+            ),
+            (digest_name, Value::from(digest)),
+        ];
+        if entity_cache.schema.has_aggregations() {
+            let block_time = Value::Int8(block_time.as_secs_since_epoch());
+            data.push((entity_cache.schema.poi_block_time(), block_time));
+        }
+        let poi = entity_cache.make_entity(data)?;
+        entity_cache.set(key, poi, None).await
+    }
+
+    let _section_guard = stopwatch.start_section("update_proof_of_indexing");
+
+    let mut proof_of_indexing = proof_of_indexing.take();
+
+    for (causality_region, stream) in proof_of_indexing.drain() {
+        // Create the special POI entity key specific to this causality_region
+        // There are two things called causality regions here, one is the causality region for
+        // the poi which is a string and the PoI entity id. The other is the data source
+        // causality region to which the PoI belongs as an entity. Currently offchain events do
+        // not affect PoI so it is assumed to be `ONCHAIN`.
+        // See also: poi-ignores-offchain
+        let entity_key = entity_cache
+            .schema
+            .poi_type()
+            .key_in(causality_region, CausalityRegion::ONCHAIN);
+
+        // Grab the current digest attribute on this entity
+        let poi_digest = entity_cache.schema.poi_digest().clone();
+        let prev_poi = entity_cache
+            .get(&entity_key, GetScope::Store)
+            .await
+            .map_err(Error::from)?
+            .map(|entity| match entity.get(poi_digest.as_str()) {
+                Some(Value::Bytes(b)) => b.clone(),
+                _ => panic!("Expected POI entity to have a digest and for it to be bytes"),
+            });
+
+        // Finish the POI stream, getting the new POI value.
+        let updated_proof_of_indexing = stream.pause(prev_poi.as_deref());
+        let updated_proof_of_indexing: Bytes = (&updated_proof_of_indexing[..]).into();
+
+        // Put this onto an entity with the same digest attribute
+        // that was expected before when reading.
+        store_poi_entity(
+            entity_cache,
+            entity_key,
+            updated_proof_of_indexing,
+            block_time,
+        )
+        .await?;
+    }
+
+    Ok(())
+}
+
+/// Checks if the Deployment BlockPtr is within N blocks of the chain head or ahead.
+fn close_to_chain_head(
+    deployment_head_ptr: &BlockPtr,
+    chain_head_ptr: &Option<BlockPtr>,
+    n: BlockNumber,
+) -> bool {
+    matches!((deployment_head_ptr, &chain_head_ptr), (b1, Some(b2)) if b1.number >= (b2.number - n))
+}
+
+#[test]
+fn test_close_to_chain_head() {
+    let offset = 1;
+
+    let block_0 = BlockPtr::try_from((
+        "bd34884280958002c51d3f7b5f853e6febeba33de0f40d15b0363006533c924f",
+        0,
+    ))
+    .unwrap();
+    let block_1 = BlockPtr::try_from((
+        "8511fa04b64657581e3f00e14543c1d522d5d7e771b54aa3060b662ade47da13",
+        1,
+    ))
+    .unwrap();
+    let block_2 = BlockPtr::try_from((
+        "b98fb783b49de5652097a989414c767824dff7e7fd765a63b493772511db81c1",
+        2,
+    ))
+    .unwrap();
+
+    assert!(!close_to_chain_head(&block_0, &None, offset));
+    assert!(!close_to_chain_head(&block_2, &None, offset));
+
+    assert!(!close_to_chain_head(
+        &block_0,
+        &Some(block_2.clone()),
+        offset
+    ));
+
+    assert!(close_to_chain_head(
+        &block_1,
+        &Some(block_2.clone()),
+        offset
+    ));
+    assert!(close_to_chain_head(
+        &block_2,
+        &Some(block_2.clone()),
+        offset
+    ));
+}
diff --git a/core/src/subgraph/runner/state.rs b/core/src/subgraph/runner/state.rs
new file mode 100644
index 00000000000..d6401842522
--- /dev/null
+++ b/core/src/subgraph/runner/state.rs
@@ -0,0 +1,96 @@
+//! State machine types for SubgraphRunner.
+//!
+//! This module defines the explicit state machine that controls the runner's lifecycle,
+//! replacing the previous nested loop structure with clear state transitions.
+
+use graph::blockchain::Blockchain;
+use graph::blockchain::block_stream::{BlockStream, BlockWithTriggers, FirehoseCursor};
+use graph::ext::futures::Cancelable;
+use graph::prelude::BlockPtr;
+
+/// The current state of the SubgraphRunner's lifecycle.
+///
+/// The runner transitions through these states as it processes blocks,
+/// handles reverts, and responds to errors or cancellation signals.
+///
+/// ## State Transitions
+///
+/// ```text
+/// Initializing ───────────────────────────────────┐
+///      │                                          │
+///      v                                          │
+///  AwaitingBlock ◄────────────────────────────────┤
+///      │                                          │
+///      ├── ProcessBlock event ──► ProcessingBlock │
+///      │                              │           │
+///      │                              ├── success ┼──► AwaitingBlock
+///      │                              │           │
+///      │                              └── restart ┼──► Restarting
+///      │                                          │
+///      ├── Revert event ──────────► Reverting ────┤
+///      │                                          │
+///      ├── Error ─────────────────► Restarting ───┤
+///      │                                          │
+///      └── Cancel/MaxBlock ───────► Stopped       │
+///                                                 │
+/// Restarting ─────────────────────────────────────┘
+/// ```
+#[derive(Default)]
+pub enum RunnerState<C: Blockchain> {
+    /// Initial state, ready to start block stream.
+    #[default]
+    Initializing,
+
+    /// Block stream active, waiting for next event.
+    AwaitingBlock {
+        block_stream: Cancelable<Box<dyn BlockStream<C>>>,
+    },
+
+    /// Processing a block through the pipeline.
+    /// The block stream is kept alive to continue processing after this block.
+    ProcessingBlock {
+        block_stream: Cancelable<Box<dyn BlockStream<C>>>,
+        block: BlockWithTriggers<C>,
+        cursor: FirehoseCursor,
+    },
+
+    /// Handling a revert event.
+    /// The block stream is kept alive to continue processing after the revert.
+    Reverting {
+        block_stream: Cancelable<Box<dyn BlockStream<C>>>,
+        to_ptr: BlockPtr,
+        cursor: FirehoseCursor,
+    },
+
+    /// Restarting block stream (new filters, store restart, etc.).
+    Restarting { reason: RestartReason },
+
+    /// Terminal state.
+    Stopped { reason: StopReason },
+}
+
+/// Reasons for restarting the block stream.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RestartReason {
+    /// New dynamic data source was created that requires filter updates.
+    DynamicDataSourceCreated,
+    /// Store error occurred and store needs to be restarted.
+    StoreError,
+    /// Possible reorg detected, need to restart to detect it.
+    /// NOTE: Currently unused but reserved for future error handling consolidation (Phase 5).
+    #[allow(dead_code)]
+    PossibleReorg,
+}
+
+/// Reasons for stopping the runner.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum StopReason {
+    /// The maximum end block was reached.
+    MaxEndBlockReached,
+    /// The runner was canceled (unassigned or shutdown).
+    Canceled,
+    /// The subgraph was unassigned while this runner was active.
+    Unassigned,
+    /// The block stream ended (typically in tests).
+    StreamEnded,
+}
diff --git a/core/src/subgraph/runner/trigger_runner.rs b/core/src/subgraph/runner/trigger_runner.rs
new file mode 100644
index 00000000000..6c89052e5dc
--- /dev/null
+++ b/core/src/subgraph/runner/trigger_runner.rs
@@ -0,0 +1,79 @@
+use std::sync::Arc;
+
+use graph::blockchain::Blockchain;
+use graph::components::store::SubgraphFork;
+use graph::components::subgraph::{MappingError, SharedProofOfIndexing};
+use graph::components::trigger_processor::RunnableTriggers;
+use graph::prelude::{BlockState, RuntimeHostBuilder, SubgraphInstanceMetrics, TriggerProcessor};
+use graph::slog::Logger;
+
+/// Handles the execution of triggers against runtime hosts, accumulating state.
+///
+/// This component unifies the trigger processing loop that was previously duplicated
+/// for initial triggers and dynamically created data source triggers.
+pub struct TriggerRunner<'a, C: Blockchain, T: RuntimeHostBuilder<C>> {
+    processor: &'a dyn TriggerProcessor<C, T>,
+    logger: &'a Logger,
+    metrics: &'a Arc<SubgraphInstanceMetrics>,
+    debug_fork: &'a Option<Arc<dyn SubgraphFork>>,
+    instrument: bool,
+}
+
+impl<'a, C, T> TriggerRunner<'a, C, T>
+where
+    C: Blockchain,
+    T: RuntimeHostBuilder<C>,
+{
+    /// Create a new TriggerRunner with the given dependencies.
+    pub fn new(
+        processor: &'a dyn TriggerProcessor<C, T>,
+        logger: &'a Logger,
+        metrics: &'a Arc<SubgraphInstanceMetrics>,
+        debug_fork: &'a Option<Arc<dyn SubgraphFork>>,
+        instrument: bool,
+    ) -> Self {
+        Self {
+            processor,
+            logger,
+            metrics,
+            debug_fork,
+            instrument,
+        }
+    }
+
+    /// Execute a sequence of runnable triggers, accumulating state changes.
+    ///
+    /// Processes each trigger in order. If any trigger fails with a non-deterministic
+    /// error, processing stops and the error is returned. Deterministic errors are
+    /// accumulated in the block state.
+    pub async fn execute(
+        &self,
+        block: &Arc<C::Block>,
+        runnables: Vec<RunnableTriggers<'a, C>>,
+        block_state: BlockState,
+        proof_of_indexing: &SharedProofOfIndexing,
+        causality_region: &str,
+    ) -> Result<BlockState, MappingError> {
+        let mut state = block_state;
+
+        for runnable in runnables {
+            state = self
+                .processor
+                .process_trigger(
+                    self.logger,
+                    runnable.hosted_triggers,
+                    block,
+                    state,
+                    proof_of_indexing,
+                    causality_region,
+                    self.debug_fork,
+                    self.metrics,
+                    self.instrument,
+                )
+                .await
+                .map_err(|e| e.add_trigger_context(&runnable.trigger))?;
+        }
+
+        Ok(state)
+    }
+}
diff --git a/core/src/subgraph/state.rs b/core/src/subgraph/state.rs
index 727cd8d45e6..c1da4b43199 100644
--- a/core/src/subgraph/state.rs
+++ b/core/src/subgraph/state.rs
@@ -1,15 +1,11 @@
 use graph::{
-    prelude::{BlockPtr, Entity},
-    schema::EntityKey,
-    util::{backoff::ExponentialBackoff, lfu_cache::LfuCache},
+    components::store::EntityLfuCache, prelude::BlockPtr, util::backoff::ExponentialBackoff,
 };
 use std::time::Instant;
 
 pub struct IndexingState {
     /// `true` -> `false` on the first run
     pub should_try_unfail_non_deterministic: bool,
-    /// `false` -> `true` once it reaches chain head
-    pub synced: bool,
     /// Backoff used for the retry mechanism on non-deterministic errors
     pub backoff: ExponentialBackoff,
     /// Related to field above `backoff`
@@ -18,6 +14,9 @@ pub struct IndexingState {
     /// - The time THRESHOLD is passed
     /// - Or the subgraph has triggers for the block
     pub skip_ptr_updates_timer: Instant,
-    pub entity_lfu_cache: LfuCache<EntityKey, Option<Entity>>,
+    pub entity_lfu_cache: EntityLfuCache,
     pub cached_head_ptr: Option<BlockPtr>,
+    /// Set to `true` once postponed indexes have been created. This
+    /// ensures we only trigger index creation once per subgraph run.
+    pub postponed_indexes_created: bool,
 }
diff --git a/core/src/subgraph/stream.rs b/core/src/subgraph/stream.rs
index c1d767e3fcf..5547543f13d 100644
--- a/core/src/subgraph/stream.rs
+++ b/core/src/subgraph/stream.rs
@@ -1,13 +1,13 @@
 use crate::subgraph::inputs::IndexingInputs;
 use anyhow::bail;
 use graph::blockchain::block_stream::{BlockStream, BufferedBlockStream};
-use graph::blockchain::Blockchain;
+use graph::blockchain::{Blockchain, TriggerFilterWrapper};
 use graph::prelude::{CheapClone, Error, SubgraphInstanceMetrics};
 use std::sync::Arc;
 
 pub async fn new_block_stream<C: Blockchain>(
     inputs: &IndexingInputs<C>,
-    filter: &C::TriggerFilter,
+    filter: TriggerFilterWrapper<C>,
     metrics: &SubgraphInstanceMetrics,
 ) -> Result<Box<dyn BlockStream<C>>, Error> {
     let is_firehose = inputs.chain.chain_client().is_firehose();
@@ -18,6 +18,7 @@ pub async fn new_block_stream<C: Blockchain>(
             inputs.deployment.clone(),
             inputs.store.cheap_clone(),
             inputs.start_blocks.clone(),
+            inputs.source_subgraph_stores.clone(),
             Arc::new(filter.clone()),
             inputs.unified_api_version.clone(),
         )
diff --git a/core/src/subgraph/trigger_processor.rs b/core/src/subgraph/trigger_processor.rs
index 61fa585e416..c3123e87268 100644
--- a/core/src/subgraph/trigger_processor.rs
+++ b/core/src/subgraph/trigger_processor.rs
@@ -1,14 +1,16 @@
 use async_trait::async_trait;
-use graph::blockchain::{Block, Blockchain};
+use graph::blockchain::{Block, Blockchain, DecoderHook as _};
 use graph::cheap_clone::CheapClone;
 use graph::components::store::SubgraphFork;
 use graph::components::subgraph::{MappingError, SharedProofOfIndexing};
-use graph::data_source::{MappingTrigger, TriggerData, TriggerWithHandler};
+use graph::components::trigger_processor::{HostedTrigger, RunnableTriggers};
+use graph::data_source::TriggerData;
 use graph::prelude::tokio::time::Instant;
 use graph::prelude::{
     BlockState, RuntimeHost, RuntimeHostBuilder, SubgraphInstanceMetrics, TriggerProcessor,
 };
 use graph::slog::Logger;
+use std::marker::PhantomData;
 use std::sync::Arc;
 
 pub struct SubgraphTriggerProcessor {}
@@ -22,47 +24,28 @@ where
     async fn process_trigger<'a>(
         &'a self,
         logger: &Logger,
-        hosts: Box<dyn Iterator<Item = &T::Host> + Send + 'a>,
+        triggers: Vec<HostedTrigger<'a, C>>,
         block: &Arc<C::Block>,
-        trigger: &TriggerData<C>,
-        mut state: BlockState<C>,
+        mut state: BlockState,
         proof_of_indexing: &SharedProofOfIndexing,
         causality_region: &str,
         debug_fork: &Option<Arc<dyn SubgraphFork>>,
         subgraph_metrics: &Arc<SubgraphInstanceMetrics>,
         instrument: bool,
-    ) -> Result<BlockState<C>, MappingError> {
+    ) -> Result<BlockState, MappingError> {
         let error_count = state.deterministic_errors.len();
 
-        let mut host_mapping: Vec<(&T::Host, TriggerWithHandler<MappingTrigger<C>>)> = vec![];
-
-        {
-            let _section = subgraph_metrics.stopwatch.start_section("match_and_decode");
-
-            for host in hosts {
-                let mapping_trigger = match host.match_and_decode(trigger, block, logger)? {
-                    // Trigger matches and was decoded as a mapping trigger.
-                    Some(mapping_trigger) => mapping_trigger,
-
-                    // Trigger does not match, do not process it.
-                    None => continue,
-                };
-
-                host_mapping.push((host, mapping_trigger));
-            }
-        }
-
-        if host_mapping.is_empty() {
+        if triggers.is_empty() {
             return Ok(state);
         }
 
-        if let Some(proof_of_indexing) = proof_of_indexing {
-            proof_of_indexing
-                .borrow_mut()
-                .start_handler(causality_region);
-        }
+        proof_of_indexing.start_handler(causality_region);
 
-        for (host, mapping_trigger) in host_mapping {
+        for HostedTrigger {
+            host,
+            mapping_trigger,
+        } in triggers
+        {
             let start = Instant::now();
             state = host
                 .process_mapping_trigger(
@@ -86,18 +69,113 @@ where
             }
         }
 
-        if let Some(proof_of_indexing) = proof_of_indexing {
-            if state.deterministic_errors.len() != error_count {
-                assert!(state.deterministic_errors.len() == error_count + 1);
+        if state.deterministic_errors.len() != error_count {
+            assert!(state.deterministic_errors.len() == error_count + 1);
 
-                // If a deterministic error has happened, write a new
-                // ProofOfIndexingEvent::DeterministicError to the SharedProofOfIndexing.
-                proof_of_indexing
-                    .borrow_mut()
-                    .write_deterministic_error(logger, causality_region);
-            }
+            // If a deterministic error has happened, write a new
+            // ProofOfIndexingEvent::DeterministicError to the SharedProofOfIndexing.
+            proof_of_indexing.write_deterministic_error(logger, causality_region);
         }
 
         Ok(state)
     }
 }
+
+/// A helper for taking triggers as `TriggerData` (usually from the block
+/// stream) and turning them into `HostedTrigger`s that are ready to run.
+///
+/// The output triggers will be run in the order in which they are returned.
+pub struct Decoder<C, T>
+where
+    C: Blockchain,
+    T: RuntimeHostBuilder<C>,
+{
+    hook: C::DecoderHook,
+    _builder: PhantomData<T>,
+}
+
+impl<C, T> Decoder<C, T>
+where
+    C: Blockchain,
+    T: RuntimeHostBuilder<C>,
+{
+    pub fn new(hook: C::DecoderHook) -> Self {
+        Decoder {
+            hook,
+            _builder: PhantomData,
+        }
+    }
+}
+
+impl<C: Blockchain, T: RuntimeHostBuilder<C>> Decoder<C, T> {
+    fn match_and_decode_inner<'a>(
+        &'a self,
+        logger: &Logger,
+        block: &Arc<C::Block>,
+        trigger: &TriggerData<C>,
+        hosts: Box<dyn Iterator<Item = &'a T::Host> + Send + 'a>,
+        subgraph_metrics: &Arc<SubgraphInstanceMetrics>,
+    ) -> Result<Vec<HostedTrigger<'a, C>>, MappingError> {
+        let mut host_mapping = vec![];
+
+        {
+            let _section = subgraph_metrics.stopwatch.start_section("match_and_decode");
+
+            for host in hosts {
+                let mapping_trigger = match host.match_and_decode(trigger, block, logger)? {
+                    // Trigger matches and was decoded as a mapping trigger.
+                    Some(mapping_trigger) => mapping_trigger,
+
+                    // Trigger does not match, do not process it.
+                    None => continue,
+                };
+
+                host_mapping.push(HostedTrigger {
+                    host,
+                    mapping_trigger,
+                });
+            }
+        }
+        Ok(host_mapping)
+    }
+
+    pub(crate) fn match_and_decode<'a>(
+        &'a self,
+        logger: &Logger,
+        block: &Arc<C::Block>,
+        trigger: TriggerData<C>,
+        hosts: Box<dyn Iterator<Item = &'a T::Host> + Send + 'a>,
+        subgraph_metrics: &Arc<SubgraphInstanceMetrics>,
+    ) -> Result<RunnableTriggers<'a, C>, MappingError> {
+        self.match_and_decode_inner(logger, block, &trigger, hosts, subgraph_metrics)
+            .map_err(|e| e.add_trigger_context(&trigger))
+            .map(|hosted_triggers| RunnableTriggers {
+                trigger,
+                hosted_triggers,
+            })
+    }
+
+    pub(crate) async fn match_and_decode_many<'a, F>(
+        &'a self,
+        logger: &Logger,
+        block: &Arc<C::Block>,
+        triggers: impl Iterator<Item = TriggerData<C>>,
+        hosts_filter: F,
+        metrics: &Arc<SubgraphInstanceMetrics>,
+    ) -> Result<Vec<RunnableTriggers<'a, C>>, MappingError>
+    where
+        F: Fn(&TriggerData<C>) -> Box<dyn Iterator<Item = &'a T::Host> + Send + 'a>,
+    {
+        let mut runnables = vec![];
+        for trigger in triggers {
+            let hosts = hosts_filter(&trigger);
+            match self.match_and_decode(logger, block, trigger, hosts, metrics) {
+                Ok(runnable_triggers) => runnables.push(runnable_triggers),
+                Err(e) => return Err(e),
+            }
+        }
+        self.hook
+            .after_decode(logger, &block.ptr(), runnables, metrics)
+            .await
+    }
+}
diff --git a/core/src/subgraph_manifest.rs b/core/src/subgraph_manifest.rs
new file mode 100644
index 00000000000..ddc01e0bc69
--- /dev/null
+++ b/core/src/subgraph_manifest.rs
@@ -0,0 +1,93 @@
+use graph::{
+    cheap_clone::CheapClone as _,
+    components::{
+        link_resolver::{LinkResolver, LinkResolverContext},
+        store::{StoreError, SubgraphStore},
+    },
+    data::subgraph::DeploymentHash,
+};
+use slog::{Logger, debug};
+
+pub(super) async fn load_raw_subgraph_manifest(
+    logger: &Logger,
+    subgraph_store: &dyn SubgraphStore,
+    link_resolver: &dyn LinkResolver,
+    hash: &DeploymentHash,
+) -> Result<serde_yaml::Mapping, Error> {
+    if let Some(raw_manifest) =
+        subgraph_store
+            .raw_manifest(hash)
+            .await
+            .map_err(|e| Error::LoadManifest {
+                hash: hash.cheap_clone(),
+                source: anyhow::Error::from(e),
+            })?
+    {
+        debug!(logger, "Loaded raw manifest from the subgraph store");
+        return Ok(raw_manifest);
+    }
+
+    debug!(logger, "Loading raw manifest using link resolver");
+
+    let link_resolver =
+        link_resolver
+            .for_manifest(&hash.to_string())
+            .map_err(|e| Error::CreateLinkResolver {
+                hash: hash.cheap_clone(),
+                source: e,
+            })?;
+
+    let file_bytes = link_resolver
+        .cat(
+            &LinkResolverContext::new(hash, logger),
+            &hash.to_ipfs_link(),
+        )
+        .await
+        .map_err(|e| Error::LoadManifest {
+            hash: hash.cheap_clone(),
+            source: e,
+        })?;
+
+    let raw_manifest: serde_yaml::Mapping =
+        serde_yaml::from_slice(&file_bytes).map_err(|e| Error::ParseManifest {
+            hash: hash.cheap_clone(),
+            source: e,
+        })?;
+
+    subgraph_store
+        .set_raw_manifest_once(hash, &raw_manifest)
+        .await
+        .map_err(|e| Error::StoreManifest {
+            hash: hash.cheap_clone(),
+            source: e,
+        })?;
+
+    Ok(raw_manifest)
+}
+
+#[derive(Debug, thiserror::Error)]
+pub(super) enum Error {
+    #[error("failed to create link resolver for '{hash}': {source:#}")]
+    CreateLinkResolver {
+        hash: DeploymentHash,
+        source: anyhow::Error,
+    },
+
+    #[error("failed to load manifest for '{hash}': {source:#}")]
+    LoadManifest {
+        hash: DeploymentHash,
+        source: anyhow::Error,
+    },
+
+    #[error("failed to parse manifest for '{hash}': {source:#}")]
+    ParseManifest {
+        hash: DeploymentHash,
+        source: serde_yaml::Error,
+    },
+
+    #[error("failed to store manifest for '{hash}': {source:#}")]
+    StoreManifest {
+        hash: DeploymentHash,
+        source: StoreError,
+    },
+}
diff --git a/core/src/subgraph_provider.rs b/core/src/subgraph_provider.rs
new file mode 100644
index 00000000000..7e479dd9495
--- /dev/null
+++ b/core/src/subgraph_provider.rs
@@ -0,0 +1,346 @@
+use std::{collections::HashMap, sync::Arc, time::Instant};
+
+use graph::{
+    amp,
+    cheap_clone::CheapClone as _,
+    components::{
+        link_resolver::LinkResolver,
+        metrics::subgraph::SubgraphCountMetric,
+        store::{DeploymentLocator, SubgraphStore},
+        subgraph::SubgraphInstanceManager,
+    },
+    log::factory::LoggerFactory,
+};
+use itertools::Itertools as _;
+use parking_lot::RwLock;
+use slog::{debug, error};
+use tokio_util::sync::CancellationToken;
+
+use super::subgraph_manifest;
+
+/// Starts and stops subgraph deployments.
+///
+/// For each subgraph deployment, checks the subgraph processing kind
+/// and finds the appropriate subgraph instance manager to handle the
+/// processing of the subgraph deployment.
+///
+/// This is required to support both trigger-based subgraphs and Amp-powered subgraphs,
+/// which have separate runners.
+pub struct SubgraphProvider {
+    logger_factory: LoggerFactory,
+    count_metrics: Arc<SubgraphCountMetric>,
+    subgraph_store: Arc<dyn SubgraphStore>,
+    link_resolver: Arc<dyn LinkResolver>,
+
+    /// Stops active subgraph start request tasks.
+    ///
+    /// When a subgraph deployment start request is processed, a background task is created
+    /// to load the subgraph manifest and determine the subgraph processing kind. The processing
+    /// kind is then used to find the appropriate subgraph instance manager. This token stops
+    /// all tasks that are still loading manifests or waiting for subgraphs to start.
+    cancel_token: CancellationToken,
+
+    /// Contains the enabled subgraph instance managers.
+    ///
+    /// Only subgraphs for which there is an appropriate instance manager will be started.
+    instance_managers: SubgraphInstanceManagers,
+
+    /// Maintains a list of started subgraphs with their processing kinds.
+    ///
+    /// Used to forward subgraph deployment stop requests to the appropriate subgraph instance manager.
+    assignments: SubgraphAssignments,
+}
+
+impl SubgraphProvider {
+    /// Creates a new subgraph provider.
+    ///
+    /// # Arguments
+    /// - `logger_factory`: Creates loggers for each subgraph deployment start/stop request
+    /// - `count_metrics`: Tracks the number of started subgraph deployments
+    /// - `subgraph_store`: Loads subgraph manifests to determine the subgraph processing kinds
+    /// - `link_resolver`: Loads subgraph manifests to determine the subgraph processing kinds
+    /// - `cancel_token`: Stops active subgraph start request tasks
+    /// - `instance_managers`: Contains the enabled subgraph instance managers
+    pub fn new(
+        logger_factory: &LoggerFactory,
+        count_metrics: Arc<SubgraphCountMetric>,
+        subgraph_store: Arc<dyn SubgraphStore>,
+        link_resolver: Arc<dyn LinkResolver>,
+        cancel_token: CancellationToken,
+        instance_managers: SubgraphInstanceManagers,
+    ) -> Self {
+        let logger = logger_factory.component_logger("SubgraphProvider", None);
+        let logger_factory = logger_factory.with_parent(logger.cheap_clone());
+
+        debug!(logger, "Creating subgraph provider";
+            "enabled_subgraph_processing_kinds" => instance_managers.0.keys().join(", ")
+        );
+
+        Self {
+            logger_factory,
+            count_metrics,
+            subgraph_store,
+            link_resolver,
+            cancel_token,
+            instance_managers,
+            assignments: SubgraphAssignments::new(),
+        }
+    }
+
+    /// Starts a subgraph deployment with the appropriate subgraph instance manager.
+    ///
+    /// Loads the subgraph manifest for the specified deployment locator, determines
+    /// the subgraph processing kind, finds the required instance manager, and forwards
+    /// the start request to that instance manager. Keeps the subgraph processing kind
+    /// in memory for handling the stop requests.
+    async fn assign_and_start_subgraph(
+        &self,
+        loc: DeploymentLocator,
+        stop_block: Option<i32>,
+    ) -> Result<(), Error> {
+        let logger = self.logger_factory.subgraph_logger(&loc);
+
+        let raw_manifest = subgraph_manifest::load_raw_subgraph_manifest(
+            &logger,
+            &*self.subgraph_store,
+            &*self.link_resolver,
+            &loc.hash,
+        )
+        .await
+        .map_err(|e| Error::LoadManifest {
+            loc: loc.cheap_clone(),
+            source: e,
+        })?;
+
+        let subgraph_kind = SubgraphProcessingKind::from_manifest(&raw_manifest);
+        self.assignments.set_subgraph_kind(&loc, subgraph_kind);
+
+        let Some(instance_manager) = self.instance_managers.get(&subgraph_kind) else {
+            return Err(Error::GetManager { loc, subgraph_kind });
+        };
+
+        instance_manager.start_subgraph(loc, stop_block).await;
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl SubgraphInstanceManager for SubgraphProvider {
+    async fn start_subgraph(self: Arc<Self>, loc: DeploymentLocator, stop_block: Option<i32>) {
+        let logger = self
+            .logger_factory
+            .subgraph_logger(&loc)
+            .new(slog::o!("method" => "start_subgraph"));
+
+        if self.assignments.is_assigned(&loc) {
+            debug!(logger, "Subgraph is already started");
+            return;
+        }
+
+        self.count_metrics.deployment_count.inc();
+
+        let handle = tokio::spawn({
+            let provider = self.cheap_clone();
+            let loc = loc.cheap_clone();
+            let start_instant = Instant::now();
+
+            async move {
+                debug!(logger, "Starting subgraph");
+
+                let fut = provider.assign_and_start_subgraph(loc, stop_block);
+                match provider.cancel_token.run_until_cancelled(fut).await {
+                    Some(Ok(())) => {
+                        debug!(logger, "Subgraph started";
+                            "duration_ms" => start_instant.elapsed().as_millis()
+                        );
+                    }
+                    Some(Err(e)) => {
+                        error!(logger, "Subgraph failed to start";
+                            "e" => ?e
+                        );
+                    }
+                    None => {
+                        debug!(logger, "Subgraph start cancelled");
+                    }
+                }
+            }
+        });
+
+        self.assignments.add(
+            loc,
+            SubgraphAssignment {
+                handle,
+                subgraph_kind: None,
+            },
+        )
+    }
+
+    async fn stop_subgraph(&self, loc: DeploymentLocator) {
+        let logger = self
+            .logger_factory
+            .subgraph_logger(&loc)
+            .new(slog::o!("method" => "stop_subgraph"));
+
+        debug!(logger, "Stopping subgraph");
+
+        let Some(SubgraphAssignment {
+            handle,
+            subgraph_kind,
+        }) = self.assignments.take(&loc)
+        else {
+            debug!(logger, "Subgraph is not started");
+            return;
+        };
+
+        handle.abort();
+        self.count_metrics.deployment_count.dec();
+
+        let Some(subgraph_kind) = subgraph_kind else {
+            debug!(logger, "Unknown subgraph kind");
+            return;
+        };
+
+        let Some(instance_manager) = self.instance_managers.get(&subgraph_kind) else {
+            debug!(logger, "Missing instance manager");
+            return;
+        };
+
+        instance_manager.stop_subgraph(loc).await;
+        debug!(logger, "Subgraph stopped");
+    }
+}
+
+/// Enumerates all possible errors of the subgraph provider.
+#[derive(Debug, thiserror::Error)]
+enum Error {
+    #[error("failed to load manifest for '{loc}': {source:#}")]
+    LoadManifest {
+        loc: DeploymentLocator,
+        source: subgraph_manifest::Error,
+    },
+
+    #[error("failed to get instance manager for '{loc}' with kind '{subgraph_kind}'")]
+    GetManager {
+        loc: DeploymentLocator,
+        subgraph_kind: SubgraphProcessingKind,
+    },
+}
+
+/// Contains a mapping of enabled subgraph instance managers by subgraph processing kinds.
+///
+/// Before starting a subgraph, its processing kind is determined from the subgraph manifest.
+/// Then, the appropriate instance manager is loaded from this mapping.
+#[derive(Default)]
+pub struct SubgraphInstanceManagers(
+    HashMap<SubgraphProcessingKind, Arc<dyn SubgraphInstanceManager>>,
+);
+
+impl SubgraphInstanceManagers {
+    /// Creates a new empty subgraph instance manager mapping.
+    pub fn new() -> Self {
+        Self(HashMap::new())
+    }
+
+    /// Adds a new subgraph instance manager for all subgraphs of the specified processing kind.
+    pub fn add(
+        &mut self,
+        subgraph_kind: SubgraphProcessingKind,
+        instance_manager: Arc<dyn SubgraphInstanceManager>,
+    ) {
+        self.0.insert(subgraph_kind, instance_manager);
+    }
+
+    /// Returns the subgraph instance manager for the specified processing kind.
+    pub fn get(
+        &self,
+        subgraph_kind: &SubgraphProcessingKind,
+    ) -> Option<Arc<dyn SubgraphInstanceManager>> {
+        self.0
+            .get(subgraph_kind)
+            .map(|instance_manager| instance_manager.cheap_clone())
+    }
+}
+
+/// Enumerates the supported subgraph processing kinds.
+///
+/// Subgraphs may have different processing requirements, and this enum helps to map them
+/// to the appropriate instance managers.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display)]
+#[strum(serialize_all = "snake_case")]
+pub enum SubgraphProcessingKind {
+    /// Represents trigger-based subgraphs.
+    Trigger,
+
+    /// Represents Amp-powered subgraphs.
+    Amp,
+}
+
+impl SubgraphProcessingKind {
+    /// Determines the subgraph processing kind from the subgraph manifest.
+    fn from_manifest(raw_manifest: &serde_yaml::Mapping) -> Self {
+        use serde_yaml::Value;
+
+        let is_amp_manifest = raw_manifest
+            .get("dataSources")
+            .and_then(Value::as_sequence)
+            .and_then(|seq| {
+                seq.iter()
+                    .filter_map(Value::as_mapping)
+                    .filter_map(|map| map.get("kind"))
+                    .filter_map(Value::as_str)
+                    .find(|kind| *kind == amp::manifest::DataSource::KIND)
+            })
+            .is_some();
+
+        if is_amp_manifest {
+            return Self::Amp;
+        }
+
+        Self::Trigger
+    }
+}
+
+/// Maintains a list of started subgraph deployments with details required for stopping them.
+struct SubgraphAssignments(RwLock<HashMap<DeploymentLocator, SubgraphAssignment>>);
+
+impl SubgraphAssignments {
+    /// Creates a new empty list of started subgraph deployments.
+    fn new() -> Self {
+        Self(RwLock::new(HashMap::new()))
+    }
+
+    /// Adds a new subgraph deployment to the list of started subgraph deployments.
+    fn add(&self, loc: DeploymentLocator, subgraph_assignment: SubgraphAssignment) {
+        self.0.write().insert(loc, subgraph_assignment);
+    }
+
+    /// Updates the started subgraph deployment with the specified subgraph processing kind.
+    fn set_subgraph_kind(&self, loc: &DeploymentLocator, subgraph_kind: SubgraphProcessingKind) {
+        if let Some(subgraph_assignment) = self.0.write().get_mut(loc) {
+            subgraph_assignment.subgraph_kind = Some(subgraph_kind);
+        }
+    }
+
+    /// Checks if the subgraph deployment is started.
+    fn is_assigned(&self, loc: &DeploymentLocator) -> bool {
+        self.0.read().contains_key(loc)
+    }
+
+    /// Removes the subgraph deployment from the list of started subgraph deployments and returns its details.
+    fn take(&self, loc: &DeploymentLocator) -> Option<SubgraphAssignment> {
+        self.0.write().remove(loc)
+    }
+}
+
+/// Contains the details of a started subgraph deployment.
+struct SubgraphAssignment {
+    /// The handle to the background task that starts this subgraph deployment.
+    handle: tokio::task::JoinHandle<()>,
+
+    /// The subgraph processing kind of this subgraph deployment.
+    ///
+    /// Used to get the appropriate subgraph instance manager to forward the stop request to.
+    ///
+    /// Set to `None` until the subgraph manifest is loaded and parsed.
+    subgraph_kind: Option<SubgraphProcessingKind>,
+}
diff --git a/docker/Dockerfile b/docker/Dockerfile
index 0044c6b7812..29d8e142db0 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -4,7 +4,7 @@
 # by running something like the following
 #   docker build --target STAGE -f docker/Dockerfile .
 
-FROM golang:bullseye as envsubst
+FROM golang:bookworm AS envsubst
 
 # v1.2.0
 ARG ENVSUBST_COMMIT_SHA=16035fe3571ad42c7796bf554f978bb2df64231b
@@ -13,7 +13,7 @@ ARG ENVSUBST_COMMIT_SHA=16035fe3571ad42c7796bf554f978bb2df64231b
 RUN go install github.com/a8m/envsubst/cmd/envsubst@$ENVSUBST_COMMIT_SHA \
     && strip -g /go/bin/envsubst
 
-FROM rust:bullseye as graph-node-build
+FROM rust:bookworm AS graph-node-build
 
 ARG COMMIT_SHA=unknown
 ARG REPO_NAME=unknown
@@ -22,20 +22,18 @@ ARG TAG_NAME=unknown
 
 ADD . /graph-node
 
-RUN apt-get update \
-    && apt-get install -y cmake protobuf-compiler && \
-    cd /graph-node && \
-    RUSTFLAGS="-g" cargo build --release --package graph-node \
+RUN apt-get update && apt-get install -y cmake protobuf-compiler
+
+RUN cd /graph-node \
+    && RUSTFLAGS="-g -C force-frame-pointers=yes" cargo build --release --package graph-node \
     && cp target/release/graph-node /usr/local/bin/graph-node \
     && cp target/release/graphman /usr/local/bin/graphman \
-    # Reduce the size of the layer by removing unnecessary files.
     && cargo clean \
-    && objcopy --only-keep-debug /usr/local/bin/graph-node /usr/local/bin/graph-node.debug \
-    && strip -g /usr/local/bin/graph-node \
-    && strip -g /usr/local/bin/graphman \
-    && cd /usr/local/bin \
-    && objcopy --add-gnu-debuglink=graph-node.debug graph-node \
-    && echo "REPO_NAME='$REPO_NAME'" > /etc/image-info \
+    && cp /usr/local/bin/graph-node /usr/local/bin/graph-node-debug \
+    && cp /usr/local/bin/graphman /usr/local/bin/graphman-debug \
+    && strip -g /usr/local/bin/graph-node /usr/local/bin/graphman
+
+RUN echo "REPO_NAME='$REPO_NAME'" > /etc/image-info \
     && echo "TAG_NAME='$TAG_NAME'" >> /etc/image-info \
     && echo "BRANCH_NAME='$BRANCH_NAME'" >> /etc/image-info \
     && echo "COMMIT_SHA='$COMMIT_SHA'" >> /etc/image-info \
@@ -43,49 +41,41 @@ RUN apt-get update \
     && echo "RUST_VERSION='$(rustc --version)'" >> /etc/image-info \
     && echo "CARGO_DEV_BUILD='$CARGO_DEV_BUILD'" >> /etc/image-info
 
-# Debug image to access core dumps
-FROM graph-node-build as graph-node-debug
-RUN apt-get update \
-    && apt-get install -y curl gdb postgresql-client
-
-COPY docker/Dockerfile /Dockerfile
-COPY docker/bin/* /usr/local/bin/
-
 # The graph-node runtime image with only the executable
-FROM debian:bullseye-slim as graph-node
-ENV RUST_LOG ""
-ENV GRAPH_LOG ""
-ENV EARLY_LOG_CHUNK_SIZE ""
-ENV ETHEREUM_RPC_PARALLEL_REQUESTS ""
-ENV ETHEREUM_BLOCK_CHUNK_SIZE ""
-
-ENV postgres_host ""
-ENV postgres_user ""
-ENV postgres_pass ""
-ENV postgres_db ""
-ENV postgres_args "sslmode=prefer"
+FROM debian:bookworm-20241111-slim AS graph-node
+ENV RUST_LOG=""
+ENV GRAPH_LOG=""
+ENV EARLY_LOG_CHUNK_SIZE=""
+ENV ETHEREUM_RPC_PARALLEL_REQUESTS=""
+ENV ETHEREUM_BLOCK_CHUNK_SIZE=""
+
+ENV postgres_host=""
+ENV postgres_user=""
+ENV postgres_pass=""
+ENV postgres_db=""
+ENV postgres_args="sslmode=prefer"
 # The full URL to the IPFS node
-ENV ipfs ""
+ENV ipfs=""
 # The etherum network(s) to connect to. Set this to a space-separated
 # list of the networks where each entry has the form NAME:URL
-ENV ethereum ""
+ENV ethereum=""
 # The role the node should have, one of index-node, query-node, or
 # combined-node
-ENV node_role "combined-node"
+ENV node_role="combined-node"
 # The name of this node
-ENV node_id "default"
+ENV node_id="default"
 # The ethereum network polling interval  (in milliseconds)
-ENV ethereum_polling_interval ""
+ENV ethereum_polling_interval=""
 
 # The location of an optional configuration file for graph-node, as
 # described in ../docs/config.md
 # Using a configuration file is experimental, and the file format may
 # change in backwards-incompatible ways
-ENV GRAPH_NODE_CONFIG ""
+ENV GRAPH_NODE_CONFIG=""
 
 # Disable core dumps; this is useful for query nodes with large caches. Set
 # this to anything to disable coredumps (via 'ulimit -c 0')
-ENV disable_core_dumps ""
+ENV disable_core_dumps=""
 
 # HTTP port
 EXPOSE 8000
@@ -97,7 +87,7 @@ EXPOSE 8020
 EXPOSE 8030
 
 RUN apt-get update \
-    && apt-get install -y libpq-dev ca-certificates netcat
+    && apt-get install -y libpq-dev ca-certificates netcat-openbsd
 
 ADD docker/wait_for docker/start /usr/local/bin/
 COPY --from=graph-node-build /usr/local/bin/graph-node /usr/local/bin/graphman /usr/local/bin/
@@ -105,3 +95,13 @@ COPY --from=graph-node-build /etc/image-info /etc/image-info
 COPY --from=envsubst /go/bin/envsubst /usr/local/bin/
 COPY docker/Dockerfile /Dockerfile
 CMD ["start"]
+
+# Debug and profiling image
+# Build with: docker build --target graph-node-debug -f docker/Dockerfile .
+FROM graph-node AS graph-node-debug
+COPY --from=graph-node-build /usr/local/bin/graph-node-debug /usr/local/bin/graph-node
+COPY --from=graph-node-build /usr/local/bin/graphman-debug /usr/local/bin/graphman
+RUN apt-get update \
+    && apt-get install -y curl gdb postgresql-client linux-perf procps binutils
+COPY docker/Dockerfile /Dockerfile
+COPY docker/bin/* /usr/local/bin/
diff --git a/docker/README.md b/docker/README.md
index af95f4bbd52..6ea02f70b0f 100644
--- a/docker/README.md
+++ b/docker/README.md
@@ -1,34 +1,9 @@
-# Graph Node Docker Image
+# Running prebuilt `graph-node` images
 
-Preconfigured Docker image for running a Graph Node.
-
-## Usage
-
-```sh
-docker run -it \
-  -e postgres_host=<HOST> \
-  -e postgres_port=<PORT> \
-  -e postgres_user=<USER> \
-  -e postgres_pass=<PASSWORD> \
-  -e postgres_db=<DBNAME> \
-  -e ipfs=<HOST>:<PORT> \
-  -e ethereum=<NETWORK_NAME>:<ETHEREUM_RPC_URL> \
-  graphprotocol/graph-node:latest
-```
-
-### Example usage
-
-```sh
-docker run -it \
-  -e postgres_host=host.docker.internal \
-  -e postgres_port=5432 \
-  -e postgres_user=graph-node \
-  -e postgres_pass=oh-hello \
-  -e postgres_db=graph-node \
-  -e ipfs=host.docker.internal:5001 \
-  -e ethereum=mainnet:http://localhost:8545/ \
-  graphprotocol/graph-node:latest
-```
+You can run the `graph-node` docker image either in a [complete
+setup](#docker-compose) controlled by Docker Compose, or, if you already
+have an IPFS and Postgres server, [by
+itself](#running-with-existing-ipfs-and-postgres).
 
 ## Docker Compose
 
@@ -77,3 +52,17 @@ docker rmi graphprotocol/graph-node:latest
 # Tag the newly created image
 docker tag graph-node graphprotocol/graph-node:latest
 ```
+
+## Running with existing IPFS and Postgres
+
+```sh
+docker run -it \
+  -e postgres_host=<HOST> \
+  -e postgres_port=<PORT> \
+  -e postgres_user=<USER> \
+  -e postgres_pass=<PASSWORD> \
+  -e postgres_db=<DBNAME> \
+  -e ipfs=<HOST>:<PORT> \
+  -e ethereum=<NETWORK_NAME>:<ETHEREUM_RPC_URL> \
+  graphprotocol/graph-node:latest
+```
diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml
index 701fc68dacf..c78c2eb2194 100644
--- a/docker/docker-compose.yml
+++ b/docker/docker-compose.yml
@@ -22,13 +22,13 @@ services:
       ethereum: 'mainnet:http://host.docker.internal:8545'
       GRAPH_LOG: info
   ipfs:
-    image: ipfs/kubo:v0.14.0
+    image: ipfs/kubo:v0.17.0
     ports:
       - '5001:5001'
     volumes:
-      - ./data/ipfs:/data/ipfs
+      - ./data/ipfs:/data/ipfs:Z
   postgres:
-    image: postgres:14
+    image: postgres
     ports:
       - '5432:5432'
     command:
@@ -47,4 +47,4 @@ services:
       PGDATA: "/var/lib/postgresql/data"
       POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C"
     volumes:
-      - ./data/postgres:/var/lib/postgresql/data
+      - ./data/postgres:/var/lib/postgresql/data:Z
diff --git a/docker/tag.sh b/docker/tag.sh
index 032ab54417b..1abafa95afa 100644
--- a/docker/tag.sh
+++ b/docker/tag.sh
@@ -25,4 +25,7 @@ tag_and_push "$SHORT_SHA"
 # Builds for tags vN.N.N become the 'latest'
 [[ "$TAG_NAME" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]] && tag_and_push latest
 
+# If the build is from the master branch, tag it as 'nightly'
+[ "$BRANCH_NAME" = "master" ] && tag_and_push nightly
+
 exit 0
diff --git a/docs/aggregations.md b/docs/aggregations.md
index 77f49b9bceb..3e90d7ee62f 100644
--- a/docs/aggregations.md
+++ b/docs/aggregations.md
@@ -1,10 +1,5 @@
 # Timeseries and aggregations
 
-**This feature is experimental. We very much encourage users to try this
-out, but we might still need to make material changes to what's described
-here in a manner that is not backwards compatible. That might require
-deleting and redeploying any subgraph that uses the features here.**
-
 _This feature is available from spec version 1.1.0 onwards_
 
 ## Overview
@@ -16,13 +11,13 @@ data points are to be aggregated. A very simple aggregation can be declared like
 ```graphql
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
 }
 ```
@@ -33,9 +28,11 @@ populate the `Stats` aggregations whenever a given hour or day ends.
 
 The type for the raw data points is defined with an `@entity(timeseries:
 true)` annotation. Timeseries types are immutable, and must have an `id`
-field and a `timestamp` field. The `timestamp` is set automatically by
-`graph-node` to the timestamp of the current block; if mappings set this
-field, it is silently overridden when the entity is saved.
+field and a `timestamp` field. The `id` must be of type `Int8` and is set
+automatically so that ids are increasing in insertion order. The `timestamp`
+is set automatically by `graph-node` to the timestamp of the current block;
+if mappings set this field, it is silently overridden when the entity is
+saved.
 
 Aggregations are declared with an `@aggregation` annotation instead of an
 `@entity` annotation. They must have an `id` field and a `timestamp` field.
@@ -46,8 +43,6 @@ for example, to the beginning of the hour for an hourly aggregation. The
 the aggregation. Which one is chosen is not specified and should not be
 relied on.
 
-**TODO**: add a `Timestamp` type and use that for `timestamp`
-
 **TODO**: figure out whether we should just automatically add `id` and
 `timestamp` and have validation just check that these fields don't exist
 
@@ -63,7 +58,7 @@ type Token @entity { .. }
 # Raw data points
 type TokenData @entity(timeseries: true) {
     id: Bytes!
-    timestamp: Int8!
+    timestamp: Timestamp!
     token: Token!
     amount: BigDecimal!
     priceUSD: BigDecimal!
@@ -72,11 +67,11 @@ type TokenData @entity(timeseries: true) {
 # Aggregations over TokenData
 type TokenStats @aggregation(intervals: ["hour", "day"], source: "TokenData") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   totalVolume: BigDecimal! @aggregate(fn: "sum", arg: "amount")
   priceUSD: BigDecimal! @aggregate(fn: "last", arg: "priceUSD")
-  count: Int8! @aggregate(fn: "count")
+  count: Int8! @aggregate(fn: "count", cumulative: true)
 }
 ```
 
@@ -85,31 +80,25 @@ _dimensions_, and fields with the `@aggregate` directive are called
 _aggregates_. A timeseries type really represents many timeseries, one for
 each combination of values for the dimensions.
 
-**TODO** As written, this supports buckets that start at zero with every new
-hour/day. We also want to support cumulative statistics, i.e., snapshotting
-of time series where a new bucket starts with the values of the previous
-bucket.
-
-**TODO** Since average is a little more complicated to handle for cumulative
-aggregations, and it doesn't seem like it used in practice, we won't
-initially support it. (same for variance, stddev etc.)
-
-**TODO** The timeseries type can be simplified for some situations if
-aggregations can be done over expressions, for example over `priceUSD *
-amount` to track `totalVolumeUSD`
+The same timeseries can be used for multiple aggregations. For example, the
+`Stats` aggregation could also be formed by aggregating over the `TokenData`
+timeseries. Since `Stats` doesn't have a `token` dimension, all aggregates
+will be formed across all tokens.
 
-**TODO** It might be necessary to allow `@aggregate` fields that are only
-used for some intervals. We could allow that with syntax like
-`@aggregate(fn: .., arg: .., interval: "day")`
+Each `@aggregate` by default starts at 0 for each new bucket and therefore
+just aggregates over the time interval for the bucket. The `@aggregate`
+directive also accepts a boolean flag `cumulative` that indicates whether
+the aggregation should be cumulative. Cumulative aggregations aggregate over
+the entire timeseries up to the end of the time interval for the bucket.
 
 ## Specification
 
 ### Timeseries
 
 A timeseries is an entity type with the annotation `@entity(timeseries:
-true)`. It must have an `id` attribute and a `timestamp` attribute of type
-`Int8`. It must not also be annotated with `immutable: false` as timeseries
-are always immutable.
+true)`. It must have an `id` attribute of type `Int8` and a `timestamp`
+attribute of type `Timestamp`. It must not also be annotated with
+`immutable: false` as timeseries are always immutable.
 
 ### Aggregations
 
@@ -121,15 +110,18 @@ must have two arguments:
 - `source`: the name of a timeseries type. Aggregates are computed based on
   the attributes of the timeseries type.
 
-The aggregation type must have an `id` attribute and a `timestamp` attribute
-of type `Int8`.
+The aggregation type must have an `id` attribute of type `Int8` and a
+`timestamp` attribute of type `Timestamp`.
 
 The aggregation type must have at least one attribute with the `@aggregate`
 annotation. These attributes must be of a numeric type (`Int`, `Int8`,
 `BigInt`, or `BigDecimal`) The annotation must have two arguments:
 
 - `fn`: the name of an aggregation function
-- `arg`: the name of an attribute in the timeseries type
+- `arg`: the name of an attribute in the timeseries type, or an expression
+  using only constants and attributes of the timeseries type
+
+#### Aggregation functions
 
 The following aggregation functions are currently supported:
 
@@ -142,15 +134,42 @@ The following aggregation functions are currently supported:
 | `first` | First value       |
 | `last`  | Last value        |
 
-## Querying
+The `first` and `last` aggregation function calculate the first and last
+value in an interval by sorting the data by `id`; `graph-node` enforces
+correctness here by automatically setting the `id` for timeseries entities.
+
+#### Aggregation expressions
 
-_This section is not implemented yet, and will require a bit more thought
-about details_
+The `arg` can be the name of any attribute in the timeseries type, or an
+expression using only constants and attributes of the timeseries type such
+as `price * amount` or `greatest(amount0, amount1)`. Expressions use SQL
+syntax and support a subset of builtin SQL functions, operators, and other
+constructs.
 
-**TODO** As written, timeseries points like `TokenData` can be queried like
-any other entity. It would be nice to restrict how these data points can be
-queried, maybe even forbid it, as that would give us more latitude in how we
-store that data.
+Supported operators are `+`, `-`, `*`, `/`, `%`, `^`, `=`, `!=`, `<`, `<=`,
+`>`, `>=`, `<->`, `and`, `or`, and `not`. In addition the operators `is
+[not] {null|true|false}`, and `is [not] distinct from` are supported.
+
+The supported SQL functions are the [math
+functions](https://www.postgresql.org/docs/current/functions-math.html)
+`abs`, `ceil`, `ceiling`, `div`, `floor`, `gcd`, `lcm`, `mod`, `power`,
+`sign`, and the [conditional
+functions](https://www.postgresql.org/docs/current/functions-conditional.html)
+`coalesce`, `nullif`, `greatest`, and `least`.
+
+The
+[statement](https://www.postgresql.org/docs/current/functions-conditional.html#FUNCTIONS-CASE)
+`case when .. else .. end` is also supported.
+
+Some examples of valid expressions, assuming the underlying timeseries
+contains the mentioned fields:
+
+- Aggregate the value of a token: `@aggregate(fn: "sum", arg: "priceUSD * amount")`
+- Aggregate the maximum positive amount of two different amounts:
+  `@aggregate(fn: "max", arg: "greatest(amount0, amount1, 0)")`
+- Conditionally sum an amount: `@aggregate(fn: "sum", arg: "case when amount0 > amount1 then amount0 else 0 end")`
+
+## Querying
 
 We create a toplevel query field for each aggregation. That query field
 accepts the following arguments:
@@ -159,16 +178,18 @@ accepts the following arguments:
   dimension
 - A mandatory `interval`
 - An optional `current` to indicate whether to include the current,
-  partially filled bucket in the response. Can be either `ignore` (the
+  partially filled bucket in the response. Can be either `exclude` (the
   default) or `include`
-- Optional `timestamp_{gte|gt|lt|lte|eq}` filters to restrict the range of
-  timestamps to return
-- Timeseries are always sorted by the dimensions in the order in which they
-  are declared in the schema and the `timestamp` in descending order
+- Optional `timestamp_{gte|gt|lt|lte|eq|in}` filters to restrict the range
+  of timestamps to return. The timestamp to filter by must be a string
+  containing microseconds since the epoch. The value `"1704164640000000"`
+  corresponds to `2024-01-02T03:04Z`
+- Timeseries are sorted by `timestamp` and `id` in descending order by
+  default
 
 ```graphql
 token_stats(interval: "hour",
-      current: ignore,
+      current: exclude,
       where: {
         token: "0x1234",
         timestamp_gte: 1234567890,
@@ -181,5 +202,52 @@ token_stats(interval: "hour",
 }
 ```
 
-**TODO**: what about time-travel? Is it possible to include a block
-constraint?
+### Current Bucket
+
+By default, aggregation queries return only completed, rolled-up buckets
+(`current: exclude`). These are buckets whose time interval has ended and
+whose data has been fully aggregated by `graph-node`'s rollup process.
+
+Setting `current: include` adds an additional, partially filled bucket that
+is computed on-the-fly from the unrolled timeseries data that has been
+inserted since the last rollup. This current bucket aggregates raw data
+points from the source timeseries table that have not yet been rolled up
+into the aggregation table. It covers the time period from the end of the
+last completed bucket up to the most recent data point.
+
+- `current: exclude` (default) — return only completed, rolled-up buckets
+- `current: include` — also return the in-progress bucket computed from
+  unrolled source data
+
+The current bucket is useful when you need near-real-time aggregation data
+without waiting for the next rollup cycle to complete.
+
+#### Nested Aggregation Queries
+
+The `current` argument also works on nested aggregation fields accessed
+through a parent entity. For example, if a `Token` entity has a derived
+aggregation field `tokenStats`, you can query the current bucket for each
+token:
+
+```graphql
+{
+  tokens {
+    id
+    name
+    tokenStats(interval: "hour", current: include) {
+      timestamp
+      totalVolume
+    }
+  }
+}
+```
+
+This returns both the completed rolled-up hourly buckets and the current
+in-progress bucket for each token's stats.
+
+#### Limitations
+
+Current bucket support for nested aggregation fields is only available when
+the field references a single aggregation type. It is not supported when the
+aggregation field is accessed through an interface with multiple
+implementations.
diff --git a/docs/amp-powered-subgraphs.md b/docs/amp-powered-subgraphs.md
new file mode 100644
index 00000000000..60bccdde449
--- /dev/null
+++ b/docs/amp-powered-subgraphs.md
@@ -0,0 +1,582 @@
+# Amp-powered subgraphs
+
+> [!WARNING]
+> This feature is experimental and may change in future releases.
+
+> [!NOTE]
+> This feature is available starting from spec version `1.5.0`
+
+Amp-powered subgraphs are a new kind of subgraphs with SQL data sources that query and index data from the Amp servers.
+They are significantly more efficient than the standard subgraphs, and the indexing time can be reduced from days and weeks,
+to minutes and hours in most cases.
+
+## Prerequisites
+
+To enable Amp-powered subgraphs, the `GRAPH_AMP_FLIGHT_SERVICE_ADDRESS` ENV variable must be set to a valid Amp Flight gRPC service address.
+
+Additionally, if authentication is required for the Amp Flight gRPC service, the `GRAPH_AMP_FLIGHT_SERVICE_TOKEN` ENV variable must contain a valid authentication token.
+
+## Subgraph manifest
+
+Amp-powered subgraphs introduce a new structure for defining Amp subgraph data sources within the manifest.
+
+### Spec version
+
+The minimum spec version for Amp-powered subgraphs is `1.5.0`.
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
++ specVersion: 1.5.0
+  dataSources:
+    - kind: amp
+      name: Transfers
+      network: ethereum-mainnet
+      source:
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
+      transformer:
+        apiVersion: 0.0.1
+        tables:
+          - name: Transfer
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### Data source structure
+
+### `kind`
+
+Every Amp data source must have the `kind` set to `amp`, and Amp-powered subgraphs must contain only Amp data sources.
+This is used to assign the subgraph to the appropriate indexing process.
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
++   - kind: amp
+      name: Transfers
+      network: ethereum-mainnet
+      source:
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
+      transformer:
+        apiVersion: 0.0.1
+        tables:
+          - name: Transfer
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### `name`
+
+Every Amp data source must have the `name` set to a non-empty string, containing only numbers, letters, hypens, or underscores.
+This name is used for observability purposes and to identify progress and potential errors produced by the data source.
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
++     name: Transfers
+      network: ethereum-mainnet
+      source:
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
+      transformer:
+        apiVersion: 0.0.1
+        tables:
+          - name: Transfer
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### `network`
+
+Every Amp data source must have the `network` field set to a valid network name.
+This is used to validate that the SQL queries for this data source produce results for the expected network.
+
+> [!NOTE]
+> Currently, the SQL queries are required to produce results for a single network in order to maintain compatibility with non-Amp subgraphs.
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Transfers
++     network: ethereum-mainnet
+      source:
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
+      transformer:
+        apiVersion: 0.0.1
+        tables:
+          - name: Transfer
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### `source`
+
+Every Amp data source must have a valid `source` that describes the behavior of SQL queries from this data source.
+
+### `source.dataset`
+
+Contains the name of the dataset that can be queried by SQL queries in this data source.
+This is used to validate that the SQL queries for this data source only query the expected dataset.
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Transfers
+      network: ethereum-mainnet
++     source:
++       dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
+      transformer:
+        apiVersion: 0.0.1
+        tables:
+          - name: Transfer
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### `source.tables`
+
+Contains the names of the tables that can be queried by SQL queries in this data source.
+This is used to validate that the SQL queries for this data source only query the expected tables.
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Transfers
+      network: ethereum-mainnet
++     source:
+        dataset: edgeandnode/ethereum_mainnet
++       tables:
++         - blocks
++         - transactions
+      transformer:
+        apiVersion: 0.0.1
+        tables:
+          - name: Transfer
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### Optional `source.address`
+
+Contains the contract address with which SQL queries in the data source interact.
+
+Enables SQL query reuse through `sg_source_address()` calls instead of hard-coding the contract address.
+SQL queries resolve `sg_source_address()` calls to this contract address.
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Transfers
+      network: ethereum-mainnet
++     source:
++       address: "0xc944E90C64B2c07662A292be6244BDf05Cda44a7"
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
+      transformer:
+        apiVersion: 0.0.1
+        tables:
+          - name: Transfer
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### Optional `source.startBlock`
+
+Contains the minimum block number that SQL queries in the data source can query.
+This is used as a starting point for the indexing process.
+
+_When not provided, defaults to block number `0`._
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Transfers
+      network: ethereum-mainnet
++     source:
++       startBlock: 11446769
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
+      transformer:
+        apiVersion: 0.0.1
+        tables:
+          - name: Transfer
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### Optional `source.endBlock`
+
+Contains the maximum block number that SQL queries in the data source can query.
+Reaching this block number will complete the indexing process.
+
+_When not provided, defaults to the maximum possible block number._
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Transfers
+      network: ethereum-mainnet
++     source:
++       endBlock: 23847939
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
+      transformer:
+        apiVersion: 0.0.1
+        tables:
+          - name: Transfer
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### `transformer`
+
+Every Amp data source must have a valid `transformer` that describes the transformations of source tables indexed by the Amp-powered subgraph.
+
+### `transformer.apiVersion`
+
+Represents the version of this transformer. Each version may contain a different set of features.
+
+> [!NOTE]
+> Currently, only the version `0.0.1` is available.
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Transfers
+      network: ethereum-mainnet
+      source:
+        endBlock: 23847939
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
++     transformer:
++       apiVersion: 0.0.1
+        tables:
+          - name: Transfers
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### Optional `transformer.abis`
+
+Contains a list of ABIs that SQL queries can reference to extract event signatures.
+
+Enables the use of `sg_event_signature('CONTRACT_NAME', 'EVENT_NAME')` calls in the
+SQL queries which are resolved to full event signatures based on this list.
+
+_When not provided, defaults to an empty list._
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Transfers
+      network: ethereum-mainnet
+      source:
+        endBlock: 23847939
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
++     transformer:
++       abis:
++         - name: ERC721 # The name of the contract
++           file: <IPFS CID of the JSON ABI file>
+        apiVersion: 0.0.1
+        tables:
+          - name: Transfer
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### `transformer.tables`
+
+Contains a list of transformed tables that extract data from source tables into subgraph entities.
+
+### Transformer table structure
+
+### `transformer.tables[i].name`
+
+Represents the name of the transformed table. Must reference a valid entity name from the subgraph schema.
+
+<details>
+<summary>Example:</summary>
+
+**GraphQL schema:**
+
+```graphql
+type Block @entity(immutable: true) {
+    # .. entity fields ...
+}
+```
+
+**YAML manifest:**
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Blocks
+      network: ethereum-mainnet
+      source:
+        endBlock: 23847939
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
++     transformer:
+        apiVersion: 0.0.1
++       tables:
++         - name: Block
+            file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### `transformer.tables[i].query`
+
+Contains an inline SQL query that executes on the Amp server.
+This is useful for simple SQL queries like `SELECT * FROM "edgeandnode/ethereum_mainnet".blocks;`.
+For more complex cases, a separate file containing the SQL query can be used in the `file` field.
+
+The data resulting from this SQL query execution transforms into subgraph entities.
+
+_When not provided, the `file` field is used instead._
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Blocks
+      network: ethereum-mainnet
+      source:
+        endBlock: 23847939
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
++     transformer:
+        apiVersion: 0.0.1
++       tables:
+          - name: Block
++           query: SELECT * FROM "edgeandnode/ethereum_mainnet".blocks;
+```
+
+</details>
+
+### `transformer.tables[i].file`
+
+Contains the IPFS link to the SQL query that executes on the Amp server.
+
+The data resulting from this SQL query execution transforms into subgraph entities.
+
+_Ignored when the `query` field is provided._
+_When not provided, the `query` field is used instead._
+
+<details>
+<summary>Example YAML:</summary>
+
+```diff
+  specVersion: 1.5.0
++ dataSources:
+    - kind: amp
+      name: Blocks
+      network: ethereum-mainnet
+      source:
+        endBlock: 23847939
+        dataset: edgeandnode/ethereum_mainnet
+        tables:
+          - blocks
+          - transactions
++     transformer:
+        apiVersion: 0.0.1
++       tables:
+          - name: Block
++           file: <IPFS CID of the SQL query file>
+```
+
+</details>
+
+### Amp-powered subgraph examples
+
+Complete examples on how to create, deploy and query Amp-powered subgraphs are available in a separate repository:
+https://github.com/edgeandnode/amp-subgraph-examples
+
+## SQL query requirements
+
+### Names
+
+The names of tables, columns, and aliases must not start with `amp_` as this
+prefix is reserved for internal use.
+
+### Block numbers
+
+Every SQL query in Amp-powered subgraphs must return the block number for every row.
+This is required because subgraphs rely on this information for storing subgraph entities.
+
+Graph-node will look for block numbers in the following columns:
+`_block_num`, `block_num`, `blockNum`, `block`, `block_number`, `blockNumber`.
+
+Example SQL query: `SELECT _block_num, /* .. other projections .. */ FROM "edgeandnode/ethereum_mainnet".blocks;`
+
+### Block hashes
+
+Every SQL query in Amp-powered subgraphs is expected to return the block hash for every row.
+This is required because subgraphs rely on this information for storing subgraph entities.
+
+When a SQL query does not have the block hash projection, graph-node will attempt to get it from the
+source tables specified in the subgraph manifest.
+
+Graph-node will look for block hashes in the following columns:
+`hash`, `block_hash`, `blockHash`.
+
+Example SQL query: `SELECT hash, /* .. other projections .. */ FROM "edgeandnode/ethereum_mainnet".blocks;`
+
+> [!NOTE]
+> If a table does not contain the block hash column, it can be retrieved by joining that table with another that contains the column on the `_block_num` column.
+
+### Block timestamps
+
+> [!NOTE]
+> Only required for Amp-powered subgraphs that use subgraph aggregations.
+
+Every SQL query in Amp-powered subgraphs is expected to return the block timestamps for every row.
+This is required because subgraphs rely on this information for storing subgraph entities.
+
+When a SQL query does not have the block timestamps projection, graph-node will attempt to get it from the
+source tables specified in the subgraph manifest.
+
+Graph-node will look for block timestamps in the following columns:
+`timestamp`, `block_timestamp`, `blockTimestamp`.
+
+Example SQL query: `SELECT timestamp, /* .. other projections .. */ FROM "edgeandnode/ethereum_mainnet".blocks;`
+
+> [!NOTE]
+> If a table does not contain the block timestamp column, it can be retrieved by joining that table with another that contains the column on the `_block_num` column.
+
+## Type conversions
+
+Amp core SQL data types are converted intuitively to compatible subgraph entity types.
+
+## Schema generation
+
+Amp-powered subgraphs support the generation of GraphQL schemas based on the schemas of SQL queries referenced in the subgraph manifest.
+This is useful when indexing entities that do not rely on complex relationships, such as contract events.
+
+The generated subgraph entities are immutable.
+
+To enable schema generation, simply remove the `schema` field from the subgraph manifest.
+
+> [!NOTE]
+> For more flexibility and control over the schema, a manually created GraphQL schema is preferred.
+
+## Aggregations
+
+Amp-powered subgraphs fully support the subgraph aggregations feature.
+This allows having complex aggregations on top of data indexed from the Amp servers.
+
+For more information on using the powerful subgraph aggregations feature,
+refer to the [documentation](https://github.com/graphprotocol/graph-node/blob/master/docs/aggregations.md).
+
+## Composition
+
+Amp-powered subgraphs fully support the subgraph composition feature.
+This allows applying complex subgraph mappings on top of data indexed from the Amp servers.
+
+For more information on using the powerful subgraph composition feature,
+refer to the [documentation](https://github.com/graphprotocol/example-composable-subgraph).
+
+## ENV variables
+
+Amp-powered subgraphs feature introduces the following new ENV variables:
+
+- `GRAPH_AMP_FLIGHT_SERVICE_ADDRESS` – The address of the Amp Flight gRPC service. _Defaults to `None`, which disables support for Amp-powered subgraphs._
+- `GRAPH_AMP_FLIGHT_SERVICE_TOKEN` – Token used to authenticate Amp Flight gRPC service requests. _Defaults to `None`, which disables authentication._
+- `GRAPH_AMP_BUFFER_SIZE` – Maximum number of response batches to buffer in memory per stream for each SQL query. _Defaults to `1,000`._
+- `GRAPH_AMP_BLOCK_RANGE` – Maximum number of blocks to request per stream for each SQL query. _Defaults to `100,000`._
+- `GRAPH_AMP_QUERY_RETRY_MIN_DELAY_SECONDS` – Minimum time to wait before retrying a failed SQL query to the Amp server. _Defaults to `1` second._
+- `GRAPH_AMP_QUERY_RETRY_MAX_DELAY_SECONDS` – Maximum time to wait before retrying a failed SQL query to the Amp server. _Defaults to `600` seconds._
+
+## Metrics
+
+In addition to reporting updates to the existing `deployment_status`, `deployment_head`, `deployment_synced` and `deployment_blocks_processed_count`
+metrics, Amp-powered subgraphs feature introduces the following new metrics:
+
+- `deployment_target` – Tracks the maximum block number currently available for indexing within a deployment.
+- `deployment_indexing_duration_seconds` – Tracks the total duration in seconds of deployment indexing.
+
+Additionally, the `deployment_sync_secs` is extended with new sections specific to the Amp indexing process.
diff --git a/docs/config.md b/docs/config.md
index 0a6c3536da4..db5fc083a5f 100644
--- a/docs/config.md
+++ b/docs/config.md
@@ -5,12 +5,11 @@ CLI. The location of the file is passed with the `--config` command line switch.
 configuration file, it is not possible to use the options `--postgres-url`,
 `--postgres-secondary-hosts`, and `--postgres-host-weights`.
 
-The TOML file consists of four sections:
+The TOML file consists of three sections:
 
-- `[chains]` sets the endpoints to blockchain clients.
-- `[store]` describes the available databases.
-- `[ingestor]` sets the name of the node responsible for block ingestion.
-- `[deployment]` describes how to place newly deployed subgraphs.
+- [`[chains]`](#configuring-chains) lists the available chains and how to access them.
+- [`[store]`](#configuring-multiple-databases) describes the available databases.
+- [`[deployment]`](#controlling-deployment) describes how to place newly deployed subgraphs.
 
 Some of these sections support environment variable expansion out of the box,
 most notably Postgres connection strings. The official `graph-node` Docker image
@@ -100,48 +99,162 @@ time the configuration is changed to make sure that the connection pools
 are what is expected. Here, `$all_nodes` should be a list of all the node
 names that will use this configuration file.
 
-## Configuring Ethereum Providers
+## Configuring Chains
 
-The `[chains]` section controls the ethereum providers that `graph-node`
+The `[chains]` section controls the providers that `graph-node`
 connects to, and where blocks and other metadata for each chain are
-stored. The section consists of the name of the node doing block ingestion
-(currently not used), and a list of chains. The configuration for a chain
-`name` is specified in the section `[chains.<name>]`, and consists of the
-`shard` where chain data is stored and a list of providers for that
-chain. For each provider, the following information must be given:
-
-- `label`: a label that is used when logging information about that
-  provider (not implemented yet)
+stored. The section consists of the name of the node responsible for block
+ingestion and a list of chains. Block ingestion only runs on the node
+whose `--node-id` matches the `ingestor` value. The
+`--disable-block-ingestor` flag (or `DISABLE_BLOCK_INGESTOR` env var)
+acts as a hard override that always prevents ingestion regardless of
+the config.
+
+The section-level setting `cache_size` controls the default number of
+blocks from the chain head for which block data is kept cached. Individual
+chains can override this value. The default is 500. When the environment
+variable `GRAPH_STORE_IGNORE_BLOCK_CACHE` is set, blocks older than
+`cache_size` are treated as if they have no data. The value must be greater
+than the reorg threshold.
+
+The configuration for a chain `name` is specified in the section
+`[chains.<name>]`, with the following:
+
+- `shard`: where chain data is stored
+- `protocol`: the protocol type being indexed, default `ethereum`
+  (alternatively `near`, `cosmos`,`arweave`,`starknet`)
+- `amp`: the network name used by AMP for this chain; defaults to the chain name.
+  Set this when AMP uses a different name than graph-node (e.g., `amp = "ethereum-mainnet"`
+  on a chain named `mainnet`).
+- `cache_size`: number of blocks from the chain head for which to keep
+  block data cached. Defaults to the section-level `cache_size`.
+- `provider`: a list of providers for that chain
+
+Additionally, Ethereum chains support per-chain RPC tuning settings. When
+omitted, each setting falls back to its corresponding environment variable
+default (see [environment-variables.md](environment-variables.md) for
+details):
+
+- `polling_interval`: block ingestor polling interval in milliseconds.
+  Default: `ETHEREUM_POLLING_INTERVAL` (1000ms).
+- `json_rpc_timeout`: timeout for JSON-RPC requests in seconds.
+  Default: `GRAPH_ETHEREUM_JSON_RPC_TIMEOUT` (180s).
+- `request_retries`: number of times to retry failed JSON-RPC requests.
+  Default: `GRAPH_ETHEREUM_REQUEST_RETRIES` (10).
+- `max_block_range_size`: maximum number of blocks to scan for triggers per
+  request. Default: `GRAPH_ETHEREUM_MAX_BLOCK_RANGE_SIZE` (1000).
+- `block_batch_size`: number of blocks to request in parallel.
+  Default: `ETHEREUM_BLOCK_BATCH_SIZE` (10).
+- `block_ptr_batch_size`: number of block pointers to request in parallel.
+  Default: `ETHEREUM_BLOCK_PTR_BATCH_SIZE` (100).
+- `max_event_only_range`: maximum range for `eth_getLogs` requests that
+  don't filter on contract address.
+  Default: `GRAPH_ETHEREUM_MAX_EVENT_ONLY_RANGE` (500).
+- `target_triggers_per_block_range`: ideal number of triggers per batch.
+  Default: `GRAPH_ETHEREUM_TARGET_TRIGGERS_PER_BLOCK_RANGE` (100).
+- `get_logs_max_contracts`: maximum contracts per `eth_getLogs` call.
+  Default: `GRAPH_ETH_GET_LOGS_MAX_CONTRACTS` (2000).
+- `block_ingestor_max_concurrent_json_rpc_calls`: maximum concurrent
+  JSON-RPC calls for transaction receipts during block ingestion.
+  Default: `GRAPH_ETHEREUM_BLOCK_INGESTOR_MAX_CONCURRENT_JSON_RPC_CALLS_FOR_TXN_RECEIPTS` (1000).
+- `genesis_block_number`: genesis block number for this chain.
+  Default: `GRAPH_ETHEREUM_GENESIS_BLOCK_NUMBER` (0).
+
+A `provider` is an object with the following characteristics:
+
+- `label`: the name of the provider, which will appear in logs
+- `details`: provider details
+
+`details` includes the following:
+
+- `type`: one of `web3` (default), `firehose`, or `web3call`
 - `transport`: one of `rpc`, `ws`, and `ipc`. Defaults to `rpc`.
 - `url`: the URL for the provider
 - `features`: an array of features that the provider supports, either empty
-  or any combination of `traces` and `archive`
+  or any combination of the following for Web3 providers:
+  - `traces`: provider supports `debug_traceBlockByNumber` for call tracing
+  - `archive`: provider is an archive node with full historical state
+  - `no_eip1898`: provider doesn't support EIP-1898 (block parameter by hash/number object)
+  - `no_eip2718`: provider doesn't return the `type` field in transaction receipts
+    (pre-EIP-2718 chains). When set, receipts are patched to add
+    `"type": "0x0"` for legacy transaction compatibility.
+  - `compression/<method>`: provider supports compression for RPC requests,
+    where `<method>` is the compression method supported by the provider,
+    one of `gzip`, `brotli`, or `deflate`. The default is no compression.
+
+  For Firehose providers: `compression` and `filters`
+
 - `headers`: HTTP headers to be added on every request. Defaults to none.
 - `limit`: the maximum number of subgraphs that can use this provider.
   Defaults to unlimited. At least one provider should be unlimited,
   otherwise `graph-node` might not be able to handle all subgraphs. The
   tracking for this is approximate, and a small amount of deviation from
   this value should be expected. The deviation will be less than 10.
+- `token`: bearer token, for Firehose providers
+- `key`: API key for Firehose providers when using key-based authentication
+
+Note that for backwards compatibility, Web3 provider `details` can be specified at the "top level" of
+the `provider`.
 
-The following example configures two chains, `mainnet` and `kovan`, where
-blocks for `mainnet` are stored in the `vip` shard and blocks for `kovan`
+The following example configures three chains, `mainnet`, `sepolia` and `near-mainnet`, where
+blocks for `mainnet` are stored in the `vip` shard and blocks for `sepolia`
 are stored in the primary shard. The `mainnet` chain can use two different
-providers, whereas `kovan` only has one provider.
+providers, whereas `sepolia` only has one provider. The `near-mainnet` chain expects data from
+the `near` protocol via a Firehose, where the Firehose offers the `compression` and `filters`
+optimisations.
 
 ```toml
 [chains]
 ingestor = "block_ingestor_node"
+cache_size = 500
 [chains.mainnet]
 shard = "vip"
+amp = "ethereum-mainnet"
+# Per-chain RPC tuning (all optional — omitted fields use env var defaults)
+json_rpc_timeout = 300
+request_retries = 15
+max_block_range_size = 2000
 provider = [
   { label = "mainnet1", url = "http://..", features = [], headers = { Authorization = "Bearer foo" } },
   { label = "mainnet2", url = "http://..", features = [ "archive", "traces" ] }
 ]
-[chains.kovan]
+[chains.sepolia]
 shard = "primary"
-provider = [ { label = "kovan", url = "http://..", features = [] } ]
+provider = [ { label = "sepolia", url = "http://..", features = [] } ]
+
+[chains.near-mainnet]
+shard = "blocks_b"
+protocol = "near"
+provider = [ { label = "near", details = { type = "firehose", url = "https://..", key = "", features = ["compression", "filters"] } } ]
 ```
 
+### Block ingestor failover
+
+When the block ingestor's `do_poll()` call fails (after all internal per-request retries are
+exhausted), `graph-node` automatically attempts to switch to a healthier provider. The logic
+is:
+
+1. **Probe the current provider first.** `do_poll()` can fail for reasons unrelated to RPC
+   availability (e.g. a database error or a chain reorg). If the current provider still
+   responds to `eth_blockNumber`, the failure was not caused by the provider — no switch
+   occurs.
+2. **Probe all alternatives in parallel.** If the current provider is unreachable, all other
+   validated providers are probed simultaneously via `eth_blockNumber` to minimise wait time
+   when providers are timing out.
+3. **Switch to the first reachable provider.** The first provider to respond successfully
+   to the probe is selected as the new provider for the ingestor.
+   The remaining probes are cancelled at this point.
+4. **If all providers are unreachable**, the ingestor stays on the current provider and
+   re-probes on the next `do_poll()` failure.
+
+There is no automatic return to the original provider. Once the ingestor switches, it stays on
+the new provider until that provider fails, at which point the same probe-and-switch logic
+applies.
+
+Only validated providers are eligible as failover candidates. A provider in a temporary failure
+state (e.g. unreachable at startup, pending re-validation) is excluded until it passes
+validation again.
+
 ### Controlling the number of subgraphs using a provider
 
 **This feature is experimental and might be removed in a future release**
diff --git a/docs/dump.md b/docs/dump.md
new file mode 100644
index 00000000000..c8a3d32372b
--- /dev/null
+++ b/docs/dump.md
@@ -0,0 +1,311 @@
+## Dump Format
+
+The `graphman dump` command exports all entity data and metadata for a
+single subgraph deployment into a self-contained directory of Parquet files
+and JSON metadata. The resulting dump can be used to restore the deployment
+into a different `graph-node` instance via `graphman restore`. Dumps are
+consistent snapshots of the deployment's state at a specific point in time.
+
+**WARNING**: The dump and restore commands are experimental and can not
+replace proper database backups at this point. In particular, there is no
+guarantee that a dump will be restorable. Having said that, we encourage
+users to try out the dump and restore commands in non-production
+environments and report any issues they encounter.
+
+**WARNING**: Dumping happens in a single transaction and can put significant
+load on the database for large subgraphs. Use with caution on production
+instances.
+
+**WARNING**: Restoring a dump will currently create all the default indexes
+that a new deployment gets, and ignores the indexes that might have been
+carefully curated for the original deployment, even though they are recorded
+in the dump. This can lead to very long restore times for large subgraphs.
+The restore process will be optimized in the future to only create indexes
+that are present in the dump's metadata.
+
+### Usage
+
+#### Dumping a deployment
+
+```bash
+graphman dump <deployment> <directory>
+```
+
+`<deployment>` identifies the subgraph deployment to dump. It can be a
+subgraph name, a deployment hash (`Qm...`), or a database namespace
+(`sgdNNN`). `<directory>` is the path where the dump will be written; it
+will be created if it does not exist.
+
+Running `graphman dump` against an existing dump directory performs an
+**incremental dump**: only rows added since the last dump are exported, and
+new chunk files are appended rather than rewriting existing ones.
+
+```bash
+# Full dump
+graphman dump my-subgraph /backups/my-subgraph
+
+# Incremental update of the same dump
+graphman dump my-subgraph /backups/my-subgraph
+```
+
+#### Restoring a deployment
+
+```bash
+graphman restore <directory> [options]
+```
+
+`<directory>` is the path to a dump previously created with `graphman
+dump`.
+
+| Option      | Description                                                                                         |
+| ----------- | --------------------------------------------------------------------------------------------------- |
+| `--shard`   | Target database shard. Uses deployment rules (or primary shard) when omitted. Required with `--add` |
+| `--name`    | Subgraph name for deployment rule matching and node assignment. Falls back to an existing name       |
+| `--replace` | Drop and recreate if the deployment already exists in the target shard                               |
+| `--add`     | Create a copy in a shard that doesn't already have this deployment (requires `--shard`)              |
+| `--force`   | Replace if the deployment exists in the target shard, add if it doesn't                              |
+
+`--replace`, `--add`, and `--force` are mutually exclusive. When none is
+given, restore fails if the deployment already exists in the target shard.
+
+```bash
+# Restore into the default shard
+graphman restore /backups/my-subgraph
+
+# Restore into a specific shard, replacing if it already exists
+graphman restore /backups/my-subgraph --shard shard1 --replace
+
+# Force-restore (replace or add as needed)
+graphman restore /backups/my-subgraph --force
+```
+
+### Directory layout
+
+A dump directory has the following structure:
+
+```
+<dump-dir>/
+  metadata.json                  -- deployment metadata + per-table state
+  schema.graphql                 -- raw GraphQL schema text
+  subgraph.yaml                  -- raw subgraph manifest YAML (optional)
+  <EntityType>/
+    chunk_000000.parquet         -- rows ordered by vid
+    chunk_000001.parquet         -- incremental append (future chunks)
+    ...
+  data_sources$/
+    chunk_000000.parquet         -- dynamic data sources
+```
+
+Each entity type defined in the GraphQL schema gets its own subdirectory,
+named after the entity type exactly as it appears in the schema (e.g.
+`Token/`, `Pool/`). The Proof of Indexing appears as a regular entity
+directory name `Poi$`. The special `data_sources$` directory holds dynamic
+data sources created at runtime.
+
+Within each directory, data is stored in numbered chunk files
+(`chunk_000000.parquet`, `chunk_000001.parquet`, ...). A fresh dump
+produces a single `chunk_000000.parquet` per table. Incremental dumps
+append new chunks rather than rewriting existing ones.
+
+The GraphQL schema and subgraph manifest are stored as separate plain-text
+files `schema.graphql` and `subgraph.yaml`.
+
+### metadata.json
+
+The top-level `metadata.json` contains everything needed to reconstruct the
+deployment's table structure, plus diagnostic information captured at dump
+time. Its structure is:
+
+```json
+{
+  "version": 1,
+  "deployment": "Qm...",
+  "network": "mainnet",
+
+  "manifest": {
+    "spec_version": "1.0.0",
+    "description": "Optional subgraph description",
+    "repository": "https://github.com/...",
+    "features": ["..."],
+    "entities_with_causality_region": ["EntityType1"],
+    "history_blocks": 2147483647
+  },
+
+  "earliest_block_number": 12345,
+  "start_block": { "number": 12345, "hash": "0xabc..." },
+  "head_block": { "number": 99999, "hash": "0xdef..." },
+  "entity_count": 150000,
+
+  "graft_base": null,
+  "graft_block": null,
+  "debug_fork": null,
+
+  "health": {
+    "failed": false,
+    "health": "healthy",
+    "fatal_error": null,
+    "non_fatal_errors": []
+  },
+
+  "indexes": {
+    "token": [
+      "CREATE INDEX CONCURRENTLY IF NOT EXISTS attr_0_0_id ON sgd.token USING btree (id)"
+    ]
+  },
+
+  "tables": {
+    "Token": {
+      "immutable": true,
+      "has_causality_region": false,
+      "chunks": [
+        {
+          "file": "Token/chunk_000000.parquet",
+          "min_vid": 0,
+          "max_vid": 50000,
+          "row_count": 50000
+        }
+      ],
+      "max_vid": 50000
+    },
+    "data_sources$": {
+      "immutable": false,
+      "has_causality_region": true,
+      "chunks": [
+        {
+          "file": "data_sources$/chunk_000000.parquet",
+          "min_vid": 0,
+          "max_vid": 100,
+          "row_count": 100
+        }
+      ],
+      "max_vid": 100
+    }
+  }
+}
+```
+
+**Field descriptions:**
+
+| Field                                     | Description                                                                                                                         |
+| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `version`                                 | Format version. Must be `1`.                                                                                                        |
+| `deployment`                              | Deployment hash (`Qm...`).                                                                                                          |
+| `network`                                 | The blockchain network (e.g. `mainnet`, `goerli`).                                                                                  |
+| `manifest`                                | Manifest metadata extracted from `subgraphs.subgraph_manifest`.                                                                     |
+| `manifest.spec_version`                   | Subgraph API version. Required to parse `schema.graphql`.                                                                           |
+| `manifest.entities_with_causality_region` | Entity types that have a `causality_region` column.                                                                                 |
+| `manifest.history_blocks`                 | How many blocks of entity version history are retained.                                                                             |
+| `earliest_block_number`                   | Earliest block for which data exists (accounts for pruning).                                                                        |
+| `start_block`                             | The block where indexing started. Null if not set.                                                                                  |
+| `head_block`                              | The latest indexed block at dump time.                                                                                              |
+| `entity_count`                            | Total entity count across all tables.                                                                                               |
+| `graft_base`                              | Deployment hash of the graft base, if any.                                                                                          |
+| `graft_block`                             | Block pointer of the graft point, if any.                                                                                           |
+| `debug_fork`                              | Debug fork deployment hash, if any.                                                                                                 |
+| `health`                                  | Point-in-time health snapshot. Not used during restore.                                                                             |
+| `indexes`                                 | Point-in-time index definitions as SQL. Not used during restore (indexes are auto-created by `Layout::create_relational_schema()`). |
+| `tables`                                  | Per-table metadata keyed by entity type name (or `data_sources$`).                                                                  |
+
+Each entry in `tables` contains:
+
+| Field                  | Description                                                                    |
+| ---------------------- | ------------------------------------------------------------------------------ |
+| `immutable`            | Whether the entity type is immutable (uses `block$` instead of `block_range`). |
+| `has_causality_region` | Whether rows have a `causality_region` column.                                 |
+| `chunks`               | Ordered list of Parquet chunk files for this table.                            |
+| `chunks[].file`        | Relative path from the dump directory.                                         |
+| `chunks[].min_vid`     | Minimum `vid` value in this chunk.                                             |
+| `chunks[].max_vid`     | Maximum `vid` value in this chunk.                                             |
+| `chunks[].row_count`   | Number of rows in this chunk.                                                  |
+| `max_vid`              | Maximum `vid` across all chunks. `-1` if the table is empty.                   |
+
+### Parquet schema: entity tables
+
+Each entity table's Parquet file uses an Arrow schema derived from the
+entity's GraphQL definition. Columns are ordered as follows:
+
+1. **System columns** (always present, in this order):
+   - `vid` (Int64, non-nullable) -- row version ID
+   - Block tracking (one of):
+     - Immutable entities: `block$` (Int32, non-nullable)
+     - Mutable entities: `block_range_start` (Int32, non-nullable),
+       `block_range_end` (Int32, nullable -- null means unbounded/current)
+   - `causality_region` (Int32, non-nullable) -- only if the entity has one
+
+2. **Data columns** in GraphQL declaration order, skipping fulltext
+   (`TSVector`) columns which are generated and rebuilt on restore.
+
+The PostgreSQL `int4range` type used for `block_range` is decomposed into
+two scalar columns (`block_range_start`, `block_range_end`) in the Parquet
+representation. This avoids the need for a custom range type in Arrow.
+
+#### Type mapping
+
+GraphQL/PostgreSQL column types map to Arrow data types as follows:
+
+| ColumnType      | Arrow DataType                 | Notes                                                          |
+| --------------- | ------------------------------ | -------------------------------------------------------------- |
+| `Boolean`       | `Boolean`                      |                                                                |
+| `Int`           | `Int32`                        |                                                                |
+| `Int8`          | `Int64`                        |                                                                |
+| `Bytes`         | `Binary`                       | Raw bytes, no hex encoding                                     |
+| `BigInt`        | `Utf8`                         | Stored as decimal string for arbitrary precision               |
+| `BigDecimal`    | `Utf8`                         | Stored as decimal string for arbitrary precision               |
+| `Timestamp`     | `Timestamp(Microsecond, None)` | Microseconds since epoch, no timezone                          |
+| `String`        | `Utf8`                         |                                                                |
+| `Enum(...)`     | `Utf8`                         | Enum variant as string (cast from PG enum to text during dump) |
+| `TSVector(...)` | _skipped_                      | Fulltext index columns are generated; rebuilt on restore       |
+
+**Array columns:** A GraphQL list field (e.g. `tags: [String!]!`) is
+stored as `List<T>` where `T` is the base Arrow type from the table
+above. Whether a column is a list is determined by the GraphQL field type,
+not by `ColumnType`. For example, `[String!]!` becomes `List<Utf8>` and
+`[Int!]` becomes `List<Int32>`.
+
+**Nullability** follows the GraphQL schema: non-null fields produce
+non-nullable Arrow columns; optional fields produce nullable columns. List
+elements within list columns are always marked nullable in the Arrow schema.
+
+### Parquet schema: data_sources$
+
+The `data_sources$` table has a fixed schema independent of the GraphQL
+definition:
+
+| Column              | Arrow DataType | Nullable | Description                                        |
+| ------------------- | -------------- | -------- | -------------------------------------------------- |
+| `vid`               | `Int64`        | no       | Row version ID                                     |
+| `block_range_start` | `Int32`        | no       | Lower bound of `block_range`                       |
+| `block_range_end`   | `Int32`        | yes      | Upper bound (null = unbounded)                     |
+| `causality_region`  | `Int32`        | no       | Causality region                                   |
+| `manifest_idx`      | `Int32`        | no       | Index into the manifest's data source list         |
+| `parent`            | `Int32`        | yes      | Self-referencing parent data source                |
+| `id`                | `Binary`       | yes      | Data source identifier                             |
+| `param`             | `Binary`       | yes      | Data source parameter                              |
+| `context`           | `Utf8`         | yes      | JSON context                                       |
+| `done_at`           | `Int32`        | yes      | Block number where the data source was marked done |
+
+### Compression
+
+All Parquet files use ZSTD compression (default level).
+
+### Row ordering
+
+Within each Parquet chunk file, rows are ordered by `vid` (ascending).
+This matches the primary key ordering in PostgreSQL and enables efficient
+sequential reads during restore.
+
+### Incremental dumps
+
+An incremental dump reads the existing `metadata.json`, determines the
+`max_vid` for each table, and queries only rows with `vid > max_vid`. New
+rows are written to new chunk files (e.g. `chunk_000001.parquet`) and the
+metadata is updated atomically (write to a temp file, then rename).
+
+### Atomicity
+
+The `metadata.json` file is always written atomically: the dump writes to
+`metadata.json.tmp` first, then renames it to `metadata.json`. This
+ensures that a reader never sees a partially-written metadata file. If the
+dump process crashes mid-write, the previous `metadata.json` remains
+intact. The Parquet chunk files are written before `metadata.json` is
+updated, so chunk files referenced by `metadata.json` are always complete.
diff --git a/docs/environment-variables.md b/docs/environment-variables.md
index b50fd598ca5..7a601e32e64 100644
--- a/docs/environment-variables.md
+++ b/docs/environment-variables.md
@@ -10,10 +10,15 @@ those.
 
 ## JSON-RPC configuration for EVM chains
 
+> **Note**: Many of these settings can now be overridden per-chain in the TOML
+> configuration file under `[chains.<name>]`. When a per-chain value is set in
+> the config file it takes precedence over the environment variable. See
+> [config.md](config.md#configuring-chains) for details.
+
 - `ETHEREUM_REORG_THRESHOLD`: Maximum expected reorg size, if a larger reorg
   happens, subgraphs might process inconsistent data. Defaults to 250.
 - `ETHEREUM_POLLING_INTERVAL`: how often to poll Ethereum for new blocks (in ms,
-  defaults to 500ms)
+  defaults to 1000ms)
 - `GRAPH_ETHEREUM_TARGET_TRIGGERS_PER_BLOCK_RANGE`: The ideal amount of triggers
   to be processed in a batch. If this is too small it may cause too many requests
   to the ethereum node, if it is too large it may cause unreasonably expensive
@@ -53,6 +58,13 @@ those.
   be used if the store uses more than one shard.
 - `GRAPH_ETHEREUM_GENESIS_BLOCK_NUMBER`: Specify genesis block number. If the flag
   is not set, the default value will be `0`.
+- `GRAPH_ETH_GET_LOGS_MAX_CONTRACTS`: Maximum number of contracts to query in a single `eth_getLogs` request.
+  Defaults to 2000.
+
+## Firehose configuration
+
+- `GRAPH_NODE_FIREHOSE_MAX_DECODE_SIZE`: Maximum size of a message that can be
+  decoded by the firehose. Defaults to 25MB.
 
 ## Running mapping handlers
 
@@ -79,8 +91,17 @@ those.
   may use (in bytes, defaults to 256MB).
 - `GRAPH_MAX_IPFS_CACHE_SIZE`: maximum number of files cached (defaults to 50).
 - `GRAPH_MAX_IPFS_CACHE_FILE_SIZE`: maximum size of each cached file (in bytes, defaults to 1MiB).
-- `GRAPH_IPFS_REQUEST_LIMIT`: Limits the number of requests per second to IPFS for file data sources.
-   Defaults to 100.
+- `GRAPH_IPFS_REQUEST_LIMIT`: Limits the number of requests per second to IPFS for file data sources. Defaults to 100.
+- `GRAPH_IPFS_MAX_ATTEMPTS`: This limits the IPFS retry requests in case of a
+  file not found or logical issue working as a safety mechanism to
+  prevent infinite spamming of IPFS servers and network congestion
+  (default: 100 000).
+- `GRAPH_IPFS_CACHE_LOCATION`: When set, files retrieved from IPFS will be
+  cached in that location; future accesses to the same file will be served
+  from cache rather than IPFS. This can either be a URL starting with
+  `redis://`, in which case there must be a Redis instance running at that
+  URL, or an absolute file system path which must be a directory writable
+  by the `graph-node` process (experimental)
 
 ## GraphQL
 
@@ -105,18 +126,10 @@ those.
   result is checked while the response is being constructed, so that
   execution does not take more memory than what is configured. The default
   value for both is unlimited.
-- `GRAPH_GRAPHQL_MAX_OPERATIONS_PER_CONNECTION`: maximum number of GraphQL
-  operations per WebSocket connection. Any operation created after the limit
-  will return an error to the client. Default: 1000.
 - `GRAPH_GRAPHQL_HTTP_PORT` : Port for the GraphQL HTTP server
-- `GRAPH_GRAPHQL_WS_PORT` : Port for the GraphQL WebSocket server
 - `GRAPH_SQL_STATEMENT_TIMEOUT`: the maximum number of seconds an
   individual SQL query is allowed to take during GraphQL
   execution. Default: unlimited
-- `GRAPH_DISABLE_SUBSCRIPTION_NOTIFICATIONS`: disables the internal
-  mechanism that is used to trigger updates on GraphQL subscriptions. When
-  this variable is set to any value, `graph-node` will still accept GraphQL
-  subscriptions, but they won't receive any updates.
 - `ENABLE_GRAPHQL_VALIDATIONS`: enables GraphQL validations, based on the GraphQL specification.
   This will validate and ensure every query executes follows the execution
   rules. Default: `false`
@@ -142,6 +155,10 @@ those.
 - `GRAPH_QUERY_CACHE_BLOCKS`: How many recent blocks per network should be kept in the query cache. This should be kept small since the lookup time and the cache memory usage are proportional to this value. Set to 0 to disable the cache. Defaults to 1.
 - `GRAPH_QUERY_CACHE_MAX_MEM`: Maximum total memory to be used by the query cache, in MB. The total amount of memory used for caching will be twice this value - once for recent blocks, divided evenly among the `GRAPH_QUERY_CACHE_BLOCKS`, and once for frequent queries against older blocks. The default is plenty for most loads, particularly if `GRAPH_QUERY_CACHE_BLOCKS` is kept small. Defaults to 1000, which corresponds to 1GB.
 - `GRAPH_QUERY_CACHE_STALE_PERIOD`: Number of queries after which a cache entry can be considered stale. Defaults to 100.
+- `GRAPH_QUERY_CACHE_MAX_ENTRY_RATIO`: Limits the maximum size of a cache
+  entry. Query results larger than the size of a cache shard divided by this
+  value will not be cached. The default is 3. A value of 0 means that there
+  is no limit on the size of a cache entry.
 
 ## Miscellaneous
 
@@ -174,11 +191,10 @@ those.
   query, and the `query_id` of the GraphQL query that caused the SQL
   query. These SQL queries are marked with `component: GraphQlRunner` There
   are additional SQL queries that get logged when `sql` is given. These are
-  queries caused by mappings when processing blocks for a subgraph, and
-  queries caused by subscriptions. If `cache` is present in addition to
-  `gql`, also logs information for each toplevel GraphQL query field
-  whether that could be retrieved from cache or not. Defaults to no
-  logging.
+  queries caused by mappings when processing blocks for a subgraph. If
+  `cache` is present in addition to `gql`, also logs information for each
+  toplevel GraphQL query field whether that could be retrieved from cache
+  or not. Defaults to no logging.
 - `GRAPH_LOG_TIME_FORMAT`: Custom log time format.Default value is `%b %d %H:%M:%S%.3f`. More information [here](https://docs.rs/chrono/latest/chrono/#formatting-and-parsing).
 - `STORE_CONNECTION_POOL_SIZE`: How many simultaneous connections to allow to the store.
   Due to implementation details, this value may not be strictly adhered to. Defaults to 10.
@@ -205,6 +221,14 @@ those.
   decisions. Set to `true` to turn simulation on, defaults to `false`
 - `GRAPH_STORE_CONNECTION_TIMEOUT`: How long to wait to connect to a
   database before assuming the database is down in ms. Defaults to 5000ms.
+- `GRAPH_STORE_SETUP_TIMEOUT`: Timeout for database setup operations
+  (migrations, schema creation) in milliseconds. Defaults to 30000ms (30s).
+  Setup operations can legitimately take longer than normal runtime operations.
+- `GRAPH_STORE_CONNECTION_UNAVAILABLE_RETRY`: When a database shard is marked
+  unavailable due to connection timeouts, this controls how often to allow a
+  single probe request through to check if the database has recovered. Only one
+  request per interval will attempt a connection; all others fail instantly.
+  Value is in seconds and defaults to 2s.
 - `EXPERIMENTAL_SUBGRAPH_VERSION_SWITCHING_MODE`: default is `instant`, set
   to `synced` to only switch a named subgraph to a new deployment once it
   has synced, making the new deployment the "Pending" version.
@@ -221,6 +245,18 @@ those.
   copying or grafting should take. This limits how long transactions for
   such long running operations will be, and therefore helps control bloat
   in other tables. Value is in seconds and defaults to 180s.
+- `GRAPH_STORE_BATCH_TIMEOUT`: How long a batch operation during copying,
+  grafting, or pruning is allowed to take at most. This is meant to guard
+  against batches that are catastrophically big and should be set to a
+  small multiple of `GRAPH_STORE_BATCH_TARGET_DURATION`, like 10 times that
+  value, and needs to be at least 2 times that value when set. If this
+  timeout is hit, the batch size is reset to 1 so we can be sure that
+  batches stay below `GRAPH_STORE_BATCH_TARGET_DURATION` and the smaller
+  batch is retried. Value is in seconds and defaults to unlimited.
+- `GRAPH_STORE_BATCH_WORKERS`: The number of workers to use for batch
+    operations. If there are idle connectiosn, each subgraph copy operation
+    will use up to this many workers to copy tables in parallel. Defaults
+    to 1 and must be at least 1
 - `GRAPH_START_BLOCK`: block hash:block number where the forked subgraph will start indexing at.
 - `GRAPH_FORK_BASE`: api url for where the graph node will fork from, use `https://api.thegraph.com/subgraphs/id/`
   for the hosted service.
@@ -247,3 +283,87 @@ those.
 - `GRAPH_STORE_WRITE_BATCH_SIZE`: how many changes to accumulate during
   syncing in kilobytes before a write has to happen. The default is 10_000
   which corresponds to 10MB. Setting this to 0 disables write batching.
+- `GRAPH_MIN_HISTORY_BLOCKS`: Specifies the minimum number of blocks to
+  retain for subgraphs with historyBlocks set to auto. The default value is 2 times the reorg threshold.
+- `GRAPH_ETHEREUM_BLOCK_RECEIPTS_CHECK_TIMEOUT`: Timeout for checking
+  `eth_getBlockReceipts` support during chain startup, if this times out
+  individual transaction receipts will be fetched instead. Defaults to 10s.
+- `GRAPH_POSTPONE_ATTRIBUTE_INDEX_CREATION`: During the coping of a subgraph
+  postponing creation of certain indexes (btree, attribute based ones), would
+  speed up syncing
+- `GRAPH_STORE_INSERT_EXTRA_COLS`: Makes it possible to work around bugs in
+  the subgraph writing code that manifest as Postgres errors saying 'number
+  of parameters must be between 0 and 65535' Such errors are always
+  graph-node bugs, but since it is hard to work around them, setting this
+  variable to something like 10 makes it possible to work around such a bug
+  while it is being fixed (default: 0)
+- `GRAPH_ENABLE_SQL_QUERIES`: Enable the experimental [SQL query
+  interface](implementation/sql-interface.md).
+  (default: false)
+- `GRAPH_STORE_ACCOUNT_LIKE_SCAN_INTERVAL_HOURS`: If set, enables an experimental job that
+  periodically scans for entity tables that may benefit from an [account-like optimization](https://thegraph.com/docs/en/indexing/tooling/graph-node/#account-like-optimisation) and marks them with an
+  account-like flag. The value is the interval in hours at which the job
+  should run. The job reads data from the `info.table_stats` materialized view, which refreshes every six hours.
+  Expects an integer value, e.g., 24. Requires also setting
+  `GRAPH_STORE_ACCOUNT_LIKE_MIN_VERSIONS_COUNT` and `GRAPH_STORE_ACCOUNT_LIKE_MAX_UNIQUE_RATIO`.
+- `GRAPH_STORE_ACCOUNT_LIKE_MIN_VERSIONS_COUNT`: Sets the minimum total number of versions a table must have
+  to be considered for account-like flagging. Expects a positive integer value. No default value.
+- `GRAPH_STORE_ACCOUNT_LIKE_MAX_UNIQUE_RATIO`: Sets the maximum unique entities to version ratio
+  (e.g., 0.01 ≈ 1:100 entity-to-version ratio).
+- `GRAPH_STORE_DISABLE_CALL_CACHE`: Disables storing or reading `eth_call` results from the store call cache.
+  This option may be useful for indexers who are running their own RPC nodes.
+  Disabling the store call cache may significantly impact performance; the actual impact depends on
+  the average execution time of an `eth_call` compared to the cost of a database lookup for a cached result.
+  (default: false)
+
+## Log Store Configuration
+
+`graph-node` supports storing and querying subgraph logs through multiple backends: Elasticsearch, Loki, local files, or disabled.
+
+**For complete log store documentation**, including detailed configuration, querying examples, and choosing the right backend, see the **[Log Store Guide](log-store.md)**.
+
+### Quick Reference
+
+**Backend selection:**
+- `GRAPH_LOG_STORE_BACKEND`: `disabled` (default), `elasticsearch`, `loki`, or `file`
+
+**Elasticsearch:**
+- `GRAPH_LOG_STORE_ELASTICSEARCH_URL`: Elasticsearch endpoint URL (required)
+- `GRAPH_LOG_STORE_ELASTICSEARCH_USER`: Username (optional)
+- `GRAPH_LOG_STORE_ELASTICSEARCH_PASSWORD`: Password (optional)
+- `GRAPH_LOG_STORE_ELASTICSEARCH_INDEX`: Index name (default: `subgraph`)
+
+**Loki:**
+- `GRAPH_LOG_STORE_LOKI_URL`: Loki endpoint URL (required)
+- `GRAPH_LOG_STORE_LOKI_TENANT_ID`: Tenant ID (optional)
+
+**File-based:**
+- `GRAPH_LOG_STORE_FILE_DIR`: Log directory (required)
+- `GRAPH_LOG_STORE_FILE_MAX_SIZE`: Max file size in bytes (default: 104857600 = 100MB)
+- `GRAPH_LOG_STORE_FILE_RETENTION_DAYS`: Retention period (default: 30)
+
+**Deprecated variables** (will be removed in future versions):
+- `GRAPH_ELASTICSEARCH_URL` → use `GRAPH_LOG_STORE_ELASTICSEARCH_URL`
+- `GRAPH_ELASTICSEARCH_USER` → use `GRAPH_LOG_STORE_ELASTICSEARCH_USER`
+- `GRAPH_ELASTICSEARCH_PASSWORD` → use `GRAPH_LOG_STORE_ELASTICSEARCH_PASSWORD`
+- `GRAPH_ELASTIC_SEARCH_INDEX` → use `GRAPH_LOG_STORE_ELASTICSEARCH_INDEX`
+
+### Example: File-based Logs for Local Development
+
+```bash
+mkdir -p ./graph-logs
+export GRAPH_LOG_STORE_BACKEND=file
+export GRAPH_LOG_STORE_FILE_DIR=./graph-logs
+
+graph-node \
+  --postgres-url postgresql://graph:pass@localhost/graph-node \
+  --ethereum-rpc mainnet:https://... \
+  --ipfs 127.0.0.1:5001
+```
+
+See the **[Log Store Guide](log-store.md)** for:
+- Detailed configuration for all backends
+- How log stores work internally
+- GraphQL query examples
+- Choosing the right backend for your use case
+- Best practices and troubleshooting
diff --git a/docs/getting-started.md b/docs/getting-started.md
deleted file mode 100644
index 13c2c8786d4..00000000000
--- a/docs/getting-started.md
+++ /dev/null
@@ -1,486 +0,0 @@
-# Getting Started
-> **Note:**  This project is heavily a WIP, and until it reaches v1.0, the API is subject to change in breaking ways without notice.
-
-## 0 Introduction
-
-This page explains everything you need to know to run a local Graph Node, including links to other reference pages. First, we describe what The Graph is and then explain how to get started.
-
-### 0.1 What Is The Graph?
-
-The Graph is a decentralized protocol for indexing and querying data from blockchains, which makes it possible to query for data that is difficult or impossible to do directly. Currently, we only work with Ethereum.
-
-For example, with the popular Cryptokitties decentralized application (dApp) that implements the [ERC-721 Non-Fungible Token (NFT)](https://github.com/ethereum/eips/issues/721) standard, it is relatively straightforward to ask the following questions:
-> *How many cryptokitties does a specific Ethereum account own?*
-> *When was a particular cryptokitty born?*
-
-These read patterns are directly supported by the methods exposed by the [contract](https://github.com/dapperlabs/cryptokitties-bounty/blob/master/contracts/KittyCore.sol): the [`balanceOf`](https://github.com/dapperlabs/cryptokitties-bounty/blob/master/contracts/KittyOwnership.sol#L64) and [`getKitty`](https://github.com/dapperlabs/cryptokitties-bounty/blob/master/contracts/KittyCore.sol#L91) methods for these two examples.
-
-However, other questions are more difficult to answer:
-> *Who are the owners of the cryptokitties born between January and February of 2018?*
-
-To answer this question, you need to process all [`Birth` events](https://github.com/dapperlabs/cryptokitties-bounty/blob/master/contracts/KittyBase.sol#L15) and then call the [`ownerOf` method](https://github.com/dapperlabs/cryptokitties-bounty/blob/master/contracts/KittyOwnership.sol#L144) for each cryptokitty born. An alternate approach could involve processing all (`Transfer` events) and filtering based on the most recent transfer for each cryptokitty.
-
-Even for this relatively simple question, it would take hours or even days for a dApp running in a browser to find an answer. Indexing and caching data off blockchains is hard. There are also edge cases around finality, chain reorganizations, uncled blocks, etc., which make it even more difficult to display deterministic data to the end user.
-
-The Graph solves this issue by providing an open source node implementation, [Graph Node](../README.md), which handles indexing and caching of blockchain data. The entire community can contribute to and utilize this tool. In the current implementation, it exposes functionality through a GraphQL API for end users.
-
-### 0.2 How Does It Work?
-
-The Graph must be run alongside a running IPFS node, Ethereum node, and a store (Postgres, in this initial implementation).
-
-![Data Flow Diagram](images/TheGraph_DataFlowDiagram.png)
-
-The high-level dataflow for a dApp using The Graph is as follows:
-1. The dApp creates/modifies data on Ethereum through a transaction to a smart contract.
-2. The smart contract emits one or more events (logs) while processing this transaction.
-3. The Graph Node listens for specific events and triggers handlers in a user-defined mapping.
-4. The mapping is a WASM module that runs in a WASM runtime. It creates one or more store transactions in response to Ethereum events.
-5. The store is updated along with the indexes.
-6. The dApp queries the Graph Node for data indexed from the blockchain using the node's [GraphQL endpoint](https://graphql.org/learn/). The Graph Node, in turn, translates the GraphQL queries into queries for its underlying store to fetch this data. This makes use of the store's indexing capabilities.
-7. The dApp displays this data in a user-friendly format, which an end-user leverages when making new transactions against the Ethereum blockchain.
-8. And, this cycle repeats.
-
-### 0.3 What's Needed to Build a Graph Node?
-Three repositories are relevant to building on The Graph:
-1. [Graph Node](../README.md) – A server implementation for indexing, caching, and serving queries against data from Ethereum.
-2. [Graph CLI](https://github.com/graphprotocol/graph-tooling/tree/main/packages/cli) – A CLI for building and compiling projects that are deployed to the Graph Node.
-3. [Graph TypeScript Library](https://github.com/graphprotocol/graph-tooling/tree/main/packages/ts) – TypeScript/AssemblyScript library for writing subgraph mappings to be deployed to The Graph.
-
-### 0.4 Getting Started Overview
-Below, we outline the required steps to build a subgraph from scratch, which will serve queries from a GraphQL endpoint. The three major steps are:
-
-1. [Define the subgraph](#1-define-the-subgraph)
-    1. [Define the data sources and create a manifest](#11-define-the-data-sources-and-create-a-manifest)
-
-    2. [Create the GraphQL schema](#12-create-the-graphql-schema-for-the-data-source)
-
-    3. [Create a subgraph project and generate types](#13-create-a-subgraph-project-and-generate-types)
-
-    4. [Write the mappings](#14-writing-mappings)
-2. Deploy the subgraph
-    1. [Start up an IPFS node](#21-start-up-ipfs)
-
-    2. [Create the Postgres database](#22-create-the-postgres-db)
-
-    3. [Start the Graph Node and Connect to an Ethereum node](#23-starting-the-graph-node-and-connecting-to-an-ethereum-node)
-
-    4. [Deploy the subgraph](#24-deploying-the-subgraph)
-3. Query the subgraph
-    1. [Query the newly deployed GraphQL API](#3-query-the-local-graph-node)
-
-Now, let's dig in!
-
-## 1 Define the Subgraph
-When we refer to a subgraph, we reference the entire project that is indexing a chosen set of data.
-
-To start, create a repository for this project.
-
-### 1.1 Define the Data Sources and Create a Manifest
-
-When building a subgraph, you must first decide what blockchain data you want the Graph Node to index. These are known as `dataSources`, which are datasets derived from a blockchain, i.e., an Ethereum smart contract.
-
-The subgraph is defined by a YAML file known as the **subgraph manifest**. This file should always be named `subgraph.yaml`. View the full specification for the subgraph manifest [here](subgraph-manifest.md). It contains a schema, data sources, and mappings that are used to deploy the GraphQL endpoint.
-
-Let's go through an example to display what a subgraph manifest looks like. In this case, we use the common ERC721 contract and look at the `Transfer` event because it is familiar to many developers. Below, we define a subgraph manifest with one contract under `dataSources`, which is a smart contract implementing the ERC721 interface:
-```yaml
-specVersion: 0.0.1
-description: ERC-721 Example
-repository: https://github.com/<YOUR_GITHUB_NAME>/erc721-example
-schema:
-  file: ./schema.graphql
-dataSources:
-- kind: ethereum/contract
-  name: MyERC721Contract
-  network: mainnet
-  source:
-    address: "0x06012c8cf97BEaD5deAe237070F9587f8E7A266d"
-    abi: ERC721
-  mapping:
-    kind: ethereum/events
-    apiVersion: 0.0.1
-    language: wasm/assemblyscript
-    entities:
-    - Token
-    abis:
-    - name: ERC721
-      file: ./abis/ERC721ABI.json
-    eventHandlers:
-    - event: Transfer(address,address,uint256)
-      handler: handleTransfer
-    file: ./mapping.ts
-```
-We point out a few important facts from this example to supplement the [subgraph manifest spec](subgraph-manifest.md):
-
-* The name `ERC721` under `source > abi` must match the name displayed underneath `abis > name`.
-* The event `Transfer(address,address,uint256)` under `eventHandlers` must match what is in the ABI. The name `handleTransfer` under `eventHandlers > handler` must match the name of the mapping function, which we explain in section 1.4.
-* Ensure that you have the correct contract address under `source > address`. This is also the case when indexing testnet contracts as well because you might switch back and forth.
-* You can define multiple data sources under dataSources. Within a datasource, you can also have multiple `entities` and `events`. See [this subgraph](https://github.com/graphprotocol/decentraland-subgraph/blob/master/subgraph.yaml) for an example.
-* If at any point the Graph CLI outputs 'Failed to copy subgraph files', it probably means you have a typo in the manifest.
-
-#### 1.1.1 Obtain the Contract ABIs  
-The ABI JSON file must contain the correct ABI to source all the events or any contract state you wish to ingest into the Graph Node. There are a few ways to obtain an ABI for the contract:
-* If you are building your own project, you likely have access to your most current ABIs of your smart contracts.
-* If you are building a subgraph for a public project, you can download that project to your computer and generate the ABI by using [`truffle compile`](https://truffleframework.com/docs/truffle/overview) or `solc` to compile. This creates the ABI files that you can then transfer to your subgraph `/abi` folder.
-* Sometimes, you can also find the ABI on [Etherscan](https://etherscan.io), but this is not always reliable because the uploaded ABI may be out of date. Make sure you have the correct ABI. Otherwise, you will not be able to start a Graph Node.
-
-If you run into trouble here, double-check the ABI and ensure that the event signatures exist *exactly* as you expect them by examining the smart contract code you are sourcing. Also, note with the ABI, you only need the array for the ABI. Compiling the contracts locally results in a `.json` file that contains the complete ABI nested within the `.json` file under the key `abi`.
-
-An example `abi` for the `Transfer` event is shown below and would be stored in the `/abi` folder with the name `ERC721ABI.json`:
-
-```json
-  [{
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": true,
-        "name": "_from",
-        "type": "address"
-      },
-      {
-        "indexed": true,
-        "name": "_to",
-        "type": "address"
-      },
-      {
-        "indexed": true,
-        "name": "_tokenId",
-        "type": "uint256"
-      }
-    ],
-    "name": "Transfer",
-    "type": "event"
-  }]
-  ```
-
-Once you create this `subgraph.yaml` file, move to the next section.
-
-### 1.2 Create the GraphQL Schema for the Data Source
-GraphQL schemas are defined using the GraphQL interface definition language (IDL). If you have never written a GraphQL schema, we recommend checking out a [quick primer](https://graphql.org/learn/schema/#type-language) on the GraphQL type system.
-
-With The Graph, rather than defining the top-level `Query` type, you simply define entity types. Then, the Graph Node will generate top-level fields for querying single instances and collections of that entity type. Each entity type is required to be annotated with an `@entity` directive.
-
-As you see in the example `subgraph.yaml` manifest above, it contains one entity named `Token`. Let's define what that would look like for the GraphQL schema:
-
-Define a Token entity type:
-```graphql
-type Token @entity {
-  id: ID!
-  currentOwner: Address!
-}
-```
-
-This `entity` tracks a single ERC721 token on Ethereum by its ID and the current owner. The **`ID` field is required** and stores values of the ID type, which are strings. The `ID` must be a unique value so that it can be placed into the store. For an ERC721 token, the unique ID could be the token ID because that value is unique to that coin.
-
-The exclamation mark represents the fact that that field must be set when the entity is stored in the database, i.e., it cannot be `null`. See the [Schema API](https://github.com/graphprotocol/docs/blob/main/pages/en/querying/graphql-api.mdx#schema) for a complete reference on defining the schema for The Graph.
-
-When you complete the schema, add its path to the top-level `schema` key in the subgraph manifest. See the code below for an example:
-
-```yaml
-specVersion: 0.0.1
-schema:
-  file: ./schema.graphql
-```
-
-### 1.3 Create a Subgraph Project and Generate Types
-Once you have the `subgraph.yaml` manifest and the `./schema.graphql` file, you are ready to use the Graph CLI to set up the subgraph directory. The Graph CLI is a command-line tool that contains helpful commands for deploying the subgraphs. Before continuing with this guide, please go to the [Graph CLI README](https://github.com/graphprotocol/graph-tooling/tree/main/packages/cli) and follow the instructions up to Step 7 for setting up the subgraph directory.
-
-Once you run `yarn codegen` as outlined in the [Graph CLI README](https://github.com/graphprotocol/graph-tooling/tree/main/packages/cli), you are ready to create the mappings.
-
-`yarn codegen` looks at the contract ABIs defined in the subgraph manifest and generates TypeScript classes for the smart contracts the mappings script will interface with, which includes the types of public methods and events. In reality, the classes are AssemblyScript but more on that later.
-
-Classes are also generated based on the types defined in the GraphQL schema. These generated classes are incredibly useful for writing correct mappings. This allows you to autocomplete Ethererum events as well as improve developer productivity using the TypeScript language support in your favorite editor or IDE.
-
-### 1.4 Write the Mappings
-
-The mappings that you write will perform transformations on the Ethereum data you are sourcing, and it will dictate how this data is loaded into the Graph Node. Mappings can be very simple but can become complex. It depends on how much abstraction you want between the data and the underlying Ethereum contract.
-
-Mappings are written in a subset of TypeScript called AssemblyScript, which can be compiled down to WASM. AssemblyScript is stricter than normal TypeScript but follows the same backbone. A few TypeScript/JavaScript features that are not supported in AssemblyScript include plain old Javascript objects (POJOs), untyped arrays, untyped maps, union types, the `any` type, and variadic functions. In addition, `switch` statements also work differently. See the [AssemblyScript wiki](https://github.com/AssemblyScript/assemblyscript/wiki) for a full reference on AssemblyScript features.
-
-In the mapping file, create export functions named after the event handlers in the subgraph manifest. Each handler should accept a single parameter called `event` with a type corresponding to the name of the event that is being handled. This type was generated for you in the previous step, 1.3.
-
-```typescript
-export function handleTransfer(event: Transfer): void {
-  // Event handler logic goes here
-}
-```
-
-As mentioned, AssemblyScript does not have untyped maps or POJOs, so classes are generated to represent the types defined in the GraphQL schema. The generated type classes handle property type conversions for you, so AssemblyScript's requirement of strictly typed functions is satisfied without the extra work of converting each property explicitly.
-
-Let's look at an example. Continuing with our previous token example, let's write a mapping that tracks the owner of a particular ERC721 token.
-
-```typescript
-
-// This is an example event type generated by `graph-cli`
-// from an Ethereum smart contract ABI
-import { Transfer } from './types/abis/SomeContract'
-
-// This is an example of an entity type generated from a
-// subgraph's GraphQL schema
-import { Token } from './types/schema'
-
-export function handleTransfer(event: Transfer): void {
-    let tokenID = event.params.tokenID.toHex()
-    let token = new Token(tokenID)
-    token.currentOwner = event.params.to
-
-    token.save()
-}
-```
-A few things to note from this code:
-* We create a new entity named `token`, which is stored in the Graph Node database.
-* We create an ID for that token, which must be unique, and then create an entity with `new Token(tokenID)`. We get the token ID from the event emitted by Ethereum, which was turned into an AssemblyScript type by the [Graph TypeScript Library](https://github.com/graphprotocol/graph-tooling/tree/main/packages/ts). We access it at `event.params.tokenId`. Note that you must set `ID` as a string and call `toHex()` on the `tokenID` to turn it into a hex string.
-* This entity is updated by the `Transfer` event emitted by the ERC721 contract.
-* The current owner is gathered from the event with `event.params.to`. It is set as an Address by the Token class.
-* Event handlers functions always return `void`.
-* `token.save()` is used to set the Token entity. `.save()` comes from `graph-ts` just like the entity type (`Token` in this example). It is used for setting the value(s) of a particular entity's attribute(s) in the store. There is also a `.load()` function, which will be explained in 1.4.1.
-
-#### 1.4.1 Use the `save`, `load`, and `remove` entity functions
-
-The only way that entities may be added to The Graph is by calling `<entity>.save()`, which may be called multiple times in an event handler. `<entity>.save()` will only set the entity attributes that have explicitly been set on the `entity`. Attributes that are not explicitly set or are unset by calling `Entity.unset(<attribute>)` will not be overwritten. This means you can safely update one field of an entity and not worry about overwriting other fields not referenced in the mapping.
-
-The definition for `<entity>.save()` is:
-
-```typescript
-entity.save() // Entity is representative of the entity type being updated. In our example above, it is Token.
-```
-
- `<entity>.load()` expects the entity type and ID of the entity. Use `<entity>.load()` to retrieve information previously added with `<entity>.save()`.
-
-The definition for `<entity>.load()` is:
-
- ```typescript
-entity.load() // Entity is representative of the entity type being updated. In our example above, it is Token.
-```
-
-Once again, all these functions come from the [Graph TypeScript Library](https://github.com/graphprotocol/graph-tooling/tree/main/packages/ts).
-
-Let's look at the ERC721 token as an example for using `token.load()`. Above, we showed how to use `token.save()`. Now, let's consider that you have another event handler that needs to retrieve the currentOwner of an ERC721 token. To do this within an event handler, you would write the following:
-
-```typescript
-  let token = token.load(tokenID.toHex())
-  if (token !== null) {
-    let owner = token.currentOwner
-  }
-```
-
-You now have the `owner` data, and you can use that in the mapping to set the owner value to a new entity.
-
-There is also `<entity>.remove()`, which allows you to erase an entry that exists in the store. You simply pass the entity and ID:
-
-```typescript
-entity.remove(ID)
-```
-
-#### 1.4.2 Call into the Contract Storage to Get Data
-
-You can also obtain data that is stored in one of the included ABI contracts. Any state variable that is marked `public` or any `view` function can be accessed. Below shows how you obtain the token
-symbol of an ERC721 token, which is a state variable of the smart contract. You would add this inside of the event handler function.  
-
-```typescript
-  let tokenContract = ERC721.bind(event.address);
-  let tokenSymbol = tokenContract.symbol();
-```
-
-Note, we are using an ERC721 class generated from the ABI, which we call bind on. This is gathered from the subgraph manifest here:
-```yaml
-  source:
-    address: "0x06012c8cf97BEaD5deAe237070F9587f8E7A266d"
-    abi: ERC721
-```
-
-The class is imported from the ABI's TypeScript file generated via `yarn codegen`.
-
-## 2 Deploy the Subgraph
-
-### 2.1 Start Up an IPFS Node
-To deploy the subgraph to the Graph Node, the subgraph will first need to be built and stored on IPFS, along with all linked files.
-
-To run an IPFS daemon locally, execute the following:
-1. Download and install IPFS.
-2. Run `ipfs init`.
-3. Run `ipfs daemon`.
-
-If you encounter problems, follow the instructions from the [IPFS website](https://ipfs.io/docs/getting-started/).
-
-To confirm the subgraph is stored on IPFS, pass that subgraph ID into `ipfs cat` to view the subgraph manifest with file paths replaced by IPLD links.
-
-### 2.2 Create the Postgres database
-
-Ensure that you have Postgres installed. Navigate to a location where you want to save the `.postgres` folder. The desktop is fine since this folder can be used for many different subgraphs. Then, run the following commands:
-
-```
-initdb -D .postgres
-pg_ctl -D .postgres -l logfile start
-createdb <POSTGRES_DB_NAME>
-```
-Name the database something relevant to the project so that you always know how to access it.
-
-### 2.3 Start the Graph Node and Connect to an Ethereum Node
-
-When you start the Graph Node, you need to specify which Ethereum network it should connect to. There are three common ways to do this:
- * Infura
- * A local Ethereum node
- * Ganache
-
-The Ethereum Network (Mainnet, Ropsten, Rinkeby, etc.) must be passed as a flag in the command that starts the Graph Node as laid out in the following subsections.
-
-#### 2.3.1 Infura
-
-[Infura](https://infura.io/) is supported and is the simplest way to connect to an Ethereum node because you do not have to set up your own geth or parity node. However, it does sync slower than being connected to your own node. The following flags are passed to start the Graph Node and indicate you want to use Infura:
-
-```sh
-cargo run -p graph-node --release -- \
-  --postgres-url postgresql://<USERNAME><:PASSWORD>@localhost:5432/<POSTGRES_DB_NAME> \
-  --ethereum-rpc <ETHEREUM_NETWORK_NAME>:https://mainnet.infura.io \
-  --ipfs 127.0.0.1:5001 \
-  --debug
-```
-
-Also, note that the Postgres database may not have a password at all. If that is the case, the Postgres connection URL can be passed as follows:
-
-`  --postgres-url postgresql://<USERNAME>@localhost:5432/<POSTGRES_DB_NAME> \ `
-
-#### 2.3.2 Local Geth or Parity Node
-
-This is the speediest way to get mainnet or testnet data. The problem is that if you do not already have a synced [geth](https://geth.ethereum.org/docs/getting-started) or [parity](https://github.com/paritytech/parity-ethereum) node, you will have to sync one, which takes a very long time and takes up a lot of space. Additionally, note that geth `fast sync` works. So, if you are starting from scratch, this is the fastest way to get caught up, but expect at least 12 hours of syncing on a modern laptop with a good internet connection to sync geth. Normal mode geth or parity will take much longer. Use the following geth command to start syncing:
-
-`geth --syncmode "fast" --rpc --ws --wsorigins="*" --rpcvhosts="*" --cache 1024`
-
-Once you have the local node fully synced, run the following command:
-
-```sh
-cargo run -p graph-node --release -- \
-  --postgres-url postgresql://<USERNAME><:PASSWORD>@localhost:5432/<POSTGRES_DB_NAME> \
-  --ethereum-rpc <ETHEREUM_NETWORK_NAME>:127.0.0.1:8545 \
-  --ipfs 127.0.0.1:5001 \
-  --debug
-```
-
-This assumes the local node is on the default `8545` port. If you are on a different port, change it.
-
-Switching back and forth between sourcing data from Infura and your own local nodes is fine. The Graph Node picks up where it left off.
-
-#### 2.3.3 Ganache
-
-**IMPORTANT: Ganache fixed the [issue](https://github.com/trufflesuite/ganache/issues/907) that prevented things from working properly. However, it did not release the new version. Follow the steps in this [issue](https://github.com/graphprotocol/graph-node/issues/375) to run the fixed version locally.**
-
-[Ganache](https://github.com/trufflesuite/ganache-cli) can be used as well and is preferable for quick testing. This might be an option if you are simply testing out the contracts for quick iterations. Of course, if you close Ganache, then the Graph Node will no longer have any data to source. Ganache is best for short-term projects such as hackathons. Also, it is useful for testing to see that the schema and mappings are working properly before working on the mainnet.
-
-You can connect the Graph Node to Ganache the same way you connected to a local geth or parity node in the previous section, 2.3.2. Note, however, that Ganache normally runs on port `9545` instead of `8545`.
-
-#### 2.3.4 Local Parity Testnet
-
-To set up a local testnet that will allow you to rapidly test the project, download the parity software if you do not already have it.
-
-This command will work for a one-line install:
-
-`bash <(curl https://get.parity.io -L)`
-
-Next, you want to make an account that you can unlock and make transactions on for the parity dev chain. Run the following command:
-
-`parity account new --chain dev`
-
-Create a password that you will remember. Take note of the account that gets output. Now, you also have to make that password a text file and pass it into the next command. The desktop is a good location for it. If the password is `123`, only put the numbers in the text file. Do not include any quotes.
-
-Then, run this command:
-
-`parity --config dev --unsafe-expose --jsonrpc-cors="all" --unlock <ACCOUNT_ADDRESS> --password ~/Desktop/password.txt`
-
-The chain should start and will be accessible by default on `localhost:8545`. It is a chain with 0 block time and instant transactions, making testing very fast. Passing `unsafe-expose` and `--jsonrpc-cors="all"` as flags allows MetaMask to connect. The `unlock` flag gives parity the ability to send transactions with that account. You can also import the account to MetaMask, which allows you to interact with the test chain directly in your browser. With MetaMask, you need to import the account with the private testnet Ether. The base account that the normal configuration of parity gives you is
-`0x00a329c0648769A73afAc7F9381E08FB43dBEA72`.
-
-The private key is:
-```
-4d5db4107d237df6a3d58ee5f70ae63d73d7658d4026f2eefd2f204c81682cb7 (note this is the private key given along with the parity dev chain, so it is okay to share)
-```
-Use MetaMask ---> import account ---> private key.
-
-All the extra information for customization of a parity dev chain is located [here](https://wiki.parity.io/Private-development-chain#customizing-the-development-chain).
-
-You now have an Ethereum account with a ton of Ether and should be able to set up the migrations on this network and use Truffle. Now, send some Ether to the previous account that was created and unlocked. This way, you can run `truffle migrate` with this account.
-
-#### 2.3.5 Syncing with a Public Testnet
-
-If you want to sync using a public testnet such as Kovan, Rinkeby, or Ropsten, just make sure the local node is a testnet node or that you are hitting the correct Infura testnet endpoint.
-
-### 2.4 Deploy the Subgraph
-
-When you deploy the subgraph to the Graph Node, it will start ingesting all the subgraph events from the blockchain, transforming that data with the subgraph mappings and storing it in the Graph Node. Note that a running subgraph can safely be stopped and restarted, picking up where it left off.
-
-Now that the infrastructure is set up, you can run `yarn create-subgraph` and then `yarn deploy` in the subgraph directory. These commands should have been added to `package.json` in section 1.3 when we took a moment to go through the set up for [Graph CLI documentation](https://github.com/graphprotocol/graph-tooling/tree/main/packages/cli). This builds the subgraph and creates the WASM files in the `dist/` folder. Next, it uploads the `dist/
-` files to IPFS and deploys it to the Graph Node. The subgraph is now fully running.
-
-The `watch` flag allows the subgraph to continually restart every time you save an update to the `manifest`, `schema`, or `mappings`. If you are making many edits or have a subgraph that has been syncing for a few hours, leave this flag off.
-
-Depending on how many events have been emitted by your smart contracts, it could take less than a minute to get fully caught up. If it is a large contract, it could take hours. For example, ENS takes about 12 to 14 hours to register every single ENS domain.
-
-## 3 Query the Local Graph Node
-With the subgraph deployed to the locally running Graph Node, visit http://127.0.0.1:8000/ to open up a [GraphiQL](https://github.com/graphql/graphiql) interface where you can explore the deployed GraphQL API for the subgraph by issuing queries and viewing the schema.
-
-We provide a few simple examples below, but please see the [Query API](https://github.com/graphprotocol/docs/blob/main/pages/en/querying/graphql-api.mdx#queries) for a complete reference on how to query the subgraph's entities.
-
-Query the `Token` entities:
-```graphql
-{
-  tokens(first: 100) {
-    id
-    currentOwner
-  }
-}
-```
-Notice that `tokens` is plural and that it will return at most 100 entities.
-
-Later, when you have deployed the subgraph with this entity, you can query for a specific value, such as the token ID:
-
-```graphql
-{
-  token(first: 100, id: "c2dac230ed4ced84ad0ca5dfb3ff8592d59cef7ff2983450113d74a47a12") {
-    currentOwner
-  }
-}
-```
-
-You can also sort, filter, or paginate query results. The query below would organize all tokens by their ID and return the current owner of each token.
-
-```graphql
-{
-  tokens(first: 100, orderBy: id) {
-    currentOwner
-  }
-}
-```
-
-GraphQL provides a ton of functionality. Once again, check out the [Query API](graphql-api.md#1-queries) to find out how to use all supported query features.
-
-## 4 Changing the Schema, Mappings, and Manifest, and Launching a New Subgraph
-
-When you first start building the subgraph, it is likely that you will make a few changes to the manifest, mappings, or schema. If you update any of them, rerun `yarn codegen` and `yarn deploy`. This will post the new files on IPFS and deploy the new subgraph. Note that the Graph Node can track multiple subgraphs, so you can do this as many times as you like.
-
-## 5 Common Patterns for Building Subgraphs
-
-### 5.1 Removing Elements of an Array in a Subgraph
-
-Using the AssemblyScript built-in functions for arrays is the way to go. Find the source code [here](https://github.com/AssemblyScript/assemblyscript/blob/18826798074c9fb02243dff76b1a938570a8eda7/std/assembly/array.ts). Using `.indexOf()` to find the element and then using `.splice()` is one way to do so. See this [file](https://github.com/graphprotocol/aragon-subgraph/blob/master/individual-dao-subgraph/mappings/ACL.ts) from the Aragon subgraph for a working implementation.
-
-### 5.2 Getting Data from Multiple Versions of Your Contracts
-
-If you have launched multiple versions of your smart contracts onto Ethereum, it is very easy to source data from all of them. This simply requires you to add all versions of the contracts to the `subgraph.yaml` file and handle the events from each contract. Design your schema to consider both versions, and handle any changes to the event signatures that are emitted from each version. See the [0x Subgraph](https://github.com/graphprotocol/0x-subgraph/tree/master/src/mappings) for an implementation of multiple versions of smart contracts being ingested by a subgraph.
-
-## 5 Example Subgraphs
-
-Here is a list of current subgraphs that we have open sourced:
-* https://github.com/graphprotocol/ens-subgraph
-* https://github.com/graphprotocol/decentraland-subgraph
-* https://github.com/graphprotocol/adchain-subgraph
-* https://github.com/graphprotocol/0x-subgraph
-* https://github.com/graphprotocol/aragon-subgraph
-* https://github.com/graphprotocol/dharma-subgraph
-* https://github.com/daostack/subgraph
-* https://github.com/graphprotocol/dydx-subgraph
-* https://github.com/livepeer/livepeerjs/tree/master/packages/subgraph
-* https://github.com/graphprotocol/augur-subgraph
-
-## Contributions
-
-All feedback and contributions in the form of issues and pull requests are welcome!
-
diff --git a/docs/graphman-graphql-api.md b/docs/graphman-graphql-api.md
new file mode 100644
index 00000000000..486bee6090d
--- /dev/null
+++ b/docs/graphman-graphql-api.md
@@ -0,0 +1,213 @@
+# Graphman GraphQL API
+
+The graphman API provides functionality to manage various aspects of `graph-node` through GraphQL operations. It is only
+started when the environment variable `GRAPHMAN_SERVER_AUTH_TOKEN` is set. The token is used to authenticate graphman
+GraphQL requests. Even with the token, the server should not be exposed externally as it provides operations that an
+attacker can use to severely impede the functioning of an indexer. The server listens on the port `GRAPHMAN_PORT`, port
+`8050` by default.
+
+Environment variables to control the graphman API:
+
+- `GRAPHMAN_SERVER_AUTH_TOKEN` - The token is used to authenticate graphman GraphQL requests.
+- `GRAPHMAN_PORT` - The port for the graphman GraphQL server (Defaults to `8050`)
+
+## GraphQL playground
+
+When the graphman GraphQL server is running the GraphQL playground is available at the following
+address: http://127.0.0.1:8050
+
+**Note:** The port might be different.
+
+Please make sure to set the authorization header to be able to use the playground:
+
+```json
+{
+  "Authorization": "Bearer GRAPHMAN_SERVER_AUTH_TOKEN"
+}
+```
+
+**Note:** There is a headers section at the bottom of the playground page.
+
+## Supported commands
+
+The playground is the best place to see the full schema, the latest available queries and mutations, and their
+documentation. Below, we will briefly describe some supported commands and example queries.
+
+At the time of writing, the following graphman commands are available via the GraphQL API:
+
+### Deployment Info
+
+Returns the available information about one, multiple, or all deployments.
+
+**Example query:**
+
+```text
+query {
+    deployment {
+        info(deployment: { hash: "Qm..." }) {
+            status {
+                isPaused
+            }
+        }
+    }
+}
+```
+
+**Example response:**
+
+```json
+{
+  "data": {
+    "deployment": {
+      "info": [
+        {
+          "status": {
+            "isPaused": false
+          }
+        }
+      ]
+    }
+  }
+}
+```
+
+### Pause Deployment
+
+Pauses a deployment that is not already paused.
+
+**Example query:**
+
+```text
+mutation {
+    deployment {
+        pause(deployment: { hash: "Qm..." }) {
+            success
+        }
+    }
+}
+```
+
+**Example response:**
+
+```json
+{
+  "data": {
+    "deployment": {
+      "pause": {
+        "success": true
+      }
+    }
+  }
+}
+```
+
+### Resume Deployment
+
+Resumes a deployment that has been previously paused.
+
+**Example query:**
+
+```text
+mutation {
+    deployment {
+        resume(deployment: { hash: "Qm..." }) {
+            success
+        }
+    }
+}
+```
+
+**Example response:**
+
+```json
+{
+  "data": {
+    "deployment": {
+      "resume": {
+        "success": true
+      }
+    }
+  }
+}
+```
+
+### Restart Deployment
+
+Pauses a deployment and resumes it after a delay.
+
+**Example query:**
+
+```text
+mutation {
+    deployment {
+        restart(deployment: { hash: "Qm..." }) {
+            id
+        }
+    }
+}
+```
+
+**Example response:**
+
+```json
+{
+  "data": {
+    "deployment": {
+      "restart": {
+        "id": "UNIQUE_EXECUTION_ID"
+      }
+    }
+  }
+}
+```
+
+This is a long-running command because the default delay before resuming the deployment is 20 seconds. Long-running
+commands are executed in the background. For long-running commands, the GraphQL API will return a unique execution ID.
+
+The ID can be used to query the execution status and the output of the command:
+
+```text
+query {
+  execution {
+      info(id: "UNIQUE_EXECUTION_ID") {
+          status
+          errorMessage
+      }
+  }
+}
+```
+
+**Example response when execution is in-progress:**
+
+```json
+{
+  "data": {
+    "execution": {
+      "info": {
+        "status": "RUNNING",
+        "errorMessage": null
+      }
+    }
+  }
+}
+```
+
+**Example response when execution is completed:**
+
+```json
+{
+  "data": {
+    "execution": {
+      "info": {
+        "status": "SUCCEEDED",
+        "errorMessage": null
+      }
+    }
+  }
+}
+```
+
+## Other commands
+
+GraphQL support for other graphman commands will be added over time, so please make sure to check the GraphQL playground
+for the full schema and the latest available queries and mutations.
diff --git a/docs/graphman.md b/docs/graphman.md
index 31353fbabc3..8c857703dda 100644
--- a/docs/graphman.md
+++ b/docs/graphman.md
@@ -371,21 +371,30 @@ Inspect all blocks after block `13000000`:
 
 Remove the call cache of the specified chain.
 
-If block numbers are not mentioned in `--from` and `--to`, then all the call cache will be removed.
+Either remove entries in the range `--from` and `--to`, remove stale contracts which have not been accessed for a specified duration `--ttl_days`, or remove the entire cache with `--remove-entire-cache`. Removing the entire cache can reduce indexing performance significantly and should generally be avoided.
 
-USAGE:
-    graphman chain call-cache <CHAIN_NAME> remove [OPTIONS]
+    Usage: graphman chain call-cache <CHAIN_NAME> remove [OPTIONS]
 
-OPTIONS:
-    -f, --from <FROM>
-            Starting block number
+    Options:
+        --remove-entire-cache
+            Remove the entire cache
+
+        --ttl-days <TTL_DAYS>
+            Remove stale contracts based on call_meta table
 
-    -h, --help
-            Print help information
+        --ttl-max-contracts <TTL_MAX_CONTRACTS>
+            Limit the number of contracts to consider for stale contract removal
+
+        -f, --from <FROM>
+            Starting block number
 
-    -t, --to <TO>
+        -t, --to <TO>
             Ending block number
 
+        -h, --help
+            Print help (see a summary with '-h')
+
+
 ### DESCRIPTION
 
 Remove the call cache of a specified chain.
@@ -404,6 +413,15 @@ the first block number will be used as the starting block number.
 The `to` option is used to specify the ending block number of the block range. In the absence of `to` option,
 the last block number will be used as the ending block number.
 
+#### `--remove-entire-cache`
+The `--remove-entire-cache` option is used to remove the entire call cache of the specified chain.
+
+#### `--ttl-days <TTL_DAYS>`
+The `--ttl-days` option is used to remove stale contracts based on the `call_meta.accessed_at` field. For example, if `--ttl-days` is set to 7, all calls to a contract that has not been accessed in the last 7 days will be removed from the call cache.
+
+#### `--ttl-max-contracts <TTL_MAX_CONTRACTS>`
+The `--ttl-max-contracts` option is used to limit the maximum number of contracts to be removed when using the `--ttl-days` option. For example, if `--ttl-max-contracts` is set to 100, at most 100 contracts will be removed from the call cache even if more contracts meet the TTL criteria.
+
 ### EXAMPLES
 
 Remove the call cache for all blocks numbered from 10 to 20:
@@ -412,5 +430,12 @@ Remove the call cache for all blocks numbered from 10 to 20:
 
 Remove all the call cache of the specified chain:
 
-    graphman --config config.toml chain call-cache ethereum remove
+    graphman --config config.toml chain call-cache ethereum remove --remove-entire-cache
+
+Remove stale contracts from the call cache that have not been accessed in the last 7 days:
+
+    graphman --config config.toml chain call-cache ethereum remove --ttl-days 7
+
+Remove stale contracts from the call cache that have not been accessed in the last 7 days, limiting the removal to a maximum of 100 contracts:
+    graphman --config config.toml chain call-cache ethereum remove --ttl-days 7 --ttl-max-contracts 100
 
diff --git a/docs/implementation/README.md b/docs/implementation/README.md
index 31d4eb694a6..d54a39babbe 100644
--- a/docs/implementation/README.md
+++ b/docs/implementation/README.md
@@ -10,3 +10,4 @@ the code should go into comments.
 * [SQL Query Generation](./sql-query-generation.md)
 * [Adding support for a new chain](./add-chain.md)
 * [Pruning](./pruning.md)
+* [Dump Format](./dump.md)
diff --git a/docs/implementation/add-chain.md b/docs/implementation/add-chain.md
deleted file mode 100644
index f4af3371f25..00000000000
--- a/docs/implementation/add-chain.md
+++ /dev/null
@@ -1,279 +0,0 @@
-# Adding support for a new chain
-
-## Context
-
-`graph-node` started as a project that could only index EVM compatible chains, eg: `ethereum`, `xdai`, etc.
-
-It was known from the start that with growth we would like `graph-node` to be able to index other chains like `NEAR`, `Solana`, `Cosmos`, list goes on...
-
-However to do it, several refactors were necessary, because the code had a great amount of assumptions based of how Ethereum works.
-
-At first there was a [RFC](https://github.com/graphprotocol/rfcs/blob/10aaae30fdf82f0dd2ccdf4bbecf7ec6bbfb703b/rfcs/0005-multi-blockchain-support.md) for a design overview, then actual PRs such as:
-
-- https://github.com/graphprotocol/graph-node/pull/2272
-- https://github.com/graphprotocol/graph-node/pull/2292
-- https://github.com/graphprotocol/graph-node/pull/2399
-- https://github.com/graphprotocol/graph-node/pull/2411
-- https://github.com/graphprotocol/graph-node/pull/2453
-- https://github.com/graphprotocol/graph-node/pull/2463
-- https://github.com/graphprotocol/graph-node/pull/2755
-
-All new chains, besides the EVM compatible ones, are integrated using [StreamingFast](https://www.streamingfast.io/)'s [Firehose](https://firehose.streamingfast.io/). The integration consists of chain specific `protobuf` files with the type definitions.
-
-## How to do it?
-
-The `graph-node` repository contains multiple Rust crates in it, this section will be divided in each of them that needs to be modified/created.
-
-> It's important to remember that this document is static and may not be up to date with the current implementation. Be aware too that it won't contain all that's needed, it's mostly listing the main areas that need change.
-
-### chain
-
-You'll need to create a new crate in the [chain folder](https://github.com/graphprotocol/graph-node/tree/1cd7936f9143f317feb51be1fc199122761fcbb1/chain) with an appropriate name and the same `version` as the rest of the other ones.
-
-> Note: you'll probably have to add something like `graph-chain-{{CHAIN_NAME}} = { path = "../chain/{{CHAIN_NAME}}" }` to the `[dependencies]` section of a few other `Cargo.toml` files
-
-It's here that you add the `protobuf` definitions with the specific types for the chain you're integrating with. Examples:
-
-- [Ethereum](https://github.com/graphprotocol/graph-node/blob/1cd7936f9143f317feb51be1fc199122761fcbb1/chain/ethereum/proto/codec.proto)
-- [NEAR](https://github.com/graphprotocol/graph-node/blob/1cd7936f9143f317feb51be1fc199122761fcbb1/chain/near/proto/codec.proto)
-- [Cosmos](https://github.com/graphprotocol/graph-node/blob/caa54c1039d3c282ac31bb0e96cb277dbf82f793/chain/cosmos/proto/type.proto)
-
-To compile those we use a crate called `tonic`, it will require a [`build.rs` file](https://doc.rust-lang.org/cargo/reference/build-scripts.html) like the one in the other folders/chains, eg:
-
-```rust
-fn main() {
-    println!("cargo:rerun-if-changed=proto");
-    tonic_build::configure()
-        .out_dir("src/protobuf")
-        .compile(&["proto/codec.proto"], &["proto"])
-        .expect("Failed to compile Firehose CoolChain proto(s)");
-}
-```
-
-You'll also need a `src/codec.rs` to extract the data from the generated Rust code, much like [this one](https://github.com/graphprotocol/graph-node/blob/caa54c1039d3c282ac31bb0e96cb277dbf82f793/chain/cosmos/src/codec.rs).
-
-Besides this source file, there should also be a `TriggerFilter`, `NodeCapabilities` and `RuntimeAdapter`, here are a few empty examples:
-
-`src/adapter.rs`
-```rust
-use crate::capabilities::NodeCapabilities;
-use crate::{data_source::DataSource, Chain};
-use graph::blockchain as bc;
-use graph::prelude::*;
-
-#[derive(Clone, Debug, Default)]
-pub struct TriggerFilter {}
-
-impl bc::TriggerFilter<Chain> for TriggerFilter {
-    fn extend<'a>(&mut self, _data_sources: impl Iterator<Item = &'a DataSource> + Clone) {}
-
-    fn node_capabilities(&self) -> NodeCapabilities {
-        NodeCapabilities {}
-    }
-
-    fn extend_with_template(
-        &mut self,
-        _data_source: impl Iterator<Item = <Chain as bc::Blockchain>::DataSourceTemplate>,
-    ) {
-    }
-
-    fn to_firehose_filter(self) -> Vec<prost_types::Any> {
-        vec![]
-    }
-}
-```
-
-`src/capabilities.rs`
-```rust
-use std::cmp::PartialOrd;
-use std::fmt;
-use std::str::FromStr;
-
-use anyhow::Error;
-use graph::impl_slog_value;
-
-use crate::DataSource;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd)]
-pub struct NodeCapabilities {}
-
-impl FromStr for NodeCapabilities {
-    type Err = Error;
-
-    fn from_str(_s: &str) -> Result<Self, Self::Err> {
-        Ok(NodeCapabilities {})
-    }
-}
-
-impl fmt::Display for NodeCapabilities {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("{{CHAIN_NAME}}")
-    }
-}
-
-impl_slog_value!(NodeCapabilities, "{}");
-
-impl graph::blockchain::NodeCapabilities<crate::Chain> for NodeCapabilities {
-    fn from_data_sources(_data_sources: &[DataSource]) -> Self {
-        NodeCapabilities {}
-    }
-}
-```
-
-`src/runtime/runtime_adapter.rs`
-```rust
-use crate::{Chain, DataSource};
-use anyhow::Result;
-use blockchain::HostFn;
-use graph::blockchain;
-
-pub struct RuntimeAdapter {}
-
-impl blockchain::RuntimeAdapter<Chain> for RuntimeAdapter {
-    fn host_fns(&self, _ds: &DataSource) -> Result<Vec<HostFn>> {
-        Ok(vec![])
-    }
-}
-```
-
-The chain specific type definitions should also be available for the `runtime`. Since it comes mostly from the `protobuf` files, there's a [generation tool](https://github.com/streamingfast/graph-as-to-rust) made by StreamingFast that you can use to create the `src/runtime/generated.rs`.
-
-You'll also have to implement `ToAscObj` for those types, that usually is made in a `src/runtime/abi.rs` file.
-
-Another thing that will be needed is the `DataSource` types for the [subgraph manifest](https://thegraph.com/docs/en/developer/create-subgraph-hosted/#the-subgraph-manifest).
-
-`src/data_source.rs`
-```rust
-#[derive(Clone, Debug)]
-pub struct DataSource {
-    // example fields:
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub source: Source,
-    pub mapping: Mapping,
-    pub context: Arc<Option<DataSourceContext>>,
-    pub creation_block: Option<BlockNumber>,
-    /*...*/
-}
-
-impl blockchain::DataSource<Chain> for DataSource { /*...*/ }
-
-#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
-pub struct UnresolvedDataSource {
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub source: Source,
-    pub mapping: UnresolvedMapping,
-    pub context: Option<DataSourceContext>,
-}
-
-#[async_trait]
-impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource { /*...*/ }
-
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
-pub struct BaseDataSourceTemplate<M> {
-    pub kind: String,
-    pub network: Option<String>,
-    pub name: String,
-    pub mapping: M,
-}
-
-pub type UnresolvedDataSourceTemplate = BaseDataSourceTemplate<UnresolvedMapping>;
-pub type DataSourceTemplate = BaseDataSourceTemplate<Mapping>;
-
-#[async_trait]
-impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTemplate { /*...*/ }
-
-impl blockchain::DataSourceTemplate<Chain> for DataSourceTemplate { /*...*/ }
-```
-
-And at last, the type that will glue them all, the `Chain` itself.
-
-`src/chain.rs`
-```rust
-pub struct Chain { /*...*/ }
-
-#[async_trait]
-impl Blockchain for Chain {
-    const KIND: BlockchainKind = BlockchainKind::CoolChain;
-
-    type Block = codec::...;
-
-    type DataSource = DataSource;
-
-    // ...
-
-    type TriggerFilter = TriggerFilter;
-
-    type NodeCapabilities = NodeCapabilities;
-
-    type RuntimeAdapter = RuntimeAdapter;
-}
-
-pub struct TriggersAdapter { /*...*/ }
-
-#[async_trait]
-impl TriggersAdapterTrait<Chain> for TriggersAdapter { /*...*/ }
-
-pub struct FirehoseMapper {
-    endpoint: Arc<FirehoseEndpoint>,
-}
-
-#[async_trait]
-impl FirehoseMapperTrait<Chain> for FirehoseMapper { /*...*/ }
-```
-
-### node
-
-The `src/main.rs` file should be able to handle the connection to the new chain via Firehose for the startup, similar to [this](https://github.com/graphprotocol/graph-node/blob/1cd7936f9143f317feb51be1fc199122761fcbb1/node/src/main.rs#L255).
-
-### graph
-
-Two changes are required here:
-
-1. [BlockchainKind](https://github.com/graphprotocol/graph-node/blob/1cd7936f9143f317feb51be1fc199122761fcbb1/graph/src/blockchain/mod.rs#L309) needs to have a new variant for the chain you're integrating with.
-2. And the [IndexForAscTypeId](https://github.com/graphprotocol/graph-node/blob/1cd7936f9143f317feb51be1fc199122761fcbb1/graph/src/runtime/mod.rs#L147) should have the new variants for the chain specific types of the `runtime`.
-
-### server
-
-You'll just have to handle the new `BlockchainKind` in the [index-node/src/resolver.rs](https://github.com/graphprotocol/graph-node/blob/1cd7936f9143f317feb51be1fc199122761fcbb1/server/index-node/src/resolver.rs#L361).
-
-### core
-
-Just like in the `server` crate, you'll just have to handle the new `BlockchainKind` in the [SubgraphInstanceManager](https://github.com/graphprotocol/graph-node/blob/1cd7936f9143f317feb51be1fc199122761fcbb1/core/src/subgraph/instance_manager.rs#L41).
-
-## Example Integrations (PRs)
-
-- NEAR by StreamingFast
-  - https://github.com/graphprotocol/graph-node/pull/2820
-- Cosmos by Figment
-  - https://github.com/graphprotocol/graph-node/pull/3212
-  - https://github.com/graphprotocol/graph-node/pull/3543
-- Solana by StreamingFast
-  - https://github.com/graphprotocol/graph-node/pull/3210
-
-## What else?
-
-Besides making `graph-node` support the new chain, [graph-cli](https://github.com/graphprotocol/graph-tooling/tree/main/packages/cli) and [graph-ts](https://github.com/graphprotocol/graph-tooling/tree/main/packages/ts) should also include the new types and enable the new functionality so that subgraph developers can use it.
-
-For now this document doesn't include how to do that integration, here are a few PRs that might help you with that:
-
-- NEAR
-  - `graph-cli`
-    - https://github.com/graphprotocol/graph-tooling/pull/760
-    - https://github.com/graphprotocol/graph-tooling/pull/783
-  - `graph-ts`
-    - https://github.com/graphprotocol/graph-ts/pull/210
-    - https://github.com/graphprotocol/graph-ts/pull/217
-- Cosmos
-  - `graph-cli`
-    - https://github.com/graphprotocol/graph-tooling/pull/827
-    - https://github.com/graphprotocol/graph-tooling/pull/851
-    - https://github.com/graphprotocol/graph-toolingpull/888
-  - `graph-ts`
-    - https://github.com/graphprotocol/graph-ts/pull/250
-    - https://github.com/graphprotocol/graph-ts/pull/273
-
-Also this document doesn't include the multi-blockchain part required for The Graph Network, which at this current moment is in progress, for now the network only supports Ethereum `mainnet`.
diff --git a/docs/implementation/metadata.md b/docs/implementation/metadata.md
index 562bc371e71..1cf3c189c6c 100644
--- a/docs/implementation/metadata.md
+++ b/docs/implementation/metadata.md
@@ -7,7 +7,7 @@
 List of all known subgraph names. Maintained in the primary, but there is a background job that periodically copies the table from the primary to all other shards. Those copies are used for queries when the primary is down.
 
 | Column            | Type         | Use                                       |
-|-------------------|--------------|-------------------------------------------|
+| ----------------- | ------------ | ----------------------------------------- |
 | `id`              | `text!`      | primary key, UUID                         |
 | `name`            | `text!`      | user-chosen name                          |
 | `current_version` | `text`       | `subgraph_version.id` for current version |
@@ -18,13 +18,12 @@ List of all known subgraph names. Maintained in the primary, but there is a back
 
 The `id` is used by the hosted explorer to reference the subgraph.
 
-
 ### `subgraphs.subgraph_version`
 
 Mapping of subgraph names from `subgraph` to IPFS hashes. Maintained in the primary, but there is a background job that periodically copies the table from the primary to all other shards. Those copies are used for queries when the primary is down.
 
 | Column        | Type         | Use                     |
-|---------------|--------------|-------------------------|
+| ------------- | ------------ | ----------------------- |
 | `id`          | `text!`      | primary key, UUID       |
 | `subgraph`    | `text!`      | `subgraph.id`           |
 | `deployment`  | `text!`      | IPFS hash of deployment |
@@ -32,15 +31,14 @@ Mapping of subgraph names from `subgraph` to IPFS hashes. Maintained in the prim
 | `vid`         | `int8!`      | unused                  |
 | `block_range` | `int4range!` | unused                  |
 
-
 ## Managing a deployment
 
 Directory of all deployments. Maintained in the primary, but there is a background job that periodically copies the table from the primary to all other shards. Those copies are used for queries when the primary is down.
 
-### `deployment_schemas`
+### `public.deployment_schemas`
 
 | Column       | Type           | Use                                          |
-|--------------|----------------|----------------------------------------------|
+| ------------ | -------------- | -------------------------------------------- |
 | `id`         | `int4!`        | primary key                                  |
 | `subgraph`   | `text!`        | IPFS hash of deployment                      |
 | `name`       | `text!`        | name of `sgdNNN` schema                      |
@@ -52,49 +50,66 @@ Directory of all deployments. Maintained in the primary, but there is a backgrou
 
 There can be multiple copies of the same deployment, but at most one per shard. The `active` flag indicates which of these copies will be used for queries; `graph-node` makes sure that there is always exactly one for each IPFS hash.
 
-### `subgraph_deployment`
+### `subgraphs.head`
+
+Details about a deployment that change on every block. Maintained in the
+shard alongside the deployment's data in `sgdNNN`.
+
+| Column            | Type       | Use                                          |
+| ----------------- | ---------- | -------------------------------------------- |
+| `id`              | `integer!` | primary key, same as `deployment_schemas.id` |
+| `block_hash`      | `bytea`    | current subgraph head                        |
+| `block_number`    | `numeric`  |                                              |
+| `entity_count`    | `numeric!` | total number of entities                     |
+| `firehose_cursor` | `text`     |                                              |
+
+The head block pointer in `block_number` and `block_hash` is the latest
+block that has been fully processed by the deployment. It will be `null`
+until the deployment is fully initialized, and only set when the deployment
+processes the first block. For deployments that are grafted or being copied,
+the head block pointer will be `null` until the graft/copy has finished
+which can take considerable time.
+
+### `subgraphs.deployment`
 
 Details about a deployment to track sync progress etc. Maintained in the
 shard alongside the deployment's data in `sgdNNN`. The table should only
-contain frequently changing data, but for historical reasons contains also
-static data.
-
-| Column                               | Type       | Use                                          |
-|--------------------------------------|------------|----------------------------------------------|
-| `id`                                 | `integer!` | primary key, same as `deployment_schemas.id` |
-| `deployment`                         | `text!`    | IPFS hash                                    |
-| `failed`                             | `boolean!` |                                              |
-| `synced`                             | `boolean!` |                                              |
-| `earliest_block_number`              | `integer!` | earliest block for which we have data        |
-| `latest_ethereum_block_hash`         | `bytea`    | current subgraph head                        |
-| `latest_ethereum_block_number`       | `numeric`  |                                              |
-| `entity_count`                       | `numeric!` | total number of entities                     |
-| `graft_base`                         | `text`     | IPFS hash of graft base                      |
-| `graft_block_hash`                   | `bytea`    | graft block                                  |
-| `graft_block_number`                 | `numeric`  |                                              |
-| `reorg_count`                        | `integer!` |                                              |
-| `current_reorg_depth`                | `integer!` |                                              |
-| `max_reorg_depth`                    | `integer!` |                                              |
-| `fatal_error`                        | `text`     |                                              |
-| `non_fatal_errors`                   | `text[]`   |                                              |
-| `health`                             | `health!`  |                                              |
-| `last_healthy_ethereum_block_hash`   | `bytea`    |                                              |
-| `last_healthy_ethereum_block_number` | `numeric`  |                                              |
-| `firehose_cursor`                    | `text`     |                                              |
-| `debug_fork`                         | `text`     |                                              |
+contain data that changes fairly infrequently, but for historical reasons
+contains also static data.
+
+| Column                               | Type          | Use                                                  |
+| ------------------------------------ | ------------- | ---------------------------------------------------- |
+| `id`                                 | `integer!`    | primary key, same as `deployment_schemas.id`         |
+| `subgraph`                           | `text!`       | IPFS hash                                            |
+| `earliest_block_number`              | `integer!`    | earliest block for which we have data                |
+| `health`                             | `health!`     |                                                      |
+| `failed`                             | `boolean!`    |                                                      |
+| `fatal_error`                        | `text`        |                                                      |
+| `non_fatal_errors`                   | `text[]`      |                                                      |
+| `graft_base`                         | `text`        | IPFS hash of graft base                              |
+| `graft_block_hash`                   | `bytea`       | graft block                                          |
+| `graft_block_number`                 | `numeric`     |                                                      |
+| `reorg_count`                        | `integer!`    |                                                      |
+| `current_reorg_depth`                | `integer!`    |                                                      |
+| `max_reorg_depth`                    | `integer!`    |                                                      |
+| `last_healthy_ethereum_block_hash`   | `bytea`       |                                                      |
+| `last_healthy_ethereum_block_number` | `numeric`     |                                                      |
+| `debug_fork`                         | `text`        |                                                      |
+| `synced_at`                          | `timestamptz` | time when deployment first reach chain head          |
+| `synced_at_block_number`             | `integer`     | block number where deployment first reach chain head |
 
 The columns `reorg_count`, `current_reorg_depth`, and `max_reorg_depth` are
 set during indexing. They are used to determine whether a reorg happened
 while a query was running, and whether that reorg could have affected the
 query.
 
-### `subgraph_manifest`
+### `subgraphs.subgraph_manifest`
 
 Details about a deployment that rarely change. Maintained in the
 shard alongside the deployment's data in `sgdNNN`.
 
 | Column                  | Type       | Use                                                  |
-|-------------------------|------------|------------------------------------------------------|
+| ----------------------- | ---------- | ---------------------------------------------------- |
 | `id`                    | `integer!` | primary key, same as `deployment_schemas.id`         |
 | `spec_version`          | `text!`    |                                                      |
 | `description`           | `text`     |                                                      |
@@ -108,25 +123,25 @@ shard alongside the deployment's data in `sgdNNN`.
 | `on_sync`               | `text`     | Additional behavior when deployment becomes synced   |
 | `history_blocks`        | `int4!`    | How many blocks of history to keep                   |
 
-### `subgraph_deployment_assignment`
+### `subgraphs.subgraph_deployment_assignment`
 
 Tracks which index node is indexing a deployment. Maintained in the primary,
 but there is a background job that periodically copies the table from the
 primary to all other shards.
 
 | Column  | Type  | Use                                         |
-|---------|-------|---------------------------------------------|
+| ------- | ----- | ------------------------------------------- |
 | id      | int4! | primary key, ref to `deployment_schemas.id` |
 | node_id | text! | name of index node                          |
 
 This table could simply be a column on `deployment_schemas`.
 
-### `dynamic_ethereum_contract_data_source`
+### `subgraphs.dynamic_ethereum_contract_data_source`
 
 Stores the dynamic data sources for all subgraphs (will be turned into a
 table that lives in each subgraph's namespace `sgdNNN` soon)
 
-### `subgraph_error`
+### `subgraphs.subgraph_error`
 
 Stores details about errors that subgraphs encounter during indexing.
 
@@ -147,7 +162,7 @@ should have the 'account-like' optimization turned on.
 Details about features that a deployment uses, Maintained in the primary.
 
 | Column         | Type      | Use         |
-|----------------|-----------|-------------|
+| -------------- | --------- | ----------- |
 | `id`           | `text!`   | primary key |
 | `spec_version` | `text!`   |             |
 | `api_version`  | `text`    |             |
diff --git a/docs/implementation/sql-interface.md b/docs/implementation/sql-interface.md
new file mode 100644
index 00000000000..6b90fe6da9c
--- /dev/null
+++ b/docs/implementation/sql-interface.md
@@ -0,0 +1,89 @@
+# SQL Queries
+
+**This interface is extremely experimental. There is no guarantee that this
+interface will ever be brought to production use. It's solely here to help
+evaluate the utility of such an interface**
+
+**The interface is only available if the environment variable `GRAPH_ENABLE_SQL_QUERIES` is set to `true`**
+
+SQL queries can be issued by posting a JSON document to
+`/subgraphs/sql`. The server will respond with a JSON response that
+contains the records matching the query in JSON form.
+
+The body of the request must contain the following keys:
+
+* `deployment`: the hash of the deployment against which the query should
+  be run
+* `query`: the SQL query
+* `mode`: either `info` or `data`. When the mode is `info` only some
+  information of the response is reported, with a mode of `data` the query
+  result is sent in the response
+
+The SQL query can use all the tables of the given subgraph. Table and
+attribute names for normal `@entity` types are snake-cased from their form
+in the GraphQL schema, so that data for `SomeDailyStuff` is stored in a
+table `some_daily_stuff`. For `@aggregation` types, the table can be
+accessed as `<aggregation>(<interval>)`, for example, `my_stats('hour')` for
+`type MyStats @aggregation(..) { .. }`
+
+The query can use fairly arbitrary SQL, including aggregations and most
+functions built into PostgreSQL.
+
+## Example
+
+For a subgraph whose schema defines an entity `Block`, the following query
+```json
+{
+    "query": "select number, hash, parent_hash, timestamp from block order by number desc limit 2",
+    "deployment": "QmSoMeThInG",
+    "mode": "data"
+}
+```
+
+might result in this response
+```json
+{
+  "data": [
+    {
+      "hash": "\\x5f91e535ee4d328725b869dd96f4c42059e3f2728dfc452c32e5597b28ce68d6",
+      "number": 5000,
+      "parent_hash": "\\x82e95c1ee3a98cd0646225b5ae6afc0b0229367b992df97aeb669c898657a4bb",
+      "timestamp": "2015-07-30T20:07:44+00:00"
+    },
+    {
+      "hash": "\\x82e95c1ee3a98cd0646225b5ae6afc0b0229367b992df97aeb669c898657a4bb",
+      "number": 4999,
+      "parent_hash": "\\x875c9a0f8215258c3b17fd5af5127541121cca1f594515aae4fbe5a7fbef8389",
+      "timestamp": "2015-07-30T20:07:36+00:00"
+    }
+  ]
+}
+```
+
+## Limitations/Ideas/Disclaimers
+
+Most of these are fairly easy to address:
+
+- bind variables/query parameters are not supported, only literal SQL
+  queries
+* queries must finish within `GRAPH_SQL_STATEMENT_TIMEOUT` (unlimited by
+  default)
+* queries are always executed at the subgraph head. It would be easy to add
+  a way to specify a block at which the query should be executed
+* the interface right now pretty much exposes the raw SQL schema for a
+  subgraph, though system columns like `vid` or `block_range` are made
+  inaccessible.
+* it is not possible to join across subgraphs, though it would be possible
+  to add that. Implenting that would require some additional plumbing that
+  hides the effects of sharding.
+* JSON as the response format is pretty terrible, and we should change that
+  to something that isn't so inefficient
+* the response contains data that's pretty raw; as the example shows,
+  binary data uses Postgres' notation for hex strings
+* because of how broad the supported SQL is, it is pretty easy to issue
+  queries that take a very long time. It will therefore not be hard to take
+  down a `graph-node`, especially when no query timeout is set
+
+Most importantly: while quite a bit of effort has been put into making this
+interface safe, in particular, making sure it's not possible to write
+through this interface, there's no guarantee that this works without bugs.
diff --git a/docs/log-store.md b/docs/log-store.md
new file mode 100644
index 00000000000..8be1cddecd8
--- /dev/null
+++ b/docs/log-store.md
@@ -0,0 +1,853 @@
+# Log Store Configuration and Usage
+
+This guide explains how to configure subgraph indexing logs storage in graph-node.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [How Log Stores Work](#how-log-stores-work)
+- [Log Store Types](#log-store-types)
+  - [File-based Logs](#file-based-logs)
+  - [Elasticsearch](#elasticsearch)
+  - [Loki](#loki)
+  - [Disabled](#disabled)
+- [Configuration](#configuration)
+  - [Environment Variables](#environment-variables)
+  - [CLI Arguments](#cli-arguments)
+  - [Configuration Precedence](#configuration-precedence)
+- [Querying Logs](#querying-logs)
+- [Migrating from Deprecated Configuration](#migrating-from-deprecated-configuration)
+- [Choosing the Right Backend](#choosing-the-right-backend)
+- [Best Practices](#best-practices)
+- [Troubleshooting](#troubleshooting)
+
+## Overview
+
+Graph Node supports multiple logs storage backends for subgraph indexing logs. Subgraph indexing logs include:
+- **User-generated logs**: Explicit logging from subgraph mapping code (`log.info()`, `log.error()`, etc.)
+- **Runtime logs**: Handler execution, event processing, data source activity
+- **System logs**: Warnings, errors, and diagnostics from the indexing system
+
+**Available backends:**
+- **File**: JSON Lines files on local filesystem (for local development)
+- **Elasticsearch**: Enterprise-grade search and analytics (for production)
+- **Loki**: Grafana's lightweight log aggregation system (for production)
+- **Disabled**: No log storage (default)
+
+All backends share the same query interface through GraphQL, making it easy to switch between them.
+
+**Important Note:** When log storage is disabled (the default), subgraph logs still appear in stdout/stderr as they always have. The "disabled" setting simply means logs are not stored separately in a queryable format. You can still see logs in your terminal or container logs - they just won't be available via the `_logs` GraphQL query.
+
+## How Log Stores Work
+
+### Architecture
+
+```
+┌─────────────────┐
+│  Subgraph Code  │
+│   (mappings)    │
+└────────┬────────┘
+         │ log.info(), log.error(), etc.
+         ▼
+┌─────────────────┐
+│  Graph Runtime  │
+│   (WebAssembly) │
+└────────┬────────┘
+         │ Log events
+         ▼
+┌─────────────────┐
+│   Log Drain     │  ◄─── slog-based logging system
+└────────┬────────┘
+         │ Write
+         ▼
+┌─────────────────┐
+│   Log Store     │  ◄─── Configurable backend
+│  (ES/Loki/File) │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  GraphQL API    │  ◄─── Unified query interface
+│  (port 8000)    │
+└─────────────────┘
+```
+
+### Log Flow
+
+1. **Log sources** generate logs from:
+   - User mapping code (explicit `log.info()`, `log.error()`, etc. calls)
+   - Subgraph runtime (handler execution, event processing, data source triggers)
+   - System warnings and errors (indexing issues, constraint violations, etc.)
+2. **Graph runtime** captures these logs with metadata (timestamp, level, source location)
+3. **Log drain** formats logs and writes to configured backend
+4. **Log store** persists logs and handles queries
+5. **GraphQL API** exposes logs through the `_logs` query
+
+### Log Entry Structure
+
+Each log entry contains:
+- **`id`**: Unique identifier
+- **`subgraphId`**: Deployment hash (QmXxx...)
+- **`timestamp`**: ISO 8601 timestamp (e.g., `2024-01-15T10:30:00.123456789Z`)
+- **`level`**: CRITICAL, ERROR, WARNING, INFO, or DEBUG
+- **`text`**: Log message
+- **`arguments`**: Key-value pairs from structured logging
+- **`meta`**: Source location (module, line, column)
+
+## Log Store Types
+
+### File-based Logs
+
+**Best for:** Local development, testing
+
+#### How It Works
+
+File-based logs store each subgraph's logs in a separate JSON Lines (`.jsonl`) file:
+
+```
+graph-logs/
+├── QmSubgraph1Hash.jsonl
+├── QmSubgraph2Hash.jsonl
+└── QmSubgraph3Hash.jsonl
+```
+
+Each line in the file is a complete JSON object representing one log entry.
+
+#### Storage Format
+
+```json
+{"id":"QmTest-2024-01-15T10:30:00.123456789Z","subgraphId":"QmTest","timestamp":"2024-01-15T10:30:00.123456789Z","level":"error","text":"Handler execution failed, retries: 3","arguments":[{"key":"retries","value":"3"}],"meta":{"module":"mapping.ts","line":42,"column":10}}
+```
+
+#### Query Performance
+
+File-based logs stream through files line-by-line with bounded memory usage.
+
+**Performance characteristics:**
+- Query time: O(n) where n = number of log entries
+- Memory usage: O(skip + first) - only matching entries kept in memory
+- Suitable for: Development and testing
+
+#### Configuration
+
+**Minimum configuration (CLI):**
+```bash
+graph-node \
+  --postgres-url postgresql://graph:pass@localhost/graph-node \
+  --ethereum-rpc mainnet:https://... \
+  --ipfs 127.0.0.1:5001 \
+  --log-store-backend file \
+  --log-store-file-dir ./graph-logs
+```
+
+**Full configuration (environment variables):**
+```bash
+export GRAPH_LOG_STORE_BACKEND=file
+export GRAPH_LOG_STORE_FILE_DIR=/var/log/graph-node
+export GRAPH_LOG_STORE_FILE_MAX_SIZE=104857600      # 100MB
+export GRAPH_LOG_STORE_FILE_RETENTION_DAYS=30
+```
+
+#### Features
+
+**Advantages:**
+- No external dependencies
+- Simple setup (just specify a directory)
+- Human-readable format (JSON Lines)
+- Easy to inspect with standard tools (`jq`, `grep`, etc.)
+- Good for debugging during development
+
+**Limitations:**
+- Not suitable for production with high log volume
+- No indexing (O(n) query time scales with file size)
+- No automatic log rotation or retention management
+- Single file per subgraph (no sharding)
+
+#### When to Use
+
+Use file-based logs when:
+- Developing subgraphs locally
+- Testing on a development machine
+- Running low-traffic subgraphs (< 1000 total logs/day including system logs)
+- You want simple log access without external services
+
+### Elasticsearch
+
+**Best for:** Production deployments, high log volume, advanced search
+
+#### How It Works
+
+Elasticsearch stores logs in indices with full-text search capabilities, making it ideal for production deployments with high log volume.
+
+**Architecture:**
+```
+graph-node → Elasticsearch HTTP API → Elasticsearch cluster
+                                    → Index: subgraph-logs-*
+                                    → Query DSL for filtering
+```
+
+#### Features
+
+**Advantages:**
+- **Indexed searching**: Fast queries even with millions of logs
+- **Full-text search**: Powerful text search across log messages
+- **Scalability**: Handles billions of log entries
+- **High availability**: Supports clustering and replication
+- **Kibana integration**: Rich visualization and dashboards for operators
+- **Time-based indices**: Efficient retention management
+
+**Considerations:**
+- Requires Elasticsearch cluster (infrastructure overhead)
+- Resource-intensive (CPU, memory, disk)
+
+#### Configuration
+
+**Minimum configuration (CLI):**
+```bash
+graph-node \
+  --postgres-url postgresql://graph:pass@localhost/graph-node \
+  --ethereum-rpc mainnet:https://... \
+  --ipfs 127.0.0.1:5001 \
+  --log-store-backend elasticsearch \
+  --log-store-elasticsearch-url http://localhost:9200
+```
+
+**Full configuration with authentication:**
+```bash
+graph-node \
+  --postgres-url postgresql://graph:pass@localhost/graph-node \
+  --ethereum-rpc mainnet:https://... \
+  --ipfs 127.0.0.1:5001 \
+  --log-store-backend elasticsearch \
+  --log-store-elasticsearch-url https://es.example.com:9200 \
+  --log-store-elasticsearch-user elastic \
+  --log-store-elasticsearch-password secret \
+  --log-store-elasticsearch-index subgraph-logs
+```
+
+**Environment variables:**
+```bash
+export GRAPH_LOG_STORE_BACKEND=elasticsearch
+export GRAPH_LOG_STORE_ELASTICSEARCH_URL=http://localhost:9200
+export GRAPH_LOG_STORE_ELASTICSEARCH_USER=elastic
+export GRAPH_LOG_STORE_ELASTICSEARCH_PASSWORD=secret
+export GRAPH_LOG_STORE_ELASTICSEARCH_INDEX=subgraph-logs
+```
+
+#### Index Configuration
+
+Logs are stored in the configured index (default: `subgraph`). The index mapping is automatically created.
+
+**Recommended index settings for production:**
+```json
+{
+  "settings": {
+    "number_of_shards": 3,
+    "number_of_replicas": 1,
+    "refresh_interval": "5s"
+  }
+}
+```
+
+#### Query Performance
+
+**Performance characteristics:**
+- Query time: O(log n) with indexing
+- Memory usage: Minimal (server-side filtering)
+- Suitable for: Millions to billions of log entries
+
+#### When to Use
+
+Use Elasticsearch when:
+- Running production deployments
+- High log volume
+- Need advanced search and filtering
+- Want to build dashboards with Kibana
+- Need high availability and scalability
+- Have DevOps resources to manage Elasticsearch or can set up a managed ElasticSearch deployment
+
+### Loki
+
+**Best for:** Production deployments, Grafana users, cost-effective at scale
+
+#### How It Works
+
+Loki is Grafana's log aggregation system, designed to be cost-effective and easy to operate. Unlike Elasticsearch, Loki only indexes metadata (not full-text), making it more efficient for time-series log data.
+
+**Architecture:**
+```
+graph-node → Loki HTTP API → Loki
+                           → Stores compressed chunks
+                           → Indexes labels only
+```
+
+#### Features
+
+**Advantages:**
+- **Cost-effective**: Lower storage costs than Elasticsearch
+- **Grafana integration**: Native integration with Grafana
+- **Horizontal scalability**: Designed for cloud-native deployments
+- **Multi-tenancy**: Built-in tenant isolation
+- **Efficient compression**: Optimized for log data
+- **LogQL**: Powerful query language similar to PromQL
+- **Lower resource usage**: Less CPU/memory than Elasticsearch
+
+**Considerations:**
+- No full-text indexing (slower text searches)
+- Best used with Grafana (less tooling than Elasticsearch)
+- Younger ecosystem than Elasticsearch
+- Query performance depends on label cardinality
+
+#### Configuration
+
+**Minimum configuration (CLI):**
+```bash
+graph-node \
+  --postgres-url postgresql://graph:pass@localhost/graph-node \
+  --ethereum-rpc mainnet:https://... \
+  --ipfs 127.0.0.1:5001 \
+  --log-store-backend loki \
+  --log-store-loki-url http://localhost:3100
+```
+
+**With multi-tenancy:**
+```bash
+graph-node \
+  --postgres-url postgresql://graph:pass@localhost/graph-node \
+  --ethereum-rpc mainnet:https://... \
+  --ipfs 127.0.0.1:5001 \
+  --log-store-backend loki \
+  --log-store-loki-url http://localhost:3100 \
+  --log-store-loki-tenant-id my-graph-node
+```
+
+**Environment variables:**
+```bash
+export GRAPH_LOG_STORE_BACKEND=loki
+export GRAPH_LOG_STORE_LOKI_URL=http://localhost:3100
+export GRAPH_LOG_STORE_LOKI_TENANT_ID=my-graph-node
+```
+
+#### Labels
+
+Loki uses labels for indexing. Graph Node automatically creates labels:
+- `subgraph_id`: Deployment hash
+- `level`: Log level
+- `job`: "graph-node"
+
+#### Query Performance
+
+**Performance characteristics:**
+- Query time: O(n) for text searches, O(log n) for label queries
+- Memory usage: Minimal (server-side processing)
+- Suitable for: Millions to billions of log entries
+- Best performance with label-based filtering
+
+#### When to Use
+
+Use Loki when:
+- Already using Grafana for monitoring
+- Need cost-effective log storage at scale
+- Want simpler operations than Elasticsearch
+- Multi-tenancy is required
+- Log volume is very high (> 1M logs/day)
+- Full-text search is not critical
+
+### Disabled
+
+**Best for:** Minimalist deployments, reduced overhead
+
+#### How It Works
+
+When log storage is disabled (the default), subgraph logs are **still written to stdout/stderr** along with all other graph-node logs. They are just **not stored separately** in a queryable format.
+
+**Important:** "Disabled" does NOT mean logs are discarded. It means:
+- Logs appear in stdout/stderr (traditional behavior)
+- Logs are not stored in a separate queryable backend
+- The `_logs` GraphQL query returns empty results
+
+This is the default behavior - logs continue to work exactly as they did before this feature was added.
+
+#### Configuration
+
+**Explicitly disable:**
+```bash
+export GRAPH_LOG_STORE_BACKEND=disabled
+```
+
+**Or simply don't configure a backend** (defaults to disabled):
+```bash
+# No log store configuration = disabled
+graph-node \
+  --postgres-url postgresql://graph:pass@localhost/graph-node \
+  --ethereum-rpc mainnet:https://... \
+  --ipfs 127.0.0.1:5001
+```
+
+#### Features
+
+**Advantages:**
+- Zero additional overhead
+- No external dependencies
+- Minimal configuration
+- Logs still appear in stdout/stderr for debugging
+
+**Limitations:**
+- Cannot query logs via GraphQL (`_logs` returns empty results)
+- No separation of subgraph logs from other graph-node logs in stdout
+- Logs mixed with system logs (harder to filter programmatically)
+- No structured querying or filtering capabilities
+
+#### When to Use
+
+Use disabled log storage when:
+- Running minimal test deployments with less dependencies
+- Exposing logs to users is not required for your use case
+- You'd like subgraph logs sent to external log collection (e.g., container logs)
+
+## Configuration
+
+### Environment Variables
+
+Environment variables are the recommended way to configure log stores, especially in containerized deployments.
+
+#### Backend Selection
+
+```bash
+GRAPH_LOG_STORE_BACKEND=<backend>
+```
+Valid values: `disabled`, `elasticsearch`, `loki`, `file`
+
+#### Elasticsearch
+
+```bash
+GRAPH_LOG_STORE_ELASTICSEARCH_URL=http://localhost:9200
+GRAPH_LOG_STORE_ELASTICSEARCH_USER=elastic          # Optional
+GRAPH_LOG_STORE_ELASTICSEARCH_PASSWORD=secret       # Optional
+GRAPH_LOG_STORE_ELASTICSEARCH_INDEX=subgraph        # Default: "subgraph"
+```
+
+#### Loki
+
+```bash
+GRAPH_LOG_STORE_LOKI_URL=http://localhost:3100
+GRAPH_LOG_STORE_LOKI_TENANT_ID=my-tenant           # Optional
+```
+
+#### File
+
+```bash
+GRAPH_LOG_STORE_FILE_DIR=/var/log/graph-node
+GRAPH_LOG_STORE_FILE_MAX_SIZE=104857600            # Default: 100MB
+GRAPH_LOG_STORE_FILE_RETENTION_DAYS=30             # Default: 30
+```
+
+### CLI Arguments
+
+CLI arguments provide the same functionality as environment variables and the two can be mixed together.
+
+#### Backend Selection
+
+```bash
+--log-store-backend <backend>
+```
+
+#### Elasticsearch
+
+```bash
+--log-store-elasticsearch-url <URL>
+--log-store-elasticsearch-user <USER>
+--log-store-elasticsearch-password <PASSWORD>
+--log-store-elasticsearch-index <INDEX>
+```
+
+#### Loki
+
+```bash
+--log-store-loki-url <URL>
+--log-store-loki-tenant-id <TENANT_ID>
+```
+
+#### File
+
+```bash
+--log-store-file-dir <DIR>
+--log-store-file-max-size <BYTES>
+--log-store-file-retention-days <DAYS>
+```
+
+### Configuration Precedence
+
+When multiple configuration methods are used:
+
+1. **CLI arguments** take highest precedence
+2. **Environment variables** are used if no CLI args provided
+3. **Defaults** are used if neither is set
+
+## Querying Logs
+
+All log backends share the same GraphQL query interface. Logs are queried through the subgraph-specific GraphQL endpoint:
+
+- **Subgraph by deployment**: `http://localhost:8000/subgraphs/id/<deployment-hash>`
+- **Subgraph by name**: `http://localhost:8000/subgraphs/name/<subgraph-name>`
+
+The `_logs` query is automatically scoped to the subgraph in the URL, so you don't need to pass a `subgraphId` parameter.
+
+**Note**: Queries return all log types - both user-generated logs from mapping code and system-generated runtime logs (handler execution, events, warnings, etc.). Use the `search` filter to search for specific messages, or `level` to filter by severity.
+
+### Basic Query
+
+Query the `_logs` field at your subgraph's GraphQL endpoint:
+
+```graphql
+query {
+  _logs(
+    first: 100
+  ) {
+    id
+    timestamp
+    level
+    text
+  }
+}
+```
+
+**Example endpoint**: `http://localhost:8000/subgraphs/id/QmYourDeploymentHash`
+
+### Query with Filters
+
+```graphql
+query {
+  _logs(
+    level: ERROR
+    from: "2024-01-01T00:00:00Z"
+    to: "2024-01-31T23:59:59Z"
+    search: "timeout"
+    first: 50
+    skip: 0
+  ) {
+    id
+    timestamp
+    level
+    text
+    arguments {
+      key
+      value
+    }
+    meta {
+      module
+      line
+      column
+    }
+  }
+}
+```
+
+### Available Filters
+
+| Filter | Type | Description |
+|--------|------|-------------|
+| `level` | LogLevel | Filter by level: CRITICAL, ERROR, WARNING, INFO, DEBUG |
+| `from` | String | Start timestamp (ISO 8601) |
+| `to` | String | End timestamp (ISO 8601) |
+| `search` | String | Case-insensitive substring search in log messages |
+| `first` | Int | Number of results to return (default: 100, max: 1000) |
+| `skip` | Int | Number of results to skip for pagination (max: 10000) |
+
+### Response Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | String | Unique log entry ID |
+| `timestamp` | String | ISO 8601 timestamp with nanosecond precision |
+| `level` | LogLevel | Log level (CRITICAL, ERROR, WARNING, INFO, DEBUG) |
+| `text` | String | Complete log message with arguments |
+| `arguments` | [(String, String)] | Structured key-value pairs |
+| `meta.module` | String | Source file name |
+| `meta.line` | Int | Line number |
+| `meta.column` | Int | Column number |
+
+### Query Examples
+
+#### Recent Errors
+
+```graphql
+query RecentErrors {
+  _logs(
+    level: ERROR
+    first: 20
+  ) {
+    timestamp
+    text
+    meta {
+      module
+      line
+    }
+  }
+}
+```
+
+#### Search for Specific Text
+
+```graphql
+query SearchTimeout {
+  _logs(
+    search: "timeout"
+    first: 50
+  ) {
+    timestamp
+    level
+    text
+  }
+}
+```
+
+#### Handler Execution Logs
+
+```graphql
+query HandlerLogs {
+  _logs(
+    search: "handler"
+    first: 50
+  ) {
+    timestamp
+    level
+    text
+  }
+}
+```
+
+#### Time Range Query
+
+```graphql
+query LogsInRange {
+  _logs(
+    from: "2024-01-15T00:00:00Z"
+    to: "2024-01-15T23:59:59Z"
+    first: 1000
+  ) {
+    timestamp
+    level
+    text
+  }
+}
+```
+
+#### Pagination
+
+```graphql
+# First page
+query Page1 {
+  _logs(
+    first: 100
+    skip: 0
+  ) {
+    id
+    text
+  }
+}
+
+# Second page
+query Page2 {
+  _logs(
+    first: 100
+    skip: 100
+  ) {
+    id
+    text
+  }
+}
+```
+
+### Querying the logs store using cURL
+
+```bash
+curl -X POST http://localhost:8000/subgraphs/id/<deployment-hash> \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "{ _logs(level: ERROR, first: 10) { timestamp level text } }"
+  }'
+```
+
+### Performance Considerations
+
+**File-based:** _for development only_
+- Streams through files line-by-line (bounded memory usage)
+- Memory usage limited to O(skip + first) entries
+- Query time is O(n) where n = total log entries in file
+
+**Elasticsearch:**
+- Indexed queries are fast regardless of size
+- Text searches are optimized with full-text indexing
+- Can handle billions of log entries
+- Best for production with high query volume
+
+**Loki:**
+- Label-based queries are fast (indexed)
+- Text searches scan compressed chunks (slower than Elasticsearch)
+- Good performance with proper label filtering
+- Best for production with Grafana integration
+
+## Choosing the Right Backend
+
+### Decision Matrix
+
+| Scenario | Recommended Backend | Reason                                                                            |
+|----------|-------------------|-----------------------------------------------------------------------------------|
+| Local development | **File** | Simple, no dependencies, easy to inspect                                          |
+| Testing/staging | **File** or **Elasticsearch** | File for simplicity, ES if testing production config                              |
+| Production | **Elasticsearch** or **Loki** | Both handle scale well                                                            |
+| Using Grafana | **Loki** | Native integration                                                                |
+| Cost-sensitive at scale | **Loki** | Lower storage costs                                                               |
+| Want rich ecosystem | **Elasticsearch** | More tools and plugins                                                            |
+| Minimal deployment | **Disabled** | No overhead                                                                       |
+
+### Resource Requirements
+
+#### File-based
+- **Disk**: Minimal (log files only)
+- **Memory**: Depends on file size during queries
+- **CPU**: Minimal
+- **Network**: None
+- **External services**: None
+
+#### Elasticsearch
+- **Disk**: High (indices + replicas)
+- **Memory**: 4-8GB minimum for small deployments
+- **CPU**: Medium to high
+- **Network**: HTTP API calls
+- **External services**: Elasticsearch cluster
+
+#### Loki
+- **Disk**: Medium (compressed chunks)
+- **Memory**: 2-4GB minimum
+- **CPU**: Low to medium
+- **Network**: HTTP API calls
+- **External services**: Loki server
+
+## Best Practices
+
+### General
+
+1. **Start with file-based for development** - Simplest setup, easy debugging
+2. **Use Elasticsearch or Loki for production** - Better performance and features
+3. **Monitor log volume** - Set up alerts if log volume grows unexpectedly (includes both user logs and system-generated runtime logs)
+4. **Set retention policies** - Don't keep logs forever (disk space and cost)
+5. **Use structured logging** - Pass key-value pairs to log functions for better filtering
+
+### File-based Logs
+
+1. **Monitor file size** - While queries use bounded memory, larger files take longer to scan (O(n) query time)
+2. **Archive old logs** - Manually archive/delete old files or implement external rotation
+3. **Monitor disk usage** - Files can grow quickly with verbose logging
+4. **Use JSON tools** - `jq` is excellent for inspecting .jsonl files locally
+
+**Example local inspection:**
+```bash
+# Count logs by level
+cat graph-logs/QmExample.jsonl | jq -r '.level' | sort | uniq -c
+
+# Find errors in last 1000 lines
+tail -n 1000 graph-logs/QmExample.jsonl | jq 'select(.level == "error")'
+
+# Search for specific text
+cat graph-logs/QmExample.jsonl | jq 'select(.text | contains("timeout"))'
+```
+
+### Elasticsearch
+
+1. **Use index patterns** - Time-based indices for easier management
+2. **Configure retention** - Use Index Lifecycle Management (ILM)
+3. **Monitor cluster health** - Set up Elasticsearch monitoring
+4. **Tune for your workload** - Adjust shards/replicas based on log volume
+5. **Use Kibana** - Visualize and explore logs effectively
+
+**Example Elasticsearch retention policy:**
+```json
+{
+  "policy": "graph-logs-policy",
+  "phases": {
+    "hot": { "min_age": "0ms", "actions": {} },
+    "warm": { "min_age": "7d", "actions": {} },
+    "delete": { "min_age": "30d", "actions": { "delete": {} } }
+  }
+}
+```
+
+### Loki
+
+1. **Use proper labels** - Don't over-index, keep label cardinality low
+2. **Configure retention** - Set retention period in Loki config
+3. **Use Grafana** - Native integration provides best experience
+4. **Compress efficiently** - Loki's compression works best with batch writes
+5. **Multi-tenancy** - Use tenant IDs if running multiple environments
+
+**Example Grafana query:**
+```logql
+{subgraph_id="QmExample", level="error"} |= "timeout"
+```
+
+## Troubleshooting
+
+### File-based Logs
+
+**Problem: Log file doesn't exist**
+- Check `GRAPH_LOG_STORE_FILE_DIR` is set correctly
+- Verify directory is writable by graph-node
+
+**Problem: Queries are slow**
+- Subgraph logs file may be very large
+- Consider archiving old logs or implementing retention
+- For high-volume production use, switch to Elasticsearch or Loki
+
+**Problem: Disk filling up**
+- Implement log rotation
+- Reduce log verbosity in subgraph code
+- Set up monitoring for disk usage
+
+### Elasticsearch
+
+**Problem: Cannot connect to Elasticsearch**
+- Verify `GRAPH_LOG_STORE_ELASTICSEARCH_URL` is correct
+- Check Elasticsearch is running: `curl http://localhost:9200`
+- Verify authentication credentials if using security features
+- Check network connectivity and firewall rules
+
+**Problem: No logs appearing in Elasticsearch**
+- Check Elasticsearch cluster health
+- Verify index exists: `curl http://localhost:9200/_cat/indices`
+- Check graph-node logs for write errors
+- Verify Elasticsearch has disk space
+
+**Problem: Queries are slow**
+- Check Elasticsearch cluster health and resources
+- Verify indices are not over-sharded
+- Consider adding replicas for query performance
+- Review query patterns and add appropriate indices
+
+### Loki
+
+**Problem: Cannot connect to Loki**
+- Verify `GRAPH_LOG_STORE_LOKI_URL` is correct
+- Check Loki is running: `curl http://localhost:3100/ready`
+- Verify tenant ID if using multi-tenancy
+- Check network connectivity
+
+**Problem: No logs appearing in Loki**
+- Check Loki service health
+- Verify Loki has disk space for chunks
+- Check graph-node logs for write errors
+- Verify Loki retention settings aren't deleting logs immediately
+
+**Problem: Queries return no results in Grafana**
+- Check label selectors match what graph-node is sending
+- Verify time range includes when logs were written
+- Check Loki retention period
+- Verify tenant ID matches if using multi-tenancy
+
+## Further Reading
+
+- [Environment Variables Reference](environment-variables.md)
+- [Graph Node Configuration](config.md)
+- [Elasticsearch Documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html)
+- [Grafana Loki Documentation](https://grafana.com/docs/loki/latest/)
diff --git a/docs/plans/gnd-cli-expansion.md b/docs/plans/gnd-cli-expansion.md
new file mode 100644
index 00000000000..b1bef8bc108
--- /dev/null
+++ b/docs/plans/gnd-cli-expansion.md
@@ -0,0 +1,418 @@
+# Plan: Extend gnd with graph-cli functionality
+
+## Overview
+
+Extend the existing `gnd` (Graph Node Dev) CLI to be a **drop-in replacement** for the TypeScript-based `graph-cli`. The goal is identical CLI behavior, flags, output format, and byte-for-byte identical AssemblyScript code generation.
+
+**Spec document**: `docs/specs/gnd-cli-expansion.md`
+
+**Scope**:
+
+- Ethereum protocol only (other protocols are future work)
+- All graph-cli commands except `local` and `node` subcommand
+- Match latest graph-cli version (0.98.x)
+
+**Current state of gnd** (`~/code/graph-node/gnd/`):
+
+- ~700 lines of Rust across 3 files
+- Single command with flags (no subcommands)
+- Already uses clap, imports graph crates
+- Runs graph-node in dev mode with file watching
+
+## Status Summary (Updated 2026-01-19)
+
+**Overall Progress**: ~99% complete (implementation + docs + automated tests done, only publish/test commands need manual verification)
+
+| Phase | Status | Notes |
+|-------|--------|-------|
+| Phase 1: CLI Restructure | ✅ Complete | |
+| Phase 2: Infrastructure | ✅ Complete | |
+| Phase 3: Simple Commands | ✅ Complete | |
+| Phase 4: Code Generation | ✅ Complete | 11 verification fixtures passing |
+| Phase 5: Migrations | ✅ Complete | |
+| Phase 6: Build Command | ✅ Complete | Tested via `just test-gnd-commands` |
+| Phase 7: Deploy Command | ✅ Complete | Tested via `just test-gnd-cli` |
+| Phase 8: Init Command | ✅ Complete | Tested via `just test-gnd-commands` |
+| Phase 9: Add Command | ✅ Complete | |
+| Phase 10: Publish Command | 🟡 Needs Testing | Manual end-to-end verification |
+| Phase 11: Test Command | 🟡 Needs Testing | Manual Matchstick test |
+| Phase 12: Testing & Polish | ✅ Complete | Documentation done, test porting analyzed |
+| Phase 13: CLI Integration Tests | ✅ Complete | Test infrastructure created, ready for manual verification |
+
+**Total LOC**: ~15,000 lines of Rust (158 unit tests, 11 verification tests passing)
+
+**Documentation**:
+- `gnd/README.md` - CLI command reference with examples
+- `gnd/docs/MIGRATING_FROM_GRAPH_CLI.md` - Migration guide from graph-cli
+
+## Git Workflow
+
+**Branch**: All work should be committed to the `gnd-cli` branch.
+
+**Commit discipline**:
+
+- Commit work in small, reviewable chunks
+- Each commit should be self-contained and pass all checks
+- Prefer many small commits over few large ones
+- Each commit message should clearly describe what it does
+
+**Before each commit**:
+
+```bash
+just format
+just lint
+just test-unit  # only run the tests in gnd/
+```
+
+- MANDATORY: Work must be committed, a task is only done when work is committed
+- MANDATORY: Make sure to follow the commit discipline above
+
+## Commands
+
+| Command       | Description                         | Complexity              |
+| ------------- | ----------------------------------- | ----------------------- |
+| `gnd dev`     | Existing gnd functionality          | Done (restructure only) |
+| `gnd codegen` | Generate AssemblyScript types       | High                    |
+| `gnd build`   | Compile to WASM                     | Medium                  |
+| `gnd deploy`  | Deploy to Graph Node                | Medium                  |
+| `gnd init`    | Scaffold new subgraph               | High                    |
+| `gnd add`     | Add datasource to existing subgraph | Medium                  |
+| `gnd create`  | Register subgraph name              | Low                     |
+| `gnd remove`  | Unregister subgraph name            | Low                     |
+| `gnd auth`    | Set deploy key                      | Low                     |
+| `gnd publish` | Publish to decentralized network    | Medium                  |
+| `gnd test`    | Run Matchstick tests                | Low (shell out)         |
+| `gnd clean`   | Remove build artifacts              | Low                     |
+
+**Not implemented** (documented differences):
+
+- `gnd local` - Use existing test infrastructure
+- `gnd node` - Use graphman for node management
+- `--uncrashable` flag - Float Capital third-party feature
+
+## Reusable from graph-node
+
+| Feature             | Location                              | Status                       |
+| ------------------- | ------------------------------------- | ---------------------------- |
+| Manifest parsing    | `graph/src/data/subgraph/mod.rs`      | Ready                        |
+| Manifest validation | `graph/src/data/subgraph/mod.rs`      | Ready (may need refactoring) |
+| GraphQL schema      | `graph/src/schema/input/`             | Ready                        |
+| ABI parsing         | `ethabi` + chain/ethereum wrappers    | Ready                        |
+| IPFS client         | `graph/src/ipfs/`                     | Ready                        |
+| Link resolution     | `graph/src/components/link_resolver/` | Ready                        |
+| File watching       | `gnd/src/watcher.rs`                  | Ready                        |
+| CLI framework       | `clap` (already in gnd)               | Ready                        |
+
+## Module Structure
+
+```
+gnd/src/
+├── main.rs                    # Entry point, clap setup
+├── lib.rs
+├── commands/
+│   ├── mod.rs
+│   ├── dev.rs                 # Existing gnd functionality
+│   ├── codegen.rs
+│   ├── build.rs
+│   ├── deploy.rs
+│   ├── init.rs
+│   ├── add.rs
+│   ├── create.rs
+│   ├── remove.rs
+│   ├── auth.rs
+│   ├── publish.rs
+│   ├── test.rs
+│   └── clean.rs
+├── codegen/
+│   ├── mod.rs
+│   ├── schema.rs              # Entity class generation
+│   ├── abi.rs                 # ABI binding generation
+│   └── template.rs            # Template binding generation
+├── scaffold/
+│   ├── mod.rs
+│   ├── manifest.rs            # Generate subgraph.yaml
+│   ├── schema.rs              # Generate schema.graphql
+│   └── mapping.rs             # Generate mapping.ts
+├── migrations/
+│   ├── mod.rs
+│   └── ...                    # One module per migration version
+├── compiler/
+│   ├── mod.rs
+│   └── asc.rs                 # Shell out to asc
+├── services/
+│   ├── mod.rs
+│   ├── etherscan.rs           # Etherscan API client
+│   ├── sourcify.rs            # Sourcify API client
+│   ├── registry.rs            # Network registry client
+│   └── graph_node.rs          # Graph Node JSON-RPC client
+├── config/
+│   ├── mod.rs
+│   ├── auth.rs                # ~/.graphprotocol/ management
+│   └── networks.rs            # networks.json handling
+├── output/
+│   ├── mod.rs
+│   └── spinner.rs             # Progress/spinner output (match TS CLI exactly)
+└── watcher.rs                 # Existing file watcher
+```
+
+## Dependencies to Add
+
+| Crate       | Purpose                                     |
+| ----------- | ------------------------------------------- |
+| `inquire`   | Interactive prompts (init)                  |
+| `minijinja` | Template rendering (scaffold)               |
+| `indicatif` | Progress bars and spinners                  |
+| `reqwest`   | HTTP client (Etherscan, Sourcify, registry) |
+
+## TODO List
+
+### Phase 1: CLI Restructure
+
+- [x] Create `gnd-cli` branch
+- [x] Restructure main.rs with clap subcommands
+- [x] Move existing gnd logic to `commands/dev.rs`
+- [x] Add empty command stubs for all commands
+- [x] Verify `gnd dev` works exactly as before
+- [x] Add `--version` output showing both gnd and graph-cli versions
+
+### Phase 2: Infrastructure
+
+- [x] Implement `output/spinner.rs` matching TS CLI output format exactly
+- [x] Implement `config/auth.rs` for `~/.graph-cli.json` management (in commands/auth.rs)
+- [x] Implement `config/networks.rs` for networks.json parsing
+- [x] Add reqwest dependency and basic HTTP client setup (in services/graph_node.rs)
+- [x] Implement `services/registry.rs` for @pinax/graph-networks-registry (implemented as `NetworksRegistry` in services/contract.rs)
+
+### Phase 3: Simple Commands
+
+- [x] Implement `gnd clean` command
+- [x] Implement `gnd auth` command
+- [x] Implement `gnd create` command
+- [x] Implement `gnd remove` command
+- [x] Add tests for simple commands
+
+### Phase 4: Code Generation (High Priority, High Risk)
+
+- [x] Study TS CLI codegen output in detail
+- [x] Implement `codegen/schema.rs` - entity classes from GraphQL
+- [x] Implement `codegen/typescript.rs` - AST builders for TypeScript/AssemblyScript
+- [x] Implement `codegen/types.rs` - type conversion utilities
+- [x] Implement `codegen/abi.rs` - ABI bindings
+- [x] Implement `codegen/template.rs` - template bindings
+- [x] Integrate prettier formatting (shell out)
+- [x] Implement `commands/codegen.rs` with all flags
+- [x] Implement `--watch` mode using existing file watcher
+- [x] Create snapshot tests comparing output to TS CLI (11 fixtures from graph-cli validation tests)
+- [x] Verify byte-for-byte identical output - tests pass with documented known differences:
+  - Int8 import always included (gnd simplicity)
+  - Trailing commas in multi-line constructs (gnd style)
+  - 2D array accessors use correct `toStringMatrix()` (gnd fixes graph-cli bug)
+
+### Phase 5: Migrations
+
+- [x] Study TS CLI migrations in `/packages/cli/src/migrations/`
+- [x] Implement migration framework in `migrations/mod.rs`
+- [x] Implement each migration version (0.0.1 → current)
+- [x] Add `--skip-migrations` flag support
+- [x] Test migrations with old manifest versions
+
+### Phase 6: Build Command
+
+- [x] Implement `compiler/asc.rs` - shell out to asc
+- [x] Implement `commands/build.rs` with all flags (~1084 lines, full build pipeline)
+- [x] Handle network file resolution
+- [x] Implement `--watch` mode
+- [x] Implement optional IPFS upload with deduplication
+- [x] Test build output matches TS CLI - Covered by `just test-gnd-commands` (test_build_after_codegen)
+
+### Phase 7: Deploy Command
+
+- [x] Implement `services/graph_node.rs` - JSON-RPC client (~258 lines, create/remove/deploy)
+- [x] Implement `commands/deploy.rs` with all flags (~239 lines)
+- [x] Support all deploy targets (local, studio, hosted service) - defaults to Subgraph Studio
+- [x] Handle access token / deploy key authentication
+- [x] Test deployment to local Graph Node - Covered by `just test-gnd-cli` (block-handlers, value-roundtrip, int8)
+
+### Phase 8: Init Command
+
+- [x] Add `inquire` dependency for interactive prompts
+- [x] Implement `services/contract.rs` - ABI fetching (Etherscan, Blockscout, Sourcify) (~730 lines)
+- [x] Implement networks registry loading
+- [x] Implement `scaffold/manifest.rs` (~271 lines)
+- [x] Implement `scaffold/schema.rs` (~206 lines)
+- [x] Implement `scaffold/mapping.rs` (~205 lines)
+- [x] Implement `commands/init.rs` with all flags (~1060 lines including --from-subgraph)
+- [x] Implement --from-example mode
+- [x] Implement --from-contract mode (uses ContractService for ABI fetching)
+- [x] Add interactive prompts when required options are missing
+- [x] Implement --from-subgraph mode (fetches manifest from IPFS, extracts immutable entities)
+- [x] Test scaffold output matches TS CLI - Covered by `just test-gnd-commands` (test_init_from_example, test_init_from_contract_with_abi)
+
+### Phase 9: Add Command
+
+- [x] Implement `commands/add.rs` (~773 lines, fully functional)
+- [x] Reuse scaffold components for actual implementation
+- [x] ABI validation, entity generation, mapping creation, manifest updates
+- [x] Test adding datasource to existing subgraph (unit tests for helper functions)
+- [x] Comprehensive error handling
+
+### Phase 10: Publish Command
+
+- [x] Implement `commands/publish.rs` (~230 lines, fully functional)
+- [x] Build subgraph and upload to IPFS (reuses build command)
+- [x] Open browser to webapp URL with query params (same approach as graph-cli)
+- [x] Support --ipfs-hash flag to skip build
+- [x] Support --subgraph-id, --api-key for updating existing subgraphs
+- [x] Support --protocol-network (arbitrum-one, arbitrum-sepolia)
+- [x] Interactive prompt before opening browser
+- [ ] Test publish workflow (NEEDS HUMAN: manual end-to-end verification)
+
+### Phase 11: Test Command
+
+- [x] Implement Matchstick binary download/detection
+- [x] Implement `commands/test.rs` (~254 lines, shell out to Matchstick)
+- [x] Handle Docker mode (Dockerfile generation on demand)
+- [x] Recompilation flag support
+- [ ] Test with actual Matchstick tests (NEEDS HUMAN: install matchstick + run end-to-end)
+
+### Phase 12: Testing & Polish
+
+- [x] Port all tests from TS CLI test suite not already covered by gnd tests
+  - Location: `/home/lutter/code/subgraphs/graph-cli/packages/cli/tests/`
+  - Review existing coverage and identify gaps
+  - Analysis: gnd has 11/12 success fixtures from graph-cli validation tests (missing `near-is-valid` which is out of scope for Ethereum-only support). Error/validation fixtures test manifest parsing which is handled by graph-node's validation layer.
+- [x] Add snapshot tests for code generation scenarios (11 fixtures from graph-cli validation tests)
+- [x] Add tests for overloaded events/functions in ABI codegen (disambiguation)
+- [x] Add tests for simple array fields in schema codegen
+- [x] Add tests for nested array types (`[[String]]` etc.) - schema codegen refactored to track list depth
+- [x] Add tests for tuple/struct types in ABI codegen (functions, events, nested, arrays)
+- [x] Add tests for array types in ABI codegen (array params in events, 2D matrices)
+- [x] Codegen verification test framework (gnd/tests/codegen_verification.rs)
+- [x] Add comprehensive tests for prompt module (network completer, source type)
+- [x] Add comprehensive tests for init command (interactive mode detection)
+- [ ] Ensure all edge cases are covered (ongoing)
+- [x] Documentation:
+  - [x] CLI usage docs (README with command reference, examples, common workflows)
+  - [x] Migration guide from graph-cli to gnd (differences, compatibility notes)
+- [x] Shell completions (bash, elvish, fish, powershell, zsh via clap_complete)
+
+### Phase 13: CLI Integration Tests
+
+Verify gnd works as a drop-in replacement for graph-cli by running integration tests with `GRAPH_CLI=../target/debug/gnd`.
+
+**Key Insight**: The existing integration test infrastructure uses `CONFIG.graph_cli` which can be set via the `GRAPH_CLI` environment variable. By setting this to the gnd binary, existing integration tests will use gnd for the deployment flow (codegen, create, deploy).
+
+#### Integration Deployment Tests (`tests/tests/gnd_cli_tests.rs`)
+
+- [x] Create test file that sets `GRAPH_CLI` env var to gnd binary
+- [x] Verify gnd binary exists (fail fast with clear message)
+- [x] Run subset of integration tests: `block-handlers`, `value-roundtrip`, `int8`
+- [x] Reuse `Contract::deploy_all()`, `CONFIG.reset_database()`, `CONFIG.spawn_graph_node()`
+- [x] Use `Subgraph::deploy()` which calls: `gnd codegen`, `gnd create`, `gnd deploy`
+- [x] Verify subgraphs sync and queries return expected data
+
+**Commands Tested via Subgraph::deploy()**:
+- `gnd codegen` - via `Subgraph::deploy()`
+- `gnd create` - via `Subgraph::deploy()`
+- `gnd deploy` - via `Subgraph::deploy()`
+
+#### Standalone Command Tests (`gnd/tests/cli_commands.rs`)
+
+Tests for commands that don't require running graph-node:
+
+**`gnd init` Tests**:
+- [x] `test_init_from_example` - Run `gnd init --from-example ethereum-gravatar`, verify scaffold created
+- [x] `test_init_from_contract_with_abi` - Run with `--from-contract` + `--abi`, verify manifest/schema/mapping created
+- [ ] `test_init_from_subgraph` - Run with `--from-subgraph`, verify immutable entities extracted (requires IPFS) - **Skipped**: Requires IPFS with subgraph data
+
+**`gnd add` Tests**:
+- [x] `test_add_datasource` - Create base subgraph with init, then add contract, verify manifest updated
+
+**`gnd build` Tests**:
+- [x] `test_build_after_codegen` - Copy fixture, run codegen + build, verify `build/` directory created with WASM
+
+**`gnd codegen` Tests**:
+- [x] `test_codegen_generates_types` - Run codegen on scaffolded subgraph, verify `generated/schema.ts` exists
+
+**`gnd clean` Tests**:
+- [x] `test_clean_removes_artifacts` - Verify clean removes `generated/` and `build/` directories
+
+**ABIs Available**: `tests/contracts/abis/*.json`
+
+#### Justfile Targets
+
+- [x] Add `test-gnd-cli` - Run gnd CLI integration tests (deployment with gnd as CLI)
+- [x] Add `test-gnd-commands` - Run gnd standalone command tests (init, add, build)
+
+#### Service Requirements
+
+Tests use the same services as `just test-integration`:
+
+| Service | Port | Start Command |
+|---------|------|---------------|
+| PostgreSQL | 3011 | `nix run .#integration` |
+| IPFS | 3001 | (included above) |
+| Anvil | 3021 | (included above) |
+
+#### Verification
+
+1. `just build` - Build gnd binary
+2. `just test-gnd-cli` - Run integration deployment tests with gnd
+3. `just test-gnd-commands` - Run standalone command tests
+
+Expected output: All tests pass, showing gnd works as drop-in replacement.
+
+## Key Decisions
+
+| Decision         | Choice                       | Rationale                                   |
+| ---------------- | ---------------------------- | ------------------------------------------- |
+| Binary name      | `gnd`                        | Existing name, avoid confusion with `graph` |
+| Protocol support | Ethereum only                | Simplify initial scope                      |
+| Compatibility    | Drop-in replacement          | Same flags, output, exit codes              |
+| Code generation  | Byte-for-byte identical      | Snapshot testable, no surprises             |
+| Formatting       | Shell out to prettier        | Guarantees identical output                 |
+| Compilation      | Shell out to asc             | Same as TS CLI                              |
+| Testing          | Shell out to Matchstick      | Same as TS CLI                              |
+| Debug logging    | RUST_LOG                     | Rust standard, not DEBUG env var            |
+| Validation       | Use graph-node's             | Refactor if needed, single source of truth  |
+| Network registry | Fetch at runtime             | Registry contents change over time          |
+| Error messages   | Same info, format may differ | Convey same information                     |
+| TS CLI bugs      | Fix them                     | Don't replicate bugs                        |
+
+## Risk Assessment
+
+| Risk                        | Severity | Mitigation                           |
+| --------------------------- | -------- | ------------------------------------ |
+| Code generation fidelity    | High     | Snapshot tests against TS CLI output |
+| Migration correctness       | High     | Test with real old manifests         |
+| Breaking existing gnd users | Medium   | Keep `gnd dev` behavior identical    |
+| `asc` version compat        | Medium   | Version detection, clear errors      |
+| Network API changes         | Low      | Error handling, clear messages       |
+
+## TS CLI References
+
+Key files to study in `/home/lutter/code/subgraphs/graph-cli/packages/cli/src/`:
+
+| Feature          | TS CLI Location                     |
+| ---------------- | ----------------------------------- |
+| Commands         | `commands/*.ts`                     |
+| Type generator   | `type-generator.ts`                 |
+| Schema codegen   | `codegen/schema.ts`                 |
+| ABI codegen      | `protocols/ethereum/codegen/abi.ts` |
+| Template codegen | `codegen/template.ts`               |
+| Compiler         | `compiler/index.ts`                 |
+| Migrations       | `migrations/`                       |
+| Scaffold         | `scaffold/`                         |
+| Spinner/output   | `command-helpers/spinner.ts`        |
+| Auth             | `command-helpers/auth.ts`           |
+| Network config   | `command-helpers/network.ts`        |
+| Tests            | `../tests/cli/`                     |
+
+## Effort Estimate
+
+**~3-4 person-months** for full implementation because:
+
+- Code generation must be byte-for-byte identical (requires careful study)
+- All migrations must be implemented
+- Full test coverage needed
+- But we reuse: manifest parsing, validation, IPFS client, file watching, CLI framework
diff --git a/docs/plans/runner-refactor.md b/docs/plans/runner-refactor.md
new file mode 100644
index 00000000000..c5ce612f8db
--- /dev/null
+++ b/docs/plans/runner-refactor.md
@@ -0,0 +1,281 @@
+# Runner Refactor Implementation Plan
+
+This document outlines the implementation plan for the runner refactor described in [the spec](../specs/runner-refactor.md).
+
+## Overview
+
+The refactor transforms `core/src/subgraph/runner.rs` from a complex nested-loop structure into a cleaner state machine with explicit pipeline stages.
+
+## Git Workflow
+
+**Branch**: All work should be committed to the `runner-refactor` branch.
+
+**Commit discipline**:
+
+- Commit work in small, reviewable chunks
+- Each commit should be self-contained and pass all checks
+- Prefer many small commits over few large ones
+- Each commit message should clearly describe what it does
+- Each step in the implementation phases should correspond to one or more commits
+
+**Before each commit**:
+
+```bash
+just format
+just lint
+just test-unit
+just test-runner
+```
+
+- MANDATORY: Work must be committed, a task is only done when work is committed
+- MANDATORY: Make sure to follow the commit discipline above
+- IMPORTANT: The runner tests produce output in `tests/runner-tests.log`. Use that to investigate failures.
+
+## Implementation Phases
+
+### Phase 1: Extract TriggerRunner Component
+
+**Goal:** Eliminate duplicated trigger processing code (lines 616-656 vs 754-790).
+
+**Files to modify:**
+
+- `core/src/subgraph/runner.rs` - Extract logic
+- Create `core/src/subgraph/runner/trigger_runner.rs`
+
+**Steps:**
+
+1. Create `TriggerRunner` struct with execute method
+2. Replace first trigger loop (lines 616-656) with `TriggerRunner::execute()`
+3. Replace second trigger loop (lines 754-790) with same call
+4. Verify tests pass
+
+**Verification:**
+
+- `just test-unit` passes
+- `just test-runner` passes
+- No behavioral changes
+
+### Phase 2: Define RunnerState Enum
+
+**Goal:** Introduce explicit state machine types without changing control flow yet.
+
+**Files to modify:**
+
+- Create `core/src/subgraph/runner/state.rs`
+- `core/src/subgraph/runner.rs` - Add state field
+
+**Steps:**
+
+1. Define `RunnerState` enum with all variants
+2. Define `RestartReason` and `StopReason` enums
+3. Add `state: RunnerState` field to `SubgraphRunner`
+4. Initialize state in constructor
+5. Verify tests pass (no behavioral changes yet)
+
+**Verification:**
+
+- Code compiles
+- Tests pass unchanged
+
+### Phase 3: Refactor run_inner to State Machine
+
+**Goal:** Replace nested loops with explicit state transitions.
+
+**Files to modify:**
+
+- `core/src/subgraph/runner.rs` - Rewrite `run_inner`
+
+**Steps:**
+
+1. Extract `initialize()` method for pre-loop setup
+2. Extract `await_block()` method for stream event handling
+3. Extract `restart()` method for restart logic
+4. Extract `finalize()` method for cleanup
+5. Rewrite `run_inner` as state machine loop
+6. Remove nested loop structure
+7. Verify tests pass
+
+**Verification:**
+
+- `just test-unit` passes
+- `just test-runner` passes
+- Same behavior, cleaner structure
+
+### Phase 4: Define Pipeline Stages
+
+**Goal:** Break `process_block` into explicit stages.
+
+**Files to modify:**
+
+- Create `core/src/subgraph/runner/pipeline.rs`
+- `core/src/subgraph/runner.rs` - Refactor `process_block`
+
+**Steps:**
+
+1. Extract `match_triggers()` stage method
+2. Extract `execute_triggers()` stage method (uses `TriggerRunner`)
+3. Extract `process_dynamic_data_sources()` stage method
+4. Extract `process_offchain_triggers()` stage method
+5. Extract `persist_block_state()` stage method
+6. Rewrite `process_block` to call stages in sequence
+7. Verify tests pass
+
+**Verification:**
+
+- `just test-unit` passes
+- `just test-runner` passes
+- Same behavior, cleaner structure
+
+### Phase 5: Consolidate Error Handling
+
+**Goal:** Unify scattered error handling into explicit classification.
+
+**Files to modify:**
+
+- `graph/src/components/subgraph/error.rs` (or wherever `ProcessingError` lives)
+- `core/src/subgraph/runner.rs` - Use new error methods
+
+**Steps:**
+
+1. Add `ProcessingErrorKind` enum with Deterministic/NonDeterministic/PossibleReorg variants
+2. Add `kind()` method to `ProcessingError`
+3. Add helper methods: `should_stop_processing()`, `should_restart()`, `is_retryable()`
+4. Replace scattered error checks in `process_block` with unified logic
+5. Replace scattered error checks in dynamic DS handling
+6. Replace scattered error checks in `handle_offchain_triggers`
+7. Document error handling invariants in code comments
+8. Verify tests pass
+
+**Verification:**
+
+- `just test-unit` passes
+- `just test-runner` passes
+- Error behavior unchanged (same semantics, cleaner code)
+
+### Phase 6: Add BlockState Checkpoints
+
+**Goal:** Enable rollback capability with minimal overhead.
+
+**Files to modify:**
+
+- `graph/src/prelude.rs` or wherever `BlockState` is defined
+- `core/src/subgraph/runner.rs` - Use checkpoints
+
+**Steps:**
+
+1. Add `checkpoint()` method to `BlockState`
+2. Add `BlockStateCheckpoint` struct
+3. Add `restore()` method to `BlockState`
+4. Use checkpoint before dynamic DS processing
+5. Verify tests pass
+
+**Verification:**
+
+- `just test-unit` passes
+- No performance regression (checkpoints are lightweight)
+
+### Phase 7: Module Organization
+
+**Goal:** Organize code into proper module structure.
+
+**Files to create/modify:**
+
+- `core/src/subgraph/runner/mod.rs`
+- Move/organize existing extracted modules
+
+**Steps:**
+
+1. Create `runner/` directory
+2. Move `state.rs`, `pipeline.rs`, `trigger_runner.rs` into it
+3. Update `runner.rs` to re-export from module
+4. Update imports in dependent files
+5. Verify tests pass
+
+**Verification:**
+
+- `just test-unit` passes
+- `just test-runner` passes
+- `just lint` shows no warnings
+
+## Completion Criteria
+
+Each phase is complete when:
+
+1. `just format` - Code is formatted
+2. `just lint` - Zero warnings
+3. `just check --release` - Builds in release mode
+4. `just test-unit` - Unit tests pass
+5. `just test-runner` - Runner tests pass
+
+## Progress Checklist
+
+### Phase 1: Extract TriggerRunner Component
+
+- [x] Create `TriggerRunner` struct with execute method
+- [x] Replace first trigger loop (lines 616-656)
+- [x] Replace second trigger loop (lines 754-790)
+- [x] Verify tests pass
+
+### Phase 2: Define RunnerState Enum
+
+- [x] Define `RunnerState` enum with all variants
+- [x] Define `RestartReason` and `StopReason` enums
+- [x] Add `state: RunnerState` field to `SubgraphRunner`
+- [x] Initialize state in constructor
+- [x] Verify tests pass
+
+### Phase 3: Refactor run_inner to State Machine
+
+- [x] Extract `initialize()` method
+- [x] Extract `await_block()` method
+- [x] Extract `restart()` method
+- [x] Extract `finalize()` method
+- [x] Rewrite `run_inner` as state machine loop
+- [x] Remove nested loop structure
+- [x] Verify tests pass
+
+### Phase 4: Define Pipeline Stages
+
+- [x] Extract `match_triggers()` stage method
+- [x] Extract `execute_triggers()` stage method
+- [x] Extract `process_dynamic_data_sources()` stage method
+- [x] Extract `process_offchain_triggers()` stage method
+- [x] Extract `persist_block_state()` stage method
+- [x] Rewrite `process_block` to call stages in sequence
+- [x] Verify tests pass
+
+### Phase 5: Consolidate Error Handling
+
+- [x] Add `ProcessingErrorKind` enum
+- [x] Add `kind()` method to `ProcessingError`
+- [x] Add helper methods (`should_stop_processing()`, `should_restart()`, `is_retryable()`)
+- [x] Replace scattered error checks in `process_block`
+- [x] Replace scattered error checks in dynamic DS handling (preserved existing behavior per spec)
+- [x] Replace scattered error checks in `handle_offchain_triggers` (preserved existing behavior per spec)
+- [x] Document error handling invariants
+- [x] Verify tests pass
+
+### Phase 6: Add BlockState Checkpoints
+
+- [x] Add `BlockStateCheckpoint` struct
+- [x] Add `checkpoint()` method to `BlockState`
+- [x] Add `restore()` method to `BlockState`
+- [x] Use checkpoint before dynamic DS processing
+- [x] Verify tests pass
+
+### Phase 7: Module Organization
+
+- [x] Create `runner_components/` directory (named to avoid conflict with `runner.rs`)
+- [x] Move `state.rs`, `trigger_runner.rs` into it (pipeline.rs was not created as stages are methods)
+- [x] Create `runner_components/mod.rs` with re-exports
+- [x] Update imports in `runner.rs` to use the new module path
+- [x] Verify tests pass
+- [x] `just lint` shows zero warnings
+
+## Notes
+
+- Each phase should be a separate, reviewable PR
+- Phases 1-4 can potentially be combined if changes are small
+- Phase 3 (FSM refactor of run_inner) is the most invasive and should be reviewed carefully
+- Phase 5 (error handling) can be done earlier if it helps simplify other phases
+- Preserve all existing behavior - this is a refactor, not a feature change
diff --git a/docs/specs/dump-restore.md b/docs/specs/dump-restore.md
new file mode 100644
index 00000000000..6d7e117b78d
--- /dev/null
+++ b/docs/specs/dump-restore.md
@@ -0,0 +1,269 @@
+# Spec: Parquet Dump/Restore for Subgraph Data
+
+## Problem
+
+Subgraph entity data lives exclusively in PostgreSQL. There's no way to export a subgraph's data for backup, migration between environments, or sharing. We need a file-based dump/restore mechanism.
+
+## Goals
+
+1. **Dump** a subgraph's entity data to parquet files
+2. **Restore** a subgraph from parquet files
+3. **Incremental append** -- add newly arrived data to an existing dump without rewriting it
+4. Long-term: make dumping an **ongoing process** (not just a one-off CLI operation)
+
+## Non-goals (for now)
+
+- S3/GCS output
+- Schema evolution / migration between different schema versions
+
+## Data Model Recap
+
+Each subgraph deployment has:
+- A PostgreSQL schema (e.g., `sgd123`)
+- One table per entity type, with columns:
+  - `vid` (bigserial) -- row version ID, primary key
+  - `block_range` (int4range) for mutable entities OR `block$` (int) for immutable
+  - `causality_region` (int, optional) -- for offchain data sources
+  - Data columns matching GraphQL fields (text, int, bigint, numeric, bytea, bool, timestamptz, arrays, enums)
+- `data_sources$` table -- dynamic data sources created at runtime (defined in `dynds/private.rs`, separate from Layout):
+  - `vid` (int, identity PK), `block_range` (int4range), `causality_region` (int)
+  - `manifest_idx` (int), `parent` (int, self-ref FK), `id` (bytea)
+  - `param` (bytea, nullable), `context` (jsonb, nullable), `done_at` (int, nullable)
+  - Note: `parent` and `id` exist in the DDL but are currently unused by `insert()`, `load()`, and `copy_to()`. The dump should include them for completeness (they may contain data in older deployments).
+- `poi2$` table -- Proof of Indexing data (a **mutable** entity table in the Layout, i.e. it uses `block_range` not `block$`; has `digest` (bytea), `id` (text), optionally `block_time$` (int8); `has_causality_region: false`). Conditionally created when `catalog.use_poi` is true. Excluded from some Layout operations like `find_changes()`.
+- Metadata in `subgraphs.subgraph_manifest`, `subgraphs.deployment`, and `subgraphs.head` tables
+
+## Dump Format
+
+### Directory layout
+
+```
+<dump-dir>/
+  metadata.json                  -- deployment metadata + per-table state
+  schema.graphql                 -- raw GraphQL schema text
+  subgraph.yaml                  -- raw subgraph manifest YAML (optional)
+  <EntityType>/
+    chunk_000000.parquet         -- rows ordered by vid
+    chunk_000001.parquet         -- incremental append
+    ...
+  data_sources$/
+    chunk_000000.parquet         -- dynamic data sources
+```
+
+One parquet file per entity type (each has a different columnar schema). The `data_sources$` table is dumped alongside entity tables. The `poi2$` table, when present, is a regular entity table in the `Layout` (conditionally created when `catalog.use_poi` is true) and appears as any other entity type directory. Incremental dumps produce new chunk files rather than rewriting existing ones.
+
+The GraphQL schema and subgraph manifest YAML are stored as separate files rather than embedded in `metadata.json`. This matches the existing dump code in `dump.rs` and keeps the files human-readable and diffable.
+
+### Parquet schema per entity type
+
+System columns (always present):
+- `vid` -> Int64
+- Immutable entities: `block$` -> Int32
+- Mutable entities: `block_range_start` -> Int32, `block_range_end` -> Int32 (nullable; null = unbounded/current)
+- `causality_region` -> Int32 (only if table has it)
+
+Data columns mapped from `ColumnType` (all 10 variants defined in `relational.rs:1342`):
+
+| ColumnType         | Arrow DataType             | Notes                        |
+|--------------------|---------------------------|-------------------------------|
+| Boolean            | Boolean                    |                               |
+| Int                | Int32                      |                               |
+| Int8               | Int64                      |                               |
+| Bytes              | Binary                     | Raw bytes                     |
+| BigInt             | Utf8                       | Arbitrary precision as string |
+| BigDecimal         | Utf8                       | Arbitrary precision as string |
+| Timestamp          | TimestampMicrosecond(None) | Matches Value::Timestamp      |
+| String             | Utf8                       |                               |
+| Enum(EnumType)     | Utf8                       | String value of enum variant  |
+| TSVector(FulltextConfig) | **Skip**             | Generated; rebuild on restore |
+
+**List/array columns:** `List(T)` is not a `ColumnType` variant. Whether a column is an array is determined by `Column.is_list()` (delegates to the GraphQL `field_type`). A `[String]` field has `column_type: ColumnType::String` with a list-typed `field_type`. For Arrow mapping, check `column.is_list()` and wrap the base Arrow type in `List<mapped T>`. In `OidValue`, arrays have separate variants (`StringArray`, `BytesArray`, `BoolArray`, `Ints`, `Int8Array`, `BigDecimalArray`, `TimestampArray`).
+
+Nullability follows the GraphQL schema (non-null fields -> non-nullable Arrow columns).
+
+### metadata.json
+
+Contains everything needed to reconstruct the deployment's table structure, plus diagnostic information (health, indexes) captured at dump time. The GraphQL schema and manifest YAML are stored in separate files (`schema.graphql`, `subgraph.yaml`), not embedded here.
+
+The struct backing this file is `Metadata` (evolved from the existing `Control` struct in `dump.rs`).
+
+```json
+{
+  "version": 1,
+  "deployment": "Qm...",
+  "network": "mainnet",
+
+  "manifest": {
+    "spec_version": "1.0.0",
+    "description": "Optional subgraph description",
+    "repository": "https://github.com/...",
+    "features": ["..."],
+    "entities_with_causality_region": ["EntityType1"],
+    "history_blocks": 2147483647
+  },
+
+  "earliest_block_number": 12345,
+  "start_block": { "number": 12345, "hash": "0xabc..." },
+  "head_block": { "number": 99999, "hash": "0xdef..." },
+  "entity_count": 150000,
+
+  "graft_base": null,
+  "graft_block": null,
+  "debug_fork": null,
+
+  "health": {
+    "failed": false,
+    "health": "healthy",
+    "fatal_error": null,
+    "non_fatal_errors": []
+  },
+
+  "indexes": {
+    "token": [
+      "CREATE INDEX CONCURRENTLY IF NOT EXISTS attr_0_0_id ON sgd.token USING btree (id)"
+    ]
+  },
+
+  "tables": {
+    "Token": {
+      "immutable": true,
+      "has_causality_region": false,
+      "chunks": [
+        { "file": "Token/chunk_000000.parquet", "min_vid": 0, "max_vid": 50000, "row_count": 50000 }
+      ],
+      "max_vid": 50000
+    },
+    "data_sources$": {
+      "immutable": false,
+      "has_causality_region": true,
+      "chunks": [
+        { "file": "data_sources$/chunk_000000.parquet", "min_vid": 0, "max_vid": 100, "row_count": 100 }
+      ],
+      "max_vid": 100
+    }
+  }
+}
+```
+
+**Field sources:**
+
+| Field | Source | Code path |
+|-------|--------|-----------|
+| `manifest.*` | `subgraphs.subgraph_manifest` | `SubgraphManifestEntity` via `deployment_entity()` in `detail.rs` |
+| `start_block` | `subgraphs.subgraph_manifest` | `start_block_number`, `start_block_hash` columns; available via `StoredSubgraphManifest` in `detail.rs:542-543`, assembled into `SubgraphDeploymentEntity.start_block` |
+| `earliest_block_number` | `subgraphs.deployment` | `SubgraphDeploymentEntity.earliest_block_number` |
+| `graft_base`, `graft_block` | `subgraphs.deployment` | `SubgraphDeploymentEntity.graft_base`, `.graft_block` |
+| `debug_fork` | `subgraphs.deployment` | `SubgraphDeploymentEntity.debug_fork` |
+| `head_block` | `subgraphs.head` | `SubgraphDeploymentEntity.latest_block` |
+| `entity_count` | `subgraphs.head` | `DeploymentDetail.entity_count` (i64 in DB, usize in Rust) |
+| `health.*` | `subgraphs.deployment` + `subgraph_error` | `SubgraphDeploymentEntity.{failed, health, fatal_error, non_fatal_errors}` |
+| `indexes` | `pg_indexes` catalog | `IndexList::load()` → `CreateIndex::to_sql()` (existing code in `dump.rs:163-179`) |
+| `network` | `deployment_schemas` | `Site.network` |
+| `tables.*` | `Layout.tables` | `Table.{immutable, has_causality_region}` |
+
+**Notes:**
+- `use_bytea_prefix` is not stored in the dump. It is hardcoded to `true` in `create_deployment` (deployment.rs:1302) and will always be set to `true` on restore.
+- `health` and `indexes` are point-in-time diagnostic snapshots. They are not used during restore (a restored deployment starts healthy; indexes are auto-created by `Layout::create_relational_schema()`). They are included for inspection and debugging.
+- `indexes` are serialized as SQL strings using `CreateIndex::with_nsp("sgd")` + `to_sql(true, true)`, producing `CREATE INDEX CONCURRENTLY IF NOT EXISTS` statements with a normalized `sgd` namespace.
+- The `manifest` fields mirror the existing `Manifest` struct in `dump.rs` (derived from `SubgraphManifestEntity`). The `schema` and `raw_yaml` fields of `SubgraphManifestEntity` are written to separate files instead.
+- The `poi2$` table, when present, is a regular mutable entity table in `Layout.tables` and appears in the `tables` map like any other entity. It does not need special handling.
+
+The raw GraphQL schema (in `schema.graphql`) is sufficient to reconstruct the full relational layout via `InputSchema::parse(spec_version, schema, deployment_hash)` → `Layout::new()`. The `InputSchema::parse()` call requires `manifest.spec_version` for version-specific parsing logic.
+
+## Dump Process
+
+**Existing code:** There is already a metadata-only dump in `store/postgres/src/relational/dump.rs` (`Layout::dump()`) that writes `control.json`, `schema.graphql`, and `subgraph.yaml`. It is called via `DeploymentStore::dump()` (deployment_store.rs:901) which loads `Layout` + `IndexList` and passes both to `Layout::dump()`. The connection is `AsyncPgConnection` via `pool.get_permitted()`. The new parquet dump extends this to include entity data.
+
+The existing `Control` struct is renamed to `Metadata` and extended with the fields described above. The existing `Manifest`, `BlockPtr`, `Health`, and `Error` structs in `dump.rs` are reused and extended.
+
+1. Resolve the deployment (by name, hash, or sgdN)
+2. Read deployment metadata from `subgraph_manifest` + `deployment` + `head` tables (via `deployment_entity()` in `detail.rs`)
+3. Write `schema.graphql` and `subgraph.yaml` (existing behavior)
+4. For each entity type table in `Layout.tables` (sorted by name for determinism; includes `poi2$` when present):
+   a. Query rows in vid order, batched (adaptive sizing like `VidBatcher`)
+   b. Convert PG rows directly to Arrow `RecordBatch` (no JSON intermediate)
+   c. Write batches to parquet file
+   d. Record chunk info (file path, min_vid, max_vid, row_count)
+5. Dump `data_sources$` table (fixed schema, same batch approach; include all DDL columns: `vid`, `block_range`, `causality_region`, `manifest_idx`, `parent`, `id`, `param`, `context`, `done_at`). Note: `parent` and `id` are in the DDL (`private.rs:68-69`) but not in the `DataSourcesTable` struct — dumping them requires raw SQL or extending the struct.
+6. Write `metadata.json` atomically (write to tmp file, rename)
+
+### Incremental append
+
+- Read existing `metadata.json` to get `max_vid` per entity type
+- Query rows with `vid > max_vid`
+- Write as new chunk files (`chunk_000001.parquet`, etc.)
+- Update metadata atomically
+
+## Restore Process
+
+1. Read `metadata.json` and `schema.graphql`
+2. Parse schema via `InputSchema::parse(manifest.spec_version, schema_text, deployment_hash)`
+3. Create a `Site` entry in `deployment_schemas` (needed for the deployment to be discoverable)
+4. Create deployment via `create_deployment(conn, site, DeploymentCreate { .. })` -- this populates three tables:
+   - `subgraphs.head` (block pointers, entity count -- initially null/0)
+   - `subgraphs.deployment` (deployment hash, earliest_block, graft info, health)
+   - `subgraphs.subgraph_manifest` (schema from file, features/spec_version/etc. from metadata)
+5. Create tables via `Layout::create_relational_schema()` -- this generates DDL from the parsed schema and creates all entity tables with default indexes
+6. Restore `data_sources$` table via DDL from `DataSourcesTable::new().as_ddl()` + batch-insert
+7. For each entity type (including `poi2$` if present), read all parquet chunks in order, batch-insert into PG
+8. Reset vid sequences to `max_vid + 1` for all entity tables and data_sources$
+9. Update `subgraphs.head` with `head_block.number`, `head_block.hash`, and `entity_count` from dump metadata
+
+## PG Read Strategy: OidValue-based Dynamic Columns
+
+Use the existing `dsl::Table::select_cols()` + `DynamicRow<OidValue>` pattern (see `store/postgres/src/relational/dsl.rs` and `store/postgres/src/relational/value.rs`). This already solves dynamic-schema typed extraction through the connection pool:
+
+1. `select_cols()` builds a typed SELECT using `DynamicSelectClause` for any set of columns
+2. Results are `DynamicRow<OidValue>` where `OidValue` dispatches on PG OID at runtime
+3. `OidValue` captures all needed types: String, Bytes, Bool, Int, Int8, BigDecimal, Timestamp, plus array variants
+4. Convert `OidValue` -> Arrow `ArrayBuilder` (analogous to existing `OidValue` -> `Entity` in `FromOidRow`)
+
+No JSON, no separate connection. The existing `DeploymentStore::dump()` already uses `AsyncPgConnection` via `pool.get_permitted()`.
+
+**Block range handling:** Add `OidValue::Int4Range(Bound<i32>, Bound<i32>)` variant (OID 3904). Diesel already has `FromSql<Range<Integer>, Pg>` for `(Bound<i32>, Bound<i32>)` which parses the binary format. ~15 lines of code in `value.rs` + fix the `BLOCK_RANGE_COL` placeholder in `dsl.rs:46-49` (currently `ColumnType::Bytes`, with comment "we can't deserialize in4range"). This resolves the existing TODO at dsl.rs line 294.
+
+**Key existing code:**
+- `dsl::Table::select_cols()` (`store/postgres/src/relational/dsl.rs:305`)
+- `OidValue` enum and `FromSql<Any, Pg>` impl (`store/postgres/src/relational/value.rs:33`)
+- `FromOidRow` trait for result deserialization (`value.rs:206`)
+- `selected_columns()` for building column list with system columns (`dsl.rs:246`)
+
+### Vid continuity on restore
+
+Preserve original vid values. Needed for incremental consistency and simpler to implement. Reset vid sequence to `max_vid + 1` after restore.
+
+## Where Code Lives
+
+- `store/postgres/src/relational/dump.rs` -- **Existing** metadata-only dump. Contains `Manifest`, `BlockPtr`, `Error`, `Health`, `Control` structs. `Control` will be renamed to `Metadata` and extended. The existing helper structs (`Manifest`, `BlockPtr`, `Health`, `Error`) are reused. Called via `DeploymentStore::dump()` → `Layout::dump()`.
+- `store/postgres/src/parquet/` -- New module for parquet read/write/schema mapping
+- `node/src/manager/commands/dump.rs` -- **Existing** CLI command skeleton (resolves deployment, calls `SubgraphStore::dump()`)
+- `node/src/manager/commands/restore.rs` -- New CLI command for restore
+- Expose via `command_support` in `store/postgres/src/lib.rs`
+
+## Dependencies to Add
+
+- `parquet = "=57.3.0"` (same version as existing `arrow`) to workspace and `store/postgres`
+- `arrow` workspace dep to `store/postgres`
+
+## Existing Code to Reuse
+
+- `Layout`, `Table`, `Column`, `ColumnType` (`store/postgres/src/relational.rs`) -- schema introspection; `poi2$` is in Layout as a mutable entity table (conditionally, when `catalog.use_poi` is true)
+- `Column.is_list()` (`relational.rs:1574`) -- determines if a column is an array type (delegates to GraphQL `field_type.is_list()`)
+- `DataSourcesTable` (`store/postgres/src/dynds/private.rs`) -- `data_sources$` DDL via `as_ddl()` method; note that `parent` and `id` columns are in the DDL but not in the struct's typed fields
+- `VidBatcher` (`store/postgres/src/vid_batcher.rs`) -- adaptive batch iteration using PG histogram statistics
+- `copy.rs` pattern -- progress reporting, batch operation lifecycle; already handles both entity tables and `data_sources$` copying
+- `InputSchema::parse(spec_version, raw, id)` (`graph/src/schema/input/mod.rs:965`) -- schema reconstruction from text
+- `DeploymentSearch` (`node/src/manager/deployment.rs`) -- CLI deployment resolution (supports name, Qm hash, sgdN namespace)
+- `create_deployment` (`store/postgres/src/deployment.rs:1224`) -- populates `head`, `deployment`, and `subgraph_manifest` tables
+- `DeploymentCreate` + `SubgraphManifestEntity` (`graph/src/data/subgraph/schema.rs:103`) -- structs needed by `create_deployment`
+- `deployment_entity()` (`store/postgres/src/detail.rs`) -- reads deployment metadata into `SubgraphDeploymentEntity`; note that `start_block_*` is in the DB table (`StoredSubgraphManifest`) but only partially exposed through `SubgraphDeploymentEntity`
+- `IndexList::load()` + `CreateIndex::to_sql()` (`store/postgres/src/relational/index.rs`) -- loads and serializes indexes
+- Existing `dump.rs` (`store/postgres/src/relational/dump.rs`) -- metadata serialization types: `Manifest`, `BlockPtr`, `Health`, `Error`, `Control` (to be renamed `Metadata`)
+
+## Implementation Order
+
+1. Schema mapping + metadata types (foundation, unit-testable)
+2. Parquet writer (dump from PG) + graphman `dump` command
+3. Incremental append support
+4. Parquet reader (restore to PG) + graphman `restore` command
+5. Ongoing dump integration (run as part of graph-node, not just CLI)
diff --git a/docs/specs/gnd-cli-expansion.md b/docs/specs/gnd-cli-expansion.md
new file mode 100644
index 00000000000..7d0cf0d37fe
--- /dev/null
+++ b/docs/specs/gnd-cli-expansion.md
@@ -0,0 +1,891 @@
+# Spec: gnd CLI Expansion
+
+This spec describes the expansion of `gnd` (Graph Node Dev) to include functionality currently provided by the TypeScript-based `graph-cli`. The goal is a drop-in replacement for subgraph development workflows, implemented in Rust and integrated with graph-node's existing infrastructure.
+
+## Goals
+
+- **Drop-in replacement**: Same commands, flags, output format, and exit codes as `graph-cli`
+- **Identical code generation**: AssemblyScript output must be byte-for-byte identical after formatting
+- **Ethereum only**: Initial scope limited to Ethereum protocol
+- **Reuse graph-node internals**: Leverage existing manifest parsing, validation, IPFS client, etc.
+
+## Non-Goals
+
+- Multi-protocol support (NEAR, Cosmos, Arweave, Substreams) - future work
+- Rollout/migration plan from TS CLI
+- Performance optimization beyond reasonable behavior
+
+## Commands
+
+### Command Matrix
+
+| Command   | TS CLI | gnd | Notes                                      |
+| --------- | ------ | --- | ------------------------------------------ |
+| `codegen` | Yes    | Yes | Generate AssemblyScript types              |
+| `build`   | Yes    | Yes | Compile to WASM                            |
+| `deploy`  | Yes    | Yes | Deploy to Graph Node                       |
+| `init`    | Yes    | Yes | Scaffold new subgraph                      |
+| `add`     | Yes    | Yes | Add datasource to existing subgraph        |
+| `remove`  | Yes    | Yes | Unregister subgraph name                   |
+| `create`  | Yes    | Yes | Register subgraph name                     |
+| `auth`    | Yes    | Yes | Set deploy key                             |
+| `publish` | Yes    | Yes | Publish to decentralized network           |
+| `test`    | Yes    | Yes | Run Matchstick tests                       |
+| `clean`   | Yes    | Yes | Remove build artifacts                     |
+| `dev`     | No     | Yes | Run graph-node in dev mode (existing gnd)  |
+| `local`   | Yes    | No  | Skipped - use existing test infrastructure |
+| `node`    | Yes    | No  | Skipped - use graphman for node management |
+
+### Known Differences from TS CLI
+
+**Commands:**
+
+1. **`local` command**: Not implemented. Users should use existing integration test infrastructure.
+2. **`node` subcommand**: Not implemented. Use `graphman` for node management operations.
+3. **`--uncrashable` flag on codegen**: Not implemented. Float Capital's uncrashable helper generation is a niche third-party feature.
+4. **Debug output**: Uses `RUST_LOG` environment variable instead of `DEBUG=graph-cli:*`.
+
+**Code generation** (intentional, documented in verification tests): 5. **Int8 import**: gnd always imports `Int8` for simplicity, even when not used. 6. **Trailing commas**: gnd uses trailing commas in multi-line constructs. 7. **2D array accessors**: gnd uses correct `toStringMatrix()` while graph-cli has a bug using `toStringArray()` for 2D GraphQL array types. 8. **Tuple/struct component names**: gnd correctly extracts component names from raw ABI JSON, while graph-cli's ethabi parser loses nested component names for some tuple types. 9. **Subgraph data source file naming**: gnd uses the data source name (`subgraph-SourceName.ts`) instead of IPFS hash (`subgraph-QmHash.ts`) for stable import paths that don't break when source subgraphs are redeployed.
+
+## CLI Interface
+
+### Binary and Invocation
+
+```
+gnd <command> [options] [arguments]
+```
+
+The binary name is `gnd`. All graph-cli commands become gnd subcommands.
+
+### Version Output
+
+```
+$ gnd --version
+gnd 0.1.0 (graph-cli compatible: 0.98.1)
+```
+
+Shows both gnd version and the graph-cli version it emulates.
+
+### Flag Compatibility
+
+All flags must match the TS CLI exactly:
+
+- Same long names (`--output-dir`)
+- Same short names (`-o`)
+- Same defaults
+- Same validation behavior
+
+Reference: Each command section below lists flags with references to TS CLI source.
+
+### Output Format
+
+Output must match TS CLI format exactly, including:
+
+- Spinner/progress indicators
+- Success checkmarks (`✔`)
+- Step descriptions
+- File paths displayed
+- Error formatting (information must match; exact wording may differ)
+
+Reference: `/packages/cli/src/command-helpers/spinner.ts`
+
+### Exit Codes
+
+Exit codes must match TS CLI behavior:
+
+- `0`: Success
+- `1`: Error (validation, compilation, deployment failure, etc.)
+
+### Configuration Files
+
+Use same paths and formats as TS CLI:
+
+| File           | Path                           | Purpose                       |
+| -------------- | ------------------------------ | ----------------------------- |
+| Auth tokens    | `~/.graphprotocol/`            | Deploy keys and access tokens |
+| Network config | `networks.json` (project root) | Network-specific addresses    |
+
+Reference: `/packages/cli/src/command-helpers/auth.ts`
+
+## Command Specifications
+
+### `gnd codegen`
+
+Generates AssemblyScript types from subgraph manifest.
+
+**Usage:**
+
+```
+gnd codegen [subgraph-manifest]
+```
+
+**Arguments:**
+
+- `subgraph-manifest`: Path to manifest file (default: `subgraph.yaml`)
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--output-dir` | `-o` | `generated/` | Output directory for generated types |
+| `--skip-migrations` | | `false` | Skip subgraph migrations |
+| `--watch` | `-w` | `false` | Regenerate on file changes |
+| `--ipfs` | `-i` | `https://api.thegraph.com/ipfs/` | IPFS node URL |
+| `--help` | `-h` | | Show help |
+
+**Behavior:**
+
+1. Load and validate manifest
+2. Apply migrations (unless `--skip-migrations`)
+3. Assert minimum API version (0.0.5) and graph-ts version (0.25.0)
+4. Generate entity classes from GraphQL schema
+5. Generate ABI bindings for each contract
+6. Generate template datasource bindings
+7. Format output with prettier
+8. Write to output directory
+
+**Output Structure:**
+
+```
+generated/
+├── schema.ts                           # Entity classes
+├── <DataSourceName>/
+│   └── <ContractName>.ts              # ABI bindings
+├── templates/
+│   └── <TemplateName>/
+│       └── <ContractName>.ts          # Template ABI bindings
+└── subgraph-<DataSourceName>.ts       # Entity types for subgraph data sources
+```
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/codegen.ts`
+- Type generator: `/packages/cli/src/type-generator.ts`
+- Schema codegen: `/packages/cli/src/codegen/schema.ts`
+- ABI codegen: `/packages/cli/src/protocols/ethereum/codegen/abi.ts`
+
+### `gnd build`
+
+Compiles subgraph to WASM.
+
+**Usage:**
+
+```
+gnd build [subgraph-manifest]
+```
+
+**Arguments:**
+
+- `subgraph-manifest`: Path to manifest file (default: `subgraph.yaml`)
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--output-dir` | `-o` | `build/` | Output directory |
+| `--output-format` | `-t` | `wasm` | Output format: `wasm` or `wast` |
+| `--skip-migrations` | | `false` | Skip subgraph migrations |
+| `--watch` | `-w` | `false` | Rebuild on file changes |
+| `--ipfs` | `-i` | | IPFS node URL (uploads if provided) |
+| `--network` | | | Network to use from networks.json |
+| `--network-file` | | `networks.json` | Path to networks config |
+| `--help` | `-h` | | Show help |
+
+**Behavior:**
+
+1. Run codegen (unless types already exist)
+2. Apply migrations (unless `--skip-migrations`)
+3. Resolve network-specific values from networks.json
+4. Shell out to `asc` (AssemblyScript compiler) for each mapping
+5. Copy ABIs and schema to build directory
+6. Copy template ABIs to build/templates/<name>/ directories
+7. Generate build manifest
+8. Optionally upload to IPFS
+
+**Build Output Structure:**
+
+```
+build/
+├── schema.graphql
+├── subgraph.yaml
+├── <DataSourceName>/
+│   ├── <DataSourceName>.wasm
+│   └── <ContractName>.json          # ABI
+└── templates/
+    └── <TemplateName>/
+        ├── <TemplateName>.wasm
+        └── <ContractName>.json      # ABI
+```
+
+**Note:** When multiple data sources or templates share the same mapping.ts file, gnd compiles it once and copies the resulting WASM to all required output locations.
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/build.ts`
+- Compiler: `/packages/cli/src/compiler/index.ts`
+
+### `gnd deploy`
+
+Deploys subgraph to a Graph Node.
+
+**Usage:**
+
+```
+gnd deploy [subgraph-name] [subgraph-manifest]
+```
+
+**Arguments:**
+
+- `subgraph-name`: Name to deploy as (e.g., `user/subgraph`)
+- `subgraph-manifest`: Path to manifest file (default: `subgraph.yaml`)
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--product` | | | Product: `subgraph-studio` or `hosted-service` |
+| `--studio` | | `false` | Shorthand for `--product subgraph-studio` |
+| `--node` | `-g` | | Graph Node URL |
+| `--ipfs` | `-i` | | IPFS node URL |
+| `--access-token` | | | Access token for authentication |
+| `--deploy-key` | | | Deploy key (alias for access-token) |
+| `--version-label` | `-l` | | Version label |
+| `--headers` | | | Additional HTTP headers (JSON) |
+| `--debug-fork` | | | Fork subgraph for debugging |
+| `--skip-migrations` | | `false` | Skip subgraph migrations |
+| `--network` | | | Network from networks.json |
+| `--network-file` | | `networks.json` | Path to networks config |
+| `--output-dir` | `-o` | `build/` | Build output directory |
+| `--help` | `-h` | | Show help |
+
+**Deploy Targets:**
+
+- Local Graph Node (via `--node` and `--ipfs`)
+- Subgraph Studio (`--product subgraph-studio` or `--studio`)
+- Hosted Service (`--product hosted-service`)
+- Decentralized network (via `publish` command)
+
+**Behavior:**
+
+1. Build subgraph (runs build command)
+2. Upload build artifacts to IPFS
+3. Send deployment request to Graph Node via JSON-RPC
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/deploy.ts`
+
+### `gnd init`
+
+Scaffolds a new subgraph project.
+
+**Usage:**
+
+```
+gnd init [directory]
+```
+
+**Arguments:**
+
+- `directory`: Directory to create subgraph in
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--protocol` | | | Protocol: `ethereum` |
+| `--product` | | | Product for deployment |
+| `--studio` | | `false` | Initialize for Subgraph Studio |
+| `--from-contract` | | | Contract address to generate from |
+| `--from-example` | | | Example subgraph to clone |
+| `--contract-name` | | | Name for the contract |
+| `--index-events` | | `false` | Index all contract events |
+| `--start-block` | | | Start block for indexing |
+| `--network` | | `mainnet` | Network name |
+| `--abi` | | | Path to ABI file |
+| `--spkg` | | | Path to Substreams package |
+| `--allow-simple-name` | | `false` | Allow simple subgraph names |
+| `--help` | `-h` | | Show help |
+
+**Example Subgraphs:**
+
+The `--from-example <name>` flag clones from `https://github.com/graphprotocol/graph-tooling/tree/main/examples`.
+The example name is **required** - no default is provided. Available examples include:
+`ethereum-gravatar`, `aggregations`, `ethereum-basic-event-handlers`, `substreams-powered-subgraph`, etc.
+Legacy name `ethereum/gravatar` is automatically converted to `ethereum-gravatar`.
+
+**Behavior:**
+
+1. Prompt for missing information (protocol, network, contract, etc.)
+2. Fetch ABI from Etherscan/Sourcify if `--from-contract` and no `--abi`
+3. Generate scaffold:
+   - `subgraph.yaml` manifest
+   - `schema.graphql` with entities for events
+   - `src/mapping.ts` with event handlers
+   - `package.json` with dependencies
+   - `tsconfig.json`
+   - ABIs directory
+4. Optionally initialize git repository
+5. Install dependencies
+
+**External APIs:**
+
+- Etherscan API: Fetch verified contract ABIs
+- Sourcify API: Fetch verified contract ABIs (fallback)
+- Network registry: `@pinax/graph-networks-registry` for chain configuration
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/init.ts`
+- Scaffold: `/packages/cli/src/scaffold/index.ts`
+- Schema generation: `/packages/cli/src/scaffold/schema.ts`
+- Mapping generation: `/packages/cli/src/scaffold/mapping.ts`
+- Etherscan client: `/packages/cli/src/command-helpers/contracts.ts`
+
+### `gnd add`
+
+Adds a new datasource to an existing subgraph.
+
+**Usage:**
+
+```
+gnd add <address> [subgraph-manifest]
+```
+
+**Arguments:**
+
+- `address`: Contract address
+- `subgraph-manifest`: Path to manifest file (default: `subgraph.yaml`)
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--abi` | | | Path to ABI file |
+| `--contract-name` | | | Name for the contract |
+| `--merge-entities` | | `false` | Merge with existing entities |
+| `--network-file` | | `networks.json` | Path to networks config |
+| `--start-block` | | | Start block |
+| `--help` | `-h` | | Show help |
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/add.ts`
+
+### `gnd create`
+
+Registers a subgraph name with a Graph Node.
+
+**Usage:**
+
+```
+gnd create <subgraph-name>
+```
+
+**Arguments:**
+
+- `subgraph-name`: Name to register
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--node` | `-g` | | Graph Node URL |
+| `--access-token` | | | Access token |
+| `--help` | `-h` | | Show help |
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/create.ts`
+
+### `gnd remove`
+
+Unregisters a subgraph name from a Graph Node.
+
+**Usage:**
+
+```
+gnd remove <subgraph-name>
+```
+
+**Arguments:**
+
+- `subgraph-name`: Name to unregister
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--node` | `-g` | | Graph Node URL |
+| `--access-token` | | | Access token |
+| `--help` | `-h` | | Show help |
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/remove.ts`
+
+### `gnd auth`
+
+Sets the deploy key for a Graph Node.
+
+**Usage:**
+
+```
+gnd auth <deploy-key>
+```
+
+**Arguments:**
+
+- `deploy-key`: Deploy key to store
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--product` | | | Product: `subgraph-studio` or `hosted-service` |
+| `--studio` | | `false` | Shorthand for subgraph-studio |
+| `--help` | `-h` | | Show help |
+
+**Behavior:**
+Stores deploy key in `~/.graphprotocol/` for later use by deploy/publish commands.
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/auth.ts`
+- Auth helpers: `/packages/cli/src/command-helpers/auth.ts`
+
+### `gnd publish`
+
+Publishes a subgraph to The Graph's decentralized network.
+
+**Usage:**
+
+```
+gnd publish [subgraph-manifest]
+```
+
+**Arguments:**
+
+- `subgraph-manifest`: Path to manifest file (default: `subgraph.yaml`)
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--subgraph-id` | | | Subgraph ID to publish to |
+| `--ipfs` | `-i` | | IPFS node URL |
+| `--protocol-network` | | | Protocol network (e.g., `arbitrum-one`) |
+| `--help` | `-h` | | Show help |
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/publish.ts`
+
+### `gnd test`
+
+Runs Matchstick tests for the subgraph.
+
+**Usage:**
+
+```
+gnd test [datasource]
+```
+
+**Arguments:**
+
+- `datasource`: Specific datasource to test (optional)
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--coverage` | `-c` | `false` | Run with coverage |
+| `--docker` | `-d` | `false` | Run in Docker container |
+| `--force` | `-f` | `false` | Force recompilation |
+| `--logs` | `-l` | `false` | Show logs |
+| `--recompile` | `-r` | `false` | Recompile before testing |
+| `--version` | `-v` | | Matchstick version |
+| `--help` | `-h` | | Show help |
+
+**Behavior:**
+
+1. Download Matchstick binary (if not present)
+2. Shell out to Matchstick with appropriate flags
+3. Report test results
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/test.ts`
+
+### `gnd clean`
+
+Removes build artifacts and generated files.
+
+**Usage:**
+
+```
+gnd clean
+```
+
+**Flags:**
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--codegen-dir` | | `generated/` | Codegen output directory |
+| `--build-dir` | | `build/` | Build output directory |
+| `--help` | `-h` | | Show help |
+
+**Behavior:**
+Removes `generated/` and `build/` directories (or custom paths if specified).
+
+**TS CLI References:**
+
+- Command: `/packages/cli/src/commands/clean.ts`
+
+### `gnd dev`
+
+Runs graph-node in development mode with file watching.
+
+This is the existing `gnd` functionality, preserved as a subcommand. The implementation can be adjusted to fit the new subcommand structure.
+
+**Usage:**
+
+```
+gnd dev [options]
+```
+
+**Flags:**
+Preserve existing gnd flags, adjusted as needed for subcommand structure.
+
+## Code Generation
+
+Code generation is the most complex component and must produce byte-for-byte identical output to the TS CLI (after prettier formatting).
+
+### Generated File Types
+
+#### 1. Entity Classes (`schema.ts`)
+
+Generated from GraphQL schema. Each entity type becomes an AssemblyScript class with:
+
+- Constructor
+- Static `load(id)` method
+- Static `loadInBlock(id)` method
+- `save()` method
+- Getters/setters for each field
+- Proper type mappings (GraphQL → AssemblyScript)
+
+**TS CLI Reference:** `/packages/cli/src/codegen/schema.ts`
+
+#### 2. ABI Bindings (`<Contract>.ts`)
+
+Generated from contract ABI. Includes:
+
+- Event classes with typed parameters
+- Function call result classes
+- Contract class with typed call methods
+- Proper Ethereum type mappings
+
+**Tuple/Struct Handling:**
+When an event or function has tuple parameters with named components (e.g., a struct), gnd generates proper struct classes with named getters:
+
+```typescript
+class AssetTransfer__ParamsAssetStruct extends ethereum.Tuple {
+  get addr(): Address {
+    return this[0].toAddress();
+  }
+  get amount(): BigInt {
+    return this[1].toBigInt();
+  }
+  get active(): boolean {
+    return this[2].toBoolean();
+  }
+}
+```
+
+gnd parses the raw ABI JSON to extract component names, which ethabi loses during parsing.
+
+**TS CLI Reference:** `/packages/cli/src/protocols/ethereum/codegen/abi.ts`
+
+#### 3. Template Bindings
+
+Generated for template datasources with the same structure as ABI bindings.
+
+**TS CLI Reference:** `/packages/cli/src/codegen/template.ts`
+
+#### 4. Subgraph Data Source Bindings (`subgraph-<DataSourceName>.ts`)
+
+Generated for `kind: subgraph` data sources. When a manifest contains a subgraph data source:
+
+```yaml
+dataSources:
+  - kind: subgraph
+    name: SourceSubgraph
+    source:
+      address: "QmRWTEejPDDwALaquFGm6X2GBbbh5osYDXwCRRkoZ6KQhb"
+```
+
+gnd will:
+
+1. Validate that all subgraph data source names are unique (error if duplicates found)
+2. Fetch the referenced subgraph's manifest from IPFS
+3. Extract and fetch the schema from the manifest
+4. Generate entity types (without store methods) to `generated/subgraph-{DataSourceName}.ts`
+
+**Note:** gnd uses the data source name (e.g., `SourceSubgraph`) for the generated filename rather than the IPFS hash. This produces stable import paths like `import { Entity } from '../generated/subgraph-SourceSubgraph'` that don't break when the source subgraph is redeployed with a new hash. This differs from graph-cli which uses the IPFS hash.
+
+The generated types include entity classes with getters for all fields, but no `save()`, `load()`, or `loadInBlock()` methods since these are read-only types from the source subgraph.
+
+**TS CLI Reference:** `/packages/cli/src/type-generator.ts` lines 72-136
+
+### Type Mappings
+
+#### GraphQL → AssemblyScript
+
+| GraphQL          | AssemblyScript |
+| ---------------- | -------------- |
+| `ID`             | `string`       |
+| `String`         | `string`       |
+| `Int`            | `i32`          |
+| `BigInt`         | `BigInt`       |
+| `BigDecimal`     | `BigDecimal`   |
+| `Bytes`          | `Bytes`        |
+| `Boolean`        | `boolean`      |
+| `[T]`            | `Array<T>`     |
+| Entity reference | `string` (ID)  |
+
+**TS CLI Reference:** `/packages/cli/src/codegen/schema.ts` (look for type mapping functions)
+
+#### Ethereum ABI → AssemblyScript
+
+| Solidity  | AssemblyScript  |
+| --------- | --------------- |
+| `address` | `Address`       |
+| `bool`    | `boolean`       |
+| `bytes`   | `Bytes`         |
+| `bytesN`  | `Bytes`         |
+| `intN`    | `BigInt`        |
+| `uintN`   | `BigInt`        |
+| `string`  | `string`        |
+| `T[]`     | `Array<T>`      |
+| tuple     | Generated class |
+
+**TS CLI Reference:** `/packages/cli/src/protocols/ethereum/codegen/abi.ts`
+
+### API Version Handling
+
+Different `apiVersion` values in the manifest affect code generation. gnd must support all versions that the TS CLI supports.
+
+**TS CLI Reference:** `/packages/cli/src/codegen/` (version-specific logic throughout)
+
+### Formatting
+
+All generated code must be formatted with prettier before writing:
+
+- Shell out to `prettier` with same configuration as TS CLI
+- Parser: `typescript`
+
+## Migrations
+
+Migrations update older manifest formats to newer versions. gnd must implement all migrations that TS CLI supports.
+
+**Migration Chain:**
+
+```
+0.0.1 → 0.0.2 → 0.0.3 → 0.0.4 → 0.0.5 → ... → current
+```
+
+**TS CLI Reference:** `/packages/cli/src/migrations/`
+
+Each migration is a transformation function that:
+
+1. Checks manifest version
+2. Applies necessary changes
+3. Updates version number
+
+## External Dependencies
+
+### Runtime Dependencies (shell out)
+
+| Tool         | Purpose                 | Required      |
+| ------------ | ----------------------- | ------------- |
+| `asc`        | AssemblyScript compiler | For `build`   |
+| `prettier`   | Code formatting         | For `codegen` |
+| `matchstick` | Test runner             | For `test`    |
+
+### Network APIs
+
+| API                              | Purpose                                 |
+| -------------------------------- | --------------------------------------- |
+| Etherscan                        | Fetch verified contract ABIs            |
+| Sourcify                         | Fetch verified contract ABIs (fallback) |
+| `@pinax/graph-networks-registry` | Network configuration (chain IDs, etc.) |
+
+The network registry should be fetched at runtime to get current network configurations.
+
+### graph-node Reuse
+
+| Component           | graph-node Location                   | Purpose                     |
+| ------------------- | ------------------------------------- | --------------------------- |
+| Manifest parsing    | `graph/src/data/subgraph/`            | Load subgraph.yaml          |
+| Manifest validation | `graph/src/data/subgraph/`            | Validate manifest structure |
+| GraphQL schema      | `graph/src/schema/input/`             | Parse schema.graphql        |
+| IPFS client         | `graph/src/ipfs/`                     | Upload to IPFS              |
+| Link resolver       | `graph/src/components/link_resolver/` | Resolve file references     |
+| File watcher        | `gnd/src/watcher.rs`                  | Watch mode                  |
+
+Refactor graph-node components as needed to make them reusable.
+
+## Module Structure
+
+```
+gnd/src/
+├── main.rs                    # Entry point, clap setup
+├── lib.rs
+├── formatter.rs               # Prettier integration for code formatting
+├── prompt.rs                  # Interactive prompts (network selection, etc.)
+├── watcher.rs                 # File watcher for --watch modes
+├── commands/
+│   ├── mod.rs
+│   ├── add.rs
+│   ├── auth.rs
+│   ├── build.rs
+│   ├── clean.rs
+│   ├── codegen.rs
+│   ├── create.rs
+│   ├── deploy.rs
+│   ├── dev.rs                 # Existing gnd functionality
+│   ├── init.rs
+│   ├── publish.rs
+│   ├── remove.rs
+│   └── test.rs
+├── codegen/
+│   ├── mod.rs
+│   ├── abi.rs                 # ABI binding generation
+│   ├── schema.rs              # Entity class generation
+│   ├── template.rs            # Template binding generation
+│   ├── types.rs               # Type conversion utilities
+│   └── typescript.rs          # AST builders for TypeScript/AssemblyScript
+├── scaffold/
+│   ├── mod.rs
+│   ├── manifest.rs            # Generate subgraph.yaml
+│   ├── mapping.rs             # Generate mapping.ts
+│   └── schema.rs              # Generate schema.graphql
+├── migrations/
+│   ├── mod.rs
+│   ├── api_version.rs         # API version migrations
+│   ├── spec_version.rs        # Spec version migrations
+│   └── versions.rs            # Version definitions
+├── compiler/
+│   ├── mod.rs
+│   └── asc.rs                 # Shell out to asc
+├── services/
+│   ├── mod.rs
+│   ├── contract.rs            # ABI fetching (Etherscan, Blockscout, Sourcify, registry)
+│   ├── graph_node.rs          # Graph Node JSON-RPC client
+│   └── ipfs.rs                # IPFS client for uploads
+├── config/
+│   ├── mod.rs
+│   └── networks.rs            # networks.json handling
+└── output/
+    ├── mod.rs
+    └── spinner.rs             # Progress/spinner output
+```
+
+## Testing
+
+### Current Status
+
+- **166 unit tests** passing (`cargo test -p gnd --lib`)
+- **12 codegen verification tests** passing (`cargo test -p gnd --test codegen_verification`)
+- **7 CLI command tests** passing (`cargo test -p gnd --test cli_commands`)
+- Test fixtures from graph-cli validation tests in `gnd/tests/fixtures/codegen_verification/`
+
+### Test Strategy
+
+1. **Unit tests**: Test individual functions (type mappings, migrations, etc.)
+2. **Snapshot tests**: Compare generated output against TS CLI output
+3. **Integration tests**: End-to-end command execution
+
+### Test Corpus
+
+Use the same test corpus as graph-cli. Tests must cover at least everything the TS CLI tests cover.
+
+**TS CLI Test Location:** `/packages/cli/tests/`
+
+### Codegen Verification Tests
+
+Located in `gnd/tests/codegen_verification.rs`, these tests verify compatibility with graph-cli:
+
+1. Copy fixture to temp directory (excluding `generated/`)
+2. Run `gnd codegen` on the fixture
+3. Compare output against expected `generated/` directory
+4. Allow known differences (Int8 import, trailing commas, 2D array fix)
+
+Fixtures can be regenerated with `./tests/fixtures/regenerate.sh`.
+
+### Edge Cases
+
+When edge case bugs are discovered in the TS CLI, gnd should fix them rather than replicate them. Document any behavioral differences that result from bug fixes.
+
+### CLI Integration Tests
+
+Located in `tests/tests/gnd_cli_tests.rs`, these tests verify gnd works as a drop-in replacement for graph-cli by running the integration test suite with `GRAPH_CLI` environment variable pointing to the gnd binary.
+
+**How it works:**
+
+- The integration test infrastructure uses `CONFIG.graph_cli` for deployment commands
+- Setting `GRAPH_CLI=../target/debug/gnd` makes tests use gnd instead of graph-cli
+- `Subgraph::deploy()` calls `gnd codegen`, `gnd create`, `gnd deploy`
+
+**Commands tested:**
+
+- `gnd codegen` - Generate AssemblyScript types
+- `gnd create` - Register subgraph name with Graph Node
+- `gnd deploy` - Deploy subgraph to Graph Node
+
+**Running:**
+
+```bash
+just test-gnd-cli
+```
+
+### Standalone Command Tests
+
+Located in `gnd/tests/cli_commands.rs`, these tests verify commands that don't require a running Graph Node:
+
+**Commands tested:**
+
+- `gnd init` - Scaffold generation (--from-example, --from-contract, --from-subgraph)
+- `gnd add` - Add datasource to existing subgraph
+- `gnd build` - WASM compilation
+
+**Running:**
+
+```bash
+just test-gnd-commands
+```
+
+## Dependencies to Add
+
+### Cargo.toml additions
+
+```toml
+[dependencies]
+# CLI framework (already present)
+clap = { version = "...", features = ["derive"] }
+
+# Interactive prompts (for init)
+inquire = "..."
+
+# HTTP client (for Etherscan, Sourcify, registry)
+reqwest = { version = "...", features = ["json"] }
+
+# Progress/spinner output
+indicatif = "..."
+
+# Template rendering (for scaffold)
+minijinja = "..."
+
+# JSON handling
+serde_json = "..."
+```
+
+## Open Questions
+
+None at this time. All major decisions have been made.
+
+## References
+
+- TS CLI repository: https://github.com/graphprotocol/graph-tooling
+- TS CLI source: `/packages/cli/src/`
+- Local checkout: `/home/lutter/code/subgraphs/graph-cli`
+- Original gnd expansion plan: `/LOCAL/plans/gnd-cli-expansion.md`
diff --git a/docs/specs/runner-refactor.md b/docs/specs/runner-refactor.md
new file mode 100644
index 00000000000..ee36ebe3342
--- /dev/null
+++ b/docs/specs/runner-refactor.md
@@ -0,0 +1,380 @@
+# Subgraph Runner Simplification Spec
+
+## Problem Statement
+
+`core/src/subgraph/runner.rs` is complex and hard to modify. Key issues:
+
+1. **Duplicated trigger processing** (lines 616-656 vs 754-790): Nearly identical loops
+2. **Control flow confusion**: Nested loops in `run_inner` with 6 exit paths
+3. **State management**: Mixed patterns (mutable fields, `std::mem::take`, drains)
+4. **`process_block` monolith**: ~260 lines handling triggers, dynamic DS, offchain, persistence
+
+## Design Decisions
+
+| Aspect | Decision |
+|--------|----------|
+| Control flow | Enum-based FSM for full runner lifecycle |
+| Trigger processing | New `TriggerRunner` component |
+| Block processing | Pipeline with explicitly defined stages |
+| State management | Mutable accumulator with checkpoints |
+| Breaking changes | Moderate (internal APIs can change) |
+
+## Target Architecture
+
+### 1. Runner State Machine
+
+Replace nested loops in `run_inner` with an explicit enum FSM covering the full lifecycle:
+
+```rust
+enum RunnerState {
+    /// Initial state, ready to start block stream
+    Initializing,
+
+    /// Block stream active, waiting for next event
+    AwaitingBlock {
+        block_stream: Cancelable<Box<dyn BlockStream<C>>>,
+    },
+
+    /// Processing a block through the pipeline
+    ProcessingBlock {
+        block: BlockWithTriggers<C>,
+        cursor: FirehoseCursor,
+    },
+
+    /// Handling a revert event
+    Reverting {
+        to_ptr: BlockPtr,
+        cursor: FirehoseCursor,
+    },
+
+    /// Restarting block stream (new filters, store restart, etc.)
+    Restarting {
+        reason: RestartReason,
+    },
+
+    /// Terminal state
+    Stopped {
+        reason: StopReason,
+    },
+}
+
+enum RestartReason {
+    DynamicDataSourceCreated,
+    DataSourceExpired,
+    StoreError,
+    PossibleReorg,
+}
+
+enum StopReason {
+    MaxEndBlockReached,
+    Canceled,
+    Unassigned,
+}
+```
+
+The main loop becomes:
+
+```rust
+async fn run(mut self) -> Result<(), SubgraphRunnerError> {
+    loop {
+        self.state = match self.state {
+            RunnerState::Initializing => self.initialize().await?,
+            RunnerState::AwaitingBlock { stream } => self.await_block(stream).await?,
+            RunnerState::ProcessingBlock { block, cursor } => {
+                self.process_block(block, cursor).await?
+            }
+            RunnerState::Reverting { to_ptr, cursor } => {
+                self.handle_revert(to_ptr, cursor).await?
+            }
+            RunnerState::Restarting { reason } => self.restart(reason).await?,
+            RunnerState::Stopped { reason } => return self.finalize(reason).await,
+        };
+    }
+}
+```
+
+### 2. Block Processing Pipeline
+
+Replace the `process_block` monolith with explicit stages:
+
+```rust
+/// Pipeline stages for block processing
+mod pipeline {
+    pub struct TriggerMatchStage;
+    pub struct TriggerExecuteStage;
+    pub struct DynamicDataSourceStage;
+    pub struct OffchainTriggerStage;
+    pub struct PersistStage;
+}
+
+/// Result of block processing pipeline
+pub struct BlockProcessingResult {
+    pub action: Action,
+    pub block_state: BlockState,
+}
+
+impl SubgraphRunner {
+    async fn process_block(
+        &mut self,
+        block: BlockWithTriggers<C>,
+        cursor: FirehoseCursor,
+    ) -> Result<RunnerState, ProcessingError> {
+        let block = Arc::new(block.block);
+        let triggers = block.trigger_data;
+
+        // Stage 1: Match triggers to hosts and decode
+        let runnables = self.match_triggers(&block, triggers).await?;
+
+        // Stage 2: Execute triggers (unified for initial + dynamic DS)
+        let mut block_state = self.execute_triggers(&block, runnables).await?;
+
+        // Checkpoint before dynamic DS processing
+        let checkpoint = block_state.checkpoint();
+
+        // Stage 3: Process dynamic data sources (loop until none created)
+        block_state = self.process_dynamic_data_sources(&block, &cursor, block_state).await?;
+
+        // Stage 4: Handle offchain triggers
+        let offchain_result = self.process_offchain_triggers(&block, &mut block_state).await?;
+
+        // Stage 5: Persist to store
+        self.persist_block_state(block_state, offchain_result).await?;
+
+        // Determine next state
+        Ok(self.determine_next_state())
+    }
+}
+```
+
+### 3. Error Handling Strategy
+
+Consolidate scattered error handling into explicit classification:
+
+```rust
+/// Unified error classification for trigger processing
+pub enum ProcessingErrorKind {
+    /// Stop processing, persist PoI only
+    Deterministic(anyhow::Error),
+    /// Retry with backoff, attempt to unfail
+    NonDeterministic(anyhow::Error),
+    /// Restart block stream cleanly (don't persist)
+    PossibleReorg(anyhow::Error),
+}
+
+impl ProcessingError {
+    /// Classify error once, use classification throughout
+    pub fn kind(&self) -> ProcessingErrorKind { ... }
+
+    /// Whether this error should stop processing the current block
+    pub fn should_stop_processing(&self) -> bool {
+        matches!(self.kind(), ProcessingErrorKind::Deterministic(_))
+    }
+
+    /// Whether this error requires a clean restart
+    pub fn should_restart(&self) -> bool {
+        matches!(self.kind(), ProcessingErrorKind::PossibleReorg(_))
+    }
+
+    /// Whether this error is retryable with backoff
+    pub fn is_retryable(&self) -> bool {
+        matches!(self.kind(), ProcessingErrorKind::NonDeterministic(_))
+    }
+}
+```
+
+**Key Invariant (must be preserved):**
+```
+Deterministic    → Stop processing block, persist PoI only
+NonDeterministic → Retry with backoff
+PossibleReorg    → Restart cleanly (don't persist)
+```
+
+Currently this logic is scattered across:
+- `process_block` early return for PossibleReorg (line 664-677)
+- Dynamic data sources error mapping (line 792-802)
+- `transact_block_state` (line 405-430)
+- `handle_offchain_triggers` (line 1180-1190)
+
+Consolidating into helper methods eliminates these scattered special cases.
+
+### 4. TriggerRunner Component
+
+Extract trigger execution into a dedicated component:
+
+```rust
+/// Handles matching, decoding, and executing triggers
+pub struct TriggerRunner<'a, C: Blockchain, T: RuntimeHostBuilder<C>> {
+    decoder: &'a Decoder<C, T>,
+    processor: &'a dyn TriggerProcessor<C, T>,
+    logger: &'a Logger,
+    metrics: &'a SubgraphMetrics,
+    debug_fork: &'a Option<Arc<dyn SubgraphFork>>,
+    instrument: bool,
+}
+
+impl<'a, C, T> TriggerRunner<'a, C, T>
+where
+    C: Blockchain,
+    T: RuntimeHostBuilder<C>,
+{
+    /// Execute triggers against hosts, accumulating state
+    pub async fn execute(
+        &self,
+        block: &Arc<C::Block>,
+        runnables: Vec<RunnableTriggers<'a, C>>,
+        mut block_state: BlockState,
+        proof_of_indexing: &SharedProofOfIndexing,
+        causality_region: &PoICausalityRegion,
+    ) -> Result<BlockState, MappingError> {
+        for runnable in runnables {
+            block_state = self.processor
+                .process_trigger(
+                    self.logger,
+                    runnable.hosted_triggers,
+                    block,
+                    block_state,
+                    proof_of_indexing,
+                    causality_region,
+                    self.debug_fork,
+                    self.metrics,
+                    self.instrument,
+                )
+                .await
+                .map_err(|e| e.add_trigger_context(&runnable.trigger))?;
+        }
+        Ok(block_state)
+    }
+}
+```
+
+This eliminates the duplicated loops (lines 616-656 and 754-790).
+
+### 5. State Management with Checkpoints
+
+**Explicit Input/Output Types for Pipeline Stages:**
+
+```rust
+/// Input to trigger processing - makes dependencies explicit
+struct TriggerProcessingContext<'a> {
+    block: &'a Arc<C::Block>,
+    proof_of_indexing: &'a SharedProofOfIndexing,
+    causality_region: &'a PoICausalityRegion,
+}
+
+/// Output from trigger processing - makes results explicit
+struct TriggerProcessingResult {
+    block_state: BlockState,
+    restart_needed: bool,
+}
+```
+
+**Add checkpoint capability to `BlockState` for rollback scenarios:**
+
+```rust
+impl BlockState {
+    /// Create a lightweight checkpoint for rollback
+    pub fn checkpoint(&self) -> BlockStateCheckpoint {
+        BlockStateCheckpoint {
+            created_data_sources_count: self.created_data_sources.len(),
+            persisted_data_sources_count: self.persisted_data_sources.len(),
+            // Note: entity_cache changes cannot be easily checkpointed
+            // Rollback clears the cache (acceptable per current behavior)
+        }
+    }
+
+    /// Restore state to checkpoint (partial rollback)
+    pub fn restore(&mut self, checkpoint: BlockStateCheckpoint) {
+        self.created_data_sources.truncate(checkpoint.created_data_sources_count);
+        self.persisted_data_sources.truncate(checkpoint.persisted_data_sources_count);
+        // Entity cache is cleared on rollback (matches current behavior)
+    }
+}
+```
+
+### 6. File Structure
+
+```
+core/src/subgraph/
+├── runner.rs              # Main SubgraphRunner with FSM
+├── runner/
+│   ├── mod.rs
+│   ├── state.rs           # RunnerState enum and transitions
+│   ├── pipeline.rs        # Pipeline stage definitions
+│   └── trigger_runner.rs  # TriggerRunner component
+├── context.rs             # IndexingContext (unchanged)
+├── inputs.rs              # IndexingInputs (unchanged)
+└── state.rs               # IndexingState (unchanged)
+```
+
+## Deferred Concerns
+
+### Fishy Block Refetch (Preserve Behavior)
+
+The TODO at lines 721-729 notes unclear behavior around block refetching in the dynamic DS loop. The restructure preserves this behavior without attempting to fix it. Investigate separately.
+
+## Key Interfaces
+
+### RunnerState Transitions
+
+```
+Initializing ──────────────────────────────────┐
+     │                                          │
+     v                                          │
+AwaitingBlock ◄─────────────────────────────────┤
+     │                                          │
+     ├── ProcessBlock event ──► ProcessingBlock │
+     │                              │           │
+     │                              ├── success ┼──► AwaitingBlock
+     │                              │           │
+     │                              └── restart ┼──► Restarting
+     │                                          │
+     ├── Revert event ──────────► Reverting ────┤
+     │                                          │
+     ├── Error ─────────────────► Restarting ───┤
+     │                                          │
+     └── Cancel/MaxBlock ───────► Stopped       │
+                                                │
+Restarting ─────────────────────────────────────┘
+```
+
+### Pipeline Data Flow
+
+```
+BlockWithTriggers
+       │
+       v
+┌──────────────────┐
+│ TriggerMatchStage│ ─► Vec<RunnableTriggers>
+└──────────────────┘
+       │
+       v
+┌────────────────────┐
+│ TriggerExecuteStage│ ─► BlockState (mutated)
+└────────────────────┘
+       │
+       v (loop while has_created_data_sources)
+┌─────────────────────────┐
+│ DynamicDataSourceStage  │ ─► BlockState (mutated), new hosts added
+└─────────────────────────┘
+       │
+       v
+┌─────────────────────┐
+│ OffchainTriggerStage│ ─► offchain_mods, processed_ds
+└─────────────────────┘
+       │
+       v
+┌─────────────┐
+│ PersistStage│ ─► Store transaction
+└─────────────┘
+```
+
+## Verification
+
+After implementation, verify:
+
+1. **Unit tests pass**: `just test-unit`
+2. **Runner tests pass**: `just test-runner`
+3. **Lint clean**: `just lint` (zero warnings)
+4. **Build succeeds**: `just check --release`
+
+For behavioral verification, the existing runner tests should catch regressions. No new integration tests required for a refactor that preserves behavior.
diff --git a/docs/subgraph-manifest.md b/docs/subgraph-manifest.md
index e595690e9f3..caad7943e84 100644
--- a/docs/subgraph-manifest.md
+++ b/docs/subgraph-manifest.md
@@ -74,6 +74,7 @@ The `mapping` field may be one of the following supported mapping manifests:
 | **event** | *String* | An identifier for an event that will be handled in the mapping script. For Ethereum contracts, this must be the full event signature to distinguish from events that may share the same name. No alias types can be used. For example, uint will not work, uint256 must be used.|
 | **handler** | *String* | The name of an exported function in the mapping script that should handle the specified event. |
 | **topic0** | optional *String* | A `0x` prefixed hex string. If provided, events whose topic0 is equal to this value will be processed by the given handler. When topic0 is provided, _only_ the topic0 value will be matched, and not the hash of the event signature. This is useful for processing anonymous events in Solidity, which can have their topic0 set to anything.  By default, topic0 is equal to the hash of the event signature. |
+| **calls** | optional [*CallDecl*](#153-declaring-calls) | A list of predeclared `eth_calls` that will be made before running the handler |
 
 #### 1.5.2.3 CallHandler
 
@@ -95,6 +96,40 @@ The `mapping` field may be one of the following supported mapping manifests:
 | --- | --- | --- |
 | **kind** | *String* | The selected block handler filter. Only option for now: `call`: This will only run the handler if the block contains at least one call to the data source contract. |
 
+### 1.5.3 Declaring calls
+
+_Available from spec version 1.2.0. Struct field access available from spec version 1.4.0_
+
+Declared calls are performed in parallel before the handler is run and can
+greatly speed up syncing. Mappings access the call results simply by using
+`ethereum.call` from the mappings. The **calls** are a map of key value pairs:
+
+| Field | Type | Description |
+| --- | --- | --- |
+| **label** | *String* | A label for the call for error messages etc. |
+| **call** | *String* | See below |
+
+Each call is of the form `<ABI>[<address>].<function>(<args>)`:
+
+| Field | Type | Description |
+| --- | --- | --- |
+| **ABI** | *String* | The name of an ABI from the `abis` section |
+| **address** | *Expr* | The address of a contract that follows the `ABI` |
+| **function** | *String* | The name of a view function in the contract |
+| **args** | *[Expr]* | The arguments to pass to the function |
+
+#### Expression Types
+
+The `Expr` can be one of the following:
+
+| Expression | Description |
+| --- | --- |
+| **event.address** | The address of the contract that emitted the event |
+| **event.params.&lt;name&gt;** | A simple parameter from the event |
+| **event.params.&lt;name&gt;.&lt;index&gt;** | A field from a struct parameter by numeric index |
+| **event.params.&lt;name&gt;.&lt;fieldName&gt;** | A field from a struct parameter by field name (spec version 1.4.0+) |
+
+
 ## 1.6 Path
 A path has one field `path`, which either refers to a path of a file on the local dev machine or an [IPLD link](https://github.com/ipld/specs/).
 
diff --git a/entitlements.plist b/entitlements.plist
new file mode 100644
index 00000000000..d9ce520f2e1
--- /dev/null
+++ b/entitlements.plist
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.cs.disable-executable-page-protection</key>
+    <true/>
+</dict>
+</plist> 
\ No newline at end of file
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 00000000000..7d69cf5ac8c
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,182 @@
+{
+  "nodes": {
+    "fenix": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "rust-analyzer-src": "rust-analyzer-src"
+      },
+      "locked": {
+        "lastModified": 1755585599,
+        "narHash": "sha256-tl/0cnsqB/Yt7DbaGMel2RLa7QG5elA8lkaOXli6VdY=",
+        "owner": "nix-community",
+        "repo": "fenix",
+        "rev": "6ed03ef4c8ec36d193c18e06b9ecddde78fb7e42",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "fenix",
+        "type": "github"
+      }
+    },
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1754487366,
+        "narHash": "sha256-pHYj8gUBapuUzKV/kN/tR3Zvqc7o6gdFB9XKXIp1SQ8=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "af66ad14b28a127c5c0f3bbb298218fc63528a18",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "locked": {
+        "lastModified": 1644229661,
+        "narHash": "sha256-1YdnJAsNy69bpcjuoKdOYQX0YxZBiCYZo4Twxerqv7k=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "3cecb5b042f7f209c56ffd8371b2711a290ec797",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "foundry": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      },
+      "locked": {
+        "lastModified": 1760001025,
+        "narHash": "sha256-j/jPNlW2W4zwV2rSqgw5ts1VoTXVe5n3CNXFvtQhK3Q=",
+        "owner": "shazow",
+        "repo": "foundry.nix",
+        "rev": "b7adb89167832516589c899addcd25ca2a78dcfe",
+        "type": "github"
+      },
+      "original": {
+        "owner": "shazow",
+        "repo": "foundry.nix",
+        "rev": "b7adb89167832516589c899addcd25ca2a78dcfe",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1666753130,
+        "narHash": "sha256-Wff1dGPFSneXJLI2c0kkdWTgxnQ416KE6X4KnFkgPYQ=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "f540aeda6f677354f1e7144ab04352f61aaa0118",
+        "type": "github"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "type": "indirect"
+      }
+    },
+    "nixpkgs-lib": {
+      "locked": {
+        "lastModified": 1753579242,
+        "narHash": "sha256-zvaMGVn14/Zz8hnp4VWT9xVnhc8vuL3TStRqwk22biA=",
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "rev": "0f36c44e01a6129be94e3ade315a5883f0228a6e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1756128520,
+        "narHash": "sha256-R94HxJBi+RK1iCm8Y4Q9pdrHZl0GZoDPIaYwjxRNPh4=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "c53baa6685261e5253a1c355a1b322f82674a824",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "process-compose-flake": {
+      "locked": {
+        "lastModified": 1749418557,
+        "narHash": "sha256-wJHHckWz4Gvj8HXtM5WVJzSKXAEPvskQANVoRiu2w1w=",
+        "owner": "Platonic-Systems",
+        "repo": "process-compose-flake",
+        "rev": "91dcc48a6298e47e2441ec76df711f4e38eab94e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "Platonic-Systems",
+        "repo": "process-compose-flake",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "fenix": "fenix",
+        "flake-parts": "flake-parts",
+        "foundry": "foundry",
+        "nixpkgs": "nixpkgs_2",
+        "process-compose-flake": "process-compose-flake",
+        "services-flake": "services-flake"
+      }
+    },
+    "rust-analyzer-src": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1755504847,
+        "narHash": "sha256-VX0B9hwhJypCGqncVVLC+SmeMVd/GAYbJZ0MiiUn2Pk=",
+        "owner": "rust-lang",
+        "repo": "rust-analyzer",
+        "rev": "a905e3b21b144d77e1b304e49f3264f6f8d4db75",
+        "type": "github"
+      },
+      "original": {
+        "owner": "rust-lang",
+        "ref": "nightly",
+        "repo": "rust-analyzer",
+        "type": "github"
+      }
+    },
+    "services-flake": {
+      "locked": {
+        "lastModified": 1755996515,
+        "narHash": "sha256-1RQQIDhshp1g4PP5teqibcFLfk/ckTDOJRckecAHiU0=",
+        "owner": "juspay",
+        "repo": "services-flake",
+        "rev": "e316d6b994fd153f0c35d54bd07d60e53f0ad9a9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "juspay",
+        "repo": "services-flake",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 00000000000..933a35ef04c
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,209 @@
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
+    foundry.url = "github:shazow/foundry.nix/b7adb89167832516589c899addcd25ca2a78dcfe";
+    fenix = {
+      url = "github:nix-community/fenix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+    process-compose-flake.url = "github:Platonic-Systems/process-compose-flake";
+    services-flake.url = "github:juspay/services-flake";
+    flake-parts.url = "github:hercules-ci/flake-parts";
+  };
+
+  outputs = inputs @ {
+    flake-parts,
+    process-compose-flake,
+    services-flake,
+    nixpkgs,
+    fenix,
+    foundry,
+    ...
+  }:
+    flake-parts.lib.mkFlake {inherit inputs;} {
+      imports = [process-compose-flake.flakeModule];
+      systems = [
+        "x86_64-linux" # 64-bit Intel/AMD Linux
+        "aarch64-linux" # 64-bit ARM Linux
+        "x86_64-darwin" # 64-bit Intel macOS
+        "aarch64-darwin" # 64-bit ARM macOS
+      ];
+
+      perSystem = {
+        config,
+        self',
+        inputs',
+        pkgs,
+        system,
+        ...
+      }: let
+        overlays = [
+          fenix.overlays.default
+          foundry.overlay
+        ];
+
+        pkgs = import nixpkgs {
+          inherit overlays system;
+        };
+
+        toolchain = with fenix.packages.${system};
+          combine [
+            (fromToolchainFile {
+              file = ./rust-toolchain.toml;
+              sha256 = "sha256-+9FmLhAOezBZCOziO0Qct1NOrfpjNsXxc/8I0c7BdKE=";
+            })
+            stable.rust-src # This is needed for rust-analyzer to find stdlib symbols. Should use the same channel as the toolchain.
+          ];
+      in {
+        formatter = pkgs.alejandra;
+        devShells.default = pkgs.mkShell {
+          packages = with pkgs; [
+            toolchain
+            foundry-bin
+            solc
+            protobuf
+            uv
+            cmake
+            corepack
+            nodejs
+            postgresql
+            just
+            cargo-nextest
+          ];
+        };
+
+        process-compose = let
+          inherit (services-flake.lib) multiService;
+          ipfs = multiService ./nix/ipfs.nix;
+          anvil = multiService ./nix/anvil.nix;
+
+          # Helper function to create postgres configuration with graph-specific defaults
+          mkPostgresConfig = {
+            name,
+            port,
+            user,
+            password,
+            database,
+            dataDir,
+          }: {
+            enable = true;
+            inherit port dataDir;
+            initialScript = {
+              before = ''
+                CREATE ROLE postgres WITH LOGIN;
+                CREATE USER \"${user}\" WITH PASSWORD '${password}' SUPERUSER;
+              '';
+            };
+            initialDatabases = [
+              {
+                inherit name;
+                schemas = [
+                  (pkgs.writeText "init-${name}.sql" ''
+                    CREATE EXTENSION IF NOT EXISTS pg_trgm;
+                    CREATE EXTENSION IF NOT EXISTS btree_gist;
+                    CREATE EXTENSION IF NOT EXISTS postgres_fdw;
+                    CREATE EXTENSION IF NOT EXISTS pg_stat_statements;
+                    GRANT USAGE ON FOREIGN DATA WRAPPER postgres_fdw TO "${user}";
+                    ALTER DATABASE "${database}" OWNER TO "${user}";
+                  '')
+                ];
+              }
+            ];
+            settings = {
+              shared_preload_libraries = "pg_stat_statements";
+              log_statement = "all";
+              default_text_search_config = "pg_catalog.english";
+              max_connections = 500;
+            };
+          };
+        in {
+          # Unit tests configuration
+          unit = {
+            imports = [
+              services-flake.processComposeModules.default
+              ipfs
+              anvil
+            ];
+
+            cli = {
+              environment.PC_DISABLE_TUI = true;
+              options = {
+                port = 8881;
+              };
+            };
+
+            services.postgres."postgres-unit" = mkPostgresConfig {
+              name = "graph-test";
+              port = 5432;
+              dataDir = "./.data/unit/postgres";
+              user = "graph";
+              password = "graph";
+              database = "graph-test";
+            };
+
+            # Set PGUSER so psql connects as the OS user (matching initdb's superuser)
+            settings.processes."postgres-unit-init".environment = {
+              PGUSER = builtins.getEnv "USER";
+            };
+
+            services.ipfs."ipfs-unit" = {
+              enable = true;
+              dataDir = "./.data/unit/ipfs";
+              port = 5001;
+              gateway = 8080;
+            };
+          };
+
+          # Integration tests configuration
+          integration = {
+            imports = [
+              services-flake.processComposeModules.default
+              ipfs
+              anvil
+            ];
+
+            cli = {
+              environment.PC_DISABLE_TUI = true;
+              options = {
+                port = 8882;
+              };
+            };
+
+            services.postgres."postgres-integration" = mkPostgresConfig {
+              name = "graph-node";
+              port = 3011;
+              dataDir = "./.data/integration/postgres";
+              user = "graph-node";
+              password = "let-me-in";
+              database = "graph-node";
+            };
+
+            # Set PGUSER so psql connects as the OS user (matching initdb's superuser)
+            settings.processes."postgres-integration-init".environment = {
+              PGUSER = builtins.getEnv "USER";
+            };
+
+            services.ipfs."ipfs-integration" = {
+              enable = true;
+              dataDir = "./.data/integration/ipfs";
+              port = 3001;
+              gateway = 3002;
+            };
+
+            services.anvil."anvil-integration" = {
+              enable = true;
+              package = pkgs.foundry-bin;
+              port = 3021;
+              timestamp = 1743944919;
+              gasLimit = 100000000000;
+              baseFee = 1;
+              blockTime = null;
+              state = "./.data/integration/anvil/state.json";
+              stateInterval = 30;
+              preserveHistoricalStates = true;
+            };
+          };
+        };
+      };
+    };
+}
diff --git a/gnd/Cargo.toml b/gnd/Cargo.toml
new file mode 100644
index 00000000000..754949a4722
--- /dev/null
+++ b/gnd/Cargo.toml
@@ -0,0 +1,92 @@
+[package]
+name = "gnd"
+version.workspace = true
+edition.workspace = true
+
+[[bin]]
+name = "gnd"
+path = "src/main.rs"
+
+[[test]]
+name = "cli_commands"
+path = "tests/cli_commands.rs"
+
+[[test]]
+name = "codegen_verification"
+path = "tests/codegen_verification.rs"
+
+[[test]]
+name = "gnd_test"
+path = "tests/gnd_test.rs"
+
+[dependencies]
+# Core graph dependencies
+graph = { path = "../graph" }
+graph-chain-ethereum = { path = "../chain/ethereum" }
+graph-core = { path = "../core" }
+graph-node = { path = "../node" }
+graph-graphql = { path = "../graphql" }
+graph-store-postgres = { path = "../store/postgres" }
+
+# Test command dependencies
+hex = "0.4"
+async-trait = { workspace = true }
+tower = { workspace = true }
+
+# Direct dependencies from current dev.rs
+anyhow = { workspace = true }
+clap = { workspace = true }
+clap_complete = { workspace = true }
+env_logger = { workspace = true }
+git-testament = { workspace = true }
+lazy_static = { workspace = true }
+serde = { workspace = true }
+tokio = { workspace = true }
+tokio-util = { workspace = true }
+
+# File watching
+notify = "8.2.0"
+globset = "0.4.18"
+
+# Config and auth
+url = { workspace = true }
+serde_json = { workspace = true }
+pq-sys = { version = "0.7.5", features = ["bundled"] }
+
+# HTTP client for Graph Node API
+reqwest = { workspace = true }
+thiserror = { workspace = true }
+
+# Console output
+similar = "3"
+indicatif = { workspace = true }
+console = { workspace = true }
+
+# Code generation
+graphql-tools = { workspace = true }
+regex = { workspace = true }
+serde_yaml = { workspace = true }
+Inflector = { workspace = true }
+
+# Migrations
+semver = { workspace = true }
+
+# Build command
+sha1 = "0.11"
+wasmparser = { workspace = true }
+
+# Interactive prompts
+inquire = "0.9"
+
+# Temp directories for init
+tempfile = "3"
+
+# Browser opening for publish command
+open = "5"
+
+[target.'cfg(unix)'.dependencies]
+pgtemp = { git = "https://github.com/graphprotocol/pgtemp", branch = "initdb-args" }
+
+[dev-dependencies]
+tempfile = "3"
+walkdir = "2"
diff --git a/gnd/README.md b/gnd/README.md
new file mode 100644
index 00000000000..375e1ef0e01
--- /dev/null
+++ b/gnd/README.md
@@ -0,0 +1,524 @@
+# gnd - Graph Node Dev CLI
+
+A drop-in replacement for `graph-cli` written in Rust. `gnd` provides all the subgraph development commands with identical output, flags, and behavior.
+
+## Installation
+
+Build from source:
+
+```bash
+cargo build -p gnd --release
+```
+
+The binary will be at `target/release/gnd`.
+
+## Quick Start
+
+```bash
+# Create a new subgraph from a contract
+gnd init --from-contract 0x1234... --network mainnet my-subgraph
+
+# Generate AssemblyScript types
+gnd codegen
+
+# Build the subgraph
+gnd build
+
+# Deploy to a local Graph Node
+gnd create --node http://localhost:8020 my-name/my-subgraph
+gnd deploy --node http://localhost:8020 --ipfs http://localhost:5001 -l v0.0.1 my-name/my-subgraph
+
+# Or deploy to Subgraph Studio
+gnd auth YOUR_DEPLOY_KEY
+gnd deploy -l v0.0.1 my-name/my-subgraph
+```
+
+## Commands
+
+### `gnd init`
+
+Create a new subgraph with basic scaffolding.
+
+```bash
+gnd init [SUBGRAPH_NAME] [DIRECTORY]
+```
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--protocol` | | Protocol: `ethereum`, `near`, `cosmos`, `arweave`, `substreams` |
+| `--from-contract` | | Create from an existing contract address |
+| `--from-example` | | Create from an example subgraph template |
+| `--from-subgraph` | | Create from an existing deployed subgraph |
+| `--contract-name` | | Name for the contract (with `--from-contract`) |
+| `--index-events` | | Index all contract events as entities |
+| `--network` | | Network the contract is deployed to |
+| `--start-block` | | Block number to start indexing from |
+| `--abi` | | Path to the contract ABI file |
+| `--node` | `-g` | Graph Node URL |
+| `--ipfs` | `-i` | IPFS node URL |
+| `--skip-install` | | Skip installing npm dependencies |
+| `--skip-git` | | Skip initializing a Git repository |
+
+**Examples:**
+
+```bash
+# Interactive mode (prompts for all options)
+gnd init
+
+# From contract with ABI fetched from Etherscan
+gnd init --from-contract 0x1234... --network mainnet my-subgraph
+
+# From contract with local ABI
+gnd init --from-contract 0x1234... --abi ./MyContract.json my-subgraph
+
+# From an existing deployed subgraph
+gnd init --from-subgraph QmHash... my-subgraph
+```
+
+### `gnd codegen`
+
+Generate AssemblyScript types from the subgraph manifest.
+
+```bash
+gnd codegen [MANIFEST]
+```
+
+**Arguments:**
+- `MANIFEST`: Path to subgraph manifest (default: `subgraph.yaml`)
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--output-dir` | `-o` | Output directory (default: `generated/`) |
+| `--skip-migrations` | | Skip manifest migrations |
+| `--watch` | `-w` | Regenerate on file changes |
+| `--ipfs` | `-i` | IPFS node URL |
+
+**Examples:**
+
+```bash
+# Generate types
+gnd codegen
+
+# Generate to custom directory
+gnd codegen -o src/generated/
+
+# Watch mode
+gnd codegen --watch
+```
+
+### `gnd build`
+
+Compile the subgraph to WASM.
+
+```bash
+gnd build [MANIFEST]
+```
+
+**Arguments:**
+- `MANIFEST`: Path to subgraph manifest (default: `subgraph.yaml`)
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--output-dir` | `-o` | Output directory (default: `build/`) |
+| `--output-format` | `-t` | Output format: `wasm` or `wast` (default: `wasm`) |
+| `--skip-migrations` | | Skip manifest migrations |
+| `--watch` | `-w` | Rebuild on file changes |
+| `--ipfs` | `-i` | IPFS node URL (uploads if provided) |
+| `--network` | | Network from networks.json |
+| `--network-file` | | Path to networks config (default: `networks.json`) |
+
+**Examples:**
+
+```bash
+# Build subgraph
+gnd build
+
+# Build and upload to IPFS
+gnd build --ipfs http://localhost:5001
+
+# Build for specific network
+gnd build --network mainnet
+```
+
+### `gnd deploy`
+
+Deploy a subgraph to a Graph Node.
+
+```bash
+gnd deploy <SUBGRAPH_NAME> [MANIFEST]
+```
+
+**Arguments:**
+- `SUBGRAPH_NAME`: Name to deploy as (e.g., `user/subgraph`)
+- `MANIFEST`: Path to subgraph manifest (default: `subgraph.yaml`)
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--node` | `-g` | Graph Node URL (defaults to Subgraph Studio) |
+| `--ipfs` | `-i` | IPFS node URL |
+| `--deploy-key` | | Deploy key for authentication |
+| `--version-label` | `-l` | Version label for the deployment (required in non-interactive mode) |
+| `--ipfs-hash` | | IPFS hash of already-uploaded manifest |
+| `--output-dir` | `-o` | Build output directory (default: `build/`) |
+| `--skip-migrations` | | Skip manifest migrations |
+| `--network` | | Network from networks.json |
+| `--network-file` | | Path to networks config |
+| `--debug-fork` | | Fork subgraph ID for debugging |
+
+If `--version-label` is omitted in an interactive terminal, `gnd deploy` prompts for it.
+In non-interactive environments (CI/scripts), you must pass `--version-label`.
+
+**Examples:**
+
+```bash
+# Deploy to Subgraph Studio (uses saved auth key)
+gnd deploy -l v1.0.0 my-name/my-subgraph
+
+# Deploy to local Graph Node
+gnd deploy --node http://localhost:8020 --ipfs http://localhost:5001 -l v1.0.0 my-name/my-subgraph
+
+# Deploy without --version-label in an interactive terminal (prompts)
+gnd deploy my-name/my-subgraph
+```
+
+### `gnd publish`
+
+Publish a subgraph to The Graph's decentralized network.
+
+```bash
+gnd publish [MANIFEST]
+```
+
+**Arguments:**
+- `MANIFEST`: Path to subgraph manifest (default: `subgraph.yaml`)
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--ipfs` | `-i` | IPFS node URL |
+| `--ipfs-hash` | | Skip build, use existing IPFS hash |
+| `--subgraph-id` | | Subgraph ID for updating existing subgraphs |
+| `--protocol-network` | | Network: `arbitrum-one` or `arbitrum-sepolia` |
+| `--api-key` | | API key (required when updating existing) |
+| `--output-dir` | `-o` | Build output directory |
+| `--skip-migrations` | | Skip manifest migrations |
+| `--network` | | Network from networks.json |
+| `--network-file` | | Path to networks config |
+
+**Examples:**
+
+```bash
+# Publish new subgraph
+gnd publish
+
+# Update existing subgraph
+gnd publish --subgraph-id Qm... --api-key YOUR_KEY
+```
+
+### `gnd add`
+
+Add a new data source to an existing subgraph.
+
+```bash
+gnd add <ADDRESS> [MANIFEST]
+```
+
+**Arguments:**
+- `ADDRESS`: Contract address to add
+- `MANIFEST`: Path to subgraph manifest (default: `subgraph.yaml`)
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--abi` | | Path to the contract ABI |
+| `--contract-name` | | Name for the new data source |
+| `--merge-entities` | | Merge with existing entities of same name |
+| `--network` | | Network the contract is deployed to |
+| `--start-block` | | Block number to start indexing from |
+
+**Examples:**
+
+```bash
+# Add contract with ABI from Etherscan
+gnd add 0x1234... --network mainnet
+
+# Add contract with local ABI
+gnd add 0x1234... --abi ./NewContract.json --contract-name MyContract
+```
+
+### `gnd create`
+
+Register a subgraph name with a Graph Node.
+
+```bash
+gnd create <SUBGRAPH_NAME> --node <URL>
+```
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--node` | `-g` | Graph Node URL (required) |
+| `--access-token` | | Access token for authentication |
+
+### `gnd remove`
+
+Unregister a subgraph name from a Graph Node.
+
+```bash
+gnd remove <SUBGRAPH_NAME> --node <URL>
+```
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--node` | `-g` | Graph Node URL (required) |
+| `--access-token` | | Access token for authentication |
+
+### `gnd auth`
+
+Store a deploy key for authentication.
+
+```bash
+gnd auth <DEPLOY_KEY>
+```
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--node` | `-g` | Graph Node URL (default: Subgraph Studio) |
+
+Keys are stored in `~/.graph-cli.json`.
+
+### `gnd test`
+
+Run subgraph tests.
+
+```bash
+gnd test [TEST_FILES...]
+```
+
+**Arguments:**
+- `PATHS`: Test JSON files or directories to scan. Defaults to `tests/` when nothing is specified.
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--manifest` | `-m` | Path to subgraph manifest (default: `subgraph.yaml`) |
+| `--skip-build` | `-s` | Skip building the subgraph before testing |
+| `--postgres-url` | | PostgreSQL connection URL (env: `POSTGRES_URL`) |
+| `--matchstick` | | Use legacy Matchstick runner (**deprecated** — migrate to JSON-based tests) |
+| `--docker` | `-d` | Run Matchstick in Docker (requires `--matchstick`) |
+| `--coverage` | `-c` | Run with coverage reporting (requires `--matchstick`) |
+| `--recompile` | `-r` | Force recompilation (requires `--matchstick`) |
+| `--force` | `-f` | Force redownload of Matchstick binary (requires `--matchstick`) |
+
+**Examples:**
+
+```bash
+# Run all tests in tests/ directory (default)
+gnd test
+
+# Run specific test files
+gnd test transfer.json approval.json
+gnd test tests/transfer.json
+
+# Scan a custom directory
+gnd test my-tests/
+
+# Use a different manifest
+gnd test -m subgraph.staging.yaml tests/transfer.json
+
+# Skip automatic build
+gnd test -s
+```
+
+### `gnd clean`
+
+Remove build artifacts and generated files.
+
+```bash
+gnd clean
+```
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--codegen-dir` | | Codegen directory (default: `generated/`) |
+| `--build-dir` | | Build directory (default: `build/`) |
+
+### `gnd dev`
+
+Run graph-node in development mode with file watching.
+
+```bash
+gnd dev [OPTIONS]
+```
+
+**Flags:**
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--watch` | | Watch build directory for changes |
+| `--manifests` | | Subgraph manifest locations |
+| `--sources` | | Source manifest locations for aliases |
+| `--database-dir` | | Database directory (default: `./build`) |
+| `--postgres-url` | | PostgreSQL connection URL |
+| `--ethereum-rpc` | | Ethereum RPC URL |
+| `--ipfs` | | IPFS node URL |
+
+### `gnd indexer`
+
+Manage indexer operations via [`indexer-cli`](https://github.com/graphprotocol/indexer/tree/main/packages/indexer-cli).
+
+Requires `graph-indexer` to be installed and on `$PATH`:
+
+```bash
+npm install -g @graphprotocol/indexer-cli
+```
+
+```bash
+gnd indexer <subcommand> [args...]
+```
+
+**Help:**
+
+There are two ways to get help:
+
+| Command | What it shows |
+|---------|---------------|
+| `gnd indexer --help` | gnd's own help for the indexer subcommand (works without `graph-indexer` installed) |
+| `gnd indexer help` | Full `graph-indexer` help with all available commands (requires `graph-indexer`) |
+
+**Examples:**
+
+```bash
+# Check indexer status
+gnd indexer status --network arbitrum-one
+
+# Manage indexing rules
+gnd indexer rules get all --network mainnet
+gnd indexer rules set <deployment> decisionBasis always --network mainnet
+
+# Manage allocations
+gnd indexer allocations get --network arbitrum-one
+
+# Manage cost models
+gnd indexer cost get
+
+# View available indexer commands
+gnd indexer help
+
+# Check graph-indexer version
+gnd indexer version
+```
+
+### `gnd completions`
+
+Generate shell completions.
+
+```bash
+gnd completions <SHELL>
+```
+
+**Arguments:**
+- `SHELL`: One of `bash`, `elvish`, `fish`, `powershell`, `zsh`
+
+**Examples:**
+
+```bash
+# Bash
+gnd completions bash > ~/.bash_completion.d/gnd
+
+# Zsh
+gnd completions zsh > ~/.zfunc/_gnd
+
+# Fish
+gnd completions fish > ~/.config/fish/completions/gnd.fish
+```
+
+## Configuration Files
+
+### `~/.graph-cli.json`
+
+Stores deploy keys for different Graph Node URLs. Created by `gnd auth`.
+
+### `networks.json`
+
+Network-specific configuration for contract addresses and start blocks:
+
+```json
+{
+  "mainnet": {
+    "MyContract": {
+      "address": "0x1234...",
+      "startBlock": 12345678
+    }
+  },
+  "sepolia": {
+    "MyContract": {
+      "address": "0x5678...",
+      "startBlock": 1000000
+    }
+  }
+}
+```
+
+Use with `--network mainnet` on build/deploy commands.
+
+## Differences from graph-cli
+
+`gnd` is designed as a drop-in replacement for `graph-cli`. Some intentional differences:
+
+### Commands Not Implemented
+
+- **`local`**: Use graph-node's integration test infrastructure instead
+- **`node`**: Use `graphman` for node management operations
+
+### Code Generation Differences
+
+These are documented and tested:
+
+1. **Int8 import**: Always imported for simplicity, even when not used
+2. **Trailing commas**: Used in multi-line constructs
+3. **2D array accessors**: Uses correct `toStringMatrix()` (fixes a bug in graph-cli)
+
+### Other Differences
+
+- **Debug logging**: Uses `RUST_LOG` environment variable instead of `DEBUG=graph-cli:*`
+- **`--uncrashable` flag**: Not implemented (Float Capital third-party feature)
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `RUST_LOG` | Debug logging level (e.g., `RUST_LOG=gnd=debug`) |
+| `POSTGRES_URL` | PostgreSQL URL for `gnd dev` |
+| `ETHEREUM_RPC` | Ethereum RPC URL for `gnd dev` |
+
+## Version
+
+```bash
+gnd --version
+# gnd 0.1.0 (graph-cli compatible: 0.98.1)
+```
+
+Shows both the gnd version and the graph-cli version it emulates.
+
+## License
+
+Apache-2.0 OR MIT
diff --git a/gnd/docs/gnd-test.md b/gnd/docs/gnd-test.md
new file mode 100644
index 00000000000..6fcc118fc29
--- /dev/null
+++ b/gnd/docs/gnd-test.md
@@ -0,0 +1,939 @@
+# gnd test
+
+Mock-based subgraph test runner that feeds JSON-defined blocks through real graph-node infrastructure (store, WASM runtime, trigger processing) with only the blockchain layer mocked.
+
+## Quick Start
+
+```bash
+# Run all tests in tests/ directory
+gnd test
+
+# Run a specific test file
+gnd test tests/transfer.json
+
+# Skip automatic build (if subgraph already built)
+gnd test --skip-build
+
+# Use legacy Matchstick runner
+gnd test --matchstick
+```
+
+## Test File Format
+
+Tests are JSON files that define:
+- Mock blockchain blocks with events
+- Mock Ethereum RPC responses (`eth_call`, `eth_getBalance`, `eth_getCode`)
+- GraphQL assertions to validate entity state
+
+Place test files in a `tests/` directory with `.json` or `.test.json` extension.
+
+### Basic Example
+
+```json
+{
+  "name": "Transfer creates entity",
+  "blocks": [
+    {
+      "number": 1,
+      "timestamp": 1672531200,
+      "events": [
+        {
+          "address": "0x1234...",
+          "event": "Transfer(address indexed from, address indexed to, uint256 value)",
+          "params": {
+            "from": "0xaaaa...",
+            "to": "0xbbbb...",
+            "value": "1000"
+          }
+        }
+      ],
+      "ethCalls": [
+        {
+          "address": "0x1234...",
+          "function": "balanceOf(address)(uint256)",
+          "params": ["0xaaaa..."],
+          "returns": ["1000000000000000000"]
+        }
+      ]
+    }
+  ],
+  "assertions": [
+    {
+      "query": "{ transfer(id: \"1\") { from to value } }",
+      "expected": {
+        "transfer": {
+          "from": "0xaaaa...",
+          "to": "0xbbbb...",
+          "value": "1000"
+        }
+      }
+    }
+  ]
+}
+```
+
+## Block Fields
+
+| Field | Required | Default | Description |
+|-------|----------|---------|-------------|
+| `number` | No | Auto-increments from lowest defined `startBlock` in the manifest file, or from  `0` if no `startBlock` are defined | Block number |
+| `hash` | No | `keccak256(block_number)` | Block hash |
+| `timestamp` | No | `block_number` | Unix timestamp |
+| `baseFeePerGas` | No | None (pre-EIP-1559) | Base fee in wei |
+| `events` | No | Empty array | Log events in this block |
+| `ethCalls` | No | Empty array | Mock `eth_call` responses |
+| `getBalanceCalls` | No | Empty array | Mock `eth_getBalance` responses for `ethereum.getBalance()` |
+| `hasCodeCalls` | No | Empty array | Mock `eth_getCode` responses for `ethereum.hasCode()` |
+
+### Empty Blocks
+
+Empty blocks (no events) still trigger block handlers:
+
+```json
+{
+  "name": "Test block handlers",
+  "blocks": [
+    {
+      "number": 1,
+      "events": [...]
+    },
+    {}  // Block 2 with no events - block handlers still fire
+  ]
+}
+```
+
+## Event Fields
+
+| Field | Required | Default | Description |
+|-------|----------|---------|-------------|
+| `address` | Yes | — | Contract address (lowercase hex with 0x prefix) |
+| `event` | Yes | — | Full event signature with `indexed` keywords |
+| `params` | No | Empty object | Event parameter values |
+| `txHash` | No | `keccak256(block_number \|\| log_index)` | Transaction hash |
+
+### Event Signature Format
+
+**Important:** Include `indexed` keywords in the signature:
+
+```json
+{
+  "event": "Transfer(address indexed from, address indexed to, uint256 value)"
+}
+```
+
+Not:
+```json
+{
+  "event": "Transfer(address,address,uint256)"  // ❌ Missing indexed keywords
+}
+```
+
+### Parameter Types
+
+Event parameters are automatically ABI-encoded based on the signature. Supported formats:
+
+```json
+{
+  "params": {
+    "from": "0xaaaa...",           // address
+    "to": "0xbbbb...",              // address
+    "value": "1000",                // uint256 (string or number)
+    "amount": 1000,                 // uint256 (number)
+    "enabled": true,                // bool
+    "data": "0x1234...",           // bytes
+    "name": "Token"                 // string
+  }
+}
+```
+
+## Transaction Receipts
+
+Mock receipts are constructed for every log trigger and attached only to handlers that declare `receipt: true` in the manifest, mirroring production behaviour. Handlers without `receipt: true` receive a null receipt — the same as on a real node.
+
+**Limitation:** Only `receipt.logs` reflects your test data. All other receipt fields (`from`, `to`, `gas_used`, `status`, etc.) are hardcoded stubs and do not correspond to real transaction data. If your handler reads those fields, the values will be fixed defaults regardless of what you put in the test JSON.
+
+### How receipts are built
+
+Every event gets a mock receipt attached automatically. The key rule is **`txHash` grouping**:
+
+- Events sharing the same `txHash` share **one receipt** — `event.receipt!.logs` contains all of their logs in declaration order.
+- Events without an explicit `txHash` each get a unique auto-generated hash (`keccak256(block_number || log_index)`), so each gets its own single-log receipt.
+
+### Example: Two events sharing a receipt
+
+```json
+{
+  "events": [
+    {
+      "address": "0x1234...",
+      "event": "Transfer(address indexed from, address indexed to, uint256 value)",
+      "params": { "from": "0xaaaa...", "to": "0xbbbb...", "value": "100" },
+      "txHash": "0xdeadbeef0000000000000000000000000000000000000000000000000000000"
+    },
+    {
+      "address": "0x1234...",
+      "event": "Transfer(address indexed from, address indexed to, uint256 value)",
+      "params": { "from": "0xbbbb...", "to": "0xcccc...", "value": "50" },
+      "txHash": "0xdeadbeef0000000000000000000000000000000000000000000000000000000"
+    }
+  ]
+}
+```
+
+Both handlers receive a receipt where `receipt.logs` has two entries, in declaration order.
+
+### Mock receipt defaults
+
+| Field | Value |
+|-------|-------|
+| `status` | success |
+| `cumulative_gas_used` | `21000` |
+| `gas_used` | `21000` |
+| transaction type | `2` (EIP-1559) |
+| `from` | `0x000...000` |
+| `to` | `null` |
+| `effective_gas_price` | `0` |
+
+Handlers without `receipt: true` in the manifest are unaffected — they never access `event.receipt`.
+
+## Block Handlers
+
+Block handlers are **automatically triggered** for every block. You don't need to specify block triggers in the JSON.
+
+### How Block Handlers Work
+
+The test runner auto-injects both `Start` and `End` block triggers for each block, ensuring all block handler filters work correctly:
+
+- **`once` filter** → Fires once at `startBlock` (via `Start` trigger)
+- **No filter** → Fires on every block (via `End` trigger)
+- **`polling` filter** → Fires every N blocks based on formula: `(block_number - startBlock) % every == 0`
+
+### Example: Basic Block Handlers
+
+```json
+{
+  "name": "Block handlers test",
+  "blocks": [
+    {},  // Block 0 - both 'once' and regular block handlers fire
+    {}   // Block 1 - only regular block handlers fire
+  ],
+  "assertions": [
+    {
+      "query": "{ blocks { number } }",
+      "expected": {
+        "blocks": [
+          {"number": "0"},
+          {"number": "1"}
+        ]
+      }
+    },
+    {
+      "query": "{ blockOnces { msg } }",
+      "expected": {
+        "blockOnces": [
+          {"msg": "This fires only once at block 0"}
+        ]
+      }
+    }
+  ]
+}
+```
+
+### Polling Block Handlers
+
+Polling handlers fire at regular intervals specified by the `every` parameter. The handler fires when:
+
+```
+(block_number - startBlock) % every == 0
+```
+
+**Manifest example:**
+```yaml
+blockHandlers:
+  - handler: handleEveryThreeBlocks
+    filter:
+      kind: polling
+      every: 3
+```
+
+**Test example (startBlock: 0):**
+```json
+{
+  "name": "Polling handler test",
+  "blocks": [
+    {},  // Block 0 - handler fires (0 % 3 == 0)
+    {},  // Block 1 - handler doesn't fire
+    {},  // Block 2 - handler doesn't fire
+    {},  // Block 3 - handler fires (3 % 3 == 0)
+    {},  // Block 4 - handler doesn't fire
+    {},  // Block 5 - handler doesn't fire
+    {}   // Block 6 - handler fires (6 % 3 == 0)
+  ],
+  "assertions": [
+    {
+      "query": "{ pollingBlocks(orderBy: number) { number } }",
+      "expected": {
+        "pollingBlocks": [
+          {"number": "0"},
+          {"number": "3"},
+          {"number": "6"}
+        ]
+      }
+    }
+  ]
+}
+```
+
+**With non-zero startBlock:**
+
+When your data source has `startBlock > 0`, the polling interval is calculated from that starting point.
+
+**Manifest:**
+```yaml
+dataSources:
+  - name: Token
+    source:
+      startBlock: 100
+    mapping:
+      blockHandlers:
+        - handler: handlePolling
+          filter:
+            kind: polling
+            every: 5
+```
+
+**Test:**
+```json
+{
+  "name": "Polling from block 100",
+  "blocks": [
+    {"number": 100},  // Fires: (100-100) % 5 == 0
+    {"number": 101},  // Doesn't fire
+    {"number": 102},  // Doesn't fire
+    {"number": 103},  // Doesn't fire
+    {"number": 104},  // Doesn't fire
+    {"number": 105},  // Fires: (105-100) % 5 == 0
+    {"number": 106},  // Doesn't fire
+    {"number": 107},  // Doesn't fire
+    {"number": 108},  // Doesn't fire
+    {"number": 109},  // Doesn't fire
+    {"number": 110}   // Fires: (110-100) % 5 == 0
+  ],
+  "assertions": [
+    {
+      "query": "{ pollingBlocks(orderBy: number) { number } }",
+      "expected": {
+        "pollingBlocks": [
+          {"number": "100"},
+          {"number": "105"},
+          {"number": "110"}
+        ]
+      }
+    }
+  ]
+}
+```
+
+**Note:** The test runner automatically handles `startBlock > 0`, so blocks default to numbering from the manifest's `startBlock`.
+
+## eth_call Mocking
+
+Mock contract calls made from mapping handlers using `contract.call()`:
+
+```json
+{
+  "ethCalls": [
+    {
+      "address": "0x1234...",
+      "function": "balanceOf(address)(uint256)",
+      "params": ["0xaaaa..."],
+      "returns": ["1000000000000000000"]
+    }
+  ]
+}
+```
+
+### ethCall Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `address` | Yes | Contract address |
+| `function` | Yes | Full signature: `"functionName(inputTypes)(returnTypes)"` |
+| `params` | Yes | Array of input parameters (as strings) |
+| `returns` | Yes | Array of return values (as strings, ignored if `reverts: true`) |
+| `reverts` | No | Default `false`. If `true`, the mock transport returns an RPC error |
+
+### Function Signature Format
+
+Use full signatures with input and return types:
+
+```json
+{
+  "function": "symbol()(string)",           // No inputs, returns string
+  "function": "balanceOf(address)(uint256)", // One input, returns uint256
+  "function": "decimals()(uint8)"           // No inputs, returns uint8
+}
+```
+
+### Mocking Reverts
+
+```json
+{
+  "address": "0x1234...",
+  "function": "transfer(address,uint256)(bool)",
+  "params": ["0xaaaa...", "1000"],
+  "returns": [],
+  "reverts": true
+}
+```
+
+### Real-World Example
+
+From the ERC20 test:
+
+```json
+{
+  "ethCalls": [
+    {
+      "address": "0x731a10897d267e19b34503ad902d0a29173ba4b1",
+      "function": "symbol()(string)",
+      "params": [],
+      "returns": ["GRT"]
+    },
+    {
+      "address": "0x731a10897d267e19b34503ad902d0a29173ba4b1",
+      "function": "name()(string)",
+      "params": [],
+      "returns": ["TheGraph"]
+    },
+    {
+      "address": "0x731a10897d267e19b34503ad902d0a29173ba4b1",
+      "function": "balanceOf(address)(uint256)",
+      "params": ["0xaaaa000000000000000000000000000000000000"],
+      "returns": ["3000000000000000000"]
+    }
+  ]
+}
+```
+
+## ethereum.getBalance() Mocking
+
+Mock balance lookups made from mapping handlers using `ethereum.getBalance()`:
+
+```json
+{
+  "getBalanceCalls": [
+    {
+      "address": "0xaaaa000000000000000000000000000000000000",
+      "value": "1000000000000000000"
+    }
+  ]
+}
+```
+
+### getBalanceCalls Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `address` | Yes | Account address (checksummed or lowercase hex) |
+| `value` | Yes | Balance in Wei as a decimal string |
+
+## ethereum.hasCode() Mocking
+
+Mock code existence checks made from mapping handlers using `ethereum.hasCode()`:
+
+```json
+{
+  "hasCodeCalls": [
+    {
+      "address": "0x1234000000000000000000000000000000000000",
+      "hasCode": true
+    }
+  ]
+}
+```
+
+### hasCodeCalls Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `address` | Yes | Contract address (checksummed or lowercase hex) |
+| `hasCode` | Yes | Whether the address has deployed bytecode |
+
+## File Data Sources
+
+Mock IPFS and Arweave file contents for file data source handlers. Files are defined at the top level of the test JSON (not inside blocks).
+
+### IPFS Files
+
+```json
+{
+  "name": "File data source test",
+  "files": [
+    {
+      "cid": "QmExample...",
+      "content": "{\"name\": \"Token\", \"description\": \"A token\"}"
+    },
+    {
+      "cid": "QmAnother...",
+      "file": "fixtures/metadata.json"
+    }
+  ],
+  "blocks": [...],
+  "assertions": [...]
+}
+```
+
+#### files Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `cid` | Yes | IPFS CID (`Qm...` or `bafy...`). The mock ignores hash/content relationship |
+| `content` | One of `content`/`file` | Inline UTF-8 content |
+| `file` | One of `content`/`file` | File path, resolved relative to the test JSON |
+
+### Arweave Files
+
+```json
+{
+  "name": "Arweave data source test",
+  "arweaveFiles": [
+    {
+      "txId": "abc123",
+      "content": "{\"name\": \"Token\"}"
+    },
+    {
+      "txId": "def456/metadata.json",
+      "file": "fixtures/arweave-data.json"
+    }
+  ],
+  "blocks": [...],
+  "assertions": [...]
+}
+```
+
+#### arweaveFiles Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `txId` | Yes | Arweave transaction ID or bundle path (e.g. `"txid/filename.json"`) |
+| `content` | One of `content`/`file` | Inline UTF-8 content |
+| `file` | One of `content`/`file` | File path, resolved relative to the test JSON |
+
+## Assertions
+
+GraphQL queries to validate the indexed entity state after processing all blocks.
+
+### Assertion Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `query` | Yes | GraphQL query string |
+| `expected` | Yes | Expected JSON response |
+
+### Comparison Behavior
+
+| Aspect | Behavior |
+|--------|----------|
+| Objects | Key-compared, order-insensitive |
+| Arrays | **Order-insensitive** (set comparison) |
+| String vs Number | Coerced — `"123"` matches `123` |
+| Nulls/Booleans | Strict equality |
+| Hex strings | **Must be lowercase** — graph-node returns all hex values in lowercase |
+
+**Important:** Arrays are compared as sets (order doesn't matter).
+
+**Important:** graph-node returns all hex-encoded values (addresses, transaction hashes, byte arrays) in **lowercase**. Expected values in assertions must match exactly — mixed-case hex will not match:
+
+```json
+{
+  "expected": {
+    "transfer": {
+      "from": "0xaaaa000000000000000000000000000000000000",  // ✅ lowercase
+      "to":   "0xBBBB000000000000000000000000000000000000"   // ❌ will not match
+    }
+  }
+}
+```
+
+Note: hex values in event inputs (`params`, `address`) are normalized automatically and can be mixed case. If you need ordered results, use `orderBy` in your GraphQL query:
+
+```json
+{
+  "query": "{ transfers(orderBy: timestamp, orderDirection: asc) { id from to value } }",
+  "expected": { ... }
+}
+```
+
+### Multiple Assertions
+
+You can have multiple assertions per test. They run sequentially after all blocks are processed:
+
+```json
+{
+  "assertions": [
+    {
+      "query": "{ tokens { id name symbol } }",
+      "expected": { ... }
+    },
+    {
+      "query": "{ accounts { id balance } }",
+      "expected": { ... }
+    }
+  ]
+}
+```
+
+### Nested Entity Queries
+
+Test relationships and nested entities:
+
+```json
+{
+  "query": "{ accounts { id balances { token { symbol } amount } } }",
+  "expected": {
+    "accounts": [
+      {
+        "id": "0xbbbb...",
+        "balances": [
+          {
+            "token": { "symbol": "GRT" },
+            "amount": "5000000000000000000"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## startBlock Handling
+
+The test runner automatically reads `startBlock` from your subgraph manifest and handles it correctly — **no real blockchain connection needed**.
+
+### How It Works
+
+1. Extracts the **minimum `startBlock`** across all data sources in your manifest
+2. If min > 0, creates a `start_block_override` to bypass graph-node's on-chain block validation
+3. Test blocks without explicit `"number"` auto-increment starting from that minimum `startBlock`
+
+### Default Block Numbering
+
+The starting block number depends on your manifest:
+
+| Manifest Configuration | Test Block Numbers |
+|----------------------|-------------------|
+| `startBlock: 0` (or unset) | 0, 1, 2, ... |
+| `startBlock: 100` | 100, 101, 102, ... |
+| Multiple data sources: `startBlock: 50` and `startBlock: 200` | 50, 51, 52, ... (uses minimum) |
+
+### Example: Single Data Source
+
+**Manifest:**
+```yaml
+dataSources:
+  - name: Token
+    source:
+      startBlock: 1000
+```
+
+**Test:**
+```json
+{
+  "blocks": [
+    {},  // Block 1000 (auto-numbered)
+    {}   // Block 1001 (auto-numbered)
+  ]
+}
+```
+
+### Example: Explicit Block Numbers
+
+Override auto-numbering by specifying `"number"`:
+
+```json
+{
+  "blocks": [
+    {
+      "number": 5000,
+      "events": [...]
+    },
+    {
+      "number": 5001,
+      "events": [...]
+    }
+  ]
+}
+```
+
+### Multi-Data Source Testing
+
+When your subgraph has multiple data sources with different `startBlock` values, you may need to use explicit block numbers.
+
+**Scenario:** DataSource A at `startBlock: 50` (Transfer events), DataSource B at `startBlock: 200` (Approval events). You want to test only DataSource B.
+
+**Manifest:**
+```yaml
+dataSources:
+  - name: TokenTransfers
+    source:
+      startBlock: 50
+    mapping:
+      eventHandlers:
+        - event: Transfer(...)
+          handler: handleTransfer
+  - name: TokenApprovals
+    source:
+      startBlock: 200
+    mapping:
+      eventHandlers:
+        - event: Approval(...)
+          handler: handleApproval
+```
+
+**Test:**
+```json
+{
+  "name": "Test Approval handler",
+  "blocks": [
+    {
+      "number": 200,  // Explicit number >= DataSource B's startBlock
+      "events": [
+        {
+          "address": "0x5678...",
+          "event": "Approval(address indexed owner, address indexed spender, uint256 value)",
+          "params": {
+            "owner": "0xaaaa...",
+            "spender": "0xbbbb...",
+            "value": "500"
+          }
+        }
+      ]
+    },
+    {
+      "number": 201,
+      "events": [...]
+    }
+  ]
+}
+```
+
+**Why explicit numbers are needed:**
+- Default numbering starts at the **minimum** `startBlock` across all data sources (50 in this case)
+- Blocks 50-199 are below DataSource B's `startBlock: 200`, so its handlers won't fire
+- Use explicit `"number": 200` to ensure the block is in DataSource B's active range
+
+**Note:** DataSource A is still "active" from block 50 onward, but it simply sees no matching Transfer events in blocks 200-201, so no handlers fire for it. This is normal behavior — graph-node doesn't error on inactive handlers.
+
+## Test Organization
+
+### Directory Structure
+
+```
+my-subgraph/
+├── subgraph.yaml
+├── schema.graphql
+├── src/
+│   └── mapping.ts
+└── tests/
+    ├── transfer.json
+    ├── approval.json
+    └── edge-cases.test.json
+```
+
+### Naming Conventions
+
+- Use `.json` or `.test.json` extension
+- Descriptive names: `transfer.json`, `mint-burn.json`, `edge-cases.json`
+- The test runner discovers all `*.json` and `*.test.json` files in the test directory
+
+## Known Limitations
+
+| Feature | Status |
+|---------|--------|
+| Log events | ✅ Supported |
+| Block handlers (all filters) | ✅ Supported |
+| `eth_call` mocking | ✅ Supported |
+| `ethereum.getBalance()` mocking | ✅ Supported |
+| `ethereum.hasCode()` mocking | ✅ Supported |
+| Dynamic/template data sources | ✅ Supported |
+| Transaction receipts (`receipt: true`) | ⚠️ Partial — `receipt.logs` is populated and grouped by `txHash`; other fields (gas, from, to, etc.) are hardcoded stubs (see [Transaction Receipts](#transaction-receipts)) |
+| File data sources (IPFS + Arweave) | ✅ Supported |
+| Call triggers (traces) | ❌ Not implemented |
+| `--json` CI output | ❌ Not implemented |
+| Parallel test execution | ❌ Not implemented |
+| Test name filtering (`--filter`) | ❌ Not implemented |
+
+## Tips & Best Practices
+
+### Use Lowercase Hex in Assertions
+
+graph-node returns **all** hex-encoded values in lowercase — addresses, transaction hashes, and any `Bytes`/`ID` fields. Expected values in assertions must use lowercase hex:
+
+```json
+{
+  "expected": {
+    "transfer": {
+      "from": "0xaaaa000000000000000000000000000000000000"  // ✅ lowercase
+    }
+  }
+}
+```
+
+Not:
+```json
+{
+  "expected": {
+    "transfer": {
+      "from": "0xAAAA000000000000000000000000000000000000"  // ❌ will not match
+    }
+  }
+}
+```
+
+Event inputs (`address`, `params`) are normalized automatically and can be mixed case.
+
+### Test One Thing at a Time
+
+Write focused tests that validate a single behavior:
+
+```json
+// ✅ Good - tests one scenario
+{
+  "name": "Transfer event creates TransferEvent entity",
+  "blocks": [...],
+  "assertions": [...]
+}
+```
+
+```json
+// ❌ Avoid - tests too many things
+{
+  "name": "Test everything",
+  "blocks": [/* 50 blocks */],
+  "assertions": [/* 20 assertions */]
+}
+```
+
+### Order GraphQL Results
+
+If your assertion needs specific ordering, use `orderBy`:
+
+```json
+{
+  "query": "{ transfers(first: 10, orderBy: timestamp, orderDirection: asc) { id } }",
+  "expected": { ... }
+}
+```
+
+### Test Block Handlers with Empty Blocks
+
+Use empty blocks to test that block handlers fire even without events:
+
+```json
+{
+  "blocks": [
+    {},  // Empty block - block handlers still fire
+    {}
+  ]
+}
+```
+
+### Split Complex Tests
+
+Instead of one large test with many blocks, split into multiple focused test files:
+
+```
+tests/
+├── transfer-basic.json        # Basic transfer functionality
+├── transfer-zero-value.json   # Edge case: zero value
+└── transfer-same-account.json # Edge case: self-transfer
+```
+
+## Architecture
+
+The test runner reuses real graph-node infrastructure:
+
+```
+test.json
+    ↓
+Parse & ABI encode events
+    ↓
+Mock block stream (StaticStreamBuilder)
+    ↓
+Real graph-node indexer
+    ├── WASM runtime
+    ├── Trigger processing
+    └── Entity storage (pgtemp database)
+    ↓
+GraphQL queries → Assertions
+```
+
+**Key design principles:**
+
+- **Isolated database per test:** Each test gets a pgtemp database dropped on completion (default), or a shared persistent database with post-test cleanup (`--postgres-url`)
+- **Mock transport layer:** A mock Alloy transport serves `eth_call`, `eth_getBalance`, and `eth_getCode` from test JSON data. All three flow through the real production code path — only the transport returns mock responses. Unmocked RPC calls fail immediately with a descriptive error.
+- **No IPFS for manifest:** Uses `FileLinkResolver` to load manifest/WASM from build directory
+
+## Troubleshooting
+
+### Test Fails: "Entity not found"
+
+**Cause:** Handler didn't create the expected entity.
+
+**Fix:**
+1. Check event signature matches ABI (include `indexed` keywords)
+2. Verify contract address matches manifest
+3. Check block number is >= data source's `startBlock`
+4. Add debug logging to your mapping handler
+
+### Test Timeout
+
+**Cause:** Indexer took longer than 60 seconds (default timeout).
+
+**Fix:**
+1. Reduce number of blocks in test
+2. Simplify mapping logic
+3. Check for infinite loops in handler code
+
+### Unmocked RPC Call
+
+**Cause:** A mapping handler calls `ethereum.call`, `ethereum.getBalance`, or `ethereum.hasCode` for a call that has no matching mock entry.
+
+**Symptom:** Test fails immediately with a descriptive error like:
+```
+gnd test: unmocked eth_call to 0x1234... at block hash 0xabcd...
+Add a matching 'ethCalls' entry to this block in your test JSON.
+```
+
+**Fix:**
+1. Add the missing mock to the appropriate field in your test block (`ethCalls`, `getBalanceCalls`, or `hasCodeCalls`)
+2. If the call is not supposed to happen, check the mapping logic — a code path may be executing unexpectedly
+
+### Block Handler Not Firing
+
+**Cause:** Block handlers auto-fire, but might be outside data source's active range.
+
+**Fix:**
+1. Check data source's `startBlock` in manifest
+2. Use explicit `"number"` in test blocks to ensure they're >= `startBlock`
+3. Verify handler is defined in manifest's `blockHandlers` section
+
+## Legacy Matchstick Mode
+
+Fall back to the external Matchstick test runner for backward compatibility:
+
+```bash
+gnd test --matchstick
+```
+
+This is useful if:
+- You have existing Matchstick tests
+- You need features not yet supported by the mock-based runner
+- You're migrating gradually from Matchstick to the new test format
+
+## See Also
+
+- [Subgraph Manifest Documentation](https://thegraph.com/docs/en/developing/creating-a-subgraph/)
+- [AssemblyScript Mapping API](https://thegraph.com/docs/en/developing/assemblyscript-api/)
+- [GraphQL Schema](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-graph-ql-schema)
diff --git a/gnd/docs/migrating-from-graph-cli.md b/gnd/docs/migrating-from-graph-cli.md
new file mode 100644
index 00000000000..6203a6f2f21
--- /dev/null
+++ b/gnd/docs/migrating-from-graph-cli.md
@@ -0,0 +1,303 @@
+# Migrating from graph-cli to gnd
+
+`gnd` is designed as a drop-in replacement for `graph-cli`. This guide covers the differences and how to migrate your workflow.
+
+## TL;DR
+
+For most users, migration is straightforward:
+
+```bash
+# Instead of:
+graph codegen
+graph build
+graph deploy --studio my-subgraph
+
+# Use:
+gnd codegen
+gnd build
+gnd deploy my-subgraph  # defaults to Studio; prompts for version label in interactive terminals
+```
+
+## Command Mapping
+
+| graph-cli | gnd | Notes |
+|-----------|-----|-------|
+| `graph init` | `gnd init` | Identical flags |
+| `graph codegen` | `gnd codegen` | Identical flags |
+| `graph build` | `gnd build` | Identical flags |
+| `graph deploy` | `gnd deploy` | Defaults to Studio if `--node` not provided; pass `--version-label` in non-interactive mode |
+| `graph create` | `gnd create` | Identical flags |
+| `graph remove` | `gnd remove` | Identical flags |
+| `graph auth` | `gnd auth` | Identical flags |
+| `graph add` | `gnd add` | Identical flags |
+| `graph test` | `gnd test` | Identical flags |
+| `graph clean` | `gnd clean` | Identical flags (new in graph-cli 0.80+) |
+| `graph publish` | `gnd publish` | Identical flags |
+| `graph indexer` | `gnd indexer` | Delegates to `graph-indexer` — requires `indexer-cli` installed |
+| `graph local` | N/A | Not implemented - use graph-node's test infrastructure |
+| `graph node` | N/A | Not implemented - use `graphman` |
+
+## What's the Same
+
+### Flag Compatibility
+
+All flags use the same names, short forms, and defaults:
+
+```bash
+# Both work identically
+graph codegen -o generated/ --skip-migrations
+gnd codegen -o generated/ --skip-migrations
+
+graph build -t wasm --network mainnet
+gnd build -t wasm --network mainnet
+
+graph deploy -l v1.0.0 --ipfs http://localhost:5001 my-subgraph
+gnd deploy -l v1.0.0 --ipfs http://localhost:5001 my-subgraph
+```
+
+### Output Format
+
+Same success checkmarks, step descriptions, and progress indicators:
+
+```
+✔ Generate types for data source: Gravity (...)
+✔ Write types to generated/Gravity/Gravity.ts (...)
+```
+
+### Exit Codes
+
+- `0` for success
+- `1` for any error
+- `gnd indexer` passes through the exit code from `graph-indexer`
+
+### Configuration Files
+
+`gnd` uses the same configuration files as `graph-cli`:
+
+- `~/.graph-cli.json` - Deploy keys (from `gnd auth`)
+- `networks.json` - Network-specific addresses
+
+Your existing auth keys work with both tools.
+
+### Generated Code
+
+Code generation produces identical AssemblyScript output (after formatting). Your existing subgraph code will work without changes.
+
+## What's Different
+
+### Indexer Commands
+
+`gnd indexer` provides access to indexer management commands via [`indexer-cli`](https://github.com/graphprotocol/indexer/tree/main/packages/indexer-cli). Requires `graph-indexer` on `$PATH`:
+
+```bash
+npm install -g @graphprotocol/indexer-cli
+
+gnd indexer status --network arbitrum-one
+gnd indexer rules get all --network mainnet
+gnd indexer allocations get --network arbitrum-one
+```
+
+Note: `gnd indexer --help` shows gnd's own help and works without `graph-indexer` installed. Use `gnd indexer help` to see the full list of `graph-indexer` commands.
+
+### Commands Not Available
+
+#### `graph local`
+
+Not implemented in `gnd`. Use graph-node's built-in integration test infrastructure or Docker compose setups instead.
+
+#### `graph node`
+
+Not implemented. Use `graphman` for node management operations:
+
+```bash
+# Instead of graph node commands, use graphman:
+graphman info subgraph-name
+graphman reassign subgraph-name shard
+```
+
+### Debug Logging
+
+```bash
+# graph-cli uses:
+DEBUG=graph-cli:* graph codegen
+
+# gnd uses:
+RUST_LOG=gnd=debug gnd codegen
+```
+
+### The `--uncrashable` Flag
+
+The `--uncrashable` flag on `codegen` (Float Capital's uncrashable helper generation) is not implemented. This is a third-party feature that most subgraphs don't use.
+
+### Minor Code Generation Differences
+
+These differences are intentional and documented:
+
+1. **Int8 import**: `gnd` always imports `Int8` in generated code for simplicity, even when not used. This doesn't affect functionality.
+
+2. **Trailing commas**: `gnd` uses trailing commas in multi-line constructs:
+   ```typescript
+   // gnd output
+   new Foo(
+     param1,
+     param2,  // trailing comma
+   )
+
+   // graph-cli output
+   new Foo(
+     param1,
+     param2
+   )
+   ```
+
+3. **2D array accessors**: `gnd` uses the correct `toStringMatrix()` method for 2D GraphQL arrays, fixing a bug in graph-cli that used `toStringArray()`.
+
+## Migration Steps
+
+### Step 1: Install gnd
+
+Build from source in the graph-node repository:
+
+```bash
+cargo build -p gnd --release
+# Binary at target/release/gnd
+```
+
+### Step 2: Verify Your Auth
+
+Your existing `~/.graph-cli.json` works with both tools. Verify with:
+
+```bash
+# Check stored keys
+cat ~/.graph-cli.json
+
+# Or just run a deploy dry-run to see if auth is working
+gnd deploy --help
+```
+
+### Step 3: Test Locally
+
+Run your normal workflow with gnd:
+
+```bash
+gnd codegen
+gnd build
+```
+
+Compare the output to graph-cli if you want to verify:
+
+```bash
+# graph-cli
+graph codegen -o generated-graph/
+graph build -o build-graph/
+
+# gnd
+gnd codegen -o generated-gnd/
+gnd build -o build-gnd/
+
+# Compare (should be identical after formatting)
+diff -r generated-graph generated-gnd
+diff -r build-graph build-gnd
+```
+
+### Step 4: Update CI/CD
+
+Replace `graph` with `gnd` in your CI configuration:
+
+```yaml
+# Before
+- run: graph codegen
+- run: graph build
+- run: graph deploy --studio -l ${{ github.sha }} ${{ secrets.SUBGRAPH_NAME }}
+
+# After
+- run: gnd codegen
+- run: gnd build
+- run: gnd deploy -l ${{ github.sha }} ${{ secrets.SUBGRAPH_NAME }}
+```
+
+### Step 5: Update package.json Scripts (Optional)
+
+If you have npm scripts calling graph-cli:
+
+```json
+{
+  "scripts": {
+    "codegen": "gnd codegen",
+    "build": "gnd build",
+    "deploy": "gnd deploy -l $VERSION_LABEL"
+  }
+}
+```
+
+Set `VERSION_LABEL` in your environment (for example, from a git tag or commit SHA).
+
+## Troubleshooting
+
+### "Command not found: gnd"
+
+Make sure the gnd binary is in your PATH:
+
+```bash
+export PATH="$PATH:/path/to/graph-node/target/release"
+```
+
+### "prettier: command not found"
+
+`gnd codegen` shells out to `prettier` for formatting. Install it:
+
+```bash
+npm install -g prettier
+# or
+pnpm add -g prettier
+```
+
+### "asc: command not found"
+
+`gnd build` shells out to the AssemblyScript compiler. Install it:
+
+```bash
+npm install -g assemblyscript
+# or have it in your subgraph's node_modules
+npm install --save-dev assemblyscript
+```
+
+### Different Output After codegen
+
+If you notice differences in generated code:
+
+1. Check if it's one of the documented differences (Int8 import, trailing commas)
+2. Run prettier on both outputs to normalize formatting
+3. Report any unexpected differences as a bug
+
+### Authentication Issues
+
+Keys stored by graph-cli work with gnd and vice versa. If you have issues:
+
+```bash
+# Re-authenticate
+gnd auth YOUR_DEPLOY_KEY
+
+# Verify the key was saved
+cat ~/.graph-cli.json
+```
+
+## Why Migrate?
+
+### Benefits of gnd
+
+- **Native performance**: Rust implementation is faster for large subgraphs
+- **Integrated with graph-node**: Same codebase, consistent behavior
+- **Better error messages**: Leverages graph-node's validation
+- **`gnd dev` command**: Run graph-node in development mode
+
+### When to Keep Using graph-cli
+
+- If you need multi-protocol support (NEAR, Cosmos, Arweave, Substreams) - gnd currently focuses on Ethereum
+- If you use the `--uncrashable` flag
+- If you need the `graph local` or `graph node` commands
+
+## Getting Help
+
+- File issues at: https://github.com/graphprotocol/graph-node/issues
+- Check gnd version: `gnd --version`
diff --git a/gnd/npm/README.md b/gnd/npm/README.md
new file mode 100644
index 00000000000..acca621b4dc
--- /dev/null
+++ b/gnd/npm/README.md
@@ -0,0 +1,35 @@
+# The Graph CLI
+
+This package installs the CLI for developing subgraphs for [The Graph
+Network](https://thegraph.com/subgraphs/) It supports all aspects of
+[developing, testing, and deploying subgraphs](https://thegraph.com/docs/en/subgraphs/quick-start/) locally and
+on the network.
+
+This package is a complete replacement for the older
+[graph-cli](https://www.npmjs.com/package/@graphprotocol/graph-cli) which
+will over time be migrated to be a simple wrapper for `gnd`. Older
+documentation will reference `graph-cli` in its instructions; running
+`alias graph=gnd` in the shell make it possible to follow these
+instructions verbatim with `gnd`.
+
+Besides the tools to develop subgraphs, `gnd` also contains a version of
+[graph-node](https://github.com/graphprotocol/graph-node) tailored to
+running subgraphs locally via `gnd dev`.
+
+
+## Getting started
+
+Run `npm install -g @graphprotocol/gnd` to install `gnd`.
+
+After installation, you can create and run an example subgraph locally with
+```bash
+gnd init --from-example ethereum-gravatar 'My new subgraph' new-subgraph
+cd new-subgraph
+gnd codegen
+gnd build
+gnd dev --ethereum-rpc 'mainnet:<RPC URL>'
+```
+
+If you have an existing contract for which you want to write a subgraph,
+have a look at `gnd help init` and the `--from-contract` option. You can
+also simply run `gnd init` and follow the prompts to set up your subgraph.
diff --git a/gnd/npm/bin/gnd.js b/gnd/npm/bin/gnd.js
new file mode 100644
index 00000000000..82a7ae5bf09
--- /dev/null
+++ b/gnd/npm/bin/gnd.js
@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+const { execFileSync } = require("child_process");
+const path = require("path");
+
+const PLATFORMS = {
+  "darwin-arm64": "@graphprotocol/gnd-darwin-arm64",
+  "darwin-x64": "@graphprotocol/gnd-darwin-x64",
+  "linux-arm64": "@graphprotocol/gnd-linux-arm64",
+  "linux-x64": "@graphprotocol/gnd-linux-x64",
+  "win32-x64": "@graphprotocol/gnd-win32-x64",
+};
+
+const key = `${process.platform}-${process.arch}`;
+const pkg = PLATFORMS[key];
+if (!pkg) {
+  console.error(`Unsupported platform: ${key}`);
+  process.exit(1);
+}
+
+const bin = process.platform === "win32" ? "gnd.exe" : "gnd";
+const binPath = path.join(
+  require.resolve(`${pkg}/package.json`),
+  "..",
+  "bin",
+  bin
+);
+
+try {
+  execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+} catch (e) {
+  process.exit(e.status ?? 1);
+}
diff --git a/gnd/src/abi.rs b/gnd/src/abi.rs
new file mode 100644
index 00000000000..0a5fa695cf4
--- /dev/null
+++ b/gnd/src/abi.rs
@@ -0,0 +1,101 @@
+//! ABI normalization utilities.
+//!
+//! Handles extraction of bare ABI arrays from various artifact formats
+//! (raw arrays, Hardhat/Foundry, Truffle).
+
+use anyhow::{Context, Result, anyhow};
+
+/// Normalize ABI JSON to extract the actual ABI array from various artifact formats.
+///
+/// Supports:
+/// - Raw ABI array: `[{...}]`
+/// - Foundry/Hardhat format: `{"abi": [...], ...}`
+/// - Truffle format: `{"compilerOutput": {"abi": [...], ...}, ...}`
+pub fn normalize_abi_json(abi_str: &str) -> Result<serde_json::Value> {
+    let value: serde_json::Value =
+        serde_json::from_str(abi_str).context("Failed to parse ABI JSON")?;
+
+    // Case 1: Already an array - return as-is
+    if value.is_array() {
+        return Ok(value);
+    }
+
+    // Case 2: Object with "abi" field (Foundry/Hardhat format)
+    if let Some(abi) = value.get("abi")
+        && abi.is_array()
+    {
+        return Ok(abi.clone());
+    }
+
+    // Case 3: Object with "compilerOutput.abi" field (Truffle format)
+    if let Some(compiler_output) = value.get("compilerOutput")
+        && let Some(abi) = compiler_output.get("abi")
+        && abi.is_array()
+    {
+        return Ok(abi.clone());
+    }
+
+    Err(anyhow!(
+        "Invalid ABI format: expected an array or an object with 'abi' field"
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_normalize_abi_json_raw_array() {
+        let raw_abi = r#"[{"type": "event", "name": "Transfer"}]"#;
+        let result = normalize_abi_json(raw_abi).unwrap();
+        assert!(result.is_array());
+        assert_eq!(result.as_array().unwrap().len(), 1);
+    }
+
+    #[test]
+    fn test_normalize_abi_json_hardhat_format() {
+        let hardhat_abi = r#"{
+            "_format": "hh-sol-artifact-1",
+            "contractName": "MyContract",
+            "abi": [{"type": "event", "name": "Transfer"}],
+            "bytecode": "0x..."
+        }"#;
+        let result = normalize_abi_json(hardhat_abi).unwrap();
+        assert!(result.is_array());
+        assert_eq!(result.as_array().unwrap().len(), 1);
+        assert_eq!(
+            result.as_array().unwrap()[0].get("name").unwrap(),
+            "Transfer"
+        );
+    }
+
+    #[test]
+    fn test_normalize_abi_json_truffle_format() {
+        let truffle_abi = r#"{
+            "contractName": "MyContract",
+            "compilerOutput": {
+                "abi": [{"type": "event", "name": "Transfer"}]
+            }
+        }"#;
+        let result = normalize_abi_json(truffle_abi).unwrap();
+        assert!(result.is_array());
+        assert_eq!(result.as_array().unwrap().len(), 1);
+        assert_eq!(
+            result.as_array().unwrap()[0].get("name").unwrap(),
+            "Transfer"
+        );
+    }
+
+    #[test]
+    fn test_normalize_abi_json_invalid_format() {
+        let invalid_abi = r#"{"contractName": "MyContract"}"#;
+        let result = normalize_abi_json(invalid_abi);
+        assert!(result.is_err());
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("Invalid ABI format")
+        );
+    }
+}
diff --git a/gnd/src/codegen/abi.rs b/gnd/src/codegen/abi.rs
new file mode 100644
index 00000000000..9b881fdcbe9
--- /dev/null
+++ b/gnd/src/codegen/abi.rs
@@ -0,0 +1,1955 @@
+//! ABI code generation for Ethereum contracts.
+//!
+//! Generates AssemblyScript bindings from contract ABIs:
+//! - Event classes with typed parameters
+//! - Call classes for function calls with inputs/outputs
+//! - Contract class with typed call methods
+
+use std::collections::HashMap;
+
+use graph::abi::{
+    DynSolType, Event, EventParam, Function, FunctionExt, JsonAbi, Param, StateMutability,
+};
+use regex::Regex;
+
+use super::typescript::{self as ts, Class, ClassMember, Method, ModuleImports, Param as TsParam};
+use crate::shared::{capitalize, handle_reserved_word};
+
+/// Resolve a `Param`'s type to `DynSolType`.
+fn resolve_param_type(param: &Param) -> DynSolType {
+    param
+        .selector_type()
+        .parse::<DynSolType>()
+        .expect("valid ABI type")
+}
+
+/// Resolve an `EventParam`'s type to `DynSolType`.
+fn resolve_event_param_type(param: &EventParam) -> DynSolType {
+    param
+        .selector_type()
+        .parse::<DynSolType>()
+        .expect("valid ABI type")
+}
+
+const GRAPH_TS_MODULE: &str = "@graphprotocol/graph-ts";
+
+/// ABI code generator.
+pub struct AbiCodeGenerator {
+    contract: JsonAbi,
+    name: String,
+}
+
+impl AbiCodeGenerator {
+    /// Create a new ABI code generator.
+    pub fn new(contract: JsonAbi, name: impl Into<String>) -> Self {
+        let mut name = name.into();
+        // Sanitize name to be a valid class name
+        let re = Regex::new(r#"[!@#$%^&*()+\-=\[\]{};':\"|,.<>/?]+"#).unwrap();
+        name = re.replace_all(&name, "_").to_string();
+        Self { contract, name }
+    }
+
+    /// Generate module imports for the ABI file.
+    pub fn generate_module_imports(&self) -> Vec<ModuleImports> {
+        vec![ModuleImports::new(
+            vec![
+                "ethereum".to_string(),
+                "JSONValue".to_string(),
+                "TypedMap".to_string(),
+                "Entity".to_string(),
+                "Bytes".to_string(),
+                "Address".to_string(),
+                "BigInt".to_string(),
+            ],
+            GRAPH_TS_MODULE,
+        )]
+    }
+
+    /// Generate all types from the ABI.
+    pub fn generate_types(&self) -> Vec<Class> {
+        let mut classes = Vec::new();
+        classes.extend(self.generate_event_types());
+        classes.extend(self.generate_smart_contract_class());
+        classes.extend(self.generate_call_types());
+        classes
+    }
+
+    /// Generate event type classes.
+    fn generate_event_types(&self) -> Vec<Class> {
+        let mut classes = Vec::new();
+        let events = self.disambiguate_events();
+
+        for (event, alias) in events {
+            let event_class_name = alias.clone();
+            let mut tuple_classes = Vec::new();
+
+            // Generate params class
+            let params_class_name = [&event_class_name, "__Params"].concat();
+            let mut params_class = ts::klass(&params_class_name).exported();
+            params_class.add_member(ClassMember::new("_event", &event_class_name));
+            params_class.add_method(Method::new(
+                "constructor",
+                vec![TsParam::new("event", ts::NamedType::new(&event_class_name))],
+                None,
+                "this._event = event",
+            ));
+
+            // Generate getters for event params
+            let inputs = self.disambiguate_event_params(&event.inputs, "param");
+            for (index, (param, param_name)) in inputs.iter().enumerate() {
+                let param_object = self.generate_event_param(
+                    param,
+                    param_name,
+                    index,
+                    &event_class_name,
+                    &mut tuple_classes,
+                );
+                params_class.add_method(param_object);
+            }
+
+            // Generate event class
+            let mut event_class = ts::klass(&event_class_name)
+                .exported()
+                .extends("ethereum.Event");
+            event_class.add_method(Method::new(
+                "get params",
+                vec![],
+                Some(ts::NamedType::new(&params_class_name).into()),
+                format!("return new {}(this)", params_class_name),
+            ));
+
+            classes.push(event_class);
+            classes.push(params_class);
+            classes.extend(tuple_classes);
+        }
+
+        classes
+    }
+
+    /// Generate the smart contract class with call methods.
+    fn generate_smart_contract_class(&self) -> Vec<Class> {
+        let mut classes = Vec::new();
+
+        let mut contract_class = ts::klass(&self.name)
+            .exported()
+            .extends("ethereum.SmartContract");
+
+        // Add static bind method
+        let contract_name = &self.name;
+        contract_class.add_static_method(ts::StaticMethod::new(
+            "bind",
+            vec![TsParam::new("address", ts::NamedType::new("Address"))],
+            ts::NamedType::new(&self.name),
+            format!("return new {}('{}', address)", contract_name, contract_name),
+        ));
+
+        // Get callable functions and sort alphabetically for deterministic output
+        let mut functions = self.get_callable_functions();
+        functions.sort_by(|a, b| a.name.cmp(&b.name));
+        let disambiguated = self.disambiguate_functions(&functions);
+
+        for (func, alias) in disambiguated {
+            let (method, try_method, result_classes) = self.generate_function_methods(func, &alias);
+            contract_class.add_method(method);
+            contract_class.add_method(try_method);
+            classes.extend(result_classes);
+        }
+
+        classes.push(contract_class);
+        classes
+    }
+
+    /// Generate call type classes.
+    fn generate_call_types(&self) -> Vec<Class> {
+        let mut classes = Vec::new();
+        let mut functions = self.get_call_functions();
+        functions.sort_by(|a, b| a.name.cmp(&b.name));
+        let disambiguated = self.disambiguate_call_functions(&functions);
+
+        for (func, alias) in disambiguated {
+            let cap_alias = capitalize(&alias);
+            let call_class_name = format!("{}Call", cap_alias);
+            let mut tuple_classes = Vec::new();
+
+            // Generate inputs class
+            let inputs_class_name = [&call_class_name, "__Inputs"].concat();
+            let mut inputs_class = ts::klass(&inputs_class_name).exported();
+            inputs_class.add_member(ClassMember::new("_call", &call_class_name));
+            inputs_class.add_method(Method::new(
+                "constructor",
+                vec![TsParam::new("call", ts::NamedType::new(&call_class_name))],
+                None,
+                "this._call = call",
+            ));
+
+            let inputs = self.disambiguate_params(&func.inputs, "value");
+            for (index, (param, param_name)) in inputs.iter().enumerate() {
+                let getter = self.generate_input_output_getter(
+                    param,
+                    param_name,
+                    index,
+                    &call_class_name,
+                    "call",
+                    "inputValues",
+                    &mut tuple_classes,
+                );
+                inputs_class.add_method(getter);
+            }
+
+            // Generate outputs class
+            let outputs_class_name = [&call_class_name, "__Outputs"].concat();
+            let mut outputs_class = ts::klass(&outputs_class_name).exported();
+            outputs_class.add_member(ClassMember::new("_call", &call_class_name));
+            outputs_class.add_method(Method::new(
+                "constructor",
+                vec![TsParam::new("call", ts::NamedType::new(&call_class_name))],
+                None,
+                "this._call = call",
+            ));
+
+            let outputs = self.disambiguate_params(&func.outputs, "value");
+            for (index, (param, param_name)) in outputs.iter().enumerate() {
+                let getter = self.generate_input_output_getter(
+                    param,
+                    param_name,
+                    index,
+                    &call_class_name,
+                    "call",
+                    "outputValues",
+                    &mut tuple_classes,
+                );
+                outputs_class.add_method(getter);
+            }
+
+            // Generate call class
+            let mut call_class = ts::klass(&call_class_name)
+                .exported()
+                .extends("ethereum.Call");
+            call_class.add_method(Method::new(
+                "get inputs",
+                vec![],
+                Some(ts::NamedType::new(&inputs_class_name).into()),
+                format!("return new {}(this)", inputs_class_name),
+            ));
+            call_class.add_method(Method::new(
+                "get outputs",
+                vec![],
+                Some(ts::NamedType::new(&outputs_class_name).into()),
+                format!("return new {}(this)", outputs_class_name),
+            ));
+
+            classes.push(call_class);
+            classes.push(inputs_class);
+            classes.push(outputs_class);
+            classes.extend(tuple_classes);
+        }
+
+        classes
+    }
+
+    /// Generate a getter method for an event parameter.
+    fn generate_event_param(
+        &self,
+        param: &EventParam,
+        name: &str,
+        index: usize,
+        event_class_name: &str,
+        tuple_classes: &mut Vec<Class>,
+    ) -> Method {
+        let param_type = resolve_event_param_type(param);
+
+        // Handle indexed params - strings, bytes and arrays are hashed to bytes32
+        let value_type = if param.indexed {
+            indexed_input_type(&param_type)
+        } else {
+            param_type.clone()
+        };
+
+        if contains_tuple_type(&value_type) {
+            self.generate_tuple_getter_for_event_param(
+                param,
+                &param_type,
+                name,
+                index,
+                event_class_name,
+                "event",
+                "parameters",
+                tuple_classes,
+            )
+        } else {
+            let asc_type = asc_type_for_ethereum(&value_type);
+            let access = format!("this._event.parameters[{}].value", index);
+            let conversion = ethereum_to_asc(&access, &value_type, None);
+            Method::new(
+                format!("get {}", name),
+                vec![],
+                Some(ts::TypeExpr::Raw(asc_type)),
+                format!("return {}", conversion),
+            )
+        }
+    }
+
+    /// Generate a getter for call inputs/outputs.
+    #[allow(clippy::too_many_arguments)]
+    fn generate_input_output_getter(
+        &self,
+        param: &Param,
+        name: &str,
+        index: usize,
+        parent_class: &str,
+        parent_type: &str,
+        parent_field: &str,
+        tuple_classes: &mut Vec<Class>,
+    ) -> Method {
+        let param_type = resolve_param_type(param);
+        if contains_tuple_type(&param_type) {
+            self.generate_tuple_getter(
+                param,
+                &param_type,
+                name,
+                index,
+                parent_class,
+                parent_type,
+                parent_field,
+                tuple_classes,
+            )
+        } else {
+            let asc_type = asc_type_for_ethereum(&param_type);
+            let access = format!("this._{}.{}[{}].value", parent_type, parent_field, index);
+            let conversion = ethereum_to_asc(&access, &param_type, None);
+            Method::new(
+                format!("get {}", name),
+                vec![],
+                Some(ts::TypeExpr::Raw(asc_type)),
+                format!("return {}", conversion),
+            )
+        }
+    }
+
+    /// Generate a tuple getter and its associated classes (for `Param`).
+    #[allow(clippy::too_many_arguments)]
+    fn generate_tuple_getter(
+        &self,
+        param: &Param,
+        param_type: &DynSolType,
+        name: &str,
+        index: usize,
+        parent_class: &str,
+        parent_type: &str,
+        parent_field: &str,
+        tuple_classes: &mut Vec<Class>,
+    ) -> Method {
+        let cap_name = capitalize(name);
+        let tuple_identifier = format!("{}{}", parent_class, cap_name);
+        let tuple_class_name = if parent_field == "outputValues" {
+            format!("{}OutputStruct", tuple_identifier)
+        } else {
+            format!("{}Struct", tuple_identifier)
+        };
+
+        let is_tuple = matches!(param_type, DynSolType::Tuple(_));
+        let access_code = if parent_type == "tuple" {
+            format!("this[{}]", index)
+        } else {
+            format!("this._{}.{}[{}].value", parent_type, parent_field, index)
+        };
+
+        let return_value = ethereum_to_asc(&access_code, param_type, Some(&tuple_class_name));
+
+        let return_type = if is_tuple_matrix_type(param_type) {
+            format!("Array<Array<{}>>", tuple_class_name)
+        } else if is_tuple_array_type(param_type) {
+            format!("Array<{}>", tuple_class_name)
+        } else {
+            tuple_class_name.clone()
+        };
+
+        let body = if is_tuple {
+            format!("return changetype<{}>({})", tuple_class_name, return_value)
+        } else {
+            format!("return {}", return_value)
+        };
+
+        // Generate tuple class from Param's components
+        let components = get_tuple_param_components(param);
+        if !components.is_empty() {
+            let mut tuple_class = ts::klass(&tuple_class_name)
+                .exported()
+                .extends("ethereum.Tuple");
+
+            let component_params = disambiguate_tuple_components(components);
+            for (idx, (component, component_name)) in component_params.iter().enumerate() {
+                let component_getter = self.generate_tuple_component_getter(
+                    component,
+                    component_name,
+                    idx,
+                    &tuple_identifier,
+                    tuple_classes,
+                );
+                tuple_class.add_method(component_getter);
+            }
+
+            tuple_classes.push(tuple_class);
+        }
+
+        Method::new(
+            format!("get {}", name),
+            vec![],
+            Some(ts::TypeExpr::Raw(return_type)),
+            body,
+        )
+    }
+
+    /// Generate a tuple getter and its associated classes (for `EventParam`).
+    #[allow(clippy::too_many_arguments)]
+    fn generate_tuple_getter_for_event_param(
+        &self,
+        param: &EventParam,
+        param_type: &DynSolType,
+        name: &str,
+        index: usize,
+        parent_class: &str,
+        parent_type: &str,
+        parent_field: &str,
+        tuple_classes: &mut Vec<Class>,
+    ) -> Method {
+        let cap_name = capitalize(name);
+        let tuple_identifier = format!("{}{}", parent_class, cap_name);
+        let tuple_class_name = if parent_field == "outputValues" {
+            format!("{}OutputStruct", tuple_identifier)
+        } else {
+            format!("{}Struct", tuple_identifier)
+        };
+
+        let is_tuple = matches!(param_type, DynSolType::Tuple(_));
+        let access_code = if parent_type == "tuple" {
+            format!("this[{}]", index)
+        } else {
+            format!("this._{}.{}[{}].value", parent_type, parent_field, index)
+        };
+
+        let return_value = ethereum_to_asc(&access_code, param_type, Some(&tuple_class_name));
+
+        let return_type = if is_tuple_matrix_type(param_type) {
+            format!("Array<Array<{}>>", tuple_class_name)
+        } else if is_tuple_array_type(param_type) {
+            format!("Array<{}>", tuple_class_name)
+        } else {
+            tuple_class_name.clone()
+        };
+
+        let body = if is_tuple {
+            format!("return changetype<{}>({})", tuple_class_name, return_value)
+        } else {
+            format!("return {}", return_value)
+        };
+
+        // Generate tuple class from EventParam's components
+        // EventParam.components is Vec<Param>, same as Param.components
+        let components = &param.components;
+        if !components.is_empty() {
+            let mut tuple_class = ts::klass(&tuple_class_name)
+                .exported()
+                .extends("ethereum.Tuple");
+
+            let component_params = disambiguate_tuple_components(components);
+            for (idx, (component, component_name)) in component_params.iter().enumerate() {
+                let component_getter = self.generate_tuple_component_getter(
+                    component,
+                    component_name,
+                    idx,
+                    &tuple_identifier,
+                    tuple_classes,
+                );
+                tuple_class.add_method(component_getter);
+            }
+
+            tuple_classes.push(tuple_class);
+        }
+
+        Method::new(
+            format!("get {}", name),
+            vec![],
+            Some(ts::TypeExpr::Raw(return_type)),
+            body,
+        )
+    }
+
+    /// Generate a getter for a tuple component.
+    fn generate_tuple_component_getter(
+        &self,
+        param: &Param,
+        name: &str,
+        index: usize,
+        parent_class: &str,
+        tuple_classes: &mut Vec<Class>,
+    ) -> Method {
+        let param_type = resolve_param_type(param);
+        if contains_tuple_type(&param_type) {
+            self.generate_tuple_getter(
+                param,
+                &param_type,
+                name,
+                index,
+                parent_class,
+                "tuple",
+                "",
+                tuple_classes,
+            )
+        } else {
+            let asc_type = asc_type_for_ethereum(&param_type);
+            let access = format!("this[{}]", index);
+            let conversion = ethereum_to_asc(&access, &param_type, None);
+            Method::new(
+                format!("get {}", name),
+                vec![],
+                Some(ts::TypeExpr::Raw(asc_type)),
+                format!("return {}", conversion),
+            )
+        }
+    }
+
+    /// Generate methods for a callable function.
+    fn generate_function_methods(
+        &self,
+        func: &Function,
+        alias: &str,
+    ) -> (Method, Method, Vec<Class>) {
+        let mut result_classes = Vec::new();
+        let fn_signature = func.signature_compat();
+        let contract_name = &self.name;
+        let tuple_result_parent_type = [contract_name, "__", alias, "Result"].concat();
+        let tuple_input_parent_type = [contract_name, "__", alias, "Input"].concat();
+
+        // Disambiguate outputs
+        let outputs = self.disambiguate_params(&func.outputs, "value");
+
+        // Determine return type
+        let (return_type, simple_return_type) = if outputs.len() > 1 {
+            // Multiple outputs - create a result struct
+            let result_class = self.generate_result_class(
+                &outputs,
+                &tuple_result_parent_type,
+                &mut result_classes,
+            );
+            result_classes.push(result_class.clone());
+            (result_class.name.clone(), false)
+        } else if !outputs.is_empty() {
+            let (param, _) = &outputs[0];
+            let param_type = resolve_param_type(param);
+            if contains_tuple_type(&param_type) {
+                let tuple_name = self.generate_tuple_return_type(
+                    param,
+                    &param_type,
+                    0,
+                    &tuple_result_parent_type,
+                    &mut result_classes,
+                );
+                (tuple_name, true)
+            } else {
+                (asc_type_for_ethereum(&param_type), true)
+            }
+        } else {
+            ("void".to_string(), true)
+        };
+
+        // Disambiguate inputs
+        let inputs = self.disambiguate_params(&func.inputs, "param");
+
+        // Generate tuple types for inputs
+        for (index, (param, _)) in inputs.iter().enumerate() {
+            let param_type = resolve_param_type(param);
+            if contains_tuple_type(&param_type) {
+                self.generate_tuple_class_for_input(
+                    param,
+                    index,
+                    &tuple_input_parent_type,
+                    &mut result_classes,
+                );
+            }
+        }
+
+        // Build params
+        let params: Vec<TsParam> = inputs
+            .iter()
+            .enumerate()
+            .map(|(index, (param, name))| {
+                let p_type = resolve_param_type(param);
+                let param_type_str =
+                    get_param_type_for_input(&p_type, index, &tuple_input_parent_type);
+                TsParam::new(name.clone(), ts::TypeExpr::Raw(param_type_str))
+            })
+            .collect();
+
+        // Build call arguments
+        let call_args: Vec<String> = inputs
+            .iter()
+            .map(|(param, name)| {
+                let p_type = resolve_param_type(param);
+                ethereum_from_asc(name, &p_type)
+            })
+            .collect();
+
+        let func_name = &func.name;
+        let call_args_str = call_args.join(", ");
+        let super_inputs = format!("'{}', '{}', [{}]", func_name, fn_signature, call_args_str);
+
+        // Generate method body
+        let method_body = self.generate_call_body(
+            &outputs,
+            &return_type,
+            simple_return_type,
+            &super_inputs,
+            &tuple_result_parent_type,
+            false,
+        );
+
+        let try_method_body = self.generate_call_body(
+            &outputs,
+            &return_type,
+            simple_return_type,
+            &super_inputs,
+            &tuple_result_parent_type,
+            true,
+        );
+
+        let method = Method::new(
+            alias.to_string(),
+            params.clone(),
+            Some(ts::TypeExpr::Raw(return_type.clone())),
+            method_body,
+        );
+
+        let try_method = Method::new(
+            format!("try_{}", alias),
+            params,
+            Some(ts::TypeExpr::Raw(format!(
+                "ethereum.CallResult<{}>",
+                return_type
+            ))),
+            try_method_body,
+        );
+
+        (method, try_method, result_classes)
+    }
+
+    /// Generate call method body.
+    fn generate_call_body(
+        &self,
+        outputs: &[(&Param, String)],
+        return_type: &str,
+        simple_return_type: bool,
+        super_inputs: &str,
+        tuple_result_parent_type: &str,
+        is_try: bool,
+    ) -> String {
+        let nl = "\n";
+        let (call_stmt, result_var) = if is_try {
+            let mut lines = Vec::new();
+            lines.push(format!("let result = super.tryCall({})", super_inputs));
+            lines.push("    if (result.reverted) {".to_string());
+            lines.push("      return new ethereum.CallResult()".to_string());
+            lines.push("    }".to_string());
+            lines.push("    let value = result.value".to_string());
+            (lines.join(nl), "value")
+        } else {
+            (
+                format!("let result = super.call({})", super_inputs),
+                "result",
+            )
+        };
+
+        let return_val = if simple_return_type {
+            if outputs.is_empty() {
+                String::new()
+            } else {
+                let (param, _) = &outputs[0];
+                let p_type = resolve_param_type(param);
+                let tuple_name = if is_tuple_array_type(&p_type) {
+                    Some(tuple_type_name(0, tuple_result_parent_type))
+                } else {
+                    None
+                };
+                let val = ethereum_to_asc(
+                    &format!("{}[0]", result_var),
+                    &p_type,
+                    tuple_name.as_deref(),
+                );
+                if matches!(p_type, DynSolType::Tuple(_)) {
+                    format!("changetype<{}>({})", return_type, val)
+                } else {
+                    val
+                }
+            }
+        } else {
+            let conversions: Vec<String> = outputs
+                .iter()
+                .enumerate()
+                .map(|(index, (param, _))| {
+                    let p_type = resolve_param_type(param);
+                    let tuple_name = if is_tuple_array_type(&p_type) {
+                        Some(tuple_type_name(index, tuple_result_parent_type))
+                    } else {
+                        None
+                    };
+                    let val = ethereum_to_asc(
+                        &format!("{}[{}]", result_var, index),
+                        &p_type,
+                        tuple_name.as_deref(),
+                    );
+                    if matches!(p_type, DynSolType::Tuple(_)) {
+                        let tn = tuple_type_name(index, tuple_result_parent_type);
+                        format!("changetype<{}>({})", tn, val)
+                    } else {
+                        val
+                    }
+                })
+                .collect();
+            let conv_str = conversions.join(", ");
+            format!("new {}({})", return_type, conv_str)
+        };
+
+        if is_try {
+            [
+                &call_stmt,
+                nl,
+                "    return ethereum.CallResult.fromValue(",
+                &return_val,
+                ")",
+            ]
+            .concat()
+        } else if outputs.is_empty() {
+            call_stmt
+        } else {
+            [&call_stmt, nl, nl, "    return (", &return_val, ")"].concat()
+        }
+    }
+
+    /// Generate a result class for multiple outputs.
+    fn generate_result_class(
+        &self,
+        outputs: &[(&Param, String)],
+        tuple_result_parent_type: &str,
+        result_classes: &mut Vec<Class>,
+    ) -> Class {
+        let class_name = tuple_result_parent_type.to_string();
+        let mut klass = ts::klass(&class_name).exported();
+
+        // Add constructor
+        let constructor_params: Vec<TsParam> = outputs
+            .iter()
+            .enumerate()
+            .map(|(index, (param, _))| {
+                let p_type = resolve_param_type(param);
+                let param_type_str =
+                    get_param_type_for_input(&p_type, index, tuple_result_parent_type);
+                TsParam::new(format!("value{}", index), ts::TypeExpr::Raw(param_type_str))
+            })
+            .collect();
+
+        let nl = "\n";
+        let constructor_body: Vec<String> = outputs
+            .iter()
+            .enumerate()
+            .map(|(index, _)| format!("this.value{} = value{}", index, index))
+            .collect();
+
+        klass.add_method(Method::new(
+            "constructor",
+            constructor_params,
+            None,
+            constructor_body.join(&format!("{}    ", nl)),
+        ));
+
+        // Add toMap method
+        let map_entries: Vec<String> = outputs
+            .iter()
+            .enumerate()
+            .map(|(index, (param, _))| {
+                let p_type = resolve_param_type(param);
+                let this_val = format!("this.value{}", index);
+                let from_asc = ethereum_from_asc(&this_val, &p_type);
+                format!("map.set('value{}', {})", index, from_asc)
+            })
+            .collect();
+
+        let map_body = [
+            "let map = new TypedMap<string,ethereum.Value>()",
+            nl,
+            "    ",
+            &map_entries.join(&format!("{}    ", nl)),
+            nl,
+            "    return map",
+        ]
+        .concat();
+
+        klass.add_method(Method::new(
+            "toMap",
+            vec![],
+            Some(ts::TypeExpr::Raw(
+                "TypedMap<string,ethereum.Value>".to_string(),
+            )),
+            map_body,
+        ));
+
+        // Add members
+        for (index, (param, _)) in outputs.iter().enumerate() {
+            let p_type = resolve_param_type(param);
+            let param_type_str = get_param_type_for_input(&p_type, index, tuple_result_parent_type);
+            klass.add_member(ClassMember::new(format!("value{}", index), param_type_str));
+        }
+
+        // Add getters for outputs
+        for (index, (param, _)) in outputs.iter().enumerate() {
+            let getter_name = if param.name.trim().is_empty() {
+                format!("getValue{}", index)
+            } else {
+                let cap = capitalize(&param.name);
+                format!("get{}", cap)
+            };
+            let p_type = resolve_param_type(param);
+            let param_type_str = get_param_type_for_input(&p_type, index, tuple_result_parent_type);
+            klass.add_method(Method::new(
+                getter_name,
+                vec![],
+                Some(ts::TypeExpr::Raw(param_type_str)),
+                format!("return this.value{}", index),
+            ));
+        }
+
+        // Generate tuple classes for outputs
+        for (index, (param, _)) in outputs.iter().enumerate() {
+            let p_type = resolve_param_type(param);
+            if contains_tuple_type(&p_type) {
+                self.generate_tuple_class_for_input(
+                    param,
+                    index,
+                    tuple_result_parent_type,
+                    result_classes,
+                );
+            }
+        }
+
+        klass
+    }
+
+    /// Generate tuple return type name and classes.
+    fn generate_tuple_return_type(
+        &self,
+        param: &Param,
+        param_type: &DynSolType,
+        index: usize,
+        parent_type: &str,
+        result_classes: &mut Vec<Class>,
+    ) -> String {
+        self.generate_tuple_class_for_input(param, index, parent_type, result_classes);
+        let tn = tuple_type_name(index, parent_type);
+        if is_tuple_array_type(param_type) {
+            format!("Array<{}>", tn)
+        } else if is_tuple_matrix_type(param_type) {
+            format!("Array<Array<{}>>", tn)
+        } else {
+            tn
+        }
+    }
+
+    /// Generate tuple class for an input/output.
+    fn generate_tuple_class_for_input(
+        &self,
+        param: &Param,
+        index: usize,
+        parent_type: &str,
+        result_classes: &mut Vec<Class>,
+    ) {
+        let tuple_class_name = tuple_type_name(index, parent_type);
+        let mut tuple_class = ts::klass(&tuple_class_name)
+            .exported()
+            .extends("ethereum.Tuple");
+
+        let components = get_tuple_param_components(param);
+        if !components.is_empty() {
+            let component_params = disambiguate_tuple_components(components);
+            for (idx, (component, component_name)) in component_params.iter().enumerate() {
+                let component_type = resolve_param_type(component);
+                let getter = if contains_tuple_type(&component_type) {
+                    // Recursively generate tuple classes
+                    let cap = capitalize(&format!("{}", index));
+                    let nested_parent = format!("{}Value{}", parent_type, cap);
+                    self.generate_tuple_class_for_input(
+                        component,
+                        idx,
+                        &nested_parent,
+                        result_classes,
+                    );
+                    let nested_tuple_name = tuple_type_name(idx, &nested_parent);
+                    let access = format!("this[{}]", idx);
+                    let conversion =
+                        ethereum_to_asc(&access, &component_type, Some(&nested_tuple_name));
+                    let return_type = if is_tuple_array_type(&component_type) {
+                        format!("Array<{}>", nested_tuple_name)
+                    } else {
+                        nested_tuple_name.clone()
+                    };
+                    let body = if matches!(component_type, DynSolType::Tuple(_)) {
+                        format!("return changetype<{}>({})", nested_tuple_name, conversion)
+                    } else {
+                        format!("return {}", conversion)
+                    };
+                    Method::new(
+                        format!("get {}", component_name),
+                        vec![],
+                        Some(ts::TypeExpr::Raw(return_type)),
+                        body,
+                    )
+                } else {
+                    let asc_type = asc_type_for_ethereum(&component_type);
+                    let access = format!("this[{}]", idx);
+                    let conversion = ethereum_to_asc(&access, &component_type, None);
+                    Method::new(
+                        format!("get {}", component_name),
+                        vec![],
+                        Some(ts::TypeExpr::Raw(asc_type)),
+                        format!("return {}", conversion),
+                    )
+                };
+                tuple_class.add_method(getter);
+            }
+        }
+
+        result_classes.push(tuple_class);
+    }
+
+    /// Get callable functions (view, pure, nonpayable, constant with outputs).
+    fn get_callable_functions(&self) -> Vec<&Function> {
+        self.contract
+            .functions()
+            .filter(|f| {
+                !f.outputs.is_empty()
+                    && matches!(
+                        f.state_mutability,
+                        StateMutability::View | StateMutability::Pure | StateMutability::NonPayable
+                    )
+            })
+            .collect()
+    }
+
+    /// Get functions that can be used as calls (non-view, non-pure functions).
+    fn get_call_functions(&self) -> Vec<&Function> {
+        self.contract
+            .functions()
+            .filter(|f| {
+                matches!(
+                    f.state_mutability,
+                    StateMutability::NonPayable | StateMutability::Payable
+                )
+            })
+            .collect()
+    }
+
+    /// Disambiguate events with duplicate names.
+    fn disambiguate_events(&self) -> Vec<(&Event, String)> {
+        let mut result = Vec::new();
+        let mut collision_counter: HashMap<String, u32> = HashMap::new();
+
+        for event in self.contract.events() {
+            let name = handle_reserved_word(&event.name);
+            let counter = collision_counter.entry(name.clone()).or_insert(0);
+            let alias = if *counter == 0 {
+                name.clone()
+            } else {
+                format!("{}{}", name, counter)
+            };
+            *counter += 1;
+            result.push((event, alias));
+        }
+
+        result
+    }
+
+    /// Disambiguate functions.
+    fn disambiguate_functions<'a>(
+        &self,
+        functions: &[&'a Function],
+    ) -> Vec<(&'a Function, String)> {
+        let mut result = Vec::new();
+        let mut collision_counter: HashMap<String, u32> = HashMap::new();
+
+        for func in functions {
+            let name = handle_reserved_word(&func.name);
+            let counter = collision_counter.entry(name.clone()).or_insert(0);
+            let alias = if *counter == 0 {
+                name.clone()
+            } else {
+                format!("{}{}", name, counter)
+            };
+            *counter += 1;
+            result.push((*func, alias));
+        }
+
+        result
+    }
+
+    /// Disambiguate call functions.
+    fn disambiguate_call_functions<'a>(
+        &self,
+        functions: &[&'a Function],
+    ) -> Vec<(&'a Function, String)> {
+        let mut result = Vec::new();
+        let mut collision_counter: HashMap<String, u32> = HashMap::new();
+
+        for func in functions {
+            let name = if func.name.is_empty() {
+                "default".to_string()
+            } else {
+                handle_reserved_word(&func.name)
+            };
+            let counter = collision_counter.entry(name.clone()).or_insert(0);
+            let alias = if *counter == 0 {
+                name.clone()
+            } else {
+                format!("{}{}", name, counter)
+            };
+            *counter += 1;
+            result.push((*func, alias));
+        }
+
+        result
+    }
+
+    /// Disambiguate event params.
+    fn disambiguate_event_params<'a>(
+        &self,
+        params: &'a [EventParam],
+        default_prefix: &str,
+    ) -> Vec<(&'a EventParam, String)> {
+        let mut result = Vec::new();
+        let mut collision_counter: HashMap<String, u32> = HashMap::new();
+
+        for (index, param) in params.iter().enumerate() {
+            let name = if param.name.is_empty() {
+                format!("{}{}", default_prefix, index)
+            } else {
+                handle_reserved_word(&param.name)
+            };
+            let counter = collision_counter.entry(name.clone()).or_insert(0);
+            let disambiguated = if *counter == 0 {
+                name.clone()
+            } else {
+                format!("{}{}", name, counter)
+            };
+            *counter += 1;
+            result.push((param, disambiguated));
+        }
+
+        result
+    }
+
+    /// Disambiguate function params.
+    fn disambiguate_params<'a>(
+        &self,
+        params: &'a [Param],
+        default_prefix: &str,
+    ) -> Vec<(&'a Param, String)> {
+        let mut result = Vec::new();
+        let mut collision_counter: HashMap<String, u32> = HashMap::new();
+
+        for (index, param) in params.iter().enumerate() {
+            let name = if param.name.is_empty() {
+                format!("{}{}", default_prefix, index)
+            } else {
+                handle_reserved_word(&param.name)
+            };
+            let counter = collision_counter.entry(name.clone()).or_insert(0);
+            let disambiguated = if *counter == 0 {
+                name.clone()
+            } else {
+                format!("{}{}", name, counter)
+            };
+            *counter += 1;
+            result.push((param, disambiguated));
+        }
+
+        result
+    }
+}
+
+/// Get tuple type name for a param.
+fn tuple_type_name(index: usize, parent_type: &str) -> String {
+    format!("{}Value{}Struct", parent_type, index)
+}
+
+/// Get the param type string for an input, handling tuples.
+fn get_param_type_for_input(param_type: &DynSolType, index: usize, parent_type: &str) -> String {
+    if matches!(param_type, DynSolType::Tuple(_)) {
+        tuple_type_name(index, parent_type)
+    } else if is_tuple_matrix_type(param_type) {
+        let tn = tuple_type_name(index, parent_type);
+        format!("Array<Array<{}>>", tn)
+    } else if is_tuple_array_type(param_type) {
+        let tn = tuple_type_name(index, parent_type);
+        format!("Array<{}>", tn)
+    } else {
+        asc_type_for_ethereum(param_type)
+    }
+}
+
+/// Get the tuple components from a `Param`, following through arrays.
+/// Returns the `components` from the innermost tuple `Param`.
+fn get_tuple_param_components(param: &Param) -> &[Param] {
+    // If this param has components directly (tuple type), return them
+    if !param.components.is_empty() {
+        return &param.components;
+    }
+    // For array-of-tuple types, the components are on the param itself
+    // (alloy stores them on the outer param for tuple[] types)
+    &[]
+}
+
+/// Disambiguate tuple components, reading names directly from `Param.name`.
+fn disambiguate_tuple_components(components: &[Param]) -> Vec<(&Param, String)> {
+    components
+        .iter()
+        .enumerate()
+        .map(|(index, component)| {
+            let name = if component.name.is_empty() {
+                format!("value{}", index)
+            } else {
+                component.name.clone()
+            };
+            (component, name)
+        })
+        .collect()
+}
+
+/// Get AssemblyScript type for an Ethereum type.
+fn asc_type_for_ethereum(param_type: &DynSolType) -> String {
+    match param_type {
+        DynSolType::Address => "Address".to_string(),
+        DynSolType::Bool => "boolean".to_string(),
+        DynSolType::Bytes => "Bytes".to_string(),
+        DynSolType::FixedBytes(_) => "Bytes".to_string(),
+        DynSolType::Int(bits) => {
+            if *bits <= 32 {
+                "i32".to_string()
+            } else {
+                "BigInt".to_string()
+            }
+        }
+        DynSolType::Uint(bits) => {
+            if *bits <= 24 {
+                "i32".to_string()
+            } else {
+                "BigInt".to_string()
+            }
+        }
+        DynSolType::String => "string".to_string(),
+        DynSolType::Array(inner) => {
+            let inner_type = asc_type_for_ethereum(inner);
+            format!("Array<{}>", inner_type)
+        }
+        DynSolType::FixedArray(inner, _) => {
+            let inner_type = asc_type_for_ethereum(inner);
+            format!("Array<{}>", inner_type)
+        }
+        DynSolType::Tuple(_) => "ethereum.Tuple".to_string(),
+        _ => "ethereum.Tuple".to_string(), // Function and other future variants
+    }
+}
+
+/// Convert ethereum value to AssemblyScript.
+fn ethereum_to_asc(code: &str, param_type: &DynSolType, tuple_type: Option<&str>) -> String {
+    match param_type {
+        DynSolType::Address => format!("{}.toAddress()", code),
+        DynSolType::Bool => format!("{}.toBoolean()", code),
+        DynSolType::Bytes | DynSolType::FixedBytes(_) => format!("{}.toBytes()", code),
+        DynSolType::Int(bits) => {
+            if *bits <= 32 {
+                format!("{}.toI32()", code)
+            } else {
+                format!("{}.toBigInt()", code)
+            }
+        }
+        DynSolType::Uint(bits) => {
+            if *bits <= 24 {
+                format!("{}.toI32()", code)
+            } else {
+                format!("{}.toBigInt()", code)
+            }
+        }
+        DynSolType::String => format!("{}.toString()", code),
+        DynSolType::Array(inner) | DynSolType::FixedArray(inner, _) => match inner.as_ref() {
+            DynSolType::Address => format!("{}.toAddressArray()", code),
+            DynSolType::Bool => format!("{}.toBooleanArray()", code),
+            DynSolType::Bytes | DynSolType::FixedBytes(_) => {
+                format!("{}.toBytesArray()", code)
+            }
+            DynSolType::Int(bits) => {
+                if *bits <= 32 {
+                    format!("{}.toI32Array()", code)
+                } else {
+                    format!("{}.toBigIntArray()", code)
+                }
+            }
+            DynSolType::Uint(bits) => {
+                if *bits <= 24 {
+                    format!("{}.toI32Array()", code)
+                } else {
+                    format!("{}.toBigIntArray()", code)
+                }
+            }
+            DynSolType::String => format!("{}.toStringArray()", code),
+            DynSolType::Tuple(_) => {
+                if let Some(tuple_name) = tuple_type {
+                    format!("{}.toTupleArray<{}>()", code, tuple_name)
+                } else {
+                    format!("{}.toTupleArray<ethereum.Tuple>()", code)
+                }
+            }
+            DynSolType::Array(inner2) | DynSolType::FixedArray(inner2, _) => {
+                ethereum_to_asc_matrix(code, inner2.as_ref(), tuple_type)
+            }
+            _ => format!("{}.toString()", code), // fallback for Function etc.
+        },
+        DynSolType::Tuple(_) => format!("{}.toTuple()", code),
+        _ => format!("{}.toTuple()", code), // fallback for Function etc.
+    }
+}
+
+/// Convert matrix type to AssemblyScript.
+fn ethereum_to_asc_matrix(code: &str, inner_type: &DynSolType, tuple_type: Option<&str>) -> String {
+    match inner_type {
+        DynSolType::Address => format!("{}.toAddressMatrix()", code),
+        DynSolType::Bool => format!("{}.toBooleanMatrix()", code),
+        DynSolType::Bytes | DynSolType::FixedBytes(_) => format!("{}.toBytesMatrix()", code),
+        DynSolType::Int(bits) => {
+            if *bits <= 32 {
+                format!("{}.toI32Matrix()", code)
+            } else {
+                format!("{}.toBigIntMatrix()", code)
+            }
+        }
+        DynSolType::Uint(bits) => {
+            if *bits <= 24 {
+                format!("{}.toI32Matrix()", code)
+            } else {
+                format!("{}.toBigIntMatrix()", code)
+            }
+        }
+        DynSolType::String => format!("{}.toStringMatrix()", code),
+        DynSolType::Tuple(_) => {
+            if let Some(tuple_name) = tuple_type {
+                format!("{}.toTupleMatrix<{}>()", code, tuple_name)
+            } else {
+                format!("{}.toTupleMatrix<ethereum.Tuple>()", code)
+            }
+        }
+        _ => format!("{}.toStringMatrix()", code), // fallback
+    }
+}
+
+/// Convert AssemblyScript value to ethereum value.
+fn ethereum_from_asc(code: &str, param_type: &DynSolType) -> String {
+    match param_type {
+        DynSolType::Address => format!("ethereum.Value.fromAddress({})", code),
+        DynSolType::Bool => format!("ethereum.Value.fromBoolean({})", code),
+        DynSolType::Bytes => format!("ethereum.Value.fromBytes({})", code),
+        DynSolType::FixedBytes(_) => format!("ethereum.Value.fromFixedBytes({})", code),
+        DynSolType::Int(bits) => {
+            if *bits <= 32 {
+                format!("ethereum.Value.fromI32({})", code)
+            } else {
+                format!("ethereum.Value.fromSignedBigInt({})", code)
+            }
+        }
+        DynSolType::Uint(bits) => {
+            if *bits <= 24 {
+                format!(
+                    "ethereum.Value.fromUnsignedBigInt(BigInt.fromI32({}))",
+                    code
+                )
+            } else {
+                format!("ethereum.Value.fromUnsignedBigInt({})", code)
+            }
+        }
+        DynSolType::String => format!("ethereum.Value.fromString({})", code),
+        DynSolType::Array(inner) | DynSolType::FixedArray(inner, _) => {
+            ethereum_from_asc_array(code, inner.as_ref())
+        }
+        DynSolType::Tuple(_) => format!("ethereum.Value.fromTuple({})", code),
+        _ => format!("ethereum.Value.fromTuple({})", code), // fallback
+    }
+}
+
+/// Convert array to ethereum value.
+fn ethereum_from_asc_array(code: &str, inner_type: &DynSolType) -> String {
+    match inner_type {
+        DynSolType::Address => format!("ethereum.Value.fromAddressArray({})", code),
+        DynSolType::Bool => format!("ethereum.Value.fromBooleanArray({})", code),
+        DynSolType::Bytes => format!("ethereum.Value.fromBytesArray({})", code),
+        DynSolType::FixedBytes(_) => format!("ethereum.Value.fromFixedBytesArray({})", code),
+        DynSolType::Int(bits) => {
+            if *bits <= 32 {
+                format!("ethereum.Value.fromI32Array({})", code)
+            } else {
+                format!("ethereum.Value.fromSignedBigIntArray({})", code)
+            }
+        }
+        DynSolType::Uint(bits) => {
+            if *bits <= 24 {
+                format!("ethereum.Value.fromI32Array({})", code)
+            } else {
+                format!("ethereum.Value.fromUnsignedBigIntArray({})", code)
+            }
+        }
+        DynSolType::String => format!("ethereum.Value.fromStringArray({})", code),
+        DynSolType::Tuple(_) => format!("ethereum.Value.fromTupleArray({})", code),
+        DynSolType::Array(inner2) | DynSolType::FixedArray(inner2, _) => {
+            ethereum_from_asc_matrix(code, inner2.as_ref())
+        }
+        _ => format!("ethereum.Value.fromStringArray({})", code), // fallback
+    }
+}
+
+/// Convert matrix to ethereum value.
+fn ethereum_from_asc_matrix(code: &str, inner_type: &DynSolType) -> String {
+    match inner_type {
+        DynSolType::Address => format!("ethereum.Value.fromAddressMatrix({})", code),
+        DynSolType::Bool => format!("ethereum.Value.fromBooleanMatrix({})", code),
+        DynSolType::Bytes => format!("ethereum.Value.fromBytesMatrix({})", code),
+        DynSolType::FixedBytes(_) => format!("ethereum.Value.fromFixedBytesMatrix({})", code),
+        DynSolType::Int(bits) => {
+            if *bits <= 32 {
+                format!("ethereum.Value.fromI32Matrix({})", code)
+            } else {
+                format!("ethereum.Value.fromSignedBigIntMatrix({})", code)
+            }
+        }
+        DynSolType::Uint(bits) => {
+            if *bits <= 24 {
+                format!("ethereum.Value.fromI32Matrix({})", code)
+            } else {
+                format!("ethereum.Value.fromUnsignedBigIntMatrix({})", code)
+            }
+        }
+        DynSolType::String => format!("ethereum.Value.fromStringMatrix({})", code),
+        DynSolType::Tuple(_) => format!("ethereum.Value.fromTupleMatrix({})", code),
+        _ => format!("ethereum.Value.fromStringMatrix({})", code), // fallback
+    }
+}
+
+/// Check if param type contains a tuple.
+fn contains_tuple_type(param_type: &DynSolType) -> bool {
+    match param_type {
+        DynSolType::Tuple(_) => true,
+        DynSolType::Array(inner) | DynSolType::FixedArray(inner, _) => contains_tuple_type(inner),
+        _ => false,
+    }
+}
+
+/// Check if param type is a tuple array.
+fn is_tuple_array_type(param_type: &DynSolType) -> bool {
+    matches!(
+        param_type,
+        DynSolType::Array(inner) | DynSolType::FixedArray(inner, _)
+            if matches!(inner.as_ref(), DynSolType::Tuple(_))
+    )
+}
+
+/// Check if param type is a tuple matrix (2D array).
+fn is_tuple_matrix_type(param_type: &DynSolType) -> bool {
+    match param_type {
+        DynSolType::Array(inner) | DynSolType::FixedArray(inner, _) => is_tuple_array_type(inner),
+        _ => false,
+    }
+}
+
+/// Handle indexed input type conversion.
+fn indexed_input_type(param_type: &DynSolType) -> DynSolType {
+    // Strings, bytes, and arrays are encoded and hashed to bytes32
+    match param_type {
+        DynSolType::String | DynSolType::Bytes | DynSolType::Tuple(_) => DynSolType::FixedBytes(32),
+        DynSolType::Array(_) | DynSolType::FixedArray(_, _) => DynSolType::FixedBytes(32),
+        _ => param_type.clone(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    fn parse_abi(json: &str) -> JsonAbi {
+        serde_json::from_str(json).unwrap()
+    }
+
+    #[test]
+    fn test_simple_event() {
+        let abi_json = r#"[
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": [
+                    {"name": "from", "type": "address", "indexed": true},
+                    {"name": "to", "type": "address", "indexed": true},
+                    {"name": "value", "type": "uint256", "indexed": false}
+                ],
+                "anonymous": false
+            }
+        ]"#;
+
+        let contract = parse_abi(abi_json);
+        let generator = AbiCodeGenerator::new(contract, "Token");
+        let types = generator.generate_types();
+
+        assert!(types.iter().any(|c| c.name == "Transfer"));
+        assert!(types.iter().any(|c| c.name == "Transfer__Params"));
+    }
+
+    #[test]
+    fn test_function_with_outputs() {
+        let abi_json = r#"[
+            {
+                "type": "function",
+                "name": "balanceOf",
+                "inputs": [{"name": "owner", "type": "address"}],
+                "outputs": [{"name": "", "type": "uint256"}],
+                "stateMutability": "view"
+            }
+        ]"#;
+
+        let contract = parse_abi(abi_json);
+        let generator = AbiCodeGenerator::new(contract, "Token");
+        let types = generator.generate_types();
+
+        assert!(types.iter().any(|c| c.name == "Token"));
+        let token_class = types.iter().find(|c| c.name == "Token").unwrap();
+
+        assert!(token_class.methods.iter().any(|m| m.name == "balanceOf"));
+        assert!(
+            token_class
+                .methods
+                .iter()
+                .any(|m| m.name == "try_balanceOf")
+        );
+    }
+
+    #[test]
+    fn test_asc_type_for_ethereum() {
+        assert_eq!(asc_type_for_ethereum(&DynSolType::Address), "Address");
+        assert_eq!(asc_type_for_ethereum(&DynSolType::Bool), "boolean");
+        assert_eq!(asc_type_for_ethereum(&DynSolType::Uint(256)), "BigInt");
+        assert_eq!(asc_type_for_ethereum(&DynSolType::Uint(8)), "i32");
+        assert_eq!(asc_type_for_ethereum(&DynSolType::Int(32)), "i32");
+        assert_eq!(asc_type_for_ethereum(&DynSolType::String), "string");
+        assert_eq!(asc_type_for_ethereum(&DynSolType::Bytes), "Bytes");
+    }
+
+    #[test]
+    fn test_name_sanitization() {
+        let generator = AbiCodeGenerator::new(JsonAbi::default(), "Test!Contract@Name");
+        assert_eq!(generator.name, "Test_Contract_Name");
+    }
+
+    #[test]
+    fn test_indexed_input_type() {
+        assert_eq!(
+            indexed_input_type(&DynSolType::String),
+            DynSolType::FixedBytes(32)
+        );
+        assert_eq!(
+            indexed_input_type(&DynSolType::Bytes),
+            DynSolType::FixedBytes(32)
+        );
+        assert_eq!(
+            indexed_input_type(&DynSolType::Array(Box::new(DynSolType::Uint(256)))),
+            DynSolType::FixedBytes(32)
+        );
+        assert_eq!(
+            indexed_input_type(&DynSolType::Address),
+            DynSolType::Address
+        );
+        assert_eq!(
+            indexed_input_type(&DynSolType::Uint(256)),
+            DynSolType::Uint(256)
+        );
+    }
+
+    /// Test that overloaded events (same name, different inputs) are disambiguated.
+    /// The TS CLI generates unique names like Transfer, Transfer1, Transfer2.
+    #[test]
+    fn test_overloaded_events() {
+        let abi_json = r#"[
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": [],
+                "anonymous": false
+            },
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": [{"name": "to", "type": "address", "indexed": false}],
+                "anonymous": false
+            },
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": [
+                    {"name": "from", "type": "address", "indexed": false},
+                    {"name": "to", "type": "address", "indexed": false}
+                ],
+                "anonymous": false
+            }
+        ]"#;
+
+        let contract = parse_abi(abi_json);
+        let generator = AbiCodeGenerator::new(contract, "Token");
+        let types = generator.generate_types();
+
+        // Get all event class names
+        let event_names: Vec<&str> = types
+            .iter()
+            .filter(|c| c.extends == Some("ethereum.Event".to_string()))
+            .map(|c| c.name.as_str())
+            .collect();
+
+        // Verify we have 3 distinct Transfer events with disambiguation
+        assert_eq!(
+            event_names.len(),
+            3,
+            "Should have 3 Transfer event variants"
+        );
+
+        // Check that Transfer (with no suffix) exists
+        assert!(
+            event_names.contains(&"Transfer"),
+            "Should have base Transfer event"
+        );
+
+        // Check that numbered variants exist (Transfer1, Transfer2)
+        assert!(
+            event_names.contains(&"Transfer1"),
+            "Should have Transfer1 event"
+        );
+        assert!(
+            event_names.contains(&"Transfer2"),
+            "Should have Transfer2 event"
+        );
+    }
+
+    /// Test that overloaded functions are disambiguated.
+    #[test]
+    fn test_overloaded_functions() {
+        let abi_json = r#"[
+            {
+                "type": "function",
+                "name": "getSomething",
+                "inputs": [],
+                "outputs": [{"name": "result", "type": "bytes32"}],
+                "stateMutability": "view"
+            },
+            {
+                "type": "function",
+                "name": "getSomething",
+                "inputs": [{"name": "owner", "type": "address"}],
+                "outputs": [{"name": "result", "type": "bytes32"}],
+                "stateMutability": "view"
+            }
+        ]"#;
+
+        let contract = parse_abi(abi_json);
+        let generator = AbiCodeGenerator::new(contract, "Token");
+        let types = generator.generate_types();
+
+        // Find the Token contract class
+        let token_class = types.iter().find(|c| c.name == "Token").unwrap();
+
+        // Get all method names (excluding try_ variants and bind)
+        let method_names: Vec<&str> = token_class
+            .methods
+            .iter()
+            .map(|m| m.name.as_str())
+            .filter(|n| !n.starts_with("try_") && *n != "bind")
+            .collect();
+
+        // Verify we have disambiguated getSomething variants
+        assert!(
+            method_names.contains(&"getSomething"),
+            "Should have base getSomething method"
+        );
+        assert!(
+            method_names.contains(&"getSomething1"),
+            "Should have getSomething1 method"
+        );
+    }
+
+    /// Test that tuple/struct types in function inputs and outputs are handled correctly.
+    #[test]
+    fn test_tuple_types_in_functions() {
+        let abi_json = r#"[
+            {
+                "type": "function",
+                "name": "doSomething",
+                "inputs": [
+                    {
+                        "name": "data",
+                        "type": "tuple",
+                        "components": [
+                            {"name": "owner", "type": "address"},
+                            {"name": "value", "type": "uint256"}
+                        ]
+                    }
+                ],
+                "outputs": [
+                    {
+                        "name": "result",
+                        "type": "tuple",
+                        "components": [
+                            {"name": "success", "type": "bool"},
+                            {"name": "newValue", "type": "uint256"}
+                        ]
+                    }
+                ],
+                "stateMutability": "nonpayable"
+            }
+        ]"#;
+
+        let contract = parse_abi(abi_json);
+        let generator = AbiCodeGenerator::new(contract, "TestContract");
+        let types = generator.generate_types();
+
+        // Get class names
+        let class_names: Vec<&str> = types.iter().map(|c| c.name.as_str()).collect();
+
+        // Should have main contract class
+        assert!(
+            class_names.contains(&"TestContract"),
+            "Should have TestContract class"
+        );
+
+        // Should have struct classes for input and output tuples
+        // Input struct: TestContract__doSomethingInputValue0Struct
+        // Output struct: TestContract__doSomethingResultValue0Struct
+        let has_input_struct = class_names
+            .iter()
+            .any(|n| n.contains("Input") && n.contains("Struct"));
+        let has_output_struct = class_names
+            .iter()
+            .any(|n| n.contains("Result") && n.contains("Struct"));
+
+        assert!(
+            has_input_struct,
+            "Should have input struct class, found: {:?}",
+            class_names
+        );
+        assert!(
+            has_output_struct,
+            "Should have output/result struct class, found: {:?}",
+            class_names
+        );
+
+        // Verify the output struct extends ethereum.Tuple
+        let output_struct = types
+            .iter()
+            .find(|c| c.name.contains("Result") && c.name.contains("Struct"))
+            .expect("Should find output struct");
+        assert_eq!(
+            output_struct.extends,
+            Some("ethereum.Tuple".to_string()),
+            "Output struct should extend ethereum.Tuple"
+        );
+
+        // Verify the output struct has getters for its components
+        // With alloy, component names are preserved from the ABI
+        let method_names: Vec<&str> = output_struct
+            .methods
+            .iter()
+            .map(|m| m.name.as_str())
+            .collect();
+        assert!(
+            method_names.iter().any(|n| n.contains("success")),
+            "Should have success getter for first component, found methods: {:?}",
+            method_names
+        );
+        assert!(
+            method_names.iter().any(|n| n.contains("newValue")),
+            "Should have newValue getter for second component, found methods: {:?}",
+            method_names
+        );
+    }
+
+    /// Test that tuple types in events are handled correctly.
+    #[test]
+    fn test_tuple_types_in_events() {
+        let abi_json = r#"[
+            {
+                "type": "event",
+                "name": "DataUpdated",
+                "inputs": [
+                    {"name": "id", "type": "uint256", "indexed": true},
+                    {
+                        "name": "data",
+                        "type": "tuple",
+                        "indexed": false,
+                        "components": [
+                            {"name": "timestamp", "type": "uint256"},
+                            {"name": "value", "type": "bytes32"}
+                        ]
+                    }
+                ],
+                "anonymous": false
+            }
+        ]"#;
+
+        let contract = parse_abi(abi_json);
+        let generator = AbiCodeGenerator::new(contract, "TestContract");
+        let types = generator.generate_types();
+
+        // Get class names
+        let class_names: Vec<&str> = types.iter().map(|c| c.name.as_str()).collect();
+
+        // Should have event class
+        assert!(
+            class_names.contains(&"DataUpdated"),
+            "Should have DataUpdated event class"
+        );
+
+        // Should have params class
+        assert!(
+            class_names.contains(&"DataUpdated__Params"),
+            "Should have DataUpdated__Params class"
+        );
+
+        // Should have struct class for the tuple parameter
+        let has_struct = class_names
+            .iter()
+            .any(|n| n.contains("Struct") && n.contains("DataUpdated"));
+        assert!(
+            has_struct,
+            "Should have struct class for tuple parameter, found: {:?}",
+            class_names
+        );
+    }
+
+    /// Test that nested tuple types (struct with struct field) are handled.
+    #[test]
+    fn test_nested_tuple_types() {
+        let abi_json = r#"[
+            {
+                "type": "function",
+                "name": "getNestedData",
+                "inputs": [],
+                "outputs": [
+                    {
+                        "name": "result",
+                        "type": "tuple",
+                        "components": [
+                            {"name": "id", "type": "uint256"},
+                            {
+                                "name": "inner",
+                                "type": "tuple",
+                                "components": [
+                                    {"name": "x", "type": "uint256"},
+                                    {"name": "y", "type": "uint256"}
+                                ]
+                            }
+                        ]
+                    }
+                ],
+                "stateMutability": "view"
+            }
+        ]"#;
+
+        let contract = parse_abi(abi_json);
+        let generator = AbiCodeGenerator::new(contract, "TestContract");
+        let types = generator.generate_types();
+
+        // Get class names
+        let class_names: Vec<&str> = types.iter().map(|c| c.name.as_str()).collect();
+
+        // Should have main contract class
+        assert!(
+            class_names.contains(&"TestContract"),
+            "Should have TestContract class"
+        );
+
+        // Should have at least two struct classes (outer and inner)
+        let struct_count = class_names.iter().filter(|n| n.contains("Struct")).count();
+        assert!(
+            struct_count >= 2,
+            "Should have at least 2 struct classes for nested tuple, found {} in {:?}",
+            struct_count,
+            class_names
+        );
+    }
+
+    /// Test that tuple arrays are handled correctly.
+    #[test]
+    fn test_tuple_array_types() {
+        let abi_json = r#"[
+            {
+                "type": "function",
+                "name": "getAllItems",
+                "inputs": [],
+                "outputs": [
+                    {
+                        "name": "items",
+                        "type": "tuple[]",
+                        "components": [
+                            {"name": "id", "type": "uint256"},
+                            {"name": "name", "type": "string"}
+                        ]
+                    }
+                ],
+                "stateMutability": "view"
+            }
+        ]"#;
+
+        let contract = parse_abi(abi_json);
+        let generator = AbiCodeGenerator::new(contract, "TestContract");
+        let types = generator.generate_types();
+
+        // Find the contract class
+        let contract_class = types.iter().find(|c| c.name == "TestContract").unwrap();
+
+        // Find the getAllItems method
+        let method = contract_class
+            .methods
+            .iter()
+            .find(|m| m.name == "getAllItems")
+            .expect("Should have getAllItems method");
+
+        // The return type should be an Array of the struct type
+        let return_type = method
+            .return_type
+            .as_ref()
+            .expect("Should have return type");
+        let return_type_str = return_type.to_string();
+        assert!(
+            return_type_str.starts_with("Array<"),
+            "Return type should be Array<...>, got: {}",
+            return_type_str
+        );
+    }
+
+    /// Test that array types in events are handled correctly.
+    #[test]
+    fn test_array_types_in_events() {
+        let abi_json = r#"[
+            {
+                "type": "event",
+                "name": "Airdropped",
+                "inputs": [
+                    {"name": "sender", "type": "address", "indexed": true},
+                    {"name": "recipients", "type": "address[]", "indexed": false},
+                    {"name": "amounts", "type": "uint256[]", "indexed": false}
+                ],
+                "anonymous": false
+            }
+        ]"#;
+
+        let contract = parse_abi(abi_json);
+        let generator = AbiCodeGenerator::new(contract, "Token");
+        let types = generator.generate_types();
+
+        // Find the params class
+        let params_class = types
+            .iter()
+            .find(|c| c.name == "Airdropped__Params")
+            .expect("Should have Airdropped__Params class");
+
+        // Check that the array getters exist and have correct return types
+        let method_names: Vec<&str> = params_class
+            .methods
+            .iter()
+            .map(|m| m.name.as_str())
+            .collect();
+
+        assert!(
+            method_names.iter().any(|n| n.contains("recipients")),
+            "Should have recipients getter, found: {:?}",
+            method_names
+        );
+        assert!(
+            method_names.iter().any(|n| n.contains("amounts")),
+            "Should have amounts getter, found: {:?}",
+            method_names
+        );
+
+        // Verify the recipients getter returns Array<Address>
+        let recipients_getter = params_class
+            .methods
+            .iter()
+            .find(|m| m.name.contains("recipients"))
+            .expect("Should have recipients getter");
+        let return_type_str = recipients_getter
+            .return_type
+            .as_ref()
+            .expect("Should have return type")
+            .to_string();
+        assert!(
+            return_type_str.contains("Array<Address>"),
+            "recipients should return Array<Address>, got: {}",
+            return_type_str
+        );
+
+        // Verify the amounts getter returns Array<BigInt>
+        let amounts_getter = params_class
+            .methods
+            .iter()
+            .find(|m| m.name.contains("amounts"))
+            .expect("Should have amounts getter");
+        let amounts_type_str = amounts_getter
+            .return_type
+            .as_ref()
+            .expect("Should have return type")
+            .to_string();
+        assert!(
+            amounts_type_str.contains("Array<BigInt>"),
+            "amounts should return Array<BigInt>, got: {}",
+            amounts_type_str
+        );
+    }
+
+    /// Test that 2D array types (matrices) are handled correctly in functions.
+    #[test]
+    fn test_matrix_types_in_functions() {
+        let abi_json = r#"[
+            {
+                "type": "function",
+                "name": "getMatrix",
+                "inputs": [],
+                "outputs": [
+                    {"name": "data", "type": "uint256[][]"}
+                ],
+                "stateMutability": "view"
+            }
+        ]"#;
+
+        let contract = parse_abi(abi_json);
+        let generator = AbiCodeGenerator::new(contract, "TestContract");
+        let types = generator.generate_types();
+
+        // Find the contract class
+        let contract_class = types.iter().find(|c| c.name == "TestContract").unwrap();
+
+        // Find the getMatrix method
+        let method = contract_class
+            .methods
+            .iter()
+            .find(|m| m.name == "getMatrix")
+            .expect("Should have getMatrix method");
+
+        // The return type should be Array<Array<BigInt>>
+        let return_type = method
+            .return_type
+            .as_ref()
+            .expect("Should have return type");
+        let return_type_str = return_type.to_string();
+        assert!(
+            return_type_str.contains("Array<Array<BigInt>>"),
+            "Return type should be Array<Array<BigInt>>, got: {}",
+            return_type_str
+        );
+    }
+}
diff --git a/gnd/src/codegen/mod.rs b/gnd/src/codegen/mod.rs
new file mode 100644
index 00000000000..4c8f5fdbd98
--- /dev/null
+++ b/gnd/src/codegen/mod.rs
@@ -0,0 +1,20 @@
+//! Code generation for subgraph AssemblyScript types.
+//!
+//! This module generates AssemblyScript types from:
+//! - GraphQL schema (entity classes)
+//! - Contract ABIs (event and call bindings)
+//! - Data source templates
+
+mod abi;
+mod schema;
+mod template;
+mod types;
+mod typescript;
+
+pub use abi::AbiCodeGenerator;
+pub use schema::SchemaCodeGenerator;
+pub use template::{Template, TemplateCodeGenerator, TemplateKind};
+pub use typescript::{
+    ArrayType, Class, ClassMember, GENERATED_FILE_NOTE, Method, ModuleImports, NamedType,
+    NullableType, Param, StaticMethod,
+};
diff --git a/gnd/src/codegen/schema.rs b/gnd/src/codegen/schema.rs
new file mode 100644
index 00000000000..a8a276f1ca0
--- /dev/null
+++ b/gnd/src/codegen/schema.rs
@@ -0,0 +1,1289 @@
+//! Schema code generation.
+//!
+//! Generates AssemblyScript entity classes from GraphQL schemas.
+
+use anyhow::{Result, anyhow};
+use graphql_tools::parser::schema::{
+    Definition, Document, Field, ObjectType, Type, TypeDefinition,
+};
+
+use super::types::{asc_type_for_value, value_from_asc, value_to_asc};
+use super::typescript::{
+    self as ts, ArrayType, Class, Method, ModuleImports, NamedType, NullableType, Param,
+    StaticMethod, TypeExpr,
+};
+use crate::shared::handle_reserved_word;
+
+/// Type of the ID field.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum IdFieldKind {
+    String,
+    Bytes,
+    Int8,
+}
+
+impl IdFieldKind {
+    /// Get the AssemblyScript type name for this ID type.
+    pub fn type_name(&self) -> &'static str {
+        match self {
+            IdFieldKind::String => "string",
+            IdFieldKind::Bytes => "Bytes",
+            IdFieldKind::Int8 => "i64",
+        }
+    }
+
+    /// Get the GraphQL type name for this ID type.
+    pub fn gql_type_name(&self) -> &'static str {
+        match self {
+            IdFieldKind::String => "String",
+            IdFieldKind::Bytes => "Bytes",
+            IdFieldKind::Int8 => "Int8",
+        }
+    }
+
+    /// Get the code to create a Value from the ID.
+    pub fn value_from(&self) -> &'static str {
+        match self {
+            IdFieldKind::String => "Value.fromString(id)",
+            IdFieldKind::Bytes => "Value.fromBytes(id)",
+            IdFieldKind::Int8 => "Value.fromI64(id)",
+        }
+    }
+
+    /// Get the ValueKind for this ID type.
+    pub fn value_kind(&self) -> &'static str {
+        match self {
+            IdFieldKind::String => "ValueKind.STRING",
+            IdFieldKind::Bytes => "ValueKind.BYTES",
+            IdFieldKind::Int8 => "ValueKind.INT8",
+        }
+    }
+
+    /// Get the code to convert a Value to a string representation.
+    pub fn value_to_string(&self) -> &'static str {
+        match self {
+            IdFieldKind::String => "id.toString()",
+            IdFieldKind::Bytes => "id.toBytes().toHexString()",
+            IdFieldKind::Int8 => "id.toI64().toString()",
+        }
+    }
+
+    /// Get the code to convert the ID to a string.
+    pub fn id_to_string_code(self) -> &'static str {
+        match self {
+            IdFieldKind::String => "id",
+            IdFieldKind::Bytes => "id.toHexString()",
+            IdFieldKind::Int8 => "id.toString()",
+        }
+    }
+
+    /// Determine the ID field kind from a type name.
+    pub fn from_type_name(type_name: &str) -> Self {
+        match type_name {
+            "Bytes" => IdFieldKind::Bytes,
+            "Int8" => IdFieldKind::Int8,
+            _ => IdFieldKind::String,
+        }
+    }
+
+    /// Returns true if this ID type supports auto-increment (optional constructor arg).
+    pub fn supports_auto(&self) -> bool {
+        matches!(self, IdFieldKind::Int8 | IdFieldKind::Bytes)
+    }
+
+    /// Get the constructor parameter type (with nullability for auto-increment types).
+    pub fn constructor_param_type(&self) -> &'static str {
+        match self {
+            IdFieldKind::String => "string",
+            IdFieldKind::Bytes => "Bytes | null",
+            IdFieldKind::Int8 => "i64", // primitive, can't be nullable
+        }
+    }
+
+    /// Get the default value for constructor parameter (for auto-increment types).
+    pub fn constructor_default(&self) -> Option<&'static str> {
+        match self {
+            IdFieldKind::String => None,
+            IdFieldKind::Bytes => Some("null"),
+            IdFieldKind::Int8 => Some("i64.MIN_VALUE"),
+        }
+    }
+
+    /// Get the condition to check if id was provided (not auto-increment).
+    pub fn auto_check_condition(&self) -> &'static str {
+        match self {
+            IdFieldKind::String => "", // N/A
+            // For Bytes we end up generating 'if (id) { .. }' Using 'id !=
+            // null' crashes the AssemblyScript compiler  0.19.23 because id
+            // has type 'Bytes | null' and the compiler doesn't strip the
+            // null from the type in the body of the if
+            IdFieldKind::Bytes => "id",
+            IdFieldKind::Int8 => "id != i64.MIN_VALUE",
+        }
+    }
+}
+
+/// Get the base type name from a GraphQL type (stripping NonNull and List wrappers).
+fn get_base_type_name(ty: &Type<'_, String>) -> String {
+    match ty {
+        Type::NamedType(name) => name.clone(),
+        Type::NonNullType(inner) => get_base_type_name(inner),
+        Type::ListType(inner) => get_base_type_name(inner),
+    }
+}
+
+/// Check if a type is nullable (not wrapped in NonNull).
+fn is_nullable(ty: &Type<'_, String>) -> bool {
+    !matches!(ty, Type::NonNullType(_))
+}
+
+/// Count the list nesting depth of a type.
+/// `String` -> 0, `[String]` -> 1, `[[String]]` -> 2, etc.
+fn list_depth(ty: &Type<'_, String>) -> u8 {
+    match ty {
+        Type::ListType(inner) => 1 + list_depth(inner),
+        Type::NonNullType(inner) => list_depth(inner),
+        Type::NamedType(_) => 0,
+    }
+}
+
+/// Check if the innermost list members are nullable.
+/// For `[String]` returns true, for `[String!]` returns false.
+/// For non-list types, returns false.
+fn is_list_member_nullable(ty: &Type<'_, String>) -> bool {
+    match ty {
+        Type::ListType(inner) => {
+            // Check the immediate inner type
+            is_nullable(inner)
+        }
+        Type::NonNullType(inner) => is_list_member_nullable(inner),
+        Type::NamedType(_) => false,
+    }
+}
+
+/// Check if a field has the @derivedFrom directive.
+fn is_derived_field(field: &Field<'_, String>) -> bool {
+    field.directives.iter().any(|d| d.name == "derivedFrom")
+}
+
+/// Check if an object type has the @entity directive.
+fn is_entity_type(obj: &ObjectType<'_, String>) -> bool {
+    obj.directives.iter().any(|d| d.name == "entity")
+}
+
+/// Collected entity info for code generation.
+struct EntityInfo {
+    name: String,
+    id_kind: IdFieldKind,
+    fields: Vec<FieldInfo>,
+}
+
+/// Collected field info.
+struct FieldInfo {
+    name: String,
+    is_derived: bool,
+    base_type: String,
+    is_nullable: bool,
+    /// The nesting depth of list wrappers. 0 = scalar, 1 = [T], 2 = [[T]], etc.
+    list_depth: u8,
+    /// Whether list members are nullable. Only meaningful when list_depth > 0.
+    member_nullable: bool,
+}
+
+/// Schema code generator.
+pub struct SchemaCodeGenerator {
+    entities: Vec<EntityInfo>,
+    entity_names: std::collections::HashSet<String>,
+    /// Maps entity name to its ID field kind, for resolving entity reference types.
+    entity_id_kinds: std::collections::HashMap<String, IdFieldKind>,
+}
+
+impl SchemaCodeGenerator {
+    /// Create a new schema code generator from a parsed GraphQL document.
+    ///
+    /// Returns an error if the schema contains invalid patterns like non-nullable
+    /// lists with nullable members (e.g., `[Something]!`).
+    pub fn new(document: &Document<'_, String>) -> Result<Self> {
+        let mut entities = Vec::new();
+        let mut entity_names = std::collections::HashSet::new();
+        let mut entity_id_kinds = std::collections::HashMap::new();
+
+        // First pass: collect entity names and their ID types
+        for def in &document.definitions {
+            if let Definition::TypeDefinition(TypeDefinition::Object(obj)) = def
+                && is_entity_type(obj)
+            {
+                entity_names.insert(obj.name.clone());
+                let id_field = obj.fields.iter().find(|f| f.name == "id");
+                let id_kind = id_field
+                    .map(|f| IdFieldKind::from_type_name(&get_base_type_name(&f.field_type)))
+                    .unwrap_or(IdFieldKind::String);
+                entity_id_kinds.insert(obj.name.clone(), id_kind);
+            }
+        }
+
+        // Second pass: collect entity info
+        for def in &document.definitions {
+            if let Definition::TypeDefinition(TypeDefinition::Object(obj)) = def
+                && is_entity_type(obj)
+            {
+                let name = obj.name.clone();
+
+                // Find ID field
+                let id_field = obj.fields.iter().find(|f| f.name == "id");
+                let id_kind = id_field
+                    .map(|f| IdFieldKind::from_type_name(&get_base_type_name(&f.field_type)))
+                    .unwrap_or(IdFieldKind::String);
+
+                // Collect field info
+                let fields: Vec<_> = obj
+                    .fields
+                    .iter()
+                    .map(|f| FieldInfo {
+                        name: f.name.clone(),
+                        is_derived: is_derived_field(f),
+                        base_type: get_base_type_name(&f.field_type),
+                        is_nullable: is_nullable(&f.field_type),
+                        list_depth: list_depth(&f.field_type),
+                        member_nullable: is_list_member_nullable(&f.field_type),
+                    })
+                    .collect();
+
+                entities.push(EntityInfo {
+                    name,
+                    id_kind,
+                    fields,
+                });
+            }
+        }
+
+        // Validate: non-nullable lists must have non-nullable members
+        for entity in &entities {
+            for field in &entity.fields {
+                if field.list_depth > 0 && !field.is_nullable && field.member_nullable {
+                    return Err(anyhow!(
+                        "Codegen can't generate code for GraphQL field '{}' of type '[{}]!' since the inner type is nullable.\n\
+                         Suggestion: add an '!' to the inner type, e.g., '[{}!]!'",
+                        field.name,
+                        field.base_type,
+                        field.base_type
+                    ));
+                }
+            }
+        }
+
+        Ok(Self {
+            entities,
+            entity_names,
+            entity_id_kinds,
+        })
+    }
+
+    /// Generate module imports for the schema file.
+    pub fn generate_module_imports(&self) -> Vec<ModuleImports> {
+        vec![ModuleImports::new(
+            vec![
+                "TypedMap".to_string(),
+                "Entity".to_string(),
+                "Value".to_string(),
+                "ValueKind".to_string(),
+                "store".to_string(),
+                "Bytes".to_string(),
+                "BigInt".to_string(),
+                "BigDecimal".to_string(),
+                "Int8".to_string(),
+            ],
+            "@graphprotocol/graph-ts",
+        )]
+    }
+
+    /// Generate entity classes from the schema.
+    pub fn generate_types(&self, generate_store_methods: bool) -> Vec<Class> {
+        self.entities
+            .iter()
+            .map(|entity| self.generate_entity_type(entity, generate_store_methods))
+            .collect()
+    }
+
+    /// Generate derived loaders for fields with @derivedFrom.
+    pub fn generate_derived_loaders(&self) -> Vec<Class> {
+        let mut loaders = Vec::new();
+        let mut seen_types = std::collections::HashSet::new();
+
+        for entity in &self.entities {
+            for field in &entity.fields {
+                if field.is_derived && !seen_types.contains(&field.base_type) {
+                    // Only generate loaders for entity types, not interfaces
+                    if self.entity_names.contains(&field.base_type) {
+                        seen_types.insert(field.base_type.clone());
+                        loaders.push(self.generate_derived_loader(&field.base_type));
+                    }
+                }
+            }
+        }
+
+        loaders
+    }
+
+    fn generate_entity_type(&self, entity: &EntityInfo, generate_store_methods: bool) -> Class {
+        let mut klass = ts::klass(&entity.name).exported().extends("Entity");
+
+        // Generate constructor
+        klass.add_method(self.generate_constructor(&entity.id_kind));
+
+        // Generate store methods
+        if generate_store_methods {
+            for method in self.generate_store_methods(&entity.name, &entity.id_kind) {
+                match method {
+                    StoreMethod::Regular(m) => klass.add_method(m),
+                    StoreMethod::Static(m) => klass.add_static_method(m),
+                }
+            }
+        }
+
+        // Generate field getters and setters
+        for field in &entity.fields {
+            if let Some(getter) = self.generate_field_getter(&entity.name, field, &entity.id_kind) {
+                klass.add_method(getter);
+            }
+            if let Some(setter) = self.generate_field_setter(field) {
+                klass.add_method(setter);
+            }
+        }
+
+        klass
+    }
+
+    fn generate_constructor(&self, id_kind: &IdFieldKind) -> Method {
+        if id_kind.supports_auto() {
+            // For Int8 and Bytes, make id optional to support auto-increment
+            let param_type = id_kind.constructor_param_type();
+            let default_value = id_kind.constructor_default().unwrap();
+            let check_condition = id_kind.auto_check_condition();
+
+            Method::new(
+                "constructor",
+                vec![Param::with_default(
+                    "id",
+                    TypeExpr::Raw(param_type.to_string()),
+                    default_value,
+                )],
+                None,
+                format!(
+                    r#"
+      super()
+      if ({}) {{
+        this.set('id', {})
+      }}"#,
+                    check_condition,
+                    id_kind.value_from()
+                ),
+            )
+            .with_doc("Leaving out the id argument uses an autoincrementing id.")
+        } else {
+            // For String IDs, keep the existing behavior (required parameter)
+            Method::new(
+                "constructor",
+                vec![Param::new("id", NamedType::new(id_kind.type_name()))],
+                None,
+                format!(
+                    r#"
+      super()
+      this.set('id', {})"#,
+                    id_kind.value_from()
+                ),
+            )
+        }
+    }
+
+    fn generate_store_methods(&self, entity_name: &str, id_kind: &IdFieldKind) -> Vec<StoreMethod> {
+        // Generate save() method - different for auto-increment vs string IDs
+        let save_method = if id_kind.supports_auto() {
+            // For Int8 and Bytes, check if id is null/unset and use "auto" as the key
+            Method::new(
+                "save",
+                vec![],
+                Some(NamedType::new("void").into()),
+                format!(
+                    r#"
+        let id = this.get('id')
+        if (id == null || id.kind == ValueKind.NULL) {{
+          store.set('{}', 'auto', this)
+        }} else {{
+          assert(id.kind == {},
+                 `Entities of type {} must have an ID of type {} but the id '${{id.displayData()}}' is of type ${{id.displayKind()}}`)
+          store.set('{}', {}, this)
+        }}"#,
+                    entity_name,
+                    id_kind.value_kind(),
+                    entity_name,
+                    id_kind.gql_type_name(),
+                    entity_name,
+                    id_kind.value_to_string()
+                ),
+            )
+        } else {
+            // For String IDs, keep the existing behavior (require ID)
+            Method::new(
+                "save",
+                vec![],
+                Some(NamedType::new("void").into()),
+                format!(
+                    r#"
+        let id = this.get('id')
+        assert(id != null,
+               'Cannot save {} entity without an ID')
+        if (id) {{
+          assert(id.kind == {},
+                 `Entities of type {} must have an ID of type {} but the id '${{id.displayData()}}' is of type ${{id.displayKind()}}`)
+          store.set('{}', {}, this)
+        }}"#,
+                    entity_name,
+                    id_kind.value_kind(),
+                    entity_name,
+                    id_kind.gql_type_name(),
+                    entity_name,
+                    id_kind.value_to_string()
+                ),
+            )
+        };
+
+        vec![
+            StoreMethod::Regular(save_method),
+            // loadInBlock() static method
+            StoreMethod::Static(StaticMethod::new(
+                "loadInBlock",
+                vec![Param::new("id", NamedType::new(id_kind.type_name()))],
+                NullableType::new(NamedType::new(entity_name)),
+                format!(
+                    r#"
+        return changetype<{} | null>(store.get_in_block('{}', {}))"#,
+                    entity_name,
+                    entity_name,
+                    id_kind.id_to_string_code()
+                ),
+            )),
+            // load() static method
+            StoreMethod::Static(StaticMethod::new(
+                "load",
+                vec![Param::new("id", NamedType::new(id_kind.type_name()))],
+                NullableType::new(NamedType::new(entity_name)),
+                format!(
+                    r#"
+        return changetype<{} | null>(store.get('{}', {}))"#,
+                    entity_name,
+                    entity_name,
+                    id_kind.id_to_string_code()
+                ),
+            )),
+        ]
+    }
+
+    fn generate_field_getter(
+        &self,
+        entity_name: &str,
+        field: &FieldInfo,
+        id_kind: &IdFieldKind,
+    ) -> Option<Method> {
+        let safe_name = handle_reserved_word(&field.name);
+
+        // Handle derived fields
+        if field.is_derived {
+            return self.generate_derived_field_getter(entity_name, field, &safe_name, id_kind);
+        }
+
+        let value_type = self.value_type_from_field(field);
+        let return_type = self.type_from_field(field);
+        let nullable = field.is_nullable;
+
+        let primitive_default = match &return_type {
+            TypeExpr::Named(t) => t.get_primitive_default(),
+            _ => None,
+        };
+
+        let get_code = if nullable {
+            format!(
+                r#"
+       let value = this.get('{}')
+       if (!value || value.kind == ValueKind.NULL) {{
+         return null
+       }} else {{
+         return {}
+       }}"#,
+                field.name,
+                value_to_asc("value", &value_type)
+            )
+        } else {
+            let null_handling = match primitive_default {
+                Some(default) => format!("return {}", default),
+                None => "throw new Error('Cannot return null for a required field.')".to_string(),
+            };
+            format!(
+                r#"
+       let value = this.get('{}')
+       if (!value || value.kind == ValueKind.NULL) {{
+         {}
+       }} else {{
+         return {}
+       }}"#,
+                field.name,
+                null_handling,
+                value_to_asc("value", &value_type)
+            )
+        };
+
+        Some(Method::new(
+            format!("get {}", safe_name),
+            vec![],
+            Some(return_type),
+            get_code,
+        ))
+    }
+
+    fn generate_derived_field_getter(
+        &self,
+        entity_name: &str,
+        field: &FieldInfo,
+        safe_name: &str,
+        id_kind: &IdFieldKind,
+    ) -> Option<Method> {
+        let loader_name = format!("{}Loader", field.base_type);
+
+        let id_conversion = match id_kind {
+            IdFieldKind::Bytes => "this.get('id')!.toBytes().toHexString()",
+            _ => "this.get('id')!.toString()",
+        };
+
+        Some(Method::new(
+            format!("get {}", safe_name),
+            vec![],
+            Some(NamedType::new(&loader_name).into()),
+            format!(
+                r#"
+        return new {}('{}', {}, '{}')"#,
+                loader_name, entity_name, id_conversion, field.name
+            ),
+        ))
+    }
+
+    fn generate_field_setter(&self, field: &FieldInfo) -> Option<Method> {
+        // No setters for derived fields
+        if field.is_derived {
+            return None;
+        }
+
+        let safe_name = handle_reserved_word(&field.name);
+        let value_type = self.value_type_from_field(field);
+        let param_type = self.type_from_field(field);
+        let nullable = field.is_nullable;
+
+        let set_code = if nullable {
+            let inner_type = match &param_type {
+                TypeExpr::Nullable(n) => n.inner.to_string(),
+                other => other.to_string(),
+            };
+            format!(
+                r#"
+      if (!value) {{
+        this.unset('{}')
+      }} else {{
+        this.set('{}', {})
+      }}"#,
+                field.name,
+                field.name,
+                value_from_asc(&format!("<{}>value", inner_type), &value_type)
+            )
+        } else {
+            format!(
+                r#"
+      this.set('{}', {})"#,
+                field.name,
+                value_from_asc("value", &value_type)
+            )
+        };
+
+        Some(Method::new(
+            format!("set {}", safe_name),
+            vec![Param::new("value", param_type)],
+            None,
+            set_code,
+        ))
+    }
+
+    fn generate_derived_loader(&self, type_name: &str) -> Class {
+        let loader_name = format!("{}Loader", type_name);
+        let mut klass = ts::klass(&loader_name).exported().extends("Entity");
+
+        // Add members
+        klass.add_member(ts::klass_member("_entity", "string"));
+        klass.add_member(ts::klass_member("_field", "string"));
+        klass.add_member(ts::klass_member("_id", "string"));
+
+        // Add constructor
+        klass.add_method(Method::new(
+            "constructor",
+            vec![
+                Param::new("entity", NamedType::new("string")),
+                Param::new("id", NamedType::new("string")),
+                Param::new("field", NamedType::new("string")),
+            ],
+            None,
+            r#"
+      super();
+      this._entity = entity;
+      this._id = id;
+      this._field = field;"#
+                .to_string(),
+        ));
+
+        // Add load() method
+        klass.add_method(Method::new(
+            "load",
+            vec![],
+            Some(TypeExpr::Raw(format!("{}[]", type_name))),
+            format!(
+                r#"
+  let value = store.loadRelated(this._entity, this._id, this._field);
+  return changetype<{}[]>(value);"#,
+                type_name
+            ),
+        ));
+
+        klass
+    }
+
+    /// Get the value type string for a field.
+    ///
+    /// Returns the GraphQL-style value type string:
+    /// - Scalars: `String`, `Int`, `BigInt`, etc.
+    /// - Arrays: `[String]`, `[Int]`, etc.
+    /// - Nested arrays: `[[String]]`, `[[Int]]`, etc.
+    /// - Entity references are converted to the referenced entity's ID type
+    fn value_type_from_field(&self, field: &FieldInfo) -> String {
+        let base = if let Some(id_kind) = self.entity_id_kinds.get(&field.base_type) {
+            id_kind.gql_type_name().to_string()
+        } else {
+            field.base_type.clone()
+        };
+
+        // Wrap with brackets for each level of list nesting
+        let mut result = base;
+        for _ in 0..field.list_depth {
+            result = format!("[{}]", result);
+        }
+        result
+    }
+
+    /// Convert field info to an AssemblyScript TypeExpr.
+    ///
+    /// Creates the correct type expression including nested arrays:
+    /// - Scalars: `string`, `i32`, `BigInt`, etc.
+    /// - Arrays: `Array<string>`, `Array<i32>`, etc.
+    /// - Nested arrays: `Array<Array<string>>`, etc.
+    fn type_from_field(&self, field: &FieldInfo) -> TypeExpr {
+        let type_name = if let Some(id_kind) = self.entity_id_kinds.get(&field.base_type) {
+            id_kind.type_name()
+        } else {
+            asc_type_for_value(&field.base_type)
+        };
+
+        let named = NamedType::new(type_name);
+
+        if field.list_depth > 0 {
+            // Use ArrayType::with_depth to create nested array types
+            let array_type = ArrayType::with_depth(named, field.list_depth);
+            if field.is_nullable {
+                NullableType::new(array_type).into()
+            } else {
+                array_type
+            }
+        } else if field.is_nullable && !named.is_primitive() {
+            NullableType::new(named).into()
+        } else {
+            named.into()
+        }
+    }
+}
+
+enum StoreMethod {
+    Regular(Method),
+    Static(StaticMethod),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use graphql_tools::parser::parse_schema;
+
+    #[test]
+    fn test_simple_entity() {
+        let schema = r#"
+            type Transfer @entity {
+                id: ID!
+                from: Bytes!
+                to: Bytes!
+                value: BigInt!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        assert_eq!(classes.len(), 1);
+
+        let transfer = &classes[0];
+        assert_eq!(transfer.name, "Transfer");
+        assert_eq!(transfer.extends, Some("Entity".to_string()));
+        assert!(transfer.export);
+    }
+
+    #[test]
+    fn test_nullable_field() {
+        let schema = r#"
+            type Token @entity {
+                id: ID!
+                name: String
+                symbol: String!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        assert_eq!(classes.len(), 1);
+
+        // Check that we have methods for nullable and non-nullable fields
+        let token = &classes[0];
+        let method_names: Vec<_> = token.methods.iter().map(|m| m.name.as_str()).collect();
+        assert!(method_names.contains(&"get name"));
+        assert!(method_names.contains(&"set name"));
+        assert!(method_names.contains(&"get symbol"));
+        assert!(method_names.contains(&"set symbol"));
+    }
+
+    #[test]
+    fn test_id_field_types() {
+        assert_eq!(IdFieldKind::String.type_name(), "string");
+        assert_eq!(IdFieldKind::Bytes.type_name(), "Bytes");
+        assert_eq!(IdFieldKind::Int8.type_name(), "i64");
+    }
+
+    #[test]
+    fn test_auto_increment_support() {
+        // String IDs don't support auto-increment
+        assert!(!IdFieldKind::String.supports_auto());
+        assert!(IdFieldKind::String.constructor_default().is_none());
+
+        // Int8 IDs support auto-increment
+        assert!(IdFieldKind::Int8.supports_auto());
+        assert_eq!(IdFieldKind::Int8.constructor_param_type(), "i64");
+        assert_eq!(
+            IdFieldKind::Int8.constructor_default(),
+            Some("i64.MIN_VALUE")
+        );
+        assert_eq!(
+            IdFieldKind::Int8.auto_check_condition(),
+            "id != i64.MIN_VALUE"
+        );
+
+        // Bytes IDs support auto-increment
+        assert!(IdFieldKind::Bytes.supports_auto());
+        assert_eq!(IdFieldKind::Bytes.constructor_param_type(), "Bytes | null");
+        assert_eq!(IdFieldKind::Bytes.constructor_default(), Some("null"));
+        assert_eq!(IdFieldKind::Bytes.auto_check_condition(), "id");
+    }
+
+    #[test]
+    fn test_int8_id_auto_increment_codegen() {
+        let schema = r#"
+            type Counter @entity {
+                id: Int8!
+                value: BigInt!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        assert_eq!(classes.len(), 1);
+
+        let counter = &classes[0];
+        let output = counter.to_string();
+
+        // Constructor should have optional id with sentinel default
+        assert!(
+            output.contains("constructor(id: i64 = i64.MIN_VALUE)"),
+            "Int8 ID constructor should have default sentinel value, got: {}",
+            output
+        );
+
+        // Constructor should have doc comment
+        assert!(
+            output.contains("Leaving out the id argument uses an autoincrementing id"),
+            "Constructor should have auto-increment doc comment"
+        );
+
+        // Constructor body should conditionally set id
+        assert!(
+            output.contains("if (id != i64.MIN_VALUE)"),
+            "Constructor should check for sentinel value"
+        );
+
+        // save() method should use "auto" when id is null
+        assert!(
+            output.contains("store.set('Counter', 'auto', this)"),
+            "save() should use 'auto' key for auto-increment, got: {}",
+            output
+        );
+    }
+
+    #[test]
+    fn test_bytes_id_auto_increment_codegen() {
+        let schema = r#"
+            type Event @entity {
+                id: Bytes!
+                data: String!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        assert_eq!(classes.len(), 1);
+
+        let event = &classes[0];
+        let output = event.to_string();
+
+        // Constructor should have nullable id with null default
+        assert!(
+            output.contains("constructor(id: Bytes | null = null)"),
+            "Bytes ID constructor should have null default, got: {}",
+            output
+        );
+
+        // Constructor should have doc comment
+        assert!(
+            output.contains("Leaving out the id argument uses an autoincrementing id"),
+            "Constructor should have auto-increment doc comment"
+        );
+
+        // Constructor body should conditionally set id
+        assert!(
+            output.contains("if (id)"),
+            "Constructor should check for null"
+        );
+
+        // save() method should use "auto" when id is null
+        assert!(
+            output.contains("store.set('Event', 'auto', this)"),
+            "save() should use 'auto' key for auto-increment, got: {}",
+            output
+        );
+    }
+
+    #[test]
+    fn test_string_id_no_auto_increment() {
+        let schema = r#"
+            type User @entity {
+                id: ID!
+                name: String!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        assert_eq!(classes.len(), 1);
+
+        let user = &classes[0];
+        let output = user.to_string();
+
+        // Constructor should have required id (no default)
+        assert!(
+            output.contains("constructor(id: string)"),
+            "String ID constructor should have required parameter, got: {}",
+            output
+        );
+
+        // Constructor should NOT have auto-increment doc comment
+        assert!(
+            !output.contains("autoincrementing"),
+            "String ID should not mention auto-increment"
+        );
+
+        // save() method should NOT use "auto"
+        assert!(
+            !output.contains("'auto'"),
+            "String ID save() should not use 'auto' key"
+        );
+
+        // save() should require ID
+        assert!(
+            output.contains("Cannot save User entity without an ID"),
+            "String ID save() should require ID"
+        );
+    }
+
+    #[test]
+    fn test_entity_reference() {
+        let schema = r#"
+            type User @entity {
+                id: ID!
+                name: String!
+            }
+            type Post @entity {
+                id: ID!
+                author: User!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        // The Post.author field should be treated as a string (entity ID reference)
+        assert!(generator.entity_names.contains("User"));
+        assert!(generator.entity_names.contains("Post"));
+    }
+
+    #[test]
+    fn test_simple_array_field() {
+        let schema = r#"
+            type Token @entity {
+                id: ID!
+                holders: [String!]!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        assert_eq!(classes.len(), 1);
+
+        let token = &classes[0];
+        let output = token.to_string();
+
+        // Verify array field getter/setter are generated
+        assert!(
+            output.contains("get holders()"),
+            "Should have holders getter"
+        );
+        assert!(
+            output.contains("set holders("),
+            "Should have holders setter"
+        );
+
+        // Check the type is Array<string>
+        assert!(
+            output.contains("Array<string>"),
+            "Array field should use Array<string> type"
+        );
+    }
+
+    #[test]
+    fn test_nested_array_field() {
+        let schema = r#"
+            type Matrix @entity {
+                id: ID!
+                stringMatrix: [[String!]!]!
+                intMatrix: [[Int!]!]
+                bigIntMatrix: [[BigInt!]!]!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        assert_eq!(classes.len(), 1);
+
+        let matrix = &classes[0];
+        let output = matrix.to_string();
+
+        // Verify nested array field getter/setter are generated
+        assert!(
+            output.contains("get stringMatrix()"),
+            "Should have stringMatrix getter"
+        );
+        assert!(
+            output.contains("set stringMatrix("),
+            "Should have stringMatrix setter"
+        );
+
+        // Check the type is Array<Array<string>>
+        assert!(
+            output.contains("Array<Array<string>>"),
+            "Nested array field should use Array<Array<string>> type, got: {}",
+            output
+        );
+
+        // Check that toStringMatrix() and fromStringMatrix() are used
+        assert!(
+            output.contains("toStringMatrix()"),
+            "Should use toStringMatrix() for nested string arrays"
+        );
+        assert!(
+            output.contains("fromStringMatrix("),
+            "Should use Value.fromStringMatrix() for nested string arrays"
+        );
+
+        // Check BigInt matrix uses correct methods
+        assert!(
+            output.contains("Array<Array<BigInt>>"),
+            "BigInt matrix should use Array<Array<BigInt>> type"
+        );
+        assert!(
+            output.contains("toBigIntMatrix()"),
+            "Should use toBigIntMatrix() for nested BigInt arrays"
+        );
+        assert!(
+            output.contains("fromBigIntMatrix("),
+            "Should use Value.fromBigIntMatrix() for nested BigInt arrays"
+        );
+
+        // Check nullable nested array has correct type
+        assert!(
+            output.contains("Array<Array<i32>> | null"),
+            "Nullable nested array should be Array<Array<i32>> | null"
+        );
+    }
+
+    #[test]
+    fn test_list_depth() {
+        use graphql_tools::parser::parse_schema;
+
+        // Helper to get list depth from schema field type
+        fn get_field_list_depth(schema_str: &str) -> u8 {
+            let doc = parse_schema::<String>(schema_str).unwrap();
+            for def in &doc.definitions {
+                if let Definition::TypeDefinition(TypeDefinition::Object(obj)) = def {
+                    for field in &obj.fields {
+                        if field.name == "field" {
+                            return list_depth(&field.field_type);
+                        }
+                    }
+                }
+            }
+            panic!("Field not found");
+        }
+
+        // Scalar
+        assert_eq!(
+            get_field_list_depth("type T @entity { id: ID!, field: String! }"),
+            0
+        );
+
+        // Simple array
+        assert_eq!(
+            get_field_list_depth("type T @entity { id: ID!, field: [String!]! }"),
+            1
+        );
+
+        // Nested array (matrix)
+        assert_eq!(
+            get_field_list_depth("type T @entity { id: ID!, field: [[String!]!]! }"),
+            2
+        );
+
+        // Triple nested array
+        assert_eq!(
+            get_field_list_depth("type T @entity { id: ID!, field: [[[String!]!]!]! }"),
+            3
+        );
+    }
+
+    #[test]
+    fn test_value_type_from_field_nested() {
+        let schema = r#"
+            type Test @entity {
+                id: ID!
+                scalar: String!
+                array: [String!]!
+                matrix: [[String!]!]!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        // Find the entity
+        let entity = &generator.entities[0];
+
+        // Find each field and check its value type
+        let scalar_field = entity.fields.iter().find(|f| f.name == "scalar").unwrap();
+        let array_field = entity.fields.iter().find(|f| f.name == "array").unwrap();
+        let matrix_field = entity.fields.iter().find(|f| f.name == "matrix").unwrap();
+
+        assert_eq!(generator.value_type_from_field(scalar_field), "String");
+        assert_eq!(generator.value_type_from_field(array_field), "[String]");
+        assert_eq!(generator.value_type_from_field(matrix_field), "[[String]]");
+    }
+
+    #[test]
+    fn test_bytes_id_entity_reference() {
+        let schema = r#"
+            type Token @entity {
+                id: Bytes!
+                name: String!
+            }
+            type Balance @entity {
+                id: ID!
+                token: Token!
+                amount: BigInt!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        let balance = classes.iter().find(|c| c.name == "Balance").unwrap();
+        let output = balance.to_string();
+
+        // Getter should return Bytes and use toBytes()
+        assert!(
+            output.contains("value.toBytes()"),
+            "Bytes-ID entity reference getter should use toBytes(), got: {}",
+            output
+        );
+
+        // Setter should use Value.fromBytes()
+        assert!(
+            output.contains("Value.fromBytes("),
+            "Bytes-ID entity reference setter should use Value.fromBytes(), got: {}",
+            output
+        );
+
+        // Return type should be Bytes, not string
+        assert!(
+            output.contains("get token(): Bytes"),
+            "Bytes-ID entity reference getter should return Bytes, got: {}",
+            output
+        );
+    }
+
+    #[test]
+    fn test_int8_id_entity_reference() {
+        let schema = r#"
+            type Counter @entity {
+                id: Int8!
+                value: BigInt!
+            }
+            type Snapshot @entity {
+                id: ID!
+                counter: Counter!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        let snapshot = classes.iter().find(|c| c.name == "Snapshot").unwrap();
+        let output = snapshot.to_string();
+
+        // Getter should return i64 and use toI64()
+        assert!(
+            output.contains("value.toI64()"),
+            "Int8-ID entity reference getter should use toI64(), got: {}",
+            output
+        );
+
+        // Setter should use Value.fromI64()
+        assert!(
+            output.contains("Value.fromI64("),
+            "Int8-ID entity reference setter should use Value.fromI64(), got: {}",
+            output
+        );
+
+        // Return type should be i64
+        assert!(
+            output.contains("get counter(): i64"),
+            "Int8-ID entity reference getter should return i64, got: {}",
+            output
+        );
+    }
+
+    #[test]
+    fn test_mixed_id_entity_references() {
+        let schema = r#"
+            type User @entity {
+                id: ID!
+                name: String!
+            }
+            type Token @entity {
+                id: Bytes!
+                owner: User!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        let token = classes.iter().find(|c| c.name == "Token").unwrap();
+        let output = token.to_string();
+
+        // Token.owner references User which has String ID
+        assert!(
+            output.contains("get owner(): string"),
+            "Reference to String-ID entity should use string type, got: {}",
+            output
+        );
+        assert!(
+            output.contains("value.toString()"),
+            "Reference to String-ID entity should use toString(), got: {}",
+            output
+        );
+    }
+
+    #[test]
+    fn test_nullable_bytes_id_entity_reference() {
+        let schema = r#"
+            type Token @entity {
+                id: Bytes!
+                name: String!
+            }
+            type Balance @entity {
+                id: ID!
+                token: Token
+                amount: BigInt!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        let balance = classes.iter().find(|c| c.name == "Balance").unwrap();
+        let output = balance.to_string();
+
+        // Nullable Bytes reference should be `Bytes | null`
+        assert!(
+            output.contains("get token(): Bytes | null"),
+            "Nullable Bytes-ID reference should return Bytes | null, got: {}",
+            output
+        );
+    }
+
+    #[test]
+    fn test_derived_field_with_bytes_id_parent() {
+        let schema = r#"
+            type Token @entity {
+                id: Bytes!
+                balances: [Balance!]! @derivedFrom(field: "token")
+            }
+            type Balance @entity {
+                id: ID!
+                token: Token!
+                amount: BigInt!
+            }
+        "#;
+        let doc = parse_schema::<String>(schema).unwrap();
+        let generator = SchemaCodeGenerator::new(&doc).unwrap();
+
+        let classes = generator.generate_types(true);
+        let token = classes.iter().find(|c| c.name == "Token").unwrap();
+        let output = token.to_string();
+
+        // Derived field getter on Bytes-ID entity should use toBytes().toHexString()
+        assert!(
+            output.contains("this.get('id')!.toBytes().toHexString()"),
+            "Derived field on Bytes-ID entity should use toBytes().toHexString(), got: {}",
+            output
+        );
+    }
+}
diff --git a/gnd/src/codegen/template.rs b/gnd/src/codegen/template.rs
new file mode 100644
index 00000000000..72a27f9e733
--- /dev/null
+++ b/gnd/src/codegen/template.rs
@@ -0,0 +1,286 @@
+//! Data source template code generation.
+//!
+//! Generates AssemblyScript classes for subgraph templates that allow
+//! dynamic data source creation at runtime.
+
+use super::typescript::{self as ts, Class, ModuleImports, Param, StaticMethod};
+
+/// The kind of a data source template.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TemplateKind {
+    /// Ethereum contract template
+    Ethereum,
+    /// IPFS file template
+    FileIpfs,
+    /// Arweave file template
+    FileArweave,
+}
+
+impl TemplateKind {
+    /// Parse a template kind from a string (e.g., "ethereum/contract", "file/ipfs").
+    pub fn from_str_kind(kind: &str) -> Option<Self> {
+        match kind {
+            "ethereum/contract" | "ethereum" => Some(TemplateKind::Ethereum),
+            "file/ipfs" => Some(TemplateKind::FileIpfs),
+            "file/arweave" => Some(TemplateKind::FileArweave),
+            _ => None,
+        }
+    }
+}
+
+/// A data source template from the subgraph manifest.
+pub struct Template {
+    /// The name of the template.
+    pub name: String,
+    /// The kind of template.
+    pub kind: TemplateKind,
+}
+
+impl Template {
+    /// Create a new template.
+    pub fn new(name: impl Into<String>, kind: TemplateKind) -> Self {
+        Self {
+            name: name.into(),
+            kind,
+        }
+    }
+}
+
+const GRAPH_TS_MODULE: &str = "@graphprotocol/graph-ts";
+
+/// Template code generator.
+pub struct TemplateCodeGenerator {
+    templates: Vec<Template>,
+}
+
+impl TemplateCodeGenerator {
+    /// Create a new template code generator.
+    pub fn new(templates: Vec<Template>) -> Self {
+        Self { templates }
+    }
+
+    /// Generate module imports for templates.
+    pub fn generate_module_imports(&self) -> Vec<ModuleImports> {
+        if self.templates.is_empty() {
+            return vec![];
+        }
+
+        let mut imports = vec![
+            "DataSourceTemplate".to_string(),
+            "DataSourceContext".to_string(),
+        ];
+
+        // Add Address if any Ethereum templates exist
+        if self
+            .templates
+            .iter()
+            .any(|t| t.kind == TemplateKind::Ethereum)
+        {
+            imports.push("Address".to_string());
+        }
+
+        vec![ModuleImports::new(imports, GRAPH_TS_MODULE)]
+    }
+
+    /// Generate all template classes.
+    pub fn generate_types(&self) -> Vec<Class> {
+        self.templates
+            .iter()
+            .map(|t| self.generate_type(t))
+            .collect()
+    }
+
+    /// Generate a single template class.
+    fn generate_type(&self, template: &Template) -> Class {
+        let mut klass = ts::klass(&template.name)
+            .exported()
+            .extends("DataSourceTemplate");
+
+        klass.add_static_method(self.generate_create_method(template));
+        klass.add_static_method(self.generate_create_with_context_method(template));
+
+        klass
+    }
+
+    /// Generate the static `create` method.
+    fn generate_create_method(&self, template: &Template) -> StaticMethod {
+        match template.kind {
+            TemplateKind::Ethereum => StaticMethod::new(
+                "create",
+                vec![Param::new("address", ts::NamedType::new("Address"))],
+                ts::NamedType::new("void"),
+                format!(
+                    "\n      DataSourceTemplate.create('{}', [address.toHex()])\n      ",
+                    template.name
+                ),
+            ),
+            TemplateKind::FileIpfs | TemplateKind::FileArweave => StaticMethod::new(
+                "create",
+                vec![Param::new("cid", ts::NamedType::new("string"))],
+                ts::NamedType::new("void"),
+                format!(
+                    "\n      DataSourceTemplate.create('{}', [cid])\n      ",
+                    template.name
+                ),
+            ),
+        }
+    }
+
+    /// Generate the static `createWithContext` method.
+    fn generate_create_with_context_method(&self, template: &Template) -> StaticMethod {
+        match template.kind {
+            TemplateKind::Ethereum => StaticMethod::new(
+                "createWithContext",
+                vec![
+                    Param::new("address", ts::NamedType::new("Address")),
+                    Param::new("context", ts::NamedType::new("DataSourceContext")),
+                ],
+                ts::NamedType::new("void"),
+                format!(
+                    "\n      DataSourceTemplate.createWithContext('{}', [address.toHex()], context)\n      ",
+                    template.name
+                ),
+            ),
+            TemplateKind::FileIpfs | TemplateKind::FileArweave => StaticMethod::new(
+                "createWithContext",
+                vec![
+                    Param::new("cid", ts::NamedType::new("string")),
+                    Param::new("context", ts::NamedType::new("DataSourceContext")),
+                ],
+                ts::NamedType::new("void"),
+                format!(
+                    "\n      DataSourceTemplate.createWithContext('{}', [cid], context)\n      ",
+                    template.name
+                ),
+            ),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn test_template_kind_parsing() {
+        assert_eq!(
+            TemplateKind::from_str_kind("ethereum/contract"),
+            Some(TemplateKind::Ethereum)
+        );
+        assert_eq!(
+            TemplateKind::from_str_kind("ethereum"),
+            Some(TemplateKind::Ethereum)
+        );
+        assert_eq!(
+            TemplateKind::from_str_kind("file/ipfs"),
+            Some(TemplateKind::FileIpfs)
+        );
+        assert_eq!(
+            TemplateKind::from_str_kind("file/arweave"),
+            Some(TemplateKind::FileArweave)
+        );
+        assert_eq!(TemplateKind::from_str_kind("unknown"), None);
+    }
+
+    #[test]
+    fn test_ethereum_template() {
+        let template = Template::new("DynamicToken", TemplateKind::Ethereum);
+        let generator = TemplateCodeGenerator::new(vec![template]);
+
+        let imports = generator.generate_module_imports();
+        assert_eq!(imports.len(), 1);
+        let import_names: Vec<_> = imports[0].names.iter().collect();
+        assert!(import_names.contains(&&"DataSourceTemplate".to_string()));
+        assert!(import_names.contains(&&"DataSourceContext".to_string()));
+        assert!(import_names.contains(&&"Address".to_string()));
+
+        let types = generator.generate_types();
+        assert_eq!(types.len(), 1);
+
+        let klass = &types[0];
+        assert_eq!(klass.name, "DynamicToken");
+        assert!(klass.export);
+        assert_eq!(klass.extends, Some("DataSourceTemplate".to_string()));
+        assert_eq!(klass.static_methods.len(), 2);
+
+        // Check create method
+        let create = &klass.static_methods[0];
+        assert_eq!(create.name, "create");
+        assert_eq!(create.params.len(), 1);
+        assert_eq!(create.params[0].name, "address");
+
+        // Check createWithContext method
+        let create_ctx = &klass.static_methods[1];
+        assert_eq!(create_ctx.name, "createWithContext");
+        assert_eq!(create_ctx.params.len(), 2);
+    }
+
+    #[test]
+    fn test_file_ipfs_template() {
+        let template = Template::new("TokenMetadata", TemplateKind::FileIpfs);
+        let generator = TemplateCodeGenerator::new(vec![template]);
+
+        let imports = generator.generate_module_imports();
+        assert_eq!(imports.len(), 1);
+        let import_names: Vec<_> = imports[0].names.iter().collect();
+        assert!(import_names.contains(&&"DataSourceTemplate".to_string()));
+        assert!(import_names.contains(&&"DataSourceContext".to_string()));
+        // No Address for file templates
+        assert!(!import_names.contains(&&"Address".to_string()));
+
+        let types = generator.generate_types();
+        assert_eq!(types.len(), 1);
+
+        let klass = &types[0];
+        assert_eq!(klass.name, "TokenMetadata");
+
+        // Check create method uses cid parameter
+        let create = &klass.static_methods[0];
+        assert_eq!(create.params[0].name, "cid");
+        assert!(create.body.contains("[cid]"));
+    }
+
+    #[test]
+    fn test_mixed_templates() {
+        let templates = vec![
+            Template::new("DynamicToken", TemplateKind::Ethereum),
+            Template::new("TokenMetadata", TemplateKind::FileIpfs),
+        ];
+        let generator = TemplateCodeGenerator::new(templates);
+
+        let imports = generator.generate_module_imports();
+        // Should have Address because of Ethereum template
+        let import_names: Vec<_> = imports[0].names.iter().collect();
+        assert!(import_names.contains(&&"Address".to_string()));
+
+        let types = generator.generate_types();
+        assert_eq!(types.len(), 2);
+    }
+
+    #[test]
+    fn test_empty_templates() {
+        let generator = TemplateCodeGenerator::new(vec![]);
+        assert!(generator.generate_module_imports().is_empty());
+        assert!(generator.generate_types().is_empty());
+    }
+
+    #[test]
+    fn test_generated_output() {
+        let template = Template::new("DynamicToken", TemplateKind::Ethereum);
+        let generator = TemplateCodeGenerator::new(vec![template]);
+
+        let types = generator.generate_types();
+        let output = types[0].to_string();
+
+        assert!(output.contains("export class DynamicToken extends DataSourceTemplate"));
+        assert!(output.contains("static create(address: Address): void"));
+        assert!(output.contains("DataSourceTemplate.create('DynamicToken', [address.toHex()])"));
+        assert!(output.contains(
+            "static createWithContext(address: Address, context: DataSourceContext): void"
+        ));
+        assert!(output.contains(
+            "DataSourceTemplate.createWithContext('DynamicToken', [address.toHex()], context)"
+        ));
+    }
+}
diff --git a/gnd/src/codegen/types.rs b/gnd/src/codegen/types.rs
new file mode 100644
index 00000000000..faeccbe772b
--- /dev/null
+++ b/gnd/src/codegen/types.rs
@@ -0,0 +1,297 @@
+//! Type conversion utilities for code generation.
+//!
+//! This module handles conversions between:
+//! - GraphQL schema types and AssemblyScript types
+//! - Ethereum ABI types and AssemblyScript types
+//! - graph-node Value types and AssemblyScript types
+
+/// Get the AssemblyScript type for a GraphQL Value type.
+///
+/// Supports scalar types, arrays, and nested arrays (matrices).
+/// Value types use bracket notation: `String`, `[String]`, `[[String]]`
+pub fn asc_type_for_value(value_type: &str) -> &'static str {
+    match value_type {
+        // Scalar types
+        "Bytes" => "Bytes",
+        "Boolean" => "boolean",
+        "Int" => "i32",
+        "Int8" => "i64",
+        "BigInt" => "BigInt",
+        "ID" | "String" => "string",
+        "BigDecimal" => "BigDecimal",
+        "Timestamp" => "i64",
+        // Array types (single dimension)
+        "[Bytes]" => "Array<Bytes>",
+        "[Boolean]" => "Array<boolean>",
+        "[Int]" => "Array<i32>",
+        "[Int8]" => "Array<i64>",
+        "[Timestamp]" => "Array<i64>",
+        "[BigInt]" => "Array<BigInt>",
+        "[ID]" | "[String]" => "Array<string>",
+        "[BigDecimal]" => "Array<BigDecimal>",
+        // Matrix types (nested arrays - 2D)
+        "[[Bytes]]" => "Array<Array<Bytes>>",
+        "[[Boolean]]" => "Array<Array<boolean>>",
+        "[[Int]]" => "Array<Array<i32>>",
+        "[[Int8]]" => "Array<Array<i64>>",
+        "[[Timestamp]]" => "Array<Array<i64>>",
+        "[[BigInt]]" => "Array<Array<BigInt>>",
+        "[[ID]]" | "[[String]]" => "Array<Array<string>>",
+        "[[BigDecimal]]" => "Array<Array<BigDecimal>>",
+        // Default for entity references and unknown types
+        _ => {
+            if value_type.starts_with("[[") && value_type.ends_with("]]") {
+                "Array<Array<string>>" // Entity reference matrices
+            } else if value_type.starts_with('[') && value_type.ends_with(']') {
+                "Array<string>" // Entity reference arrays
+            } else {
+                "string" // Entity references
+            }
+        }
+    }
+}
+
+/// Generate code to convert a Value to AssemblyScript.
+///
+/// Supports scalar types, arrays, and nested arrays (matrices).
+pub fn value_to_asc(code: &str, value_type: &str) -> String {
+    match value_type {
+        // Scalar types
+        "Bytes" => format!("{}.toBytes()", code),
+        "Boolean" => format!("{}.toBoolean()", code),
+        "Int" => format!("{}.toI32()", code),
+        "Int8" => format!("{}.toI64()", code),
+        "BigInt" => format!("{}.toBigInt()", code),
+        "ID" | "String" => format!("{}.toString()", code),
+        "BigDecimal" => format!("{}.toBigDecimal()", code),
+        "Timestamp" => format!("{}.toTimestamp()", code),
+        // Array types (single dimension)
+        "[Bytes]" => format!("{}.toBytesArray()", code),
+        "[Boolean]" => format!("{}.toBooleanArray()", code),
+        "[Int]" => format!("{}.toI32Array()", code),
+        "[Int8]" => format!("{}.toI64Array()", code),
+        "[Timestamp]" => format!("{}.toTimestampArray()", code),
+        "[BigInt]" => format!("{}.toBigIntArray()", code),
+        "[ID]" | "[String]" => format!("{}.toStringArray()", code),
+        "[BigDecimal]" => format!("{}.toBigDecimalArray()", code),
+        // Matrix types (nested arrays - 2D)
+        "[[Bytes]]" => format!("{}.toBytesMatrix()", code),
+        "[[Boolean]]" => format!("{}.toBooleanMatrix()", code),
+        "[[Int]]" => format!("{}.toI32Matrix()", code),
+        "[[Int8]]" => format!("{}.toI64Matrix()", code),
+        "[[Timestamp]]" => format!("{}.toTimestampMatrix()", code),
+        "[[BigInt]]" => format!("{}.toBigIntMatrix()", code),
+        "[[ID]]" | "[[String]]" => format!("{}.toStringMatrix()", code),
+        "[[BigDecimal]]" => format!("{}.toBigDecimalMatrix()", code),
+        // Default for entity references
+        _ => {
+            if value_type.starts_with("[[") {
+                format!("{}.toStringMatrix()", code)
+            } else if value_type.starts_with('[') {
+                format!("{}.toStringArray()", code)
+            } else {
+                format!("{}.toString()", code)
+            }
+        }
+    }
+}
+
+/// Generate code to convert an AssemblyScript value to a Value.
+///
+/// Supports scalar types, arrays, and nested arrays (matrices).
+pub fn value_from_asc(code: &str, value_type: &str) -> String {
+    match value_type {
+        // Scalar types
+        "Bytes" => format!("Value.fromBytes({})", code),
+        "Boolean" => format!("Value.fromBoolean({})", code),
+        "Int" => format!("Value.fromI32({})", code),
+        "Int8" => format!("Value.fromI64({})", code),
+        "BigInt" => format!("Value.fromBigInt({})", code),
+        "ID" | "String" => format!("Value.fromString({})", code),
+        "BigDecimal" => format!("Value.fromBigDecimal({})", code),
+        "Timestamp" => format!("Value.fromTimestamp({})", code),
+        // Array types (single dimension)
+        "[Bytes]" => format!("Value.fromBytesArray({})", code),
+        "[Boolean]" => format!("Value.fromBooleanArray({})", code),
+        "[Int]" => format!("Value.fromI32Array({})", code),
+        "[Int8]" => format!("Value.fromI64Array({})", code),
+        "[Timestamp]" => format!("Value.fromTimestampArray({})", code),
+        "[BigInt]" => format!("Value.fromBigIntArray({})", code),
+        "[ID]" | "[String]" => format!("Value.fromStringArray({})", code),
+        "[BigDecimal]" => format!("Value.fromBigDecimalArray({})", code),
+        // Matrix types (nested arrays - 2D)
+        "[[Bytes]]" => format!("Value.fromBytesMatrix({})", code),
+        "[[Boolean]]" => format!("Value.fromBooleanMatrix({})", code),
+        "[[Int]]" => format!("Value.fromI32Matrix({})", code),
+        "[[Int8]]" => format!("Value.fromI64Matrix({})", code),
+        "[[Timestamp]]" => format!("Value.fromTimestampMatrix({})", code),
+        "[[BigInt]]" => format!("Value.fromBigIntMatrix({})", code),
+        "[[ID]]" | "[[String]]" => format!("Value.fromStringMatrix({})", code),
+        "[[BigDecimal]]" => format!("Value.fromBigDecimalMatrix({})", code),
+        // Default for entity references
+        _ => {
+            if value_type.starts_with("[[") {
+                format!("Value.fromStringMatrix({})", code)
+            } else if value_type.starts_with('[') {
+                format!("Value.fromStringArray({})", code)
+            } else {
+                format!("Value.fromString({})", code)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_asc_type_for_value() {
+        // Scalar types
+        assert_eq!(asc_type_for_value("String"), "string");
+        assert_eq!(asc_type_for_value("ID"), "string");
+        assert_eq!(asc_type_for_value("Int"), "i32");
+        assert_eq!(asc_type_for_value("BigInt"), "BigInt");
+        assert_eq!(asc_type_for_value("Bytes"), "Bytes");
+        assert_eq!(asc_type_for_value("Boolean"), "boolean");
+        assert_eq!(asc_type_for_value("BigDecimal"), "BigDecimal");
+        assert_eq!(asc_type_for_value("Int8"), "i64");
+        assert_eq!(asc_type_for_value("Timestamp"), "i64");
+
+        // Array types
+        assert_eq!(asc_type_for_value("[String]"), "Array<string>");
+        assert_eq!(asc_type_for_value("[ID]"), "Array<string>");
+        assert_eq!(asc_type_for_value("[Int]"), "Array<i32>");
+        assert_eq!(asc_type_for_value("[BigInt]"), "Array<BigInt>");
+        assert_eq!(asc_type_for_value("[Bytes]"), "Array<Bytes>");
+        assert_eq!(asc_type_for_value("[Boolean]"), "Array<boolean>");
+        assert_eq!(asc_type_for_value("[BigDecimal]"), "Array<BigDecimal>");
+        assert_eq!(asc_type_for_value("[Int8]"), "Array<i64>");
+        assert_eq!(asc_type_for_value("[Timestamp]"), "Array<i64>");
+
+        // Matrix types (nested arrays)
+        assert_eq!(asc_type_for_value("[[String]]"), "Array<Array<string>>");
+        assert_eq!(asc_type_for_value("[[ID]]"), "Array<Array<string>>");
+        assert_eq!(asc_type_for_value("[[Int]]"), "Array<Array<i32>>");
+        assert_eq!(asc_type_for_value("[[BigInt]]"), "Array<Array<BigInt>>");
+        assert_eq!(asc_type_for_value("[[Bytes]]"), "Array<Array<Bytes>>");
+        assert_eq!(asc_type_for_value("[[Boolean]]"), "Array<Array<boolean>>");
+        assert_eq!(
+            asc_type_for_value("[[BigDecimal]]"),
+            "Array<Array<BigDecimal>>"
+        );
+        assert_eq!(asc_type_for_value("[[Int8]]"), "Array<Array<i64>>");
+        assert_eq!(asc_type_for_value("[[Timestamp]]"), "Array<Array<i64>>");
+
+        // Entity references
+        assert_eq!(asc_type_for_value("SomeEntity"), "string");
+        assert_eq!(asc_type_for_value("[SomeEntity]"), "Array<string>");
+        assert_eq!(asc_type_for_value("[[SomeEntity]]"), "Array<Array<string>>");
+    }
+
+    #[test]
+    fn test_value_to_asc() {
+        // Scalar types
+        assert_eq!(value_to_asc("value", "String"), "value.toString()");
+        assert_eq!(value_to_asc("value", "BigInt"), "value.toBigInt()");
+        assert_eq!(value_to_asc("value", "Bytes"), "value.toBytes()");
+        assert_eq!(value_to_asc("value", "Boolean"), "value.toBoolean()");
+        assert_eq!(value_to_asc("value", "Int"), "value.toI32()");
+        assert_eq!(value_to_asc("value", "Int8"), "value.toI64()");
+
+        // Array types
+        assert_eq!(value_to_asc("value", "[Int]"), "value.toI32Array()");
+        assert_eq!(value_to_asc("value", "[String]"), "value.toStringArray()");
+        assert_eq!(value_to_asc("value", "[Bytes]"), "value.toBytesArray()");
+        assert_eq!(value_to_asc("value", "[BigInt]"), "value.toBigIntArray()");
+
+        // Matrix types
+        assert_eq!(value_to_asc("value", "[[Int]]"), "value.toI32Matrix()");
+        assert_eq!(
+            value_to_asc("value", "[[String]]"),
+            "value.toStringMatrix()"
+        );
+        assert_eq!(value_to_asc("value", "[[Bytes]]"), "value.toBytesMatrix()");
+        assert_eq!(
+            value_to_asc("value", "[[BigInt]]"),
+            "value.toBigIntMatrix()"
+        );
+        assert_eq!(
+            value_to_asc("value", "[[Boolean]]"),
+            "value.toBooleanMatrix()"
+        );
+        assert_eq!(value_to_asc("value", "[[Int8]]"), "value.toI64Matrix()");
+        assert_eq!(
+            value_to_asc("value", "[[BigDecimal]]"),
+            "value.toBigDecimalMatrix()"
+        );
+
+        // Entity reference matrices
+        assert_eq!(
+            value_to_asc("value", "[[SomeEntity]]"),
+            "value.toStringMatrix()"
+        );
+    }
+
+    #[test]
+    fn test_value_from_asc() {
+        // Scalar types
+        assert_eq!(value_from_asc("value", "String"), "Value.fromString(value)");
+        assert_eq!(value_from_asc("value", "BigInt"), "Value.fromBigInt(value)");
+        assert_eq!(value_from_asc("value", "Bytes"), "Value.fromBytes(value)");
+        assert_eq!(
+            value_from_asc("value", "Boolean"),
+            "Value.fromBoolean(value)"
+        );
+
+        // Array types
+        assert_eq!(
+            value_from_asc("value", "[Int]"),
+            "Value.fromI32Array(value)"
+        );
+        assert_eq!(
+            value_from_asc("value", "[String]"),
+            "Value.fromStringArray(value)"
+        );
+        assert_eq!(
+            value_from_asc("value", "[BigInt]"),
+            "Value.fromBigIntArray(value)"
+        );
+
+        // Matrix types
+        assert_eq!(
+            value_from_asc("value", "[[Int]]"),
+            "Value.fromI32Matrix(value)"
+        );
+        assert_eq!(
+            value_from_asc("value", "[[String]]"),
+            "Value.fromStringMatrix(value)"
+        );
+        assert_eq!(
+            value_from_asc("value", "[[Bytes]]"),
+            "Value.fromBytesMatrix(value)"
+        );
+        assert_eq!(
+            value_from_asc("value", "[[BigInt]]"),
+            "Value.fromBigIntMatrix(value)"
+        );
+        assert_eq!(
+            value_from_asc("value", "[[Boolean]]"),
+            "Value.fromBooleanMatrix(value)"
+        );
+        assert_eq!(
+            value_from_asc("value", "[[Int8]]"),
+            "Value.fromI64Matrix(value)"
+        );
+        assert_eq!(
+            value_from_asc("value", "[[BigDecimal]]"),
+            "Value.fromBigDecimalMatrix(value)"
+        );
+
+        // Entity reference matrices
+        assert_eq!(
+            value_from_asc("value", "[[SomeEntity]]"),
+            "Value.fromStringMatrix(value)"
+        );
+    }
+}
diff --git a/gnd/src/codegen/typescript.rs b/gnd/src/codegen/typescript.rs
new file mode 100644
index 00000000000..5ed19a9bd1b
--- /dev/null
+++ b/gnd/src/codegen/typescript.rs
@@ -0,0 +1,537 @@
+//! TypeScript/AssemblyScript code generation utilities.
+//!
+//! This module provides builder types for generating TypeScript/AssemblyScript code,
+//! matching the output format of the TS CLI's `codegen/typescript.ts`.
+
+use std::fmt::{self, Display};
+
+/// Note prepended to all generated files.
+pub const GENERATED_FILE_NOTE: &str = r#"
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+"#;
+
+/// A function/method parameter.
+#[derive(Debug, Clone)]
+pub struct Param {
+    pub name: String,
+    pub param_type: Box<TypeExpr>,
+    /// Optional default value for the parameter.
+    pub default_value: Option<String>,
+}
+
+impl Param {
+    pub fn new(name: impl Into<String>, param_type: impl Into<TypeExpr>) -> Self {
+        Self {
+            name: name.into(),
+            param_type: Box::new(param_type.into()),
+            default_value: None,
+        }
+    }
+
+    /// Create a parameter with a default value.
+    pub fn with_default(
+        name: impl Into<String>,
+        param_type: impl Into<TypeExpr>,
+        default: impl Into<String>,
+    ) -> Self {
+        Self {
+            name: name.into(),
+            param_type: Box::new(param_type.into()),
+            default_value: Some(default.into()),
+        }
+    }
+}
+
+impl Display for Param {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.default_value {
+            Some(default) => write!(f, "{}: {} = {}", self.name, self.param_type, default),
+            None => write!(f, "{}: {}", self.name, self.param_type),
+        }
+    }
+}
+
+/// A type expression (named type, array type, or nullable type).
+#[derive(Debug, Clone)]
+pub enum TypeExpr {
+    Named(NamedType),
+    Array(ArrayType),
+    Nullable(NullableType),
+    /// Raw string type (for complex types like `ethereum.CallResult<T>`)
+    Raw(String),
+}
+
+impl From<NamedType> for TypeExpr {
+    fn from(t: NamedType) -> Self {
+        TypeExpr::Named(t)
+    }
+}
+
+impl From<ArrayType> for TypeExpr {
+    fn from(t: ArrayType) -> Self {
+        TypeExpr::Array(t)
+    }
+}
+
+impl From<NullableType> for TypeExpr {
+    fn from(t: NullableType) -> Self {
+        TypeExpr::Nullable(t)
+    }
+}
+
+impl From<&str> for TypeExpr {
+    fn from(s: &str) -> Self {
+        TypeExpr::Named(NamedType::new(s))
+    }
+}
+
+impl From<String> for TypeExpr {
+    fn from(s: String) -> Self {
+        TypeExpr::Named(NamedType::new(s))
+    }
+}
+
+impl Display for TypeExpr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            TypeExpr::Named(t) => write!(f, "{}", t),
+            TypeExpr::Array(t) => write!(f, "{}", t),
+            TypeExpr::Nullable(t) => write!(f, "{}", t),
+            TypeExpr::Raw(s) => write!(f, "{}", s),
+        }
+    }
+}
+
+/// A named type (e.g., `string`, `BigInt`, `MyEntity`).
+#[derive(Debug, Clone)]
+pub struct NamedType {
+    pub name: String,
+}
+
+impl NamedType {
+    pub fn new(name: impl Into<String>) -> Self {
+        Self { name: name.into() }
+    }
+
+    /// Capitalize the first letter of the type name.
+    pub fn capitalize(&mut self) -> &mut Self {
+        if let Some(c) = self.name.chars().next() {
+            self.name = c.to_uppercase().collect::<String>() + &self.name[c.len_utf8()..];
+        }
+        self
+    }
+
+    /// Returns true if this is a primitive AssemblyScript type.
+    pub fn is_primitive(&self) -> bool {
+        matches!(
+            self.name.as_str(),
+            "boolean"
+                | "u8"
+                | "i8"
+                | "u16"
+                | "i16"
+                | "u32"
+                | "i32"
+                | "u64"
+                | "i64"
+                | "f32"
+                | "f64"
+                | "usize"
+                | "isize"
+        )
+    }
+
+    /// Returns the default value for primitive types, or None if not a primitive.
+    pub fn get_primitive_default(&self) -> Option<&'static str> {
+        if !self.is_primitive() {
+            return None;
+        }
+        match self.name.as_str() {
+            "boolean" => Some("false"),
+            "u8" | "i8" | "u16" | "i16" | "u32" | "i32" | "u64" | "i64" | "f32" | "f64"
+            | "usize" | "isize" => Some("0"),
+            _ => None,
+        }
+    }
+}
+
+impl Display for NamedType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.name)
+    }
+}
+
+/// An array type (e.g., `Array<string>` or `Array<Array<string>>`).
+#[derive(Debug, Clone)]
+pub struct ArrayType {
+    pub inner: Box<TypeExpr>,
+}
+
+impl ArrayType {
+    /// Create a new array type from any inner type expression.
+    pub fn new(inner: impl Into<TypeExpr>) -> Self {
+        Self {
+            inner: Box::new(inner.into()),
+        }
+    }
+
+    /// Create a nested array type with the specified nesting depth.
+    /// depth=1 creates `Array<T>`, depth=2 creates `Array<Array<T>>`, etc.
+    pub fn with_depth(inner: impl Into<TypeExpr>, depth: u8) -> TypeExpr {
+        let mut result = inner.into();
+        for _ in 0..depth {
+            result = ArrayType::new(result).into();
+        }
+        result
+    }
+}
+
+impl Display for ArrayType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Array<{}>", self.inner)
+    }
+}
+
+/// A nullable type (e.g., `string | null`).
+#[derive(Debug, Clone)]
+pub struct NullableType {
+    pub inner: Box<TypeExpr>,
+}
+
+impl NullableType {
+    pub fn new(inner: impl Into<TypeExpr>) -> Self {
+        Self {
+            inner: Box::new(inner.into()),
+        }
+    }
+}
+
+impl Display for NullableType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{} | null", self.inner)
+    }
+}
+
+/// A class method.
+#[derive(Debug, Clone)]
+pub struct Method {
+    pub name: String,
+    pub params: Vec<Param>,
+    pub return_type: Option<TypeExpr>,
+    pub body: String,
+    /// Optional documentation comment.
+    pub doc: Option<String>,
+}
+
+impl Method {
+    pub fn new(
+        name: impl Into<String>,
+        params: Vec<Param>,
+        return_type: Option<TypeExpr>,
+        body: impl Into<String>,
+    ) -> Self {
+        Self {
+            name: name.into(),
+            params,
+            return_type,
+            body: body.into(),
+            doc: None,
+        }
+    }
+
+    /// Add a documentation comment to the method.
+    pub fn with_doc(mut self, doc: impl Into<String>) -> Self {
+        self.doc = Some(doc.into());
+        self
+    }
+}
+
+impl Display for Method {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Write doc comment if present
+        if let Some(doc) = &self.doc {
+            writeln!(f)?;
+            writeln!(f, "  /**")?;
+            writeln!(f, "   * {}", doc)?;
+            writeln!(f, "   */")?;
+        }
+        let params = self
+            .params
+            .iter()
+            .map(|p| p.to_string())
+            .collect::<Vec<_>>()
+            .join(", ");
+        let return_type = self
+            .return_type
+            .as_ref()
+            .map(|t| format!(": {}", t))
+            .unwrap_or_default();
+        if self.doc.is_some() {
+            // Already wrote newline for doc
+            write!(
+                f,
+                "  {}({}){} {{{}\n  }}\n",
+                self.name, params, return_type, self.body
+            )
+        } else {
+            write!(
+                f,
+                "\n  {}({}){} {{{}\n  }}\n",
+                self.name, params, return_type, self.body
+            )
+        }
+    }
+}
+
+/// A static class method.
+#[derive(Debug, Clone)]
+pub struct StaticMethod {
+    pub name: String,
+    pub params: Vec<Param>,
+    pub return_type: TypeExpr,
+    pub body: String,
+}
+
+impl StaticMethod {
+    pub fn new(
+        name: impl Into<String>,
+        params: Vec<Param>,
+        return_type: impl Into<TypeExpr>,
+        body: impl Into<String>,
+    ) -> Self {
+        Self {
+            name: name.into(),
+            params,
+            return_type: return_type.into(),
+            body: body.into(),
+        }
+    }
+}
+
+impl Display for StaticMethod {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let params = self
+            .params
+            .iter()
+            .map(|p| p.to_string())
+            .collect::<Vec<_>>()
+            .join(", ");
+        write!(
+            f,
+            "\n  static {}({}): {} {{{}\n  }}\n",
+            self.name, params, self.return_type, self.body
+        )
+    }
+}
+
+/// A class member (field).
+#[derive(Debug, Clone)]
+pub struct ClassMember {
+    pub name: String,
+    pub member_type: String,
+}
+
+impl ClassMember {
+    pub fn new(name: impl Into<String>, member_type: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            member_type: member_type.into(),
+        }
+    }
+}
+
+impl Display for ClassMember {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "  {}: {}", self.name, self.member_type)
+    }
+}
+
+/// Code that can be part of a class body (method or static method).
+#[derive(Debug, Clone)]
+pub enum ClassCode {
+    Method(Method),
+    StaticMethod(StaticMethod),
+}
+
+impl Display for ClassCode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ClassCode::Method(m) => write!(f, "{}", m),
+            ClassCode::StaticMethod(m) => write!(f, "{}", m),
+        }
+    }
+}
+
+/// A TypeScript/AssemblyScript class.
+#[derive(Debug, Clone)]
+pub struct Class {
+    pub name: String,
+    pub extends: Option<String>,
+    pub export: bool,
+    pub members: Vec<ClassMember>,
+    /// Methods in insertion order (regular and static)
+    code: Vec<ClassCode>,
+    // Keep separate vectors for backward compatibility with existing code
+    pub methods: Vec<Method>,
+    pub static_methods: Vec<StaticMethod>,
+}
+
+impl Class {
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            name: name.into(),
+            extends: None,
+            export: false,
+            members: Vec::new(),
+            code: Vec::new(),
+            methods: Vec::new(),
+            static_methods: Vec::new(),
+        }
+    }
+
+    pub fn exported(mut self) -> Self {
+        self.export = true;
+        self
+    }
+
+    pub fn extends(mut self, base: impl Into<String>) -> Self {
+        self.extends = Some(base.into());
+        self
+    }
+
+    pub fn add_member(&mut self, member: ClassMember) {
+        self.members.push(member);
+    }
+
+    pub fn add_method(&mut self, method: Method) {
+        self.code.push(ClassCode::Method(method.clone()));
+        self.methods.push(method);
+    }
+
+    pub fn add_static_method(&mut self, method: StaticMethod) {
+        self.code.push(ClassCode::StaticMethod(method.clone()));
+        self.static_methods.push(method);
+    }
+}
+
+impl Display for Class {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let export = if self.export { "export " } else { "" };
+        let extends = self
+            .extends
+            .as_ref()
+            .map(|e| format!(" extends {}", e))
+            .unwrap_or_default();
+
+        writeln!(f, "\n{}class {}{} {{", export, self.name, extends)?;
+
+        // Write members
+        for member in &self.members {
+            writeln!(f, "{}", member)?;
+        }
+
+        // Write methods in insertion order (maintains graph-cli output order)
+        for code in &self.code {
+            write!(f, "{}", code)?;
+        }
+
+        writeln!(f, "}}")
+    }
+}
+
+/// An import statement.
+#[derive(Debug, Clone)]
+pub struct ModuleImports {
+    pub names: Vec<String>,
+    pub module: String,
+}
+
+impl ModuleImports {
+    pub fn new(names: Vec<String>, module: impl Into<String>) -> Self {
+        Self {
+            names,
+            module: module.into(),
+        }
+    }
+
+    pub fn single(name: impl Into<String>, module: impl Into<String>) -> Self {
+        Self {
+            names: vec![name.into()],
+            module: module.into(),
+        }
+    }
+}
+
+impl Display for ModuleImports {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let names = self.names.join(", ");
+        write!(f, "import {{ {} }} from \"{}\"", names, self.module)
+    }
+}
+
+/// Helper functions matching the TS CLI API.
+pub fn klass(name: impl Into<String>) -> Class {
+    Class::new(name)
+}
+
+pub fn klass_member(name: impl Into<String>, member_type: impl Into<String>) -> ClassMember {
+    ClassMember::new(name, member_type)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    pub fn named_type(name: impl Into<String>) -> NamedType {
+        NamedType::new(name)
+    }
+
+    pub fn param(name: impl Into<String>, param_type: impl Into<TypeExpr>) -> Param {
+        Param::new(name, param_type)
+    }
+
+    pub fn method(
+        name: impl Into<String>,
+        params: Vec<Param>,
+        return_type: Option<TypeExpr>,
+        body: impl Into<String>,
+    ) -> Method {
+        Method::new(name, params, return_type, body)
+    }
+
+    #[test]
+    fn test_method() {
+        let m = method(
+            "save",
+            vec![],
+            Some(named_type("void").into()),
+            "\n    store.set('Entity', this.id, this)\n  ",
+        );
+        let output = m.to_string();
+        assert!(output.contains("save()"));
+        assert!(output.contains(": void"));
+        assert!(output.contains("store.set"));
+    }
+
+    #[test]
+    fn test_class() {
+        let mut c = klass("MyEntity").exported().extends("Entity");
+        c.add_method(method(
+            "constructor",
+            vec![param("id", named_type("string"))],
+            None,
+            "\n    super()\n    this.set('id', Value.fromString(id))\n  ",
+        ));
+        let output = c.to_string();
+        assert!(output.contains("export class MyEntity extends Entity"));
+        assert!(output.contains("constructor(id: string)"));
+    }
+
+    #[test]
+    fn test_is_primitive() {
+        assert!(named_type("boolean").is_primitive());
+        assert!(named_type("i32").is_primitive());
+        assert!(!named_type("string").is_primitive());
+        assert!(!named_type("BigInt").is_primitive());
+    }
+}
diff --git a/gnd/src/commands/add.rs b/gnd/src/commands/add.rs
new file mode 100644
index 00000000000..ef936884dfe
--- /dev/null
+++ b/gnd/src/commands/add.rs
@@ -0,0 +1,736 @@
+//! Add command for adding data sources to existing subgraphs.
+//!
+//! This command adds a new data source to an existing subgraph, generating
+//! the necessary manifest entries, schema types, and mapping stubs.
+
+use std::collections::HashSet;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result, anyhow};
+use clap::Parser;
+use graphql_tools::parser::schema as gql;
+use serde_json::Value as JsonValue;
+
+use crate::config::networks::update_networks_file;
+use crate::formatter::format_typescript;
+use crate::output::{Step, step};
+use crate::scaffold::manifest::{EventInfo, extract_events_from_abi};
+use crate::scaffold::{
+    MAPPING_API_VERSION, ResolvedEvent, ScaffoldOptions, disambiguate_events,
+    generate_event_entity, generate_event_handlers, to_kebab_case,
+};
+use crate::services::ContractService;
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Add a data source to an existing subgraph")]
+pub struct AddOpt {
+    /// Contract address to add
+    #[clap()]
+    pub address: String,
+
+    /// Path to the subgraph manifest
+    #[clap(default_value = "subgraph.yaml")]
+    pub manifest: PathBuf,
+
+    /// Path to the contract ABI
+    #[clap(long)]
+    pub abi: Option<PathBuf>,
+
+    /// Name for the new data source
+    #[clap(long)]
+    pub contract_name: Option<String>,
+
+    /// Merge entities with the same name (off by default)
+    #[clap(long)]
+    pub merge_entities: bool,
+
+    /// Path to the networks.json file
+    #[clap(long, default_value = "networks.json")]
+    pub network_file: PathBuf,
+
+    /// Block number to start indexing from
+    #[clap(long)]
+    pub start_block: Option<String>,
+
+    /// Suppress "Next steps" output (used when called from init loop)
+    #[clap(skip)]
+    pub quiet: bool,
+}
+
+/// Run the add command.
+pub async fn run_add(opt: AddOpt) -> Result<()> {
+    // Validate address format first
+    if !opt.address.starts_with("0x") || opt.address.len() != 42 {
+        return Err(anyhow!(
+            "Invalid contract address '{}'. Expected format: 0x followed by 40 hex characters.",
+            opt.address
+        ));
+    }
+
+    // Check if manifest exists
+    if !opt.manifest.exists() {
+        return Err(anyhow!(
+            "Manifest file '{}' not found. Run 'gnd init' first to create a subgraph.",
+            opt.manifest.display()
+        ));
+    }
+
+    step(
+        Step::Load,
+        &format!("Adding data source for {}", opt.address),
+    );
+
+    // Load existing manifest to get network
+    let manifest_content = fs::read_to_string(&opt.manifest)
+        .with_context(|| format!("Failed to read manifest: {}", opt.manifest.display()))?;
+
+    let manifest: serde_yaml::Value = serde_yaml::from_str(&manifest_content)
+        .with_context(|| format!("Failed to parse manifest: {}", opt.manifest.display()))?;
+
+    // Get network from manifest's first data source
+    let network = manifest
+        .get("dataSources")
+        .and_then(|ds| ds.as_sequence())
+        .and_then(|seq| seq.first())
+        .and_then(|first| first.get("network"))
+        .and_then(|n| n.as_str())
+        .map(String::from)
+        .unwrap_or_else(|| "mainnet".to_string());
+
+    // Fetch or load ABI
+    let (abi, contract_name, start_block) = get_contract_info(&opt, &network).await?;
+
+    // A data source / template name must be unique within the subgraph.
+    if existing_source_names(&manifest).contains(&contract_name) {
+        return Err(anyhow!(
+            "Data source or template named '{}' already exists. Choose a different name with --contract-name.",
+            contract_name
+        ));
+    }
+
+    // Get project directory
+    let project_dir = crate::manifest::manifest_dir(&opt.manifest);
+
+    // Create scaffold options for code generation
+    let scaffold_options = ScaffoldOptions {
+        address: Some(opt.address.clone()),
+        network: network.clone(),
+        contract_name: contract_name.clone(),
+        subgraph_name: "subgraph".to_string(),
+        start_block,
+        abi: Some(abi.clone()),
+        index_events: true, // Always index events for add command
+    };
+
+    // Extract events from the ABI and resolve their names against the entities
+    // already present in the subgraph (handles overloads and collisions). Both
+    // the manifest's entity lists and the types declared in schema.graphql count
+    // as existing, since either can be the source of a name collision.
+    let events = extract_events_from_abi(&scaffold_options);
+    let mut existing = existing_entities(&manifest);
+    existing.extend(schema_entity_types(project_dir, &manifest));
+    let resolved = resolve_events(events, &existing, &contract_name, opt.merge_entities)?;
+
+    // Add ABI file
+    add_abi_file(project_dir, &contract_name, &abi)?;
+
+    // Add mapping file
+    add_mapping_file(project_dir, &contract_name, &resolved)?;
+
+    // Update manifest
+    update_manifest(
+        &opt.manifest,
+        &opt.address,
+        &contract_name,
+        &network,
+        start_block,
+        &resolved,
+    )?;
+
+    // Declare the new event entities in the schema so codegen/build succeed.
+    add_schema_entities(project_dir, &manifest, &resolved)?;
+
+    // Update networks.json if the subgraph uses one.
+    let networks_path = project_dir.join(&opt.network_file);
+    if networks_path.exists() {
+        update_networks_file(
+            &networks_path,
+            &network,
+            &contract_name,
+            &opt.address,
+            start_block,
+        )?;
+        step(
+            Step::Write,
+            &format!("Updated {}", opt.network_file.display()),
+        );
+    }
+
+    step(Step::Done, &format!("Added data source: {}", contract_name));
+
+    if !opt.quiet {
+        println!();
+        println!("Next steps:");
+        println!("  gnd codegen");
+        println!("  gnd build");
+    }
+
+    Ok(())
+}
+
+/// Get contract info (ABI, name, start block) from local file or network.
+async fn get_contract_info(
+    opt: &AddOpt,
+    network: &str,
+) -> Result<(JsonValue, String, Option<u64>)> {
+    if let Some(abi_path) = &opt.abi {
+        // Load ABI from file
+        step(
+            Step::Load,
+            &format!("Loading ABI from {}", abi_path.display()),
+        );
+
+        let abi_str = fs::read_to_string(abi_path)
+            .with_context(|| format!("Failed to read ABI file: {}", abi_path.display()))?;
+
+        let abi: JsonValue = serde_json::from_str(&abi_str)
+            .with_context(|| format!("Failed to parse ABI file: {}", abi_path.display()))?;
+
+        let contract_name = opt.contract_name.clone().unwrap_or_else(|| {
+            abi_path
+                .file_stem()
+                .and_then(|s| s.to_str())
+                .map(|s| s.to_string())
+                .unwrap_or_else(|| "Contract".to_string())
+        });
+
+        let start_block = opt.start_block.as_ref().and_then(|s| s.parse::<u64>().ok());
+
+        Ok((abi, contract_name, start_block))
+    } else {
+        // Fetch from network
+        step(
+            Step::Load,
+            &format!("Fetching ABI from {} network", network),
+        );
+
+        let contract_info = {
+            let service = ContractService::load()
+                .await
+                .context("Failed to load contract service")?;
+
+            service
+                .get_contract_info(network, &opt.address)
+                .await
+                .context("Failed to fetch contract info")?
+        };
+
+        let contract_name = opt.contract_name.clone().unwrap_or(contract_info.name);
+
+        let start_block = opt
+            .start_block
+            .as_ref()
+            .and_then(|s| s.parse::<u64>().ok())
+            .or(contract_info.start_block);
+
+        Ok((contract_info.abi, contract_name, start_block))
+    }
+}
+
+/// Add ABI file to the abis directory.
+fn add_abi_file(project_dir: &Path, contract_name: &str, abi: &JsonValue) -> Result<()> {
+    let abis_dir = project_dir.join("abis");
+    fs::create_dir_all(&abis_dir).context("Failed to create abis directory")?;
+
+    let abi_file = abis_dir.join(format!("{}.json", contract_name));
+    let abi_str = serde_json::to_string_pretty(abi).context("Failed to serialize ABI")?;
+
+    step(
+        Step::Write,
+        &format!("Writing ABI to {}", abi_file.display()),
+    );
+    fs::write(&abi_file, abi_str).context("Failed to write ABI file")?;
+
+    Ok(())
+}
+
+/// Add mapping file for the new data source.
+fn add_mapping_file(
+    project_dir: &Path,
+    contract_name: &str,
+    events: &[ResolvedEvent],
+) -> Result<()> {
+    let src_dir = project_dir.join("src");
+    fs::create_dir_all(&src_dir).context("Failed to create src directory")?;
+
+    let mapping_file = src_dir.join(format!("{}.ts", to_kebab_case(contract_name)));
+
+    if mapping_file.exists() {
+        step(
+            Step::Skip,
+            &format!("Mapping file {} already exists", mapping_file.display()),
+        );
+        return Ok(());
+    }
+
+    let mapping_content = generate_event_handlers(contract_name, events);
+    let formatted = format_typescript(&mapping_content).unwrap_or(mapping_content);
+
+    step(
+        Step::Write,
+        &format!("Writing mapping to {}", mapping_file.display()),
+    );
+    fs::write(&mapping_file, formatted).context("Failed to write mapping file")?;
+
+    Ok(())
+}
+
+/// Collect the names of all existing data sources and templates in the manifest.
+fn existing_source_names(manifest: &serde_yaml::Value) -> HashSet<String> {
+    let mut names = HashSet::new();
+    for key in ["dataSources", "templates"] {
+        if let Some(seq) = manifest.get(key).and_then(|v| v.as_sequence()) {
+            for item in seq {
+                if let Some(name) = item.get("name").and_then(|n| n.as_str()) {
+                    names.insert(name.to_string());
+                }
+            }
+        }
+    }
+    names
+}
+
+/// Collect the entity names already declared by existing data sources / templates.
+fn existing_entities(manifest: &serde_yaml::Value) -> HashSet<String> {
+    let mut entities = HashSet::new();
+    for key in ["dataSources", "templates"] {
+        if let Some(seq) = manifest.get(key).and_then(|v| v.as_sequence()) {
+            for item in seq {
+                if let Some(list) = item
+                    .get("mapping")
+                    .and_then(|m| m.get("entities"))
+                    .and_then(|e| e.as_sequence())
+                {
+                    for entity in list.iter().filter_map(|e| e.as_str()) {
+                        entities.insert(entity.to_string());
+                    }
+                }
+            }
+        }
+    }
+    entities
+}
+
+/// Collect the `@entity` type names declared in the subgraph's schema.graphql.
+///
+/// The schema is the real source of truth for declared types, so a hand-written
+/// `type Foo @entity` that no mapping lists in its `entities` still counts as a
+/// collision. Returns empty on a missing or unparseable schema (falling back to
+/// the manifest's entity lists).
+fn schema_entity_types(project_dir: &Path, manifest: &serde_yaml::Value) -> HashSet<String> {
+    let schema_file = manifest
+        .get("schema")
+        .and_then(|s| s.get("file"))
+        .and_then(|f| f.as_str())
+        .unwrap_or("schema.graphql");
+    let Ok(content) = fs::read_to_string(project_dir.join(schema_file)) else {
+        return HashSet::new();
+    };
+    entity_types_in_schema(&content)
+}
+
+/// Parse GraphQL schema text and return the names of object types marked
+/// `@entity`. Returns empty if the schema does not parse.
+fn entity_types_in_schema(content: &str) -> HashSet<String> {
+    let Ok(ast) = gql::parse_schema::<String>(content) else {
+        return HashSet::new();
+    };
+    ast.definitions
+        .into_iter()
+        .filter_map(|def| match def {
+            gql::Definition::TypeDefinition(gql::TypeDefinition::Object(obj))
+                if obj.directives.iter().any(|d| d.name == "entity") =>
+            {
+                Some(obj.name)
+            }
+            _ => None,
+        })
+        .collect()
+}
+
+/// Resolve event names against the entities already present in the subgraph.
+///
+/// - Events overloaded within this ABI are disambiguated (`Transfer`, `Transfer1`).
+/// - An event whose name collides with an existing entity is either merged into
+///   that entity (`merge_entities`: reuse it, keeping the handler so this
+///   contract's events are still indexed, but don't redeclare the type) or
+///   renamed with the contract prefix so both entities can coexist.
+fn resolve_events(
+    events: Vec<EventInfo>,
+    existing: &HashSet<String>,
+    contract_name: &str,
+    merge_entities: bool,
+) -> Result<Vec<ResolvedEvent>> {
+    let mut resolved = disambiguate_events(events);
+
+    for r in &mut resolved {
+        // Check the name we would actually declare (the disambiguated alias),
+        // not the raw event name, so an overload alias like `Transfer1` that
+        // collides with an existing entity is still caught.
+        if !existing.contains(&r.entity_name) {
+            continue;
+        }
+        if merge_entities {
+            // Reuse the existing entity (entity_name already equals it). Merge is
+            // by name only, so a signature mismatch surfaces at codegen/build.
+            r.declare_in_schema = false;
+        } else {
+            let prefixed = format!("{}{}", contract_name, r.alias);
+            if existing.contains(&prefixed) {
+                return Err(anyhow!(
+                    "Entity '{}' already exists; cannot rename '{}' to avoid a collision. Choose a different contract name.",
+                    prefixed,
+                    r.entity_name
+                ));
+            }
+            r.entity_name = prefixed;
+        }
+    }
+
+    Ok(resolved)
+}
+
+/// Append entity type definitions for the new events to the subgraph schema.
+///
+/// The mapping and manifest reference one entity per event; without this the
+/// referenced types never exist in schema.graphql and codegen/build fail.
+fn add_schema_entities(
+    project_dir: &Path,
+    manifest: &serde_yaml::Value,
+    events: &[ResolvedEvent],
+) -> Result<()> {
+    let mut additions = String::new();
+    for resolved in events {
+        // Reused entities already exist in the schema; don't redeclare them.
+        if !resolved.declare_in_schema {
+            continue;
+        }
+        additions.push('\n');
+        additions.push_str(&generate_event_entity(
+            &resolved.entity_name,
+            &resolved.event.inputs,
+        ));
+        additions.push('\n');
+    }
+
+    if additions.is_empty() {
+        return Ok(());
+    }
+
+    let schema_file = manifest
+        .get("schema")
+        .and_then(|s| s.get("file"))
+        .and_then(|f| f.as_str())
+        .unwrap_or("schema.graphql");
+    let schema_path = project_dir.join(schema_file);
+
+    step(Step::Write, &format!("Updating {}", schema_path.display()));
+
+    use std::io::Write;
+    let mut file = fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&schema_path)
+        .with_context(|| format!("Failed to open schema file: {}", schema_path.display()))?;
+    file.write_all(additions.as_bytes())
+        .context("Failed to append entities to schema")?;
+
+    Ok(())
+}
+
+/// Update the manifest with the new data source.
+fn update_manifest(
+    manifest_path: &Path,
+    address: &str,
+    contract_name: &str,
+    network: &str,
+    start_block: Option<u64>,
+    events: &[ResolvedEvent],
+) -> Result<()> {
+    let content = fs::read_to_string(manifest_path).context("Failed to read manifest")?;
+
+    let mut manifest: serde_yaml::Value =
+        serde_yaml::from_str(&content).context("Failed to parse manifest")?;
+
+    // Build the new data source
+    let mut source = serde_yaml::Mapping::new();
+    source.insert(
+        serde_yaml::Value::String("abi".to_string()),
+        serde_yaml::Value::String(contract_name.to_string()),
+    );
+    source.insert(
+        serde_yaml::Value::String("address".to_string()),
+        serde_yaml::Value::String(address.to_string()),
+    );
+    if let Some(block) = start_block {
+        source.insert(
+            serde_yaml::Value::String("startBlock".to_string()),
+            serde_yaml::Value::Number(block.into()),
+        );
+    }
+
+    // Build event handlers
+    let mut event_handlers = Vec::new();
+    for resolved in events {
+        let mut handler = serde_yaml::Mapping::new();
+        handler.insert(
+            serde_yaml::Value::String("event".to_string()),
+            serde_yaml::Value::String(resolved.event.signature.clone()),
+        );
+        handler.insert(
+            serde_yaml::Value::String("handler".to_string()),
+            serde_yaml::Value::String(format!("handle{}", resolved.alias)),
+        );
+        event_handlers.push(serde_yaml::Value::Mapping(handler));
+    }
+
+    // Build entities list
+    let entities: Vec<serde_yaml::Value> = events
+        .iter()
+        .map(|e| serde_yaml::Value::String(e.entity_name.clone()))
+        .collect();
+
+    // Build ABI entry
+    let mut abi_entry = serde_yaml::Mapping::new();
+    abi_entry.insert(
+        serde_yaml::Value::String("name".to_string()),
+        serde_yaml::Value::String(contract_name.to_string()),
+    );
+    abi_entry.insert(
+        serde_yaml::Value::String("file".to_string()),
+        serde_yaml::Value::String(format!("./abis/{}.json", contract_name)),
+    );
+
+    // Build mapping section
+    let mut mapping = serde_yaml::Mapping::new();
+    mapping.insert(
+        serde_yaml::Value::String("kind".to_string()),
+        serde_yaml::Value::String("ethereum/events".to_string()),
+    );
+    mapping.insert(
+        serde_yaml::Value::String("apiVersion".to_string()),
+        serde_yaml::Value::String(MAPPING_API_VERSION.to_string()),
+    );
+    mapping.insert(
+        serde_yaml::Value::String("language".to_string()),
+        serde_yaml::Value::String("wasm/assemblyscript".to_string()),
+    );
+    mapping.insert(
+        serde_yaml::Value::String("entities".to_string()),
+        serde_yaml::Value::Sequence(entities),
+    );
+    mapping.insert(
+        serde_yaml::Value::String("abis".to_string()),
+        serde_yaml::Value::Sequence(vec![serde_yaml::Value::Mapping(abi_entry)]),
+    );
+    mapping.insert(
+        serde_yaml::Value::String("eventHandlers".to_string()),
+        serde_yaml::Value::Sequence(event_handlers),
+    );
+    mapping.insert(
+        serde_yaml::Value::String("file".to_string()),
+        serde_yaml::Value::String(format!("./src/{}.ts", to_kebab_case(contract_name))),
+    );
+
+    // Build the data source
+    let mut data_source = serde_yaml::Mapping::new();
+    data_source.insert(
+        serde_yaml::Value::String("kind".to_string()),
+        serde_yaml::Value::String("ethereum".to_string()),
+    );
+    data_source.insert(
+        serde_yaml::Value::String("name".to_string()),
+        serde_yaml::Value::String(contract_name.to_string()),
+    );
+    data_source.insert(
+        serde_yaml::Value::String("network".to_string()),
+        serde_yaml::Value::String(network.to_string()),
+    );
+    data_source.insert(
+        serde_yaml::Value::String("source".to_string()),
+        serde_yaml::Value::Mapping(source),
+    );
+    data_source.insert(
+        serde_yaml::Value::String("mapping".to_string()),
+        serde_yaml::Value::Mapping(mapping),
+    );
+
+    // Add to dataSources array
+    let data_sources = manifest
+        .get_mut("dataSources")
+        .and_then(|ds| ds.as_sequence_mut())
+        .ok_or_else(|| anyhow!("Manifest missing dataSources array"))?;
+
+    data_sources.push(serde_yaml::Value::Mapping(data_source));
+
+    // Write back
+    let updated = serde_yaml::to_string(&manifest)?;
+    step(Step::Write, "Updating subgraph.yaml");
+    fs::write(manifest_path, updated).context("Failed to write manifest")?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_invalid_address() {
+        let opt = AddOpt {
+            address: "invalid".to_string(),
+            manifest: PathBuf::from("subgraph.yaml"),
+            abi: None,
+            contract_name: None,
+            merge_entities: false,
+            network_file: PathBuf::from("networks.json"),
+            start_block: None,
+            quiet: false,
+        };
+
+        let result = run_add(opt).await;
+        assert!(result.is_err());
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("Invalid contract address")
+        );
+    }
+
+    #[tokio::test]
+    async fn test_missing_manifest() {
+        let opt = AddOpt {
+            address: "0x1234567890123456789012345678901234567890".to_string(),
+            manifest: PathBuf::from("nonexistent.yaml"),
+            abi: None,
+            contract_name: None,
+            merge_entities: false,
+            network_file: PathBuf::from("networks.json"),
+            start_block: None,
+            quiet: false,
+        };
+
+        let result = run_add(opt).await;
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("Manifest file"));
+    }
+
+    fn ev(name: &str) -> EventInfo {
+        EventInfo {
+            name: name.to_string(),
+            signature: format!("{}()", name),
+            inputs: vec![],
+        }
+    }
+
+    fn entities(names: &[&str]) -> HashSet<String> {
+        names.iter().map(|s| s.to_string()).collect()
+    }
+
+    #[test]
+    fn test_resolve_events_no_collision() {
+        let resolved =
+            resolve_events(vec![ev("Transfer")], &entities(&[]), "Token", false).unwrap();
+        assert_eq!(resolved.len(), 1);
+        assert_eq!(resolved[0].alias, "Transfer");
+        assert_eq!(resolved[0].entity_name, "Transfer");
+        assert!(resolved[0].declare_in_schema);
+    }
+
+    #[test]
+    fn test_resolve_events_overload_disambiguates() {
+        // Two events named Transfer in one ABI get distinct aliases.
+        let resolved = resolve_events(
+            vec![ev("Transfer"), ev("Transfer")],
+            &entities(&[]),
+            "Token",
+            false,
+        )
+        .unwrap();
+        assert_eq!(resolved[0].alias, "Transfer");
+        assert_eq!(resolved[1].alias, "Transfer1");
+        assert_eq!(resolved[1].entity_name, "Transfer1");
+    }
+
+    #[test]
+    fn test_resolve_events_collision_merge_reuses() {
+        let resolved = resolve_events(
+            vec![ev("Transfer")],
+            &entities(&["Transfer"]),
+            "Token",
+            true,
+        )
+        .unwrap();
+        // Reuse the existing entity, don't redeclare it, but keep the handler.
+        assert_eq!(resolved[0].entity_name, "Transfer");
+        assert!(!resolved[0].declare_in_schema);
+    }
+
+    #[test]
+    fn test_resolve_events_collision_no_merge_renames() {
+        let resolved = resolve_events(
+            vec![ev("Transfer")],
+            &entities(&["Transfer"]),
+            "Token",
+            false,
+        )
+        .unwrap();
+        assert_eq!(resolved[0].entity_name, "TokenTransfer");
+        assert!(resolved[0].declare_in_schema);
+    }
+
+    #[test]
+    fn test_resolve_events_collision_renamed_also_exists_errors() {
+        let result = resolve_events(
+            vec![ev("Transfer")],
+            &entities(&["Transfer", "TokenTransfer"]),
+            "Token",
+            false,
+        );
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_resolve_events_overload_alias_collision_renames() {
+        // The second overload's disambiguated alias (Transfer1) collides with an
+        // existing entity; the collision must be detected on the alias, not the
+        // raw event name.
+        let resolved = resolve_events(
+            vec![ev("Transfer"), ev("Transfer")],
+            &entities(&["Transfer1"]),
+            "Token",
+            false,
+        )
+        .unwrap();
+        assert_eq!(resolved[0].entity_name, "Transfer");
+        assert_eq!(resolved[1].alias, "Transfer1");
+        assert_eq!(resolved[1].entity_name, "TokenTransfer1");
+    }
+
+    #[test]
+    fn test_entity_types_in_schema() {
+        let schema = r#"
+            type Foo @entity { id: Bytes! }
+            type Bar @entity(immutable: true) { id: Bytes! }
+            type NotAnEntity { id: Bytes! }
+        "#;
+        let types = entity_types_in_schema(schema);
+        assert!(types.contains("Foo"));
+        assert!(types.contains("Bar"));
+        assert!(!types.contains("NotAnEntity"));
+        // A schema that doesn't parse yields no types rather than erroring.
+        assert!(entity_types_in_schema("this is not graphql {{{").is_empty());
+    }
+}
diff --git a/gnd/src/commands/auth.rs b/gnd/src/commands/auth.rs
new file mode 100644
index 00000000000..925aac2de02
--- /dev/null
+++ b/gnd/src/commands/auth.rs
@@ -0,0 +1,182 @@
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+
+use anyhow::{Context, Result};
+use clap::Parser;
+use url::Url;
+
+/// Default Subgraph Studio deploy URL
+const SUBGRAPH_STUDIO_URL: &str = "https://api.studio.thegraph.com/deploy/";
+
+/// Get the path to the config file (~/.graph-cli.json)
+fn config_path() -> PathBuf {
+    std::env::home_dir()
+        .expect("Could not determine home directory")
+        .join(".graph-cli.json")
+}
+
+/// Normalize a node URL by parsing and re-serializing it
+fn normalize_node_url(node: &str) -> Result<String> {
+    let url = Url::parse(node).context("Invalid node URL")?;
+    Ok(url.to_string())
+}
+
+/// Load the config file from a specific path, returning an empty map if it doesn't exist
+fn load_config_from(path: &PathBuf) -> Result<HashMap<String, String>> {
+    if !path.exists() {
+        return Ok(HashMap::new());
+    }
+
+    let content = fs::read_to_string(path)
+        .with_context(|| format!("Failed to read config file: {}", path.display()))?;
+
+    serde_json::from_str(&content)
+        .with_context(|| format!("Failed to parse config file: {}", path.display()))
+}
+
+/// Save the config file to a specific path
+fn save_config_to(path: &PathBuf, config: &HashMap<String, String>) -> Result<()> {
+    let content = serde_json::to_string(config).context("Failed to serialize config")?;
+    fs::write(path, content)
+        .with_context(|| format!("Failed to write config file: {}", path.display()))
+}
+
+/// Save a deploy key for a node (uses default config path)
+pub fn save_deploy_key(node: &str, deploy_key: &str) -> Result<()> {
+    save_deploy_key_to(&config_path(), node, deploy_key)
+}
+
+/// Save a deploy key for a node to a specific config file
+fn save_deploy_key_to(config_file: &PathBuf, node: &str, deploy_key: &str) -> Result<()> {
+    let normalized_node = normalize_node_url(node)?;
+    let mut config = load_config_from(config_file)?;
+    config.insert(normalized_node, deploy_key.to_string());
+    save_config_to(config_file, &config)
+}
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Set the deploy key for a Graph Node")]
+pub struct AuthOpt {
+    /// The deploy key to store
+    #[clap(value_name = "DEPLOY_KEY")]
+    pub deploy_key: String,
+
+    /// The Graph Node URL to authenticate with
+    #[clap(
+        long,
+        short = 'g',
+        value_name = "URL",
+        default_value = SUBGRAPH_STUDIO_URL,
+        help = "Graph Node URL"
+    )]
+    pub node: String,
+}
+
+/// Validate that a deploy key looks like a valid Subgraph Studio key (32 hex chars)
+fn is_valid_studio_key(key: &str) -> bool {
+    key.len() == 32 && key.chars().all(|c| c.is_ascii_hexdigit())
+}
+
+/// Run the auth command
+pub fn run_auth(opt: AuthOpt) -> Result<()> {
+    // Validate the deploy key format for Studio
+    if opt.node == SUBGRAPH_STUDIO_URL && !is_valid_studio_key(&opt.deploy_key) {
+        println!(
+            "Warning: Deploy key doesn't look like a valid Subgraph Studio key (expected 32 hex characters)"
+        );
+    }
+
+    save_deploy_key(&opt.node, &opt.deploy_key)?;
+
+    let normalized_node = normalize_node_url(&opt.node)?;
+    println!("✔ Deploy key set for {}", normalized_node);
+
+    Ok(())
+}
+
+/// Get the deploy key for a node, if one is saved (uses default config path)
+pub fn get_deploy_key(node: &str) -> Result<Option<String>> {
+    get_deploy_key_from(&config_path(), node)
+}
+
+/// Get the deploy key for a node from a specific config file
+fn get_deploy_key_from(config_file: &PathBuf, node: &str) -> Result<Option<String>> {
+    let normalized_node = normalize_node_url(node)?;
+    let config = load_config_from(config_file)?;
+    Ok(config.get(&normalized_node).cloned())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_normalize_node_url() {
+        assert_eq!(
+            normalize_node_url("https://example.com").unwrap(),
+            "https://example.com/"
+        );
+        assert_eq!(
+            normalize_node_url("https://example.com/").unwrap(),
+            "https://example.com/"
+        );
+        assert_eq!(
+            normalize_node_url("https://api.studio.thegraph.com/deploy/").unwrap(),
+            "https://api.studio.thegraph.com/deploy/"
+        );
+    }
+
+    #[test]
+    fn test_is_valid_studio_key() {
+        assert!(is_valid_studio_key("0123456789abcdef0123456789abcdef"));
+        assert!(is_valid_studio_key("ABCDEF0123456789abcdef0123456789"));
+        assert!(!is_valid_studio_key("too-short"));
+        assert!(!is_valid_studio_key("0123456789abcdef0123456789abcdefXX")); // too long
+        assert!(!is_valid_studio_key("0123456789abcdef0123456789abcdeg")); // invalid char
+    }
+
+    #[test]
+    fn test_save_and_get_deploy_key() {
+        let temp_dir = tempfile::TempDir::new().unwrap();
+        let config_file = temp_dir.path().join(".graph-cli.json");
+
+        let node = "https://example.com/deploy/";
+        let key = "test-deploy-key-12345";
+
+        // Initially no key
+        assert!(get_deploy_key_from(&config_file, node).unwrap().is_none());
+
+        // Save key
+        save_deploy_key_to(&config_file, node, key).unwrap();
+
+        // Get key back
+        assert_eq!(
+            get_deploy_key_from(&config_file, node).unwrap(),
+            Some(key.to_string())
+        );
+    }
+
+    #[test]
+    fn test_multiple_nodes() {
+        let temp_dir = tempfile::TempDir::new().unwrap();
+        let config_file = temp_dir.path().join(".graph-cli.json");
+
+        let node1 = "https://node1.example.com/";
+        let node2 = "https://node2.example.com/";
+        let key1 = "key1";
+        let key2 = "key2";
+
+        save_deploy_key_to(&config_file, node1, key1).unwrap();
+        save_deploy_key_to(&config_file, node2, key2).unwrap();
+
+        assert_eq!(
+            get_deploy_key_from(&config_file, node1).unwrap(),
+            Some(key1.to_string())
+        );
+        assert_eq!(
+            get_deploy_key_from(&config_file, node2).unwrap(),
+            Some(key2.to_string())
+        );
+    }
+}
diff --git a/gnd/src/commands/build.rs b/gnd/src/commands/build.rs
new file mode 100644
index 00000000000..b33731330aa
--- /dev/null
+++ b/gnd/src/commands/build.rs
@@ -0,0 +1,930 @@
+//! Build command for compiling subgraph mappings to WebAssembly.
+//!
+//! This command compiles AssemblyScript mappings to WASM using the asc compiler,
+//! copies all required files to the build directory, and optionally uploads
+//! the result to IPFS.
+
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result, anyhow};
+use clap::Parser;
+use sha1::{Digest, Sha1};
+
+use crate::abi::normalize_abi_json;
+use crate::compiler::{AscCompileOptions, compile_mapping, find_graph_ts};
+use crate::config::{apply_network_config, get_network_config, load_networks_config};
+use crate::manifest::{DataSource, Manifest, Template, load_manifest, resolve_path};
+use crate::migrations;
+use crate::output::{Step, step};
+use crate::services::IpfsClient;
+use crate::validation::{
+    collect_handler_names, collect_template_handler_names, format_manifest_errors,
+    format_schema_errors, validate_manifest, validate_schema, validate_wasm_handlers,
+};
+use crate::watch::watch_and_run;
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Build a subgraph and (optionally) upload it to IPFS")]
+pub struct BuildOpt {
+    /// Path to the subgraph manifest
+    #[clap(default_value = "subgraph.yaml")]
+    pub manifest: PathBuf,
+
+    /// Output directory for build results
+    #[clap(short = 'o', long, default_value = "build/")]
+    pub output_dir: PathBuf,
+
+    /// Output format for mappings (wasm or wast)
+    #[clap(short = 't', long, default_value = "wasm")]
+    pub output_format: String,
+
+    /// Skip subgraph migrations
+    #[clap(long)]
+    pub skip_migrations: bool,
+
+    /// Rebuild when subgraph files change
+    #[clap(short = 'w', long)]
+    pub watch: bool,
+
+    /// IPFS node URL to upload build results to
+    #[clap(short = 'i', long)]
+    pub ipfs: Option<String>,
+
+    /// Network configuration to use from the networks config file
+    #[clap(long)]
+    pub network: Option<String>,
+
+    /// Networks config file path
+    #[clap(long, default_value = "networks.json")]
+    pub network_file: PathBuf,
+
+    /// Skip the asc version check (use with caution)
+    #[clap(long, env = "GND_SKIP_ASC_VERSION_CHECK")]
+    pub skip_asc_version_check: bool,
+}
+
+/// Result of a build operation.
+#[derive(Debug)]
+pub struct BuildResult {
+    /// IPFS hash of the uploaded manifest (if IPFS upload was requested)
+    pub ipfs_hash: Option<String>,
+}
+
+/// Run the build command.
+pub async fn run_build(opt: BuildOpt) -> Result<Option<String>> {
+    // Validate output format
+    if opt.output_format != "wasm" && opt.output_format != "wast" {
+        return Err(anyhow!(
+            "Invalid output format '{}'. Must be 'wasm' or 'wast'",
+            opt.output_format
+        ));
+    }
+
+    if opt.watch {
+        watch_and_build(&opt).await?;
+        Ok(None)
+    } else {
+        let result = build_subgraph(&opt).await?;
+        Ok(result.ipfs_hash)
+    }
+}
+
+/// Watch subgraph files and rebuild on changes.
+async fn watch_and_build(opt: &BuildOpt) -> Result<()> {
+    // Get files to watch (need to load manifest first)
+    let manifest = load_manifest(&opt.manifest)?;
+    let files_to_watch = get_files_to_watch(&opt.manifest, &manifest);
+
+    watch_and_run(
+        files_to_watch,
+        "Watching subgraph files for changes...",
+        || async { build_subgraph(opt).await.map(|_| ()) },
+    )
+    .await
+}
+
+/// Get the list of files to watch for changes.
+fn get_files_to_watch(manifest_path: &Path, manifest: &Manifest) -> Vec<PathBuf> {
+    let mut files = vec![manifest_path.to_path_buf()];
+
+    // Add schema file
+    if let Some(schema_path) = &manifest.schema {
+        files.push(resolve_path(manifest_path, schema_path));
+    }
+
+    // Add mapping files
+    for ds in &manifest.data_sources {
+        if let Some(mapping) = &ds.mapping_file {
+            files.push(resolve_path(manifest_path, mapping));
+        }
+        for abi in &ds.abis {
+            files.push(resolve_path(manifest_path, &abi.file));
+        }
+    }
+
+    // Add template mapping files
+    for template in &manifest.templates {
+        if let Some(mapping) = &template.mapping_file {
+            files.push(resolve_path(manifest_path, mapping));
+        }
+    }
+
+    files
+}
+
+/// Build the subgraph.
+async fn build_subgraph(opt: &BuildOpt) -> Result<BuildResult> {
+    // Apply migrations unless skipped
+    if !opt.skip_migrations {
+        migrations::apply_migrations(&opt.manifest)?;
+    }
+
+    // Apply network configuration if specified
+    if let Some(network) = &opt.network {
+        apply_network_to_manifest(&opt.manifest, network, &opt.network_file)?;
+    }
+
+    // Load the manifest
+    let manifest = load_manifest(&opt.manifest)?;
+    let source_dir = crate::manifest::manifest_dir(&opt.manifest).to_path_buf();
+
+    // Validate manifest structure
+    let manifest_errors = validate_manifest(&manifest, &source_dir);
+    if !manifest_errors.is_empty() {
+        eprintln!(
+            "Manifest validation errors:\n{}",
+            format_manifest_errors(&manifest_errors)
+        );
+        return Err(anyhow!(
+            "Manifest validation failed with {} error(s)",
+            manifest_errors.len()
+        ));
+    }
+
+    // Validate schema before compilation
+    if let Some(schema_path) = &manifest.schema {
+        let schema_path = resolve_path(&opt.manifest, schema_path);
+        let validation_errors = validate_schema(&schema_path, &manifest.spec_version)?;
+
+        if !validation_errors.is_empty() {
+            eprintln!(
+                "Schema validation errors:\n{}",
+                format_schema_errors(&validation_errors)
+            );
+            return Err(anyhow!(
+                "Schema validation failed with {} error(s)",
+                validation_errors.len()
+            ));
+        }
+    }
+
+    // Find graph-ts and node_modules
+    let (lib_dirs, global_file) = find_graph_ts(&source_dir)?;
+    let libs = lib_dirs
+        .iter()
+        .map(|p| p.to_string_lossy().to_string())
+        .collect::<Vec<_>>()
+        .join(",");
+
+    // Create output directory
+    fs::create_dir_all(&opt.output_dir)
+        .with_context(|| format!("Failed to create output directory: {:?}", opt.output_dir))?;
+
+    // Compile data source mappings
+    // Track compiled files: source hash -> compiled output path
+    let mut compiled_files: HashMap<String, PathBuf> = HashMap::new();
+
+    for ds in &manifest.data_sources {
+        if let Some(mapping) = &ds.mapping_file {
+            let mapping_path = resolve_path(&opt.manifest, mapping);
+            let output_subdir = opt.output_dir.join(&ds.name);
+            compile_mapping_to_dir(
+                &ds.name,
+                &mapping_path,
+                &source_dir,
+                &output_subdir,
+                &libs,
+                &global_file,
+                &opt.output_format,
+                &mut compiled_files,
+                opt.skip_asc_version_check,
+                "data source",
+            )?;
+        }
+    }
+
+    // Compile template mappings
+    for template in &manifest.templates {
+        if let Some(mapping) = &template.mapping_file {
+            let mapping_path = resolve_path(&opt.manifest, mapping);
+            let output_subdir = opt.output_dir.join("templates").join(&template.name);
+            compile_mapping_to_dir(
+                &template.name,
+                &mapping_path,
+                &source_dir,
+                &output_subdir,
+                &libs,
+                &global_file,
+                &opt.output_format,
+                &mut compiled_files,
+                opt.skip_asc_version_check,
+                "data source template",
+            )?;
+        }
+    }
+
+    // Validate compiled WASM handler exports (only for binary WASM output)
+    if opt.output_format == "wasm" {
+        let mut wasm_errors = Vec::new();
+
+        for ds in &manifest.data_sources {
+            let handler_names = collect_handler_names(ds);
+            if handler_names.is_empty() {
+                continue;
+            }
+            let wasm_path = opt
+                .output_dir
+                .join(&ds.name)
+                .join(format!("{}.wasm", ds.name));
+            if wasm_path.exists() {
+                wasm_errors.extend(validate_wasm_handlers(&wasm_path, &ds.name, &handler_names));
+            }
+        }
+
+        for template in &manifest.templates {
+            let handler_names = collect_template_handler_names(template);
+            if handler_names.is_empty() {
+                continue;
+            }
+            let wasm_path = opt
+                .output_dir
+                .join("templates")
+                .join(&template.name)
+                .join(format!("{}.wasm", template.name));
+            if wasm_path.exists() {
+                wasm_errors.extend(validate_wasm_handlers(
+                    &wasm_path,
+                    &template.name,
+                    &handler_names,
+                ));
+            }
+        }
+
+        if !wasm_errors.is_empty() {
+            eprintln!(
+                "WASM handler validation errors:\n{}",
+                format_manifest_errors(&wasm_errors)
+            );
+            return Err(anyhow!(
+                "WASM handler validation failed with {} error(s)",
+                wasm_errors.len()
+            ));
+        }
+    }
+
+    // Copy schema file
+    if let Some(schema_path) = &manifest.schema {
+        let schema_path = resolve_path(&opt.manifest, schema_path);
+        copy_schema(&schema_path, &opt.output_dir)?;
+    }
+
+    // Copy ABI files for data sources
+    for ds in &manifest.data_sources {
+        for abi in &ds.abis {
+            let abi_path = resolve_path(&opt.manifest, &abi.file);
+            let output_subdir = opt.output_dir.join(&ds.name);
+            copy_abi_to_dir(&abi.name, &abi_path, &output_subdir)?;
+        }
+    }
+
+    // Copy ABI files for templates
+    for template in &manifest.templates {
+        for abi in &template.abis {
+            let abi_path = resolve_path(&opt.manifest, &abi.file);
+            let output_subdir = opt.output_dir.join("templates").join(&template.name);
+            copy_abi_to_dir(&abi.name, &abi_path, &output_subdir)?;
+        }
+    }
+
+    // Write output manifest
+    write_output_manifest(
+        &opt.manifest,
+        &manifest,
+        &opt.output_dir,
+        &opt.output_format,
+    )?;
+
+    // Upload to IPFS if requested
+    let ipfs_hash = if let Some(ipfs_url) = &opt.ipfs {
+        let hash = upload_to_ipfs(ipfs_url, &opt.output_dir, &manifest).await?;
+        step(Step::Done, &format!("Build completed: {}", hash));
+        Some(hash)
+    } else {
+        let manifest_path = opt.output_dir.join("subgraph.yaml");
+
+        step(
+            Step::Done,
+            &format!("Build completed: {}", manifest_path.display()),
+        );
+        None
+    };
+
+    Ok(BuildResult { ipfs_hash })
+}
+
+/// Tracks both content hash to IPFS hash (for deduplication) and path to IPFS hash (for lookups).
+#[derive(Default)]
+struct UploadedFiles {
+    /// Content hash -> IPFS hash (for deduplication)
+    content_to_ipfs: HashMap<String, String>,
+    /// Relative path -> IPFS hash (for manifest updates)
+    path_to_ipfs: HashMap<String, String>,
+}
+
+/// Upload build artifacts to IPFS and return the manifest hash.
+async fn upload_to_ipfs(ipfs_url: &str, output_dir: &Path, manifest: &Manifest) -> Result<String> {
+    step(Step::Generate, "Upload subgraph to IPFS");
+
+    let client = IpfsClient::new(ipfs_url)?;
+
+    // Track uploaded files
+    let mut uploaded = UploadedFiles::default();
+
+    // Upload schema file
+    if let Some(schema_path) = &manifest.schema {
+        let schema_name = Path::new(schema_path)
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("schema.graphql");
+        let schema_file = output_dir.join(schema_name);
+        let content = fs::read(&schema_file)
+            .with_context(|| format!("Failed to read schema file: {}", schema_file.display()))?;
+        let hash = upload_file_to_ipfs(&client, schema_name, content, &mut uploaded).await?;
+        step(Step::Write, &format!("  {} => {}", schema_name, hash));
+    }
+
+    // Upload ABI files for data sources
+    for ds in &manifest.data_sources {
+        for abi in &ds.abis {
+            let abi_filename = format!("{}.json", abi.name);
+            let abi_file = output_dir.join(&ds.name).join(&abi_filename);
+            if abi_file.exists() {
+                let content = fs::read(&abi_file)
+                    .with_context(|| format!("Failed to read ABI file: {}", abi_file.display()))?;
+                let rel_path = format!("{}/{}", ds.name, abi_filename);
+                let hash = upload_file_to_ipfs(&client, &rel_path, content, &mut uploaded).await?;
+                step(Step::Write, &format!("  {} => {}", rel_path, hash));
+            }
+        }
+    }
+
+    // Upload ABI files for templates
+    for template in &manifest.templates {
+        for abi in &template.abis {
+            let abi_filename = format!("{}.json", abi.name);
+            let abi_file = output_dir
+                .join("templates")
+                .join(&template.name)
+                .join(&abi_filename);
+            if abi_file.exists() {
+                let content = fs::read(&abi_file)
+                    .with_context(|| format!("Failed to read ABI file: {}", abi_file.display()))?;
+                let rel_path = format!("templates/{}/{}", template.name, abi_filename);
+                let hash = upload_file_to_ipfs(&client, &rel_path, content, &mut uploaded).await?;
+                step(Step::Write, &format!("  {} => {}", rel_path, hash));
+            }
+        }
+    }
+
+    // Upload mapping files
+    for ds in &manifest.data_sources {
+        let mapping_filename = format!("{}.wasm", ds.name);
+        let mapping_file = output_dir.join(&ds.name).join(&mapping_filename);
+        if mapping_file.exists() {
+            let content = fs::read(&mapping_file).with_context(|| {
+                format!("Failed to read mapping file: {}", mapping_file.display())
+            })?;
+            let rel_path = format!("{}/{}", ds.name, mapping_filename);
+            let hash = upload_file_to_ipfs(&client, &rel_path, content, &mut uploaded).await?;
+            step(Step::Write, &format!("  {} => {}", rel_path, hash));
+        }
+    }
+
+    // Upload template mapping files
+    for template in &manifest.templates {
+        let mapping_filename = format!("{}.wasm", template.name);
+        let mapping_file = output_dir
+            .join("templates")
+            .join(&template.name)
+            .join(&mapping_filename);
+        if mapping_file.exists() {
+            let content = fs::read(&mapping_file).with_context(|| {
+                format!(
+                    "Failed to read template mapping: {}",
+                    mapping_file.display()
+                )
+            })?;
+            let rel_path = format!("templates/{}/{}", template.name, mapping_filename);
+            let hash = upload_file_to_ipfs(&client, &rel_path, content, &mut uploaded).await?;
+            step(Step::Write, &format!("  {} => {}", rel_path, hash));
+        }
+    }
+
+    // Now we need to update the manifest with IPFS hashes and upload it
+    let manifest_content = create_ipfs_manifest(output_dir, manifest, &uploaded)?;
+    let manifest_hash = client
+        .add("subgraph.yaml", manifest_content.into_bytes())
+        .await?;
+    step(
+        Step::Write,
+        &format!("  subgraph.yaml => {}", manifest_hash),
+    );
+
+    Ok(manifest_hash)
+}
+
+/// Upload a file to IPFS, using cache to avoid duplicates.
+async fn upload_file_to_ipfs(
+    client: &IpfsClient,
+    path: &str,
+    content: Vec<u8>,
+    uploaded: &mut UploadedFiles,
+) -> Result<String> {
+    // Check if we already uploaded this content
+    let content_hash = {
+        let mut hasher = Sha1::new();
+        hasher.update(&content);
+        hex::encode(hasher.finalize())
+    };
+
+    let ipfs_hash = if let Some(hash) = uploaded.content_to_ipfs.get(&content_hash) {
+        hash.clone()
+    } else {
+        let hash = client.add(path, content).await?;
+        uploaded.content_to_ipfs.insert(content_hash, hash.clone());
+        hash
+    };
+
+    // Also track by path for manifest lookups
+    uploaded
+        .path_to_ipfs
+        .insert(path.to_string(), ipfs_hash.clone());
+
+    Ok(ipfs_hash)
+}
+
+/// Create the IPFS manifest with file paths replaced by IPFS hashes.
+fn create_ipfs_manifest(
+    output_dir: &Path,
+    manifest: &Manifest,
+    uploaded: &UploadedFiles,
+) -> Result<String> {
+    // Read the original manifest
+    let manifest_path = output_dir.join("subgraph.yaml");
+    let manifest_str = fs::read_to_string(&manifest_path)
+        .with_context(|| format!("Failed to read manifest: {}", manifest_path.display()))?;
+
+    let mut value: serde_yaml::Value = serde_yaml::from_str(&manifest_str)?;
+
+    // Update schema path to IPFS reference
+    if let Some(schema_path) = &manifest.schema {
+        let schema_name = Path::new(schema_path)
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("schema.graphql");
+
+        // Find the hash for this file
+        if let Some(hash) = uploaded.path_to_ipfs.get(schema_name)
+            && let Some(schema) = value.get_mut("schema")
+            && let Some(file) = schema.get_mut("file")
+        {
+            *file = create_ipfs_link(hash);
+        }
+    }
+
+    // Update data source paths
+    if let Some(data_sources) = value.get_mut("dataSources")
+        && let Some(arr) = data_sources.as_sequence_mut()
+    {
+        for (i, ds_value) in arr.iter_mut().enumerate() {
+            if i < manifest.data_sources.len() {
+                let ds = &manifest.data_sources[i];
+                update_data_source_ipfs_paths(ds_value, ds, uploaded);
+            }
+        }
+    }
+
+    // Update template paths
+    if let Some(templates) = value.get_mut("templates")
+        && let Some(arr) = templates.as_sequence_mut()
+    {
+        for (i, template_value) in arr.iter_mut().enumerate() {
+            if i < manifest.templates.len() {
+                let template = &manifest.templates[i];
+                update_template_ipfs_paths(template_value, template, uploaded);
+            }
+        }
+    }
+
+    serde_yaml::to_string(&value).context("Failed to serialize IPFS manifest")
+}
+
+/// Create an IPFS link value.
+fn create_ipfs_link(hash: &str) -> serde_yaml::Value {
+    let mut map = serde_yaml::Mapping::new();
+    map.insert(
+        serde_yaml::Value::String("/".to_string()),
+        serde_yaml::Value::String(format!("/ipfs/{}", hash)),
+    );
+    serde_yaml::Value::Mapping(map)
+}
+
+/// Update data source paths in the manifest to IPFS references.
+fn update_data_source_ipfs_paths(
+    ds_value: &mut serde_yaml::Value,
+    ds: &DataSource,
+    uploaded: &UploadedFiles,
+) {
+    if let Some(mapping) = ds_value.get_mut("mapping") {
+        // Update mapping file
+        if let Some(file) = mapping.get_mut("file") {
+            let mapping_path = format!("{}/{}.wasm", ds.name, ds.name);
+            if let Some(hash) = uploaded.path_to_ipfs.get(&mapping_path) {
+                *file = create_ipfs_link(hash);
+            }
+        }
+
+        // Update ABIs
+        if let Some(abis) = mapping.get_mut("abis")
+            && let Some(arr) = abis.as_sequence_mut()
+        {
+            for (j, abi_value) in arr.iter_mut().enumerate() {
+                if j < ds.abis.len() {
+                    let abi = &ds.abis[j];
+                    if let Some(file) = abi_value.get_mut("file") {
+                        let abi_path = format!("{}/{}.json", ds.name, abi.name);
+                        if let Some(hash) = uploaded.path_to_ipfs.get(&abi_path) {
+                            *file = create_ipfs_link(hash);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Update template paths in the manifest to IPFS references.
+fn update_template_ipfs_paths(
+    template_value: &mut serde_yaml::Value,
+    template: &Template,
+    uploaded: &UploadedFiles,
+) {
+    if let Some(mapping) = template_value.get_mut("mapping") {
+        // Update mapping file
+        if let Some(file) = mapping.get_mut("file") {
+            let mapping_path = format!("templates/{}/{}.wasm", template.name, template.name);
+            if let Some(hash) = uploaded.path_to_ipfs.get(&mapping_path) {
+                *file = create_ipfs_link(hash);
+            }
+        }
+
+        // Update ABIs
+        if let Some(abis) = mapping.get_mut("abis")
+            && let Some(arr) = abis.as_sequence_mut()
+        {
+            for (j, abi_value) in arr.iter_mut().enumerate() {
+                if j < template.abis.len() {
+                    let abi = &template.abis[j];
+                    if let Some(file) = abi_value.get_mut("file") {
+                        let abi_path = format!("templates/{}/{}.json", template.name, abi.name);
+                        if let Some(hash) = uploaded.path_to_ipfs.get(&abi_path) {
+                            *file = create_ipfs_link(hash);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Get the file extension for the output format.
+fn output_extension(output_format: &str) -> &'static str {
+    if output_format == "wasm" {
+        "wasm"
+    } else {
+        "wast"
+    }
+}
+
+/// Compile a mapping to a specific output directory.
+///
+/// This unified function handles both data source and template mappings.
+/// The caller specifies the output directory and display name.
+#[allow(clippy::too_many_arguments)]
+fn compile_mapping_to_dir(
+    name: &str,
+    mapping_path: &Path,
+    source_dir: &Path,
+    output_subdir: &Path,
+    libs: &str,
+    global_file: &Path,
+    output_format: &str,
+    compiled_files: &mut HashMap<String, PathBuf>,
+    skip_version_check: bool,
+    item_type: &str, // "data source" or "data source template"
+) -> Result<()> {
+    let cache_key = file_hash(mapping_path)?;
+
+    fs::create_dir_all(output_subdir)?;
+
+    let extension = output_extension(output_format);
+    let output_file = output_subdir.join(format!("{}.{}", name, extension));
+
+    // Check if already compiled - copy existing WASM file if so
+    if let Some(existing_wasm) = compiled_files.get(&cache_key) {
+        step(
+            Step::Skip,
+            &format!("Compile {}: {} (already compiled)", item_type, name),
+        );
+        fs::copy(existing_wasm, &output_file).with_context(|| {
+            format!(
+                "Failed to copy WASM from {} to {}",
+                existing_wasm.display(),
+                output_file.display()
+            )
+        })?;
+        return Ok(());
+    }
+
+    step(Step::Generate, &format!("Compile {}: {}", item_type, name));
+
+    let options = AscCompileOptions {
+        input_file: mapping_path.to_path_buf(),
+        base_dir: source_dir.to_path_buf(),
+        libs: libs.to_string(),
+        global_file: global_file.to_path_buf(),
+        output_file: output_file.clone(),
+        output_format: output_format.to_string(),
+        skip_version_check,
+    };
+
+    compile_mapping(&options)?;
+    compiled_files.insert(cache_key, output_file);
+
+    Ok(())
+}
+
+/// Copy the schema file to the output directory.
+fn copy_schema(schema_path: &Path, output_dir: &Path) -> Result<()> {
+    let schema_name = schema_path
+        .file_name()
+        .ok_or_else(|| anyhow!("Invalid schema path"))?;
+    let output_path = output_dir.join(schema_name);
+
+    step(
+        Step::Write,
+        &format!("Copy schema file to {}", output_path.display()),
+    );
+
+    fs::copy(schema_path, &output_path).with_context(|| {
+        format!(
+            "Failed to copy schema from {} to {}",
+            schema_path.display(),
+            output_path.display()
+        )
+    })?;
+
+    Ok(())
+}
+
+/// Copy an ABI file to the specified output directory, normalizing it to a bare
+/// ABI array. This handles Hardhat/Foundry artifacts (`{"abi": [...]}`) and
+/// Truffle artifacts (`{"compilerOutput": {"abi": [...]}}`) in addition to raw
+/// ABI arrays.
+fn copy_abi_to_dir(abi_name: &str, abi_path: &Path, output_subdir: &Path) -> Result<()> {
+    fs::create_dir_all(output_subdir)?;
+
+    let abi_filename = format!("{}.json", abi_name);
+    let output_path = output_subdir.join(&abi_filename);
+
+    step(
+        Step::Write,
+        &format!("Copy ABI {} to {}", abi_name, output_path.display()),
+    );
+
+    let abi_str = fs::read_to_string(abi_path)
+        .with_context(|| format!("Failed to read ABI file: {}", abi_path.display()))?;
+
+    let normalized = normalize_abi_json(&abi_str)
+        .with_context(|| format!("Failed to normalize ABI: {}", abi_path.display()))?;
+
+    let output_str =
+        serde_json::to_string_pretty(&normalized).context("Failed to serialize normalized ABI")?;
+
+    fs::write(&output_path, output_str)
+        .with_context(|| format!("Failed to write ABI to {}", output_path.display()))?;
+
+    Ok(())
+}
+
+/// Write the output manifest file.
+fn write_output_manifest(
+    manifest_path: &Path,
+    manifest: &Manifest,
+    output_dir: &Path,
+    output_format: &str,
+) -> Result<()> {
+    let output_path = output_dir.join("subgraph.yaml");
+
+    step(
+        Step::Write,
+        &format!("Write subgraph manifest to {}", output_path.display()),
+    );
+
+    // Load original manifest
+    let manifest_str = fs::read_to_string(manifest_path)
+        .with_context(|| format!("Failed to read manifest: {:?}", manifest_path))?;
+
+    let mut value: serde_yaml::Value = serde_yaml::from_str(&manifest_str)?;
+
+    // Update schema path
+    if let Some(schema) = value.get_mut("schema")
+        && let Some(file) = schema.get_mut("file")
+        && let Some(schema_path) = manifest.schema.as_ref()
+    {
+        let schema_name = Path::new(schema_path)
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("schema.graphql");
+        *file = serde_yaml::Value::String(schema_name.to_string());
+    }
+
+    // Update data source paths
+    if let Some(data_sources) = value.get_mut("dataSources")
+        && let Some(arr) = data_sources.as_sequence_mut()
+    {
+        for (i, ds) in arr.iter_mut().enumerate() {
+            if i < manifest.data_sources.len() {
+                let ds_name = &manifest.data_sources[i].name;
+                update_data_source_paths(ds, ds_name, output_format);
+            }
+        }
+    }
+
+    // Update template paths
+    if let Some(templates) = value.get_mut("templates")
+        && let Some(arr) = templates.as_sequence_mut()
+    {
+        for (i, template) in arr.iter_mut().enumerate() {
+            if i < manifest.templates.len() {
+                let template_name = &manifest.templates[i].name;
+                update_template_paths(template, template_name, output_format);
+            }
+        }
+    }
+
+    // Write output manifest
+    let output_str = serde_yaml::to_string(&value)?;
+    fs::write(&output_path, output_str)?;
+
+    Ok(())
+}
+
+/// Update paths in a data source for the output manifest.
+fn update_data_source_paths(ds: &mut serde_yaml::Value, ds_name: &str, output_format: &str) {
+    // Update mapping file path
+    if let Some(mapping) = ds.get_mut("mapping") {
+        if let Some(file) = mapping.get_mut("file") {
+            let extension = output_extension(output_format);
+            *file = serde_yaml::Value::String(format!("{}/{}.{}", ds_name, ds_name, extension));
+        }
+
+        // Update ABI paths
+        if let Some(abis) = mapping.get_mut("abis")
+            && let Some(arr) = abis.as_sequence_mut()
+        {
+            for abi in arr.iter_mut() {
+                // Extract name first to avoid borrow conflicts
+                let abi_name = abi
+                    .get("name")
+                    .and_then(|n| n.as_str())
+                    .map(|s| s.to_string());
+                if let Some(name) = abi_name
+                    && let Some(file) = abi.get_mut("file")
+                {
+                    *file = serde_yaml::Value::String(format!("{}/{}.json", ds_name, name));
+                }
+            }
+        }
+    }
+}
+
+/// Update paths in a template for the output manifest.
+fn update_template_paths(
+    template: &mut serde_yaml::Value,
+    template_name: &str,
+    output_format: &str,
+) {
+    // Update mapping file path
+    if let Some(mapping) = template.get_mut("mapping") {
+        if let Some(file) = mapping.get_mut("file") {
+            let extension = output_extension(output_format);
+            *file = serde_yaml::Value::String(format!(
+                "templates/{}/{}.{}",
+                template_name, template_name, extension
+            ));
+        }
+
+        // Update ABI paths
+        if let Some(abis) = mapping.get_mut("abis")
+            && let Some(arr) = abis.as_sequence_mut()
+        {
+            for abi in arr.iter_mut() {
+                // Extract name first to avoid borrow conflicts
+                let abi_name = abi
+                    .get("name")
+                    .and_then(|n| n.as_str())
+                    .map(|s| s.to_string());
+                if let Some(name) = abi_name
+                    && let Some(file) = abi.get_mut("file")
+                {
+                    *file = serde_yaml::Value::String(format!(
+                        "templates/{}/{}.json",
+                        template_name, name
+                    ));
+                }
+            }
+        }
+    }
+}
+
+/// Apply network configuration to the manifest file.
+///
+/// This modifies the manifest file in place, updating data source addresses
+/// and start blocks based on the networks.json configuration.
+fn apply_network_to_manifest(
+    manifest_path: &Path,
+    network: &str,
+    network_file: &Path,
+) -> Result<()> {
+    // Check if network file exists
+    if !network_file.exists() {
+        return Err(anyhow!(
+            "Network file '{}' does not exist. Create it or remove --network flag.",
+            network_file.display()
+        ));
+    }
+
+    step(
+        Step::Generate,
+        &format!("Apply network configuration: {}", network),
+    );
+
+    // Load network config
+    let networks_config = load_networks_config(network_file)?;
+    let network_config = get_network_config(&networks_config, network)?;
+
+    // Load manifest
+    let manifest_str = fs::read_to_string(manifest_path)
+        .with_context(|| format!("Failed to read manifest: {}", manifest_path.display()))?;
+
+    let mut manifest: serde_yaml::Value = serde_yaml::from_str(&manifest_str)
+        .with_context(|| format!("Failed to parse manifest: {}", manifest_path.display()))?;
+
+    // Apply network config
+    apply_network_config(&mut manifest, network, network_config)?;
+
+    // Write back to manifest
+    let updated_str = serde_yaml::to_string(&manifest)?;
+    fs::write(manifest_path, updated_str)
+        .with_context(|| format!("Failed to write manifest: {}", manifest_path.display()))?;
+
+    Ok(())
+}
+
+/// Calculate SHA1 hash of a file for caching.
+fn file_hash(path: &Path) -> Result<String> {
+    let content = fs::read(path).with_context(|| format!("Failed to read file: {:?}", path))?;
+    let mut hasher = Sha1::new();
+    hasher.update(&content);
+    Ok(hex::encode(hasher.finalize()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_file_hash() {
+        let temp_dir = TempDir::new().unwrap();
+        let file_path = temp_dir.path().join("test.txt");
+        fs::write(&file_path, "hello world").unwrap();
+
+        let hash = file_hash(&file_path).unwrap();
+        // SHA1 of "hello world"
+        assert_eq!(hash, "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed");
+    }
+}
diff --git a/gnd/src/commands/clean.rs b/gnd/src/commands/clean.rs
new file mode 100644
index 00000000000..3968532b917
--- /dev/null
+++ b/gnd/src/commands/clean.rs
@@ -0,0 +1,102 @@
+use std::path::Path;
+
+use anyhow::Result;
+use clap::Parser;
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Remove build artifacts and generated files")]
+pub struct CleanOpt {
+    #[clap(
+        long,
+        default_value = "generated/",
+        help = "Directory where the codegen output is stored"
+    )]
+    pub codegen_dir: String,
+
+    #[clap(
+        long,
+        default_value = "build/",
+        help = "Directory where the build output is stored"
+    )]
+    pub build_dir: String,
+}
+
+/// Run the clean command
+pub fn run_clean(opt: CleanOpt) -> Result<()> {
+    println!("Cleaning cache and generated files...");
+
+    let codegen_path = Path::new(&opt.codegen_dir);
+    let build_path = Path::new(&opt.build_dir);
+
+    let mut cleaned = false;
+
+    if codegen_path.exists() {
+        std::fs::remove_dir_all(codegen_path)?;
+        println!("✔ Removed {}", opt.codegen_dir);
+        cleaned = true;
+    }
+
+    if build_path.exists() {
+        std::fs::remove_dir_all(build_path)?;
+        println!("✔ Removed {}", opt.build_dir);
+        cleaned = true;
+    }
+
+    if cleaned {
+        println!("Cache and generated files cleaned");
+    } else {
+        println!("Nothing to clean");
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_clean_removes_directories() {
+        let temp_dir = TempDir::new().unwrap();
+        let codegen_dir = temp_dir.path().join("generated");
+        let build_dir = temp_dir.path().join("build");
+
+        // Create the directories
+        fs::create_dir(&codegen_dir).unwrap();
+        fs::create_dir(&build_dir).unwrap();
+
+        // Create some files in them
+        fs::write(codegen_dir.join("schema.ts"), "test").unwrap();
+        fs::write(build_dir.join("subgraph.wasm"), "test").unwrap();
+
+        assert!(codegen_dir.exists());
+        assert!(build_dir.exists());
+
+        let opt = CleanOpt {
+            codegen_dir: codegen_dir.to_string_lossy().to_string(),
+            build_dir: build_dir.to_string_lossy().to_string(),
+        };
+
+        run_clean(opt).unwrap();
+
+        assert!(!codegen_dir.exists());
+        assert!(!build_dir.exists());
+    }
+
+    #[test]
+    fn test_clean_handles_missing_directories() {
+        let temp_dir = TempDir::new().unwrap();
+        let codegen_dir = temp_dir.path().join("nonexistent_generated");
+        let build_dir = temp_dir.path().join("nonexistent_build");
+
+        let opt = CleanOpt {
+            codegen_dir: codegen_dir.to_string_lossy().to_string(),
+            build_dir: build_dir.to_string_lossy().to_string(),
+        };
+
+        // Should not error when directories don't exist
+        run_clean(opt).unwrap();
+    }
+}
diff --git a/gnd/src/commands/codegen.rs b/gnd/src/commands/codegen.rs
new file mode 100644
index 00000000000..deb0feb0ca5
--- /dev/null
+++ b/gnd/src/commands/codegen.rs
@@ -0,0 +1,959 @@
+//! Code generation command.
+//!
+//! Generates AssemblyScript types for a subgraph from:
+//! - GraphQL schema (entity classes)
+//! - Contract ABIs (event and call bindings)
+//! - Data source templates
+//! - Subgraph data sources (fetches schema from IPFS)
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result, anyhow};
+use clap::Parser;
+use graph::abi::JsonAbi;
+use graphql_tools::parser::schema as gql;
+use semver::Version;
+
+use crate::abi::normalize_abi_json;
+use crate::codegen::{
+    AbiCodeGenerator, Class, GENERATED_FILE_NOTE, ModuleImports, SchemaCodeGenerator,
+    Template as CodegenTemplate, TemplateCodeGenerator, TemplateKind,
+};
+use crate::formatter::try_format_typescript;
+use crate::manifest::{DataSource, Manifest, Template, load_manifest, resolve_path};
+use crate::migrations;
+use crate::output::{Step, step};
+use crate::services::IpfsClient;
+use crate::validation::{
+    format_manifest_errors, format_schema_errors, validate_manifest_files, validate_schema,
+};
+use crate::watch::watch_and_run;
+
+/// Default IPFS URL.
+const DEFAULT_IPFS_URL: &str = "https://api.thegraph.com/ipfs/api/v0";
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Generate AssemblyScript types for a subgraph")]
+pub struct CodegenOpt {
+    /// Path to the subgraph manifest
+    #[clap(default_value = "subgraph.yaml")]
+    pub manifest: PathBuf,
+
+    /// Output directory for generated types
+    #[clap(short = 'o', long, default_value = "generated/")]
+    pub output_dir: PathBuf,
+
+    /// Skip subgraph migrations
+    #[clap(long)]
+    pub skip_migrations: bool,
+
+    /// Regenerate types when subgraph files change
+    #[clap(short = 'w', long)]
+    pub watch: bool,
+
+    /// IPFS node to use for fetching subgraph data
+    #[clap(short = 'i', long, default_value = DEFAULT_IPFS_URL)]
+    pub ipfs: String,
+}
+
+/// Run the codegen command.
+pub async fn run_codegen(opt: CodegenOpt) -> Result<()> {
+    if opt.watch {
+        watch_and_generate(&opt).await
+    } else {
+        generate_types(&opt).await
+    }
+}
+
+/// Watch subgraph files and regenerate types on changes.
+async fn watch_and_generate(opt: &CodegenOpt) -> Result<()> {
+    // Get files to watch (need to load manifest first)
+    let manifest = load_manifest(&opt.manifest)?;
+    let files_to_watch = get_files_to_watch(&opt.manifest, &manifest);
+
+    watch_and_run(
+        files_to_watch,
+        "Watching subgraph files for changes...",
+        || generate_types(opt),
+    )
+    .await
+}
+
+/// Get the list of files to watch for changes.
+fn get_files_to_watch(manifest_path: &Path, manifest: &Manifest) -> Vec<PathBuf> {
+    let mut files = vec![manifest_path.to_path_buf()];
+
+    // Add schema file
+    if let Some(schema_path) = &manifest.schema {
+        files.push(resolve_path(manifest_path, schema_path));
+    }
+
+    // Add ABI files
+    for ds in &manifest.data_sources {
+        for abi in &ds.abis {
+            files.push(resolve_path(manifest_path, &abi.file));
+        }
+    }
+
+    files
+}
+
+/// Generate all types for the subgraph.
+async fn generate_types(opt: &CodegenOpt) -> Result<()> {
+    // Apply migrations unless skipped
+    if !opt.skip_migrations {
+        migrations::apply_migrations(&opt.manifest)?;
+    }
+
+    // Load the subgraph manifest
+    let manifest = load_manifest(&opt.manifest)?;
+
+    // Validate manifest file references (schema, mappings, ABIs exist and are valid)
+    let source_dir = crate::manifest::manifest_dir(&opt.manifest).to_path_buf();
+    let manifest_errors = validate_manifest_files(&manifest, &source_dir);
+    if !manifest_errors.is_empty() {
+        eprintln!(
+            "Manifest validation errors:\n{}",
+            format_manifest_errors(&manifest_errors)
+        );
+        return Err(anyhow!(
+            "Manifest validation failed with {} error(s)",
+            manifest_errors.len()
+        ));
+    }
+
+    // Create output directory
+    fs::create_dir_all(&opt.output_dir)
+        .with_context(|| format!("Failed to create output directory: {:?}", opt.output_dir))?;
+
+    // Generate schema types
+    if let Some(schema_path) = manifest.schema.as_ref() {
+        let schema_path = resolve_path(&opt.manifest, schema_path);
+        let _ = generate_schema_types(&schema_path, &opt.output_dir, &manifest.spec_version)?;
+    }
+
+    // Generate ABI types for each data source
+    for ds in &manifest.data_sources {
+        for abi in &ds.abis {
+            let abi_path = resolve_path(&opt.manifest, &abi.file);
+            // Output to: <output_dir>/<DataSourceName>/<AbiName>.ts
+            let ds_output_dir = opt.output_dir.join(&ds.name);
+            generate_abi_types(&abi.name, &abi_path, &ds_output_dir)?;
+        }
+    }
+
+    // Generate template types
+    if !manifest.templates.is_empty() {
+        generate_template_types(&manifest.templates, &opt.output_dir)?;
+
+        // Generate ABI types for templates
+        for template in &manifest.templates {
+            for abi in &template.abis {
+                let abi_path = resolve_path(&opt.manifest, &abi.file);
+                // Output to: <output_dir>/templates/<TemplateName>/<AbiName>.ts
+                let template_output_dir = opt.output_dir.join("templates").join(&template.name);
+                generate_abi_types(&abi.name, &abi_path, &template_output_dir)?;
+            }
+        }
+    }
+
+    // Generate types for subgraph data sources
+    let subgraph_sources: Vec<&DataSource> = manifest
+        .data_sources
+        .iter()
+        .filter(|ds| ds.is_subgraph_source())
+        .collect();
+    if !subgraph_sources.is_empty() {
+        generate_subgraph_source_types(&subgraph_sources, &opt.output_dir, &opt.ipfs).await?;
+    }
+
+    step(Step::Done, "Types generated successfully");
+    Ok(())
+}
+
+/// Generate types from the GraphQL schema.
+///
+/// Returns Ok(true) if types were generated successfully, Ok(false) if schema
+/// validation failed and schema.ts was skipped.
+fn generate_schema_types(
+    schema_path: &Path,
+    output_dir: &Path,
+    spec_version: &Version,
+) -> Result<bool> {
+    step(
+        Step::Load,
+        &format!("Load GraphQL schema from {}", schema_path.display()),
+    );
+
+    // Run graph-node schema validation
+    let validation_errors = validate_schema(schema_path, spec_version)?;
+
+    if !validation_errors.is_empty() {
+        eprintln!(
+            "Schema validation errors:\n{}",
+            format_schema_errors(&validation_errors)
+        );
+        return Err(anyhow!(
+            "Schema validation failed with {} error(s)",
+            validation_errors.len()
+        ));
+    }
+
+    let schema_str = fs::read_to_string(schema_path)
+        .with_context(|| format!("Failed to read schema file: {:?}", schema_path))?;
+
+    let ast: gql::Document<'_, String> = gql::parse_schema(&schema_str)
+        .map_err(|e| anyhow::anyhow!("Failed to parse GraphQL schema: {}", e))?;
+
+    step(Step::Generate, "Generate types for GraphQL schema");
+
+    let generator = match SchemaCodeGenerator::new(&ast) {
+        Ok(generator) => generator,
+        Err(e) => {
+            // Schema validation failed - skip schema.ts generation but don't fail
+            eprintln!("Warning: {}", e);
+            return Ok(false);
+        }
+    };
+    let imports = generator.generate_module_imports();
+    let entity_classes = generator.generate_types(true);
+    let derived_loaders = generator.generate_derived_loaders();
+
+    // Combine entity classes with derived loaders
+    let all_classes: Vec<Class> = entity_classes.into_iter().chain(derived_loaders).collect();
+
+    let code = generate_file(&imports, &all_classes);
+    let formatted = try_format_typescript(&code);
+
+    let output_file = output_dir.join("schema.ts");
+    step(
+        Step::Write,
+        &format!("Write types to {}", output_file.display()),
+    );
+    fs::write(&output_file, formatted)
+        .with_context(|| format!("Failed to write schema types: {:?}", output_file))?;
+
+    Ok(true)
+}
+
+/// Preprocess ABI JSON to normalize artifact formats and add defaults
+/// required by alloy's ABI parser:
+/// - `anonymous: false` for events (alloy requires this field)
+/// - `param{index}` names for unnamed event parameters (to match graph-cli behavior)
+fn preprocess_abi_json(abi_str: &str) -> Result<String> {
+    // Normalize to get the ABI array from various artifact formats
+    let mut abi = normalize_abi_json(abi_str)?;
+
+    if let Some(items) = abi.as_array_mut() {
+        for item in items {
+            if let Some(obj) = item.as_object_mut() {
+                let is_event = obj
+                    .get("type")
+                    .and_then(|t| t.as_str())
+                    .map(|t| t == "event")
+                    .unwrap_or(false);
+
+                if is_event {
+                    // Add anonymous: false for events if missing (alloy requires it)
+                    if !obj.contains_key("anonymous") {
+                        obj.insert("anonymous".to_string(), serde_json::Value::Bool(false));
+                    }
+
+                    // Add param{index} names for unnamed event parameters
+                    if let Some(inputs) = obj.get_mut("inputs") {
+                        add_default_event_param_names(inputs);
+                    }
+                }
+            }
+        }
+    }
+
+    serde_json::to_string(&abi).context("Failed to serialize processed ABI")
+}
+
+/// Add `param{index}` names to unnamed event parameters to match graph-cli behavior.
+/// Alloy defaults missing names to empty strings, but for events we want `param0`, `param1`, etc.
+fn add_default_event_param_names(params: &mut serde_json::Value) {
+    if let Some(params_arr) = params.as_array_mut() {
+        for (index, param) in params_arr.iter_mut().enumerate() {
+            if let Some(obj) = param.as_object_mut()
+                && !obj.contains_key("name")
+            {
+                obj.insert(
+                    "name".to_string(),
+                    serde_json::Value::String(format!("param{}", index)),
+                );
+            }
+        }
+    }
+}
+
+/// Generate types from an ABI file.
+fn generate_abi_types(name: &str, abi_path: &Path, output_dir: &Path) -> Result<()> {
+    step(Step::Load, &format!("Load ABI from {}", abi_path.display()));
+
+    let abi_str = fs::read_to_string(abi_path)
+        .with_context(|| format!("Failed to read ABI file: {:?}", abi_path))?;
+
+    // Preprocess ABI to normalize format and add default event param names
+    let processed_abi = preprocess_abi_json(&abi_str)
+        .with_context(|| format!("Failed to preprocess ABI: {:?}", abi_path))?;
+
+    let contract: JsonAbi = serde_json::from_str(&processed_abi)
+        .with_context(|| format!("Failed to parse ABI JSON: {:?}", abi_path))?;
+
+    step(Step::Generate, &format!("Generate types for ABI {}", name));
+
+    let generator = AbiCodeGenerator::new(contract, name);
+    let imports = generator.generate_module_imports();
+    let classes = generator.generate_types();
+
+    let code = generate_file(&imports, &classes);
+    let formatted = try_format_typescript(&code);
+
+    // Create output directory (for data source subdirectory)
+    fs::create_dir_all(output_dir)
+        .with_context(|| format!("Failed to create output directory: {:?}", output_dir))?;
+
+    let output_file = output_dir.join(format!("{}.ts", name));
+    step(
+        Step::Write,
+        &format!("Write types to {}", output_file.display()),
+    );
+    fs::write(&output_file, formatted)
+        .with_context(|| format!("Failed to write ABI types: {:?}", output_file))?;
+
+    Ok(())
+}
+
+/// Generate types for data source templates.
+fn generate_template_types(templates: &[Template], output_dir: &Path) -> Result<()> {
+    step(Step::Generate, "Generate types for data source templates");
+
+    let codegen_templates: Vec<CodegenTemplate> = templates
+        .iter()
+        .filter_map(|t| {
+            TemplateKind::from_str_kind(&t.kind).map(|kind| CodegenTemplate::new(&t.name, kind))
+        })
+        .collect();
+
+    if codegen_templates.is_empty() {
+        return Ok(());
+    }
+
+    let generator = TemplateCodeGenerator::new(codegen_templates);
+    let imports = generator.generate_module_imports();
+    let classes = generator.generate_types();
+
+    let code = generate_file(&imports, &classes);
+    let formatted = try_format_typescript(&code);
+
+    let output_file = output_dir.join("templates.ts");
+    step(
+        Step::Write,
+        &format!("Write types to {}", output_file.display()),
+    );
+    fs::write(&output_file, formatted)
+        .with_context(|| format!("Failed to write template types: {:?}", output_file))?;
+
+    Ok(())
+}
+
+/// Generate types for subgraph data sources.
+///
+/// For each subgraph data source, this fetches the referenced subgraph's schema
+/// from IPFS and generates entity types (without store methods).
+async fn generate_subgraph_source_types(
+    subgraph_sources: &[&DataSource],
+    output_dir: &Path,
+    ipfs_url: &str,
+) -> Result<()> {
+    step(Step::Generate, "Generate types for subgraph data sources");
+
+    let ipfs_client = IpfsClient::new(ipfs_url)?;
+
+    // Validate that all subgraph data source names are unique
+    let mut seen_names = std::collections::HashSet::new();
+    for source in subgraph_sources {
+        if !seen_names.insert(&source.name) {
+            return Err(anyhow!(
+                "Duplicate subgraph data source name '{}'. Each subgraph data source must have a unique name.",
+                source.name
+            ));
+        }
+    }
+
+    for source in subgraph_sources {
+        // source_address is guaranteed to be Some because of is_subgraph_source() filter
+        let address = source.source_address.as_ref().unwrap();
+
+        step(
+            Step::Load,
+            &format!("Fetch schema for subgraph {} ({})", source.name, address),
+        );
+
+        // Fetch schema from IPFS using block_in_place to allow blocking in async context
+        let schema_str = ipfs_client.fetch_subgraph_schema(address).await?;
+
+        // Parse the schema
+        let ast: gql::Document<'_, String> = gql::parse_schema(&schema_str)
+            .map_err(|e| anyhow::anyhow!("Failed to parse subgraph schema: {}", e))?;
+
+        step(
+            Step::Generate,
+            &format!("Generate types for subgraph {} ({})", source.name, address),
+        );
+
+        // Generate entity types WITHOUT store methods (false = no store methods)
+        let generator = match SchemaCodeGenerator::new(&ast) {
+            Ok(generator) => generator,
+            Err(e) => {
+                eprintln!(
+                    "Warning: Failed to create schema generator for subgraph {} ({}): {}",
+                    source.name, address, e
+                );
+                continue;
+            }
+        };
+
+        let imports = generator.generate_module_imports();
+        // Pass false to generate entities without store methods
+        let entity_classes = generator.generate_types(false);
+
+        let code = generate_file(&imports, &entity_classes);
+        let formatted = try_format_typescript(&code);
+
+        // Output to: <output_dir>/subgraph-<NAME>.ts
+        // Using name instead of IPFS hash for stable file names
+        let output_file = output_dir.join(format!("subgraph-{}.ts", source.name));
+        step(
+            Step::Write,
+            &format!("Write types to {}", output_file.display()),
+        );
+        fs::write(&output_file, formatted)
+            .with_context(|| format!("Failed to write subgraph types: {:?}", output_file))?;
+    }
+
+    Ok(())
+}
+
+/// Generate a TypeScript file from imports and classes.
+fn generate_file(imports: &[ModuleImports], classes: &[Class]) -> String {
+    let mut output = String::new();
+
+    // Add generated file note
+    output.push_str(GENERATED_FILE_NOTE);
+    output.push('\n');
+
+    // Add imports
+    for import in imports {
+        output.push_str(&import.to_string());
+        output.push('\n');
+    }
+
+    // Add classes
+    for class in classes {
+        output.push_str(&class.to_string());
+    }
+
+    output
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_generate_file() {
+        let imports = vec![ModuleImports::new(
+            vec!["Entity".to_string()],
+            "@graphprotocol/graph-ts",
+        )];
+        let classes = vec![];
+        let output = generate_file(&imports, &classes);
+        assert!(output.contains("AUTOGENERATED"));
+        assert!(output.contains("import { Entity }"));
+    }
+
+    /// Test that codegen generates types in the correct directory structure.
+    ///
+    /// TS CLI generates:
+    /// - generated/schema.ts
+    /// - generated/<DataSourceName>/<AbiName>.ts
+    /// - generated/templates/<TemplateName>/<AbiName>.ts
+    #[tokio::test]
+    async fn test_codegen_directory_structure() {
+        let temp_dir = TempDir::new().unwrap();
+        let project_dir = temp_dir.path();
+        let output_dir = project_dir.join("generated");
+
+        // Create manifest
+        let manifest_content = r#"
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    network: mainnet
+    source:
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - MyEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          handler: handleExampleEvent
+"#;
+        fs::write(project_dir.join("subgraph.yaml"), manifest_content).unwrap();
+
+        // Create schema
+        let schema_content = r#"
+type MyEntity @entity(immutable: true) {
+  id: ID!
+  x: BigDecimal!
+}
+"#;
+        fs::write(project_dir.join("schema.graphql"), schema_content).unwrap();
+
+        // Create ABI
+        let abi_content = r#"[
+  {
+    "type": "event",
+    "name": "ExampleEvent",
+    "anonymous": false,
+    "inputs": [{ "type": "string", "name": "param0", "indexed": false }]
+  }
+]"#;
+        fs::write(project_dir.join("Abi.json"), abi_content).unwrap();
+
+        // Create mapping (empty is fine)
+        fs::write(project_dir.join("mapping.ts"), "").unwrap();
+
+        // Run codegen
+        let opt = CodegenOpt {
+            manifest: project_dir.join("subgraph.yaml"),
+            output_dir: output_dir.clone(),
+            skip_migrations: true,
+            watch: false,
+            ipfs: "https://api.thegraph.com/ipfs/api/v0".to_string(),
+        };
+        generate_types(&opt).await.unwrap();
+
+        // Verify directory structure
+        assert!(
+            output_dir.join("schema.ts").exists(),
+            "schema.ts should exist at root of output dir"
+        );
+        assert!(
+            output_dir.join("ExampleSubgraph").is_dir(),
+            "ExampleSubgraph directory should exist"
+        );
+        assert!(
+            output_dir
+                .join("ExampleSubgraph/ExampleContract.ts")
+                .exists(),
+            "ExampleContract.ts should be in ExampleSubgraph subdirectory"
+        );
+
+        // Verify schema.ts content
+        let schema_ts = fs::read_to_string(output_dir.join("schema.ts")).unwrap();
+        assert!(
+            schema_ts.contains("export class MyEntity"),
+            "schema.ts should contain MyEntity class"
+        );
+        assert!(
+            schema_ts.contains("AUTOGENERATED"),
+            "schema.ts should have autogenerated note"
+        );
+
+        // Verify ABI types content
+        let abi_ts =
+            fs::read_to_string(output_dir.join("ExampleSubgraph/ExampleContract.ts")).unwrap();
+        assert!(
+            abi_ts.contains("export class ExampleEvent"),
+            "ABI types should contain ExampleEvent class"
+        );
+        assert!(
+            abi_ts.contains("export class ExampleContract"),
+            "ABI types should contain ExampleContract class"
+        );
+    }
+
+    /// Snapshot test for schema codegen output format.
+    ///
+    /// Tests that schema.ts matches the expected TS CLI format for a simple entity.
+    /// This helps ensure byte-for-byte compatibility with the graph-cli.
+    #[tokio::test]
+    async fn test_schema_codegen_snapshot() {
+        let temp_dir = TempDir::new().unwrap();
+        let project_dir = temp_dir.path();
+        let output_dir = project_dir.join("generated");
+
+        // Create manifest
+        let manifest_content = r#"
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: TestDataSource
+    network: mainnet
+    source:
+      abi: TestContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - MyEntity
+      abis:
+        - name: TestContract
+          file: ./TestContract.json
+      eventHandlers:
+        - event: Transfer(address,address,uint256)
+          handler: handleTransfer
+"#;
+        fs::write(project_dir.join("subgraph.yaml"), manifest_content).unwrap();
+
+        // Create a simple schema with BigDecimal field
+        let schema_content = r#"
+type MyEntity @entity(immutable: true) {
+  id: ID!
+  x: BigDecimal!
+}
+"#;
+        fs::write(project_dir.join("schema.graphql"), schema_content).unwrap();
+        fs::write(project_dir.join("mapping.ts"), "").unwrap();
+        let abi = r#"[{
+            "type": "event",
+            "name": "Transfer",
+            "anonymous": false,
+            "inputs": [
+                {"name": "from", "type": "address", "indexed": true},
+                {"name": "to", "type": "address", "indexed": true},
+                {"name": "value", "type": "uint256", "indexed": false}
+            ]
+        }]"#;
+        fs::write(project_dir.join("TestContract.json"), abi).unwrap();
+
+        // Run codegen
+        let opt = CodegenOpt {
+            manifest: project_dir.join("subgraph.yaml"),
+            output_dir: output_dir.clone(),
+            skip_migrations: true,
+            watch: false,
+            ipfs: "https://api.thegraph.com/ipfs/api/v0".to_string(),
+        };
+        generate_types(&opt).await.unwrap();
+
+        // Read generated schema.ts
+        let schema_ts = fs::read_to_string(output_dir.join("schema.ts")).unwrap();
+
+        // Verify key parts of the output that must match TS CLI format
+        assert!(
+            schema_ts.contains("// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY."),
+            "Should have standard autogenerated note"
+        );
+        assert!(schema_ts.contains("import {"), "Should have imports");
+        assert!(
+            schema_ts.contains("from \"@graphprotocol/graph-ts\""),
+            "Should import from @graphprotocol/graph-ts"
+        );
+        assert!(
+            schema_ts.contains("export class MyEntity extends Entity"),
+            "Should export MyEntity class extending Entity"
+        );
+        assert!(
+            schema_ts.contains("constructor(id: string)"),
+            "Should have constructor with id parameter"
+        );
+        assert!(
+            schema_ts.contains("save(): void"),
+            "Should have save method"
+        );
+        assert!(
+            schema_ts.contains("static loadInBlock(id: string): MyEntity | null"),
+            "Should have loadInBlock static method"
+        );
+        assert!(
+            schema_ts.contains("static load(id: string): MyEntity | null"),
+            "Should have load static method"
+        );
+        assert!(
+            schema_ts.contains("get id(): string"),
+            "Should have id getter"
+        );
+        assert!(
+            schema_ts.contains("set id(value: string)"),
+            "Should have id setter"
+        );
+        assert!(
+            schema_ts.contains("get x(): BigDecimal"),
+            "Should have x getter returning BigDecimal"
+        );
+        assert!(
+            schema_ts.contains("set x(value: BigDecimal)"),
+            "Should have x setter accepting BigDecimal"
+        );
+
+        // Verify the save method has correct entity type assertion
+        assert!(
+            schema_ts.contains("store.set(\"MyEntity\""),
+            "save() should call store.set with entity type name"
+        );
+
+        // Verify load methods use correct store methods
+        assert!(
+            schema_ts.contains("store.get(\"MyEntity\""),
+            "load() should call store.get with entity type name"
+        );
+        assert!(
+            schema_ts.contains("store.get_in_block(\"MyEntity\""),
+            "loadInBlock() should call store.get_in_block with entity type name"
+        );
+    }
+
+    /// Snapshot test for ABI codegen output format.
+    ///
+    /// Tests that ABI types match the expected TS CLI format for events and contract class.
+    #[tokio::test]
+    async fn test_abi_codegen_snapshot() {
+        let temp_dir = TempDir::new().unwrap();
+        let project_dir = temp_dir.path();
+        let output_dir = project_dir.join("generated");
+
+        // Create manifest
+        let manifest_content = r#"
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    network: mainnet
+    source:
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - MyEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          handler: handleExampleEvent
+"#;
+        fs::write(project_dir.join("subgraph.yaml"), manifest_content).unwrap();
+
+        // Create schema
+        fs::write(
+            project_dir.join("schema.graphql"),
+            "type MyEntity @entity { id: ID! }",
+        )
+        .unwrap();
+        fs::write(project_dir.join("mapping.ts"), "").unwrap();
+
+        // Create ABI with event
+        let abi_content = r#"[
+  {
+    "type": "event",
+    "name": "ExampleEvent",
+    "anonymous": false,
+    "inputs": [{ "type": "string", "name": "param0", "indexed": false }]
+  }
+]"#;
+        fs::write(project_dir.join("Abi.json"), abi_content).unwrap();
+
+        // Run codegen
+        let opt = CodegenOpt {
+            manifest: project_dir.join("subgraph.yaml"),
+            output_dir: output_dir.clone(),
+            skip_migrations: true,
+            watch: false,
+            ipfs: "https://api.thegraph.com/ipfs/api/v0".to_string(),
+        };
+        generate_types(&opt).await.unwrap();
+
+        // Read generated ABI types
+        let abi_ts =
+            fs::read_to_string(output_dir.join("ExampleSubgraph/ExampleContract.ts")).unwrap();
+
+        // Verify key parts of the output that must match TS CLI format
+        assert!(
+            abi_ts.contains("// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY."),
+            "Should have standard autogenerated note"
+        );
+        assert!(abi_ts.contains("import {"), "Should have imports");
+        assert!(
+            abi_ts.contains("from \"@graphprotocol/graph-ts\""),
+            "Should import from @graphprotocol/graph-ts"
+        );
+
+        // Event class
+        assert!(
+            abi_ts.contains("export class ExampleEvent extends ethereum.Event"),
+            "Should export event class extending ethereum.Event"
+        );
+        assert!(
+            abi_ts.contains("get params(): ExampleEvent__Params"),
+            "Event should have params getter"
+        );
+
+        // Params class
+        assert!(
+            abi_ts.contains("export class ExampleEvent__Params"),
+            "Should have params class"
+        );
+        assert!(
+            abi_ts.contains("_event: ExampleEvent"),
+            "Params should have _event field"
+        );
+        assert!(
+            abi_ts.contains("get param0(): string"),
+            "Params should have param0 getter"
+        );
+
+        // Contract class
+        assert!(
+            abi_ts.contains("export class ExampleContract extends ethereum.SmartContract"),
+            "Should export contract class extending ethereum.SmartContract"
+        );
+        assert!(
+            abi_ts.contains("static bind(address: Address): ExampleContract"),
+            "Contract should have static bind method"
+        );
+    }
+
+    /// Test that codegen fails when referenced ABI file does not exist.
+    ///
+    /// Before Step 2, codegen did not validate the manifest. Now it calls
+    /// `validate_manifest()` which checks file existence, so a missing ABI
+    /// file is caught before codegen even starts generating types.
+    #[tokio::test]
+    async fn test_codegen_fails_on_missing_abi_file() {
+        let temp_dir = TempDir::new().unwrap();
+        let project_dir = temp_dir.path();
+        let output_dir = project_dir.join("generated");
+
+        // Manifest references an ABI file that doesn't exist
+        let manifest_content = r#"
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Token
+    network: mainnet
+    source:
+      abi: ERC20
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - MyEntity
+      abis:
+        - name: ERC20
+          file: ./abis/ERC20.json
+"#;
+        fs::write(project_dir.join("subgraph.yaml"), manifest_content).unwrap();
+
+        // Create schema and mapping, but NOT the ABI file
+        fs::write(
+            project_dir.join("schema.graphql"),
+            "type MyEntity @entity { id: ID! }",
+        )
+        .unwrap();
+        fs::write(project_dir.join("mapping.ts"), "").unwrap();
+
+        let opt = CodegenOpt {
+            manifest: project_dir.join("subgraph.yaml"),
+            output_dir,
+            skip_migrations: true,
+            watch: false,
+            ipfs: "https://api.thegraph.com/ipfs/api/v0".to_string(),
+        };
+
+        let result = generate_types(&opt).await;
+        assert!(
+            result.is_err(),
+            "Codegen should fail when ABI file is missing"
+        );
+        let err = format!("{:#}", result.unwrap_err());
+        assert!(
+            err.contains("validation failed"),
+            "Error should mention validation failure, got: {}",
+            err
+        );
+    }
+
+    /// Test that codegen fails when referenced schema file does not exist.
+    #[tokio::test]
+    async fn test_codegen_fails_on_missing_schema_file() {
+        let temp_dir = TempDir::new().unwrap();
+        let project_dir = temp_dir.path();
+        let output_dir = project_dir.join("generated");
+
+        // Manifest references a schema file that doesn't exist
+        let manifest_content = r#"
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Token
+    network: mainnet
+    source:
+      abi: ERC20
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - MyEntity
+      abis: []
+"#;
+        fs::write(project_dir.join("subgraph.yaml"), manifest_content).unwrap();
+
+        // Create mapping, but NOT the schema file
+        fs::write(project_dir.join("mapping.ts"), "").unwrap();
+
+        let opt = CodegenOpt {
+            manifest: project_dir.join("subgraph.yaml"),
+            output_dir,
+            skip_migrations: true,
+            watch: false,
+            ipfs: "https://api.thegraph.com/ipfs/api/v0".to_string(),
+        };
+
+        let result = generate_types(&opt).await;
+        assert!(
+            result.is_err(),
+            "Codegen should fail when schema file is missing"
+        );
+        let err = format!("{:#}", result.unwrap_err());
+        assert!(
+            err.contains("validation failed"),
+            "Error should mention validation failure, got: {}",
+            err
+        );
+    }
+}
diff --git a/gnd/src/commands/create.rs b/gnd/src/commands/create.rs
new file mode 100644
index 00000000000..5351a4eff21
--- /dev/null
+++ b/gnd/src/commands/create.rs
@@ -0,0 +1,96 @@
+use anyhow::{Context, Result};
+use clap::Parser;
+
+use crate::commands::auth::get_deploy_key;
+use crate::services::GraphNodeClient;
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Register a subgraph name with a Graph Node")]
+pub struct CreateOpt {
+    /// The subgraph name to register (e.g., "user/subgraph")
+    #[clap(value_name = "SUBGRAPH_NAME")]
+    pub subgraph_name: String,
+
+    /// Graph Node admin URL
+    #[clap(long, short = 'g', value_name = "URL", help = "Graph Node URL")]
+    pub node: String,
+
+    /// Access token for authentication
+    #[clap(long, value_name = "TOKEN", help = "Graph access token")]
+    pub access_token: Option<String>,
+}
+
+/// Run the create command
+pub async fn run_create(opt: CreateOpt) -> Result<()> {
+    println!("Creating subgraph in Graph node: {}", opt.node);
+
+    // Get access token (from flag or from config)
+    let access_token = match &opt.access_token {
+        Some(token) => Some(token.clone()),
+        None => get_deploy_key(&opt.node)
+            .ok()
+            .flatten()
+            .map(|key| key.to_string()),
+    };
+
+    let client = GraphNodeClient::new(&opt.node, access_token.as_deref())
+        .context("Failed to create Graph Node client")?;
+
+    client
+        .create_subgraph(&opt.subgraph_name)
+        .await
+        .context("Failed to create subgraph")?;
+
+    println!("✔ Created subgraph: {}", opt.subgraph_name);
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_opt_parsing() {
+        // Test that required args are enforced
+        let result = CreateOpt::try_parse_from(["create"]);
+        assert!(result.is_err());
+
+        // Test with just subgraph name (missing --node)
+        let result = CreateOpt::try_parse_from(["create", "user/subgraph"]);
+        assert!(result.is_err());
+
+        // Test with all required args
+        let result = CreateOpt::try_parse_from([
+            "create",
+            "user/subgraph",
+            "--node",
+            "http://localhost:8020",
+        ]);
+        assert!(result.is_ok());
+        let opt = result.unwrap();
+        assert_eq!(opt.subgraph_name, "user/subgraph");
+        assert_eq!(opt.node, "http://localhost:8020");
+        assert!(opt.access_token.is_none());
+
+        // Test with access token
+        let result = CreateOpt::try_parse_from([
+            "create",
+            "user/subgraph",
+            "--node",
+            "http://localhost:8020",
+            "--access-token",
+            "my-token",
+        ]);
+        assert!(result.is_ok());
+        let opt = result.unwrap();
+        assert_eq!(opt.access_token, Some("my-token".to_string()));
+
+        // Test short flag for node
+        let result =
+            CreateOpt::try_parse_from(["create", "user/subgraph", "-g", "http://localhost:8020"]);
+        assert!(result.is_ok());
+        let opt = result.unwrap();
+        assert_eq!(opt.node, "http://localhost:8020");
+    }
+}
diff --git a/gnd/src/commands/deploy.rs b/gnd/src/commands/deploy.rs
new file mode 100644
index 00000000000..5c9e744ba02
--- /dev/null
+++ b/gnd/src/commands/deploy.rs
@@ -0,0 +1,318 @@
+//! Deploy command for deploying subgraphs to a Graph Node.
+//!
+//! This command builds a subgraph (unless an IPFS hash is provided),
+//! uploads it to IPFS, and deploys it to a Graph Node.
+
+use std::{
+    io::{self, IsTerminal},
+    path::PathBuf,
+};
+
+use anyhow::{Context, Result, anyhow};
+use clap::Parser;
+use url::Url;
+
+use crate::commands::auth::get_deploy_key;
+use crate::commands::build::{BuildOpt, run_build};
+use crate::output::{Step, step};
+use crate::prompt::{normalize_version_label, prompt_version_label};
+use crate::services::GraphNodeClient;
+
+/// Default IPFS URL used by The Graph
+const DEFAULT_IPFS_URL: &str = "https://api.thegraph.com/ipfs/api/v0";
+
+/// Default deploy URL for Subgraph Studio
+const SUBGRAPH_STUDIO_URL: &str = "https://api.studio.thegraph.com/deploy/";
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Deploy a subgraph to a Graph Node")]
+pub struct DeployOpt {
+    /// Name to deploy the subgraph as (e.g., "user/subgraph")
+    #[clap()]
+    pub subgraph_name: String,
+
+    /// Path to the subgraph manifest
+    #[clap(default_value = "subgraph.yaml")]
+    pub manifest: PathBuf,
+
+    /// Graph Node admin URL. Defaults to Subgraph Studio if not provided.
+    #[clap(short = 'g', long)]
+    pub node: Option<String>,
+
+    /// IPFS node URL to upload build results to
+    #[clap(short = 'i', long, default_value = DEFAULT_IPFS_URL)]
+    pub ipfs: String,
+
+    /// Deploy key for authentication
+    #[clap(long)]
+    pub deploy_key: Option<String>,
+
+    /// Version label for the deployment (e.g., "v0.0.1")
+    #[clap(short = 'l', long)]
+    pub version_label: Option<String>,
+
+    /// IPFS hash of an already-uploaded subgraph manifest to deploy
+    #[clap(long)]
+    pub ipfs_hash: Option<String>,
+
+    /// Output directory for build results
+    #[clap(short = 'o', long, default_value = "build/")]
+    pub output_dir: PathBuf,
+
+    /// Skip subgraph migrations
+    #[clap(long)]
+    pub skip_migrations: bool,
+
+    /// Network configuration to use from the networks config file
+    #[clap(long)]
+    pub network: Option<String>,
+
+    /// Networks config file path
+    #[clap(long, default_value = "networks.json")]
+    pub network_file: PathBuf,
+
+    /// Fork subgraph ID for debugging
+    #[clap(long)]
+    pub debug_fork: Option<String>,
+
+    /// Skip the asc version check (use with caution)
+    #[clap(long, env = "GND_SKIP_ASC_VERSION_CHECK")]
+    pub skip_asc_version_check: bool,
+}
+
+/// Run the deploy command.
+pub async fn run_deploy(opt: DeployOpt) -> Result<()> {
+    // Use Subgraph Studio URL if no node is provided
+    let node = opt.node.as_deref().unwrap_or(SUBGRAPH_STUDIO_URL);
+
+    // Validate URLs
+    validate_url(node, "node")?;
+    validate_url(&opt.ipfs, "IPFS")?;
+
+    // Get deploy key (from flag or stored auth)
+    let deploy_key = match &opt.deploy_key {
+        Some(key) => Some(key.clone()),
+        None => get_deploy_key(node)?,
+    };
+
+    let version_label =
+        match resolve_version_label(opt.version_label.as_deref(), io::stdin().is_terminal())? {
+            Some(label) => label,
+            None => prompt_version_label()?,
+        };
+
+    // Get or build the IPFS hash
+    let ipfs_hash = match &opt.ipfs_hash {
+        Some(hash) => {
+            step(Step::Skip, "Build (using provided IPFS hash)");
+            hash.clone()
+        }
+        None => {
+            // Build the subgraph and upload to IPFS
+            build_and_upload(&opt).await?
+        }
+    };
+
+    // Deploy to Graph Node
+    deploy_to_node(
+        &opt,
+        node,
+        &ipfs_hash,
+        &version_label,
+        deploy_key.as_deref(),
+    )
+    .await
+}
+
+/// Validate that a URL is well-formed.
+fn validate_url(url: &str, name: &str) -> Result<()> {
+    Url::parse(url)
+        .map_err(|e| anyhow!("Invalid {} URL '{}': {}", name, url, e))
+        .map(|parsed| {
+            match parsed.scheme() {
+                "http" | "https" => {}
+                scheme => {
+                    return Err(anyhow!(
+                        "Unsupported protocol '{}' for {} URL. Must be http:// or https://",
+                        scheme,
+                        name
+                    ));
+                }
+            }
+            Ok(())
+        })??;
+    Ok(())
+}
+
+/// Parse and validate a normalized version label.
+fn parse_version_label(label: &str) -> Result<String> {
+    let normalized = normalize_version_label(label);
+    if normalized.is_empty() {
+        return Err(anyhow!("Version label cannot be empty"));
+    }
+    Ok(normalized)
+}
+
+/// Resolve version label from flag or interactive prompt mode.
+fn resolve_version_label(
+    version_label: Option<&str>,
+    stdin_is_terminal: bool,
+) -> Result<Option<String>> {
+    match version_label {
+        Some(label) => parse_version_label(label)
+            .context("Invalid --version-label value")
+            .map(Some),
+        None if stdin_is_terminal => Ok(None),
+        None => Err(anyhow!(
+            "--version-label is required in non-interactive mode. \
+             Pass --version-label <LABEL>."
+        )),
+    }
+}
+
+/// Build the subgraph and upload to IPFS.
+async fn build_and_upload(opt: &DeployOpt) -> Result<String> {
+    // Run the build command with IPFS upload enabled
+    let build_opt = BuildOpt {
+        manifest: opt.manifest.clone(),
+        output_dir: opt.output_dir.clone(),
+        output_format: "wasm".to_string(),
+        skip_migrations: opt.skip_migrations,
+        watch: false,
+        ipfs: Some(opt.ipfs.clone()),
+        network: opt.network.clone(),
+        network_file: opt.network_file.clone(),
+        skip_asc_version_check: opt.skip_asc_version_check,
+    };
+
+    match run_build(build_opt).await? {
+        Some(ipfs_hash) => Ok(ipfs_hash),
+        None => Err(anyhow!(
+            "Build succeeded but no IPFS hash was returned. This is unexpected."
+        )),
+    }
+}
+
+/// Deploy the subgraph to the Graph Node.
+async fn deploy_to_node(
+    opt: &DeployOpt,
+    node: &str,
+    ipfs_hash: &str,
+    version_label: &str,
+    deploy_key: Option<&str>,
+) -> Result<()> {
+    step(Step::Deploy, &format!("Deploying to {}", node));
+
+    let client = GraphNodeClient::new(node, deploy_key)?;
+
+    let result = client
+        .deploy_subgraph(
+            &opt.subgraph_name,
+            ipfs_hash,
+            Some(version_label),
+            opt.debug_fork.as_deref(),
+        )
+        .await
+        .with_context(|| {
+            format!(
+                "Failed to deploy subgraph '{}' to {}",
+                opt.subgraph_name, node
+            )
+        })?;
+
+    // Normalize URLs if they're relative (start with ':')
+    let base = Url::parse(node)?;
+    let base_str = format!(
+        "{}://{}",
+        base.scheme(),
+        base.host_str().unwrap_or("localhost")
+    );
+
+    let playground = if result.playground.starts_with(':') {
+        format!("{}{}", base_str, result.playground)
+    } else {
+        result.playground
+    };
+
+    let queries = if result.queries.starts_with(':') {
+        format!("{}{}", base_str, result.queries)
+    } else {
+        result.queries
+    };
+
+    step(Step::Done, &format!("Deployed to {}", playground));
+    println!();
+    println!("Subgraph endpoints:");
+    println!("Queries (HTTP):     {}", queries);
+    println!();
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_url_valid_http() {
+        assert!(validate_url("http://localhost:8020", "node").is_ok());
+    }
+
+    #[test]
+    fn test_validate_url_valid_https() {
+        assert!(validate_url("https://api.thegraph.com/ipfs", "IPFS").is_ok());
+    }
+
+    #[test]
+    fn test_validate_url_invalid() {
+        assert!(validate_url("not-a-url", "test").is_err());
+    }
+
+    #[test]
+    fn test_validate_url_unsupported_protocol() {
+        assert!(validate_url("ftp://example.com", "test").is_err());
+    }
+
+    #[test]
+    fn test_subgraph_studio_url() {
+        // Verify the default URL is valid
+        assert!(validate_url(SUBGRAPH_STUDIO_URL, "node").is_ok());
+    }
+
+    #[test]
+    fn test_default_ipfs_url() {
+        // Verify the default IPFS URL is valid
+        assert!(validate_url(DEFAULT_IPFS_URL, "IPFS").is_ok());
+    }
+
+    #[test]
+    fn test_parse_version_label_rejects_empty_after_normalize() {
+        assert!(parse_version_label("").is_err());
+        assert!(parse_version_label("   ").is_err());
+        assert!(parse_version_label("\"\"").is_err());
+        assert!(parse_version_label(" \"\" ").is_err());
+        assert!(parse_version_label("\"   \"").is_err());
+    }
+
+    #[test]
+    fn test_resolve_version_label_from_flag() {
+        assert_eq!(
+            resolve_version_label(Some(" \"v1.0.0\" "), false).unwrap(),
+            Some("v1.0.0".to_string())
+        );
+    }
+
+    #[test]
+    fn test_resolve_version_label_interactive_without_flag() {
+        assert_eq!(resolve_version_label(None, true).unwrap(), None);
+    }
+
+    #[test]
+    fn test_resolve_version_label_non_interactive_requires_flag() {
+        let err = resolve_version_label(None, false).unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("--version-label is required in non-interactive mode")
+        );
+    }
+}
diff --git a/gnd/src/commands/dev.rs b/gnd/src/commands/dev.rs
new file mode 100644
index 00000000000..044cefa877e
--- /dev/null
+++ b/gnd/src/commands/dev.rs
@@ -0,0 +1,304 @@
+use std::{path::Path, sync::Arc};
+
+use anyhow::{Context, Result};
+use clap::Parser;
+use graph::{
+    components::link_resolver::FileLinkResolver,
+    env::EnvVars,
+    prelude::{CheapClone, DeploymentHash, LinkResolver, SubgraphName},
+    slog::{Logger, error, info},
+};
+use graph_core::polling_monitor::ipfs_service;
+use graph_node::{launcher, opt::Opt};
+use tokio::sync::mpsc;
+use tokio_util::sync::CancellationToken;
+
+use crate::watcher::{deploy_all_subgraphs, parse_manifest_args, watch_subgraphs};
+
+#[cfg(unix)]
+use pgtemp::{PgTempDB, PgTempDBBuilder};
+
+// Add an alias for the temporary Postgres DB handle. On non unix
+// targets we don't have pgtemp, but we still need the type to satisfy the
+// function signatures.
+#[cfg(unix)]
+type TempPgDB = PgTempDB;
+#[cfg(not(unix))]
+type TempPgDB = ();
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Run graph-node in dev mode")]
+pub struct DevOpt {
+    #[clap(
+        long,
+        help = "Start a graph-node in dev mode watching a build directory for changes"
+    )]
+    pub watch: bool,
+
+    #[clap(
+        long,
+        value_name = "MANIFEST:[BUILD_DIR]",
+        help = "The location of the subgraph manifest file. If no build directory is provided, the default is 'build'. The file can be an alias, in the format '[BUILD_DIR:]manifest' where 'manifest' is the path to the manifest file, and 'BUILD_DIR' is the path to the build directory relative to the manifest file.",
+        default_value = "./subgraph.yaml",
+        value_delimiter = ','
+    )]
+    pub manifests: Vec<String>,
+
+    #[clap(
+        long,
+        value_name = "ALIAS:MANIFEST:[BUILD_DIR]",
+        value_delimiter = ',',
+        help = "The location of the source subgraph manifest files. This is used to resolve aliases in the manifest files for subgraph data sources. The format is ALIAS:MANIFEST:[BUILD_DIR], where ALIAS is the alias name, BUILD_DIR is the build directory relative to the manifest file, and MANIFEST is the manifest file location."
+    )]
+    pub sources: Vec<String>,
+
+    #[clap(
+        long,
+        help = "The location of the database directory.",
+        default_value = "./build"
+    )]
+    pub database_dir: String,
+
+    #[clap(
+        long,
+        value_name = "URL",
+        env = "POSTGRES_URL",
+        help = "Location of the Postgres database used for storing entities"
+    )]
+    pub postgres_url: Option<String>,
+
+    #[clap(
+        long,
+        allow_negative_numbers = false,
+        value_name = "NETWORK_NAME:[CAPABILITIES]:URL",
+        env = "ETHEREUM_RPC",
+        help = "Ethereum network name (e.g. 'mainnet'), optional comma-separated capabilities (eg 'full,archive'), and an Ethereum RPC URL, separated by a ':'"
+    )]
+    pub ethereum_rpc: Vec<String>,
+
+    #[clap(
+        long,
+        value_name = "HOST:PORT",
+        env = "IPFS",
+        help = "HTTP addresses of IPFS servers (RPC, Gateway)",
+        default_value = "https://api.thegraph.com/ipfs"
+    )]
+    pub ipfs: Vec<String>,
+    #[clap(
+        long,
+        default_value = "8000",
+        value_name = "PORT",
+        help = "Port for the GraphQL HTTP server",
+        env = "GRAPH_GRAPHQL_HTTP_PORT"
+    )]
+    pub http_port: u16,
+    #[clap(
+        long,
+        default_value = "8030",
+        value_name = "PORT",
+        help = "Port for the index node server"
+    )]
+    pub index_node_port: u16,
+    #[clap(
+        long,
+        default_value = "8020",
+        value_name = "PORT",
+        help = "Port for the JSON-RPC admin server"
+    )]
+    pub admin_port: u16,
+    #[clap(
+        long,
+        default_value = "8040",
+        value_name = "PORT",
+        help = "Port for the Prometheus metrics server"
+    )]
+    pub metrics_port: u16,
+}
+
+/// Builds the Graph Node options from DevOpt
+fn build_args(dev_opt: &DevOpt, db_url: &str) -> Result<Opt> {
+    let mut args = vec!["gnd".to_string()];
+
+    if !dev_opt.ipfs.is_empty() {
+        args.push("--ipfs".to_string());
+        args.push(dev_opt.ipfs.join(","));
+    }
+
+    if !dev_opt.ethereum_rpc.is_empty() {
+        args.push("--ethereum-rpc".to_string());
+        args.push(dev_opt.ethereum_rpc.join(","));
+    }
+
+    args.push("--postgres-url".to_string());
+    args.push(db_url.to_string());
+
+    let mut opt = Opt::parse_from(args);
+
+    opt.http_port = dev_opt.http_port;
+    opt.admin_port = dev_opt.admin_port;
+    opt.metrics_port = dev_opt.metrics_port;
+    opt.index_node_port = dev_opt.index_node_port;
+
+    Ok(opt)
+}
+
+async fn run_graph_node(
+    logger: &Logger,
+    opt: Opt,
+    link_resolver: Arc<dyn LinkResolver>,
+    subgraph_updates_channel: mpsc::Receiver<(DeploymentHash, SubgraphName)>,
+    cancel_token: CancellationToken,
+) -> Result<()> {
+    let env_vars = Arc::new(EnvVars::from_env().context("Failed to load environment variables")?);
+
+    let (prometheus_registry, metrics_registry) = launcher::setup_metrics(logger);
+
+    let ipfs_client = graph::ipfs::new_ipfs_client(&opt.ipfs, &metrics_registry, logger)
+        .await
+        .unwrap_or_else(|err| panic!("Failed to create IPFS client: {err:#}"));
+
+    let ipfs_service = ipfs_service(
+        ipfs_client.cheap_clone(),
+        env_vars.mappings.max_ipfs_file_bytes,
+        env_vars.mappings.ipfs_timeout,
+        env_vars.mappings.ipfs_request_limit,
+    );
+
+    launcher::run(
+        logger.clone(),
+        opt,
+        env_vars,
+        ipfs_service,
+        link_resolver,
+        Some(subgraph_updates_channel),
+        prometheus_registry,
+        metrics_registry,
+        cancel_token,
+    )
+    .await;
+    Ok(())
+}
+
+/// Get the database URL, either from the provided option or by creating a temporary database
+fn get_database_url(
+    postgres_url: Option<&String>,
+    database_dir: &Path,
+) -> Result<(String, Option<TempPgDB>)> {
+    if let Some(url) = postgres_url {
+        Ok((url.clone(), None))
+    } else {
+        #[cfg(unix)]
+        {
+            // Check the database directory exists
+            if !database_dir.exists() {
+                anyhow::bail!(
+                    "Database directory does not exist: {}",
+                    database_dir.display()
+                );
+            }
+
+            let db = PgTempDBBuilder::new()
+                .with_data_dir_prefix(database_dir)
+                .persist_data(false)
+                .with_initdb_arg("-E", "UTF8")
+                .with_initdb_arg("--locale", "C")
+                .start();
+            let url = db.connection_uri().to_string();
+            // Return the handle so it lives for the lifetime of the program; dropping it will
+            // shut down Postgres and remove the temporary directory automatically.
+            Ok((url, Some(db)))
+        }
+
+        #[cfg(not(unix))]
+        {
+            let _ = database_dir; // Suppress unused warning
+            anyhow::bail!(
+                "Please provide a postgres_url manually using the --postgres-url option."
+            );
+        }
+    }
+}
+
+/// Run the dev command
+pub async fn run_dev(
+    dev_opt: DevOpt,
+    logger: Logger,
+    cancel_token: CancellationToken,
+) -> Result<()> {
+    let database_dir = Path::new(&dev_opt.database_dir);
+
+    info!(logger, "Starting Graph Node Dev");
+    info!(logger, "Database directory: {}", database_dir.display());
+
+    // Get the database URL and keep the temporary database handle alive for the life of the
+    // program so that it is dropped (and cleaned up) on graceful shutdown.
+    let (db_url, mut temp_db_opt) = get_database_url(dev_opt.postgres_url.as_ref(), database_dir)?;
+
+    let opt = build_args(&dev_opt, &db_url)?;
+
+    let (manifests_paths, source_subgraph_aliases): (
+        Vec<std::path::PathBuf>,
+        std::collections::HashMap<String, std::path::PathBuf>,
+    ) = parse_manifest_args(dev_opt.manifests.clone(), dev_opt.sources.clone(), &logger)?;
+    let file_link_resolver = Arc::new(FileLinkResolver::new(None, source_subgraph_aliases.clone()));
+
+    let (tx, rx) = mpsc::channel(1);
+
+    let logger_clone = logger.clone();
+    let cancel_token_clone = cancel_token.clone();
+    graph::spawn(async move {
+        let _ = run_graph_node(
+            &logger_clone,
+            opt,
+            file_link_resolver,
+            rx,
+            cancel_token_clone,
+        )
+        .await;
+    });
+
+    let deploy_result: anyhow::Result<()> =
+        deploy_all_subgraphs(&logger, &manifests_paths, &source_subgraph_aliases, &tx).await;
+    if let Err(e) = deploy_result {
+        let error_msg = e.to_string();
+        error!(logger, "Error deploying subgraphs"; "error" => error_msg);
+        std::process::exit(1);
+    }
+
+    if dev_opt.watch {
+        let logger_clone_watch = logger.clone();
+        graph::spawn_blocking(async move {
+            let watch_result: anyhow::Result<()> = watch_subgraphs(
+                &logger_clone_watch,
+                manifests_paths,
+                source_subgraph_aliases,
+                vec!["pgtemp-*".to_string()],
+                tx,
+            )
+            .await;
+            if let Err(e) = watch_result {
+                let error_msg = e.to_string();
+                error!(logger_clone_watch, "Error watching subgraphs"; "error" => error_msg);
+                std::process::exit(1);
+            }
+        });
+    }
+
+    // Wait for Ctrl+C so we can shut down cleanly and drop the temporary database, which removes
+    // the data directory.
+    tokio::signal::ctrl_c()
+        .await
+        .expect("Failed to listen for Ctrl+C signal");
+    info!(logger, "Received Ctrl+C, shutting down.");
+
+    // Explicitly shut down and clean up the temporary database directory if we started one.
+    #[cfg(unix)]
+    if let Some(db) = temp_db_opt.take() {
+        db.shutdown();
+    }
+
+    #[cfg(not(unix))]
+    let _ = temp_db_opt; // Suppress unused warning
+
+    Ok(())
+}
diff --git a/gnd/src/commands/init.rs b/gnd/src/commands/init.rs
new file mode 100644
index 00000000000..629297616d0
--- /dev/null
+++ b/gnd/src/commands/init.rs
@@ -0,0 +1,1450 @@
+//! Init command for creating new subgraphs.
+//!
+//! This command creates a new subgraph with basic scaffolding. It supports
+//! multiple modes:
+//! - From an example subgraph template
+//! - From an existing contract (fetch ABI from Etherscan/Sourcify)
+//! - From an existing deployed subgraph
+//!
+//! When required options are not provided, the command runs in interactive mode,
+//! prompting the user for necessary information.
+
+use std::fs;
+use std::io::{self, IsTerminal};
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result, anyhow};
+use clap::{Parser, ValueEnum};
+use graphql_tools::parser::schema as gql;
+
+use crate::commands::add::{AddOpt, run_add};
+use crate::commands::codegen::{CodegenOpt, run_codegen};
+use crate::config::networks::update_networks_file;
+use crate::output::{Step, step, with_spinner};
+use crate::prompt::{
+    InitForm, SourceType, get_subgraph_basename, prompt_add_another_contract,
+    prompt_contract_address, prompt_contract_name, prompt_directory_with_confirm,
+    prompt_start_block, prompt_subgraph_slug_with_confirm, resolve_directory_collision,
+};
+use crate::scaffold::{ScaffoldOptions, generate_scaffold, init_git, install_dependencies};
+use crate::services::{ContractInfo, ContractService, IpfsClient, NetworksRegistry};
+
+/// Available protocols for subgraph development.
+#[derive(Clone, Debug, ValueEnum)]
+pub enum Protocol {
+    Ethereum,
+    Near,
+    Cosmos,
+    Arweave,
+    Substreams,
+}
+
+impl std::fmt::Display for Protocol {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Protocol::Ethereum => write!(f, "ethereum"),
+            Protocol::Near => write!(f, "near"),
+            Protocol::Cosmos => write!(f, "cosmos"),
+            Protocol::Arweave => write!(f, "arweave"),
+            Protocol::Substreams => write!(f, "substreams"),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Parser, Default)]
+#[clap(about = "Create a new subgraph with basic scaffolding")]
+pub struct InitOpt {
+    /// Name of the subgraph (e.g., "user/my-subgraph")
+    #[clap()]
+    pub subgraph_name: Option<String>,
+
+    /// Directory to create the subgraph in
+    #[clap()]
+    pub directory: Option<PathBuf>,
+
+    /// Protocol to use for the subgraph
+    #[clap(long, value_enum)]
+    pub protocol: Option<Protocol>,
+
+    /// Graph node URL
+    #[clap(short = 'g', long)]
+    pub node: Option<String>,
+
+    /// Create scaffold from an existing contract address
+    #[clap(long, conflicts_with_all = ["from_example", "from_subgraph"])]
+    pub from_contract: Option<String>,
+
+    /// Create scaffold from an example subgraph
+    #[clap(long, conflicts_with_all = ["from_contract", "from_subgraph"])]
+    pub from_example: Option<String>,
+
+    /// Create scaffold based on an existing deployed subgraph
+    #[clap(long, conflicts_with_all = ["from_contract", "from_example"])]
+    pub from_subgraph: Option<String>,
+
+    /// Name of the contract (used with --from-contract)
+    #[clap(long)]
+    pub contract_name: Option<String>,
+
+    /// Index contract events as entities
+    #[clap(long)]
+    pub index_events: bool,
+
+    /// Skip installing dependencies
+    #[clap(long)]
+    pub skip_install: bool,
+
+    /// Skip initializing a Git repository
+    #[clap(long)]
+    pub skip_git: bool,
+
+    /// Block number to start indexing from
+    #[clap(long)]
+    pub start_block: Option<String>,
+
+    /// Path to the contract ABI file
+    #[clap(long)]
+    pub abi: Option<PathBuf>,
+
+    /// Network the contract is deployed to
+    #[clap(long)]
+    pub network: Option<String>,
+
+    /// IPFS node URL for fetching subgraph data
+    #[clap(short = 'i', long)]
+    pub ipfs: Option<String>,
+}
+
+/// Run the init command.
+pub async fn run_init(opt: InitOpt) -> Result<()> {
+    // Check if we need interactive mode
+    let needs_interactive = should_run_interactive(&opt);
+
+    if needs_interactive {
+        // Check if we're in a terminal
+        if !io::stdin().is_terminal() {
+            return Err(anyhow!(
+                "Interactive mode requires a terminal. \
+                 Please provide required options via command line flags.\n\n\
+                 Required: --from-contract <address> --network <network>\n\
+                 Or use: --from-example to create from an example"
+            ));
+        }
+
+        return run_interactive(opt).await;
+    }
+
+    // Non-interactive mode - determine the scaffold source
+    let source = if opt.from_contract.is_some() {
+        ScaffoldSource::Contract
+    } else if opt.from_example.is_some() {
+        ScaffoldSource::Example
+    } else if opt.from_subgraph.is_some() {
+        ScaffoldSource::Subgraph
+    } else {
+        // Default to example if nothing specified
+        ScaffoldSource::Example
+    };
+
+    match source {
+        ScaffoldSource::Contract => init_from_contract(&opt, None).await,
+        ScaffoldSource::Example => init_from_example(&opt),
+        ScaffoldSource::Subgraph => init_from_subgraph(&opt).await,
+    }
+}
+
+/// Check if we should run in interactive mode.
+fn should_run_interactive(opt: &InitOpt) -> bool {
+    // If --from-example is specified, we can run non-interactively
+    if opt.from_example.is_some() {
+        return false;
+    }
+
+    // If --from-subgraph is specified, we can run non-interactively (will error)
+    if opt.from_subgraph.is_some() {
+        return false;
+    }
+
+    // If --from-contract is specified with network, we can run non-interactively
+    if opt.from_contract.is_some() && opt.network.is_some() {
+        return false;
+    }
+
+    // If --from-contract is specified without network, need interactive
+    if opt.from_contract.is_some() && opt.network.is_none() {
+        return true;
+    }
+
+    // If no source specified, we need interactive mode
+    true
+}
+
+/// Run in interactive mode.
+async fn run_interactive(opt: InitOpt) -> Result<()> {
+    println!("Creating a new subgraph...\n");
+
+    // Load the networks registry
+    let registry = NetworksRegistry::load().await?;
+
+    // Parse start block if provided
+    let start_block = opt.start_block.as_ref().and_then(|s| s.parse::<u64>().ok());
+
+    // Run the interactive form
+    let form = InitForm::run_interactive(
+        &registry,
+        opt.network.clone(),
+        opt.subgraph_name.clone(),
+        opt.directory
+            .clone()
+            .map(|p| p.to_string_lossy().to_string()),
+        opt.from_contract.clone(),
+        opt.from_example.is_some(),
+        opt.contract_name.clone(),
+        start_block,
+        opt.index_events,
+        opt.abi.clone().map(|p| p.to_string_lossy().to_string()),
+    )
+    .await?;
+
+    // Execute based on source type
+    match form.source_type {
+        SourceType::Example => {
+            let example_opt = InitOpt {
+                subgraph_name: Some(form.subgraph_name),
+                directory: Some(PathBuf::from(&form.directory)),
+                from_example: Some("ethereum-gravatar".to_string()),
+                skip_install: opt.skip_install,
+                skip_git: opt.skip_git,
+                ..Default::default()
+            };
+            init_from_example(&example_opt)
+        }
+        SourceType::Contract => {
+            let contract_opt = InitOpt {
+                subgraph_name: Some(form.subgraph_name),
+                directory: Some(PathBuf::from(&form.directory)),
+                from_contract: form.contract_address,
+                contract_name: Some(form.contract_name),
+                network: Some(form.network),
+                start_block: form.start_block.map(|b| b.to_string()),
+                index_events: form.index_events,
+                abi: form.abi_path.map(PathBuf::from),
+                skip_install: opt.skip_install,
+                skip_git: opt.skip_git,
+                ..Default::default()
+            };
+            init_from_contract(&contract_opt, form.contract_info).await
+        }
+    }
+}
+
+enum ScaffoldSource {
+    Contract,
+    Example,
+    Subgraph,
+}
+
+/// Initialize a subgraph from a contract address.
+///
+/// If `prefetched` is provided, it will be used instead of fetching contract info again.
+/// This avoids duplicate network requests when running in interactive mode.
+async fn init_from_contract(opt: &InitOpt, prefetched: Option<ContractInfo>) -> Result<()> {
+    let address = opt
+        .from_contract
+        .as_ref()
+        .ok_or_else(|| anyhow!("Contract address is required"))?;
+
+    // Validate address format
+    if !address.starts_with("0x") || address.len() != 42 {
+        return Err(anyhow!(
+            "Invalid contract address '{}'. Expected format: 0x followed by 40 hex characters.",
+            address
+        ));
+    }
+
+    let network = opt.network.as_deref().unwrap_or("mainnet");
+
+    let contract_info = {
+        // Load ABI from file if provided
+        if let Some(abi_path) = &opt.abi {
+            step(
+                Step::Load,
+                &format!("Loading contract ABI from {}", abi_path.display()),
+            );
+
+            let abi_str = fs::read_to_string(abi_path)
+                .with_context(|| format!("Failed to read ABI file: {}", abi_path.display()))?;
+            let abi: serde_json::Value = serde_json::from_str(&abi_str)
+                .with_context(|| format!("Failed to parse ABI file: {}", abi_path.display()))?;
+
+            // Try to get start block from API if not provided
+            let start_block = if let Some(block) = &opt.start_block {
+                block.parse::<u64>().ok()
+            } else {
+                // Try to fetch from API
+                match ContractService::load().await {
+                    Ok(service) => service.get_start_block(network, address).await.ok(),
+                    Err(_) => None,
+                }
+            };
+
+            let name = opt
+                .contract_name
+                .clone()
+                .unwrap_or_else(|| "Contract".to_string());
+
+            ContractInfo {
+                abi,
+                name,
+                start_block,
+            }
+        } else if let Some(info) = prefetched {
+            // Use pre-fetched contract info from interactive prompts
+            info
+        } else {
+            // Fetch ABI from Etherscan/Sourcify
+            step(
+                Step::Load,
+                &format!("Fetching contract info from {} on {}", address, network),
+            );
+
+            let service = ContractService::load()
+                .await
+                .context("Failed to load contract service")?;
+
+            service
+                .get_contract_info(network, address)
+                .await
+                .context("Failed to fetch contract info")?
+        }
+    };
+
+    step(
+        Step::Done,
+        &format!("Found contract: {}", contract_info.name),
+    );
+
+    // Determine contract name
+    let contract_name = opt
+        .contract_name
+        .clone()
+        .unwrap_or_else(|| contract_info.name.clone());
+
+    // Determine subgraph name
+    let subgraph_name = opt
+        .subgraph_name
+        .clone()
+        .unwrap_or_else(|| format!("user/{}", contract_name.to_lowercase()));
+
+    // Determine directory
+    let initial_directory = opt.directory.clone().unwrap_or_else(|| {
+        PathBuf::from(
+            subgraph_name
+                .split('/')
+                .next_back()
+                .unwrap_or(&contract_name),
+        )
+    });
+
+    // Resolve directory collision by prompting for a new name if needed
+    let directory = PathBuf::from(resolve_directory_collision(&initial_directory)?);
+
+    // Determine start block
+    let start_block = opt
+        .start_block
+        .as_ref()
+        .and_then(|s| s.parse::<u64>().ok())
+        .or(contract_info.start_block);
+
+    // Generate scaffold
+    let scaffold_options = ScaffoldOptions {
+        address: Some(address.clone()),
+        network: network.to_string(),
+        contract_name: contract_name.clone(),
+        subgraph_name: subgraph_name.clone(),
+        start_block,
+        abi: Some(contract_info.abi),
+        index_events: opt.index_events,
+    };
+
+    generate_scaffold(&directory, &scaffold_options)?;
+
+    // Create networks.json with the contract configuration
+    let networks_path = directory.join("networks.json");
+    update_networks_file(
+        &networks_path,
+        network,
+        &contract_name,
+        address,
+        start_block,
+    )?;
+
+    // Initialize git unless skipped
+    if !opt.skip_git {
+        let _ = init_git(&directory);
+    }
+
+    // Install dependencies unless skipped
+    if !opt.skip_install
+        && let Err(e) = install_dependencies(&directory)
+    {
+        eprintln!("Warning: {}", e);
+    }
+
+    // Run codegen to generate types (requires dependencies to be installed)
+    if !opt.skip_install {
+        let codegen_opt = CodegenOpt {
+            manifest: directory.join("subgraph.yaml"),
+            output_dir: directory.join("generated"),
+            skip_migrations: true,
+            watch: false,
+            ipfs: "https://api.thegraph.com/ipfs/api/v0".to_string(),
+        };
+        if let Err(e) = run_codegen(codegen_opt).await {
+            eprintln!("Warning: codegen failed: {}", e);
+        }
+    }
+
+    step(
+        Step::Done,
+        &format!("Subgraph created at {}", directory.display()),
+    );
+
+    // Prompt to add more contracts if in interactive mode
+    if io::stdin().is_terminal() {
+        add_more_contracts_loop(&directory, network).await?;
+    }
+
+    println!();
+    println!("Next steps:");
+    println!("  cd {}", directory.display());
+    println!("  gnd codegen");
+    println!("  gnd build");
+
+    Ok(())
+}
+
+/// Loop to add more contracts interactively.
+async fn add_more_contracts_loop(directory: &Path, network: &str) -> Result<()> {
+    while prompt_add_another_contract(network)? {
+        // Prompt for contract address
+        let address = prompt_contract_address()?;
+
+        // Fetch contract info to get defaults
+        let fetched_info = fetch_contract_info_for_add(network, &address).await;
+
+        // Prompt for contract name with fetched default
+        let default_name = fetched_info.as_ref().map(|i| i.name.as_str());
+        let contract_name = prompt_contract_name(default_name)?;
+
+        // Prompt for start block with fetched default
+        let default_start_block = fetched_info.as_ref().and_then(|i| i.start_block);
+        let start_block = prompt_start_block(default_start_block)?;
+
+        // Run the add command
+        let add_opt = AddOpt {
+            address,
+            manifest: directory.join("subgraph.yaml"),
+            abi: None,
+            contract_name: Some(contract_name),
+            merge_entities: true, // Merge by default when adding during init
+            network_file: PathBuf::from("networks.json"),
+            start_block: start_block.map(|b| b.to_string()),
+            quiet: true,
+        };
+
+        if let Err(e) = run_add(add_opt).await {
+            eprintln!("Warning: Failed to add contract: {}", e);
+            // Continue the loop to allow trying again or adding a different contract
+        }
+    }
+
+    Ok(())
+}
+
+/// Fetch contract info for the add-another-contract flow.
+async fn fetch_contract_info_for_add(network: &str, address: &str) -> Option<ContractInfo> {
+    step(
+        Step::Load,
+        &format!("Fetching contract info for {} on {}", address, network),
+    );
+
+    let service = match ContractService::load().await {
+        Ok(s) => s,
+        Err(e) => {
+            step(
+                Step::Warn,
+                &format!("Could not load contract service: {}", e),
+            );
+            return None;
+        }
+    };
+
+    match service.get_contract_info(network, address).await {
+        Ok(info) => {
+            step(Step::Done, &format!("Found contract: {}", info.name));
+            Some(info)
+        }
+        Err(e) => {
+            step(Step::Warn, &format!("Could not fetch contract info: {}", e));
+            None
+        }
+    }
+}
+
+/// Recursively copy a directory and its contents.
+fn copy_dir_recursive(src: &Path, dst: &Path) -> Result<()> {
+    fs::create_dir_all(dst)?;
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let src_path = entry.path();
+        let dst_path = dst.join(entry.file_name());
+        if entry.file_type()?.is_dir() {
+            copy_dir_recursive(&src_path, &dst_path)?;
+        } else {
+            fs::copy(&src_path, &dst_path)?;
+        }
+    }
+    Ok(())
+}
+
+/// Initialize a subgraph from an example template.
+///
+/// This matches the graph-cli `init --from-example` behavior:
+/// 1. Prompt for subgraph slug (with confirmation output)
+/// 2. Prompt for directory (with confirmation output)
+/// 3. Clone example with spinner
+/// 4. Initialize networks config with spinner
+/// 5. Update package.json with spinner
+/// 6. Initialize git with spinner
+/// 7. Install dependencies with spinner
+/// 8. Run codegen with spinner
+/// 9. Print "Next steps" message
+fn init_from_example(opt: &InitOpt) -> Result<()> {
+    use std::io::IsTerminal;
+
+    let example = opt.from_example.as_deref().ok_or_else(|| {
+        anyhow!(
+            "Example name is required. See available examples at:\n\
+             https://github.com/graphprotocol/graph-tooling/tree/main/examples"
+        )
+    })?;
+
+    // Handle legacy example name format
+    let example = match example {
+        "ethereum/gravatar" => "ethereum-gravatar",
+        other => other,
+    };
+
+    // Determine subgraph slug - prompt if not provided and in terminal
+    let subgraph_name = if let Some(name) = &opt.subgraph_name {
+        name.clone()
+    } else if io::stdin().is_terminal() {
+        prompt_subgraph_slug_with_confirm(None)?
+    } else {
+        "my-subgraph".to_string()
+    };
+
+    // Determine directory - prompt if not provided and in terminal
+    let initial_directory = if let Some(dir) = &opt.directory {
+        dir.clone()
+    } else if io::stdin().is_terminal() {
+        let default_dir = get_subgraph_basename(&subgraph_name);
+        PathBuf::from(prompt_directory_with_confirm(Some(&default_dir))?)
+    } else {
+        PathBuf::from(get_subgraph_basename(&subgraph_name))
+    };
+
+    // Resolve directory collision by prompting for a new name if needed
+    let directory = PathBuf::from(resolve_directory_collision(&initial_directory)?);
+
+    // Clone example with spinner
+    clone_example_with_spinner(example, &directory)?;
+
+    // Initialize networks config with spinner
+    init_networks_config_with_spinner(&directory)?;
+
+    // Update package.json with subgraph name
+    update_package_json_with_spinner(&directory, &subgraph_name)?;
+
+    // Initialize git unless skipped
+    if !opt.skip_git {
+        init_git_with_spinner(&directory)?;
+    }
+
+    // Install dependencies unless skipped
+    if !opt.skip_install
+        && let Err(e) = install_dependencies(&directory)
+    {
+        eprintln!("Warning: {}", e);
+    }
+
+    // Run codegen unless install was skipped (codegen requires dependencies)
+    if !opt.skip_install {
+        run_codegen_with_spinner(&directory)?;
+    }
+
+    // Print final message
+    print_next_steps(&subgraph_name, &directory);
+
+    Ok(())
+}
+
+/// Clone example subgraph with spinner.
+fn clone_example_with_spinner(example: &str, directory: &Path) -> Result<()> {
+    use std::process::{Command, Stdio};
+
+    with_spinner(
+        "Cloning example subgraph",
+        "Failed to clone example",
+        "Cloned with warnings",
+        |_spinner| {
+            let temp_dir = tempfile::tempdir()?;
+            let repo_url = "https://github.com/graphprotocol/graph-tooling";
+            let example_subpath = format!("examples/{}", example);
+
+            // Initialize empty repo with sparse checkout
+            let status = Command::new("git")
+                .current_dir(temp_dir.path())
+                .args(["init"])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status()?;
+
+            if !status.success() {
+                return Err(anyhow!("Failed to initialize git repository"));
+            }
+
+            // Configure sparse checkout for just the example directory
+            Command::new("git")
+                .current_dir(temp_dir.path())
+                .args(["sparse-checkout", "init", "--cone"])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status()?;
+
+            Command::new("git")
+                .current_dir(temp_dir.path())
+                .args(["sparse-checkout", "set", &example_subpath])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status()?;
+
+            // Add remote and fetch only the needed content
+            Command::new("git")
+                .current_dir(temp_dir.path())
+                .args(["remote", "add", "origin", repo_url])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status()?;
+
+            let fetch_status = Command::new("git")
+                .current_dir(temp_dir.path())
+                .args(["fetch", "--depth=1", "origin", "main"])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status()?;
+
+            if !fetch_status.success() {
+                return Err(anyhow!("Failed to fetch from graph-tooling repository"));
+            }
+
+            Command::new("git")
+                .current_dir(temp_dir.path())
+                .args(["checkout", "origin/main"])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status()?;
+
+            // Verify example exists
+            let example_path = temp_dir.path().join("examples").join(example);
+            if !example_path.exists() {
+                return Err(anyhow!(
+                    "Example '{}' not found. See available examples at:\n\
+                     https://github.com/graphprotocol/graph-tooling/tree/main/examples",
+                    example
+                ));
+            }
+
+            // Copy example to target directory
+            copy_dir_recursive(&example_path, directory)?;
+
+            Ok(())
+        },
+    )
+}
+
+/// Initialize networks.json with spinner.
+fn init_networks_config_with_spinner(directory: &Path) -> Result<()> {
+    with_spinner(
+        "Initialize networks config",
+        "Failed to initialize networks config",
+        "Networks config initialized with warnings",
+        |_spinner| {
+            // Create a minimal networks.json if it doesn't exist
+            let networks_path = directory.join("networks.json");
+            if !networks_path.exists() {
+                let networks_content = serde_json::json!({
+                    "mainnet": {
+                        "Gravity": {
+                            "address": "0x2E645469f354BB4F5c8a05B3b30A929361cf77eC"
+                        }
+                    }
+                });
+                fs::write(
+                    &networks_path,
+                    serde_json::to_string_pretty(&networks_content)?,
+                )?;
+            }
+            Ok(())
+        },
+    )
+}
+
+/// Update package.json with subgraph name with spinner.
+fn update_package_json_with_spinner(directory: &Path, subgraph_name: &str) -> Result<()> {
+    with_spinner(
+        "Update subgraph name and commands in package.json",
+        "Failed to update package.json",
+        "Updated with warnings",
+        |_spinner| {
+            let package_path = directory.join("package.json");
+            if package_path.exists() {
+                let content = fs::read_to_string(&package_path)?;
+                let mut package: serde_json::Value = serde_json::from_str(&content)?;
+
+                if let Some(obj) = package.as_object_mut() {
+                    // Update name to the subgraph basename
+                    let basename = subgraph_name
+                        .split('/')
+                        .next_back()
+                        .unwrap_or(subgraph_name);
+                    obj.insert("name".to_string(), serde_json::json!(basename));
+
+                    // Remove license and repository fields (like graph-cli does)
+                    obj.remove("license");
+                    obj.remove("repository");
+
+                    // Update deploy script with new subgraph name
+                    if let Some(scripts) = obj.get_mut("scripts").and_then(|s| s.as_object_mut()) {
+                        scripts.insert(
+                            "deploy".to_string(),
+                            serde_json::json!(format!(
+                                "graph deploy --node https://api.studio.thegraph.com/deploy/ {}",
+                                subgraph_name
+                            )),
+                        );
+                        scripts.insert(
+                            "create-local".to_string(),
+                            serde_json::json!(format!(
+                                "graph create --node http://localhost:8020/ {}",
+                                subgraph_name
+                            )),
+                        );
+                        scripts.insert(
+                            "remove-local".to_string(),
+                            serde_json::json!(format!(
+                                "graph remove --node http://localhost:8020/ {}",
+                                subgraph_name
+                            )),
+                        );
+                        scripts.insert(
+                            "deploy-local".to_string(),
+                            serde_json::json!(format!(
+                                "graph deploy --node http://localhost:8020/ --ipfs http://localhost:5001 {}",
+                                subgraph_name
+                            )),
+                        );
+                    }
+                }
+
+                fs::write(&package_path, serde_json::to_string_pretty(&package)?)?;
+            }
+            Ok(())
+        },
+    )
+}
+
+/// Initialize git repository with spinner.
+fn init_git_with_spinner(directory: &Path) -> Result<()> {
+    use std::process::{Command, Stdio};
+
+    with_spinner(
+        "Initialize subgraph repository",
+        "Failed to initialize git repository",
+        "Git initialized with warnings",
+        |_spinner| {
+            // Remove any existing .git directory (from the cloned example)
+            let git_dir = directory.join(".git");
+            if git_dir.exists() {
+                fs::remove_dir_all(&git_dir)?;
+            }
+
+            // Initialize fresh git repo
+            let status = Command::new("git")
+                .current_dir(directory)
+                .arg("init")
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status()?;
+
+            if !status.success() {
+                return Err(anyhow!("git init failed"));
+            }
+
+            // Stage all files
+            let _ = Command::new("git")
+                .current_dir(directory)
+                .args(["add", "--all"])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status();
+
+            // Create initial commit
+            let _ = Command::new("git")
+                .current_dir(directory)
+                .args(["commit", "-m", "Initial commit"])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status();
+
+            Ok(())
+        },
+    )
+}
+
+/// Run codegen with spinner.
+fn run_codegen_with_spinner(directory: &Path) -> Result<()> {
+    use std::process::{Command, Stdio};
+
+    // Detect package manager
+    let pkg_manager = if directory.join("pnpm-lock.yaml").exists() {
+        "pnpm"
+    } else if directory.join("yarn.lock").exists() {
+        "yarn"
+    } else {
+        "npm"
+    };
+
+    with_spinner(
+        format!("Generate ABI and schema types with {} codegen", pkg_manager),
+        "Failed to run codegen",
+        "Codegen completed with warnings",
+        |_spinner| {
+            let status = Command::new(pkg_manager)
+                .current_dir(directory)
+                .args(["run", "codegen"])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status()?;
+
+            if !status.success() {
+                return Err(anyhow!("codegen failed"));
+            }
+
+            Ok(())
+        },
+    )
+}
+
+/// Print the "Next steps" message in graph-cli format.
+fn print_next_steps(subgraph_name: &str, directory: &Path) {
+    let basename = subgraph_name
+        .split('/')
+        .next_back()
+        .unwrap_or(subgraph_name);
+    let dir_name = directory
+        .file_name()
+        .map(|s| s.to_string_lossy().to_string())
+        .unwrap_or_else(|| directory.to_string_lossy().to_string());
+
+    println!();
+    println!("Subgraph {} created in {}", basename, dir_name);
+    println!();
+    println!("Next steps:");
+    println!();
+    println!("  1. Run `graph auth` to authenticate with your deploy key.");
+    println!();
+    println!("  2. Type `cd {}` to enter the subgraph.", dir_name);
+    println!();
+    println!("  3. Run `yarn deploy` to deploy the subgraph.");
+    println!();
+    println!(
+        "Make sure to visit the documentation on https://thegraph.com/docs/ for further information."
+    );
+}
+
+/// Initialize a subgraph from an existing deployed subgraph.
+///
+/// This creates a new subgraph scaffold based on an existing subgraph deployment,
+/// extracting immutable entities from the deployed schema.
+async fn init_from_subgraph(opt: &InitOpt) -> Result<()> {
+    let deployment_id = opt
+        .from_subgraph
+        .as_ref()
+        .ok_or_else(|| anyhow!("Deployment ID is required for --from-subgraph"))?;
+
+    let network = opt.network.as_deref().unwrap_or("mainnet");
+
+    // Determine IPFS URL
+    let ipfs_url = opt
+        .ipfs
+        .as_deref()
+        .unwrap_or("https://api.thegraph.com/ipfs");
+
+    step(
+        Step::Load,
+        &format!("Fetching subgraph {} from IPFS", deployment_id),
+    );
+
+    // Create IPFS client
+    let ipfs_client = IpfsClient::new(ipfs_url)?;
+
+    // Fetch the manifest from IPFS
+    let manifest_yaml = ipfs_client.fetch_manifest(deployment_id).await?;
+
+    step(Step::Done, "Manifest fetched successfully");
+
+    // Parse the manifest
+    let manifest: serde_yaml::Value =
+        serde_yaml::from_str(&manifest_yaml).context("Failed to parse subgraph manifest YAML")?;
+
+    // Validate network matches
+    if let Some(manifest_network) = extract_network(&manifest)
+        && manifest_network != network
+    {
+        return Err(anyhow!(
+            "Network mismatch: The source subgraph is indexing '{}', but you specified '{}'.\n\
+                 When composing subgraphs, they must index the same network.",
+            manifest_network,
+            network
+        ));
+    }
+
+    // Get start block from manifest if not provided
+    let start_block = opt
+        .start_block
+        .as_ref()
+        .and_then(|s| s.parse::<u64>().ok())
+        .or_else(|| get_min_start_block(&manifest));
+
+    // Extract schema CID from manifest
+    let schema_cid = extract_schema_cid(&manifest).ok_or_else(|| {
+        anyhow!("Could not find schema CID in manifest. Expected schema.file['/'] field.")
+    })?;
+
+    step(Step::Load, &format!("Fetching schema {}", schema_cid));
+
+    // Fetch the schema from IPFS
+    let schema_content = ipfs_client.fetch_schema(&schema_cid).await?;
+
+    step(Step::Done, "Schema fetched successfully");
+
+    // Find immutable entities in the schema
+    let immutable_entities = find_immutable_entities(&schema_content)?;
+
+    if immutable_entities.is_empty() {
+        return Err(anyhow!(
+            "Source subgraph must have at least one immutable entity.\n\
+             This subgraph cannot be used as a source subgraph since it has no immutable entities.\n\n\
+             Immutable entities are marked with @entity(immutable: true) in the schema."
+        ));
+    }
+
+    step(
+        Step::Generate,
+        &format!(
+            "Found {} immutable entities: {}",
+            immutable_entities.len(),
+            immutable_entities.join(", ")
+        ),
+    );
+
+    // Determine subgraph name
+    let subgraph_name = opt
+        .subgraph_name
+        .clone()
+        .unwrap_or_else(|| "composed-subgraph".to_string());
+
+    // Determine directory
+    let initial_directory = opt.directory.clone().unwrap_or_else(|| {
+        PathBuf::from(subgraph_name.split('/').next_back().unwrap_or("subgraph"))
+    });
+
+    // Resolve directory collision by prompting for a new name if needed
+    let directory = PathBuf::from(resolve_directory_collision(&initial_directory)?);
+
+    // Generate scaffold with immutable entities
+    let scaffold_options = ScaffoldOptions {
+        address: None,
+        network: network.to_string(),
+        contract_name: "Contract".to_string(),
+        subgraph_name: subgraph_name.clone(),
+        start_block,
+        abi: None,
+        index_events: false,
+    };
+
+    generate_scaffold(&directory, &scaffold_options)?;
+
+    // Write the fetched schema to the subgraph
+    let schema_path = directory.join("schema.graphql");
+    fs::write(&schema_path, &schema_content)
+        .with_context(|| format!("Failed to write schema to {}", schema_path.display()))?;
+
+    // Update the manifest with the source subgraph reference
+    update_manifest_with_source(&directory, deployment_id, &immutable_entities)?;
+
+    // Initialize git unless skipped
+    if !opt.skip_git {
+        let _ = init_git(&directory);
+    }
+
+    // Install dependencies unless skipped
+    if !opt.skip_install
+        && let Err(e) = install_dependencies(&directory)
+    {
+        eprintln!("Warning: {}", e);
+    }
+
+    step(
+        Step::Done,
+        &format!("Subgraph created at {}", directory.display()),
+    );
+
+    println!();
+    println!("Next steps:");
+    println!("  cd {}", directory.display());
+    println!("  # Edit subgraph.yaml to add your own data sources");
+    println!("  # The source subgraph's immutable entities are available via grafting");
+    println!("  gnd codegen");
+    println!("  gnd build");
+
+    Ok(())
+}
+
+// ============================================================================
+// Manifest Parsing Utilities
+// ============================================================================
+
+/// Extract the schema CID from a subgraph manifest.
+///
+/// The schema is typically at `schema.file["/"]` in the manifest YAML.
+fn extract_schema_cid(manifest: &serde_yaml::Value) -> Option<String> {
+    let schema = manifest.get("schema")?;
+    let file = schema.get("file")?;
+    let cid = file.get("/")?;
+    let cid_str = cid.as_str()?;
+
+    // Strip /ipfs/ prefix if present
+    Some(
+        cid_str
+            .strip_prefix("/ipfs/")
+            .unwrap_or(cid_str)
+            .to_string(),
+    )
+}
+
+/// Extract the network from the first data source in a manifest.
+fn extract_network(manifest: &serde_yaml::Value) -> Option<String> {
+    let data_sources = manifest.get("dataSources")?.as_sequence()?;
+    let first_ds = data_sources.first()?;
+    let network = first_ds.get("network")?.as_str()?;
+    Some(network.to_string())
+}
+
+/// Get the minimum start block from all data sources.
+fn get_min_start_block(manifest: &serde_yaml::Value) -> Option<u64> {
+    let data_sources = manifest.get("dataSources")?.as_sequence()?;
+
+    let start_blocks: Vec<u64> = data_sources
+        .iter()
+        .filter_map(|ds| {
+            ds.get("source")
+                .and_then(|s| s.get("startBlock"))
+                .and_then(|b| b.as_u64())
+        })
+        .collect();
+
+    start_blocks.into_iter().min()
+}
+
+// ============================================================================
+// Schema Parsing Utilities
+// ============================================================================
+
+/// Find all immutable entities in a GraphQL schema.
+///
+/// Immutable entities are marked with `@entity(immutable: true)`.
+fn find_immutable_entities(schema: &str) -> Result<Vec<String>> {
+    let ast = gql::parse_schema::<String>(schema)
+        .map_err(|e| anyhow!("Failed to parse GraphQL schema: {}", e))?;
+
+    let mut immutable_entities = Vec::new();
+
+    for def in ast.definitions {
+        if let gql::Definition::TypeDefinition(gql::TypeDefinition::Object(obj)) = def {
+            // Check if this type has @entity(immutable: true)
+            if is_immutable_entity(&obj) {
+                immutable_entities.push(obj.name);
+            }
+        }
+    }
+
+    Ok(immutable_entities)
+}
+
+/// Check if an object type has the @entity(immutable: true) directive.
+fn is_immutable_entity(obj: &gql::ObjectType<String>) -> bool {
+    for directive in &obj.directives {
+        if directive.name == "entity" {
+            for (name, value) in &directive.arguments {
+                if name == "immutable"
+                    && let gql::Value::Boolean(true) = value
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
+
+/// Update the generated manifest to include the source subgraph reference.
+fn update_manifest_with_source(
+    directory: &Path,
+    source_deployment: &str,
+    _immutable_entities: &[String],
+) -> Result<()> {
+    let manifest_path = directory.join("subgraph.yaml");
+
+    // Read the generated manifest
+    let manifest_content = fs::read_to_string(&manifest_path)
+        .with_context(|| format!("Failed to read manifest at {}", manifest_path.display()))?;
+
+    // Add a comment about the source subgraph at the top
+    let updated_content = format!(
+        "# This subgraph composes data from an existing subgraph.\n\
+         # Source deployment: {}\n\
+         #\n\
+         # To access the source subgraph's immutable entities, you can use grafting:\n\
+         # features:\n\
+         #   - grafting\n\
+         # graft:\n\
+         #   base: {}\n\
+         #   block: <block-number>\n\
+         #\n{}",
+        source_deployment, source_deployment, manifest_content
+    );
+
+    fs::write(&manifest_path, updated_content)
+        .with_context(|| format!("Failed to update manifest at {}", manifest_path.display()))?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_protocol_display() {
+        assert_eq!(Protocol::Ethereum.to_string(), "ethereum");
+        assert_eq!(Protocol::Near.to_string(), "near");
+        assert_eq!(Protocol::Cosmos.to_string(), "cosmos");
+        assert_eq!(Protocol::Arweave.to_string(), "arweave");
+        assert_eq!(Protocol::Substreams.to_string(), "substreams");
+    }
+
+    #[test]
+    fn test_should_run_interactive() {
+        // Example mode should not be interactive
+        let opt = InitOpt {
+            from_example: Some("gravatar".to_string()),
+            ..Default::default()
+        };
+        assert!(!should_run_interactive(&opt));
+
+        // Contract with network should not be interactive
+        let opt = InitOpt {
+            from_contract: Some("0x1234567890123456789012345678901234567890".to_string()),
+            network: Some("mainnet".to_string()),
+            ..Default::default()
+        };
+        assert!(!should_run_interactive(&opt));
+
+        // Contract without network should be interactive
+        let opt = InitOpt {
+            from_contract: Some("0x1234567890123456789012345678901234567890".to_string()),
+            ..Default::default()
+        };
+        assert!(should_run_interactive(&opt));
+
+        // No source should be interactive
+        let opt = InitOpt::default();
+        assert!(should_run_interactive(&opt));
+
+        // from_subgraph should not be interactive (will error)
+        let opt = InitOpt {
+            from_subgraph: Some("Qm123".to_string()),
+            ..Default::default()
+        };
+        assert!(!should_run_interactive(&opt));
+    }
+
+    #[test]
+    fn test_init_opt_default() {
+        let opt = InitOpt::default();
+        assert!(opt.subgraph_name.is_none());
+        assert!(opt.directory.is_none());
+        assert!(opt.protocol.is_none());
+        assert!(opt.node.is_none());
+        assert!(opt.from_contract.is_none());
+        assert!(opt.from_example.is_none());
+        assert!(opt.from_subgraph.is_none());
+        assert!(opt.contract_name.is_none());
+        assert!(!opt.index_events);
+        assert!(!opt.skip_install);
+        assert!(!opt.skip_git);
+        assert!(opt.start_block.is_none());
+        assert!(opt.abi.is_none());
+        assert!(opt.network.is_none());
+        assert!(opt.ipfs.is_none());
+    }
+
+    // ========================================================================
+    // Manifest Parsing Tests
+    // ========================================================================
+
+    #[test]
+    fn test_extract_schema_cid() {
+        // Standard manifest format with /ipfs/ prefix
+        let manifest: serde_yaml::Value = serde_yaml::from_str(
+            r#"
+            schema:
+              file:
+                "/": "/ipfs/QmSchemaHash123"
+            "#,
+        )
+        .unwrap();
+        assert_eq!(
+            extract_schema_cid(&manifest),
+            Some("QmSchemaHash123".to_string())
+        );
+
+        // Manifest without /ipfs/ prefix
+        let manifest: serde_yaml::Value = serde_yaml::from_str(
+            r#"
+            schema:
+              file:
+                "/": "QmSchemaHash456"
+            "#,
+        )
+        .unwrap();
+        assert_eq!(
+            extract_schema_cid(&manifest),
+            Some("QmSchemaHash456".to_string())
+        );
+
+        // Missing schema
+        let manifest: serde_yaml::Value = serde_yaml::from_str(r#"dataSources: []"#).unwrap();
+        assert_eq!(extract_schema_cid(&manifest), None);
+
+        // Missing file
+        let manifest: serde_yaml::Value = serde_yaml::from_str(r#"schema: {}"#).unwrap();
+        assert_eq!(extract_schema_cid(&manifest), None);
+    }
+
+    #[test]
+    fn test_extract_network() {
+        // Standard manifest with network
+        let manifest: serde_yaml::Value = serde_yaml::from_str(
+            r#"
+            dataSources:
+              - network: mainnet
+                source:
+                  address: "0x123"
+            "#,
+        )
+        .unwrap();
+        assert_eq!(extract_network(&manifest), Some("mainnet".to_string()));
+
+        // Multiple data sources
+        let manifest: serde_yaml::Value = serde_yaml::from_str(
+            r#"
+            dataSources:
+              - network: polygon
+                source:
+                  address: "0x123"
+              - network: polygon
+                source:
+                  address: "0x456"
+            "#,
+        )
+        .unwrap();
+        assert_eq!(extract_network(&manifest), Some("polygon".to_string()));
+
+        // No data sources
+        let manifest: serde_yaml::Value = serde_yaml::from_str(r#"dataSources: []"#).unwrap();
+        assert_eq!(extract_network(&manifest), None);
+
+        // Missing dataSources
+        let manifest: serde_yaml::Value = serde_yaml::from_str(r#"schema: {}"#).unwrap();
+        assert_eq!(extract_network(&manifest), None);
+    }
+
+    #[test]
+    fn test_get_min_start_block() {
+        // Multiple data sources with start blocks
+        let manifest: serde_yaml::Value = serde_yaml::from_str(
+            r#"
+            dataSources:
+              - source:
+                  startBlock: 100
+              - source:
+                  startBlock: 50
+              - source:
+                  startBlock: 200
+            "#,
+        )
+        .unwrap();
+        assert_eq!(get_min_start_block(&manifest), Some(50));
+
+        // Mixed with and without start blocks
+        let manifest: serde_yaml::Value = serde_yaml::from_str(
+            r#"
+            dataSources:
+              - source:
+                  address: "0x123"
+              - source:
+                  startBlock: 150
+              - source:
+                  startBlock: 75
+            "#,
+        )
+        .unwrap();
+        assert_eq!(get_min_start_block(&manifest), Some(75));
+
+        // No start blocks
+        let manifest: serde_yaml::Value = serde_yaml::from_str(
+            r#"
+            dataSources:
+              - source:
+                  address: "0x123"
+            "#,
+        )
+        .unwrap();
+        assert_eq!(get_min_start_block(&manifest), None);
+
+        // Empty data sources
+        let manifest: serde_yaml::Value = serde_yaml::from_str(r#"dataSources: []"#).unwrap();
+        assert_eq!(get_min_start_block(&manifest), None);
+    }
+
+    // ========================================================================
+    // Schema Parsing Tests
+    // ========================================================================
+
+    #[test]
+    fn test_find_immutable_entities() {
+        // Schema with immutable entities
+        let schema = r#"
+            type Transfer @entity(immutable: true) {
+                id: ID!
+                from: Bytes!
+                to: Bytes!
+                amount: BigInt!
+            }
+
+            type Account @entity {
+                id: ID!
+                balance: BigInt!
+            }
+
+            type Approval @entity(immutable: true) {
+                id: ID!
+                owner: Bytes!
+                spender: Bytes!
+            }
+        "#;
+
+        let entities = find_immutable_entities(schema).unwrap();
+        assert_eq!(entities.len(), 2);
+        assert!(entities.contains(&"Transfer".to_string()));
+        assert!(entities.contains(&"Approval".to_string()));
+        assert!(!entities.contains(&"Account".to_string()));
+    }
+
+    #[test]
+    fn test_find_immutable_entities_none() {
+        // Schema with no immutable entities
+        let schema = r#"
+            type Account @entity {
+                id: ID!
+                balance: BigInt!
+            }
+
+            type Token @entity {
+                id: ID!
+                name: String!
+            }
+        "#;
+
+        let entities = find_immutable_entities(schema).unwrap();
+        assert!(entities.is_empty());
+    }
+
+    #[test]
+    fn test_find_immutable_entities_explicit_false() {
+        // Entity with immutable: false should not be included
+        let schema = r#"
+            type Transfer @entity(immutable: false) {
+                id: ID!
+                amount: BigInt!
+            }
+
+            type Withdrawal @entity(immutable: true) {
+                id: ID!
+                amount: BigInt!
+            }
+        "#;
+
+        let entities = find_immutable_entities(schema).unwrap();
+        assert_eq!(entities.len(), 1);
+        assert!(entities.contains(&"Withdrawal".to_string()));
+    }
+
+    #[test]
+    fn test_is_immutable_entity() {
+        let schema = r#"
+            type Transfer @entity(immutable: true) {
+                id: ID!
+            }
+        "#;
+
+        let ast = gql::parse_schema::<String>(schema).unwrap();
+        for def in ast.definitions {
+            if let gql::Definition::TypeDefinition(gql::TypeDefinition::Object(obj)) = def
+                && obj.name == "Transfer"
+            {
+                assert!(is_immutable_entity(&obj));
+            }
+        }
+
+        // Non-immutable entity
+        let schema = r#"
+            type Account @entity {
+                id: ID!
+            }
+        "#;
+
+        let ast = gql::parse_schema::<String>(schema).unwrap();
+        for def in ast.definitions {
+            if let gql::Definition::TypeDefinition(gql::TypeDefinition::Object(obj)) = def
+                && obj.name == "Account"
+            {
+                assert!(!is_immutable_entity(&obj));
+            }
+        }
+    }
+}
diff --git a/gnd/src/commands/mod.rs b/gnd/src/commands/mod.rs
new file mode 100644
index 00000000000..5867cc8d584
--- /dev/null
+++ b/gnd/src/commands/mod.rs
@@ -0,0 +1,25 @@
+mod add;
+mod auth;
+mod build;
+mod clean;
+mod codegen;
+mod create;
+mod deploy;
+mod dev;
+mod init;
+mod publish;
+mod remove;
+mod test;
+
+pub use add::{AddOpt, run_add};
+pub use auth::{AuthOpt, get_deploy_key, run_auth};
+pub use build::{BuildOpt, run_build};
+pub use clean::{CleanOpt, run_clean};
+pub use codegen::{CodegenOpt, run_codegen};
+pub use create::{CreateOpt, run_create};
+pub use deploy::{DeployOpt, run_deploy};
+pub use dev::{DevOpt, run_dev};
+pub use init::{InitOpt, run_init};
+pub use publish::{PublishOpt, run_publish};
+pub use remove::{RemoveOpt, run_remove};
+pub use test::{TestOpt, run_test};
diff --git a/gnd/src/commands/publish.rs b/gnd/src/commands/publish.rs
new file mode 100644
index 00000000000..e07a57de999
--- /dev/null
+++ b/gnd/src/commands/publish.rs
@@ -0,0 +1,249 @@
+//! Publish command for publishing subgraphs to The Graph's decentralized network.
+//!
+//! This command builds a subgraph, uploads it to IPFS, and opens a browser
+//! to complete the publishing process on The Graph Network.
+
+use std::path::PathBuf;
+
+use anyhow::{Result, anyhow};
+use clap::Parser;
+use inquire::Confirm;
+
+use crate::commands::build::{BuildOpt, run_build};
+use crate::output::{Step, step};
+
+/// Default IPFS URL for The Graph's hosted IPFS node.
+const DEFAULT_IPFS_URL: &str = "https://api.thegraph.com/ipfs/api/v0";
+
+/// Default webapp URL for publishing.
+const DEFAULT_WEBAPP_URL: &str = "https://cli.thegraph.com/publish";
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Publish a subgraph to The Graph's decentralized network")]
+pub struct PublishOpt {
+    /// Path to the subgraph manifest
+    #[clap(default_value = "subgraph.yaml")]
+    pub manifest: PathBuf,
+
+    /// IPFS node URL to upload build results to
+    #[clap(short = 'i', long, default_value = DEFAULT_IPFS_URL)]
+    pub ipfs: String,
+
+    /// IPFS hash of the subgraph manifest to deploy (skips build)
+    #[clap(long)]
+    pub ipfs_hash: Option<String>,
+
+    /// Subgraph ID to publish to (for updating existing subgraphs)
+    #[clap(long)]
+    pub subgraph_id: Option<String>,
+
+    /// The network to use for the subgraph deployment
+    #[clap(long, default_value = "arbitrum-one")]
+    pub protocol_network: String,
+
+    /// The API key for Subgraph queries (required when updating existing subgraph)
+    #[clap(long)]
+    pub api_key: Option<String>,
+
+    /// URL of the web UI to use for publishing
+    #[clap(long, default_value = DEFAULT_WEBAPP_URL)]
+    pub webapp_url: String,
+
+    /// Output directory for build results
+    #[clap(short = 'o', long, default_value = "build/")]
+    pub output_dir: PathBuf,
+
+    /// Skip subgraph migrations
+    #[clap(long)]
+    pub skip_migrations: bool,
+
+    /// Network configuration to use from the networks config file
+    #[clap(long)]
+    pub network: Option<String>,
+
+    /// Networks config file path
+    #[clap(long, default_value = "networks.json")]
+    pub network_file: PathBuf,
+
+    /// Skip the asc version check (use with caution)
+    #[clap(long, env = "GND_SKIP_ASC_VERSION_CHECK")]
+    pub skip_asc_version_check: bool,
+}
+
+/// Run the publish command.
+pub async fn run_publish(opt: PublishOpt) -> Result<()> {
+    // Validate: if subgraph_id is provided, api_key is required
+    if opt.subgraph_id.is_some() && opt.api_key.is_none() {
+        return Err(anyhow!(
+            "API key is required to publish to an existing subgraph (--api-key).\n\
+             See https://thegraph.com/docs/en/deploying/subgraph-studio-faqs/#2-how-do-i-create-an-api-key"
+        ));
+    }
+
+    // Validate protocol network
+    if opt.protocol_network != "arbitrum-one" && opt.protocol_network != "arbitrum-sepolia" {
+        return Err(anyhow!(
+            "Invalid protocol network '{}'. Must be 'arbitrum-one' or 'arbitrum-sepolia'",
+            opt.protocol_network
+        ));
+    }
+
+    // Extract URL-related fields before potentially moving opt fields into BuildOpt
+    let webapp_url = opt.webapp_url.clone();
+    let subgraph_id = opt.subgraph_id.clone();
+    let protocol_network = opt.protocol_network.clone();
+    let api_key = opt.api_key.clone();
+
+    // Get the IPFS hash - either from flag or by building
+    let ipfs_hash = if let Some(hash) = opt.ipfs_hash {
+        step(Step::Skip, "Using provided IPFS hash");
+        hash
+    } else {
+        // Build the subgraph and upload to IPFS
+        step(Step::Load, "Building subgraph for publishing");
+
+        // Validate manifest exists
+        if !opt.manifest.exists() {
+            return Err(anyhow!(
+                "Manifest '{}' not found.\n\
+                 Please provide either:\n\
+                 - A valid manifest path: gnd publish <manifest>\n\
+                 - An IPFS hash: gnd publish --ipfs-hash <hash>",
+                opt.manifest.display()
+            ));
+        }
+
+        let build_opt = BuildOpt {
+            manifest: opt.manifest,
+            output_dir: opt.output_dir,
+            output_format: "wasm".to_string(),
+            skip_migrations: opt.skip_migrations,
+            watch: false,
+            ipfs: Some(opt.ipfs),
+            network: opt.network,
+            network_file: opt.network_file,
+            skip_asc_version_check: opt.skip_asc_version_check,
+        };
+
+        match run_build(build_opt).await? {
+            Some(hash) => hash,
+            None => {
+                return Err(anyhow!(
+                    "Build completed but IPFS upload failed. Cannot proceed with publish."
+                ));
+            }
+        }
+    };
+
+    // Prompt user to open browser
+    step(Step::Generate, "Ready to publish to The Graph Network");
+
+    let open_browser = Confirm::new("Open browser to continue publishing?")
+        .with_default(true)
+        .prompt()?;
+
+    if !open_browser {
+        println!("\nTo publish manually, visit:");
+        println!(
+            "  {}",
+            build_publish_url(
+                &webapp_url,
+                &ipfs_hash,
+                &subgraph_id,
+                &protocol_network,
+                &api_key
+            )
+        );
+        return Ok(());
+    }
+
+    // Build the URL with query parameters
+    let url = build_publish_url(
+        &webapp_url,
+        &ipfs_hash,
+        &subgraph_id,
+        &protocol_network,
+        &api_key,
+    );
+
+    step(Step::Done, "Opening browser to complete publishing");
+    println!("\n  {}\n", url);
+
+    // Open the browser
+    open::that(&url).map_err(|e| anyhow!("Failed to open browser: {}", e))?;
+
+    Ok(())
+}
+
+/// Build the publish URL with query parameters.
+fn build_publish_url(
+    base_url: &str,
+    ipfs_hash: &str,
+    subgraph_id: &Option<String>,
+    protocol_network: &str,
+    api_key: &Option<String>,
+) -> String {
+    let mut params = vec![format!("id={}", ipfs_hash)];
+
+    if let Some(id) = subgraph_id {
+        params.push(format!("subgraphId={}", id));
+    }
+
+    params.push(format!("network={}", protocol_network));
+
+    if let Some(key) = api_key {
+        params.push(format!("apiKey={}", key));
+    }
+
+    format!("{}?{}", base_url, params.join("&"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_build_publish_url_basic() {
+        let url = build_publish_url(
+            DEFAULT_WEBAPP_URL,
+            "QmTest123",
+            &None,
+            "arbitrum-one",
+            &None,
+        );
+        assert_eq!(
+            url,
+            "https://cli.thegraph.com/publish?id=QmTest123&network=arbitrum-one"
+        );
+    }
+
+    #[test]
+    fn test_build_publish_url_with_subgraph_id() {
+        let url = build_publish_url(
+            DEFAULT_WEBAPP_URL,
+            "QmTest456",
+            &Some("my-subgraph".to_string()),
+            "arbitrum-sepolia",
+            &Some("abc123".to_string()),
+        );
+        assert_eq!(
+            url,
+            "https://cli.thegraph.com/publish?id=QmTest456&subgraphId=my-subgraph&network=arbitrum-sepolia&apiKey=abc123"
+        );
+    }
+
+    #[test]
+    fn test_build_publish_url_custom_webapp() {
+        let url = build_publish_url(
+            "https://custom.example.com/publish",
+            "QmCustom",
+            &None,
+            "arbitrum-one",
+            &None,
+        );
+        assert_eq!(
+            url,
+            "https://custom.example.com/publish?id=QmCustom&network=arbitrum-one"
+        );
+    }
+}
diff --git a/gnd/src/commands/remove.rs b/gnd/src/commands/remove.rs
new file mode 100644
index 00000000000..52cac738968
--- /dev/null
+++ b/gnd/src/commands/remove.rs
@@ -0,0 +1,96 @@
+use anyhow::{Context, Result};
+use clap::Parser;
+
+use crate::commands::auth::get_deploy_key;
+use crate::services::GraphNodeClient;
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Unregister a subgraph name from a Graph Node")]
+pub struct RemoveOpt {
+    /// The subgraph name to unregister
+    #[clap(value_name = "SUBGRAPH_NAME")]
+    pub subgraph_name: String,
+
+    /// Graph Node admin URL
+    #[clap(long, short = 'g', value_name = "URL", help = "Graph Node URL")]
+    pub node: String,
+
+    /// Access token for authentication
+    #[clap(long, value_name = "TOKEN", help = "Graph access token")]
+    pub access_token: Option<String>,
+}
+
+/// Run the remove command
+pub async fn run_remove(opt: RemoveOpt) -> Result<()> {
+    println!("Removing subgraph from Graph node: {}", opt.node);
+
+    // Get access token (from flag or from config)
+    let access_token = match &opt.access_token {
+        Some(token) => Some(token.clone()),
+        None => get_deploy_key(&opt.node)
+            .ok()
+            .flatten()
+            .map(|key| key.to_string()),
+    };
+
+    let client = GraphNodeClient::new(&opt.node, access_token.as_deref())
+        .context("Failed to create Graph Node client")?;
+
+    client
+        .remove_subgraph(&opt.subgraph_name)
+        .await
+        .context("Failed to remove subgraph")?;
+
+    println!("✔ Removed subgraph: {}", opt.subgraph_name);
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_remove_opt_parsing() {
+        // Test that required args are enforced
+        let result = RemoveOpt::try_parse_from(["remove"]);
+        assert!(result.is_err());
+
+        // Test with just subgraph name (missing --node)
+        let result = RemoveOpt::try_parse_from(["remove", "user/subgraph"]);
+        assert!(result.is_err());
+
+        // Test with all required args
+        let result = RemoveOpt::try_parse_from([
+            "remove",
+            "user/subgraph",
+            "--node",
+            "http://localhost:8020",
+        ]);
+        assert!(result.is_ok());
+        let opt = result.unwrap();
+        assert_eq!(opt.subgraph_name, "user/subgraph");
+        assert_eq!(opt.node, "http://localhost:8020");
+        assert!(opt.access_token.is_none());
+
+        // Test with access token
+        let result = RemoveOpt::try_parse_from([
+            "remove",
+            "user/subgraph",
+            "--node",
+            "http://localhost:8020",
+            "--access-token",
+            "my-token",
+        ]);
+        assert!(result.is_ok());
+        let opt = result.unwrap();
+        assert_eq!(opt.access_token, Some("my-token".to_string()));
+
+        // Test short flag for node
+        let result =
+            RemoveOpt::try_parse_from(["remove", "user/subgraph", "-g", "http://localhost:8020"]);
+        assert!(result.is_ok());
+        let opt = result.unwrap();
+        assert_eq!(opt.node, "http://localhost:8020");
+    }
+}
diff --git a/gnd/src/commands/test/assertion.rs b/gnd/src/commands/test/assertion.rs
new file mode 100644
index 00000000000..9d6455c69bb
--- /dev/null
+++ b/gnd/src/commands/test/assertion.rs
@@ -0,0 +1,192 @@
+//! GraphQL assertion execution for test validation.
+
+use super::runner::TestContext;
+use super::schema::{Assertion, AssertionFailure, AssertionOutcome, TestResult};
+use anyhow::{Result, anyhow};
+use graph::data::query::{Query, QueryResults, QueryTarget};
+use graph::prelude::{ApiVersion, GraphQlRunner as GraphQlRunnerTrait, q};
+
+pub(super) async fn run_assertions(
+    ctx: &TestContext,
+    assertions: &[Assertion],
+) -> Result<TestResult> {
+    let mut outcomes = Vec::new();
+
+    for assertion in assertions {
+        match run_single_assertion(ctx, assertion).await {
+            Ok(None) => {
+                outcomes.push(AssertionOutcome::Passed {
+                    query: assertion.query.clone(),
+                });
+            }
+            Ok(Some(failure)) => {
+                outcomes.push(AssertionOutcome::Failed(failure));
+            }
+            Err(e) => {
+                outcomes.push(AssertionOutcome::Failed(AssertionFailure {
+                    query: assertion.query.clone(),
+                    expected: assertion.expected.clone(),
+                    actual: serde_json::json!({ "error": e.to_string() }),
+                }));
+            }
+        }
+    }
+
+    Ok(TestResult {
+        handler_error: None,
+        assertions: outcomes,
+    })
+}
+
+/// Execute a single assertion. Returns `None` on pass, `Some(failure)` on mismatch.
+async fn run_single_assertion(
+    ctx: &TestContext,
+    assertion: &Assertion,
+) -> Result<Option<AssertionFailure>> {
+    let target = QueryTarget::Deployment(ctx.deployment.hash.clone(), ApiVersion::default());
+    let query = Query::new(
+        q::parse_query(&assertion.query)
+            .map_err(|e| anyhow!("Failed to parse query: {:?}", e))?
+            .into_static(),
+        None,
+        false,
+    );
+
+    let query_res: QueryResults = ctx.graphql_runner.clone().run_query(query, target).await;
+
+    let result = query_res
+        .first()
+        .ok_or_else(|| anyhow!("No query result"))?
+        .duplicate()
+        .to_result()
+        .map_err(|errors| anyhow!("Query errors: {:?}", errors))?;
+
+    let actual_json = match result {
+        Some(value) => serde_json::to_value(&value)?,
+        None => serde_json::Value::Null,
+    };
+
+    if json_equal(&actual_json, &assertion.expected) {
+        Ok(None)
+    } else {
+        Ok(Some(AssertionFailure {
+            query: assertion.query.clone(),
+            expected: assertion.expected.clone(),
+            actual: actual_json,
+        }))
+    }
+}
+
+/// Reorder `actual` arrays to match `expected`'s element order for cleaner diffs.
+///
+/// Without this, out-of-order elements show every field as changed even when
+/// only one field differs.
+pub(super) fn align_for_diff(
+    expected: &serde_json::Value,
+    actual: &serde_json::Value,
+) -> serde_json::Value {
+    match (expected, actual) {
+        (serde_json::Value::Array(exp), serde_json::Value::Array(act)) => {
+            let mut used = vec![false; act.len()];
+            let mut aligned = Vec::with_capacity(exp.len().max(act.len()));
+
+            for exp_elem in exp {
+                let best = act
+                    .iter()
+                    .enumerate()
+                    .filter(|(i, _)| !used[*i])
+                    .max_by_key(|(_, a)| json_similarity(exp_elem, a));
+
+                if let Some((idx, _)) = best {
+                    used[idx] = true;
+                    aligned.push(align_for_diff(exp_elem, &act[idx]));
+                }
+            }
+
+            for (i, elem) in act.iter().enumerate() {
+                if !used[i] {
+                    aligned.push(elem.clone());
+                }
+            }
+
+            serde_json::Value::Array(aligned)
+        }
+        (serde_json::Value::Object(exp), serde_json::Value::Object(act)) => {
+            let aligned: serde_json::Map<String, serde_json::Value> = act
+                .iter()
+                .map(|(k, v)| {
+                    let aligned_v = if let Some(exp_v) = exp.get(k) {
+                        align_for_diff(exp_v, v)
+                    } else {
+                        v.clone()
+                    };
+                    (k.clone(), aligned_v)
+                })
+                .collect();
+            serde_json::Value::Object(aligned)
+        }
+        _ => actual.clone(),
+    }
+}
+
+/// Score JSON similarity for [`align_for_diff`].
+/// Objects: matching `"id"` = 100, other equal fields = 1. Non-objects: 0 or 1.
+fn json_similarity(a: &serde_json::Value, b: &serde_json::Value) -> usize {
+    match (a, b) {
+        (serde_json::Value::Object(a_obj), serde_json::Value::Object(b_obj)) => {
+            let mut score = 0;
+            for (k, v) in a_obj {
+                if let Some(bv) = b_obj.get(k)
+                    && json_equal(v, bv)
+                {
+                    // `id` match is a strong signal for entity identity.
+                    score += if k == "id" { 100 } else { 1 };
+                }
+            }
+            score
+        }
+        _ => {
+            if json_equal(a, b) {
+                1
+            } else {
+                0
+            }
+        }
+    }
+}
+
+/// Compare JSON values for equality, ignoring object key ordering.
+///
+/// Coerces string/number: `"123"` == `123` to handle GraphQL `BigInt`/`BigDecimal`.
+fn json_equal(a: &serde_json::Value, b: &serde_json::Value) -> bool {
+    match (a, b) {
+        (serde_json::Value::Null, serde_json::Value::Null) => true,
+        (serde_json::Value::Bool(a), serde_json::Value::Bool(b)) => a == b,
+        (serde_json::Value::Number(a), serde_json::Value::Number(b)) => a == b,
+        (serde_json::Value::String(a), serde_json::Value::String(b)) => a == b,
+        (serde_json::Value::String(s), serde_json::Value::Number(n))
+        | (serde_json::Value::Number(n), serde_json::Value::String(s)) => s == &n.to_string(),
+        (serde_json::Value::Array(a), serde_json::Value::Array(b)) => {
+            if a.len() != b.len() {
+                return false;
+            }
+            // Order-insensitive: O(n²), fine for realistic test sizes.
+            let mut used = vec![false; b.len()];
+            a.iter().all(|a_elem| {
+                for (i, b_elem) in b.iter().enumerate() {
+                    if !used[i] && json_equal(a_elem, b_elem) {
+                        used[i] = true;
+                        return true;
+                    }
+                }
+                false
+            })
+        }
+        (serde_json::Value::Object(a), serde_json::Value::Object(b)) => {
+            a.len() == b.len()
+                && a.iter()
+                    .all(|(k, v)| b.get(k).map(|bv| json_equal(v, bv)).unwrap_or(false))
+        }
+        _ => false,
+    }
+}
diff --git a/gnd/src/commands/test/block_stream.rs b/gnd/src/commands/test/block_stream.rs
new file mode 100644
index 00000000000..cd8dd8642c3
--- /dev/null
+++ b/gnd/src/commands/test/block_stream.rs
@@ -0,0 +1,105 @@
+//! Mock `BlockStreamBuilder` that feeds pre-defined test blocks.
+
+use async_trait::async_trait;
+use graph::blockchain::block_stream::{
+    BlockStream, BlockStreamBuilder, BlockStreamError, BlockStreamEvent, BlockWithTriggers,
+    FirehoseCursor,
+};
+use graph::blockchain::{BlockPtr, Blockchain, TriggerFilterWrapper};
+use graph::components::store::{DeploymentLocator, SourceableStore};
+use graph::futures03::Stream;
+use graph::prelude::BlockNumber;
+use graph_chain_ethereum::Chain;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context as TaskContext, Poll};
+
+pub(super) struct StaticStreamBuilder {
+    pub chain: Vec<BlockWithTriggers<Chain>>,
+}
+
+#[async_trait]
+impl BlockStreamBuilder<Chain> for StaticStreamBuilder {
+    async fn build_firehose(
+        &self,
+        _chain: &Chain,
+        _deployment: DeploymentLocator,
+        _block_cursor: FirehoseCursor,
+        _start_blocks: Vec<BlockNumber>,
+        current_block: Option<BlockPtr>,
+        _filter: Arc<<Chain as Blockchain>::TriggerFilter>,
+        _unified_api_version: graph::data::subgraph::UnifiedMappingApiVersion,
+    ) -> anyhow::Result<Box<dyn BlockStream<Chain>>> {
+        let current_idx = current_block.map(|current_block| {
+            self.chain
+                .iter()
+                .enumerate()
+                .find(|(_, b)| b.ptr() == current_block)
+                .map(|(i, _)| i)
+                .unwrap_or(0)
+        });
+        Ok(Box::new(StaticStream::new(self.chain.clone(), current_idx)))
+    }
+
+    async fn build_polling(
+        &self,
+        _chain: &Chain,
+        _deployment: DeploymentLocator,
+        _start_blocks: Vec<BlockNumber>,
+        _source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
+        current_block: Option<BlockPtr>,
+        _filter: Arc<TriggerFilterWrapper<Chain>>,
+        _unified_api_version: graph::data::subgraph::UnifiedMappingApiVersion,
+    ) -> anyhow::Result<Box<dyn BlockStream<Chain>>> {
+        let current_idx = current_block.map(|current_block| {
+            self.chain
+                .iter()
+                .enumerate()
+                .find(|(_, b)| b.ptr() == current_block)
+                .map(|(i, _)| i)
+                .unwrap_or(0)
+        });
+        Ok(Box::new(StaticStream::new(self.chain.clone(), current_idx)))
+    }
+}
+
+/// A `Stream` that yields pre-defined blocks synchronously.
+/// Returns `None` when all blocks are emitted, signaling sync completion.
+struct StaticStream {
+    blocks: Vec<BlockWithTriggers<Chain>>,
+    current_idx: usize,
+}
+
+impl StaticStream {
+    /// `skip_to`: if `Some(i)`, start from block `i+1` (block `i` already processed).
+    fn new(blocks: Vec<BlockWithTriggers<Chain>>, skip_to: Option<usize>) -> Self {
+        Self {
+            blocks,
+            current_idx: skip_to.map(|i| i + 1).unwrap_or(0),
+        }
+    }
+}
+
+impl BlockStream<Chain> for StaticStream {
+    fn buffer_size_hint(&self) -> usize {
+        1
+    }
+}
+
+impl Unpin for StaticStream {}
+
+impl Stream for StaticStream {
+    type Item = Result<BlockStreamEvent<Chain>, BlockStreamError>;
+
+    fn poll_next(mut self: Pin<&mut Self>, _cx: &mut TaskContext<'_>) -> Poll<Option<Self::Item>> {
+        if self.current_idx >= self.blocks.len() {
+            return Poll::Ready(None);
+        }
+
+        let block = self.blocks[self.current_idx].clone();
+        let cursor = FirehoseCursor::from(format!("test-cursor-{}", self.current_idx));
+        self.current_idx += 1;
+
+        Poll::Ready(Some(Ok(BlockStreamEvent::ProcessBlock(block, cursor))))
+    }
+}
diff --git a/gnd/src/commands/test/eth_calls.rs b/gnd/src/commands/test/eth_calls.rs
new file mode 100644
index 00000000000..5f9152037a1
--- /dev/null
+++ b/gnd/src/commands/test/eth_calls.rs
@@ -0,0 +1,175 @@
+//! ABI encoding helpers for mock Ethereum call data.
+
+use super::trigger::json_to_sol_value;
+use anyhow::{Context, Result, anyhow};
+use graph::abi::FunctionExt as GraphFunctionExt;
+use graph::prelude::alloy::dyn_abi::{DynSolType, FunctionExt as AlloyFunctionExt};
+use graph::prelude::alloy::json_abi::Function;
+
+/// ABI-encode a function call (selector + params) using graph-node's encoding path.
+pub(super) fn encode_function_call(
+    function_sig: &str,
+    params: &[serde_json::Value],
+) -> Result<Vec<u8>> {
+    let alloy_sig = to_alloy_signature(function_sig);
+    let function = Function::parse(&alloy_sig).map_err(|e| {
+        anyhow!(
+            "Failed to parse function signature '{}': {:?}",
+            function_sig,
+            e
+        )
+    })?;
+
+    if params.len() != function.inputs.len() {
+        return Err(anyhow!(
+            "Parameter count mismatch for '{}': expected {} parameters, got {}",
+            function_sig,
+            function.inputs.len(),
+            params.len()
+        ));
+    }
+
+    let args: Vec<_> = params
+        .iter()
+        .zip(&function.inputs)
+        .map(|(json, param)| {
+            let sol_type: DynSolType = param
+                .ty
+                .parse()
+                .map_err(|e| anyhow!("Invalid type '{}': {:?}", param.ty, e))?;
+            json_to_sol_value(&sol_type, json)
+        })
+        .collect::<Result<Vec<_>>>()?;
+
+    GraphFunctionExt::abi_encode_input(&function, &args).context("Failed to encode function call")
+}
+
+/// ABI-encode function return values (no selector prefix).
+pub(super) fn encode_return_value(
+    function_sig: &str,
+    returns: &[serde_json::Value],
+) -> Result<Vec<u8>> {
+    let alloy_sig = to_alloy_signature(function_sig);
+    let function = Function::parse(&alloy_sig).map_err(|e| {
+        anyhow!(
+            "Failed to parse function signature '{}': {:?}",
+            function_sig,
+            e
+        )
+    })?;
+
+    if returns.len() != function.outputs.len() {
+        return Err(anyhow!(
+            "Return value count mismatch for '{}': expected {} return values, got {}",
+            function_sig,
+            function.outputs.len(),
+            returns.len()
+        ));
+    }
+
+    let output_values: Vec<_> = returns
+        .iter()
+        .zip(&function.outputs)
+        .map(|(json, param)| {
+            let sol_type: DynSolType = param
+                .ty
+                .parse()
+                .map_err(|e| anyhow!("Invalid type '{}': {:?}", param.ty, e))?;
+            json_to_sol_value(&sol_type, json)
+        })
+        .collect::<Result<Vec<_>>>()?;
+
+    AlloyFunctionExt::abi_encode_output(&function, &output_values)
+        .map_err(|e| anyhow!("Failed to encode return value: {}", e))
+}
+
+/// Convert graph-node `name(inputs):(outputs)` to alloy `name(inputs) returns (outputs)`.
+/// Passes through signatures already in alloy format or without outputs.
+pub(super) fn to_alloy_signature(sig: &str) -> String {
+    // If it already contains "returns", assume alloy format.
+    if sig.contains(" returns ") {
+        return sig.to_string();
+    }
+
+    // Look for the "):(" pattern that separates inputs from outputs.
+    if let Some(pos) = sig.find("):(") {
+        let inputs = &sig[..=pos]; // "name(inputs)"
+        let outputs = &sig[pos + 2..]; // "(outputs)"
+        format!("{} returns {}", inputs, outputs)
+    } else {
+        sig.to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_to_alloy_signature_with_colon() {
+        assert_eq!(
+            to_alloy_signature("balanceOf(address):(uint256)"),
+            "balanceOf(address) returns (uint256)"
+        );
+    }
+
+    #[test]
+    fn test_to_alloy_signature_multiple_outputs() {
+        assert_eq!(
+            to_alloy_signature("getReserves():(uint112,uint112,uint32)"),
+            "getReserves() returns (uint112,uint112,uint32)"
+        );
+    }
+
+    #[test]
+    fn test_to_alloy_signature_no_outputs() {
+        assert_eq!(
+            to_alloy_signature("transfer(address,uint256)"),
+            "transfer(address,uint256)"
+        );
+    }
+
+    #[test]
+    fn test_to_alloy_signature_already_alloy_format() {
+        assert_eq!(
+            to_alloy_signature("balanceOf(address) returns (uint256)"),
+            "balanceOf(address) returns (uint256)"
+        );
+    }
+
+    #[test]
+    fn test_encode_function_call_balanceof() {
+        let encoded = encode_function_call(
+            "balanceOf(address):(uint256)",
+            &[serde_json::json!(
+                "0x0000000000000000000000000000000000000001"
+            )],
+        )
+        .unwrap();
+
+        // First 4 bytes should be the selector for balanceOf(address)
+        assert_eq!(&encoded[..4], &[0x70, 0xa0, 0x82, 0x31]);
+        // Total length: 4 (selector) + 32 (address param) = 36
+        assert_eq!(encoded.len(), 36);
+    }
+
+    #[test]
+    fn test_encode_return_value_uint256() {
+        let encoded = encode_return_value(
+            "balanceOf(address):(uint256)",
+            &[serde_json::json!("1000000000000000000")],
+        )
+        .unwrap();
+
+        // ABI-encoded uint256 is 32 bytes (no selector)
+        assert_eq!(encoded.len(), 32);
+    }
+
+    #[test]
+    fn test_encode_function_call_no_params() {
+        let encoded = encode_function_call("symbol():(string)", &[]).unwrap();
+
+        // Just the 4-byte selector
+        assert_eq!(encoded.len(), 4);
+    }
+}
diff --git a/gnd/src/commands/test/matchstick.rs b/gnd/src/commands/test/matchstick.rs
new file mode 100644
index 00000000000..08657366650
--- /dev/null
+++ b/gnd/src/commands/test/matchstick.rs
@@ -0,0 +1,398 @@
+//! Backward-compatible Matchstick test runner (legacy mode).
+//!
+//! Dispatches to Docker mode or binary mode depending on the `--docker` flag.
+//! This is the legacy path for projects that haven't migrated to the new
+//! JSON-based test format yet.
+
+use anyhow::{Context, Result, anyhow};
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use crate::output::{Step, step};
+
+use super::TestOpt;
+
+const MATCHSTICK_GITHUB_RELEASES: &str =
+    "https://api.github.com/repos/LimeChain/matchstick/releases/latest";
+const MATCHSTICK_DOWNLOAD_BASE: &str = "https://github.com/LimeChain/matchstick/releases/download";
+const MATCHSTICK_FALLBACK_VERSION: &str = "0.6.0";
+const VERSION_CACHE_TTL_SECS: u64 = 86400; // 24 hours
+
+/// Cached version info written to `{test_dir}/.latest.json`.
+#[derive(Serialize, Deserialize)]
+struct VersionCache {
+    version: String,
+    timestamp: u64,
+}
+
+pub(super) async fn run(opt: &TestOpt) -> Result<()> {
+    if opt.docker {
+        run_docker_tests(opt).await
+    } else {
+        run_binary_tests(opt).await
+    }
+}
+
+/// Resolve the Matchstick version to use.
+///
+/// Priority: CLI flag → cached `.latest.json` (24h TTL) → GitHub API → fallback.
+async fn resolve_matchstick_version(
+    explicit_version: Option<&str>,
+    cache_dir: &Path,
+) -> Result<String> {
+    if let Some(v) = explicit_version {
+        return Ok(v.to_string());
+    }
+
+    let cache_path = cache_dir.join(".latest.json");
+
+    if let Some(cached) = read_version_cache(&cache_path) {
+        return Ok(cached);
+    }
+
+    step(Step::Load, "Fetching latest Matchstick version");
+    match fetch_latest_version().await {
+        Ok(version) => {
+            let _ = write_version_cache(&cache_path, &version);
+            Ok(version)
+        }
+        Err(e) => {
+            step(
+                Step::Warn,
+                &format!(
+                    "Failed to fetch latest version ({}), using {}",
+                    e, MATCHSTICK_FALLBACK_VERSION
+                ),
+            );
+            Ok(MATCHSTICK_FALLBACK_VERSION.to_string())
+        }
+    }
+}
+
+async fn fetch_latest_version() -> Result<String> {
+    let client = reqwest::Client::builder().user_agent("gnd-cli").build()?;
+
+    let resp: serde_json::Value = client
+        .get(MATCHSTICK_GITHUB_RELEASES)
+        .send()
+        .await
+        .context("Failed to reach GitHub API")?
+        .error_for_status()
+        .context("GitHub API returned an error")?
+        .json()
+        .await
+        .context("Failed to parse GitHub API response")?;
+
+    resp["tag_name"]
+        .as_str()
+        .map(|s| s.to_string())
+        .ok_or_else(|| anyhow!("GitHub API response missing tag_name"))
+}
+
+fn read_version_cache(path: &Path) -> Option<String> {
+    let data = std::fs::read_to_string(path).ok()?;
+    let cache: VersionCache = serde_json::from_str(&data).ok()?;
+    let now = SystemTime::now().duration_since(UNIX_EPOCH).ok()?.as_secs();
+
+    if now.saturating_sub(cache.timestamp) < VERSION_CACHE_TTL_SECS {
+        Some(cache.version)
+    } else {
+        None
+    }
+}
+
+fn write_version_cache(path: &Path, version: &str) -> Result<()> {
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .context("System clock before UNIX epoch")?
+        .as_secs();
+
+    let cache = VersionCache {
+        version: version.to_string(),
+        timestamp: now,
+    };
+
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    std::fs::write(path, serde_json::to_string_pretty(&cache)?)?;
+    Ok(())
+}
+
+/// Platform-specific binary name for a Matchstick version.
+/// Mirrors getPlatform from graph-tooling: versions > 0.5.4 use simplified names.
+fn get_platform(version: &str) -> Result<String> {
+    let ver = semver::Version::parse(version)?;
+    let cutoff = semver::Version::new(0, 5, 4);
+
+    let os = std::env::consts::OS;
+    let arch = std::env::consts::ARCH;
+
+    if arch != "x86_64" && !(os == "macos" && arch == "aarch64") {
+        return Err(anyhow!("Unsupported platform: {} {}", os, arch));
+    }
+
+    if ver > cutoff {
+        match os {
+            "macos" if arch == "aarch64" => Ok("binary-macos-12-m1".to_string()),
+            "macos" => Ok("binary-macos-12".to_string()),
+            "linux" => Ok("binary-linux-22".to_string()),
+            _ => Err(anyhow!("Unsupported OS: {}", os)),
+        }
+    } else {
+        // Legacy platform detection for versions <= 0.5.4
+        match os {
+            "macos" => {
+                let darwin_major = get_darwin_major_version();
+                if matches!(darwin_major, Some(18) | Some(19)) {
+                    Ok("binary-macos-10.15".to_string())
+                } else if arch == "aarch64" {
+                    Ok("binary-macos-11-m1".to_string())
+                } else {
+                    Ok("binary-macos-11".to_string())
+                }
+            }
+            "linux" => {
+                let linux_major = get_linux_major_version();
+                match linux_major {
+                    Some(18) => Ok("binary-linux-18".to_string()),
+                    Some(22) | Some(24) => Ok("binary-linux-22".to_string()),
+                    _ => Ok("binary-linux-20".to_string()),
+                }
+            }
+            _ => Err(anyhow!("Unsupported OS: {}", os)),
+        }
+    }
+}
+
+/// Darwin kernel major version from `uname -r`. Darwin 18/19 → macOS 10.14/10.15.
+fn get_darwin_major_version() -> Option<u32> {
+    let output = std::process::Command::new("uname")
+        .arg("-r")
+        .output()
+        .ok()?;
+    let release = String::from_utf8_lossy(&output.stdout);
+    release.trim().split('.').next()?.parse().ok()
+}
+
+fn get_linux_major_version() -> Option<u32> {
+    let content = std::fs::read_to_string("/etc/os-release").ok()?;
+    for line in content.lines() {
+        if let Some(val) = line.strip_prefix("VERSION_ID=") {
+            let val = val.trim_matches('"');
+            // Handle "22.04" → 22, or "22" → 22
+            return val.split('.').next()?.parse().ok();
+        }
+    }
+    None
+}
+
+/// Download the Matchstick binary to `node_modules/.bin/matchstick-{platform}`. Skips if already exists.
+async fn download_matchstick_binary(version: &str, platform: &str, force: bool) -> Result<PathBuf> {
+    let bin_dir = PathBuf::from("node_modules/.bin");
+    let bin_path = bin_dir.join(format!("matchstick-{platform}"));
+
+    if bin_path.exists() && !force {
+        step(
+            Step::Done,
+            &format!("Binary already exists: {}", bin_path.display()),
+        );
+        return Ok(bin_path);
+    }
+
+    std::fs::create_dir_all(&bin_dir)?;
+
+    let url = format!("{MATCHSTICK_DOWNLOAD_BASE}/{version}/{platform}");
+    step(Step::Load, &format!("Downloading Matchstick {version}"));
+
+    let client = reqwest::Client::builder().user_agent("gnd-cli").build()?;
+
+    let resp = client.get(&url).send().await?.error_for_status()?;
+
+    let bytes = resp
+        .bytes()
+        .await
+        .context("Failed to read download response")?;
+
+    std::fs::write(&bin_path, &bytes)?;
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        std::fs::set_permissions(&bin_path, std::fs::Permissions::from_mode(0o755))?;
+    }
+
+    step(Step::Done, &format!("Downloaded to {}", bin_path.display()));
+    Ok(bin_path)
+}
+
+async fn run_binary_tests(opt: &TestOpt) -> Result<()> {
+    step(Step::Generate, "Running Matchstick tests (legacy mode)");
+
+    let version = resolve_matchstick_version(
+        opt.matchstick_version.as_deref(),
+        Path::new(super::DEFAULT_TEST_DIR),
+    )
+    .await?;
+
+    let platform = get_platform(&version)?;
+    let bin_path = download_matchstick_binary(&version, &platform, opt.force).await?;
+
+    let workdir = opt
+        .manifest
+        .parent()
+        .filter(|p| !p.as_os_str().is_empty())
+        .unwrap_or(Path::new("."));
+    let mut cmd = std::process::Command::new(&bin_path);
+    cmd.current_dir(workdir);
+
+    if opt.coverage {
+        cmd.arg("-c");
+    }
+    if opt.recompile {
+        cmd.arg("-r");
+    }
+    if let Some(datasource) = &opt.datasource {
+        cmd.arg(datasource);
+    }
+
+    let status = cmd.status()?;
+
+    if status.success() {
+        step(Step::Done, "Matchstick tests passed");
+        Ok(())
+    } else {
+        Err(anyhow!("Matchstick tests failed"))
+    }
+}
+
+/// Run Matchstick tests in Docker (recommended on macOS where the native binary is bugged).
+async fn run_docker_tests(opt: &TestOpt) -> Result<()> {
+    step(Step::Generate, "Running Matchstick tests in Docker");
+
+    std::process::Command::new("docker")
+        .arg("--version")
+        .output()
+        .context("Docker not found. Please install Docker to use -d/--docker mode.")?;
+
+    let mut test_args = String::new();
+    if opt.coverage {
+        test_args.push_str(" -c");
+    }
+    if opt.recompile {
+        test_args.push_str(" -r");
+    }
+    if let Some(datasource) = &opt.datasource {
+        // Validate datasource name to prevent shell injection via Docker's
+        // `sh -c "matchstick $ARGS"` expansion.
+        if !datasource
+            .chars()
+            .all(|c| c.is_alphanumeric() || c == '_' || c == '-')
+        {
+            anyhow::bail!(
+                "Invalid datasource name '{}': must contain only alphanumeric characters, hyphens, or underscores",
+                datasource
+            );
+        }
+        test_args.push_str(&format!(" {}", datasource));
+    }
+
+    let cwd = std::env::current_dir().context("Failed to get current directory")?;
+
+    let mut cmd = std::process::Command::new("docker");
+    cmd.args([
+        "run",
+        "-it",
+        "--rm",
+        "--mount",
+        &format!("type=bind,source={},target=/matchstick", cwd.display()),
+    ]);
+    if !test_args.is_empty() {
+        cmd.args(["-e", &format!("ARGS={}", test_args.trim())]);
+    }
+    cmd.arg("matchstick");
+
+    // Check if the Docker image already exists.
+    let image_check = std::process::Command::new("docker")
+        .args(["images", "-q", "matchstick"])
+        .output()
+        .context("Failed to check for Docker image")?;
+    let image_exists = !image_check.stdout.is_empty();
+
+    if !image_exists || opt.force {
+        let version = resolve_matchstick_version(
+            opt.matchstick_version.as_deref(),
+            Path::new(super::DEFAULT_TEST_DIR),
+        )
+        .await?;
+
+        step(Step::Generate, "Building Matchstick Docker image");
+        let dockerfile_path = PathBuf::from("tests/.docker/Dockerfile");
+        if !dockerfile_path.exists() || opt.force {
+            create_dockerfile(&dockerfile_path, &version)?;
+        }
+        let build_status = std::process::Command::new("docker")
+            .args([
+                "build",
+                "-f",
+                &dockerfile_path.to_string_lossy(),
+                "-t",
+                "matchstick",
+                ".",
+            ])
+            .status()
+            .context("Failed to build Docker image")?;
+        if !build_status.success() {
+            return Err(anyhow!("Failed to build Matchstick Docker image"));
+        }
+    }
+
+    let status = cmd.status().context("Failed to run Docker container")?;
+    if status.success() {
+        step(Step::Done, "Tests passed");
+        Ok(())
+    } else {
+        Err(anyhow!("Tests failed"))
+    }
+}
+
+/// Generate a Dockerfile that downloads the Matchstick runner binary (not from npm).
+fn create_dockerfile(path: &PathBuf, version: &str) -> Result<()> {
+    use std::fs;
+
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    let dockerfile_content = format!(
+        r#"FROM --platform=linux/x86_64 ubuntu:22.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+ENV ARGS=""
+
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends \
+     curl ca-certificates postgresql postgresql-contrib \
+  && rm -rf /var/lib/apt/lists/*
+
+RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash - \
+  && apt-get install -y --no-install-recommends nodejs \
+  && rm -rf /var/lib/apt/lists/*
+
+RUN curl -fsSL -o /usr/local/bin/matchstick \
+     https://github.com/LimeChain/matchstick/releases/download/{version}/binary-linux-22 \
+  && chmod +x /usr/local/bin/matchstick
+
+RUN mkdir /matchstick
+WORKDIR /matchstick
+
+CMD ["sh", "-c", "matchstick $ARGS"]
+"#,
+        version = version
+    );
+
+    fs::write(path, dockerfile_content)?;
+    step(Step::Write, &format!("Created {}", path.display()));
+    Ok(())
+}
diff --git a/gnd/src/commands/test/mock_arweave.rs b/gnd/src/commands/test/mock_arweave.rs
new file mode 100644
index 00000000000..7b04cb60e4a
--- /dev/null
+++ b/gnd/src/commands/test/mock_arweave.rs
@@ -0,0 +1,45 @@
+//! Mock Arweave resolver for `gnd test`.
+//!
+//! Replaces the real `ArweaveClient` with a map of pre-loaded txId → bytes.
+//! Any txId not found in the map is sent to the `unresolved_tx` channel and
+//! `ServerUnavailable` is returned, which causes the `PollingMonitor` to retry
+//! with backoff. After sync, the runner drains the channel and reports missing
+//! tx IDs as a clear test failure.
+
+use std::collections::HashMap;
+
+use async_trait::async_trait;
+use graph::bytes::Bytes;
+use graph::components::link_resolver::{ArweaveClientError, ArweaveResolver, FileSizeLimit};
+use graph::data_source::offchain::Base64;
+use tokio::sync::mpsc::UnboundedSender;
+
+#[derive(Debug)]
+pub struct MockArweaveResolver {
+    pub files: HashMap<String, Bytes>,
+    pub unresolved_tx: UnboundedSender<String>,
+}
+
+#[async_trait]
+impl ArweaveResolver for MockArweaveResolver {
+    async fn get(&self, file: &Base64) -> Result<Vec<u8>, ArweaveClientError> {
+        self.get_with_limit(file, &FileSizeLimit::Unlimited).await
+    }
+
+    async fn get_with_limit(
+        &self,
+        file: &Base64,
+        _limit: &FileSizeLimit,
+    ) -> Result<Vec<u8>, ArweaveClientError> {
+        match self.files.get(file.as_str()) {
+            Some(bytes) => Ok(bytes.to_vec()),
+            None => {
+                let _ = self.unresolved_tx.send(file.as_str().to_owned());
+                Err(ArweaveClientError::ServerUnavailable(format!(
+                    "txId '{}' not found in mock 'arweaveFiles'",
+                    file.as_str()
+                )))
+            }
+        }
+    }
+}
diff --git a/gnd/src/commands/test/mock_chain.rs b/gnd/src/commands/test/mock_chain.rs
new file mode 100644
index 00000000000..c3a1a69f01f
--- /dev/null
+++ b/gnd/src/commands/test/mock_chain.rs
@@ -0,0 +1,19 @@
+//! Block pointer utilities for mock chains.
+
+use graph::blockchain::block_stream::BlockWithTriggers;
+use graph::prelude::BlockPtr;
+use graph::prelude::alloy::primitives::B256;
+use graph_chain_ethereum::Chain;
+
+/// Last block pointer — used as the indexer's stop target.
+pub fn final_block_ptr(blocks: &[BlockWithTriggers<Chain>]) -> Option<BlockPtr> {
+    blocks.last().map(|b| b.ptr())
+}
+
+/// Genesis block (block 0, zero hash) — used as stop target when there are no blocks.
+pub fn genesis_ptr() -> BlockPtr {
+    BlockPtr {
+        hash: B256::ZERO.into(),
+        number: 0,
+    }
+}
diff --git a/gnd/src/commands/test/mock_ipfs.rs b/gnd/src/commands/test/mock_ipfs.rs
new file mode 100644
index 00000000000..4c31f958682
--- /dev/null
+++ b/gnd/src/commands/test/mock_ipfs.rs
@@ -0,0 +1,46 @@
+//! Mock IPFS client for `gnd test`.
+//!
+//! Replaces the real `IpfsRpcClient` with a map of pre-loaded CID → bytes.
+//! Any CID not found in the map is sent to the `unresolved_tx` channel and
+//! an error is returned so the `OffchainMonitor` retries with backoff.
+//! After sync, the runner drains the channel and reports missing CIDs.
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use graph::bytes::Bytes;
+use graph::ipfs::{
+    ContentPath, IpfsClient, IpfsError, IpfsMetrics, IpfsRequest, IpfsResponse, IpfsResult,
+};
+use tokio::sync::mpsc::UnboundedSender;
+
+pub struct MockIpfsClient {
+    pub files: HashMap<ContentPath, Bytes>,
+    pub metrics: IpfsMetrics,
+    pub unresolved_tx: UnboundedSender<ContentPath>,
+}
+
+#[async_trait]
+impl IpfsClient for MockIpfsClient {
+    fn metrics(&self) -> &IpfsMetrics {
+        &self.metrics
+    }
+
+    async fn call(self: Arc<Self>, req: IpfsRequest) -> IpfsResult<IpfsResponse> {
+        let path = match req {
+            IpfsRequest::Cat(p) | IpfsRequest::GetBlock(p) => p,
+        };
+
+        match self.files.get(&path) {
+            Some(bytes) => Ok(IpfsResponse::for_test(path, bytes.clone())),
+            None => {
+                let _ = self.unresolved_tx.send(path.clone());
+                Err(IpfsError::ContentNotAvailable {
+                    path,
+                    reason: anyhow::anyhow!("CID not found in mock 'files'"),
+                })
+            }
+        }
+    }
+}
diff --git a/gnd/src/commands/test/mock_runtime.rs b/gnd/src/commands/test/mock_runtime.rs
new file mode 100644
index 00000000000..d18e93fd3c0
--- /dev/null
+++ b/gnd/src/commands/test/mock_runtime.rs
@@ -0,0 +1,77 @@
+//! Wraps Ethereum host functions to convert `PossibleReorg` errors into
+//! `Deterministic` ones so they surface immediately instead of causing
+//! infinite restart loops.
+
+use anyhow::anyhow;
+use graph::blockchain::{self, ChainIdentifier, HostFn, HostFnCtx};
+use graph::data_source;
+use graph::futures03::FutureExt;
+use graph::prelude::EthereumCallCache;
+use graph::runtime::HostExportError;
+use graph_chain_ethereum::Chain;
+use graph_chain_ethereum::chain::{EthereumRuntimeAdapterBuilder, RuntimeAdapterBuilder};
+use graph_chain_ethereum::network::EthereumNetworkAdapters;
+use std::sync::Arc;
+
+const WRAPPED_HOST_FNS: &[&str] = &["ethereum.call", "ethereum.getBalance", "ethereum.hasCode"];
+
+pub struct TestRuntimeAdapterBuilder;
+
+impl RuntimeAdapterBuilder for TestRuntimeAdapterBuilder {
+    fn build(
+        &self,
+        eth_adapters: Arc<EthereumNetworkAdapters>,
+        call_cache: Arc<dyn EthereumCallCache>,
+        chain_identifier: Arc<ChainIdentifier>,
+    ) -> Arc<dyn blockchain::RuntimeAdapter<Chain>> {
+        let real_adapter =
+            EthereumRuntimeAdapterBuilder {}.build(eth_adapters, call_cache, chain_identifier);
+        Arc::new(TestRuntimeAdapter { real_adapter })
+    }
+}
+
+struct TestRuntimeAdapter {
+    real_adapter: Arc<dyn blockchain::RuntimeAdapter<Chain>>,
+}
+
+impl TestRuntimeAdapter {
+    /// Convert `PossibleReorg` → `Deterministic` for a single host function.
+    fn wrap_possible_reorg(real: HostFn) -> HostFn {
+        let real_func = real.func.clone();
+        let name = real.name;
+        HostFn {
+            name,
+            func: Arc::new(move |ctx: HostFnCtx<'_>, wasm_ptr: u32| {
+                let real_func = real_func.clone();
+                async move {
+                    match real_func(ctx, wasm_ptr).await {
+                        Ok(result) => Ok(result),
+                        Err(HostExportError::PossibleReorg(e)) => {
+                            Err(HostExportError::Deterministic(anyhow!(
+                                "{}. Add mock data to your test JSON.",
+                                e
+                            )))
+                        }
+                        Err(other) => Err(other),
+                    }
+                }
+                .boxed()
+            }),
+        }
+    }
+}
+
+impl blockchain::RuntimeAdapter<Chain> for TestRuntimeAdapter {
+    fn host_fns(&self, ds: &data_source::DataSource<Chain>) -> Result<Vec<HostFn>, anyhow::Error> {
+        let mut fns = self.real_adapter.host_fns(ds)?;
+
+        // PossibleReorg → Deterministic for mock-backed host functions.
+        for hf in &mut fns {
+            if WRAPPED_HOST_FNS.contains(&hf.name) {
+                *hf = Self::wrap_possible_reorg(hf.clone());
+            }
+        }
+
+        Ok(fns)
+    }
+}
diff --git a/gnd/src/commands/test/mock_transport.rs b/gnd/src/commands/test/mock_transport.rs
new file mode 100644
index 00000000000..4db45addeb9
--- /dev/null
+++ b/gnd/src/commands/test/mock_transport.rs
@@ -0,0 +1,285 @@
+//! Mock Alloy transport that serves `eth_getBalance`, `eth_getCode`, and
+//! `eth_call` from test JSON mock data. Unmocked RPC calls fail immediately.
+
+use super::eth_calls::{encode_function_call, encode_return_value};
+use super::schema::TestFile;
+use anyhow::{Context, Result};
+use graph::blockchain::block_stream::BlockWithTriggers;
+use graph::prelude::alloy::primitives::{Address, B256, U256};
+use graph::prelude::alloy::rpc::json_rpc::{RequestPacket, ResponsePacket};
+use graph::prelude::alloy::transports::{TransportError, TransportErrorKind, TransportFut};
+use graph_chain_ethereum::Chain;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::task::{Context as TaskContext, Poll};
+use tower::Service;
+
+#[derive(Debug)]
+enum EthCallResult {
+    Success(Vec<u8>),
+    Revert,
+}
+
+#[derive(Debug)]
+struct Inner {
+    get_balance: HashMap<(Address, B256), U256>,
+    get_code: HashMap<(Address, B256), bool>,
+    eth_calls: HashMap<(Address, Vec<u8>, B256), EthCallResult>,
+}
+
+/// Mock RPC transport backed by test JSON data. Cheap to clone (`Arc` inner).
+#[derive(Clone)]
+pub struct MockTransport {
+    inner: Arc<Inner>,
+}
+
+impl MockTransport {
+    /// Build from test file mock data, keyed by built block hashes.
+    pub fn new(test_file: &TestFile, blocks: &[BlockWithTriggers<Chain>]) -> Result<Self> {
+        let mut get_balance = HashMap::new();
+        let mut get_code = HashMap::new();
+        let mut eth_calls = HashMap::new();
+
+        for (test_block, built_block) in test_file.blocks.iter().zip(blocks.iter()) {
+            let block_hash = built_block.ptr().hash.as_b256();
+
+            for mock_balance in &test_block.get_balance_calls {
+                let address: Address = mock_balance
+                    .address
+                    .parse()
+                    .context("Invalid address in getBalanceCalls mock")?;
+                let value: U256 = mock_balance.value.parse().context(
+                    "Invalid value in getBalanceCalls mock — expected decimal Wei string",
+                )?;
+                get_balance.insert((address, block_hash), value);
+            }
+
+            for mock_code in &test_block.has_code_calls {
+                let address: Address = mock_code
+                    .address
+                    .parse()
+                    .context("Invalid address in hasCodeCalls mock")?;
+                get_code.insert((address, block_hash), mock_code.has_code);
+            }
+
+            for eth_call in &test_block.eth_calls {
+                let address: Address = eth_call
+                    .address
+                    .parse()
+                    .context("Invalid address in ethCalls mock")?;
+                let calldata = encode_function_call(&eth_call.function, &eth_call.params)?;
+                let result = if eth_call.reverts {
+                    EthCallResult::Revert
+                } else {
+                    let return_data = encode_return_value(&eth_call.function, &eth_call.returns)?;
+                    EthCallResult::Success(return_data)
+                };
+                eth_calls.insert((address, calldata, block_hash), result);
+            }
+        }
+
+        Ok(Self {
+            inner: Arc::new(Inner {
+                get_balance,
+                get_code,
+                eth_calls,
+            }),
+        })
+    }
+
+    /// Successful JSON-RPC response.
+    fn success_response(
+        id: &serde_json::Value,
+        result: serde_json::Value,
+    ) -> Result<ResponsePacket, TransportError> {
+        let response = serde_json::json!({
+            "jsonrpc": "2.0",
+            "id": id,
+            "result": result,
+        });
+        serde_json::from_value(response).map_err(|e| {
+            TransportErrorKind::custom_str(&format!("Failed to build mock response: {}", e))
+        })
+    }
+
+    /// JSON-RPC error response (for reverts).
+    fn error_response(
+        id: &serde_json::Value,
+        code: i64,
+        message: &str,
+    ) -> Result<ResponsePacket, TransportError> {
+        let response = serde_json::json!({
+            "jsonrpc": "2.0",
+            "id": id,
+            "error": {
+                "code": code,
+                "message": message,
+            },
+        });
+        serde_json::from_value(response).map_err(|e| {
+            TransportErrorKind::custom_str(&format!("Failed to build mock error response: {}", e))
+        })
+    }
+
+    /// Extract `(address, block_hash)` from `[address, {"blockHash": hash}]` params.
+    fn parse_address_and_block_hash(params: &serde_json::Value) -> Result<(Address, B256), String> {
+        let arr = params.as_array().ok_or("Expected array params")?;
+
+        let address_str = arr
+            .first()
+            .and_then(|v| v.as_str())
+            .ok_or("Missing address param")?;
+        let address: Address = address_str
+            .parse()
+            .map_err(|e| format!("Invalid address '{}': {}", address_str, e))?;
+
+        let block_hash_str = arr
+            .get(1)
+            .and_then(|v| v.get("blockHash"))
+            .and_then(|v| v.as_str())
+            .ok_or("Missing blockHash in params")?;
+        let block_hash: B256 = block_hash_str
+            .parse()
+            .map_err(|e| format!("Invalid blockHash '{}': {}", block_hash_str, e))?;
+
+        Ok((address, block_hash))
+    }
+
+    fn handle_get_balance(
+        &self,
+        params: &serde_json::Value,
+        id: &serde_json::Value,
+    ) -> Result<ResponsePacket, TransportError> {
+        let (address, block_hash) = Self::parse_address_and_block_hash(params)
+            .map_err(|e| TransportErrorKind::custom_str(&format!("eth_getBalance: {}", e)))?;
+
+        match self.inner.get_balance.get(&(address, block_hash)) {
+            Some(value) => Self::success_response(id, serde_json::json!(format!("0x{:x}", value))),
+            None => Err(TransportErrorKind::custom_str(&format!(
+                "gnd test: no mock getBalance entry for address {} at block hash {}. \
+                 Add a 'getBalanceCalls' entry to this block in your test JSON.",
+                address, block_hash
+            ))),
+        }
+    }
+
+    fn handle_get_code(
+        &self,
+        params: &serde_json::Value,
+        id: &serde_json::Value,
+    ) -> Result<ResponsePacket, TransportError> {
+        let (address, block_hash) = Self::parse_address_and_block_hash(params)
+            .map_err(|e| TransportErrorKind::custom_str(&format!("eth_getCode: {}", e)))?;
+
+        match self.inner.get_code.get(&(address, block_hash)) {
+            // graph-node checks `code.len() > 2`; "0xff" is the minimal truthy value.
+            Some(true) => Self::success_response(id, serde_json::json!("0xff")),
+            Some(false) => Self::success_response(id, serde_json::json!("0x")),
+            None => Err(TransportErrorKind::custom_str(&format!(
+                "gnd test: no mock hasCode entry for address {} at block hash {}. \
+                 Add a 'hasCodeCalls' entry to this block in your test JSON.",
+                address, block_hash
+            ))),
+        }
+    }
+
+    fn handle_eth_call(
+        &self,
+        params: &serde_json::Value,
+        id: &serde_json::Value,
+    ) -> Result<ResponsePacket, TransportError> {
+        let arr = params
+            .as_array()
+            .ok_or_else(|| TransportErrorKind::custom_str("eth_call: expected array params"))?;
+
+        let tx = arr.first().ok_or_else(|| {
+            TransportErrorKind::custom_str("eth_call: missing transaction object")
+        })?;
+
+        let to_str = tx
+            .get("to")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| TransportErrorKind::custom_str("eth_call: missing 'to' field"))?;
+        let address: Address = to_str.parse().map_err(|e| {
+            TransportErrorKind::custom_str(&format!("eth_call: invalid 'to' address: {}", e))
+        })?;
+
+        let input_str = tx
+            .get("input")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| TransportErrorKind::custom_str("eth_call: missing 'input' field"))?;
+        let input =
+            hex::decode(input_str.strip_prefix("0x").unwrap_or(input_str)).map_err(|e| {
+                TransportErrorKind::custom_str(&format!("eth_call: invalid 'input' hex: {}", e))
+            })?;
+
+        let block_hash_str = arr
+            .get(1)
+            .and_then(|v| v.get("blockHash"))
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| TransportErrorKind::custom_str("eth_call: missing blockHash"))?;
+        let block_hash: B256 = block_hash_str.parse().map_err(|e| {
+            TransportErrorKind::custom_str(&format!("eth_call: invalid blockHash: {}", e))
+        })?;
+
+        match self.inner.eth_calls.get(&(address, input, block_hash)) {
+            Some(EthCallResult::Success(data)) => {
+                Self::success_response(id, serde_json::json!(format!("0x{}", hex::encode(data))))
+            }
+            Some(EthCallResult::Revert) => Self::error_response(id, 3, "execution reverted"),
+            None => Err(TransportErrorKind::custom_str(&format!(
+                "gnd test: unmocked eth_call to {} at block hash {}. \
+                 Add a matching 'ethCalls' entry to this block in your test JSON.",
+                address, block_hash
+            ))),
+        }
+    }
+}
+
+impl Service<RequestPacket> for MockTransport {
+    type Response = ResponsePacket;
+    type Error = TransportError;
+    type Future = TransportFut<'static>;
+
+    fn poll_ready(&mut self, _cx: &mut TaskContext<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, request: RequestPacket) -> Self::Future {
+        let transport = self.clone();
+        Box::pin(async move {
+            let req = match &request {
+                RequestPacket::Single(req) => req,
+                RequestPacket::Batch(_) => {
+                    return Err(TransportErrorKind::custom_str(
+                        "gnd test: batch RPC requests are not supported by MockTransport",
+                    ));
+                }
+            };
+
+            let method = req.method();
+            let params: serde_json::Value = req
+                .params()
+                .map(|p| serde_json::from_str(p.get()))
+                .transpose()
+                .map_err(|e| {
+                    TransportErrorKind::custom_str(&format!("Failed to parse params: {}", e))
+                })?
+                .unwrap_or(serde_json::Value::Null);
+
+            let id = serde_json::to_value(req.id()).map_err(|e| {
+                TransportErrorKind::custom_str(&format!("Failed to serialize request id: {}", e))
+            })?;
+
+            match method {
+                "eth_getBalance" => transport.handle_get_balance(&params, &id),
+                "eth_getCode" => transport.handle_get_code(&params, &id),
+                "eth_call" => transport.handle_eth_call(&params, &id),
+                _ => Err(TransportErrorKind::custom_str(&format!(
+                    "gnd test: unmocked RPC method '{}'. Add mock data to your test JSON file.",
+                    method
+                ))),
+            }
+        })
+    }
+}
diff --git a/gnd/src/commands/test/mod.rs b/gnd/src/commands/test/mod.rs
new file mode 100644
index 00000000000..7352ae73e48
--- /dev/null
+++ b/gnd/src/commands/test/mod.rs
@@ -0,0 +1,218 @@
+//! Mock-based subgraph test runner for `gnd test`.
+//!
+//! This module replaces the old Matchstick-only test command with a mock-based
+//! integration testing solution. Tests are defined as JSON files containing mock
+//! blockchain data (blocks, log events, block triggers) and GraphQL assertions
+//! that validate the resulting entity state.
+//!
+//! ## How it works
+//!
+//! 1. Build the subgraph (unless `--skip-build`)
+//! 2. Discover `*.json` / `*.test.json` files in the test directory
+//! 3. For each test file:
+//!    a. Parse JSON into mock blocks with triggers
+//!    b. Spin up a temporary PostgreSQL database (pgtemp on Unix)
+//!    c. Initialize graph-node stores and deploy the subgraph
+//!    d. Feed mock blocks through a static block stream (no real RPC)
+//!    e. Wait for the indexer to process all blocks
+//!    f. Run GraphQL assertions against the indexed data
+//! 4. Report pass/fail results
+//!
+//! The key insight is that we reuse real graph-node infrastructure (stores,
+//! subgraph deployment, WASM runtime) and only mock the blockchain layer.
+//! This means tests exercise the same code paths as production indexing.
+//!
+//! ## Legacy mode
+//!
+//! The `--matchstick` flag falls back to the external Matchstick test runner
+//! for backward compatibility with existing test suites.
+
+mod assertion;
+mod block_stream;
+mod eth_calls;
+mod matchstick;
+mod mock_arweave;
+mod mock_chain;
+mod mock_ipfs;
+mod mock_runtime;
+mod mock_transport;
+mod noop;
+mod output;
+mod runner;
+mod schema;
+mod trigger;
+
+use anyhow::{Result, anyhow};
+use clap::Parser;
+use console::style;
+use std::path::PathBuf;
+
+use crate::output::{Step, step};
+
+const DEFAULT_TEST_DIR: &str = "tests";
+
+#[derive(Clone, Debug, Parser)]
+#[clap(about = "Run subgraph tests")]
+pub struct TestOpt {
+    /// Test files or directories to run. Directories are scanned for *.json / *.test.json.
+    /// Defaults to the "tests/" directory when nothing is specified.
+    pub tests: Vec<PathBuf>,
+
+    /// Path to subgraph manifest
+    #[clap(short = 'm', long, default_value = "subgraph.yaml")]
+    pub manifest: PathBuf,
+
+    /// Skip building the subgraph before testing
+    #[clap(short = 's', long)]
+    pub skip_build: bool,
+
+    /// PostgreSQL connection URL. If not provided, a temporary database will be created (Unix only).
+    #[clap(long, env = "POSTGRES_URL")]
+    pub postgres_url: Option<String>,
+
+    /// Use Matchstick runner instead (deprecated legacy mode — migrate to JSON-based tests)
+    #[clap(long)]
+    pub matchstick: bool,
+
+    /// Run Matchstick tests in Docker (recommended on macOS where the native binary is bugged)
+    #[clap(short = 'd', long, requires = "matchstick")]
+    pub docker: bool,
+
+    /// Run tests with coverage reporting (Matchstick only)
+    #[clap(short = 'c', long, requires = "matchstick")]
+    pub coverage: bool,
+
+    /// Force recompilation of tests (Matchstick only)
+    #[clap(short = 'r', long, requires = "matchstick")]
+    pub recompile: bool,
+
+    /// Force redownload of Matchstick binary / rebuild Docker image
+    #[clap(short = 'f', long, requires = "matchstick")]
+    pub force: bool,
+
+    /// Matchstick version to use (default: latest from GitHub)
+    #[clap(long, requires = "matchstick")]
+    pub matchstick_version: Option<String>,
+
+    /// Specific data source to test (Matchstick only)
+    #[clap(long, requires = "matchstick")]
+    pub datasource: Option<String>,
+
+    /// Increase graph-node log verbosity (-v info, -vv debug, -vvv trace).
+    /// Overridden by GRAPH_LOG env var when set.
+    #[clap(short = 'v', long, action = clap::ArgAction::Count)]
+    pub verbose: u8,
+}
+
+pub async fn run_test(opt: TestOpt) -> Result<()> {
+    if opt.matchstick {
+        step(
+            Step::Warn,
+            "Matchstick is deprecated and will be removed in a future release. \
+            Migrate to the JSON-based test format (see: gnd/docs/gnd-test.md).",
+        );
+        return matchstick::run(&opt).await;
+    }
+
+    // Build the subgraph first (WASM and schema must be available in build/).
+    if !opt.skip_build {
+        step(Step::Generate, "Building subgraph");
+        let build_opt = crate::commands::BuildOpt {
+            manifest: opt.manifest.clone(),
+            output_dir: std::path::PathBuf::from("build"),
+            output_format: "wasm".to_string(),
+            skip_migrations: false,
+            watch: false,
+            ipfs: None,
+            network: None,
+            network_file: std::path::PathBuf::from("networks.json"),
+            skip_asc_version_check: false,
+        };
+        crate::commands::run_build(build_opt).await?;
+        step(Step::Done, "Build complete");
+    }
+
+    // Resolve test files from positional args. Default to "tests/" when none given.
+    let tests = if opt.tests.is_empty() {
+        vec![PathBuf::from(DEFAULT_TEST_DIR)]
+    } else {
+        opt.tests.clone()
+    };
+
+    step(Step::Load, "Loading manifest");
+    let manifest_info = runner::load_manifest_info(&opt)?;
+
+    step(Step::Load, "Discovering test files");
+    let test_files = resolve_test_paths(&tests)?;
+
+    if test_files.is_empty() {
+        step(Step::Warn, "No test files found");
+        for test in &tests {
+            println!(
+                "  Looking in: {}",
+                test.canonicalize().unwrap_or(test.clone()).display()
+            );
+        }
+        println!("  Expected: *.test.json or *.json files");
+        return Ok(());
+    }
+
+    let mut passed = 0;
+    let mut failed = 0;
+    let mut all_failures = Vec::new();
+
+    for path in test_files {
+        output::print_test_start(&path);
+
+        let test_file = match schema::parse_test_file(&path) {
+            Ok(tf) => tf,
+            Err(e) => {
+                println!("  {} Failed to parse: {}", style("✘").red(), e);
+                failed += 1;
+                continue;
+            }
+        };
+
+        match runner::run_single_test(&opt, &manifest_info, &test_file, &path).await {
+            Ok(result) => {
+                output::print_test_result(&test_file.name, &result);
+                if result.is_passed() {
+                    passed += 1;
+                } else {
+                    all_failures.extend(output::collect_failures(&test_file.name, &result));
+                    failed += 1;
+                }
+            }
+            Err(e) => {
+                println!("  {} {} - Error: {}", style("✘").red(), test_file.name, e);
+                failed += 1;
+            }
+        }
+    }
+
+    output::print_failure_details(&all_failures);
+    output::print_summary(passed, failed);
+
+    if failed > 0 {
+        Err(anyhow!("{} test(s) failed", failed))
+    } else {
+        Ok(())
+    }
+}
+
+fn resolve_test_paths(paths: &[PathBuf]) -> Result<Vec<PathBuf>> {
+    let mut files = Vec::new();
+
+    for path in paths {
+        if path.is_dir() {
+            files.extend(schema::discover_test_files(path)?);
+        } else if path.exists() {
+            files.push(path.clone());
+        } else {
+            anyhow::bail!("Test file not found: {}", path.display());
+        }
+    }
+
+    files.sort();
+    Ok(files)
+}
diff --git a/gnd/src/commands/test/noop.rs b/gnd/src/commands/test/noop.rs
new file mode 100644
index 00000000000..069ab45bcbd
--- /dev/null
+++ b/gnd/src/commands/test/noop.rs
@@ -0,0 +1,119 @@
+//! Noop trait implementations for the mock `Chain`.
+//!
+//! Satisfy `Chain` constructor bounds but are never called:
+//! - Triggers come from `StaticStreamBuilder` (no scanning)
+//! - Host functions use `EthereumRuntimeAdapterBuilder` with the eth_call cache
+
+use async_trait::async_trait;
+use graph::blockchain::block_stream::{BlockRefetcher, BlockWithTriggers, FirehoseCursor};
+use graph::blockchain::{BlockPtr, Blockchain, TriggersAdapter, TriggersAdapterSelector};
+use graph::components::store::DeploymentLocator;
+use graph::prelude::{BlockHash, BlockNumber, Error};
+use graph::slog::{Discard, Logger};
+use std::collections::BTreeSet;
+use std::marker::PhantomData;
+use std::sync::Arc;
+
+use graph::slog::o;
+
+/// No-op block refetcher. Tests have no reorgs, so refetching is never needed.
+pub(super) struct StaticBlockRefetcher<C: Blockchain> {
+    pub _phantom: PhantomData<C>,
+}
+
+#[async_trait]
+impl<C: Blockchain> BlockRefetcher<C> for StaticBlockRefetcher<C> {
+    fn required(&self, _chain: &C) -> bool {
+        false
+    }
+
+    async fn get_block(
+        &self,
+        _chain: &C,
+        _logger: &Logger,
+        _cursor: FirehoseCursor,
+    ) -> Result<C::Block, Error> {
+        Err(anyhow::anyhow!(
+            "StaticBlockRefetcher::get_block should never be called — block refetching is disabled in test mode"
+        ))
+    }
+}
+
+pub(super) struct NoopAdapterSelector<C> {
+    pub _phantom: PhantomData<C>,
+}
+
+impl<C: Blockchain> TriggersAdapterSelector<C> for NoopAdapterSelector<C> {
+    fn triggers_adapter(
+        &self,
+        _loc: &DeploymentLocator,
+        _capabilities: &<C as Blockchain>::NodeCapabilities,
+        _unified_api_version: graph::data::subgraph::UnifiedMappingApiVersion,
+    ) -> Result<Arc<dyn TriggersAdapter<C>>, Error> {
+        Ok(Arc::new(NoopTriggersAdapter {
+            _phantom: PhantomData,
+        }))
+    }
+}
+
+/// Returns empty/default results. Never called since triggers come from `StaticStreamBuilder`.
+struct NoopTriggersAdapter<C: Blockchain> {
+    _phantom: PhantomData<C>,
+}
+
+#[async_trait]
+impl<C: Blockchain> TriggersAdapter<C> for NoopTriggersAdapter<C> {
+    async fn ancestor_block(
+        &self,
+        _ptr: BlockPtr,
+        _offset: BlockNumber,
+        _root: Option<BlockHash>,
+    ) -> Result<Option<<C as Blockchain>::Block>, Error> {
+        Ok(None)
+    }
+
+    async fn load_block_ptrs_by_numbers(
+        &self,
+        _logger: Logger,
+        _block_numbers: BTreeSet<BlockNumber>,
+    ) -> Result<Vec<C::Block>, Error> {
+        Ok(vec![])
+    }
+
+    async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error> {
+        Ok(None)
+    }
+
+    async fn scan_triggers(
+        &self,
+        _from: BlockNumber,
+        _to: BlockNumber,
+        _filter: &C::TriggerFilter,
+    ) -> Result<(Vec<BlockWithTriggers<C>>, BlockNumber), Error> {
+        Ok((vec![], 0))
+    }
+
+    async fn triggers_in_block(
+        &self,
+        _logger: &Logger,
+        block: <C as Blockchain>::Block,
+        _filter: &<C as Blockchain>::TriggerFilter,
+    ) -> Result<BlockWithTriggers<C>, Error> {
+        let logger = Logger::root(Discard, o!());
+        Ok(BlockWithTriggers::new(block, Vec::new(), &logger))
+    }
+
+    async fn is_on_main_chain(&self, _ptr: BlockPtr) -> Result<bool, Error> {
+        Ok(true)
+    }
+
+    async fn parent_ptr(&self, block: &BlockPtr) -> Result<Option<BlockPtr>, Error> {
+        match block.number {
+            0 => Ok(None),
+            n => Ok(Some(BlockPtr {
+                hash: BlockHash::default(),
+                number: n - 1,
+            })),
+        }
+    }
+}
diff --git a/gnd/src/commands/test/output.rs b/gnd/src/commands/test/output.rs
new file mode 100644
index 00000000000..8746574b511
--- /dev/null
+++ b/gnd/src/commands/test/output.rs
@@ -0,0 +1,113 @@
+//! Console output formatting for test results.
+
+use console::style;
+use similar::{ChangeTag, TextDiff};
+
+use super::assertion::align_for_diff;
+use super::schema::{AssertionFailure, AssertionOutcome, TestResult};
+use crate::output::{Step, step};
+
+pub fn print_test_start(path: &std::path::Path) {
+    step(Step::Load, &format!("Running {}", path.display()));
+}
+
+/// Print pass/fail for a test case. Diffs are deferred to `print_failure_details`.
+pub fn print_test_result(name: &str, result: &TestResult) {
+    if result.is_passed() {
+        println!("  {} {}", style("✔").green(), name);
+    } else {
+        println!("  {} {}", style("✘").red(), name);
+    }
+
+    if let Some(err) = &result.handler_error {
+        println!("    {} {}", style("Handler error:").red(), err);
+    }
+
+    for outcome in &result.assertions {
+        match outcome {
+            AssertionOutcome::Passed { query } => {
+                println!("    {} {}", style("✔").green(), style(query).dim());
+            }
+            AssertionOutcome::Failed(failure) => {
+                println!("    {} {}", style("✘").red(), failure.query);
+            }
+        }
+    }
+}
+
+pub struct FailureDetail {
+    pub test_name: String,
+    pub failure: AssertionFailure,
+}
+
+pub fn collect_failures(test_name: &str, result: &TestResult) -> Vec<FailureDetail> {
+    result
+        .assertions
+        .iter()
+        .filter_map(|outcome| match outcome {
+            AssertionOutcome::Passed { .. } => None,
+            AssertionOutcome::Failed(failure) => Some(FailureDetail {
+                test_name: test_name.to_string(),
+                failure: AssertionFailure {
+                    query: failure.query.clone(),
+                    expected: failure.expected.clone(),
+                    actual: failure.actual.clone(),
+                },
+            }),
+        })
+        .collect()
+}
+
+pub fn print_failure_details(details: &[FailureDetail]) {
+    if details.is_empty() {
+        return;
+    }
+
+    println!("\n{}", style("Failures:").red().bold());
+
+    for detail in details {
+        println!(
+            "\n  {} {} {}",
+            style("●").red(),
+            style(&detail.test_name).bold(),
+            style("→").dim(),
+        );
+        println!("    {} {}", style("Query:").yellow(), detail.failure.query);
+
+        let expected = serde_json::to_string_pretty(&detail.failure.expected).unwrap_or_default();
+        let aligned_actual = align_for_diff(&detail.failure.expected, &detail.failure.actual);
+        let actual = serde_json::to_string_pretty(&aligned_actual).unwrap_or_default();
+
+        println!(
+            "    {} {} expected {} actual",
+            style("Diff:").yellow(),
+            style("(-)").red(),
+            style("(+)").green(),
+        );
+
+        let diff = TextDiff::from_lines(&expected, &actual);
+        for change in diff.iter_all_changes() {
+            let text = change.value().trim_end_matches('\n');
+            match change.tag() {
+                ChangeTag::Delete => println!("      {}", style(format!("- {text}")).red()),
+                ChangeTag::Insert => println!("      {}", style(format!("+ {text}")).green()),
+                ChangeTag::Equal => println!("        {text}"),
+            }
+        }
+    }
+}
+
+pub fn print_summary(passed: usize, failed: usize) {
+    println!();
+    if failed == 0 {
+        println!(
+            "{}",
+            style(format!("Tests: {} passed, {} failed", passed, failed)).green()
+        );
+    } else {
+        println!(
+            "{}",
+            style(format!("Tests: {} passed, {} failed", passed, failed)).red()
+        );
+    }
+}
diff --git a/gnd/src/commands/test/runner.rs b/gnd/src/commands/test/runner.rs
new file mode 100644
index 00000000000..19db7347deb
--- /dev/null
+++ b/gnd/src/commands/test/runner.rs
@@ -0,0 +1,912 @@
+//! Test runner: orchestrates subgraph indexing with mock blockchain data.
+//!
+//! This is the core of `gnd test`. For each test file, it:
+//!
+//! 1. Creates a test database (`TestDatabase::Temporary` via pgtemp, or
+//!    `TestDatabase::Persistent` via `--postgres-url`) for test isolation
+//! 2. Initializes graph-node stores (entity storage, block storage, chain store)
+//! 3. Constructs a mock Ethereum chain that feeds pre-defined blocks
+//! 4. Deploys the subgraph and starts the indexer
+//! 5. Waits for all blocks to be processed (or a fatal error)
+//! 6. Runs GraphQL assertions against the indexed entity state
+
+use super::TestOpt;
+use super::assertion::run_assertions;
+use super::block_stream::StaticStreamBuilder;
+use super::mock_arweave::MockArweaveResolver;
+use super::mock_chain;
+use super::mock_ipfs::MockIpfsClient;
+use super::mock_runtime::TestRuntimeAdapterBuilder;
+use super::mock_transport::MockTransport;
+use super::noop::{NoopAdapterSelector, StaticBlockRefetcher};
+use super::schema::{TestFile, TestResult};
+use super::trigger::build_blocks_with_triggers;
+use crate::manifest::{Manifest, load_manifest};
+use anyhow::{Context, Result, anyhow, ensure};
+use graph::amp::FlightClient;
+use graph::blockchain::block_stream::BlockWithTriggers;
+use graph::blockchain::{BlockPtr, BlockchainMap, ChainIdentifier};
+use graph::cheap_clone::CheapClone;
+use graph::components::link_resolver::FileLinkResolver;
+use graph::components::metrics::MetricsRegistry;
+use graph::components::network_provider::{
+    AmpChainNames, ChainName, ProviderCheckStrategy, ProviderManager,
+};
+use graph::components::store::DeploymentLocator;
+use graph::components::subgraph::{Settings, SubgraphInstanceManager as _};
+use graph::data::graphql::load_manager::LoadManager;
+use graph::data::subgraph::schema::SubgraphError;
+use graph::endpoint::EndpointMetrics;
+use graph::env::EnvVars;
+use graph::firehose::{FirehoseEndpoint, FirehoseEndpoints, SubgraphLimit};
+use graph::ipfs::{ContentPath, IpfsMetrics};
+use graph::prelude::{
+    DeploymentHash, LoggerFactory, NodeId, SubgraphCountMetric, SubgraphName, SubgraphRegistrar,
+    SubgraphStore as SubgraphStoreTrait, SubgraphVersionSwitchingMode,
+};
+use graph::slog::{Logger, info, o};
+use graph_chain_ethereum::network::{EthereumNetworkAdapter, EthereumNetworkAdapters};
+use graph_chain_ethereum::{
+    Chain, EthereumAdapter, NodeCapabilities, ProviderEthRpcMetrics, Transport,
+    chain::ChainSettings,
+};
+use graph_core::polling_monitor::{arweave_service, ipfs_service};
+use graph_graphql::prelude::GraphQlRunner;
+use graph_node::config::{Config, Opt};
+use graph_node::manager::PanicSubscriptionManager;
+use graph_node::store_builder::StoreBuilder;
+use graph_store_postgres::{ChainHeadUpdateListener, ChainStore, Store, SubgraphStore};
+use std::collections::HashMap;
+use std::marker::PhantomData;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+
+#[cfg(unix)]
+use pgtemp::PgTempDBBuilder;
+
+const NODE_ID: &str = "gnd-test";
+
+/// Build a logger from the `-v` flag. `GRAPH_LOG` env var always takes precedence.
+/// `verbose`: 0=off, 1=Info, 2=Debug, 3+=Trace.
+fn make_test_logger(verbose: u8) -> Logger {
+    if std::env::var("GRAPH_LOG").is_ok() {
+        return graph::log::logger(true);
+    }
+
+    match verbose {
+        0 => graph::log::discard(),
+        1 => graph::log::logger_with_levels(false, None),
+        2 => graph::log::logger_with_levels(true, None),
+        // "trace" sets GRAPH_LOG=trace globally via slog_envlogger.
+        _ => graph::log::logger_with_levels(true, Some("trace")),
+    }
+}
+
+/// Mock file data passed to `setup_context`.
+struct MockData {
+    ipfs_files: HashMap<ContentPath, graph::bytes::Bytes>,
+    ipfs_unresolved_tx: tokio::sync::mpsc::UnboundedSender<ContentPath>,
+    arweave_files: HashMap<String, graph::bytes::Bytes>,
+    arweave_unresolved_tx: tokio::sync::mpsc::UnboundedSender<String>,
+}
+
+struct TestStores {
+    network_name: ChainName,
+    /// Listens for chain head updates — needed by the Chain constructor.
+    chain_head_listener: Arc<ChainHeadUpdateListener>,
+    network_store: Arc<Store>,
+    chain_store: Arc<ChainStore>,
+}
+
+/// Components needed to run a test after infrastructure setup.
+pub(super) struct TestContext {
+    pub(super) provider: Arc<graph_core::subgraph_provider::SubgraphProvider>,
+    pub(super) store: Arc<SubgraphStore>,
+    pub(super) deployment: DeploymentLocator,
+    pub(super) graphql_runner: Arc<GraphQlRunner<Store>>,
+}
+
+/// Manifest data shared across all tests in a run.
+pub(super) struct ManifestInfo {
+    pub build_dir: PathBuf,
+    /// Built manifest path. Aliased to `hash` in `FileLinkResolver` so the Qm
+    /// hash resolves to a real filesystem path.
+    pub manifest_path: PathBuf,
+    pub network_name: ChainName,
+    pub min_start_block: u64,
+    /// Override for on-chain block validation when startBlock > 0.
+    pub start_block_override: Option<BlockPtr>,
+    pub hash: DeploymentHash,
+    pub subgraph_name: SubgraphName,
+    /// Event selectors (topic0) for handlers that declare `receipt: true`.
+    /// Only logs whose topic0 is in this set receive a non-null receipt.
+    pub receipt_required_selectors:
+        std::collections::HashSet<graph::prelude::alloy::primitives::B256>,
+}
+
+/// Compute `"Qm" + hex(sha1(path + '\0' + seed))`. Seed ensures per-run uniqueness.
+fn deployment_hash_from_path_and_seed(path: &Path, seed: u128) -> Result<DeploymentHash> {
+    use sha1::{Digest, Sha1};
+
+    let input = format!("{}\0{}", path.display(), seed);
+    let digest = Sha1::digest(input.as_bytes());
+    let qm = format!("Qm{}", hex::encode(digest));
+    DeploymentHash::new(qm).map_err(|e| anyhow!("Failed to create deployment hash: {}", e))
+}
+
+pub(super) fn load_manifest_info(opt: &TestOpt) -> Result<ManifestInfo> {
+    let manifest_dir = opt
+        .manifest
+        .parent()
+        .map(|p| p.to_path_buf())
+        .unwrap_or_else(|| PathBuf::from("."));
+
+    let build_dir = manifest_dir.join("build");
+
+    let manifest_filename = opt
+        .manifest
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("subgraph.yaml");
+    let built_manifest_path = build_dir.join(manifest_filename);
+    let built_manifest_path = built_manifest_path
+        .canonicalize()
+        .context("Failed to resolve built manifest path — did you run 'gnd build'?")?;
+
+    let manifest = load_manifest(&built_manifest_path)?;
+
+    let network_name: ChainName = extract_network_from_manifest(&manifest)?.into();
+    let min_start_block = extract_start_block_from_manifest(&manifest)?;
+
+    let start_block_override = if min_start_block > 0 {
+        use graph::prelude::alloy::primitives::keccak256;
+        let hash = keccak256((min_start_block - 1).to_be_bytes());
+        ensure!(
+            min_start_block - 1 <= i32::MAX as u64,
+            "block number {} exceeds i32::MAX",
+            min_start_block - 1
+        );
+        Some(BlockPtr::new(hash.into(), (min_start_block - 1) as i32))
+    } else {
+        None
+    };
+
+    // Per-run seed for unique deployment hash and subgraph name.
+    let seed = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis();
+
+    let hash = deployment_hash_from_path_and_seed(&built_manifest_path, seed)?;
+
+    // Derive subgraph name from the root dir, sanitized for SubgraphName compatibility.
+    let root_dir_name = manifest_dir
+        .canonicalize()
+        .unwrap_or(manifest_dir.clone())
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("gnd-test")
+        .chars()
+        .filter(|c| c.is_alphanumeric() || *c == '-' || *c == '_')
+        .collect::<String>();
+    let subgraph_name = SubgraphName::new(format!("test/{}-{}", root_dir_name, seed))
+        .map_err(|e| anyhow!("{}", e))?;
+
+    let receipt_required_selectors = extract_receipt_required_selectors(&manifest);
+
+    Ok(ManifestInfo {
+        build_dir,
+        manifest_path: built_manifest_path,
+        network_name,
+        min_start_block,
+        start_block_override,
+        hash,
+        subgraph_name,
+        receipt_required_selectors,
+    })
+}
+
+/// Collect topic0 selectors for handlers declaring `receipt: true`.
+///
+/// Covers data sources and templates. Mirrors `MappingEventHandler::topic0()`:
+/// strip `"indexed "` and spaces, then keccak256.
+fn extract_receipt_required_selectors(
+    manifest: &Manifest,
+) -> std::collections::HashSet<graph::prelude::alloy::primitives::B256> {
+    use graph::prelude::alloy::primitives::keccak256;
+
+    manifest
+        .data_sources
+        .iter()
+        .flat_map(|ds| &ds.event_handlers)
+        .chain(manifest.templates.iter().flat_map(|t| &t.event_handlers))
+        .filter(|h| h.receipt)
+        .map(|h| {
+            let normalized = h.event.replace("indexed ", "").replace(' ', "");
+            keccak256(normalized.as_bytes())
+        })
+        .collect()
+}
+
+fn extract_network_from_manifest(manifest: &Manifest) -> Result<String> {
+    let network = manifest
+        .data_sources
+        .first()
+        .and_then(|ds| ds.network.clone())
+        .unwrap_or_else(|| "mainnet".to_string());
+
+    Ok(network)
+}
+
+/// Extract the minimum `startBlock` across all data sources.
+fn extract_start_block_from_manifest(manifest: &Manifest) -> Result<u64> {
+    Ok(manifest
+        .data_sources
+        .iter()
+        .map(|ds| ds.start_block)
+        .min()
+        .unwrap_or(0))
+}
+
+pub async fn run_single_test(
+    opt: &TestOpt,
+    manifest_info: &ManifestInfo,
+    test_file: &TestFile,
+    test_file_path: &Path,
+) -> Result<TestResult> {
+    // Warn (and short-circuit) when there are no assertions.
+    if test_file.assertions.is_empty() {
+        if test_file.blocks.is_empty() {
+            eprintln!(
+                "  {} Test '{}' has no blocks and no assertions",
+                console::style("⚠").yellow(),
+                test_file.name
+            );
+            return Ok(TestResult {
+                handler_error: None,
+                assertions: vec![],
+            });
+        } else {
+            eprintln!(
+                "  {} Test '{}' has blocks but no assertions",
+                console::style("⚠").yellow(),
+                test_file.name
+            );
+        }
+    }
+
+    // Start numbering at the manifest's startBlock so implicit blocks are in range.
+    let blocks = build_blocks_with_triggers(
+        test_file,
+        manifest_info.min_start_block,
+        &manifest_info.receipt_required_selectors,
+    )?;
+
+    // Build mock IPFS file map.
+    let test_file_dir = test_file_path
+        .parent()
+        .map(|p| p.to_path_buf())
+        .unwrap_or_else(|| PathBuf::from("."));
+
+    let mut mock_files: HashMap<ContentPath, graph::bytes::Bytes> = HashMap::new();
+    for entry in &test_file.files {
+        let path = ContentPath::new(&entry.cid)
+            .map_err(|e| anyhow!("Invalid CID '{}' in test files: {}", entry.cid, e))?;
+        let content = entry
+            .resolve(&test_file_dir)
+            .with_context(|| format!("Failed to resolve mock file for CID '{}'", entry.cid))?;
+        mock_files.insert(path, content);
+    }
+
+    let (unresolved_tx, mut unresolved_rx) = tokio::sync::mpsc::unbounded_channel::<ContentPath>();
+
+    let mut mock_arweave_files: HashMap<String, graph::bytes::Bytes> = HashMap::new();
+    for entry in &test_file.arweave_files {
+        let content = entry.resolve(&test_file_dir).with_context(|| {
+            format!(
+                "Failed to resolve mock Arweave file for txId '{}'",
+                entry.tx_id
+            )
+        })?;
+        mock_arweave_files.insert(entry.tx_id.clone(), content);
+    }
+
+    let (arweave_unresolved_tx, mut arweave_unresolved_rx) =
+        tokio::sync::mpsc::unbounded_channel::<String>();
+
+    // `db` must stay alive — dropping it destroys a pgtemp database.
+    let db = create_test_database(opt, &manifest_info.build_dir)?;
+
+    let logger = make_test_logger(opt.verbose).new(o!("test" => test_file.name.clone()));
+
+    let stores = setup_stores(&logger, &db, &manifest_info.network_name).await?;
+
+    let mock_transport = MockTransport::new(test_file, &blocks)?;
+    let chain = setup_chain(&logger, blocks.clone(), &stores, mock_transport).await?;
+
+    let mock_data = MockData {
+        ipfs_files: mock_files,
+        ipfs_unresolved_tx: unresolved_tx,
+        arweave_files: mock_arweave_files,
+        arweave_unresolved_tx,
+    };
+
+    let ctx = setup_context(&logger, &stores, &chain, manifest_info, mock_data).await?;
+
+    // The indexer will process until it reaches this block.
+    let stop_block = if blocks.is_empty() {
+        mock_chain::genesis_ptr()
+    } else {
+        mock_chain::final_block_ptr(&blocks).ok_or_else(|| anyhow!("No blocks to process"))?
+    };
+
+    info!(logger, "Starting subgraph indexing"; "stop_block" => stop_block.number);
+
+    ctx.provider
+        .clone()
+        .start_subgraph(ctx.deployment.clone(), Some(stop_block.number))
+        .await;
+
+    let result = match wait_for_sync(
+        &logger,
+        ctx.store.clone(),
+        &ctx.deployment,
+        stop_block.clone(),
+    )
+    .await
+    {
+        Ok(()) => {
+            // Drain unresolved CIDs/tx IDs, deduplicating.
+            let mut unresolved_ipfs: Vec<ContentPath> = Vec::new();
+            while let Ok(cid) = unresolved_rx.try_recv() {
+                if !unresolved_ipfs.contains(&cid) {
+                    unresolved_ipfs.push(cid);
+                }
+            }
+
+            let mut unresolved_arweave: Vec<String> = Vec::new();
+            while let Ok(tx_id) = arweave_unresolved_rx.try_recv() {
+                if !unresolved_arweave.contains(&tx_id) {
+                    unresolved_arweave.push(tx_id);
+                }
+            }
+
+            let mut missing_parts: Vec<String> = Vec::new();
+
+            if !unresolved_ipfs.is_empty() {
+                let list = unresolved_ipfs
+                    .iter()
+                    .map(|p| format!("  - {}", p))
+                    .collect::<Vec<_>>()
+                    .join("\n");
+                missing_parts.push(format!(
+                    "IPFS CIDs not found in mock 'files':\n{}\n\
+                     Add the missing CID(s) to the \"files\" array in your test JSON.",
+                    list
+                ));
+            }
+
+            if !unresolved_arweave.is_empty() {
+                let list = unresolved_arweave
+                    .iter()
+                    .map(|id| format!("  - {}", id))
+                    .collect::<Vec<_>>()
+                    .join("\n");
+                missing_parts.push(format!(
+                    "Arweave tx IDs not found in mock 'arweaveFiles':\n{}\n\
+                     Add the missing txId(s) to the \"arweaveFiles\" array in your test JSON.",
+                    list
+                ));
+            }
+
+            if !missing_parts.is_empty() {
+                Ok(TestResult {
+                    handler_error: Some(missing_parts.join("\n\n")),
+                    assertions: vec![],
+                })
+            } else {
+                run_assertions(&ctx, &test_file.assertions).await
+            }
+        }
+        Err(subgraph_error) => {
+            // Fatal handler error — skip assertions.
+            Ok(TestResult {
+                handler_error: Some(format_handler_error(&subgraph_error)),
+                assertions: vec![],
+            })
+        }
+    };
+
+    // Stop the subgraph regardless of result.
+    ctx.provider
+        .clone()
+        .stop_subgraph(ctx.deployment.clone())
+        .await;
+
+    // For persistent DBs: clean up on pass, preserve on failure for inspection.
+    if db.needs_cleanup() {
+        let test_passed = result.as_ref().map(|r| r.is_passed()).unwrap_or(false);
+        if test_passed {
+            cleanup(
+                &ctx.store,
+                &manifest_info.subgraph_name,
+                &manifest_info.hash,
+            )
+            .await
+            .ok();
+        } else {
+            eprintln!(
+                "  {} Test failed — database preserved for inspection: {}",
+                console::style("ℹ").cyan(),
+                db.url()
+            );
+        }
+    }
+
+    result
+}
+
+/// Create the test database: pgtemp (auto-dropped) or persistent (`--postgres-url`).
+/// On non-Unix systems, `--postgres-url` is required.
+fn create_test_database(opt: &TestOpt, build_dir: &Path) -> Result<TestDatabase> {
+    if let Some(url) = &opt.postgres_url {
+        return Ok(TestDatabase::Persistent { url: url.clone() });
+    }
+
+    #[cfg(unix)]
+    {
+        if !build_dir.exists() {
+            anyhow::bail!(
+                "Build directory does not exist: {}. Run 'gnd build' first.",
+                build_dir.display()
+            );
+        }
+
+        // Override unix_socket_directories to /tmp: macOS temp paths can exceed
+        // the 104-byte Unix socket limit, causing postgres to silently fail to start.
+        let db = PgTempDBBuilder::new()
+            .with_data_dir_prefix(build_dir)
+            .persist_data(false)
+            .with_initdb_arg("-E", "UTF8")
+            .with_initdb_arg("--locale", "C")
+            .with_config_param("unix_socket_directories", "/tmp")
+            .start();
+
+        let url = db.connection_uri().to_string();
+        Ok(TestDatabase::Temporary { url, _handle: db })
+    }
+
+    #[cfg(not(unix))]
+    {
+        let _ = build_dir;
+        Err(anyhow!(
+            "On non-Unix systems, please provide --postgres-url"
+        ))
+    }
+}
+
+/// Database used for a single test run.
+enum TestDatabase {
+    #[cfg(unix)]
+    Temporary {
+        url: String,
+        _handle: pgtemp::PgTempDB,
+    },
+    Persistent {
+        url: String,
+    },
+}
+
+impl TestDatabase {
+    fn url(&self) -> &str {
+        match self {
+            #[cfg(unix)]
+            Self::Temporary { url, .. } => url,
+            Self::Persistent { url } => url,
+        }
+    }
+
+    /// Returns true if the deployment must be cleaned up after the test.
+    /// Temporary databases are auto-dropped; persistent ones accumulate state.
+    fn needs_cleanup(&self) -> bool {
+        match self {
+            #[cfg(unix)]
+            Self::Temporary { .. } => false,
+            Self::Persistent { .. } => true,
+        }
+    }
+}
+
+async fn setup_stores(
+    logger: &Logger,
+    db: &TestDatabase,
+    network_name: &ChainName,
+) -> Result<TestStores> {
+    let config_str = format!(
+        r#"
+[store]
+[store.primary]
+connection = "{}"
+pool_size = 2
+
+[deployment]
+[[deployment.rule]]
+store = "primary"
+indexers = [ "default" ]
+
+[chains]
+ingestor = "default"
+"#,
+        db.url()
+    );
+
+    let config = Config::from_str(&config_str, &Opt::default())
+        .map_err(|e| anyhow!("Failed to parse config: {}", e))?;
+
+    let mock_registry = Arc::new(MetricsRegistry::mock());
+    let node_id = NodeId::new(NODE_ID).unwrap();
+
+    // StoreBuilder runs migrations and creates connection pools.
+    let store_builder =
+        StoreBuilder::new(logger, &node_id, &config, None, mock_registry.clone()).await;
+
+    let chain_head_listener = store_builder.chain_head_update_listener();
+    let network_identifiers: Vec<ChainName> = vec![network_name.clone()];
+    let network_store = store_builder.network_store(network_identifiers).await;
+
+    let block_store = network_store.block_store();
+
+    // Synthetic chain identifier — net_version "1" with zero genesis hash.
+    let ident = ChainIdentifier {
+        net_version: "1".into(),
+        genesis_block_hash: graph::prelude::alloy::primitives::B256::ZERO.into(),
+    };
+
+    let chain_store = block_store
+        .create_chain_store(network_name, ident)
+        .await
+        .context("Failed to create chain store")?;
+
+    Ok(TestStores {
+        network_name: network_name.clone(),
+        chain_head_listener,
+        network_store,
+        chain_store,
+    })
+}
+
+/// Construct the mock Ethereum `Chain` with pre-built blocks.
+async fn setup_chain(
+    logger: &Logger,
+    blocks: Vec<BlockWithTriggers<Chain>>,
+    stores: &TestStores,
+    mock_transport: MockTransport,
+) -> Result<Arc<Chain>> {
+    let mock_registry = Arc::new(MetricsRegistry::mock());
+    let logger_factory = LoggerFactory::new(logger.clone(), None, mock_registry.clone());
+
+    // Dummy firehose endpoint — required by Chain constructor, never used.
+    let firehose_endpoints = FirehoseEndpoints::for_testing(vec![Arc::new(FirehoseEndpoint::new(
+        "",
+        "http://0.0.0.0:0",
+        None,
+        None,
+        true,
+        false,
+        SubgraphLimit::Unlimited,
+        Arc::new(EndpointMetrics::mock()),
+    ))]);
+
+    let client =
+        Arc::new(graph::blockchain::client::ChainClient::<Chain>::new_firehose(firehose_endpoints));
+
+    let endpoint_metrics = Arc::new(EndpointMetrics::mock());
+    let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
+    let rpc_client = graph::prelude::alloy::rpc::client::RpcClient::new(mock_transport, true);
+    let transport = Transport::RPC(rpc_client);
+
+    let block_stream_builder: Arc<dyn graph::blockchain::block_stream::BlockStreamBuilder<Chain>> =
+        Arc::new(StaticStreamBuilder { chain: blocks });
+    let dummy_adapter = Arc::new(
+        EthereumAdapter::new(
+            logger.clone(),
+            String::new(),
+            transport,
+            provider_metrics,
+            true,
+            false,
+            Arc::new(ChainSettings::from_env_defaults()),
+        )
+        .await,
+    );
+    let adapter = EthereumNetworkAdapter::new(
+        endpoint_metrics,
+        NodeCapabilities {
+            archive: true,
+            traces: false,
+        },
+        dummy_adapter,
+        SubgraphLimit::Unlimited,
+    );
+    let provider_manager = ProviderManager::new(
+        logger.clone(),
+        vec![(stores.network_name.clone(), vec![adapter])],
+        ProviderCheckStrategy::MarkAsValid,
+    );
+    let eth_adapters = Arc::new(EthereumNetworkAdapters::new(
+        stores.network_name.clone(),
+        provider_manager,
+        vec![],
+        None,
+    ));
+
+    let chain_settings = Arc::new(ChainSettings::from_env_defaults());
+    let chain = Chain::new(
+        logger_factory,
+        stores.network_name.clone(),
+        mock_registry,
+        stores.chain_store.cheap_clone(),
+        stores.chain_store.cheap_clone(),
+        client,
+        stores.chain_head_listener.cheap_clone(),
+        block_stream_builder,
+        Arc::new(StaticBlockRefetcher {
+            _phantom: PhantomData,
+        }),
+        Arc::new(NoopAdapterSelector {
+            _phantom: PhantomData,
+        }),
+        Arc::new(TestRuntimeAdapterBuilder),
+        eth_adapters,
+        graph::prelude::ENV_VARS.reorg_threshold(),
+        true,
+        chain_settings,
+    );
+
+    Ok(Arc::new(chain))
+}
+
+/// Wire up all graph-node components and deploy the subgraph.
+async fn setup_context(
+    logger: &Logger,
+    stores: &TestStores,
+    chain: &Arc<Chain>,
+    manifest_info: &ManifestInfo,
+    mock_data: MockData,
+) -> Result<TestContext> {
+    let build_dir = &manifest_info.build_dir;
+    let manifest_path = &manifest_info.manifest_path;
+    let hash = manifest_info.hash.clone();
+    let subgraph_name = manifest_info.subgraph_name.clone();
+    let start_block_override = manifest_info.start_block_override.clone();
+
+    let env_vars = Arc::new(EnvVars::from_env().unwrap_or_default());
+    let mock_registry = Arc::new(MetricsRegistry::mock());
+    let logger_factory = LoggerFactory::new(logger.clone(), None, mock_registry.clone());
+    let node_id = NodeId::new(NODE_ID).unwrap();
+
+    let subgraph_store = stores.network_store.subgraph_store();
+
+    // Route triggers to our mock chain.
+    let mut blockchain_map = BlockchainMap::new();
+    blockchain_map.insert(stores.network_name.clone(), chain.clone());
+    let blockchain_map = Arc::new(blockchain_map);
+
+    // FileLinkResolver loads from build dir. Alias maps the Qm hash → manifest path
+    // so clone_for_manifest can resolve it without treating the hash as a path.
+    let aliases =
+        std::collections::HashMap::from([(hash.to_string(), manifest_path.to_path_buf())]);
+    let link_resolver: Arc<dyn graph::components::link_resolver::LinkResolver> = Arc::new(
+        FileLinkResolver::new(Some(build_dir.to_path_buf()), aliases),
+    );
+
+    // Mock IPFS client for file data sources (FileLinkResolver handles the manifest).
+    let ipfs_metrics = IpfsMetrics::new(&mock_registry);
+    let ipfs_client = Arc::new(MockIpfsClient {
+        files: mock_data.ipfs_files,
+        metrics: ipfs_metrics,
+        unresolved_tx: mock_data.ipfs_unresolved_tx,
+    });
+
+    let ipfs_service = ipfs_service(
+        ipfs_client,
+        env_vars.mappings.max_ipfs_file_bytes,
+        env_vars.mappings.ipfs_timeout,
+        env_vars.mappings.ipfs_request_limit,
+    );
+
+    let arweave_resolver: Arc<dyn graph::components::link_resolver::ArweaveResolver> =
+        Arc::new(MockArweaveResolver {
+            files: mock_data.arweave_files,
+            unresolved_tx: mock_data.arweave_unresolved_tx,
+        });
+    let arweave_service = arweave_service(
+        arweave_resolver,
+        env_vars.mappings.ipfs_request_limit,
+        graph::components::link_resolver::FileSizeLimit::MaxBytes(
+            env_vars.mappings.max_ipfs_file_bytes as u64,
+        ),
+    );
+
+    let sg_count = Arc::new(SubgraphCountMetric::new(mock_registry.cheap_clone()));
+    let static_filters = env_vars.experimental_static_filters;
+
+    let subgraph_instance_manager = Arc::new(graph_core::subgraph::SubgraphInstanceManager::<
+        SubgraphStore,
+        FlightClient,
+    >::new(
+        &logger_factory,
+        env_vars.cheap_clone(),
+        subgraph_store.clone(),
+        blockchain_map.clone(),
+        sg_count.cheap_clone(),
+        mock_registry.clone(),
+        link_resolver.cheap_clone(),
+        ipfs_service,
+        arweave_service,
+        None,
+        static_filters,
+    ));
+
+    let mut subgraph_instance_managers =
+        graph_core::subgraph_provider::SubgraphInstanceManagers::new();
+    subgraph_instance_managers.add(
+        graph_core::subgraph_provider::SubgraphProcessingKind::Trigger,
+        subgraph_instance_manager.cheap_clone(),
+    );
+
+    let subgraph_provider = Arc::new(graph_core::subgraph_provider::SubgraphProvider::new(
+        &logger_factory,
+        sg_count.cheap_clone(),
+        subgraph_store.clone(),
+        link_resolver.cheap_clone(),
+        tokio_util::sync::CancellationToken::new(),
+        subgraph_instance_managers,
+    ));
+
+    let load_manager = LoadManager::new(logger, Vec::new(), Vec::new(), mock_registry.clone());
+    let graphql_runner = Arc::new(GraphQlRunner::new(
+        logger,
+        stores.network_store.clone(),
+        Arc::new(load_manager),
+        mock_registry.clone(),
+        Arc::new(graph::components::log_store::NoOpLogStore),
+    ));
+
+    // Uses PanicSubscriptionManager — tests don't need GraphQL subscriptions.
+    let panicking_subscription_manager = Arc::new(PanicSubscriptionManager {});
+    let subgraph_registrar = Arc::new(graph_core::subgraph::SubgraphRegistrar::new(
+        &logger_factory,
+        link_resolver.cheap_clone(),
+        subgraph_provider.cheap_clone(),
+        subgraph_store.clone(),
+        panicking_subscription_manager,
+        Option::<Arc<graph::amp::FlightClient>>::None,
+        blockchain_map.clone(),
+        node_id.clone(),
+        SubgraphVersionSwitchingMode::Instant,
+        Arc::new(Settings::default()),
+        Arc::new(AmpChainNames::default()),
+    ));
+
+    SubgraphRegistrar::create_subgraph(subgraph_registrar.as_ref(), subgraph_name.clone()).await?;
+
+    // Deploy the subgraph. start_block_override bypasses on-chain block validation.
+    let deployment = SubgraphRegistrar::create_subgraph_version(
+        subgraph_registrar.as_ref(),
+        subgraph_name.clone(),
+        hash.clone(),
+        node_id.clone(),
+        None,
+        start_block_override,
+        None,
+        None,
+        false,
+    )
+    .await?;
+
+    Ok(TestContext {
+        provider: subgraph_provider,
+        store: subgraph_store,
+        deployment,
+        graphql_runner,
+    })
+}
+
+/// Remove a subgraph deployment after a test run. Errors are ignored.
+async fn cleanup(
+    subgraph_store: &SubgraphStore,
+    name: &SubgraphName,
+    hash: &DeploymentHash,
+) -> Result<()> {
+    let locators = SubgraphStoreTrait::locators(subgraph_store, hash).await?;
+
+    // Ignore errors - the subgraph might not exist on first run
+    let _ = subgraph_store.remove_subgraph(name.clone()).await;
+
+    for locator in &locators {
+        // Unassign the deployment from its node first — remove_deployment
+        // silently skips deletion if the deployment is still assigned.
+        let _ = SubgraphStoreTrait::unassign_subgraph(subgraph_store, locator).await;
+        subgraph_store.remove_deployment(locator.id.into()).await?;
+    }
+
+    Ok(())
+}
+
+/// Format a `SubgraphError` for user-facing output.
+fn format_handler_error(err: &SubgraphError) -> String {
+    let mut parts = Vec::new();
+
+    if let Some(handler) = &err.handler {
+        parts.push(format!("in {handler}"));
+    }
+    if let Some(block_ptr) = &err.block_ptr {
+        parts.push(format!("at block #{}", block_ptr.number));
+    }
+
+    let location = parts.join(" ");
+    if location.is_empty() {
+        err.message.clone()
+    } else {
+        format!("{location}: {}", err.message)
+    }
+}
+
+/// Poll until the subgraph reaches `stop_block`, returning `Err` on fatal error or timeout.
+async fn wait_for_sync(
+    logger: &Logger,
+    store: Arc<SubgraphStore>,
+    deployment: &DeploymentLocator,
+    stop_block: BlockPtr,
+) -> Result<(), SubgraphError> {
+    // Hardcoded; could be made configurable via env var or CLI flag.
+    const MAX_WAIT: Duration = Duration::from_secs(60);
+    const WAIT_TIME: Duration = Duration::from_millis(500);
+
+    let start = Instant::now();
+
+    async fn flush(logger: &Logger, store: &Arc<SubgraphStore>, deployment: &DeploymentLocator) {
+        if let Ok(writable) = store
+            .clone()
+            .writable(logger.clone(), deployment.id, Arc::new(vec![]))
+            .await
+        {
+            let _ = writable.flush().await;
+        }
+    }
+
+    flush(logger, &store, deployment).await;
+
+    while start.elapsed() < MAX_WAIT {
+        tokio::time::sleep(WAIT_TIME).await;
+        flush(logger, &store, deployment).await;
+
+        let block_ptr = match store.least_block_ptr(&deployment.hash).await {
+            Ok(Some(ptr)) => ptr,
+            _ => continue, // Not started yet
+        };
+
+        info!(logger, "Sync progress"; "current" => block_ptr.number, "target" => stop_block.number);
+
+        // Check for fatal errors.
+        let status = store.status_for_id(deployment.id).await;
+        if let Some(fatal_error) = status.fatal_error {
+            return Err(fatal_error);
+        }
+
+        if block_ptr.number >= stop_block.number {
+            info!(logger, "Reached stop block");
+            return Ok(());
+        }
+    }
+
+    Err(SubgraphError {
+        subgraph_id: deployment.hash.clone(),
+        message: format!("Sync timeout after {}s", MAX_WAIT.as_secs()),
+        block_ptr: None,
+        handler: None,
+        deterministic: false,
+    })
+}
diff --git a/gnd/src/commands/test/schema.rs b/gnd/src/commands/test/schema.rs
new file mode 100644
index 00000000000..d684e98fff6
--- /dev/null
+++ b/gnd/src/commands/test/schema.rs
@@ -0,0 +1,315 @@
+//! JSON schema types for test files.
+//!
+//! Test files describe mock blockchain blocks with triggers and GraphQL assertions.
+//! Block triggers (Start/End) are auto-injected so block handlers with any filter
+//! (`once`, `polling`, or none) fire without explicit config.
+//!
+//! ```json
+//! {
+//!   "name": "Transfer creates entity",
+//!   "blocks": [
+//!     {
+//!       "number": 1,
+//!       "events": [
+//!         {
+//!           "address": "0x1234...",
+//!           "event": "Transfer(address indexed from, address indexed to, uint256 value)",
+//!           "params": { "from": "0xaaaa...", "to": "0xbbbb...", "value": "1000" }
+//!         }
+//!       ]
+//!     }
+//!   ],
+//!   "assertions": [
+//!     {
+//!       "query": "{ transfer(id: \"1\") { from to value } }",
+//!       "expected": { "transfer": { "from": "0xaaaa...", "to": "0xbbbb...", "value": "1000" } }
+//!     }
+//!   ]
+//! }
+//! ```
+
+use graph::bytes::Bytes;
+use serde::Deserialize;
+use serde_json::Value;
+use std::path::{Path, PathBuf};
+
+/// Top-level test file. A named test case with mock blocks and GraphQL assertions.
+#[derive(Debug, Clone, Deserialize)]
+pub struct TestFile {
+    pub name: String,
+
+    /// Mock IPFS file contents keyed by CID. Used for file data sources.
+    #[serde(default)]
+    pub files: Vec<MockFile>,
+
+    /// Mock Arweave file contents keyed by transaction ID. Used for file/arweave data sources.
+    #[serde(default, rename = "arweaveFiles")]
+    pub arweave_files: Vec<MockArweaveFile>,
+
+    /// Ordered sequence of mock blocks to index.
+    #[serde(default)]
+    pub blocks: Vec<TestBlock>,
+
+    /// GraphQL assertions to run after indexing.
+    #[serde(default)]
+    pub assertions: Vec<Assertion>,
+}
+
+/// A mock IPFS file entry for file data source testing.
+///
+/// Exactly one of `content` or `file` must be set.
+#[derive(Debug, Clone, Deserialize)]
+pub struct MockFile {
+    /// IPFS CID (`Qm...` or `bafy...`). The mock ignores hash/content relationship.
+    pub cid: String,
+
+    /// Inline UTF-8 content. Exactly one of `content` or `file` must be set.
+    #[serde(default)]
+    pub content: Option<String>,
+
+    /// File path, resolved relative to the test JSON. One of `content` or `file` required.
+    #[serde(default)]
+    pub file: Option<String>,
+}
+
+/// A mock Arweave file entry for file/arweave data source testing.
+///
+/// Exactly one of `content` or `file` must be set.
+#[derive(Debug, Clone, Deserialize)]
+pub struct MockArweaveFile {
+    /// Arweave transaction ID or bundle path (e.g. `"txid/filename.json"`).
+    /// No format validation — treated as an opaque string key.
+    #[serde(rename = "txId")]
+    pub tx_id: String,
+
+    /// Inline UTF-8 content. Exactly one of `content` or `file` must be set.
+    #[serde(default)]
+    pub content: Option<String>,
+
+    /// File path, resolved relative to the test JSON. One of `content` or `file` required.
+    #[serde(default)]
+    pub file: Option<String>,
+}
+
+impl MockArweaveFile {
+    /// Resolve to bytes. Exactly one of `content` or `file` must be set.
+    pub fn resolve(&self, test_dir: &Path) -> anyhow::Result<graph::bytes::Bytes> {
+        match (&self.content, &self.file) {
+            (Some(content), None) => Ok(graph::bytes::Bytes::from(content.clone().into_bytes())),
+            (None, Some(file)) => {
+                let path = if Path::new(file).is_absolute() {
+                    PathBuf::from(file)
+                } else {
+                    test_dir.join(file)
+                };
+                let data = std::fs::read(&path).map_err(|e| {
+                    anyhow::anyhow!("Failed to read file '{}': {}", path.display(), e)
+                })?;
+                Ok(graph::bytes::Bytes::from(data))
+            }
+            (Some(_), Some(_)) => anyhow::bail!(
+                "MockArweaveFile entry for txId '{}' must have either 'content' or 'file', not both",
+                self.tx_id
+            ),
+            (None, None) => anyhow::bail!(
+                "MockArweaveFile entry for txId '{}' must have either 'content' or 'file'",
+                self.tx_id
+            ),
+        }
+    }
+}
+
+impl MockFile {
+    /// Resolve to bytes. Exactly one of `content` or `file` must be set.
+    pub fn resolve(&self, test_dir: &Path) -> anyhow::Result<Bytes> {
+        match (&self.content, &self.file) {
+            (Some(content), None) => Ok(Bytes::from(content.clone().into_bytes())),
+            (None, Some(file)) => {
+                let path = if Path::new(file).is_absolute() {
+                    PathBuf::from(file)
+                } else {
+                    test_dir.join(file)
+                };
+                let data = std::fs::read(&path).map_err(|e| {
+                    anyhow::anyhow!("Failed to read file '{}': {}", path.display(), e)
+                })?;
+                Ok(Bytes::from(data))
+            }
+            (Some(_), Some(_)) => {
+                anyhow::bail!(
+                    "MockFile entry for CID '{}' must have either 'content' or 'file', not both",
+                    self.cid
+                )
+            }
+            (None, None) => {
+                anyhow::bail!(
+                    "MockFile entry for CID '{}' must have either 'content' or 'file'",
+                    self.cid
+                )
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct TestBlock {
+    /// Block number. If omitted, auto-increments starting from `start_block`
+    /// (default 1). Explicit numbers allow gaps (e.g., blocks 1, 5, 100).
+    #[serde(default)]
+    pub number: Option<u64>,
+
+    /// Block hash as hex string (e.g., "0xabc..."). If omitted, generated
+    /// deterministically as `keccak256(block_number)`.
+    #[serde(default)]
+    pub hash: Option<String>,
+
+    /// Unix timestamp in seconds. Defaults to the block number if omitted.
+    #[serde(default)]
+    pub timestamp: Option<u64>,
+
+    /// Log events within this block. Block triggers (Start/End) are auto-injected.
+    #[serde(default)]
+    pub events: Vec<LogEvent>,
+
+    #[serde(default, rename = "ethCalls")]
+    pub eth_calls: Vec<MockEthCall>,
+
+    #[serde(default, rename = "getBalanceCalls")]
+    pub get_balance_calls: Vec<MockBalance>,
+
+    #[serde(default, rename = "hasCodeCalls")]
+    pub has_code_calls: Vec<MockCode>,
+}
+
+/// A mock Ethereum event log.
+#[derive(Debug, Clone, Deserialize)]
+pub struct LogEvent {
+    /// Contract address that emitted the event (checksummed or lowercase hex).
+    pub address: String,
+
+    /// Full event signature with parameter names and `indexed` keywords.
+    /// e.g. `"Transfer(address indexed from, address indexed to, uint256 value)"`
+    pub event: String,
+
+    /// Parameter values keyed by name. JSON → Solidity type:
+    /// - Addresses: `"0x1234..."`
+    /// - Integers: `"1000000000000000000"` or `1000`
+    /// - Booleans: `true` / `false`
+    /// - Bytes: `"0xdeadbeef"`
+    #[serde(default)]
+    pub params: serde_json::Map<String, Value>,
+
+    /// Explicit tx hash, or generated as `keccak256(block_number || log_index)`.
+    #[serde(default, rename = "txHash")]
+    pub tx_hash: Option<String>,
+}
+
+/// A mock contract call response pre-cached for a specific block.
+#[derive(Debug, Clone, Deserialize)]
+pub struct MockEthCall {
+    pub address: String,
+    pub function: String,
+    pub params: Vec<Value>,
+    pub returns: Vec<Value>,
+
+    #[serde(default)]
+    pub reverts: bool,
+}
+
+/// Mock `ethereum.getBalance()` response.
+#[derive(Debug, Clone, Deserialize)]
+pub struct MockBalance {
+    pub address: String,
+    /// Wei as a decimal string.
+    pub value: String,
+}
+
+/// Mock `ethereum.hasCode()` response.
+#[derive(Debug, Clone, Deserialize)]
+pub struct MockCode {
+    pub address: String,
+    #[serde(rename = "hasCode")]
+    pub has_code: bool,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct Assertion {
+    pub query: String,
+
+    /// Expected JSON result. String/number coercion is applied (BigInt/BigDecimal).
+    pub expected: Value,
+}
+
+#[derive(Debug)]
+pub struct TestResult {
+    pub handler_error: Option<String>,
+    pub assertions: Vec<AssertionOutcome>,
+}
+
+impl TestResult {
+    pub fn is_passed(&self) -> bool {
+        self.handler_error.is_none()
+            && self
+                .assertions
+                .iter()
+                .all(|a| matches!(a, AssertionOutcome::Passed { .. }))
+    }
+}
+
+#[derive(Debug)]
+pub enum AssertionOutcome {
+    Passed { query: String },
+    Failed(AssertionFailure),
+}
+
+#[derive(Debug)]
+pub struct AssertionFailure {
+    pub query: String,
+    pub expected: Value,
+    pub actual: Value,
+}
+
+/// Parse a JSON test file (validates schema only, not semantic correctness).
+pub fn parse_test_file(path: &Path) -> anyhow::Result<TestFile> {
+    let content = std::fs::read_to_string(path)
+        .map_err(|e| anyhow::anyhow!("Failed to read test file {}: {}", path.display(), e))?;
+    serde_json::from_str(&content)
+        .map_err(|e| anyhow::anyhow!("Failed to parse test file {}: {}", path.display(), e))
+}
+
+/// Recursively discover `*.json` / `*.test.json` files.
+/// Skips entries whose name starts with a non-alphanumeric character.
+pub fn discover_test_files(dir: &Path) -> anyhow::Result<Vec<PathBuf>> {
+    let mut files = Vec::new();
+
+    if !dir.exists() {
+        return Ok(files);
+    }
+
+    discover_recursive(dir, &mut files)?;
+    files.sort();
+    Ok(files)
+}
+
+fn discover_recursive(dir: &Path, files: &mut Vec<PathBuf>) -> anyhow::Result<()> {
+    for entry in std::fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        let name = match path.file_name().and_then(|n| n.to_str()) {
+            Some(n) => n,
+            None => continue,
+        };
+
+        if !name.starts_with(|c: char| c.is_alphanumeric()) {
+            continue;
+        }
+
+        if path.is_dir() {
+            discover_recursive(&path, files)?;
+        } else if path.is_file() && (name.ends_with(".test.json") || name.ends_with(".json")) {
+            files.push(path);
+        }
+    }
+
+    Ok(())
+}
diff --git a/gnd/src/commands/test/trigger.rs b/gnd/src/commands/test/trigger.rs
new file mode 100644
index 00000000000..6ac11557678
--- /dev/null
+++ b/gnd/src/commands/test/trigger.rs
@@ -0,0 +1,504 @@
+//! ABI encoding of JSON test triggers into graph-node's Ethereum trigger types.
+//!
+//! For `Transfer(address indexed from, address indexed to, uint256 value)`:
+//! - topic0 = keccak256("Transfer(address,address,uint256)")
+//! - topic1 = left-padded `from` address (indexed)
+//! - topic2 = left-padded `to` address (indexed)
+//! - data = ABI-encoded `value` (non-indexed)
+
+use super::schema::{LogEvent, TestFile};
+use anyhow::{Context, Result, anyhow, ensure};
+use graph::blockchain::block_stream::BlockWithTriggers;
+use graph::components::ethereum::AnyTransactionReceiptBare;
+use graph::prelude::alloy::consensus::{Eip658Value, Receipt, ReceiptWithBloom};
+use graph::prelude::alloy::dyn_abi::{DynSolType, DynSolValue};
+use graph::prelude::alloy::json_abi::Event;
+use graph::prelude::alloy::network::AnyReceiptEnvelope;
+use graph::prelude::alloy::primitives::{Address, B256, Bloom, Bytes, I256, U256, keccak256};
+use graph::prelude::alloy::rpc::types::{Log, TransactionReceipt};
+use graph::prelude::{BlockPtr, LightEthereumBlock};
+use graph_chain_ethereum::Chain;
+use graph_chain_ethereum::chain::BlockFinality;
+use graph_chain_ethereum::trigger::{EthereumBlockTriggerType, EthereumTrigger, LogRef};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+/// Build `BlockWithTriggers` from test blocks, chained by parent hash.
+/// Numbers auto-increment from `start_block` when omitted.
+/// Only logs whose topic0 is in `receipt_required_selectors` get a non-null receipt.
+pub fn build_blocks_with_triggers(
+    test_file: &TestFile,
+    start_block: u64,
+    receipt_required_selectors: &std::collections::HashSet<B256>,
+) -> Result<Vec<BlockWithTriggers<Chain>>> {
+    let mut blocks = Vec::new();
+    let mut current_number = start_block;
+    let mut parent_hash = B256::ZERO;
+
+    for test_block in &test_file.blocks {
+        let number = test_block.number.unwrap_or(current_number);
+
+        let hash = test_block
+            .hash
+            .as_ref()
+            .map(|h| h.parse::<B256>())
+            .transpose()
+            .context("Invalid block hash")?
+            .unwrap_or_else(|| keccak256(number.to_be_bytes()));
+
+        // Default timestamp = block number — avoids chain-specific block times.
+        let timestamp = test_block.timestamp.unwrap_or(number);
+
+        let mut triggers = Vec::new();
+
+        // Pass 1: parse each event into (tx_hash, Arc<Log>).
+        let event_logs: Vec<(B256, Arc<Log>)> = test_block
+            .events
+            .iter()
+            .enumerate()
+            .map(|(i, e)| prepare_event_log(number, hash, i as u64, e))
+            .collect::<Result<_>>()?;
+
+        // Pass 2: build one mock receipt per tx-hash group.
+        let receipts = build_receipts_by_tx(number, hash, &event_logs);
+
+        // Pass 3: one log trigger per event. Receipt only for `receipt: true` handlers.
+        for (tx_hash, full_log) in &event_logs {
+            let needs_receipt = full_log
+                .topics()
+                .first()
+                .is_some_and(|t| receipt_required_selectors.contains(t));
+            let receipt = needs_receipt.then(|| receipts[tx_hash].clone());
+            triggers.push(EthereumTrigger::Log(LogRef::FullLog(
+                full_log.clone(),
+                receipt,
+            )));
+        }
+
+        // Inject Start/End block triggers so `once`, `polling`, and unfiltered handlers fire.
+        ensure!(
+            number <= i32::MAX as u64,
+            "block number {} exceeds i32::MAX",
+            number
+        );
+        let block_ptr = BlockPtr::new(hash.into(), number as i32);
+        triggers.push(EthereumTrigger::Block(
+            block_ptr.clone(),
+            EthereumBlockTriggerType::Start,
+        ));
+        triggers.push(EthereumTrigger::Block(
+            block_ptr,
+            EthereumBlockTriggerType::End,
+        ));
+
+        let block = create_block_with_triggers(number, hash, parent_hash, timestamp, triggers)?;
+        blocks.push(block);
+
+        parent_hash = hash;
+        current_number = number + 1;
+    }
+
+    Ok(blocks)
+}
+
+/// Parse a test event into `(tx_hash, Arc<Log>)`.
+/// tx_hash from the event or generated as `keccak256(block_number || log_index)`.
+fn prepare_event_log(
+    block_number: u64,
+    block_hash: B256,
+    log_index: u64,
+    trigger: &LogEvent,
+) -> Result<(B256, Arc<Log>)> {
+    let address: Address = trigger.address.parse()?;
+
+    let (topics, data) = encode_event_log(&trigger.event, &trigger.params)?;
+
+    // Deterministic tx hash: keccak256(block_number || log_index).
+    let tx_hash = trigger
+        .tx_hash
+        .as_ref()
+        .map(|h| h.parse::<B256>())
+        .transpose()?
+        .unwrap_or_else(|| {
+            keccak256([block_number.to_be_bytes(), log_index.to_be_bytes()].concat())
+        });
+
+    let inner_log = graph::prelude::alloy::primitives::Log {
+        address,
+        data: graph::prelude::alloy::primitives::LogData::new_unchecked(topics, data),
+    };
+
+    let full_log = Arc::new(Log {
+        inner: inner_log,
+        block_hash: Some(block_hash),
+        block_number: Some(block_number),
+        block_timestamp: None,
+        transaction_hash: Some(tx_hash),
+        transaction_index: Some(0),
+        log_index: Some(log_index),
+        removed: false,
+    });
+
+    Ok((tx_hash, full_log))
+}
+
+/// Build one receipt per unique tx_hash. Logs sharing a tx_hash are grouped;
+/// events without an explicit tx_hash each get their own receipt.
+fn build_receipts_by_tx(
+    block_number: u64,
+    block_hash: B256,
+    event_logs: &[(B256, Arc<Log>)],
+) -> HashMap<B256, Arc<AnyTransactionReceiptBare>> {
+    // Collect logs per tx_hash, preserving insertion order for tx_index.
+    let mut tx_order: Vec<B256> = Vec::new();
+    let mut logs_by_tx: HashMap<B256, Vec<Log>> = HashMap::new();
+
+    for (tx_hash, log) in event_logs {
+        let entry = logs_by_tx.entry(*tx_hash).or_insert_with(|| {
+            tx_order.push(*tx_hash);
+            Vec::new()
+        });
+        entry.push((**log).clone());
+    }
+
+    let mut receipts: HashMap<B256, Arc<AnyTransactionReceiptBare>> =
+        HashMap::with_capacity(tx_order.len());
+
+    for (tx_index, tx_hash) in tx_order.into_iter().enumerate() {
+        let logs = logs_by_tx.remove(&tx_hash).unwrap_or_default();
+
+        let core_receipt = Receipt {
+            status: Eip658Value::Eip658(true),
+            cumulative_gas_used: 21_000,
+            logs,
+        };
+
+        let receipt_with_bloom = ReceiptWithBloom::new(core_receipt, Bloom::default());
+
+        let any_envelope = AnyReceiptEnvelope {
+            inner: receipt_with_bloom,
+            r#type: 2,
+        };
+
+        let receipt = TransactionReceipt {
+            transaction_hash: tx_hash,
+            transaction_index: Some(tx_index as u64),
+            block_hash: Some(block_hash),
+            block_number: Some(block_number),
+            gas_used: 21_000,
+            from: Address::ZERO,
+            to: None,
+            effective_gas_price: 0,
+            blob_gas_used: None,
+            blob_gas_price: None,
+            contract_address: None,
+            inner: any_envelope,
+        };
+
+        receipts.insert(tx_hash, Arc::new(receipt));
+    }
+
+    receipts
+}
+
+/// ABI-encode event params into EVM log (topics, data).
+///
+/// topic0 = keccak256 of the canonical signature; indexed params → topics;
+/// non-indexed params → ABI-encoded data.
+pub fn encode_event_log(
+    event_sig: &str,
+    params: &serde_json::Map<String, serde_json::Value>,
+) -> Result<(Vec<B256>, Bytes)> {
+    // Event::parse requires "event " prefix — add if missing.
+    let sig_with_prefix = if event_sig.trim_start().starts_with("event ") {
+        event_sig.to_string()
+    } else {
+        format!("event {}", event_sig)
+    };
+
+    let event = Event::parse(&sig_with_prefix)
+        .map_err(|e| anyhow!("Failed to parse event signature '{}': {:?}", event_sig, e))?;
+
+    let topic0 = event.selector();
+    let mut topics = vec![topic0];
+    let mut data_values = Vec::new();
+
+    for input in &event.inputs {
+        let value = params
+            .get(&input.name)
+            .ok_or_else(|| anyhow!("Missing parameter: {}", input.name))?;
+
+        let sol_type: DynSolType = input
+            .ty
+            .parse()
+            .map_err(|e| anyhow!("Invalid type '{}': {:?}", input.ty, e))?;
+
+        let sol_value = json_to_sol_value(&sol_type, value)?;
+
+        if input.indexed {
+            let topic = sol_value_to_topic(&sol_value)?;
+            topics.push(topic);
+        } else {
+            data_values.push(sol_value);
+        }
+    }
+
+    let data = if data_values.is_empty() {
+        Bytes::new()
+    } else {
+        let tuple = DynSolValue::Tuple(data_values);
+        Bytes::from(tuple.abi_encode_params())
+    };
+
+    Ok((topics, data))
+}
+
+/// Convert a JSON value to the corresponding Solidity type.
+/// Supports: address, uint/int (decimal or hex string), bool, bytes, string, bytes1-32, arrays, tuples.
+pub fn json_to_sol_value(sol_type: &DynSolType, value: &serde_json::Value) -> Result<DynSolValue> {
+    match sol_type {
+        DynSolType::Address => {
+            let s = value
+                .as_str()
+                .ok_or_else(|| anyhow!("Expected string for address"))?;
+            let addr: Address = s.parse().context("Invalid address")?;
+            Ok(DynSolValue::Address(addr))
+        }
+        DynSolType::Uint(bits) => {
+            let n = match value {
+                serde_json::Value::String(s) => {
+                    let (digits, radix) = match s.strip_prefix("0x") {
+                        Some(hex) => (hex, 16),
+                        None => (s.as_str(), 10),
+                    };
+                    U256::from_str_radix(digits, radix).context("Invalid uint")?
+                }
+                // JSON numbers are limited to u64 range — use strings for larger values.
+                serde_json::Value::Number(n) => U256::from(n.as_u64().ok_or_else(|| {
+                    anyhow!("uint value {} does not fit in u64, use a string instead", n)
+                })?),
+                _ => return Err(anyhow!("Expected string or number for uint")),
+            };
+            Ok(DynSolValue::Uint(n, *bits))
+        }
+        DynSolType::Int(bits) => {
+            let n = match value {
+                serde_json::Value::String(s) => {
+                    let (is_neg, s_abs) = match s.strip_prefix('-') {
+                        Some(rest) => (true, rest),
+                        None => (false, s.as_str()),
+                    };
+                    let (digits, radix) = match s_abs.strip_prefix("0x") {
+                        Some(hex) => (hex, 16),
+                        None => (s_abs, 10),
+                    };
+                    let abs = U256::from_str_radix(digits, radix).context("Invalid int")?;
+                    if is_neg { !abs + U256::from(1) } else { abs }
+                }
+                serde_json::Value::Number(n) => {
+                    if let Some(i) = n.as_i64() {
+                        // into_raw() gives the two's complement U256 representation.
+                        // Handles i64::MIN correctly (unlike `-i as u64` which overflows).
+                        I256::try_from(i).unwrap().into_raw()
+                    } else {
+                        U256::from(n.as_u64().ok_or_else(|| {
+                            anyhow!(
+                                "int value {} not representable as u64, use a string instead",
+                                n
+                            )
+                        })?)
+                    }
+                }
+                _ => return Err(anyhow!("Expected string or number for int")),
+            };
+            Ok(DynSolValue::Int(I256::from_raw(n), *bits))
+        }
+        DynSolType::Bool => {
+            let b = value.as_bool().ok_or_else(|| anyhow!("Expected bool"))?;
+            Ok(DynSolValue::Bool(b))
+        }
+        DynSolType::Bytes => {
+            let s = value
+                .as_str()
+                .ok_or_else(|| anyhow!("Expected string for bytes"))?;
+            let hex_str = s.strip_prefix("0x").unwrap_or(s);
+            let bytes = hex::decode(hex_str).context("Invalid hex")?;
+            Ok(DynSolValue::Bytes(bytes))
+        }
+        DynSolType::String => {
+            let s = value.as_str().ok_or_else(|| anyhow!("Expected string"))?;
+            Ok(DynSolValue::String(s.to_string()))
+        }
+        DynSolType::FixedBytes(len) => {
+            let s = value
+                .as_str()
+                .ok_or_else(|| anyhow!("Expected string for bytes{}", len))?;
+            let hex_str = s.strip_prefix("0x").unwrap_or(s);
+            let bytes = hex::decode(hex_str).context("Invalid hex")?;
+            if bytes.len() > *len {
+                return Err(anyhow!(
+                    "bytes{}: got {} bytes, expected at most {}",
+                    len,
+                    bytes.len(),
+                    len
+                ));
+            }
+            // DynSolValue::FixedBytes wraps a full B256 — right-zero-pad.
+            let mut padded = [0u8; 32];
+            padded[..bytes.len()].copy_from_slice(&bytes);
+            Ok(DynSolValue::FixedBytes(B256::from(padded), *len))
+        }
+        DynSolType::Array(inner) => {
+            let arr = value
+                .as_array()
+                .ok_or_else(|| anyhow!("Expected JSON array for array type"))?;
+            let elements: Vec<DynSolValue> = arr
+                .iter()
+                .map(|elem| json_to_sol_value(inner, elem))
+                .collect::<Result<_>>()?;
+            Ok(DynSolValue::Array(elements))
+        }
+        DynSolType::FixedArray(inner, size) => {
+            let arr = value
+                .as_array()
+                .ok_or_else(|| anyhow!("Expected JSON array for fixed array type"))?;
+            ensure!(
+                arr.len() == *size,
+                "Fixed array expects {} elements, got {}",
+                size,
+                arr.len()
+            );
+            let elements: Vec<DynSolValue> = arr
+                .iter()
+                .map(|elem| json_to_sol_value(inner, elem))
+                .collect::<Result<_>>()?;
+            Ok(DynSolValue::FixedArray(elements))
+        }
+        DynSolType::Tuple(types) => {
+            let arr = value
+                .as_array()
+                .ok_or_else(|| anyhow!("Expected JSON array for tuple type (positional)"))?;
+            ensure!(
+                arr.len() == types.len(),
+                "Tuple expects {} elements, got {}",
+                types.len(),
+                arr.len()
+            );
+            let values: Vec<DynSolValue> = types
+                .iter()
+                .zip(arr.iter())
+                .map(|(ty, val)| json_to_sol_value(ty, val))
+                .collect::<Result<_>>()?;
+            Ok(DynSolValue::Tuple(values))
+        }
+        _ => Err(anyhow!("Unsupported type: {:?}", sol_type)),
+    }
+}
+
+/// Encode a Solidity value as a 32-byte EVM log topic.
+fn sol_value_to_topic(value: &DynSolValue) -> Result<B256> {
+    match value {
+        DynSolValue::Address(addr) => {
+            let mut bytes = [0u8; 32];
+            bytes[12..].copy_from_slice(addr.as_slice());
+            Ok(B256::from(bytes))
+        }
+        DynSolValue::Uint(n, _) => Ok(B256::from(*n)),
+        DynSolValue::Int(n, _) => Ok(B256::from(n.into_raw())),
+        DynSolValue::Bool(b) => {
+            let mut bytes = [0u8; 32];
+            if *b {
+                bytes[31] = 1;
+            }
+            Ok(B256::from(bytes))
+        }
+        DynSolValue::FixedBytes(b, _) => Ok(*b),
+        // Dynamic types are hashed per Solidity spec.
+        DynSolValue::Bytes(b) => Ok(keccak256(b)),
+        DynSolValue::String(s) => Ok(keccak256(s.as_bytes())),
+        _ => Err(anyhow!("Cannot convert {:?} to topic", value)),
+    }
+}
+
+/// Create a dummy transaction for block transaction lists.
+/// Graph-node requires matching transactions for log processing.
+fn dummy_transaction(
+    block_number: u64,
+    block_hash: B256,
+    transaction_index: u64,
+    transaction_hash: B256,
+) -> graph::components::ethereum::AnyTransaction {
+    use graph::components::ethereum::AnyTxEnvelope;
+    use graph::prelude::alloy::consensus::transaction::Recovered;
+    use graph::prelude::alloy::consensus::{Signed, TxEnvelope, TxLegacy};
+    use graph::prelude::alloy::primitives::{Address, Signature, U256};
+    use graph::prelude::alloy::rpc::types::Transaction;
+
+    let signed = Signed::new_unchecked(
+        TxLegacy::default(),
+        Signature::new(U256::from(1), U256::from(1), false),
+        transaction_hash,
+    );
+
+    let envelope = AnyTxEnvelope::Ethereum(TxEnvelope::Legacy(signed));
+
+    Transaction {
+        inner: Recovered::new_unchecked(envelope, Address::ZERO),
+        block_hash: Some(block_hash),
+        block_number: Some(block_number),
+        block_timestamp: None,
+        transaction_index: Some(transaction_index),
+        effective_gas_price: None,
+    }
+}
+
+fn create_block_with_triggers(
+    number: u64,
+    hash: B256,
+    parent_hash: B256,
+    timestamp: u64,
+    triggers: Vec<EthereumTrigger>,
+) -> Result<BlockWithTriggers<Chain>> {
+    use graph::components::ethereum::AnyHeader;
+    use graph::prelude::alloy::consensus::Header as ConsensusHeader;
+    use graph::prelude::alloy::rpc::types::{Block, BlockTransactions, Header};
+    use std::collections::HashSet;
+
+    // Collect unique transaction hashes from log triggers.
+    let mut tx_hashes: HashSet<B256> = HashSet::new();
+    for trigger in &triggers {
+        if let EthereumTrigger::Log(LogRef::FullLog(log, _)) = trigger
+            && let Some(tx_hash) = log.transaction_hash
+        {
+            tx_hashes.insert(tx_hash);
+        }
+    }
+
+    let transactions: Vec<_> = tx_hashes
+        .into_iter()
+        .enumerate()
+        .map(|(idx, tx_hash)| dummy_transaction(number, hash, idx as u64, tx_hash))
+        .collect();
+
+    let alloy_block = Block::empty(Header {
+        hash,
+        inner: AnyHeader::from(ConsensusHeader {
+            number,
+            parent_hash,
+            timestamp,
+            ..Default::default()
+        }),
+        total_difficulty: None,
+        size: None,
+    })
+    .with_transactions(BlockTransactions::Full(transactions));
+
+    let light_block = LightEthereumBlock::new(alloy_block);
+    let finality_block = BlockFinality::Final(Arc::new(light_block));
+
+    Ok(BlockWithTriggers::new(
+        finality_block,
+        triggers,
+        &graph::log::logger(false),
+    ))
+}
diff --git a/gnd/src/compiler/asc.rs b/gnd/src/compiler/asc.rs
new file mode 100644
index 00000000000..821adba699c
--- /dev/null
+++ b/gnd/src/compiler/asc.rs
@@ -0,0 +1,276 @@
+//! AssemblyScript compiler wrapper.
+//!
+//! This module provides a wrapper around the `asc` (AssemblyScript compiler)
+//! command-line tool for compiling subgraph mappings to WebAssembly.
+
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use anyhow::{Context, Result, anyhow};
+
+/// Options for compiling an AssemblyScript file.
+#[derive(Debug, Clone)]
+pub struct AscCompileOptions {
+    /// The input TypeScript/AssemblyScript file to compile.
+    pub input_file: PathBuf,
+    /// The base directory for resolving imports.
+    pub base_dir: PathBuf,
+    /// Comma-separated list of library directories (node_modules paths).
+    pub libs: String,
+    /// Path to the graph-ts global.ts file.
+    pub global_file: PathBuf,
+    /// Output file path.
+    pub output_file: PathBuf,
+    /// Output format: "wasm" or "wast".
+    pub output_format: String,
+    /// Skip the asc version check (use with caution).
+    pub skip_version_check: bool,
+}
+
+/// The required AssemblyScript compiler version.
+/// gnd functionality is very sensitive to asc version changes.
+const REQUIRED_ASC_VERSION: &str = "0.19.23";
+
+/// Compile an AssemblyScript mapping file to WebAssembly.
+///
+/// This shells out to the `asc` command-line tool with the appropriate flags
+/// to match the graph-cli behavior.
+///
+/// Requires asc version 0.19.23 to be installed.
+pub fn compile_mapping(options: &AscCompileOptions) -> Result<()> {
+    // Resolve the asc binary, checking global PATH and local node_modules/.bin
+    let asc_bin = find_asc_binary(&options.base_dir).ok_or_else(|| {
+        anyhow!(
+            "AssemblyScript compiler (asc) not found. Install it with:\n  \
+             npm install -g assemblyscript@{REQUIRED_ASC_VERSION}\n  \
+             or locally:\n  \
+             npm install --save-dev assemblyscript@{REQUIRED_ASC_VERSION}"
+        )
+    })?;
+
+    // Check version unless explicitly skipped
+    if !options.skip_version_check {
+        let version = get_asc_version(&asc_bin)?;
+        if version != REQUIRED_ASC_VERSION {
+            return Err(anyhow!(
+                "AssemblyScript compiler version mismatch: found {}, required {}.\n  \
+                 Please install the correct version with:\n  \
+                 npm install -g assemblyscript@{REQUIRED_ASC_VERSION}\n\n  \
+                 If you know what you're doing, use --skip-asc-version-check or set GND_SKIP_ASC_VERSION_CHECK=1 to bypass this check.",
+                version,
+                REQUIRED_ASC_VERSION
+            ));
+        }
+    }
+
+    // Determine input and output paths relative to base_dir
+    let input_rel = options
+        .input_file
+        .strip_prefix(&options.base_dir)
+        .unwrap_or(&options.input_file);
+    let global_rel = options
+        .global_file
+        .strip_prefix(&options.base_dir)
+        .unwrap_or(&options.global_file);
+    let output_rel = options
+        .output_file
+        .strip_prefix(&options.base_dir)
+        .unwrap_or(&options.output_file);
+
+    // Build the asc command
+    let mut cmd = Command::new(&asc_bin);
+
+    // Add compiler flags matching graph-cli behavior
+    cmd.arg("--explicitStart")
+        .arg("--exportRuntime")
+        .arg("--runtime")
+        .arg("stub")
+        .arg(input_rel)
+        .arg(global_rel)
+        .arg("--baseDir")
+        .arg(&options.base_dir)
+        .arg("--lib")
+        .arg(&options.libs)
+        .arg("--outFile")
+        .arg(output_rel)
+        .arg("--optimize")
+        .arg("--debug");
+
+    // Set working directory
+    cmd.current_dir(&options.base_dir);
+
+    // Execute the compiler
+    let output = cmd
+        .output()
+        .context("Failed to execute AssemblyScript compiler (asc). Is it installed?")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+
+        let error_msg = if !stderr.is_empty() {
+            stderr.to_string()
+        } else if !stdout.is_empty() {
+            stdout.to_string()
+        } else {
+            "Unknown compilation error".to_string()
+        };
+
+        return Err(anyhow!(
+            "AssemblyScript compilation failed for {}:\n{}",
+            options.input_file.display(),
+            error_msg
+        ));
+    }
+
+    Ok(())
+}
+
+/// Find the graph-ts package in node_modules.
+///
+/// Searches upward from `source_dir` looking for `node_modules/@graphprotocol/graph-ts`.
+/// Returns the paths needed for compilation:
+/// - List of node_modules directories (for --lib flag)
+/// - Path to global/global.ts
+pub fn find_graph_ts(source_dir: &Path) -> Result<(Vec<PathBuf>, PathBuf)> {
+    let mut lib_dirs = Vec::new();
+    let mut graph_ts_dir: Option<PathBuf> = None;
+
+    let mut current = source_dir.canonicalize().ok();
+
+    while let Some(dir) = current {
+        let node_modules = dir.join("node_modules");
+
+        if node_modules.exists() {
+            lib_dirs.push(node_modules.clone());
+
+            // Check if this node_modules has graph-ts
+            let graph_ts_path = node_modules.join("@graphprotocol").join("graph-ts");
+
+            if graph_ts_path.exists() && graph_ts_dir.is_none() {
+                graph_ts_dir = Some(graph_ts_path);
+            }
+        }
+
+        // Move up to parent directory
+        current = dir.parent().map(|p| p.to_path_buf());
+    }
+
+    if lib_dirs.is_empty() {
+        return Err(anyhow!(
+            "Could not locate `node_modules` in parent directories of subgraph manifest"
+        ));
+    }
+
+    let graph_ts = graph_ts_dir.ok_or_else(|| {
+        anyhow!(
+            "Could not locate `@graphprotocol/graph-ts` package in parent directories of subgraph manifest"
+        )
+    })?;
+
+    let global_file = graph_ts.join("global").join("global.ts");
+    if !global_file.exists() {
+        return Err(anyhow!(
+            "Could not find global.ts in graph-ts package at {}",
+            graph_ts.display()
+        ));
+    }
+
+    Ok((lib_dirs, global_file))
+}
+
+/// Find the `asc` binary by checking the global PATH first, then the project's
+/// root `node_modules/.bin/asc`.
+pub fn find_asc_binary(base_dir: &Path) -> Option<PathBuf> {
+    // Check global PATH first
+    if Command::new("asc")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+    {
+        return Some(PathBuf::from("asc"));
+    }
+
+    // Backward compatibility with graph-cli: check local node_modules/.bin/asc
+    let local_asc = base_dir.join("node_modules").join(".bin").join("asc");
+    if local_asc.exists() {
+        return Some(local_asc);
+    }
+
+    None
+}
+
+/// Get the asc compiler version.
+fn get_asc_version(asc_bin: &Path) -> Result<String> {
+    let output = Command::new(asc_bin)
+        .arg("--version")
+        .output()
+        .context("Failed to execute asc --version")?;
+
+    if !output.status.success() {
+        return Err(anyhow!("asc --version failed"));
+    }
+
+    // Output is "Version X.Y.Z", extract just the version number
+    let version_output = String::from_utf8_lossy(&output.stdout);
+    let version = version_output
+        .trim()
+        .strip_prefix("Version ")
+        .unwrap_or(version_output.trim())
+        .to_string();
+    Ok(version)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_find_graph_ts_not_found() {
+        let temp_dir = TempDir::new().unwrap();
+        let result = find_graph_ts(temp_dir.path());
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("node_modules"));
+    }
+
+    #[test]
+    fn test_find_graph_ts_found() {
+        let temp_dir = TempDir::new().unwrap();
+
+        // Create the graph-ts directory structure
+        let graph_ts_dir = temp_dir
+            .path()
+            .join("node_modules")
+            .join("@graphprotocol")
+            .join("graph-ts")
+            .join("global");
+        std::fs::create_dir_all(&graph_ts_dir).unwrap();
+        std::fs::write(graph_ts_dir.join("global.ts"), "// global").unwrap();
+
+        let (lib_dirs, global_file) = find_graph_ts(temp_dir.path()).unwrap();
+
+        assert_eq!(lib_dirs.len(), 1);
+        assert!(lib_dirs[0].ends_with("node_modules"));
+        assert!(global_file.ends_with("global.ts"));
+    }
+
+    #[test]
+    fn test_asc_version_check() {
+        // Skip if asc is not installed
+        let temp_dir = TempDir::new().unwrap();
+        let asc_bin = match find_asc_binary(temp_dir.path()) {
+            Some(bin) => bin,
+            None => return,
+        };
+
+        let version = get_asc_version(&asc_bin).unwrap();
+        // Version should be a semver-like string (e.g., "0.19.23")
+        assert!(
+            version.split('.').count() >= 2,
+            "Version '{}' doesn't look like a semver",
+            version
+        );
+    }
+}
diff --git a/gnd/src/compiler/mod.rs b/gnd/src/compiler/mod.rs
new file mode 100644
index 00000000000..0c80a4aec89
--- /dev/null
+++ b/gnd/src/compiler/mod.rs
@@ -0,0 +1,8 @@
+//! Compiler module for building subgraph mappings.
+//!
+//! This module provides functionality to compile AssemblyScript mappings
+//! to WebAssembly using the AssemblyScript compiler (asc).
+
+mod asc;
+
+pub use asc::{AscCompileOptions, compile_mapping, find_asc_binary, find_graph_ts};
diff --git a/gnd/src/config/mod.rs b/gnd/src/config/mod.rs
new file mode 100644
index 00000000000..38b57baf6b4
--- /dev/null
+++ b/gnd/src/config/mod.rs
@@ -0,0 +1,13 @@
+//! Configuration file handling for gnd.
+//!
+//! This module provides parsers and utilities for various configuration files
+//! used by the gnd CLI:
+//!
+//! - `networks.json` - Network-specific contract addresses and start blocks
+
+pub mod networks;
+
+pub use networks::{
+    DataSourceNetworkConfig, NetworkConfig, NetworksConfig, apply_network_config,
+    get_network_config, init_networks_config, load_networks_config, update_networks_file,
+};
diff --git a/gnd/src/config/networks.rs b/gnd/src/config/networks.rs
new file mode 100644
index 00000000000..667d72745aa
--- /dev/null
+++ b/gnd/src/config/networks.rs
@@ -0,0 +1,543 @@
+//! Network configuration parsing for subgraph deployments.
+//!
+//! This module handles parsing and applying networks.json configuration files,
+//! which allow deploying the same subgraph to different networks with
+//! network-specific contract addresses and start blocks.
+
+use std::collections::HashMap;
+use std::fs;
+use std::path::Path;
+
+use anyhow::{Context, Result, anyhow};
+use serde::{Deserialize, Serialize};
+
+/// Network-specific configuration for a data source.
+///
+/// Contains the contract address and optional start block for a specific
+/// data source on a specific network.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DataSourceNetworkConfig {
+    /// Contract address (with or without 0x prefix)
+    pub address: Option<String>,
+
+    /// Block number to start indexing from
+    #[serde(rename = "startBlock")]
+    pub start_block: Option<u64>,
+}
+
+/// Configuration for a specific network.
+///
+/// Maps data source names to their network-specific configuration.
+pub type NetworkConfig = HashMap<String, DataSourceNetworkConfig>;
+
+/// Complete networks configuration file.
+///
+/// Maps network names to their configuration.
+pub type NetworksConfig = HashMap<String, NetworkConfig>;
+
+/// Load a networks.json configuration file.
+///
+/// # Arguments
+/// * `path` - Path to the networks.json file
+///
+/// # Returns
+/// The parsed networks configuration, or an error if the file doesn't exist
+/// or is malformed.
+pub fn load_networks_config(path: &Path) -> Result<NetworksConfig> {
+    let content = fs::read_to_string(path)
+        .with_context(|| format!("Failed to read networks config from {}", path.display()))?;
+
+    serde_json::from_str(&content)
+        .with_context(|| format!("Failed to parse networks config from {}", path.display()))
+}
+
+/// Get configuration for a specific network.
+///
+/// # Arguments
+/// * `config` - The full networks configuration
+/// * `network` - The network name to look up
+///
+/// # Returns
+/// The network configuration, or an error if the network is not found.
+pub fn get_network_config<'a>(
+    config: &'a NetworksConfig,
+    network: &str,
+) -> Result<&'a NetworkConfig> {
+    config
+        .get(network)
+        .ok_or_else(|| anyhow!("Network '{}' was not found in networks config", network))
+}
+
+/// Apply network configuration to a manifest YAML.
+///
+/// Updates data source addresses and start blocks based on the network configuration.
+///
+/// # Arguments
+/// * `manifest` - Mutable reference to the parsed manifest YAML
+/// * `network` - The target network name
+/// * `network_config` - Configuration for the target network
+///
+/// # Returns
+/// Ok(()) on success, or an error if a data source is missing from the config.
+pub fn apply_network_config(
+    manifest: &mut serde_yaml::Value,
+    network: &str,
+    network_config: &NetworkConfig,
+) -> Result<()> {
+    // Update data sources
+    if let Some(data_sources) = manifest.get_mut("dataSources")
+        && let Some(arr) = data_sources.as_sequence_mut()
+    {
+        for ds in arr.iter_mut() {
+            update_data_source(ds, network, network_config)?;
+        }
+    }
+
+    // Update templates to use the same network
+    if let Some(templates) = manifest.get_mut("templates")
+        && let Some(arr) = templates.as_sequence_mut()
+    {
+        for template in arr.iter_mut() {
+            if let Some(mapping) = template.as_mapping_mut() {
+                mapping.insert(
+                    serde_yaml::Value::String("network".to_string()),
+                    serde_yaml::Value::String(network.to_string()),
+                );
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Update a single data source with network configuration.
+fn update_data_source(
+    ds: &mut serde_yaml::Value,
+    network: &str,
+    network_config: &NetworkConfig,
+) -> Result<()> {
+    // Get data source name
+    let ds_name = ds
+        .get("name")
+        .and_then(|n| n.as_str())
+        .ok_or_else(|| anyhow!("Data source missing 'name' field"))?
+        .to_string();
+
+    // Look up config for this data source
+    let ds_config = network_config.get(&ds_name).ok_or_else(|| {
+        anyhow!(
+            "'{}' was not found in the '{}' network configuration",
+            ds_name,
+            network
+        )
+    })?;
+
+    // Update network field
+    if let Some(mapping) = ds.as_mapping_mut() {
+        mapping.insert(
+            serde_yaml::Value::String("network".to_string()),
+            serde_yaml::Value::String(network.to_string()),
+        );
+    }
+
+    // Update source section
+    if let Some(source) = ds.get_mut("source") {
+        // Preserve existing ABI reference if present
+        let abi = source.get("abi").cloned();
+
+        // Clear and rebuild source
+        if let Some(mapping) = source.as_mapping_mut() {
+            mapping.clear();
+
+            // Restore ABI if it existed
+            if let Some(abi_value) = abi {
+                mapping.insert(serde_yaml::Value::String("abi".to_string()), abi_value);
+            }
+
+            // Add address if configured
+            if let Some(address) = &ds_config.address {
+                mapping.insert(
+                    serde_yaml::Value::String("address".to_string()),
+                    serde_yaml::Value::String(address.clone()),
+                );
+            }
+
+            // Add start block if configured
+            if let Some(start_block) = ds_config.start_block {
+                mapping.insert(
+                    serde_yaml::Value::String("startBlock".to_string()),
+                    serde_yaml::Value::Number(start_block.into()),
+                );
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Initialize a networks.json file from an existing manifest.
+///
+/// Creates a networks.json with the current network configuration
+/// extracted from the manifest's data sources.
+///
+/// # Arguments
+/// * `manifest_path` - Path to the subgraph.yaml manifest
+/// * `output_path` - Path to write the networks.json file
+pub fn init_networks_config(manifest_path: &Path, output_path: &Path) -> Result<()> {
+    let content = fs::read_to_string(manifest_path)
+        .with_context(|| format!("Failed to read manifest from {}", manifest_path.display()))?;
+
+    let manifest: serde_yaml::Value = serde_yaml::from_str(&content)
+        .with_context(|| format!("Failed to parse manifest from {}", manifest_path.display()))?;
+
+    let mut networks_config: NetworksConfig = HashMap::new();
+
+    // Extract configuration from data sources
+    if let Some(data_sources) = manifest.get("dataSources").and_then(|ds| ds.as_sequence()) {
+        for ds in data_sources {
+            let name = ds.get("name").and_then(|n| n.as_str()).unwrap_or("unknown");
+            let network = ds
+                .get("network")
+                .and_then(|n| n.as_str())
+                .unwrap_or("mainnet");
+
+            let address = ds
+                .get("source")
+                .and_then(|s| s.get("address"))
+                .and_then(|a| a.as_str())
+                .map(String::from);
+
+            let start_block = ds
+                .get("source")
+                .and_then(|s| s.get("startBlock"))
+                .and_then(|b| b.as_u64());
+
+            let ds_config = DataSourceNetworkConfig {
+                address,
+                start_block,
+            };
+
+            networks_config
+                .entry(network.to_string())
+                .or_default()
+                .insert(name.to_string(), ds_config);
+        }
+    }
+
+    // Write the networks.json file
+    let json = serde_json::to_string_pretty(&networks_config)
+        .context("Failed to serialize networks config")?;
+
+    fs::write(output_path, json).with_context(|| {
+        format!(
+            "Failed to write networks config to {}",
+            output_path.display()
+        )
+    })?;
+
+    Ok(())
+}
+
+/// Update the networks.json file with a new data source entry.
+///
+/// # Arguments
+/// * `networks_path` - Path to the networks.json file
+/// * `network` - Network name
+/// * `data_source` - Data source name
+/// * `address` - Contract address
+/// * `start_block` - Optional start block
+pub fn update_networks_file(
+    networks_path: &Path,
+    network: &str,
+    data_source: &str,
+    address: &str,
+    start_block: Option<u64>,
+) -> Result<()> {
+    // Load existing config or create new
+    let mut config: NetworksConfig = if networks_path.exists() {
+        load_networks_config(networks_path)?
+    } else {
+        HashMap::new()
+    };
+
+    // Update or create entry
+    let ds_config = DataSourceNetworkConfig {
+        address: Some(address.to_string()),
+        start_block,
+    };
+
+    config
+        .entry(network.to_string())
+        .or_default()
+        .insert(data_source.to_string(), ds_config);
+
+    // Write back
+    let json =
+        serde_json::to_string_pretty(&config).context("Failed to serialize networks config")?;
+
+    fs::write(networks_path, json).with_context(|| {
+        format!(
+            "Failed to write networks config to {}",
+            networks_path.display()
+        )
+    })?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_load_networks_config() {
+        let temp_dir = TempDir::new().unwrap();
+        let path = temp_dir.path().join("networks.json");
+
+        let config = r#"{
+            "mainnet": {
+                "Token": {
+                    "address": "0x1234567890123456789012345678901234567890",
+                    "startBlock": 12345678
+                }
+            },
+            "goerli": {
+                "Token": {
+                    "address": "0x0987654321098765432109876543210987654321",
+                    "startBlock": 100
+                }
+            }
+        }"#;
+
+        fs::write(&path, config).unwrap();
+
+        let loaded = load_networks_config(&path).unwrap();
+
+        assert!(loaded.contains_key("mainnet"));
+        assert!(loaded.contains_key("goerli"));
+
+        let mainnet = &loaded["mainnet"];
+        let token = &mainnet["Token"];
+        assert_eq!(
+            token.address,
+            Some("0x1234567890123456789012345678901234567890".to_string())
+        );
+        assert_eq!(token.start_block, Some(12345678));
+    }
+
+    #[test]
+    fn test_load_networks_config_missing_optional_fields() {
+        let temp_dir = TempDir::new().unwrap();
+        let path = temp_dir.path().join("networks.json");
+
+        let config = r#"{
+            "mainnet": {
+                "Token": {
+                    "address": "0x1234567890123456789012345678901234567890"
+                }
+            }
+        }"#;
+
+        fs::write(&path, config).unwrap();
+
+        let loaded = load_networks_config(&path).unwrap();
+        let token = &loaded["mainnet"]["Token"];
+
+        assert_eq!(
+            token.address,
+            Some("0x1234567890123456789012345678901234567890".to_string())
+        );
+        assert_eq!(token.start_block, None);
+    }
+
+    #[test]
+    fn test_get_network_config() {
+        let mut config = NetworksConfig::new();
+        let mut mainnet = NetworkConfig::new();
+        mainnet.insert(
+            "Token".to_string(),
+            DataSourceNetworkConfig {
+                address: Some("0x123".to_string()),
+                start_block: Some(100),
+            },
+        );
+        config.insert("mainnet".to_string(), mainnet);
+
+        assert!(get_network_config(&config, "mainnet").is_ok());
+        assert!(get_network_config(&config, "goerli").is_err());
+    }
+
+    #[test]
+    fn test_apply_network_config() {
+        let manifest_yaml = r#"
+specVersion: 0.0.4
+dataSources:
+  - kind: ethereum/contract
+    name: Token
+    network: mainnet
+    source:
+      abi: ERC20
+      address: "0x0000000000000000000000000000000000000000"
+      startBlock: 0
+    mapping:
+      kind: ethereum/events
+      file: ./src/mapping.ts
+templates:
+  - kind: ethereum/contract
+    name: DynamicToken
+    network: mainnet
+"#;
+
+        let mut manifest: serde_yaml::Value = serde_yaml::from_str(manifest_yaml).unwrap();
+
+        let mut network_config = NetworkConfig::new();
+        network_config.insert(
+            "Token".to_string(),
+            DataSourceNetworkConfig {
+                address: Some("0x1234567890123456789012345678901234567890".to_string()),
+                start_block: Some(12345678),
+            },
+        );
+
+        apply_network_config(&mut manifest, "goerli", &network_config).unwrap();
+
+        // Check data source was updated
+        let ds = &manifest["dataSources"][0];
+        assert_eq!(ds["network"].as_str(), Some("goerli"));
+        assert_eq!(
+            ds["source"]["address"].as_str(),
+            Some("0x1234567890123456789012345678901234567890")
+        );
+        assert_eq!(ds["source"]["startBlock"].as_u64(), Some(12345678));
+        // ABI should be preserved
+        assert_eq!(ds["source"]["abi"].as_str(), Some("ERC20"));
+
+        // Check template was updated
+        let template = &manifest["templates"][0];
+        assert_eq!(template["network"].as_str(), Some("goerli"));
+    }
+
+    #[test]
+    fn test_apply_network_config_missing_data_source() {
+        let manifest_yaml = r#"
+specVersion: 0.0.4
+dataSources:
+  - kind: ethereum/contract
+    name: Token
+    network: mainnet
+    source:
+      address: "0x0000000000000000000000000000000000000000"
+"#;
+
+        let mut manifest: serde_yaml::Value = serde_yaml::from_str(manifest_yaml).unwrap();
+
+        // Network config with different data source name
+        let mut network_config = NetworkConfig::new();
+        network_config.insert(
+            "OtherContract".to_string(),
+            DataSourceNetworkConfig {
+                address: Some("0x123".to_string()),
+                start_block: None,
+            },
+        );
+
+        let result = apply_network_config(&mut manifest, "goerli", &network_config);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("Token"));
+    }
+
+    #[test]
+    fn test_init_networks_config() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest_path = temp_dir.path().join("subgraph.yaml");
+        let networks_path = temp_dir.path().join("networks.json");
+
+        let manifest = r#"
+specVersion: 0.0.4
+dataSources:
+  - kind: ethereum/contract
+    name: Token
+    network: mainnet
+    source:
+      address: "0x1234567890123456789012345678901234567890"
+      startBlock: 12345678
+  - kind: ethereum/contract
+    name: Factory
+    network: mainnet
+    source:
+      address: "0xabcdef0123456789abcdef0123456789abcdef01"
+      startBlock: 12340000
+"#;
+
+        fs::write(&manifest_path, manifest).unwrap();
+        init_networks_config(&manifest_path, &networks_path).unwrap();
+
+        let loaded = load_networks_config(&networks_path).unwrap();
+        assert!(loaded.contains_key("mainnet"));
+
+        let mainnet = &loaded["mainnet"];
+        assert!(mainnet.contains_key("Token"));
+        assert!(mainnet.contains_key("Factory"));
+
+        let token = &mainnet["Token"];
+        assert_eq!(
+            token.address,
+            Some("0x1234567890123456789012345678901234567890".to_string())
+        );
+        assert_eq!(token.start_block, Some(12345678));
+    }
+
+    #[test]
+    fn test_update_networks_file_new() {
+        let temp_dir = TempDir::new().unwrap();
+        let networks_path = temp_dir.path().join("networks.json");
+
+        update_networks_file(
+            &networks_path,
+            "mainnet",
+            "Token",
+            "0x1234567890123456789012345678901234567890",
+            Some(100),
+        )
+        .unwrap();
+
+        let loaded = load_networks_config(&networks_path).unwrap();
+        let token = &loaded["mainnet"]["Token"];
+        assert_eq!(
+            token.address,
+            Some("0x1234567890123456789012345678901234567890".to_string())
+        );
+        assert_eq!(token.start_block, Some(100));
+    }
+
+    #[test]
+    fn test_update_networks_file_existing() {
+        let temp_dir = TempDir::new().unwrap();
+        let networks_path = temp_dir.path().join("networks.json");
+
+        // Create initial config
+        let initial = r#"{
+            "mainnet": {
+                "Token": {
+                    "address": "0x0000000000000000000000000000000000000000"
+                }
+            }
+        }"#;
+        fs::write(&networks_path, initial).unwrap();
+
+        // Update with new data source
+        update_networks_file(
+            &networks_path,
+            "mainnet",
+            "Factory",
+            "0x1111111111111111111111111111111111111111",
+            None,
+        )
+        .unwrap();
+
+        let loaded = load_networks_config(&networks_path).unwrap();
+        assert!(loaded["mainnet"].contains_key("Token"));
+        assert!(loaded["mainnet"].contains_key("Factory"));
+    }
+}
diff --git a/gnd/src/formatter.rs b/gnd/src/formatter.rs
new file mode 100644
index 00000000000..58947e15519
--- /dev/null
+++ b/gnd/src/formatter.rs
@@ -0,0 +1,152 @@
+//! Code formatting utilities.
+//!
+//! This module provides formatting for generated TypeScript/AssemblyScript code
+//! using Prettier.
+
+use std::io::Write;
+use std::process::{Command, Stdio};
+
+use anyhow::{Context, Result, bail};
+
+/// Format TypeScript/AssemblyScript code using Prettier.
+///
+/// Returns the formatted code, or an error if formatting fails.
+/// Use `try_format_typescript` for graceful fallback.
+pub fn format_typescript(code: &str) -> Result<String> {
+    format_with_prettier(code, "typescript")
+}
+
+/// Format TypeScript/AssemblyScript code using Prettier.
+///
+/// If Prettier is not available or fails, the code is returned unformatted.
+pub fn try_format_typescript(code: &str) -> String {
+    match format_with_prettier(code, "typescript") {
+        Ok(formatted) => formatted,
+        Err(_) => code.to_string(),
+    }
+}
+
+/// Format code using Prettier with the specified parser.
+fn format_with_prettier(code: &str, parser: &str) -> Result<String> {
+    // Try npx prettier first (most common setup)
+    let result = run_prettier_command(code, parser, "npx", &["prettier", "--stdin-filepath"]);
+    if result.is_ok() {
+        return result;
+    }
+
+    // Try pnpx prettier
+    let result = run_prettier_command(code, parser, "pnpx", &["prettier", "--stdin-filepath"]);
+    if result.is_ok() {
+        return result;
+    }
+
+    // Try global prettier installation
+    run_prettier_command(code, parser, "prettier", &["--stdin-filepath"])
+}
+
+/// Run prettier command with the given program and arguments.
+fn run_prettier_command(code: &str, parser: &str, program: &str, args: &[&str]) -> Result<String> {
+    // Build command with stdin-filepath to hint the parser
+    let filepath = format!("file.{}", parser_to_extension(parser));
+
+    let mut cmd = Command::new(program);
+    for arg in args {
+        cmd.arg(arg);
+    }
+    cmd.arg(&filepath);
+
+    cmd.stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+
+    let mut child = cmd.spawn().context("Failed to spawn prettier process")?;
+
+    // Write code to stdin
+    if let Some(mut stdin) = child.stdin.take() {
+        stdin
+            .write_all(code.as_bytes())
+            .context("Failed to write to prettier stdin")?;
+    }
+
+    let output = child
+        .wait_with_output()
+        .context("Failed to read prettier output")?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!("Prettier failed: {}", stderr);
+    }
+
+    String::from_utf8(output.stdout).context("Prettier output is not valid UTF-8")
+}
+
+/// Convert parser name to file extension.
+fn parser_to_extension(parser: &str) -> &str {
+    match parser {
+        "typescript" => "ts",
+        "json" => "json",
+        "yaml" => "yaml",
+        _ => "ts",
+    }
+}
+
+/// Check if Prettier is available on the system.
+pub fn is_prettier_available() -> bool {
+    // Check npx
+    if Command::new("npx")
+        .args(["prettier", "--version"])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false)
+    {
+        return true;
+    }
+
+    // Check pnpx
+    if Command::new("pnpx")
+        .args(["prettier", "--version"])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false)
+    {
+        return true;
+    }
+
+    // Check global prettier
+    Command::new("prettier")
+        .arg("--version")
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parser_to_extension() {
+        assert_eq!(parser_to_extension("typescript"), "ts");
+        assert_eq!(parser_to_extension("json"), "json");
+        assert_eq!(parser_to_extension("yaml"), "yaml");
+        assert_eq!(parser_to_extension("unknown"), "ts");
+    }
+
+    #[test]
+    fn test_format_typescript_graceful_fallback() {
+        // Even if prettier is not installed, format_typescript should return
+        // the original code without error
+        let code = "export class Foo { }";
+        let result = format_typescript(code);
+        assert!(result.is_ok());
+        // Result should either be formatted or the original code
+        let formatted = result.unwrap();
+        assert!(formatted.contains("class Foo") || formatted.contains("Foo"));
+    }
+}
diff --git a/gnd/src/lib.rs b/gnd/src/lib.rs
new file mode 100644
index 00000000000..ba5ba2c1147
--- /dev/null
+++ b/gnd/src/lib.rs
@@ -0,0 +1,16 @@
+pub mod abi;
+pub mod codegen;
+pub mod commands;
+pub mod compiler;
+pub mod config;
+pub mod formatter;
+pub mod manifest;
+pub mod migrations;
+pub mod output;
+pub mod prompt;
+pub mod scaffold;
+pub mod services;
+pub mod shared;
+pub mod validation;
+pub mod watch;
+pub mod watcher;
diff --git a/gnd/src/main.rs b/gnd/src/main.rs
new file mode 100644
index 00000000000..092674e5da0
--- /dev/null
+++ b/gnd/src/main.rs
@@ -0,0 +1,271 @@
+use std::ffi::OsString;
+use std::io;
+use std::process::Command;
+
+use anyhow::{Result, bail};
+use clap::{CommandFactory, Parser, Subcommand, ValueEnum};
+use clap_complete::{Shell, generate};
+use git_testament::{git_testament, render_testament};
+use graph::log::logger;
+use lazy_static::lazy_static;
+use tokio_util::sync::CancellationToken;
+
+use gnd::commands::{
+    AddOpt, AuthOpt, BuildOpt, CleanOpt, CodegenOpt, CreateOpt, DeployOpt, DevOpt, InitOpt,
+    PublishOpt, RemoveOpt, TestOpt, run_add, run_auth, run_build, run_clean, run_codegen,
+    run_create, run_deploy, run_dev, run_init, run_publish, run_remove, run_test,
+};
+
+git_testament!(TESTAMENT);
+lazy_static! {
+    static ref RENDERED_TESTAMENT: String = render_testament!(TESTAMENT);
+    static ref VERSION_STRING: String = format!(
+        "{} (graph-cli compatible: {})",
+        RENDERED_TESTAMENT.as_str(),
+        GRAPH_CLI_COMPAT_VERSION
+    );
+    static ref LONG_VERSION_STRING: String = format!(
+        "{}\ngraph-cli compatibility version: {}",
+        RENDERED_TESTAMENT.as_str(),
+        GRAPH_CLI_COMPAT_VERSION
+    );
+}
+
+/// The version of graph-cli that gnd emulates
+const GRAPH_CLI_COMPAT_VERSION: &str = "0.98.1";
+
+#[derive(Parser)]
+#[clap(
+    name = "gnd",
+    about = "Graph Node Dev - A drop-in replacement for graph-cli",
+    author = "Graph Protocol, Inc.",
+    version = VERSION_STRING.as_str(),
+    long_version = LONG_VERSION_STRING.as_str(),
+)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Run graph-node in dev mode
+    Dev(DevOpt),
+
+    /// Generate AssemblyScript types from subgraph manifest
+    Codegen(CodegenOpt),
+
+    /// Compile subgraph to WASM
+    Build(BuildOpt),
+
+    /// Deploy subgraph to a Graph Node
+    Deploy(DeployOpt),
+
+    /// Scaffold a new subgraph project
+    Init(InitOpt),
+
+    /// Add a datasource to an existing subgraph
+    Add(AddOpt),
+
+    /// Register a subgraph name with a Graph Node
+    Create(CreateOpt),
+
+    /// Unregister a subgraph name from a Graph Node
+    Remove(RemoveOpt),
+
+    /// Set the deploy key for a Graph Node
+    Auth(AuthOpt),
+
+    /// Publish subgraph to The Graph's decentralized network
+    Publish(PublishOpt),
+
+    /// Run Matchstick tests
+    Test(TestOpt),
+
+    /// Remove build artifacts and generated files
+    Clean(CleanOpt),
+
+    /// Manage indexer operations. Requires `graph-indexer` to be installed and available on $PATH.
+    ///
+    /// Install it with:
+    ///
+    ///   npm install -g @graphprotocol/indexer-cli
+    ///
+    /// Arguments are forwarded to `graph-indexer`. For example:
+    ///
+    ///   gnd indexer allocations get --network arbitrum-one
+    ///
+    /// Use `gnd indexer help` for more details on available commands.
+    Indexer {
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<OsString>,
+    },
+
+    /// Generate shell completions
+    Completions(CompletionsOpt),
+}
+
+/// Options for shell completion generation.
+#[derive(Parser, Debug)]
+pub struct CompletionsOpt {
+    /// Shell to generate completions for
+    #[clap(value_enum)]
+    pub shell: CompletionShell,
+}
+
+/// Supported shells for completion generation.
+#[derive(Copy, Clone, Debug, ValueEnum)]
+pub enum CompletionShell {
+    Bash,
+    Elvish,
+    Fish,
+    PowerShell,
+    Zsh,
+}
+
+fn shutdown_token() -> CancellationToken {
+    use tokio::signal;
+
+    let cancel_token = CancellationToken::new();
+    let cancel_token_clone = cancel_token.clone();
+
+    async fn shutdown_signal_handler() {
+        let ctrl_c = async {
+            signal::ctrl_c().await.unwrap();
+        };
+
+        #[cfg(unix)]
+        let terminate = async {
+            signal::unix::signal(signal::unix::SignalKind::terminate())
+                .unwrap()
+                .recv()
+                .await;
+        };
+
+        #[cfg(not(unix))]
+        let terminate = std::future::pending::<()>();
+
+        tokio::select! {
+            _ = ctrl_c => {},
+            _ = terminate => {},
+        };
+    }
+
+    tokio::spawn(async move {
+        shutdown_signal_handler().await;
+        cancel_token_clone.cancel();
+    });
+
+    cancel_token
+}
+
+fn generate_completions(completions_opt: CompletionsOpt) -> Result<()> {
+    let shell = match completions_opt.shell {
+        CompletionShell::Bash => Shell::Bash,
+        CompletionShell::Elvish => Shell::Elvish,
+        CompletionShell::Fish => Shell::Fish,
+        CompletionShell::PowerShell => Shell::PowerShell,
+        CompletionShell::Zsh => Shell::Zsh,
+    };
+    generate(shell, &mut Cli::command(), "gnd", &mut io::stdout());
+    Ok(())
+}
+
+/// Delegates to the `graph-indexer` binary from the `indexer-cli` npm package.
+///
+/// The `graph-indexer` CLI expects all indexer management commands to be
+/// prefixed with `indexer` (e.g. `graph-indexer indexer allocations get ...`).
+/// This is because `graph-indexer` uses Gluegun's plugin system where `indexer`
+/// is the plugin namespace. We prepend it automatically so that users can write
+/// `gnd indexer allocations get` instead of the longer form.
+fn run_indexer(args: Vec<OsString>) -> Result<()> {
+    let mut cmd = Command::new("graph-indexer");
+    // `version` and `help` are top-level commands, but all other commands
+    // require the `indexer` namespace prefix (e.g. `graph-indexer indexer allocations get`).
+    let first = args.first().and_then(|s| s.to_str());
+    match first {
+        Some("version" | "--version" | "v" | "-v" | "help" | "h") => {}
+        // If no arguments are provided, default to showing top-level help
+        None => {
+            cmd.arg("help");
+        }
+        _ => {
+            cmd.arg("indexer");
+        }
+    }
+    cmd.args(&args);
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::process::CommandExt;
+        let err = cmd.exec();
+        if err.kind() == io::ErrorKind::NotFound {
+            bail!(
+                "'graph-indexer' not found on $PATH. Install indexer-cli: npm install -g @graphprotocol/indexer-cli"
+            );
+        }
+        bail!("failed to exec 'graph-indexer': {err}");
+    }
+
+    #[cfg(not(unix))]
+    {
+        match cmd.status() {
+            Ok(status) if status.success() => Ok(()),
+            Ok(status) => std::process::exit(status.code().unwrap_or(1)),
+            Err(e) if e.kind() == io::ErrorKind::NotFound => {
+                bail!(
+                    "'graph-indexer' not found on $PATH. Install indexer-cli: npm install -g @graphprotocol/indexer-cli"
+                );
+            }
+            Err(e) => bail!("failed to run 'graph-indexer': {e}"),
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    graph::tls::install_default_crypto_provider();
+    unsafe {
+        std::env::set_var("ETHEREUM_REORG_THRESHOLD", "10");
+        std::env::set_var("GRAPH_NODE_DISABLE_DEPLOYMENT_HASH_VALIDATION", "true");
+    }
+    env_logger::init();
+
+    let cli = Cli::parse();
+    let logger = logger(true);
+    let cancel_token = shutdown_token();
+
+    let res = match cli.command {
+        Commands::Dev(dev_opt) => {
+            run_dev(dev_opt, logger, cancel_token).await?;
+            Ok(())
+        }
+        Commands::Codegen(codegen_opt) => run_codegen(codegen_opt).await,
+        Commands::Build(build_opt) => run_build(build_opt).await.map(|_| ()),
+        Commands::Deploy(deploy_opt) => run_deploy(deploy_opt).await,
+        Commands::Init(init_opt) => run_init(init_opt).await,
+        Commands::Add(add_opt) => run_add(add_opt).await,
+        Commands::Create(create_opt) => run_create(create_opt).await,
+        Commands::Remove(remove_opt) => run_remove(remove_opt).await,
+        Commands::Auth(auth_opt) => run_auth(auth_opt),
+        Commands::Publish(publish_opt) => run_publish(publish_opt).await,
+        Commands::Test(test_opt) => {
+            // Disable RPC retries so unmocked calls fail immediately.
+            // SAFETY: single-threaded here, before the Tokio runtime is built.
+            unsafe {
+                std::env::set_var("GRAPH_ETHEREUM_REQUEST_RETRIES", "1");
+            }
+            run_test(test_opt).await
+        }
+        Commands::Clean(clean_opt) => run_clean(clean_opt),
+        Commands::Indexer { args } => run_indexer(args),
+        Commands::Completions(completions_opt) => generate_completions(completions_opt),
+    };
+
+    if let Err(e) = res {
+        eprintln!("Error: {}", e);
+        std::process::exit(1);
+    }
+
+    Ok(())
+}
diff --git a/gnd/src/manifest.rs b/gnd/src/manifest.rs
new file mode 100644
index 00000000000..0221070edfe
--- /dev/null
+++ b/gnd/src/manifest.rs
@@ -0,0 +1,736 @@
+//! Shared manifest types and parsing for gnd commands.
+//!
+//! This module provides unified manifest loading and types used by build,
+//! codegen, and validation commands. Manifest parsing uses graph-node's
+//! `UnresolvedSubgraphManifest` types which enforce required fields via serde
+//! (e.g. `source.abi`, `mapping.abis`).
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result};
+use graph::data::subgraph::UnresolvedSubgraphManifest;
+use graph::data_source::{
+    UnresolvedDataSource as GraphUnresolvedDS, UnresolvedDataSourceTemplate as GraphUnresolvedDST,
+};
+use graph::prelude::DeploymentHash;
+use graph_chain_ethereum::{BlockHandlerFilter, Chain};
+use semver::Version;
+
+use crate::output::{Step, step};
+
+/// Type alias for the graph-node unresolved manifest parameterized on Ethereum.
+type GraphManifest = UnresolvedSubgraphManifest<Chain>;
+
+/// A simplified subgraph manifest structure.
+///
+/// This unified struct contains all fields needed by build, codegen, and
+/// validation. Commands use only the fields they need.
+///
+/// Parsing uses graph-node's `UnresolvedSubgraphManifest::parse()` which
+/// enforces required fields via serde (e.g. `source.abi`, `mapping.abis`
+/// for Ethereum data sources).
+///
+/// # Data Source Organization
+///
+/// All data sources from the manifest are stored in the `data_sources` field,
+/// regardless of their kind. Subgraph data sources (kind: subgraph) are
+/// identified by `DataSource::is_subgraph_source()` and have the `source_address`
+/// field set to the IPFS deployment ID of the referenced subgraph.
+#[derive(Debug)]
+pub struct Manifest {
+    pub spec_version: Version,
+    pub schema: Option<String>,
+    pub features: Vec<String>,
+    pub graft: Option<GraftConfig>,
+    /// All data sources, including both contract-style sources and subgraph sources.
+    pub data_sources: Vec<DataSource>,
+    pub templates: Vec<Template>,
+}
+
+/// Graft configuration.
+#[derive(Debug)]
+pub struct GraftConfig {
+    pub base: String,
+    pub block: u64,
+}
+
+/// A data source in the manifest.
+#[derive(Debug)]
+pub struct DataSource {
+    pub name: String,
+    pub kind: String,
+    pub network: Option<String>,
+    pub mapping_file: Option<String>,
+    pub api_version: Option<Version>,
+    pub abis: Vec<Abi>,
+    /// For subgraph data sources: the IPFS deployment ID of the referenced subgraph.
+    pub source_address: Option<String>,
+    /// The ABI name referenced in `source.abi` (Ethereum data sources only).
+    pub source_abi: Option<String>,
+    /// The block number at which this data source starts indexing (from source.startBlock).
+    pub start_block: u64,
+    /// The block number at which this data source stops indexing (from source.endBlock).
+    pub end_block: Option<u64>,
+    /// Event handlers from the mapping.
+    pub event_handlers: Vec<EventHandler>,
+    /// Call handlers from the mapping.
+    pub call_handlers: Vec<CallHandler>,
+    /// Block handlers from the mapping (with filter info for validation).
+    pub block_handlers: Vec<BlockHandler>,
+}
+
+impl DataSource {
+    /// Returns true if this is a valid subgraph data source (kind: subgraph with address).
+    pub fn is_subgraph_source(&self) -> bool {
+        self.kind == "subgraph" && self.source_address.is_some()
+    }
+}
+
+/// A data source template in the manifest.
+#[derive(Debug)]
+pub struct Template {
+    pub name: String,
+    pub kind: String,
+    pub network: Option<String>,
+    pub mapping_file: Option<String>,
+    pub api_version: Option<Version>,
+    pub abis: Vec<Abi>,
+    /// The ABI name referenced in `source.abi` (Ethereum templates only).
+    pub source_abi: Option<String>,
+    /// Event handlers from the mapping.
+    pub event_handlers: Vec<EventHandler>,
+    /// Call handlers from the mapping.
+    pub call_handlers: Vec<CallHandler>,
+    /// Block handlers from the mapping (with filter info for validation).
+    pub block_handlers: Vec<BlockHandler>,
+}
+
+impl Manifest {
+    /// Returns the total count of all data sources.
+    pub fn total_source_count(&self) -> usize {
+        self.data_sources.len()
+    }
+}
+
+/// An ABI reference in a data source or template.
+#[derive(Debug)]
+pub struct Abi {
+    pub name: String,
+    pub file: String,
+}
+
+/// An event handler with metadata needed for validation.
+#[derive(Debug)]
+pub struct EventHandler {
+    /// The Solidity event signature, e.g. `Transfer(address,address,uint256)`.
+    pub event: String,
+    pub handler: String,
+    /// Whether this handler requires transaction receipts.
+    pub receipt: bool,
+    /// Whether this handler has eth call declarations.
+    pub has_call_decls: bool,
+}
+
+/// A call handler with metadata needed for validation.
+#[derive(Debug)]
+pub struct CallHandler {
+    /// The Solidity function signature, e.g. `approve(address,uint256)`.
+    pub function: String,
+    pub handler: String,
+}
+
+/// A block handler with filter info needed for validation.
+#[derive(Debug)]
+pub struct BlockHandler {
+    pub handler: String,
+    pub filter: Option<BlockHandlerFilterKind>,
+}
+
+/// The kind of filter on a block handler (simplified from graph-node's `BlockHandlerFilter`).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BlockHandlerFilterKind {
+    Call,
+    Once,
+    Polling,
+}
+
+/// Load a subgraph manifest from a YAML file.
+///
+/// This uses graph-node's `UnresolvedSubgraphManifest::parse()` which
+/// enforces all required fields via serde deserialization. Missing required
+/// fields (e.g. `source.abi`, `mapping.abis`) produce clear parse errors.
+pub fn load_manifest(path: &Path) -> Result<Manifest> {
+    step(
+        Step::Load,
+        &format!("Load subgraph from {}", path.display()),
+    );
+
+    let manifest_str =
+        fs::read_to_string(path).with_context(|| format!("Failed to read manifest: {:?}", path))?;
+
+    let raw: serde_yaml::Mapping = serde_yaml::from_str(&manifest_str)
+        .with_context(|| format!("Failed to parse manifest YAML: {:?}", path))?;
+
+    // Use a dummy deployment hash for local CLI use
+    let id = DeploymentHash::new("QmLocalDev").unwrap();
+
+    let parsed: GraphManifest = GraphManifest::parse(id, raw)
+        .with_context(|| format!("Failed to parse manifest: {:?}", path))?;
+
+    Ok(convert_manifest(parsed))
+}
+
+/// Convert a graph-node `UnresolvedSubgraphManifest` into gnd's `Manifest`.
+fn convert_manifest(m: GraphManifest) -> Manifest {
+    let spec_version = m.spec_version;
+
+    let schema = m.schema.map(|s| s.file.link);
+
+    let features = m.features.into_iter().map(|f| f.to_string()).collect();
+
+    let graft = m.graft.map(|g| GraftConfig {
+        base: g.base.to_string(),
+        block: g.block.max(0) as u64,
+    });
+
+    let data_sources = m
+        .data_sources
+        .into_iter()
+        .map(convert_data_source)
+        .collect();
+
+    let templates = m.templates.into_iter().map(convert_template).collect();
+
+    Manifest {
+        spec_version,
+        schema,
+        features,
+        graft,
+        data_sources,
+        templates,
+    }
+}
+
+/// Convert a graph-node `UnresolvedDataSource` enum into gnd's `DataSource`.
+fn convert_data_source(ds: GraphUnresolvedDS<Chain>) -> DataSource {
+    match ds {
+        GraphUnresolvedDS::Onchain(eth) => DataSource {
+            name: eth.name.clone(),
+            kind: eth.kind.clone(),
+            network: eth.network.clone(),
+            mapping_file: Some(eth.mapping.file.link.clone()),
+            api_version: Version::parse(&eth.mapping.api_version).ok(),
+            abis: eth
+                .mapping
+                .abis
+                .iter()
+                .map(|a| Abi {
+                    name: a.name.clone(),
+                    file: a.file.link.clone(),
+                })
+                .collect(),
+            source_address: eth.source.address.map(|a| format!("{:?}", a)),
+            source_abi: Some(eth.source.abi.clone()),
+            start_block: eth.source.start_block as u64,
+            end_block: eth.source.end_block.map(|b| b as u64),
+            event_handlers: eth
+                .mapping
+                .event_handlers
+                .iter()
+                .map(|h| EventHandler {
+                    event: h.event.clone(),
+                    handler: h.handler.clone(),
+                    receipt: h.receipt,
+                    has_call_decls: !h.calls.raw_decls.is_empty(),
+                })
+                .collect(),
+            call_handlers: eth
+                .mapping
+                .call_handlers
+                .iter()
+                .map(|h| CallHandler {
+                    function: h.function.clone(),
+                    handler: h.handler.clone(),
+                })
+                .collect(),
+            block_handlers: eth
+                .mapping
+                .block_handlers
+                .iter()
+                .map(|h| BlockHandler {
+                    handler: h.handler.clone(),
+                    filter: h.filter.as_ref().map(convert_block_handler_filter),
+                })
+                .collect(),
+        },
+        GraphUnresolvedDS::Subgraph(sub) => DataSource {
+            name: sub.name.clone(),
+            kind: sub.kind.clone(),
+            network: Some(sub.network.clone()),
+            mapping_file: Some(sub.mapping.file.link.clone()),
+            api_version: Version::parse(&sub.mapping.api_version).ok(),
+            abis: sub
+                .mapping
+                .abis
+                .as_deref()
+                .unwrap_or(&[])
+                .iter()
+                .map(|a| Abi {
+                    name: a.name.clone(),
+                    file: a.file.link.clone(),
+                })
+                .collect(),
+            source_address: Some(sub.source.address().to_string()),
+            source_abi: None,
+            start_block: sub.source.start_block() as u64,
+            end_block: None, // Subgraph sources don't have end_block
+            event_handlers: vec![],
+            call_handlers: vec![],
+            block_handlers: vec![],
+        },
+        GraphUnresolvedDS::Offchain(off) => DataSource {
+            name: off.name.clone(),
+            kind: off.kind.clone(),
+            network: None,
+            mapping_file: Some(off.mapping.file.link.clone()),
+            api_version: Version::parse(&off.mapping.api_version).ok(),
+            abis: vec![],
+            source_address: None,
+            source_abi: None,
+            start_block: 0, // Offchain data sources don't have start_block
+            end_block: None,
+            event_handlers: vec![],
+            call_handlers: vec![],
+            block_handlers: vec![],
+        },
+        GraphUnresolvedDS::Amp(amp) => DataSource {
+            name: amp.name.clone(),
+            kind: amp.kind.clone(),
+            network: Some(amp.network.clone()),
+            mapping_file: None,
+            api_version: None,
+            abis: vec![],
+            source_address: None,
+            source_abi: None,
+            start_block: amp.source.start_block.unwrap_or(0),
+            end_block: amp.source.end_block,
+            event_handlers: vec![],
+            call_handlers: vec![],
+            block_handlers: vec![],
+        },
+    }
+}
+
+/// Convert a graph-node `UnresolvedDataSourceTemplate` enum into gnd's `Template`.
+fn convert_template(t: GraphUnresolvedDST<Chain>) -> Template {
+    match t {
+        GraphUnresolvedDST::Onchain(eth) => Template {
+            name: eth.name.clone(),
+            kind: eth.kind.clone(),
+            network: eth.network.clone(),
+            mapping_file: Some(eth.mapping.file.link.clone()),
+            api_version: Version::parse(&eth.mapping.api_version).ok(),
+            abis: eth
+                .mapping
+                .abis
+                .iter()
+                .map(|a| Abi {
+                    name: a.name.clone(),
+                    file: a.file.link.clone(),
+                })
+                .collect(),
+            source_abi: Some(eth.source.abi.clone()),
+            event_handlers: eth
+                .mapping
+                .event_handlers
+                .iter()
+                .map(|h| EventHandler {
+                    event: h.event.clone(),
+                    handler: h.handler.clone(),
+                    receipt: h.receipt,
+                    has_call_decls: !h.calls.raw_decls.is_empty(),
+                })
+                .collect(),
+            call_handlers: eth
+                .mapping
+                .call_handlers
+                .iter()
+                .map(|h| CallHandler {
+                    function: h.function.clone(),
+                    handler: h.handler.clone(),
+                })
+                .collect(),
+            block_handlers: eth
+                .mapping
+                .block_handlers
+                .iter()
+                .map(|h| BlockHandler {
+                    handler: h.handler.clone(),
+                    filter: h.filter.as_ref().map(convert_block_handler_filter),
+                })
+                .collect(),
+        },
+        GraphUnresolvedDST::Offchain(off) => Template {
+            name: off.name.clone(),
+            kind: off.kind.clone(),
+            network: off.network.clone(),
+            mapping_file: Some(off.mapping.file.link.clone()),
+            api_version: Version::parse(&off.mapping.api_version).ok(),
+            abis: vec![],
+            source_abi: None,
+            event_handlers: vec![],
+            call_handlers: vec![],
+            block_handlers: vec![],
+        },
+        GraphUnresolvedDST::Subgraph(sub) => Template {
+            name: sub.name.clone(),
+            kind: sub.kind.clone(),
+            network: sub.network.clone(),
+            mapping_file: Some(sub.mapping.file.link.clone()),
+            api_version: Version::parse(&sub.mapping.api_version).ok(),
+            abis: sub
+                .mapping
+                .abis
+                .as_deref()
+                .unwrap_or(&[])
+                .iter()
+                .map(|a| Abi {
+                    name: a.name.clone(),
+                    file: a.file.link.clone(),
+                })
+                .collect(),
+            source_abi: None,
+            event_handlers: vec![],
+            call_handlers: vec![],
+            block_handlers: vec![],
+        },
+    }
+}
+
+/// Convert a graph-node `BlockHandlerFilter` to gnd's simplified `BlockHandlerFilterKind`.
+fn convert_block_handler_filter(filter: &BlockHandlerFilter) -> BlockHandlerFilterKind {
+    match filter {
+        BlockHandlerFilter::Call => BlockHandlerFilterKind::Call,
+        BlockHandlerFilter::Once => BlockHandlerFilterKind::Once,
+        BlockHandlerFilter::Polling { .. } => BlockHandlerFilterKind::Polling,
+    }
+}
+
+/// Get the directory containing a manifest file.
+///
+/// This handles the edge case where `manifest_path` is a bare filename
+/// like `"subgraph.yaml"` - in that case, `parent()` returns an empty
+/// path, so we fall back to `"."` (current directory).
+pub fn manifest_dir(manifest_path: &Path) -> &Path {
+    manifest_path
+        .parent()
+        .filter(|p| !p.as_os_str().is_empty())
+        .unwrap_or_else(|| Path::new("."))
+}
+
+/// Resolve a path relative to the manifest file.
+pub fn resolve_path(manifest: &Path, path: &str) -> PathBuf {
+    manifest_dir(manifest).join(path)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_manifest_dir_with_directory() {
+        let manifest = PathBuf::from("/home/user/project/subgraph.yaml");
+        assert_eq!(manifest_dir(&manifest), Path::new("/home/user/project"));
+    }
+
+    #[test]
+    fn test_manifest_dir_bare_filename() {
+        // When manifest_path is just "subgraph.yaml", parent() returns Some("")
+        // which is empty, so we should fall back to "."
+        let manifest = PathBuf::from("subgraph.yaml");
+        assert_eq!(manifest_dir(&manifest), Path::new("."));
+    }
+
+    #[test]
+    fn test_manifest_dir_relative_path() {
+        let manifest = PathBuf::from("./subgraph.yaml");
+        assert_eq!(manifest_dir(&manifest), Path::new("."));
+    }
+
+    #[test]
+    fn test_resolve_path() {
+        let manifest = PathBuf::from("/home/user/project/subgraph.yaml");
+        let path = "src/mapping.ts";
+        let resolved = resolve_path(&manifest, path);
+        assert_eq!(resolved, PathBuf::from("/home/user/project/src/mapping.ts"));
+    }
+
+    #[test]
+    fn test_resolve_path_bare_filename() {
+        // When manifest is just "subgraph.yaml", paths should resolve relative to "."
+        let manifest = PathBuf::from("subgraph.yaml");
+        let path = "src/mapping.ts";
+        let resolved = resolve_path(&manifest, path);
+        assert_eq!(resolved, PathBuf::from("./src/mapping.ts"));
+    }
+
+    #[test]
+    fn test_load_manifest_basic() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest_path = temp_dir.path().join("subgraph.yaml");
+
+        let manifest_content = r#"
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Token
+    network: mainnet
+    source:
+      abi: ERC20
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      file: ./src/mapping.ts
+      entities:
+        - MyEntity
+      abis:
+        - name: ERC20
+          file: ./abis/ERC20.json
+templates:
+  - kind: ethereum/contract
+    name: DynamicToken
+    network: mainnet
+    source:
+      abi: ERC20
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      file: ./src/dynamic.ts
+      entities:
+        - MyEntity
+      abis: []
+"#;
+
+        fs::write(&manifest_path, manifest_content).unwrap();
+
+        let manifest = load_manifest(&manifest_path).unwrap();
+        assert_eq!(manifest.spec_version, Version::new(0, 0, 4));
+        assert_eq!(manifest.schema, Some("./schema.graphql".to_string()));
+        assert_eq!(manifest.data_sources.len(), 1);
+        assert_eq!(manifest.data_sources[0].name, "Token");
+        assert_eq!(manifest.data_sources[0].kind, "ethereum/contract");
+        assert_eq!(
+            manifest.data_sources[0].network,
+            Some("mainnet".to_string())
+        );
+        assert_eq!(
+            manifest.data_sources[0].api_version,
+            Some(Version::new(0, 0, 6))
+        );
+        assert_eq!(
+            manifest.data_sources[0].mapping_file,
+            Some("./src/mapping.ts".to_string())
+        );
+        assert_eq!(manifest.data_sources[0].abis.len(), 1);
+        assert_eq!(manifest.data_sources[0].abis[0].name, "ERC20");
+        assert_eq!(manifest.templates.len(), 1);
+        assert_eq!(manifest.templates[0].name, "DynamicToken");
+        assert_eq!(manifest.templates[0].kind, "ethereum/contract");
+        assert_eq!(manifest.templates[0].network, Some("mainnet".to_string()));
+        assert_eq!(
+            manifest.templates[0].api_version,
+            Some(Version::new(0, 0, 6))
+        );
+    }
+
+    #[test]
+    fn test_load_manifest_with_graft_and_features() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest_path = temp_dir.path().join("subgraph.yaml");
+
+        let manifest_content = r#"
+specVersion: 0.0.6
+features:
+  - nonFatalErrors
+  - fullTextSearch
+graft:
+  base: QmXYZ123abcdefghijklmnopqrstuvwxyz1234567890ab
+  block: 12345
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Token
+    network: mainnet
+    source:
+      abi: ERC20
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      file: ./src/mapping.ts
+      entities:
+        - MyEntity
+      abis:
+        - name: ERC20
+          file: ./abis/ERC20.json
+"#;
+
+        fs::write(&manifest_path, manifest_content).unwrap();
+
+        let manifest = load_manifest(&manifest_path).unwrap();
+        assert_eq!(manifest.spec_version, Version::new(0, 0, 6));
+        assert_eq!(
+            manifest.features,
+            vec!["nonFatalErrors".to_string(), "fullTextSearch".to_string()]
+        );
+        assert!(manifest.graft.is_some());
+        let graft = manifest.graft.unwrap();
+        assert_eq!(graft.base, "QmXYZ123abcdefghijklmnopqrstuvwxyz1234567890ab");
+        assert_eq!(graft.block, 12345);
+    }
+
+    #[test]
+    fn test_load_manifest_with_subgraph_sources() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest_path = temp_dir.path().join("subgraph.yaml");
+
+        let manifest_content = r#"
+specVersion: 1.0.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: subgraph
+    name: SourceSubgraph
+    network: mainnet
+    source:
+      address: QmSourceHash1234567890abcdefghijklmnopqrstuvwx
+      startBlock: 0
+    mapping:
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      file: ./src/mapping.ts
+      entities:
+        - MyEntity
+      handlers:
+        - handler: handleEntity
+          entity: MyEntity
+  - kind: ethereum/contract
+    name: Token
+    network: mainnet
+    source:
+      abi: ERC20
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      file: ./src/mapping.ts
+      entities:
+        - MyEntity
+      abis: []
+"#;
+
+        fs::write(&manifest_path, manifest_content).unwrap();
+
+        let manifest = load_manifest(&manifest_path).unwrap();
+        // All data sources go to data_sources
+        assert_eq!(manifest.data_sources.len(), 2);
+        // First is the subgraph source
+        assert_eq!(manifest.data_sources[0].name, "SourceSubgraph");
+        assert_eq!(manifest.data_sources[0].kind, "subgraph");
+        assert!(manifest.data_sources[0].is_subgraph_source());
+        assert_eq!(
+            manifest.data_sources[0].source_address,
+            Some("QmSourceHash1234567890abcdefghijklmnopqrstuvwx".to_string())
+        );
+        // Second is the contract source
+        assert_eq!(manifest.data_sources[1].name, "Token");
+        assert_eq!(manifest.data_sources[1].kind, "ethereum/contract");
+        assert!(!manifest.data_sources[1].is_subgraph_source());
+        assert_eq!(manifest.data_sources[1].source_address, None);
+        // total_source_count includes both
+        assert_eq!(manifest.total_source_count(), 2);
+    }
+
+    #[test]
+    fn test_load_manifest_missing_source_abi_fails() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest_path = temp_dir.path().join("subgraph.yaml");
+
+        let manifest_content = r#"
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Token
+    network: mainnet
+    source: {}
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      file: ./src/mapping.ts
+      entities:
+        - MyEntity
+      abis:
+        - name: ERC20
+          file: ./abis/ERC20.json
+"#;
+
+        fs::write(&manifest_path, manifest_content).unwrap();
+
+        let result = load_manifest(&manifest_path);
+        assert!(result.is_err(), "Missing source.abi should fail parsing");
+        let err = result.unwrap_err();
+        let err_chain = format!("{:#}", err);
+        assert!(
+            err_chain.contains("abi"),
+            "Error should mention missing abi field, got: {}",
+            err_chain
+        );
+    }
+
+    #[test]
+    fn test_load_manifest_missing_mapping_abis_fails() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest_path = temp_dir.path().join("subgraph.yaml");
+
+        let manifest_content = r#"
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Token
+    network: mainnet
+    source:
+      abi: ERC20
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      file: ./src/mapping.ts
+      entities:
+        - MyEntity
+"#;
+
+        fs::write(&manifest_path, manifest_content).unwrap();
+
+        let result = load_manifest(&manifest_path);
+        assert!(result.is_err(), "Missing mapping.abis should fail parsing");
+        let err = result.unwrap_err();
+        let err_chain = format!("{:#}", err);
+        assert!(
+            err_chain.contains("abis"),
+            "Error should mention missing abis field, got: {}",
+            err_chain
+        );
+    }
+}
diff --git a/gnd/src/migrations/api_version.rs b/gnd/src/migrations/api_version.rs
new file mode 100644
index 00000000000..f660d54ca5e
--- /dev/null
+++ b/gnd/src/migrations/api_version.rs
@@ -0,0 +1,323 @@
+//! API version migrations.
+//!
+//! These migrations update the `apiVersion` field in data source and template mappings.
+//! Each migration requires a minimum graph-ts version to be installed.
+
+use anyhow::Result;
+
+use super::{
+    Migration, MigrationCheck, MigrationContext, load_manifest, manifest_has_api_version,
+    replace_in_file, versions,
+};
+
+/// Helper to create an API version migration check.
+fn check_api_version(
+    ctx: &MigrationContext,
+    from_version: &str,
+    min_graph_ts: (u64, u64, u64),
+    use_gte: bool,
+) -> Result<MigrationCheck> {
+    // Check graph-ts version
+    match versions::get_graph_ts_version(ctx.source_dir) {
+        Ok(version) => {
+            let meets_requirement = if use_gte {
+                versions::version_gte(&version, min_graph_ts.0, min_graph_ts.1, min_graph_ts.2)
+            } else {
+                versions::version_gt(&version, min_graph_ts.0, min_graph_ts.1, min_graph_ts.2)
+            };
+
+            if !meets_requirement {
+                return Ok(MigrationCheck::Skip);
+            }
+        }
+        Err(_) => {
+            return Ok(MigrationCheck::SkipWithReason(
+                "graph-ts dependency not installed yet".to_string(),
+            ));
+        }
+    }
+
+    // Check if manifest has the old apiVersion
+    let manifest = load_manifest(ctx.manifest_path)?;
+    if manifest_has_api_version(&manifest, from_version) {
+        Ok(MigrationCheck::ShouldApply)
+    } else {
+        Ok(MigrationCheck::Skip)
+    }
+}
+
+/// Helper to apply an API version migration.
+fn apply_api_version(ctx: &MigrationContext, from: &str, to: &str) -> Result<()> {
+    // Escape dots in version string for regex
+    let from_escaped = from.replace('.', r"\.");
+    let to_str = to;
+
+    replace_in_file(
+        ctx.manifest_path,
+        &[
+            (
+                &format!(r"apiVersion: {}", from_escaped),
+                &format!("apiVersion: {}", to_str),
+            ),
+            (
+                &format!(r"apiVersion: '{}'", from_escaped),
+                &format!("apiVersion: '{}'", to_str),
+            ),
+            (
+                &format!(r#"apiVersion: "{}""#, from_escaped),
+                &format!(r#"apiVersion: "{}""#, to_str),
+            ),
+        ],
+    )
+}
+
+// =============================================================================
+// Migrations
+// =============================================================================
+
+/// Migration: apiVersion 0.0.1 -> 0.0.2
+///
+/// Requires graph-ts > 0.5.1
+pub struct ApiVersion0_0_1To0_0_2;
+
+impl Migration for ApiVersion0_0_1To0_0_2 {
+    fn name(&self) -> &'static str {
+        "Bump mapping apiVersion from 0.0.1 to 0.0.2"
+    }
+
+    fn check(&self, ctx: &MigrationContext) -> Result<MigrationCheck> {
+        check_api_version(ctx, "0.0.1", (0, 5, 1), false)
+    }
+
+    fn apply(&self, ctx: &MigrationContext) -> Result<()> {
+        apply_api_version(ctx, "0.0.1", "0.0.2")
+    }
+}
+
+/// Migration: apiVersion 0.0.2 -> 0.0.3
+///
+/// Requires graph-ts > 0.12.0
+pub struct ApiVersion0_0_2To0_0_3;
+
+impl Migration for ApiVersion0_0_2To0_0_3 {
+    fn name(&self) -> &'static str {
+        "Bump mapping apiVersion from 0.0.2 to 0.0.3"
+    }
+
+    fn check(&self, ctx: &MigrationContext) -> Result<MigrationCheck> {
+        check_api_version(ctx, "0.0.2", (0, 12, 0), false)
+    }
+
+    fn apply(&self, ctx: &MigrationContext) -> Result<()> {
+        apply_api_version(ctx, "0.0.2", "0.0.3")
+    }
+}
+
+/// Migration: apiVersion 0.0.3 -> 0.0.4
+///
+/// Requires graph-ts > 0.17.0
+pub struct ApiVersion0_0_3To0_0_4;
+
+impl Migration for ApiVersion0_0_3To0_0_4 {
+    fn name(&self) -> &'static str {
+        "Bump mapping apiVersion from 0.0.3 to 0.0.4"
+    }
+
+    fn check(&self, ctx: &MigrationContext) -> Result<MigrationCheck> {
+        check_api_version(ctx, "0.0.3", (0, 17, 0), false)
+    }
+
+    fn apply(&self, ctx: &MigrationContext) -> Result<()> {
+        apply_api_version(ctx, "0.0.3", "0.0.4")
+    }
+}
+
+/// Migration: apiVersion 0.0.4 -> 0.0.5
+///
+/// Requires graph-ts >= 0.22.0
+pub struct ApiVersion0_0_4To0_0_5;
+
+impl Migration for ApiVersion0_0_4To0_0_5 {
+    fn name(&self) -> &'static str {
+        "Bump mapping apiVersion from 0.0.4 to 0.0.5"
+    }
+
+    fn check(&self, ctx: &MigrationContext) -> Result<MigrationCheck> {
+        check_api_version(ctx, "0.0.4", (0, 22, 0), true)
+    }
+
+    fn apply(&self, ctx: &MigrationContext) -> Result<()> {
+        apply_api_version(ctx, "0.0.4", "0.0.5")
+    }
+}
+
+/// Migration: apiVersion 0.0.5 -> 0.0.6
+///
+/// Requires graph-ts >= 0.24.0
+pub struct ApiVersion0_0_5To0_0_6;
+
+impl Migration for ApiVersion0_0_5To0_0_6 {
+    fn name(&self) -> &'static str {
+        "Bump mapping apiVersion from 0.0.5 to 0.0.6"
+    }
+
+    fn check(&self, ctx: &MigrationContext) -> Result<MigrationCheck> {
+        check_api_version(ctx, "0.0.5", (0, 24, 0), true)
+    }
+
+    fn apply(&self, ctx: &MigrationContext) -> Result<()> {
+        apply_api_version(ctx, "0.0.5", "0.0.6")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    fn setup_with_graph_ts(
+        manifest_content: &str,
+        graph_ts_version: &str,
+    ) -> (TempDir, std::path::PathBuf) {
+        let temp_dir = TempDir::new().unwrap();
+
+        // Create manifest
+        let manifest_path = temp_dir.path().join("subgraph.yaml");
+        std::fs::write(&manifest_path, manifest_content).unwrap();
+
+        // Create graph-ts package.json
+        let graph_ts_dir = temp_dir
+            .path()
+            .join("node_modules")
+            .join("@graphprotocol")
+            .join("graph-ts");
+        std::fs::create_dir_all(&graph_ts_dir).unwrap();
+        std::fs::write(
+            graph_ts_dir.join("package.json"),
+            format!(
+                r#"{{"name": "@graphprotocol/graph-ts", "version": "{}"}}"#,
+                graph_ts_version
+            ),
+        )
+        .unwrap();
+
+        (temp_dir, manifest_path)
+    }
+
+    #[test]
+    fn test_api_version_0_0_4_to_0_0_5_check_should_apply() {
+        let manifest = r#"
+specVersion: 0.0.4
+dataSources:
+  - kind: ethereum/contract
+    mapping:
+      apiVersion: 0.0.4
+"#;
+        let (_temp_dir, manifest_path) = setup_with_graph_ts(manifest, "0.25.0");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = ApiVersion0_0_4To0_0_5;
+        match migration.check(&ctx).unwrap() {
+            MigrationCheck::ShouldApply => {}
+            MigrationCheck::Skip => panic!("Expected ShouldApply, got Skip"),
+            MigrationCheck::SkipWithReason(r) => {
+                panic!("Expected ShouldApply, got SkipWithReason({})", r)
+            }
+        }
+    }
+
+    #[test]
+    fn test_api_version_0_0_4_to_0_0_5_skip_old_graph_ts() {
+        let manifest = r#"
+specVersion: 0.0.4
+dataSources:
+  - kind: ethereum/contract
+    mapping:
+      apiVersion: 0.0.4
+"#;
+        let (_temp_dir, manifest_path) = setup_with_graph_ts(manifest, "0.20.0");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = ApiVersion0_0_4To0_0_5;
+        match migration.check(&ctx).unwrap() {
+            MigrationCheck::Skip => {}
+            _ => panic!("Expected Skip"),
+        }
+    }
+
+    #[test]
+    fn test_api_version_0_0_4_to_0_0_5_apply() {
+        let manifest = r#"
+specVersion: 0.0.4
+dataSources:
+  - kind: ethereum/contract
+    mapping:
+      apiVersion: 0.0.4
+templates:
+  - kind: ethereum/contract
+    mapping:
+      apiVersion: 0.0.4
+"#;
+        let (_temp_dir, manifest_path) = setup_with_graph_ts(manifest, "0.25.0");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = ApiVersion0_0_4To0_0_5;
+        migration.apply(&ctx).unwrap();
+
+        let content = std::fs::read_to_string(&manifest_path).unwrap();
+        assert!(content.contains("apiVersion: 0.0.5"));
+        assert!(!content.contains("apiVersion: 0.0.4"));
+    }
+
+    #[test]
+    fn test_api_version_no_graph_ts() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest_path = temp_dir.path().join("subgraph.yaml");
+        std::fs::write(&manifest_path, "specVersion: 0.0.4\ndataSources: []").unwrap();
+
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = ApiVersion0_0_4To0_0_5;
+        match migration.check(&ctx).unwrap() {
+            MigrationCheck::SkipWithReason(reason) => {
+                assert!(reason.contains("not installed"));
+            }
+            _ => panic!("Expected SkipWithReason"),
+        }
+    }
+
+    #[test]
+    fn test_api_version_migration_with_quoted_versions() {
+        // Test with single quotes
+        let manifest_single = r#"
+specVersion: 0.0.4
+dataSources:
+  - kind: ethereum/contract
+    mapping:
+      apiVersion: '0.0.4'
+"#;
+        let (_temp_dir, manifest_path) = setup_with_graph_ts(manifest_single, "0.25.0");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = ApiVersion0_0_4To0_0_5;
+        migration.apply(&ctx).unwrap();
+
+        let content = std::fs::read_to_string(&manifest_path).unwrap();
+        assert!(content.contains("apiVersion: '0.0.5'"));
+    }
+}
diff --git a/gnd/src/migrations/mod.rs b/gnd/src/migrations/mod.rs
new file mode 100644
index 00000000000..0fa888e80e6
--- /dev/null
+++ b/gnd/src/migrations/mod.rs
@@ -0,0 +1,238 @@
+//! Subgraph manifest migrations.
+//!
+//! This module provides automatic migrations for updating subgraph manifests
+//! to newer versions. Migrations handle both:
+//! - `specVersion`: The manifest schema version
+//! - `apiVersion`: The mapping API version in data sources/templates
+//!
+//! The migration system checks graph-ts version compatibility when applicable
+//! and applies changes in-place using regex-based patching to preserve
+//! formatting.
+
+mod api_version;
+mod spec_version;
+mod versions;
+
+use std::path::Path;
+
+use anyhow::Result;
+use regex::Regex;
+
+use crate::output::{Step, step};
+
+pub use versions::get_graph_ts_version;
+
+/// Context for running migrations.
+pub struct MigrationContext<'a> {
+    /// Path to the manifest file.
+    pub manifest_path: &'a Path,
+    /// Directory containing the subgraph source (for finding graph-ts).
+    pub source_dir: &'a Path,
+}
+
+/// Result of checking whether a migration should be applied.
+pub enum MigrationCheck {
+    /// Migration should be applied.
+    ShouldApply,
+    /// Migration should be skipped (no changes needed).
+    Skip,
+    /// Migration should be skipped with an explanation.
+    SkipWithReason(String),
+}
+
+/// A single migration that can be applied to a manifest.
+pub trait Migration {
+    /// Human-readable name of the migration.
+    fn name(&self) -> &'static str;
+
+    /// Check if this migration should be applied.
+    fn check(&self, ctx: &MigrationContext) -> Result<MigrationCheck>;
+
+    /// Apply the migration to the manifest file.
+    fn apply(&self, ctx: &MigrationContext) -> Result<()>;
+}
+
+/// All available migrations in order.
+fn all_migrations() -> Vec<Box<dyn Migration>> {
+    vec![
+        // Spec version migrations
+        Box::new(spec_version::SpecVersion0_0_1To0_0_2),
+        Box::new(spec_version::SpecVersion0_0_2To0_0_4),
+        // API version migrations
+        Box::new(api_version::ApiVersion0_0_1To0_0_2),
+        Box::new(api_version::ApiVersion0_0_2To0_0_3),
+        Box::new(api_version::ApiVersion0_0_3To0_0_4),
+        Box::new(api_version::ApiVersion0_0_4To0_0_5),
+        Box::new(api_version::ApiVersion0_0_5To0_0_6),
+    ]
+}
+
+/// Apply all applicable migrations to a manifest file.
+///
+/// Migrations are applied in order, with each migration checking if it should
+/// be applied before making changes. The manifest file is modified in-place.
+pub fn apply_migrations(manifest_path: &Path) -> Result<()> {
+    let mut apply_printed = false;
+    let mut print_apply = || {
+        if !apply_printed {
+            step(Step::Generate, "Applying migrations");
+            apply_printed = true;
+        }
+    };
+
+    let source_dir = crate::manifest::manifest_dir(manifest_path);
+
+    let ctx = MigrationContext {
+        manifest_path,
+        source_dir,
+    };
+
+    for migration in all_migrations() {
+        match migration.check(&ctx)? {
+            MigrationCheck::ShouldApply => {
+                print_apply();
+                step(
+                    Step::Generate,
+                    &format!("Apply migration: {}", migration.name()),
+                );
+                migration.apply(&ctx)?;
+            }
+            MigrationCheck::Skip => {
+                // No need to bother the user
+            }
+            MigrationCheck::SkipWithReason(reason) => {
+                print_apply();
+                step(
+                    Step::Skip,
+                    &format!("Skip migration: {} ({})", migration.name(), reason),
+                );
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Replace all occurrences of a pattern in a file.
+///
+/// This handles the common case of replacing version strings that might be
+/// written with different quote styles (unquoted, single-quoted, double-quoted).
+fn replace_in_file(path: &Path, patterns: &[(&str, &str)]) -> Result<()> {
+    let content = std::fs::read_to_string(path)?;
+    let mut result = content;
+
+    for (pattern, replacement) in patterns {
+        let re = Regex::new(pattern)?;
+        result = re.replace_all(&result, *replacement).to_string();
+    }
+
+    std::fs::write(path, result)?;
+    Ok(())
+}
+
+/// Check if manifest has a specific apiVersion in dataSources or templates.
+fn manifest_has_api_version(manifest: &serde_json::Value, version: &str) -> bool {
+    // Check dataSources
+    if let Some(data_sources) = manifest.get("dataSources").and_then(|ds| ds.as_array()) {
+        for ds in data_sources {
+            if let Some(api_version) = ds
+                .get("mapping")
+                .and_then(|m| m.get("apiVersion"))
+                .and_then(|v| v.as_str())
+                && api_version == version
+            {
+                return true;
+            }
+        }
+    }
+
+    // Check templates
+    if let Some(templates) = manifest.get("templates").and_then(|t| t.as_array()) {
+        for template in templates {
+            if let Some(api_version) = template
+                .get("mapping")
+                .and_then(|m| m.get("apiVersion"))
+                .and_then(|v| v.as_str())
+                && api_version == version
+            {
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
+/// Load manifest as serde_json::Value for inspection.
+fn load_manifest(path: &Path) -> Result<serde_json::Value> {
+    let content = std::fs::read_to_string(path)?;
+    let value: serde_json::Value = serde_yaml::from_str(&content)?;
+    Ok(value)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_manifest_has_api_version() {
+        let manifest: serde_json::Value = serde_json::json!({
+            "dataSources": [
+                {
+                    "mapping": {
+                        "apiVersion": "0.0.4"
+                    }
+                }
+            ]
+        });
+
+        assert!(manifest_has_api_version(&manifest, "0.0.4"));
+        assert!(!manifest_has_api_version(&manifest, "0.0.5"));
+    }
+
+    #[test]
+    fn test_manifest_has_api_version_in_templates() {
+        let manifest: serde_json::Value = serde_json::json!({
+            "dataSources": [],
+            "templates": [
+                {
+                    "mapping": {
+                        "apiVersion": "0.0.3"
+                    }
+                }
+            ]
+        });
+
+        assert!(manifest_has_api_version(&manifest, "0.0.3"));
+        assert!(!manifest_has_api_version(&manifest, "0.0.4"));
+    }
+
+    #[test]
+    fn test_replace_in_file() {
+        let temp_dir = TempDir::new().unwrap();
+        let file_path = temp_dir.path().join("test.yaml");
+
+        std::fs::write(
+            &file_path,
+            "apiVersion: 0.0.4\napiVersion: '0.0.4'\napiVersion: \"0.0.4\"\n",
+        )
+        .unwrap();
+
+        replace_in_file(
+            &file_path,
+            &[
+                (r"apiVersion: 0\.0\.4", "apiVersion: 0.0.5"),
+                (r"apiVersion: '0\.0\.4'", "apiVersion: '0.0.5'"),
+                (r#"apiVersion: "0\.0\.4""#, r#"apiVersion: "0.0.5""#),
+            ],
+        )
+        .unwrap();
+
+        let content = std::fs::read_to_string(&file_path).unwrap();
+        assert!(content.contains("apiVersion: 0.0.5"));
+        assert!(content.contains("apiVersion: '0.0.5'"));
+        assert!(content.contains("apiVersion: \"0.0.5\""));
+        assert!(!content.contains("0.0.4"));
+    }
+}
diff --git a/gnd/src/migrations/spec_version.rs b/gnd/src/migrations/spec_version.rs
new file mode 100644
index 00000000000..ffdb6f13ce7
--- /dev/null
+++ b/gnd/src/migrations/spec_version.rs
@@ -0,0 +1,202 @@
+//! Spec version migrations.
+//!
+//! These migrations update the manifest's `specVersion` field to newer versions.
+
+use anyhow::Result;
+
+use super::{Migration, MigrationCheck, MigrationContext, load_manifest, replace_in_file};
+
+/// Migration: specVersion 0.0.1 -> 0.0.2
+///
+/// Spec version 0.0.2 uses top-level templates. graph-cli no longer supports
+/// 0.0.1 which used nested templates.
+pub struct SpecVersion0_0_1To0_0_2;
+
+impl Migration for SpecVersion0_0_1To0_0_2 {
+    fn name(&self) -> &'static str {
+        "Bump manifest specVersion from 0.0.1 to 0.0.2"
+    }
+
+    fn check(&self, ctx: &MigrationContext) -> Result<MigrationCheck> {
+        let manifest = load_manifest(ctx.manifest_path)?;
+
+        let spec_version = manifest
+            .get("specVersion")
+            .and_then(|v| v.as_str())
+            .unwrap_or("");
+
+        if spec_version == "0.0.1" {
+            Ok(MigrationCheck::ShouldApply)
+        } else {
+            Ok(MigrationCheck::Skip)
+        }
+    }
+
+    fn apply(&self, ctx: &MigrationContext) -> Result<()> {
+        replace_in_file(
+            ctx.manifest_path,
+            &[
+                (r"specVersion: 0\.0\.1", "specVersion: 0.0.2"),
+                (r"specVersion: '0\.0\.1'", "specVersion: '0.0.2'"),
+                (r#"specVersion: "0\.0\.1""#, r#"specVersion: "0.0.2""#),
+            ],
+        )
+    }
+}
+
+/// Migration: specVersion 0.0.2/0.0.3 -> 0.0.4
+///
+/// Spec version 0.0.4 uses feature management, but features are detected
+/// and validated by the graph-node instance during subgraph deployment.
+///
+/// We skip spec version 0.0.3, which is considered invalid and non-canonical.
+pub struct SpecVersion0_0_2To0_0_4;
+
+impl Migration for SpecVersion0_0_2To0_0_4 {
+    fn name(&self) -> &'static str {
+        "Bump manifest specVersion from 0.0.2 to 0.0.4"
+    }
+
+    fn check(&self, ctx: &MigrationContext) -> Result<MigrationCheck> {
+        let manifest = load_manifest(ctx.manifest_path)?;
+
+        let spec_version = manifest
+            .get("specVersion")
+            .and_then(|v| v.as_str())
+            .unwrap_or("");
+
+        if spec_version == "0.0.2" || spec_version == "0.0.3" {
+            Ok(MigrationCheck::ShouldApply)
+        } else {
+            Ok(MigrationCheck::Skip)
+        }
+    }
+
+    fn apply(&self, ctx: &MigrationContext) -> Result<()> {
+        // Replace both 0.0.2 and 0.0.3 with 0.0.4
+        replace_in_file(
+            ctx.manifest_path,
+            &[(r#"specVersion: ['"]?0\.0\.[23]['"]?"#, "specVersion: 0.0.4")],
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    fn setup_manifest(content: &str) -> (TempDir, std::path::PathBuf) {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest_path = temp_dir.path().join("subgraph.yaml");
+        std::fs::write(&manifest_path, content).unwrap();
+        (temp_dir, manifest_path)
+    }
+
+    #[test]
+    fn test_spec_version_0_0_1_to_0_0_2_check() {
+        let (_temp_dir, manifest_path) = setup_manifest("specVersion: 0.0.1\ndataSources: []");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = SpecVersion0_0_1To0_0_2;
+        match migration.check(&ctx).unwrap() {
+            MigrationCheck::ShouldApply => {}
+            _ => panic!("Expected ShouldApply"),
+        }
+    }
+
+    #[test]
+    fn test_spec_version_0_0_1_to_0_0_2_skip() {
+        let (_temp_dir, manifest_path) = setup_manifest("specVersion: 0.0.2\ndataSources: []");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = SpecVersion0_0_1To0_0_2;
+        match migration.check(&ctx).unwrap() {
+            MigrationCheck::Skip => {}
+            _ => panic!("Expected Skip"),
+        }
+    }
+
+    #[test]
+    fn test_spec_version_0_0_1_to_0_0_2_apply() {
+        let (_temp_dir, manifest_path) = setup_manifest("specVersion: 0.0.1\ndataSources: []");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = SpecVersion0_0_1To0_0_2;
+        migration.apply(&ctx).unwrap();
+
+        let content = std::fs::read_to_string(&manifest_path).unwrap();
+        assert!(content.contains("specVersion: 0.0.2"));
+        assert!(!content.contains("specVersion: 0.0.1"));
+    }
+
+    #[test]
+    fn test_spec_version_0_0_2_to_0_0_4_check() {
+        let (_temp_dir, manifest_path) = setup_manifest("specVersion: 0.0.2\ndataSources: []");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = SpecVersion0_0_2To0_0_4;
+        match migration.check(&ctx).unwrap() {
+            MigrationCheck::ShouldApply => {}
+            _ => panic!("Expected ShouldApply"),
+        }
+    }
+
+    #[test]
+    fn test_spec_version_0_0_3_to_0_0_4_check() {
+        let (_temp_dir, manifest_path) = setup_manifest("specVersion: 0.0.3\ndataSources: []");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = SpecVersion0_0_2To0_0_4;
+        match migration.check(&ctx).unwrap() {
+            MigrationCheck::ShouldApply => {}
+            _ => panic!("Expected ShouldApply"),
+        }
+    }
+
+    #[test]
+    fn test_spec_version_0_0_2_to_0_0_4_skip() {
+        let (_temp_dir, manifest_path) = setup_manifest("specVersion: 0.0.4\ndataSources: []");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = SpecVersion0_0_2To0_0_4;
+        match migration.check(&ctx).unwrap() {
+            MigrationCheck::Skip => {}
+            _ => panic!("Expected Skip"),
+        }
+    }
+
+    #[test]
+    fn test_spec_version_0_0_2_to_0_0_4_apply() {
+        let (_temp_dir, manifest_path) = setup_manifest("specVersion: 0.0.2\ndataSources: []");
+        let ctx = MigrationContext {
+            manifest_path: &manifest_path,
+            source_dir: manifest_path.parent().unwrap(),
+        };
+
+        let migration = SpecVersion0_0_2To0_0_4;
+        migration.apply(&ctx).unwrap();
+
+        let content = std::fs::read_to_string(&manifest_path).unwrap();
+        assert!(content.contains("specVersion: 0.0.4"));
+        assert!(!content.contains("specVersion: 0.0.2"));
+    }
+}
diff --git a/gnd/src/migrations/versions.rs b/gnd/src/migrations/versions.rs
new file mode 100644
index 00000000000..f0cd6a3e221
--- /dev/null
+++ b/gnd/src/migrations/versions.rs
@@ -0,0 +1,144 @@
+//! Version detection utilities for migrations.
+//!
+//! Provides functions to detect the installed version of graph-ts
+//! by searching for its package.json in node_modules.
+
+use std::path::Path;
+
+use anyhow::{Result, anyhow};
+use semver::Version;
+
+/// Get the installed graph-ts version by searching node_modules.
+///
+/// Searches upward from `source_dir` looking for `node_modules/@graphprotocol/graph-ts/package.json`.
+/// Returns the version string from the package.json, or an error if not found.
+pub fn get_graph_ts_version(source_dir: &Path) -> Result<Version> {
+    let mut current = source_dir.canonicalize().ok();
+
+    while let Some(dir) = current {
+        let graph_ts_path = dir
+            .join("node_modules")
+            .join("@graphprotocol")
+            .join("graph-ts")
+            .join("package.json");
+
+        if graph_ts_path.exists() {
+            let content = std::fs::read_to_string(&graph_ts_path)?;
+            let pkg: serde_json::Value = serde_json::from_str(&content)?;
+
+            let version_str = pkg
+                .get("version")
+                .and_then(|v| v.as_str())
+                .ok_or_else(|| anyhow!("No version field in graph-ts package.json"))?;
+
+            // Parse version, handling prerelease versions by coercing
+            let version = parse_version(version_str)?;
+            return Ok(version);
+        }
+
+        // Move up to parent directory
+        current = dir.parent().map(|p| p.to_path_buf());
+    }
+
+    Err(anyhow!("graph-ts dependency not installed"))
+}
+
+/// Parse a version string, handling semver-incompatible formats.
+///
+/// Semver prerelease versions like "0.25.0-alpha.1" are valid, but we also
+/// handle cases where the version might have extra components.
+fn parse_version(version_str: &str) -> Result<Version> {
+    // Try direct parsing first
+    if let Ok(version) = Version::parse(version_str) {
+        return Ok(version);
+    }
+
+    // Try to extract just the major.minor.patch part
+    let parts: Vec<&str> = version_str
+        .split('-')
+        .next()
+        .unwrap_or(version_str)
+        .split('.')
+        .collect();
+    if parts.len() >= 3 {
+        let major: u64 = parts[0].parse()?;
+        let minor: u64 = parts[1].parse()?;
+        let patch: u64 = parts[2].parse()?;
+        return Ok(Version::new(major, minor, patch));
+    }
+
+    Err(anyhow!("Failed to parse version: {}", version_str))
+}
+
+/// Check if a version satisfies a minimum requirement.
+pub fn version_gte(version: &Version, major: u64, minor: u64, patch: u64) -> bool {
+    let requirement = Version::new(major, minor, patch);
+    version >= &requirement
+}
+
+/// Check if a version is greater than a reference.
+pub fn version_gt(version: &Version, major: u64, minor: u64, patch: u64) -> bool {
+    let requirement = Version::new(major, minor, patch);
+    version > &requirement
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_parse_version_simple() {
+        let v = parse_version("0.25.0").unwrap();
+        assert_eq!(v, Version::new(0, 25, 0));
+    }
+
+    #[test]
+    fn test_parse_version_prerelease() {
+        let v = parse_version("0.25.0-alpha.1").unwrap();
+        assert_eq!(v.major, 0);
+        assert_eq!(v.minor, 25);
+        assert_eq!(v.patch, 0);
+    }
+
+    #[test]
+    fn test_version_gte() {
+        let v = Version::new(0, 25, 0);
+        assert!(version_gte(&v, 0, 25, 0));
+        assert!(version_gte(&v, 0, 24, 0));
+        assert!(!version_gte(&v, 0, 26, 0));
+    }
+
+    #[test]
+    fn test_version_gt() {
+        let v = Version::new(0, 25, 0);
+        assert!(version_gt(&v, 0, 24, 0));
+        assert!(!version_gt(&v, 0, 25, 0));
+        assert!(!version_gt(&v, 0, 26, 0));
+    }
+
+    #[test]
+    fn test_get_graph_ts_version_not_found() {
+        let temp_dir = TempDir::new().unwrap();
+        let result = get_graph_ts_version(temp_dir.path());
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("not installed"));
+    }
+
+    #[test]
+    fn test_get_graph_ts_version_found() {
+        let temp_dir = TempDir::new().unwrap();
+        let graph_ts_dir = temp_dir
+            .path()
+            .join("node_modules")
+            .join("@graphprotocol")
+            .join("graph-ts");
+        std::fs::create_dir_all(&graph_ts_dir).unwrap();
+
+        let package_json = r#"{"name": "@graphprotocol/graph-ts", "version": "0.32.0"}"#;
+        std::fs::write(graph_ts_dir.join("package.json"), package_json).unwrap();
+
+        let version = get_graph_ts_version(temp_dir.path()).unwrap();
+        assert_eq!(version, Version::new(0, 32, 0));
+    }
+}
diff --git a/gnd/src/output/mod.rs b/gnd/src/output/mod.rs
new file mode 100644
index 00000000000..e0cf8a356f5
--- /dev/null
+++ b/gnd/src/output/mod.rs
@@ -0,0 +1,58 @@
+mod spinner;
+
+pub use spinner::{Spinner, SpinnerResult, step as spinner_step, with_spinner};
+
+use console::style;
+
+/// Step type for standalone step printing (without spinner)
+#[derive(Debug, Clone, Copy)]
+pub enum Step {
+    /// Loading/reading a file
+    Load,
+    /// Generating code
+    Generate,
+    /// Writing a file
+    Write,
+    /// Skipping a step
+    Skip,
+    /// Deploying a subgraph
+    Deploy,
+    /// Done with all steps
+    Done,
+    /// Warning (non-fatal)
+    Warn,
+}
+
+/// Print a standalone step without a spinner.
+///
+/// This is used for code generation steps where we don't need
+/// the spinner animation but want consistent output formatting.
+pub fn step(step_type: Step, message: &str) {
+    let symbol = match step_type {
+        Step::Load => style("→").cyan(),
+        Step::Generate => style("→").cyan(),
+        Step::Write => style("→").cyan(),
+        Step::Skip => style("→").dim(),
+        Step::Deploy => style("→").cyan(),
+        Step::Done => style("✔").green(),
+        Step::Warn => style("⚠").yellow(),
+    };
+    println!("{} {}", symbol, message);
+}
+
+/// Print a standalone step result.
+pub struct StepResult;
+
+impl StepResult {
+    pub fn success(message: &str) {
+        println!("{} {}", style("✔").green(), message);
+    }
+
+    pub fn error(message: &str) {
+        eprintln!("{} {}", style("✖").red(), message);
+    }
+
+    pub fn warning(message: &str) {
+        println!("{} {}", style("⚠").yellow(), message);
+    }
+}
diff --git a/gnd/src/output/spinner.rs b/gnd/src/output/spinner.rs
new file mode 100644
index 00000000000..24822e294d3
--- /dev/null
+++ b/gnd/src/output/spinner.rs
@@ -0,0 +1,299 @@
+//! Spinner and progress output utilities.
+//!
+//! This module provides spinner functionality matching the output format of
+//! the TypeScript graph-cli, which uses gluegun's print.spin() (based on ora).
+//!
+//! # Examples
+//!
+//! ```ignore
+//! use gnd::output::{with_spinner, Spinner};
+//!
+//! // Simple usage with closure
+//! let result = with_spinner(
+//!     "Loading data",
+//!     "Failed to load data",
+//!     "Data loaded with warnings",
+//!     |spinner| {
+//!         // Do work...
+//!         Ok::<_, anyhow::Error>(42)
+//!     }
+//! )?;
+//!
+//! // Or use Spinner directly for more control
+//! let mut spinner = Spinner::new("Processing...");
+//! spinner.step("Step 1", Some("details"));
+//! spinner.succeed("Done!");
+//! ```
+
+use std::fmt::Display;
+use std::time::Duration;
+
+use console::{Term, style};
+use indicatif::{ProgressBar, ProgressStyle};
+
+/// The checkmark symbol used for successful steps (matches TS CLI)
+pub const SUCCESS_SYMBOL: &str = "✔";
+/// The cross symbol used for failed steps (matches TS CLI)
+pub const FAILURE_SYMBOL: &str = "✖";
+/// The warning symbol used for warnings
+pub const WARNING_SYMBOL: &str = "⚠";
+
+/// A command-line spinner for showing progress on long-running operations.
+///
+/// This matches the behavior of gluegun's `print.spin()` which is based on ora.
+pub struct Spinner {
+    progress: ProgressBar,
+    term: Term,
+}
+
+impl Spinner {
+    /// Create a new spinner with the given initial message.
+    pub fn new(message: impl Into<String>) -> Self {
+        let progress = ProgressBar::new_spinner();
+        progress.set_style(
+            ProgressStyle::default_spinner()
+                .tick_chars("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏")
+                .template("{spinner:.cyan} {msg}")
+                .expect("Invalid spinner template"),
+        );
+        progress.set_message(message.into());
+        progress.enable_steady_tick(Duration::from_millis(80));
+
+        Self {
+            progress,
+            term: Term::stderr(),
+        }
+    }
+
+    /// Update the spinner message.
+    pub fn set_message(&self, message: impl Into<String>) {
+        self.progress.set_message(message.into());
+    }
+
+    /// Stop the spinner and show a step with optional details.
+    ///
+    /// The spinner will continue after showing the step (matches TS CLI behavior).
+    pub fn step(&self, subject: impl Display, text: Option<impl Display>) {
+        self.progress.suspend(|| {
+            let msg = if let Some(text) = text {
+                format!("{} {}", style(subject).dim(), style(text).dim())
+            } else {
+                format!("{}", style(subject).dim())
+            };
+            let _ = self.term.write_line(&msg);
+        });
+    }
+
+    /// Stop the spinner with a success checkmark and message.
+    pub fn succeed(self, message: impl Display) {
+        self.progress.finish_and_clear();
+        let _ = self
+            .term
+            .write_line(&format!("{} {}", style(SUCCESS_SYMBOL).green(), message));
+    }
+
+    /// Stop the spinner with a failure X and message.
+    pub fn fail(self, message: impl Display) {
+        self.progress.finish_and_clear();
+        let _ = self
+            .term
+            .write_line(&format!("{} {}", style(FAILURE_SYMBOL).red(), message));
+    }
+
+    /// Stop the spinner with a warning symbol and message.
+    pub fn warn(self, message: impl Display) {
+        self.progress.finish_and_clear();
+        let _ = self
+            .term
+            .write_line(&format!("{} {}", style(WARNING_SYMBOL).yellow(), message));
+    }
+
+    /// Stop the spinner, clearing the line without any message.
+    pub fn stop(self) {
+        self.progress.finish_and_clear();
+    }
+
+    /// Stop the spinner and persist with a custom symbol and text.
+    pub fn stop_and_persist(self, symbol: impl Display, message: impl Display) {
+        self.progress.finish_and_clear();
+        let _ = self.term.write_line(&format!("{} {}", symbol, message));
+    }
+}
+
+/// Result type for spinner operations that can have warnings.
+#[derive(Debug)]
+pub enum SpinnerResult<T> {
+    /// Operation succeeded without warnings
+    Ok(T),
+    /// Operation succeeded with a warning
+    Warning { result: T, warning: String },
+    /// Operation failed with an error message
+    Error { result: Option<T>, error: String },
+}
+
+impl<T> SpinnerResult<T> {
+    /// Create a successful result
+    pub fn ok(result: T) -> Self {
+        SpinnerResult::Ok(result)
+    }
+
+    /// Create a result with a warning
+    pub fn warning(result: T, warning: impl Into<String>) -> Self {
+        SpinnerResult::Warning {
+            result,
+            warning: warning.into(),
+        }
+    }
+
+    /// Create an error result
+    pub fn error(error: impl Into<String>) -> Self {
+        SpinnerResult::Error {
+            result: None,
+            error: error.into(),
+        }
+    }
+
+    /// Create an error result with a partial result
+    pub fn error_with_result(result: T, error: impl Into<String>) -> Self {
+        SpinnerResult::Error {
+            result: Some(result),
+            error: error.into(),
+        }
+    }
+}
+
+/// Execute a function with a spinner, showing progress and handling errors.
+///
+/// This matches the TS CLI's `withSpinner` function behavior:
+/// - Shows `text` while the operation is in progress
+/// - On success, shows `text` with a checkmark
+/// - On error, shows `error_text: <error message>` with an X
+/// - If the function returns `SpinnerResult::Warning`, shows the warning but still succeeds
+///
+/// # Arguments
+///
+/// * `text` - The text to show while the operation is in progress (and on success)
+/// * `error_text` - The prefix for error messages
+/// * `warning_text` - The prefix for warning messages
+/// * `f` - The function to execute
+///
+/// # Returns
+///
+/// The result of the function, or an error if the function failed.
+///
+/// # Examples
+///
+/// ```ignore
+/// let result = with_spinner(
+///     "Uploading files",
+///     "Failed to upload",
+///     "Uploaded with warnings",
+///     |spinner| {
+///         spinner.step("Preparing", Some("files"));
+///         // Do work...
+///         Ok::<_, anyhow::Error>(42)
+///     }
+/// )?;
+/// ```
+pub fn with_spinner<T, E>(
+    text: impl Into<String>,
+    error_text: impl Into<String>,
+    _warning_text: impl Into<String>,
+    f: impl FnOnce(&Spinner) -> Result<T, E>,
+) -> Result<T, E>
+where
+    E: Display,
+{
+    let text = text.into();
+    let error_text = error_text.into();
+
+    let spinner = Spinner::new(&text);
+
+    match f(&spinner) {
+        Ok(result) => {
+            spinner.succeed(&text);
+            Ok(result)
+        }
+        Err(e) => {
+            spinner.fail(format!("{}: {}", error_text, e));
+            Err(e)
+        }
+    }
+}
+
+/// Execute a step as part of a spinner, showing the step description.
+///
+/// This matches the TS CLI's `step` function which shows a muted step
+/// description while continuing the spinner.
+pub fn step(spinner: &Spinner, subject: impl Display, text: Option<impl Display>) {
+    spinner.step(subject, text);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_spinner_result_ok() {
+        let result: SpinnerResult<i32> = SpinnerResult::ok(42);
+        match result {
+            SpinnerResult::Ok(v) => assert_eq!(v, 42),
+            _ => panic!("Expected Ok"),
+        }
+    }
+
+    #[test]
+    fn test_spinner_result_warning() {
+        let result: SpinnerResult<i32> = SpinnerResult::warning(42, "some warning");
+        match result {
+            SpinnerResult::Warning { result, warning } => {
+                assert_eq!(result, 42);
+                assert_eq!(warning, "some warning");
+            }
+            _ => panic!("Expected Warning"),
+        }
+    }
+
+    #[test]
+    fn test_spinner_result_error() {
+        let result: SpinnerResult<i32> = SpinnerResult::error("some error");
+        match result {
+            SpinnerResult::Error { result, error } => {
+                assert!(result.is_none());
+                assert_eq!(error, "some error");
+            }
+            _ => panic!("Expected Error"),
+        }
+    }
+
+    #[test]
+    fn test_spinner_result_error_with_result() {
+        let result: SpinnerResult<i32> = SpinnerResult::error_with_result(42, "partial error");
+        match result {
+            SpinnerResult::Error { result, error } => {
+                assert_eq!(result, Some(42));
+                assert_eq!(error, "partial error");
+            }
+            _ => panic!("Expected Error"),
+        }
+    }
+
+    #[test]
+    fn test_with_spinner_success() {
+        let result: Result<i32, &str> =
+            with_spinner("Testing", "Test failed", "Test warning", |_spinner| {
+                Ok::<_, &str>(42)
+            });
+        assert_eq!(result.unwrap(), 42);
+    }
+
+    #[test]
+    fn test_with_spinner_error() {
+        let result: Result<i32, &str> =
+            with_spinner("Testing", "Test failed", "Test warning", |_spinner| {
+                Err::<i32, _>("error occurred")
+            });
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), "error occurred");
+    }
+}
diff --git a/gnd/src/prompt.rs b/gnd/src/prompt.rs
new file mode 100644
index 00000000000..ed2a2037f98
--- /dev/null
+++ b/gnd/src/prompt.rs
@@ -0,0 +1,771 @@
+//! Interactive prompt utilities for CLI commands.
+//!
+//! This module provides wrappers around the `inquire` crate to provide
+//! consistent prompting behavior similar to the TypeScript graph-cli.
+
+use std::path::Path;
+
+use anyhow::Result;
+use console::{Term, style};
+use inquire::parser::CustomTypeParser;
+use inquire::validator::Validation;
+use inquire::{Autocomplete, Confirm, CustomType, CustomUserError, Select, Text};
+
+use crate::output::{Step, step};
+use crate::services::{ContractInfo, ContractService, Network, NetworksRegistry};
+
+/// Format a network for display.
+fn format_network(network: &Network) -> String {
+    let full_name = network.full_name.as_deref().unwrap_or(&network.id);
+    format!("{} ({})", full_name, network.id)
+}
+
+/// A network autocompleter that works with owned data.
+#[derive(Clone)]
+struct SimpleNetworkCompleter {
+    entries: Vec<NetworkEntry>,
+}
+
+#[derive(Clone)]
+struct NetworkEntry {
+    display: String,
+    search_terms: String,
+}
+
+impl SimpleNetworkCompleter {
+    fn new(registry: &NetworksRegistry) -> Self {
+        let entries: Vec<NetworkEntry> = registry
+            .networks
+            .iter()
+            .map(|n| {
+                let display = format_network(n);
+                let search_terms = format!(
+                    "{} {} {} {}",
+                    n.id,
+                    n.full_name.as_deref().unwrap_or(""),
+                    n.short_name.as_deref().unwrap_or(""),
+                    n.aliases.join(" ")
+                )
+                .to_lowercase();
+                NetworkEntry {
+                    display,
+                    search_terms,
+                }
+            })
+            .collect();
+        Self { entries }
+    }
+}
+
+impl Autocomplete for SimpleNetworkCompleter {
+    fn get_suggestions(&mut self, input: &str) -> Result<Vec<String>, CustomUserError> {
+        let input_lower = input.to_lowercase();
+        let matches: Vec<String> = self
+            .entries
+            .iter()
+            .filter(|e| {
+                e.search_terms.contains(&input_lower)
+                    || e.display.to_lowercase().contains(&input_lower)
+            })
+            .take(15)
+            .map(|e| e.display.clone())
+            .collect();
+        Ok(matches)
+    }
+
+    fn get_completion(
+        &mut self,
+        _input: &str,
+        highlighted_suggestion: Option<String>,
+    ) -> Result<inquire::autocompletion::Replacement, CustomUserError> {
+        Ok(highlighted_suggestion)
+    }
+}
+
+/// Prompt for the subgraph slug/name.
+pub fn prompt_subgraph_name(default: Option<&str>) -> Result<String> {
+    let mut prompt = Text::new("Subgraph slug:")
+        .with_help_message("e.g., my-subgraph or myorg/my-subgraph")
+        .with_validator(|input: &str| {
+            if input.trim().is_empty() {
+                Ok(Validation::Invalid("Subgraph slug cannot be empty".into()))
+            } else {
+                Ok(Validation::Valid)
+            }
+        });
+
+    if let Some(d) = default {
+        prompt = prompt.with_default(d);
+    }
+
+    let name = prompt.prompt()?;
+    Ok(format_subgraph_name(&name))
+}
+
+/// Prompt for the directory to create the subgraph in.
+pub fn prompt_directory(default: Option<&str>) -> Result<String> {
+    let mut prompt = Text::new("Directory:")
+        .with_help_message("Directory to create the subgraph in")
+        .with_validator(|input: &str| {
+            if input.trim().is_empty() {
+                Ok(Validation::Invalid("Directory cannot be empty".into()))
+            } else {
+                Ok(Validation::Valid)
+            }
+        });
+
+    if let Some(d) = default {
+        prompt = prompt.with_default(d);
+    }
+
+    Ok(prompt.prompt()?)
+}
+
+/// Prompt for a contract address.
+pub fn prompt_contract_address() -> Result<String> {
+    Text::new("Contract address:")
+        .with_help_message("0x... address of the contract")
+        .with_validator(|input: &str| {
+            if !input.starts_with("0x") || input.len() != 42 {
+                Ok(Validation::Invalid(
+                    "Address must start with 0x and be 42 characters".into(),
+                ))
+            } else if !input[2..].chars().all(|c| c.is_ascii_hexdigit()) {
+                Ok(Validation::Invalid(
+                    "Address must contain only hex characters".into(),
+                ))
+            } else {
+                Ok(Validation::Valid)
+            }
+        })
+        .prompt()
+        .map_err(Into::into)
+}
+
+/// Prompt for the contract name.
+pub fn prompt_contract_name(default: Option<&str>) -> Result<String> {
+    let mut prompt = Text::new("Contract name:")
+        .with_help_message("Name for the contract (used in generated code)")
+        .with_validator(|input: &str| {
+            if input.trim().is_empty() {
+                Ok(Validation::Invalid("Contract name cannot be empty".into()))
+            } else {
+                Ok(Validation::Valid)
+            }
+        });
+
+    if let Some(d) = default {
+        prompt = prompt.with_default(d);
+    } else {
+        prompt = prompt.with_default("Contract");
+    }
+
+    Ok(prompt.prompt()?)
+}
+
+/// Prompt for the start block.
+pub fn prompt_start_block(default: Option<u64>) -> Result<Option<u64>> {
+    let default_str = default
+        .map(|b| b.to_string())
+        .unwrap_or_else(|| "0".to_string());
+
+    let input = Text::new("Start block:")
+        .with_help_message("Block number to start indexing from")
+        .with_default(&default_str)
+        .with_validator(|input: &str| {
+            if input.trim().is_empty() {
+                Ok(Validation::Valid)
+            } else if input.parse::<u64>().is_err() {
+                Ok(Validation::Invalid("Must be a valid block number".into()))
+            } else {
+                Ok(Validation::Valid)
+            }
+        })
+        .prompt()?;
+
+    if input.trim().is_empty() {
+        Ok(None)
+    } else {
+        Ok(input.parse().ok())
+    }
+}
+
+/// Prompt for whether to index events.
+pub fn prompt_index_events() -> Result<bool> {
+    Confirm::new("Index contract events as entities?")
+        .with_default(true)
+        .with_help_message("Generate entities for each event in the contract ABI")
+        .prompt()
+        .map_err(Into::into)
+}
+
+/// Prompt for whether to add another contract to the subgraph.
+pub fn prompt_add_another_contract(network: &str) -> Result<bool> {
+    Confirm::new(&format!("Add another contract from {}?", network))
+        .with_default(false)
+        .prompt()
+        .map_err(Into::into)
+}
+
+/// Prompt for the source type (contract, example, subgraph).
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum SourceType {
+    Contract,
+    Example,
+    // Subgraph support is not yet implemented
+}
+
+impl std::fmt::Display for SourceType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SourceType::Contract => write!(f, "Smart contract"),
+            SourceType::Example => write!(f, "Example subgraph"),
+        }
+    }
+}
+
+/// Prompt for the scaffold source type.
+pub fn prompt_source_type() -> Result<SourceType> {
+    let options = vec![SourceType::Contract, SourceType::Example];
+
+    Select::new("Source:", options)
+        .with_help_message("How to initialize the subgraph")
+        .prompt()
+        .map_err(Into::into)
+}
+
+/// Prompt for ABI file path.
+pub fn prompt_abi_path() -> Result<Option<String>> {
+    let has_abi = Confirm::new("Do you have an ABI file?")
+        .with_default(false)
+        .with_help_message("If not, we'll try to fetch it from Etherscan/Sourcify")
+        .prompt()?;
+
+    if has_abi {
+        let path = Text::new("ABI file path:")
+            .with_help_message("Path to the contract ABI JSON file")
+            .prompt()?;
+        Ok(Some(path))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Prompt for subgraph slug with graph-cli style confirmation output.
+///
+/// After the user enters a value, clears the prompt line and shows:
+/// `✔ Subgraph slug · <value>`
+pub fn prompt_subgraph_slug_with_confirm(default: Option<&str>) -> Result<String> {
+    let term = Term::stderr();
+    let mut prompt = Text::new("Subgraph slug")
+        .with_help_message("e.g., my-subgraph or myorg/my-subgraph")
+        .with_validator(|input: &str| {
+            if input.trim().is_empty() {
+                Ok(Validation::Invalid("Subgraph slug cannot be empty".into()))
+            } else {
+                Ok(Validation::Valid)
+            }
+        });
+
+    if let Some(d) = default {
+        prompt = prompt.with_default(d);
+    }
+
+    let name = prompt.prompt()?;
+    let formatted = format_subgraph_name(&name);
+
+    // Clear the previous line and print confirmation
+    let _ = term.clear_last_lines(1);
+    let label = "Subgraph slug";
+    println!(
+        "{} {} {} {}",
+        style("✔").green(),
+        label,
+        style("·").dim(),
+        formatted
+    );
+
+    Ok(formatted)
+}
+
+/// Prompt for directory with graph-cli style confirmation output.
+///
+/// After the user enters a value, clears the prompt line and shows:
+/// `✔ Directory to create the subgraph in · <value>`
+pub fn prompt_directory_with_confirm(default: Option<&str>) -> Result<String> {
+    let term = Term::stderr();
+    let mut prompt = Text::new("Directory to create the subgraph in")
+        .with_help_message("Directory name for the new subgraph")
+        .with_validator(|input: &str| {
+            if input.trim().is_empty() {
+                Ok(Validation::Invalid("Directory cannot be empty".into()))
+            } else {
+                Ok(Validation::Valid)
+            }
+        });
+
+    if let Some(d) = default {
+        prompt = prompt.with_default(d);
+    }
+
+    let dir = prompt.prompt()?;
+
+    // Clear the previous line and print confirmation
+    let _ = term.clear_last_lines(1);
+    let label = "Directory to create the subgraph in";
+    println!(
+        "{} {} {} {}",
+        style("✔").green(),
+        label,
+        style("·").dim(),
+        dir
+    );
+
+    Ok(dir)
+}
+
+/// Resolve directory collision by prompting for a new directory name.
+///
+/// If the given directory already exists, asks the user for an alternative
+/// directory name instead of failing with an error. Continues prompting
+/// until a non-existent directory is chosen.
+///
+/// Returns the resolved directory path as a String.
+pub fn resolve_directory_collision(initial_dir: &Path) -> Result<String> {
+    if !initial_dir.exists() {
+        return Ok(initial_dir.to_str().unwrap_or("subgraph").to_string());
+    }
+
+    // Directory exists, warn and prompt for a new name
+    eprintln!(
+        "{} Directory '{}' already exists",
+        style("!").yellow(),
+        initial_dir.display()
+    );
+
+    loop {
+        let dir = Text::new("Enter a different directory name:")
+            .with_help_message("Choose a directory that doesn't exist")
+            .with_validator(|input: &str| {
+                if input.trim().is_empty() {
+                    Ok(Validation::Invalid("Directory cannot be empty".into()))
+                } else {
+                    Ok(Validation::Valid)
+                }
+            })
+            .prompt()?;
+
+        let path = Path::new(&dir);
+        if path.exists() {
+            eprintln!(
+                "{} Directory '{}' also exists, please try another name",
+                style("!").yellow(),
+                dir
+            );
+        } else {
+            return Ok(dir);
+        }
+    }
+}
+
+/// Format a subgraph name to be valid.
+fn format_subgraph_name(name: &str) -> String {
+    name.trim()
+        .to_lowercase()
+        .chars()
+        .map(|c| {
+            if c.is_alphanumeric() || c == '-' || c == '/' {
+                c
+            } else {
+                '-'
+            }
+        })
+        .collect()
+}
+
+/// Extract the directory name from a subgraph name.
+pub fn get_subgraph_basename(name: &str) -> String {
+    name.split('/').next_back().unwrap_or(name).to_string()
+}
+
+/// Normalize a version label from either a flag or interactive prompt.
+pub fn normalize_version_label(label: &str) -> String {
+    label.trim_matches(|c| c == '"' || c == ' ').to_string()
+}
+
+/// Prompt for a version label for deployment.
+/// Uses CustomType instead of Text to normalize the input before validation
+pub fn prompt_version_label() -> Result<String> {
+    let parser: CustomTypeParser<String> = &|val| {
+        let normalized = normalize_version_label(val);
+        Ok(normalized)
+    };
+    let label = CustomType::<String>::new("Which version label to use? (e.g. v0.0.1):")
+        .with_parser(parser)
+        .with_validator(|input: &String| {
+            if input.is_empty() {
+                Ok(Validation::Invalid("Version label cannot be empty".into()))
+            } else {
+                Ok(Validation::Valid)
+            }
+        })
+        .prompt()?;
+
+    Ok(label)
+}
+
+/// Interactive init form for when options are not fully provided.
+pub struct InitForm {
+    pub network: String,
+    pub subgraph_name: String,
+    pub directory: String,
+    pub source_type: SourceType,
+    pub contract_address: Option<String>,
+    pub contract_name: String,
+    /// User-confirmed start block. May differ from the fetched default in
+    /// `contract_info` if the user modified it when prompted.
+    pub start_block: Option<u64>,
+    pub index_events: bool,
+    pub abi_path: Option<String>,
+    /// Cached contract info fetched during interactive prompts, to avoid
+    /// re-fetching. Primarily used for the ABI; the `start_block` here is
+    /// the original fetched value before user confirmation (use
+    /// `self.start_block` for the final value).
+    pub contract_info: Option<ContractInfo>,
+}
+
+impl InitForm {
+    /// Run the interactive form, filling in missing values.
+    ///
+    /// The flow for contract mode is:
+    /// 1. Prompt for network (if not provided)
+    /// 2. Prompt for contract address (if not provided)
+    /// 3. Fetch contract info from Etherscan/Sourcify (ABI, name, start block)
+    /// 4. Use fetched values as defaults for remaining prompts
+    #[allow(clippy::too_many_arguments)]
+    pub async fn run_interactive(
+        registry: &NetworksRegistry,
+        // Pre-filled values from CLI args
+        network: Option<String>,
+        subgraph_name: Option<String>,
+        directory: Option<String>,
+        from_contract: Option<String>,
+        from_example: bool,
+        contract_name: Option<String>,
+        start_block: Option<u64>,
+        index_events: bool,
+        abi_path: Option<String>,
+    ) -> Result<Self> {
+        // Determine source type from flags or prompt
+        let source_type = if from_contract.is_some() {
+            SourceType::Contract
+        } else if from_example {
+            SourceType::Example
+        } else {
+            prompt_source_type()?
+        };
+
+        // For example mode, we only need subgraph name and directory
+        if source_type == SourceType::Example {
+            let subgraph_name = match subgraph_name {
+                Some(n) => n,
+                None => prompt_subgraph_name(None)?,
+            };
+
+            let default_dir = get_subgraph_basename(&subgraph_name);
+            let directory = match directory {
+                Some(d) => d,
+                None => prompt_directory(Some(&default_dir))?,
+            };
+
+            return Ok(Self {
+                network: "mainnet".to_string(), // Not used for example
+                subgraph_name,
+                directory,
+                source_type,
+                contract_address: None,
+                contract_name: "Contract".to_string(),
+                start_block: None,
+                index_events: false,
+                abi_path: None,
+                contract_info: None,
+            });
+        }
+
+        // For contract mode, we need network, address, etc.
+
+        // Step 1: Network
+        let network = match network {
+            Some(n) => n,
+            None => prompt_network_interactive(registry)?,
+        };
+
+        // Step 2: Contract address
+        let contract_address = match from_contract {
+            Some(addr) => addr,
+            None => prompt_contract_address()?,
+        };
+
+        // Step 3: Fetch contract info immediately after getting address
+        // This allows us to use fetched values as defaults for remaining prompts
+        let fetched_info = if abi_path.is_none() {
+            fetch_contract_info_interactive(&network, &contract_address).await
+        } else {
+            None
+        };
+
+        // Step 4: Contract name (use fetched name as default)
+        let default_contract_name = fetched_info
+            .as_ref()
+            .map(|info| info.name.clone())
+            .or_else(|| contract_name.clone());
+        let contract_name = match contract_name {
+            Some(n) => n,
+            None => prompt_contract_name(default_contract_name.as_deref())?,
+        };
+
+        // Subgraph name
+        let default_subgraph_name = contract_name.to_lowercase();
+        let subgraph_name = match subgraph_name {
+            Some(n) => n,
+            None => prompt_subgraph_name(Some(&default_subgraph_name))?,
+        };
+
+        // Directory
+        let default_dir = get_subgraph_basename(&subgraph_name);
+        let directory = match directory {
+            Some(d) => d,
+            None => prompt_directory(Some(&default_dir))?,
+        };
+
+        // ABI path - only prompt if we didn't fetch it successfully
+        let abi_path = match abi_path {
+            Some(p) => Some(p),
+            None => {
+                if fetched_info.is_some() {
+                    // We successfully fetched the ABI, no need to prompt
+                    None
+                } else {
+                    prompt_abi_path()?
+                }
+            }
+        };
+
+        // Start block (use fetched start block as default)
+        let default_start_block = fetched_info
+            .as_ref()
+            .and_then(|info| info.start_block)
+            .or(start_block);
+        let start_block = if start_block.is_some() {
+            start_block
+        } else {
+            prompt_start_block(default_start_block)?
+        };
+
+        // Index events
+        let index_events = if index_events {
+            true
+        } else {
+            prompt_index_events()?
+        };
+
+        Ok(Self {
+            network,
+            subgraph_name,
+            directory,
+            source_type,
+            contract_address: Some(contract_address),
+            contract_name,
+            start_block,
+            index_events,
+            abi_path,
+            contract_info: fetched_info,
+        })
+    }
+}
+
+/// Fetch contract info from Etherscan/Sourcify with status feedback.
+///
+/// Returns None if fetching fails (the prompts will fall back to manual entry).
+async fn fetch_contract_info_interactive(network: &str, address: &str) -> Option<ContractInfo> {
+    step(
+        Step::Load,
+        &format!("Fetching contract info for {} on {}", address, network),
+    );
+
+    // Load the contract service
+    let service = match ContractService::load().await {
+        Ok(s) => s,
+        Err(e) => {
+            step(
+                Step::Warn,
+                &format!("Could not load contract service: {}", e),
+            );
+            return None;
+        }
+    };
+
+    // Fetch the contract info
+    match service.get_contract_info(network, address).await {
+        Ok(info) => {
+            step(Step::Done, &format!("Found contract: {}", info.name));
+            Some(info)
+        }
+        Err(e) => {
+            step(
+                Step::Warn,
+                &format!(
+                    "Could not fetch contract info: {}. You'll need to provide an ABI file.",
+                    e
+                ),
+            );
+            None
+        }
+    }
+}
+
+/// Prompt for network selection using the simple completer.
+fn prompt_network_interactive(registry: &NetworksRegistry) -> Result<String> {
+    let completer = SimpleNetworkCompleter::new(registry);
+
+    let input = Text::new("Network:")
+        .with_autocomplete(completer)
+        .with_help_message("Type to search (mainnet, polygon, arbitrum-one, etc.)")
+        .prompt()?;
+
+    // Extract network ID from the selection
+    // Format is "Full Name (id)"
+    if let Some(start) = input.rfind('(')
+        && let Some(end) = input.rfind(')')
+    {
+        let id = &input[start + 1..end];
+        if registry.get_network(id).is_some() {
+            return Ok(id.to_string());
+        }
+    }
+
+    // Try the input as-is
+    if registry.get_network(&input).is_some() {
+        return Ok(input);
+    }
+
+    anyhow::bail!(
+        "Network '{}' not found in registry. Check available networks at https://thegraph.com/docs/en/supported-networks/",
+        input
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_format_subgraph_name() {
+        assert_eq!(format_subgraph_name("My Subgraph"), "my-subgraph");
+        assert_eq!(format_subgraph_name("org/my-subgraph"), "org/my-subgraph");
+        assert_eq!(format_subgraph_name("  test  "), "test");
+        assert_eq!(format_subgraph_name("Test_123"), "test-123");
+        assert_eq!(format_subgraph_name("a/b/c"), "a/b/c");
+    }
+
+    #[test]
+    fn test_get_subgraph_basename() {
+        assert_eq!(get_subgraph_basename("my-subgraph"), "my-subgraph");
+        assert_eq!(get_subgraph_basename("org/my-subgraph"), "my-subgraph");
+        assert_eq!(get_subgraph_basename("a/b/c"), "c");
+        assert_eq!(get_subgraph_basename(""), "");
+    }
+
+    #[test]
+    fn test_normalize_version_label() {
+        assert_eq!(normalize_version_label("v1.0.0"), "v1.0.0");
+        assert_eq!(normalize_version_label("  v1.0.0  "), "v1.0.0");
+        assert_eq!(normalize_version_label("\"v1.0.0\""), "v1.0.0");
+        assert_eq!(normalize_version_label(" \"v1.0.0\" "), "v1.0.0");
+        assert_eq!(normalize_version_label("v1.0.0-beta"), "v1.0.0-beta");
+        assert_eq!(normalize_version_label(" my version "), "my version");
+    }
+
+    #[test]
+    fn test_format_network() {
+        let network = Network {
+            id: "mainnet".to_string(),
+            short_name: Some("Ethereum".to_string()),
+            full_name: Some("Ethereum Mainnet".to_string()),
+            aliases: vec!["ethereum".to_string()],
+            caip2_id: "eip155:1".to_string(),
+            api_urls: vec![],
+            rpc_urls: vec![],
+        };
+        assert_eq!(format_network(&network), "Ethereum Mainnet (mainnet)");
+
+        let network_no_full_name = Network {
+            id: "custom".to_string(),
+            short_name: None,
+            full_name: None,
+            aliases: vec![],
+            caip2_id: "eip155:999".to_string(),
+            api_urls: vec![],
+            rpc_urls: vec![],
+        };
+        assert_eq!(format_network(&network_no_full_name), "custom (custom)");
+    }
+
+    #[test]
+    fn test_source_type_display() {
+        assert_eq!(SourceType::Contract.to_string(), "Smart contract");
+        assert_eq!(SourceType::Example.to_string(), "Example subgraph");
+    }
+
+    #[test]
+    fn test_simple_network_completer() {
+        let registry = NetworksRegistry {
+            networks: vec![
+                Network {
+                    id: "mainnet".to_string(),
+                    short_name: Some("Ethereum".to_string()),
+                    full_name: Some("Ethereum Mainnet".to_string()),
+                    aliases: vec!["ethereum".to_string(), "eth".to_string()],
+                    caip2_id: "eip155:1".to_string(),
+                    api_urls: vec![],
+                    rpc_urls: vec![],
+                },
+                Network {
+                    id: "polygon".to_string(),
+                    short_name: Some("Polygon".to_string()),
+                    full_name: Some("Polygon Mainnet".to_string()),
+                    aliases: vec!["matic".to_string()],
+                    caip2_id: "eip155:137".to_string(),
+                    api_urls: vec![],
+                    rpc_urls: vec![],
+                },
+            ],
+        };
+
+        let mut completer = SimpleNetworkCompleter::new(&registry);
+
+        // Test suggestions for "mainnet" (exact ID match)
+        let suggestions = completer.get_suggestions("mainnet").unwrap();
+        assert!(!suggestions.is_empty());
+        assert!(suggestions[0].contains("Ethereum Mainnet"));
+
+        // Test suggestions for "eth" (matches "ethereum" alias)
+        let suggestions = completer.get_suggestions("eth").unwrap();
+        assert!(!suggestions.is_empty());
+        // Should match the network with "ethereum" in aliases
+        assert!(suggestions.iter().any(|s| s.contains("Ethereum")));
+
+        // Test suggestions for "matic" (only matches polygon)
+        let suggestions = completer.get_suggestions("matic").unwrap();
+        assert_eq!(suggestions.len(), 1);
+        assert!(suggestions[0].contains("Polygon"));
+
+        // Test suggestions for empty string (should return all)
+        let suggestions = completer.get_suggestions("").unwrap();
+        assert_eq!(suggestions.len(), 2);
+
+        // Test no matches
+        let suggestions = completer.get_suggestions("nonexistent").unwrap();
+        assert!(suggestions.is_empty());
+    }
+}
diff --git a/gnd/src/scaffold/manifest.rs b/gnd/src/scaffold/manifest.rs
new file mode 100644
index 00000000000..b0b731ff4be
--- /dev/null
+++ b/gnd/src/scaffold/manifest.rs
@@ -0,0 +1,416 @@
+//! Manifest (subgraph.yaml) generation for scaffold.
+
+use std::collections::HashMap;
+
+use super::ScaffoldOptions;
+use crate::shared::handle_reserved_word;
+
+/// Generate the subgraph.yaml manifest content.
+pub fn generate_manifest(options: &ScaffoldOptions) -> String {
+    let contract_name = &options.contract_name;
+    let network = &options.network;
+    let mapping_file = format!("./src/{}.ts", super::to_kebab_case(contract_name));
+    let abi_file = format!("./abis/{}.json", contract_name);
+
+    let mut source = String::new();
+
+    if let Some(address) = &options.address {
+        source.push_str(&format!("      address: \"{}\"\n", address));
+    }
+
+    source.push_str(&format!("      abi: {contract_name}\n"));
+
+    if let Some(start_block) = options.start_block {
+        source.push_str(&format!("      startBlock: {}\n", start_block));
+    }
+
+    // Resolve events once (disambiguating overloaded names) so the handlers and
+    // entities lists stay consistent.
+    let events = disambiguate_events(extract_events_from_abi(options));
+    let event_handlers = get_event_handlers(contract_name, &events);
+
+    format!(
+        r#"specVersion: {spec_version}
+indexerHints:
+  prune: auto
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum
+    name: {contract_name}
+    network: {network}
+    source:
+{source}    mapping:
+      kind: ethereum/events
+      apiVersion: {api_version}
+      language: wasm/assemblyscript
+      entities:{entities}
+      abis:
+        - name: {contract_name}
+          file: {abi_file}
+      eventHandlers:{event_handlers}
+      file: {mapping_file}
+"#,
+        spec_version = super::SPEC_VERSION,
+        api_version = super::MAPPING_API_VERSION,
+        entities = get_entities(&events),
+    )
+}
+
+/// Get event handlers for the manifest.
+fn get_event_handlers(contract_name: &str, events: &[ResolvedEvent]) -> String {
+    if events.is_empty() {
+        // Default placeholder handler
+        return format!(
+            r#"
+        - event: ExampleEvent(indexed address,uint256)
+          handler: handle{contract_name}ExampleEvent"#
+        );
+    }
+
+    let mut handlers = String::new();
+    for event in events {
+        handlers.push_str(&format!(
+            "\n        - event: {}\n          handler: handle{}",
+            event.event.signature, event.alias
+        ));
+    }
+
+    handlers
+}
+
+/// Get entities list for the manifest.
+fn get_entities(events: &[ResolvedEvent]) -> String {
+    if events.is_empty() {
+        return "\n        - ExampleEntity".to_string();
+    }
+
+    let mut entities = String::new();
+    for event in events {
+        entities.push_str(&format!("\n        - {}", event.entity_name));
+    }
+    entities
+}
+
+/// Event info extracted from ABI.
+#[derive(Debug, Clone)]
+pub struct EventInfo {
+    pub name: String,
+    pub signature: String,
+    pub inputs: Vec<EventInput>,
+}
+
+/// An event resolved to the concrete names the generators render.
+///
+/// Decided once (here / by collision resolution) so the schema, mapping and
+/// manifest generators never derive names independently:
+/// - `alias` names the handler function and the ABI event-type import; it is
+///   disambiguated for events overloaded within a single ABI.
+/// - `entity_name` names the GraphQL entity type, the `new` expression and the
+///   schema import; it gains a contract prefix when it collides with an entity
+///   that already exists in the subgraph.
+/// - `declare_in_schema` is false when the event reuses an entity that already
+///   exists (a merge), so the type must not be redeclared.
+#[derive(Debug, Clone)]
+pub struct ResolvedEvent {
+    pub event: EventInfo,
+    pub alias: String,
+    pub entity_name: String,
+    pub declare_in_schema: bool,
+}
+
+/// Resolve events for a fresh scaffold, disambiguating names that are overloaded
+/// within one ABI by suffixing repeats (`Transfer`, `Transfer1`, ...). There are
+/// no existing entities to collide with, so each entity is declared as-is.
+pub fn disambiguate_events(events: Vec<EventInfo>) -> Vec<ResolvedEvent> {
+    let mut seen: HashMap<String, usize> = HashMap::new();
+    events
+        .into_iter()
+        .map(|event| {
+            let count = seen.entry(event.name.clone()).or_insert(0);
+            let alias = if *count == 0 {
+                event.name.clone()
+            } else {
+                format!("{}{}", event.name, count)
+            };
+            *count += 1;
+            let entity_name = alias.clone();
+            ResolvedEvent {
+                event,
+                alias,
+                entity_name,
+                declare_in_schema: true,
+            }
+        })
+        .collect()
+}
+
+/// The `event.params.<name>` accessor for each input, mirroring the names the
+/// ABI codegen gives the generated getters: reserved words are escaped and
+/// unnamed params become `param<index>`, with a counter for any collisions.
+/// Keeps the mapping's right-hand side in sync with the generated bindings.
+pub fn event_param_accessors(inputs: &[EventInput]) -> Vec<String> {
+    let mut seen: HashMap<String, u32> = HashMap::new();
+    inputs
+        .iter()
+        .enumerate()
+        .map(|(index, input)| {
+            let base = if input.name.is_empty() {
+                format!("param{index}")
+            } else {
+                handle_reserved_word(&input.name)
+            };
+            let count = seen.entry(base.clone()).or_insert(0);
+            let name = if *count == 0 {
+                base.clone()
+            } else {
+                format!("{base}{count}")
+            };
+            *count += 1;
+            name
+        })
+        .collect()
+}
+
+/// Event input parameter.
+#[derive(Debug, Clone)]
+pub struct EventInput {
+    pub name: String,
+    pub solidity_type: String,
+    pub indexed: bool,
+}
+
+/// Extract events from ABI JSON.
+pub fn extract_events_from_abi(options: &ScaffoldOptions) -> Vec<EventInfo> {
+    let Some(abi) = &options.abi else {
+        return vec![];
+    };
+
+    let Some(items) = abi.as_array() else {
+        return vec![];
+    };
+
+    let mut events = Vec::new();
+
+    for item in items {
+        if item.get("type").and_then(|t| t.as_str()) != Some("event") {
+            continue;
+        }
+
+        let Some(name) = item.get("name").and_then(|n| n.as_str()) else {
+            continue;
+        };
+
+        let inputs = item
+            .get("inputs")
+            .and_then(|i| i.as_array())
+            .map(|arr| {
+                arr.iter()
+                    .filter_map(|input| {
+                        let name = input.get("name").and_then(|n| n.as_str())?.to_string();
+                        let solidity_type = input.get("type").and_then(|t| t.as_str())?.to_string();
+                        let indexed = input
+                            .get("indexed")
+                            .and_then(|i| i.as_bool())
+                            .unwrap_or(false);
+                        Some(EventInput {
+                            name,
+                            solidity_type,
+                            indexed,
+                        })
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+
+        let signature = format_event_signature(name, &inputs);
+
+        events.push(EventInfo {
+            name: name.to_string(),
+            signature,
+            inputs,
+        });
+    }
+
+    events
+}
+
+/// Format an event signature string.
+fn format_event_signature(name: &str, inputs: &[EventInput]) -> String {
+    let params: Vec<String> = inputs
+        .iter()
+        .map(|input| {
+            if input.indexed {
+                format!("indexed {}", input.solidity_type)
+            } else {
+                input.solidity_type.clone()
+            }
+        })
+        .collect();
+
+    format!("{}({})", name, params.join(","))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_generate_manifest_minimal() {
+        let options = ScaffoldOptions::default();
+        let manifest = generate_manifest(&options);
+
+        assert!(manifest.contains("specVersion: 1.3.0"));
+        assert!(manifest.contains("kind: ethereum"));
+        assert!(manifest.contains("network: mainnet"));
+        assert!(manifest.contains("kind: ethereum/events"));
+    }
+
+    #[test]
+    fn test_generate_manifest_with_address() {
+        let options = ScaffoldOptions {
+            address: Some("0x1234567890123456789012345678901234567890".to_string()),
+            network: "goerli".to_string(),
+            contract_name: "MyToken".to_string(),
+            start_block: Some(12345678),
+            ..Default::default()
+        };
+
+        let manifest = generate_manifest(&options);
+
+        assert!(manifest.contains("network: goerli"));
+        assert!(manifest.contains("name: MyToken"));
+        assert!(manifest.contains("0x1234567890123456789012345678901234567890"));
+        assert!(manifest.contains("startBlock: 12345678"));
+
+        // Verify address comes before abi
+        let address_pos = manifest.find("address:").unwrap();
+        let abi_pos = manifest.find("abi: MyToken").unwrap();
+        assert!(address_pos < abi_pos, "address should come before abi");
+    }
+
+    #[test]
+    fn test_get_entities_uses_event_names() {
+        let abi = json!([
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": []
+            },
+            {
+                "type": "event",
+                "name": "Approval",
+                "inputs": []
+            }
+        ]);
+
+        // Even with index_events=false, entities should be event names
+        let options = ScaffoldOptions {
+            abi: Some(abi),
+            index_events: false,
+            ..Default::default()
+        };
+
+        let manifest = generate_manifest(&options);
+        assert!(manifest.contains("- Transfer"));
+        assert!(manifest.contains("- Approval"));
+        // Should NOT contain ExampleEntity
+        assert!(!manifest.contains("ExampleEntity"));
+    }
+
+    #[test]
+    fn test_event_handlers_no_blank_lines() {
+        let abi = json!([
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": []
+            },
+            {
+                "type": "event",
+                "name": "Approval",
+                "inputs": []
+            }
+        ]);
+
+        let options = ScaffoldOptions {
+            abi: Some(abi),
+            ..Default::default()
+        };
+
+        let manifest = generate_manifest(&options);
+
+        // Check there are no double newlines in the eventHandlers section
+        assert!(!manifest.contains("handler: handleTransfer\n\n"));
+    }
+
+    #[test]
+    fn test_extract_events_from_abi() {
+        let abi = json!([
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": [
+                    {"name": "from", "type": "address", "indexed": true},
+                    {"name": "to", "type": "address", "indexed": true},
+                    {"name": "value", "type": "uint256", "indexed": false}
+                ]
+            },
+            {
+                "type": "function",
+                "name": "transfer"
+            }
+        ]);
+
+        let options = ScaffoldOptions {
+            abi: Some(abi),
+            ..Default::default()
+        };
+
+        let events = extract_events_from_abi(&options);
+        assert_eq!(events.len(), 1);
+        assert_eq!(events[0].name, "Transfer");
+        assert_eq!(
+            events[0].signature,
+            "Transfer(indexed address,indexed address,uint256)"
+        );
+        assert_eq!(events[0].inputs.len(), 3);
+    }
+
+    #[test]
+    fn test_format_event_signature() {
+        let inputs = vec![
+            EventInput {
+                name: "from".to_string(),
+                solidity_type: "address".to_string(),
+                indexed: true,
+            },
+            EventInput {
+                name: "value".to_string(),
+                solidity_type: "uint256".to_string(),
+                indexed: false,
+            },
+        ];
+
+        let sig = format_event_signature("Transfer", &inputs);
+        assert_eq!(sig, "Transfer(indexed address,uint256)");
+    }
+
+    #[test]
+    fn test_disambiguate_events() {
+        let ev = |name: &str| EventInfo {
+            name: name.to_string(),
+            signature: format!("{}()", name),
+            inputs: vec![],
+        };
+        let resolved = disambiguate_events(vec![ev("Transfer"), ev("Transfer"), ev("Approval")]);
+        // Repeated names are suffixed; the first occurrence is unchanged.
+        assert_eq!(resolved[0].alias, "Transfer");
+        assert_eq!(resolved[0].entity_name, "Transfer");
+        assert_eq!(resolved[1].alias, "Transfer1");
+        assert_eq!(resolved[1].entity_name, "Transfer1");
+        assert_eq!(resolved[2].alias, "Approval");
+        assert!(resolved.iter().all(|r| r.declare_in_schema));
+    }
+}
diff --git a/gnd/src/scaffold/mapping.rs b/gnd/src/scaffold/mapping.rs
new file mode 100644
index 00000000000..8749c91ab2b
--- /dev/null
+++ b/gnd/src/scaffold/mapping.rs
@@ -0,0 +1,438 @@
+//! Mapping (AssemblyScript) generation for scaffold.
+
+use super::ScaffoldOptions;
+use super::manifest::{EventInfo, ResolvedEvent, extract_events_from_abi};
+use super::sanitize_field_name;
+
+/// Generate the mapping.ts content.
+pub fn generate_mapping(options: &ScaffoldOptions) -> String {
+    let events = extract_events_from_abi(options);
+    let contract_name = &options.contract_name;
+
+    if events.is_empty() {
+        return generate_fallback_mapping(contract_name);
+    }
+
+    if !options.index_events {
+        return generate_placeholder_mapping(contract_name, &events, options);
+    }
+
+    let resolved = super::disambiguate_events(events);
+    generate_event_handlers(contract_name, &resolved)
+}
+
+/// Generate a fallback mapping when no events are found in ABI.
+fn generate_fallback_mapping(contract_name: &str) -> String {
+    format!(
+        r#"import {{ BigInt, Bytes }} from "@graphprotocol/graph-ts"
+import {{ ExampleEvent as ExampleEventEvent }} from "../generated/{contract_name}/{contract_name}"
+import {{ ExampleEntity }} from "../generated/schema"
+
+export function handle{contract_name}ExampleEvent(event: ExampleEventEvent): void {{
+  let entity = ExampleEntity.load(
+    event.transaction.hash.concat(Bytes.fromByteArray(Bytes.fromBigInt(event.logIndex)))
+  )
+
+  if (!entity) {{
+    entity = new ExampleEntity(
+      event.transaction.hash.concat(Bytes.fromByteArray(Bytes.fromBigInt(event.logIndex)))
+    )
+    entity.count = BigInt.fromI32(0)
+  }}
+
+  entity.count = entity.count + BigInt.fromI32(1)
+  entity.save()
+}}
+"#
+    )
+}
+
+/// Generate placeholder mapping when events are found but index_events is false.
+fn generate_placeholder_mapping(
+    contract_name: &str,
+    events: &[EventInfo],
+    options: &ScaffoldOptions,
+) -> String {
+    let resolved = super::disambiguate_events(events.to_vec());
+
+    let mut output = String::new();
+
+    // Import graph-ts types
+    output.push_str("import {\n  BigInt,\n  Bytes\n} from \"@graphprotocol/graph-ts\"\n");
+
+    // Import contract class and all events (by disambiguated alias).
+    output.push_str(&format!("import {{\n  {contract_name},\n"));
+    for (i, event) in resolved.iter().enumerate() {
+        let suffix = if i < resolved.len() - 1 { ",\n" } else { "\n" };
+        output.push_str(&format!(
+            "  {} as {}Event{}",
+            event.alias, event.alias, suffix
+        ));
+    }
+    output.push_str(&format!(
+        "}} from \"../generated/{contract_name}/{contract_name}\"\n"
+    ));
+
+    // Import entity
+    output.push_str("import { ExampleEntity } from \"../generated/schema\"\n");
+
+    // Generate first handler with full example code
+    output.push_str(&generate_first_placeholder_handler(
+        &resolved[0],
+        contract_name,
+        options,
+    ));
+
+    // Generate empty stub handlers for remaining events
+    for event in resolved.iter().skip(1) {
+        output.push_str(&format!(
+            "\nexport function handle{}(event: {}Event): void {{}}\n",
+            event.alias, event.alias
+        ));
+    }
+
+    output
+}
+
+/// Generate the first handler with full example code.
+fn generate_first_placeholder_handler(
+    event: &ResolvedEvent,
+    contract_name: &str,
+    options: &ScaffoldOptions,
+) -> String {
+    let event_name = &event.alias;
+
+    // Generate field assignments for first 2 event params
+    let mut field_assignments = String::new();
+    let accessors = super::event_param_accessors(&event.event.inputs);
+    for (input, accessor) in event.event.inputs.iter().zip(&accessors).take(2) {
+        let field_name = sanitize_field_name(&input.name);
+        field_assignments.push_str(&format!(
+            "  entity.{} = event.params.{}\n",
+            field_name, accessor
+        ));
+    }
+
+    // Extract callable functions from ABI for comments
+    let callable_functions = extract_callable_functions(options);
+
+    format!(
+        r#"
+export function handle{event_name}(event: {event_name}Event): void {{
+  // Entities can be loaded from the store using their id; using 'Bytes' as
+  // the id type is more efficient than 'ID' or 'String' and should be used
+  // whenever possible.
+  const id = event.transaction.hash.concat(
+    Bytes.fromByteArray(Bytes.fromBigInt(event.logIndex))
+  )
+  let entity = ExampleEntity.load(id)
+
+  // Entities only exist after they have been saved to the store;
+  // `null` checks allow to create entities on demand
+  if (!entity) {{
+    entity = new ExampleEntity(id)
+
+    // Entity fields can be set using simple assignments
+    entity.count = BigInt.fromI32(0)
+  }}
+
+  // BigInt and BigDecimal math are supported
+  entity.count = entity.count + BigInt.fromI32(1)
+
+  // Entity fields can be set based on event parameters
+{field_assignments}
+  entity.save()
+
+  // It is also possible to access smart contracts from mappings. For
+  // example, the contract that has emitted the event can be connected to
+  // with:
+  //
+  // let contract = {contract_name}.bind(event.address)
+  //
+  // The following functions can then be called on this contract to access
+  // state variables and other data:
+  //{callable_functions}
+}}
+"#
+    )
+}
+
+/// Generate event handlers for all resolved events.
+pub fn generate_event_handlers(contract_name: &str, events: &[ResolvedEvent]) -> String {
+    let mut imports = String::from("import { BigInt, Bytes } from \"@graphprotocol/graph-ts\"\n");
+
+    if events.is_empty() {
+        return imports;
+    }
+
+    // Import event types (by ABI alias).
+    let event_imports: Vec<String> = events
+        .iter()
+        .map(|e| format!("{} as {}Event", e.alias, e.alias))
+        .collect();
+
+    imports.push_str(&format!(
+        "import {{ {} }} from \"../generated/{}/{}\"\n",
+        event_imports.join(", "),
+        contract_name,
+        contract_name
+    ));
+
+    // Import entity types.
+    let entity_imports: Vec<String> = events.iter().map(|e| e.entity_name.clone()).collect();
+
+    imports.push_str(&format!(
+        "import {{ {} }} from \"../generated/schema\"\n",
+        entity_imports.join(", ")
+    ));
+
+    // Generate handler for each event.
+    let mut handlers = String::new();
+    for event in events {
+        handlers.push('\n');
+        handlers.push_str(&generate_single_handler(event));
+    }
+
+    format!("{}\n{}", imports, handlers)
+}
+
+/// Generate a handler function for a single resolved event.
+fn generate_single_handler(resolved: &ResolvedEvent) -> String {
+    let alias = &resolved.alias;
+    let entity_name = &resolved.entity_name;
+
+    // Generate field assignments from event parameters. The accessor mirrors the
+    // generated binding getter (escaped reserved words, param<index> for unnamed).
+    let mut field_assignments = String::new();
+    let accessors = super::event_param_accessors(&resolved.event.inputs);
+    for (input, accessor) in resolved.event.inputs.iter().zip(&accessors) {
+        let field_name = sanitize_field_name(&input.name);
+        field_assignments.push_str(&format!(
+            "  entity.{} = event.params.{}\n",
+            field_name, accessor
+        ));
+    }
+
+    format!(
+        r#"export function handle{alias}(event: {alias}Event): void {{
+  let entity = new {entity_name}(
+    event.transaction.hash.concatI32(event.logIndex.toI32())
+  )
+
+{field_assignments}  entity.blockNumber = event.block.number
+  entity.blockTimestamp = event.block.timestamp
+  entity.transactionHash = event.transaction.hash
+
+  entity.save()
+}}
+"#
+    )
+}
+
+/// Extract callable functions from ABI for documentation comments.
+fn extract_callable_functions(options: &ScaffoldOptions) -> String {
+    let Some(abi) = &options.abi else {
+        return "\n  // - None found".to_string();
+    };
+
+    let Some(items) = abi.as_array() else {
+        return "\n  // - None found".to_string();
+    };
+
+    let mut functions = Vec::new();
+
+    for item in items {
+        let item_type = item.get("type").and_then(|t| t.as_str());
+
+        // Include functions that are view/pure (callable without state change)
+        if item_type == Some("function") {
+            let state = item
+                .get("stateMutability")
+                .and_then(|s| s.as_str())
+                .unwrap_or("");
+
+            // Only include view and pure functions (callable from mappings)
+            if (state == "view" || state == "pure")
+                && let Some(name) = item.get("name").and_then(|n| n.as_str())
+            {
+                functions.push(format!("\n  // - contract.{}(...)", name));
+            }
+        }
+    }
+
+    if functions.is_empty() {
+        "\n  //\n  // - None".to_string()
+    } else {
+        functions.join("")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_generate_fallback_mapping() {
+        let mapping = generate_fallback_mapping("MyContract");
+
+        assert!(mapping.contains("handleMyContractExampleEvent"));
+        assert!(mapping.contains("ExampleEntity"));
+        assert!(mapping.contains("@graphprotocol/graph-ts"));
+        // Check for the correct ID pattern
+        assert!(mapping.contains("Bytes.fromByteArray(Bytes.fromBigInt(event.logIndex))"));
+    }
+
+    #[test]
+    fn test_generate_placeholder_mapping_with_events() {
+        let abi = json!([
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": [
+                    {"name": "from", "type": "address", "indexed": true},
+                    {"name": "to", "type": "address", "indexed": true},
+                    {"name": "value", "type": "uint256", "indexed": false}
+                ]
+            },
+            {
+                "type": "event",
+                "name": "Approval",
+                "inputs": [
+                    {"name": "owner", "type": "address", "indexed": true},
+                    {"name": "spender", "type": "address", "indexed": true},
+                    {"name": "value", "type": "uint256", "indexed": false}
+                ]
+            },
+            {
+                "type": "function",
+                "name": "balanceOf",
+                "stateMutability": "view",
+                "inputs": [{"name": "owner", "type": "address"}]
+            }
+        ]);
+
+        let options = ScaffoldOptions {
+            contract_name: "Token".to_string(),
+            abi: Some(abi),
+            index_events: false, // placeholder mode
+            ..Default::default()
+        };
+
+        let mapping = generate_mapping(&options);
+
+        // Check imports
+        assert!(mapping.contains("Token,"));
+        assert!(mapping.contains("Transfer as TransferEvent"));
+        assert!(mapping.contains("Approval as ApprovalEvent"));
+        assert!(mapping.contains("ExampleEntity"));
+
+        // First handler has full implementation
+        assert!(mapping.contains("export function handleTransfer(event: TransferEvent): void {"));
+        assert!(mapping.contains("entity.from = event.params.from"));
+        assert!(mapping.contains("entity.to = event.params.to"));
+        // Check for correct ID pattern
+        assert!(mapping.contains("Bytes.fromByteArray(Bytes.fromBigInt(event.logIndex))"));
+        // Check for callable functions comment
+        assert!(mapping.contains("contract.balanceOf(...)"));
+
+        // Second handler is empty stub
+        assert!(mapping.contains("export function handleApproval(event: ApprovalEvent): void {}"));
+    }
+
+    #[test]
+    fn test_generate_mapping_with_events() {
+        let abi = json!([
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": [
+                    {"name": "from", "type": "address", "indexed": true},
+                    {"name": "to", "type": "address", "indexed": true},
+                    {"name": "value", "type": "uint256", "indexed": false}
+                ]
+            }
+        ]);
+
+        let options = ScaffoldOptions {
+            contract_name: "Token".to_string(),
+            abi: Some(abi),
+            index_events: true,
+            ..Default::default()
+        };
+
+        let mapping = generate_mapping(&options);
+
+        assert!(mapping.contains("handleTransfer"));
+        assert!(mapping.contains("Transfer as TransferEvent"));
+        assert!(mapping.contains("event.params.from"));
+        assert!(mapping.contains("event.params.to"));
+        assert!(mapping.contains("event.params.value"));
+    }
+
+    #[test]
+    fn test_extract_callable_functions() {
+        let abi = json!([
+            {
+                "type": "function",
+                "name": "balanceOf",
+                "stateMutability": "view"
+            },
+            {
+                "type": "function",
+                "name": "totalSupply",
+                "stateMutability": "pure"
+            },
+            {
+                "type": "function",
+                "name": "transfer",
+                "stateMutability": "nonpayable"
+            }
+        ]);
+
+        let options = ScaffoldOptions {
+            abi: Some(abi),
+            ..Default::default()
+        };
+
+        let functions = extract_callable_functions(&options);
+        assert!(functions.contains("balanceOf"));
+        assert!(functions.contains("totalSupply"));
+        // transfer is nonpayable, should not be included
+        assert!(!functions.contains("transfer"));
+    }
+
+    #[test]
+    fn test_generate_mapping_reserved_and_unnamed_params() {
+        let abi = json!([
+            {
+                "type": "event",
+                "name": "Act",
+                "inputs": [
+                    {"name": "new", "type": "uint256", "indexed": false},
+                    {"name": "", "type": "address", "indexed": false}
+                ]
+            }
+        ]);
+
+        let options = ScaffoldOptions {
+            contract_name: "RW".to_string(),
+            abi: Some(abi),
+            index_events: true,
+            ..Default::default()
+        };
+
+        let mapping = generate_mapping(&options);
+        // The RHS must match the generated getter: `new` -> `new_`, unnamed -> `param1`.
+        assert!(
+            mapping.contains("event.params.new_"),
+            "reserved param accessor should be escaped, got:\n{}",
+            mapping
+        );
+        assert!(
+            mapping.contains("event.params.param1"),
+            "unnamed param accessor should be param<index>, got:\n{}",
+            mapping
+        );
+    }
+}
diff --git a/gnd/src/scaffold/mod.rs b/gnd/src/scaffold/mod.rs
new file mode 100644
index 00000000000..72cb5d70a37
--- /dev/null
+++ b/gnd/src/scaffold/mod.rs
@@ -0,0 +1,288 @@
+//! Scaffold generation for new subgraphs.
+//!
+//! This module provides functionality to generate the scaffolding files for a new
+//! subgraph project, including manifest, schema, mappings, and configuration files.
+
+pub mod manifest;
+mod mapping;
+mod naming;
+mod schema;
+
+pub use manifest::{
+    EventInfo, EventInput, ResolvedEvent, disambiguate_events, event_param_accessors,
+    extract_events_from_abi, generate_manifest,
+};
+pub use mapping::{generate_event_handlers, generate_mapping};
+pub(crate) use naming::sanitize_field_name;
+pub use schema::{generate_event_entity, generate_schema};
+
+use std::fs;
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+use anyhow::{Context, Result, anyhow};
+use inflector::Inflector;
+use serde_json::Value as JsonValue;
+
+use crate::formatter::format_typescript;
+use crate::output::{Step, step, with_spinner};
+
+/// Options for scaffold generation.
+#[derive(Debug, Clone)]
+pub struct ScaffoldOptions {
+    /// Contract address
+    pub address: Option<String>,
+    /// Network name
+    pub network: String,
+    /// Contract name
+    pub contract_name: String,
+    /// Subgraph name
+    pub subgraph_name: String,
+    /// Start block for indexing
+    pub start_block: Option<u64>,
+    /// Contract ABI as JSON
+    pub abi: Option<JsonValue>,
+    /// Whether to index all events
+    pub index_events: bool,
+}
+
+impl Default for ScaffoldOptions {
+    fn default() -> Self {
+        Self {
+            address: None,
+            network: "mainnet".to_string(),
+            contract_name: "Contract".to_string(),
+            subgraph_name: "my-subgraph".to_string(),
+            start_block: None,
+            abi: None,
+            index_events: false,
+        }
+    }
+}
+
+/// Graph-ts and graph-cli versions for package.json.
+const GRAPH_CLI_VERSION: &str = "0.98.0";
+const GRAPH_TS_VERSION: &str = "0.37.0";
+const MATCHSTICK_VERSION: &str = "0.6.0";
+
+/// Manifest format versions emitted by the scaffolder.
+pub(crate) const SPEC_VERSION: &str = "1.3.0";
+pub(crate) const MAPPING_API_VERSION: &str = "0.0.9";
+
+/// Generate all scaffold files and write to directory.
+pub fn generate_scaffold(dir: &Path, options: &ScaffoldOptions) -> Result<()> {
+    step(Step::Generate, "Generating scaffold files");
+
+    // Create directory structure
+    fs::create_dir_all(dir).context("Failed to create project directory")?;
+    fs::create_dir_all(dir.join("src")).context("Failed to create src directory")?;
+    fs::create_dir_all(dir.join("abis")).context("Failed to create abis directory")?;
+
+    // Generate and write files
+    let manifest = generate_manifest(options);
+    fs::write(dir.join("subgraph.yaml"), manifest).context("Failed to write subgraph.yaml")?;
+
+    let schema = generate_schema(options);
+    fs::write(dir.join("schema.graphql"), schema).context("Failed to write schema.graphql")?;
+
+    let mapping = generate_mapping(options);
+    let mapping_formatted = format_typescript(&mapping).unwrap_or(mapping);
+    let mapping_file = format!("{}.ts", to_kebab_case(&options.contract_name));
+    fs::write(dir.join("src").join(&mapping_file), mapping_formatted)
+        .context("Failed to write mapping file")?;
+
+    // Write ABI if provided
+    if let Some(abi) = &options.abi {
+        let abi_str = serde_json::to_string_pretty(abi).context("Failed to serialize ABI")?;
+        let abi_file = format!("{}.json", options.contract_name);
+        fs::write(dir.join("abis").join(&abi_file), abi_str).context("Failed to write ABI file")?;
+    }
+
+    // Generate package.json
+    let package_json = generate_package_json(options);
+    fs::write(dir.join("package.json"), package_json).context("Failed to write package.json")?;
+
+    // Generate tsconfig.json
+    let tsconfig = generate_tsconfig();
+    fs::write(dir.join("tsconfig.json"), tsconfig).context("Failed to write tsconfig.json")?;
+
+    // Generate .gitignore
+    let gitignore = generate_gitignore();
+    fs::write(dir.join(".gitignore"), gitignore).context("Failed to write .gitignore")?;
+
+    Ok(())
+}
+
+/// Initialize git repository in directory.
+pub fn init_git(dir: &Path) -> Result<()> {
+    step(Step::Generate, "Initializing Git repository");
+
+    let status = Command::new("git")
+        .current_dir(dir)
+        .arg("init")
+        .status()
+        .context("Failed to run git init")?;
+
+    if !status.success() {
+        return Err(anyhow!("git init failed"));
+    }
+
+    Ok(())
+}
+
+/// Install npm dependencies with spinner and suppressed output.
+pub fn install_dependencies(dir: &Path) -> Result<()> {
+    // Detect which package manager to use
+    let pkg_manager = detect_package_manager(dir);
+
+    with_spinner(
+        format!("Install dependencies with {}", pkg_manager),
+        "Failed to install dependencies",
+        "Installed with warnings",
+        |_spinner| {
+            let status = Command::new(&pkg_manager)
+                .current_dir(dir)
+                .arg("install")
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .status()
+                .map_err(|e| anyhow!("{}: {}", pkg_manager, e))?;
+
+            if status.success() {
+                return Ok(());
+            }
+
+            // If pnpm failed, try npm as fallback
+            if pkg_manager == "pnpm" {
+                let npm_status = Command::new("npm")
+                    .current_dir(dir)
+                    .arg("install")
+                    .stdout(Stdio::null())
+                    .stderr(Stdio::null())
+                    .status()
+                    .map_err(|e| anyhow!("npm: {}", e))?;
+
+                if npm_status.success() {
+                    return Ok(());
+                }
+            }
+
+            Err(anyhow!(
+                "Failed to install dependencies. Please run 'npm install' manually."
+            ))
+        },
+    )
+}
+
+/// Detect the package manager to use based on lock files.
+fn detect_package_manager(dir: &Path) -> String {
+    if dir.join("pnpm-lock.yaml").exists() {
+        "pnpm".to_string()
+    } else if dir.join("yarn.lock").exists() {
+        "yarn".to_string()
+    } else if dir.join("package-lock.json").exists() {
+        "npm".to_string()
+    } else {
+        // Default to pnpm
+        "pnpm".to_string()
+    }
+}
+
+/// Generate package.json content.
+fn generate_package_json(options: &ScaffoldOptions) -> String {
+    let basename = options
+        .subgraph_name
+        .split('/')
+        .next_back()
+        .unwrap_or(&options.subgraph_name);
+
+    serde_json::to_string_pretty(&serde_json::json!({
+        "name": basename,
+        "license": "UNLICENSED",
+        "scripts": {
+            "codegen": "graph codegen",
+            "build": "graph build",
+            "deploy": format!("graph deploy --node https://api.studio.thegraph.com/deploy/ {}", options.subgraph_name),
+            "create-local": format!("graph create --node http://localhost:8020/ {}", options.subgraph_name),
+            "remove-local": format!("graph remove --node http://localhost:8020/ {}", options.subgraph_name),
+            "deploy-local": format!("graph deploy --node http://localhost:8020/ --ipfs http://localhost:5001 {}", options.subgraph_name),
+            "test": "graph test"
+        },
+        "dependencies": {
+            "@graphprotocol/graph-cli": GRAPH_CLI_VERSION,
+            "@graphprotocol/graph-ts": GRAPH_TS_VERSION
+        },
+        "devDependencies": {
+            "matchstick-as": MATCHSTICK_VERSION
+        }
+    }))
+    .unwrap_or_default()
+}
+
+/// Generate tsconfig.json content.
+fn generate_tsconfig() -> String {
+    serde_json::to_string_pretty(&serde_json::json!({
+        "extends": "@graphprotocol/graph-ts/types/tsconfig.base.json",
+        "include": ["src", "tests"]
+    }))
+    .unwrap_or_default()
+}
+
+/// Generate .gitignore content.
+fn generate_gitignore() -> String {
+    r#"node_modules/
+build/
+generated/
+.env
+.env.local
+"#
+    .to_string()
+}
+
+/// Convert a string to kebab-case.
+/// Uses Inflector which correctly handles acronyms (ERC20 → erc20, not e-r-c20).
+pub(crate) fn to_kebab_case(s: &str) -> String {
+    s.to_kebab_case()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_to_kebab_case() {
+        // Inflector correctly handles acronyms - consecutive uppercase letters stay together
+        assert_eq!(to_kebab_case("MyContract"), "my-contract");
+        assert_eq!(to_kebab_case("ERC20"), "erc20");
+        assert_eq!(to_kebab_case("contract"), "contract");
+        assert_eq!(to_kebab_case("ABCToken"), "abc-token");
+        assert_eq!(to_kebab_case("ERC20Token"), "erc20-token");
+    }
+
+    #[test]
+    fn test_generate_package_json() {
+        let options = ScaffoldOptions {
+            subgraph_name: "user/my-subgraph".to_string(),
+            ..Default::default()
+        };
+
+        let json = generate_package_json(&options);
+        assert!(json.contains(r#""name": "my-subgraph""#));
+        assert!(json.contains("@graphprotocol/graph-cli"));
+        assert!(json.contains("@graphprotocol/graph-ts"));
+    }
+
+    #[test]
+    fn test_generate_tsconfig() {
+        let json = generate_tsconfig();
+        assert!(json.contains("@graphprotocol/graph-ts/types/tsconfig.base.json"));
+    }
+
+    #[test]
+    fn test_generate_gitignore() {
+        let gitignore = generate_gitignore();
+        assert!(gitignore.contains("node_modules/"));
+        assert!(gitignore.contains("build/"));
+        assert!(gitignore.contains("generated/"));
+    }
+}
diff --git a/gnd/src/scaffold/naming.rs b/gnd/src/scaffold/naming.rs
new file mode 100644
index 00000000000..54d4563f2cb
--- /dev/null
+++ b/gnd/src/scaffold/naming.rs
@@ -0,0 +1,86 @@
+//! Shared name sanitization for scaffold code generation.
+//!
+//! A single source of truth for turning ABI parameter names into valid GraphQL
+//! field / AssemblyScript identifiers, used by both the schema and mapping
+//! generators so the two never disagree.
+
+/// Sanitize a parameter name into a valid GraphQL/AssemblyScript field identifier.
+pub(crate) fn sanitize_field_name(name: &str) -> String {
+    if name.is_empty() {
+        return "value".to_string();
+    }
+
+    // Identifiers must start with a letter or underscore; replace anything else.
+    let mut result = String::new();
+    for (i, c) in name.chars().enumerate() {
+        if i == 0 && c.is_ascii_digit() {
+            result.push('_');
+        }
+        if c.is_alphanumeric() || c == '_' {
+            result.push(c);
+        } else {
+            result.push('_');
+        }
+    }
+
+    // Convert a leading uppercase to camelCase.
+    if result
+        .chars()
+        .next()
+        .map(|c| c.is_uppercase())
+        .unwrap_or(false)
+    {
+        let mut chars = result.chars();
+        if let Some(first) = chars.next() {
+            result = first.to_lowercase().collect::<String>() + chars.as_str();
+        }
+    }
+
+    // Avoid clashing with the entity `id` field and the GraphQL `type` keyword.
+    let result = match result.as_str() {
+        "id" => "eventId".to_string(),
+        "type" => "eventType".to_string(),
+        _ => result,
+    };
+
+    // Escape reserved words via the shared list, so the entity field name
+    // matches the member the schema/ABI codegen generates from the same list.
+    crate::shared::handle_reserved_word(&result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sanitize_field_name() {
+        // Normal names pass through.
+        assert_eq!(sanitize_field_name("owner"), "owner");
+        assert_eq!(sanitize_field_name("from"), "from");
+        // Empty -> placeholder.
+        assert_eq!(sanitize_field_name(""), "value");
+        // Leading uppercase -> camelCase.
+        assert_eq!(sanitize_field_name("Owner"), "owner");
+        assert_eq!(sanitize_field_name("TokenId"), "tokenId");
+        // Names that clash with the entity id / GraphQL keyword.
+        assert_eq!(sanitize_field_name("id"), "eventId");
+        assert_eq!(sanitize_field_name("type"), "eventType");
+        // Reserved words are suffixed so the generated code compiles. These use
+        // the shared list, so words only in it (for/default/null/void/instanceof)
+        // are covered too — and stay consistent with the schema/ABI codegen.
+        assert_eq!(sanitize_field_name("new"), "new_");
+        assert_eq!(sanitize_field_name("class"), "class_");
+        assert_eq!(sanitize_field_name("return"), "return_");
+        assert_eq!(sanitize_field_name("for"), "for_");
+        assert_eq!(sanitize_field_name("default"), "default_");
+        assert_eq!(sanitize_field_name("null"), "null_");
+        assert_eq!(sanitize_field_name("void"), "void_");
+        assert_eq!(sanitize_field_name("instanceof"), "instanceof_");
+        // Leading uppercase reserved word still resolves after camelCasing.
+        assert_eq!(sanitize_field_name("New"), "new_");
+        // Leading digit -> underscore prefix.
+        assert_eq!(sanitize_field_name("0value"), "_0value");
+        // Non-alphanumeric -> underscore.
+        assert_eq!(sanitize_field_name("a-b"), "a_b");
+    }
+}
diff --git a/gnd/src/scaffold/schema.rs b/gnd/src/scaffold/schema.rs
new file mode 100644
index 00000000000..ed47de3e041
--- /dev/null
+++ b/gnd/src/scaffold/schema.rs
@@ -0,0 +1,280 @@
+//! Schema (schema.graphql) generation for scaffold.
+
+use super::ScaffoldOptions;
+use super::manifest::{EventInput, extract_events_from_abi};
+use super::sanitize_field_name;
+
+/// Generate the schema.graphql content.
+pub fn generate_schema(options: &ScaffoldOptions) -> String {
+    let events = extract_events_from_abi(options);
+
+    if events.is_empty() {
+        // Generate example entity with no event params
+        return generate_example_entity(&[]);
+    }
+
+    if !options.index_events {
+        // Generate example entity with first event's params
+        return generate_example_entity(&events[0].inputs);
+    }
+
+    // Generate an entity for each event, disambiguating overloaded names.
+    let mut schema = String::new();
+
+    for resolved in super::disambiguate_events(events) {
+        let entity = generate_event_entity(&resolved.entity_name, &resolved.event.inputs);
+        schema.push_str(&entity);
+        schema.push_str("\n\n");
+    }
+
+    schema.trim_end().to_string()
+}
+
+/// Generate an example entity for placeholder mode.
+/// Uses first 2 event params if available, with type comments.
+fn generate_example_entity(inputs: &[EventInput]) -> String {
+    let mut fields = String::new();
+    fields.push_str("  # Use Bytes when possible for better performance\n");
+    fields.push_str("  id: Bytes!\n");
+    fields.push_str("  count: BigInt!\n");
+
+    // Include first 2 event params with type comments
+    for input in inputs.iter().take(2) {
+        let field_name = sanitize_field_name(&input.name);
+        let graphql_type = solidity_to_graphql(&input.solidity_type);
+        fields.push_str(&format!(
+            "  {}: {}! # {}\n",
+            field_name, graphql_type, input.solidity_type
+        ));
+    }
+
+    format!(
+        "# Declare entity types as immutable when possible for better performance\n\
+         type ExampleEntity @entity(immutable: true) {{\n{}}}\n",
+        fields
+    )
+}
+
+/// Generate an entity type for an event.
+pub fn generate_event_entity(entity_name: &str, inputs: &[EventInput]) -> String {
+    let mut fields = String::new();
+
+    // ID field
+    fields.push_str("  id: Bytes!\n");
+
+    // Fields from event inputs
+    for input in inputs {
+        let field_name = sanitize_field_name(&input.name);
+        let graphql_type = solidity_to_graphql(&input.solidity_type);
+        fields.push_str(&format!("  {}: {}!\n", field_name, graphql_type));
+    }
+
+    // Standard blockchain fields
+    fields.push_str("  blockNumber: BigInt!\n");
+    fields.push_str("  blockTimestamp: BigInt!\n");
+    fields.push_str("  transactionHash: Bytes!");
+
+    format!(
+        "# Declare entity types as immutable when possible for better performance\n\
+         type {} @entity(immutable: true) {{\n{}\n}}",
+        entity_name, fields
+    )
+}
+
+/// Convert Solidity type to GraphQL type.
+fn solidity_to_graphql(solidity_type: &str) -> &'static str {
+    // Handle arrays
+    if solidity_type.ends_with("[]") {
+        let inner = &solidity_type.strip_suffix("[]").unwrap();
+        return match solidity_to_graphql(inner) {
+            "Bytes" => "[Bytes!]",
+            "BigInt" => "[BigInt!]",
+            "Int" => "[Int!]",
+            "String" => "[String!]",
+            "Boolean" => "[Boolean!]",
+            _ => "[Bytes!]",
+        };
+    }
+
+    match solidity_type {
+        // Address types
+        "address" => "Bytes",
+
+        // Boolean
+        "bool" => "Boolean",
+
+        // String
+        "string" => "String",
+
+        // Bytes types
+        "bytes" => "Bytes",
+        "bytes1" | "bytes2" | "bytes3" | "bytes4" | "bytes5" | "bytes6" | "bytes7" | "bytes8"
+        | "bytes9" | "bytes10" | "bytes11" | "bytes12" | "bytes13" | "bytes14" | "bytes15"
+        | "bytes16" | "bytes17" | "bytes18" | "bytes19" | "bytes20" | "bytes21" | "bytes22"
+        | "bytes23" | "bytes24" | "bytes25" | "bytes26" | "bytes27" | "bytes28" | "bytes29"
+        | "bytes30" | "bytes31" | "bytes32" => "Bytes",
+
+        // Integers: small widths fit in an i32 (GraphQL Int), the rest need BigInt.
+        t if t.starts_with("uint") || t.starts_with("int") => int_to_graphql(t),
+
+        // Default to Bytes for unknown types
+        _ => "Bytes",
+    }
+}
+
+/// Map a Solidity integer type to GraphQL `Int` when it fits in an i32, else
+/// `BigInt`. An i32 holds signed ints up to 32 bits and unsigned ints up to 24
+/// bits, matching graph-cli's AssemblyScript type conversion.
+fn int_to_graphql(solidity_type: &str) -> &'static str {
+    let (signed, width) = match solidity_type.strip_prefix("uint") {
+        Some(rest) => (false, rest),
+        None => match solidity_type.strip_prefix("int") {
+            Some(rest) => (true, rest),
+            None => return "BigInt",
+        },
+    };
+
+    // A bare `int` / `uint` is 256 bits.
+    let bits: u32 = if width.is_empty() {
+        256
+    } else {
+        width.parse().unwrap_or(256)
+    };
+
+    let fits_i32 = if signed { bits <= 32 } else { bits <= 24 };
+    if fits_i32 { "Int" } else { "BigInt" }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_generate_example_entity_no_inputs() {
+        let schema = generate_example_entity(&[]);
+        assert!(schema.contains("type ExampleEntity @entity(immutable: true)"));
+        assert!(schema.contains("id: Bytes!"));
+        assert!(schema.contains("count: BigInt!"));
+        // Should not contain block fields
+        assert!(!schema.contains("blockNumber"));
+        assert!(!schema.contains("blockTimestamp"));
+        assert!(!schema.contains("transactionHash"));
+    }
+
+    #[test]
+    fn test_generate_example_entity_with_inputs() {
+        let inputs = vec![
+            EventInput {
+                name: "from".to_string(),
+                solidity_type: "address".to_string(),
+                indexed: true,
+            },
+            EventInput {
+                name: "to".to_string(),
+                solidity_type: "address".to_string(),
+                indexed: true,
+            },
+            EventInput {
+                name: "value".to_string(),
+                solidity_type: "uint256".to_string(),
+                indexed: false,
+            },
+        ];
+
+        let schema = generate_example_entity(&inputs);
+        assert!(schema.contains("type ExampleEntity @entity(immutable: true)"));
+        assert!(schema.contains("id: Bytes!"));
+        assert!(schema.contains("count: BigInt!"));
+        // First 2 params with type comments
+        assert!(schema.contains("from: Bytes! # address"));
+        assert!(schema.contains("to: Bytes! # address"));
+        // Third param should NOT be included (only first 2)
+        assert!(!schema.contains("value: BigInt!"));
+    }
+
+    #[test]
+    fn test_generate_schema_placeholder_mode() {
+        let abi = json!([
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": [
+                    {"name": "from", "type": "address", "indexed": true},
+                    {"name": "to", "type": "address", "indexed": true},
+                    {"name": "value", "type": "uint256", "indexed": false}
+                ]
+            }
+        ]);
+
+        let options = ScaffoldOptions {
+            abi: Some(abi),
+            index_events: false, // placeholder mode
+            ..Default::default()
+        };
+
+        let schema = generate_schema(&options);
+
+        assert!(schema.contains("type ExampleEntity @entity(immutable: true)"));
+        // First 2 event params with type comments
+        assert!(schema.contains("from: Bytes! # address"));
+        assert!(schema.contains("to: Bytes! # address"));
+    }
+
+    #[test]
+    fn test_generate_schema_with_events() {
+        let abi = json!([
+            {
+                "type": "event",
+                "name": "Transfer",
+                "inputs": [
+                    {"name": "from", "type": "address", "indexed": true},
+                    {"name": "to", "type": "address", "indexed": true},
+                    {"name": "value", "type": "uint256", "indexed": false}
+                ]
+            }
+        ]);
+
+        let options = ScaffoldOptions {
+            abi: Some(abi),
+            index_events: true,
+            ..Default::default()
+        };
+
+        let schema = generate_schema(&options);
+
+        assert!(schema.contains("type Transfer @entity(immutable: true)"));
+        assert!(schema.contains("from: Bytes!"));
+        assert!(schema.contains("to: Bytes!"));
+        assert!(schema.contains("value: BigInt!"));
+    }
+
+    #[test]
+    fn test_solidity_to_graphql() {
+        assert_eq!(solidity_to_graphql("address"), "Bytes");
+        assert_eq!(solidity_to_graphql("bool"), "Boolean");
+        assert_eq!(solidity_to_graphql("string"), "String");
+        assert_eq!(solidity_to_graphql("bytes32"), "Bytes");
+        assert_eq!(solidity_to_graphql("bytes"), "Bytes");
+        assert_eq!(solidity_to_graphql("address[]"), "[Bytes!]");
+        assert_eq!(solidity_to_graphql("uint256[]"), "[BigInt!]");
+    }
+
+    #[test]
+    fn test_integer_width_mapping() {
+        // Small widths that fit in an i32 map to Int.
+        assert_eq!(solidity_to_graphql("int8"), "Int");
+        assert_eq!(solidity_to_graphql("int32"), "Int");
+        assert_eq!(solidity_to_graphql("uint8"), "Int");
+        assert_eq!(solidity_to_graphql("uint24"), "Int");
+        // Wider integers need BigInt (uint32 does not fit an i32).
+        assert_eq!(solidity_to_graphql("uint32"), "BigInt");
+        assert_eq!(solidity_to_graphql("int40"), "BigInt");
+        assert_eq!(solidity_to_graphql("uint256"), "BigInt");
+        assert_eq!(solidity_to_graphql("int"), "BigInt");
+        assert_eq!(solidity_to_graphql("uint"), "BigInt");
+        // Arrays follow the element type.
+        assert_eq!(solidity_to_graphql("int8[]"), "[Int!]");
+        assert_eq!(solidity_to_graphql("uint64[]"), "[BigInt!]");
+    }
+}
diff --git a/gnd/src/services/contract.rs b/gnd/src/services/contract.rs
new file mode 100644
index 00000000000..d6dea4376c2
--- /dev/null
+++ b/gnd/src/services/contract.rs
@@ -0,0 +1,724 @@
+//! Contract ABI fetching service.
+//!
+//! This module provides functionality to fetch verified contract ABIs and metadata
+//! from block explorer APIs (Etherscan, Blockscout) and Sourcify.
+
+use std::env;
+use std::time::Duration;
+
+use anyhow::{Context, Result, anyhow};
+use reqwest::Client;
+use serde::Deserialize;
+use serde_json::Value as JsonValue;
+
+/// Timeout for HTTP requests to external APIs.
+const REQUEST_TIMEOUT: Duration = Duration::from_secs(10);
+
+/// Contract service for fetching ABIs and metadata.
+pub struct ContractService {
+    client: Client,
+    registry: NetworksRegistry,
+}
+
+/// A network definition from the registry.
+#[derive(Debug, Clone, Deserialize)]
+pub struct Network {
+    /// Network identifier (e.g., "mainnet", "goerli")
+    pub id: String,
+    /// Short display name
+    #[serde(rename = "shortName")]
+    pub short_name: Option<String>,
+    /// Full display name
+    #[serde(rename = "fullName")]
+    pub full_name: Option<String>,
+    /// Alternative names for the network
+    #[serde(default)]
+    pub aliases: Vec<String>,
+    /// CAIP-2 chain identifier (e.g., "eip155:1")
+    #[serde(rename = "caip2Id")]
+    pub caip2_id: String,
+    /// Block explorer API URLs
+    #[serde(rename = "apiUrls", default)]
+    pub api_urls: Vec<ApiUrl>,
+    /// JSON-RPC URLs
+    #[serde(rename = "rpcUrls", default)]
+    pub rpc_urls: Vec<String>,
+}
+
+/// An API URL entry from the registry.
+#[derive(Debug, Clone, Deserialize)]
+pub struct ApiUrl {
+    /// The API URL (may contain {ENVVAR} placeholders)
+    pub url: String,
+    /// The type of API (etherscan, blockscout, etc.)
+    pub kind: String,
+}
+
+/// The networks registry.
+#[derive(Debug, Clone, Deserialize)]
+pub struct NetworksRegistry {
+    /// List of networks
+    pub networks: Vec<Network>,
+}
+
+impl NetworksRegistry {
+    /// Load the registry from the default URL.
+    pub async fn load() -> Result<Self> {
+        let client = Client::builder()
+            .timeout(REQUEST_TIMEOUT)
+            .build()
+            .context("Failed to create HTTP client")?;
+
+        let url = "https://networks-registry.thegraph.com/TheGraphNetworksRegistry.json";
+        let response = client
+            .get(url)
+            .send()
+            .await
+            .context("Failed to fetch networks registry")?;
+
+        if !response.status().is_success() {
+            return Err(anyhow!(
+                "Failed to fetch networks registry: {}",
+                response.status()
+            ));
+        }
+
+        response
+            .json::<NetworksRegistry>()
+            .await
+            .context("Failed to parse networks registry")
+    }
+
+    /// Load from a JSON string (for testing).
+    pub fn from_json(json: &str) -> Result<Self> {
+        serde_json::from_str(json).context("Failed to parse networks registry JSON")
+    }
+
+    /// Get a network by ID or alias.
+    pub fn get_network(&self, id: &str) -> Option<&Network> {
+        let id_lower = id.to_lowercase();
+        self.networks.iter().find(|n| {
+            n.id.to_lowercase() == id_lower
+                || n.aliases.iter().any(|a| a.to_lowercase() == id_lower)
+        })
+    }
+}
+
+/// Result of fetching contract info from Sourcify.
+#[derive(Debug)]
+pub struct SourcifyResult {
+    /// The contract ABI as JSON
+    pub abi: JsonValue,
+    /// The contract name
+    pub name: String,
+    /// The deployment block number
+    pub start_block: u64,
+}
+
+/// Response from Etherscan getabi API.
+#[derive(Debug, Deserialize)]
+struct EtherscanResponse {
+    status: String,
+    message: String,
+    result: Option<JsonValue>,
+}
+
+/// Response from Etherscan getsourcecode API.
+#[derive(Debug, Deserialize)]
+struct SourceCodeResponse {
+    status: String,
+    #[allow(dead_code)]
+    message: String,
+    result: Option<Vec<SourceCodeResult>>,
+}
+
+#[derive(Debug, Deserialize)]
+struct SourceCodeResult {
+    #[serde(rename = "ContractName")]
+    contract_name: Option<String>,
+}
+
+/// Response from Etherscan getcontractcreation API.
+#[derive(Debug, Deserialize)]
+struct ContractCreationResponse {
+    status: String,
+    #[allow(dead_code)]
+    message: String,
+    result: Option<Vec<ContractCreationResult>>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ContractCreationResult {
+    #[serde(rename = "blockNumber")]
+    block_number: Option<String>,
+    #[serde(rename = "txHash")]
+    tx_hash: Option<String>,
+}
+
+/// Response from Sourcify API.
+#[derive(Debug, Deserialize)]
+struct SourcifyResponse {
+    abi: Option<JsonValue>,
+    compilation: Option<SourcifyCompilation>,
+    deployment: Option<SourcifyDeployment>,
+}
+
+#[derive(Debug, Deserialize)]
+struct SourcifyCompilation {
+    name: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct SourcifyDeployment {
+    #[serde(rename = "blockNumber")]
+    block_number: Option<String>,
+}
+
+/// Response from eth_getTransactionByHash RPC.
+#[derive(Debug, Deserialize)]
+struct RpcResponse {
+    result: Option<TransactionResult>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TransactionResult {
+    #[serde(rename = "blockNumber")]
+    block_number: Option<String>,
+}
+
+impl ContractService {
+    /// Create a new contract service with the given registry.
+    pub fn new(registry: NetworksRegistry) -> Self {
+        let client = Client::builder()
+            .timeout(REQUEST_TIMEOUT)
+            .build()
+            .expect("Failed to create HTTP client");
+
+        Self { client, registry }
+    }
+
+    /// Create a new contract service, loading the registry from the default URL.
+    pub async fn load() -> Result<Self> {
+        let registry = NetworksRegistry::load().await?;
+        Ok(Self::new(registry))
+    }
+
+    /// Get the contract ABI for a given network and address.
+    pub async fn get_abi(&self, network_id: &str, address: &str) -> Result<JsonValue> {
+        let urls = self.get_etherscan_urls(network_id)?;
+        if urls.is_empty() {
+            return Err(anyhow!(
+                "No contract API available for {} in the registry",
+                network_id
+            ));
+        }
+
+        let mut last_error = None;
+
+        for url in urls {
+            let api_url = format!("{}?module=contract&action=getabi&address={}", url, address);
+
+            match self.fetch_from_etherscan(&api_url).await {
+                Ok(response) => {
+                    if response.status == "1"
+                        && let Some(result) = response.result
+                    {
+                        // The result is a JSON string containing the ABI
+                        if let Some(abi_str) = result.as_str() {
+                            return serde_json::from_str(abi_str)
+                                .context("Failed to parse ABI JSON");
+                        }
+                        return Ok(result);
+                    }
+                    last_error = Some(anyhow!(
+                        "{} - {}",
+                        response.message,
+                        response.result.unwrap_or(JsonValue::Null)
+                    ));
+                }
+                Err(e) => {
+                    last_error = Some(e);
+                }
+            }
+        }
+
+        Err(last_error.unwrap_or_else(|| anyhow!("No API URLs available")))
+    }
+
+    /// Get the contract name for a given network and address.
+    pub async fn get_contract_name(&self, network_id: &str, address: &str) -> Result<String> {
+        let urls = self.get_etherscan_urls(network_id)?;
+        if urls.is_empty() {
+            return Err(anyhow!(
+                "No contract API available for {} in the registry",
+                network_id
+            ));
+        }
+
+        let mut last_error = None;
+
+        for url in urls {
+            let api_url = format!(
+                "{}?module=contract&action=getsourcecode&address={}",
+                url, address
+            );
+
+            let response = self
+                .client
+                .get(&api_url)
+                .send()
+                .await
+                .context("Contract API is unreachable")?;
+
+            if response.status().is_success() {
+                match response.json::<SourceCodeResponse>().await {
+                    Ok(data) => {
+                        if data.status == "1"
+                            && let Some(results) = data.result
+                            && let Some(first) = results.first()
+                            && let Some(name) = &first.contract_name
+                            && !name.is_empty()
+                        {
+                            return Ok(name.clone());
+                        }
+                        last_error = Some(anyhow!("Contract name is empty"));
+                    }
+                    Err(e) => {
+                        last_error = Some(anyhow!("Invalid JSON: {}", e));
+                    }
+                }
+            } else {
+                last_error = Some(anyhow!(
+                    "{} {}",
+                    response.status(),
+                    response.status().canonical_reason().unwrap_or("")
+                ));
+            }
+        }
+
+        Err(last_error.unwrap_or_else(|| anyhow!("Name not found")))
+    }
+
+    /// Get the deployment block number for a contract.
+    pub async fn get_start_block(&self, network_id: &str, address: &str) -> Result<u64> {
+        let urls = self.get_etherscan_urls(network_id)?;
+        if urls.is_empty() {
+            return Err(anyhow!(
+                "No contract API available for {} in the registry",
+                network_id
+            ));
+        }
+
+        let mut last_error = None;
+
+        for url in urls {
+            let api_url = format!(
+                "{}?module=contract&action=getcontractcreation&contractaddresses={}",
+                url, address
+            );
+
+            let response = self
+                .client
+                .get(&api_url)
+                .send()
+                .await
+                .context("Contract API is unreachable")?;
+
+            if response.status().is_success() {
+                match response.json::<ContractCreationResponse>().await {
+                    Ok(data) => {
+                        if data.status == "1"
+                            && let Some(results) = data.result
+                            && let Some(first) = results.first()
+                        {
+                            // Try direct block number first
+                            if let Some(block) = &first.block_number
+                                && let Ok(num) = block.parse::<u64>()
+                            {
+                                return Ok(num);
+                            }
+                            // Fall back to fetching transaction
+                            if let Some(tx_hash) = &first.tx_hash
+                                && let Ok(block) = self.get_block_from_tx(network_id, tx_hash).await
+                            {
+                                return Ok(block);
+                            }
+                        }
+                        last_error = Some(anyhow!("No contract creation info found"));
+                    }
+                    Err(e) => {
+                        last_error = Some(anyhow!("Invalid JSON: {}", e));
+                    }
+                }
+            } else {
+                last_error = Some(anyhow!(
+                    "{} {}",
+                    response.status(),
+                    response.status().canonical_reason().unwrap_or("")
+                ));
+            }
+        }
+
+        Err(last_error
+            .unwrap_or_else(|| anyhow!("Failed to fetch contract deployment transaction")))
+    }
+
+    /// Fetch contract info from Sourcify.
+    pub async fn get_from_sourcify(
+        &self,
+        network_id: &str,
+        address: &str,
+    ) -> Result<SourcifyResult> {
+        let network = self
+            .registry
+            .get_network(network_id)
+            .ok_or_else(|| anyhow!("Invalid network {}", network_id))?;
+
+        // Sourcify only supports EVM chains
+        if !network.caip2_id.starts_with("eip155") {
+            return Err(anyhow!(
+                "Invalid chainId, Sourcify API only supports EVM chains"
+            ));
+        }
+
+        // Validate address
+        if !address.starts_with("0x") || address.len() != 42 {
+            return Err(anyhow!(
+                "Invalid address, must start with 0x prefix and be 20 bytes long"
+            ));
+        }
+
+        let chain_id = network
+            .caip2_id
+            .split(':')
+            .nth(1)
+            .ok_or_else(|| anyhow!("Invalid CAIP-2 ID"))?;
+
+        let url = format!(
+            "https://sourcify.dev/server/v2/contract/{}/{}?fields=abi,compilation,deployment",
+            chain_id, address
+        );
+
+        let response = self
+            .client
+            .get(&url)
+            .send()
+            .await
+            .context("Sourcify API is unreachable")?;
+
+        if response.status().as_u16() == 404 {
+            return Err(anyhow!("Contract is not verified on Sourcify"));
+        }
+
+        if !response.status().is_success() {
+            return Err(anyhow!(
+                "Sourcify API returned status {}",
+                response.status()
+            ));
+        }
+
+        let data: SourcifyResponse = response.json().await.context("Invalid Sourcify response")?;
+
+        let abi = data.abi.ok_or_else(|| anyhow!("Contract ABI is missing"))?;
+
+        let name = data
+            .compilation
+            .and_then(|c| c.name)
+            .ok_or_else(|| anyhow!("Contract name is missing"))?;
+
+        let start_block = data
+            .deployment
+            .and_then(|d| d.block_number)
+            .and_then(|b| b.parse::<u64>().ok())
+            .ok_or_else(|| anyhow!("Contract deployment block is missing"))?;
+
+        Ok(SourcifyResult {
+            abi,
+            name,
+            start_block,
+        })
+    }
+
+    /// Get all contract info (ABI, name, start block), trying Sourcify first.
+    pub async fn get_contract_info(&self, network_id: &str, address: &str) -> Result<ContractInfo> {
+        // Try Sourcify first (more reliable for verified contracts)
+        if let Ok(sourcify) = self.get_from_sourcify(network_id, address).await {
+            return Ok(ContractInfo {
+                abi: sourcify.abi,
+                name: sourcify.name,
+                start_block: Some(sourcify.start_block),
+            });
+        }
+
+        // Fall back to Etherscan-compatible APIs
+        let abi = self.get_abi(network_id, address).await?;
+        let name = self.get_contract_name(network_id, address).await.ok();
+        let start_block = self.get_start_block(network_id, address).await.ok();
+
+        Ok(ContractInfo {
+            abi,
+            name: name.unwrap_or_else(|| "Contract".to_string()),
+            start_block,
+        })
+    }
+
+    /// Get Etherscan-compatible API URLs for a network.
+    fn get_etherscan_urls(&self, network_id: &str) -> Result<Vec<String>> {
+        let network = self
+            .registry
+            .get_network(network_id)
+            .ok_or_else(|| anyhow!("Invalid network {}", network_id))?;
+
+        let urls: Vec<String> = network
+            .api_urls
+            .iter()
+            .filter(|url| url.kind == "etherscan" || url.kind == "blockscout")
+            .map(|url| self.apply_env_vars(&url.url))
+            .filter(|url| !url.is_empty())
+            .collect();
+
+        Ok(urls)
+    }
+
+    /// Get JSON-RPC URLs for a network.
+    fn get_rpc_urls(&self, network_id: &str) -> Result<Vec<String>> {
+        let network = self
+            .registry
+            .get_network(network_id)
+            .ok_or_else(|| anyhow!("Invalid network {}", network_id))?;
+
+        let urls: Vec<String> = network
+            .rpc_urls
+            .iter()
+            .map(|url| self.apply_env_vars(url))
+            .filter(|url| !url.is_empty())
+            .collect();
+
+        Ok(urls)
+    }
+
+    /// Replace {ENVVAR} placeholders with environment variable values.
+    fn apply_env_vars(&self, url: &str) -> String {
+        // Find {ENVVAR} pattern
+        let re = regex::Regex::new(r"\{([^}]+)\}").unwrap();
+        if let Some(caps) = re.captures(url) {
+            let var_name = &caps[1];
+            if let Ok(value) = env::var(var_name) {
+                return url.replace(&format!("{{{}}}", var_name), &value);
+            }
+            // If env var not found, return empty string (skip this URL)
+            return String::new();
+        }
+        url.to_string()
+    }
+
+    /// Fetch from an Etherscan-compatible API.
+    async fn fetch_from_etherscan(&self, url: &str) -> Result<EtherscanResponse> {
+        let response = self
+            .client
+            .get(url)
+            .send()
+            .await
+            .context("Contract API is unreachable")?;
+
+        if !response.status().is_success() {
+            return Err(anyhow!(
+                "{} {}",
+                response.status(),
+                response.status().canonical_reason().unwrap_or("")
+            ));
+        }
+
+        response
+            .json::<EtherscanResponse>()
+            .await
+            .context("Invalid JSON response")
+    }
+
+    /// Get block number from transaction hash via JSON-RPC.
+    async fn get_block_from_tx(&self, network_id: &str, tx_hash: &str) -> Result<u64> {
+        let urls = self.get_rpc_urls(network_id)?;
+        if urls.is_empty() {
+            return Err(anyhow!("No JSON-RPC available for {}", network_id));
+        }
+
+        let mut last_error = None;
+
+        let body = serde_json::json!({
+            "jsonrpc": "2.0",
+            "method": "eth_getTransactionByHash",
+            "params": [tx_hash],
+            "id": 1
+        });
+
+        for url in urls {
+            match self
+                .client
+                .post(&url)
+                .header("Content-Type", "application/json")
+                .json(&body)
+                .send()
+                .await
+            {
+                Ok(response) => {
+                    if response.status().is_success() {
+                        match response.json::<RpcResponse>().await {
+                            Ok(data) => {
+                                if let Some(result) = data.result
+                                    && let Some(block_hex) = result.block_number
+                                {
+                                    // Parse hex block number
+                                    let block_str = block_hex.trim_start_matches("0x");
+                                    if let Ok(block) = u64::from_str_radix(block_str, 16) {
+                                        return Ok(block);
+                                    }
+                                }
+                                last_error = Some(anyhow!("No block number in transaction"));
+                            }
+                            Err(e) => {
+                                last_error = Some(anyhow!("Invalid JSON: {}", e));
+                            }
+                        }
+                    } else {
+                        last_error = Some(anyhow!("RPC returned {}", response.status()));
+                    }
+                }
+                Err(e) => {
+                    last_error = Some(anyhow!("RPC request failed: {}", e));
+                }
+            }
+        }
+
+        Err(last_error.unwrap_or_else(|| anyhow!("Failed to fetch transaction {}", tx_hash)))
+    }
+}
+
+/// Information about a verified contract.
+#[derive(Debug)]
+pub struct ContractInfo {
+    /// The contract ABI as JSON
+    pub abi: JsonValue,
+    /// The contract name
+    pub name: String,
+    /// The deployment block number (if available)
+    pub start_block: Option<u64>,
+}
+
+/// Well-known Etherscan API URLs for common networks (fallback if registry unavailable).
+pub fn get_fallback_etherscan_url(network: &str) -> Option<&'static str> {
+    // Note: These require API keys for high-volume usage
+    static ETHERSCAN_URLS: &[(&str, &str)] = &[
+        ("mainnet", "https://api.etherscan.io/api"),
+        ("goerli", "https://api-goerli.etherscan.io/api"),
+        ("sepolia", "https://api-sepolia.etherscan.io/api"),
+        ("polygon", "https://api.polygonscan.com/api"),
+        ("arbitrum-one", "https://api.arbiscan.io/api"),
+        ("optimism", "https://api-optimistic.etherscan.io/api"),
+        ("base", "https://api.basescan.org/api"),
+        ("bnb", "https://api.bscscan.com/api"),
+        ("avalanche", "https://api.snowtrace.io/api"),
+        ("gnosis", "https://api.gnosisscan.io/api"),
+    ];
+
+    ETHERSCAN_URLS
+        .iter()
+        .find(|(n, _)| *n == network)
+        .map(|(_, url)| *url)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const TEST_REGISTRY_JSON: &str = r#"{
+        "networks": [
+            {
+                "id": "mainnet",
+                "shortName": "Ethereum",
+                "fullName": "Ethereum Mainnet",
+                "aliases": ["ethereum", "eth"],
+                "caip2Id": "eip155:1",
+                "apiUrls": [
+                    {"url": "https://api.etherscan.io/api", "kind": "etherscan"},
+                    {"url": "https://eth.blockscout.com/api", "kind": "blockscout"}
+                ],
+                "rpcUrls": ["https://ethereum-rpc.publicnode.com"]
+            },
+            {
+                "id": "goerli",
+                "aliases": [],
+                "caip2Id": "eip155:5",
+                "apiUrls": [],
+                "rpcUrls": []
+            }
+        ]
+    }"#;
+
+    #[test]
+    fn test_parse_registry() {
+        let registry = NetworksRegistry::from_json(TEST_REGISTRY_JSON).unwrap();
+        assert_eq!(registry.networks.len(), 2);
+
+        let mainnet = registry.get_network("mainnet").unwrap();
+        assert_eq!(mainnet.id, "mainnet");
+        assert_eq!(mainnet.caip2_id, "eip155:1");
+        assert_eq!(mainnet.api_urls.len(), 2);
+        assert_eq!(mainnet.rpc_urls.len(), 1);
+    }
+
+    #[test]
+    fn test_get_network_by_alias() {
+        let registry = NetworksRegistry::from_json(TEST_REGISTRY_JSON).unwrap();
+
+        assert!(registry.get_network("eth").is_some());
+        assert!(registry.get_network("ethereum").is_some());
+        assert!(registry.get_network("MAINNET").is_some());
+        assert!(registry.get_network("invalid").is_none());
+    }
+
+    #[test]
+    fn test_apply_env_vars() {
+        let registry = NetworksRegistry::from_json(TEST_REGISTRY_JSON).unwrap();
+        let service = ContractService::new(registry);
+
+        // URL without env var
+        assert_eq!(
+            service.apply_env_vars("https://api.etherscan.io/api"),
+            "https://api.etherscan.io/api"
+        );
+
+        // URL with non-existent env var should return empty string
+        let url_with_var = "https://api.etherscan.io/api?apikey={NONEXISTENT_VAR}";
+        assert_eq!(service.apply_env_vars(url_with_var), "");
+    }
+
+    #[test]
+    fn test_get_etherscan_urls() {
+        let registry = NetworksRegistry::from_json(TEST_REGISTRY_JSON).unwrap();
+        let service = ContractService::new(registry);
+
+        let urls = service.get_etherscan_urls("mainnet").unwrap();
+        assert_eq!(urls.len(), 2);
+        assert!(urls.contains(&"https://api.etherscan.io/api".to_string()));
+
+        // Network without API URLs
+        let urls = service.get_etherscan_urls("goerli").unwrap();
+        assert!(urls.is_empty());
+
+        // Invalid network
+        assert!(service.get_etherscan_urls("invalid").is_err());
+    }
+
+    #[test]
+    fn test_fallback_etherscan_urls() {
+        assert_eq!(
+            get_fallback_etherscan_url("mainnet"),
+            Some("https://api.etherscan.io/api")
+        );
+        assert_eq!(
+            get_fallback_etherscan_url("polygon"),
+            Some("https://api.polygonscan.com/api")
+        );
+        assert_eq!(get_fallback_etherscan_url("unknown"), None);
+    }
+}
diff --git a/gnd/src/services/graph_node.rs b/gnd/src/services/graph_node.rs
new file mode 100644
index 00000000000..9d3faa07d2b
--- /dev/null
+++ b/gnd/src/services/graph_node.rs
@@ -0,0 +1,258 @@
+//! JSON-RPC client for communicating with Graph Node admin API.
+//!
+//! This client is used by the `create`, `remove`, and `deploy` commands to
+//! interact with a Graph Node instance.
+
+use reqwest::header::{AUTHORIZATION, HeaderMap, HeaderValue, USER_AGENT};
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+use url::Url;
+
+/// Version string for User-Agent header
+const GND_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Errors that can occur when communicating with a Graph Node
+#[derive(Debug, Error)]
+pub enum GraphNodeError {
+    #[error("Invalid node URL: {0}")]
+    InvalidUrl(#[from] url::ParseError),
+
+    #[error("Unsupported protocol: {protocol}. The Graph Node URL must be http:// or https://")]
+    UnsupportedProtocol { protocol: String },
+
+    #[error("HTTP error: {0}")]
+    Http(#[from] reqwest::Error),
+
+    #[error("JSON-RPC error: {message}")]
+    JsonRpc { code: i64, message: String },
+}
+
+/// A client for communicating with a Graph Node's JSON-RPC admin API
+#[derive(Debug, Clone)]
+pub struct GraphNodeClient {
+    client: reqwest::Client,
+    url: Url,
+}
+
+impl GraphNodeClient {
+    /// Create a new client for the given Graph Node URL.
+    ///
+    /// The URL should be the admin JSON-RPC endpoint (e.g., `http://localhost:8020`).
+    /// An optional access token can be provided for authentication.
+    pub fn new(node_url: &str, access_token: Option<&str>) -> Result<Self, GraphNodeError> {
+        let url = Url::parse(node_url)?;
+
+        // Validate protocol
+        match url.scheme() {
+            "http" | "https" => {}
+            other => {
+                return Err(GraphNodeError::UnsupportedProtocol {
+                    protocol: other.to_string(),
+                });
+            }
+        }
+
+        // Build headers
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            USER_AGENT,
+            HeaderValue::from_str(&format!("gnd/{}", GND_VERSION))
+                .expect("valid user agent string"),
+        );
+
+        if let Some(token) = access_token {
+            headers.insert(
+                AUTHORIZATION,
+                HeaderValue::from_str(&format!("Bearer {}", token))
+                    .expect("valid authorization header"),
+            );
+        }
+
+        let client = reqwest::Client::builder()
+            .default_headers(headers)
+            .timeout(std::time::Duration::from_secs(120))
+            .build()?;
+
+        Ok(Self { client, url })
+    }
+
+    /// Create a subgraph with the given name.
+    ///
+    /// This registers the subgraph name with the Graph Node but does not deploy any code.
+    pub async fn create_subgraph(&self, name: &str) -> Result<(), GraphNodeError> {
+        let request = JsonRpcRequest::name_only("subgraph_create", name);
+        self.call::<serde_json::Value>(request).await?;
+        Ok(())
+    }
+
+    /// Remove a subgraph with the given name.
+    ///
+    /// This unregisters the subgraph name from the Graph Node.
+    pub async fn remove_subgraph(&self, name: &str) -> Result<(), GraphNodeError> {
+        let request = JsonRpcRequest::name_only("subgraph_remove", name);
+        self.call::<serde_json::Value>(request).await?;
+        Ok(())
+    }
+
+    /// Deploy a subgraph to the Graph Node.
+    ///
+    /// This deploys the subgraph with the given name using the provided IPFS hash.
+    /// Returns the deployment result containing playground and queries URLs.
+    pub async fn deploy_subgraph(
+        &self,
+        name: &str,
+        ipfs_hash: &str,
+        version_label: Option<&str>,
+        debug_fork: Option<&str>,
+    ) -> Result<DeployResult, GraphNodeError> {
+        let request = JsonRpcRequest::deploy(name, ipfs_hash, version_label, debug_fork);
+        self.call::<DeployResult>(request).await
+    }
+
+    /// Make a JSON-RPC call to the Graph Node
+    async fn call<T: for<'de> Deserialize<'de>>(
+        &self,
+        request: JsonRpcRequest,
+    ) -> Result<T, GraphNodeError> {
+        let response = self
+            .client
+            .post(self.url.clone())
+            .json(&request)
+            .send()
+            .await?
+            .json::<JsonRpcResponse<T>>()
+            .await?;
+
+        if let Some(error) = response.error {
+            return Err(GraphNodeError::JsonRpc {
+                code: error.code,
+                message: error.message,
+            });
+        }
+
+        // If there's no error, there should be a result
+        response.result.ok_or_else(|| GraphNodeError::JsonRpc {
+            code: -1,
+            message: "No result in response".to_string(),
+        })
+    }
+}
+
+/// Result from a successful subgraph deployment.
+#[derive(Debug, Deserialize)]
+pub struct DeployResult {
+    /// URL to the GraphQL playground for this subgraph
+    pub playground: String,
+    /// URL to the GraphQL queries endpoint for this subgraph
+    pub queries: String,
+}
+
+#[derive(Debug, Serialize)]
+struct JsonRpcRequest {
+    jsonrpc: &'static str,
+    id: u32,
+    method: &'static str,
+    params: JsonRpcParams,
+}
+
+impl JsonRpcRequest {
+    fn name_only(method: &'static str, name: &str) -> Self {
+        Self {
+            jsonrpc: "2.0",
+            id: 1,
+            method,
+            params: JsonRpcParams::NameOnly {
+                name: name.to_string(),
+            },
+        }
+    }
+
+    fn deploy(
+        name: &str,
+        ipfs_hash: &str,
+        version_label: Option<&str>,
+        debug_fork: Option<&str>,
+    ) -> Self {
+        Self {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "subgraph_deploy",
+            params: JsonRpcParams::Deploy {
+                name: name.to_string(),
+                ipfs_hash: ipfs_hash.to_string(),
+                version_label: version_label.map(|s| s.to_string()),
+                debug_fork: debug_fork.map(|s| s.to_string()),
+            },
+        }
+    }
+}
+
+#[derive(Debug, Serialize)]
+#[serde(untagged)]
+enum JsonRpcParams {
+    NameOnly {
+        name: String,
+    },
+    Deploy {
+        name: String,
+        ipfs_hash: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        version_label: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        debug_fork: Option<String>,
+    },
+}
+
+#[derive(Debug, Deserialize)]
+struct JsonRpcResponse<T> {
+    #[allow(dead_code)]
+    jsonrpc: String,
+    #[allow(dead_code)]
+    id: u32,
+    result: Option<T>,
+    error: Option<JsonRpcError>,
+}
+
+#[derive(Debug, Deserialize)]
+struct JsonRpcError {
+    code: i64,
+    message: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_invalid_url() {
+        let result = GraphNodeClient::new("not-a-valid-url", None);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_unsupported_protocol() {
+        let result = GraphNodeClient::new("ftp://example.com", None);
+        assert!(matches!(
+            result,
+            Err(GraphNodeError::UnsupportedProtocol { protocol }) if protocol == "ftp"
+        ));
+    }
+
+    #[test]
+    fn test_valid_http_url() {
+        let result = GraphNodeClient::new("http://localhost:8020", None);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_valid_https_url() {
+        let result = GraphNodeClient::new("https://example.com/admin", None);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_with_access_token() {
+        let result = GraphNodeClient::new("http://localhost:8020", Some("test-token"));
+        assert!(result.is_ok());
+    }
+}
diff --git a/gnd/src/services/ipfs.rs b/gnd/src/services/ipfs.rs
new file mode 100644
index 00000000000..54070dbac2b
--- /dev/null
+++ b/gnd/src/services/ipfs.rs
@@ -0,0 +1,273 @@
+//! IPFS client for uploading and fetching subgraph files.
+//!
+//! This module provides an IPFS client that uses the Kubo RPC API to upload
+//! files, get their IPFS hashes, and fetch content by CID. It's used by the
+//! build, deploy, and init commands.
+
+use std::collections::HashMap;
+use std::path::Path;
+
+use anyhow::{Context, Result, anyhow};
+use reqwest::multipart::{Form, Part};
+use serde::Deserialize;
+use url::Url;
+
+/// Version string for User-Agent header
+const GND_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// IPFS client for uploading files to an IPFS node.
+#[derive(Debug, Clone)]
+pub struct IpfsClient {
+    client: reqwest::Client,
+    api_url: Url,
+}
+
+impl IpfsClient {
+    /// Create a new IPFS client for the given IPFS node URL.
+    ///
+    /// The URL should be the IPFS HTTP API endpoint (e.g., `http://localhost:5001`
+    /// or `https://api.thegraph.com/ipfs/api/v0`).
+    pub fn new(url: &str) -> Result<Self> {
+        let mut api_url = Url::parse(url).context("Invalid IPFS URL")?;
+
+        // Ensure the URL ends with /api/v0 for the Kubo API
+        let path = api_url.path();
+        if !path.ends_with("/api/v0") && !path.ends_with("/api/v0/") {
+            // Append /api/v0 if needed
+            let new_path = if path.ends_with('/') {
+                format!("{}api/v0", path)
+            } else if path.contains("/api/v0") {
+                path.to_string()
+            } else {
+                format!("{}/api/v0", path.trim_end_matches('/'))
+            };
+            api_url.set_path(&new_path);
+        }
+
+        let client = reqwest::Client::builder()
+            .user_agent(format!("gnd/{}", GND_VERSION))
+            .timeout(std::time::Duration::from_secs(300)) // 5 minutes for large uploads
+            .build()
+            .context("Failed to create HTTP client")?;
+
+        Ok(Self { client, api_url })
+    }
+
+    /// Add a file to IPFS and return its CID (content identifier).
+    ///
+    /// The file is uploaded using the IPFS `add` API endpoint.
+    pub async fn add(&self, filename: &str, content: Vec<u8>) -> Result<String> {
+        let mut url = self.api_url.clone();
+        url.set_path(&format!("{}/add", url.path().trim_end_matches('/')));
+
+        // Add query parameters
+        url.query_pairs_mut()
+            .append_pair("pin", "true")
+            .append_pair("wrap-with-directory", "false");
+
+        let part = Part::bytes(content)
+            .file_name(filename.to_string())
+            .mime_str("application/octet-stream")
+            .context("Failed to create multipart form")?;
+
+        let form = Form::new().part("file", part);
+
+        let response = self
+            .client
+            .post(url)
+            .multipart(form)
+            .send()
+            .await
+            .context("Failed to send request to IPFS")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let body = response.text().await.unwrap_or_default();
+            return Err(anyhow!("IPFS add failed with status {}: {}", status, body));
+        }
+
+        // IPFS returns newline-delimited JSON (one object per line).
+        // When the filename contains a path separator, IPFS returns multiple lines:
+        // first the file itself, then any parent directories. We want the first
+        // line which is the actual file CID.
+        let body = response
+            .text()
+            .await
+            .context("Failed to read IPFS response body")?;
+
+        // Parse the first non-empty line as the result (the actual file)
+        let first_line = body
+            .lines()
+            .find(|line| !line.is_empty())
+            .ok_or_else(|| anyhow!("Empty response from IPFS"))?;
+
+        let result: AddResponse =
+            serde_json::from_str(first_line).context("Failed to parse IPFS response JSON")?;
+
+        Ok(result.hash)
+    }
+
+    /// Add multiple files to IPFS and return a map of filenames to CIDs.
+    ///
+    /// This is more efficient than calling `add` multiple times for many files.
+    pub async fn add_all(&self, files: Vec<(String, Vec<u8>)>) -> Result<HashMap<String, String>> {
+        let mut results = HashMap::new();
+
+        for (filename, content) in files {
+            let hash = self.add(&filename, content).await?;
+            results.insert(filename, hash);
+        }
+
+        Ok(results)
+    }
+
+    /// Pin an existing CID to ensure it's not garbage collected.
+    pub async fn pin(&self, cid: &str) -> Result<()> {
+        let mut url = self.api_url.clone();
+        url.set_path(&format!("{}/pin/add", url.path().trim_end_matches('/')));
+        url.query_pairs_mut().append_pair("arg", cid);
+
+        let response = self
+            .client
+            .post(url)
+            .send()
+            .await
+            .context("Failed to send pin request to IPFS")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let body = response.text().await.unwrap_or_default();
+            return Err(anyhow!("IPFS pin failed with status {}: {}", status, body));
+        }
+
+        Ok(())
+    }
+
+    /// Fetch content from IPFS by CID.
+    ///
+    /// Returns the content as a string. The CID can be with or without the
+    /// `/ipfs/` prefix.
+    pub async fn cat(&self, cid: &str) -> Result<String> {
+        // Normalize CID: strip /ipfs/ prefix if present
+        let normalized_cid = cid.strip_prefix("/ipfs/").unwrap_or(cid);
+
+        let mut url = self.api_url.clone();
+        url.set_path(&format!("{}/cat", url.path().trim_end_matches('/')));
+        url.query_pairs_mut().append_pair("arg", normalized_cid);
+
+        let response = self
+            .client
+            .post(url)
+            .send()
+            .await
+            .context("Failed to send cat request to IPFS")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let body = response.text().await.unwrap_or_default();
+            return Err(anyhow!(
+                "Failed to fetch {} from IPFS (status {}): {}",
+                normalized_cid,
+                status,
+                body
+            ));
+        }
+
+        response
+            .text()
+            .await
+            .context("Failed to read response body from IPFS")
+    }
+
+    /// Fetch a subgraph manifest from IPFS by deployment ID.
+    ///
+    /// The deployment ID is the CID of the manifest (typically starts with `Qm`).
+    /// Returns the raw manifest YAML content.
+    pub async fn fetch_manifest(&self, deployment_id: &str) -> Result<String> {
+        self.cat(deployment_id)
+            .await
+            .with_context(|| format!("Failed to fetch manifest for deployment {}", deployment_id))
+    }
+
+    /// Fetch the schema from IPFS using a manifest's schema CID.
+    ///
+    /// The schema CID is extracted from the manifest YAML at `schema.file["/"]`.
+    pub async fn fetch_schema(&self, schema_cid: &str) -> Result<String> {
+        self.cat(schema_cid)
+            .await
+            .with_context(|| format!("Failed to fetch schema {}", schema_cid))
+    }
+
+    /// Fetch the GraphQL schema for a subgraph deployment.
+    ///
+    /// This fetches the manifest from IPFS, extracts the schema CID, and then
+    /// fetches the schema content. Used for generating types for subgraph data sources.
+    pub async fn fetch_subgraph_schema(&self, deployment_id: &str) -> Result<String> {
+        // Fetch the manifest
+        let manifest_content = self.fetch_manifest(deployment_id).await?;
+
+        // Parse manifest YAML to extract schema CID
+        let manifest: serde_json::Value = serde_yaml::from_str(&manifest_content)
+            .with_context(|| format!("Failed to parse manifest YAML for {}", deployment_id))?;
+
+        // Extract schema CID from schema.file["/"]
+        let schema_cid = manifest
+            .get("schema")
+            .and_then(|s| s.get("file"))
+            .and_then(|f| f.get("/"))
+            .and_then(|c| c.as_str())
+            .ok_or_else(|| {
+                anyhow!(
+                    "Failed to extract schema CID from manifest {}",
+                    deployment_id
+                )
+            })?;
+
+        // Normalize schema CID - strip /ipfs/ prefix if present
+        let normalized_cid = schema_cid.strip_prefix("/ipfs/").unwrap_or(schema_cid);
+
+        // Fetch and return the schema
+        self.fetch_schema(normalized_cid).await
+    }
+}
+
+/// Response from the IPFS add endpoint.
+#[derive(Debug, Deserialize)]
+struct AddResponse {
+    #[serde(rename = "Hash")]
+    hash: String,
+    #[serde(rename = "Name")]
+    #[allow(dead_code)]
+    name: String,
+    #[serde(rename = "Size")]
+    #[allow(dead_code)]
+    size: String,
+}
+
+/// Read a file and return its contents as bytes.
+pub fn read_file(path: &Path) -> Result<Vec<u8>> {
+    std::fs::read(path).with_context(|| format!("Failed to read file: {}", path.display()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_url_normalization_no_api() {
+        let client = IpfsClient::new("http://localhost:5001").unwrap();
+        assert!(client.api_url.path().contains("/api/v0"));
+    }
+
+    #[test]
+    fn test_url_normalization_with_api() {
+        let client = IpfsClient::new("https://api.thegraph.com/ipfs/api/v0").unwrap();
+        assert!(client.api_url.path().contains("/api/v0"));
+    }
+
+    #[test]
+    fn test_url_normalization_thegraph() {
+        let client = IpfsClient::new("https://api.thegraph.com/ipfs").unwrap();
+        assert!(client.api_url.path().ends_with("/api/v0"));
+    }
+}
diff --git a/gnd/src/services/mod.rs b/gnd/src/services/mod.rs
new file mode 100644
index 00000000000..27fa4942c99
--- /dev/null
+++ b/gnd/src/services/mod.rs
@@ -0,0 +1,10 @@
+mod contract;
+mod graph_node;
+mod ipfs;
+
+pub use contract::{
+    ContractInfo, ContractService, Network, NetworksRegistry, SourcifyResult,
+    get_fallback_etherscan_url,
+};
+pub use graph_node::{DeployResult, GraphNodeClient, GraphNodeError};
+pub use ipfs::{IpfsClient, read_file};
diff --git a/gnd/src/shared/mod.rs b/gnd/src/shared/mod.rs
new file mode 100644
index 00000000000..4421dbd4645
--- /dev/null
+++ b/gnd/src/shared/mod.rs
@@ -0,0 +1,8 @@
+//! Shared utilities for gnd code generation.
+//!
+//! This module contains common utilities used across multiple codegen
+//! and scaffold modules to reduce duplication.
+
+pub mod sanitize;
+
+pub use sanitize::{RESERVED_WORDS, capitalize, handle_reserved_word};
diff --git a/gnd/src/shared/sanitize.rs b/gnd/src/shared/sanitize.rs
new file mode 100644
index 00000000000..a0b22eeaead
--- /dev/null
+++ b/gnd/src/shared/sanitize.rs
@@ -0,0 +1,111 @@
+//! Shared sanitization utilities for code generation.
+//!
+//! Contains reserved word handling and name sanitization used by both
+//! schema codegen and ABI codegen.
+
+/// Reserved words in AssemblyScript that need to be escaped.
+///
+/// This is a superset of reserved words from ECMAScript plus AssemblyScript-specific
+/// additions. When a field or parameter name matches one of these, it gets
+/// an underscore appended.
+pub const RESERVED_WORDS: &[&str] = &[
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "interface",
+    "let",
+    "new",
+    "null",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+];
+
+/// Handle reserved words by appending an underscore.
+///
+/// If the given name is a reserved word in AssemblyScript, returns the name
+/// with an underscore appended. Otherwise returns the name unchanged.
+pub fn handle_reserved_word(name: &str) -> String {
+    if RESERVED_WORDS.contains(&name) {
+        format!("{}_", name)
+    } else {
+        name.to_string()
+    }
+}
+
+/// Capitalize the first letter of a string.
+///
+/// Returns an empty string if the input is empty, otherwise returns the
+/// string with the first character uppercased.
+pub fn capitalize(s: &str) -> String {
+    let mut chars = s.chars();
+    match chars.next() {
+        None => String::new(),
+        Some(c) => c.to_uppercase().collect::<String>() + chars.as_str(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_handle_reserved_word_reserved() {
+        assert_eq!(handle_reserved_word("class"), "class_");
+        assert_eq!(handle_reserved_word("return"), "return_");
+        assert_eq!(handle_reserved_word("await"), "await_");
+        assert_eq!(handle_reserved_word("default"), "default_");
+    }
+
+    #[test]
+    fn test_handle_reserved_word_not_reserved() {
+        assert_eq!(handle_reserved_word("myField"), "myField");
+        assert_eq!(handle_reserved_word("amount"), "amount");
+        assert_eq!(handle_reserved_word("value"), "value");
+    }
+
+    #[test]
+    fn test_capitalize() {
+        assert_eq!(capitalize("hello"), "Hello");
+        assert_eq!(capitalize("world"), "World");
+        assert_eq!(capitalize(""), "");
+        assert_eq!(capitalize("a"), "A");
+        assert_eq!(capitalize("ALREADY"), "ALREADY");
+    }
+}
diff --git a/gnd/src/validation/mod.rs b/gnd/src/validation/mod.rs
new file mode 100644
index 00000000000..8991df4fba5
--- /dev/null
+++ b/gnd/src/validation/mod.rs
@@ -0,0 +1,2373 @@
+//! Schema and manifest validation using graph-node's validation logic.
+//!
+//! This module provides validation functions that use the same validation
+//! logic as graph-node, ensuring developers get early feedback about issues
+//! that would cause deployment failures.
+
+use std::collections::HashSet;
+use std::path::Path;
+
+use anyhow::{Context, Result};
+use graph::abi::{Event, Function, JsonAbi};
+use graph::data::subgraph::SubgraphManifestValidationError;
+use graph::data::subgraph::api_version::{LATEST_VERSION, MIN_SPEC_VERSION};
+use graph::data::subgraph::manifest_validation;
+use graph::prelude::DeploymentHash;
+use graph::schema::{InputSchema, SchemaValidationError};
+use semver::Version;
+
+use crate::manifest::{Abi, BlockHandlerFilterKind, CallHandler, DataSource, Manifest, Template};
+
+/// Validate a GraphQL schema using graph-node's InputSchema validation.
+///
+/// Returns a list of validation errors. An empty list means the schema is valid.
+pub fn validate_schema(
+    schema_path: &Path,
+    spec_version: &Version,
+) -> Result<Vec<SchemaValidationError>> {
+    let schema_str = std::fs::read_to_string(schema_path)
+        .with_context(|| format!("Failed to read schema: {}", schema_path.display()))?;
+
+    // Use a dummy deployment hash for local validation
+    // The hash must be alphanumeric only (no dashes or special chars)
+    let id = DeploymentHash::new("QmLocalValidation").unwrap();
+
+    Ok(InputSchema::validate(spec_version, &schema_str, id))
+}
+
+/// Format validation errors for display.
+pub fn format_schema_errors(errors: &[SchemaValidationError]) -> String {
+    errors
+        .iter()
+        .map(|e| format!("  - {}", e))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+/// Errors that can occur during manifest validation in gnd.
+#[derive(Debug)]
+pub enum ManifestValidationError {
+    /// Error from shared validation logic.
+    Shared(Box<SubgraphManifestValidationError>),
+    /// Unsupported spec version.
+    UnsupportedSpecVersion {
+        version: Version,
+        min: Version,
+        max: Version,
+    },
+    /// File not found.
+    FileNotFound { path: String, description: String },
+    /// File could not be parsed.
+    InvalidFile { path: String, reason: String },
+    /// source.abi references an ABI name not listed in mapping.abis.
+    SourceAbiNotInMappingAbis {
+        data_source: String,
+        source_abi: String,
+        available: Vec<String>,
+    },
+    /// Duplicate data source or template name.
+    DuplicateName { kind: &'static str, name: String },
+    /// Ethereum data source has no handlers defined.
+    NoHandlers { data_source: String },
+    /// Invalid data source kind (not a valid Ethereum kind).
+    InvalidKind { data_source: String, kind: String },
+    /// Call or block handlers require a source address.
+    SourceAddressRequired { data_source: String },
+    /// Block handler constraint violation.
+    BlockHandlerConstraint { data_source: String, reason: String },
+    /// Event handler receipt requires apiVersion >= 0.0.7.
+    ReceiptRequiresApiVersion { data_source: String },
+    /// Eth call declarations require specVersion >= 1.2.0.
+    CallDeclsRequireSpecVersion { data_source: String },
+    /// Handler names from the manifest are missing as exports in the compiled WASM.
+    MissingWasmHandlers {
+        data_source: String,
+        missing: Vec<String>,
+    },
+    /// Failed to parse a compiled WASM file.
+    InvalidWasm { path: String, reason: String },
+    /// Event handler references an event signature not found in the ABI.
+    EventNotInAbi {
+        data_source: String,
+        event: String,
+        abi_name: String,
+    },
+    /// Call handler references a function signature not found in the ABI.
+    FunctionNotInAbi {
+        data_source: String,
+        function: String,
+        abi_name: String,
+    },
+}
+
+impl std::fmt::Display for ManifestValidationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ManifestValidationError::Shared(e) => write!(f, "{}", e),
+            ManifestValidationError::UnsupportedSpecVersion { version, min, max } => {
+                write!(
+                    f,
+                    "unsupported spec version {}: must be between {} and {}",
+                    version, min, max
+                )
+            }
+            ManifestValidationError::FileNotFound { path, description } => {
+                write!(f, "{} not found: {}", description, path)
+            }
+            ManifestValidationError::InvalidFile { path, reason } => {
+                write!(f, "invalid file {}: {}", path, reason)
+            }
+            ManifestValidationError::SourceAbiNotInMappingAbis {
+                data_source,
+                source_abi,
+                available,
+            } => {
+                if available.is_empty() {
+                    write!(
+                        f,
+                        "data source '{}': source.abi '{}' not found in mapping.abis (no ABIs defined)",
+                        data_source, source_abi
+                    )
+                } else {
+                    write!(
+                        f,
+                        "data source '{}': source.abi '{}' not found in mapping.abis (available: {})",
+                        data_source,
+                        source_abi,
+                        available.join(", ")
+                    )
+                }
+            }
+            ManifestValidationError::DuplicateName { kind, name } => {
+                write!(f, "duplicate {} name: '{}'", kind, name)
+            }
+            ManifestValidationError::NoHandlers { data_source } => {
+                write!(
+                    f,
+                    "data source '{}': no event, call, or block handlers defined",
+                    data_source
+                )
+            }
+            ManifestValidationError::InvalidKind { data_source, kind } => {
+                write!(
+                    f,
+                    "data source '{}': invalid kind '{}', expected 'ethereum' or 'ethereum/contract'",
+                    data_source, kind
+                )
+            }
+            ManifestValidationError::SourceAddressRequired { data_source } => {
+                write!(
+                    f,
+                    "data source '{}': source address is required when using call or block handlers",
+                    data_source
+                )
+            }
+            ManifestValidationError::BlockHandlerConstraint {
+                data_source,
+                reason,
+            } => {
+                write!(f, "data source '{}': {}", data_source, reason)
+            }
+            ManifestValidationError::ReceiptRequiresApiVersion { data_source } => {
+                write!(
+                    f,
+                    "data source '{}': event handlers that require transaction receipts need apiVersion >= 0.0.7",
+                    data_source
+                )
+            }
+            ManifestValidationError::CallDeclsRequireSpecVersion { data_source } => {
+                write!(
+                    f,
+                    "data source '{}': eth call declarations on event handlers require specVersion >= 1.2.0",
+                    data_source
+                )
+            }
+            ManifestValidationError::MissingWasmHandlers {
+                data_source,
+                missing,
+            } => {
+                write!(
+                    f,
+                    "data source '{}': missing WASM handlers: {}",
+                    data_source,
+                    missing.join(", ")
+                )
+            }
+            ManifestValidationError::InvalidWasm { path, reason } => {
+                write!(f, "invalid WASM file {}: {}", path, reason)
+            }
+            ManifestValidationError::EventNotInAbi {
+                data_source,
+                event,
+                abi_name,
+            } => {
+                write!(
+                    f,
+                    "data source '{}': event '{}' not found in ABI '{}'",
+                    data_source, event, abi_name
+                )
+            }
+            ManifestValidationError::FunctionNotInAbi {
+                data_source,
+                function,
+                abi_name,
+            } => {
+                write!(
+                    f,
+                    "data source '{}': function '{}' not found in ABI '{}'",
+                    data_source, function, abi_name
+                )
+            }
+        }
+    }
+}
+
+impl From<SubgraphManifestValidationError> for ManifestValidationError {
+    fn from(e: SubgraphManifestValidationError) -> Self {
+        ManifestValidationError::Shared(Box::new(e))
+    }
+}
+
+/// Validate manifest file references.
+///
+/// Checks that all referenced files exist, ABI files are valid JSON,
+/// source.abi cross-references mapping.abis, names are unique,
+/// Ethereum data sources have at least one handler, and handler
+/// signatures match events/functions in the ABI. This validation
+/// runs before codegen to catch errors early.
+///
+/// Note: Ethereum structural constraints (kind, address, block handler
+/// combos, receipt/call-decl version requirements) are validated separately
+/// in `validate_manifest` which runs during build.
+pub(crate) fn validate_manifest_files(
+    manifest: &Manifest,
+    manifest_dir: &Path,
+) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    // Validate file existence
+    errors.extend(validate_file_existence(manifest, manifest_dir));
+
+    // Validate ABIs are valid JSON
+    errors.extend(validate_abis(manifest, manifest_dir));
+
+    // Validate source.abi references an ABI in mapping.abis
+    errors.extend(validate_source_abi_references(manifest));
+
+    // Validate unique data source and template names
+    errors.extend(validate_unique_names(manifest));
+
+    // Validate Ethereum data sources have at least one handler
+    errors.extend(validate_handler_presence(manifest));
+
+    // Validate event/call handler signatures match ABI definitions
+    errors.extend(validate_handler_signatures(manifest, manifest_dir));
+
+    errors
+}
+
+/// Validate a subgraph manifest.
+///
+/// This performs several validation checks:
+/// - At least one data source exists
+/// - All data sources use the same network
+/// - All data sources use consistent API versions
+/// - Spec version is within supported range
+/// - Referenced files exist (schema, mappings, ABIs)
+/// - ABI files are valid JSON
+/// - source.abi references an ABI in mapping.abis
+/// - Data source and template names are unique
+/// - Ethereum data sources have at least one handler
+pub(crate) fn validate_manifest(
+    manifest: &Manifest,
+    manifest_dir: &Path,
+) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    // Validate using shared validation functions
+    if let Err(e) = manifest_validation::validate_has_data_sources(manifest.total_source_count()) {
+        errors.push(e.into());
+    }
+
+    // Validate spec version (gnd-specific check)
+    if manifest.spec_version < MIN_SPEC_VERSION || manifest.spec_version > *LATEST_VERSION {
+        errors.push(ManifestValidationError::UnsupportedSpecVersion {
+            version: manifest.spec_version.clone(),
+            min: MIN_SPEC_VERSION.clone(),
+            max: LATEST_VERSION.clone(),
+        });
+    }
+
+    // Collect networks from data sources and templates
+    let networks: Vec<Option<&str>> = manifest
+        .data_sources
+        .iter()
+        .map(|ds| ds.network.as_deref())
+        .chain(manifest.templates.iter().map(|t| t.network.as_deref()))
+        .collect();
+
+    // Only validate networks if there are data sources
+    if !manifest.data_sources.is_empty()
+        && let Err(e) = manifest_validation::validate_single_network(&networks)
+    {
+        errors.push(e.into());
+    }
+
+    // Collect API versions from data sources and templates
+    let api_versions: Vec<Version> = manifest
+        .data_sources
+        .iter()
+        .filter_map(|ds| ds.api_version.clone())
+        .chain(
+            manifest
+                .templates
+                .iter()
+                .filter_map(|t| t.api_version.clone()),
+        )
+        .collect();
+
+    if let Err(e) = manifest_validation::validate_api_versions(&api_versions) {
+        errors.push(e.into());
+    }
+
+    // Validate file existence
+    errors.extend(validate_file_existence(manifest, manifest_dir));
+
+    // Validate ABIs are valid JSON
+    errors.extend(validate_abis(manifest, manifest_dir));
+
+    // Validate source.abi references an ABI in mapping.abis
+    errors.extend(validate_source_abi_references(manifest));
+
+    // Validate unique data source and template names
+    errors.extend(validate_unique_names(manifest));
+
+    // Validate Ethereum data sources have at least one handler
+    errors.extend(validate_handler_presence(manifest));
+
+    // Validate Ethereum-specific structural constraints
+    errors.extend(validate_ethereum_constraints(manifest));
+
+    // Validate event/call handler signatures match ABI definitions
+    errors.extend(validate_handler_signatures(manifest, manifest_dir));
+
+    errors
+}
+
+/// Validate that all referenced files exist.
+fn validate_file_existence(
+    manifest: &Manifest,
+    manifest_dir: &Path,
+) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    // Check schema file
+    if let Some(schema_path) = &manifest.schema {
+        let full_path = manifest_dir.join(schema_path.as_str());
+        if !full_path.exists() {
+            errors.push(ManifestValidationError::FileNotFound {
+                path: schema_path.to_string(),
+                description: "Schema file".to_string(),
+            });
+        }
+    }
+
+    // Check data source files
+    for ds in &manifest.data_sources {
+        errors.extend(validate_data_source_files(ds, manifest_dir));
+    }
+
+    // Check template files
+    for template in &manifest.templates {
+        errors.extend(validate_template_files(template, manifest_dir));
+    }
+
+    errors
+}
+
+/// Validate data source file references.
+fn validate_data_source_files(
+    ds: &DataSource,
+    manifest_dir: &Path,
+) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    // Check mapping file
+    if let Some(mapping_path) = &ds.mapping_file {
+        let full_path = manifest_dir.join(mapping_path.as_str());
+        if !full_path.exists() {
+            errors.push(ManifestValidationError::FileNotFound {
+                path: mapping_path.to_string(),
+                description: format!("Mapping file for data source '{}'", ds.name),
+            });
+        }
+    }
+
+    // Check ABI files
+    for abi in &ds.abis {
+        let full_path = manifest_dir.join(&abi.file);
+        if !full_path.exists() {
+            errors.push(ManifestValidationError::FileNotFound {
+                path: abi.file.clone(),
+                description: format!("ABI '{}' for data source '{}'", abi.name, ds.name),
+            });
+        }
+    }
+
+    errors
+}
+
+/// Validate template file references.
+fn validate_template_files(
+    template: &Template,
+    manifest_dir: &Path,
+) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    // Check mapping file
+    if let Some(mapping_path) = &template.mapping_file {
+        let full_path = manifest_dir.join(mapping_path.as_str());
+        if !full_path.exists() {
+            errors.push(ManifestValidationError::FileNotFound {
+                path: mapping_path.to_string(),
+                description: format!("Mapping file for template '{}'", template.name),
+            });
+        }
+    }
+
+    errors
+}
+
+/// Validate that ABI files are valid JSON.
+fn validate_abis(manifest: &Manifest, manifest_dir: &Path) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    for ds in &manifest.data_sources {
+        errors.extend(validate_data_source_abis(ds, manifest_dir));
+    }
+
+    errors
+}
+
+/// Validate ABIs for a data source.
+fn validate_data_source_abis(ds: &DataSource, manifest_dir: &Path) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    for abi in &ds.abis {
+        if let Err(e) = validate_abi_file(abi, manifest_dir) {
+            errors.push(e);
+        }
+    }
+
+    errors
+}
+
+/// Validate a single ABI file.
+fn validate_abi_file(abi: &Abi, manifest_dir: &Path) -> Result<(), ManifestValidationError> {
+    let full_path = manifest_dir.join(&abi.file);
+
+    // Only validate if file exists (file existence is checked separately)
+    if !full_path.exists() {
+        return Ok(());
+    }
+
+    let content =
+        std::fs::read_to_string(&full_path).map_err(|e| ManifestValidationError::InvalidFile {
+            path: abi.file.clone(),
+            reason: format!("failed to read: {}", e),
+        })?;
+
+    // Try to parse as JSON
+    let _: serde_json::Value =
+        serde_json::from_str(&content).map_err(|e| ManifestValidationError::InvalidFile {
+            path: abi.file.clone(),
+            reason: format!("invalid JSON: {}", e),
+        })?;
+
+    Ok(())
+}
+
+/// Validate that each data source's `source.abi` references an ABI listed in `mapping.abis`.
+fn validate_source_abi_references(manifest: &Manifest) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    for ds in &manifest.data_sources {
+        if let Some(source_abi) = &ds.source_abi
+            && !ds.abis.iter().any(|a| a.name == *source_abi)
+        {
+            errors.push(ManifestValidationError::SourceAbiNotInMappingAbis {
+                data_source: ds.name.clone(),
+                source_abi: source_abi.clone(),
+                available: ds.abis.iter().map(|a| a.name.clone()).collect(),
+            });
+        }
+    }
+
+    for t in &manifest.templates {
+        if let Some(source_abi) = &t.source_abi
+            && !t.abis.iter().any(|a| a.name == *source_abi)
+        {
+            errors.push(ManifestValidationError::SourceAbiNotInMappingAbis {
+                data_source: t.name.clone(),
+                source_abi: source_abi.clone(),
+                available: t.abis.iter().map(|a| a.name.clone()).collect(),
+            });
+        }
+    }
+
+    errors
+}
+
+/// Validate that data source and template names are unique.
+fn validate_unique_names(manifest: &Manifest) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+    let mut seen_ds_names = std::collections::HashSet::new();
+    let mut seen_template_names = std::collections::HashSet::new();
+
+    for ds in &manifest.data_sources {
+        if !seen_ds_names.insert(&ds.name) {
+            errors.push(ManifestValidationError::DuplicateName {
+                kind: "data source",
+                name: ds.name.clone(),
+            });
+        }
+    }
+
+    for t in &manifest.templates {
+        if !seen_template_names.insert(&t.name) {
+            errors.push(ManifestValidationError::DuplicateName {
+                kind: "template",
+                name: t.name.clone(),
+            });
+        }
+    }
+
+    errors
+}
+
+/// Validate that Ethereum data sources have at least one handler defined.
+fn validate_handler_presence(manifest: &Manifest) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    for ds in &manifest.data_sources {
+        // Only check Ethereum data sources (which have source_abi set)
+        if ds.source_abi.is_some()
+            && ds.event_handlers.is_empty()
+            && ds.call_handlers.is_empty()
+            && ds.block_handlers.is_empty()
+        {
+            errors.push(ManifestValidationError::NoHandlers {
+                data_source: ds.name.clone(),
+            });
+        }
+    }
+
+    for t in &manifest.templates {
+        if t.source_abi.is_some()
+            && t.event_handlers.is_empty()
+            && t.call_handlers.is_empty()
+            && t.block_handlers.is_empty()
+        {
+            errors.push(ManifestValidationError::NoHandlers {
+                data_source: t.name.clone(),
+            });
+        }
+    }
+
+    errors
+}
+
+/// Valid Ethereum data source kinds (matches graph-node's `ETHEREUM_KINDS`).
+const ETHEREUM_KINDS: &[&str] = &["ethereum/contract", "ethereum"];
+
+/// Validate Ethereum-specific structural constraints on data sources and templates.
+///
+/// This covers:
+/// - Data source kind must be `ethereum` or `ethereum/contract`
+/// - Source address is required when call or block handlers are present
+/// - Block handler filter constraints (no duplicates, no invalid combos)
+/// - Event handler receipt requires apiVersion >= 0.0.7
+/// - Eth call declarations on event handlers require specVersion >= 1.2.0
+fn validate_ethereum_constraints(manifest: &Manifest) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    for ds in &manifest.data_sources {
+        // Only validate Ethereum data sources (identified by having source_abi)
+        if ds.source_abi.is_none() {
+            continue;
+        }
+        errors.extend(validate_ethereum_kind(&ds.name, &ds.kind));
+        errors.extend(validate_source_address_required(
+            &ds.name,
+            ds.source_address.is_some(),
+            &ds.call_handlers,
+            &ds.block_handlers,
+        ));
+        errors.extend(validate_block_handler_constraints(
+            &ds.name,
+            &ds.block_handlers,
+        ));
+        errors.extend(validate_receipt_api_version(
+            &ds.name,
+            ds.api_version.as_ref(),
+            &ds.event_handlers,
+        ));
+        errors.extend(validate_call_decls_spec_version(
+            &ds.name,
+            &manifest.spec_version,
+            &ds.event_handlers,
+        ));
+    }
+
+    for t in &manifest.templates {
+        if t.source_abi.is_none() {
+            continue;
+        }
+        errors.extend(validate_ethereum_kind(&t.name, &t.kind));
+        // Templates don't have source addresses — skip address validation
+        errors.extend(validate_block_handler_constraints(
+            &t.name,
+            &t.block_handlers,
+        ));
+        errors.extend(validate_receipt_api_version(
+            &t.name,
+            t.api_version.as_ref(),
+            &t.event_handlers,
+        ));
+        errors.extend(validate_call_decls_spec_version(
+            &t.name,
+            &manifest.spec_version,
+            &t.event_handlers,
+        ));
+    }
+
+    errors
+}
+
+/// Validate that an Ethereum data source has a valid kind.
+fn validate_ethereum_kind(name: &str, kind: &str) -> Vec<ManifestValidationError> {
+    if ETHEREUM_KINDS.contains(&kind) {
+        vec![]
+    } else {
+        vec![ManifestValidationError::InvalidKind {
+            data_source: name.to_string(),
+            kind: kind.to_string(),
+        }]
+    }
+}
+
+/// Validate that a source address is present when call or block handlers are used.
+fn validate_source_address_required(
+    name: &str,
+    has_address: bool,
+    call_handlers: &[CallHandler],
+    block_handlers: &[crate::manifest::BlockHandler],
+) -> Vec<ManifestValidationError> {
+    if !has_address && (!call_handlers.is_empty() || !block_handlers.is_empty()) {
+        vec![ManifestValidationError::SourceAddressRequired {
+            data_source: name.to_string(),
+        }]
+    } else {
+        vec![]
+    }
+}
+
+/// Validate block handler constraints:
+/// - At most one handler of each filter type
+/// - Non-filtered handlers cannot be mixed with polling or once handlers
+fn validate_block_handler_constraints(
+    name: &str,
+    block_handlers: &[crate::manifest::BlockHandler],
+) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    let mut non_filtered = 0u32;
+    let mut call_filtered = 0u32;
+    let mut polling_filtered = 0u32;
+    let mut once_filtered = 0u32;
+
+    for handler in block_handlers {
+        match &handler.filter {
+            None => non_filtered += 1,
+            Some(BlockHandlerFilterKind::Call) => call_filtered += 1,
+            Some(BlockHandlerFilterKind::Once) => once_filtered += 1,
+            Some(BlockHandlerFilterKind::Polling) => polling_filtered += 1,
+        }
+    }
+
+    // Check for duplicates of any type
+    if non_filtered > 1 || call_filtered > 1 || once_filtered > 1 || polling_filtered > 1 {
+        errors.push(ManifestValidationError::BlockHandlerConstraint {
+            data_source: name.to_string(),
+            reason: "duplicated block handlers".to_string(),
+        });
+    }
+
+    // Non-filtered handlers cannot be mixed with polling or once handlers
+    // (mixing with call filter is allowed)
+    if non_filtered > 0 && (polling_filtered > 0 || once_filtered > 0) {
+        errors.push(ManifestValidationError::BlockHandlerConstraint {
+            data_source: name.to_string(),
+            reason: "combination of non-filtered and polling/once block handlers is not allowed"
+                .to_string(),
+        });
+    }
+
+    errors
+}
+
+/// Validate that event handlers requiring receipts have apiVersion >= 0.0.7.
+fn validate_receipt_api_version(
+    name: &str,
+    api_version: Option<&Version>,
+    event_handlers: &[crate::manifest::EventHandler],
+) -> Vec<ManifestValidationError> {
+    let api_version = match api_version {
+        Some(v) => v,
+        None => return vec![],
+    };
+
+    if *api_version >= Version::new(0, 0, 7) {
+        return vec![];
+    }
+
+    if event_handlers.iter().any(|h| h.receipt) {
+        vec![ManifestValidationError::ReceiptRequiresApiVersion {
+            data_source: name.to_string(),
+        }]
+    } else {
+        vec![]
+    }
+}
+
+/// Validate that event handlers with eth call declarations have specVersion >= 1.2.0.
+fn validate_call_decls_spec_version(
+    name: &str,
+    spec_version: &Version,
+    event_handlers: &[crate::manifest::EventHandler],
+) -> Vec<ManifestValidationError> {
+    if *spec_version >= Version::new(1, 2, 0) {
+        return vec![];
+    }
+
+    if event_handlers.iter().any(|h| h.has_call_decls) {
+        vec![ManifestValidationError::CallDeclsRequireSpecVersion {
+            data_source: name.to_string(),
+        }]
+    } else {
+        vec![]
+    }
+}
+
+/// Validate that event and call handler signatures match events/functions in the ABI.
+///
+/// For each Ethereum data source (and template) with a `source.abi`, loads the
+/// corresponding ABI file and checks:
+/// - Each event handler's `event` signature matches an event in the ABI
+/// - Each call handler's `function` signature matches a function in the ABI
+fn validate_handler_signatures(
+    manifest: &Manifest,
+    manifest_dir: &Path,
+) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    for ds in &manifest.data_sources {
+        if let Some(source_abi) = &ds.source_abi
+            && let Some(abi_entry) = ds.abis.iter().find(|a| a.name == *source_abi)
+        {
+            let abi_path = manifest_dir.join(&abi_entry.file);
+            if let Some(contract) = load_abi(&abi_path) {
+                errors.extend(validate_event_signatures(
+                    &ds.name,
+                    source_abi,
+                    &ds.event_handlers,
+                    &contract,
+                ));
+                errors.extend(validate_function_signatures(
+                    &ds.name,
+                    source_abi,
+                    &ds.call_handlers,
+                    &contract,
+                ));
+            }
+        }
+    }
+
+    for t in &manifest.templates {
+        if let Some(source_abi) = &t.source_abi
+            && let Some(abi_entry) = t.abis.iter().find(|a| a.name == *source_abi)
+        {
+            let abi_path = manifest_dir.join(&abi_entry.file);
+            if let Some(contract) = load_abi(&abi_path) {
+                errors.extend(validate_event_signatures(
+                    &t.name,
+                    source_abi,
+                    &t.event_handlers,
+                    &contract,
+                ));
+                errors.extend(validate_function_signatures(
+                    &t.name,
+                    source_abi,
+                    &t.call_handlers,
+                    &contract,
+                ));
+            }
+        }
+    }
+
+    errors
+}
+
+/// Try to load an ABI file as a `JsonAbi`.
+///
+/// Returns `None` if the file doesn't exist or can't be parsed (those errors
+/// are reported separately by file existence and ABI JSON validation).
+fn load_abi(abi_path: &Path) -> Option<JsonAbi> {
+    let content = std::fs::read_to_string(abi_path).ok()?;
+    let normalized = crate::abi::normalize_abi_json(&content).ok()?;
+    let json_str = normalized.to_string();
+    serde_json::from_str(&json_str).ok()
+}
+
+/// Build the event signature with `indexed` hints: `Name(indexed type1,type2,...)`.
+fn event_signature_with_indexed(event: &Event) -> String {
+    let params: Vec<String> = event
+        .inputs
+        .iter()
+        .map(|p| {
+            let ty = p.selector_type();
+            if p.indexed {
+                format!("indexed {}", ty)
+            } else {
+                ty.into_owned()
+            }
+        })
+        .collect();
+    format!("{}({})", event.name, params.join(","))
+}
+
+/// Validate that each event handler's event signature matches an event in the ABI.
+///
+/// Matching follows the same logic as graph-node's `contract_event_with_signature`:
+/// 1. Try exact match with `indexed` hints
+/// 2. Fall back to matching without `indexed` if only one event variant exists
+fn validate_event_signatures(
+    ds_name: &str,
+    abi_name: &str,
+    event_handlers: &[crate::manifest::EventHandler],
+    abi: &JsonAbi,
+) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    let all_events: Vec<&Event> = abi.events.values().flatten().collect();
+
+    for handler in event_handlers {
+        let signature = &handler.event;
+
+        // Try exact match with indexed hints
+        let exact_match = all_events
+            .iter()
+            .any(|e| event_signature_with_indexed(e) == *signature);
+
+        if exact_match {
+            continue;
+        }
+
+        // Fallback: match without indexed if only one event variant with that name
+        let event_name = signature.split('(').next().unwrap_or("");
+        let matching_by_name: Vec<&&Event> =
+            all_events.iter().filter(|e| e.name == event_name).collect();
+
+        let fallback_match =
+            matching_by_name.len() == 1 && matching_by_name[0].signature() == *signature;
+
+        if !fallback_match {
+            errors.push(ManifestValidationError::EventNotInAbi {
+                data_source: ds_name.to_string(),
+                event: signature.clone(),
+                abi_name: abi_name.to_string(),
+            });
+        }
+    }
+
+    errors
+}
+
+/// Validate that each call handler's function signature matches a function in the ABI.
+fn validate_function_signatures(
+    ds_name: &str,
+    abi_name: &str,
+    call_handlers: &[CallHandler],
+    abi: &JsonAbi,
+) -> Vec<ManifestValidationError> {
+    let mut errors = Vec::new();
+
+    let all_functions: Vec<&Function> = abi.functions.values().flatten().collect();
+
+    for handler in call_handlers {
+        let target = &handler.function;
+
+        let found = all_functions.iter().any(|f| f.signature() == *target);
+
+        if !found {
+            errors.push(ManifestValidationError::FunctionNotInAbi {
+                data_source: ds_name.to_string(),
+                function: target.clone(),
+                abi_name: abi_name.to_string(),
+            });
+        }
+    }
+
+    errors
+}
+
+/// Format manifest validation errors for display.
+pub(crate) fn format_manifest_errors(errors: &[ManifestValidationError]) -> String {
+    errors
+        .iter()
+        .map(|e| format!("  - {}", e))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+/// Extract exported function names from a WASM binary.
+fn wasm_exported_functions(wasm_bytes: &[u8]) -> Result<HashSet<String>> {
+    use wasmparser::Payload;
+
+    let mut exports = HashSet::new();
+    for payload in wasmparser::Parser::new(0).parse_all(wasm_bytes) {
+        if let Payload::ExportSection(s) = payload? {
+            for export in s {
+                let export = export?;
+                if export.kind == wasmparser::ExternalKind::Func {
+                    exports.insert(export.name.to_string());
+                }
+            }
+        }
+    }
+    Ok(exports)
+}
+
+/// Validate that all handler names from a data source exist as exports in the
+/// compiled WASM file. Returns errors for any handlers missing from the WASM.
+pub(crate) fn validate_wasm_handlers(
+    wasm_path: &Path,
+    ds_name: &str,
+    handler_names: &[&str],
+) -> Vec<ManifestValidationError> {
+    let wasm_bytes = match std::fs::read(wasm_path) {
+        Ok(bytes) => bytes,
+        Err(e) => {
+            return vec![ManifestValidationError::InvalidWasm {
+                path: wasm_path.display().to_string(),
+                reason: format!("failed to read: {}", e),
+            }];
+        }
+    };
+
+    let exports = match wasm_exported_functions(&wasm_bytes) {
+        Ok(exports) => exports,
+        Err(e) => {
+            return vec![ManifestValidationError::InvalidWasm {
+                path: wasm_path.display().to_string(),
+                reason: format!("failed to parse: {}", e),
+            }];
+        }
+    };
+
+    let missing: Vec<String> = handler_names
+        .iter()
+        .filter(|name| !exports.contains(**name))
+        .map(|name| name.to_string())
+        .collect();
+
+    if missing.is_empty() {
+        vec![]
+    } else {
+        vec![ManifestValidationError::MissingWasmHandlers {
+            data_source: ds_name.to_string(),
+            missing,
+        }]
+    }
+}
+
+/// Collect all handler names from a data source.
+pub(crate) fn collect_handler_names(ds: &DataSource) -> Vec<&str> {
+    let mut names = Vec::new();
+    for h in &ds.event_handlers {
+        names.push(h.handler.as_str());
+    }
+    for h in &ds.call_handlers {
+        names.push(h.handler.as_str());
+    }
+    for h in &ds.block_handlers {
+        names.push(h.handler.as_str());
+    }
+    names
+}
+
+/// Collect all handler names from a template.
+pub(crate) fn collect_template_handler_names(t: &Template) -> Vec<&str> {
+    let mut names = Vec::new();
+    for h in &t.event_handlers {
+        names.push(h.handler.as_str());
+    }
+    for h in &t.call_handlers {
+        names.push(h.handler.as_str());
+    }
+    for h in &t.block_handlers {
+        names.push(h.handler.as_str());
+    }
+    names
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::manifest::{BlockHandler, EventHandler};
+    use std::fs;
+    use tempfile::TempDir;
+
+    fn event_handler(name: &str) -> EventHandler {
+        EventHandler {
+            event: "Transfer(address,address,uint256)".to_string(),
+            handler: name.to_string(),
+            receipt: false,
+            has_call_decls: false,
+        }
+    }
+
+    fn call_handler(name: &str) -> CallHandler {
+        CallHandler {
+            function: "approve(address,uint256)".to_string(),
+            handler: name.to_string(),
+        }
+    }
+
+    fn block_handler(name: &str) -> BlockHandler {
+        BlockHandler {
+            handler: name.to_string(),
+            filter: None,
+        }
+    }
+
+    fn block_handler_with_filter(name: &str, filter: BlockHandlerFilterKind) -> BlockHandler {
+        BlockHandler {
+            handler: name.to_string(),
+            filter: Some(filter),
+        }
+    }
+
+    #[test]
+    fn test_validate_valid_schema() {
+        let temp_dir = TempDir::new().unwrap();
+        let schema_path = temp_dir.path().join("schema.graphql");
+
+        let schema_content = r#"
+type MyEntity @entity {
+  id: ID!
+  name: String!
+}
+"#;
+        fs::write(&schema_path, schema_content).unwrap();
+
+        let spec_version = Version::new(0, 0, 4);
+        let errors = validate_schema(&schema_path, &spec_version).unwrap();
+        assert!(errors.is_empty(), "Expected no errors, got: {:?}", errors);
+    }
+
+    #[test]
+    fn test_validate_missing_entity_directive() {
+        let temp_dir = TempDir::new().unwrap();
+        let schema_path = temp_dir.path().join("schema.graphql");
+
+        // Schema without @entity directive
+        let schema_content = r#"
+type MyEntity {
+  id: ID!
+  name: String!
+}
+"#;
+        fs::write(&schema_path, schema_content).unwrap();
+
+        let spec_version = Version::new(0, 0, 4);
+        let errors = validate_schema(&schema_path, &spec_version).unwrap();
+        assert!(!errors.is_empty(), "Expected validation errors");
+    }
+
+    #[test]
+    fn test_validate_missing_id_field() {
+        let temp_dir = TempDir::new().unwrap();
+        let schema_path = temp_dir.path().join("schema.graphql");
+
+        // Schema without id field
+        let schema_content = r#"
+type MyEntity @entity {
+  name: String!
+}
+"#;
+        fs::write(&schema_path, schema_content).unwrap();
+
+        let spec_version = Version::new(0, 0, 4);
+        let errors = validate_schema(&schema_path, &spec_version).unwrap();
+        assert!(!errors.is_empty(), "Expected validation errors");
+        let formatted = format_schema_errors(&errors);
+        assert!(
+            formatted.contains("id"),
+            "Error should mention missing id field"
+        );
+    }
+
+    #[test]
+    fn test_validate_invalid_derived_from() {
+        let temp_dir = TempDir::new().unwrap();
+        let schema_path = temp_dir.path().join("schema.graphql");
+
+        // Schema with invalid @derivedFrom
+        let schema_content = r#"
+type User @entity {
+  id: ID!
+  posts: [Post!]! @derivedFrom(field: "nonexistent")
+}
+
+type Post @entity {
+  id: ID!
+  author: User!
+}
+"#;
+        fs::write(&schema_path, schema_content).unwrap();
+
+        let spec_version = Version::new(0, 0, 4);
+        let errors = validate_schema(&schema_path, &spec_version).unwrap();
+        assert!(!errors.is_empty(), "Expected validation errors");
+    }
+
+    #[test]
+    fn test_format_schema_errors() {
+        let errors = vec![
+            SchemaValidationError::IdFieldMissing("TestEntity".to_string()),
+            SchemaValidationError::InterfaceUndefined("IFoo".to_string()),
+        ];
+
+        let formatted = format_schema_errors(&errors);
+        assert!(formatted.contains("TestEntity"));
+        assert!(formatted.contains("IFoo"));
+        assert!(formatted.contains("  - ")); // Check indent
+    }
+
+    // Helper to create a test manifest
+    fn create_test_manifest(data_sources: Vec<DataSource>, templates: Vec<Template>) -> Manifest {
+        Manifest {
+            spec_version: Version::new(0, 0, 4),
+            schema: Some("schema.graphql".to_string()),
+            features: vec![],
+            graft: None,
+            data_sources,
+            templates,
+        }
+    }
+
+    fn create_data_source(
+        name: &str,
+        network: Option<&str>,
+        api_version: Option<Version>,
+    ) -> DataSource {
+        DataSource {
+            name: name.to_string(),
+            kind: "ethereum/contract".to_string(),
+            network: network.map(String::from),
+            mapping_file: Some(format!("src/{}.ts", name)),
+            api_version,
+            abis: vec![],
+            source_address: None,
+            source_abi: None,
+            start_block: 0,
+            end_block: None,
+            event_handlers: vec![],
+            call_handlers: vec![],
+            block_handlers: vec![],
+        }
+    }
+
+    fn create_subgraph_data_source(name: &str, address: &str) -> DataSource {
+        DataSource {
+            name: name.to_string(),
+            kind: "subgraph".to_string(),
+            network: None,
+            mapping_file: None,
+            api_version: None,
+            abis: vec![],
+            source_address: Some(address.to_string()),
+            source_abi: None,
+            start_block: 0,
+            end_block: None,
+            event_handlers: vec![],
+            call_handlers: vec![],
+            block_handlers: vec![],
+        }
+    }
+
+    #[test]
+    fn test_validate_manifest_no_data_sources() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest = create_test_manifest(vec![], vec![]);
+
+        let errors = validate_manifest(&manifest, temp_dir.path());
+
+        assert!(errors.iter().any(|e| matches!(
+            e,
+            ManifestValidationError::Shared(e) if matches!(e.as_ref(), SubgraphManifestValidationError::NoDataSources)
+        )));
+    }
+
+    #[test]
+    fn test_validate_manifest_only_subgraph_sources() {
+        let temp_dir = TempDir::new().unwrap();
+
+        // Create schema file
+        fs::write(
+            temp_dir.path().join("schema.graphql"),
+            "type T @entity { id: ID! }",
+        )
+        .unwrap();
+
+        // Manifest with only subgraph sources (no regular data sources)
+        let data_sources = vec![create_subgraph_data_source(
+            "SourceSubgraph",
+            "QmSourceHash123",
+        )];
+        let manifest = Manifest {
+            spec_version: Version::new(1, 0, 0),
+            schema: Some("schema.graphql".to_string()),
+            features: vec![],
+            graft: None,
+            data_sources,
+            templates: vec![],
+        };
+
+        let errors = validate_manifest(&manifest, temp_dir.path());
+
+        // Should NOT have "no data sources" error since we have subgraph sources
+        assert!(
+            !errors.iter().any(|e| matches!(
+                e,
+                ManifestValidationError::Shared(e) if matches!(e.as_ref(), SubgraphManifestValidationError::NoDataSources)
+            )),
+            "Manifest with subgraph sources should not fail 'no data sources' validation"
+        );
+    }
+
+    #[test]
+    fn test_validate_manifest_multiple_networks() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest = create_test_manifest(
+            vec![
+                create_data_source("ds1", Some("mainnet"), None),
+                create_data_source("ds2", Some("ropsten"), None),
+            ],
+            vec![],
+        );
+
+        let errors = validate_manifest(&manifest, temp_dir.path());
+
+        assert!(errors.iter().any(|e| matches!(
+            e,
+            ManifestValidationError::Shared(e) if matches!(e.as_ref(), SubgraphManifestValidationError::MultipleEthereumNetworks)
+        )));
+    }
+
+    #[test]
+    fn test_validate_manifest_different_api_versions() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest = create_test_manifest(
+            vec![
+                create_data_source("ds1", Some("mainnet"), Some(Version::new(0, 0, 5))),
+                create_data_source("ds2", Some("mainnet"), Some(Version::new(0, 0, 6))),
+            ],
+            vec![],
+        );
+
+        let errors = validate_manifest(&manifest, temp_dir.path());
+
+        assert!(errors.iter().any(|e| matches!(
+            e,
+            ManifestValidationError::Shared(e) if matches!(e.as_ref(), SubgraphManifestValidationError::DifferentApiVersions(_))
+        )));
+    }
+
+    #[test]
+    fn test_validate_manifest_missing_schema_file() {
+        let temp_dir = TempDir::new().unwrap();
+        let manifest = create_test_manifest(
+            vec![create_data_source("ds1", Some("mainnet"), None)],
+            vec![],
+        );
+
+        let errors = validate_manifest(&manifest, temp_dir.path());
+
+        assert!(errors.iter().any(|e| matches!(
+            e,
+            ManifestValidationError::FileNotFound { description, .. } if description.contains("Schema")
+        )));
+    }
+
+    #[test]
+    fn test_validate_manifest_missing_mapping_file() {
+        let temp_dir = TempDir::new().unwrap();
+
+        // Create schema file
+        fs::write(
+            temp_dir.path().join("schema.graphql"),
+            "type T @entity { id: ID! }",
+        )
+        .unwrap();
+
+        let manifest = create_test_manifest(
+            vec![create_data_source("ds1", Some("mainnet"), None)],
+            vec![],
+        );
+
+        let errors = validate_manifest(&manifest, temp_dir.path());
+
+        assert!(errors.iter().any(|e| matches!(
+            e,
+            ManifestValidationError::FileNotFound { description, .. } if description.contains("Mapping")
+        )));
+    }
+
+    #[test]
+    fn test_validate_manifest_invalid_abi_json() {
+        let temp_dir = TempDir::new().unwrap();
+
+        // Create schema and mapping files
+        fs::write(
+            temp_dir.path().join("schema.graphql"),
+            "type T @entity { id: ID! }",
+        )
+        .unwrap();
+        fs::create_dir_all(temp_dir.path().join("src")).unwrap();
+        fs::write(temp_dir.path().join("src/ds1.ts"), "// mapping").unwrap();
+
+        // Create invalid ABI file
+        fs::create_dir_all(temp_dir.path().join("abis")).unwrap();
+        fs::write(temp_dir.path().join("abis/ERC20.json"), "not valid json").unwrap();
+
+        let mut ds = create_data_source("ds1", Some("mainnet"), None);
+        ds.abis = vec![Abi {
+            name: "ERC20".to_string(),
+            file: "abis/ERC20.json".to_string(),
+        }];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+
+        let errors = validate_manifest(&manifest, temp_dir.path());
+
+        assert!(errors.iter().any(|e| matches!(
+            e,
+            ManifestValidationError::InvalidFile { reason, .. } if reason.contains("JSON")
+        )));
+    }
+
+    #[test]
+    fn test_validate_manifest_valid() {
+        let temp_dir = TempDir::new().unwrap();
+
+        // Create all required files
+        fs::write(
+            temp_dir.path().join("schema.graphql"),
+            "type T @entity { id: ID! }",
+        )
+        .unwrap();
+        fs::create_dir_all(temp_dir.path().join("src")).unwrap();
+        fs::write(temp_dir.path().join("src/ds1.ts"), "// mapping").unwrap();
+        fs::create_dir_all(temp_dir.path().join("abis")).unwrap();
+        fs::write(temp_dir.path().join("abis/ERC20.json"), erc20_abi_json()).unwrap();
+
+        let mut ds = create_data_source("ds1", Some("mainnet"), Some(Version::new(0, 0, 6)));
+        ds.abis = vec![Abi {
+            name: "ERC20".to_string(),
+            file: "abis/ERC20.json".to_string(),
+        }];
+        ds.source_abi = Some("ERC20".to_string());
+        ds.event_handlers = vec![event_handler("handleTransfer")];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+
+        let errors = validate_manifest(&manifest, temp_dir.path());
+
+        assert!(errors.is_empty(), "Expected no errors, got: {:?}", errors);
+    }
+
+    #[test]
+    fn test_format_manifest_errors() {
+        let errors = vec![
+            ManifestValidationError::Shared(Box::new(
+                SubgraphManifestValidationError::NoDataSources,
+            )),
+            ManifestValidationError::FileNotFound {
+                path: "schema.graphql".to_string(),
+                description: "Schema file".to_string(),
+            },
+        ];
+
+        let formatted = format_manifest_errors(&errors);
+        assert!(formatted.contains("no data sources"));
+        assert!(formatted.contains("schema.graphql"));
+        assert!(formatted.contains("  - "));
+    }
+
+    // --- source.abi cross-reference tests ---
+
+    #[test]
+    fn test_validate_source_abi_found_in_mapping_abis() {
+        let mut ds = create_data_source("ds1", Some("mainnet"), None);
+        ds.source_abi = Some("ERC20".to_string());
+        ds.abis = vec![Abi {
+            name: "ERC20".to_string(),
+            file: "abis/ERC20.json".to_string(),
+        }];
+        ds.event_handlers = vec![event_handler("handleTransfer")];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_source_abi_references(&manifest);
+        assert!(errors.is_empty(), "Expected no errors, got: {:?}", errors);
+    }
+
+    #[test]
+    fn test_validate_source_abi_not_in_mapping_abis() {
+        let mut ds = create_data_source("ds1", Some("mainnet"), None);
+        ds.source_abi = Some("ERC721".to_string());
+        ds.abis = vec![Abi {
+            name: "ERC20".to_string(),
+            file: "abis/ERC20.json".to_string(),
+        }];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_source_abi_references(&manifest);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::SourceAbiNotInMappingAbis {
+                data_source,
+                source_abi,
+                available,
+            } if data_source == "ds1" && source_abi == "ERC721" && available == &["ERC20"]
+        ));
+    }
+
+    #[test]
+    fn test_validate_source_abi_no_abis_defined() {
+        let mut ds = create_data_source("ds1", Some("mainnet"), None);
+        ds.source_abi = Some("ERC20".to_string());
+        // abis is empty (default from create_data_source)
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_source_abi_references(&manifest);
+        assert_eq!(errors.len(), 1);
+        let msg = format!("{}", errors[0]);
+        assert!(msg.contains("no ABIs defined"));
+    }
+
+    #[test]
+    fn test_validate_source_abi_skips_non_ethereum() {
+        // Subgraph data sources have no source_abi, should be skipped
+        let ds = create_subgraph_data_source("sub1", "QmHash123");
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_source_abi_references(&manifest);
+        assert!(errors.is_empty());
+    }
+
+    // --- unique names tests ---
+
+    #[test]
+    fn test_validate_unique_data_source_names() {
+        let ds1 = create_data_source("Token", Some("mainnet"), None);
+        let ds2 = create_data_source("Token", Some("mainnet"), None);
+        let manifest = create_test_manifest(vec![ds1, ds2], vec![]);
+
+        let errors = validate_unique_names(&manifest);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::DuplicateName { kind, name }
+                if *kind == "data source" && name == "Token"
+        ));
+    }
+
+    #[test]
+    fn test_validate_unique_template_names() {
+        let t1 = Template {
+            name: "DynToken".to_string(),
+            kind: "ethereum/contract".to_string(),
+            network: Some("mainnet".to_string()),
+            mapping_file: Some("src/dyn.ts".to_string()),
+            api_version: None,
+            abis: vec![],
+            source_abi: None,
+            event_handlers: vec![],
+            call_handlers: vec![],
+            block_handlers: vec![],
+        };
+        let t2 = Template {
+            name: "DynToken".to_string(),
+            kind: "ethereum/contract".to_string(),
+            network: Some("mainnet".to_string()),
+            mapping_file: Some("src/dyn2.ts".to_string()),
+            api_version: None,
+            abis: vec![],
+            source_abi: None,
+            event_handlers: vec![],
+            call_handlers: vec![],
+            block_handlers: vec![],
+        };
+
+        let manifest = create_test_manifest(vec![], vec![t1, t2]);
+        let errors = validate_unique_names(&manifest);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::DuplicateName { kind, name }
+                if *kind == "template" && name == "DynToken"
+        ));
+    }
+
+    #[test]
+    fn test_validate_unique_names_all_distinct() {
+        let ds1 = create_data_source("TokenA", Some("mainnet"), None);
+        let ds2 = create_data_source("TokenB", Some("mainnet"), None);
+        let manifest = create_test_manifest(vec![ds1, ds2], vec![]);
+
+        let errors = validate_unique_names(&manifest);
+        assert!(errors.is_empty());
+    }
+
+    // --- handler presence tests ---
+
+    #[test]
+    fn test_validate_handler_presence_with_event_handler() {
+        let mut ds = create_data_source("ds1", Some("mainnet"), None);
+        ds.source_abi = Some("ERC20".to_string());
+        ds.event_handlers = vec![event_handler("handleTransfer")];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_handler_presence(&manifest);
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_handler_presence_with_call_handler() {
+        let mut ds = create_data_source("ds1", Some("mainnet"), None);
+        ds.source_abi = Some("ERC20".to_string());
+        ds.call_handlers = vec![call_handler("handleApprove")];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_handler_presence(&manifest);
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_handler_presence_with_block_handler() {
+        let mut ds = create_data_source("ds1", Some("mainnet"), None);
+        ds.source_abi = Some("ERC20".to_string());
+        ds.block_handlers = vec![block_handler("handleBlock")];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_handler_presence(&manifest);
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_handler_presence_no_handlers() {
+        let mut ds = create_data_source("ds1", Some("mainnet"), None);
+        ds.source_abi = Some("ERC20".to_string());
+        // No handlers set
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_handler_presence(&manifest);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::NoHandlers { data_source } if data_source == "ds1"
+        ));
+    }
+
+    #[test]
+    fn test_validate_handler_presence_skips_non_ethereum() {
+        // Subgraph data sources have no source_abi, should be skipped
+        let ds = create_subgraph_data_source("sub1", "QmHash123");
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_handler_presence(&manifest);
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_handler_presence_template_no_handlers() {
+        let t = Template {
+            name: "DynToken".to_string(),
+            kind: "ethereum/contract".to_string(),
+            network: Some("mainnet".to_string()),
+            mapping_file: Some("src/dyn.ts".to_string()),
+            api_version: None,
+            abis: vec![],
+            source_abi: Some("ERC20".to_string()),
+            event_handlers: vec![],
+            call_handlers: vec![],
+            block_handlers: vec![],
+        };
+
+        let manifest = create_test_manifest(vec![], vec![t]);
+        let errors = validate_handler_presence(&manifest);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::NoHandlers { data_source } if data_source == "DynToken"
+        ));
+    }
+
+    // --- Ethereum kind validation tests ---
+
+    #[test]
+    fn test_validate_valid_ethereum_kind() {
+        assert!(validate_ethereum_kind("ds1", "ethereum/contract").is_empty());
+        assert!(validate_ethereum_kind("ds1", "ethereum").is_empty());
+    }
+
+    #[test]
+    fn test_validate_invalid_ethereum_kind() {
+        let errors = validate_ethereum_kind("ds1", "ethereum/invalid");
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::InvalidKind { data_source, kind }
+                if data_source == "ds1" && kind == "ethereum/invalid"
+        ));
+    }
+
+    // --- Source address required tests ---
+
+    #[test]
+    fn test_validate_address_not_required_for_event_handlers_only() {
+        let errors = validate_source_address_required("ds1", false, &[], &[]);
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_address_required_for_call_handlers() {
+        let call_handlers = vec![call_handler("handleCall")];
+        let errors = validate_source_address_required("ds1", false, &call_handlers, &[]);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::SourceAddressRequired { data_source } if data_source == "ds1"
+        ));
+    }
+
+    #[test]
+    fn test_validate_address_required_for_block_handlers() {
+        let block_handlers = vec![block_handler("handleBlock")];
+        let errors = validate_source_address_required("ds1", false, &[], &block_handlers);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::SourceAddressRequired { data_source } if data_source == "ds1"
+        ));
+    }
+
+    #[test]
+    fn test_validate_address_present_with_call_handlers() {
+        let call_handlers = vec![call_handler("handleCall")];
+        let errors = validate_source_address_required("ds1", true, &call_handlers, &[]);
+        assert!(errors.is_empty());
+    }
+
+    // --- Block handler constraint tests ---
+
+    #[test]
+    fn test_validate_block_handlers_single_non_filtered() {
+        let handlers = vec![block_handler("handleBlock")];
+        let errors = validate_block_handler_constraints("ds1", &handlers);
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_block_handlers_single_call_filtered() {
+        let handlers = vec![block_handler_with_filter(
+            "handleBlock",
+            BlockHandlerFilterKind::Call,
+        )];
+        let errors = validate_block_handler_constraints("ds1", &handlers);
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_block_handlers_non_filtered_with_call_filter_allowed() {
+        // Non-filtered + call filter is allowed
+        let handlers = vec![
+            block_handler("handleBlock"),
+            block_handler_with_filter("handleCallBlock", BlockHandlerFilterKind::Call),
+        ];
+        let errors = validate_block_handler_constraints("ds1", &handlers);
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_block_handlers_duplicate_non_filtered() {
+        let handlers = vec![block_handler("handleBlock1"), block_handler("handleBlock2")];
+        let errors = validate_block_handler_constraints("ds1", &handlers);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::BlockHandlerConstraint { data_source, reason }
+                if data_source == "ds1" && reason.contains("duplicated")
+        ));
+    }
+
+    #[test]
+    fn test_validate_block_handlers_duplicate_call_filtered() {
+        let handlers = vec![
+            block_handler_with_filter("h1", BlockHandlerFilterKind::Call),
+            block_handler_with_filter("h2", BlockHandlerFilterKind::Call),
+        ];
+        let errors = validate_block_handler_constraints("ds1", &handlers);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::BlockHandlerConstraint { reason, .. }
+                if reason.contains("duplicated")
+        ));
+    }
+
+    #[test]
+    fn test_validate_block_handlers_non_filtered_with_polling_not_allowed() {
+        let handlers = vec![
+            block_handler("handleBlock"),
+            block_handler_with_filter("handlePolling", BlockHandlerFilterKind::Polling),
+        ];
+        let errors = validate_block_handler_constraints("ds1", &handlers);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::BlockHandlerConstraint { reason, .. }
+                if reason.contains("combination")
+        ));
+    }
+
+    #[test]
+    fn test_validate_block_handlers_non_filtered_with_once_not_allowed() {
+        let handlers = vec![
+            block_handler("handleBlock"),
+            block_handler_with_filter("handleInit", BlockHandlerFilterKind::Once),
+        ];
+        let errors = validate_block_handler_constraints("ds1", &handlers);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::BlockHandlerConstraint { reason, .. }
+                if reason.contains("combination")
+        ));
+    }
+
+    // --- Receipt API version tests ---
+
+    #[test]
+    fn test_validate_receipt_api_version_ok() {
+        let handlers = vec![EventHandler {
+            event: "Transfer(address,address,uint256)".to_string(),
+            handler: "handleTransfer".to_string(),
+            receipt: true,
+            has_call_decls: false,
+        }];
+        let errors = validate_receipt_api_version("ds1", Some(&Version::new(0, 0, 7)), &handlers);
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_receipt_api_version_too_low() {
+        let handlers = vec![EventHandler {
+            event: "Transfer(address,address,uint256)".to_string(),
+            handler: "handleTransfer".to_string(),
+            receipt: true,
+            has_call_decls: false,
+        }];
+        let errors = validate_receipt_api_version("ds1", Some(&Version::new(0, 0, 6)), &handlers);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::ReceiptRequiresApiVersion { data_source }
+                if data_source == "ds1"
+        ));
+    }
+
+    #[test]
+    fn test_validate_receipt_no_receipt_any_version() {
+        let handlers = vec![event_handler("handleTransfer")];
+        let errors = validate_receipt_api_version("ds1", Some(&Version::new(0, 0, 5)), &handlers);
+        assert!(errors.is_empty());
+    }
+
+    // --- Call declarations spec version tests ---
+
+    #[test]
+    fn test_validate_call_decls_spec_version_ok() {
+        let handlers = vec![EventHandler {
+            event: "Transfer(address,address,uint256)".to_string(),
+            handler: "handleTransfer".to_string(),
+            receipt: false,
+            has_call_decls: true,
+        }];
+        let errors = validate_call_decls_spec_version("ds1", &Version::new(1, 2, 0), &handlers);
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_call_decls_spec_version_too_low() {
+        let handlers = vec![EventHandler {
+            event: "Transfer(address,address,uint256)".to_string(),
+            handler: "handleTransfer".to_string(),
+            receipt: false,
+            has_call_decls: true,
+        }];
+        let errors = validate_call_decls_spec_version("ds1", &Version::new(1, 1, 0), &handlers);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::CallDeclsRequireSpecVersion { data_source }
+                if data_source == "ds1"
+        ));
+    }
+
+    #[test]
+    fn test_validate_call_decls_no_decls_any_version() {
+        let handlers = vec![event_handler("handleTransfer")];
+        let errors = validate_call_decls_spec_version("ds1", &Version::new(0, 0, 4), &handlers);
+        assert!(errors.is_empty());
+    }
+
+    // --- Integration test: validate_ethereum_constraints ---
+
+    #[test]
+    fn test_validate_ethereum_constraints_valid() {
+        let mut ds = create_data_source("ds1", Some("mainnet"), Some(Version::new(0, 0, 7)));
+        ds.source_abi = Some("ERC20".to_string());
+        ds.source_address = Some("0x1234".to_string());
+        ds.event_handlers = vec![event_handler("handleTransfer")];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_ethereum_constraints(&manifest);
+        assert!(errors.is_empty(), "Expected no errors, got: {:?}", errors);
+    }
+
+    #[test]
+    fn test_validate_ethereum_constraints_skips_non_ethereum() {
+        let ds = create_subgraph_data_source("sub1", "QmHash123");
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_ethereum_constraints(&manifest);
+        assert!(errors.is_empty());
+    }
+
+    // --- ABI signature validation tests ---
+
+    /// Build a minimal ERC20-like ABI JSON with Transfer event and approve function.
+    fn erc20_abi_json() -> String {
+        r#"[
+            {
+                "type": "event",
+                "name": "Transfer",
+                "anonymous": false,
+                "inputs": [
+                    {"name": "from", "type": "address", "indexed": true},
+                    {"name": "to", "type": "address", "indexed": true},
+                    {"name": "value", "type": "uint256", "indexed": false}
+                ]
+            },
+            {
+                "type": "event",
+                "name": "Approval",
+                "anonymous": false,
+                "inputs": [
+                    {"name": "owner", "type": "address", "indexed": true},
+                    {"name": "spender", "type": "address", "indexed": true},
+                    {"name": "value", "type": "uint256", "indexed": false}
+                ]
+            },
+            {
+                "type": "function",
+                "name": "approve",
+                "inputs": [
+                    {"name": "spender", "type": "address"},
+                    {"name": "amount", "type": "uint256"}
+                ],
+                "outputs": [{"name": "", "type": "bool"}],
+                "stateMutability": "nonpayable"
+            },
+            {
+                "type": "function",
+                "name": "transfer",
+                "inputs": [
+                    {"name": "to", "type": "address"},
+                    {"name": "amount", "type": "uint256"}
+                ],
+                "outputs": [{"name": "", "type": "bool"}],
+                "stateMutability": "nonpayable"
+            }
+        ]"#
+        .to_string()
+    }
+
+    fn parse_abi(json: &str) -> JsonAbi {
+        serde_json::from_str(json).unwrap()
+    }
+
+    #[test]
+    fn test_validate_event_signatures_exact_match_with_indexed() {
+        let contract = parse_abi(&erc20_abi_json());
+        let handlers = vec![EventHandler {
+            event: "Transfer(indexed address,indexed address,uint256)".to_string(),
+            handler: "handleTransfer".to_string(),
+            receipt: false,
+            has_call_decls: false,
+        }];
+        let errors = validate_event_signatures("ds1", "ERC20", &handlers, &contract);
+        assert!(errors.is_empty(), "Expected no errors, got: {:?}", errors);
+    }
+
+    #[test]
+    fn test_validate_event_signatures_fallback_without_indexed() {
+        let contract = parse_abi(&erc20_abi_json());
+        // Signature without indexed hints — should match via fallback
+        let handlers = vec![EventHandler {
+            event: "Transfer(address,address,uint256)".to_string(),
+            handler: "handleTransfer".to_string(),
+            receipt: false,
+            has_call_decls: false,
+        }];
+        let errors = validate_event_signatures("ds1", "ERC20", &handlers, &contract);
+        assert!(errors.is_empty(), "Expected no errors, got: {:?}", errors);
+    }
+
+    #[test]
+    fn test_validate_event_signatures_nonexistent_event() {
+        let contract = parse_abi(&erc20_abi_json());
+        let handlers = vec![EventHandler {
+            event: "Mint(address,uint256)".to_string(),
+            handler: "handleMint".to_string(),
+            receipt: false,
+            has_call_decls: false,
+        }];
+        let errors = validate_event_signatures("ds1", "ERC20", &handlers, &contract);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::EventNotInAbi {
+                data_source,
+                event,
+                abi_name,
+            } if data_source == "ds1" && event == "Mint(address,uint256)" && abi_name == "ERC20"
+        ));
+    }
+
+    #[test]
+    fn test_validate_event_signatures_wrong_param_types() {
+        let contract = parse_abi(&erc20_abi_json());
+        // Transfer exists but with wrong param types
+        let handlers = vec![EventHandler {
+            event: "Transfer(uint256,uint256,uint256)".to_string(),
+            handler: "handleTransfer".to_string(),
+            receipt: false,
+            has_call_decls: false,
+        }];
+        let errors = validate_event_signatures("ds1", "ERC20", &handlers, &contract);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::EventNotInAbi { .. }
+        ));
+    }
+
+    #[test]
+    fn test_validate_function_signatures_valid() {
+        let contract = parse_abi(&erc20_abi_json());
+        let handlers = vec![CallHandler {
+            function: "approve(address,uint256)".to_string(),
+            handler: "handleApprove".to_string(),
+        }];
+        let errors = validate_function_signatures("ds1", "ERC20", &handlers, &contract);
+        assert!(errors.is_empty(), "Expected no errors, got: {:?}", errors);
+    }
+
+    #[test]
+    fn test_validate_function_signatures_nonexistent() {
+        let contract = parse_abi(&erc20_abi_json());
+        let handlers = vec![CallHandler {
+            function: "mint(address,uint256)".to_string(),
+            handler: "handleMint".to_string(),
+        }];
+        let errors = validate_function_signatures("ds1", "ERC20", &handlers, &contract);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::FunctionNotInAbi {
+                data_source,
+                function,
+                abi_name,
+            } if data_source == "ds1" && function == "mint(address,uint256)" && abi_name == "ERC20"
+        ));
+    }
+
+    #[test]
+    fn test_validate_function_signatures_wrong_params() {
+        let contract = parse_abi(&erc20_abi_json());
+        // approve exists but with wrong param types
+        let handlers = vec![CallHandler {
+            function: "approve(uint256,uint256)".to_string(),
+            handler: "handleApprove".to_string(),
+        }];
+        let errors = validate_function_signatures("ds1", "ERC20", &handlers, &contract);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::FunctionNotInAbi { .. }
+        ));
+    }
+
+    #[test]
+    fn test_validate_handler_signatures_integration() {
+        let temp_dir = TempDir::new().unwrap();
+
+        // Create ABI file
+        fs::create_dir_all(temp_dir.path().join("abis")).unwrap();
+        fs::write(temp_dir.path().join("abis/ERC20.json"), erc20_abi_json()).unwrap();
+
+        let mut ds = create_data_source("ds1", Some("mainnet"), Some(Version::new(0, 0, 6)));
+        ds.abis = vec![Abi {
+            name: "ERC20".to_string(),
+            file: "abis/ERC20.json".to_string(),
+        }];
+        ds.source_abi = Some("ERC20".to_string());
+        ds.event_handlers = vec![EventHandler {
+            event: "Transfer(address,address,uint256)".to_string(),
+            handler: "handleTransfer".to_string(),
+            receipt: false,
+            has_call_decls: false,
+        }];
+        ds.call_handlers = vec![CallHandler {
+            function: "approve(address,uint256)".to_string(),
+            handler: "handleApprove".to_string(),
+        }];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_handler_signatures(&manifest, temp_dir.path());
+        assert!(errors.is_empty(), "Expected no errors, got: {:?}", errors);
+    }
+
+    #[test]
+    fn test_validate_handler_signatures_bad_event_good_function() {
+        let temp_dir = TempDir::new().unwrap();
+
+        fs::create_dir_all(temp_dir.path().join("abis")).unwrap();
+        fs::write(temp_dir.path().join("abis/ERC20.json"), erc20_abi_json()).unwrap();
+
+        let mut ds = create_data_source("ds1", Some("mainnet"), Some(Version::new(0, 0, 6)));
+        ds.abis = vec![Abi {
+            name: "ERC20".to_string(),
+            file: "abis/ERC20.json".to_string(),
+        }];
+        ds.source_abi = Some("ERC20".to_string());
+        ds.event_handlers = vec![EventHandler {
+            event: "Mint(address,uint256)".to_string(),
+            handler: "handleMint".to_string(),
+            receipt: false,
+            has_call_decls: false,
+        }];
+        ds.call_handlers = vec![CallHandler {
+            function: "approve(address,uint256)".to_string(),
+            handler: "handleApprove".to_string(),
+        }];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_handler_signatures(&manifest, temp_dir.path());
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::EventNotInAbi { event, .. } if event == "Mint(address,uint256)"
+        ));
+    }
+
+    #[test]
+    fn test_validate_handler_signatures_skips_missing_abi_file() {
+        let temp_dir = TempDir::new().unwrap();
+
+        // Don't create the ABI file — validation should silently skip
+        let mut ds = create_data_source("ds1", Some("mainnet"), None);
+        ds.abis = vec![Abi {
+            name: "ERC20".to_string(),
+            file: "abis/ERC20.json".to_string(),
+        }];
+        ds.source_abi = Some("ERC20".to_string());
+        ds.event_handlers = vec![EventHandler {
+            event: "Nonexistent(uint256)".to_string(),
+            handler: "handleNonexistent".to_string(),
+            receipt: false,
+            has_call_decls: false,
+        }];
+
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        // Should produce no errors (file not found is reported elsewhere)
+        let errors = validate_handler_signatures(&manifest, temp_dir.path());
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_validate_handler_signatures_skips_non_ethereum() {
+        let temp_dir = TempDir::new().unwrap();
+
+        let ds = create_subgraph_data_source("sub1", "QmHash123");
+        let manifest = create_test_manifest(vec![ds], vec![]);
+        let errors = validate_handler_signatures(&manifest, temp_dir.path());
+        assert!(errors.is_empty());
+    }
+
+    #[test]
+    fn test_event_signature() {
+        let abi = parse_abi(&erc20_abi_json());
+        let transfer = abi.events.get("Transfer").unwrap().first().unwrap();
+        assert_eq!(transfer.signature(), "Transfer(address,address,uint256)");
+        assert_eq!(
+            event_signature_with_indexed(transfer),
+            "Transfer(indexed address,indexed address,uint256)"
+        );
+    }
+
+    #[test]
+    fn test_function_signature() {
+        let abi = parse_abi(&erc20_abi_json());
+        let approve = abi.functions.get("approve").unwrap().first().unwrap();
+        assert_eq!(approve.signature(), "approve(address,uint256)");
+    }
+
+    #[test]
+    fn test_event_not_in_abi_display() {
+        let err = ManifestValidationError::EventNotInAbi {
+            data_source: "Token".to_string(),
+            event: "Mint(address,uint256)".to_string(),
+            abi_name: "ERC20".to_string(),
+        };
+        assert_eq!(
+            format!("{}", err),
+            "data source 'Token': event 'Mint(address,uint256)' not found in ABI 'ERC20'"
+        );
+    }
+
+    #[test]
+    fn test_function_not_in_abi_display() {
+        let err = ManifestValidationError::FunctionNotInAbi {
+            data_source: "Token".to_string(),
+            function: "mint(address,uint256)".to_string(),
+            abi_name: "ERC20".to_string(),
+        };
+        assert_eq!(
+            format!("{}", err),
+            "data source 'Token': function 'mint(address,uint256)' not found in ABI 'ERC20'"
+        );
+    }
+
+    // --- WASM handler export validation tests ---
+
+    /// Build a minimal valid WASM module that exports the given function names.
+    ///
+    /// The module defines one function type `() -> ()`, one function per export
+    /// name, and exports each function by name.
+    fn build_wasm_with_exports(export_names: &[&str]) -> Vec<u8> {
+        let mut wasm = Vec::new();
+
+        // Magic number + version
+        wasm.extend_from_slice(b"\0asm");
+        wasm.extend_from_slice(&1u32.to_le_bytes());
+
+        let n = export_names.len();
+
+        // Type section: one type `() -> ()`
+        {
+            let section = vec![
+                1,    // count: 1 type
+                0x60, // func type
+                0,    // 0 params
+                0,    // 0 results
+            ];
+            wasm.push(1); // section id: Type
+            leb128_encode(&mut wasm, section.len() as u32);
+            wasm.extend_from_slice(&section);
+        }
+
+        // Function section: n functions, all type index 0
+        {
+            let mut section = Vec::new();
+            leb128_encode(&mut section, n as u32);
+            section.extend(std::iter::repeat_n(0u8, n)); // type index 0 for each
+            wasm.push(3); // section id: Function
+            leb128_encode(&mut wasm, section.len() as u32);
+            wasm.extend_from_slice(&section);
+        }
+
+        // Export section: export each function
+        {
+            let mut section = Vec::new();
+            leb128_encode(&mut section, n as u32);
+            for (i, name) in export_names.iter().enumerate() {
+                leb128_encode(&mut section, name.len() as u32);
+                section.extend_from_slice(name.as_bytes());
+                section.push(0x00); // export kind: func
+                leb128_encode(&mut section, i as u32); // func index
+            }
+            wasm.push(7); // section id: Export
+            leb128_encode(&mut wasm, section.len() as u32);
+            wasm.extend_from_slice(&section);
+        }
+
+        // Code section: n function bodies, each is just `end`
+        {
+            let mut section = Vec::new();
+            leb128_encode(&mut section, n as u32);
+            for _ in 0..n {
+                // Function body: size=2, 0 locals, end
+                section.push(2); // body size
+                section.push(0); // 0 local declarations
+                section.push(0x0b); // end
+            }
+            wasm.push(10); // section id: Code
+            leb128_encode(&mut wasm, section.len() as u32);
+            wasm.extend_from_slice(&section);
+        }
+
+        wasm
+    }
+
+    /// Encode a u32 as unsigned LEB128.
+    fn leb128_encode(buf: &mut Vec<u8>, mut value: u32) {
+        loop {
+            let mut byte = (value & 0x7f) as u8;
+            value >>= 7;
+            if value != 0 {
+                byte |= 0x80;
+            }
+            buf.push(byte);
+            if value == 0 {
+                break;
+            }
+        }
+    }
+
+    #[test]
+    fn test_wasm_exported_functions_extracts_exports() {
+        let wasm = build_wasm_with_exports(&["handleTransfer", "handleApproval"]);
+        let exports = wasm_exported_functions(&wasm).unwrap();
+        assert!(exports.contains("handleTransfer"));
+        assert!(exports.contains("handleApproval"));
+        assert_eq!(exports.len(), 2);
+    }
+
+    #[test]
+    fn test_wasm_exported_functions_empty_module() {
+        let wasm = build_wasm_with_exports(&[]);
+        let exports = wasm_exported_functions(&wasm).unwrap();
+        assert!(exports.is_empty());
+    }
+
+    #[test]
+    fn test_validate_wasm_handlers_all_present() {
+        let temp_dir = TempDir::new().unwrap();
+        let wasm_path = temp_dir.path().join("test.wasm");
+        let wasm = build_wasm_with_exports(&["handleTransfer", "handleBlock"]);
+        fs::write(&wasm_path, wasm).unwrap();
+
+        let errors = validate_wasm_handlers(&wasm_path, "ds1", &["handleTransfer", "handleBlock"]);
+        assert!(errors.is_empty(), "Expected no errors, got: {:?}", errors);
+    }
+
+    #[test]
+    fn test_validate_wasm_handlers_missing_handlers() {
+        let temp_dir = TempDir::new().unwrap();
+        let wasm_path = temp_dir.path().join("test.wasm");
+        let wasm = build_wasm_with_exports(&["handleTransfer"]);
+        fs::write(&wasm_path, wasm).unwrap();
+
+        let errors = validate_wasm_handlers(
+            &wasm_path,
+            "ds1",
+            &["handleTransfer", "handleFoo", "handleBar"],
+        );
+        assert_eq!(errors.len(), 1);
+        match &errors[0] {
+            ManifestValidationError::MissingWasmHandlers {
+                data_source,
+                missing,
+            } => {
+                assert_eq!(data_source, "ds1");
+                assert_eq!(missing, &["handleFoo", "handleBar"]);
+            }
+            other => panic!("Expected MissingWasmHandlers, got: {:?}", other),
+        }
+    }
+
+    #[test]
+    fn test_validate_wasm_handlers_file_not_found() {
+        let errors = validate_wasm_handlers(
+            Path::new("/nonexistent/path.wasm"),
+            "ds1",
+            &["handleTransfer"],
+        );
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::InvalidWasm { .. }
+        ));
+    }
+
+    #[test]
+    fn test_validate_wasm_handlers_invalid_wasm() {
+        let temp_dir = TempDir::new().unwrap();
+        let wasm_path = temp_dir.path().join("bad.wasm");
+        fs::write(&wasm_path, b"not a wasm file").unwrap();
+
+        let errors = validate_wasm_handlers(&wasm_path, "ds1", &["handleTransfer"]);
+        assert_eq!(errors.len(), 1);
+        assert!(matches!(
+            &errors[0],
+            ManifestValidationError::InvalidWasm { reason, .. } if reason.contains("parse")
+        ));
+    }
+
+    #[test]
+    fn test_validate_wasm_handlers_display_format() {
+        let err = ManifestValidationError::MissingWasmHandlers {
+            data_source: "Token".to_string(),
+            missing: vec!["handleFoo".to_string(), "handleBar".to_string()],
+        };
+        let msg = format!("{}", err);
+        assert_eq!(
+            msg,
+            "data source 'Token': missing WASM handlers: handleFoo, handleBar"
+        );
+    }
+
+    #[test]
+    fn test_collect_handler_names() {
+        let mut ds = create_data_source("ds1", Some("mainnet"), None);
+        ds.event_handlers = vec![event_handler("handleTransfer")];
+        ds.call_handlers = vec![call_handler("handleApprove")];
+        ds.block_handlers = vec![block_handler("handleBlock")];
+
+        let names = collect_handler_names(&ds);
+        assert_eq!(
+            names,
+            vec!["handleTransfer", "handleApprove", "handleBlock"]
+        );
+    }
+
+    #[test]
+    fn test_collect_handler_names_empty() {
+        let ds = create_data_source("ds1", Some("mainnet"), None);
+        let names = collect_handler_names(&ds);
+        assert!(names.is_empty());
+    }
+}
diff --git a/gnd/src/watch.rs b/gnd/src/watch.rs
new file mode 100644
index 00000000000..cf1d3e4ea31
--- /dev/null
+++ b/gnd/src/watch.rs
@@ -0,0 +1,124 @@
+//! File watching utilities for build and codegen commands.
+//!
+//! This module provides a unified watch loop implementation used by both
+//! the build and codegen commands when running with the --watch flag.
+
+use std::collections::HashSet;
+use std::future::Future;
+use std::path::PathBuf;
+use std::sync::mpsc;
+use std::time::Duration;
+
+use anyhow::{Result, anyhow};
+use notify::{RecursiveMode, Watcher, recommended_watcher};
+
+/// Delay between file change detection and callback execution to batch multiple events.
+pub const WATCH_DEBOUNCE: Duration = Duration::from_millis(500);
+
+/// Watch files and run a callback when changes are detected.
+///
+/// This function:
+/// - Sets up a file watcher for all directories containing the specified files
+/// - Debounces file change events (waits 500ms and drains pending events)
+/// - Calls the callback when relevant files change
+/// - Runs forever until interrupted or an error occurs
+///
+/// The callback is called once initially before entering the watch loop.
+///
+/// # Type Parameters
+///
+/// * `F` - The callback closure type
+/// * `Fut` - The future returned by the callback
+///
+/// # Arguments
+///
+/// * `files_to_watch` - List of file paths to watch for changes
+/// * `initial_msg` - Message to print after initial run before entering watch mode
+/// * `on_change` - Async callback to run when files change
+pub async fn watch_and_run<F, Fut>(
+    files_to_watch: Vec<PathBuf>,
+    initial_msg: &str,
+    on_change: F,
+) -> Result<()>
+where
+    F: Fn() -> Fut,
+    Fut: Future<Output = Result<()>>,
+{
+    // Do initial run
+    if let Err(e) = on_change().await {
+        eprintln!("Error during initial run: {}", e);
+    }
+
+    println!("\n{}", initial_msg);
+    println!("Press Ctrl+C to stop.\n");
+
+    // Set up file watcher
+    let (tx, rx) = mpsc::channel();
+
+    let mut watcher = recommended_watcher(move |res| {
+        if let Ok(event) = res {
+            let _ = tx.send(event);
+        }
+    })
+    .map_err(|e| anyhow!("Failed to create file watcher: {}", e))?;
+
+    // Watch directories containing the files
+    let mut watched_dirs = HashSet::new();
+    for file in &files_to_watch {
+        if let Some(dir) = file.parent()
+            && watched_dirs.insert(dir.to_path_buf())
+        {
+            watcher
+                .watch(dir, RecursiveMode::NonRecursive)
+                .map_err(|e| anyhow!("Failed to watch {}: {}", dir.display(), e))?;
+        }
+    }
+
+    // Event loop
+    loop {
+        match rx.recv() {
+            Ok(event) => {
+                // Check if the event is for a file we care about
+                let relevant = event.paths.iter().any(|p| {
+                    files_to_watch.iter().any(|f| {
+                        p.file_name() == f.file_name()
+                            || p.ends_with(f.file_name().unwrap_or_default())
+                    })
+                });
+
+                if relevant {
+                    // Debounce: wait a bit and drain any pending events
+                    std::thread::sleep(WATCH_DEBOUNCE);
+                    while rx.try_recv().is_ok() {}
+
+                    // Get the changed file for logging
+                    let changed = event
+                        .paths
+                        .first()
+                        .map(|p| p.display().to_string())
+                        .unwrap_or_else(|| "unknown".to_string());
+
+                    println!("\nFile change detected: {}\n", changed);
+
+                    if let Err(e) = on_change().await {
+                        eprintln!("Error during rebuild: {}", e);
+                    }
+                }
+            }
+            Err(_) => {
+                return Err(anyhow!("File watcher channel closed"));
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_watch_debounce_duration() {
+        // Verify the debounce duration is 500ms
+        assert_eq!(WATCH_DEBOUNCE, Duration::from_millis(500));
+    }
+}
diff --git a/gnd/src/watcher.rs b/gnd/src/watcher.rs
new file mode 100644
index 00000000000..4f07df8b37e
--- /dev/null
+++ b/gnd/src/watcher.rs
@@ -0,0 +1,364 @@
+use anyhow::{Context, Result, anyhow};
+use globset::{Glob, GlobSet, GlobSetBuilder};
+use graph::prelude::{DeploymentHash, SubgraphName};
+use graph::slog::{self, Logger, error, info};
+use notify::{Event, RecursiveMode, Watcher, recommended_watcher};
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::mpsc;
+use std::time::Duration;
+use tokio::sync::mpsc::Sender;
+
+const WATCH_DELAY: Duration = Duration::from_secs(5);
+const DEFAULT_BUILD_DIR: &str = "build";
+
+/// Parse an alias string into a tuple of (alias_name, manifest, Option<build_dir>)
+pub fn parse_alias(alias: &str) -> anyhow::Result<(String, String, Option<String>)> {
+    let mut split = alias.split(':');
+    let alias_name = split.next();
+    let alias_value = split.next();
+
+    if alias_name.is_none() || alias_value.is_none() || split.next().is_some() {
+        return Err(anyhow::anyhow!(
+            "Invalid alias format: expected 'alias=[BUILD_DIR:]manifest', got '{}'",
+            alias
+        ));
+    }
+
+    let alias_name = alias_name.unwrap().to_owned();
+    let (manifest, build_dir) = parse_manifest_arg(alias_value.unwrap())
+        .with_context(|| format!("While parsing alias '{}'", alias))?;
+
+    Ok((alias_name, manifest, build_dir))
+}
+
+/// Parse a manifest string into a tuple of (manifest, Option<build_dir>)
+pub fn parse_manifest_arg(value: &str) -> anyhow::Result<(String, Option<String>)> {
+    match value.split_once(':') {
+        Some((manifest, build_dir)) if !manifest.is_empty() => {
+            Ok((manifest.to_owned(), Some(build_dir.to_owned())))
+        }
+        Some(_) => Err(anyhow::anyhow!(
+            "Invalid manifest arg: missing manifest in '{}'",
+            value
+        )),
+        None => Ok((value.to_owned(), None)),
+    }
+}
+
+// Parses manifest arguments and returns a vector of paths to the manifest files
+pub fn parse_manifest_args(
+    manifests: Vec<String>,
+    subgraph_sources: Vec<String>,
+    logger: &Logger,
+) -> Result<(Vec<PathBuf>, HashMap<String, PathBuf>)> {
+    let mut manifests_paths = Vec::new();
+    let mut source_subgraph_aliases = HashMap::new();
+
+    for subgraph_source in subgraph_sources {
+        let (alias_name, manifest_path_str, build_dir_opt) = parse_alias(&subgraph_source)?;
+        let manifest_path =
+            process_manifest(build_dir_opt, &manifest_path_str, Some(&alias_name), logger)?;
+
+        manifests_paths.push(manifest_path.clone());
+        source_subgraph_aliases.insert(alias_name, manifest_path);
+    }
+
+    for manifest_str in manifests {
+        let (manifest_path_str, build_dir_opt) = parse_manifest_arg(&manifest_str)
+            .with_context(|| format!("While parsing manifest '{}'", manifest_str))?;
+
+        let built_manifest_path =
+            process_manifest(build_dir_opt, &manifest_path_str, None, logger)?;
+
+        manifests_paths.push(built_manifest_path);
+    }
+
+    Ok((manifests_paths, source_subgraph_aliases))
+}
+
+/// Helper function to process a manifest
+fn process_manifest(
+    build_dir_opt: Option<String>,
+    manifest_path_str: &str,
+    alias_name: Option<&String>,
+    logger: &Logger,
+) -> Result<PathBuf> {
+    let build_dir_str = build_dir_opt.unwrap_or_else(|| DEFAULT_BUILD_DIR.to_owned());
+
+    info!(logger, "Validating manifest: {}", manifest_path_str);
+
+    let manifest_path = Path::new(manifest_path_str);
+    let manifest_path = manifest_path
+        .canonicalize()
+        .with_context(|| format!("Manifest path does not exist: {}", manifest_path_str))?;
+
+    // Get the parent directory of the manifest
+    let parent_dir = manifest_path
+        .parent()
+        .ok_or_else(|| {
+            anyhow!(
+                "Failed to get parent directory for manifest: {}",
+                manifest_path_str
+            )
+        })?
+        .canonicalize()
+        .with_context(|| {
+            format!(
+                "Parent directory does not exist for manifest: {}",
+                manifest_path_str
+            )
+        })?;
+
+    // Create the build directory path by joining the parent directory with the build_dir_str
+    let build_dir = parent_dir.join(build_dir_str);
+    let build_dir = build_dir
+        .canonicalize()
+        .with_context(|| format!("Build directory does not exist: {}", build_dir.display()))?;
+
+    let manifest_file_name = manifest_path.file_name().ok_or_else(|| {
+        anyhow!(
+            "Failed to get file name for manifest: {}",
+            manifest_path_str
+        )
+    })?;
+
+    let built_manifest_path = build_dir.join(manifest_file_name);
+
+    info!(
+        logger,
+        "Watching manifest: {}",
+        built_manifest_path.display()
+    );
+
+    if let Some(name) = alias_name {
+        info!(
+            logger,
+            "Using build directory for {}: {}",
+            name,
+            build_dir.display()
+        );
+    } else {
+        info!(logger, "Using build directory: {}", build_dir.display());
+    }
+
+    Ok(built_manifest_path)
+}
+
+/// Sets up a watcher for the given directory with optional exclusions.
+/// Exclusions can include glob patterns like "pgtemp-*".
+pub async fn watch_subgraphs(
+    logger: &Logger,
+    manifests_paths: Vec<PathBuf>,
+    source_subgraph_aliases: HashMap<String, PathBuf>,
+    exclusions: Vec<String>,
+    sender: Sender<(DeploymentHash, SubgraphName)>,
+) -> Result<()> {
+    let logger = logger.new(slog::o!("component" => "Watcher"));
+
+    watch_subgraph_dirs(
+        &logger,
+        manifests_paths,
+        source_subgraph_aliases,
+        exclusions,
+        sender,
+    )
+    .await?;
+    Ok(())
+}
+
+/// Sets up a watcher for the given directories with optional exclusions.
+/// Exclusions can include glob patterns like "pgtemp-*".
+pub async fn watch_subgraph_dirs(
+    logger: &Logger,
+    manifests_paths: Vec<PathBuf>,
+    source_subgraph_aliases: HashMap<String, PathBuf>,
+    exclusions: Vec<String>,
+    sender: Sender<(DeploymentHash, SubgraphName)>,
+) -> Result<()> {
+    if manifests_paths.is_empty() {
+        info!(logger, "No directories to watch");
+        return Ok(());
+    }
+
+    info!(
+        logger,
+        "Watching for changes in {} directories",
+        manifests_paths.len()
+    );
+
+    if !exclusions.is_empty() {
+        info!(logger, "Excluding patterns: {}", exclusions.join(", "));
+    }
+
+    // Create exclusion matcher
+    let exclusion_set = build_glob_set(&exclusions, logger);
+
+    // Create a channel to receive the events
+    let (tx, rx) = mpsc::channel();
+
+    let mut watcher = match recommended_watcher(tx) {
+        Ok(w) => w,
+        Err(e) => {
+            error!(logger, "Error creating file watcher: {}", e);
+            return Err(anyhow!("Error creating file watcher"));
+        }
+    };
+
+    for manifest_path in manifests_paths.iter() {
+        let dir = manifest_path.parent().unwrap();
+        if let Err(e) = watcher.watch(dir, RecursiveMode::Recursive) {
+            error!(logger, "Error watching directory {}: {}", dir.display(), e);
+            std::process::exit(1);
+        }
+        info!(logger, "Watching directory: {}", dir.display());
+    }
+
+    // Process file change events
+    process_file_events(
+        logger,
+        rx,
+        &exclusion_set,
+        &manifests_paths,
+        &source_subgraph_aliases,
+        sender,
+    )
+    .await
+}
+
+/// Processes file change events and triggers redeployments
+async fn process_file_events(
+    logger: &Logger,
+    rx: mpsc::Receiver<Result<Event, notify::Error>>,
+    exclusion_set: &GlobSet,
+    manifests_paths: &[PathBuf],
+    source_subgraph_aliases: &HashMap<String, PathBuf>,
+    sender: Sender<(DeploymentHash, SubgraphName)>,
+) -> Result<()> {
+    loop {
+        // Wait for an event
+        let event = match rx.recv() {
+            Ok(Ok(e)) => e,
+            Ok(_) => continue,
+            Err(_) => {
+                error!(logger, "Error receiving file change event");
+                return Err(anyhow!("Error receiving file change event"));
+            }
+        };
+
+        if !is_relevant_event(
+            &event,
+            manifests_paths
+                .iter()
+                .map(|p| p.parent().unwrap().to_path_buf())
+                .collect(),
+            exclusion_set,
+        ) {
+            continue;
+        }
+
+        // Once we receive an event, wait for a short period of time to allow for multiple events to be received
+        // This is because running graph build writes multiple files at once
+        // Which triggers multiple events, we only need to react to it once
+        let start = std::time::Instant::now();
+        while start.elapsed() < WATCH_DELAY {
+            match rx.try_recv() {
+                // Discard all events until the time window has passed
+                Ok(_) => continue,
+                Err(_) => break,
+            }
+        }
+
+        // Redeploy all subgraphs
+        deploy_all_subgraphs(logger, manifests_paths, source_subgraph_aliases, &sender).await?;
+    }
+}
+
+/// Checks if an event is relevant for any of the watched directories
+fn is_relevant_event(event: &Event, watched_dirs: Vec<PathBuf>, exclusion_set: &GlobSet) -> bool {
+    for path in event.paths.iter() {
+        for dir in watched_dirs.iter() {
+            if path.starts_with(dir) && should_process_event(event, dir, exclusion_set) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+/// Redeploys all subgraphs in the order it appears in the manifests_paths
+pub async fn deploy_all_subgraphs(
+    logger: &Logger,
+    manifests_paths: &[PathBuf],
+    source_subgraph_aliases: &HashMap<String, PathBuf>,
+    sender: &Sender<(DeploymentHash, SubgraphName)>,
+) -> Result<()> {
+    info!(logger, "File change detected, redeploying all subgraphs");
+    for (count, manifest_path) in manifests_paths.iter().enumerate() {
+        let alias_name = source_subgraph_aliases
+            .iter()
+            .find(|(_, path)| path == &manifest_path)
+            .map(|(name, _)| name);
+
+        let id = alias_name
+            .map(|s| s.to_owned())
+            .unwrap_or_else(|| manifest_path.display().to_string());
+
+        let _ = sender
+            .send((
+                DeploymentHash::new(id).map_err(|_| anyhow!("Failed to create deployment hash"))?,
+                SubgraphName::new(format!("subgraph-{}", count))
+                    .map_err(|_| anyhow!("Failed to create subgraph name"))?,
+            ))
+            .await;
+    }
+    Ok(())
+}
+
+/// Build a GlobSet from the provided patterns
+fn build_glob_set(patterns: &[String], logger: &Logger) -> GlobSet {
+    let mut builder = GlobSetBuilder::new();
+
+    for pattern in patterns {
+        match Glob::new(pattern) {
+            Ok(glob) => {
+                builder.add(glob);
+            }
+            Err(e) => error!(logger, "Invalid glob pattern '{}': {}", pattern, e),
+        }
+    }
+
+    match builder.build() {
+        Ok(set) => set,
+        Err(e) => {
+            error!(logger, "Failed to build glob set: {}", e);
+            GlobSetBuilder::new().build().unwrap()
+        }
+    }
+}
+
+/// Determines if an event should be processed based on exclusion patterns
+fn should_process_event(event: &Event, base_dir: &Path, exclusion_set: &GlobSet) -> bool {
+    // Check each path in the event
+    for path in event.paths.iter() {
+        // Get the relative path from the base directory
+        if let Ok(rel_path) = path.strip_prefix(base_dir) {
+            let path_str = rel_path.to_string_lossy();
+
+            // Check if path matches any exclusion pattern
+            if exclusion_set.is_match(path_str.as_ref()) {
+                return false;
+            }
+
+            // Also check against the file name for basename patterns
+            if let Some(file_name) = rel_path.file_name() {
+                let name_str = file_name.to_string_lossy();
+                if exclusion_set.is_match(name_str.as_ref()) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    true
+}
diff --git a/gnd/tests/cli_commands.rs b/gnd/tests/cli_commands.rs
new file mode 100644
index 00000000000..192d201c3be
--- /dev/null
+++ b/gnd/tests/cli_commands.rs
@@ -0,0 +1,902 @@
+//! Standalone command tests for `gnd` CLI.
+//!
+//! These tests verify commands that don't require a running Graph Node:
+//! - `gnd init` - Scaffold new subgraph
+//! - `gnd add` - Add datasource to existing subgraph
+//! - `gnd build` - Compile subgraph to WASM
+//!
+//! # Prerequisites
+//!
+//! - Build the gnd binary: `cargo build -p gnd`
+//! - IPFS running on localhost:5001 (for some tests)
+//!
+//! # Running
+//!
+//! ```bash
+//! just test-gnd-commands
+//! ```
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use tempfile::TempDir;
+
+/// Get the path to the gnd binary
+fn gnd_binary_path() -> PathBuf {
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    PathBuf::from(manifest_dir)
+        .parent()
+        .unwrap()
+        .join("target")
+        .join("debug")
+        .join("gnd")
+}
+
+/// Get the path to test ABIs
+fn test_abis_path() -> PathBuf {
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    PathBuf::from(manifest_dir)
+        .parent()
+        .unwrap()
+        .join("tests")
+        .join("contracts")
+        .join("abis")
+}
+
+/// Verify the gnd binary exists
+fn verify_gnd_binary() -> PathBuf {
+    let gnd_path = gnd_binary_path();
+    if !gnd_path.exists() {
+        panic!(
+            "gnd binary not found at {}. Run `cargo build -p gnd` first.",
+            gnd_path.display()
+        );
+    }
+    gnd_path
+}
+
+/// Run gnd command and return output
+fn run_gnd(args: &[&str], cwd: &Path) -> std::process::Output {
+    let gnd = verify_gnd_binary();
+    Command::new(&gnd)
+        .args(args)
+        .current_dir(cwd)
+        .output()
+        .expect("Failed to execute gnd")
+}
+
+/// Run gnd command and assert it succeeds
+fn run_gnd_success(args: &[&str], cwd: &Path) -> std::process::Output {
+    let output = run_gnd(args, cwd);
+    if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        panic!(
+            "gnd {:?} failed:\nstdout: {}\nstderr: {}",
+            args, stdout, stderr
+        );
+    }
+    output
+}
+
+// ============================================================================
+// gnd indexer tests
+// ============================================================================
+
+#[test]
+fn test_indexer_missing_binary_error() {
+    let gnd = verify_gnd_binary();
+
+    // Run with an empty PATH so graph-indexer cannot be found.
+    let output = Command::new(&gnd)
+        .args(["indexer", "status", "--network", "mainnet"])
+        .env("PATH", "")
+        .output()
+        .expect("Failed to execute gnd");
+
+    assert!(
+        !output.status.success(),
+        "gnd indexer should fail when graph-indexer is not on $PATH"
+    );
+
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("graph-indexer") && stderr.contains("not found"),
+        "Error should mention graph-indexer not found. Got:\n{stderr}"
+    );
+    assert!(
+        stderr.contains("indexer-cli"),
+        "Error should mention indexer-cli install instructions. Got:\n{stderr}"
+    );
+}
+
+#[test]
+fn test_indexer_clap_help() {
+    let gnd = verify_gnd_binary();
+
+    // `--help` is intercepted by clap, not forwarded to graph-indexer.
+    let output = Command::new(&gnd)
+        .args(["indexer", "--help"])
+        .env("PATH", "")
+        .output()
+        .expect("Failed to execute gnd");
+
+    assert!(output.status.success(), "gnd indexer --help should succeed");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(
+        stdout.contains("indexer-cli"),
+        "Help should mention indexer-cli. Got:\n{stdout}"
+    );
+    assert!(
+        stdout.contains("graph-indexer"),
+        "Help should mention graph-indexer. Got:\n{stdout}"
+    );
+}
+
+// ============================================================================
+// gnd init tests
+// ============================================================================
+
+#[test]
+fn test_init_from_example() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("my-subgraph");
+
+    // Run gnd init --from-example. We pass --skip-install since `pnpm
+    // install` for the example will ask for github credentials (unclear
+    // why)
+    let output = run_gnd(
+        &[
+            "init",
+            "--skip-install",
+            "--from-example",
+            "ethereum-gravatar",
+            "my-subgraph",
+        ],
+        temp_dir.path(),
+    );
+
+    if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        // Example downloads from GitHub, may fail in CI without network
+        // Skip test if it fails due to network issues
+        if stderr.contains("network")
+            || stderr.contains("fetch")
+            || stderr.contains("download")
+            || stderr.contains("Failed to fetch")
+        {
+            eprintln!("Skipping test_init_from_example: network unavailable");
+            return;
+        }
+        panic!(
+            "gnd init --from-example failed:\nstdout: {}\nstderr: {}",
+            stdout, stderr
+        );
+    }
+
+    // Verify scaffold was created
+    assert!(subgraph_dir.exists(), "Subgraph directory should exist");
+    assert!(
+        subgraph_dir.join("subgraph.yaml").exists(),
+        "subgraph.yaml should exist"
+    );
+    assert!(
+        subgraph_dir.join("schema.graphql").exists(),
+        "schema.graphql should exist"
+    );
+    assert!(
+        subgraph_dir.join("package.json").exists(),
+        "package.json should exist"
+    );
+
+    // Verify it's actually the ethereum-gravatar example (contains Gravatar entity)
+    let schema = fs::read_to_string(subgraph_dir.join("schema.graphql")).unwrap();
+    assert!(
+        schema.contains("Gravatar"),
+        "schema.graphql should contain Gravatar entity"
+    );
+}
+
+#[test]
+fn test_init_from_example_invalid_name() {
+    let temp_dir = TempDir::new().unwrap();
+    let output = run_gnd(
+        &[
+            "init",
+            "--skip-install",
+            "--from-example",
+            "nonexistent-example-12345",
+            "test",
+        ],
+        temp_dir.path(),
+    );
+
+    // Command should fail
+    assert!(!output.status.success());
+
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    // Skip test if it fails due to network issues (can't verify example doesn't exist)
+    if stderr.contains("Failed to fetch from graph-tooling") {
+        eprintln!("Skipping test_init_from_example_invalid_name: network unavailable");
+        return;
+    }
+
+    // Should show helpful error message
+    assert!(
+        stderr.contains("not found") || stderr.contains("graph-tooling"),
+        "Error should mention example not found or link to graph-tooling. Got: {}",
+        stderr
+    );
+}
+
+#[test]
+fn test_init_from_example_aggregations() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("my-agg");
+
+    let output = run_gnd(
+        &[
+            "init",
+            "--skip-install",
+            "--from-example",
+            "aggregations",
+            "my-agg",
+        ],
+        temp_dir.path(),
+    );
+
+    if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        // Example downloads from GitHub, may fail in CI without network
+        if stderr.contains("network")
+            || stderr.contains("fetch")
+            || stderr.contains("download")
+            || stderr.contains("Failed to fetch")
+        {
+            eprintln!("Skipping test_init_from_example_aggregations: network unavailable");
+            return;
+        }
+        panic!(
+            "gnd init --from-example aggregations failed:\nstdout: {}\nstderr: {}",
+            stdout, stderr
+        );
+    }
+
+    // Verify scaffold was created
+    assert!(subgraph_dir.exists(), "Subgraph directory should exist");
+
+    // Verify it's actually the aggregations example, not ethereum-gravatar
+    let manifest = fs::read_to_string(subgraph_dir.join("subgraph.yaml")).unwrap();
+
+    // The aggregations example uses specVersion 1.1.0 and has blockHandlers,
+    // whereas ethereum-gravatar uses 0.0.5 and has eventHandlers
+    assert!(
+        manifest.contains("specVersion: 1.1.0") || manifest.contains("blockHandlers"),
+        "Manifest should be the aggregations example (expected specVersion 1.1.0 or blockHandlers)"
+    );
+}
+
+#[test]
+fn test_init_from_contract_with_abi() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("simple-subgraph");
+
+    // Get the path to SimpleContract ABI
+    let abi_path = test_abis_path().join("SimpleContract.json");
+    assert!(abi_path.exists(), "SimpleContract.json ABI should exist");
+
+    // Run gnd init with --from-contract and --abi
+    let output = run_gnd(
+        &[
+            "init",
+            "--from-contract",
+            "0x5fbdb2315678afecb367f032d93f642f64180aa3",
+            "--abi",
+            abi_path.to_str().unwrap(),
+            "--network",
+            "mainnet",
+            "--contract-name",
+            "SimpleContract",
+            "simple-subgraph",
+        ],
+        temp_dir.path(),
+    );
+
+    if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        panic!(
+            "gnd init --from-contract failed:\nstdout: {}\nstderr: {}",
+            stdout, stderr
+        );
+    }
+
+    // Verify scaffold was created
+    assert!(subgraph_dir.exists(), "Subgraph directory should exist");
+    assert!(
+        subgraph_dir.join("subgraph.yaml").exists(),
+        "subgraph.yaml should exist"
+    );
+    assert!(
+        subgraph_dir.join("schema.graphql").exists(),
+        "schema.graphql should exist"
+    );
+
+    // Verify manifest contains the contract
+    let manifest = fs::read_to_string(subgraph_dir.join("subgraph.yaml")).unwrap();
+    assert!(
+        manifest.contains("0x5fbdb2315678afecb367f032d93f642f64180aa3"),
+        "Manifest should contain contract address"
+    );
+    assert!(
+        manifest.contains("SimpleContract"),
+        "Manifest should contain contract name"
+    );
+
+    // Verify networks.json was created with contract config
+    let networks_path = subgraph_dir.join("networks.json");
+    assert!(networks_path.exists(), "networks.json should exist");
+
+    let networks: serde_json::Value =
+        serde_json::from_str(&fs::read_to_string(&networks_path).unwrap()).unwrap();
+    assert!(
+        networks["mainnet"]["SimpleContract"]["address"]
+            .as_str()
+            .unwrap()
+            .contains("0x5fbdb2315678afecb367f032d93f642f64180aa3"),
+        "networks.json should contain contract address"
+    );
+}
+
+#[test]
+fn test_init_creates_mapping_file() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("mapping-test");
+
+    // Get the path to SimpleContract ABI
+    let abi_path = test_abis_path().join("SimpleContract.json");
+
+    // Run gnd init
+    let output = run_gnd(
+        &[
+            "init",
+            "--from-contract",
+            "0x1234567890123456789012345678901234567890",
+            "--abi",
+            abi_path.to_str().unwrap(),
+            "--network",
+            "mainnet",
+            "--contract-name",
+            "TestContract",
+            "--index-events",
+            "mapping-test",
+        ],
+        temp_dir.path(),
+    );
+
+    if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        panic!("gnd init failed:\nstdout: {}\nstderr: {}", stdout, stderr);
+    }
+
+    // Verify mapping file was created
+    let mapping_path = subgraph_dir.join("src").join("test-contract.ts");
+    assert!(
+        mapping_path.exists() || subgraph_dir.join("src").join("mapping.ts").exists(),
+        "Mapping file should exist"
+    );
+}
+
+// ============================================================================
+// gnd add tests
+// ============================================================================
+
+#[test]
+fn test_add_datasource() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("add-test");
+
+    // First create a subgraph with init
+    let abi_path = test_abis_path().join("SimpleContract.json");
+    run_gnd_success(
+        &[
+            "init",
+            "--from-contract",
+            "0x1111111111111111111111111111111111111111",
+            "--abi",
+            abi_path.to_str().unwrap(),
+            "--network",
+            "mainnet",
+            "--contract-name",
+            "FirstContract",
+            "add-test",
+        ],
+        temp_dir.path(),
+    );
+
+    // Verify initial manifest
+    let manifest_before = fs::read_to_string(subgraph_dir.join("subgraph.yaml")).unwrap();
+    assert!(
+        manifest_before.contains("FirstContract"),
+        "Initial manifest should have FirstContract"
+    );
+    assert!(
+        !manifest_before.contains("SecondContract"),
+        "Initial manifest should not have SecondContract"
+    );
+
+    // The added contract's event entity should not exist in the schema yet.
+    let schema_before = fs::read_to_string(subgraph_dir.join("schema.graphql")).unwrap();
+    assert!(
+        !schema_before.contains("type Trigger"),
+        "Initial schema should not have the Trigger entity"
+    );
+
+    // Now add another datasource
+    let second_abi_path = test_abis_path().join("LimitedContract.json");
+    let output = run_gnd(
+        &[
+            "add",
+            "0x2222222222222222222222222222222222222222",
+            "--abi",
+            second_abi_path.to_str().unwrap(),
+            "--contract-name",
+            "SecondContract",
+        ],
+        &subgraph_dir,
+    );
+
+    if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        panic!("gnd add failed:\nstdout: {}\nstderr: {}", stdout, stderr);
+    }
+
+    // Verify manifest was updated
+    let manifest_after = fs::read_to_string(subgraph_dir.join("subgraph.yaml")).unwrap();
+    assert!(
+        manifest_after.contains("FirstContract"),
+        "Updated manifest should still have FirstContract"
+    );
+    assert!(
+        manifest_after.contains("SecondContract"),
+        "Updated manifest should have SecondContract"
+    );
+    assert!(
+        manifest_after.contains("0x2222222222222222222222222222222222222222"),
+        "Updated manifest should have second contract address"
+    );
+
+    // The added Trigger event collides with the first contract's Trigger entity;
+    // without --merge-entities it is renamed with the contract prefix so both
+    // can coexist, and declared in the schema.
+    let schema_after = fs::read_to_string(subgraph_dir.join("schema.graphql")).unwrap();
+    assert!(
+        schema_after.contains("type SecondContractTrigger @entity"),
+        "Updated schema should declare the renamed entity, got:\n{}",
+        schema_after
+    );
+}
+
+#[test]
+fn test_add_merge_entities_reuses_existing() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("merge-test");
+
+    // Init with --index-events so the schema actually declares the event entities.
+    let abi_path = test_abis_path().join("SimpleContract.json");
+    run_gnd_success(
+        &[
+            "init",
+            "--from-contract",
+            "0x1111111111111111111111111111111111111111",
+            "--abi",
+            abi_path.to_str().unwrap(),
+            "--network",
+            "mainnet",
+            "--contract-name",
+            "FirstContract",
+            "--index-events",
+            "merge-test",
+        ],
+        temp_dir.path(),
+    );
+
+    // Add a contract whose Trigger event collides, with --merge-entities.
+    let second_abi_path = test_abis_path().join("LimitedContract.json");
+    run_gnd_success(
+        &[
+            "add",
+            "0x2222222222222222222222222222222222222222",
+            "--abi",
+            second_abi_path.to_str().unwrap(),
+            "--contract-name",
+            "SecondContract",
+            "--merge-entities",
+        ],
+        &subgraph_dir,
+    );
+
+    // Merge reuses the existing Trigger entity: no renamed type is declared...
+    let schema_after = fs::read_to_string(subgraph_dir.join("schema.graphql")).unwrap();
+    assert!(
+        !schema_after.contains("SecondContractTrigger"),
+        "merge should reuse Trigger, not declare a renamed entity, got:\n{}",
+        schema_after
+    );
+
+    // ...but the handler is still generated, writing into the shared entity.
+    let mapping = fs::read_to_string(subgraph_dir.join("src").join("second-contract.ts")).unwrap();
+    assert!(
+        mapping.contains("new Trigger("),
+        "merged handler should write into the existing Trigger entity, got:\n{}",
+        mapping
+    );
+}
+
+#[test]
+fn test_add_overloaded_events_disambiguate() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("over-test");
+
+    // A base subgraph without overloaded events.
+    let abi_path = test_abis_path().join("LimitedContract.json");
+    run_gnd_success(
+        &[
+            "init",
+            "--from-contract",
+            "0x1111111111111111111111111111111111111111",
+            "--abi",
+            abi_path.to_str().unwrap(),
+            "--network",
+            "mainnet",
+            "--contract-name",
+            "Base",
+            "over-test",
+        ],
+        temp_dir.path(),
+    );
+
+    // An ABI with two events of the same name (a Solidity overload).
+    let overloaded_abi = temp_dir.path().join("Overloaded.json");
+    fs::write(
+        &overloaded_abi,
+        r#"[
+          {"type":"event","name":"Ping","inputs":[{"name":"account","type":"address","indexed":true}]},
+          {"type":"event","name":"Ping","inputs":[{"name":"amount","type":"uint256","indexed":false}]}
+        ]"#,
+    )
+    .unwrap();
+
+    run_gnd_success(
+        &[
+            "add",
+            "0x2222222222222222222222222222222222222222",
+            "--abi",
+            overloaded_abi.to_str().unwrap(),
+            "--contract-name",
+            "Over",
+        ],
+        &subgraph_dir,
+    );
+
+    // The two Ping events get distinct entities and handlers.
+    let schema = fs::read_to_string(subgraph_dir.join("schema.graphql")).unwrap();
+    assert!(
+        schema.contains("type Ping @entity") && schema.contains("type Ping1 @entity"),
+        "overloaded events should produce Ping and Ping1 entities, got:\n{}",
+        schema
+    );
+
+    let mapping = fs::read_to_string(subgraph_dir.join("src").join("over.ts")).unwrap();
+    assert!(
+        mapping.contains("handlePing(") && mapping.contains("handlePing1("),
+        "overloaded events should produce handlePing and handlePing1, got:\n{}",
+        mapping
+    );
+}
+
+#[test]
+fn test_init_overloaded_events_disambiguate() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("over-init");
+
+    // An ABI with two events of the same name (a Solidity overload).
+    let overloaded_abi = temp_dir.path().join("Overloaded.json");
+    fs::write(
+        &overloaded_abi,
+        r#"[
+          {"type":"event","name":"Ping","inputs":[{"name":"account","type":"address","indexed":true}]},
+          {"type":"event","name":"Ping","inputs":[{"name":"amount","type":"uint256","indexed":false}]}
+        ]"#,
+    )
+    .unwrap();
+
+    run_gnd_success(
+        &[
+            "init",
+            "--from-contract",
+            "0x1111111111111111111111111111111111111111",
+            "--abi",
+            overloaded_abi.to_str().unwrap(),
+            "--network",
+            "mainnet",
+            "--contract-name",
+            "Over",
+            "--index-events",
+            "over-init",
+        ],
+        temp_dir.path(),
+    );
+
+    // init must disambiguate too, or it emits duplicate types / handlers.
+    let schema = fs::read_to_string(subgraph_dir.join("schema.graphql")).unwrap();
+    assert!(
+        schema.contains("type Ping @entity") && schema.contains("type Ping1 @entity"),
+        "init should disambiguate overloaded events, got:\n{}",
+        schema
+    );
+
+    let mapping = fs::read_to_string(subgraph_dir.join("src").join("over.ts")).unwrap();
+    assert!(
+        mapping.contains("handlePing(") && mapping.contains("handlePing1("),
+        "init mapping should disambiguate overloaded handlers, got:\n{}",
+        mapping
+    );
+}
+
+#[test]
+fn test_add_duplicate_name_errors() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("dup-test");
+
+    let abi_path = test_abis_path().join("SimpleContract.json");
+    run_gnd_success(
+        &[
+            "init",
+            "--from-contract",
+            "0x1111111111111111111111111111111111111111",
+            "--abi",
+            abi_path.to_str().unwrap(),
+            "--network",
+            "mainnet",
+            "--contract-name",
+            "FirstContract",
+            "dup-test",
+        ],
+        temp_dir.path(),
+    );
+
+    // Adding a data source whose name already exists must fail.
+    let second_abi_path = test_abis_path().join("LimitedContract.json");
+    let output = run_gnd(
+        &[
+            "add",
+            "0x2222222222222222222222222222222222222222",
+            "--abi",
+            second_abi_path.to_str().unwrap(),
+            "--contract-name",
+            "FirstContract",
+        ],
+        &subgraph_dir,
+    );
+
+    assert!(
+        !output.status.success(),
+        "gnd add should fail when the data source name already exists"
+    );
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("already exists"),
+        "error should mention the name already exists, got: {}",
+        stderr
+    );
+}
+
+// ============================================================================
+// gnd codegen tests
+// ============================================================================
+
+#[test]
+fn test_codegen_generates_types() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("codegen-test");
+
+    // Create a subgraph
+    let abi_path = test_abis_path().join("SimpleContract.json");
+    run_gnd_success(
+        &[
+            "init",
+            "--from-contract",
+            "0x1234567890123456789012345678901234567890",
+            "--abi",
+            abi_path.to_str().unwrap(),
+            "--network",
+            "mainnet",
+            "--contract-name",
+            "SimpleContract",
+            "--index-events",
+            "codegen-test",
+        ],
+        temp_dir.path(),
+    );
+
+    // Run codegen
+    let output = run_gnd(&["codegen", "--skip-migrations"], &subgraph_dir);
+
+    if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        panic!(
+            "gnd codegen failed:\nstdout: {}\nstderr: {}",
+            stdout, stderr
+        );
+    }
+
+    // Verify generated directory exists
+    let generated_dir = subgraph_dir.join("generated");
+    assert!(generated_dir.exists(), "generated/ directory should exist");
+
+    // Verify schema.ts was generated
+    assert!(
+        generated_dir.join("schema.ts").exists(),
+        "generated/schema.ts should exist"
+    );
+}
+
+// ============================================================================
+// gnd build tests
+// ============================================================================
+
+#[test]
+fn test_build_after_codegen() {
+    // Skip this test if asc is not installed
+    if Command::new("asc").arg("--version").output().is_err() {
+        eprintln!("Skipping test_build_after_codegen: asc not installed");
+        return;
+    }
+
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("build-test");
+
+    // Create a subgraph
+    let abi_path = test_abis_path().join("SimpleContract.json");
+    run_gnd_success(
+        &[
+            "init",
+            "--from-contract",
+            "0x1234567890123456789012345678901234567890",
+            "--abi",
+            abi_path.to_str().unwrap(),
+            "--network",
+            "mainnet",
+            "--contract-name",
+            "SimpleContract",
+            "--index-events",
+            "build-test",
+        ],
+        temp_dir.path(),
+    );
+
+    // Install dependencies (required for codegen and build)
+    let npm_install = Command::new("npm")
+        .arg("install")
+        .current_dir(&subgraph_dir)
+        .output();
+
+    if npm_install.is_err() || !npm_install.unwrap().status.success() {
+        eprintln!("Skipping test_build_after_codegen: npm install failed");
+        return;
+    }
+
+    // Run codegen first to generate types
+    let codegen_output = run_gnd(&["codegen", "--skip-migrations"], &subgraph_dir);
+    if !codegen_output.status.success() {
+        let stdout = String::from_utf8_lossy(&codegen_output.stdout);
+        let stderr = String::from_utf8_lossy(&codegen_output.stderr);
+        if stderr.contains("Cannot find module") || stderr.contains("graph-ts") {
+            eprintln!("Skipping test_build_after_codegen: dependencies not available");
+            return;
+        }
+        panic!(
+            "gnd codegen failed:\nstdout: {}\nstderr: {}",
+            stdout, stderr
+        );
+    }
+
+    // Run build (codegen already done)
+    let output = run_gnd(&["build", "--skip-migrations"], &subgraph_dir);
+
+    if !output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        // Build may fail if dependencies aren't set up correctly
+        // This is expected in some CI environments
+        if stderr.contains("Cannot find module") || stderr.contains("graph-ts") {
+            eprintln!("Skipping test_build_after_codegen: dependencies not available");
+            return;
+        }
+        panic!("gnd build failed:\nstdout: {}\nstderr: {}", stdout, stderr);
+    }
+
+    // Verify build directory exists
+    let build_dir = subgraph_dir.join("build");
+    assert!(build_dir.exists(), "build/ directory should exist");
+
+    // Verify WASM was generated
+    let wasm_files: Vec<_> = fs::read_dir(&build_dir)
+        .unwrap()
+        .filter_map(|e| e.ok())
+        .filter(|e| {
+            e.path()
+                .extension()
+                .map(|ext| ext == "wasm")
+                .unwrap_or(false)
+        })
+        .collect();
+
+    assert!(
+        !wasm_files.is_empty(),
+        "build/ should contain at least one .wasm file"
+    );
+}
+
+// ============================================================================
+// gnd clean tests
+// ============================================================================
+
+#[test]
+fn test_clean_removes_artifacts() {
+    let temp_dir = TempDir::new().unwrap();
+    let subgraph_dir = temp_dir.path().join("clean-test");
+
+    // Create a subgraph
+    let abi_path = test_abis_path().join("SimpleContract.json");
+    run_gnd_success(
+        &[
+            "init",
+            "--from-contract",
+            "0x1234567890123456789012345678901234567890",
+            "--abi",
+            abi_path.to_str().unwrap(),
+            "--network",
+            "mainnet",
+            "--contract-name",
+            "SimpleContract",
+            "clean-test",
+        ],
+        temp_dir.path(),
+    );
+
+    // Run codegen to create generated/
+    run_gnd_success(&["codegen", "--skip-migrations"], &subgraph_dir);
+
+    // Verify generated/ exists
+    assert!(
+        subgraph_dir.join("generated").exists(),
+        "generated/ should exist after codegen"
+    );
+
+    // Create a fake build/ directory
+    fs::create_dir(subgraph_dir.join("build")).unwrap();
+    assert!(subgraph_dir.join("build").exists(), "build/ should exist");
+
+    // Run clean
+    run_gnd_success(&["clean"], &subgraph_dir);
+
+    // Verify directories were removed
+    assert!(
+        !subgraph_dir.join("generated").exists(),
+        "generated/ should be removed after clean"
+    );
+    assert!(
+        !subgraph_dir.join("build").exists(),
+        "build/ should be removed after clean"
+    );
+}
diff --git a/gnd/tests/codegen_verification.rs b/gnd/tests/codegen_verification.rs
new file mode 100644
index 00000000000..e17730a75ce
--- /dev/null
+++ b/gnd/tests/codegen_verification.rs
@@ -0,0 +1,493 @@
+//! Integration tests that verify `gnd codegen` produces compatible output
+//! to `graph-cli codegen` using golden test fixtures.
+//!
+//! Fixtures are stored locally in `tests/fixtures/codegen_verification/`.
+//! To regenerate fixtures after graph-cli changes, run:
+//! ```sh
+//! ./tests/fixtures/regenerate.sh
+//! ```
+//!
+//! # Known Differences
+//!
+//! Some differences between gnd and graph-cli output are intentional:
+//!
+//! 1. **Int8 import**: gnd always imports Int8 for simplicity
+//! 2. **Trailing commas**: gnd uses trailing commas in multi-line constructs
+//! 3. **2D array accessors**: gnd uses correct `toStringMatrix()` while graph-cli
+//!    has a bug using `toStringArray()` for 2D GraphQL array types
+//!
+//! These differences are documented and accepted in the test comparisons.
+
+use regex::Regex;
+use similar::{ChangeTag, TextDiff};
+use std::collections::HashSet;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use tempfile::TempDir;
+use walkdir::WalkDir;
+
+/// Fixtures to test - these are directories under graph-cli's validation test folder
+/// that have a `generated/` directory with expected output.
+const FIXTURES: &[&str] = &[
+    "2d-array-is-valid",
+    "3d-array-is-valid",
+    "big-decimal-is-valid",
+    "block-handler-filters",
+    "call-handler-with-tuple",
+    "derived-from-with-interface",
+    "example-values-found",
+    "invalid-graphql-schema",
+    "no-network-names",
+    "source-without-address-is-valid",
+    "topic0-is-valid",
+];
+
+/// Get the path to the fixtures directory
+fn fixtures_path() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join("codegen_verification")
+}
+
+/// Get the path to the gnd binary
+fn gnd_binary_path() -> PathBuf {
+    // Use the binary built by cargo test
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    PathBuf::from(manifest_dir)
+        .parent()
+        .unwrap()
+        .join("target")
+        .join("debug")
+        .join("gnd")
+}
+
+/// Copy a fixture directory to a temporary directory, excluding the generated/ folder
+fn copy_fixture_to_temp(fixture_path: &Path, temp_dir: &Path) -> std::io::Result<()> {
+    for entry in WalkDir::new(fixture_path).min_depth(1) {
+        let entry = entry?;
+        let relative_path = entry.path().strip_prefix(fixture_path).unwrap();
+
+        // Skip the generated directory
+        if relative_path.starts_with("generated") {
+            continue;
+        }
+
+        let dest_path = temp_dir.join(relative_path);
+
+        if entry.file_type().is_dir() {
+            fs::create_dir_all(&dest_path)?;
+        } else {
+            if let Some(parent) = dest_path.parent() {
+                fs::create_dir_all(parent)?;
+            }
+            fs::copy(entry.path(), &dest_path)?;
+        }
+    }
+    Ok(())
+}
+
+/// Collect all files in a directory recursively
+fn collect_files(dir: &Path) -> std::io::Result<HashSet<PathBuf>> {
+    let mut files = HashSet::new();
+    if !dir.exists() {
+        return Ok(files);
+    }
+    for entry in WalkDir::new(dir) {
+        let entry = entry?;
+        if entry.file_type().is_file() {
+            let relative_path = entry.path().strip_prefix(dir).unwrap();
+            files.insert(relative_path.to_path_buf());
+        }
+    }
+    Ok(files)
+}
+
+/// Normalize content to remove known acceptable differences between gnd and graph-cli.
+///
+/// Known differences:
+/// 1. Int8 import - gnd always includes it
+/// 2. Trailing commas - gnd uses them, graph-cli doesn't
+/// 3. toStringMatrix vs toStringArray - gnd correctly uses Matrix for 2D arrays
+/// 4. Import order - may differ between implementations
+fn normalize_content(content: &str) -> String {
+    let mut normalized = content.to_string();
+
+    // Remove Int8 from imports (gnd always includes it, graph-cli doesn't)
+    // Handles both "Int8," and ",\n  Int8"
+    normalized = normalized.replace(",\n  Int8,", ",");
+    normalized = normalized.replace("  Int8,\n", "");
+
+    // Normalize trailing commas using regex
+    // Match patterns like: `])\n` -> `],)\n`, `)\n  }` -> `),\n  }`
+    // gnd uses trailing commas, graph-cli doesn't - normalize TO having them
+
+    // Trailing comma before closing bracket in arrays: `])\n` -> `],)\n`
+    let re_array_close = Regex::new(r"\]\)(\s*\n)").unwrap();
+    normalized = re_array_close.replace_all(&normalized, "],)$1").to_string();
+
+    // Trailing comma before closing paren in multi-line: `)\n    );` -> `),\n    );`
+    let re_call_close = Regex::new(r"\)(\s*\n\s*\);)").unwrap();
+    normalized = re_call_close.replace_all(&normalized, "),$1").to_string();
+
+    // Trailing comma in function arguments that end with )
+    let re_func_arg = Regex::new(r"\)(\s*\n\s+\])").unwrap();
+    normalized = re_func_arg.replace_all(&normalized, "),$1").to_string();
+
+    // Trailing comma before new statement
+    let re_stmt = Regex::new(r"([^\s,])(\s*\n\s*\);)").unwrap();
+    normalized = re_stmt.replace_all(&normalized, "$1,$2").to_string();
+
+    // Handle specific patterns that regex doesn't catch well
+    // Multi-line changetype call
+    normalized = normalized.replace(")\n    );", "),\n    );");
+
+    // Multi-line GravatarLoader call
+    normalized = normalized.replace("\"gravatars\"\n    );", "\"gravatars\",\n    );");
+
+    // Normalize trailing commas in imports
+    // graph-cli: doesn't use trailing commas
+    // gnd: uses trailing commas
+    normalized = normalized.replace("BigDecimal\n}", "BigDecimal,\n}");
+    normalized = normalized.replace("BigInt\n}", "BigInt,\n}");
+    normalized = normalized.replace("Address\n}", "Address,\n}");
+
+    // Normalize template imports
+    normalized = normalized.replace("DataSourceContext\n}", "DataSourceContext,\n}");
+
+    // Normalize trailing commas in multi-line constructs
+    normalized = normalized.replace("displayKind()}`\n", "displayKind()}`,\n");
+    normalized = normalized.replace(".toTuple()\n", ".toTuple(),\n");
+    normalized = normalized.replace("context\n    );", "context,\n    );");
+
+    // Normalize 2D array accessors - gnd correctly uses Matrix
+    // graph-cli has a bug using toStringArray for 2D arrays
+    normalized = normalized.replace(".toStringArray()", ".toStringMatrix()");
+    normalized = normalized.replace(".toBytesArray()", ".toBytesMatrix()");
+    normalized = normalized.replace(".toBooleanArray()", ".toBooleanMatrix()");
+    normalized = normalized.replace(".toI32Array()", ".toI32Matrix()");
+    normalized = normalized.replace(".toBigIntArray()", ".toBigIntMatrix()");
+    normalized = normalized.replace(".toBigDecimalArray()", ".toBigDecimalMatrix()");
+
+    // Normalize import order by sorting import lines
+    // This handles: import { A, B, C } and import { C, B, A } becoming equivalent
+    normalized = normalize_imports(&normalized);
+
+    normalized
+}
+
+/// Normalize import statements by sorting the imported items.
+/// This makes `import { B, A }` equivalent to `import { A, B }`.
+fn normalize_imports(content: &str) -> String {
+    let re = Regex::new(r"import \{\s*\n?([\s\S]*?)\n?\} from").unwrap();
+    re.replace_all(content, |caps: &regex::Captures| {
+        let items_str = &caps[1];
+        let mut items: Vec<&str> = items_str
+            .split(',')
+            .map(|s| s.trim())
+            .filter(|s| !s.is_empty())
+            .collect();
+        items.sort();
+        format!("import {{\n  {},\n}} from", items.join(",\n  "))
+    })
+    .to_string()
+}
+
+/// Final normalization pass that removes all stylistic differences.
+fn normalize_final(content: &str) -> String {
+    let mut normalized = content.to_string();
+
+    // Remove all trailing commas before closing ) or ]
+    // Pattern: comma followed by whitespace and closing paren/bracket
+    let re_trailing_comma = Regex::new(r",(\s*[\)\]])").unwrap();
+    normalized = re_trailing_comma.replace_all(&normalized, "$1").to_string();
+
+    // Remove trailing commas at end of function parameters
+    // Pattern: comma, optional whitespace, newline, spaces, closing paren
+    let re_param_comma = Regex::new(r",\s*\n(\s*\))").unwrap();
+    normalized = re_param_comma.replace_all(&normalized, "\n$1").to_string();
+
+    // Remove multiple consecutive blank lines (keep single blank lines)
+    let re_blank_lines = Regex::new(r"\n\n\n+").unwrap();
+    normalized = re_blank_lines.replace_all(&normalized, "\n\n").to_string();
+
+    // Ensure consistent blank line before export class (one blank line)
+    let re_class_blank = Regex::new(r"\n+export class").unwrap();
+    normalized = re_class_blank
+        .replace_all(&normalized, "\n\nexport class")
+        .to_string();
+
+    normalized
+}
+
+/// Sort methods within the SmartContract class to normalize method ordering.
+/// Methods within a class may be in different order between gnd and graph-cli.
+fn sort_methods_in_contract(content: &str) -> String {
+    // Find contract class and sort its methods
+    let contract_re =
+        Regex::new(r"(?s)(export class \w+ extends ethereum\.SmartContract \{)(.*?)(\n\})")
+            .unwrap();
+
+    contract_re
+        .replace(content, |caps: &regex::Captures| {
+            let class_header = &caps[1];
+            let body = &caps[2];
+            let class_footer = &caps[3];
+
+            // Extract methods from body
+            let method_re = Regex::new(r"(?s)\n  (\w+\([^)]*\)[^}]*\})").unwrap();
+            let mut methods: Vec<String> = method_re
+                .captures_iter(body)
+                .map(|c| c[0].to_string())
+                .collect();
+
+            // Also capture static methods and try_ methods
+            let static_re = Regex::new(r"(?s)\n  (static \w+\([^)]*\)[^}]*\})").unwrap();
+            let static_methods: Vec<String> = static_re
+                .captures_iter(body)
+                .map(|c| c[0].to_string())
+                .collect();
+
+            // Sort methods alphabetically
+            methods.sort();
+
+            format!(
+                "{}\n{}{}{}",
+                class_header,
+                static_methods.join(""),
+                methods.join(""),
+                class_footer
+            )
+        })
+        .to_string()
+}
+
+/// Sort class declarations to normalize ordering differences.
+/// gnd outputs classes in alphabetical order, graph-cli may use a different order.
+fn sort_classes(content: &str) -> String {
+    // Find positions where "export class" appears at start of line
+    let mut class_starts: Vec<usize> = Vec::new();
+    let mut current_pos = 0usize;
+
+    for line in content.lines() {
+        if line.starts_with("export class ") {
+            class_starts.push(current_pos);
+        }
+        current_pos += line.len() + 1; // +1 for newline
+    }
+
+    if class_starts.is_empty() {
+        return content.to_string();
+    }
+
+    let header = &content[..class_starts[0]];
+
+    // Extract each class
+    let mut classes: Vec<&str> = Vec::new();
+    for i in 0..class_starts.len() {
+        let start = class_starts[i];
+        let end = if i + 1 < class_starts.len() {
+            class_starts[i + 1]
+        } else {
+            content.len()
+        };
+        classes.push(&content[start..end]);
+    }
+
+    // Sort classes alphabetically by their names
+    classes.sort_by(|a, b| {
+        fn get_name(s: &str) -> &str {
+            s.split_whitespace()
+                .nth(2)
+                .unwrap_or("")
+                .trim_end_matches(['{', ' '])
+        }
+        get_name(a).cmp(get_name(b))
+    });
+
+    format!("{}{}", header, classes.join(""))
+}
+
+/// Compare two files and return a diff if they differ
+fn compare_files(expected: &Path, actual: &Path) -> Result<Option<String>, std::io::Error> {
+    let expected_content = fs::read_to_string(expected)?;
+    let actual_content = fs::read_to_string(actual)?;
+
+    // Normalize both contents to remove known acceptable differences
+    let expected_normalized = normalize_final(&sort_methods_in_contract(&sort_classes(
+        &normalize_content(&expected_content),
+    )));
+    let actual_normalized = normalize_final(&sort_methods_in_contract(&sort_classes(
+        &normalize_content(&actual_content),
+    )));
+
+    if expected_normalized == actual_normalized {
+        return Ok(None);
+    }
+
+    let diff = TextDiff::from_lines(&expected_normalized, &actual_normalized);
+    let mut diff_output = String::new();
+
+    for change in diff.iter_all_changes() {
+        let sign = match change.tag() {
+            ChangeTag::Delete => "-",
+            ChangeTag::Insert => "+",
+            ChangeTag::Equal => " ",
+        };
+        diff_output.push_str(&format!("{}{}", sign, change));
+    }
+
+    Ok(Some(diff_output))
+}
+
+/// Run codegen verification for a single fixture
+fn verify_fixture(fixture_name: &str) -> Result<(), String> {
+    let fixtures_dir = fixtures_path();
+    let fixture_path = fixtures_dir.join(fixture_name);
+
+    if !fixture_path.exists() {
+        return Err(format!(
+            "Fixture directory not found: {}",
+            fixture_path.display()
+        ));
+    }
+
+    let expected_dir = fixture_path.join("generated");
+    if !expected_dir.exists() {
+        return Err(format!(
+            "Expected generated/ directory not found in fixture: {}",
+            fixture_name
+        ));
+    }
+
+    // Create temp directory and copy fixture files
+    let temp_dir = TempDir::new().map_err(|e| format!("Failed to create temp dir: {}", e))?;
+
+    copy_fixture_to_temp(&fixture_path, temp_dir.path())
+        .map_err(|e| format!("Failed to copy fixture: {}", e))?;
+
+    // Run gnd codegen
+    let gnd_binary = gnd_binary_path();
+    if !gnd_binary.exists() {
+        return Err(format!(
+            "gnd binary not found at {}. Run `cargo build -p gnd` first.",
+            gnd_binary.display()
+        ));
+    }
+
+    let output = Command::new(&gnd_binary)
+        .arg("codegen")
+        .arg("--skip-migrations")
+        .current_dir(temp_dir.path())
+        .output()
+        .map_err(|e| format!("Failed to run gnd codegen: {}", e))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        return Err(format!(
+            "gnd codegen failed for {}:\nstdout: {}\nstderr: {}",
+            fixture_name, stdout, stderr
+        ));
+    }
+
+    // Compare generated files
+    let actual_dir = temp_dir.path().join("generated");
+
+    let expected_files = collect_files(&expected_dir)
+        .map_err(|e| format!("Failed to collect expected files: {}", e))?;
+    let actual_files =
+        collect_files(&actual_dir).map_err(|e| format!("Failed to collect actual files: {}", e))?;
+
+    let mut errors = Vec::new();
+
+    // Check for missing files (in expected but not in actual)
+    for file in expected_files.difference(&actual_files) {
+        errors.push(format!("Missing file: {}", file.display()));
+    }
+
+    // Check for extra files (in actual but not in expected)
+    for file in actual_files.difference(&expected_files) {
+        errors.push(format!("Extra file: {}", file.display()));
+    }
+
+    // Compare common files
+    for file in expected_files.intersection(&actual_files) {
+        let expected_file = expected_dir.join(file);
+        let actual_file = actual_dir.join(file);
+
+        match compare_files(&expected_file, &actual_file) {
+            Ok(Some(diff)) => {
+                errors.push(format!("File {} differs:\n{}", file.display(), diff));
+            }
+            Ok(None) => {}
+            Err(e) => {
+                errors.push(format!("Failed to compare {}: {}", file.display(), e));
+            }
+        }
+    }
+
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(errors.join("\n\n"))
+    }
+}
+
+// Generate individual test functions for each fixture
+macro_rules! fixture_test {
+    ($name:ident, $fixture:expr) => {
+        #[test]
+        fn $name() {
+            match verify_fixture($fixture) {
+                Ok(()) => {}
+                Err(e) => panic!("Fixture '{}' verification failed:\n{}", $fixture, e),
+            }
+        }
+    };
+}
+
+fixture_test!(test_2d_array_is_valid, "2d-array-is-valid");
+fixture_test!(test_3d_array_is_valid, "3d-array-is-valid");
+fixture_test!(test_big_decimal_is_valid, "big-decimal-is-valid");
+fixture_test!(test_block_handler_filters, "block-handler-filters");
+fixture_test!(test_call_handler_with_tuple, "call-handler-with-tuple");
+fixture_test!(
+    test_derived_from_with_interface,
+    "derived-from-with-interface"
+);
+fixture_test!(test_example_values_found, "example-values-found");
+fixture_test!(test_invalid_graphql_schema, "invalid-graphql-schema");
+fixture_test!(test_no_network_names, "no-network-names");
+fixture_test!(
+    test_source_without_address_is_valid,
+    "source-without-address-is-valid"
+);
+fixture_test!(test_topic0_is_valid, "topic0-is-valid");
+
+/// Run all fixtures and report summary
+#[test]
+fn test_all_fixtures() {
+    let mut passed = Vec::new();
+    let mut failed = Vec::new();
+
+    for fixture in FIXTURES {
+        match verify_fixture(fixture) {
+            Ok(()) => passed.push(*fixture),
+            Err(e) => failed.push((*fixture, e)),
+        }
+    }
+
+    println!("\n=== Codegen Verification Summary ===");
+    println!("Passed: {}/{}", passed.len(), FIXTURES.len());
+
+    if !failed.is_empty() {
+        println!("\nFailed fixtures:");
+        for (fixture, error) in &failed {
+            println!("\n--- {} ---", fixture);
+            println!("{}", error);
+        }
+        panic!("{} fixture(s) failed verification", failed.len());
+    }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/Abi.json b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/Abi.json
new file mode 100644
index 00000000000..4d05f5839f8
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/Abi.json
@@ -0,0 +1,7 @@
+[
+  {
+    "type": "event",
+    "name": "ExampleEvent",
+    "inputs": [{ "type": "string" }]
+  }
+]
diff --git a/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/generated/ExampleSubgraph/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/generated/ExampleSubgraph/ExampleContract.ts
new file mode 100644
index 00000000000..6b59c48fbac
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/generated/ExampleSubgraph/ExampleContract.ts
@@ -0,0 +1,35 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt
+} from "@graphprotocol/graph-ts";
+
+export class ExampleEvent extends ethereum.Event {
+  get params(): ExampleEvent__Params {
+    return new ExampleEvent__Params(this);
+  }
+}
+
+export class ExampleEvent__Params {
+  _event: ExampleEvent;
+
+  constructor(event: ExampleEvent) {
+    this._event = event;
+  }
+
+  get param0(): string {
+    return this._event.parameters[0].value.toString();
+  }
+}
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/generated/schema.ts b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/generated/schema.ts
new file mode 100644
index 00000000000..c785093d200
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/generated/schema.ts
@@ -0,0 +1,65 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  TypedMap,
+  Entity,
+  Value,
+  ValueKind,
+  store,
+  Bytes,
+  BigInt,
+  BigDecimal
+} from "@graphprotocol/graph-ts";
+
+export class MyEntity extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save MyEntity entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type MyEntity must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`
+      );
+      store.set("MyEntity", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get_in_block("MyEntity", id));
+  }
+
+  static load(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get("MyEntity", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+
+  get childTokenURIs(): Array<Array<string>> {
+    let value = this.get("childTokenURIs");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toStringArray();
+    }
+  }
+
+  set childTokenURIs(value: Array<Array<string>>) {
+    this.set("childTokenURIs", Value.fromStringMatrix(value));
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/mapping.ts b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/mapping.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/schema.graphql b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/schema.graphql
new file mode 100644
index 00000000000..91dad2a14e6
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/schema.graphql
@@ -0,0 +1,4 @@
+type MyEntity @entity(immutable: true) {
+  id: ID!
+  childTokenURIs: [[String!]!]! # string[][]
+}
diff --git a/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/subgraph.yaml
new file mode 100644
index 00000000000..fa916d5b6c3
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/2d-array-is-valid/subgraph.yaml
@@ -0,0 +1,23 @@
+specVersion: 0.0.1
+repository: https://github.com/graphprotocol/test-subgraph
+description: Test subgraph
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    source:
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - ExampleEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          handler: handleExampleEvent
diff --git a/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/Abi.json b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/Abi.json
new file mode 100644
index 00000000000..4d05f5839f8
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/Abi.json
@@ -0,0 +1,7 @@
+[
+  {
+    "type": "event",
+    "name": "ExampleEvent",
+    "inputs": [{ "type": "string" }]
+  }
+]
diff --git a/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/generated/ExampleSubgraph/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/generated/ExampleSubgraph/ExampleContract.ts
new file mode 100644
index 00000000000..6b59c48fbac
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/generated/ExampleSubgraph/ExampleContract.ts
@@ -0,0 +1,35 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt
+} from "@graphprotocol/graph-ts";
+
+export class ExampleEvent extends ethereum.Event {
+  get params(): ExampleEvent__Params {
+    return new ExampleEvent__Params(this);
+  }
+}
+
+export class ExampleEvent__Params {
+  _event: ExampleEvent;
+
+  constructor(event: ExampleEvent) {
+    this._event = event;
+  }
+
+  get param0(): string {
+    return this._event.parameters[0].value.toString();
+  }
+}
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/generated/schema.ts b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/generated/schema.ts
new file mode 100644
index 00000000000..bb926318dd2
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/generated/schema.ts
@@ -0,0 +1,65 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  TypedMap,
+  Entity,
+  Value,
+  ValueKind,
+  store,
+  Bytes,
+  BigInt,
+  BigDecimal
+} from "@graphprotocol/graph-ts";
+
+export class MyEntity extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save MyEntity entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type MyEntity must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`
+      );
+      store.set("MyEntity", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get_in_block("MyEntity", id));
+  }
+
+  static load(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get("MyEntity", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+
+  get childTokenURIs(): Array<Array<Array<string>>> {
+    let value = this.get("childTokenURIs");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toStringArray();
+    }
+  }
+
+  set childTokenURIs(value: Array<Array<Array<string>>>) {
+    this.set("childTokenURIs", Value.fromStringMatrix(value));
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/mapping.ts b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/mapping.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/schema.graphql b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/schema.graphql
new file mode 100644
index 00000000000..6b4e8719678
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/schema.graphql
@@ -0,0 +1,4 @@
+type MyEntity @entity(immutable: true) {
+  id: ID!
+  childTokenURIs: [[[String!]!]!]! # string[][][]
+}
diff --git a/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/subgraph.yaml
new file mode 100644
index 00000000000..fa916d5b6c3
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/3d-array-is-valid/subgraph.yaml
@@ -0,0 +1,23 @@
+specVersion: 0.0.1
+repository: https://github.com/graphprotocol/test-subgraph
+description: Test subgraph
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    source:
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - ExampleEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          handler: handleExampleEvent
diff --git a/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/Abi.json b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/Abi.json
new file mode 100644
index 00000000000..4d05f5839f8
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/Abi.json
@@ -0,0 +1,7 @@
+[
+  {
+    "type": "event",
+    "name": "ExampleEvent",
+    "inputs": [{ "type": "string" }]
+  }
+]
diff --git a/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/generated/ExampleSubgraph/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/generated/ExampleSubgraph/ExampleContract.ts
new file mode 100644
index 00000000000..6b59c48fbac
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/generated/ExampleSubgraph/ExampleContract.ts
@@ -0,0 +1,35 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt
+} from "@graphprotocol/graph-ts";
+
+export class ExampleEvent extends ethereum.Event {
+  get params(): ExampleEvent__Params {
+    return new ExampleEvent__Params(this);
+  }
+}
+
+export class ExampleEvent__Params {
+  _event: ExampleEvent;
+
+  constructor(event: ExampleEvent) {
+    this._event = event;
+  }
+
+  get param0(): string {
+    return this._event.parameters[0].value.toString();
+  }
+}
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/generated/schema.ts b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/generated/schema.ts
new file mode 100644
index 00000000000..faf8087b1cf
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/generated/schema.ts
@@ -0,0 +1,65 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  TypedMap,
+  Entity,
+  Value,
+  ValueKind,
+  store,
+  Bytes,
+  BigInt,
+  BigDecimal
+} from "@graphprotocol/graph-ts";
+
+export class MyEntity extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save MyEntity entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type MyEntity must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`
+      );
+      store.set("MyEntity", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get_in_block("MyEntity", id));
+  }
+
+  static load(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get("MyEntity", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+
+  get x(): BigDecimal {
+    let value = this.get("x");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toBigDecimal();
+    }
+  }
+
+  set x(value: BigDecimal) {
+    this.set("x", Value.fromBigDecimal(value));
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/mapping.ts b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/mapping.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/schema.graphql b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/schema.graphql
new file mode 100644
index 00000000000..1edfc3c6c18
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/schema.graphql
@@ -0,0 +1,4 @@
+type MyEntity @entity(immutable: true) {
+  id: ID!
+  x: BigDecimal!
+}
diff --git a/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/subgraph.yaml
new file mode 100644
index 00000000000..fa916d5b6c3
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/big-decimal-is-valid/subgraph.yaml
@@ -0,0 +1,23 @@
+specVersion: 0.0.1
+repository: https://github.com/graphprotocol/test-subgraph
+description: Test subgraph
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    source:
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - ExampleEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          handler: handleExampleEvent
diff --git a/gnd/tests/fixtures/codegen_verification/block-handler-filters/Abi.json b/gnd/tests/fixtures/codegen_verification/block-handler-filters/Abi.json
new file mode 100644
index 00000000000..0637a088a01
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/block-handler-filters/Abi.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/gnd/tests/fixtures/codegen_verification/block-handler-filters/generated/DataSource/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/block-handler-filters/generated/DataSource/ExampleContract.ts
new file mode 100644
index 00000000000..9109534743f
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/block-handler-filters/generated/DataSource/ExampleContract.ts
@@ -0,0 +1,17 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt
+} from "@graphprotocol/graph-ts";
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/block-handler-filters/generated/schema.ts b/gnd/tests/fixtures/codegen_verification/block-handler-filters/generated/schema.ts
new file mode 100644
index 00000000000..570565361ea
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/block-handler-filters/generated/schema.ts
@@ -0,0 +1,52 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  TypedMap,
+  Entity,
+  Value,
+  ValueKind,
+  store,
+  Bytes,
+  BigInt,
+  BigDecimal
+} from "@graphprotocol/graph-ts";
+
+export class A extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save A entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type A must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`
+      );
+      store.set("A", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): A | null {
+    return changetype<A | null>(store.get_in_block("A", id));
+  }
+
+  static load(id: string): A | null {
+    return changetype<A | null>(store.get("A", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/block-handler-filters/mapping.ts b/gnd/tests/fixtures/codegen_verification/block-handler-filters/mapping.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/gnd/tests/fixtures/codegen_verification/block-handler-filters/schema.graphql b/gnd/tests/fixtures/codegen_verification/block-handler-filters/schema.graphql
new file mode 100644
index 00000000000..98b9b177aca
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/block-handler-filters/schema.graphql
@@ -0,0 +1,3 @@
+type A @entity(immutable: true) {
+  id: ID!
+}
diff --git a/gnd/tests/fixtures/codegen_verification/block-handler-filters/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/block-handler-filters/subgraph.yaml
new file mode 100644
index 00000000000..de252559ed9
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/block-handler-filters/subgraph.yaml
@@ -0,0 +1,29 @@
+specVersion: 0.0.1
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: DataSource
+    source:
+      address: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - A
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      blockHandlers:
+        - handler: handleBlock0
+        - handler: handleBlock1
+          filter:
+            kind: polling
+            every: 2
+        - handler: handleBlock2
+          filter:
+            kind: once
+
diff --git a/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/Abi.json b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/Abi.json
new file mode 100644
index 00000000000..3cc71a06ca8
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/Abi.json
@@ -0,0 +1,24 @@
+[
+  {
+    "constant": false,
+    "inputs": [
+      { "name": "", "type": "uint256" },
+      {
+        "type": "tuple",
+        "components": [
+          { "type": "bytes32" },
+          { "type": "bytes32" },
+          { "type": "uint256" }
+        ]
+      },
+      {
+        "type": "bool"
+      }
+    ],
+    "name": "doSomething",
+    "outputs": [],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/generated/ExampleSubgraph/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/generated/ExampleSubgraph/ExampleContract.ts
new file mode 100644
index 00000000000..34692aeba31
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/generated/ExampleSubgraph/ExampleContract.ts
@@ -0,0 +1,71 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt
+} from "@graphprotocol/graph-ts";
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
+
+export class DoSomethingCall extends ethereum.Call {
+  get inputs(): DoSomethingCall__Inputs {
+    return new DoSomethingCall__Inputs(this);
+  }
+
+  get outputs(): DoSomethingCall__Outputs {
+    return new DoSomethingCall__Outputs(this);
+  }
+}
+
+export class DoSomethingCall__Inputs {
+  _call: DoSomethingCall;
+
+  constructor(call: DoSomethingCall) {
+    this._call = call;
+  }
+
+  get value0(): BigInt {
+    return this._call.inputValues[0].value.toBigInt();
+  }
+
+  get value1(): DoSomethingCallValue1Struct {
+    return changetype<DoSomethingCallValue1Struct>(
+      this._call.inputValues[1].value.toTuple()
+    );
+  }
+
+  get value2(): boolean {
+    return this._call.inputValues[2].value.toBoolean();
+  }
+}
+
+export class DoSomethingCall__Outputs {
+  _call: DoSomethingCall;
+
+  constructor(call: DoSomethingCall) {
+    this._call = call;
+  }
+}
+
+export class DoSomethingCallValue1Struct extends ethereum.Tuple {
+  get value0(): Bytes {
+    return this[0].toBytes();
+  }
+
+  get value1(): Bytes {
+    return this[1].toBytes();
+  }
+
+  get value2(): BigInt {
+    return this[2].toBigInt();
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/generated/schema.ts b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/generated/schema.ts
new file mode 100644
index 00000000000..64ee920ecd1
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/generated/schema.ts
@@ -0,0 +1,53 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  TypedMap,
+  Entity,
+  Value,
+  ValueKind,
+  store,
+  Bytes,
+  BigInt,
+  BigDecimal,
+  Int8,
+} from "@graphprotocol/graph-ts";
+
+export class MyEntity extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save MyEntity entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type MyEntity must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`,
+      );
+      store.set("MyEntity", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get_in_block("MyEntity", id));
+  }
+
+  static load(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get("MyEntity", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/mapping.ts b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/mapping.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/schema.graphql b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/schema.graphql
new file mode 100644
index 00000000000..d5a41952be6
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/schema.graphql
@@ -0,0 +1,3 @@
+type MyEntity @entity(immutable: true) {
+  id: ID!
+}
diff --git a/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/subgraph.yaml
new file mode 100644
index 00000000000..93c21a2969a
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/call-handler-with-tuple/subgraph.yaml
@@ -0,0 +1,22 @@
+specVersion: 0.0.2
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    source:
+      address: '22843e74c59580b3eaf6c233fa67d8b7c561a835'
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - ExampleEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      callHandlers:
+        - function: doSomething(uint256,(bytes32,bytes32,uint256),bool)
+          handler: handleDoSomething
diff --git a/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/Gravity.json b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/Gravity.json
new file mode 100644
index 00000000000..d9412537c13
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/Gravity.json
@@ -0,0 +1 @@
+[{"constant":false,"inputs":[{"name":"_imageUrl","type":"string"}],"name":"updateGravatarImage","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"setMythicalGravatar","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"owner","type":"address"}],"name":"getGravatar","outputs":[{"name":"","type":"string"},{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"gravatarToOwner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"ownerToGravatar","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_displayName","type":"string"}],"name":"updateGravatarName","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_displayName","type":"string"},{"name":"_imageUrl","type":"string"}],"name":"createGravatar","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"gravatars","outputs":[{"name":"owner","type":"address"},{"name":"displayName","type":"string"},{"name":"imageUrl","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"id","type":"uint256"},{"indexed":false,"name":"owner","type":"address"},{"indexed":false,"name":"displayName","type":"string"},{"indexed":false,"name":"imageUrl","type":"string"}],"name":"NewGravatar","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"id","type":"uint256"},{"indexed":false,"name":"owner","type":"address"},{"indexed":false,"name":"displayName","type":"string"},{"indexed":false,"name":"imageUrl","type":"string"}],"name":"UpdatedGravatar","type":"event"}]
diff --git a/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/generated/Gravity/Gravity.ts b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/generated/Gravity/Gravity.ts
new file mode 100644
index 00000000000..55ae85a6b33
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/generated/Gravity/Gravity.ts
@@ -0,0 +1,363 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt
+} from "@graphprotocol/graph-ts";
+
+export class NewGravatar extends ethereum.Event {
+  get params(): NewGravatar__Params {
+    return new NewGravatar__Params(this);
+  }
+}
+
+export class NewGravatar__Params {
+  _event: NewGravatar;
+
+  constructor(event: NewGravatar) {
+    this._event = event;
+  }
+
+  get id(): BigInt {
+    return this._event.parameters[0].value.toBigInt();
+  }
+
+  get owner(): Address {
+    return this._event.parameters[1].value.toAddress();
+  }
+
+  get displayName(): string {
+    return this._event.parameters[2].value.toString();
+  }
+
+  get imageUrl(): string {
+    return this._event.parameters[3].value.toString();
+  }
+}
+
+export class UpdatedGravatar extends ethereum.Event {
+  get params(): UpdatedGravatar__Params {
+    return new UpdatedGravatar__Params(this);
+  }
+}
+
+export class UpdatedGravatar__Params {
+  _event: UpdatedGravatar;
+
+  constructor(event: UpdatedGravatar) {
+    this._event = event;
+  }
+
+  get id(): BigInt {
+    return this._event.parameters[0].value.toBigInt();
+  }
+
+  get owner(): Address {
+    return this._event.parameters[1].value.toAddress();
+  }
+
+  get displayName(): string {
+    return this._event.parameters[2].value.toString();
+  }
+
+  get imageUrl(): string {
+    return this._event.parameters[3].value.toString();
+  }
+}
+
+export class Gravity__getGravatarResult {
+  value0: string;
+  value1: string;
+
+  constructor(value0: string, value1: string) {
+    this.value0 = value0;
+    this.value1 = value1;
+  }
+
+  toMap(): TypedMap<string, ethereum.Value> {
+    let map = new TypedMap<string, ethereum.Value>();
+    map.set("value0", ethereum.Value.fromString(this.value0));
+    map.set("value1", ethereum.Value.fromString(this.value1));
+    return map;
+  }
+
+  getValue0(): string {
+    return this.value0;
+  }
+
+  getValue1(): string {
+    return this.value1;
+  }
+}
+
+export class Gravity__gravatarsResult {
+  value0: Address;
+  value1: string;
+  value2: string;
+
+  constructor(value0: Address, value1: string, value2: string) {
+    this.value0 = value0;
+    this.value1 = value1;
+    this.value2 = value2;
+  }
+
+  toMap(): TypedMap<string, ethereum.Value> {
+    let map = new TypedMap<string, ethereum.Value>();
+    map.set("value0", ethereum.Value.fromAddress(this.value0));
+    map.set("value1", ethereum.Value.fromString(this.value1));
+    map.set("value2", ethereum.Value.fromString(this.value2));
+    return map;
+  }
+
+  getOwner(): Address {
+    return this.value0;
+  }
+
+  getDisplayName(): string {
+    return this.value1;
+  }
+
+  getImageUrl(): string {
+    return this.value2;
+  }
+}
+
+export class Gravity extends ethereum.SmartContract {
+  static bind(address: Address): Gravity {
+    return new Gravity("Gravity", address);
+  }
+
+  getGravatar(owner: Address): Gravity__getGravatarResult {
+    let result = super.call(
+      "getGravatar",
+      "getGravatar(address):(string,string)",
+      [ethereum.Value.fromAddress(owner)]
+    );
+
+    return new Gravity__getGravatarResult(
+      result[0].toString(),
+      result[1].toString()
+    );
+  }
+
+  try_getGravatar(
+    owner: Address
+  ): ethereum.CallResult<Gravity__getGravatarResult> {
+    let result = super.tryCall(
+      "getGravatar",
+      "getGravatar(address):(string,string)",
+      [ethereum.Value.fromAddress(owner)]
+    );
+    if (result.reverted) {
+      return new ethereum.CallResult();
+    }
+    let value = result.value;
+    return ethereum.CallResult.fromValue(
+      new Gravity__getGravatarResult(value[0].toString(), value[1].toString())
+    );
+  }
+
+  gravatarToOwner(param0: BigInt): Address {
+    let result = super.call(
+      "gravatarToOwner",
+      "gravatarToOwner(uint256):(address)",
+      [ethereum.Value.fromUnsignedBigInt(param0)]
+    );
+
+    return result[0].toAddress();
+  }
+
+  try_gravatarToOwner(param0: BigInt): ethereum.CallResult<Address> {
+    let result = super.tryCall(
+      "gravatarToOwner",
+      "gravatarToOwner(uint256):(address)",
+      [ethereum.Value.fromUnsignedBigInt(param0)]
+    );
+    if (result.reverted) {
+      return new ethereum.CallResult();
+    }
+    let value = result.value;
+    return ethereum.CallResult.fromValue(value[0].toAddress());
+  }
+
+  ownerToGravatar(param0: Address): BigInt {
+    let result = super.call(
+      "ownerToGravatar",
+      "ownerToGravatar(address):(uint256)",
+      [ethereum.Value.fromAddress(param0)]
+    );
+
+    return result[0].toBigInt();
+  }
+
+  try_ownerToGravatar(param0: Address): ethereum.CallResult<BigInt> {
+    let result = super.tryCall(
+      "ownerToGravatar",
+      "ownerToGravatar(address):(uint256)",
+      [ethereum.Value.fromAddress(param0)]
+    );
+    if (result.reverted) {
+      return new ethereum.CallResult();
+    }
+    let value = result.value;
+    return ethereum.CallResult.fromValue(value[0].toBigInt());
+  }
+
+  gravatars(param0: BigInt): Gravity__gravatarsResult {
+    let result = super.call(
+      "gravatars",
+      "gravatars(uint256):(address,string,string)",
+      [ethereum.Value.fromUnsignedBigInt(param0)]
+    );
+
+    return new Gravity__gravatarsResult(
+      result[0].toAddress(),
+      result[1].toString(),
+      result[2].toString()
+    );
+  }
+
+  try_gravatars(param0: BigInt): ethereum.CallResult<Gravity__gravatarsResult> {
+    let result = super.tryCall(
+      "gravatars",
+      "gravatars(uint256):(address,string,string)",
+      [ethereum.Value.fromUnsignedBigInt(param0)]
+    );
+    if (result.reverted) {
+      return new ethereum.CallResult();
+    }
+    let value = result.value;
+    return ethereum.CallResult.fromValue(
+      new Gravity__gravatarsResult(
+        value[0].toAddress(),
+        value[1].toString(),
+        value[2].toString()
+      )
+    );
+  }
+}
+
+export class UpdateGravatarImageCall extends ethereum.Call {
+  get inputs(): UpdateGravatarImageCall__Inputs {
+    return new UpdateGravatarImageCall__Inputs(this);
+  }
+
+  get outputs(): UpdateGravatarImageCall__Outputs {
+    return new UpdateGravatarImageCall__Outputs(this);
+  }
+}
+
+export class UpdateGravatarImageCall__Inputs {
+  _call: UpdateGravatarImageCall;
+
+  constructor(call: UpdateGravatarImageCall) {
+    this._call = call;
+  }
+
+  get _imageUrl(): string {
+    return this._call.inputValues[0].value.toString();
+  }
+}
+
+export class UpdateGravatarImageCall__Outputs {
+  _call: UpdateGravatarImageCall;
+
+  constructor(call: UpdateGravatarImageCall) {
+    this._call = call;
+  }
+}
+
+export class SetMythicalGravatarCall extends ethereum.Call {
+  get inputs(): SetMythicalGravatarCall__Inputs {
+    return new SetMythicalGravatarCall__Inputs(this);
+  }
+
+  get outputs(): SetMythicalGravatarCall__Outputs {
+    return new SetMythicalGravatarCall__Outputs(this);
+  }
+}
+
+export class SetMythicalGravatarCall__Inputs {
+  _call: SetMythicalGravatarCall;
+
+  constructor(call: SetMythicalGravatarCall) {
+    this._call = call;
+  }
+}
+
+export class SetMythicalGravatarCall__Outputs {
+  _call: SetMythicalGravatarCall;
+
+  constructor(call: SetMythicalGravatarCall) {
+    this._call = call;
+  }
+}
+
+export class UpdateGravatarNameCall extends ethereum.Call {
+  get inputs(): UpdateGravatarNameCall__Inputs {
+    return new UpdateGravatarNameCall__Inputs(this);
+  }
+
+  get outputs(): UpdateGravatarNameCall__Outputs {
+    return new UpdateGravatarNameCall__Outputs(this);
+  }
+}
+
+export class UpdateGravatarNameCall__Inputs {
+  _call: UpdateGravatarNameCall;
+
+  constructor(call: UpdateGravatarNameCall) {
+    this._call = call;
+  }
+
+  get _displayName(): string {
+    return this._call.inputValues[0].value.toString();
+  }
+}
+
+export class UpdateGravatarNameCall__Outputs {
+  _call: UpdateGravatarNameCall;
+
+  constructor(call: UpdateGravatarNameCall) {
+    this._call = call;
+  }
+}
+
+export class CreateGravatarCall extends ethereum.Call {
+  get inputs(): CreateGravatarCall__Inputs {
+    return new CreateGravatarCall__Inputs(this);
+  }
+
+  get outputs(): CreateGravatarCall__Outputs {
+    return new CreateGravatarCall__Outputs(this);
+  }
+}
+
+export class CreateGravatarCall__Inputs {
+  _call: CreateGravatarCall;
+
+  constructor(call: CreateGravatarCall) {
+    this._call = call;
+  }
+
+  get _displayName(): string {
+    return this._call.inputValues[0].value.toString();
+  }
+
+  get _imageUrl(): string {
+    return this._call.inputValues[1].value.toString();
+  }
+}
+
+export class CreateGravatarCall__Outputs {
+  _call: CreateGravatarCall;
+
+  constructor(call: CreateGravatarCall) {
+    this._call = call;
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/generated/schema.ts b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/generated/schema.ts
new file mode 100644
index 00000000000..2029cb57397
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/generated/schema.ts
@@ -0,0 +1,159 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  TypedMap,
+  Entity,
+  Value,
+  ValueKind,
+  store,
+  Bytes,
+  BigInt,
+  BigDecimal
+} from "@graphprotocol/graph-ts";
+
+export class Gravatar extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save Gravatar entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type Gravatar must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`
+      );
+      store.set("Gravatar", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): Gravatar | null {
+    return changetype<Gravatar | null>(store.get_in_block("Gravatar", id));
+  }
+
+  static load(id: string): Gravatar | null {
+    return changetype<Gravatar | null>(store.get("Gravatar", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+
+  get owner(): string {
+    let value = this.get("owner");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set owner(value: string) {
+    this.set("owner", Value.fromString(value));
+  }
+
+  get imageUrl(): string {
+    let value = this.get("imageUrl");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set imageUrl(value: string) {
+    this.set("imageUrl", Value.fromString(value));
+  }
+}
+
+export class UserAccount extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save UserAccount entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type UserAccount must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`
+      );
+      store.set("UserAccount", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): UserAccount | null {
+    return changetype<UserAccount | null>(
+      store.get_in_block("UserAccount", id)
+    );
+  }
+
+  static load(id: string): UserAccount | null {
+    return changetype<UserAccount | null>(store.get("UserAccount", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+
+  get name(): string {
+    let value = this.get("name");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set name(value: string) {
+    this.set("name", Value.fromString(value));
+  }
+
+  get gravatars(): GravatarLoader {
+    return new GravatarLoader(
+      "UserAccount",
+      this.get("id")!.toString(),
+      "gravatars"
+    );
+  }
+}
+
+export class GravatarLoader extends Entity {
+  _entity: string;
+  _field: string;
+  _id: string;
+
+  constructor(entity: string, id: string, field: string) {
+    super();
+    this._entity = entity;
+    this._id = id;
+    this._field = field;
+  }
+
+  load(): Gravatar[] {
+    let value = store.loadRelated(this._entity, this._id, this._field);
+    return changetype<Gravatar[]>(value);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/mapping.ts b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/mapping.ts
new file mode 100644
index 00000000000..0a1bad999e7
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/mapping.ts
@@ -0,0 +1,22 @@
+import { NewGravatar, UpdatedGravatar } from '../generated/Gravity/Gravity'
+import { Gravatar } from '../generated/schema'
+
+export function handleNewGravatar(event: NewGravatar): void {
+  let gravatar = new Gravatar(event.params.id.toHex())
+  gravatar.owner = event.params.owner
+  gravatar.displayName = event.params.displayName
+  gravatar.imageUrl = event.params.imageUrl
+  gravatar.save()
+}
+
+export function handleUpdatedGravatar(event: UpdatedGravatar): void {
+  let id = event.params.id.toHex()
+  let gravatar = Gravatar.load(id)
+  if (gravatar == null) {
+    gravatar = new Gravatar(id)
+  }
+  gravatar.owner = event.params.owner
+  gravatar.displayName = event.params.displayName
+  gravatar.imageUrl = event.params.imageUrl
+  gravatar.save()
+}
diff --git a/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/schema.graphql b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/schema.graphql
new file mode 100644
index 00000000000..cfe420f39d1
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/schema.graphql
@@ -0,0 +1,19 @@
+type Gravatar @entity(immutable: false) {
+  id: ID!
+  # This field points at an interface; we allow that a derived field
+  # in a type that implements the interface derives from this field
+  # The test checks that this construct is accepted
+  owner: Account!
+  imageUrl: String!
+}
+
+interface Account {
+  id: ID!
+  gravatars: [Gravatar!]! @derivedFrom(field: "owner")
+}
+
+type UserAccount implements Account @entity(immutable: true) {
+  id: ID!
+  name: String!
+  gravatars: [Gravatar!]! @derivedFrom(field: "owner")
+}
diff --git a/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/subgraph.yaml
new file mode 100644
index 00000000000..04e378d590f
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/derived-from-with-interface/subgraph.yaml
@@ -0,0 +1,25 @@
+specVersion: 0.0.2
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Gravity
+    network: mainnet
+    source:
+      address: '0x2E645469f354BB4F5c8a05B3b30A929361cf77eC'
+      abi: Gravity
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      entities:
+        - Gravatar
+      abis:
+        - name: Gravity
+          file: ./Gravity.json
+      eventHandlers:
+        - event: NewGravatar(uint256,address,string,string)
+          handler: handleNewGravatar
+        - event: UpdatedGravatar(uint256,address,string,string)
+          handler: handleUpdatedGravatar
+      file: ./mapping.ts
diff --git a/gnd/tests/fixtures/codegen_verification/example-values-found/Abi.json b/gnd/tests/fixtures/codegen_verification/example-values-found/Abi.json
new file mode 100644
index 00000000000..4d05f5839f8
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/example-values-found/Abi.json
@@ -0,0 +1,7 @@
+[
+  {
+    "type": "event",
+    "name": "ExampleEvent",
+    "inputs": [{ "type": "string" }]
+  }
+]
diff --git a/gnd/tests/fixtures/codegen_verification/example-values-found/generated/ExampleSubgraph/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/example-values-found/generated/ExampleSubgraph/ExampleContract.ts
new file mode 100644
index 00000000000..6c9108fe3db
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/example-values-found/generated/ExampleSubgraph/ExampleContract.ts
@@ -0,0 +1,35 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt,
+} from "@graphprotocol/graph-ts";
+
+export class ExampleEvent extends ethereum.Event {
+  get params(): ExampleEvent__Params {
+    return new ExampleEvent__Params(this);
+  }
+}
+
+export class ExampleEvent__Params {
+  _event: ExampleEvent;
+
+  constructor(event: ExampleEvent) {
+    this._event = event;
+  }
+
+  get param0(): string {
+    return this._event.parameters[0].value.toString();
+  }
+}
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/example-values-found/generated/schema.ts b/gnd/tests/fixtures/codegen_verification/example-values-found/generated/schema.ts
new file mode 100644
index 00000000000..64ee920ecd1
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/example-values-found/generated/schema.ts
@@ -0,0 +1,53 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  TypedMap,
+  Entity,
+  Value,
+  ValueKind,
+  store,
+  Bytes,
+  BigInt,
+  BigDecimal,
+  Int8,
+} from "@graphprotocol/graph-ts";
+
+export class MyEntity extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save MyEntity entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type MyEntity must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`,
+      );
+      store.set("MyEntity", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get_in_block("MyEntity", id));
+  }
+
+  static load(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get("MyEntity", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/example-values-found/mapping.ts b/gnd/tests/fixtures/codegen_verification/example-values-found/mapping.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/gnd/tests/fixtures/codegen_verification/example-values-found/schema.graphql b/gnd/tests/fixtures/codegen_verification/example-values-found/schema.graphql
new file mode 100644
index 00000000000..d5a41952be6
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/example-values-found/schema.graphql
@@ -0,0 +1,3 @@
+type MyEntity @entity(immutable: true) {
+  id: ID!
+}
diff --git a/gnd/tests/fixtures/codegen_verification/example-values-found/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/example-values-found/subgraph.yaml
new file mode 100644
index 00000000000..8eeefd554e9
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/example-values-found/subgraph.yaml
@@ -0,0 +1,24 @@
+specVersion: 0.0.1
+repository: https://github.com/graphprotocol/graph-tooling
+description: Gravatar for Ethereum
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    source:
+      address: '22843e74c59580b3eaf6c233fa67d8b7c561a835'
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - ExampleEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          handler: handleExampleEvent
diff --git a/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/Abi.json b/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/Abi.json
new file mode 100644
index 00000000000..4d05f5839f8
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/Abi.json
@@ -0,0 +1,7 @@
+[
+  {
+    "type": "event",
+    "name": "ExampleEvent",
+    "inputs": [{ "type": "string" }]
+  }
+]
diff --git a/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/generated/ExampleSubgraph/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/generated/ExampleSubgraph/ExampleContract.ts
new file mode 100644
index 00000000000..6b59c48fbac
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/generated/ExampleSubgraph/ExampleContract.ts
@@ -0,0 +1,35 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt
+} from "@graphprotocol/graph-ts";
+
+export class ExampleEvent extends ethereum.Event {
+  get params(): ExampleEvent__Params {
+    return new ExampleEvent__Params(this);
+  }
+}
+
+export class ExampleEvent__Params {
+  _event: ExampleEvent;
+
+  constructor(event: ExampleEvent) {
+    this._event = event;
+  }
+
+  get param0(): string {
+    return this._event.parameters[0].value.toString();
+  }
+}
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/mapping.ts b/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/mapping.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/schema.graphql b/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/schema.graphql
new file mode 100644
index 00000000000..350d9b0936a
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/schema.graphql
@@ -0,0 +1,8 @@
+type Something @entity(immutable: true) {
+  id: ID!
+}
+
+type MyEntity @entity(immutable: true) {
+  id: ID!
+  invalidField: [Something]!
+}
diff --git a/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/subgraph.yaml
new file mode 100644
index 00000000000..b8f7166ae2a
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/invalid-graphql-schema/subgraph.yaml
@@ -0,0 +1,22 @@
+specVersion: 0.0.1
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    source:
+      address: '22843e74c59580b3eaf6c233fa67d8b7c561a835'
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - ExampleEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          handler: handleExampleEvent
diff --git a/gnd/tests/fixtures/codegen_verification/no-network-names/Abi.json b/gnd/tests/fixtures/codegen_verification/no-network-names/Abi.json
new file mode 100644
index 00000000000..4d05f5839f8
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/no-network-names/Abi.json
@@ -0,0 +1,7 @@
+[
+  {
+    "type": "event",
+    "name": "ExampleEvent",
+    "inputs": [{ "type": "string" }]
+  }
+]
diff --git a/gnd/tests/fixtures/codegen_verification/no-network-names/generated/ExampleSubgraph/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/no-network-names/generated/ExampleSubgraph/ExampleContract.ts
new file mode 100644
index 00000000000..6b59c48fbac
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/no-network-names/generated/ExampleSubgraph/ExampleContract.ts
@@ -0,0 +1,35 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt
+} from "@graphprotocol/graph-ts";
+
+export class ExampleEvent extends ethereum.Event {
+  get params(): ExampleEvent__Params {
+    return new ExampleEvent__Params(this);
+  }
+}
+
+export class ExampleEvent__Params {
+  _event: ExampleEvent;
+
+  constructor(event: ExampleEvent) {
+    this._event = event;
+  }
+
+  get param0(): string {
+    return this._event.parameters[0].value.toString();
+  }
+}
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/no-network-names/generated/schema.ts b/gnd/tests/fixtures/codegen_verification/no-network-names/generated/schema.ts
new file mode 100644
index 00000000000..4dea4256e51
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/no-network-names/generated/schema.ts
@@ -0,0 +1,52 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  TypedMap,
+  Entity,
+  Value,
+  ValueKind,
+  store,
+  Bytes,
+  BigInt,
+  BigDecimal
+} from "@graphprotocol/graph-ts";
+
+export class MyEntity extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save MyEntity entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type MyEntity must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`
+      );
+      store.set("MyEntity", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get_in_block("MyEntity", id));
+  }
+
+  static load(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get("MyEntity", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/no-network-names/generated/templates.ts b/gnd/tests/fixtures/codegen_verification/no-network-names/generated/templates.ts
new file mode 100644
index 00000000000..73242b4dde7
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/no-network-names/generated/templates.ts
@@ -0,0 +1,21 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  Address,
+  DataSourceTemplate,
+  DataSourceContext
+} from "@graphprotocol/graph-ts";
+
+export class ExampleTemplate extends DataSourceTemplate {
+  static create(address: Address): void {
+    DataSourceTemplate.create("ExampleTemplate", [address.toHex()]);
+  }
+
+  static createWithContext(address: Address, context: DataSourceContext): void {
+    DataSourceTemplate.createWithContext(
+      "ExampleTemplate",
+      [address.toHex()],
+      context
+    );
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/no-network-names/generated/templates/ExampleTemplate/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/no-network-names/generated/templates/ExampleTemplate/ExampleContract.ts
new file mode 100644
index 00000000000..6b59c48fbac
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/no-network-names/generated/templates/ExampleTemplate/ExampleContract.ts
@@ -0,0 +1,35 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt
+} from "@graphprotocol/graph-ts";
+
+export class ExampleEvent extends ethereum.Event {
+  get params(): ExampleEvent__Params {
+    return new ExampleEvent__Params(this);
+  }
+}
+
+export class ExampleEvent__Params {
+  _event: ExampleEvent;
+
+  constructor(event: ExampleEvent) {
+    this._event = event;
+  }
+
+  get param0(): string {
+    return this._event.parameters[0].value.toString();
+  }
+}
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/no-network-names/mapping.ts b/gnd/tests/fixtures/codegen_verification/no-network-names/mapping.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/gnd/tests/fixtures/codegen_verification/no-network-names/schema.graphql b/gnd/tests/fixtures/codegen_verification/no-network-names/schema.graphql
new file mode 100644
index 00000000000..d5a41952be6
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/no-network-names/schema.graphql
@@ -0,0 +1,3 @@
+type MyEntity @entity(immutable: true) {
+  id: ID!
+}
diff --git a/gnd/tests/fixtures/codegen_verification/no-network-names/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/no-network-names/subgraph.yaml
new file mode 100644
index 00000000000..1812193aa94
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/no-network-names/subgraph.yaml
@@ -0,0 +1,40 @@
+specVersion: 0.0.1
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    source:
+      address: '22843e74c59580b3eaf6c233fa67d8b7c561a835'
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - ExampleEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          handler: handleExampleEvent
+templates:
+  - kind: ethereum/contract
+    name: ExampleTemplate
+    source:
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - ExampleEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          handler: handleExampleEvent
diff --git a/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/Abi.json b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/Abi.json
new file mode 100644
index 00000000000..4d05f5839f8
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/Abi.json
@@ -0,0 +1,7 @@
+[
+  {
+    "type": "event",
+    "name": "ExampleEvent",
+    "inputs": [{ "type": "string" }]
+  }
+]
diff --git a/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/generated/ExampleSubgraph/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/generated/ExampleSubgraph/ExampleContract.ts
new file mode 100644
index 00000000000..6c9108fe3db
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/generated/ExampleSubgraph/ExampleContract.ts
@@ -0,0 +1,35 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt,
+} from "@graphprotocol/graph-ts";
+
+export class ExampleEvent extends ethereum.Event {
+  get params(): ExampleEvent__Params {
+    return new ExampleEvent__Params(this);
+  }
+}
+
+export class ExampleEvent__Params {
+  _event: ExampleEvent;
+
+  constructor(event: ExampleEvent) {
+    this._event = event;
+  }
+
+  get param0(): string {
+    return this._event.parameters[0].value.toString();
+  }
+}
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/generated/schema.ts b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/generated/schema.ts
new file mode 100644
index 00000000000..4dea4256e51
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/generated/schema.ts
@@ -0,0 +1,52 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  TypedMap,
+  Entity,
+  Value,
+  ValueKind,
+  store,
+  Bytes,
+  BigInt,
+  BigDecimal
+} from "@graphprotocol/graph-ts";
+
+export class MyEntity extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save MyEntity entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type MyEntity must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`
+      );
+      store.set("MyEntity", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get_in_block("MyEntity", id));
+  }
+
+  static load(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get("MyEntity", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/mapping.ts b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/mapping.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/schema.graphql b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/schema.graphql
new file mode 100644
index 00000000000..d5a41952be6
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/schema.graphql
@@ -0,0 +1,3 @@
+type MyEntity @entity(immutable: true) {
+  id: ID!
+}
diff --git a/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/subgraph.yaml
new file mode 100644
index 00000000000..fa916d5b6c3
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/source-without-address-is-valid/subgraph.yaml
@@ -0,0 +1,23 @@
+specVersion: 0.0.1
+repository: https://github.com/graphprotocol/test-subgraph
+description: Test subgraph
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    source:
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - ExampleEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          handler: handleExampleEvent
diff --git a/gnd/tests/fixtures/codegen_verification/topic0-is-valid/Abi.json b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/Abi.json
new file mode 100644
index 00000000000..4d05f5839f8
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/Abi.json
@@ -0,0 +1,7 @@
+[
+  {
+    "type": "event",
+    "name": "ExampleEvent",
+    "inputs": [{ "type": "string" }]
+  }
+]
diff --git a/gnd/tests/fixtures/codegen_verification/topic0-is-valid/generated/ExampleSubgraph/ExampleContract.ts b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/generated/ExampleSubgraph/ExampleContract.ts
new file mode 100644
index 00000000000..6b59c48fbac
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/generated/ExampleSubgraph/ExampleContract.ts
@@ -0,0 +1,35 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  ethereum,
+  JSONValue,
+  TypedMap,
+  Entity,
+  Bytes,
+  Address,
+  BigInt
+} from "@graphprotocol/graph-ts";
+
+export class ExampleEvent extends ethereum.Event {
+  get params(): ExampleEvent__Params {
+    return new ExampleEvent__Params(this);
+  }
+}
+
+export class ExampleEvent__Params {
+  _event: ExampleEvent;
+
+  constructor(event: ExampleEvent) {
+    this._event = event;
+  }
+
+  get param0(): string {
+    return this._event.parameters[0].value.toString();
+  }
+}
+
+export class ExampleContract extends ethereum.SmartContract {
+  static bind(address: Address): ExampleContract {
+    return new ExampleContract("ExampleContract", address);
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/topic0-is-valid/generated/schema.ts b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/generated/schema.ts
new file mode 100644
index 00000000000..faf8087b1cf
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/generated/schema.ts
@@ -0,0 +1,65 @@
+// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+
+import {
+  TypedMap,
+  Entity,
+  Value,
+  ValueKind,
+  store,
+  Bytes,
+  BigInt,
+  BigDecimal
+} from "@graphprotocol/graph-ts";
+
+export class MyEntity extends Entity {
+  constructor(id: string) {
+    super();
+    this.set("id", Value.fromString(id));
+  }
+
+  save(): void {
+    let id = this.get("id");
+    assert(id != null, "Cannot save MyEntity entity without an ID");
+    if (id) {
+      assert(
+        id.kind == ValueKind.STRING,
+        `Entities of type MyEntity must have an ID of type String but the id '${id.displayData()}' is of type ${id.displayKind()}`
+      );
+      store.set("MyEntity", id.toString(), this);
+    }
+  }
+
+  static loadInBlock(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get_in_block("MyEntity", id));
+  }
+
+  static load(id: string): MyEntity | null {
+    return changetype<MyEntity | null>(store.get("MyEntity", id));
+  }
+
+  get id(): string {
+    let value = this.get("id");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toString();
+    }
+  }
+
+  set id(value: string) {
+    this.set("id", Value.fromString(value));
+  }
+
+  get x(): BigDecimal {
+    let value = this.get("x");
+    if (!value || value.kind == ValueKind.NULL) {
+      throw new Error("Cannot return null for a required field.");
+    } else {
+      return value.toBigDecimal();
+    }
+  }
+
+  set x(value: BigDecimal) {
+    this.set("x", Value.fromBigDecimal(value));
+  }
+}
diff --git a/gnd/tests/fixtures/codegen_verification/topic0-is-valid/mapping.ts b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/mapping.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/gnd/tests/fixtures/codegen_verification/topic0-is-valid/schema.graphql b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/schema.graphql
new file mode 100644
index 00000000000..1edfc3c6c18
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/schema.graphql
@@ -0,0 +1,4 @@
+type MyEntity @entity(immutable: true) {
+  id: ID!
+  x: BigDecimal!
+}
diff --git a/gnd/tests/fixtures/codegen_verification/topic0-is-valid/subgraph.yaml b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/subgraph.yaml
new file mode 100644
index 00000000000..eb8721b6280
--- /dev/null
+++ b/gnd/tests/fixtures/codegen_verification/topic0-is-valid/subgraph.yaml
@@ -0,0 +1,24 @@
+specVersion: 0.0.1
+repository: https://github.com/graphprotocol/test-subgraph
+description: Test subgraph
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: ExampleSubgraph
+    source:
+      abi: ExampleContract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.5
+      language: wasm/assemblyscript
+      file: ./mapping.ts
+      entities:
+        - ExampleEntity
+      abis:
+        - name: ExampleContract
+          file: ./Abi.json
+      eventHandlers:
+        - event: ExampleEvent(string)
+          topic0: b74a38eb2ebca56512a2bb0283f335555a4a4dac46ab998d65fd76f9027dca70
+          handler: handleExampleEvent
diff --git a/gnd/tests/fixtures/gnd_test/blocks/abis/ERC20.json b/gnd/tests/fixtures/gnd_test/blocks/abis/ERC20.json
new file mode 100644
index 00000000000..405d6b36486
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/blocks/abis/ERC20.json
@@ -0,0 +1,222 @@
+[
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "name",
+    "outputs": [
+      {
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      {
+        "name": "_spender",
+        "type": "address"
+      },
+      {
+        "name": "_value",
+        "type": "uint256"
+      }
+    ],
+    "name": "approve",
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "totalSupply",
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      {
+        "name": "_from",
+        "type": "address"
+      },
+      {
+        "name": "_to",
+        "type": "address"
+      },
+      {
+        "name": "_value",
+        "type": "uint256"
+      }
+    ],
+    "name": "transferFrom",
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "decimals",
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [
+      {
+        "name": "_owner",
+        "type": "address"
+      }
+    ],
+    "name": "balanceOf",
+    "outputs": [
+      {
+        "name": "balance",
+        "type": "uint256"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "symbol",
+    "outputs": [
+      {
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      {
+        "name": "_to",
+        "type": "address"
+      },
+      {
+        "name": "_value",
+        "type": "uint256"
+      }
+    ],
+    "name": "transfer",
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [
+      {
+        "name": "_owner",
+        "type": "address"
+      },
+      {
+        "name": "_spender",
+        "type": "address"
+      }
+    ],
+    "name": "allowance",
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "payable": true,
+    "stateMutability": "payable",
+    "type": "fallback"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "name": "owner",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "Approval",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "Transfer",
+    "type": "event"
+  }
+]
diff --git a/gnd/tests/fixtures/gnd_test/blocks/package.json b/gnd/tests/fixtures/gnd_test/blocks/package.json
new file mode 100644
index 00000000000..8f9d6327502
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/blocks/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "gnd-test-blocks",
+  "version": "0.1.0",
+  "private": true,
+  "devDependencies": {
+    "@graphprotocol/graph-cli": "0.98.1",
+    "@graphprotocol/graph-ts": "0.38.2",
+    "assemblyscript": "0.19.23"
+  }
+}
diff --git a/gnd/tests/fixtures/gnd_test/blocks/schema.graphql b/gnd/tests/fixtures/gnd_test/blocks/schema.graphql
new file mode 100644
index 00000000000..53154f2b1d3
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/blocks/schema.graphql
@@ -0,0 +1,14 @@
+type Block @entity(immutable: true) {
+  id: Bytes!
+  number: BigInt!
+}
+
+type OnceBlock @entity(immutable: true) {
+  id: Bytes!
+  msg: String!
+}
+
+type PollingBlock @entity(immutable: true) {
+  id: Bytes!
+  number: BigInt!
+}
diff --git a/gnd/tests/fixtures/gnd_test/blocks/src/blocks.ts b/gnd/tests/fixtures/gnd_test/blocks/src/blocks.ts
new file mode 100644
index 00000000000..f9a271681ad
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/blocks/src/blocks.ts
@@ -0,0 +1,23 @@
+import { Bytes, ethereum, log } from "@graphprotocol/graph-ts";
+import {Block, OnceBlock, PollingBlock} from "../generated/schema";
+
+export function handleEveryBlock(block: ethereum.Block): void {
+  log.warning("Handling every block event for block number: {}", [block.number.toString()]);
+  let blockEntity = new Block(block.hash);
+  blockEntity.number = block.number;
+  blockEntity.save();
+}
+
+export function handleOnce(block: ethereum.Block): void {
+  log.warning("Handling a one-time block event for block number: {}", [block.number.toString()]);
+  let blockOnceEntity = new OnceBlock(block.hash.concat(Bytes.fromUTF8("-once")));
+  blockOnceEntity.msg = "This is a one-time block entity";
+  blockOnceEntity.save();
+}
+
+export function handlePolling(block: ethereum.Block): void {
+  log.warning("Handling a polling block event for block number: {}", [block.number.toString()]);
+  let blockEntity = new PollingBlock(block.hash);
+  blockEntity.number = block.number;
+  blockEntity.save();
+}
diff --git a/gnd/tests/fixtures/gnd_test/blocks/subgraph.yaml b/gnd/tests/fixtures/gnd_test/blocks/subgraph.yaml
new file mode 100644
index 00000000000..a5f727da28d
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/blocks/subgraph.yaml
@@ -0,0 +1,64 @@
+specVersion: 1.3.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - name: EveryBlock
+    kind: ethereum
+    network: arbitrum
+    source:
+      abi: ERC20
+      address: "0x0000000000000000000000000000000000000000"
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      file: ./src/blocks.ts
+      entities:
+        - Block
+      abis:
+        - name: ERC20
+          file: ./abis/ERC20.json
+      blockHandlers:
+        - handler: handleEveryBlock
+  - name: BlockOnce
+    kind: ethereum
+    network: arbitrum
+    source:
+      abi: ERC20
+      address: "0x0000000000000000000000000000000000000000"
+      startBlock: 1000
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      file: ./src/blocks.ts
+      entities:
+        - OnceBlock
+      abis:
+        - name: ERC20
+          file: ./abis/ERC20.json
+      blockHandlers:
+        - handler: handleOnce
+          filter:
+            kind: once
+  - name: BlockPolling
+    kind: ethereum
+    network: arbitrum
+    source:
+      abi: ERC20
+      address: "0x0000000000000000000000000000000000000000"
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      file: ./src/blocks.ts
+      entities:
+        - PollingBlock
+      abis:
+        - name: ERC20
+          file: ./abis/ERC20.json
+      blockHandlers:
+        - handler: handlePolling
+          filter:
+            kind: polling
+            every: 5
diff --git a/gnd/tests/fixtures/gnd_test/blocks/tests/blocks.json b/gnd/tests/fixtures/gnd_test/blocks/tests/blocks.json
new file mode 100644
index 00000000000..8065b6aa398
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/blocks/tests/blocks.json
@@ -0,0 +1,43 @@
+{
+  "name": "Example Block Handler Testing",
+  "blocks": [
+    {"number": 1000},
+    {"number": 1001},
+    {"number": 1002},
+    {"number": 1003},
+    {"number": 1004},
+    {"number": 1005}
+  ],
+  "assertions": [
+    {
+      "query": "{ blocks { number } }",
+      "expected": {
+        "blocks": [
+          {"number": "1000"},
+          {"number": "1001"},
+          {"number": "1002"},
+          {"number": "1003"},
+          {"number": "1004"},
+          {"number": "1005"}
+        ]
+      }
+    },
+    {
+      "query": "{ onceBlocks { msg } }",
+      "expected": {
+        "onceBlocks": [
+          {"msg": "This is a one-time block entity"}
+        ]
+      }
+    },
+    {
+      "query": "{ pollingBlocks { number } }",
+      "expected": {
+        "pollingBlocks": [
+          {"number":"1000"},
+          {"number": "1005"}
+        ]
+      }
+    }
+  ]
+}
diff --git a/gnd/tests/fixtures/gnd_test/file-data-sources/abis/FileEvents.json b/gnd/tests/fixtures/gnd_test/file-data-sources/abis/FileEvents.json
new file mode 100644
index 00000000000..8a1a3861982
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/file-data-sources/abis/FileEvents.json
@@ -0,0 +1,28 @@
+[
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "string",
+        "name": "cid",
+        "type": "string"
+      }
+    ],
+    "name": "IpfsFileCreated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "string",
+        "name": "txId",
+        "type": "string"
+      }
+    ],
+    "name": "ArweaveFileCreated",
+    "type": "event"
+  }
+]
diff --git a/gnd/tests/fixtures/gnd_test/file-data-sources/package.json b/gnd/tests/fixtures/gnd_test/file-data-sources/package.json
new file mode 100644
index 00000000000..6154ce4bee6
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/file-data-sources/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "gnd-test-file-data-sources",
+  "version": "0.1.0",
+  "private": true,
+  "devDependencies": {
+    "@graphprotocol/graph-cli": "0.98.1",
+    "@graphprotocol/graph-ts": "0.38.2",
+    "assemblyscript": "0.19.23"
+  }
+}
diff --git a/gnd/tests/fixtures/gnd_test/file-data-sources/schema.graphql b/gnd/tests/fixtures/gnd_test/file-data-sources/schema.graphql
new file mode 100644
index 00000000000..1966b71c61c
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/file-data-sources/schema.graphql
@@ -0,0 +1,9 @@
+type IpfsFile @entity {
+  id: ID!
+  content: String!
+}
+
+type ArweaveFile @entity {
+  id: ID!
+  content: String!
+}
diff --git a/gnd/tests/fixtures/gnd_test/file-data-sources/src/files.ts b/gnd/tests/fixtures/gnd_test/file-data-sources/src/files.ts
new file mode 100644
index 00000000000..a5bd9ee7e7e
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/file-data-sources/src/files.ts
@@ -0,0 +1,26 @@
+import { dataSource, Bytes } from "@graphprotocol/graph-ts";
+import {
+  IpfsFileCreated,
+  ArweaveFileCreated,
+} from "../generated/FileEvents/FileEvents";
+import { IpfsFile, ArweaveFile } from "../generated/schema";
+
+export function handleIpfsFileCreated(event: IpfsFileCreated): void {
+  dataSource.create("IpfsFile", [event.params.cid]);
+}
+
+export function handleArweaveFileCreated(event: ArweaveFileCreated): void {
+  dataSource.create("ArweaveFile", [event.params.txId]);
+}
+
+export function handleIpfsFile(data: Bytes): void {
+  let entity = new IpfsFile(dataSource.stringParam());
+  entity.content = data.toString();
+  entity.save();
+}
+
+export function handleArweaveFile(data: Bytes): void {
+  let entity = new ArweaveFile(dataSource.stringParam());
+  entity.content = data.toString();
+  entity.save();
+}
diff --git a/gnd/tests/fixtures/gnd_test/file-data-sources/subgraph.yaml b/gnd/tests/fixtures/gnd_test/file-data-sources/subgraph.yaml
new file mode 100644
index 00000000000..3a898f9f8d6
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/file-data-sources/subgraph.yaml
@@ -0,0 +1,53 @@
+specVersion: 1.3.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - name: FileEvents
+    kind: ethereum/contract
+    network: arbitrum
+    source:
+      abi: FileEvents
+      address: "0x0000000000000000000000000000000000000002"
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      file: ./src/files.ts
+      entities:
+        - IpfsFile
+        - ArweaveFile
+      abis:
+        - name: FileEvents
+          file: ./abis/FileEvents.json
+      eventHandlers:
+        - event: IpfsFileCreated(string)
+          handler: handleIpfsFileCreated
+        - event: ArweaveFileCreated(string)
+          handler: handleArweaveFileCreated
+templates:
+  - name: IpfsFile
+    kind: file/ipfs
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      file: ./src/files.ts
+      entities:
+        - IpfsFile
+      abis:
+        - name: FileEvents
+          file: ./abis/FileEvents.json
+      handler: handleIpfsFile
+  - name: ArweaveFile
+    kind: file/arweave
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      file: ./src/files.ts
+      entities:
+        - ArweaveFile
+      abis:
+        - name: FileEvents
+          file: ./abis/FileEvents.json
+      handler: handleArweaveFile
diff --git a/gnd/tests/fixtures/gnd_test/file-data-sources/tests/file_arweave.json b/gnd/tests/fixtures/gnd_test/file-data-sources/tests/file_arweave.json
new file mode 100644
index 00000000000..708ca1a5865
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/file-data-sources/tests/file_arweave.json
@@ -0,0 +1,36 @@
+{
+  "name": "Arweave file data source creates entity from fetched content",
+  "arweaveFiles": [
+    {
+      "txId": "8APeQ5lW0-csTcBaGdPBDLAL2ci2AT9pTn2tppGPU_8",
+      "content": "Hello from Arweave"
+    }
+  ],
+  "blocks": [
+    {
+      "events": [
+        {
+          "address": "0x0000000000000000000000000000000000000002",
+          "event": "ArweaveFileCreated(string txId)",
+          "params": {
+            "txId": "8APeQ5lW0-csTcBaGdPBDLAL2ci2AT9pTn2tppGPU_8"
+          }
+        }
+      ]
+    },
+    {}
+  ],
+  "assertions": [
+    {
+      "query": "{ arweaveFiles { id content } }",
+      "expected": {
+        "arweaveFiles": [
+          {
+            "id": "8APeQ5lW0-csTcBaGdPBDLAL2ci2AT9pTn2tppGPU_8",
+            "content": "Hello from Arweave"
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/gnd/tests/fixtures/gnd_test/file-data-sources/tests/file_ipfs.json b/gnd/tests/fixtures/gnd_test/file-data-sources/tests/file_ipfs.json
new file mode 100644
index 00000000000..8fee92571b4
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/file-data-sources/tests/file_ipfs.json
@@ -0,0 +1,36 @@
+{
+  "name": "IPFS file data source creates entity from fetched content",
+  "files": [
+    {
+      "cid": "QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG",
+      "content": "Hello from IPFS"
+    }
+  ],
+  "blocks": [
+    {
+      "events": [
+        {
+          "address": "0x0000000000000000000000000000000000000002",
+          "event": "IpfsFileCreated(string cid)",
+          "params": {
+            "cid": "QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG"
+          }
+        }
+      ]
+    },
+    {}
+  ],
+  "assertions": [
+    {
+      "query": "{ ipfsFiles { id content } }",
+      "expected": {
+        "ipfsFiles": [
+          {
+            "id": "QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG",
+            "content": "Hello from IPFS"
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/gnd/tests/fixtures/gnd_test/receipts/abis/ERC20.json b/gnd/tests/fixtures/gnd_test/receipts/abis/ERC20.json
new file mode 100644
index 00000000000..405d6b36486
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/receipts/abis/ERC20.json
@@ -0,0 +1,222 @@
+[
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "name",
+    "outputs": [
+      {
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      {
+        "name": "_spender",
+        "type": "address"
+      },
+      {
+        "name": "_value",
+        "type": "uint256"
+      }
+    ],
+    "name": "approve",
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "totalSupply",
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      {
+        "name": "_from",
+        "type": "address"
+      },
+      {
+        "name": "_to",
+        "type": "address"
+      },
+      {
+        "name": "_value",
+        "type": "uint256"
+      }
+    ],
+    "name": "transferFrom",
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "decimals",
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [
+      {
+        "name": "_owner",
+        "type": "address"
+      }
+    ],
+    "name": "balanceOf",
+    "outputs": [
+      {
+        "name": "balance",
+        "type": "uint256"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "symbol",
+    "outputs": [
+      {
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      {
+        "name": "_to",
+        "type": "address"
+      },
+      {
+        "name": "_value",
+        "type": "uint256"
+      }
+    ],
+    "name": "transfer",
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [
+      {
+        "name": "_owner",
+        "type": "address"
+      },
+      {
+        "name": "_spender",
+        "type": "address"
+      }
+    ],
+    "name": "allowance",
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "payable": true,
+    "stateMutability": "payable",
+    "type": "fallback"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "name": "owner",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "Approval",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "Transfer",
+    "type": "event"
+  }
+]
diff --git a/gnd/tests/fixtures/gnd_test/receipts/package.json b/gnd/tests/fixtures/gnd_test/receipts/package.json
new file mode 100644
index 00000000000..c04018dd36c
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/receipts/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "gnd-test-receipts",
+  "version": "0.1.0",
+  "private": true,
+  "devDependencies": {
+    "@graphprotocol/graph-cli": "0.98.1",
+    "@graphprotocol/graph-ts": "0.38.2",
+    "assemblyscript": "0.19.23"
+  }
+}
diff --git a/gnd/tests/fixtures/gnd_test/receipts/schema.graphql b/gnd/tests/fixtures/gnd_test/receipts/schema.graphql
new file mode 100644
index 00000000000..009205bf890
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/receipts/schema.graphql
@@ -0,0 +1,13 @@
+type Transfer @entity(immutable: true) {
+  id: Bytes!
+  from: Bytes!
+  to: Bytes!
+  value: BigInt!
+}
+
+type Approval @entity(immutable: true) {
+  id: Bytes!
+  owner: Bytes!
+  spender: Bytes!
+  value: BigInt!
+}
diff --git a/gnd/tests/fixtures/gnd_test/receipts/src/receipts.ts b/gnd/tests/fixtures/gnd_test/receipts/src/receipts.ts
new file mode 100644
index 00000000000..3a7934c6d55
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/receipts/src/receipts.ts
@@ -0,0 +1,40 @@
+import { Transfer as TransferEvent } from '../generated/Receipts/ERC20'
+import { Transfer, Approval } from '../generated/schema'
+import { Bytes, ethereum, log } from "@graphprotocol/graph-ts";
+
+const APPROVAL_TOPIC0 = "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"
+
+export function handleEventsWithReceipts(event: TransferEvent): void {
+  let receipt = event.receipt;
+
+  if (!receipt) {
+    log.error("No receipt found for transaction {}", [event.transaction.hash.toHexString()]);
+    return;
+  }
+
+  // iterate over the logs in the receipt and find the Approval event
+  for (let i = 0; i < receipt.logs.length; i++) {
+    let logEntry = receipt.logs[i];
+
+    if (logEntry.topics[0].toHexString() == APPROVAL_TOPIC0) {
+      let approval = new Approval(event.transaction.hash);
+      // trim the padding from the topics to get the actual address
+      approval.owner = changetype<Bytes>(logEntry.topics[1].subarray(12, 32));
+      approval.spender = changetype<Bytes>(logEntry.topics[2].subarray(12, 32));
+      let data = ethereum.decode("uint256", logEntry.data);
+      if (data) {
+        approval.value = data.toBigInt();
+      } else {
+        log.error("Failed to decode approval value for transaction {}", [event.transaction.hash.toHexString()]);
+        return;
+      }
+      approval.save();
+    }
+  }
+
+  let transfer = new Transfer(event.transaction.hash);
+  transfer.from = event.params.from;
+  transfer.to = event.params.to;
+  transfer.value = event.params.value;
+  transfer.save();
+}
diff --git a/gnd/tests/fixtures/gnd_test/receipts/subgraph.yaml b/gnd/tests/fixtures/gnd_test/receipts/subgraph.yaml
new file mode 100644
index 00000000000..5913550c427
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/receipts/subgraph.yaml
@@ -0,0 +1,25 @@
+specVersion: 1.3.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - name: Receipts
+    kind: ethereum/contract
+    network: arbitrum
+    source:
+      abi: ERC20
+      address: "0x000000000000000000000000000000000000000a"
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      file: ./src/receipts.ts
+      entities:
+        - Transfer
+        - Approval
+      abis:
+        - name: ERC20
+          file: ./abis/ERC20.json
+      eventHandlers:
+        - event: Transfer(indexed address,indexed address,uint256)
+          handler: handleEventsWithReceipts
+          receipt: true
diff --git a/gnd/tests/fixtures/gnd_test/receipts/tests/receipts.json b/gnd/tests/fixtures/gnd_test/receipts/tests/receipts.json
new file mode 100644
index 00000000000..67388f6faa8
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/receipts/tests/receipts.json
@@ -0,0 +1,39 @@
+{
+  "name": "Test events and eth_call mocking",
+  "blocks": [
+    {
+      "events": [
+        {
+          "address": "0x000000000000000000000000000000000000000a",
+          "event": "Approval(address indexed owner, address indexed spender, uint256 value)",
+          "params": {
+            "owner": "0xaaaa000000000000000000000000000000000000",
+            "spender": "0xbbbb000000000000000000000000000000000000",
+            "value": "1000000000000000000"
+          },
+          "txHash": "0xdeadbeef00000000000000000000000000000000000000000000000000000000"
+        },
+        {
+          "address": "0x000000000000000000000000000000000000000a",
+          "event": "Transfer(address indexed from, address indexed to, uint256 value)",
+          "params": {
+            "from": "0xbbbb000000000000000000000000000000000000",
+            "to": "0xcccc000000000000000000000000000000000000",
+            "value": "1000000000000000000"
+          },
+          "txHash": "0xdeadbeef00000000000000000000000000000000000000000000000000000000"
+        }
+      ]
+    }
+  ],
+  "assertions": [
+    {
+      "query": "{ transfers { id from to value } }",
+      "expected": { "transfers": [ { "id": "0xdeadbeef00000000000000000000000000000000000000000000000000000000", "from": "0xbbbb000000000000000000000000000000000000", "to": "0xcccc000000000000000000000000000000000000", "value": "1000000000000000000"} ] }
+    },
+    {
+      "query": "{ approvals {id owner spender value } }",
+      "expected": { "approvals": [ { "id": "0xdeadbeef00000000000000000000000000000000000000000000000000000000", "owner": "0xaaaa000000000000000000000000000000000000", "spender": "0xbbbb000000000000000000000000000000000000", "value": "1000000000000000000" } ] }
+    }
+  ]
+}
diff --git a/gnd/tests/fixtures/gnd_test/token/abis/ERC20.json b/gnd/tests/fixtures/gnd_test/token/abis/ERC20.json
new file mode 100644
index 00000000000..405d6b36486
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/token/abis/ERC20.json
@@ -0,0 +1,222 @@
+[
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "name",
+    "outputs": [
+      {
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      {
+        "name": "_spender",
+        "type": "address"
+      },
+      {
+        "name": "_value",
+        "type": "uint256"
+      }
+    ],
+    "name": "approve",
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "totalSupply",
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      {
+        "name": "_from",
+        "type": "address"
+      },
+      {
+        "name": "_to",
+        "type": "address"
+      },
+      {
+        "name": "_value",
+        "type": "uint256"
+      }
+    ],
+    "name": "transferFrom",
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "decimals",
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [
+      {
+        "name": "_owner",
+        "type": "address"
+      }
+    ],
+    "name": "balanceOf",
+    "outputs": [
+      {
+        "name": "balance",
+        "type": "uint256"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "symbol",
+    "outputs": [
+      {
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      {
+        "name": "_to",
+        "type": "address"
+      },
+      {
+        "name": "_value",
+        "type": "uint256"
+      }
+    ],
+    "name": "transfer",
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [
+      {
+        "name": "_owner",
+        "type": "address"
+      },
+      {
+        "name": "_spender",
+        "type": "address"
+      }
+    ],
+    "name": "allowance",
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "payable": true,
+    "stateMutability": "payable",
+    "type": "fallback"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "name": "owner",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "Approval",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "Transfer",
+    "type": "event"
+  }
+]
diff --git a/gnd/tests/fixtures/gnd_test/token/abis/TokenFactory.json b/gnd/tests/fixtures/gnd_test/token/abis/TokenFactory.json
new file mode 100644
index 00000000000..d23f24c8ae2
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/token/abis/TokenFactory.json
@@ -0,0 +1,28 @@
+[
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "addr",
+        "type": "address"
+      }
+    ],
+    "name": "FactoryTokenCreated",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "addr",
+        "type": "address"
+      }
+    ],
+    "name": "createToken",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/gnd/tests/fixtures/gnd_test/token/package.json b/gnd/tests/fixtures/gnd_test/token/package.json
new file mode 100644
index 00000000000..69ecc1c9311
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/token/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "gnd-test-token",
+  "version": "0.1.0",
+  "private": true,
+  "devDependencies": {
+    "@graphprotocol/graph-cli": "0.98.1",
+    "@graphprotocol/graph-ts": "0.38.2",
+    "assemblyscript": "0.19.23"
+  }
+}
diff --git a/gnd/tests/fixtures/gnd_test/token/schema.graphql b/gnd/tests/fixtures/gnd_test/token/schema.graphql
new file mode 100644
index 00000000000..4f4885fe848
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/token/schema.graphql
@@ -0,0 +1,18 @@
+type Token @entity(immutable: true) {
+  id: Bytes! # Address
+  name: String!
+  symbol: String!
+  decimals: Int!
+}
+
+type Account @entity(immutable: false) {
+  id: Bytes! # Address
+  balances: [Balance!]! @derivedFrom(field: "account")
+}
+
+type Balance @entity(immutable: false) {
+  id: Bytes! # Account address + token address
+  token: Token!
+  account: Account!
+  amount: BigInt
+}
diff --git a/gnd/tests/fixtures/gnd_test/token/src/factory.ts b/gnd/tests/fixtures/gnd_test/token/src/factory.ts
new file mode 100644
index 00000000000..9b00e6a0b74
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/token/src/factory.ts
@@ -0,0 +1,21 @@
+import { FactoryTokenCreated } from '../generated/Factory/TokenFactory'
+import { Token } from '../generated/schema'
+import { FactoryToken } from '../generated/templates';
+import { ERC20 } from '../generated/templates/FactoryToken/ERC20';
+
+export function handleTokenCreated(event: FactoryTokenCreated): void {
+  FactoryToken.create(event.params.addr);
+  let token = new Token(event.params.addr);
+
+  // Try to fetch token details using ERC20 interface
+  let erc20 = ERC20.bind(event.params.addr);
+  let nameResult = erc20.try_name();
+  let symbolResult = erc20.try_symbol();
+  let decimalsResult = erc20.try_decimals();
+
+  // If the calls revert, we can set default values
+  token.name = nameResult.reverted ? "Unknown" : nameResult.value;
+  token.symbol = symbolResult.reverted ? "Unknown" : symbolResult.value;
+  token.decimals = decimalsResult.reverted ? 18 : decimalsResult.value;
+  token.save();
+}
diff --git a/gnd/tests/fixtures/gnd_test/token/src/token.ts b/gnd/tests/fixtures/gnd_test/token/src/token.ts
new file mode 100644
index 00000000000..21b09f43de6
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/token/src/token.ts
@@ -0,0 +1,86 @@
+import { Transfer } from '../generated/StandardToken/ERC20'
+import { Token, Account, Balance } from '../generated/schema'
+import { ERC20 } from '../generated/StandardToken/ERC20';
+import { log } from "@graphprotocol/graph-ts";
+
+export function handleTransfer(event: Transfer): void {
+  let token = Token.load(event.address);
+  let from = Account.load(event.params.from);
+  let to = Account.load(event.params.to);
+  let balanceFrom = Balance.load(event.params.from.concat(event.address));
+  let balanceTo = Balance.load(event.params.to.concat(event.address));
+
+  let erc20 = ERC20.bind(event.address);
+
+  if (!token) {
+    token = new Token(event.address);
+
+    // Try to fetch token details using ERC20 interface
+    let nameResult = erc20.try_name();
+    let symbolResult = erc20.try_symbol();
+    let decimalsResult = erc20.try_decimals();
+
+    // If the calls revert, we can set default values
+    token.name = nameResult.reverted ? "Unknown" : nameResult.value;
+    token.symbol = symbolResult.reverted ? "Unknown" : symbolResult.value;
+    token.decimals = decimalsResult.reverted ? 18 : decimalsResult.value;
+    token.save();
+  }
+
+  if (!from) {
+    from = new Account(event.params.from);
+    from.save();
+  }
+
+  if (!to) {
+    to = new Account(event.params.to);
+    to.save();
+  }
+
+  if (!balanceFrom) {
+    log.warning("Balance for account {} and token {} does not exist. Creating new balance entity.", [event.params.from.toHexString(), event.address.toHexString()]);
+    balanceFrom = new Balance(event.params.from.concat(event.address));
+    balanceFrom.account = event.params.from;
+    balanceFrom.token = event.address;
+    let balanceFromResult = erc20.try_balanceOf(event.params.from);
+    balanceFrom.amount = balanceFromResult.reverted ? null : balanceFromResult.value;
+  } else {
+    log.warning("Balance for account {} and token {} already exists. Updating balance based on transfer value.", [event.params.from.toHexString(), event.address.toHexString()]);
+    // If the balance already exists, we need to update it based on the transfer value
+    // We will fetch the current balance and then update it after the transfer
+    let currentBalance = balanceFrom.amount;
+
+    if (currentBalance) {
+      let newBalance = currentBalance.minus(event.params.value);
+      balanceFrom.amount = newBalance;
+    } else {
+      // Try to fetch the balance if it was not previously set
+      let balanceFromResult = erc20.try_balanceOf(event.params.from);
+      balanceFrom.amount = balanceFromResult.reverted ? null : balanceFromResult.value;
+    }
+  }
+
+  if (!balanceTo) {
+    balanceTo = new Balance(event.params.to.concat(event.address));
+    balanceTo.account = event.params.to;
+    balanceTo.token = event.address;
+    let balanceToResult = erc20.try_balanceOf(event.params.to);
+    balanceTo.amount = balanceToResult.reverted ? null : balanceToResult.value;
+  } else {
+    // If the balance already exists, we need to update it based on the transfer value
+    // We will fetch the current balance and then update it after the transfer
+    let currentBalance = balanceTo.amount;
+
+    if (currentBalance) {
+      let newBalance = currentBalance.plus(event.params.value);
+      balanceTo.amount = newBalance;
+    } else {
+      // Try to fetch the balance if it was not previously set
+      let balanceToResult = erc20.try_balanceOf(event.params.to);
+      balanceTo.amount = balanceToResult.reverted ? null : balanceToResult.value;
+    }
+  }
+
+  balanceFrom.save();
+  balanceTo.save();
+}
diff --git a/gnd/tests/fixtures/gnd_test/token/subgraph.yaml b/gnd/tests/fixtures/gnd_test/token/subgraph.yaml
new file mode 100644
index 00000000000..081b071704b
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/token/subgraph.yaml
@@ -0,0 +1,68 @@
+specVersion: 1.3.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - name: StandardToken
+    kind: ethereum/contract
+    network: arbitrum
+    source:
+      abi: ERC20
+      address: "0x9623063377AD1B27544C965cCd7342f7EA7e88C7"
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      file: ./src/token.ts
+      entities:
+        - Token
+        - Account
+        - Balance
+      abis:
+        - name: ERC20
+          file: ./abis/ERC20.json
+      eventHandlers:
+        - event: Transfer(indexed address,indexed address,uint256)
+          handler: handleTransfer
+  - name: Factory
+    kind: ethereum/contract
+    network: arbitrum
+    source:
+      abi: TokenFactory
+      address: "0x0000000000000000000000000000000000000001"
+      startBlock: 2000
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      file: ./src/factory.ts
+      entities:
+        - Token
+      abis:
+        - name: TokenFactory
+          file: ./abis/TokenFactory.json
+        - name: ERC20
+          file: ./abis/ERC20.json
+      eventHandlers:
+        - event: FactoryTokenCreated(indexed address)
+          handler: handleTokenCreated
+templates:
+  - name: FactoryToken
+    kind: ethereum/contract
+    network: arbitrum
+    source:
+      abi: ERC20
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      file: ./src/token.ts
+      entities:
+        - Token
+        - Account
+        - Balance
+      abis:
+        - name: ERC20
+          file: ./abis/ERC20.json
+      eventHandlers:
+        - event: Transfer(indexed address,indexed address,uint256)
+          handler: handleTransfer
diff --git a/gnd/tests/fixtures/gnd_test/token/tests/failing.json b/gnd/tests/fixtures/gnd_test/token/tests/failing.json
new file mode 100644
index 00000000000..e9970588221
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/token/tests/failing.json
@@ -0,0 +1,12 @@
+{
+  "name": "Deliberately failing test (wrong expected value)",
+  "blocks": [
+    {}
+  ],
+  "assertions": [
+    {
+      "query": "{ tokens { id name symbol } }",
+      "expected": { "tokens": [ { "id": "0x731a10897d267e19b34503ad902d0a29173ba4b1", "name": "TheGraph", "symbol": "GRT" } ] }
+    }
+  ]
+}
diff --git a/gnd/tests/fixtures/gnd_test/token/tests/templates.json b/gnd/tests/fixtures/gnd_test/token/tests/templates.json
new file mode 100644
index 00000000000..dc78dfc4c28
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/token/tests/templates.json
@@ -0,0 +1,80 @@
+{
+  "name": "Test dynamic datasources support",
+  "blocks": [
+    {
+      "number": 2001,
+      "events": [
+        {
+          "address": "0x0000000000000000000000000000000000000001",
+          "event": "FactoryTokenCreated(address indexed addr)",
+          "params": {
+            "addr": "0x0000000000000000000000000000000000000002"
+          }
+        }
+      ],
+      "ethCalls": [
+        {
+          "address": "0x0000000000000000000000000000000000000002",
+          "function": "symbol()(string)",
+          "params": [],
+          "returns": ["FT1"]
+        },
+        {
+          "address": "0x0000000000000000000000000000000000000002",
+          "function": "name()(string)",
+          "params": [],
+          "returns": ["FactoryToken1"]
+        },
+        {
+          "address": "0x0000000000000000000000000000000000000002",
+          "function": "decimals()(uint8)",
+          "params": [],
+          "returns": ["18"]
+        }
+      ]
+    },
+    {
+      "number": 2002,
+      "events": [
+        {
+          "address": "0x0000000000000000000000000000000000000002",
+          "event": "Transfer(address indexed from, address indexed to, uint256 value)",
+          "params": {
+            "from": "0xaaaa000000000000000000000000000000000000",
+            "to": "0xbbbb000000000000000000000000000000000000",
+            "value": "1000000000000000000"
+          }
+        }
+      ],
+      "ethCalls": [
+        {
+          "address": "0x0000000000000000000000000000000000000002",
+          "function": "balanceOf(address)(uint256)",
+          "params": ["0xaaaa000000000000000000000000000000000000"],
+          "returns": ["3000000000000000000"]
+        },
+        {
+          "address": "0x0000000000000000000000000000000000000002",
+          "function": "balanceOf(address)(uint256)",
+          "params": ["0xbbbb000000000000000000000000000000000000"],
+          "returns": ["5000000000000000000"]
+        }
+      ]
+    }
+  ],
+  "assertions": [
+    {
+      "query": "{ tokens { id name symbol decimals } }",
+      "expected": { "tokens": [ { "id": "0x0000000000000000000000000000000000000002", "name": "FactoryToken1", "symbol": "FT1", "decimals": 18 } ] }
+    },
+    {
+      "query": "{ accounts { id balances { token { symbol } amount } } }",
+      "expected": {
+        "accounts": [
+          {"id": "0xbbbb000000000000000000000000000000000000", "balances": [{"token": { "symbol": "FT1" }, "amount": "5000000000000000000"}]},
+          {"id": "0xaaaa000000000000000000000000000000000000", "balances": [{"token": { "symbol": "FT1" }, "amount": "3000000000000000000"}]}
+        ]
+      }
+    }
+  ]
+}
diff --git a/gnd/tests/fixtures/gnd_test/token/tests/transfer.json b/gnd/tests/fixtures/gnd_test/token/tests/transfer.json
new file mode 100644
index 00000000000..d8693d89590
--- /dev/null
+++ b/gnd/tests/fixtures/gnd_test/token/tests/transfer.json
@@ -0,0 +1,65 @@
+{
+  "name": "Test events and eth_call mocking",
+  "blocks": [
+    {
+      "events": [
+        {
+          "address": "0x9623063377AD1B27544C965cCd7342f7EA7e88C7",
+          "event": "Transfer(address indexed from, address indexed to, uint256 value)",
+          "params": {
+            "from": "0xaaaa000000000000000000000000000000000000",
+            "to": "0xbbbb000000000000000000000000000000000000",
+            "value": "1000000000000000000"
+          }
+        }
+      ],
+      "ethCalls": [
+        {
+          "address": "0x9623063377AD1B27544C965cCd7342f7EA7e88C7",
+          "function": "symbol()(string)",
+          "params": [],
+          "returns": ["GRT"]
+        },
+        {
+          "address": "0x9623063377AD1B27544C965cCd7342f7EA7e88C7",
+          "function": "name()(string)",
+          "params": [],
+          "returns": ["TheGraph"]
+        },
+        {
+          "address": "0x9623063377AD1B27544C965cCd7342f7EA7e88C7",
+          "function": "decimals()(uint8)",
+          "params": [],
+          "returns": ["18"]
+        },
+        {
+          "address": "0x9623063377AD1B27544C965cCd7342f7EA7e88C7",
+          "function": "balanceOf(address)(uint256)",
+          "params": ["0xaaaa000000000000000000000000000000000000"],
+          "returns": ["3000000000000000000"]
+        },
+        {
+          "address": "0x9623063377AD1B27544C965cCd7342f7EA7e88C7",
+          "function": "balanceOf(address)(uint256)",
+          "params": ["0xbbbb000000000000000000000000000000000000"],
+          "returns": ["5000000000000000000"]
+        }
+      ]
+    }
+  ],
+  "assertions": [
+    {
+      "query": "{ tokens { id name symbol decimals } }",
+      "expected": { "tokens": [ { "id": "0x9623063377ad1b27544c965ccd7342f7ea7e88c7", "name": "TheGraph", "symbol": "GRT", "decimals": 18 } ] }
+    },
+    {
+      "query": "{ accounts { id balances { token { symbol } amount } } }",
+      "expected": {
+        "accounts": [
+          {"id": "0xbbbb000000000000000000000000000000000000", "balances": [{"token": { "symbol": "GRT" }, "amount": "5000000000000000000"}]},
+          {"id": "0xaaaa000000000000000000000000000000000000", "balances": [{"token": { "symbol": "GRT" }, "amount": "3000000000000000000"}]}
+        ]
+      }
+    }
+  ]
+}
diff --git a/gnd/tests/fixtures/regenerate.sh b/gnd/tests/fixtures/regenerate.sh
new file mode 100755
index 00000000000..c423342b42c
--- /dev/null
+++ b/gnd/tests/fixtures/regenerate.sh
@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+#
+# Regenerate codegen fixtures using graph-cli.
+#
+# This script regenerates the `generated/` directories in the codegen_verification
+# fixtures using the `graph` CLI. Run this when you need to update the expected
+# output after changes to graph-cli codegen.
+#
+# Prerequisites:
+#   - graph CLI must be installed (`pnpm install -g @graphprotocol/graph-cli`)
+#   - Or use npx: GRAPH_CMD="npx graph" ./regenerate.sh
+#
+# Usage:
+#   ./regenerate.sh              # Regenerate all fixtures
+#   ./regenerate.sh fixture-name # Regenerate specific fixture
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+FIXTURES_DIR="$SCRIPT_DIR/codegen_verification"
+
+# Allow overriding the graph command (e.g., GRAPH_CMD="npx graph")
+GRAPH_CMD="${GRAPH_CMD:-graph}"
+
+FIXTURES=(
+    "2d-array-is-valid"
+    "3d-array-is-valid"
+    "big-decimal-is-valid"
+    "block-handler-filters"
+    "call-handler-with-tuple"
+    "derived-from-with-interface"
+    "example-values-found"
+    "invalid-graphql-schema"
+    "no-network-names"
+    "source-without-address-is-valid"
+    "topic0-is-valid"
+)
+
+# Check if graph CLI is available
+if ! command -v $GRAPH_CMD &> /dev/null; then
+    echo "Error: '$GRAPH_CMD' command not found."
+    echo ""
+    echo "Install graph-cli with one of these methods:"
+    echo "  pnpm install -g @graphprotocol/graph-cli"
+    echo "  npm install -g @graphprotocol/graph-cli"
+    echo ""
+    echo "Or use npx to run without installing:"
+    echo "  GRAPH_CMD=\"npx graph\" $0"
+    exit 1
+fi
+
+regenerate_fixture() {
+    local fixture="$1"
+    local fixture_path="$FIXTURES_DIR/$fixture"
+
+    if [[ ! -d "$fixture_path" ]]; then
+        echo "Error: Fixture directory not found: $fixture_path"
+        return 1
+    fi
+
+    echo "Regenerating: $fixture"
+
+    # Remove existing generated directory
+    rm -rf "$fixture_path/generated"
+
+    # Run graph codegen
+    pushd "$fixture_path" > /dev/null
+    if $GRAPH_CMD codegen --skip-migrations 2>/dev/null; then
+        echo "  OK"
+    else
+        echo "  FAILED (this may be expected for invalid fixtures)"
+    fi
+    popd > /dev/null
+}
+
+if [[ $# -gt 0 ]]; then
+    # Regenerate specific fixture(s)
+    for fixture in "$@"; do
+        regenerate_fixture "$fixture"
+    done
+else
+    # Regenerate all fixtures
+    echo "Regenerating all codegen fixtures..."
+    echo ""
+    for fixture in "${FIXTURES[@]}"; do
+        regenerate_fixture "$fixture"
+    done
+    echo ""
+    echo "Done! Review changes with: git diff gnd/tests/fixtures/"
+fi
diff --git a/gnd/tests/gnd_test.rs b/gnd/tests/gnd_test.rs
new file mode 100644
index 00000000000..74f9d4ce522
--- /dev/null
+++ b/gnd/tests/gnd_test.rs
@@ -0,0 +1,276 @@
+//! Integration tests for `gnd test` — the mock-based subgraph test runner.
+//!
+//! Each fixture under `tests/fixtures/gnd_test/` covers one focused area:
+//!
+//! - `token/`             — ERC20 event handling, eth_call mocking, dynamic templates
+//! - `blocks/`            — Block handlers (`every`, `once`, `polling` filters)
+//! - `receipts/`          — Transaction receipts (`receipt: true` handlers)
+//! - `file-data-sources/` — IPFS and Arweave file data sources
+//!
+//! # Prerequisites
+//!
+//! - Build the gnd binary: `cargo build -p gnd`
+//! - AssemblyScript compiler (`asc`) in PATH or local `node_modules/.bin`
+//! - pnpm available for dependency installation
+//!
+//! # Running
+//!
+//! ```bash
+//! just test-gnd-test
+//! ```
+//!
+//! Tests run with `--test-threads=1` to avoid races when sharing a Postgres
+//! instance via `--postgres-url` (CI). With pgtemp (default) each test gets
+//! its own isolated database, but serial execution keeps things simple.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use tempfile::TempDir;
+use walkdir::WalkDir;
+
+// ============================================================================
+// Shared helpers
+// ============================================================================
+
+fn fixtures_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join("gnd_test")
+}
+
+/// Copy a named fixture into a fresh temp directory, install pnpm dependencies,
+/// and run `gnd codegen`. Returns the temp dir handle (to keep it alive) and
+/// the path to the prepared subgraph directory.
+fn setup_fixture(name: &str) -> (TempDir, PathBuf) {
+    let temp_dir = TempDir::new().expect("Failed to create temp directory");
+    let subgraph_dir = temp_dir.path().join(name);
+    fs::create_dir_all(&subgraph_dir).unwrap();
+
+    let fixture = fixtures_root().join(name);
+    assert!(
+        fixture.exists(),
+        "Fixture '{}' not found at {}",
+        name,
+        fixture.display()
+    );
+
+    copy_dir_recursive(&fixture, &subgraph_dir).expect("Failed to copy fixture to temp directory");
+
+    let npm_output = Command::new("pnpm")
+        .arg("install")
+        .current_dir(&subgraph_dir)
+        .output()
+        .expect("Failed to run `pnpm install`. Is pnpm available?");
+
+    assert!(
+        npm_output.status.success(),
+        "pnpm install failed in fixture '{}':\nstdout: {}\nstderr: {}",
+        name,
+        String::from_utf8_lossy(&npm_output.stdout),
+        String::from_utf8_lossy(&npm_output.stderr),
+    );
+
+    verify_asc_available(&subgraph_dir);
+
+    let gnd = verify_gnd_binary();
+    let codegen_output = Command::new(&gnd)
+        .args(["codegen", "--skip-migrations"])
+        .current_dir(&subgraph_dir)
+        .output()
+        .expect("Failed to run `gnd codegen`");
+
+    assert!(
+        codegen_output.status.success(),
+        "gnd codegen failed in fixture '{}':\nstdout: {}\nstderr: {}",
+        name,
+        String::from_utf8_lossy(&codegen_output.stdout),
+        String::from_utf8_lossy(&codegen_output.stderr),
+    );
+
+    (temp_dir, subgraph_dir)
+}
+
+fn gnd_binary_path() -> PathBuf {
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    PathBuf::from(manifest_dir)
+        .parent()
+        .unwrap()
+        .join("target")
+        .join("debug")
+        .join("gnd")
+}
+
+fn verify_gnd_binary() -> PathBuf {
+    let gnd_path = gnd_binary_path();
+    assert!(
+        gnd_path.exists(),
+        "gnd binary not found at {}. Run `cargo build -p gnd` first.",
+        gnd_path.display()
+    );
+    gnd_path
+}
+
+fn verify_asc_available(subgraph_dir: &Path) {
+    assert!(
+        gnd::compiler::find_asc_binary(subgraph_dir).is_some(),
+        "asc compiler not found globally or in {}/node_modules/.bin. \
+         Install it with: npm install -g assemblyscript@0.19.23",
+        subgraph_dir.display()
+    );
+}
+
+fn copy_dir_recursive(src: &Path, dst: &Path) -> std::io::Result<()> {
+    for entry in WalkDir::new(src).min_depth(1) {
+        let entry = entry?;
+        let relative_path = entry.path().strip_prefix(src).unwrap();
+        let dest_path = dst.join(relative_path);
+
+        if entry.file_type().is_dir() {
+            fs::create_dir_all(&dest_path)?;
+        } else {
+            fs::copy(entry.path(), &dest_path)?;
+        }
+    }
+    Ok(())
+}
+
+fn run_gnd_test(args: &[&str], cwd: &Path) -> std::process::Output {
+    let gnd = verify_gnd_binary();
+    let mut cmd = Command::new(&gnd);
+    cmd.arg("test");
+
+    // When a database URL is provided via env var (e.g. in CI), pass it through
+    // to skip pgtemp which may not be available.
+    if let Ok(db_url) = std::env::var("THEGRAPH_STORE_POSTGRES_DIESEL_URL") {
+        cmd.arg("--postgres-url").arg(db_url);
+    }
+
+    cmd.args(args)
+        .current_dir(cwd)
+        .output()
+        .expect("Failed to execute gnd test")
+}
+
+// ============================================================================
+// token — ERC20 events, eth_call mocking, dynamic templates
+// ============================================================================
+
+#[test]
+fn test_token_transfer() {
+    let (_temp_dir, subgraph_dir) = setup_fixture("token");
+
+    let output = run_gnd_test(&["tests/transfer.json"], &subgraph_dir);
+
+    assert!(
+        output.status.success(),
+        "gnd test failed for token fixture\nstdout: {}\nstderr: {}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+}
+
+#[test]
+fn test_templates() {
+    let (_temp_dir, subgraph_dir) = setup_fixture("token");
+
+    let output = run_gnd_test(&["tests/templates.json"], &subgraph_dir);
+
+    assert!(
+        output.status.success(),
+        "gnd test failed for token fixture\nstdout: {}\nstderr: {}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+}
+
+/// Verifies that `gnd test` exits with a non-zero code when an assertion fails.
+#[test]
+fn test_token_failing_assertion() {
+    let (_temp_dir, subgraph_dir) = setup_fixture("token");
+
+    let output = run_gnd_test(&["tests/failing.json"], &subgraph_dir);
+
+    assert!(
+        !output.status.success(),
+        "gnd test should have failed for failing.json but exited with code 0\nstdout: {}\nstderr: {}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+}
+
+// ============================================================================
+// blocks — block handlers with every/once/polling filters
+// ============================================================================
+
+#[test]
+fn test_blocks() {
+    let (_temp_dir, subgraph_dir) = setup_fixture("blocks");
+
+    let output = run_gnd_test(&["tests/blocks.json"], &subgraph_dir);
+
+    assert!(
+        output.status.success(),
+        "gnd test failed for blocks fixture\nstdout: {}\nstderr: {}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+}
+
+// ============================================================================
+// receipts — receipt: true event handlers
+// ============================================================================
+
+#[test]
+fn test_receipts() {
+    let (_temp_dir, subgraph_dir) = setup_fixture("receipts");
+
+    let output = run_gnd_test(&["tests/receipts.json"], &subgraph_dir);
+
+    assert!(
+        output.status.success(),
+        "gnd test failed for receipts fixture\nstdout: {}\nstderr: {}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+}
+
+// ============================================================================
+// file-data-sources — IPFS and Arweave file data sources
+// ============================================================================
+
+/// Verifies that an event handler can spawn a `file/ipfs` data source, the mock
+/// IPFS client serves the pre-loaded content, and the file handler writes an
+/// entity whose content matches the mocked bytes.
+#[test]
+fn test_file_ipfs() {
+    let (_temp_dir, subgraph_dir) = setup_fixture("file-data-sources");
+
+    let output = run_gnd_test(&["tests/file_ipfs.json"], &subgraph_dir);
+
+    assert!(
+        output.status.success(),
+        "gnd test failed for file_ipfs.json\nstdout: {}\nstderr: {}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+}
+
+/// Verifies that an event handler can spawn a `file/arweave` data source, the
+/// mock Arweave resolver serves the pre-loaded content, and the file handler
+/// writes an entity whose content matches the mocked bytes.
+#[test]
+fn test_file_arweave() {
+    let (_temp_dir, subgraph_dir) = setup_fixture("file-data-sources");
+
+    let output = run_gnd_test(&["tests/file_arweave.json"], &subgraph_dir);
+
+    assert!(
+        output.status.success(),
+        "gnd test failed for file_arweave.json\nstdout: {}\nstderr: {}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr),
+    );
+}
diff --git a/graph/Cargo.toml b/graph/Cargo.toml
index 6e4e8e50ba9..13364f1a9fd 100644
--- a/graph/Cargo.toml
+++ b/graph/Cargo.toml
@@ -4,78 +4,108 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
+alloy = { workspace = true }
+base64 = "=0.22.1"
 anyhow = "1.0"
-async-trait = "0.1.50"
+async-trait = { workspace = true }
 async-stream = "0.3"
-atomic_refcell = "0.1.13"
-bigdecimal = { version = "0.1.0", features = ["serde"] }
+atomic_refcell = "0.1.14"
+# We require this precise version of bigdecimal. Updating to later versions
+# has caused PoI differences; if you update this version, you will need to
+# make sure that it does not cause PoI changes
+old_bigdecimal = { version = "=0.1.2", features = [
+    "serde",
+], package = "bigdecimal" }
 bytes = "1.0.1"
-cid = "0.11.0"
-defer = "0.1"
-diesel = { version = "1.4.8", features = ["postgres", "serde_json", "numeric", "r2d2", "chrono"] }
-diesel_derives = "1.4"
-chrono = "0.4.31"
-envconfig = "0.10.0"
+bs58 = { workspace = true }
+cid = "0.11.3"
+derive_more = { workspace = true, features = ["debug"] }
+graph_derive = { path = "./derive" }
+diesel = { workspace = true }
+diesel_derives = { workspace = true }
+chrono = "0.4.44"
+envconfig = { workspace = true }
 Inflector = "0.11.3"
-isatty = "0.1.9"
-reqwest = { version = "0.11.18", features = ["json", "stream", "multipart"] }
-ethabi = "17.2"
+reqwest = { version = "0.12.23", features = ["json", "stream", "multipart", "gzip", "brotli", "deflate"] }
+rustls = { workspace = true }
 hex = "0.4.3"
-http = "0.2.3"
-futures = "0.1.21"
-graphql-parser = "0.4.0"
-humantime = "2.1.0"
-lazy_static = "1.4.0"
-num-bigint = { version = "^0.2.6", features = ["serde"] }
-num_cpus = "1.16.0"
-num-traits = "=0.2.17"
-rand = "0.8.4"
-regex = "1.5.4"
-semver = { version = "1.0.21", features = ["serde"] }
-serde = { version = "1.0.126", features = ["rc"] }
-serde_derive = "1.0.125"
-serde_json = { version = "1.0", features = ["arbitrary_precision"] }
-serde_regex = "1.1.0"
-serde_yaml = "0.9.21"
-slog = { version = "2.7.0", features = ["release_max_level_trace", "max_level_trace"] }
+http0 = { version = "0", package = "http" }
+http = "1"
+hyper = { version = "1", features = ["full"] }
+http-body-util = "0.1"
+hyper-util = { version = "0.1", features = ["full"] }
+futures01 = { package = "futures", version = "0.1.31" }
+lru_time_cache = "0.11"
+graphql-tools = { workspace = true }
+lazy_static = { workspace = true }
+num-bigint = { version = "=0.2.6", features = ["serde"] }
+num-integer = { version = "=0.1.46" }
+num-traits = "=0.2.19"
+rand.workspace = true
+redis = { workspace = true }
+regex = { workspace = true }
+semver = { workspace = true }
+serde = { workspace = true }
+serde_derive = { workspace = true }
+serde_json = { workspace = true }
+serde_regex = { workspace = true }
+serde_yaml = { workspace = true }
+sha2 = "0.11.0"
+slog = { workspace = true }
+sqlparser = { workspace = true }
 # TODO: This should be reverted to the latest version once it's published
 # stable-hash_legacy = { version = "0.3.3", package = "stable-hash" }
 # stable-hash = { version = "0.4.2" }
-stable-hash = { git = "https://github.com/graphprotocol/stable-hash", branch = "main"}
-stable-hash_legacy = { git = "https://github.com/graphprotocol/stable-hash", branch = "old", package = "stable-hash", doc = false }
-strum = "0.21.0"
-strum_macros = "0.25.3"
+stable-hash = { git = "https://github.com/graphprotocol/stable-hash", rev = "70300f974e61529675aef3f20803f26a23f0e0ea" }
+stable-hash_legacy = { git = "https://github.com/graphprotocol/stable-hash", rev = "42b85d936c6b9f1b7a4b8385d2f081d5564daa69", package = "stable-hash" }
+strum_macros = "0.28.0"
 slog-async = "2.5.0"
 slog-envlogger = "2.1.0"
 slog-term = "2.7.0"
-petgraph = "0.6.4"
-tiny-keccak = "1.5.0"
-tokio = { version = "1.35.1", features = ["time", "sync", "macros", "test-util", "rt-multi-thread", "parking_lot"] }
-tokio-stream = { version = "0.1.14", features = ["sync"] }
-tokio-retry = "0.3.0"
-toml = "0.8.8"
-url = "2.5.0"
-prometheus = "0.13.3"
-priority-queue = "0.7.0"
+petgraph = "0.8.3"
+tokio = { workspace = true}
+tokio-stream = { workspace = true }
+tokio-retry = { workspace = true }
+toml = "1.1.2"
+url = { workspace = true }
+prometheus = "0.14.0"
+priority-queue = "2.7.0"
 tonic = { workspace = true }
+tonic-prost = { workspace = true }
 prost = { workspace = true }
 prost-types = { workspace = true }
 
-futures03 = { version = "0.3.1", package = "futures", features = ["compat"] }
-wasmparser = "0.78.2"
-thiserror = "1.0.25"
-parking_lot = "0.12.1"
-itertools = "0.12.0"
+futures03 = { version = "0.3.31", package = "futures", features = ["compat"] }
+wasmparser = "0.118.1"
+thiserror = { workspace = true }
+parking_lot = "0.12.5"
+portable-atomic = { version = "1.13", features = ["fallback"] }
+itertools = "0.15.0"
+defer = "0.2"
 
-# Our fork contains patches to make some fields optional for Celo and Fantom compatibility.
-# Without the "arbitrary_precision" feature, we get the error `data did not match any variant of untagged enum Response`.
-web3 = { git = "https://github.com/graphprotocol/rust-web3", branch = "graph-patches-onto-0.18", features = ["arbitrary_precision"] }
 serde_plain = "1.0.2"
+csv = "1.4.0"
+object_store = { version = "0.14.0", features = ["gcp"] }
+
+# Dependencies related to Amp subgraphs
+ahash.workspace = true
+arrow-flight.workspace = true
+arrow.workspace = true
+half.workspace = true
+indoc.workspace = true
+lazy-regex.workspace = true
+sqlparser-latest.workspace = true
+tokio-util.workspace = true
 
 [dev-dependencies]
-clap = { version = "3.2.25", features = ["derive", "env"] }
+clap.workspace = true
 maplit = "1.0.2"
-hex-literal = "0.4"
+hex-literal = "1.1"
+wiremock = "0.6.5"
+tempfile = "3.8"
 
 [build-dependencies]
-tonic-build = { workspace = true }
+tonic-prost-build = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/graph/build.rs b/graph/build.rs
index 3cc00c0dc07..184e22dc7e1 100644
--- a/graph/build.rs
+++ b/graph/build.rs
@@ -1,28 +1,14 @@
 fn main() {
     println!("cargo:rerun-if-changed=proto");
-    tonic_build::configure()
+    tonic_prost_build::configure()
         .out_dir("src/firehose")
-        .compile(
+        .compile_protos(
             &[
                 "proto/firehose.proto",
                 "proto/ethereum/transforms.proto",
                 "proto/near/transforms.proto",
-                "proto/cosmos/transforms.proto",
             ],
             &["proto"],
         )
         .expect("Failed to compile Firehose proto(s)");
-
-    tonic_build::configure()
-        .protoc_arg("--experimental_allow_proto3_optional")
-        .out_dir("src/substreams")
-        .compile(&["proto/substreams.proto"], &["proto"])
-        .expect("Failed to compile Substreams proto(s)");
-
-    tonic_build::configure()
-        .protoc_arg("--experimental_allow_proto3_optional")
-        .extern_path(".sf.substreams.v1", "crate::substreams")
-        .out_dir("src/substreams_rpc")
-        .compile(&["proto/substreams-rpc.proto"], &["proto"])
-        .expect("Failed to compile Substreams RPC proto(s)");
 }
diff --git a/graph/derive/Cargo.toml b/graph/derive/Cargo.toml
new file mode 100644
index 00000000000..405eb648a8a
--- /dev/null
+++ b/graph/derive/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "graph_derive"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+readme.workspace = true
+homepage.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { workspace = true }
+quote = "1.0"
+proc-macro2 = "1.0.106"
+
+[dev-dependencies]
+proc-macro-utils = "0.10.0"
diff --git a/graph/derive/src/lib.rs b/graph/derive/src/lib.rs
new file mode 100644
index 00000000000..8cbf79b3825
--- /dev/null
+++ b/graph/derive/src/lib.rs
@@ -0,0 +1,377 @@
+#![recursion_limit = "256"]
+
+use proc_macro::TokenStream;
+use proc_macro2::{Span, TokenStream as TokenStream2};
+use quote::quote;
+use syn::{
+    Data, DeriveInput, Fields, Generics, Ident, Index, ItemFn, TypeParamBound, parse_macro_input,
+};
+
+#[proc_macro_derive(CheapClone)]
+pub fn derive_cheap_clone(input: TokenStream) -> TokenStream {
+    impl_cheap_clone(input.into()).into()
+}
+
+fn impl_cheap_clone(input: TokenStream2) -> TokenStream2 {
+    fn constrain_generics(generics: &Generics, bound: &TypeParamBound) -> Generics {
+        let mut generics = generics.clone();
+        for ty in generics.type_params_mut() {
+            ty.bounds.push(bound.clone());
+        }
+        generics
+    }
+
+    fn cheap_clone_path() -> TokenStream2 {
+        let crate_name = std::env::var("CARGO_PKG_NAME").unwrap();
+        if crate_name == "graph" {
+            quote! { crate::cheap_clone::CheapClone }
+        } else {
+            quote! { graph::cheap_clone::CheapClone }
+        }
+    }
+
+    fn cheap_clone_body(data: Data) -> TokenStream2 {
+        match data {
+            Data::Struct(st) => match &st.fields {
+                Fields::Unit => quote! { Self  },
+                Fields::Unnamed(fields) => {
+                    let mut field_clones = Vec::new();
+                    for (num, _) in fields.unnamed.iter().enumerate() {
+                        let idx = Index::from(num);
+                        field_clones.push(quote! { self.#idx.cheap_clone() });
+                    }
+                    quote! { Self(#(#field_clones,)*) }
+                }
+                Fields::Named(fields) => {
+                    let mut field_clones = Vec::new();
+                    for field in fields.named.iter() {
+                        let ident = field.ident.as_ref().unwrap();
+                        field_clones.push(quote! { #ident: self.#ident.cheap_clone() });
+                    }
+                    quote! {
+                        Self {
+                            #(#field_clones,)*
+                        }
+                    }
+                }
+            },
+            Data::Enum(en) => {
+                let mut arms = Vec::new();
+                for variant in en.variants {
+                    let ident = variant.ident;
+                    match variant.fields {
+                        Fields::Named(fields) => {
+                            let mut idents = Vec::new();
+                            let mut clones = Vec::new();
+                            for field in fields.named {
+                                let ident = field.ident.unwrap();
+                                idents.push(ident.clone());
+                                clones.push(quote! { #ident: #ident.cheap_clone() });
+                            }
+                            arms.push(quote! {
+                                Self::#ident{#(#idents,)*} => Self::#ident{#(#clones,)*}
+                            });
+                        }
+                        Fields::Unnamed(fields) => {
+                            let num_fields = fields.unnamed.len();
+                            let idents = (0..num_fields)
+                                .map(|i| Ident::new(&format!("v{}", i), Span::call_site()))
+                                .collect::<Vec<_>>();
+                            let mut cloned = Vec::new();
+                            for ident in &idents {
+                                cloned.push(quote! { #ident.cheap_clone() });
+                            }
+                            arms.push(quote! {
+                                Self::#ident(#(#idents,)*) => Self::#ident(#(#cloned,)*)
+                            });
+                        }
+                        Fields::Unit => {
+                            arms.push(quote! { Self::#ident => Self::#ident });
+                        }
+                    }
+                }
+                quote! {
+                    match self {
+                        #(#arms,)*
+                    }
+                }
+            }
+            Data::Union(_) => {
+                panic!("Deriving CheapClone for unions is currently not supported.")
+            }
+        }
+    }
+
+    let input = match syn::parse2::<DeriveInput>(input) {
+        Ok(input) => input,
+        Err(e) => {
+            return e.to_compile_error();
+        }
+    };
+    let DeriveInput {
+        ident: name,
+        generics,
+        data,
+        ..
+    } = input;
+
+    let cheap_clone = cheap_clone_path();
+    let constrained = constrain_generics(&generics, &syn::parse_quote!(#cheap_clone));
+    let body = cheap_clone_body(data);
+
+    let expanded = quote! {
+        impl #constrained #cheap_clone for #name #generics {
+            fn cheap_clone(&self) -> Self {
+                #body
+            }
+        }
+    };
+
+    expanded
+}
+
+#[proc_macro_derive(CacheWeight)]
+pub fn derive_cache_weight(input: TokenStream) -> TokenStream {
+    // Parse the input tokens into a syntax tree
+    let DeriveInput {
+        ident,
+        generics,
+        data,
+        ..
+    } = parse_macro_input!(input as DeriveInput);
+
+    let crate_name = std::env::var("CARGO_PKG_NAME").unwrap();
+    let cache_weight = if crate_name == "graph" {
+        quote! { crate::util::cache_weight::CacheWeight }
+    } else {
+        quote! { graph::util::cache_weight::CacheWeight }
+    };
+
+    let total = Ident::new("__total_cache_weight", Span::call_site());
+    let body = match data {
+        syn::Data::Struct(st) => {
+            let mut incrs: Vec<proc_macro2::TokenStream> = Vec::new();
+            for (num, field) in st.fields.iter().enumerate() {
+                let incr = match &field.ident {
+                    Some(ident) => quote! {
+                        #total += self.#ident.indirect_weight();
+                    },
+                    None => {
+                        let idx = Index::from(num);
+                        quote! {
+                            #total += self.#idx.indirect_weight();
+                        }
+                    }
+                };
+                incrs.push(incr);
+            }
+            quote! {
+                let mut #total = 0;
+                #(#incrs)*
+                #total
+            }
+        }
+        syn::Data::Enum(en) => {
+            let mut match_arms = Vec::new();
+            for variant in en.variants.into_iter() {
+                let ident = variant.ident;
+                match variant.fields {
+                    syn::Fields::Named(fields) => {
+                        let idents: Vec<_> =
+                            fields.named.into_iter().map(|f| f.ident.unwrap()).collect();
+
+                        let mut incrs = Vec::new();
+                        for ident in &idents {
+                            incrs.push(quote! { #total += #ident.indirect_weight(); });
+                        }
+                        match_arms.push(quote! {
+                            Self::#ident{#(#idents,)*} => {
+                                #(#incrs)*
+                            }
+                        });
+                    }
+                    syn::Fields::Unnamed(fields) => {
+                        let num_fields = fields.unnamed.len();
+
+                        let idents = (0..num_fields)
+                            .map(|i| {
+                                syn::Ident::new(&format!("v{}", i), proc_macro2::Span::call_site())
+                            })
+                            .collect::<Vec<_>>();
+                        let mut incrs = Vec::new();
+                        for ident in &idents {
+                            incrs.push(quote! { #total += #ident.indirect_weight(); });
+                        }
+                        match_arms.push(quote! {
+                            Self::#ident(#(#idents,)*) => {
+                                #(#incrs)*
+                            }
+                        });
+                    }
+                    syn::Fields::Unit => {
+                        match_arms.push(quote! { Self::#ident => { /* nothing to do */ }})
+                    }
+                };
+            }
+            quote! {
+                let mut #total = 0;
+                match &self { #(#match_arms)* };
+                #total
+            }
+        }
+        syn::Data::Union(_) => {
+            panic!("Deriving CacheWeight for unions is currently not supported.")
+        }
+    };
+    // Build the output, possibly using the input
+    let expanded = quote! {
+        // The generated impl
+        impl #generics #cache_weight for #ident #generics {
+            fn indirect_weight(&self) -> usize {
+              #body
+            }
+         }
+    };
+
+    // Hand the output tokens back to the compiler
+    TokenStream::from(expanded)
+}
+
+/// A proc macro attribute similar to `tokio::test` but uses the
+/// `TEST_RUNTIME` instead of creating a new runtime for each test.
+///
+/// # Example
+///
+/// ```ignore
+/// use graph::prelude::*;
+///
+/// #[graph::test]
+/// async fn my_test() {
+///     // Test code here
+/// }
+/// ```
+///
+/// The macro transforms the async test function to use
+/// `TEST_RUNTIME.block_on()`.
+///
+/// Note that for tests in the `graph` crate itself, the macro must be used
+/// as `#[crate::test]`
+#[proc_macro_attribute]
+pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as ItemFn);
+
+    if !args.is_empty() {
+        let msg = "the `#[graph::test]` attribute does not take any arguments";
+        return syn::Error::new(Span::call_site(), msg)
+            .to_compile_error()
+            .into();
+    }
+
+    let ret = &input.sig.output;
+    let name = &input.sig.ident;
+    let body = &input.block;
+    let attrs = &input.attrs;
+    let vis = &input.vis;
+
+    if input.sig.asyncness.is_none() {
+        let msg = "the `async` keyword is missing from the function declaration";
+        return syn::Error::new_spanned(input.sig.fn_token, msg)
+            .to_compile_error()
+            .into();
+    }
+
+    let crate_name = std::env::var("CARGO_CRATE_NAME").unwrap();
+    let pkg_name = std::env::var("CARGO_PKG_NAME").unwrap();
+    let runtime = if crate_name == "graph" && pkg_name == "graph" {
+        quote! { crate::tokio::TEST_RUNTIME }
+    } else {
+        quote! { graph::TEST_RUNTIME }
+    };
+
+    let expanded = quote! {
+        #[::core::prelude::v1::test]
+        #(#attrs)*
+        #vis fn #name() #ret {
+            #runtime.block_on(async #body)
+        }
+    };
+
+    TokenStream::from(expanded)
+}
+
+#[cfg(test)]
+mod tests {
+    use proc_macro_utils::assert_expansion;
+
+    use super::impl_cheap_clone;
+
+    #[test]
+    fn cheap_clone() {
+        assert_expansion!(
+            #[derive(impl_cheap_clone)]
+            struct Empty;,
+            {
+                impl graph::cheap_clone::CheapClone for Empty {
+                    fn cheap_clone(&self) -> Self {
+                        Self
+                    }
+                }
+            }
+        );
+
+        assert_expansion!(
+            #[derive(impl_cheap_clone)]
+            struct Foo<T> {
+                a: T,
+                b: u32,
+            },
+            {
+                impl<T: graph::cheap_clone::CheapClone> graph::cheap_clone::CheapClone for Foo<T> {
+                    fn cheap_clone(&self) -> Self {
+                        Self {
+                            a: self.a.cheap_clone(),
+                            b: self.b.cheap_clone(),
+                        }
+                    }
+                }
+            }
+        );
+
+        #[rustfmt::skip]
+        assert_expansion!(
+            #[derive(impl_cheap_clone)]
+            struct Bar(u32, u32);,
+            {
+                impl graph::cheap_clone::CheapClone for Bar {
+                    fn cheap_clone(&self) -> Self {
+                        Self(self.0.cheap_clone(), self.1.cheap_clone(),)
+                    }
+                }
+            }
+        );
+
+        #[rustfmt::skip]
+        assert_expansion!(
+            #[derive(impl_cheap_clone)]
+            enum Bar {
+                A,
+                B(u32),
+                C { a: u32, b: u32 },
+            },
+            {
+                impl graph::cheap_clone::CheapClone for Bar {
+                    fn cheap_clone(&self) -> Self {
+                        match self {
+                            Self::A => Self::A,
+                            Self::B(v0,) => Self::B(v0.cheap_clone(),),
+                            Self::C { a, b, } => Self::C {
+                                a: a.cheap_clone(),
+                                b: b.cheap_clone(),
+                            },
+                        }
+                    }
+                }
+            }
+        );
+    }
+}
diff --git a/graph/examples/append_row.rs b/graph/examples/append_row.rs
new file mode 100644
index 00000000000..61509d33349
--- /dev/null
+++ b/graph/examples/append_row.rs
@@ -0,0 +1,123 @@
+use std::{collections::HashSet, sync::Arc, time::Instant};
+
+use anyhow::anyhow;
+use clap::Parser;
+use graph::{
+    components::store::write::{EntityModification, RowGroupForPerfTest as RowGroup},
+    data::{
+        store::{Id, Value},
+        subgraph::DeploymentHash,
+        value::Word,
+    },
+    schema::{EntityType, InputSchema},
+};
+use lazy_static::lazy_static;
+use rand::{Rng, rng};
+
+#[derive(Parser)]
+#[clap(
+    name = "append_row",
+    about = "Measure time it takes to append rows to a row group"
+)]
+struct Opt {
+    /// Number of repetitions of the test
+    #[clap(short, long, default_value = "5")]
+    niter: usize,
+    /// Number of rows
+    #[clap(short, long, default_value = "10000")]
+    rows: usize,
+    /// Number of blocks
+    #[clap(short, long, default_value = "300")]
+    blocks: usize,
+    /// Number of ids
+    #[clap(short, long, default_value = "500")]
+    ids: usize,
+}
+
+// A very fake schema that allows us to get the entity types we need
+const GQL: &str = r#"
+      type Thing @entity { id: ID!, count: Int! }
+      type RowGroup @entity { id: ID! }
+      type Entry @entity { id: ID! }
+    "#;
+lazy_static! {
+    static ref DEPLOYMENT: DeploymentHash = DeploymentHash::new("batchAppend").unwrap();
+    static ref SCHEMA: InputSchema = InputSchema::parse_latest(GQL, DEPLOYMENT.clone()).unwrap();
+    static ref THING_TYPE: EntityType = SCHEMA.entity_type("Thing").unwrap();
+    static ref ROW_GROUP_TYPE: EntityType = SCHEMA.entity_type("RowGroup").unwrap();
+    static ref ENTRY_TYPE: EntityType = SCHEMA.entity_type("Entry").unwrap();
+}
+
+pub fn main() -> anyhow::Result<()> {
+    let opt = Opt::parse();
+    let next_block = opt.blocks as f64 / opt.rows as f64;
+    for _ in 0..opt.niter {
+        let ids = (0..opt.ids)
+            .map(|n| Id::String(Word::from(format!("00{n}010203040506"))))
+            .collect::<Vec<_>>();
+        let mut existing: HashSet<Id> = HashSet::new();
+        let mut mods = Vec::new();
+        let mut block = 0;
+        let mut block_pos = Vec::new();
+        for _ in 0..opt.rows {
+            if rng().random_bool(next_block) {
+                block += 1;
+                block_pos.clear();
+            }
+
+            let mut attempt = 0;
+            let pos = loop {
+                if attempt > 20 {
+                    return Err(anyhow!(
+                        "Failed to find a position in 20 attempts. Increase `ids`"
+                    ));
+                }
+                attempt += 1;
+                let pos = rng().random_range(0..opt.ids);
+                if block_pos.contains(&pos) {
+                    continue;
+                }
+                block_pos.push(pos);
+                break pos;
+            };
+            let id = &ids[pos];
+            let data = vec![
+                (Word::from("id"), Value::String(id.to_string())),
+                (Word::from("count"), Value::Int(block)),
+            ];
+            let data = Arc::new(SCHEMA.make_entity(data).unwrap());
+            let md = if existing.contains(id) {
+                EntityModification::Overwrite {
+                    key: THING_TYPE.key(id.clone()),
+                    data,
+                    block,
+                    end: None,
+                }
+            } else {
+                existing.insert(id.clone());
+                EntityModification::Insert {
+                    key: THING_TYPE.key(id.clone()),
+                    data,
+                    block,
+                    end: None,
+                }
+            };
+            mods.push(md);
+        }
+        let mut group = RowGroup::new(THING_TYPE.clone());
+
+        let start = Instant::now();
+        for md in mods {
+            group.append_row(md).unwrap();
+        }
+        let elapsed = start.elapsed();
+        println!(
+            "Adding {} rows with {} ids across {} blocks took {:?}",
+            opt.rows,
+            existing.len(),
+            block,
+            elapsed
+        );
+    }
+    Ok(())
+}
diff --git a/graph/examples/stress.rs b/graph/examples/stress.rs
index 5fbfb2f82ad..253ee501e7b 100644
--- a/graph/examples/stress.rs
+++ b/graph/examples/stress.rs
@@ -1,16 +1,16 @@
 use std::alloc::{GlobalAlloc, Layout, System};
 use std::collections::{BTreeMap, HashMap};
 use std::iter::FromIterator;
-use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 use std::time::{Duration, Instant};
 
 use clap::Parser;
 use graph::data::value::{Object, Word};
 use graph::object;
-use graph::prelude::{lazy_static, q, r, BigDecimal, BigInt, QueryResult};
-use rand::SeedableRng;
-use rand::{rngs::SmallRng, Rng};
+use graph::prelude::{BigDecimal, BigInt, QueryResult, lazy_static, q, r};
+use rand::{Rng, rngs::SmallRng};
+use rand::{RngCore, SeedableRng};
 
 use graph::util::cache_weight::CacheWeight;
 use graph::util::lfu_cache::LfuCache;
@@ -48,13 +48,12 @@ static mut PRINT_SAMPLES: bool = false;
 /// number of entries divided by `NODE_FILL`, and the number of
 /// interior nodes can be determined by dividing the number of nodes
 /// at the child level by `NODE_FILL`
-
+///
 /// The other difficulty is that the structs with which `BTreeMap`
 /// represents internal and leaf nodes are not public, so we can't
 /// get their size with `std::mem::size_of`; instead, we base our
 /// estimates of their size on the current `std` code, assuming that
 /// these structs will not change
-
 mod btree {
     use std::mem;
     use std::{mem::MaybeUninit, ptr::NonNull};
@@ -167,7 +166,7 @@ impl<K: CacheWeight, V: CacheWeight> CacheWeight for MapMeasure<K, V> {
 
 unsafe impl GlobalAlloc for Counter {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        let ret = System.alloc(layout);
+        let ret = unsafe { System.alloc(layout) };
         if !ret.is_null() {
             ALLOCATED.fetch_add(layout.size(), SeqCst);
         }
@@ -175,7 +174,7 @@ unsafe impl GlobalAlloc for Counter {
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        System.dealloc(ptr, layout);
+        unsafe { System.dealloc(ptr, layout) };
         ALLOCATED.fetch_sub(layout.size(), SeqCst);
     }
 }
@@ -240,12 +239,8 @@ impl Template for BigInt {
     fn create(size: usize, rng: Option<&mut SmallRng>) -> Self {
         let f = match rng {
             Some(rng) => {
-                let mag = rng.gen_range(1..100);
-                if rng.gen_bool(0.5) {
-                    mag
-                } else {
-                    -mag
-                }
+                let mag = rng.random_range(1..100);
+                if rng.random_bool(0.5) { mag } else { -mag }
             }
             None => 1,
         };
@@ -261,17 +256,13 @@ impl Template for BigDecimal {
     fn create(size: usize, mut rng: Option<&mut SmallRng>) -> Self {
         let f = match rng.as_deref_mut() {
             Some(rng) => {
-                let mag = rng.gen_range(1i32..100);
-                if rng.gen_bool(0.5) {
-                    mag
-                } else {
-                    -mag
-                }
+                let mag = rng.random_range(1i32..100);
+                if rng.random_bool(0.5) { mag } else { -mag }
             }
             None => 1,
         };
         let exp = match rng {
-            Some(rng) => rng.gen_range(-100..=100),
+            Some(rng) => rng.random_range(-100..=100),
             None => 1,
         };
         let bi = BigInt::from(3u64).pow(size as u8).unwrap() * BigInt::from(f);
@@ -307,7 +298,7 @@ fn make_object(size: usize, mut rng: Option<&mut SmallRng>) -> Object {
     for i in 0..size {
         let kind = rng
             .as_deref_mut()
-            .map(|rng| rng.gen_range(0..modulus))
+            .map(|rng| rng.random_range(0..modulus))
             .unwrap_or(i % modulus);
 
         let value = match kind {
@@ -334,7 +325,11 @@ fn make_object(size: usize, mut rng: Option<&mut SmallRng>) -> Object {
             _ => unreachable!(),
         };
 
-        let key = rng.as_deref_mut().map(|rng| rng.gen()).unwrap_or(i) % modulus;
+        let key = rng
+            .as_deref_mut()
+            .map(|rng| rng.next_u32() as usize)
+            .unwrap_or(i)
+            % modulus;
         obj.push((Word::from(format!("val{}", key)), value));
     }
     Object::from_iter(obj)
@@ -406,7 +401,7 @@ impl ValueMap {
         for i in 0..size {
             let kind = rng
                 .as_deref_mut()
-                .map(|rng| rng.gen_range(0..modulus))
+                .map(|rng| rng.random_range(0..modulus))
                 .unwrap_or(i % modulus);
 
             let value = match kind {
@@ -431,7 +426,11 @@ impl ValueMap {
                 _ => unreachable!(),
             };
 
-            let key = rng.as_deref_mut().map(|rng| rng.gen()).unwrap_or(i) % modulus;
+            let key = rng
+                .as_deref_mut()
+                .map(|rng| rng.next_u32() as usize)
+                .unwrap_or(i)
+                % modulus;
             map.insert(format!("val{}", key), value);
         }
         MapMeasure(map)
@@ -466,7 +465,10 @@ impl UsizeMap {
     fn make_map(size: usize, mut rng: Option<&mut SmallRng>) -> Self {
         let mut map = BTreeMap::new();
         for i in 0..size {
-            let key = rng.as_deref_mut().map(|rng| rng.gen()).unwrap_or(2 * i);
+            let key = rng
+                .as_deref_mut()
+                .map(|rng| rng.next_u32() as usize)
+                .unwrap_or(2 * i);
             map.insert(key, i * 3);
         }
         MapMeasure(map)
@@ -554,16 +556,15 @@ struct Opt {
 }
 
 fn maybe_rng<'a>(opt: &'a Opt, rng: &'a mut SmallRng) -> Option<&'a mut SmallRng> {
-    if opt.seed == Some(0) {
-        None
-    } else {
-        Some(rng)
-    }
+    if opt.seed == Some(0) { None } else { Some(rng) }
 }
 
 fn stress<T: Template>(opt: &Opt) {
     let mut rng = match opt.seed {
-        None => SmallRng::from_entropy(),
+        None => {
+            let mut rng = rand::rng();
+            SmallRng::from_rng(&mut rng)
+        }
         Some(seed) => SmallRng::seed_from_u64(seed),
     };
 
@@ -624,7 +625,7 @@ fn stress<T: Template>(opt: &Opt) {
         let size = if opt.fixed || opt.obj_size == 0 {
             opt.obj_size
         } else {
-            rng.gen_range(0..opt.obj_size)
+            rng.random_range(0..opt.obj_size)
         };
         let before = ALLOCATED.load(SeqCst);
         let sample = template.sample(size, maybe_rng(opt, &mut rng));
@@ -638,7 +639,7 @@ fn stress<T: Template>(opt: &Opt) {
         cache.insert(key, Entry::from(*sample));
         // Do a few random reads from the cache
         for _attempt in 0..5 {
-            let read = rng.gen_range(0..=key);
+            let read = rng.random_range(0..=key);
             let _v = cache.get(&read);
         }
     }
@@ -675,7 +676,7 @@ fn stress<T: Template>(opt: &Opt) {
 /// memory used on the heap since we started inserting into the cache to
 /// the target `cache_size`
 pub fn main() {
-    let opt = Opt::from_args();
+    let opt = Opt::parse();
     unsafe { PRINT_SAMPLES = opt.samples }
 
     // Use different Cacheables to see how the cache manages memory with
diff --git a/graph/examples/validate.rs b/graph/examples/validate.rs
index a9991188ab9..87888ef155b 100644
--- a/graph/examples/validate.rs
+++ b/graph/examples/validate.rs
@@ -29,20 +29,52 @@
 /// ```
 use clap::Parser;
 
-use graph::data::graphql::ext::DirectiveFinder;
 use graph::data::graphql::DirectiveExt;
 use graph::data::graphql::DocumentExt;
+use graph::data::graphql::ext::DirectiveFinder;
 use graph::data::subgraph::SPEC_VERSION_1_1_0;
-use graph::prelude::s;
 use graph::prelude::DeploymentHash;
+use graph::prelude::s;
 use graph::schema::InputSchema;
-use graphql_parser::parse_schema;
 use serde::Deserialize;
+use std::alloc::GlobalAlloc;
+use std::alloc::Layout;
+use std::alloc::System;
 use std::env;
 use std::fs::File;
 use std::io::BufRead;
 use std::io::BufReader;
 use std::process::exit;
+use std::str::FromStr;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+use std::time::{Duration, Instant};
+
+use graph::anyhow::{Result, anyhow, bail};
+
+// Install an allocator that tracks allocation sizes
+
+static ALLOCATED: AtomicUsize = AtomicUsize::new(0);
+
+struct Counter;
+
+unsafe impl GlobalAlloc for Counter {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let ret = unsafe { System.alloc(layout) };
+        if !ret.is_null() {
+            ALLOCATED.fetch_add(layout.size(), SeqCst);
+        }
+        ret
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        unsafe { System.dealloc(ptr, layout) };
+        ALLOCATED.fetch_sub(layout.size(), SeqCst);
+    }
+}
+
+#[global_allocator]
+static A: Counter = Counter;
 
 pub fn usage(msg: &str) -> ! {
     println!("{}", msg);
@@ -81,6 +113,24 @@ struct Entry {
     schema: String,
 }
 
+#[derive(Clone)]
+enum RunMode {
+    Validate,
+    Size,
+}
+
+impl FromStr for RunMode {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "validate" => Ok(RunMode::Validate),
+            "size" => Ok(RunMode::Size),
+            _ => Err("Invalid mode".to_string()),
+        }
+    }
+}
+
 #[derive(Parser)]
 #[clap(
     name = "validate",
@@ -95,45 +145,155 @@ struct Opts {
     batch: bool,
     #[clap(long)]
     api: bool,
+    #[clap(
+        short, long, default_value = "validate",
+        value_parser = clap::builder::PossibleValuesParser::new(&["validate", "size"])
+    )]
+    mode: RunMode,
     /// Subgraph schemas to validate
     #[clap(required = true)]
     schemas: Vec<String>,
 }
 
-fn parse(raw: &str, name: &str, api: bool) {
-    let schema = ensure(
-        parse_schema(raw).map(|v| v.into_static()),
-        &format!("Failed to parse schema sgd{}", name),
-    );
+fn parse(raw: &str, name: &str, api: bool) -> Result<DeploymentHash> {
+    let schema = s::parse_schema(raw)
+        .map(|v| v.into_static())
+        .map_err(|e| anyhow!("Failed to parse schema sgd{name}: {e}"))?;
     let id = subgraph_id(&schema);
     let input_schema = match InputSchema::parse(&SPEC_VERSION_1_1_0, raw, id.clone()) {
         Ok(schema) => schema,
         Err(e) => {
-            println!("InputSchema: {}[{}]: {}", name, id, e);
-            return;
+            bail!("InputSchema: {}[{}]: {}", name, id, e);
         }
     };
     if api {
         let _api_schema = match input_schema.api_schema() {
             Ok(schema) => schema,
             Err(e) => {
-                println!("ApiSchema: {}[{}]: {}", name, id, e);
-                return;
+                bail!("ApiSchema: {}[{}]: {}", name, id, e);
             }
         };
     }
-    println!("Schema {}[{}]: OK", name, id);
+    Ok(id)
+}
+
+trait Runner {
+    fn run(&self, raw: &str, name: &str, api: bool);
+}
+
+struct Validator;
+
+impl Runner for Validator {
+    fn run(&self, raw: &str, name: &str, api: bool) {
+        match parse(raw, name, api) {
+            Ok(id) => {
+                println!("Schema {}[{}]: OK", name, id);
+            }
+            Err(e) => {
+                println!("Error: {}", e);
+                exit(1);
+            }
+        }
+    }
+}
+
+struct Sizes {
+    /// Size of the input schema as a string
+    text: usize,
+    /// Size of the parsed schema
+    gql: usize,
+    /// Size of the input schema
+    input: usize,
+    /// Size of the API schema
+    api: usize,
+    /// Size of the API schema as a string
+    api_text: usize,
+    /// Time to parse the schema as an input and an API schema
+    time: Duration,
+}
+
+struct Sizer {
+    first: AtomicBool,
+}
+
+impl Sizer {
+    fn size<T, F: Fn() -> Result<T>>(&self, f: F) -> Result<(usize, T)> {
+        f()?;
+        ALLOCATED.store(0, SeqCst);
+        let res = f()?;
+        let end = ALLOCATED.load(SeqCst);
+        Ok((end, res))
+    }
+
+    fn collect_sizes(&self, raw: &str, name: &str) -> Result<Sizes> {
+        // Prime possible lazy_statics etc.
+        let start = Instant::now();
+        let id = parse(raw, name, true)?;
+        let elapsed = start.elapsed();
+        let txt_size = raw.len();
+        let (gql_size, _) = self.size(|| {
+            s::parse_schema(raw)
+                .map(|v| v.into_static())
+                .map_err(Into::into)
+        })?;
+        let (input_size, input_schema) =
+            self.size(|| InputSchema::parse_latest(raw, id.clone()))?;
+        let (api_size, api) = self.size(|| input_schema.api_schema())?;
+        let api_text = api.document().to_string().len();
+        Ok(Sizes {
+            gql: gql_size,
+            text: txt_size,
+            input: input_size,
+            api: api_size,
+            api_text,
+            time: elapsed,
+        })
+    }
+}
+
+impl Runner for Sizer {
+    fn run(&self, raw: &str, name: &str, _api: bool) {
+        if self.first.swap(false, SeqCst) {
+            println!("name,raw,gql,input,api,api_text,time_ns");
+        }
+        match self.collect_sizes(raw, name) {
+            Ok(sizes) => {
+                println!(
+                    "{name},{},{},{},{},{},{}",
+                    sizes.text,
+                    sizes.gql,
+                    sizes.input,
+                    sizes.api,
+                    sizes.api_text,
+                    sizes.time.as_nanos()
+                );
+            }
+            Err(e) => {
+                eprintln!("Error: {}", e);
+                exit(1);
+            }
+        }
+    }
 }
 
 pub fn main() {
     // Allow fulltext search in schemas
-    std::env::set_var("GRAPH_ALLOW_NON_DETERMINISTIC_FULLTEXT_SEARCH", "true");
+    unsafe {
+        std::env::set_var("GRAPH_ALLOW_NON_DETERMINISTIC_FULLTEXT_SEARCH", "true");
+    }
 
     let opt = Opts::parse();
 
+    let runner: Box<dyn Runner> = match opt.mode {
+        RunMode::Validate => Box::new(Validator),
+        RunMode::Size => Box::new(Sizer {
+            first: AtomicBool::new(true),
+        }),
+    };
+
     if opt.batch {
         for schema in &opt.schemas {
-            println!("Validating schemas from {schema}");
+            eprintln!("Validating schemas from {schema}");
             let file = File::open(schema).expect("file exists");
             let rdr = BufReader::new(file);
             for line in rdr.lines() {
@@ -142,14 +302,14 @@ pub fn main() {
 
                 let raw = &entry.schema;
                 let name = format!("sgd{}", entry.id);
-                parse(raw, &name, opt.api);
+                runner.run(raw, &name, opt.api);
             }
         }
     } else {
         for schema in &opt.schemas {
-            println!("Validating schema from {schema}");
+            eprintln!("Validating schema from {schema}");
             let raw = std::fs::read_to_string(schema).expect("file exists");
-            parse(&raw, schema, opt.api);
+            runner.run(&raw, schema, opt.api);
         }
     }
 }
diff --git a/graph/proto/firehose.proto b/graph/proto/firehose.proto
index a4101a83e18..5938737e2a1 100644
--- a/graph/proto/firehose.proto
+++ b/graph/proto/firehose.proto
@@ -14,28 +14,32 @@ service Fetch {
   rpc Block(SingleBlockRequest) returns (SingleBlockResponse);
 }
 
+service EndpointInfo {
+  rpc Info(InfoRequest) returns (InfoResponse);
+}
+
 message SingleBlockRequest {
 
   // Get the current known canonical version of a block at with this number
   message BlockNumber{
-    uint64 num=1;
+    uint64 num = 1;
   }
 
   // Get the current block with specific hash and number
   message BlockHashAndNumber{
-    uint64 num=1;
-    string hash=2;
+    uint64 num = 1;
+    string hash = 2;
   }
 
   // Get the block that generated a specific cursor
   message Cursor{
-    string cursor=1;
+    string cursor = 1;
   }
 
   oneof reference{
-    BlockNumber block_number=3;
-    BlockHashAndNumber block_hash_and_number=4;
-    Cursor cursor=5;
+    BlockNumber block_number = 3;
+    BlockHashAndNumber block_hash_and_number = 4;
+    Cursor cursor = 5;
   }
 
   repeated google.protobuf.Any transforms = 6;
@@ -108,3 +112,35 @@ enum ForkStep {
   // see chain documentation for more details)
   STEP_FINAL = 3;
 }
+
+message InfoRequest {}
+
+message InfoResponse {
+  // Canonical chain name from https://thegraph.com/docs/en/developing/supported-networks/ (ex: matic, mainnet ...).
+  string chain_name = 1;
+
+  // Alternate names for the chain.
+  repeated string chain_name_aliases = 2;
+
+  // First block that is served by this endpoint.
+  // This should usually be the genesis block, but some providers may have truncated history.
+  uint64 first_streamable_block_num = 3;
+  string first_streamable_block_id = 4;
+
+  enum BlockIdEncoding {
+    BLOCK_ID_ENCODING_UNSET = 0;
+    BLOCK_ID_ENCODING_HEX = 1;
+    BLOCK_ID_ENCODING_0X_HEX = 2;
+    BLOCK_ID_ENCODING_BASE58 = 3;
+    BLOCK_ID_ENCODING_BASE64 = 4;
+    BLOCK_ID_ENCODING_BASE64URL = 5;
+  }
+
+  // This informs the client on how to decode the `block_id` field inside the `Block` message
+  // as well as the `first_streamable_block_id` above.
+  BlockIdEncoding block_id_encoding = 5;
+
+  // Features describes the blocks.
+  // Popular values for EVM chains include "base", "extended" or "hybrid".
+  repeated string block_features = 10;
+}
diff --git a/graph/proto/substreams-rpc.proto b/graph/proto/substreams-rpc.proto
deleted file mode 100644
index a0ba1b72037..00000000000
--- a/graph/proto/substreams-rpc.proto
+++ /dev/null
@@ -1,236 +0,0 @@
-syntax = "proto3";
-
-package sf.substreams.rpc.v2;
-
-import "google/protobuf/any.proto";
-import "substreams.proto";
-
-service Stream {
-  rpc Blocks(Request) returns (stream Response);
-}
-
-message Request {
-  int64 start_block_num = 1;
-  string start_cursor = 2;
-  uint64 stop_block_num = 3;
-
-  // With final_block_only, you only receive blocks that are irreversible:
-  // 'final_block_height' will be equal to current block and no 'undo_signal' will ever be sent
-  bool final_blocks_only = 4;
-
-  // Substreams has two mode when executing your module(s) either development mode or production
-  // mode. Development and production modes impact the execution of Substreams, important aspects
-  // of execution include:
-  // * The time required to reach the first byte.
-  // * The speed that large ranges get executed.
-  // * The module logs and outputs sent back to the client.
-  //
-  // By default, the engine runs in developer mode, with richer and deeper output. Differences
-  // between production and development modes include:
-  // * Forward parallel execution is enabled in production mode and disabled in development mode
-  // * The time required to reach the first byte in development mode is faster than in production mode.
-  //
-  // Specific attributes of development mode include:
-  // * The client will receive all of the executed module's logs.
-  // * It's possible to request specific store snapshots in the execution tree (via `debug_initial_store_snapshot_for_modules`).
-  // * Multiple module's output is possible.
-  //
-  // With production mode`, however, you trade off functionality for high speed enabling forward
-  // parallel execution of module ahead of time.
-  bool production_mode = 5;
-
-  string output_module = 6;
-
-  sf.substreams.v1.Modules modules = 7;
-
-  // Available only in developer mode
-  repeated string debug_initial_store_snapshot_for_modules = 10;
-}
-
-
-message Response {
-  oneof message {
-    SessionInit session = 1; // Always sent first
-    ModulesProgress progress = 2; // Progress of data preparation, before sending in the stream of `data` events.
-    BlockScopedData block_scoped_data = 3;
-    BlockUndoSignal block_undo_signal = 4;
-    Error fatal_error = 5;
-
-    // Available only in developer mode, and only if `debug_initial_store_snapshot_for_modules` is set.
-    InitialSnapshotData debug_snapshot_data = 10;
-    // Available only in developer mode, and only if `debug_initial_store_snapshot_for_modules` is set.
-    InitialSnapshotComplete debug_snapshot_complete = 11;
-  }
-}
-
-
-// BlockUndoSignal informs you that every bit of data
-// with a block number above 'last_valid_block' has been reverted
-// on-chain. Delete that data and restart from 'last_valid_cursor'
-message BlockUndoSignal {
-  sf.substreams.v1.BlockRef last_valid_block = 1;
-  string last_valid_cursor = 2;
-}
-
-message BlockScopedData {
-  MapModuleOutput output = 1;
-  sf.substreams.v1.Clock clock = 2;
-  string cursor = 3;
-
-  // Non-deterministic, allows substreams-sink to let go of their undo data.
-  uint64 final_block_height = 4;
-
-  repeated MapModuleOutput debug_map_outputs = 10;
-  repeated StoreModuleOutput debug_store_outputs = 11;
-}
-
-message SessionInit  {
-  string trace_id = 1;
-  uint64 resolved_start_block = 2;
-  uint64 linear_handoff_block = 3;
-  uint64 max_parallel_workers = 4;
-}
-
-message InitialSnapshotComplete {
-  string cursor = 1;
-}
-
-message InitialSnapshotData {
-  string module_name = 1;
-  repeated StoreDelta deltas = 2;
-  uint64 sent_keys = 4;
-  uint64 total_keys = 3;
-}
-
-message MapModuleOutput {
-  string name = 1;
-  google.protobuf.Any map_output = 2;
-  // DebugOutputInfo is available in non-production mode only
-  OutputDebugInfo debug_info = 10;
-}
-
-// StoreModuleOutput are produced for store modules in development mode.
-// It is not possible to retrieve store models in production, with parallelization
-// enabled. If you need the deltas directly, write a pass through mapper module
-// that will get them down to you.
-message StoreModuleOutput {
-  string name = 1;
-  repeated StoreDelta debug_store_deltas = 2;
-  OutputDebugInfo debug_info = 10;
-}
-
-message OutputDebugInfo {
-  repeated string logs = 1;
-  // LogsTruncated is a flag that tells you if you received all the logs or if they
-  // were truncated because you logged too much (fixed limit currently is set to 128 KiB).
-  bool logs_truncated = 2;
-  bool cached = 3;
-}
-
-// ModulesProgress is a message that is sent every 500ms
-message ModulesProgress {
-  // previously: repeated ModuleProgress modules = 1;
-  // these previous `modules` messages were sent in bursts and are not sent anymore.
-  reserved 1;
-  // List of jobs running on tier2 servers
-  repeated Job running_jobs = 2;
-  // Execution statistics for each module
-  repeated ModuleStats modules_stats = 3;
-  // Stages definition and completed block ranges
-  repeated Stage stages = 4;
-
-  ProcessedBytes processed_bytes = 5;
-}
-
-message ProcessedBytes {
-  uint64 total_bytes_read = 1;
-  uint64 total_bytes_written = 2;
-}
-
-
-message Error {
-  string module = 1;
-  string reason = 2;
-  repeated string logs = 3;
-  // FailureLogsTruncated is a flag that tells you if you received all the logs or if they
-  // were truncated because you logged too much (fixed limit currently is set to 128 KiB).
-  bool logs_truncated = 4;
-}
-
-
-message Job {
-    uint32 stage = 1;
-    uint64 start_block = 2;
-    uint64 stop_block = 3;
-    uint64 processed_blocks = 4;
-    uint64 duration_ms = 5;
-}
-
-message Stage {
-    repeated string modules = 1;
-    repeated BlockRange completed_ranges = 2;
-}
-
-// ModuleStats gathers metrics and statistics from each module, running on tier1 or tier2
-// All the 'count' and 'time_ms' values may include duplicate for each stage going over that module
-message ModuleStats {
-    // name of the module
-    string name = 1;
-
-    // total_processed_blocks is the sum of blocks sent to that module code
-    uint64 total_processed_block_count = 2;
-    // total_processing_time_ms is the sum of all time spent running that module code
-    uint64 total_processing_time_ms = 3;
-
-    //// external_calls are chain-specific intrinsics, like "Ethereum RPC calls".
-    repeated ExternalCallMetric external_call_metrics = 4;
-
-    // total_store_operation_time_ms is the sum of all time spent running that module code waiting for a store operation (ex: read, write, delete...)
-    uint64 total_store_operation_time_ms = 5;
-    // total_store_read_count is the sum of all the store Read operations called from that module code
-    uint64 total_store_read_count = 6;
-
-    // total_store_write_count is the sum of all store Write operations called from that module code (store-only)
-    uint64 total_store_write_count = 10;
-
-    // total_store_deleteprefix_count is the sum of all store DeletePrefix operations called from that module code (store-only)
-    // note that DeletePrefix can be a costly operation on large stores
-    uint64 total_store_deleteprefix_count = 11;
-
-    // store_size_bytes is the uncompressed size of the full KV store for that module, from the last 'merge' operation (store-only)
-    uint64 store_size_bytes = 12;
-
-    // total_store_merging_time_ms is the time spent merging partial stores into a full KV store for that module (store-only)
-    uint64 total_store_merging_time_ms = 13;
-
-    // store_currently_merging is true if there is a merging operation (partial store to full KV store) on the way.
-    bool store_currently_merging = 14;
-
-    // highest_contiguous_block is the highest block in the highest merged full KV store of that module (store-only)
-    uint64 highest_contiguous_block = 15;
-}
-
-message ExternalCallMetric {
-    string name = 1;
-    uint64 count = 2;
-    uint64 time_ms = 3;
-}
-
-message StoreDelta {
-  enum Operation {
-    UNSET = 0;
-    CREATE = 1;
-    UPDATE = 2;
-    DELETE = 3;
-  }
-  Operation operation = 1;
-  uint64 ordinal = 2;
-  string key = 3;
-  bytes old_value = 4;
-  bytes new_value = 5;
-}
-
-message BlockRange {
-  uint64 start_block = 2;
-  uint64 end_block = 3;
-}
diff --git a/graph/proto/substreams.proto b/graph/proto/substreams.proto
deleted file mode 100644
index a03d77c9f46..00000000000
--- a/graph/proto/substreams.proto
+++ /dev/null
@@ -1,144 +0,0 @@
-syntax = "proto3";
-
-package sf.substreams.v1;
-
-import "google/protobuf/timestamp.proto";
-import "google/protobuf/descriptor.proto";
-import "google/protobuf/any.proto";
-
-message Package {
-  // Needs to be one so this file can be used _directly_ as a
-  // buf `Image` andor a ProtoSet for grpcurl and other tools
-  repeated google.protobuf.FileDescriptorProto proto_files = 1;
-  reserved 2 to 4; // Reserved for future: in case protosets adds fields
-
-  uint64 version = 5;
-  sf.substreams.v1.Modules modules = 6;
-  repeated ModuleMetadata module_meta = 7;
-  repeated PackageMetadata package_meta = 8;
-
-  // Source network for Substreams to fetch its data from.
-  string network = 9;
-
-  google.protobuf.Any sink_config = 10;
-  string sink_module = 11;
-}
-
-message PackageMetadata {
-  string version = 1;
-  string url = 2;
-  string name = 3;
-  string doc = 4;
-}
-
-message ModuleMetadata {
-  // Corresponds to the index in `Package.metadata.package_meta`
-  uint64 package_index = 1;
-  string doc = 2;
-}
-
-message Modules {
-  repeated Module modules = 1;
-  repeated Binary binaries = 2;
-}
-
-// Binary represents some code compiled to its binary form.
-message Binary {
-  string type = 1;
-  bytes content = 2;
-}
-
-message Module {
-  string name = 1;
-  oneof kind {
-    KindMap kind_map = 2;
-    KindStore kind_store = 3;
-  };
-
-  uint32 binary_index = 4;
-  string binary_entrypoint = 5;
-
-  repeated Input inputs = 6;
-  Output output = 7;
-
-  uint64 initial_block = 8;
-
-  message KindMap {
-    string output_type = 1;
-  }
-
-  message KindStore {
-    // The `update_policy` determines the functions available to mutate the store
-    // (like `set()`, `set_if_not_exists()` or `sum()`, etc..) in
-    // order to ensure that parallel operations are possible and deterministic
-    //
-    // Say a store cumulates keys from block 0 to 1M, and a second store
-    // cumulates keys from block 1M to 2M. When we want to use this
-    // store as a dependency for a downstream module, we will merge the
-    // two stores according to this policy.
-    UpdatePolicy update_policy = 1;
-    string value_type = 2;
-
-    enum UpdatePolicy {
-      UPDATE_POLICY_UNSET = 0;
-      // Provides a store where you can `set()` keys, and the latest key wins
-      UPDATE_POLICY_SET = 1;
-      // Provides a store where you can `set_if_not_exists()` keys, and the first key wins
-      UPDATE_POLICY_SET_IF_NOT_EXISTS = 2;
-      // Provides a store where you can `add_*()` keys, where two stores merge by summing its values.
-      UPDATE_POLICY_ADD = 3;
-      // Provides a store where you can `min_*()` keys, where two stores merge by leaving the minimum value.
-      UPDATE_POLICY_MIN = 4;
-      // Provides a store where you can `max_*()` keys, where two stores merge by leaving the maximum value.
-      UPDATE_POLICY_MAX = 5;
-      // Provides a store where you can `append()` keys, where two stores merge by concatenating the bytes in order.
-      UPDATE_POLICY_APPEND = 6;
-    }
-  }
-
-  message Input {
-    oneof input {
-      Source source = 1;
-      Map map = 2;
-      Store store = 3;
-      Params params = 4;
-    }
-
-    message Source {
-      string type = 1; // ex: "sf.ethereum.type.v1.Block"
-    }
-    message Map {
-      string module_name = 1; // ex: "block_to_pairs"
-    }
-    message Store {
-      string module_name = 1;
-      Mode mode = 2;
-
-      enum Mode {
-	UNSET = 0;
-	GET = 1;
-	DELTAS = 2;
-      }
-    }
-    message Params {
-      string value = 1;
-    }
-  }
-
-  message Output {
-    string type = 1;
-  }
-}
-
-// Clock is a pointer to a block with added timestamp
-message Clock {
-  string id = 1;
-  uint64 number = 2;
-  google.protobuf.Timestamp timestamp = 3;
-}
-
-// BlockRef is a pointer to a block to which we don't know the timestamp
-message BlockRef {
-  string id = 1;
-  uint64 number = 2;
-}
diff --git a/graph/src/abi/event_ext.rs b/graph/src/abi/event_ext.rs
new file mode 100644
index 00000000000..9083f44b931
--- /dev/null
+++ b/graph/src/abi/event_ext.rs
@@ -0,0 +1,169 @@
+use std::collections::VecDeque;
+
+use alloy::json_abi::Event;
+use alloy::rpc::types::Log;
+use anyhow::Result;
+use anyhow::anyhow;
+
+use crate::abi::{DynSolParam, DynSolValue};
+
+pub trait EventExt {
+    fn decode_log(&self, log: &Log) -> Result<Vec<DynSolParam>>;
+}
+
+impl EventExt for Event {
+    fn decode_log(&self, log: &Log) -> Result<Vec<DynSolParam>> {
+        let log_data = log.data();
+        let decoded_event = alloy::dyn_abi::EventExt::decode_log(self, log_data)?;
+        let mut indexed: VecDeque<DynSolValue> = decoded_event.indexed.into();
+        let mut body: VecDeque<DynSolValue> = decoded_event.body.into();
+
+        if self.inputs.len() != indexed.len() + body.len() {
+            return Err(anyhow!(
+                "unexpected number of decoded event inputs; expected {}, got {}",
+                self.inputs.len(),
+                indexed.len() + body.len(),
+            ));
+        }
+
+        let mut decoded_params = Vec::with_capacity(self.inputs.len());
+
+        for input in &self.inputs {
+            decoded_params.push(DynSolParam {
+                name: input.name.clone(),
+                value: {
+                    if input.indexed {
+                        indexed.pop_front().unwrap()
+                    } else {
+                        body.pop_front().unwrap()
+                    }
+                },
+            });
+        }
+
+        Ok(decoded_params)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use alloy::dyn_abi::DynSolValue;
+    use alloy::primitives::{LogData, U256};
+
+    use super::*;
+
+    fn make_log(topics: &[[u8; 32]], data: Vec<u8>) -> Log {
+        Log {
+            inner: alloy::primitives::Log {
+                address: [1; 20].into(),
+                data: LogData::new_unchecked(topics.iter().map(Into::into).collect(), data.into()),
+            },
+            block_hash: None,
+            block_number: None,
+            block_timestamp: None,
+            transaction_hash: None,
+            transaction_index: None,
+            log_index: None,
+            removed: false,
+        }
+    }
+
+    #[test]
+    fn decode_log_no_topic_0() {
+        let event = Event::parse("event X(uint256 indexed a, bytes32 b)").unwrap();
+        let a = U256::from(10).to_be_bytes::<32>();
+        let b = DynSolValue::FixedBytes([10; 32].into(), 32).abi_encode();
+
+        let log = make_log(&[a], b);
+        let err = event.decode_log(&log).unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "invalid log topic list length: expected 2 topics, got 1",
+        );
+    }
+
+    #[test]
+    fn decode_log_invalid_topic_0() {
+        let event = Event::parse("event X(uint256 indexed a, bytes32 b)").unwrap();
+        let a = U256::from(10).to_be_bytes::<32>();
+        let b = DynSolValue::FixedBytes([10; 32].into(), 32).abi_encode();
+
+        let log = make_log(&[[0; 32], a], b);
+        let err = event.decode_log(&log).unwrap_err();
+
+        assert!(err.to_string().starts_with("invalid event signature:"));
+    }
+
+    #[test]
+    fn decode_log_success() {
+        let event = Event::parse("event X(uint256 indexed a, bytes32 b)").unwrap();
+        let topic_0 = event.selector().0;
+        let a = U256::from(10).to_be_bytes::<32>();
+        let b = DynSolValue::FixedBytes([10; 32].into(), 32).abi_encode();
+
+        let log = make_log(&[topic_0, a], b);
+        let resp = event.decode_log(&log).unwrap();
+
+        assert_eq!(
+            resp,
+            vec![
+                DynSolParam {
+                    name: "a".to_owned(),
+                    value: DynSolValue::Uint(U256::from(10), 256),
+                },
+                DynSolParam {
+                    name: "b".to_owned(),
+                    value: DynSolValue::FixedBytes([10; 32].into(), 32),
+                }
+            ],
+        );
+    }
+
+    #[test]
+    fn decode_log_too_many_topics() {
+        let event = Event::parse("event X(uint256 indexed a, bytes32 b)").unwrap();
+        let topic_0 = event.selector().0;
+        let a = U256::from(10).to_be_bytes::<32>();
+        let b = DynSolValue::FixedBytes([10; 32].into(), 32).abi_encode();
+
+        let log = make_log(&[topic_0, a, a, a, a], b);
+        let err = event.decode_log(&log).unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "invalid log topic list length: expected 2 topics, got 5"
+        );
+    }
+
+    #[test]
+    fn decode_log_when_indexed_param_is_not_the_first() {
+        let event = Event::parse("event X(uint256 a, uint256 indexed b, bytes32 c)").unwrap();
+        let topic_0 = event.selector().0;
+        let a = DynSolValue::Uint(U256::from(10), 32);
+        let b = U256::from(20).to_be_bytes::<32>();
+        let c = DynSolValue::FixedBytes([30; 32].into(), 32);
+        let data = DynSolValue::Tuple(vec![a, c]).abi_encode();
+
+        let log = make_log(&[topic_0, b], data);
+        let resp = event.decode_log(&log).unwrap();
+
+        assert_eq!(
+            resp,
+            vec![
+                DynSolParam {
+                    name: "a".to_owned(),
+                    value: DynSolValue::Uint(U256::from(10), 256),
+                },
+                DynSolParam {
+                    name: "b".to_owned(),
+                    value: DynSolValue::Uint(U256::from(20), 256),
+                },
+                DynSolParam {
+                    name: "c".to_owned(),
+                    value: DynSolValue::FixedBytes([30; 32].into(), 32),
+                }
+            ],
+        );
+    }
+}
diff --git a/graph/src/abi/function_ext.rs b/graph/src/abi/function_ext.rs
new file mode 100644
index 00000000000..ab17e0d9b55
--- /dev/null
+++ b/graph/src/abi/function_ext.rs
@@ -0,0 +1,303 @@
+use std::borrow::Cow;
+
+use alloy::dyn_abi::DynSolType;
+use alloy::dyn_abi::DynSolValue;
+use alloy::dyn_abi::Specifier;
+use alloy::json_abi::Function;
+use alloy::json_abi::Param;
+use anyhow::Result;
+use anyhow::anyhow;
+use itertools::Itertools;
+
+use crate::abi::DynSolValueExt;
+
+pub trait FunctionExt {
+    /// Returns the signature of this function in the following formats:
+    /// - if the function has no outputs: `$name($($inputs),*)`
+    /// - if the function has outputs: `$name($($inputs),*):($(outputs),*)`
+    ///
+    /// Examples:
+    /// - `functionName()`
+    /// - `functionName():(uint256)`
+    /// - `functionName(bool):(uint256,string)`
+    /// - `functionName(uint256,bytes32):(string,uint256)`
+    fn signature_compat(&self) -> String;
+
+    /// ABI-decodes the given data according to the function's input types.
+    fn abi_decode_input(&self, data: &[u8]) -> Result<Vec<DynSolValue>>;
+
+    /// ABI-decodes the given data according to the function's output types.
+    fn abi_decode_output(&self, data: &[u8]) -> Result<Vec<DynSolValue>>;
+
+    /// ABI-encodes the given values, prefixed by the function's selector, if any.
+    ///
+    /// This behaviour is to ensure consistency with `ethabi`.
+    fn abi_encode_input(&self, values: &[DynSolValue]) -> Result<Vec<u8>>;
+}
+
+impl FunctionExt for Function {
+    fn signature_compat(&self) -> String {
+        let name = &self.name;
+        let inputs = &self.inputs;
+        let outputs = &self.outputs;
+
+        // This is what `alloy` uses internally when creating signatures.
+        const MAX_SOL_TYPE_LEN: usize = 32;
+
+        let mut sig_cap = name.len() + 1 + inputs.len() * MAX_SOL_TYPE_LEN + 1;
+
+        if !outputs.is_empty() {
+            sig_cap = sig_cap + 2 + outputs.len() * MAX_SOL_TYPE_LEN + 1;
+        }
+
+        let mut sig = String::with_capacity(sig_cap);
+
+        sig.push_str(name);
+        signature_part(inputs, &mut sig);
+
+        if !outputs.is_empty() {
+            sig.push(':');
+            signature_part(outputs, &mut sig);
+        }
+
+        sig
+    }
+
+    fn abi_decode_input(&self, data: &[u8]) -> Result<Vec<DynSolValue>> {
+        (self as &dyn alloy::dyn_abi::FunctionExt)
+            .abi_decode_input(data)
+            .map_err(Into::into)
+    }
+
+    fn abi_decode_output(&self, data: &[u8]) -> Result<Vec<DynSolValue>> {
+        (self as &dyn alloy::dyn_abi::FunctionExt)
+            .abi_decode_output(data)
+            .map_err(Into::into)
+    }
+
+    fn abi_encode_input(&self, values: &[DynSolValue]) -> Result<Vec<u8>> {
+        let inputs = &self.inputs;
+
+        if inputs.len() != values.len() {
+            return Err(anyhow!(
+                "unexpected number of values; expected {}, got {}",
+                inputs.len(),
+                values.len(),
+            ));
+        }
+
+        let mut fixed_values = Vec::with_capacity(values.len());
+
+        for (i, input) in inputs.iter().enumerate() {
+            let ty = input.resolve()?;
+            let val = &values[i];
+
+            fixed_values.push(fix_type_size(&ty, val)?);
+        }
+
+        if fixed_values.iter().all(|x| matches!(x, Cow::Borrowed(_))) {
+            return (self as &dyn alloy::dyn_abi::JsonAbiExt)
+                .abi_encode_input(values)
+                .map_err(Into::into);
+        }
+
+        // Required because of `alloy::dyn_abi::JsonAbiExt::abi_encode_input` API;
+        let owned_fixed_values = fixed_values
+            .into_iter()
+            .map(|x| x.into_owned())
+            .collect_vec();
+
+        (self as &dyn alloy::dyn_abi::JsonAbiExt)
+            .abi_encode_input(&owned_fixed_values)
+            .map_err(Into::into)
+    }
+}
+
+// An efficient way to compute a part of the signature without new allocations.
+fn signature_part(params: &[Param], out: &mut String) {
+    out.push('(');
+
+    match params.len() {
+        0 => {}
+        1 => {
+            params[0].selector_type_raw(out);
+        }
+        _ => {
+            params[0].selector_type_raw(out);
+
+            for param in params.iter().skip(1) {
+                out.push(',');
+                param.selector_type_raw(out);
+            }
+        }
+    }
+
+    out.push(')');
+}
+
+// Alloy is stricter in type checking than `ehtabi` and requires that the decoded values have
+// exactly the same number of bits / bytes as the type used for checking.
+//
+// This is a problem because in some ASC conversions we lose the original number of bits / bytes
+// if the actual data takes less memory.
+//
+// This method fixes that in a simple but not very cheap way, by encoding the value and trying
+// to decode it again using the given type. The result fixes the number of bits / bytes in the
+// decoded values, so we can use `alloy` methods that have strict type checking internally.
+fn fix_type_size<'a>(ty: &DynSolType, val: &'a DynSolValue) -> Result<Cow<'a, DynSolValue>> {
+    if val.matches(ty) {
+        return Ok(Cow::Borrowed(val));
+    }
+
+    if !val.type_check(ty) {
+        return Err(anyhow!(
+            "invalid value type; expected '{}', got '{:?}'",
+            ty.sol_type_name(),
+            val.sol_type_name(),
+        ));
+    }
+
+    let bytes = val.abi_encode();
+    let new_val = ty.abi_decode(&bytes)?;
+
+    Ok(Cow::Owned(new_val))
+}
+
+#[cfg(test)]
+mod tests {
+    use alloy::primitives::I256;
+    use alloy::primitives::U256;
+
+    use super::*;
+
+    fn s(f: &str) -> String {
+        Function::parse(f).unwrap().signature_compat()
+    }
+
+    fn u256(u: u64) -> U256 {
+        U256::from(u)
+    }
+
+    fn i256(i: i32) -> I256 {
+        I256::try_from(i).unwrap()
+    }
+
+    #[test]
+    fn signature_compat_no_inputs_no_outputs() {
+        assert_eq!(s("x()"), "x()");
+    }
+
+    #[test]
+    fn signature_compat_one_input_no_outputs() {
+        assert_eq!(s("x(uint256 a)"), "x(uint256)");
+    }
+
+    #[test]
+    fn signature_compat_multiple_inputs_no_outputs() {
+        assert_eq!(s("x(uint256 a, bytes32 b)"), "x(uint256,bytes32)");
+    }
+
+    #[test]
+    fn signature_compat_no_inputs_one_output() {
+        assert_eq!(s("x() returns (uint256)"), "x():(uint256)");
+    }
+
+    #[test]
+    fn signature_compat_no_inputs_multiple_outputs() {
+        assert_eq!(s("x() returns (uint256, bytes32)"), "x():(uint256,bytes32)");
+    }
+
+    #[test]
+    fn signature_compat_multiple_inputs_multiple_outputs() {
+        assert_eq!(
+            s("x(bytes32 a, uint256 b) returns (uint256, bytes32)"),
+            "x(bytes32,uint256):(uint256,bytes32)",
+        );
+    }
+
+    #[test]
+    fn abi_decode_input() {
+        use DynSolValue::{Int, Tuple, Uint};
+
+        let f = Function::parse("x(uint256 a, int256 b)").unwrap();
+        let data = Tuple(vec![Uint(u256(10), 256), Int(i256(-10), 256)]).abi_encode_params();
+        let inputs = f.abi_decode_input(&data).unwrap();
+
+        assert_eq!(inputs, vec![Uint(u256(10), 256), Int(i256(-10), 256)]);
+    }
+
+    #[test]
+    fn abi_decode_output() {
+        use DynSolValue::{Int, Tuple, Uint};
+
+        let f = Function::parse("x() returns (uint256 a, int256 b)").unwrap();
+        let data = Tuple(vec![Uint(u256(10), 256), Int(i256(-10), 256)]).abi_encode_params();
+        let outputs = f.abi_decode_output(&data).unwrap();
+
+        assert_eq!(outputs, vec![Uint(u256(10), 256), Int(i256(-10), 256)]);
+    }
+
+    #[test]
+    fn abi_encode_input_no_values() {
+        let f = Function::parse("x(uint256 a, int256 b)").unwrap();
+        let err = f.abi_encode_input(&[]).unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "unexpected number of values; expected 2, got 0",
+        );
+    }
+
+    #[test]
+    fn abi_encode_input_too_many_values() {
+        use DynSolValue::Bool;
+
+        let f = Function::parse("x(uint256 a, int256 b)").unwrap();
+
+        let err = f
+            .abi_encode_input(&[Bool(true), Bool(false), Bool(true)])
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "unexpected number of values; expected 2, got 3",
+        );
+    }
+
+    #[test]
+    fn abi_encode_input_invalid_types() {
+        use DynSolValue::Bool;
+
+        let f = Function::parse("x(uint256 a, int256 b)").unwrap();
+        let err = f.abi_encode_input(&[Bool(true), Bool(false)]).unwrap_err();
+        assert!(err.to_string().starts_with("invalid value type;"));
+    }
+
+    #[test]
+    fn abi_encode_success() {
+        use DynSolValue::{Bool, Uint};
+
+        let f = Function::parse("x(uint256 a, bool b)").unwrap();
+        let a = Uint(u256(10), 256);
+        let b = Bool(true);
+
+        let data = f.abi_encode_input(&[a.clone(), b.clone()]).unwrap();
+        let inputs = f.abi_decode_input(&data[4..]).unwrap();
+
+        assert_eq!(inputs, vec![a, b]);
+    }
+
+    #[test]
+    fn abi_encode_success_with_size_fix() {
+        use DynSolValue::{Int, Uint};
+
+        let f = Function::parse("x(uint256 a, int256 b)").unwrap();
+        let a = Uint(u256(10), 32);
+        let b = Int(i256(-10), 32);
+
+        let data = f.abi_encode_input(&[a, b]).unwrap();
+        let inputs = f.abi_decode_input(&data[4..]).unwrap();
+
+        assert_eq!(inputs, vec![Uint(u256(10), 256), Int(i256(-10), 256)]);
+    }
+}
diff --git a/graph/src/abi/mod.rs b/graph/src/abi/mod.rs
new file mode 100644
index 00000000000..12c0bc8e71b
--- /dev/null
+++ b/graph/src/abi/mod.rs
@@ -0,0 +1,22 @@
+mod event_ext;
+mod function_ext;
+mod param;
+mod value_ext;
+
+pub use alloy::dyn_abi::DynSolType;
+pub use alloy::dyn_abi::DynSolValue;
+
+pub use alloy::json_abi::Event;
+pub use alloy::json_abi::EventParam;
+pub use alloy::json_abi::Function;
+pub use alloy::json_abi::JsonAbi;
+pub use alloy::json_abi::Param;
+pub use alloy::json_abi::StateMutability;
+
+pub use alloy::primitives::I256;
+pub use alloy::primitives::U256 as AlloyU256;
+
+pub use self::event_ext::EventExt;
+pub use self::function_ext::FunctionExt;
+pub use self::param::DynSolParam;
+pub use self::value_ext::DynSolValueExt;
diff --git a/graph/src/abi/param.rs b/graph/src/abi/param.rs
new file mode 100644
index 00000000000..49e0f0878ea
--- /dev/null
+++ b/graph/src/abi/param.rs
@@ -0,0 +1,7 @@
+use alloy::dyn_abi::DynSolValue;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct DynSolParam {
+    pub name: String,
+    pub value: DynSolValue,
+}
diff --git a/graph/src/abi/value_ext.rs b/graph/src/abi/value_ext.rs
new file mode 100644
index 00000000000..cf0d36006af
--- /dev/null
+++ b/graph/src/abi/value_ext.rs
@@ -0,0 +1,287 @@
+use alloy::dyn_abi::DynSolType;
+use alloy::dyn_abi::DynSolValue;
+use anyhow::Result;
+use anyhow::anyhow;
+use itertools::Itertools;
+
+pub trait DynSolValueExt {
+    /// Creates a fixed-byte decoded value from a slice.
+    ///
+    /// Fails if the source slice exceeds 32 bytes.
+    fn fixed_bytes_from_slice(s: &[u8]) -> Result<DynSolValue>;
+
+    /// Returns the decoded value as a string.
+    ///
+    /// The resulting string contains no type information.
+    fn to_string(&self) -> String;
+
+    /// Checks whether the value is of the specified type.
+    ///
+    /// For types with additional size information, returns true if the size of the value is less
+    /// than or equal to the size of the specified type.
+    #[must_use]
+    fn type_check(&self, ty: &DynSolType) -> bool;
+}
+
+impl DynSolValueExt for DynSolValue {
+    fn fixed_bytes_from_slice(s: &[u8]) -> Result<Self> {
+        let num_bytes = s.len();
+
+        if num_bytes > 32 {
+            return Err(anyhow!(
+                "input slice must contain a maximum of 32 bytes, got {num_bytes}"
+            ));
+        }
+
+        let mut bytes = [0u8; 32];
+
+        // Access: If `x` is of type `bytesI`, then `x[k]` for `0 <= k < I` returns the `k`th byte.
+        // Ref: <https://docs.soliditylang.org/en/v0.8.28/types.html#fixed-size-byte-arrays>
+        bytes[..num_bytes].copy_from_slice(s);
+
+        Ok(Self::FixedBytes(bytes.into(), num_bytes))
+    }
+
+    fn to_string(&self) -> String {
+        let s = |v: &[Self]| v.iter().map(|x| x.to_string()).collect_vec().join(",");
+
+        // Output format is taken from `ethabi`;
+        // See: <https://docs.rs/ethabi/18.0.0/ethabi/enum.Token.html#impl-Display-for-Token>
+        match self {
+            Self::Bool(v) => v.to_string(),
+            Self::Int(v, _) => format!("{v:x}"),
+            Self::Uint(v, _) => format!("{v:x}"),
+            Self::FixedBytes(v, _) => hex::encode(v),
+            Self::Address(v) => format!("{v:x}"),
+            Self::Function(v) => format!("{v:x}"),
+            Self::Bytes(v) => hex::encode(v),
+            Self::String(v) => v.to_owned(),
+            Self::Array(v) => format!("[{}]", s(v)),
+            Self::FixedArray(v) => format!("[{}]", s(v)),
+            Self::Tuple(v) => format!("({})", s(v)),
+        }
+    }
+
+    fn type_check(&self, ty: &DynSolType) -> bool {
+        match self {
+            Self::Bool(_) => *ty == DynSolType::Bool,
+            Self::Int(_, a) => {
+                if let DynSolType::Int(b) = ty {
+                    b >= a
+                } else {
+                    false
+                }
+            }
+            Self::Uint(_, a) => {
+                if let DynSolType::Uint(b) = ty {
+                    b >= a
+                } else {
+                    false
+                }
+            }
+            Self::FixedBytes(_, a) => {
+                if let DynSolType::FixedBytes(b) = ty {
+                    b >= a
+                } else {
+                    false
+                }
+            }
+            Self::Address(_) => *ty == DynSolType::Address,
+            Self::Function(_) => *ty == DynSolType::Function,
+            Self::Bytes(_) => *ty == DynSolType::Bytes,
+            Self::String(_) => *ty == DynSolType::String,
+            Self::Array(values) => {
+                if let DynSolType::Array(ty) = ty {
+                    values.iter().all(|x| x.type_check(ty))
+                } else {
+                    false
+                }
+            }
+            Self::FixedArray(values) => {
+                if let DynSolType::FixedArray(ty, size) = ty {
+                    *size == values.len() && values.iter().all(|x| x.type_check(ty))
+                } else {
+                    false
+                }
+            }
+            Self::Tuple(values) => {
+                if let DynSolType::Tuple(types) = ty {
+                    types.len() == values.len()
+                        && values
+                            .iter()
+                            .enumerate()
+                            .all(|(i, x)| x.type_check(&types[i]))
+                } else {
+                    false
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use alloy::primitives::I256;
+    use alloy::primitives::U256;
+
+    use super::*;
+
+    #[test]
+    fn fixed_bytes_from_slice_empty_slice() {
+        let val = DynSolValue::fixed_bytes_from_slice(&[]).unwrap();
+        let bytes = [0; 32];
+
+        assert_eq!(val, DynSolValue::FixedBytes(bytes.into(), 0));
+    }
+
+    #[test]
+    fn fixed_bytes_from_slice_one_byte() {
+        let val = DynSolValue::fixed_bytes_from_slice(&[10]).unwrap();
+        let mut bytes = [0; 32];
+        bytes[0] = 10;
+
+        assert_eq!(val, DynSolValue::FixedBytes(bytes.into(), 1));
+    }
+
+    #[test]
+    fn fixed_bytes_from_slice_multiple_bytes() {
+        let val = DynSolValue::fixed_bytes_from_slice(&[10, 20, 30]).unwrap();
+        let mut bytes = [0; 32];
+        bytes[0] = 10;
+        bytes[1] = 20;
+        bytes[2] = 30;
+
+        assert_eq!(val, DynSolValue::FixedBytes(bytes.into(), 3));
+    }
+
+    #[test]
+    fn fixed_bytes_from_slice_max_bytes() {
+        let val = DynSolValue::fixed_bytes_from_slice(&[10; 32]).unwrap();
+        let bytes = [10; 32];
+
+        assert_eq!(val, DynSolValue::FixedBytes(bytes.into(), 32));
+    }
+
+    #[test]
+    fn fixed_bytes_from_slice_too_many_bytes() {
+        DynSolValue::fixed_bytes_from_slice(&[10; 33]).unwrap_err();
+    }
+
+    #[test]
+    fn to_string() {
+        use DynSolValue::*;
+
+        assert_eq!(Bool(false).to_string(), "false");
+        assert_eq!(Bool(true).to_string(), "true");
+
+        assert_eq!(
+            Int(I256::try_from(-10).unwrap(), 256).to_string(),
+            "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6",
+        );
+
+        assert_eq!(Uint(U256::from(10), 256).to_string(), "a");
+
+        assert_eq!(
+            FixedBytes([10; 32].into(), 32).to_string(),
+            "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a",
+        );
+
+        assert_eq!(
+            Address([10; 20].into()).to_string(),
+            "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a",
+        );
+
+        assert_eq!(
+            Function([10; 24].into()).to_string(),
+            "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a",
+        );
+
+        assert_eq!(Bytes(vec![10, 20, 30]).to_string(), "0a141e");
+
+        assert_eq!(
+            String("one two three".to_owned()).to_string(),
+            "one two three"
+        );
+
+        assert_eq!(
+            Array(vec![String("one".to_owned()), String("two".to_owned())]).to_string(),
+            "[one,two]",
+        );
+
+        assert_eq!(
+            FixedArray(vec![String("one".to_owned()), String("two".to_owned())]).to_string(),
+            "[one,two]"
+        );
+
+        assert_eq!(
+            Tuple(vec![String("one".to_owned()), String("two".to_owned())]).to_string(),
+            "(one,two)"
+        );
+    }
+
+    #[test]
+    fn type_check() {
+        use DynSolType as T;
+        use DynSolValue::*;
+
+        assert!(Bool(true).type_check(&T::Bool));
+        assert!(!Bool(true).type_check(&T::Int(256)));
+
+        assert!(!Int(I256::try_from(-10).unwrap(), 32).type_check(&T::Int(24)));
+        assert!(Int(I256::try_from(-10).unwrap(), 32).type_check(&T::Int(32)));
+        assert!(Int(I256::try_from(-10).unwrap(), 32).type_check(&T::Int(256)));
+        assert!(!Int(I256::try_from(-10).unwrap(), 32).type_check(&T::Uint(256)));
+
+        assert!(!Uint(U256::from(10), 32).type_check(&T::Uint(24)));
+        assert!(Uint(U256::from(10), 32).type_check(&T::Uint(32)));
+        assert!(Uint(U256::from(10), 32).type_check(&T::Uint(256)));
+        assert!(!Uint(U256::from(10), 32).type_check(&T::FixedBytes(32)));
+
+        assert!(!FixedBytes([0; 32].into(), 16).type_check(&T::FixedBytes(8)));
+        assert!(FixedBytes([0; 32].into(), 16).type_check(&T::FixedBytes(16)));
+        assert!(FixedBytes([0; 32].into(), 16).type_check(&T::FixedBytes(32)));
+        assert!(!FixedBytes([0; 32].into(), 32).type_check(&T::Address));
+
+        assert!(Address([0; 20].into()).type_check(&T::Address));
+        assert!(!Address([0; 20].into()).type_check(&T::Function));
+
+        assert!(Function([0; 24].into()).type_check(&T::Function));
+        assert!(!Function([0; 24].into()).type_check(&T::Bytes));
+
+        assert!(Bytes(vec![0, 0, 0]).type_check(&T::Bytes));
+        assert!(!Bytes(vec![0, 0, 0]).type_check(&T::String));
+
+        assert!(String("".to_owned()).type_check(&T::String));
+        assert!(!String("".to_owned()).type_check(&T::Array(Box::new(T::Bool))));
+
+        assert!(Array(vec![Bool(true)]).type_check(&T::Array(Box::new(T::Bool))));
+        assert!(!Array(vec![Bool(true)]).type_check(&T::Array(Box::new(T::String))));
+        assert!(!Array(vec![Bool(true)]).type_check(&T::FixedArray(Box::new(T::Bool), 1)));
+
+        assert!(
+            !FixedArray(vec![String("".to_owned())])
+                .type_check(&T::FixedArray(Box::new(T::Bool), 1))
+        );
+        assert!(
+            !FixedArray(vec![Bool(true), Bool(false)])
+                .type_check(&T::FixedArray(Box::new(T::Bool), 1))
+        );
+        assert!(
+            FixedArray(vec![Bool(true), Bool(false)])
+                .type_check(&T::FixedArray(Box::new(T::Bool), 2))
+        );
+        assert!(
+            !FixedArray(vec![Bool(true), Bool(false)])
+                .type_check(&T::FixedArray(Box::new(T::Bool), 3))
+        );
+        assert!(
+            !FixedArray(vec![Bool(true), Bool(false)])
+                .type_check(&T::Tuple(vec![T::Bool, T::Bool]))
+        );
+
+        assert!(!Tuple(vec![Bool(true), Bool(false)]).type_check(&T::Tuple(vec![T::Bool])));
+        assert!(Tuple(vec![Bool(true), Bool(false)]).type_check(&T::Tuple(vec![T::Bool, T::Bool])));
+        assert!(!Tuple(vec![Bool(true)]).type_check(&T::Tuple(vec![T::Bool, T::Bool])));
+        assert!(!Tuple(vec![Bool(true)]).type_check(&T::Bool));
+    }
+}
diff --git a/graph/src/amp/client/flight_client.rs b/graph/src/amp/client/flight_client.rs
new file mode 100644
index 00000000000..bda2c783fd9
--- /dev/null
+++ b/graph/src/amp/client/flight_client.rs
@@ -0,0 +1,389 @@
+use std::{collections::HashMap, ops::RangeInclusive, time::Duration};
+
+use ahash::RandomState;
+use alloy::primitives::{BlockHash, BlockNumber};
+use arrow::datatypes::Schema;
+use arrow_flight::{
+    decode::DecodedPayload, error::FlightError, flight_service_client::FlightServiceClient,
+    sql::client::FlightSqlServiceClient,
+};
+use async_stream::try_stream;
+use bytes::Bytes;
+use futures03::{StreamExt, future::BoxFuture, stream::BoxStream};
+use http::Uri;
+use serde::{Deserialize, Serialize};
+use slog::{Logger, debug, trace};
+use thiserror::Error;
+use tonic::transport::{Channel, ClientTlsConfig, Endpoint};
+
+use crate::{
+    amp::{
+        client::{
+            Client, LatestBlockBeforeReorg, RequestMetadata, ResponseBatch, ResumeStreamingQuery,
+        },
+        error,
+        log::{Logger as _, one_line},
+    },
+    prelude::CheapClone,
+};
+
+/// A client for the Amp Flight gRPC service.
+///
+/// This client connects to an Amp server and executes SQL queries
+/// using the Apache Arrow Flight protocol.
+pub struct FlightClient {
+    channel: Channel,
+    auth_token: Option<String>,
+}
+
+impl FlightClient {
+    /// Creates a new Amp client connected to the specified Amp Flight service address.
+    pub async fn new(addr: Uri) -> Result<Self, Error> {
+        let is_https = addr.scheme() == Some(&http::uri::Scheme::HTTPS);
+        let mut endpoint = Endpoint::from(addr)
+            .tcp_keepalive(Some(Duration::from_secs(30)))
+            .keep_alive_while_idle(true)
+            .http2_adaptive_window(true)
+            .initial_connection_window_size(Some(32 * 1024 * 1024))
+            .initial_stream_window_size(Some(16 * 1024 * 1024))
+            .connect_timeout(Duration::from_secs(10));
+
+        if is_https {
+            let mut tls_config = ClientTlsConfig::new();
+            tls_config = tls_config.with_native_roots();
+
+            endpoint = endpoint.tls_config(tls_config).unwrap();
+        }
+
+        Ok(Self {
+            channel: endpoint.connect().await.map_err(Error::Connection)?,
+            auth_token: None,
+        })
+    }
+
+    /// Sets the authentication token for requests to the Amp server.
+    pub fn set_auth_token(&mut self, auth_token: impl Into<String>) {
+        self.auth_token = Some(auth_token.into());
+    }
+
+    fn raw_client(&self) -> FlightSqlServiceClient<Channel> {
+        let channel = self.channel.cheap_clone();
+        let client = FlightServiceClient::new(channel)
+            .max_encoding_message_size(256 * 1024 * 1024)
+            .max_decoding_message_size(256 * 1024 * 1024);
+
+        let mut client = FlightSqlServiceClient::new_from_inner(client);
+        if let Some(auth_token) = &self.auth_token {
+            client.set_token(auth_token.clone());
+        }
+
+        client
+    }
+}
+
+impl Client for FlightClient {
+    type Error = Error;
+
+    fn schema(
+        &self,
+        logger: &Logger,
+        query: impl ToString,
+    ) -> BoxFuture<'static, Result<Schema, Self::Error>> {
+        let logger = logger.component("AmpFlightClient");
+        let mut raw_client = self.raw_client();
+        let query = query.to_string();
+
+        Box::pin(async move {
+            const TXN_ID: Option<Bytes> = None;
+
+            debug!(logger, "Executing SQL query";
+                "query" => &*one_line(&query)
+            );
+
+            let flight_info = raw_client
+                .execute(query, TXN_ID)
+                .await
+                .map_err(Error::service)?;
+
+            flight_info.try_decode_schema().map_err(Error::service)
+        })
+    }
+
+    fn query(
+        &self,
+        logger: &Logger,
+        query: impl ToString,
+        request_metadata: Option<RequestMetadata>,
+    ) -> BoxStream<'static, Result<ResponseBatch, Self::Error>> {
+        let query = query.to_string();
+
+        // Generates a hash from the SQL query for log correlation.
+        // The hash allows connecting related logs without including the full SQL query in every log message.
+        // Constant seeds ensure consistent hashes for the same query.
+        let hasher = RandomState::with_seeds(0, 0, 0, 0);
+
+        let logger = logger
+            .component("AmpFlightClient")
+            .new(slog::o!("query_hash" => hasher.hash_one(&query)));
+
+        let mut raw_client = self.raw_client();
+        let mut prev_block_ranges: Vec<BlockRange> = Vec::new();
+
+        if let Some(request_metadata) = request_metadata {
+            let RequestMetadata {
+                resume_streaming_query,
+            } = request_metadata;
+
+            if let Some(resume_streaming_query) = resume_streaming_query {
+                prev_block_ranges = resume_streaming_query
+                    .iter()
+                    .cloned()
+                    .map(BlockRange::from)
+                    .collect();
+
+                let metadata = serialize_resume_streaming_query(resume_streaming_query);
+                debug!(logger, "Setting request metadata";
+                    "amp-resume" => &metadata
+                );
+
+                raw_client.set_header("amp-resume", metadata.clone());
+
+                // TODO: Remove when the Amp server updates to the latest version
+                raw_client.set_header("nozzle-resume", metadata);
+            }
+        }
+
+        try_stream! {
+            const TXN_ID: Option<Bytes> = None;
+
+            debug!(logger, "Executing SQL query";
+                "query" => &*one_line(&query)
+            );
+
+            let flight_info = raw_client
+                .execute(query, TXN_ID)
+                .await
+                .map_err(Error::service)?;
+
+            for (endpoint_index, endpoint) in flight_info.endpoint.into_iter().enumerate() {
+                let Some(ticket) = endpoint.ticket else {
+                    continue;
+                };
+
+                let mut stream = raw_client.do_get(ticket).await.map_err(Error::service)?.into_inner();
+                let mut batch_index = 0u32;
+                let mut prev_block_ranges = prev_block_ranges.clone();
+
+                while let Some(batch_result) = stream.next().await {
+                    let flight_data = batch_result.map_err(Error::Stream)?;
+                    let app_metadata = flight_data.inner.app_metadata;
+                    let payload = flight_data.payload;
+
+                    let record_batch = match payload {
+                        DecodedPayload::None => {
+                            trace!(logger, "Received empty data";
+                                "endpoint_index" => endpoint_index
+                            );
+                            continue
+                        },
+                        DecodedPayload::Schema(_) => {
+                            trace!(logger, "Received schema only";
+                                "endpoint_index" => endpoint_index
+                            );
+                            continue
+                        }
+                        DecodedPayload::RecordBatch(record_batch) => record_batch,
+                    };
+                    let block_ranges = Metadata::parse(&app_metadata)?.ranges;
+
+                    trace!(logger, "Received a new record batch";
+                        "endpoint_index" => endpoint_index,
+                        "batch_index" => batch_index,
+                        "num_rows" => record_batch.num_rows(),
+                        "memory_size_bytes" => record_batch.get_array_memory_size(),
+                        "block_ranges" => ?block_ranges
+                    );
+
+                    if let Some(reorg) = detect_reorg(&block_ranges, &prev_block_ranges) {
+                        yield ResponseBatch::Reorg(reorg);
+                    }
+
+                    yield ResponseBatch::Batch { data: record_batch };
+
+                    batch_index += 1;
+                    prev_block_ranges = block_ranges;
+                }
+
+                debug!(logger, "Query execution completed successfully";
+                    "batch_count" => batch_index
+                );
+            }
+        }
+        .boxed()
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("invalid metadata: {0:#}")]
+    InvalidMetadata(#[source] anyhow::Error),
+
+    #[error("connection failed: {0:#}")]
+    Connection(#[source] tonic::transport::Error),
+
+    #[error("service failed: {0:#}")]
+    Service(#[source] Box<dyn std::error::Error + Sync + Send>),
+
+    #[error("stream failed: {0:#}")]
+    Stream(#[source] FlightError),
+}
+
+impl Error {
+    pub fn service<T: std::error::Error + Sync + Send + 'static>(e: T) -> Self {
+        Self::Service(Box::new(e))
+    }
+}
+
+impl error::IsDeterministic for Error {
+    fn is_deterministic(&self) -> bool {
+        let msg = match self {
+            Self::InvalidMetadata(_) => return true,
+            Self::Connection(_) => return false,
+            Self::Service(e) => e.to_string(),
+            Self::Stream(_) => return false,
+        };
+
+        static DETERMINISTIC_ERROR_PATTERNS: &[&str] = &[
+            // Example SQL query: SELECT;
+            r#"code: InvalidArgument, message: ""#,
+            // Example SQL query: SELECT * FROM invalid_dataset;
+            //                    SELECT * FROM valid_dataset.invalid_table;
+            r#"code: Internal, message: "error creating planning context: "#,
+            // Example SQL query: SELECT invalid_column FROM valid_dataset.valid_table;
+            r#"code: Internal, message: "planning error: "#,
+        ];
+
+        for &pattern in DETERMINISTIC_ERROR_PATTERNS {
+            if msg.contains(pattern) {
+                return true;
+            }
+        }
+
+        false
+    }
+}
+
+/// Metadata received with every record batch.
+#[derive(Debug, Clone, Deserialize)]
+struct Metadata {
+    /// Block ranges processed by the Amp server to produce the record batch.
+    ranges: Vec<BlockRange>,
+}
+
+impl Metadata {
+    /// Parses and returns the metadata.
+    fn parse(app_metadata: &[u8]) -> Result<Self, Error> {
+        if app_metadata.is_empty() {
+            return Ok(Self { ranges: Vec::new() });
+        }
+
+        serde_json::from_slice::<Self>(app_metadata).map_err(|e| Error::InvalidMetadata(e.into()))
+    }
+}
+
+/// Block range processed by the Amp server to produce a record batch.
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+struct BlockRange {
+    /// Network that contains the source data for the dataset.
+    network: String,
+
+    /// Block numbers processed.
+    numbers: RangeInclusive<BlockNumber>,
+
+    /// Hash of the last block in the block range.
+    hash: BlockHash,
+
+    /// Hash of the parent block of the first block in the block range.
+    prev_hash: Option<BlockHash>,
+}
+
+impl BlockRange {
+    /// Returns the first block number in the range.
+    fn start(&self) -> BlockNumber {
+        *self.numbers.start()
+    }
+
+    /// Returns the last block number in the range.
+    fn end(&self) -> BlockNumber {
+        *self.numbers.end()
+    }
+}
+
+impl From<ResumeStreamingQuery> for BlockRange {
+    fn from(resume: ResumeStreamingQuery) -> Self {
+        Self {
+            network: resume.network,
+            numbers: resume.block_number..=resume.block_number,
+            hash: resume.block_hash,
+            prev_hash: None,
+        }
+    }
+}
+
+/// Serializes the information required to resume a streaming SQL query to JSON.
+fn serialize_resume_streaming_query(resume_streaming_query: Vec<ResumeStreamingQuery>) -> String {
+    #[derive(Serialize)]
+    struct Block {
+        number: BlockNumber,
+        hash: BlockHash,
+    }
+
+    let mapping: HashMap<String, Block> = resume_streaming_query
+        .into_iter()
+        .map(
+            |ResumeStreamingQuery {
+                 network,
+                 block_number: number,
+                 block_hash: hash,
+             }| { (network, Block { number, hash }) },
+        )
+        .collect();
+
+    serde_json::to_string(&mapping).unwrap()
+}
+
+/// Detects whether a reorg occurred during query execution.
+///
+/// Compares current block ranges with block ranges from the previous record batch
+/// to detect non-incremental batches. When a non-incremental batch is detected,
+/// returns the block number and hash of the parent block of the first block
+/// after reorg for every processed network.
+///
+/// Returns `None` when no reorgs are detected.
+fn detect_reorg(
+    block_ranges: &[BlockRange],
+    prev_block_ranges: &[BlockRange],
+) -> Option<Vec<LatestBlockBeforeReorg>> {
+    Some(
+        block_ranges
+            .iter()
+            .filter_map(|block_range| {
+                let prev_block_range = prev_block_ranges
+                    .iter()
+                    .find(|prev_block_range| prev_block_range.network == block_range.network)?;
+
+                if block_range != prev_block_range && block_range.start() <= prev_block_range.end()
+                {
+                    return Some(LatestBlockBeforeReorg {
+                        network: block_range.network.clone(),
+                        block_number: block_range.start().checked_sub(1),
+                        block_hash: block_range.prev_hash,
+                    });
+                }
+
+                None
+            })
+            .collect::<Vec<_>>(),
+    )
+    .filter(|v| !v.is_empty())
+}
diff --git a/graph/src/amp/client/mod.rs b/graph/src/amp/client/mod.rs
new file mode 100644
index 00000000000..34999da03fa
--- /dev/null
+++ b/graph/src/amp/client/mod.rs
@@ -0,0 +1,83 @@
+pub mod flight_client;
+
+use std::error::Error;
+
+use alloy::primitives::{BlockHash, BlockNumber};
+use arrow::{array::RecordBatch, datatypes::Schema};
+use futures03::{future::BoxFuture, stream::BoxStream};
+use slog::Logger;
+
+use crate::amp::error;
+
+/// Client for connecting to Amp core and executing SQL queries.
+pub trait Client {
+    type Error: Error + error::IsDeterministic + Send + Sync + 'static;
+
+    /// Executes a SQL query and returns the corresponding schema.
+    fn schema(
+        &self,
+        logger: &Logger,
+        query: impl ToString,
+    ) -> BoxFuture<'static, Result<Schema, Self::Error>>;
+
+    /// Executes a SQL query and streams the requested data in batches.
+    fn query(
+        &self,
+        logger: &Logger,
+        query: impl ToString,
+        request_metadata: Option<RequestMetadata>,
+    ) -> BoxStream<'static, Result<ResponseBatch, Self::Error>>;
+}
+
+/// Metadata sent to the Amp server with the SQL query.
+#[derive(Debug, Clone)]
+pub struct RequestMetadata {
+    /// Allows resuming streaming SQL queries from any block.
+    pub resume_streaming_query: Option<Vec<ResumeStreamingQuery>>,
+}
+
+/// Resumes a streaming SQL query from the specified block.
+#[derive(Debug, Clone)]
+pub struct ResumeStreamingQuery {
+    /// Network that contains the source data for the dataset.
+    pub network: String,
+
+    /// Block number after which the SQL query should resume.
+    ///
+    /// An invalid block number triggers a reorg message.
+    pub block_number: BlockNumber,
+
+    /// Block hash of the block after which the SQL query should resume.
+    ///
+    /// An invalid block hash triggers a reorg message.
+    pub block_hash: BlockHash,
+}
+
+/// Represents a batch response resulting from query execution on the Amp server.
+#[derive(Debug, Clone)]
+pub enum ResponseBatch {
+    /// Contains the batch data received from the Amp server.
+    Batch { data: RecordBatch },
+
+    /// Contains the reorg message received from the Amp server.
+    ///
+    /// It is received before the record batch that contains the data after the reorg.
+    Reorg(Vec<LatestBlockBeforeReorg>),
+}
+
+/// Represents the parent block of the first block after the reorg.
+#[derive(Debug, Clone)]
+pub struct LatestBlockBeforeReorg {
+    /// Network that contains the source data for the dataset.
+    pub network: String,
+
+    /// Block number of the parent block of the first block after the reorg.
+    ///
+    /// It is `None` when the reorg affects every block in the blockchain.
+    pub block_number: Option<BlockNumber>,
+
+    /// Block hash of the parent block of the first block after the reorg.
+    ///
+    /// It is `None` when the reorg affects every block in the blockchain.
+    pub block_hash: Option<BlockHash>,
+}
diff --git a/graph/src/amp/codec/array_decoder.rs b/graph/src/amp/codec/array_decoder.rs
new file mode 100644
index 00000000000..3c261554ff3
--- /dev/null
+++ b/graph/src/amp/codec/array_decoder.rs
@@ -0,0 +1,2084 @@
+use std::{fmt::Display, sync::LazyLock};
+
+use alloy::primitives::B256;
+use anyhow::{Result, anyhow};
+use arrow::{
+    array::{
+        Array, ArrayAccessor, BinaryArray, BinaryViewArray, BooleanArray, Decimal128Array,
+        Decimal256Array, FixedSizeBinaryArray, Float16Array, Float32Array, Float64Array, Int8Array,
+        Int16Array, Int32Array, Int64Array, LargeBinaryArray, LargeStringArray, PrimitiveArray,
+        StringArray, StringViewArray, TimestampMicrosecondArray, TimestampMillisecondArray,
+        TimestampNanosecondArray, TimestampSecondArray, UInt8Array, UInt16Array, UInt32Array,
+        UInt64Array, timezone::Tz,
+    },
+    datatypes::ArrowTemporalType,
+};
+use chrono::{DateTime, Utc};
+
+use super::decoder::Decoder;
+use crate::data::store::scalar::{BigDecimal, BigInt};
+
+/// Decodes Arrow arrays into subgraph types.
+pub struct ArrayDecoder<'a, T: 'static>(&'a T);
+
+impl<'a, T> ArrayDecoder<'a, T>
+where
+    T: Array + 'static,
+{
+    /// Creates a new Arrow array decoder.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the `array` cannot be downcasted to type `T`.
+    ///
+    /// The returned error is deterministic.
+    pub fn new(array: &'a dyn Array) -> Result<Self> {
+        Ok(Self(downcast_ref(array)?))
+    }
+}
+
+macro_rules! check_value {
+    ($self:ident, $row_index:ident) => {
+        if $row_index >= $self.0.len() {
+            return Ok(None);
+        }
+
+        if $self.0.is_null($row_index) {
+            return Ok(None);
+        }
+    };
+}
+
+impl<'a, T> ArrayDecoder<'a, T>
+where
+    &'a T: ArrayAccessor,
+{
+    fn value<V>(
+        &'a self,
+        row_index: usize,
+        mapping: impl FnOnce(<&'a T as ArrayAccessor>::Item) -> Result<V>,
+    ) -> Result<Option<V>> {
+        check_value!(self, row_index);
+        mapping(self.0.value(row_index)).map(Some)
+    }
+}
+
+impl Decoder<Option<bool>> for ArrayDecoder<'_, BooleanArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<bool>> {
+        self.value(row_index, Ok)
+    }
+}
+
+impl Decoder<Option<i32>> for ArrayDecoder<'_, Int8Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i32>> {
+        self.value(row_index, decode_i32)
+    }
+}
+
+impl Decoder<Option<i64>> for ArrayDecoder<'_, Int8Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i64>> {
+        self.value(row_index, decode_i64)
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, Int8Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |x| decode_signed_big_int(x.to_le_bytes()))
+    }
+}
+
+impl Decoder<Option<i32>> for ArrayDecoder<'_, Int16Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i32>> {
+        self.value(row_index, decode_i32)
+    }
+}
+
+impl Decoder<Option<i64>> for ArrayDecoder<'_, Int16Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i64>> {
+        self.value(row_index, decode_i64)
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, Int16Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |x| decode_signed_big_int(x.to_le_bytes()))
+    }
+}
+
+impl Decoder<Option<i32>> for ArrayDecoder<'_, Int32Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i32>> {
+        self.value(row_index, decode_i32)
+    }
+}
+
+impl Decoder<Option<i64>> for ArrayDecoder<'_, Int32Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i64>> {
+        self.value(row_index, decode_i64)
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, Int32Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |x| decode_signed_big_int(x.to_le_bytes()))
+    }
+}
+
+impl Decoder<Option<i32>> for ArrayDecoder<'_, Int64Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i32>> {
+        self.value(row_index, decode_i32)
+    }
+}
+
+impl Decoder<Option<i64>> for ArrayDecoder<'_, Int64Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i64>> {
+        self.value(row_index, decode_i64)
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, Int64Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |x| decode_signed_big_int(x.to_le_bytes()))
+    }
+}
+
+impl Decoder<Option<i32>> for ArrayDecoder<'_, UInt8Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i32>> {
+        self.value(row_index, decode_i32)
+    }
+}
+
+impl Decoder<Option<i64>> for ArrayDecoder<'_, UInt8Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i64>> {
+        self.value(row_index, decode_i64)
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, UInt8Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |x| decode_unsigned_big_int(x.to_le_bytes()))
+    }
+}
+
+impl Decoder<Option<i32>> for ArrayDecoder<'_, UInt16Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i32>> {
+        self.value(row_index, decode_i32)
+    }
+}
+
+impl Decoder<Option<i64>> for ArrayDecoder<'_, UInt16Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i64>> {
+        self.value(row_index, decode_i64)
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, UInt16Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |x| decode_unsigned_big_int(x.to_le_bytes()))
+    }
+}
+
+impl Decoder<Option<i32>> for ArrayDecoder<'_, UInt32Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i32>> {
+        self.value(row_index, decode_i32)
+    }
+}
+
+impl Decoder<Option<i64>> for ArrayDecoder<'_, UInt32Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i64>> {
+        self.value(row_index, decode_i64)
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, UInt32Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |x| decode_unsigned_big_int(x.to_le_bytes()))
+    }
+}
+
+impl Decoder<Option<i32>> for ArrayDecoder<'_, UInt64Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i32>> {
+        self.value(row_index, decode_i32)
+    }
+}
+
+impl Decoder<Option<i64>> for ArrayDecoder<'_, UInt64Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i64>> {
+        self.value(row_index, decode_i64)
+    }
+}
+
+impl Decoder<Option<u64>> for ArrayDecoder<'_, UInt64Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<u64>> {
+        self.value(row_index, Ok)
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, UInt64Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |x| decode_unsigned_big_int(x.to_le_bytes()))
+    }
+}
+
+impl Decoder<Option<BigDecimal>> for ArrayDecoder<'_, Float16Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigDecimal>> {
+        self.value(row_index, |value| Ok(value.to_f32().into()))
+    }
+}
+
+impl Decoder<Option<BigDecimal>> for ArrayDecoder<'_, Float32Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigDecimal>> {
+        self.value(row_index, |value| Ok(value.into()))
+    }
+}
+
+impl Decoder<Option<BigDecimal>> for ArrayDecoder<'_, Float64Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigDecimal>> {
+        self.value(row_index, |value| Ok(value.into()))
+    }
+}
+
+impl Decoder<Option<i32>> for ArrayDecoder<'_, Decimal128Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i32>> {
+        if self.0.scale() != 0 {
+            return Err(anyhow!("cannot decode `i32` from a decimal value"));
+        }
+
+        self.value(row_index, decode_i32)
+    }
+}
+
+impl Decoder<Option<i64>> for ArrayDecoder<'_, Decimal128Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i64>> {
+        if self.0.scale() != 0 {
+            return Err(anyhow!("cannot decode `i64` from a decimal value"));
+        }
+
+        self.value(row_index, decode_i64)
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, Decimal128Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        if self.0.scale() != 0 {
+            return Err(anyhow!("cannot decode `BigInt` from a decimal value"));
+        }
+
+        self.value(row_index, |x| decode_signed_big_int(x.to_le_bytes()))
+    }
+}
+
+impl Decoder<Option<BigDecimal>> for ArrayDecoder<'_, Decimal128Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigDecimal>> {
+        self.value(row_index, |x| {
+            let scale = self.0.scale() as i64;
+            let big_int = decode_signed_big_int(x.to_le_bytes())?;
+
+            Ok(BigDecimal::new(big_int, -scale))
+        })
+    }
+}
+
+impl Decoder<Option<i32>> for ArrayDecoder<'_, Decimal256Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i32>> {
+        if self.0.scale() != 0 {
+            return Err(anyhow!("cannot decode `i32` from a decimal value"));
+        }
+
+        self.value(row_index, |value| {
+            let value = value
+                .to_i128()
+                .ok_or_else(|| anyhow!("cannot decode `i32` from a larger `i256` value"))?;
+
+            decode_i32(value)
+        })
+    }
+}
+
+impl Decoder<Option<i64>> for ArrayDecoder<'_, Decimal256Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<i64>> {
+        if self.0.scale() != 0 {
+            return Err(anyhow!("cannot decode `i64` from a decimal value"));
+        }
+
+        self.value(row_index, |value| {
+            let value = value
+                .to_i128()
+                .ok_or_else(|| anyhow!("cannot decode `i64` from a larger `i256` value"))?;
+
+            decode_i64(value)
+        })
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, Decimal256Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        if self.0.scale() != 0 {
+            return Err(anyhow!("cannot decode `BigInt` from a decimal value"));
+        }
+
+        self.value(row_index, |x| decode_signed_big_int(x.to_le_bytes()))
+    }
+}
+
+impl Decoder<Option<BigDecimal>> for ArrayDecoder<'_, Decimal256Array> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigDecimal>> {
+        self.value(row_index, |x| {
+            let scale = self.0.scale() as i64;
+            let big_int = decode_signed_big_int(x.to_le_bytes())?;
+
+            Ok(BigDecimal::new(big_int, -scale))
+        })
+    }
+}
+
+impl Decoder<Option<String>> for ArrayDecoder<'_, StringArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<String>> {
+        self.value(row_index, |x| Ok(x.to_string()))
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, StringArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |value| {
+            value
+                .parse()
+                .map_err(|_| anyhow!("failed to parse `BigInt` from a non-numeric string value"))
+        })
+    }
+}
+
+impl Decoder<Option<BigDecimal>> for ArrayDecoder<'_, StringArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigDecimal>> {
+        self.value(row_index, |value| {
+            value.parse().map_err(|_| {
+                anyhow!("failed to parse `BigDecimal` from a non-numeric string value")
+            })
+        })
+    }
+}
+
+impl Decoder<Option<String>> for ArrayDecoder<'_, StringViewArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<String>> {
+        self.value(row_index, |x| Ok(x.to_string()))
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, StringViewArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |value| {
+            value
+                .parse()
+                .map_err(|_| anyhow!("failed to parse `BigInt` from a non-numeric string value"))
+        })
+    }
+}
+
+impl Decoder<Option<BigDecimal>> for ArrayDecoder<'_, StringViewArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigDecimal>> {
+        self.value(row_index, |value| {
+            value.parse().map_err(|_| {
+                anyhow!("failed to parse `BigDecimal` from a non-numeric string value")
+            })
+        })
+    }
+}
+
+impl Decoder<Option<String>> for ArrayDecoder<'_, LargeStringArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<String>> {
+        self.value(row_index, |x| Ok(x.to_string()))
+    }
+}
+
+impl Decoder<Option<BigInt>> for ArrayDecoder<'_, LargeStringArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigInt>> {
+        self.value(row_index, |value| {
+            value
+                .parse()
+                .map_err(|_| anyhow!("failed to parse `BigInt` from a non-numeric string value"))
+        })
+    }
+}
+
+impl Decoder<Option<BigDecimal>> for ArrayDecoder<'_, LargeStringArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<BigDecimal>> {
+        self.value(row_index, |value| {
+            value.parse().map_err(|_| {
+                anyhow!("failed to parse `BigDecimal` from a non-numeric string value")
+            })
+        })
+    }
+}
+
+impl Decoder<Option<Box<[u8]>>> for ArrayDecoder<'_, BinaryArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<Box<[u8]>>> {
+        self.value(row_index, |x| Ok(x.into()))
+    }
+}
+
+impl Decoder<Option<Box<[u8]>>> for ArrayDecoder<'_, BinaryViewArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<Box<[u8]>>> {
+        self.value(row_index, |x| Ok(x.into()))
+    }
+}
+
+impl Decoder<Option<Box<[u8]>>> for ArrayDecoder<'_, FixedSizeBinaryArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<Box<[u8]>>> {
+        self.value(row_index, |x| Ok(x.into()))
+    }
+}
+
+impl Decoder<Option<B256>> for ArrayDecoder<'_, FixedSizeBinaryArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<B256>> {
+        self.value(row_index, |x| {
+            B256::try_from(x)
+                .map_err(|_| anyhow!("failed to convert '{}' to 'B256'", hex::encode(x)))
+        })
+    }
+}
+
+impl Decoder<Option<Box<[u8]>>> for ArrayDecoder<'_, LargeBinaryArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<Box<[u8]>>> {
+        self.value(row_index, |x| Ok(x.into()))
+    }
+}
+
+impl Decoder<Option<DateTime<Utc>>> for ArrayDecoder<'_, TimestampSecondArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<DateTime<Utc>>> {
+        check_value!(self, row_index);
+        decode_timestamp(self.0, row_index).map(Some)
+    }
+}
+
+impl Decoder<Option<DateTime<Utc>>> for ArrayDecoder<'_, TimestampMillisecondArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<DateTime<Utc>>> {
+        check_value!(self, row_index);
+        decode_timestamp(self.0, row_index).map(Some)
+    }
+}
+
+impl Decoder<Option<DateTime<Utc>>> for ArrayDecoder<'_, TimestampMicrosecondArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<DateTime<Utc>>> {
+        check_value!(self, row_index);
+        decode_timestamp(self.0, row_index).map(Some)
+    }
+}
+
+impl Decoder<Option<DateTime<Utc>>> for ArrayDecoder<'_, TimestampNanosecondArray> {
+    fn decode(&self, row_index: usize) -> Result<Option<DateTime<Utc>>> {
+        check_value!(self, row_index);
+        decode_timestamp(self.0, row_index).map(Some)
+    }
+}
+
+fn downcast_ref<T>(array: &dyn Array) -> Result<&T>
+where
+    T: Array + 'static,
+{
+    array
+        .as_any()
+        .downcast_ref()
+        .ok_or_else(|| anyhow!("failed to downcast array"))
+}
+
+fn decode_i32<T>(n: T) -> Result<i32>
+where
+    T: TryInto<i32> + Copy + Display,
+{
+    n.try_into()
+        .map_err(|_| anyhow!("failed to convert '{n}' to 'i32'"))
+}
+
+fn decode_i64<T>(n: T) -> Result<i64>
+where
+    T: TryInto<i64> + Copy + Display,
+{
+    n.try_into()
+        .map_err(|_| anyhow!("failed to convert '{n}' to 'i64'"))
+}
+
+fn decode_signed_big_int(le_bytes: impl AsRef<[u8]>) -> Result<BigInt> {
+    let le_bytes = le_bytes.as_ref();
+
+    BigInt::from_signed_bytes_le(le_bytes)
+        .map_err(|_| anyhow!("failed to convert '{}' to 'BigInt'", hex::encode(le_bytes)))
+}
+
+fn decode_unsigned_big_int(le_bytes: impl AsRef<[u8]>) -> Result<BigInt> {
+    let le_bytes = le_bytes.as_ref();
+
+    BigInt::from_unsigned_bytes_le(le_bytes)
+        .map_err(|_| anyhow!("failed to convert '{}' to 'BigInt'", hex::encode(le_bytes)))
+}
+
+fn decode_timestamp<T>(array: &PrimitiveArray<T>, row_index: usize) -> Result<DateTime<Utc>>
+where
+    T: ArrowTemporalType,
+    i64: From<T::Native>,
+{
+    static UTC: LazyLock<Tz> = LazyLock::new(|| "+00:00".parse().unwrap());
+
+    let Some(timestamp) = array.value_as_datetime_with_tz(row_index, *UTC) else {
+        return Err(anyhow!("failed to decode timestamp; unknown timezone"));
+    };
+
+    Ok(timestamp.to_utc())
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow::datatypes::i256;
+    use chrono::TimeZone;
+    use half::f16;
+
+    use super::super::test_fixtures::*;
+    use super::*;
+
+    mod boolean_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, BooleanArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("boolean").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_values() {
+            let decoder = decoder::<bool>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(true));
+            assert_eq!(decoder.decode(1).unwrap(), Some(false));
+            assert_eq!(decoder.decode(2).unwrap(), Some(true));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<bool>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<UInt32Array>::new(RECORD_BATCH.column_by_name("boolean").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod int8_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Int8Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Int8Array>::new(RECORD_BATCH.column_by_name("int8").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_i32_values() {
+            let decoder = decoder::<i32>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i32));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i32));
+            assert_eq!(decoder.decode(2).unwrap(), Some(i8::MAX as i32));
+        }
+
+        #[test]
+        fn decode_valid_i64_values() {
+            let decoder = decoder::<i64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i64));
+            assert_eq!(decoder.decode(2).unwrap(), Some(i8::MAX as i64));
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigInt::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigInt::from(20)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(i8::MAX)));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<i32>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("int8").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod int16_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Int16Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Int16Array>::new(RECORD_BATCH.column_by_name("int16").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_i32_values() {
+            let decoder = decoder::<i32>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i32));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i32));
+            assert_eq!(decoder.decode(2).unwrap(), Some(i16::MAX as i32));
+        }
+
+        #[test]
+        fn decode_valid_i64_values() {
+            let decoder = decoder::<i64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i64));
+            assert_eq!(decoder.decode(2).unwrap(), Some(i16::MAX as i64));
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigInt::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigInt::from(20)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(i16::MAX)));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<i32>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("int16").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod int32_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Int32Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Int32Array>::new(RECORD_BATCH.column_by_name("int32").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_i32_values() {
+            let decoder = decoder::<i32>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i32));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i32));
+            assert_eq!(decoder.decode(2).unwrap(), Some(i32::MAX));
+        }
+
+        #[test]
+        fn decode_valid_i64_values() {
+            let decoder = decoder::<i64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i64));
+            assert_eq!(decoder.decode(2).unwrap(), Some(i32::MAX as i64));
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigInt::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigInt::from(20)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(i32::MAX)));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<i32>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("int32").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod int64_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Int64Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Int64Array>::new(RECORD_BATCH.column_by_name("int64").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_i32_values() {
+            let decoder = decoder::<i32>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i32));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i32));
+        }
+
+        #[test]
+        fn fail_to_decode_i32_values_from_larger_values() {
+            let decoder = decoder::<i32>();
+
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_i64_values() {
+            let decoder = decoder::<i64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i64));
+            assert_eq!(decoder.decode(2).unwrap(), Some(i64::MAX));
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigInt::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigInt::from(20)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(i64::MAX)));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<i32>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("int64").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod uint8_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, UInt8Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<UInt8Array>::new(RECORD_BATCH.column_by_name("uint8").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_i32_values() {
+            let decoder = decoder::<i32>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i32));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i32));
+            assert_eq!(decoder.decode(2).unwrap(), Some(u8::MAX as i32));
+        }
+
+        #[test]
+        fn decode_valid_i64_values() {
+            let decoder = decoder::<i64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i64));
+            assert_eq!(decoder.decode(2).unwrap(), Some(u8::MAX as i64));
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigInt::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigInt::from(20)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(u8::MAX)));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<i32>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("uint8").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod uint16_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, UInt16Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<UInt16Array>::new(RECORD_BATCH.column_by_name("uint16").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_i32_values() {
+            let decoder = decoder::<i32>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i32));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i32));
+            assert_eq!(decoder.decode(2).unwrap(), Some(u16::MAX as i32));
+        }
+
+        #[test]
+        fn decode_valid_i64_values() {
+            let decoder = decoder::<i64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i64));
+            assert_eq!(decoder.decode(2).unwrap(), Some(u16::MAX as i64));
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigInt::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigInt::from(20)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(u16::MAX)));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<i32>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("uint16").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod uint32_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, UInt32Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<UInt32Array>::new(RECORD_BATCH.column_by_name("uint32").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_i32_values() {
+            let decoder = decoder::<i32>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i32));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i32));
+        }
+
+        #[test]
+        fn fail_to_decode_i32_values_from_larger_values() {
+            let decoder = decoder::<i32>();
+
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_i64_values() {
+            let decoder = decoder::<i64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i64));
+            assert_eq!(decoder.decode(2).unwrap(), Some(u32::MAX as i64));
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigInt::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigInt::from(20)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(u32::MAX)));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<i32>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("uint32").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod uint64_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, UInt64Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<UInt64Array>::new(RECORD_BATCH.column_by_name("uint64").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_i32_values() {
+            let decoder = decoder::<i32>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i32));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i32));
+        }
+
+        #[test]
+        fn fail_to_decode_i32_values_from_larger_values() {
+            let decoder = decoder::<i32>();
+
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_i64_values() {
+            let decoder = decoder::<i64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i64));
+        }
+
+        #[test]
+        fn fail_to_decode_i64_values_from_larger_values() {
+            let decoder = decoder::<i64>();
+
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigInt::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigInt::from(20)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(u64::MAX)));
+        }
+
+        #[test]
+        fn decode_valid_u64_values() {
+            let decoder = decoder::<u64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10u64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20u64));
+            assert_eq!(decoder.decode(2).unwrap(), Some(u64::MAX));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<i32>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("uint64").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod float16_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Float16Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Float16Array>::new(RECORD_BATCH.column_by_name("float16").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_big_decimal_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigDecimal::from(10.0)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigDecimal::from(20.0)));
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Some(BigDecimal::from(f16::MAX.to_f32()))
+            );
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("float16").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod float32_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Float32Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Float32Array>::new(RECORD_BATCH.column_by_name("float32").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_big_decimal_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigDecimal::from(10.0)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigDecimal::from(20.0)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigDecimal::from(f32::MAX)));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("float32").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod float64_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Float64Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Float64Array>::new(RECORD_BATCH.column_by_name("float64").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_big_decimal_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigDecimal::from(10.0)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigDecimal::from(20.0)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigDecimal::from(f64::MAX)));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("float64").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod decimal128_decoder_without_scale {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Decimal128Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Decimal128Array>::new(
+                    RECORD_BATCH.column_by_name("decimal128").unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_i32_values() {
+            let decoder = decoder::<i32>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i32));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i32));
+        }
+
+        #[test]
+        fn fail_to_decode_i32_values_from_larger_values() {
+            let decoder = decoder::<i32>();
+
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_i64_values() {
+            let decoder = decoder::<i64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i64));
+        }
+
+        #[test]
+        fn fail_to_decode_i64_values_from_larger_values() {
+            let decoder = decoder::<i64>();
+
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigInt::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigInt::from(20)));
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(i128::MAX)));
+        }
+
+        #[test]
+        fn decode_valid_big_decimal_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigDecimal::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigDecimal::from(20)));
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Some(BigDecimal::from(i128::MAX))
+            );
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<i32>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("decimal128").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod decimal128_decoder_with_scale {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Decimal128Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Decimal128Array>::new(
+                    RECORD_BATCH
+                        .column_by_name("decimal128_with_scale")
+                        .unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn fail_to_decode_i32_values() {
+            let decoder = decoder::<i32>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn fail_to_decode_i64_values() {
+            let decoder = decoder::<i64>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn fail_to_decode_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_big_decimal_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Some(BigDecimal::new(10.into(), -10))
+            );
+            assert_eq!(
+                decoder.decode(1).unwrap(),
+                Some(BigDecimal::new(20.into(), -10))
+            );
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Some(BigDecimal::new(i128::MAX.into(), -10))
+            );
+        }
+    }
+
+    mod decimal256_decoder_without_scale {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Decimal256Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Decimal256Array>::new(
+                    RECORD_BATCH.column_by_name("decimal256").unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_i32_values() {
+            let decoder = decoder::<i32>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i32));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i32));
+        }
+
+        #[test]
+        fn fail_to_decode_i32_values_from_larger_values() {
+            let decoder = decoder::<i32>();
+
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_i64_values() {
+            let decoder = decoder::<i64>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(10i64));
+            assert_eq!(decoder.decode(1).unwrap(), Some(20i64));
+        }
+
+        #[test]
+        fn fail_to_decode_i64_values_from_larger_values() {
+            let decoder = decoder::<i64>();
+
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigInt::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigInt::from(20)));
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Some(BigInt::from_signed_bytes_be(&i256::MAX.to_be_bytes()).unwrap())
+            );
+        }
+
+        #[test]
+        fn decode_valid_big_decimal_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(BigDecimal::from(10)));
+            assert_eq!(decoder.decode(1).unwrap(), Some(BigDecimal::from(20)));
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Some(BigDecimal::new(
+                    BigInt::from_signed_bytes_be(&i256::MAX.to_be_bytes()).unwrap(),
+                    0
+                ))
+            );
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<i32>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("decimal256").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod decimal256_decoder_with_scale {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, Decimal256Array>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<Decimal256Array>::new(
+                    RECORD_BATCH
+                        .column_by_name("decimal256_with_scale")
+                        .unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn fail_to_decode_i32_values() {
+            let decoder = decoder::<i32>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn fail_to_decode_i64_values() {
+            let decoder = decoder::<i64>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn fail_to_decode_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_big_decimal_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Some(BigDecimal::new(10.into(), -10))
+            );
+            assert_eq!(
+                decoder.decode(1).unwrap(),
+                Some(BigDecimal::new(20.into(), -10))
+            );
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Some(BigDecimal::new(
+                    BigInt::from_signed_bytes_be(&i256::MAX.to_be_bytes()).unwrap(),
+                    -10
+                ))
+            );
+        }
+    }
+
+    mod utf8_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, StringArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<StringArray>::new(RECORD_BATCH.column_by_name("utf8").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_string_values() {
+            let decoder = decoder::<String>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some("aa".to_string()));
+            assert_eq!(decoder.decode(1).unwrap(), Some("bb".to_string()));
+            assert_eq!(decoder.decode(2).unwrap(), Some("30".to_string()));
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(30)));
+        }
+
+        #[test]
+        fn fail_to_decode_big_int_values_from_non_numeric_values() {
+            let decoder = decoder::<BigInt>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_big_decimal_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigDecimal::from(30)));
+        }
+
+        #[test]
+        fn fail_to_decode_big_decimal_values_from_non_numeric_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<String>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("utf8").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod utf8_view_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, StringViewArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<StringViewArray>::new(
+                    RECORD_BATCH.column_by_name("utf8_view").unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_string_values() {
+            let decoder = decoder::<String>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some("aa".to_string()));
+            assert_eq!(decoder.decode(1).unwrap(), Some("bb".to_string()));
+            assert_eq!(decoder.decode(2).unwrap(), Some("30".to_string()));
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(30)));
+        }
+
+        #[test]
+        fn fail_to_decode_big_int_values_from_non_numeric_values() {
+            let decoder = decoder::<BigInt>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_big_decimal_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigDecimal::from(30)));
+        }
+
+        #[test]
+        fn fail_to_decode_big_decimal_values_from_non_numeric_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<String>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("utf8_view").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod large_utf8_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, LargeStringArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<LargeStringArray>::new(
+                    RECORD_BATCH.column_by_name("large_utf8").unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_string_values() {
+            let decoder = decoder::<String>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some("aa".to_string()));
+            assert_eq!(decoder.decode(1).unwrap(), Some("bb".to_string()));
+            assert_eq!(decoder.decode(2).unwrap(), Some("30".to_string()));
+        }
+
+        #[test]
+        fn decode_valid_big_int_values() {
+            let decoder = decoder::<BigInt>();
+
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigInt::from(30)));
+        }
+
+        #[test]
+        fn fail_to_decode_big_int_values_from_non_numeric_values() {
+            let decoder = decoder::<BigInt>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+        }
+
+        #[test]
+        fn decode_valid_big_decimal_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            assert_eq!(decoder.decode(2).unwrap(), Some(BigDecimal::from(30)));
+        }
+
+        #[test]
+        fn fail_to_decode_big_decimal_values_from_non_numeric_values() {
+            let decoder = decoder::<BigDecimal>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<String>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("large_utf8").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod binary_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, BinaryArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<BinaryArray>::new(RECORD_BATCH.column_by_name("binary").unwrap())
+                    .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_binary_values() {
+            let decoder = decoder::<Box<[u8]>>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some((b"aa".as_slice()).into()));
+            assert_eq!(decoder.decode(1).unwrap(), Some((b"bb".as_slice()).into()));
+            assert_eq!(decoder.decode(2).unwrap(), Some((b"cc".as_slice()).into()));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<Box<[u8]>>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("binary").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod binary_view_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, BinaryViewArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<BinaryViewArray>::new(
+                    RECORD_BATCH.column_by_name("binary_view").unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_binary_values() {
+            let decoder = decoder::<Box<[u8]>>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some((b"aa".as_slice()).into()));
+            assert_eq!(decoder.decode(1).unwrap(), Some((b"bb".as_slice()).into()));
+            assert_eq!(decoder.decode(2).unwrap(), Some((b"cc".as_slice()).into()));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<Box<[u8]>>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("binary_view").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod fixed_size_binary_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, FixedSizeBinaryArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<FixedSizeBinaryArray>::new(
+                    RECORD_BATCH.column_by_name("fixed_size_binary").unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_binary_values() {
+            let decoder = decoder::<Box<[u8]>>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some((b"aa".as_slice()).into()));
+            assert_eq!(decoder.decode(1).unwrap(), Some((b"bb".as_slice()).into()));
+            assert_eq!(decoder.decode(2).unwrap(), Some((b"cc".as_slice()).into()));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<Box<[u8]>>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_decode_b256_values_from_invalid_binary_size() {
+            let decoder = decoder::<B256>();
+
+            decoder.decode(0).unwrap_err();
+            decoder.decode(1).unwrap_err();
+            decoder.decode(2).unwrap_err();
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(
+                RECORD_BATCH.column_by_name("fixed_size_binary").unwrap(),
+            )
+            .map(|_| ())
+            .unwrap_err();
+        }
+    }
+
+    mod fixed_size_binary_32_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, FixedSizeBinaryArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<FixedSizeBinaryArray>::new(
+                    RECORD_BATCH.column_by_name("fixed_size_binary_32").unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_b256_values() {
+            let decoder = decoder::<B256>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some(B256::from([10u8; 32])));
+            assert_eq!(decoder.decode(1).unwrap(), Some(B256::from([20u8; 32])));
+            assert_eq!(decoder.decode(2).unwrap(), Some(B256::from([30u8; 32])));
+        }
+    }
+
+    mod large_binary_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, LargeBinaryArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<LargeBinaryArray>::new(
+                    RECORD_BATCH.column_by_name("large_binary").unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_binary_values() {
+            let decoder = decoder::<Box<[u8]>>();
+
+            assert_eq!(decoder.decode(0).unwrap(), Some((b"aa".as_slice()).into()));
+            assert_eq!(decoder.decode(1).unwrap(), Some((b"bb".as_slice()).into()));
+            assert_eq!(decoder.decode(2).unwrap(), Some((b"cc".as_slice()).into()));
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<Box<[u8]>>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(RECORD_BATCH.column_by_name("large_binary").unwrap())
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod timestamp_second_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, TimestampSecondArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<TimestampSecondArray>::new(
+                    RECORD_BATCH.column_by_name("timestamp_second").unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_values() {
+            let decoder = decoder::<DateTime<Utc>>();
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap())
+            );
+            assert_eq!(
+                decoder.decode(1).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 10, 10, 10, 10, 10).unwrap())
+            );
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 12, 31, 23, 59, 59).unwrap())
+            );
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<DateTime<Utc>>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(
+                RECORD_BATCH.column_by_name("timestamp_second").unwrap(),
+            )
+            .map(|_| ())
+            .unwrap_err();
+        }
+    }
+
+    mod timestamp_millisecond_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, TimestampMillisecondArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<TimestampMillisecondArray>::new(
+                    RECORD_BATCH
+                        .column_by_name("timestamp_millisecond")
+                        .unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_values() {
+            let decoder = decoder::<DateTime<Utc>>();
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap())
+            );
+            assert_eq!(
+                decoder.decode(1).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 10, 10, 10, 10, 10).unwrap())
+            );
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 12, 31, 23, 59, 59).unwrap())
+            );
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<DateTime<Utc>>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(
+                RECORD_BATCH
+                    .column_by_name("timestamp_millisecond")
+                    .unwrap(),
+            )
+            .map(|_| ())
+            .unwrap_err();
+        }
+    }
+
+    mod timestamp_microsecond_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, TimestampMicrosecondArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<TimestampMicrosecondArray>::new(
+                    RECORD_BATCH
+                        .column_by_name("timestamp_microsecond")
+                        .unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_values() {
+            let decoder = decoder::<DateTime<Utc>>();
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap())
+            );
+            assert_eq!(
+                decoder.decode(1).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 10, 10, 10, 10, 10).unwrap())
+            );
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 12, 31, 23, 59, 59).unwrap())
+            );
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<DateTime<Utc>>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(
+                RECORD_BATCH
+                    .column_by_name("timestamp_microsecond")
+                    .unwrap(),
+            )
+            .map(|_| ())
+            .unwrap_err();
+        }
+    }
+
+    mod timestamp_nanosecond_decoder {
+        use super::*;
+
+        fn decoder<T>() -> Box<dyn Decoder<Option<T>>>
+        where
+            ArrayDecoder<'static, TimestampNanosecondArray>: Decoder<Option<T>>,
+        {
+            Box::new(
+                ArrayDecoder::<TimestampNanosecondArray>::new(
+                    RECORD_BATCH.column_by_name("timestamp_nanosecond").unwrap(),
+                )
+                .unwrap(),
+            )
+        }
+
+        #[test]
+        fn decode_valid_values() {
+            let decoder = decoder::<DateTime<Utc>>();
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap())
+            );
+            assert_eq!(
+                decoder.decode(1).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 10, 10, 10, 10, 10).unwrap())
+            );
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Some(Utc.with_ymd_and_hms(2020, 12, 31, 23, 59, 59).unwrap())
+            );
+        }
+
+        #[test]
+        fn handle_missing_values() {
+            let decoder = decoder::<DateTime<Utc>>();
+
+            assert!(decoder.decode(3).unwrap().is_none());
+            assert!(decoder.decode(4).unwrap().is_none());
+        }
+
+        #[test]
+        fn fail_to_create_decoder_with_invalid_type() {
+            ArrayDecoder::<BooleanArray>::new(
+                RECORD_BATCH.column_by_name("timestamp_nanosecond").unwrap(),
+            )
+            .map(|_| ())
+            .unwrap_err();
+        }
+    }
+}
diff --git a/graph/src/amp/codec/decoder.rs b/graph/src/amp/codec/decoder.rs
new file mode 100644
index 00000000000..9b5c340e891
--- /dev/null
+++ b/graph/src/amp/codec/decoder.rs
@@ -0,0 +1,29 @@
+use anyhow::Result;
+
+/// Decodes Arrow data at specific row indices into subgraph types.
+///
+/// This trait provides a common interface for converting Arrow format data into
+/// custom types. Implementations handle the specifics of extracting data from
+/// Arrow arrays and constructing the target type `T`.
+pub trait Decoder<T> {
+    /// Decodes and returns the value at the `row_index`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The data cannot be converted to type `T`
+    /// - The underlying Arrow data is invalid or corrupted
+    ///
+    /// The returned error is deterministic.
+    fn decode(&self, row_index: usize) -> Result<T>;
+}
+
+/// Forwards decoding operations through boxed trait objects.
+///
+/// This implementation enables using `Box<dyn Decoder<T>>` as a decoder,
+/// delegating to the underlying implementation.
+impl<T> Decoder<T> for Box<dyn Decoder<T> + '_> {
+    fn decode(&self, row_index: usize) -> Result<T> {
+        (**self).decode(row_index)
+    }
+}
diff --git a/graph/src/amp/codec/list_decoder.rs b/graph/src/amp/codec/list_decoder.rs
new file mode 100644
index 00000000000..4c0e2a44504
--- /dev/null
+++ b/graph/src/amp/codec/list_decoder.rs
@@ -0,0 +1,88 @@
+use anyhow::Result;
+
+use super::decoder::Decoder;
+
+/// Decodes Arrow lists to vectors of decoded values.
+pub(super) struct ListDecoder<'a, T> {
+    decoder: T,
+    offsets: ArrayOffsets<'a>,
+}
+
+/// Contains row index offsets used to determine how many values to decode from an Arrow list.
+pub(super) enum ArrayOffsets<'a> {
+    Small(&'a [i32]),
+    Large(&'a [i64]),
+    Fixed(i32),
+}
+
+impl<'a, T> ListDecoder<'a, T> {
+    /// Creates a new Arrow list decoder with provided `offsets`.
+    pub(super) fn new(decoder: T, offsets: ArrayOffsets<'a>) -> Self {
+        Self { decoder, offsets }
+    }
+}
+
+impl<'a, T, V> Decoder<Option<Vec<V>>> for ListDecoder<'a, T>
+where
+    T: Decoder<V>,
+{
+    fn decode(&self, row_index: usize) -> Result<Option<Vec<V>>> {
+        let Some(range) = self.offsets.range(row_index) else {
+            return Ok(None);
+        };
+
+        let values = range
+            .map(|row_index| self.decoder.decode(row_index))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        if values.is_empty() {
+            return Ok(None);
+        }
+
+        Ok(Some(values))
+    }
+}
+
+impl<'a> ArrayOffsets<'a> {
+    /// Returns row indices belonging to a list at `row_index`.
+    fn range(&self, row_index: usize) -> Option<impl Iterator<Item = usize>> {
+        match self {
+            Self::Small(offsets) => {
+                let start = *offsets.get(row_index)? as usize;
+                let end = *offsets.get(row_index + 1)? as usize;
+
+                Some(start..end)
+            }
+            Self::Large(offsets) => {
+                let start = *offsets.get(row_index)? as usize;
+                let end = *offsets.get(row_index + 1)? as usize;
+
+                Some(start..end)
+            }
+            Self::Fixed(value_length) => {
+                let start = *value_length as usize * row_index;
+                let end = *value_length as usize * (row_index + 1);
+
+                Some(start..end)
+            }
+        }
+    }
+}
+
+impl<'a> From<&'a [i32]> for ArrayOffsets<'a> {
+    fn from(offsets: &'a [i32]) -> Self {
+        Self::Small(offsets)
+    }
+}
+
+impl<'a> From<&'a [i64]> for ArrayOffsets<'a> {
+    fn from(offsets: &'a [i64]) -> Self {
+        Self::Large(offsets)
+    }
+}
+
+impl From<i32> for ArrayOffsets<'static> {
+    fn from(value_length: i32) -> Self {
+        Self::Fixed(value_length)
+    }
+}
diff --git a/graph/src/amp/codec/mapping_decoder.rs b/graph/src/amp/codec/mapping_decoder.rs
new file mode 100644
index 00000000000..19a81cb6dcb
--- /dev/null
+++ b/graph/src/amp/codec/mapping_decoder.rs
@@ -0,0 +1,32 @@
+use anyhow::Result;
+
+use super::decoder::Decoder;
+
+/// Decodes Arrow arrays and maps the decoded values to a different type.
+pub(super) struct MappingDecoder<T, U, V> {
+    decoder: T,
+    mapping: Box<dyn Fn(U) -> V + 'static>,
+}
+
+impl<T, U, V> MappingDecoder<T, U, V> {
+    /// Creates a new decoder that wraps the `decoder`.
+    ///
+    /// The `mapping` function transforms decoded values from type `U` to type `V`.
+    pub(super) fn new(decoder: T, mapping: impl Fn(U) -> V + 'static) -> Self {
+        Self {
+            decoder,
+            mapping: Box::new(mapping),
+        }
+    }
+}
+
+impl<T, U, V> Decoder<V> for MappingDecoder<T, U, V>
+where
+    T: Decoder<U>,
+{
+    fn decode(&self, row_index: usize) -> Result<V> {
+        let value = self.decoder.decode(row_index)?;
+
+        Ok((self.mapping)(value))
+    }
+}
diff --git a/graph/src/amp/codec/mod.rs b/graph/src/amp/codec/mod.rs
new file mode 100644
index 00000000000..f259ae528d8
--- /dev/null
+++ b/graph/src/amp/codec/mod.rs
@@ -0,0 +1,511 @@
+mod array_decoder;
+mod decoder;
+mod list_decoder;
+mod mapping_decoder;
+mod name_cache;
+mod value_decoder;
+
+#[cfg(test)]
+mod test_fixtures;
+
+pub mod utils;
+
+use std::{
+    collections::{BTreeMap, HashMap},
+    sync::Arc,
+};
+
+use anyhow::{Context, Result, anyhow, bail};
+use arrow::array::{Array, RecordBatch};
+
+use self::{list_decoder::ListDecoder, mapping_decoder::MappingDecoder, name_cache::NameCache};
+use crate::{
+    data::{
+        graphql::TypeExt,
+        store::{Id, IdType, Value},
+        value::Word,
+    },
+    schema::{EntityKey, EntityType, Field, InputSchema},
+};
+
+pub use self::{array_decoder::ArrayDecoder, decoder::Decoder};
+
+/// Handles decoding of record batches to subgraph entities.
+pub struct Codec {
+    input_schema: InputSchema,
+    name_cache: NameCache,
+}
+
+/// Contains the entities decoded from a record batch.
+pub struct DecodeOutput {
+    /// The type of entities in this batch.
+    pub entity_type: EntityType,
+
+    /// The type of the ID of entities in this batch.
+    pub id_type: IdType,
+
+    /// A list of decoded entities of the same type.
+    pub decoded_entities: Vec<DecodedEntity>,
+}
+
+/// Contains a single entity decoded from a record batch.
+pub struct DecodedEntity {
+    /// The unique ID of the entity.
+    ///
+    /// When set to `None`, the ID is expected to be auto-generated before a new entity is persisted.
+    pub key: Option<EntityKey>,
+
+    /// A list of entity field names and their values.
+    ///
+    /// This list could contain a subset of fields of an entity.
+    pub entity_data: Vec<(Word, Value)>,
+}
+
+impl Codec {
+    /// Creates a new decoder for the `input_schema`.
+    pub fn new(input_schema: InputSchema) -> Self {
+        let name_cache = NameCache::new();
+
+        Self {
+            input_schema,
+            name_cache,
+        }
+    }
+
+    /// Decodes a `record_batch` according to the schema of the entity with name `entity_name`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `record_batch` is not compatible with the schema of the entity with name `entity_name`.
+    ///
+    /// The returned error is deterministic.
+    pub fn decode(&mut self, record_batch: RecordBatch, entity_name: &str) -> Result<DecodeOutput> {
+        let entity_type = self.entity_type(entity_name)?;
+        let id_type = entity_type.id_type()?;
+        let value_decoders = self.value_decoders(&entity_type, &record_batch)?;
+        let mut decoded_entities = Vec::with_capacity(record_batch.num_rows());
+
+        for i in 0..record_batch.num_rows() {
+            let err_ctx = |s: &str| format!("field '{s}' at row {i}");
+            let mut entity_id: Option<Value> = None;
+            let mut entity_data = Vec::with_capacity(value_decoders.len());
+
+            for (&field_name, value_decoder) in &value_decoders {
+                let value = value_decoder
+                    .decode(i)
+                    .with_context(|| err_ctx(field_name))?;
+
+                if field_name.eq_ignore_ascii_case("id") {
+                    entity_id = Some(value.clone());
+                }
+
+                entity_data.push((Word::from(field_name), value));
+            }
+
+            let entity_key = entity_id
+                .map(Id::try_from)
+                .transpose()
+                .with_context(|| err_ctx("id"))?
+                .map(|entity_id| entity_type.key(entity_id));
+
+            decoded_entities.push(DecodedEntity {
+                key: entity_key,
+                entity_data,
+            });
+        }
+
+        drop(value_decoders);
+
+        Ok(DecodeOutput {
+            entity_type,
+            id_type,
+            decoded_entities,
+        })
+    }
+
+    /// Returns the type of the entity with name `entity_name`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - There is no entity with name `entity_name`
+    /// - The entity is not an object
+    /// - The entity is a POI entity
+    ///
+    /// The returned error is deterministic.
+    fn entity_type(&self, entity_name: &str) -> Result<EntityType> {
+        let entity_type = self
+            .input_schema
+            .entity_type(entity_name)
+            .context("entity not found")?;
+
+        if !entity_type.is_object_type() {
+            return Err(anyhow!("entity is not an object"));
+        }
+
+        if entity_type.is_poi() {
+            return Err(anyhow!("entity is POI entity"));
+        }
+
+        Ok(entity_type)
+    }
+
+    /// Creates and returns value decoders for the fields of the entity with name `entity_name`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if a decoder could not be created for a required field.
+    ///
+    /// The returned error is deterministic.
+    fn value_decoders<'a>(
+        &mut self,
+        entity_type: &'a EntityType,
+        record_batch: &'a RecordBatch,
+    ) -> Result<BTreeMap<&'a str, Box<dyn Decoder<Value> + 'a>>> {
+        let object_type = entity_type.object_type().unwrap();
+        let columns = record_batch
+            .schema_ref()
+            .fields()
+            .into_iter()
+            .zip(record_batch.columns())
+            .map(|(field, array)| Ok((self.ident(field.name()), array.as_ref())))
+            .collect::<Result<HashMap<_, _>>>()?;
+
+        let mut value_decoders = BTreeMap::new();
+        for field in &object_type.fields {
+            let Some(value_decoder) = self.value_decoder(field, &columns)? else {
+                continue;
+            };
+
+            value_decoders.insert(field.name.as_str(), value_decoder);
+        }
+
+        Ok(value_decoders)
+    }
+
+    /// Creates and returns a value decoder for the `field`.
+    ///
+    /// Returns `None` when the `field` does not require a decoder.
+    /// This happens for derived fields, reserved fields, and when there is no associated
+    /// Arrow array for a nullable `field` or a `field` that could be auto-generated.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - There is no associated Arrow array for a required `field`
+    /// - The `field` type is not compatible with the Arrow array
+    ///
+    /// The returned error is deterministic.
+    fn value_decoder<'a>(
+        &mut self,
+        field: &'a Field,
+        columns: &HashMap<Arc<str>, &'a dyn Array>,
+    ) -> Result<Option<Box<dyn Decoder<Value> + 'a>>> {
+        // VIDs are auto-generated
+        if field.name.eq_ignore_ascii_case("vid") {
+            return Ok(None);
+        }
+
+        // Derived fields are handled automatically
+        if field.is_derived() {
+            return Ok(None);
+        }
+
+        let normalized_name = self.ident(&field.name);
+        let array = match columns.get(&normalized_name) {
+            Some(&array) => array,
+            None => {
+                // Allow ID auto-generation
+                if field.name.eq_ignore_ascii_case("id") {
+                    return Ok(None);
+                }
+
+                // Allow partial entities
+                if !field.field_type.is_non_null() {
+                    return Ok(None);
+                }
+
+                bail!("failed to get column for field '{}'", field.name);
+            }
+        };
+
+        let decoder = value_decoder::value_decoder(field.value_type, field.is_list(), array)
+            .with_context(|| format!("failed to create decoder for field '{}'", field.name))?;
+
+        Ok(Some(decoder))
+    }
+
+    fn ident(&mut self, name: impl AsRef<str>) -> Arc<str> {
+        self.name_cache.ident(name.as_ref())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::LazyLock;
+
+    use arrow::array::{BinaryArray, BooleanArray, Int8Array, Int64Array};
+    use arrow::datatypes::{DataType, Field, Schema};
+
+    use crate::data::subgraph::DeploymentHash;
+
+    use super::*;
+
+    static SCHEMA: LazyLock<InputSchema> = LazyLock::new(|| {
+        InputSchema::parse_latest(
+            r#"
+            type Id @entity {
+                id: Int8!
+            }
+
+            type BlockNumber @entity {
+                id: Int8!
+                blockNumber: BigInt!
+            }
+
+            type OptionalBlockNumber @entity {
+                id: Int8!
+                blockNumber: BigInt
+            }
+
+            type Block @entity {
+                id: Int8!
+                number: Int8!
+                hash: Bytes!
+                value: BigInt
+            }
+            "#,
+            DeploymentHash::default(),
+        )
+        .unwrap()
+    });
+
+    #[inline]
+    fn new_codec() -> Codec {
+        Codec::new(SCHEMA.clone())
+    }
+
+    #[test]
+    fn fail_to_decode_unknown_entity() {
+        let schema = Schema::new(vec![Field::new("some_field", DataType::Boolean, true)]);
+        let record_batch = RecordBatch::new_empty(schema.into());
+
+        let mut codec = new_codec();
+        let e = codec
+            .decode(record_batch, "SomeEntity")
+            .map(|_| ())
+            .unwrap_err();
+
+        assert!(format!("{e:#}").contains("entity not found"))
+    }
+
+    #[test]
+    fn do_not_fail_on_empty_record_batch() {
+        let schema = Schema::new(vec![Field::new("some_field", DataType::Boolean, true)]);
+        let record_batch = RecordBatch::new_empty(schema.into());
+
+        let mut codec = new_codec();
+        let decode_output = codec.decode(record_batch, "Id").unwrap();
+
+        assert!(decode_output.decoded_entities.is_empty());
+    }
+
+    #[test]
+    fn allow_entity_ids_to_be_auto_generated() {
+        let schema = Schema::new(vec![Field::new("some_field", DataType::Boolean, true)]);
+        let record_batch = RecordBatch::try_new(
+            schema.into(),
+            vec![Arc::new(BooleanArray::from(vec![true, false]))],
+        )
+        .unwrap();
+
+        let mut codec = new_codec();
+        let decode_output = codec.decode(record_batch, "Id").unwrap();
+        let decoded_entities = decode_output.decoded_entities;
+
+        assert_eq!(decoded_entities.len(), 2);
+
+        for decoded_entity in decoded_entities {
+            assert!(decoded_entity.key.is_none());
+            assert!(decoded_entity.entity_data.is_empty());
+        }
+    }
+
+    #[test]
+    fn decode_entity_ids() {
+        let schema = Schema::new(vec![Field::new("id", DataType::Int8, true)]);
+        let record_batch = RecordBatch::try_new(
+            schema.into(),
+            vec![Arc::new(Int8Array::from(vec![10, 20, 30]))],
+        )
+        .unwrap();
+
+        let mut codec = new_codec();
+        let decode_output = codec.decode(record_batch, "Id").unwrap();
+        let decoded_entities = decode_output.decoded_entities;
+
+        assert_eq!(decoded_entities.len(), 3);
+
+        assert_eq!(
+            decoded_entities[0].key.as_ref().unwrap().entity_id,
+            Id::Int8(10),
+        );
+        assert_eq!(
+            &decoded_entities[0].entity_data,
+            &[(Word::from("id"), Value::Int8(10))],
+        );
+
+        assert_eq!(
+            decoded_entities[1].key.as_ref().unwrap().entity_id,
+            Id::Int8(20)
+        );
+        assert_eq!(
+            &decoded_entities[1].entity_data,
+            &[(Word::from("id"), Value::Int8(20))],
+        );
+
+        assert_eq!(
+            decoded_entities[2].key.as_ref().unwrap().entity_id,
+            Id::Int8(30)
+        );
+        assert_eq!(
+            &decoded_entities[2].entity_data,
+            &[(Word::from("id"), Value::Int8(30))],
+        );
+    }
+
+    #[test]
+    fn fail_to_decode_entity_when_a_required_field_is_missing() {
+        let schema = Schema::new(vec![Field::new("some_field", DataType::Int8, true)]);
+        let record_batch =
+            RecordBatch::try_new(schema.into(), vec![Arc::new(Int8Array::from(vec![10]))]).unwrap();
+
+        let mut codec = new_codec();
+        let e = codec
+            .decode(record_batch, "BlockNumber")
+            .map(|_| ())
+            .unwrap_err();
+
+        assert!(format!("{e:#}").contains("failed to get column for field 'blockNumber'"));
+    }
+
+    #[test]
+    fn decode_entity_when_an_optional_field_is_missing() {
+        let schema = Schema::new(vec![Field::new("some_field", DataType::Int8, true)]);
+        let record_batch =
+            RecordBatch::try_new(schema.into(), vec![Arc::new(Int8Array::from(vec![10]))]).unwrap();
+
+        let mut codec = new_codec();
+        let decode_output = codec.decode(record_batch, "OptionalBlockNumber").unwrap();
+        let decoded_entitites = decode_output.decoded_entities;
+
+        assert_eq!(decoded_entitites.len(), 1);
+        assert!(decoded_entitites[0].entity_data.is_empty());
+    }
+
+    #[test]
+    fn match_entity_field_name_with_column_name_ignoring_case() {
+        for column_name in [
+            "block_number",
+            "Block_Number",
+            "BLOCK_NUMBER",
+            "blocknumber",
+            "blockNumber",
+            "BlockNumber",
+            "BLOCKNUMBER",
+        ] {
+            let schema = Schema::new(vec![Field::new(column_name, DataType::Int8, true)]);
+            let record_batch = RecordBatch::try_new(
+                schema.into(),
+                vec![Arc::new(Int8Array::from(vec![10, 20, 30]))],
+            )
+            .unwrap();
+
+            let mut codec = new_codec();
+            let decode_output = codec.decode(record_batch, "BlockNumber").unwrap();
+            let decoded_entitites = decode_output.decoded_entities;
+
+            assert_eq!(decoded_entitites.len(), 3);
+
+            assert_eq!(
+                &decoded_entitites[0].entity_data,
+                &[(Word::from("blockNumber"), Value::BigInt(10.into()))]
+            );
+            assert_eq!(
+                &decoded_entitites[1].entity_data,
+                &[(Word::from("blockNumber"), Value::BigInt(20.into()))]
+            );
+            assert_eq!(
+                &decoded_entitites[2].entity_data,
+                &[(Word::from("blockNumber"), Value::BigInt(30.into()))]
+            );
+        }
+    }
+
+    #[test]
+    fn fail_to_decode_entity_when_field_type_and_column_type_are_incompatible() {
+        let schema = Schema::new(vec![Field::new("block_number", DataType::Boolean, true)]);
+        let record_batch = RecordBatch::try_new(
+            schema.into(),
+            vec![Arc::new(BooleanArray::from(vec![true]))],
+        )
+        .unwrap();
+
+        let mut codec = new_codec();
+        let e = codec
+            .decode(record_batch, "BlockNumber")
+            .map(|_| ())
+            .unwrap_err();
+
+        assert!(format!("{e:#}").contains("failed to create decoder for field 'blockNumber'"))
+    }
+
+    #[test]
+    fn decode_entities_with_multiple_fields() {
+        let schema = Schema::new(vec![
+            Field::new("number", DataType::Int8, true),
+            Field::new("hash", DataType::Binary, true),
+            Field::new("value", DataType::Int64, true),
+        ]);
+        let record_batch = RecordBatch::try_new(
+            schema.into(),
+            vec![
+                Arc::new(Int8Array::from(vec![10, 20, 30])),
+                Arc::new(BinaryArray::from(vec![b"aa".as_ref(), b"bb", b"cc"])),
+                Arc::new(Int64Array::from(vec![100, 200, 300])),
+            ],
+        )
+        .unwrap();
+
+        let mut codec = new_codec();
+        let decode_output = codec.decode(record_batch, "Block").unwrap();
+        let decoded_entitites = decode_output.decoded_entities;
+
+        assert_eq!(decoded_entitites.len(), 3);
+
+        assert_eq!(
+            &decoded_entitites[0].entity_data,
+            &[
+                (Word::from("hash"), Value::Bytes(b"aa".as_ref().into())),
+                (Word::from("number"), Value::Int8(10)),
+                (Word::from("value"), Value::BigInt(100.into()))
+            ]
+        );
+        assert_eq!(
+            &decoded_entitites[1].entity_data,
+            &[
+                (Word::from("hash"), Value::Bytes(b"bb".as_ref().into())),
+                (Word::from("number"), Value::Int8(20)),
+                (Word::from("value"), Value::BigInt(200.into()))
+            ]
+        );
+        assert_eq!(
+            &decoded_entitites[2].entity_data,
+            &[
+                (Word::from("hash"), Value::Bytes(b"cc".as_ref().into())),
+                (Word::from("number"), Value::Int8(30)),
+                (Word::from("value"), Value::BigInt(300.into()))
+            ]
+        );
+    }
+}
diff --git a/graph/src/amp/codec/name_cache.rs b/graph/src/amp/codec/name_cache.rs
new file mode 100644
index 00000000000..9ad28f7a3b1
--- /dev/null
+++ b/graph/src/amp/codec/name_cache.rs
@@ -0,0 +1,34 @@
+use std::{collections::HashMap, sync::Arc};
+
+use inflector::Inflector;
+
+use crate::cheap_clone::CheapClone;
+
+/// Normalizes and caches identifiers that are used to match Arrow columns and subgraph entity fields.
+pub(super) struct NameCache {
+    cache: HashMap<Box<str>, Arc<str>>,
+}
+
+impl NameCache {
+    /// Creates a new empty cache.
+    pub(super) fn new() -> Self {
+        Self {
+            cache: HashMap::new(),
+        }
+    }
+
+    /// Normalizes and returns the identifier for the given name.
+    ///
+    /// If the identifier exists in the cache, returns the cached version.
+    /// Otherwise, creates a new normalized identifier, caches it, and returns it.
+    pub(super) fn ident(&mut self, name: &str) -> Arc<str> {
+        if let Some(ident) = self.cache.get(name) {
+            return ident.cheap_clone();
+        }
+
+        let ident: Arc<str> = name.to_camel_case().to_lowercase().into();
+        self.cache.insert(name.into(), ident.cheap_clone());
+
+        ident
+    }
+}
diff --git a/graph/src/amp/codec/test_fixtures.rs b/graph/src/amp/codec/test_fixtures.rs
new file mode 100644
index 00000000000..4b4bdc3e627
--- /dev/null
+++ b/graph/src/amp/codec/test_fixtures.rs
@@ -0,0 +1,363 @@
+use std::sync::{Arc, LazyLock};
+
+use arrow::{
+    array::{
+        BinaryArray, BinaryViewArray, BooleanArray, BooleanBuilder, Decimal128Builder,
+        Decimal256Builder, FixedSizeBinaryArray, FixedSizeListBuilder, Float16Array, Float32Array,
+        Float64Array, Int8Array, Int16Array, Int32Array, Int64Array, LargeBinaryArray,
+        LargeListBuilder, LargeListViewBuilder, LargeStringArray, ListBuilder, ListViewBuilder,
+        RecordBatch, StringArray, StringViewArray, TimestampMicrosecondArray,
+        TimestampMillisecondArray, TimestampNanosecondArray, TimestampSecondArray, UInt8Array,
+        UInt16Array, UInt32Array, UInt64Array,
+    },
+    datatypes::{
+        DECIMAL128_MAX_PRECISION, DECIMAL256_MAX_PRECISION, DataType, Field, Schema, TimeUnit, i256,
+    },
+};
+use chrono::{TimeZone, Utc};
+use half::f16;
+
+pub static RECORD_BATCH: LazyLock<RecordBatch> = LazyLock::new(|| {
+    let record_batches = [
+        &BOOLEAN_RECORD_BATCH,
+        &INT_RECORD_BATCH,
+        &UINT_RECORD_BATCH,
+        &DECIMAL_RECORD_BATCH,
+        &FLOAT_RECORD_BATCH,
+        &STRING_RECORD_BATCH,
+        &BINARY_RECORD_BATCH,
+        &TIMESTAMP_RECORD_BATCH,
+    ];
+
+    let schemas = record_batches
+        .iter()
+        .map(|record_batch| (*record_batch.schema()).clone());
+
+    let columns = record_batches
+        .into_iter()
+        .flat_map(|record_batch| record_batch.columns())
+        .cloned()
+        .collect::<Vec<_>>();
+
+    RecordBatch::try_new(Schema::try_merge(schemas).unwrap().into(), columns).unwrap()
+});
+
+pub static BOOLEAN_RECORD_BATCH: LazyLock<RecordBatch> = LazyLock::new(|| {
+    let schema = Schema::new(vec![
+        Field::new("boolean", DataType::Boolean, true),
+        Field::new(
+            "boolean_list",
+            DataType::List(Arc::new(Field::new("item", DataType::Boolean, true))),
+            true,
+        ),
+        Field::new(
+            "boolean_list_view",
+            DataType::ListView(Arc::new(Field::new("item", DataType::Boolean, true))),
+            true,
+        ),
+        Field::new(
+            "boolean_fixed_size_list",
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Boolean, true)), 3),
+            true,
+        ),
+        Field::new(
+            "boolean_large_list",
+            DataType::LargeList(Arc::new(Field::new("item", DataType::Boolean, true))),
+            true,
+        ),
+        Field::new(
+            "boolean_large_list_view",
+            DataType::LargeListView(Arc::new(Field::new("item", DataType::Boolean, true))),
+            true,
+        ),
+    ]);
+
+    let builder = || {
+        let mut builder = BooleanBuilder::new();
+        builder.append_value(true);
+        builder.append_value(false);
+        builder.append_value(true);
+        builder
+    };
+
+    RecordBatch::try_new(
+        schema.into(),
+        vec![
+            Arc::new(BooleanArray::from(vec![true, false, true])),
+            Arc::new({
+                let mut list_builder = ListBuilder::new(builder());
+                list_builder.append(true);
+                list_builder.append(false);
+                list_builder.append(false);
+                list_builder.finish()
+            }),
+            Arc::new({
+                let mut list_builder = ListViewBuilder::new(builder());
+                list_builder.append(true);
+                list_builder.append(false);
+                list_builder.append(false);
+                list_builder.finish()
+            }),
+            Arc::new({
+                let mut list_builder = FixedSizeListBuilder::new(builder(), 3);
+                list_builder.append(true);
+                list_builder.values().append_null();
+                list_builder.values().append_null();
+                list_builder.values().append_null();
+                list_builder.append(false);
+                list_builder.values().append_null();
+                list_builder.values().append_null();
+                list_builder.values().append_null();
+                list_builder.append(false);
+                list_builder.finish()
+            }),
+            Arc::new({
+                let mut list_builder = LargeListBuilder::new(builder());
+                list_builder.append(true);
+                list_builder.append(false);
+                list_builder.append(false);
+                list_builder.finish()
+            }),
+            Arc::new({
+                let mut list_builder = LargeListViewBuilder::new(builder());
+                list_builder.append(true);
+                list_builder.append(false);
+                list_builder.append(false);
+                list_builder.finish()
+            }),
+        ],
+    )
+    .unwrap()
+});
+
+pub static INT_RECORD_BATCH: LazyLock<RecordBatch> = LazyLock::new(|| {
+    let schema = Schema::new(vec![
+        Field::new("int8", DataType::Int8, true),
+        Field::new("int16", DataType::Int16, true),
+        Field::new("int32", DataType::Int32, true),
+        Field::new("int64", DataType::Int64, true),
+    ]);
+
+    RecordBatch::try_new(
+        schema.into(),
+        vec![
+            Arc::new(Int8Array::from(vec![10, 20, i8::MAX])),
+            Arc::new(Int16Array::from(vec![10, 20, i16::MAX])),
+            Arc::new(Int32Array::from(vec![10, 20, i32::MAX])),
+            Arc::new(Int64Array::from(vec![10, 20, i64::MAX])),
+        ],
+    )
+    .unwrap()
+});
+
+pub static UINT_RECORD_BATCH: LazyLock<RecordBatch> = LazyLock::new(|| {
+    let schema = Schema::new(vec![
+        Field::new("uint8", DataType::UInt8, true),
+        Field::new("uint16", DataType::UInt16, true),
+        Field::new("uint32", DataType::UInt32, true),
+        Field::new("uint64", DataType::UInt64, true),
+    ]);
+
+    RecordBatch::try_new(
+        schema.into(),
+        vec![
+            Arc::new(UInt8Array::from(vec![10, 20, u8::MAX])),
+            Arc::new(UInt16Array::from(vec![10, 20, u16::MAX])),
+            Arc::new(UInt32Array::from(vec![10, 20, u32::MAX])),
+            Arc::new(UInt64Array::from(vec![10, 20, u64::MAX])),
+        ],
+    )
+    .unwrap()
+});
+
+pub static DECIMAL_RECORD_BATCH: LazyLock<RecordBatch> = LazyLock::new(|| {
+    let schema = Schema::new(vec![
+        Field::new(
+            "decimal128",
+            DataType::Decimal128(DECIMAL128_MAX_PRECISION, 0),
+            true,
+        ),
+        Field::new(
+            "decimal128_with_scale",
+            DataType::Decimal128(DECIMAL128_MAX_PRECISION, 10),
+            true,
+        ),
+        Field::new(
+            "decimal256",
+            DataType::Decimal256(DECIMAL256_MAX_PRECISION, 0),
+            true,
+        ),
+        Field::new(
+            "decimal256_with_scale",
+            DataType::Decimal256(DECIMAL256_MAX_PRECISION, 10),
+            true,
+        ),
+    ]);
+
+    let decimal_128_array = |scale: i8| {
+        let mut builder = Decimal128Builder::new()
+            .with_precision_and_scale(DECIMAL128_MAX_PRECISION, scale)
+            .unwrap();
+
+        builder.append_value(10);
+        builder.append_value(20);
+        builder.append_value(i128::MAX);
+        builder.finish()
+    };
+
+    let decimal_256_array = |scale: i8| {
+        let mut builder = Decimal256Builder::new()
+            .with_precision_and_scale(DECIMAL256_MAX_PRECISION, scale)
+            .unwrap();
+
+        builder.append_value(10.into());
+        builder.append_value(20.into());
+        builder.append_value(i256::MAX);
+        builder.finish()
+    };
+
+    RecordBatch::try_new(
+        schema.into(),
+        vec![
+            Arc::new(decimal_128_array(0)),
+            Arc::new(decimal_128_array(10)),
+            Arc::new(decimal_256_array(0)),
+            Arc::new(decimal_256_array(10)),
+        ],
+    )
+    .unwrap()
+});
+
+pub static FLOAT_RECORD_BATCH: LazyLock<RecordBatch> = LazyLock::new(|| {
+    let schema = Schema::new(vec![
+        Field::new("float16", DataType::Float16, true),
+        Field::new("float32", DataType::Float32, true),
+        Field::new("float64", DataType::Float64, true),
+    ]);
+
+    RecordBatch::try_new(
+        schema.into(),
+        vec![
+            Arc::new(Float16Array::from(vec![
+                f16::from_f32(10.0),
+                f16::from_f32(20.0),
+                f16::MAX,
+            ])),
+            Arc::new(Float32Array::from(vec![10.0, 20.0, f32::MAX])),
+            Arc::new(Float64Array::from(vec![10.0, 20.0, f64::MAX])),
+        ],
+    )
+    .unwrap()
+});
+
+pub static STRING_RECORD_BATCH: LazyLock<RecordBatch> = LazyLock::new(|| {
+    let schema = Schema::new(vec![
+        Field::new("utf8", DataType::Utf8, true),
+        Field::new("utf8_view", DataType::Utf8View, true),
+        Field::new("large_utf8", DataType::LargeUtf8, true),
+    ]);
+
+    RecordBatch::try_new(
+        schema.into(),
+        vec![
+            Arc::new(StringArray::from(vec!["aa", "bb", "30"])),
+            Arc::new(StringViewArray::from(vec!["aa", "bb", "30"])),
+            Arc::new(LargeStringArray::from(vec!["aa", "bb", "30"])),
+        ],
+    )
+    .unwrap()
+});
+
+pub static BINARY_RECORD_BATCH: LazyLock<RecordBatch> = LazyLock::new(|| {
+    let schema = Schema::new(vec![
+        Field::new("binary", DataType::Binary, true),
+        Field::new("binary_view", DataType::BinaryView, true),
+        Field::new("fixed_size_binary", DataType::FixedSizeBinary(2), true),
+        Field::new("fixed_size_binary_32", DataType::FixedSizeBinary(32), true),
+        Field::new("large_binary", DataType::LargeBinary, true),
+    ]);
+
+    RecordBatch::try_new(
+        schema.into(),
+        vec![
+            Arc::new(BinaryArray::from(vec![b"aa".as_ref(), b"bb", b"cc"])),
+            Arc::new(BinaryViewArray::from(vec![b"aa".as_ref(), b"bb", b"cc"])),
+            Arc::new(FixedSizeBinaryArray::try_from(vec![b"aa", b"bb", b"cc"]).unwrap()),
+            Arc::new(
+                FixedSizeBinaryArray::try_from(vec![&[10; 32], &[20; 32], &[30; 32]]).unwrap(),
+            ),
+            Arc::new(LargeBinaryArray::from(vec![b"aa".as_ref(), b"bb", b"cc"])),
+        ],
+    )
+    .unwrap()
+});
+
+pub static TIMESTAMP_RECORD_BATCH: LazyLock<RecordBatch> = LazyLock::new(|| {
+    let schema = Schema::new(vec![
+        Field::new(
+            "timestamp_second",
+            DataType::Timestamp(TimeUnit::Second, None),
+            true,
+        ),
+        Field::new(
+            "timestamp_millisecond",
+            DataType::Timestamp(TimeUnit::Millisecond, None),
+            true,
+        ),
+        Field::new(
+            "timestamp_microsecond",
+            DataType::Timestamp(TimeUnit::Microsecond, None),
+            true,
+        ),
+        Field::new(
+            "timestamp_nanosecond",
+            DataType::Timestamp(TimeUnit::Nanosecond, None),
+            true,
+        ),
+    ]);
+
+    let date_time_one = Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
+    let date_time_two = Utc.with_ymd_and_hms(2020, 10, 10, 10, 10, 10).unwrap();
+    let date_time_three = Utc.with_ymd_and_hms(2020, 12, 31, 23, 59, 59).unwrap();
+
+    RecordBatch::try_new(
+        schema.into(),
+        vec![
+            Arc::new(TimestampSecondArray::from(vec![
+                date_time_one.timestamp(),
+                date_time_two.timestamp(),
+                date_time_three.timestamp(),
+            ])),
+            Arc::new(TimestampMillisecondArray::from(vec![
+                date_time_one.timestamp_millis(),
+                date_time_two.timestamp_millis(),
+                date_time_three.timestamp_millis(),
+            ])),
+            Arc::new(TimestampMicrosecondArray::from(vec![
+                date_time_one.timestamp_micros(),
+                date_time_two.timestamp_micros(),
+                date_time_three.timestamp_micros(),
+            ])),
+            Arc::new(TimestampNanosecondArray::from(vec![
+                date_time_one.timestamp_nanos_opt().unwrap(),
+                date_time_two.timestamp_nanos_opt().unwrap(),
+                date_time_three.timestamp_nanos_opt().unwrap(),
+            ])),
+        ],
+    )
+    .unwrap()
+});
+
+#[test]
+fn record_batch_is_valid() {
+    let _schema = BOOLEAN_RECORD_BATCH.schema();
+    let _schema = INT_RECORD_BATCH.schema();
+    let _schema = UINT_RECORD_BATCH.schema();
+    let _schema = DECIMAL_RECORD_BATCH.schema();
+    let _schema = FLOAT_RECORD_BATCH.schema();
+    let _schema = STRING_RECORD_BATCH.schema();
+    let _schema = BINARY_RECORD_BATCH.schema();
+    let _schema = TIMESTAMP_RECORD_BATCH.schema();
+
+    let _schema = RECORD_BATCH.schema();
+}
diff --git a/graph/src/amp/codec/utils.rs b/graph/src/amp/codec/utils.rs
new file mode 100644
index 00000000000..78e8857fa6a
--- /dev/null
+++ b/graph/src/amp/codec/utils.rs
@@ -0,0 +1,120 @@
+use alloy::primitives::{BlockHash, BlockNumber};
+use anyhow::{Context, Result, bail};
+use arrow::array::{
+    Array, FixedSizeBinaryArray, RecordBatch, TimestampNanosecondArray, UInt64Array,
+};
+use chrono::{DateTime, Utc};
+
+use super::{ArrayDecoder, Decoder};
+use crate::amp::common::column_aliases;
+
+pub fn auto_block_number_decoder<'a>(
+    record_batch: &'a RecordBatch,
+) -> Result<(&'static str, Box<dyn Decoder<Option<BlockNumber>> + 'a>)> {
+    let (&column_name, column_index) = find_column(record_batch, column_aliases::BLOCK_NUMBER)
+        .with_context(|| {
+            format!(
+                "failed to find block numbers column; expected one of: {}",
+                column_aliases::BLOCK_NUMBER.join(", ")
+            )
+        })?;
+
+    block_number_decoder(record_batch, column_index)
+        .map(|decoder| (column_name, decoder))
+        .with_context(|| format!("column '{column_name}' is not valid"))
+}
+
+pub fn block_number_decoder<'a>(
+    record_batch: &'a RecordBatch,
+    column_index: usize,
+) -> Result<Box<dyn Decoder<Option<BlockNumber>> + 'a>> {
+    column_decoder::<UInt64Array, BlockNumber>(record_batch, column_index, false)
+}
+
+pub fn auto_block_hash_decoder<'a>(
+    record_batch: &'a RecordBatch,
+) -> Result<(&'static str, Box<dyn Decoder<Option<BlockHash>> + 'a>)> {
+    let (&column_name, column_index) = find_column(record_batch, column_aliases::BLOCK_HASH)
+        .with_context(|| {
+            format!(
+                "failed to find block hashes column; expected one of: {}",
+                column_aliases::BLOCK_HASH.join(", ")
+            )
+        })?;
+
+    block_hash_decoder(record_batch, column_index)
+        .map(|decoder| (column_name, decoder))
+        .with_context(|| format!("column '{column_name}' is not valid"))
+}
+
+pub fn block_hash_decoder<'a>(
+    record_batch: &'a RecordBatch,
+    column_index: usize,
+) -> Result<Box<dyn Decoder<Option<BlockHash>> + 'a>> {
+    column_decoder::<FixedSizeBinaryArray, BlockHash>(record_batch, column_index, false)
+}
+
+pub fn auto_block_timestamp_decoder<'a>(
+    record_batch: &'a RecordBatch,
+) -> Result<(&'static str, Box<dyn Decoder<Option<DateTime<Utc>>> + 'a>)> {
+    let (&column_name, column_index) = find_column(record_batch, column_aliases::BLOCK_TIMESTAMP)
+        .with_context(|| {
+        format!(
+            "failed to find block timestamps column; expected one of: {}",
+            column_aliases::BLOCK_TIMESTAMP.join(", ")
+        )
+    })?;
+
+    block_timestamp_decoder(record_batch, column_index)
+        .map(|decoder| (column_name, decoder))
+        .with_context(|| format!("column '{column_name}' is not valid"))
+}
+
+pub fn block_timestamp_decoder<'a>(
+    record_batch: &'a RecordBatch,
+    column_index: usize,
+) -> Result<Box<dyn Decoder<Option<DateTime<Utc>>> + 'a>> {
+    column_decoder::<TimestampNanosecondArray, DateTime<Utc>>(record_batch, column_index, false)
+}
+
+pub fn find_column<T>(
+    record_batch: &RecordBatch,
+    column_names: impl IntoIterator<Item = T>,
+) -> Option<(T, usize)>
+where
+    T: AsRef<str>,
+{
+    let schema_ref = record_batch.schema_ref();
+
+    for column_name in column_names {
+        if let Some((column_index, _)) = schema_ref.column_with_name(column_name.as_ref()) {
+            return Some((column_name, column_index));
+        }
+    }
+
+    None
+}
+
+pub fn column_decoder<'a, T, U>(
+    record_batch: &'a RecordBatch,
+    column_index: usize,
+    nullable: bool,
+) -> Result<Box<dyn Decoder<Option<U>> + 'a>>
+where
+    T: Array + 'static,
+    ArrayDecoder<'a, T>: Decoder<Option<U>>,
+{
+    if column_index >= record_batch.num_columns() {
+        bail!("column does not exist");
+    }
+
+    let array = record_batch.column(column_index);
+
+    if !nullable && array.is_nullable() {
+        bail!("column must not have nullable values");
+    }
+
+    let decoder = ArrayDecoder::<T>::new(array)?;
+
+    Ok(Box::new(decoder))
+}
diff --git a/graph/src/amp/codec/value_decoder.rs b/graph/src/amp/codec/value_decoder.rs
new file mode 100644
index 00000000000..72073c31887
--- /dev/null
+++ b/graph/src/amp/codec/value_decoder.rs
@@ -0,0 +1,873 @@
+use anyhow::{Context, Result, anyhow};
+use arrow::{
+    array::{
+        Array, BinaryArray, BinaryViewArray, BooleanArray, Decimal128Array, Decimal256Array,
+        FixedSizeBinaryArray, FixedSizeListArray, Float16Array, Float32Array, Float64Array,
+        Int8Array, Int16Array, Int32Array, Int64Array, LargeBinaryArray, LargeListArray,
+        LargeListViewArray, LargeStringArray, ListArray, ListViewArray, StringArray,
+        StringViewArray, TimestampMicrosecondArray, TimestampMillisecondArray,
+        TimestampNanosecondArray, TimestampSecondArray, UInt8Array, UInt16Array, UInt32Array,
+        UInt64Array,
+    },
+    datatypes::{DataType, TimeUnit},
+};
+use chrono::{DateTime, Utc};
+
+use super::{ArrayDecoder, Decoder, ListDecoder, MappingDecoder};
+use crate::data::store::{
+    Value, ValueType,
+    scalar::{BigDecimal, BigInt, Bytes, Timestamp},
+};
+
+/// Returns a decoder that converts an Arrow array into subgraph store values.
+///
+/// # Errors
+///
+/// Returns an error if the subgraph store type is not compatible with the Arrow array type.
+///
+/// The returned error is deterministic.
+pub(super) fn value_decoder<'a>(
+    value_type: ValueType,
+    is_list: bool,
+    array: &'a dyn Array,
+) -> Result<Box<dyn Decoder<Value> + 'a>> {
+    let decoder = if is_list {
+        list_value_decoder(value_type, array)
+    } else {
+        single_value_decoder(value_type, array)
+    };
+
+    decoder.with_context(|| {
+        format!(
+            "failed to decode '{}' from '{}'",
+            value_type.to_str(),
+            array.data_type(),
+        )
+    })
+}
+
+fn list_value_decoder<'a>(
+    value_type: ValueType,
+    array: &'a dyn Array,
+) -> Result<Box<dyn Decoder<Value> + 'a>> {
+    match array.data_type() {
+        DataType::List(_) => {
+            let list = array.as_any().downcast_ref::<ListArray>().unwrap();
+            let decoder = single_value_decoder(value_type, list.values())?;
+            let list_decoder = ListDecoder::new(decoder, list.value_offsets().into());
+
+            Ok(mapping_decoder(list_decoder, Value::List))
+        }
+        DataType::ListView(_) => {
+            let list = array.as_any().downcast_ref::<ListViewArray>().unwrap();
+            let decoder = single_value_decoder(value_type, list.values())?;
+            let list_decoder = ListDecoder::new(decoder, list.value_offsets().into());
+
+            Ok(mapping_decoder(list_decoder, Value::List))
+        }
+        DataType::FixedSizeList(_, _) => {
+            let list = array.as_any().downcast_ref::<FixedSizeListArray>().unwrap();
+            let decoder = single_value_decoder(value_type, list.values())?;
+            let list_decoder = ListDecoder::new(decoder, list.value_length().into());
+
+            Ok(mapping_decoder(list_decoder, Value::List))
+        }
+        DataType::LargeList(_) => {
+            let list = array.as_any().downcast_ref::<LargeListArray>().unwrap();
+            let decoder = single_value_decoder(value_type, list.values())?;
+            let list_decoder = ListDecoder::new(decoder, list.value_offsets().into());
+
+            Ok(mapping_decoder(list_decoder, Value::List))
+        }
+        DataType::LargeListView(_) => {
+            let list = array.as_any().downcast_ref::<LargeListViewArray>().unwrap();
+            let decoder = single_value_decoder(value_type, list.values())?;
+            let list_decoder = ListDecoder::new(decoder, list.value_offsets().into());
+
+            Ok(mapping_decoder(list_decoder, Value::List))
+        }
+        _ => {
+            let decoder = single_value_decoder(value_type, array)?;
+
+            Ok(Box::new(MappingDecoder::new(decoder, |value| {
+                if matches!(value, Value::Null) {
+                    return Value::Null;
+                }
+
+                Value::List(vec![value])
+            })))
+        }
+    }
+}
+
+fn single_value_decoder<'a>(
+    value_type: ValueType,
+    array: &'a dyn Array,
+) -> Result<Box<dyn Decoder<Value> + 'a>> {
+    let incompatible_types_err = || Err(anyhow!("incompatible types"));
+
+    let decoder = match (value_type, array.data_type()) {
+        (ValueType::Boolean, DataType::Boolean) => {
+            let array_decoder = ArrayDecoder::<BooleanArray>::new(array)?;
+            mapping_decoder(array_decoder, Value::Bool)
+        }
+        (ValueType::Boolean, _) => return incompatible_types_err(),
+
+        (ValueType::Int, data_type) if is_integer(data_type) => {
+            let integer_decoder = integer_decoder::<Option<i32>>(array)?;
+            mapping_decoder(integer_decoder, Value::Int)
+        }
+        (ValueType::Int, _) => return incompatible_types_err(),
+
+        (ValueType::Int8, data_type) if is_integer(data_type) => {
+            let integer_decoder = integer_decoder::<Option<i64>>(array)?;
+            mapping_decoder(integer_decoder, Value::Int8)
+        }
+        (ValueType::Int8, _) => return incompatible_types_err(),
+
+        (ValueType::BigInt, data_type) if is_integer(data_type) => {
+            let integer_decoder = integer_decoder::<Option<BigInt>>(array)?;
+            mapping_decoder(integer_decoder, Value::BigInt)
+        }
+        (ValueType::BigInt, data_type) if is_string(data_type) => {
+            let string_decoder = string_decoder::<Option<BigInt>>(array)?;
+            mapping_decoder(string_decoder, Value::BigInt)
+        }
+        (ValueType::BigInt, _) => return incompatible_types_err(),
+
+        (ValueType::BigDecimal, data_type) if is_decimal(data_type) => {
+            let decimal_decoder = decimal_decoder::<Option<BigDecimal>>(array)?;
+            mapping_decoder(decimal_decoder, Value::BigDecimal)
+        }
+        (ValueType::BigDecimal, data_type) if is_string(data_type) => {
+            let string_decoder = string_decoder::<Option<BigDecimal>>(array)?;
+            mapping_decoder(string_decoder, Value::BigDecimal)
+        }
+        (ValueType::BigDecimal, _) => return incompatible_types_err(),
+
+        (ValueType::Bytes, data_type) if is_binary(data_type) => {
+            let binary_decoder = binary_decoder::<Option<Box<[u8]>>>(array)?;
+            mapping_decoder(binary_decoder, |x| Bytes::from(&*x).into())
+        }
+        (ValueType::Bytes, _) => return incompatible_types_err(),
+
+        (ValueType::String, data_type) if is_string(data_type) => {
+            let string_decoder = string_decoder::<Option<String>>(array)?;
+            mapping_decoder(string_decoder, Value::String)
+        }
+        (ValueType::String, data_type) if is_integer(data_type) => {
+            let integer_decoder = integer_decoder::<Option<BigInt>>(array)?;
+            mapping_decoder(integer_decoder, |x| x.to_string().into())
+        }
+        (ValueType::String, data_type) if is_binary(data_type) => {
+            let binary_decoder = binary_decoder::<Option<Box<[u8]>>>(array)?;
+            mapping_decoder(binary_decoder, |x| format!("0x{}", hex::encode(x)).into())
+        }
+        (ValueType::String, _) => return incompatible_types_err(),
+
+        (ValueType::Timestamp, data_type) if is_timestamp(data_type) => {
+            let timestamp_decoder = timestamp_decoder::<Option<DateTime<Utc>>>(array)?;
+            mapping_decoder(timestamp_decoder, |x| Timestamp(x).into())
+        }
+        (ValueType::Timestamp, _) => return incompatible_types_err(),
+    };
+
+    Ok(decoder)
+}
+
+fn mapping_decoder<'a, T, U: 'static>(
+    array_decoder: T,
+    mapping: fn(U) -> Value,
+) -> Box<dyn Decoder<Value> + 'a>
+where
+    T: Decoder<Option<U>> + 'a,
+{
+    Box::new(MappingDecoder::new(
+        array_decoder,
+        move |value: Option<U>| match value {
+            Some(value) => mapping(value),
+            None => Value::Null,
+        },
+    ))
+}
+
+fn is_integer(data_type: &DataType) -> bool {
+    use DataType::*;
+
+    matches! {
+        data_type,
+        Int8 | Int16 | Int32 | Int64 |
+        UInt8 | UInt16 | UInt32 | UInt64 |
+        Decimal128(_, 0) | Decimal256(_, 0)
+    }
+}
+
+fn integer_decoder<'a, T>(array: &'a dyn Array) -> Result<Box<dyn Decoder<T> + 'a>>
+where
+    T: 'static,
+    ArrayDecoder<'a, Int8Array>: Decoder<T>,
+    ArrayDecoder<'a, Int16Array>: Decoder<T>,
+    ArrayDecoder<'a, Int32Array>: Decoder<T>,
+    ArrayDecoder<'a, Int64Array>: Decoder<T>,
+    ArrayDecoder<'a, UInt8Array>: Decoder<T>,
+    ArrayDecoder<'a, UInt16Array>: Decoder<T>,
+    ArrayDecoder<'a, UInt32Array>: Decoder<T>,
+    ArrayDecoder<'a, UInt64Array>: Decoder<T>,
+    ArrayDecoder<'a, Decimal128Array>: Decoder<T>,
+    ArrayDecoder<'a, Decimal256Array>: Decoder<T>,
+{
+    use DataType::*;
+
+    let array_decoder: Box<dyn Decoder<T>> = match array.data_type() {
+        Int8 => Box::new(ArrayDecoder::<Int8Array>::new(array)?),
+        Int16 => Box::new(ArrayDecoder::<Int16Array>::new(array)?),
+        Int32 => Box::new(ArrayDecoder::<Int32Array>::new(array)?),
+        Int64 => Box::new(ArrayDecoder::<Int64Array>::new(array)?),
+        UInt8 => Box::new(ArrayDecoder::<UInt8Array>::new(array)?),
+        UInt16 => Box::new(ArrayDecoder::<UInt16Array>::new(array)?),
+        UInt32 => Box::new(ArrayDecoder::<UInt32Array>::new(array)?),
+        UInt64 => Box::new(ArrayDecoder::<UInt64Array>::new(array)?),
+        Decimal128(_, 0) => Box::new(ArrayDecoder::<Decimal128Array>::new(array)?),
+        Decimal256(_, 0) => Box::new(ArrayDecoder::<Decimal256Array>::new(array)?),
+        data_type => return Err(anyhow!("'{data_type}' is not a supported integer type")),
+    };
+
+    Ok(array_decoder)
+}
+
+fn is_decimal(data_type: &DataType) -> bool {
+    use DataType::*;
+
+    matches! {
+        data_type,
+        Float16 | Float32 | Float64 |
+        Decimal128(_, _) | Decimal256(_, _)
+    }
+}
+
+fn decimal_decoder<'a, T>(array: &'a dyn Array) -> Result<Box<dyn Decoder<T> + 'a>>
+where
+    T: 'static,
+    ArrayDecoder<'a, Float16Array>: Decoder<T>,
+    ArrayDecoder<'a, Float32Array>: Decoder<T>,
+    ArrayDecoder<'a, Float64Array>: Decoder<T>,
+    ArrayDecoder<'a, Decimal128Array>: Decoder<T>,
+    ArrayDecoder<'a, Decimal256Array>: Decoder<T>,
+{
+    use DataType::*;
+
+    let array_decoder: Box<dyn Decoder<T>> = match array.data_type() {
+        Float16 => Box::new(ArrayDecoder::<Float16Array>::new(array)?),
+        Float32 => Box::new(ArrayDecoder::<Float32Array>::new(array)?),
+        Float64 => Box::new(ArrayDecoder::<Float64Array>::new(array)?),
+        Decimal128(_, _) => Box::new(ArrayDecoder::<Decimal128Array>::new(array)?),
+        Decimal256(_, _) => Box::new(ArrayDecoder::<Decimal256Array>::new(array)?),
+        data_type => return Err(anyhow!("'{data_type}' is not a supported decimal type")),
+    };
+
+    Ok(array_decoder)
+}
+
+fn is_binary(data_type: &DataType) -> bool {
+    use DataType::*;
+
+    matches! {
+        data_type,
+        Binary | BinaryView | FixedSizeBinary(_) | LargeBinary
+    }
+}
+
+fn binary_decoder<'a, T>(array: &'a dyn Array) -> Result<Box<dyn Decoder<T> + 'a>>
+where
+    T: 'static,
+    ArrayDecoder<'a, BinaryArray>: Decoder<T>,
+    ArrayDecoder<'a, BinaryViewArray>: Decoder<T>,
+    ArrayDecoder<'a, FixedSizeBinaryArray>: Decoder<T>,
+    ArrayDecoder<'a, LargeBinaryArray>: Decoder<T>,
+{
+    use DataType::*;
+
+    let array_decoder: Box<dyn Decoder<T>> = match array.data_type() {
+        Binary => Box::new(ArrayDecoder::<BinaryArray>::new(array)?),
+        BinaryView => Box::new(ArrayDecoder::<BinaryViewArray>::new(array)?),
+        FixedSizeBinary(_) => Box::new(ArrayDecoder::<FixedSizeBinaryArray>::new(array)?),
+        LargeBinary => Box::new(ArrayDecoder::<LargeBinaryArray>::new(array)?),
+        data_type => return Err(anyhow!("'{data_type}' is not a supported binary type")),
+    };
+
+    Ok(array_decoder)
+}
+
+fn is_string(data_type: &DataType) -> bool {
+    use DataType::*;
+
+    matches! {
+        data_type,
+        Utf8 | Utf8View | LargeUtf8
+    }
+}
+
+fn string_decoder<'a, T>(array: &'a dyn Array) -> Result<Box<dyn Decoder<T> + 'a>>
+where
+    T: 'static,
+    ArrayDecoder<'a, StringArray>: Decoder<T>,
+    ArrayDecoder<'a, StringViewArray>: Decoder<T>,
+    ArrayDecoder<'a, LargeStringArray>: Decoder<T>,
+{
+    use DataType::*;
+
+    let array_decoder: Box<dyn Decoder<T>> = match array.data_type() {
+        Utf8 => Box::new(ArrayDecoder::<StringArray>::new(array)?),
+        Utf8View => Box::new(ArrayDecoder::<StringViewArray>::new(array)?),
+        LargeUtf8 => Box::new(ArrayDecoder::<LargeStringArray>::new(array)?),
+        data_type => return Err(anyhow!("'{data_type}' is not a supported string type")),
+    };
+
+    Ok(array_decoder)
+}
+
+fn is_timestamp(data_type: &DataType) -> bool {
+    use DataType::*;
+
+    matches! {
+        data_type,
+        Timestamp(TimeUnit::Second, _) |
+        Timestamp(TimeUnit::Millisecond, _) |
+        Timestamp(TimeUnit::Microsecond, _) |
+        Timestamp(TimeUnit::Nanosecond, _)
+    }
+}
+
+fn timestamp_decoder<'a, T>(array: &'a dyn Array) -> Result<Box<dyn Decoder<T> + 'a>>
+where
+    T: 'static,
+    ArrayDecoder<'a, TimestampSecondArray>: Decoder<T>,
+    ArrayDecoder<'a, TimestampMillisecondArray>: Decoder<T>,
+    ArrayDecoder<'a, TimestampMicrosecondArray>: Decoder<T>,
+    ArrayDecoder<'a, TimestampNanosecondArray>: Decoder<T>,
+{
+    use DataType::*;
+
+    let array_decoder: Box<dyn Decoder<T>> = match array.data_type() {
+        Timestamp(TimeUnit::Second, _) => {
+            Box::new(ArrayDecoder::<TimestampSecondArray>::new(array)?) //
+        }
+        Timestamp(TimeUnit::Millisecond, _) => {
+            Box::new(ArrayDecoder::<TimestampMillisecondArray>::new(array)?) //
+        }
+        Timestamp(TimeUnit::Microsecond, _) => {
+            Box::new(ArrayDecoder::<TimestampMicrosecondArray>::new(array)?) //
+        }
+        Timestamp(TimeUnit::Nanosecond, _) => {
+            Box::new(ArrayDecoder::<TimestampNanosecondArray>::new(array)?) //
+        }
+        data_type => return Err(anyhow!("'{data_type}' is not a supported timestamp type")),
+    };
+
+    Ok(array_decoder)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::test_fixtures::*;
+    use super::*;
+
+    mod boolean_value_decoder {
+        use super::*;
+
+        fn decoder(column_name: &str, is_list: bool) -> Box<dyn Decoder<Value>> {
+            value_decoder(
+                ValueType::Boolean,
+                is_list,
+                RECORD_BATCH.column_by_name(column_name).unwrap(),
+            )
+            .unwrap()
+        }
+
+        #[test]
+        fn decode_single_values() {
+            let decoder = decoder("boolean", false);
+
+            assert_eq!(decoder.decode(0).unwrap(), Value::Bool(true));
+            assert_eq!(decoder.decode(1).unwrap(), Value::Bool(false));
+            assert_eq!(decoder.decode(2).unwrap(), Value::Bool(true));
+            assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+        }
+
+        #[test]
+        fn decode_single_values_as_lists() {
+            let decoder = decoder("boolean", true);
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Value::List(vec![Value::Bool(true)])
+            );
+            assert_eq!(
+                decoder.decode(1).unwrap(),
+                Value::List(vec![Value::Bool(false)])
+            );
+            assert_eq!(
+                decoder.decode(2).unwrap(),
+                Value::List(vec![Value::Bool(true)])
+            );
+            assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+        }
+
+        #[test]
+        fn decode_list_values() {
+            let decoder = decoder("boolean_list", true);
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Value::List(vec![
+                    Value::Bool(true),
+                    Value::Bool(false),
+                    Value::Bool(true),
+                ])
+            );
+            assert_eq!(decoder.decode(1).unwrap(), Value::Null);
+        }
+
+        #[test]
+        fn decode_list_view_values() {
+            let decoder = decoder("boolean_list_view", true);
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Value::List(vec![
+                    Value::Bool(true),
+                    Value::Bool(false),
+                    Value::Bool(true),
+                ])
+            );
+            assert_eq!(decoder.decode(1).unwrap(), Value::Null);
+        }
+
+        #[test]
+        fn decode_fixed_size_list_values() {
+            let decoder = decoder("boolean_fixed_size_list", true);
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Value::List(vec![
+                    Value::Bool(true),
+                    Value::Bool(false),
+                    Value::Bool(true),
+                ])
+            );
+        }
+
+        #[test]
+        fn decode_large_list_values() {
+            let decoder = decoder("boolean_large_list", true);
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Value::List(vec![
+                    Value::Bool(true),
+                    Value::Bool(false),
+                    Value::Bool(true),
+                ])
+            );
+            assert_eq!(decoder.decode(1).unwrap(), Value::Null);
+        }
+
+        #[test]
+        fn decode_large_list_view_values() {
+            let decoder = decoder("boolean_large_list_view", true);
+
+            assert_eq!(
+                decoder.decode(0).unwrap(),
+                Value::List(vec![
+                    Value::Bool(true),
+                    Value::Bool(false),
+                    Value::Bool(true),
+                ])
+            );
+            assert_eq!(decoder.decode(1).unwrap(), Value::Null);
+        }
+
+        #[test]
+        fn fail_to_decode_values_of_other_types() {
+            value_decoder(ValueType::Boolean, false, BINARY_RECORD_BATCH.column(0))
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod int_value_decoder {
+        use super::*;
+
+        fn decoder(column_name: &str) -> Box<dyn Decoder<Value>> {
+            value_decoder(
+                ValueType::Int,
+                false,
+                RECORD_BATCH.column_by_name(column_name).unwrap(),
+            )
+            .unwrap()
+        }
+
+        #[test]
+        fn decode_values() {
+            for column in [
+                "int8",
+                "int16",
+                "int32",
+                "int64",
+                "uint8",
+                "uint16",
+                "uint32",
+                "uint64",
+                "decimal128",
+                "decimal256",
+            ] {
+                let decoder = decoder(column);
+
+                assert_eq!(decoder.decode(0).unwrap(), Value::Int(10));
+                assert_eq!(decoder.decode(1).unwrap(), Value::Int(20));
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn fail_to_decode_values_of_other_types() {
+            value_decoder(ValueType::Int, false, BOOLEAN_RECORD_BATCH.column(0))
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod int8_value_decoder {
+        use super::*;
+
+        fn decoder(column_name: &str) -> Box<dyn Decoder<Value>> {
+            value_decoder(
+                ValueType::Int8,
+                false,
+                RECORD_BATCH.column_by_name(column_name).unwrap(),
+            )
+            .unwrap()
+        }
+
+        #[test]
+        fn decode_values() {
+            for column in [
+                "int8",
+                "int16",
+                "int32",
+                "int64",
+                "uint8",
+                "uint16",
+                "uint32",
+                "uint64",
+                "decimal128",
+                "decimal256",
+            ] {
+                let decoder = decoder(column);
+
+                assert_eq!(decoder.decode(0).unwrap(), Value::Int8(10));
+                assert_eq!(decoder.decode(1).unwrap(), Value::Int8(20));
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn fail_to_decode_values_of_other_types() {
+            value_decoder(ValueType::Int8, false, BOOLEAN_RECORD_BATCH.column(0))
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod big_int_value_decoder {
+        use super::*;
+
+        fn decoder(column_name: &str) -> Box<dyn Decoder<Value>> {
+            value_decoder(
+                ValueType::BigInt,
+                false,
+                RECORD_BATCH.column_by_name(column_name).unwrap(),
+            )
+            .unwrap()
+        }
+
+        #[test]
+        fn decode_values() {
+            for column in [
+                "int8",
+                "int16",
+                "int32",
+                "int64",
+                "uint8",
+                "uint16",
+                "uint32",
+                "uint64",
+                "decimal128",
+                "decimal256",
+            ] {
+                let decoder = decoder(column);
+
+                assert_eq!(decoder.decode(0).unwrap(), Value::BigInt(BigInt::from(10)));
+                assert_eq!(decoder.decode(1).unwrap(), Value::BigInt(BigInt::from(20)));
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn decode_values_from_numerical_strings() {
+            for column in ["utf8", "utf8_view", "large_utf8"] {
+                let decoder = decoder(column);
+
+                assert_eq!(decoder.decode(2).unwrap(), Value::BigInt(BigInt::from(30)));
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn fail_to_decode_values_from_non_numerical_strings() {
+            for column in ["utf8", "utf8_view", "large_utf8"] {
+                let decoder = decoder(column);
+
+                decoder.decode(0).unwrap_err();
+            }
+        }
+
+        #[test]
+        fn fail_to_decode_values_of_other_types() {
+            value_decoder(ValueType::BigInt, false, BOOLEAN_RECORD_BATCH.column(0))
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod big_decimal_value_decoder {
+        use super::*;
+
+        fn decoder(column_name: &str) -> Box<dyn Decoder<Value>> {
+            value_decoder(
+                ValueType::BigDecimal,
+                false,
+                RECORD_BATCH.column_by_name(column_name).unwrap(),
+            )
+            .unwrap()
+        }
+
+        #[test]
+        fn decode_values() {
+            for column in ["float16", "float32", "float64", "decimal128", "decimal256"] {
+                let decoder = decoder(column);
+
+                assert_eq!(
+                    decoder.decode(0).unwrap(),
+                    Value::BigDecimal(BigDecimal::from(10.0))
+                );
+                assert_eq!(
+                    decoder.decode(1).unwrap(),
+                    Value::BigDecimal(BigDecimal::from(20.0))
+                );
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn decode_values_from_numerical_strings() {
+            for column in ["utf8", "utf8_view", "large_utf8"] {
+                let decoder = decoder(column);
+
+                assert_eq!(
+                    decoder.decode(2).unwrap(),
+                    Value::BigDecimal(BigDecimal::from(30.0))
+                );
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn fail_to_decode_values_from_non_numerical_strings() {
+            for column in ["utf8", "utf8_view", "large_utf8"] {
+                let decoder = decoder(column);
+
+                decoder.decode(0).unwrap_err();
+            }
+        }
+
+        #[test]
+        fn fail_to_decode_values_of_other_types() {
+            value_decoder(ValueType::BigDecimal, false, BOOLEAN_RECORD_BATCH.column(0))
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod bytes_value_decoder {
+        use super::*;
+
+        fn decoder(column_name: &str) -> Box<dyn Decoder<Value>> {
+            value_decoder(
+                ValueType::Bytes,
+                false,
+                RECORD_BATCH.column_by_name(column_name).unwrap(),
+            )
+            .unwrap()
+        }
+
+        #[test]
+        fn decode_values() {
+            for column in ["binary", "binary_view", "fixed_size_binary", "large_binary"] {
+                let decoder = decoder(column);
+
+                assert_eq!(
+                    decoder.decode(0).unwrap(),
+                    Value::Bytes(b"aa".as_slice().into())
+                );
+                assert_eq!(
+                    decoder.decode(1).unwrap(),
+                    Value::Bytes(b"bb".as_slice().into())
+                );
+                assert_eq!(
+                    decoder.decode(2).unwrap(),
+                    Value::Bytes(b"cc".as_slice().into())
+                );
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn fail_to_decode_values_of_other_types() {
+            value_decoder(ValueType::Bytes, false, BOOLEAN_RECORD_BATCH.column(0))
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod string_value_decoder {
+        use super::*;
+
+        fn decoder(column_name: &str) -> Box<dyn Decoder<Value>> {
+            value_decoder(
+                ValueType::String,
+                false,
+                RECORD_BATCH.column_by_name(column_name).unwrap(),
+            )
+            .unwrap()
+        }
+
+        #[test]
+        fn decode_values_from_strings() {
+            for column in ["utf8", "utf8_view", "large_utf8"] {
+                let decoder = decoder(column);
+
+                assert_eq!(decoder.decode(0).unwrap(), Value::String("aa".to_string()));
+                assert_eq!(decoder.decode(1).unwrap(), Value::String("bb".to_string()));
+                assert_eq!(decoder.decode(2).unwrap(), Value::String("30".to_string()));
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn decode_values_from_numbers() {
+            for column in [
+                "int8",
+                "int16",
+                "int32",
+                "int64",
+                "uint8",
+                "uint16",
+                "uint32",
+                "uint64",
+                "decimal128",
+                "decimal256",
+            ] {
+                let decoder = decoder(column);
+
+                assert_eq!(decoder.decode(0).unwrap(), Value::String("10".to_string()));
+                assert_eq!(decoder.decode(1).unwrap(), Value::String("20".to_string()));
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn decode_values_from_bytes() {
+            for column in ["binary", "binary_view", "fixed_size_binary", "large_binary"] {
+                let decoder = decoder(column);
+
+                assert_eq!(
+                    decoder.decode(0).unwrap(),
+                    Value::String(format!("0x{}", hex::encode(b"aa")))
+                );
+                assert_eq!(
+                    decoder.decode(1).unwrap(),
+                    Value::String(format!("0x{}", hex::encode(b"bb")))
+                );
+                assert_eq!(
+                    decoder.decode(2).unwrap(),
+                    Value::String(format!("0x{}", hex::encode(b"cc")))
+                );
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn fail_to_decode_values_of_other_types() {
+            value_decoder(ValueType::String, false, BOOLEAN_RECORD_BATCH.column(0))
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+
+    mod timestamp_value_decoder {
+        use chrono::{TimeZone, Utc};
+
+        use super::*;
+
+        fn decoder(column_name: &str) -> Box<dyn Decoder<Value>> {
+            value_decoder(
+                ValueType::Timestamp,
+                false,
+                RECORD_BATCH.column_by_name(column_name).unwrap(),
+            )
+            .unwrap()
+        }
+
+        #[test]
+        fn decode_values() {
+            for column in [
+                "timestamp_second",
+                "timestamp_millisecond",
+                "timestamp_microsecond",
+                "timestamp_nanosecond",
+            ] {
+                let decoder = decoder(column);
+
+                assert_eq!(
+                    decoder.decode(0).unwrap(),
+                    Value::Timestamp(Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap().into())
+                );
+                assert_eq!(
+                    decoder.decode(1).unwrap(),
+                    Value::Timestamp(
+                        Utc.with_ymd_and_hms(2020, 10, 10, 10, 10, 10)
+                            .unwrap()
+                            .into()
+                    )
+                );
+                assert_eq!(
+                    decoder.decode(2).unwrap(),
+                    Value::Timestamp(
+                        Utc.with_ymd_and_hms(2020, 12, 31, 23, 59, 59)
+                            .unwrap()
+                            .into()
+                    )
+                );
+                assert_eq!(decoder.decode(3).unwrap(), Value::Null);
+            }
+        }
+
+        #[test]
+        fn fail_to_decode_values_of_other_types() {
+            value_decoder(ValueType::Timestamp, false, BOOLEAN_RECORD_BATCH.column(0))
+                .map(|_| ())
+                .unwrap_err();
+        }
+    }
+}
diff --git a/graph/src/amp/common/mod.rs b/graph/src/amp/common/mod.rs
new file mode 100644
index 00000000000..9c4f5e71813
--- /dev/null
+++ b/graph/src/amp/common/mod.rs
@@ -0,0 +1,25 @@
+// TODO: Remove this once there is a better way to get this information from Amp servers.
+pub(super) mod column_aliases {
+    pub(in crate::amp) static BLOCK_NUMBER: &[&str] = &[
+        "_block_num",   // Meta column present in all tables
+        "block_num",    // Standard column in most raw tables
+        "blockNum",     // Common alternative name
+        "blocknum",     // Common alternative name
+        "block",        // Common alternative name
+        "block_number", // Common alternative name
+        "blockNumber",  // Common alternative name
+        "blocknumber",  // Common alternative name
+    ];
+    pub(in crate::amp) static BLOCK_HASH: &[&str] = &[
+        "hash",       // Standard column in some raw tables
+        "block_hash", // Standard column in most raw tables and common alternative name
+        "blockHash",  // Common alternative name
+        "blockhash",  // Common alternative name
+    ];
+    pub(in crate::amp) static BLOCK_TIMESTAMP: &[&str] = &[
+        "timestamp",       // Standard column in most raw tables
+        "block_timestamp", // Common alternative name
+        "blockTimestamp",  // Common alternative name
+        "blocktimestamp",  // Common alternative name
+    ];
+}
diff --git a/graph/src/amp/error.rs b/graph/src/amp/error.rs
new file mode 100644
index 00000000000..3489d7a94de
--- /dev/null
+++ b/graph/src/amp/error.rs
@@ -0,0 +1,5 @@
+/// Checks whether errors are deterministic.
+pub trait IsDeterministic {
+    /// Returns `true` if the error is deterministic.
+    fn is_deterministic(&self) -> bool;
+}
diff --git a/graph/src/amp/log.rs b/graph/src/amp/log.rs
new file mode 100644
index 00000000000..e11c129b6b7
--- /dev/null
+++ b/graph/src/amp/log.rs
@@ -0,0 +1,20 @@
+use std::borrow::Cow;
+
+use lazy_regex::regex_replace_all;
+
+/// Extends the [slog::Logger] with methods commonly used in Amp modules
+pub trait Logger {
+    /// Creates a new child logger scoped to a specific component
+    fn component(&self, name: &'static str) -> slog::Logger;
+}
+
+impl Logger for slog::Logger {
+    fn component(&self, name: &'static str) -> slog::Logger {
+        self.new(slog::o!("component" => name))
+    }
+}
+
+/// Removes newlines and extra spaces from a string
+pub fn one_line<'a>(s: &'a str) -> Cow<'a, str> {
+    regex_replace_all!(r"(\\r)?(\\n)?\s+", s, " ")
+}
diff --git a/graph/src/amp/manifest/data_source/mod.rs b/graph/src/amp/manifest/data_source/mod.rs
new file mode 100644
index 00000000000..eb0575fdbf4
--- /dev/null
+++ b/graph/src/amp/manifest/data_source/mod.rs
@@ -0,0 +1,112 @@
+pub mod raw;
+
+use alloy::{
+    json_abi::JsonAbi,
+    primitives::{Address, BlockNumber},
+};
+use arrow::datatypes::Schema;
+use semver::Version;
+
+use crate::{amp::sql::BlockRangeQueryBuilder, data::subgraph::SPEC_VERSION_1_5_0};
+
+pub use self::raw::RawDataSource;
+
+/// Represents a valid data source of an Amp subgraph.
+///
+/// This data source contains parsed, formatted, and resolved data.
+#[derive(Debug, Clone)]
+pub struct DataSource {
+    /// The name of the data source.
+    ///
+    /// Used for observability to identify progress and errors produced by this data source.
+    pub name: String,
+
+    /// The network name of the data source.
+    pub network: String,
+
+    /// Contains the sources used by this data source.
+    pub source: Source,
+
+    /// Contains the transformations of source tables indexed by the subgraph.
+    pub transformer: Transformer,
+}
+
+impl DataSource {
+    pub const KIND: &str = "amp";
+    pub const MIN_SPEC_VERSION: Version = SPEC_VERSION_1_5_0;
+}
+
+/// Contains the sources that a data source uses.
+#[derive(Debug, Clone)]
+pub struct Source {
+    /// The dataset from which SQL queries in the data source can query.
+    pub dataset: String,
+
+    /// The tables from which SQL queries in the data source can query.
+    pub tables: Vec<String>,
+
+    /// The contract address with which SQL queries in the data source interact.
+    ///
+    /// This address enables SQL query reuse through `sg_source_address()` calls instead of hard-coding the contract address.
+    /// The `sg_source_address()` calls in SQL queries of the data source resolve to this contract address.
+    ///
+    /// SQL queries are not limited to using only this contract address.
+    ///
+    /// Defaults to an empty contract address.
+    pub address: Address,
+
+    /// The minimum block number that SQL queries in the data source can query.
+    ///
+    /// Defaults to the minimum possible block number.
+    pub start_block: BlockNumber,
+
+    /// The maximum block number that SQL queries in the data source can query.
+    ///
+    /// Defaults to the maximum possible block number.
+    pub end_block: BlockNumber,
+}
+
+/// Contains the transformations of source tables indexed by the subgraph.
+#[derive(Debug, Clone)]
+pub struct Transformer {
+    /// The version of this transformer.
+    pub api_version: Version,
+
+    /// The ABIs that SQL queries can reference to extract event signatures.
+    ///
+    /// The `sg_event_signature('CONTRACT_NAME', 'EVENT_NAME')` calls in the
+    /// SQL queries resolve to a full event signature based on this list.
+    pub abis: Vec<Abi>,
+
+    /// The transformed tables that extract data from source tables for indexing.
+    pub tables: Vec<Table>,
+}
+
+/// Represents an ABI of a smart contract.
+#[derive(Debug, Clone)]
+pub struct Abi {
+    /// The name of the contract.
+    pub name: String,
+
+    /// The JSON ABI of the contract.
+    pub contract: JsonAbi,
+}
+
+/// Represents a transformed table that extracts data from source tables for indexing.
+#[derive(Debug, Clone)]
+pub struct Table {
+    /// The name of the transformed table.
+    ///
+    /// Must reference a valid entity name from the subgraph schema.
+    pub name: String,
+
+    /// The SQL query that executes on the Amp server.
+    ///
+    /// The data resulting from this SQL query execution transforms into subgraph entities.
+    pub query: BlockRangeQueryBuilder,
+
+    /// The Arrow schema of this transformed table SQL query.
+    ///
+    /// This schema loads from the Amp server.
+    pub schema: Schema,
+}
diff --git a/graph/src/amp/manifest/data_source/raw.rs b/graph/src/amp/manifest/data_source/raw.rs
new file mode 100644
index 00000000000..91d792293be
--- /dev/null
+++ b/graph/src/amp/manifest/data_source/raw.rs
@@ -0,0 +1,713 @@
+use std::{collections::HashSet, sync::LazyLock};
+
+use alloy::{
+    json_abi::JsonAbi,
+    primitives::{Address, BlockNumber},
+};
+use anyhow::anyhow;
+use arrow::{array::RecordBatch, datatypes::Schema};
+use futures03::future::try_join_all;
+use itertools::Itertools;
+use lazy_regex::regex_is_match;
+use semver::Version;
+use serde::Deserialize;
+use slog::{Logger, debug, error};
+use thiserror::Error;
+
+use super::{Abi, DataSource, Source, Table, Transformer};
+use crate::{
+    amp::{
+        self,
+        codec::utils::{
+            auto_block_hash_decoder, auto_block_number_decoder, auto_block_timestamp_decoder,
+        },
+        error::IsDeterministic,
+        sql::{BlockRangeQueryBuilder, ContextQuery, ValidQuery},
+    },
+    components::link_resolver::{LinkResolver, LinkResolverContext},
+    data::subgraph::DeploymentHash,
+    schema::InputSchema,
+};
+
+/// Supported API versions for data source transformers.
+static API_VERSIONS: LazyLock<HashSet<Version>> =
+    LazyLock::new(|| HashSet::from([Version::new(0, 0, 1)]));
+
+/// Represents an unmodified input data source of an Amp subgraph.
+///
+/// May contain invalid or partial data.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RawDataSource {
+    /// The name of the data source.
+    ///
+    /// Must be a valid, non-empty identifier with no spaces or special characters.
+    pub name: String,
+
+    /// The kind of the data source.
+    ///
+    /// Must be equal to `amp`.
+    pub kind: String,
+
+    /// The network name of the data source.
+    pub network: String,
+
+    /// Contains sources used by this data source.
+    pub source: RawSource,
+
+    /// Contains transformations of source tables indexed by the subgraph.
+    pub transformer: RawTransformer,
+}
+
+impl RawDataSource {
+    /// Parses, formats, and resolves the input data source into a valid data source.
+    pub async fn resolve(
+        self,
+        logger: &Logger,
+        link_resolver: &dyn LinkResolver,
+        amp_client: &impl amp::Client,
+        input_schema: Option<&InputSchema>,
+    ) -> Result<DataSource, Error> {
+        let Self {
+            name,
+            kind,
+            network,
+            source,
+            transformer,
+        } = self;
+
+        let logger = logger.new(slog::o!("data_source" => name.clone()));
+        debug!(logger, "Resolving data source");
+
+        validate_ident(&name).map_err(|e| e.source_context("invalid `name`"))?;
+        Self::validate_kind(kind)?;
+
+        let source = source
+            .resolve()
+            .map_err(|e| e.source_context("invalid `source`"))?;
+
+        let transformer = transformer
+            .resolve(&logger, link_resolver, amp_client, input_schema, &source)
+            .await
+            .map_err(|e| e.source_context("invalid `transformer`"))?;
+
+        Ok(DataSource {
+            name,
+            network,
+            source,
+            transformer,
+        })
+    }
+
+    fn validate_kind(kind: String) -> Result<(), Error> {
+        if !kind.eq_ignore_ascii_case(DataSource::KIND) {
+            return Err(Error::InvalidValue(anyhow!("invalid `kind`")));
+        }
+
+        Ok(())
+    }
+}
+
+/// Contains an unmodified input source used by the data source.
+///
+/// May contain invalid or partial data.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RawSource {
+    /// The dataset that SQL queries in the data source can query.
+    ///
+    /// Must reference a valid dataset name from the Amp server.
+    pub dataset: String,
+
+    /// The tables that SQL queries in the data source can query.
+    ///
+    /// Must reference valid table names of the dataset from the Amp server.
+    pub tables: Vec<String>,
+
+    /// The contract address used by SQL queries in the data source.
+    ///
+    /// Enables SQL query reuse through `sg_source_address()` calls instead of hard-coding the contract address.
+    /// SQL queries resolve `sg_source_address()` calls to this contract address.
+    pub address: Option<Address>,
+
+    /// The minimum block number that SQL queries in the data source can query.
+    pub start_block: Option<BlockNumber>,
+
+    /// The maximum block number that SQL queries in the data source can query.
+    pub end_block: Option<BlockNumber>,
+}
+
+impl RawSource {
+    /// Parses, formats, and resolves the input source into a valid source.
+    fn resolve(self) -> Result<Source, Error> {
+        let Self {
+            dataset,
+            tables,
+            address,
+            start_block,
+            end_block,
+        } = self;
+
+        if dataset.is_empty() {
+            return Err(Error::InvalidValue(anyhow!("`dataset` cannot be empty")));
+        }
+        Self::validate_tables(&tables)?;
+
+        let dataset = normalize_sql_ident(&dataset);
+        let tables = tables
+            .into_iter()
+            .map(|table| normalize_sql_ident(&table))
+            .collect_vec();
+
+        let address = address.unwrap_or(Address::ZERO);
+        let start_block = start_block.unwrap_or(BlockNumber::MIN);
+        let end_block = end_block.unwrap_or(BlockNumber::MAX);
+
+        if start_block >= end_block {
+            return Err(Error::InvalidValue(anyhow!(
+                "`end_block` must be greater than `start_block`"
+            )));
+        }
+
+        Ok(Source {
+            dataset,
+            tables,
+            address,
+            start_block,
+            end_block,
+        })
+    }
+
+    fn validate_tables(tables: &[String]) -> Result<(), Error> {
+        const MAX_TABLES: usize = 100;
+
+        if tables.is_empty() {
+            return Err(Error::InvalidValue(anyhow!("`tables` cannot be empty")));
+        }
+
+        if tables.len() > MAX_TABLES {
+            return Err(Error::InvalidValue(anyhow!(
+                "`tables` cannot have more than {MAX_TABLES} tables"
+            )));
+        }
+
+        for (i, table) in tables.iter().enumerate() {
+            if table.is_empty() {
+                return Err(Error::InvalidValue(anyhow!(
+                    "`table` at index {i} cannot be empty"
+                )));
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// Contains unmodified input transformations of source tables indexed by the subgraph.
+///
+/// May contain invalid or partial data.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RawTransformer {
+    /// The version of this transformer.
+    ///
+    /// Must be a supported API version of the Amp subgraph transformers API.
+    pub api_version: Version,
+
+    /// The ABIs that SQL queries can reference to extract event signatures.
+    ///
+    /// SQL queries resolve `sg_event_signature('CONTRACT_NAME', 'EVENT_NAME')` calls
+    /// to full event signatures based on this list.
+    pub abis: Option<Vec<RawAbi>>,
+
+    /// The transformed tables that extract data from source tables for indexing.
+    pub tables: Vec<RawTable>,
+}
+
+impl RawTransformer {
+    /// Parses, formats, and resolves the input transformer into a valid transformer.
+    async fn resolve(
+        self,
+        logger: &Logger,
+        link_resolver: &dyn LinkResolver,
+        amp_client: &impl amp::Client,
+        input_schema: Option<&InputSchema>,
+        source: &Source,
+    ) -> Result<Transformer, Error> {
+        let Self {
+            api_version,
+            abis,
+            tables,
+        } = self;
+        Self::validate_api_version(&api_version)?;
+
+        let abis = Self::resolve_abis(logger, link_resolver, abis).await?;
+        let tables = Self::resolve_tables(
+            logger,
+            link_resolver,
+            amp_client,
+            input_schema,
+            tables,
+            source,
+            &abis,
+        )
+        .await?;
+
+        Ok(Transformer {
+            api_version,
+            abis,
+            tables,
+        })
+    }
+
+    fn validate_api_version(api_version: &Version) -> Result<(), Error> {
+        if !API_VERSIONS.contains(api_version) {
+            return Err(Error::InvalidValue(anyhow!("invalid `api_version`")));
+        }
+
+        Ok(())
+    }
+
+    async fn resolve_abis(
+        logger: &Logger,
+        link_resolver: &dyn LinkResolver,
+        abis: Option<Vec<RawAbi>>,
+    ) -> Result<Vec<Abi>, Error> {
+        const MAX_ABIS: usize = 100;
+
+        let Some(abis) = abis else {
+            return Ok(Vec::new());
+        };
+
+        if abis.len() > MAX_ABIS {
+            return Err(Error::InvalidValue(anyhow!(
+                "`abis` cannot have more than {MAX_ABIS} ABIs"
+            )));
+        }
+
+        let abi_futs = abis.into_iter().enumerate().map(|(i, abi)| async move {
+            let logger = logger.new(slog::o!("abi_name" => abi.name.clone()));
+            debug!(logger, "Resolving ABI";
+                "file" => &abi.file,
+            );
+
+            abi.resolve(&logger, link_resolver)
+                .await
+                .map_err(|e| e.source_context(format!("invalid `abis` at index {i}")))
+        });
+
+        try_join_all(abi_futs).await
+    }
+
+    async fn resolve_tables(
+        logger: &Logger,
+        link_resolver: &dyn LinkResolver,
+        amp_client: &impl amp::Client,
+        input_schema: Option<&InputSchema>,
+        tables: Vec<RawTable>,
+        source: &Source,
+        abis: &[Abi],
+    ) -> Result<Vec<Table>, Error> {
+        const MAX_TABLES: usize = 100;
+
+        if tables.is_empty() {
+            return Err(Error::InvalidValue(anyhow!("`tables` cannot be empty")));
+        }
+
+        if tables.len() > MAX_TABLES {
+            return Err(Error::InvalidValue(anyhow!(
+                "`tables` cannot have more than {MAX_TABLES} tables"
+            )));
+        }
+
+        let table_futs = tables.into_iter().enumerate().map(|(i, table)| async move {
+            let logger = logger.new(slog::o!("table_name" => table.name.clone()));
+            debug!(logger, "Resolving table";
+                "file" => ?&table.file
+            );
+
+            table
+                .resolve(
+                    &logger,
+                    link_resolver,
+                    amp_client,
+                    input_schema,
+                    source,
+                    abis,
+                )
+                .await
+                .map_err(|e| e.source_context(format!("invalid `tables` at index {i}")))
+        });
+
+        try_join_all(table_futs).await
+    }
+}
+
+/// Represents an unmodified input ABI of a smart contract.
+///
+/// May contain invalid or partial data.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RawAbi {
+    /// The name of the contract.
+    pub name: String,
+
+    /// The IPFS link to the JSON ABI of the contract.
+    pub file: String,
+}
+
+impl RawAbi {
+    /// Parses, formats, and resolves the input ABI into a valid ABI.
+    async fn resolve(
+        self,
+        logger: &Logger,
+        link_resolver: &dyn LinkResolver,
+    ) -> Result<Abi, Error> {
+        let Self { name, file } = self;
+
+        validate_ident(&name).map_err(|e| e.source_context("invalid `name`"))?;
+        let contract = Self::resolve_contract(logger, link_resolver, file).await?;
+
+        Ok(Abi { name, contract })
+    }
+
+    async fn resolve_contract(
+        logger: &Logger,
+        link_resolver: &dyn LinkResolver,
+        file: String,
+    ) -> Result<JsonAbi, Error> {
+        if file.is_empty() {
+            return Err(Error::InvalidValue(anyhow!("`file` cannot be empty")));
+        }
+
+        let file_bytes = link_resolver
+            .cat(
+                &LinkResolverContext::new(&DeploymentHash::default(), logger),
+                &(file.into()),
+            )
+            .await
+            .map_err(|e| Error::FailedToResolveFile(e.context("invalid `file`")))?;
+
+        let contract: JsonAbi = serde_json::from_slice(&file_bytes)
+            .map_err(|e| Error::InvalidValue(anyhow!(e).context("invalid `file`")))?;
+
+        Ok(contract)
+    }
+}
+
+/// Represents an unmodified input transformed table that extracts data from source tables for indexing.
+///
+/// May contain invalid or partial data.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RawTable {
+    /// The name of the transformed table.
+    ///
+    /// Must reference a valid entity name from the subgraph schema.
+    pub name: String,
+
+    /// The SQL query that executes on the Amp server.
+    ///
+    /// Transforms the execution results into subgraph entities.
+    pub query: Option<String>,
+
+    /// The IPFS link to the SQL query that executes on the Amp server.
+    ///
+    /// Transforms the execution results into subgraph entities.
+    ///
+    /// Ignored when `query` is set.
+    pub file: Option<String>,
+}
+
+impl RawTable {
+    /// Parses, formats, and resolves the input table into a valid transformed table.
+    async fn resolve(
+        self,
+        logger: &Logger,
+        link_resolver: &dyn LinkResolver,
+        amp_client: &impl amp::Client,
+        input_schema: Option<&InputSchema>,
+        source: &Source,
+        abis: &[Abi],
+    ) -> Result<Table, Error> {
+        let Self { name, query, file } = self;
+
+        validate_ident(&name).map_err(|e| e.source_context("invalid `name`"))?;
+        let query = match Self::resolve_query(query, source, abis)? {
+            Some(query) => query,
+            None => Self::resolve_file(logger, link_resolver, file, source, abis).await?,
+        };
+
+        debug!(logger, "Resolving query schema");
+        let schema = Self::resolve_schema(logger, amp_client, &query).await?;
+
+        for field in schema.fields() {
+            validate_ident(field.name()).map_err(|e| {
+                e.source_context(format!(
+                    "invalid query output schema: invalid column '{}'",
+                    field.name()
+                ))
+            })?;
+        }
+
+        let block_range_query_builder = Self::resolve_block_range_query_builder(
+            logger,
+            amp_client,
+            input_schema,
+            source,
+            query,
+            schema.clone(),
+        )
+        .await?;
+
+        Ok(Table {
+            name,
+            query: block_range_query_builder,
+            schema,
+        })
+    }
+
+    fn resolve_query(
+        query: Option<String>,
+        source: &Source,
+        abis: &[Abi],
+    ) -> Result<Option<ValidQuery>, Error> {
+        let Some(query) = query else {
+            return Ok(None);
+        };
+
+        if query.is_empty() {
+            return Err(Error::InvalidValue(anyhow!("`query` cannot be empty")));
+        }
+
+        ValidQuery::new(
+            &query,
+            source.dataset.as_str(),
+            source.tables.iter().map(|table| table.as_str()),
+            &source.address,
+            abis.iter().map(|abi| (abi.name.as_str(), &abi.contract)),
+        )
+        .map(Some)
+        .map_err(|e| Error::InvalidValue(e.context("invalid `query`")))
+    }
+
+    async fn resolve_file(
+        logger: &Logger,
+        link_resolver: &dyn LinkResolver,
+        file: Option<String>,
+        source: &Source,
+        abis: &[Abi],
+    ) -> Result<ValidQuery, Error> {
+        debug!(logger, "Resolving query file");
+
+        let Some(file) = file else {
+            return Err(Error::InvalidValue(anyhow!("`file` cannot be empty")));
+        };
+
+        if file.is_empty() {
+            return Err(Error::InvalidValue(anyhow!("`file` cannot be empty")));
+        }
+
+        let file_bytes = link_resolver
+            .cat(
+                &LinkResolverContext::new(&DeploymentHash::default(), logger),
+                &(file.into()),
+            )
+            .await
+            .map_err(|e| Error::FailedToResolveFile(e.context("invalid `file`")))?;
+
+        let query = String::from_utf8(file_bytes)
+            .map_err(|e| Error::InvalidValue(anyhow!(e).context("invalid `file`")))?;
+
+        if query.is_empty() {
+            return Err(Error::InvalidValue(anyhow!("`file` cannot be empty")));
+        }
+
+        ValidQuery::new(
+            &query,
+            source.dataset.as_str(),
+            source.tables.iter().map(|table| table.as_str()),
+            &source.address,
+            abis.iter().map(|abi| (abi.name.as_str(), &abi.contract)),
+        )
+        .map_err(|e| Error::InvalidValue(e.context("invalid `file`")))
+    }
+
+    async fn resolve_schema(
+        logger: &Logger,
+        amp_client: &impl amp::Client,
+        query: impl ToString,
+    ) -> Result<Schema, Error> {
+        amp_client
+            .schema(logger, query)
+            .await
+            .map_err(|e| Error::FailedToExecuteQuery {
+                is_deterministic: e.is_deterministic(),
+                source: anyhow!(e).context("failed to load schema"),
+            })
+    }
+
+    async fn resolve_block_range_query_builder(
+        logger: &Logger,
+        amp_client: &impl amp::Client,
+        input_schema: Option<&InputSchema>,
+        source: &Source,
+        query: ValidQuery,
+        schema: Schema,
+    ) -> Result<BlockRangeQueryBuilder, Error> {
+        debug!(logger, "Resolving block range query builder");
+
+        let record_batch = RecordBatch::new_empty(schema.into());
+        let (block_number_column, _) =
+            auto_block_number_decoder(&record_batch).map_err(Error::InvalidQuery)?;
+
+        let need_block_hash_column = auto_block_hash_decoder(&record_batch).is_err();
+        let need_block_timestamp_column = input_schema
+            .map(|input_schema| input_schema.has_aggregations())
+            .unwrap_or(false)
+            && auto_block_timestamp_decoder(&record_batch).is_err();
+
+        if !need_block_hash_column && !need_block_timestamp_column {
+            return Ok(BlockRangeQueryBuilder::new(query, block_number_column));
+        }
+
+        debug!(logger, "Resolving context query");
+        let mut context_query: Option<ContextQuery> = None;
+
+        // TODO: Context is embedded in the original query using INNER JOIN to ensure availability for every output row.
+        //       This requires all source tables to match or exceed the expected query output size.
+        let context_sources_iter = source
+            .tables
+            .iter()
+            .map(|table| (source.dataset.as_str(), table.as_str()));
+
+        for (dataset, table) in context_sources_iter {
+            let context_logger = logger.new(slog::o!(
+                "context_dataset" => dataset.to_string(),
+                "context_table" => table.to_string()
+            ));
+            debug!(context_logger, "Loading context schema");
+            let schema_query = format!("SELECT * FROM {dataset}.{table}");
+            let schema = match Self::resolve_schema(logger, amp_client, schema_query).await {
+                Ok(schema) => schema,
+                Err(e) => {
+                    error!(context_logger, "Failed to load context schema";
+                        "e" => ?e
+                    );
+                    continue;
+                }
+            };
+
+            let record_batch = RecordBatch::new_empty(schema.clone().into());
+            let mut columns = Vec::new();
+
+            if need_block_hash_column {
+                let Ok((block_hash_column, _)) = auto_block_hash_decoder(&record_batch) else {
+                    debug!(
+                        context_logger,
+                        "Context schema does not contain block hash column, skipping"
+                    );
+                    continue;
+                };
+
+                columns.push(block_hash_column);
+            }
+
+            if need_block_timestamp_column {
+                let Ok((block_timestamp_column, _)) = auto_block_timestamp_decoder(&record_batch)
+                else {
+                    debug!(
+                        context_logger,
+                        "Context schema does not contain block timestamp column, skipping"
+                    );
+                    continue;
+                };
+
+                columns.push(block_timestamp_column);
+            }
+
+            debug!(context_logger, "Creating context query");
+            context_query = Some(ContextQuery::new(
+                query,
+                block_number_column,
+                dataset,
+                table,
+                columns,
+            ));
+            break;
+        }
+
+        if let Some(context_query) = context_query {
+            return Ok(BlockRangeQueryBuilder::new_with_context(context_query));
+        }
+
+        Err(Error::InvalidQuery(anyhow!(
+            "query is required to output block numbers, block hashes and block timestamps"
+        )))
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("invalid value: {0:#}")]
+    InvalidValue(#[source] anyhow::Error),
+
+    #[error("invalid query: {0:#}")]
+    InvalidQuery(#[source] anyhow::Error),
+
+    #[error("failed to resolve file: {0:#}")]
+    FailedToResolveFile(#[source] anyhow::Error),
+
+    #[error("failed to execute query: {source:#}")]
+    FailedToExecuteQuery {
+        source: anyhow::Error,
+        is_deterministic: bool,
+    },
+}
+
+impl Error {
+    /// Extends the source errors with additional context keeping the original error kind and the determinism.
+    fn source_context(self, cx: impl Into<String>) -> Self {
+        match self {
+            Self::InvalidValue(e) => Self::InvalidValue(e.context(cx.into())),
+            Self::InvalidQuery(e) => Self::InvalidQuery(e.context(cx.into())),
+            Self::FailedToResolveFile(e) => Self::FailedToResolveFile(e.context(cx.into())),
+            Self::FailedToExecuteQuery {
+                source,
+                is_deterministic,
+            } => Self::FailedToExecuteQuery {
+                source: source.context(cx.into()),
+                is_deterministic,
+            },
+        }
+    }
+}
+
+impl IsDeterministic for Error {
+    fn is_deterministic(&self) -> bool {
+        match self {
+            Self::InvalidValue(_) => true,
+            Self::InvalidQuery(_) => true,
+            Self::FailedToResolveFile(_) => false,
+            Self::FailedToExecuteQuery {
+                is_deterministic, ..
+            } => *is_deterministic,
+        }
+    }
+}
+
+fn validate_ident(s: &str) -> Result<(), Error> {
+    if !regex_is_match!("^[a-zA-Z_][a-zA-Z0-9_-]{0,100}$", s) {
+        return Err(Error::InvalidValue(anyhow!(
+            "invalid identifier '{s}': must start with a letter or an underscore, and contain only letters, numbers, hyphens, and underscores"
+        )));
+    }
+    Ok(())
+}
+
+fn normalize_sql_ident(s: &str) -> String {
+    match validate_ident(s) {
+        Ok(()) => s.to_lowercase(),
+        Err(_e) => sqlparser_latest::ast::Ident::with_quote('"', s).to_string(),
+    }
+}
diff --git a/graph/src/amp/manifest/mod.rs b/graph/src/amp/manifest/mod.rs
new file mode 100644
index 00000000000..520f2ebcee5
--- /dev/null
+++ b/graph/src/amp/manifest/mod.rs
@@ -0,0 +1,99 @@
+pub mod data_source;
+
+use std::sync::Arc;
+
+use anyhow::{Context, Result, bail};
+use itertools::Itertools;
+use semver::Version;
+use slog::Logger;
+
+use crate::{
+    amp::Client,
+    blockchain::Blockchain,
+    cheap_clone::CheapClone as _,
+    components::link_resolver::LinkResolver,
+    data::subgraph::{BaseSubgraphManifest, DeploymentHash, UnresolvedSubgraphManifest},
+    data_source::DataSource as GenericDataSource,
+    schema::InputSchema,
+};
+
+pub use self::data_source::DataSource;
+
+/// Represents a valid Amp subgraph manifest.
+///
+/// This manifest contains parsed, formatted, and resolved data.
+#[derive(Debug, Clone)]
+pub struct Manifest {
+    /// The schema of the subgraph.
+    ///
+    /// Contains all the entities, aggregations, and relationships between them.
+    pub schema: InputSchema,
+
+    /// The Amp data sources of the subgraph.
+    ///
+    /// An Amp subgraph can only contain Amp data sources.
+    pub data_sources: Vec<DataSource>,
+}
+
+impl Manifest {
+    /// Resolves and returns a valid Amp subgraph manifest.
+    pub async fn resolve<C: Blockchain, AC: Client>(
+        logger: &Logger,
+        link_resolver: Arc<dyn LinkResolver>,
+        amp_client: Arc<AC>,
+        max_spec_version: Version,
+        deployment: DeploymentHash,
+        raw_manifest: serde_yaml::Mapping,
+    ) -> Result<Self> {
+        let unresolved_manifest =
+            UnresolvedSubgraphManifest::<C>::parse(deployment.cheap_clone(), raw_manifest)
+                .context("failed to parse subgraph manifest")?;
+
+        let resolved_manifest = unresolved_manifest
+            .resolve(
+                &deployment,
+                &link_resolver,
+                Some(amp_client),
+                logger,
+                max_spec_version,
+            )
+            .await
+            .context("failed to resolve subgraph manifest")?;
+
+        let BaseSubgraphManifest {
+            id: _,
+            spec_version: _,
+            features: _,
+            description: _,
+            repository: _,
+            schema,
+            data_sources,
+            graft: _,
+            templates: _,
+            chain: _,
+            indexer_hints: _,
+        } = resolved_manifest;
+
+        let data_sources_count = data_sources.len();
+        let amp_data_sources = data_sources
+            .into_iter()
+            .filter_map(|data_source| match data_source {
+                GenericDataSource::Amp(amp_data_source) => Some(amp_data_source),
+                _ => None,
+            })
+            .collect_vec();
+
+        if amp_data_sources.is_empty() {
+            bail!("invalid subgraph manifest: failed to find Amp data sources");
+        }
+
+        if amp_data_sources.len() != data_sources_count {
+            bail!("invalid subgraph manifest: only Amp data sources are allowed");
+        }
+
+        Ok(Self {
+            schema,
+            data_sources: amp_data_sources,
+        })
+    }
+}
diff --git a/graph/src/amp/mod.rs b/graph/src/amp/mod.rs
new file mode 100644
index 00000000000..21f3e064c58
--- /dev/null
+++ b/graph/src/amp/mod.rs
@@ -0,0 +1,17 @@
+//! This module contains the functionality required to support Amp subgraphs.
+
+pub mod client;
+pub mod codec;
+pub mod common;
+pub mod error;
+pub mod log;
+pub mod manifest;
+pub mod schema;
+pub mod sql;
+pub mod stream_aggregator;
+
+pub use self::{
+    client::{Client, flight_client::FlightClient},
+    codec::Codec,
+    manifest::Manifest,
+};
diff --git a/graph/src/amp/schema/generator/entity.rs b/graph/src/amp/schema/generator/entity.rs
new file mode 100644
index 00000000000..5655df21a48
--- /dev/null
+++ b/graph/src/amp/schema/generator/entity.rs
@@ -0,0 +1,172 @@
+use std::fmt;
+
+use anyhow::{Context, Result, bail};
+use inflector::Inflector;
+
+use crate::data::store::ValueType;
+
+/// A minimal representation of a subgraph entity.
+pub(super) struct SchemaEntity {
+    name: String,
+    fields: Vec<SchemaField>,
+}
+
+impl SchemaEntity {
+    /// Converts the Arrow schema to a subgraph entity.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if Arrow fields cannot be converted to subgraph entity fields.
+    ///
+    /// The returned error is deterministic.
+    pub(super) fn new(name: String, arrow_schema: arrow::datatypes::Schema) -> Result<Self> {
+        let mut fields = arrow_schema
+            .fields()
+            .iter()
+            .map(|field| {
+                SchemaField::new(field)
+                    .with_context(|| format!("failed to create field '{}'", field.name()))
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        if !fields
+            .iter()
+            .any(|field| field.name.as_str().eq_ignore_ascii_case("id"))
+        {
+            fields.push(SchemaField::id());
+        }
+
+        fields.sort_unstable_by_key(|field| field.name.clone());
+
+        Ok(Self { name, fields })
+    }
+}
+
+impl fmt::Display for SchemaEntity {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write! {f, "type {} @entity(immutable: true)", self.name.to_pascal_case()}?;
+        writeln! {f, " {{"}?;
+        for field in &self.fields {
+            writeln! {f, "\t{field}"}?;
+        }
+        write! {f, "}}"}
+    }
+}
+
+/// A minimal representation of a subgraph entity field.
+struct SchemaField {
+    name: String,
+    value_type: ValueType,
+    is_list: bool,
+    is_required: bool,
+}
+
+impl SchemaField {
+    /// Converts the Arrow field to a subgraph entity field.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The Arrow field has an invalid name
+    /// - The Arrow field type cannot be converted to a subgraph entity value type
+    ///
+    /// The returned error is deterministic.
+    fn new(arrow_field: &arrow::datatypes::Field) -> Result<Self> {
+        let name = arrow_field.name().to_string();
+        let (value_type, is_list) = arrow_data_type_to_value_type(arrow_field.data_type())?;
+        let is_required = !arrow_field.is_nullable();
+
+        Ok(Self {
+            name,
+            value_type,
+            is_list,
+            is_required,
+        })
+    }
+
+    /// Creates an `ID` subgraph entity field.
+    fn id() -> Self {
+        Self {
+            name: "id".to_string(),
+            value_type: ValueType::Bytes,
+            is_list: false,
+            is_required: true,
+        }
+    }
+}
+
+impl fmt::Display for SchemaField {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write! {f, "{}: ", self.name.to_camel_case()}?;
+        if self.is_list {
+            write! {f, "["}?;
+        }
+        write! {f, "{}", self.value_type.to_str()}?;
+        if self.is_list {
+            write! {f, "]"}?;
+        }
+        if self.is_required {
+            write! {f, "!"}?;
+        }
+        Ok(())
+    }
+}
+
+fn arrow_data_type_to_value_type(
+    data_type: &arrow::datatypes::DataType,
+) -> Result<(ValueType, bool)> {
+    use arrow::datatypes::DataType::*;
+
+    let type_not_supported = || bail!("type '{data_type}' not supported");
+    let value_type = match data_type {
+        Null => return type_not_supported(),
+        Boolean => ValueType::Boolean,
+        Int8 => ValueType::Int,
+        Int16 => ValueType::Int,
+        Int32 => ValueType::Int,
+        Int64 => ValueType::Int8,
+        UInt8 => ValueType::Int,
+        UInt16 => ValueType::Int,
+        UInt32 => ValueType::Int8,
+        UInt64 => ValueType::BigInt,
+        Float16 => ValueType::BigDecimal,
+        Float32 => ValueType::BigDecimal,
+        Float64 => ValueType::BigDecimal,
+        Timestamp(_, _) => ValueType::Timestamp,
+        Date32 => ValueType::Timestamp,
+        Date64 => ValueType::Timestamp,
+        Time32(_) => return type_not_supported(),
+        Time64(_) => return type_not_supported(),
+        Duration(_) => return type_not_supported(),
+        Interval(_) => return type_not_supported(),
+        Binary => ValueType::Bytes,
+        FixedSizeBinary(_) => ValueType::Bytes,
+        LargeBinary => ValueType::Bytes,
+        BinaryView => ValueType::Bytes,
+        Utf8 => ValueType::String,
+        LargeUtf8 => ValueType::String,
+        Utf8View => ValueType::String,
+        List(field)
+        | ListView(field)
+        | FixedSizeList(field, _)
+        | LargeList(field)
+        | LargeListView(field) => {
+            if field.data_type().is_nested() {
+                return type_not_supported();
+            }
+
+            return arrow_data_type_to_value_type(field.data_type())
+                .map(|(value_type, _)| (value_type, true));
+        }
+        Struct(_) => return type_not_supported(),
+        Union(_, _) => return type_not_supported(),
+        Dictionary(_, _) => return type_not_supported(),
+        Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _) => {
+            ValueType::BigDecimal
+        }
+        Map(_, _) => return type_not_supported(),
+        RunEndEncoded(_, _) => return type_not_supported(),
+    };
+
+    Ok((value_type, false))
+}
diff --git a/graph/src/amp/schema/generator/mod.rs b/graph/src/amp/schema/generator/mod.rs
new file mode 100644
index 00000000000..117d710adbe
--- /dev/null
+++ b/graph/src/amp/schema/generator/mod.rs
@@ -0,0 +1,65 @@
+mod entity;
+
+use anyhow::{Context, Result};
+use itertools::Itertools;
+
+use self::entity::SchemaEntity;
+use crate::{data::subgraph::DeploymentHash, schema::InputSchema};
+
+/// Generates a subgraph schema from a list of Arrow schemas.
+///
+/// # Limitations
+///
+/// The generated subgraph entities are immutable and do not contain any relationships to other entities within the schema.
+///
+/// # Errors
+///
+/// Returns an error if any of the Arrow schemas cannot be represented as valid subgraph entities.
+///
+/// The returned error is deterministic.
+pub fn generate_subgraph_schema(
+    deployment_hash: &DeploymentHash,
+    named_schemas: impl IntoIterator<Item = (String, arrow::datatypes::Schema)>,
+) -> Result<InputSchema> {
+    let mut named_schemas = merge_related_schemas(named_schemas)?;
+    named_schemas.sort_unstable_by_key(|(name, _)| name.clone());
+
+    let entities = create_entities(named_schemas)?;
+    let mut subgraph_schema = String::new();
+
+    for entity in entities {
+        subgraph_schema.extend(std::iter::once(entity.to_string()));
+        subgraph_schema.push_str("\n\n");
+    }
+
+    let input_schema = InputSchema::parse_latest(&subgraph_schema, deployment_hash.to_owned())
+        .context("failed to parse subgraph schema")?;
+
+    Ok(input_schema)
+}
+
+fn merge_related_schemas(
+    named_schemas: impl IntoIterator<Item = (String, arrow::datatypes::Schema)>,
+) -> Result<Vec<(String, arrow::datatypes::Schema)>> {
+    named_schemas
+        .into_iter()
+        .into_group_map_by(|(name, _)| name.clone())
+        .into_iter()
+        .map(|(name, related_schemas)| {
+            let related_schemas = related_schemas.into_iter().map(|(_, schema)| schema);
+
+            arrow::datatypes::Schema::try_merge(related_schemas).map(|schema| (name, schema))
+        })
+        .collect::<Result<Vec<_>, _>>()
+        .context("failed to merge schemas of related SQL queries")
+}
+
+fn create_entities(queries: Vec<(String, arrow::datatypes::Schema)>) -> Result<Vec<SchemaEntity>> {
+    queries
+        .into_iter()
+        .map(|(name, schema)| {
+            SchemaEntity::new(name.clone(), schema)
+                .with_context(|| format!("failed to create entity '{}'", name))
+        })
+        .collect::<Result<Vec<_>, _>>()
+}
diff --git a/graph/src/amp/schema/mod.rs b/graph/src/amp/schema/mod.rs
new file mode 100644
index 00000000000..546777a14ff
--- /dev/null
+++ b/graph/src/amp/schema/mod.rs
@@ -0,0 +1,3 @@
+mod generator;
+
+pub use self::generator::generate_subgraph_schema;
diff --git a/graph/src/amp/sql/mod.rs b/graph/src/amp/sql/mod.rs
new file mode 100644
index 00000000000..02355895afa
--- /dev/null
+++ b/graph/src/amp/sql/mod.rs
@@ -0,0 +1,3 @@
+pub mod query_builder;
+
+pub use self::query_builder::{BlockRangeQueryBuilder, ContextQuery, ValidQuery};
diff --git a/graph/src/amp/sql/query_builder/block_range_query.rs b/graph/src/amp/sql/query_builder/block_range_query.rs
new file mode 100644
index 00000000000..2c22336d379
--- /dev/null
+++ b/graph/src/amp/sql/query_builder/block_range_query.rs
@@ -0,0 +1,180 @@
+use std::{
+    collections::BTreeMap,
+    ops::{ControlFlow, RangeInclusive},
+};
+
+use alloy::primitives::BlockNumber;
+use sqlparser_latest::ast::{self, VisitMut, VisitorMut};
+
+use super::{TableReference, extract_tables, parse_query};
+
+/// Limits the query execution to the specified block range.
+///
+/// Wraps the `query` in a CTE, and creates CTEs for every table it references.
+/// These CTEs load data from the referenced tables only on the specified block range.
+/// All the table references in the original SQL query are replaced with the created CTE names.
+///
+/// The output is ordered by block numbers.
+pub(super) fn new_block_range_query(
+    query: &ast::Query,
+    block_number_column: &str,
+    block_range: &RangeInclusive<BlockNumber>,
+) -> ast::Query {
+    // CTE names are unique within a SQL query.
+
+    let tables_to_ctes_mapping = new_tables_to_ctes_mapping(query);
+    assert!(!tables_to_ctes_mapping.is_empty());
+
+    let mut cte_tables = Vec::with_capacity(tables_to_ctes_mapping.len());
+    for (table, cte_table) in &tables_to_ctes_mapping {
+        cte_tables.push(format!(
+            "{cte_table} AS (SELECT * FROM {table} WHERE _block_num BETWEEN {start_block} AND {end_block})",
+            start_block = block_range.start(),
+            end_block = block_range.end()
+        ))
+    }
+
+    let mut query = query.clone();
+    let mut table_replacer = TableReplacer::new(tables_to_ctes_mapping);
+    let _: ControlFlow<()> = VisitMut::visit(&mut query, &mut table_replacer);
+
+    let block_range_query = format!(
+        "WITH {cte_tables}, {source} AS ({query}) SELECT {source}.* FROM {source} ORDER BY {source}.{block_number_column}",
+        cte_tables = cte_tables.join(", "),
+        source = format!("amp_src")
+    );
+
+    parse_query(block_range_query).unwrap()
+}
+
+/// Creates unique CTE names for every table referenced by the SQL query.
+fn new_tables_to_ctes_mapping(query: &ast::Query) -> BTreeMap<TableReference, String> {
+    extract_tables(query)
+        .into_iter()
+        .enumerate()
+        .map(|(idx, table)| (table, format!("amp_br{}", idx + 1)))
+        .collect()
+}
+
+/// Visits the SQL query AST and replaces referenced table names with CTE names.
+struct TableReplacer {
+    tables_to_ctes_mapping: BTreeMap<TableReference, String>,
+}
+
+impl TableReplacer {
+    /// Creates a new table replacer.
+    fn new(tables_to_ctes_mapping: BTreeMap<TableReference, String>) -> Self {
+        Self {
+            tables_to_ctes_mapping,
+        }
+    }
+
+    /// Replaces the table name of the current `table_factor` with the associated CTE name.
+    fn visit_table_factor(&mut self, table_factor: &mut ast::TableFactor) {
+        let ast::TableFactor::Table { name, alias, .. } = table_factor else {
+            return;
+        };
+
+        let Some(cte_table) = self
+            .tables_to_ctes_mapping
+            .get(&TableReference::with_object_name(name))
+        else {
+            return;
+        };
+
+        // Set the alias to the original table name so that queries like `SELECT table.column FROM table` do not break
+        if alias.is_none() {
+            let last_name_part = name.0.last().unwrap();
+
+            *alias = Some(ast::TableAlias {
+                name: last_name_part.as_ident().unwrap().clone(),
+                columns: Vec::new(),
+            })
+        }
+
+        *name = ast::ObjectName(vec![ast::ObjectNamePart::Identifier(ast::Ident::new(
+            cte_table,
+        ))]);
+    }
+}
+
+impl VisitorMut for TableReplacer {
+    type Break = ();
+
+    fn pre_visit_table_factor(
+        &mut self,
+        table_factor: &mut ast::TableFactor,
+    ) -> ControlFlow<Self::Break> {
+        self.visit_table_factor(table_factor);
+        ControlFlow::Continue(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::parse_query;
+    use super::*;
+
+    #[test]
+    fn query_with_one_table_reference_is_wrapped_with_block_range() {
+        let query = parse_query("SELECT a, b, c FROM d").unwrap();
+        let block_number_column = "b";
+        let block_range = 0..=1_000_000;
+        let block_range_query = new_block_range_query(&query, block_number_column, &block_range);
+
+        assert_eq!(
+            block_range_query.to_string(),
+            parse_query(
+                r#"
+                WITH amp_br1 AS (
+                    SELECT * FROM d WHERE _block_num BETWEEN 0 AND 1000000
+                ),
+                amp_src AS (
+                    SELECT a, b, c FROM amp_br1 AS d
+                )
+                SELECT
+                    amp_src.*
+                FROM
+                    amp_src
+                ORDER BY
+                    amp_src.b
+                "#
+            )
+            .unwrap()
+            .to_string(),
+        )
+    }
+
+    #[test]
+    fn query_with_multiple_table_references_is_wrapped_with_block_range() {
+        let query = parse_query("SELECT a, b, c FROM d JOIN e ON e.e = d.d").unwrap();
+        let block_number_column = "b";
+        let block_range = 0..=1_000_000;
+        let block_range_query = new_block_range_query(&query, block_number_column, &block_range);
+
+        assert_eq!(
+            block_range_query.to_string(),
+            parse_query(
+                r#"
+                WITH amp_br1 AS (
+                    SELECT * FROM d WHERE _block_num BETWEEN 0 AND 1000000
+                ),
+                amp_br2 AS (
+                    SELECT * FROM e WHERE _block_num BETWEEN 0 AND 1000000
+                ),
+                amp_src AS (
+                    SELECT a, b, c FROM amp_br1 AS d JOIN amp_br2 AS e ON e.e = d.d
+                )
+                SELECT
+                    amp_src.*
+                FROM
+                    amp_src
+                ORDER BY
+                    amp_src.b
+                "#
+            )
+            .unwrap()
+            .to_string(),
+        )
+    }
+}
diff --git a/graph/src/amp/sql/query_builder/context_query.rs b/graph/src/amp/sql/query_builder/context_query.rs
new file mode 100644
index 00000000000..00cb60a4eac
--- /dev/null
+++ b/graph/src/amp/sql/query_builder/context_query.rs
@@ -0,0 +1,89 @@
+use itertools::Itertools;
+use sqlparser_latest::ast;
+
+use super::parse_query;
+
+/// Wraps the SQL query with additional context columns from a separate dataset.
+///
+/// Creates two CTEs: one wrapping the input `query` and another loading context columns
+/// from the specified context dataset and table. Joins both CTEs on block numbers to
+/// include the context columns in the original query's output.
+///
+/// This enables including columns required by Amp subgraphs in the original SQL query.
+pub(super) fn new_context_query<'a>(
+    query: &ast::Query,
+    block_number_column: &str,
+    context_dataset: &str,
+    context_table: &str,
+    context_columns: impl IntoIterator<Item = &'a str>,
+) -> ast::Query {
+    // CTE names are unique within a SQL query.
+    let context_columns = context_columns.into_iter().collect_vec();
+    assert!(!context_columns.is_empty());
+
+    let context_cte = "amp_ctx";
+    let source_cte = "amp_src";
+
+    let context_query = format!(
+        "
+        WITH {context_cte} AS (
+            SELECT DISTINCT _block_num, {input_context_columns} FROM {context_dataset}.{context_table}
+        ),
+        {source_cte} AS (
+            {query}
+        )
+        SELECT
+            {output_context_columns},
+            {source_cte}.*
+        FROM
+            {source_cte}
+        INNER JOIN {context_cte} ON
+            {context_cte}._block_num = {source_cte}.{block_number_column}
+        ",
+        input_context_columns = context_columns.join(", "),
+        output_context_columns = context_columns
+            .iter()
+            .map(|context_column| format!("{context_cte}.{context_column}"))
+            .join(", "),
+    );
+
+    parse_query(context_query).unwrap()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::parse_query;
+    use super::*;
+
+    #[test]
+    fn query_is_wrapped_with_context() {
+        let query = parse_query("SELECT a, b, c FROM d").unwrap();
+        let block_number_column = "b";
+        let context_dataset = "cx_a";
+        let context_table = "cx_b";
+        let context_columns = ["cx_c", "cx_d"];
+
+        let context_query = new_context_query(
+            &query,
+            block_number_column,
+            context_dataset,
+            context_table,
+            context_columns,
+        );
+
+        assert_eq!(
+            context_query,
+            parse_query(
+                "
+                WITH amp_ctx AS (
+                       SELECT DISTINCT _block_num, cx_c, cx_d FROM cx_a.cx_b
+                     ),
+                     amp_src AS (SELECT a, b, c FROM d)
+              SELECT amp_ctx.cx_c, amp_ctx.cx_d, amp_src.*
+                FROM amp_src
+                INNER JOIN amp_ctx ON amp_ctx._block_num = amp_src.b"
+            )
+            .unwrap()
+        )
+    }
+}
diff --git a/graph/src/amp/sql/query_builder/event_signature_resolver.rs b/graph/src/amp/sql/query_builder/event_signature_resolver.rs
new file mode 100644
index 00000000000..27a1bdcf2bd
--- /dev/null
+++ b/graph/src/amp/sql/query_builder/event_signature_resolver.rs
@@ -0,0 +1,183 @@
+use std::ops::ControlFlow;
+
+use alloy::json_abi::JsonAbi;
+use anyhow::{Context, Result, bail};
+use sqlparser_latest::ast::{self, visit_expressions_mut};
+
+static FUNCTION_NAME: &str = "sg_event_signature";
+
+/// Replaces `sg_event_signature('CONTRACT_NAME', 'EVENT_NAME')` function calls with
+/// the correct event signature based on `abis`.
+///
+/// # Errors
+///
+/// Returns an error if:
+/// - The function is called with incorrect arguments
+/// - The contract name is not found in `abis`
+/// - The event name is not found in `abis`
+///
+/// The returned error is deterministic.
+pub(super) fn resolve_event_signatures(
+    query: &mut ast::Query,
+    abis: &[(&str, &JsonAbi)],
+) -> Result<()> {
+    let visit_result = visit_expressions_mut(query, |expr| match visit_expr(expr, abis) {
+        Ok(()) => ControlFlow::Continue(()),
+        Err(e) => ControlFlow::Break(e),
+    });
+
+    if let ControlFlow::Break(e) = visit_result {
+        return Err(e).with_context(|| format!("failed to resolve '{FUNCTION_NAME}' calls"));
+    }
+
+    Ok(())
+}
+
+fn visit_expr(expr: &mut ast::Expr, abis: &[(&str, &JsonAbi)]) -> Result<()> {
+    let ast::Expr::Function(function) = expr else {
+        return Ok(());
+    };
+
+    if !FUNCTION_NAME.eq_ignore_ascii_case(&function.name.to_string()) {
+        return Ok(());
+    }
+
+    let Some((contract_name, event_name)) = get_args(function) else {
+        bail!(
+            "invalid function call: expected `{FUNCTION_NAME}('CONTRACT_NAME', 'EVENT_NAME')`, found: `{function}`"
+        );
+    };
+
+    let Some(event) = get_event(abis, contract_name, event_name) else {
+        bail!("invalid function call: unknown contract '{contract_name}' or event '{event_name}'");
+    };
+
+    let signature = ast::Value::SingleQuotedString(event.full_signature()).with_empty_span();
+    *expr = ast::Expr::Value(signature);
+
+    Ok(())
+}
+
+fn get_args(function: &ast::Function) -> Option<(&str, &str)> {
+    let ast::FunctionArguments::List(args) = &function.args else {
+        return None;
+    };
+
+    if args.args.len() != 2 {
+        return None;
+    }
+
+    match (get_arg(&args.args[0]), get_arg(&args.args[1])) {
+        (Some(contract_name), Some(event_name)) => Some((contract_name, event_name)),
+        _ => None,
+    }
+}
+
+fn get_arg(arg: &ast::FunctionArg) -> Option<&str> {
+    let ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(expr)) = arg else {
+        return None;
+    };
+
+    match expr {
+        ast::Expr::Value(ast::ValueWithSpan {
+            value: ast::Value::SingleQuotedString(value),
+            ..
+        }) if !value.is_empty() => Some(value),
+        _ => None,
+    }
+}
+
+fn get_event<'a>(
+    abis: &'a [(&str, &JsonAbi)],
+    contract_name: &str,
+    event_name: &str,
+) -> Option<&'a alloy::json_abi::Event> {
+    abis.iter()
+        .filter(|(name, _)| *name == contract_name)
+        .filter_map(|(_, contract)| contract.event(event_name))
+        .filter_map(|events| events.first())
+        .next()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::parse_query;
+    use super::*;
+
+    use self::fixtures::*;
+
+    mod fixtures {
+        use std::sync::LazyLock;
+
+        use super::*;
+
+        pub(super) static ABIS: LazyLock<Vec<(&str, JsonAbi)>> = LazyLock::new(|| {
+            vec![
+                ("ContractA", JsonAbi::parse([&*event("TransferA")]).unwrap()),
+                ("ContractB", JsonAbi::parse([&*event("TransferB")]).unwrap()),
+                ("ContractB", JsonAbi::parse([&*event("TransferC")]).unwrap()),
+            ]
+        });
+
+        pub(super) fn event(name: &str) -> String {
+            format!("event {name}(address indexed from, address indexed to, address value)")
+        }
+    }
+
+    macro_rules! test_resolve_event_signatures {
+        ($($name:ident: $query:expr => $expected:expr),* $(,)?) => {
+            $(
+                #[test]
+                fn $name() {
+                    let mut query = parse_query($query).unwrap();
+                    let abis = ABIS.iter().map(|abi| (abi.0, &abi.1)).collect::<Vec<_>>();
+                    let result = resolve_event_signatures(&mut query, &abis);
+
+                    match $expected {
+                        Result::<&str, ()>::Ok(expected) => {
+                            result.unwrap();
+                            assert_eq!(query, parse_query(expected).unwrap());
+                        },
+                        Err(_) => {
+                            result.unwrap_err();
+                        }
+                    }
+                }
+            )*
+        };
+    }
+
+    test_resolve_event_signatures! {
+        nothing_to_resolve: "SELECT a FROM b" => Ok("SELECT a FROM b"),
+
+        call_with_no_arguments: "SELECT a FROM b WHERE c = sg_event_signature()" => Err(()),
+        call_with_one_argument: "SELECT a FROM b WHERE c = sg_event_signature('ContractA')" => Err(()),
+        call_with_first_invalid_argument: "SELECT a FROM b WHERE c = sg_event_signature(ContractA, 'TransferA')" => Err(()),
+        call_with_second_invalid_argument: "SELECT a FROM b WHERE c = sg_event_signature('ContractA', TransferA)" => Err(()),
+        call_with_two_invalid_arguments: "SELECT a FROM b WHERE c = sg_event_signature(ContractA, TransferA)" => Err(()),
+        call_with_unknown_contract: "SELECT a FROM b WHERE c = sg_event_signature('ContractX', 'TransferA')" => Err(()),
+        call_with_unknown_event: "SELECT a FROM b WHERE c = sg_event_signature('ContractA', 'TransferX')" => Err(()),
+        call_with_contract_and_event_mismatch: "SELECT a FROM b WHERE c = sg_event_signature('ContractA', 'TransferB')" => Err(()),
+        call_with_invalid_argument_cases: "SELECT a FROM b WHERE c = sg_event_signature('contractA', 'transferA')" => Err(()),
+
+        resolve_one_call:
+            "SELECT a FROM b WHERE c = sg_event_signature('ContractA', 'TransferA')" =>
+            Ok(&*format!("SELECT a FROM b WHERE c = '{}'", event("TransferA"))),
+
+        resolve_multiple_calls:
+            "SELECT a FROM b WHERE c = sg_event_signature('ContractA', 'TransferA') OR d = sg_event_signature('ContractA', 'TransferA')" =>
+            Ok(&*format!("SELECT a FROM b WHERE c = '{}' OR d = '{}'", event("TransferA"), event("TransferA"))),
+
+        resolve_multiple_calls_with_different_arguments:
+            "SELECT a FROM b WHERE c = sg_event_signature('ContractA', 'TransferA') OR d = sg_event_signature('ContractB', 'TransferB')" =>
+            Ok(&*format!("SELECT a FROM b WHERE c = '{}' OR d = '{}'", event("TransferA"), event("TransferB"))),
+
+        resolve_multiple_calls_with_events_from_different_abis_with_the_same_name:
+            "SELECT a FROM b WHERE c = sg_event_signature('ContractB', 'TransferB') OR d = sg_event_signature('ContractB', 'TransferC')" =>
+            Ok(&*format!("SELECT a FROM b WHERE c = '{}' OR d = '{}'", event("TransferB"), event("TransferC"))),
+
+        resolve_calls_with_case_insensitive_function_name:
+            "SELECT a FROM b WHERE c = sg_Event_SIGNATURE('ContractA', 'TransferA')" =>
+            Ok(&*format!("SELECT a FROM b WHERE c = '{}'", event("TransferA"))),
+    }
+}
diff --git a/graph/src/amp/sql/query_builder/mod.rs b/graph/src/amp/sql/query_builder/mod.rs
new file mode 100644
index 00000000000..c71c6ef5baf
--- /dev/null
+++ b/graph/src/amp/sql/query_builder/mod.rs
@@ -0,0 +1,191 @@
+mod block_range_query;
+mod context_query;
+mod event_signature_resolver;
+mod parser;
+mod source_address_resolver;
+mod table_extractor;
+mod table_validator;
+
+use std::{fmt, ops::RangeInclusive};
+
+use alloy::{
+    json_abi::JsonAbi,
+    primitives::{Address, BlockNumber},
+};
+use anyhow::{Context, Result, bail};
+use itertools::Itertools;
+use sqlparser_latest::ast;
+
+use self::{
+    block_range_query::new_block_range_query,
+    context_query::new_context_query,
+    event_signature_resolver::resolve_event_signatures,
+    parser::parse_query,
+    source_address_resolver::resolve_source_address,
+    table_extractor::{TableReference, extract_tables},
+    table_validator::validate_tables,
+};
+
+/// Represents a valid SQL query that can be executed on an Amp server.
+#[derive(Debug, Clone)]
+pub struct ValidQuery {
+    query: ast::Query,
+}
+
+impl ValidQuery {
+    /// Parses, validates and resolves the input SQL query.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The SQL query cannot be parsed
+    /// - The SQL query is not valid
+    /// - The SQL query cannot be resolved
+    ///
+    /// The returned error is deterministic.
+    pub fn new<'a>(
+        sql: &str,
+        dataset: &str,
+        tables: impl IntoIterator<Item = &'a str>,
+        source_address: &Address,
+        abis: impl IntoIterator<Item = (&'a str, &'a JsonAbi)>,
+    ) -> Result<Self> {
+        let mut query = parse_query(sql).context("failed to parse SQL query")?;
+
+        Self::validate(&query, dataset, tables).context("failed to validate SQL query")?;
+        Self::resolve(&mut query, source_address, abis).context("failed to resolve SQL query")?;
+
+        Ok(Self { query })
+    }
+
+    /// Validates the SQL query.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The SQL query references unknown datasets or tables
+    /// - The SQL query uses custom `SETTINGS`
+    ///
+    /// The returned error is deterministic.
+    fn validate<'a>(
+        query: &ast::Query,
+        dataset: &str,
+        tables: impl IntoIterator<Item = &'a str>,
+    ) -> Result<()> {
+        validate_tables(query, dataset, tables)?;
+
+        if query.settings.is_some() {
+            bail!("custom SETTINGS are not allowed");
+        }
+
+        Ok(())
+    }
+
+    /// Resolves subgraph-specific function calls in the SQL query.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - Source address function calls cannot be resolved
+    /// - Event signature function calls cannot be resolved
+    ///
+    /// The returned error is deterministic.
+    fn resolve<'a>(
+        query: &mut ast::Query,
+        source_address: &Address,
+        abis: impl IntoIterator<Item = (&'a str, &'a JsonAbi)>,
+    ) -> Result<()> {
+        resolve_source_address(query, source_address)?;
+        resolve_event_signatures(query, &abis.into_iter().collect_vec())?;
+
+        Ok(())
+    }
+}
+
+impl fmt::Display for ValidQuery {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.query)
+    }
+}
+
+/// Represents a valid SQL query that contains columns required by Amp subgraphs.
+#[derive(Debug, Clone)]
+pub struct ContextQuery {
+    query: ast::Query,
+    block_number_column: String,
+}
+
+impl ContextQuery {
+    /// Wraps the SQL query with additional context columns from a separate dataset.
+    ///
+    /// Creates two CTEs: one wrapping the input `query` and another loading context columns
+    /// from the specified context dataset and table. Joins both CTEs on block numbers to
+    /// include the context columns in the original query's output.
+    ///
+    /// This enables including columns required by Amp subgraphs in the original SQL query.
+    pub fn new<'a>(
+        valid_query: ValidQuery,
+        block_number_column: &str,
+        context_dataset: &str,
+        context_table: &str,
+        context_columns: impl IntoIterator<Item = &'a str>,
+    ) -> Self {
+        let ValidQuery { query } = valid_query;
+
+        let query = new_context_query(
+            &query,
+            block_number_column,
+            context_dataset,
+            context_table,
+            context_columns,
+        );
+
+        Self {
+            query,
+            block_number_column: block_number_column.to_string(),
+        }
+    }
+}
+
+/// Builds valid SQL queries for execution on an Amp server with block range limits.
+#[derive(Debug, Clone)]
+pub struct BlockRangeQueryBuilder {
+    query: ast::Query,
+    block_number_column: String,
+}
+
+impl BlockRangeQueryBuilder {
+    /// Creates a new block range query builder with the specified valid SQL query.
+    pub fn new(valid_query: ValidQuery, block_number_column: &str) -> Self {
+        let ValidQuery { query } = valid_query;
+
+        Self {
+            query,
+            block_number_column: block_number_column.to_string(),
+        }
+    }
+
+    /// Creates a new block range query builder with the specified context SQL query.
+    pub fn new_with_context(context_query: ContextQuery) -> Self {
+        let ContextQuery {
+            query,
+            block_number_column,
+        } = context_query;
+
+        Self {
+            query,
+            block_number_column,
+        }
+    }
+
+    /// Limits the query execution to the specified block range.
+    ///
+    /// Wraps this SQL query in a CTE, and creates CTEs for every table it references.
+    /// These CTEs load data from the referenced tables only on the specified block range.
+    /// All the table references in the original SQL query are replaced with the created CTE names.
+    ///
+    /// The output is ordered by block numbers.
+    pub fn build_with_block_range(&self, block_range: &RangeInclusive<BlockNumber>) -> String {
+        new_block_range_query(&self.query, &self.block_number_column, block_range).to_string()
+    }
+}
diff --git a/graph/src/amp/sql/query_builder/parser.rs b/graph/src/amp/sql/query_builder/parser.rs
new file mode 100644
index 00000000000..9b25e8431f6
--- /dev/null
+++ b/graph/src/amp/sql/query_builder/parser.rs
@@ -0,0 +1,115 @@
+use std::ops::ControlFlow;
+
+use anyhow::{Context, Result, anyhow, bail};
+use itertools::Itertools;
+use sqlparser_latest::{
+    ast::{self, Visit, Visitor},
+    dialect::GenericDialect,
+    parser::Parser,
+};
+
+/// Parses a SQL query and returns its AST.
+///
+/// # Errors
+///
+/// Returns an error if:
+/// - The SQL query cannot be parsed
+/// - The SQL query contains multiple SQL statements
+/// - The SQL query is not a `SELECT` query
+///
+/// The returned error is deterministic.
+pub(super) fn parse_query(s: impl AsRef<str>) -> Result<ast::Query> {
+    let statement = Parser::parse_sql(&GenericDialect {}, s.as_ref())
+        .context("invalid SQL query")?
+        .into_iter()
+        .exactly_one()
+        .map_err(|e| anyhow!("expected exactly one SQL statement, found {}", e.count()))?;
+
+    let query = match statement {
+        ast::Statement::Query(query) => *query,
+        _ => bail!("invalid SQL query: only SELECT statements are allowed"),
+    };
+
+    if let ControlFlow::Break(e) = query.visit(&mut AllowOnlySelectQueries) {
+        return Err(e);
+    }
+
+    Ok(query)
+}
+
+/// Validates that the SQL query AST contains only `SELECT` queries in subqueries.
+struct AllowOnlySelectQueries;
+
+impl AllowOnlySelectQueries {
+    /// Returns an error if the `set_expr` is not a `SELECT` expression.
+    fn visit_set_expr(set_expr: &ast::SetExpr) -> Result<()> {
+        match set_expr {
+            ast::SetExpr::Select(_)
+            | ast::SetExpr::Query(_)
+            | ast::SetExpr::Values(_)
+            | ast::SetExpr::Table(_) => Ok(()),
+            ast::SetExpr::SetOperation { left, right, .. } => {
+                Self::visit_set_expr(left)?;
+                Self::visit_set_expr(right)?;
+                Ok(())
+            }
+            ast::SetExpr::Insert(_) | ast::SetExpr::Update(_) | ast::SetExpr::Delete(_) => {
+                bail!("invalid SQL query: only SELECT queries are allowed")
+            }
+        }
+    }
+}
+
+impl Visitor for AllowOnlySelectQueries {
+    type Break = anyhow::Error;
+
+    fn pre_visit_query(&mut self, query: &ast::Query) -> ControlFlow<Self::Break> {
+        match Self::visit_set_expr(&query.body) {
+            Ok(()) => ControlFlow::Continue(()),
+            Err(e) => ControlFlow::Break(e),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    macro_rules! test_parse_query {
+        ($($name:ident: $input:expr => $expected:expr),* $(,)?) => {
+            $(
+                #[test]
+                fn $name() {
+                    let result = parse_query($input);
+
+                    match $expected {
+                        Result::<&str, &str>::Ok(expected) => {
+                            assert_eq!(result.unwrap().to_string(), expected);
+                        },
+                        Err(e) => {
+                            assert_eq!(result.unwrap_err().to_string(), e);
+                        }
+                    }
+                }
+            )*
+        };
+    }
+
+    test_parse_query! {
+        invalid_query: "SELECT" => Err("invalid SQL query"),
+        multiple_statements: "SELECT a FROM b; SELECT c FROM d" => Err("expected exactly one SQL statement, found 2"),
+        insert_statement: "INSERT INTO a VALUES (b)" => Err("invalid SQL query: only SELECT statements are allowed"),
+        update_statement: "UPDATE a SET b = c" => Err("invalid SQL query: only SELECT statements are allowed"),
+        delete_statement: "DELETE FROM a WHERE b = c" => Err("invalid SQL query: only SELECT statements are allowed"),
+        truncate_statement: "TRUNCATE TABLE a" => Err("invalid SQL query: only SELECT statements are allowed"),
+        drop_statement: "DROP TABLE a" => Err("invalid SQL query: only SELECT statements are allowed"),
+
+        nested_insert_query: "WITH a AS (INSERT INTO b VALUES (c) RETURNING d) SELECT * FROM a" => Err("invalid SQL query: only SELECT queries are allowed"),
+        nested_update_query: "WITH a AS (UPDATE b SET c = d RETURNING e) SELECT * FROM a" => Err("invalid SQL query: only SELECT queries are allowed"),
+        nested_delete_query: "WITH a AS (DELETE FROM b WHERE c = d RETURNING e) SELECT * FROM a" => Err("invalid SQL query: only SELECT queries are allowed"),
+
+        valid_query: "SELECT a FROM b" => Ok("SELECT a FROM b"),
+        valid_query_with_cte: "WITH a AS (SELECT b FROM c) SELECT * FROM a" => Ok("WITH a AS (SELECT b FROM c) SELECT * FROM a"),
+        valid_query_with_join: "SELECT a FROM b INNER JOIN c ON c.c = b.b" => Ok("SELECT a FROM b INNER JOIN c ON c.c = b.b"),
+    }
+}
diff --git a/graph/src/amp/sql/query_builder/source_address_resolver.rs b/graph/src/amp/sql/query_builder/source_address_resolver.rs
new file mode 100644
index 00000000000..e0d908deb24
--- /dev/null
+++ b/graph/src/amp/sql/query_builder/source_address_resolver.rs
@@ -0,0 +1,133 @@
+use std::ops::ControlFlow;
+
+use alloy::primitives::Address;
+use anyhow::{Context, Result, bail};
+use sqlparser_latest::ast::{self, visit_expressions_mut};
+
+static FUNCTION_NAME: &str = "sg_source_address";
+
+/// Replaces `sg_source_address()` function calls in the SQL query with the `source_address`.
+///
+/// # Errors
+///
+/// Returns an error if the function is called with any arguments.
+///
+/// The returned error is deterministic.
+pub(super) fn resolve_source_address(
+    query: &mut ast::Query,
+    source_address: &Address,
+) -> Result<()> {
+    let visit_result =
+        visit_expressions_mut(query, |expr| match visit_expr(expr, source_address) {
+            Ok(()) => ControlFlow::Continue(()),
+            Err(e) => ControlFlow::Break(e),
+        });
+
+    if let ControlFlow::Break(e) = visit_result {
+        return Err(e).with_context(|| format!("failed to resolve '{FUNCTION_NAME}' calls"));
+    }
+
+    Ok(())
+}
+
+fn visit_expr(expr: &mut ast::Expr, source_address: &Address) -> Result<()> {
+    let ast::Expr::Function(function) = expr else {
+        return Ok(());
+    };
+
+    if !FUNCTION_NAME.eq_ignore_ascii_case(&function.name.to_string()) {
+        return Ok(());
+    }
+
+    match &function.args {
+        ast::FunctionArguments::None => {}
+        ast::FunctionArguments::List(args) if args.args.is_empty() => {}
+        _ => {
+            bail!("invalid function call: function '{FUNCTION_NAME}' does not accept arguments");
+        }
+    }
+
+    *function = ast::Function {
+        name: ast::ObjectName(vec![ast::ObjectNamePart::Identifier(ast::Ident::new(
+            "arrow_cast",
+        ))]),
+        uses_odbc_syntax: false,
+        parameters: ast::FunctionArguments::None,
+        args: ast::FunctionArguments::List(ast::FunctionArgumentList {
+            duplicate_treatment: None,
+            args: vec![
+                ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(ast::Expr::Value(
+                    ast::Value::HexStringLiteral(hex::encode(source_address)).with_empty_span(),
+                ))),
+                ast::FunctionArg::Unnamed(ast::FunctionArgExpr::Expr(ast::Expr::Value(
+                    ast::Value::SingleQuotedString("FixedSizeBinary(20)".to_string())
+                        .with_empty_span(),
+                ))),
+            ],
+            clauses: vec![],
+        }),
+        filter: None,
+        null_treatment: None,
+        over: None,
+        within_group: vec![],
+    };
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::parse_query;
+    use super::*;
+
+    use self::fixtures::*;
+
+    mod fixtures {
+        use super::*;
+
+        pub(super) const SOURCE_ADDRESS: Address = Address::ZERO;
+
+        pub(super) const RESOLVED_FUNCTION_CALL: &str =
+            "arrow_cast(X'0000000000000000000000000000000000000000', 'FixedSizeBinary(20)')";
+    }
+
+    macro_rules! test_resolve_source_address {
+        ($($name:ident: $query:expr => $expected:expr),* $(,)?) => {
+            $(
+                #[test]
+                fn $name() {
+                    let mut query = parse_query($query).unwrap();
+                    let result = resolve_source_address(&mut query, &SOURCE_ADDRESS);
+
+                    match $expected {
+                        Result::<&str, ()>::Ok(expected) => {
+                            result.unwrap();
+                            assert_eq!(query, parse_query(expected).unwrap());
+                        },
+                        Err(_) => {
+                            result.unwrap_err();
+                        }
+                    }
+                }
+            )*
+        };
+    }
+
+    test_resolve_source_address! {
+        nothing_to_resolve: "SELECT a FROM b" => Ok("SELECT a FROM b"),
+        call_with_one_argument: "SELECT a FROM b WHERE c = sg_source_address(d)" => Err(()),
+        call_with_multiple_argument: "SELECT a FROM b WHERE c = sg_source_address(d, e)" => Err(()),
+
+        resolve_one_call:
+            "SELECT a FROM b WHERE c = sg_source_address()" =>
+            Ok(&*format!("SELECT a FROM b WHERE c = {RESOLVED_FUNCTION_CALL}")),
+
+        resolve_multiple_calls:
+            "SELECT a FROM b WHERE c = sg_source_address() OR d = sg_source_address()" =>
+            Ok(&*format!("SELECT a FROM b WHERE c = {RESOLVED_FUNCTION_CALL} OR d = {RESOLVED_FUNCTION_CALL}")),
+
+        resolve_calls_with_case_insensitive_function_name:
+            "SELECT a FROM b WHERE c = sg_Source_ADDRESS()" =>
+            Ok(&*format!("SELECT a FROM b WHERE c = {RESOLVED_FUNCTION_CALL}")),
+    }
+}
diff --git a/graph/src/amp/sql/query_builder/table_extractor.rs b/graph/src/amp/sql/query_builder/table_extractor.rs
new file mode 100644
index 00000000000..ac1074fe8a5
--- /dev/null
+++ b/graph/src/amp/sql/query_builder/table_extractor.rs
@@ -0,0 +1,198 @@
+use std::{collections::BTreeSet, fmt, ops::ControlFlow};
+
+use sqlparser_latest::ast::{self, Visit, Visitor};
+
+/// Returns all tables that are referenced by the SQL query.
+///
+/// The table names are lowercased and quotes are ignored.
+pub(super) fn extract_tables(query: &ast::Query) -> BTreeSet<TableReference> {
+    let mut table_extractor = TableExtractor::new();
+    let _: ControlFlow<()> = Visit::visit(query, &mut table_extractor);
+
+    table_extractor.tables
+}
+
+/// Contains a normalized table reference.
+///
+/// Used to compare physical table references with CTE names and custom tables.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub(super) struct TableReference(String);
+
+impl TableReference {
+    /// Creates a raw table reference from a custom dataset and table.
+    pub(super) fn raw(dataset: &str, table: &str) -> Self {
+        Self(format!("{dataset}.{table}"))
+    }
+
+    /// Creates a new table reference from an object name.
+    pub(super) fn with_object_name(object_name: &ast::ObjectName) -> Self {
+        Self::with_idents(
+            object_name
+                .0
+                .iter()
+                .map(|object_name_part| match object_name_part {
+                    ast::ObjectNamePart::Identifier(ident) => ident,
+                }),
+        )
+    }
+
+    /// Creates a new table reference from a list of identifiers.
+    pub(super) fn with_idents<'a>(idents: impl IntoIterator<Item = &'a ast::Ident>) -> Self {
+        Self(
+            ast::ObjectName::from(
+                idents
+                    .into_iter()
+                    .map(|ident| {
+                        let ast::Ident {
+                            value,
+                            quote_style,
+                            span: _,
+                        } = ident;
+
+                        match quote_style {
+                            Some(_quote_style) => ast::Ident::with_quote('"', value),
+                            None => ast::Ident::new(value.to_lowercase()),
+                        }
+                    })
+                    .collect::<Vec<_>>(),
+            )
+            .to_string(),
+        )
+    }
+}
+
+impl fmt::Display for TableReference {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// Visits the SQL query AST and extracts referenced table names, ignoring CTEs.
+struct TableExtractor {
+    tables: BTreeSet<TableReference>,
+    cte_stack: CteStack,
+}
+
+impl TableExtractor {
+    /// Creates a new empty table extractor.
+    fn new() -> Self {
+        Self {
+            tables: BTreeSet::new(),
+            cte_stack: CteStack::new(),
+        }
+    }
+
+    /// Extracts and stores the table name from the current `table_factor`.
+    fn visit_table_factor(&mut self, table_factor: &ast::TableFactor) {
+        let ast::TableFactor::Table { name, .. } = table_factor else {
+            return;
+        };
+
+        let table_reference = TableReference::with_object_name(name);
+        if self.cte_stack.contains(&table_reference) {
+            return;
+        }
+
+        self.tables.insert(table_reference);
+    }
+}
+
+impl Visitor for TableExtractor {
+    type Break = ();
+
+    fn pre_visit_query(&mut self, query: &ast::Query) -> ControlFlow<Self::Break> {
+        self.cte_stack.pre_visit_query(query);
+        ControlFlow::Continue(())
+    }
+
+    fn post_visit_query(&mut self, _query: &ast::Query) -> ControlFlow<Self::Break> {
+        self.cte_stack.post_visit_query();
+        ControlFlow::Continue(())
+    }
+
+    fn pre_visit_table_factor(
+        &mut self,
+        table_factor: &ast::TableFactor,
+    ) -> ControlFlow<Self::Break> {
+        self.visit_table_factor(table_factor);
+        ControlFlow::Continue(())
+    }
+}
+
+/// Maintains a list of active CTEs for each subquery scope.
+struct CteStack {
+    stack: Vec<BTreeSet<TableReference>>,
+}
+
+impl CteStack {
+    /// Creates a new empty CTE stack.
+    fn new() -> Self {
+        Self { stack: Vec::new() }
+    }
+
+    /// Returns `true` if the `table_reference` is present in the CTE list at any scope.
+    fn contains(&self, table_reference: &TableReference) -> bool {
+        self.stack
+            .iter()
+            .any(|scope| scope.contains(table_reference))
+    }
+
+    /// Creates a new subquery scope with all the CTEs of the current `query`.
+    fn pre_visit_query(&mut self, query: &ast::Query) {
+        let cte_tables = match &query.with {
+            Some(with) => with
+                .cte_tables
+                .iter()
+                .map(|cte_table| TableReference::with_idents([&cte_table.alias.name]))
+                .collect(),
+            None => BTreeSet::new(),
+        };
+
+        self.stack.push(cte_tables);
+    }
+
+    /// Removes all the CTEs from the most recent subquery scope.
+    fn post_visit_query(&mut self) {
+        self.stack.pop();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::parse_query;
+    use super::*;
+
+    macro_rules! test_extract_tables {
+        ($($name:ident: $input:expr => $expected:expr),* $(,)?) => {
+            $(
+                #[test]
+                fn $name() {
+                    let query = parse_query($input).unwrap();
+                    assert_eq!(
+                        extract_tables(&query).into_iter().map(|table| table.to_string()).collect::<Vec<_>>(),
+                        $expected.into_iter().map(|table| table.to_string()).collect::<Vec<_>>()
+                    );
+                }
+            )*
+        };
+    }
+
+    test_extract_tables! {
+        one_table: "SELECT a FROM b" => ["b"],
+        multiple_tables_with_one_join: "SELECT a FROM b JOIN c ON c.c = b.b" => ["b", "c"],
+        multiple_tables_with_multiple_joins: "SELECT a FROM b JOIN c ON c.c = b.b JOIN d ON d.d = b.b" => ["b", "c", "d"],
+        one_table_with_one_cte: "WITH a AS (SELECT * FROM b) SELECT * FROM a" => ["b"],
+        one_table_with_multiple_ctes: "WITH a AS (SELECT * FROM b), c AS (SELECT * FROM a) SELECT * FROM c" => ["b"],
+        multiple_tables_with_multiple_ctes: "WITH a AS (SELECT * FROM b), c AS (SELECT * FROM d) SELECT * FROM a JOIN c ON c.c = a.a" => ["b", "d"],
+        multiple_tables_with_nested_ctes: "WITH a AS (WITH b AS (SELECT * FROM c) SELECT * FROM d JOIN b ON b.b = d.d) SELECT * FROM a" => ["c", "d"],
+        multiple_tables_with_union: "SELECT a FROM b UNION SELECT c FROM d" => ["b", "d"],
+        multiple_tables_with_union_all: "SELECT a FROM b UNION ALL SELECT c FROM d" => ["b", "d"],
+
+        namespace_is_preserved: "SELECT a FROM b.c" => ["b.c"],
+        catalog_is_preserved: "SELECT a FROM b.c.d" => ["b.c.d"],
+        unquoted_tables_are_lowercased: "SELECT a FROM B.C" => ["b.c"],
+        single_quotes_in_tables_are_converted_to_double_quotes: "SELECT a FROM 'B'.'C'" => [r#""B"."C""#],
+        double_quotes_in_tables_are_preserved: r#"SELECT a FROM "B"."C""# => [r#""B"."C""#],
+        backticks_in_tables_are_converted_to_double_quotes: "SELECT a FROM `B`.`C`" => [r#""B"."C""#],
+    }
+}
diff --git a/graph/src/amp/sql/query_builder/table_validator.rs b/graph/src/amp/sql/query_builder/table_validator.rs
new file mode 100644
index 00000000000..43e7fa9c128
--- /dev/null
+++ b/graph/src/amp/sql/query_builder/table_validator.rs
@@ -0,0 +1,99 @@
+use std::collections::BTreeSet;
+
+use anyhow::{Result, bail};
+use sqlparser_latest::ast;
+
+use super::{TableReference, extract_tables};
+
+/// Validates that SQL query references only allowed dataset and tables.
+///
+/// # Errors
+///
+/// Returns an error if:
+/// - The `query` does not reference any tables
+/// - The `query` references a table not in `allowed_tables`
+/// - The `query` references a dataset other than `allowed_dataset`
+///
+/// The returned error is deterministic.
+pub(super) fn validate_tables<'a>(
+    query: &ast::Query,
+    allowed_dataset: &str,
+    allowed_tables: impl IntoIterator<Item = &'a str>,
+) -> Result<()> {
+    let used_tables = extract_tables(query);
+
+    if used_tables.is_empty() {
+        bail!("query does not use any tables");
+    }
+
+    let allowed_tables = allowed_tables
+        .into_iter()
+        .map(|allowed_table| TableReference::raw(allowed_dataset, allowed_table))
+        .collect::<BTreeSet<_>>();
+
+    for used_table in used_tables {
+        if !allowed_tables.contains(&used_table) {
+            bail!("table '{used_table}' not allowed");
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::parse_query;
+    use super::*;
+
+    macro_rules! test_validate_tables {
+        ($($name:ident: $input:expr, $dataset:expr, $tables:expr => $expected:expr),* $(,)?) => {
+            $(
+                #[test]
+                fn $name() {
+                    let query = parse_query($input).unwrap();
+                    let result = validate_tables(&query, $dataset, $tables);
+
+                    match $expected {
+                        Result::<(), &str>::Ok(()) => {
+                            result.unwrap();
+                        },
+                        Err(e) => {
+                            assert_eq!(result.unwrap_err().to_string(), e);
+                        }
+                    }
+                }
+            )*
+        };
+    }
+
+    test_validate_tables! {
+        no_table_references: "SELECT *", "a", ["b"] => Err("query does not use any tables"),
+        missing_dataset: "SELECT * FROM b", "a", ["b"] => Err("table 'b' not allowed"),
+        missing_table: "SELECT * FROM a", "a", ["b"] => Err("table 'a' not allowed"),
+        invalid_dataset: "SELECT * FROM c.b", "a", ["b"] => Err("table 'c.b' not allowed"),
+        invalid_nested_dataset: "WITH a AS (SELECT * FROM c.b) SELECT * FROM a", "a", ["b"] => Err("table 'c.b' not allowed"),
+        invalid_table: "SELECT * FROM a.c", "a", ["b"] => Err("table 'a.c' not allowed"),
+        invalid_nested_table: "WITH a AS (SELECT * FROM a.c) SELECT * FROM a", "a", ["b"] => Err("table 'a.c' not allowed"),
+        using_catalog: "SELECT * FROM c.a.b", "a", ["b"] => Err("table 'c.a.b' not allowed"),
+
+        one_valid_table: "SELECT * FROM a.b", "a", ["b"] => Ok(()),
+        one_valid_nested_table: "WITH a AS (SELECT * FROM a.b) SELECT * FROM a", "a", ["b"] => Ok(()),
+        multiple_valid_tables: "SELECT * FROM a.b JOIN a.c ON a.c.c = a.b.b", "a", ["b", "c"] => Ok(()),
+        multiple_valid_nested_tables: "WITH a AS (SELECT * FROM a.b JOIN a.c ON a.c.c = a.b.b) SELECT * FROM a", "a", ["b", "c"] => Ok(()),
+
+        unquoted_dataset_is_case_insensitive: "SELECT * FROM A.b", "a", ["b"] => Ok(()),
+        unquoted_tables_are_case_insensitive: "SELECT * FROM a.B", "a", ["b"] => Ok(()),
+
+        single_quoted_dataset_is_case_sensitive: "SELECT * FROM 'A'.b", "a", ["b"] => Err(r#"table '"A".b' not allowed"#),
+        single_quoted_tables_are_case_sensitive: "SELECT * FROM a.'B'", "a", ["b"] => Err(r#"table 'a."B"' not allowed"#),
+
+        double_quoted_dataset_is_case_sensitive: r#"SELECT * FROM "A".b"#, "a", ["b"] => Err(r#"table '"A".b' not allowed"#),
+        double_quoted_tables_are_case_sensitive: r#"SELECT * FROM a."B""#, "a", ["b"] => Err(r#"table 'a."B"' not allowed"#),
+
+        backtick_quoted_dataset_is_case_sensitive: "SELECT * FROM `A`.b", "a", ["b"] => Err(r#"table '"A".b' not allowed"#),
+        backtick_quoted_tables_are_case_sensitive: "SELECT * FROM a.`B`", "a", ["b"] => Err(r#"table 'a."B"' not allowed"#),
+
+        allowed_dataset_is_case_sensitive: "SELECT * FROM a.b", "A", ["b"] => Err("table 'a.b' not allowed"),
+        allowed_tables_are_case_sensitive: "SELECT * FROM a.b", "a", ["B"] => Err("table 'a.b' not allowed"),
+    }
+}
diff --git a/graph/src/amp/stream_aggregator/error.rs b/graph/src/amp/stream_aggregator/error.rs
new file mode 100644
index 00000000000..a2ba55f71e2
--- /dev/null
+++ b/graph/src/amp/stream_aggregator/error.rs
@@ -0,0 +1,51 @@
+use std::sync::Arc;
+
+use thiserror::Error;
+
+use crate::amp::error::IsDeterministic;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("failed to aggregate record batches: {0:#}")]
+    Aggregation(#[source] anyhow::Error),
+
+    #[error("failed to buffer record batches from stream '{stream_name}': {source:#}")]
+    Buffer {
+        stream_name: Arc<str>,
+        source: anyhow::Error,
+    },
+
+    #[error("failed to read record batch from stream '{stream_name}': {source:#}")]
+    Stream {
+        stream_name: Arc<str>,
+        source: anyhow::Error,
+        is_deterministic: bool,
+    },
+}
+
+impl Error {
+    pub(super) fn stream<E>(stream_name: Arc<str>, e: E) -> Self
+    where
+        E: std::error::Error + IsDeterministic + Send + Sync + 'static,
+    {
+        let is_deterministic = e.is_deterministic();
+
+        Self::Stream {
+            stream_name,
+            source: anyhow::Error::from(e),
+            is_deterministic,
+        }
+    }
+}
+
+impl IsDeterministic for Error {
+    fn is_deterministic(&self) -> bool {
+        match self {
+            Self::Aggregation(_) => true,
+            Self::Buffer { .. } => true,
+            Self::Stream {
+                is_deterministic, ..
+            } => *is_deterministic,
+        }
+    }
+}
diff --git a/graph/src/amp/stream_aggregator/mod.rs b/graph/src/amp/stream_aggregator/mod.rs
new file mode 100644
index 00000000000..df990fa20d6
--- /dev/null
+++ b/graph/src/amp/stream_aggregator/mod.rs
@@ -0,0 +1,238 @@
+mod error;
+mod record_batch;
+
+use std::{
+    pin::Pin,
+    sync::Arc,
+    task::{self, Poll},
+};
+
+use anyhow::{Result, anyhow};
+use arrow::array::RecordBatch;
+use futures03::{Stream, StreamExt, TryStreamExt, stream::BoxStream};
+use slog::{Logger, debug, info};
+
+use self::record_batch::Buffer;
+use crate::{
+    amp::{client::ResponseBatch, error::IsDeterministic, log::Logger as _},
+    cheap_clone::CheapClone,
+};
+
+pub use self::{
+    error::Error,
+    record_batch::{RecordBatchGroup, RecordBatchGroups, StreamRecordBatch},
+};
+
+/// Reads record batches from multiple streams and groups them by block number and hash pairs.
+///
+/// Processes each row in the response record batches and groups them by block number
+/// and hash. When processing starts for a new block, all data from previous blocks
+/// is grouped and streamed in batches.
+///
+/// The reason the aggregation is required is to ensure compatibility with the existing
+/// subgraph storage implementation.
+///
+/// # Stream requirements
+///
+/// - Every record batch must have valid block number and hash columns
+/// - Every record batch must contain blocks in ascending order
+///
+/// # Performance
+///
+/// To ensure data consistency and ordered output, the aggregator waits for slower streams
+/// to catch up with faster streams. The output stream speed matches the slowest input stream.
+pub struct StreamAggregator {
+    named_streams: Vec<(Arc<str>, BoxStream<'static, Result<RecordBatch, Error>>)>,
+    buffer: Buffer,
+    logger: Logger,
+
+    /// Indicates whether all streams are fully consumed.
+    is_finalized: bool,
+
+    /// Indicates whether any stream has produced an error.
+    ///
+    /// When `true`, the stream aggregator stops polling all other streams.
+    is_failed: bool,
+}
+
+impl StreamAggregator {
+    /// Creates a new stream aggregator from the `streams` with a bounded buffer.
+    pub fn new<E>(
+        logger: &Logger,
+        named_streams: impl IntoIterator<Item = (String, BoxStream<'static, Result<ResponseBatch, E>>)>,
+        buffer_size: usize,
+    ) -> Self
+    where
+        E: std::error::Error + IsDeterministic + Send + Sync + 'static,
+    {
+        let logger = logger.component("AmpStreamAggregator");
+
+        let named_streams = named_streams
+            .into_iter()
+            .map(|(stream_name, stream)| {
+                let stream_name: Arc<str> = stream_name.into();
+                (
+                    stream_name.cheap_clone(),
+                    stream
+                        .map_err({
+                            let stream_name = stream_name.cheap_clone();
+                            move |e| Error::stream(stream_name.cheap_clone(), e)
+                        })
+                        .try_filter_map({
+                            let stream_name = stream_name.cheap_clone();
+                            move |response_batch| {
+                                let stream_name = stream_name.cheap_clone();
+                                async move {
+                                    match response_batch {
+                                        ResponseBatch::Batch { data } => Ok(Some(data)),
+                                        ResponseBatch::Reorg(_) => Err(Error::Stream {
+                                            stream_name: stream_name.cheap_clone(),
+                                            source: anyhow!("chain reorg"),
+                                            is_deterministic: false,
+                                        }),
+                                    }
+                                }
+                            }
+                        })
+                        .boxed(),
+                )
+            })
+            .collect::<Vec<_>>();
+
+        let num_streams = named_streams.len();
+
+        Self {
+            named_streams,
+            buffer: Buffer::new(num_streams, buffer_size),
+            logger,
+            is_finalized: false,
+            is_failed: false,
+        }
+    }
+
+    fn poll_all_streams(
+        &mut self,
+        cx: &mut task::Context<'_>,
+    ) -> Poll<Option<Result<RecordBatchGroups, Error>>> {
+        let mut made_progress = false;
+        let mut needs_repoll = false;
+
+        for (stream_index, (stream_name, stream)) in self.named_streams.iter_mut().enumerate() {
+            let logger = self.logger.new(slog::o!(
+                "stream_index" => stream_index,
+                "stream_name" => stream_name.cheap_clone()
+            ));
+
+            if self.buffer.is_finalized(stream_index) {
+                continue;
+            }
+
+            if self.buffer.is_blocked(stream_index) {
+                self.is_failed = true;
+
+                return Poll::Ready(Some(Err(Error::Buffer {
+                    stream_name: stream_name.cheap_clone(),
+                    source: anyhow!("buffer is blocked"),
+                })));
+            }
+
+            if !self.buffer.has_capacity(stream_index) {
+                continue;
+            }
+
+            match stream.poll_next_unpin(cx) {
+                Poll::Ready(Some(Ok(record_batch))) if record_batch.num_rows() != 0 => {
+                    let buffer_result =
+                        self.buffer
+                            .extend(stream_index, record_batch)
+                            .map_err(|e| Error::Buffer {
+                                stream_name: stream_name.cheap_clone(),
+                                source: e,
+                            });
+
+                    match buffer_result {
+                        Ok(()) => {
+                            made_progress = true;
+                            needs_repoll = true;
+
+                            debug!(logger, "Buffered record batch";
+                                "buffer_size" => self.buffer.size(stream_index),
+                                "has_capacity" => self.buffer.has_capacity(stream_index)
+                            );
+                        }
+                        Err(e) => {
+                            self.is_failed = true;
+
+                            return Poll::Ready(Some(Err(e)));
+                        }
+                    }
+                }
+                Poll::Ready(Some(Ok(_empty_record_batch))) => {
+                    debug!(logger, "Received an empty record batch");
+                    needs_repoll = true;
+                }
+                Poll::Ready(Some(Err(e))) => {
+                    self.is_failed = true;
+
+                    return Poll::Ready(Some(Err(e)));
+                }
+                Poll::Ready(None) => {
+                    self.buffer.finalize(stream_index);
+
+                    if self.buffer.all_finalized() {
+                        self.is_finalized = true;
+                    }
+
+                    made_progress = true;
+
+                    info!(logger, "Stream completed";
+                        "buffer_size" => self.buffer.size(stream_index)
+                    );
+                }
+                Poll::Pending => {
+                    //
+                }
+            }
+        }
+
+        if made_progress
+            && let Some(completed_groups) =
+                self.buffer.completed_groups().map_err(Error::Aggregation)?
+        {
+            debug!(self.logger, "Sending completed record batch groups";
+                "num_completed_groups" => completed_groups.len()
+            );
+
+            return Poll::Ready(Some(Ok(completed_groups)));
+        }
+
+        if self.is_finalized {
+            info!(self.logger, "All streams completed");
+            return Poll::Ready(None);
+        }
+
+        // When any stream returned `Poll::Ready` but we couldn't produce
+        // output (e.g. empty batch, or data buffered but no completed
+        // groups yet), the waker was consumed by that stream's poll call
+        // and won't be re-registered until we poll it again. Schedule an
+        // immediate re-poll so those streams get polled again and their
+        // wakers are properly re-registered.
+        if needs_repoll {
+            cx.waker().wake_by_ref();
+        }
+
+        Poll::Pending
+    }
+}
+
+impl Stream for StreamAggregator {
+    type Item = Result<RecordBatchGroups, Error>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Option<Self::Item>> {
+        if self.is_finalized || self.is_failed {
+            return Poll::Ready(None);
+        }
+
+        self.poll_all_streams(cx)
+    }
+}
diff --git a/graph/src/amp/stream_aggregator/record_batch/aggregator.rs b/graph/src/amp/stream_aggregator/record_batch/aggregator.rs
new file mode 100644
index 00000000000..acce58ebdeb
--- /dev/null
+++ b/graph/src/amp/stream_aggregator/record_batch/aggregator.rs
@@ -0,0 +1,230 @@
+use std::{
+    collections::{BTreeMap, HashSet, btree_map::Entry},
+    sync::{Arc, Weak},
+};
+
+use alloy::primitives::{BlockHash, BlockNumber};
+use anyhow::{Context, Result, bail};
+use arrow::array::RecordBatch;
+
+use super::{Decoder, GroupData};
+use crate::cheap_clone::CheapClone;
+
+/// Groups record batches by block number and hash pairs.
+///
+/// This aggregator collects and organizes record batches based on their
+/// associated block identifiers.
+pub(super) struct Aggregator {
+    buffer: BTreeMap<(BlockNumber, BlockHash), GroupData>,
+    buffered_record_batches: Vec<Weak<RecordBatch>>,
+    is_finalized: bool,
+}
+
+impl Aggregator {
+    /// Creates a new empty aggregator.
+    pub(super) fn new() -> Self {
+        Self {
+            buffer: BTreeMap::new(),
+            buffered_record_batches: Vec::new(),
+            is_finalized: false,
+        }
+    }
+
+    /// Extends this aggregator with data from a new `record_batch`.
+    ///
+    /// Processes each row in the `record_batch` and groups them by block number
+    /// and hash. Each unique block is stored in the internal buffer with references
+    /// to all rows that belong to that block.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - `record_batch` does not contain block numbers or hashes
+    /// - `record_batch` contains invalid block numbers or hashes
+    /// - `record_batch` data is not ordered
+    /// - `record_batch` data is not consistent
+    ///
+    /// The returned error is deterministic.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this aggregator has already been finalized.
+    pub(super) fn extend(&mut self, record_batch: RecordBatch) -> Result<()> {
+        assert!(!self.is_finalized);
+
+        let record_batch = Arc::new(record_batch);
+        let decoder = Decoder::new(&record_batch)?;
+
+        self.buffered_record_batches
+            .push(Arc::downgrade(&record_batch));
+
+        let num_rows = record_batch.num_rows();
+        let mut record_batch_buffered: HashSet<(BlockNumber, BlockHash)> =
+            HashSet::with_capacity(num_rows);
+
+        for row_index in 0..num_rows {
+            let err_cx = || format!("invalid group data at row {row_index}");
+            let block_number = decoder.block_number(row_index).with_context(err_cx)?;
+            let block_hash = decoder.block_hash(row_index).with_context(err_cx)?;
+            let block_ptr = (block_number, block_hash);
+
+            self.ensure_incremental_update(&block_ptr)
+                .with_context(err_cx)?;
+
+            match self.buffer.entry(block_ptr) {
+                Entry::Vacant(entry) => {
+                    entry.insert(GroupData::new(record_batch.cheap_clone(), row_index));
+                    record_batch_buffered.insert(block_ptr);
+                }
+                Entry::Occupied(mut entry) => {
+                    let group_data = entry.get_mut();
+
+                    if !record_batch_buffered.contains(&block_ptr) {
+                        group_data.add(record_batch.cheap_clone(), row_index);
+                        record_batch_buffered.insert(block_ptr);
+                    } else {
+                        group_data.add_row_index(row_index);
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Returns the block number and hash pair for the most recent completed group.
+    ///
+    /// A group is considered complete when:
+    /// - There is a group with a higher block number in the internal buffer
+    /// - This aggregator is finalized
+    ///
+    /// Any group in this aggregator with a lower block number than the one returned by
+    /// this method is also considered complete.
+    pub(super) fn max_completed_block_ptr(&self) -> Option<&(BlockNumber, BlockHash)> {
+        let mut iter = self.buffer.keys().rev();
+
+        if self.is_finalized {
+            return iter.next();
+        }
+
+        iter.nth(1)
+    }
+
+    /// Returns `true` if this aggregator contains completed groups.
+    ///
+    /// A group is considered complete when:
+    /// - There is a group with a higher block number in the internal buffer
+    /// - This aggregator is finalized
+    pub(super) fn has_completed_groups(&self) -> bool {
+        (self.is_finalized && !self.buffer.is_empty()) || self.buffer.len() > 1
+    }
+
+    /// Removes and returns completed groups from this aggregator up to `max_block_ptr`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if groups cannot be converted into record batches.
+    ///
+    /// The returned error is deterministic.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `max_block_ptr` is greater than the most recent completed block in this aggregator.
+    pub(super) fn completed_groups(
+        &mut self,
+        max_block_ptr: &(BlockNumber, BlockHash),
+    ) -> Result<Option<BTreeMap<(BlockNumber, BlockHash), RecordBatch>>> {
+        if self.buffer.is_empty() {
+            return Ok(None);
+        }
+
+        let Some(max_completed_block_ptr) = self.max_completed_block_ptr() else {
+            return Ok(None);
+        };
+
+        assert!(max_block_ptr <= max_completed_block_ptr);
+        let incomplete_groups = self.buffer.split_off(max_block_ptr);
+        let mut completed_groups = std::mem::replace(&mut self.buffer, incomplete_groups);
+
+        if let Some((block_ptr, _)) = self.buffer.first_key_value()
+            && block_ptr == max_block_ptr
+        {
+            let (block_ptr, group_data) = self.buffer.pop_first().unwrap();
+            completed_groups.insert(block_ptr, group_data);
+        }
+
+        if completed_groups.is_empty() {
+            return Ok(None);
+        }
+
+        let completed_groups = completed_groups
+            .into_iter()
+            .map(|(block_ptr, group_data)| Ok((block_ptr, group_data.into_record_batch()?)))
+            .collect::<Result<BTreeMap<_, _>>>()?;
+
+        self.buffered_record_batches
+            .retain(|weak_ref| weak_ref.strong_count() > 0);
+
+        Ok(Some(completed_groups))
+    }
+
+    /// Marks this aggregator as finalized.
+    ///
+    /// A finalized aggregator cannot be extended.
+    pub(super) fn finalize(&mut self) {
+        self.is_finalized = true;
+    }
+
+    /// Returns `true` if this aggregator is finalized.
+    pub(super) fn is_finalized(&self) -> bool {
+        self.is_finalized
+    }
+
+    /// Returns the number of record batches that this aggregator holds strong references to.
+    pub(super) fn len(&self) -> usize {
+        self.buffered_record_batches
+            .iter()
+            .filter(|weak_ref| weak_ref.strong_count() > 0)
+            .count()
+    }
+
+    /// Ensures that block updates arrive in sequential order.
+    ///
+    /// Validates that the provided block number and hash represent a valid
+    /// incremental update relative to the last block in the buffer.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The block number is less than the maximum stored block number
+    /// - The block number equals the maximum but has a different hash
+    ///
+    /// The returned error is deterministic.
+    ///
+    /// # Note
+    ///
+    /// Potential reorgs are not handled at this level and are
+    /// treated as data corruption.
+    fn ensure_incremental_update(
+        &self,
+        (block_number, block_hash): &(BlockNumber, BlockHash),
+    ) -> Result<()> {
+        let Some(((max_block_number, max_block_hash), _)) = self.buffer.last_key_value() else {
+            return Ok(());
+        };
+
+        if block_number < max_block_number {
+            bail!("received block number {block_number} after {max_block_number}");
+        }
+
+        if block_number == max_block_number && block_hash != max_block_hash {
+            bail!(
+                "received block hash '0x{}' after '0x{}' for block number {block_number}",
+                hex::encode(block_hash),
+                hex::encode(max_block_hash)
+            );
+        }
+
+        Ok(())
+    }
+}
diff --git a/graph/src/amp/stream_aggregator/record_batch/buffer.rs b/graph/src/amp/stream_aggregator/record_batch/buffer.rs
new file mode 100644
index 00000000000..476da79f0fc
--- /dev/null
+++ b/graph/src/amp/stream_aggregator/record_batch/buffer.rs
@@ -0,0 +1,210 @@
+use std::collections::{BTreeMap, btree_map::Entry};
+
+use alloy::primitives::{BlockHash, BlockNumber};
+use anyhow::{Result, bail};
+use arrow::array::RecordBatch;
+
+use super::{Aggregator, RecordBatchGroup, RecordBatchGroups, StreamRecordBatch};
+
+/// Buffers record batches from multiple streams in memory and creates
+/// groups of record batches by block number and hash pairs.
+pub(in super::super) struct Buffer {
+    aggregators: Vec<Aggregator>,
+    num_streams: usize,
+    buffer_size: usize,
+}
+
+impl Buffer {
+    /// Creates a new buffer that can handle exactly `num_streams` number of streams.
+    ///
+    /// Creates a new associated `Aggregator` for each stream.
+    /// The `buffer_size` specifies how many record batches for each stream can be buffered at most.
+    pub(in super::super) fn new(num_streams: usize, buffer_size: usize) -> Self {
+        let aggregators = (0..num_streams).map(|_| Aggregator::new()).collect();
+
+        Self {
+            aggregators,
+            num_streams,
+            buffer_size,
+        }
+    }
+
+    /// Extends the aggregator for `stream_index` with data from a new `record_batch`.
+    ///
+    /// # Errors
+    ///
+    /// Errors if the aggregator cannot be extended.
+    ///
+    /// The returned error is deterministic.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the `stream_index` is greater than the initialized number of streams.
+    pub(in super::super) fn extend(
+        &mut self,
+        stream_index: usize,
+        record_batch: RecordBatch,
+    ) -> Result<()> {
+        assert!(stream_index < self.num_streams);
+        self.aggregators[stream_index].extend(record_batch)
+    }
+
+    /// Removes and returns all completed groups from this buffer.
+    ///
+    /// # Errors
+    ///
+    /// Errors if aggregators fail to return completed groups.
+    ///
+    /// The returned error is deterministic.
+    ///
+    /// # Panics
+    ///
+    /// Panics if aggregators return inconsistent responses.
+    pub(in super::super) fn completed_groups(&mut self) -> Result<Option<RecordBatchGroups>> {
+        let Some(max_completed_block_ptr) = self.max_completed_block_ptr()? else {
+            return Ok(None);
+        };
+
+        let mut ordered_completed_groups = BTreeMap::new();
+
+        for (stream_index, agg) in self.aggregators.iter_mut().enumerate() {
+            let Some(completed_groups) = agg.completed_groups(&max_completed_block_ptr)? else {
+                continue;
+            };
+
+            for (block_ptr, record_batch) in completed_groups {
+                match ordered_completed_groups.entry(block_ptr) {
+                    Entry::Vacant(entry) => {
+                        entry.insert(RecordBatchGroup {
+                            record_batches: vec![StreamRecordBatch {
+                                stream_index,
+                                record_batch,
+                            }],
+                        });
+                    }
+                    Entry::Occupied(mut entry) => {
+                        entry.get_mut().record_batches.push(StreamRecordBatch {
+                            stream_index,
+                            record_batch,
+                        });
+                    }
+                }
+            }
+        }
+
+        assert!(!ordered_completed_groups.is_empty());
+        Ok(Some(ordered_completed_groups))
+    }
+
+    /// Marks the aggregator for the `stream_index` as finalized.
+    ///
+    /// A finalized aggregator cannot be extended.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the `stream_index` is greater than the initialized number of streams.
+    pub(in super::super) fn finalize(&mut self, stream_index: usize) {
+        assert!(stream_index < self.num_streams);
+        self.aggregators[stream_index].finalize();
+    }
+
+    /// Returns `true` if the aggregator for `stream_index` is finalized.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the `stream_index` is greater than the initialized number of streams.
+    pub(in super::super) fn is_finalized(&self, stream_index: usize) -> bool {
+        assert!(stream_index < self.num_streams);
+        self.aggregators[stream_index].is_finalized()
+    }
+
+    /// Returns `true` if all aggregators are finalized.
+    pub(in super::super) fn all_finalized(&self) -> bool {
+        self.aggregators.iter().all(|agg| agg.is_finalized())
+    }
+
+    /// Returns `true` if the aggregator for `stream_index` can be extended.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the `stream_index` is greater than the initialized number of streams.
+    pub(in super::super) fn has_capacity(&self, stream_index: usize) -> bool {
+        assert!(stream_index < self.num_streams);
+        self.aggregators[stream_index].len() < self.buffer_size
+    }
+
+    /// Returns `true` if the stream `stream_index` is not allowed to make progress and
+    /// its aggregator does not contain any completed groups.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the `stream_index` is greater than the initialized number of streams.
+    pub(in super::super) fn is_blocked(&self, stream_index: usize) -> bool {
+        !self.has_capacity(stream_index)
+            && !self.is_finalized(stream_index)
+            && !self.aggregators[stream_index].has_completed_groups()
+    }
+
+    /// Returns the number of record batches stream `stream_index` has buffered.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the `stream_index` is greater than the initialized number of streams.
+    pub(in super::super) fn size(&self, stream_index: usize) -> usize {
+        assert!(stream_index < self.num_streams);
+        self.aggregators[stream_index].len()
+    }
+
+    /// Returns the block number and hash pair for the most recent completed group across all streams.
+    ///
+    /// Finds the highest block number that all streams have completed. This ensures
+    /// slower streams can still produce valid completed groups without skipping any groups.
+    /// The function returns the minimum of all maximum completed blocks to maintain consistency.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if multiple streams return the same block number but different hashes.
+    ///
+    /// The returned error is deterministic.
+    ///
+    /// # Note
+    ///
+    /// Potential reorgs are not handled at this level and are treated as data corruption.
+    fn max_completed_block_ptr(&self) -> Result<Option<(BlockNumber, BlockHash)>> {
+        let mut max_completed_block_ptrs: BTreeMap<&BlockNumber, &BlockHash> = BTreeMap::new();
+
+        for (stream_index, agg) in self.aggregators.iter().enumerate() {
+            let Some((max_completed_block_number, max_completed_block_hash)) =
+                agg.max_completed_block_ptr()
+            else {
+                if !agg.is_finalized() {
+                    return Ok(None);
+                }
+
+                continue;
+            };
+
+            match max_completed_block_ptrs.entry(max_completed_block_number) {
+                Entry::Vacant(entry) => {
+                    entry.insert(max_completed_block_hash);
+                }
+                Entry::Occupied(entry) => {
+                    if *entry.get() != max_completed_block_hash {
+                        bail!(
+                            "aggregated data is corrupted: stream {} produced block hash '0x{}' for block {}, but a previous stream set the block hash to '0x{}'",
+                            stream_index,
+                            hex::encode(max_completed_block_hash),
+                            max_completed_block_number,
+                            hex::encode(entry.get()),
+                        );
+                    }
+                }
+            };
+        }
+
+        Ok(max_completed_block_ptrs
+            .into_iter()
+            .next()
+            .map(|(block_number, block_hash)| (*block_number, *block_hash)))
+    }
+}
diff --git a/graph/src/amp/stream_aggregator/record_batch/decoder.rs b/graph/src/amp/stream_aggregator/record_batch/decoder.rs
new file mode 100644
index 00000000000..14e5410910a
--- /dev/null
+++ b/graph/src/amp/stream_aggregator/record_batch/decoder.rs
@@ -0,0 +1,62 @@
+use alloy::primitives::{BlockHash, BlockNumber};
+use anyhow::{Result, anyhow};
+use arrow::array::RecordBatch;
+
+use crate::amp::codec::{
+    self,
+    utils::{auto_block_hash_decoder, auto_block_number_decoder},
+};
+
+/// Decodes the data required for stream aggregation.
+pub(super) struct Decoder<'a> {
+    /// Block numbers serve as group keys for related record batches.
+    block_number: Box<dyn codec::Decoder<Option<BlockNumber>> + 'a>,
+
+    /// Block hashes ensure data consistency across tables and datasets.
+    block_hash: Box<dyn codec::Decoder<Option<BlockHash>> + 'a>,
+}
+
+impl<'a> Decoder<'a> {
+    /// Constructs a new decoder for `record_batch`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - `record_batch` does not contain valid block number or hash columns
+    ///
+    /// The returned error is deterministic.
+    pub(super) fn new(record_batch: &'a RecordBatch) -> Result<Self> {
+        Ok(Self {
+            block_number: auto_block_number_decoder(record_batch)?.1,
+            block_hash: auto_block_hash_decoder(record_batch)?.1,
+        })
+    }
+
+    /// Returns the block number at `row_index`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The block number at `row_index` is null
+    ///
+    /// The returned error is deterministic.
+    pub(super) fn block_number(&self, row_index: usize) -> Result<BlockNumber> {
+        self.block_number
+            .decode(row_index)?
+            .ok_or_else(|| anyhow!("block number is empty"))
+    }
+
+    /// Returns the block hash at `row_index`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - The block hash at `row_index` is null or invalid
+    ///
+    /// The returned error is deterministic.
+    pub(super) fn block_hash(&self, row_index: usize) -> Result<BlockHash> {
+        self.block_hash
+            .decode(row_index)?
+            .ok_or_else(|| anyhow!("block hash is empty"))
+    }
+}
diff --git a/graph/src/amp/stream_aggregator/record_batch/group_data.rs b/graph/src/amp/stream_aggregator/record_batch/group_data.rs
new file mode 100644
index 00000000000..32d3317c585
--- /dev/null
+++ b/graph/src/amp/stream_aggregator/record_batch/group_data.rs
@@ -0,0 +1,88 @@
+use std::sync::Arc;
+
+use anyhow::{Context, Result};
+use arrow::{
+    array::{RecordBatch, UInt64Array},
+    compute::{concat_batches, take_record_batch},
+};
+
+/// Contains references to all record batches and rows of a group.
+pub(super) struct GroupData {
+    parts: Vec<Part>,
+}
+
+struct Part {
+    record_batch: Arc<RecordBatch>,
+    row_indices: Vec<u64>,
+}
+
+impl GroupData {
+    /// Creates a new group with an initial `record_batch` and `row_index`.
+    pub(super) fn new(record_batch: Arc<RecordBatch>, row_index: usize) -> Self {
+        Self {
+            parts: vec![Part {
+                record_batch,
+                row_indices: vec![row_index as u64],
+            }],
+        }
+    }
+
+    /// Adds a new `record_batch` and `row_index` to this group.
+    pub(super) fn add(&mut self, record_batch: Arc<RecordBatch>, row_index: usize) {
+        self.parts.push(Part {
+            record_batch,
+            row_indices: vec![row_index as u64],
+        })
+    }
+
+    /// Adds a `row_index` to the most recent record batch in this group.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this group is empty.
+    pub(super) fn add_row_index(&mut self, row_index: usize) {
+        assert!(!self.parts.is_empty());
+
+        self.parts
+            .last_mut()
+            .unwrap()
+            .row_indices
+            .push(row_index as u64);
+    }
+
+    /// Converts this group into a single record batch.
+    ///
+    /// Merges all group rows from all record batches together.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the record batches in this group have incompatible types.
+    ///
+    /// The returned error is deterministic.
+    ///
+    /// # Panics
+    ///
+    /// Panics if:
+    /// - This group is empty
+    /// - This group contains invalid row indices
+    pub(super) fn into_record_batch(self) -> Result<RecordBatch> {
+        assert!(!self.parts.is_empty());
+
+        let schema = self.parts[0].record_batch.schema();
+        let mut partial_record_batches = Vec::with_capacity(self.parts.len());
+
+        for part in self.parts {
+            let Part {
+                record_batch,
+                row_indices,
+            } = part;
+
+            let row_indices = UInt64Array::from(row_indices);
+            let partial_record_batch = take_record_batch(&record_batch, &row_indices).unwrap();
+
+            partial_record_batches.push(partial_record_batch);
+        }
+
+        concat_batches(&schema, &partial_record_batches).context("failed to merge record batches")
+    }
+}
diff --git a/graph/src/amp/stream_aggregator/record_batch/mod.rs b/graph/src/amp/stream_aggregator/record_batch/mod.rs
new file mode 100644
index 00000000000..171f360f5fa
--- /dev/null
+++ b/graph/src/amp/stream_aggregator/record_batch/mod.rs
@@ -0,0 +1,38 @@
+//! This module handles grouping record batches from multiple streams.
+//!
+//! # Safety
+//!
+//! The implementation occasionally uses `assert` and `unwrap` to ensure consistency
+//! between related types and methods.
+//!
+//! This is safe because the functionality is internal and not exposed to other modules.
+//!
+//! A panic indicates a critical error in the grouping algorithm.
+
+mod aggregator;
+mod buffer;
+mod decoder;
+mod group_data;
+
+use std::collections::BTreeMap;
+
+use alloy::primitives::{BlockHash, BlockNumber};
+use arrow::array::RecordBatch;
+
+use self::{aggregator::Aggregator, decoder::Decoder, group_data::GroupData};
+
+pub(super) use buffer::Buffer;
+
+/// Maps block number and hash pairs to record batches.
+pub type RecordBatchGroups = BTreeMap<(BlockNumber, BlockHash), RecordBatchGroup>;
+
+/// Contains record batches associated with a specific block number and hash pair.
+pub struct RecordBatchGroup {
+    pub record_batches: Vec<StreamRecordBatch>,
+}
+
+/// Contains a record batch and the index of its source stream.
+pub struct StreamRecordBatch {
+    pub stream_index: usize,
+    pub record_batch: RecordBatch,
+}
diff --git a/graph/src/blockchain/block_stream.rs b/graph/src/blockchain/block_stream.rs
index 7a9b61f012e..8098cfea664 100644
--- a/graph/src/blockchain/block_stream.rs
+++ b/graph/src/blockchain/block_stream.rs
@@ -1,32 +1,29 @@
-use crate::substreams::Clock;
-use crate::substreams_rpc::response::Message as SubstreamsMessage;
-use crate::substreams_rpc::BlockScopedData;
+use crate::blockchain::SubgraphFilter;
+use crate::data_source::{CausalityRegion, subgraph};
 use anyhow::Error;
 use async_stream::stream;
+use async_trait::async_trait;
 use futures03::Stream;
-use prost_types::Any;
+use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::fmt;
 use std::sync::Arc;
-use std::time::Instant;
 use thiserror::Error;
 use tokio::sync::mpsc::{self, Receiver, Sender};
 
-use super::substreams_block_stream::SubstreamsLogData;
-use super::{Block, BlockPtr, BlockTime, Blockchain};
+use super::{Block, BlockPtr, Blockchain, Trigger, TriggerFilterWrapper};
 use crate::anyhow::Result;
-use crate::components::store::{BlockNumber, DeploymentLocator};
+use crate::components::store::{BlockNumber, DeploymentLocator, SourceableStore};
 use crate::data::subgraph::UnifiedMappingApiVersion;
 use crate::firehose::{self, FirehoseEndpoint};
-use crate::schema::InputSchema;
-use crate::substreams_rpc::response::Message;
+use crate::futures03::stream::StreamExt as _;
+use crate::schema::{EntityType, InputSchema};
 use crate::{prelude::*, prometheus::labels};
 
 pub const BUFFERED_BLOCK_STREAM_SIZE: usize = 100;
 pub const FIREHOSE_BUFFER_STREAM_SIZE: usize = 1;
-pub const SUBSTREAMS_BUFFER_STREAM_SIZE: usize = 1;
 
 pub struct BufferedBlockStream<C: Blockchain> {
-    inner: Pin<Box<dyn Stream<Item = Result<BlockStreamEvent<C>, Error>> + Send>>,
+    inner: Pin<Box<dyn Stream<Item = Result<BlockStreamEvent<C>, BlockStreamError>> + Send>>,
 }
 
 impl<C: Blockchain + 'static> BufferedBlockStream<C> {
@@ -34,13 +31,14 @@ impl<C: Blockchain + 'static> BufferedBlockStream<C> {
         size_hint: usize,
         stream: Box<dyn BlockStream<C>>,
     ) -> Box<dyn BlockStream<C>> {
-        let (sender, receiver) = mpsc::channel::<Result<BlockStreamEvent<C>, Error>>(size_hint);
+        let (sender, receiver) =
+            mpsc::channel::<Result<BlockStreamEvent<C>, BlockStreamError>>(size_hint);
         crate::spawn(async move { BufferedBlockStream::stream_blocks(stream, sender).await });
 
         Box::new(BufferedBlockStream::new(receiver))
     }
 
-    pub fn new(mut receiver: Receiver<Result<BlockStreamEvent<C>, Error>>) -> Self {
+    pub fn new(mut receiver: Receiver<Result<BlockStreamEvent<C>, BlockStreamError>>) -> Self {
         let inner = stream! {
             loop {
                 let event = match receiver.recv().await {
@@ -59,7 +57,7 @@ impl<C: Blockchain + 'static> BufferedBlockStream<C> {
 
     pub async fn stream_blocks(
         mut stream: Box<dyn BlockStream<C>>,
-        sender: Sender<Result<BlockStreamEvent<C>, Error>>,
+        sender: Sender<Result<BlockStreamEvent<C>, BlockStreamError>>,
     ) -> Result<(), Error> {
         while let Some(event) = stream.next().await {
             match sender.send(event).await {
@@ -68,7 +66,7 @@ impl<C: Blockchain + 'static> BufferedBlockStream<C> {
                     return Err(anyhow!(
                         "buffered blockstream channel is closed, stopping. Err: {}",
                         err
-                    ))
+                    ));
                 }
             }
         }
@@ -84,7 +82,7 @@ impl<C: Blockchain> BlockStream<C> for BufferedBlockStream<C> {
 }
 
 impl<C: Blockchain> Stream for BufferedBlockStream<C> {
-    type Item = Result<BlockStreamEvent<C>, Error>;
+    type Item = Result<BlockStreamEvent<C>, BlockStreamError>;
 
     fn poll_next(
         mut self: Pin<&mut Self>,
@@ -95,7 +93,7 @@ impl<C: Blockchain> Stream for BufferedBlockStream<C> {
 }
 
 pub trait BlockStream<C: Blockchain>:
-    Stream<Item = Result<BlockStreamEvent<C>, Error>> + Unpin + Send
+    Stream<Item = Result<BlockStreamEvent<C>, BlockStreamError>> + Unpin + Send
 {
     fn buffer_size_hint(&self) -> usize;
 }
@@ -127,25 +125,38 @@ pub trait BlockStreamBuilder<C: Blockchain>: Send + Sync {
         unified_api_version: UnifiedMappingApiVersion,
     ) -> Result<Box<dyn BlockStream<C>>>;
 
-    async fn build_substreams(
+    async fn build_polling(
         &self,
         chain: &C,
-        schema: InputSchema,
         deployment: DeploymentLocator,
-        block_cursor: FirehoseCursor,
+        start_blocks: Vec<BlockNumber>,
+        source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
         subgraph_current_block: Option<BlockPtr>,
-        filter: Arc<C::TriggerFilter>,
+        filter: Arc<TriggerFilterWrapper<C>>,
+        unified_api_version: UnifiedMappingApiVersion,
     ) -> Result<Box<dyn BlockStream<C>>>;
 
-    async fn build_polling(
+    async fn build_subgraph_block_stream(
         &self,
         chain: &C,
         deployment: DeploymentLocator,
         start_blocks: Vec<BlockNumber>,
+        source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
         subgraph_current_block: Option<BlockPtr>,
-        filter: Arc<C::TriggerFilter>,
+        filter: Arc<TriggerFilterWrapper<C>>,
         unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<C>>>;
+    ) -> Result<Box<dyn BlockStream<C>>> {
+        self.build_polling(
+            chain,
+            deployment,
+            start_blocks,
+            source_subgraph_stores,
+            subgraph_current_block,
+            filter,
+            unified_api_version,
+        )
+        .await
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -196,7 +207,7 @@ impl AsRef<Option<String>> for FirehoseCursor {
 #[derive(Debug)]
 pub struct BlockWithTriggers<C: Blockchain> {
     pub block: C::Block,
-    pub trigger_data: Vec<C::TriggerData>,
+    pub trigger_data: Vec<Trigger<C>>,
 }
 
 impl<C: Blockchain> Clone for BlockWithTriggers<C>
@@ -214,7 +225,31 @@ where
 impl<C: Blockchain> BlockWithTriggers<C> {
     /// Creates a BlockWithTriggers structure, which holds
     /// the trigger data ordered and without any duplicates.
-    pub fn new(block: C::Block, mut trigger_data: Vec<C::TriggerData>, logger: &Logger) -> Self {
+    pub fn new(block: C::Block, trigger_data: Vec<C::TriggerData>, logger: &Logger) -> Self {
+        Self::new_with_triggers(
+            block,
+            trigger_data.into_iter().map(Trigger::Chain).collect(),
+            logger,
+        )
+    }
+
+    pub fn new_with_subgraph_triggers(
+        block: C::Block,
+        trigger_data: Vec<subgraph::TriggerData>,
+        logger: &Logger,
+    ) -> Self {
+        Self::new_with_triggers(
+            block,
+            trigger_data.into_iter().map(Trigger::Subgraph).collect(),
+            logger,
+        )
+    }
+
+    fn new_with_triggers(
+        block: C::Block,
+        mut trigger_data: Vec<Trigger<C>>,
+        logger: &Logger,
+    ) -> Self {
         // This is where triggers get sorted.
         trigger_data.sort();
 
@@ -254,18 +289,304 @@ impl<C: Blockchain> BlockWithTriggers<C> {
     pub fn parent_ptr(&self) -> Option<BlockPtr> {
         self.block.parent_ptr()
     }
+
+    pub fn extend_triggers(&mut self, triggers: Vec<Trigger<C>>) {
+        self.trigger_data.extend(triggers);
+        self.trigger_data.sort();
+    }
+}
+
+/// The `TriggersAdapterWrapper` wraps the chain-specific `TriggersAdapter`, enabling chain-agnostic
+/// handling of subgraph datasource triggers. Without this wrapper, we would have to duplicate the same
+/// logic for each chain, increasing code repetition.
+pub struct TriggersAdapterWrapper<C: Blockchain> {
+    pub adapter: Arc<dyn TriggersAdapter<C>>,
+    pub source_subgraph_stores: HashMap<DeploymentHash, Arc<dyn SourceableStore>>,
+}
+
+impl<C: Blockchain> TriggersAdapterWrapper<C> {
+    pub fn new(
+        adapter: Arc<dyn TriggersAdapter<C>>,
+        source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
+    ) -> Self {
+        let stores_map: HashMap<_, _> = source_subgraph_stores
+            .iter()
+            .map(|store| (store.input_schema().id().clone(), store.clone()))
+            .collect();
+        Self {
+            adapter,
+            source_subgraph_stores: stores_map,
+        }
+    }
+
+    pub async fn blocks_with_subgraph_triggers(
+        &self,
+        logger: &Logger,
+        filters: &[SubgraphFilter],
+        range: SubgraphTriggerScanRange<C>,
+    ) -> Result<Vec<BlockWithTriggers<C>>, Error> {
+        if filters.is_empty() {
+            return Err(anyhow!("No subgraph filters provided"));
+        }
+
+        let (blocks, hash_to_entities) = match range {
+            SubgraphTriggerScanRange::Single(block) => {
+                let hash_to_entities = self
+                    .fetch_entities_for_filters(filters, block.number(), block.number())
+                    .await?;
+
+                (vec![block], hash_to_entities)
+            }
+            SubgraphTriggerScanRange::Range(from, to) => {
+                let hash_to_entities = self.fetch_entities_for_filters(filters, from, to).await?;
+
+                // Get block numbers that have entities
+                let mut block_numbers: BTreeSet<_> = hash_to_entities
+                    .iter()
+                    .flat_map(|(_, entities, _)| entities.keys().copied())
+                    .collect();
+
+                // Always include the last block in the range
+                block_numbers.insert(to);
+
+                let blocks = self
+                    .adapter
+                    .load_block_ptrs_by_numbers(logger.clone(), block_numbers)
+                    .await?;
+
+                (blocks, hash_to_entities)
+            }
+        };
+
+        create_subgraph_triggers::<C>(logger.clone(), blocks, hash_to_entities).await
+    }
+
+    async fn fetch_entities_for_filters(
+        &self,
+        filters: &[SubgraphFilter],
+        from: BlockNumber,
+        to: BlockNumber,
+    ) -> Result<
+        Vec<(
+            DeploymentHash,
+            BTreeMap<BlockNumber, Vec<EntitySourceOperation>>,
+            u32,
+        )>,
+        Error,
+    > {
+        let futures = filters
+            .iter()
+            .filter_map(|filter| {
+                self.source_subgraph_stores
+                    .get(&filter.subgraph)
+                    .map(|store| {
+                        let store = store.clone();
+                        let schema = store.input_schema();
+
+                        async move {
+                            let entities =
+                                get_entities_for_range(&store, filter, &schema, from, to).await?;
+                            Ok::<_, Error>((filter.subgraph.clone(), entities, filter.manifest_idx))
+                        }
+                    })
+            })
+            .collect::<Vec<_>>();
+
+        if futures.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        futures03::future::try_join_all(futures).await
+    }
+}
+
+fn create_subgraph_trigger_from_entities(
+    subgraph: &DeploymentHash,
+    entities: Vec<EntitySourceOperation>,
+    manifest_idx: u32,
+) -> Vec<subgraph::TriggerData> {
+    entities
+        .into_iter()
+        .map(|entity| subgraph::TriggerData {
+            source: subgraph.clone(),
+            entity,
+            source_idx: manifest_idx,
+        })
+        .collect()
+}
+
+async fn create_subgraph_triggers<C: Blockchain>(
+    logger: Logger,
+    blocks: Vec<C::Block>,
+    subgraph_data: Vec<(
+        DeploymentHash,
+        BTreeMap<BlockNumber, Vec<EntitySourceOperation>>,
+        u32,
+    )>,
+) -> Result<Vec<BlockWithTriggers<C>>, Error> {
+    let logger_clone = logger.cheap_clone();
+    let blocks: Vec<BlockWithTriggers<C>> = blocks
+        .into_iter()
+        .map(|block| {
+            let block_number = block.number();
+            let mut all_trigger_data = Vec::new();
+
+            for (hash, entities, manifest_idx) in subgraph_data.iter() {
+                if let Some(block_entities) = entities.get(&block_number) {
+                    let trigger_data = create_subgraph_trigger_from_entities(
+                        hash,
+                        block_entities.clone(),
+                        *manifest_idx,
+                    );
+                    all_trigger_data.extend(trigger_data);
+                }
+            }
+
+            BlockWithTriggers::new_with_subgraph_triggers(block, all_trigger_data, &logger_clone)
+        })
+        .collect();
+
+    Ok(blocks)
+}
+
+pub enum SubgraphTriggerScanRange<C: Blockchain> {
+    Single(C::Block),
+    Range(BlockNumber, BlockNumber),
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum EntityOperationKind {
+    Create,
+    Modify,
+    Delete,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct EntitySourceOperation {
+    pub entity_op: EntityOperationKind,
+    pub entity_type: EntityType,
+    pub entity: Entity,
+    pub vid: i64,
+}
+
+async fn get_entities_for_range(
+    store: &Arc<dyn SourceableStore>,
+    filter: &SubgraphFilter,
+    schema: &InputSchema,
+    from: BlockNumber,
+    to: BlockNumber,
+) -> Result<BTreeMap<BlockNumber, Vec<EntitySourceOperation>>, Error> {
+    let entity_types: Result<Vec<EntityType>> = filter
+        .entities
+        .iter()
+        .map(|name| schema.entity_type(name))
+        .collect();
+    Ok(store
+        .get_range(entity_types?, CausalityRegion::ONCHAIN, from..to)
+        .await?)
+}
+
+impl<C: Blockchain> TriggersAdapterWrapper<C> {
+    pub async fn ancestor_block(
+        &self,
+        ptr: BlockPtr,
+        offset: BlockNumber,
+        root: Option<BlockHash>,
+    ) -> Result<Option<C::Block>, Error> {
+        self.adapter.ancestor_block(ptr, offset, root).await
+    }
+
+    pub async fn scan_triggers(
+        &self,
+        logger: &Logger,
+        from: BlockNumber,
+        to: BlockNumber,
+        filter: &Arc<TriggerFilterWrapper<C>>,
+    ) -> Result<(Vec<BlockWithTriggers<C>>, BlockNumber), Error> {
+        if !filter.subgraph_filter.is_empty() {
+            let blocks_with_triggers = self
+                .blocks_with_subgraph_triggers(
+                    logger,
+                    &filter.subgraph_filter,
+                    SubgraphTriggerScanRange::Range(from, to),
+                )
+                .await?;
+
+            return Ok((blocks_with_triggers, to));
+        }
+
+        self.adapter
+            .scan_triggers(from, to, &filter.chain_filter)
+            .await
+    }
+
+    pub async fn triggers_in_block(
+        &self,
+        logger: &Logger,
+        block: C::Block,
+        filter: &Arc<TriggerFilterWrapper<C>>,
+    ) -> Result<BlockWithTriggers<C>, Error> {
+        trace!(
+            logger,
+            "triggers_in_block";
+            "block_number" => block.number(),
+            "block_hash" => block.hash().hash_hex(),
+        );
+
+        if !filter.subgraph_filter.is_empty() {
+            let blocks_with_triggers = self
+                .blocks_with_subgraph_triggers(
+                    logger,
+                    &filter.subgraph_filter,
+                    SubgraphTriggerScanRange::Single(block),
+                )
+                .await?;
+
+            return Ok(blocks_with_triggers.into_iter().next().unwrap());
+        }
+
+        self.adapter
+            .triggers_in_block(logger, block, &filter.chain_filter)
+            .await
+    }
+
+    pub async fn is_on_main_chain(&self, ptr: BlockPtr) -> Result<bool, Error> {
+        self.adapter.is_on_main_chain(ptr).await
+    }
+
+    pub async fn parent_ptr(&self, block: &BlockPtr) -> Result<Option<BlockPtr>, Error> {
+        self.adapter.parent_ptr(block).await
+    }
+
+    pub async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error> {
+        if self.source_subgraph_stores.is_empty() {
+            return self.adapter.chain_head_ptr().await;
+        }
+
+        let ptrs = futures03::future::try_join_all(
+            self.source_subgraph_stores
+                .values()
+                .map(|store| store.block_ptr()),
+        )
+        .await?;
+
+        let min_ptr = ptrs.into_iter().flatten().min_by_key(|ptr| ptr.number);
+
+        Ok(min_ptr)
+    }
 }
 
 #[async_trait]
 pub trait TriggersAdapter<C: Blockchain>: Send + Sync {
-    // Return the block that is `offset` blocks before the block pointed to
-    // by `ptr` from the local cache. An offset of 0 means the block itself,
-    // an offset of 1 means the block's parent etc. If the block is not in
-    // the local cache, return `None`
+    // Return the block that is `offset` blocks before the block pointed to by `ptr` from the local
+    // cache. An offset of 0 means the block itself, an offset of 1 means the block's parent etc. If
+    // `root` is passed, short-circuit upon finding a child of `root`. If the block is not in the
+    // local cache, return `None`.
     async fn ancestor_block(
         &self,
         ptr: BlockPtr,
         offset: BlockNumber,
+        root: Option<BlockHash>,
     ) -> Result<Option<C::Block>, Error>;
 
     // Returns a sequence of blocks in increasing order of block number.
@@ -279,7 +600,7 @@ pub trait TriggersAdapter<C: Blockchain>: Send + Sync {
         from: BlockNumber,
         to: BlockNumber,
         filter: &C::TriggerFilter,
-    ) -> Result<Vec<BlockWithTriggers<C>>, Error>;
+    ) -> Result<(Vec<BlockWithTriggers<C>>, BlockNumber), Error>;
 
     // Used for reprocessing blocks when creating a data source.
     async fn triggers_in_block(
@@ -295,6 +616,15 @@ pub trait TriggersAdapter<C: Blockchain>: Send + Sync {
 
     /// Get pointer to parent of `block`. This is called when reverting `block`.
     async fn parent_ptr(&self, block: &BlockPtr) -> Result<Option<BlockPtr>, Error>;
+
+    /// Get pointer to parent of `block`. This is called when reverting `block`.
+    async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error>;
+
+    async fn load_block_ptrs_by_numbers(
+        &self,
+        logger: Logger,
+        block_numbers: BTreeSet<BlockNumber>,
+    ) -> Result<Vec<C::Block>>;
 }
 
 #[async_trait]
@@ -340,109 +670,13 @@ pub trait FirehoseMapper<C: Blockchain>: Send + Sync {
 
 #[async_trait]
 pub trait BlockStreamMapper<C: Blockchain>: Send + Sync {
-    fn decode_block(&self, output: Option<&[u8]>) -> Result<Option<C::Block>, Error>;
+    fn decode_block(&self, output: Option<&[u8]>) -> Result<Option<C::Block>, BlockStreamError>;
 
     async fn block_with_triggers(
         &self,
         logger: &Logger,
         block: C::Block,
-    ) -> Result<BlockWithTriggers<C>, Error>;
-
-    async fn handle_substreams_block(
-        &self,
-        logger: &Logger,
-        clock: Clock,
-        cursor: FirehoseCursor,
-        block: Vec<u8>,
-    ) -> Result<BlockStreamEvent<C>, Error>;
-
-    async fn to_block_stream_event(
-        &self,
-        logger: &mut Logger,
-        message: Option<Message>,
-        log_data: &mut SubstreamsLogData,
-    ) -> Result<Option<BlockStreamEvent<C>>, SubstreamsError> {
-        match message {
-            Some(SubstreamsMessage::Session(session_init)) => {
-                info!(
-                    &logger,
-                    "Received session init";
-                    "session" => format!("{:?}", session_init),
-                );
-                log_data.trace_id = session_init.trace_id;
-                return Ok(None);
-            }
-            Some(SubstreamsMessage::BlockUndoSignal(undo)) => {
-                let valid_block = match undo.last_valid_block {
-                    Some(clock) => clock,
-                    None => return Err(SubstreamsError::InvalidUndoError),
-                };
-                let valid_ptr = BlockPtr {
-                    hash: valid_block.id.trim_start_matches("0x").try_into()?,
-                    number: valid_block.number as i32,
-                };
-                log_data.last_seen_block = valid_block.number;
-                return Ok(Some(BlockStreamEvent::Revert(
-                    valid_ptr,
-                    FirehoseCursor::from(undo.last_valid_cursor.clone()),
-                )));
-            }
-
-            Some(SubstreamsMessage::BlockScopedData(block_scoped_data)) => {
-                let BlockScopedData {
-                    output,
-                    clock,
-                    cursor,
-                    final_block_height: _,
-                    debug_map_outputs: _,
-                    debug_store_outputs: _,
-                } = block_scoped_data;
-
-                let module_output = match output {
-                    Some(out) => out,
-                    None => return Ok(None),
-                };
-
-                let clock = match clock {
-                    Some(clock) => clock,
-                    None => return Err(SubstreamsError::MissingClockError),
-                };
-
-                let value = match module_output.map_output {
-                    Some(Any { type_url: _, value }) => value,
-                    None => return Ok(None),
-                };
-
-                log_data.last_seen_block = clock.number;
-                let cursor = FirehoseCursor::from(cursor);
-
-                let event = self
-                    .handle_substreams_block(&logger, clock, cursor, value)
-                    .await?;
-
-                Ok(Some(event))
-            }
-
-            Some(SubstreamsMessage::Progress(progress)) => {
-                if log_data.last_progress.elapsed() > Duration::from_secs(30) {
-                    info!(&logger, "{}", log_data.info_string(&progress); "trace_id" => &log_data.trace_id);
-                    debug!(&logger, "{}", log_data.debug_string(&progress); "trace_id" => &log_data.trace_id);
-                    trace!(
-                        &logger,
-                        "Received progress update";
-                        "progress" => format!("{:?}", progress),
-                        "trace_id" => &log_data.trace_id,
-                    );
-                    log_data.last_progress = Instant::now();
-                }
-                Ok(None)
-            }
-
-            // ignoring Progress messages and SessionInit
-            // We are only interested in Data and Undo signals
-            _ => Ok(None),
-        }
-    }
+    ) -> Result<BlockWithTriggers<C>, BlockStreamError>;
 }
 
 #[derive(Error, Debug)]
@@ -456,30 +690,21 @@ pub enum FirehoseError {
     UnknownError(#[from] anyhow::Error),
 }
 
-#[derive(Error, Debug)]
-pub enum SubstreamsError {
-    #[error("response is missing the clock information")]
-    MissingClockError,
-
-    #[error("invalid undo message")]
-    InvalidUndoError,
-
-    /// We were unable to decode the received block payload into the chain specific Block struct (e.g. chain_ethereum::pb::Block)
-    #[error("received gRPC block payload cannot be decoded: {0}")]
-    DecodingError(#[from] prost::DecodeError),
-
-    /// Some unknown error occurred
-    #[error("unknown error")]
-    UnknownError(#[from] anyhow::Error),
-
-    #[error("multiple module output error")]
-    MultipleModuleOutputError,
-
-    #[error("module output was not available (none) or wrong data provided")]
-    ModuleOutputNotPresentOrUnexpected,
+impl From<BlockStreamError> for FirehoseError {
+    fn from(value: BlockStreamError) -> Self {
+        match value {
+            BlockStreamError::ProtobufDecodingError(e) => FirehoseError::DecodingError(e),
+            e => FirehoseError::UnknownError(anyhow!(e.to_string())),
+        }
+    }
+}
 
-    #[error("unexpected store delta output")]
-    UnexpectedStoreDeltaOutput,
+#[derive(Debug, Error)]
+pub enum BlockStreamError {
+    #[error("Failed to decode protobuf {0}")]
+    ProtobufDecodingError(#[from] prost::DecodeError),
+    #[error("block stream error {0}")]
+    Unknown(#[from] anyhow::Error),
 }
 
 #[derive(Debug)]
@@ -488,32 +713,11 @@ pub enum BlockStreamEvent<C: Blockchain> {
     Revert(BlockPtr, FirehoseCursor),
 
     ProcessBlock(BlockWithTriggers<C>, FirehoseCursor),
-    ProcessWasmBlock(BlockPtr, BlockTime, Box<[u8]>, String, FirehoseCursor),
-}
-
-impl<C: Blockchain> Clone for BlockStreamEvent<C>
-where
-    C::TriggerData: Clone,
-{
-    fn clone(&self) -> Self {
-        match self {
-            Self::Revert(arg0, arg1) => Self::Revert(arg0.clone(), arg1.clone()),
-            Self::ProcessBlock(arg0, arg1) => Self::ProcessBlock(arg0.clone(), arg1.clone()),
-            Self::ProcessWasmBlock(arg0, arg1, arg2, arg3, arg4) => Self::ProcessWasmBlock(
-                arg0.clone(),
-                arg1.clone(),
-                arg2.clone(),
-                arg3.clone(),
-                arg4.clone(),
-            ),
-        }
-    }
 }
 
 #[derive(Clone)]
 pub struct BlockStreamMetrics {
     pub deployment_head: Box<Gauge>,
-    pub deployment_failed: Box<Gauge>,
     pub reverted_blocks: Gauge,
     pub stopwatch: StopwatchMetrics,
 }
@@ -541,20 +745,12 @@ impl BlockStreamMetrics {
         let deployment_head = registry
             .new_gauge(
                 "deployment_head",
-                "Track the head block number for a deployment",
+                "Tracks the most recent block number processed by a deployment",
                 labels.clone(),
             )
             .expect("failed to create `deployment_head` gauge");
-        let deployment_failed = registry
-            .new_gauge(
-                "deployment_failed",
-                "Boolean gauge to indicate whether the deployment has failed (1 == failed)",
-                labels,
-            )
-            .expect("failed to create `deployment_failed` gauge");
         Self {
             deployment_head,
-            deployment_failed,
             reverted_blocks,
             stopwatch,
         }
@@ -576,7 +772,6 @@ pub trait ChainHeadUpdateListener: Send + Sync + 'static {
 mod test {
     use std::{collections::HashSet, task::Poll};
 
-    use anyhow::Error;
     use futures03::{Stream, StreamExt, TryStreamExt};
 
     use crate::{
@@ -585,7 +780,8 @@ mod test {
     };
 
     use super::{
-        BlockStream, BlockStreamEvent, BlockWithTriggers, BufferedBlockStream, FirehoseCursor,
+        BlockStream, BlockStreamError, BlockStreamEvent, BlockWithTriggers, BufferedBlockStream,
+        FirehoseCursor,
     };
 
     #[derive(Debug)]
@@ -600,7 +796,7 @@ mod test {
     }
 
     impl Stream for TestStream {
-        type Item = Result<BlockStreamEvent<MockBlockchain>, Error>;
+        type Item = Result<BlockStreamEvent<MockBlockchain>, BlockStreamError>;
 
         fn poll_next(
             mut self: std::pin::Pin<&mut Self>,
@@ -619,7 +815,7 @@ mod test {
         }
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn consume_stream() {
         let initial_block = 100;
         let buffer_size = 5;
@@ -631,7 +827,7 @@ mod test {
 
         let mut stream = BufferedBlockStream::spawn_from_stream(buffer_size, stream)
             .map_err(CancelableError::Error)
-            .cancelable(&guard, || Err(CancelableError::Cancel));
+            .cancelable(&guard);
 
         let mut blocks = HashSet::<MockBlock>::new();
         let mut count = 0;
diff --git a/graph/src/blockchain/builder.rs b/graph/src/blockchain/builder.rs
deleted file mode 100644
index 3ea1464a2a3..00000000000
--- a/graph/src/blockchain/builder.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use super::Blockchain;
-use crate::{
-    components::store::ChainStore, env::EnvVars, firehose::FirehoseEndpoints,
-    prelude::LoggerFactory, prelude::MetricsRegistry,
-};
-use std::sync::Arc;
-
-/// An implementor of [`BlockchainBuilder`] for chains that don't require
-/// particularly fancy builder logic.
-pub struct BasicBlockchainBuilder {
-    pub logger_factory: LoggerFactory,
-    pub name: String,
-    pub chain_store: Arc<dyn ChainStore>,
-    pub firehose_endpoints: FirehoseEndpoints,
-    pub metrics_registry: Arc<MetricsRegistry>,
-}
-
-/// Something that can build a [`Blockchain`].
-pub trait BlockchainBuilder<C>
-where
-    C: Blockchain,
-{
-    fn build(self, config: &Arc<EnvVars>) -> C;
-}
diff --git a/graph/src/blockchain/client.rs b/graph/src/blockchain/client.rs
index 4f853569e87..1ac1b4f892c 100644
--- a/graph/src/blockchain/client.rs
+++ b/graph/src/blockchain/client.rs
@@ -17,20 +17,11 @@ pub enum ChainClient<C: Blockchain> {
 
 impl<C: Blockchain> ChainClient<C> {
     pub fn new_firehose(firehose_endpoints: FirehoseEndpoints) -> Self {
-        Self::new(firehose_endpoints, C::Client::default())
+        Self::Firehose(firehose_endpoints)
     }
-    pub fn new(firehose_endpoints: FirehoseEndpoints, adapters: C::Client) -> Self {
-        // If we can get a firehose endpoint then we should prioritise it.
-        // the reason we want to test this by getting an adapter is because
-        // adapter limits in the configuration can effectively disable firehose
-        // by setting a limit to 0.
-        // In this case we should fallback to an rpc client.
-        let firehose_available = firehose_endpoints.endpoint().is_ok();
 
-        match firehose_available {
-            true => Self::Firehose(firehose_endpoints),
-            false => Self::Rpc(adapters),
-        }
+    pub fn new_rpc(rpc: C::Client) -> Self {
+        Self::Rpc(rpc)
     }
 
     pub fn is_firehose(&self) -> bool {
@@ -40,9 +31,9 @@ impl<C: Blockchain> ChainClient<C> {
         }
     }
 
-    pub fn firehose_endpoint(&self) -> anyhow::Result<Arc<FirehoseEndpoint>> {
+    pub async fn firehose_endpoint(&self) -> anyhow::Result<Arc<FirehoseEndpoint>> {
         match self {
-            ChainClient::Firehose(endpoints) => endpoints.endpoint(),
+            ChainClient::Firehose(endpoints) => endpoints.endpoint().await,
             _ => Err(anyhow!("firehose endpoint requested on rpc chain client")),
         }
     }
@@ -50,7 +41,7 @@ impl<C: Blockchain> ChainClient<C> {
     pub fn rpc(&self) -> anyhow::Result<&C::Client> {
         match self {
             Self::Rpc(rpc) => Ok(rpc),
-            _ => Err(anyhow!("rpc endpoint requested on firehose chain client")),
+            Self::Firehose(_) => Err(anyhow!("rpc endpoint requested on firehose chain client")),
         }
     }
 }
diff --git a/graph/src/blockchain/firehose_block_ingestor.rs b/graph/src/blockchain/firehose_block_ingestor.rs
index 97703a7a93d..1a0ff0f2c06 100644
--- a/graph/src/blockchain/firehose_block_ingestor.rs
+++ b/graph/src/blockchain/firehose_block_ingestor.rs
@@ -2,9 +2,9 @@ use std::{marker::PhantomData, sync::Arc, time::Duration};
 
 use crate::{
     blockchain::Block as BlockchainBlock,
-    components::store::ChainStore,
-    firehose::{self, decode_firehose_block, HeaderOnly},
-    prelude::{error, info, Logger},
+    components::store::ChainHeadStore,
+    firehose::{self, HeaderOnly, decode_firehose_block},
+    prelude::{Logger, error, info},
     util::backoff::ExponentialBackoff,
 };
 use anyhow::{Context, Error};
@@ -15,7 +15,8 @@ use prost_types::Any;
 use slog::{o, trace};
 use tonic::Streaming;
 
-use super::{client::ChainClient, BlockIngestor, Blockchain};
+use super::{BlockIngestor, Blockchain, BlockchainKind, client::ChainClient};
+use crate::components::network_provider::ChainName;
 
 const TRANSFORM_ETHEREUM_HEADER_ONLY: &str =
     "type.googleapis.com/sf.ethereum.transform.v1.HeaderOnly";
@@ -39,11 +40,11 @@ pub struct FirehoseBlockIngestor<M, C: Blockchain>
 where
     M: prost::Message + BlockchainBlock + Default + 'static,
 {
-    chain_store: Arc<dyn ChainStore>,
+    chain_head_store: Arc<dyn ChainHeadStore>,
     client: Arc<ChainClient<C>>,
     logger: Logger,
     default_transforms: Vec<Transforms>,
-    chain_name: String,
+    chain_name: ChainName,
 
     phantom: PhantomData<M>,
 }
@@ -53,13 +54,13 @@ where
     M: prost::Message + BlockchainBlock + Default + 'static,
 {
     pub fn new(
-        chain_store: Arc<dyn ChainStore>,
+        chain_head_store: Arc<dyn ChainHeadStore>,
         client: Arc<ChainClient<C>>,
         logger: Logger,
-        chain_name: String,
+        chain_name: ChainName,
     ) -> FirehoseBlockIngestor<M, C> {
         FirehoseBlockIngestor {
-            chain_store,
+            chain_head_store,
             client,
             logger,
             phantom: PhantomData {},
@@ -77,7 +78,7 @@ where
         let mut backoff =
             ExponentialBackoff::new(Duration::from_millis(250), Duration::from_secs(30));
         loop {
-            match self.chain_store.clone().chain_head_cursor() {
+            match self.chain_head_store.clone().chain_head_cursor().await {
                 Ok(cursor) => return cursor.unwrap_or_default(),
                 Err(e) => {
                     error!(self.logger, "Fetching chain head cursor failed: {:#}", e);
@@ -104,7 +105,7 @@ where
         while let Some(message) = stream.next().await {
             match message {
                 Ok(v) => {
-                    let step = ForkStep::from_i32(v.step)
+                    let step = ForkStep::try_from(v.step)
                         .expect("Fork step should always match to known value");
 
                     let result = match step {
@@ -148,7 +149,7 @@ where
 
         trace!(self.logger, "Received new block to ingest {}", block.ptr());
 
-        self.chain_store
+        self.chain_head_store
             .clone()
             .set_chain_head(block, response.cursor.clone())
             .await
@@ -169,7 +170,7 @@ where
             ExponentialBackoff::new(Duration::from_millis(250), Duration::from_secs(30));
 
         loop {
-            let endpoint = match self.client.firehose_endpoint() {
+            let endpoint = match self.client.firehose_endpoint().await {
                 Ok(endpoint) => endpoint,
                 Err(err) => {
                     error!(
@@ -182,7 +183,7 @@ where
             };
 
             let logger = self.logger.new(
-                o!("provider" => endpoint.provider.to_string(), "network_name"=> self.network_name()),
+                o!("provider" => endpoint.provider.to_string(), "network_name"=> self.network_name().to_string()),
             );
 
             info!(
@@ -192,14 +193,17 @@ where
 
             let result = endpoint
                 .clone()
-                .stream_blocks(firehose::Request {
-                    // Starts at current HEAD block of the chain (viewed from Firehose side)
-                    start_block_num: -1,
-                    cursor: latest_cursor.clone(),
-                    final_blocks_only: false,
-                    transforms: self.default_transforms.iter().map(|t| t.into()).collect(),
-                    ..Default::default()
-                })
+                .stream_blocks(
+                    firehose::Request {
+                        // Starts at current HEAD block of the chain (viewed from Firehose side)
+                        start_block_num: -1,
+                        cursor: latest_cursor.clone(),
+                        final_blocks_only: false,
+                        transforms: self.default_transforms.iter().map(|t| t.into()).collect(),
+                        ..Default::default()
+                    },
+                    &firehose::ConnectionHeaders::new(),
+                )
                 .await;
 
             match result {
@@ -207,7 +211,11 @@ where
                     info!(logger, "Blockstream connected, consuming blocks");
 
                     // Consume the stream of blocks until an error is hit
-                    latest_cursor = self.process_blocks(latest_cursor, stream).await
+                    let cursor = self.process_blocks(latest_cursor.clone(), stream).await;
+                    if cursor != latest_cursor {
+                        backoff.reset();
+                        latest_cursor = cursor;
+                    }
                 }
                 Err(e) => {
                     error!(logger, "Unable to connect to endpoint: {:#}", e);
@@ -219,7 +227,11 @@ where
         }
     }
 
-    fn network_name(&self) -> String {
+    fn network_name(&self) -> ChainName {
         self.chain_name.clone()
     }
+
+    fn kind(&self) -> BlockchainKind {
+        C::KIND
+    }
 }
diff --git a/graph/src/blockchain/firehose_block_stream.rs b/graph/src/blockchain/firehose_block_stream.rs
index 29febc67108..9ad0f2aa6e5 100644
--- a/graph/src/blockchain/firehose_block_stream.rs
+++ b/graph/src/blockchain/firehose_block_stream.rs
@@ -1,10 +1,10 @@
+use super::Blockchain;
 use super::block_stream::{
-    BlockStream, BlockStreamEvent, FirehoseMapper, FIREHOSE_BUFFER_STREAM_SIZE,
+    BlockStream, BlockStreamError, BlockStreamEvent, FIREHOSE_BUFFER_STREAM_SIZE, FirehoseMapper,
 };
 use super::client::ChainClient;
-use super::Blockchain;
-use crate::blockchain::block_stream::FirehoseCursor;
 use crate::blockchain::TriggerFilter;
+use crate::blockchain::block_stream::FirehoseCursor;
 use crate::prelude::*;
 use crate::util::backoff::ExponentialBackoff;
 use crate::{firehose, firehose::FirehoseEndpoint};
@@ -64,10 +64,10 @@ impl FirehoseBlockStreamMetrics {
 
     fn observe_successful_connection(&self, time: &mut Instant, provider: &str) {
         self.restarts
-            .with_label_values(&[&self.deployment, &provider, "true"])
+            .with_label_values(&[self.deployment.as_str(), provider, "true"])
             .inc();
         self.connect_duration
-            .with_label_values(&[&self.deployment, &provider])
+            .with_label_values(&[self.deployment.as_str(), provider])
             .set(time.elapsed().as_secs_f64());
 
         // Reset last connection timestamp
@@ -76,10 +76,10 @@ impl FirehoseBlockStreamMetrics {
 
     fn observe_failed_connection(&self, time: &mut Instant, provider: &str) {
         self.restarts
-            .with_label_values(&[&self.deployment, &provider, "false"])
+            .with_label_values(&[self.deployment.as_str(), provider, "false"])
             .inc();
         self.connect_duration
-            .with_label_values(&[&self.deployment, &provider])
+            .with_label_values(&[self.deployment.as_str(), provider])
             .set(time.elapsed().as_secs_f64());
 
         // Reset last connection timestamp
@@ -88,10 +88,10 @@ impl FirehoseBlockStreamMetrics {
 
     fn observe_response(&self, kind: &str, time: &mut Instant, provider: &str) {
         self.time_between_responses
-            .with_label_values(&[&self.deployment, &provider])
+            .with_label_values(&[self.deployment.as_str(), provider])
             .observe(time.elapsed().as_secs_f64());
         self.responses
-            .with_label_values(&[&self.deployment, &provider, kind])
+            .with_label_values(&[self.deployment.as_str(), provider, kind])
             .inc();
 
         // Reset last response timestamp
@@ -100,7 +100,7 @@ impl FirehoseBlockStreamMetrics {
 }
 
 pub struct FirehoseBlockStream<C: Blockchain> {
-    stream: Pin<Box<dyn Stream<Item = Result<BlockStreamEvent<C>, Error>> + Send>>,
+    stream: Pin<Box<dyn Stream<Item = Result<BlockStreamEvent<C>, BlockStreamError>> + Send>>,
 }
 
 impl<C> FirehoseBlockStream<C>
@@ -156,7 +156,7 @@ fn stream_blocks<C: Blockchain, F: FirehoseMapper<C>>(
     subgraph_current_block: Option<BlockPtr>,
     logger: Logger,
     metrics: FirehoseBlockStreamMetrics,
-) -> impl Stream<Item = Result<BlockStreamEvent<C>, Error>> {
+) -> impl Stream<Item = Result<BlockStreamEvent<C>, BlockStreamError>> {
     let mut subgraph_current_block = subgraph_current_block;
     let mut start_block_num = subgraph_current_block
         .as_ref()
@@ -203,16 +203,18 @@ fn stream_blocks<C: Blockchain, F: FirehoseMapper<C>>(
         debug!(&logger, "Going to check continuity of chain on first block");
     }
 
+    let headers = firehose::ConnectionHeaders::new().with_deployment(deployment.clone());
+
     // Back off exponentially whenever we encounter a connection error or a stream with bad data
     let mut backoff = ExponentialBackoff::new(Duration::from_millis(500), Duration::from_secs(45));
 
-    // This attribute is needed because `try_stream!` seems to break detection of `skip_backoff` assignments
-    #[allow(unused_assignments)]
-    let mut skip_backoff = false;
-
     try_stream! {
+        // This attribute is needed because `try_stream!` seems to break detection of `skip_backoff` assignments
+        #[allow(unused_assignments)]
+        let mut skip_backoff = false;
+
         loop {
-            let endpoint = client.firehose_endpoint()?;
+            let endpoint = client.firehose_endpoint().await?;
             let logger = logger.new(o!("deployment" => deployment.clone(), "provider" => endpoint.provider.to_string()));
 
             info!(
@@ -240,7 +242,7 @@ fn stream_blocks<C: Blockchain, F: FirehoseMapper<C>>(
             }
 
             let mut connect_start = Instant::now();
-            let req = endpoint.clone().stream_blocks(request);
+            let req = endpoint.clone().stream_blocks(request, &headers);
             let result = tokio::time::timeout(Duration::from_secs(120), req).await.map_err(|x| x.into()).and_then(|x| x);
 
             match result {
@@ -358,16 +360,21 @@ async fn process_firehose_response<C: Blockchain, F: FirehoseMapper<C>>(
         .context("Mapping block to BlockStreamEvent failed")?;
 
     if *check_subgraph_continuity {
-        info!(logger, "Firehose started from a subgraph pointer without an existing cursor, ensuring chain continuity");
+        info!(
+            logger,
+            "Firehose started from a subgraph pointer without an existing cursor, ensuring chain continuity"
+        );
 
         if let BlockStreamEvent::ProcessBlock(ref block, _) = event {
             let previous_block_ptr = block.parent_ptr();
             if previous_block_ptr.is_some() && previous_block_ptr.as_ref() != subgraph_current_block
             {
+                #[allow(clippy::unnecessary_unwrap)]
+                let firehose_start_block = previous_block_ptr.unwrap();
                 warn!(&logger,
                     "Firehose selected first streamed block's parent should match subgraph start block, reverting to last know final chain segment";
                     "subgraph_current_block" => &subgraph_current_block.unwrap(),
-                    "firehose_start_block" => &previous_block_ptr.unwrap(),
+                    "firehose_start_block" => &firehose_start_block,
                 );
 
                 let mut revert_to = mapper
@@ -376,7 +383,10 @@ async fn process_firehose_response<C: Blockchain, F: FirehoseMapper<C>>(
                     .context("Could not fetch final block to revert to")?;
 
                 if revert_to.number < manifest_start_block_num {
-                    warn!(&logger, "We would return before subgraph manifest's start block, limiting rewind to manifest's start block");
+                    warn!(
+                        &logger,
+                        "We would return before subgraph manifest's start block, limiting rewind to manifest's start block"
+                    );
 
                     // We must revert up to parent's of manifest start block to ensure we delete everything "including" the start
                     // block that was processed.
@@ -406,7 +416,7 @@ async fn process_firehose_response<C: Blockchain, F: FirehoseMapper<C>>(
 }
 
 impl<C: Blockchain> Stream for FirehoseBlockStream<C> {
-    type Item = Result<BlockStreamEvent<C>, Error>;
+    type Item = Result<BlockStreamEvent<C>, BlockStreamError>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         self.stream.poll_next_unpin(cx)
@@ -441,10 +451,10 @@ fn must_check_subgraph_continuity(
 #[cfg(test)]
 mod tests {
     use crate::blockchain::{
-        block_stream::FirehoseCursor, firehose_block_stream::must_check_subgraph_continuity,
-        BlockPtr,
+        BlockPtr, block_stream::FirehoseCursor,
+        firehose_block_stream::must_check_subgraph_continuity,
     };
-    use slog::{o, Logger};
+    use slog::{Logger, o};
 
     #[test]
     fn check_continuity() {
@@ -461,48 +471,64 @@ mod tests {
 
         // Nothing
 
-        assert_eq!(
-            must_check_subgraph_continuity(&logger, &no_current_block, &no_cursor, 10),
-            false,
-        );
+        assert!(!must_check_subgraph_continuity(
+            &logger,
+            &no_current_block,
+            &no_cursor,
+            10
+        ),);
 
         // No cursor, subgraph current block ptr <, ==, > than manifest start block num
 
-        assert_eq!(
-            must_check_subgraph_continuity(&logger, &some_current_block(9), &no_cursor, 10),
-            false,
-        );
-
-        assert_eq!(
-            must_check_subgraph_continuity(&logger, &some_current_block(10), &no_cursor, 10),
-            true,
-        );
-
-        assert_eq!(
-            must_check_subgraph_continuity(&logger, &some_current_block(11), &no_cursor, 10),
-            true,
-        );
+        assert!(!must_check_subgraph_continuity(
+            &logger,
+            &some_current_block(9),
+            &no_cursor,
+            10
+        ),);
+
+        assert!(must_check_subgraph_continuity(
+            &logger,
+            &some_current_block(10),
+            &no_cursor,
+            10
+        ),);
+
+        assert!(must_check_subgraph_continuity(
+            &logger,
+            &some_current_block(11),
+            &no_cursor,
+            10
+        ),);
 
         // Some cursor, subgraph current block ptr <, ==, > than manifest start block num
 
-        assert_eq!(
-            must_check_subgraph_continuity(&logger, &no_current_block, &some_cursor, 10),
-            false,
-        );
-
-        assert_eq!(
-            must_check_subgraph_continuity(&logger, &some_current_block(9), &some_cursor, 10),
-            false,
-        );
-
-        assert_eq!(
-            must_check_subgraph_continuity(&logger, &some_current_block(10), &some_cursor, 10),
-            false,
-        );
-
-        assert_eq!(
-            must_check_subgraph_continuity(&logger, &some_current_block(11), &some_cursor, 10),
-            false,
-        );
+        assert!(!must_check_subgraph_continuity(
+            &logger,
+            &no_current_block,
+            &some_cursor,
+            10
+        ),);
+
+        assert!(!must_check_subgraph_continuity(
+            &logger,
+            &some_current_block(9),
+            &some_cursor,
+            10
+        ),);
+
+        assert!(!must_check_subgraph_continuity(
+            &logger,
+            &some_current_block(10),
+            &some_cursor,
+            10
+        ),);
+
+        assert!(!must_check_subgraph_continuity(
+            &logger,
+            &some_current_block(11),
+            &some_cursor,
+            10
+        ),);
     }
 }
diff --git a/graph/src/blockchain/mock.rs b/graph/src/blockchain/mock.rs
index cc8fa9caaa7..a87e3da1fc3 100644
--- a/graph/src/blockchain/mock.rs
+++ b/graph/src/blockchain/mock.rs
@@ -1,27 +1,45 @@
 use crate::{
+    bail,
     components::{
+        ethereum::CachedBlock,
         link_resolver::LinkResolver,
-        store::{BlockNumber, DeploymentCursorTracker, DeploymentLocator},
+        network_provider::ChainName,
+        store::{
+            BlockNumber, ChainHeadStore, ChainIdStore, DeploymentCursorTracker, DeploymentLocator,
+            SourceableStore, StaleCallCacheResult,
+        },
+        subgraph::InstanceDSTemplateInfo,
+    },
+    data::subgraph::{DeploymentHash, UnifiedMappingApiVersion},
+    data_source,
+    prelude::{
+        BlockHash, ChainStore, DataSourceTemplateInfo, StoreError,
+        transaction_receipt::LightTransactionReceipt,
     },
-    data::subgraph::UnifiedMappingApiVersion,
-    prelude::DataSourceTemplateInfo,
 };
-use anyhow::Error;
+use alloy::primitives::{B256, U256};
+use anyhow::{Error, Result};
 use async_trait::async_trait;
 use serde::Deserialize;
-use std::{collections::HashSet, convert::TryFrom, sync::Arc};
+use slog::Logger;
+use std::{
+    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
+    convert::TryFrom,
+    sync::Arc,
+};
 
 use super::{
+    BlockIngestor, BlockTime, ChainIdentifier, EmptyNodeCapabilities, ExtendedBlockPtr, HostFn,
+    IngestorError, MappingTriggerTrait, NoopDecoderHook, Trigger, TriggerFilterWrapper,
+    TriggerWithHandler,
     block_stream::{self, BlockStream, FirehoseCursor},
     client::ChainClient,
-    BlockIngestor, BlockTime, EmptyNodeCapabilities, HostFn, IngestorError, MappingTriggerTrait,
-    TriggerWithHandler,
 };
 
 use super::{
-    block_stream::BlockWithTriggers, Block, BlockPtr, Blockchain, BlockchainKind, DataSource,
-    DataSourceTemplate, RuntimeAdapter, TriggerData, TriggerFilter, TriggersAdapter,
-    UnresolvedDataSource, UnresolvedDataSourceTemplate,
+    Block, BlockPtr, Blockchain, BlockchainKind, DataSource, DataSourceTemplate, RuntimeAdapter,
+    TriggerData, TriggerFilter, TriggersAdapter, UnresolvedDataSource,
+    UnresolvedDataSourceTemplate, block_stream::BlockWithTriggers,
 };
 
 #[derive(Debug)]
@@ -34,15 +52,32 @@ pub struct MockBlock {
 
 impl Block for MockBlock {
     fn ptr(&self) -> BlockPtr {
-        todo!()
+        test_ptr(self.number as i32)
     }
 
     fn parent_ptr(&self) -> Option<BlockPtr> {
-        todo!()
+        if self.number == 0 {
+            None
+        } else {
+            Some(test_ptr(self.number as i32 - 1))
+        }
     }
 
     fn timestamp(&self) -> BlockTime {
-        todo!()
+        BlockTime::since_epoch(self.ptr().number as i64 * 45 * 60, 0)
+    }
+}
+
+pub fn test_ptr(n: BlockNumber) -> BlockPtr {
+    test_ptr_reorged(n, 0)
+}
+
+pub fn test_ptr_reorged(n: BlockNumber, reorg_n: u32) -> BlockPtr {
+    let mut hash = B256::from(U256::from(n as u64));
+    hash[0..4].copy_from_slice(&reorg_n.to_be_bytes());
+    BlockPtr {
+        hash: hash.into(),
+        number: n,
     }
 }
 
@@ -53,16 +88,19 @@ pub struct MockDataSource {
     pub network: Option<String>,
 }
 
-impl<C: Blockchain> TryFrom<DataSourceTemplateInfo<C>> for MockDataSource {
+impl TryFrom<DataSourceTemplateInfo> for MockDataSource {
     type Error = Error;
 
-    fn try_from(_value: DataSourceTemplateInfo<C>) -> Result<Self, Self::Error> {
+    fn try_from(_value: DataSourceTemplateInfo) -> Result<Self, Self::Error> {
         todo!()
     }
 }
 
 impl<C: Blockchain> DataSource<C> for MockDataSource {
-    fn from_template_info(_template_info: DataSourceTemplateInfo<C>) -> Result<Self, Error> {
+    fn from_template_info(
+        _info: InstanceDSTemplateInfo,
+        _template: &crate::data_source::DataSourceTemplate<C>,
+    ) -> Result<Self, Error> {
         todo!()
     }
 
@@ -80,6 +118,10 @@ impl<C: Blockchain> DataSource<C> for MockDataSource {
             .collect()
     }
 
+    fn has_declared_calls(&self) -> bool {
+        true
+    }
+
     fn end_block(&self) -> Option<BlockNumber> {
         todo!()
     }
@@ -130,13 +172,13 @@ impl<C: Blockchain> DataSource<C> for MockDataSource {
     }
 
     fn from_stored_dynamic_data_source(
-        _template: &C::DataSourceTemplate,
+        _template: &<C as Blockchain>::DataSourceTemplate,
         _stored: crate::components::store::StoredDynamicDataSource,
     ) -> Result<Self, anyhow::Error> {
         todo!()
     }
 
-    fn validate(&self) -> Vec<anyhow::Error> {
+    fn validate(&self, _: &semver::Version) -> Vec<anyhow::Error> {
         todo!()
     }
 }
@@ -148,9 +190,11 @@ pub struct MockUnresolvedDataSource;
 impl<C: Blockchain> UnresolvedDataSource<C> for MockUnresolvedDataSource {
     async fn resolve(
         self,
+        _deployment_hash: &DeploymentHash,
         _resolver: &Arc<dyn LinkResolver>,
         _logger: &slog::Logger,
         _manifest_idx: u32,
+        _spec_version: &semver::Version,
     ) -> Result<C::DataSource, anyhow::Error> {
         todo!()
     }
@@ -159,7 +203,13 @@ impl<C: Blockchain> UnresolvedDataSource<C> for MockUnresolvedDataSource {
 #[derive(Debug, Clone)]
 pub struct MockDataSourceTemplate;
 
-impl<C: Blockchain> DataSourceTemplate<C> for MockDataSourceTemplate {
+impl From<MockDataSourceTemplate> for DataSourceTemplateInfo {
+    fn from(_val: MockDataSourceTemplate) -> Self {
+        todo!()
+    }
+}
+
+impl DataSourceTemplate<MockBlockchain> for MockDataSourceTemplate {
     fn api_version(&self) -> semver::Version {
         todo!()
     }
@@ -179,6 +229,10 @@ impl<C: Blockchain> DataSourceTemplate<C> for MockDataSourceTemplate {
     fn kind(&self) -> &str {
         todo!()
     }
+
+    fn info(&self) -> DataSourceTemplateInfo {
+        todo!()
+    }
 }
 
 #[derive(Clone, Default, Deserialize)]
@@ -188,9 +242,11 @@ pub struct MockUnresolvedDataSourceTemplate;
 impl<C: Blockchain> UnresolvedDataSourceTemplate<C> for MockUnresolvedDataSourceTemplate {
     async fn resolve(
         self,
+        _deployment_hash: &DeploymentHash,
         _resolver: &Arc<dyn LinkResolver>,
         _logger: &slog::Logger,
         _manifest_idx: u32,
+        _spec_version: &semver::Version,
     ) -> Result<C::DataSourceTemplate, anyhow::Error> {
         todo!()
     }
@@ -199,30 +255,54 @@ impl<C: Blockchain> UnresolvedDataSourceTemplate<C> for MockUnresolvedDataSource
 pub struct MockTriggersAdapter;
 
 #[async_trait]
-impl<C: Blockchain> TriggersAdapter<C> for MockTriggersAdapter {
+impl TriggersAdapter<MockBlockchain> for MockTriggersAdapter {
     async fn ancestor_block(
         &self,
         _ptr: BlockPtr,
         _offset: BlockNumber,
-    ) -> Result<Option<C::Block>, Error> {
+        _root: Option<BlockHash>,
+    ) -> Result<Option<MockBlock>, Error> {
         todo!()
     }
 
+    async fn load_block_ptrs_by_numbers(
+        &self,
+        _logger: Logger,
+        block_numbers: BTreeSet<BlockNumber>,
+    ) -> Result<Vec<MockBlock>> {
+        Ok(block_numbers
+            .into_iter()
+            .map(|number| MockBlock {
+                number: number as u64,
+            })
+            .collect())
+    }
+
+    async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error> {
+        unimplemented!()
+    }
+
     async fn scan_triggers(
         &self,
-        _from: crate::components::store::BlockNumber,
-        _to: crate::components::store::BlockNumber,
-        _filter: &C::TriggerFilter,
-    ) -> Result<Vec<block_stream::BlockWithTriggers<C>>, Error> {
-        todo!()
+        from: crate::components::store::BlockNumber,
+        to: crate::components::store::BlockNumber,
+        filter: &MockTriggerFilter,
+    ) -> Result<
+        (
+            Vec<block_stream::BlockWithTriggers<MockBlockchain>>,
+            BlockNumber,
+        ),
+        Error,
+    > {
+        blocks_with_triggers(from, to, filter).await
     }
 
     async fn triggers_in_block(
         &self,
         _logger: &slog::Logger,
-        _block: C::Block,
-        _filter: &C::TriggerFilter,
-    ) -> Result<BlockWithTriggers<C>, Error> {
+        _block: MockBlock,
+        _filter: &MockTriggerFilter,
+    ) -> Result<BlockWithTriggers<MockBlockchain>, Error> {
         todo!()
     }
 
@@ -235,6 +315,26 @@ impl<C: Blockchain> TriggersAdapter<C> for MockTriggersAdapter {
     }
 }
 
+async fn blocks_with_triggers(
+    _from: crate::components::store::BlockNumber,
+    to: crate::components::store::BlockNumber,
+    _filter: &MockTriggerFilter,
+) -> Result<
+    (
+        Vec<block_stream::BlockWithTriggers<MockBlockchain>>,
+        BlockNumber,
+    ),
+    Error,
+> {
+    Ok((
+        vec![BlockWithTriggers {
+            block: MockBlock { number: 0 },
+            trigger_data: vec![Trigger::Chain(MockTriggerData)],
+        }],
+        to,
+    ))
+}
+
 #[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub struct MockTriggerData;
 
@@ -283,7 +383,7 @@ impl<C: Blockchain> TriggerFilter<C> for MockTriggerFilter {
 pub struct MockRuntimeAdapter;
 
 impl<C: Blockchain> RuntimeAdapter<C> for MockRuntimeAdapter {
-    fn host_fns(&self, _ds: &C::DataSource) -> Result<Vec<HostFn>, Error> {
+    fn host_fns(&self, _ds: &data_source::DataSource<C>) -> Result<Vec<HostFn>, Error> {
         todo!()
     }
 }
@@ -311,6 +411,8 @@ impl Blockchain for MockBlockchain {
 
     type NodeCapabilities = EmptyNodeCapabilities<Self>;
 
+    type DecoderHook = NoopDecoderHook;
+
     fn triggers_adapter(
         &self,
         _loc: &crate::components::store::DeploymentLocator,
@@ -325,7 +427,8 @@ impl Blockchain for MockBlockchain {
         _deployment: DeploymentLocator,
         _store: impl DeploymentCursorTracker,
         _start_blocks: Vec<BlockNumber>,
-        _filter: Arc<Self::TriggerFilter>,
+        _source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
+        _filter: Arc<TriggerFilterWrapper<Self>>,
         _unified_api_version: UnifiedMappingApiVersion,
     ) -> Result<Box<dyn BlockStream<Self>>, Error> {
         todo!()
@@ -343,7 +446,7 @@ impl Blockchain for MockBlockchain {
         todo!()
     }
 
-    fn chain_store(&self) -> std::sync::Arc<dyn crate::components::store::ChainStore> {
+    async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error> {
         todo!()
     }
 
@@ -355,15 +458,165 @@ impl Blockchain for MockBlockchain {
         todo!()
     }
 
-    fn runtime_adapter(&self) -> std::sync::Arc<dyn RuntimeAdapter<Self>> {
-        todo!()
+    async fn runtime(
+        &self,
+    ) -> anyhow::Result<(std::sync::Arc<dyn RuntimeAdapter<Self>>, Self::DecoderHook)> {
+        bail!("mock has no runtime adapter")
     }
 
     fn chain_client(&self) -> Arc<ChainClient<MockBlockchain>> {
         todo!()
     }
 
-    fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>> {
+    async fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>> {
         todo!()
     }
 }
+
+// Mock implementation
+#[derive(Default)]
+pub struct MockChainStore {
+    pub blocks: BTreeMap<BlockNumber, Vec<ExtendedBlockPtr>>,
+}
+
+#[async_trait]
+impl ChainHeadStore for MockChainStore {
+    async fn chain_head_ptr(self: Arc<Self>) -> Result<Option<BlockPtr>, Error> {
+        unimplemented!()
+    }
+    async fn chain_head_cursor(&self) -> Result<Option<String>, Error> {
+        unimplemented!()
+    }
+    async fn set_chain_head(
+        self: Arc<Self>,
+        _block: Arc<dyn Block>,
+        _cursor: String,
+    ) -> Result<(), Error> {
+        unimplemented!()
+    }
+}
+
+#[async_trait]
+impl ChainStore for MockChainStore {
+    async fn block_ptrs_by_numbers(
+        self: Arc<Self>,
+        numbers: Vec<BlockNumber>,
+    ) -> Result<BTreeMap<BlockNumber, Vec<ExtendedBlockPtr>>, Error> {
+        let mut result = BTreeMap::new();
+        for num in numbers {
+            if let Some(blocks) = self.blocks.get(&num) {
+                result.insert(num, blocks.clone());
+            }
+        }
+        Ok(result)
+    }
+
+    // Implement other required methods with minimal implementations
+    async fn genesis_block_ptr(&self) -> Result<BlockPtr, Error> {
+        unimplemented!()
+    }
+    async fn upsert_block(&self, _block: Arc<dyn Block>) -> Result<(), Error> {
+        unimplemented!()
+    }
+    async fn upsert_light_blocks(&self, _blocks: &[&dyn Block]) -> Result<(), Error> {
+        unimplemented!()
+    }
+    async fn attempt_chain_head_update(
+        self: Arc<Self>,
+        _ancestor_count: BlockNumber,
+    ) -> Result<Option<B256>, Error> {
+        unimplemented!()
+    }
+    async fn blocks(self: Arc<Self>, _hashes: Vec<BlockHash>) -> Result<Vec<CachedBlock>, Error> {
+        unimplemented!()
+    }
+    async fn block_parent_ptr(
+        self: Arc<Self>,
+        _hash: &BlockHash,
+    ) -> Result<Option<BlockPtr>, Error> {
+        unimplemented!()
+    }
+    async fn ancestor_block(
+        self: Arc<Self>,
+        _block_ptr: BlockPtr,
+        _offset: BlockNumber,
+        _root: Option<BlockHash>,
+    ) -> Result<Option<(CachedBlock, BlockPtr)>, Error> {
+        unimplemented!()
+    }
+    async fn ancestor_block_ptr(
+        self: Arc<Self>,
+        _block_ptr: BlockPtr,
+        _offset: BlockNumber,
+        _root: Option<BlockHash>,
+    ) -> Result<Option<BlockPtr>, Error> {
+        unimplemented!()
+    }
+    async fn cleanup_cached_blocks(
+        &self,
+        _ancestor_count: BlockNumber,
+    ) -> Result<Option<(BlockNumber, usize)>, Error> {
+        unimplemented!()
+    }
+    async fn block_hashes_by_block_number(
+        &self,
+        _number: BlockNumber,
+    ) -> Result<Vec<BlockHash>, Error> {
+        unimplemented!()
+    }
+    async fn confirm_block_hash(
+        &self,
+        _number: BlockNumber,
+        _hash: &BlockHash,
+    ) -> Result<usize, Error> {
+        unimplemented!()
+    }
+    async fn block_number(
+        &self,
+        _hash: &BlockHash,
+    ) -> Result<Option<(String, BlockNumber, Option<u64>, Option<BlockHash>)>, StoreError> {
+        unimplemented!()
+    }
+    async fn block_numbers(
+        &self,
+        _hashes: Vec<BlockHash>,
+    ) -> Result<HashMap<BlockHash, BlockNumber>, StoreError> {
+        unimplemented!()
+    }
+    async fn transaction_receipts_in_block(
+        &self,
+        _block_ptr: &B256,
+    ) -> Result<Vec<LightTransactionReceipt>, StoreError> {
+        unimplemented!()
+    }
+    async fn clear_call_cache(&self, _from: BlockNumber, _to: BlockNumber) -> Result<(), Error> {
+        unimplemented!()
+    }
+    async fn clear_stale_call_cache(
+        &self,
+        _ttl_days: usize,
+        _max_contracts: Option<usize>,
+    ) -> Result<StaleCallCacheResult, Error> {
+        unimplemented!()
+    }
+    async fn chain_identifier(&self) -> Result<ChainIdentifier, Error> {
+        unimplemented!()
+    }
+    fn as_head_store(self: Arc<Self>) -> Arc<dyn ChainHeadStore> {
+        self.clone()
+    }
+}
+
+#[async_trait]
+impl ChainIdStore for MockChainStore {
+    async fn chain_identifier(&self, _name: &ChainName) -> Result<ChainIdentifier, Error> {
+        unimplemented!()
+    }
+    async fn set_chain_identifier(
+        &self,
+        _name: &ChainName,
+        _ident: &ChainIdentifier,
+    ) -> Result<(), Error> {
+        unimplemented!()
+    }
+}
diff --git a/graph/src/blockchain/mod.rs b/graph/src/blockchain/mod.rs
index 85787385efe..df942d19910 100644
--- a/graph/src/blockchain/mod.rs
+++ b/graph/src/blockchain/mod.rs
@@ -3,38 +3,39 @@
 //! trait which is the centerpiece of this module.
 
 pub mod block_stream;
-mod builder;
 pub mod client;
 mod empty_node_capabilities;
 pub mod firehose_block_ingestor;
 pub mod firehose_block_stream;
 pub mod mock;
 mod noop_runtime_adapter;
-pub mod polling_block_stream;
-pub mod substreams_block_stream;
 mod types;
 
 // Try to reexport most of the necessary types
 use crate::{
     cheap_clone::CheapClone,
     components::{
-        store::{DeploymentCursorTracker, DeploymentLocator, StoredDynamicDataSource},
-        subgraph::HostMetrics,
+        metrics::subgraph::SubgraphInstanceMetrics,
+        store::{
+            DeploymentCursorTracker, DeploymentLocator, SourceableStore, StoredDynamicDataSource,
+        },
+        subgraph::{HostMetrics, InstanceDSTemplateInfo, MappingError},
+        trigger_processor::RunnableTriggers,
     },
-    data::subgraph::{UnifiedMappingApiVersion, MIN_SPEC_VERSION},
-    data_source,
-    prelude::DataSourceContext,
-    runtime::{gas::GasCounter, AscHeap, HostExportError},
+    data::subgraph::{MIN_SPEC_VERSION, UnifiedMappingApiVersion},
+    data_source::{self, DataSourceTemplateInfo, subgraph},
+    prelude::{DataSourceContext, DeploymentHash},
+    runtime::{AscHeap, HostExportError, gas::GasCounter},
 };
 use crate::{
-    components::{
-        store::{BlockNumber, ChainStore},
-        subgraph::DataSourceTemplateInfo,
-    },
-    prelude::{thiserror::Error, LinkResolver},
+    components::store::BlockNumber,
+    prelude::{LinkResolver, thiserror::Error},
 };
-use anyhow::{anyhow, Context, Error};
+use alloy::primitives::B256;
+use anyhow::{Context, Error, anyhow};
 use async_trait::async_trait;
+use futures03::future::BoxFuture;
+use graph_derive::CheapClone;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use slog::Logger;
@@ -45,23 +46,23 @@ use std::{
     str::FromStr,
     sync::Arc,
 };
-use web3::types::H256;
 
 pub use block_stream::{ChainHeadUpdateListener, ChainHeadUpdateStream, TriggersAdapter};
-pub use builder::{BasicBlockchainBuilder, BlockchainBuilder};
 pub use empty_node_capabilities::EmptyNodeCapabilities;
 pub use noop_runtime_adapter::NoopRuntimeAdapter;
-pub use types::{BlockHash, BlockPtr, BlockTime, ChainIdentifier};
+pub use types::{BlockHash, BlockPtr, BlockTime, ChainIdentifier, ExtendedBlockPtr};
 
 use self::{
     block_stream::{BlockStream, FirehoseCursor},
     client::ChainClient,
 };
+use crate::components::network_provider::ChainName;
 
 #[async_trait]
 pub trait BlockIngestor: 'static + Send + Sync {
     async fn run(self: Box<Self>);
-    fn network_name(&self) -> String;
+    fn network_name(&self) -> ChainName;
+    fn kind(&self) -> BlockchainKind;
 }
 
 pub trait TriggersAdapterSelector<C: Blockchain>: Sync + Send {
@@ -147,7 +148,7 @@ pub trait Blockchain: Debug + Sized + Send + Sync + Unpin + 'static {
     const KIND: BlockchainKind;
     const ALIASES: &'static [&'static str] = &[];
 
-    type Client: Debug + Default + Sync + Send;
+    type Client: Debug + Sync + Send;
     // The `Clone` bound is used when reprocessing a block, because `triggers_in_block` requires an
     // owned `Block`. It would be good to come up with a way to remove this bound.
     type Block: Block + Clone + Debug + Default;
@@ -170,6 +171,11 @@ pub trait Blockchain: Debug + Sized + Send + Sync + Unpin + 'static {
 
     type NodeCapabilities: NodeCapabilities<Self> + std::fmt::Display;
 
+    /// A callback that is called after the triggers have been decoded and
+    /// gets an opportunity to post-process triggers before they are run on
+    /// hosts
+    type DecoderHook: DecoderHook<Self> + Sync + Send;
+
     fn triggers_adapter(
         &self,
         log: &DeploymentLocator,
@@ -182,11 +188,13 @@ pub trait Blockchain: Debug + Sized + Send + Sync + Unpin + 'static {
         deployment: DeploymentLocator,
         store: impl DeploymentCursorTracker,
         start_blocks: Vec<BlockNumber>,
-        filter: Arc<Self::TriggerFilter>,
+        source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
+        filter: Arc<TriggerFilterWrapper<Self>>,
         unified_api_version: UnifiedMappingApiVersion,
     ) -> Result<Box<dyn BlockStream<Self>>, Error>;
 
-    fn chain_store(&self) -> Arc<dyn ChainStore>;
+    /// Return the pointer for the latest block that we are aware of
+    async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error>;
 
     async fn block_pointer_from_number(
         &self,
@@ -202,11 +210,11 @@ pub trait Blockchain: Debug + Sized + Send + Sync + Unpin + 'static {
 
     fn is_refetch_block_required(&self) -> bool;
 
-    fn runtime_adapter(&self) -> Arc<dyn RuntimeAdapter<Self>>;
+    async fn runtime(&self) -> anyhow::Result<(Arc<dyn RuntimeAdapter<Self>>, Self::DecoderHook)>;
 
     fn chain_client(&self) -> Arc<ChainClient<Self>>;
 
-    fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>>;
+    async fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>>;
 }
 
 #[derive(Error, Debug)]
@@ -214,21 +222,60 @@ pub enum IngestorError {
     /// The Ethereum node does not know about this block for some reason, probably because it
     /// disappeared in a chain reorg.
     #[error("Block data unavailable, block was likely uncled (block hash = {0:?})")]
-    BlockUnavailable(H256),
+    BlockUnavailable(B256),
 
     /// The Ethereum node does not know about this block for some reason, probably because it
     /// disappeared in a chain reorg.
     #[error("Receipt for tx {1:?} unavailable, block was likely uncled (block hash = {0:?})")]
-    ReceiptUnavailable(H256, H256),
+    ReceiptUnavailable(B256, B256),
+
+    /// The Ethereum node does not know about this block for some reason
+    #[error("Transaction receipts for block (block hash = {0:?}) is unavailable")]
+    BlockReceiptsUnavailable(B256),
+
+    /// The Ethereum node does not know about this block for some reason
+    #[error("Received confliciting block receipts for block (block hash = {0:?})")]
+    BlockReceiptsMismatched(B256),
 
     /// An unexpected error occurred.
     #[error("Ingestor error: {0:#}")]
     Unknown(#[from] Error),
 }
 
-impl From<web3::Error> for IngestorError {
-    fn from(e: web3::Error) -> Self {
-        IngestorError::Unknown(anyhow::anyhow!(e))
+/// The `TriggerFilterWrapper` is a higher-level wrapper around the chain-specific `TriggerFilter`,
+/// enabling subgraph-based trigger filtering for subgraph datasources. This abstraction is necessary
+/// because subgraph filtering operates at a higher level than chain-based filtering. By using this wrapper,
+/// we reduce code duplication, allowing subgraph-based filtering to be implemented once, instead of
+/// duplicating it across different chains.
+#[derive(Debug)]
+pub struct TriggerFilterWrapper<C: Blockchain> {
+    pub chain_filter: Arc<C::TriggerFilter>,
+    pub subgraph_filter: Vec<SubgraphFilter>,
+}
+
+#[derive(Clone, Debug)]
+pub struct SubgraphFilter {
+    pub subgraph: DeploymentHash,
+    pub start_block: BlockNumber,
+    pub entities: Vec<String>,
+    pub manifest_idx: u32,
+}
+
+impl<C: Blockchain> TriggerFilterWrapper<C> {
+    pub fn new(filter: C::TriggerFilter, subgraph_filter: Vec<SubgraphFilter>) -> Self {
+        Self {
+            chain_filter: Arc::new(filter),
+            subgraph_filter,
+        }
+    }
+}
+
+impl<C: Blockchain> Clone for TriggerFilterWrapper<C> {
+    fn clone(&self) -> Self {
+        Self {
+            chain_filter: self.chain_filter.cheap_clone(),
+            subgraph_filter: self.subgraph_filter.clone(),
+        }
     }
 }
 
@@ -251,7 +298,10 @@ pub trait TriggerFilter<C: Blockchain>: Default + Clone + Send + Sync {
 }
 
 pub trait DataSource<C: Blockchain>: 'static + Sized + Send + Sync + Clone {
-    fn from_template_info(info: DataSourceTemplateInfo<C>) -> Result<Self, Error>;
+    fn from_template_info(
+        info: InstanceDSTemplateInfo,
+        template: &data_source::DataSourceTemplate<C>,
+    ) -> Result<Self, Error>;
 
     fn from_stored_dynamic_data_source(
         template: &C::DataSourceTemplate,
@@ -299,11 +349,14 @@ pub trait DataSource<C: Blockchain>: 'static + Sized + Send + Sync + Clone {
     fn as_stored_dynamic_data_source(&self) -> StoredDynamicDataSource;
 
     /// Used as part of manifest validation. If there are no errors, return an empty vector.
-    fn validate(&self) -> Vec<Error>;
+    fn validate(&self, spec_version: &semver::Version) -> Vec<Error>;
 
     fn has_expired(&self, block: BlockNumber) -> bool {
-        self.end_block()
-            .map_or(false, |end_block| block > end_block)
+        self.end_block().is_some_and(|end_block| block > end_block)
+    }
+
+    fn has_declared_calls(&self) -> bool {
+        false
     }
 }
 
@@ -313,9 +366,11 @@ pub trait UnresolvedDataSourceTemplate<C: Blockchain>:
 {
     async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         logger: &Logger,
         manifest_idx: u32,
+        spec_version: &semver::Version,
     ) -> Result<C::DataSourceTemplate, anyhow::Error>;
 }
 
@@ -325,6 +380,15 @@ pub trait DataSourceTemplate<C: Blockchain>: Send + Sync + Debug {
     fn name(&self) -> &str;
     fn manifest_idx(&self) -> u32;
     fn kind(&self) -> &str;
+    fn info(&self) -> DataSourceTemplateInfo {
+        DataSourceTemplateInfo {
+            api_version: self.api_version(),
+            runtime: self.runtime(),
+            name: self.name().to_string(),
+            manifest_idx: Some(self.manifest_idx()),
+            kind: self.kind().to_string(),
+        }
+    }
 }
 
 #[async_trait]
@@ -333,12 +397,83 @@ pub trait UnresolvedDataSource<C: Blockchain>:
 {
     async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         logger: &Logger,
         manifest_idx: u32,
+        spec_version: &semver::Version,
     ) -> Result<C::DataSource, anyhow::Error>;
 }
 
+#[derive(Debug)]
+pub enum Trigger<C: Blockchain> {
+    Chain(C::TriggerData),
+    Subgraph(subgraph::TriggerData),
+}
+
+impl<C: Blockchain> Trigger<C> {
+    pub fn as_chain(&self) -> Option<&C::TriggerData> {
+        match self {
+            Trigger::Chain(data) => Some(data),
+            _ => None,
+        }
+    }
+
+    pub fn as_subgraph(&self) -> Option<&subgraph::TriggerData> {
+        match self {
+            Trigger::Subgraph(data) => Some(data),
+            _ => None,
+        }
+    }
+}
+
+impl<C: Blockchain> Eq for Trigger<C> where C::TriggerData: Eq {}
+
+impl<C: Blockchain> PartialEq for Trigger<C>
+where
+    C::TriggerData: PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Trigger::Chain(data1), Trigger::Chain(data2)) => data1 == data2,
+            (Trigger::Subgraph(a), Trigger::Subgraph(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
+impl<C: Blockchain> Clone for Trigger<C>
+where
+    C::TriggerData: Clone,
+{
+    fn clone(&self) -> Self {
+        match self {
+            Trigger::Chain(data) => Trigger::Chain(data.clone()),
+            Trigger::Subgraph(data) => Trigger::Subgraph(data.clone()),
+        }
+    }
+}
+
+impl<C: Blockchain> Ord for Trigger<C>
+where
+    C::TriggerData: Ord,
+{
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        match (self, other) {
+            (Trigger::Chain(data1), Trigger::Chain(data2)) => data1.cmp(data2),
+            (Trigger::Subgraph(_), Trigger::Chain(_)) => std::cmp::Ordering::Greater,
+            (Trigger::Chain(_), Trigger::Subgraph(_)) => std::cmp::Ordering::Less,
+            (Trigger::Subgraph(t1), Trigger::Subgraph(t2)) => t1.cmp(t2),
+        }
+    }
+}
+
+impl<C: Blockchain> PartialOrd for Trigger<C> {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
 pub trait TriggerData {
     /// If there is an error when processing this trigger, this will called to add relevant context.
     /// For example an useful return is: `"block #<N> (<hash>), transaction <tx_hash>".
@@ -359,6 +494,35 @@ pub trait MappingTriggerTrait {
     fn error_context(&self) -> String;
 }
 
+/// A callback that is called after the triggers have been decoded.
+#[async_trait]
+pub trait DecoderHook<C: Blockchain> {
+    async fn after_decode<'a>(
+        &self,
+        logger: &Logger,
+        block_ptr: &BlockPtr,
+        triggers: Vec<RunnableTriggers<'a, C>>,
+        metrics: &Arc<SubgraphInstanceMetrics>,
+    ) -> Result<Vec<RunnableTriggers<'a, C>>, MappingError>;
+}
+
+/// A decoder hook that does nothing and just returns the triggers that were
+/// passed in
+pub struct NoopDecoderHook;
+
+#[async_trait]
+impl<C: Blockchain> DecoderHook<C> for NoopDecoderHook {
+    async fn after_decode<'a>(
+        &self,
+        _: &Logger,
+        _: &BlockPtr,
+        triggers: Vec<RunnableTriggers<'a, C>>,
+        _: &Arc<SubgraphInstanceMetrics>,
+    ) -> Result<Vec<RunnableTriggers<'a, C>>, MappingError> {
+        Ok(triggers)
+    }
+}
+
 pub struct HostFnCtx<'a> {
     pub logger: Logger,
     pub block_ptr: BlockPtr,
@@ -369,23 +533,19 @@ pub struct HostFnCtx<'a> {
 
 /// Host fn that receives one u32 argument and returns an u32.
 /// The name for an AS fuction is in the format `<namespace>.<function>`.
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 pub struct HostFn {
     pub name: &'static str,
-    pub func: Arc<dyn Send + Sync + Fn(HostFnCtx, u32) -> Result<u32, HostExportError>>,
-}
-
-impl CheapClone for HostFn {
-    fn cheap_clone(&self) -> Self {
-        HostFn {
-            name: self.name,
-            func: self.func.cheap_clone(),
-        }
-    }
+    pub func: Arc<
+        dyn Send
+            + Sync
+            + for<'a> Fn(HostFnCtx<'a>, u32) -> BoxFuture<'a, Result<u32, HostExportError>>,
+    >,
 }
 
+#[async_trait]
 pub trait RuntimeAdapter<C: Blockchain>: Send + Sync {
-    fn host_fns(&self, ds: &C::DataSource) -> Result<Vec<HostFn>, Error>;
+    fn host_fns(&self, ds: &data_source::DataSource<C>) -> Result<Vec<HostFn>, Error>;
 }
 
 pub trait NodeCapabilities<C: Blockchain> {
@@ -396,32 +556,18 @@ pub trait NodeCapabilities<C: Blockchain> {
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize)]
 #[serde(rename_all = "lowercase")]
 pub enum BlockchainKind {
-    /// Arweave chains that are compatible.
-    Arweave,
-
     /// Ethereum itself or chains that are compatible.
     Ethereum,
 
     /// NEAR chains (Mainnet, Testnet) or chains that are compatible
     Near,
-
-    /// Cosmos chains
-    Cosmos,
-
-    Substreams,
-
-    Starknet,
 }
 
 impl fmt::Display for BlockchainKind {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let value = match self {
-            BlockchainKind::Arweave => "arweave",
             BlockchainKind::Ethereum => "ethereum",
             BlockchainKind::Near => "near",
-            BlockchainKind::Cosmos => "cosmos",
-            BlockchainKind::Substreams => "substreams",
-            BlockchainKind::Starknet => "starknet",
         };
         write!(f, "{}", value)
     }
@@ -432,12 +578,10 @@ impl FromStr for BlockchainKind {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "arweave" => Ok(BlockchainKind::Arweave),
             "ethereum" => Ok(BlockchainKind::Ethereum),
             "near" => Ok(BlockchainKind::Near),
-            "cosmos" => Ok(BlockchainKind::Cosmos),
-            "substreams" => Ok(BlockchainKind::Substreams),
-            "starknet" => Ok(BlockchainKind::Starknet),
+            "subgraph" => Ok(BlockchainKind::Ethereum), // TODO(krishna): We should detect the blockchain kind from the source subgraph
+            "amp" => Ok(BlockchainKind::Ethereum),      // TODO: Maybe get this from the Amp server
             _ => Err(anyhow!("unknown blockchain kind {}", s)),
         }
     }
@@ -451,11 +595,11 @@ impl BlockchainKind {
         //
         // Split by `/` to, for example, read 'ethereum' in 'ethereum/contracts'.
         manifest
-            .get(&Value::String("dataSources".to_owned()))
+            .get(Value::String("dataSources".to_owned()))
             .and_then(|ds| ds.as_sequence())
             .and_then(|ds| ds.first())
             .and_then(|ds| ds.as_mapping())
-            .and_then(|ds| ds.get(&Value::String("kind".to_owned())))
+            .and_then(|ds| ds.get(Value::String("kind".to_owned())))
             .and_then(|kind| kind.as_str())
             .and_then(|kind| kind.split('/').next())
             .context("invalid manifest")
@@ -465,18 +609,42 @@ impl BlockchainKind {
 
 /// A collection of blockchains, keyed by `BlockchainKind` and network.
 #[derive(Default, Debug, Clone)]
-pub struct BlockchainMap(HashMap<(BlockchainKind, String), Arc<dyn Any + Send + Sync>>);
+pub struct BlockchainMap(HashMap<(BlockchainKind, ChainName), Arc<dyn Any + Send + Sync>>);
 
 impl BlockchainMap {
     pub fn new() -> Self {
         Self::default()
     }
 
-    pub fn insert<C: Blockchain>(&mut self, network: String, chain: Arc<C>) {
+    pub fn iter(
+        &self,
+    ) -> impl Iterator<Item = (&(BlockchainKind, ChainName), &Arc<dyn Any + Sync + Send>)> {
+        self.0.iter()
+    }
+
+    pub fn insert<C: Blockchain>(&mut self, network: ChainName, chain: Arc<C>) {
         self.0.insert((C::KIND, network), chain);
     }
 
-    pub fn get<C: Blockchain>(&self, network: String) -> Result<Arc<C>, Error> {
+    pub fn get_all_by_kind<C: Blockchain>(
+        &self,
+        kind: BlockchainKind,
+    ) -> Result<Vec<Arc<C>>, Error> {
+        self.0
+            .iter()
+            .flat_map(|((k, _), chain)| {
+                if k.eq(&kind) {
+                    Some(chain.cheap_clone().downcast().map_err(|_| {
+                        anyhow!("unable to downcast, wrong type for blockchain {}", C::KIND)
+                    }))
+                } else {
+                    None
+                }
+            })
+            .collect::<Result<Vec<Arc<C>>, Error>>()
+    }
+
+    pub fn get<C: Blockchain>(&self, network: ChainName) -> Result<Arc<C>, Error> {
         self.0
             .get(&(C::KIND, network.clone()))
             .with_context(|| format!("no network {} found on chain {}", network, C::KIND))?
diff --git a/graph/src/blockchain/noop_runtime_adapter.rs b/graph/src/blockchain/noop_runtime_adapter.rs
index 2f30a30e608..0b8b9e0707c 100644
--- a/graph/src/blockchain/noop_runtime_adapter.rs
+++ b/graph/src/blockchain/noop_runtime_adapter.rs
@@ -1,5 +1,7 @@
 use std::marker::PhantomData;
 
+use crate::data_source;
+
 use super::{Blockchain, HostFn, RuntimeAdapter};
 
 /// A [`RuntimeAdapter`] that does not expose any host functions.
@@ -16,7 +18,7 @@ impl<C> RuntimeAdapter<C> for NoopRuntimeAdapter<C>
 where
     C: Blockchain,
 {
-    fn host_fns(&self, _ds: &C::DataSource) -> anyhow::Result<Vec<HostFn>> {
+    fn host_fns(&self, _ds: &data_source::DataSource<C>) -> anyhow::Result<Vec<HostFn>> {
         Ok(vec![])
     }
 }
diff --git a/graph/src/blockchain/substreams_block_stream.rs b/graph/src/blockchain/substreams_block_stream.rs
deleted file mode 100644
index 8a89d391597..00000000000
--- a/graph/src/blockchain/substreams_block_stream.rs
+++ /dev/null
@@ -1,415 +0,0 @@
-use super::block_stream::{BlockStreamMapper, SUBSTREAMS_BUFFER_STREAM_SIZE};
-use super::client::ChainClient;
-use crate::blockchain::block_stream::{BlockStream, BlockStreamEvent};
-use crate::blockchain::Blockchain;
-use crate::prelude::*;
-use crate::substreams::Modules;
-use crate::substreams_rpc::{ModulesProgress, Request, Response};
-use crate::util::backoff::ExponentialBackoff;
-use async_stream::try_stream;
-use futures03::{Stream, StreamExt};
-use humantime::format_duration;
-use std::sync::Arc;
-use std::task::{Context, Poll};
-use std::time::{Duration, Instant};
-use tonic::Status;
-
-struct SubstreamsBlockStreamMetrics {
-    deployment: DeploymentHash,
-    restarts: CounterVec,
-    connect_duration: GaugeVec,
-    time_between_responses: HistogramVec,
-    responses: CounterVec,
-}
-
-impl SubstreamsBlockStreamMetrics {
-    pub fn new(registry: Arc<MetricsRegistry>, deployment: DeploymentHash) -> Self {
-        Self {
-            deployment,
-            restarts: registry
-                .global_counter_vec(
-                    "deployment_substreams_blockstream_restarts",
-                    "Counts the number of times a Substreams block stream is (re)started",
-                    vec!["deployment", "provider", "success"].as_slice(),
-                )
-                .unwrap(),
-
-            connect_duration: registry
-                .global_gauge_vec(
-                    "deployment_substreams_blockstream_connect_duration",
-                    "Measures the time it takes to connect a Substreams block stream",
-                    vec!["deployment", "provider"].as_slice(),
-                )
-                .unwrap(),
-
-            time_between_responses: registry
-                .global_histogram_vec(
-                    "deployment_substreams_blockstream_time_between_responses",
-                    "Measures the time between receiving and processing Substreams stream responses",
-                    vec!["deployment", "provider"].as_slice(),
-                )
-                .unwrap(),
-
-            responses: registry
-                .global_counter_vec(
-                    "deployment_substreams_blockstream_responses",
-                    "Counts the number of responses received from a Substreams block stream",
-                    vec!["deployment", "provider", "kind"].as_slice(),
-                )
-                .unwrap(),
-        }
-    }
-
-    fn observe_successful_connection(&self, time: &mut Instant, provider: &str) {
-        self.restarts
-            .with_label_values(&[&self.deployment, &provider, "true"])
-            .inc();
-        self.connect_duration
-            .with_label_values(&[&self.deployment, &provider])
-            .set(time.elapsed().as_secs_f64());
-
-        // Reset last connection timestamp
-        *time = Instant::now();
-    }
-
-    fn observe_failed_connection(&self, time: &mut Instant, provider: &str) {
-        self.restarts
-            .with_label_values(&[&self.deployment, &provider, "false"])
-            .inc();
-        self.connect_duration
-            .with_label_values(&[&self.deployment, &provider])
-            .set(time.elapsed().as_secs_f64());
-
-        // Reset last connection timestamp
-        *time = Instant::now();
-    }
-
-    fn observe_response(&self, kind: &str, time: &mut Instant, provider: &str) {
-        self.time_between_responses
-            .with_label_values(&[&self.deployment, &provider])
-            .observe(time.elapsed().as_secs_f64());
-        self.responses
-            .with_label_values(&[&self.deployment, &provider, kind])
-            .inc();
-
-        // Reset last response timestamp
-        *time = Instant::now();
-    }
-}
-
-pub struct SubstreamsBlockStream<C: Blockchain> {
-    //fixme: not sure if this is ok to be set as public, maybe
-    // we do not want to expose the stream to the caller
-    stream: Pin<Box<dyn Stream<Item = Result<BlockStreamEvent<C>, Error>> + Send>>,
-}
-
-impl<C> SubstreamsBlockStream<C>
-where
-    C: Blockchain,
-{
-    pub fn new<F>(
-        deployment: DeploymentHash,
-        client: Arc<ChainClient<C>>,
-        subgraph_current_block: Option<BlockPtr>,
-        cursor: Option<String>,
-        mapper: Arc<F>,
-        modules: Option<Modules>,
-        module_name: String,
-        start_blocks: Vec<BlockNumber>,
-        end_blocks: Vec<BlockNumber>,
-        logger: Logger,
-        registry: Arc<MetricsRegistry>,
-    ) -> Self
-    where
-        F: BlockStreamMapper<C> + 'static,
-    {
-        let manifest_start_block_num = start_blocks.into_iter().min().unwrap_or(0);
-
-        let manifest_end_block_num = end_blocks.into_iter().min().unwrap_or(0);
-
-        let metrics = SubstreamsBlockStreamMetrics::new(registry, deployment.clone());
-
-        SubstreamsBlockStream {
-            stream: Box::pin(stream_blocks(
-                client,
-                cursor,
-                deployment,
-                mapper,
-                modules,
-                module_name,
-                manifest_start_block_num,
-                manifest_end_block_num,
-                subgraph_current_block,
-                logger,
-                metrics,
-            )),
-        }
-    }
-}
-
-fn stream_blocks<C: Blockchain, F: BlockStreamMapper<C>>(
-    client: Arc<ChainClient<C>>,
-    cursor: Option<String>,
-    deployment: DeploymentHash,
-    mapper: Arc<F>,
-    modules: Option<Modules>,
-    module_name: String,
-    manifest_start_block_num: BlockNumber,
-    manifest_end_block_num: BlockNumber,
-    subgraph_current_block: Option<BlockPtr>,
-    logger: Logger,
-    metrics: SubstreamsBlockStreamMetrics,
-) -> impl Stream<Item = Result<BlockStreamEvent<C>, Error>> {
-    let mut latest_cursor = cursor.unwrap_or_default();
-
-    let start_block_num = subgraph_current_block
-        .as_ref()
-        .map(|ptr| {
-            // current_block has already been processed, we start at next block
-            ptr.block_number() as i64 + 1
-        })
-        .unwrap_or(manifest_start_block_num as i64);
-
-    let stop_block_num = manifest_end_block_num as u64;
-
-    // Back off exponentially whenever we encounter a connection error or a stream with bad data
-    let mut backoff = ExponentialBackoff::new(Duration::from_millis(500), Duration::from_secs(45));
-
-    // This attribute is needed because `try_stream!` seems to break detection of `skip_backoff` assignments
-    #[allow(unused_assignments)]
-    let mut skip_backoff = false;
-
-    let mut log_data = SubstreamsLogData::new();
-
-    try_stream! {
-            let endpoint = client.firehose_endpoint()?;
-            let mut logger = logger.new(o!("deployment" => deployment.clone(), "provider" => endpoint.provider.to_string()));
-
-        loop {
-            info!(
-                &logger,
-                "Blockstreams disconnected, connecting";
-                "endpoint_uri" => format_args!("{}", endpoint),
-                "subgraph" => &deployment,
-                "start_block" => start_block_num,
-                "cursor" => &latest_cursor,
-                "provider_err_count" => endpoint.current_error_count(),
-            );
-
-            // We just reconnected, assume that we want to back off on errors
-            skip_backoff = false;
-
-            let mut connect_start = Instant::now();
-            let request = Request {
-                start_block_num,
-                start_cursor: latest_cursor.clone(),
-                stop_block_num,
-                modules: modules.clone(),
-                output_module: module_name.clone(),
-                production_mode: true,
-                ..Default::default()
-            };
-
-
-            let result = endpoint.clone().substreams(request).await;
-
-            match result {
-                Ok(stream) => {
-                    info!(&logger, "Blockstreams connected");
-
-                    // Track the time it takes to set up the block stream
-                    metrics.observe_successful_connection(&mut connect_start, &endpoint.provider);
-
-                    let mut last_response_time = Instant::now();
-                    let mut expected_stream_end = false;
-
-                    for await response in stream{
-                        match process_substreams_response(
-                            response,
-                            mapper.as_ref(),
-                            &mut logger,
-                            &mut log_data,
-                        ).await {
-                            Ok(block_response) => {
-                                match block_response {
-                                    None => {}
-                                    Some(BlockResponse::Proceed(event, cursor)) => {
-                                        // Reset backoff because we got a good value from the stream
-                                        backoff.reset();
-
-                                        metrics.observe_response("proceed", &mut last_response_time, &endpoint.provider);
-
-                                        yield event;
-
-                                        latest_cursor = cursor;
-                                    }
-                                }
-                            },
-                            Err(err) => {
-                                info!(&logger, "received err");
-                                // We have an open connection but there was an error processing the Firehose
-                                // response. We will reconnect the stream after this; this is the case where
-                                // we actually _want_ to back off in case we keep running into the same error.
-                                // An example of this situation is if we get invalid block or transaction data
-                                // that cannot be decoded properly.
-
-                                metrics.observe_response("error", &mut last_response_time, &endpoint.provider);
-
-                                error!(logger, "{:#}", err);
-                                expected_stream_end = true;
-                                break;
-                            }
-                        }
-                    }
-
-                    if !expected_stream_end {
-                        error!(logger, "Stream blocks complete unexpectedly, expecting stream to always stream blocks");
-                    }
-                },
-                Err(e) => {
-                    // We failed to connect and will try again; this is another
-                    // case where we actually _want_ to back off in case we keep
-                    // having connection errors.
-
-                    metrics.observe_failed_connection(&mut connect_start, &endpoint.provider);
-
-                    error!(logger, "Unable to connect to endpoint: {:#}", e);
-                }
-            }
-
-            // If we reach this point, we must wait a bit before retrying, unless `skip_backoff` is true
-            if !skip_backoff {
-                backoff.sleep_async().await;
-            }
-        }
-    }
-}
-
-enum BlockResponse<C: Blockchain> {
-    Proceed(BlockStreamEvent<C>, String),
-}
-
-async fn process_substreams_response<C: Blockchain, F: BlockStreamMapper<C>>(
-    result: Result<Response, Status>,
-    mapper: &F,
-    logger: &mut Logger,
-    log_data: &mut SubstreamsLogData,
-) -> Result<Option<BlockResponse<C>>, Error> {
-    let response = match result {
-        Ok(v) => v,
-        Err(e) => return Err(anyhow!("An error occurred while streaming blocks: {:#}", e)),
-    };
-
-    match mapper
-        .to_block_stream_event(logger, response.message, log_data)
-        .await
-        .context("Mapping message to BlockStreamEvent failed")?
-    {
-        Some(event) => {
-            let cursor = match &event {
-                BlockStreamEvent::Revert(_, cursor) => cursor,
-                BlockStreamEvent::ProcessBlock(_, cursor) => cursor,
-                BlockStreamEvent::ProcessWasmBlock(_, _, _, _, cursor) => cursor,
-            }
-            .to_string();
-
-            return Ok(Some(BlockResponse::Proceed(event, cursor)));
-        }
-        None => Ok(None), // some progress responses are ignored within to_block_stream_event
-    }
-}
-
-impl<C: Blockchain> Stream for SubstreamsBlockStream<C> {
-    type Item = Result<BlockStreamEvent<C>, Error>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.stream.poll_next_unpin(cx)
-    }
-}
-
-impl<C: Blockchain> BlockStream<C> for SubstreamsBlockStream<C> {
-    fn buffer_size_hint(&self) -> usize {
-        SUBSTREAMS_BUFFER_STREAM_SIZE
-    }
-}
-
-pub struct SubstreamsLogData {
-    pub last_progress: Instant,
-    pub last_seen_block: u64,
-    pub trace_id: String,
-}
-
-impl SubstreamsLogData {
-    fn new() -> SubstreamsLogData {
-        SubstreamsLogData {
-            last_progress: Instant::now(),
-            last_seen_block: 0,
-            trace_id: "".to_string(),
-        }
-    }
-    pub fn info_string(&self, progress: &ModulesProgress) -> String {
-        format!(
-            "Substreams backend graph_out last block is {}, {} stages, {} jobs",
-            self.last_seen_block,
-            progress.stages.len(),
-            progress.running_jobs.len()
-        )
-    }
-    pub fn debug_string(&self, progress: &ModulesProgress) -> String {
-        let len = progress.stages.len();
-        let mut stages_str = "".to_string();
-        for i in (0..len).rev() {
-            let stage = &progress.stages[i];
-            let range = if stage.completed_ranges.len() > 0 {
-                let b = stage.completed_ranges.iter().map(|x| x.end_block).min();
-                format!(" up to {}", b.unwrap_or(0))
-            } else {
-                "".to_string()
-            };
-            let mlen = stage.modules.len();
-            let module = if mlen == 0 {
-                "".to_string()
-            } else if mlen == 1 {
-                format!(" ({})", stage.modules[0])
-            } else {
-                format!(" ({} +{})", stage.modules[mlen - 1], mlen - 1)
-            };
-            if !stages_str.is_empty() {
-                stages_str.push_str(", ");
-            }
-            stages_str.push_str(&format!("#{}{}{}", i, range, module));
-        }
-        let stage_str = if len > 0 {
-            format!(" Stages: [{}]", stages_str)
-        } else {
-            "".to_string()
-        };
-        let mut jobs_str = "".to_string();
-        let jlen = progress.running_jobs.len();
-        for i in 0..jlen {
-            let job = &progress.running_jobs[i];
-            if !jobs_str.is_empty() {
-                jobs_str.push_str(", ");
-            }
-            let duration_str = format_duration(Duration::from_millis(job.duration_ms));
-            jobs_str.push_str(&format!(
-                "#{} on Stage {} @ {} | +{}|{} elapsed {}",
-                i,
-                job.stage,
-                job.start_block,
-                job.processed_blocks,
-                job.stop_block - job.start_block,
-                duration_str
-            ));
-        }
-        let job_str = if jlen > 0 {
-            format!(", Jobs: [{}]", jobs_str)
-        } else {
-            "".to_string()
-        };
-        format!(
-            "Substreams backend graph_out last block is {},{}{}",
-            self.last_seen_block, stage_str, job_str,
-        )
-    }
-}
diff --git a/graph/src/blockchain/types.rs b/graph/src/blockchain/types.rs
index cf23ae86ad5..dc88bd91841 100644
--- a/graph/src/blockchain/types.rs
+++ b/graph/src/blockchain/types.rs
@@ -1,26 +1,30 @@
+use alloy::primitives::B256;
 use anyhow::anyhow;
-use chrono::{DateTime, Utc};
+use diesel::deserialize::FromSql;
 use diesel::pg::Pg;
-use diesel::serialize::Output;
+use diesel::serialize::{Output, ToSql};
 use diesel::sql_types::Timestamptz;
 use diesel::sql_types::{Bytea, Nullable, Text};
-use diesel::types::FromSql;
-use diesel::types::ToSql;
 use diesel_derives::{AsExpression, FromSqlRow};
+use serde::{Deserialize, Deserializer};
 use std::convert::TryFrom;
-use std::io::Write;
 use std::time::Duration;
 use std::{fmt, str::FromStr};
-use web3::types::{Block, H256};
 
+use crate::components::ethereum::LightEthereumBlock;
+
+use crate::cheap_clone::CheapClone;
+use crate::components::store::BlockNumber;
 use crate::data::graphql::IntoValue;
+use crate::data::store::scalar::Timestamp;
+use crate::derive::CheapClone;
 use crate::object;
-use crate::prelude::{r, BigInt, TryFromValue, Value, ValueMap};
-use crate::util::stable_hash_glue::{impl_stable_hash, AsBytes};
-use crate::{cheap_clone::CheapClone, components::store::BlockNumber};
+use crate::prelude::{Value, r};
+use crate::util::stable_hash_glue::{AsBytes, impl_stable_hash};
 
 /// A simple marker for byte arrays that are really block hashes
-#[derive(Clone, Default, PartialEq, Eq, Hash, AsExpression, FromSqlRow)]
+#[derive(Clone, Default, PartialEq, Eq, Hash, FromSqlRow, AsExpression)]
+#[diesel(sql_type = Bytea)]
 pub struct BlockHash(pub Box<[u8]>);
 
 impl_stable_hash!(BlockHash(transparent: AsBytes));
@@ -30,6 +34,10 @@ impl BlockHash {
         &self.0
     }
 
+    pub fn as_b256(&self) -> B256 {
+        B256::from_slice(self.as_slice())
+    }
+
     /// Encodes the block hash into a hexadecimal string **without** a "0x"
     /// prefix. Hashes are stored in the database in this format when the
     /// schema uses `text` columns, which is a legacy and such columns
@@ -39,7 +47,23 @@ impl BlockHash {
     }
 
     pub fn zero() -> Self {
-        Self::from(H256::zero())
+        Self::from(B256::ZERO)
+    }
+}
+
+impl<'de> Deserialize<'de> for BlockHash {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = Deserialize::deserialize(deserializer)?;
+        BlockHash::from_str(&s).map_err(serde::de::Error::custom)
+    }
+}
+
+impl CheapClone for BlockHash {
+    fn cheap_clone(&self) -> Self {
+        Self(self.0.clone())
     }
 }
 
@@ -61,20 +85,18 @@ impl fmt::LowerHex for BlockHash {
     }
 }
 
-impl CheapClone for BlockHash {}
-
-impl From<H256> for BlockHash {
-    fn from(hash: H256) -> Self {
-        BlockHash(hash.as_bytes().into())
-    }
-}
-
 impl From<Vec<u8>> for BlockHash {
     fn from(bytes: Vec<u8>) -> Self {
         BlockHash(bytes.as_slice().into())
     }
 }
 
+impl From<B256> for BlockHash {
+    fn from(hash: B256) -> Self {
+        BlockHash(hash.as_slice().into())
+    }
+}
+
 impl TryFrom<&str> for BlockHash {
     type Error = anyhow::Error;
 
@@ -95,7 +117,7 @@ impl FromStr for BlockHash {
 }
 
 impl FromSql<Nullable<Text>, Pg> for BlockHash {
-    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
+    fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
         let s = <String as FromSql<Text, Pg>>::from_sql(bytes)?;
         BlockHash::try_from(s.as_str())
             .map_err(|e| format!("invalid block hash `{}`: {}", s, e).into())
@@ -103,7 +125,7 @@ impl FromSql<Nullable<Text>, Pg> for BlockHash {
 }
 
 impl FromSql<Text, Pg> for BlockHash {
-    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
+    fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
         let s = <String as FromSql<Text, Pg>>::from_sql(bytes)?;
         BlockHash::try_from(s.as_str())
             .map_err(|e| format!("invalid block hash `{}`: {}", s, e).into())
@@ -111,23 +133,27 @@ impl FromSql<Text, Pg> for BlockHash {
 }
 
 impl FromSql<Bytea, Pg> for BlockHash {
-    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
+    fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
         let bytes = <Vec<u8> as FromSql<Bytea, Pg>>::from_sql(bytes)?;
         Ok(BlockHash::from(bytes))
     }
 }
 
+impl ToSql<Bytea, Pg> for BlockHash {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
+        ToSql::<Bytea, Pg>::to_sql(self.0.as_ref(), out)
+    }
+}
+
 /// A block hash and block number from a specific Ethereum block.
 ///
 /// Block numbers are signed 32 bit integers
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Clone, CheapClone, PartialEq, Eq, Hash)]
 pub struct BlockPtr {
     pub hash: BlockHash,
     pub number: BlockNumber,
 }
 
-impl CheapClone for BlockPtr {}
-
 impl_stable_hash!(BlockPtr { hash, number });
 
 impl BlockPtr {
@@ -146,13 +172,6 @@ impl BlockPtr {
         self.number
     }
 
-    // FIXME:
-    //
-    // workaround for arweave
-    pub fn hash_as_h256(&self) -> H256 {
-        H256::from_slice(&self.hash_slice()[..32])
-    }
-
     pub fn hash_slice(&self) -> &[u8] {
         self.hash.0.as_ref()
     }
@@ -181,15 +200,15 @@ impl slog::Value for BlockPtr {
     }
 }
 
-impl<T> From<Block<T>> for BlockPtr {
-    fn from(b: Block<T>) -> BlockPtr {
-        BlockPtr::from((b.hash.unwrap(), b.number.unwrap().as_u64()))
+impl From<LightEthereumBlock> for BlockPtr {
+    fn from(b: LightEthereumBlock) -> BlockPtr {
+        BlockPtr::from((b.hash(), b.number_u64()))
     }
 }
 
-impl<'a, T> From<&'a Block<T>> for BlockPtr {
-    fn from(b: &'a Block<T>) -> BlockPtr {
-        BlockPtr::from((b.hash.unwrap(), b.number.unwrap().as_u64()))
+impl From<&LightEthereumBlock> for BlockPtr {
+    fn from(b: &LightEthereumBlock) -> BlockPtr {
+        BlockPtr::from((b.hash(), b.number_u64()))
     }
 }
 
@@ -202,40 +221,51 @@ impl From<(Vec<u8>, i32)> for BlockPtr {
     }
 }
 
-impl From<(H256, i32)> for BlockPtr {
-    fn from((hash, number): (H256, i32)) -> BlockPtr {
+impl From<(B256, i32)> for BlockPtr {
+    fn from((hash, number): (B256, i32)) -> BlockPtr {
         BlockPtr {
             hash: hash.into(),
             number,
         }
     }
 }
-
-impl From<(Vec<u8>, u64)> for BlockPtr {
-    fn from((bytes, number): (Vec<u8>, u64)) -> Self {
+impl From<(B256, u64)> for BlockPtr {
+    fn from((hash, number): (B256, u64)) -> BlockPtr {
         let number = i32::try_from(number).unwrap();
         BlockPtr {
-            hash: BlockHash::from(bytes),
+            hash: hash.into(),
             number,
         }
     }
 }
 
-impl From<(H256, u64)> for BlockPtr {
-    fn from((hash, number): (H256, u64)) -> BlockPtr {
+impl From<(B256, i64)> for BlockPtr {
+    fn from((hash, number): (B256, i64)) -> BlockPtr {
         let number = i32::try_from(number).unwrap();
-
-        BlockPtr::from((hash, number))
+        BlockPtr {
+            hash: hash.into(),
+            number,
+        }
     }
 }
 
-impl From<(H256, i64)> for BlockPtr {
-    fn from((hash, number): (H256, i64)) -> BlockPtr {
-        if number < 0 {
-            panic!("block number out of range: {}", number);
+impl From<(Vec<u8>, u64)> for BlockPtr {
+    fn from((bytes, number): (Vec<u8>, u64)) -> Self {
+        let number = i32::try_from(number).unwrap();
+        BlockPtr {
+            hash: BlockHash::from(bytes),
+            number,
         }
+    }
+}
 
-        BlockPtr::from((hash, number as u64))
+impl From<(Vec<u8>, i64)> for BlockPtr {
+    fn from((bytes, number): (Vec<u8>, i64)) -> Self {
+        let number = i32::try_from(number).unwrap();
+        BlockPtr {
+            hash: BlockHash::from(bytes),
+            number,
+        }
     }
 }
 
@@ -254,37 +284,20 @@ impl TryFrom<(&[u8], i64)> for BlockPtr {
     type Error = anyhow::Error;
 
     fn try_from((bytes, number): (&[u8], i64)) -> Result<Self, Self::Error> {
-        let hash = if bytes.len() == H256::len_bytes() {
-            H256::from_slice(bytes)
+        let hash = if bytes.len() == B256::len_bytes() {
+            B256::from_slice(bytes)
         } else {
             return Err(anyhow!(
-                "invalid H256 value `{}` has {} bytes instead of {}",
+                "invalid B256 value `{}` has {} bytes instead of {}",
                 hex::encode(bytes),
                 bytes.len(),
-                H256::len_bytes()
+                B256::len_bytes()
             ));
         };
         Ok(BlockPtr::from((hash, number)))
     }
 }
 
-impl TryFromValue for BlockPtr {
-    fn try_from_value(value: &r::Value) -> Result<Self, anyhow::Error> {
-        match value {
-            r::Value::Object(o) => {
-                let number = o.get_required::<BigInt>("number")?.to_u64() as BlockNumber;
-                let hash = o.get_required::<BlockHash>("hash")?;
-
-                Ok(BlockPtr::new(hash, number))
-            }
-            _ => Err(anyhow!(
-                "failed to parse non-object value into BlockPtr: {:?}",
-                value
-            )),
-        }
-    }
-}
-
 impl IntoValue for BlockPtr {
     fn into_value(self) -> r::Value {
         object! {
@@ -295,9 +308,9 @@ impl IntoValue for BlockPtr {
     }
 }
 
-impl From<BlockPtr> for H256 {
+impl From<BlockPtr> for B256 {
     fn from(ptr: BlockPtr) -> Self {
-        ptr.hash_as_h256()
+        ptr.hash.as_b256()
     }
 }
 
@@ -307,6 +320,154 @@ impl From<BlockPtr> for BlockNumber {
     }
 }
 
+fn deserialize_block_number<'de, D>(deserializer: D) -> Result<BlockNumber, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s: String = Deserialize::deserialize(deserializer)?;
+
+    if s.starts_with("0x") {
+        let s = s.trim_start_matches("0x");
+        i32::from_str_radix(s, 16).map_err(serde::de::Error::custom)
+    } else {
+        i32::from_str(&s).map_err(serde::de::Error::custom)
+    }
+}
+
+fn deserialize_block_time<'de, D>(deserializer: D) -> Result<BlockTime, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let value = String::deserialize(deserializer)?;
+
+    if value.starts_with("0x") {
+        let hex_value = value.trim_start_matches("0x");
+
+        i64::from_str_radix(hex_value, 16)
+            .map(|secs| BlockTime::since_epoch(secs, 0))
+            .map_err(serde::de::Error::custom)
+    } else {
+        value
+            .parse::<i64>()
+            .map(|secs| BlockTime::since_epoch(secs, 0))
+            .map_err(serde::de::Error::custom)
+    }
+}
+#[derive(Clone, PartialEq, Eq, Hash, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtendedBlockPtr {
+    pub hash: BlockHash,
+    #[serde(deserialize_with = "deserialize_block_number")]
+    pub number: BlockNumber,
+    pub parent_hash: BlockHash,
+    #[serde(deserialize_with = "deserialize_block_time")]
+    pub timestamp: BlockTime,
+}
+
+impl ExtendedBlockPtr {
+    pub fn new(
+        hash: BlockHash,
+        number: BlockNumber,
+        parent_hash: BlockHash,
+        timestamp: BlockTime,
+    ) -> Self {
+        Self {
+            hash,
+            number,
+            parent_hash,
+            timestamp,
+        }
+    }
+
+    /// Encodes the block hash into a hexadecimal string **without** a "0x" prefix.
+    /// Hashes are stored in the database in this format.
+    pub fn hash_hex(&self) -> String {
+        self.hash.hash_hex()
+    }
+
+    /// Encodes the parent block hash into a hexadecimal string **without** a "0x" prefix.
+    pub fn parent_hash_hex(&self) -> String {
+        self.parent_hash.hash_hex()
+    }
+
+    /// Block number to be passed into the store. Panics if it does not fit in an i32.
+    pub fn block_number(&self) -> BlockNumber {
+        self.number
+    }
+}
+
+impl fmt::Display for ExtendedBlockPtr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "#{} ({}) [parent: {}]",
+            self.number,
+            self.hash_hex(),
+            self.parent_hash_hex()
+        )
+    }
+}
+
+impl fmt::Debug for ExtendedBlockPtr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "#{} ({}) [parent: {}]",
+            self.number,
+            self.hash_hex(),
+            self.parent_hash_hex()
+        )
+    }
+}
+
+impl slog::Value for ExtendedBlockPtr {
+    fn serialize(
+        &self,
+        record: &slog::Record,
+        key: slog::Key,
+        serializer: &mut dyn slog::Serializer,
+    ) -> slog::Result {
+        slog::Value::serialize(&self.to_string(), record, key, serializer)
+    }
+}
+
+impl IntoValue for ExtendedBlockPtr {
+    fn into_value(self) -> r::Value {
+        object! {
+            __typename: "Block",
+            hash: self.hash_hex(),
+            number: format!("{}", self.number),
+            parent_hash: self.parent_hash_hex(),
+            timestamp: format!("{}", self.timestamp),
+        }
+    }
+}
+
+impl TryFrom<(B256, i32, B256, u64)> for ExtendedBlockPtr {
+    type Error = anyhow::Error;
+
+    fn try_from(tuple: (B256, i32, B256, u64)) -> Result<Self, Self::Error> {
+        let (hash, block_number, parent_hash, timestamp) = tuple;
+
+        // Convert timestamp to `BlockTime`
+        let secs = timestamp;
+        let block_time = BlockTime::since_epoch(secs as i64, 0);
+
+        Ok(ExtendedBlockPtr {
+            hash: hash.into(),
+            number: block_number,
+            parent_hash: parent_hash.into(),
+            timestamp: block_time,
+        })
+    }
+}
+
+impl From<ExtendedBlockPtr> for BlockNumber {
+    fn from(ptr: ExtendedBlockPtr) -> Self {
+        ptr.number
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 /// A collection of attributes that (kind of) uniquely identify a blockchain.
 pub struct ChainIdentifier {
@@ -314,6 +475,21 @@ pub struct ChainIdentifier {
     pub genesis_block_hash: BlockHash,
 }
 
+impl ChainIdentifier {
+    pub fn is_default(&self) -> bool {
+        ChainIdentifier::default().eq(self)
+    }
+}
+
+impl Default for ChainIdentifier {
+    fn default() -> Self {
+        Self {
+            net_version: String::default(),
+            genesis_block_hash: BlockHash::from(B256::ZERO),
+        }
+    }
+}
+
 impl fmt::Display for ChainIdentifier {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
@@ -326,32 +502,41 @@ impl fmt::Display for ChainIdentifier {
 
 /// The timestamp associated with a block. This is used whenever a time
 /// needs to be connected to data within the block
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct BlockTime(DateTime<Utc>);
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, FromSqlRow, AsExpression, Deserialize,
+)]
+#[diesel(sql_type = Timestamptz)]
+pub struct BlockTime(Timestamp);
 
 impl BlockTime {
     /// A timestamp from a long long time ago used to indicate that we don't
     /// have a timestamp
-    pub const NONE: Self = Self(DateTime::<Utc>::MIN_UTC);
+    pub const NONE: Self = Self(Timestamp::NONE);
 
-    pub const MAX: Self = Self(DateTime::<Utc>::MAX_UTC);
+    pub const MAX: Self = Self(Timestamp::MAX);
 
-    pub const MIN: Self = Self(DateTime::<Utc>::MIN_UTC);
+    pub const MIN: Self = Self(Timestamp::MIN);
 
     /// Construct a block time that is the given number of seconds and
     /// nanoseconds after the Unix epoch
     pub fn since_epoch(secs: i64, nanos: u32) -> Self {
-        Self(DateTime::from_timestamp(secs, nanos).unwrap())
+        Self(
+            Timestamp::since_epoch(secs, nanos)
+                .ok_or_else(|| anyhow!("invalid block time: {}s {}ns", secs, nanos))
+                .unwrap(),
+        )
     }
 
-    /// Construct a block time for tests where blocks are exactly 10s apart
+    /// Construct a block time for tests where blocks are exactly 45 minutes
+    /// apart. We use that big a timespan to make it easier to trigger
+    /// hourly rollups in tests
     #[cfg(debug_assertions)]
     pub fn for_test(ptr: &BlockPtr) -> Self {
-        Self::since_epoch(ptr.number as i64 * 10, 0)
+        Self::since_epoch(ptr.number as i64 * 45 * 60, 0)
     }
 
     pub fn as_secs_since_epoch(&self) -> i64 {
-        self.0.timestamp()
+        self.0.as_secs_since_epoch()
     }
 
     /// Return the number of the last bucket that starts before `self`
@@ -372,9 +557,15 @@ impl From<Duration> for BlockTime {
     }
 }
 
+impl From<Timestamp> for BlockTime {
+    fn from(value: Timestamp) -> Self {
+        Self(value)
+    }
+}
+
 impl From<BlockTime> for Value {
     fn from(block_time: BlockTime) -> Self {
-        Value::Int8(block_time.as_secs_since_epoch())
+        Value::Timestamp(block_time.0)
     }
 }
 
@@ -390,7 +581,90 @@ impl TryFrom<&Value> for BlockTime {
 }
 
 impl ToSql<Timestamptz, Pg> for BlockTime {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> diesel::serialize::Result {
-        <DateTime<Utc> as ToSql<Timestamptz, Pg>>::to_sql(&self.0, out)
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
+        <Timestamp as ToSql<Timestamptz, Pg>>::to_sql(&self.0, out)
+    }
+}
+
+impl FromSql<Timestamptz, Pg> for BlockTime {
+    fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
+        <Timestamp as FromSql<Timestamptz, Pg>>::from_sql(bytes).map(Self)
+    }
+}
+
+impl fmt::Display for BlockTime {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0.as_microseconds_since_epoch())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json;
+
+    #[test]
+    fn test_blockhash_deserialization() {
+        let json_data = "\"0x8186da3ec5590631ae7b9415ce58548cb98c7f1dc68c5ea1c519a3f0f6a25aac\"";
+
+        let block_hash: BlockHash =
+            serde_json::from_str(json_data).expect("Deserialization failed");
+
+        let expected_bytes =
+            hex::decode("8186da3ec5590631ae7b9415ce58548cb98c7f1dc68c5ea1c519a3f0f6a25aac")
+                .expect("Hex decoding failed");
+
+        assert_eq!(
+            *block_hash.0, expected_bytes,
+            "BlockHash does not match expected bytes"
+        );
+    }
+
+    #[test]
+    fn test_block_ptr_ext_deserialization() {
+        // JSON data with a hex string for BlockNumber
+        let json_data = r#"
+        {
+            "hash": "0x8186da3ec5590631ae7b9415ce58548cb98c7f1dc68c5ea1c519a3f0f6a25aac",
+            "number": "0x2A",
+            "parentHash": "0xd71699894d637632dea4d425396086edf033c1ff72b13753e8c4e67700e3eb8e",
+            "timestamp": "0x673b284f"
+        }
+        "#;
+
+        // Deserialize the JSON string into a ExtendedBlockPtr
+        let block_ptr_ext: ExtendedBlockPtr =
+            serde_json::from_str(json_data).expect("Deserialization failed");
+
+        // Verify the deserialized values
+        assert_eq!(block_ptr_ext.number, 42); // 0x2A in hex is 42 in decimal
+        assert_eq!(
+            block_ptr_ext.hash_hex(),
+            "8186da3ec5590631ae7b9415ce58548cb98c7f1dc68c5ea1c519a3f0f6a25aac"
+        );
+        assert_eq!(
+            block_ptr_ext.parent_hash_hex(),
+            "d71699894d637632dea4d425396086edf033c1ff72b13753e8c4e67700e3eb8e"
+        );
+        assert_eq!(block_ptr_ext.timestamp.0.as_secs_since_epoch(), 1731930191);
+    }
+
+    #[test]
+    fn test_invalid_block_number_deserialization() {
+        let invalid_json_data = r#"
+        {
+            "hash": "0x8186da3ec5590631ae7b9415ce58548cb98c7f1dc68c5ea1c519a3f0f6a25aac",
+            "number": "invalid_hex_string",
+            "parentHash": "0xd71699894d637632dea4d425396086edf033c1ff72b13753e8c4e67700e3eb8e",
+            "timestamp": "123456789012345678901234567890"
+        }
+        "#;
+
+        let result: Result<ExtendedBlockPtr, _> = serde_json::from_str(invalid_json_data);
+
+        assert!(
+            result.is_err(),
+            "Deserialization should have failed for invalid block number"
+        );
     }
 }
diff --git a/graph/src/cheap_clone.rs b/graph/src/cheap_clone.rs
index ed375b00079..a8250bd6fb0 100644
--- a/graph/src/cheap_clone.rs
+++ b/graph/src/cheap_clone.rs
@@ -1,40 +1,124 @@
-use slog::Logger;
 use std::future::Future;
 use std::rc::Rc;
 use std::sync::Arc;
 use tonic::transport::Channel;
 
-/// Things that are fast to clone in the context of an application such as Graph Node
+/// Things that are fast to clone in the context of an application such as
+/// Graph Node
 ///
-/// The purpose of this API is to reduce the number of calls to .clone() which need to
-/// be audited for performance.
+/// The purpose of this API is to reduce the number of calls to .clone()
+/// which need to be audited for performance.
 ///
-/// As a rule of thumb, only constant-time Clone impls should also implement CheapClone.
+/// In general, the derive macro `graph::Derive::CheapClone` should be used
+/// to implement this trait. A manual implementation should only be used if
+/// the derive macro cannot be used, and should mention all fields that need
+/// to be cloned.
+///
+/// As a rule of thumb, only constant-time Clone impls should also implement
+/// CheapClone.
 /// Eg:
 ///    ✔ Arc<T>
 ///    ✗ Vec<T>
 ///    ✔ u128
 ///    ✗ String
 pub trait CheapClone: Clone {
+    fn cheap_clone(&self) -> Self;
+}
+
+impl<T: ?Sized> CheapClone for Rc<T> {
     #[inline]
     fn cheap_clone(&self) -> Self {
         self.clone()
     }
 }
 
-impl<T: ?Sized> CheapClone for Rc<T> {}
-impl<T: ?Sized> CheapClone for Arc<T> {}
-impl<T: ?Sized + CheapClone> CheapClone for Box<T> {}
-impl<T: ?Sized + CheapClone> CheapClone for std::pin::Pin<T> {}
-impl<T: CheapClone> CheapClone for Option<T> {}
-impl CheapClone for Logger {}
-// reqwest::Client uses Arc internally, so it is CheapClone.
-impl CheapClone for reqwest::Client {}
+impl<T: ?Sized> CheapClone for Arc<T> {
+    #[inline]
+    fn cheap_clone(&self) -> Self {
+        self.clone()
+    }
+}
+
+impl<T: CheapClone> CheapClone for Box<T> {
+    #[inline]
+    fn cheap_clone(&self) -> Self {
+        self.clone()
+    }
+}
+
+impl<T: CheapClone> CheapClone for std::pin::Pin<T> {
+    #[inline]
+    fn cheap_clone(&self) -> Self {
+        self.clone()
+    }
+}
+
+impl<T: CheapClone> CheapClone for Option<T> {
+    #[inline]
+    fn cheap_clone(&self) -> Self {
+        self.clone()
+    }
+}
 
 // Pool is implemented as a newtype over Arc,
 // So it is CheapClone.
-impl<M: diesel::r2d2::ManageConnection> CheapClone for diesel::r2d2::Pool<M> {}
+impl<M: diesel::r2d2::ManageConnection> CheapClone for diesel::r2d2::Pool<M> {
+    #[inline]
+    fn cheap_clone(&self) -> Self {
+        self.clone()
+    }
+}
+
+impl<F: Future> CheapClone for futures03::future::Shared<F> {
+    #[inline]
+    fn cheap_clone(&self) -> Self {
+        self.clone()
+    }
+}
+
+macro_rules! cheap_clone_is_clone {
+    ($($t:ty),*) => {
+        $(
+            impl CheapClone for $t {
+                #[inline]
+                fn cheap_clone(&self) -> Self {
+                    self.clone()
+                }
+            }
+        )*
+    };
+}
+
+macro_rules! cheap_clone_is_copy {
+    ($($t:ty),*) => {
+        $(
+            impl CheapClone for $t {
+                #[inline]
+                fn cheap_clone(&self) -> Self {
+                    *self
+                }
+            }
+        )*
+    };
+}
+
+cheap_clone_is_clone!(Channel);
+// reqwest::Client uses Arc internally, so it is CheapClone.
+cheap_clone_is_clone!(reqwest::Client);
+cheap_clone_is_clone!(slog::Logger);
+cheap_clone_is_clone!(semver::Version);
 
-impl<F: Future> CheapClone for futures03::future::Shared<F> {}
+cheap_clone_is_copy!(
+    (),
+    bool,
+    u16,
+    u32,
+    i32,
+    u64,
+    usize,
+    &'static str,
+    std::time::Duration
+);
+cheap_clone_is_copy!(alloy::primitives::Address);
 
-impl CheapClone for Channel {}
+cheap_clone_is_clone!(tokio_util::sync::CancellationToken);
diff --git a/graph/src/components/ethereum/json_patch.rs b/graph/src/components/ethereum/json_patch.rs
new file mode 100644
index 00000000000..13859c8f4a7
--- /dev/null
+++ b/graph/src/components/ethereum/json_patch.rs
@@ -0,0 +1,123 @@
+//! JSON patching utilities for Ethereum blocks and receipts.
+//!
+//! Some cached blocks are missing the transaction `type` field because
+//! graph-node's rust-web3 fork didn't capture it. Alloy requires this field for
+//! deserialization. These utilities patch the JSON to add `type: "0x0"` (legacy
+//! transaction) where missing.
+//!
+//! Also used by `PatchingHttp` for chains that don't support EIP-2718 typed transactions.
+
+use serde_json::Value;
+
+pub fn patch_type_field(obj: &mut Value) -> bool {
+    if let Value::Object(map) = obj
+        && !map.contains_key("type")
+    {
+        map.insert("type".to_string(), Value::String("0x0".to_string()));
+        return true;
+    }
+    false
+}
+
+pub fn patch_block_transactions(block: &mut Value) -> bool {
+    let Some(txs) = block.get_mut("transactions").and_then(|t| t.as_array_mut()) else {
+        return false;
+    };
+    let mut patched = false;
+    for tx in txs {
+        patched |= patch_type_field(tx);
+    }
+    patched
+}
+
+pub fn patch_receipts(result: &mut Value) -> bool {
+    match result {
+        Value::Object(_) => patch_type_field(result),
+        Value::Array(arr) => {
+            let mut patched = false;
+            for r in arr {
+                patched |= patch_type_field(r);
+            }
+            patched
+        }
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn patch_type_field_adds_missing_type() {
+        let mut obj = json!({"status": "0x1", "gasUsed": "0x5208"});
+        assert!(patch_type_field(&mut obj));
+        assert_eq!(obj["type"], "0x0");
+    }
+
+    #[test]
+    fn patch_type_field_preserves_existing_type() {
+        let mut obj = json!({"status": "0x1", "type": "0x2"});
+        assert!(!patch_type_field(&mut obj));
+        assert_eq!(obj["type"], "0x2");
+    }
+
+    #[test]
+    fn patch_type_field_handles_non_object() {
+        let mut val = json!("not an object");
+        assert!(!patch_type_field(&mut val));
+    }
+
+    #[test]
+    fn patch_block_transactions_patches_all() {
+        let mut block = json!({
+            "hash": "0x123",
+            "transactions": [
+                {"hash": "0xabc", "nonce": "0x1"},
+                {"hash": "0xdef", "nonce": "0x2", "type": "0x2"},
+                {"hash": "0xghi", "nonce": "0x3"}
+            ]
+        });
+        assert!(patch_block_transactions(&mut block));
+        assert_eq!(block["transactions"][0]["type"], "0x0");
+        assert_eq!(block["transactions"][1]["type"], "0x2");
+        assert_eq!(block["transactions"][2]["type"], "0x0");
+    }
+
+    #[test]
+    fn patch_block_transactions_handles_empty() {
+        let mut block = json!({"hash": "0x123", "transactions": []});
+        assert!(!patch_block_transactions(&mut block));
+    }
+
+    #[test]
+    fn patch_block_transactions_handles_missing_field() {
+        let mut block = json!({"hash": "0x123"});
+        assert!(!patch_block_transactions(&mut block));
+    }
+
+    #[test]
+    fn patch_receipts_single() {
+        let mut receipt = json!({"status": "0x1"});
+        assert!(patch_receipts(&mut receipt));
+        assert_eq!(receipt["type"], "0x0");
+    }
+
+    #[test]
+    fn patch_receipts_array() {
+        let mut receipts = json!([
+            {"status": "0x1"},
+            {"status": "0x1", "type": "0x2"}
+        ]);
+        assert!(patch_receipts(&mut receipts));
+        assert_eq!(receipts[0]["type"], "0x0");
+        assert_eq!(receipts[1]["type"], "0x2");
+    }
+
+    #[test]
+    fn patch_receipts_handles_null() {
+        let mut val = Value::Null;
+        assert!(!patch_receipts(&mut val));
+    }
+}
diff --git a/graph/src/components/ethereum/mod.rs b/graph/src/components/ethereum/mod.rs
index 45f1f5d98ad..bda1ef5c32b 100644
--- a/graph/src/components/ethereum/mod.rs
+++ b/graph/src/components/ethereum/mod.rs
@@ -1,6 +1,12 @@
+pub mod json_patch;
+mod network;
 mod types;
 
+pub use self::network::AnyNetworkBare;
 pub use self::types::{
-    evaluate_transaction_status, EthereumBlock, EthereumBlockWithCalls, EthereumCall,
-    LightEthereumBlock, LightEthereumBlockExt,
+    AnyBlock, AnyTransaction, AnyTransactionReceiptBare, CachedBlock, EthereumBlock,
+    EthereumBlockWithCalls, EthereumCall, LightEthereumBlock, LightEthereumBlockExt,
 };
+
+// Re-export Alloy network types for convenience
+pub use alloy::network::{AnyHeader, AnyRpcHeader, AnyTxEnvelope};
diff --git a/graph/src/components/ethereum/network.rs b/graph/src/components/ethereum/network.rs
new file mode 100644
index 00000000000..8460ad7bdf1
--- /dev/null
+++ b/graph/src/components/ethereum/network.rs
@@ -0,0 +1,310 @@
+use alloy::consensus::BlobTransactionSidecarVariant;
+use alloy::eips::eip7702::SignedAuthorization;
+use alloy::network::{
+    AnyHeader, AnyReceiptEnvelope, AnyRpcTransaction, AnyTxEnvelope, AnyTxType,
+    AnyTypedTransaction, BuildResult, Network, NetworkTransactionBuilder, NetworkWallet,
+    TransactionBuilder, TransactionBuilder4844, TransactionBuilder7702, TransactionBuilderError,
+};
+use alloy::primitives::{Address, Bytes, ChainId, TxKind, U256};
+use alloy::providers::fillers::{
+    BlobGasFiller, ChainIdFiller, GasFiller, JoinFill, NonceFiller, RecommendedFillers,
+};
+use alloy::rpc::types::{
+    AccessList, Block, Header, Log, Transaction, TransactionInputKind, TransactionReceipt,
+    TransactionRequest,
+};
+use alloy::serde::WithOtherFields;
+use serde::{Deserialize, Serialize};
+use std::ops::{Deref, DerefMut};
+
+use super::types::AnyTransaction;
+
+/// Like alloy's [`AnyNetwork`] but without [`WithOtherFields`] on response types.
+///
+/// `AnyNetwork` wraps every response (block, transaction, receipt) in `WithOtherFields<T>`,
+/// which captures unknown JSON keys into a `BTreeMap`. This requires `#[serde(flatten)]`,
+/// forcing serde to buffer entire JSON objects into intermediate `Value` maps and
+/// re-serialize them to diff keys — on every block and every transaction.
+/// graph-node never uses these extra fields, so we define a bare network that deserializes
+/// directly into the inner types.
+///
+/// Uses `AnyTxEnvelope` (not `TxEnvelope`) to support non-standard transaction types from
+/// L2s and sidechains. `TransactionRequest` retains `WithOtherFields` because upstream
+/// `From` impls for `AnyTxEnvelope` only exist on `WithOtherFields<TransactionRequest>`.
+///
+/// [`AnyNetwork`]: alloy::network::AnyNetwork
+/// [`WithOtherFields`]: alloy::serde::WithOtherFields
+#[derive(Clone, Copy, Debug)]
+pub struct AnyNetworkBare;
+
+/// Newtype around `WithOtherFields<TransactionRequest>` needed because
+/// `Network::TransactionRequest` requires `From<Self::TransactionResponse>` and our
+/// `TransactionResponse` is `Transaction<AnyTxEnvelope>` (not wrapped in `WithOtherFields`).
+/// Upstream only provides `From<WithOtherFields<Transaction<AnyTxEnvelope>>>`, so we need
+/// this local type to bridge the conversion. Additionally, `NetworkTransactionBuilder`
+/// requires `TransactionBuilder + TransactionBuilder4844 + TransactionBuilder7702` as
+/// supertraits, so we must re-implement those by delegation since Rust doesn't auto-delegate
+/// trait impls through `Deref`.
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+#[serde(transparent)]
+pub struct AnyTransactionRequest(WithOtherFields<TransactionRequest>);
+
+impl Deref for AnyTransactionRequest {
+    type Target = WithOtherFields<TransactionRequest>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for AnyTransactionRequest {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl From<AnyTxEnvelope> for AnyTransactionRequest {
+    fn from(value: AnyTxEnvelope) -> Self {
+        Self(value.into())
+    }
+}
+
+impl From<TransactionRequest> for AnyTransactionRequest {
+    fn from(value: TransactionRequest) -> Self {
+        Self(value.into())
+    }
+}
+
+impl From<AnyTypedTransaction> for AnyTransactionRequest {
+    fn from(value: AnyTypedTransaction) -> Self {
+        Self(value.into())
+    }
+}
+
+impl From<AnyTransaction> for AnyTransactionRequest {
+    fn from(value: AnyTransaction) -> Self {
+        // Upstream only has From<AnyRpcTransaction> for WithOtherFields<TransactionRequest>,
+        // so we wrap in WithOtherFields first to match that impl.
+        let tx = WithOtherFields::<Transaction<AnyTxEnvelope>>::new(value);
+        Self(AnyRpcTransaction::from(tx).into())
+    }
+}
+
+impl Network for AnyNetworkBare {
+    type TxType = AnyTxType;
+    type TxEnvelope = AnyTxEnvelope;
+    type UnsignedTx = AnyTypedTransaction;
+    type ReceiptEnvelope = AnyReceiptEnvelope;
+    type Header = AnyHeader;
+
+    type TransactionRequest = AnyTransactionRequest;
+    type TransactionResponse = AnyTransaction;
+    type ReceiptResponse = TransactionReceipt<AnyReceiptEnvelope<Log>>;
+    type HeaderResponse = Header<AnyHeader>;
+    type BlockResponse = Block<AnyTransaction, Header<AnyHeader>>;
+}
+
+impl RecommendedFillers for AnyNetworkBare {
+    type RecommendedFillers =
+        JoinFill<GasFiller, JoinFill<BlobGasFiller, JoinFill<NonceFiller, ChainIdFiller>>>;
+
+    fn recommended_fillers() -> Self::RecommendedFillers {
+        Default::default()
+    }
+}
+
+// Delegate `TransactionBuilder` to the inner `WithOtherFields<TransactionRequest>`.
+// Required as a supertrait of `NetworkTransactionBuilder`.
+impl TransactionBuilder for AnyTransactionRequest {
+    fn chain_id(&self) -> Option<ChainId> {
+        self.0.chain_id()
+    }
+
+    fn set_chain_id(&mut self, chain_id: ChainId) {
+        self.0.set_chain_id(chain_id)
+    }
+
+    fn nonce(&self) -> Option<u64> {
+        self.0.nonce()
+    }
+
+    fn set_nonce(&mut self, nonce: u64) {
+        self.0.set_nonce(nonce)
+    }
+
+    fn take_nonce(&mut self) -> Option<u64> {
+        self.0.deref_mut().nonce.take()
+    }
+
+    fn input(&self) -> Option<&Bytes> {
+        self.0.input()
+    }
+
+    fn set_input<T: Into<Bytes>>(&mut self, input: T) {
+        self.0.set_input(input);
+    }
+
+    fn set_input_kind<T: Into<Bytes>>(&mut self, input: T, kind: TransactionInputKind) {
+        self.0.set_input_kind(input, kind)
+    }
+
+    fn from(&self) -> Option<Address> {
+        self.0.from()
+    }
+
+    fn set_from(&mut self, from: Address) {
+        self.0.set_from(from);
+    }
+
+    fn kind(&self) -> Option<TxKind> {
+        self.0.kind()
+    }
+
+    fn clear_kind(&mut self) {
+        self.0.clear_kind()
+    }
+
+    fn set_kind(&mut self, kind: TxKind) {
+        self.0.set_kind(kind)
+    }
+
+    fn value(&self) -> Option<U256> {
+        self.0.value()
+    }
+
+    fn set_value(&mut self, value: U256) {
+        self.0.set_value(value)
+    }
+
+    fn gas_price(&self) -> Option<u128> {
+        self.0.gas_price()
+    }
+
+    fn set_gas_price(&mut self, gas_price: u128) {
+        self.0.set_gas_price(gas_price);
+    }
+
+    fn max_fee_per_gas(&self) -> Option<u128> {
+        self.0.max_fee_per_gas()
+    }
+
+    fn set_max_fee_per_gas(&mut self, max_fee_per_gas: u128) {
+        self.0.set_max_fee_per_gas(max_fee_per_gas);
+    }
+
+    fn max_priority_fee_per_gas(&self) -> Option<u128> {
+        self.0.max_priority_fee_per_gas()
+    }
+
+    fn set_max_priority_fee_per_gas(&mut self, max_priority_fee_per_gas: u128) {
+        self.0
+            .set_max_priority_fee_per_gas(max_priority_fee_per_gas);
+    }
+
+    fn gas_limit(&self) -> Option<u64> {
+        self.0.gas_limit()
+    }
+
+    fn set_gas_limit(&mut self, gas_limit: u64) {
+        self.0.set_gas_limit(gas_limit);
+    }
+
+    fn access_list(&self) -> Option<&AccessList> {
+        self.0.access_list()
+    }
+
+    fn set_access_list(&mut self, access_list: AccessList) {
+        self.0.set_access_list(access_list)
+    }
+}
+
+// Delegate `TransactionBuilder4844` — required as a supertrait of `NetworkTransactionBuilder`.
+impl TransactionBuilder4844 for AnyTransactionRequest {
+    fn max_fee_per_blob_gas(&self) -> Option<u128> {
+        self.0.max_fee_per_blob_gas()
+    }
+
+    fn set_max_fee_per_blob_gas(&mut self, max_fee_per_blob_gas: u128) {
+        self.0.set_max_fee_per_blob_gas(max_fee_per_blob_gas)
+    }
+
+    fn blob_sidecar(&self) -> Option<&BlobTransactionSidecarVariant> {
+        self.0.blob_sidecar()
+    }
+
+    fn has_blob_sidecar(&self) -> bool {
+        self.0.has_blob_sidecar()
+    }
+
+    fn set_blob_sidecar(&mut self, sidecar: BlobTransactionSidecarVariant) {
+        self.0.set_blob_sidecar(sidecar)
+    }
+}
+
+// Delegate `TransactionBuilder7702` — required as a supertrait of `NetworkTransactionBuilder`.
+impl TransactionBuilder7702 for AnyTransactionRequest {
+    fn authorization_list(&self) -> Option<&Vec<SignedAuthorization>> {
+        self.0.authorization_list()
+    }
+
+    fn set_authorization_list(&mut self, authorization_list: Vec<SignedAuthorization>) {
+        self.0.set_authorization_list(authorization_list)
+    }
+}
+
+impl NetworkTransactionBuilder<AnyNetworkBare> for AnyTransactionRequest {
+    fn complete_type(
+        &self,
+        ty: <AnyNetworkBare as Network>::TxType,
+    ) -> Result<(), Vec<&'static str>> {
+        self.0
+            .deref()
+            .complete_type(ty.try_into().map_err(|_| vec!["supported tx type"])?)
+    }
+
+    fn can_submit(&self) -> bool {
+        self.0.deref().can_submit()
+    }
+
+    fn can_build(&self) -> bool {
+        self.0.deref().can_build()
+    }
+
+    fn output_tx_type(&self) -> <AnyNetworkBare as Network>::TxType {
+        self.0.deref().output_tx_type().into()
+    }
+
+    fn output_tx_type_checked(&self) -> Option<<AnyNetworkBare as Network>::TxType> {
+        self.0.deref().output_tx_type_checked().map(Into::into)
+    }
+
+    fn prep_for_submission(&mut self) {
+        self.0.deref_mut().prep_for_submission()
+    }
+
+    fn build_unsigned(
+        self,
+    ) -> BuildResult<<AnyNetworkBare as Network>::UnsignedTx, AnyNetworkBare> {
+        if let Err((tx_type, missing)) = self.0.missing_keys() {
+            return Err(TransactionBuilderError::InvalidTransactionRequest(
+                tx_type.into(),
+                missing,
+            )
+            .into_unbuilt(self));
+        }
+        Ok(self
+            .0
+            .inner
+            .build_typed_tx()
+            .expect("checked by missing_keys")
+            .into())
+    }
+
+    async fn build<W: NetworkWallet<AnyNetworkBare>>(
+        self,
+        wallet: &W,
+    ) -> Result<<AnyNetworkBare as Network>::TxEnvelope, TransactionBuilderError<AnyNetworkBare>>
+    {
+        Ok(wallet.sign_request(self).await?)
+    }
+}
diff --git a/graph/src/components/ethereum/types.rs b/graph/src/components/ethereum/types.rs
index b43730590d4..104f6dbe036 100644
--- a/graph/src/components/ethereum/types.rs
+++ b/graph/src/components/ethereum/types.rs
@@ -1,68 +1,162 @@
-use serde::{Deserialize, Serialize};
-use std::{convert::TryFrom, sync::Arc};
-use web3::types::{
-    Action, Address, Block, Bytes, Log, Res, Trace, Transaction, TransactionReceipt, H256, U256,
-    U64,
+use alloy::{
+    network::{
+        AnyHeader, AnyReceiptEnvelope, AnyRpcHeader, AnyTxEnvelope, ReceiptResponse,
+        TransactionResponse,
+    },
+    primitives::{Address, B256, Bytes, U256},
+    rpc::types::{
+        Block, Header, Log, Transaction, TransactionReceipt,
+        trace::parity::{Action, LocalizedTransactionTrace, TraceOutput},
+    },
 };
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
 
 use crate::{
     blockchain::{BlockPtr, BlockTime},
     prelude::BlockNumber,
 };
 
-pub type LightEthereumBlock = Block<Transaction>;
+use super::json_patch;
+
+pub type AnyTransaction = Transaction<AnyTxEnvelope>;
+pub type AnyBlock = Block<AnyTransaction, Header<AnyHeader>>;
+/// Like alloy's `AnyTransactionReceipt` but without the `WithOtherFields` wrapper,
+/// avoiding `#[serde(flatten)]` overhead during deserialization.
+pub type AnyTransactionReceiptBare = TransactionReceipt<AnyReceiptEnvelope<Log>>;
+
+#[allow(dead_code)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct LightEthereumBlock(AnyBlock);
+
+impl Default for LightEthereumBlock {
+    fn default() -> Self {
+        use alloy::rpc::types::BlockTransactions;
+
+        Self(Block {
+            header: AnyRpcHeader::default(),
+            transactions: BlockTransactions::Full(vec![]),
+            uncles: vec![],
+            withdrawals: None,
+        })
+    }
+}
+
+impl LightEthereumBlock {
+    pub fn new(block: AnyBlock) -> Self {
+        Self(block)
+    }
+
+    pub fn hash(&self) -> B256 {
+        self.0.header.hash
+    }
+
+    pub fn number_u64(&self) -> u64 {
+        self.0.header.number
+    }
+
+    pub fn timestamp_u64(&self) -> u64 {
+        self.0.header.timestamp
+    }
+
+    pub fn transactions(&self) -> Option<&[AnyTransaction]> {
+        self.0.transactions.as_transactions()
+    }
+
+    pub fn inner(&self) -> &AnyBlock {
+        &self.0
+    }
+
+    pub fn base_fee_per_gas(&self) -> Option<u64> {
+        self.0.header.base_fee_per_gas
+    }
+}
 
 pub trait LightEthereumBlockExt {
     fn number(&self) -> BlockNumber;
-    fn transaction_for_log(&self, log: &Log) -> Option<Transaction>;
-    fn transaction_for_call(&self, call: &EthereumCall) -> Option<Transaction>;
+    fn transaction_for_log(&self, log: &Log) -> Option<AnyTransaction>;
+    fn transaction_for_call(&self, call: &EthereumCall) -> Option<AnyTransaction>;
     fn parent_ptr(&self) -> Option<BlockPtr>;
     fn format(&self) -> String;
     fn block_ptr(&self) -> BlockPtr;
     fn timestamp(&self) -> BlockTime;
 }
 
-impl LightEthereumBlockExt for LightEthereumBlock {
+impl LightEthereumBlockExt for AnyBlock {
     fn number(&self) -> BlockNumber {
-        BlockNumber::try_from(self.number.unwrap().as_u64()).unwrap()
+        BlockNumber::try_from(self.header.number).unwrap()
     }
 
-    fn transaction_for_log(&self, log: &Log) -> Option<Transaction> {
-        log.transaction_hash
-            .and_then(|hash| self.transactions.iter().find(|tx| tx.hash == hash))
-            .cloned()
+    fn timestamp(&self) -> BlockTime {
+        let time = self.header.timestamp;
+        let time = i64::try_from(time).unwrap();
+        BlockTime::since_epoch(time, 0)
     }
 
-    fn transaction_for_call(&self, call: &EthereumCall) -> Option<Transaction> {
-        call.transaction_hash
-            .and_then(|hash| self.transactions.iter().find(|tx| tx.hash == hash))
-            .cloned()
+    fn transaction_for_log(&self, log: &Log) -> Option<AnyTransaction> {
+        log.transaction_hash.and_then(|hash| {
+            self.transactions
+                .txns()
+                .find(|tx| tx.tx_hash() == hash)
+                .cloned()
+        })
+    }
+
+    fn transaction_for_call(&self, call: &EthereumCall) -> Option<AnyTransaction> {
+        call.transaction_hash.and_then(|hash| {
+            self.transactions
+                .txns()
+                .find(|tx| tx.tx_hash() == hash)
+                .cloned()
+        })
     }
 
     fn parent_ptr(&self) -> Option<BlockPtr> {
-        match self.number() {
+        match self.header.number {
             0 => None,
-            n => Some(BlockPtr::from((self.parent_hash, n - 1))),
+            n => {
+                let number = i32::try_from(n - 1).unwrap();
+                Some(BlockPtr::new(self.header.parent_hash.into(), number))
+            }
         }
     }
 
     fn format(&self) -> String {
-        format!(
-            "{} ({})",
-            self.number
-                .map_or(String::from("none"), |number| format!("#{}", number)),
-            self.hash
-                .map_or(String::from("-"), |hash| format!("{:x}", hash))
-        )
+        format!("{} ({})", self.header.number, self.header.hash)
     }
 
     fn block_ptr(&self) -> BlockPtr {
-        BlockPtr::from((self.hash.unwrap(), self.number.unwrap().as_u64()))
+        BlockPtr::from((self.header.hash, self.header.number))
+    }
+}
+
+impl LightEthereumBlockExt for LightEthereumBlock {
+    fn number(&self) -> BlockNumber {
+        self.0.header.number.try_into().unwrap()
+    }
+
+    fn transaction_for_log(&self, log: &alloy::rpc::types::Log) -> Option<AnyTransaction> {
+        self.0.transaction_for_log(log)
+    }
+
+    fn transaction_for_call(&self, call: &EthereumCall) -> Option<AnyTransaction> {
+        self.0.transaction_for_call(call)
+    }
+
+    fn parent_ptr(&self) -> Option<BlockPtr> {
+        self.0.parent_ptr()
+    }
+
+    fn format(&self) -> String {
+        self.0.format()
+    }
+
+    fn block_ptr(&self) -> BlockPtr {
+        self.0.block_ptr()
     }
 
     fn timestamp(&self) -> BlockTime {
-        let ts = i64::try_from(self.timestamp.as_u64()).unwrap();
-        BlockTime::since_epoch(ts, 0)
+        self.0.timestamp()
     }
 }
 
@@ -90,24 +184,14 @@ impl EthereumBlockWithCalls {
                 "failed to find the receipt for this transaction"
             ))?;
 
-        Ok(evaluate_transaction_status(receipt.status))
+        Ok(receipt.status())
     }
 }
 
-/// Evaluates if a given transaction was successful.
-///
-/// Returns `true` on success and `false` on failure.
-/// If a receipt does not have a status value (EIP-658), assume the transaction was successful.
-pub fn evaluate_transaction_status(receipt_status: Option<U64>) -> bool {
-    receipt_status
-        .map(|status| !status.is_zero())
-        .unwrap_or(true)
-}
-
-#[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct EthereumBlock {
     pub block: Arc<LightEthereumBlock>,
-    pub transaction_receipts: Vec<Arc<TransactionReceipt>>,
+    pub transaction_receipts: Vec<Arc<AnyTransactionReceiptBare>>,
 }
 
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
@@ -115,37 +199,40 @@ pub struct EthereumCall {
     pub from: Address,
     pub to: Address,
     pub value: U256,
-    pub gas_used: U256,
+    pub gas_used: u64,
     pub input: Bytes,
     pub output: Bytes,
     pub block_number: BlockNumber,
-    pub block_hash: H256,
-    pub transaction_hash: Option<H256>,
+    pub block_hash: B256,
+    pub transaction_hash: Option<B256>,
     pub transaction_index: u64,
 }
 
 impl EthereumCall {
-    pub fn try_from_trace(trace: &Trace) -> Option<Self> {
+    pub fn try_from_trace(trace: &LocalizedTransactionTrace) -> Option<Self> {
         // The parity-ethereum tracing api returns traces for operations which had execution errors.
         // Filter errorful traces out, since call handlers should only run on successful CALLs.
-        if trace.error.is_some() {
+
+        let tx_trace = &trace.trace;
+
+        if tx_trace.error.is_some() {
             return None;
         }
         // We are only interested in traces from CALLs
-        let call = match &trace.action {
+        let call = match &tx_trace.action {
             // Contract to contract value transfers compile to the CALL opcode
             // and have no input. Call handlers are for triggering on explicit method calls right now.
             Action::Call(call) if call.input.0.len() >= 4 => call,
             _ => return None,
         };
-        let (output, gas_used) = match &trace.result {
-            Some(Res::Call(result)) => (result.output.clone(), result.gas_used),
+        let (output, gas_used) = match &tx_trace.result {
+            Some(TraceOutput::Call(result)) => (result.output.clone(), result.gas_used),
             _ => return None,
         };
 
         // The only traces without transactions are those from Parity block reward contracts, we
         // don't support triggering on that.
-        let transaction_index = trace.transaction_position? as u64;
+        let transaction_index = trace.transaction_position?;
 
         Some(EthereumCall {
             from: call.from,
@@ -154,28 +241,113 @@ impl EthereumCall {
             gas_used,
             input: call.input.clone(),
             output,
-            block_number: trace.block_number as BlockNumber,
-            block_hash: trace.block_hash,
+            block_number: BlockNumber::try_from(
+                trace
+                    .block_number
+                    .expect("localized trace must have block_number"),
+            )
+            .unwrap(),
+            block_hash: trace
+                .block_hash
+                .expect("localized trace must have block_hash"),
             transaction_hash: trace.transaction_hash,
             transaction_index,
         })
     }
 }
 
-impl From<EthereumBlock> for BlockPtr {
-    fn from(b: EthereumBlock) -> BlockPtr {
-        BlockPtr::from((b.block.hash.unwrap(), b.block.number.unwrap().as_u64()))
+impl<'a> From<&'a EthereumCall> for BlockPtr {
+    fn from(call: &'a EthereumCall) -> BlockPtr {
+        BlockPtr::from((call.block_hash, call.block_number))
     }
 }
 
-impl<'a> From<&'a EthereumBlock> for BlockPtr {
-    fn from(b: &'a EthereumBlock) -> BlockPtr {
-        BlockPtr::from((b.block.hash.unwrap(), b.block.number.unwrap().as_u64()))
-    }
+/// Typed cached block for Ethereum. Stores the deserialized block so that
+/// repeated reads from the in-memory cache avoid `serde_json::from_value()`.
+#[derive(Clone, Debug)]
+pub enum CachedBlock {
+    Full(EthereumBlock),
+    Light(Arc<LightEthereumBlock>),
 }
 
-impl<'a> From<&'a EthereumCall> for BlockPtr {
-    fn from(call: &'a EthereumCall) -> BlockPtr {
-        BlockPtr::from((call.block_hash, call.block_number))
+impl CachedBlock {
+    pub fn light_block(&self) -> &LightEthereumBlock {
+        match self {
+            CachedBlock::Full(block) => &block.block,
+            CachedBlock::Light(block) => block,
+        }
+    }
+
+    pub fn to_light_block(&self) -> Arc<LightEthereumBlock> {
+        match self {
+            CachedBlock::Full(block) => block.block.clone(),
+            CachedBlock::Light(block) => block.clone(),
+        }
+    }
+
+    pub fn into_full_block(self) -> Option<EthereumBlock> {
+        match self {
+            CachedBlock::Full(block) => Some(block),
+            CachedBlock::Light(_) => None,
+        }
+    }
+
+    /// Serializes the block data directly. Note: the output shape differs
+    /// from the store format (which wraps in a `{"block": ..}` envelope).
+    pub fn to_json(&self) -> serde_json::Result<serde_json::Value> {
+        match self {
+            CachedBlock::Full(b) => serde_json::to_value(b),
+            CachedBlock::Light(b) => serde_json::to_value(b),
+        }
+    }
+
+    /// Deserializes a JSON block from the store into a typed `CachedBlock`.
+    /// Returns `None` for shallow (header-only) blocks.
+    ///
+    /// Patches missing `type` fields in transactions/receipts before
+    /// deserialization for compatibility with blocks cached by older
+    /// graph-node versions.
+    pub fn from_json(mut value: serde_json::Value) -> Option<Self> {
+        // Shallow blocks have no body, only a null `data` field.
+        if value.get("data") == Some(&serde_json::Value::Null) {
+            return None;
+        }
+
+        let has_receipts = value
+            .get("transaction_receipts")
+            .is_some_and(|v| !v.is_null());
+
+        if has_receipts {
+            // Full block: patch in place then deserialize the entire value.
+            if let Some(block) = value.get_mut("block") {
+                json_patch::patch_block_transactions(block);
+            }
+            if let Some(receipts) = value.get_mut("transaction_receipts") {
+                json_patch::patch_receipts(receipts);
+            }
+            serde_json::from_value(value).ok().map(CachedBlock::Full)
+        } else {
+            // Light block: extract the inner `block` field, patch, and deserialize.
+            let mut inner = value
+                .as_object_mut()
+                .and_then(|obj| obj.remove("block"))
+                .unwrap_or(value);
+            json_patch::patch_block_transactions(&mut inner);
+            serde_json::from_value(inner)
+                .ok()
+                .map(|b| CachedBlock::Light(Arc::new(b)))
+        }
+    }
+
+    pub fn timestamp(&self) -> Option<u64> {
+        Some(self.light_block().timestamp_u64())
+    }
+
+    pub fn parent_ptr(&self) -> Option<BlockPtr> {
+        self.light_block().parent_ptr()
+    }
+
+    pub fn ptr(&self) -> BlockPtr {
+        self.light_block().block_ptr()
     }
 }
diff --git a/graph/src/components/graphql.rs b/graph/src/components/graphql.rs
index 4a6fcbe5638..8d42cecb9d8 100644
--- a/graph/src/components/graphql.rs
+++ b/graph/src/components/graphql.rs
@@ -1,18 +1,12 @@
-use futures::prelude::*;
-
-use crate::data::query::QueryResults;
 use crate::data::query::{Query, QueryTarget};
-use crate::data::subscription::{Subscription, SubscriptionError, SubscriptionResult};
-use crate::prelude::DeploymentHash;
+use crate::data::query::{QueryResults, SqlQueryReq};
+use crate::data::store::SqlQueryObject;
+use crate::prelude::{DeploymentHash, QueryExecutionError};
 
 use async_trait::async_trait;
 use std::sync::Arc;
 use std::time::Duration;
 
-/// Future for subscription results.
-pub type SubscriptionResultFuture =
-    Box<dyn Future<Item = SubscriptionResult, Error = SubscriptionError> + Send>;
-
 pub enum GraphQlTarget {
     SubgraphName(String),
     Deployment(DeploymentHash),
@@ -34,14 +28,12 @@ pub trait GraphQlRunner: Send + Sync + 'static {
         max_skip: Option<u32>,
     ) -> QueryResults;
 
-    /// Runs a GraphQL subscription and returns a stream of results.
-    async fn run_subscription(
-        self: Arc<Self>,
-        subscription: Subscription,
-        target: QueryTarget,
-    ) -> Result<SubscriptionResult, SubscriptionError>;
-
     fn metrics(&self) -> Arc<dyn GraphQLMetrics>;
+
+    async fn run_sql_query(
+        self: Arc<Self>,
+        req: SqlQueryReq,
+    ) -> Result<Vec<SqlQueryObject>, QueryExecutionError>;
 }
 
 pub trait GraphQLMetrics: Send + Sync + 'static {
diff --git a/graph/src/components/link_resolver.rs b/graph/src/components/link_resolver/arweave.rs
similarity index 69%
rename from graph/src/components/link_resolver.rs
rename to graph/src/components/link_resolver/arweave.rs
index aff56bf3d40..e42263c9fe1 100644
--- a/graph/src/components/link_resolver.rs
+++ b/graph/src/components/link_resolver/arweave.rs
@@ -1,16 +1,14 @@
 use std::pin::Pin;
-use std::time::Duration;
 
 use async_trait::async_trait;
 use futures03::prelude::Stream;
 use reqwest::Client;
 use serde_json::Value;
-use slog::{debug, Logger};
+use slog::{Logger, debug};
 use thiserror::Error;
 
-use crate::cheap_clone::CheapClone;
-use crate::data::subgraph::Link;
 use crate::data_source::offchain::Base64;
+use crate::derive::CheapClone;
 use crate::prelude::Error;
 use std::fmt::Debug;
 
@@ -25,28 +23,6 @@ pub struct JsonStreamValue {
 pub type JsonValueStream =
     Pin<Box<dyn Stream<Item = Result<JsonStreamValue, Error>> + Send + 'static>>;
 
-/// Resolves links to subgraph manifests and resources referenced by them.
-#[async_trait]
-pub trait LinkResolver: Send + Sync + 'static + Debug {
-    /// Updates the timeout used by the resolver.
-    fn with_timeout(&self, timeout: Duration) -> Box<dyn LinkResolver>;
-
-    /// Enables infinite retries.
-    fn with_retries(&self) -> Box<dyn LinkResolver>;
-
-    /// Fetches the link contents as bytes.
-    async fn cat(&self, logger: &Logger, link: &Link) -> Result<Vec<u8>, Error>;
-
-    /// Fetches the IPLD block contents as bytes.
-    async fn get_block(&self, logger: &Logger, link: &Link) -> Result<Vec<u8>, Error>;
-
-    /// Read the contents of `link` and deserialize them into a stream of JSON
-    /// values. The values must each be on a single line; newlines are significant
-    /// as they are used to split the file contents and each line is deserialized
-    /// separately.
-    async fn json_stream(&self, logger: &Logger, link: &Link) -> Result<JsonValueStream, Error>;
-}
-
 #[derive(Debug)]
 pub struct ArweaveClient {
     base_url: url::Url,
@@ -54,21 +30,19 @@ pub struct ArweaveClient {
     logger: Logger,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, CheapClone)]
 pub enum FileSizeLimit {
     Unlimited,
     MaxBytes(u64),
 }
 
-impl CheapClone for FileSizeLimit {}
-
 impl Default for ArweaveClient {
     fn default() -> Self {
         use slog::o;
 
         Self {
             base_url: "https://arweave.net".parse().unwrap(),
-            client: Client::default(),
+            client: Client::builder().gzip(false).build().unwrap(),
             logger: Logger::root(slog::Discard, o!()),
         }
     }
@@ -79,7 +53,26 @@ impl ArweaveClient {
         Self {
             base_url,
             logger,
-            client: Client::default(),
+            client: Client::builder().gzip(false).build().unwrap(),
+        }
+    }
+
+    /// Make a request to arweave.net to fetch the content of the file with
+    /// the given txid/filename. Returns `None` if `arweave.net` is not
+    /// reachable.
+    #[cfg(debug_assertions)]
+    pub async fn get_test(file: &Base64) -> Option<Vec<u8>> {
+        let client = Self::default();
+
+        match client.get(file).await {
+            Ok(resp) => Some(resp),
+            Err(ArweaveClientError::ServerUnavailable(_)) => {
+                eprintln!("arweave.net is not reachable, skipping arweave tests");
+                None
+            }
+            Err(e) => {
+                panic!("Failed to fetch from arweave.net: {:?}", e);
+            }
         }
     }
 }
@@ -103,10 +96,17 @@ impl ArweaveResolver for ArweaveClient {
             .await
             .map_err(ArweaveClientError::from)?;
 
+        println!("Got response from arweave.net with status {}", rsp.status());
+        if rsp.status() == reqwest::StatusCode::GATEWAY_TIMEOUT {
+            return Err(ArweaveClientError::ServerUnavailable(
+                self.base_url.to_string(),
+            ));
+        }
+
         match (&limit, rsp.content_length()) {
             (_, None) => return Err(ArweaveClientError::UnableToCheckFileSize),
             (FileSizeLimit::MaxBytes(max), Some(cl)) if cl > *max => {
-                return Err(ArweaveClientError::FileTooLarge { got: cl, max: *max })
+                return Err(ArweaveClientError::FileTooLarge { got: cl, max: *max });
             }
             _ => {}
         };
@@ -140,21 +140,22 @@ pub enum ArweaveClientError {
     FileTooLarge { got: u64, max: u64 },
     #[error("Unknown error")]
     Unknown(#[from] reqwest::Error),
+    #[error("Server {0} unavailable")]
+    ServerUnavailable(String),
 }
 
 #[cfg(test)]
 mod test {
     use serde_derive::Deserialize;
 
-    use crate::{
-        components::link_resolver::{ArweaveClient, ArweaveResolver},
-        data_source::offchain::Base64,
-    };
+    use crate::{components::link_resolver::ArweaveClient, data_source::offchain::Base64};
 
     // This test ensures that passing txid/filename works when the txid refers to manifest.
     // the actual data seems to have some binary header and footer so these ranges were found
     // by inspecting the data with hexdump.
-    #[tokio::test]
+    #[crate::test]
+    // Ignored because arweave.net is unreliable right now
+    #[ignore]
     async fn fetch_bundler_url() {
         let url = Base64::from("Rtdn3QWEzM88MPC2dpWyV5waO7Vuz3VwPl_usS2WoHM/DriveManifest.json");
         #[derive(Deserialize, Debug, PartialEq)]
@@ -162,8 +163,11 @@ mod test {
             pub manifest: String,
         }
 
-        let client = ArweaveClient::default();
-        let no_header = &client.get(&url).await.unwrap()[1295..320078];
+        let Some(body) = ArweaveClient::get_test(&url).await else {
+            return;
+        };
+
+        let no_header = &body[1295..320078];
         let content: Manifest = serde_json::from_slice(no_header).unwrap();
         assert_eq!(
             content,
diff --git a/graph/src/components/link_resolver/file.rs b/graph/src/components/link_resolver/file.rs
new file mode 100644
index 00000000000..593dccc641b
--- /dev/null
+++ b/graph/src/components/link_resolver/file.rs
@@ -0,0 +1,320 @@
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+use anyhow::anyhow;
+use async_trait::async_trait;
+
+use crate::components::link_resolver::LinkResolverContext;
+use crate::data::subgraph::Link;
+use crate::prelude::{Error, JsonValueStream, LinkResolver as LinkResolverTrait};
+
+#[derive(Clone, Debug)]
+pub struct FileLinkResolver {
+    base_dir: Option<PathBuf>,
+    timeout: Duration,
+    // This is a hashmap that maps the alias name to the path of the file that is aliased
+    aliases: HashMap<String, PathBuf>,
+}
+
+impl Default for FileLinkResolver {
+    fn default() -> Self {
+        Self {
+            base_dir: None,
+            timeout: Duration::from_secs(30),
+            aliases: HashMap::new(),
+        }
+    }
+}
+
+impl FileLinkResolver {
+    /// Create a new FileLinkResolver
+    ///
+    /// All paths are treated as absolute paths.
+    pub fn new(base_dir: Option<PathBuf>, aliases: HashMap<String, PathBuf>) -> Self {
+        Self {
+            base_dir,
+            timeout: Duration::from_secs(30),
+            aliases,
+        }
+    }
+
+    /// Create a new FileLinkResolver with a base directory
+    ///
+    /// All paths that are not absolute will be considered
+    /// relative to this base directory.
+    pub fn with_base_dir<P: AsRef<Path>>(base_dir: P) -> Self {
+        Self {
+            base_dir: Some(base_dir.as_ref().to_owned()),
+            timeout: Duration::from_secs(30),
+            aliases: HashMap::new(),
+        }
+    }
+
+    fn resolve_path(&self, link: &str) -> PathBuf {
+        let path = Path::new(link);
+
+        // If the path is an alias, use the aliased path
+        if let Some(aliased) = self.aliases.get(link) {
+            return aliased.clone();
+        }
+
+        // Return the path as is if base_dir is None, or join with base_dir if present.
+        // if "link" is an absolute path, join will simply return that path.
+        self.base_dir
+            .as_ref()
+            .map_or_else(|| path.to_owned(), |base_dir| base_dir.join(link))
+    }
+
+    /// This method creates a new resolver that is scoped to a specific subgraph
+    /// It will set the base directory to the parent directory of the manifest path
+    /// This is required because paths mentioned in the subgraph manifest are relative paths
+    /// and we need a new resolver with the right base directory for the specific subgraph
+    fn clone_for_manifest(&self, manifest_path_str: &str) -> Result<Self, Error> {
+        let mut resolver = self.clone();
+
+        // Create a path to the manifest based on the current resolver's
+        // base directory or default to using the deployment string as path
+        // If the deployment string is an alias, use the aliased path
+        let manifest_path = if let Some(aliased) = self.aliases.get(manifest_path_str) {
+            aliased.clone()
+        } else {
+            match &resolver.base_dir {
+                Some(dir) => dir.join(manifest_path_str),
+                None => PathBuf::from(manifest_path_str),
+            }
+        };
+
+        let canonical_manifest_path = manifest_path
+            .canonicalize()
+            .map_err(|e| anyhow!("Failed to canonicalize manifest path: {}", e))?;
+
+        // The manifest path is the path of the subgraph manifest file in the build directory
+        // We use the parent directory as the base directory for the new resolver
+        let base_dir = canonical_manifest_path
+            .parent()
+            .ok_or_else(|| anyhow!("Manifest path has no parent directory"))?
+            .to_path_buf();
+
+        resolver.base_dir = Some(base_dir);
+        Ok(resolver)
+    }
+}
+
+pub fn remove_prefix(link: &str) -> &str {
+    const IPFS: &str = "/ipfs/";
+    link.strip_prefix(IPFS).unwrap_or(link)
+}
+
+#[async_trait]
+impl LinkResolverTrait for FileLinkResolver {
+    fn with_timeout(&self, timeout: Duration) -> Box<dyn LinkResolverTrait> {
+        let mut resolver = self.clone();
+        resolver.timeout = timeout;
+        Box::new(resolver)
+    }
+
+    fn with_retries(&self) -> Box<dyn LinkResolverTrait> {
+        Box::new(self.clone())
+    }
+
+    async fn cat(&self, ctx: &LinkResolverContext, link: &Link) -> Result<Vec<u8>, Error> {
+        let link = remove_prefix(&link.link);
+        let path = self.resolve_path(link);
+
+        slog::debug!(ctx.logger, "File resolver: reading file";
+            "path" => path.to_string_lossy().to_string());
+
+        match tokio::fs::read(&path).await {
+            Ok(data) => Ok(data),
+            Err(e) => {
+                slog::error!(ctx.logger, "Failed to read file";
+                    "path" => path.to_string_lossy().to_string(),
+                    "error" => e.to_string());
+                Err(anyhow!("Failed to read file {}: {}", path.display(), e))
+            }
+        }
+    }
+
+    fn for_manifest(&self, manifest_path: &str) -> Result<Box<dyn LinkResolverTrait>, Error> {
+        Ok(Box::new(self.clone_for_manifest(manifest_path)?))
+    }
+
+    async fn get_block(&self, _ctx: &LinkResolverContext, _link: &Link) -> Result<Vec<u8>, Error> {
+        Err(anyhow!("get_block is not implemented for FileLinkResolver"))
+    }
+
+    async fn json_stream(
+        &self,
+        _ctx: &LinkResolverContext,
+        _link: &Link,
+    ) -> Result<JsonValueStream, Error> {
+        Err(anyhow!(
+            "json_stream is not implemented for FileLinkResolver"
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::env;
+    use std::fs;
+    use std::io::Write;
+
+    #[crate::test]
+    async fn test_file_resolver_absolute() {
+        // Test the resolver without a base directory (absolute paths only)
+
+        // Create a temporary directory for test files
+        let temp_dir = env::temp_dir().join("file_resolver_test");
+        let _ = fs::create_dir_all(&temp_dir);
+
+        // Create a test file in the temp directory
+        let test_file_path = temp_dir.join("test.txt");
+        let test_content = b"Hello, world!";
+        let mut file = fs::File::create(&test_file_path).unwrap();
+        file.write_all(test_content).unwrap();
+
+        // Create a resolver without a base directory
+        let resolver = FileLinkResolver::default();
+
+        // Test valid path resolution
+        let link = Link {
+            link: test_file_path.to_string_lossy().to_string(),
+        };
+        let result = resolver
+            .cat(&LinkResolverContext::test(), &link)
+            .await
+            .unwrap();
+        assert_eq!(result, test_content);
+
+        // Test path with leading slash that likely doesn't exist
+        let link = Link {
+            link: "/test.txt".to_string(),
+        };
+        let result = resolver.cat(&LinkResolverContext::test(), &link).await;
+        assert!(
+            result.is_err(),
+            "Reading /test.txt should fail as it doesn't exist"
+        );
+
+        // Clean up
+        let _ = fs::remove_file(test_file_path);
+        let _ = fs::remove_dir(temp_dir);
+    }
+
+    #[crate::test]
+    async fn test_file_resolver_with_base_dir() {
+        // Test the resolver with a base directory
+
+        // Create a temporary directory for test files
+        let temp_dir = env::temp_dir().join("file_resolver_test_base_dir");
+        let _ = fs::create_dir_all(&temp_dir);
+
+        // Create a test file in the temp directory
+        let test_file_path = temp_dir.join("test.txt");
+        let test_content = b"Hello from base dir!";
+        let mut file = fs::File::create(&test_file_path).unwrap();
+        file.write_all(test_content).unwrap();
+
+        // Create a resolver with a base directory
+        let resolver = FileLinkResolver::with_base_dir(&temp_dir);
+
+        // Test relative path (no leading slash)
+        let link = Link {
+            link: "test.txt".to_string(),
+        };
+        let result = resolver
+            .cat(&LinkResolverContext::test(), &link)
+            .await
+            .unwrap();
+        assert_eq!(result, test_content);
+
+        // Test absolute path
+        let link = Link {
+            link: test_file_path.to_string_lossy().to_string(),
+        };
+        let result = resolver
+            .cat(&LinkResolverContext::test(), &link)
+            .await
+            .unwrap();
+        assert_eq!(result, test_content);
+
+        // Test missing file
+        let link = Link {
+            link: "missing.txt".to_string(),
+        };
+        let result = resolver.cat(&LinkResolverContext::test(), &link).await;
+        assert!(result.is_err());
+
+        // Clean up
+        let _ = fs::remove_file(test_file_path);
+        let _ = fs::remove_dir(temp_dir);
+    }
+
+    #[crate::test]
+    async fn test_file_resolver_with_aliases() {
+        // Create a temporary directory for test files
+        let temp_dir = env::temp_dir().join("file_resolver_test_aliases");
+        let _ = fs::create_dir_all(&temp_dir);
+
+        // Create two test files with different content
+        let test_file1_path = temp_dir.join("file.txt");
+        let test_content1 = b"This is the file content";
+        let mut file1 = fs::File::create(&test_file1_path).unwrap();
+        file1.write_all(test_content1).unwrap();
+
+        let test_file2_path = temp_dir.join("another_file.txt");
+        let test_content2 = b"This is another file content";
+        let mut file2 = fs::File::create(&test_file2_path).unwrap();
+        file2.write_all(test_content2).unwrap();
+
+        // Create aliases mapping
+        let mut aliases = HashMap::new();
+        aliases.insert("alias1".to_string(), test_file1_path.clone());
+        aliases.insert("alias2".to_string(), test_file2_path.clone());
+        aliases.insert("deployment-id".to_string(), test_file1_path.clone());
+
+        // Create resolver with aliases
+        let resolver = FileLinkResolver::new(Some(temp_dir.clone()), aliases);
+
+        // Test resolving by aliases
+        let link1 = Link {
+            link: "alias1".to_string(),
+        };
+        let result1 = resolver
+            .cat(&LinkResolverContext::test(), &link1)
+            .await
+            .unwrap();
+        assert_eq!(result1, test_content1);
+
+        let link2 = Link {
+            link: "alias2".to_string(),
+        };
+        let result2 = resolver
+            .cat(&LinkResolverContext::test(), &link2)
+            .await
+            .unwrap();
+        assert_eq!(result2, test_content2);
+
+        // Test that the alias works in for_deployment as well
+        let deployment_resolver = resolver.clone_for_manifest("deployment-id").unwrap();
+
+        let expected_dir = test_file1_path.parent().unwrap();
+        let deployment_base_dir = deployment_resolver.base_dir.clone().unwrap();
+
+        let canonical_expected_dir = expected_dir.canonicalize().unwrap();
+        let canonical_deployment_dir = deployment_base_dir.canonicalize().unwrap();
+
+        assert_eq!(
+            canonical_deployment_dir, canonical_expected_dir,
+            "Build directory paths don't match"
+        );
+
+        // Clean up
+        let _ = fs::remove_file(test_file1_path);
+        let _ = fs::remove_file(test_file2_path);
+        let _ = fs::remove_dir(temp_dir);
+    }
+}
diff --git a/graph/src/components/link_resolver/ipfs.rs b/graph/src/components/link_resolver/ipfs.rs
new file mode 100644
index 00000000000..c1b866c9994
--- /dev/null
+++ b/graph/src/components/link_resolver/ipfs.rs
@@ -0,0 +1,343 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::anyhow;
+use async_trait::async_trait;
+use bytes::BytesMut;
+use derive_more::Debug;
+use futures03::compat::Stream01CompatExt;
+use futures03::stream::StreamExt;
+use futures03::stream::TryStreamExt;
+use serde_json::Value;
+
+use crate::derive::CheapClone;
+use crate::env::EnvVars;
+use crate::futures01::Async;
+use crate::futures01::Poll;
+use crate::futures01::stream::Stream;
+use crate::futures01::stream::poll_fn;
+use crate::futures01::try_ready;
+use crate::ipfs::{ContentPath, IpfsClient, IpfsContext, RetryPolicy};
+use crate::prelude::*;
+
+use super::{LinkResolver, LinkResolverContext};
+
+#[derive(Clone, CheapClone, Debug)]
+pub struct IpfsResolver {
+    #[debug(skip)]
+    client: Arc<dyn IpfsClient>,
+
+    timeout: Duration,
+    max_file_size: usize,
+    max_map_file_size: usize,
+
+    /// When set to `true`, it means infinite retries, ignoring the timeout setting.
+    retry: bool,
+}
+
+impl IpfsResolver {
+    pub fn new(client: Arc<dyn IpfsClient>, env_vars: Arc<EnvVars>) -> Self {
+        let env = &env_vars.mappings;
+
+        Self {
+            client,
+            timeout: env.ipfs_timeout,
+            max_file_size: env.max_ipfs_file_bytes,
+            max_map_file_size: env.max_ipfs_map_file_size,
+            retry: false,
+        }
+    }
+}
+
+#[async_trait]
+impl LinkResolver for IpfsResolver {
+    fn with_timeout(&self, timeout: Duration) -> Box<dyn LinkResolver> {
+        let mut s = self.cheap_clone();
+        s.timeout = timeout;
+        Box::new(s)
+    }
+
+    fn with_retries(&self) -> Box<dyn LinkResolver> {
+        let mut s = self.cheap_clone();
+        s.retry = true;
+        Box::new(s)
+    }
+
+    fn for_manifest(&self, _manifest_path: &str) -> Result<Box<dyn LinkResolver>, Error> {
+        Ok(Box::new(self.cheap_clone()))
+    }
+
+    async fn cat(&self, ctx: &LinkResolverContext, link: &Link) -> Result<Vec<u8>, Error> {
+        let LinkResolverContext {
+            deployment_hash,
+            logger,
+        } = ctx;
+
+        let path = ContentPath::new(&link.link)?;
+        let timeout = self.timeout;
+        let max_file_size = self.max_file_size;
+
+        let (timeout, retry_policy) = if self.retry {
+            (None, RetryPolicy::NonDeterministic)
+        } else {
+            (Some(timeout), RetryPolicy::Networking)
+        };
+
+        let ctx = IpfsContext {
+            deployment_hash: deployment_hash.cheap_clone(),
+            logger: logger.cheap_clone(),
+        };
+        let data = self
+            .client
+            .clone()
+            .cat(&ctx, &path, max_file_size, timeout, retry_policy)
+            .await?
+            .to_vec();
+
+        Ok(data)
+    }
+
+    async fn get_block(&self, ctx: &LinkResolverContext, link: &Link) -> Result<Vec<u8>, Error> {
+        let LinkResolverContext {
+            deployment_hash,
+            logger,
+        } = ctx;
+
+        let path = ContentPath::new(&link.link)?;
+        let timeout = self.timeout;
+
+        trace!(logger, "IPFS block get"; "hash" => path.to_string());
+
+        let (timeout, retry_policy) = if self.retry {
+            (None, RetryPolicy::NonDeterministic)
+        } else {
+            (Some(timeout), RetryPolicy::Networking)
+        };
+
+        let ctx = IpfsContext {
+            deployment_hash: deployment_hash.cheap_clone(),
+            logger: logger.cheap_clone(),
+        };
+        let data = self
+            .client
+            .clone()
+            .get_block(&ctx, &path, timeout, retry_policy)
+            .await?
+            .to_vec();
+
+        Ok(data)
+    }
+
+    async fn json_stream(
+        &self,
+        ctx: &LinkResolverContext,
+        link: &Link,
+    ) -> Result<JsonValueStream, Error> {
+        let LinkResolverContext {
+            deployment_hash,
+            logger,
+        } = ctx;
+
+        let path = ContentPath::new(&link.link)?;
+        let max_map_file_size = self.max_map_file_size;
+        let timeout = self.timeout;
+
+        trace!(logger, "IPFS JSON stream"; "hash" => path.to_string());
+
+        let (timeout, retry_policy) = if self.retry {
+            (None, RetryPolicy::NonDeterministic)
+        } else {
+            (Some(timeout), RetryPolicy::Networking)
+        };
+
+        let ctx = IpfsContext {
+            deployment_hash: deployment_hash.cheap_clone(),
+            logger: logger.cheap_clone(),
+        };
+        let mut stream = self
+            .client
+            .clone()
+            .cat_stream(&ctx, &path, timeout, retry_policy)
+            .await?
+            .fuse()
+            .boxed()
+            .compat();
+
+        let mut buf = BytesMut::with_capacity(1024);
+
+        // Count the number of lines we've already successfully deserialized.
+        // We need that to adjust the line number in error messages from serde_json
+        // to translate from line numbers in the snippet we are deserializing
+        // to the line number in the overall file
+        let mut count = 0;
+
+        let mut cumulative_file_size = 0;
+
+        let stream: JsonValueStream = Box::pin(
+            poll_fn(move || -> Poll<Option<JsonStreamValue>, Error> {
+                loop {
+                    cumulative_file_size += buf.len();
+
+                    if cumulative_file_size > max_map_file_size {
+                        return Err(anyhow!(
+                            "IPFS file {} is too large. It can be at most {} bytes",
+                            path,
+                            max_map_file_size,
+                        ));
+                    }
+
+                    if let Some(offset) = buf.iter().position(|b| *b == b'\n') {
+                        let line_bytes = buf.split_to(offset + 1);
+                        count += 1;
+                        if line_bytes.len() > 1 {
+                            let line = std::str::from_utf8(&line_bytes)?;
+                            let res = match serde_json::from_str::<Value>(line) {
+                                Ok(v) => Ok(Async::Ready(Some(JsonStreamValue {
+                                    value: v,
+                                    line: count,
+                                }))),
+                                Err(e) => {
+                                    // Adjust the line number in the serde error. This
+                                    // is fun because we can only get at the full error
+                                    // message, and not the error message without line number
+                                    let msg = e.to_string();
+                                    let msg = msg.split(" at line ").next().unwrap();
+                                    Err(anyhow!(
+                                        "{} at line {} column {}: '{}'",
+                                        msg,
+                                        e.line() + count - 1,
+                                        e.column(),
+                                        line
+                                    ))
+                                }
+                            };
+                            return res;
+                        }
+                    } else {
+                        // We only get here if there is no complete line in buf, and
+                        // it is therefore ok to immediately pass an Async::NotReady
+                        // from stream through.
+                        // If we get a None from poll, but still have something in buf,
+                        // that means the input was not terminated with a newline. We
+                        // add that so that the last line gets picked up in the next
+                        // run through the loop.
+                        match try_ready!(stream.poll().map_err(|e| anyhow::anyhow!("{}", e))) {
+                            Some(b) => buf.extend_from_slice(&b),
+                            None if !buf.is_empty() => buf.extend_from_slice(b"\n"),
+                            None => return Ok(Async::Ready(None)),
+                        }
+                    }
+                }
+            })
+            .compat(),
+        );
+
+        Ok(stream)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+    use crate::env::EnvVars;
+    use crate::ipfs::test_utils::add_files_to_local_ipfs_node_for_testing;
+    use crate::ipfs::{IpfsMetrics, IpfsRpcClient, ServerAddress};
+
+    #[crate::test]
+    async fn max_file_size() {
+        let mut env_vars = EnvVars::default();
+        env_vars.mappings.max_ipfs_file_bytes = 200;
+
+        let file: &[u8] = &[0u8; 201];
+
+        let cid = add_files_to_local_ipfs_node_for_testing([file.to_vec()])
+            .await
+            .unwrap()[0]
+            .hash
+            .to_owned();
+
+        let logger = crate::log::discard();
+
+        let client = IpfsRpcClient::new_unchecked(
+            ServerAddress::test_rpc_api(),
+            IpfsMetrics::test(),
+            &logger,
+        )
+        .unwrap();
+        let resolver = IpfsResolver::new(Arc::new(client), Arc::new(env_vars));
+
+        let err = IpfsResolver::cat(
+            &resolver,
+            &LinkResolverContext::test(),
+            &Link { link: cid.clone() },
+        )
+        .await
+        .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            format!("IPFS content from '{cid}' exceeds the 200 bytes limit")
+        );
+    }
+
+    async fn json_round_trip(text: &'static str, env_vars: EnvVars) -> Result<Vec<Value>, Error> {
+        let cid = add_files_to_local_ipfs_node_for_testing([text.as_bytes().to_vec()]).await?[0]
+            .hash
+            .to_owned();
+
+        let logger = crate::log::discard();
+        let client = IpfsRpcClient::new_unchecked(
+            ServerAddress::test_rpc_api(),
+            IpfsMetrics::test(),
+            &logger,
+        )?;
+        let resolver = IpfsResolver::new(Arc::new(client), Arc::new(env_vars));
+
+        let stream =
+            IpfsResolver::json_stream(&resolver, &LinkResolverContext::test(), &Link { link: cid })
+                .await?;
+        stream.map_ok(|sv| sv.value).try_collect().await
+    }
+
+    #[crate::test]
+    async fn read_json_stream() {
+        let values = json_round_trip("\"with newline\"\n", EnvVars::default()).await;
+        assert_eq!(vec![json!("with newline")], values.unwrap());
+
+        let values = json_round_trip("\"without newline\"", EnvVars::default()).await;
+        assert_eq!(vec![json!("without newline")], values.unwrap());
+
+        let values = json_round_trip("\"two\" \n \"things\"", EnvVars::default()).await;
+        assert_eq!(vec![json!("two"), json!("things")], values.unwrap());
+
+        let values = json_round_trip(
+            "\"one\"\n  \"two\" \n [\"bad\" \n \"split\"]",
+            EnvVars::default(),
+        )
+        .await;
+        assert_eq!(
+            "EOF while parsing a list at line 4 column 0: ' [\"bad\" \n'",
+            values.unwrap_err().to_string()
+        );
+    }
+
+    #[crate::test]
+    async fn ipfs_map_file_size() {
+        let file = "\"small test string that trips the size restriction\"";
+        let mut env_vars = EnvVars::default();
+        env_vars.mappings.max_ipfs_map_file_size = file.len() - 1;
+
+        let err = json_round_trip(file, env_vars).await.unwrap_err();
+
+        assert!(err.to_string().contains(" is too large"));
+
+        env_vars = EnvVars::default();
+        let values = json_round_trip(file, env_vars).await;
+        assert_eq!(
+            vec!["small test string that trips the size restriction"],
+            values.unwrap()
+        );
+    }
+}
diff --git a/graph/src/components/link_resolver/mod.rs b/graph/src/components/link_resolver/mod.rs
new file mode 100644
index 00000000000..5ec9ecaea61
--- /dev/null
+++ b/graph/src/components/link_resolver/mod.rs
@@ -0,0 +1,82 @@
+use std::{fmt::Debug, sync::Arc, time::Duration};
+
+use slog::Logger;
+
+use crate::{
+    cheap_clone::CheapClone,
+    data::subgraph::{DeploymentHash, Link},
+    derive::CheapClone,
+    prelude::Error,
+};
+
+mod arweave;
+mod file;
+mod ipfs;
+
+pub use arweave::*;
+use async_trait::async_trait;
+pub use file::*;
+pub use ipfs::*;
+
+/// Resolves links to subgraph manifests and resources referenced by them.
+#[async_trait]
+pub trait LinkResolver: Send + Sync + 'static + Debug {
+    /// Updates the timeout used by the resolver.
+    fn with_timeout(&self, timeout: Duration) -> Box<dyn LinkResolver>;
+
+    /// Enables infinite retries.
+    fn with_retries(&self) -> Box<dyn LinkResolver>;
+
+    /// Fetches the link contents as bytes.
+    async fn cat(&self, ctx: &LinkResolverContext, link: &Link) -> Result<Vec<u8>, Error>;
+
+    /// Fetches the IPLD block contents as bytes.
+    async fn get_block(&self, ctx: &LinkResolverContext, link: &Link) -> Result<Vec<u8>, Error>;
+
+    /// Creates a new resolver scoped to a specific subgraph manifest.
+    ///
+    /// For FileLinkResolver, this sets the base directory to the manifest's parent directory.
+    /// Note the manifest here is the manifest in the build directory, not the manifest in the source directory
+    /// to properly resolve relative paths referenced in the manifest (schema, mappings, etc.).
+    /// For other resolvers (IPFS/Arweave), this simply returns a clone since they use
+    /// absolute content identifiers.
+    ///
+    /// The `manifest_path` parameter can be a filesystem path or an alias. Aliases are used
+    /// in development environments (via `gnd --sources`) to map user-defined
+    /// aliases to actual subgraph paths, enabling local development with file-based
+    /// subgraphs that reference each other.
+    fn for_manifest(&self, manifest_path: &str) -> Result<Box<dyn LinkResolver>, Error>;
+
+    /// Read the contents of `link` and deserialize them into a stream of JSON
+    /// values. The values must each be on a single line; newlines are significant
+    /// as they are used to split the file contents and each line is deserialized
+    /// separately.
+    async fn json_stream(
+        &self,
+        ctx: &LinkResolverContext,
+        link: &Link,
+    ) -> Result<JsonValueStream, Error>;
+}
+
+#[derive(Debug, Clone, CheapClone)]
+pub struct LinkResolverContext {
+    pub deployment_hash: Arc<str>,
+    pub logger: Logger,
+}
+
+impl LinkResolverContext {
+    pub fn new(deployment_hash: &DeploymentHash, logger: &Logger) -> Self {
+        Self {
+            deployment_hash: deployment_hash.as_str().into(),
+            logger: logger.cheap_clone(),
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn test() -> Self {
+        Self {
+            deployment_hash: "test".into(),
+            logger: crate::log::discard(),
+        }
+    }
+}
diff --git a/graph/src/components/log_store/elasticsearch.rs b/graph/src/components/log_store/elasticsearch.rs
new file mode 100644
index 00000000000..4b1353690fe
--- /dev/null
+++ b/graph/src/components/log_store/elasticsearch.rs
@@ -0,0 +1,233 @@
+use async_trait::async_trait;
+use reqwest::Client;
+use serde::Deserialize;
+use serde_json::json;
+use slog::{Logger, warn};
+use std::collections::HashMap;
+use std::time::Duration;
+
+use crate::log::elastic::ElasticLoggingConfig;
+use crate::prelude::DeploymentHash;
+
+use super::{LogEntry, LogMeta, LogQuery, LogStore, LogStoreError};
+
+pub struct ElasticsearchLogStore {
+    endpoint: String,
+    username: Option<String>,
+    password: Option<String>,
+    client: Client,
+    index: String,
+    timeout: Duration,
+    logger: Logger,
+}
+
+impl ElasticsearchLogStore {
+    pub fn new(config: ElasticLoggingConfig, index: String, timeout: Duration) -> Self {
+        Self {
+            logger: crate::log::logger(false),
+            endpoint: config.endpoint,
+            username: config.username,
+            password: config.password,
+            client: config.client,
+            index,
+            timeout,
+        }
+    }
+
+    fn build_query(&self, query: &LogQuery) -> serde_json::Value {
+        let mut must_clauses = Vec::new();
+
+        // Filter by subgraph ID
+        must_clauses.push(json!({
+            "term": {
+                "subgraphId": query.subgraph_id.to_string()
+            }
+        }));
+
+        // Filter by log level
+        if let Some(level) = &query.level {
+            must_clauses.push(json!({
+                "term": {
+                    "level": level.as_str().to_ascii_lowercase()
+                }
+            }));
+        }
+
+        // Filter by time range
+        if query.from.is_some() || query.to.is_some() {
+            let mut range = serde_json::Map::new();
+            if let Some(from) = &query.from {
+                range.insert("gte".to_string(), json!(from));
+            }
+            if let Some(to) = &query.to {
+                range.insert("lte".to_string(), json!(to));
+            }
+            must_clauses.push(json!({
+                "range": {
+                    "timestamp": range
+                }
+            }));
+        }
+
+        // Filter by text search
+        if let Some(search) = &query.search {
+            must_clauses.push(json!({
+                "match": {
+                    "text": search
+                }
+            }));
+        }
+
+        json!({
+            "query": {
+                "bool": {
+                    "must": must_clauses
+                }
+            },
+            "from": query.skip,
+            "size": query.first,
+            "sort": [
+                { "timestamp": { "order": query.order_direction.as_str() } }
+            ]
+        })
+    }
+
+    async fn execute_search(
+        &self,
+        query_body: serde_json::Value,
+    ) -> Result<Vec<LogEntry>, LogStoreError> {
+        let url = format!("{}/{}/_search", self.endpoint, self.index);
+
+        let mut request = self
+            .client
+            .post(&url)
+            .json(&query_body)
+            .timeout(self.timeout);
+
+        // Add basic auth if credentials provided
+        if let (Some(username), Some(password)) = (&self.username, &self.password) {
+            request = request.basic_auth(username, Some(password));
+        }
+
+        let response = request.send().await.map_err(|e| {
+            LogStoreError::QueryFailed(
+                anyhow::Error::from(e).context("Elasticsearch request failed"),
+            )
+        })?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            // Include response body in error context for debugging
+            // The body is part of the error chain but not the main error message to avoid
+            // leaking sensitive Elasticsearch internals in logs
+            let body_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "<failed to read response body>".to_string());
+            return Err(LogStoreError::QueryFailed(
+                anyhow::anyhow!("Elasticsearch query failed with status {}", status)
+                    .context(format!("Response body: {}", body_text)),
+            ));
+        }
+
+        let response_body: ElasticsearchResponse = response.json().await.map_err(|e| {
+            LogStoreError::QueryFailed(
+                anyhow::Error::from(e).context(
+                    "failed to parse Elasticsearch search response: response format may have changed or be invalid",
+                ),
+            )
+        })?;
+
+        let entries = response_body
+            .hits
+            .hits
+            .into_iter()
+            .filter_map(|hit| self.parse_log_entry(hit.source))
+            .collect();
+
+        Ok(entries)
+    }
+
+    fn parse_log_entry(&self, source: ElasticsearchLogDocument) -> Option<LogEntry> {
+        let level = match source.level.parse() {
+            Ok(l) => l,
+            Err(_) => {
+                warn!(self.logger, "Invalid log level in Elasticsearch entry"; "level" => &source.level);
+                return None;
+            }
+        };
+
+        let subgraph_id = match DeploymentHash::new(&source.subgraph_id) {
+            Ok(id) => id,
+            Err(_) => {
+                warn!(self.logger, "Invalid subgraph ID in Elasticsearch entry"; "subgraph_id" => &source.subgraph_id);
+                return None;
+            }
+        };
+
+        // Convert arguments HashMap to Vec<(String, String)>
+        let arguments: Vec<(String, String)> = source.arguments.into_iter().collect();
+
+        Some(LogEntry {
+            id: source.id,
+            subgraph_id,
+            timestamp: source.timestamp,
+            level,
+            text: source.text,
+            arguments,
+            meta: LogMeta {
+                module: source.meta.module,
+                line: source.meta.line,
+                column: source.meta.column,
+            },
+        })
+    }
+}
+
+#[async_trait]
+impl LogStore for ElasticsearchLogStore {
+    async fn query_logs(&self, query: LogQuery) -> Result<Vec<LogEntry>, LogStoreError> {
+        let query_body = self.build_query(&query);
+        self.execute_search(query_body).await
+    }
+
+    fn is_available(&self) -> bool {
+        true
+    }
+}
+
+// Elasticsearch response types
+#[derive(Debug, Deserialize)]
+struct ElasticsearchResponse {
+    hits: ElasticsearchHits,
+}
+
+#[derive(Debug, Deserialize)]
+struct ElasticsearchHits {
+    hits: Vec<ElasticsearchHit>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ElasticsearchHit {
+    #[serde(rename = "_source")]
+    source: ElasticsearchLogDocument,
+}
+
+#[derive(Debug, Deserialize)]
+struct ElasticsearchLogDocument {
+    id: String,
+    #[serde(rename = "subgraphId")]
+    subgraph_id: String,
+    timestamp: String,
+    level: String,
+    text: String,
+    arguments: HashMap<String, String>,
+    meta: ElasticsearchLogMeta,
+}
+
+#[derive(Debug, Deserialize)]
+struct ElasticsearchLogMeta {
+    module: String,
+    line: i64,
+    column: i64,
+}
diff --git a/graph/src/components/log_store/file.rs b/graph/src/components/log_store/file.rs
new file mode 100644
index 00000000000..55899dedd72
--- /dev/null
+++ b/graph/src/components/log_store/file.rs
@@ -0,0 +1,637 @@
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use slog::{Logger, warn};
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+use std::path::PathBuf;
+
+use crate::prelude::DeploymentHash;
+
+use super::{LogEntry, LogMeta, LogQuery, LogStore, LogStoreError};
+
+pub struct FileLogStore {
+    directory: PathBuf,
+    retention_hours: u32,
+    logger: Logger,
+}
+
+impl FileLogStore {
+    pub fn new(directory: PathBuf, retention_hours: u32) -> Result<Self, LogStoreError> {
+        // Create directory if it doesn't exist
+        std::fs::create_dir_all(&directory)
+            .map_err(|e| LogStoreError::InitializationFailed(e.into()))?;
+
+        let store = Self {
+            directory,
+            retention_hours,
+            logger: crate::log::logger(false),
+        };
+
+        // Run cleanup on startup for all existing log files
+        if retention_hours > 0
+            && let Ok(entries) = std::fs::read_dir(&store.directory)
+        {
+            for entry in entries.filter_map(Result::ok) {
+                let path = entry.path();
+
+                // Only process .jsonl files
+                if path.extension().and_then(|s| s.to_str()) == Some("jsonl") {
+                    // Run cleanup, but don't fail initialization if cleanup fails
+                    if let Err(e) = store.cleanup_old_logs(&path) {
+                        eprintln!("Warning: Failed to cleanup old logs for {:?}: {}", path, e);
+                    }
+                }
+            }
+        }
+
+        Ok(store)
+    }
+
+    /// Get log file path for a subgraph
+    fn log_file_path(&self, subgraph_id: &DeploymentHash) -> PathBuf {
+        self.directory.join(format!("{}.jsonl", subgraph_id))
+    }
+
+    /// Parse a JSON line into a LogEntry
+    fn parse_line(&self, line: &str) -> Option<LogEntry> {
+        let doc: FileLogDocument = match serde_json::from_str(line) {
+            Ok(doc) => doc,
+            Err(e) => {
+                warn!(self.logger, "Failed to parse log line"; "error" => e.to_string());
+                return None;
+            }
+        };
+
+        let level = match doc.level.parse() {
+            Ok(l) => l,
+            Err(_) => {
+                warn!(self.logger, "Invalid log level"; "level" => &doc.level);
+                return None;
+            }
+        };
+
+        let subgraph_id = match DeploymentHash::new(&doc.subgraph_id) {
+            Ok(id) => id,
+            Err(_) => {
+                warn!(self.logger, "Invalid subgraph ID"; "subgraph_id" => &doc.subgraph_id);
+                return None;
+            }
+        };
+
+        Some(LogEntry {
+            id: doc.id,
+            subgraph_id,
+            timestamp: doc.timestamp,
+            level,
+            text: doc.text,
+            arguments: doc.arguments,
+            meta: LogMeta {
+                module: doc.meta.module,
+                line: doc.meta.line,
+                column: doc.meta.column,
+            },
+        })
+    }
+
+    /// Check if an entry matches the query filters
+    fn matches_filters(&self, entry: &LogEntry, query: &LogQuery) -> bool {
+        // Level filter
+        if let Some(level) = query.level
+            && entry.level != level
+        {
+            return false;
+        }
+
+        // Time range filters
+        if let Some(ref from) = query.from
+            && entry.timestamp < *from
+        {
+            return false;
+        }
+
+        if let Some(ref to) = query.to
+            && entry.timestamp > *to
+        {
+            return false;
+        }
+
+        // Text search (case-insensitive)
+        if let Some(ref search) = query.search
+            && !entry.text.to_lowercase().contains(&search.to_lowercase())
+        {
+            return false;
+        }
+
+        true
+    }
+
+    /// Delete log entries older than retention_hours
+    fn cleanup_old_logs(&self, file_path: &std::path::Path) -> Result<(), LogStoreError> {
+        if self.retention_hours == 0 {
+            return Ok(()); // Cleanup disabled, keep all logs
+        }
+
+        use chrono::{DateTime, Duration, Utc};
+        use std::io::Write;
+
+        // Calculate cutoff time
+        let cutoff = Utc::now() - Duration::hours(self.retention_hours as i64);
+
+        // Read all log entries
+        let file = File::open(file_path).map_err(|e| LogStoreError::QueryFailed(e.into()))?;
+        let reader = BufReader::new(file);
+
+        let kept_entries: Vec<String> = reader
+            .lines()
+            .map_while(Result::ok)
+            .filter(|line| {
+                // Parse timestamp from log entry
+                if let Some(entry) = self.parse_line(line) {
+                    // Parse RFC3339 timestamp
+                    if let Ok(timestamp) = DateTime::parse_from_rfc3339(&entry.timestamp) {
+                        return timestamp.with_timezone(&Utc) >= cutoff;
+                    }
+                }
+                // Keep if we can't parse (don't delete on error)
+                true
+            })
+            .collect();
+
+        // Write filtered file atomically
+        let temp_path = file_path.with_extension("jsonl.tmp");
+        let mut temp_file =
+            File::create(&temp_path).map_err(|e| LogStoreError::QueryFailed(e.into()))?;
+
+        for entry in kept_entries {
+            writeln!(temp_file, "{}", entry).map_err(|e| LogStoreError::QueryFailed(e.into()))?;
+        }
+
+        temp_file
+            .sync_all()
+            .map_err(|e| LogStoreError::QueryFailed(e.into()))?;
+
+        // Atomic rename
+        std::fs::rename(&temp_path, file_path).map_err(|e| LogStoreError::QueryFailed(e.into()))?;
+
+        Ok(())
+    }
+}
+
+/// Helper struct to enable timestamp-based comparisons for BinaryHeap
+/// Implements Ord based on timestamp field for maintaining a min-heap of recent entries
+struct TimestampedEntry {
+    entry: LogEntry,
+}
+
+impl PartialEq for TimestampedEntry {
+    fn eq(&self, other: &Self) -> bool {
+        self.entry.timestamp == other.entry.timestamp
+    }
+}
+
+impl Eq for TimestampedEntry {}
+
+impl PartialOrd for TimestampedEntry {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for TimestampedEntry {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.entry.timestamp.cmp(&other.entry.timestamp)
+    }
+}
+
+#[async_trait]
+impl LogStore for FileLogStore {
+    async fn query_logs(&self, query: LogQuery) -> Result<Vec<LogEntry>, LogStoreError> {
+        let file_path = self.log_file_path(&query.subgraph_id);
+
+        if !file_path.exists() {
+            return Ok(vec![]);
+        }
+
+        let file = File::open(&file_path).map_err(|e| LogStoreError::QueryFailed(e.into()))?;
+        let reader = BufReader::new(file);
+
+        // Calculate how many entries we need to keep in memory
+        // We need skip + first entries to handle pagination
+        let needed_entries = (query.skip + query.first) as usize;
+
+        // Use a min-heap (via Reverse) to maintain only the top N most recent entries
+        // This bounds memory usage to O(skip + first) instead of O(total_log_entries)
+        let mut top_entries: BinaryHeap<Reverse<TimestampedEntry>> =
+            BinaryHeap::with_capacity(needed_entries + 1);
+
+        // Stream through the file line-by-line, applying filters and maintaining bounded collection
+        for line in reader.lines() {
+            // Skip malformed lines
+            let line = match line {
+                Ok(l) => l,
+                Err(_) => continue,
+            };
+
+            // Parse the line into a LogEntry
+            let entry = match self.parse_line(&line) {
+                Some(e) => e,
+                None => continue,
+            };
+
+            // Apply filters early to avoid keeping filtered-out entries in memory
+            if !self.matches_filters(&entry, &query) {
+                continue;
+            }
+
+            let timestamped = TimestampedEntry { entry };
+
+            // Maintain only the top N most recent entries by timestamp
+            // BinaryHeap with Reverse creates a min-heap, so we can efficiently
+            // keep the N largest (most recent) timestamps
+            if top_entries.len() < needed_entries {
+                top_entries.push(Reverse(timestamped));
+            } else if let Some(Reverse(oldest)) = top_entries.peek() {
+                // If this entry is more recent than the oldest in our heap, replace it
+                if timestamped.entry.timestamp > oldest.entry.timestamp {
+                    top_entries.pop();
+                    top_entries.push(Reverse(timestamped));
+                }
+            }
+        }
+
+        // Convert heap to sorted vector (most recent first)
+        let mut result: Vec<LogEntry> = top_entries
+            .into_iter()
+            .map(|Reverse(te)| te.entry)
+            .collect();
+
+        // Sort by timestamp (direction based on query)
+        match query.order_direction {
+            super::OrderDirection::Desc => result.sort_by(|a, b| b.timestamp.cmp(&a.timestamp)),
+            super::OrderDirection::Asc => result.sort_by(|a, b| a.timestamp.cmp(&b.timestamp)),
+        }
+
+        // Apply skip and take to get the final page
+        Ok(result
+            .into_iter()
+            .skip(query.skip as usize)
+            .take(query.first as usize)
+            .collect())
+    }
+
+    fn is_available(&self) -> bool {
+        self.directory.exists() && self.directory.is_dir()
+    }
+}
+
+// File log document format (JSON Lines)
+#[derive(Debug, Serialize, Deserialize)]
+struct FileLogDocument {
+    id: String,
+    #[serde(rename = "subgraphId")]
+    subgraph_id: String,
+    timestamp: String,
+    level: String,
+    text: String,
+    arguments: Vec<(String, String)>,
+    meta: FileLogMeta,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct FileLogMeta {
+    module: String,
+    line: i64,
+    column: i64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use slog::Level;
+    use std::io::Write;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_file_log_store_initialization() {
+        let temp_dir = TempDir::new().unwrap();
+        let store = FileLogStore::new(temp_dir.path().to_path_buf(), 0);
+        assert!(store.is_ok());
+
+        let store = store.unwrap();
+        assert!(store.is_available());
+    }
+
+    #[test]
+    fn test_log_file_path() {
+        let temp_dir = TempDir::new().unwrap();
+        let store = FileLogStore::new(temp_dir.path().to_path_buf(), 0).unwrap();
+
+        let subgraph_id = DeploymentHash::new("QmTest").unwrap();
+        let path = store.log_file_path(&subgraph_id);
+
+        assert_eq!(path, temp_dir.path().join("QmTest.jsonl"));
+    }
+
+    #[tokio::test]
+    async fn test_query_nonexistent_file() {
+        let temp_dir = TempDir::new().unwrap();
+        let store = FileLogStore::new(temp_dir.path().to_path_buf(), 0).unwrap();
+
+        let query = LogQuery {
+            subgraph_id: DeploymentHash::new("QmNonexistent").unwrap(),
+            level: None,
+            from: None,
+            to: None,
+            search: None,
+            first: 100,
+            skip: 0,
+            order_direction: super::super::OrderDirection::Desc,
+        };
+
+        let result = store.query_logs(query).await;
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap().len(), 0);
+    }
+
+    #[tokio::test]
+    async fn test_query_with_sample_data() {
+        let temp_dir = TempDir::new().unwrap();
+        let store = FileLogStore::new(temp_dir.path().to_path_buf(), 0).unwrap();
+
+        let subgraph_id = DeploymentHash::new("QmTest").unwrap();
+        let file_path = store.log_file_path(&subgraph_id);
+
+        // Write some test data
+        let mut file = File::create(&file_path).unwrap();
+        let log_entry = FileLogDocument {
+            id: "log-1".to_string(),
+            subgraph_id: "QmTest".to_string(),
+            timestamp: "2024-01-15T10:30:00Z".to_string(),
+            level: "error".to_string(),
+            text: "Test error message".to_string(),
+            arguments: vec![],
+            meta: FileLogMeta {
+                module: "test.ts".to_string(),
+                line: 42,
+                column: 10,
+            },
+        };
+        writeln!(file, "{}", serde_json::to_string(&log_entry).unwrap()).unwrap();
+
+        // Query
+        let query = LogQuery {
+            subgraph_id,
+            level: None,
+            from: None,
+            to: None,
+            search: None,
+            first: 100,
+            skip: 0,
+            order_direction: super::super::OrderDirection::Desc,
+        };
+
+        let result = store.query_logs(query).await;
+        assert!(result.is_ok());
+
+        let entries = result.unwrap();
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].id, "log-1");
+        assert_eq!(entries[0].text, "Test error message");
+        assert_eq!(entries[0].level, Level::Error);
+    }
+
+    #[tokio::test]
+    async fn test_query_with_level_filter() {
+        let temp_dir = TempDir::new().unwrap();
+        let store = FileLogStore::new(temp_dir.path().to_path_buf(), 0).unwrap();
+
+        let subgraph_id = DeploymentHash::new("QmTest").unwrap();
+        let file_path = store.log_file_path(&subgraph_id);
+
+        // Write test data with different levels
+        let mut file = File::create(&file_path).unwrap();
+        for (id, level) in [("log-1", "error"), ("log-2", "info"), ("log-3", "error")] {
+            let log_entry = FileLogDocument {
+                id: id.to_string(),
+                subgraph_id: "QmTest".to_string(),
+                timestamp: format!("2024-01-15T10:30:{}Z", id),
+                level: level.to_string(),
+                text: format!("Test {} message", level),
+                arguments: vec![],
+                meta: FileLogMeta {
+                    module: "test.ts".to_string(),
+                    line: 42,
+                    column: 10,
+                },
+            };
+            writeln!(file, "{}", serde_json::to_string(&log_entry).unwrap()).unwrap();
+        }
+
+        // Query for errors only
+        let query = LogQuery {
+            subgraph_id,
+            level: Some(Level::Error),
+            from: None,
+            to: None,
+            search: None,
+            first: 100,
+            skip: 0,
+            order_direction: super::super::OrderDirection::Desc,
+        };
+
+        let result = store.query_logs(query).await;
+        assert!(result.is_ok());
+
+        let entries = result.unwrap();
+        assert_eq!(entries.len(), 2);
+        assert!(entries.iter().all(|e| e.level == Level::Error));
+    }
+
+    #[tokio::test]
+    async fn test_cleanup_old_logs() {
+        use chrono::{Duration, Utc};
+
+        let temp_dir = TempDir::new().unwrap();
+        let store = FileLogStore::new(temp_dir.path().to_path_buf(), 24).unwrap();
+
+        let subgraph_id = DeploymentHash::new("QmTest").unwrap();
+        let file_path = store.log_file_path(&subgraph_id);
+
+        // Create test data with old and new entries
+        let mut file = File::create(&file_path).unwrap();
+
+        // Old entry (48 hours ago)
+        let old_timestamp =
+            (Utc::now() - Duration::hours(48)).to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
+        let old_entry = FileLogDocument {
+            id: "log-old".to_string(),
+            subgraph_id: "QmTest".to_string(),
+            timestamp: old_timestamp,
+            level: "info".to_string(),
+            text: "Old log entry".to_string(),
+            arguments: vec![],
+            meta: FileLogMeta {
+                module: "test.ts".to_string(),
+                line: 1,
+                column: 1,
+            },
+        };
+        writeln!(file, "{}", serde_json::to_string(&old_entry).unwrap()).unwrap();
+
+        // New entry (12 hours ago)
+        let new_timestamp =
+            (Utc::now() - Duration::hours(12)).to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
+        let new_entry = FileLogDocument {
+            id: "log-new".to_string(),
+            subgraph_id: "QmTest".to_string(),
+            timestamp: new_timestamp,
+            level: "info".to_string(),
+            text: "New log entry".to_string(),
+            arguments: vec![],
+            meta: FileLogMeta {
+                module: "test.ts".to_string(),
+                line: 2,
+                column: 1,
+            },
+        };
+        writeln!(file, "{}", serde_json::to_string(&new_entry).unwrap()).unwrap();
+        drop(file);
+
+        // Run cleanup
+        store.cleanup_old_logs(&file_path).unwrap();
+
+        // Query to verify only new entry remains
+        let query = LogQuery {
+            subgraph_id,
+            level: None,
+            from: None,
+            to: None,
+            search: None,
+            first: 100,
+            skip: 0,
+            order_direction: super::super::OrderDirection::Desc,
+        };
+
+        let result = store.query_logs(query).await.unwrap();
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].id, "log-new");
+    }
+
+    #[tokio::test]
+    async fn test_cleanup_keeps_unparseable_entries() {
+        let temp_dir = TempDir::new().unwrap();
+        let store = FileLogStore::new(temp_dir.path().to_path_buf(), 24).unwrap();
+
+        let subgraph_id = DeploymentHash::new("QmTest").unwrap();
+        let file_path = store.log_file_path(&subgraph_id);
+
+        // Create test data with valid and unparseable entries
+        let mut file = File::create(&file_path).unwrap();
+
+        // Valid entry
+        let valid_entry = FileLogDocument {
+            id: "log-valid".to_string(),
+            subgraph_id: "QmTest".to_string(),
+            timestamp: chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true),
+            level: "info".to_string(),
+            text: "Valid entry".to_string(),
+            arguments: vec![],
+            meta: FileLogMeta {
+                module: "test.ts".to_string(),
+                line: 1,
+                column: 1,
+            },
+        };
+        writeln!(file, "{}", serde_json::to_string(&valid_entry).unwrap()).unwrap();
+
+        // Unparseable entry (invalid JSON)
+        writeln!(file, "{{invalid json}}").unwrap();
+
+        // Entry with invalid timestamp
+        writeln!(
+            file,
+            r#"{{"id":"log-bad-time","subgraphId":"QmTest","timestamp":"not-a-timestamp","level":"info","text":"Bad timestamp","arguments":[],"meta":{{"module":"test.ts","line":2,"column":1}}}}"#
+        )
+        .unwrap();
+        drop(file);
+
+        // Run cleanup
+        store.cleanup_old_logs(&file_path).unwrap();
+
+        // Read file contents directly
+        let file_contents = std::fs::read_to_string(&file_path).unwrap();
+        let lines: Vec<&str> = file_contents.lines().collect();
+
+        // All 3 entries should be kept (don't delete on error)
+        assert_eq!(lines.len(), 3);
+    }
+
+    #[tokio::test]
+    async fn test_startup_cleanup() {
+        use chrono::{Duration, Utc};
+
+        let temp_dir = TempDir::new().unwrap();
+
+        // Create a log file with old entries before initializing the store
+        let file_path = temp_dir.path().join("QmTestStartup.jsonl");
+        let mut file = File::create(&file_path).unwrap();
+
+        // Old entry (48 hours ago)
+        let old_timestamp =
+            (Utc::now() - Duration::hours(48)).to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
+        let old_entry = FileLogDocument {
+            id: "log-old".to_string(),
+            subgraph_id: "QmTestStartup".to_string(),
+            timestamp: old_timestamp,
+            level: "info".to_string(),
+            text: "Old log entry".to_string(),
+            arguments: vec![],
+            meta: FileLogMeta {
+                module: "test.ts".to_string(),
+                line: 1,
+                column: 1,
+            },
+        };
+        writeln!(file, "{}", serde_json::to_string(&old_entry).unwrap()).unwrap();
+
+        // New entry (12 hours ago)
+        let new_timestamp =
+            (Utc::now() - Duration::hours(12)).to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
+        let new_entry = FileLogDocument {
+            id: "log-new".to_string(),
+            subgraph_id: "QmTestStartup".to_string(),
+            timestamp: new_timestamp,
+            level: "info".to_string(),
+            text: "New log entry".to_string(),
+            arguments: vec![],
+            meta: FileLogMeta {
+                module: "test.ts".to_string(),
+                line: 2,
+                column: 1,
+            },
+        };
+        writeln!(file, "{}", serde_json::to_string(&new_entry).unwrap()).unwrap();
+        drop(file);
+
+        // Initialize store with 24-hour retention - should cleanup on startup
+        let store = FileLogStore::new(temp_dir.path().to_path_buf(), 24).unwrap();
+
+        // Verify old entry was cleaned up
+        let query = LogQuery {
+            subgraph_id: DeploymentHash::new("QmTestStartup").unwrap(),
+            level: None,
+            from: None,
+            to: None,
+            search: None,
+            first: 100,
+            skip: 0,
+            order_direction: super::super::OrderDirection::Desc,
+        };
+
+        let result = store.query_logs(query).await.unwrap();
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].id, "log-new");
+    }
+}
diff --git a/graph/src/components/log_store/loki.rs b/graph/src/components/log_store/loki.rs
new file mode 100644
index 00000000000..562ef42feb6
--- /dev/null
+++ b/graph/src/components/log_store/loki.rs
@@ -0,0 +1,332 @@
+use async_trait::async_trait;
+use reqwest::Client;
+use serde::Deserialize;
+use slog::{Logger, warn};
+use std::collections::HashMap;
+use std::time::Duration;
+
+use crate::prelude::DeploymentHash;
+
+use super::{LogEntry, LogMeta, LogQuery, LogStore, LogStoreError};
+
+pub struct LokiLogStore {
+    endpoint: String,
+    tenant_id: Option<String>,
+    username: Option<String>,
+    password: Option<String>,
+    client: Client,
+    logger: Logger,
+}
+
+impl LokiLogStore {
+    pub fn new(
+        endpoint: String,
+        tenant_id: Option<String>,
+        username: Option<String>,
+        password: Option<String>,
+    ) -> Result<Self, LogStoreError> {
+        let client = Client::builder()
+            .timeout(Duration::from_secs(10))
+            .build()
+            .map_err(|e| LogStoreError::InitializationFailed(e.into()))?;
+
+        Ok(Self {
+            endpoint,
+            tenant_id,
+            username,
+            password,
+            client,
+            logger: crate::log::logger(false),
+        })
+    }
+
+    fn build_logql_query(&self, query: &LogQuery) -> String {
+        let mut selectors = vec![format!("subgraphId=\"{}\"", query.subgraph_id)];
+
+        // Add log level selector if specified
+        if let Some(level) = &query.level {
+            selectors.push(format!("level=\"{}\"", level.as_str().to_ascii_lowercase()));
+        }
+
+        // Base selector
+        let selector = format!("{{{}}}", selectors.join(","));
+
+        // Add line filter for text search if specified
+        if let Some(search) = &query.search {
+            format!("{} |~ \"(?i){}\"", selector, regex::escape(search))
+        } else {
+            selector
+        }
+    }
+
+    async fn execute_query(
+        &self,
+        query_str: &str,
+        from: &str,
+        to: &str,
+        limit: u32,
+        order_direction: super::OrderDirection,
+    ) -> Result<Vec<LogEntry>, LogStoreError> {
+        let url = format!("{}/loki/api/v1/query_range", self.endpoint);
+
+        // Map order direction to Loki's direction parameter
+        let direction = match order_direction {
+            super::OrderDirection::Desc => "backward", // Most recent first
+            super::OrderDirection::Asc => "forward",   // Oldest first
+        };
+
+        let mut request = self
+            .client
+            .get(&url)
+            .query(&[
+                ("query", query_str),
+                ("start", from),
+                ("end", to),
+                ("limit", &limit.to_string()),
+                ("direction", direction),
+            ])
+            .timeout(Duration::from_secs(10));
+
+        // Add X-Scope-OrgID header for multi-tenancy if configured
+        if let Some(tenant_id) = &self.tenant_id {
+            request = request.header("X-Scope-OrgID", tenant_id);
+        }
+
+        // Add basic auth if configured
+        if let Some(username) = &self.username {
+            request = request.basic_auth(username, self.password.as_ref());
+        }
+
+        let response = request.send().await.map_err(|e| {
+            LogStoreError::QueryFailed(anyhow::Error::from(e).context("Loki request failed"))
+        })?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            return Err(LogStoreError::QueryFailed(anyhow::anyhow!(
+                "Loki query failed with status {}",
+                status
+            )));
+        }
+
+        let response_body: LokiResponse = response.json().await.map_err(|e| {
+            LogStoreError::QueryFailed(
+                anyhow::Error::from(e)
+                    .context("failed to parse Loki response: response format may have changed"),
+            )
+        })?;
+
+        if response_body.status != "success" {
+            return Err(LogStoreError::QueryFailed(anyhow::anyhow!(
+                "Loki query failed with status: {}",
+                response_body.status
+            )));
+        }
+
+        // Parse results
+        let entries = response_body
+            .data
+            .result
+            .into_iter()
+            .flat_map(|stream| {
+                let stream_labels = stream.stream; // Take ownership
+                stream
+                    .values
+                    .into_iter()
+                    .filter_map(move |value| self.parse_log_entry(value, &stream_labels))
+            })
+            .collect();
+
+        Ok(entries)
+    }
+
+    fn parse_log_entry(
+        &self,
+        value: LokiValue,
+        _labels: &HashMap<String, String>,
+    ) -> Option<LogEntry> {
+        // value is [timestamp_ns, log_line]
+        // We expect the log line to be JSON with our log entry structure
+        let log_data: LokiLogDocument = match serde_json::from_str(&value.1) {
+            Ok(doc) => doc,
+            Err(e) => {
+                warn!(self.logger, "Failed to parse Loki log entry"; "error" => e.to_string());
+                return None;
+            }
+        };
+
+        let level = match log_data.level.parse() {
+            Ok(l) => l,
+            Err(_) => {
+                warn!(self.logger, "Invalid log level in Loki entry"; "level" => &log_data.level);
+                return None;
+            }
+        };
+
+        let subgraph_id = match DeploymentHash::new(&log_data.subgraph_id) {
+            Ok(id) => id,
+            Err(_) => {
+                warn!(self.logger, "Invalid subgraph ID in Loki entry"; "subgraph_id" => &log_data.subgraph_id);
+                return None;
+            }
+        };
+
+        Some(LogEntry {
+            id: log_data.id,
+            subgraph_id,
+            timestamp: log_data.timestamp,
+            level,
+            text: log_data.text,
+            arguments: log_data.arguments.into_iter().collect(),
+            meta: LogMeta {
+                module: log_data.meta.module,
+                line: log_data.meta.line,
+                column: log_data.meta.column,
+            },
+        })
+    }
+}
+
+#[async_trait]
+impl LogStore for LokiLogStore {
+    async fn query_logs(&self, query: LogQuery) -> Result<Vec<LogEntry>, LogStoreError> {
+        let logql_query = self.build_logql_query(&query);
+
+        // Calculate time range
+        let from = query.from.as_deref().unwrap_or("now-1h");
+        let to = query.to.as_deref().unwrap_or("now");
+
+        // Execute query with limit + skip to handle pagination
+        let limit = query.first + query.skip;
+
+        let mut entries = self
+            .execute_query(&logql_query, from, to, limit, query.order_direction)
+            .await?;
+
+        // Apply skip/first pagination
+        if query.skip > 0 {
+            entries = entries.into_iter().skip(query.skip as usize).collect();
+        }
+        entries.truncate(query.first as usize);
+
+        Ok(entries)
+    }
+
+    fn is_available(&self) -> bool {
+        true
+    }
+}
+
+// Loki response types
+#[derive(Debug, Deserialize)]
+struct LokiResponse {
+    status: String,
+    data: LokiData,
+}
+
+#[derive(Debug, Deserialize)]
+struct LokiData {
+    // Part of Loki API response, required for deserialization
+    #[allow(dead_code)]
+    #[serde(rename = "resultType")]
+    result_type: String,
+    result: Vec<LokiStream>,
+}
+
+#[derive(Debug, Deserialize)]
+struct LokiStream {
+    stream: HashMap<String, String>, // Labels
+    values: Vec<LokiValue>,
+}
+
+#[derive(Debug, Deserialize)]
+struct LokiValue(
+    // Timestamp in nanoseconds since epoch (part of Loki API, not currently used)
+    #[allow(dead_code)] String,
+    // Log line (JSON document)
+    String,
+);
+
+#[derive(Debug, Deserialize)]
+struct LokiLogDocument {
+    id: String,
+    #[serde(rename = "subgraphId")]
+    subgraph_id: String,
+    timestamp: String,
+    level: String,
+    text: String,
+    arguments: HashMap<String, String>,
+    meta: LokiLogMeta,
+}
+
+#[derive(Debug, Deserialize)]
+struct LokiLogMeta {
+    module: String,
+    line: i64,
+    column: i64,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use slog::Level;
+
+    #[test]
+    fn test_build_logql_query_basic() {
+        let store =
+            LokiLogStore::new("http://localhost:3100".to_string(), None, None, None).unwrap();
+        let query = LogQuery {
+            subgraph_id: DeploymentHash::new("QmTest").unwrap(),
+            level: None,
+            from: None,
+            to: None,
+            search: None,
+            first: 100,
+            skip: 0,
+            order_direction: crate::components::log_store::OrderDirection::Desc,
+        };
+
+        let logql = store.build_logql_query(&query);
+        assert_eq!(logql, "{subgraphId=\"QmTest\"}");
+    }
+
+    #[test]
+    fn test_build_logql_query_with_level() {
+        let store =
+            LokiLogStore::new("http://localhost:3100".to_string(), None, None, None).unwrap();
+        let query = LogQuery {
+            subgraph_id: DeploymentHash::new("QmTest").unwrap(),
+            level: Some(Level::Error),
+            from: None,
+            to: None,
+            search: None,
+            first: 100,
+            skip: 0,
+            order_direction: crate::components::log_store::OrderDirection::Desc,
+        };
+
+        let logql = store.build_logql_query(&query);
+        assert_eq!(logql, "{subgraphId=\"QmTest\",level=\"error\"}");
+    }
+
+    #[test]
+    fn test_build_logql_query_with_text_filter() {
+        let store =
+            LokiLogStore::new("http://localhost:3100".to_string(), None, None, None).unwrap();
+        let query = LogQuery {
+            subgraph_id: DeploymentHash::new("QmTest").unwrap(),
+            level: None,
+            from: None,
+            to: None,
+            search: Some("transaction failed".to_string()),
+            first: 100,
+            skip: 0,
+            order_direction: crate::components::log_store::OrderDirection::Desc,
+        };
+
+        let logql = store.build_logql_query(&query);
+        assert!(logql.contains("{subgraphId=\"QmTest\"}"));
+        assert!(logql.contains("|~"));
+        assert!(logql.contains("transaction failed"));
+    }
+}
diff --git a/graph/src/components/log_store/mod.rs b/graph/src/components/log_store/mod.rs
new file mode 100644
index 00000000000..a1db6b6aed5
--- /dev/null
+++ b/graph/src/components/log_store/mod.rs
@@ -0,0 +1,195 @@
+pub mod elasticsearch;
+pub mod file;
+pub mod loki;
+
+use async_trait::async_trait;
+use slog::Level;
+use std::fmt;
+use std::path::PathBuf;
+use std::str::FromStr;
+use std::sync::Arc;
+use thiserror::Error;
+
+use crate::prelude::DeploymentHash;
+
+#[derive(Error, Debug)]
+pub enum LogStoreError {
+    #[error("log store query failed: {0}")]
+    QueryFailed(#[from] anyhow::Error),
+
+    #[error("log store initialization failed: {0}")]
+    InitializationFailed(anyhow::Error),
+
+    #[error("log store configuration error: {0}")]
+    ConfigurationError(anyhow::Error),
+}
+
+/// Configuration for different log store backends
+#[derive(Debug, Clone)]
+pub enum LogStoreConfig {
+    /// No logging - returns empty results
+    Disabled,
+
+    /// Elasticsearch backend
+    Elasticsearch {
+        endpoint: String,
+        username: Option<String>,
+        password: Option<String>,
+        index: String,
+        timeout_secs: u64,
+    },
+
+    /// Loki (Grafana's log aggregation system)
+    Loki {
+        endpoint: String,
+        tenant_id: Option<String>,
+        username: Option<String>,
+        password: Option<String>,
+    },
+
+    /// File-based logs (JSON lines format)
+    File {
+        directory: PathBuf,
+        retention_hours: u32,
+    },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OrderDirection {
+    Asc,
+    Desc,
+}
+
+impl OrderDirection {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            OrderDirection::Asc => "asc",
+            OrderDirection::Desc => "desc",
+        }
+    }
+}
+
+impl FromStr for OrderDirection {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "asc" | "ascending" => Ok(OrderDirection::Asc),
+            "desc" | "descending" => Ok(OrderDirection::Desc),
+            _ => Err(format!("Invalid order direction: {}", s)),
+        }
+    }
+}
+
+impl fmt::Display for OrderDirection {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct LogMeta {
+    pub module: String,
+    pub line: i64,
+    pub column: i64,
+}
+
+#[derive(Debug, Clone)]
+pub struct LogEntry {
+    pub id: String,
+    pub subgraph_id: DeploymentHash,
+    pub timestamp: String,
+    pub level: Level,
+    pub text: String,
+    pub arguments: Vec<(String, String)>,
+    pub meta: LogMeta,
+}
+
+#[derive(Debug, Clone)]
+pub struct LogQuery {
+    pub subgraph_id: DeploymentHash,
+    pub level: Option<Level>,
+    pub from: Option<String>,
+    pub to: Option<String>,
+    pub search: Option<String>,
+    pub first: u32,
+    pub skip: u32,
+    pub order_direction: OrderDirection,
+}
+
+#[async_trait]
+pub trait LogStore: Send + Sync + 'static {
+    async fn query_logs(&self, query: LogQuery) -> Result<Vec<LogEntry>, LogStoreError>;
+    fn is_available(&self) -> bool;
+}
+
+/// Factory for creating LogStore instances from configuration
+pub struct LogStoreFactory;
+
+impl LogStoreFactory {
+    /// Create a LogStore from configuration
+    pub fn from_config(config: LogStoreConfig) -> Result<Arc<dyn LogStore>, LogStoreError> {
+        match config {
+            LogStoreConfig::Disabled => Ok(Arc::new(NoOpLogStore)),
+
+            LogStoreConfig::Elasticsearch {
+                endpoint,
+                username,
+                password,
+                index,
+                timeout_secs,
+            } => {
+                let timeout = std::time::Duration::from_secs(timeout_secs);
+                let client = reqwest::Client::builder()
+                    .timeout(timeout)
+                    .build()
+                    .map_err(|e| LogStoreError::InitializationFailed(e.into()))?;
+
+                let config = crate::log::elastic::ElasticLoggingConfig {
+                    endpoint,
+                    username,
+                    password,
+                    client,
+                };
+
+                Ok(Arc::new(elasticsearch::ElasticsearchLogStore::new(
+                    config, index, timeout,
+                )))
+            }
+
+            LogStoreConfig::Loki {
+                endpoint,
+                tenant_id,
+                username,
+                password,
+            } => Ok(Arc::new(loki::LokiLogStore::new(
+                endpoint, tenant_id, username, password,
+            )?)),
+
+            LogStoreConfig::File {
+                directory,
+                retention_hours,
+            } => Ok(Arc::new(file::FileLogStore::new(
+                directory,
+                retention_hours,
+            )?)),
+        }
+    }
+}
+
+/// A no-op LogStore that returns empty results.
+///
+/// Used when log storage is disabled (the default). Note that subgraph logs
+/// still appear in stdout/stderr - they're just not stored in a queryable format.
+pub struct NoOpLogStore;
+
+#[async_trait]
+impl LogStore for NoOpLogStore {
+    async fn query_logs(&self, _query: LogQuery) -> Result<Vec<LogEntry>, LogStoreError> {
+        Ok(vec![])
+    }
+
+    fn is_available(&self) -> bool {
+        false
+    }
+}
diff --git a/graph/src/components/metrics/block_state.rs b/graph/src/components/metrics/block_state.rs
new file mode 100644
index 00000000000..93c9f9a8302
--- /dev/null
+++ b/graph/src/components/metrics/block_state.rs
@@ -0,0 +1,238 @@
+use std::collections::HashMap;
+
+use anyhow::{Result, anyhow};
+use futures03::future::join_all;
+use object_store::{ObjectStoreExt as _, gcp::GoogleCloudStorageBuilder, path::Path};
+use serde::Serialize;
+use slog::{Logger, error, info};
+use url::Url;
+
+use crate::{
+    blockchain::BlockPtr,
+    components::store::{DeploymentId, Entity},
+    data::store::Id,
+    env::ENV_VARS,
+    runtime::gas::Gas,
+    schema::EntityType,
+    util::cache_weight::CacheWeight,
+};
+
+#[derive(Debug)]
+pub struct BlockStateMetrics {
+    pub gas_counter: HashMap<CounterKey, u64>,
+    pub op_counter: HashMap<CounterKey, u64>,
+    pub read_bytes_counter: HashMap<CounterKey, u64>,
+    pub write_bytes_counter: HashMap<CounterKey, u64>,
+}
+
+#[derive(Hash, PartialEq, Eq, Debug, Clone)]
+pub enum CounterKey {
+    Entity(EntityType, Id),
+    String(String),
+}
+
+impl From<&str> for CounterKey {
+    fn from(s: &str) -> Self {
+        Self::String(s.to_string())
+    }
+}
+
+impl Default for BlockStateMetrics {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl BlockStateMetrics {
+    pub fn new() -> Self {
+        BlockStateMetrics {
+            read_bytes_counter: HashMap::new(),
+            write_bytes_counter: HashMap::new(),
+            gas_counter: HashMap::new(),
+            op_counter: HashMap::new(),
+        }
+    }
+
+    pub fn extend(&mut self, other: BlockStateMetrics) {
+        for (key, value) in other.read_bytes_counter {
+            *self.read_bytes_counter.entry(key).or_insert(0) += value;
+        }
+
+        for (key, value) in other.write_bytes_counter {
+            *self.write_bytes_counter.entry(key).or_insert(0) += value;
+        }
+
+        for (key, value) in other.gas_counter {
+            *self.gas_counter.entry(key).or_insert(0) += value;
+        }
+
+        for (key, value) in other.op_counter {
+            *self.op_counter.entry(key).or_insert(0) += value;
+        }
+    }
+
+    fn serialize_to_csv<T: Serialize, U: Serialize, I: IntoIterator<Item = T>>(
+        data: I,
+        column_names: U,
+    ) -> Result<String> {
+        let mut wtr = csv::Writer::from_writer(vec![]);
+        wtr.serialize(column_names)?;
+        for record in data {
+            wtr.serialize(record)?;
+        }
+        wtr.flush()?;
+        Ok(String::from_utf8(wtr.into_inner()?)?)
+    }
+
+    pub fn counter_to_csv(
+        data: &HashMap<CounterKey, u64>,
+        column_names: Vec<&str>,
+    ) -> Result<String> {
+        Self::serialize_to_csv(
+            data.iter().map(|(key, value)| match key {
+                CounterKey::Entity(typename, id) => {
+                    vec![
+                        typename.typename().to_string(),
+                        id.to_string(),
+                        value.to_string(),
+                    ]
+                }
+                CounterKey::String(key) => vec![key.to_string(), value.to_string()],
+            }),
+            column_names,
+        )
+    }
+
+    async fn write_csv_to_store(bucket: &str, path: &str, data: String) -> Result<()> {
+        let data_bytes = data.into_bytes();
+
+        let bucket =
+            Url::parse(bucket).map_err(|e| anyhow!("Failed to parse bucket url: {}", e))?;
+        let store = GoogleCloudStorageBuilder::from_env()
+            .with_url(bucket)
+            .build()?;
+
+        store.put(&Path::parse(path)?, data_bytes.into()).await?;
+
+        Ok(())
+    }
+
+    pub fn track_gas_and_ops(&mut self, gas_used: Gas, method: &str) {
+        if ENV_VARS.enable_dips_metrics {
+            let key = CounterKey::from(method);
+            let counter = self.gas_counter.entry(key.clone()).or_insert(0);
+            *counter += gas_used.0;
+
+            let counter = self.op_counter.entry(key).or_insert(0);
+            *counter += 1;
+        }
+    }
+
+    pub fn track_entity_read(&mut self, entity_type: &EntityType, entity: &Entity) {
+        if ENV_VARS.enable_dips_metrics {
+            let key = CounterKey::Entity(entity_type.clone(), entity.id());
+            let counter = self.read_bytes_counter.entry(key).or_insert(0);
+            *counter += entity.weight() as u64;
+        }
+    }
+
+    pub fn track_entity_write(&mut self, entity_type: &EntityType, entity: &Entity) {
+        if ENV_VARS.enable_dips_metrics {
+            let key = CounterKey::Entity(entity_type.clone(), entity.id());
+            let counter = self.write_bytes_counter.entry(key).or_insert(0);
+            *counter += entity.weight() as u64;
+        }
+    }
+
+    pub fn track_entity_read_batch(&mut self, entity_type: &EntityType, entities: &[Entity]) {
+        if ENV_VARS.enable_dips_metrics {
+            for entity in entities {
+                let key = CounterKey::Entity(entity_type.clone(), entity.id());
+                let counter = self.read_bytes_counter.entry(key).or_insert(0);
+                *counter += entity.weight() as u64;
+            }
+        }
+    }
+
+    pub fn track_entity_write_batch(&mut self, entity_type: &EntityType, entities: &[Entity]) {
+        if ENV_VARS.enable_dips_metrics {
+            for entity in entities {
+                let key = CounterKey::Entity(entity_type.clone(), entity.id());
+                let counter = self.write_bytes_counter.entry(key).or_insert(0);
+                *counter += entity.weight() as u64;
+            }
+        }
+    }
+
+    pub fn flush_metrics_to_store(
+        &self,
+        logger: &Logger,
+        block_ptr: BlockPtr,
+        subgraph_id: DeploymentId,
+    ) -> Result<()> {
+        if !ENV_VARS.enable_dips_metrics {
+            return Ok(());
+        }
+
+        let logger = logger.clone();
+
+        let bucket = ENV_VARS
+            .dips_metrics_object_store_url
+            .as_deref()
+            .ok_or_else(|| anyhow!("Object store URL is not set"))?;
+
+        // Clone self and other necessary data for the async block
+        let gas_counter = self.gas_counter.clone();
+        let op_counter = self.op_counter.clone();
+        let read_bytes_counter = self.read_bytes_counter.clone();
+        let write_bytes_counter = self.write_bytes_counter.clone();
+
+        // Spawn the async task
+        crate::spawn(async move {
+            // Prepare data for uploading
+            let metrics_data = vec![
+                (
+                    "gas",
+                    Self::counter_to_csv(&gas_counter, vec!["method", "gas"]).unwrap(),
+                ),
+                (
+                    "op",
+                    Self::counter_to_csv(&op_counter, vec!["method", "count"]).unwrap(),
+                ),
+                (
+                    "read_bytes",
+                    Self::counter_to_csv(&read_bytes_counter, vec!["entity", "id", "bytes"])
+                        .unwrap(),
+                ),
+                (
+                    "write_bytes",
+                    Self::counter_to_csv(&write_bytes_counter, vec!["entity", "id", "bytes"])
+                        .unwrap(),
+                ),
+            ];
+
+            // Convert each metrics upload into a future
+            let upload_futures = metrics_data.into_iter().map(|(metric_name, data)| {
+                let file_path = format!("{}/{}/{}.csv", subgraph_id, block_ptr.number, metric_name);
+                let bucket_clone = bucket.to_string();
+                let logger_clone = logger.clone();
+                async move {
+                    match Self::write_csv_to_store(&bucket_clone, &file_path, data).await {
+                        Ok(_) => info!(
+                            logger_clone,
+                            "Uploaded {} metrics for block {}", metric_name, block_ptr.number
+                        ),
+                        Err(e) => error!(
+                            logger_clone,
+                            "Error uploading {} metrics: {}", metric_name, e
+                        ),
+                    }
+                }
+            });
+
+            join_all(upload_futures).await;
+        });
+
+        Ok(())
+    }
+}
diff --git a/graph/src/components/metrics/gas.rs b/graph/src/components/metrics/gas.rs
index 94bc8550949..120e90cb0dc 100644
--- a/graph/src/components/metrics/gas.rs
+++ b/graph/src/components/metrics/gas.rs
@@ -1,5 +1,5 @@
 use super::MetricsRegistry;
-use crate::prelude::DeploymentHash;
+use crate::{cheap_clone::CheapClone, prelude::DeploymentHash};
 use prometheus::CounterVec;
 use std::sync::Arc;
 
@@ -9,6 +9,15 @@ pub struct GasMetrics {
     pub op_counter: CounterVec,
 }
 
+impl CheapClone for GasMetrics {
+    fn cheap_clone(&self) -> Self {
+        Self {
+            gas_counter: self.gas_counter.clone(),
+            op_counter: self.op_counter.clone(),
+        }
+    }
+}
+
 impl GasMetrics {
     pub fn new(subgraph_id: DeploymentHash, registry: Arc<MetricsRegistry>) -> Self {
         let gas_counter = registry
diff --git a/graph/src/components/metrics/mod.rs b/graph/src/components/metrics/mod.rs
index 06aa540103e..f028c8aa515 100644
--- a/graph/src/components/metrics/mod.rs
+++ b/graph/src/components/metrics/mod.rs
@@ -1,7 +1,7 @@
 pub use prometheus::core::Collector;
 pub use prometheus::{
-    labels, Counter, CounterVec, Error as PrometheusError, Gauge, GaugeVec, Histogram,
-    HistogramOpts, HistogramVec, Opts, Registry,
+    Counter, CounterVec, Error as PrometheusError, Gauge, GaugeVec, Histogram, HistogramOpts,
+    HistogramVec, Opts, Registry, labels,
 };
 
 pub mod registry;
@@ -16,6 +16,8 @@ pub mod stopwatch;
 
 pub mod gas;
 
+pub mod block_state;
+
 /// Create an unregistered counter with labels
 pub fn counter_with_labels(
     name: &str,
diff --git a/graph/src/components/metrics/registry.rs b/graph/src/components/metrics/registry.rs
index 7fa5b903b05..5efb6564ef7 100644
--- a/graph/src/components/metrics/registry.rs
+++ b/graph/src/components/metrics/registry.rs
@@ -1,7 +1,11 @@
 use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 
-use prometheus::{labels, Histogram, IntCounterVec};
+use crate::parking_lot::RwLock;
+
+use prometheus::{Histogram, IntCounterVec, labels};
+use prometheus::{IntCounter, IntGauge};
+use slog::debug;
 
 use crate::components::metrics::{counter_with_labels, gauge_with_labels};
 use crate::prelude::Collector;
@@ -9,7 +13,7 @@ use crate::prometheus::{
     Counter, CounterVec, Error as PrometheusError, Gauge, GaugeVec, HistogramOpts, HistogramVec,
     Opts, Registry,
 };
-use crate::slog::{self, error, o, Logger};
+use crate::slog::{self, Logger, error, o};
 
 pub struct MetricsRegistry {
     logger: Logger,
@@ -107,65 +111,47 @@ impl MetricsRegistry {
         };
         let counters = CounterVec::new(opts, variable_labels)?;
         let id = counters.desc().first().unwrap().id;
-        let maybe_counter = self.global_counter_vecs.read().unwrap().get(&id).cloned();
+        let maybe_counter = self.global_counter_vecs.read().get(&id).cloned();
         if let Some(counters) = maybe_counter {
             Ok(counters)
         } else {
             self.register(name, Box::new(counters.clone()));
             self.global_counter_vecs
                 .write()
-                .unwrap()
                 .insert(id, counters.clone());
             Ok(counters)
         }
     }
 
-    pub fn register(&self, name: &str, c: Box<dyn Collector>) {
-        let err = match self.registry.register(c).err() {
-            None => {
+    /// Adds the metric to the registry.
+    ///
+    /// If the metric is a duplicate, it replaces a previous registration.
+    fn register<T>(&self, name: &str, collector: Box<T>)
+    where
+        T: Collector + Clone + 'static,
+    {
+        let logger = self.logger.new(o!("metric_name" => name.to_string()));
+        let mut result = self.registry.register(collector.clone());
+
+        if matches!(result, Err(PrometheusError::AlreadyReg)) {
+            debug!(logger, "Resolving duplicate metric registration");
+
+            // Since the current metric is a duplicate,
+            // we can use it to unregister the previous registration.
+            self.unregister(collector.clone());
+
+            result = self.registry.register(collector);
+        }
+
+        match result {
+            Ok(()) => {
                 self.registered_metrics.inc();
-                return;
             }
-            Some(err) => {
+            Err(err) => {
+                error!(logger, "Failed to register a new metric"; "error" => format!("{err:#}"));
                 self.register_errors.inc();
-                err
             }
-        };
-        match err {
-            PrometheusError::AlreadyReg => {
-                error!(
-                    self.logger,
-                    "registering metric [{}] failed because it was already registered", name,
-                );
-            }
-            PrometheusError::InconsistentCardinality { expect, got } => {
-                error!(
-                    self.logger,
-                    "registering metric [{}] failed due to inconsistent caridinality, expected = {} got = {}",
-                    name,
-                    expect,
-                    got,
-                );
-            }
-            PrometheusError::Msg(msg) => {
-                error!(
-                    self.logger,
-                    "registering metric [{}] failed because: {}", name, msg,
-                );
-            }
-            PrometheusError::Io(err) => {
-                error!(
-                    self.logger,
-                    "registering metric [{}] failed due to io error: {}", name, err,
-                );
-            }
-            PrometheusError::Protobuf(err) => {
-                error!(
-                    self.logger,
-                    "registering metric [{}] failed due to protobuf error: {}", name, err
-                );
-            }
-        };
+        }
     }
 
     pub fn global_counter(
@@ -176,15 +162,12 @@ impl MetricsRegistry {
     ) -> Result<Counter, PrometheusError> {
         let counter = counter_with_labels(name, help, const_labels)?;
         let id = counter.desc().first().unwrap().id;
-        let maybe_counter = self.global_counters.read().unwrap().get(&id).cloned();
+        let maybe_counter = self.global_counters.read().get(&id).cloned();
         if let Some(counter) = maybe_counter {
             Ok(counter)
         } else {
             self.register(name, Box::new(counter.clone()));
-            self.global_counters
-                .write()
-                .unwrap()
-                .insert(id, counter.clone());
+            self.global_counters.write().insert(id, counter.clone());
             Ok(counter)
         }
     }
@@ -225,15 +208,12 @@ impl MetricsRegistry {
     ) -> Result<Gauge, PrometheusError> {
         let gauge = gauge_with_labels(name, help, const_labels)?;
         let id = gauge.desc().first().unwrap().id;
-        let maybe_gauge = self.global_gauges.read().unwrap().get(&id).cloned();
+        let maybe_gauge = self.global_gauges.read().get(&id).cloned();
         if let Some(gauge) = maybe_gauge {
             Ok(gauge)
         } else {
             self.register(name, Box::new(gauge.clone()));
-            self.global_gauges
-                .write()
-                .unwrap()
-                .insert(id, gauge.clone());
+            self.global_gauges.write().insert(id, gauge.clone());
             Ok(gauge)
         }
     }
@@ -247,15 +227,12 @@ impl MetricsRegistry {
         let opts = Opts::new(name, help);
         let gauges = GaugeVec::new(opts, variable_labels)?;
         let id = gauges.desc().first().unwrap().id;
-        let maybe_gauge = self.global_gauge_vecs.read().unwrap().get(&id).cloned();
+        let maybe_gauge = self.global_gauge_vecs.read().get(&id).cloned();
         if let Some(gauges) = maybe_gauge {
             Ok(gauges)
         } else {
             self.register(name, Box::new(gauges.clone()));
-            self.global_gauge_vecs
-                .write()
-                .unwrap()
-                .insert(id, gauges.clone());
+            self.global_gauge_vecs.write().insert(id, gauges.clone());
             Ok(gauges)
         }
     }
@@ -269,14 +246,13 @@ impl MetricsRegistry {
         let opts = HistogramOpts::new(name, help);
         let histograms = HistogramVec::new(opts, variable_labels)?;
         let id = histograms.desc().first().unwrap().id;
-        let maybe_histogram = self.global_histogram_vecs.read().unwrap().get(&id).cloned();
+        let maybe_histogram = self.global_histogram_vecs.read().get(&id).cloned();
         if let Some(histograms) = maybe_histogram {
             Ok(histograms)
         } else {
             self.register(name, Box::new(histograms.clone()));
             self.global_histogram_vecs
                 .write()
-                .unwrap()
                 .insert(id, histograms.clone());
             Ok(histograms)
         }
@@ -364,6 +340,23 @@ impl MetricsRegistry {
         Ok(counter)
     }
 
+    pub fn new_int_counter(
+        &self,
+        name: impl AsRef<str>,
+        help: impl AsRef<str>,
+        const_labels: impl IntoIterator<Item = (impl ToString, impl ToString)>,
+    ) -> Result<IntCounter, PrometheusError> {
+        let opts = Opts::new(name.as_ref(), help.as_ref()).const_labels(
+            const_labels
+                .into_iter()
+                .map(|(key, value)| (key.to_string(), value.to_string()))
+                .collect(),
+        );
+        let int_counter = IntCounter::with_opts(opts)?;
+        self.register(name.as_ref(), Box::new(int_counter.clone()));
+        Ok(int_counter)
+    }
+
     pub fn new_counter_with_labels(
         &self,
         name: &str,
@@ -393,7 +386,7 @@ impl MetricsRegistry {
         variable_labels: &[&str],
     ) -> Result<Box<IntCounterVec>, PrometheusError> {
         let opts = Opts::new(name, help);
-        let counters = Box::new(IntCounterVec::new(opts, &variable_labels)?);
+        let counters = Box::new(IntCounterVec::new(opts, variable_labels)?);
         self.register(name, counters.clone());
         Ok(counters)
     }
@@ -510,6 +503,23 @@ impl MetricsRegistry {
         self.register(name, histograms.clone());
         Ok(histograms)
     }
+
+    pub fn new_int_gauge(
+        &self,
+        name: impl AsRef<str>,
+        help: impl AsRef<str>,
+        const_labels: impl IntoIterator<Item = (impl ToString, impl ToString)>,
+    ) -> Result<IntGauge, PrometheusError> {
+        let opts = Opts::new(name.as_ref(), help.as_ref()).const_labels(
+            const_labels
+                .into_iter()
+                .map(|(key, value)| (key.to_string(), value.to_string()))
+                .collect(),
+        );
+        let gauge = IntGauge::with_opts(opts)?;
+        self.register(name.as_ref(), Box::new(gauge.clone()));
+        Ok(gauge)
+    }
 }
 
 fn deployment_labels(subgraph: &str) -> HashMap<String, String> {
diff --git a/graph/src/components/metrics/stopwatch.rs b/graph/src/components/metrics/stopwatch.rs
index fabcd2d16d3..ce6ddfd0ff8 100644
--- a/graph/src/components/metrics/stopwatch.rs
+++ b/graph/src/components/metrics/stopwatch.rs
@@ -1,7 +1,9 @@
-use crate::prelude::*;
-use std::sync::{atomic::AtomicBool, atomic::Ordering, Mutex};
+use std::sync::{Mutex, atomic::AtomicBool, atomic::Ordering};
 use std::time::Instant;
 
+use crate::derive::CheapClone;
+use crate::prelude::*;
+
 /// This is a "section guard", that closes the section on drop.
 pub struct Section {
     id: String,
@@ -32,14 +34,12 @@ impl Drop for Section {
 /// // do stuff...
 /// // At the end of the scope `_main_section` is dropped, which is equivalent to calling
 /// // `_main_section.end()`.
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 pub struct StopwatchMetrics {
     disabled: Arc<AtomicBool>,
     inner: Arc<Mutex<StopwatchInner>>,
 }
 
-impl CheapClone for StopwatchMetrics {}
-
 impl StopwatchMetrics {
     pub fn new(
         logger: Logger,
@@ -150,6 +150,8 @@ impl StopwatchInner {
     }
 
     fn start_section(&mut self, id: String) {
+        #[cfg(debug_assertions)]
+        self.record_section_relation(&id);
         self.record_and_reset();
         self.section_stack.push(id);
     }
@@ -168,4 +170,69 @@ impl StopwatchInner {
                                         "received" => id),
         }
     }
+
+    /// In debug builds, allow recording the relation between sections to
+    /// build a tree of how sections are nested. The resulting JSON file can
+    /// be turned into a graph with Graphviz's `dot` command using this
+    /// shell script:
+    ///
+    /// ```sh
+    /// #! /bin/bash
+    ///
+    /// src=/tmp/sections.txt # GRAPH_SECTION_MAP
+    /// out=/tmp/sections.dot
+    ///
+    /// echo 'digraph { node [shape="box"];' > $out
+    /// jq -r '.[] | "\"\(.parent)[\(.stage)]\" -> \"\(.child)[\(.stage)]\";"' $src >> $out
+    /// echo "}" >> $out
+    ///
+    /// dot -Tpng -O $out
+    /// ```
+    #[cfg(debug_assertions)]
+    fn record_section_relation(&self, child: &str) {
+        use std::fs;
+        use std::fs::OpenOptions;
+
+        lazy_static! {
+            static ref FILE_LOCK: Mutex<()> = Mutex::new(());
+        }
+
+        #[derive(PartialEq, Serialize, Deserialize)]
+        struct Entry {
+            parent: String,
+            child: String,
+            stage: String,
+        }
+
+        if let Some(section_map) = &ENV_VARS.section_map {
+            let _guard = FILE_LOCK.lock().unwrap();
+            let prev = self
+                .section_stack
+                .last()
+                .map(|s| s.as_str())
+                .unwrap_or("none");
+
+            let mut entries: Vec<Entry> = match fs::read_to_string(section_map) {
+                Ok(existing) => serde_json::from_str(&existing).expect("can parse json"),
+                Err(_) => Vec::new(),
+            };
+            let new_entry = Entry {
+                parent: prev.to_string(),
+                child: child.to_string(),
+                stage: self.stage.to_string(),
+            };
+            if !entries.contains(&new_entry) {
+                entries.push(new_entry);
+            }
+            let file = OpenOptions::new()
+                .read(true)
+                .write(true)
+                .append(false)
+                .create(true)
+                .truncate(true)
+                .open(section_map)
+                .expect("can open file");
+            serde_json::to_writer(&file, &entries).expect("can write json");
+        }
+    }
 }
diff --git a/graph/src/components/metrics/subgraph.rs b/graph/src/components/metrics/subgraph.rs
index d9b68da8631..e45e7bd33a5 100644
--- a/graph/src/components/metrics/subgraph.rs
+++ b/graph/src/components/metrics/subgraph.rs
@@ -1,21 +1,26 @@
-use prometheus::Counter;
-
-use crate::blockchain::block_stream::BlockStreamMetrics;
-use crate::prelude::{Gauge, Histogram, HostMetrics};
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
 
-use super::stopwatch::StopwatchMetrics;
+use indoc::indoc;
+use prometheus::Counter;
+use prometheus::IntGauge;
+
 use super::MetricsRegistry;
+use super::stopwatch::StopwatchMetrics;
+use crate::blockchain::block_stream::BlockStreamMetrics;
+use crate::components::store::DeploymentLocator;
+use crate::prelude::{Gauge, Histogram, HostMetrics};
 
 pub struct SubgraphInstanceMetrics {
     pub block_trigger_count: Box<Histogram>,
     pub block_processing_duration: Box<Histogram>,
     pub block_ops_transaction_duration: Box<Histogram>,
     pub firehose_connection_errors: Counter,
-
     pub stopwatch: StopwatchMetrics,
+    pub deployment_status: DeploymentStatusMetric,
+    pub deployment_synced: DeploymentSyncedMetric,
+
     trigger_processing_duration: Box<Histogram>,
     blocks_processed_secs: Box<Counter>,
     blocks_processed_count: Box<Counter>,
@@ -26,6 +31,7 @@ impl SubgraphInstanceMetrics {
         registry: Arc<MetricsRegistry>,
         subgraph_hash: &str,
         stopwatch: StopwatchMetrics,
+        deployment_status: DeploymentStatusMetric,
     ) -> Self {
         let block_trigger_count = registry
             .new_deployment_histogram(
@@ -82,17 +88,23 @@ impl SubgraphInstanceMetrics {
         let blocks_processed_count = registry
             .new_counter_with_labels(
                 "deployment_blocks_processed_count",
-                "Measures the number of blocks processed",
+                "Tracks the total number of blocks processed by a deployment",
                 labels,
             )
             .expect("failed to create blocks_processed_count counter");
+
+        let deployment_synced =
+            DeploymentSyncedMetric::register(&registry, subgraph_hash, &stopwatch.shard());
+
         Self {
             block_trigger_count,
             block_processing_duration,
-            trigger_processing_duration,
             block_ops_transaction_duration,
             firehose_connection_errors,
             stopwatch,
+            deployment_status,
+            deployment_synced,
+            trigger_processing_duration,
             blocks_processed_secs,
             blocks_processed_count,
         }
@@ -114,6 +126,7 @@ impl SubgraphInstanceMetrics {
         registry.unregister(self.block_trigger_count.clone());
         registry.unregister(self.trigger_processing_duration.clone());
         registry.unregister(self.block_ops_transaction_duration.clone());
+        registry.unregister(Box::new(self.deployment_synced.inner.clone()));
     }
 }
 
@@ -154,3 +167,117 @@ pub struct RunnerMetrics {
     /// Sensors to measure the BlockStream metrics
     pub stream: Arc<BlockStreamMetrics>,
 }
+
+/// Reports the current indexing status of a deployment.
+#[derive(Clone)]
+pub struct DeploymentStatusMetric {
+    inner: IntGauge,
+}
+
+impl DeploymentStatusMetric {
+    const STATUS_STARTING: i64 = 1;
+    const STATUS_RUNNING: i64 = 2;
+    const STATUS_STOPPED: i64 = 3;
+    const STATUS_FAILED: i64 = 4;
+
+    /// Registers the metric.
+    pub fn register(registry: &MetricsRegistry, deployment: &DeploymentLocator) -> Self {
+        let deployment_status = registry
+            .new_int_gauge(
+                "deployment_status",
+                indoc!(
+                    "
+                    Indicates the current indexing status of a deployment.
+                    Possible values:
+                    1 - graph-node is preparing to start indexing;
+                    2 - deployment is being indexed;
+                    3 - indexing is stopped by request;
+                    4 - indexing failed;
+                    "
+                ),
+                [
+                    ("deployment", deployment.hash.as_str()),
+                    // TODO: Shard not available because this metric is initialized when there is no access to the writable store.
+                    ("shard", ""),
+                ],
+            )
+            .expect("failed to register `deployment_status` gauge");
+
+        Self {
+            inner: deployment_status,
+        }
+    }
+
+    /// Records that the graph-node is preparing to start indexing.
+    pub fn starting(&self) {
+        self.inner.set(Self::STATUS_STARTING);
+    }
+
+    /// Records that the deployment is being indexed.
+    pub fn running(&self) {
+        self.inner.set(Self::STATUS_RUNNING);
+    }
+
+    /// Records that the indexing is stopped by request.
+    pub fn stopped(&self) {
+        self.inner.set(Self::STATUS_STOPPED);
+    }
+
+    /// Records that the indexing failed.
+    pub fn failed(&self) {
+        self.inner.set(Self::STATUS_FAILED);
+    }
+}
+
+/// Indicates whether a deployment has reached the chain head since it was deployed.
+pub struct DeploymentSyncedMetric {
+    inner: IntGauge,
+
+    // If, for some reason, a deployment reports that it is synced, and then reports that it is not
+    // synced during an execution, this prevents the metric from reverting to the not synced state.
+    previously_synced: std::sync::OnceLock<()>,
+}
+
+impl DeploymentSyncedMetric {
+    const NOT_SYNCED: i64 = 0;
+    const SYNCED: i64 = 1;
+
+    /// Registers the metric.
+    pub fn register(registry: &MetricsRegistry, deployment_hash: &str, shard: &str) -> Self {
+        let metric = registry
+            .new_int_gauge(
+                "deployment_synced",
+                indoc!(
+                    "
+                    Indicates whether a deployment has reached the chain head or the end block since it was deployed.
+                    Possible values:
+                    0 - deployment is not synced;
+                    1 - deployment is synced;
+                    "
+                ),
+                [("deployment", deployment_hash), ("shard", shard)],
+            )
+            .expect("failed to register `deployment_synced` gauge");
+
+        Self {
+            inner: metric,
+            previously_synced: std::sync::OnceLock::new(),
+        }
+    }
+
+    /// Records the current sync status of the deployment.
+    /// Will ignore all values after the first `true` is received.
+    pub fn record(&self, synced: bool) {
+        if self.previously_synced.get().is_some() {
+            return;
+        }
+
+        if synced {
+            self.inner.set(Self::SYNCED);
+            let _ = self.previously_synced.set(());
+            return;
+        }
+
+        self.inner.set(Self::NOT_SYNCED);
+    }
+}
diff --git a/graph/src/components/mod.rs b/graph/src/components/mod.rs
index 79d698f8aa7..2dfc34f6373 100644
--- a/graph/src/components/mod.rs
+++ b/graph/src/components/mod.rs
@@ -33,7 +33,7 @@
 //! that define common operations on event streams, facilitating the
 //! configuration of component graphs.
 
-use futures::prelude::*;
+use futures01::{Sink, Stream};
 
 /// Components dealing with subgraphs.
 pub mod subgraph;
@@ -50,6 +50,9 @@ pub mod server;
 /// Components dealing with storing entities.
 pub mod store;
 
+/// Components dealing with log storage.
+pub mod log_store;
+
 pub mod link_resolver;
 
 pub mod trigger_processor;
@@ -78,4 +81,5 @@ pub trait EventProducer<E> {
     fn take_event_stream(&mut self) -> Option<Box<dyn Stream<Item = E, Error = ()> + Send>>;
 }
 
+pub mod network_provider;
 pub mod transaction_receipt;
diff --git a/graph/src/components/network_provider/chain_identifier_validator.rs b/graph/src/components/network_provider/chain_identifier_validator.rs
new file mode 100644
index 00000000000..8eabe44edc7
--- /dev/null
+++ b/graph/src/components/network_provider/chain_identifier_validator.rs
@@ -0,0 +1,129 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use thiserror::Error;
+
+use crate::blockchain::BlockHash;
+use crate::blockchain::ChainIdentifier;
+use crate::components::network_provider::ChainName;
+use crate::components::store::ChainIdStore;
+
+/// Additional requirements for stores that are necessary for provider checks.
+#[async_trait]
+pub trait ChainIdentifierValidator: Send + Sync + 'static {
+    /// Verifies that the chain identifier returned by the network provider
+    /// matches the previously stored value.
+    ///
+    /// Fails if the identifiers do not match or if something goes wrong.
+    async fn validate_identifier(
+        &self,
+        chain_name: &ChainName,
+        chain_identifier: &ChainIdentifier,
+    ) -> Result<(), ChainIdentifierValidationError>;
+
+    /// Saves the provided identifier that will be used as the source of truth
+    /// for future validations.
+    async fn update_identifier(
+        &self,
+        chain_name: &ChainName,
+        chain_identifier: &ChainIdentifier,
+    ) -> Result<(), ChainIdentifierValidationError>;
+}
+
+#[derive(Debug, Error)]
+pub enum ChainIdentifierValidationError {
+    #[error("identifier not set for chain '{0}'")]
+    IdentifierNotSet(ChainName),
+
+    #[error(
+        "net version mismatch on chain '{chain_name}'; expected '{store_net_version}', found '{chain_net_version}'"
+    )]
+    NetVersionMismatch {
+        chain_name: ChainName,
+        store_net_version: String,
+        chain_net_version: String,
+    },
+
+    #[error(
+        "genesis block hash mismatch on chain '{chain_name}'; expected '{store_genesis_block_hash}', found '{chain_genesis_block_hash}'"
+    )]
+    GenesisBlockHashMismatch {
+        chain_name: ChainName,
+        store_genesis_block_hash: BlockHash,
+        chain_genesis_block_hash: BlockHash,
+    },
+
+    #[error("store error: {0:#}")]
+    Store(#[source] anyhow::Error),
+}
+
+pub fn chain_id_validator(store: Box<dyn ChainIdStore>) -> Arc<dyn ChainIdentifierValidator> {
+    Arc::new(ChainIdentifierStore::new(store))
+}
+
+pub(crate) struct ChainIdentifierStore {
+    store: Box<dyn ChainIdStore>,
+}
+
+impl ChainIdentifierStore {
+    pub fn new(store: Box<dyn ChainIdStore>) -> Self {
+        Self { store }
+    }
+}
+
+#[async_trait]
+impl ChainIdentifierValidator for ChainIdentifierStore {
+    async fn validate_identifier(
+        &self,
+        chain_name: &ChainName,
+        chain_identifier: &ChainIdentifier,
+    ) -> Result<(), ChainIdentifierValidationError> {
+        let store_identifier = self
+            .store
+            .chain_identifier(chain_name)
+            .await
+            .map_err(ChainIdentifierValidationError::Store)?;
+
+        if store_identifier.is_default() {
+            return Err(ChainIdentifierValidationError::IdentifierNotSet(
+                chain_name.clone(),
+            ));
+        }
+
+        if store_identifier.net_version != chain_identifier.net_version {
+            // This behavior is carried over from the previous implementation.
+            // Firehose does not provide a `net_version`, so switching to and from Firehose will
+            // cause this value to be different. We prioritize RPC when creating the chain,
+            // but it's possible that it will be created by Firehose. Firehose always returns "0"
+            // for `net_version`, so we need to allow switching between the two.
+            if store_identifier.net_version != "0" && chain_identifier.net_version != "0" {
+                return Err(ChainIdentifierValidationError::NetVersionMismatch {
+                    chain_name: chain_name.clone(),
+                    store_net_version: store_identifier.net_version,
+                    chain_net_version: chain_identifier.net_version.clone(),
+                });
+            }
+        }
+
+        if store_identifier.genesis_block_hash != chain_identifier.genesis_block_hash {
+            return Err(ChainIdentifierValidationError::GenesisBlockHashMismatch {
+                chain_name: chain_name.clone(),
+                store_genesis_block_hash: store_identifier.genesis_block_hash,
+                chain_genesis_block_hash: chain_identifier.genesis_block_hash.clone(),
+            });
+        }
+
+        Ok(())
+    }
+
+    async fn update_identifier(
+        &self,
+        chain_name: &ChainName,
+        chain_identifier: &ChainIdentifier,
+    ) -> Result<(), ChainIdentifierValidationError> {
+        self.store
+            .set_chain_identifier(chain_name, chain_identifier)
+            .await
+            .map_err(ChainIdentifierValidationError::Store)
+    }
+}
diff --git a/graph/src/components/network_provider/extended_blocks_check.rs b/graph/src/components/network_provider/extended_blocks_check.rs
new file mode 100644
index 00000000000..a7ef879990d
--- /dev/null
+++ b/graph/src/components/network_provider/extended_blocks_check.rs
@@ -0,0 +1,236 @@
+use std::collections::HashSet;
+use std::time::Instant;
+
+use async_trait::async_trait;
+use slog::Logger;
+use slog::error;
+use slog::warn;
+
+use crate::components::network_provider::ChainName;
+use crate::components::network_provider::NetworkDetails;
+use crate::components::network_provider::ProviderCheck;
+use crate::components::network_provider::ProviderCheckStatus;
+use crate::components::network_provider::ProviderName;
+
+/// Requires providers to support extended block details.
+pub struct ExtendedBlocksCheck {
+    disabled_for_chains: HashSet<ChainName>,
+}
+
+impl ExtendedBlocksCheck {
+    pub fn new(disabled_for_chains: impl IntoIterator<Item = ChainName>) -> Self {
+        Self {
+            disabled_for_chains: disabled_for_chains.into_iter().collect(),
+        }
+    }
+}
+
+#[async_trait]
+impl ProviderCheck for ExtendedBlocksCheck {
+    fn name(&self) -> &'static str {
+        "ExtendedBlocksCheck"
+    }
+
+    async fn check(
+        &self,
+        logger: &Logger,
+        chain_name: &ChainName,
+        provider_name: &ProviderName,
+        adapter: &dyn NetworkDetails,
+    ) -> ProviderCheckStatus {
+        if self.disabled_for_chains.contains(chain_name) {
+            warn!(
+                logger,
+                "Extended blocks check for provider '{}' was disabled on chain '{}'",
+                provider_name,
+                chain_name,
+            );
+
+            return ProviderCheckStatus::Valid;
+        }
+
+        match adapter.provides_extended_blocks().await {
+            Ok(true) => ProviderCheckStatus::Valid,
+            Ok(false) => {
+                let message = format!(
+                    "Provider '{}' does not support extended blocks on chain '{}'",
+                    provider_name, chain_name,
+                );
+
+                error!(logger, "{}", message);
+
+                ProviderCheckStatus::Failed { message }
+            }
+            Err(err) => {
+                let message = format!(
+                    "Failed to check if provider '{}' supports extended blocks on chain '{}': {:#}",
+                    provider_name, chain_name, err,
+                );
+
+                error!(logger, "{}", message);
+
+                ProviderCheckStatus::TemporaryFailure {
+                    checked_at: Instant::now(),
+                    message,
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Mutex;
+
+    use anyhow::Result;
+    use anyhow::anyhow;
+
+    use super::*;
+    use crate::blockchain::ChainIdentifier;
+    use crate::log::discard;
+
+    #[derive(Default)]
+    struct TestAdapter {
+        provides_extended_blocks_calls: Mutex<Vec<Result<bool>>>,
+    }
+
+    impl TestAdapter {
+        fn provides_extended_blocks_call(&self, x: Result<bool>) {
+            self.provides_extended_blocks_calls.lock().unwrap().push(x)
+        }
+    }
+
+    impl Drop for TestAdapter {
+        fn drop(&mut self) {
+            assert!(
+                self.provides_extended_blocks_calls
+                    .lock()
+                    .unwrap()
+                    .is_empty()
+            );
+        }
+    }
+
+    #[async_trait]
+    impl NetworkDetails for TestAdapter {
+        fn provider_name(&self) -> ProviderName {
+            unimplemented!();
+        }
+
+        async fn chain_identifier(&self) -> Result<ChainIdentifier> {
+            unimplemented!();
+        }
+
+        async fn provides_extended_blocks(&self) -> Result<bool> {
+            self.provides_extended_blocks_calls
+                .lock()
+                .unwrap()
+                .remove(0)
+        }
+    }
+
+    #[crate::test]
+    async fn check_valid_when_disabled_for_chain() {
+        let check = ExtendedBlocksCheck::new(["chain-1".into()]);
+        let adapter = TestAdapter::default();
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert_eq!(status, ProviderCheckStatus::Valid);
+    }
+
+    #[crate::test]
+    async fn check_valid_when_disabled_for_multiple_chains() {
+        let check = ExtendedBlocksCheck::new(["chain-1".into(), "chain-2".into()]);
+        let adapter = TestAdapter::default();
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert_eq!(status, ProviderCheckStatus::Valid);
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-2".into()),
+                &("provider-2".into()),
+                &adapter,
+            )
+            .await;
+
+        assert_eq!(status, ProviderCheckStatus::Valid);
+    }
+
+    #[crate::test]
+    async fn check_valid_when_extended_blocks_are_supported() {
+        let check = ExtendedBlocksCheck::new([]);
+
+        let adapter = TestAdapter::default();
+        adapter.provides_extended_blocks_call(Ok(true));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert_eq!(status, ProviderCheckStatus::Valid);
+    }
+
+    #[crate::test]
+    async fn check_fails_when_extended_blocks_are_not_supported() {
+        let check = ExtendedBlocksCheck::new([]);
+
+        let adapter = TestAdapter::default();
+        adapter.provides_extended_blocks_call(Ok(false));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert!(matches!(status, ProviderCheckStatus::Failed { .. }));
+    }
+
+    #[crate::test]
+    async fn check_temporary_failure_when_provider_request_fails() {
+        let check = ExtendedBlocksCheck::new([]);
+
+        let adapter = TestAdapter::default();
+        adapter.provides_extended_blocks_call(Err(anyhow!("error")));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert!(matches!(
+            status,
+            ProviderCheckStatus::TemporaryFailure { .. }
+        ))
+    }
+}
diff --git a/graph/src/components/network_provider/genesis_hash_check.rs b/graph/src/components/network_provider/genesis_hash_check.rs
new file mode 100644
index 00000000000..50b895913c6
--- /dev/null
+++ b/graph/src/components/network_provider/genesis_hash_check.rs
@@ -0,0 +1,486 @@
+use std::sync::Arc;
+use std::time::Instant;
+
+use async_trait::async_trait;
+use slog::Logger;
+use slog::error;
+use slog::warn;
+
+use crate::components::network_provider::ChainIdentifierValidationError;
+use crate::components::network_provider::ChainIdentifierValidator;
+use crate::components::network_provider::ChainName;
+use crate::components::network_provider::NetworkDetails;
+use crate::components::network_provider::ProviderCheck;
+use crate::components::network_provider::ProviderCheckStatus;
+use crate::components::network_provider::ProviderName;
+use crate::components::network_provider::chain_id_validator;
+use crate::components::store::ChainIdStore;
+
+/// Requires providers to have the same network version and genesis hash as one
+/// previously stored in the database.
+pub struct GenesisHashCheck {
+    chain_identifier_store: Arc<dyn ChainIdentifierValidator>,
+}
+
+impl GenesisHashCheck {
+    pub fn new(chain_identifier_store: Arc<dyn ChainIdentifierValidator>) -> Self {
+        Self {
+            chain_identifier_store,
+        }
+    }
+
+    pub fn from_id_store(id_store: Box<dyn ChainIdStore>) -> Self {
+        Self {
+            chain_identifier_store: chain_id_validator(id_store),
+        }
+    }
+}
+
+#[async_trait]
+impl ProviderCheck for GenesisHashCheck {
+    fn name(&self) -> &'static str {
+        "GenesisHashCheck"
+    }
+
+    async fn check(
+        &self,
+        logger: &Logger,
+        chain_name: &ChainName,
+        provider_name: &ProviderName,
+        adapter: &dyn NetworkDetails,
+    ) -> ProviderCheckStatus {
+        let chain_identifier = match adapter.chain_identifier().await {
+            Ok(chain_identifier) => chain_identifier,
+            Err(err) => {
+                let message = format!(
+                    "Failed to get chain identifier from the provider '{}' on chain '{}': {:#}",
+                    provider_name, chain_name, err,
+                );
+
+                error!(logger, "{}", message);
+
+                return ProviderCheckStatus::TemporaryFailure {
+                    checked_at: Instant::now(),
+                    message,
+                };
+            }
+        };
+
+        let check_result = self
+            .chain_identifier_store
+            .validate_identifier(chain_name, &chain_identifier)
+            .await;
+
+        use ChainIdentifierValidationError::*;
+
+        match check_result {
+            Ok(()) => ProviderCheckStatus::Valid,
+            Err(IdentifierNotSet(_)) => {
+                let update_result = self
+                    .chain_identifier_store
+                    .update_identifier(chain_name, &chain_identifier)
+                    .await;
+
+                if let Err(err) = update_result {
+                    let message = format!(
+                        "Failed to store chain identifier for chain '{}' using provider '{}': {:#}",
+                        chain_name, provider_name, err,
+                    );
+
+                    error!(logger, "{}", message);
+
+                    return ProviderCheckStatus::TemporaryFailure {
+                        checked_at: Instant::now(),
+                        message,
+                    };
+                }
+
+                ProviderCheckStatus::Valid
+            }
+            Err(NetVersionMismatch {
+                store_net_version,
+                chain_net_version,
+                ..
+            }) if store_net_version == "0" => {
+                warn!(
+                    logger,
+                    "The net version for chain '{}' has changed from '0' to '{}' while using provider '{}'; \
+                     The difference is probably caused by Firehose, since it does not provide the net version, and the default value was stored",
+                    chain_name,
+                    chain_net_version,
+                    provider_name,
+                );
+
+                ProviderCheckStatus::Valid
+            }
+            Err(err @ NetVersionMismatch { .. }) => {
+                let message = format!(
+                    "Genesis hash validation failed on provider '{}': {:#}",
+                    provider_name, err,
+                );
+
+                error!(logger, "{}", message);
+
+                ProviderCheckStatus::Failed { message }
+            }
+            Err(err @ GenesisBlockHashMismatch { .. }) => {
+                let message = format!(
+                    "Genesis hash validation failed on provider '{}': {:#}",
+                    provider_name, err,
+                );
+
+                error!(logger, "{}", message);
+
+                ProviderCheckStatus::Failed { message }
+            }
+            Err(err @ Store(_)) => {
+                let message = format!(
+                    "Genesis hash validation failed on provider '{}': {:#}",
+                    provider_name, err,
+                );
+
+                error!(logger, "{}", message);
+
+                ProviderCheckStatus::TemporaryFailure {
+                    checked_at: Instant::now(),
+                    message,
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use std::sync::Mutex;
+
+    use anyhow::Result;
+    use anyhow::anyhow;
+
+    use super::*;
+    use crate::blockchain::ChainIdentifier;
+    use crate::log::discard;
+
+    #[derive(Default)]
+    struct TestChainIdentifierStore {
+        validate_identifier_calls: Mutex<Vec<Result<(), ChainIdentifierValidationError>>>,
+        update_identifier_calls: Mutex<Vec<Result<(), ChainIdentifierValidationError>>>,
+    }
+
+    impl TestChainIdentifierStore {
+        fn validate_identifier_call(&self, x: Result<(), ChainIdentifierValidationError>) {
+            self.validate_identifier_calls.lock().unwrap().push(x)
+        }
+
+        fn update_identifier_call(&self, x: Result<(), ChainIdentifierValidationError>) {
+            self.update_identifier_calls.lock().unwrap().push(x)
+        }
+    }
+
+    impl Drop for TestChainIdentifierStore {
+        fn drop(&mut self) {
+            let Self {
+                validate_identifier_calls,
+                update_identifier_calls,
+            } = self;
+
+            assert!(validate_identifier_calls.get_mut().unwrap().is_empty());
+            assert!(update_identifier_calls.get_mut().unwrap().is_empty());
+        }
+    }
+
+    #[async_trait]
+    impl ChainIdentifierValidator for TestChainIdentifierStore {
+        async fn validate_identifier(
+            &self,
+            _chain_name: &ChainName,
+            _chain_identifier: &ChainIdentifier,
+        ) -> Result<(), ChainIdentifierValidationError> {
+            self.validate_identifier_calls.lock().unwrap().remove(0)
+        }
+
+        async fn update_identifier(
+            &self,
+            _chain_name: &ChainName,
+            _chain_identifier: &ChainIdentifier,
+        ) -> Result<(), ChainIdentifierValidationError> {
+            self.update_identifier_calls.lock().unwrap().remove(0)
+        }
+    }
+
+    #[derive(Default)]
+    struct TestAdapter {
+        chain_identifier_calls: Mutex<Vec<Result<ChainIdentifier>>>,
+    }
+
+    impl TestAdapter {
+        fn chain_identifier_call(&self, x: Result<ChainIdentifier>) {
+            self.chain_identifier_calls.lock().unwrap().push(x)
+        }
+    }
+
+    impl Drop for TestAdapter {
+        fn drop(&mut self) {
+            let Self {
+                chain_identifier_calls,
+            } = self;
+
+            assert!(chain_identifier_calls.get_mut().unwrap().is_empty());
+        }
+    }
+
+    #[async_trait]
+    impl NetworkDetails for TestAdapter {
+        fn provider_name(&self) -> ProviderName {
+            unimplemented!();
+        }
+
+        async fn chain_identifier(&self) -> Result<ChainIdentifier> {
+            self.chain_identifier_calls.lock().unwrap().remove(0)
+        }
+
+        async fn provides_extended_blocks(&self) -> Result<bool> {
+            unimplemented!();
+        }
+    }
+
+    #[crate::test]
+    async fn check_temporary_failure_when_network_provider_request_fails() {
+        let store = Arc::new(TestChainIdentifierStore::default());
+        let check = GenesisHashCheck::new(store);
+
+        let adapter = TestAdapter::default();
+        adapter.chain_identifier_call(Err(anyhow!("error")));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert!(matches!(
+            status,
+            ProviderCheckStatus::TemporaryFailure { .. }
+        ));
+    }
+
+    #[crate::test]
+    async fn check_valid_when_store_successfully_validates_chain_identifier() {
+        let store = Arc::new(TestChainIdentifierStore::default());
+        store.validate_identifier_call(Ok(()));
+
+        let check = GenesisHashCheck::new(store);
+
+        let chain_identifier = ChainIdentifier {
+            net_version: "1".to_owned(),
+            genesis_block_hash: vec![1].into(),
+        };
+
+        let adapter = TestAdapter::default();
+        adapter.chain_identifier_call(Ok(chain_identifier));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert_eq!(status, ProviderCheckStatus::Valid);
+    }
+
+    #[crate::test]
+    async fn check_temporary_failure_on_initial_chain_identifier_update_error() {
+        let store = Arc::new(TestChainIdentifierStore::default());
+        store.validate_identifier_call(Err(ChainIdentifierValidationError::IdentifierNotSet(
+            "chain-1".into(),
+        )));
+        store.update_identifier_call(Err(ChainIdentifierValidationError::Store(anyhow!("error"))));
+
+        let check = GenesisHashCheck::new(store);
+
+        let chain_identifier = ChainIdentifier {
+            net_version: "1".to_owned(),
+            genesis_block_hash: vec![1].into(),
+        };
+
+        let adapter = TestAdapter::default();
+        adapter.chain_identifier_call(Ok(chain_identifier));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert!(matches!(
+            status,
+            ProviderCheckStatus::TemporaryFailure { .. }
+        ));
+    }
+
+    #[crate::test]
+    async fn check_valid_on_initial_chain_identifier_update() {
+        let store = Arc::new(TestChainIdentifierStore::default());
+        store.validate_identifier_call(Err(ChainIdentifierValidationError::IdentifierNotSet(
+            "chain-1".into(),
+        )));
+        store.update_identifier_call(Ok(()));
+
+        let check = GenesisHashCheck::new(store);
+
+        let chain_identifier = ChainIdentifier {
+            net_version: "1".to_owned(),
+            genesis_block_hash: vec![1].into(),
+        };
+
+        let adapter = TestAdapter::default();
+        adapter.chain_identifier_call(Ok(chain_identifier));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert_eq!(status, ProviderCheckStatus::Valid);
+    }
+
+    #[crate::test]
+    async fn check_valid_when_stored_identifier_network_version_is_zero() {
+        let store = Arc::new(TestChainIdentifierStore::default());
+        store.validate_identifier_call(Err(ChainIdentifierValidationError::NetVersionMismatch {
+            chain_name: "chain-1".into(),
+            store_net_version: "0".to_owned(),
+            chain_net_version: "1".to_owned(),
+        }));
+
+        let check = GenesisHashCheck::new(store);
+
+        let chain_identifier = ChainIdentifier {
+            net_version: "1".to_owned(),
+            genesis_block_hash: vec![1].into(),
+        };
+
+        let adapter = TestAdapter::default();
+        adapter.chain_identifier_call(Ok(chain_identifier));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert_eq!(status, ProviderCheckStatus::Valid);
+    }
+
+    #[crate::test]
+    async fn check_fails_on_identifier_network_version_mismatch() {
+        let store = Arc::new(TestChainIdentifierStore::default());
+        store.validate_identifier_call(Err(ChainIdentifierValidationError::NetVersionMismatch {
+            chain_name: "chain-1".into(),
+            store_net_version: "2".to_owned(),
+            chain_net_version: "1".to_owned(),
+        }));
+
+        let check = GenesisHashCheck::new(store);
+
+        let chain_identifier = ChainIdentifier {
+            net_version: "1".to_owned(),
+            genesis_block_hash: vec![1].into(),
+        };
+
+        let adapter = TestAdapter::default();
+        adapter.chain_identifier_call(Ok(chain_identifier));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert!(matches!(status, ProviderCheckStatus::Failed { .. }));
+    }
+
+    #[crate::test]
+    async fn check_fails_on_identifier_genesis_hash_mismatch() {
+        let store = Arc::new(TestChainIdentifierStore::default());
+        store.validate_identifier_call(Err(
+            ChainIdentifierValidationError::GenesisBlockHashMismatch {
+                chain_name: "chain-1".into(),
+                store_genesis_block_hash: vec![2].into(),
+                chain_genesis_block_hash: vec![1].into(),
+            },
+        ));
+
+        let check = GenesisHashCheck::new(store);
+
+        let chain_identifier = ChainIdentifier {
+            net_version: "1".to_owned(),
+            genesis_block_hash: vec![1].into(),
+        };
+
+        let adapter = TestAdapter::default();
+        adapter.chain_identifier_call(Ok(chain_identifier));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert!(matches!(status, ProviderCheckStatus::Failed { .. }));
+    }
+
+    #[crate::test]
+    async fn check_temporary_failure_on_store_errors() {
+        let store = Arc::new(TestChainIdentifierStore::default());
+        store
+            .validate_identifier_call(Err(ChainIdentifierValidationError::Store(anyhow!("error"))));
+
+        let check = GenesisHashCheck::new(store);
+
+        let chain_identifier = ChainIdentifier {
+            net_version: "1".to_owned(),
+            genesis_block_hash: vec![1].into(),
+        };
+
+        let adapter = TestAdapter::default();
+        adapter.chain_identifier_call(Ok(chain_identifier));
+
+        let status = check
+            .check(
+                &discard(),
+                &("chain-1".into()),
+                &("provider-1".into()),
+                &adapter,
+            )
+            .await;
+
+        assert!(matches!(
+            status,
+            ProviderCheckStatus::TemporaryFailure { .. }
+        ));
+    }
+}
diff --git a/graph/src/components/network_provider/mod.rs b/graph/src/components/network_provider/mod.rs
new file mode 100644
index 00000000000..e6b239360c5
--- /dev/null
+++ b/graph/src/components/network_provider/mod.rs
@@ -0,0 +1,75 @@
+mod chain_identifier_validator;
+mod extended_blocks_check;
+mod genesis_hash_check;
+mod network_details;
+mod provider_check;
+mod provider_manager;
+
+pub use self::chain_identifier_validator::ChainIdentifierValidationError;
+pub use self::chain_identifier_validator::ChainIdentifierValidator;
+pub use self::chain_identifier_validator::chain_id_validator;
+pub use self::extended_blocks_check::ExtendedBlocksCheck;
+pub use self::genesis_hash_check::GenesisHashCheck;
+pub use self::network_details::NetworkDetails;
+pub use self::provider_check::ProviderCheck;
+pub use self::provider_check::ProviderCheckStatus;
+pub use self::provider_manager::ProviderCheckStrategy;
+pub use self::provider_manager::ProviderManager;
+
+use std::collections::HashMap;
+
+// Used to increase memory efficiency.
+// Currently, there is no need to create a separate type for this.
+pub type ChainName = crate::data::value::Word;
+
+// Used to increase memory efficiency.
+// Currently, there is no need to create a separate type for this.
+pub type ProviderName = crate::data::value::Word;
+
+/// Maps AMP network names to internal graph-node chain names.
+///
+/// AMP-powered subgraphs may use different network names than graph-node
+/// (e.g., AMP uses `"ethereum-mainnet"` while graph-node uses `"mainnet"`).
+/// This type provides a config-driven translation layer.
+#[derive(Clone, Debug, Default)]
+pub struct AmpChainNames(HashMap<ChainName, ChainName>);
+
+impl AmpChainNames {
+    pub fn new(mapping: HashMap<ChainName, ChainName>) -> Self {
+        AmpChainNames(mapping)
+    }
+
+    /// Returns the internal chain name for an AMP alias, or the input
+    /// unchanged if no alias matches.
+    pub fn resolve(&self, name: &ChainName) -> ChainName {
+        self.0.get(name).cloned().unwrap_or_else(|| name.clone())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn amp_chain_names_resolve_known_alias() {
+        let mut map = HashMap::new();
+        map.insert(
+            ChainName::from("ethereum-mainnet"),
+            ChainName::from("mainnet"),
+        );
+        let names = AmpChainNames::new(map);
+        assert_eq!(
+            names.resolve(&ChainName::from("ethereum-mainnet")),
+            ChainName::from("mainnet")
+        );
+    }
+
+    #[test]
+    fn amp_chain_names_resolve_unknown_passthrough() {
+        let names = AmpChainNames::default();
+        assert_eq!(
+            names.resolve(&ChainName::from("mainnet")),
+            ChainName::from("mainnet")
+        );
+    }
+}
diff --git a/graph/src/components/network_provider/network_details.rs b/graph/src/components/network_provider/network_details.rs
new file mode 100644
index 00000000000..a9ec5c2b58d
--- /dev/null
+++ b/graph/src/components/network_provider/network_details.rs
@@ -0,0 +1,17 @@
+use anyhow::Result;
+use async_trait::async_trait;
+
+use crate::blockchain::ChainIdentifier;
+use crate::components::network_provider::ProviderName;
+
+/// Additional requirements for network providers that are necessary for provider checks.
+#[async_trait]
+pub trait NetworkDetails: Send + Sync + 'static {
+    fn provider_name(&self) -> ProviderName;
+
+    /// Returns the data that helps to uniquely identify a chain.
+    async fn chain_identifier(&self) -> Result<ChainIdentifier>;
+
+    /// Returns true if the provider supports extended block details.
+    async fn provides_extended_blocks(&self) -> Result<bool>;
+}
diff --git a/graph/src/components/network_provider/provider_check.rs b/graph/src/components/network_provider/provider_check.rs
new file mode 100644
index 00000000000..115782cceb2
--- /dev/null
+++ b/graph/src/components/network_provider/provider_check.rs
@@ -0,0 +1,44 @@
+use std::time::Instant;
+
+use async_trait::async_trait;
+use slog::Logger;
+
+use crate::components::network_provider::ChainName;
+use crate::components::network_provider::NetworkDetails;
+use crate::components::network_provider::ProviderName;
+
+#[async_trait]
+pub trait ProviderCheck: Send + Sync + 'static {
+    fn name(&self) -> &'static str;
+
+    async fn check(
+        &self,
+        logger: &Logger,
+        chain_name: &ChainName,
+        provider_name: &ProviderName,
+        adapter: &dyn NetworkDetails,
+    ) -> ProviderCheckStatus;
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ProviderCheckStatus {
+    NotChecked,
+    TemporaryFailure {
+        checked_at: Instant,
+        message: String,
+    },
+    Valid,
+    Failed {
+        message: String,
+    },
+}
+
+impl ProviderCheckStatus {
+    pub fn is_valid(&self) -> bool {
+        matches!(self, ProviderCheckStatus::Valid)
+    }
+
+    pub fn is_failed(&self) -> bool {
+        matches!(self, ProviderCheckStatus::Failed { .. })
+    }
+}
diff --git a/graph/src/components/network_provider/provider_manager.rs b/graph/src/components/network_provider/provider_manager.rs
new file mode 100644
index 00000000000..c94f71563ec
--- /dev/null
+++ b/graph/src/components/network_provider/provider_manager.rs
@@ -0,0 +1,965 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::sync::OnceLock;
+use std::time::Duration;
+
+use derive_more::Debug;
+use itertools::Itertools;
+use slog::Logger;
+use slog::info;
+use slog::warn;
+use thiserror::Error;
+use tokio::sync::RwLock;
+
+use crate::components::network_provider::ChainName;
+use crate::components::network_provider::NetworkDetails;
+use crate::components::network_provider::ProviderCheck;
+use crate::components::network_provider::ProviderCheckStatus;
+use crate::components::network_provider::ProviderName;
+
+/// The total time all providers have to perform all checks.
+const VALIDATION_MAX_DURATION: Duration = Duration::from_secs(30);
+
+/// Providers that failed validation with a temporary failure are re-validated at this interval.
+const VALIDATION_RETRY_INTERVAL: Duration = Duration::from_secs(300);
+
+/// ProviderManager is responsible for validating providers before they are returned to consumers.
+#[derive(Clone, Debug)]
+pub struct ProviderManager<T: NetworkDetails> {
+    #[debug(skip)]
+    inner: Arc<Inner<T>>,
+
+    validation_max_duration: Duration,
+    validation_retry_interval: Duration,
+}
+
+/// The strategy used by the [ProviderManager] when checking providers.
+#[derive(Clone)]
+pub enum ProviderCheckStrategy<'a> {
+    /// Marks a provider as valid without performing any checks on it.
+    MarkAsValid,
+
+    /// Requires a provider to pass all specified checks to be considered valid.
+    RequireAll(&'a [Arc<dyn ProviderCheck>]),
+}
+
+#[derive(Debug, Error)]
+pub enum ProviderManagerError {
+    #[error("provider validation timed out on chain '{0}'")]
+    ProviderValidationTimeout(ChainName),
+
+    #[error("no providers available for chain '{0}'")]
+    NoProvidersAvailable(ChainName),
+
+    #[error("all providers failed for chain '{0}'")]
+    AllProvidersFailed(ChainName),
+}
+
+struct Inner<T: NetworkDetails> {
+    logger: Logger,
+    adapters: HashMap<ChainName, Box<[Adapter<T>]>>,
+    validations: Box<[Validation]>,
+    enabled_checks: Box<[Arc<dyn ProviderCheck>]>,
+}
+
+struct Adapter<T: NetworkDetails> {
+    /// An index from the validations vector that is used to directly access the validation state
+    /// of the provider without additional checks or pointer dereferences.
+    ///
+    /// This is useful because the same provider can have multiple adapters to increase the number
+    /// of concurrent requests, but it does not make sense to perform multiple validations on
+    /// the same provider.
+    ///
+    /// It is guaranteed to be a valid index from the validations vector.
+    validation_index: usize,
+
+    inner: T,
+}
+
+/// Contains all the information needed to determine whether a provider is valid or not.
+struct Validation {
+    chain_name: ChainName,
+    provider_name: ProviderName,
+
+    /// Used to avoid acquiring the lock if possible.
+    ///
+    /// If it is not set, it means that validation is required.
+    /// If it is 'true', it means that the provider has passed all the checks.
+    /// If it is 'false', it means that the provider has failed at least one check.
+    is_valid: OnceLock<bool>,
+
+    /// Contains the statuses resulting from performing provider checks on the provider.
+    /// It is guaranteed to have the same number of elements as the number of checks enabled.
+    check_results: RwLock<Box<[ProviderCheckStatus]>>,
+}
+
+impl<T: NetworkDetails> ProviderManager<T> {
+    /// Creates a new provider manager for the specified providers.
+    ///
+    /// Performs enabled provider checks on each provider when it is accessed.
+    pub fn new(
+        logger: Logger,
+        adapters: impl IntoIterator<Item = (ChainName, Vec<T>)>,
+        strategy: ProviderCheckStrategy<'_>,
+    ) -> Self {
+        let enabled_checks = match strategy {
+            ProviderCheckStrategy::MarkAsValid => {
+                warn!(
+                    &logger,
+                    "No network provider checks enabled. \
+                     This can cause data inconsistency and many other issues."
+                );
+
+                &[]
+            }
+            ProviderCheckStrategy::RequireAll(checks) => {
+                info!(
+                    &logger,
+                    "All network providers have checks enabled. \
+                     To be considered valid they will have to pass the following checks: [{}]",
+                    checks.iter().map(|x| x.name()).join(",")
+                );
+
+                checks
+            }
+        };
+
+        let mut validations: Vec<Validation> = Vec::new();
+        let adapters = Self::adapters_by_chain_names(adapters, &mut validations, enabled_checks);
+
+        let inner = Inner {
+            logger,
+            adapters,
+            validations: validations.into(),
+            enabled_checks: enabled_checks.to_vec().into(),
+        };
+
+        Self {
+            inner: Arc::new(inner),
+            validation_max_duration: VALIDATION_MAX_DURATION,
+            validation_retry_interval: VALIDATION_RETRY_INTERVAL,
+        }
+    }
+
+    /// Returns the total number of providers available for the chain.
+    ///
+    /// Does not take provider validation status into account.
+    pub fn len(&self, chain_name: &ChainName) -> usize {
+        self.inner
+            .adapters
+            .get(chain_name)
+            .map(|adapter| adapter.len())
+            .unwrap_or_default()
+    }
+
+    /// Returns all available providers for the chain.
+    ///
+    /// Does not perform any provider validation and does not guarantee that providers will be
+    /// accessible or return the expected data.
+    pub fn providers_unchecked(&self, chain_name: &ChainName) -> impl Iterator<Item = &T> {
+        self.inner.adapters_unchecked(chain_name)
+    }
+
+    /// Returns all valid providers for the chain.
+    ///
+    /// Performs all enabled provider checks for each available provider for the chain.
+    /// A provider is considered valid if it successfully passes all checks.
+    ///
+    /// Note: Provider checks may take some time to complete.
+    pub async fn providers(
+        &self,
+        chain_name: &ChainName,
+    ) -> Result<impl Iterator<Item = &T>, ProviderManagerError> {
+        tokio::time::timeout(
+            self.validation_max_duration,
+            self.inner
+                .adapters(chain_name, self.validation_retry_interval),
+        )
+        .await
+        .map_err(|_| ProviderManagerError::ProviderValidationTimeout(chain_name.clone()))?
+    }
+
+    fn adapters_by_chain_names(
+        adapters: impl IntoIterator<Item = (ChainName, Vec<T>)>,
+        validations: &mut Vec<Validation>,
+        enabled_checks: &[Arc<dyn ProviderCheck>],
+    ) -> HashMap<ChainName, Box<[Adapter<T>]>> {
+        adapters
+            .into_iter()
+            .map(|(chain_name, adapters)| {
+                let adapters = adapters
+                    .into_iter()
+                    .map(|adapter| {
+                        let provider_name = adapter.provider_name();
+
+                        let validation_index = Self::get_or_init_validation_index(
+                            validations,
+                            enabled_checks,
+                            &chain_name,
+                            &provider_name,
+                        );
+
+                        Adapter {
+                            validation_index,
+                            inner: adapter,
+                        }
+                    })
+                    .collect_vec();
+
+                (chain_name, adapters.into())
+            })
+            .collect()
+    }
+
+    fn get_or_init_validation_index(
+        validations: &mut Vec<Validation>,
+        enabled_checks: &[Arc<dyn ProviderCheck>],
+        chain_name: &ChainName,
+        provider_name: &ProviderName,
+    ) -> usize {
+        validations
+            .iter()
+            .position(|validation| {
+                validation.chain_name == *chain_name && validation.provider_name == *provider_name
+            })
+            .unwrap_or_else(|| {
+                validations.push(Validation {
+                    chain_name: chain_name.clone(),
+                    provider_name: provider_name.clone(),
+                    is_valid: if enabled_checks.is_empty() {
+                        OnceLock::from(true)
+                    } else {
+                        OnceLock::new()
+                    },
+                    check_results: RwLock::new(
+                        vec![ProviderCheckStatus::NotChecked; enabled_checks.len()].into(),
+                    ),
+                });
+
+                validations.len() - 1
+            })
+    }
+}
+
+// Used to simplify some tests.
+impl<T: NetworkDetails> Default for ProviderManager<T> {
+    fn default() -> Self {
+        Self {
+            inner: Arc::new(Inner {
+                logger: crate::log::discard(),
+                adapters: HashMap::new(),
+                validations: vec![].into(),
+                enabled_checks: vec![].into(),
+            }),
+            validation_max_duration: VALIDATION_MAX_DURATION,
+            validation_retry_interval: VALIDATION_RETRY_INTERVAL,
+        }
+    }
+}
+
+impl<T: NetworkDetails> Inner<T> {
+    fn adapters_unchecked(&self, chain_name: &ChainName) -> impl Iterator<Item = &T> {
+        match self.adapters.get(chain_name) {
+            Some(adapters) => adapters.iter(),
+            None => [].iter(),
+        }
+        .map(|adapter| &adapter.inner)
+    }
+
+    async fn adapters(
+        &self,
+        chain_name: &ChainName,
+        validation_retry_interval: Duration,
+    ) -> Result<impl Iterator<Item = &T>, ProviderManagerError> {
+        use std::iter::once;
+
+        let (initial_size, adapters) = match self.adapters.get(chain_name) {
+            Some(adapters) => {
+                if !self.enabled_checks.is_empty() {
+                    self.validate_adapters(adapters, validation_retry_interval)
+                        .await;
+                }
+
+                (adapters.len(), adapters.iter())
+            }
+            None => (0, [].iter()),
+        };
+
+        let mut valid_adapters = adapters
+            .clone()
+            .filter(|adapter| {
+                self.validations[adapter.validation_index].is_valid.get() == Some(&true)
+            })
+            .map(|adapter| &adapter.inner);
+
+        // A thread-safe and fast way to check if an iterator has elements.
+        // Note: Using `.peekable()` is not thread safe.
+        if let first_valid_adapter @ Some(_) = valid_adapters.next() {
+            return Ok(once(first_valid_adapter).flatten().chain(valid_adapters));
+        }
+
+        // This is done to maintain backward compatibility with the previous implementation,
+        // and to avoid breaking modules that may rely on empty results in some cases.
+        if initial_size == 0 {
+            // Even though we know there are no adapters at this point,
+            // we still need to return the same type.
+            return Ok(once(None).flatten().chain(valid_adapters));
+        }
+
+        let failed_count = adapters
+            .filter(|adapter| {
+                self.validations[adapter.validation_index].is_valid.get() == Some(&false)
+            })
+            .count();
+
+        if failed_count == initial_size {
+            return Err(ProviderManagerError::AllProvidersFailed(chain_name.clone()));
+        }
+
+        Err(ProviderManagerError::NoProvidersAvailable(
+            chain_name.clone(),
+        ))
+    }
+
+    async fn validate_adapters(
+        &self,
+        adapters: &[Adapter<T>],
+        validation_retry_interval: Duration,
+    ) {
+        let validation_futs = adapters
+            .iter()
+            .filter(|adapter| {
+                self.validations[adapter.validation_index]
+                    .is_valid
+                    .get()
+                    .is_none()
+            })
+            .map(|adapter| self.validate_adapter(adapter, validation_retry_interval));
+
+        let _outputs: Vec<()> = crate::futures03::future::join_all(validation_futs).await;
+    }
+
+    async fn validate_adapter(&self, adapter: &Adapter<T>, validation_retry_interval: Duration) {
+        let validation = &self.validations[adapter.validation_index];
+
+        let chain_name = &validation.chain_name;
+        let provider_name = &validation.provider_name;
+        let mut check_results = validation.check_results.write().await;
+
+        // Make sure that when we get the lock, the adapter is still not validated.
+        if validation.is_valid.get().is_some() {
+            return;
+        }
+
+        for (i, check_result) in check_results.iter_mut().enumerate() {
+            use ProviderCheckStatus::*;
+
+            match check_result {
+                NotChecked => {
+                    // Check is required;
+                }
+                TemporaryFailure {
+                    checked_at,
+                    message: _,
+                } => {
+                    if checked_at.elapsed() < validation_retry_interval {
+                        continue;
+                    }
+
+                    // A new check is required;
+                }
+                Valid => continue,
+                Failed { message: _ } => continue,
+            }
+
+            *check_result = self.enabled_checks[i]
+                .check(&self.logger, chain_name, provider_name, &adapter.inner)
+                .await;
+
+            // One failure is enough to not even try to perform any further checks,
+            // because that adapter will never be considered valid.
+            if check_result.is_failed() {
+                validation.is_valid.get_or_init(|| false);
+                return;
+            }
+        }
+
+        if check_results.iter().all(|x| x.is_valid()) {
+            validation.is_valid.get_or_init(|| true);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Mutex;
+    use std::time::Instant;
+
+    use anyhow::Result;
+    use async_trait::async_trait;
+
+    use super::*;
+    use crate::blockchain::ChainIdentifier;
+    use crate::log::discard;
+
+    struct TestAdapter {
+        id: usize,
+        provider_name_calls: Mutex<Vec<ProviderName>>,
+    }
+
+    impl TestAdapter {
+        fn new(id: usize) -> Self {
+            Self {
+                id,
+                provider_name_calls: Default::default(),
+            }
+        }
+
+        fn provider_name_call(&self, x: ProviderName) {
+            self.provider_name_calls.lock().unwrap().push(x)
+        }
+    }
+
+    impl Drop for TestAdapter {
+        fn drop(&mut self) {
+            let Self {
+                id: _,
+                provider_name_calls,
+            } = self;
+
+            assert!(provider_name_calls.get_mut().unwrap().is_empty());
+        }
+    }
+
+    #[async_trait]
+    impl NetworkDetails for Arc<TestAdapter> {
+        fn provider_name(&self) -> ProviderName {
+            self.provider_name_calls.lock().unwrap().remove(0)
+        }
+
+        async fn chain_identifier(&self) -> Result<ChainIdentifier> {
+            unimplemented!();
+        }
+
+        async fn provides_extended_blocks(&self) -> Result<bool> {
+            unimplemented!();
+        }
+    }
+
+    #[derive(Default)]
+    struct TestProviderCheck {
+        check_calls: Mutex<Vec<Box<dyn FnOnce() -> ProviderCheckStatus + Send>>>,
+    }
+
+    impl TestProviderCheck {
+        fn check_call(&self, x: Box<dyn FnOnce() -> ProviderCheckStatus + Send>) {
+            self.check_calls.lock().unwrap().push(x)
+        }
+    }
+
+    impl Drop for TestProviderCheck {
+        fn drop(&mut self) {
+            assert!(self.check_calls.lock().unwrap().is_empty());
+        }
+    }
+
+    #[async_trait]
+    impl ProviderCheck for TestProviderCheck {
+        fn name(&self) -> &'static str {
+            "TestProviderCheck"
+        }
+
+        async fn check(
+            &self,
+            _logger: &Logger,
+            _chain_name: &ChainName,
+            _provider_name: &ProviderName,
+            _adapter: &dyn NetworkDetails,
+        ) -> ProviderCheckStatus {
+            self.check_calls.lock().unwrap().remove(0)()
+        }
+    }
+
+    fn chain_name() -> ChainName {
+        "test_chain".into()
+    }
+
+    fn other_chain_name() -> ChainName {
+        "other_chain".into()
+    }
+
+    fn ids<'a>(adapters: impl Iterator<Item = &'a Arc<TestAdapter>>) -> Vec<usize> {
+        adapters.map(|adapter| adapter.id).collect()
+    }
+
+    #[crate::test]
+    async fn no_providers() {
+        let manager: ProviderManager<Arc<TestAdapter>> =
+            ProviderManager::new(discard(), [], ProviderCheckStrategy::MarkAsValid);
+
+        assert_eq!(manager.len(&chain_name()), 0);
+        assert_eq!(manager.providers_unchecked(&chain_name()).count(), 0);
+        assert_eq!(manager.providers(&chain_name()).await.unwrap().count(), 0);
+    }
+
+    #[crate::test]
+    async fn no_providers_for_chain() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(other_chain_name(), vec![adapter_1.clone()])],
+            ProviderCheckStrategy::MarkAsValid,
+        );
+
+        assert_eq!(manager.len(&chain_name()), 0);
+        assert_eq!(manager.len(&other_chain_name()), 1);
+
+        assert_eq!(manager.providers_unchecked(&chain_name()).count(), 0);
+
+        assert_eq!(
+            ids(manager.providers_unchecked(&other_chain_name())),
+            vec![1],
+        );
+
+        assert_eq!(manager.providers(&chain_name()).await.unwrap().count(), 0);
+
+        assert_eq!(
+            ids(manager.providers(&other_chain_name()).await.unwrap()),
+            vec![1],
+        );
+    }
+
+    #[crate::test]
+    async fn multiple_providers() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let adapter_2 = Arc::new(TestAdapter::new(2));
+        adapter_2.provider_name_call("provider_2".into());
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone(), adapter_2.clone()])],
+            ProviderCheckStrategy::MarkAsValid,
+        );
+
+        assert_eq!(manager.len(&chain_name()), 2);
+
+        assert_eq!(ids(manager.providers_unchecked(&chain_name())), vec![1, 2]);
+
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1, 2],
+        );
+    }
+
+    #[crate::test]
+    async fn providers_unchecked_skips_provider_checks() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone()])],
+            #[allow(clippy::cloned_ref_to_slice_refs)]
+            ProviderCheckStrategy::RequireAll(&[check_1.clone()]),
+        );
+
+        assert_eq!(ids(manager.providers_unchecked(&chain_name())), vec![1]);
+    }
+
+    #[crate::test]
+    async fn successful_provider_check() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone()])],
+            #[allow(clippy::cloned_ref_to_slice_refs)]
+            ProviderCheckStrategy::RequireAll(&[check_1.clone()]),
+        );
+
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1]
+        );
+
+        // Another call will not trigger a new validation.
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1]
+        );
+    }
+
+    #[crate::test]
+    async fn multiple_successful_provider_checks() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let check_2 = Arc::new(TestProviderCheck::default());
+        check_2.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone()])],
+            ProviderCheckStrategy::RequireAll(&[check_1.clone(), check_2.clone()]),
+        );
+
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1]
+        );
+
+        // Another call will not trigger a new validation.
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1]
+        );
+    }
+
+    #[crate::test]
+    async fn multiple_successful_provider_checks_on_multiple_adapters() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let adapter_2 = Arc::new(TestAdapter::new(2));
+        adapter_2.provider_name_call("provider_2".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Valid));
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let check_2 = Arc::new(TestProviderCheck::default());
+        check_2.check_call(Box::new(|| ProviderCheckStatus::Valid));
+        check_2.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone(), adapter_2.clone()])],
+            ProviderCheckStrategy::RequireAll(&[check_1.clone(), check_2.clone()]),
+        );
+
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1, 2],
+        );
+
+        // Another call will not trigger a new validation.
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1, 2],
+        );
+    }
+
+    #[crate::test]
+    async fn successful_provider_check_for_a_pool_of_adapters_for_a_provider() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let adapter_2 = Arc::new(TestAdapter::new(2));
+        adapter_2.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone(), adapter_2.clone()])],
+            #[allow(clippy::cloned_ref_to_slice_refs)]
+            ProviderCheckStrategy::RequireAll(&[check_1.clone()]),
+        );
+
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1, 2],
+        );
+
+        // Another call will not trigger a new validation.
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1, 2],
+        );
+    }
+
+    #[crate::test]
+    async fn multiple_successful_provider_checks_for_a_pool_of_adapters_for_a_provider() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let adapter_2 = Arc::new(TestAdapter::new(2));
+        adapter_2.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let check_2 = Arc::new(TestProviderCheck::default());
+        check_2.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone(), adapter_2.clone()])],
+            ProviderCheckStrategy::RequireAll(&[check_1.clone(), check_2.clone()]),
+        );
+
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1, 2],
+        );
+
+        // Another call will not trigger a new validation.
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1, 2],
+        );
+    }
+
+    #[crate::test]
+    async fn provider_validation_timeout() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| {
+            std::thread::sleep(Duration::from_millis(200));
+            ProviderCheckStatus::Valid
+        }));
+
+        let mut manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone()])],
+            #[allow(clippy::cloned_ref_to_slice_refs)]
+            ProviderCheckStrategy::RequireAll(&[check_1.clone()]),
+        );
+
+        manager.validation_max_duration = Duration::from_millis(100);
+
+        match manager.providers(&chain_name()).await {
+            Ok(_) => {}
+            Err(err) => {
+                assert_eq!(
+                    err.to_string(),
+                    ProviderManagerError::ProviderValidationTimeout(chain_name()).to_string(),
+                );
+            }
+        };
+    }
+
+    #[crate::test]
+    async fn no_providers_available() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::TemporaryFailure {
+            checked_at: Instant::now(),
+            message: "error".to_owned(),
+        }));
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone()])],
+            #[allow(clippy::cloned_ref_to_slice_refs)]
+            ProviderCheckStrategy::RequireAll(&[check_1.clone()]),
+        );
+
+        match manager.providers(&chain_name()).await {
+            Ok(_) => {}
+            Err(err) => {
+                assert_eq!(
+                    err.to_string(),
+                    ProviderManagerError::NoProvidersAvailable(chain_name()).to_string(),
+                );
+            }
+        };
+    }
+
+    #[crate::test]
+    async fn all_providers_failed() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Failed {
+            message: "error".to_owned(),
+        }));
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone()])],
+            #[allow(clippy::cloned_ref_to_slice_refs)]
+            ProviderCheckStrategy::RequireAll(&[check_1.clone()]),
+        );
+
+        match manager.providers(&chain_name()).await {
+            Ok(_) => {}
+            Err(err) => {
+                assert_eq!(
+                    err.to_string(),
+                    ProviderManagerError::AllProvidersFailed(chain_name()).to_string(),
+                );
+            }
+        };
+    }
+
+    #[crate::test]
+    async fn temporary_provider_check_failures_are_retried() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::TemporaryFailure {
+            checked_at: Instant::now(),
+            message: "error".to_owned(),
+        }));
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let mut manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone()])],
+            #[allow(clippy::cloned_ref_to_slice_refs)]
+            ProviderCheckStrategy::RequireAll(&[check_1.clone()]),
+        );
+
+        manager.validation_retry_interval = Duration::from_millis(100);
+
+        assert!(manager.providers(&chain_name()).await.is_err());
+
+        tokio::time::sleep(Duration::from_millis(200)).await;
+
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1]
+        );
+    }
+
+    #[crate::test]
+    async fn final_provider_check_failures_are_not_retried() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Failed {
+            message: "error".to_owned(),
+        }));
+
+        let mut manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone()])],
+            #[allow(clippy::cloned_ref_to_slice_refs)]
+            ProviderCheckStrategy::RequireAll(&[check_1.clone()]),
+        );
+
+        manager.validation_retry_interval = Duration::from_millis(100);
+
+        assert!(manager.providers(&chain_name()).await.is_err());
+
+        tokio::time::sleep(Duration::from_millis(200)).await;
+
+        assert!(manager.providers(&chain_name()).await.is_err());
+    }
+
+    #[crate::test]
+    async fn mix_valid_and_invalid_providers() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let adapter_2 = Arc::new(TestAdapter::new(2));
+        adapter_2.provider_name_call("provider_2".into());
+
+        let adapter_3 = Arc::new(TestAdapter::new(3));
+        adapter_3.provider_name_call("provider_3".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Valid));
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Failed {
+            message: "error".to_owned(),
+        }));
+        check_1.check_call(Box::new(|| ProviderCheckStatus::TemporaryFailure {
+            checked_at: Instant::now(),
+            message: "error".to_owned(),
+        }));
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(
+                chain_name(),
+                vec![adapter_1.clone(), adapter_2.clone(), adapter_3.clone()],
+            )],
+            #[allow(clippy::cloned_ref_to_slice_refs)]
+            ProviderCheckStrategy::RequireAll(&[check_1.clone()]),
+        );
+
+        assert_eq!(
+            ids(manager.providers(&chain_name()).await.unwrap()),
+            vec![1]
+        );
+    }
+
+    #[crate::test]
+    async fn one_provider_check_failure_is_enough_to_mark_an_provider_as_invalid() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let check_2 = Arc::new(TestProviderCheck::default());
+        check_2.check_call(Box::new(|| ProviderCheckStatus::Failed {
+            message: "error".to_owned(),
+        }));
+
+        let check_3 = Arc::new(TestProviderCheck::default());
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone()])],
+            ProviderCheckStrategy::RequireAll(&[check_1.clone(), check_2.clone(), check_3.clone()]),
+        );
+
+        assert!(manager.providers(&chain_name()).await.is_err());
+    }
+
+    #[crate::test]
+    async fn concurrent_providers_access_does_not_trigger_multiple_validations() {
+        let adapter_1 = Arc::new(TestAdapter::new(1));
+        adapter_1.provider_name_call("provider_1".into());
+
+        let check_1 = Arc::new(TestProviderCheck::default());
+        check_1.check_call(Box::new(|| ProviderCheckStatus::Valid));
+
+        let manager: ProviderManager<Arc<TestAdapter>> = ProviderManager::new(
+            discard(),
+            [(chain_name(), vec![adapter_1.clone()])],
+            #[allow(clippy::cloned_ref_to_slice_refs)]
+            ProviderCheckStrategy::RequireAll(&[check_1.clone()]),
+        );
+
+        let fut = || {
+            let manager = manager.clone();
+
+            async move {
+                let chain_name = chain_name();
+
+                ids(manager.providers(&chain_name).await.unwrap())
+            }
+        };
+
+        let results = crate::futures03::future::join_all([fut(), fut(), fut(), fut()]).await;
+
+        assert_eq!(
+            results.into_iter().flatten().collect_vec(),
+            vec![1, 1, 1, 1],
+        );
+    }
+}
diff --git a/graph/src/components/server/index_node.rs b/graph/src/components/server/index_node.rs
index 56fd8f0fd71..e8f6fa1eacb 100644
--- a/graph/src/components/server/index_node.rs
+++ b/graph/src/components/server/index_node.rs
@@ -1,5 +1,3 @@
-use futures::prelude::*;
-
 use crate::{prelude::BlockNumber, schema::InputSchema};
 
 /// This is only needed to support the explorer API.
@@ -16,14 +14,3 @@ pub struct VersionInfo {
     pub schema: InputSchema,
     pub network: String,
 }
-
-/// Common trait for index node server implementations.
-pub trait IndexNodeServer {
-    type ServeError;
-
-    /// Creates a new Tokio task that, when spawned, brings up the index node server.
-    fn serve(
-        &mut self,
-        port: u16,
-    ) -> Result<Box<dyn Future<Item = (), Error = ()> + Send>, Self::ServeError>;
-}
diff --git a/graph/src/components/server/mod.rs b/graph/src/components/server/mod.rs
index da2b4d47b76..a2dbcadb65f 100644
--- a/graph/src/components/server/mod.rs
+++ b/graph/src/components/server/mod.rs
@@ -1,8 +1,8 @@
 /// Component for running GraphQL queries over HTTP.
 pub mod query;
 
-/// Component for running GraphQL subscriptions over WebSockets.
-pub mod subscription;
-
 /// Component for the index node server.
 pub mod index_node;
+
+#[allow(clippy::module_inception)]
+pub mod server;
diff --git a/graph/src/components/server/query.rs b/graph/src/components/server/query.rs
index 9fca8ea25c7..d20a7dcb6c0 100644
--- a/graph/src/components/server/query.rs
+++ b/graph/src/components/server/query.rs
@@ -1,71 +1,65 @@
+use http_body_util::Full;
+use hyper::Response;
+use hyper::body::Bytes;
+
 use crate::data::query::QueryError;
-use futures::prelude::*;
 use std::error::Error;
 use std::fmt;
 
 use crate::components::store::StoreError;
 
+pub type ServerResponse = Response<Full<Bytes>>;
+pub type ServerResult = Result<ServerResponse, ServerError>;
+
 /// Errors that can occur while processing incoming requests.
 #[derive(Debug)]
-pub enum GraphQLServerError {
+pub enum ServerError {
     ClientError(String),
     QueryError(QueryError),
     InternalError(String),
 }
 
-impl From<QueryError> for GraphQLServerError {
+impl From<QueryError> for ServerError {
     fn from(e: QueryError) -> Self {
-        GraphQLServerError::QueryError(e)
+        ServerError::QueryError(e)
     }
 }
 
-impl From<StoreError> for GraphQLServerError {
+impl From<StoreError> for ServerError {
     fn from(e: StoreError) -> Self {
         match e {
-            StoreError::ConstraintViolation(s) => GraphQLServerError::InternalError(s),
-            _ => GraphQLServerError::ClientError(e.to_string()),
+            StoreError::InternalError(s) => ServerError::InternalError(s),
+            _ => ServerError::ClientError(e.to_string()),
         }
     }
 }
 
-impl fmt::Display for GraphQLServerError {
+impl fmt::Display for ServerError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            GraphQLServerError::ClientError(ref s) => {
+            ServerError::ClientError(ref s) => {
                 write!(f, "GraphQL server error (client error): {}", s)
             }
-            GraphQLServerError::QueryError(ref e) => {
+            ServerError::QueryError(ref e) => {
                 write!(f, "GraphQL server error (query error): {}", e)
             }
-            GraphQLServerError::InternalError(ref s) => {
+            ServerError::InternalError(ref s) => {
                 write!(f, "GraphQL server error (internal error): {}", s)
             }
         }
     }
 }
 
-impl Error for GraphQLServerError {
+impl Error for ServerError {
     fn description(&self) -> &str {
         "Failed to process the GraphQL request"
     }
 
     fn cause(&self) -> Option<&dyn Error> {
         match *self {
-            GraphQLServerError::ClientError(_) => None,
-            GraphQLServerError::QueryError(ref e) => Some(e),
-            GraphQLServerError::InternalError(_) => None,
+            ServerError::ClientError(_) => None,
+            ServerError::QueryError(ref e) => Some(e),
+            ServerError::InternalError(_) => None,
         }
     }
 }
-
-/// Common trait for GraphQL server implementations.
-pub trait GraphQLServer {
-    type ServeError;
-
-    /// Creates a new Tokio task that, when spawned, brings up the GraphQL server.
-    fn serve(
-        &mut self,
-        port: u16,
-        ws_port: u16,
-    ) -> Result<Box<dyn Future<Item = (), Error = ()> + Send>, Self::ServeError>;
-}
diff --git a/graph/src/components/server/server.rs b/graph/src/components/server/server.rs
new file mode 100644
index 00000000000..e17e4d5897a
--- /dev/null
+++ b/graph/src/components/server/server.rs
@@ -0,0 +1,70 @@
+use std::future::Future;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+
+use hyper::Request;
+use hyper::body::Incoming;
+use tokio::net::TcpListener;
+use tokio::task::JoinHandle;
+
+use crate::anyhow;
+use crate::cheap_clone::CheapClone;
+use crate::hyper::server::conn::http1;
+use crate::hyper::service::service_fn;
+use crate::hyper_util::rt::TokioIo;
+use crate::slog::error;
+
+use crate::prelude::Logger;
+
+use super::query::ServerResult;
+
+/// A handle to the server that can be used to shut it down. The `accepting`
+/// field is only used in tests to check if the server is running
+pub struct ServerHandle {
+    pub handle: JoinHandle<()>,
+    pub accepting: Arc<AtomicBool>,
+}
+
+pub async fn start<F, S>(
+    logger: Logger,
+    port: u16,
+    handler: F,
+) -> Result<ServerHandle, anyhow::Error>
+where
+    F: Fn(Request<Incoming>) -> S + Send + Clone + 'static,
+    S: Future<Output = ServerResult> + Send + 'static,
+{
+    let addr = SocketAddr::from(([0, 0, 0, 0], port));
+    let listener = TcpListener::bind(addr).await?;
+    let accepting = Arc::new(AtomicBool::new(false));
+    let accepting2 = accepting.cheap_clone();
+    let handle = crate::spawn(async move {
+        accepting2.store(true, std::sync::atomic::Ordering::SeqCst);
+        loop {
+            let (stream, _) = match listener.accept().await {
+                Ok(res) => res,
+                Err(e) => {
+                    error!(logger, "Error accepting connection"; "error" => e.to_string());
+                    continue;
+                }
+            };
+
+            // Use an adapter to access something implementing `tokio::io` traits as if they implement
+            // `hyper::rt` IO traits.
+            let io = TokioIo::new(stream);
+
+            let handler = handler.clone();
+            // Spawn a tokio task to serve multiple connections concurrently
+            tokio::task::spawn(async move {
+                let new_service = service_fn(handler);
+                // Finally, we bind the incoming connection to our `hello` service
+                http1::Builder::new()
+                    // `service_fn` converts our function in a `Service`
+                    .serve_connection(io, new_service)
+                    .await
+            });
+        }
+    });
+    Ok(ServerHandle { handle, accepting })
+}
diff --git a/graph/src/components/server/subscription.rs b/graph/src/components/server/subscription.rs
deleted file mode 100644
index dae619356b6..00000000000
--- a/graph/src/components/server/subscription.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-use async_trait::async_trait;
-
-/// Common trait for GraphQL subscription servers.
-#[async_trait]
-pub trait SubscriptionServer {
-    /// Returns a Future that, when spawned, brings up the GraphQL subscription server.
-    async fn serve(self, port: u16);
-}
diff --git a/graph/src/components/store/entity_cache.rs b/graph/src/components/store/entity_cache.rs
index dc4af287b04..0bc3f17efef 100644
--- a/graph/src/components/store/entity_cache.rs
+++ b/graph/src/components/store/entity_cache.rs
@@ -1,19 +1,73 @@
-use anyhow::anyhow;
-use std::borrow::Cow;
-use std::collections::HashMap;
+use anyhow::{anyhow, bail};
+use std::borrow::Borrow;
+use std::collections::{BTreeSet, HashMap};
 use std::fmt::{self, Debug};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU32, Ordering};
 
+use crate::cheap_clone::CheapClone;
 use crate::components::store::write::EntityModification;
 use crate::components::store::{self as s, Entity, EntityOperation};
 use crate::data::store::{EntityValidationError, Id, IdType, IntoEntityIterator};
-use crate::prelude::ENV_VARS;
+use crate::prelude::{CacheWeight, ENV_VARS, StopwatchMetrics};
 use crate::schema::{EntityKey, InputSchema};
 use crate::util::intern::Error as InternError;
 use crate::util::lfu_cache::{EvictStats, LfuCache};
 
 use super::{BlockNumber, DerivedEntityQuery, LoadRelatedRequest, StoreError};
 
+pub type EntityLfuCache = LfuCache<EntityKey, Option<Arc<Entity>>>;
+
+// Number of VIDs that are reserved outside of the generated ones here.
+// Currently none is used, but lets reserve a few more.
+const RESERVED_VIDS: u32 = 100;
+
+/// Shared generator for VID and entity ID sequences within a block.
+///
+/// Created once per block and shared (via `Arc`) across all `EntityCache`
+/// instances that operate on the same block. This prevents VID collisions
+/// when multiple isolated caches (e.g. ipfs.map callbacks, offchain
+/// triggers) write entities in the same block.
+#[derive(Clone, Debug)]
+pub struct SeqGenerator {
+    block: BlockNumber,
+    vid_seq: Arc<AtomicU32>,
+    id_seq: Arc<AtomicU32>,
+}
+
+impl CheapClone for SeqGenerator {
+    fn cheap_clone(&self) -> Self {
+        self.clone()
+    }
+}
+
+impl SeqGenerator {
+    pub fn new(block: BlockNumber) -> Self {
+        SeqGenerator {
+            block,
+            vid_seq: Arc::new(AtomicU32::new(RESERVED_VIDS)),
+            id_seq: Arc::new(AtomicU32::new(0)),
+        }
+    }
+
+    /// Return the next VID. The VID encodes the block number in the upper
+    /// 32 bits and a monotonically increasing sequence in the lower 32
+    /// bits.
+    pub fn vid(&self) -> i64 {
+        let seq = self.vid_seq.fetch_add(1, Ordering::Relaxed);
+        ((self.block as i64) << 32) + seq as i64
+    }
+
+    /// Generate the next entity ID for the given ID type. The ID encodes
+    /// the block number in the upper 32 bits and a monotonically
+    /// increasing sequence in the lower 32 bits.
+    pub fn id(&self, id_type: IdType) -> anyhow::Result<Id> {
+        let seq = self.id_seq.fetch_add(1, Ordering::Relaxed);
+
+        id_type.generate_id(self.block, seq)
+    }
+}
+
 /// The scope in which the `EntityCache` should perform a `get` operation
 pub enum GetScope {
     /// Get from all previously stored entities in the store
@@ -31,14 +85,20 @@ enum EntityOp {
 }
 
 impl EntityOp {
-    fn apply_to(self, entity: &mut Option<Cow<Entity>>) -> Result<(), InternError> {
+    fn apply_to<E: Borrow<Entity>>(
+        self,
+        entity: &Option<E>,
+    ) -> Result<Option<Entity>, InternError> {
         use EntityOp::*;
         match (self, entity) {
-            (Remove, e @ _) => *e = None,
-            (Overwrite(new), e @ _) | (Update(new), e @ None) => *e = Some(Cow::Owned(new)),
-            (Update(updates), Some(entity)) => entity.to_mut().merge_remove_null_fields(updates)?,
+            (Remove, _) => Ok(None),
+            (Overwrite(new), _) | (Update(new), None) => Ok(Some(new)),
+            (Update(updates), Some(entity)) => {
+                let mut e = entity.borrow().clone();
+                e.merge_remove_null_fields(updates)?;
+                Ok(Some(e))
+            }
         }
-        Ok(())
     }
 
     fn accumulate(&mut self, next: EntityOp) {
@@ -74,7 +134,7 @@ impl EntityOp {
 pub struct EntityCache {
     /// The state of entities in the store. An entry of `None`
     /// means that the entity is not present in the store
-    current: LfuCache<EntityKey, Option<Entity>>,
+    current: LfuCache<EntityKey, Option<Arc<Entity>>>,
 
     /// The accumulated changes to an entity.
     updates: HashMap<EntityKey, EntityOp>,
@@ -90,12 +150,8 @@ pub struct EntityCache {
 
     pub schema: InputSchema,
 
-    /// A sequence number for generating entity IDs. We use one number for
-    /// all id's as the id's are scoped by block and a u32 has plenty of
-    /// room for all changes in one block. To ensure reproducability of
-    /// generated IDs, the `EntityCache` needs to be newly instantiated for
-    /// each block
-    seq: u32,
+    /// Shared sequence generator for VIDs and entity IDs within a block.
+    pub seq_gen: SeqGenerator,
 }
 
 impl Debug for EntityCache {
@@ -109,12 +165,12 @@ impl Debug for EntityCache {
 
 pub struct ModificationsAndCache {
     pub modifications: Vec<s::EntityModification>,
-    pub entity_lfu_cache: LfuCache<EntityKey, Option<Entity>>,
+    pub entity_lfu_cache: EntityLfuCache,
     pub evict_stats: EvictStats,
 }
 
 impl EntityCache {
-    pub fn new(store: Arc<dyn s::ReadStore>) -> Self {
+    pub fn new(store: Arc<dyn s::ReadStore>, seq_gen: SeqGenerator) -> Self {
         Self {
             current: LfuCache::new(),
             updates: HashMap::new(),
@@ -122,7 +178,7 @@ impl EntityCache {
             in_handler: false,
             schema: store.input_schema(),
             store,
-            seq: 0,
+            seq_gen,
         }
     }
 
@@ -136,7 +192,8 @@ impl EntityCache {
 
     pub fn with_current(
         store: Arc<dyn s::ReadStore>,
-        current: LfuCache<EntityKey, Option<Entity>>,
+        current: EntityLfuCache,
+        seq_gen: SeqGenerator,
     ) -> EntityCache {
         EntityCache {
             current,
@@ -145,10 +202,14 @@ impl EntityCache {
             in_handler: false,
             schema: store.input_schema(),
             store,
-            seq: 0,
+            seq_gen,
         }
     }
 
+    pub fn seq_gen(&self) -> SeqGenerator {
+        self.seq_gen.cheap_clone()
+    }
+
     pub(crate) fn enter_handler(&mut self) {
         assert!(!self.in_handler);
         self.in_handler = true;
@@ -171,44 +232,53 @@ impl EntityCache {
         self.handler_updates.clear();
     }
 
-    pub fn get(
+    pub async fn get(
         &mut self,
         key: &EntityKey,
         scope: GetScope,
-    ) -> Result<Option<Cow<Entity>>, StoreError> {
+    ) -> Result<Option<Arc<Entity>>, StoreError> {
         // Get the current entity, apply any updates from `updates`, then
         // from `handler_updates`.
-        let mut entity: Option<Cow<Entity>> = match scope {
+        let mut entity: Option<Arc<Entity>> = match scope {
             GetScope::Store => {
                 if !self.current.contains_key(key) {
-                    let entity = self.store.get(key)?;
-                    self.current.insert(key.clone(), entity);
+                    let entity = self.store.get(key).await?;
+                    self.current.insert(key.clone(), entity.map(Arc::new));
                 }
                 // Unwrap: we just inserted the entity
-                self.current.get(key).unwrap().as_ref().map(Cow::Borrowed)
+                self.current.get(key).unwrap().cheap_clone()
             }
             GetScope::InBlock => None,
         };
 
         // Always test the cache consistency in debug mode. The test only
-        // makes sense when we were actually asked to read from the store
+        // makes sense when we were actually asked to read from the store.
+        // We need to remove the VID as the one from the DB  might come from
+        // a legacy subgraph that has VID autoincremented while this trait
+        // always creates it in a new style.
         debug_assert!(match scope {
-            GetScope::Store => entity == self.store.get(key).unwrap().map(Cow::Owned),
+            GetScope::Store => {
+                entity == self.store.get(key).await.unwrap().map(Arc::new)
+            }
             GetScope::InBlock => true,
         });
 
         if let Some(op) = self.updates.get(key).cloned() {
-            op.apply_to(&mut entity)
-                .map_err(|e| key.unknown_attribute(e))?;
+            entity = op
+                .apply_to(&entity)
+                .map_err(|e| key.unknown_attribute(e))?
+                .map(Arc::new);
         }
         if let Some(op) = self.handler_updates.get(key).cloned() {
-            op.apply_to(&mut entity)
-                .map_err(|e| key.unknown_attribute(e))?;
+            entity = op
+                .apply_to(&entity)
+                .map_err(|e| key.unknown_attribute(e))?
+                .map(Arc::new);
         }
         Ok(entity)
     }
 
-    pub fn load_related(
+    pub async fn load_related(
         &mut self,
         eref: &LoadRelatedRequest,
     ) -> Result<Vec<Entity>, anyhow::Error> {
@@ -216,113 +286,57 @@ impl EntityCache {
 
         let query = DerivedEntityQuery {
             entity_type,
-            entity_field: field.name.clone().into(),
+            entity_field: field.name.clone(),
             value: eref.entity_id.clone(),
             causality_region: eref.causality_region,
         };
 
-        let mut entity_map = self.store.get_derived(&query)?;
+        // Entities that satisfied the query at the start of this block.
+        let stored = self.store.get_derived(&query).await?;
 
-        for (key, entity) in entity_map.iter() {
-            // Only insert to the cache if it's not already there
-            if !self.current.contains_key(&key) {
-                self.current.insert(key.clone(), Some(entity.clone()));
+        for (key, entity) in &stored {
+            if !self.current.contains_key(key) {
+                self.current
+                    .insert(key.clone(), Some(Arc::new(entity.clone())));
             }
         }
 
-        let mut keys_to_remove = Vec::new();
-
-        // Apply updates from `updates` and `handler_updates` directly to entities in `entity_map` that match the query
-        for (key, entity) in entity_map.iter_mut() {
-            let mut entity_cow = Some(Cow::Borrowed(entity));
-
-            if let Some(op) = self.updates.get(key).cloned() {
-                op.apply_to(&mut entity_cow)
-                    .map_err(|e| key.unknown_attribute(e))?;
-            }
-
-            if let Some(op) = self.handler_updates.get(key).cloned() {
-                op.apply_to(&mut entity_cow)
-                    .map_err(|e| key.unknown_attribute(e))?;
-            }
-
-            if let Some(updated_entity) = entity_cow {
-                *entity = updated_entity.into_owned();
-            } else {
-                // if entity_cow is None, it means that the entity was removed by an update
-                // mark the key for removal from the map
-                keys_to_remove.push(key.clone());
+        // Candidate set: keys that were matching at baseline, plus keys
+        // any in-block write has touched whose entity_type and causality
+        // region are compatible with the query. The latter catches
+        // entities an in-block write has moved into the matching set or
+        // created fresh in this block.
+        let mut candidates: BTreeSet<&EntityKey> = stored.keys().collect();
+        for key in self.updates.keys().chain(self.handler_updates.keys()) {
+            if key.entity_type == query.entity_type
+                && key.causality_region == query.causality_region
+            {
+                candidates.insert(key);
             }
         }
 
-        // A helper function that checks if an update matches the query and returns the updated entity if it does
-        fn matches_query(
-            op: &EntityOp,
-            query: &DerivedEntityQuery,
-            key: &EntityKey,
-        ) -> Result<Option<Entity>, anyhow::Error> {
-            match op {
-                EntityOp::Update(entity) | EntityOp::Overwrite(entity)
-                    if query.matches(key, entity) =>
-                {
-                    Ok(Some(entity.clone()))
-                }
-                EntityOp::Remove => Ok(None),
-                _ => Ok(None),
+        let mut result = Vec::new();
+        for key in candidates {
+            // Resolve the entity's final in-block state by layering
+            // store baseline, then self.updates, then self.handler_updates.
+            // Each layer's op may mutate, replace, or remove the entity.
+            let mut entity: Option<Entity> = stored.get(key).cloned();
+            if let Some(op) = self.updates.get(key).cloned() {
+                entity = op.apply_to(&entity).map_err(|e| key.unknown_attribute(e))?;
             }
-        }
-
-        // Iterate over self.updates to find entities that:
-        // - Aren't already present in the entity_map
-        // - Match the query
-        // If these conditions are met:
-        // - Check if there's an update for the same entity in handler_updates and apply it.
-        // - Add the entity to entity_map.
-        for (key, op) in self.updates.iter() {
-            if !entity_map.contains_key(key) {
-                if let Some(entity) = matches_query(op, &query, key)? {
-                    if let Some(handler_op) = self.handler_updates.get(key).cloned() {
-                        // If there's a corresponding update in handler_updates, apply it to the entity
-                        // and insert the updated entity into entity_map
-                        let mut entity_cow = Some(Cow::Borrowed(&entity));
-                        handler_op
-                            .apply_to(&mut entity_cow)
-                            .map_err(|e| key.unknown_attribute(e))?;
-
-                        if let Some(updated_entity) = entity_cow {
-                            entity_map.insert(key.clone(), updated_entity.into_owned());
-                        }
-                    } else {
-                        // If there isn't a corresponding update in handler_updates or the update doesn't match the query, just insert the entity from self.updates
-                        entity_map.insert(key.clone(), entity);
-                    }
-                }
+            if let Some(op) = self.handler_updates.get(key).cloned() {
+                entity = op.apply_to(&entity).map_err(|e| key.unknown_attribute(e))?;
             }
-        }
 
-        // Iterate over handler_updates to find entities that:
-        // - Aren't already present in the entity_map.
-        // - Aren't present in self.updates.
-        // - Match the query.
-        // If these conditions are met, add the entity to entity_map.
-        for (key, handler_op) in self.handler_updates.iter() {
-            if !entity_map.contains_key(key) && !self.updates.contains_key(key) {
-                if let Some(entity) = matches_query(handler_op, &query, key)? {
-                    entity_map.insert(key.clone(), entity);
-                }
+            // Include the entity only if its final state still matches the query.
+            if let Some(entity) = entity
+                && query.matches(key, &entity)
+            {
+                result.push(entity);
             }
         }
 
-        // Remove entities that are in the store but have been removed by an update.
-        // We do this last since the loops over updates and handler_updates are only
-        // concerned with entities that are not in the store yet and by leaving removed
-        // keys in entity_map we avoid processing these updates a second time when we
-        // already looked at them when we went through entity_map
-        for key in keys_to_remove {
-            entity_map.remove(&key);
-        }
-
-        Ok(entity_map.into_values().collect())
+        Ok(result)
     }
 
     pub fn remove(&mut self, key: EntityKey) {
@@ -334,17 +348,47 @@ impl EntityCache {
     /// with existing data. The entity will be validated against the
     /// subgraph schema, and any errors will result in an `Err` being
     /// returned.
-    pub fn set(&mut self, key: EntityKey, entity: Entity) -> Result<(), anyhow::Error> {
+    pub async fn set(
+        &mut self,
+        key: EntityKey,
+        entity: Entity,
+        write_capacity_remaining: Option<&mut usize>,
+    ) -> Result<(), anyhow::Error> {
         // check the validate for derived fields
         let is_valid = entity.validate(&key).is_ok();
 
+        if let Some(write_capacity_remaining) = write_capacity_remaining {
+            let weight = entity.weight();
+            if !self.current.contains_key(&key) && weight > *write_capacity_remaining {
+                return Err(anyhow!(
+                    "exceeded block write limit when writing entity `{}`",
+                    key.entity_id,
+                ));
+            }
+
+            *write_capacity_remaining -= weight;
+        }
+
+        let vid = self.seq_gen.vid();
+        let mut entity = entity;
+        let old_vid = entity.set_vid(vid).expect("the vid should be set");
+        // Make sure that there was no VID previously set for this entity.
+        if let Some(ovid) = old_vid {
+            bail!(
+                "VID: {} of entity: {} with ID: {} was already present when set in EntityCache",
+                ovid,
+                key.entity_type,
+                entity.id()
+            );
+        }
+
         self.entity_op(key.clone(), EntityOp::Update(entity));
 
         // The updates we were given are not valid by themselves; force a
         // lookup in the database and check again with an entity that merges
         // the existing entity with the changes
         if !is_valid {
-            let entity = self.get(&key, GetScope::Store)?.ok_or_else(|| {
+            let entity = self.get(&key, GetScope::Store).await?.ok_or_else(|| {
                 anyhow!(
                     "Failed to read entity {}[{}] back from cache",
                     key.entity_type,
@@ -396,21 +440,15 @@ impl EntityCache {
         }
     }
 
-    /// Generate an id.
-    pub fn generate_id(&mut self, id_type: IdType, block: BlockNumber) -> anyhow::Result<Id> {
-        let id = id_type.generate_id(block, self.seq)?;
-        self.seq += 1;
-        Ok(id)
-    }
-
     /// Return the changes that have been made via `set` and `remove` as
     /// `EntityModification`, making sure to only produce one when a change
     /// to the current state is actually needed.
     ///
     /// Also returns the updated `LfuCache`.
-    pub fn as_modifications(
+    pub async fn as_modifications(
         mut self,
         block: BlockNumber,
+        stopwatch: &StopwatchMetrics,
     ) -> Result<ModificationsAndCache, StoreError> {
         assert!(!self.in_handler);
 
@@ -428,10 +466,14 @@ impl EntityCache {
         // is wrong and the store already has a version of the entity from a
         // previous block, the attempt to insert will trigger a constraint
         // violation in the database, ensuring correctness
-        let missing = missing.filter(|key| !key.entity_type.is_immutable());
+        {
+            let _section = stopwatch.start_section("as_modifications_load");
 
-        for (entity_key, entity) in self.store.get_many(missing.cloned().collect())? {
-            self.current.insert(entity_key, Some(entity));
+            let missing = missing.filter(|key| !key.entity_type.is_immutable());
+
+            for (entity_key, entity) in self.store.get_many(missing.cloned().collect()).await? {
+                self.current.insert(entity_key, Some(Arc::new(entity)));
+            }
         }
 
         let mut mods = Vec::new();
@@ -444,21 +486,25 @@ impl EntityCache {
                 (None, EntityOp::Update(mut updates))
                 | (None, EntityOp::Overwrite(mut updates)) => {
                     updates.remove_null_fields();
-                    self.current.insert(key.clone(), Some(updates.clone()));
+                    let data = Arc::new(updates);
+                    self.current.insert(key.clone(), Some(data.cheap_clone()));
                     Some(Insert {
                         key,
-                        data: updates,
+                        data,
                         block,
                         end: None,
                     })
                 }
                 // Entity may have been changed
                 (Some(current), EntityOp::Update(updates)) => {
-                    let mut data = current.clone();
-                    data.merge_remove_null_fields(updates)
+                    let mut data =
+                        Arc::try_unwrap(current).unwrap_or_else(|arc| arc.as_ref().clone());
+                    let changed = data
+                        .merge_remove_null_fields(updates)
                         .map_err(|e| key.unknown_attribute(e))?;
-                    self.current.insert(key.clone(), Some(data.clone()));
-                    if current != data {
+                    let data = Arc::new(data);
+                    self.current.insert(key.clone(), Some(data.cheap_clone()));
+                    if changed {
                         Some(Overwrite {
                             key,
                             data,
@@ -471,7 +517,8 @@ impl EntityCache {
                 }
                 // Entity was removed and then updated, so it will be overwritten
                 (Some(current), EntityOp::Overwrite(data)) => {
-                    self.current.insert(key.clone(), Some(data.clone()));
+                    let data = Arc::new(data);
+                    self.current.insert(key.clone(), Some(data.cheap_clone()));
                     if current != data {
                         Some(Overwrite {
                             key,
diff --git a/graph/src/components/store/err.rs b/graph/src/components/store/err.rs
index 5187c65cf14..9e94342cb34 100644
--- a/graph/src/components/store/err.rs
+++ b/graph/src/components/store/err.rs
@@ -1,32 +1,29 @@
 use super::{BlockNumber, DeploymentSchemaVersion};
+use crate::prelude::DeploymentHash;
 use crate::prelude::QueryExecutionError;
-use crate::util::intern::Error as InternError;
-use crate::{data::store::EntityValidationError, prelude::DeploymentHash};
 
-use anyhow::{anyhow, Error};
+use anyhow::{Error, anyhow};
 use diesel::result::Error as DieselError;
 use thiserror::Error;
 use tokio::task::JoinError;
 
+pub type StoreResult<T> = Result<T, StoreError>;
+
 #[derive(Error, Debug)]
 pub enum StoreError {
     #[error("store error: {0:#}")]
     Unknown(Error),
-    #[error("Entity validation failed: {0}")]
-    EntityValidationError(EntityValidationError),
     #[error(
         "tried to set entity of type `{0}` with ID \"{1}\" but an entity of type `{2}`, \
          which has an interface in common with `{0}`, exists with the same ID"
     )]
     ConflictingId(String, String, String), // (entity, id, conflicting_entity)
-    #[error("unknown field '{0}'")]
-    UnknownField(String),
+    #[error("table '{0}' does not have a field '{1}'")]
+    UnknownField(String, String),
     #[error("unknown table '{0}'")]
     UnknownTable(String),
     #[error("entity type '{0}' does not have an attribute '{0}'")]
     UnknownAttribute(String, String),
-    #[error("malformed directive '{0}'")]
-    MalformedDirective(String),
     #[error("query execution failed: {0}")]
     QueryExecutionError(String),
     #[error("Child filter nesting not supported by value `{0}`: `{1}`")]
@@ -41,20 +38,20 @@ pub enum StoreError {
     /// An internal error where we expected the application logic to enforce
     /// some constraint, e.g., that subgraph names are unique, but found that
     /// constraint to not hold
-    #[error("internal constraint violated: {0}")]
-    ConstraintViolation(String),
+    #[error("internal error: {0}")]
+    InternalError(String),
     #[error("deployment not found: {0}")]
     DeploymentNotFound(String),
     #[error("shard not found: {0} (this usually indicates a misconfiguration)")]
     UnknownShard(String),
     #[error("Fulltext search not yet deterministic")]
     FulltextSearchNonDeterministic,
+    #[error("Fulltext search column missing configuration")]
+    FulltextColumnMissingConfig,
     #[error("operation was canceled")]
     Canceled,
     #[error("database unavailable")]
     DatabaseUnavailable,
-    #[error("database disabled")]
-    DatabaseDisabled,
     #[error("subgraph forking failed: {0}")]
     ForkFailure(String),
     #[error("subgraph writer poisoned by previous error")]
@@ -62,23 +59,35 @@ pub enum StoreError {
     #[error("panic in subgraph writer: {0}")]
     WriterPanic(JoinError),
     #[error(
-        "found schema version {0} but this graph node only supports versions up to {}. \
+        "found schema version {0} but this graph node only supports versions up to {latest}. \
          Did you downgrade Graph Node?",
-        DeploymentSchemaVersion::LATEST
+        latest = DeploymentSchemaVersion::LATEST
     )]
     UnsupportedDeploymentSchemaVersion(i32),
     #[error("pruning failed: {0}")]
     PruneFailure(String),
+    #[error("unsupported filter `{0}` for value `{1}`")]
+    UnsupportedFilter(String, String),
+    #[error("writing {0} entities at block {1} failed: {2} Query: {3}")]
+    WriteFailure(String, BlockNumber, String, String),
+    #[error("database query timed out")]
+    StatementTimeout,
+    #[error("database constraint violated: {0}")]
+    ConstraintViolation(String),
+    /// The input to some operation, usually user input, makes it impossible
+    /// to complete the operation. This must be a deterministic error
+    #[error("{0}")]
+    Input(String),
 }
 
-// Convenience to report a constraint violation
+// Convenience to report an internal error
 #[macro_export]
-macro_rules! constraint_violation {
+macro_rules! internal_error {
     ($msg:expr) => {{
-        $crate::prelude::StoreError::ConstraintViolation(format!("{}", $msg))
+        $crate::prelude::StoreError::InternalError(format!("{}", $msg))
     }};
     ($fmt:expr, $($arg:tt)*) => {{
-        $crate::prelude::StoreError::ConstraintViolation(format!($fmt, $($arg)*))
+        $crate::prelude::StoreError::InternalError(format!($fmt, $($arg)*))
     }}
 }
 
@@ -89,57 +98,129 @@ impl Clone for StoreError {
     fn clone(&self) -> Self {
         match self {
             Self::Unknown(arg0) => Self::Unknown(anyhow!("{}", arg0)),
-            Self::EntityValidationError(arg0) => Self::EntityValidationError(arg0.clone()),
             Self::ConflictingId(arg0, arg1, arg2) => {
                 Self::ConflictingId(arg0.clone(), arg1.clone(), arg2.clone())
             }
-            Self::UnknownField(arg0) => Self::UnknownField(arg0.clone()),
+            Self::UnknownField(arg0, arg1) => Self::UnknownField(arg0.clone(), arg1.clone()),
             Self::UnknownTable(arg0) => Self::UnknownTable(arg0.clone()),
             Self::UnknownAttribute(arg0, arg1) => {
                 Self::UnknownAttribute(arg0.clone(), arg1.clone())
             }
-            Self::MalformedDirective(arg0) => Self::MalformedDirective(arg0.clone()),
             Self::QueryExecutionError(arg0) => Self::QueryExecutionError(arg0.clone()),
             Self::ChildFilterNestingNotSupportedError(arg0, arg1) => {
                 Self::ChildFilterNestingNotSupportedError(arg0.clone(), arg1.clone())
             }
             Self::InvalidIdentifier(arg0) => Self::InvalidIdentifier(arg0.clone()),
             Self::DuplicateBlockProcessing(arg0, arg1) => {
-                Self::DuplicateBlockProcessing(arg0.clone(), arg1.clone())
+                Self::DuplicateBlockProcessing(arg0.clone(), *arg1)
             }
-            Self::ConstraintViolation(arg0) => Self::ConstraintViolation(arg0.clone()),
+            Self::InternalError(arg0) => Self::InternalError(arg0.clone()),
             Self::DeploymentNotFound(arg0) => Self::DeploymentNotFound(arg0.clone()),
             Self::UnknownShard(arg0) => Self::UnknownShard(arg0.clone()),
             Self::FulltextSearchNonDeterministic => Self::FulltextSearchNonDeterministic,
+            Self::FulltextColumnMissingConfig => Self::FulltextColumnMissingConfig,
             Self::Canceled => Self::Canceled,
             Self::DatabaseUnavailable => Self::DatabaseUnavailable,
-            Self::DatabaseDisabled => Self::DatabaseDisabled,
             Self::ForkFailure(arg0) => Self::ForkFailure(arg0.clone()),
             Self::Poisoned => Self::Poisoned,
             Self::WriterPanic(arg0) => Self::Unknown(anyhow!("writer panic: {}", arg0)),
             Self::UnsupportedDeploymentSchemaVersion(arg0) => {
-                Self::UnsupportedDeploymentSchemaVersion(arg0.clone())
+                Self::UnsupportedDeploymentSchemaVersion(*arg0)
             }
             Self::PruneFailure(arg0) => Self::PruneFailure(arg0.clone()),
+            Self::UnsupportedFilter(arg0, arg1) => {
+                Self::UnsupportedFilter(arg0.clone(), arg1.clone())
+            }
+            Self::WriteFailure(arg0, arg1, arg2, arg3) => {
+                Self::WriteFailure(arg0.clone(), *arg1, arg2.clone(), arg3.clone())
+            }
+            Self::StatementTimeout => Self::StatementTimeout,
+            Self::ConstraintViolation(arg0) => Self::ConstraintViolation(arg0.clone()),
+            Self::Input(arg0) => Self::Input(arg0.clone()),
+        }
+    }
+}
+
+impl StoreError {
+    pub fn from_diesel_error(e: &DieselError) -> Option<Self> {
+        const CONN_CLOSE: &str = "server closed the connection unexpectedly";
+        const STMT_TIMEOUT: &str = "canceling statement due to statement timeout";
+        const UNIQUE_CONSTR: &str = "duplicate key value violates unique constraint";
+        let DieselError::DatabaseError(_, info) = e else {
+            return None;
+        };
+        if info.message().contains(CONN_CLOSE) {
+            // When the error is caused by a closed connection, treat the error
+            // as 'database unavailable'. When this happens during indexing, the
+            // indexing machinery will retry in that case rather than fail the
+            // subgraph
+            Some(StoreError::DatabaseUnavailable)
+        } else if info.message().contains(STMT_TIMEOUT) {
+            Some(StoreError::StatementTimeout)
+        } else if info.message().contains(UNIQUE_CONSTR) {
+            let msg = match info.details() {
+                Some(details) => format!("{}: {}", info.message(), details.replace('\n', " ")),
+                None => info.message().to_string(),
+            };
+            Some(StoreError::ConstraintViolation(msg))
+        } else {
+            None
+        }
+    }
+
+    pub fn write_failure(
+        error: DieselError,
+        entity: &str,
+        block: BlockNumber,
+        query: String,
+    ) -> Self {
+        Self::from_diesel_error(&error).unwrap_or_else(|| {
+            StoreError::WriteFailure(entity.to_string(), block, error.to_string(), query)
+        })
+    }
+
+    pub fn is_deterministic(&self) -> bool {
+        use StoreError::*;
+
+        // This classification tries to err on the side of caution. If in doubt,
+        // assume the error is non-deterministic.
+        match self {
+            // deterministic errors
+            ConflictingId(_, _, _)
+            | UnknownField(_, _)
+            | UnknownTable(_)
+            | UnknownAttribute(_, _)
+            | InvalidIdentifier(_)
+            | UnsupportedFilter(_, _)
+            | ConstraintViolation(_)
+            | Input(_) => true,
+
+            // non-deterministic errors
+            Unknown(_)
+            | QueryExecutionError(_)
+            | ChildFilterNestingNotSupportedError(_, _)
+            | DuplicateBlockProcessing(_, _)
+            | InternalError(_)
+            | DeploymentNotFound(_)
+            | UnknownShard(_)
+            | FulltextSearchNonDeterministic
+            | FulltextColumnMissingConfig
+            | Canceled
+            | DatabaseUnavailable
+            | ForkFailure(_)
+            | Poisoned
+            | WriterPanic(_)
+            | UnsupportedDeploymentSchemaVersion(_)
+            | PruneFailure(_)
+            | WriteFailure(_, _, _, _)
+            | StatementTimeout => false,
         }
     }
 }
 
 impl From<DieselError> for StoreError {
     fn from(e: DieselError) -> Self {
-        // When the error is caused by a closed connection, treat the error
-        // as 'database unavailable'. When this happens during indexing, the
-        // indexing machinery will retry in that case rather than fail the
-        // subgraph
-        if let DieselError::DatabaseError(_, info) = &e {
-            if info
-                .message()
-                .contains("server closed the connection unexpectedly")
-            {
-                return StoreError::DatabaseUnavailable;
-            }
-        }
-        StoreError::Unknown(e.into())
+        Self::from_diesel_error(&e).unwrap_or_else(|| StoreError::Unknown(e.into()))
     }
 }
 
@@ -169,14 +250,12 @@ impl From<QueryExecutionError> for StoreError {
 
 impl From<std::fmt::Error> for StoreError {
     fn from(e: std::fmt::Error) -> Self {
-        StoreError::Unknown(anyhow!("{}", e.to_string()))
+        StoreError::Unknown(anyhow!("{}", e))
     }
 }
 
-impl From<InternError> for StoreError {
-    fn from(e: InternError) -> Self {
-        match e {
-            InternError::NotInterned(key) => StoreError::UnknownField(key),
-        }
+impl crate::amp::error::IsDeterministic for StoreError {
+    fn is_deterministic(&self) -> bool {
+        StoreError::is_deterministic(self)
     }
 }
diff --git a/graph/src/components/store/mod.rs b/graph/src/components/store/mod.rs
index 0a0cf506a35..a3a85b51cc2 100644
--- a/graph/src/components/store/mod.rs
+++ b/graph/src/components/store/mod.rs
@@ -3,40 +3,49 @@ mod err;
 mod traits;
 pub mod write;
 
-pub use entity_cache::{EntityCache, GetScope, ModificationsAndCache};
-use futures03::future::{FutureExt, TryFutureExt};
-use slog::{trace, Logger};
+use alloy::primitives::Address;
+use diesel::deserialize::FromSql;
+use diesel::pg::Pg;
+use diesel::serialize::{Output, ToSql};
+use diesel::sql_types::Integer;
+use diesel_derives::{AsExpression, FromSqlRow};
+pub use entity_cache::{
+    EntityCache, EntityLfuCache, GetScope, ModificationsAndCache, SeqGenerator,
+};
+use slog::Logger;
+use tokio_stream::wrappers::ReceiverStream;
 
 pub use super::subgraph::Entity;
-pub use err::StoreError;
+pub use err::{StoreError, StoreResult};
 use itertools::Itertools;
 use strum_macros::Display;
 pub use traits::*;
 pub use write::Batch;
 
-use futures::stream::poll_fn;
-use futures::{Async, Poll, Stream};
 use serde::{Deserialize, Serialize};
 use std::collections::btree_map::Entry;
 use std::collections::{BTreeMap, BTreeSet, HashSet};
 use std::fmt;
 use std::fmt::Display;
+use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::{Arc, RwLock};
 use std::time::Duration;
 
+use async_trait::async_trait;
+
 use crate::blockchain::{Block, BlockHash, BlockPtr};
 use crate::cheap_clone::CheapClone;
 use crate::components::store::write::EntityModification;
-use crate::constraint_violation;
 use crate::data::store::scalar::Bytes;
 use crate::data::store::{Id, IdList, Value};
 use crate::data::value::Word;
 use crate::data_source::CausalityRegion;
+use crate::derive::CheapClone;
 use crate::env::ENV_VARS;
-use crate::prelude::{s, Attribute, DeploymentHash, SubscriptionFilter, ValueType};
-use crate::schema::{ast as sast, EntityKey, EntityType, InputSchema};
-use crate::util::stats::MovingStats;
+use crate::internal_error;
+use crate::prelude::{Attribute, DeploymentHash, ValueType, s};
+use crate::schema::{EntityKey, EntityType, InputSchema, ast as sast};
+use crate::util::stats::AtomicMovingStats;
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct EntityFilterDerivative(bool);
@@ -89,6 +98,7 @@ impl DerivedEntityQuery {
     /// Checks if a given key and entity match this query.
     pub fn matches(&self, key: &EntityKey, entity: &Entity) -> bool {
         key.entity_type == self.entity_type
+            && key.causality_region == self.causality_region
             && entity
                 .get(&self.entity_field)
                 .map(|v| &self.value == v)
@@ -420,13 +430,14 @@ impl EntityCollection {
 /// be enough for everybody
 pub type BlockNumber = i32;
 
-pub const BLOCK_NUMBER_MAX: BlockNumber = std::i32::MAX;
+pub const BLOCK_NUMBER_MAX: BlockNumber = i32::MAX;
 
 /// A query for entities in a store.
 ///
 /// Details of how query generation for `EntityQuery` works can be found
 /// at https://github.com/graphprotocol/rfcs/blob/master/engineering-plans/0001-graphql-query-prefetching.md
 #[derive(Clone, Debug)]
+#[non_exhaustive]
 pub struct EntityQuery {
     /// ID of the subgraph.
     pub subgraph_id: DeploymentHash,
@@ -458,7 +469,7 @@ pub struct EntityQuery {
 
     pub trace: bool,
 
-    _force_use_of_new: (),
+    pub aggregation_current: Option<AggregationCurrent>,
 }
 
 impl EntityQuery {
@@ -477,7 +488,7 @@ impl EntityQuery {
             logger: None,
             query_id: None,
             trace: false,
-            _force_use_of_new: (),
+            aggregation_current: None,
         }
     }
 
@@ -510,26 +521,26 @@ impl EntityQuery {
         // If there is one window, with one id, in a direct relation to the
         // entities, we can simplify the query by changing the filter and
         // getting rid of the window
-        if let EntityCollection::Window(windows) = &self.collection {
-            if windows.len() == 1 {
-                let window = windows.first().expect("we just checked");
-                if window.ids.len() == 1 {
-                    let id = window.ids.first().expect("we just checked").to_value();
-                    if let EntityLink::Direct(attribute, _) = &window.link {
-                        let filter = match attribute {
-                            WindowAttribute::Scalar(name) => {
-                                EntityFilter::Equal(name.clone(), id.into())
-                            }
-                            WindowAttribute::List(name) => {
-                                EntityFilter::Contains(name.clone(), Value::from(vec![id]))
-                            }
-                        };
-                        self.filter = Some(filter.and_maybe(self.filter));
-                        self.collection = EntityCollection::All(vec![(
-                            window.child_type.clone(),
-                            window.column_names.clone(),
-                        )]);
-                    }
+        if let EntityCollection::Window(windows) = &self.collection
+            && windows.len() == 1
+        {
+            let window = windows.first().expect("we just checked");
+            if window.ids.len() == 1 {
+                let id = window.ids.first().expect("we just checked").to_value();
+                if let EntityLink::Direct(attribute, _) = &window.link {
+                    let filter = match attribute {
+                        WindowAttribute::Scalar(name) => {
+                            EntityFilter::Equal(name.clone(), id.into())
+                        }
+                        WindowAttribute::List(name) => {
+                            EntityFilter::Contains(name.clone(), Value::from(vec![id]))
+                        }
+                    };
+                    self.filter = Some(filter.and_maybe(self.filter));
+                    self.collection = EntityCollection::All(vec![(
+                        window.child_type.clone(),
+                        window.column_names.clone(),
+                    )]);
                 }
             }
         }
@@ -537,58 +548,54 @@ impl EntityQuery {
     }
 }
 
-/// Operation types that lead to entity changes.
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
+/// Indicates whether the current, partially filled bucket should be included in the response.
+///
+/// This is only relevant for aggregation entity queries.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum AggregationCurrent {
+    /// Exclude the current, partially filled bucket from the response.
+    #[default]
+    Exclude,
+
+    /// Include the current, partially filled bucket in the response.
+    Include,
+}
+
+/// Operation types that lead to changes in assignments
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
 #[serde(rename_all = "lowercase")]
-pub enum EntityChangeOperation {
-    /// An entity was added or updated
+pub enum AssignmentOperation {
+    /// An assignment was added or updated
     Set,
-    /// An existing entity was removed.
+    /// An assignment was removed.
     Removed,
 }
 
-/// Entity change events emitted by [Store](trait.Store.html) implementations.
+/// Assignment change events emitted by [Store](trait.Store.html) implementations.
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
-pub enum EntityChange {
-    Data {
-        subgraph_id: DeploymentHash,
-        /// Entity type name of the changed entity.
-        entity_type: String,
-    },
-    Assignment {
-        deployment: DeploymentLocator,
-        operation: EntityChangeOperation,
-    },
-}
-
-impl EntityChange {
-    pub fn for_data(subgraph_id: DeploymentHash, key: EntityKey) -> Self {
-        Self::Data {
-            subgraph_id,
-            entity_type: key.entity_type.to_string(),
-        }
-    }
+pub struct AssignmentChange {
+    deployment: DeploymentLocator,
+    operation: AssignmentOperation,
+}
 
-    pub fn for_assignment(deployment: DeploymentLocator, operation: EntityChangeOperation) -> Self {
-        Self::Assignment {
+impl AssignmentChange {
+    fn new(deployment: DeploymentLocator, operation: AssignmentOperation) -> Self {
+        Self {
             deployment,
             operation,
         }
     }
 
-    pub fn as_filter(&self, schema: &InputSchema) -> SubscriptionFilter {
-        use EntityChange::*;
-        match self {
-            Data {
-                subgraph_id,
-                entity_type,
-                ..
-            } => SubscriptionFilter::Entities(
-                subgraph_id.clone(),
-                schema.entity_type(entity_type).unwrap(),
-            ),
-            Assignment { .. } => SubscriptionFilter::Assignment,
-        }
+    pub fn set(deployment: DeploymentLocator) -> Self {
+        Self::new(deployment, AssignmentOperation::Set)
+    }
+
+    pub fn removed(deployment: DeploymentLocator) -> Self {
+        Self::new(deployment, AssignmentOperation::Removed)
+    }
+
+    pub fn into_parts(self) -> (DeploymentLocator, AssignmentOperation) {
+        (self.deployment, self.operation)
     }
 }
 
@@ -605,74 +612,26 @@ pub struct StoreEvent {
     // The tag is only there to make it easier to track StoreEvents in the
     // logs as they flow through the system
     pub tag: usize,
-    pub changes: HashSet<EntityChange>,
+    pub changes: HashSet<AssignmentChange>,
 }
 
 impl StoreEvent {
-    pub fn new(changes: Vec<EntityChange>) -> StoreEvent {
+    pub fn new(changes: Vec<AssignmentChange>) -> StoreEvent {
         let changes = changes.into_iter().collect();
         StoreEvent::from_set(changes)
     }
 
-    fn from_set(changes: HashSet<EntityChange>) -> StoreEvent {
+    fn from_set(changes: HashSet<AssignmentChange>) -> StoreEvent {
         static NEXT_TAG: AtomicUsize = AtomicUsize::new(0);
 
         let tag = NEXT_TAG.fetch_add(1, Ordering::Relaxed);
         StoreEvent { tag, changes }
     }
 
-    pub fn from_mods<'a, I: IntoIterator<Item = &'a EntityModification>>(
-        subgraph_id: &DeploymentHash,
-        mods: I,
-    ) -> Self {
-        let changes: Vec<_> = mods
-            .into_iter()
-            .map(|op| {
-                use EntityModification::*;
-                match op {
-                    Insert { key, .. } | Overwrite { key, .. } | Remove { key, .. } => {
-                        EntityChange::for_data(subgraph_id.clone(), key.clone())
-                    }
-                }
-            })
-            .collect();
-        StoreEvent::new(changes)
-    }
-
-    pub fn from_types(deployment: &DeploymentHash, entity_types: HashSet<EntityType>) -> Self {
-        let changes =
-            HashSet::from_iter(
-                entity_types
-                    .into_iter()
-                    .map(|entity_type| EntityChange::Data {
-                        subgraph_id: deployment.clone(),
-                        entity_type: entity_type.to_string(),
-                    }),
-            );
-        Self::from_set(changes)
-    }
-
-    /// Extend `ev1` with `ev2`. If `ev1` is `None`, just set it to `ev2`
-    fn accumulate(logger: &Logger, ev1: &mut Option<StoreEvent>, ev2: StoreEvent) {
-        if let Some(e) = ev1 {
-            trace!(logger, "Adding changes to event";
-                           "from" => ev2.tag, "to" => e.tag);
-            e.changes.extend(ev2.changes);
-        } else {
-            *ev1 = Some(ev2);
-        }
-    }
-
     pub fn extend(mut self, other: StoreEvent) -> Self {
         self.changes.extend(other.changes);
         self
     }
-
-    pub fn matches(&self, filters: &BTreeSet<SubscriptionFilter>) -> bool {
-        self.changes
-            .iter()
-            .any(|change| filters.iter().any(|filter| filter.matches(change)))
-    }
 }
 
 impl fmt::Display for StoreEvent {
@@ -693,134 +652,8 @@ impl PartialEq for StoreEvent {
     }
 }
 
-/// A `StoreEventStream` produces the `StoreEvents`. Various filters can be applied
-/// to it to reduce which and how many events are delivered by the stream.
-pub struct StoreEventStream<S> {
-    source: S,
-}
-
 /// A boxed `StoreEventStream`
-pub type StoreEventStreamBox =
-    StoreEventStream<Box<dyn Stream<Item = Arc<StoreEvent>, Error = ()> + Send>>;
-
-pub type UnitStream = Box<dyn futures03::Stream<Item = ()> + Unpin + Send + Sync>;
-
-impl<S> Stream for StoreEventStream<S>
-where
-    S: Stream<Item = Arc<StoreEvent>, Error = ()> + Send,
-{
-    type Item = Arc<StoreEvent>;
-    type Error = ();
-
-    fn poll(&mut self) -> Result<Async<Option<Self::Item>>, Self::Error> {
-        self.source.poll()
-    }
-}
-
-impl<S> StoreEventStream<S>
-where
-    S: Stream<Item = Arc<StoreEvent>, Error = ()> + Send + 'static,
-{
-    // Create a new `StoreEventStream` from another such stream
-    pub fn new(source: S) -> Self {
-        StoreEventStream { source }
-    }
-
-    /// Filter a `StoreEventStream` by subgraph and entity. Only events that have
-    /// at least one change to one of the given (subgraph, entity) combinations
-    /// will be delivered by the filtered stream.
-    pub fn filter_by_entities(self, filters: BTreeSet<SubscriptionFilter>) -> StoreEventStreamBox {
-        let source = self.source.filter(move |event| event.matches(&filters));
-
-        StoreEventStream::new(Box::new(source))
-    }
-
-    /// Reduce the frequency with which events are generated while a
-    /// subgraph deployment is syncing. While the given `deployment` is not
-    /// synced yet, events from `source` are reported at most every
-    /// `interval`. At the same time, no event is held for longer than
-    /// `interval`. The `StoreEvents` that arrive during an interval appear
-    /// on the returned stream as a single `StoreEvent`; the events are
-    /// combined by using the maximum of all sources and the concatenation
-    /// of the changes of the `StoreEvents` received during the interval.
-    //
-    // Currently unused, needs to be made compatible with `subscribe_no_payload`.
-    pub async fn throttle_while_syncing(
-        self,
-        logger: &Logger,
-        store: Arc<dyn QueryStore>,
-        interval: Duration,
-    ) -> StoreEventStreamBox {
-        // Check whether a deployment is marked as synced in the store. Note that in the moment a
-        // subgraph becomes synced any existing subscriptions will continue to be throttled since
-        // this is not re-checked.
-        let synced = store.is_deployment_synced().await.unwrap_or(false);
-
-        let mut pending_event: Option<StoreEvent> = None;
-        let mut source = self.source.fuse();
-        let mut had_err = false;
-        let mut delay = tokio::time::sleep(interval).unit_error().boxed().compat();
-        let logger = logger.clone();
-
-        let source = Box::new(poll_fn(move || -> Poll<Option<Arc<StoreEvent>>, ()> {
-            if had_err {
-                // We had an error the last time through, but returned the pending
-                // event first. Indicate the error now
-                had_err = false;
-                return Err(());
-            }
-
-            if synced {
-                return source.poll();
-            }
-
-            // Check if interval has passed since the last time we sent something.
-            // If it has, start a new delay timer
-            let should_send = match futures::future::Future::poll(&mut delay) {
-                Ok(Async::NotReady) => false,
-                // Timer errors are harmless. Treat them as if the timer had
-                // become ready.
-                Ok(Async::Ready(())) | Err(_) => {
-                    delay = tokio::time::sleep(interval).unit_error().boxed().compat();
-                    true
-                }
-            };
-
-            // Get as many events as we can off of the source stream
-            loop {
-                match source.poll() {
-                    Ok(Async::NotReady) => {
-                        if should_send && pending_event.is_some() {
-                            let event = pending_event.take().map(Arc::new);
-                            return Ok(Async::Ready(event));
-                        } else {
-                            return Ok(Async::NotReady);
-                        }
-                    }
-                    Ok(Async::Ready(None)) => {
-                        let event = pending_event.take().map(Arc::new);
-                        return Ok(Async::Ready(event));
-                    }
-                    Ok(Async::Ready(Some(event))) => {
-                        StoreEvent::accumulate(&logger, &mut pending_event, (*event).clone());
-                    }
-                    Err(()) => {
-                        // Before we report the error, deliver what we have accumulated so far.
-                        // We will report the error the next time poll() is called
-                        if pending_event.is_some() {
-                            had_err = true;
-                            let event = pending_event.take().map(Arc::new);
-                            return Ok(Async::Ready(event));
-                        } else {
-                            return Err(());
-                        }
-                    }
-                };
-            }
-        }));
-        StoreEventStream::new(source)
-    }
-}
+pub type StoreEventStreamBox = ReceiverStream<Arc<StoreEvent>>;
 
 /// An entity operation that can be transacted into the store.
 #[derive(Clone, Debug, PartialEq)]
@@ -835,8 +668,12 @@ pub enum EntityOperation {
 
 #[derive(Debug, PartialEq)]
 pub enum UnfailOutcome {
+    /// Nothing to do - no error exists, or error is of wrong type (e.g., deterministic).
     Noop,
+    /// Successfully unfailed the subgraph.
     Unfailed,
+    /// The deployment head is still behind the error block, retry on subsequent blocks.
+    BehindErrorBlock,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -853,7 +690,20 @@ pub struct StoredDynamicDataSource {
 /// identifier only has meaning in the context of a specific instance of
 /// graph-node. Only store code should ever construct or consume it; all
 /// other code passes it around as an opaque token.
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
+#[derive(
+    Copy,
+    Clone,
+    CheapClone,
+    Debug,
+    Serialize,
+    Deserialize,
+    PartialEq,
+    Eq,
+    Hash,
+    AsExpression,
+    FromSqlRow,
+)]
+#[diesel(sql_type = Integer)]
 pub struct DeploymentId(pub i32);
 
 impl Display for DeploymentId {
@@ -868,18 +718,29 @@ impl DeploymentId {
     }
 }
 
+impl FromSql<Integer, Pg> for DeploymentId {
+    fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
+        let id = <i32 as FromSql<Integer, Pg>>::from_sql(bytes)?;
+        Ok(DeploymentId(id))
+    }
+}
+
+impl ToSql<Integer, Pg> for DeploymentId {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
+        <i32 as ToSql<Integer, Pg>>::to_sql(&self.0, out)
+    }
+}
+
 /// A unique identifier for a deployment that specifies both its external
 /// identifier (`hash`) and its unique internal identifier (`id`) which
 /// ensures we are talking about a unique location for the deployment's data
 /// in the store
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
+#[derive(Clone, CheapClone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
 pub struct DeploymentLocator {
     pub id: DeploymentId,
     pub hash: DeploymentHash,
 }
 
-impl CheapClone for DeploymentLocator {}
-
 impl slog::Value for DeploymentLocator {
     fn serialize(
         &self,
@@ -904,8 +765,8 @@ impl Display for DeploymentLocator {
 }
 
 // The type that the connection pool uses to track wait times for
-// connection checkouts
-pub type PoolWaitStats = Arc<RwLock<MovingStats>>;
+// connection checkouts. Uses lock-free atomic operations internally.
+pub type PoolWaitStats = Arc<AtomicMovingStats>;
 
 /// Determines which columns should be selected in a table.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -1029,16 +890,20 @@ impl EmptyStore {
     }
 }
 
+#[async_trait]
 impl ReadStore for EmptyStore {
-    fn get(&self, _key: &EntityKey) -> Result<Option<Entity>, StoreError> {
+    async fn get(&self, _key: &EntityKey) -> Result<Option<Entity>, StoreError> {
         Ok(None)
     }
 
-    fn get_many(&self, _: BTreeSet<EntityKey>) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
+    async fn get_many(
+        &self,
+        _: BTreeSet<EntityKey>,
+    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         Ok(BTreeMap::new())
     }
 
-    fn get_derived(
+    async fn get_derived(
         &self,
         _query: &DerivedEntityQuery,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
@@ -1054,13 +919,20 @@ impl ReadStore for EmptyStore {
 /// in a database table
 #[derive(Clone, Debug)]
 pub struct VersionStats {
-    pub entities: i32,
-    pub versions: i32,
+    pub entities: i64,
+    pub versions: i64,
     pub tablename: String,
     /// The ratio `entities / versions`
     pub ratio: f64,
     /// The last block to which this table was pruned
     pub last_pruned_block: Option<BlockNumber>,
+    /// Histograms for the upper bounds of the block ranges in
+    /// this table. Each histogram bucket contains roughly the same number
+    /// of rows; values might be repeated to achieve that. The vectors are
+    /// empty if the table hasn't been analyzed, the subgraph is stored in
+    /// Postgres version 16 or lower, or if the table doesn't have a
+    /// block_range column.
+    pub block_range_upper: Vec<BlockNumber>,
 }
 
 /// What phase of pruning we are working on
@@ -1112,6 +984,75 @@ pub trait PruneReporter: Send + 'static {
     fn finish(&mut self) {}
 }
 
+/// Callbacks for `SubgraphStore.dump` so that callers can report progress
+/// of the dump procedure to users
+#[allow(unused_variables)]
+pub trait DumpReporter: Send + 'static {
+    /// Called at the start with deployment hash and total entity table count.
+    fn start(&mut self, deployment: &str, table_count: usize) {}
+
+    /// Called before dumping an entity table. `rows_approx` is estimated
+    /// from the vid range (max_vid - min_vid + 1), 0 if empty.
+    fn start_table(&mut self, table: &str, rows_approx: usize) {}
+
+    /// Called after a batch of rows has been written to Parquet.
+    fn batch_dumped(&mut self, table: &str, rows: usize) {}
+
+    /// Called after an entity table has been fully dumped.
+    fn finish_table(&mut self, table: &str, rows: usize) {}
+
+    /// Called before dumping data_sources$.
+    fn start_data_sources(&mut self) {}
+
+    /// Called after data_sources$ has been dumped.
+    fn finish_data_sources(&mut self, rows: usize) {}
+
+    /// Called before dumping clamps for a table.
+    fn start_clamps(&mut self, _table: &str, _rows_approx: usize) {}
+
+    /// Called after clamps have been dumped for a table.
+    fn finish_clamps(&mut self, _table: &str, _rows: usize) {}
+
+    /// Called when the entire dump has completed.
+    fn finish(&mut self) {}
+}
+
+/// Callbacks for `SubgraphStore.restore` so that callers can report
+/// progress of the restore procedure to users
+#[allow(unused_variables)]
+pub trait RestoreReporter: Send + 'static {
+    /// Called at the start with deployment hash and total entity table count.
+    fn start(&mut self, deployment: &str, table_count: usize) {}
+
+    /// Called when creating the schema.
+    fn start_create_schema(&mut self, namespace: &str, shard: &str) {}
+    fn finish_create_schema(&mut self) {}
+
+    /// Called before importing an entity table. `total_rows` is the sum
+    /// of row counts across all chunks for this table.
+    fn start_table(&mut self, table: &str, total_rows: usize) {}
+
+    /// Called after a batch of rows has been inserted.
+    fn batch_imported(&mut self, table: &str, rows: usize) {}
+
+    /// Called when a table is skipped because it was already restored.
+    fn skip_table(&mut self, table: &str) {}
+
+    /// Called after an entity table has been fully imported.
+    fn finish_table(&mut self, table: &str, rows: usize) {}
+
+    /// Called before/after importing data_sources$.
+    fn start_data_sources(&mut self, total_rows: usize) {}
+    fn finish_data_sources(&mut self, rows: usize) {}
+
+    /// Called during finalization (sequence resets, head block set).
+    fn start_finalize(&mut self) {}
+    fn finish_finalize(&mut self) {}
+
+    /// Called when the entire restore has completed.
+    fn finish(&mut self) {}
+}
+
 /// Select how pruning should be done
 #[derive(Clone, Copy, Debug, Display, PartialEq)]
 pub enum PruningStrategy {
@@ -1136,6 +1077,9 @@ pub struct PruneRequest {
     pub earliest_block: BlockNumber,
     /// The last block that contains final entities not subject to a reorg
     pub final_block: BlockNumber,
+    /// The first block for which the deployment contained entities when the
+    /// request was made
+    pub first_block: BlockNumber,
     /// The latest block, i.e., the subgraph head
     pub latest_block: BlockNumber,
     /// Use the rebuild strategy when removing more than this fraction of
@@ -1163,18 +1107,18 @@ impl PruneRequest {
     ) -> Result<Self, StoreError> {
         let rebuild_threshold = ENV_VARS.store.rebuild_threshold;
         let delete_threshold = ENV_VARS.store.delete_threshold;
-        if rebuild_threshold < 0.0 || rebuild_threshold > 1.0 {
-            return Err(constraint_violation!(
+        if !(0.0..=1.0).contains(&rebuild_threshold) {
+            return Err(internal_error!(
                 "the copy threshold must be between 0 and 1 but is {rebuild_threshold}"
             ));
         }
-        if delete_threshold < 0.0 || delete_threshold > 1.0 {
-            return Err(constraint_violation!(
+        if !(0.0..=1.0).contains(&delete_threshold) {
+            return Err(internal_error!(
                 "the delete threshold must be between 0 and 1 but is {delete_threshold}"
             ));
         }
         if history_blocks <= reorg_threshold {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "the deployment {} needs to keep at least {} blocks \
                    of history and can't be pruned to only {} blocks of history",
                 deployment,
@@ -1183,13 +1127,22 @@ impl PruneRequest {
             ));
         }
         if first_block >= latest_block {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "the earliest block {} must be before the latest block {}",
                 first_block,
                 latest_block
             ));
         }
 
+        // Note: this intentionally keeps `history_blocks + 1` blocks on disk.
+        // The range [earliest_block, latest_block] is inclusive on both ends,
+        // so it contains `history_blocks + 1` entries. The extra block is a
+        // required buffer: `revert_block_ptr` requires at least
+        // `reorg_threshold + 2` actual blocks on disk to allow even a
+        // single-block reorg after pruning, and `strategy` requires
+        // `earliest_block < final_block`. Both conditions are satisfied when
+        // `history_blocks >= reorg_threshold + 1`, which gives
+        // `reorg_threshold + 2` blocks on disk.
         let earliest_block = latest_block - history_blocks;
         let final_block = latest_block - reorg_threshold;
 
@@ -1199,6 +1152,7 @@ impl PruneRequest {
             earliest_block,
             final_block,
             latest_block,
+            first_block,
             rebuild_threshold,
             delete_threshold,
         })
@@ -1220,11 +1174,22 @@ impl PruneRequest {
             return None;
         }
 
-        // Estimate how much data we will throw away; we assume that
-        // entity versions are distributed evenly across all blocks so
-        // that `history_pct` will tell us how much of that data pruning
-        // will remove.
-        let removal_ratio = self.history_pct(stats) * (1.0 - stats.ratio);
+        let removal_ratio = if stats.block_range_upper.is_empty()
+            || ENV_VARS.store.prune_disable_range_bound_estimation
+        {
+            // Estimate how much data we will throw away; we assume that
+            // entity versions are distributed evenly across all blocks so
+            // that `history_pct` will tell us how much of that data pruning
+            // will remove.
+            self.history_pct(stats) * (1.0 - stats.ratio)
+        } else {
+            // This estimate is more accurate than the one above since it
+            // does not assume anything about the distribution of entities
+            // and versions but uses the estimates from Postgres statistics.
+            // Of course, we can only use it if we have statistics
+            self.remove_pct_from_bounds(stats)
+        };
+
         if removal_ratio >= self.rebuild_threshold {
             Some(PruningStrategy::Rebuild)
         } else if removal_ratio >= self.delete_threshold {
@@ -1249,6 +1214,18 @@ impl PruneRequest {
             1.0 - self.history_blocks as f64 / total_blocks as f64
         }
     }
+
+    /// Return the fraction of entities that we will remove according to the
+    /// histogram bounds in `stats`. That fraction can be estimated as the
+    /// fraction of histogram buckets that end before `self.earliest_block`
+    fn remove_pct_from_bounds(&self, stats: &VersionStats) -> f64 {
+        stats
+            .block_range_upper
+            .iter()
+            .filter(|b| **b <= self.earliest_block)
+            .count() as f64
+            / stats.block_range_upper.len() as f64
+    }
 }
 
 /// Represents an item retrieved from an
@@ -1262,7 +1239,7 @@ pub struct CachedEthereumCall {
     pub block_ptr: BlockPtr,
 
     /// The address to the called contract.
-    pub contract_address: ethabi::Address,
+    pub contract_address: Address,
 
     /// The encoded return value of this call.
     pub return_value: Vec<u8>,
diff --git a/graph/src/components/store/traits.rs b/graph/src/components/store/traits.rs
index 95463f9801d..0249e999da6 100644
--- a/graph/src/components/store/traits.rs
+++ b/graph/src/components/store/traits.rs
@@ -1,58 +1,65 @@
+use std::collections::HashMap;
+use std::ops::Range;
+
 use anyhow::Error;
 use async_trait::async_trait;
-use web3::types::{Address, H256};
 
 use super::*;
-use crate::blockchain::block_stream::FirehoseCursor;
-use crate::blockchain::BlockTime;
+use crate::blockchain::block_stream::{EntitySourceOperation, FirehoseCursor};
+use crate::blockchain::{BlockTime, ChainIdentifier, ExtendedBlockPtr};
+use crate::components::ethereum::CachedBlock;
 use crate::components::metrics::stopwatch::StopwatchMetrics;
+use crate::components::network_provider::ChainName;
 use crate::components::server::index_node::VersionInfo;
 use crate::components::subgraph::SubgraphVersionSwitchingMode;
 use crate::components::transaction_receipt;
 use crate::components::versions::ApiVersion;
 use crate::data::query::Trace;
-use crate::data::store::QueryObject;
-use crate::data::subgraph::{status, DeploymentFeatures};
+use crate::data::store::ethereum::call;
+use crate::data::store::{QueryObject, SqlQueryObject};
+use crate::data::subgraph::{DeploymentFeatures, status};
 use crate::data::{query::QueryTarget, subgraph::schema::*};
-use crate::prelude::{DeploymentState, NodeId, QueryExecutionError, SubgraphName};
+use crate::prelude::{
+    DeploymentState, NodeId, QueryExecutionError, SubgraphName,
+    alloy::primitives::{Address, B256},
+};
 use crate::schema::{ApiSchema, InputSchema};
 
 pub trait SubscriptionManager: Send + Sync + 'static {
     /// Subscribe to changes for specific subgraphs and entities.
     ///
     /// Returns a stream of store events that match the input arguments.
-    fn subscribe(&self, entities: BTreeSet<SubscriptionFilter>) -> StoreEventStreamBox;
-
-    /// If the payload is not required, use for a more efficient subscription mechanism backed by a watcher.
-    fn subscribe_no_payload(&self, entities: BTreeSet<SubscriptionFilter>) -> UnitStream;
+    fn subscribe(&self) -> StoreEventStreamBox;
 }
 
 /// Subgraph forking is the process of lazily fetching entities
 /// from another subgraph's store (usually a remote one).
+#[async_trait]
 pub trait SubgraphFork: Send + Sync + 'static {
-    fn fetch(&self, entity_type: String, id: String) -> Result<Option<Entity>, StoreError>;
+    async fn fetch(&self, entity_type: String, id: String) -> Result<Option<Entity>, StoreError>;
 }
 
 /// A special trait to handle looking up ENS names from special rainbow
 /// tables that need to be manually loaded into the system
+#[async_trait]
 pub trait EnsLookup: Send + Sync + 'static {
     /// Find the reverse of keccak256 for `hash` through looking it up in the
     /// rainbow table.
-    fn find_name(&self, hash: &str) -> Result<Option<String>, StoreError>;
+    async fn find_name(&self, hash: &str) -> Result<Option<String>, StoreError>;
     // Check if the rainbow table is filled.
-    fn is_table_empty(&self) -> Result<bool, StoreError>;
+    async fn is_table_empty(&self) -> Result<bool, StoreError>;
 }
 
 /// An entry point for all operations that require access to the node's storage
 /// layer. It provides access to a [`BlockStore`] and a [`SubgraphStore`].
 pub trait Store: Clone + StatusStore + Send + Sync + 'static {
     /// The [`BlockStore`] implementor used by this [`Store`].
-    type BlockStore: BlockStore;
+    type BlockStore: BlockStore + CheapClone;
 
     /// The [`SubgraphStore`] implementor used by this [`Store`].
     type SubgraphStore: SubgraphStore;
 
-    fn block_store(&self) -> Arc<Self::BlockStore>;
+    fn block_store(&self) -> Self::BlockStore;
 
     fn subgraph_store(&self) -> Arc<Self::SubgraphStore>;
 }
@@ -65,7 +72,7 @@ pub trait SubgraphStore: Send + Sync + 'static {
     /// Check if the store is accepting queries for the specified subgraph.
     /// May return true even if the specified subgraph is not currently assigned to an indexing
     /// node, as the store will still accept queries.
-    fn is_deployed(&self, id: &DeploymentHash) -> Result<bool, StoreError>;
+    async fn is_deployed(&self, id: &DeploymentHash) -> Result<bool, StoreError>;
 
     async fn subgraph_features(
         &self,
@@ -76,7 +83,7 @@ pub trait SubgraphStore: Send + Sync + 'static {
     /// already exists (as identified by the `schema.id`), reuse that, otherwise
     /// create a new deployment, and point the current or pending version of
     /// `name` at it, depending on the `mode`
-    fn create_subgraph_deployment(
+    async fn create_subgraph_deployment(
         &self,
         name: SubgraphName,
         schema: &InputSchema,
@@ -87,65 +94,84 @@ pub trait SubgraphStore: Send + Sync + 'static {
     ) -> Result<DeploymentLocator, StoreError>;
 
     /// Create a subgraph_feature record in the database
-    fn create_subgraph_features(&self, features: DeploymentFeatures) -> Result<(), StoreError>;
+    async fn create_subgraph_features(
+        &self,
+        features: DeploymentFeatures,
+    ) -> Result<(), StoreError>;
 
     /// Create a new subgraph with the given name. If one already exists, use
     /// the existing one. Return the `id` of the newly created or existing
     /// subgraph
-    fn create_subgraph(&self, name: SubgraphName) -> Result<String, StoreError>;
+    async fn create_subgraph(&self, name: SubgraphName) -> Result<String, StoreError>;
 
-    /// Remove a subgraph and all its versions; if deployments that were used
-    /// by this subgraph do not need to be indexed anymore, also remove
+    /// Remove a subgraph and all its versions; if deployments that were
+    /// used by this subgraph do not need to be indexed anymore, also remove
     /// their assignment, but keep the deployments themselves around
-    fn remove_subgraph(&self, name: SubgraphName) -> Result<(), StoreError>;
+    ///
+    /// Returns the hashes of all deployments that were associated with the
+    /// removed name
+    async fn remove_subgraph(&self, name: SubgraphName) -> Result<Vec<DeploymentHash>, StoreError>;
 
     /// Assign the subgraph with `id` to the node `node_id`. If there is no
     /// assignment for the given deployment, report an error.
-    fn reassign_subgraph(
+    async fn reassign_subgraph(
         &self,
         deployment: &DeploymentLocator,
         node_id: &NodeId,
     ) -> Result<(), StoreError>;
 
-    fn assigned_node(&self, deployment: &DeploymentLocator) -> Result<Option<NodeId>, StoreError>;
+    async fn unassign_subgraph(&self, deployment: &DeploymentLocator) -> Result<(), StoreError>;
+
+    async fn pause_subgraph(&self, deployment: &DeploymentLocator) -> Result<(), StoreError>;
+
+    async fn resume_subgraph(&self, deployment: &DeploymentLocator) -> Result<(), StoreError>;
+
+    async fn assigned_node(
+        &self,
+        deployment: &DeploymentLocator,
+    ) -> Result<Option<NodeId>, StoreError>;
 
     /// Returns Option<(node_id,is_paused)> where `node_id` is the node that
     /// the subgraph is assigned to, and `is_paused` is true if the
     /// subgraph is paused.
     /// Returns None if the deployment does not exist.
-    fn assignment_status(
+    async fn assignment_status(
         &self,
         deployment: &DeploymentLocator,
     ) -> Result<Option<(NodeId, bool)>, StoreError>;
 
-    fn assignments(&self, node: &NodeId) -> Result<Vec<DeploymentLocator>, StoreError>;
-
     /// Returns assignments that are not paused
-    fn active_assignments(&self, node: &NodeId) -> Result<Vec<DeploymentLocator>, StoreError>;
+    async fn active_assignments(&self, node: &NodeId)
+    -> Result<Vec<DeploymentLocator>, StoreError>;
 
     /// Return `true` if a subgraph `name` exists, regardless of whether the
     /// subgraph has any deployments attached to it
-    fn subgraph_exists(&self, name: &SubgraphName) -> Result<bool, StoreError>;
+    async fn subgraph_exists(&self, name: &SubgraphName) -> Result<bool, StoreError>;
 
     /// Returns a collection of all [`EntityModification`] items in relation to
     /// the given [`BlockNumber`]. No distinction is made between inserts and
     /// updates, which may be returned as either [`EntityModification::Insert`]
     /// or [`EntityModification::Overwrite`].
-    fn entity_changes_in_block(
+    async fn entity_changes_in_block(
         &self,
         subgraph_id: &DeploymentHash,
         block_number: BlockNumber,
     ) -> Result<Vec<EntityOperation>, StoreError>;
 
     /// Return the GraphQL schema supplied by the user
-    fn input_schema(&self, subgraph_id: &DeploymentHash) -> Result<InputSchema, StoreError>;
+    async fn input_schema(&self, subgraph_id: &DeploymentHash) -> Result<InputSchema, StoreError>;
 
     /// Return a bool represeting whether there is a pending graft for the subgraph
-    fn graft_pending(&self, id: &DeploymentHash) -> Result<bool, StoreError>;
+    async fn graft_pending(&self, id: &DeploymentHash) -> Result<bool, StoreError>;
 
     /// Return the GraphQL schema that was derived from the user's schema by
     /// adding a root query type etc. to it
-    fn api_schema(
+    ///
+    /// We use the store as a cache for the `ApiSchema`, so that we do not
+    /// have to rebuild the `ApiSchema` from `InputSchema.api_schema()` for
+    /// every query. That's a bit clumsy and it might be better to make the
+    /// `InputSchema` the cache instead.
+    async fn api_schema(
         &self,
         subgraph_id: &DeploymentHash,
         api_version: &ApiVersion,
@@ -153,7 +179,7 @@ pub trait SubgraphStore: Send + Sync + 'static {
 
     /// Return a `SubgraphFork`, derived from the user's `debug-fork` deployment argument,
     /// that is used for debugging purposes only.
-    fn debug_fork(
+    async fn debug_fork(
         &self,
         subgraph_id: &DeploymentHash,
         logger: Logger,
@@ -178,6 +204,11 @@ pub trait SubgraphStore: Send + Sync + 'static {
         manifest_idx_and_name: Arc<Vec<(u32, String)>>,
     ) -> Result<Arc<dyn WritableStore>, StoreError>;
 
+    async fn sourceable(
+        self: Arc<Self>,
+        deployment: DeploymentId,
+    ) -> Result<Arc<dyn SourceableStore>, StoreError>;
+
     /// Initiate a graceful shutdown of the writable that a previous call to
     /// `writable` might have started
     async fn stop_subgraph(&self, deployment: &DeploymentLocator) -> Result<(), StoreError>;
@@ -188,40 +219,57 @@ pub trait SubgraphStore: Send + Sync + 'static {
     /// being set up
     async fn least_block_ptr(&self, id: &DeploymentHash) -> Result<Option<BlockPtr>, StoreError>;
 
+    /// Return the earliest block for which the deployment with the given
+    /// `id` still has entity data. Blocks below this are either pre-`startBlock`
+    /// or have been removed by pruning, and cannot serve as a graft or copy
+    /// source.
+    async fn earliest_block_number(&self, id: &DeploymentHash) -> Result<BlockNumber, StoreError>;
+
     async fn is_healthy(&self, id: &DeploymentHash) -> Result<bool, StoreError>;
 
     /// Find all deployment locators for the subgraph with the given hash.
-    fn locators(&self, hash: &str) -> Result<Vec<DeploymentLocator>, StoreError>;
+    async fn locators(&self, hash: &str) -> Result<Vec<DeploymentLocator>, StoreError>;
 
     /// Find the deployment locator for the active deployment with the given
     /// hash. Returns `None` if there is no deployment with that hash
-    fn active_locator(&self, hash: &str) -> Result<Option<DeploymentLocator>, StoreError>;
+    async fn active_locator(&self, hash: &str) -> Result<Option<DeploymentLocator>, StoreError>;
+
+    /// Return `true` if the `instrument` flag for the deployment is set.
+    /// When this flag is set, indexing of the deployment should log
+    /// additional diagnostic information
+    async fn instrument(&self, deployment: &DeploymentLocator) -> Result<bool, StoreError>;
 
-    /// This migrates subgraphs that existed before the raw_yaml column was added.
-    async fn set_manifest_raw_yaml(
+    /// Sets the raw subgraph manifest for the given deployment hash, if not previously set.
+    ///
+    /// Returns `Ok(())` regardless of whether the value was updated.
+    async fn set_raw_manifest_once(
         &self,
         hash: &DeploymentHash,
-        raw_yaml: String,
+        raw_manifest: &serde_yaml::Mapping,
     ) -> Result<(), StoreError>;
 
-    /// Return `true` if the `instrument` flag for the deployment is set.
-    /// When this flag is set, indexing of the deployment should log
-    /// additional diagnostic information
-    fn instrument(&self, deployment: &DeploymentLocator) -> Result<bool, StoreError>;
+    /// Returns the raw subgraph manifest for the given deployment hash, if one exists.
+    ///
+    /// Returns `None` if no manifest is found for the specified deployment hash.
+    async fn raw_manifest(
+        &self,
+        hash: &DeploymentHash,
+    ) -> Result<Option<serde_yaml::Mapping>, StoreError>;
 }
 
+#[async_trait]
 pub trait ReadStore: Send + Sync + 'static {
     /// Looks up an entity using the given store key at the latest block.
-    fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError>;
+    async fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError>;
 
     /// Look up multiple entities as of the latest block.
-    fn get_many(
+    async fn get_many(
         &self,
         keys: BTreeSet<EntityKey>,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError>;
 
     /// Reverse lookup
-    fn get_derived(
+    async fn get_derived(
         &self,
         query_derived: &DerivedEntityQuery,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError>;
@@ -230,23 +278,24 @@ pub trait ReadStore: Send + Sync + 'static {
 }
 
 // This silly impl is needed until https://github.com/rust-lang/rust/issues/65991 is stable.
+#[async_trait]
 impl<T: ?Sized + ReadStore> ReadStore for Arc<T> {
-    fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
-        (**self).get(key)
+    async fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
+        (**self).get(key).await
     }
 
-    fn get_many(
+    async fn get_many(
         &self,
         keys: BTreeSet<EntityKey>,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
-        (**self).get_many(keys)
+        (**self).get_many(keys).await
     }
 
-    fn get_derived(
+    async fn get_derived(
         &self,
         entity_derived: &DerivedEntityQuery,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
-        (**self).get_derived(entity_derived)
+        (**self).get_derived(entity_derived).await
     }
 
     fn input_schema(&self) -> InputSchema {
@@ -280,6 +329,46 @@ impl<T: ?Sized + DeploymentCursorTracker> DeploymentCursorTracker for Arc<T> {
     }
 }
 
+#[async_trait]
+pub trait SourceableStore: Sync + Send + 'static {
+    /// Returns all versions of entities of the given entity_type that were
+    /// changed in the given block_range.
+    async fn get_range(
+        &self,
+        entity_types: Vec<EntityType>,
+        causality_region: CausalityRegion,
+        block_range: Range<BlockNumber>,
+    ) -> Result<BTreeMap<BlockNumber, Vec<EntitySourceOperation>>, StoreError>;
+
+    fn input_schema(&self) -> InputSchema;
+
+    /// Get a pointer to the most recently processed block in the subgraph.
+    async fn block_ptr(&self) -> Result<Option<BlockPtr>, StoreError>;
+}
+
+// This silly impl is needed until https://github.com/rust-lang/rust/issues/65991 is stable.
+#[async_trait]
+impl<T: ?Sized + SourceableStore> SourceableStore for Arc<T> {
+    async fn get_range(
+        &self,
+        entity_types: Vec<EntityType>,
+        causality_region: CausalityRegion,
+        block_range: Range<BlockNumber>,
+    ) -> Result<BTreeMap<BlockNumber, Vec<EntitySourceOperation>>, StoreError> {
+        (**self)
+            .get_range(entity_types, causality_region, block_range)
+            .await
+    }
+
+    fn input_schema(&self) -> InputSchema {
+        (**self).input_schema()
+    }
+
+    async fn block_ptr(&self) -> Result<Option<BlockPtr>, StoreError> {
+        (**self).block_ptr().await
+    }
+}
+
 /// A view of the store for indexing. All indexing-related operations need
 /// to go through this trait. Methods in this trait will never return a
 /// `StoreError::DatabaseUnavailable`. Instead, they will retry the
@@ -309,7 +398,7 @@ pub trait WritableStore: ReadStore + DeploymentCursorTracker {
 
     /// If a non-deterministic error happened and the current deployment head is past the error
     /// block range, this function unfails the subgraph and deletes the error.
-    fn unfail_non_deterministic_error(
+    async fn unfail_non_deterministic_error(
         &self,
         current_ptr: &BlockPtr,
     ) -> Result<UnfailOutcome, StoreError>;
@@ -317,12 +406,15 @@ pub trait WritableStore: ReadStore + DeploymentCursorTracker {
     /// Set subgraph status to failed with the given error as the cause.
     async fn fail_subgraph(&self, error: SubgraphError) -> Result<(), StoreError>;
 
-    async fn supports_proof_of_indexing(&self) -> Result<bool, StoreError>;
-
     /// Transact the entity changes from a single block atomically into the store, and update the
     /// subgraph block pointer to `block_ptr_to`, and update the firehose cursor to `firehose_cursor`
     ///
     /// `block_ptr_to` must point to a child block of the current subgraph block pointer.
+    ///
+    /// `is_caught_up_with_chain_head` indicates if `block_ptr_to` is close enough to the chain head
+    /// to be considered 'caught up', for purposes such as setting the synced flag or turning off
+    /// write batching. This is as vague as it sounds, it is not deterministic and should be treated
+    /// as a hint only.
     async fn transact_block_operations(
         &self,
         block_ptr_to: BlockPtr,
@@ -334,18 +426,17 @@ pub trait WritableStore: ReadStore + DeploymentCursorTracker {
         deterministic_errors: Vec<SubgraphError>,
         offchain_to_remove: Vec<StoredDynamicDataSource>,
         is_non_fatal_errors_active: bool,
+        is_caught_up_with_chain_head: bool,
     ) -> Result<(), StoreError>;
 
-    /// The deployment `id` finished syncing, mark it as synced in the database
-    /// and promote it to the current version in the subgraphs where it was the
-    /// pending version so far
-    fn deployment_synced(&self) -> Result<(), StoreError>;
+    /// Force synced status, used for testing.
+    async fn deployment_synced(&self, block_ptr: BlockPtr) -> Result<(), StoreError>;
 
-    /// Return true if the deployment with the given id is fully synced,
-    /// and return false otherwise. Errors from the store are passed back up
-    async fn is_deployment_synced(&self) -> Result<bool, StoreError>;
+    /// Return true if the deployment with the given id is fully synced, and return false otherwise.
+    /// Cheap, cached operation.
+    fn is_deployment_synced(&self) -> bool;
 
-    fn unassign_subgraph(&self) -> Result<(), StoreError>;
+    async fn pause_subgraph(&self) -> Result<(), StoreError>;
 
     /// Load the dynamic data sources for the given deployment
     async fn load_dynamic_data_sources(
@@ -362,6 +453,12 @@ pub trait WritableStore: ReadStore + DeploymentCursorTracker {
 
     async fn health(&self) -> Result<SubgraphHealth, StoreError>;
 
+    /// Create indexes whose creation was postponed at deployment time.
+    /// This should be called when a subgraph gets close to the chain
+    /// head. Calling it when all postponed indexes already exist is safe
+    /// and a no-op.
+    async fn create_postponed_indexes(&self) -> Result<(), StoreError>;
+
     /// Wait for the background writer to finish processing its queue
     async fn flush(&self) -> Result<(), StoreError>;
 
@@ -387,31 +484,86 @@ pub trait QueryStoreManager: Send + Sync + 'static {
     /// which deployment will be queried. It is not possible to use the id of the
     /// metadata subgraph, though the resulting store can be used to query
     /// metadata about the deployment `id` (but not metadata about other deployments).
-    ///
-    /// If `for_subscription` is true, the main replica will always be used.
     async fn query_store(
         &self,
         target: QueryTarget,
-        for_subscription: bool,
     ) -> Result<Arc<dyn QueryStore + Send + Sync>, QueryExecutionError>;
 }
 
-pub trait BlockStore: Send + Sync + 'static {
+#[async_trait]
+pub trait BlockStore: ChainIdStore + Send + Sync + 'static {
     type ChainStore: ChainStore;
 
-    fn chain_store(&self, network: &str) -> Option<Arc<Self::ChainStore>>;
+    async fn chain_store(&self, network: &str) -> Option<Arc<Self::ChainStore>>;
+}
+
+/// An interface for tracking the chain head in the store used by most chain
+/// implementations
+#[async_trait]
+pub trait ChainHeadStore: Send + Sync {
+    /// Get the current head block pointer for this chain.
+    /// Any changes to the head block pointer will be to a block with a larger block number, never
+    /// to a block with a smaller or equal block number.
+    ///
+    /// The head block pointer will be None on initial set up.
+    async fn chain_head_ptr(self: Arc<Self>) -> Result<Option<BlockPtr>, Error>;
+
+    /// Get the current head block cursor for this chain.
+    ///
+    /// The head block cursor will be None on initial set up.
+    async fn chain_head_cursor(&self) -> Result<Option<String>, Error>;
+
+    /// This method does actually three operations:
+    /// - Upserts received block into blocks table
+    /// - Update chain head block into networks table
+    /// - Update chain head cursor into networks table
+    async fn set_chain_head(
+        self: Arc<Self>,
+        block: Arc<dyn Block>,
+        cursor: String,
+    ) -> Result<(), Error>;
+}
+
+#[async_trait]
+pub trait ChainIdStore: Send + Sync + 'static {
+    /// Return the chain identifier for this store.
+    async fn chain_identifier(&self, chain_name: &ChainName) -> Result<ChainIdentifier, Error>;
+
+    /// Update the chain identifier for this store.
+    async fn set_chain_identifier(
+        &self,
+        chain_name: &ChainName,
+        ident: &ChainIdentifier,
+    ) -> Result<(), Error>;
+}
+
+/// The default size for the block cache, i.e., how many blocks behind
+/// the chain head we should keep in the database cache. The
+/// configuration can change this for individual chains
+pub const BLOCK_CACHE_SIZE: BlockNumber = i32::MAX;
+
+/// Result of clearing stale call cache entries.
+pub struct StaleCallCacheResult {
+    /// The effective TTL in days that was actually used for deletion.
+    /// This may be larger than the requested TTL if `max_contracts`
+    /// was set and caused the cutoff to be adjusted.
+    pub effective_ttl_days: usize,
+    /// Number of cache entries deleted from the call cache.
+    pub cache_entries_deleted: usize,
+    /// Number of contract entries deleted from call meta.
+    pub contracts_deleted: usize,
 }
 
 /// Common trait for blockchain store implementations.
 #[async_trait]
-pub trait ChainStore: Send + Sync + 'static {
+pub trait ChainStore: ChainHeadStore {
     /// Get a pointer to this blockchain's genesis block.
-    fn genesis_block_ptr(&self) -> Result<BlockPtr, Error>;
+    async fn genesis_block_ptr(&self) -> Result<BlockPtr, Error>;
 
     /// Insert a block into the store (or update if they are already present).
     async fn upsert_block(&self, block: Arc<dyn Block>) -> Result<(), Error>;
 
-    fn upsert_light_blocks(&self, blocks: &[&dyn Block]) -> Result<(), Error>;
+    async fn upsert_light_blocks(&self, blocks: &[&dyn Block]) -> Result<(), Error>;
 
     /// Try to update the head block pointer to the block with the highest block number.
     ///
@@ -432,104 +584,151 @@ pub trait ChainStore: Send + Sync + 'static {
     async fn attempt_chain_head_update(
         self: Arc<Self>,
         ancestor_count: BlockNumber,
-    ) -> Result<Option<H256>, Error>;
+    ) -> Result<Option<B256>, Error>;
 
-    /// Get the current head block pointer for this chain.
-    /// Any changes to the head block pointer will be to a block with a larger block number, never
-    /// to a block with a smaller or equal block number.
-    ///
-    /// The head block pointer will be None on initial set up.
-    async fn chain_head_ptr(self: Arc<Self>) -> Result<Option<BlockPtr>, Error>;
+    /// Returns the blocks present in the store as typed cached blocks.
+    async fn blocks(self: Arc<Self>, hashes: Vec<BlockHash>) -> Result<Vec<CachedBlock>, Error>;
 
-    /// Get the current head block cursor for this chain.
-    ///
-    /// The head block cursor will be None on initial set up.
-    fn chain_head_cursor(&self) -> Result<Option<String>, Error>;
-
-    /// This method does actually three operations:
-    /// - Upserts received block into blocks table
-    /// - Update chain head block into networks table
-    /// - Update chain head cursor into networks table
-    async fn set_chain_head(
-        self: Arc<Self>,
-        block: Arc<dyn Block>,
-        cursor: String,
-    ) -> Result<(), Error>;
+    /// Return the parent block pointer for the block with the given hash.
+    /// Only reads header columns (hash, number, parent_hash), not the data
+    /// column. More efficient than `blocks` when only the parent pointer is
+    /// needed.
+    async fn block_parent_ptr(self: Arc<Self>, hash: &BlockHash)
+    -> Result<Option<BlockPtr>, Error>;
 
-    /// Returns the blocks present in the store.
-    async fn blocks(
+    /// Returns the blocks present in the store for the given block numbers.
+    async fn block_ptrs_by_numbers(
         self: Arc<Self>,
-        hashes: Vec<BlockHash>,
-    ) -> Result<Vec<serde_json::Value>, Error>;
+        numbers: Vec<BlockNumber>,
+    ) -> Result<BTreeMap<BlockNumber, Vec<ExtendedBlockPtr>>, Error>;
 
     /// Get the `offset`th ancestor of `block_hash`, where offset=0 means the block matching
-    /// `block_hash` and offset=1 means its parent. Returns None if unable to complete due to
-    /// missing blocks in the chain store.
+    /// `block_hash` and offset=1 means its parent. If `root` is passed, short-circuit upon finding
+    /// a child of `root`. Returns None if unable to complete due to missing blocks in the chain
+    /// store.
+    ///
+    /// The short-circuit mechanism is particularly useful in situations where blocks are skipped
+    /// in certain chains like Filecoin EVM. In such cases, relying solely on the numeric offset
+    /// might lead to inaccuracies because block numbers could be non-sequential. By allowing a
+    /// `root` block hash as a reference, the function can more accurately identify the desired
+    /// ancestor by stopping the search as soon as it discovers a block that is a direct child
+    /// of the `root` (i.e., when block.parent_hash equals root.hash). This approach ensures
+    /// the correct ancestor block is identified without solely depending on the offset.
     ///
     /// Returns an error if the offset would reach past the genesis block.
     async fn ancestor_block(
         self: Arc<Self>,
         block_ptr: BlockPtr,
         offset: BlockNumber,
-    ) -> Result<Option<serde_json::Value>, Error>;
+        root: Option<BlockHash>,
+    ) -> Result<Option<(CachedBlock, BlockPtr)>, Error>;
+
+    /// Like `ancestor_block` but returns only the block pointer, not the
+    /// block data. More efficient when callers only need to identify which
+    /// block is the ancestor without reading the full block body.
+    async fn ancestor_block_ptr(
+        self: Arc<Self>,
+        block_ptr: BlockPtr,
+        offset: BlockNumber,
+        root: Option<BlockHash>,
+    ) -> Result<Option<BlockPtr>, Error>;
 
     /// Remove old blocks from the cache we maintain in the database and
     /// return a pair containing the number of the oldest block retained
     /// and the number of blocks deleted.
     /// We will never remove blocks that are within `ancestor_count` of
     /// the chain head.
-    fn cleanup_cached_blocks(
+    async fn cleanup_cached_blocks(
         &self,
         ancestor_count: BlockNumber,
     ) -> Result<Option<(BlockNumber, usize)>, Error>;
 
     /// Return the hashes of all blocks with the given number
-    fn block_hashes_by_block_number(&self, number: BlockNumber) -> Result<Vec<BlockHash>, Error>;
+    async fn block_hashes_by_block_number(
+        &self,
+        number: BlockNumber,
+    ) -> Result<Vec<BlockHash>, Error>;
 
     /// Confirm that block number `number` has hash `hash` and that the store
     /// may purge any other blocks with that number
-    fn confirm_block_hash(&self, number: BlockNumber, hash: &BlockHash) -> Result<usize, Error>;
+    async fn confirm_block_hash(
+        &self,
+        number: BlockNumber,
+        hash: &BlockHash,
+    ) -> Result<usize, Error>;
 
-    /// Find the block with `block_hash` and return the network name, number and timestamp if present.
+    /// Find the block with `block_hash` and return the network name, number, timestamp and parentHash if present.
     /// Currently, the timestamp is only returned if it's present in the top level block. This format is
     /// depends on the chain and the implementation of Blockchain::Block for the specific chain.
     /// eg: {"block": { "timestamp": 123123123 } }
     async fn block_number(
         &self,
         hash: &BlockHash,
-    ) -> Result<Option<(String, BlockNumber, Option<u64>)>, StoreError>;
+    ) -> Result<Option<(String, BlockNumber, Option<u64>, Option<BlockHash>)>, StoreError>;
+
+    /// Do the same lookup as `block_number`, but in bulk
+    async fn block_numbers(
+        &self,
+        hashes: Vec<BlockHash>,
+    ) -> Result<HashMap<BlockHash, BlockNumber>, StoreError>;
 
     /// Tries to retrieve all transactions receipts for a given block.
     async fn transaction_receipts_in_block(
         &self,
-        block_ptr: &H256,
+        block_ptr: &B256,
     ) -> Result<Vec<transaction_receipt::LightTransactionReceipt>, StoreError>;
 
     /// Clears call cache of the chain for the given `from` and `to` block number.
     async fn clear_call_cache(&self, from: BlockNumber, to: BlockNumber) -> Result<(), Error>;
+
+    /// Clears stale call cache entries for the given TTL in days. If
+    /// `max_contracts` is set, increase the effective TTL so that at
+    /// most `max_contracts` contracts are evicted.
+    async fn clear_stale_call_cache(
+        &self,
+        ttl_days: usize,
+        max_contracts: Option<usize>,
+    ) -> Result<StaleCallCacheResult, Error>;
+
+    /// Return the chain identifier for this store.
+    async fn chain_identifier(&self) -> Result<ChainIdentifier, Error>;
+
+    /// Workaround for Rust issue #65991 that keeps us from using an
+    /// `Arc<dyn ChainStore>` as an `Arc<dyn ChainHeadStore>`
+    fn as_head_store(self: Arc<Self>) -> Arc<dyn ChainHeadStore>;
 }
 
+#[async_trait]
 pub trait EthereumCallCache: Send + Sync + 'static {
-    /// Returns the return value of the provided Ethereum call, if present in
-    /// the cache.
-    fn get_call(
+    /// Returns the return value of the provided Ethereum call, if present
+    /// in the cache. A return of `None` indicates that we know nothing
+    /// about the call.
+    async fn get_call(
         &self,
-        contract_address: ethabi::Address,
-        encoded_call: &[u8],
+        call: &call::Request,
         block: BlockPtr,
-    ) -> Result<Option<Vec<u8>>, Error>;
+    ) -> Result<Option<call::Response>, Error>;
+
+    /// Get the return values of many Ethereum calls. For the ones found in
+    /// the cache, return a `Response`; the ones that were not found are
+    /// returned as the original `Request`
+    async fn get_calls(
+        &self,
+        reqs: &[call::Request],
+        block: BlockPtr,
+    ) -> Result<(Vec<call::Response>, Vec<call::Request>), Error>;
 
     /// Returns all cached calls for a given `block`. This method does *not*
     /// update the last access time of the returned cached calls.
-    fn get_calls_in_block(&self, block: BlockPtr) -> Result<Vec<CachedEthereumCall>, Error>;
+    async fn get_calls_in_block(&self, block: BlockPtr) -> Result<Vec<CachedEthereumCall>, Error>;
 
     /// Stores the provided Ethereum call in the cache.
-    fn set_call(
-        &self,
-        contract_address: ethabi::Address,
-        encoded_call: &[u8],
+    async fn set_call(
+        self: Arc<Self>,
+        logger: &Logger,
+        call: call::Request,
         block: BlockPtr,
-        return_value: &[u8],
+        return_value: call::Retval,
     ) -> Result<(), Error>;
 }
 
@@ -541,42 +740,47 @@ pub struct QueryPermit {
 /// Store operations used when serving queries for a specific deployment
 #[async_trait]
 pub trait QueryStore: Send + Sync {
-    fn find_query_values(
+    async fn find_query_values(
         &self,
         query: EntityQuery,
     ) -> Result<(Vec<QueryObject>, Trace), QueryExecutionError>;
 
+    async fn execute_sql(&self, sql: &str) -> Result<Vec<SqlQueryObject>, QueryExecutionError>;
+
     async fn is_deployment_synced(&self) -> Result<bool, Error>;
 
     async fn block_ptr(&self) -> Result<Option<BlockPtr>, StoreError>;
 
     async fn block_number(&self, block_hash: &BlockHash)
-        -> Result<Option<BlockNumber>, StoreError>;
+    -> Result<Option<BlockNumber>, StoreError>;
+
+    async fn block_numbers(
+        &self,
+        block_hashes: Vec<BlockHash>,
+    ) -> Result<HashMap<BlockHash, BlockNumber>, StoreError>;
 
-    /// Returns the blocknumber as well as the timestamp. Timestamp depends on the chain block type
+    /// Returns the blocknumber, timestamp and the parentHash. Timestamp depends on the chain block type
     /// and can have multiple formats, it can also not be prevent. For now this is only available
     /// for EVM chains both firehose and rpc.
-    async fn block_number_with_timestamp(
+    async fn block_number_with_timestamp_and_parent_hash(
         &self,
         block_hash: &BlockHash,
-    ) -> Result<Option<(BlockNumber, Option<u64>)>, StoreError>;
-
-    fn wait_stats(&self) -> Result<PoolWaitStats, StoreError>;
+    ) -> Result<Option<(BlockNumber, Option<u64>, Option<BlockHash>)>, StoreError>;
 
-    async fn has_deterministic_errors(&self, block: BlockNumber) -> Result<bool, StoreError>;
+    fn wait_stats(&self) -> PoolWaitStats;
 
     /// Find the current state for the subgraph deployment `id` and
     /// return details about it needed for executing queries
     async fn deployment_state(&self) -> Result<DeploymentState, QueryExecutionError>;
 
-    fn api_schema(&self) -> Result<Arc<ApiSchema>, QueryExecutionError>;
+    async fn api_schema(&self) -> Result<Arc<ApiSchema>, QueryExecutionError>;
 
-    fn input_schema(&self) -> Result<InputSchema, QueryExecutionError>;
+    async fn input_schema(&self) -> Result<InputSchema, QueryExecutionError>;
 
     fn network_name(&self) -> &str;
 
     /// A permit should be acquired before starting query execution.
-    async fn query_permit(&self) -> Result<QueryPermit, StoreError>;
+    async fn query_permit(&self) -> QueryPermit;
 
     /// Report the name of the shard in which the subgraph is stored. This
     /// should only be used for reporting and monitoring
@@ -591,25 +795,25 @@ pub trait QueryStore: Send + Sync {
 #[async_trait]
 pub trait StatusStore: Send + Sync + 'static {
     /// A permit should be acquired before starting query execution.
-    async fn query_permit(&self) -> Result<QueryPermit, StoreError>;
+    async fn query_permit(&self) -> QueryPermit;
 
-    fn status(&self, filter: status::Filter) -> Result<Vec<status::Info>, StoreError>;
+    async fn status(&self, filter: status::Filter) -> Result<Vec<status::Info>, StoreError>;
 
     /// Support for the explorer-specific API
-    fn version_info(&self, version_id: &str) -> Result<VersionInfo, StoreError>;
+    async fn version_info(&self, version_id: &str) -> Result<VersionInfo, StoreError>;
 
     /// Support for the explorer-specific API; note that `subgraph_id` must be
     /// the id of an entry in `subgraphs.subgraph`, not that of a deployment.
     /// The return values are the ids of the `subgraphs.subgraph_version` for
     /// the current and pending versions of the subgraph
-    fn versions_for_subgraph_id(
+    async fn versions_for_subgraph_id(
         &self,
         subgraph_id: &str,
     ) -> Result<(Option<String>, Option<String>), StoreError>;
 
     /// Support for the explorer-specific API. Returns a vector of (name, version) of all
     /// subgraphs for a given deployment hash.
-    fn subgraphs_for_deployment_hash(
+    async fn subgraphs_for_deployment_hash(
         &self,
         deployment_hash: &str,
     ) -> Result<Vec<(String, String)>, StoreError>;
diff --git a/graph/src/components/store/write.rs b/graph/src/components/store/write.rs
index aed8f6734bb..1a29714e51e 100644
--- a/graph/src/components/store/write.rs
+++ b/graph/src/components/store/write.rs
@@ -1,18 +1,24 @@
 //! Data structures and helpers for writing subgraph changes to the store
-use std::collections::HashSet;
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+
+use slog::Logger;
 
 use crate::{
-    blockchain::{block_stream::FirehoseCursor, BlockPtr, BlockTime},
+    blockchain::{BlockPtr, BlockTime, block_stream::FirehoseCursor},
     cheap_clone::CheapClone,
     components::subgraph::Entity,
-    constraint_violation,
     data::{store::Id, subgraph::schema::SubgraphError},
     data_source::CausalityRegion,
-    prelude::DeploymentHash,
+    derive::CacheWeight,
+    env::ENV_VARS,
+    internal_error,
     util::cache_weight::CacheWeight,
 };
 
-use super::{BlockNumber, EntityKey, EntityType, StoreError, StoreEvent, StoredDynamicDataSource};
+use super::{BlockNumber, EntityKey, EntityType, StoreError, StoredDynamicDataSource};
 
 /// A data structure similar to `EntityModification`, but tagged with a
 /// block. We might eventually replace `EntityModification` with this, but
@@ -36,19 +42,19 @@ use super::{BlockNumber, EntityKey, EntityType, StoreError, StoreEvent, StoredDy
 /// `append_row`, eliminates an update in the database which would otherwise
 /// be needed to clamp the open block range of the entity to the block
 /// contained in `end`
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, CacheWeight, Debug, PartialEq, Eq)]
 pub enum EntityModification {
     /// Insert the entity
     Insert {
         key: EntityKey,
-        data: Entity,
+        data: Arc<Entity>,
         block: BlockNumber,
         end: Option<BlockNumber>,
     },
     /// Update the entity by overwriting it
     Overwrite {
         key: EntityKey,
-        data: Entity,
+        data: Arc<Entity>,
         block: BlockNumber,
         end: Option<BlockNumber>,
     },
@@ -68,6 +74,16 @@ pub struct EntityWrite<'a> {
     pub end: Option<BlockNumber>,
 }
 
+impl std::fmt::Display for EntityWrite<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let range = match self.end {
+            Some(end) => format!("[{}, {}]", self.block, end - 1),
+            None => format!("[{}, ∞)", self.block),
+        };
+        write!(f, "{}@{}", self.id, range)
+    }
+}
+
 impl<'a> TryFrom<&'a EntityModification> for EntityWrite<'a> {
     type Error = ();
 
@@ -78,8 +94,14 @@ impl<'a> TryFrom<&'a EntityModification> for EntityWrite<'a> {
                 data,
                 block,
                 end,
-            }
-            | EntityModification::Overwrite {
+            } => Ok(EntityWrite {
+                id: &key.entity_id,
+                entity: data,
+                causality_region: key.causality_region,
+                block: *block,
+                end: *end,
+            }),
+            EntityModification::Overwrite {
                 key,
                 data,
                 block,
@@ -125,7 +147,7 @@ impl EntityModification {
 
     /// Return the details of the write if `self` is a write operation for a
     /// new or an existing entity
-    fn as_write(&self) -> Option<EntityWrite> {
+    fn as_write(&self) -> Option<EntityWrite<'_>> {
         EntityWrite::try_from(self).ok()
     }
 
@@ -138,9 +160,10 @@ impl EntityModification {
     }
 
     pub fn creates_entity(&self) -> bool {
+        use EntityModification::*;
         match self {
-            EntityModification::Insert { .. } => true,
-            EntityModification::Overwrite { .. } | EntityModification::Remove { .. } => false,
+            Insert { .. } => true,
+            Overwrite { .. } | Remove { .. } => false,
         }
     }
 
@@ -166,7 +189,7 @@ impl EntityModification {
         match self {
             Insert { end, .. } | Overwrite { end, .. } => {
                 if end.is_some() {
-                    return Err(constraint_violation!(
+                    return Err(internal_error!(
                         "can not clamp {:?} to block {}",
                         self,
                         block
@@ -175,18 +198,18 @@ impl EntityModification {
                 *end = Some(block);
             }
             Remove { .. } => {
-                return Err(constraint_violation!(
+                return Err(internal_error!(
                     "can not clamp block range for removal of {:?} to {}",
                     self,
                     block
-                ))
+                ));
             }
         }
         Ok(())
     }
 
     /// Turn an `Overwrite` into an `Insert`, return an error if this is a `Remove`
-    fn as_insert(self, entity_type: &EntityType) -> Result<Self, StoreError> {
+    fn into_insert(self, entity_type: &EntityType) -> Result<Self, StoreError> {
         use EntityModification::*;
 
         match self {
@@ -202,13 +225,11 @@ impl EntityModification {
                 block,
                 end,
             }),
-            Remove { key, .. } => {
-                return Err(constraint_violation!(
-                    "a remove for {}[{}] can not be converted into an insert",
-                    entity_type,
-                    key.entity_id
-                ))
-            }
+            Remove { key, .. } => Err(internal_error!(
+                "a remove for {}[{}] can not be converted into an insert",
+                entity_type,
+                key.entity_id
+            )),
         }
     }
 
@@ -257,7 +278,7 @@ impl EntityModification {
     pub fn insert(key: EntityKey, data: Entity, block: BlockNumber) -> Self {
         EntityModification::Insert {
             key,
-            data,
+            data: Arc::new(data),
             block,
             end: None,
         }
@@ -266,7 +287,7 @@ impl EntityModification {
     pub fn overwrite(key: EntityKey, data: Entity, block: BlockNumber) -> Self {
         EntityModification::Overwrite {
             key,
-            data,
+            data: Arc::new(data),
             block,
             end: None,
         }
@@ -284,24 +305,58 @@ impl EntityModification {
     }
 }
 
+/// A map from entity ids to the index of the last modification for that id.
+/// If `ENV_VARS.store.write_batch_memoize` is `false`, this map is never
+/// written to and always empty
+#[derive(Debug, CacheWeight)]
+struct LastMod {
+    /// If `ENV_VARS.store.write_batch_memoize` is `false`, we never write
+    /// into this map
+    map: HashMap<Id, usize>,
+}
+
+impl LastMod {
+    fn new() -> LastMod {
+        LastMod {
+            map: HashMap::new(),
+        }
+    }
+
+    fn get(&self, id: &Id) -> Option<&usize> {
+        if ENV_VARS.store.write_batch_memoize {
+            return self.map.get(id);
+        }
+        None
+    }
+
+    fn insert(&mut self, id: Id, idx: usize) {
+        if ENV_VARS.store.write_batch_memoize {
+            self.map.insert(id, idx);
+        }
+    }
+}
+
 /// A list of entity changes grouped by the entity type
-#[derive(Debug)]
+#[derive(Debug, CacheWeight)]
 pub struct RowGroup {
     pub entity_type: EntityType,
+
     /// All changes for this entity type, ordered by block; i.e., if `i < j`
     /// then `rows[i].block() <= rows[j].block()`. Several methods on this
     /// struct rely on the fact that this ordering is observed.
     rows: Vec<EntityModification>,
 
-    immutable: bool,
+    /// Map the `key.entity_id` of all entries in `rows` to the index with
+    /// the most recent entry for that id to speed up lookups.
+    last_mod: LastMod,
 }
 
 impl RowGroup {
-    pub fn new(entity_type: EntityType, immutable: bool) -> Self {
+    pub fn new(entity_type: EntityType) -> Self {
         Self {
             entity_type,
             rows: Vec::new(),
-            immutable,
+            last_mod: LastMod::new(),
         }
     }
 
@@ -314,7 +369,7 @@ impl RowGroup {
         if !is_forward {
             // unwrap: we only get here when `last()` is `Some`
             let last_block = self.rows.last().map(|emod| emod.block()).unwrap();
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "we already have a modification for block {}, can not append {:?}",
                 last_block,
                 emod
@@ -358,6 +413,22 @@ impl RowGroup {
     }
 
     pub fn last_op(&self, key: &EntityKey, at: BlockNumber) -> Option<EntityOp<'_>> {
+        // If we have `key` in `last_mod`, use that and return the
+        // corresponding op. If not, fall through to a more expensive search
+        if let Some(&idx) = self.last_mod.get(&key.entity_id)
+            && let Some(op) = self.rows.get(idx).and_then(|emod| {
+                if emod.block() <= at {
+                    Some(emod.as_entity_op(at))
+                } else {
+                    None
+                }
+            })
+        {
+            return Some(op);
+        }
+        // We are looking for the change at a block `at` that is before the
+        // change we remember in `last_mod`, and therefore have to scan
+        // through all changes
         self.rows
             .iter()
             // We are scanning backwards, i.e., in descendng order of
@@ -367,7 +438,14 @@ impl RowGroup {
             .map(|emod| emod.as_entity_op(at))
     }
 
+    /// Return an iterator over all changes that are effective at `at`. That
+    /// makes it possible to construct the state that the deployment will
+    /// have once all changes for block `at` have been written.
     pub fn effective_ops(&self, at: BlockNumber) -> impl Iterator<Item = EntityOp<'_>> {
+        // We don't use `self.last_mod` here, because we need to return
+        // operations for all entities that have pending changes at block
+        // `at`, and there is no guarantee that `self.last_mod` is visible
+        // at `at` since the change in `self.last_mod` might come after `at`
         let mut seen = HashSet::new();
         self.rows
             .iter()
@@ -384,19 +462,52 @@ impl RowGroup {
 
     /// Find the most recent entry for `id`
     fn prev_row_mut(&mut self, id: &Id) -> Option<&mut EntityModification> {
+        if let Some(&idx) = self.last_mod.get(id) {
+            return self.rows.get_mut(idx);
+        }
         self.rows.iter_mut().rfind(|emod| emod.id() == id)
     }
 
     /// Append `row` to `self.rows` by combining it with a previously
     /// existing row, if that is possible
     fn append_row(&mut self, row: EntityModification) -> Result<(), StoreError> {
-        if self.immutable {
+        if self.entity_type.is_immutable() {
             match row {
                 EntityModification::Insert { .. } => {
-                    self.rows.push(row);
+                    // Check if this is an attempt to overwrite an immutable
+                    // entity. We allow overwriting immutable entities in
+                    // the same block, but not across blocks; if such an
+                    // attempt happens across two batches, it would result
+                    // in a database constraint violation. This check is
+                    // simply here to provide a friendlier error message and
+                    // to raise the error earlier, before we actually write
+                    // to the database
+                    match self
+                        .last_mod
+                        .get(row.id())
+                        .and_then(|&idx| self.rows.get(idx))
+                    {
+                        Some(prev) if prev.block() != row.block() => {
+                            if self.entity_type.skip_duplicates() {
+                                return Ok(());
+                            }
+                            return Err(StoreError::Input(format!(
+                                "entity {} is immutable; inserting it at block {} is not possible as it was already inserted at block {}",
+                                row.key(),
+                                row.block(),
+                                prev.block()
+                            )));
+                        }
+                        _ => { /* nothing to check */ }
+                    }
+
+                    self.push_row(row);
                 }
                 EntityModification::Overwrite { .. } | EntityModification::Remove { .. } => {
-                    return Err(constraint_violation!(
+                    if self.entity_type.skip_duplicates() {
+                        return Ok(());
+                    }
+                    return Err(internal_error!(
                         "immutable entity type {} only allows inserts, not {:?}",
                         self.entity_type,
                         row
@@ -410,57 +521,76 @@ impl RowGroup {
             use EntityModification::*;
 
             if row.block() <= prev_row.block() {
-                return Err(constraint_violation!(
+                return Err(internal_error!(
                     "can not append operations that go backwards from {:?} to {:?}",
                     prev_row,
                     row
                 ));
             }
 
+            if row.id() != prev_row.id() {
+                return Err(internal_error!(
+                    "last_mod map is corrupted: got id {} looking up id {}",
+                    prev_row.id(),
+                    row.id()
+                ));
+            }
+
             // The heart of the matter: depending on what `row` is, clamp
             // `prev_row` and either ignore `row` since it is not needed, or
             // turn it into an `Insert`, which also does not require
             // clamping an old version
             match (&*prev_row, &row) {
                 (Insert { end: None, .. } | Overwrite { end: None, .. }, Insert { .. })
-                | (Remove { .. }, Overwrite { .. } | Remove { .. })
+                | (Remove { .. }, Overwrite { .. })
                 | (
                     Insert { end: Some(_), .. } | Overwrite { end: Some(_), .. },
                     Overwrite { .. } | Remove { .. },
                 ) => {
-                    return Err(constraint_violation!(
+                    return Err(internal_error!(
                         "impossible combination of entity operations: {:?} and then {:?}",
                         prev_row,
                         row
-                    ))
+                    ));
+                }
+                (Remove { .. }, Remove { .. }) => {
+                    // Ignore the new row, since prev_row is already a
+                    // delete. This can happen when subgraphs delete
+                    // entities without checking if they even exist
                 }
                 (
                     Insert { end: Some(_), .. } | Overwrite { end: Some(_), .. } | Remove { .. },
                     Insert { .. },
                 ) => {
                     // prev_row was deleted
-                    self.rows.push(row);
+                    self.push_row(row);
                 }
                 (
                     Insert { end: None, .. } | Overwrite { end: None, .. },
                     Overwrite { block, .. },
                 ) => {
                     prev_row.clamp(*block)?;
-                    self.rows.push(row.as_insert(&self.entity_type)?);
+                    let row = row.into_insert(&self.entity_type)?;
+                    self.push_row(row);
                 }
                 (Insert { end: None, .. } | Overwrite { end: None, .. }, Remove { block, .. }) => {
                     prev_row.clamp(*block)?;
                 }
             }
         } else {
-            self.rows.push(row);
+            self.push_row(row);
         }
         Ok(())
     }
 
+    fn push_row(&mut self, row: EntityModification) {
+        self.last_mod.insert(row.id().clone(), self.rows.len());
+        self.rows.push(row);
+    }
+
     fn append(&mut self, group: RowGroup) -> Result<(), StoreError> {
         if self.entity_type != group.entity_type {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "Can not append a row group for {} to a row group for {}",
                 group.entity_type,
                 self.entity_type
@@ -480,6 +610,22 @@ impl RowGroup {
     }
 }
 
+pub struct RowGroupForPerfTest(RowGroup);
+
+impl RowGroupForPerfTest {
+    pub fn new(entity_type: EntityType) -> Self {
+        Self(RowGroup::new(entity_type))
+    }
+
+    pub fn push(&mut self, emod: EntityModification, block: BlockNumber) -> Result<(), StoreError> {
+        self.0.push(emod, block)
+    }
+
+    pub fn append_row(&mut self, row: EntityModification) -> Result<(), StoreError> {
+        self.0.append_row(row)
+    }
+}
+
 struct ClampsByBlockIterator<'a> {
     position: usize,
     rows: &'a [EntityModification],
@@ -521,14 +667,18 @@ impl<'a> Iterator for ClampsByBlockIterator<'a> {
 }
 
 /// A list of entity changes with one group per entity type
-#[derive(Debug)]
+#[derive(Debug, CacheWeight)]
 pub struct RowGroups {
     pub groups: Vec<RowGroup>,
+    logger: Logger,
 }
 
 impl RowGroups {
-    fn new() -> Self {
-        Self { groups: Vec::new() }
+    fn new(logger: Logger) -> Self {
+        Self {
+            groups: Vec::new(),
+            logger,
+        }
     }
 
     fn group(&self, entity_type: &EntityType) -> Option<&RowGroup> {
@@ -547,9 +697,7 @@ impl RowGroups {
         match pos {
             Some(pos) => &mut self.groups[pos],
             None => {
-                let immutable = entity_type.is_immutable();
-                self.groups
-                    .push(RowGroup::new(entity_type.clone(), immutable));
+                self.groups.push(RowGroup::new(entity_type.clone()));
                 // unwrap: we just pushed an entry
                 self.groups.last_mut().unwrap()
             }
@@ -622,13 +770,19 @@ pub struct Batch {
     pub first_block: BlockNumber,
     /// The firehose cursor corresponding to `block_ptr`
     pub firehose_cursor: FirehoseCursor,
-    mods: RowGroups,
+    pub mods: RowGroups,
     /// New data sources
     pub data_sources: DataSources,
     pub deterministic_errors: Vec<SubgraphError>,
     pub offchain_to_remove: DataSources,
     pub error: Option<StoreError>,
     pub is_non_fatal_errors_active: bool,
+    /// Memoize the indirect weight of the batch. We need the `CacheWeight`
+    /// of the batch a lot in the write queue to determine if a batch should
+    /// be written. Recalculating it every time, which has to happen while
+    /// the writer holds a lock, conflicts with appending to the batch and
+    /// causes batches to be finished prematurely.
+    indirect_weight: usize,
 }
 
 impl Batch {
@@ -641,6 +795,7 @@ impl Batch {
         deterministic_errors: Vec<SubgraphError>,
         offchain_to_remove: Vec<StoredDynamicDataSource>,
         is_non_fatal_errors_active: bool,
+        logger: Logger,
     ) -> Result<Self, StoreError> {
         let block = block_ptr.number;
 
@@ -654,7 +809,7 @@ impl Batch {
             EntityModification::Remove { .. } => 0,
         });
 
-        let mut mods = RowGroups::new();
+        let mut mods = RowGroups::new(logger);
 
         for m in raw_mods {
             mods.group_entry(&m.key().entity_type).push(m, block)?;
@@ -664,7 +819,7 @@ impl Batch {
         let offchain_to_remove = DataSources::new(block_ptr.cheap_clone(), offchain_to_remove);
         let first_block = block_ptr.number;
         let block_times = vec![(block, block_time)];
-        Ok(Self {
+        let mut batch = Self {
             block_ptr,
             first_block,
             block_times,
@@ -675,12 +830,19 @@ impl Batch {
             offchain_to_remove,
             error: None,
             is_non_fatal_errors_active,
-        })
+            indirect_weight: 0,
+        };
+        batch.weigh();
+        Ok(batch)
     }
 
     fn append_inner(&mut self, mut batch: Batch) -> Result<(), StoreError> {
         if batch.block_ptr.number <= self.block_ptr.number {
-            return Err(constraint_violation!("Batches must go forward. Can't append a batch with block pointer {} to one with block pointer {}", batch.block_ptr, self.block_ptr));
+            return Err(internal_error!(
+                "Batches must go forward. Can't append a batch with block pointer {} to one with block pointer {}",
+                batch.block_ptr,
+                self.block_ptr
+            ));
         }
 
         self.block_ptr = batch.block_ptr;
@@ -706,6 +868,7 @@ impl Batch {
         if let Err(e) = &res {
             self.error = Some(e.clone());
         }
+        self.weigh();
         res
     }
 
@@ -725,7 +888,7 @@ impl Batch {
         &self,
         entity_type: &EntityType,
         at: BlockNumber,
-    ) -> impl Iterator<Item = EntityOp> {
+    ) -> impl Iterator<Item = EntityOp<'_>> {
         self.mods
             .group(entity_type)
             .map(|group| group.effective_ops(at))
@@ -741,8 +904,7 @@ impl Batch {
             .entries
             .iter()
             .filter(move |(ptr, _)| ptr.number <= at)
-            .map(|(_, ds)| ds)
-            .flatten()
+            .flat_map(|(_, ds)| ds)
             .filter(|ds| {
                 !self
                     .offchain_to_remove
@@ -752,49 +914,18 @@ impl Batch {
             })
     }
 
-    /// Generate a store event for all the changes that this batch makes
-    pub fn store_event(&self, deployment: &DeploymentHash) -> StoreEvent {
-        let entity_types = HashSet::from_iter(
-            self.mods
-                .groups
-                .iter()
-                .map(|group| group.entity_type.clone()),
-        );
-        StoreEvent::from_types(deployment, entity_types)
-    }
-
-    pub fn groups<'a>(&'a self) -> impl Iterator<Item = &'a RowGroup> {
+    pub fn groups(&self) -> impl Iterator<Item = &RowGroup> {
         self.mods.groups.iter()
     }
-}
-
-impl CacheWeight for Batch {
-    fn indirect_weight(&self) -> usize {
-        self.mods.indirect_weight()
-    }
-}
 
-impl CacheWeight for RowGroups {
-    fn indirect_weight(&self) -> usize {
-        self.groups.indirect_weight()
+    fn weigh(&mut self) {
+        self.indirect_weight = self.mods.indirect_weight();
     }
 }
 
-impl CacheWeight for RowGroup {
+impl CacheWeight for Batch {
     fn indirect_weight(&self) -> usize {
-        self.rows.indirect_weight()
-    }
-}
-
-impl CacheWeight for EntityModification {
-    fn indirect_weight(&self) -> usize {
-        match self {
-            EntityModification::Insert { key, data, .. }
-            | EntityModification::Overwrite { key, data, .. } => {
-                key.indirect_weight() + data.indirect_weight()
-            }
-            EntityModification::Remove { key, .. } => key.indirect_weight(),
-        }
+        self.indirect_weight
     }
 }
 
@@ -854,6 +985,10 @@ impl<'a> WriteChunk<'a> {
         self.iter().next().is_none()
     }
 
+    pub fn len(&self) -> usize {
+        (self.group.row_count() - self.position).min(self.chunk_size)
+    }
+
     pub fn iter(&self) -> WriteChunkIter<'a> {
         WriteChunkIter {
             group: self.group,
@@ -862,6 +997,17 @@ impl<'a> WriteChunk<'a> {
             count: 0,
         }
     }
+
+    /// Return a vector of `WriteChunk`s each containing a single write
+    pub fn as_single_writes(&self) -> Vec<Self> {
+        (0..self.len())
+            .map(|position| WriteChunk {
+                group: self.group,
+                chunk_size: 1,
+                position: self.position + position,
+            })
+            .collect()
+    }
 }
 
 impl<'a> IntoIterator for &WriteChunk<'a> {
@@ -898,15 +1044,18 @@ impl<'a> Iterator for WriteChunkIter<'a> {
                 return insert;
             }
         }
-        return None;
+        None
     }
 }
 
 #[cfg(test)]
 mod test {
+    use std::collections::HashMap;
+    use std::sync::Arc;
+
     use crate::{
         components::store::{
-            write::EntityModification, write::EntityOp, BlockNumber, EntityType, StoreError,
+            BlockNumber, EntityType, StoreError, write::EntityModification, write::EntityOp,
         },
         data::{store::Id, value::Word},
         entity,
@@ -915,7 +1064,7 @@ mod test {
     };
     use lazy_static::lazy_static;
 
-    use super::RowGroup;
+    use super::{LastMod, RowGroup};
 
     #[track_caller]
     fn check_runs(values: &[usize], blocks: &[BlockNumber], exp: &[(BlockNumber, &[usize])]) {
@@ -925,7 +1074,7 @@ mod test {
 
         assert_eq!(values.len(), blocks.len());
 
-        let rows = values
+        let rows: Vec<_> = values
             .iter()
             .zip(blocks.iter())
             .map(|(value, block)| EntityModification::Remove {
@@ -933,10 +1082,20 @@ mod test {
                 block: *block,
             })
             .collect();
+        let last_mod = LastMod {
+            map: rows
+                .iter()
+                .enumerate()
+                .fold(HashMap::new(), |mut map, (idx, emod)| {
+                    map.insert(emod.id().clone(), idx);
+                    map
+                }),
+        };
+
         let group = RowGroup {
             entity_type: ENTRY_TYPE.clone(),
             rows,
-            immutable: false,
+            last_mod,
         };
         let act = group
             .clamps_by_block()
@@ -951,7 +1110,7 @@ mod test {
             })
             .collect::<Vec<_>>();
         let exp = Vec::from_iter(
-            exp.into_iter()
+            exp.iter()
                 .map(|(block, values)| (*block, Vec::from_iter(values.iter().map(as_id)))),
         );
         assert_eq!(exp, act);
@@ -976,6 +1135,8 @@ mod test {
       type Thing @entity { id: ID!, count: Int! }
       type RowGroup @entity { id: ID! }
       type Entry @entity { id: ID! }
+      type ImmThing @entity(immutable: true) { id: ID!, count: Int! }
+      type SkipDupThing @entity(immutable: true, skipDuplicates: true) { id: ID!, count: Int! }
     "#;
     lazy_static! {
         static ref DEPLOYMENT: DeploymentHash = DeploymentHash::new("batchAppend").unwrap();
@@ -984,6 +1145,8 @@ mod test {
         static ref THING_TYPE: EntityType = SCHEMA.entity_type("Thing").unwrap();
         static ref ROW_GROUP_TYPE: EntityType = SCHEMA.entity_type("RowGroup").unwrap();
         static ref ENTRY_TYPE: EntityType = SCHEMA.entity_type("Entry").unwrap();
+        static ref IMM_THING_TYPE: EntityType = SCHEMA.entity_type("ImmThing").unwrap();
+        static ref SKIP_DUP_THING_TYPE: EntityType = SCHEMA.entity_type("SkipDupThing").unwrap();
     }
 
     /// Convenient notation for changes to a fixed entity
@@ -1007,26 +1170,26 @@ mod test {
             match value {
                 Ins(block) => EntityModification::Insert {
                     key,
-                    data: entity! { SCHEMA => id: "one", count: block },
+                    data: Arc::new(entity! { SCHEMA => id: "one", count: block }),
                     block,
                     end: None,
                 },
                 Ovw(block) => EntityModification::Overwrite {
                     key,
-                    data: entity! { SCHEMA => id: "one", count: block },
+                    data: Arc::new(entity! { SCHEMA => id: "one", count: block }),
                     block,
                     end: None,
                 },
                 Rem(block) => EntityModification::Remove { key, block },
                 InsC(block, end) => EntityModification::Insert {
                     key,
-                    data: entity! { SCHEMA => id: "one", count: block },
+                    data: Arc::new(entity! { SCHEMA => id: "one", count: block }),
                     block,
                     end: Some(end),
                 },
                 OvwC(block, end) => EntityModification::Overwrite {
                     key,
-                    data: entity! { SCHEMA => id: "one", count: block },
+                    data: Arc::new(entity! { SCHEMA => id: "one", count: block }),
                     block,
                     end: Some(end),
                 },
@@ -1043,7 +1206,7 @@ mod test {
     impl Group {
         fn new() -> Self {
             Self {
-                group: RowGroup::new(THING_TYPE.clone(), false),
+                group: RowGroup::new(THING_TYPE.clone()),
             }
         }
 
@@ -1063,7 +1226,7 @@ mod test {
 
     impl PartialEq<&[Mod]> for Group {
         fn eq(&self, mods: &&[Mod]) -> bool {
-            let mods: Vec<_> = mods.iter().map(|m| EntityModification::from(m)).collect();
+            let mods: Vec<_> = mods.iter().map(EntityModification::from).collect();
             self.group.rows == mods
         }
     }
@@ -1148,4 +1311,76 @@ mod test {
         let op = group.last_op(&key, 0);
         assert_eq!(None, op);
     }
+
+    fn make_insert(entity_type: &EntityType, id: &str, block: BlockNumber) -> EntityModification {
+        EntityModification::Insert {
+            key: entity_type.parse_key(id).unwrap(),
+            data: Arc::new(entity! { SCHEMA => id: id, count: block }),
+            block,
+            end: None,
+        }
+    }
+
+    fn make_overwrite(
+        entity_type: &EntityType,
+        id: &str,
+        block: BlockNumber,
+    ) -> EntityModification {
+        EntityModification::Overwrite {
+            key: entity_type.parse_key(id).unwrap(),
+            data: Arc::new(entity! { SCHEMA => id: id, count: block }),
+            block,
+            end: None,
+        }
+    }
+
+    fn make_remove(entity_type: &EntityType, id: &str, block: BlockNumber) -> EntityModification {
+        EntityModification::Remove {
+            key: entity_type.parse_key(id).unwrap(),
+            block,
+        }
+    }
+
+    #[test]
+    fn append_row_immutable_default_rejects_cross_block_duplicate() {
+        let mut group = RowGroup::new(IMM_THING_TYPE.clone());
+        let res = group.push(make_insert(&IMM_THING_TYPE, "one", 1), 1);
+        assert!(res.is_ok());
+        let res = group.push(make_insert(&IMM_THING_TYPE, "one", 2), 2);
+        assert!(res.is_err());
+    }
+
+    #[test]
+    fn append_row_skip_duplicates_allows_cross_block_duplicate() {
+        let mut group = RowGroup::new(SKIP_DUP_THING_TYPE.clone());
+        let res = group.push(make_insert(&SKIP_DUP_THING_TYPE, "one", 1), 1);
+        assert!(res.is_ok());
+        let res = group.push(make_insert(&SKIP_DUP_THING_TYPE, "one", 2), 2);
+        assert!(res.is_ok());
+        assert_eq!(group.row_count(), 1);
+    }
+
+    #[test]
+    fn append_row_skip_duplicates_allows_overwrite() {
+        let mut group = RowGroup::new(SKIP_DUP_THING_TYPE.clone());
+        let res = group.append_row(make_overwrite(&SKIP_DUP_THING_TYPE, "one", 1));
+        assert!(res.is_ok());
+    }
+
+    #[test]
+    fn append_row_skip_duplicates_allows_remove() {
+        let mut group = RowGroup::new(SKIP_DUP_THING_TYPE.clone());
+        let res = group.append_row(make_remove(&SKIP_DUP_THING_TYPE, "one", 1));
+        assert!(res.is_ok());
+    }
+
+    #[test]
+    fn append_row_skip_duplicates_same_block_still_pushes() {
+        let mut group = RowGroup::new(SKIP_DUP_THING_TYPE.clone());
+        let res = group.push(make_insert(&SKIP_DUP_THING_TYPE, "one", 1), 1);
+        assert!(res.is_ok());
+        let res = group.push(make_insert(&SKIP_DUP_THING_TYPE, "one", 1), 1);
+        assert!(res.is_ok());
+        assert_eq!(group.row_count(), 2);
+    }
 }
diff --git a/graph/src/components/subgraph/host.rs b/graph/src/components/subgraph/host.rs
index 534bd6e39e5..40bdc10f8eb 100644
--- a/graph/src/components/subgraph/host.rs
+++ b/graph/src/components/subgraph/host.rs
@@ -4,9 +4,8 @@ use std::time::Instant;
 
 use anyhow::Error;
 use async_trait::async_trait;
-use futures::sync::mpsc;
+use futures01::sync::mpsc;
 
-use crate::blockchain::BlockTime;
 use crate::components::metrics::gas::GasMetrics;
 use crate::components::store::SubgraphFork;
 use crate::data_source::{
@@ -32,9 +31,9 @@ impl From<anyhow::Error> for MappingError {
 impl From<HostExportError> for MappingError {
     fn from(value: HostExportError) -> MappingError {
         match value {
-            HostExportError::PossibleReorg(e) => MappingError::PossibleReorg(e.into()),
+            HostExportError::PossibleReorg(e) => MappingError::PossibleReorg(e),
             HostExportError::Deterministic(e) | HostExportError::Unknown(e) => {
-                MappingError::Unknown(e.into())
+                MappingError::Unknown(e)
             }
         }
     }
@@ -48,6 +47,15 @@ impl MappingError {
             Unknown(e) => Unknown(e.context(s)),
         }
     }
+
+    pub fn add_trigger_context<C: Blockchain>(mut self, trigger: &TriggerData<C>) -> MappingError {
+        let error_context = trigger.error_context();
+        if !error_context.is_empty() {
+            self = self.context(error_context)
+        }
+        self = self.context("failed to process trigger".to_string());
+        self
+    }
 }
 
 /// Common trait for runtime host implementations.
@@ -62,28 +70,15 @@ pub trait RuntimeHost<C: Blockchain>: Send + Sync + 'static {
         logger: &Logger,
     ) -> Result<Option<TriggerWithHandler<MappingTrigger<C>>>, Error>;
 
-    async fn process_block(
-        &self,
-        logger: &Logger,
-        block_ptr: BlockPtr,
-        block_time: BlockTime,
-        block_data: Box<[u8]>,
-        handler: String,
-        state: BlockState<C>,
-        proof_of_indexing: SharedProofOfIndexing,
-        debug_fork: &Option<Arc<dyn SubgraphFork>>,
-        instrument: bool,
-    ) -> Result<BlockState<C>, MappingError>;
-
     async fn process_mapping_trigger(
         &self,
         logger: &Logger,
         trigger: TriggerWithHandler<MappingTrigger<C>>,
-        state: BlockState<C>,
+        state: BlockState,
         proof_of_indexing: SharedProofOfIndexing,
         debug_fork: &Option<Arc<dyn SubgraphFork>>,
         instrument: bool,
-    ) -> Result<BlockState<C>, MappingError>;
+    ) -> Result<BlockState, MappingError>;
 
     /// Block number in which this host was created.
     /// Returns `None` for static data sources.
@@ -96,6 +91,9 @@ pub trait RuntimeHost<C: Blockchain>: Send + Sync + 'static {
     /// Convenience function to avoid leaking internal representation of
     /// mutable number. Calling this on OnChain Datasources is a noop.
     fn set_done_at(&self, block: Option<BlockNumber>);
+
+    /// Return a metrics object for this host.
+    fn host_metrics(&self) -> Arc<HostMetrics>;
 }
 
 pub struct HostMetrics {
@@ -127,11 +125,7 @@ impl HostMetrics {
                 "deployment_eth_call_execution_time",
                 "Measures the execution time for eth_call",
                 subgraph,
-                vec![
-                    String::from("contract_name"),
-                    String::from("address"),
-                    String::from("method"),
-                ],
+                vec![String::from("contract_name"), String::from("method")],
                 vec![0.1, 0.5, 1.0, 10.0, 100.0],
             )
             .expect("failed to create `deployment_eth_call_execution_time` histogram");
@@ -170,11 +164,10 @@ impl HostMetrics {
         &self,
         duration: f64,
         contract_name: &str,
-        address: &str,
         method: &str,
     ) {
         self.eth_call_execution_time
-            .with_label_values(&[contract_name, address, method][..])
+            .with_label_values(&[contract_name, method][..])
             .observe(duration);
     }
 
diff --git a/graph/src/components/subgraph/instance.rs b/graph/src/components/subgraph/instance.rs
index 8634d5725f7..ae4a91ed540 100644
--- a/graph/src/components/subgraph/instance.rs
+++ b/graph/src/components/subgraph/instance.rs
@@ -1,54 +1,113 @@
 use crate::{
-    blockchain::Blockchain,
-    components::store::{ReadStore, StoredDynamicDataSource},
+    blockchain::{Blockchain, DataSourceTemplate as _},
+    components::{
+        metrics::block_state::BlockStateMetrics,
+        store::{EntityLfuCache, ReadStore, SeqGenerator, StoredDynamicDataSource},
+    },
     data::subgraph::schema::SubgraphError,
-    data_source::DataSourceTemplate,
+    data_source::{DataSourceTemplate, DataSourceTemplateInfo},
     prelude::*,
-    schema::EntityKey,
-    util::lfu_cache::LfuCache,
 };
 
+#[derive(Debug, Clone)]
+pub enum InstanceDSTemplate {
+    Onchain(DataSourceTemplateInfo),
+    Offchain(crate::data_source::offchain::DataSourceTemplate),
+}
+
+impl<C: Blockchain> From<&DataSourceTemplate<C>> for InstanceDSTemplate {
+    fn from(value: &crate::data_source::DataSourceTemplate<C>) -> Self {
+        match value {
+            DataSourceTemplate::Onchain(ds) => Self::Onchain(ds.info()),
+            DataSourceTemplate::Offchain(ds) => Self::Offchain(ds.clone()),
+            DataSourceTemplate::Subgraph(_) => todo!(), // TODO(krishna)
+        }
+    }
+}
+
+impl InstanceDSTemplate {
+    pub fn name(&self) -> &str {
+        match self {
+            Self::Onchain(ds) => &ds.name,
+            Self::Offchain(ds) => &ds.name,
+        }
+    }
+
+    pub fn is_onchain(&self) -> bool {
+        match self {
+            Self::Onchain(_) => true,
+            Self::Offchain(_) => false,
+        }
+    }
+
+    pub fn into_onchain(self) -> Option<DataSourceTemplateInfo> {
+        match self {
+            Self::Onchain(ds) => Some(ds),
+            Self::Offchain(_) => None,
+        }
+    }
+
+    pub fn manifest_idx(&self) -> Option<u32> {
+        match self {
+            InstanceDSTemplate::Onchain(info) => info.manifest_idx,
+            InstanceDSTemplate::Offchain(info) => Some(info.manifest_idx),
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
-pub struct DataSourceTemplateInfo<C: Blockchain> {
-    pub template: DataSourceTemplate<C>,
+pub struct InstanceDSTemplateInfo {
+    pub template: InstanceDSTemplate,
     pub params: Vec<String>,
     pub context: Option<DataSourceContext>,
     pub creation_block: BlockNumber,
 }
 
 #[derive(Debug)]
-pub struct BlockState<C: Blockchain> {
+pub struct BlockState {
     pub entity_cache: EntityCache,
     pub deterministic_errors: Vec<SubgraphError>,
-    created_data_sources: Vec<DataSourceTemplateInfo<C>>,
+    created_data_sources: Vec<InstanceDSTemplateInfo>,
 
     // Data sources to be transacted into the store.
     pub persisted_data_sources: Vec<StoredDynamicDataSource>,
 
     // Data sources created in the current handler.
-    handler_created_data_sources: Vec<DataSourceTemplateInfo<C>>,
+    handler_created_data_sources: Vec<InstanceDSTemplateInfo>,
 
     // data source that have been processed.
     pub processed_data_sources: Vec<StoredDynamicDataSource>,
 
     // Marks whether a handler is currently executing.
     in_handler: bool,
+
+    pub metrics: BlockStateMetrics,
+
+    pub write_capacity_remaining: usize,
 }
 
-impl<C: Blockchain> BlockState<C> {
-    pub fn new(store: impl ReadStore, lfu_cache: LfuCache<EntityKey, Option<Entity>>) -> Self {
+impl BlockState {
+    pub fn new(store: impl ReadStore, lfu_cache: EntityLfuCache, vid_gen: SeqGenerator) -> Self {
         BlockState {
-            entity_cache: EntityCache::with_current(Arc::new(store), lfu_cache),
+            entity_cache: EntityCache::with_current(Arc::new(store), lfu_cache, vid_gen),
             deterministic_errors: Vec::new(),
             created_data_sources: Vec::new(),
             persisted_data_sources: Vec::new(),
             handler_created_data_sources: Vec::new(),
             processed_data_sources: Vec::new(),
             in_handler: false,
+            metrics: BlockStateMetrics::new(),
+            write_capacity_remaining: ENV_VARS.block_write_capacity,
         }
     }
 
-    pub fn extend(&mut self, other: BlockState<C>) {
+    pub fn seq_gen(&self) -> SeqGenerator {
+        self.entity_cache.seq_gen()
+    }
+}
+
+impl BlockState {
+    pub fn extend(&mut self, other: BlockState) {
         assert!(!other.in_handler);
 
         let BlockState {
@@ -59,6 +118,8 @@ impl<C: Blockchain> BlockState<C> {
             handler_created_data_sources,
             processed_data_sources,
             in_handler,
+            metrics,
+            write_capacity_remaining,
         } = self;
 
         match in_handler {
@@ -69,10 +130,9 @@ impl<C: Blockchain> BlockState<C> {
         entity_cache.extend(other.entity_cache);
         processed_data_sources.extend(other.processed_data_sources);
         persisted_data_sources.extend(other.persisted_data_sources);
-    }
-
-    pub fn has_errors(&self) -> bool {
-        !self.deterministic_errors.is_empty()
+        metrics.extend(other.metrics);
+        *write_capacity_remaining =
+            write_capacity_remaining.saturating_sub(other.write_capacity_remaining);
     }
 
     pub fn has_created_data_sources(&self) -> bool {
@@ -84,13 +144,10 @@ impl<C: Blockchain> BlockState<C> {
         assert!(!self.in_handler);
         self.created_data_sources
             .iter()
-            .any(|ds| match ds.template {
-                DataSourceTemplate::Onchain(_) => true,
-                _ => false,
-            })
+            .any(|ds| matches!(ds.template, InstanceDSTemplate::Onchain(_)))
     }
 
-    pub fn drain_created_data_sources(&mut self) -> Vec<DataSourceTemplateInfo<C>> {
+    pub fn drain_created_data_sources(&mut self) -> Vec<InstanceDSTemplateInfo> {
         assert!(!self.in_handler);
         std::mem::take(&mut self.created_data_sources)
     }
@@ -117,7 +174,7 @@ impl<C: Blockchain> BlockState<C> {
         self.deterministic_errors.push(e);
     }
 
-    pub fn push_created_data_source(&mut self, ds: DataSourceTemplateInfo<C>) {
+    pub fn push_created_data_source(&mut self, ds: InstanceDSTemplateInfo) {
         assert!(self.in_handler);
         self.handler_created_data_sources.push(ds);
     }
@@ -125,4 +182,48 @@ impl<C: Blockchain> BlockState<C> {
     pub fn persist_data_source(&mut self, ds: StoredDynamicDataSource) {
         self.persisted_data_sources.push(ds)
     }
+
+    /// Create a lightweight checkpoint for rollback.
+    ///
+    /// This captures the current counts of created and persisted data sources,
+    /// allowing a partial rollback via `restore()`. Note that entity cache changes
+    /// cannot be easily checkpointed; rollback clears the cache (acceptable per
+    /// current behavior).
+    pub fn checkpoint(&self) -> BlockStateCheckpoint {
+        assert!(!self.in_handler);
+        BlockStateCheckpoint {
+            created_data_sources_count: self.created_data_sources.len(),
+            persisted_data_sources_count: self.persisted_data_sources.len(),
+            processed_data_sources_count: self.processed_data_sources.len(),
+            deterministic_errors_count: self.deterministic_errors.len(),
+        }
+    }
+
+    /// Restore state to a previously captured checkpoint (partial rollback).
+    ///
+    /// This truncates the data source vectors to their checkpoint sizes.
+    /// Entity cache is NOT restored - caller should handle cache state if needed.
+    pub fn restore(&mut self, checkpoint: BlockStateCheckpoint) {
+        assert!(!self.in_handler);
+        self.created_data_sources
+            .truncate(checkpoint.created_data_sources_count);
+        self.persisted_data_sources
+            .truncate(checkpoint.persisted_data_sources_count);
+        self.processed_data_sources
+            .truncate(checkpoint.processed_data_sources_count);
+        self.deterministic_errors
+            .truncate(checkpoint.deterministic_errors_count);
+    }
+}
+
+/// A lightweight checkpoint for `BlockState` rollback.
+///
+/// Captures counts of mutable vectors in `BlockState` to enable partial rollback.
+/// Used before processing dynamic data sources to allow recovery if needed.
+#[derive(Debug, Clone, Copy)]
+pub struct BlockStateCheckpoint {
+    created_data_sources_count: usize,
+    persisted_data_sources_count: usize,
+    processed_data_sources_count: usize,
+    deterministic_errors_count: usize,
 }
diff --git a/graph/src/components/subgraph/instance_manager.rs b/graph/src/components/subgraph/instance_manager.rs
index c04fd5237b4..d014366ead2 100644
--- a/graph/src/components/subgraph/instance_manager.rs
+++ b/graph/src/components/subgraph/instance_manager.rs
@@ -1,4 +1,3 @@
-use crate::prelude::BlockNumber;
 use std::sync::Arc;
 
 use crate::components::store::DeploymentLocator;
@@ -10,11 +9,7 @@ use crate::components::store::DeploymentLocator;
 /// subgraph instance manager stops and removes the corresponding instance.
 #[async_trait::async_trait]
 pub trait SubgraphInstanceManager: Send + Sync + 'static {
-    async fn start_subgraph(
-        self: Arc<Self>,
-        deployment: DeploymentLocator,
-        manifest: serde_yaml::Mapping,
-        stop_block: Option<BlockNumber>,
-    );
-    async fn stop_subgraph(&self, deployment: DeploymentLocator);
+    async fn start_subgraph(self: Arc<Self>, loc: DeploymentLocator, stop_block: Option<i32>);
+
+    async fn stop_subgraph(&self, loc: DeploymentLocator);
 }
diff --git a/graph/src/components/subgraph/mod.rs b/graph/src/components/subgraph/mod.rs
index 4cb9eb91142..45ab3b16ac4 100644
--- a/graph/src/components/subgraph/mod.rs
+++ b/graph/src/components/subgraph/mod.rs
@@ -2,19 +2,19 @@ mod host;
 mod instance;
 mod instance_manager;
 mod proof_of_indexing;
-mod provider;
 mod registrar;
 mod settings;
 
 pub use crate::prelude::Entity;
 
 pub use self::host::{HostMetrics, MappingError, RuntimeHost, RuntimeHostBuilder};
-pub use self::instance::{BlockState, DataSourceTemplateInfo};
+pub use self::instance::{
+    BlockState, BlockStateCheckpoint, InstanceDSTemplate, InstanceDSTemplateInfo,
+};
 pub use self::instance_manager::SubgraphInstanceManager;
 pub use self::proof_of_indexing::{
     PoICausalityRegion, ProofOfIndexing, ProofOfIndexingEvent, ProofOfIndexingFinisher,
     ProofOfIndexingVersion, SharedProofOfIndexing,
 };
-pub use self::provider::SubgraphAssignmentProvider;
 pub use self::registrar::{SubgraphRegistrar, SubgraphVersionSwitchingMode};
 pub use self::settings::{Setting, Settings};
diff --git a/graph/src/components/subgraph/proof_of_indexing/event.rs b/graph/src/components/subgraph/proof_of_indexing/event.rs
index 4fc2e90c171..227a7a6c561 100644
--- a/graph/src/components/subgraph/proof_of_indexing/event.rs
+++ b/graph/src/components/subgraph/proof_of_indexing/event.rs
@@ -60,8 +60,8 @@ pub enum ProofOfIndexingEvent<'a> {
 
 impl stable_hash_legacy::StableHash for ProofOfIndexingEvent<'_> {
     fn stable_hash<H: StableHasher>(&self, mut sequence_number: H::Seq, state: &mut H) {
-        use stable_hash_legacy::prelude::*;
         use ProofOfIndexingEvent::*;
+        use stable_hash_legacy::prelude::*;
 
         let str: &'static str = self.into();
         str.stable_hash(sequence_number.next_child(), state);
diff --git a/graph/src/components/subgraph/proof_of_indexing/mod.rs b/graph/src/components/subgraph/proof_of_indexing/mod.rs
index c8dd8c13314..58ec37e04f3 100644
--- a/graph/src/components/subgraph/proof_of_indexing/mod.rs
+++ b/graph/src/components/subgraph/proof_of_indexing/mod.rs
@@ -3,11 +3,15 @@ mod online;
 mod reference;
 
 pub use event::ProofOfIndexingEvent;
+use graph_derive::CheapClone;
 pub use online::{ProofOfIndexing, ProofOfIndexingFinisher};
 pub use reference::PoICausalityRegion;
 
 use atomic_refcell::AtomicRefCell;
-use std::sync::Arc;
+use slog::Logger;
+use std::{ops::Deref, sync::Arc};
+
+use crate::prelude::BlockNumber;
 
 #[derive(Copy, Clone, Debug)]
 pub enum ProofOfIndexingVersion {
@@ -22,34 +26,104 @@ pub enum ProofOfIndexingVersion {
 /// intentionally disallowed - PoI requires sequential access to the hash
 /// function within a given causality region even if ownership is shared across
 /// multiple mapping contexts.
-///
-/// The Option<_> is because not all subgraphs support PoI until re-deployed.
-/// Eventually this can be removed.
-///
-/// This is not a great place to define this type, since the ProofOfIndexing
-/// shouldn't "know" these details about wasmtime and subgraph re-deployments,
-/// but the APIs that would make use of this are in graph/components so this
-/// lives here for lack of a better choice.
-pub type SharedProofOfIndexing = Option<Arc<AtomicRefCell<ProofOfIndexing>>>;
+#[derive(Clone, CheapClone)]
+pub struct SharedProofOfIndexing {
+    poi: Option<Arc<AtomicRefCell<ProofOfIndexing>>>,
+}
+
+impl SharedProofOfIndexing {
+    pub fn new(block: BlockNumber, version: ProofOfIndexingVersion) -> Self {
+        SharedProofOfIndexing {
+            poi: Some(Arc::new(AtomicRefCell::new(ProofOfIndexing::new(
+                block, version,
+            )))),
+        }
+    }
+
+    pub fn ignored() -> Self {
+        SharedProofOfIndexing { poi: None }
+    }
+
+    pub fn write_event(
+        &self,
+        poi_event: &ProofOfIndexingEvent,
+        causality_region: &str,
+        logger: &Logger,
+    ) {
+        if let Some(poi) = &self.poi {
+            let mut poi = poi.deref().borrow_mut();
+            poi.write(logger, causality_region, poi_event);
+        }
+    }
+
+    pub fn start_handler(&self, causality_region: &str) {
+        if let Some(poi) = &self.poi {
+            let mut poi = poi.deref().borrow_mut();
+            poi.start_handler(causality_region);
+        }
+    }
+
+    pub fn write_deterministic_error(&self, logger: &Logger, causality_region: &str) {
+        if let Some(proof_of_indexing) = &self.poi {
+            proof_of_indexing
+                .deref()
+                .borrow_mut()
+                .write_deterministic_error(logger, causality_region);
+        }
+    }
+
+    pub fn into_inner(self) -> Option<ProofOfIndexing> {
+        self.poi
+            .map(|poi| Arc::try_unwrap(poi).unwrap().into_inner())
+    }
+}
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::util::stable_hash_glue::{AsBytes, impl_stable_hash};
     use crate::{
         data::store::Id,
         prelude::{BlockPtr, DeploymentHash, Value},
         schema::InputSchema,
     };
+    use alloy::primitives::{Address, B256};
     use maplit::hashmap;
     use online::ProofOfIndexingFinisher;
     use reference::*;
-    use slog::{o, Discard, Logger};
+    use slog::{Discard, Logger, o};
     use stable_hash::{fast_stable_hash, utils::check_for_child_errors};
     use stable_hash_legacy::crypto::SetHasher;
     use stable_hash_legacy::utils::stable_hash as stable_hash_legacy;
     use std::collections::HashMap;
     use std::convert::TryInto;
-    use web3::types::{Address, H256};
+
+    /// The PoI is the StableHash of this struct. This reference implementation is
+    /// mostly here just to make sure that the online implementation is
+    /// well-implemented (without conflicting sequence numbers, or other oddities).
+    /// It's just way easier to check that this works, and serves as a kind of
+    /// documentation as a side-benefit.
+    pub struct PoI<'a> {
+        pub causality_regions: HashMap<String, PoICausalityRegion<'a>>,
+        pub subgraph_id: DeploymentHash,
+        pub block_hash: B256,
+        pub indexer: Option<Address>,
+    }
+
+    fn b256_as_bytes(val: &B256) -> AsBytes<&[u8]> {
+        AsBytes(val.as_slice())
+    }
+
+    fn indexer_opt_as_bytes(val: &Option<Address>) -> Option<AsBytes<&[u8]>> {
+        val.as_ref().map(|v| AsBytes(v.as_slice()))
+    }
+
+    impl_stable_hash!(PoI<'_> {
+        causality_regions,
+        subgraph_id,
+        block_hash: b256_as_bytes,
+        indexer: indexer_opt_as_bytes
+    });
 
     /// Verify that the stable hash of a reference and online implementation match
     fn check(case: Case, cache: &mut HashMap<String, &str>) {
@@ -60,7 +134,8 @@ mod tests {
         // return the same result.
         check_for_child_errors(&case.data).expect("Found child errors");
 
-        let offline_fast = tiny_keccak::keccak256(&fast_stable_hash(&case.data).to_le_bytes());
+        let offline_fast =
+            alloy::primitives::keccak256(fast_stable_hash(&case.data).to_le_bytes()).0;
         let offline_legacy = stable_hash_legacy::<SetHasher, _>(&case.data);
 
         for (version, offline, hardcoded) in [
@@ -74,11 +149,10 @@ mod tests {
             // Create a database which stores intermediate PoIs
             let mut db = HashMap::<Id, Vec<u8>>::new();
 
-            let mut block_count = 1;
-            for causality_region in case.data.causality_regions.values() {
-                block_count = causality_region.blocks.len();
-                break;
-            }
+            let block_count = match case.data.causality_regions.values().next() {
+                Some(causality_region) => causality_region.blocks.len(),
+                None => 1,
+            };
 
             for block_i in 0..block_count {
                 let mut stream = ProofOfIndexing::new(block_i.try_into().unwrap(), version);
@@ -173,7 +247,7 @@ mod tests {
                 fast: "dced49c45eac68e8b3d8f857928e7be6c270f2db8b56b0d7f27ce725100bae01",
                 data: PoI {
                     subgraph_id: DeploymentHash::new("test").unwrap(),
-                    block_hash: H256::repeat_byte(1),
+                    block_hash: B256::repeat_byte(1),
                     causality_regions: HashMap::new(),
                     indexer: None,
                 },
@@ -185,7 +259,7 @@ mod tests {
                 fast: "8bb3373fb55e02bde3202bac0eeecf1bd9a676856a4dd6667bd809aceda41885",
                 data: PoI {
                     subgraph_id: DeploymentHash::new("test").unwrap(),
-                    block_hash: H256::repeat_byte(1),
+                    block_hash: B256::repeat_byte(1),
                     causality_regions: hashmap! {
                         "eth".to_owned() => PoICausalityRegion {
                             blocks: vec! [
@@ -212,7 +286,7 @@ mod tests {
                 fast: "8b0097ad96b21f7e4bd8dcc41985e6e5506b808f1185016ab1073dd8745238ce",
                 data: PoI {
                     subgraph_id: DeploymentHash::new("b").unwrap(),
-                    block_hash: H256::repeat_byte(3),
+                    block_hash: B256::repeat_byte(3),
                     causality_regions: hashmap! {
                         "eth".to_owned() => PoICausalityRegion {
                             blocks: vec! [
@@ -250,7 +324,7 @@ mod tests {
                 fast: "2041af28678e68406247a5cfb5fe336947da75256c79b35c2f61fc7985091c0e",
                 data: PoI {
                     subgraph_id: DeploymentHash::new("b").unwrap(),
-                    block_hash: H256::repeat_byte(3),
+                    block_hash: B256::repeat_byte(3),
                     causality_regions: hashmap! {
                         "eth".to_owned() => PoICausalityRegion {
                             blocks: vec! [
@@ -312,7 +386,7 @@ mod tests {
                 fast: "421ef30a03be64014b9eef2b999795dcabfc601368040df855635e7886eb3822",
                 data: PoI {
                     subgraph_id: DeploymentHash::new("test").unwrap(),
-                    block_hash: H256::repeat_byte(1),
+                    block_hash: B256::repeat_byte(1),
                     causality_regions: hashmap! {
                         "eth".to_owned() => PoICausalityRegion {
                             blocks: vec! [
diff --git a/graph/src/components/subgraph/proof_of_indexing/online.rs b/graph/src/components/subgraph/proof_of_indexing/online.rs
index caaa76f0a76..b3043e12473 100644
--- a/graph/src/components/subgraph/proof_of_indexing/online.rs
+++ b/graph/src/components/subgraph/proof_of_indexing/online.rs
@@ -6,10 +6,12 @@ use super::{ProofOfIndexingEvent, ProofOfIndexingVersion};
 use crate::{
     blockchain::BlockPtr,
     data::store::Id,
-    prelude::{debug, BlockNumber, DeploymentHash, Logger, ENV_VARS},
+    prelude::{BlockNumber, DeploymentHash, ENV_VARS, Logger, debug},
     util::stable_hash_glue::AsBytes,
 };
-use stable_hash::{fast::FastStableHasher, FieldAddress, StableHash, StableHasher};
+use alloy::primitives::Address;
+use sha2::{Digest, Sha256};
+use stable_hash::{FieldAddress, StableHash, StableHasher, fast::FastStableHasher};
 use stable_hash_legacy::crypto::{Blake3SeqNo, SetHasher};
 use stable_hash_legacy::prelude::{
     StableHash as StableHashLegacy, StableHasher as StableHasherLegacy, *,
@@ -17,7 +19,6 @@ use stable_hash_legacy::prelude::{
 use std::collections::HashMap;
 use std::convert::TryInto;
 use std::fmt;
-use web3::types::Address;
 
 pub struct BlockEventStream {
     vec_length: u64,
@@ -31,6 +32,8 @@ enum Hashers {
     Legacy(SetHasher),
 }
 
+const STABLE_HASH_LEN: usize = 32;
+
 impl Hashers {
     fn new(version: ProofOfIndexingVersion) -> Self {
         match version {
@@ -132,9 +135,14 @@ impl BlockEventStream {
             }
             Hashers::Fast(mut digest) => {
                 if let Some(prev) = prev {
-                    let prev = prev
-                        .try_into()
-                        .expect("Expected valid fast stable hash representation");
+                    let prev = if prev.len() == STABLE_HASH_LEN {
+                        prev.try_into()
+                            .expect("Expected valid fast stable hash representation")
+                    } else {
+                        let mut hasher = Sha256::new();
+                        hasher.update(prev);
+                        hasher.finalize().into()
+                    };
                     let prev = FastStableHasher::from_bytes(prev);
                     digest.mixin(&prev);
                 }
@@ -146,8 +154,8 @@ impl BlockEventStream {
     fn write(&mut self, event: &ProofOfIndexingEvent<'_>) {
         let children = &[
             1,                // kvp -> v
-            0,                // PoICausalityRegion.blocks: Vec<Block>
-            self.block_index, // Vec<Block> -> [i]
+            0,                // PoICausalityRegion.blocks: Result<Vec<Block>>
+            self.block_index, // Result<Vec<Block>> -> [i]
             0,                // Block.events -> Vec<ProofOfIndexingEvent>
             self.vec_length,
         ];
@@ -242,6 +250,10 @@ impl ProofOfIndexing {
     pub fn take(self) -> HashMap<Id, BlockEventStream> {
         self.per_causality_region
     }
+
+    pub fn get_block(&self) -> BlockNumber {
+        self.block_number
+    }
 }
 
 pub struct ProofOfIndexingFinisher {
@@ -266,7 +278,7 @@ impl ProofOfIndexingFinisher {
         state.write(&AsBytes(block.hash_slice()), &[2]);
 
         // Add PoI.indexer
-        state.write(&indexer.as_ref().map(|i| AsBytes(i.as_bytes())), &[3]);
+        state.write(&indexer.as_ref().map(|i| AsBytes(i.as_slice())), &[3]);
 
         ProofOfIndexingFinisher {
             block_number: block.number,
@@ -312,7 +324,7 @@ impl ProofOfIndexingFinisher {
 
         match self.state {
             Hashers::Legacy(legacy) => legacy.finish(),
-            Hashers::Fast(fast) => tiny_keccak::keccak256(&fast.finish().to_le_bytes()),
+            Hashers::Fast(fast) => alloy::primitives::keccak256(fast.finish().to_le_bytes()).0,
         }
     }
 }
diff --git a/graph/src/components/subgraph/proof_of_indexing/reference.rs b/graph/src/components/subgraph/proof_of_indexing/reference.rs
index 5c7d269d7a7..31050a1c821 100644
--- a/graph/src/components/subgraph/proof_of_indexing/reference.rs
+++ b/graph/src/components/subgraph/proof_of_indexing/reference.rs
@@ -1,35 +1,5 @@
 use super::ProofOfIndexingEvent;
-use crate::prelude::DeploymentHash;
-use crate::util::stable_hash_glue::{impl_stable_hash, AsBytes};
-use std::collections::HashMap;
-use web3::types::{Address, H256};
-
-/// The PoI is the StableHash of this struct. This reference implementation is
-/// mostly here just to make sure that the online implementation is
-/// well-implemented (without conflicting sequence numbers, or other oddities).
-/// It's just way easier to check that this works, and serves as a kind of
-/// documentation as a side-benefit.
-pub struct PoI<'a> {
-    pub causality_regions: HashMap<String, PoICausalityRegion<'a>>,
-    pub subgraph_id: DeploymentHash,
-    pub block_hash: H256,
-    pub indexer: Option<Address>,
-}
-
-fn h256_as_bytes(val: &H256) -> AsBytes<&[u8]> {
-    AsBytes(val.as_bytes())
-}
-
-fn indexer_opt_as_bytes(val: &Option<Address>) -> Option<AsBytes<&[u8]>> {
-    val.as_ref().map(|v| AsBytes(v.as_bytes()))
-}
-
-impl_stable_hash!(PoI<'_> {
-    causality_regions,
-    subgraph_id,
-    block_hash: h256_as_bytes,
-    indexer: indexer_opt_as_bytes
-});
+use crate::util::stable_hash_glue::impl_stable_hash;
 
 pub struct PoICausalityRegion<'a> {
     pub blocks: Vec<Block<'a>>,
diff --git a/graph/src/components/subgraph/provider.rs b/graph/src/components/subgraph/provider.rs
deleted file mode 100644
index 5edc22391c8..00000000000
--- a/graph/src/components/subgraph/provider.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use async_trait::async_trait;
-
-use crate::{components::store::DeploymentLocator, prelude::*};
-
-/// Common trait for subgraph providers.
-#[async_trait]
-pub trait SubgraphAssignmentProvider: Send + Sync + 'static {
-    async fn start(
-        &self,
-        deployment: DeploymentLocator,
-        stop_block: Option<BlockNumber>,
-    ) -> Result<(), SubgraphAssignmentProviderError>;
-    async fn stop(
-        &self,
-        deployment: DeploymentLocator,
-    ) -> Result<(), SubgraphAssignmentProviderError>;
-}
diff --git a/graph/src/components/subgraph/registrar.rs b/graph/src/components/subgraph/registrar.rs
index 8da173cd70d..361a704e754 100644
--- a/graph/src/components/subgraph/registrar.rs
+++ b/graph/src/components/subgraph/registrar.rs
@@ -45,6 +45,7 @@ pub trait SubgraphRegistrar: Send + Sync + 'static {
         start_block_block: Option<BlockPtr>,
         graft_block_override: Option<BlockPtr>,
         history_blocks: Option<i32>,
+        ignore_graft_base: bool,
     ) -> Result<DeploymentLocator, SubgraphRegistrarError>;
 
     async fn remove_subgraph(&self, name: SubgraphName) -> Result<(), SubgraphRegistrarError>;
@@ -54,4 +55,8 @@ pub trait SubgraphRegistrar: Send + Sync + 'static {
         hash: &DeploymentHash,
         node_id: &NodeId,
     ) -> Result<(), SubgraphRegistrarError>;
+
+    async fn pause_subgraph(&self, hash: &DeploymentHash) -> Result<(), SubgraphRegistrarError>;
+
+    async fn resume_subgraph(&self, hash: &DeploymentHash) -> Result<(), SubgraphRegistrarError>;
 }
diff --git a/graph/src/components/subgraph/settings.rs b/graph/src/components/subgraph/settings.rs
index a7512614583..3e4db56c9ed 100644
--- a/graph/src/components/subgraph/settings.rs
+++ b/graph/src/components/subgraph/settings.rs
@@ -3,7 +3,7 @@ use std::fs::read_to_string;
 
 use crate::{
     anyhow,
-    prelude::{regex::Regex, SubgraphName},
+    prelude::{SubgraphName, regex::Regex},
 };
 use serde::{Deserialize, Serialize};
 
@@ -45,7 +45,7 @@ impl Settings {
         Self::from_str(&read_to_string(path)?)
     }
 
-    pub fn from_str(toml: &str) -> Result<Self, anyhow::Error> {
+    fn from_str(toml: &str) -> Result<Self, anyhow::Error> {
         toml::from_str::<Self>(toml).map_err(anyhow::Error::from)
     }
 
@@ -77,18 +77,12 @@ mod test {
         let section = Settings::from_str(content).unwrap();
         assert_eq!(section.settings.len(), 3);
 
-        let rule1 = match &section.settings[0].pred {
-            Predicate::Name(name) => name,
-        };
+        let Predicate::Name(rule1) = &section.settings[0].pred;
         assert_eq!(rule1.as_str(), ".*");
 
-        let rule2 = match &section.settings[1].pred {
-            Predicate::Name(name) => name,
-        };
+        let Predicate::Name(rule2) = &section.settings[1].pred;
         assert_eq!(rule2.as_str(), "xxxxx");
-        let rule1 = match &section.settings[2].pred {
-            Predicate::Name(name) => name,
-        };
+        let Predicate::Name(rule1) = &section.settings[2].pred;
         assert_eq!(rule1.as_str(), ".*!$");
     }
 }
diff --git a/graph/src/components/transaction_receipt.rs b/graph/src/components/transaction_receipt.rs
index dc8eaf6a730..52d3730ddc0 100644
--- a/graph/src/components/transaction_receipt.rs
+++ b/graph/src/components/transaction_receipt.rs
@@ -3,37 +3,28 @@
 //! This module exposes the [`LightTransactionReceipt`] type, which holds basic information about
 //! the retrieved transaction receipts.
 
-use web3::types::{TransactionReceipt, H256, U256, U64};
+use alloy::network::ReceiptResponse;
+use alloy::primitives::B256;
 
-/// Like web3::types::Receipt, but with fewer fields.
 #[derive(Debug, PartialEq, Eq)]
 pub struct LightTransactionReceipt {
-    pub transaction_hash: H256,
-    pub transaction_index: U64,
-    pub block_hash: Option<H256>,
-    pub block_number: Option<U64>,
-    pub gas_used: Option<U256>,
-    pub status: Option<U64>,
+    pub transaction_hash: B256,
+    pub transaction_index: u64,
+    pub block_hash: Option<B256>,
+    pub block_number: Option<u64>,
+    pub gas_used: u64,
+    pub status: bool,
 }
 
-impl From<TransactionReceipt> for LightTransactionReceipt {
-    fn from(receipt: TransactionReceipt) -> Self {
-        let TransactionReceipt {
-            transaction_hash,
-            transaction_index,
-            block_hash,
-            block_number,
-            gas_used,
-            status,
-            ..
-        } = receipt;
+impl From<super::ethereum::AnyTransactionReceiptBare> for LightTransactionReceipt {
+    fn from(receipt: super::ethereum::AnyTransactionReceiptBare) -> Self {
         LightTransactionReceipt {
-            transaction_hash,
-            transaction_index,
-            block_hash,
-            block_number,
-            gas_used,
-            status,
+            transaction_hash: receipt.transaction_hash,
+            transaction_index: receipt.transaction_index.unwrap(), // unwrap is safe because its None only for pending transactions, graph-node does not ingest pending transactions
+            block_hash: receipt.block_hash,
+            block_number: receipt.block_number,
+            gas_used: receipt.gas_used,
+            status: receipt.status(),
         }
     }
 }
diff --git a/graph/src/components/trigger_processor.rs b/graph/src/components/trigger_processor.rs
index ae58b9cd683..f21fe5b7894 100644
--- a/graph/src/components/trigger_processor.rs
+++ b/graph/src/components/trigger_processor.rs
@@ -3,13 +3,37 @@ use std::sync::Arc;
 use async_trait::async_trait;
 use slog::Logger;
 
-use crate::{blockchain::Blockchain, data_source::TriggerData, prelude::SubgraphInstanceMetrics};
+use crate::{
+    blockchain::Blockchain,
+    data_source::{MappingTrigger, TriggerData, TriggerWithHandler},
+    prelude::SubgraphInstanceMetrics,
+};
 
 use super::{
     store::SubgraphFork,
-    subgraph::{BlockState, MappingError, RuntimeHostBuilder, SharedProofOfIndexing},
+    subgraph::{BlockState, MappingError, RuntimeHost, RuntimeHostBuilder, SharedProofOfIndexing},
 };
 
+/// A trigger that is almost ready to run: we have a host to run it on, and
+/// transformed the `TriggerData` into a `MappingTrigger`.
+pub struct HostedTrigger<'a, C>
+where
+    C: Blockchain,
+{
+    pub host: &'a dyn RuntimeHost<C>,
+    pub mapping_trigger: TriggerWithHandler<MappingTrigger<C>>,
+}
+
+/// The `TriggerData` and the `HostedTriggers` that were derived from it. We
+/// need to hang on to the `TriggerData` solely for error reporting.
+pub struct RunnableTriggers<'a, C>
+where
+    C: Blockchain,
+{
+    pub trigger: TriggerData<C>,
+    pub hosted_triggers: Vec<HostedTrigger<'a, C>>,
+}
+
 #[async_trait]
 pub trait TriggerProcessor<C, T>: Sync + Send
 where
@@ -19,14 +43,54 @@ where
     async fn process_trigger<'a>(
         &'a self,
         logger: &Logger,
-        hosts: Box<dyn Iterator<Item = &T::Host> + Send + 'a>,
+        triggers: Vec<HostedTrigger<'a, C>>,
         block: &Arc<C::Block>,
-        trigger: &TriggerData<C>,
-        mut state: BlockState<C>,
+        mut state: BlockState,
         proof_of_indexing: &SharedProofOfIndexing,
         causality_region: &str,
         debug_fork: &Option<Arc<dyn SubgraphFork>>,
         subgraph_metrics: &Arc<SubgraphInstanceMetrics>,
         instrument: bool,
-    ) -> Result<BlockState<C>, MappingError>;
+    ) -> Result<BlockState, MappingError>;
+}
+
+/// A trait for taking triggers as `TriggerData` (usually from the block
+/// stream) and turning them into `HostedTrigger`s that are ready to run.
+///
+/// The output triggers will be run in the order in which they are returned.
+pub trait Decoder<C, T>: Sync + Send
+where
+    C: Blockchain,
+    T: RuntimeHostBuilder<C>,
+{
+    fn match_and_decode<'a>(
+        &'a self,
+        logger: &Logger,
+        block: &Arc<C::Block>,
+        trigger: TriggerData<C>,
+        hosts: Box<dyn Iterator<Item = &'a T::Host> + Send + 'a>,
+        subgraph_metrics: &Arc<SubgraphInstanceMetrics>,
+    ) -> Result<RunnableTriggers<'a, C>, MappingError>;
+
+    fn match_and_decode_many<'a, F>(
+        &'a self,
+        logger: &Logger,
+        block: &Arc<C::Block>,
+        triggers: Box<dyn Iterator<Item = TriggerData<C>>>,
+        hosts_filter: F,
+        subgraph_metrics: &Arc<SubgraphInstanceMetrics>,
+    ) -> Result<Vec<RunnableTriggers<'a, C>>, MappingError>
+    where
+        F: Fn(&TriggerData<C>) -> Box<dyn Iterator<Item = &'a T::Host> + Send + 'a>,
+    {
+        let mut runnables = vec![];
+        for trigger in triggers {
+            let hosts = hosts_filter(&trigger);
+            match self.match_and_decode(logger, block, trigger, hosts, subgraph_metrics) {
+                Ok(runnable_triggers) => runnables.push(runnable_triggers),
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(runnables)
+    }
 }
diff --git a/graph/src/data/graphql/ext.rs b/graph/src/data/graphql/ext.rs
index c0055185bfd..4177da59eae 100644
--- a/graph/src/data/graphql/ext.rs
+++ b/graph/src/data/graphql/ext.rs
@@ -1,11 +1,12 @@
 use anyhow::Error;
+use inflector::Inflector;
 
 use super::ObjectOrInterface;
 use crate::prelude::s::{
-    Definition, Directive, Document, EnumType, Field, InterfaceType, ObjectType, Type,
+    self, Definition, Directive, Document, EnumType, Field, InterfaceType, ObjectType, Type,
     TypeDefinition, Value,
 };
-use crate::prelude::{ValueType, ENV_VARS};
+use crate::prelude::{ENV_VARS, ValueType};
 use crate::schema::{META_FIELD_TYPE, SCHEMA_TYPE_NAME};
 use std::collections::{BTreeMap, HashMap};
 
@@ -51,8 +52,6 @@ pub trait DocumentExt {
 
     fn get_root_query_type(&self) -> Option<&ObjectType>;
 
-    fn get_root_subscription_type(&self) -> Option<&ObjectType>;
-
     fn object_or_interface(&self, name: &str) -> Option<ObjectOrInterface<'_>>;
 
     fn get_named_type(&self, name: &str) -> Option<&TypeDefinition>;
@@ -158,21 +157,6 @@ impl DocumentExt for Document {
             .next()
     }
 
-    fn get_root_subscription_type(&self) -> Option<&ObjectType> {
-        self.definitions
-            .iter()
-            .filter_map(|d| match d {
-                Definition::TypeDefinition(TypeDefinition::Object(t))
-                    if t.name == "Subscription" =>
-                {
-                    Some(t)
-                }
-                _ => None,
-            })
-            .peekable()
-            .next()
-    }
-
     fn object_or_interface(&self, name: &str) -> Option<ObjectOrInterface<'_>> {
         match self.get_named_type(name) {
             Some(TypeDefinition::Object(t)) => Some(t.into()),
@@ -253,10 +237,7 @@ impl TypeExt for Type {
 
     // Returns true if the given type is a non-null type.
     fn is_non_null(&self) -> bool {
-        match self {
-            Type::NonNullType(_) => true,
-            _ => false,
-        }
+        matches!(self, Type::NonNullType(_))
     }
 }
 
@@ -312,7 +293,16 @@ impl ValueExt for Value {
 
 pub trait DirectiveFinder {
     fn find_directive(&self, name: &str) -> Option<&Directive>;
-    fn is_derived(&self) -> bool;
+
+    fn is_derived(&self) -> bool {
+        self.find_directive("derivedFrom").is_some()
+    }
+
+    fn derived_from(&self) -> Option<&str> {
+        self.find_directive("derivedFrom")
+            .and_then(|directive| directive.argument("field"))
+            .and_then(|value| value.as_str())
+    }
 }
 
 impl DirectiveFinder for ObjectType {
@@ -321,12 +311,6 @@ impl DirectiveFinder for ObjectType {
             .iter()
             .find(|directive| directive.name.eq(&name))
     }
-
-    fn is_derived(&self) -> bool {
-        let is_derived = |directive: &Directive| directive.name.eq("derivedFrom");
-
-        self.directives.iter().any(is_derived)
-    }
 }
 
 impl DirectiveFinder for Field {
@@ -335,12 +319,6 @@ impl DirectiveFinder for Field {
             .iter()
             .find(|directive| directive.name.eq(name))
     }
-
-    fn is_derived(&self) -> bool {
-        let is_derived = |directive: &Directive| directive.name.eq("derivedFrom");
-
-        self.directives.iter().any(is_derived)
-    }
 }
 
 impl DirectiveFinder for Vec<Directive> {
@@ -378,22 +356,44 @@ impl TypeDefinitionExt for TypeDefinition {
     }
 }
 
+/// Return the singular and plural names for `name` for use in queries
+pub fn camel_cased_names(name: &str) -> (String, String) {
+    let singular = name.to_camel_case();
+    let mut plural = name.to_plural().to_camel_case();
+    if plural == singular {
+        plural.push_str("_collection");
+    }
+    (singular, plural)
+}
+
 pub trait FieldExt {
     // Return `true` if this is the name of one of the query fields from the
     // introspection schema
     fn is_introspection(&self) -> bool;
+
+    /// Return the singular and plural names for this field for use in
+    /// queries
+    fn camel_cased_names(&self) -> (String, String);
+
+    fn argument(&self, name: &str) -> Option<&s::InputValue>;
 }
 
 impl FieldExt for Field {
     fn is_introspection(&self) -> bool {
         &self.name == "__schema" || &self.name == "__type"
     }
+
+    fn camel_cased_names(&self) -> (String, String) {
+        camel_cased_names(&self.name)
+    }
+
+    fn argument(&self, name: &str) -> Option<&s::InputValue> {
+        self.arguments.iter().find(|iv| iv.name == name)
+    }
 }
 
 #[cfg(test)]
 mod directive_finder_tests {
-    use graphql_parser::parse_schema;
-
     use super::*;
 
     const SCHEMA: &str = "
@@ -405,7 +405,7 @@ mod directive_finder_tests {
     /// Makes sure that the DirectiveFinder::find_directive implementation for ObjectiveType and Field works
     #[test]
     fn find_directive_impls() {
-        let ast = parse_schema::<String>(SCHEMA).unwrap();
+        let ast = s::parse_schema::<String>(SCHEMA).unwrap();
         let object_types = ast.get_object_type_definitions();
         assert_eq!(object_types.len(), 1);
         let object_type = object_types[0];
@@ -428,7 +428,7 @@ mod directive_finder_tests {
     /// Makes sure that the DirectiveFinder::is_derived implementation for ObjectiveType and Field works
     #[test]
     fn is_derived_impls() {
-        let ast = parse_schema::<String>(SCHEMA).unwrap();
+        let ast = s::parse_schema::<String>(SCHEMA).unwrap();
         let object_types = ast.get_object_type_definitions();
         assert_eq!(object_types.len(), 1);
         let object_type = object_types[0];
diff --git a/graph/src/data/graphql/load_manager.rs b/graph/src/data/graphql/load_manager.rs
index 5e314d1607a..79655e25629 100644
--- a/graph/src/data/graphql/load_manager.rs
+++ b/graph/src/data/graphql/load_manager.rs
@@ -1,18 +1,20 @@
 //! Utilities to keep moving statistics about queries
 
 use prometheus::core::GenericCounter;
-use rand::{prelude::Rng, thread_rng};
+use rand::{prelude::Rng, rng};
 use std::collections::{HashMap, HashSet};
 use std::iter::FromIterator;
-use std::sync::{Arc, RwLock};
+use std::sync::Arc;
 use std::time::{Duration, Instant};
 
+use crate::parking_lot::RwLock;
+
 use crate::components::metrics::{Counter, GaugeVec, MetricsRegistry};
 use crate::components::store::{DeploymentId, PoolWaitStats};
 use crate::data::graphql::shape_hash::shape_hash;
 use crate::data::query::{CacheStatus, QueryExecutionError};
 use crate::prelude::q;
-use crate::prelude::{debug, info, o, warn, Logger, ENV_VARS};
+use crate::prelude::{ENV_VARS, Logger, debug, info, o, warn};
 use crate::util::stats::MovingStats;
 
 const SHARD_LABEL: [&str; 1] = ["shard"];
@@ -57,7 +59,7 @@ impl ShardEffort {
     }
 
     pub fn add(&self, shard: &str, qref: QueryRef, duration: Duration, gauge: &GaugeVec) {
-        let mut inner = self.inner.write().unwrap();
+        let mut inner = self.inner.write();
         inner.add(qref, duration);
         gauge
             .with_label_values(&[shard])
@@ -70,7 +72,7 @@ impl ShardEffort {
     /// data for the particular query, return `None` as the effort
     /// for the query
     pub fn current_effort(&self, qref: &QueryRef) -> (Option<Duration>, Duration) {
-        let inner = self.inner.read().unwrap();
+        let inner = self.inner.read();
         let total_effort = inner.total.duration();
         let query_effort = inner.effort.get(qref).map(|stats| stats.duration());
         (query_effort, total_effort)
@@ -310,9 +312,9 @@ impl LoadManager {
             .map(GenericCounter::inc);
         if !ENV_VARS.load_management_is_disabled() {
             let qref = QueryRef::new(deployment, shape_hash);
-            self.effort
-                .get(shard)
-                .map(|effort| effort.add(shard, qref, duration, &self.effort_gauge));
+            if let Some(effort) = self.effort.get(shard) {
+                effort.add(shard, qref, duration, &self.effort_gauge)
+            }
         }
     }
 
@@ -381,7 +383,7 @@ impl LoadManager {
 
         let qref = QueryRef::new(deployment, shape_hash);
 
-        if self.jailed_queries.read().unwrap().contains(&qref) {
+        if self.jailed_queries.read().contains(&qref) {
             return if ENV_VARS.load_simulate {
                 Proceed
             } else {
@@ -415,31 +417,31 @@ impl LoadManager {
         let total_effort = total_effort.as_millis() as f64;
 
         // When this variable is not set, we never jail any queries.
-        if let Some(jail_threshold) = ENV_VARS.load_jail_threshold {
-            if known_query && query_effort / total_effort > jail_threshold {
-                // Any single query that causes at least JAIL_THRESHOLD of the
-                // effort in an overload situation gets killed
-                warn!(self.logger, "Jailing query";
+        if let Some(jail_threshold) = ENV_VARS.load_jail_threshold
+            && known_query
+            && query_effort / total_effort > jail_threshold
+        {
+            // Any single query that causes at least JAIL_THRESHOLD of the
+            // effort in an overload situation gets killed
+            warn!(self.logger, "Jailing query";
                 "query" => query,
                 "sgd" => format!("sgd{}", qref.id),
                 "wait_ms" => wait_ms.as_millis(),
                 "query_effort_ms" => query_effort,
                 "total_effort_ms" => total_effort,
                 "ratio" => format!("{:.4}", query_effort/total_effort));
-                self.jailed_queries.write().unwrap().insert(qref);
-                return if ENV_VARS.load_simulate {
-                    Proceed
-                } else {
-                    TooExpensive
-                };
-            }
+            self.jailed_queries.write().insert(qref);
+            return if ENV_VARS.load_simulate {
+                Proceed
+            } else {
+                TooExpensive
+            };
         }
 
         // Kill random queries in case we have no queries, or not enough queries
         // that cause at least 20% of the effort
         let kill_rate = self.update_kill_rate(shard, kill_rate, last_update, overloaded, wait_ms);
-        let decline =
-            thread_rng().gen_bool((kill_rate * query_effort / total_effort).min(1.0).max(0.0));
+        let decline = rng().random_bool((kill_rate * query_effort / total_effort).clamp(0.0, 1.0));
         if decline {
             if ENV_VARS.load_simulate {
                 debug!(self.logger, "Declining query";
@@ -458,7 +460,7 @@ impl LoadManager {
     }
 
     fn overloaded(&self, wait_stats: &PoolWaitStats) -> (bool, Duration) {
-        let store_avg = wait_stats.read().unwrap().average();
+        let store_avg = wait_stats.average();
         let overloaded = store_avg
             .map(|average| average > ENV_VARS.load_threshold)
             .unwrap_or(false);
@@ -466,7 +468,7 @@ impl LoadManager {
     }
 
     fn kill_state(&self, shard: &str) -> (f64, Instant) {
-        let state = self.kill_state.get(shard).unwrap().read().unwrap();
+        let state = self.kill_state.get(shard).unwrap().read();
         (state.kill_rate, state.last_update)
     }
 
@@ -506,7 +508,7 @@ impl LoadManager {
                 kill_rate = (kill_rate - KILL_RATE_STEP_DOWN).max(0.0);
             }
             let event = {
-                let mut state = self.kill_state.get(shard).unwrap().write().unwrap();
+                let mut state = self.kill_state.get(shard).unwrap().write();
                 state.kill_rate = kill_rate;
                 state.last_update = now;
                 state.log_event(now, kill_rate, overloaded)
diff --git a/graph/src/data/graphql/mod.rs b/graph/src/data/graphql/mod.rs
index 1bb2c691411..fe6b6d8707d 100644
--- a/graph/src/data/graphql/mod.rs
+++ b/graph/src/data/graphql/mod.rs
@@ -30,4 +30,4 @@ pub use object_or_interface::ObjectOrInterface;
 
 pub mod object_macro;
 pub use crate::object;
-pub use object_macro::{object_value, IntoValue};
+pub use object_macro::{IntoValue, object_value};
diff --git a/graph/src/data/graphql/object_or_interface.rs b/graph/src/data/graphql/object_or_interface.rs
index 625965f2ba1..b86764bbdc5 100644
--- a/graph/src/data/graphql/object_or_interface.rs
+++ b/graph/src/data/graphql/object_or_interface.rs
@@ -100,7 +100,7 @@ impl<'a> ObjectOrInterface<'a> {
     }
 
     pub fn field(&self, name: &str) -> Option<&s::Field> {
-        self.fields().iter().find(|field| &field.name == name)
+        self.fields().iter().find(|field| field.name == name)
     }
 
     pub fn object_types(self, schema: &'a Schema) -> Option<Vec<&'a s::ObjectType>> {
diff --git a/graph/src/data/graphql/shape_hash.rs b/graph/src/data/graphql/shape_hash.rs
index 00ab6476c9f..017093c641c 100644
--- a/graph/src/data/graphql/shape_hash.rs
+++ b/graph/src/data/graphql/shape_hash.rs
@@ -38,7 +38,7 @@ impl ShapeHash for q::Document {
 
 impl ShapeHash for q::OperationDefinition {
     fn shape_hash(&self, hasher: &mut ShapeHasher) {
-        use graphql_parser::query::OperationDefinition::*;
+        use graphql_tools::parser::query::OperationDefinition::*;
         // We want `[query|subscription|mutation] things { BODY }` to hash
         // to the same thing as just `things { BODY }`
         match self {
@@ -69,7 +69,7 @@ impl ShapeHash for q::SelectionSet {
 
 impl ShapeHash for q::Selection {
     fn shape_hash(&self, hasher: &mut ShapeHasher) {
-        use graphql_parser::query::Selection::*;
+        use graphql_tools::parser::query::Selection::*;
         match self {
             Field(field) => field.shape_hash(hasher),
             FragmentSpread(spread) => spread.shape_hash(hasher),
@@ -92,7 +92,7 @@ impl ShapeHash for q::Field {
 
 impl ShapeHash for s::Value {
     fn shape_hash(&self, hasher: &mut ShapeHasher) {
-        use graphql_parser::schema::Value::*;
+        use graphql_tools::parser::schema::Value::*;
 
         match self {
             Variable(_) | Int(_) | Float(_) | String(_) | Boolean(_) | Null | Enum(_) => {
@@ -151,7 +151,6 @@ impl ShapeHash for q::TypeCondition {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use graphql_parser::parse_query;
 
     #[test]
     fn identical_and_different() {
@@ -159,16 +158,16 @@ mod tests {
         const Q2: &str = "{ things(where: { stuff_gt: 42 }) { id } }";
         const Q3: &str = "{ things(where: { stuff_lte: 42 }) { id } }";
         const Q4: &str = "{ things(where: { stuff_gt: 42 }) { id name } }";
-        let q1 = parse_query(Q1)
+        let q1 = q::parse_query(Q1)
             .expect("q1 is syntactically valid")
             .into_static();
-        let q2 = parse_query(Q2)
+        let q2 = q::parse_query(Q2)
             .expect("q2 is syntactically valid")
             .into_static();
-        let q3 = parse_query(Q3)
+        let q3 = q::parse_query(Q3)
             .expect("q3 is syntactically valid")
             .into_static();
-        let q4 = parse_query(Q4)
+        let q4 = q::parse_query(Q4)
             .expect("q4 is syntactically valid")
             .into_static();
 
diff --git a/graph/src/data/graphql/values.rs b/graph/src/data/graphql/values.rs
index 7f15d26dc98..6e493675e48 100644
--- a/graph/src/data/graphql/values.rs
+++ b/graph/src/data/graphql/values.rs
@@ -1,12 +1,12 @@
-use anyhow::{anyhow, Error};
+use alloy::primitives::Address;
+use anyhow::{Error, anyhow};
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::str::FromStr;
 
 use crate::blockchain::BlockHash;
 use crate::data::value::Object;
-use crate::prelude::{r, BigInt};
-use web3::types::H160;
+use crate::prelude::{BigInt, r};
 
 pub trait TryFromValue: Sized {
     fn try_from_value(value: &r::Value) -> Result<Self, Error>;
@@ -74,16 +74,11 @@ impl TryFromValue for i32 {
     }
 }
 
-impl TryFromValue for H160 {
+impl TryFromValue for Address {
     fn try_from_value(value: &r::Value) -> Result<Self, Error> {
         match value {
-            r::Value::String(s) => {
-                // `H160::from_str` takes a hex string with no leading `0x`.
-                let string = s.trim_start_matches("0x");
-                H160::from_str(string).map_err(|e| {
-                    anyhow!("Cannot parse Address/H160 value from string `{}`: {}", s, e)
-                })
-            }
+            r::Value::String(s) => Address::from_str(s)
+                .map_err(|e| anyhow!("Cannot parse Address/H160 value from string `{}`: {}", s, e)),
             _ => Err(anyhow!(
                 "Cannot parse value into an Address/H160: {:?}",
                 value
diff --git a/graph/src/data/graphql/visitor.rs b/graph/src/data/graphql/visitor.rs
deleted file mode 100644
index 94d26c08644..00000000000
--- a/graph/src/data/graphql/visitor.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use crate::prelude::q;
-
-pub trait Visitor<E> {
-    fn enter_field(&mut self, _: &q::Field) -> Result<(), E> {
-        Ok(())
-    }
-    fn leave_field(&mut self, _: &mut q::Field) -> Result<(), E> {
-        Ok(())
-    }
-
-    fn enter_query(&mut self, _: &q::Query) -> Result<(), E> {
-        Ok(())
-    }
-    fn leave_query(&mut self, _: &mut q::Query) -> Result<(), E> {
-        Ok(())
-    }
-
-    fn visit_fragment_spread(&mut self, _: &q::FragmentSpread) -> Result<(), E> {
-        Ok(())
-    }
-}
-
-pub fn visit<E, T>(visitor: &mut dyn Visitor<E>, doc: &mut q::Document) -> Result<(), E> {
-    for def in &mut doc.definitions {
-        match def {
-            q::Definition::Operation(op) => match op {
-                q::OperationDefinition::SelectionSet(set) => {
-                    visit_selection_set(visitor, set)?;
-                }
-                q::OperationDefinition::Query(query) => {
-                    visitor.enter_query(query)?;
-                    visit_selection_set(visitor, &mut query.selection_set)?;
-                    visitor.leave_query(query)?;
-                }
-                q::OperationDefinition::Mutation(_) => todo!(),
-                q::OperationDefinition::Subscription(_) => todo!(),
-            },
-            q::Definition::Fragment(frag) => {}
-        }
-    }
-    Ok(())
-}
-
-fn visit_selection_set<E>(
-    visitor: &mut dyn Visitor<E>,
-    set: &mut q::SelectionSet,
-) -> Result<(), E> {
-    for sel in &mut set.items {
-        match sel {
-            q::Selection::Field(field) => {
-                visitor.enter_field(field)?;
-                visit_selection_set(visitor, &mut field.selection_set)?;
-                visitor.leave_field(field)?;
-            }
-            q::Selection::FragmentSpread(frag) => {
-                visitor.visit_fragment_spread(frag)?;
-            }
-            q::Selection::InlineFragment(frag) => {}
-        }
-    }
-    Ok(())
-}
diff --git a/graph/src/data/mod.rs b/graph/src/data/mod.rs
index 45f085c96fa..246d4cdba12 100644
--- a/graph/src/data/mod.rs
+++ b/graph/src/data/mod.rs
@@ -7,9 +7,6 @@ pub mod query;
 /// Data types for dealing with storing entities.
 pub mod store;
 
-/// Data types for dealing with GraphQL subscriptions.
-pub mod subscription;
-
 /// Data types for dealing with GraphQL values.
 pub mod graphql;
 
diff --git a/graph/src/data/query/cache_status.rs b/graph/src/data/query/cache_status.rs
index 93d7a96853e..0a713e81a46 100644
--- a/graph/src/data/query/cache_status.rs
+++ b/graph/src/data/query/cache_status.rs
@@ -1,8 +1,12 @@
 use std::fmt;
 use std::slice::Iter;
 
+use serde::Serialize;
+
+use crate::derive::CacheWeight;
+
 /// Used for checking if a response hit the cache.
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, CacheWeight, Debug, PartialEq, Eq, Hash, Default)]
 pub enum CacheStatus {
     /// Hit is a hit in the generational cache.
     Hit,
@@ -14,23 +18,13 @@ pub enum CacheStatus {
     Insert,
 
     /// A miss is none of the above.
+    #[default]
     Miss,
 }
 
-impl Default for CacheStatus {
-    fn default() -> Self {
-        CacheStatus::Miss
-    }
-}
-
 impl fmt::Display for CacheStatus {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            CacheStatus::Hit => f.write_str("hit"),
-            CacheStatus::Shared => f.write_str("shared"),
-            CacheStatus::Insert => f.write_str("insert"),
-            CacheStatus::Miss => f.write_str("miss"),
-        }
+        f.write_str(self.as_str())
     }
 }
 
@@ -40,4 +34,29 @@ impl CacheStatus {
         static STATUSES: [CacheStatus; 4] = [Hit, Shared, Insert, Miss];
         STATUSES.iter()
     }
+
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            CacheStatus::Hit => "hit",
+            CacheStatus::Shared => "shared",
+            CacheStatus::Insert => "insert",
+            CacheStatus::Miss => "miss",
+        }
+    }
+
+    pub fn uses_database(&self) -> bool {
+        match self {
+            CacheStatus::Hit | CacheStatus::Shared => false,
+            CacheStatus::Insert | CacheStatus::Miss => true,
+        }
+    }
+}
+
+impl Serialize for CacheStatus {
+    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        ser.serialize_str(self.as_str())
+    }
 }
diff --git a/graph/src/data/query/error.rs b/graph/src/data/query/error.rs
index e1564041a93..aa6f84b2591 100644
--- a/graph/src/data/query/error.rs
+++ b/graph/src/data/query/error.rs
@@ -1,4 +1,3 @@
-use graphql_parser::Pos;
 use hex::FromHexError;
 use serde::ser::*;
 use std::collections::HashMap;
@@ -26,23 +25,22 @@ pub enum QueryExecutionError {
     OperationNameRequired,
     OperationNotFound(String),
     NotSupported(String),
-    NoRootSubscriptionObjectType,
-    NonNullError(Pos, String),
-    ListValueError(Pos, String),
+    NonNullError(q::Pos, String),
+    ListValueError(q::Pos, String),
     NamedTypeError(String),
     AbstractTypeError(String),
-    InvalidArgumentError(Pos, String, q::Value),
-    MissingArgumentError(Pos, String),
-    ValidationError(Option<Pos>, String),
-    InvalidVariableTypeError(Pos, String),
-    MissingVariableError(Pos, String),
+    InvalidArgumentError(q::Pos, String, q::Value),
+    MissingArgumentError(q::Pos, String),
+    ValidationError(Option<q::Pos>, String),
+    InvalidVariableTypeError(q::Pos, String),
+    MissingVariableError(q::Pos, String),
     ResolveEntitiesError(String),
     OrderByNotSupportedError(String, String),
     OrderByNotSupportedForType(String),
     FilterNotSupportedError(String, String),
-    UnknownField(Pos, String, String),
+    UnknownField(q::Pos, String, String),
     EmptyQuery,
-    MultipleSubscriptionFields,
+    InvalidOrFilterStructure(Vec<String>, String),
     SubgraphDeploymentIdError(String),
     RangeArgumentsError(&'static str, u32, i64),
     InvalidFilterError,
@@ -56,10 +54,10 @@ pub enum QueryExecutionError {
     StoreError(CloneableAnyhowError),
     Timeout,
     EmptySelectionSet(String),
-    AmbiguousDerivedFromResult(Pos, String, String, String),
+    AmbiguousDerivedFromResult(q::Pos, String, String, String),
     Unimplemented(String),
-    EnumCoercionError(Pos, String, q::Value, String, Vec<String>),
-    ScalarCoercionError(Pos, String, q::Value, String),
+    EnumCoercionError(q::Pos, String, q::Value, String, Vec<String>),
+    ScalarCoercionError(q::Pos, String, q::Value, String),
     TooComplex(u64, u64), // (complexity, max_complexity)
     TooDeep(u8),          // max_depth
     CyclicalFragment(String),
@@ -67,7 +65,6 @@ pub enum QueryExecutionError {
     Throttled,
     UndefinedFragment(String),
     Panic(String),
-    EventStreamError,
     FulltextQueryRequiresFilter,
     FulltextQueryInvalidSyntax(String),
     DeploymentReverted,
@@ -75,8 +72,10 @@ pub enum QueryExecutionError {
     InvalidSubgraphManifest,
     ResultTooBig(usize, usize),
     DeploymentNotFound(String),
+    SqlError(String),
     IdMissing,
     IdNotString,
+    InternalError(String),
 }
 
 impl QueryExecutionError {
@@ -86,7 +85,6 @@ impl QueryExecutionError {
             OperationNameRequired
             | OperationNotFound(_)
             | NotSupported(_)
-            | NoRootSubscriptionObjectType
             | NonNullError(_, _)
             | NamedTypeError(_)
             | AbstractTypeError(_)
@@ -100,7 +98,7 @@ impl QueryExecutionError {
             | ChildFilterNestingNotSupportedError(_, _)
             | UnknownField(_, _, _)
             | EmptyQuery
-            | MultipleSubscriptionFields
+            | InvalidOrFilterStructure(_, _)
             | SubgraphDeploymentIdError(_)
             | InvalidFilterError
             | EntityFieldError(_, _)
@@ -126,7 +124,6 @@ impl QueryExecutionError {
             | TooComplex(_, _)
             | TooDeep(_)
             | Panic(_)
-            | EventStreamError
             | TooExpensive
             | Throttled
             | DeploymentReverted
@@ -136,7 +133,9 @@ impl QueryExecutionError {
             | ResultTooBig(_, _)
             | DeploymentNotFound(_)
             | IdMissing
-            | IdNotString => false,
+            | IdNotString
+            | InternalError(_) => false,
+            SqlError(_) => false,
         }
     }
 }
@@ -164,9 +163,6 @@ impl fmt::Display for QueryExecutionError {
                 write!(f, "{}", message)
             }
             NotSupported(s) => write!(f, "Not supported: {}", s),
-            NoRootSubscriptionObjectType => {
-                write!(f, "No root Subscription type defined in the schema")
-            }
             NonNullError(_, s) => {
                 write!(f, "Null value resolved for non-null field `{}`", s)
             }
@@ -195,7 +191,11 @@ impl fmt::Display for QueryExecutionError {
                 write!(f, "Failed to get entities from store: {}", e)
             }
             OrderByNotSupportedError(entity, field) => {
-                write!(f, "Ordering by `{}` is not supported for type `{}`", field, entity)
+                write!(
+                    f,
+                    "Ordering by `{}` is not supported for type `{}`",
+                    field, entity
+                )
             }
             OrderByNotSupportedForType(field_type) => {
                 write!(f, "Ordering by `{}` fields is not supported", field_type)
@@ -204,23 +204,35 @@ impl fmt::Display for QueryExecutionError {
                 write!(f, "Filter not supported by value `{}`: `{}`", value, filter)
             }
             ChildFilterNestingNotSupportedError(value, filter) => {
-                write!(f, "Child filter nesting not supported by value `{}`: `{}`", value, filter)
+                write!(
+                    f,
+                    "Child filter nesting not supported by value `{}`: `{}`",
+                    value, filter
+                )
             }
             UnknownField(_, t, s) => {
                 write!(f, "Type `{}` has no field `{}`", t, s)
             }
             EmptyQuery => write!(f, "The query is empty"),
-            MultipleSubscriptionFields => write!(
-                f,
-                "Only a single top-level field is allowed in subscriptions"
-            ),
             SubgraphDeploymentIdError(s) => {
                 write!(f, "Failed to get subgraph ID from type: `{}`", s)
             }
             RangeArgumentsError(arg, max, actual) => {
-                write!(f, "The `{}` argument must be between 0 and {}, but is {}", arg, max, actual)
+                write!(
+                    f,
+                    "The `{}` argument must be between 0 and {}, but is {}",
+                    arg, max, actual
+                )
             }
             InvalidFilterError => write!(f, "Filter must by an object"),
+            InvalidOrFilterStructure(fields, example) => {
+                write!(
+                    f,
+                    "Cannot mix column filters with 'or' operator at the same level. Found column filter(s) {} alongside 'or' operator.\n\n{}",
+                    fields.join(", "),
+                    example
+                )
+            }
             EntityFieldError(e, a) => {
                 write!(f, "Entity `{}` has no attribute `{}`", e, a)
             }
@@ -238,7 +250,11 @@ impl fmt::Display for QueryExecutionError {
                 write!(f, "Failed to decode `{}` value: `{}`", t, e)
             }
             AttributeTypeError(value, ty) => {
-                write!(f, "Query contains value with invalid type `{}`: `{}`", ty, value)
+                write!(
+                    f,
+                    "Query contains value with invalid type `{}`: `{}`",
+                    ty, value
+                )
             }
             EntityParseError(s) => {
                 write!(f, "Broken entity found in store: {}", s)
@@ -251,41 +267,82 @@ impl fmt::Display for QueryExecutionError {
                 write!(f, "Selection set for type `{}` is empty", entity_type)
             }
             AmbiguousDerivedFromResult(_, field, target_type, target_field) => {
-                write!(f, "Ambiguous result for derived field `{}`: \
+                write!(
+                    f,
+                    "Ambiguous result for derived field `{}`: \
                            Multiple `{}` entities refer back via `{}`",
-                       field, target_type, target_field)
+                    field, target_type, target_field
+                )
             }
             Unimplemented(feature) => {
                 write!(f, "Feature `{}` is not yet implemented", feature)
             }
             EnumCoercionError(_, field, value, enum_type, values) => {
-                write!(f, "Failed to coerce value `{}` of field `{}` to enum type `{}`. Possible values are: {}", value, field, enum_type, values.join(", "))
+                write!(
+                    f,
+                    "Failed to coerce value `{}` of field `{}` to enum type `{}`. Possible values are: {}",
+                    value,
+                    field,
+                    enum_type,
+                    values.join(", ")
+                )
             }
             ScalarCoercionError(_, field, value, scalar_type) => {
-                write!(f, "Failed to coerce value `{}` of field `{}` to scalar type `{}`", value, field, scalar_type)
+                write!(
+                    f,
+                    "Failed to coerce value `{}` of field `{}` to scalar type `{}`",
+                    value, field, scalar_type
+                )
             }
             TooComplex(complexity, max_complexity) => {
-                write!(f, "query potentially returns `{}` entities or more and thereby exceeds \
+                write!(
+                    f,
+                    "query potentially returns `{}` entities or more and thereby exceeds \
                            the limit of `{}` entities. Possible solutions are reducing the depth \
                            of the query, querying fewer relationships or using `first` to \
-                           return smaller collections", complexity, max_complexity)
+                           return smaller collections",
+                    complexity, max_complexity
+                )
             }
-            TooDeep(max_depth) => write!(f, "query has a depth that exceeds the limit of `{}`", max_depth),
-            CyclicalFragment(name) =>write!(f, "query has fragment cycle including `{}`", name),
+            TooDeep(max_depth) => write!(
+                f,
+                "query has a depth that exceeds the limit of `{}`",
+                max_depth
+            ),
+            CyclicalFragment(name) => write!(f, "query has fragment cycle including `{}`", name),
             UndefinedFragment(frag_name) => write!(f, "fragment `{}` is not defined", frag_name),
             Panic(msg) => write!(f, "panic processing query: {}", msg),
-            EventStreamError => write!(f, "error in the subscription event stream"),
-            FulltextQueryRequiresFilter => write!(f, "fulltext search queries can only use EntityFilter::Equal"),
-            FulltextQueryInvalidSyntax(msg) => write!(f, "Invalid fulltext search query syntax. Error: {}. Hint: Search terms with spaces need to be enclosed in single quotes", msg),
+            FulltextQueryRequiresFilter => write!(
+                f,
+                "fulltext search queries can only use EntityFilter::Equal"
+            ),
+            FulltextQueryInvalidSyntax(msg) => write!(
+                f,
+                "Invalid fulltext search query syntax. Error: {}. Hint: Search terms with spaces need to be enclosed in single quotes",
+                msg
+            ),
             TooExpensive => write!(f, "query is too expensive"),
-            Throttled => write!(f, "service is overloaded and can not run the query right now. Please try again in a few minutes"),
+            Throttled => write!(
+                f,
+                "service is overloaded and can not run the query right now. Please try again in a few minutes"
+            ),
             DeploymentReverted => write!(f, "the chain was reorganized while executing the query"),
-            SubgraphManifestResolveError(e) => write!(f, "failed to resolve subgraph manifest: {}", e),
+            SubgraphManifestResolveError(e) => {
+                write!(f, "failed to resolve subgraph manifest: {}", e)
+            }
             InvalidSubgraphManifest => write!(f, "invalid subgraph manifest file"),
-            ResultTooBig(actual, limit) => write!(f, "the result size of {} is larger than the allowed limit of {}", actual, limit),
-            DeploymentNotFound(id_or_name) => write!(f, "deployment `{}` does not exist", id_or_name),
+            ResultTooBig(actual, limit) => write!(
+                f,
+                "the result size of {} is larger than the allowed limit of {}",
+                actual, limit
+            ),
+            DeploymentNotFound(id_or_name) => {
+                write!(f, "deployment `{}` does not exist", id_or_name)
+            }
             IdMissing => write!(f, "entity is missing an `id` attribute"),
             IdNotString => write!(f, "entity `id` attribute is not a string"),
+            InternalError(msg) => write!(f, "internal error: {}", msg),
+            SqlError(e) => write!(f, "sql error: {}", e),
         }
     }
 }
@@ -302,8 +359,8 @@ impl From<FromHexError> for QueryExecutionError {
     }
 }
 
-impl From<bigdecimal::ParseBigDecimalError> for QueryExecutionError {
-    fn from(e: bigdecimal::ParseBigDecimalError) -> Self {
+impl From<old_bigdecimal::ParseBigDecimalError> for QueryExecutionError {
+    fn from(e: old_bigdecimal::ParseBigDecimalError) -> Self {
         QueryExecutionError::ValueParseError("BigDecimal".to_string(), format!("{}", e))
     }
 }
@@ -317,6 +374,7 @@ impl From<StoreError> for QueryExecutionError {
             StoreError::ChildFilterNestingNotSupportedError(attr, filter) => {
                 QueryExecutionError::ChildFilterNestingNotSupportedError(attr, filter)
             }
+            StoreError::InternalError(msg) => QueryExecutionError::InternalError(msg),
             _ => QueryExecutionError::StoreError(CloneableAnyhowError(Arc::new(e.into()))),
         }
     }
diff --git a/graph/src/data/query/mod.rs b/graph/src/data/query/mod.rs
index 7b5a901908f..b278160a01d 100644
--- a/graph/src/data/query/mod.rs
+++ b/graph/src/data/query/mod.rs
@@ -1,11 +1,12 @@
 mod cache_status;
 mod error;
+#[allow(clippy::module_inception)]
 mod query;
 mod result;
 mod trace;
 
 pub use self::cache_status::CacheStatus;
 pub use self::error::{QueryError, QueryExecutionError};
-pub use self::query::{Query, QueryTarget, QueryVariables};
-pub use self::result::{QueryResult, QueryResults};
+pub use self::query::{Query, QueryTarget, QueryVariables, SqlQueryMode, SqlQueryReq};
+pub use self::result::{LatestBlockInfo, QueryResult, QueryResults};
 pub use self::trace::Trace;
diff --git a/graph/src/data/query/query.rs b/graph/src/data/query/query.rs
index 2ca93f0cc43..ab069852374 100644
--- a/graph/src/data/query/query.rs
+++ b/graph/src/data/query/query.rs
@@ -1,13 +1,14 @@
 use serde::de::Deserializer;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashMap};
 use std::convert::TryFrom;
+use std::hash::{DefaultHasher, Hash as _, Hasher as _};
 use std::ops::{Deref, DerefMut};
 use std::sync::Arc;
 
 use crate::{
     data::graphql::shape_hash::shape_hash,
-    prelude::{q, r, ApiVersion, DeploymentHash, SubgraphName, ENV_VARS},
+    prelude::{ApiVersion, DeploymentHash, ENV_VARS, SubgraphName, q, r},
 };
 
 fn deserialize_number<'de, D>(deserializer: D) -> Result<q::Number, D::Error>
@@ -126,6 +127,7 @@ impl QueryTarget {
 
 /// A GraphQL query as submitted by a client, either directly or through a subscription.
 #[derive(Clone, Debug)]
+#[non_exhaustive]
 pub struct Query {
     pub document: q::Document,
     pub variables: Option<QueryVariables>,
@@ -133,7 +135,6 @@ pub struct Query {
     pub query_text: Arc<String>,
     pub variables_text: Arc<String>,
     pub trace: bool,
-    _force_use_of_new: (),
 }
 
 impl Query {
@@ -146,7 +147,7 @@ impl Query {
         {
             (
                 document
-                    .format(graphql_parser::Style::default().indent(0))
+                    .format(graphql_tools::parser::Style::default().indent(0))
                     .replace('\n', " "),
                 serde_json::to_string(&variables).unwrap_or_default(),
             )
@@ -161,7 +162,29 @@ impl Query {
             query_text: Arc::new(query_text),
             variables_text: Arc::new(variables_text),
             trace,
-            _force_use_of_new: (),
         }
     }
 }
+
+#[derive(Copy, Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum SqlQueryMode {
+    Data,
+    Info,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct SqlQueryReq {
+    pub deployment: DeploymentHash,
+    pub query: String,
+    pub mode: SqlQueryMode,
+}
+
+impl SqlQueryReq {
+    pub fn query_hash(&self) -> u64 {
+        let mut hasher = DefaultHasher::new();
+        self.deployment.hash(&mut hasher);
+        self.query.hash(&mut hasher);
+        hasher.finish()
+    }
+}
diff --git a/graph/src/data/query/result.rs b/graph/src/data/query/result.rs
index 4f0f0e26842..5694bf3fcd9 100644
--- a/graph/src/data/query/result.rs
+++ b/graph/src/data/query/result.rs
@@ -1,16 +1,23 @@
 use super::error::{QueryError, QueryExecutionError};
+use super::trace::{HttpTrace, TRACE_NONE};
+use crate::cheap_clone::CheapClone;
+use crate::components::server::query::ServerResponse;
 use crate::data::value::Object;
-use crate::prelude::{r, CacheWeight, DeploymentHash};
-use http::header::{
+use crate::derive::CacheWeight;
+use crate::prelude::{BlockHash, BlockNumber, CacheWeight, DeploymentHash, r};
+use http_body_util::Full;
+use hyper::Response;
+use hyper::header::{
     ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
     CONTENT_TYPE,
 };
-use serde::ser::*;
 use serde::Serialize;
+use serde::ser::*;
 use std::convert::TryFrom;
 use std::sync::Arc;
+use std::time::Instant;
 
-use super::Trace;
+use super::{CacheStatus, Trace};
 
 fn serialize_data<S>(data: &Option<Data>, serializer: S) -> Result<S::Ok, S::Error>
 where
@@ -41,18 +48,37 @@ where
     ser.end()
 }
 
+fn serialize_block_hash<S>(data: &BlockHash, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    serializer.serialize_str(&data.to_string())
+}
+
 pub type Data = Object;
 
 #[derive(Debug)]
 /// A collection of query results that is serialized as a single result.
 pub struct QueryResults {
     results: Vec<Arc<QueryResult>>,
+    pub trace: Trace,
+    pub indexed_block: Option<LatestBlockInfo>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct LatestBlockInfo {
+    #[serde(serialize_with = "serialize_block_hash")]
+    pub hash: BlockHash,
+    pub number: BlockNumber,
+    pub timestamp: Option<u64>,
 }
 
 impl QueryResults {
-    pub fn empty() -> Self {
+    pub fn empty(trace: Trace, indexed_block: Option<LatestBlockInfo>) -> Self {
         QueryResults {
             results: Vec::new(),
+            trace,
+            indexed_block,
         }
     }
 
@@ -75,17 +101,18 @@ impl QueryResults {
             .next()
     }
 
-    pub fn traces(&self) -> Vec<&Trace> {
-        self.results.iter().map(|res| &res.trace).collect()
-    }
-
     pub fn errors(&self) -> Vec<QueryError> {
         self.results.iter().flat_map(|r| r.errors.clone()).collect()
     }
+
+    pub fn is_attestable(&self) -> bool {
+        self.results.iter().all(|r| r.is_attestable())
+    }
 }
 
 impl Serialize for QueryResults {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let start = Instant::now();
         let mut len = 0;
         let has_data = self.results.iter().any(|r| r.has_data());
         if has_data {
@@ -95,14 +122,7 @@ impl Serialize for QueryResults {
         if has_errors {
             len += 1;
         }
-        let first_trace = self
-            .results
-            .iter()
-            .find(|r| !r.trace.is_none())
-            .map(|r| &r.trace);
-        if first_trace.is_some() {
-            len += 1;
-        }
+        len += 1;
         let mut state = serializer.serialize_struct("QueryResults", len)?;
 
         // Serialize data.
@@ -138,8 +158,10 @@ impl Serialize for QueryResults {
             state.serialize_field("errors", &SerError(self))?;
         }
 
-        if let Some(trace) = first_trace {
-            state.serialize_field("trace", trace)?;
+        if !self.trace.is_none() {
+            let http = HttpTrace::new(start.elapsed(), self.results.weight());
+            state.serialize_field("trace", &self.trace)?;
+            state.serialize_field("http", &http)?;
         }
         state.end()
     }
@@ -149,6 +171,8 @@ impl From<Data> for QueryResults {
     fn from(x: Data) -> Self {
         QueryResults {
             results: vec![Arc::new(x.into())],
+            trace: Trace::None,
+            indexed_block: None,
         }
     }
 }
@@ -157,13 +181,19 @@ impl From<QueryResult> for QueryResults {
     fn from(x: QueryResult) -> Self {
         QueryResults {
             results: vec![Arc::new(x)],
+            trace: Trace::None,
+            indexed_block: None,
         }
     }
 }
 
 impl From<Arc<QueryResult>> for QueryResults {
     fn from(x: Arc<QueryResult>) -> Self {
-        QueryResults { results: vec![x] }
+        QueryResults {
+            results: vec![x],
+            trace: Trace::None,
+            indexed_block: None,
+        }
     }
 }
 
@@ -171,6 +201,8 @@ impl From<QueryExecutionError> for QueryResults {
     fn from(x: QueryExecutionError) -> Self {
         QueryResults {
             results: vec![Arc::new(x.into())],
+            trace: Trace::None,
+            indexed_block: None,
         }
     }
 }
@@ -179,38 +211,39 @@ impl From<Vec<QueryExecutionError>> for QueryResults {
     fn from(x: Vec<QueryExecutionError>) -> Self {
         QueryResults {
             results: vec![Arc::new(x.into())],
+            trace: Trace::None,
+            indexed_block: None,
         }
     }
 }
 
 impl QueryResults {
-    pub fn append(&mut self, other: Arc<QueryResult>) {
+    pub fn append(&mut self, other: Arc<QueryResult>, cache_status: CacheStatus) {
+        let trace = other.trace.cheap_clone();
+        self.trace.append(trace, cache_status);
         self.results.push(other);
     }
 
-    pub fn as_http_response<T: From<String>>(&self) -> http::Response<T> {
-        let status_code = http::StatusCode::OK;
-
-        let json =
-            serde_json::to_string(self).expect("Failed to serialize GraphQL response to JSON");
-
-        http::Response::builder()
-            .status(status_code)
+    pub fn as_http_response(&self) -> ServerResponse {
+        let json = serde_json::to_string(&self).unwrap();
+        let attestable = self.results.iter().all(|r| r.is_attestable());
+        let indexed_block = serde_json::to_string(&self.indexed_block).unwrap();
+        Response::builder()
+            .status(200)
             .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+            .header(CONTENT_TYPE, "application/json")
             .header(ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type, User-Agent")
             .header(ACCESS_CONTROL_ALLOW_METHODS, "GET, OPTIONS, POST")
             .header(CONTENT_TYPE, "application/json")
-            .header(
-                "Graph-Attestable",
-                self.results.iter().all(|r| r.is_attestable()).to_string(),
-            )
-            .body(T::from(json))
+            .header("graph-attestable", attestable.to_string())
+            .header("graph-indexed", indexed_block)
+            .body(Full::from(json))
             .unwrap()
     }
 }
 
 /// The result of running a query, if successful.
-#[derive(Debug, Default, Serialize)]
+#[derive(Debug, CacheWeight, Default, Serialize)]
 pub struct QueryResult {
     #[serde(
         skip_serializing_if = "Option::is_none",
@@ -222,7 +255,7 @@ pub struct QueryResult {
     #[serde(skip_serializing)]
     pub deployment: Option<DeploymentHash>,
     #[serde(skip_serializing)]
-    pub trace: Trace,
+    pub trace: Arc<Trace>,
 }
 
 impl QueryResult {
@@ -231,7 +264,7 @@ impl QueryResult {
             data: Some(data),
             errors: Vec::new(),
             deployment: None,
-            trace: Trace::None,
+            trace: TRACE_NONE.cheap_clone(),
         }
     }
 
@@ -243,7 +276,7 @@ impl QueryResult {
             data: self.data.clone(),
             errors: self.errors.clone(),
             deployment: self.deployment.clone(),
-            trace: Trace::None,
+            trace: TRACE_NONE.cheap_clone(),
         }
     }
 
@@ -299,7 +332,7 @@ impl From<QueryExecutionError> for QueryResult {
             data: None,
             errors: vec![e.into()],
             deployment: None,
-            trace: Trace::None,
+            trace: TRACE_NONE.cheap_clone(),
         }
     }
 }
@@ -310,7 +343,7 @@ impl From<QueryError> for QueryResult {
             data: None,
             errors: vec![e],
             deployment: None,
-            trace: Trace::None,
+            trace: TRACE_NONE.cheap_clone(),
         }
     }
 }
@@ -321,7 +354,7 @@ impl From<Vec<QueryExecutionError>> for QueryResult {
             data: None,
             errors: e.into_iter().map(QueryError::from).collect(),
             deployment: None,
-            trace: Trace::None,
+            trace: TRACE_NONE.cheap_clone(),
         }
     }
 }
@@ -335,7 +368,7 @@ impl From<Object> for QueryResult {
 impl From<(Object, Trace)> for QueryResult {
     fn from((val, trace): (Object, Trace)) -> Self {
         let mut res = QueryResult::new(val);
-        res.trace = trace;
+        res.trace = Arc::new(trace);
         res
     }
 }
@@ -360,12 +393,6 @@ impl<V: Into<QueryResult>, E: Into<QueryResult>> From<Result<V, E>> for QueryRes
     }
 }
 
-impl CacheWeight for QueryResult {
-    fn indirect_weight(&self) -> usize {
-        self.data.indirect_weight() + self.errors.indirect_weight()
-    }
-}
-
 // Check that when we serialize a `QueryResult` with multiple entries
 // in `data` it appears as if we serialized one big map
 #[test]
@@ -383,9 +410,9 @@ fn multiple_data_items() {
     let obj1 = make_obj("key1", "value1");
     let obj2 = make_obj("key2", "value2");
 
-    let mut res = QueryResults::empty();
-    res.append(obj1);
-    res.append(obj2);
+    let mut res = QueryResults::empty(Trace::None, None);
+    res.append(obj1, CacheStatus::default());
+    res.append(obj2, CacheStatus::default());
 
     let expected =
         serde_json::to_string(&json!({"data":{"key1": "value1", "key2": "value2"}})).unwrap();
diff --git a/graph/src/data/query/trace.rs b/graph/src/data/query/trace.rs
index c9779b568a9..369c36a5435 100644
--- a/graph/src/data/query/trace.rs
+++ b/graph/src/data/query/trace.rs
@@ -1,47 +1,88 @@
-use std::{
-    sync::{Arc, Mutex},
-    time::Duration,
+use std::{sync::Arc, time::Duration};
+
+use serde::{Serialize, ser::SerializeMap};
+
+use crate::{
+    components::store::{BlockNumber, QueryPermit},
+    derive::CacheWeight,
+    prelude::{CheapClone, lazy_static},
 };
 
-use serde::{ser::SerializeMap, Serialize};
+use super::{CacheStatus, QueryExecutionError};
+
+lazy_static! {
+    pub static ref TRACE_NONE: Arc<Trace> = Arc::new(Trace::None);
+}
+
+#[derive(Debug, CacheWeight)]
+pub struct TraceWithCacheStatus {
+    pub trace: Arc<Trace>,
+    pub cache_status: CacheStatus,
+}
+
+#[derive(Debug, Default)]
+pub struct HttpTrace {
+    to_json: Duration,
+    cache_weight: usize,
+}
 
-use crate::{components::store::BlockNumber, prelude::CheapClone};
+impl HttpTrace {
+    pub fn new(to_json: Duration, cache_weight: usize) -> Self {
+        HttpTrace {
+            to_json,
+            cache_weight,
+        }
+    }
+}
 
-#[derive(Debug)]
+#[derive(Debug, CacheWeight, Default)]
 pub enum Trace {
+    #[default]
     None,
     Root {
         query: Arc<String>,
         variables: Arc<String>,
         query_id: String,
+        /// How long setup took before we executed queries. This includes
+        /// the time to get the current state of the deployment and setting
+        /// up the `QueryStore`
+        setup: Duration,
+        /// The total time it took to execute the query; that includes setup
+        /// and the processing time for all SQL queries. It does not include
+        /// the time it takes to serialize the result
+        elapsed: Duration,
+        query_parsing: Duration,
+        /// A list of `Trace::Block`, one for each block constraint in the query
+        blocks: Vec<TraceWithCacheStatus>,
+    },
+    Block {
         block: BlockNumber,
-        elapsed: Mutex<Duration>,
-        conn_wait: Duration,
+        elapsed: Duration,
         permit_wait: Duration,
+        /// Pairs of response key and traces. Each trace is either a `Trace::Query` or a `Trace::None`
         children: Vec<(String, Trace)>,
     },
     Query {
+        /// The SQL query that was executed
         query: String,
+        /// How long executing the SQL query took. This is just the time it
+        /// took to send the already built query to the database and receive
+        /// results.
         elapsed: Duration,
+        /// How long we had to wait for a connection from the pool
         conn_wait: Duration,
         permit_wait: Duration,
         entity_count: usize,
+        /// Pairs of response key and traces. Each trace is either a `Trace::Query` or a `Trace::None`
         children: Vec<(String, Trace)>,
     },
 }
 
-impl Default for Trace {
-    fn default() -> Self {
-        Self::None
-    }
-}
-
 impl Trace {
     pub fn root(
         query: &Arc<String>,
         variables: &Arc<String>,
         query_id: &str,
-        block: BlockNumber,
         do_trace: bool,
     ) -> Trace {
         if do_trace {
@@ -49,9 +90,21 @@ impl Trace {
                 query: query.cheap_clone(),
                 variables: variables.cheap_clone(),
                 query_id: query_id.to_string(),
+                elapsed: Duration::ZERO,
+                setup: Duration::ZERO,
+                query_parsing: Duration::ZERO,
+                blocks: Vec::new(),
+            }
+        } else {
+            Trace::None
+        }
+    }
+
+    pub fn block(block: BlockNumber, do_trace: bool) -> Trace {
+        if do_trace {
+            Trace::Block {
                 block,
-                elapsed: Mutex::new(Duration::from_millis(0)),
-                conn_wait: Duration::from_millis(0),
+                elapsed: Duration::from_millis(0),
                 permit_wait: Duration::from_millis(0),
                 children: Vec::new(),
             }
@@ -60,16 +113,53 @@ impl Trace {
         }
     }
 
-    pub fn finish(&self, dur: Duration) {
+    pub fn query_done(&mut self, dur: Duration, permit: &QueryPermit) {
+        let permit_dur = permit.wait;
         match self {
-            Trace::None | Trace::Query { .. } => { /* nothing to do */ }
-            Trace::Root { elapsed, .. } => *elapsed.lock().unwrap() = dur,
+            Trace::None => { /* nothing to do */ }
+            Trace::Root { .. } => {
+                unreachable!("can not call query_done on Root")
+            }
+            Trace::Block {
+                elapsed,
+                permit_wait,
+                ..
+            }
+            | Trace::Query {
+                elapsed,
+                permit_wait,
+                ..
+            } => {
+                *elapsed = dur;
+                *permit_wait = permit_dur;
+            }
+        }
+    }
+
+    pub fn finish(&mut self, setup_dur: Duration, total: Duration) {
+        match self {
+            Trace::None => { /* nothing to do */ }
+            Trace::Query { .. } | Trace::Block { .. } => {
+                unreachable!("can not call finish on Query or Block")
+            }
+            Trace::Root { elapsed, setup, .. } => {
+                *setup = setup_dur;
+                *elapsed = total
+            }
         }
     }
 
     pub fn query(query: &str, elapsed: Duration, entity_count: usize) -> Trace {
+        // Strip out the comment `/* .. */` that adds various tags to the
+        // query that are irrelevant for us
+        let query = match query.find("*/") {
+            Some(pos) => &query[pos + 2..],
+            None => query,
+        };
+
+        let query = query.replace("\t", "").replace("\"", "");
         Trace::Query {
-            query: query.to_string(),
+            query,
             elapsed,
             conn_wait: Duration::from_millis(0),
             permit_wait: Duration::from_millis(0),
@@ -80,7 +170,7 @@ impl Trace {
 
     pub fn push(&mut self, name: &str, trace: Trace) {
         match (self, &trace) {
-            (Self::Root { children, .. }, Self::Query { .. }) => {
+            (Self::Block { children, .. }, Self::Query { .. }) => {
                 children.push((name.to_string(), trace))
             }
             (Self::Query { children, .. }, Self::Query { .. }) => {
@@ -97,25 +187,131 @@ impl Trace {
     pub fn is_none(&self) -> bool {
         match self {
             Trace::None => true,
-            Trace::Root { .. } | Trace::Query { .. } => false,
+            Trace::Root { .. } | Trace::Block { .. } | Trace::Query { .. } => false,
         }
     }
 
     pub fn conn_wait(&mut self, time: Duration) {
         match self {
             Trace::None => { /* nothing to do  */ }
-            Trace::Root { conn_wait, .. } | Trace::Query { conn_wait, .. } => *conn_wait += time,
+            Trace::Root { .. } | Trace::Block { .. } => {
+                unreachable!("can not add conn_wait to Root or Block")
+            }
+            Trace::Query { conn_wait, .. } => *conn_wait += time,
         }
     }
 
-    pub fn permit_wait(&mut self, time: Duration) {
+    pub fn permit_wait(&mut self, res: &Result<QueryPermit, QueryExecutionError>) {
+        let time = match res {
+            Ok(permit) => permit.wait,
+            Err(_) => {
+                return;
+            }
+        };
         match self {
             Trace::None => { /* nothing to do  */ }
-            Trace::Root { permit_wait, .. } | Trace::Query { permit_wait, .. } => {
+            Trace::Root { .. } => unreachable!("can not add permit_wait to Root"),
+            Trace::Block { permit_wait, .. } | Trace::Query { permit_wait, .. } => {
                 *permit_wait += time
             }
         }
     }
+
+    pub fn append(&mut self, trace: Arc<Trace>, cache_status: CacheStatus) {
+        match self {
+            Trace::None => { /* tracing turned off */ }
+            Trace::Root { blocks, .. } => blocks.push(TraceWithCacheStatus {
+                trace,
+                cache_status,
+            }),
+            s => {
+                unreachable!("can not append self: {:#?} trace: {:#?}", s, trace)
+            }
+        }
+    }
+
+    pub fn query_parsing(&mut self, time: Duration) {
+        match self {
+            Trace::None => { /* nothing to do  */ }
+            Trace::Root { query_parsing, .. } => *query_parsing += time,
+            Trace::Block { .. } | Trace::Query { .. } => {
+                unreachable!("can not add query_parsing to Block or Query")
+            }
+        }
+    }
+
+    /// Return the total time spent executing database queries
+    pub fn query_total(&self) -> QueryTotal {
+        QueryTotal::calculate(self)
+    }
+}
+
+#[derive(Default)]
+pub struct QueryTotal {
+    pub elapsed: Duration,
+    pub conn_wait: Duration,
+    pub permit_wait: Duration,
+    pub entity_count: usize,
+    pub query_count: usize,
+    pub cached_count: usize,
+}
+
+impl QueryTotal {
+    fn add(&mut self, trace: &Trace) {
+        use Trace::*;
+        match trace {
+            None => { /* nothing to do */ }
+            Root { blocks, .. } => {
+                blocks.iter().for_each(|twc| {
+                    if twc.cache_status.uses_database() {
+                        self.query_count += 1;
+                        self.add(&twc.trace)
+                    } else {
+                        self.cached_count += 1
+                    }
+                });
+            }
+            Block { children, .. } => {
+                children.iter().for_each(|(_, trace)| self.add(trace));
+            }
+            Query {
+                elapsed,
+                conn_wait,
+                permit_wait,
+                children,
+                entity_count,
+                ..
+            } => {
+                self.elapsed += *elapsed;
+                self.conn_wait += *conn_wait;
+                self.permit_wait += *permit_wait;
+                self.entity_count += entity_count;
+                children.iter().for_each(|(_, trace)| self.add(trace));
+            }
+        }
+    }
+
+    fn calculate(trace: &Trace) -> Self {
+        let mut qt = QueryTotal::default();
+        qt.add(trace);
+        qt
+    }
+}
+
+impl Serialize for QueryTotal {
+    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut map = ser.serialize_map(Some(4))?;
+        map.serialize_entry("elapsed_ms", &self.elapsed.as_millis())?;
+        map.serialize_entry("conn_wait_ms", &self.conn_wait.as_millis())?;
+        map.serialize_entry("permit_wait_ms", &self.permit_wait.as_millis())?;
+        map.serialize_entry("entity_count", &self.entity_count)?;
+        map.serialize_entry("query_count", &self.query_count)?;
+        map.serialize_entry("cached_count", &self.cached_count)?;
+        map.end()
+    }
 }
 
 impl Serialize for Trace {
@@ -129,24 +325,37 @@ impl Serialize for Trace {
                 query,
                 variables,
                 query_id,
-                block,
                 elapsed,
-                conn_wait,
-                permit_wait,
-                children,
+                setup,
+                query_parsing,
+                blocks,
             } => {
-                let mut map = ser.serialize_map(Some(children.len() + 2))?;
+                let qt = self.query_total();
+                let mut map = ser.serialize_map(Some(8))?;
                 map.serialize_entry("query", query)?;
                 if !variables.is_empty() && variables.as_str() != "{}" {
                     map.serialize_entry("variables", variables)?;
                 }
                 map.serialize_entry("query_id", query_id)?;
+                map.serialize_entry("elapsed_ms", &elapsed.as_millis())?;
+                map.serialize_entry("setup_ms", &setup.as_millis())?;
+                map.serialize_entry("query_parsing_ms", &query_parsing.as_millis())?;
+                map.serialize_entry("db", &qt)?;
+                map.serialize_entry("blocks", blocks)?;
+                map.end()
+            }
+            Trace::Block {
+                block,
+                elapsed,
+                permit_wait,
+                children,
+            } => {
+                let mut map = ser.serialize_map(Some(children.len() + 3))?;
                 map.serialize_entry("block", block)?;
-                map.serialize_entry("elapsed_ms", &elapsed.lock().unwrap().as_millis())?;
+                map.serialize_entry("elapsed_ms", &elapsed.as_millis())?;
                 for (child, trace) in children {
                     map.serialize_entry(child, trace)?;
                 }
-                map.serialize_entry("conn_wait_ms", &conn_wait.as_millis())?;
                 map.serialize_entry("permit_wait_ms", &permit_wait.as_millis())?;
                 map.end()
             }
@@ -172,3 +381,27 @@ impl Serialize for Trace {
         }
     }
 }
+
+impl Serialize for TraceWithCacheStatus {
+    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut map = ser.serialize_map(Some(2))?;
+        map.serialize_entry("trace", &self.trace)?;
+        map.serialize_entry("cache", &self.cache_status)?;
+        map.end()
+    }
+}
+
+impl Serialize for HttpTrace {
+    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut map = ser.serialize_map(Some(3))?;
+        map.serialize_entry("to_json", &format!("{:?}", self.to_json))?;
+        map.serialize_entry("cache_weight", &self.cache_weight)?;
+        map.end()
+    }
+}
diff --git a/graph/src/data/store/ethereum.rs b/graph/src/data/store/ethereum.rs
index 7bbf2f17542..29f4544c71c 100644
--- a/graph/src/data/store/ethereum.rs
+++ b/graph/src/data/store/ethereum.rs
@@ -1,6 +1,7 @@
 use super::scalar;
+use crate::derive::CheapClone;
 use crate::prelude::*;
-use web3::types::{Address, Bytes, H2048, H256, H64, U64};
+use alloy::primitives::{Address, B64, B256, Bytes, U64, aliases::B2048};
 
 impl From<Address> for Value {
     fn from(address: Address) -> Value {
@@ -8,27 +9,27 @@ impl From<Address> for Value {
     }
 }
 
-impl From<H64> for Value {
-    fn from(hash: H64) -> Value {
+impl From<B64> for Value {
+    fn from(hash: B64) -> Value {
         Value::Bytes(scalar::Bytes::from(hash.as_ref()))
     }
 }
 
-impl From<H256> for Value {
-    fn from(hash: H256) -> Value {
+impl From<B256> for Value {
+    fn from(hash: B256) -> Value {
         Value::Bytes(scalar::Bytes::from(hash.as_ref()))
     }
 }
 
-impl From<H2048> for Value {
-    fn from(hash: H2048) -> Value {
+impl From<B2048> for Value {
+    fn from(hash: B2048) -> Value {
         Value::Bytes(scalar::Bytes::from(hash.as_ref()))
     }
 }
 
 impl From<Bytes> for Value {
     fn from(bytes: Bytes) -> Value {
-        Value::Bytes(scalar::Bytes::from(bytes.0.as_slice()))
+        Value::Bytes(scalar::Bytes::from(bytes.as_ref()))
     }
 }
 
@@ -37,3 +38,120 @@ impl From<U64> for Value {
         Value::BigInt(BigInt::from(n))
     }
 }
+
+/// Helper structs for dealing with ethereum calls
+pub mod call {
+    use std::sync::Arc;
+
+    use alloy::primitives::Address;
+
+    use crate::data::store::scalar::Bytes;
+
+    use super::CheapClone;
+
+    /// The return value of an ethereum call. `Null` indicates that we made
+    /// the call but didn't get a value back (including when we get the
+    /// error 'call reverted')
+    #[derive(Debug, Clone, PartialEq)]
+    pub enum Retval {
+        Null,
+        Value(Bytes),
+    }
+
+    impl Retval {
+        pub fn unwrap(self) -> Bytes {
+            use Retval::*;
+            match self {
+                Value(val) => val,
+                Null => panic!("called `call::Retval::unwrap()` on a `Null` value"),
+            }
+        }
+    }
+
+    /// Indication of where the result of an ethereum call comes from. We
+    /// unfortunately need that so we can avoid double-counting declared calls
+    /// as they are accessed as normal eth calls and we'd count them twice
+    /// without this.
+    #[derive(Debug, Clone, Copy, PartialEq)]
+    pub enum Source {
+        Memory,
+        Store,
+        Rpc,
+    }
+
+    impl Source {
+        /// Return `true` if calls from this source should be observed,
+        /// i.e., counted as actual calls
+        pub fn observe(&self) -> bool {
+            matches!(self, Source::Rpc | Source::Store)
+        }
+    }
+
+    impl std::fmt::Display for Source {
+        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+            match self {
+                Source::Memory => write!(f, "memory"),
+                Source::Store => write!(f, "store"),
+                Source::Rpc => write!(f, "rpc"),
+            }
+        }
+    }
+
+    /// The address and encoded name and parms for an `eth_call`, the raw
+    /// ingredients to make an `eth_call` request. Because we cache this, it
+    /// gets cloned a lot and needs to remain cheap to clone.
+    ///
+    /// For equality and hashing, we only consider the address and the
+    /// encoded call as the index is set by the caller and has no influence
+    /// on the call's return value
+    #[derive(Debug, Clone, CheapClone)]
+    pub struct Request {
+        pub address: Address,
+        pub encoded_call: Arc<Bytes>,
+        /// The index is set by the caller and is used to identify the
+        /// request in related data structures that the caller might have
+        pub index: u32,
+    }
+
+    impl Request {
+        pub fn new(address: Address, encoded_call: Vec<u8>, index: u32) -> Self {
+            Request {
+                address,
+                encoded_call: Arc::new(Bytes::from(encoded_call)),
+                index,
+            }
+        }
+
+        /// Create a response struct for this request
+        pub fn response(self, retval: Retval, source: Source) -> Response {
+            Response {
+                req: self,
+                retval,
+                source,
+            }
+        }
+    }
+
+    impl PartialEq for Request {
+        fn eq(&self, other: &Self) -> bool {
+            self.address == other.address
+                && self.encoded_call.as_ref() == other.encoded_call.as_ref()
+        }
+    }
+
+    impl Eq for Request {}
+
+    impl std::hash::Hash for Request {
+        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+            self.address.hash(state);
+            self.encoded_call.as_ref().hash(state);
+        }
+    }
+
+    #[derive(Debug, PartialEq)]
+    pub struct Response {
+        pub req: Request,
+        pub retval: Retval,
+        pub source: Source,
+    }
+}
diff --git a/graph/src/data/store/id.rs b/graph/src/data/store/id.rs
index 14311466355..8391da53b76 100644
--- a/graph/src/data/store/id.rs
+++ b/graph/src/data/store/id.rs
@@ -1,6 +1,12 @@
 //! Types and helpers to deal with entity IDs which support a subset of the
 //! types that more general values support
-use anyhow::{anyhow, Context, Error};
+use anyhow::{Context, Error, anyhow};
+use diesel::{
+    QueryResult,
+    pg::Pg,
+    query_builder::AstPass,
+    sql_types::{BigInt, Binary, Text},
+};
 use stable_hash::{StableHash, StableHasher};
 use std::convert::TryFrom;
 use std::fmt;
@@ -14,14 +20,14 @@ use crate::{
 
 use crate::{
     components::store::StoreError,
-    constraint_violation,
     data::value::Word,
-    prelude::{CacheWeight, QueryExecutionError},
+    derive::CacheWeight,
+    internal_error,
+    prelude::QueryExecutionError,
     runtime::gas::{Gas, GasSizeOf},
-    schema::EntityType,
 };
 
-use super::{scalar, Value, ValueType, ID};
+use super::{ID, Value, ValueType, scalar};
 
 /// The types that can be used for the `id` of an entity
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
@@ -83,12 +89,12 @@ impl IdType {
     }
 }
 
-impl<'a> TryFrom<&s::ObjectType> for IdType {
+impl TryFrom<&s::ObjectType> for IdType {
     type Error = Error;
 
     fn try_from(obj_type: &s::ObjectType) -> Result<Self, Self::Error> {
         let base_type = obj_type
-            .field(&*ID)
+            .field(&ID)
             .ok_or_else(|| anyhow!("Type {} does not have an `id` field", obj_type.name))?
             .field_type
             .get_base_type();
@@ -132,7 +138,7 @@ impl std::fmt::Display for IdType {
 }
 
 /// Values for the ids of entities
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, CacheWeight, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Id {
     String(Word),
     Bytes(scalar::Bytes),
@@ -213,16 +219,6 @@ impl std::fmt::Display for Id {
     }
 }
 
-impl CacheWeight for Id {
-    fn indirect_weight(&self) -> usize {
-        match self {
-            Id::String(s) => s.indirect_weight(),
-            Id::Bytes(b) => b.indirect_weight(),
-            Id::Int8(_) => 0,
-        }
-    }
-}
-
 impl GasSizeOf for Id {
     fn gas_size_of(&self) -> Gas {
         match self {
@@ -300,6 +296,24 @@ impl<'a> IdRef<'a> {
             IdRef::Int8(_) => IdType::Int8,
         }
     }
+
+    pub fn push_bind_param<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        match self {
+            IdRef::String(s) => out.push_bind_param::<Text, _>(*s),
+            IdRef::Bytes(b) => out.push_bind_param::<Binary, _>(*b),
+            IdRef::Int8(i) => out.push_bind_param::<BigInt, _>(i),
+        }
+    }
+}
+
+impl<'a> From<&'a Id> for IdRef<'a> {
+    fn from(id: &'a Id) -> Self {
+        match id {
+            Id::String(s) => IdRef::String(s.as_str()),
+            Id::Bytes(b) => IdRef::Bytes(b.as_slice()),
+            Id::Int8(i) => IdRef::Int8(*i),
+        }
+    }
 }
 
 /// A homogeneous list of entity ids, i.e., all ids in the list are of the
@@ -343,10 +357,9 @@ impl IdList {
     /// Turn a list of ids into an `IdList` and check that they are all the
     /// same type
     pub fn try_from_iter<I: Iterator<Item = Id>>(
-        entity_type: &EntityType,
+        id_type: IdType,
         mut iter: I,
     ) -> Result<Self, QueryExecutionError> {
-        let id_type = entity_type.id_type()?;
         match id_type {
             IdType::String => {
                 let ids: Vec<Word> = iter.try_fold(vec![], |mut ids, id| match id {
@@ -354,7 +367,7 @@ impl IdList {
                         ids.push(id);
                         Ok(ids)
                     }
-                    _ => Err(constraint_violation!(
+                    _ => Err(internal_error!(
                         "expected string id, got {}: {}",
                         id.id_type(),
                         id,
@@ -368,7 +381,7 @@ impl IdList {
                         ids.push(id);
                         Ok(ids)
                     }
-                    _ => Err(constraint_violation!(
+                    _ => Err(internal_error!(
                         "expected bytes id, got {}: {}",
                         id.id_type(),
                         id,
@@ -382,7 +395,7 @@ impl IdList {
                         ids.push(id);
                         Ok(ids)
                     }
-                    _ => Err(constraint_violation!(
+                    _ => Err(internal_error!(
                         "expected int8 id, got {}: {}",
                         id.id_type(),
                         id,
@@ -410,7 +423,7 @@ impl IdList {
                         ids.push(Word::from(id));
                         Ok(ids)
                     }
-                    _ => Err(constraint_violation!(
+                    _ => Err(internal_error!(
                         "expected string id, got {}: 0x{}",
                         id.id_type(),
                         id,
@@ -425,7 +438,7 @@ impl IdList {
                             ids.push(scalar::Bytes::from(id));
                             Ok(ids)
                         }
-                        _ => Err(constraint_violation!(
+                        _ => Err(internal_error!(
                             "expected bytes id, got {}: {}",
                             id.id_type(),
                             id,
@@ -439,7 +452,7 @@ impl IdList {
                         ids.push(id);
                         Ok(ids)
                     }
-                    _ => Err(constraint_violation!(
+                    _ => Err(internal_error!(
                         "expected int8 id, got {}: {}",
                         id.id_type(),
                         id,
@@ -450,7 +463,7 @@ impl IdList {
         }
     }
 
-    pub fn index(&self, index: usize) -> IdRef<'_> {
+    pub fn index<'b>(&'b self, index: usize) -> IdRef<'b> {
         match self {
             IdList::String(ids) => IdRef::String(&ids[index]),
             IdList::Bytes(ids) => IdRef::Bytes(ids[index].as_slice()),
@@ -458,8 +471,20 @@ impl IdList {
         }
     }
 
+    pub fn bind_entry<'b>(
+        &'b self,
+        index: usize,
+        out: &mut AstPass<'_, 'b, Pg>,
+    ) -> QueryResult<()> {
+        match self {
+            IdList::String(ids) => out.push_bind_param::<Text, _>(&ids[index]),
+            IdList::Bytes(ids) => out.push_bind_param::<Binary, _>(ids[index].as_slice()),
+            IdList::Int8(ids) => out.push_bind_param::<BigInt, _>(&ids[index]),
+        }
+    }
+
     pub fn first(&self) -> Option<IdRef<'_>> {
-        if self.len() > 0 {
+        if !self.is_empty() {
             Some(self.index(0))
         } else {
             None
@@ -508,7 +533,7 @@ impl IdList {
                 ids.push(id);
                 Ok(())
             }
-            (list, id) => Err(constraint_violation!(
+            (list, id) => Err(internal_error!(
                 "expected id of type {}, but got {}[{}]",
                 list.id_type(),
                 id.id_type(),
@@ -541,7 +566,7 @@ mod tests {
         assert_eq!(exp, id);
 
         let id = IdType::Int8.generate_id(3, 2).unwrap();
-        let exp = Id::Int8(0x0000_0003__0000_0002);
+        let exp = Id::Int8(0x0000_0003_0000_0002);
         assert_eq!(exp, id);
 
         // Should be id + 1
diff --git a/graph/src/data/store/mod.rs b/graph/src/data/store/mod.rs
index 607426478f9..d0b3ff7edd1 100644
--- a/graph/src/data/store/mod.rs
+++ b/graph/src/data/store/mod.rs
@@ -1,13 +1,11 @@
 use crate::{
-    components::store::DeploymentLocator,
-    prelude::{lazy_static, q, r, s, CacheWeight, QueryExecutionError},
+    derive::CacheWeight,
+    prelude::{CacheWeight, QueryExecutionError, lazy_static, q, r, s},
     runtime::gas::{Gas, GasSizeOf},
-    schema::{EntityKey, EntityType},
-    util::intern::{self, AtomPool},
-    util::intern::{Error as InternError, NullValue, Object},
+    schema::{EntityKey, input::VID_FIELD},
+    util::intern::{self, AtomPool, Error as InternError, NullValue, Object},
 };
-use crate::{data::subgraph::DeploymentHash, prelude::EntityChange};
-use anyhow::{anyhow, Error};
+use anyhow::{Error, anyhow};
 use itertools::Itertools;
 use serde::de;
 use serde::{Deserialize, Serialize};
@@ -35,43 +33,24 @@ pub mod ethereum;
 /// Conversion of values to/from SQL
 pub mod sql;
 
-/// Filter subscriptions
-#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum SubscriptionFilter {
-    /// Receive updates about all entities from the given deployment of the
-    /// given type
-    Entities(DeploymentHash, EntityType),
-    /// Subscripe to changes in deployment assignments
-    Assignment,
-}
-
-impl SubscriptionFilter {
-    pub fn matches(&self, change: &EntityChange) -> bool {
-        match (self, change) {
-            (
-                Self::Entities(eid, etype),
-                EntityChange::Data {
-                    subgraph_id,
-                    entity_type,
-                    ..
-                },
-            ) => subgraph_id == eid && entity_type == etype.as_str(),
-            (Self::Assignment, EntityChange::Assignment { .. }) => true,
-            _ => false,
-        }
-    }
+lazy_static! {
+    /// The name of the default node is `"default"`. This is used when no
+    /// node is specified for a deployment.
+    pub static ref DEFAULT_NODE_ID: NodeId = NodeId::new("default").unwrap();
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct NodeId(String);
 
 impl NodeId {
-    pub fn new(s: impl Into<String>) -> Result<Self, ()> {
+    /// Create a new NodeId. The name `s` must be between 1 and 63
+    /// characters long. If it is not, `Err(s)` is returned
+    pub fn new(s: impl Into<String>) -> Result<Self, String> {
         let s = s.into();
 
         // Enforce minimum and maximum length limit
         if s.len() > 63 || s.is_empty() {
-            return Err(());
+            return Err(s);
         }
 
         Ok(NodeId(s))
@@ -105,30 +84,8 @@ impl<'de> de::Deserialize<'de> for NodeId {
         D: de::Deserializer<'de>,
     {
         let s: String = de::Deserialize::deserialize(deserializer)?;
-        NodeId::new(s.clone())
-            .map_err(|()| de::Error::invalid_value(de::Unexpected::Str(&s), &"valid node ID"))
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
-#[serde(tag = "type")]
-pub enum AssignmentEvent {
-    Add {
-        deployment: DeploymentLocator,
-        node_id: NodeId,
-    },
-    Remove {
-        deployment: DeploymentLocator,
-        node_id: NodeId,
-    },
-}
-
-impl AssignmentEvent {
-    pub fn node_id(&self) -> &NodeId {
-        match self {
-            AssignmentEvent::Add { node_id, .. } => node_id,
-            AssignmentEvent::Remove { node_id, .. } => node_id,
-        }
+        NodeId::new(s)
+            .map_err(|s| de::Error::invalid_value(de::Unexpected::Str(&s), &"valid node ID"))
     }
 }
 
@@ -139,6 +96,7 @@ pub const BYTES_SCALAR: &str = "Bytes";
 pub const BIG_INT_SCALAR: &str = "BigInt";
 pub const BIG_DECIMAL_SCALAR: &str = "BigDecimal";
 pub const INT8_SCALAR: &str = "Int8";
+pub const TIMESTAMP_SCALAR: &str = "Timestamp";
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum ValueType {
@@ -149,6 +107,7 @@ pub enum ValueType {
     Int,
     Int8,
     String,
+    Timestamp,
 }
 
 impl FromStr for ValueType {
@@ -162,6 +121,7 @@ impl FromStr for ValueType {
             "BigDecimal" => Ok(ValueType::BigDecimal),
             "Int" => Ok(ValueType::Int),
             "Int8" => Ok(ValueType::Int8),
+            "Timestamp" => Ok(ValueType::Timestamp),
             "String" | "ID" => Ok(ValueType::String),
             s => Err(anyhow!("Type not available in this context: {}", s)),
         }
@@ -177,7 +137,9 @@ impl ValueType {
     pub fn is_numeric(&self) -> bool {
         match self {
             ValueType::BigInt | ValueType::BigDecimal | ValueType::Int | ValueType::Int8 => true,
-            ValueType::Boolean | ValueType::Bytes | ValueType::String => false,
+            ValueType::Boolean | ValueType::Bytes | ValueType::String | ValueType::Timestamp => {
+                false
+            }
         }
     }
 
@@ -189,6 +151,7 @@ impl ValueType {
             ValueType::BigDecimal => "BigDecimal",
             ValueType::Int => "Int",
             ValueType::Int8 => "Int8",
+            ValueType::Timestamp => "Timestamp",
             ValueType::String => "String",
         }
     }
@@ -221,9 +184,14 @@ impl PartialOrd for ValueType {
             | (BigDecimal, Int)
             | (BigDecimal, Int8)
             | (Int8, Int) => Some(Greater),
-            (Boolean, _) | (_, Boolean) | (Bytes, _) | (_, Bytes) | (String, _) | (_, String) => {
-                None
-            }
+            (Timestamp, _)
+            | (_, Timestamp)
+            | (Boolean, _)
+            | (_, Boolean)
+            | (Bytes, _)
+            | (_, Bytes)
+            | (String, _)
+            | (_, String) => None,
         }
     }
 }
@@ -243,6 +211,7 @@ pub enum Value {
     String(String),
     Int(i32),
     Int8(i64),
+    Timestamp(scalar::Timestamp),
     BigDecimal(scalar::BigDecimal),
     Bool(bool),
     List(Vec<Value>),
@@ -259,8 +228,8 @@ impl stable_hash_legacy::StableHash for Value {
         mut sequence_number: H::Seq,
         state: &mut H,
     ) {
-        use stable_hash_legacy::prelude::*;
         use Value::*;
+        use stable_hash_legacy::prelude::*;
 
         // This is the default, so write nothing.
         if self == &Null {
@@ -298,6 +267,9 @@ impl stable_hash_legacy::StableHash for Value {
             BigInt(inner) => {
                 stable_hash_legacy::StableHash::stable_hash(inner, sequence_number, state)
             }
+            Timestamp(inner) => {
+                stable_hash_legacy::StableHash::stable_hash(inner, sequence_number, state)
+            }
         }
     }
 }
@@ -345,6 +317,10 @@ impl StableHash for Value {
                 inner.stable_hash(field_address.child(0), state);
                 8
             }
+            Timestamp(inner) => {
+                inner.stable_hash(field_address.child(0), state);
+                9
+            }
         };
 
         state.write(field_address, &[variant])
@@ -359,7 +335,7 @@ impl NullValue for Value {
 
 impl Value {
     pub fn from_query_value(value: &r::Value, ty: &s::Type) -> Result<Value, QueryExecutionError> {
-        use graphql_parser::schema::Type::{ListType, NamedType, NonNullType};
+        use graphql_tools::parser::schema::Type::{ListType, NamedType, NonNullType};
 
         Ok(match (value, ty) {
             // When dealing with non-null types, use the inner type to convert the value
@@ -389,17 +365,26 @@ impl Value {
                     })?),
                     BIG_DECIMAL_SCALAR => Value::BigDecimal(scalar::BigDecimal::from_str(s)?),
                     INT8_SCALAR => Value::Int8(s.parse::<i64>().map_err(|_| {
-                        QueryExecutionError::ValueParseError("Int8".to_string(), format!("{}", s))
+                        QueryExecutionError::ValueParseError("Int8".to_string(), s.to_string())
                     })?),
+                    TIMESTAMP_SCALAR => {
+                        Value::Timestamp(scalar::Timestamp::parse_timestamp(s).map_err(|_| {
+                            QueryExecutionError::ValueParseError(
+                                "Timestamp".to_string(),
+                                s.to_string(),
+                            )
+                        })?)
+                    }
                     _ => Value::String(s.clone()),
                 }
             }
             (r::Value::Int(i), _) => Value::Int(*i as i32),
             (r::Value::Boolean(b), _) => Value::Bool(b.to_owned()),
+            (r::Value::Timestamp(ts), _) => Value::Timestamp(*ts),
             (r::Value::Null, _) => Value::Null,
             _ => {
                 return Err(QueryExecutionError::AttributeTypeError(
-                    value.to_string(),
+                    format!("{:?}", value),
                     ty.to_string(),
                 ));
             }
@@ -491,6 +476,7 @@ impl Value {
             Value::Bytes(_) => "Bytes".to_owned(),
             Value::Int(_) => "Int".to_owned(),
             Value::Int8(_) => "Int8".to_owned(),
+            Value::Timestamp(_) => "Timestamp".to_owned(),
             Value::List(values) => {
                 if let Some(v) = values.first() {
                     format!("[{}]", v.type_name())
@@ -512,6 +498,7 @@ impl Value {
             | (Value::Bytes(_), ValueType::Bytes)
             | (Value::Int(_), ValueType::Int)
             | (Value::Int8(_), ValueType::Int8)
+            | (Value::Timestamp(_), ValueType::Timestamp)
             | (Value::Null, _) => true,
             (Value::List(values), _) if is_list => values
                 .iter()
@@ -534,13 +521,14 @@ impl fmt::Display for Value {
                 Value::String(s) => s.to_string(),
                 Value::Int(i) => i.to_string(),
                 Value::Int8(i) => i.to_string(),
+                Value::Timestamp(i) => i.to_string(),
                 Value::BigDecimal(d) => d.to_string(),
                 Value::Bool(b) => b.to_string(),
                 Value::Null => "null".to_string(),
-                Value::List(ref values) =>
+                Value::List(values) =>
                     format!("[{}]", values.iter().map(ToString::to_string).join(", ")),
-                Value::Bytes(ref bytes) => bytes.to_string(),
-                Value::BigInt(ref number) => number.to_string(),
+                Value::Bytes(bytes) => bytes.to_string(),
+                Value::BigInt(number) => number.to_string(),
             }
         )
     }
@@ -552,6 +540,7 @@ impl fmt::Debug for Value {
             Self::String(s) => f.debug_tuple("String").field(s).finish(),
             Self::Int(i) => f.debug_tuple("Int").field(i).finish(),
             Self::Int8(i) => f.debug_tuple("Int8").field(i).finish(),
+            Self::Timestamp(i) => f.debug_tuple("Timestamp").field(i).finish(),
             Self::BigDecimal(d) => d.fmt(f),
             Self::Bool(arg0) => f.debug_tuple("Bool").field(arg0).finish(),
             Self::List(arg0) => f.debug_tuple("List").field(arg0).finish(),
@@ -568,6 +557,7 @@ impl From<Value> for q::Value {
             Value::String(s) => q::Value::String(s),
             Value::Int(i) => q::Value::Int(q::Number::from(i)),
             Value::Int8(i) => q::Value::String(i.to_string()),
+            Value::Timestamp(ts) => q::Value::String(ts.as_microseconds_since_epoch().to_string()),
             Value::BigDecimal(d) => q::Value::String(d.to_string()),
             Value::Bool(b) => q::Value::Boolean(b),
             Value::Null => q::Value::Null,
@@ -586,6 +576,7 @@ impl From<Value> for r::Value {
             Value::String(s) => r::Value::String(s),
             Value::Int(i) => r::Value::Int(i as i64),
             Value::Int8(i) => r::Value::String(i.to_string()),
+            Value::Timestamp(i) => r::Value::Timestamp(i),
             Value::BigDecimal(d) => r::Value::String(d.to_string()),
             Value::Bool(b) => r::Value::Boolean(b),
             Value::Null => r::Value::Null,
@@ -622,6 +613,12 @@ impl From<scalar::Bytes> for Value {
     }
 }
 
+impl From<scalar::Timestamp> for Value {
+    fn from(value: scalar::Timestamp) -> Value {
+        Value::Timestamp(value)
+    }
+}
+
 impl From<bool> for Value {
     fn from(value: bool) -> Value {
         Value::Bool(value)
@@ -654,7 +651,7 @@ impl From<u64> for Value {
 
 impl From<i64> for Value {
     fn from(value: i64) -> Value {
-        Value::Int8(value.into())
+        Value::Int8(value)
     }
 }
 
@@ -694,19 +691,22 @@ where
 lazy_static! {
     /// The name of the id attribute, `"id"`
     pub static ref ID: Word = Word::from("id");
+    /// The name of the vid attribute, `"vid"`
+    pub static ref VID: Word = Word::from("vid");
 }
 
 /// An entity is represented as a map of attribute names to values.
-#[derive(Clone, PartialEq, Eq, Serialize)]
+#[derive(Clone, CacheWeight, Eq, Serialize)]
 pub struct Entity(Object<Value>);
 
 impl<'a> IntoIterator for &'a Entity {
-    type Item = (Word, Value);
+    type Item = (&'a str, &'a Value);
 
-    type IntoIter = intern::ObjectOwningIter<Value>;
+    type IntoIter =
+        std::iter::Filter<intern::ObjectIter<'a, Value>, fn(&(&'a str, &'a Value)) -> bool>;
 
     fn into_iter(self) -> Self::IntoIter {
-        self.0.clone().into_iter()
+        (&self.0).into_iter().filter(|(k, _)| *k != VID_FIELD)
     }
 }
 
@@ -719,11 +719,123 @@ pub trait TryIntoEntityIterator<E>: IntoIterator<Item = Result<(Word, Value), E>
 impl<E, T: IntoIterator<Item = Result<(Word, Value), E>>> TryIntoEntityIterator<E> for T {}
 
 #[derive(Debug, Error, PartialEq, Eq, Clone)]
-pub enum EntityValidationError {
+pub struct EntityValidationError(Box<EntityValidationErrorInner>);
+
+impl fmt::Display for EntityValidationError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl EntityValidationError {
+    pub fn unknown_entity_type(key: &EntityKey) -> Self {
+        let entity = key.entity_type.to_string();
+        let id = key.entity_id.to_string();
+
+        EntityValidationError(Box::new(EntityValidationErrorInner::UnknownEntityType {
+            entity,
+            id,
+        }))
+    }
+
+    pub fn mismatched_element_type_in_list(
+        key: &EntityKey,
+        field: &crate::schema::Field,
+        value: &Value,
+        elt: &Value,
+        index: usize,
+    ) -> Self {
+        let entity = key.entity_type.to_string();
+        let entity_id = key.entity_id.to_string();
+        let expected_type = field.field_type.to_string();
+        let field = field.name.to_string();
+        let value = value.to_string();
+        let actual_type = elt.type_name();
+        EntityValidationError(Box::new(
+            EntityValidationErrorInner::MismatchedElementTypeInList {
+                entity,
+                entity_id,
+                field,
+                expected_type,
+                value,
+                actual_type,
+                index,
+            },
+        ))
+    }
+
+    pub fn invalid_field_type(
+        key: &EntityKey,
+        field: &crate::schema::Field,
+        value: &Value,
+    ) -> Self {
+        let entity = key.entity_type.to_string();
+        let entity_id = key.entity_id.to_string();
+        let expected_type = field.field_type.to_string();
+        let field = field.name.to_string();
+        let actual_type = value.type_name();
+        let value = value.to_string();
+
+        EntityValidationError(Box::new(EntityValidationErrorInner::InvalidFieldType {
+            entity,
+            entity_id,
+            value,
+            field,
+            expected_type,
+            actual_type,
+        }))
+    }
+
+    fn missing_value_for_non_nullable_field(key: &EntityKey, field: &crate::schema::Field) -> Self {
+        let entity = key.entity_type.to_string();
+        let entity_id = key.entity_id.to_string();
+        let field = field.name.to_string();
+        EntityValidationError(Box::new(
+            EntityValidationErrorInner::MissingValueForNonNullableField {
+                entity,
+                entity_id,
+                field,
+            },
+        ))
+    }
+
+    fn cannot_set_derived_field(key: &EntityKey, field: &crate::schema::Field) -> Self {
+        EntityValidationError(Box::new(
+            EntityValidationErrorInner::CannotSetDerivedField {
+                entity: key.entity_type.to_string(),
+                entity_id: key.entity_id.to_string(),
+                field: field.name.to_string(),
+            },
+        ))
+    }
+
+    fn unknown_key(not_interned: String) -> Self {
+        EntityValidationError(Box::new(EntityValidationErrorInner::UnknownKey(
+            not_interned,
+        )))
+    }
+
+    fn missing_id_attribute(entity: String) -> EntityValidationError {
+        EntityValidationError(Box::new(EntityValidationErrorInner::MissingIDAttribute {
+            entity,
+        }))
+    }
+
+    fn unsupported_type_for_id_attribute() -> EntityValidationError {
+        EntityValidationError(Box::new(
+            EntityValidationErrorInner::UnsupportedTypeForIDAttribute,
+        ))
+    }
+}
+
+#[derive(Debug, Error, PartialEq, Eq, Clone)]
+pub enum EntityValidationErrorInner {
     #[error("Entity {entity}[{id}]: unknown entity type `{entity}`")]
     UnknownEntityType { entity: String, id: String },
 
-    #[error("Entity {entity}[{entity_id}]: field `{field}` is of type {expected_type}, but the value `{value}` contains a {actual_type} at index {index}")]
+    #[error(
+        "Entity {entity}[{entity_id}]: field `{field}` is of type {expected_type}, but the value `{value}` contains a {actual_type} at index {index}"
+    )]
     MismatchedElementTypeInList {
         entity: String,
         entity_id: String,
@@ -734,7 +846,9 @@ pub enum EntityValidationError {
         index: usize,
     },
 
-    #[error("Entity {entity}[{entity_id}]: the value `{value}` for field `{field}` must have type {expected_type} but has type {actual_type}")]
+    #[error(
+        "Entity {entity}[{entity_id}]: the value `{value}` for field `{field}` must have type {expected_type} but has type {actual_type}"
+    )]
     InvalidFieldType {
         entity: String,
         entity_id: String,
@@ -788,10 +902,9 @@ pub enum EntityValidationError {
 macro_rules! entity {
     ($schema:expr => $($name:ident: $value:expr,)*) => {
         {
-            let mut result = Vec::new();
-            $(
-                result.push(($crate::data::value::Word::from(stringify!($name)), $crate::data::store::Value::from($value)));
-            )*
+            let result = vec![$(
+                ($crate::data::value::Word::from(stringify!($name)), $crate::data::store::Value::from($value)),
+            )*];
             $schema.make_entity(result).unwrap()
         }
     };
@@ -808,7 +921,7 @@ impl Entity {
         let mut obj = Object::new(pool);
         for (key, value) in iter {
             obj.insert(key, value)
-                .map_err(|e| EntityValidationError::UnknownKey(e.not_interned()))?;
+                .map_err(|e| EntityValidationError::unknown_key(e.not_interned()))?;
         }
         let entity = Entity(obj);
         entity.check_id()?;
@@ -831,33 +944,46 @@ impl Entity {
     }
 
     pub fn get(&self, key: &str) -> Option<&Value> {
+        // VID field is private and not visible outside
+        if key == VID_FIELD {
+            return None;
+        }
         self.0.get(key)
     }
 
     pub fn contains_key(&self, key: &str) -> bool {
+        // VID field is private and not visible outside
+        if key == VID_FIELD {
+            return false;
+        }
         self.0.contains_key(key)
     }
 
     // This collects the entity into an ordered vector so that it can be iterated deterministically.
     pub fn sorted(self) -> Vec<(Word, Value)> {
-        let mut v: Vec<_> = self.0.into_iter().map(|(k, v)| (k, v)).collect();
+        let mut v: Vec<_> = self
+            .0
+            .into_iter()
+            .filter(|(k, _)| !k.eq(VID_FIELD))
+            .collect();
         v.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
         v
     }
 
     pub fn sorted_ref(&self) -> Vec<(&str, &Value)> {
-        let mut v: Vec<_> = self.0.iter().collect();
-        v.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
+        let mut v: Vec<_> = self.0.iter().filter(|(k, _)| !k.eq(&VID_FIELD)).collect();
+        v.sort_by_key(|(k1, _)| *k1);
         v
     }
 
     fn check_id(&self) -> Result<(), EntityValidationError> {
         match self.get("id") {
-            None => Err(EntityValidationError::MissingIDAttribute {
-                entity: format!("{:?}", self.0),
-            }),
+            None => Err(EntityValidationError::missing_id_attribute(format!(
+                "{:?}",
+                self.0
+            ))),
             Some(Value::String(_)) | Some(Value::Bytes(_)) | Some(Value::Int8(_)) => Ok(()),
-            _ => Err(EntityValidationError::UnsupportedTypeForIDAttribute),
+            _ => Err(EntityValidationError::unsupported_type_for_id_attribute()),
         }
     }
 
@@ -869,6 +995,21 @@ impl Entity {
         Id::try_from(self.get("id").unwrap().clone()).expect("the id is set to a valid value")
     }
 
+    /// Return the VID of this entity and if its missing or of a type different than
+    /// i64 it panics.
+    pub fn vid(&self) -> i64 {
+        self.0
+            .get(VID_FIELD)
+            .expect("the vid must be set")
+            .as_int8()
+            .expect("the vid must be set to a valid value")
+    }
+
+    /// Sets the VID of the entity. The previous one is returned.
+    pub fn set_vid(&mut self, value: i64) -> Result<Option<Value>, InternError> {
+        self.0.insert(VID_FIELD, value.into())
+    }
+
     /// Merges an entity update `update` into this entity.
     ///
     /// If a key exists in both entities, the value from `update` is chosen.
@@ -883,14 +1024,29 @@ impl Entity {
     /// If a key exists in both entities, the value from `update` is chosen.
     /// If a key only exists on one entity, the value from that entity is chosen.
     /// If a key is set to `Value::Null` in `update`, the key/value pair is removed.
-    pub fn merge_remove_null_fields(&mut self, update: Entity) -> Result<(), InternError> {
+    pub fn merge_remove_null_fields(&mut self, update: Entity) -> Result<bool, InternError> {
+        let mut changed = false;
         for (key, value) in update.0.into_iter() {
+            // A change in VID, which changes on every save, does not count
+            // as a change to the entity's data; this avoids spurious
+            // `Overwrite` modifications.
+            let is_vid = key.as_str() == VID_FIELD;
             match value {
-                Value::Null => self.0.remove(&key),
-                _ => self.0.insert(&key, value)?,
-            };
+                Value::Null => {
+                    if self.0.remove(&key).is_some() && !is_vid {
+                        changed = true;
+                    }
+                }
+                _ => {
+                    let different = self.0.get(key.as_str()).is_none_or(|old| *old != value);
+                    self.0.insert(&key, value)?;
+                    if different && !is_vid {
+                        changed = true;
+                    }
+                }
+            }
         }
-        Ok(())
+        Ok(changed)
     }
 
     /// Remove all entries with value `Value::Null` from `self`
@@ -923,15 +1079,13 @@ impl Entity {
             return Ok(());
         }
 
-        let object_type = key.entity_type.object_type().map_err(|_| {
-            EntityValidationError::UnknownEntityType {
-                entity: key.entity_type.to_string(),
-                id: key.entity_id.to_string(),
-            }
-        })?;
+        let object_type = key
+            .entity_type
+            .object_type()
+            .map_err(|_| EntityValidationError::unknown_entity_type(key))?;
 
         for field in object_type.fields.iter() {
-            match (self.get(&field.name), field.is_derived) {
+            match (self.get(&field.name), field.is_derived()) {
                 (Some(value), false) => {
                     let scalar_type = &field.value_type;
                     if field.field_type.is_list() {
@@ -940,48 +1094,29 @@ impl Entity {
                         // assigning a scalar to a list will be caught below
                         if let Value::List(elts) = value {
                             for (index, elt) in elts.iter().enumerate() {
-                                if !elt.is_assignable(&scalar_type, false) {
+                                if !elt.is_assignable(scalar_type, false) {
                                     return Err(
-                                        EntityValidationError::MismatchedElementTypeInList {
-                                            entity: key.entity_type.to_string(),
-                                            entity_id: key.entity_id.to_string(),
-                                            field: field.name.to_string(),
-                                            expected_type: field.field_type.to_string(),
-                                            value: value.to_string(),
-                                            actual_type: elt.type_name().to_string(),
-                                            index,
-                                        },
+                                        EntityValidationError::mismatched_element_type_in_list(
+                                            key, field, value, elt, index,
+                                        ),
                                     );
                                 }
                             }
                         }
                     }
-                    if !value.is_assignable(&scalar_type, field.field_type.is_list()) {
-                        return Err(EntityValidationError::InvalidFieldType {
-                            entity: key.entity_type.to_string(),
-                            entity_id: key.entity_id.to_string(),
-                            value: value.to_string(),
-                            field: field.name.to_string(),
-                            expected_type: field.field_type.to_string(),
-                            actual_type: value.type_name().to_string(),
-                        });
+                    if !value.is_assignable(scalar_type, field.field_type.is_list()) {
+                        return Err(EntityValidationError::invalid_field_type(key, field, value));
                     }
                 }
                 (None, false) => {
                     if field.field_type.is_non_null() {
-                        return Err(EntityValidationError::MissingValueForNonNullableField {
-                            entity: key.entity_type.to_string(),
-                            entity_id: key.entity_id.to_string(),
-                            field: field.name.to_string(),
-                        });
+                        return Err(EntityValidationError::missing_value_for_non_nullable_field(
+                            key, field,
+                        ));
                     }
                 }
                 (Some(_), true) => {
-                    return Err(EntityValidationError::CannotSetDerivedField {
-                        entity: key.entity_type.to_string(),
-                        entity_id: key.entity_id.to_string(),
-                        field: field.name.to_string(),
-                    });
+                    return Err(EntityValidationError::cannot_set_derived_field(key, field));
                 }
                 (None, true) => {
                     // derived fields should not be set
@@ -992,6 +1127,13 @@ impl Entity {
     }
 }
 
+/// Checks equality of two entities while ignoring the VID fields
+impl PartialEq for Entity {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.eq_ignore_key(&other.0, VID_FIELD)
+    }
+}
+
 /// Convenience methods to modify individual attributes for tests.
 /// Production code should not use/need this.
 #[cfg(debug_assertions)]
@@ -1011,6 +1153,14 @@ impl Entity {
     ) -> Result<Option<Value>, InternError> {
         self.0.insert(name, value.into())
     }
+
+    /// Sets the VID if it's not already set. Should be used only for tests.
+    pub fn set_vid_if_empty(&mut self) {
+        let vid = self.0.get(VID_FIELD);
+        if vid.is_none() {
+            let _ = self.set_vid(100).expect("the vid should be set");
+        }
+    }
 }
 
 impl<'a> From<&'a Entity> for Cow<'a, Entity> {
@@ -1019,12 +1169,6 @@ impl<'a> From<&'a Entity> for Cow<'a, Entity> {
     }
 }
 
-impl CacheWeight for Entity {
-    fn indirect_weight(&self) -> usize {
-        self.0.indirect_weight()
-    }
-}
-
 impl GasSizeOf for Entity {
     fn gas_size_of(&self) -> Gas {
         self.0.gas_size_of()
@@ -1050,6 +1194,10 @@ pub struct QueryObject {
     pub entity: r::Object,
 }
 
+/// An object that is returned from a SQL query. It wraps an `r::Value`
+#[derive(CacheWeight, Serialize)]
+pub struct SqlQueryObject(pub r::Value);
+
 impl CacheWeight for QueryObject {
     fn indirect_weight(&self) -> usize {
         self.parent.indirect_weight() + self.entity.indirect_weight()
@@ -1064,7 +1212,9 @@ fn value_bytes() {
     assert_eq!(
         from_query,
         Value::Bytes(scalar::Bytes::from(
-            &[143, 73, 76, 102, 175, 193, 211, 248, 172, 27, 69, 223, 33, 240, 42, 70][..]
+            &[
+                143, 73, 76, 102, 175, 193, 211, 248, 172, 27, 69, 223, 33, 240, 42, 70
+            ][..]
         ))
     );
     assert_eq!(r::Value::from(from_query), graphql_value);
@@ -1085,6 +1235,8 @@ fn value_bigint() {
 
 #[test]
 fn entity_validation() {
+    use crate::data::subgraph::DeploymentHash;
+    use crate::schema::EntityType;
     use crate::schema::InputSchema;
 
     const DOCUMENT: &str = "
@@ -1208,3 +1360,76 @@ fn fmt_debug() {
     let bi = Value::BigInt(scalar::BigInt::from(-17i32));
     assert_eq!("BigInt(-17)", format!("{:?}", bi));
 }
+
+#[test]
+fn entity_hidden_vid() {
+    use crate::schema::InputSchema;
+    let subgraph_id = "oneInterfaceOneEntity";
+    let document = "type Thing @entity {id: ID!, name: String!}";
+    let schema = InputSchema::raw(document, subgraph_id);
+
+    let entity = entity! { schema => id: "1", name: "test", vid: 3i64 };
+    let debug_str = format!("{:?}", entity);
+    let entity_str = "Entity { id: String(\"1\"), name: String(\"test\"), vid: Int8(3) }";
+    assert_eq!(debug_str, entity_str);
+
+    // get returns nothing...
+    assert_eq!(entity.get(VID_FIELD), None);
+    assert!(!entity.contains_key(VID_FIELD));
+    // ...while vid is present
+    assert_eq!(entity.vid(), 3i64);
+
+    // into_iter() misses it too
+    let mut it = entity.into_iter();
+    assert_eq!(Some(("id", &Value::String("1".to_string()))), it.next());
+    assert_eq!(
+        Some(("name", &Value::String("test".to_string()))),
+        it.next()
+    );
+    assert_eq!(None, it.next());
+
+    let mut entity2 = entity! { schema => id: "1", name: "test", vid: 5i64 };
+    assert_eq!(entity2.vid(), 5i64);
+    // equal with different vid
+    assert_eq!(entity, entity2);
+
+    entity2.remove(VID_FIELD);
+    // equal if one has no vid
+    assert_eq!(entity, entity2);
+    let debug_str2 = format!("{:?}", entity2);
+    let entity_str2 = "Entity { id: String(\"1\"), name: String(\"test\") }";
+    assert_eq!(debug_str2, entity_str2);
+
+    // set again
+    _ = entity2.set_vid(7i64);
+    assert_eq!(entity2.vid(), 7i64);
+}
+
+#[test]
+fn merge_remove_null_fields_ignores_vid() {
+    use crate::schema::InputSchema;
+    let schema = InputSchema::raw("type Thing @entity {id: ID!, name: String!}", "test");
+
+    let mut current = entity! { schema => id: "1", name: "alice", vid: 3i64 };
+    let update = entity! { schema => id: "1", name: "alice", vid: 99i64 };
+
+    // Merging an identical entity with a different VID must report no change.
+    let changed = current.merge_remove_null_fields(update).unwrap();
+    assert!(!changed, "VID-only difference must not count as a change");
+    // The VID must still be updated to the new value.
+    assert_eq!(current.vid(), 99i64);
+}
+
+#[test]
+fn merge_remove_null_fields_detects_real_change() {
+    use crate::schema::InputSchema;
+    let schema = InputSchema::raw("type Thing @entity {id: ID!, name: String!}", "test");
+
+    let mut current = entity! { schema => id: "1", name: "alice", vid: 3i64 };
+    let update = entity! { schema => id: "1", name: "bob", vid: 99i64 };
+
+    let changed = current.merge_remove_null_fields(update).unwrap();
+    assert!(changed, "data change must be detected");
+    assert_eq!(current.get("name"), Some(&Value::String("bob".to_string())));
+    assert_eq!(current.vid(), 99i64);
+}
diff --git a/graph/src/data/store/scalar.rs b/graph/src/data/store/scalar.rs
deleted file mode 100644
index 53b247917ef..00000000000
--- a/graph/src/data/store/scalar.rs
+++ /dev/null
@@ -1,805 +0,0 @@
-use diesel::deserialize::FromSql;
-use diesel::serialize::ToSql;
-use diesel_derives::{AsExpression, FromSqlRow};
-use hex;
-use num_bigint;
-use serde::{self, Deserialize, Serialize};
-use stable_hash::utils::AsInt;
-use stable_hash::{FieldAddress, StableHash};
-use stable_hash_legacy::SequenceNumber;
-use thiserror::Error;
-use web3::types::*;
-
-use std::convert::{TryFrom, TryInto};
-use std::fmt::{self, Display, Formatter};
-use std::io::Write;
-use std::ops::{Add, BitAnd, BitOr, Deref, Div, Mul, Rem, Shl, Shr, Sub};
-use std::str::FromStr;
-
-pub use num_bigint::Sign as BigIntSign;
-
-use crate::blockchain::BlockHash;
-use crate::runtime::gas::{Gas, GasSizeOf, SaturatingInto};
-use crate::util::stable_hash_glue::{impl_stable_hash, AsBytes};
-
-/// All operations on `BigDecimal` return a normalized value.
-// Caveat: The exponent is currently an i64 and may overflow. See
-// https://github.com/akubera/bigdecimal-rs/issues/54.
-// Using `#[serde(from = "BigDecimal"]` makes sure deserialization calls `BigDecimal::new()`.
-#[derive(
-    Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, AsExpression, FromSqlRow,
-)]
-#[serde(from = "bigdecimal::BigDecimal")]
-#[sql_type = "diesel::sql_types::Numeric"]
-pub struct BigDecimal(bigdecimal::BigDecimal);
-
-impl From<bigdecimal::BigDecimal> for BigDecimal {
-    fn from(big_decimal: bigdecimal::BigDecimal) -> Self {
-        BigDecimal(big_decimal).normalized()
-    }
-}
-
-impl BigDecimal {
-    /// These are the limits of IEEE-754 decimal128, a format we may want to switch to. See
-    /// https://en.wikipedia.org/wiki/Decimal128_floating-point_format.
-    pub const MIN_EXP: i32 = -6143;
-    pub const MAX_EXP: i32 = 6144;
-    pub const MAX_SIGNFICANT_DIGITS: i32 = 34;
-
-    pub fn new(digits: BigInt, exp: i64) -> Self {
-        // bigdecimal uses `scale` as the opposite of the power of ten, so negate `exp`.
-        Self::from(bigdecimal::BigDecimal::new(digits.inner(), -exp))
-    }
-
-    pub fn parse_bytes(bytes: &[u8]) -> Option<Self> {
-        bigdecimal::BigDecimal::parse_bytes(bytes, 10).map(Self)
-    }
-
-    pub fn zero() -> BigDecimal {
-        use bigdecimal::Zero;
-
-        BigDecimal(bigdecimal::BigDecimal::zero())
-    }
-
-    pub fn as_bigint_and_exponent(&self) -> (num_bigint::BigInt, i64) {
-        self.0.as_bigint_and_exponent()
-    }
-
-    pub fn digits(&self) -> u64 {
-        self.0.digits()
-    }
-
-    // Copy-pasted from `bigdecimal::BigDecimal::normalize`. We can use the upstream version once it
-    // is included in a released version supported by Diesel.
-    #[must_use]
-    pub fn normalized(&self) -> BigDecimal {
-        if self == &BigDecimal::zero() {
-            return BigDecimal::zero();
-        }
-
-        // Round to the maximum significant digits.
-        let big_decimal = self.0.with_prec(Self::MAX_SIGNFICANT_DIGITS as u64);
-
-        let (bigint, exp) = big_decimal.as_bigint_and_exponent();
-        let (sign, mut digits) = bigint.to_radix_be(10);
-        let trailing_count = digits.iter().rev().take_while(|i| **i == 0).count();
-        digits.truncate(digits.len() - trailing_count);
-        let int_val = num_bigint::BigInt::from_radix_be(sign, &digits, 10).unwrap();
-        let scale = exp - trailing_count as i64;
-
-        BigDecimal(bigdecimal::BigDecimal::new(int_val, scale))
-    }
-}
-
-impl Display for BigDecimal {
-    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
-        self.0.fmt(f)
-    }
-}
-
-impl fmt::Debug for BigDecimal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "BigDecimal({})", self.0)
-    }
-}
-
-impl FromStr for BigDecimal {
-    type Err = <bigdecimal::BigDecimal as FromStr>::Err;
-
-    fn from_str(s: &str) -> Result<BigDecimal, Self::Err> {
-        Ok(Self::from(bigdecimal::BigDecimal::from_str(s)?))
-    }
-}
-
-impl From<i32> for BigDecimal {
-    fn from(n: i32) -> Self {
-        Self::from(bigdecimal::BigDecimal::from(n))
-    }
-}
-
-impl From<i64> for BigDecimal {
-    fn from(n: i64) -> Self {
-        Self::from(bigdecimal::BigDecimal::from(n))
-    }
-}
-
-impl From<u64> for BigDecimal {
-    fn from(n: u64) -> Self {
-        Self::from(bigdecimal::BigDecimal::from(n))
-    }
-}
-
-impl From<f64> for BigDecimal {
-    fn from(n: f64) -> Self {
-        Self::from(bigdecimal::BigDecimal::from(n))
-    }
-}
-
-impl Add for BigDecimal {
-    type Output = Self;
-
-    fn add(self, other: Self) -> Self {
-        Self::from(self.0.add(other.0))
-    }
-}
-
-impl Sub for BigDecimal {
-    type Output = Self;
-
-    fn sub(self, other: Self) -> Self {
-        Self::from(self.0.sub(other.0))
-    }
-}
-
-impl Mul for BigDecimal {
-    type Output = Self;
-
-    fn mul(self, other: Self) -> Self {
-        Self::from(self.0.mul(other.0))
-    }
-}
-
-impl Div for BigDecimal {
-    type Output = Self;
-
-    fn div(self, other: Self) -> Self {
-        if other == BigDecimal::from(0) {
-            panic!("Cannot divide by zero-valued `BigDecimal`!")
-        }
-
-        Self::from(self.0.div(other.0))
-    }
-}
-
-// Used only for JSONB support
-impl ToSql<diesel::sql_types::Numeric, diesel::pg::Pg> for BigDecimal {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut diesel::serialize::Output<W, diesel::pg::Pg>,
-    ) -> diesel::serialize::Result {
-        <_ as ToSql<diesel::sql_types::Numeric, _>>::to_sql(&self.0, out)
-    }
-}
-
-impl FromSql<diesel::sql_types::Numeric, diesel::pg::Pg> for BigDecimal {
-    fn from_sql(
-        bytes: Option<&<diesel::pg::Pg as diesel::backend::Backend>::RawValue>,
-    ) -> diesel::deserialize::Result<Self> {
-        Ok(Self::from(bigdecimal::BigDecimal::from_sql(bytes)?))
-    }
-}
-
-impl bigdecimal::ToPrimitive for BigDecimal {
-    fn to_i64(&self) -> Option<i64> {
-        self.0.to_i64()
-    }
-    fn to_u64(&self) -> Option<u64> {
-        self.0.to_u64()
-    }
-}
-
-impl stable_hash_legacy::StableHash for BigDecimal {
-    fn stable_hash<H: stable_hash_legacy::StableHasher>(
-        &self,
-        mut sequence_number: H::Seq,
-        state: &mut H,
-    ) {
-        let (int, exp) = self.as_bigint_and_exponent();
-        // This only allows for backward compatible changes between
-        // BigDecimal and unsigned ints
-        stable_hash_legacy::StableHash::stable_hash(&exp, sequence_number.next_child(), state);
-        stable_hash_legacy::StableHash::stable_hash(
-            &BigInt::unchecked_new(int),
-            sequence_number,
-            state,
-        );
-    }
-}
-
-impl StableHash for BigDecimal {
-    fn stable_hash<H: stable_hash::StableHasher>(&self, field_address: H::Addr, state: &mut H) {
-        // This implementation allows for backward compatible changes from integers (signed or unsigned)
-        // when the exponent is zero.
-        let (int, exp) = self.as_bigint_and_exponent();
-        StableHash::stable_hash(&exp, field_address.child(1), state);
-        // Normally it would be a red flag to pass field_address in after having used a child slot.
-        // But, we know the implemecntation of StableHash for BigInt will not use child(1) and that
-        // it will not in the future due to having no forward schema evolutions for ints and the
-        // stability guarantee.
-        //
-        // For reference, ints use child(0) for the sign and write the little endian bytes to the parent slot.
-        BigInt::unchecked_new(int).stable_hash(field_address, state);
-    }
-}
-
-impl GasSizeOf for BigDecimal {
-    fn gas_size_of(&self) -> Gas {
-        let (int, _) = self.as_bigint_and_exponent();
-        BigInt::unchecked_new(int).gas_size_of()
-    }
-}
-
-// Use a private module to ensure a constructor is used.
-pub use big_int::BigInt;
-mod big_int {
-    use std::{
-        f32::consts::LOG2_10,
-        fmt::{self, Display, Formatter},
-    };
-
-    #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
-    pub struct BigInt(num_bigint::BigInt);
-
-    impl Display for BigInt {
-        fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
-            self.0.fmt(f)
-        }
-    }
-
-    impl BigInt {
-        // Postgres `numeric` has a limit documented here [https://www.postgresql.org/docs/current/datatype-numeric.htm]:
-        // "Up to 131072 digits before the decimal point; up to 16383 digits after the decimal point"
-        // So based on this we adopt a limit of 131072 decimal digits for big int, converted here to bits.
-        pub const MAX_BITS: u32 = (131072.0 * LOG2_10) as u32 + 1; // 435_412
-
-        pub fn new(inner: num_bigint::BigInt) -> Result<Self, anyhow::Error> {
-            // `inner.bits()` won't include the sign bit, so we add 1 to account for it.
-            let bits = inner.bits() + 1;
-            if bits > Self::MAX_BITS as usize {
-                anyhow::bail!(
-                    "BigInt is too big, total bits {} (max {})",
-                    bits,
-                    Self::MAX_BITS
-                );
-            }
-            Ok(Self(inner))
-        }
-
-        /// Creates a BigInt without checking the digit limit.
-        pub(super) fn unchecked_new(inner: num_bigint::BigInt) -> Self {
-            Self(inner)
-        }
-
-        pub fn sign(&self) -> num_bigint::Sign {
-            self.0.sign()
-        }
-
-        pub fn to_bytes_le(&self) -> (super::BigIntSign, Vec<u8>) {
-            self.0.to_bytes_le()
-        }
-
-        pub fn to_bytes_be(&self) -> (super::BigIntSign, Vec<u8>) {
-            self.0.to_bytes_be()
-        }
-
-        pub fn to_signed_bytes_le(&self) -> Vec<u8> {
-            self.0.to_signed_bytes_le()
-        }
-
-        pub fn bits(&self) -> usize {
-            self.0.bits()
-        }
-
-        pub(super) fn inner(self) -> num_bigint::BigInt {
-            self.0
-        }
-    }
-}
-
-impl stable_hash_legacy::StableHash for BigInt {
-    #[inline]
-    fn stable_hash<H: stable_hash_legacy::StableHasher>(
-        &self,
-        sequence_number: H::Seq,
-        state: &mut H,
-    ) {
-        stable_hash_legacy::utils::AsInt {
-            is_negative: self.sign() == BigIntSign::Minus,
-            little_endian: &self.to_bytes_le().1,
-        }
-        .stable_hash(sequence_number, state)
-    }
-}
-
-impl StableHash for BigInt {
-    fn stable_hash<H: stable_hash::StableHasher>(&self, field_address: H::Addr, state: &mut H) {
-        AsInt {
-            is_negative: self.sign() == BigIntSign::Minus,
-            little_endian: &self.to_bytes_le().1,
-        }
-        .stable_hash(field_address, state)
-    }
-}
-
-#[derive(Error, Debug)]
-pub enum BigIntOutOfRangeError {
-    #[error("Cannot convert negative BigInt into type")]
-    Negative,
-    #[error("BigInt value is too large for type")]
-    Overflow,
-}
-
-impl<'a> TryFrom<&'a BigInt> for u64 {
-    type Error = BigIntOutOfRangeError;
-    fn try_from(value: &'a BigInt) -> Result<u64, BigIntOutOfRangeError> {
-        let (sign, bytes) = value.to_bytes_le();
-
-        if sign == num_bigint::Sign::Minus {
-            return Err(BigIntOutOfRangeError::Negative);
-        }
-
-        if bytes.len() > 8 {
-            return Err(BigIntOutOfRangeError::Overflow);
-        }
-
-        // Replace this with u64::from_le_bytes when stabilized
-        let mut n = 0u64;
-        let mut shift_dist = 0;
-        for b in bytes {
-            n |= (b as u64) << shift_dist;
-            shift_dist += 8;
-        }
-        Ok(n)
-    }
-}
-
-impl TryFrom<BigInt> for u64 {
-    type Error = BigIntOutOfRangeError;
-    fn try_from(value: BigInt) -> Result<u64, BigIntOutOfRangeError> {
-        (&value).try_into()
-    }
-}
-
-impl fmt::Debug for BigInt {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "BigInt({})", self)
-    }
-}
-
-impl BigInt {
-    pub fn from_unsigned_bytes_le(bytes: &[u8]) -> Result<Self, anyhow::Error> {
-        BigInt::new(num_bigint::BigInt::from_bytes_le(
-            num_bigint::Sign::Plus,
-            bytes,
-        ))
-    }
-
-    pub fn from_signed_bytes_le(bytes: &[u8]) -> Result<Self, anyhow::Error> {
-        BigInt::new(num_bigint::BigInt::from_signed_bytes_le(bytes))
-    }
-
-    pub fn from_signed_bytes_be(bytes: &[u8]) -> Result<Self, anyhow::Error> {
-        BigInt::new(num_bigint::BigInt::from_signed_bytes_be(bytes))
-    }
-
-    /// Deprecated. Use try_into instead
-    pub fn to_u64(&self) -> u64 {
-        self.try_into().unwrap()
-    }
-
-    pub fn from_unsigned_u128(n: U128) -> Self {
-        let mut bytes: [u8; 16] = [0; 16];
-        n.to_little_endian(&mut bytes);
-        // Unwrap: 128 bits is much less than BigInt::MAX_BITS
-        BigInt::from_unsigned_bytes_le(&bytes).unwrap()
-    }
-
-    pub fn from_unsigned_u256(n: &U256) -> Self {
-        let mut bytes: [u8; 32] = [0; 32];
-        n.to_little_endian(&mut bytes);
-        // Unwrap: 256 bits is much less than BigInt::MAX_BITS
-        BigInt::from_unsigned_bytes_le(&bytes).unwrap()
-    }
-
-    pub fn from_signed_u256(n: &U256) -> Self {
-        let mut bytes: [u8; 32] = [0; 32];
-        n.to_little_endian(&mut bytes);
-        BigInt::from_signed_bytes_le(&bytes).unwrap()
-    }
-
-    pub fn to_signed_u256(&self) -> U256 {
-        let bytes = self.to_signed_bytes_le();
-        if self < &BigInt::from(0) {
-            assert!(
-                bytes.len() <= 32,
-                "BigInt value does not fit into signed U256"
-            );
-            let mut i_bytes: [u8; 32] = [255; 32];
-            i_bytes[..bytes.len()].copy_from_slice(&bytes);
-            U256::from_little_endian(&i_bytes)
-        } else {
-            U256::from_little_endian(&bytes)
-        }
-    }
-
-    pub fn to_unsigned_u256(&self) -> U256 {
-        let (sign, bytes) = self.to_bytes_le();
-        assert!(
-            sign == BigIntSign::NoSign || sign == BigIntSign::Plus,
-            "negative value encountered for U256: {}",
-            self
-        );
-        U256::from_little_endian(&bytes)
-    }
-
-    pub fn pow(self, exponent: u8) -> Result<BigInt, anyhow::Error> {
-        use num_traits::pow::Pow;
-
-        BigInt::new(self.inner().pow(&exponent))
-    }
-}
-
-impl From<i32> for BigInt {
-    fn from(i: i32) -> BigInt {
-        BigInt::unchecked_new(i.into())
-    }
-}
-
-impl From<u64> for BigInt {
-    fn from(i: u64) -> BigInt {
-        BigInt::unchecked_new(i.into())
-    }
-}
-
-impl From<i64> for BigInt {
-    fn from(i: i64) -> BigInt {
-        BigInt::unchecked_new(i.into())
-    }
-}
-
-impl From<U64> for BigInt {
-    /// This implementation assumes that U64 represents an unsigned U64,
-    /// and not a signed U64 (aka int64 in Solidity). Right now, this is
-    /// all we need (for block numbers). If it ever becomes necessary to
-    /// handle signed U64s, we should add the same
-    /// `{to,from}_{signed,unsigned}_u64` methods that we have for U64.
-    fn from(n: U64) -> BigInt {
-        BigInt::from(n.as_u64())
-    }
-}
-
-impl FromStr for BigInt {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<BigInt, Self::Err> {
-        num_bigint::BigInt::from_str(s)
-            .map_err(anyhow::Error::from)
-            .and_then(BigInt::new)
-    }
-}
-
-impl Serialize for BigInt {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.to_string().serialize(serializer)
-    }
-}
-
-impl<'de> Deserialize<'de> for BigInt {
-    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        use serde::de::Error;
-
-        let decimal_string = <String>::deserialize(deserializer)?;
-        BigInt::from_str(&decimal_string).map_err(D::Error::custom)
-    }
-}
-
-impl Add for BigInt {
-    type Output = BigInt;
-
-    fn add(self, other: BigInt) -> BigInt {
-        BigInt::unchecked_new(self.inner().add(other.inner()))
-    }
-}
-
-impl Sub for BigInt {
-    type Output = BigInt;
-
-    fn sub(self, other: BigInt) -> BigInt {
-        BigInt::unchecked_new(self.inner().sub(other.inner()))
-    }
-}
-
-impl Mul for BigInt {
-    type Output = BigInt;
-
-    fn mul(self, other: BigInt) -> BigInt {
-        BigInt::unchecked_new(self.inner().mul(other.inner()))
-    }
-}
-
-impl Div for BigInt {
-    type Output = BigInt;
-
-    fn div(self, other: BigInt) -> BigInt {
-        if other == BigInt::from(0) {
-            panic!("Cannot divide by zero-valued `BigInt`!")
-        }
-
-        BigInt::unchecked_new(self.inner().div(other.inner()))
-    }
-}
-
-impl Rem for BigInt {
-    type Output = BigInt;
-
-    fn rem(self, other: BigInt) -> BigInt {
-        BigInt::unchecked_new(self.inner().rem(other.inner()))
-    }
-}
-
-impl BitOr for BigInt {
-    type Output = Self;
-
-    fn bitor(self, other: Self) -> Self {
-        BigInt::unchecked_new(self.inner().bitor(other.inner()))
-    }
-}
-
-impl BitAnd for BigInt {
-    type Output = Self;
-
-    fn bitand(self, other: Self) -> Self {
-        BigInt::unchecked_new(self.inner().bitand(other.inner()))
-    }
-}
-
-impl Shl<u8> for BigInt {
-    type Output = Self;
-
-    fn shl(self, bits: u8) -> Self {
-        BigInt::unchecked_new(self.inner().shl(bits.into()))
-    }
-}
-
-impl Shr<u8> for BigInt {
-    type Output = Self;
-
-    fn shr(self, bits: u8) -> Self {
-        BigInt::unchecked_new(self.inner().shr(bits.into()))
-    }
-}
-
-impl GasSizeOf for BigInt {
-    fn gas_size_of(&self) -> Gas {
-        // Add one to always have an upper bound on the number of bytes required to represent the
-        // number, and so that `0` has a size of 1.
-        let n_bytes = self.bits() / 8 + 1;
-        n_bytes.saturating_into()
-    }
-}
-
-/// A byte array that's serialized as a hex string prefixed by `0x`.
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Bytes(Box<[u8]>);
-
-impl Deref for Bytes {
-    type Target = [u8];
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl fmt::Debug for Bytes {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "Bytes(0x{})", hex::encode(&self.0))
-    }
-}
-
-impl_stable_hash!(Bytes(transparent: AsBytes));
-
-impl Bytes {
-    pub fn as_slice(&self) -> &[u8] {
-        &self.0
-    }
-}
-
-impl Display for Bytes {
-    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
-        write!(f, "0x{}", hex::encode(&self.0))
-    }
-}
-
-impl FromStr for Bytes {
-    type Err = hex::FromHexError;
-
-    fn from_str(s: &str) -> Result<Bytes, Self::Err> {
-        hex::decode(s.trim_start_matches("0x")).map(|x| Bytes(x.into()))
-    }
-}
-
-impl<'a> From<&'a [u8]> for Bytes {
-    fn from(array: &[u8]) -> Self {
-        Bytes(array.into())
-    }
-}
-
-impl From<Address> for Bytes {
-    fn from(address: Address) -> Bytes {
-        Bytes::from(address.as_ref())
-    }
-}
-
-impl From<web3::types::Bytes> for Bytes {
-    fn from(bytes: web3::types::Bytes) -> Bytes {
-        Bytes::from(bytes.0.as_slice())
-    }
-}
-
-impl From<BlockHash> for Bytes {
-    fn from(hash: BlockHash) -> Self {
-        Bytes(hash.0)
-    }
-}
-
-impl Serialize for Bytes {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.to_string().serialize(serializer)
-    }
-}
-
-impl<'de> Deserialize<'de> for Bytes {
-    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        use serde::de::Error;
-
-        let hex_string = <String>::deserialize(deserializer)?;
-        Bytes::from_str(&hex_string).map_err(D::Error::custom)
-    }
-}
-
-impl<const N: usize> From<[u8; N]> for Bytes {
-    fn from(array: [u8; N]) -> Bytes {
-        Bytes(array.into())
-    }
-}
-
-impl From<Vec<u8>> for Bytes {
-    fn from(vec: Vec<u8>) -> Self {
-        Bytes(vec.into())
-    }
-}
-
-impl ToSql<diesel::sql_types::Binary, diesel::pg::Pg> for Bytes {
-    fn to_sql<W: Write>(
-        &self,
-        out: &mut diesel::serialize::Output<W, diesel::pg::Pg>,
-    ) -> diesel::serialize::Result {
-        <_ as ToSql<diesel::sql_types::Binary, _>>::to_sql(self.as_slice(), out)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::{BigDecimal, BigInt, Bytes};
-    use stable_hash_legacy::crypto::SetHasher;
-    use stable_hash_legacy::prelude::*;
-    use stable_hash_legacy::utils::stable_hash;
-    use std::str::FromStr;
-    use web3::types::U64;
-
-    #[test]
-    fn bigint_to_from_u64() {
-        for n in 0..100 {
-            let u = U64::from(n);
-            let bn = BigInt::from(u);
-            assert_eq!(n, bn.to_u64());
-        }
-    }
-
-    fn crypto_stable_hash(value: impl StableHash) -> <SetHasher as StableHasher>::Out {
-        stable_hash::<SetHasher, _>(&value)
-    }
-
-    fn same_stable_hash(left: impl StableHash, right: impl StableHash) {
-        let left = crypto_stable_hash(left);
-        let right = crypto_stable_hash(right);
-        assert_eq!(left, right);
-    }
-
-    #[test]
-    fn big_int_stable_hash_same_as_int() {
-        same_stable_hash(0, BigInt::from(0u64));
-        same_stable_hash(1, BigInt::from(1u64));
-        same_stable_hash(1u64 << 20, BigInt::from(1u64 << 20));
-
-        same_stable_hash(
-            -1,
-            BigInt::from_signed_bytes_le(&(-1i32).to_le_bytes()).unwrap(),
-        );
-    }
-
-    #[test]
-    fn big_decimal_stable_hash_same_as_uint() {
-        same_stable_hash(0, BigDecimal::from(0u64));
-        same_stable_hash(4, BigDecimal::from(4i64));
-        same_stable_hash(1u64 << 21, BigDecimal::from(1u64 << 21));
-    }
-
-    #[test]
-    fn big_decimal_stable() {
-        let cases = vec![
-            (
-                "28b09c9c3f3e2fe037631b7fbccdf65c37594073016d8bf4bb0708b3fda8066a",
-                "0.1",
-            ),
-            (
-                "74fb39f038d2f1c8975740bf2651a5ac0403330ee7e9367f9563cbd7d21086bd",
-                "-0.1",
-            ),
-            (
-                "1d79e0476bc5d6fe6074fb54636b04fd3bc207053c767d9cb5e710ba5f002441",
-                "198.98765544",
-            ),
-            (
-                "e63f6ad2c65f193aa9eba18dd7e1043faa2d6183597ba84c67765aaa95c95351",
-                "0.00000093937698",
-            ),
-            (
-                "6b06b34cc714810072988dc46c493c66a6b6c2c2dd0030271aa3adf3b3f21c20",
-                "98765587998098786876.0",
-            ),
-        ];
-        for (hash, s) in cases.iter() {
-            let dec = BigDecimal::from_str(s).unwrap();
-            assert_eq!(*hash, hex::encode(crypto_stable_hash(dec)));
-        }
-    }
-
-    #[test]
-    fn test_normalize() {
-        let vals = vec![
-            (
-                BigDecimal::new(BigInt::from(10), -2),
-                BigDecimal(bigdecimal::BigDecimal::new(1.into(), 1)),
-                "0.1",
-            ),
-            (
-                BigDecimal::new(BigInt::from(132400), 4),
-                BigDecimal(bigdecimal::BigDecimal::new(1324.into(), -6)),
-                "1324000000",
-            ),
-            (
-                BigDecimal::new(BigInt::from(1_900_000), -3),
-                BigDecimal(bigdecimal::BigDecimal::new(19.into(), -2)),
-                "1900",
-            ),
-            (BigDecimal::new(0.into(), 3), BigDecimal::zero(), "0"),
-            (BigDecimal::new(0.into(), -5), BigDecimal::zero(), "0"),
-        ];
-
-        for (not_normalized, normalized, string) in vals {
-            assert_eq!(not_normalized.normalized(), normalized);
-            assert_eq!(not_normalized.normalized().to_string(), string);
-            assert_eq!(normalized.to_string(), string);
-        }
-    }
-
-    #[test]
-    fn fmt_debug() {
-        let bi = BigInt::from(-17);
-        let bd = BigDecimal::new(bi.clone(), -2);
-        let bytes = Bytes::from([222, 173, 190, 239].as_slice());
-        assert_eq!("BigInt(-17)", format!("{:?}", bi));
-        assert_eq!("BigDecimal(-0.17)", format!("{:?}", bd));
-        assert_eq!("Bytes(0xdeadbeef)", format!("{:?}", bytes));
-    }
-}
diff --git a/graph/src/data/store/scalar/bigdecimal.rs b/graph/src/data/store/scalar/bigdecimal.rs
new file mode 100644
index 00000000000..3d038682471
--- /dev/null
+++ b/graph/src/data/store/scalar/bigdecimal.rs
@@ -0,0 +1,700 @@
+use diesel::deserialize::FromSqlRow;
+use diesel::expression::AsExpression;
+use num_bigint::{self, ToBigInt};
+use num_traits::FromPrimitive;
+use serde::{self, Deserialize, Serialize};
+use stable_hash::{FieldAddress, StableHash};
+use stable_hash_legacy::SequenceNumber;
+
+use std::fmt::{self, Display, Formatter};
+use std::ops::{Add, Div, Mul, Sub};
+use std::str::FromStr;
+
+use crate::anyhow::anyhow;
+use crate::runtime::gas::{Gas, GasSizeOf};
+use old_bigdecimal::BigDecimal as OldBigDecimal;
+pub use old_bigdecimal::ToPrimitive;
+
+use super::BigInt;
+
+/// All operations on `BigDecimal` return a normalized value.
+// Caveat: The exponent is currently an i64 and may overflow. See
+// https://github.com/akubera/bigdecimal-rs/issues/54.
+// Using `#[serde(from = "BigDecimal"]` makes sure deserialization calls `BigDecimal::new()`.
+#[derive(
+    Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, AsExpression, FromSqlRow,
+)]
+#[serde(from = "OldBigDecimal")]
+#[diesel(sql_type = diesel::sql_types::Numeric)]
+pub struct BigDecimal(OldBigDecimal);
+
+impl From<OldBigDecimal> for BigDecimal {
+    fn from(big_decimal: OldBigDecimal) -> Self {
+        BigDecimal(big_decimal).normalized()
+    }
+}
+
+impl BigDecimal {
+    /// These are the limits of IEEE-754 decimal128, a format we may want to switch to. See
+    /// https://en.wikipedia.org/wiki/Decimal128_floating-point_format.
+    pub const MIN_EXP: i32 = -6143;
+    pub const MAX_EXP: i32 = 6144;
+    pub const MAX_SIGNFICANT_DIGITS: i32 = 34;
+
+    pub fn new(digits: BigInt, exp: i64) -> Self {
+        // bigdecimal uses `scale` as the opposite of the power of ten, so negate `exp`.
+        Self::from(OldBigDecimal::new(digits.inner(), -exp))
+    }
+
+    pub fn parse_bytes(bytes: &[u8]) -> Option<Self> {
+        OldBigDecimal::parse_bytes(bytes, 10).map(Self)
+    }
+
+    pub fn zero() -> BigDecimal {
+        use old_bigdecimal::Zero;
+
+        BigDecimal(OldBigDecimal::zero())
+    }
+
+    pub fn as_bigint_and_exponent(&self) -> (num_bigint::BigInt, i64) {
+        self.0.as_bigint_and_exponent()
+    }
+
+    pub fn is_integer(&self) -> bool {
+        self.0.is_integer()
+    }
+
+    /// Convert this `BigDecimal` to a `BigInt` if it is an integer, and
+    /// return an error if it is not. Also return an error if the integer
+    /// would use too many digits as definied by `BigInt::new`
+    pub fn to_bigint(&self) -> Result<BigInt, anyhow::Error> {
+        if !self.is_integer() {
+            return Err(anyhow!(
+                "Cannot convert non-integer `BigDecimal` to `BigInt`: {:?}",
+                self
+            ));
+        }
+        let bi = self.0.to_bigint().ok_or_else(|| {
+            anyhow!("The implementation of `to_bigint` for `OldBigDecimal` always returns `Some`")
+        })?;
+        BigInt::new(bi)
+    }
+
+    pub fn digits(&self) -> u64 {
+        self.0.digits()
+    }
+
+    // Copy-pasted from `OldBigDecimal::normalize`. We can use the upstream version once it
+    // is included in a released version supported by Diesel.
+    #[must_use]
+    pub fn normalized(&self) -> BigDecimal {
+        if self == &BigDecimal::zero() {
+            return BigDecimal::zero();
+        }
+
+        // Round to the maximum significant digits.
+        let big_decimal = self.0.with_prec(Self::MAX_SIGNFICANT_DIGITS as u64);
+
+        let (bigint, exp) = big_decimal.as_bigint_and_exponent();
+        let (sign, mut digits) = bigint.to_radix_be(10);
+        let trailing_count = digits.iter().rev().take_while(|i| **i == 0).count();
+        digits.truncate(digits.len() - trailing_count);
+        let int_val = num_bigint::BigInt::from_radix_be(sign, &digits, 10).unwrap();
+        let scale = exp - trailing_count as i64;
+
+        BigDecimal(OldBigDecimal::new(int_val, scale))
+    }
+}
+
+impl Display for BigDecimal {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+        self.0.fmt(f)
+    }
+}
+
+impl fmt::Debug for BigDecimal {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "BigDecimal({})", self.0)
+    }
+}
+
+impl FromStr for BigDecimal {
+    type Err = <OldBigDecimal as FromStr>::Err;
+
+    fn from_str(s: &str) -> Result<BigDecimal, Self::Err> {
+        Ok(Self::from(OldBigDecimal::from_str(s)?))
+    }
+}
+
+impl From<i32> for BigDecimal {
+    fn from(n: i32) -> Self {
+        Self::from(OldBigDecimal::from(n))
+    }
+}
+
+impl From<i64> for BigDecimal {
+    fn from(n: i64) -> Self {
+        Self::from(OldBigDecimal::from(n))
+    }
+}
+
+impl From<i128> for BigDecimal {
+    fn from(n: i128) -> Self {
+        Self::from(OldBigDecimal::new(BigInt::from(n).inner(), 0))
+    }
+}
+
+impl From<u64> for BigDecimal {
+    fn from(n: u64) -> Self {
+        Self::from(OldBigDecimal::from(n))
+    }
+}
+
+impl From<f32> for BigDecimal {
+    fn from(n: f32) -> Self {
+        Self::from(OldBigDecimal::from_f32(n).unwrap_or_default())
+    }
+}
+
+impl From<f64> for BigDecimal {
+    fn from(n: f64) -> Self {
+        Self::from(OldBigDecimal::from_f64(n).unwrap_or_default())
+    }
+}
+
+impl Add for BigDecimal {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        Self::from(self.0.add(other.0))
+    }
+}
+
+impl Sub for BigDecimal {
+    type Output = Self;
+
+    fn sub(self, other: Self) -> Self {
+        Self::from(self.0.sub(other.0))
+    }
+}
+
+impl Mul for BigDecimal {
+    type Output = Self;
+
+    fn mul(self, other: Self) -> Self {
+        Self::from(self.0.mul(other.0))
+    }
+}
+
+impl Div for BigDecimal {
+    type Output = Self;
+
+    fn div(self, other: Self) -> Self {
+        if other == BigDecimal::from(0) {
+            panic!("Cannot divide by zero-valued `BigDecimal`!")
+        }
+
+        Self::from(self.0.div(other.0))
+    }
+}
+
+impl old_bigdecimal::ToPrimitive for BigDecimal {
+    fn to_i64(&self) -> Option<i64> {
+        self.0.to_i64()
+    }
+    fn to_u64(&self) -> Option<u64> {
+        self.0.to_u64()
+    }
+}
+
+impl stable_hash_legacy::StableHash for BigDecimal {
+    fn stable_hash<H: stable_hash_legacy::StableHasher>(
+        &self,
+        mut sequence_number: H::Seq,
+        state: &mut H,
+    ) {
+        let (int, exp) = self.as_bigint_and_exponent();
+        // This only allows for backward compatible changes between
+        // BigDecimal and unsigned ints
+        stable_hash_legacy::StableHash::stable_hash(&exp, sequence_number.next_child(), state);
+        stable_hash_legacy::StableHash::stable_hash(
+            &BigInt::unchecked_new(int),
+            sequence_number,
+            state,
+        );
+    }
+}
+
+impl StableHash for BigDecimal {
+    fn stable_hash<H: stable_hash::StableHasher>(&self, field_address: H::Addr, state: &mut H) {
+        // This implementation allows for backward compatible changes from integers (signed or unsigned)
+        // when the exponent is zero.
+        let (int, exp) = self.as_bigint_and_exponent();
+        StableHash::stable_hash(&exp, field_address.child(1), state);
+        // Normally it would be a red flag to pass field_address in after having used a child slot.
+        // But, we know the implemecntation of StableHash for BigInt will not use child(1) and that
+        // it will not in the future due to having no forward schema evolutions for ints and the
+        // stability guarantee.
+        //
+        // For reference, ints use child(0) for the sign and write the little endian bytes to the parent slot.
+        BigInt::unchecked_new(int).stable_hash(field_address, state);
+    }
+}
+
+impl GasSizeOf for BigDecimal {
+    fn gas_size_of(&self) -> Gas {
+        let (int, _) = self.as_bigint_and_exponent();
+        BigInt::unchecked_new(int).gas_size_of()
+    }
+}
+
+// This code was copied from diesel. Unfortunately, we need to reimplement
+// it here because any change to diesel's version of bigdecimal will cause
+// the build to break as our old_bigdecimal::BigDecimal and diesel's
+// bigdecimal::BigDecimal will then become distinct types, and we can't
+// update our old_bigdecimal because updating causes PoI divergences.
+//
+// The code was taken from diesel-2.1.4/src/pg/types/numeric.rs
+mod pg {
+    use std::error::Error;
+
+    use diesel::deserialize::FromSql;
+    use diesel::pg::{Pg, PgValue};
+    use diesel::serialize::{self, Output, ToSql};
+    use diesel::sql_types::Numeric;
+    use diesel::{data_types::PgNumeric, deserialize};
+    use num_bigint::{BigInt, BigUint, Sign};
+    use num_integer::Integer;
+    use num_traits::{Signed, ToPrimitive, Zero};
+
+    use super::super::BigIntSign;
+    use super::{BigDecimal, OldBigDecimal};
+
+    /// Iterator over the digits of a big uint in base 10k.
+    /// The digits will be returned in little endian order.
+    struct ToBase10000(Option<BigUint>);
+
+    impl Iterator for ToBase10000 {
+        type Item = i16;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.0.take().map(|v| {
+                let (div, rem) = v.div_rem(&BigUint::from(10_000u16));
+                if !div.is_zero() {
+                    self.0 = Some(div);
+                }
+                rem.to_i16().expect("10000 always fits in an i16")
+            })
+        }
+    }
+
+    impl<'a> TryFrom<&'a PgNumeric> for BigDecimal {
+        type Error = Box<dyn Error + Send + Sync>;
+
+        fn try_from(numeric: &'a PgNumeric) -> deserialize::Result<Self> {
+            let (sign, weight, scale, digits) = match *numeric {
+                PgNumeric::Positive {
+                    weight,
+                    scale,
+                    ref digits,
+                } => (BigIntSign::Plus, weight, scale, digits),
+                PgNumeric::Negative {
+                    weight,
+                    scale,
+                    ref digits,
+                } => (Sign::Minus, weight, scale, digits),
+                PgNumeric::NaN => {
+                    return Err(Box::from("NaN is not (yet) supported in BigDecimal"));
+                }
+            };
+
+            let mut result = BigUint::default();
+            let count = digits.len() as i64;
+            for digit in digits {
+                result *= BigUint::from(10_000u64);
+                result += BigUint::from(*digit as u64);
+            }
+            // First digit got factor 10_000^(digits.len() - 1), but should get 10_000^weight
+            let correction_exp = 4 * (i64::from(weight) - count + 1);
+            let result = OldBigDecimal::new(BigInt::from_biguint(sign, result), -correction_exp)
+                .with_scale(i64::from(scale));
+            Ok(BigDecimal(result))
+        }
+    }
+
+    impl TryFrom<PgNumeric> for BigDecimal {
+        type Error = Box<dyn Error + Send + Sync>;
+
+        fn try_from(numeric: PgNumeric) -> deserialize::Result<Self> {
+            (&numeric).try_into()
+        }
+    }
+
+    impl<'a> From<&'a BigDecimal> for PgNumeric {
+        // NOTE(clippy): No `std::ops::MulAssign` impl for `BigInt`
+        // NOTE(clippy): Clippy suggests to replace the `.take_while(|i| i.is_zero())`
+        // with `.take_while(Zero::is_zero)`, but that's a false positive.
+        // The closure gets an `&&i16` due to autoderef `<i16 as Zero>::is_zero(&self) -> bool`
+        // is called. There is no impl for `&i16` that would work with this closure.
+        #[allow(clippy::assign_op_pattern, clippy::redundant_closure)]
+        fn from(decimal: &'a BigDecimal) -> Self {
+            let (mut integer, scale) = decimal.as_bigint_and_exponent();
+
+            // Handling of negative scale
+            let scale = if scale < 0 {
+                for _ in 0..(-scale) {
+                    integer = integer * 10;
+                }
+                0
+            } else {
+                scale as u16
+            };
+
+            integer = integer.abs();
+
+            // Ensure that the decimal will always lie on a digit boundary
+            for _ in 0..(4 - scale % 4) {
+                integer = integer * 10;
+            }
+            let integer = integer.to_biguint().expect("integer is always positive");
+
+            let mut digits = ToBase10000(Some(integer)).collect::<Vec<_>>();
+            digits.reverse();
+            let digits_after_decimal = scale / 4 + 1;
+            let weight = digits.len() as i16 - digits_after_decimal as i16 - 1;
+
+            let unnecessary_zeroes = digits.iter().rev().take_while(|i| i.is_zero()).count();
+
+            let relevant_digits = digits.len() - unnecessary_zeroes;
+            digits.truncate(relevant_digits);
+
+            match decimal.0.sign() {
+                Sign::Plus => PgNumeric::Positive {
+                    digits,
+                    scale,
+                    weight,
+                },
+                Sign::Minus => PgNumeric::Negative {
+                    digits,
+                    scale,
+                    weight,
+                },
+                Sign::NoSign => PgNumeric::Positive {
+                    digits: vec![0],
+                    scale: 0,
+                    weight: 0,
+                },
+            }
+        }
+    }
+
+    impl From<BigDecimal> for PgNumeric {
+        fn from(bigdecimal: BigDecimal) -> Self {
+            (&bigdecimal).into()
+        }
+    }
+
+    impl ToSql<Numeric, Pg> for BigDecimal {
+        fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
+            let numeric = PgNumeric::from(self);
+            ToSql::<Numeric, Pg>::to_sql(&numeric, &mut out.reborrow())
+        }
+    }
+
+    impl FromSql<Numeric, Pg> for BigDecimal {
+        fn from_sql(numeric: PgValue<'_>) -> deserialize::Result<Self> {
+            PgNumeric::from_sql(numeric)?.try_into()
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        // The tests are exactly the same as Diesel's tests, but we use our
+        // BigDecimal instead of bigdecimal::BigDecimal. In a few places, we
+        // have to construct the BigDecimal directly as
+        // `BigDecimal(OldBigDecimal...)` because BigDecimal::new inverts
+        // the sign of the exponent
+        use diesel::data_types::PgNumeric;
+
+        use super::super::{BigDecimal, OldBigDecimal};
+        use std::str::FromStr;
+
+        #[test]
+        fn bigdecimal_to_pgnumeric_converts_digits_to_base_10000() {
+            let decimal = BigDecimal::from_str("1").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: 0,
+                scale: 0,
+                digits: vec![1],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal::from_str("10").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: 0,
+                scale: 0,
+                digits: vec![10],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal::from_str("10000").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: 1,
+                scale: 0,
+                digits: vec![1],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal::from_str("10001").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: 1,
+                scale: 0,
+                digits: vec![1, 1],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal::from_str("100000000").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: 2,
+                scale: 0,
+                digits: vec![1],
+            };
+            assert_eq!(expected, decimal.into());
+        }
+
+        #[test]
+        fn bigdecimal_to_pg_numeric_properly_adjusts_scale() {
+            let decimal = BigDecimal::from_str("1").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: 0,
+                scale: 0,
+                digits: vec![1],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal(OldBigDecimal::from_str("1.0").unwrap());
+            let expected = PgNumeric::Positive {
+                weight: 0,
+                scale: 1,
+                digits: vec![1],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal::from_str("1.1").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: 0,
+                scale: 1,
+                digits: vec![1, 1000],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal(OldBigDecimal::from_str("1.10").unwrap());
+            let expected = PgNumeric::Positive {
+                weight: 0,
+                scale: 2,
+                digits: vec![1, 1000],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal::from_str("100000000.0001").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: 2,
+                scale: 4,
+                digits: vec![1, 0, 0, 1],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal::from_str("0.1").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: -1,
+                scale: 1,
+                digits: vec![1000],
+            };
+            assert_eq!(expected, decimal.into());
+        }
+
+        #[test]
+        fn bigdecimal_to_pg_numeric_retains_sign() {
+            let decimal = BigDecimal::from_str("123.456").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: 0,
+                scale: 3,
+                digits: vec![123, 4560],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal::from_str("-123.456").unwrap();
+            let expected = PgNumeric::Negative {
+                weight: 0,
+                scale: 3,
+                digits: vec![123, 4560],
+            };
+            assert_eq!(expected, decimal.into());
+        }
+
+        #[test]
+        fn bigdecimal_with_negative_scale_to_pg_numeric_works() {
+            let decimal = BigDecimal(OldBigDecimal::new(50.into(), -2));
+            let expected = PgNumeric::Positive {
+                weight: 0,
+                scale: 0,
+                digits: vec![5000],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal(OldBigDecimal::new(1.into(), -4));
+            let expected = PgNumeric::Positive {
+                weight: 1,
+                scale: 0,
+                digits: vec![1],
+            };
+            assert_eq!(expected, decimal.into());
+        }
+
+        #[test]
+        fn bigdecimal_with_negative_weight_to_pg_numeric_works() {
+            let decimal = BigDecimal(OldBigDecimal::from_str("0.1000000000000000").unwrap());
+            let expected = PgNumeric::Positive {
+                weight: -1,
+                scale: 16,
+                digits: vec![1000],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal::from_str("0.00315937").unwrap();
+            let expected = PgNumeric::Positive {
+                weight: -1,
+                scale: 8,
+                digits: vec![31, 5937],
+            };
+            assert_eq!(expected, decimal.into());
+
+            let decimal = BigDecimal(OldBigDecimal::from_str("0.003159370000000000").unwrap());
+            let expected = PgNumeric::Positive {
+                weight: -1,
+                scale: 18,
+                digits: vec![31, 5937],
+            };
+            assert_eq!(expected, decimal.into());
+        }
+
+        #[test]
+        fn pg_numeric_to_bigdecimal_works() {
+            let expected = BigDecimal::from_str("123.456").unwrap();
+            let pg_numeric = PgNumeric::Positive {
+                weight: 0,
+                scale: 3,
+                digits: vec![123, 4560],
+            };
+            let res: BigDecimal = pg_numeric.try_into().unwrap();
+            assert_eq!(res, expected);
+
+            let expected = BigDecimal::from_str("-56.78").unwrap();
+            let pg_numeric = PgNumeric::Negative {
+                weight: 0,
+                scale: 2,
+                digits: vec![56, 7800],
+            };
+            let res: BigDecimal = pg_numeric.try_into().unwrap();
+            assert_eq!(res, expected);
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{
+        super::Bytes,
+        super::test::{crypto_stable_hash, same_stable_hash},
+        BigDecimal, BigInt, OldBigDecimal,
+    };
+    use std::str::FromStr;
+
+    #[test]
+    fn big_int_stable_hash_same_as_int() {
+        same_stable_hash(0, BigInt::from(0u64));
+        same_stable_hash(1, BigInt::from(1u64));
+        same_stable_hash(1u64 << 20, BigInt::from(1u64 << 20));
+
+        same_stable_hash(
+            -1,
+            BigInt::from_signed_bytes_le(&(-1i32).to_le_bytes()).unwrap(),
+        );
+    }
+
+    #[test]
+    fn big_decimal_stable_hash_same_as_uint() {
+        same_stable_hash(0, BigDecimal::from(0u64));
+        same_stable_hash(4, BigDecimal::from(4i64));
+        same_stable_hash(1u64 << 21, BigDecimal::from(1u64 << 21));
+    }
+
+    #[test]
+    fn big_decimal_stable() {
+        let cases = [
+            (
+                "28b09c9c3f3e2fe037631b7fbccdf65c37594073016d8bf4bb0708b3fda8066a",
+                "0.1",
+            ),
+            (
+                "74fb39f038d2f1c8975740bf2651a5ac0403330ee7e9367f9563cbd7d21086bd",
+                "-0.1",
+            ),
+            (
+                "1d79e0476bc5d6fe6074fb54636b04fd3bc207053c767d9cb5e710ba5f002441",
+                "198.98765544",
+            ),
+            (
+                "e63f6ad2c65f193aa9eba18dd7e1043faa2d6183597ba84c67765aaa95c95351",
+                "0.00000093937698",
+            ),
+            (
+                "6b06b34cc714810072988dc46c493c66a6b6c2c2dd0030271aa3adf3b3f21c20",
+                "98765587998098786876.0",
+            ),
+        ];
+        for (hash, s) in cases.iter() {
+            let dec = BigDecimal::from_str(s).unwrap();
+            assert_eq!(*hash, hex::encode(crypto_stable_hash(dec)));
+        }
+    }
+
+    #[test]
+    fn test_normalize() {
+        let vals = vec![
+            (
+                BigDecimal::new(BigInt::from(10), -2),
+                BigDecimal(OldBigDecimal::new(1.into(), 1)),
+                "0.1",
+            ),
+            (
+                BigDecimal::new(BigInt::from(132400), 4),
+                BigDecimal(OldBigDecimal::new(1324.into(), -6)),
+                "1324000000",
+            ),
+            (
+                BigDecimal::new(BigInt::from(1_900_000), -3),
+                BigDecimal(OldBigDecimal::new(19.into(), -2)),
+                "1900",
+            ),
+            (BigDecimal::new(0.into(), 3), BigDecimal::zero(), "0"),
+            (BigDecimal::new(0.into(), -5), BigDecimal::zero(), "0"),
+        ];
+
+        for (not_normalized, normalized, string) in vals {
+            assert_eq!(not_normalized.normalized(), normalized);
+            assert_eq!(not_normalized.normalized().to_string(), string);
+            assert_eq!(normalized.to_string(), string);
+        }
+    }
+
+    #[test]
+    fn fmt_debug() {
+        let bi = BigInt::from(-17);
+        let bd = BigDecimal::new(bi.clone(), -2);
+        let bytes = Bytes::from([222, 173, 190, 239].as_slice());
+        assert_eq!("BigInt(-17)", format!("{:?}", bi));
+        assert_eq!("BigDecimal(-0.17)", format!("{:?}", bd));
+        assert_eq!("Bytes(0xdeadbeef)", format!("{:?}", bytes));
+    }
+}
diff --git a/graph/src/data/store/scalar/bigint.rs b/graph/src/data/store/scalar/bigint.rs
new file mode 100644
index 00000000000..9ede6e08a4d
--- /dev/null
+++ b/graph/src/data/store/scalar/bigint.rs
@@ -0,0 +1,507 @@
+use alloy::primitives::I256;
+use anyhow::bail;
+use num_bigint;
+use serde::{self, Deserialize, Serialize};
+use stable_hash::StableHash;
+use stable_hash::utils::AsInt;
+use thiserror::Error;
+
+use crate::prelude::alloy::primitives::{U64, U128, U256};
+use std::convert::{TryFrom, TryInto};
+use std::fmt;
+use std::ops::{Add, BitAnd, BitOr, Div, Mul, Rem, Shl, Shr, Sub};
+use std::str::FromStr;
+
+pub use num_bigint::Sign as BigIntSign;
+
+use crate::runtime::gas::{Gas, GasSizeOf, SaturatingInto};
+
+// Use a private module to ensure a constructor is used.
+pub use big_int::BigInt;
+mod big_int {
+    use std::{
+        f32::consts::LOG2_10,
+        fmt::{self, Display, Formatter},
+    };
+
+    #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
+    pub struct BigInt(num_bigint::BigInt);
+
+    impl Display for BigInt {
+        fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+            self.0.fmt(f)
+        }
+    }
+
+    impl BigInt {
+        // Postgres `numeric` has a limit documented here [https://www.postgresql.org/docs/current/datatype-numeric.htm]:
+        // "Up to 131072 digits before the decimal point; up to 16383 digits after the decimal point"
+        // So based on this we adopt a limit of 131072 decimal digits for big int, converted here to bits.
+        pub const MAX_BITS: u32 = (131072.0 * LOG2_10) as u32 + 1; // 435_412
+
+        pub fn new(inner: num_bigint::BigInt) -> Result<Self, anyhow::Error> {
+            // `inner.bits()` won't include the sign bit, so we add 1 to account for it.
+            let bits = inner.bits() + 1;
+            if bits > Self::MAX_BITS as usize {
+                anyhow::bail!(
+                    "BigInt is too big, total bits {} (max {})",
+                    bits,
+                    Self::MAX_BITS
+                );
+            }
+            Ok(Self(inner))
+        }
+
+        /// Creates a BigInt without checking the digit limit.
+        pub(in super::super) fn unchecked_new(inner: num_bigint::BigInt) -> Self {
+            Self(inner)
+        }
+
+        pub fn sign(&self) -> num_bigint::Sign {
+            self.0.sign()
+        }
+
+        pub fn to_bytes_le(&self) -> (super::BigIntSign, Vec<u8>) {
+            self.0.to_bytes_le()
+        }
+
+        pub fn to_bytes_be(&self) -> (super::BigIntSign, Vec<u8>) {
+            self.0.to_bytes_be()
+        }
+
+        pub fn to_signed_bytes_le(&self) -> Vec<u8> {
+            self.0.to_signed_bytes_le()
+        }
+
+        pub fn bits(&self) -> usize {
+            self.0.bits()
+        }
+
+        pub(in super::super) fn inner(self) -> num_bigint::BigInt {
+            self.0
+        }
+    }
+}
+
+impl stable_hash_legacy::StableHash for BigInt {
+    #[inline]
+    fn stable_hash<H: stable_hash_legacy::StableHasher>(
+        &self,
+        sequence_number: H::Seq,
+        state: &mut H,
+    ) {
+        stable_hash_legacy::utils::AsInt {
+            is_negative: self.sign() == BigIntSign::Minus,
+            little_endian: &self.to_bytes_le().1,
+        }
+        .stable_hash(sequence_number, state)
+    }
+}
+
+impl StableHash for BigInt {
+    fn stable_hash<H: stable_hash::StableHasher>(&self, field_address: H::Addr, state: &mut H) {
+        AsInt {
+            is_negative: self.sign() == BigIntSign::Minus,
+            little_endian: &self.to_bytes_le().1,
+        }
+        .stable_hash(field_address, state)
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum BigIntOutOfRangeError {
+    #[error("Cannot convert negative BigInt into type")]
+    Negative,
+    #[error("BigInt value is too large for type")]
+    Overflow,
+}
+
+impl<'a> TryFrom<&'a BigInt> for u64 {
+    type Error = BigIntOutOfRangeError;
+    fn try_from(value: &'a BigInt) -> Result<u64, BigIntOutOfRangeError> {
+        let (sign, bytes) = value.to_bytes_le();
+
+        if sign == num_bigint::Sign::Minus {
+            return Err(BigIntOutOfRangeError::Negative);
+        }
+
+        if bytes.len() > 8 {
+            return Err(BigIntOutOfRangeError::Overflow);
+        }
+
+        // Replace this with u64::from_le_bytes when stabilized
+        let mut n = 0u64;
+        let mut shift_dist = 0;
+        for b in bytes {
+            n |= (b as u64) << shift_dist;
+            shift_dist += 8;
+        }
+        Ok(n)
+    }
+}
+
+impl TryFrom<BigInt> for u64 {
+    type Error = BigIntOutOfRangeError;
+    fn try_from(value: BigInt) -> Result<u64, BigIntOutOfRangeError> {
+        (&value).try_into()
+    }
+}
+
+impl fmt::Debug for BigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "BigInt({})", self)
+    }
+}
+
+impl BigInt {
+    pub fn from_unsigned_bytes_le(bytes: &[u8]) -> Result<Self, anyhow::Error> {
+        BigInt::new(num_bigint::BigInt::from_bytes_le(
+            num_bigint::Sign::Plus,
+            bytes,
+        ))
+    }
+
+    pub fn from_signed_bytes_le(bytes: &[u8]) -> Result<Self, anyhow::Error> {
+        BigInt::new(num_bigint::BigInt::from_signed_bytes_le(bytes))
+    }
+
+    pub fn from_signed_bytes_be(bytes: &[u8]) -> Result<Self, anyhow::Error> {
+        BigInt::new(num_bigint::BigInt::from_signed_bytes_be(bytes))
+    }
+
+    /// Deprecated. Use try_into instead
+    pub fn to_u64(&self) -> u64 {
+        self.try_into().unwrap()
+    }
+
+    pub fn from_unsigned_u128(n: U128) -> Self {
+        let bytes: [u8; U128::BYTES] = n.to_le_bytes();
+        // Unwrap: 128 bits is much less than BigInt::MAX_BITS
+        BigInt::from_unsigned_bytes_le(&bytes).unwrap()
+    }
+
+    pub fn from_unsigned_u256(n: &U256) -> Self {
+        let bytes: [u8; U256::BYTES] = n.to_le_bytes();
+        // Unwrap: 256 bits is much less than BigInt::MAX_BITS
+        BigInt::from_unsigned_bytes_le(&bytes).unwrap()
+    }
+
+    pub fn from_i256(n: &I256) -> Self {
+        let bytes: [u8; I256::BYTES] = n.to_le_bytes();
+        // Unwrap: 256 bits is much less than BigInt::MAX_BITS
+        BigInt::from_signed_bytes_le(&bytes).unwrap()
+    }
+
+    pub fn to_i256(&self) -> Result<I256, anyhow::Error> {
+        let bytes = self.to_signed_bytes_le();
+        anyhow::ensure!(
+            bytes.len() <= I256::BYTES,
+            "BigInt value `{}` does not fit into int256",
+            self
+        );
+        let fill: u8 = if self.sign() == BigIntSign::Minus {
+            0xFF
+        } else {
+            0x00
+        };
+        let mut buf = [fill; I256::BYTES];
+        buf[..bytes.len()].copy_from_slice(&bytes);
+        Ok(I256::from_le_bytes(buf))
+    }
+
+    pub fn to_unsigned_u256(&self) -> Result<U256, anyhow::Error> {
+        let (sign, bytes) = self.to_bytes_le();
+        if sign != BigIntSign::Plus && sign != BigIntSign::NoSign {
+            bail!(
+                "BigInt value is negative, cannot convert to unsigned U256: {}",
+                self
+            );
+        }
+        anyhow::ensure!(
+            bytes.len() <= U256::BYTES,
+            "BigInt value `{}` does not fit into uint256",
+            self
+        );
+        Ok(U256::from_le_slice(&bytes))
+    }
+
+    pub fn pow(self, exponent: u8) -> Result<BigInt, anyhow::Error> {
+        use num_traits::pow::Pow;
+
+        BigInt::new(self.inner().pow(&exponent))
+    }
+}
+
+impl From<i8> for BigInt {
+    fn from(i: i8) -> BigInt {
+        BigInt::unchecked_new(i.into())
+    }
+}
+
+impl From<i16> for BigInt {
+    fn from(i: i16) -> BigInt {
+        BigInt::unchecked_new(i.into())
+    }
+}
+
+impl From<i32> for BigInt {
+    fn from(i: i32) -> BigInt {
+        BigInt::unchecked_new(i.into())
+    }
+}
+
+impl From<i64> for BigInt {
+    fn from(i: i64) -> BigInt {
+        BigInt::unchecked_new(i.into())
+    }
+}
+
+impl From<i128> for BigInt {
+    fn from(i: i128) -> BigInt {
+        BigInt::unchecked_new(i.into())
+    }
+}
+
+impl From<u128> for BigInt {
+    fn from(i: u128) -> BigInt {
+        BigInt::unchecked_new(i.into())
+    }
+}
+
+impl From<u8> for BigInt {
+    fn from(i: u8) -> BigInt {
+        BigInt::unchecked_new(i.into())
+    }
+}
+
+impl From<u16> for BigInt {
+    fn from(i: u16) -> BigInt {
+        BigInt::unchecked_new(i.into())
+    }
+}
+
+impl From<u32> for BigInt {
+    fn from(i: u32) -> BigInt {
+        BigInt::unchecked_new(i.into())
+    }
+}
+
+impl From<u64> for BigInt {
+    fn from(i: u64) -> BigInt {
+        BigInt::unchecked_new(i.into())
+    }
+}
+
+impl From<U64> for BigInt {
+    /// This implementation assumes that U64 represents an unsigned U64,
+    /// and not a signed U64 (aka int64 in Solidity). Right now, this is
+    /// all we need (for block numbers). If it ever becomes necessary to
+    /// handle signed U64s, we should add the same
+    /// `{to,from}_{signed,unsigned}_u64` methods that we have for U64.
+    fn from(n: U64) -> BigInt {
+        BigInt::from(n.to::<u64>())
+    }
+}
+
+impl FromStr for BigInt {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<BigInt, Self::Err> {
+        num_bigint::BigInt::from_str(s)
+            .map_err(anyhow::Error::from)
+            .and_then(BigInt::new)
+    }
+}
+
+impl Serialize for BigInt {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.to_string().serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for BigInt {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        use serde::de::Error;
+
+        let decimal_string = <String>::deserialize(deserializer)?;
+        BigInt::from_str(&decimal_string).map_err(D::Error::custom)
+    }
+}
+
+impl Add for BigInt {
+    type Output = BigInt;
+
+    fn add(self, other: BigInt) -> BigInt {
+        BigInt::unchecked_new(self.inner().add(other.inner()))
+    }
+}
+
+impl Sub for BigInt {
+    type Output = BigInt;
+
+    fn sub(self, other: BigInt) -> BigInt {
+        BigInt::unchecked_new(self.inner().sub(other.inner()))
+    }
+}
+
+impl Mul for BigInt {
+    type Output = BigInt;
+
+    fn mul(self, other: BigInt) -> BigInt {
+        BigInt::unchecked_new(self.inner().mul(other.inner()))
+    }
+}
+
+impl Div for BigInt {
+    type Output = BigInt;
+
+    fn div(self, other: BigInt) -> BigInt {
+        if other == BigInt::from(0) {
+            panic!("Cannot divide by zero-valued `BigInt`!")
+        }
+
+        BigInt::unchecked_new(self.inner().div(other.inner()))
+    }
+}
+
+impl Rem for BigInt {
+    type Output = BigInt;
+
+    fn rem(self, other: BigInt) -> BigInt {
+        BigInt::unchecked_new(self.inner().rem(other.inner()))
+    }
+}
+
+impl BitOr for BigInt {
+    type Output = Self;
+
+    fn bitor(self, other: Self) -> Self {
+        BigInt::unchecked_new(self.inner().bitor(other.inner()))
+    }
+}
+
+impl BitAnd for BigInt {
+    type Output = Self;
+
+    fn bitand(self, other: Self) -> Self {
+        BigInt::unchecked_new(self.inner().bitand(other.inner()))
+    }
+}
+
+impl Shl<u8> for BigInt {
+    type Output = Self;
+
+    fn shl(self, bits: u8) -> Self {
+        BigInt::unchecked_new(self.inner().shl(bits.into()))
+    }
+}
+
+impl Shr<u8> for BigInt {
+    type Output = Self;
+
+    fn shr(self, bits: u8) -> Self {
+        BigInt::unchecked_new(self.inner().shr(bits.into()))
+    }
+}
+
+impl GasSizeOf for BigInt {
+    fn gas_size_of(&self) -> Gas {
+        // Add one to always have an upper bound on the number of bytes required to represent the
+        // number, and so that `0` has a size of 1.
+        let n_bytes = self.bits() / 8 + 1;
+        n_bytes.saturating_into()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use alloy::primitives::U64;
+
+    use super::{super::test::same_stable_hash, BigInt};
+
+    /// Compute 2^n via repeated doubling so we can build values larger than
+    /// `BigInt::pow`'s u8 exponent limit.
+    fn pow2(n: u32) -> BigInt {
+        let mut acc = BigInt::from(1u64);
+        for _ in 0..n {
+            acc = acc * BigInt::from(2u64);
+        }
+        acc
+    }
+
+    #[test]
+    fn to_i256_succeeds_at_boundaries() {
+        let one = BigInt::from(1u64);
+        let i256_max = pow2(255) - one.clone();
+        let i256_min = BigInt::from(0) - pow2(255);
+
+        for v in &[
+            BigInt::from(0),
+            BigInt::from(1),
+            BigInt::from(-1),
+            i256_max.clone(),
+            i256_min.clone(),
+        ] {
+            let i = v.to_i256().expect("in-range value should convert");
+            let back = BigInt::from_i256(&i);
+            assert_eq!(&back, v, "round-trip failed for {}", v);
+        }
+    }
+
+    #[test]
+    fn to_i256_errors_outside_range() {
+        let one = BigInt::from(1u64);
+        let just_above_max = pow2(255);
+        let just_below_min = BigInt::from(0) - pow2(255) - one;
+        let way_above = pow2(300);
+        let way_below = BigInt::from(0) - pow2(300);
+
+        for v in &[just_above_max, just_below_min, way_above, way_below] {
+            assert!(
+                v.to_i256().is_err(),
+                "out-of-range value {} should error, not panic",
+                v
+            );
+        }
+    }
+
+    #[test]
+    fn to_unsigned_u256_errors_outside_range() {
+        let just_above_max = pow2(256);
+        let way_above = pow2(300);
+
+        for v in &[just_above_max, way_above] {
+            assert!(
+                v.to_unsigned_u256().is_err(),
+                "value {} above u256::MAX should error, not panic",
+                v
+            );
+        }
+
+        assert!(
+            BigInt::from(-1).to_unsigned_u256().is_err(),
+            "negative value should error"
+        );
+    }
+
+    #[test]
+    fn bigint_to_from_u64() {
+        for n in 0..100 {
+            let u = U64::from(n);
+            let bn = BigInt::from(u);
+            assert_eq!(n, bn.to_u64());
+        }
+    }
+
+    #[test]
+    fn big_int_stable_hash_same_as_int() {
+        same_stable_hash(0, BigInt::from(0u64));
+        same_stable_hash(1, BigInt::from(1u64));
+        same_stable_hash(1u64 << 20, BigInt::from(1u64 << 20));
+
+        same_stable_hash(
+            -1,
+            BigInt::from_signed_bytes_le(&(-1i32).to_le_bytes()).unwrap(),
+        );
+    }
+}
diff --git a/graph/src/data/store/scalar/bytes.rs b/graph/src/data/store/scalar/bytes.rs
new file mode 100644
index 00000000000..62a50d3cb49
--- /dev/null
+++ b/graph/src/data/store/scalar/bytes.rs
@@ -0,0 +1,125 @@
+use alloy::primitives::Address;
+use diesel::deserialize::FromSql;
+use diesel::pg::PgValue;
+use diesel::serialize::ToSql;
+use hex;
+use serde::{self, Deserialize, Serialize};
+
+use std::fmt::{self, Display, Formatter};
+use std::ops::Deref;
+use std::str::FromStr;
+
+use crate::blockchain::BlockHash;
+use crate::derive::CacheWeight;
+use crate::util::stable_hash_glue::{AsBytes, impl_stable_hash};
+
+/// A byte array that's serialized as a hex string prefixed by `0x`.
+#[derive(Clone, CacheWeight, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Bytes(Box<[u8]>);
+
+impl Deref for Bytes {
+    type Target = [u8];
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl fmt::Debug for Bytes {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "Bytes(0x{})", hex::encode(&self.0))
+    }
+}
+
+impl_stable_hash!(Bytes(transparent: AsBytes));
+
+impl Bytes {
+    pub fn as_slice(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl Display for Bytes {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+        write!(f, "0x{}", hex::encode(&self.0))
+    }
+}
+
+impl FromStr for Bytes {
+    type Err = hex::FromHexError;
+
+    fn from_str(s: &str) -> Result<Bytes, Self::Err> {
+        hex::decode(s.trim_start_matches("0x")).map(|x| Bytes(x.into()))
+    }
+}
+
+impl From<&[u8]> for Bytes {
+    fn from(array: &[u8]) -> Self {
+        Bytes(array.into())
+    }
+}
+
+impl From<Address> for Bytes {
+    fn from(address: Address) -> Bytes {
+        Bytes::from(address.as_ref())
+    }
+}
+
+impl From<BlockHash> for Bytes {
+    fn from(hash: BlockHash) -> Self {
+        Bytes(hash.0)
+    }
+}
+
+impl Serialize for Bytes {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.to_string().serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for Bytes {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        use serde::de::Error;
+
+        let hex_string = <String>::deserialize(deserializer)?;
+        Bytes::from_str(&hex_string).map_err(D::Error::custom)
+    }
+}
+
+impl<const N: usize> From<[u8; N]> for Bytes {
+    fn from(array: [u8; N]) -> Bytes {
+        Bytes(array.into())
+    }
+}
+
+impl From<Vec<u8>> for Bytes {
+    fn from(vec: Vec<u8>) -> Self {
+        Bytes(vec.into())
+    }
+}
+
+impl AsRef<[u8]> for Bytes {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl ToSql<diesel::sql_types::Binary, diesel::pg::Pg> for Bytes {
+    fn to_sql<'b>(
+        &'b self,
+        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,
+    ) -> diesel::serialize::Result {
+        <_ as ToSql<diesel::sql_types::Binary, _>>::to_sql(self.as_slice(), &mut out.reborrow())
+    }
+}
+
+impl FromSql<diesel::sql_types::Binary, diesel::pg::Pg> for Bytes {
+    fn from_sql(value: PgValue) -> diesel::deserialize::Result<Self> {
+        <Vec<u8> as FromSql<diesel::sql_types::Binary, _>>::from_sql(value).map(Bytes::from)
+    }
+}
+
+impl From<alloy::primitives::Bytes> for Bytes {
+    fn from(bytes: alloy::primitives::Bytes) -> Bytes {
+        Bytes::from(bytes.as_ref())
+    }
+}
diff --git a/graph/src/data/store/scalar/mod.rs b/graph/src/data/store/scalar/mod.rs
new file mode 100644
index 00000000000..bc10c1b1c71
--- /dev/null
+++ b/graph/src/data/store/scalar/mod.rs
@@ -0,0 +1,28 @@
+mod bigdecimal;
+mod bigint;
+mod bytes;
+mod timestamp;
+
+pub use bigdecimal::BigDecimal;
+pub use bigint::{BigInt, BigIntSign};
+pub use bytes::Bytes;
+pub use old_bigdecimal::ToPrimitive;
+pub use timestamp::Timestamp;
+
+// Test helpers for BigInt and BigDecimal tests
+#[cfg(test)]
+mod test {
+    use stable_hash_legacy::crypto::SetHasher;
+    use stable_hash_legacy::prelude::*;
+    use stable_hash_legacy::utils::stable_hash;
+
+    pub(super) fn crypto_stable_hash(value: impl StableHash) -> <SetHasher as StableHasher>::Out {
+        stable_hash::<SetHasher, _>(&value)
+    }
+
+    pub(super) fn same_stable_hash(left: impl StableHash, right: impl StableHash) {
+        let left = crypto_stable_hash(left);
+        let right = crypto_stable_hash(right);
+        assert_eq!(left, right);
+    }
+}
diff --git a/graph/src/data/store/scalar/timestamp.rs b/graph/src/data/store/scalar/timestamp.rs
new file mode 100644
index 00000000000..1d9026d5a72
--- /dev/null
+++ b/graph/src/data/store/scalar/timestamp.rs
@@ -0,0 +1,125 @@
+use chrono::{DateTime, Utc};
+use diesel::deserialize::FromSql;
+use diesel::pg::PgValue;
+use diesel::serialize::ToSql;
+use diesel::sql_types::Timestamptz;
+use serde::{self, Deserialize, Serialize};
+use stable_hash::StableHash;
+
+use std::fmt::{self, Display, Formatter};
+use std::num::ParseIntError;
+
+use crate::derive::CacheWeight;
+use crate::runtime::gas::{Gas, GasSizeOf, SaturatingInto};
+
+#[derive(
+    Clone, Copy, CacheWeight, Debug, Deserialize, Serialize, PartialEq, Eq, Hash, PartialOrd, Ord,
+)]
+pub struct Timestamp(pub DateTime<Utc>);
+
+#[derive(thiserror::Error, Debug)]
+pub enum TimestampError {
+    #[error("Invalid timestamp string: {0}")]
+    StringParseError(ParseIntError),
+    #[error("Invalid timestamp format")]
+    InvalidTimestamp,
+}
+
+impl Timestamp {
+    /// A timestamp from a long long time ago used to indicate that we don't
+    /// have a timestamp
+    pub const NONE: Self = Self(DateTime::<Utc>::MIN_UTC);
+
+    pub const MAX: Self = Self(DateTime::<Utc>::MAX_UTC);
+
+    pub const MIN: Self = Self(DateTime::<Utc>::MIN_UTC);
+
+    pub fn parse_timestamp(v: &str) -> Result<Self, TimestampError> {
+        let as_num: i64 = v.parse().map_err(TimestampError::StringParseError)?;
+        Timestamp::from_microseconds_since_epoch(as_num)
+    }
+
+    pub fn from_rfc3339(v: &str) -> Result<Self, chrono::ParseError> {
+        Ok(Timestamp(DateTime::parse_from_rfc3339(v)?.into()))
+    }
+
+    pub fn from_microseconds_since_epoch(micros: i64) -> Result<Self, TimestampError> {
+        let secs = micros / 1_000_000;
+        let ns = (micros % 1_000_000) * 1_000;
+
+        match DateTime::from_timestamp(secs, ns as u32) {
+            Some(dt) => Ok(Self(dt)),
+            None => Err(TimestampError::InvalidTimestamp),
+        }
+    }
+
+    pub fn as_microseconds_since_epoch(&self) -> i64 {
+        self.0.timestamp_micros()
+    }
+
+    pub fn since_epoch(secs: i64, nanos: u32) -> Option<Self> {
+        DateTime::from_timestamp(secs, nanos).map(Timestamp)
+    }
+
+    pub fn as_secs_since_epoch(&self) -> i64 {
+        self.0.timestamp()
+    }
+
+    pub(crate) fn timestamp_millis(&self) -> i64 {
+        self.0.timestamp_millis()
+    }
+}
+
+impl StableHash for Timestamp {
+    fn stable_hash<H: stable_hash::StableHasher>(&self, field_address: H::Addr, state: &mut H) {
+        self.0.timestamp_micros().stable_hash(field_address, state)
+    }
+}
+
+impl stable_hash_legacy::StableHash for Timestamp {
+    fn stable_hash<H: stable_hash_legacy::StableHasher>(
+        &self,
+        sequence_number: H::Seq,
+        state: &mut H,
+    ) {
+        stable_hash_legacy::StableHash::stable_hash(
+            &self.0.timestamp_micros(),
+            sequence_number,
+            state,
+        )
+    }
+}
+
+impl From<DateTime<Utc>> for Timestamp {
+    fn from(value: DateTime<Utc>) -> Self {
+        Self(value)
+    }
+}
+
+impl Display for Timestamp {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+        write!(f, "{}", self.as_microseconds_since_epoch())
+    }
+}
+
+impl ToSql<Timestamptz, diesel::pg::Pg> for Timestamp {
+    fn to_sql<'b>(
+        &'b self,
+        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,
+    ) -> diesel::serialize::Result {
+        <_ as ToSql<Timestamptz, _>>::to_sql(&self.0, &mut out.reborrow())
+    }
+}
+
+impl GasSizeOf for Timestamp {
+    fn const_gas_size_of() -> Option<Gas> {
+        Some(Gas::new(std::mem::size_of::<Timestamp>().saturating_into()))
+    }
+}
+
+impl FromSql<diesel::sql_types::Timestamptz, diesel::pg::Pg> for Timestamp {
+    fn from_sql(value: PgValue) -> diesel::deserialize::Result<Self> {
+        <DateTime<Utc> as FromSql<diesel::sql_types::Timestamptz, _>>::from_sql(value)
+            .map(Timestamp)
+    }
+}
diff --git a/graph/src/data/store/sql.rs b/graph/src/data/store/sql.rs
index 9fb84bacef9..7124927ee74 100644
--- a/graph/src/data/store/sql.rs
+++ b/graph/src/data/store/sql.rs
@@ -1,17 +1,16 @@
 use anyhow::anyhow;
 use diesel::pg::Pg;
 use diesel::serialize::{self, Output, ToSql};
-use diesel::sql_types::{Binary, Bool, Int8, Integer, Text};
+use diesel::sql_types::{Binary, Bool, Int8, Integer, Text, Timestamptz};
 
-use std::io::Write;
 use std::str::FromStr;
 
-use super::{scalar, Value};
+use super::{Value, scalar};
 
 impl ToSql<Bool, Pg> for Value {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
         match self {
-            Value::Bool(b) => <bool as ToSql<Bool, Pg>>::to_sql(b, out),
+            Value::Bool(b) => <bool as ToSql<Bool, Pg>>::to_sql(b, &mut out.reborrow()),
             v => Err(anyhow!(
                 "Failed to convert non-boolean attribute value to boolean in SQL: {}",
                 v
@@ -22,9 +21,9 @@ impl ToSql<Bool, Pg> for Value {
 }
 
 impl ToSql<Integer, Pg> for Value {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
         match self {
-            Value::Int(i) => <i32 as ToSql<Integer, Pg>>::to_sql(i, out),
+            Value::Int(i) => <i32 as ToSql<Integer, Pg>>::to_sql(i, &mut out.reborrow()),
             v => Err(anyhow!(
                 "Failed to convert non-int attribute value to int in SQL: {}",
                 v
@@ -35,10 +34,10 @@ impl ToSql<Integer, Pg> for Value {
 }
 
 impl ToSql<Int8, Pg> for Value {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
         match self {
-            Value::Int8(i) => <i64 as ToSql<Int8, Pg>>::to_sql(i, out),
-            Value::Int(i) => <i64 as ToSql<Int8, Pg>>::to_sql(&(*i as i64), out),
+            Value::Int8(i) => <i64 as ToSql<Int8, Pg>>::to_sql(i, &mut out.reborrow()),
+            Value::Int(i) => <i64 as ToSql<Int8, Pg>>::to_sql(&(*i as i64), &mut out.reborrow()),
             v => Err(anyhow!(
                 "Failed to convert non-int8 attribute value to int8 in SQL: {}",
                 v
@@ -48,11 +47,26 @@ impl ToSql<Int8, Pg> for Value {
     }
 }
 
+impl ToSql<Timestamptz, Pg> for Value {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
+        match self {
+            Value::Timestamp(i) => i.to_sql(&mut out.reborrow()),
+            v => Err(anyhow!(
+                "Failed to convert non-timestamp attribute value to timestamp in SQL: {}",
+                v
+            )
+            .into()),
+        }
+    }
+}
+
 impl ToSql<Text, Pg> for Value {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
         match self {
-            Value::String(s) => <String as ToSql<Text, Pg>>::to_sql(s, out),
-            Value::Bytes(h) => <String as ToSql<Text, Pg>>::to_sql(&h.to_string(), out),
+            Value::String(s) => <String as ToSql<Text, Pg>>::to_sql(s, &mut out.reborrow()),
+            Value::Bytes(h) => {
+                <String as ToSql<Text, Pg>>::to_sql(&h.to_string(), &mut out.reborrow())
+            }
             v => Err(anyhow!(
                 "Failed to convert attribute value to String or Bytes in SQL: {}",
                 v
@@ -63,12 +77,13 @@ impl ToSql<Text, Pg> for Value {
 }
 
 impl ToSql<Binary, Pg> for Value {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
         match self {
-            Value::Bytes(h) => <_ as ToSql<Binary, Pg>>::to_sql(&h.as_slice(), out),
-            Value::String(s) => {
-                <_ as ToSql<Binary, Pg>>::to_sql(scalar::Bytes::from_str(s)?.as_slice(), out)
-            }
+            Value::Bytes(h) => <_ as ToSql<Binary, Pg>>::to_sql(&h.as_slice(), &mut out.reborrow()),
+            Value::String(s) => <_ as ToSql<Binary, Pg>>::to_sql(
+                scalar::Bytes::from_str(s)?.as_slice(),
+                &mut out.reborrow(),
+            ),
             v => Err(anyhow!("Failed to convert attribute value to Bytes in SQL: {}", v).into()),
         }
     }
diff --git a/graph/src/data/subgraph/api_version.rs b/graph/src/data/subgraph/api_version.rs
index fc661598cd1..f0e7a213af2 100644
--- a/graph/src/data/subgraph/api_version.rs
+++ b/graph/src/data/subgraph/api_version.rs
@@ -5,6 +5,9 @@ use thiserror::Error;
 
 pub const API_VERSION_0_0_2: Version = Version::new(0, 0, 2);
 
+/// Changed calling convention for `ethereum.call`
+pub const API_VERSION_0_0_4: Version = Version::new(0, 0, 4);
+
 /// This version adds a new subgraph validation step that rejects manifests whose mappings have
 /// different API versions if at least one of them is equal to or higher than `0.0.5`.
 pub const API_VERSION_0_0_5: Version = Version::new(0, 0, 5);
@@ -18,6 +21,12 @@ pub const API_VERSION_0_0_7: Version = Version::new(0, 0, 7);
 /// Enables validation for fields that doesnt exist in the schema for an entity.
 pub const API_VERSION_0_0_8: Version = Version::new(0, 0, 8);
 
+/// Enables new host function `eth_get_balance`
+pub const API_VERSION_0_0_9: Version = Version::new(0, 0, 9);
+
+/// Enables new host function `ethereum.decodeParams`
+pub const API_VERSION_0_0_10: Version = Version::new(0, 0, 10);
+
 /// Before this check was introduced, there were already subgraphs in the wild with spec version
 /// 0.0.3, due to confusion with the api version. To avoid breaking those, we accept 0.0.3 though it
 /// doesn't exist.
@@ -48,8 +57,23 @@ pub const SPEC_VERSION_1_0_0: Version = Version::new(1, 0, 0);
 // Enables `id: Int8`
 pub const SPEC_VERSION_1_1_0: Version = Version::new(1, 1, 0);
 
+// Enables eth call declarations and indexed arguments(topics) filtering in manifest
+pub const SPEC_VERSION_1_2_0: Version = Version::new(1, 2, 0);
+
+// Enables subgraphs as datasource.
+// Changes the way the VID field is generated. It used to be autoincrement. Now its
+// based on block number and the order of the entities in a block. The latter
+// represents the write order across all entity types in the subgraph.
+pub const SPEC_VERSION_1_3_0: Version = Version::new(1, 3, 0);
+
+// Enables struct field access in declarative calls
+pub const SPEC_VERSION_1_4_0: Version = Version::new(1, 4, 0);
+
+// Enables support for Amp data sources;
+pub const SPEC_VERSION_1_5_0: Version = Version::new(1, 5, 0);
+
 // The latest spec version available
-pub const LATEST_VERSION: &Version = &SPEC_VERSION_1_1_0;
+pub const LATEST_VERSION: &Version = &SPEC_VERSION_1_5_0;
 
 pub const MIN_SPEC_VERSION: Version = Version::new(0, 0, 2);
 
@@ -71,15 +95,26 @@ impl UnifiedMappingApiVersion {
     pub(super) fn try_from_versions(
         versions: impl Iterator<Item = Version>,
     ) -> Result<Self, DifferentMappingApiVersions> {
-        let unique_versions: BTreeSet<Version> = versions.collect();
+        use super::SubgraphManifestValidationError;
+        use super::manifest_validation::validate_api_versions;
+
+        let versions_vec: Vec<Version> = versions.collect();
+
+        // Use shared validation logic
+        if let Err(SubgraphManifestValidationError::DifferentApiVersions(e)) =
+            validate_api_versions(&versions_vec)
+        {
+            return Err(e);
+        }
 
+        // Extract the unified version
+        let unique_versions: BTreeSet<Version> = versions_vec.into_iter().collect();
         let all_below_referential_version = unique_versions.iter().all(|v| *v < API_VERSION_0_0_5);
-        let all_the_same = unique_versions.len() == 1;
 
-        let unified_version: Option<Version> = match (all_below_referential_version, all_the_same) {
-            (false, false) => return Err(DifferentMappingApiVersions(unique_versions)),
-            (false, true) => Some(unique_versions.iter().next().unwrap().clone()),
-            (true, _) => None,
+        let unified_version: Option<Version> = if all_below_referential_version {
+            None
+        } else {
+            unique_versions.into_iter().next()
         };
 
         Ok(UnifiedMappingApiVersion(unified_version))
diff --git a/graph/src/data/subgraph/features.rs b/graph/src/data/subgraph/features.rs
index da6b00d1ce6..dd2263858f9 100644
--- a/graph/src/data/subgraph/features.rs
+++ b/graph/src/data/subgraph/features.rs
@@ -33,6 +33,10 @@ pub enum SubgraphFeature {
     NonFatalErrors,
     Grafting,
     FullTextSearch,
+    Aggregations,
+    BytesAsIds,
+    DeclaredEthCalls,
+    ImmutableEntities,
     #[serde(alias = "nonDeterministicIpfs")]
     IpfsOnEthereumContracts,
 }
@@ -154,11 +158,15 @@ mod tests {
         FullTextSearch,
         IpfsOnEthereumContracts,
     ];
-    const STRING: [&str; 4] = [
+    const STRING: [&str; 8] = [
         "nonFatalErrors",
         "grafting",
         "fullTextSearch",
         "ipfsOnEthereumContracts",
+        "declaredEthCalls",
+        "aggregations",
+        "immutableEntities",
+        "bytesAsIds",
     ];
 
     #[test]
diff --git a/graph/src/data/subgraph/manifest_validation.rs b/graph/src/data/subgraph/manifest_validation.rs
new file mode 100644
index 00000000000..d2ed1eb8414
--- /dev/null
+++ b/graph/src/data/subgraph/manifest_validation.rs
@@ -0,0 +1,125 @@
+//! Pure manifest validation functions.
+//!
+//! This module provides pure validation functions that can be used by both
+//! graph-node and external tools (like gnd) without requiring database access
+//! or other heavy dependencies.
+
+use semver::Version;
+use std::collections::BTreeSet;
+
+use super::api_version::API_VERSION_0_0_5;
+use super::{DifferentMappingApiVersions, SubgraphManifestValidationError};
+
+/// Validate that the manifest has at least one data source.
+pub fn validate_has_data_sources(count: usize) -> Result<(), SubgraphManifestValidationError> {
+    if count == 0 {
+        Err(SubgraphManifestValidationError::NoDataSources)
+    } else {
+        Ok(())
+    }
+}
+
+/// Validate that all data sources use the same network.
+///
+/// Returns Ok(()) if:
+/// - All data sources use the same network, or
+/// - No data sources specify a network (for non-chain data sources)
+///
+/// Returns an error if data sources use different networks.
+pub fn validate_single_network(
+    networks: &[Option<&str>],
+) -> Result<(), SubgraphManifestValidationError> {
+    let unique_networks: BTreeSet<&str> = networks.iter().filter_map(|n| *n).collect();
+
+    match unique_networks.len() {
+        0 => Err(SubgraphManifestValidationError::EthereumNetworkRequired),
+        1 => Ok(()),
+        _ => Err(SubgraphManifestValidationError::MultipleEthereumNetworks),
+    }
+}
+
+/// Validate that all data sources use the same API version when any version >= 0.0.5.
+///
+/// For API versions < 0.0.5, different versions are allowed.
+/// For API versions >= 0.0.5, all data sources must use the same version.
+pub fn validate_api_versions(versions: &[Version]) -> Result<(), SubgraphManifestValidationError> {
+    let unique_versions: BTreeSet<Version> = versions.iter().cloned().collect();
+
+    let all_below_005 = unique_versions.iter().all(|v| *v < API_VERSION_0_0_5);
+    let all_the_same = unique_versions.len() <= 1;
+
+    if all_below_005 || all_the_same {
+        Ok(())
+    } else {
+        Err(SubgraphManifestValidationError::DifferentApiVersions(
+            DifferentMappingApiVersions(unique_versions),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_has_data_sources() {
+        assert!(validate_has_data_sources(0).is_err());
+        assert!(validate_has_data_sources(1).is_ok());
+        assert!(validate_has_data_sources(5).is_ok());
+    }
+
+    #[test]
+    fn test_validate_single_network() {
+        // All same network - ok
+        assert!(validate_single_network(&[Some("mainnet"), Some("mainnet")]).is_ok());
+
+        // Single network - ok
+        assert!(validate_single_network(&[Some("mainnet")]).is_ok());
+
+        // No network specified - error
+        assert!(matches!(
+            validate_single_network(&[]),
+            Err(SubgraphManifestValidationError::EthereumNetworkRequired)
+        ));
+
+        // All None - error (no network)
+        assert!(matches!(
+            validate_single_network(&[None, None]),
+            Err(SubgraphManifestValidationError::EthereumNetworkRequired)
+        ));
+
+        // Different networks - error
+        let result = validate_single_network(&[Some("mainnet"), Some("ropsten")]);
+        assert!(matches!(
+            result,
+            Err(SubgraphManifestValidationError::MultipleEthereumNetworks)
+        ));
+
+        // Mixed with None - ok if all specified networks are the same
+        assert!(validate_single_network(&[Some("mainnet"), None, Some("mainnet")]).is_ok());
+    }
+
+    #[test]
+    fn test_validate_api_versions() {
+        // All same version >= 0.0.5 - ok
+        assert!(validate_api_versions(&[Version::new(0, 0, 5), Version::new(0, 0, 5)]).is_ok());
+
+        // All same version >= 0.0.6 - ok
+        assert!(validate_api_versions(&[Version::new(0, 0, 6), Version::new(0, 0, 6)]).is_ok());
+
+        // All below 0.0.5 - ok (even if different)
+        assert!(validate_api_versions(&[Version::new(0, 0, 3), Version::new(0, 0, 4)]).is_ok());
+
+        // Mixed with version >= 0.0.5 and different - error
+        assert!(validate_api_versions(&[Version::new(0, 0, 3), Version::new(0, 0, 5)]).is_err());
+
+        // Different versions both >= 0.0.5 - error
+        assert!(validate_api_versions(&[Version::new(0, 0, 5), Version::new(0, 0, 6)]).is_err());
+
+        // Empty - ok
+        assert!(validate_api_versions(&[]).is_ok());
+
+        // Single version - ok
+        assert!(validate_api_versions(&[Version::new(0, 0, 5)]).is_ok());
+    }
+}
diff --git a/graph/src/data/subgraph/mod.rs b/graph/src/data/subgraph/mod.rs
index 6d90de519a3..0c20405cdf1 100644
--- a/graph/src/data/subgraph/mod.rs
+++ b/graph/src/data/subgraph/mod.rs
@@ -3,16 +3,20 @@ pub mod schema;
 
 /// API version and spec version.
 pub mod api_version;
+use alloy::primitives::Address;
 pub use api_version::*;
 
+/// Pure manifest validation functions for use by external tools.
+pub mod manifest_validation;
+
 pub mod features;
 pub mod status;
 
 pub use features::{SubgraphFeature, SubgraphFeatureValidationError};
 
-use crate::{components::store::BLOCK_NUMBER_MAX, object};
-use anyhow::{anyhow, Context, Error};
-use futures03::{future::try_join, stream::FuturesOrdered, TryStreamExt as _};
+use crate::{cheap_clone::CheapClone, components::store::BLOCK_NUMBER_MAX, object};
+use anyhow::{Context, Error, anyhow};
+use futures03::future::try_join_all;
 use itertools::Itertools;
 use semver::Version;
 use serde::{
@@ -29,13 +33,12 @@ use std::{
 };
 use thiserror::Error;
 use wasmparser;
-use web3::types::Address;
 
 use crate::{
-    bail,
-    blockchain::{BlockPtr, Blockchain, DataSource as _},
+    amp, bail,
+    blockchain::{BlockPtr, Blockchain},
     components::{
-        link_resolver::LinkResolver,
+        link_resolver::{LinkResolver, LinkResolverContext},
         store::{StoreError, SubgraphStore},
     },
     data::{
@@ -43,15 +46,16 @@ use crate::{
         subgraph::features::validate_subgraph_features,
     },
     data_source::{
-        offchain::OFFCHAIN_KINDS, DataSource, DataSourceTemplate, UnresolvedDataSource,
-        UnresolvedDataSourceTemplate,
+        DataSource, DataSourceTemplate, UnresolvedDataSource, UnresolvedDataSourceTemplate,
+        offchain::OFFCHAIN_KINDS,
     },
+    derive::CacheWeight,
     ensure,
-    prelude::{r, CheapClone, Value, ENV_VARS},
+    prelude::{ENV_VARS, Value, r},
     schema::{InputSchema, SchemaValidationError},
 };
 
-use crate::prelude::{impl_slog_value, BlockNumber, Deserialize, Serialize};
+use crate::prelude::{BlockNumber, Deserialize, Serialize, impl_slog_value};
 
 use std::fmt;
 use std::ops::Deref;
@@ -76,9 +80,15 @@ where
 
 /// The IPFS hash used to identifiy a deployment externally, i.e., the
 /// `Qm..` string that `graph-cli` prints when deploying to a subgraph
-#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
+#[derive(Clone, CacheWeight, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
 pub struct DeploymentHash(String);
 
+impl CheapClone for DeploymentHash {
+    fn cheap_clone(&self) -> Self {
+        self.clone()
+    }
+}
+
 impl stable_hash_legacy::StableHash for DeploymentHash {
     #[inline]
     fn stable_hash<H: stable_hash_legacy::StableHasher>(
@@ -100,9 +110,6 @@ impl StableHash for DeploymentHash {
 
 impl_slog_value!(DeploymentHash);
 
-/// `DeploymentHash` is fixed-length so cheap to clone.
-impl CheapClone for DeploymentHash {}
-
 impl DeploymentHash {
     /// Check that `s` is a valid `SubgraphDeploymentId` and create a new one.
     /// If `s` is longer than 46 characters, or contains characters other than
@@ -110,20 +117,23 @@ impl DeploymentHash {
     pub fn new(s: impl Into<String>) -> Result<Self, String> {
         let s = s.into();
 
-        // Enforce length limit
-        if s.len() > 46 {
-            return Err(s);
-        }
+        // When the disable_deployment_hash_validation flag is set, we skip the validation
+        if !ENV_VARS.disable_deployment_hash_validation {
+            // Enforce length limit
+            if s.len() > 46 {
+                return Err(s);
+            }
 
-        // Check that the ID contains only allowed characters.
-        if !s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
-            return Err(s);
-        }
+            // Check that the ID contains only allowed characters.
+            if !s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
+                return Err(s);
+            }
 
-        // Allow only deployment id's for 'real' subgraphs, not the old
-        // metadata subgraph.
-        if s == "subgraphs" {
-            return Err(s);
+            // Allow only deployment id's for 'real' subgraphs, not the old
+            // metadata subgraph.
+            if s == "subgraphs" {
+                return Err(s);
+            }
         }
 
         Ok(DeploymentHash(s))
@@ -134,6 +144,10 @@ impl DeploymentHash {
             link: format!("/ipfs/{}", self),
         }
     }
+
+    pub fn to_bytes(&self) -> Vec<u8> {
+        self.0.as_bytes().to_vec()
+    }
 }
 
 impl Deref for DeploymentHash {
@@ -181,7 +195,14 @@ impl TryFromValue for DeploymentHash {
 pub struct SubgraphName(String);
 
 impl SubgraphName {
-    pub fn new(s: impl Into<String>) -> Result<Self, ()> {
+    /// Construct a new `SubgraphName`, validating the name according to the rules:
+    /// - Length between 1 and 255 characters
+    /// - Contains only alphanumeric characters, dashes (`-`), underscores (`_`), and slashes (`/`)
+    /// - Each part (separated by `/`) must be non-empty, start and end with an alphanumeric character,
+    ///   contain at least one alphabetic character, and not be equal to "graphql"
+    ///
+    /// If the name is invalid, return s (as a `String`) as the error
+    pub fn new(s: impl Into<String>) -> Result<Self, String> {
         let s = s.into();
 
         // Note: these validation rules must be kept consistent with the validation rules
@@ -189,7 +210,7 @@ impl SubgraphName {
 
         // Enforce length limits
         if s.is_empty() || s.len() > 255 {
-            return Err(());
+            return Err(s);
         }
 
         // Check that the name contains only allowed characters.
@@ -197,19 +218,19 @@ impl SubgraphName {
             .chars()
             .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_' || c == '/')
         {
-            return Err(());
+            return Err(s);
         }
 
         // Parse into components and validate each
         for part in s.split('/') {
             // Each part must be non-empty
             if part.is_empty() {
-                return Err(());
+                return Err(s);
             }
 
             // To keep URLs unambiguous, reserve the token "graphql"
             if part == "graphql" {
-                return Err(());
+                return Err(s);
             }
 
             // Part should not start or end with a special character.
@@ -219,7 +240,7 @@ impl SubgraphName {
                 || !last_char.is_ascii_alphanumeric()
                 || !part.chars().any(|c| c.is_ascii_alphabetic())
             {
-                return Err(());
+                return Err(s);
             }
         }
 
@@ -259,7 +280,7 @@ impl<'de> de::Deserialize<'de> for SubgraphName {
     {
         let s: String = de::Deserialize::deserialize(deserializer)?;
         SubgraphName::new(s.clone())
-            .map_err(|()| de::Error::invalid_value(de::Unexpected::Str(&s), &"valid subgraph name"))
+            .map_err(|s| de::Error::invalid_value(de::Unexpected::Str(&s), &"valid subgraph name"))
     }
 }
 
@@ -338,7 +359,7 @@ pub enum SubgraphManifestValidationError {
     MultipleEthereumNetworks,
     #[error("subgraph must have at least one Ethereum network data source")]
     EthereumNetworkRequired,
-    #[error("the specified block must exist on the Ethereum network")]
+    #[error("the specified block {0} must exist on the Ethereum network")]
     BlockNotFound(String),
     #[error("schema validation failed: {0:?}")]
     SchemaValidationError(Vec<SchemaValidationError>),
@@ -350,6 +371,8 @@ pub enum SubgraphManifestValidationError {
     FeatureValidationError(#[from] SubgraphFeatureValidationError),
     #[error("data source {0} is invalid: {1}")]
     DataSourceValidation(String, Error),
+    #[error("failed to validate Amp subgraph: {0:#}")]
+    Amp(#[source] Error),
 }
 
 #[derive(Error, Debug)]
@@ -360,13 +383,19 @@ pub enum SubgraphManifestResolveError {
     NonUtf8,
     #[error("subgraph is not valid YAML")]
     InvalidFormat,
-    #[error("resolve error: {0}")]
+    #[error("resolve error: {0:#}")]
     ResolveError(#[from] anyhow::Error),
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct DataSourceContext(HashMap<Word, Value>);
 
+impl Default for DataSourceContext {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl DataSourceContext {
     pub fn new() -> Self {
         Self(HashMap::new())
@@ -387,12 +416,65 @@ impl From<HashMap<Word, Value>> for DataSourceContext {
 }
 
 /// IPLD link.
-#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
+#[derive(Clone, Debug, Default, Hash, Eq, PartialEq)]
 pub struct Link {
-    #[serde(rename = "/")]
     pub link: String,
 }
 
+/// Custom deserializer for Link
+/// This handles both formats:
+/// 1. Simple string: "schema.graphql" or "subgraph.yaml" which is used in [`FileLinkResolver`]
+///    FileLinkResolver is used in local development environments
+/// 2. IPLD format: { "/": "Qm..." } which is used in [`IpfsLinkResolver`]
+impl<'de> de::Deserialize<'de> for Link {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        struct LinkVisitor;
+
+        impl<'de> de::Visitor<'de> for LinkVisitor {
+            type Value = Link;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("string or map with '/' key")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Link, E>
+            where
+                E: de::Error,
+            {
+                Ok(Link {
+                    link: value.to_string(),
+                })
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Link, A::Error>
+            where
+                A: de::MapAccess<'de>,
+            {
+                let mut link = None;
+
+                while let Some(key) = map.next_key::<String>()? {
+                    if key == "/" {
+                        if link.is_some() {
+                            return Err(de::Error::duplicate_field("/"));
+                        }
+                        link = Some(map.next_value()?);
+                    } else {
+                        return Err(de::Error::unknown_field(&key, &["/"]));
+                    }
+                }
+
+                link.map(|l: String| Link { link: l })
+                    .ok_or_else(|| de::Error::missing_field("/"))
+            }
+        }
+
+        deserializer.deserialize_any(LinkVisitor)
+    }
+}
+
 impl<S: ToString> From<S> for Link {
     fn from(s: S) -> Self {
         Self {
@@ -409,13 +491,17 @@ pub struct UnresolvedSchema {
 impl UnresolvedSchema {
     pub async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         spec_version: &Version,
         id: DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         logger: &Logger,
     ) -> Result<InputSchema, anyhow::Error> {
         let schema_bytes = resolver
-            .cat(logger, &self.file)
+            .cat(
+                &LinkResolverContext::new(deployment_hash, logger),
+                &self.file,
+            )
             .await
             .with_context(|| format!("failed to resolve schema {}", &self.file.link))?;
         InputSchema::parse(spec_version, &String::from_utf8(schema_bytes)?, id)
@@ -443,7 +529,7 @@ pub fn calls_host_fn(runtime: &[u8], host_fn: &str) -> anyhow::Result<bool> {
         if let Payload::ImportSection(s) = payload? {
             for import in s {
                 let import = import?;
-                if import.field == Some(host_fn) {
+                if import.name == host_fn {
                     return Ok(true);
                 }
             }
@@ -491,6 +577,18 @@ impl Graft {
                 "failed to graft onto `{}` at block {} since it has only processed block {}",
                 self.base, self.block, ptr.number
             ))),
+            // The graft point must be at least `reorg_threshold` blocks
+            // behind the subgraph head so that a reorg can not affect the
+            // data that we copy for grafting
+            (Some(ptr), true) if self.block + ENV_VARS.reorg_threshold() > ptr.number => {
+                Err(GraftBaseInvalid(format!(
+                    "failed to graft onto `{}` at block {} since it's only at block {} which is within the reorg threshold of {} blocks",
+                    self.base,
+                    self.block,
+                    ptr.number,
+                    ENV_VARS.reorg_threshold()
+                )))
+            }
             // If the base deployment is failed *and* the `graft.block` is not
             // less than the `base.block`, the graft shouldn't be permitted.
             //
@@ -498,9 +596,28 @@ impl Graft {
             // to `base.block - 1` or less.
             (Some(ptr), false) if self.block >= ptr.number => Err(GraftBaseInvalid(format!(
                 "failed to graft onto `{}` at block {} since it's not healthy. You can graft it starting at block {} backwards",
-                self.base, self.block, ptr.number - 1
+                self.base,
+                self.block,
+                ptr.number - 1
             ))),
-            (Some(_), _) => Ok(()),
+            (Some(_), _) => {
+                // The graft block must be at or above the base's earliest
+                // available block. Below that the base store no longer has
+                // the entity versions the copy step would need: either the
+                // base started above the graft block, or pruning has
+                // removed the history.
+                let earliest_block = store
+                    .earliest_block_number(&self.base)
+                    .await
+                    .map_err(|e| GraftBaseInvalid(e.to_string()))?;
+                if self.block < earliest_block {
+                    return Err(GraftBaseInvalid(format!(
+                        "failed to graft onto `{}` at block {} since its earliest available block is {}",
+                        self.base, self.block, earliest_block
+                    )));
+                }
+                Ok(())
+            }
         }
     }
 }
@@ -514,6 +631,10 @@ pub struct DeploymentFeatures {
     pub data_source_kinds: Vec<String>,
     pub network: String,
     pub handler_kinds: Vec<String>,
+    pub has_declared_calls: bool,
+    pub has_bytes_as_ids: bool,
+    pub has_aggregations: bool,
+    pub immutable_entities: Vec<String>,
 }
 
 impl IntoValue for DeploymentFeatures {
@@ -526,6 +647,10 @@ impl IntoValue for DeploymentFeatures {
             dataSources: self.data_source_kinds,
             handlers: self.handler_kinds,
             network: self.network,
+            hasDeclaredEthCalls: self.has_declared_calls,
+            hasBytesAsIds: self.has_bytes_as_ids,
+            hasAggregations: self.has_aggregations,
+            immutableEntities: self.immutable_entities
         }
     }
 }
@@ -552,7 +677,7 @@ pub struct BaseSubgraphManifest<C, S, D, T> {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct IndexerHints {
-    prune: Option<Prune>,
+    pub prune: Option<Prune>,
 }
 
 impl IndexerHints {
@@ -634,7 +759,7 @@ impl<'de> de::Deserialize<'de> for Prune {
 /// SubgraphManifest with IPFS links unresolved
 pub type UnresolvedSubgraphManifest<C> = BaseSubgraphManifest<
     C,
-    UnresolvedSchema,
+    Option<UnresolvedSchema>,
     UnresolvedDataSource<C>,
     UnresolvedDataSourceTemplate<C>,
 >;
@@ -647,18 +772,93 @@ pub type SubgraphManifest<C> =
 pub struct UnvalidatedSubgraphManifest<C: Blockchain>(SubgraphManifest<C>);
 
 impl<C: Blockchain> UnvalidatedSubgraphManifest<C> {
+    fn validate_subgraph_datasources(
+        data_sources: &[DataSource<C>],
+        spec_version: &Version,
+    ) -> Vec<SubgraphManifestValidationError> {
+        let mut errors = Vec::new();
+
+        // Check spec version support for subgraph datasources
+        if *spec_version < SPEC_VERSION_1_3_0
+            && data_sources
+                .iter()
+                .any(|ds| matches!(ds, DataSource::Subgraph(_)))
+        {
+            errors.push(SubgraphManifestValidationError::DataSourceValidation(
+                "subgraph".to_string(),
+                anyhow!(
+                    "Subgraph datasources are not supported prior to spec version {}",
+                    SPEC_VERSION_1_3_0
+                ),
+            ));
+            return errors;
+        }
+
+        let subgraph_ds_count = data_sources
+            .iter()
+            .filter(|ds| matches!(ds, DataSource::Subgraph(_)))
+            .count();
+
+        if subgraph_ds_count > 5 {
+            errors.push(SubgraphManifestValidationError::DataSourceValidation(
+                "subgraph".to_string(),
+                anyhow!("Cannot have more than 5 subgraph datasources"),
+            ));
+        }
+
+        let has_subgraph_ds = subgraph_ds_count > 0;
+        let has_onchain_ds = data_sources
+            .iter()
+            .any(|d| matches!(d, DataSource::Onchain(_)));
+
+        if has_subgraph_ds && has_onchain_ds {
+            errors.push(SubgraphManifestValidationError::DataSourceValidation(
+                "subgraph".to_string(),
+                anyhow!("Subgraph datasources cannot be used alongside onchain datasources"),
+            ));
+        }
+
+        // Check for duplicate source subgraphs
+        let mut seen_sources = std::collections::HashSet::new();
+        for ds in data_sources.iter() {
+            if let DataSource::Subgraph(ds) = ds {
+                let source_id = ds.source.address();
+                if !seen_sources.insert(source_id.clone()) {
+                    errors.push(SubgraphManifestValidationError::DataSourceValidation(
+                        "subgraph".to_string(),
+                        anyhow!(
+                            "Multiple subgraph datasources cannot use the same source subgraph {}",
+                            source_id
+                        ),
+                    ));
+                }
+            }
+        }
+
+        errors
+    }
+
     /// Entry point for resolving a subgraph definition.
     /// Right now the only supported links are of the form:
     /// `/ipfs/QmUmg7BZC1YP1ca66rRtWKxpXp77WgVHrnv263JtDuvs2k`
-    pub async fn resolve(
+    pub async fn resolve<AC: amp::Client>(
         id: DeploymentHash,
         raw: serde_yaml::Mapping,
         resolver: &Arc<dyn LinkResolver>,
+        amp_client: Option<Arc<AC>>,
         logger: &Logger,
         max_spec_version: semver::Version,
     ) -> Result<Self, SubgraphManifestResolveError> {
         Ok(Self(
-            SubgraphManifest::resolve_from_raw(id, raw, resolver, logger, max_spec_version).await?,
+            SubgraphManifest::resolve_from_raw(
+                id,
+                raw,
+                resolver,
+                amp_client,
+                logger,
+                max_spec_version,
+            )
+            .await?,
         ))
     }
 
@@ -670,15 +870,17 @@ impl<C: Blockchain> UnvalidatedSubgraphManifest<C> {
         store: Arc<S>,
         validate_graft_base: bool,
     ) -> Result<SubgraphManifest<C>, Vec<SubgraphManifestValidationError>> {
+        use manifest_validation::{validate_has_data_sources, validate_single_network};
+
         let mut errors: Vec<SubgraphManifestValidationError> = vec![];
 
         // Validate that the manifest has at least one data source
-        if self.0.data_sources.is_empty() {
-            errors.push(SubgraphManifestValidationError::NoDataSources);
+        if let Err(e) = validate_has_data_sources(self.0.data_sources.len()) {
+            errors.push(e);
         }
 
         for ds in &self.0.data_sources {
-            errors.extend(ds.validate().into_iter().map(|e| {
+            errors.extend(ds.validate(&self.0.spec_version).into_iter().map(|e| {
                 SubgraphManifestValidationError::DataSourceValidation(ds.name().to_owned(), e)
             }));
         }
@@ -688,35 +890,34 @@ impl<C: Blockchain> UnvalidatedSubgraphManifest<C> {
             errors.push(different_api_versions.into());
         };
 
-        let mut networks = self
-            .0
-            .data_sources
-            .iter()
-            .filter_map(|d| Some(d.as_onchain()?.network()?.to_string()))
-            .collect::<Vec<String>>();
-        networks.sort();
-        networks.dedup();
-        match networks.len() {
-            0 => errors.push(SubgraphManifestValidationError::EthereumNetworkRequired),
-            1 => (),
-            _ => errors.push(SubgraphManifestValidationError::MultipleEthereumNetworks),
+        // Validate single network using shared validation
+        let networks: Vec<Option<&str>> = self.0.data_sources.iter().map(|d| d.network()).collect();
+        if let Err(e) = validate_single_network(&networks) {
+            errors.push(e);
         }
 
-        if let Some(graft) = &self.0.graft {
-            if validate_graft_base {
-                if let Err(graft_err) = graft.validate(store).await {
-                    errors.push(graft_err);
-                }
-            }
+        if let Some(graft) = &self.0.graft
+            && validate_graft_base
+            && let Err(graft_err) = graft.validate(store).await
+        {
+            errors.push(graft_err);
         }
 
         // Validate subgraph feature usage and declaration.
-        if self.0.spec_version >= SPEC_VERSION_0_0_4 {
-            if let Err(feature_validation_error) = validate_subgraph_features(&self.0) {
-                errors.push(feature_validation_error.into())
-            }
+        if self.0.spec_version >= SPEC_VERSION_0_0_4
+            && let Err(feature_validation_error) = validate_subgraph_features(&self.0)
+        {
+            errors.push(feature_validation_error.into())
         }
 
+        // Validate subgraph datasource constraints
+        errors.extend(Self::validate_subgraph_datasources(
+            &self.0.data_sources,
+            &self.0.spec_version,
+        ));
+
+        errors.append(&mut Self::validate_amp_subgraph(&self.0));
+
         match errors.is_empty() {
             true => Ok(self.0),
             false => Err(errors),
@@ -726,23 +927,80 @@ impl<C: Blockchain> UnvalidatedSubgraphManifest<C> {
     pub fn spec_version(&self) -> &Version {
         &self.0.spec_version
     }
+
+    fn validate_amp_subgraph(
+        manifest: &SubgraphManifest<C>,
+    ) -> Vec<SubgraphManifestValidationError> {
+        use api_version::SPEC_VERSION_1_5_0;
+
+        let BaseSubgraphManifest {
+            id: _,
+            spec_version,
+            features,
+            description: _,
+            repository: _,
+            schema: _,
+            data_sources,
+            graft,
+            templates,
+            chain: _,
+            indexer_hints: _,
+        } = manifest;
+
+        let amp_data_sources = data_sources
+            .iter()
+            .filter_map(|data_source| match data_source {
+                DataSource::Amp(amp_data_source) => Some(amp_data_source),
+                _ => None,
+            })
+            .collect_vec();
+
+        if amp_data_sources.is_empty() {
+            // Not an Amp subgraph
+            return Vec::new();
+        }
+
+        let mut errors = Vec::new();
+        let err = |msg: &str| SubgraphManifestValidationError::Amp(anyhow!(msg.to_owned()));
+
+        if data_sources.len() != amp_data_sources.len() {
+            errors.push(err("multiple data source kinds are not supported"));
+        }
+
+        if *spec_version < SPEC_VERSION_1_5_0 {
+            errors.push(err("spec version is not supported"));
+        }
+
+        if !features.is_empty() {
+            errors.push(err("manifest features are not supported"));
+        }
+
+        if graft.is_some() {
+            errors.push(err("grafting is not supported"));
+        }
+
+        if !templates.is_empty() {
+            errors.push(err("data source templates are not supported"));
+        }
+
+        errors
+    }
 }
 
 impl<C: Blockchain> SubgraphManifest<C> {
     /// Entry point for resolving a subgraph definition.
-    pub async fn resolve_from_raw(
+    pub async fn resolve_from_raw<AC: amp::Client>(
         id: DeploymentHash,
         raw: serde_yaml::Mapping,
         resolver: &Arc<dyn LinkResolver>,
+        amp_client: Option<Arc<AC>>,
         logger: &Logger,
         max_spec_version: semver::Version,
     ) -> Result<Self, SubgraphManifestResolveError> {
-        let unresolved = UnresolvedSubgraphManifest::parse(id, raw)?;
-
+        let unresolved = UnresolvedSubgraphManifest::parse(id.cheap_clone(), raw)?;
         let resolved = unresolved
-            .resolve(resolver, logger, max_spec_version)
+            .resolve(&id, resolver, amp_client, logger, max_spec_version)
             .await?;
-
         Ok(resolved)
     }
 
@@ -750,14 +1008,14 @@ impl<C: Blockchain> SubgraphManifest<C> {
         // Assume the manifest has been validated, ensuring network names are homogenous
         self.data_sources
             .iter()
-            .find_map(|d| Some(d.as_onchain()?.network()?.to_string()))
+            .find_map(|d| Some(d.network()?.to_string()))
             .expect("Validated manifest does not have a network defined on any datasource")
     }
 
     pub fn start_blocks(&self) -> Vec<BlockNumber> {
         self.data_sources
             .iter()
-            .filter_map(|d| Some(d.as_onchain()?.start_block()))
+            .filter_map(|d| d.start_block())
             .collect()
     }
 
@@ -778,15 +1036,20 @@ impl<C: Blockchain> SubgraphManifest<C> {
     pub fn deployment_features(&self) -> DeploymentFeatures {
         let unified_api_version = self.unified_mapping_api_version().ok();
         let network = self.network_name();
-        let api_version = unified_api_version
-            .map(|v| v.version().map(|v| v.to_string()))
-            .flatten();
+        let has_declared_calls = self.data_sources.iter().any(|ds| ds.has_declared_calls());
+        let has_aggregations = self.schema.has_aggregations();
+        let immutable_entities = self
+            .schema
+            .immutable_entities()
+            .map(|s| s.to_string())
+            .collect_vec();
+
+        let api_version = unified_api_version.and_then(|v| v.version().map(|v| v.to_string()));
 
         let handler_kinds = self
             .data_sources
             .iter()
-            .map(|ds| ds.handler_kinds())
-            .flatten()
+            .flat_map(|ds| ds.handler_kinds())
             .collect::<HashSet<_>>();
 
         let features: Vec<String> = self
@@ -821,6 +1084,10 @@ impl<C: Blockchain> SubgraphManifest<C> {
                 .map(|s| s.to_string())
                 .collect_vec(),
             network,
+            has_declared_calls,
+            has_bytes_as_ids: self.schema.has_bytes_as_ids(),
+            immutable_entities,
+            has_aggregations,
         }
     }
 
@@ -865,9 +1132,11 @@ impl<C: Blockchain> UnresolvedSubgraphManifest<C> {
         serde_yaml::from_value(raw.into()).map_err(Into::into)
     }
 
-    pub async fn resolve(
+    pub async fn resolve<AC: amp::Client>(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
+        amp_client: Option<Arc<AC>>,
         logger: &Logger,
         max_spec_version: semver::Version,
     ) -> Result<SubgraphManifest<C>, SubgraphManifestResolveError> {
@@ -877,7 +1146,7 @@ impl<C: Blockchain> UnresolvedSubgraphManifest<C> {
             features,
             description,
             repository,
-            schema,
+            schema: unresolved_schema,
             data_sources,
             graft,
             templates,
@@ -895,33 +1164,79 @@ impl<C: Blockchain> UnresolvedSubgraphManifest<C> {
             ).into());
         }
 
-        let ds_count = data_sources.len();
-        if ds_count as u64 + templates.len() as u64 > u32::MAX as u64 {
+        if data_sources.len() + templates.len() > u32::MAX as usize {
             return Err(
-                anyhow!("Subgraph has too many declared data sources and templates",).into(),
+                anyhow!("subgraph has too many declared data sources and templates").into(),
             );
         }
 
-        let schema = schema
-            .resolve(&spec_version, id.clone(), resolver, logger)
-            .await?;
+        let schema = match unresolved_schema {
+            Some(unresolved_schema) => Some(
+                unresolved_schema
+                    .resolve(
+                        deployment_hash,
+                        &spec_version,
+                        id.cheap_clone(),
+                        resolver,
+                        logger,
+                    )
+                    .await?,
+            ),
+            None => {
+                // It is attempted to be auto-generated after data sources are resolved.
+                None
+            }
+        };
 
-        let (data_sources, templates) = try_join(
-            data_sources
-                .into_iter()
-                .enumerate()
-                .map(|(idx, ds)| ds.resolve(resolver, logger, idx as u32))
-                .collect::<FuturesOrdered<_>>()
-                .try_collect::<Vec<_>>(),
-            templates
-                .into_iter()
-                .enumerate()
-                .map(|(idx, template)| {
-                    template.resolve(resolver, &schema, logger, ds_count as u32 + idx as u32)
-                })
-                .collect::<FuturesOrdered<_>>()
-                .try_collect::<Vec<_>>(),
-        )
+        let data_sources = try_join_all(data_sources.into_iter().enumerate().map(|(idx, ds)| {
+            ds.resolve(
+                deployment_hash,
+                resolver,
+                amp_client.cheap_clone(),
+                logger,
+                idx as u32,
+                &spec_version,
+                schema.as_ref(),
+            )
+        }))
+        .await?;
+
+        let amp_data_sources = data_sources
+            .iter()
+            .filter_map(|data_source| match data_source {
+                DataSource::Amp(amp_data_source) => Some(amp_data_source),
+                _ => None,
+            })
+            .collect_vec();
+
+        let schema = match schema {
+            Some(schema) => schema,
+            None if amp_data_sources.len() == data_sources.len() => {
+                let table_schemas = amp_data_sources.iter().flat_map(|data_source| {
+                    data_source
+                        .transformer
+                        .tables
+                        .iter()
+                        .map(|table| (table.name.clone(), table.schema.clone()))
+                });
+
+                amp::schema::generate_subgraph_schema(&id, table_schemas)?
+            }
+            None => {
+                return Err(anyhow!("subgraph schema is required").into());
+            }
+        };
+
+        let templates = try_join_all(templates.into_iter().enumerate().map(|(idx, template)| {
+            template.resolve(
+                &id,
+                resolver,
+                &schema,
+                logger,
+                data_sources.len() as u32 + idx as u32,
+                &spec_version,
+            )
+        }))
         .await?;
 
         for ds in &data_sources {
@@ -962,6 +1277,17 @@ impl<C: Blockchain> UnresolvedSubgraphManifest<C> {
             );
         }
 
+        // Validate subgraph datasource constraints
+        if let Some(error) = UnvalidatedSubgraphManifest::<C>::validate_subgraph_datasources(
+            &data_sources,
+            &spec_version,
+        )
+        .into_iter()
+        .next()
+        {
+            return Err(anyhow::Error::from(error).into());
+        }
+
         // Check the min_spec_version of each data source against the spec version of the subgraph
         let min_spec_version_mismatch = data_sources
             .iter()
@@ -977,7 +1303,7 @@ impl<C: Blockchain> UnresolvedSubgraphManifest<C> {
             );
         }
 
-        Ok(SubgraphManifest {
+        let manifest = SubgraphManifest {
             id,
             spec_version,
             features,
@@ -989,7 +1315,16 @@ impl<C: Blockchain> UnresolvedSubgraphManifest<C> {
             templates,
             chain,
             indexer_hints,
-        })
+        };
+
+        if let Some(e) = UnvalidatedSubgraphManifest::<C>::validate_amp_subgraph(&manifest)
+            .into_iter()
+            .next()
+        {
+            return Err(anyhow::Error::from(e).into());
+        }
+
+        Ok(manifest)
     }
 }
 
@@ -1013,6 +1348,8 @@ pub struct DeploymentState {
     pub latest_block: BlockPtr,
     /// The earliest block that the subgraph has processed
     pub earliest_block_number: BlockNumber,
+    /// The first block at which the subgraph has a deterministic error
+    pub first_error_block: Option<BlockNumber>,
 }
 
 impl DeploymentState {
@@ -1038,6 +1375,13 @@ impl DeploymentState {
         }
         Ok(())
     }
+
+    /// Return `true` if the subgraph has a deterministic error visible at
+    /// `block`
+    pub fn has_deterministic_errors(&self, block: &BlockPtr) -> bool {
+        self.first_error_block
+            .is_some_and(|first_error_block| first_error_block <= block.number)
+    }
 }
 
 fn display_vector(input: &[impl std::fmt::Display]) -> impl std::fmt::Display {
diff --git a/graph/src/data/subgraph/schema.rs b/graph/src/data/subgraph/schema.rs
index 9cc66bde1a0..c65dfad88e2 100644
--- a/graph/src/data/subgraph/schema.rs
+++ b/graph/src/data/subgraph/schema.rs
@@ -1,9 +1,10 @@
 //! Entity types that contain the graph-node state.
 
-use anyhow::{anyhow, bail, Error};
+use anyhow::{Error, anyhow, bail};
+use chrono::{DateTime, Utc};
 use hex;
+use rand::TryRngCore as _;
 use rand::rngs::OsRng;
-use rand::Rng;
 use std::collections::BTreeSet;
 use std::str::FromStr;
 use std::{fmt, fmt::Display};
@@ -159,7 +160,7 @@ pub struct SubgraphDeploymentEntity {
     pub manifest: SubgraphManifestEntity,
     pub failed: bool,
     pub health: SubgraphHealth,
-    pub synced: bool,
+    pub synced_at: Option<DateTime<Utc>>,
     pub fatal_error: Option<SubgraphError>,
     pub non_fatal_errors: Vec<SubgraphError>,
     /// The earliest block for which we have data
@@ -271,11 +272,9 @@ impl_stable_hash!(SubgraphError {
 });
 
 pub fn generate_entity_id() -> String {
-    // Fast crypto RNG from operating system
-    let mut rng = OsRng::default();
-
     // 128 random bits
-    let id_bytes: [u8; 16] = rng.gen();
+    let mut id_bytes = [0u8; 16];
+    OsRng.try_fill_bytes(&mut id_bytes).unwrap();
 
     // 32 hex chars
     // Comparable to uuidv4, but without the hyphens,
diff --git a/graph/src/data/subgraph/status.rs b/graph/src/data/subgraph/status.rs
index aff4ee82512..86c45fc193f 100644
--- a/graph/src/data/subgraph/status.rs
+++ b/graph/src/data/subgraph/status.rs
@@ -3,8 +3,8 @@
 use super::schema::{SubgraphError, SubgraphHealth};
 use crate::blockchain::BlockHash;
 use crate::components::store::{BlockNumber, DeploymentId};
-use crate::data::graphql::{object, IntoValue};
-use crate::prelude::{r, BlockPtr, Value};
+use crate::data::graphql::{IntoValue, object};
+use crate::prelude::{BlockPtr, Value, r};
 
 pub enum Filter {
     /// Get all versions for the named subgraph
@@ -19,7 +19,7 @@ pub enum Filter {
 }
 
 /// Light wrapper around `EthereumBlockPointer` that is compatible with GraphQL values.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct EthereumBlock(BlockPtr);
 
 impl EthereumBlock {
@@ -55,7 +55,7 @@ impl From<BlockPtr> for EthereumBlock {
 /// Indexing status information related to the chain. Right now, we only
 /// support Ethereum, but once we support more chains, we'll have to turn this into
 /// an enum
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct ChainInfo {
     /// The network name (e.g. `mainnet`, `ropsten`, `rinkeby`, `kovan` or `goerli`).
     pub network: String,
@@ -91,6 +91,35 @@ impl IntoValue for ChainInfo {
     }
 }
 
+#[derive(Debug, Default)]
+pub struct SubgraphSize {
+    pub row_estimate: i64,
+    pub table_bytes: i64,
+    pub index_bytes: i64,
+    pub toast_bytes: i64,
+    pub total_bytes: i64,
+}
+
+impl IntoValue for SubgraphSize {
+    fn into_value(self) -> r::Value {
+        let SubgraphSize {
+            row_estimate,
+            table_bytes,
+            index_bytes,
+            toast_bytes,
+            total_bytes,
+        } = self;
+        object! {
+            __typename: "SubgraphSize",
+            rowEstimate: format!("{}", row_estimate),
+            tableSize: format!("{}", table_bytes),
+            indexSize: format!("{}", index_bytes),
+            toastSize: format!("{}", toast_bytes),
+            totalSize: format!("{}", total_bytes),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Info {
     pub id: DeploymentId,
@@ -114,6 +143,9 @@ pub struct Info {
     pub node: Option<String>,
 
     pub history_blocks: i32,
+
+    /// The size of all entity tables in a deployment's namespace in bytes.
+    pub subgraph_size: SubgraphSize,
 }
 
 impl IntoValue for Info {
@@ -130,6 +162,7 @@ impl IntoValue for Info {
             non_fatal_errors,
             synced,
             history_blocks,
+            subgraph_size,
         } = self;
 
         fn subgraph_error_to_value(subgraph_error: SubgraphError) -> r::Value {
@@ -173,6 +206,7 @@ impl IntoValue for Info {
             entityCount: format!("{}", entity_count),
             node: node,
             historyBlocks: history_blocks,
+            subgraphSize: subgraph_size.into_value(),
         }
     }
 }
diff --git a/graph/src/data/subscription/error.rs b/graph/src/data/subscription/error.rs
deleted file mode 100644
index 20cf3f3af73..00000000000
--- a/graph/src/data/subscription/error.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use serde::ser::*;
-
-use crate::prelude::QueryExecutionError;
-use thiserror::Error;
-
-/// Error caused while processing a [Subscription](struct.Subscription.html) request.
-#[derive(Debug, Error)]
-pub enum SubscriptionError {
-    #[error("GraphQL error: {0:?}")]
-    GraphQLError(Vec<QueryExecutionError>),
-}
-
-impl From<QueryExecutionError> for SubscriptionError {
-    fn from(e: QueryExecutionError) -> Self {
-        SubscriptionError::GraphQLError(vec![e])
-    }
-}
-
-impl From<Vec<QueryExecutionError>> for SubscriptionError {
-    fn from(e: Vec<QueryExecutionError>) -> Self {
-        SubscriptionError::GraphQLError(e)
-    }
-}
-impl Serialize for SubscriptionError {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let mut map = serializer.serialize_map(Some(1))?;
-        let msg = format!("{}", self);
-        map.serialize_entry("message", msg.as_str())?;
-        map.end()
-    }
-}
diff --git a/graph/src/data/subscription/mod.rs b/graph/src/data/subscription/mod.rs
deleted file mode 100644
index 093c0008728..00000000000
--- a/graph/src/data/subscription/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-mod error;
-mod result;
-mod subscription;
-
-pub use self::error::SubscriptionError;
-pub use self::result::{QueryResultStream, SubscriptionResult};
-pub use self::subscription::Subscription;
diff --git a/graph/src/data/subscription/result.rs b/graph/src/data/subscription/result.rs
deleted file mode 100644
index 648ce79ac52..00000000000
--- a/graph/src/data/subscription/result.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use crate::prelude::QueryResult;
-use std::pin::Pin;
-use std::sync::Arc;
-
-/// A stream of query results for a subscription.
-pub type QueryResultStream =
-    Pin<Box<dyn futures03::stream::Stream<Item = Arc<QueryResult>> + Send>>;
-
-/// The result of running a subscription, if successful.
-pub type SubscriptionResult = QueryResultStream;
diff --git a/graph/src/data/subscription/subscription.rs b/graph/src/data/subscription/subscription.rs
deleted file mode 100644
index 8ae6b872fba..00000000000
--- a/graph/src/data/subscription/subscription.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use crate::prelude::Query;
-
-/// A GraphQL subscription made by a client.
-///
-/// At the moment, this only contains the GraphQL query submitted as the
-/// subscription payload.
-#[derive(Clone, Debug)]
-pub struct Subscription {
-    /// The GraphQL subscription query.
-    pub query: Query,
-}
diff --git a/graph/src/data/value.rs b/graph/src/data/value.rs
index 5d9df9502ae..6dce081aa7b 100644
--- a/graph/src/data/value.rs
+++ b/graph/src/data/value.rs
@@ -1,16 +1,17 @@
-use crate::prelude::{q, s, CacheWeight};
+use crate::derive::CacheWeight;
+use crate::prelude::{q, s};
 use crate::runtime::gas::{Gas, GasSizeOf, SaturatingInto};
 use diesel::pg::Pg;
-use diesel::serialize::{self, Output};
+use diesel::serialize::{self, Output, ToSql};
 use diesel::sql_types::Text;
-use diesel::types::ToSql;
-use serde::ser::{SerializeMap, SerializeSeq, Serializer};
 use serde::Serialize;
+use serde::ser::{SerializeMap, SerializeSeq, Serializer};
 use std::collections::BTreeMap;
 use std::convert::TryFrom;
-use std::io::Write;
 use std::iter::FromIterator;
 
+use super::store::scalar;
+
 /// An immutable string that is more memory-efficient since it only has an
 /// overhead of 16 bytes for storing a string vs the 24 bytes that `String`
 /// requires
@@ -74,8 +75,8 @@ impl<'de> serde::Deserialize<'de> for Word {
 }
 
 impl ToSql<Text, Pg> for Word {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
-        <str as ToSql<Text, Pg>>::to_sql(&self.0, out)
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
+        <str as ToSql<Text, Pg>>::to_sql(&self.0, &mut out.reborrow())
     }
 }
 
@@ -114,13 +115,31 @@ impl PartialEq<&str> for Word {
     }
 }
 
+impl PartialEq<str> for Word {
+    fn eq(&self, other: &str) -> bool {
+        self.as_str() == other
+    }
+}
+
+impl PartialEq<String> for Word {
+    fn eq(&self, other: &String) -> bool {
+        self.as_str() == other
+    }
+}
+
+impl PartialEq<Word> for String {
+    fn eq(&self, other: &Word) -> bool {
+        self.as_str() == other.as_str()
+    }
+}
+
 impl PartialEq<Word> for &str {
     fn eq(&self, other: &Word) -> bool {
         self == &other.as_str()
     }
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, CacheWeight, Debug, PartialEq)]
 struct Entry {
     key: Option<Word>,
     value: Value,
@@ -142,7 +161,7 @@ impl Entry {
     }
 }
 
-#[derive(Clone, PartialEq, Default)]
+#[derive(Clone, CacheWeight, PartialEq, Default)]
 pub struct Object(Box<[Entry]>);
 
 impl Object {
@@ -272,22 +291,10 @@ impl<'a> IntoIterator for &'a Object {
     }
 }
 
-impl CacheWeight for Entry {
-    fn indirect_weight(&self) -> usize {
-        self.key.indirect_weight() + self.value.indirect_weight()
-    }
-}
-
-impl CacheWeight for Object {
-    fn indirect_weight(&self) -> usize {
-        self.0.iter().map(CacheWeight::indirect_weight).sum()
-    }
-}
-
 impl std::fmt::Debug for Object {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_map()
-            .entries(self.0.into_iter().map(|e| {
+            .entries(self.0.iter().map(|e| {
                 (
                     e.key.as_ref().map(|w| w.as_str()).unwrap_or("---"),
                     &e.value,
@@ -297,7 +304,7 @@ impl std::fmt::Debug for Object {
     }
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Clone, CacheWeight, PartialEq)]
 pub enum Value {
     Int(i64),
     Float(f64),
@@ -307,6 +314,7 @@ pub enum Value {
     Enum(String),
     List(Vec<Value>),
     Object(Object),
+    Timestamp(scalar::Timestamp),
 }
 
 impl Value {
@@ -342,7 +350,7 @@ impl Value {
             ("BigDecimal", Value::Int(i)) => Ok(Value::String(i.to_string())),
             ("BigDecimal", Value::String(s)) => Ok(Value::String(s)),
             ("Int", Value::Int(num)) => {
-                if i32::min_value() as i64 <= num && num <= i32::max_value() as i64 {
+                if i32::MIN as i64 <= num && num <= i32::MAX as i64 {
                     Ok(Value::Int(num))
                 } else {
                     Err(Value::Int(num))
@@ -350,6 +358,10 @@ impl Value {
             }
             ("Int8", Value::Int(num)) => Ok(Value::String(num.to_string())),
             ("Int8", Value::String(num)) => Ok(Value::String(num)),
+            ("Timestamp", Value::Timestamp(ts)) => Ok(Value::Timestamp(ts)),
+            ("Timestamp", Value::String(ts_str)) => Ok(Value::Timestamp(
+                scalar::Timestamp::parse_timestamp(&ts_str).map_err(|_| Value::String(ts_str))?,
+            )),
             ("String", Value::String(s)) => Ok(Value::String(s)),
             ("ID", Value::String(s)) => Ok(Value::String(s)),
             ("ID", Value::Int(n)) => Ok(Value::String(n.to_string())),
@@ -396,17 +408,9 @@ impl std::fmt::Display for Value {
                 }
                 write!(f, "}}")
             }
-        }
-    }
-}
-
-impl CacheWeight for Value {
-    fn indirect_weight(&self) -> usize {
-        match self {
-            Value::Boolean(_) | Value::Int(_) | Value::Null | Value::Float(_) => 0,
-            Value::Enum(s) | Value::String(s) => s.indirect_weight(),
-            Value::List(l) => l.indirect_weight(),
-            Value::Object(o) => o.indirect_weight(),
+            Value::Timestamp(ref ts) => {
+                write!(f, "\"{}\"", ts.as_microseconds_since_epoch())
+            }
         }
     }
 }
@@ -428,6 +432,9 @@ impl Serialize for Value {
                 }
                 seq.end()
             }
+            Value::Timestamp(ts) => {
+                serializer.serialize_str(ts.as_microseconds_since_epoch().to_string().as_str())
+            }
             Value::Null => serializer.serialize_none(),
             Value::String(s) => serializer.serialize_str(s),
             Value::Object(o) => {
@@ -521,6 +528,7 @@ impl From<Value> for q::Value {
                 }
                 q::Value::Object(rmap)
             }
+            Value::Timestamp(ts) => q::Value::String(ts.as_microseconds_since_epoch().to_string()),
         }
     }
 }
@@ -536,6 +544,44 @@ impl std::fmt::Debug for Value {
             Value::Enum(e) => write!(f, "{e}"),
             Value::List(l) => f.debug_list().entries(l).finish(),
             Value::Object(o) => write!(f, "{o:?}"),
+            Value::Timestamp(ts) => {
+                write!(f, "{:?}", ts.as_microseconds_since_epoch().to_string())
+            }
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::prelude::CacheWeight;
+
+    use super::{Entry, Object, Value, Word};
+
+    /// Test that we measure cache weight properly. If the definition of
+    /// `Value` changes, it's ok if these tests fail. They will then just
+    /// need to be adapted to the changed layout of `Value`
+    #[test]
+    fn cache_weight() {
+        let e = Entry::new(Word::from("hello"), Value::Int(42));
+        assert_eq!(e.weight(), 48 + 5);
+
+        let o = Object(vec![e.clone(), e.clone()].into_boxed_slice());
+        assert_eq!(o.weight(), 16 + 2 * (48 + 5));
+
+        let map = vec![
+            (Word::from("a"), Value::Int(1)),
+            (Word::from("b"), Value::Int(2)),
+        ];
+        let entries_weight = 2 * (16 + 1 + 32);
+        assert_eq!(map.weight(), 24 + entries_weight);
+
+        let v = Value::String("hello".to_string());
+        assert_eq!(v.weight(), 32 + 5);
+        let v = Value::Int(42);
+        assert_eq!(v.weight(), 32);
+
+        let v = Value::Object(Object::from_iter(map));
+        // Not entirely sure where the 8 comes from
+        assert_eq!(v.weight(), 24 + 8 + entries_weight);
+    }
+}
diff --git a/graph/src/data_source/causality_region.rs b/graph/src/data_source/causality_region.rs
index 808538b6027..5755657f157 100644
--- a/graph/src/data_source/causality_region.rs
+++ b/graph/src/data_source/causality_region.rs
@@ -1,14 +1,14 @@
 use diesel::{
-    pg::Pg,
-    serialize::Output,
+    deserialize::{FromSql, FromSqlRow},
+    pg::{Pg, PgValue},
+    serialize::{Output, ToSql},
     sql_types::Integer,
-    types::{FromSql, ToSql},
-    FromSqlRow,
 };
+use diesel_derives::AsExpression;
 use std::fmt;
-use std::io;
 
 use crate::components::subgraph::Entity;
+use crate::derive::CacheWeight;
 
 /// The causality region of a data source. All onchain data sources share the same causality region,
 /// but each offchain data source is assigned its own. This isolates offchain data sources from
@@ -21,7 +21,10 @@ use crate::components::subgraph::Entity;
 /// This necessary for determinism because offchain data sources don't have a deterministic order of
 /// execution, for example an IPFS file may become available at any point in time. The isolation
 /// rules make the indexing result reproducible, given a set of available files.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, FromSqlRow, Hash, PartialOrd, Ord)]
+#[derive(
+    Debug, CacheWeight, Copy, Clone, PartialEq, Eq, FromSqlRow, Hash, PartialOrd, Ord, AsExpression,
+)]
+#[diesel(sql_type = Integer)]
 pub struct CausalityRegion(i32);
 
 impl fmt::Display for CausalityRegion {
@@ -31,14 +34,20 @@ impl fmt::Display for CausalityRegion {
 }
 
 impl FromSql<Integer, Pg> for CausalityRegion {
-    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
+    fn from_sql(bytes: PgValue) -> diesel::deserialize::Result<Self> {
         <i32 as FromSql<Integer, Pg>>::from_sql(bytes).map(CausalityRegion)
     }
 }
 
 impl ToSql<Integer, Pg> for CausalityRegion {
-    fn to_sql<W: io::Write>(&self, out: &mut Output<W, Pg>) -> diesel::serialize::Result {
-        <i32 as ToSql<Integer, Pg>>::to_sql(&self.0, out)
+    fn to_sql(&self, out: &mut Output<Pg>) -> diesel::serialize::Result {
+        <i32 as ToSql<Integer, Pg>>::to_sql(&self.0, &mut out.reborrow())
+    }
+}
+
+impl From<i32> for CausalityRegion {
+    fn from(value: i32) -> Self {
+        CausalityRegion(value)
     }
 }
 
diff --git a/graph/src/data_source/common.rs b/graph/src/data_source/common.rs
new file mode 100644
index 00000000000..f23c8d3d849
--- /dev/null
+++ b/graph/src/data_source/common.rs
@@ -0,0 +1,2387 @@
+use crate::abi;
+use crate::abi::DynSolValueExt;
+use crate::abi::FunctionExt;
+use crate::blockchain::block_stream::EntitySourceOperation;
+use crate::data::subgraph::SPEC_VERSION_1_4_0;
+use crate::prelude::{BlockPtr, Value};
+use crate::{
+    components::link_resolver::{LinkResolver, LinkResolverContext},
+    data::subgraph::DeploymentHash,
+    data::value::Word,
+    prelude::Link,
+};
+use alloy::primitives::{Address, U256};
+use alloy::rpc::types::Log;
+use anyhow::{Context, Error, anyhow};
+use graph_derive::CheapClone;
+use lazy_static::lazy_static;
+use num_bigint::Sign;
+use regex::Regex;
+use serde::Deserialize;
+use serde::de;
+use serde_json;
+use slog::Logger;
+use std::collections::HashMap;
+use std::{str::FromStr, sync::Arc};
+
+/// Normalizes ABI JSON to handle compatibility issues between the legacy `ethabi`/`rust-web3`
+/// parser and the stricter `alloy` parser.
+///
+/// Some deployed subgraph ABIs contain non-standard constructs that `ethabi` accepted but
+/// `alloy` rejects. This function patches these issues to maintain backward compatibility:
+///
+/// 1. **`stateMutability: "undefined"`** - Some ABIs use "undefined" which is not a valid
+///    Solidity state mutability. We replace it with "nonpayable".
+///
+/// 2. **Duplicate constructors** - Some ABIs contain multiple constructor definitions.
+///    We keep only the first one.
+///
+/// 3. **Duplicate fallback functions** - Similar to constructors, some ABIs have multiple
+///    fallback definitions. We keep only the first one.
+///
+/// 4. **`indexed` field in non-event params** - The `indexed` field is only valid for event
+///    parameters, but some ABIs include it on function inputs/outputs. We strip it from
+///    non-event items.
+///
+/// These issues were identified by validating ABIs across deployed subgraphs in production
+/// before the migration to alloy.
+fn normalize_abi_json(json_bytes: &[u8]) -> Result<Vec<u8>, anyhow::Error> {
+    let mut value: serde_json::Value = serde_json::from_slice(json_bytes)?;
+
+    if let Some(array) = value.as_array_mut() {
+        let mut found_constructor = false;
+        let mut found_fallback = false;
+        let mut indices_to_remove = Vec::new();
+
+        for (index, item) in array.iter_mut().enumerate() {
+            if let Some(obj) = item.as_object_mut() {
+                if let Some(state_mutability) = obj.get_mut("stateMutability")
+                    && let Some(s) = state_mutability.as_str()
+                    && s == "undefined"
+                {
+                    *state_mutability = serde_json::Value::String("nonpayable".to_string());
+                }
+
+                let item_type = obj.get("type").and_then(|t| t.as_str());
+
+                match item_type {
+                    Some("constructor") if found_constructor => indices_to_remove.push(index),
+                    Some("constructor") => found_constructor = true,
+                    Some("fallback") if found_fallback => indices_to_remove.push(index),
+                    Some("fallback") => found_fallback = true,
+                    _ => {}
+                }
+
+                if item_type != Some("event") {
+                    strip_indexed_from_params(obj.get_mut("inputs"));
+                    strip_indexed_from_params(obj.get_mut("outputs"));
+                }
+            }
+        }
+
+        for index in indices_to_remove.iter().rev() {
+            array.remove(*index);
+        }
+    }
+
+    Ok(serde_json::to_vec(&value)?)
+}
+
+fn strip_indexed_from_params(params: Option<&mut serde_json::Value>) {
+    if let Some(serde_json::Value::Array(arr)) = params {
+        for param in arr.iter_mut() {
+            if let Some(obj) = param.as_object_mut() {
+                obj.remove("indexed");
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct MappingABI {
+    pub name: String,
+    pub contract: abi::JsonAbi,
+}
+
+impl MappingABI {
+    pub fn function(
+        &self,
+        contract_name: &str,
+        name: &str,
+        signature: Option<&str>,
+    ) -> Result<&abi::Function, Error> {
+        let contract = &self.contract;
+        let function = match signature {
+            // Behavior for apiVersion < 0.0.4: look up function by name; for overloaded
+            // functions this always picks the same overloaded variant, which is incorrect
+            // and may lead to encoding/decoding errors
+            None => contract
+                .function(name)
+                .and_then(|matches| matches.first())
+                .with_context(|| {
+                    format!(
+                        "Unknown function \"{}::{}\" called from WASM runtime",
+                        contract_name, name
+                    )
+                })?,
+
+            // Behavior for apiVersion >= 0.0.04: look up function by signature of
+            // the form `functionName(uint256,string) returns (bytes32,string)`; this
+            // correctly picks the correct variant of an overloaded function
+            Some(ref signature) => contract
+                .function(name)
+                .with_context(|| {
+                    format!(
+                        "Unknown function \"{}::{}\" called from WASM runtime",
+                        contract_name, name
+                    )
+                })?
+                .iter()
+                .find(|f| signature == &f.signature_compat())
+                .with_context(|| {
+                    format!(
+                        "Unknown function \"{}::{}\" with signature `{}` \
+                             called from WASM runtime",
+                        contract_name, name, signature,
+                    )
+                })?,
+        };
+        Ok(function)
+    }
+}
+
+/// Helper struct for working with ABI JSON to extract struct field information on demand
+#[derive(Clone, Debug)]
+pub struct AbiJson {
+    abi: serde_json::Value,
+}
+
+impl AbiJson {
+    pub fn new(abi_bytes: &[u8]) -> Result<Self, Error> {
+        let abi = serde_json::from_slice(abi_bytes).with_context(|| "Failed to parse ABI JSON")?;
+        Ok(Self { abi })
+    }
+
+    /// Extract event name from event signature
+    /// e.g., "Transfer(address,address,uint256)" -> "Transfer"
+    fn extract_event_name(signature: &str) -> &str {
+        signature.split('(').next().unwrap_or(signature).trim()
+    }
+
+    /// Get struct field information for a specific event parameter
+    pub fn get_struct_field_info(
+        &self,
+        event_signature: &str,
+        param_name: &str,
+    ) -> Result<Option<StructFieldInfo>, Error> {
+        let event_name = Self::extract_event_name(event_signature);
+
+        let Some(abi_array) = self.abi.as_array() else {
+            return Ok(None);
+        };
+
+        for item in abi_array {
+            // Only process events
+            if item.get("type").and_then(|t| t.as_str()) == Some("event")
+                && let Some(item_event_name) = item.get("name").and_then(|n| n.as_str())
+                && item_event_name == event_name
+            {
+                // Found the event, now look for the parameter
+                if let Some(inputs) = item.get("inputs").and_then(|i| i.as_array()) {
+                    for input in inputs {
+                        if let Some(input_param_name) = input.get("name").and_then(|n| n.as_str())
+                            && input_param_name == param_name
+                        {
+                            // Found the parameter, check if it's a struct
+                            if let Some(param_type) = input.get("type").and_then(|t| t.as_str())
+                                && param_type == "tuple"
+                                && let Some(components) = input.get("components")
+                            {
+                                // Parse the ParamType from the JSON (simplified for now)
+                                let param_type = abi::DynSolType::Tuple(vec![]);
+                                return StructFieldInfo::from_components(
+                                    param_name.to_string(),
+                                    param_type,
+                                    components,
+                                )
+                                .map(Some);
+                            }
+                            // Parameter found but not a struct
+                            return Ok(None);
+                        }
+                    }
+                }
+                // Event found but parameter not found
+                return Ok(None);
+            }
+        }
+
+        // Event not found
+        Ok(None)
+    }
+
+    /// Get nested struct field information by resolving a field path
+    /// e.g., field_path = ["complexAsset", "base", "addr"]
+    /// returns Some(vec![0, 0]) if complexAsset.base is at index 0 and base.addr is at index 0
+    pub fn get_nested_struct_field_info(
+        &self,
+        event_signature: &str,
+        field_path: &[&str],
+    ) -> Result<Option<Vec<usize>>, Error> {
+        if field_path.is_empty() {
+            return Ok(None);
+        }
+
+        let event_name = Self::extract_event_name(event_signature);
+        let param_name = field_path[0];
+        let nested_path = &field_path[1..];
+
+        let Some(abi_array) = self.abi.as_array() else {
+            return Ok(None);
+        };
+
+        for item in abi_array {
+            // Only process events
+            if item.get("type").and_then(|t| t.as_str()) == Some("event")
+                && let Some(item_event_name) = item.get("name").and_then(|n| n.as_str())
+                && item_event_name == event_name
+            {
+                // Found the event, now look for the parameter
+                if let Some(inputs) = item.get("inputs").and_then(|i| i.as_array()) {
+                    for input in inputs {
+                        if let Some(input_param_name) = input.get("name").and_then(|n| n.as_str())
+                            && input_param_name == param_name
+                        {
+                            // Found the parameter, check if it's a struct
+                            if let Some(param_type) = input.get("type").and_then(|t| t.as_str())
+                                && param_type == "tuple"
+                                && let Some(components) = input.get("components")
+                            {
+                                // If no nested path, this is the end
+                                if nested_path.is_empty() {
+                                    return Ok(Some(vec![]));
+                                }
+                                // Recursively resolve the nested path
+                                return Self::resolve_field_path(components, nested_path).map(Some);
+                            }
+                            // Parameter found but not a struct
+                            return Ok(None);
+                        }
+                    }
+                }
+                // Event found but parameter not found
+                return Ok(None);
+            }
+        }
+
+        // Event not found
+        Ok(None)
+    }
+
+    /// Recursively resolve a field path within ABI components
+    /// Supports both numeric indices and field names
+    /// Returns the index path to access the final field
+    fn resolve_field_path(
+        components: &serde_json::Value,
+        field_path: &[&str],
+    ) -> Result<Vec<usize>, Error> {
+        if field_path.is_empty() {
+            return Ok(vec![]);
+        }
+
+        let field_accessor = field_path[0];
+        let remaining_path = &field_path[1..];
+
+        let Some(components_array) = components.as_array() else {
+            return Err(anyhow!("Expected components array"));
+        };
+
+        // Check if it's a numeric index
+        if let Ok(index) = field_accessor.parse::<usize>() {
+            // Validate the index
+            if index >= components_array.len() {
+                return Err(anyhow!(
+                    "Index {} out of bounds for struct with {} fields",
+                    index,
+                    components_array.len()
+                ));
+            }
+
+            // If there are more fields to resolve
+            if !remaining_path.is_empty() {
+                let component = &components_array[index];
+
+                // Check if this component is a tuple that can be further accessed
+                if let Some(component_type) = component.get("type").and_then(|t| t.as_str()) {
+                    if component_type == "tuple" {
+                        if let Some(nested_components) = component.get("components") {
+                            // Recursively resolve the remaining path
+                            let mut result = vec![index];
+                            let nested_result =
+                                Self::resolve_field_path(nested_components, remaining_path)?;
+                            result.extend(nested_result);
+                            return Ok(result);
+                        } else {
+                            return Err(anyhow!(
+                                "Field at index {} is a tuple but has no components",
+                                index
+                            ));
+                        }
+                    } else {
+                        return Err(anyhow!(
+                            "Field at index {} is not a struct (type: {}), cannot access nested field '{}'",
+                            index,
+                            component_type,
+                            remaining_path[0]
+                        ));
+                    }
+                }
+            }
+
+            // This is the final field
+            return Ok(vec![index]);
+        }
+
+        // It's a field name - find it in the current level
+        for (index, component) in components_array.iter().enumerate() {
+            if let Some(component_name) = component.get("name").and_then(|n| n.as_str())
+                && component_name == field_accessor
+            {
+                // Found the field
+                if remaining_path.is_empty() {
+                    // This is the final field, return its index
+                    return Ok(vec![index]);
+                } else {
+                    // We need to go deeper - check if this component is a tuple
+                    if let Some(component_type) = component.get("type").and_then(|t| t.as_str()) {
+                        if component_type == "tuple" {
+                            if let Some(nested_components) = component.get("components") {
+                                // Recursively resolve the remaining path
+                                let mut result = vec![index];
+                                let nested_result =
+                                    Self::resolve_field_path(nested_components, remaining_path)?;
+                                result.extend(nested_result);
+                                return Ok(result);
+                            } else {
+                                return Err(anyhow!(
+                                    "Tuple field '{}' has no components",
+                                    field_accessor
+                                ));
+                            }
+                        } else {
+                            return Err(anyhow!(
+                                "Field '{}' is not a struct (type: {}), cannot access nested field '{}'",
+                                field_accessor,
+                                component_type,
+                                remaining_path[0]
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+
+        // Field not found at this level
+        let available_fields: Vec<String> = components_array
+            .iter()
+            .filter_map(|c| c.get("name").and_then(|n| n.as_str()))
+            .map(String::from)
+            .collect();
+
+        Err(anyhow!(
+            "Field '{}' not found. Available fields: {:?}",
+            field_accessor,
+            available_fields
+        ))
+    }
+}
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
+pub struct UnresolvedMappingABI {
+    pub name: String,
+    pub file: Link,
+}
+
+impl UnresolvedMappingABI {
+    pub async fn resolve(
+        self,
+        deployment_hash: &DeploymentHash,
+        resolver: &Arc<dyn LinkResolver>,
+        logger: &Logger,
+    ) -> Result<(MappingABI, AbiJson), anyhow::Error> {
+        let contract_bytes = resolver
+            .cat(
+                &LinkResolverContext::new(deployment_hash, logger),
+                &self.file,
+            )
+            .await
+            .with_context(|| {
+                format!(
+                    "failed to resolve ABI {} from {}",
+                    self.name, self.file.link
+                )
+            })?;
+        // Normalize the ABI to handle compatibility issues between ethabi and alloy parsers.
+        // See `normalize_abi_json` for details on the specific issues being addressed.
+        let normalized_bytes = normalize_abi_json(&contract_bytes)
+            .with_context(|| format!("failed to normalize ABI JSON for {}", self.name))?;
+
+        let contract = serde_json::from_slice(&normalized_bytes)
+            .with_context(|| format!("failed to load ABI {}", self.name))?;
+
+        // Parse ABI JSON for on-demand struct field extraction
+        let abi_json = AbiJson::new(&normalized_bytes)
+            .with_context(|| format!("Failed to parse ABI JSON for {}", self.name))?;
+
+        Ok((
+            MappingABI {
+                name: self.name,
+                contract,
+            },
+            abi_json,
+        ))
+    }
+}
+
+/// Internal representation of declared calls. In the manifest that's
+/// written as part of an event handler as
+/// ```yaml
+/// calls:
+///   - myCall1: Contract[address].function(arg1, arg2, ...)
+///   - ..
+/// ```
+///
+/// The `address` and `arg` fields can be either `event.address` or
+/// `event.params.<name>`. Each entry under `calls` gets turned into a
+/// `CallDcl`
+#[derive(Clone, CheapClone, Debug, Default, Hash, Eq, PartialEq)]
+#[non_exhaustive]
+pub struct CallDecls {
+    pub decls: Arc<Vec<CallDecl>>,
+}
+
+/// A single call declaration, like `myCall1:
+/// Contract[address].function(arg1, arg2, ...)`
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+#[non_exhaustive]
+pub struct CallDecl {
+    /// A user-defined label
+    pub label: String,
+    /// The call expression
+    pub expr: CallExpr,
+}
+
+impl CallDecl {
+    pub fn validate_args(&self) -> Result<(), Error> {
+        self.expr.validate_args()
+    }
+
+    pub fn address_for_log(
+        &self,
+        log: &Log,
+        params: &[abi::DynSolParam],
+    ) -> Result<Address, Error> {
+        self.address_for_log_with_abi(log, params)
+    }
+
+    pub fn address_for_log_with_abi(
+        &self,
+        log: &Log,
+        params: &[abi::DynSolParam],
+    ) -> Result<Address, Error> {
+        let address = match &self.expr.address {
+            CallArg::HexAddress(address) => *address,
+            CallArg::Ethereum(arg) => match arg {
+                EthereumArg::Address => log.address(),
+                EthereumArg::Param(name) => {
+                    let value = &params
+                        .iter()
+                        .find(|param| param.name == name.as_str())
+                        .ok_or_else(|| {
+                            anyhow!(
+                                "In declarative call '{}': unknown param {}",
+                                self.label,
+                                name
+                            )
+                        })?
+                        .value;
+
+                    let address = value.as_address().ok_or_else(|| {
+                        anyhow!(
+                            "In declarative call '{}': param {} is not an address",
+                            self.label,
+                            name
+                        )
+                    })?;
+
+                    Address::from(address.into_array())
+                }
+                EthereumArg::StructField(param_name, field_accesses) => {
+                    let param = params
+                        .iter()
+                        .find(|param| param.name == param_name.as_str())
+                        .ok_or_else(|| {
+                            anyhow!(
+                                "In declarative call '{}': unknown param {}",
+                                self.label,
+                                param_name
+                            )
+                        })?;
+
+                    Self::extract_nested_struct_field_as_address(
+                        &param.value,
+                        field_accesses,
+                        &self.label,
+                    )?
+                }
+            },
+            CallArg::Subgraph(_) => {
+                return Err(anyhow!(
+                    "In declarative call '{}': Subgraph params are not supported for event handlers",
+                    self.label
+                ));
+            }
+        };
+        Ok(address)
+    }
+
+    pub fn args_for_log(
+        &self,
+        log: &Log,
+        params: &[abi::DynSolParam],
+    ) -> Result<Vec<abi::DynSolValue>, Error> {
+        self.args_for_log_with_abi(log, params)
+    }
+
+    pub fn args_for_log_with_abi(
+        &self,
+        log: &Log,
+        params: &[abi::DynSolParam],
+    ) -> Result<Vec<abi::DynSolValue>, Error> {
+        use abi::DynSolValue;
+        self.expr
+            .args
+            .iter()
+            .map(|arg| match arg {
+                CallArg::HexAddress(address) => Ok(DynSolValue::Address(*address)),
+                CallArg::Ethereum(arg) => match arg {
+                    EthereumArg::Address => Ok(DynSolValue::Address(log.address())),
+                    EthereumArg::Param(name) => {
+                        let value = params
+                            .iter()
+                            .find(|param| param.name == name.as_str())
+                            .ok_or_else(|| anyhow!("In declarative call '{}': unknown param {}", self.label, name))?
+                            .value
+                            .clone();
+                        Ok(value)
+                    }
+                    EthereumArg::StructField(param_name, field_accesses) => {
+                        let param = params
+                            .iter()
+                            .find(|param| param.name == param_name.as_str())
+                            .ok_or_else(|| anyhow!("In declarative call '{}': unknown param {}", self.label, param_name))?;
+
+                        Self::extract_nested_struct_field(
+                            &param.value,
+                            field_accesses,
+                            &self.label,
+                        )
+                    }
+                },
+                CallArg::Subgraph(_) => Err(anyhow!(
+                    "In declarative call '{}': Subgraph params are not supported for event handlers",
+                    self.label
+                )),
+            })
+            .collect()
+    }
+
+    pub fn get_function(
+        &self,
+        mapping: &dyn FindMappingABI,
+    ) -> Result<abi::Function, anyhow::Error> {
+        let contract_name = self.expr.abi.to_string();
+        let function_name = self.expr.func.as_str();
+        let abi = mapping.find_abi(&contract_name)?;
+
+        // TODO: Handle overloaded functions
+        // Behavior for apiVersion < 0.0.4: look up function by name; for overloaded
+        // functions this always picks the same overloaded variant, which is incorrect
+        // and may lead to encoding/decoding errors
+        abi.contract
+            .function(function_name)
+            .and_then(|matches| matches.first())
+            .cloned()
+            .with_context(|| {
+                format!(
+                    "Unknown function \"{}::{}\" called from WASM runtime",
+                    contract_name, function_name
+                )
+            })
+    }
+
+    pub fn address_for_entity_handler(
+        &self,
+        entity: &EntitySourceOperation,
+    ) -> Result<Address, Error> {
+        match &self.expr.address {
+            // Static hex address - just return it directly
+            CallArg::HexAddress(address) => Ok(*address),
+
+            // Ethereum params not allowed here
+            CallArg::Ethereum(_) => Err(anyhow!(
+                "Ethereum params are not supported for entity handler calls"
+            )),
+
+            // Look up address from entity parameter
+            CallArg::Subgraph(SubgraphArg::EntityParam(name)) => {
+                // Get the value for this parameter
+                let value = entity
+                    .entity
+                    .get(name.as_str())
+                    .ok_or_else(|| anyhow!("entity missing required param '{name}'"))?;
+
+                // Make sure it's a bytes value and convert to address
+                match value {
+                    Value::Bytes(bytes) => {
+                        let address = Address::from_slice(bytes.as_slice());
+                        Ok(address)
+                    }
+                    _ => Err(anyhow!("param '{name}' must be an address")),
+                }
+            }
+        }
+    }
+
+    /// Processes arguments for an entity handler, converting them to the expected token types.
+    /// Returns an error if argument count mismatches or if conversion fails.
+    pub fn args_for_entity_handler(
+        &self,
+        entity: &EntitySourceOperation,
+        param_types: Vec<abi::DynSolType>,
+    ) -> Result<Vec<abi::DynSolValue>, Error> {
+        self.validate_entity_handler_args(&param_types)?;
+
+        self.expr
+            .args
+            .iter()
+            .zip(param_types)
+            .map(|(arg, expected_type)| {
+                self.process_entity_handler_arg(arg, &expected_type, entity)
+            })
+            .collect()
+    }
+
+    /// Validates that the number of provided arguments matches the expected parameter types.
+    fn validate_entity_handler_args(&self, param_types: &[abi::DynSolType]) -> Result<(), Error> {
+        if self.expr.args.len() != param_types.len() {
+            return Err(anyhow!(
+                "mismatched number of arguments: expected {}, got {}",
+                param_types.len(),
+                self.expr.args.len()
+            ));
+        }
+        Ok(())
+    }
+
+    /// Processes a single entity handler argument based on its type (HexAddress, Ethereum, or Subgraph).
+    /// Returns error for unsupported Ethereum params.
+    fn process_entity_handler_arg(
+        &self,
+        arg: &CallArg,
+        expected_type: &abi::DynSolType,
+        entity: &EntitySourceOperation,
+    ) -> Result<abi::DynSolValue, Error> {
+        match arg {
+            CallArg::HexAddress(address) => self.process_hex_address(*address, expected_type),
+            CallArg::Ethereum(_) => Err(anyhow!(
+                "Ethereum params are not supported for entity handler calls"
+            )),
+            CallArg::Subgraph(SubgraphArg::EntityParam(name)) => {
+                self.process_entity_param(name, expected_type, entity)
+            }
+        }
+    }
+
+    /// Converts a hex address to a token, ensuring it matches the expected parameter type.
+    fn process_hex_address(
+        &self,
+        address: Address,
+        expected_type: &abi::DynSolType,
+    ) -> Result<abi::DynSolValue, Error> {
+        match expected_type {
+            abi::DynSolType::Address => Ok(abi::DynSolValue::Address(address)),
+            _ => Err(anyhow!(
+                "type mismatch: hex address provided for non-address parameter"
+            )),
+        }
+    }
+
+    /// Retrieves and processes an entity parameter, converting it to the expected token type.
+    fn process_entity_param(
+        &self,
+        name: &str,
+        expected_type: &abi::DynSolType,
+        entity: &EntitySourceOperation,
+    ) -> Result<abi::DynSolValue, Error> {
+        let value = entity
+            .entity
+            .get(name)
+            .ok_or_else(|| anyhow!("entity missing required param '{name}'"))?;
+
+        self.convert_entity_value_to_token(value, expected_type, name)
+    }
+
+    /// Converts a `Value` to the appropriate `Token` type based on the expected parameter type.
+    /// Handles various type conversions including primitives, bytes, and arrays.
+    fn convert_entity_value_to_token(
+        &self,
+        value: &Value,
+        expected_type: &abi::DynSolType,
+        param_name: &str,
+    ) -> Result<abi::DynSolValue, Error> {
+        use abi::DynSolType;
+        use abi::DynSolValue;
+
+        match (expected_type, value) {
+            (DynSolType::Address, Value::Bytes(b)) => {
+                Ok(DynSolValue::Address(b.as_slice().try_into()?))
+            }
+            (DynSolType::Bytes, Value::Bytes(b)) => Ok(DynSolValue::Bytes(b.as_ref().to_vec())),
+            (DynSolType::FixedBytes(size), Value::Bytes(b)) if b.len() == *size => {
+                DynSolValue::fixed_bytes_from_slice(b.as_ref())
+            }
+            (DynSolType::String, Value::String(s)) => Ok(DynSolValue::String(s.to_string())),
+            (DynSolType::Bool, Value::Bool(b)) => Ok(DynSolValue::Bool(*b)),
+            (DynSolType::Int(_), Value::Int(i)) => {
+                let x = abi::I256::try_from(*i)?;
+                Ok(DynSolValue::Int(x, x.bits() as usize))
+            }
+            (DynSolType::Int(_), Value::Int8(i)) => {
+                let x = abi::I256::try_from(*i)?;
+                Ok(DynSolValue::Int(x, x.bits() as usize))
+            }
+            (DynSolType::Int(_), Value::BigInt(i)) => {
+                let x = i.to_i256()?;
+                Ok(DynSolValue::Int(x, x.bits() as usize))
+            }
+            (DynSolType::Uint(_), Value::Int(i)) if *i >= 0 => {
+                let x = U256::try_from(*i)?;
+                Ok(DynSolValue::Uint(x, x.bit_len()))
+            }
+            (DynSolType::Uint(_), Value::BigInt(i)) if i.sign() == Sign::Plus => {
+                let x = i.to_unsigned_u256()?;
+                Ok(DynSolValue::Uint(x, x.bit_len()))
+            }
+            (DynSolType::Array(inner_type), Value::List(values)) => {
+                self.process_entity_array_values(values, inner_type.as_ref(), param_name)
+            }
+            _ => Err(anyhow!(
+                "type mismatch for param '{param_name}': cannot convert {:?} to {:?}",
+                value,
+                expected_type
+            )),
+        }
+    }
+
+    fn process_entity_array_values(
+        &self,
+        values: &[Value],
+        inner_type: &abi::DynSolType,
+        param_name: &str,
+    ) -> Result<abi::DynSolValue, Error> {
+        let tokens: Result<Vec<abi::DynSolValue>, Error> = values
+            .iter()
+            .enumerate()
+            .map(|(idx, v)| {
+                self.convert_entity_value_to_token(v, inner_type, &format!("{param_name}[{idx}]"))
+            })
+            .collect();
+        Ok(abi::DynSolValue::Array(tokens?))
+    }
+
+    /// Extracts a nested field value from a struct parameter with mixed numeric/named access
+    fn extract_nested_struct_field_as_address(
+        struct_token: &abi::DynSolValue,
+        field_accesses: &[usize],
+        call_label: &str,
+    ) -> Result<Address, Error> {
+        let field_token =
+            Self::extract_nested_struct_field(struct_token, field_accesses, call_label)?;
+        let address = field_token.as_address().ok_or_else(|| {
+            anyhow!(
+                "In declarative call '{}': nested struct field is not an address",
+                call_label
+            )
+        })?;
+        Ok(address)
+    }
+
+    /// Extracts a nested field value from a struct parameter using numeric indices
+    fn extract_nested_struct_field(
+        struct_token: &abi::DynSolValue,
+        field_accesses: &[usize],
+        call_label: &str,
+    ) -> Result<abi::DynSolValue, Error> {
+        assert!(
+            !field_accesses.is_empty(),
+            "Internal error: empty field access path should be caught at parse time"
+        );
+
+        let mut current_token = struct_token;
+
+        for (index, &field_index) in field_accesses.iter().enumerate() {
+            match current_token {
+                abi::DynSolValue::Tuple(fields) => {
+                    let field_token = fields
+                        .get(field_index)
+                        .ok_or_else(|| {
+                            anyhow!(
+                                "In declarative call '{}': struct field index {} out of bounds (struct has {} fields) at access step {}",
+                                call_label, field_index, fields.len(), index
+                            )
+                        })?;
+
+                    // If this is the last field access, return the token
+                    if index == field_accesses.len() - 1 {
+                        return Ok(field_token.clone());
+                    }
+
+                    // Otherwise, continue with the next level
+                    current_token = field_token;
+                }
+                _ => {
+                    return Err(anyhow!(
+                        "In declarative call '{}': cannot access field on non-struct/tuple at access step {} (field path: {:?})",
+                        call_label,
+                        index,
+                        field_accesses
+                    ));
+                }
+            }
+        }
+
+        // This should never be reached due to empty check at the beginning
+        unreachable!()
+    }
+}
+
+/// Unresolved representation of declared calls stored as raw strings
+/// Used during initial manifest parsing before ABI context is available
+#[derive(Clone, CheapClone, Debug, Default, Eq, PartialEq)]
+#[non_exhaustive]
+pub struct UnresolvedCallDecls {
+    pub raw_decls: Arc<std::collections::HashMap<String, String>>,
+}
+
+impl UnresolvedCallDecls {
+    /// Parse the raw call declarations into CallDecls using ABI context
+    pub fn resolve(
+        self,
+        abi_json: &AbiJson,
+        event_signature: Option<&str>,
+        spec_version: &semver::Version,
+    ) -> Result<CallDecls, anyhow::Error> {
+        let decls: Result<Vec<CallDecl>, anyhow::Error> = self
+            .raw_decls
+            .iter()
+            .map(|(label, expr)| {
+                CallExpr::parse(expr, abi_json, event_signature, spec_version)
+                    .map(|expr| CallDecl {
+                        label: label.clone(),
+                        expr,
+                    })
+                    .with_context(|| format!("Error in declared call '{}':", label))
+            })
+            .collect();
+
+        Ok(CallDecls {
+            decls: Arc::new(decls?),
+        })
+    }
+
+    /// Check if the unresolved calls are empty
+    pub fn is_empty(&self) -> bool {
+        self.raw_decls.is_empty()
+    }
+}
+
+impl<'de> de::Deserialize<'de> for UnresolvedCallDecls {
+    fn deserialize<D>(deserializer: D) -> Result<UnresolvedCallDecls, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        let raw_decls: std::collections::HashMap<String, String> =
+            de::Deserialize::deserialize(deserializer)?;
+        Ok(UnresolvedCallDecls {
+            raw_decls: Arc::new(raw_decls),
+        })
+    }
+}
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+#[non_exhaustive]
+pub struct CallExpr {
+    pub abi: Word,
+    pub address: CallArg,
+    pub func: Word,
+    pub args: Vec<CallArg>,
+}
+
+impl CallExpr {
+    fn validate_args(&self) -> Result<(), anyhow::Error> {
+        // Consider address along with args for checking Ethereum/Subgraph mixing
+        let has_ethereum = matches!(self.address, CallArg::Ethereum(_))
+            || self
+                .args
+                .iter()
+                .any(|arg| matches!(arg, CallArg::Ethereum(_)));
+
+        let has_subgraph = matches!(self.address, CallArg::Subgraph(_))
+            || self
+                .args
+                .iter()
+                .any(|arg| matches!(arg, CallArg::Subgraph(_)));
+
+        if has_ethereum && has_subgraph {
+            return Err(anyhow!(
+                "Cannot mix Ethereum and Subgraph args in the same call expression"
+            ));
+        }
+
+        Ok(())
+    }
+
+    /// Parse a call expression with ABI context to resolve field names at parse time
+    pub fn parse(
+        s: &str,
+        abi_json: &AbiJson,
+        event_signature: Option<&str>,
+        spec_version: &semver::Version,
+    ) -> Result<Self, anyhow::Error> {
+        // Parse the expression manually to inject ABI context for field name resolution
+        // Format: Contract[address].function(arg1, arg2, ...)
+
+        // Find the contract name and opening bracket
+        let bracket_pos = s.find('[').ok_or_else(|| {
+            anyhow!(
+                "Invalid call expression '{}': missing '[' after contract name",
+                s
+            )
+        })?;
+        let abi = s[..bracket_pos].trim();
+
+        if abi.is_empty() {
+            return Err(anyhow!(
+                "Invalid call expression '{}': missing contract name before '['",
+                s
+            ));
+        }
+
+        // Find the closing bracket and extract the address part
+        let bracket_end = s.find(']').ok_or_else(|| {
+            anyhow!(
+                "Invalid call expression '{}': missing ']' to close address",
+                s
+            )
+        })?;
+        let address_str = &s[bracket_pos + 1..bracket_end];
+
+        if address_str.is_empty() {
+            return Err(anyhow!(
+                "Invalid call expression '{}': empty address in '{}[{}]'",
+                s,
+                abi,
+                address_str
+            ));
+        }
+
+        // Parse the address with ABI context
+        let address = CallArg::parse_with_abi(address_str, abi_json, event_signature, spec_version)
+            .with_context(|| {
+                format!(
+                    "Failed to parse address '{}' in call expression '{}'",
+                    address_str, s
+                )
+            })?;
+
+        // Find the function name and arguments
+        let dot_pos = s[bracket_end..].find('.').ok_or_else(|| {
+            anyhow!(
+                "Invalid call expression '{}': missing '.' after address '{}[{}]'",
+                s,
+                abi,
+                address_str
+            )
+        })?;
+        let func_start = bracket_end + dot_pos + 1;
+
+        let paren_pos = s[func_start..].find('(').ok_or_else(|| {
+            anyhow!(
+                "Invalid call expression '{}': missing '(' to start function arguments",
+                s
+            )
+        })?;
+        let func = &s[func_start..func_start + paren_pos];
+
+        if func.is_empty() {
+            return Err(anyhow!(
+                "Invalid call expression '{}': missing function name after '{}[{}].'",
+                s,
+                abi,
+                address_str
+            ));
+        }
+
+        // Find the closing parenthesis and extract arguments
+        let paren_end = s.rfind(')').ok_or_else(|| {
+            anyhow!(
+                "Invalid call expression '{}': missing ')' to close function arguments",
+                s
+            )
+        })?;
+        let args_str = &s[func_start + paren_pos + 1..paren_end];
+
+        // Parse arguments with ABI context
+        let mut args = Vec::new();
+        if !args_str.trim().is_empty() {
+            for (i, arg_str) in args_str.split(',').enumerate() {
+                let arg_str = arg_str.trim();
+                let arg = CallArg::parse_with_abi(arg_str, abi_json, event_signature, spec_version)
+                    .with_context(|| {
+                        format!(
+                            "Failed to parse argument {} '{}' in call expression '{}'",
+                            i + 1,
+                            arg_str,
+                            s
+                        )
+                    })?;
+                args.push(arg);
+            }
+        }
+
+        let expr = CallExpr {
+            abi: Word::from(abi),
+            address,
+            func: Word::from(func),
+            args,
+        };
+
+        expr.validate_args().with_context(|| {
+            format!(
+                "Invalid call expression '{}': argument validation failed",
+                s
+            )
+        })?;
+        Ok(expr)
+    }
+}
+/// Parse expressions of the form `Contract[address].function(arg1, arg2,
+/// ...)` where the `address` and the args are either `event.address` or
+/// `event.params.<name>`.
+///
+/// The parser is pretty awful as it generates error messages that aren't
+/// very helpful. We should replace all this with a real parser, most likely
+/// `combine` which is what `graphql_parser` uses
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub enum CallArg {
+    // Hard-coded hex address
+    HexAddress(Address),
+    // Ethereum-specific variants
+    Ethereum(EthereumArg),
+    // Subgraph datasource specific variants
+    Subgraph(SubgraphArg),
+}
+
+/// Information about struct field mappings extracted from ABI JSON components
+#[derive(Clone, Debug, PartialEq)]
+pub struct StructFieldInfo {
+    /// Original parameter name from the event
+    pub param_name: String,
+    /// Mapping from field names to their indices in the tuple
+    pub field_mappings: HashMap<String, usize>,
+    /// The alloy DynSolType for type validation
+    pub param_type: abi::DynSolType,
+}
+
+impl StructFieldInfo {
+    /// Create a new StructFieldInfo from ABI JSON components
+    pub fn from_components(
+        param_name: String,
+        param_type: abi::DynSolType,
+        components: &serde_json::Value,
+    ) -> Result<Self, Error> {
+        let mut field_mappings = HashMap::new();
+
+        if let Some(components_array) = components.as_array() {
+            for (index, component) in components_array.iter().enumerate() {
+                if let Some(field_name) = component.get("name").and_then(|n| n.as_str()) {
+                    field_mappings.insert(field_name.to_string(), index);
+                }
+            }
+        }
+
+        Ok(StructFieldInfo {
+            param_name,
+            field_mappings,
+            param_type,
+        })
+    }
+
+    /// Resolve a field name to its tuple index
+    pub fn resolve_field_name(&self, field_name: &str) -> Option<usize> {
+        self.field_mappings.get(field_name).copied()
+    }
+
+    /// Get all available field names
+    pub fn get_field_names(&self) -> Vec<String> {
+        let mut names: Vec<_> = self.field_mappings.keys().cloned().collect();
+        names.sort();
+        names
+    }
+}
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub enum EthereumArg {
+    Address,
+    Param(Word),
+    /// Struct field access with numeric indices (field names resolved at parse time)
+    StructField(Word, Vec<usize>),
+}
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub enum SubgraphArg {
+    EntityParam(Word),
+}
+
+lazy_static! {
+    // Matches a 40-character hexadecimal string prefixed with '0x', typical for Ethereum addresses
+    static ref ADDR_RE: Regex = Regex::new(r"^0x[0-9a-fA-F]{40}$").unwrap();
+}
+
+impl CallArg {
+    /// Parse a call argument with ABI context to resolve field names at parse time
+    pub fn parse_with_abi(
+        s: &str,
+        abi_json: &AbiJson,
+        event_signature: Option<&str>,
+        spec_version: &semver::Version,
+    ) -> Result<Self, anyhow::Error> {
+        // Handle hex addresses first
+        if ADDR_RE.is_match(s)
+            && let Ok(parsed_address) = Address::from_str(s)
+        {
+            return Ok(CallArg::HexAddress(parsed_address));
+        }
+
+        // Context validation
+        let starts_with_event = s.starts_with("event.");
+        let starts_with_entity = s.starts_with("entity.");
+
+        match event_signature {
+            None => {
+                // In entity handler context: forbid event.* expressions
+                if starts_with_event {
+                    return Err(anyhow!(
+                        "'event.*' expressions not allowed in entity handler context"
+                    ));
+                }
+            }
+            Some(_) => {
+                // In event handler context: require event.* expressions (or hex addresses)
+                if starts_with_entity {
+                    return Err(anyhow!(
+                        "'entity.*' expressions not allowed in event handler context"
+                    ));
+                }
+                if !starts_with_event && !ADDR_RE.is_match(s) {
+                    return Err(anyhow!(
+                        "In event handler context, only 'event.*' expressions and hex addresses are allowed"
+                    ));
+                }
+            }
+        }
+
+        let mut parts = s.split('.');
+        match (parts.next(), parts.next(), parts.next()) {
+            (Some("event"), Some("address"), None) => Ok(CallArg::Ethereum(EthereumArg::Address)),
+            (Some("event"), Some("params"), Some(param)) => {
+                // Check if there are any additional parts for struct field access
+                let remaining_parts: Vec<&str> = parts.collect();
+                if remaining_parts.is_empty() {
+                    // Simple parameter access: event.params.foo
+                    Ok(CallArg::Ethereum(EthereumArg::Param(Word::from(param))))
+                } else {
+                    // Struct field access: event.params.foo.bar.0.baz...
+                    // Validate spec version before allowing any struct field access
+                    if spec_version < &SPEC_VERSION_1_4_0 {
+                        return Err(anyhow!(
+                            "Struct field access 'event.params.{}.*' in declarative calls is only supported for specVersion >= 1.4.0, current version is {}. Event: '{}'",
+                            param,
+                            spec_version,
+                            event_signature.unwrap_or("unknown")
+                        ));
+                    }
+
+                    // Resolve field path - supports both numeric and named fields
+                    let field_indices = if let Some(signature) = event_signature {
+                        // Build field path: [param, field1, field2, ...]
+                        let mut field_path = vec![param];
+                        field_path.extend(remaining_parts.clone());
+
+                        let resolved_indices = abi_json
+                            .get_nested_struct_field_info(signature, &field_path)
+                            .with_context(|| {
+                                format!(
+                                    "Failed to resolve nested field path for event '{}', path '{}'",
+                                    signature,
+                                    field_path.join(".")
+                                )
+                            })?;
+
+                        match resolved_indices {
+                            Some(indices) => indices,
+                            None => {
+                                return Err(anyhow!(
+                                    "Cannot resolve field path 'event.params.{}' for event '{}'",
+                                    field_path.join("."),
+                                    signature
+                                ));
+                            }
+                        }
+                    } else {
+                        // No ABI context - only allow numeric indices
+                        let all_numeric = remaining_parts
+                            .iter()
+                            .all(|part| part.parse::<usize>().is_ok());
+                        if !all_numeric {
+                            return Err(anyhow!(
+                                "Field access 'event.params.{}.{}' requires event signature context for named field resolution",
+                                param,
+                                remaining_parts.join(".")
+                            ));
+                        }
+                        remaining_parts
+                            .into_iter()
+                            .map(|part| part.parse::<usize>())
+                            .collect::<Result<Vec<_>, _>>()
+                            .with_context(|| "Failed to parse numeric field indices".to_string())?
+                    };
+                    Ok(CallArg::Ethereum(EthereumArg::StructField(
+                        Word::from(param),
+                        field_indices,
+                    )))
+                }
+            }
+            (Some("entity"), Some(param), None) => Ok(CallArg::Subgraph(SubgraphArg::EntityParam(
+                Word::from(param),
+            ))),
+            _ => Err(anyhow!("invalid call argument `{}`", s)),
+        }
+    }
+}
+
+pub trait FindMappingABI {
+    fn find_abi(&self, abi_name: &str) -> Result<Arc<MappingABI>, Error>;
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct DeclaredCall {
+    /// The user-supplied label from the manifest
+    label: String,
+    contract_name: String,
+    address: Address,
+    function: abi::Function,
+    args: Vec<abi::DynSolValue>,
+}
+
+impl DeclaredCall {
+    pub fn from_log_trigger(
+        mapping: &dyn FindMappingABI,
+        call_decls: &CallDecls,
+        log: &alloy::rpc::types::Log,
+        params: &[abi::DynSolParam],
+    ) -> Result<Vec<DeclaredCall>, anyhow::Error> {
+        Self::from_log_trigger_with_event(mapping, call_decls, log, params)
+    }
+
+    pub fn from_log_trigger_with_event(
+        mapping: &dyn FindMappingABI,
+        call_decls: &CallDecls,
+        log: &Log,
+        params: &[abi::DynSolParam],
+    ) -> Result<Vec<DeclaredCall>, anyhow::Error> {
+        Self::create_calls(mapping, call_decls, |decl, _| {
+            Ok((
+                decl.address_for_log_with_abi(log, params)?,
+                decl.args_for_log_with_abi(log, params)?,
+            ))
+        })
+    }
+
+    pub fn from_entity_trigger(
+        mapping: &dyn FindMappingABI,
+        call_decls: &CallDecls,
+        entity: &EntitySourceOperation,
+    ) -> Result<Vec<DeclaredCall>, Error> {
+        Self::create_calls(mapping, call_decls, |decl, function| {
+            let param_types = function
+                .inputs
+                .iter()
+                .map(|param| param.selector_type().parse())
+                .collect::<Result<Vec<_>, _>>()?;
+
+            Ok((
+                decl.address_for_entity_handler(entity)?,
+                decl.args_for_entity_handler(entity, param_types)
+                    .context(format!(
+                        "Failed to parse arguments for call to function \"{}\" of contract \"{}\"",
+                        decl.expr.func.as_str(),
+                        decl.expr.abi
+                    ))?,
+            ))
+        })
+    }
+
+    fn create_calls<F>(
+        mapping: &dyn FindMappingABI,
+        call_decls: &CallDecls,
+        get_address_and_args: F,
+    ) -> Result<Vec<DeclaredCall>, anyhow::Error>
+    where
+        F: Fn(&CallDecl, &abi::Function) -> Result<(Address, Vec<abi::DynSolValue>), anyhow::Error>,
+    {
+        let mut calls = Vec::new();
+        for decl in call_decls.decls.iter() {
+            let contract_name = decl.expr.abi.to_string();
+            let function = decl.get_function(mapping)?;
+            let (address, args) = get_address_and_args(decl, &function)?;
+
+            calls.push(DeclaredCall {
+                label: decl.label.clone(),
+                contract_name,
+                address,
+                function: function.clone(),
+                args,
+            });
+        }
+        Ok(calls)
+    }
+
+    pub fn as_eth_call(self, block_ptr: BlockPtr, gas: Option<u32>) -> (ContractCall, String) {
+        (
+            ContractCall {
+                contract_name: self.contract_name,
+                address: self.address,
+                block_ptr,
+                function: self.function,
+                args: self.args,
+                gas,
+            },
+            self.label,
+        )
+    }
+}
+#[derive(Clone, Debug)]
+pub struct ContractCall {
+    pub contract_name: String,
+    pub address: Address,
+    pub block_ptr: BlockPtr,
+    pub function: abi::Function,
+    pub args: Vec<abi::DynSolValue>,
+    pub gas: Option<u32>,
+}
+
+#[cfg(test)]
+mod tests {
+    use alloy::primitives::B256;
+
+    use crate::data::subgraph::SPEC_VERSION_1_3_0;
+
+    use super::*;
+
+    const EV_TRANSFER: Option<&str> = Some("Transfer(address,tuple)");
+    const EV_COMPLEX_ASSET: Option<&str> =
+        Some("ComplexAssetCreated(((address,uint256,bool),string,uint256[]),uint256)");
+
+    /// Test helper for parsing CallExpr expressions with predefined ABI and
+    /// event context.
+    ///
+    /// This struct simplifies testing by providing a fluent API for parsing
+    /// call expressions with the test ABI (from
+    /// `create_test_mapping_abi()`). It handles three main contexts:
+    /// - Event handler context with Transfer event (default)
+    /// - Event handler context with ComplexAssetCreated event
+    ///   (`for_complex_asset()`)
+    /// - Entity handler context with no event (`for_subgraph()`)
+    ///
+    /// # Examples
+    /// ```ignore
+    /// let parser = ExprParser::new();
+    /// // Parse and expect success
+    /// let expr = parser.ok("Contract[event.params.asset.addr].test()");
+    ///
+    /// // Parse and expect error, get error message
+    /// let error_msg = parser.err("Contract[invalid].test()");
+    ///
+    /// // Test with different spec version
+    /// let result = parser.parse_with_version(expr, &old_version);
+    ///
+    /// // Test entity handler context
+    /// let entity_parser = ExprParser::new().for_subgraph();
+    /// let expr = entity_parser.ok("Contract[entity.addr].test()");
+    /// ```
+    struct ExprParser {
+        abi: super::AbiJson,
+        event: Option<String>,
+    }
+
+    impl ExprParser {
+        /// Creates a new parser with the test ABI and Transfer event context
+        fn new() -> Self {
+            let abi = create_test_mapping_abi();
+            Self {
+                abi,
+                event: EV_TRANSFER.map(|s| s.to_string()),
+            }
+        }
+
+        /// Switches to entity handler context (no event signature)
+        fn for_subgraph(mut self) -> Self {
+            self.event = None;
+            self
+        }
+
+        /// Switches to ComplexAssetCreated event context for testing nested
+        /// structs
+        fn for_complex_asset(mut self) -> Self {
+            self.event = EV_COMPLEX_ASSET.map(|s| s.to_string());
+            self
+        }
+
+        /// Parses an expression using the default spec version (1.4.0)
+        fn parse(&self, expression: &str) -> Result<CallExpr, Error> {
+            self.parse_with_version(expression, &SPEC_VERSION_1_4_0)
+        }
+
+        /// Parses an expression with a specific spec version for testing
+        /// version compatibility
+        fn parse_with_version(
+            &self,
+            expression: &str,
+            spec_version: &semver::Version,
+        ) -> Result<CallExpr, Error> {
+            CallExpr::parse(expression, &self.abi, self.event.as_deref(), spec_version)
+        }
+
+        /// Parses an expression and panics if it fails, returning the
+        /// parsed CallExpr. Use this when the expression is expected to
+        /// parse successfully.
+        #[track_caller]
+        fn ok(&self, expression: &str) -> CallExpr {
+            let result = self.parse(expression);
+            assert!(
+                result.is_ok(),
+                "Expression '{}' should have parsed successfully: {:#}",
+                expression,
+                result.unwrap_err()
+            );
+            result.unwrap()
+        }
+
+        /// Parses an expression and panics if it succeeds, returning the
+        /// error message. Use this when testing error cases and you want to
+        /// verify the error message.
+        #[track_caller]
+        fn err(&self, expression: &str) -> String {
+            match self.parse(expression) {
+                Ok(expr) => {
+                    panic!(
+                        "Expression '{}' should have failed to parse but yielded {:#?}",
+                        expression, expr
+                    );
+                }
+                Err(e) => {
+                    format!("{:#}", e)
+                }
+            }
+        }
+    }
+
+    /// Test helper for parsing CallArg expressions with the test ABI.
+    ///
+    /// This struct is specifically for testing argument parsing (e.g.,
+    /// `event.params.asset.addr`) as opposed to full call expressions. It
+    /// uses the same test ABI as ExprParser.
+    ///
+    /// # Examples
+    /// ```ignore
+    /// let parser = ArgParser::new();
+    /// // Parse an event parameter argument
+    /// let arg = parser.ok("event.params.asset.addr", Some("Transfer(address,tuple)"));
+    ///
+    /// // Test entity context argument
+    /// let arg = parser.ok("entity.contractAddress", None);
+    ///
+    /// // Test error cases
+    /// let error = parser.err("invalid.arg", Some("Transfer(address,tuple)"));
+    /// ```
+    struct ArgParser {
+        abi: super::AbiJson,
+    }
+
+    impl ArgParser {
+        /// Creates a new argument parser with the test ABI
+        fn new() -> Self {
+            let abi = create_test_mapping_abi();
+            Self { abi }
+        }
+
+        /// Parses a call argument with optional event signature context
+        fn parse(&self, expression: &str, event_signature: Option<&str>) -> Result<CallArg, Error> {
+            CallArg::parse_with_abi(expression, &self.abi, event_signature, &SPEC_VERSION_1_4_0)
+        }
+
+        /// Parses an argument and panics if it fails, returning the parsed
+        /// CallArg. Use this when the argument is expected to parse
+        /// successfully.
+        fn ok(&self, expression: &str, event_signature: Option<&str>) -> CallArg {
+            let result = self.parse(expression, event_signature);
+            assert!(
+                result.is_ok(),
+                "Expression '{}' should have parsed successfully: {}",
+                expression,
+                result.unwrap_err()
+            );
+            result.unwrap()
+        }
+
+        /// Parses an argument and panics if it succeeds, returning the
+        /// error message. Use this when testing error cases and you want to
+        /// verify the error message.
+        fn err(&self, expression: &str, event_signature: Option<&str>) -> String {
+            match self.parse(expression, event_signature) {
+                Ok(arg) => {
+                    panic!(
+                        "Expression '{}' should have failed to parse but yielded {:#?}",
+                        expression, arg
+                    );
+                }
+                Err(e) => {
+                    format!("{:#}", e)
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_ethereum_call_expr() {
+        let parser = ExprParser::new();
+        let expr: CallExpr = parser.ok("ERC20[event.address].balanceOf(event.params.token)");
+        assert_eq!(expr.abi, "ERC20");
+        assert_eq!(expr.address, CallArg::Ethereum(EthereumArg::Address));
+        assert_eq!(expr.func, "balanceOf");
+        assert_eq!(
+            expr.args,
+            vec![CallArg::Ethereum(EthereumArg::Param("token".into()))]
+        );
+
+        let expr: CallExpr =
+            parser.ok("Pool[event.params.pool].fees(event.params.token0, event.params.token1)");
+        assert_eq!(expr.abi, "Pool");
+        assert_eq!(
+            expr.address,
+            CallArg::Ethereum(EthereumArg::Param("pool".into()))
+        );
+        assert_eq!(expr.func, "fees");
+        assert_eq!(
+            expr.args,
+            vec![
+                CallArg::Ethereum(EthereumArg::Param("token0".into())),
+                CallArg::Ethereum(EthereumArg::Param("token1".into()))
+            ]
+        );
+    }
+
+    #[test]
+    fn test_subgraph_call_expr() {
+        let parser = ExprParser::new().for_subgraph();
+
+        let expr: CallExpr = parser.ok("Token[entity.id].symbol()");
+        assert_eq!(expr.abi, "Token");
+        assert_eq!(
+            expr.address,
+            CallArg::Subgraph(SubgraphArg::EntityParam("id".into()))
+        );
+        assert_eq!(expr.func, "symbol");
+        assert_eq!(expr.args, vec![]);
+
+        let expr: CallExpr = parser.ok("Pair[entity.pair].getReserves(entity.token0)");
+        assert_eq!(expr.abi, "Pair");
+        assert_eq!(
+            expr.address,
+            CallArg::Subgraph(SubgraphArg::EntityParam("pair".into()))
+        );
+        assert_eq!(expr.func, "getReserves");
+        assert_eq!(
+            expr.args,
+            vec![CallArg::Subgraph(SubgraphArg::EntityParam("token0".into()))]
+        );
+    }
+
+    #[test]
+    fn test_hex_address_call_expr() {
+        let parser = ExprParser::new();
+
+        let addr = "0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF";
+        let hex_address = CallArg::HexAddress(Address::from_str(addr).unwrap());
+
+        // Test HexAddress in address position
+        let expr: CallExpr = parser.ok(&format!("Pool[{}].growth()", addr));
+        assert_eq!(expr.abi, "Pool");
+        assert_eq!(expr.address, hex_address.clone());
+        assert_eq!(expr.func, "growth");
+        assert_eq!(expr.args, vec![]);
+
+        // Test HexAddress in argument position
+        let expr: CallExpr = parser.ok(&format!(
+            "Pool[event.address].approve({}, event.params.amount)",
+            addr
+        ));
+        assert_eq!(expr.abi, "Pool");
+        assert_eq!(expr.address, CallArg::Ethereum(EthereumArg::Address));
+        assert_eq!(expr.func, "approve");
+        assert_eq!(expr.args.len(), 2);
+        assert_eq!(expr.args[0], hex_address);
+    }
+
+    #[test]
+    fn test_invalid_call_args() {
+        let parser = ArgParser::new();
+        // Invalid hex address
+        parser.err("Pool[0xinvalid].test()", EV_TRANSFER);
+
+        // Invalid event path
+        parser.err("Pool[event.invalid].test()", EV_TRANSFER);
+
+        // Invalid entity path
+        parser.err("Pool[entity].test()", EV_TRANSFER);
+
+        // Empty address
+        parser.err("Pool[].test()", EV_TRANSFER);
+
+        // Invalid parameter format
+        parser.err("Pool[event.params].test()", EV_TRANSFER);
+    }
+
+    #[test]
+    fn test_simple_args() {
+        let parser = ArgParser::new();
+
+        // Test valid hex address
+        let addr = "0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF";
+        let arg = parser.ok(addr, EV_TRANSFER);
+        assert!(matches!(arg, CallArg::HexAddress(_)));
+
+        // Test Ethereum Address
+        let arg = parser.ok("event.address", EV_TRANSFER);
+        assert!(matches!(arg, CallArg::Ethereum(EthereumArg::Address)));
+
+        // Test Ethereum Param
+        let arg = parser.ok("event.params.token", EV_TRANSFER);
+        assert!(matches!(arg, CallArg::Ethereum(EthereumArg::Param(_))));
+
+        // Test Subgraph EntityParam
+        let arg = parser.ok("entity.token", None);
+        assert!(matches!(
+            arg,
+            CallArg::Subgraph(SubgraphArg::EntityParam(_))
+        ));
+    }
+
+    #[test]
+    fn test_struct_field_access_functions() {
+        use crate::abi::DynSolValue;
+        use alloy::primitives::{Address, U256};
+
+        let parser = ExprParser::new();
+
+        let tuple_fields = vec![
+            DynSolValue::Uint(U256::from(8u8), 8), // index 0: uint8
+            DynSolValue::Address(Address::from([1u8; 20])), // index 1: address
+            DynSolValue::Uint(U256::from(1000u64), 256), // index 2: uint256
+        ];
+
+        // Test extract_struct_field with numeric indices
+        let struct_token = DynSolValue::Tuple(tuple_fields.clone());
+
+        // Test accessing index 0 (uint8)
+        let result =
+            CallDecl::extract_nested_struct_field(&struct_token, &[0], "testCall").unwrap();
+        assert_eq!(result, tuple_fields[0]);
+
+        // Test accessing index 1 (address)
+        let result =
+            CallDecl::extract_nested_struct_field(&struct_token, &[1], "testCall").unwrap();
+        assert_eq!(result, tuple_fields[1]);
+
+        // Test accessing index 2 (uint256)
+        let result =
+            CallDecl::extract_nested_struct_field(&struct_token, &[2], "testCall").unwrap();
+        assert_eq!(result, tuple_fields[2]);
+
+        // Test that it works in a declarative call context
+        let expr: CallExpr = parser.ok("ERC20[event.params.asset.1].name()");
+        assert_eq!(expr.abi, "ERC20");
+        assert_eq!(
+            expr.address,
+            CallArg::Ethereum(EthereumArg::StructField("asset".into(), vec![1]))
+        );
+        assert_eq!(expr.func, "name");
+        assert_eq!(expr.args, vec![]);
+    }
+
+    #[test]
+    fn test_invalid_struct_field_parsing() {
+        let parser = ArgParser::new();
+        // Test invalid patterns
+        parser.err("event.params", EV_TRANSFER);
+        parser.err("event.invalid.param.field", EV_TRANSFER);
+    }
+
+    #[test]
+    fn test_declarative_call_error_context() {
+        use crate::abi::{DynSolParam, DynSolValue};
+        use alloy::primitives::U256;
+        use alloy::rpc::types::Log;
+
+        let parser = ExprParser::new();
+
+        // Create a test call declaration
+        let call_decl = CallDecl {
+            label: "myTokenCall".to_string(),
+            expr: parser.ok("ERC20[event.params.asset.1].name()"),
+        };
+
+        // Test scenario 1: Unknown parameter
+        let inner_log = alloy::primitives::Log {
+            address: Address::ZERO,
+            data: alloy::primitives::LogData::new_unchecked(vec![], vec![].into()),
+        };
+        let log = Log {
+            inner: inner_log,
+            block_hash: Some(B256::ZERO),
+            block_number: Some(1),
+            block_timestamp: None,
+            transaction_hash: Some(B256::ZERO),
+            transaction_index: Some(0),
+            log_index: Some(0),
+            removed: false,
+        };
+        let params = vec![]; // Empty params - 'asset' param is missing
+
+        let result = call_decl.address_for_log(&log, &params);
+        assert!(result.is_err());
+        let error_msg = result.unwrap_err().to_string();
+        assert!(error_msg.contains("In declarative call 'myTokenCall'"));
+        assert!(error_msg.contains("unknown param asset"));
+
+        // Test scenario 2: Struct field access error
+        let params = vec![DynSolParam {
+            name: "asset".to_string(),
+            value: DynSolValue::Tuple(vec![DynSolValue::Uint(U256::from(1u8), 8)]), // Only 1 field, but trying to access index 1
+        }];
+
+        let result = call_decl.address_for_log(&log, &params);
+        assert!(result.is_err());
+        let error_msg = result.unwrap_err().to_string();
+        assert!(error_msg.contains("In declarative call 'myTokenCall'"));
+        assert!(error_msg.contains("out of bounds"));
+        assert!(error_msg.contains("struct has 1 fields"));
+
+        // Test scenario 3: Non-address field access
+        let params = vec![DynSolParam {
+            name: "asset".to_string(),
+            value: DynSolValue::Tuple(vec![
+                DynSolValue::Uint(U256::from(1u8), 8),
+                DynSolValue::Uint(U256::from(2u8), 8), // Index 1 is uint, not address
+            ]),
+        }];
+
+        let result = call_decl.address_for_log(&log, &params);
+        assert!(result.is_err());
+        let error_msg = result.unwrap_err().to_string();
+        assert!(error_msg.contains("In declarative call 'myTokenCall'"));
+        assert!(error_msg.contains("nested struct field is not an address"));
+
+        // Test scenario 4: Field index out of bounds is caught at parse time
+        let parser = parser.for_complex_asset();
+        let error_msg =
+            parser.err("ERC20[event.address].transfer(event.params.complexAsset.base.3)");
+        assert!(error_msg.contains("Index 3 out of bounds for struct with 3 fields"));
+
+        // Test scenario 5: Runtime struct field extraction error - out of bounds
+        let expr = parser.ok("ERC20[event.address].transfer(event.params.complexAsset.base.2)");
+        let call_decl_with_args = CallDecl {
+            label: "transferCall".to_string(),
+            expr,
+        };
+
+        // Create a structure where base has only 2 fields instead of 3
+        // The parser thinks there should be 3 fields based on ABI, but at runtime we provide only 2
+        let base_struct = DynSolValue::Tuple(vec![
+            DynSolValue::Address(Address::from([1u8; 20])), // addr at index 0
+            DynSolValue::Uint(U256::from(100u64), 256),     // amount at index 1
+                                                            // Missing the active field at index 2!
+        ]);
+
+        let params = vec![DynSolParam {
+            name: "complexAsset".to_string(),
+            value: DynSolValue::Tuple(vec![
+                base_struct,                                 // base with only 2 fields
+                DynSolValue::String("metadata".to_string()), // metadata at index 1
+                DynSolValue::Array(vec![]),                  // values at index 2
+            ]),
+        }];
+
+        let result = call_decl_with_args.args_for_log(&log, &params);
+        assert!(result.is_err());
+        let error_msg = result.unwrap_err().to_string();
+        assert!(error_msg.contains("In declarative call 'transferCall'"));
+        assert!(error_msg.contains("out of bounds"));
+        assert!(error_msg.contains("struct has 2 fields"));
+    }
+
+    #[test]
+    fn test_struct_field_extraction_comprehensive() {
+        use crate::abi::DynSolValue;
+        use alloy::primitives::{Address, U256};
+
+        // Create a complex nested structure for comprehensive testing:
+        // struct Asset {
+        //   uint8 kind;          // index 0
+        //   Token token;         // index 1 (nested struct)
+        //   uint256 amount;      // index 2
+        // }
+        // struct Token {
+        //   address addr;        // index 0
+        //   string name;         // index 1
+        // }
+        let inner_struct = DynSolValue::Tuple(vec![
+            DynSolValue::Address(Address::from([0x42; 20])), // token.addr
+            DynSolValue::String("TokenName".to_string()),    // token.name
+        ]);
+
+        let outer_struct = DynSolValue::Tuple(vec![
+            DynSolValue::Uint(U256::from(1u8), 8),       // asset.kind
+            inner_struct,                                // asset.token
+            DynSolValue::Uint(U256::from(1000u64), 256), // asset.amount
+        ]);
+
+        // Test cases: (path, expected_value, description)
+        let test_cases = vec![
+            (
+                vec![0],
+                DynSolValue::Uint(U256::from(1u8), 8),
+                "Simple field access",
+            ),
+            (
+                vec![1, 0],
+                DynSolValue::Address(Address::from([0x42; 20])),
+                "Nested field access",
+            ),
+            (
+                vec![1, 1],
+                DynSolValue::String("TokenName".to_string()),
+                "Nested string field",
+            ),
+            (
+                vec![2],
+                DynSolValue::Uint(U256::from(1000u64), 256),
+                "Last field access",
+            ),
+        ];
+
+        for (path, expected, description) in test_cases {
+            let result = CallDecl::extract_nested_struct_field(&outer_struct, &path, "testCall")
+                .unwrap_or_else(|e| panic!("Failed {}: {}", description, e));
+            assert_eq!(result, expected, "Failed: {}", description);
+        }
+
+        // Test error cases
+        let error_cases = vec![
+            (vec![3], "out of bounds (struct has 3 fields)"),
+            (vec![1, 2], "struct has 2 fields"),
+            (vec![0, 0], "cannot access field on non-struct/tuple"),
+        ];
+
+        for (path, expected_error) in error_cases {
+            let result = CallDecl::extract_nested_struct_field(&outer_struct, &path, "testCall");
+            assert!(result.is_err(), "Expected error for path: {:?}", path);
+            let error_msg = result.unwrap_err().to_string();
+            assert!(
+                error_msg.contains(expected_error),
+                "Error message should contain '{}'. Got: {}",
+                expected_error,
+                error_msg
+            );
+        }
+    }
+
+    #[test]
+    fn test_abi_aware_named_field_resolution() {
+        let parser = ExprParser::new();
+
+        // Test 1: Named field resolution with ABI context
+        let expr = parser.ok("TestContract[event.params.asset.addr].name()");
+
+        assert_eq!(expr.abi, "TestContract");
+        assert_eq!(
+            expr.address,
+            CallArg::Ethereum(EthereumArg::StructField("asset".into(), vec![0])) // addr -> 0
+        );
+        assert_eq!(expr.func, "name");
+        assert_eq!(expr.args, vec![]);
+
+        // Test 2: Mixed named and numeric access in arguments
+        let expr = parser.ok(
+            "TestContract[event.address].transfer(event.params.asset.amount, event.params.asset.1)",
+        );
+
+        assert_eq!(expr.abi, "TestContract");
+        assert_eq!(expr.address, CallArg::Ethereum(EthereumArg::Address));
+        assert_eq!(expr.func, "transfer");
+        assert_eq!(
+            expr.args,
+            vec![
+                CallArg::Ethereum(EthereumArg::StructField("asset".into(), vec![1])), // amount -> 1
+                CallArg::Ethereum(EthereumArg::StructField("asset".into(), vec![1])), // numeric 1
+            ]
+        );
+    }
+
+    #[test]
+    fn test_abi_aware_error_handling() {
+        let parser = ExprParser::new();
+
+        // Test 1: Invalid field name provides helpful suggestions
+        let error_msg = parser.err("TestContract[event.params.asset.invalid].name()");
+        assert!(error_msg.contains("Field 'invalid' not found"));
+        assert!(error_msg.contains("Available fields:"));
+
+        // Test 2: Named field access without event context
+        let error_msg = parser
+            .for_subgraph()
+            .err("TestContract[event.params.asset.addr].name()");
+        assert!(error_msg.contains("'event.*' expressions not allowed in entity handler context"));
+    }
+
+    #[test]
+    fn test_parse_function_error_messages() {
+        const SV: &semver::Version = &SPEC_VERSION_1_4_0;
+        const EV: Option<&str> = Some("Test()");
+
+        // Create a minimal ABI for testing
+        let abi_json = r#"[{"anonymous": false, "inputs": [], "name": "Test", "type": "event"}]"#;
+        let abi_json_helper = AbiJson::new(abi_json.as_bytes()).unwrap();
+
+        let parse = |expr: &str| {
+            let result = CallExpr::parse(expr, &abi_json_helper, EV, SV);
+            assert!(
+                result.is_err(),
+                "Expression {} should have failed to parse",
+                expr
+            );
+            result.unwrap_err().to_string()
+        };
+
+        // Test 1: Missing opening bracket
+        let error_msg = parse("TestContract event.address].test()");
+        assert!(error_msg.contains("Invalid call expression"));
+        assert!(error_msg.contains("missing '[' after contract name"));
+
+        // Test 2: Missing closing bracket
+        let error_msg = parse("TestContract[event.address.test()");
+        assert!(error_msg.contains("missing ']' to close address"));
+
+        // Test 3: Empty contract name
+        let error_msg = parse("[event.address].test()");
+        assert!(error_msg.contains("missing contract name before '['"));
+
+        // Test 4: Empty address
+        let error_msg = parse("TestContract[].test()");
+        assert!(error_msg.contains("empty address"));
+
+        // Test 5: Missing function name
+        let error_msg = parse("TestContract[event.address].()");
+        assert!(error_msg.contains("missing function name"));
+
+        // Test 6: Missing opening parenthesis
+        let error_msg = parse("TestContract[event.address].test");
+        assert!(error_msg.contains("missing '(' to start function arguments"));
+
+        // Test 7: Missing closing parenthesis
+        let error_msg = parse("TestContract[event.address].test(");
+        assert!(error_msg.contains("missing ')' to close function arguments"));
+
+        // Test 8: Invalid argument should show argument position
+        let error_msg = parse("TestContract[event.address].test(invalid.arg)");
+        assert!(error_msg.contains("Failed to parse argument 1"));
+        assert!(error_msg.contains("'invalid.arg'"));
+    }
+
+    #[test]
+    fn test_call_expr_abi_context_comprehensive() {
+        // Comprehensive test for CallExpr parsing with ABI context
+        let parser = ExprParser::new().for_complex_asset();
+
+        // Test 1: Parse-time field name resolution
+        let expr = parser.ok("Contract[event.params.complexAsset.base.addr].test()");
+        assert_eq!(
+            expr.address,
+            CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 0]))
+        );
+
+        // Test 2: Mixed named and numeric field access
+        let expr = parser.ok(
+            "Contract[event.address].test(event.params.complexAsset.0.1, event.params.complexAsset.base.active)"
+        );
+        assert_eq!(
+            expr.args,
+            vec![
+                CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 1])), // base.amount
+                CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 2])), // base.active
+            ]
+        );
+
+        // Test 3: Error - Invalid field name with helpful suggestions
+        let error_msg = parser.err("Contract[event.params.complexAsset.invalid].test()");
+        assert!(error_msg.contains("Field 'invalid' not found"));
+        // Check that it mentions available fields (the exact format may vary)
+        assert!(
+            error_msg.contains("base")
+                && error_msg.contains("metadata")
+                && error_msg.contains("values")
+        );
+
+        // Test 4: Error - Accessing nested field on non-struct
+        let error_msg = parser.err("Contract[event.params.complexAsset.metadata.something].test()");
+        assert!(error_msg.contains("is not a struct"));
+
+        // Test 5: Error - Out of bounds numeric access
+        let error_msg = parser.err("Contract[event.params.complexAsset.3].test()");
+        assert!(error_msg.contains("out of bounds"));
+
+        // Test 6: Deep nesting with mixed access
+        let expr = parser.ok(
+            "Contract[event.params.complexAsset.base.0].test(event.params.complexAsset.0.amount)",
+        );
+        assert_eq!(
+            expr.address,
+            CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 0])) // base.addr
+        );
+        assert_eq!(
+            expr.args,
+            vec![
+                CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 1])) // base.amount
+            ]
+        );
+
+        // Test 7: Version check - struct field access requires v1.4.0+
+        let result = parser.parse_with_version(
+            "Contract[event.params.complexAsset.base.addr].test()",
+            &SPEC_VERSION_1_3_0,
+        );
+        assert!(result.is_err());
+        let error_msg = format!("{:#}", result.unwrap_err());
+        assert!(error_msg.contains("only supported for specVersion >= 1.4.0"));
+
+        // Test 8: Entity handler context - no event.* expressions allowed
+        let entity_parser = ExprParser::new().for_subgraph();
+        let error_msg = entity_parser.err("Contract[event.params.something].test()");
+        assert!(error_msg.contains("'event.*' expressions not allowed in entity handler context"));
+
+        // Test 9: Successful entity handler expression
+        let expr = entity_parser.ok("Contract[entity.contractAddress].test(entity.amount)");
+        assert!(matches!(expr.address, CallArg::Subgraph(_)));
+        assert!(matches!(expr.args[0], CallArg::Subgraph(_)));
+    }
+
+    #[test]
+    fn complex_asset() {
+        let parser = ExprParser::new().for_complex_asset();
+
+        // Test 1: All named field access: event.params.complexAsset.base.addr
+        let expr =
+            parser.ok("Contract[event.address].getMetadata(event.params.complexAsset.base.addr)");
+        assert_eq!(
+            expr.args[0],
+            CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 0])) // base=0, addr=0
+        );
+
+        // Test 2: All numeric field access: event.params.complexAsset.0.0
+        let expr = parser.ok("Contract[event.address].getMetadata(event.params.complexAsset.0.0)");
+        assert_eq!(
+            expr.args[0],
+            CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 0]))
+        );
+
+        // Test 3: Mixed access - numeric then named: event.params.complexAsset.0.addr
+        let expr = parser.ok("Contract[event.address].transfer(event.params.complexAsset.0.addr)");
+        assert_eq!(
+            expr.args[0],
+            CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 0])) // 0=base, addr=0
+        );
+
+        // Test 4: Mixed access - named then numeric: event.params.complexAsset.base.1
+        let expr =
+            parser.ok("Contract[event.address].updateAmount(event.params.complexAsset.base.1)");
+        assert_eq!(
+            expr.args[0],
+            CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 1])) // base=0, 1=amount
+        );
+
+        // Test 5: Access non-nested field by name: event.params.complexAsset.metadata
+        let expr =
+            parser.ok("Contract[event.address].setMetadata(event.params.complexAsset.metadata)");
+        assert_eq!(
+            expr.args[0],
+            CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![1])) // metadata=1
+        );
+
+        // Test 6: Error case - invalid field name
+        let error_msg =
+            parser.err("Contract[event.address].test(event.params.complexAsset.invalid)");
+        assert!(error_msg.contains("Field 'invalid' not found"));
+
+        // Test 7: Error case - accessing nested field on non-tuple
+        let error_msg = parser
+            .err("Contract[event.address].test(event.params.complexAsset.metadata.something)");
+        assert!(error_msg.contains("is not a struct"));
+    }
+
+    #[test]
+    fn test_normalize_abi_json_with_undefined_state_mutability() {
+        let abi_with_undefined = r#"[
+            {
+                "type": "function",
+                "name": "testFunction",
+                "inputs": [],
+                "outputs": [],
+                "stateMutability": "undefined"
+            },
+            {
+                "type": "function",
+                "name": "normalFunction",
+                "inputs": [],
+                "outputs": [],
+                "stateMutability": "view"
+            }
+        ]"#;
+
+        let normalized = normalize_abi_json(abi_with_undefined.as_bytes()).unwrap();
+        let result: serde_json::Value = serde_json::from_slice(&normalized).unwrap();
+
+        if let Some(array) = result.as_array() {
+            assert_eq!(array[0]["stateMutability"], "nonpayable");
+            assert_eq!(array[1]["stateMutability"], "view");
+        } else {
+            panic!("Expected JSON array");
+        }
+
+        let json_abi: abi::JsonAbi = serde_json::from_slice(&normalized).unwrap();
+        assert_eq!(json_abi.len(), 2);
+    }
+
+    #[test]
+    fn test_normalize_abi_json_with_duplicate_constructors() {
+        let abi_with_duplicate_constructors = r#"[
+            {
+                "type": "constructor",
+                "inputs": [{"name": "param1", "type": "address"}],
+                "stateMutability": "nonpayable"
+            },
+            {
+                "type": "function",
+                "name": "someFunction",
+                "inputs": [],
+                "outputs": [],
+                "stateMutability": "view"
+            },
+            {
+                "type": "constructor",
+                "inputs": [{"name": "param2", "type": "uint256"}],
+                "stateMutability": "nonpayable"
+            }
+        ]"#;
+
+        let normalized = normalize_abi_json(abi_with_duplicate_constructors.as_bytes()).unwrap();
+        let result: serde_json::Value = serde_json::from_slice(&normalized).unwrap();
+
+        if let Some(array) = result.as_array() {
+            assert_eq!(array.len(), 2);
+            assert_eq!(array[0]["type"], "constructor");
+            assert_eq!(array[0]["inputs"][0]["name"], "param1");
+            assert_eq!(array[1]["type"], "function");
+        } else {
+            panic!("Expected JSON array");
+        }
+
+        let json_abi: abi::JsonAbi = serde_json::from_slice(&normalized).unwrap();
+        assert_eq!(json_abi.len(), 2);
+    }
+
+    #[test]
+    fn test_normalize_abi_json_with_duplicate_fallbacks() {
+        let abi_with_duplicate_fallbacks = r#"[
+            {
+                "type": "fallback",
+                "stateMutability": "payable"
+            },
+            {
+                "type": "function",
+                "name": "someFunction",
+                "inputs": [],
+                "outputs": [],
+                "stateMutability": "view"
+            },
+            {
+                "type": "fallback",
+                "stateMutability": "nonpayable"
+            }
+        ]"#;
+
+        let normalized = normalize_abi_json(abi_with_duplicate_fallbacks.as_bytes()).unwrap();
+        let result: serde_json::Value = serde_json::from_slice(&normalized).unwrap();
+
+        if let Some(array) = result.as_array() {
+            assert_eq!(array.len(), 2);
+            assert_eq!(array[0]["type"], "fallback");
+            assert_eq!(array[0]["stateMutability"], "payable");
+            assert_eq!(array[1]["type"], "function");
+        } else {
+            panic!("Expected JSON array");
+        }
+
+        let json_abi: abi::JsonAbi = serde_json::from_slice(&normalized).unwrap();
+        assert_eq!(json_abi.len(), 2);
+    }
+
+    #[test]
+    fn test_normalize_abi_json_strips_indexed_from_non_events() {
+        let abi_with_indexed_in_function = r#"[
+            {
+                "type": "function",
+                "name": "testFunction",
+                "inputs": [{"name": "x", "type": "uint256", "indexed": true}],
+                "outputs": [{"name": "y", "type": "address", "indexed": false}],
+                "stateMutability": "view"
+            },
+            {
+                "type": "event",
+                "name": "TestEvent",
+                "anonymous": false,
+                "inputs": [{"name": "from", "type": "address", "indexed": true}]
+            }
+        ]"#;
+
+        let normalized = normalize_abi_json(abi_with_indexed_in_function.as_bytes()).unwrap();
+        let result: serde_json::Value = serde_json::from_slice(&normalized).unwrap();
+
+        if let Some(array) = result.as_array() {
+            assert!(array[0]["inputs"][0].get("indexed").is_none());
+            assert!(array[0]["outputs"][0].get("indexed").is_none());
+            assert_eq!(array[1]["inputs"][0]["indexed"], true);
+        } else {
+            panic!("Expected JSON array");
+        }
+
+        let json_abi: abi::JsonAbi = serde_json::from_slice(&normalized).unwrap();
+        assert_eq!(json_abi.len(), 2);
+    }
+
+    // Helper function to create consistent test ABI
+    fn create_test_mapping_abi() -> AbiJson {
+        const ABI_JSON: &str = r#"[
+            {
+                "anonymous": false,
+                "inputs": [
+                    {
+                        "indexed": false,
+                        "name": "from",
+                        "type": "address"
+                    },
+                    {
+                        "indexed": false,
+                        "name": "asset",
+                        "type": "tuple",
+                        "components": [
+                            {
+                                "name": "addr",
+                                "type": "address"
+                            },
+                            {
+                                "name": "amount",
+                                "type": "uint256"
+                            },
+                            {
+                                "name": "active",
+                                "type": "bool"
+                            }
+                        ]
+                    }
+                ],
+                "name": "Transfer",
+                "type": "event"
+            },
+            {
+                "type": "event",
+                "name": "ComplexAssetCreated",
+                "inputs": [
+                    {
+                        "name": "complexAsset",
+                        "type": "tuple",
+                        "indexed": false,
+                        "internalType": "struct DeclaredCallsContract.ComplexAsset",
+                        "components": [
+                            {
+                                "name": "base",
+                                "type": "tuple",
+                                "internalType": "struct DeclaredCallsContract.Asset",
+                                "components": [
+                                        {
+                                            "name": "addr",
+                                            "type": "address",
+                                            "internalType": "address"
+                                        },
+                                        {
+                                            "name": "amount",
+                                            "type": "uint256",
+                                            "internalType": "uint256"
+                                        },
+                                        {
+                                            "name": "active",
+                                            "type": "bool",
+                                            "internalType": "bool"
+                                        }
+                                ]
+                            },
+                            {
+                                "name": "metadata",
+                                "type": "string",
+                                "internalType": "string"
+                            },
+                            {
+                                "name": "values",
+                                "type": "uint256[]",
+                                "internalType": "uint256[]"
+                            }
+                        ]
+                    }
+                ]
+            }
+        ]"#;
+
+        AbiJson::new(ABI_JSON.as_bytes()).unwrap()
+    }
+}
diff --git a/graph/src/data_source/mod.rs b/graph/src/data_source/mod.rs
index 964f5d7451b..016903ab55f 100644
--- a/graph/src/data_source/mod.rs
+++ b/graph/src/data_source/mod.rs
@@ -1,6 +1,11 @@
 pub mod causality_region;
+pub mod common;
 pub mod offchain;
+pub mod subgraph;
 
+use crate::data::subgraph::DeploymentHash;
+
+pub use self::DataSource as DataSourceEnum;
 pub use causality_region::CausalityRegion;
 
 #[cfg(test)]
@@ -16,13 +21,13 @@ use crate::{
         link_resolver::LinkResolver,
         store::{BlockNumber, StoredDynamicDataSource},
     },
-    data_source::offchain::OFFCHAIN_KINDS,
+    data_source::{offchain::OFFCHAIN_KINDS, subgraph::SUBGRAPH_DS_KIND},
     prelude::{CheapClone as _, DataSourceContext},
     schema::{EntityType, InputSchema},
 };
-use anyhow::Error;
+use anyhow::{Context, Error, anyhow};
 use semver::Version;
-use serde::{de::IntoDeserializer as _, Deserialize, Deserializer};
+use serde::{Deserialize, Deserializer, de::IntoDeserializer as _};
 use slog::{Logger, SendSyncRefUnwindSafeKV};
 use std::{
     collections::{BTreeMap, HashSet},
@@ -31,10 +36,14 @@ use std::{
 };
 use thiserror::Error;
 
+use crate::amp;
+
 #[derive(Debug)]
 pub enum DataSource<C: Blockchain> {
     Onchain(C::DataSource),
     Offchain(offchain::DataSource),
+    Subgraph(subgraph::DataSource),
+    Amp(amp::manifest::DataSource),
 }
 
 #[derive(Error, Debug)]
@@ -68,7 +77,7 @@ impl fmt::Display for EntityTypeAccess {
         match self {
             Self::Any => write!(f, "Any"),
             Self::Restriced(entities) => {
-                let strings = entities.iter().map(|e| e.as_str()).collect::<Vec<_>>();
+                let strings = entities.iter().map(|e| e.typename()).collect::<Vec<_>>();
                 write!(f, "{}", strings.join(", "))
             }
         }
@@ -89,6 +98,26 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => Some(ds),
             Self::Offchain(_) => None,
+            Self::Subgraph(_) => None,
+            Self::Amp(_) => None,
+        }
+    }
+
+    pub fn as_subgraph(&self) -> Option<&subgraph::DataSource> {
+        match self {
+            Self::Onchain(_) => None,
+            Self::Offchain(_) => None,
+            Self::Subgraph(ds) => Some(ds),
+            Self::Amp(_) => None,
+        }
+    }
+
+    pub fn is_chain_based(&self) -> bool {
+        match self {
+            Self::Onchain(_) => true,
+            Self::Offchain(_) => false,
+            Self::Subgraph(_) => true,
+            Self::Amp(_) => true,
         }
     }
 
@@ -96,6 +125,26 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(_) => None,
             Self::Offchain(ds) => Some(ds),
+            Self::Subgraph(_) => None,
+            Self::Amp(_) => None,
+        }
+    }
+
+    pub fn network(&self) -> Option<&str> {
+        match self {
+            DataSourceEnum::Onchain(ds) => ds.network(),
+            DataSourceEnum::Offchain(_) => None,
+            DataSourceEnum::Subgraph(ds) => ds.network(),
+            Self::Amp(ds) => Some(&ds.network),
+        }
+    }
+
+    pub fn start_block(&self) -> Option<BlockNumber> {
+        match self {
+            DataSourceEnum::Onchain(ds) => Some(ds.start_block()),
+            DataSourceEnum::Offchain(_) => None,
+            DataSourceEnum::Subgraph(ds) => Some(ds.source.start_block),
+            Self::Amp(ds) => Some(ds.source.start_block as i32),
         }
     }
 
@@ -111,6 +160,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.address().map(ToOwned::to_owned),
             Self::Offchain(ds) => ds.address(),
+            Self::Subgraph(ds) => ds.address(),
+            Self::Amp(ds) => Some(ds.source.address.to_vec()),
         }
     }
 
@@ -118,6 +169,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.name(),
             Self::Offchain(ds) => &ds.name,
+            Self::Subgraph(ds) => &ds.name,
+            Self::Amp(ds) => ds.name.as_str(),
         }
     }
 
@@ -125,6 +178,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.kind().to_owned(),
             Self::Offchain(ds) => ds.kind.to_string(),
+            Self::Subgraph(ds) => ds.kind.clone(),
+            Self::Amp(_) => amp::manifest::DataSource::KIND.to_string(),
         }
     }
 
@@ -132,6 +187,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.min_spec_version(),
             Self::Offchain(ds) => ds.min_spec_version(),
+            Self::Subgraph(ds) => ds.min_spec_version(),
+            Self::Amp(_) => amp::manifest::DataSource::MIN_SPEC_VERSION,
         }
     }
 
@@ -139,6 +196,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.end_block(),
             Self::Offchain(_) => None,
+            Self::Subgraph(_) => None,
+            Self::Amp(ds) => Some(ds.source.end_block as i32),
         }
     }
 
@@ -146,6 +205,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.creation_block(),
             Self::Offchain(ds) => ds.creation_block,
+            Self::Subgraph(ds) => ds.creation_block,
+            Self::Amp(_) => None,
         }
     }
 
@@ -153,6 +214,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.context(),
             Self::Offchain(ds) => ds.context.clone(),
+            Self::Subgraph(ds) => ds.context.clone(),
+            Self::Amp(_) => Arc::new(None),
         }
     }
 
@@ -160,6 +223,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.api_version(),
             Self::Offchain(ds) => ds.mapping.api_version.clone(),
+            Self::Subgraph(ds) => ds.mapping.api_version.clone(),
+            Self::Amp(ds) => ds.transformer.api_version.clone(),
         }
     }
 
@@ -167,6 +232,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.runtime(),
             Self::Offchain(ds) => Some(ds.mapping.runtime.cheap_clone()),
+            Self::Subgraph(ds) => Some(ds.mapping.runtime.cheap_clone()),
+            Self::Amp(_) => None,
         }
     }
 
@@ -176,6 +243,8 @@ impl<C: Blockchain> DataSource<C> {
             // been enforced.
             Self::Onchain(_) => EntityTypeAccess::Any,
             Self::Offchain(ds) => EntityTypeAccess::Restriced(ds.mapping.entities.clone()),
+            Self::Subgraph(_) => EntityTypeAccess::Any,
+            Self::Amp(_) => EntityTypeAccess::Any,
         }
     }
 
@@ -183,6 +252,17 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.handler_kinds(),
             Self::Offchain(ds) => vec![ds.handler_kind()].into_iter().collect(),
+            Self::Subgraph(ds) => vec![ds.handler_kind()].into_iter().collect(),
+            Self::Amp(_) => HashSet::new(),
+        }
+    }
+
+    pub fn has_declared_calls(&self) -> bool {
+        match self {
+            Self::Onchain(ds) => ds.has_declared_calls(),
+            Self::Offchain(_) => false,
+            Self::Subgraph(_) => false,
+            Self::Amp(_) => false,
         }
     }
 
@@ -200,8 +280,16 @@ impl<C: Blockchain> DataSource<C> {
             (Self::Offchain(ds), TriggerData::Offchain(trigger)) => {
                 Ok(ds.match_and_decode(trigger))
             }
+            (Self::Subgraph(ds), TriggerData::Subgraph(trigger)) => {
+                ds.match_and_decode(block, trigger)
+            }
             (Self::Onchain(_), TriggerData::Offchain(_))
-            | (Self::Offchain(_), TriggerData::Onchain(_)) => Ok(None),
+            | (Self::Offchain(_), TriggerData::Onchain(_))
+            | (Self::Onchain(_), TriggerData::Subgraph(_))
+            | (Self::Offchain(_), TriggerData::Subgraph(_))
+            | (Self::Subgraph(_), TriggerData::Onchain(_))
+            | (Self::Subgraph(_), TriggerData::Offchain(_)) => Ok(None),
+            (Self::Amp(_), _) => Ok(None),
         }
     }
 
@@ -217,6 +305,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(ds) => ds.as_stored_dynamic_data_source(),
             Self::Offchain(ds) => ds.as_stored_dynamic_data_source(),
+            Self::Subgraph(_) => todo!(), // TODO(krishna)
+            Self::Amp(_) => unreachable!(),
         }
     }
 
@@ -233,13 +323,16 @@ impl<C: Blockchain> DataSource<C> {
                 offchain::DataSource::from_stored_dynamic_data_source(template, stored)
                     .map(DataSource::Offchain)
             }
+            DataSourceTemplate::Subgraph(_) => todo!(), // TODO(krishna)
         }
     }
 
-    pub fn validate(&self) -> Vec<Error> {
+    pub fn validate(&self, spec_version: &semver::Version) -> Vec<Error> {
         match self {
-            Self::Onchain(ds) => ds.validate(),
+            Self::Onchain(ds) => ds.validate(spec_version),
             Self::Offchain(_) => vec![],
+            Self::Subgraph(_) => vec![], // TODO(krishna)
+            Self::Amp(_) => Vec::new(),
         }
     }
 
@@ -247,6 +340,8 @@ impl<C: Blockchain> DataSource<C> {
         match self {
             Self::Onchain(_) => CausalityRegion::ONCHAIN,
             Self::Offchain(ds) => ds.causality_region,
+            Self::Subgraph(_) => CausalityRegion::ONCHAIN,
+            Self::Amp(_) => CausalityRegion::ONCHAIN,
         }
     }
 }
@@ -255,41 +350,92 @@ impl<C: Blockchain> DataSource<C> {
 pub enum UnresolvedDataSource<C: Blockchain> {
     Onchain(C::UnresolvedDataSource),
     Offchain(offchain::UnresolvedDataSource),
+    Subgraph(subgraph::UnresolvedDataSource),
+    Amp(amp::manifest::data_source::RawDataSource),
 }
 
 impl<C: Blockchain> UnresolvedDataSource<C> {
-    pub async fn resolve(
+    pub async fn resolve<AC: amp::Client>(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
+        amp_client: Option<Arc<AC>>,
         logger: &Logger,
         manifest_idx: u32,
+        spec_version: &semver::Version,
+        input_schema: Option<&InputSchema>,
     ) -> Result<DataSource<C>, anyhow::Error> {
         match self {
             Self::Onchain(unresolved) => unresolved
-                .resolve(resolver, logger, manifest_idx)
+                .resolve(
+                    deployment_hash,
+                    resolver,
+                    logger,
+                    manifest_idx,
+                    spec_version,
+                )
                 .await
                 .map(DataSource::Onchain),
+            Self::Subgraph(unresolved) => unresolved
+                .resolve::<C, AC>(
+                    deployment_hash,
+                    resolver,
+                    amp_client,
+                    logger,
+                    manifest_idx,
+                    spec_version,
+                )
+                .await
+                .map(DataSource::Subgraph),
             Self::Offchain(_unresolved) => {
                 anyhow::bail!(
                     "static file data sources are not yet supported, \\
                      for details see https://github.com/graphprotocol/graph-node/issues/3864"
                 );
             }
+            Self::Amp(raw_data_source) => match amp_client {
+                Some(amp_client) => raw_data_source
+                    .resolve(logger, resolver.as_ref(), amp_client.as_ref(), input_schema)
+                    .await
+                    .map(DataSource::Amp)
+                    .map_err(Error::from),
+                None => Err(anyhow!("support for Amp data sources is not enabled")),
+            },
         }
+        .with_context(|| format!("failed to resolve data source at index {manifest_idx}"))
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct DataSourceTemplateInfo {
+    pub api_version: semver::Version,
+    pub runtime: Option<Arc<Vec<u8>>>,
+    pub name: String,
+    pub manifest_idx: Option<u32>,
+    pub kind: String,
+}
+
 #[derive(Debug)]
 pub enum DataSourceTemplate<C: Blockchain> {
     Onchain(C::DataSourceTemplate),
     Offchain(offchain::DataSourceTemplate),
+    Subgraph(subgraph::DataSourceTemplate),
 }
 
 impl<C: Blockchain> DataSourceTemplate<C> {
+    pub fn info(&self) -> DataSourceTemplateInfo {
+        match self {
+            DataSourceTemplate::Onchain(template) => template.info(),
+            DataSourceTemplate::Offchain(template) => template.clone().into(),
+            DataSourceTemplate::Subgraph(template) => template.clone().into(),
+        }
+    }
+
     pub fn as_onchain(&self) -> Option<&C::DataSourceTemplate> {
         match self {
             Self::Onchain(ds) => Some(ds),
             Self::Offchain(_) => None,
+            Self::Subgraph(_) => todo!(), // TODO(krishna)
         }
     }
 
@@ -297,6 +443,7 @@ impl<C: Blockchain> DataSourceTemplate<C> {
         match self {
             Self::Onchain(_) => None,
             Self::Offchain(t) => Some(t),
+            Self::Subgraph(_) => todo!(), // TODO(krishna)
         }
     }
 
@@ -304,6 +451,7 @@ impl<C: Blockchain> DataSourceTemplate<C> {
         match self {
             Self::Onchain(ds) => Some(ds),
             Self::Offchain(_) => None,
+            Self::Subgraph(_) => todo!(), // TODO(krishna)
         }
     }
 
@@ -311,6 +459,7 @@ impl<C: Blockchain> DataSourceTemplate<C> {
         match self {
             Self::Onchain(ds) => ds.name(),
             Self::Offchain(ds) => &ds.name,
+            Self::Subgraph(ds) => &ds.name,
         }
     }
 
@@ -318,6 +467,7 @@ impl<C: Blockchain> DataSourceTemplate<C> {
         match self {
             Self::Onchain(ds) => ds.api_version(),
             Self::Offchain(ds) => ds.mapping.api_version.clone(),
+            Self::Subgraph(ds) => ds.mapping.api_version.clone(),
         }
     }
 
@@ -325,6 +475,7 @@ impl<C: Blockchain> DataSourceTemplate<C> {
         match self {
             Self::Onchain(ds) => ds.runtime(),
             Self::Offchain(ds) => Some(ds.mapping.runtime.clone()),
+            Self::Subgraph(ds) => Some(ds.mapping.runtime.clone()),
         }
     }
 
@@ -332,6 +483,7 @@ impl<C: Blockchain> DataSourceTemplate<C> {
         match self {
             Self::Onchain(ds) => ds.manifest_idx(),
             Self::Offchain(ds) => ds.manifest_idx,
+            Self::Subgraph(ds) => ds.manifest_idx,
         }
     }
 
@@ -339,6 +491,7 @@ impl<C: Blockchain> DataSourceTemplate<C> {
         match self {
             Self::Onchain(ds) => ds.kind().to_string(),
             Self::Offchain(ds) => ds.kind.to_string(),
+            Self::Subgraph(ds) => ds.kind.clone(),
         }
     }
 }
@@ -347,6 +500,7 @@ impl<C: Blockchain> DataSourceTemplate<C> {
 pub enum UnresolvedDataSourceTemplate<C: Blockchain> {
     Onchain(C::UnresolvedDataSourceTemplate),
     Offchain(offchain::UnresolvedDataSourceTemplate),
+    Subgraph(subgraph::UnresolvedDataSourceTemplate),
 }
 
 impl<C: Blockchain> Default for UnresolvedDataSourceTemplate<C> {
@@ -358,20 +512,38 @@ impl<C: Blockchain> Default for UnresolvedDataSourceTemplate<C> {
 impl<C: Blockchain> UnresolvedDataSourceTemplate<C> {
     pub async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         schema: &InputSchema,
         logger: &Logger,
         manifest_idx: u32,
+        spec_version: &semver::Version,
     ) -> Result<DataSourceTemplate<C>, Error> {
         match self {
             Self::Onchain(ds) => ds
-                .resolve(resolver, logger, manifest_idx)
+                .resolve(
+                    deployment_hash,
+                    resolver,
+                    logger,
+                    manifest_idx,
+                    spec_version,
+                )
                 .await
-                .map(DataSourceTemplate::Onchain),
+                .map(|ti| DataSourceTemplate::Onchain(ti)),
             Self::Offchain(ds) => ds
-                .resolve(resolver, logger, manifest_idx, schema)
+                .resolve(deployment_hash, resolver, logger, manifest_idx, schema)
                 .await
                 .map(DataSourceTemplate::Offchain),
+            Self::Subgraph(ds) => ds
+                .resolve(
+                    deployment_hash,
+                    resolver,
+                    logger,
+                    manifest_idx,
+                    spec_version,
+                )
+                .await
+                .map(DataSourceTemplate::Subgraph),
         }
     }
 }
@@ -452,6 +624,7 @@ impl<T> TriggerWithHandler<T> {
 pub enum TriggerData<C: Blockchain> {
     Onchain(C::TriggerData),
     Offchain(offchain::TriggerData),
+    Subgraph(subgraph::TriggerData),
 }
 
 impl<C: Blockchain> TriggerData<C> {
@@ -459,6 +632,7 @@ impl<C: Blockchain> TriggerData<C> {
         match self {
             Self::Onchain(trigger) => trigger.error_context(),
             Self::Offchain(trigger) => format!("{:?}", trigger.source),
+            Self::Subgraph(trigger) => format!("{:?}", trigger.source),
         }
     }
 }
@@ -467,6 +641,7 @@ impl<C: Blockchain> TriggerData<C> {
 pub enum MappingTrigger<C: Blockchain> {
     Onchain(C::MappingTrigger),
     Offchain(offchain::TriggerData),
+    Subgraph(subgraph::MappingEntityTrigger),
 }
 
 impl<C: Blockchain> MappingTrigger<C> {
@@ -474,57 +649,108 @@ impl<C: Blockchain> MappingTrigger<C> {
         match self {
             Self::Onchain(trigger) => Some(trigger.error_context()),
             Self::Offchain(_) => None, // TODO: Add error context for offchain triggers
+            Self::Subgraph(_) => None, // TODO(krishna)
+        }
+    }
+
+    pub fn as_onchain(&self) -> Option<&C::MappingTrigger> {
+        match self {
+            Self::Onchain(trigger) => Some(trigger),
+            Self::Offchain(_) => None,
+            Self::Subgraph(_) => None, // TODO(krishna)
         }
     }
 }
 
-macro_rules! clone_data_source {
-    ($t:ident) => {
-        impl<C: Blockchain> Clone for $t<C> {
-            fn clone(&self) -> Self {
-                match self {
-                    Self::Onchain(ds) => Self::Onchain(ds.clone()),
-                    Self::Offchain(ds) => Self::Offchain(ds.clone()),
-                }
-            }
+impl<C: Blockchain> Clone for DataSource<C> {
+    fn clone(&self) -> Self {
+        match self {
+            Self::Onchain(ds) => Self::Onchain(ds.clone()),
+            Self::Offchain(ds) => Self::Offchain(ds.clone()),
+            Self::Subgraph(ds) => Self::Subgraph(ds.clone()),
+            Self::Amp(ds) => Self::Amp(ds.clone()),
         }
-    };
+    }
 }
 
-clone_data_source!(DataSource);
-clone_data_source!(DataSourceTemplate);
-
-macro_rules! deserialize_data_source {
-    ($t:ident) => {
-        impl<'de, C: Blockchain> Deserialize<'de> for $t<C> {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                let map: BTreeMap<String, serde_json::Value> = BTreeMap::deserialize(deserializer)?;
-                let kind = map
-                    .get("kind")
-                    .ok_or(serde::de::Error::missing_field("kind"))?
-                    .as_str()
-                    .unwrap_or("?");
-                if OFFCHAIN_KINDS.contains_key(&kind) {
-                    offchain::$t::deserialize(map.into_deserializer())
-                        .map_err(serde::de::Error::custom)
-                        .map($t::Offchain)
-                } else if (&C::KIND.to_string() == kind) || C::ALIASES.contains(&kind) {
-                    C::$t::deserialize(map.into_deserializer())
-                        .map_err(serde::de::Error::custom)
-                        .map($t::Onchain)
-                } else {
-                    Err(serde::de::Error::custom(format!(
-                        "data source has invalid `kind`; expected {}, file/ipfs",
-                        C::KIND,
-                    )))
-                }
-            }
+impl<C: Blockchain> Clone for DataSourceTemplate<C> {
+    fn clone(&self) -> Self {
+        match self {
+            Self::Onchain(ds) => Self::Onchain(ds.clone()),
+            Self::Offchain(ds) => Self::Offchain(ds.clone()),
+            Self::Subgraph(ds) => Self::Subgraph(ds.clone()),
         }
-    };
+    }
 }
 
-deserialize_data_source!(UnresolvedDataSource);
-deserialize_data_source!(UnresolvedDataSourceTemplate);
+impl<'de, C: Blockchain> Deserialize<'de> for UnresolvedDataSource<C> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let map: BTreeMap<String, serde_json::Value> = BTreeMap::deserialize(deserializer)?;
+
+        let kind = map
+            .get("kind")
+            .ok_or(serde::de::Error::missing_field("kind"))?
+            .as_str()
+            .unwrap_or("?");
+
+        if OFFCHAIN_KINDS.contains_key(&kind) {
+            offchain::UnresolvedDataSource::deserialize(map.into_deserializer())
+                .map_err(serde::de::Error::custom)
+                .map(UnresolvedDataSource::Offchain)
+        } else if SUBGRAPH_DS_KIND == kind {
+            subgraph::UnresolvedDataSource::deserialize(map.into_deserializer())
+                .map_err(serde::de::Error::custom)
+                .map(UnresolvedDataSource::Subgraph)
+        } else if amp::manifest::DataSource::KIND == kind {
+            amp::manifest::data_source::RawDataSource::deserialize(map.into_deserializer())
+                .map(UnresolvedDataSource::Amp)
+                .map_err(serde::de::Error::custom)
+        } else if (C::KIND.to_string() == kind) || C::ALIASES.contains(&kind) {
+            C::UnresolvedDataSource::deserialize(map.into_deserializer())
+                .map_err(serde::de::Error::custom)
+                .map(UnresolvedDataSource::Onchain)
+        } else {
+            Err(serde::de::Error::custom(format!(
+                "data source has invalid `kind`; expected {}, file/ipfs",
+                C::KIND,
+            )))
+        }
+    }
+}
+
+impl<'de, C: Blockchain> Deserialize<'de> for UnresolvedDataSourceTemplate<C> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let map: BTreeMap<String, serde_json::Value> = BTreeMap::deserialize(deserializer)?;
+
+        let kind = map
+            .get("kind")
+            .ok_or(serde::de::Error::missing_field("kind"))?
+            .as_str()
+            .unwrap_or("?");
+
+        if OFFCHAIN_KINDS.contains_key(&kind) {
+            offchain::UnresolvedDataSourceTemplate::deserialize(map.into_deserializer())
+                .map_err(serde::de::Error::custom)
+                .map(UnresolvedDataSourceTemplate::Offchain)
+        } else if SUBGRAPH_DS_KIND == kind {
+            subgraph::UnresolvedDataSourceTemplate::deserialize(map.into_deserializer())
+                .map_err(serde::de::Error::custom)
+                .map(UnresolvedDataSourceTemplate::Subgraph)
+        } else if (C::KIND.to_string() == kind) || C::ALIASES.contains(&kind) {
+            C::UnresolvedDataSourceTemplate::deserialize(map.into_deserializer())
+                .map_err(serde::de::Error::custom)
+                .map(UnresolvedDataSourceTemplate::Onchain)
+        } else {
+            Err(serde::de::Error::custom(format!(
+                "data source has invalid `kind`; expected {}, file/ipfs",
+                C::KIND,
+            )))
+        }
+    }
+}
diff --git a/graph/src/data_source/offchain.rs b/graph/src/data_source/offchain.rs
index d7d3d90ecca..b21b52a6e3a 100644
--- a/graph/src/data_source/offchain.rs
+++ b/graph/src/data_source/offchain.rs
@@ -2,29 +2,33 @@ use crate::{
     bail,
     blockchain::{BlockPtr, BlockTime, Blockchain},
     components::{
-        link_resolver::LinkResolver,
+        link_resolver::{LinkResolver, LinkResolverContext},
         store::{BlockNumber, StoredDynamicDataSource},
-        subgraph::DataSourceTemplateInfo,
+        subgraph::{InstanceDSTemplate, InstanceDSTemplateInfo},
+    },
+    data::{
+        store::scalar::Bytes,
+        subgraph::{DeploymentHash, SPEC_VERSION_0_0_7},
+        value::Word,
     },
-    data::{store::scalar::Bytes, subgraph::SPEC_VERSION_0_0_7, value::Word},
     data_source,
-    ipfs_client::CidFile,
+    ipfs::ContentPath,
     prelude::{DataSourceContext, Link},
     schema::{EntityType, InputSchema},
 };
-use anyhow::{anyhow, Context, Error};
+use anyhow::{Context, Error, anyhow};
 use itertools::Itertools;
 use lazy_static::lazy_static;
 use serde::Deserialize;
-use slog::{info, warn, Logger};
+use slog::{Logger, info, warn};
 use std::{
     collections::HashMap,
     fmt,
     str::FromStr,
-    sync::{atomic::AtomicI32, Arc},
+    sync::{Arc, atomic::AtomicI32},
 };
 
-use super::{CausalityRegion, DataSourceCreationError, TriggerWithHandler};
+use super::{CausalityRegion, DataSourceCreationError, DataSourceTemplateInfo, TriggerWithHandler};
 
 lazy_static! {
     pub static ref OFFCHAIN_KINDS: HashMap<&'static str, OffchainDataSourceKind> = [
@@ -47,8 +51,8 @@ impl OffchainDataSourceKind {
     pub fn try_parse_source(&self, bs: Bytes) -> Result<Source, anyhow::Error> {
         let source = match self {
             OffchainDataSourceKind::Ipfs => {
-                let cid_file = CidFile::try_from(bs)?;
-                Source::Ipfs(cid_file)
+                let path = ContentPath::try_from(bs)?;
+                Source::Ipfs(path)
             }
             OffchainDataSourceKind::Arweave => {
                 let base64 = Word::from(String::from_utf8(bs.to_vec())?);
@@ -59,21 +63,17 @@ impl OffchainDataSourceKind {
     }
 }
 
-impl ToString for OffchainDataSourceKind {
-    fn to_string(&self) -> String {
+impl fmt::Display for OffchainDataSourceKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // This is less performant than hardcoding the values but makes it more difficult
         // to be used incorrectly, since this map is quite small it should be fine.
-        OFFCHAIN_KINDS
+        let label = OFFCHAIN_KINDS
             .iter()
-            .find_map(|(str, kind)| {
-                if kind.eq(self) {
-                    Some(str.to_string())
-                } else {
-                    None
-                }
-            })
+            .find_map(|(str, kind)| if kind.eq(self) { Some(*str) } else { None })
             // the kind is validated based on OFFCHAIN_KINDS so it's guaranteed to exist
-            .unwrap()
+            .unwrap_or("<unknown offchain kind>");
+
+        write!(f, "{}", label)
     }
 }
 
@@ -169,12 +169,12 @@ impl DataSource {
 
 impl DataSource {
     pub fn from_template_info(
-        info: DataSourceTemplateInfo<impl Blockchain>,
+        info: InstanceDSTemplateInfo,
         causality_region: CausalityRegion,
     ) -> Result<Self, DataSourceCreationError> {
         let template = match info.template {
-            data_source::DataSourceTemplate::Offchain(template) => template,
-            data_source::DataSourceTemplate::Onchain(_) => {
+            InstanceDSTemplate::Offchain(template) => template,
+            InstanceDSTemplate::Onchain(_) => {
                 bail!("Cannot create offchain data source from onchain template")
             }
         };
@@ -187,7 +187,7 @@ impl DataSource {
             OffchainDataSourceKind::Ipfs => match source.parse() {
                 Ok(source) => Source::Ipfs(source),
                 // Ignore data sources created with an invalid CID.
-                Err(e) => return Err(DataSourceCreationError::Ignore(source, e)),
+                Err(e) => return Err(DataSourceCreationError::Ignore(source, e.into())),
             },
             OffchainDataSourceKind::Arweave => Source::Arweave(Word::from(source)),
         };
@@ -313,7 +313,7 @@ pub type Base64 = Word;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Source {
-    Ipfs(CidFile),
+    Ipfs(ContentPath),
     Arweave(Base64),
 }
 
@@ -326,17 +326,17 @@ impl Source {
     ///    the `source` of the data source is equal the `source` of the `TriggerData`.
     pub fn address(&self) -> Option<Vec<u8>> {
         match self {
-            Source::Ipfs(ref cid) => Some(cid.to_bytes()),
-            Source::Arweave(ref base64) => Some(base64.as_bytes().to_vec()),
+            Source::Ipfs(path) => Some(path.to_string().as_bytes().to_vec()),
+            Source::Arweave(base64) => Some(base64.as_bytes().to_vec()),
         }
     }
 }
 
-impl Into<Bytes> for Source {
-    fn into(self) -> Bytes {
-        match self {
-            Source::Ipfs(ref link) => Bytes::from(link.to_bytes()),
-            Source::Arweave(ref base64) => Bytes::from(base64.as_bytes()),
+impl From<Source> for Bytes {
+    fn from(val: Source) -> Self {
+        match val {
+            Source::Ipfs(path) => Bytes::from(path.to_string().as_bytes().to_vec()),
+            Source::Arweave(base64) => Bytes::from(base64.as_bytes()),
         }
     }
 }
@@ -374,42 +374,10 @@ pub struct UnresolvedMapping {
     pub entities: Vec<String>,
 }
 
-impl UnresolvedDataSource {
-    #[allow(dead_code)]
-    pub(super) async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-        manifest_idx: u32,
-        causality_region: CausalityRegion,
-        schema: &InputSchema,
-    ) -> Result<DataSource, Error> {
-        info!(logger, "Resolve offchain data source";
-            "name" => &self.name,
-            "kind" => &self.kind,
-            "source" => format_args!("{:?}", &self.source),
-        );
-
-        let kind = OffchainDataSourceKind::from_str(self.kind.as_str())?;
-        let source = kind.try_parse_source(Bytes::from(self.source.file.link.as_bytes()))?;
-
-        Ok(DataSource {
-            manifest_idx,
-            kind,
-            name: self.name,
-            source,
-            mapping: self.mapping.resolve(resolver, schema, logger).await?,
-            context: Arc::new(None),
-            creation_block: None,
-            done_at: Arc::new(AtomicI32::new(NOT_DONE_VALUE)),
-            causality_region,
-        })
-    }
-}
-
 impl UnresolvedMapping {
     pub async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         schema: &InputSchema,
         logger: &Logger,
@@ -433,7 +401,14 @@ impl UnresolvedMapping {
             api_version: semver::Version::parse(&self.api_version)?,
             entities,
             handler: self.handler,
-            runtime: Arc::new(resolver.cat(logger, &self.file).await?),
+            runtime: Arc::new(
+                resolver
+                    .cat(
+                        &LinkResolverContext::new(deployment_hash, logger),
+                        &self.file,
+                    )
+                    .await?,
+            ),
             link: self.file,
         })
     }
@@ -456,9 +431,30 @@ pub struct DataSourceTemplate {
     pub mapping: Mapping,
 }
 
+impl From<DataSourceTemplate> for DataSourceTemplateInfo {
+    fn from(val: DataSourceTemplate) -> Self {
+        let DataSourceTemplate {
+            kind,
+            network: _,
+            name,
+            manifest_idx,
+            mapping,
+        } = val;
+
+        DataSourceTemplateInfo {
+            api_version: mapping.api_version.clone(),
+            runtime: Some(mapping.runtime),
+            name,
+            manifest_idx: Some(manifest_idx),
+            kind: kind.to_string(),
+        }
+    }
+}
+
 impl UnresolvedDataSourceTemplate {
     pub async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
         logger: &Logger,
         manifest_idx: u32,
@@ -468,7 +464,7 @@ impl UnresolvedDataSourceTemplate {
 
         let mapping = self
             .mapping
-            .resolve(resolver, schema, logger)
+            .resolve(deployment_hash, resolver, schema, logger)
             .await
             .with_context(|| format!("failed to resolve data source template {}", self.name))?;
 
@@ -506,11 +502,9 @@ impl fmt::Debug for TriggerData {
 
 #[cfg(test)]
 mod test {
-    use std::str::FromStr;
-
     use crate::{
         data::{store::scalar::Bytes, value::Word},
-        ipfs_client::CidFile,
+        ipfs::ContentPath,
     };
 
     use super::{OffchainDataSourceKind, Source};
@@ -518,13 +512,13 @@ mod test {
     #[test]
     fn test_source_bytes_round_trip() {
         let base64 = "8APeQ5lW0-csTcBaGdPBDLAL2ci2AT9pTn2tppGPU_8";
-        let cid = CidFile::from_str("QmVkvoPGi9jvvuxsHDVJDgzPEzagBaWSZRYoRDzU244HjZ").unwrap();
+        let path = ContentPath::new("QmVkvoPGi9jvvuxsHDVJDgzPEzagBaWSZRYoRDzU244HjZ").unwrap();
 
-        let ipfs_source: Bytes = Source::Ipfs(cid.clone()).into();
+        let ipfs_source: Bytes = Source::Ipfs(path.clone()).into();
         let s = OffchainDataSourceKind::Ipfs
             .try_parse_source(ipfs_source)
             .unwrap();
-        assert! { matches!(s, Source::Ipfs(ipfs) if ipfs.eq(&cid))};
+        assert! { matches!(s, Source::Ipfs(ipfs) if ipfs.eq(&path))};
 
         let arweave_source = Source::Arweave(Word::from(base64));
         let s = OffchainDataSourceKind::Arweave
diff --git a/graph/src/data_source/subgraph.rs b/graph/src/data_source/subgraph.rs
new file mode 100644
index 00000000000..e7b6319b942
--- /dev/null
+++ b/graph/src/data_source/subgraph.rs
@@ -0,0 +1,694 @@
+use crate::{
+    blockchain::{Block, Blockchain, block_stream::EntitySourceOperation},
+    components::{
+        link_resolver::{LinkResolver, LinkResolverContext},
+        store::BlockNumber,
+    },
+    data::{
+        subgraph::{
+            LATEST_VERSION, SPEC_VERSION_1_3_0, SubgraphManifest, UnresolvedSubgraphManifest,
+            calls_host_fn,
+        },
+        value::Word,
+    },
+    data_source::{self, common::DeclaredCall},
+    ensure,
+    prelude::{CheapClone, DataSourceContext, DeploymentHash, Link},
+    schema::TypeKind,
+};
+use anyhow::{Context, Error, Result, anyhow};
+use futures03::{TryStreamExt, stream::FuturesOrdered};
+use serde::Deserialize;
+use slog::{Logger, info};
+use std::{fmt, sync::Arc};
+
+use super::{
+    DataSourceTemplateInfo, TriggerWithHandler,
+    common::{
+        AbiJson, CallDecls, FindMappingABI, MappingABI, UnresolvedCallDecls, UnresolvedMappingABI,
+    },
+};
+use crate::amp;
+
+pub const SUBGRAPH_DS_KIND: &str = "subgraph";
+
+const ENTITY_HANDLER_KINDS: &str = "entity";
+
+#[derive(Debug, Clone)]
+pub struct DataSource {
+    pub kind: String,
+    pub name: String,
+    pub network: String,
+    pub manifest_idx: u32,
+    pub source: Source,
+    pub mapping: Mapping,
+    pub context: Arc<Option<DataSourceContext>>,
+    pub creation_block: Option<BlockNumber>,
+}
+
+impl DataSource {
+    pub fn new(
+        kind: String,
+        name: String,
+        network: String,
+        manifest_idx: u32,
+        source: Source,
+        mapping: Mapping,
+        context: Arc<Option<DataSourceContext>>,
+        creation_block: Option<BlockNumber>,
+    ) -> Self {
+        Self {
+            kind,
+            name,
+            network,
+            manifest_idx,
+            source,
+            mapping,
+            context,
+            creation_block,
+        }
+    }
+
+    pub fn min_spec_version(&self) -> semver::Version {
+        SPEC_VERSION_1_3_0
+    }
+
+    pub fn handler_kind(&self) -> &str {
+        ENTITY_HANDLER_KINDS
+    }
+
+    pub fn network(&self) -> Option<&str> {
+        Some(&self.network)
+    }
+
+    pub fn match_and_decode<C: Blockchain>(
+        &self,
+        block: &Arc<C::Block>,
+        trigger: &TriggerData,
+    ) -> Result<Option<TriggerWithHandler<super::MappingTrigger<C>>>> {
+        if self.source.address != trigger.source {
+            return Ok(None);
+        }
+
+        let mut matching_handlers: Vec<_> = self
+            .mapping
+            .handlers
+            .iter()
+            .filter(|handler| handler.entity == trigger.entity_type())
+            .collect();
+
+        // Get the matching handler if any
+        let handler = match matching_handlers.pop() {
+            Some(handler) => handler,
+            None => return Ok(None),
+        };
+
+        ensure!(
+            matching_handlers.is_empty(),
+            format!(
+                "Multiple handlers defined for entity `{}`, only one is supported",
+                trigger.entity_type()
+            )
+        );
+
+        let calls =
+            DeclaredCall::from_entity_trigger(&self.mapping, &handler.calls, &trigger.entity)?;
+        let mapping_trigger = MappingEntityTrigger {
+            data: trigger.clone(),
+            calls,
+        };
+
+        Ok(Some(TriggerWithHandler::new(
+            data_source::MappingTrigger::Subgraph(mapping_trigger),
+            handler.handler.clone(),
+            block.ptr(),
+            block.timestamp(),
+        )))
+    }
+
+    pub fn address(&self) -> Option<Vec<u8>> {
+        Some(self.source.address().to_bytes())
+    }
+
+    pub fn source_subgraph(&self) -> DeploymentHash {
+        self.source.address()
+    }
+}
+
+pub type Base64 = Word;
+
+#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
+pub struct Source {
+    pub address: DeploymentHash,
+    #[serde(default)]
+    pub start_block: BlockNumber,
+}
+
+impl Source {
+    /// The concept of an address may or not make sense for a subgraph data source, but graph node
+    /// will use this in a few places where some sort of not necessarily unique id is useful:
+    /// 1. This is used as the value to be returned to mappings from the `dataSource.address()` host
+    ///    function, so changing this is a breaking change.
+    /// 2. This is used to match with triggers with hosts in `fn hosts_for_trigger`, so make sure
+    ///    the `source` of the data source is equal the `source` of the `TriggerData`.
+    pub fn address(&self) -> DeploymentHash {
+        self.address.clone()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Mapping {
+    pub language: String,
+    pub api_version: semver::Version,
+    pub abis: Vec<Arc<MappingABI>>,
+    pub entities: Vec<String>,
+    pub handlers: Vec<EntityHandler>,
+    pub runtime: Arc<Vec<u8>>,
+    pub link: Link,
+}
+
+impl Mapping {
+    pub fn requires_archive(&self) -> anyhow::Result<bool> {
+        calls_host_fn(&self.runtime, "ethereum.call")
+    }
+}
+
+impl FindMappingABI for Mapping {
+    fn find_abi(&self, abi_name: &str) -> Result<Arc<MappingABI>, Error> {
+        Ok(self
+            .abis
+            .iter()
+            .find(|abi| abi.name == abi_name)
+            .ok_or_else(|| anyhow!("No ABI entry with name `{}` found", abi_name))?
+            .cheap_clone())
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
+pub struct UnresolvedEntityHandler {
+    pub handler: String,
+    pub entity: String,
+    #[serde(default)]
+    pub calls: UnresolvedCallDecls,
+}
+
+impl UnresolvedEntityHandler {
+    pub fn resolve(
+        self,
+        abi_json: &AbiJson,
+        spec_version: &semver::Version,
+    ) -> Result<EntityHandler, anyhow::Error> {
+        let resolved_calls = self.calls.resolve(abi_json, None, spec_version)?;
+
+        Ok(EntityHandler {
+            handler: self.handler,
+            entity: self.entity,
+            calls: resolved_calls,
+        })
+    }
+}
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub struct EntityHandler {
+    pub handler: String,
+    pub entity: String,
+    pub calls: CallDecls,
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)]
+pub struct UnresolvedDataSource {
+    pub kind: String,
+    pub name: String,
+    pub network: String,
+    pub source: UnresolvedSource,
+    pub mapping: UnresolvedMapping,
+    pub context: Option<DataSourceContext>,
+}
+
+#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UnresolvedSource {
+    address: DeploymentHash,
+    #[serde(default)]
+    start_block: BlockNumber,
+}
+
+impl UnresolvedSource {
+    pub fn address(&self) -> &DeploymentHash {
+        &self.address
+    }
+
+    pub fn start_block(&self) -> BlockNumber {
+        self.start_block
+    }
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UnresolvedMapping {
+    pub api_version: String,
+    pub language: String,
+    pub file: Link,
+    pub handlers: Vec<UnresolvedEntityHandler>,
+    pub abis: Option<Vec<UnresolvedMappingABI>>,
+    pub entities: Vec<String>,
+}
+
+impl UnresolvedDataSource {
+    fn validate_mapping_entities<C: Blockchain>(
+        mapping_entities: &[String],
+        source_manifest: &SubgraphManifest<C>,
+    ) -> Result<(), Error> {
+        for entity in mapping_entities {
+            let type_kind = source_manifest.schema.kind_of_declared_type(entity);
+
+            match type_kind {
+                Some(TypeKind::Interface) => {
+                    return Err(anyhow!(
+                        "Entity {} is an interface and cannot be used as a mapping entity",
+                        entity
+                    ));
+                }
+                Some(TypeKind::Aggregation) => {
+                    return Err(anyhow!(
+                        "Entity {} is an aggregation and cannot be used as a mapping entity",
+                        entity
+                    ));
+                }
+                None => {
+                    return Err(anyhow!("Entity {} not found in source manifest", entity));
+                }
+                Some(TypeKind::Object) => {
+                    // Check if the entity is immutable
+                    let entity_type = source_manifest.schema.entity_type(entity)?;
+                    if !entity_type.is_immutable() {
+                        return Err(anyhow!(
+                            "Entity {} is not immutable and cannot be used as a mapping entity",
+                            entity
+                        ));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    async fn resolve_source_manifest<C: Blockchain, AC: amp::Client>(
+        &self,
+        deployment_hash: &DeploymentHash,
+        resolver: &Arc<dyn LinkResolver>,
+        amp_client: Option<Arc<AC>>,
+        logger: &Logger,
+    ) -> Result<Arc<SubgraphManifest<C>>, Error> {
+        let resolver: Arc<dyn LinkResolver> =
+            Arc::from(resolver.for_manifest(&self.source.address.to_string())?);
+        let source_raw = resolver
+            .cat(
+                &LinkResolverContext::new(deployment_hash, logger),
+                &self.source.address.to_ipfs_link(),
+            )
+            .await
+            .context(format!(
+                "Failed to resolve source subgraph [{}] manifest",
+                self.source.address,
+            ))?;
+
+        let source_raw: serde_yaml::Mapping =
+            serde_yaml::from_slice(&source_raw).context(format!(
+                "Failed to parse source subgraph [{}] manifest as YAML",
+                self.source.address
+            ))?;
+
+        let deployment_hash = self.source.address.clone();
+
+        let source_manifest =
+            UnresolvedSubgraphManifest::<C>::parse(deployment_hash.cheap_clone(), source_raw)
+                .context(format!(
+                    "Failed to parse source subgraph [{}] manifest",
+                    self.source.address
+                ))?;
+
+        let resolver: Arc<dyn LinkResolver> =
+            Arc::from(resolver.for_manifest(&self.source.address.to_string())?);
+        source_manifest
+            .resolve(
+                &deployment_hash,
+                &resolver,
+                amp_client,
+                logger,
+                LATEST_VERSION.clone(),
+            )
+            .await
+            .context(format!(
+                "Failed to resolve source subgraph [{}] manifest",
+                self.source.address
+            ))
+            .map(Arc::new)
+    }
+
+    /// Recursively verifies that all grafts in the chain meet the minimum spec version requirement for a subgraph source
+    async fn verify_graft_chain_sourcable<C: Blockchain, AC: amp::Client>(
+        manifest: Arc<SubgraphManifest<C>>,
+        resolver: &Arc<dyn LinkResolver>,
+        amp_client: Option<Arc<AC>>,
+        logger: &Logger,
+        graft_chain: &mut Vec<String>,
+    ) -> Result<(), Error> {
+        // Add current manifest to graft chain
+        graft_chain.push(manifest.id.to_string());
+
+        // Check if current manifest meets spec version requirement
+        if manifest.spec_version < SPEC_VERSION_1_3_0 {
+            return Err(anyhow!(
+                "Subgraph with a spec version {} is not supported for a subgraph source, minimum supported version is {}. Graft chain: {}",
+                manifest.spec_version,
+                SPEC_VERSION_1_3_0,
+                graft_chain.join(" -> ")
+            ));
+        }
+
+        // If there's a graft, recursively verify it
+        if let Some(graft) = &manifest.graft {
+            let graft_raw = resolver
+                .cat(
+                    &LinkResolverContext::new(&manifest.id, logger),
+                    &graft.base.to_ipfs_link(),
+                )
+                .await
+                .context("Failed to resolve graft base manifest")?;
+
+            let graft_raw: serde_yaml::Mapping = serde_yaml::from_slice(&graft_raw)
+                .context("Failed to parse graft base manifest as YAML")?;
+
+            let graft_manifest =
+                UnresolvedSubgraphManifest::<C>::parse(graft.base.clone(), graft_raw)
+                    .context("Failed to parse graft base manifest")?
+                    .resolve(
+                        &manifest.id,
+                        resolver,
+                        amp_client.cheap_clone(),
+                        logger,
+                        LATEST_VERSION.clone(),
+                    )
+                    .await
+                    .context("Failed to resolve graft base manifest")?;
+
+            Box::pin(Self::verify_graft_chain_sourcable(
+                Arc::new(graft_manifest),
+                resolver,
+                amp_client,
+                logger,
+                graft_chain,
+            ))
+            .await?;
+        }
+
+        Ok(())
+    }
+
+    #[allow(dead_code)]
+    pub(super) async fn resolve<C: Blockchain, AC: amp::Client>(
+        self,
+        deployment_hash: &DeploymentHash,
+        resolver: &Arc<dyn LinkResolver>,
+        amp_client: Option<Arc<AC>>,
+        logger: &Logger,
+        manifest_idx: u32,
+        spec_version: &semver::Version,
+    ) -> Result<DataSource, Error> {
+        info!(logger, "Resolve subgraph data source";
+            "name" => &self.name,
+            "kind" => &self.kind,
+            "source" => format_args!("{:?}", &self.source),
+        );
+
+        let kind = self.kind.clone();
+        let source_manifest = self
+            .resolve_source_manifest::<C, AC>(
+                deployment_hash,
+                resolver,
+                amp_client.cheap_clone(),
+                logger,
+            )
+            .await?;
+        let source_spec_version = &source_manifest.spec_version;
+        if source_spec_version < &SPEC_VERSION_1_3_0 {
+            return Err(anyhow!(
+                "Source subgraph [{}] manifest spec version {} is not supported, minimum supported version is {}",
+                self.source.address,
+                source_spec_version,
+                SPEC_VERSION_1_3_0
+            ));
+        }
+
+        // Verify the entire graft chain meets spec version requirements
+        let mut graft_chain = Vec::new();
+        Self::verify_graft_chain_sourcable(
+            source_manifest.clone(),
+            resolver,
+            amp_client,
+            logger,
+            &mut graft_chain,
+        )
+        .await?;
+
+        if source_manifest
+            .data_sources
+            .iter()
+            .any(|ds| matches!(ds, crate::data_source::DataSource::Subgraph(_)))
+        {
+            return Err(anyhow!(
+                "Nested subgraph data sources [{}] are not supported.",
+                self.name
+            ));
+        }
+
+        let mapping_entities: Vec<String> = self
+            .mapping
+            .handlers
+            .iter()
+            .map(|handler| handler.entity.clone())
+            .collect();
+
+        Self::validate_mapping_entities(&mapping_entities, &source_manifest)?;
+
+        let source = Source {
+            address: self.source.address,
+            start_block: self.source.start_block,
+        };
+
+        Ok(DataSource {
+            manifest_idx,
+            kind,
+            name: self.name,
+            network: self.network,
+            source,
+            mapping: self
+                .mapping
+                .resolve(deployment_hash, resolver, logger, spec_version)
+                .await?,
+            context: Arc::new(self.context),
+            creation_block: None,
+        })
+    }
+}
+
+impl UnresolvedMapping {
+    pub async fn resolve(
+        self,
+        deployment_hash: &DeploymentHash,
+        resolver: &Arc<dyn LinkResolver>,
+        logger: &Logger,
+        spec_version: &semver::Version,
+    ) -> Result<Mapping, Error> {
+        info!(logger, "Resolve subgraph ds mapping"; "link" => &self.file.link);
+
+        // Resolve each ABI and collect the results
+        let abis = match self.abis {
+            Some(abis) => {
+                abis.into_iter()
+                    .map(|unresolved_abi| {
+                        let resolver = Arc::clone(resolver);
+                        let logger = logger.clone();
+                        async move {
+                            let resolved_abi = unresolved_abi
+                                .resolve(deployment_hash, &resolver, &logger)
+                                .await?;
+                            Ok::<_, Error>(resolved_abi)
+                        }
+                    })
+                    .collect::<FuturesOrdered<_>>()
+                    .try_collect::<Vec<_>>()
+                    .await?
+            }
+            None => Vec::new(),
+        };
+
+        // Parse API version for spec version validation
+        let api_version = semver::Version::parse(&self.api_version)?;
+
+        // Resolve handlers with ABI context
+        let resolved_handlers = if abis.is_empty() {
+            // If no ABIs are available, just pass through (for backward compatibility)
+            self.handlers
+                .into_iter()
+                .map(|handler| {
+                    if handler.calls.is_empty() {
+                        Ok(EntityHandler {
+                            handler: handler.handler,
+                            entity: handler.entity,
+                            calls: CallDecls::default(),
+                        })
+                    } else {
+                        Err(anyhow::Error::msg(
+                            "Cannot resolve declarative calls without ABI",
+                        ))
+                    }
+                })
+                .collect::<Result<Vec<_>, _>>()?
+        } else {
+            // Resolve using the first available ABI (subgraph data sources typically have one ABI)
+            let (_, abi_json) = &abis[0];
+            self.handlers
+                .into_iter()
+                .map(|handler| handler.resolve(abi_json, spec_version))
+                .collect::<Result<Vec<_>, _>>()?
+        };
+
+        // Extract just the MappingABIs for the final Mapping struct
+        let mapping_abis = abis.into_iter().map(|(abi, _)| Arc::new(abi)).collect();
+
+        Ok(Mapping {
+            language: self.language,
+            api_version,
+            entities: self.entities,
+            handlers: resolved_handlers,
+            abis: mapping_abis,
+            runtime: Arc::new(
+                resolver
+                    .cat(
+                        &LinkResolverContext::new(deployment_hash, logger),
+                        &self.file,
+                    )
+                    .await?,
+            ),
+            link: self.file,
+        })
+    }
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct UnresolvedDataSourceTemplate {
+    pub kind: String,
+    pub network: Option<String>,
+    pub name: String,
+    pub mapping: UnresolvedMapping,
+}
+
+#[derive(Clone, Debug)]
+pub struct DataSourceTemplate {
+    pub kind: String,
+    pub network: Option<String>,
+    pub name: String,
+    pub manifest_idx: u32,
+    pub mapping: Mapping,
+}
+
+impl From<DataSourceTemplate> for DataSourceTemplateInfo {
+    fn from(val: DataSourceTemplate) -> Self {
+        let DataSourceTemplate {
+            kind,
+            network: _,
+            name,
+            manifest_idx,
+            mapping,
+        } = val;
+
+        DataSourceTemplateInfo {
+            api_version: mapping.api_version.clone(),
+            runtime: Some(mapping.runtime),
+            name,
+            manifest_idx: Some(manifest_idx),
+            kind: kind.to_string(),
+        }
+    }
+}
+
+impl UnresolvedDataSourceTemplate {
+    pub async fn resolve(
+        self,
+        deployment_hash: &DeploymentHash,
+        resolver: &Arc<dyn LinkResolver>,
+        logger: &Logger,
+        manifest_idx: u32,
+        spec_version: &semver::Version,
+    ) -> Result<DataSourceTemplate, Error> {
+        let kind = self.kind;
+
+        let mapping = self
+            .mapping
+            .resolve(deployment_hash, resolver, logger, spec_version)
+            .await
+            .with_context(|| format!("failed to resolve data source template {}", self.name))?;
+
+        Ok(DataSourceTemplate {
+            kind,
+            network: self.network,
+            name: self.name,
+            manifest_idx,
+            mapping,
+        })
+    }
+}
+
+#[derive(Clone, PartialEq, Debug)]
+pub struct MappingEntityTrigger {
+    pub data: TriggerData,
+    pub calls: Vec<DeclaredCall>,
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct TriggerData {
+    pub source: DeploymentHash,
+    pub entity: EntitySourceOperation,
+    pub source_idx: u32,
+}
+
+impl TriggerData {
+    pub fn new(source: DeploymentHash, entity: EntitySourceOperation, source_idx: u32) -> Self {
+        Self {
+            source,
+            entity,
+            source_idx,
+        }
+    }
+
+    pub fn entity_type(&self) -> &str {
+        self.entity.entity_type.as_str()
+    }
+}
+
+impl Ord for TriggerData {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        match self.source_idx.cmp(&other.source_idx) {
+            std::cmp::Ordering::Equal => self.entity.vid.cmp(&other.entity.vid),
+            ord => ord,
+        }
+    }
+}
+
+impl PartialOrd for TriggerData {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl fmt::Debug for TriggerData {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "TriggerData {{ source: {:?}, entity: {:?} }}",
+            self.source, self.entity,
+        )
+    }
+}
diff --git a/graph/src/data_source/tests.rs b/graph/src/data_source/tests.rs
index 7a8750748d5..93818f5bb8f 100644
--- a/graph/src/data_source/tests.rs
+++ b/graph/src/data_source/tests.rs
@@ -2,7 +2,7 @@ use cid::Cid;
 
 use crate::{
     blockchain::mock::{MockBlockchain, MockDataSource},
-    ipfs_client::CidFile,
+    ipfs::ContentPath,
     prelude::Link,
 };
 
@@ -31,10 +31,7 @@ fn offchain_duplicate() {
     assert!(!a.is_duplicate_of(&c));
 
     let mut c = a.clone();
-    c.source = Source::Ipfs(CidFile {
-        cid: Cid::default(),
-        path: Some("/foo".into()),
-    });
+    c.source = Source::Ipfs(ContentPath::new(format!("{}/foo", Cid::default())).unwrap());
     assert!(!a.is_duplicate_of(&c));
 
     let mut c = a.clone();
@@ -54,10 +51,12 @@ fn data_source_helpers() {
     let offchain = new_datasource();
     let offchain_ds = DataSource::<MockBlockchain>::Offchain(offchain.clone());
     assert!(offchain_ds.causality_region() == offchain.causality_region);
-    assert!(offchain_ds
-        .as_offchain()
-        .unwrap()
-        .is_duplicate_of(&offchain));
+    assert!(
+        offchain_ds
+            .as_offchain()
+            .unwrap()
+            .is_duplicate_of(&offchain)
+    );
 
     let onchain = DataSource::<MockBlockchain>::Onchain(MockDataSource {
         api_version: Version::new(1, 0, 0),
@@ -73,10 +72,7 @@ fn new_datasource() -> offchain::DataSource {
         offchain::OffchainDataSourceKind::Ipfs,
         "theName".into(),
         0,
-        Source::Ipfs(CidFile {
-            cid: Cid::default(),
-            path: None,
-        }),
+        Source::Ipfs(ContentPath::new(Cid::default().to_string()).unwrap()),
         Mapping {
             language: String::new(),
             api_version: Version::new(0, 0, 0),
diff --git a/graph/src/endpoint.rs b/graph/src/endpoint.rs
index bff6b0c53f9..a62dc07f2ba 100644
--- a/graph/src/endpoint.rs
+++ b/graph/src/endpoint.rs
@@ -1,30 +1,28 @@
 use std::{
     collections::HashMap,
     sync::{
-        atomic::{AtomicU64, Ordering},
         Arc,
+        atomic::{AtomicU64, Ordering},
     },
 };
 
 use prometheus::IntCounterVec;
-use slog::{warn, Logger};
+use slog::{Logger, warn};
 
+use crate::components::network_provider::ProviderName;
 use crate::{components::metrics::MetricsRegistry, data::value::Word};
 
 /// ProviderCount is the underlying structure to keep the count,
 /// we require that all the hosts are known ahead of time, this way we can
 /// avoid locking since we don't need to modify the entire struture.
-type ProviderCount = Arc<HashMap<Provider, AtomicU64>>;
-
-/// Provider represents label of the underlying endpoint.
-pub type Provider = Word;
+type ProviderCount = Arc<HashMap<ProviderName, AtomicU64>>;
 
 /// This struct represents all the current labels except for the result
 /// which is added separately. If any new labels are necessary they should
 /// remain in the same order as added in [`EndpointMetrics::new`]
 #[derive(Clone)]
 pub struct RequestLabels {
-    pub provider: Provider,
+    pub provider: ProviderName,
     pub req_type: Word,
     pub conn_type: ConnectionType,
 }
@@ -33,15 +31,13 @@ pub struct RequestLabels {
 #[derive(Clone)]
 pub enum ConnectionType {
     Firehose,
-    Substreams,
     Rpc,
 }
 
-impl Into<&str> for &ConnectionType {
-    fn into(self) -> &'static str {
-        match self {
+impl From<&ConnectionType> for &str {
+    fn from(val: &ConnectionType) -> Self {
+        match val {
             ConnectionType::Firehose => "firehose",
-            ConnectionType::Substreams => "substreams",
             ConnectionType::Rpc => "rpc",
         }
     }
@@ -84,7 +80,7 @@ impl EndpointMetrics {
         let providers = Arc::new(HashMap::from_iter(
             providers
                 .iter()
-                .map(|h| (Provider::from(h.as_ref()), AtomicU64::new(0))),
+                .map(|h| (ProviderName::from(h.as_ref()), AtomicU64::new(0))),
         ));
 
         let counter = registry
@@ -104,7 +100,7 @@ impl EndpointMetrics {
 
     /// This should only be used for testing.
     pub fn mock() -> Self {
-        use slog::{o, Discard};
+        use slog::{Discard, o};
         let providers: &[&str] = &[];
         Self::new(
             Logger::root(Discard, o!()),
@@ -114,7 +110,7 @@ impl EndpointMetrics {
     }
 
     #[cfg(debug_assertions)]
-    pub fn report_for_test(&self, provider: &Provider, success: bool) {
+    pub fn report_for_test(&self, provider: &ProviderName, success: bool) {
         match success {
             true => self.success(&RequestLabels {
                 provider: provider.clone(),
@@ -161,7 +157,7 @@ impl EndpointMetrics {
 
     /// Returns the current error count of a host or 0 if the host
     /// doesn't have a value on the map.
-    pub fn get_count(&self, provider: &Provider) -> u64 {
+    pub fn get_count(&self, provider: &ProviderName) -> u64 {
         self.providers
             .get(provider)
             .map(|c| c.load(Ordering::Relaxed))
@@ -173,16 +169,17 @@ impl EndpointMetrics {
 mod test {
     use std::sync::Arc;
 
-    use slog::{o, Discard, Logger};
+    use slog::{Discard, Logger, o};
 
     use crate::{
         components::metrics::MetricsRegistry,
-        endpoint::{EndpointMetrics, Provider},
+        endpoint::{EndpointMetrics, ProviderName},
     };
 
-    #[tokio::test]
+    #[crate::test]
     async fn should_increment_and_reset() {
-        let (a, b, c): (Provider, Provider, Provider) = ("a".into(), "b".into(), "c".into());
+        let (a, b, c): (ProviderName, ProviderName, ProviderName) =
+            ("a".into(), "b".into(), "c".into());
         let hosts: &[&str] = &[&a, &b, &c];
         let logger = Logger::root(Discard, o!());
 
diff --git a/graph/src/env/amp.rs b/graph/src/env/amp.rs
new file mode 100644
index 00000000000..93cf5868f2b
--- /dev/null
+++ b/graph/src/env/amp.rs
@@ -0,0 +1,76 @@
+use std::time::Duration;
+
+/// Contains environment variables related to Amp subgraphs.
+#[derive(Debug)]
+pub struct AmpEnv {
+    /// Maximum number of record batches to buffer in memory per stream for each SQL query.
+    /// This is the maximum number of record batches that can be output by a single block.
+    ///
+    /// Defaults to `1,000`.
+    pub buffer_size: usize,
+
+    /// Maximum number of blocks to request per stream for each SQL query.
+    /// Limiting this value reduces load on the Amp server when processing heavy queries.
+    ///
+    /// Defaults to `100,000`.
+    pub block_range: usize,
+
+    /// Minimum time to wait before retrying a failed SQL query to the Amp server.
+    ///
+    /// Defaults to `1` second.
+    pub query_retry_min_delay: Duration,
+
+    /// Maximum time to wait before retrying a failed SQL query to the Amp server.
+    ///
+    /// Defaults to `600` seconds.
+    pub query_retry_max_delay: Duration,
+
+    /// Token used to authenticate Amp Flight gRPC service requests.
+    ///
+    /// Defaults to `None`.
+    pub flight_service_token: Option<String>,
+}
+
+impl AmpEnv {
+    const DEFAULT_BUFFER_SIZE: usize = 1_000;
+    const DEFAULT_BLOCK_RANGE: usize = 100_000;
+    const DEFAULT_QUERY_RETRY_MIN_DELAY: Duration = Duration::from_secs(1);
+    const DEFAULT_QUERY_RETRY_MAX_DELAY: Duration = Duration::from_secs(600);
+
+    pub(super) fn new(raw_env: &super::Inner) -> Self {
+        Self {
+            buffer_size: raw_env
+                .amp_buffer_size
+                .and_then(|value| {
+                    if value == 0 {
+                        return None;
+                    }
+                    Some(value)
+                })
+                .unwrap_or(Self::DEFAULT_BUFFER_SIZE),
+            block_range: raw_env
+                .amp_block_range
+                .map(|mut value| {
+                    if value == 0 {
+                        value = usize::MAX;
+                    }
+                    value
+                })
+                .unwrap_or(Self::DEFAULT_BLOCK_RANGE),
+            query_retry_min_delay: raw_env
+                .amp_query_retry_min_delay_seconds
+                .map(Duration::from_secs)
+                .unwrap_or(Self::DEFAULT_QUERY_RETRY_MIN_DELAY),
+            query_retry_max_delay: raw_env
+                .amp_query_retry_max_delay_seconds
+                .map(Duration::from_secs)
+                .unwrap_or(Self::DEFAULT_QUERY_RETRY_MAX_DELAY),
+            flight_service_token: raw_env.amp_flight_service_token.as_ref().and_then(|value| {
+                if value.is_empty() {
+                    return None;
+                }
+                Some(value.to_string())
+            }),
+        }
+    }
+}
diff --git a/graph/src/env/graphql.rs b/graph/src/env/graphql.rs
index 05e4c6991fb..f4563155493 100644
--- a/graph/src/env/graphql.rs
+++ b/graph/src/env/graphql.rs
@@ -53,6 +53,12 @@ pub struct EnvVarsGraphQl {
     /// Set by the environment variable `GRAPH_QUERY_CACHE_STALE_PERIOD`. The
     /// default value is 100.
     pub query_cache_stale_period: u64,
+    /// Limits the maximum size of a cache entry. Query results larger than
+    /// the size of a cache shard divided by this value will not be cached.
+    /// Set by `GRAPH_QUERY_CACHE_MAX_ENTRY_RATIO`. The default is 3. A
+    /// value of 0 means that there is no limit on the size of a cache
+    /// entry.
+    pub query_cache_max_entry_ratio: usize,
     /// Set by the environment variable `GRAPH_GRAPHQL_QUERY_TIMEOUT` (expressed in
     /// seconds). No default value is provided.
     pub query_timeout: Option<Duration>,
@@ -80,9 +86,6 @@ pub struct EnvVarsGraphQl {
     /// Set by the environment variable `GRAPH_GRAPHQL_ERROR_RESULT_SIZE`. The
     /// default value is [`usize::MAX`].
     pub error_result_size: usize,
-    /// Set by the flag `GRAPH_GRAPHQL_MAX_OPERATIONS_PER_CONNECTION`.
-    /// Defaults to 1000.
-    pub max_operations_per_connection: usize,
     /// Set by the flag `GRAPH_GRAPHQL_DISABLE_BOOL_FILTERS`. Off by default.
     /// Disables AND/OR filters
     pub disable_bool_filters: bool,
@@ -94,6 +97,9 @@ pub struct EnvVarsGraphQl {
     /// header `X-GraphTraceQuery` set to this value will include a trace of
     /// the SQL queries that were run.
     pub query_trace_token: String,
+    /// Set by the env var `GRAPH_PARALLEL_BLOCK_CONSTRAINTS`
+    /// Whether to run top-level queries with different block constraints in parallel
+    pub parallel_block_constraints: bool,
 }
 
 // This does not print any values avoid accidentally leaking any sensitive env vars
@@ -126,18 +132,19 @@ impl From<InnerGraphQl> for EnvVarsGraphQl {
             query_cache_blocks: x.query_cache_blocks,
             query_cache_max_mem: x.query_cache_max_mem_in_mb.0 * 1000 * 1000,
             query_cache_stale_period: x.query_cache_stale_period,
+            query_cache_max_entry_ratio: x.query_cache_max_entry_ratio,
             query_timeout: x.query_timeout_in_secs.map(Duration::from_secs),
             max_complexity: x.max_complexity.map(|x| x.0),
             max_depth: x.max_depth.0,
             max_first: x.max_first,
             max_skip: x.max_skip.0,
             allow_deployment_change: x.allow_deployment_change.0,
-            warn_result_size: x.warn_result_size.0 .0,
-            error_result_size: x.error_result_size.0 .0,
-            max_operations_per_connection: x.max_operations_per_connection,
+            warn_result_size: x.warn_result_size.0.0,
+            error_result_size: x.error_result_size.0.0,
             disable_bool_filters: x.disable_bool_filters.0,
             disable_child_sorting: x.disable_child_sorting.0,
             query_trace_token: x.query_trace_token,
+            parallel_block_constraints: x.parallel_block_constraints.0,
         }
     }
 }
@@ -163,6 +170,8 @@ pub struct InnerGraphQl {
     query_cache_max_mem_in_mb: NoUnderscores<usize>,
     #[envconfig(from = "GRAPH_QUERY_CACHE_STALE_PERIOD", default = "100")]
     query_cache_stale_period: u64,
+    #[envconfig(from = "GRAPH_QUERY_CACHE_MAX_ENTRY_RATIO", default = "3")]
+    query_cache_max_entry_ratio: usize,
     #[envconfig(from = "GRAPH_GRAPHQL_QUERY_TIMEOUT")]
     query_timeout_in_secs: Option<u64>,
     #[envconfig(from = "GRAPH_GRAPHQL_MAX_COMPLEXITY")]
@@ -179,12 +188,12 @@ pub struct InnerGraphQl {
     warn_result_size: WithDefaultUsize<NoUnderscores<usize>, { usize::MAX }>,
     #[envconfig(from = "GRAPH_GRAPHQL_ERROR_RESULT_SIZE", default = "")]
     error_result_size: WithDefaultUsize<NoUnderscores<usize>, { usize::MAX }>,
-    #[envconfig(from = "GRAPH_GRAPHQL_MAX_OPERATIONS_PER_CONNECTION", default = "1000")]
-    max_operations_per_connection: usize,
     #[envconfig(from = "GRAPH_GRAPHQL_DISABLE_BOOL_FILTERS", default = "false")]
     pub disable_bool_filters: EnvVarBoolean,
     #[envconfig(from = "GRAPH_GRAPHQL_DISABLE_CHILD_SORTING", default = "false")]
     pub disable_child_sorting: EnvVarBoolean,
     #[envconfig(from = "GRAPH_GRAPHQL_TRACE_TOKEN", default = "")]
     query_trace_token: String,
+    #[envconfig(from = "GRAPH_PARALLEL_BLOCK_CONSTRAINTS", default = "false")]
+    pub parallel_block_constraints: EnvVarBoolean,
 }
diff --git a/graph/src/env/mappings.rs b/graph/src/env/mappings.rs
index 6f7e5022ab3..8acab1b5d05 100644
--- a/graph/src/env/mappings.rs
+++ b/graph/src/env/mappings.rs
@@ -1,7 +1,9 @@
 use std::fmt;
+use std::path::PathBuf;
 
-use super::*;
+use anyhow::anyhow;
 
+use super::*;
 #[derive(Clone)]
 pub struct EnvVarsMapping {
     /// Forces the cache eviction policy to take its own memory overhead into account.
@@ -53,10 +55,49 @@ pub struct EnvVarsMapping {
     ///
     /// Set by the environment variable `GRAPH_IPFS_REQUEST_LIMIT`. Defaults to 100.
     pub ipfs_request_limit: u16,
+    /// Limit of max IPFS attempts to retrieve a file.
+    ///
+    /// Set by the environment variable `GRAPH_IPFS_MAX_ATTEMPTS`. Defaults to 100000.
+    pub ipfs_max_attempts: usize,
+
+    /// Set by the flag `GRAPH_IPFS_CACHE_LOCATION`.
+    pub ipfs_cache_location: Option<PathBuf>,
 
     /// Set by the flag `GRAPH_ALLOW_NON_DETERMINISTIC_IPFS`. Off by
     /// default.
     pub allow_non_deterministic_ipfs: bool,
+
+    /// Set by the flag `GRAPH_DISABLE_DECLARED_CALLS`. Disables performing
+    /// eth calls before running triggers; instead eth calls happen when
+    /// mappings call `ethereum.call`. Off by default.
+    pub disable_declared_calls: bool,
+
+    /// Set by the flag `GRAPH_STORE_ERRORS_ARE_NON_DETERMINISTIC`. Off by
+    /// default. Setting this to `true` will revert to the old behavior of
+    /// treating all store errors as nondeterministic. This is a temporary
+    /// measure and can be removed after 2025-07-01, once we are sure the
+    /// new behavior works as intended.
+    pub store_errors_are_nondeterministic: bool,
+
+    /// Maximum backoff time for FDS requests. Set by
+    /// `GRAPH_FDS_MAX_BACKOFF` in seconds, defaults to 600.
+    pub fds_max_backoff: Duration,
+
+    /// Cranelift optimization level for WASM compilation.
+    ///
+    /// Set by the environment variable `GRAPH_WASM_OPT_LEVEL`. Valid values
+    /// are `none`, `speed`, and `speed_and_size`. The default value is
+    /// `speed`.
+    pub wasm_opt_level: WasmOptLevel,
+}
+
+/// Cranelift optimization level for WASM compilation. Maps to
+/// `wasmtime::OptLevel` without introducing a dependency on wasmtime.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum WasmOptLevel {
+    None,
+    Speed,
+    SpeedAndSize,
 }
 
 // This does not print any values avoid accidentally leaking any sensitive env vars
@@ -66,15 +107,49 @@ impl fmt::Debug for EnvVarsMapping {
     }
 }
 
-impl From<InnerMappingHandlers> for EnvVarsMapping {
-    fn from(x: InnerMappingHandlers) -> Self {
-        Self {
+impl fmt::Display for WasmOptLevel {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            WasmOptLevel::None => write!(f, "none"),
+            WasmOptLevel::Speed => write!(f, "speed"),
+            WasmOptLevel::SpeedAndSize => write!(f, "speed_and_size"),
+        }
+    }
+}
+
+impl FromStr for WasmOptLevel {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "none" => Ok(WasmOptLevel::None),
+            "speed" => Ok(WasmOptLevel::Speed),
+            "speed_and_size" => Ok(WasmOptLevel::SpeedAndSize),
+            _ => Err(format!(
+                "invalid GRAPH_WASM_OPT_LEVEL '{}', expected 'none', 'speed', or 'speed_and_size'",
+                s
+            )),
+        }
+    }
+}
+
+impl TryFrom<InnerMappingHandlers> for EnvVarsMapping {
+    type Error = anyhow::Error;
+
+    fn try_from(x: InnerMappingHandlers) -> Result<Self, Self::Error> {
+        let ipfs_cache_location = x
+            .ipfs_cache_location
+            .map(PathBuf::from)
+            .map(validate_ipfs_cache_location)
+            .transpose()?;
+
+        let vars = Self {
             entity_cache_dead_weight: x.entity_cache_dead_weight.0,
             entity_cache_size: x.entity_cache_size_in_kb * 1000,
 
             max_api_version: x.max_api_version,
             timeout: x.mapping_handler_timeout_in_secs.map(Duration::from_secs),
-            max_stack_size: x.runtime_max_stack_size.0 .0,
+            max_stack_size: x.runtime_max_stack_size.0.0,
 
             max_ipfs_cache_file_size: x.max_ipfs_cache_file_size.0,
             max_ipfs_cache_size: x.max_ipfs_cache_size,
@@ -82,8 +157,15 @@ impl From<InnerMappingHandlers> for EnvVarsMapping {
             max_ipfs_map_file_size: x.max_ipfs_map_file_size.0,
             max_ipfs_file_bytes: x.max_ipfs_file_bytes.0,
             ipfs_request_limit: x.ipfs_request_limit,
+            ipfs_max_attempts: x.ipfs_max_attempts,
+            ipfs_cache_location,
             allow_non_deterministic_ipfs: x.allow_non_deterministic_ipfs.0,
-        }
+            disable_declared_calls: x.disable_declared_calls.0,
+            store_errors_are_nondeterministic: x.store_errors_are_nondeterministic.0,
+            fds_max_backoff: Duration::from_secs(x.fds_max_backoff),
+            wasm_opt_level: x.wasm_opt_level,
+        };
+        Ok(vars)
     }
 }
 
@@ -93,7 +175,7 @@ pub struct InnerMappingHandlers {
     entity_cache_dead_weight: EnvVarBoolean,
     #[envconfig(from = "GRAPH_ENTITY_CACHE_SIZE", default = "10000")]
     entity_cache_size_in_kb: usize,
-    #[envconfig(from = "GRAPH_MAX_API_VERSION", default = "0.0.8")]
+    #[envconfig(from = "GRAPH_MAX_API_VERSION", default = "0.0.10")]
     max_api_version: Version,
     #[envconfig(from = "GRAPH_MAPPING_HANDLER_TIMEOUT")]
     mapping_handler_timeout_in_secs: Option<u64>,
@@ -113,6 +195,51 @@ pub struct InnerMappingHandlers {
     max_ipfs_file_bytes: WithDefaultUsize<usize, { 25 * 1024 * 1024 }>,
     #[envconfig(from = "GRAPH_IPFS_REQUEST_LIMIT", default = "100")]
     ipfs_request_limit: u16,
+    #[envconfig(from = "GRAPH_IPFS_MAX_ATTEMPTS", default = "100000")]
+    ipfs_max_attempts: usize,
+    #[envconfig(from = "GRAPH_IPFS_CACHE_LOCATION")]
+    ipfs_cache_location: Option<String>,
     #[envconfig(from = "GRAPH_ALLOW_NON_DETERMINISTIC_IPFS", default = "false")]
     allow_non_deterministic_ipfs: EnvVarBoolean,
+    #[envconfig(from = "GRAPH_DISABLE_DECLARED_CALLS", default = "false")]
+    disable_declared_calls: EnvVarBoolean,
+    #[envconfig(from = "GRAPH_STORE_ERRORS_ARE_NON_DETERMINISTIC", default = "false")]
+    store_errors_are_nondeterministic: EnvVarBoolean,
+    #[envconfig(from = "GRAPH_FDS_MAX_BACKOFF", default = "600")]
+    fds_max_backoff: u64,
+    #[envconfig(from = "GRAPH_WASM_OPT_LEVEL", default = "speed")]
+    wasm_opt_level: WasmOptLevel,
+}
+
+fn validate_ipfs_cache_location(path: PathBuf) -> Result<PathBuf, anyhow::Error> {
+    if path.starts_with("redis://") {
+        // We validate this later when we set up the Redis client
+        return Ok(path);
+    }
+    let path = path.canonicalize().map_err(|e| {
+        anyhow!(
+            "GRAPH_IPFS_CACHE_LOCATION {} is invalid: {e}",
+            path.display()
+        )
+    })?;
+    if !path.is_absolute() {
+        return Err(anyhow::anyhow!(
+            "GRAPH_IPFS_CACHE_LOCATION must be an absolute path: {}",
+            path.display()
+        ));
+    }
+    if !path.is_dir() {
+        return Err(anyhow::anyhow!(
+            "GRAPH_IPFS_CACHE_LOCATION must be a directory: {}",
+            path.display()
+        ));
+    }
+    let metadata = path.metadata()?;
+    if metadata.permissions().readonly() {
+        return Err(anyhow::anyhow!(
+            "GRAPH_IPFS_CACHE_LOCATION must be a writable directory: {}",
+            path.display()
+        ));
+    }
+    Ok(path)
 }
diff --git a/graph/src/env/mod.rs b/graph/src/env/mod.rs
index 9e73abfde5f..54c585d5ab3 100644
--- a/graph/src/env/mod.rs
+++ b/graph/src/env/mod.rs
@@ -1,23 +1,38 @@
+mod amp;
 mod graphql;
 mod mappings;
 mod store;
 
+use std::{collections::HashSet, env::VarError, fmt, str::FromStr, sync::Arc, time::Duration};
+
 use envconfig::Envconfig;
 use lazy_static::lazy_static;
 use semver::Version;
-use std::{collections::HashSet, env::VarError, fmt, str::FromStr, time::Duration};
 
 use self::graphql::*;
 use self::mappings::*;
+
+pub use self::mappings::WasmOptLevel;
 use self::store::*;
 use crate::{
     components::{store::BlockNumber, subgraph::SubgraphVersionSwitchingMode},
     runtime::gas::CONST_MAX_GAS_PER_HANDLER,
 };
 
+pub use self::amp::AmpEnv;
+
+#[cfg(debug_assertions)]
+use std::sync::Mutex;
+
 lazy_static! {
     pub static ref ENV_VARS: EnvVars = EnvVars::from_env().unwrap();
 }
+#[cfg(debug_assertions)]
+lazy_static! {
+    pub static ref TEST_WITH_NO_REORG: Mutex<bool> = Mutex::new(false);
+    pub static ref TEST_SQL_QUERIES_ENABLED: Mutex<bool> = Mutex::new(false);
+    pub static ref TEST_STORE_CALL_CACHE_DISABLED: Mutex<bool> = Mutex::new(false);
+}
 
 /// Panics if:
 /// - The value is not UTF8.
@@ -42,6 +57,7 @@ pub struct EnvVars {
     pub graphql: EnvVarsGraphQl,
     pub mappings: EnvVarsMapping,
     pub store: EnvVarsStore,
+    pub amp: Arc<AmpEnv>,
 
     /// Enables query throttling when getting database connections goes over this value.
     /// Load management can be disabled by setting this to 0.
@@ -70,8 +86,7 @@ pub struct EnvVars {
     /// assertions](https://doc.rust-lang.org/reference/conditional-compilation.html#debug_assertions)
     /// are enabled.
     pub allow_non_deterministic_fulltext_search: bool,
-    /// Set by the environment variable `GRAPH_MAX_SPEC_VERSION`. The default
-    /// value is `0.0.7`.
+    /// Set by the environment variable `GRAPH_MAX_SPEC_VERSION`.
     pub max_spec_version: Version,
     /// Set by the environment variable `GRAPH_LOAD_WINDOW_SIZE` (expressed in
     /// seconds). The default value is 300 seconds.
@@ -86,6 +101,9 @@ pub struct EnvVars {
     /// Set by the environment variable
     /// `GRAPH_ELASTIC_SEARCH_MAX_RETRIES`. The default value is 5.
     pub elastic_search_max_retries: usize,
+    /// The name of the index in ElasticSearch to which we should log. Set
+    /// by `GRAPH_ELASTIC_SEARCH_INDEX`. The default is `subgraph`.
+    pub elastic_search_index: String,
     /// If an instrumented lock is contended for longer than the specified
     /// duration, a warning will be logged.
     ///
@@ -147,9 +165,21 @@ pub struct EnvVars {
     pub subgraph_error_retry_jitter: f64,
     /// Experimental feature.
     ///
-    /// Set by the flag `GRAPH_ENABLE_SELECT_BY_SPECIFIC_ATTRIBUTES`. Off by
+    /// Set by the flag `GRAPH_ENABLE_SELECT_BY_SPECIFIC_ATTRIBUTES`. On by
     /// default.
     pub enable_select_by_specific_attributes: bool,
+    /// Experimental feature.
+    ///
+    /// Set the flag `GRAPH_POSTPONE_ATTRIBUTE_INDEX_CREATION`. Off by default.
+    pub postpone_attribute_index_creation: bool,
+    /// When a subgraph gets within this many blocks of the chain head,
+    /// create any indexes whose creation was postponed. Only has an effect
+    /// when `postpone_attribute_index_creation` is set.
+    ///
+    /// Set by the environment variable
+    /// `GRAPH_POSTPONE_INDEXES_CREATION_THRESHOLD`. The default value is
+    /// 10000.
+    pub postpone_indexes_creation_threshold: BlockNumber,
     /// Verbose logging of mapping inputs.
     ///
     /// Set by the flag `GRAPH_LOG_TRIGGER_DATA`. Off by
@@ -175,7 +205,11 @@ pub struct EnvVars {
     pub static_filters_threshold: usize,
     /// Set by the environment variable `ETHEREUM_REORG_THRESHOLD`. The default
     /// value is 250 blocks.
-    pub reorg_threshold: BlockNumber,
+    reorg_threshold: BlockNumber,
+    /// Enable SQL query interface. SQL queries are disabled by default
+    /// because they are still experimental. Set by the environment variable
+    /// `GRAPH_ENABLE_SQL_QUERIES`. Off by default.
+    enable_sql_queries: bool,
     /// The time to wait between polls when using polling block ingestor.
     /// The value is set by `ETHERUM_POLLING_INTERVAL` in millis and the
     /// default is 1000.
@@ -183,11 +217,9 @@ pub struct EnvVars {
     /// Set by the env var `GRAPH_EXPERIMENTAL_SUBGRAPH_SETTINGS` which should point
     /// to a file with subgraph-specific settings
     pub subgraph_settings: Option<String>,
-    /// Whether to prefer substreams blocks streams over firehose when available.
-    pub prefer_substreams_block_streams: bool,
-    /// Set by the flag `GRAPH_ENABLE_GAS_METRICS`. Whether to enable
+    /// Set by the flag `GRAPH_ENABLE_DIPS_METRICS`. Whether to enable
     /// gas metrics. Off by default.
-    pub enable_gas_metrics: bool,
+    pub enable_dips_metrics: bool,
     /// Set by the env var `GRAPH_HISTORY_BLOCKS_OVERRIDE`. Defaults to None
     /// Sets an override for the amount history to keep regardless of the
     /// historyBlocks set in the manifest
@@ -196,19 +228,89 @@ pub struct EnvVars {
     /// The amount of history to keep when using 'min' historyBlocks
     /// in the manifest
     pub min_history_blocks: BlockNumber,
+    /// Set by the env var `dips_metrics_object_store_url`
+    /// The name of the object store bucket to store DIPS metrics
+    pub dips_metrics_object_store_url: Option<String>,
+    /// Write a list of how sections are nested to the file `section_map`
+    /// which must be an absolute path. This only has an effect in debug
+    /// builds. Set with `GRAPH_SECTION_MAP`. Defaults to `None`.
+    pub section_map: Option<String>,
+    /// Set the maximum grpc decode size(in MB) for firehose BlockIngestor connections.
+    /// Defaults to 25MB
+    pub firehose_grpc_max_decode_size_mb: usize,
+    /// Defined whether or not graph-node should refuse to perform genesis validation
+    /// before using an adapter. Disabled by default for the moment, will be enabled
+    /// on the next release. Disabling validation means the recorded genesis will be 0x00
+    /// if no genesis hash can be retrieved from an adapter. If enabled, the adapter is
+    /// ignored if unable to produce a genesis hash or produces a different an unexpected hash.
+    pub genesis_validation_enabled: bool,
+    /// Whether to enforce deployment hash validation rules.
+    /// When disabled, any string can be used as a deployment hash.
+    /// When enabled, deployment hashes must meet length and character constraints.
+    ///
+    /// Set by the flag `GRAPH_NODE_DISABLE_DEPLOYMENT_HASH_VALIDATION`. Enabled by default.
+    pub disable_deployment_hash_validation: bool,
+    /// How long do we wait for a response from the provider before considering that it is unavailable.
+    /// Default is 30s.
+    pub genesis_validation_timeout: Duration,
+
+    /// Sets the token that is used to authenticate graphman GraphQL queries.
+    ///
+    /// If not specified, the graphman server will not start.
+    pub graphman_server_auth_token: Option<String>,
+
+    /// By default, all providers are required to support extended block details,
+    /// as this is the safest option for a graph-node operator.
+    ///
+    /// Providers that do not support extended block details for enabled chains
+    /// are considered invalid and will not be used.
+    ///
+    /// To disable checks for one or more chains, simply specify their names
+    /// in this configuration option.
+    ///
+    /// Defaults to an empty list, which means that this feature is enabled for all chains;
+    pub firehose_disable_extended_blocks_for_chains: Vec<String>,
+
+    pub block_write_capacity: usize,
+
+    /// Set by the environment variable `GRAPH_FIREHOSE_FETCH_BLOCK_RETRY_LIMIT`.
+    /// The default value is 10.
+    pub firehose_block_fetch_retry_limit: usize,
+    /// Set by the environment variable `GRAPH_FIREHOSE_FETCH_BLOCK_TIMEOUT_SECS`.
+    /// The default value is 60 seconds.
+    pub firehose_block_fetch_timeout: u64,
+    /// Set by the environment variable `GRAPH_FIREHOSE_BLOCK_BATCH_SIZE`.
+    /// The default value is 10.
+    pub firehose_block_batch_size: usize,
+    /// Timeouts to use for various IPFS requests set by
+    /// `GRAPH_IPFS_REQUEST_TIMEOUT`. Defaults to 60 seconds for release
+    /// builds and one second for debug builds to speed up tests. The value
+    /// is in seconds.
+    pub ipfs_request_timeout: Duration,
 }
 
 impl EnvVars {
-    pub fn from_env() -> Result<Self, envconfig::Error> {
+    pub fn from_env() -> Result<Self, anyhow::Error> {
         let inner = Inner::init_from_env()?;
         let graphql = InnerGraphQl::init_from_env()?.into();
-        let mapping_handlers = InnerMappingHandlers::init_from_env()?.into();
-        let store = InnerStore::init_from_env()?.into();
+        let mapping_handlers = InnerMappingHandlers::init_from_env()?.try_into()?;
+        let store = InnerStore::init_from_env()?.try_into()?;
+        let ipfs_request_timeout = match inner.ipfs_request_timeout {
+            Some(timeout) => Duration::from_secs(timeout),
+            None => {
+                if cfg!(debug_assertions) {
+                    Duration::from_secs(1)
+                } else {
+                    Duration::from_secs(60)
+                }
+            }
+        };
 
         Ok(Self {
             graphql,
             mappings: mapping_handlers,
             store,
+            amp: Arc::new(AmpEnv::new(&inner)),
 
             load_threshold: Duration::from_millis(inner.load_threshold_in_ms),
             load_jail_threshold: inner.load_jail_threshold,
@@ -224,10 +326,11 @@ impl EnvVars {
                 inner.elastic_search_flush_interval_in_secs,
             ),
             elastic_search_max_retries: inner.elastic_search_max_retries,
+            elastic_search_index: inner.elastic_search_index,
             lock_contention_log_threshold: Duration::from_millis(
                 inner.lock_contention_log_threshold_in_ms,
             ),
-            max_gas_per_handler: inner.max_gas_per_handler.0 .0,
+            max_gas_per_handler: inner.max_gas_per_handler.0.0,
             log_query_timing: inner
                 .log_query_timing
                 .split(',')
@@ -248,6 +351,9 @@ impl EnvVars {
             subgraph_error_retry_ceil: Duration::from_secs(inner.subgraph_error_retry_ceil_in_secs),
             subgraph_error_retry_jitter: inner.subgraph_error_retry_jitter,
             enable_select_by_specific_attributes: inner.enable_select_by_specific_attributes.0,
+            postpone_attribute_index_creation: inner.postpone_attribute_index_creation.0
+                || cfg!(debug_assertions),
+            postpone_indexes_creation_threshold: inner.postpone_indexes_creation_threshold,
             log_trigger_data: inner.log_trigger_data.0,
             explorer_ttl: Duration::from_secs(inner.explorer_ttl_in_secs),
             explorer_lock_threshold: Duration::from_millis(inner.explorer_lock_threshold_in_msec),
@@ -256,14 +362,30 @@ impl EnvVars {
             external_ws_base_url: inner.external_ws_base_url,
             static_filters_threshold: inner.static_filters_threshold,
             reorg_threshold: inner.reorg_threshold,
+            enable_sql_queries: inner.enable_sql_queries.0,
             ingestor_polling_interval: Duration::from_millis(inner.ingestor_polling_interval),
             subgraph_settings: inner.subgraph_settings,
-            prefer_substreams_block_streams: inner.prefer_substreams_block_streams,
-            enable_gas_metrics: inner.enable_gas_metrics.0,
+            enable_dips_metrics: inner.enable_dips_metrics.0,
             history_blocks_override: inner.history_blocks_override,
             min_history_blocks: inner
                 .min_history_blocks
                 .unwrap_or(2 * inner.reorg_threshold),
+            dips_metrics_object_store_url: inner.dips_metrics_object_store_url,
+            section_map: inner.section_map,
+            firehose_grpc_max_decode_size_mb: inner.firehose_grpc_max_decode_size_mb,
+            genesis_validation_enabled: inner.genesis_validation_enabled.0,
+            disable_deployment_hash_validation: inner.disable_deployment_hash_validation.0,
+            genesis_validation_timeout: Duration::from_secs(inner.genesis_validation_timeout),
+            graphman_server_auth_token: inner.graphman_server_auth_token,
+            firehose_disable_extended_blocks_for_chains:
+                Self::firehose_disable_extended_blocks_for_chains(
+                    inner.firehose_disable_extended_blocks_for_chains,
+                ),
+            block_write_capacity: inner.block_write_capacity.0,
+            firehose_block_fetch_retry_limit: inner.firehose_block_fetch_retry_limit,
+            firehose_block_fetch_timeout: inner.firehose_block_fetch_timeout,
+            firehose_block_batch_size: inner.firehose_block_fetch_batch_size,
+            ipfs_request_timeout,
         })
     }
 
@@ -288,6 +410,71 @@ impl EnvVars {
     pub fn log_gql_cache_timing(&self) -> bool {
         self.log_query_timing_contains("cache") && self.log_gql_timing()
     }
+
+    fn firehose_disable_extended_blocks_for_chains(s: Option<String>) -> Vec<String> {
+        s.unwrap_or_default()
+            .split(",")
+            .map(|x| x.trim().to_string())
+            .filter(|x| !x.is_empty())
+            .collect()
+    }
+    #[cfg(debug_assertions)]
+    pub fn reorg_threshold(&self) -> i32 {
+        // The default reorganization (reorg) threshold is set to 250.
+        // For testing purposes, we need to set this threshold to 0 because:
+        // 1. Many tests involve reverting blocks.
+        // 2. Blocks cannot be reverted below the reorg threshold.
+        // Therefore, during tests, we want to set the reorg threshold to 0.
+        if *TEST_WITH_NO_REORG.lock().unwrap() {
+            0
+        } else {
+            self.reorg_threshold
+        }
+    }
+    #[cfg(not(debug_assertions))]
+    pub fn reorg_threshold(&self) -> i32 {
+        self.reorg_threshold
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn sql_queries_enabled(&self) -> bool {
+        // SQL queries are disabled by default for security.
+        // For testing purposes, we allow tests to enable SQL queries via TEST_SQL_QUERIES_ENABLED.
+        if *TEST_SQL_QUERIES_ENABLED.lock().unwrap() {
+            true
+        } else {
+            self.enable_sql_queries
+        }
+    }
+    #[cfg(not(debug_assertions))]
+    pub fn sql_queries_enabled(&self) -> bool {
+        self.enable_sql_queries
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn enable_sql_queries_for_tests(&self, enable: bool) {
+        let mut lock = TEST_SQL_QUERIES_ENABLED.lock().unwrap();
+        *lock = enable;
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn store_call_cache_disabled(&self) -> bool {
+        if *TEST_STORE_CALL_CACHE_DISABLED.lock().unwrap() {
+            true
+        } else {
+            self.store.disable_call_cache
+        }
+    }
+
+    #[cfg(not(debug_assertions))]
+    pub fn store_call_cache_disabled(&self) -> bool {
+        self.store.disable_call_cache
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn set_store_call_cache_disabled_for_tests(&self, value: bool) {
+        *TEST_STORE_CALL_CACHE_DISABLED.lock().unwrap() = value;
+    }
 }
 
 impl Default for EnvVars {
@@ -316,7 +503,7 @@ struct Inner {
         default = "false"
     )]
     allow_non_deterministic_fulltext_search: EnvVarBoolean,
-    #[envconfig(from = "GRAPH_MAX_SPEC_VERSION", default = "1.0.0")]
+    #[envconfig(from = "GRAPH_MAX_SPEC_VERSION", default = "1.5.0")]
     max_spec_version: Version,
     #[envconfig(from = "GRAPH_LOAD_WINDOW_SIZE", default = "300")]
     load_window_size_in_secs: u64,
@@ -326,6 +513,8 @@ struct Inner {
     elastic_search_flush_interval_in_secs: u64,
     #[envconfig(from = "GRAPH_ELASTIC_SEARCH_MAX_RETRIES", default = "5")]
     elastic_search_max_retries: usize,
+    #[envconfig(from = "GRAPH_ELASTIC_SEARCH_INDEX", default = "subgraph")]
+    elastic_search_index: String,
     #[envconfig(from = "GRAPH_LOCK_CONTENTION_LOG_THRESHOLD_MS", default = "100")]
     lock_contention_log_threshold_in_ms: u64,
 
@@ -365,8 +554,12 @@ struct Inner {
     subgraph_error_retry_ceil_in_secs: u64,
     #[envconfig(from = "GRAPH_SUBGRAPH_ERROR_RETRY_JITTER", default = "0.2")]
     subgraph_error_retry_jitter: f64,
-    #[envconfig(from = "GRAPH_ENABLE_SELECT_BY_SPECIFIC_ATTRIBUTES", default = "false")]
+    #[envconfig(from = "GRAPH_ENABLE_SELECT_BY_SPECIFIC_ATTRIBUTES", default = "true")]
     enable_select_by_specific_attributes: EnvVarBoolean,
+    #[envconfig(from = "GRAPH_POSTPONE_ATTRIBUTE_INDEX_CREATION", default = "false")]
+    postpone_attribute_index_creation: EnvVarBoolean,
+    #[envconfig(from = "GRAPH_POSTPONE_INDEXES_CREATION_THRESHOLD", default = "10000")]
+    postpone_indexes_creation_threshold: i32,
     #[envconfig(from = "GRAPH_LOG_TRIGGER_DATA", default = "false")]
     log_trigger_data: EnvVarBoolean,
     #[envconfig(from = "GRAPH_EXPLORER_TTL", default = "10")]
@@ -384,21 +577,58 @@ struct Inner {
     // JSON-RPC specific.
     #[envconfig(from = "ETHEREUM_REORG_THRESHOLD", default = "250")]
     reorg_threshold: BlockNumber,
+    #[envconfig(from = "GRAPH_ENABLE_SQL_QUERIES", default = "false")]
+    enable_sql_queries: EnvVarBoolean,
     #[envconfig(from = "ETHEREUM_POLLING_INTERVAL", default = "1000")]
     ingestor_polling_interval: u64,
     #[envconfig(from = "GRAPH_EXPERIMENTAL_SUBGRAPH_SETTINGS")]
     subgraph_settings: Option<String>,
-    #[envconfig(
-        from = "GRAPH_EXPERIMENTAL_PREFER_SUBSTREAMS_BLOCK_STREAMS",
-        default = "false"
-    )]
-    prefer_substreams_block_streams: bool,
-    #[envconfig(from = "GRAPH_ENABLE_GAS_METRICS", default = "false")]
-    enable_gas_metrics: EnvVarBoolean,
+    #[envconfig(from = "GRAPH_ENABLE_DIPS_METRICS", default = "false")]
+    enable_dips_metrics: EnvVarBoolean,
     #[envconfig(from = "GRAPH_HISTORY_BLOCKS_OVERRIDE")]
     history_blocks_override: Option<BlockNumber>,
     #[envconfig(from = "GRAPH_MIN_HISTORY_BLOCKS")]
     min_history_blocks: Option<BlockNumber>,
+    #[envconfig(from = "GRAPH_DIPS_METRICS_OBJECT_STORE_URL")]
+    dips_metrics_object_store_url: Option<String>,
+    #[envconfig(from = "GRAPH_SECTION_MAP")]
+    section_map: Option<String>,
+    #[envconfig(from = "GRAPH_NODE_FIREHOSE_MAX_DECODE_SIZE", default = "25")]
+    firehose_grpc_max_decode_size_mb: usize,
+    #[envconfig(from = "GRAPH_NODE_GENESIS_VALIDATION_ENABLED", default = "false")]
+    genesis_validation_enabled: EnvVarBoolean,
+    #[envconfig(from = "GRAPH_NODE_GENESIS_VALIDATION_TIMEOUT_SECONDS", default = "30")]
+    genesis_validation_timeout: u64,
+    #[envconfig(from = "GRAPHMAN_SERVER_AUTH_TOKEN")]
+    graphman_server_auth_token: Option<String>,
+    #[envconfig(from = "GRAPH_NODE_FIREHOSE_DISABLE_EXTENDED_BLOCKS_FOR_CHAINS")]
+    firehose_disable_extended_blocks_for_chains: Option<String>,
+    #[envconfig(from = "GRAPH_NODE_BLOCK_WRITE_CAPACITY", default = "4_000_000_000")]
+    block_write_capacity: NoUnderscores<usize>,
+    #[envconfig(from = "GRAPH_FIREHOSE_FETCH_BLOCK_RETRY_LIMIT", default = "10")]
+    firehose_block_fetch_retry_limit: usize,
+    #[envconfig(from = "GRAPH_FIREHOSE_FETCH_BLOCK_TIMEOUT_SECS", default = "60")]
+    firehose_block_fetch_timeout: u64,
+    #[envconfig(from = "GRAPH_FIREHOSE_FETCH_BLOCK_BATCH_SIZE", default = "10")]
+    firehose_block_fetch_batch_size: usize,
+    #[envconfig(from = "GRAPH_IPFS_REQUEST_TIMEOUT")]
+    ipfs_request_timeout: Option<u64>,
+    #[envconfig(
+        from = "GRAPH_NODE_DISABLE_DEPLOYMENT_HASH_VALIDATION",
+        default = "false"
+    )]
+    disable_deployment_hash_validation: EnvVarBoolean,
+
+    #[envconfig(from = "GRAPH_AMP_BUFFER_SIZE")]
+    amp_buffer_size: Option<usize>,
+    #[envconfig(from = "GRAPH_AMP_BLOCK_RANGE")]
+    amp_block_range: Option<usize>,
+    #[envconfig(from = "GRAPH_AMP_QUERY_RETRY_MIN_DELAY_SECONDS")]
+    amp_query_retry_min_delay_seconds: Option<u64>,
+    #[envconfig(from = "GRAPH_AMP_QUERY_RETRY_MAX_DELAY_SECONDS")]
+    amp_query_retry_max_delay_seconds: Option<u64>,
+    #[envconfig(from = "GRAPH_AMP_FLIGHT_SERVICE_TOKEN")]
+    amp_flight_service_token: Option<String>,
 }
 
 #[derive(Clone, Debug)]
diff --git a/graph/src/env/store.rs b/graph/src/env/store.rs
index ef1e31fa659..92c5564d17f 100644
--- a/graph/src/env/store.rs
+++ b/graph/src/env/store.rs
@@ -15,6 +15,10 @@ pub struct EnvVarsStore {
     /// Set by the environment variable `GRAPH_QUERY_STATS_REFRESH_INTERVAL`
     /// (expressed in seconds). The default value is 300 seconds.
     pub query_stats_refresh_interval: Duration,
+    /// How long entries in the schema cache are kept before they are
+    /// evicted in seconds. Defaults to
+    /// `2*GRAPH_QUERY_STATS_REFRESH_INTERVAL`
+    pub schema_cache_ttl: Duration,
     /// This can be used to effectively disable the query semaphore by setting
     /// it to a high number, but there's typically no need to configure this.
     ///
@@ -45,13 +49,6 @@ pub struct EnvVarsStore {
     /// only as an emergency setting for the hosted service. Remove after
     /// 2022-07-01 if hosted service had no issues with it being `true`
     pub order_by_block_range: bool,
-    /// Whether to disable the notifications that feed GraphQL
-    /// subscriptions. When the flag is set, no updates
-    /// about entity changes will be sent to query nodes.
-    ///
-    /// Set by the flag `GRAPH_DISABLE_SUBSCRIPTION_NOTIFICATIONS`. Not set
-    /// by default.
-    pub disable_subscription_notifications: bool,
     /// Set by the environment variable `GRAPH_REMOVE_UNUSED_INTERVAL`
     /// (expressed in minutes). The default value is 360 minutes.
     pub remove_unused_interval: chrono::Duration,
@@ -66,6 +63,10 @@ pub struct EnvVarsStore {
     /// Set by the environment variable `GRAPH_STORE_CONNECTION_TIMEOUT` (expressed
     /// in milliseconds). The default value is 5000ms.
     pub connection_timeout: Duration,
+    /// Set by `GRAPH_STORE_SETUP_TIMEOUT` (in milliseconds). Default: 30000ms.
+    /// Used during database setup (migrations, schema creation) which can
+    /// legitimately take longer than normal operations.
+    pub setup_timeout: Duration,
     /// Set by the environment variable `GRAPH_STORE_CONNECTION_MIN_IDLE`. No
     /// default value is provided.
     pub connection_min_idle: Option<u32>,
@@ -84,6 +85,22 @@ pub struct EnvVarsStore {
     /// The default is 180s.
     pub batch_target_duration: Duration,
 
+    /// Cancel and reset a batch copy operation if it takes longer than
+    /// this. Set by `GRAPH_STORE_BATCH_TIMEOUT`. Unlimited by default
+    pub batch_timeout: Option<Duration>,
+
+    /// The number of workers to use for batch operations. If there are idle
+    /// connections, each subgraph copy operation will use up to this many
+    /// workers to copy tables in parallel. Defaults to 1 and must be at
+    /// least 1
+    pub batch_workers: usize,
+
+    /// How long to wait to get an additional connection for a batch worker.
+    /// This should just be big enough to allow the connection pool to
+    /// establish a connection. Set by `GRAPH_STORE_BATCH_WORKER_WAIT`.
+    /// Value is in ms and defaults to 2000ms
+    pub batch_worker_wait: Duration,
+
     /// Prune tables where we will remove at least this fraction of entity
     /// versions by rebuilding the table. Set by
     /// `GRAPH_STORE_HISTORY_REBUILD_THRESHOLD`. The default is 0.5
@@ -98,6 +115,13 @@ pub struct EnvVarsStore {
     /// blocks) than its history limit. The default value is 1.2 and the
     /// value must be at least 1.01
     pub history_slack_factor: f64,
+    /// For how many prune runs per deployment to keep status information.
+    /// Set by `GRAPH_STORE_HISTORY_KEEP_STATUS`. The default is 5
+    pub prune_keep_history: usize,
+    /// Temporary switch to disable range bound estimation for pruning.
+    /// Set by `GRAPH_STORE_PRUNE_DISABLE_RANGE_BOUND_ESTIMATION`.
+    /// Defaults to false. Remove after 2025-07-15
+    pub prune_disable_range_bound_estimation: bool,
     /// How long to accumulate changes into a batch before a write has to
     /// happen. Set by the environment variable
     /// `GRAPH_STORE_WRITE_BATCH_DURATION` in seconds. The default is 300s.
@@ -109,6 +133,11 @@ pub struct EnvVarsStore {
     /// is 10_000 which corresponds to 10MB. Setting this to 0 disables
     /// write batching.
     pub write_batch_size: usize,
+    /// Whether to memoize the last operation for each entity in a write
+    /// batch to speed up adding more entities. Set by
+    /// `GRAPH_STORE_WRITE_BATCH_MEMOIZE`. The default is `true`.
+    /// Remove after 2025-07-01 if there have been no issues with it.
+    pub write_batch_memoize: bool,
     /// Whether to create GIN indexes for array attributes. Set by
     /// `GRAPH_STORE_CREATE_GIN_INDEXES`. The default is `false`
     pub create_gin_indexes: bool,
@@ -116,6 +145,46 @@ pub struct EnvVarsStore {
     pub use_brin_for_all_query_types: bool,
     /// Temporary env var to disable certain lookups in the chain store
     pub disable_block_cache_for_lookup: bool,
+    /// When set, block reads for blocks that are more than `cache_size`
+    /// blocks behind the chain head will act as if the data field in
+    /// the database was null. Set by `GRAPH_STORE_IGNORE_BLOCK_CACHE`.
+    pub ignore_block_cache: bool,
+    /// Safety switch to increase the number of columns used when
+    /// calculating the chunk size in `InsertQuery::chunk_size`. This can be
+    /// used to work around Postgres errors complaining 'number of
+    /// parameters must be between 0 and 65535' when inserting entities
+    pub insert_extra_cols: usize,
+    /// The number of rows to fetch from the foreign data wrapper in one go,
+    /// this will be set as the option 'fetch_size' on all foreign servers
+    pub fdw_fetch_size: usize,
+    /// Experimental feature to automatically set the account-like flag on eligible tables
+    /// Set by the environment variable `GRAPH_STORE_ACCOUNT_LIKE_SCAN_INTERVAL_HOURS`
+    /// If not set, the job is disabled.
+    /// Utilizes materialized view stats that refresh every 6 hours to discover heavy-write tables.
+    pub account_like_scan_interval_hours: Option<u32>,
+    /// Set by the environment variable `GRAPH_STORE_ACCOUNT_LIKE_MIN_VERSIONS_COUNT`
+    /// Tables must have at least this many total versions to be considered.
+    pub account_like_min_versions_count: Option<u64>,
+    /// Set by the environment variable `GRAPH_STORE_ACCOUNT_LIKE_MAX_UNIQUE_RATIO`
+    /// Defines the maximum share of unique entities (e.g. 0.01 for a 1:100 entity-to-version ratio).
+    pub account_like_max_unique_ratio: Option<f64>,
+    /// Disables storing or reading `eth_call` results from the store call cache.
+    /// Set by `GRAPH_STORE_DISABLE_CALL_CACHE`. Defaults to false.
+    pub disable_call_cache: bool,
+    /// Set by `GRAPH_STORE_DISABLE_CHAIN_HEAD_PTR_CACHE`. Default is false.
+    /// Set to true to disable chain_head_ptr caching (safety escape hatch).
+    pub disable_chain_head_ptr_cache: bool,
+    /// Minimum idle time before running connection health check (SELECT 67).
+    /// Connections used more recently than this threshold skip validation.
+    /// Set to 0 to always validate (previous behavior).
+    /// Set by `GRAPH_STORE_CONNECTION_VALIDATION_IDLE_SECS`. Default is 30 seconds.
+    pub connection_validation_idle_secs: Duration,
+    /// When a database shard is marked unavailable due to connection timeouts,
+    /// this controls how often to allow a single probe request through to check
+    /// if the database has recovered. Only one request per interval will attempt
+    /// a connection; all others fail instantly with DatabaseUnavailable.
+    /// Set by `GRAPH_STORE_CONNECTION_UNAVAILABLE_RETRY`. Default is 2 seconds.
+    pub connection_unavailable_retry: Duration,
 }
 
 // This does not print any values avoid accidentally leaking any sensitive env vars
@@ -125,13 +194,19 @@ impl fmt::Debug for EnvVarsStore {
     }
 }
 
-impl From<InnerStore> for EnvVarsStore {
-    fn from(x: InnerStore) -> Self {
-        Self {
+impl TryFrom<InnerStore> for EnvVarsStore {
+    type Error = anyhow::Error;
+
+    fn try_from(x: InnerStore) -> Result<Self, Self::Error> {
+        let vars = Self {
             chain_head_watcher_timeout: Duration::from_secs(x.chain_head_watcher_timeout_in_secs),
             query_stats_refresh_interval: Duration::from_secs(
                 x.query_stats_refresh_interval_in_secs,
             ),
+            schema_cache_ttl: x
+                .schema_cache_ttl
+                .map(Duration::from_secs)
+                .unwrap_or_else(|| Duration::from_secs(2 * x.query_stats_refresh_interval_in_secs)),
             extra_query_permits: x.extra_query_permits,
             large_notification_cleanup_interval: Duration::from_secs(
                 x.large_notification_cleanup_interval_in_secs,
@@ -142,25 +217,64 @@ impl From<InnerStore> for EnvVarsStore {
             typea_batch_size: x.typea_batch_size,
             typed_children_set_size: x.typed_children_set_size,
             order_by_block_range: x.order_by_block_range.0,
-            disable_subscription_notifications: x.disable_subscription_notifications.0,
             remove_unused_interval: chrono::Duration::minutes(
                 x.remove_unused_interval_in_minutes as i64,
             ),
             recent_blocks_cache_capacity: x.recent_blocks_cache_capacity,
             connection_timeout: Duration::from_millis(x.connection_timeout_in_millis),
+            setup_timeout: Duration::from_millis(x.setup_timeout_in_millis),
             connection_min_idle: x.connection_min_idle,
             connection_idle_timeout: Duration::from_secs(x.connection_idle_timeout_in_secs),
             write_queue_size: x.write_queue_size,
+            write_batch_memoize: x.write_batch_memoize,
             batch_target_duration: Duration::from_secs(x.batch_target_duration_in_secs),
+            batch_timeout: x.batch_timeout_in_secs.map(Duration::from_secs),
+            batch_workers: x.batch_workers,
+            batch_worker_wait: Duration::from_millis(x.batch_worker_wait),
             rebuild_threshold: x.rebuild_threshold.0,
             delete_threshold: x.delete_threshold.0,
             history_slack_factor: x.history_slack_factor.0,
+            prune_keep_history: x.prune_keep_status,
+            prune_disable_range_bound_estimation: x.prune_disable_range_bound_estimation,
             write_batch_duration: Duration::from_secs(x.write_batch_duration_in_secs),
             write_batch_size: x.write_batch_size * 1_000,
             create_gin_indexes: x.create_gin_indexes,
             use_brin_for_all_query_types: x.use_brin_for_all_query_types,
             disable_block_cache_for_lookup: x.disable_block_cache_for_lookup,
+            ignore_block_cache: x.ignore_block_cache,
+            insert_extra_cols: x.insert_extra_cols,
+            fdw_fetch_size: x.fdw_fetch_size,
+            account_like_scan_interval_hours: x.account_like_scan_interval_hours,
+            account_like_min_versions_count: x.account_like_min_versions_count,
+            account_like_max_unique_ratio: x.account_like_max_unique_ratio.map(|r| r.0),
+            disable_call_cache: x.disable_call_cache,
+            disable_chain_head_ptr_cache: x.disable_chain_head_ptr_cache,
+            connection_validation_idle_secs: Duration::from_secs(x.connection_validation_idle_secs),
+            connection_unavailable_retry: Duration::from_secs(
+                x.connection_unavailable_retry_in_secs,
+            ),
+        };
+        if let Some(timeout) = vars.batch_timeout
+            && timeout < 2 * vars.batch_target_duration
+        {
+            bail!(
+                "GRAPH_STORE_BATCH_TIMEOUT must be greater than 2*GRAPH_STORE_BATCH_TARGET_DURATION"
+            );
+        }
+        if vars.batch_workers < 1 {
+            bail!("GRAPH_STORE_BATCH_WORKERS must be at least 1");
+        }
+        if vars.account_like_scan_interval_hours.is_some()
+            && (vars.account_like_min_versions_count.is_none()
+                || vars.account_like_max_unique_ratio.is_none())
+        {
+            bail!(
+                "Both GRAPH_STORE_ACCOUNT_LIKE_MIN_VERSIONS_COUNT and \
+                     GRAPH_STORE_ACCOUNT_LIKE_MAX_UNIQUE_RATIO must be set when \
+                     GRAPH_STORE_ACCOUNT_LIKE_SCAN_INTERVAL_HOURS is set"
+            );
         }
+        Ok(vars)
     }
 }
 
@@ -170,6 +284,8 @@ pub struct InnerStore {
     chain_head_watcher_timeout_in_secs: u64,
     #[envconfig(from = "GRAPH_QUERY_STATS_REFRESH_INTERVAL", default = "300")]
     query_stats_refresh_interval_in_secs: u64,
+    #[envconfig(from = "GRAPH_SCHEMA_CACHE_TTL")]
+    schema_cache_ttl: Option<u64>,
     #[envconfig(from = "GRAPH_EXTRA_QUERY_PERMITS", default = "0")]
     extra_query_permits: usize,
     #[envconfig(from = "LARGE_NOTIFICATION_CLEANUP_INTERVAL", default = "300")]
@@ -182,8 +298,6 @@ pub struct InnerStore {
     typed_children_set_size: usize,
     #[envconfig(from = "ORDER_BY_BLOCK_RANGE", default = "true")]
     order_by_block_range: EnvVarBoolean,
-    #[envconfig(from = "GRAPH_DISABLE_SUBSCRIPTION_NOTIFICATIONS", default = "false")]
-    disable_subscription_notifications: EnvVarBoolean,
     #[envconfig(from = "GRAPH_REMOVE_UNUSED_INTERVAL", default = "360")]
     remove_unused_interval_in_minutes: u64,
     #[envconfig(from = "GRAPH_STORE_RECENT_BLOCKS_CACHE_CAPACITY", default = "10")]
@@ -195,6 +309,8 @@ pub struct InnerStore {
     // configured differently for each pool.
     #[envconfig(from = "GRAPH_STORE_CONNECTION_TIMEOUT", default = "5000")]
     connection_timeout_in_millis: u64,
+    #[envconfig(from = "GRAPH_STORE_SETUP_TIMEOUT", default = "30000")]
+    setup_timeout_in_millis: u64,
     #[envconfig(from = "GRAPH_STORE_CONNECTION_MIN_IDLE")]
     connection_min_idle: Option<u32>,
     #[envconfig(from = "GRAPH_STORE_CONNECTION_IDLE_TIMEOUT", default = "600")]
@@ -203,22 +319,57 @@ pub struct InnerStore {
     write_queue_size: usize,
     #[envconfig(from = "GRAPH_STORE_BATCH_TARGET_DURATION", default = "180")]
     batch_target_duration_in_secs: u64,
+    #[envconfig(from = "GRAPH_STORE_BATCH_TIMEOUT")]
+    batch_timeout_in_secs: Option<u64>,
+    #[envconfig(from = "GRAPH_STORE_BATCH_WORKERS", default = "1")]
+    batch_workers: usize,
+    #[envconfig(from = "GRAPH_STORE_BATCH_WORKER_WAIT", default = "2000")]
+    batch_worker_wait: u64,
     #[envconfig(from = "GRAPH_STORE_HISTORY_REBUILD_THRESHOLD", default = "0.5")]
     rebuild_threshold: ZeroToOneF64,
     #[envconfig(from = "GRAPH_STORE_HISTORY_DELETE_THRESHOLD", default = "0.05")]
     delete_threshold: ZeroToOneF64,
     #[envconfig(from = "GRAPH_STORE_HISTORY_SLACK_FACTOR", default = "1.2")]
     history_slack_factor: HistorySlackF64,
+    #[envconfig(from = "GRAPH_STORE_HISTORY_KEEP_STATUS", default = "5")]
+    prune_keep_status: usize,
+    #[envconfig(
+        from = "GRAPH_STORE_PRUNE_DISABLE_RANGE_BOUND_ESTIMATION",
+        default = "false"
+    )]
+    prune_disable_range_bound_estimation: bool,
     #[envconfig(from = "GRAPH_STORE_WRITE_BATCH_DURATION", default = "300")]
     write_batch_duration_in_secs: u64,
     #[envconfig(from = "GRAPH_STORE_WRITE_BATCH_SIZE", default = "10000")]
     write_batch_size: usize,
+    #[envconfig(from = "GRAPH_STORE_WRITE_BATCH_MEMOIZE", default = "true")]
+    write_batch_memoize: bool,
     #[envconfig(from = "GRAPH_STORE_CREATE_GIN_INDEXES", default = "false")]
     create_gin_indexes: bool,
     #[envconfig(from = "GRAPH_STORE_USE_BRIN_FOR_ALL_QUERY_TYPES", default = "false")]
     use_brin_for_all_query_types: bool,
     #[envconfig(from = "GRAPH_STORE_DISABLE_BLOCK_CACHE_FOR_LOOKUP", default = "false")]
     disable_block_cache_for_lookup: bool,
+    #[envconfig(from = "GRAPH_STORE_IGNORE_BLOCK_CACHE", default = "false")]
+    ignore_block_cache: bool,
+    #[envconfig(from = "GRAPH_STORE_INSERT_EXTRA_COLS", default = "0")]
+    insert_extra_cols: usize,
+    #[envconfig(from = "GRAPH_STORE_FDW_FETCH_SIZE", default = "1000")]
+    fdw_fetch_size: usize,
+    #[envconfig(from = "GRAPH_STORE_ACCOUNT_LIKE_SCAN_INTERVAL_HOURS")]
+    account_like_scan_interval_hours: Option<u32>,
+    #[envconfig(from = "GRAPH_STORE_ACCOUNT_LIKE_MIN_VERSIONS_COUNT")]
+    account_like_min_versions_count: Option<u64>,
+    #[envconfig(from = "GRAPH_STORE_ACCOUNT_LIKE_MAX_UNIQUE_RATIO")]
+    account_like_max_unique_ratio: Option<ZeroToOneF64>,
+    #[envconfig(from = "GRAPH_STORE_DISABLE_CALL_CACHE", default = "false")]
+    disable_call_cache: bool,
+    #[envconfig(from = "GRAPH_STORE_DISABLE_CHAIN_HEAD_PTR_CACHE", default = "false")]
+    disable_chain_head_ptr_cache: bool,
+    #[envconfig(from = "GRAPH_STORE_CONNECTION_VALIDATION_IDLE_SECS", default = "30")]
+    connection_validation_idle_secs: u64,
+    #[envconfig(from = "GRAPH_STORE_CONNECTION_UNAVAILABLE_RETRY", default = "2")]
+    connection_unavailable_retry_in_secs: u64,
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -229,7 +380,7 @@ impl FromStr for ZeroToOneF64 {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let f = s.parse::<f64>()?;
-        if f < 0.0 || f > 1.0 {
+        if !(0.0..=1.0).contains(&f) {
             bail!("invalid value: {s} must be between 0 and 1");
         } else {
             Ok(ZeroToOneF64(f))
diff --git a/graph/src/ext/futures.rs b/graph/src/ext/futures.rs
index 57eae6933cd..b9453ff31da 100644
--- a/graph/src/ext/futures.rs
+++ b/graph/src/ext/futures.rs
@@ -1,7 +1,8 @@
+use crate::blockchain::block_stream::BlockStreamError;
 use crate::prelude::tokio::macros::support::Poll;
 use crate::prelude::{Pin, StoreError};
 use futures03::channel::oneshot;
-use futures03::{future::Fuse, Future, FutureExt, Stream};
+use futures03::{Future, FutureExt, Stream, future::Fuse};
 use std::fmt::{Debug, Display};
 use std::sync::{Arc, Mutex, Weak};
 use std::task::Context;
@@ -11,42 +12,45 @@ use std::time::Duration;
 ///
 /// Created by calling `cancelable` extension method.
 /// Can be canceled through the corresponding `CancelGuard`.
-pub struct Cancelable<T, C> {
+pub struct Cancelable<T> {
     inner: T,
     cancel_receiver: Fuse<oneshot::Receiver<()>>,
-    on_cancel: C,
 }
 
-impl<T, C> Cancelable<T, C> {
+impl<T> Cancelable<T> {
     pub fn get_mut(&mut self) -> &mut T {
         &mut self.inner
     }
 }
 
 /// It's not viable to use `select` directly, so we do a custom implementation.
-impl<S: Stream + Unpin, C: Fn() -> S::Item + Unpin> Stream for Cancelable<S, C> {
-    type Item = S::Item;
+impl<S: Stream<Item = Result<R, E>> + Unpin, R, E: Display + Debug> Stream for Cancelable<S> {
+    type Item = Result<R, CancelableError<E>>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         // Error if the stream was canceled by dropping the sender.
         match self.cancel_receiver.poll_unpin(cx) {
             Poll::Ready(Ok(_)) => unreachable!(),
-            Poll::Ready(Err(_)) => Poll::Ready(Some((self.on_cancel)())),
-            Poll::Pending => Pin::new(&mut self.inner).poll_next(cx),
+            Poll::Ready(Err(_)) => Poll::Ready(Some(Err(CancelableError::Cancel))),
+            Poll::Pending => Pin::new(&mut self.inner)
+                .poll_next(cx)
+                .map_err(|x| CancelableError::Error(x)),
         }
     }
 }
 
-impl<F: Future + Unpin, C: Fn() -> F::Output + Unpin> Future for Cancelable<F, C> {
-    type Output = F::Output;
+impl<F: Future<Output = Result<R, E>> + Unpin, R, E: Display + Debug> Future for Cancelable<F> {
+    type Output = Result<R, CancelableError<E>>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         // Error if the future was canceled by dropping the sender.
         // `canceled` is fused so we may ignore `Ok`s.
         match self.cancel_receiver.poll_unpin(cx) {
             Poll::Ready(Ok(_)) => unreachable!(),
-            Poll::Ready(Err(_)) => Poll::Ready((self.on_cancel)()),
-            Poll::Pending => Pin::new(&mut self.inner).poll(cx),
+            Poll::Ready(Err(_)) => Poll::Ready(Err(CancelableError::Cancel)),
+            Poll::Pending => Pin::new(&mut self.inner)
+                .poll(cx)
+                .map_err(|x| CancelableError::Error(x)),
         }
     }
 }
@@ -208,25 +212,16 @@ pub trait StreamExtension: Stream + Sized {
     /// When `cancel` is called on a `CancelGuard` or it is dropped,
     /// `Cancelable` receives an error.
     ///
-    fn cancelable<C: Fn() -> Self::Item>(
-        self,
-        guard: &impl Canceler,
-        on_cancel: C,
-    ) -> Cancelable<Self, C>;
+    fn cancelable(self, guard: &impl Canceler) -> Cancelable<Self>;
 }
 
 impl<S: Stream> StreamExtension for S {
-    fn cancelable<C: Fn() -> S::Item>(
-        self,
-        guard: &impl Canceler,
-        on_cancel: C,
-    ) -> Cancelable<Self, C> {
+    fn cancelable(self, guard: &impl Canceler) -> Cancelable<Self> {
         let (canceler, cancel_receiver) = oneshot::channel();
         guard.add_cancel_sender(canceler);
         Cancelable {
             inner: self,
             cancel_receiver: cancel_receiver.fuse(),
-            on_cancel,
         }
     }
 }
@@ -236,27 +231,18 @@ pub trait FutureExtension: Future + Sized {
     /// `Cancelable` receives an error.
     ///
     /// `on_cancel` is called to make an error value upon cancelation.
-    fn cancelable<C: Fn() -> Self::Output>(
-        self,
-        guard: &impl Canceler,
-        on_cancel: C,
-    ) -> Cancelable<Self, C>;
+    fn cancelable(self, guard: &impl Canceler) -> Cancelable<Self>;
 
     fn timeout(self, dur: Duration) -> tokio::time::Timeout<Self>;
 }
 
 impl<F: Future> FutureExtension for F {
-    fn cancelable<C: Fn() -> F::Output>(
-        self,
-        guard: &impl Canceler,
-        on_cancel: C,
-    ) -> Cancelable<Self, C> {
+    fn cancelable(self, guard: &impl Canceler) -> Cancelable<Self> {
         let (canceler, cancel_receiver) = oneshot::channel();
         guard.add_cancel_sender(canceler);
         Cancelable {
             inner: self,
             cancel_receiver: cancel_receiver.fuse(),
-            on_cancel,
         }
     }
 
@@ -313,6 +299,12 @@ impl From<diesel::result::Error> for CancelableError<StoreError> {
     }
 }
 
+impl From<BlockStreamError> for CancelableError<BlockStreamError> {
+    fn from(e: BlockStreamError) -> Self {
+        Self::Error(e)
+    }
+}
+
 impl From<anyhow::Error> for CancelableError<anyhow::Error> {
     fn from(e: anyhow::Error) -> Self {
         Self::Error(e)
diff --git a/graph/src/ext/mod.rs b/graph/src/ext/mod.rs
index 4e9773f7bd3..375e8f62340 100644
--- a/graph/src/ext/mod.rs
+++ b/graph/src/ext/mod.rs
@@ -1,2 +1,2 @@
-///! Extension traits for external types.
+//! Extension traits for external types.
 pub mod futures;
diff --git a/graph/src/firehose/codec.rs b/graph/src/firehose/codec.rs
index 5537dba153b..3768f3acf45 100644
--- a/graph/src/firehose/codec.rs
+++ b/graph/src/firehose/codec.rs
@@ -10,11 +10,6 @@ mod pbethereum;
 #[path = "sf.near.transform.v1.rs"]
 mod pbnear;
 
-#[rustfmt::skip]
-#[path = "sf.cosmos.transform.v1.rs"]
-mod pbcosmos;
-
-pub use pbcosmos::*;
 pub use pbethereum::*;
 pub use pbfirehose::*;
 pub use pbnear::*;
diff --git a/graph/src/firehose/endpoint_info/client.rs b/graph/src/firehose/endpoint_info/client.rs
new file mode 100644
index 00000000000..658406672a6
--- /dev/null
+++ b/graph/src/firehose/endpoint_info/client.rs
@@ -0,0 +1,46 @@
+use anyhow::Context;
+use anyhow::Result;
+use tonic::codec::CompressionEncoding;
+use tonic::service::interceptor::InterceptedService;
+use tonic::transport::Channel;
+
+use super::info_response::InfoResponse;
+use crate::firehose::codec;
+use crate::firehose::interceptors::AuthInterceptor;
+use crate::firehose::interceptors::MetricsInterceptor;
+
+pub struct Client {
+    inner: codec::endpoint_info_client::EndpointInfoClient<
+        InterceptedService<MetricsInterceptor<Channel>, AuthInterceptor>,
+    >,
+}
+
+impl Client {
+    pub fn new(metrics: MetricsInterceptor<Channel>, auth: AuthInterceptor) -> Self {
+        let mut inner =
+            codec::endpoint_info_client::EndpointInfoClient::with_interceptor(metrics, auth);
+
+        inner = inner.accept_compressed(CompressionEncoding::Gzip);
+
+        Self { inner }
+    }
+
+    pub fn with_compression(mut self) -> Self {
+        self.inner = self.inner.send_compressed(CompressionEncoding::Gzip);
+        self
+    }
+
+    pub fn with_max_message_size(mut self, size: usize) -> Self {
+        self.inner = self.inner.max_decoding_message_size(size);
+        self
+    }
+
+    pub async fn info(&mut self) -> Result<InfoResponse> {
+        let req = codec::InfoRequest {};
+        let resp = self.inner.info(req).await?.into_inner();
+
+        resp.clone()
+            .try_into()
+            .with_context(|| format!("received response: {resp:?}"))
+    }
+}
diff --git a/graph/src/firehose/endpoint_info/info_response.rs b/graph/src/firehose/endpoint_info/info_response.rs
new file mode 100644
index 00000000000..a51ae7610c5
--- /dev/null
+++ b/graph/src/firehose/endpoint_info/info_response.rs
@@ -0,0 +1,96 @@
+use anyhow::Context;
+use anyhow::Result;
+use anyhow::anyhow;
+
+use crate::blockchain::BlockHash;
+use crate::blockchain::BlockPtr;
+use crate::components::network_provider::ChainName;
+use crate::firehose::codec;
+
+#[derive(Clone, Debug)]
+pub struct InfoResponse {
+    pub chain_name: ChainName,
+    pub block_features: Vec<String>,
+
+    first_streamable_block_num: u64,
+    first_streamable_block_hash: BlockHash,
+}
+
+impl InfoResponse {
+    /// Returns the ptr of the genesis block from the perspective of the Firehose.
+    /// It is not guaranteed to be the genesis block ptr of the chain.
+    ///
+    /// There is currently no better way to get the genesis block ptr from Firehose.
+    pub fn genesis_block_ptr(&self) -> Result<BlockPtr> {
+        let hash = self.first_streamable_block_hash.clone();
+        let number = self.first_streamable_block_num;
+
+        Ok(BlockPtr {
+            hash,
+            number: number
+                .try_into()
+                .with_context(|| format!("'{number}' is not a valid `BlockNumber`"))?,
+        })
+    }
+}
+
+impl TryFrom<codec::InfoResponse> for InfoResponse {
+    type Error = anyhow::Error;
+
+    fn try_from(resp: codec::InfoResponse) -> Result<Self> {
+        let codec::InfoResponse {
+            chain_name,
+            chain_name_aliases: _,
+            first_streamable_block_num,
+            first_streamable_block_id,
+            block_id_encoding,
+            block_features,
+        } = resp;
+
+        let encoding = codec::info_response::BlockIdEncoding::try_from(block_id_encoding)?;
+
+        Ok(Self {
+            chain_name: chain_name_checked(chain_name)?,
+            block_features: block_features_checked(block_features)?,
+            first_streamable_block_num,
+            first_streamable_block_hash: parse_block_hash(first_streamable_block_id, encoding)?,
+        })
+    }
+}
+
+fn chain_name_checked(chain_name: String) -> Result<ChainName> {
+    if chain_name.is_empty() {
+        return Err(anyhow!("`chain_name` is empty"));
+    }
+
+    Ok(chain_name.into())
+}
+
+fn block_features_checked(block_features: Vec<String>) -> Result<Vec<String>> {
+    if block_features.iter().any(|x| x.is_empty()) {
+        return Err(anyhow!("`block_features` contains empty features"));
+    }
+
+    Ok(block_features)
+}
+
+fn parse_block_hash(
+    s: String,
+    encoding: codec::info_response::BlockIdEncoding,
+) -> Result<BlockHash> {
+    use base64::Engine;
+    use base64::engine::general_purpose::STANDARD;
+    use base64::engine::general_purpose::URL_SAFE;
+    use codec::info_response::BlockIdEncoding::*;
+
+    let block_hash = match encoding {
+        Unset => return Err(anyhow!("`block_id_encoding` is not set")),
+        Hex => hex::decode(s)?.into(),
+        BlockIdEncoding0xHex => hex::decode(s.trim_start_matches("0x"))?.into(),
+        Base58 => bs58::decode(s).into_vec()?.into(),
+        Base64 => STANDARD.decode(s)?.into(),
+        Base64url => URL_SAFE.decode(s)?.into(),
+    };
+
+    Ok(block_hash)
+}
diff --git a/graph/src/firehose/endpoint_info/mod.rs b/graph/src/firehose/endpoint_info/mod.rs
new file mode 100644
index 00000000000..cb2c8fa7817
--- /dev/null
+++ b/graph/src/firehose/endpoint_info/mod.rs
@@ -0,0 +1,5 @@
+mod client;
+mod info_response;
+
+pub use client::Client;
+pub use info_response::InfoResponse;
diff --git a/graph/src/firehose/endpoints.rs b/graph/src/firehose/endpoints.rs
index 1a935b1956c..8176dc3fbd1 100644
--- a/graph/src/firehose/endpoints.rs
+++ b/graph/src/firehose/endpoints.rs
@@ -1,37 +1,39 @@
+use crate::firehose::fetch_client::FetchClient;
+use crate::firehose::interceptors::AuthInterceptor;
 use crate::{
-    blockchain::block_stream::FirehoseCursor,
-    blockchain::Block as BlockchainBlock,
-    blockchain::BlockPtr,
+    blockchain::{
+        Block as BlockchainBlock, BlockPtr, ChainIdentifier, block_stream::FirehoseCursor,
+    },
     cheap_clone::CheapClone,
     components::store::BlockNumber,
-    data::value::Word,
-    endpoint::{ConnectionType, EndpointMetrics, Provider, RequestLabels},
+    endpoint::{ConnectionType, EndpointMetrics, RequestLabels},
+    env::ENV_VARS,
     firehose::decode_firehose_block,
-    prelude::{anyhow, debug, info},
-    substreams_rpc,
+    prelude::{DeploymentHash, anyhow, debug},
 };
-
-use crate::firehose::fetch_client::FetchClient;
-use crate::firehose::interceptors::AuthInterceptor;
-use futures03::StreamExt;
+use anyhow::Context;
+use async_trait::async_trait;
+use futures03::{StreamExt, TryStreamExt};
 use http::uri::{Scheme, Uri};
 use itertools::Itertools;
-use slog::Logger;
-use std::{
-    collections::{BTreeMap, HashMap},
-    fmt::Display,
-    ops::ControlFlow,
-    sync::Arc,
-    time::Duration,
-};
+use slog::{Logger, error, info, trace};
+use std::{collections::HashMap, fmt::Display, ops::ControlFlow, sync::Arc, time::Duration};
+use tokio::sync::OnceCell;
 use tonic::codegen::InterceptedService;
 use tonic::{
+    Request,
     codegen::CompressionEncoding,
-    metadata::{Ascii, MetadataValue},
+    metadata::{Ascii, MetadataKey, MetadataValue},
     transport::{Channel, ClientTlsConfig},
 };
 
 use super::{codec as firehose, interceptors::MetricsInterceptor, stream_client::StreamClient};
+use crate::components::network_provider::ChainName;
+use crate::components::network_provider::NetworkDetails;
+use crate::components::network_provider::ProviderCheckStrategy;
+use crate::components::network_provider::ProviderManager;
+use crate::components::network_provider::ProviderName;
+use crate::prelude::retry;
 
 /// This is constant because we found this magic number of connections after
 /// which the grpc connections start to hang.
@@ -42,15 +44,86 @@ const LOW_VALUE_THRESHOLD: usize = 10;
 const LOW_VALUE_USED_PERCENTAGE: usize = 50;
 const HIGH_VALUE_USED_PERCENTAGE: usize = 80;
 
+pub trait BlockChainBlockMessage:
+    prost::Message + BlockchainBlock + Default + std::fmt::Debug + 'static
+{
+}
+
+impl<T> BlockChainBlockMessage for T where
+    T: prost::Message + BlockchainBlock + Default + std::fmt::Debug + 'static
+{
+}
+
 #[derive(Debug)]
 pub struct FirehoseEndpoint {
-    pub provider: Provider,
+    pub provider: ProviderName,
     pub auth: AuthInterceptor,
     pub filters_enabled: bool,
     pub compression_enabled: bool,
     pub subgraph_limit: SubgraphLimit,
     endpoint_metrics: Arc<EndpointMetrics>,
     channel: Channel,
+
+    /// The endpoint info is not intended to change very often, as it only contains the
+    /// endpoint's metadata, so caching it avoids sending unnecessary network requests.
+    info_response: OnceCell<crate::firehose::endpoint_info::InfoResponse>,
+}
+
+#[derive(Debug)]
+pub struct ConnectionHeaders(HashMap<MetadataKey<Ascii>, MetadataValue<Ascii>>);
+
+#[async_trait]
+impl NetworkDetails for Arc<FirehoseEndpoint> {
+    fn provider_name(&self) -> ProviderName {
+        self.provider.clone()
+    }
+
+    async fn chain_identifier(&self) -> anyhow::Result<ChainIdentifier> {
+        let genesis_block_ptr = self.clone().info().await?.genesis_block_ptr()?;
+
+        Ok(ChainIdentifier {
+            net_version: "0".to_string(),
+            genesis_block_hash: genesis_block_ptr.hash,
+        })
+    }
+
+    async fn provides_extended_blocks(&self) -> anyhow::Result<bool> {
+        let info = self.clone().info().await?;
+        let pred =
+            if info.chain_name.contains("arbitrum-one") || info.chain_name.contains("optimism") {
+                |x: &String| x.starts_with("extended") || x == "hybrid"
+            } else {
+                |x: &String| x == "extended"
+            };
+
+        Ok(info.block_features.iter().any(pred))
+    }
+}
+
+impl Default for ConnectionHeaders {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ConnectionHeaders {
+    pub fn new() -> Self {
+        Self(HashMap::new())
+    }
+    pub fn with_deployment(mut self, deployment: DeploymentHash) -> Self {
+        if let Ok(deployment) = deployment.parse() {
+            self.0
+                .insert("x-deployment-id".parse().unwrap(), deployment);
+        }
+        self
+    }
+    pub fn add_to_request<T>(&self, request: T) -> Request<T> {
+        let mut request = Request::new(request);
+        self.0.iter().for_each(|(k, v)| {
+            request.metadata_mut().insert(k, v.clone());
+        });
+        request
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Ord, Eq, PartialOrd)]
@@ -119,6 +192,7 @@ impl FirehoseEndpoint {
         provider: S,
         url: S,
         token: Option<String>,
+        key: Option<String>,
         filters_enabled: bool,
         compression_enabled: bool,
         subgraph_limit: SubgraphLimit,
@@ -131,9 +205,14 @@ impl FirehoseEndpoint {
 
         let endpoint_builder = match uri.scheme().unwrap_or(&Scheme::HTTP).as_str() {
             "http" => Channel::builder(uri),
-            "https" => Channel::builder(uri)
-                .tls_config(ClientTlsConfig::new())
-                .expect("TLS config on this host is invalid"),
+            "https" => {
+                let mut tls = ClientTlsConfig::new();
+                tls = tls.with_native_roots();
+
+                Channel::builder(uri)
+                    .tls_config(tls)
+                    .expect("TLS config on this host is invalid")
+            }
             _ => panic!("invalid uri scheme for firehose endpoint"),
         };
 
@@ -145,6 +224,12 @@ impl FirehoseEndpoint {
             })
             .expect("Firehose token is invalid");
 
+        let key: Option<MetadataValue<Ascii>> = key
+            .map_or(Ok(None), |key| {
+                key.parse::<MetadataValue<Ascii>>().map(Some)
+            })
+            .expect("Firehose key is invalid");
+
         // Note on the connection window size: We run multiple block streams on a same connection,
         // and a problematic subgraph with a stalled block stream might consume the entire window
         // capacity for its http2 stream and never release it. If there are enough stalled block
@@ -174,11 +259,12 @@ impl FirehoseEndpoint {
         FirehoseEndpoint {
             provider: provider.as_ref().into(),
             channel: endpoint.connect_lazy(),
-            auth: AuthInterceptor { token },
+            auth: AuthInterceptor { token, key },
             filters_enabled,
             compression_enabled,
             subgraph_limit,
             endpoint_metrics,
+            info_response: OnceCell::new(),
         }
     }
 
@@ -193,30 +279,38 @@ impl FirehoseEndpoint {
             .get_capacity(Arc::strong_count(self).saturating_sub(1))
     }
 
-    fn new_client(
-        &self,
-    ) -> FetchClient<
-        InterceptedService<MetricsInterceptor<Channel>, impl tonic::service::Interceptor>,
-    > {
-        let metrics = MetricsInterceptor {
+    fn metrics_interceptor(&self) -> MetricsInterceptor<Channel> {
+        MetricsInterceptor {
             metrics: self.endpoint_metrics.cheap_clone(),
             service: self.channel.cheap_clone(),
             labels: RequestLabels {
-                provider: self.provider.clone().into(),
+                provider: self.provider.clone(),
                 req_type: "unknown".into(),
                 conn_type: ConnectionType::Firehose,
             },
-        };
+        }
+    }
+
+    fn max_message_size(&self) -> usize {
+        1024 * 1024 * ENV_VARS.firehose_grpc_max_decode_size_mb
+    }
 
-        let mut client: FetchClient<
-            InterceptedService<MetricsInterceptor<Channel>, AuthInterceptor>,
-        > = FetchClient::with_interceptor(metrics, self.auth.clone())
+    fn new_fetch_client(
+        &self,
+    ) -> FetchClient<
+        InterceptedService<MetricsInterceptor<Channel>, impl tonic::service::Interceptor>,
+    > {
+        let metrics = self.metrics_interceptor();
+
+        let mut client = FetchClient::with_interceptor(metrics, self.auth.clone())
             .accept_compressed(CompressionEncoding::Gzip);
 
         if self.compression_enabled {
             client = client.send_compressed(CompressionEncoding::Gzip);
         }
 
+        client = client.max_decoding_message_size(self.max_message_size());
+
         client
     }
 
@@ -225,15 +319,7 @@ impl FirehoseEndpoint {
     ) -> StreamClient<
         InterceptedService<MetricsInterceptor<Channel>, impl tonic::service::Interceptor>,
     > {
-        let metrics = MetricsInterceptor {
-            metrics: self.endpoint_metrics.cheap_clone(),
-            service: self.channel.cheap_clone(),
-            labels: RequestLabels {
-                provider: self.provider.clone().into(),
-                req_type: "unknown".into(),
-                conn_type: ConnectionType::Firehose,
-            },
-        };
+        let metrics = self.metrics_interceptor();
 
         let mut client = StreamClient::with_interceptor(metrics, self.auth.clone())
             .accept_compressed(CompressionEncoding::Gzip);
@@ -242,34 +328,22 @@ impl FirehoseEndpoint {
             client = client.send_compressed(CompressionEncoding::Gzip);
         }
 
+        client = client.max_decoding_message_size(self.max_message_size());
+
         client
     }
 
-    fn new_substreams_client(
-        &self,
-    ) -> substreams_rpc::stream_client::StreamClient<
-        InterceptedService<MetricsInterceptor<Channel>, impl tonic::service::Interceptor>,
-    > {
-        let metrics = MetricsInterceptor {
-            metrics: self.endpoint_metrics.cheap_clone(),
-            service: self.channel.cheap_clone(),
-            labels: RequestLabels {
-                provider: self.provider.clone().into(),
-                req_type: "unknown".into(),
-                conn_type: ConnectionType::Substreams,
-            },
-        };
+    fn new_firehose_info_client(&self) -> crate::firehose::endpoint_info::Client {
+        let metrics = self.metrics_interceptor();
+        let auth = self.auth.clone();
 
-        let mut client = substreams_rpc::stream_client::StreamClient::with_interceptor(
-            metrics,
-            self.auth.clone(),
-        )
-        .accept_compressed(CompressionEncoding::Gzip);
+        let mut client = crate::firehose::endpoint_info::Client::new(metrics, auth);
 
         if self.compression_enabled {
-            client = client.send_compressed(CompressionEncoding::Gzip);
+            client = client.with_compression();
         }
 
+        client = client.with_max_message_size(self.max_message_size());
         client
     }
 
@@ -283,7 +357,8 @@ impl FirehoseEndpoint {
     {
         debug!(
             logger,
-            "Connecting to firehose to retrieve block for cursor {}", cursor
+            "Connecting to firehose to retrieve block for cursor {}", cursor;
+            "provider" => self.provider.as_str(),
         );
 
         let req = firehose::SingleBlockRequest {
@@ -295,20 +370,186 @@ impl FirehoseEndpoint {
             )),
         };
 
-        let mut client = self.new_client();
+        let mut client = self.new_fetch_client();
+        match client.block(req).await {
+            Ok(v) => Ok(M::decode(
+                v.get_ref().block.as_ref().unwrap().value.as_ref(),
+            )?),
+            Err(e) => Err(anyhow::format_err!("firehose error {}", e)),
+        }
+    }
+
+    pub async fn get_block_by_ptr<M>(
+        &self,
+        ptr: &BlockPtr,
+        logger: &Logger,
+    ) -> Result<M, anyhow::Error>
+    where
+        M: prost::Message + BlockchainBlock + Default + 'static,
+    {
+        debug!(
+            logger,
+            "Connecting to firehose to retrieve block for ptr {}", ptr;
+            "provider" => self.provider.as_str(),
+        );
+
+        let req = firehose::SingleBlockRequest {
+            transforms: [].to_vec(),
+            reference: Some(
+                firehose::single_block_request::Reference::BlockHashAndNumber(
+                    firehose::single_block_request::BlockHashAndNumber {
+                        hash: ptr.hash.to_string(),
+                        num: ptr.number as u64,
+                    },
+                ),
+            ),
+        };
+
+        let mut client = self.new_fetch_client();
+        match client.block(req).await {
+            Ok(v) => Ok(M::decode(
+                v.get_ref().block.as_ref().unwrap().value.as_ref(),
+            )?),
+            Err(e) => Err(anyhow::format_err!("firehose error {}", e)),
+        }
+    }
+
+    pub async fn get_block_by_ptr_with_retry<M>(
+        self: Arc<Self>,
+        ptr: &BlockPtr,
+        logger: &Logger,
+    ) -> Result<M, anyhow::Error>
+    where
+        M: BlockChainBlockMessage,
+    {
+        let retry_log_message = format!("get_block_by_ptr for block {}", ptr);
+        let endpoint = self.cheap_clone();
+        let logger = logger.cheap_clone();
+        let ptr_for_retry = ptr.clone();
+
+        retry(retry_log_message, &logger)
+            .limit(ENV_VARS.firehose_block_fetch_retry_limit)
+            .timeout_secs(ENV_VARS.firehose_block_fetch_timeout)
+            .run(move || {
+                let endpoint = endpoint.cheap_clone();
+                let logger = logger.cheap_clone();
+                let ptr = ptr_for_retry.clone();
+                async move {
+                    endpoint
+                        .get_block_by_ptr::<M>(&ptr, &logger)
+                        .await
+                        .context(format!(
+                            "Failed to fetch block by ptr {} from firehose",
+                            ptr
+                        ))
+                }
+            })
+            .await
+            .map_err(move |e| {
+                anyhow::anyhow!("Failed to fetch block by ptr {} from firehose: {}", ptr, e)
+            })
+    }
+
+    async fn get_block_by_number<M>(&self, number: u64, logger: &Logger) -> Result<M, anyhow::Error>
+    where
+        M: prost::Message + BlockchainBlock + Default + 'static,
+    {
+        trace!(
+            logger,
+            "Connecting to firehose to retrieve block for number {}", number;
+            "provider" => self.provider.as_str(),
+        );
+
+        let req = firehose::SingleBlockRequest {
+            transforms: [].to_vec(),
+            reference: Some(firehose::single_block_request::Reference::BlockNumber(
+                firehose::single_block_request::BlockNumber { num: number },
+            )),
+        };
+
+        let mut client = self.new_fetch_client();
         match client.block(req).await {
             Ok(v) => Ok(M::decode(
                 v.get_ref().block.as_ref().unwrap().value.as_ref(),
             )?),
-            Err(e) => return Err(anyhow::format_err!("firehose error {}", e)),
+            Err(e) => Err(anyhow::format_err!("firehose error {}", e)),
         }
     }
 
+    pub async fn get_block_by_number_with_retry<M>(
+        self: Arc<Self>,
+        number: u64,
+        logger: &Logger,
+    ) -> Result<M, anyhow::Error>
+    where
+        M: BlockChainBlockMessage,
+    {
+        let retry_log_message = format!("get_block_by_number for block {}", number);
+        let endpoint = self.cheap_clone();
+        let logger = logger.cheap_clone();
+
+        retry(retry_log_message, &logger)
+            .limit(ENV_VARS.firehose_block_fetch_retry_limit)
+            .timeout_secs(ENV_VARS.firehose_block_fetch_timeout)
+            .run(move || {
+                let endpoint = endpoint.cheap_clone();
+                let logger = logger.cheap_clone();
+                async move {
+                    endpoint
+                        .get_block_by_number::<M>(number, &logger)
+                        .await
+                        .context(format!(
+                            "Failed to fetch block by number {} from firehose",
+                            number
+                        ))
+                }
+            })
+            .await
+            .map_err(|e| {
+                anyhow::anyhow!(
+                    "Failed to fetch block by number {} from firehose: {}",
+                    number,
+                    e
+                )
+            })
+    }
+
+    pub async fn load_blocks_by_numbers<M>(
+        self: Arc<Self>,
+        numbers: Vec<u64>,
+        logger: &Logger,
+    ) -> Result<Vec<M>, anyhow::Error>
+    where
+        M: BlockChainBlockMessage,
+    {
+        let logger = logger.clone();
+        let logger_for_error = logger.clone();
+
+        let blocks_stream = futures03::stream::iter(numbers)
+            .map(move |number| {
+                let e = self.cheap_clone();
+                let l = logger.clone();
+                async move { e.get_block_by_number_with_retry::<M>(number, &l).await }
+            })
+            .buffered(ENV_VARS.firehose_block_batch_size);
+
+        let blocks = blocks_stream.try_collect::<Vec<M>>().await.map_err(|e| {
+            error!(
+                logger_for_error,
+                "Failed to load blocks from firehose: {}", e;
+            );
+            anyhow::format_err!("failed to load blocks from firehose: {}", e)
+        })?;
+
+        Ok(blocks)
+    }
+
     pub async fn genesis_block_ptr<M>(&self, logger: &Logger) -> Result<BlockPtr, anyhow::Error>
     where
         M: prost::Message + BlockchainBlock + Default + 'static,
     {
-        info!(logger, "Requesting genesis block from firehose");
+        info!(logger, "Requesting genesis block from firehose";
+            "provider" => self.provider.as_str());
 
         // We use 0 here to mean the genesis block of the chain. Firehose
         // when seeing start block number 0 will always return the genesis
@@ -327,7 +568,8 @@ impl FirehoseEndpoint {
     {
         debug!(
             logger,
-            "Connecting to firehose to retrieve block for number {}", number
+            "Connecting to firehose to retrieve block for number {}", number;
+            "provider" => self.provider.as_str(),
         );
 
         let mut client = self.new_stream_client();
@@ -355,7 +597,8 @@ impl FirehoseEndpoint {
 
         let mut block_stream = response_stream.into_inner();
 
-        debug!(logger, "Retrieving block(s) from firehose");
+        debug!(logger, "Retrieving block(s) from firehose";
+               "provider" => self.provider.as_str());
 
         let mut latest_received_block: Option<BlockPtr> = None;
         while let Some(message) = block_stream.next().await {
@@ -399,45 +642,72 @@ impl FirehoseEndpoint {
     pub async fn stream_blocks(
         self: Arc<Self>,
         request: firehose::Request,
+        headers: &ConnectionHeaders,
     ) -> Result<tonic::Streaming<firehose::Response>, anyhow::Error> {
         let mut client = self.new_stream_client();
+        let request = headers.add_to_request(request);
         let response_stream = client.blocks(request).await?;
         let block_stream = response_stream.into_inner();
 
         Ok(block_stream)
     }
 
-    pub async fn substreams(
+    pub async fn info(
         self: Arc<Self>,
-        request: substreams_rpc::Request,
-    ) -> Result<tonic::Streaming<substreams_rpc::Response>, anyhow::Error> {
-        let mut client = self.new_substreams_client();
-        let response_stream = client.blocks(request).await?;
-        let block_stream = response_stream.into_inner();
+    ) -> Result<crate::firehose::endpoint_info::InfoResponse, anyhow::Error> {
+        let endpoint = self.cheap_clone();
 
-        Ok(block_stream)
+        self.info_response
+            .get_or_try_init(move || async move {
+                let mut client = endpoint.new_firehose_info_client();
+
+                client.info().await
+            })
+            .await
+            .map(ToOwned::to_owned)
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct FirehoseEndpoints(Vec<Arc<FirehoseEndpoint>>);
+#[derive(Debug)]
+pub struct FirehoseEndpoints(ChainName, ProviderManager<Arc<FirehoseEndpoint>>);
 
 impl FirehoseEndpoints {
-    pub fn new() -> Self {
-        Self(vec![])
+    pub fn for_testing(adapters: Vec<Arc<FirehoseEndpoint>>) -> Self {
+        let chain_name: ChainName = "testing".into();
+
+        Self(
+            chain_name.clone(),
+            ProviderManager::new(
+                crate::log::discard(),
+                [(chain_name, adapters)],
+                ProviderCheckStrategy::MarkAsValid,
+            ),
+        )
+    }
+
+    pub fn new(
+        chain_name: ChainName,
+        provider_manager: ProviderManager<Arc<FirehoseEndpoint>>,
+    ) -> Self {
+        Self(chain_name, provider_manager)
     }
 
     pub fn len(&self) -> usize {
-        self.0.len()
+        self.1.len(&self.0)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
     }
 
     /// This function will attempt to grab an endpoint based on the Lowest error count
     //  with high capacity available. If an adapter cannot be found `endpoint` will
     // return an error.
-    pub fn endpoint(&self) -> anyhow::Result<Arc<FirehoseEndpoint>> {
+    pub async fn endpoint(&self) -> anyhow::Result<Arc<FirehoseEndpoint>> {
         let endpoint = self
-            .0
-            .iter()
+            .1
+            .providers(&self.0)
+            .await?
             .sorted_by_key(|x| x.current_error_count())
             .try_fold(None, |acc, adapter| {
                 match adapter.get_capacity() {
@@ -459,169 +729,98 @@ impl FirehoseEndpoints {
             adapter.cloned().ok_or(anyhow!("unable to get a connection, increase the firehose conn_pool_size or limit for the node"))
         }
     }
-
-    pub fn remove(&mut self, provider: &str) {
-        self.0
-            .retain(|network_endpoint| network_endpoint.provider.as_str() != provider);
-    }
-}
-
-impl From<Vec<Arc<FirehoseEndpoint>>> for FirehoseEndpoints {
-    fn from(val: Vec<Arc<FirehoseEndpoint>>) -> Self {
-        FirehoseEndpoints(val)
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct FirehoseNetworks {
-    /// networks contains a map from chain id (`near-mainnet`, `near-testnet`, `solana-mainnet`, etc.)
-    /// to a list of FirehoseEndpoint (type wrapper around `Arc<Vec<FirehoseEndpoint>>`).
-    pub networks: BTreeMap<String, FirehoseEndpoints>,
-}
-
-impl FirehoseNetworks {
-    pub fn new() -> FirehoseNetworks {
-        FirehoseNetworks {
-            networks: BTreeMap::new(),
-        }
-    }
-
-    pub fn insert(&mut self, chain_id: String, endpoint: Arc<FirehoseEndpoint>) {
-        let endpoints = self
-            .networks
-            .entry(chain_id)
-            .or_insert_with(FirehoseEndpoints::new);
-
-        endpoints.0.push(endpoint);
-    }
-
-    pub fn remove(&mut self, chain_id: &str, provider: &str) {
-        if let Some(endpoints) = self.networks.get_mut(chain_id) {
-            endpoints.remove(provider);
-        }
-    }
-
-    /// Returns a `HashMap` where the key is the chain's id and the key is an endpoint for this chain.
-    /// There can be mulitple keys with the same chain id but with different
-    /// endpoint where multiple providers exist for a single chain id. Providers with the same
-    /// label do not need to be tested individually, if one is working, every other endpoint in the
-    /// pool should also work.
-    pub fn flatten(&self) -> HashMap<(String, Word), Arc<FirehoseEndpoint>> {
-        self.networks
-            .iter()
-            .flat_map(|(chain_id, firehose_endpoints)| {
-                firehose_endpoints.0.iter().map(move |endpoint| {
-                    (
-                        (chain_id.clone(), endpoint.provider.clone()),
-                        endpoint.clone(),
-                    )
-                })
-            })
-            .collect()
-    }
 }
 
 #[cfg(test)]
 mod test {
     use std::{mem, sync::Arc};
 
-    use slog::{o, Discard, Logger};
+    use slog::{Discard, Logger, o};
 
-    use crate::{
-        components::metrics::MetricsRegistry, endpoint::EndpointMetrics, firehose::SubgraphLimit,
-    };
+    use super::*;
+    use crate::components::metrics::MetricsRegistry;
+    use crate::endpoint::EndpointMetrics;
+    use crate::firehose::SubgraphLimit;
 
-    use super::{AvailableCapacity, FirehoseEndpoint, FirehoseEndpoints, SUBGRAPHS_PER_CONN};
-
-    #[tokio::test]
+    #[crate::test]
     async fn firehose_endpoint_errors() {
         let endpoint = vec![Arc::new(FirehoseEndpoint::new(
             String::new(),
             "http://127.0.0.1".to_string(),
             None,
+            None,
             false,
             false,
             SubgraphLimit::Unlimited,
             Arc::new(EndpointMetrics::mock()),
         ))];
 
-        let mut endpoints = FirehoseEndpoints::from(endpoint);
+        let endpoints = FirehoseEndpoints::for_testing(endpoint);
 
         let mut keep = vec![];
         for _i in 0..SUBGRAPHS_PER_CONN {
-            keep.push(endpoints.endpoint().unwrap());
+            keep.push(endpoints.endpoint().await.unwrap());
         }
 
-        let err = endpoints.endpoint().unwrap_err();
+        let err = endpoints.endpoint().await.unwrap_err();
         assert!(err.to_string().contains("conn_pool_size"));
 
         mem::drop(keep);
-        endpoints.endpoint().unwrap();
+        endpoints.endpoint().await.unwrap();
 
-        // Fails when empty too
-        endpoints.remove("");
+        let endpoints = FirehoseEndpoints::for_testing(vec![]);
 
-        let err = endpoints.endpoint().unwrap_err();
+        let err = endpoints.endpoint().await.unwrap_err();
         assert!(err.to_string().contains("unable to get a connection"));
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn firehose_endpoint_with_limit() {
         let endpoint = vec![Arc::new(FirehoseEndpoint::new(
             String::new(),
             "http://127.0.0.1".to_string(),
             None,
+            None,
             false,
             false,
             SubgraphLimit::Limit(2),
             Arc::new(EndpointMetrics::mock()),
         ))];
 
-        let mut endpoints = FirehoseEndpoints::from(endpoint);
+        let endpoints = FirehoseEndpoints::for_testing(endpoint);
 
         let mut keep = vec![];
         for _ in 0..2 {
-            keep.push(endpoints.endpoint().unwrap());
+            keep.push(endpoints.endpoint().await.unwrap());
         }
 
-        let err = endpoints.endpoint().unwrap_err();
+        let err = endpoints.endpoint().await.unwrap_err();
         assert!(err.to_string().contains("conn_pool_size"));
 
         mem::drop(keep);
-        endpoints.endpoint().unwrap();
-
-        // Fails when empty too
-        endpoints.remove("");
-
-        let err = endpoints.endpoint().unwrap_err();
-        assert!(err.to_string().contains("unable to get a connection"));
+        endpoints.endpoint().await.unwrap();
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn firehose_endpoint_no_traffic() {
         let endpoint = vec![Arc::new(FirehoseEndpoint::new(
             String::new(),
             "http://127.0.0.1".to_string(),
             None,
+            None,
             false,
             false,
             SubgraphLimit::Disabled,
             Arc::new(EndpointMetrics::mock()),
         ))];
 
-        let mut endpoints = FirehoseEndpoints::from(endpoint);
+        let endpoints = FirehoseEndpoints::for_testing(endpoint);
 
-        let err = endpoints.endpoint().unwrap_err();
+        let err = endpoints.endpoint().await.unwrap_err();
         assert!(err.to_string().contains("conn_pool_size"));
-
-        // Fails when empty too
-        endpoints.remove("");
-
-        let err = endpoints.endpoint().unwrap_err();
-        assert!(err.to_string().contains("unable to get a connection"));
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn firehose_endpoint_selection() {
         let logger = Logger::root(Discard, o!());
         let endpoint_metrics = Arc::new(EndpointMetrics::new(
@@ -634,6 +833,7 @@ mod test {
             "high_error".to_string(),
             "http://127.0.0.1".to_string(),
             None,
+            None,
             false,
             false,
             SubgraphLimit::Unlimited,
@@ -643,6 +843,7 @@ mod test {
             "high_error".to_string(),
             "http://127.0.0.1".to_string(),
             None,
+            None,
             false,
             false,
             SubgraphLimit::Unlimited,
@@ -652,6 +853,7 @@ mod test {
             "low availability".to_string(),
             "http://127.0.0.2".to_string(),
             None,
+            None,
             false,
             false,
             SubgraphLimit::Limit(2),
@@ -661,6 +863,7 @@ mod test {
             "high availability".to_string(),
             "http://127.0.0.3".to_string(),
             None,
+            None,
             false,
             false,
             SubgraphLimit::Unlimited,
@@ -669,25 +872,36 @@ mod test {
 
         endpoint_metrics.report_for_test(&high_error_adapter1.provider, false);
 
-        let mut endpoints = FirehoseEndpoints::from(vec![
+        let endpoints = FirehoseEndpoints::for_testing(vec![
             high_error_adapter1.clone(),
-            high_error_adapter2,
+            high_error_adapter2.clone(),
             low_availability.clone(),
             high_availability.clone(),
         ]);
 
-        let res = endpoints.endpoint().unwrap();
+        let res = endpoints.endpoint().await.unwrap();
         assert_eq!(res.provider, high_availability.provider);
+        mem::drop(endpoints);
 
         // Removing high availability without errors should fallback to low availability
-        endpoints.remove(&high_availability.provider);
+        let endpoints = FirehoseEndpoints::for_testing(
+            vec![
+                high_error_adapter1.clone(),
+                high_error_adapter2,
+                low_availability.clone(),
+                high_availability.clone(),
+            ]
+            .into_iter()
+            .filter(|a| a.provider_name() != high_availability.provider)
+            .collect(),
+        );
 
         // Ensure we're in a low capacity situation
         assert_eq!(low_availability.get_capacity(), AvailableCapacity::Low);
 
         // In the scenario where the only high level adapter has errors we keep trying that
         // because the others will be low or unavailable
-        let res = endpoints.endpoint().unwrap();
+        let res = endpoints.endpoint().await.unwrap();
         // This will match both high error adapters
         assert_eq!(res.provider, high_error_adapter1.provider);
     }
@@ -767,14 +981,8 @@ mod test {
 
     #[test]
     fn available_capacity_ordering() {
-        assert_eq!(
-            AvailableCapacity::Unavailable < AvailableCapacity::Low,
-            true
-        );
-        assert_eq!(
-            AvailableCapacity::Unavailable < AvailableCapacity::High,
-            true
-        );
-        assert_eq!(AvailableCapacity::Low < AvailableCapacity::High, true);
+        assert!(AvailableCapacity::Unavailable < AvailableCapacity::Low);
+        assert!(AvailableCapacity::Unavailable < AvailableCapacity::High);
+        assert!(AvailableCapacity::Low < AvailableCapacity::High);
     }
 }
diff --git a/graph/src/firehose/interceptors.rs b/graph/src/firehose/interceptors.rs
index 8c86d034db4..3ef62b24f13 100644
--- a/graph/src/firehose/interceptors.rs
+++ b/graph/src/firehose/interceptors.rs
@@ -13,13 +13,16 @@ use crate::endpoint::{EndpointMetrics, RequestLabels};
 #[derive(Clone)]
 pub struct AuthInterceptor {
     pub token: Option<MetadataValue<Ascii>>,
+    pub key: Option<MetadataValue<Ascii>>,
 }
 
 impl std::fmt::Debug for AuthInterceptor {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self.token {
-            Some(_) => f.write_str("token_redacted"),
-            None => f.write_str("no_token_configured"),
+        match (&self.token, &self.key) {
+            (Some(_), Some(_)) => f.write_str("token_redacted, key_redacted"),
+            (Some(_), None) => f.write_str("token_redacted, no_key_configured"),
+            (None, Some(_)) => f.write_str("no_token_configured, key_redacted"),
+            (None, None) => f.write_str("no_token_configured, no_key_configured"),
         }
     }
 }
@@ -29,6 +32,9 @@ impl Interceptor for AuthInterceptor {
         if let Some(ref t) = self.token {
             req.metadata_mut().insert("authorization", t.clone());
         }
+        if let Some(ref k) = self.key {
+            req.metadata_mut().insert("x-api-key", k.clone());
+        }
 
         Ok(req)
     }
diff --git a/graph/src/firehose/mod.rs b/graph/src/firehose/mod.rs
index 2930d1ee560..9f4e8510c3b 100644
--- a/graph/src/firehose/mod.rs
+++ b/graph/src/firehose/mod.rs
@@ -1,4 +1,5 @@
 mod codec;
+mod endpoint_info;
 mod endpoints;
 mod helpers;
 mod interceptors;
diff --git a/graph/src/firehose/sf.cosmos.transform.v1.rs b/graph/src/firehose/sf.cosmos.transform.v1.rs
deleted file mode 100644
index 2a8f1251991..00000000000
--- a/graph/src/firehose/sf.cosmos.transform.v1.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EventTypeFilter {
-    #[prost(string, repeated, tag = "1")]
-    pub event_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-}
diff --git a/graph/src/firehose/sf.ethereum.transform.v1.rs b/graph/src/firehose/sf.ethereum.transform.v1.rs
index 19e07c08537..755a7c2ee05 100644
--- a/graph/src/firehose/sf.ethereum.transform.v1.rs
+++ b/graph/src/firehose/sf.ethereum.transform.v1.rs
@@ -1,22 +1,22 @@
+// This file is @generated by prost-build.
 /// CombinedFilter is a combination of "LogFilters" and "CallToFilters"
 ///
 /// It transforms the requested stream in two ways:
-///    1. STRIPPING
-///       The block data is stripped from all transactions that don't
-///       match any of the filters.
 ///
-///    2. SKIPPING
-///       If an "block index" covers a range containing a
-///       block that does NOT match any of the filters, the block will be
-///       skipped altogether, UNLESS send_all_block_headers is enabled
-///       In that case, the block would still be sent, but without any
-///       transactionTrace
+/// 1. STRIPPING
+///    The block data is stripped from all transactions that don't
+///    match any of the filters.
+///
+/// 1. SKIPPING
+///    If an "block index" covers a range containing a
+///    block that does NOT match any of the filters, the block will be
+///    skipped altogether, UNLESS send_all_block_headers is enabled
+///    In that case, the block would still be sent, but without any
+///    transactionTrace
 ///
 /// The SKIPPING feature only applies to historical blocks, because
 /// the "block index" is always produced after the merged-blocks files
 /// are produced. Therefore, the "live" blocks are never filtered out.
-///
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CombinedFilter {
     #[prost(message, repeated, tag = "1")]
@@ -29,19 +29,18 @@ pub struct CombinedFilter {
     pub send_all_block_headers: bool,
 }
 /// MultiLogFilter concatenates the results of each LogFilter (inclusive OR)
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MultiLogFilter {
     #[prost(message, repeated, tag = "1")]
     pub log_filters: ::prost::alloc::vec::Vec<LogFilter>,
 }
 /// LogFilter will match calls where *BOTH*
+///
 /// * the contract address that emits the log is one in the provided addresses -- OR addresses list is empty --
 /// * the event signature (topic.0) is one of the provided event_signatures -- OR event_signatures is empty --
 ///
 /// a LogFilter with both empty addresses and event_signatures lists is invalid and will fail.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct LogFilter {
     #[prost(bytes = "vec", repeated, tag = "1")]
     pub addresses: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
@@ -50,19 +49,18 @@ pub struct LogFilter {
     pub event_signatures: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
 }
 /// MultiCallToFilter concatenates the results of each CallToFilter (inclusive OR)
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MultiCallToFilter {
     #[prost(message, repeated, tag = "1")]
     pub call_filters: ::prost::alloc::vec::Vec<CallToFilter>,
 }
 /// CallToFilter will match calls where *BOTH*
+///
 /// * the contract address (TO) is one in the provided addresses -- OR addresses list is empty --
 /// * the method signature (in 4-bytes format) is one of the provided signatures -- OR signatures is empty --
 ///
 /// a CallToFilter with both empty addresses and signatures lists is invalid and will fail.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct CallToFilter {
     #[prost(bytes = "vec", repeated, tag = "1")]
     pub addresses: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
@@ -71,25 +69,23 @@ pub struct CallToFilter {
 }
 /// Deprecated: LightBlock is deprecated, replaced by HeaderOnly, note however that the new transform
 /// does not have any transactions traces returned, so it's not a direct replacement.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct LightBlock {}
 /// HeaderOnly returns only the block's header and few top-level core information for the block. Useful
 /// for cases where no transactions information is required at all.
 ///
 /// The structure that would will have access to after:
 ///
-/// ```ignore
+/// ```text,ignore
 /// Block {
-///   int32 ver = 1;
-///   bytes hash = 2;
-///   uint64 number = 3;
-///   uint64 size = 4;
-///   BlockHeader header = 5;
+/// int32 ver = 1;
+/// bytes hash = 2;
+/// uint64 number = 3;
+/// uint64 size = 4;
+/// BlockHeader header = 5;
 /// }
 /// ```
 ///
 /// Everything else will be empty.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct HeaderOnly {}
diff --git a/graph/src/firehose/sf.firehose.v2.rs b/graph/src/firehose/sf.firehose.v2.rs
index 6a5b9d35204..d564bcb9d1e 100644
--- a/graph/src/firehose/sf.firehose.v2.rs
+++ b/graph/src/firehose/sf.firehose.v2.rs
@@ -1,4 +1,4 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
+// This file is @generated by prost-build.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct SingleBlockRequest {
     #[prost(message, repeated, tag = "6")]
@@ -9,15 +9,13 @@ pub struct SingleBlockRequest {
 /// Nested message and enum types in `SingleBlockRequest`.
 pub mod single_block_request {
     /// Get the current known canonical version of a block at with this number
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
+    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
     pub struct BlockNumber {
         #[prost(uint64, tag = "1")]
         pub num: u64,
     }
     /// Get the current block with specific hash and number
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
     pub struct BlockHashAndNumber {
         #[prost(uint64, tag = "1")]
         pub num: u64,
@@ -25,14 +23,12 @@ pub mod single_block_request {
         pub hash: ::prost::alloc::string::String,
     }
     /// Get the block that generated a specific cursor
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
     pub struct Cursor {
         #[prost(string, tag = "1")]
         pub cursor: ::prost::alloc::string::String,
     }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
     pub enum Reference {
         #[prost(message, tag = "3")]
         BlockNumber(BlockNumber),
@@ -42,13 +38,11 @@ pub mod single_block_request {
         Cursor(Cursor),
     }
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct SingleBlockResponse {
     #[prost(message, optional, tag = "1")]
     pub block: ::core::option::Option<::prost_types::Any>,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Request {
     /// Controls where the stream of blocks will start.
@@ -61,7 +55,7 @@ pub struct Request {
     ///
     /// Can be negative, will be resolved relative to the chain head block, assuming
     /// a chain at head block #100, then using `-50` as the value will start at block
-    /// #50. If it resolves before first streamable block of chain, we assume start
+    /// \#50. If it resolves before first streamable block of chain, we assume start
     /// of chain.
     ///
     /// If `start_cursor` is given, this value is ignored and the stream instead starts
@@ -89,13 +83,13 @@ pub struct Request {
     #[prost(message, repeated, tag = "10")]
     pub transforms: ::prost::alloc::vec::Vec<::prost_types::Any>,
 }
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct Response {
     /// Chain specific block payload, ex:
-    ///    - sf.eosio.type.v1.Block
-    ///    - sf.ethereum.type.v1.Block
-    ///    - sf.near.type.v1.Block
+    ///
+    /// * sf.eosio.type.v1.Block
+    /// * sf.ethereum.type.v1.Block
+    /// * sf.near.type.v1.Block
     #[prost(message, optional, tag = "1")]
     pub block: ::core::option::Option<::prost_types::Any>,
     #[prost(enumeration = "ForkStep", tag = "6")]
@@ -103,6 +97,82 @@ pub struct Response {
     #[prost(string, tag = "10")]
     pub cursor: ::prost::alloc::string::String,
 }
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct InfoRequest {}
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct InfoResponse {
+    /// Canonical chain name from <https://thegraph.com/docs/en/developing/supported-networks/> (ex: matic, mainnet ...).
+    #[prost(string, tag = "1")]
+    pub chain_name: ::prost::alloc::string::String,
+    /// Alternate names for the chain.
+    #[prost(string, repeated, tag = "2")]
+    pub chain_name_aliases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    /// First block that is served by this endpoint.
+    /// This should usually be the genesis block, but some providers may have truncated history.
+    #[prost(uint64, tag = "3")]
+    pub first_streamable_block_num: u64,
+    #[prost(string, tag = "4")]
+    pub first_streamable_block_id: ::prost::alloc::string::String,
+    /// This informs the client on how to decode the `block_id` field inside the `Block` message
+    /// as well as the `first_streamable_block_id` above.
+    #[prost(enumeration = "info_response::BlockIdEncoding", tag = "5")]
+    pub block_id_encoding: i32,
+    /// Features describes the blocks.
+    /// Popular values for EVM chains include "base", "extended" or "hybrid".
+    #[prost(string, repeated, tag = "10")]
+    pub block_features: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+}
+/// Nested message and enum types in `InfoResponse`.
+pub mod info_response {
+    #[derive(
+        Clone,
+        Copy,
+        Debug,
+        PartialEq,
+        Eq,
+        Hash,
+        PartialOrd,
+        Ord,
+        ::prost::Enumeration
+    )]
+    #[repr(i32)]
+    pub enum BlockIdEncoding {
+        Unset = 0,
+        Hex = 1,
+        BlockIdEncoding0xHex = 2,
+        Base58 = 3,
+        Base64 = 4,
+        Base64url = 5,
+    }
+    impl BlockIdEncoding {
+        /// String value of the enum field names used in the ProtoBuf definition.
+        ///
+        /// The values are not transformed in any way and thus are considered stable
+        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+        pub fn as_str_name(&self) -> &'static str {
+            match self {
+                Self::Unset => "BLOCK_ID_ENCODING_UNSET",
+                Self::Hex => "BLOCK_ID_ENCODING_HEX",
+                Self::BlockIdEncoding0xHex => "BLOCK_ID_ENCODING_0X_HEX",
+                Self::Base58 => "BLOCK_ID_ENCODING_BASE58",
+                Self::Base64 => "BLOCK_ID_ENCODING_BASE64",
+                Self::Base64url => "BLOCK_ID_ENCODING_BASE64URL",
+            }
+        }
+        /// Creates an enum from field names used in the ProtoBuf definition.
+        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+            match value {
+                "BLOCK_ID_ENCODING_UNSET" => Some(Self::Unset),
+                "BLOCK_ID_ENCODING_HEX" => Some(Self::Hex),
+                "BLOCK_ID_ENCODING_0X_HEX" => Some(Self::BlockIdEncoding0xHex),
+                "BLOCK_ID_ENCODING_BASE58" => Some(Self::Base58),
+                "BLOCK_ID_ENCODING_BASE64" => Some(Self::Base64),
+                "BLOCK_ID_ENCODING_BASE64URL" => Some(Self::Base64url),
+                _ => None,
+            }
+        }
+    }
+}
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
 pub enum ForkStep {
@@ -122,10 +192,10 @@ impl ForkStep {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            ForkStep::StepUnset => "STEP_UNSET",
-            ForkStep::StepNew => "STEP_NEW",
-            ForkStep::StepUndo => "STEP_UNDO",
-            ForkStep::StepFinal => "STEP_FINAL",
+            Self::StepUnset => "STEP_UNSET",
+            Self::StepNew => "STEP_NEW",
+            Self::StepUndo => "STEP_UNDO",
+            Self::StepFinal => "STEP_FINAL",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -141,7 +211,13 @@ impl ForkStep {
 }
 /// Generated client implementations.
 pub mod stream_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
     use tonic::codegen::*;
     use tonic::codegen::http::Uri;
     #[derive(Debug, Clone)]
@@ -152,7 +228,7 @@ pub mod stream_client {
         /// Attempt to create a new client by connecting to a given endpoint.
         pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
         where
-            D: std::convert::TryInto<tonic::transport::Endpoint>,
+            D: TryInto<tonic::transport::Endpoint>,
             D::Error: Into<StdError>,
         {
             let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
@@ -161,10 +237,10 @@ pub mod stream_client {
     }
     impl<T> StreamClient<T>
     where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T: tonic::client::GrpcService<tonic::body::Body>,
         T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
     {
         pub fn new(inner: T) -> Self {
             let inner = tonic::client::Grpc::new(inner);
@@ -182,14 +258,14 @@ pub mod stream_client {
             F: tonic::service::Interceptor,
             T::ResponseBody: Default,
             T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
+                http::Request<tonic::body::Body>,
                 Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                 >,
             >,
             <T as tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-            >>::Error: Into<StdError> + Send + Sync,
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
         {
             StreamClient::new(InterceptedService::new(inner, interceptor))
         }
@@ -208,33 +284,241 @@ pub mod stream_client {
             self.inner = self.inner.accept_compressed(encoding);
             self
         }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
         pub async fn blocks(
             &mut self,
             request: impl tonic::IntoRequest<super::Request>,
-        ) -> Result<
-                tonic::Response<tonic::codec::Streaming<super::Response>>,
-                tonic::Status,
-            > {
+        ) -> std::result::Result<
+            tonic::Response<tonic::codec::Streaming<super::Response>>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
                 .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
+                    tonic::Status::unknown(
                         format!("Service was not ready: {}", e.into()),
                     )
                 })?;
-            let codec = tonic::codec::ProstCodec::default();
+            let codec = tonic_prost::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/sf.firehose.v2.Stream/Blocks",
             );
-            self.inner.server_streaming(request.into_request(), path, codec).await
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("sf.firehose.v2.Stream", "Blocks"));
+            self.inner.server_streaming(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod stream_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    /// Generated trait containing gRPC methods that should be implemented for use with StreamServer.
+    #[async_trait]
+    pub trait Stream: std::marker::Send + std::marker::Sync + 'static {
+        /// Server streaming response type for the Blocks method.
+        type BlocksStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::Response, tonic::Status>,
+            >
+            + std::marker::Send
+            + 'static;
+        async fn blocks(
+            &self,
+            request: tonic::Request<super::Request>,
+        ) -> std::result::Result<tonic::Response<Self::BlocksStream>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct StreamServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> StreamServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> Self {
+            Self {
+                inner,
+                accept_compression_encodings: Default::default(),
+                send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
+            }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        where
+            F: tonic::service::Interceptor,
+        {
+            InterceptedService::new(Self::new(inner), interceptor)
+        }
+        /// Enable decompressing requests with the given encoding.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.accept_compression_encodings.enable(encoding);
+            self
+        }
+        /// Compress responses with the given encoding, if the client supports it.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.send_compression_encodings.enable(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
         }
     }
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for StreamServer<T>
+    where
+        T: Stream,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/sf.firehose.v2.Stream/Blocks" => {
+                    #[allow(non_camel_case_types)]
+                    struct BlocksSvc<T: Stream>(pub Arc<T>);
+                    impl<T: Stream> tonic::server::ServerStreamingService<super::Request>
+                    for BlocksSvc<T> {
+                        type Response = super::Response;
+                        type ResponseStream = T::BlocksStream;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::ResponseStream>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::Request>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Stream>::blocks(&inner, request).await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let method = BlocksSvc(inner);
+                        let codec = tonic_prost::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.server_streaming(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(
+                            tonic::body::Body::default(),
+                        );
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
+            }
+        }
+    }
+    impl<T> Clone for StreamServer<T> {
+        fn clone(&self) -> Self {
+            let inner = self.inner.clone();
+            Self {
+                inner,
+                accept_compression_encodings: self.accept_compression_encodings,
+                send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
+            }
+        }
+    }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "sf.firehose.v2.Stream";
+    impl<T> tonic::server::NamedService for StreamServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
 }
 /// Generated client implementations.
 pub mod fetch_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
     use tonic::codegen::*;
     use tonic::codegen::http::Uri;
     #[derive(Debug, Clone)]
@@ -245,7 +529,7 @@ pub mod fetch_client {
         /// Attempt to create a new client by connecting to a given endpoint.
         pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
         where
-            D: std::convert::TryInto<tonic::transport::Endpoint>,
+            D: TryInto<tonic::transport::Endpoint>,
             D::Error: Into<StdError>,
         {
             let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
@@ -254,10 +538,10 @@ pub mod fetch_client {
     }
     impl<T> FetchClient<T>
     where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
+        T: tonic::client::GrpcService<tonic::body::Body>,
         T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
     {
         pub fn new(inner: T) -> Self {
             let inner = tonic::client::Grpc::new(inner);
@@ -275,14 +559,14 @@ pub mod fetch_client {
             F: tonic::service::Interceptor,
             T::ResponseBody: Default,
             T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
+                http::Request<tonic::body::Body>,
                 Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                 >,
             >,
             <T as tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-            >>::Error: Into<StdError> + Send + Sync,
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
         {
             FetchClient::new(InterceptedService::new(inner, interceptor))
         }
@@ -301,62 +585,88 @@ pub mod fetch_client {
             self.inner = self.inner.accept_compressed(encoding);
             self
         }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
         pub async fn block(
             &mut self,
             request: impl tonic::IntoRequest<super::SingleBlockRequest>,
-        ) -> Result<tonic::Response<super::SingleBlockResponse>, tonic::Status> {
+        ) -> std::result::Result<
+            tonic::Response<super::SingleBlockResponse>,
+            tonic::Status,
+        > {
             self.inner
                 .ready()
                 .await
                 .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
+                    tonic::Status::unknown(
                         format!("Service was not ready: {}", e.into()),
                     )
                 })?;
-            let codec = tonic::codec::ProstCodec::default();
+            let codec = tonic_prost::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/sf.firehose.v2.Fetch/Block",
             );
-            self.inner.unary(request.into_request(), path, codec).await
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("sf.firehose.v2.Fetch", "Block"));
+            self.inner.unary(req, path, codec).await
         }
     }
 }
 /// Generated server implementations.
-pub mod stream_server {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+pub mod fetch_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
     use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with StreamServer.
+    /// Generated trait containing gRPC methods that should be implemented for use with FetchServer.
     #[async_trait]
-    pub trait Stream: Send + Sync + 'static {
-        /// Server streaming response type for the Blocks method.
-        type BlocksStream: futures_core::Stream<
-                Item = Result<super::Response, tonic::Status>,
-            >
-            + Send
-            + 'static;
-        async fn blocks(
+    pub trait Fetch: std::marker::Send + std::marker::Sync + 'static {
+        async fn block(
             &self,
-            request: tonic::Request<super::Request>,
-        ) -> Result<tonic::Response<Self::BlocksStream>, tonic::Status>;
+            request: tonic::Request<super::SingleBlockRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::SingleBlockResponse>,
+            tonic::Status,
+        >;
     }
     #[derive(Debug)]
-    pub struct StreamServer<T: Stream> {
-        inner: _Inner<T>,
+    pub struct FetchServer<T> {
+        inner: Arc<T>,
         accept_compression_encodings: EnabledCompressionEncodings,
         send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
     }
-    struct _Inner<T>(Arc<T>);
-    impl<T: Stream> StreamServer<T> {
+    impl<T> FetchServer<T> {
         pub fn new(inner: T) -> Self {
             Self::from_arc(Arc::new(inner))
         }
         pub fn from_arc(inner: Arc<T>) -> Self {
-            let inner = _Inner(inner);
             Self {
                 inner,
                 accept_compression_encodings: Default::default(),
                 send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
             }
         }
         pub fn with_interceptor<F>(
@@ -380,130 +690,274 @@ pub mod stream_server {
             self.send_compression_encodings.enable(encoding);
             self
         }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
     }
-    impl<T, B> tonic::codegen::Service<http::Request<B>> for StreamServer<T>
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for FetchServer<T>
     where
-        T: Stream,
-        B: Body + Send + 'static,
-        B::Error: Into<StdError> + Send + 'static,
+        T: Fetch,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
     {
-        type Response = http::Response<tonic::body::BoxBody>;
+        type Response = http::Response<tonic::body::Body>;
         type Error = std::convert::Infallible;
         type Future = BoxFuture<Self::Response, Self::Error>;
         fn poll_ready(
             &mut self,
             _cx: &mut Context<'_>,
-        ) -> Poll<Result<(), Self::Error>> {
+        ) -> Poll<std::result::Result<(), Self::Error>> {
             Poll::Ready(Ok(()))
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            let inner = self.inner.clone();
             match req.uri().path() {
-                "/sf.firehose.v2.Stream/Blocks" => {
+                "/sf.firehose.v2.Fetch/Block" => {
                     #[allow(non_camel_case_types)]
-                    struct BlocksSvc<T: Stream>(pub Arc<T>);
-                    impl<T: Stream> tonic::server::ServerStreamingService<super::Request>
-                    for BlocksSvc<T> {
-                        type Response = super::Response;
-                        type ResponseStream = T::BlocksStream;
+                    struct BlockSvc<T: Fetch>(pub Arc<T>);
+                    impl<T: Fetch> tonic::server::UnaryService<super::SingleBlockRequest>
+                    for BlockSvc<T> {
+                        type Response = super::SingleBlockResponse;
                         type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
+                            tonic::Response<Self::Response>,
                             tonic::Status,
                         >;
                         fn call(
                             &mut self,
-                            request: tonic::Request<super::Request>,
+                            request: tonic::Request<super::SingleBlockRequest>,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
-                            let fut = async move { (*inner).blocks(request).await };
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Fetch>::block(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
-                        let inner = inner.0;
-                        let method = BlocksSvc(inner);
-                        let codec = tonic::codec::ProstCodec::default();
+                        let method = BlockSvc(inner);
+                        let codec = tonic_prost::ProstCodec::default();
                         let mut grpc = tonic::server::Grpc::new(codec)
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
-                        let res = grpc.server_streaming(method, req).await;
+                        let res = grpc.unary(method, req).await;
                         Ok(res)
                     };
                     Box::pin(fut)
                 }
                 _ => {
                     Box::pin(async move {
-                        Ok(
-                            http::Response::builder()
-                                .status(200)
-                                .header("grpc-status", "12")
-                                .header("content-type", "application/grpc")
-                                .body(empty_body())
-                                .unwrap(),
-                        )
+                        let mut response = http::Response::new(
+                            tonic::body::Body::default(),
+                        );
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
                     })
                 }
             }
         }
     }
-    impl<T: Stream> Clone for StreamServer<T> {
+    impl<T> Clone for FetchServer<T> {
         fn clone(&self) -> Self {
             let inner = self.inner.clone();
             Self {
                 inner,
                 accept_compression_encodings: self.accept_compression_encodings,
                 send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
             }
         }
     }
-    impl<T: Stream> Clone for _Inner<T> {
-        fn clone(&self) -> Self {
-            Self(self.0.clone())
-        }
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "sf.firehose.v2.Fetch";
+    impl<T> tonic::server::NamedService for FetchServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
     }
-    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            write!(f, "{:?}", self.0)
+}
+/// Generated client implementations.
+pub mod endpoint_info_client {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
+    use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
+    #[derive(Debug, Clone)]
+    pub struct EndpointInfoClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl EndpointInfoClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
         }
     }
-    impl<T: Stream> tonic::server::NamedService for StreamServer<T> {
-        const NAME: &'static str = "sf.firehose.v2.Stream";
+    impl<T> EndpointInfoClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
+    {
+        pub fn new(inner: T) -> Self {
+            let inner = tonic::client::Grpc::new(inner);
+            Self { inner }
+        }
+        pub fn with_origin(inner: T, origin: Uri) -> Self {
+            let inner = tonic::client::Grpc::with_origin(inner, origin);
+            Self { inner }
+        }
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> EndpointInfoClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            EndpointInfoClient::new(InterceptedService::new(inner, interceptor))
+        }
+        /// Compress requests with the given encoding.
+        ///
+        /// This requires the server to support it otherwise it might respond with an
+        /// error.
+        #[must_use]
+        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.send_compressed(encoding);
+            self
+        }
+        /// Enable decompressing responses.
+        #[must_use]
+        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
+            self.inner = self.inner.accept_compressed(encoding);
+            self
+        }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
+        pub async fn info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::InfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::InfoResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic_prost::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/sf.firehose.v2.EndpointInfo/Info",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("sf.firehose.v2.EndpointInfo", "Info"));
+            self.inner.unary(req, path, codec).await
+        }
     }
 }
 /// Generated server implementations.
-pub mod fetch_server {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+pub mod endpoint_info_server {
+    #![allow(
+        unused_variables,
+        dead_code,
+        missing_docs,
+        clippy::wildcard_imports,
+        clippy::let_unit_value,
+    )]
     use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with FetchServer.
+    /// Generated trait containing gRPC methods that should be implemented for use with EndpointInfoServer.
     #[async_trait]
-    pub trait Fetch: Send + Sync + 'static {
-        async fn block(
+    pub trait EndpointInfo: std::marker::Send + std::marker::Sync + 'static {
+        async fn info(
             &self,
-            request: tonic::Request<super::SingleBlockRequest>,
-        ) -> Result<tonic::Response<super::SingleBlockResponse>, tonic::Status>;
+            request: tonic::Request<super::InfoRequest>,
+        ) -> std::result::Result<tonic::Response<super::InfoResponse>, tonic::Status>;
     }
     #[derive(Debug)]
-    pub struct FetchServer<T: Fetch> {
-        inner: _Inner<T>,
+    pub struct EndpointInfoServer<T> {
+        inner: Arc<T>,
         accept_compression_encodings: EnabledCompressionEncodings,
         send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
     }
-    struct _Inner<T>(Arc<T>);
-    impl<T: Fetch> FetchServer<T> {
+    impl<T> EndpointInfoServer<T> {
         pub fn new(inner: T) -> Self {
             Self::from_arc(Arc::new(inner))
         }
         pub fn from_arc(inner: Arc<T>) -> Self {
-            let inner = _Inner(inner);
             Self {
                 inner,
                 accept_compression_encodings: Default::default(),
                 send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
             }
         }
         pub fn with_interceptor<F>(
@@ -527,55 +981,77 @@ pub mod fetch_server {
             self.send_compression_encodings.enable(encoding);
             self
         }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
     }
-    impl<T, B> tonic::codegen::Service<http::Request<B>> for FetchServer<T>
+    impl<T, B> tonic::codegen::Service<http::Request<B>> for EndpointInfoServer<T>
     where
-        T: Fetch,
-        B: Body + Send + 'static,
-        B::Error: Into<StdError> + Send + 'static,
+        T: EndpointInfo,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
     {
-        type Response = http::Response<tonic::body::BoxBody>;
+        type Response = http::Response<tonic::body::Body>;
         type Error = std::convert::Infallible;
         type Future = BoxFuture<Self::Response, Self::Error>;
         fn poll_ready(
             &mut self,
             _cx: &mut Context<'_>,
-        ) -> Poll<Result<(), Self::Error>> {
+        ) -> Poll<std::result::Result<(), Self::Error>> {
             Poll::Ready(Ok(()))
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            let inner = self.inner.clone();
             match req.uri().path() {
-                "/sf.firehose.v2.Fetch/Block" => {
+                "/sf.firehose.v2.EndpointInfo/Info" => {
                     #[allow(non_camel_case_types)]
-                    struct BlockSvc<T: Fetch>(pub Arc<T>);
-                    impl<T: Fetch> tonic::server::UnaryService<super::SingleBlockRequest>
-                    for BlockSvc<T> {
-                        type Response = super::SingleBlockResponse;
+                    struct InfoSvc<T: EndpointInfo>(pub Arc<T>);
+                    impl<T: EndpointInfo> tonic::server::UnaryService<super::InfoRequest>
+                    for InfoSvc<T> {
+                        type Response = super::InfoResponse;
                         type Future = BoxFuture<
                             tonic::Response<Self::Response>,
                             tonic::Status,
                         >;
                         fn call(
                             &mut self,
-                            request: tonic::Request<super::SingleBlockRequest>,
+                            request: tonic::Request<super::InfoRequest>,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
-                            let fut = async move { (*inner).block(request).await };
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as EndpointInfo>::info(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
-                        let inner = inner.0;
-                        let method = BlockSvc(inner);
-                        let codec = tonic::codec::ProstCodec::default();
+                        let method = InfoSvc(inner);
+                        let codec = tonic_prost::ProstCodec::default();
                         let mut grpc = tonic::server::Grpc::new(codec)
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
                         let res = grpc.unary(method, req).await;
                         Ok(res)
@@ -584,40 +1060,41 @@ pub mod fetch_server {
                 }
                 _ => {
                     Box::pin(async move {
-                        Ok(
-                            http::Response::builder()
-                                .status(200)
-                                .header("grpc-status", "12")
-                                .header("content-type", "application/grpc")
-                                .body(empty_body())
-                                .unwrap(),
-                        )
+                        let mut response = http::Response::new(
+                            tonic::body::Body::default(),
+                        );
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
                     })
                 }
             }
         }
     }
-    impl<T: Fetch> Clone for FetchServer<T> {
+    impl<T> Clone for EndpointInfoServer<T> {
         fn clone(&self) -> Self {
             let inner = self.inner.clone();
             Self {
                 inner,
                 accept_compression_encodings: self.accept_compression_encodings,
                 send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
             }
         }
     }
-    impl<T: Fetch> Clone for _Inner<T> {
-        fn clone(&self) -> Self {
-            Self(self.0.clone())
-        }
-    }
-    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            write!(f, "{:?}", self.0)
-        }
-    }
-    impl<T: Fetch> tonic::server::NamedService for FetchServer<T> {
-        const NAME: &'static str = "sf.firehose.v2.Fetch";
+    /// Generated gRPC service name
+    pub const SERVICE_NAME: &str = "sf.firehose.v2.EndpointInfo";
+    impl<T> tonic::server::NamedService for EndpointInfoServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
     }
 }
diff --git a/graph/src/firehose/sf.near.transform.v1.rs b/graph/src/firehose/sf.near.transform.v1.rs
index 1b02d2b415e..5069ed54453 100644
--- a/graph/src/firehose/sf.near.transform.v1.rs
+++ b/graph/src/firehose/sf.near.transform.v1.rs
@@ -1,4 +1,4 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
+// This file is @generated by prost-build.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BasicReceiptFilter {
     #[prost(string, repeated, tag = "1")]
@@ -7,14 +7,14 @@ pub struct BasicReceiptFilter {
     pub prefix_and_suffix_pairs: ::prost::alloc::vec::Vec<PrefixSuffixPair>,
 }
 /// PrefixSuffixPair applies a logical AND to prefix and suffix when both fields are non-empty.
+///
 /// * {prefix="hello",suffix="world"} will match "hello.world" but not "hello.friend"
 /// * {prefix="hello",suffix=""}      will match both "hello.world" and "hello.friend"
 /// * {prefix="",suffix="world"}      will match both "hello.world" and "good.day.world"
 /// * {prefix="",suffix=""}           is invalid
 ///
 /// Note that the suffix will usually have a TLD, ex: "mydomain.near" or "mydomain.testnet"
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
 pub struct PrefixSuffixPair {
     #[prost(string, tag = "1")]
     pub prefix: ::prost::alloc::string::String,
diff --git a/graph/src/ipfs/cache.rs b/graph/src/ipfs/cache.rs
new file mode 100644
index 00000000000..ab9daf6f784
--- /dev/null
+++ b/graph/src/ipfs/cache.rs
@@ -0,0 +1,291 @@
+use std::{
+    path::PathBuf,
+    sync::{Arc, Mutex},
+    time::Duration,
+};
+
+use anyhow::anyhow;
+use async_trait::async_trait;
+use bytes::Bytes;
+use graph_derive::CheapClone;
+use lru_time_cache::LruCache;
+use object_store::{ObjectStore, ObjectStoreExt as _, local::LocalFileSystem, path::Path};
+use redis::{
+    AsyncCommands as _, RedisResult, Value,
+    aio::{ConnectionManager, ConnectionManagerConfig},
+};
+use slog::{Logger, debug, info, warn};
+use tokio::sync::Mutex as AsyncMutex;
+
+use crate::{env::ENV_VARS, prelude::CheapClone};
+
+use super::{
+    ContentPath, IpfsClient, IpfsContext, IpfsError, IpfsMetrics, IpfsRequest, IpfsResponse,
+    IpfsResult, RetryPolicy,
+};
+
+struct RedisClient {
+    mgr: AsyncMutex<ConnectionManager>,
+}
+
+impl RedisClient {
+    async fn new(logger: &Logger, path: &str) -> RedisResult<Self> {
+        let env = &ENV_VARS.mappings;
+        let client = redis::Client::open(path)?;
+        let cfg = ConnectionManagerConfig::default()
+            .set_connection_timeout(Some(env.ipfs_timeout))
+            .set_response_timeout(Some(env.ipfs_timeout));
+        info!(logger, "Connecting to Redis for IPFS caching"; "url" => path);
+        // Try to connect once synchronously to check if the server is reachable.
+        let _ = client.get_connection()?;
+        let mgr = AsyncMutex::new(client.get_connection_manager_with_config(cfg).await?);
+        info!(logger, "Connected to Redis for IPFS caching"; "url" => path);
+        Ok(RedisClient { mgr })
+    }
+
+    async fn get(&self, path: &ContentPath) -> IpfsResult<Bytes> {
+        let mut mgr = self.mgr.lock().await;
+
+        let key = Self::key(path);
+        let data: Vec<u8> = mgr
+            .get(&key)
+            .await
+            .map_err(|e| IpfsError::InvalidCacheConfig {
+                source: anyhow!("Failed to get IPFS object {key} from Redis cache: {e}"),
+            })?;
+        Ok(data.into())
+    }
+
+    async fn put(&self, path: &ContentPath, data: &Bytes) -> IpfsResult<()> {
+        let mut mgr = self.mgr.lock().await;
+
+        let key = Self::key(path);
+        mgr.set(&key, data.as_ref())
+            .await
+            .map(|_: Value| ())
+            .map_err(|e| IpfsError::InvalidCacheConfig {
+                source: anyhow!("Failed to put IPFS object {key} in Redis cache: {e}"),
+            })?;
+        Ok(())
+    }
+
+    fn key(path: &ContentPath) -> String {
+        format!("ipfs:{path}")
+    }
+}
+
+#[derive(Clone, CheapClone)]
+enum Cache {
+    Memory {
+        cache: Arc<Mutex<LruCache<ContentPath, Bytes>>>,
+        max_entry_size: usize,
+    },
+    Disk {
+        store: Arc<dyn ObjectStore>,
+    },
+    Redis {
+        client: Arc<RedisClient>,
+    },
+}
+
+fn log_object_store_err(logger: &Logger, e: &object_store::Error, log_not_found: bool) {
+    if log_not_found || !matches!(e, object_store::Error::NotFound { .. }) {
+        warn!(
+            logger,
+            "Failed to get IPFS object from disk cache; fetching from IPFS";
+            "error" => e.to_string(),
+        );
+    }
+}
+
+fn log_redis_err(logger: &Logger, e: &IpfsError) {
+    warn!(
+        logger,
+        "Failed to get IPFS object from Redis cache; fetching from IPFS";
+        "error" => e.to_string(),
+    );
+}
+
+impl Cache {
+    async fn new(
+        logger: &Logger,
+        capacity: usize,
+        max_entry_size: usize,
+        path: Option<PathBuf>,
+    ) -> IpfsResult<Self> {
+        match path {
+            Some(path) if path.starts_with("redis://") => {
+                let path = path.to_string_lossy();
+                let client = RedisClient::new(logger, path.as_ref())
+                    .await
+                    .map(Arc::new)
+                    .map_err(|e| IpfsError::InvalidCacheConfig {
+                        source: anyhow!("Failed to create IPFS Redis cache at {path}: {e}"),
+                    })?;
+                Ok(Cache::Redis { client })
+            }
+            Some(path) => {
+                let fs = LocalFileSystem::new_with_prefix(&path).map_err(|e| {
+                    IpfsError::InvalidCacheConfig {
+                        source: anyhow!(
+                            "Failed to create IPFS file based cache at {}: {}",
+                            path.display(),
+                            e
+                        ),
+                    }
+                })?;
+                debug!(logger, "Using IPFS file based cache"; "path" => path.display());
+                Ok(Cache::Disk {
+                    store: Arc::new(fs),
+                })
+            }
+            None => {
+                debug!(logger, "Using IPFS in-memory cache"; "capacity" => capacity, "max_entry_size" => max_entry_size);
+                Ok(Self::Memory {
+                    cache: Arc::new(Mutex::new(LruCache::with_capacity(capacity))),
+                    max_entry_size,
+                })
+            }
+        }
+    }
+
+    async fn find(&self, logger: &Logger, path: &ContentPath) -> Option<Bytes> {
+        match self {
+            Cache::Memory {
+                cache,
+                max_entry_size: _,
+            } => cache.lock().unwrap().get(path).cloned(),
+            Cache::Disk { store } => {
+                let log_err = |e: &object_store::Error| log_object_store_err(logger, e, false);
+
+                let path = Self::disk_path(path);
+                let object = store.get(&path).await.inspect_err(log_err).ok()?;
+                let data = object.bytes().await.inspect_err(log_err).ok()?;
+                Some(data)
+            }
+            Cache::Redis { client } => client
+                .get(path)
+                .await
+                .inspect_err(|e| log_redis_err(logger, e))
+                .ok()
+                .and_then(|data| if data.is_empty() { None } else { Some(data) }),
+        }
+    }
+
+    async fn insert(&self, logger: &Logger, path: ContentPath, data: Bytes) {
+        match self {
+            Cache::Memory { max_entry_size, .. } if data.len() > *max_entry_size => {}
+            Cache::Memory { cache, .. } => {
+                let mut cache = cache.lock().unwrap();
+
+                if !cache.contains_key(&path) {
+                    cache.insert(path.clone(), data.clone());
+                }
+            }
+            Cache::Disk { store } => {
+                let log_err = |e: &object_store::Error| log_object_store_err(logger, e, true);
+                let path = Self::disk_path(&path);
+                store
+                    .put(&path, data.into())
+                    .await
+                    .inspect_err(log_err)
+                    .ok();
+            }
+            Cache::Redis { client } => {
+                if let Err(e) = client.put(&path, &data).await {
+                    log_redis_err(logger, &e);
+                }
+            }
+        }
+    }
+
+    /// The path where we cache content on disk
+    fn disk_path(path: &ContentPath) -> Path {
+        Path::from(path.to_string())
+    }
+}
+
+/// An IPFS client that caches the results of `cat` and `get_block` calls in
+/// memory or on disk, depending on settings in the environment.
+///
+/// The cache is used to avoid repeated calls to the IPFS API for the same
+/// content.
+pub struct CachingClient {
+    client: Arc<dyn IpfsClient>,
+    cache: Cache,
+}
+
+impl CachingClient {
+    pub async fn new(client: Arc<dyn IpfsClient>, logger: &Logger) -> IpfsResult<Self> {
+        let env = &ENV_VARS.mappings;
+
+        let cache = Cache::new(
+            logger,
+            env.max_ipfs_cache_size as usize,
+            env.max_ipfs_cache_file_size,
+            env.ipfs_cache_location.clone(),
+        )
+        .await?;
+
+        Ok(CachingClient { client, cache })
+    }
+
+    async fn with_cache<F>(&self, logger: Logger, path: &ContentPath, f: F) -> IpfsResult<Bytes>
+    where
+        F: AsyncFnOnce() -> IpfsResult<Bytes>,
+    {
+        if let Some(data) = self.cache.find(&logger, path).await {
+            return Ok(data);
+        }
+
+        let data = f().await?;
+        self.cache.insert(&logger, path.clone(), data.clone()).await;
+        Ok(data)
+    }
+}
+
+#[async_trait]
+impl IpfsClient for CachingClient {
+    fn metrics(&self) -> &IpfsMetrics {
+        self.client.metrics()
+    }
+
+    async fn call(self: Arc<Self>, req: IpfsRequest) -> IpfsResult<IpfsResponse> {
+        self.client.cheap_clone().call(req).await
+    }
+
+    async fn cat(
+        self: Arc<Self>,
+        ctx: &IpfsContext,
+        path: &ContentPath,
+        max_size: usize,
+        timeout: Option<Duration>,
+        retry_policy: RetryPolicy,
+    ) -> IpfsResult<Bytes> {
+        self.with_cache(ctx.logger(path), path, async || {
+            {
+                self.client
+                    .cheap_clone()
+                    .cat(ctx, path, max_size, timeout, retry_policy)
+                    .await
+            }
+        })
+        .await
+    }
+
+    async fn get_block(
+        self: Arc<Self>,
+        ctx: &IpfsContext,
+        path: &ContentPath,
+        timeout: Option<Duration>,
+        retry_policy: RetryPolicy,
+    ) -> IpfsResult<Bytes> {
+        self.with_cache(ctx.logger(path), path, async || {
+            self.client
+                .cheap_clone()
+                .get_block(ctx, path, timeout, retry_policy)
+                .await
+        })
+        .await
+    }
+}
diff --git a/graph/src/ipfs/client.rs b/graph/src/ipfs/client.rs
new file mode 100644
index 00000000000..fd8ac996985
--- /dev/null
+++ b/graph/src/ipfs/client.rs
@@ -0,0 +1,287 @@
+use std::future::Future;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+use async_trait::async_trait;
+use bytes::Bytes;
+use bytes::BytesMut;
+use futures03::StreamExt;
+use futures03::TryStreamExt;
+use futures03::stream::BoxStream;
+use slog::Logger;
+
+use crate::cheap_clone::CheapClone as _;
+use crate::data::subgraph::DeploymentHash;
+use crate::derive::CheapClone;
+use crate::ipfs::{ContentPath, IpfsError, IpfsMetrics, IpfsResult, RetryPolicy};
+
+/// A read-only connection to an IPFS server.
+#[async_trait]
+pub trait IpfsClient: Send + Sync + 'static {
+    /// Returns the metrics associated with the IPFS client.
+    fn metrics(&self) -> &IpfsMetrics;
+
+    /// Sends a request to the IPFS server and returns a raw response.
+    async fn call(self: Arc<Self>, req: IpfsRequest) -> IpfsResult<IpfsResponse>;
+
+    /// Streams data from the specified content path.
+    ///
+    /// If a timeout is specified, the execution will be aborted if the IPFS server
+    /// does not return a response within the specified amount of time.
+    ///
+    /// The timeout is not propagated to the resulting stream.
+    async fn cat_stream(
+        self: Arc<Self>,
+        ctx: &IpfsContext,
+        path: &ContentPath,
+        timeout: Option<Duration>,
+        retry_policy: RetryPolicy,
+    ) -> IpfsResult<BoxStream<'static, IpfsResult<Bytes>>> {
+        let fut = retry_policy
+            .create("IPFS.cat_stream", &ctx.logger(path))
+            .no_timeout()
+            .run({
+                let path = path.cheap_clone();
+                let deployment_hash = ctx.deployment_hash();
+
+                move || {
+                    let client = self.cheap_clone();
+                    let metrics = self.metrics().cheap_clone();
+                    let deployment_hash = deployment_hash.cheap_clone();
+                    let path = path.cheap_clone();
+
+                    async move {
+                        run_with_metrics(
+                            client.call(IpfsRequest::Cat(path)),
+                            deployment_hash,
+                            metrics,
+                        )
+                        .await
+                    }
+                }
+            });
+
+        let resp = run_with_optional_timeout(path, fut, timeout).await?;
+
+        Ok(resp.bytes_stream())
+    }
+
+    /// Downloads data from the specified content path.
+    ///
+    /// If a timeout is specified, the execution will be aborted if the IPFS server
+    /// does not return a response within the specified amount of time.
+    async fn cat(
+        self: Arc<Self>,
+        ctx: &IpfsContext,
+        path: &ContentPath,
+        max_size: usize,
+        timeout: Option<Duration>,
+        retry_policy: RetryPolicy,
+    ) -> IpfsResult<Bytes> {
+        let fut = retry_policy
+            .create("IPFS.cat", &ctx.logger(path))
+            .no_timeout()
+            .run({
+                let path = path.cheap_clone();
+                let deployment_hash = ctx.deployment_hash();
+
+                move || {
+                    let client = self.cheap_clone();
+                    let metrics = self.metrics().cheap_clone();
+                    let deployment_hash = deployment_hash.cheap_clone();
+                    let path = path.cheap_clone();
+
+                    async move {
+                        run_with_metrics(
+                            client.call(IpfsRequest::Cat(path)),
+                            deployment_hash,
+                            metrics,
+                        )
+                        .await?
+                        .bytes(Some(max_size))
+                        .await
+                    }
+                }
+            });
+
+        run_with_optional_timeout(path, fut, timeout).await
+    }
+
+    /// Downloads an IPFS block in raw format.
+    ///
+    /// If a timeout is specified, the execution will be aborted if the IPFS server
+    /// does not return a response within the specified amount of time.
+    async fn get_block(
+        self: Arc<Self>,
+        ctx: &IpfsContext,
+        path: &ContentPath,
+        timeout: Option<Duration>,
+        retry_policy: RetryPolicy,
+    ) -> IpfsResult<Bytes> {
+        let fut = retry_policy
+            .create("IPFS.get_block", &ctx.logger(path))
+            .no_timeout()
+            .run({
+                let path = path.cheap_clone();
+                let deployment_hash = ctx.deployment_hash();
+
+                move || {
+                    let client = self.cheap_clone();
+                    let metrics = self.metrics().cheap_clone();
+                    let deployment_hash = deployment_hash.cheap_clone();
+                    let path = path.cheap_clone();
+
+                    async move {
+                        run_with_metrics(
+                            client.call(IpfsRequest::GetBlock(path)),
+                            deployment_hash,
+                            metrics,
+                        )
+                        .await?
+                        .bytes(None)
+                        .await
+                    }
+                }
+            });
+
+        run_with_optional_timeout(path, fut, timeout).await
+    }
+}
+
+#[derive(Clone, Debug, CheapClone)]
+pub struct IpfsContext {
+    pub deployment_hash: Arc<str>,
+    pub logger: Logger,
+}
+
+impl IpfsContext {
+    pub fn new(deployment_hash: &DeploymentHash, logger: &Logger) -> Self {
+        Self {
+            deployment_hash: deployment_hash.as_str().into(),
+            logger: logger.cheap_clone(),
+        }
+    }
+
+    pub(super) fn deployment_hash(&self) -> Arc<str> {
+        self.deployment_hash.cheap_clone()
+    }
+
+    pub(super) fn logger(&self, path: &ContentPath) -> Logger {
+        self.logger.new(
+            slog::o!("deployment" => self.deployment_hash.to_string(), "path" => path.to_string()),
+        )
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn test() -> Self {
+        Self {
+            deployment_hash: "test".into(),
+            logger: crate::log::discard(),
+        }
+    }
+}
+
+/// Describes a request to an IPFS server.
+#[derive(Clone, Debug)]
+pub enum IpfsRequest {
+    Cat(ContentPath),
+    GetBlock(ContentPath),
+}
+
+/// Contains a raw, successful IPFS response.
+#[derive(Debug)]
+pub struct IpfsResponse {
+    pub(super) path: ContentPath,
+    pub(super) response: reqwest::Response,
+}
+
+impl IpfsResponse {
+    /// Construct an `IpfsResponse` from pre-buffered bytes.
+    ///
+    /// Intended for mock `IpfsClient` implementations in tests.
+    pub fn for_test(path: ContentPath, bytes: Bytes) -> Self {
+        Self {
+            path,
+            response: reqwest::Response::from(http::Response::new(bytes)),
+        }
+    }
+
+    /// Reads and returns the response body.
+    ///
+    /// If the max size is specified and the response body is larger than the max size,
+    /// execution will result in an error.
+    pub async fn bytes(self, max_size: Option<usize>) -> IpfsResult<Bytes> {
+        let Some(max_size) = max_size else {
+            return self.response.bytes().await.map_err(Into::into);
+        };
+
+        let bytes = self
+            .response
+            .bytes_stream()
+            .err_into()
+            .try_fold(BytesMut::new(), |mut acc, chunk| async {
+                acc.extend(chunk);
+
+                if acc.len() > max_size {
+                    return Err(IpfsError::ContentTooLarge {
+                        path: self.path.clone(),
+                        max_size,
+                    });
+                }
+
+                Ok(acc)
+            })
+            .await?;
+
+        Ok(bytes.into())
+    }
+
+    /// Converts the response into a stream of bytes from the body.
+    pub fn bytes_stream(self) -> BoxStream<'static, IpfsResult<Bytes>> {
+        self.response.bytes_stream().err_into().boxed()
+    }
+}
+
+async fn run_with_optional_timeout<F, O>(
+    path: &ContentPath,
+    fut: F,
+    timeout: Option<Duration>,
+) -> IpfsResult<O>
+where
+    F: Future<Output = IpfsResult<O>>,
+{
+    match timeout {
+        Some(timeout) => {
+            tokio::time::timeout(timeout, fut)
+                .await
+                .map_err(|_| IpfsError::RequestTimeout {
+                    path: path.to_owned(),
+                })?
+        }
+        None => fut.await,
+    }
+}
+
+async fn run_with_metrics<F, O>(
+    fut: F,
+    deployment_hash: Arc<str>,
+    metrics: IpfsMetrics,
+) -> IpfsResult<O>
+where
+    F: Future<Output = IpfsResult<O>>,
+{
+    let timer = Instant::now();
+    metrics.add_request(&deployment_hash);
+
+    fut.await
+        .inspect(|_resp| {
+            metrics.observe_request_duration(&deployment_hash, timer.elapsed().as_secs_f64())
+        })
+        .inspect_err(|err| {
+            if err.is_timeout() {
+                metrics.add_not_found(&deployment_hash)
+            } else {
+                metrics.add_error(&deployment_hash)
+            }
+        })
+}
diff --git a/graph/src/ipfs/content_path.rs b/graph/src/ipfs/content_path.rs
new file mode 100644
index 00000000000..54fd569e5e4
--- /dev/null
+++ b/graph/src/ipfs/content_path.rs
@@ -0,0 +1,306 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use cid::Cid;
+use url::Url;
+
+use crate::{
+    derive::CheapClone,
+    ipfs::{IpfsError, IpfsResult},
+};
+
+/// Represents a path to some data on IPFS.
+#[derive(Debug, Clone, CheapClone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ContentPath {
+    inner: Arc<Inner>,
+}
+
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct Inner {
+    cid: Cid,
+    path: Option<String>,
+}
+
+impl ContentPath {
+    /// Creates a new [ContentPath] from the specified input.
+    ///
+    /// Supports the following formats:
+    /// - <CID>[/<path>]
+    /// - /ipfs/<CID>[/<path>]
+    /// - ipfs://<CID>[/<path>]
+    /// - http[s]://.../ipfs/<CID>[/<path>]
+    /// - http[s]://.../api/v0/cat?arg=<CID>[/<path>]
+    pub fn new(input: impl AsRef<str>) -> IpfsResult<Self> {
+        let input = input.as_ref().trim();
+
+        if input.is_empty() {
+            return Err(IpfsError::InvalidContentPath {
+                input: "".to_string(),
+                source: anyhow!("content path is empty"),
+            });
+        }
+
+        if input.starts_with("http://") || input.starts_with("https://") {
+            return Self::parse_from_url(input);
+        }
+
+        Self::parse_from_cid_and_path(input)
+    }
+
+    fn parse_from_url(input: &str) -> IpfsResult<Self> {
+        let url = Url::parse(input).map_err(|_err| IpfsError::InvalidContentPath {
+            input: input.to_string(),
+            source: anyhow!("input is not a valid URL"),
+        })?;
+
+        if let Some((_, x)) = url.query_pairs().find(|(key, _)| key == "arg") {
+            return Self::parse_from_cid_and_path(&x);
+        }
+
+        if let Some((_, x)) = url.path().split_once("/ipfs/") {
+            return Self::parse_from_cid_and_path(x);
+        }
+
+        Self::parse_from_cid_and_path(url.path())
+    }
+
+    fn parse_from_cid_and_path(mut input: &str) -> IpfsResult<Self> {
+        input = input.trim_matches('/');
+
+        for prefix in ["ipfs/", "ipfs://"] {
+            if let Some(input_without_prefix) = input.strip_prefix(prefix) {
+                input = input_without_prefix
+            }
+        }
+
+        let (cid, path) = input.split_once('/').unwrap_or((input, ""));
+
+        let cid = cid
+            .parse::<Cid>()
+            .map_err(|err| IpfsError::InvalidContentPath {
+                input: input.to_string(),
+                source: anyhow::Error::from(err).context("invalid CID"),
+            })?;
+
+        if path.contains('?') {
+            return Err(IpfsError::InvalidContentPath {
+                input: input.to_string(),
+                source: anyhow!("query parameters not allowed"),
+            });
+        }
+
+        Ok(Self {
+            inner: Arc::new(Inner {
+                cid,
+                path: if path.is_empty() {
+                    None
+                } else {
+                    Some(path.to_string())
+                },
+            }),
+        })
+    }
+
+    pub fn cid(&self) -> &Cid {
+        &self.inner.cid
+    }
+
+    pub fn path(&self) -> Option<&str> {
+        self.inner.path.as_deref()
+    }
+}
+
+impl std::str::FromStr for ContentPath {
+    type Err = IpfsError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::new(s)
+    }
+}
+
+impl TryFrom<crate::data::store::scalar::Bytes> for ContentPath {
+    type Error = IpfsError;
+
+    fn try_from(bytes: crate::data::store::scalar::Bytes) -> Result<Self, Self::Error> {
+        let s = String::from_utf8(bytes.to_vec()).map_err(|err| IpfsError::InvalidContentPath {
+            input: bytes.to_string(),
+            source: err.into(),
+        })?;
+
+        Self::new(s)
+    }
+}
+
+impl std::fmt::Display for ContentPath {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let cid = &self.inner.cid;
+
+        match self.inner.path {
+            Some(ref path) => write!(f, "{cid}/{path}"),
+            None => write!(f, "{cid}"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const CID_V0: &str = "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn";
+    const CID_V1: &str = "bafybeiczsscdsbs7ffqz55asqdf3smv6klcw3gofszvwlyarci47bgf354";
+
+    fn make_path(cid: &str, path: Option<&str>) -> ContentPath {
+        ContentPath {
+            inner: Arc::new(Inner {
+                cid: cid.parse().unwrap(),
+                path: path.map(ToOwned::to_owned),
+            }),
+        }
+    }
+
+    #[test]
+    fn fails_on_empty_input() {
+        let err = ContentPath::new("").unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "'' is not a valid IPFS content path: content path is empty",
+        );
+    }
+
+    #[test]
+    fn fails_on_an_invalid_cid() {
+        let err = ContentPath::new("not_a_cid").unwrap_err();
+
+        assert!(
+            err.to_string()
+                .starts_with("'not_a_cid' is not a valid IPFS content path: invalid CID: ")
+        );
+    }
+
+    #[test]
+    fn accepts_a_valid_cid_v0() {
+        let path = ContentPath::new(CID_V0).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+    }
+
+    #[test]
+    fn accepts_a_valid_cid_v1() {
+        let path = ContentPath::new(CID_V1).unwrap();
+        assert_eq!(path, make_path(CID_V1, None));
+    }
+
+    #[test]
+    fn accepts_and_removes_leading_slashes() {
+        let path = ContentPath::new(format!("/{CID_V0}")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+
+        let path = ContentPath::new(format!("///////{CID_V0}")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+    }
+
+    #[test]
+    fn accepts_and_removes_trailing_slashes() {
+        let path = ContentPath::new(format!("{CID_V0}/")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+
+        let path = ContentPath::new(format!("{CID_V0}///////")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+    }
+
+    #[test]
+    fn accepts_a_path_after_the_cid() {
+        let path = ContentPath::new(format!("{CID_V0}/readme.md")).unwrap();
+        assert_eq!(path, make_path(CID_V0, Some("readme.md")));
+    }
+
+    #[test]
+    fn fails_on_an_invalid_cid_followed_by_a_path() {
+        let err = ContentPath::new("not_a_cid/readme.md").unwrap_err();
+
+        assert!(
+            err.to_string().starts_with(
+                "'not_a_cid/readme.md' is not a valid IPFS content path: invalid CID: "
+            )
+        );
+    }
+
+    #[test]
+    fn fails_on_attempts_to_pass_query_parameters() {
+        let err = ContentPath::new(format!("{CID_V0}/readme.md?offline=true")).unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            format!(
+                "'{CID_V0}/readme.md?offline=true' is not a valid IPFS content path: query parameters not allowed"
+            )
+        );
+    }
+
+    #[test]
+    fn accepts_and_removes_the_ipfs_prefix() {
+        let path = ContentPath::new(format!("/ipfs/{CID_V0}")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+
+        let path = ContentPath::new(format!("/ipfs/{CID_V0}/readme.md")).unwrap();
+        assert_eq!(path, make_path(CID_V0, Some("readme.md")));
+    }
+
+    #[test]
+    fn accepts_and_removes_the_ipfs_schema() {
+        let path = ContentPath::new(format!("ipfs://{CID_V0}")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+
+        let path = ContentPath::new(format!("ipfs://{CID_V0}/readme.md")).unwrap();
+        assert_eq!(path, make_path(CID_V0, Some("readme.md")));
+    }
+
+    #[test]
+    fn accepts_and_parses_ipfs_rpc_urls() {
+        let path = ContentPath::new(format!("http://ipfs.com/api/v0/cat?arg={CID_V0}")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+
+        let path =
+            ContentPath::new(format!("http://ipfs.com/api/v0/cat?arg={CID_V0}/readme.md")).unwrap();
+        assert_eq!(path, make_path(CID_V0, Some("readme.md")));
+
+        let path = ContentPath::new(format!("https://ipfs.com/api/v0/cat?arg={CID_V0}")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+
+        let path = ContentPath::new(format!(
+            "https://ipfs.com/api/v0/cat?arg={CID_V0}/readme.md"
+        ))
+        .unwrap();
+        assert_eq!(path, make_path(CID_V0, Some("readme.md")));
+    }
+
+    #[test]
+    fn accepts_and_parses_ipfs_gateway_urls() {
+        let path = ContentPath::new(format!("http://ipfs.com/ipfs/{CID_V0}")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+
+        let path = ContentPath::new(format!("http://ipfs.com/ipfs/{CID_V0}/readme.md")).unwrap();
+        assert_eq!(path, make_path(CID_V0, Some("readme.md")));
+
+        let path = ContentPath::new(format!("https://ipfs.com/ipfs/{CID_V0}")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+
+        let path = ContentPath::new(format!("https://ipfs.com/ipfs/{CID_V0}/readme.md")).unwrap();
+        assert_eq!(path, make_path(CID_V0, Some("readme.md")));
+    }
+
+    #[test]
+    fn accepts_and_parses_paths_from_urls() {
+        let path = ContentPath::new(format!("http://ipfs.com/{CID_V0}")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+
+        let path = ContentPath::new(format!("http://ipfs.com/{CID_V0}/readme.md")).unwrap();
+        assert_eq!(path, make_path(CID_V0, Some("readme.md")));
+
+        let path = ContentPath::new(format!("https://ipfs.com/{CID_V0}")).unwrap();
+        assert_eq!(path, make_path(CID_V0, None));
+
+        let path = ContentPath::new(format!("https://ipfs.com/{CID_V0}/readme.md")).unwrap();
+        assert_eq!(path, make_path(CID_V0, Some("readme.md")));
+    }
+}
diff --git a/graph/src/ipfs/error.rs b/graph/src/ipfs/error.rs
new file mode 100644
index 00000000000..6553813628b
--- /dev/null
+++ b/graph/src/ipfs/error.rs
@@ -0,0 +1,138 @@
+use reqwest::StatusCode;
+use thiserror::Error;
+
+use crate::ipfs::ContentPath;
+use crate::ipfs::ServerAddress;
+
+#[derive(Debug, Error)]
+pub enum IpfsError {
+    #[error("'{input}' is not a valid IPFS server address: {source:#}")]
+    InvalidServerAddress {
+        input: String,
+        source: anyhow::Error,
+    },
+
+    #[error("'{server_address}' is not a valid IPFS server: {reason:#}")]
+    InvalidServer {
+        server_address: ServerAddress,
+
+        #[source]
+        reason: anyhow::Error,
+    },
+
+    #[error("'{input}' is not a valid IPFS content path: {source:#}")]
+    InvalidContentPath {
+        input: String,
+        source: anyhow::Error,
+    },
+
+    #[error("IPFS content from '{path}' is not available: {reason:#}")]
+    ContentNotAvailable {
+        path: ContentPath,
+
+        #[source]
+        reason: anyhow::Error,
+    },
+
+    #[error("IPFS content from '{path}' exceeds the {max_size} bytes limit")]
+    ContentTooLarge { path: ContentPath, max_size: usize },
+
+    /// Does not consider HTTP status codes for timeouts.
+    #[error("IPFS request to '{path}' timed out")]
+    RequestTimeout { path: ContentPath },
+
+    #[error("IPFS request to '{path}' failed with a deterministic error: {reason:#}")]
+    DeterministicFailure {
+        path: ContentPath,
+        reason: DeterministicIpfsError,
+    },
+
+    #[error(transparent)]
+    RequestFailed(RequestError),
+
+    #[error("Invalid cache configuration: {source:#}")]
+    InvalidCacheConfig { source: anyhow::Error },
+}
+
+#[derive(Debug, Error)]
+pub enum DeterministicIpfsError {}
+
+#[derive(Debug, Error)]
+#[error("request to IPFS server failed: {0:#}")]
+pub struct RequestError(reqwest::Error);
+
+impl IpfsError {
+    /// Returns true if the sever is invalid.
+    pub fn is_invalid_server(&self) -> bool {
+        matches!(self, Self::InvalidServer { .. })
+    }
+
+    /// Returns true if the error was caused by a timeout.
+    ///
+    /// Considers HTTP status codes for timeouts.
+    pub fn is_timeout(&self) -> bool {
+        match self {
+            Self::RequestTimeout { .. } => true,
+            Self::RequestFailed(err) if err.is_timeout() => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the error was caused by a network connection failure.
+    pub fn is_networking(&self) -> bool {
+        matches!(self, Self::RequestFailed(err) if err.is_networking())
+    }
+
+    /// Returns true if the error is deterministic.
+    pub fn is_deterministic(&self) -> bool {
+        match self {
+            Self::InvalidServerAddress { .. } => true,
+            Self::InvalidServer { .. } => true,
+            Self::InvalidContentPath { .. } => true,
+            Self::ContentNotAvailable { .. } => false,
+            Self::ContentTooLarge { .. } => true,
+            Self::RequestTimeout { .. } => false,
+            Self::DeterministicFailure { .. } => true,
+            Self::RequestFailed(_) => false,
+            Self::InvalidCacheConfig { .. } => true,
+        }
+    }
+}
+
+impl From<reqwest::Error> for IpfsError {
+    fn from(err: reqwest::Error) -> Self {
+        // We remove the URL from the error as it may contain
+        // sensitive information such as auth tokens or passwords.
+        Self::RequestFailed(RequestError(err.without_url()))
+    }
+}
+
+impl RequestError {
+    /// Returns true if the request failed due to a networking error.
+    pub fn is_networking(&self) -> bool {
+        self.0.is_request() || self.0.is_connect() || self.0.is_timeout()
+    }
+
+    /// Returns true if the request failed due to a timeout.
+    pub fn is_timeout(&self) -> bool {
+        if self.0.is_timeout() {
+            return true;
+        }
+
+        let Some(status) = self.0.status() else {
+            return false;
+        };
+
+        const CLOUDFLARE_CONNECTION_TIMEOUT: u16 = 522;
+        const CLOUDFLARE_REQUEST_TIMEOUT: u16 = 524;
+
+        [
+            StatusCode::REQUEST_TIMEOUT,
+            StatusCode::GATEWAY_TIMEOUT,
+            StatusCode::from_u16(CLOUDFLARE_CONNECTION_TIMEOUT).unwrap(),
+            StatusCode::from_u16(CLOUDFLARE_REQUEST_TIMEOUT).unwrap(),
+        ]
+        .into_iter()
+        .any(|x| status == x)
+    }
+}
diff --git a/graph/src/ipfs/gateway_client.rs b/graph/src/ipfs/gateway_client.rs
new file mode 100644
index 00000000000..ff2a8a431cc
--- /dev/null
+++ b/graph/src/ipfs/gateway_client.rs
@@ -0,0 +1,662 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use async_trait::async_trait;
+use derive_more::Debug;
+use http::header::ACCEPT;
+use http::header::CACHE_CONTROL;
+use reqwest::{StatusCode, redirect::Policy as RedirectPolicy};
+use slog::Logger;
+
+use crate::env::ENV_VARS;
+use crate::ipfs::{
+    IpfsClient, IpfsError, IpfsMetrics, IpfsRequest, IpfsResponse, IpfsResult, RetryPolicy,
+    ServerAddress,
+};
+
+/// A client that connects to an IPFS gateway.
+///
+/// Reference: <https://specs.ipfs.tech/http-gateways/path-gateway>
+#[derive(Clone, Debug)]
+pub struct IpfsGatewayClient {
+    server_address: ServerAddress,
+
+    #[debug(skip)]
+    http_client: reqwest::Client,
+
+    metrics: IpfsMetrics,
+    logger: Logger,
+}
+
+impl IpfsGatewayClient {
+    /// Creates a new [IpfsGatewayClient] with the specified server address.
+    /// Verifies that the server is responding to IPFS gateway requests.
+    pub(crate) async fn new(
+        server_address: impl AsRef<str>,
+        metrics: IpfsMetrics,
+        logger: &Logger,
+    ) -> IpfsResult<Self> {
+        let client = Self::new_unchecked(server_address, metrics, logger)?;
+
+        client
+            .send_test_request()
+            .await
+            .map_err(|reason| IpfsError::InvalidServer {
+                server_address: client.server_address.clone(),
+                reason,
+            })?;
+
+        Ok(client)
+    }
+
+    /// Creates a new [IpfsGatewayClient] with the specified server address.
+    /// Does not verify that the server is responding to IPFS gateway requests.
+    pub fn new_unchecked(
+        server_address: impl AsRef<str>,
+        metrics: IpfsMetrics,
+        logger: &Logger,
+    ) -> IpfsResult<Self> {
+        Ok(Self {
+            server_address: ServerAddress::new(server_address)?,
+            http_client: reqwest::Client::builder()
+                // IPFS gateways allow requests to directory CIDs.
+                // However, they sometimes redirect before displaying the directory listing.
+                // This policy permits that behavior.
+                .redirect(RedirectPolicy::limited(1))
+                .build()?,
+            metrics,
+            logger: logger.to_owned(),
+        })
+    }
+
+    /// A one-time request sent at client initialization to verify that the specified
+    /// server address is a valid IPFS gateway server.
+    async fn send_test_request(&self) -> anyhow::Result<()> {
+        // To successfully perform this test, it does not really matter which CID we use.
+        const RANDOM_CID: &str = "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn";
+
+        // A special request described in the specification that should instruct the gateway
+        // to perform a very quick local check and return either HTTP status 200, which would
+        // mean the server has the content locally cached, or a 412 error, which would mean the
+        // content is not locally cached. This information is sufficient to verify that the
+        // server behaves like an IPFS gateway.
+        let req = self
+            .http_client
+            .head(self.ipfs_url(RANDOM_CID))
+            .header(CACHE_CONTROL, "only-if-cached");
+
+        let fut = RetryPolicy::NonDeterministic
+            .create("IPFS.Gateway.send_test_request", &self.logger)
+            .no_logging()
+            .no_timeout()
+            .run(move || {
+                let req = req.try_clone().expect("request can be cloned");
+
+                async move {
+                    let resp = req.send().await?;
+                    let status = resp.status();
+
+                    if status == StatusCode::OK || status == StatusCode::PRECONDITION_FAILED {
+                        return Ok(true);
+                    }
+
+                    resp.error_for_status()?;
+
+                    Ok(false)
+                }
+            });
+
+        let ok = tokio::time::timeout(ENV_VARS.ipfs_request_timeout, fut)
+            .await
+            .map_err(|_| anyhow!("request timed out"))??;
+
+        if !ok {
+            return Err(anyhow!("not a gateway"));
+        }
+
+        Ok(())
+    }
+
+    fn ipfs_url(&self, path_and_query: impl AsRef<str>) -> String {
+        format!("{}ipfs/{}", self.server_address, path_and_query.as_ref())
+    }
+}
+
+#[async_trait]
+impl IpfsClient for IpfsGatewayClient {
+    fn metrics(&self) -> &IpfsMetrics {
+        &self.metrics
+    }
+
+    async fn call(self: Arc<Self>, req: IpfsRequest) -> IpfsResult<IpfsResponse> {
+        use IpfsRequest::*;
+
+        let (path, req) = match req {
+            Cat(path) => {
+                let url = self.ipfs_url(path.to_string());
+                let req = self.http_client.get(url);
+
+                (path, req)
+            }
+            GetBlock(path) => {
+                let url = self.ipfs_url(format!("{path}?format=raw"));
+
+                let req = self
+                    .http_client
+                    .get(url)
+                    .header(ACCEPT, "application/vnd.ipld.raw");
+
+                (path, req)
+            }
+        };
+
+        let response = req.send().await?.error_for_status()?;
+
+        Ok(IpfsResponse { path, response })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use bytes::BytesMut;
+    use futures03::TryStreamExt;
+    use wiremock::Mock;
+    use wiremock::MockBuilder;
+    use wiremock::MockServer;
+    use wiremock::ResponseTemplate;
+    use wiremock::matchers as m;
+
+    use super::*;
+    use crate::data::subgraph::DeploymentHash;
+    use crate::ipfs::{ContentPath, IpfsContext, IpfsMetrics};
+    use crate::log::discard;
+
+    const PATH: &str = "/ipfs/QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn";
+
+    async fn mock_server() -> MockServer {
+        MockServer::start().await
+    }
+
+    fn mock_head() -> MockBuilder {
+        Mock::given(m::method("HEAD")).and(m::path(PATH))
+    }
+
+    fn mock_get() -> MockBuilder {
+        Mock::given(m::method("GET")).and(m::path(PATH))
+    }
+
+    fn mock_gateway_check(status: StatusCode) -> Mock {
+        mock_head()
+            .and(m::header("Cache-Control", "only-if-cached"))
+            .respond_with(ResponseTemplate::new(status))
+    }
+
+    fn mock_get_block() -> MockBuilder {
+        mock_get()
+            .and(m::query_param("format", "raw"))
+            .and(m::header("Accept", "application/vnd.ipld.raw"))
+    }
+
+    async fn make_client() -> (MockServer, Arc<IpfsGatewayClient>) {
+        let server = mock_server().await;
+        let client =
+            IpfsGatewayClient::new_unchecked(server.uri(), IpfsMetrics::test(), &discard())
+                .unwrap();
+
+        (server, Arc::new(client))
+    }
+
+    fn make_path() -> ContentPath {
+        ContentPath::new(PATH).unwrap()
+    }
+
+    fn ms(millis: u64) -> Duration {
+        Duration::from_millis(millis)
+    }
+
+    #[crate::test]
+    async fn new_fails_to_create_the_client_if_gateway_is_not_accessible() {
+        let server = mock_server().await;
+
+        IpfsGatewayClient::new(server.uri(), IpfsMetrics::test(), &discard())
+            .await
+            .unwrap_err();
+    }
+
+    #[crate::test]
+    async fn new_creates_the_client_if_it_can_check_the_gateway() {
+        let server = mock_server().await;
+
+        // Test content is cached locally on the gateway.
+        mock_gateway_check(StatusCode::OK)
+            .up_to_n_times(1)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        IpfsGatewayClient::new(server.uri(), IpfsMetrics::test(), &discard())
+            .await
+            .unwrap();
+
+        // Test content is not cached locally on the gateway.
+        mock_gateway_check(StatusCode::PRECONDITION_FAILED)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        IpfsGatewayClient::new(server.uri(), IpfsMetrics::test(), &discard())
+            .await
+            .unwrap();
+    }
+
+    #[crate::test]
+    async fn new_retries_gateway_check_on_non_deterministic_errors() {
+        let server = mock_server().await;
+
+        mock_gateway_check(StatusCode::INTERNAL_SERVER_ERROR)
+            .up_to_n_times(1)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        mock_gateway_check(StatusCode::OK)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        IpfsGatewayClient::new(server.uri(), IpfsMetrics::test(), &discard())
+            .await
+            .unwrap();
+    }
+
+    #[crate::test]
+    async fn new_unchecked_creates_the_client_without_checking_the_gateway() {
+        let server = mock_server().await;
+
+        IpfsGatewayClient::new_unchecked(server.uri(), IpfsMetrics::test(), &discard()).unwrap();
+    }
+
+    #[crate::test]
+    async fn cat_stream_returns_the_content() {
+        let (server, client) = make_client().await;
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"some data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .cat_stream(&IpfsContext::test(), &make_path(), None, RetryPolicy::None)
+            .await
+            .unwrap()
+            .try_fold(BytesMut::new(), |mut acc, chunk| async {
+                acc.extend(chunk);
+
+                Ok(acc)
+            })
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"some data")
+    }
+
+    #[crate::test]
+    async fn cat_stream_fails_on_timeout() {
+        let (server, client) = make_client().await;
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_delay(ms(500)))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let result = client
+            .cat_stream(
+                &IpfsContext::test(),
+                &make_path(),
+                Some(ms(300)),
+                RetryPolicy::None,
+            )
+            .await;
+
+        assert!(result.is_err());
+    }
+
+    #[crate::test]
+    async fn cat_stream_retries_the_request_on_non_deterministic_errors() {
+        let (server, client) = make_client().await;
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::INTERNAL_SERVER_ERROR))
+            .up_to_n_times(1)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::OK))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let _stream = client
+            .cat_stream(
+                &IpfsContext::test(),
+                &make_path(),
+                None,
+                RetryPolicy::NonDeterministic,
+            )
+            .await
+            .unwrap();
+    }
+
+    #[crate::test]
+    async fn cat_returns_the_content() {
+        let (server, client) = make_client().await;
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"some data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                usize::MAX,
+                None,
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"some data");
+    }
+
+    #[crate::test]
+    async fn cat_returns_the_content_if_max_size_is_equal_to_the_content_size() {
+        let (server, client) = make_client().await;
+
+        let data = b"some data";
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(data))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                data.len(),
+                None,
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), data);
+    }
+
+    #[crate::test]
+    async fn cat_fails_if_content_is_too_large() {
+        let (server, client) = make_client().await;
+
+        let data = b"some data";
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(data))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        client
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                data.len() - 1,
+                None,
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap_err();
+    }
+
+    #[crate::test]
+    async fn cat_fails_on_timeout() {
+        let (server, client) = make_client().await;
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_delay(ms(500)))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        client
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                usize::MAX,
+                Some(ms(300)),
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap_err();
+    }
+
+    #[crate::test]
+    async fn cat_retries_the_request_on_non_deterministic_errors() {
+        let (server, client) = make_client().await;
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::INTERNAL_SERVER_ERROR))
+            .up_to_n_times(1)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"some data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                usize::MAX,
+                None,
+                RetryPolicy::NonDeterministic,
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"some data");
+    }
+
+    #[crate::test]
+    async fn get_block_returns_the_block_content() {
+        let (server, client) = make_client().await;
+
+        mock_get_block()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"some data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .get_block(&IpfsContext::test(), &make_path(), None, RetryPolicy::None)
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"some data");
+    }
+
+    #[crate::test]
+    async fn get_block_fails_on_timeout() {
+        let (server, client) = make_client().await;
+
+        mock_get_block()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_delay(ms(500)))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        client
+            .get_block(
+                &IpfsContext::test(),
+                &make_path(),
+                Some(ms(300)),
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap_err();
+    }
+
+    #[crate::test]
+    async fn get_block_retries_the_request_on_non_deterministic_errors() {
+        let (server, client) = make_client().await;
+
+        mock_get_block()
+            .respond_with(ResponseTemplate::new(StatusCode::INTERNAL_SERVER_ERROR))
+            .up_to_n_times(1)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        mock_get_block()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"some data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .get_block(
+                &IpfsContext::test(),
+                &make_path(),
+                None,
+                RetryPolicy::NonDeterministic,
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"some data");
+    }
+
+    #[crate::test]
+    async fn operation_names_include_cid_for_debugging() {
+        use slog::{Drain, Logger, Record, o};
+        use std::sync::{Arc, Mutex};
+
+        // Custom drain to capture log messages
+        struct LogCapture {
+            messages: Arc<Mutex<Vec<String>>>,
+        }
+
+        impl Drain for LogCapture {
+            type Ok = ();
+            type Err = std::io::Error;
+
+            fn log(
+                &self,
+                record: &Record,
+                values: &slog::OwnedKVList,
+            ) -> std::result::Result<Self::Ok, Self::Err> {
+                use slog::KV;
+
+                let mut serialized_values = String::new();
+                let mut serializer = StringSerializer(&mut serialized_values);
+                values.serialize(record, &mut serializer).unwrap();
+
+                let message = format!("{}; {serialized_values}", record.msg());
+                self.messages.lock().unwrap().push(message);
+
+                Ok(())
+            }
+        }
+
+        struct StringSerializer<'a>(&'a mut String);
+
+        impl<'a> slog::Serializer for StringSerializer<'a> {
+            fn emit_arguments(
+                &mut self,
+                key: slog::Key,
+                val: &std::fmt::Arguments,
+            ) -> slog::Result {
+                use std::fmt::Write;
+                write!(self.0, "{}: {}, ", key, val).unwrap();
+                Ok(())
+            }
+        }
+
+        let captured_messages = Arc::new(Mutex::new(Vec::new()));
+        let drain = LogCapture {
+            messages: captured_messages.clone(),
+        };
+        let logger = Logger::root(drain.fuse(), o!());
+
+        let server = mock_server().await;
+        let client = Arc::new(
+            IpfsGatewayClient::new_unchecked(server.uri(), IpfsMetrics::test(), &logger).unwrap(),
+        );
+
+        // Set up mock to fail twice then succeed to trigger retry with warning logs
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::INTERNAL_SERVER_ERROR))
+            .up_to_n_times(2)
+            .expect(2)
+            .mount(&server)
+            .await;
+
+        mock_get()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let path = make_path();
+
+        // This should trigger retry logs because we set up failures first
+        let _result = client
+            .cat(
+                &IpfsContext::new(&DeploymentHash::default(), &logger),
+                &path,
+                usize::MAX,
+                None,
+                RetryPolicy::NonDeterministic,
+            )
+            .await
+            .unwrap();
+
+        // Check that the captured log messages include the CID
+        let messages = captured_messages.lock().unwrap();
+        let retry_messages: Vec<_> = messages
+            .iter()
+            .filter(|msg| msg.contains("Trying again after"))
+            .collect();
+
+        assert!(
+            !retry_messages.is_empty(),
+            "Expected retry messages but found none. All messages: {:?}",
+            *messages
+        );
+
+        // Verify that the operation name includes the CID
+        let expected_cid = "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn";
+        let has_cid_in_operation = retry_messages
+            .iter()
+            .any(|msg| msg.contains(&format!("path: {expected_cid}")));
+
+        assert!(
+            has_cid_in_operation,
+            "Expected operation name to include CID [{}] in retry messages: {:?}",
+            expected_cid, retry_messages
+        );
+    }
+}
diff --git a/graph/src/ipfs/metrics.rs b/graph/src/ipfs/metrics.rs
new file mode 100644
index 00000000000..48d6e3c7893
--- /dev/null
+++ b/graph/src/ipfs/metrics.rs
@@ -0,0 +1,100 @@
+use std::sync::Arc;
+
+use prometheus::{HistogramVec, IntCounterVec};
+
+use crate::{components::metrics::MetricsRegistry, derive::CheapClone};
+
+#[derive(Debug, Clone, CheapClone)]
+pub struct IpfsMetrics {
+    inner: Arc<Inner>,
+}
+
+#[derive(Debug)]
+struct Inner {
+    request_count: Box<IntCounterVec>,
+    error_count: Box<IntCounterVec>,
+    not_found_count: Box<IntCounterVec>,
+    request_duration: Box<HistogramVec>,
+}
+
+impl IpfsMetrics {
+    pub fn new(registry: &MetricsRegistry) -> Self {
+        let request_count = registry
+            .new_int_counter_vec(
+                "ipfs_request_count",
+                "The total number of IPFS requests.",
+                &["deployment"],
+            )
+            .unwrap();
+
+        let error_count = registry
+            .new_int_counter_vec(
+                "ipfs_error_count",
+                "The total number of failed IPFS requests.",
+                &["deployment"],
+            )
+            .unwrap();
+
+        let not_found_count = registry
+            .new_int_counter_vec(
+                "ipfs_not_found_count",
+                "The total number of IPFS requests that timed out.",
+                &["deployment"],
+            )
+            .unwrap();
+
+        let request_duration = registry
+            .new_histogram_vec(
+                "ipfs_request_duration",
+                "The duration of successful IPFS requests.\n\
+                 The time it takes to download the response body is not included.",
+                vec!["deployment".to_owned()],
+                vec![
+                    0.2, 0.5, 1.0, 5.0, 10.0, 20.0, 30.0, 60.0, 90.0, 120.0, 180.0, 240.0,
+                ],
+            )
+            .unwrap();
+
+        Self {
+            inner: Arc::new(Inner {
+                request_count,
+                error_count,
+                not_found_count,
+                request_duration,
+            }),
+        }
+    }
+
+    pub(super) fn add_request(&self, deployment_hash: &str) {
+        self.inner
+            .request_count
+            .with_label_values(&[deployment_hash])
+            .inc()
+    }
+
+    pub(super) fn add_error(&self, deployment_hash: &str) {
+        self.inner
+            .error_count
+            .with_label_values(&[deployment_hash])
+            .inc()
+    }
+
+    pub(super) fn add_not_found(&self, deployment_hash: &str) {
+        self.inner
+            .not_found_count
+            .with_label_values(&[deployment_hash])
+            .inc()
+    }
+
+    pub(super) fn observe_request_duration(&self, deployment_hash: &str, duration_secs: f64) {
+        self.inner
+            .request_duration
+            .with_label_values(&[deployment_hash])
+            .observe(duration_secs.clamp(0.2, 240.0));
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn test() -> Self {
+        Self::new(&MetricsRegistry::mock())
+    }
+}
diff --git a/graph/src/ipfs/mod.rs b/graph/src/ipfs/mod.rs
new file mode 100644
index 00000000000..1bbcc459be3
--- /dev/null
+++ b/graph/src/ipfs/mod.rs
@@ -0,0 +1,135 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use cache::CachingClient;
+use futures03::future::BoxFuture;
+use futures03::stream::FuturesUnordered;
+use futures03::stream::StreamExt;
+use slog::Logger;
+use slog::info;
+
+use crate::components::metrics::MetricsRegistry;
+use crate::util::security::SafeDisplay;
+
+mod cache;
+mod client;
+mod content_path;
+mod error;
+mod gateway_client;
+mod metrics;
+mod pool;
+mod retry_policy;
+mod rpc_client;
+mod server_address;
+
+pub mod test_utils;
+
+pub use self::client::{IpfsClient, IpfsContext, IpfsRequest, IpfsResponse};
+pub use self::content_path::ContentPath;
+pub use self::error::IpfsError;
+pub use self::error::RequestError;
+pub use self::gateway_client::IpfsGatewayClient;
+pub use self::metrics::IpfsMetrics;
+pub use self::pool::IpfsClientPool;
+pub use self::retry_policy::RetryPolicy;
+pub use self::rpc_client::IpfsRpcClient;
+pub use self::server_address::ServerAddress;
+
+pub type IpfsResult<T> = Result<T, IpfsError>;
+
+/// Creates and returns the most appropriate IPFS client for the given IPFS server addresses.
+///
+/// If multiple IPFS server addresses are specified, an IPFS client pool is created internally
+/// and for each IPFS request, the fastest client that can provide the content is
+/// automatically selected and the response is streamed from that client.
+///
+/// All clients are set up to cache results
+pub async fn new_ipfs_client<I, S>(
+    server_addresses: I,
+    registry: &MetricsRegistry,
+    logger: &Logger,
+) -> IpfsResult<Arc<dyn IpfsClient>>
+where
+    I: IntoIterator<Item = S>,
+    S: AsRef<str>,
+{
+    let metrics = IpfsMetrics::new(registry);
+    let mut clients: Vec<Arc<dyn IpfsClient>> = Vec::new();
+
+    for server_address in server_addresses {
+        let server_address = server_address.as_ref();
+
+        info!(
+            logger,
+            "Connecting to IPFS server at '{}'",
+            SafeDisplay(server_address)
+        );
+
+        let client = use_first_valid_api(server_address, metrics.clone(), logger).await?;
+        let client = Arc::new(CachingClient::new(client, logger).await?);
+        clients.push(client);
+    }
+
+    match clients.len() {
+        0 => Err(IpfsError::InvalidServerAddress {
+            input: "".to_owned(),
+            source: anyhow!("at least one server address is required"),
+        }),
+        1 => Ok(clients.pop().unwrap()),
+        n => {
+            info!(logger, "Creating a pool of {} IPFS clients", n);
+
+            let pool = IpfsClientPool::new(clients);
+            Ok(Arc::new(pool))
+        }
+    }
+}
+
+async fn use_first_valid_api(
+    server_address: &str,
+    metrics: IpfsMetrics,
+    logger: &Logger,
+) -> IpfsResult<Arc<dyn IpfsClient>> {
+    let supported_apis: Vec<BoxFuture<IpfsResult<Arc<dyn IpfsClient>>>> = vec![
+        Box::pin(async {
+            IpfsGatewayClient::new(server_address, metrics.clone(), logger)
+                .await
+                .map(|client| {
+                    info!(
+                        logger,
+                        "Successfully connected to IPFS gateway at: '{}'",
+                        SafeDisplay(server_address)
+                    );
+
+                    Arc::new(client) as Arc<dyn IpfsClient>
+                })
+        }),
+        Box::pin(async {
+            IpfsRpcClient::new(server_address, metrics.clone(), logger)
+                .await
+                .map(|client| {
+                    info!(
+                        logger,
+                        "Successfully connected to IPFS RPC API at: '{}'",
+                        SafeDisplay(server_address)
+                    );
+
+                    Arc::new(client) as Arc<dyn IpfsClient>
+                })
+        }),
+    ];
+
+    let mut stream = supported_apis.into_iter().collect::<FuturesUnordered<_>>();
+    while let Some(result) = stream.next().await {
+        match result {
+            Ok(client) => return Ok(client),
+            Err(err) if err.is_invalid_server() => {}
+            Err(err) => return Err(err),
+        };
+    }
+
+    Err(IpfsError::InvalidServer {
+        server_address: server_address.parse()?,
+        reason: anyhow!("unknown server kind"),
+    })
+}
diff --git a/graph/src/ipfs/pool.rs b/graph/src/ipfs/pool.rs
new file mode 100644
index 00000000000..d78ac0c9483
--- /dev/null
+++ b/graph/src/ipfs/pool.rs
@@ -0,0 +1,256 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use async_trait::async_trait;
+use futures03::stream::FuturesUnordered;
+use futures03::stream::StreamExt;
+
+use crate::ipfs::{IpfsClient, IpfsError, IpfsMetrics, IpfsRequest, IpfsResponse, IpfsResult};
+
+/// Contains a list of IPFS clients and, for each read request, selects the fastest IPFS client
+/// that can provide the content and streams the response from that client.
+///
+/// This can significantly improve performance when using multiple IPFS gateways,
+/// as some of them may already have the content cached.
+pub struct IpfsClientPool {
+    clients: Vec<Arc<dyn IpfsClient>>,
+}
+
+impl IpfsClientPool {
+    /// Creates a new IPFS client pool from the specified clients.
+    pub fn new(clients: Vec<Arc<dyn IpfsClient>>) -> Self {
+        assert!(!clients.is_empty());
+        Self { clients }
+    }
+}
+
+#[async_trait]
+impl IpfsClient for IpfsClientPool {
+    fn metrics(&self) -> &IpfsMetrics {
+        // All clients are expected to share the same metrics.
+        self.clients[0].metrics()
+    }
+
+    async fn call(self: Arc<Self>, req: IpfsRequest) -> IpfsResult<IpfsResponse> {
+        let mut futs = self
+            .clients
+            .iter()
+            .map(|client| client.clone().call(req.clone()))
+            .collect::<FuturesUnordered<_>>();
+
+        let mut last_err = None;
+
+        while let Some(result) = futs.next().await {
+            match result {
+                Ok(resp) => return Ok(resp),
+                Err(err) => last_err = Some(err),
+            };
+        }
+
+        let path = match req {
+            IpfsRequest::Cat(path) => path,
+            IpfsRequest::GetBlock(path) => path,
+        };
+
+        let err = last_err.unwrap_or_else(|| IpfsError::ContentNotAvailable {
+            path,
+            reason: anyhow!("no clients can provide the content"),
+        });
+
+        Err(err)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use bytes::BytesMut;
+    use futures03::TryStreamExt;
+    use http::StatusCode;
+    use wiremock::Mock;
+    use wiremock::MockBuilder;
+    use wiremock::MockServer;
+    use wiremock::ResponseTemplate;
+    use wiremock::matchers as m;
+
+    use super::*;
+    use crate::ipfs::{ContentPath, IpfsContext, IpfsGatewayClient, IpfsMetrics, RetryPolicy};
+    use crate::log::discard;
+
+    const PATH: &str = "/ipfs/QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn";
+
+    fn mock_get() -> MockBuilder {
+        Mock::given(m::method("GET")).and(m::path(PATH))
+    }
+
+    async fn make_client() -> (MockServer, Arc<IpfsGatewayClient>) {
+        let server = MockServer::start().await;
+        let client =
+            IpfsGatewayClient::new_unchecked(server.uri(), IpfsMetrics::test(), &discard())
+                .unwrap();
+
+        (server, Arc::new(client))
+    }
+
+    fn make_path() -> ContentPath {
+        ContentPath::new(PATH).unwrap()
+    }
+
+    fn ms(millis: u64) -> Duration {
+        Duration::from_millis(millis)
+    }
+
+    #[crate::test]
+    async fn cat_stream_streams_the_response_from_the_fastest_client() {
+        let (server_1, client_1) = make_client().await;
+        let (server_2, client_2) = make_client().await;
+        let (server_3, client_3) = make_client().await;
+
+        mock_get()
+            .respond_with(
+                ResponseTemplate::new(StatusCode::OK)
+                    .set_body_bytes(b"server_1")
+                    .set_delay(ms(300)),
+            )
+            .expect(1)
+            .mount(&server_1)
+            .await;
+
+        mock_get()
+            .respond_with(
+                ResponseTemplate::new(StatusCode::OK)
+                    .set_body_bytes(b"server_2")
+                    .set_delay(ms(200)),
+            )
+            .expect(1)
+            .mount(&server_2)
+            .await;
+
+        mock_get()
+            .respond_with(
+                ResponseTemplate::new(StatusCode::OK)
+                    .set_body_bytes(b"server_3")
+                    .set_delay(ms(100)),
+            )
+            .expect(1)
+            .mount(&server_3)
+            .await;
+
+        let clients: Vec<Arc<dyn IpfsClient>> = vec![client_1, client_2, client_3];
+        let pool = Arc::new(IpfsClientPool::new(clients));
+
+        let bytes = pool
+            .cat_stream(&IpfsContext::test(), &make_path(), None, RetryPolicy::None)
+            .await
+            .unwrap()
+            .try_fold(BytesMut::new(), |mut acc, chunk| async {
+                acc.extend(chunk);
+                Ok(acc)
+            })
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"server_3");
+    }
+
+    #[crate::test]
+    async fn cat_streams_the_response_from_the_fastest_client() {
+        let (server_1, client_1) = make_client().await;
+        let (server_2, client_2) = make_client().await;
+        let (server_3, client_3) = make_client().await;
+
+        mock_get()
+            .respond_with(
+                ResponseTemplate::new(StatusCode::OK)
+                    .set_body_bytes(b"server_1")
+                    .set_delay(ms(300)),
+            )
+            .expect(1)
+            .mount(&server_1)
+            .await;
+
+        mock_get()
+            .respond_with(
+                ResponseTemplate::new(StatusCode::OK)
+                    .set_body_bytes(b"server_2")
+                    .set_delay(ms(200)),
+            )
+            .expect(1)
+            .mount(&server_2)
+            .await;
+
+        mock_get()
+            .respond_with(
+                ResponseTemplate::new(StatusCode::OK)
+                    .set_body_bytes(b"server_3")
+                    .set_delay(ms(100)),
+            )
+            .expect(1)
+            .mount(&server_3)
+            .await;
+
+        let clients: Vec<Arc<dyn IpfsClient>> = vec![client_1, client_2, client_3];
+        let pool = Arc::new(IpfsClientPool::new(clients));
+
+        let bytes = pool
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                usize::MAX,
+                None,
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"server_3")
+    }
+
+    #[crate::test]
+    async fn get_block_streams_the_response_from_the_fastest_client() {
+        let (server_1, client_1) = make_client().await;
+        let (server_2, client_2) = make_client().await;
+        let (server_3, client_3) = make_client().await;
+
+        mock_get()
+            .respond_with(
+                ResponseTemplate::new(StatusCode::OK)
+                    .set_body_bytes(b"server_1")
+                    .set_delay(ms(300)),
+            )
+            .expect(1)
+            .mount(&server_1)
+            .await;
+
+        mock_get()
+            .respond_with(
+                ResponseTemplate::new(StatusCode::OK)
+                    .set_body_bytes(b"server_2")
+                    .set_delay(ms(200)),
+            )
+            .expect(1)
+            .mount(&server_2)
+            .await;
+
+        mock_get()
+            .respond_with(
+                ResponseTemplate::new(StatusCode::OK)
+                    .set_body_bytes(b"server_3")
+                    .set_delay(ms(100)),
+            )
+            .expect(1)
+            .mount(&server_3)
+            .await;
+
+        let clients: Vec<Arc<dyn IpfsClient>> = vec![client_1, client_2, client_3];
+        let pool = Arc::new(IpfsClientPool::new(clients));
+
+        let bytes = pool
+            .get_block(&IpfsContext::test(), &make_path(), None, RetryPolicy::None)
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"server_3")
+    }
+}
diff --git a/graph/src/ipfs/retry_policy.rs b/graph/src/ipfs/retry_policy.rs
new file mode 100644
index 00000000000..2b7d63f1657
--- /dev/null
+++ b/graph/src/ipfs/retry_policy.rs
@@ -0,0 +1,212 @@
+use slog::Logger;
+
+use crate::ipfs::error::IpfsError;
+use crate::prelude::*;
+use crate::util::futures::RetryConfig;
+use crate::util::futures::retry;
+
+/// Describes retry behavior when IPFS requests fail.
+#[derive(Clone, Copy, Debug)]
+pub enum RetryPolicy {
+    /// At the first error, immediately stops execution and returns the error.
+    None,
+
+    /// Retries the request if the error is related to the network connection.
+    Networking,
+
+    /// Retries the request if the error is related to the network connection,
+    /// and for any error that may be resolved by sending another request.
+    NonDeterministic,
+}
+
+impl RetryPolicy {
+    /// Creates a retry policy for every request sent to IPFS servers.
+    pub(super) fn create<O: Send + Sync + 'static>(
+        self,
+        operation_name: impl ToString,
+        logger: &Logger,
+    ) -> RetryConfig<O, IpfsError> {
+        retry(operation_name, logger)
+            .limit(ENV_VARS.mappings.ipfs_max_attempts)
+            .max_delay(ENV_VARS.ipfs_request_timeout)
+            .when(move |result: &Result<O, IpfsError>| match result {
+                Ok(_) => false,
+                Err(err) => match self {
+                    Self::None => false,
+                    Self::Networking => err.is_networking(),
+                    Self::NonDeterministic => !err.is_deterministic(),
+                },
+            })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+    use std::sync::atomic::AtomicU64;
+    use std::sync::atomic::Ordering;
+    use std::time::Duration;
+
+    use super::*;
+    use crate::ipfs::ContentPath;
+    use crate::log::discard;
+
+    const CID: &str = "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn";
+
+    fn path() -> ContentPath {
+        ContentPath::new(CID).unwrap()
+    }
+
+    #[crate::test]
+    async fn retry_policy_none_disables_retries() {
+        let counter = Arc::new(AtomicU64::new(0));
+
+        let err = RetryPolicy::None
+            .create::<()>("test", &discard())
+            .no_timeout()
+            .run({
+                let counter = counter.clone();
+                move || {
+                    let counter = counter.clone();
+                    async move {
+                        counter.fetch_add(1, Ordering::SeqCst);
+                        Err(IpfsError::RequestTimeout { path: path() })
+                    }
+                }
+            })
+            .await
+            .unwrap_err();
+
+        assert_eq!(counter.load(Ordering::SeqCst), 1);
+        assert!(matches!(err, IpfsError::RequestTimeout { .. }));
+    }
+
+    #[crate::test]
+    async fn retry_policy_networking_retries_only_network_related_errors() {
+        let counter = Arc::new(AtomicU64::new(0));
+
+        let err = RetryPolicy::Networking
+            .create("test", &discard())
+            .no_timeout()
+            .run({
+                let counter = counter.clone();
+                move || {
+                    let counter = counter.clone();
+                    async move {
+                        counter.fetch_add(1, Ordering::SeqCst);
+
+                        if counter.load(Ordering::SeqCst) == 10 {
+                            return Err(IpfsError::RequestTimeout { path: path() });
+                        }
+
+                        reqwest::Client::new()
+                            .get("https://simulate-dns-lookup-failure")
+                            .timeout(Duration::from_millis(50))
+                            .send()
+                            .await?;
+
+                        Ok(())
+                    }
+                }
+            })
+            .await
+            .unwrap_err();
+
+        assert_eq!(counter.load(Ordering::SeqCst), 10);
+        assert!(matches!(err, IpfsError::RequestTimeout { .. }));
+    }
+
+    #[crate::test]
+    async fn retry_policy_networking_stops_on_success() {
+        let counter = Arc::new(AtomicU64::new(0));
+
+        RetryPolicy::Networking
+            .create("test", &discard())
+            .no_timeout()
+            .run({
+                let counter = counter.clone();
+                move || {
+                    let counter = counter.clone();
+                    async move {
+                        counter.fetch_add(1, Ordering::SeqCst);
+
+                        if counter.load(Ordering::SeqCst) == 10 {
+                            return Ok(());
+                        }
+
+                        reqwest::Client::new()
+                            .get("https://simulate-dns-lookup-failure")
+                            .timeout(Duration::from_millis(50))
+                            .send()
+                            .await?;
+
+                        Ok(())
+                    }
+                }
+            })
+            .await
+            .unwrap();
+
+        assert_eq!(counter.load(Ordering::SeqCst), 10);
+    }
+
+    #[crate::test]
+    async fn retry_policy_non_deterministic_retries_all_non_deterministic_errors() {
+        let counter = Arc::new(AtomicU64::new(0));
+
+        let err = RetryPolicy::NonDeterministic
+            .create::<()>("test", &discard())
+            .no_timeout()
+            .run({
+                let counter = counter.clone();
+                move || {
+                    let counter = counter.clone();
+                    async move {
+                        counter.fetch_add(1, Ordering::SeqCst);
+
+                        if counter.load(Ordering::SeqCst) == 10 {
+                            return Err(IpfsError::ContentTooLarge {
+                                path: path(),
+                                max_size: 0,
+                            });
+                        }
+
+                        Err(IpfsError::RequestTimeout { path: path() })
+                    }
+                }
+            })
+            .await
+            .unwrap_err();
+
+        assert_eq!(counter.load(Ordering::SeqCst), 10);
+        assert!(matches!(err, IpfsError::ContentTooLarge { .. }));
+    }
+
+    #[crate::test]
+    async fn retry_policy_non_deterministic_stops_on_success() {
+        let counter = Arc::new(AtomicU64::new(0));
+
+        RetryPolicy::NonDeterministic
+            .create("test", &discard())
+            .no_timeout()
+            .run({
+                let counter = counter.clone();
+                move || {
+                    let counter = counter.clone();
+                    async move {
+                        counter.fetch_add(1, Ordering::SeqCst);
+
+                        if counter.load(Ordering::SeqCst) == 10 {
+                            return Ok(());
+                        }
+
+                        Err(IpfsError::RequestTimeout { path: path() })
+                    }
+                }
+            })
+            .await
+            .unwrap();
+
+        assert_eq!(counter.load(Ordering::SeqCst), 10);
+    }
+}
diff --git a/graph/src/ipfs/rpc_client.rs b/graph/src/ipfs/rpc_client.rs
new file mode 100644
index 00000000000..8dc1a7b9445
--- /dev/null
+++ b/graph/src/ipfs/rpc_client.rs
@@ -0,0 +1,510 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use async_trait::async_trait;
+use derive_more::Debug;
+use http::header::CONTENT_LENGTH;
+use reqwest::Response;
+use reqwest::StatusCode;
+use slog::Logger;
+
+use crate::env::ENV_VARS;
+use crate::ipfs::{
+    IpfsClient, IpfsError, IpfsMetrics, IpfsRequest, IpfsResponse, IpfsResult, RetryPolicy,
+    ServerAddress,
+};
+
+/// A client that connects to an IPFS RPC API.
+///
+/// Reference: <https://docs.ipfs.tech/reference/kubo/rpc>
+#[derive(Clone, Debug)]
+pub struct IpfsRpcClient {
+    server_address: ServerAddress,
+
+    #[debug(skip)]
+    http_client: reqwest::Client,
+
+    metrics: IpfsMetrics,
+    logger: Logger,
+}
+
+impl IpfsRpcClient {
+    /// Creates a new [IpfsRpcClient] with the specified server address.
+    /// Verifies that the server is responding to IPFS RPC API requests.
+    pub async fn new(
+        server_address: impl AsRef<str>,
+        metrics: IpfsMetrics,
+        logger: &Logger,
+    ) -> IpfsResult<Self> {
+        let client = Self::new_unchecked(server_address, metrics, logger)?;
+
+        client
+            .send_test_request()
+            .await
+            .map_err(|reason| IpfsError::InvalidServer {
+                server_address: client.server_address.clone(),
+                reason,
+            })?;
+
+        Ok(client)
+    }
+
+    /// Creates a new [IpfsRpcClient] with the specified server address.
+    /// Does not verify that the server is responding to IPFS RPC API requests.
+    pub fn new_unchecked(
+        server_address: impl AsRef<str>,
+        metrics: IpfsMetrics,
+        logger: &Logger,
+    ) -> IpfsResult<Self> {
+        Ok(Self {
+            server_address: ServerAddress::new(server_address)?,
+            http_client: reqwest::Client::new(),
+            metrics,
+            logger: logger.to_owned(),
+        })
+    }
+
+    /// A one-time request sent at client initialization to verify that the specified
+    /// server address is a valid IPFS RPC server.
+    async fn send_test_request(&self) -> anyhow::Result<()> {
+        let fut = RetryPolicy::NonDeterministic
+            .create("IPFS.RPC.send_test_request", &self.logger)
+            .no_logging()
+            .no_timeout()
+            .run({
+                let client = self.to_owned();
+
+                move || {
+                    let client = client.clone();
+
+                    async move {
+                        // While there may be unrelated servers that successfully respond to this
+                        // request, it is good enough to at least filter out unresponsive servers
+                        // and confirm that the server behaves like an IPFS RPC API.
+                        let status = client.send_request("version").await?.status();
+
+                        Ok(status == StatusCode::OK)
+                    }
+                }
+            });
+
+        let ok = tokio::time::timeout(ENV_VARS.ipfs_request_timeout, fut)
+            .await
+            .map_err(|_| anyhow!("request timed out"))??;
+
+        if !ok {
+            return Err(anyhow!("not an RPC API"));
+        }
+
+        Ok(())
+    }
+
+    async fn send_request(&self, path_and_query: impl AsRef<str>) -> IpfsResult<Response> {
+        let url = self.url(path_and_query);
+        let mut req = self.http_client.post(url);
+
+        // Some servers require `content-length` even for an empty body.
+        req = req.header(CONTENT_LENGTH, 0);
+
+        Ok(req.send().await?.error_for_status()?)
+    }
+
+    fn url(&self, path_and_query: impl AsRef<str>) -> String {
+        format!("{}api/v0/{}", self.server_address, path_and_query.as_ref())
+    }
+}
+
+#[async_trait]
+impl IpfsClient for IpfsRpcClient {
+    fn metrics(&self) -> &IpfsMetrics {
+        &self.metrics
+    }
+
+    async fn call(self: Arc<Self>, req: IpfsRequest) -> IpfsResult<IpfsResponse> {
+        use IpfsRequest::*;
+
+        let (path_and_query, path) = match req {
+            Cat(path) => (format!("cat?arg={path}"), path),
+            GetBlock(path) => (format!("block/get?arg={path}"), path),
+        };
+
+        let response = self.send_request(path_and_query).await?;
+
+        Ok(IpfsResponse { path, response })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use bytes::BytesMut;
+    use futures03::TryStreamExt;
+    use wiremock::Mock;
+    use wiremock::MockBuilder;
+    use wiremock::MockServer;
+    use wiremock::ResponseTemplate;
+    use wiremock::matchers as m;
+
+    use super::*;
+    use crate::ipfs::{ContentPath, IpfsContext, IpfsMetrics};
+    use crate::log::discard;
+
+    const CID: &str = "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn";
+
+    async fn mock_server() -> MockServer {
+        MockServer::start().await
+    }
+
+    fn mock_post(path: &str) -> MockBuilder {
+        Mock::given(m::method("POST")).and(m::path(format!("/api/v0/{path}")))
+    }
+
+    fn mock_cat() -> MockBuilder {
+        mock_post("cat").and(m::query_param("arg", CID))
+    }
+
+    fn mock_get_block() -> MockBuilder {
+        mock_post("block/get").and(m::query_param("arg", CID))
+    }
+
+    async fn make_client() -> (MockServer, Arc<IpfsRpcClient>) {
+        let server = mock_server().await;
+        let client =
+            IpfsRpcClient::new_unchecked(server.uri(), IpfsMetrics::test(), &discard()).unwrap();
+
+        (server, Arc::new(client))
+    }
+
+    fn make_path() -> ContentPath {
+        ContentPath::new(CID).unwrap()
+    }
+
+    fn ms(millis: u64) -> Duration {
+        Duration::from_millis(millis)
+    }
+
+    #[crate::test]
+    async fn new_fails_to_create_the_client_if_rpc_api_is_not_accessible() {
+        let server = mock_server().await;
+
+        IpfsRpcClient::new(server.uri(), IpfsMetrics::test(), &discard())
+            .await
+            .unwrap_err();
+    }
+
+    #[crate::test]
+    async fn new_creates_the_client_if_it_can_check_the_rpc_api() {
+        let server = mock_server().await;
+
+        mock_post("version")
+            .respond_with(ResponseTemplate::new(StatusCode::OK))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        IpfsRpcClient::new(server.uri(), IpfsMetrics::test(), &discard())
+            .await
+            .unwrap();
+    }
+
+    #[crate::test]
+    async fn new_retries_rpc_api_check_on_non_deterministic_errors() {
+        let server = mock_server().await;
+
+        mock_post("version")
+            .respond_with(ResponseTemplate::new(StatusCode::INTERNAL_SERVER_ERROR))
+            .up_to_n_times(1)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        mock_post("version")
+            .respond_with(ResponseTemplate::new(StatusCode::OK))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        IpfsRpcClient::new(server.uri(), IpfsMetrics::test(), &discard())
+            .await
+            .unwrap();
+    }
+
+    #[crate::test]
+    async fn new_unchecked_creates_the_client_without_checking_the_rpc_api() {
+        let server = mock_server().await;
+
+        IpfsRpcClient::new_unchecked(server.uri(), IpfsMetrics::test(), &discard()).unwrap();
+    }
+
+    #[crate::test]
+    async fn cat_stream_returns_the_content() {
+        let (server, client) = make_client().await;
+
+        mock_cat()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"some data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .cat_stream(&IpfsContext::test(), &make_path(), None, RetryPolicy::None)
+            .await
+            .unwrap()
+            .try_fold(BytesMut::new(), |mut acc, chunk| async {
+                acc.extend(chunk);
+
+                Ok(acc)
+            })
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"some data");
+    }
+
+    #[crate::test]
+    async fn cat_stream_fails_on_timeout() {
+        let (server, client) = make_client().await;
+
+        mock_cat()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_delay(ms(500)))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let result = client
+            .cat_stream(
+                &IpfsContext::test(),
+                &make_path(),
+                Some(ms(300)),
+                RetryPolicy::None,
+            )
+            .await;
+
+        assert!(result.is_err());
+    }
+
+    #[crate::test]
+    async fn cat_stream_retries_the_request_on_non_deterministic_errors() {
+        let (server, client) = make_client().await;
+
+        mock_cat()
+            .respond_with(ResponseTemplate::new(StatusCode::INTERNAL_SERVER_ERROR))
+            .up_to_n_times(1)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        mock_cat()
+            .respond_with(ResponseTemplate::new(StatusCode::OK))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let _stream = client
+            .cat_stream(
+                &IpfsContext::test(),
+                &make_path(),
+                None,
+                RetryPolicy::NonDeterministic,
+            )
+            .await
+            .unwrap();
+    }
+
+    #[crate::test]
+    async fn cat_returns_the_content() {
+        let (server, client) = make_client().await;
+
+        mock_cat()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"some data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                usize::MAX,
+                None,
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"some data");
+    }
+
+    #[crate::test]
+    async fn cat_returns_the_content_if_max_size_is_equal_to_the_content_size() {
+        let (server, client) = make_client().await;
+
+        let data = b"some data";
+
+        mock_cat()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(data))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                data.len(),
+                None,
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), data);
+    }
+
+    #[crate::test]
+    async fn cat_fails_if_content_is_too_large() {
+        let (server, client) = make_client().await;
+
+        let data = b"some data";
+
+        mock_cat()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(data))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        client
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                data.len() - 1,
+                None,
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap_err();
+    }
+
+    #[crate::test]
+    async fn cat_fails_on_timeout() {
+        let (server, client) = make_client().await;
+
+        mock_cat()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_delay(ms(500)))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        client
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                usize::MAX,
+                Some(ms(300)),
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap_err();
+    }
+
+    #[crate::test]
+    async fn cat_retries_the_request_on_non_deterministic_errors() {
+        let (server, client) = make_client().await;
+
+        mock_cat()
+            .respond_with(ResponseTemplate::new(StatusCode::INTERNAL_SERVER_ERROR))
+            .up_to_n_times(1)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        mock_cat()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"some data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .cat(
+                &IpfsContext::test(),
+                &make_path(),
+                usize::MAX,
+                None,
+                RetryPolicy::NonDeterministic,
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"some data");
+    }
+
+    #[crate::test]
+    async fn get_block_returns_the_block_content() {
+        let (server, client) = make_client().await;
+
+        mock_get_block()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"some data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .get_block(&IpfsContext::test(), &make_path(), None, RetryPolicy::None)
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"some data");
+    }
+
+    #[crate::test]
+    async fn get_block_fails_on_timeout() {
+        let (server, client) = make_client().await;
+
+        mock_get_block()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_delay(ms(500)))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        client
+            .get_block(
+                &IpfsContext::test(),
+                &make_path(),
+                Some(ms(300)),
+                RetryPolicy::None,
+            )
+            .await
+            .unwrap_err();
+    }
+
+    #[crate::test]
+    async fn get_block_retries_the_request_on_non_deterministic_errors() {
+        let (server, client) = make_client().await;
+
+        mock_get_block()
+            .respond_with(ResponseTemplate::new(StatusCode::INTERNAL_SERVER_ERROR))
+            .up_to_n_times(1)
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        mock_get_block()
+            .respond_with(ResponseTemplate::new(StatusCode::OK).set_body_bytes(b"some data"))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let bytes = client
+            .get_block(
+                &IpfsContext::test(),
+                &make_path(),
+                None,
+                RetryPolicy::NonDeterministic,
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(bytes.as_ref(), b"some data");
+    }
+}
diff --git a/graph/src/ipfs/server_address.rs b/graph/src/ipfs/server_address.rs
new file mode 100644
index 00000000000..a6a7cfe759a
--- /dev/null
+++ b/graph/src/ipfs/server_address.rs
@@ -0,0 +1,186 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use http::Uri;
+use http::uri::Scheme;
+
+use crate::derive::CheapClone;
+use crate::ipfs::IpfsError;
+use crate::ipfs::IpfsResult;
+
+/// Contains a valid IPFS server address.
+#[derive(Clone, Debug, CheapClone)]
+pub struct ServerAddress {
+    inner: Arc<str>,
+}
+
+impl ServerAddress {
+    /// Creates a new [ServerAddress] from the specified input.
+    pub fn new(input: impl AsRef<str>) -> IpfsResult<Self> {
+        let input = input.as_ref();
+
+        if input.is_empty() {
+            return Err(IpfsError::InvalidServerAddress {
+                input: input.to_owned(),
+                source: anyhow!("address is empty"),
+            });
+        }
+
+        let uri = input
+            .parse::<Uri>()
+            .map_err(|err| IpfsError::InvalidServerAddress {
+                input: input.to_owned(),
+                source: err.into(),
+            })?;
+
+        let scheme = uri
+            .scheme()
+            // Default to HTTP for backward compatibility.
+            .unwrap_or(&Scheme::HTTP);
+
+        let authority = uri
+            .authority()
+            .ok_or_else(|| IpfsError::InvalidServerAddress {
+                input: input.to_owned(),
+                source: anyhow!("missing authority"),
+            })?;
+
+        let mut inner = format!("{scheme}://");
+
+        // In the case of IPFS gateways, depending on the configuration, path requests are
+        // sometimes redirected to the subdomain resolver. This is a problem for localhost because
+        // some operating systems do not allow subdomain DNS resolutions on localhost for security
+        // reasons. To avoid forcing users to always specify an IP address instead of localhost
+        // when they want to use a local IPFS gateway, we will naively try to do this for them.
+        if authority.host().to_lowercase() == "localhost" {
+            inner.push_str("127.0.0.1");
+
+            if let Some(port) = authority.port_u16() {
+                inner.push_str(&format!(":{port}"));
+            }
+        } else {
+            inner.push_str(authority.as_str());
+        }
+
+        inner.push_str(uri.path().trim_end_matches('/'));
+        inner.push('/');
+
+        Ok(Self {
+            inner: inner.into(),
+        })
+    }
+
+    pub fn test_rpc_api() -> Self {
+        match std::env::var("GRAPH_NODE_TEST_IPFS_URL") {
+            Ok(value) if !value.is_empty() => Self::new(&value).unwrap_or_else(|e| {
+                panic!("GRAPH_NODE_TEST_IPFS_URL contains an invalid URL: {value}: {e}")
+            }),
+            _ => Self::new("http://127.0.0.1:5001").unwrap(),
+        }
+    }
+}
+
+impl std::str::FromStr for ServerAddress {
+    type Err = IpfsError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::new(s)
+    }
+}
+
+impl AsRef<str> for ServerAddress {
+    fn as_ref(&self) -> &str {
+        &self.inner
+    }
+}
+
+impl std::fmt::Display for ServerAddress {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.inner)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fails_on_an_empty_address() {
+        let err = ServerAddress::new("").unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "'' is not a valid IPFS server address: address is empty",
+        );
+    }
+
+    #[test]
+    fn requires_an_authority() {
+        let err = ServerAddress::new("https://").unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "'https://' is not a valid IPFS server address: empty string",
+        );
+    }
+
+    #[test]
+    fn accepts_a_valid_address() {
+        let addr = ServerAddress::new("https://example.com/").unwrap();
+
+        assert_eq!(addr.to_string(), "https://example.com/");
+    }
+
+    #[test]
+    fn defaults_to_http_scheme() {
+        let addr = ServerAddress::new("example.com").unwrap();
+
+        assert_eq!(addr.to_string(), "http://example.com/");
+    }
+
+    #[test]
+    fn accepts_a_valid_address_with_a_port() {
+        let addr = ServerAddress::new("https://example.com:8080/").unwrap();
+
+        assert_eq!(addr.to_string(), "https://example.com:8080/");
+    }
+
+    #[test]
+    fn rewrites_localhost_to_ipv4() {
+        let addr = ServerAddress::new("https://localhost/").unwrap();
+
+        assert_eq!(addr.to_string(), "https://127.0.0.1/");
+    }
+
+    #[test]
+    fn maintains_the_port_on_localhost_rewrite() {
+        let addr = ServerAddress::new("https://localhost:8080/").unwrap();
+
+        assert_eq!(addr.to_string(), "https://127.0.0.1:8080/");
+    }
+
+    #[test]
+    fn keeps_the_path_in_an_address() {
+        let addr = ServerAddress::new("https://example.com/ipfs/").unwrap();
+
+        assert_eq!(addr.to_string(), "https://example.com/ipfs/");
+    }
+
+    #[test]
+    fn removes_the_query_from_an_address() {
+        let addr = ServerAddress::new("https://example.com/?format=json").unwrap();
+
+        assert_eq!(addr.to_string(), "https://example.com/");
+    }
+
+    #[test]
+    fn adds_a_final_slash() {
+        let addr = ServerAddress::new("https://example.com").unwrap();
+
+        assert_eq!(addr.to_string(), "https://example.com/");
+
+        let addr = ServerAddress::new("https://example.com/ipfs").unwrap();
+
+        assert_eq!(addr.to_string(), "https://example.com/ipfs/");
+    }
+}
diff --git a/graph/src/ipfs/test_utils.rs b/graph/src/ipfs/test_utils.rs
new file mode 100644
index 00000000000..af4bf72ff34
--- /dev/null
+++ b/graph/src/ipfs/test_utils.rs
@@ -0,0 +1,78 @@
+use reqwest::multipart;
+use serde::Deserialize;
+
+use crate::ipfs;
+
+#[derive(Clone, Debug)]
+pub struct IpfsAddFile {
+    path: String,
+    content: Vec<u8>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct IpfsAddResponse {
+    pub name: String,
+    pub hash: String,
+}
+
+impl From<Vec<u8>> for IpfsAddFile {
+    fn from(content: Vec<u8>) -> Self {
+        Self {
+            path: Default::default(),
+            content,
+        }
+    }
+}
+
+impl<T, U> From<(T, U)> for IpfsAddFile
+where
+    T: Into<String>,
+    U: Into<Vec<u8>>,
+{
+    fn from((path, content): (T, U)) -> Self {
+        Self {
+            path: path.into(),
+            content: content.into(),
+        }
+    }
+}
+
+pub async fn add_files_to_local_ipfs_node_for_testing<T, U>(
+    files: T,
+) -> anyhow::Result<Vec<IpfsAddResponse>>
+where
+    T: IntoIterator<Item = U>,
+    U: Into<IpfsAddFile>,
+{
+    let mut form = multipart::Form::new();
+
+    for file in files.into_iter() {
+        let file = file.into();
+        let part = multipart::Part::bytes(file.content).file_name(file.path);
+
+        form = form.part("path", part);
+    }
+
+    let resp = reqwest::Client::new()
+        .post(format!("{}api/v0/add", ipfs::ServerAddress::test_rpc_api()))
+        .multipart(form)
+        .send()
+        .await?
+        .text()
+        .await?;
+
+    let mut output = Vec::new();
+
+    for line in resp.lines() {
+        let line = line.trim();
+
+        if line.is_empty() {
+            continue;
+        }
+
+        output.push(serde_json::from_str::<IpfsAddResponse>(line)?);
+    }
+
+    Ok(output)
+}
diff --git a/graph/src/ipfs_client.rs b/graph/src/ipfs_client.rs
deleted file mode 100644
index 6d921f22837..00000000000
--- a/graph/src/ipfs_client.rs
+++ /dev/null
@@ -1,326 +0,0 @@
-use crate::prelude::CheapClone;
-use anyhow::anyhow;
-use anyhow::Error;
-use bytes::Bytes;
-use cid::Cid;
-use futures03::Stream;
-use http::header::CONTENT_LENGTH;
-use http::Uri;
-use reqwest::multipart;
-use serde::Deserialize;
-use std::fmt::Display;
-use std::time::Duration;
-use std::{str::FromStr, sync::Arc};
-
-/// Represents a file on Ipfs. This file can be the CID or a path within a folder CID.
-/// The path cannot have a prefix (ie CID/hello.json would be cid: CID path: "hello.json")
-#[derive(Debug, Clone, Default, Eq, PartialEq, Hash)]
-pub struct CidFile {
-    pub cid: Cid,
-    pub path: Option<String>,
-}
-
-impl Display for CidFile {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let str = match self.path {
-            Some(ref f) => format!("{}/{}", self.cid, f),
-            None => self.cid.to_string(),
-        };
-        f.write_str(&str)
-    }
-}
-
-impl CidFile {
-    pub fn to_bytes(&self) -> Vec<u8> {
-        self.to_string().as_bytes().to_vec()
-    }
-}
-
-impl TryFrom<crate::data::store::scalar::Bytes> for CidFile {
-    type Error = anyhow::Error;
-
-    fn try_from(value: crate::data::store::scalar::Bytes) -> Result<Self, Self::Error> {
-        let str = String::from_utf8(value.to_vec())?;
-
-        Self::from_str(&str)
-    }
-}
-
-/// The string should not have a prefix and only one slash after the CID is removed, everything
-/// else is considered a file path. If this is malformed, it will fail to find the file.
-impl FromStr for CidFile {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s.is_empty() {
-            return Err(anyhow!("cid can't be empty"));
-        }
-
-        let cid_str: String = s.chars().take_while(|c| *c != '/').collect();
-        let cid = Cid::from_str(&cid_str)?;
-
-        // if cid was the only content or if it's just slash terminated.
-        if cid_str.len() == s.len() || s.len() + 1 == cid_str.len() {
-            return Ok(CidFile { cid, path: None });
-        }
-
-        let file: String = s[cid_str.len() + 1..].to_string();
-        let path = if file.is_empty() { None } else { Some(file) };
-
-        Ok(CidFile { cid, path })
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum StatApi {
-    Block,
-    Files,
-}
-
-impl StatApi {
-    fn route(&self) -> &'static str {
-        match self {
-            Self::Block => "block",
-            Self::Files => "files",
-        }
-    }
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "PascalCase")]
-struct BlockStatResponse {
-    size: u64,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "PascalCase")]
-struct FilesStatResponse {
-    cumulative_size: u64,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "PascalCase")]
-pub struct AddResponse {
-    pub name: String,
-    pub hash: String,
-    pub size: String,
-}
-
-/// Reference type, clones will share the connection pool.
-#[derive(Clone)]
-pub struct IpfsClient {
-    base: Arc<Uri>,
-    // reqwest::Client doesn't need to be `Arc` because it has one internally
-    // already.
-    client: reqwest::Client,
-}
-
-impl CheapClone for IpfsClient {
-    fn cheap_clone(&self) -> Self {
-        IpfsClient {
-            base: self.base.cheap_clone(),
-            client: self.client.cheap_clone(),
-        }
-    }
-}
-
-impl IpfsClient {
-    pub fn new(base: &str) -> Result<Self, Error> {
-        Ok(IpfsClient {
-            client: reqwest::Client::new(),
-            base: Arc::new(Uri::from_str(base)?),
-        })
-    }
-
-    pub fn localhost() -> Self {
-        IpfsClient {
-            client: reqwest::Client::new(),
-            base: Arc::new(Uri::from_str("http://localhost:5001").unwrap()),
-        }
-    }
-
-    /// Calls stat for the given API route, and returns the total size of the object.
-    pub async fn stat_size(
-        &self,
-        api: StatApi,
-        mut cid: String,
-        timeout: Duration,
-    ) -> Result<u64, reqwest::Error> {
-        let route = format!("{}/stat", api.route());
-        if api == StatApi::Files {
-            // files/stat requires a leading `/ipfs/`.
-            cid = format!("/ipfs/{}", cid);
-        }
-        let url = self.url(&route, &cid);
-        let res = self.call(url, None, Some(timeout)).await?;
-        match api {
-            StatApi::Files => Ok(res.json::<FilesStatResponse>().await?.cumulative_size),
-            StatApi::Block => Ok(res.json::<BlockStatResponse>().await?.size),
-        }
-    }
-
-    /// Download the entire contents.
-    pub async fn cat_all(&self, cid: &str, timeout: Duration) -> Result<Bytes, reqwest::Error> {
-        self.call(self.url("cat", cid), None, Some(timeout))
-            .await?
-            .bytes()
-            .await
-    }
-
-    pub async fn cat(
-        &self,
-        cid: &str,
-        timeout: Option<Duration>,
-    ) -> Result<impl Stream<Item = Result<Bytes, reqwest::Error>>, reqwest::Error> {
-        Ok(self
-            .call(self.url("cat", cid), None, timeout)
-            .await?
-            .bytes_stream())
-    }
-
-    pub async fn get_block(&self, cid: String) -> Result<Bytes, reqwest::Error> {
-        let form = multipart::Form::new().part("arg", multipart::Part::text(cid));
-        self.call(format!("{}api/v0/block/get", self.base), Some(form), None)
-            .await?
-            .bytes()
-            .await
-    }
-
-    pub async fn test(&self) -> Result<(), reqwest::Error> {
-        self.call(format!("{}api/v0/version", self.base), None, None)
-            .await
-            .map(|_| ())
-    }
-
-    pub async fn add(&self, data: Vec<u8>) -> Result<AddResponse, reqwest::Error> {
-        let form = multipart::Form::new().part("path", multipart::Part::bytes(data));
-
-        self.call(format!("{}api/v0/add", self.base), Some(form), None)
-            .await?
-            .json()
-            .await
-    }
-
-    fn url(&self, route: &str, arg: &str) -> String {
-        // URL security: We control the base and the route, user-supplied input goes only into the
-        // query parameters.
-        format!("{}api/v0/{}?arg={}", self.base, route, arg)
-    }
-
-    async fn call(
-        &self,
-        url: String,
-        form: Option<multipart::Form>,
-        timeout: Option<Duration>,
-    ) -> Result<reqwest::Response, reqwest::Error> {
-        let mut req = self.client.post(&url);
-        if let Some(form) = form {
-            req = req.multipart(form);
-        } else {
-            // Some servers require `content-length` even for an empty body.
-            req = req.header(CONTENT_LENGTH, 0);
-        }
-
-        if let Some(timeout) = timeout {
-            req = req.timeout(timeout)
-        }
-
-        req.send()
-            .await
-            .map(|res| res.error_for_status())
-            .and_then(|x| x)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::str::FromStr;
-
-    use anyhow::anyhow;
-    use cid::Cid;
-
-    use crate::ipfs_client::CidFile;
-
-    #[test]
-    fn test_cid_parsing() {
-        let cid_str = "bafyreibjo4xmgaevkgud7mbifn3dzp4v4lyaui4yvqp3f2bqwtxcjrdqg4";
-        let cid = Cid::from_str(cid_str).unwrap();
-
-        struct Case<'a> {
-            name: &'a str,
-            input: String,
-            path: String,
-            expected: Result<CidFile, anyhow::Error>,
-        }
-
-        let cases = vec![
-            Case {
-                name: "correct no slashes, no file",
-                input: cid_str.to_string(),
-                path: cid_str.to_string(),
-                expected: Ok(CidFile { cid, path: None }),
-            },
-            Case {
-                name: "correct with file path",
-                input: format!("{}/file.json", cid),
-                path: format!("{}/file.json", cid_str),
-                expected: Ok(CidFile {
-                    cid,
-                    path: Some("file.json".into()),
-                }),
-            },
-            Case {
-                name: "correct cid with trailing slash",
-                input: format!("{}/", cid),
-                path: format!("{}", cid),
-                expected: Ok(CidFile { cid, path: None }),
-            },
-            Case {
-                name: "incorrect, empty",
-                input: "".to_string(),
-                path: "".to_string(),
-                expected: Err(anyhow!("cid can't be empty")),
-            },
-            Case {
-                name: "correct, two slahes",
-                input: format!("{}//", cid),
-                path: format!("{}//", cid),
-                expected: Ok(CidFile {
-                    cid,
-                    path: Some("/".into()),
-                }),
-            },
-            Case {
-                name: "incorrect, leading slahes",
-                input: format!("/ipfs/{}/file.json", cid),
-                path: "".to_string(),
-                expected: Err(anyhow!("Input too short")),
-            },
-            Case {
-                name: "correct syntax, invalid CID",
-                input: "notacid/file.json".to_string(),
-                path: "".to_string(),
-                expected: Err(anyhow!("Failed to parse multihash")),
-            },
-        ];
-
-        for case in cases {
-            let f = CidFile::from_str(&case.input);
-
-            match case.expected {
-                Ok(cid_file) => {
-                    assert!(f.is_ok(), "case: {}", case.name);
-                    let f = f.unwrap();
-                    assert_eq!(f, cid_file, "case: {}", case.name);
-                    assert_eq!(f.to_string(), case.path, "case: {}", case.name);
-                }
-                Err(err) => assert_eq!(
-                    f.unwrap_err().to_string(),
-                    err.to_string(),
-                    "case: {}",
-                    case.name
-                ),
-            }
-        }
-    }
-}
diff --git a/graph/src/lib.rs b/graph/src/lib.rs
index 94b185a93ae..00f01f53551 100644
--- a/graph/src/lib.rs
+++ b/graph/src/lib.rs
@@ -16,8 +16,6 @@ pub mod log;
 /// `CheapClone` trait.
 pub mod cheap_clone;
 
-pub mod ipfs_client;
-
 pub mod data_source;
 
 pub mod blockchain;
@@ -26,10 +24,6 @@ pub mod runtime;
 
 pub mod firehose;
 
-pub mod substreams;
-
-pub mod substreams_rpc;
-
 pub mod endpoint;
 
 pub mod schema;
@@ -37,25 +31,42 @@ pub mod schema;
 /// Helpers for parsing environment variables.
 pub mod env;
 
+pub mod ipfs;
+
+pub mod tls;
+
+pub mod abi;
+
+pub mod amp;
+
 /// Wrapper for spawning tasks that abort on panic, which is our default.
-mod task_spawn;
-pub use task_spawn::{
+mod tokio;
+#[cfg(debug_assertions)]
+pub use tokio::TEST_RUNTIME;
+pub use tokio::{
     block_on, spawn, spawn_allow_panic, spawn_blocking, spawn_blocking_allow_panic, spawn_thread,
 };
 
 pub use anyhow;
 pub use bytes;
+pub use futures01;
+pub use futures03;
+pub use graph_derive as derive;
+pub use graph_derive::test;
+pub use http;
+pub use http_body_util;
+pub use http0;
+pub use hyper;
+pub use hyper_util;
 pub use itertools;
 pub use parking_lot;
 pub use petgraph;
 pub use prometheus;
 pub use semver;
 pub use slog;
+pub use sqlparser;
 pub use stable_hash;
 pub use stable_hash_legacy;
-pub use tokio;
-pub use tokio_retry;
-pub use tokio_stream;
 pub use url;
 
 /// A prelude that makes all system component traits and data types available.
@@ -67,23 +78,12 @@ pub use url;
 /// ```
 pub mod prelude {
     pub use ::anyhow;
-    pub use anyhow::{anyhow, Context as _, Error};
-    pub use async_trait::async_trait;
-    pub use bigdecimal;
+    pub use alloy;
+    pub use anyhow::{Context as _, Error, anyhow};
     pub use chrono;
     pub use diesel;
     pub use envconfig;
-    pub use ethabi;
-    pub use futures::future;
-    pub use futures::prelude::*;
-    pub use futures::stream;
-    pub use futures03;
-    pub use futures03::compat::{Future01CompatExt, Sink01CompatExt, Stream01CompatExt};
-    pub use futures03::future::{FutureExt as _, TryFutureExt};
-    pub use futures03::sink::SinkExt as _;
-    pub use futures03::stream::{StreamExt as _, TryStreamExt};
     pub use hex;
-    pub use isatty;
     pub use lazy_static::lazy_static;
     pub use prost;
     pub use rand;
@@ -94,7 +94,7 @@ pub mod prelude {
     pub use serde_json;
     pub use serde_regex;
     pub use serde_yaml;
-    pub use slog::{self, crit, debug, error, info, o, trace, warn, Logger};
+    pub use slog::{self, Logger, crit, debug, error, info, o, trace, warn};
     pub use std::convert::TryFrom;
     pub use std::fmt::Debug;
     pub use std::iter::FromIterator;
@@ -102,11 +102,9 @@ pub mod prelude {
     pub use std::sync::Arc;
     pub use std::time::Duration;
     pub use thiserror;
-    pub use tiny_keccak;
     pub use tokio;
     pub use toml;
     pub use tonic;
-    pub use web3;
 
     pub type DynTryFuture<'a, Ok = (), Err = Error> =
         Pin<Box<dyn futures03::Future<Output = Result<Ok, Err>> + Send + 'a>>;
@@ -117,46 +115,42 @@ pub mod prelude {
         EthereumBlock, EthereumBlockWithCalls, EthereumCall, LightEthereumBlock,
         LightEthereumBlockExt,
     };
-    pub use crate::components::graphql::{GraphQLMetrics, GraphQlRunner, SubscriptionResultFuture};
-    pub use crate::components::link_resolver::{JsonStreamValue, JsonValueStream, LinkResolver};
+    pub use crate::components::graphql::{GraphQLMetrics, GraphQlRunner};
+    pub use crate::components::link_resolver::{
+        IpfsResolver, JsonStreamValue, JsonValueStream, LinkResolver,
+    };
     pub use crate::components::metrics::{
-        stopwatch::StopwatchMetrics, subgraph::*, Collector, Counter, CounterVec, Gauge, GaugeVec,
-        Histogram, HistogramOpts, HistogramVec, MetricsRegistry, Opts, PrometheusError, Registry,
+        Collector, Counter, CounterVec, Gauge, GaugeVec, Histogram, HistogramOpts, HistogramVec,
+        MetricsRegistry, Opts, PrometheusError, Registry, stopwatch::StopwatchMetrics, subgraph::*,
     };
-    pub use crate::components::server::index_node::IndexNodeServer;
-    pub use crate::components::server::query::GraphQLServer;
-    pub use crate::components::server::subscription::SubscriptionServer;
     pub use crate::components::store::{
-        write::EntityModification, AttributeNames, BlockNumber, CachedEthereumCall, ChainStore,
-        Child, ChildMultiplicity, EntityCache, EntityChange, EntityChangeOperation,
-        EntityCollection, EntityFilter, EntityLink, EntityOperation, EntityOrder,
-        EntityOrderByChild, EntityOrderByChildInfo, EntityQuery, EntityRange, EntityWindow,
-        EthereumCallCache, ParentLink, PartialBlockPtr, PoolWaitStats, QueryStore,
-        QueryStoreManager, StoreError, StoreEvent, StoreEventStream, StoreEventStreamBox,
-        SubgraphStore, UnfailOutcome, WindowAttribute, BLOCK_NUMBER_MAX,
+        AssignmentChange, AssignmentOperation, AttributeNames, BLOCK_NUMBER_MAX, BlockNumber,
+        CachedEthereumCall, ChainStore, Child, ChildMultiplicity, EntityCache, EntityCollection,
+        EntityFilter, EntityLink, EntityOperation, EntityOrder, EntityOrderByChild,
+        EntityOrderByChildInfo, EntityQuery, EntityRange, EntityWindow, EthereumCallCache,
+        ParentLink, PartialBlockPtr, PoolWaitStats, QueryStore, QueryStoreManager, SeqGenerator,
+        StaleCallCacheResult, StoreError, StoreEvent, StoreEventStreamBox, SubgraphStore,
+        UnfailOutcome, WindowAttribute, write::EntityModification,
     };
     pub use crate::components::subgraph::{
-        BlockState, DataSourceTemplateInfo, HostMetrics, RuntimeHost, RuntimeHostBuilder,
-        SubgraphAssignmentProvider, SubgraphInstanceManager, SubgraphRegistrar,
+        BlockState, BlockStateCheckpoint, HostMetrics, InstanceDSTemplateInfo, RuntimeHost,
+        RuntimeHostBuilder, SubgraphInstanceManager, SubgraphRegistrar,
         SubgraphVersionSwitchingMode,
     };
     pub use crate::components::trigger_processor::TriggerProcessor;
     pub use crate::components::versions::{ApiVersion, FeatureFlag};
-    pub use crate::components::{transaction_receipt, EventConsumer, EventProducer};
+    pub use crate::components::{EventConsumer, EventProducer, transaction_receipt};
     pub use crate::env::ENV_VARS;
 
     pub use crate::cheap_clone::CheapClone;
     pub use crate::data::graphql::{
-        shape_hash::shape_hash, SerializableValue, TryFromValue, ValueMap,
+        SerializableValue, TryFromValue, ValueMap, shape_hash::shape_hash,
     };
     pub use crate::data::query::{
         Query, QueryError, QueryExecutionError, QueryResult, QueryTarget, QueryVariables,
     };
-    pub use crate::data::store::ethereum::*;
     pub use crate::data::store::scalar::{BigDecimal, BigInt, BigIntSign};
-    pub use crate::data::store::{
-        AssignmentEvent, Attribute, Entity, NodeId, SubscriptionFilter, Value, ValueType,
-    };
+    pub use crate::data::store::{Attribute, Entity, NodeId, Value, ValueType};
     pub use crate::data::subgraph::schema::SubgraphDeploymentEntity;
     pub use crate::data::subgraph::{
         CreateSubgraphResult, DataSourceContext, DeploymentHash, DeploymentState, Link,
@@ -164,50 +158,53 @@ pub mod prelude {
         SubgraphManifestValidationError, SubgraphName, SubgraphRegistrarError,
         UnvalidatedSubgraphManifest,
     };
-    pub use crate::data::subscription::{
-        QueryResultStream, Subscription, SubscriptionError, SubscriptionResult,
-    };
+    pub use crate::data_source::DataSourceTemplateInfo;
     pub use crate::ext::futures::{
         CancelGuard, CancelHandle, CancelToken, CancelableError, FutureExtension,
         SharedCancelGuard, StreamExtension,
     };
     pub use crate::impl_slog_value;
     pub use crate::log::codes::LogCode;
-    pub use crate::log::elastic::{elastic_logger, ElasticDrainConfig, ElasticLoggingConfig};
+    pub use crate::log::elastic::{ElasticDrainConfig, ElasticLoggingConfig, elastic_logger};
     pub use crate::log::factory::{
         ComponentLoggerConfig, ElasticComponentLoggerConfig, LoggerFactory,
     };
     pub use crate::log::split::split_logger;
     pub use crate::util::cache_weight::CacheWeight;
-    pub use crate::util::futures::{retry, TimeoutError};
-    pub use crate::util::stats::MovingStats;
+    pub use crate::util::futures::{TimeoutError, retry};
+    pub use crate::util::stats::{AtomicMovingStats, MovingStats};
+    pub use crate::util::test_utils::*;
 
     macro_rules! static_graphql {
         ($m:ident, $m2:ident, {$($n:ident,)*}) => {
-            pub mod $m {
-                use graphql_parser::$m2 as $m;
+                use graphql_tools::parser::$m2 as $m;
+                pub use graphql_tools::parser::Pos;
                 pub use $m::*;
                 $(
                     pub type $n = $m::$n<'static, String>;
                 )*
-            }
         };
     }
 
     // Static graphql mods. These are to be phased out, with a preference
     // toward making graphql generic over text. This helps to ease the
     // transition by providing the old graphql-parse 0.2.x API
-    static_graphql!(q, query, {
-        Document, Value, OperationDefinition, InlineFragment, TypeCondition,
-        FragmentSpread, Field, Selection, SelectionSet, FragmentDefinition,
-        Directive, VariableDefinition, Type, Query,
-    });
-    static_graphql!(s, schema, {
-        Field, Directive, InterfaceType, ObjectType, Value, TypeDefinition,
-        EnumType, Type, Definition, Document, ScalarType, InputValue, DirectiveDefinition,
-        UnionType, InputObjectType, EnumValue,
-    });
-
+    pub mod q {
+        static_graphql!(q, query, {
+            Document, Value, OperationDefinition, InlineFragment, TypeCondition,
+            FragmentSpread, Field, Selection, SelectionSet, FragmentDefinition,
+            Directive, VariableDefinition, Type, Query,
+        });
+        pub use q::parse_query;
+    }
+    pub mod s {
+        static_graphql!(s, schema, {
+            Field, Directive, InterfaceType, ObjectType, Value, TypeDefinition,
+            EnumType, Type, Definition, Document, ScalarType, InputValue, DirectiveDefinition,
+            UnionType, InputObjectType, EnumValue,
+        });
+        pub use s::parse_schema;
+    }
     pub mod r {
         pub use crate::data::value::{Object, Value};
     }
diff --git a/graph/src/log/common.rs b/graph/src/log/common.rs
new file mode 100644
index 00000000000..b75bf4c25bb
--- /dev/null
+++ b/graph/src/log/common.rs
@@ -0,0 +1,234 @@
+use std::collections::HashMap;
+use std::fmt;
+
+use serde::Serialize;
+use serde::ser::Serializer as SerdeSerializer;
+use slog::*;
+
+/// Serializer for concatenating key-value arguments into a string
+pub struct SimpleKVSerializer {
+    kvs: Vec<(String, String)>,
+}
+
+impl Default for SimpleKVSerializer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SimpleKVSerializer {
+    pub fn new() -> Self {
+        Self { kvs: Vec::new() }
+    }
+
+    /// Returns the number of key-value pairs and the concatenated string
+    pub fn finish(self) -> (usize, String) {
+        (
+            self.kvs.len(),
+            self.kvs
+                .iter()
+                .map(|(k, v)| format!("{}: {}", k, v))
+                .collect::<Vec<_>>()
+                .join(", "),
+        )
+    }
+}
+
+impl Serializer for SimpleKVSerializer {
+    fn emit_arguments(&mut self, key: Key, val: &fmt::Arguments) -> slog::Result {
+        self.kvs.push((key.into(), val.to_string()));
+        Ok(())
+    }
+}
+
+/// Serializer for extracting key-value pairs into a Vec
+pub struct VecKVSerializer {
+    kvs: Vec<(String, String)>,
+}
+
+impl Default for VecKVSerializer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl VecKVSerializer {
+    pub fn new() -> Self {
+        Self { kvs: Vec::new() }
+    }
+
+    pub fn finish(self) -> Vec<(String, String)> {
+        self.kvs
+    }
+}
+
+impl Serializer for VecKVSerializer {
+    fn emit_arguments(&mut self, key: Key, val: &fmt::Arguments) -> slog::Result {
+        self.kvs.push((key.into(), val.to_string()));
+        Ok(())
+    }
+}
+
+/// Serializer for extracting key-value pairs into a HashMap
+pub struct HashMapKVSerializer {
+    kvs: Vec<(String, String)>,
+}
+
+impl Default for HashMapKVSerializer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl HashMapKVSerializer {
+    pub fn new() -> Self {
+        HashMapKVSerializer { kvs: Vec::new() }
+    }
+
+    pub fn finish(self) -> HashMap<String, String> {
+        self.kvs.into_iter().collect()
+    }
+}
+
+impl Serializer for HashMapKVSerializer {
+    fn emit_arguments(&mut self, key: Key, val: &fmt::Arguments) -> slog::Result {
+        self.kvs.push((key.into(), val.to_string()));
+        Ok(())
+    }
+}
+
+/// Log metadata structure
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LogMeta {
+    pub module: String,
+    pub line: i64,
+    pub column: i64,
+}
+
+/// Serializes an slog Level as a lowercase string
+pub fn serialize_log_level<S>(level: &Level, serializer: S) -> std::result::Result<S::Ok, S::Error>
+where
+    S: SerdeSerializer,
+{
+    serializer.serialize_str(&level.as_str().to_ascii_lowercase())
+}
+
+/// Builder for common log entry fields across different drain implementations
+pub struct LogEntryBuilder<'a> {
+    record: &'a Record<'a>,
+    values: &'a OwnedKVList,
+    subgraph_id: String,
+    timestamp: String,
+}
+
+impl<'a> LogEntryBuilder<'a> {
+    pub fn new(
+        record: &'a Record<'a>,
+        values: &'a OwnedKVList,
+        subgraph_id: String,
+        timestamp: String,
+    ) -> Self {
+        Self {
+            record,
+            values,
+            subgraph_id,
+            timestamp,
+        }
+    }
+
+    /// Builds the log ID in the format: subgraph_id-timestamp
+    pub fn build_id(&self) -> String {
+        format!("{}-{}", self.subgraph_id, self.timestamp)
+    }
+
+    /// Builds the text field by concatenating the message with all key-value pairs
+    pub fn build_text(&self) -> String {
+        // Serialize logger arguments
+        let mut serializer = SimpleKVSerializer::new();
+        self.record
+            .kv()
+            .serialize(self.record, &mut serializer)
+            .expect("failed to serialize logger arguments");
+        let (n_logger_kvs, logger_kvs) = serializer.finish();
+
+        // Serialize log message arguments
+        let mut serializer = SimpleKVSerializer::new();
+        self.values
+            .serialize(self.record, &mut serializer)
+            .expect("failed to serialize log message arguments");
+        let (n_value_kvs, value_kvs) = serializer.finish();
+
+        // Build text with all key-value pairs
+        let mut text = format!("{}", self.record.msg());
+        if n_logger_kvs > 0 {
+            use std::fmt::Write;
+            write!(text, ", {}", logger_kvs).unwrap();
+        }
+        if n_value_kvs > 0 {
+            use std::fmt::Write;
+            write!(text, ", {}", value_kvs).unwrap();
+        }
+
+        text
+    }
+
+    /// Builds arguments as a Vec of tuples (for file drain)
+    pub fn build_arguments_vec(&self) -> Vec<(String, String)> {
+        let mut serializer = VecKVSerializer::new();
+        self.record
+            .kv()
+            .serialize(self.record, &mut serializer)
+            .expect("failed to serialize log message arguments into vec");
+        serializer.finish()
+    }
+
+    /// Builds arguments as a HashMap (for elastic and loki drains)
+    pub fn build_arguments_map(&self) -> HashMap<String, String> {
+        let mut serializer = HashMapKVSerializer::new();
+        self.record
+            .kv()
+            .serialize(self.record, &mut serializer)
+            .expect("failed to serialize log message arguments into hash map");
+        serializer.finish()
+    }
+
+    /// Builds metadata from the log record
+    pub fn build_meta(&self) -> LogMeta {
+        LogMeta {
+            module: self.record.module().into(),
+            line: self.record.line() as i64,
+            column: self.record.column() as i64,
+        }
+    }
+
+    /// Gets the log level
+    pub fn level(&self) -> Level {
+        self.record.level()
+    }
+
+    /// Gets the timestamp
+    pub fn timestamp(&self) -> &str {
+        &self.timestamp
+    }
+
+    /// Gets the subgraph ID
+    pub fn subgraph_id(&self) -> &str {
+        &self.subgraph_id
+    }
+}
+
+/// Creates a new asynchronous logger with consistent configuration
+pub fn create_async_logger<D>(drain: D, chan_size: usize, use_block_overflow: bool) -> Logger
+where
+    D: Drain + Send + 'static,
+    D::Err: std::fmt::Debug,
+{
+    let mut builder = slog_async::Async::new(drain.fuse()).chan_size(chan_size);
+
+    if use_block_overflow {
+        builder = builder.overflow_strategy(slog_async::OverflowStrategy::Block);
+    }
+
+    Logger::root(builder.build().fuse(), o!())
+}
diff --git a/graph/src/log/elastic.rs b/graph/src/log/elastic.rs
index 777fbb0a84d..df8d65af037 100644
--- a/graph/src/log/elastic.rs
+++ b/graph/src/log/elastic.rs
@@ -1,6 +1,4 @@
 use std::collections::HashMap;
-use std::fmt;
-use std::fmt::Write;
 use std::result::Result;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
@@ -11,14 +9,14 @@ use http::header::CONTENT_TYPE;
 use prometheus::Counter;
 use reqwest;
 use reqwest::Client;
-use serde::ser::Serializer as SerdeSerializer;
 use serde::Serialize;
 use serde_json::json;
 use slog::*;
-use slog_async;
 
 use crate::util::futures::retry;
 
+use super::common::{LogEntryBuilder, LogMeta, create_async_logger};
+
 /// General configuration parameters for Elasticsearch logging.
 #[derive(Clone, Debug)]
 pub struct ElasticLoggingConfig {
@@ -32,29 +30,7 @@ pub struct ElasticLoggingConfig {
     pub client: Client,
 }
 
-/// Serializes an slog log level using a serde Serializer.
-fn serialize_log_level<S>(level: &Level, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: SerdeSerializer,
-{
-    serializer.serialize_str(match level {
-        Level::Critical => "critical",
-        Level::Error => "error",
-        Level::Warning => "warning",
-        Level::Info => "info",
-        Level::Debug => "debug",
-        Level::Trace => "trace",
-    })
-}
-
-// Log message meta data.
-#[derive(Clone, Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-struct ElasticLogMeta {
-    module: String,
-    line: i64,
-    column: i64,
-}
+type ElasticLogMeta = LogMeta;
 
 // Log message to be written to Elasticsearch.
 #[derive(Clone, Debug, Serialize)]
@@ -66,72 +42,11 @@ struct ElasticLog {
     arguments: HashMap<String, String>,
     timestamp: String,
     text: String,
-    #[serde(serialize_with = "serialize_log_level")]
+    #[serde(serialize_with = "super::common::serialize_log_level")]
     level: Level,
     meta: ElasticLogMeta,
 }
 
-struct HashMapKVSerializer {
-    kvs: Vec<(String, String)>,
-}
-
-impl HashMapKVSerializer {
-    fn new() -> Self {
-        HashMapKVSerializer {
-            kvs: Default::default(),
-        }
-    }
-
-    fn finish(self) -> HashMap<String, String> {
-        let mut map = HashMap::new();
-        self.kvs.into_iter().for_each(|(k, v)| {
-            map.insert(k, v);
-        });
-        map
-    }
-}
-
-impl Serializer for HashMapKVSerializer {
-    fn emit_arguments(&mut self, key: Key, val: &fmt::Arguments) -> slog::Result {
-        self.kvs.push((key.into(), format!("{}", val)));
-        Ok(())
-    }
-}
-
-/// A super-simple slog Serializer for concatenating key/value arguments.
-struct SimpleKVSerializer {
-    kvs: Vec<(String, String)>,
-}
-
-impl SimpleKVSerializer {
-    /// Creates a new `SimpleKVSerializer`.
-    fn new() -> Self {
-        SimpleKVSerializer {
-            kvs: Default::default(),
-        }
-    }
-
-    /// Collects all key/value arguments into a single, comma-separated string.
-    /// Returns the number of key/value pairs and the string itself.
-    fn finish(self) -> (usize, String) {
-        (
-            self.kvs.len(),
-            self.kvs
-                .iter()
-                .map(|(k, v)| format!("{}: {}", k, v))
-                .collect::<Vec<_>>()
-                .join(", "),
-        )
-    }
-}
-
-impl Serializer for SimpleKVSerializer {
-    fn emit_arguments(&mut self, key: Key, val: &fmt::Arguments) -> slog::Result {
-        self.kvs.push((key.into(), format!("{}", val)));
-        Ok(())
-    }
-}
-
 /// Configuration for `ElasticDrain`.
 #[derive(Clone, Debug)]
 pub struct ElasticDrainConfig {
@@ -202,7 +117,7 @@ impl ElasticDrain {
         let mut interval = tokio::time::interval(self.config.flush_interval);
         let max_retries = self.config.max_retries;
 
-        crate::task_spawn::spawn(async move {
+        crate::tokio::spawn(async move {
             loop {
                 interval.tick().await;
 
@@ -309,43 +224,18 @@ impl Drain for ElasticDrain {
     type Err = ();
 
     fn log(&self, record: &Record, values: &OwnedKVList) -> Result<Self::Ok, Self::Err> {
-        // Don't sent `trace` logs to ElasticSearch.
+        // Don't send `trace` logs to ElasticSearch.
         if record.level() == Level::Trace {
             return Ok(());
         }
-        let timestamp = Utc::now().to_rfc3339_opts(SecondsFormat::Nanos, true);
-        let id = format!("{}-{}", self.config.custom_id_value, timestamp);
-
-        // Serialize logger arguments
-        let mut serializer = SimpleKVSerializer::new();
-        record
-            .kv()
-            .serialize(record, &mut serializer)
-            .expect("failed to serializer logger arguments");
-        let (n_logger_kvs, logger_kvs) = serializer.finish();
-
-        // Serialize log message arguments
-        let mut serializer = SimpleKVSerializer::new();
-        values
-            .serialize(record, &mut serializer)
-            .expect("failed to serialize log message arguments");
-        let (n_value_kvs, value_kvs) = serializer.finish();
-
-        // Serialize log message arguments into hash map
-        let mut serializer = HashMapKVSerializer::new();
-        record
-            .kv()
-            .serialize(record, &mut serializer)
-            .expect("failed to serialize log message arguments into hash map");
-        let arguments = serializer.finish();
 
-        let mut text = format!("{}", record.msg());
-        if n_logger_kvs > 0 {
-            write!(text, ", {}", logger_kvs).unwrap();
-        }
-        if n_value_kvs > 0 {
-            write!(text, ", {}", value_kvs).unwrap();
-        }
+        let timestamp = Utc::now().to_rfc3339_opts(SecondsFormat::Nanos, true);
+        let builder = LogEntryBuilder::new(
+            record,
+            values,
+            self.config.custom_id_value.clone(),
+            timestamp.clone(),
+        );
 
         // Prepare custom id for log document
         let mut custom_id = HashMap::new();
@@ -356,17 +246,13 @@ impl Drain for ElasticDrain {
 
         // Prepare log document
         let log = ElasticLog {
-            id,
+            id: builder.build_id(),
             custom_id,
-            arguments,
+            arguments: builder.build_arguments_map(),
             timestamp,
-            text,
-            level: record.level(),
-            meta: ElasticLogMeta {
-                module: record.module().into(),
-                line: record.line() as i64,
-                column: record.column() as i64,
-            },
+            text: builder.build_text(),
+            level: builder.level(),
+            meta: builder.build_meta(),
         };
 
         // Push the log into the queue
@@ -386,10 +272,6 @@ pub fn elastic_logger(
     error_logger: Logger,
     logs_sent_counter: Counter,
 ) -> Logger {
-    let elastic_drain = ElasticDrain::new(config, error_logger, logs_sent_counter).fuse();
-    let async_drain = slog_async::Async::new(elastic_drain)
-        .chan_size(20000)
-        .build()
-        .fuse();
-    Logger::root(async_drain, o!())
+    let elastic_drain = ElasticDrain::new(config, error_logger, logs_sent_counter);
+    create_async_logger(elastic_drain, 20000, false)
 }
diff --git a/graph/src/log/factory.rs b/graph/src/log/factory.rs
index 52269f1a7ed..6b1132364f0 100644
--- a/graph/src/log/factory.rs
+++ b/graph/src/log/factory.rs
@@ -1,11 +1,15 @@
 use std::sync::Arc;
+use std::time::Duration;
 
 use prometheus::Counter;
 use slog::*;
 
+use crate::components::log_store::LogStoreConfig;
 use crate::components::metrics::MetricsRegistry;
 use crate::components::store::DeploymentLocator;
 use crate::log::elastic::*;
+use crate::log::file::{FileDrainConfig, file_logger};
+use crate::log::loki::{LokiDrainConfig, loki_logger};
 use crate::log::split::*;
 use crate::prelude::ENV_VARS;
 
@@ -23,20 +27,20 @@ pub struct ComponentLoggerConfig {
 #[derive(Clone)]
 pub struct LoggerFactory {
     parent: Logger,
-    elastic_config: Option<ElasticLoggingConfig>,
+    log_store_config: Option<LogStoreConfig>,
     metrics_registry: Arc<MetricsRegistry>,
 }
 
 impl LoggerFactory {
-    /// Creates a new factory using a parent logger and optional Elasticsearch configuration.
+    /// Creates a new factory using a parent logger and optional log store configuration.
     pub fn new(
         logger: Logger,
-        elastic_config: Option<ElasticLoggingConfig>,
+        log_store_config: Option<LogStoreConfig>,
         metrics_registry: Arc<MetricsRegistry>,
     ) -> Self {
         Self {
             parent: logger,
-            elastic_config,
+            log_store_config,
             metrics_registry,
         }
     }
@@ -45,7 +49,7 @@ impl LoggerFactory {
     pub fn with_parent(&self, parent: Logger) -> Self {
         Self {
             parent,
-            elastic_config: self.elastic_config.clone(),
+            log_store_config: self.log_store_config.clone(),
             metrics_registry: self.metrics_registry.clone(),
         }
     }
@@ -62,56 +66,129 @@ impl LoggerFactory {
             None => term_logger,
             Some(config) => match config.elastic {
                 None => term_logger,
-                Some(config) => self
-                    .elastic_config
-                    .clone()
-                    .map(|elastic_config| {
-                        split_logger(
-                            term_logger.clone(),
-                            elastic_logger(
-                                ElasticDrainConfig {
-                                    general: elastic_config,
-                                    index: config.index,
-                                    custom_id_key: String::from("componentId"),
-                                    custom_id_value: component.to_string(),
-                                    flush_interval: ENV_VARS.elastic_search_flush_interval,
-                                    max_retries: ENV_VARS.elastic_search_max_retries,
-                                },
+                Some(elastic_component_config) => {
+                    // Check if we have Elasticsearch configured in log_store_config
+                    match &self.log_store_config {
+                        Some(LogStoreConfig::Elasticsearch {
+                            endpoint,
+                            username,
+                            password,
+                            ..
+                        }) => {
+                            // Build ElasticLoggingConfig on-demand
+                            let elastic_config = ElasticLoggingConfig {
+                                endpoint: endpoint.clone(),
+                                username: username.clone(),
+                                password: password.clone(),
+                                client: reqwest::Client::new(),
+                            };
+
+                            split_logger(
                                 term_logger.clone(),
-                                self.logs_sent_counter(None),
-                            ),
-                        )
-                    })
-                    .unwrap_or(term_logger),
+                                elastic_logger(
+                                    ElasticDrainConfig {
+                                        general: elastic_config,
+                                        index: elastic_component_config.index,
+                                        custom_id_key: String::from("componentId"),
+                                        custom_id_value: component.to_string(),
+                                        flush_interval: ENV_VARS.elastic_search_flush_interval,
+                                        max_retries: ENV_VARS.elastic_search_max_retries,
+                                    },
+                                    term_logger.clone(),
+                                    self.logs_sent_counter(None),
+                                ),
+                            )
+                        }
+                        _ => {
+                            // No Elasticsearch configured, just use terminal logger
+                            term_logger
+                        }
+                    }
+                }
             },
         }
     }
 
-    /// Creates a subgraph logger with Elasticsearch support.
+    /// Creates a subgraph logger with multi-backend support.
     pub fn subgraph_logger(&self, loc: &DeploymentLocator) -> Logger {
         let term_logger = self
             .parent
             .new(o!("subgraph_id" => loc.hash.to_string(), "sgd" => loc.id.to_string()));
 
-        self.elastic_config
-            .clone()
-            .map(|elastic_config| {
-                split_logger(
+        // Determine which drain to use based on log_store_config
+        let drain = match &self.log_store_config {
+            Some(LogStoreConfig::Elasticsearch {
+                endpoint,
+                username,
+                password,
+                index,
+                ..
+            }) => {
+                // Build ElasticLoggingConfig on-demand
+                let elastic_config = ElasticLoggingConfig {
+                    endpoint: endpoint.clone(),
+                    username: username.clone(),
+                    password: password.clone(),
+                    client: reqwest::Client::new(),
+                };
+
+                Some(elastic_logger(
+                    ElasticDrainConfig {
+                        general: elastic_config,
+                        index: index.clone(),
+                        custom_id_key: String::from("subgraphId"),
+                        custom_id_value: loc.hash.to_string(),
+                        flush_interval: ENV_VARS.elastic_search_flush_interval,
+                        max_retries: ENV_VARS.elastic_search_max_retries,
+                    },
+                    term_logger.clone(),
+                    self.logs_sent_counter(Some(loc.hash.as_str())),
+                ))
+            }
+
+            None => None,
+
+            Some(LogStoreConfig::Loki {
+                endpoint,
+                tenant_id,
+                username,
+                password,
+            }) => {
+                // Use Loki
+                Some(loki_logger(
+                    LokiDrainConfig {
+                        endpoint: endpoint.clone(),
+                        tenant_id: tenant_id.clone(),
+                        username: username.clone(),
+                        password: password.clone(),
+                        flush_interval: Duration::from_secs(5),
+                        subgraph_id: loc.hash.to_string(),
+                    },
                     term_logger.clone(),
-                    elastic_logger(
-                        ElasticDrainConfig {
-                            general: elastic_config,
-                            index: String::from("subgraph-logs"),
-                            custom_id_key: String::from("subgraphId"),
-                            custom_id_value: loc.hash.to_string(),
-                            flush_interval: ENV_VARS.elastic_search_flush_interval,
-                            max_retries: ENV_VARS.elastic_search_max_retries,
-                        },
-                        term_logger.clone(),
-                        self.logs_sent_counter(Some(loc.hash.as_str())),
-                    ),
-                )
-            })
+                ))
+            }
+
+            Some(LogStoreConfig::File {
+                directory,
+                retention_hours: _,
+            }) => {
+                // Use File
+                // Note: Cleanup is handled by FileLogStore on startup based on retention_hours
+                Some(file_logger(
+                    FileDrainConfig {
+                        directory: directory.clone(),
+                        subgraph_id: loc.hash.to_string(),
+                    },
+                    term_logger.clone(),
+                ))
+            }
+
+            Some(LogStoreConfig::Disabled) => None,
+        };
+
+        // Combine terminal and storage drain
+        drain
+            .map(|storage_drain| split_logger(term_logger.clone(), storage_drain))
             .unwrap_or(term_logger)
     }
 
diff --git a/graph/src/log/file.rs b/graph/src/log/file.rs
new file mode 100644
index 00000000000..0fed5ce732a
--- /dev/null
+++ b/graph/src/log/file.rs
@@ -0,0 +1,224 @@
+use std::fs::{File, OpenOptions};
+use std::io::{BufWriter, Write};
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+
+use chrono::prelude::{SecondsFormat, Utc};
+use serde::Serialize;
+use slog::*;
+
+use super::common::{LogEntryBuilder, LogMeta, create_async_logger};
+
+/// Configuration for `FileDrain`.
+#[derive(Clone, Debug)]
+pub struct FileDrainConfig {
+    /// Directory where log files will be stored
+    pub directory: PathBuf,
+    /// The subgraph ID used for the log filename
+    pub subgraph_id: String,
+}
+
+/// Log document structure for JSON Lines format
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct FileLogDocument {
+    id: String,
+    subgraph_id: String,
+    timestamp: String,
+    #[serde(serialize_with = "super::common::serialize_log_level")]
+    level: Level,
+    text: String,
+    arguments: Vec<(String, String)>,
+    meta: FileLogMeta,
+}
+
+type FileLogMeta = LogMeta;
+
+/// An slog `Drain` for logging to local files in JSON Lines format.
+///
+/// Each subgraph gets its own .jsonl file with log entries.
+/// Format: One JSON object per line
+/// ```jsonl
+/// {"id":"QmXxx-2024-01-15T10:30:00Z","subgraphId":"QmXxx","timestamp":"2024-01-15T10:30:00Z","level":"error","text":"Error message","arguments":[],"meta":{"module":"test.rs","line":42,"column":10}}
+/// ```
+pub struct FileDrain {
+    config: FileDrainConfig,
+    error_logger: Logger,
+    writer: Arc<Mutex<BufWriter<File>>>,
+}
+
+impl FileDrain {
+    /// Creates a new `FileDrain`.
+    pub fn new(config: FileDrainConfig, error_logger: Logger) -> std::io::Result<Self> {
+        std::fs::create_dir_all(&config.directory)?;
+
+        let path = config
+            .directory
+            .join(format!("{}.jsonl", config.subgraph_id));
+        let file = OpenOptions::new().create(true).append(true).open(path)?;
+
+        Ok(FileDrain {
+            config,
+            error_logger,
+            writer: Arc::new(Mutex::new(BufWriter::new(file))),
+        })
+    }
+}
+
+impl Drain for FileDrain {
+    type Ok = ();
+    type Err = Never;
+
+    fn log(&self, record: &Record, values: &OwnedKVList) -> std::result::Result<(), Never> {
+        // Don't write `trace` logs to file
+        if record.level() == Level::Trace {
+            return Ok(());
+        }
+
+        let timestamp = Utc::now().to_rfc3339_opts(SecondsFormat::Nanos, true);
+        let builder =
+            LogEntryBuilder::new(record, values, self.config.subgraph_id.clone(), timestamp);
+
+        // Build log document
+        let log_doc = FileLogDocument {
+            id: builder.build_id(),
+            subgraph_id: builder.subgraph_id().to_string(),
+            timestamp: builder.timestamp().to_string(),
+            level: builder.level(),
+            text: builder.build_text(),
+            arguments: builder.build_arguments_vec(),
+            meta: builder.build_meta(),
+        };
+
+        // Write JSON line (synchronous, buffered)
+        let mut writer = self.writer.lock().unwrap();
+        if let Err(e) = serde_json::to_writer(&mut *writer, &log_doc) {
+            error!(self.error_logger, "Failed to serialize log to JSON: {}", e);
+            return Ok(());
+        }
+
+        if let Err(e) = writeln!(&mut *writer) {
+            error!(self.error_logger, "Failed to write newline: {}", e);
+            return Ok(());
+        }
+
+        // Flush to ensure durability
+        if let Err(e) = writer.flush() {
+            error!(self.error_logger, "Failed to flush log file: {}", e);
+        }
+
+        Ok(())
+    }
+}
+
+/// Creates a new asynchronous file logger.
+///
+/// Uses `error_logger` to print any file logging errors,
+/// so they don't go unnoticed.
+pub fn file_logger(config: FileDrainConfig, error_logger: Logger) -> Logger {
+    let file_drain = match FileDrain::new(config, error_logger.clone()) {
+        Ok(drain) => drain,
+        Err(e) => {
+            error!(error_logger, "Failed to create FileDrain: {}", e);
+            // Return a logger that discards all logs
+            return Logger::root(slog::Discard, o!());
+        }
+    };
+
+    create_async_logger(file_drain, 20000, true)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_file_drain_creation() {
+        let temp_dir = TempDir::new().unwrap();
+        let error_logger = Logger::root(slog::Discard, o!());
+
+        let config = FileDrainConfig {
+            directory: temp_dir.path().to_path_buf(),
+            subgraph_id: "QmTest".to_string(),
+        };
+
+        let drain = FileDrain::new(config, error_logger);
+        assert!(drain.is_ok());
+
+        // Verify file was created
+        let file_path = temp_dir.path().join("QmTest.jsonl");
+        assert!(file_path.exists());
+    }
+
+    #[test]
+    fn test_log_entry_format() {
+        let arguments = vec![
+            ("key1".to_string(), "value1".to_string()),
+            ("key2".to_string(), "value2".to_string()),
+        ];
+
+        let doc = FileLogDocument {
+            id: "test-id".to_string(),
+            subgraph_id: "QmTest".to_string(),
+            timestamp: "2024-01-15T10:30:00Z".to_string(),
+            level: Level::Error,
+            text: "Test error message".to_string(),
+            arguments,
+            meta: FileLogMeta {
+                module: "test.rs".to_string(),
+                line: 42,
+                column: 10,
+            },
+        };
+
+        let json = serde_json::to_string(&doc).unwrap();
+        assert!(json.contains("\"id\":\"test-id\""));
+        assert!(json.contains("\"subgraphId\":\"QmTest\""));
+        assert!(json.contains("\"level\":\"error\""));
+        assert!(json.contains("\"text\":\"Test error message\""));
+        assert!(json.contains("\"arguments\""));
+    }
+
+    #[test]
+    fn test_file_drain_writes_jsonl() {
+        use std::io::{BufRead, BufReader};
+
+        let temp_dir = TempDir::new().unwrap();
+        let error_logger = Logger::root(slog::Discard, o!());
+
+        let config = FileDrainConfig {
+            directory: temp_dir.path().to_path_buf(),
+            subgraph_id: "QmTest".to_string(),
+        };
+
+        let drain = FileDrain::new(config.clone(), error_logger).unwrap();
+
+        // Create a test record
+        let logger = Logger::root(drain, o!());
+        info!(logger, "Test message"; "key" => "value");
+
+        // Give async drain time to write (in real test we'd use proper sync)
+        std::thread::sleep(std::time::Duration::from_millis(100));
+
+        // Read the file
+        let file_path = temp_dir.path().join("QmTest.jsonl");
+        let file = File::open(file_path).unwrap();
+        let reader = BufReader::new(file);
+
+        let lines: Vec<String> = reader.lines().map_while(|r| r.ok()).collect();
+
+        // Should have written at least one line
+        assert!(!lines.is_empty());
+
+        // Each line should be valid JSON
+        for line in lines {
+            let parsed: serde_json::Value = serde_json::from_str(&line).unwrap();
+            assert!(parsed.get("id").is_some());
+            assert!(parsed.get("subgraphId").is_some());
+            assert!(parsed.get("timestamp").is_some());
+            assert!(parsed.get("level").is_some());
+            assert!(parsed.get("text").is_some());
+        }
+    }
+}
diff --git a/graph/src/log/loki.rs b/graph/src/log/loki.rs
new file mode 100644
index 00000000000..c779e568dfb
--- /dev/null
+++ b/graph/src/log/loki.rs
@@ -0,0 +1,335 @@
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use chrono::prelude::{SecondsFormat, Utc};
+use reqwest::Client;
+use serde::Serialize;
+use serde_json::json;
+use slog::*;
+
+use super::common::{LogEntryBuilder, LogMeta, create_async_logger};
+
+/// Configuration for `LokiDrain`.
+#[derive(Clone, Debug)]
+pub struct LokiDrainConfig {
+    pub endpoint: String,
+    pub tenant_id: Option<String>,
+    pub username: Option<String>,
+    pub password: Option<String>,
+    pub flush_interval: Duration,
+    pub subgraph_id: String,
+}
+
+/// A log entry to be sent to Loki
+#[derive(Clone, Debug)]
+struct LokiLogEntry {
+    timestamp_ns: String,            // Nanoseconds since epoch as string
+    line: String,                    // JSON-serialized log entry
+    labels: HashMap<String, String>, // Stream labels (subgraphId, level, etc.)
+}
+
+/// Log document structure for JSON serialization
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct LokiLogDocument {
+    id: String,
+    subgraph_id: String,
+    timestamp: String,
+    #[serde(serialize_with = "super::common::serialize_log_level")]
+    level: Level,
+    text: String,
+    arguments: HashMap<String, String>,
+    meta: LokiLogMeta,
+}
+
+type LokiLogMeta = LogMeta;
+
+/// A slog `Drain` for logging to Loki.
+///
+/// Loki expects logs in the following format:
+/// ```json
+/// {
+///   "streams": [
+///     {
+///       "stream": {"subgraphId": "QmXxx", "level": "error"},
+///       "values": [
+///         ["<unix_epoch_nanoseconds>", "<log_line_json>"],
+///         ["<unix_epoch_nanoseconds>", "<log_line_json>"]
+///       ]
+///     }
+///   ]
+/// }
+/// ```
+pub struct LokiDrain {
+    config: LokiDrainConfig,
+    client: Client,
+    error_logger: Logger,
+    logs: Arc<Mutex<Vec<LokiLogEntry>>>,
+}
+
+impl LokiDrain {
+    /// Creates a new `LokiDrain`.
+    pub fn new(config: LokiDrainConfig, error_logger: Logger) -> Self {
+        let client = Client::builder()
+            .timeout(Duration::from_secs(30))
+            .build()
+            .expect("failed to create HTTP client for LokiDrain");
+
+        let drain = LokiDrain {
+            config,
+            client,
+            error_logger,
+            logs: Arc::new(Mutex::new(vec![])),
+        };
+        drain.periodically_flush_logs();
+        drain
+    }
+
+    fn periodically_flush_logs(&self) {
+        let flush_logger = self.error_logger.clone();
+        let logs = self.logs.clone();
+        let config = self.config.clone();
+        let client = self.client.clone();
+        let mut interval = tokio::time::interval(self.config.flush_interval);
+
+        crate::tokio::spawn(async move {
+            loop {
+                interval.tick().await;
+
+                let logs_to_send = {
+                    let mut logs = logs.lock().unwrap();
+                    let logs_to_send = (*logs).clone();
+                    logs.clear();
+                    logs_to_send
+                };
+
+                // Do nothing if there are no logs to flush
+                if logs_to_send.is_empty() {
+                    continue;
+                }
+
+                // Group logs by labels (Loki streams)
+                let streams = group_by_labels(logs_to_send);
+
+                // Build Loki push request body
+                let streams_json: Vec<_> = streams
+                    .into_iter()
+                    .map(|(labels, entries)| {
+                        json!({
+                            "stream": labels,
+                            "values": entries.into_iter()
+                                .map(|e| vec![e.timestamp_ns, e.line])
+                                .collect::<Vec<_>>()
+                        })
+                    })
+                    .collect();
+
+                let body = json!({
+                    "streams": streams_json
+                });
+
+                let url = format!("{}/loki/api/v1/push", config.endpoint);
+
+                let mut request = client
+                    .post(&url)
+                    .json(&body)
+                    .timeout(Duration::from_secs(30));
+
+                if let Some(ref tenant_id) = config.tenant_id {
+                    request = request.header("X-Scope-OrgID", tenant_id);
+                }
+
+                if let Some(ref username) = config.username {
+                    request = request.basic_auth(username, config.password.as_ref());
+                }
+
+                match request.send().await {
+                    Ok(resp) if resp.status().is_success() => {
+                        // Success
+                    }
+                    Ok(resp) => {
+                        error!(
+                            flush_logger,
+                            "Loki push failed with status: {}",
+                            resp.status()
+                        );
+                    }
+                    Err(e) => {
+                        error!(flush_logger, "Failed to send logs to Loki: {}", e);
+                    }
+                }
+            }
+        });
+    }
+}
+
+impl Drain for LokiDrain {
+    type Ok = ();
+    type Err = ();
+
+    fn log(&self, record: &Record, values: &OwnedKVList) -> std::result::Result<(), ()> {
+        // Don't send `trace` logs to Loki
+        if record.level() == Level::Trace {
+            return Ok(());
+        }
+
+        let now = Utc::now();
+        let timestamp = now.to_rfc3339_opts(SecondsFormat::Nanos, true);
+        let timestamp_ns = now.timestamp_nanos_opt().unwrap().to_string();
+
+        let builder = LogEntryBuilder::new(
+            record,
+            values,
+            self.config.subgraph_id.clone(),
+            timestamp.clone(),
+        );
+
+        // Build log document
+        let log_doc = LokiLogDocument {
+            id: builder.build_id(),
+            subgraph_id: builder.subgraph_id().to_string(),
+            timestamp,
+            level: builder.level(),
+            text: builder.build_text(),
+            arguments: builder.build_arguments_map(),
+            meta: builder.build_meta(),
+        };
+
+        // Serialize to JSON line
+        let line = match serde_json::to_string(&log_doc) {
+            Ok(l) => l,
+            Err(e) => {
+                error!(self.error_logger, "Failed to serialize log to JSON: {}", e);
+                return Ok(());
+            }
+        };
+
+        // Build labels for Loki stream
+        let mut labels = HashMap::new();
+        labels.insert("subgraphId".to_string(), builder.subgraph_id().to_string());
+        labels.insert(
+            "level".to_string(),
+            builder.level().as_str().to_ascii_lowercase(),
+        );
+
+        // Create log entry
+        let entry = LokiLogEntry {
+            timestamp_ns,
+            line,
+            labels,
+        };
+
+        // Push to buffer
+        let mut logs = self.logs.lock().unwrap();
+        logs.push(entry);
+
+        Ok(())
+    }
+}
+
+/// Groups log entries by their labels to create Loki streams
+/// Returns a HashMap where the key is the labels and the value is a vec of entries
+fn group_by_labels(
+    entries: Vec<LokiLogEntry>,
+) -> Vec<(HashMap<String, String>, Vec<LokiLogEntry>)> {
+    let mut streams: HashMap<String, (HashMap<String, String>, Vec<LokiLogEntry>)> = HashMap::new();
+    for entry in entries {
+        // Create a deterministic string key from the labels
+        let label_key = serde_json::to_string(&entry.labels).unwrap_or_default();
+
+        streams
+            .entry(label_key)
+            .or_insert_with(|| (entry.labels.clone(), Vec::new()))
+            .1
+            .push(entry);
+    }
+
+    // Convert to a vec of (labels, entries) tuples
+    streams.into_values().collect()
+}
+
+/// Creates a new asynchronous Loki logger.
+///
+/// Uses `error_logger` to print any Loki logging errors,
+/// so they don't go unnoticed.
+pub fn loki_logger(config: LokiDrainConfig, error_logger: Logger) -> Logger {
+    let loki_drain = LokiDrain::new(config, error_logger);
+    create_async_logger(loki_drain, 20000, true)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_group_by_labels() {
+        let mut labels1 = HashMap::new();
+        labels1.insert("subgraphId".to_string(), "QmTest".to_string());
+        labels1.insert("level".to_string(), "error".to_string());
+
+        let mut labels2 = HashMap::new();
+        labels2.insert("subgraphId".to_string(), "QmTest".to_string());
+        labels2.insert("level".to_string(), "info".to_string());
+
+        let entries = vec![
+            LokiLogEntry {
+                timestamp_ns: "1000000000".to_string(),
+                line: "log1".to_string(),
+                labels: labels1.clone(),
+            },
+            LokiLogEntry {
+                timestamp_ns: "2000000000".to_string(),
+                line: "log2".to_string(),
+                labels: labels1.clone(),
+            },
+            LokiLogEntry {
+                timestamp_ns: "3000000000".to_string(),
+                line: "log3".to_string(),
+                labels: labels2.clone(),
+            },
+        ];
+
+        let streams = group_by_labels(entries);
+
+        // Should have 2 streams (one for each unique label set)
+        assert_eq!(streams.len(), 2);
+
+        // Find streams by label and verify counts
+        for (labels, entries) in streams {
+            if labels.get("level") == Some(&"error".to_string()) {
+                assert_eq!(entries.len(), 2, "Error stream should have 2 entries");
+            } else if labels.get("level") == Some(&"info".to_string()) {
+                assert_eq!(entries.len(), 1, "Info stream should have 1 entry");
+            } else {
+                panic!("Unexpected label combination");
+            }
+        }
+    }
+
+    #[test]
+    fn test_loki_log_document_serialization() {
+        let mut arguments = HashMap::new();
+        arguments.insert("key1".to_string(), "value1".to_string());
+
+        let doc = LokiLogDocument {
+            id: "test-id".to_string(),
+            subgraph_id: "QmTest".to_string(),
+            timestamp: "2024-01-15T10:30:00Z".to_string(),
+            level: Level::Error,
+            text: "Test error".to_string(),
+            arguments,
+            meta: LokiLogMeta {
+                module: "test.rs".to_string(),
+                line: 42,
+                column: 10,
+            },
+        };
+
+        let json = serde_json::to_string(&doc).unwrap();
+        assert!(json.contains("\"id\":\"test-id\""));
+        assert!(json.contains("\"subgraphId\":\"QmTest\""));
+        assert!(json.contains("\"level\":\"error\""));
+        assert!(json.contains("\"text\":\"Test error\""));
+    }
+}
diff --git a/graph/src/log/mod.rs b/graph/src/log/mod.rs
index 717c0260aa3..833f984e208 100644
--- a/graph/src/log/mod.rs
+++ b/graph/src/log/mod.rs
@@ -17,18 +17,24 @@ macro_rules! impl_slog_value {
     };
 }
 
-use isatty;
 use slog::*;
 use slog_async;
 use slog_envlogger;
 use slog_term::*;
-use std::{fmt, io, result};
+use std::{
+    fmt,
+    io::{self, IsTerminal},
+    result,
+};
 
 use crate::prelude::ENV_VARS;
 
 pub mod codes;
+pub mod common;
 pub mod elastic;
 pub mod factory;
+pub mod file;
+pub mod loki;
 pub mod split;
 
 pub fn logger(show_debug: bool) -> Logger {
@@ -36,7 +42,7 @@ pub fn logger(show_debug: bool) -> Logger {
 }
 
 pub fn logger_with_levels(show_debug: bool, levels: Option<&str>) -> Logger {
-    let use_color = isatty::stdout_isatty();
+    let use_color = io::stdout().is_terminal();
     let decorator = slog_term::TermDecorator::new().build();
     let drain = CustomFormat::new(decorator, use_color).fuse();
     let drain = slog_envlogger::LogBuilder::new(drain)
@@ -94,6 +100,9 @@ where
 
     fn format_custom(&self, record: &Record, values: &OwnedKVList) -> io::Result<()> {
         self.decorator.with_record(record, values, |mut decorator| {
+            #[cfg(debug_assertions)]
+            write!(decorator, "[DEBUG-BUILD] ")?;
+
             decorator.start_timestamp()?;
             formatted_timestamp_local(&mut decorator)?;
             decorator.start_whitespace()?;
diff --git a/graph/src/runtime/asc_heap.rs b/graph/src/runtime/asc_heap.rs
index bf31f7dc3f2..ecccf546ba3 100644
--- a/graph/src/runtime/asc_heap.rs
+++ b/graph/src/runtime/asc_heap.rs
@@ -1,10 +1,11 @@
 use std::mem::MaybeUninit;
 
+use async_trait::async_trait;
 use semver::Version;
 
 use super::{
-    gas::GasCounter, AscIndexId, AscPtr, AscType, DeterministicHostError, HostExportError,
-    IndexForAscTypeId,
+    AscIndexId, AscPtr, AscType, DeterministicHostError, HostExportError, IndexForAscTypeId,
+    gas::GasCounter,
 };
 
 // A 128 limit is plenty for any subgraph, while the `fn recursion_limit` test ensures it is not
@@ -15,9 +16,14 @@ const MAX_RECURSION_DEPTH: usize = 128;
 /// for reading and writing Rust structs from and to Asc.
 ///
 /// The implementor must provide the direct Asc interface with `raw_new` and `get`.
-pub trait AscHeap {
+#[async_trait]
+pub trait AscHeap: Send {
     /// Allocate new space and write `bytes`, return the allocated address.
-    fn raw_new(&mut self, bytes: &[u8], gas: &GasCounter) -> Result<u32, DeterministicHostError>;
+    async fn raw_new(
+        &mut self,
+        bytes: &[u8],
+        gas: &GasCounter,
+    ) -> Result<u32, DeterministicHostError>;
 
     fn read<'a>(
         &self,
@@ -28,9 +34,12 @@ pub trait AscHeap {
 
     fn read_u32(&self, offset: u32, gas: &GasCounter) -> Result<u32, DeterministicHostError>;
 
-    fn api_version(&self) -> Version;
+    fn api_version(&self) -> &Version;
 
-    fn asc_type_id(&mut self, type_id_index: IndexForAscTypeId) -> Result<u32, HostExportError>;
+    async fn asc_type_id(
+        &mut self,
+        type_id_index: IndexForAscTypeId,
+    ) -> Result<u32, HostExportError>;
 }
 
 /// Instantiate `rust_obj` as an Asc object of class `C`.
@@ -38,21 +47,21 @@ pub trait AscHeap {
 ///
 /// This operation is expensive as it requires a call to `raw_new` for every
 /// nested object.
-pub fn asc_new<C, T: ?Sized, H: AscHeap + ?Sized>(
+pub async fn asc_new<C, T, H: AscHeap + Send + ?Sized>(
     heap: &mut H,
     rust_obj: &T,
     gas: &GasCounter,
 ) -> Result<AscPtr<C>, HostExportError>
 where
     C: AscType + AscIndexId,
-    T: ToAscObj<C>,
+    T: ToAscObj<C> + ?Sized,
 {
-    let obj = rust_obj.to_asc_obj(heap, gas)?;
-    AscPtr::alloc_obj(obj, heap, gas)
+    let obj = rust_obj.to_asc_obj(heap, gas).await?;
+    AscPtr::alloc_obj(obj, heap, gas).await
 }
 
 /// Map an optional object to its Asc equivalent if Some, otherwise return a missing field error.
-pub fn asc_new_or_missing<H, O, A>(
+pub async fn asc_new_or_missing<H, O, A>(
     heap: &mut H,
     object: &Option<O>,
     gas: &GasCounter,
@@ -60,29 +69,29 @@ pub fn asc_new_or_missing<H, O, A>(
     field_name: &str,
 ) -> Result<AscPtr<A>, HostExportError>
 where
-    H: AscHeap + ?Sized,
+    H: AscHeap + Send + ?Sized,
     O: ToAscObj<A>,
     A: AscType + AscIndexId,
 {
     match object {
-        Some(o) => asc_new(heap, o, gas),
+        Some(o) => asc_new(heap, o, gas).await,
         None => Err(missing_field_error(type_name, field_name)),
     }
 }
 
 /// Map an optional object to its Asc equivalent if Some, otherwise return null.
-pub fn asc_new_or_null<H, O, A>(
+pub async fn asc_new_or_null<H, O, A>(
     heap: &mut H,
     object: &Option<O>,
     gas: &GasCounter,
 ) -> Result<AscPtr<A>, HostExportError>
 where
-    H: AscHeap + ?Sized,
+    H: AscHeap + Send + ?Sized,
     O: ToAscObj<A>,
     A: AscType + AscIndexId,
 {
     match object {
-        Some(o) => asc_new(heap, o, gas),
+        Some(o) => asc_new(heap, o, gas).await,
         None => Ok(AscPtr::null()),
     }
 }
@@ -118,26 +127,29 @@ where
 }
 
 /// Type that can be converted to an Asc object of class `C`.
+#[async_trait]
 pub trait ToAscObj<C: AscType> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + Send + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<C, HostExportError>;
 }
 
-impl<C: AscType, T: ToAscObj<C>> ToAscObj<C> for &T {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl<C: AscType, T: ToAscObj<C> + Sync> ToAscObj<C> for &T {
+    async fn to_asc_obj<H: AscHeap + Send + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<C, HostExportError> {
-        (*self).to_asc_obj(heap, gas)
+        (*self).to_asc_obj(heap, gas).await
     }
 }
 
+#[async_trait]
 impl ToAscObj<bool> for bool {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         _heap: &mut H,
         _gas: &GasCounter,
diff --git a/graph/src/runtime/asc_ptr.rs b/graph/src/runtime/asc_ptr.rs
index 890bde20e07..8e25971590b 100644
--- a/graph/src/runtime/asc_ptr.rs
+++ b/graph/src/runtime/asc_ptr.rs
@@ -1,5 +1,7 @@
+use crate::data::subgraph::API_VERSION_0_0_4;
+
 use super::gas::GasCounter;
-use super::{padding_to_16, DeterministicHostError, HostExportError};
+use super::{DeterministicHostError, HostExportError, padding_to_16};
 
 use super::{AscHeap, AscIndexId, AscType, IndexForAscTypeId};
 use semver::Version;
@@ -17,7 +19,7 @@ impl<T> Copy for AscPtr<T> {}
 
 impl<T> Clone for AscPtr<T> {
     fn clone(&self) -> Self {
-        AscPtr(self.0, PhantomData)
+        *self
     }
 }
 
@@ -61,13 +63,13 @@ impl<C: AscType> AscPtr<C> {
         let len = match heap.api_version() {
             // TODO: The version check here conflicts with the comment on C::asc_size,
             // which states "Only used for version <= 0.0.3."
-            version if version <= Version::new(0, 0, 4) => C::asc_size(self, heap, gas),
+            version if version <= &API_VERSION_0_0_4 => C::asc_size(self, heap, gas),
             _ => self.read_len(heap, gas),
         }?;
 
         let using_buffer = |buffer: &mut [MaybeUninit<u8>]| {
             let buffer = heap.read(self.0, buffer, gas)?;
-            C::from_asc_bytes(buffer, &heap.api_version())
+            C::from_asc_bytes(buffer, heap.api_version())
         };
 
         let len = len as usize;
@@ -82,7 +84,7 @@ impl<C: AscType> AscPtr<C> {
     }
 
     /// Allocate `asc_obj` as an Asc object of class `C`.
-    pub fn alloc_obj<H: AscHeap + ?Sized>(
+    pub async fn alloc_obj<H: AscHeap + ?Sized>(
         asc_obj: C,
         heap: &mut H,
         gas: &GasCounter,
@@ -91,8 +93,8 @@ impl<C: AscType> AscPtr<C> {
         C: AscIndexId,
     {
         match heap.api_version() {
-            version if version <= Version::new(0, 0, 4) => {
-                let heap_ptr = heap.raw_new(&asc_obj.to_asc_bytes()?, gas)?;
+            version if version <= &API_VERSION_0_0_4 => {
+                let heap_ptr = heap.raw_new(&asc_obj.to_asc_bytes()?, gas).await?;
                 Ok(AscPtr::new(heap_ptr))
             }
             _ => {
@@ -101,17 +103,18 @@ impl<C: AscType> AscPtr<C> {
                 let aligned_len = padding_to_16(bytes.len());
                 // Since AssemblyScript keeps all allocated objects with a 16 byte alignment,
                 // we need to do the same when we allocate ourselves.
-                bytes.extend(std::iter::repeat(0).take(aligned_len));
+                bytes.extend(std::iter::repeat_n(0, aligned_len));
 
                 let header = Self::generate_header(
                     heap,
                     C::INDEX_ASC_TYPE_ID,
                     asc_obj.content_len(&bytes),
                     bytes.len(),
-                )?;
+                )
+                .await?;
                 let header_len = header.len() as u32;
 
-                let heap_ptr = heap.raw_new(&[header, bytes].concat(), gas)?;
+                let heap_ptr = heap.raw_new(&[header, bytes].concat(), gas).await?;
 
                 // Use header length as offset. so the AscPtr points directly at the content.
                 Ok(AscPtr::new(heap_ptr + header_len))
@@ -137,8 +140,9 @@ impl<C: AscType> AscPtr<C> {
     /// - gc_info2: usize -> second GC info (we don't free memory so it's irrelevant)
     /// - rt_id: u32 -> identifier for the class being allocated
     /// - rt_size: u32 -> content size
+    ///
     /// Only used for version >= 0.0.5.
-    fn generate_header<H: AscHeap + ?Sized>(
+    async fn generate_header<H: AscHeap + ?Sized>(
         heap: &mut H,
         type_id_index: IndexForAscTypeId,
         content_length: usize,
@@ -148,7 +152,7 @@ impl<C: AscType> AscPtr<C> {
 
         let gc_info: [u8; 4] = (0u32).to_le_bytes();
         let gc_info2: [u8; 4] = (0u32).to_le_bytes();
-        let asc_type_id = heap.asc_type_id(type_id_index)?;
+        let asc_type_id = heap.asc_type_id(type_id_index).await?;
         let rt_id: [u8; 4] = asc_type_id.to_le_bytes();
         let rt_size: [u8; 4] = (content_length as u32).to_le_bytes();
 
@@ -166,12 +170,14 @@ impl<C: AscType> AscPtr<C> {
     }
 
     /// Helper to read the length from the header.
+    ///
     /// An AssemblyScript header has 20 bytes, and it's right before the content, and composed by:
     /// - mm_info: usize
     /// - gc_info: usize
     /// - gc_info2: usize
     /// - rt_id: u32
     /// - rt_size: u32
+    ///
     /// This function returns the `rt_size`.
     /// Only used for version >= 0.0.5.
     pub fn read_len<H: AscHeap + ?Sized>(
diff --git a/graph/src/runtime/gas/combinators.rs b/graph/src/runtime/gas/combinators.rs
index a6bc37954db..152f317bab0 100644
--- a/graph/src/runtime/gas/combinators.rs
+++ b/graph/src/runtime/gas/combinators.rs
@@ -83,10 +83,10 @@ where
 
     #[inline]
     fn const_gas_size_of() -> Option<Gas> {
-        if let Some(t0) = T0::const_gas_size_of() {
-            if let Some(t1) = T1::const_gas_size_of() {
-                return Some(C::combine(t0, t1));
-            }
+        if let Some(t0) = T0::const_gas_size_of()
+            && let Some(t1) = T1::const_gas_size_of()
+        {
+            return Some(C::combine(t0, t1));
         }
         None
     }
@@ -109,12 +109,11 @@ where
 
     #[inline] // Const propagation to the rescue. I hope.
     fn const_gas_size_of() -> Option<Gas> {
-        if let Some(t0) = T0::const_gas_size_of() {
-            if let Some(t1) = T1::const_gas_size_of() {
-                if let Some(t2) = T2::const_gas_size_of() {
-                    return Some(C::combine(C::combine(t0, t1), t2));
-                }
-            }
+        if let Some(t0) = T0::const_gas_size_of()
+            && let Some(t1) = T1::const_gas_size_of()
+            && let Some(t2) = T2::const_gas_size_of()
+        {
+            return Some(C::combine(C::combine(t0, t1), t2));
         }
         None
     }
diff --git a/graph/src/runtime/gas/costs.rs b/graph/src/runtime/gas/costs.rs
index 6436fc2102d..06decdf03aa 100644
--- a/graph/src/runtime/gas/costs.rs
+++ b/graph/src/runtime/gas/costs.rs
@@ -83,3 +83,10 @@ pub const JSON_FROM_BYTES: GasOp = GasOp {
     base_cost: DEFAULT_BASE_COST,
     size_mult: DEFAULT_GAS_PER_BYTE * 100,
 };
+
+// Deeply nested YAML can take up more than 100 times the memory of the serialized format.
+// Multiplying the size cost by 100 accounts for this.
+pub const YAML_FROM_BYTES: GasOp = GasOp {
+    base_cost: DEFAULT_BASE_COST,
+    size_mult: DEFAULT_GAS_PER_BYTE * 100,
+};
diff --git a/graph/src/runtime/gas/mod.rs b/graph/src/runtime/gas/mod.rs
index e137207d274..ab666c9095b 100644
--- a/graph/src/runtime/gas/mod.rs
+++ b/graph/src/runtime/gas/mod.rs
@@ -4,15 +4,16 @@ mod ops;
 mod saturating;
 mod size_of;
 use crate::components::metrics::gas::GasMetrics;
-use crate::prelude::{CheapClone, ENV_VARS};
+use crate::derive::CheapClone;
+use crate::prelude::ENV_VARS;
 use crate::runtime::DeterministicHostError;
 pub use combinators::*;
 pub use costs::DEFAULT_BASE_COST;
 pub use costs::*;
 pub use saturating::*;
 
-use std::sync::atomic::{AtomicU64, Ordering::SeqCst};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering::SeqCst};
 use std::{fmt, fmt::Display};
 
 pub struct GasOp {
@@ -55,7 +56,7 @@ pub trait GasSizeOf {
 
 /// This wrapper ensures saturating arithmetic is used
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
-pub struct Gas(u64);
+pub struct Gas(pub u64);
 
 impl Gas {
     pub const ZERO: Gas = Gas(0);
@@ -76,14 +77,12 @@ impl Display for Gas {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 pub struct GasCounter {
     counter: Arc<AtomicU64>,
     metrics: GasMetrics,
 }
 
-impl CheapClone for GasCounter {}
-
 impl GasCounter {
     pub fn new(metrics: GasMetrics) -> Self {
         Self {
@@ -101,11 +100,11 @@ impl GasCounter {
         amount += costs::HOST_EXPORT_GAS;
 
         // If gas metrics are enabled, track the gas used
-        if ENV_VARS.enable_gas_metrics {
-            if let Some(method) = method {
-                self.metrics.track_gas(method, amount.0);
-                self.metrics.track_operations(method, 1);
-            }
+        if ENV_VARS.enable_dips_metrics
+            && let Some(method) = method
+        {
+            self.metrics.track_gas(method, amount.0);
+            self.metrics.track_operations(method, 1);
         }
 
         let old = self
diff --git a/graph/src/runtime/gas/size_of.rs b/graph/src/runtime/gas/size_of.rs
index 6d40816394b..05369d94847 100644
--- a/graph/src/runtime/gas/size_of.rs
+++ b/graph/src/runtime/gas/size_of.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     components::store::LoadRelatedRequest,
-    data::store::{scalar::Bytes, Value},
+    data::store::{Value, scalar::Bytes},
     schema::{EntityKey, EntityType},
 };
 
@@ -17,6 +17,7 @@ impl GasSizeOf for Value {
             Value::List(list) => list.gas_size_of(),
             Value::Int(int) => int.gas_size_of(),
             Value::Int8(int) => int.gas_size_of(),
+            Value::Timestamp(ts) => ts.gas_size_of(),
             Value::Bytes(bytes) => bytes.gas_size_of(),
             Value::Bool(bool) => bool.gas_size_of(),
             Value::BigInt(big_int) => big_int.gas_size_of(),
diff --git a/graph/src/runtime/mod.rs b/graph/src/runtime/mod.rs
index d20d1eccde3..34a8a316020 100644
--- a/graph/src/runtime/mod.rs
+++ b/graph/src/runtime/mod.rs
@@ -9,12 +9,14 @@ mod asc_heap;
 mod asc_ptr;
 
 pub use asc_heap::{
-    asc_get, asc_new, asc_new_or_missing, asc_new_or_null, AscHeap, FromAscObj, ToAscObj,
+    AscHeap, FromAscObj, ToAscObj, asc_get, asc_new, asc_new_or_missing, asc_new_or_null,
 };
 pub use asc_ptr::AscPtr;
 
 use anyhow::Error;
+use async_trait::async_trait;
 use semver::Version;
+
 use std::convert::TryInto;
 use std::fmt;
 use std::mem::size_of;
@@ -155,7 +157,7 @@ impl_asc_type!(u8, u16, u32, u64, i8, i32, i64, f32, f64);
 /// 3. Once defined, items and their discriminants cannot be changed, as this would break running
 ///    subgraphs compiled in previous versions of this representation.
 #[repr(u32)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum IndexForAscTypeId {
     // Ethereum type IDs
     String = 0,
@@ -258,7 +260,7 @@ pub enum IndexForAscTypeId {
     // Reserved discriminant space for more Ethereum type IDs: [1000, 1499]
     TransactionReceipt = 1000,
     Log = 1001,
-    ArrayH256 = 1002,
+    ArrayB256 = 1002,
     ArrayLog = 1003,
     ArrayTypedMapStringStoreValue = 1004,
     // Continue to add more Ethereum type IDs here.
@@ -268,77 +270,7 @@ pub enum IndexForAscTypeId {
     // ...
     // LastEthereumType = 1499,
 
-    // Reserved discriminant space for Cosmos type IDs: [1,500, 2,499]
-    CosmosAny = 1500,
-    CosmosAnyArray = 1501,
-    CosmosBytesArray = 1502,
-    CosmosCoinArray = 1503,
-    CosmosCommitSigArray = 1504,
-    CosmosEventArray = 1505,
-    CosmosEventAttributeArray = 1506,
-    CosmosEvidenceArray = 1507,
-    CosmosModeInfoArray = 1508,
-    CosmosSignerInfoArray = 1509,
-    CosmosTxResultArray = 1510,
-    CosmosValidatorArray = 1511,
-    CosmosValidatorUpdateArray = 1512,
-    CosmosAuthInfo = 1513,
-    CosmosBlock = 1514,
-    CosmosBlockId = 1515,
-    CosmosBlockIdFlagEnum = 1516,
-    CosmosBlockParams = 1517,
-    CosmosCoin = 1518,
-    CosmosCommit = 1519,
-    CosmosCommitSig = 1520,
-    CosmosCompactBitArray = 1521,
-    CosmosConsensus = 1522,
-    CosmosConsensusParams = 1523,
-    CosmosDuplicateVoteEvidence = 1524,
-    CosmosDuration = 1525,
-    CosmosEvent = 1526,
-    CosmosEventAttribute = 1527,
-    CosmosEventData = 1528,
-    CosmosEventVote = 1529,
-    CosmosEvidence = 1530,
-    CosmosEvidenceList = 1531,
-    CosmosEvidenceParams = 1532,
-    CosmosFee = 1533,
-    CosmosHeader = 1534,
-    CosmosHeaderOnlyBlock = 1535,
-    CosmosLightBlock = 1536,
-    CosmosLightClientAttackEvidence = 1537,
-    CosmosModeInfo = 1538,
-    CosmosModeInfoMulti = 1539,
-    CosmosModeInfoSingle = 1540,
-    CosmosPartSetHeader = 1541,
-    CosmosPublicKey = 1542,
-    CosmosResponseBeginBlock = 1543,
-    CosmosResponseDeliverTx = 1544,
-    CosmosResponseEndBlock = 1545,
-    CosmosSignModeEnum = 1546,
-    CosmosSignedHeader = 1547,
-    CosmosSignedMsgTypeEnum = 1548,
-    CosmosSignerInfo = 1549,
-    CosmosTimestamp = 1550,
-    CosmosTip = 1551,
-    CosmosTransactionData = 1552,
-    CosmosTx = 1553,
-    CosmosTxBody = 1554,
-    CosmosTxResult = 1555,
-    CosmosValidator = 1556,
-    CosmosValidatorParams = 1557,
-    CosmosValidatorSet = 1558,
-    CosmosValidatorSetUpdates = 1559,
-    CosmosValidatorUpdate = 1560,
-    CosmosVersionParams = 1561,
-    CosmosMessageData = 1562,
-    CosmosTransactionContext = 1563,
-    // Continue to add more Cosmos type IDs here.
-    // e.g.:
-    // NextCosmosType = 1564,
-    // AnotherCosmosType = 1565,
-    // ...
-    // LastCosmosType = 2499,
+    // Discriminant space [1,500, 2,499] was reserved for Cosmos, which has been removed
 
     // Arweave types
     ArweaveBlock = 2500,
@@ -368,7 +300,20 @@ pub enum IndexForAscTypeId {
     // ...
     // LastStarknetType = 4499,
 
-    // Reserved discriminant space for a future blockchain type IDs: [4,500, 5,499]
+    // Subgraph Data Source types
+    AscEntityTrigger = 4500,
+
+    // Reserved discriminant space for YAML type IDs: [5,500, 6,499]
+    YamlValue = 5500,
+    YamlTaggedValue = 5501,
+    YamlTypedMapEntryValueValue = 5502,
+    YamlTypedMapValueValue = 5503,
+    YamlArrayValue = 5504,
+    YamlArrayTypedMapEntryValueValue = 5505,
+    YamlWrappedValue = 5506,
+    YamlResultValueBool = 5507,
+
+    // Reserved discriminant space for a future blockchain type IDs: [6,500, 7,499]
     //
     // Generated with the following shell script:
     //
@@ -394,8 +339,9 @@ pub enum IndexForAscTypeId {
     UnitTestNetworkUnitTestTypeBoolArray = u32::MAX,
 }
 
+#[async_trait]
 impl ToAscObj<u32> for IndexForAscTypeId {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + Send + ?Sized>(
         &self,
         _heap: &mut H,
         _gas: &GasCounter,
diff --git a/graph/src/schema/api.rs b/graph/src/schema/api.rs
index 3b7bd4ace0e..38ee4582a47 100644
--- a/graph/src/schema/api.rs
+++ b/graph/src/schema/api.rs
@@ -1,20 +1,24 @@
 use std::collections::{BTreeMap, HashMap};
 use std::str::FromStr;
+use std::sync::Arc;
 
-use graphql_parser::Pos;
-use inflector::Inflector;
+use anyhow::Context;
 use lazy_static::lazy_static;
+use thiserror::Error;
 
-use crate::data::graphql::{ObjectOrInterface, ObjectTypeExt};
+use crate::cheap_clone::CheapClone;
+use crate::data::graphql::{ObjectOrInterface, ObjectTypeExt, TypeExt};
 use crate::data::store::IdType;
-use crate::schema::{ast, META_FIELD_NAME, META_FIELD_TYPE};
+use crate::env::ENV_VARS;
+use crate::schema::{LOGS_FIELD_NAME, META_FIELD_NAME, META_FIELD_TYPE, SCHEMA_TYPE_NAME, ast};
 
-use crate::data::graphql::ext::{DefinitionExt, DirectiveExt, DocumentExt, ValueExt};
-use crate::prelude::s::{Value, *};
-use crate::prelude::*;
-use thiserror::Error;
+use crate::data::graphql::ext::{
+    DefinitionExt, DirectiveExt, DocumentExt, ValueExt, camel_cased_names,
+};
+use crate::derive::CheapClone;
+use crate::prelude::{DeploymentHash, q, r, s};
 
-use super::{Schema, SCHEMA_TYPE_NAME};
+use super::{Aggregation, Field, InputSchema, Schema, TypeKind};
 
 #[derive(Error, Debug)]
 pub enum APISchemaError {
@@ -26,6 +30,8 @@ pub enum APISchemaError {
     FulltextSearchNonDeterministic,
     #[error("Illegal type for `id`: {0}")]
     IllegalIdType(String),
+    #[error("Failed to create API schema: {0}")]
+    SchemaCreationFailed(String),
 }
 
 // The followoing types are defined in meta.graphql
@@ -33,7 +39,7 @@ const BLOCK_HEIGHT: &str = "Block_height";
 const CHANGE_BLOCK_FILTER_NAME: &str = "BlockChangedFilter";
 const ERROR_POLICY_TYPE: &str = "_SubgraphErrorPolicy_";
 
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, CheapClone)]
 pub enum ErrorPolicy {
     Allow,
     Deny,
@@ -83,8 +89,8 @@ impl TryFrom<&r::Value> for ErrorPolicy {
 ///
 /// (2) By parsing an appropriate GraphQL schema from text and calling
 /// `from_graphql_schema`. In that case, it's the caller's responsibility to
-/// make sure that the schema has all the types needed for querying, like
-/// `Query` and `Subscription`
+/// make sure that the schema has all the types needed for querying, in
+/// particular `Query`
 ///
 /// Because of the second point, once constructed, it can not be assumed
 /// that an `ApiSchema` is based on an `InputSchema` and it can only be used
@@ -94,9 +100,8 @@ pub struct ApiSchema {
     schema: Schema,
 
     // Root types for the api schema.
-    pub query_type: Arc<ObjectType>,
-    pub subscription_type: Option<Arc<ObjectType>>,
-    object_types: HashMap<String, Arc<ObjectType>>,
+    pub query_type: Arc<s::ObjectType>,
+    object_types: HashMap<String, Arc<s::ObjectType>>,
 }
 
 impl ApiSchema {
@@ -114,11 +119,6 @@ impl ApiSchema {
             .get_root_query_type()
             .context("no root `Query` in the schema")?
             .clone();
-        let subscription_type = schema
-            .document
-            .get_root_subscription_type()
-            .cloned()
-            .map(Arc::new);
 
         let object_types = HashMap::from_iter(
             schema
@@ -131,7 +131,6 @@ impl ApiSchema {
         Ok(Self {
             schema,
             query_type: Arc::new(query_type),
-            subscription_type,
             object_types,
         })
     }
@@ -156,12 +155,12 @@ impl ApiSchema {
         &self.schema
     }
 
-    pub fn types_for_interface(&self) -> &BTreeMap<String, Vec<ObjectType>> {
+    pub fn types_for_interface(&self) -> &BTreeMap<String, Vec<s::ObjectType>> {
         &self.schema.types_for_interface
     }
 
     /// Returns `None` if the type implements no interfaces.
-    pub fn interfaces_for_type(&self, type_name: &str) -> Option<&Vec<InterfaceType>> {
+    pub fn interfaces_for_type(&self, type_name: &str) -> Option<&Vec<s::InterfaceType>> {
         self.schema.interfaces_for_type(type_name)
     }
 
@@ -169,7 +168,7 @@ impl ApiSchema {
     ///
     /// # Panics
     /// If `obj_type` is not part of this schema, this function panics
-    pub fn object_type(&self, obj_type: &ObjectType) -> Arc<ObjectType> {
+    pub fn object_type(&self, obj_type: &s::ObjectType) -> Arc<s::ObjectType> {
         self.object_types
             .get(&obj_type.name)
             .expect("ApiSchema.object_type is only used with existing types")
@@ -188,11 +187,13 @@ impl ApiSchema {
         match t {
             s::Type::NamedType(name) => {
                 let named_type = self.get_named_type(name);
-                named_type.map_or(false, |type_def| match type_def {
-                    s::TypeDefinition::Scalar(_)
-                    | s::TypeDefinition::Enum(_)
-                    | s::TypeDefinition::InputObject(_) => true,
-                    _ => false,
+                named_type.is_some_and(|type_def| {
+                    matches!(
+                        type_def,
+                        s::TypeDefinition::Scalar(_)
+                            | s::TypeDefinition::Enum(_)
+                            | s::TypeDefinition::InputObject(_)
+                    )
                 })
             }
             s::Type::ListType(inner) => self.is_input_type(inner),
@@ -249,9 +250,9 @@ impl ApiSchema {
 }
 
 lazy_static! {
-    static ref INTROSPECTION_SCHEMA: Document = {
+    static ref INTROSPECTION_SCHEMA: s::Document = {
         let schema = include_str!("introspection.graphql");
-        parse_schema(schema).expect("the schema `introspection.graphql` is invalid")
+        s::parse_schema(schema).expect("the schema `introspection.graphql` is invalid")
     };
     pub static ref INTROSPECTION_QUERY_TYPE: ast::ObjectType = {
         let root_query_type = INTROSPECTION_SCHEMA
@@ -271,8 +272,8 @@ pub fn is_introspection_field(name: &str) -> bool {
 ///
 /// This results in a schema that combines the original schema with the
 /// introspection schema
-fn add_introspection_schema(schema: &mut Document) {
-    fn introspection_fields() -> Vec<Field> {
+fn add_introspection_schema(schema: &mut s::Document) {
+    fn introspection_fields() -> Vec<s::Field> {
         // Generate fields for the root query fields in an introspection schema,
         // the equivalent of the fields of the `Query` type:
         //
@@ -281,30 +282,32 @@ fn add_introspection_schema(schema: &mut Document) {
         //   __type(name: String!): __Type
         // }
 
-        let type_args = vec![InputValue {
-            position: Pos::default(),
+        let type_args = vec![s::InputValue {
+            position: q::Pos::default(),
             description: None,
             name: "name".to_string(),
-            value_type: Type::NonNullType(Box::new(Type::NamedType("String".to_string()))),
+            value_type: s::Type::NonNullType(Box::new(s::Type::NamedType("String".to_string()))),
             default_value: None,
             directives: vec![],
         }];
 
         vec![
-            Field {
-                position: Pos::default(),
+            s::Field {
+                position: q::Pos::default(),
                 description: None,
                 name: "__schema".to_string(),
                 arguments: vec![],
-                field_type: Type::NonNullType(Box::new(Type::NamedType("__Schema".to_string()))),
+                field_type: s::Type::NonNullType(Box::new(s::Type::NamedType(
+                    "__Schema".to_string(),
+                ))),
                 directives: vec![],
             },
-            Field {
-                position: Pos::default(),
+            s::Field {
+                position: q::Pos::default(),
                 description: None,
                 name: "__type".to_string(),
                 arguments: type_args,
-                field_type: Type::NamedType("__Type".to_string()),
+                field_type: s::Type::NamedType("__Type".to_string()),
                 directives: vec![],
             },
         ]
@@ -325,7 +328,9 @@ fn add_introspection_schema(schema: &mut Document) {
         .definitions
         .iter_mut()
         .filter_map(|d| match d {
-            Definition::TypeDefinition(TypeDefinition::Object(t)) if t.name == "Query" => Some(t),
+            s::Definition::TypeDefinition(s::TypeDefinition::Object(t)) if t.name == "Query" => {
+                Some(t)
+            }
             _ => None,
         })
         .peekable()
@@ -339,95 +344,184 @@ fn add_introspection_schema(schema: &mut Document) {
 /// The input schema should only have type/enum/interface/union definitions
 /// and must not include a root Query type. This Query type is derived, with
 /// all its fields and their input arguments, based on the existing types.
-pub(in crate::schema) fn api_schema(input_schema: &Schema) -> Result<Document, APISchemaError> {
-    // Refactor: Take `input_schema` by value.
-    let object_types = input_schema.document.get_object_type_definitions();
-    let interface_types = input_schema.document.get_interface_type_definitions();
-
+pub(in crate::schema) fn api_schema(
+    input_schema: &InputSchema,
+) -> Result<s::Document, APISchemaError> {
     // Refactor: Don't clone the schema.
-    let mut schema = input_schema.clone();
-    add_meta_field_type(&mut schema.document);
-    add_types_for_object_types(&mut schema, &object_types)?;
-    add_types_for_interface_types(&mut schema, &interface_types)?;
-    add_field_arguments(&mut schema.document, &input_schema.document)?;
-    add_query_type(&mut schema.document, &object_types, &interface_types)?;
-    add_subscription_type(&mut schema.document, &object_types, &interface_types)?;
-
-    // Remove the `_Schema_` type from the generated schema.
-    schema.document.definitions.retain(|d| match d {
-        Definition::TypeDefinition(def @ TypeDefinition::Object(_)) => match def {
-            TypeDefinition::Object(t) if t.name.eq(SCHEMA_TYPE_NAME) => false,
-            _ => true,
-        },
-        _ => true,
-    });
+    let mut api = init_api_schema(input_schema)?;
+    add_builtin_field_types(&mut api.document);
+    add_types_for_object_types(&mut api, input_schema)?;
+    add_types_for_interface_types(&mut api, input_schema)?;
+    add_types_for_aggregation_types(&mut api, input_schema)?;
+    add_query_type(&mut api.document, input_schema)?;
+    Ok(api.document)
+}
+
+/// Initialize the API schema by copying type definitions from the input
+/// schema. The copies of the type definitions are modified to allow
+/// filtering and ordering of collections of entities.
+fn init_api_schema(input_schema: &InputSchema) -> Result<Schema, APISchemaError> {
+    /// Add arguments to fields that reference collections of other entities to
+    /// allow e.g. filtering and ordering the collections. The `fields` should
+    /// be the fields of an object or interface type
+    fn add_collection_arguments(fields: &mut [s::Field], input_schema: &InputSchema) {
+        for field in fields.iter_mut().filter(|field| field.field_type.is_list()) {
+            let field_type = field.field_type.get_base_type();
+            // `field_type`` could be an enum or scalar, in which case
+            // `type_kind_str` will return `None``
+            if let Some(ops) = input_schema
+                .kind_of_declared_type(field_type)
+                .map(FilterOps::for_kind)
+            {
+                field.arguments = ops.collection_arguments(field_type);
+            }
+        }
+    }
 
-    Ok(schema.document)
+    fn add_type_def(
+        api: &mut s::Document,
+        type_def: &s::TypeDefinition,
+        input_schema: &InputSchema,
+    ) -> Result<(), APISchemaError> {
+        match type_def {
+            s::TypeDefinition::Object(ot) => {
+                if ot.name != SCHEMA_TYPE_NAME {
+                    let mut ot = ot.clone();
+                    add_collection_arguments(&mut ot.fields, input_schema);
+                    let typedef = s::TypeDefinition::Object(ot);
+                    let def = s::Definition::TypeDefinition(typedef);
+                    api.definitions.push(def);
+                }
+            }
+            s::TypeDefinition::Interface(it) => {
+                let mut it = it.clone();
+                add_collection_arguments(&mut it.fields, input_schema);
+                let typedef = s::TypeDefinition::Interface(it);
+                let def = s::Definition::TypeDefinition(typedef);
+                api.definitions.push(def);
+            }
+            s::TypeDefinition::Enum(et) => {
+                let typedef = s::TypeDefinition::Enum(et.clone());
+                let def = s::Definition::TypeDefinition(typedef);
+                api.definitions.push(def);
+            }
+            s::TypeDefinition::InputObject(_) => {
+                // We don't support input object types in subgraph schemas
+                // but some subgraphs use that to then pass parameters of
+                // that type to queries
+                api.definitions
+                    .push(s::Definition::TypeDefinition(type_def.clone()));
+            }
+            s::TypeDefinition::Scalar(_) | s::TypeDefinition::Union(_) => {
+                // We don't support these type definitions in subgraph schemas
+                // but there are subgraphs out in the wild that contain them. We
+                // simply ignore them even though we should produce an error
+            }
+        }
+        Ok(())
+    }
+
+    let mut api = s::Document::default();
+    for defn in input_schema.schema().document.definitions.iter() {
+        match defn {
+            s::Definition::SchemaDefinition(_) | s::Definition::TypeExtension(_) => {
+                // We don't support these in subgraph schemas but there are
+                // subgraphs out in the wild that contain them. We simply
+                // ignore them even though we should produce an error
+            }
+            s::Definition::DirectiveDefinition(_) => {
+                // We don't really allow directive definitions in subgraph
+                // schemas, but the tests for introspection schemas create
+                // an input schema with a directive definition, and it's
+                // safer to allow it here rather than fail
+                api.definitions.push(defn.clone());
+            }
+            s::Definition::TypeDefinition(td) => add_type_def(&mut api, td, input_schema)?,
+        }
+    }
+
+    Schema::new(input_schema.id().clone(), api)
+        .map_err(|e| APISchemaError::SchemaCreationFailed(e.to_string()))
 }
 
-/// Adds a global `_Meta_` type to the schema. The `_meta` field
-/// accepts values of this type
-fn add_meta_field_type(schema: &mut Document) {
+/// Adds built-in field types to the schema. Currently adds `_Meta_` and `_Log_` types
+/// which are used by the `_meta` and `_logs` fields respectively.
+fn add_builtin_field_types(api: &mut s::Document) {
     lazy_static! {
-        static ref META_FIELD_SCHEMA: Document = {
+        static ref META_FIELD_SCHEMA: s::Document = {
             let schema = include_str!("meta.graphql");
-            parse_schema(schema).expect("the schema `meta.graphql` is invalid")
+            s::parse_schema(schema).expect("the schema `meta.graphql` is invalid")
+        };
+        static ref LOGS_FIELD_SCHEMA: s::Document = {
+            let schema = include_str!("logs.graphql");
+            s::parse_schema(schema).expect("the schema `logs.graphql` is invalid")
         };
     }
 
-    schema
-        .definitions
+    api.definitions
         .extend(META_FIELD_SCHEMA.definitions.iter().cloned());
+    api.definitions
+        .extend(LOGS_FIELD_SCHEMA.definitions.iter().cloned());
 }
 
 fn add_types_for_object_types(
-    schema: &mut Schema,
-    object_types: &[&ObjectType],
+    api: &mut Schema,
+    schema: &InputSchema,
 ) -> Result<(), APISchemaError> {
-    for object_type in object_types {
-        if !object_type.name.eq(SCHEMA_TYPE_NAME) {
-            add_order_by_type(&mut schema.document, &object_type.name, &object_type.fields)?;
-            add_filter_type(schema, &object_type.name, &object_type.fields)?;
-        }
+    for (name, object_type) in schema.object_types() {
+        add_order_by_type(&mut api.document, name, &object_type.fields)?;
+        add_filter_type(api, name, &object_type.fields)?;
     }
     Ok(())
 }
 
 /// Adds `*_orderBy` and `*_filter` enum types for the given interfaces to the schema.
 fn add_types_for_interface_types(
-    schema: &mut Schema,
-    interface_types: &[&InterfaceType],
+    api: &mut Schema,
+    input_schema: &InputSchema,
 ) -> Result<(), APISchemaError> {
-    for interface_type in interface_types {
-        add_order_by_type(
-            &mut schema.document,
-            &interface_type.name,
-            &interface_type.fields,
-        )?;
-        add_filter_type(schema, &interface_type.name, &interface_type.fields)?;
+    for (name, interface_type) in input_schema.interface_types() {
+        add_order_by_type(&mut api.document, name, &interface_type.fields)?;
+        add_filter_type(api, name, &interface_type.fields)?;
+    }
+    Ok(())
+}
+
+fn add_types_for_aggregation_types(
+    api: &mut Schema,
+    input_schema: &InputSchema,
+) -> Result<(), APISchemaError> {
+    for (name, agg_type) in input_schema.aggregation_types() {
+        // Combine regular fields and aggregate fields for ordering
+        let mut all_fields = agg_type.fields.to_vec();
+        for agg in agg_type.aggregates.iter() {
+            all_fields.push(agg.as_agg_field());
+        }
+        add_order_by_type(&mut api.document, name, &all_fields)?;
+        add_aggregation_filter_type(api, name, agg_type)?;
     }
     Ok(())
 }
 
 /// Adds a `<type_name>_orderBy` enum type for the given fields to the schema.
 fn add_order_by_type(
-    schema: &mut Document,
+    api: &mut s::Document,
     type_name: &str,
     fields: &[Field],
 ) -> Result<(), APISchemaError> {
     let type_name = format!("{}_orderBy", type_name);
 
-    match schema.get_named_type(&type_name) {
+    match api.get_named_type(&type_name) {
         None => {
-            let typedef = TypeDefinition::Enum(EnumType {
-                position: Pos::default(),
+            let typedef = s::TypeDefinition::Enum(s::EnumType {
+                position: q::Pos::default(),
                 description: None,
                 name: type_name,
                 directives: vec![],
-                values: field_enum_values(schema, fields)?,
+                values: field_enum_values(api, fields)?,
             });
-            let def = Definition::TypeDefinition(typedef);
-            schema.definitions.push(def);
+            let def = s::Definition::TypeDefinition(typedef);
+            api.definitions.push(def);
         }
         Some(_) => return Err(APISchemaError::TypeExists(type_name)),
     }
@@ -436,15 +530,15 @@ fn add_order_by_type(
 
 /// Generates enum values for the given set of fields.
 fn field_enum_values(
-    schema: &Document,
+    schema: &s::Document,
     fields: &[Field],
-) -> Result<Vec<EnumValue>, APISchemaError> {
+) -> Result<Vec<s::EnumValue>, APISchemaError> {
     let mut enum_values = vec![];
     for field in fields {
-        enum_values.push(EnumValue {
-            position: Pos::default(),
+        enum_values.push(s::EnumValue {
+            position: q::Pos::default(),
             description: None,
-            name: field.name.clone(),
+            name: field.name.to_string(),
             directives: vec![],
         });
         enum_values.extend(field_enum_values_from_child_entity(schema, field)?);
@@ -453,17 +547,17 @@ fn field_enum_values(
 }
 
 fn enum_value_from_child_entity_field(
-    schema: &Document,
+    schema: &s::Document,
     parent_field_name: &str,
-    field: &Field,
-) -> Option<EnumValue> {
+    field: &s::Field,
+) -> Option<s::EnumValue> {
     if ast::is_list_or_non_null_list_field(field) || ast::is_entity_type(schema, &field.field_type)
     {
         // Sorting on lists or entities is not supported.
         None
     } else {
-        Some(EnumValue {
-            position: Pos::default(),
+        Some(s::EnumValue {
+            position: q::Pos::default(),
             description: None,
             name: format!("{}__{}", parent_field_name, field.name),
             directives: vec![],
@@ -472,14 +566,14 @@ fn enum_value_from_child_entity_field(
 }
 
 fn field_enum_values_from_child_entity(
-    schema: &Document,
+    schema: &s::Document,
     field: &Field,
-) -> Result<Vec<EnumValue>, APISchemaError> {
-    fn resolve_supported_type_name(field_type: &Type) -> Option<&String> {
+) -> Result<Vec<s::EnumValue>, APISchemaError> {
+    fn resolve_supported_type_name(field_type: &s::Type) -> Option<&String> {
         match field_type {
-            Type::NamedType(name) => Some(name),
-            Type::ListType(_) => None,
-            Type::NonNullType(of_type) => resolve_supported_type_name(of_type),
+            s::Type::NamedType(name) => Some(name),
+            s::Type::ListType(_) => None,
+            s::Type::NonNullType(of_type) => resolve_supported_type_name(of_type),
         }
     }
 
@@ -494,8 +588,8 @@ fn field_enum_values_from_child_entity(
                 .get_named_type(name)
                 .ok_or_else(|| APISchemaError::TypeNotFound(name.clone()))?;
             match named_type {
-                TypeDefinition::Object(ObjectType { fields, .. })
-                | TypeDefinition::Interface(InterfaceType { fields, .. }) => fields
+                s::TypeDefinition::Object(s::ObjectType { fields, .. })
+                | s::TypeDefinition::Interface(s::InterfaceType { fields, .. }) => fields
                     .iter()
                     .filter_map(|f| {
                         enum_value_from_child_entity_field(schema, field.name.as_str(), f)
@@ -508,50 +602,175 @@ fn field_enum_values_from_child_entity(
     })
 }
 
-/// Adds a `<type_name>_filter` enum type for the given fields to the schema.
+/// Create an input object type definition for the `where` argument of a
+/// collection. The `name` is the name of the filter type, e.g.,
+/// `User_filter` and the fields are all the possible filters. This function
+/// adds fields for boolean `and` and `or` filters and for filtering by
+/// block change to the given fields.
+fn filter_type_defn(name: String, mut fields: Vec<s::InputValue>) -> s::Definition {
+    fields.push(block_changed_filter_argument());
+
+    if !ENV_VARS.graphql.disable_bool_filters {
+        fields.push(s::InputValue {
+            position: q::Pos::default(),
+            description: None,
+            name: "and".to_string(),
+            value_type: s::Type::ListType(Box::new(s::Type::NamedType(name.clone()))),
+            default_value: None,
+            directives: vec![],
+        });
+
+        fields.push(s::InputValue {
+            position: q::Pos::default(),
+            description: None,
+            name: "or".to_string(),
+            value_type: s::Type::ListType(Box::new(s::Type::NamedType(name.clone()))),
+            default_value: None,
+            directives: vec![],
+        });
+    }
+
+    let typedef = s::TypeDefinition::InputObject(s::InputObjectType {
+        position: q::Pos::default(),
+        description: None,
+        name,
+        directives: vec![],
+        fields,
+    });
+    s::Definition::TypeDefinition(typedef)
+}
+
+/// Selector for the kind of field filters to generate
+#[derive(Copy, Clone)]
+enum FilterOps {
+    /// Use ops for object and interface types
+    Object,
+    /// Use ops for aggregation types
+    Aggregation,
+}
+
+impl FilterOps {
+    fn for_type<'a>(&self, scalar_type: &'a s::ScalarType) -> FilterOpsSet<'a> {
+        match self {
+            Self::Object => FilterOpsSet::Object(&scalar_type.name),
+            Self::Aggregation => FilterOpsSet::Aggregation(&scalar_type.name),
+        }
+    }
+
+    fn for_kind(kind: TypeKind) -> FilterOps {
+        match kind {
+            TypeKind::Object | TypeKind::Interface => FilterOps::Object,
+            TypeKind::Aggregation => FilterOps::Aggregation,
+        }
+    }
+
+    /// Generates arguments for collection queries of a named type (e.g. User).
+    fn collection_arguments(&self, type_name: &str) -> Vec<s::InputValue> {
+        // `first` and `skip` should be non-nullable, but the Apollo graphql client
+        // exhibts non-conforming behaviour by erroing if no value is provided for a
+        // non-nullable field, regardless of the presence of a default.
+        let mut skip = input_value("skip", "", s::Type::NamedType("Int".to_string()));
+        skip.default_value = Some(s::Value::Int(0.into()));
+
+        let mut first = input_value("first", "", s::Type::NamedType("Int".to_string()));
+        first.default_value = Some(s::Value::Int(100.into()));
+
+        let filter_type = s::Type::NamedType(format!("{}_filter", type_name));
+        let filter = input_value("where", "", filter_type);
+
+        let order_by = match self {
+            FilterOps::Object => vec![
+                input_value(
+                    "orderBy",
+                    "",
+                    s::Type::NamedType(format!("{}_orderBy", type_name)),
+                ),
+                input_value(
+                    "orderDirection",
+                    "",
+                    s::Type::NamedType("OrderDirection".to_string()),
+                ),
+            ],
+            FilterOps::Aggregation => vec![
+                input_value(
+                    "interval",
+                    "",
+                    s::Type::NonNullType(Box::new(s::Type::NamedType(
+                        "Aggregation_interval".to_string(),
+                    ))),
+                ),
+                input_value(
+                    "orderBy",
+                    "",
+                    s::Type::NamedType(format!("{}_orderBy", type_name)),
+                ),
+                input_value(
+                    "orderDirection",
+                    "",
+                    s::Type::NamedType("OrderDirection".to_string()),
+                ),
+                input_value(
+                    "current",
+                    "",
+                    s::Type::NamedType("Aggregation_current".to_string()),
+                ),
+            ],
+        };
+
+        let mut args = vec![skip, first];
+        args.extend(order_by);
+        args.push(filter);
+
+        args
+    }
+}
+
+#[derive(Copy, Clone)]
+enum FilterOpsSet<'a> {
+    Object(&'a str),
+    Aggregation(&'a str),
+}
+
+impl<'a> FilterOpsSet<'a> {
+    fn type_name(&self) -> &'a str {
+        match self {
+            Self::Object(type_name) | Self::Aggregation(type_name) => type_name,
+        }
+    }
+}
+
+/// Adds a `<type_name>_filter` enum type for the given fields to the
+/// schema. Used for object and interface types
 fn add_filter_type(
-    schema: &mut Schema,
+    api: &mut Schema,
     type_name: &str,
     fields: &[Field],
 ) -> Result<(), APISchemaError> {
     let filter_type_name = format!("{}_filter", type_name);
-    match schema.document.get_named_type(&filter_type_name) {
-        None => {
-            let mut generated_filter_fields = field_input_values(schema, fields)?;
-            generated_filter_fields.push(block_changed_filter_argument());
+    if api.document.get_named_type(&filter_type_name).is_some() {
+        return Err(APISchemaError::TypeExists(filter_type_name));
+    }
+    let filter_fields = field_input_values(api, fields, FilterOps::Object)?;
 
-            if !ENV_VARS.graphql.disable_bool_filters {
-                generated_filter_fields.push(InputValue {
-                    position: Pos::default(),
-                    description: None,
-                    name: "and".to_string(),
-                    value_type: Type::ListType(Box::new(Type::NamedType(filter_type_name.clone()))),
-                    default_value: None,
-                    directives: vec![],
-                });
+    let defn = filter_type_defn(filter_type_name, filter_fields);
+    api.document.definitions.push(defn);
 
-                generated_filter_fields.push(InputValue {
-                    position: Pos::default(),
-                    description: None,
-                    name: "or".to_string(),
-                    value_type: Type::ListType(Box::new(Type::NamedType(filter_type_name.clone()))),
-                    default_value: None,
-                    directives: vec![],
-                });
-            }
+    Ok(())
+}
 
-            let typedef = TypeDefinition::InputObject(InputObjectType {
-                position: Pos::default(),
-                description: None,
-                name: filter_type_name,
-                directives: vec![],
-                fields: generated_filter_fields,
-            });
-            let def = Definition::TypeDefinition(typedef);
-            schema.document.definitions.push(def);
-        }
-        Some(_) => return Err(APISchemaError::TypeExists(filter_type_name)),
+fn add_aggregation_filter_type(
+    api: &mut Schema,
+    type_name: &str,
+    agg: &Aggregation,
+) -> Result<(), APISchemaError> {
+    let filter_type_name = format!("{}_filter", type_name);
+    if api.document.get_named_type(&filter_type_name).is_some() {
+        return Err(APISchemaError::TypeExists(filter_type_name));
     }
+    let filter_fields = field_input_values(api, &agg.fields, FilterOps::Aggregation)?;
+
+    let defn = filter_type_defn(filter_type_name, filter_fields);
+    api.document.definitions.push(defn);
 
     Ok(())
 }
@@ -560,10 +779,11 @@ fn add_filter_type(
 fn field_input_values(
     schema: &Schema,
     fields: &[Field],
-) -> Result<Vec<InputValue>, APISchemaError> {
+    ops: FilterOps,
+) -> Result<Vec<s::InputValue>, APISchemaError> {
     let mut input_values = vec![];
     for field in fields {
-        input_values.extend(field_filter_input_values(schema, field, &field.field_type)?);
+        input_values.extend(field_filter_input_values(schema, field, ops)?);
     }
     Ok(input_values)
 }
@@ -572,57 +792,57 @@ fn field_input_values(
 fn field_filter_input_values(
     schema: &Schema,
     field: &Field,
-    field_type: &Type,
-) -> Result<Vec<InputValue>, APISchemaError> {
-    match field_type {
-        Type::NamedType(ref name) => {
-            let named_type = schema
-                .document
-                .get_named_type(name)
-                .ok_or_else(|| APISchemaError::TypeNotFound(name.clone()))?;
-            Ok(match named_type {
-                TypeDefinition::Object(_) | TypeDefinition::Interface(_) => {
-                    let scalar_type = id_type_as_scalar(schema, named_type)?.unwrap();
-                    let mut input_values = match ast::get_derived_from_directive(field) {
-                        // Only add `where` filter fields for object and interface fields
-                        // if they are not @derivedFrom
-                        Some(_) => vec![],
-                        // We allow filtering with `where: { other: "some-id" }` and
-                        // `where: { others: ["some-id", "other-id"] }`. In both cases,
-                        // we allow ID strings as the values to be passed to these
-                        // filters.
-                        None => {
-                            field_scalar_filter_input_values(&schema.document, field, &scalar_type)
-                        }
-                    };
-                    extend_with_child_filter_input_value(field, name, &mut input_values);
-                    input_values
-                }
-                TypeDefinition::Scalar(ref t) => {
-                    field_scalar_filter_input_values(&schema.document, field, t)
-                }
-                TypeDefinition::Enum(ref t) => {
-                    field_enum_filter_input_values(&schema.document, field, t)
-                }
-                _ => vec![],
-            })
-        }
-        Type::ListType(ref t) => {
-            Ok(field_list_filter_input_values(schema, field, t)?.unwrap_or_default())
-        }
-        Type::NonNullType(ref t) => field_filter_input_values(schema, field, t),
+    ops: FilterOps,
+) -> Result<Vec<s::InputValue>, APISchemaError> {
+    let type_name = field.field_type.get_base_type();
+    if field.is_list() {
+        Ok(field_list_filter_input_values(schema, field)?.unwrap_or_default())
+    } else {
+        let named_type = schema
+            .document
+            .get_named_type(type_name)
+            .ok_or_else(|| APISchemaError::TypeNotFound(type_name.to_string()))?;
+        Ok(match named_type {
+            s::TypeDefinition::Object(_) | s::TypeDefinition::Interface(_) => {
+                let scalar_type = id_type_as_scalar(schema, named_type)?.unwrap();
+                let mut input_values = if field.is_derived() {
+                    // Only add `where` filter fields for object and interface fields
+                    // if they are not @derivedFrom
+                    vec![]
+                } else {
+                    // We allow filtering with `where: { other: "some-id" }` and
+                    // `where: { others: ["some-id", "other-id"] }`. In both cases,
+                    // we allow ID strings as the values to be passed to these
+                    // filters.
+                    field_scalar_filter_input_values(
+                        &schema.document,
+                        field,
+                        ops.for_type(&scalar_type),
+                    )
+                };
+                extend_with_child_filter_input_value(field, type_name, &mut input_values);
+                input_values
+            }
+            s::TypeDefinition::Scalar(t) => {
+                field_scalar_filter_input_values(&schema.document, field, ops.for_type(t))
+            }
+            s::TypeDefinition::Enum(t) => {
+                field_enum_filter_input_values(&schema.document, field, t)
+            }
+            _ => vec![],
+        })
     }
 }
 
 fn id_type_as_scalar(
     schema: &Schema,
-    typedef: &TypeDefinition,
-) -> Result<Option<ScalarType>, APISchemaError> {
+    typedef: &s::TypeDefinition,
+) -> Result<Option<s::ScalarType>, APISchemaError> {
     let id_type = match typedef {
-        TypeDefinition::Object(obj_type) => IdType::try_from(obj_type)
+        s::TypeDefinition::Object(obj_type) => IdType::try_from(obj_type)
             .map(Option::Some)
             .map_err(|_| APISchemaError::IllegalIdType(obj_type.name.to_owned())),
-        TypeDefinition::Interface(intf_type) => {
+        s::TypeDefinition::Interface(intf_type) => {
             match schema
                 .types_for_interface
                 .get(&intf_type.name)
@@ -637,28 +857,24 @@ fn id_type_as_scalar(
         _ => Ok(None),
     }?;
     let scalar_type = id_type.map(|id_type| match id_type {
-        IdType::String | IdType::Bytes => ScalarType::new(String::from("String")),
+        IdType::String | IdType::Bytes => s::ScalarType::new(String::from("String")),
         // It would be more logical to use "Int8" here, but currently, that
         // leads to values being turned into strings, not i64 which causes
         // database queries to fail in various places. Once this is fixed
         // (check e.g., `Value::coerce_scalar` in `graph/src/data/value.rs`)
         // we can turn that into "Int8". For now, queries can only query
         // Int8 id values up to i32::MAX.
-        IdType::Int8 => ScalarType::new(String::from("Int")),
+        IdType::Int8 => s::ScalarType::new(String::from("Int")),
     });
     Ok(scalar_type)
 }
 
-/// Generates `*_filter` input values for the given scalar field.
-fn field_scalar_filter_input_values(
-    _schema: &Document,
-    field: &Field,
-    field_type: &ScalarType,
-) -> Vec<InputValue> {
-    match field_type.name.as_ref() {
-        "BigInt" => vec!["", "not", "gt", "lt", "gte", "lte", "in", "not_in"],
-        "Boolean" => vec!["", "not", "in", "not_in"],
-        "Bytes" => vec![
+fn field_filter_ops(set: FilterOpsSet<'_>) -> &'static [&'static str] {
+    use FilterOpsSet::*;
+
+    match set {
+        Object("Boolean") => &["", "not", "in", "not_in"],
+        Object("Bytes") => &[
             "",
             "not",
             "gt",
@@ -670,11 +886,10 @@ fn field_scalar_filter_input_values(
             "contains",
             "not_contains",
         ],
-        "BigDecimal" => vec!["", "not", "gt", "lt", "gte", "lte", "in", "not_in"],
-        "ID" => vec!["", "not", "gt", "lt", "gte", "lte", "in", "not_in"],
-        "Int" => vec!["", "not", "gt", "lt", "gte", "lte", "in", "not_in"],
-        "Int8" => vec!["", "not", "gt", "lt", "gte", "lte", "in", "not_in"],
-        "String" => vec![
+        Object("ID") => &["", "not", "gt", "lt", "gte", "lte", "in", "not_in"],
+        Object("BigInt") | Object("BigDecimal") | Object("Int") | Object("Int8")
+        | Object("Timestamp") => &["", "not", "gt", "lt", "gte", "lte", "in", "not_in"],
+        Object("String") => &[
             "",
             "not",
             "gt",
@@ -696,46 +911,63 @@ fn field_scalar_filter_input_values(
             "not_ends_with",
             "not_ends_with_nocase",
         ],
-        _ => vec!["", "not"],
-    }
-    .into_iter()
-    .map(|filter_type| {
-        let field_type = Type::NamedType(field_type.name.clone());
-        let value_type = match filter_type {
-            "in" | "not_in" => Type::ListType(Box::new(Type::NonNullType(Box::new(field_type)))),
-            _ => field_type,
-        };
-        input_value(&field.name, filter_type, value_type)
-    })
-    .collect()
+        Aggregation("BigInt")
+        | Aggregation("BigDecimal")
+        | Aggregation("Int")
+        | Aggregation("Int8")
+        | Aggregation("Timestamp") => &["", "gt", "lt", "gte", "lte", "in"],
+        Object(_) => &["", "not"],
+        Aggregation(_) => &[""],
+    }
+}
+
+/// Generates `*_filter` input values for the given scalar field.
+fn field_scalar_filter_input_values(
+    _schema: &s::Document,
+    field: &Field,
+    set: FilterOpsSet<'_>,
+) -> Vec<s::InputValue> {
+    field_filter_ops(set)
+        .iter()
+        .map(|filter_type| {
+            let field_type = s::Type::NamedType(set.type_name().to_string());
+            let value_type = match *filter_type {
+                "in" | "not_in" => {
+                    s::Type::ListType(Box::new(s::Type::NonNullType(Box::new(field_type))))
+                }
+                _ => field_type,
+            };
+            input_value(&field.name, filter_type, value_type)
+        })
+        .collect()
 }
 
 /// Appends a child filter to input values
 fn extend_with_child_filter_input_value(
     field: &Field,
-    field_type_name: &String,
-    input_values: &mut Vec<InputValue>,
+    field_type_name: &str,
+    input_values: &mut Vec<s::InputValue>,
 ) {
     input_values.push(input_value(
         &format!("{}_", field.name),
         "",
-        Type::NamedType(format!("{}_filter", field_type_name)),
+        s::Type::NamedType(format!("{}_filter", field_type_name)),
     ));
 }
 
 /// Generates `*_filter` input values for the given enum field.
 fn field_enum_filter_input_values(
-    _schema: &Document,
+    _schema: &s::Document,
     field: &Field,
-    field_type: &EnumType,
-) -> Vec<InputValue> {
+    field_type: &s::EnumType,
+) -> Vec<s::InputValue> {
     vec!["", "not", "in", "not_in"]
         .into_iter()
         .map(|filter_type| {
-            let field_type = Type::NamedType(field_type.name.clone());
+            let field_type = s::Type::NamedType(field_type.name.clone());
             let value_type = match filter_type {
                 "in" | "not_in" => {
-                    Type::ListType(Box::new(Type::NonNullType(Box::new(field_type))))
+                    s::Type::ListType(Box::new(s::Type::NonNullType(Box::new(field_type))))
                 }
                 _ => field_type,
             };
@@ -744,14 +976,33 @@ fn field_enum_filter_input_values(
         .collect()
 }
 
+/// Returns true if the given type supports case-insensitive filter
+/// operations (`_nocase` variants) when used as a list element type.
+/// Only `String` scalar types and object/interface types with `String`
+/// IDs support case-insensitive matching; types like `Bytes`, `BigInt`,
+/// etc. don't have a concept of case.
+fn field_list_supports_nocase(schema: &Schema, typedef: &s::TypeDefinition) -> bool {
+    match typedef {
+        s::TypeDefinition::Scalar(t) => t.name == "String",
+        s::TypeDefinition::Object(obj_type) => {
+            matches!(IdType::try_from(obj_type), Ok(IdType::String))
+        }
+        s::TypeDefinition::Interface(intf_type) => schema
+            .types_for_interface
+            .get(&intf_type.name)
+            .and_then(|types| types.first())
+            .is_none_or(|obj_type| matches!(IdType::try_from(obj_type), Ok(IdType::String))),
+        _ => false,
+    }
+}
+
 /// Generates `*_filter` input values for the given list field.
 fn field_list_filter_input_values(
     schema: &Schema,
     field: &Field,
-    field_type: &Type,
-) -> Result<Option<Vec<InputValue>>, APISchemaError> {
+) -> Result<Option<Vec<s::InputValue>>, APISchemaError> {
     // Only add a filter field if the type of the field exists in the schema
-    let typedef = match ast::get_type_definition_from_type(&schema.document, field_type) {
+    let typedef = match ast::get_type_definition_from_type(&schema.document, &field.field_type) {
         Some(typedef) => typedef,
         None => return Ok(None),
     };
@@ -761,44 +1012,45 @@ fn field_list_filter_input_values(
     // derived, we allow ID strings to be passed on.
     // Adds child filter only to object types.
     let (input_field_type, parent_type_name) = match typedef {
-        TypeDefinition::Object(ObjectType { name, .. })
-        | TypeDefinition::Interface(InterfaceType { name, .. }) => {
-            if ast::get_derived_from_directive(field).is_some() {
+        s::TypeDefinition::Object(s::ObjectType { name, .. })
+        | s::TypeDefinition::Interface(s::InterfaceType { name, .. }) => {
+            if field.is_derived() {
                 (None, Some(name.clone()))
             } else {
                 let scalar_type = id_type_as_scalar(schema, typedef)?.unwrap();
-                let named_type = Type::NamedType(scalar_type.name);
+                let named_type = s::Type::NamedType(scalar_type.name);
                 (Some(named_type), Some(name.clone()))
             }
         }
-        TypeDefinition::Scalar(ref t) => (Some(Type::NamedType(t.name.clone())), None),
-        TypeDefinition::Enum(ref t) => (Some(Type::NamedType(t.name.clone())), None),
-        TypeDefinition::InputObject(_) | TypeDefinition::Union(_) => (None, None),
+        s::TypeDefinition::Scalar(t) => (Some(s::Type::NamedType(t.name.clone())), None),
+        s::TypeDefinition::Enum(t) => (Some(s::Type::NamedType(t.name.clone())), None),
+        s::TypeDefinition::InputObject(_) | s::TypeDefinition::Union(_) => (None, None),
     };
 
-    let mut input_values: Vec<InputValue> = match input_field_type {
+    let mut input_values: Vec<s::InputValue> = match input_field_type {
         None => {
             vec![]
         }
-        Some(input_field_type) => vec![
-            "",
-            "not",
-            "contains",
-            "contains_nocase",
-            "not_contains",
-            "not_contains_nocase",
-        ]
-        .into_iter()
-        .map(|filter_type| {
-            input_value(
-                &field.name,
-                filter_type,
-                Type::ListType(Box::new(Type::NonNullType(Box::new(
-                    input_field_type.clone(),
-                )))),
-            )
-        })
-        .collect(),
+        Some(input_field_type) => {
+            let ops: &[&str] = if field_list_supports_nocase(schema, typedef) {
+                &[
+                    "",
+                    "not",
+                    "contains",
+                    "contains_nocase",
+                    "not_contains",
+                    "not_contains_nocase",
+                ]
+            } else {
+                &["", "not", "contains", "not_contains"]
+            };
+            let value_type = s::Type::ListType(Box::new(s::Type::NonNullType(Box::new(
+                input_field_type.clone(),
+            ))));
+            ops.iter()
+                .map(|filter_type| input_value(&field.name, filter_type, value_type.clone()))
+                .collect()
+        }
     };
 
     if let Some(parent) = parent_type_name {
@@ -809,9 +1061,9 @@ fn field_list_filter_input_values(
 }
 
 /// Generates a `*_filter` input value for the given field name, suffix and value type.
-fn input_value(name: &str, suffix: &'static str, value_type: Type) -> InputValue {
-    InputValue {
-        position: Pos::default(),
+fn input_value(name: &str, suffix: &'static str, value_type: s::Type) -> s::InputValue {
+    s::InputValue {
+        position: q::Pos::default(),
         description: None,
         name: if suffix.is_empty() {
             name.to_owned()
@@ -825,47 +1077,49 @@ fn input_value(name: &str, suffix: &'static str, value_type: Type) -> InputValue
 }
 
 /// Adds a root `Query` object type to the schema.
-fn add_query_type(
-    schema: &mut Document,
-    object_types: &[&ObjectType],
-    interface_types: &[&InterfaceType],
-) -> Result<(), APISchemaError> {
+fn add_query_type(api: &mut s::Document, input_schema: &InputSchema) -> Result<(), APISchemaError> {
     let type_name = String::from("Query");
 
-    if schema.get_named_type(&type_name).is_some() {
+    if api.get_named_type(&type_name).is_some() {
         return Err(APISchemaError::TypeExists(type_name));
     }
 
-    let mut fields = object_types
-        .iter()
-        .map(|t| t.name.as_str())
-        .filter(|name| !name.eq(&SCHEMA_TYPE_NAME))
-        .chain(interface_types.iter().map(|t| t.name.as_str()))
-        .flat_map(query_fields_for_type)
-        .collect::<Vec<Field>>();
-    let mut fulltext_fields = schema
+    let mut fields = input_schema
+        .object_types()
+        .map(|(name, _)| name)
+        .chain(input_schema.interface_types().map(|(name, _)| name))
+        .flat_map(|name| query_fields_for_type(name, FilterOps::Object))
+        .collect::<Vec<s::Field>>();
+    let mut agg_fields = input_schema
+        .aggregation_types()
+        .map(|(name, _)| name)
+        .flat_map(query_fields_for_agg_type)
+        .collect::<Vec<s::Field>>();
+    let mut fulltext_fields = input_schema
         .get_fulltext_directives()
         .map_err(|_| APISchemaError::FulltextSearchNonDeterministic)?
         .iter()
         .filter_map(|fulltext| query_field_for_fulltext(fulltext))
         .collect();
+    fields.append(&mut agg_fields);
     fields.append(&mut fulltext_fields);
     fields.push(meta_field());
+    fields.push(logs_field());
 
-    let typedef = TypeDefinition::Object(ObjectType {
-        position: Pos::default(),
+    let typedef = s::TypeDefinition::Object(s::ObjectType {
+        position: q::Pos::default(),
         description: None,
         name: type_name,
         implements_interfaces: vec![],
         directives: vec![],
         fields,
     });
-    let def = Definition::TypeDefinition(typedef);
-    schema.definitions.push(def);
+    let def = s::Definition::TypeDefinition(typedef);
+    api.definitions.push(def);
     Ok(())
 }
 
-fn query_field_for_fulltext(fulltext: &Directive) -> Option<Field> {
+fn query_field_for_fulltext(fulltext: &s::Directive) -> Option<s::Field> {
     let name = fulltext.argument("name").unwrap().as_str().unwrap().into();
 
     let includes = fulltext.argument("include").unwrap().as_list().unwrap();
@@ -876,30 +1130,30 @@ fn query_field_for_fulltext(fulltext: &Directive) -> Option<Field> {
 
     let mut arguments = vec![
         // text: String
-        InputValue {
-            position: Pos::default(),
+        s::InputValue {
+            position: q::Pos::default(),
             description: None,
             name: String::from("text"),
-            value_type: Type::NonNullType(Box::new(Type::NamedType(String::from("String")))),
+            value_type: s::Type::NonNullType(Box::new(s::Type::NamedType(String::from("String")))),
             default_value: None,
             directives: vec![],
         },
         // first: Int
-        InputValue {
-            position: Pos::default(),
+        s::InputValue {
+            position: q::Pos::default(),
             description: None,
             name: String::from("first"),
-            value_type: Type::NamedType(String::from("Int")),
-            default_value: Some(Value::Int(100.into())),
+            value_type: s::Type::NamedType(String::from("Int")),
+            default_value: Some(s::Value::Int(100.into())),
             directives: vec![],
         },
         // skip: Int
-        InputValue {
-            position: Pos::default(),
+        s::InputValue {
+            position: q::Pos::default(),
             description: None,
             name: String::from("skip"),
-            value_type: Type::NamedType(String::from("Int")),
-            default_value: Some(Value::Int(0.into())),
+            value_type: s::Type::NamedType(String::from("Int")),
+            default_value: Some(s::Value::Int(0.into())),
             directives: vec![],
         },
         // block: BlockHeight
@@ -907,61 +1161,27 @@ fn query_field_for_fulltext(fulltext: &Directive) -> Option<Field> {
         input_value(
             "where",
             "",
-            Type::NamedType(format!("{}_filter", entity_name)),
+            s::Type::NamedType(format!("{}_filter", entity_name)),
         ),
     ];
 
     arguments.push(subgraph_error_argument());
 
-    Some(Field {
-        position: Pos::default(),
+    Some(s::Field {
+        position: q::Pos::default(),
         description: None,
         name,
         arguments,
-        field_type: Type::NonNullType(Box::new(Type::ListType(Box::new(Type::NonNullType(
-            Box::new(Type::NamedType(entity_name.into())),
-        ))))), // included entity type name
+        field_type: s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(
+            s::Type::NonNullType(Box::new(s::Type::NamedType(entity_name.into()))),
+        )))), // included entity type name
         directives: vec![fulltext.clone()],
     })
 }
 
-/// Adds a root `Subscription` object type to the schema.
-fn add_subscription_type(
-    schema: &mut Document,
-    object_types: &[&ObjectType],
-    interface_types: &[&InterfaceType],
-) -> Result<(), APISchemaError> {
-    let type_name = String::from("Subscription");
-
-    if schema.get_named_type(&type_name).is_some() {
-        return Err(APISchemaError::TypeExists(type_name));
-    }
-
-    let mut fields: Vec<Field> = object_types
-        .iter()
-        .map(|t| &t.name)
-        .filter(|name| !name.eq(&SCHEMA_TYPE_NAME))
-        .chain(interface_types.iter().map(|t| &t.name))
-        .flat_map(|name| query_fields_for_type(name))
-        .collect();
-    fields.push(meta_field());
-
-    let typedef = TypeDefinition::Object(ObjectType {
-        position: Pos::default(),
-        description: None,
-        name: type_name,
-        implements_interfaces: vec![],
-        directives: vec![],
-        fields,
-    });
-    let def = Definition::TypeDefinition(typedef);
-    schema.definitions.push(def);
-    Ok(())
-}
-
-fn block_argument() -> InputValue {
-    InputValue {
-        position: Pos::default(),
+fn block_argument() -> s::InputValue {
+    s::InputValue {
+        position: q::Pos::default(),
         description: Some(
             "The block at which the query should be executed. \
              Can either be a `{ hash: Bytes }` value containing a block hash, \
@@ -973,48 +1193,48 @@ fn block_argument() -> InputValue {
                 .to_owned(),
         ),
         name: "block".to_string(),
-        value_type: Type::NamedType(BLOCK_HEIGHT.to_owned()),
+        value_type: s::Type::NamedType(BLOCK_HEIGHT.to_owned()),
         default_value: None,
         directives: vec![],
     }
 }
 
-fn block_changed_filter_argument() -> InputValue {
-    InputValue {
-        position: Pos::default(),
+fn block_changed_filter_argument() -> s::InputValue {
+    s::InputValue {
+        position: q::Pos::default(),
         description: Some("Filter for the block changed event.".to_owned()),
         name: "_change_block".to_string(),
-        value_type: Type::NamedType(CHANGE_BLOCK_FILTER_NAME.to_owned()),
+        value_type: s::Type::NamedType(CHANGE_BLOCK_FILTER_NAME.to_owned()),
         default_value: None,
         directives: vec![],
     }
 }
 
-fn subgraph_error_argument() -> InputValue {
-    InputValue {
-        position: Pos::default(),
+fn subgraph_error_argument() -> s::InputValue {
+    s::InputValue {
+        position: q::Pos::default(),
         description: Some(
             "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing."
                 .to_owned(),
         ),
         name: "subgraphError".to_string(),
-        value_type: Type::NonNullType(Box::new(Type::NamedType(ERROR_POLICY_TYPE.to_string()))),
-        default_value: Some(Value::Enum("deny".to_string())),
+        value_type: s::Type::NonNullType(Box::new(s::Type::NamedType(ERROR_POLICY_TYPE.to_string()))),
+        default_value: Some(s::Value::Enum("deny".to_string())),
         directives: vec![],
     }
 }
 
 /// Generates `Query` fields for the given type name (e.g. `users` and `user`).
-fn query_fields_for_type(type_name: &str) -> Vec<Field> {
-    let mut collection_arguments = collection_arguments_for_named_type(type_name);
+fn query_fields_for_type(type_name: &str, ops: FilterOps) -> Vec<s::Field> {
+    let mut collection_arguments = ops.collection_arguments(type_name);
     collection_arguments.push(block_argument());
 
     let mut by_id_arguments = vec![
-        InputValue {
-            position: Pos::default(),
+        s::InputValue {
+            position: q::Pos::default(),
             description: None,
             name: "id".to_string(),
-            value_type: Type::NonNullType(Box::new(Type::NamedType("ID".to_string()))),
+            value_type: s::Type::NonNullType(Box::new(s::Type::NamedType("ID".to_string()))),
             default_value: None,
             directives: vec![],
         },
@@ -1024,163 +1244,190 @@ fn query_fields_for_type(type_name: &str) -> Vec<Field> {
     collection_arguments.push(subgraph_error_argument());
     by_id_arguments.push(subgraph_error_argument());
 
+    // Name formatting must be updated in sync with `graph::data::schema::validate_fulltext_directive_name()`
+    let (singular, plural) = camel_cased_names(type_name);
     vec![
-        Field {
-            position: Pos::default(),
+        s::Field {
+            position: q::Pos::default(),
             description: None,
-            name: type_name.to_camel_case(), // Name formatting must be updated in sync with `graph::data::schema::validate_fulltext_directive_name()`
+            name: singular,
             arguments: by_id_arguments,
-            field_type: Type::NamedType(type_name.to_owned()),
+            field_type: s::Type::NamedType(type_name.to_owned()),
             directives: vec![],
         },
-        Field {
-            position: Pos::default(),
+        s::Field {
+            position: q::Pos::default(),
             description: None,
-            name: type_name.to_plural().to_camel_case(), // Name formatting must be updated in sync with `graph::data::schema::validate_fulltext_directive_name()`
+            name: plural,
             arguments: collection_arguments,
-            field_type: Type::NonNullType(Box::new(Type::ListType(Box::new(Type::NonNullType(
-                Box::new(Type::NamedType(type_name.to_owned())),
-            ))))),
+            field_type: s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(
+                s::Type::NonNullType(Box::new(s::Type::NamedType(type_name.to_owned()))),
+            )))),
             directives: vec![],
         },
     ]
 }
 
-fn meta_field() -> Field {
+fn query_fields_for_agg_type(type_name: &str) -> Vec<s::Field> {
+    let mut collection_arguments = FilterOps::Aggregation.collection_arguments(type_name);
+    collection_arguments.push(block_argument());
+    collection_arguments.push(subgraph_error_argument());
+
+    let (_, plural) = camel_cased_names(type_name);
+    vec![s::Field {
+        position: q::Pos::default(),
+        description: Some(format!("Collection of aggregated `{}` values", type_name)),
+        name: plural,
+        arguments: collection_arguments,
+        field_type: s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(
+            s::Type::NonNullType(Box::new(s::Type::NamedType(type_name.to_owned()))),
+        )))),
+        directives: vec![],
+    }]
+}
+
+fn meta_field() -> s::Field {
     lazy_static! {
-        static ref META_FIELD: Field = Field {
-            position: Pos::default(),
+        static ref META_FIELD: s::Field = s::Field {
+            position: q::Pos::default(),
             description: Some("Access to subgraph metadata".to_string()),
             name: META_FIELD_NAME.to_string(),
             arguments: vec![
                 // block: BlockHeight
-                InputValue {
-                    position: Pos::default(),
+                s::InputValue {
+                    position: q::Pos::default(),
                     description: None,
                     name: String::from("block"),
-                    value_type: Type::NamedType(BLOCK_HEIGHT.to_string()),
+                    value_type: s::Type::NamedType(BLOCK_HEIGHT.to_string()),
                     default_value: None,
                     directives: vec![],
                 },
             ],
-            field_type: Type::NamedType(META_FIELD_TYPE.to_string()),
+            field_type: s::Type::NamedType(META_FIELD_TYPE.to_string()),
             directives: vec![],
         };
     }
     META_FIELD.clone()
 }
 
-/// Generates arguments for collection queries of a named type (e.g. User).
-fn collection_arguments_for_named_type(type_name: &str) -> Vec<InputValue> {
-    // `first` and `skip` should be non-nullable, but the Apollo graphql client
-    // exhibts non-conforming behaviour by erroing if no value is provided for a
-    // non-nullable field, regardless of the presence of a default.
-    let mut skip = input_value("skip", "", Type::NamedType("Int".to_string()));
-    skip.default_value = Some(Value::Int(0.into()));
-
-    let mut first = input_value("first", "", Type::NamedType("Int".to_string()));
-    first.default_value = Some(Value::Int(100.into()));
-
-    let args = vec![
-        skip,
-        first,
-        input_value(
-            "orderBy",
-            "",
-            Type::NamedType(format!("{}_orderBy", type_name)),
-        ),
-        input_value(
-            "orderDirection",
-            "",
-            Type::NamedType("OrderDirection".to_string()),
-        ),
-        input_value(
-            "where",
-            "",
-            Type::NamedType(format!("{}_filter", type_name)),
-        ),
-    ];
-
-    args
-}
-
-fn add_field_arguments(
-    schema: &mut Document,
-    input_schema: &Document,
-) -> Result<(), APISchemaError> {
-    // Refactor: Remove the `input_schema` argument and do a mutable iteration
-    // over the definitions in `schema`. Also the duplication between this and
-    // the loop for interfaces below.
-    for input_object_type in input_schema.get_object_type_definitions() {
-        for input_field in &input_object_type.fields {
-            if let Some(input_reference_type) =
-                ast::get_referenced_entity_type(input_schema, input_field)
-            {
-                if ast::is_list_or_non_null_list_field(input_field) {
-                    // Get corresponding object type and field in the output schema
-                    let object_type = ast::get_object_type_mut(schema, &input_object_type.name)
-                        .expect("object type from input schema is missing in API schema");
-                    let mut field = object_type
-                        .fields
-                        .iter_mut()
-                        .find(|field| field.name == input_field.name)
-                        .expect("field from input schema is missing in API schema");
-
-                    match input_reference_type {
-                        TypeDefinition::Object(ot) => {
-                            field.arguments = collection_arguments_for_named_type(&ot.name);
-                        }
-                        TypeDefinition::Interface(it) => {
-                            field.arguments = collection_arguments_for_named_type(&it.name);
-                        }
-                        _ => unreachable!(
-                            "referenced entity types can only be object or interface types"
-                        ),
-                    }
-                }
-            }
-        }
-    }
-
-    for input_interface_type in input_schema.get_interface_type_definitions() {
-        for input_field in &input_interface_type.fields {
-            if let Some(input_reference_type) =
-                ast::get_referenced_entity_type(input_schema, input_field)
-            {
-                if ast::is_list_or_non_null_list_field(input_field) {
-                    // Get corresponding interface type and field in the output schema
-                    let interface_type =
-                        ast::get_interface_type_mut(schema, &input_interface_type.name)
-                            .expect("interface type from input schema is missing in API schema");
-                    let mut field = interface_type
-                        .fields
-                        .iter_mut()
-                        .find(|field| field.name == input_field.name)
-                        .expect("field from input schema is missing in API schema");
-
-                    match input_reference_type {
-                        TypeDefinition::Object(ot) => {
-                            field.arguments = collection_arguments_for_named_type(&ot.name);
-                        }
-                        TypeDefinition::Interface(it) => {
-                            field.arguments = collection_arguments_for_named_type(&it.name);
-                        }
-                        _ => unreachable!(
-                            "referenced entity types can only be object or interface types"
-                        ),
-                    }
-                }
-            }
-        }
+fn logs_field() -> s::Field {
+    lazy_static! {
+        static ref LOGS_FIELD: s::Field = s::Field {
+            position: q::Pos::default(),
+            description: Some(
+                "Query execution logs emitted by the subgraph during indexing. \
+                Results are sorted by timestamp in descending order (newest first)."
+                .to_string()
+            ),
+            name: LOGS_FIELD_NAME.to_string(),
+            arguments: vec![
+                // level: LogLevel
+                s::InputValue {
+                    position: q::Pos::default(),
+                    description: Some(
+                        "Filter logs by severity level. Only logs at this level will be returned."
+                        .to_string()
+                    ),
+                    name: String::from("level"),
+                    value_type: s::Type::NamedType(String::from("LogLevel")),
+                    default_value: None,
+                    directives: vec![],
+                },
+                // from: String (RFC3339 timestamp)
+                s::InputValue {
+                    position: q::Pos::default(),
+                    description: Some(
+                        "Filter logs from this timestamp onwards (inclusive). \
+                        Must be in RFC3339 format (e.g., '2024-01-15T10:30:00Z')."
+                        .to_string()
+                    ),
+                    name: String::from("from"),
+                    value_type: s::Type::NamedType(String::from("String")),
+                    default_value: None,
+                    directives: vec![],
+                },
+                // to: String (RFC3339 timestamp)
+                s::InputValue {
+                    position: q::Pos::default(),
+                    description: Some(
+                        "Filter logs until this timestamp (inclusive). \
+                        Must be in RFC3339 format (e.g., '2024-01-15T23:59:59Z')."
+                        .to_string()
+                    ),
+                    name: String::from("to"),
+                    value_type: s::Type::NamedType(String::from("String")),
+                    default_value: None,
+                    directives: vec![],
+                },
+                // search: String (full-text search)
+                s::InputValue {
+                    position: q::Pos::default(),
+                    description: Some(
+                        "Search for logs containing this text in the message. \
+                        Case-insensitive substring match. Maximum length: 1000 characters."
+                        .to_string()
+                    ),
+                    name: String::from("search"),
+                    value_type: s::Type::NamedType(String::from("String")),
+                    default_value: None,
+                    directives: vec![],
+                },
+                // first: Int (default 100, max 1000)
+                s::InputValue {
+                    position: q::Pos::default(),
+                    description: Some(
+                        "Maximum number of logs to return. Default: 100, Maximum: 1000."
+                        .to_string()
+                    ),
+                    name: String::from("first"),
+                    value_type: s::Type::NamedType(String::from("Int")),
+                    default_value: Some(s::Value::Int(100.into())),
+                    directives: vec![],
+                },
+                // skip: Int (default 0, max 10000)
+                s::InputValue {
+                    position: q::Pos::default(),
+                    description: Some(
+                        "Number of logs to skip (for pagination). Default: 0, Maximum: 10000."
+                        .to_string()
+                    ),
+                    name: String::from("skip"),
+                    value_type: s::Type::NamedType(String::from("Int")),
+                    default_value: Some(s::Value::Int(0.into())),
+                    directives: vec![],
+                },
+                // orderDirection: OrderDirection (default desc)
+                s::InputValue {
+                    position: q::Pos::default(),
+                    description: Some(
+                        "Sort direction for results. Default: desc (newest first)."
+                        .to_string()
+                    ),
+                    name: String::from("orderDirection"),
+                    value_type: s::Type::NamedType(String::from("OrderDirection")),
+                    default_value: Some(s::Value::Enum(String::from("desc"))),
+                    directives: vec![],
+                },
+            ],
+            field_type: s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(
+                s::Type::NonNullType(Box::new(s::Type::NamedType(String::from("_Log_")))),
+            )))),
+            directives: vec![],
+        };
     }
-
-    Ok(())
+    LOGS_FIELD.clone()
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::{data::subgraph::LATEST_VERSION, prelude::DeploymentHash, schema::InputSchema};
-    use graphql_parser::schema::*;
+    use crate::{
+        data::{
+            graphql::{ObjectTypeExt, TypeExt as _, ext::FieldExt},
+            subgraph::LATEST_VERSION,
+        },
+        prelude::{DeploymentHash, s},
+        schema::{InputSchema, SCHEMA_TYPE_NAME},
+    };
     use lazy_static::lazy_static;
 
     use super::ApiSchema;
@@ -1199,6 +1446,21 @@ mod tests {
             .expect("Failed to derive API schema")
     }
 
+    /// Return a field from the `Query` type. If the field does not exist,
+    /// fail the test
+    #[track_caller]
+    fn query_field<'a>(schema: &'a ApiSchema, name: &str) -> &'a s::Field {
+        let query_type = schema
+            .get_named_type("Query")
+            .expect("Query type is missing in derived API schema");
+
+        match query_type {
+            s::TypeDefinition::Object(t) => ast::get_field(t, name),
+            _ => None,
+        }
+        .unwrap_or_else(|| panic!("Schema should contain a field named `{}`", name))
+    }
+
     #[test]
     fn api_schema_contains_built_in_scalar_types() {
         let schema = parse("type User @entity { id: ID! }");
@@ -1221,6 +1483,9 @@ mod tests {
         schema
             .get_named_type("Int8")
             .expect("Int8 type is missing in API schema");
+        schema
+            .get_named_type("Timestamp")
+            .expect("Timestamp type is missing in API schema");
     }
 
     #[test]
@@ -1231,7 +1496,7 @@ mod tests {
             .get_named_type("OrderDirection")
             .expect("OrderDirection type is missing in derived API schema");
         let enum_type = match order_direction {
-            TypeDefinition::Enum(t) => Some(t),
+            s::TypeDefinition::Enum(t) => Some(t),
             _ => None,
         }
         .expect("OrderDirection type is not an enum");
@@ -1261,7 +1526,7 @@ mod tests {
             .expect("User_orderBy type is missing in derived API schema");
 
         let enum_type = match user_order_by {
-            TypeDefinition::Enum(t) => Some(t),
+            s::TypeDefinition::Enum(t) => Some(t),
             _ => None,
         }
         .expect("User_orderBy type is not an enum");
@@ -1360,7 +1625,7 @@ mod tests {
             .expect("User_orderBy type is missing in derived API schema");
 
         let enum_type = match user_order_by {
-            TypeDefinition::Enum(t) => Some(t),
+            s::TypeDefinition::Enum(t) => Some(t),
             _ => None,
         }
         .expect("User_orderBy type is not an enum");
@@ -1402,7 +1667,7 @@ mod tests {
             .expect("Meal_orderBy type is missing in derived API schema");
 
         let enum_type = match meal_order_by {
-            TypeDefinition::Enum(t) => Some(t),
+            s::TypeDefinition::Enum(t) => Some(t),
             _ => None,
         }
         .expect("Meal_orderBy type is not an enum");
@@ -1420,7 +1685,7 @@ mod tests {
             .expect("Recipe_orderBy type is missing in derived API schema");
 
         let enum_type = match recipe_order_by {
-            TypeDefinition::Enum(t) => Some(t),
+            s::TypeDefinition::Enum(t) => Some(t),
             _ => None,
         }
         .expect("Recipe_orderBy type is not an enum");
@@ -1481,7 +1746,7 @@ mod tests {
             .expect("User_filter type is missing in derived API schema");
 
         let user_filter_type = match user_filter {
-            TypeDefinition::InputObject(t) => Some(t),
+            s::TypeDefinition::InputObject(t) => Some(t),
             _ => None,
         }
         .expect("User_filter type is not an input object");
@@ -1586,7 +1851,7 @@ mod tests {
             .expect("Pet_filter type is missing in derived API schema");
 
         let pet_filter_type = match pet_filter {
-            TypeDefinition::InputObject(t) => Some(t),
+            s::TypeDefinition::InputObject(t) => Some(t),
             _ => None,
         }
         .expect("Pet_filter type is not an input object");
@@ -1652,14 +1917,11 @@ mod tests {
         let change_block_filter = user_filter_type
             .fields
             .iter()
-            .find(move |p| match p.name.as_str() {
-                "_change_block" => true,
-                _ => false,
-            })
+            .find(|p| p.name == "_change_block")
             .expect("_change_block field is missing in User_filter");
 
         match &change_block_filter.value_type {
-            Type::NamedType(name) => assert_eq!(name.as_str(), "BlockChangedFilter"),
+            s::Type::NamedType(name) => assert_eq!(name.as_str(), "BlockChangedFilter"),
             _ => panic!("_change_block field is not a named type"),
         }
 
@@ -1704,7 +1966,7 @@ mod tests {
             .expect("User_filter type is missing in derived API schema");
 
         let user_filter_type = match user_filter {
-            TypeDefinition::InputObject(t) => Some(t),
+            s::TypeDefinition::InputObject(t) => Some(t),
             _ => None,
         }
         .expect("User_filter type is not an input object");
@@ -1778,14 +2040,11 @@ mod tests {
         let change_block_filter = user_filter_type
             .fields
             .iter()
-            .find(move |p| match p.name.as_str() {
-                "_change_block" => true,
-                _ => false,
-            })
+            .find(|p| p.name == "_change_block")
             .expect("_change_block field is missing in User_filter");
 
         match &change_block_filter.value_type {
-            Type::NamedType(name) => assert_eq!(name.as_str(), "BlockChangedFilter"),
+            s::Type::NamedType(name) => assert_eq!(name.as_str(), "BlockChangedFilter"),
             _ => panic!("_change_block field is not a named type"),
         }
 
@@ -1805,14 +2064,14 @@ mod tests {
             .expect("Query type is missing in derived API schema");
 
         let user_singular_field = match query_type {
-            TypeDefinition::Object(t) => ast::get_field(t, "user"),
+            s::TypeDefinition::Object(t) => ast::get_field(t, "user"),
             _ => None,
         }
         .expect("\"user\" field is missing on Query type");
 
         assert_eq!(
             user_singular_field.field_type,
-            Type::NamedType("User".to_string())
+            s::Type::NamedType("User".to_string())
         );
 
         assert_eq!(
@@ -1829,15 +2088,15 @@ mod tests {
         );
 
         let user_plural_field = match query_type {
-            TypeDefinition::Object(t) => ast::get_field(t, "users"),
+            s::TypeDefinition::Object(t) => ast::get_field(t, "users"),
             _ => None,
         }
         .expect("\"users\" field is missing on Query type");
 
         assert_eq!(
             user_plural_field.field_type,
-            Type::NonNullType(Box::new(Type::ListType(Box::new(Type::NonNullType(
-                Box::new(Type::NamedType("User".to_string()))
+            s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(s::Type::NonNullType(
+                Box::new(s::Type::NamedType("User".to_string()))
             )))))
         );
 
@@ -1862,26 +2121,26 @@ mod tests {
         );
 
         let user_profile_singular_field = match query_type {
-            TypeDefinition::Object(t) => ast::get_field(t, "userProfile"),
+            s::TypeDefinition::Object(t) => ast::get_field(t, "userProfile"),
             _ => None,
         }
         .expect("\"userProfile\" field is missing on Query type");
 
         assert_eq!(
             user_profile_singular_field.field_type,
-            Type::NamedType("UserProfile".to_string())
+            s::Type::NamedType("UserProfile".to_string())
         );
 
         let user_profile_plural_field = match query_type {
-            TypeDefinition::Object(t) => ast::get_field(t, "userProfiles"),
+            s::TypeDefinition::Object(t) => ast::get_field(t, "userProfiles"),
             _ => None,
         }
         .expect("\"userProfiles\" field is missing on Query type");
 
         assert_eq!(
             user_profile_plural_field.field_type,
-            Type::NonNullType(Box::new(Type::ListType(Box::new(Type::NonNullType(
-                Box::new(Type::NamedType("UserProfile".to_string()))
+            s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(s::Type::NonNullType(
+                Box::new(s::Type::NamedType("UserProfile".to_string()))
             )))))
         );
     }
@@ -1900,14 +2159,14 @@ mod tests {
             .expect("Query type is missing in derived API schema");
 
         let singular_field = match query_type {
-            TypeDefinition::Object(ref t) => ast::get_field(t, "node"),
+            s::TypeDefinition::Object(t) => ast::get_field(t, "node"),
             _ => None,
         }
         .expect("\"node\" field is missing on Query type");
 
         assert_eq!(
             singular_field.field_type,
-            Type::NamedType("Node".to_string())
+            s::Type::NamedType("Node".to_string())
         );
 
         assert_eq!(
@@ -1924,15 +2183,15 @@ mod tests {
         );
 
         let plural_field = match query_type {
-            TypeDefinition::Object(ref t) => ast::get_field(t, "nodes"),
+            s::TypeDefinition::Object(t) => ast::get_field(t, "nodes"),
             _ => None,
         }
         .expect("\"nodes\" field is missing on Query type");
 
         assert_eq!(
             plural_field.field_type,
-            Type::NonNullType(Box::new(Type::ListType(Box::new(Type::NonNullType(
-                Box::new(Type::NamedType("Node".to_string()))
+            s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(s::Type::NonNullType(
+                Box::new(s::Type::NamedType("Node".to_string()))
             )))))
         );
 
@@ -1983,12 +2242,15 @@ type Gravatar @entity {
 "#;
         let schema = parse(SCHEMA);
 
+        // The _Schema_ type must not be copied to the API schema as it will
+        // cause GraphQL validation failures on clients
+        assert_eq!(None, schema.get_named_type(SCHEMA_TYPE_NAME));
         let query_type = schema
             .get_named_type("Query")
             .expect("Query type is missing in derived API schema");
 
         let _metadata_field = match query_type {
-            TypeDefinition::Object(t) => ast::get_field(t, &String::from("metadata")),
+            s::TypeDefinition::Object(t) => ast::get_field(t, &String::from("metadata")),
             _ => None,
         }
         .expect("\"metadata\" field is missing on Query type");
@@ -2018,4 +2280,221 @@ type Gravatar @entity {
         // object type
         let _schema = parse(SCHEMA);
     }
+
+    #[test]
+    fn pluralize_plural_name() {
+        const SCHEMA: &str = r#"
+        type Stats @entity {
+            id: Bytes!
+        }
+        "#;
+        let schema = parse(SCHEMA);
+
+        query_field(&schema, "stats");
+        query_field(&schema, "stats_collection");
+    }
+
+    #[test]
+    fn nested_filters() {
+        const SCHEMA: &str = r#"
+        type Musician @entity {
+            id: Bytes!
+            bands: [Band!]!
+        }
+
+        type Band @entity {
+            id: Bytes!
+            name: String!
+            musicians: [Musician!]!
+        }
+        "#;
+        let schema = parse(SCHEMA);
+
+        let musicians = query_field(&schema, "musicians");
+        let s::TypeDefinition::Object(musicians) =
+            schema.get_type_definition_from_field(musicians).unwrap()
+        else {
+            panic!("Can not find type for 'musicians' field")
+        };
+        let bands = musicians.field("bands").unwrap();
+        let filter = bands.argument("where").unwrap();
+        assert_eq!("Band_filter", filter.value_type.get_base_type());
+
+        query_field(&schema, "bands");
+    }
+
+    #[test]
+    fn aggregation() {
+        const SCHEMA: &str = r#"
+        type Data @entity(timeseries: true) {
+            id: Int8!
+            timestamp: Timestamp!
+            value: BigDecimal!
+        }
+
+        type Stats @aggregation(source: "Data", intervals: ["hour", "day"]) {
+            id: Int8!
+            timestamp: Timestamp!
+            sum: BigDecimal! @aggregate(fn: "sum", arg: "value")
+        }
+
+        type Stuff @entity {
+            id: Bytes!
+            stats: [Stats!]!
+        }
+        "#;
+
+        #[track_caller]
+        fn assert_aggregation_field(schema: &ApiSchema, field: &s::Field, typename: &str) {
+            let filter_type = format!("{typename}_filter");
+            let interval = field.argument("interval").unwrap();
+            assert_eq!("Aggregation_interval", interval.value_type.get_base_type());
+            let filter = field.argument("where").unwrap();
+            assert_eq!(&filter_type, filter.value_type.get_base_type());
+            let current = field.argument("current").unwrap();
+            assert_eq!("Aggregation_current", current.value_type.get_base_type());
+
+            let s::TypeDefinition::InputObject(filter) = schema
+                .get_type_definition_from_type(&filter.value_type)
+                .unwrap()
+            else {
+                panic!("Can not find type for 'where' filter")
+            };
+
+            let mut fields = filter
+                .fields
+                .iter()
+                .map(|f| f.name.clone())
+                .collect::<Vec<_>>();
+            fields.sort();
+            assert_eq!(
+                [
+                    "_change_block",
+                    "and",
+                    "id",
+                    "id_gt",
+                    "id_gte",
+                    "id_in",
+                    "id_lt",
+                    "id_lte",
+                    "or",
+                    "timestamp",
+                    "timestamp_gt",
+                    "timestamp_gte",
+                    "timestamp_in",
+                    "timestamp_lt",
+                    "timestamp_lte",
+                ],
+                fields.as_slice()
+            );
+
+            let s::TypeDefinition::Object(field_type) =
+                schema.get_type_definition_from_field(field).unwrap()
+            else {
+                panic!("Can not find type for 'stats' field")
+            };
+            assert_eq!("Stats", &field_type.name);
+        }
+
+        // The `Query` type must have a `stats_collection` field, and it
+        // must look right for filtering an aggregation
+        let schema = parse(SCHEMA);
+        let stats = query_field(&schema, "stats_collection");
+        assert_aggregation_field(&schema, stats, "Stats");
+
+        // Make sure that Stuff.stats has collection arguments, in
+        // particular a `where` filter
+        let s::TypeDefinition::Object(stuff) = schema
+            .get_type_definition_from_type(&s::Type::NamedType("Stuff".to_string()))
+            .unwrap()
+        else {
+            panic!("Stuff type is missing")
+        };
+        let stats = stuff.field("stats").unwrap();
+        assert_aggregation_field(&schema, stats, "Stats");
+    }
+
+    #[test]
+    fn no_extra_filters_for_interface_children() {
+        #[track_caller]
+        fn query_field<'a>(schema: &'a ApiSchema, name: &str) -> &'a crate::schema::api::s::Field {
+            let query_type = schema
+                .get_named_type("Query")
+                .expect("Query type is missing in derived API schema");
+
+            match query_type {
+                s::TypeDefinition::Object(t) => ast::get_field(t, name),
+                _ => None,
+            }
+            .unwrap_or_else(|| panic!("Schema should contain a field named `{}`", name))
+        }
+
+        const SCHEMA: &str = r#"
+        type DexProtocol implements Protocol @entity {
+            id: Bytes!
+            metrics: [Metric!]! @derivedFrom(field: "protocol")
+            pools: [Pool!]!
+        }
+
+        type Metric @entity {
+            id: Bytes!
+            protocol: DexProtocol!
+        }
+
+        type Pool @entity {
+            id: Bytes!
+        }
+
+        interface Protocol {
+            id: Bytes!
+            metrics: [Metric!]!  @derivedFrom(field: "protocol")
+            pools: [Pool!]!
+        }
+        "#;
+        let schema = parse(SCHEMA);
+
+        // Even for interfaces, we pay attention to whether a field is
+        // derived or not and change the filters in the API schema
+        // accordingly. It doesn't really make sense but has been like this
+        // for a long time and we'll have to support it.
+        for protos in ["dexProtocols", "protocols"] {
+            let groups = query_field(&schema, protos);
+            let filter = groups.argument("where").unwrap();
+            let s::TypeDefinition::InputObject(filter) = schema
+                .get_type_definition_from_type(&filter.value_type)
+                .unwrap()
+            else {
+                panic!("Can not find type for 'groups' filter")
+            };
+            let metrics_fields: Vec<_> = filter
+                .fields
+                .iter()
+                .filter(|field| field.name.starts_with("metrics"))
+                .map(|field| &field.name)
+                .collect();
+            assert_eq!(
+                ["metrics_"],
+                metrics_fields.as_slice(),
+                "Field {protos} has additional metrics filters"
+            );
+            let mut pools_fields: Vec<_> = filter
+                .fields
+                .iter()
+                .filter(|field| field.name.starts_with("pools"))
+                .map(|field| &field.name)
+                .collect();
+            pools_fields.sort();
+            assert_eq!(
+                [
+                    "pools",
+                    "pools_",
+                    "pools_contains",
+                    "pools_not",
+                    "pools_not_contains",
+                ],
+                pools_fields.as_slice(),
+                "Field {protos} has the wrong pools filters"
+            );
+        }
+    }
 }
diff --git a/graph/src/schema/ast.rs b/graph/src/schema/ast.rs
index 3728adeaa82..fc9b97430c0 100644
--- a/graph/src/schema/ast.rs
+++ b/graph/src/schema/ast.rs
@@ -1,14 +1,15 @@
-use graphql_parser::Pos;
 use lazy_static::lazy_static;
 use std::ops::Deref;
 use std::str::FromStr;
 use std::sync::Arc;
 
-use crate::cheap_clone::CheapClone;
 use crate::data::graphql::ext::DirectiveFinder;
 use crate::data::graphql::{DirectiveExt, DocumentExt, ObjectOrInterface};
+use crate::derive::CheapClone;
 use crate::prelude::anyhow::anyhow;
-use crate::prelude::{s, Error, ValueType};
+use crate::prelude::{Error, ValueType, s};
+
+use super::AsEntityTypeName;
 
 pub enum FilterOp {
     Not,
@@ -72,16 +73,16 @@ pub fn parse_field_as_filter(key: &str) -> (String, FilterOp) {
         _ => ("", FilterOp::Equal),
     };
 
-    return match op {
+    match op {
         FilterOp::And => (key.to_owned(), op),
         FilterOp::Or => (key.to_owned(), op),
         // Strip the operator suffix to get the attribute.
         _ => (key.trim_end_matches(suffix).to_owned(), op),
-    };
+    }
 }
 
 /// An `ObjectType` with `Hash` and `Eq` derived from the name.
-#[derive(Clone, Debug)]
+#[derive(Clone, CheapClone, Debug)]
 pub struct ObjectType(Arc<s::ObjectType>);
 
 impl Ord for ObjectType {
@@ -92,7 +93,7 @@ impl Ord for ObjectType {
 
 impl PartialOrd for ObjectType {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.0.name.cmp(&other.0.name))
+        Some(self.cmp(other))
     }
 }
 
@@ -130,7 +131,11 @@ impl Deref for ObjectType {
     }
 }
 
-impl CheapClone for ObjectType {}
+impl AsEntityTypeName for &ObjectType {
+    fn name(&self) -> &str {
+        &self.0.name
+    }
+}
 
 impl ObjectType {
     pub fn name(&self) -> &str {
@@ -155,7 +160,7 @@ pub fn get_object_type_mut<'a>(
     schema: &'a mut s::Document,
     name: &str,
 ) -> Option<&'a mut s::ObjectType> {
-    use graphql_parser::schema::TypeDefinition::*;
+    use graphql_tools::parser::schema::TypeDefinition::*;
 
     get_named_type_definition_mut(schema, name).and_then(|type_def| match type_def {
         Object(object_type) => Some(object_type),
@@ -168,7 +173,7 @@ pub fn get_interface_type_mut<'a>(
     schema: &'a mut s::Document,
     name: &str,
 ) -> Option<&'a mut s::InterfaceType> {
-    use graphql_parser::schema::TypeDefinition::*;
+    use graphql_tools::parser::schema::TypeDefinition::*;
 
     get_named_type_definition_mut(schema, name).and_then(|type_def| match type_def {
         Interface(interface_type) => Some(interface_type),
@@ -183,7 +188,7 @@ pub fn get_field<'a>(
 ) -> Option<&'a s::Field> {
     lazy_static! {
         pub static ref TYPENAME_FIELD: s::Field = s::Field {
-            position: Pos::default(),
+            position: s::Pos::default(),
             description: None,
             name: "__typename".to_owned(),
             field_type: s::Type::NonNullType(Box::new(s::Type::NamedType("String".to_owned()))),
@@ -206,7 +211,7 @@ pub fn get_field<'a>(
 /// Returns the value type for a GraphQL field type.
 pub fn get_field_value_type(field_type: &s::Type) -> Result<ValueType, Error> {
     match field_type {
-        s::Type::NamedType(ref name) => ValueType::from_str(name),
+        s::Type::NamedType(name) => ValueType::from_str(name),
         s::Type::NonNullType(inner) => get_field_value_type(inner),
         s::Type::ListType(_) => Err(anyhow!("Only scalar values are supported in this context")),
     }
@@ -255,7 +260,7 @@ pub fn get_argument_definitions<'a>(
 ) -> Option<&'a Vec<s::InputValue>> {
     lazy_static! {
         pub static ref NAME_ARGUMENT: Vec<s::InputValue> = vec![s::InputValue {
-            position: Pos::default(),
+            position: s::Pos::default(),
             description: None,
             name: "name".to_owned(),
             value_type: s::Type::NonNullType(Box::new(s::Type::NamedType("String".to_owned()))),
@@ -297,10 +302,7 @@ pub fn get_object_type_directive(
 
 // Returns true if the given type is a non-null type.
 pub fn is_non_null_type(t: &s::Type) -> bool {
-    match t {
-        s::Type::NonNullType(_) => true,
-        _ => false,
-    }
+    matches!(t, s::Type::NonNullType(_))
 }
 
 /// Returns true if the given type is an input type.
@@ -311,11 +313,13 @@ pub fn is_input_type(schema: &s::Document, t: &s::Type) -> bool {
     match t {
         s::Type::NamedType(name) => {
             let named_type = schema.get_named_type(name);
-            named_type.map_or(false, |type_def| match type_def {
-                s::TypeDefinition::Scalar(_)
-                | s::TypeDefinition::Enum(_)
-                | s::TypeDefinition::InputObject(_) => true,
-                _ => false,
+            named_type.is_some_and(|type_def| {
+                matches!(
+                    type_def,
+                    s::TypeDefinition::Scalar(_)
+                        | s::TypeDefinition::Enum(_)
+                        | s::TypeDefinition::InputObject(_)
+                )
             })
         }
         s::Type::ListType(inner) => is_input_type(schema, inner),
@@ -327,7 +331,7 @@ pub fn is_entity_type(schema: &s::Document, t: &s::Type) -> bool {
     match t {
         s::Type::NamedType(name) => schema
             .get_named_type(name)
-            .map_or(false, is_entity_type_definition),
+            .is_some_and(is_entity_type_definition),
         s::Type::ListType(inner_type) => is_entity_type(schema, inner_type),
         s::Type::NonNullType(inner_type) => is_entity_type(schema, inner_type),
     }
@@ -353,10 +357,7 @@ pub fn is_entity_type_definition(type_def: &s::TypeDefinition) -> bool {
 pub fn is_list_or_non_null_list_field(field: &s::Field) -> bool {
     match &field.field_type {
         s::Type::ListType(_) => true,
-        s::Type::NonNullType(inner_type) => match inner_type.deref() {
-            s::Type::ListType(_) => true,
-            _ => false,
-        },
+        s::Type::NonNullType(inner_type) => matches!(inner_type.deref(), s::Type::ListType(_)),
         _ => false,
     }
 }
diff --git a/graph/src/schema/entity_key.rs b/graph/src/schema/entity_key.rs
index 6508131b35a..3a5a8581a3c 100644
--- a/graph/src/schema/entity_key.rs
+++ b/graph/src/schema/entity_key.rs
@@ -3,12 +3,14 @@ use std::fmt;
 use crate::components::store::StoreError;
 use crate::data::store::{Id, Value};
 use crate::data_source::CausalityRegion;
+use crate::derive::CacheWeight;
 use crate::schema::EntityType;
 use crate::util::intern;
 
 /// Key by which an individual entity in the store can be accessed. Stores
 /// only the entity type and id. The deployment must be known from context.
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, CacheWeight, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[non_exhaustive]
 pub struct EntityKey {
     /// Name of the entity type.
     pub entity_type: EntityType,
@@ -22,8 +24,6 @@ pub struct EntityKey {
     /// doing the lookup. So if the entity exists but was created on a different causality region,
     /// the lookup will return empty.
     pub causality_region: CausalityRegion,
-
-    _force_use_of_new: (),
 }
 
 impl EntityKey {
@@ -42,7 +42,6 @@ impl EntityKey {
             entity_type,
             entity_id,
             causality_region,
-            _force_use_of_new: (),
         }
     }
 
@@ -60,3 +59,17 @@ impl std::fmt::Debug for EntityKey {
         )
     }
 }
+
+impl std::fmt::Display for EntityKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.causality_region == CausalityRegion::ONCHAIN {
+            write!(f, "{}[{}]", self.entity_type, self.entity_id)
+        } else {
+            write!(
+                f,
+                "{}/{}[{}]",
+                self.entity_type, self.causality_region, self.entity_id
+            )
+        }
+    }
+}
diff --git a/graph/src/schema/entity_type.rs b/graph/src/schema/entity_type.rs
index 5994fd618ad..c46f68681c9 100644
--- a/graph/src/schema/entity_type.rs
+++ b/graph/src/schema/entity_type.rs
@@ -1,7 +1,6 @@
 use std::{borrow::Borrow, fmt, sync::Arc};
 
 use anyhow::{Context, Error};
-use serde::Serialize;
 
 use crate::{
     cheap_clone::CheapClone,
@@ -12,18 +11,21 @@ use crate::{
     util::intern::Atom,
 };
 
-use super::{
-    input_schema::{ObjectType, TypeKind, POI_OBJECT},
-    EntityKey, InputSchema, InterfaceType,
-};
+use super::{EntityKey, Field, InputSchema, InterfaceType, ObjectType, POI_OBJECT};
+
+use graph_derive::CheapClone;
 
-/// The type name of an entity. This is the string that is used in the
-/// subgraph's GraphQL schema as `type NAME @entity { .. }`
+/// A reference to a type in the input schema. It should mostly be the
+/// reference to a concrete entity type, either one declared with `@entity`
+/// in the input schema, or the object type that stores aggregations for a
+/// certain interval, in other words a type that is actually backed by a
+/// database table. However, it can also be a reference to an interface type
+/// for historical reasons.
 ///
 /// Even though it is not implemented as a string type, it behaves as if it
 /// were the string name of the type for all external purposes like
 /// comparison, ordering, and serialization
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 pub struct EntityType {
     schema: InputSchema,
     pub(in crate::schema) atom: Atom,
@@ -34,11 +36,22 @@ impl EntityType {
         EntityType { schema, atom }
     }
 
+    /// Return the name of this type as a string.
     pub fn as_str(&self) -> &str {
         // unwrap: we constructed the entity type from the schema's pool
         self.schema.pool().get(self.atom).unwrap()
     }
 
+    /// Return the name of the declared type from the input schema that this
+    /// type belongs to. For object and interface types, that's the same as
+    /// `as_str()`, but for aggregations it's the name of the aggregation
+    /// rather than the name of the specific aggregation for an interval. In
+    /// that case, `as_str()` might return `Stats_hour` whereas `typename()`
+    /// returns `Stats`
+    pub fn typename(&self) -> &str {
+        self.schema.typename(self.atom)
+    }
+
     pub fn is_poi(&self) -> bool {
         self.as_str() == POI_OBJECT
     }
@@ -47,10 +60,18 @@ impl EntityType {
         self.schema.has_field(self.atom, field)
     }
 
+    pub fn field(&self, name: &str) -> Option<&Field> {
+        self.schema.field(self.atom, name)
+    }
+
     pub fn is_immutable(&self) -> bool {
         self.schema.is_immutable(self.atom)
     }
 
+    pub fn skip_duplicates(&self) -> bool {
+        self.schema.skip_duplicates(self.atom)
+    }
+
     pub fn id_type(&self) -> Result<IdType, Error> {
         self.schema.id_type(self.atom)
     }
@@ -90,7 +111,8 @@ impl EntityType {
             .into_iter()
             .map(|id| self.parse_id(id))
             .collect::<Result<_, _>>()?;
-        IdList::try_from_iter(self, ids.into_iter()).map_err(|e| anyhow::anyhow!("error: {}", e))
+        IdList::try_from_iter(self.id_type()?, ids.into_iter())
+            .map_err(|e| anyhow::anyhow!("error: {}", e))
     }
 
     /// Parse the given `id` into an `Id` and construct a key for an onchain
@@ -126,11 +148,18 @@ impl EntityType {
         self.schema.share_interfaces(self.atom)
     }
 
-    /// Return what kind of type `self` represents
-    pub fn kind(&self) -> TypeKind {
-        self.schema
-            .type_kind(self.atom)
-            .expect("the type must exist")
+    /// Return `true` if `self` is an object type, i.e., a type that is
+    /// declared with an `@entity` directive in the input schema. This
+    /// specifically excludes interfaces and aggregations.
+    pub fn is_object_type(&self) -> bool {
+        self.schema.is_object_type(self.atom)
+    }
+
+    /// Whether the table for this entity type uses a sequence for the `vid` or whether
+    /// `graph-node` sets them explicitly. See  also [`InputSchema.strict_vid_order()`]
+    pub fn has_vid_seq(&self) -> bool {
+        // Currently the agregations entities don't have VIDs in insertion order
+        self.schema.strict_vid_order() && self.is_object_type()
     }
 }
 
@@ -146,20 +175,12 @@ impl Borrow<str> for EntityType {
     }
 }
 
-impl CheapClone for EntityType {}
-
 impl std::fmt::Debug for EntityType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "EntityType({})", self.as_str())
     }
 }
 
-impl Serialize for EntityType {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.as_str().serialize(serializer)
-    }
-}
-
 impl PartialEq for EntityType {
     fn eq(&self, other: &Self) -> bool {
         if self.same_pool(other) && self.atom == other.atom {
@@ -173,7 +194,7 @@ impl Eq for EntityType {}
 
 impl PartialOrd for EntityType {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.as_str().partial_cmp(other.as_str())
+        Some(self.cmp(other))
     }
 }
 
diff --git a/graph/src/schema/input_schema.rs b/graph/src/schema/input/mod.rs
similarity index 77%
rename from graph/src/schema/input_schema.rs
rename to graph/src/schema/input/mod.rs
index 819604da43d..905a46dbea5 100644
--- a/graph/src/schema/input_schema.rs
+++ b/graph/src/schema/input/mod.rs
@@ -4,7 +4,7 @@ use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Duration;
 
-use anyhow::{anyhow, Error};
+use anyhow::{Error, anyhow};
 use semver::Version;
 use store::Entity;
 
@@ -15,16 +15,20 @@ use crate::components::store::LoadRelatedRequest;
 use crate::data::graphql::ext::DirectiveFinder;
 use crate::data::graphql::{DirectiveExt, DocumentExt, ObjectTypeExt, TypeExt, ValueExt};
 use crate::data::store::{
-    self, EntityValidationError, IdType, IntoEntityIterator, TryIntoEntityIterator, ValueType, ID,
+    self, EntityValidationError, ID, IdType, IntoEntityIterator, TryIntoEntityIterator, ValueType,
 };
+use crate::data::subgraph::SPEC_VERSION_1_3_0;
 use crate::data::value::Word;
+use crate::derive::CheapClone;
 use crate::prelude::q::Value;
-use crate::prelude::{s, DeploymentHash};
+use crate::prelude::{DeploymentHash, s};
 use crate::schema::api::api_schema;
 use crate::util::intern::{Atom, AtomPool};
 
-use super::fulltext::FulltextDefinition;
-use super::{ApiSchema, AsEntityTypeName, EntityType, Schema};
+use crate::schema::fulltext::FulltextDefinition;
+use crate::schema::{ApiSchema, AsEntityTypeName, EntityType, Schema, SchemaValidationError};
+
+pub mod sqlexpr;
 
 /// The name of the PoI entity type
 pub(crate) const POI_OBJECT: &str = "Poi$";
@@ -32,11 +36,13 @@ pub(crate) const POI_OBJECT: &str = "Poi$";
 const POI_DIGEST: &str = "digest";
 /// The name of the PoI attribute for storing the block time
 const POI_BLOCK_TIME: &str = "blockTime";
+pub(crate) const VID_FIELD: &str = "vid";
 
-mod kw {
+pub mod kw {
     pub const ENTITY: &str = "entity";
     pub const IMMUTABLE: &str = "immutable";
     pub const TIMESERIES: &str = "timeseries";
+    pub const SKIP_DUPLICATES: &str = "skipDuplicates";
     pub const TIMESTAMP: &str = "timestamp";
     pub const AGGREGATE: &str = "aggregate";
     pub const AGGREGATION: &str = "aggregation";
@@ -44,6 +50,9 @@ mod kw {
     pub const FUNC: &str = "fn";
     pub const ARG: &str = "arg";
     pub const INTERVALS: &str = "intervals";
+    pub const INTERVAL: &str = "interval";
+    pub const CUMULATIVE: &str = "cumulative";
+    pub const CURRENT: &str = "current";
 }
 
 /// The internal representation of a subgraph schema, i.e., the
@@ -54,7 +63,7 @@ mod kw {
 ///
 /// There's no need to put this into an `Arc`, since `InputSchema` already
 /// does that internally and is `CheapClone`
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, CheapClone, Debug, PartialEq)]
 pub struct InputSchema {
     inner: Arc<Inner>,
 }
@@ -117,12 +126,27 @@ impl TypeInfo {
 
     fn is_immutable(&self) -> bool {
         match self {
-            TypeInfo::Object(obj_type) => obj_type.immutable,
+            TypeInfo::Object(obj_type) => {
+                matches!(obj_type.mutability, ObjectMutability::Immutable { .. })
+            }
             TypeInfo::Interface(_) => false,
             TypeInfo::Aggregation(_) => true,
         }
     }
 
+    fn skip_duplicates(&self) -> bool {
+        match self {
+            TypeInfo::Object(obj_type) => matches!(
+                obj_type.mutability,
+                ObjectMutability::Immutable {
+                    skip_duplicates: true
+                }
+            ),
+            TypeInfo::Interface(_) => false,
+            TypeInfo::Aggregation(_) => false,
+        }
+    }
+
     fn kind(&self) -> TypeKind {
         match self {
             TypeInfo::Object(_) => TypeKind::Object,
@@ -131,6 +155,20 @@ impl TypeInfo {
         }
     }
 
+    fn object_type(&self) -> Option<&ObjectType> {
+        match self {
+            TypeInfo::Object(obj_type) => Some(obj_type),
+            TypeInfo::Interface(_) | TypeInfo::Aggregation(_) => None,
+        }
+    }
+
+    fn interface_type(&self) -> Option<&InterfaceType> {
+        match self {
+            TypeInfo::Interface(intf_type) => Some(intf_type),
+            TypeInfo::Object(_) | TypeInfo::Aggregation(_) => None,
+        }
+    }
+
     fn aggregation(&self) -> Option<&Aggregation> {
         match self {
             TypeInfo::Aggregation(agg_type) => Some(agg_type),
@@ -180,7 +218,7 @@ impl TypeInfo {
     }
 
     fn for_aggregation(schema: &Schema, pool: &AtomPool, agg_type: &s::ObjectType) -> Self {
-        let agg_type = Aggregation::new(&schema, &pool, agg_type);
+        let agg_type = Aggregation::new(schema, pool, agg_type);
         TypeInfo::Aggregation(agg_type)
     }
 
@@ -199,17 +237,22 @@ pub struct Field {
     pub name: Word,
     pub field_type: s::Type,
     pub value_type: ValueType,
-    pub is_derived: bool,
+    derived_from: Option<Word>,
 }
 
 impl Field {
-    pub fn new(schema: &Schema, name: &str, field_type: &s::Type, is_derived: bool) -> Self {
-        let value_type = Self::scalar_value_type(&schema, field_type);
+    pub fn new(
+        schema: &Schema,
+        name: &str,
+        field_type: &s::Type,
+        derived_from: Option<Word>,
+    ) -> Self {
+        let value_type = Self::scalar_value_type(schema, field_type);
         Self {
             name: Word::from(name),
             field_type: field_type.clone(),
             value_type,
-            is_derived,
+            derived_from,
         }
     }
 
@@ -219,7 +262,7 @@ impl Field {
             s::Type::NamedType(name) => name.parse::<ValueType>().unwrap_or_else(|_| {
                 match schema.document.get_named_type(name) {
                     Some(t::Object(obj_type)) => {
-                        let id = obj_type.field(&*ID).expect("all object types have an id");
+                        let id = obj_type.field(&ID).expect("all object types have an id");
                         Self::scalar_value_type(schema, &id.field_type)
                     }
                     Some(t::Interface(intf)) => {
@@ -239,7 +282,7 @@ impl Field {
                                 ValueType::String
                             }
                             Some(obj_type) => {
-                                let id = obj_type.field(&*ID).expect("all object types have an id");
+                                let id = obj_type.field(&ID).expect("all object types have an id");
                                 Self::scalar_value_type(schema, &id.field_type)
                             }
                         }
@@ -255,6 +298,126 @@ impl Field {
             s::Type::ListType(inner) => Self::scalar_value_type(schema, inner),
         }
     }
+
+    pub fn is_list(&self) -> bool {
+        self.field_type.is_list()
+    }
+
+    pub fn derived_from<'a>(&self, schema: &'a InputSchema) -> Option<&'a Field> {
+        let derived_from = self.derived_from.as_ref()?;
+        let name = schema
+            .pool()
+            .lookup(self.field_type.get_base_type())
+            .unwrap();
+        schema.field(name, derived_from)
+    }
+
+    pub fn is_derived(&self) -> bool {
+        self.derived_from.is_some()
+    }
+}
+
+#[derive(Copy, Clone)]
+pub enum ObjectOrInterface<'a> {
+    Object(&'a InputSchema, &'a ObjectType),
+    Interface(&'a InputSchema, &'a InterfaceType),
+}
+
+impl<'a> CheapClone for ObjectOrInterface<'a> {
+    fn cheap_clone(&self) -> Self {
+        match self {
+            ObjectOrInterface::Object(schema, object) => ObjectOrInterface::Object(schema, object),
+            ObjectOrInterface::Interface(schema, interface) => {
+                ObjectOrInterface::Interface(schema, interface)
+            }
+        }
+    }
+}
+
+impl<'a> ObjectOrInterface<'a> {
+    pub fn object_types(self) -> Vec<EntityType> {
+        let (schema, object_types) = match self {
+            ObjectOrInterface::Object(schema, object) => (schema, vec![object]),
+            ObjectOrInterface::Interface(schema, interface) => {
+                (schema, schema.implementers(interface).collect())
+            }
+        };
+        object_types
+            .into_iter()
+            .map(|object_type| EntityType::new(schema.cheap_clone(), object_type.name))
+            .collect()
+    }
+
+    pub fn typename(&self) -> &str {
+        let (schema, atom) = self.unpack();
+        schema.pool().get(atom).unwrap()
+    }
+
+    /// Return the field with the given name. For interfaces, that is the
+    /// field with that name declared in the interface, not in the
+    /// implementing object types
+    pub fn field(&self, name: &str) -> Option<&Field> {
+        match self {
+            ObjectOrInterface::Object(_, object) => object.field(name),
+            ObjectOrInterface::Interface(_, interface) => interface.field(name),
+        }
+    }
+
+    /// Return the field with the given name. For object types, that's the
+    /// field with that name. For interfaces, it's the field with that name
+    /// in the first object type that implements the interface; to be
+    /// useful, this tacitly assumes that all implementers of an interface
+    /// declare that field in the same way
+    pub fn implemented_field(&self, name: &str) -> Option<&Field> {
+        let object_type = match self {
+            ObjectOrInterface::Object(_, object_type) => Some(*object_type),
+            ObjectOrInterface::Interface(schema, interface) => {
+                schema.implementers(interface).next()
+            }
+        };
+        object_type.and_then(|object_type| object_type.field(name))
+    }
+
+    pub fn is_interface(&self) -> bool {
+        match self {
+            ObjectOrInterface::Object(_, _) => false,
+            ObjectOrInterface::Interface(_, _) => true,
+        }
+    }
+
+    pub fn derived_from(&self, field_name: &str) -> Option<&str> {
+        let field = self.field(field_name)?;
+        field.derived_from.as_ref().map(|name| name.as_str())
+    }
+
+    pub fn entity_type(&self) -> EntityType {
+        let (schema, atom) = self.unpack();
+        EntityType::new(schema.cheap_clone(), atom)
+    }
+
+    fn unpack(&self) -> (&InputSchema, Atom) {
+        match self {
+            ObjectOrInterface::Object(schema, object) => (schema, object.name),
+            ObjectOrInterface::Interface(schema, interface) => (schema, interface.name),
+        }
+    }
+
+    pub fn is_aggregation(&self) -> bool {
+        match self {
+            ObjectOrInterface::Object(_, object) => object.is_aggregation(),
+            ObjectOrInterface::Interface(_, _) => false,
+        }
+    }
+}
+
+impl std::fmt::Debug for ObjectOrInterface<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let (schema, name) = match self {
+            ObjectOrInterface::Object(schema, object) => (schema, object.name),
+            ObjectOrInterface::Interface(schema, interface) => (schema, interface.name),
+        };
+        write!(f, "ObjectOrInterface({})", schema.pool().get(name).unwrap())
+    }
 }
 
 #[derive(PartialEq, Debug)]
@@ -262,7 +425,7 @@ pub struct ObjectType {
     pub name: Atom,
     pub id_type: IdType,
     pub fields: Box<[Field]>,
-    pub immutable: bool,
+    pub mutability: ObjectMutability,
     /// The name of the aggregation to which this object type belongs if it
     /// is part of an aggregation
     aggregation: Option<Atom>,
@@ -283,8 +446,8 @@ impl ObjectType {
             .fields
             .iter()
             .map(|field| {
-                let is_derived = field.is_derived();
-                Field::new(schema, &field.name, &field.field_type, is_derived)
+                let derived_from = field.derived_from().map(Word::from);
+                Field::new(schema, &field.name, &field.field_type, derived_from)
             })
             .collect();
         let interfaces = object_type
@@ -301,16 +464,28 @@ impl ObjectType {
             None => false,
             _ => unreachable!("validations ensure we don't get here"),
         };
-        let immutable = match dir.argument("immutable") {
+        let immutable = match dir.argument(kw::IMMUTABLE) {
             Some(Value::Boolean(im)) => *im,
             None => timeseries,
             _ => unreachable!("validations ensure we don't get here"),
         };
+
+        let mutability = if immutable {
+            let skip_duplicates = match dir.argument(kw::SKIP_DUPLICATES) {
+                Some(Value::Boolean(sd)) => *sd,
+                _ => false,
+            };
+
+            ObjectMutability::Immutable { skip_duplicates }
+        } else {
+            ObjectMutability::Mutable
+        };
+
         Self {
             name,
             fields,
             id_type,
-            immutable,
+            mutability,
             aggregation: None,
             timeseries,
             interfaces,
@@ -324,13 +499,13 @@ impl ObjectType {
                 name: ID.clone(),
                 field_type: s::Type::NamedType("ID".to_string()),
                 value_type: ValueType::String,
-                is_derived: false,
+                derived_from: None,
             },
             Field {
                 name: Word::from(POI_DIGEST),
                 field_type: s::Type::NamedType("String".to_string()),
                 value_type: ValueType::String,
-                is_derived: false,
+                derived_from: None,
             },
         ]
         .into_boxed_slice();
@@ -341,7 +516,7 @@ impl ObjectType {
             name,
             interfaces: Box::new([]),
             id_type: IdType::String,
-            immutable: false,
+            mutability: ObjectMutability::Mutable,
             aggregation: None,
             timeseries: false,
             fields,
@@ -349,7 +524,7 @@ impl ObjectType {
         }
     }
 
-    fn field(&self, name: &str) -> Option<&Field> {
+    pub fn field(&self, name: &str) -> Option<&Field> {
         self.fields.iter().find(|field| field.name == name)
     }
 
@@ -359,6 +534,12 @@ impl ObjectType {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ObjectMutability {
+    Mutable,
+    Immutable { skip_duplicates: bool },
+}
+
 #[derive(PartialEq, Debug)]
 pub struct InterfaceType {
     pub name: Atom,
@@ -368,6 +549,7 @@ pub struct InterfaceType {
     /// is not implemented at all, we arbitrarily use `String`
     pub id_type: IdType,
     pub fields: Box<[Field]>,
+    implementers: Box<[Atom]>,
 }
 
 impl InterfaceType {
@@ -380,7 +562,15 @@ impl InterfaceType {
         let fields = interface_type
             .fields
             .iter()
-            .map(|field| Field::new(schema, &field.name, &field.field_type, false))
+            .map(|field| {
+                // It's very unclear what it means for an interface field to
+                // be derived; but for legacy reasons, we need to allow it
+                // since the API schema does not contain certain filters for
+                // derived fields on interfaces that it would for
+                // non-derived fields
+                let derived_from = field.derived_from().map(Word::from);
+                Field::new(schema, &field.name, &field.field_type, derived_from)
+            })
             .collect();
         let name = pool
             .lookup(&interface_type.name)
@@ -389,12 +579,24 @@ impl InterfaceType {
             .first()
             .map(|obj_type| IdType::try_from(obj_type).expect("validation caught any issues here"))
             .unwrap_or(IdType::String);
+        let implementers = implementers
+            .iter()
+            .map(|obj_type| {
+                pool.lookup(&obj_type.name)
+                    .expect("object type names have been interned")
+            })
+            .collect();
         Self {
             name,
             id_type,
             fields,
+            implementers,
         }
     }
+
+    fn field(&self, name: &str) -> Option<&Field> {
+        self.fields.iter().find(|field| field.name == name)
+    }
 }
 
 #[derive(Debug, PartialEq)]
@@ -493,7 +695,7 @@ pub enum AggregationInterval {
 }
 
 impl AggregationInterval {
-    fn as_str(&self) -> &'static str {
+    pub fn as_str(&self) -> &'static str {
         match self {
             AggregationInterval::Hour => "hour",
             AggregationInterval::Day => "day",
@@ -526,6 +728,12 @@ impl AggregationInterval {
     }
 }
 
+impl std::fmt::Display for AggregationInterval {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
 #[test]
 fn buckets() {
     // 2006-07-16 07:40Z
@@ -594,40 +802,26 @@ impl AggregationMapping {
     }
 }
 
-#[derive(Clone, PartialEq, Debug)]
-pub struct Arg {
-    pub name: Word,
-    pub value_type: ValueType,
-}
-
-impl Arg {
-    fn new(name: Word, src_type: &s::ObjectType) -> Self {
-        let value_type = src_type
-            .field(&name)
-            .unwrap()
-            .field_type
-            .value_type()
-            .unwrap();
-        Self { name, value_type }
-    }
-}
+/// The `@aggregate` annotation in an aggregation. The annotation controls
+/// how values from the source table are aggregated
 #[derive(PartialEq, Debug)]
 pub struct Aggregate {
+    /// The name of the aggregate field in the aggregation
     pub name: Word,
+    /// The function used to aggregate the values
     pub func: AggregateFn,
-    pub arg: Option<Arg>,
+    /// The field to aggregate in the source table
+    pub arg: Word,
+    /// The type of the field `name` in the aggregation
     pub field_type: s::Type,
+    /// The `ValueType` corresponding to `field_type`
     pub value_type: ValueType,
+    /// Whether the aggregation is cumulative
+    pub cumulative: bool,
 }
 
 impl Aggregate {
-    fn new(
-        _schema: &Schema,
-        src_type: &s::ObjectType,
-        name: &str,
-        field_type: &s::Type,
-        dir: &s::Directive,
-    ) -> Self {
+    fn new(schema: &Schema, name: &str, field_type: &s::Type, dir: &s::Directive) -> Self {
         let func = dir
             .argument("fn")
             .unwrap()
@@ -635,27 +829,40 @@ impl Aggregate {
             .unwrap()
             .parse()
             .unwrap();
+        // The only aggregation function we have that doesn't take an
+        // argument is `count`; we just pretend that the user wanted to
+        // `count(id)`. When we form a query, we ignore the argument for
+        // `count`
         let arg = dir
             .argument("arg")
             .map(|arg| Word::from(arg.as_str().unwrap()))
-            .map(|arg| Arg::new(arg, src_type));
+            .unwrap_or_else(|| ID.clone());
+        let cumulative = dir
+            .argument(kw::CUMULATIVE)
+            .map(|arg| match arg {
+                Value::Boolean(b) => *b,
+                _ => unreachable!("validation ensures this is a boolean"),
+            })
+            .unwrap_or(false);
+
         Aggregate {
             name: Word::from(name),
             func,
             arg,
+            cumulative,
             field_type: field_type.clone(),
-            value_type: field_type.get_base_type().parse().unwrap(),
+            value_type: Field::scalar_value_type(schema, field_type),
         }
     }
 
     /// The field needed for the finalised aggregation for hourly/daily
     /// values
-    fn as_agg_field(&self) -> Field {
+    pub fn as_agg_field(&self) -> Field {
         Field {
             name: self.name.clone(),
             field_type: self.field_type.clone(),
             value_type: self.value_type,
-            is_derived: false,
+            derived_from: None,
         }
     }
 }
@@ -686,21 +893,18 @@ impl Aggregation {
             .unwrap()
             .as_str()
             .unwrap();
-        let src_type = schema.document.get_object_type_definition(source).unwrap();
         let source = pool.lookup(source).unwrap();
         let fields: Box<[_]> = agg_type
             .fields
             .iter()
             .filter(|field| field.find_directive(kw::AGGREGATE).is_none())
-            .map(|field| Field::new(schema, &field.name, &field.field_type, false))
+            .map(|field| Field::new(schema, &field.name, &field.field_type, None))
             .collect();
         let aggregates: Box<[_]> = agg_type
             .fields
             .iter()
             .filter_map(|field| field.find_directive(kw::AGGREGATE).map(|dir| (field, dir)))
-            .map(|(field, dir)| {
-                Aggregate::new(schema, src_type, &field.name, &field.field_type, dir)
-            })
+            .map(|(field, dir)| Aggregate::new(schema, &field.name, &field.field_type, dir))
             .collect();
 
         let obj_types = intervals
@@ -716,7 +920,9 @@ impl Aggregation {
                         .cloned()
                         .chain(aggregates.iter().map(Aggregate::as_agg_field))
                         .collect(),
-                    immutable: true,
+                    mutability: ObjectMutability::Immutable {
+                        skip_duplicates: false,
+                    },
                     aggregation: Some(name),
                     timeseries: false,
                     interfaces: Box::new([]),
@@ -754,10 +960,23 @@ impl Aggregation {
         self.obj_types.iter().any(|obj_type| obj_type.name == atom)
     }
 
+    fn aggregated_type(&self, atom: Atom) -> Option<&ObjectType> {
+        self.obj_types.iter().find(|obj_type| obj_type.name == atom)
+    }
+
     pub fn dimensions(&self) -> impl Iterator<Item = &Field> {
         self.fields
-            .into_iter()
-            .filter(|field| &field.name != &*ID && field.name != kw::TIMESTAMP)
+            .iter()
+            .filter(|field| field.name != *ID && field.name != kw::TIMESTAMP)
+    }
+
+    fn object_type(&self, interval: AggregationInterval) -> Option<&ObjectType> {
+        let pos = self.intervals.iter().position(|i| *i == interval)?;
+        Some(&self.obj_types[pos])
+    }
+
+    fn field(&self, name: &str) -> Option<&Field> {
+        self.fields.iter().find(|field| field.name == name)
     }
 }
 
@@ -772,14 +991,7 @@ pub struct Inner {
     pool: Arc<AtomPool>,
     /// A list of all timeseries types by interval
     agg_mappings: Box<[AggregationMapping]>,
-}
-
-impl CheapClone for InputSchema {
-    fn cheap_clone(&self) -> Self {
-        InputSchema {
-            inner: self.inner.cheap_clone(),
-        }
-    }
+    spec_version: Version,
 }
 
 impl InputSchema {
@@ -792,7 +1004,7 @@ impl InputSchema {
                 .iter()
                 .enumerate()
                 .filter_map(|(idx, ti)| ti.aggregation().map(|agg_type| (idx, agg_type)))
-                .map(|(aggregation, agg_type)| {
+                .flat_map(|(aggregation, agg_type)| {
                     agg_type
                         .intervals
                         .iter()
@@ -803,7 +1015,6 @@ impl InputSchema {
                             agg_type,
                         })
                 })
-                .flatten()
                 .collect();
             mappings.sort();
             mappings.into_boxed_slice()
@@ -867,6 +1078,7 @@ impl InputSchema {
                 enum_map,
                 pool,
                 agg_mappings,
+                spec_version: spec_version.clone(),
             }),
         })
     }
@@ -878,6 +1090,21 @@ impl InputSchema {
         Self::parse(LATEST_VERSION, raw, id)
     }
 
+    pub fn validate(
+        spec_version: &Version,
+        raw: &str,
+        id: DeploymentHash,
+    ) -> Vec<SchemaValidationError> {
+        let schema = match Schema::parse(raw, id.clone()) {
+            Ok(schema) => schema,
+            Err(err) => return vec![SchemaValidationError::InvalidSchema(err.to_string())],
+        };
+        match validations::validate(spec_version, &schema) {
+            Ok(_) => vec![],
+            Err(errors) => errors,
+        }
+    }
+
     /// Convenience for tests to construct an `InputSchema`
     ///
     /// # Panics
@@ -898,7 +1125,7 @@ impl InputSchema {
     /// `InputSchema`
     pub fn api_schema(&self) -> Result<ApiSchema, anyhow::Error> {
         let mut schema = self.inner.schema.clone();
-        schema.document = api_schema(&self.inner.schema)?;
+        schema.document = api_schema(self)?;
         schema.add_subgraph_id_directives(schema.id.clone());
         ApiSchema::from_api_schema(schema)
     }
@@ -935,7 +1162,7 @@ impl InputSchema {
             .inner
             .schema
             .document
-            .get_object_type_definition(key.entity_type.as_str())
+            .get_object_type_definition(key.entity_type.typename())
             .ok_or_else(|| field_err(key, "unknown entity type"))?
             .field(&key.entity_field)
             .ok_or_else(|| field_err(key, "unknown field"))?;
@@ -957,9 +1184,9 @@ impl InputSchema {
 
     /// Return the `TypeInfo` for the type with name `atom`. For object and
     /// interface types, `atom` must be the name of the type. For
-    /// aggregations, `atom` must be the name of one of the object types
-    /// that are part of the aggregation. If `atom` is the name of the
-    /// aggregation itself, this returns an `Err`
+    /// aggregations, `atom` must be either the name of the aggregation or
+    /// the name of one of the object types that are part of the
+    /// aggregation.
     fn type_info(&self, atom: Atom) -> Result<&TypeInfo, Error> {
         for ti in self.inner.type_infos.iter() {
             match ti {
@@ -974,7 +1201,7 @@ impl InputSchema {
                     }
                 }
                 TypeInfo::Aggregation(agg_type) => {
-                    if agg_type.has_object_type(atom) {
+                    if agg_type.name == atom || agg_type.has_object_type(atom) {
                         return Ok(ti);
                     }
                 }
@@ -1012,6 +1239,13 @@ impl InputSchema {
             .unwrap_or(false)
     }
 
+    pub(in crate::schema) fn skip_duplicates(&self, entity_type: Atom) -> bool {
+        self.type_info(entity_type)
+            .ok()
+            .map(|ti| ti.skip_duplicates())
+            .unwrap_or(false)
+    }
+
     /// Return true if `type_name` is the name of an object or interface type
     pub fn is_reference(&self, type_name: &str) -> bool {
         self.inner
@@ -1031,12 +1265,22 @@ impl InputSchema {
         obj_type.interfaces().map(|intf| {
             let atom = self.inner.pool.lookup(intf).unwrap();
             match self.type_info(atom).unwrap() {
-                TypeInfo::Interface(ref intf_type) => intf_type,
+                TypeInfo::Interface(intf_type) => intf_type,
                 _ => unreachable!("expected `{intf}` to refer to an interface"),
             }
         })
     }
 
+    fn implementers<'a>(
+        &'a self,
+        interface: &'a InterfaceType,
+    ) -> impl Iterator<Item = &'a ObjectType> {
+        interface
+            .implementers
+            .iter()
+            .map(|atom| self.object_type(*atom).unwrap())
+    }
+
     /// Return a list of all entity types that implement one of the
     /// interfaces that `entity_type` implements
     pub(in crate::schema) fn share_interfaces(
@@ -1056,7 +1300,7 @@ impl InputSchema {
         };
         Ok(obj_type
             .shared_interfaces
-            .into_iter()
+            .iter()
             .map(|atom| EntityType::new(self.cheap_clone(), *atom))
             .collect())
     }
@@ -1084,6 +1328,42 @@ impl InputSchema {
         }
     }
 
+    fn types_with_kind(&self, kind: TypeKind) -> impl Iterator<Item = (&str, &TypeInfo)> {
+        self.inner
+            .type_infos
+            .iter()
+            .filter(move |ti| ti.kind() == kind)
+            .map(|ti| {
+                let name = self.inner.pool.get(ti.name()).unwrap();
+                (name, ti)
+            })
+    }
+
+    /// Return a list of all object types, i.e., types defined with an
+    /// `@entity` annotation. This does not include the type for the PoI
+    pub(in crate::schema) fn object_types(&self) -> impl Iterator<Item = (&str, &ObjectType)> {
+        self.types_with_kind(TypeKind::Object)
+            .filter(|(name, _)| {
+                // Filter out the POI object type
+                name != &POI_OBJECT
+            })
+            .filter_map(|(name, ti)| ti.object_type().map(|obj| (name, obj)))
+    }
+
+    pub(in crate::schema) fn interface_types(
+        &self,
+    ) -> impl Iterator<Item = (&str, &InterfaceType)> {
+        self.types_with_kind(TypeKind::Interface)
+            .filter_map(|(name, ti)| ti.interface_type().map(|intf| (name, intf)))
+    }
+
+    pub(in crate::schema) fn aggregation_types(
+        &self,
+    ) -> impl Iterator<Item = (&str, &Aggregation)> {
+        self.types_with_kind(TypeKind::Aggregation)
+            .filter_map(|(name, ti)| ti.aggregation().map(|intf| (name, intf)))
+    }
+
     /// Return a list of the names of all enum types
     pub fn enum_types(&self) -> impl Iterator<Item = &str> {
         self.inner.enum_map.names()
@@ -1099,6 +1379,18 @@ impl InputSchema {
         self.inner.enum_map.values(name)
     }
 
+    pub fn immutable_entities<'a>(&'a self) -> impl Iterator<Item = EntityType> + 'a {
+        self.inner
+            .type_infos
+            .iter()
+            .filter_map(|ti| match ti {
+                TypeInfo::Object(obj_type) => Some(obj_type),
+                TypeInfo::Interface(_) | TypeInfo::Aggregation(_) => None,
+            })
+            .filter(|obj_type| matches!(obj_type.mutability, ObjectMutability::Immutable { .. }))
+            .map(|obj_type| EntityType::new(self.cheap_clone(), obj_type.name))
+    }
+
     /// Return a list of the entity types defined in the schema, i.e., the
     /// types that have a `@entity` annotation. This does not include the
     /// type for the PoI
@@ -1133,6 +1425,13 @@ impl InputSchema {
         self.inner.agg_mappings.iter()
     }
 
+    pub fn has_bytes_as_ids(&self) -> bool {
+        self.inner
+            .type_infos
+            .iter()
+            .any(|ti| ti.id_type() == Some(store::IdType::Bytes))
+    }
+
     pub fn has_aggregations(&self) -> bool {
         self.inner
             .type_infos
@@ -1140,6 +1439,14 @@ impl InputSchema {
             .any(|ti| matches!(ti, TypeInfo::Aggregation(_)))
     }
 
+    pub fn aggregation_names(&self) -> impl Iterator<Item = &str> {
+        self.inner
+            .type_infos
+            .iter()
+            .filter_map(TypeInfo::aggregation)
+            .map(|agg_type| self.inner.pool.get(agg_type.name).unwrap())
+    }
+
     pub fn entity_fulltext_definitions(
         &self,
         entity: &str,
@@ -1157,12 +1464,7 @@ impl InputSchema {
             .filter(|directive| match directive.argument("include") {
                 Some(Value::List(includes)) if !includes.is_empty() => {
                     includes.iter().any(|include| match include {
-                        Value::Object(include) => match include.get("entity") {
-                            Some(Value::String(fulltext_entity)) if fulltext_entity == entity => {
-                                true
-                            }
-                            _ => false,
-                        },
+                        Value::Object(include) => matches!(include.get("entity"), Some(Value::String(fulltext_entity)) if fulltext_entity == entity),
                         _ => false,
                     })
                 }
@@ -1256,8 +1558,102 @@ impl InputSchema {
         }
     }
 
-    pub(in crate::schema) fn type_kind(&self, atom: Atom) -> Option<TypeKind> {
-        self.type_info(atom).ok().map(|ti| ti.kind())
+    /// For the `name` of a type declared in the input schema, return
+    /// whether it is a normal object, declared with `@entity`, an
+    /// interface, or an aggregation. If there is no type `name`, or it is
+    /// not one of these three kinds, return `None`
+    pub fn kind_of_declared_type(&self, name: &str) -> Option<TypeKind> {
+        let name = self.inner.pool.lookup(name)?;
+        self.inner.type_infos.iter().find_map(|ti| {
+            if ti.name() == name {
+                Some(ti.kind())
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Return `true` if `atom` is an object type, i.e., a type that is
+    /// declared with an `@entity` directive in the input schema. This
+    /// specifically excludes interfaces and aggregations.
+    pub(crate) fn is_object_type(&self, atom: Atom) -> bool {
+        self.inner.type_infos.iter().any(|ti| match ti {
+            TypeInfo::Object(obj_type) => obj_type.name == atom,
+            _ => false,
+        })
+    }
+
+    pub(crate) fn typename(&self, atom: Atom) -> &str {
+        let name = self.type_info(atom).unwrap().name();
+        self.inner.pool.get(name).unwrap()
+    }
+
+    pub(in crate::schema) fn field(&self, type_name: Atom, name: &str) -> Option<&Field> {
+        let ti = self.type_info(type_name).ok()?;
+        match ti {
+            TypeInfo::Object(obj_type) => obj_type.field(name),
+            TypeInfo::Aggregation(agg_type) => {
+                if agg_type.name == type_name {
+                    agg_type.field(name)
+                } else {
+                    agg_type
+                        .aggregated_type(type_name)
+                        .and_then(|obj_type| obj_type.field(name))
+                }
+            }
+            TypeInfo::Interface(intf_type) => intf_type.field(name),
+        }
+    }
+
+    /// Resolve the given name and interval into an object or interface
+    /// type. If `name` refers to an object or interface type, return that
+    /// regardless of the value of `interval`. If `name` refers to an
+    /// aggregation, return the object type of that aggregation for the
+    /// given `interval`
+    pub fn object_or_interface(
+        &self,
+        name: &str,
+        interval: Option<AggregationInterval>,
+    ) -> Option<ObjectOrInterface<'_>> {
+        let name = self.inner.pool.lookup(name)?;
+        let ti = self.inner.type_infos.iter().find(|ti| ti.name() == name)?;
+        match (ti, interval) {
+            (TypeInfo::Object(obj_type), _) => Some(ObjectOrInterface::Object(self, obj_type)),
+            (TypeInfo::Interface(intf_type), _) => {
+                Some(ObjectOrInterface::Interface(self, intf_type))
+            }
+            (TypeInfo::Aggregation(agg_type), Some(interval)) => agg_type
+                .object_type(interval)
+                .map(|object_type| ObjectOrInterface::Object(self, object_type)),
+            (TypeInfo::Aggregation(_), None) => None,
+        }
+    }
+
+    /// Return an `EntityType` that either references the object type `name`
+    /// or, if `name` references an aggregation, return the object type of
+    /// that aggregation for the given `interval`
+    pub fn object_or_aggregation(
+        &self,
+        name: &str,
+        interval: Option<AggregationInterval>,
+    ) -> Option<EntityType> {
+        let name = self.inner.pool.lookup(name)?;
+        let ti = self.inner.type_infos.iter().find(|ti| ti.name() == name)?;
+        let obj_type = match (ti, interval) {
+            (TypeInfo::Object(obj_type), _) => Some(obj_type),
+            (TypeInfo::Interface(_), _) => None,
+            (TypeInfo::Aggregation(agg_type), Some(interval)) => agg_type.object_type(interval),
+            (TypeInfo::Aggregation(_), None) => None,
+        }?;
+        Some(EntityType::new(self.cheap_clone(), obj_type.name))
+    }
+
+    /// How the values for the VID field are generated.
+    /// When this is `false`, this subgraph uses the old way of autoincrementing `vid` in the database.
+    /// When it is `true`, `graph-node` sets the `vid` explicitly to a number based on block number
+    /// and the order in which entities are written, and comparing by `vid` will order entities by that order.
+    pub fn strict_vid_order(&self) -> bool {
+        self.inner.spec_version >= SPEC_VERSION_1_3_0
     }
 }
 
@@ -1266,12 +1662,14 @@ impl InputSchema {
 fn atom_pool(document: &s::Document) -> AtomPool {
     let mut pool = AtomPool::new();
 
-    pool.intern(&*ID);
+    pool.intern(&ID);
     // Name and attributes of PoI entity type
     pool.intern(POI_OBJECT);
     pool.intern(POI_DIGEST);
     pool.intern(POI_BLOCK_TIME);
 
+    pool.intern(VID_FIELD);
+
     for definition in &document.definitions {
         match definition {
             s::Definition::TypeDefinition(typedef) => match typedef {
@@ -1329,7 +1727,7 @@ fn atom_pool(document: &s::Document) -> AtomPool {
     }
 
     for object_type in document.get_object_type_definitions() {
-        for defn in InputSchema::fulltext_definitions(&document, &object_type.name).unwrap() {
+        for defn in InputSchema::fulltext_definitions(document, &object_type.name).unwrap() {
             pool.intern(defn.name.as_str());
         }
     }
@@ -1341,29 +1739,28 @@ fn atom_pool(document: &s::Document) -> AtomPool {
 mod validations {
     use std::{collections::HashSet, str::FromStr};
 
-    use inflector::Inflector;
     use itertools::Itertools;
     use semver::Version;
 
     use crate::{
         data::{
             graphql::{
-                ext::DirectiveFinder, DirectiveExt, DocumentExt, ObjectTypeExt, TypeExt, ValueExt,
+                DirectiveExt, DocumentExt, ObjectTypeExt, TypeExt, ValueExt,
+                ext::{DirectiveFinder, FieldExt},
             },
-            store::{IdType, ValueType, ID},
+            store::{ID, IdType, ValueType},
             subgraph::SPEC_VERSION_1_1_0,
         },
         prelude::s,
         schema::{
-            input_schema::{kw, AggregateFn, AggregationInterval},
-            FulltextAlgorithm, FulltextLanguage, Schema as BaseSchema, SchemaValidationError,
-            SchemaValidationError as Err, Strings, SCHEMA_TYPE_NAME,
+            FulltextAlgorithm, FulltextLanguage, SCHEMA_TYPE_NAME, Schema as BaseSchema,
+            SchemaValidationError, SchemaValidationError as Err, Strings,
+            input::{AggregateFn, AggregationInterval, kw, sqlexpr},
         },
     };
 
     /// Helper struct for validations
     struct Schema<'a> {
-        #[allow(dead_code)]
         spec_version: &'a Version,
         schema: &'a BaseSchema,
         subgraph_schema_type: Option<&'a s::ObjectType>,
@@ -1439,9 +1836,7 @@ mod validations {
                 if subgraph_schema_type
                     .directives
                     .iter()
-                    .filter(|directive| !directive.name.eq("fulltext"))
-                    .next()
-                    .is_some()
+                    .any(|directive| !directive.name.eq("fulltext"))
                 {
                     Some(SchemaValidationError::InvalidSchemaTypeDirectives)
                 } else {
@@ -1484,9 +1879,8 @@ mod validations {
             // to create the field names in `graphql::schema::api::query_fields_for_type()`.
             if self.entity_types.iter().any(|typ| {
                 typ.fields.iter().any(|field| {
-                    name == &field.name.as_str().to_camel_case()
-                        || name == &field.name.to_plural().to_camel_case()
-                        || field.name.eq(name)
+                    let (singular, plural) = field.camel_cased_names();
+                    name == &singular || name == &plural || field.name.eq(name)
                 })
             }) {
                 return vec![SchemaValidationError::FulltextNameCollision(
@@ -1581,7 +1975,7 @@ mod validations {
                             .find(|typ| typ.name[..].eq(entity))
                         {
                             None => {
-                                return vec![SchemaValidationError::FulltextIncludedEntityNotFound]
+                                return vec![SchemaValidationError::FulltextIncludedEntityNotFound];
                             }
                             Some(t) => t,
                         };
@@ -1649,13 +2043,30 @@ mod validations {
                 })
         }
 
-        /// The `@entity` direactive accepts two flags `immutable` and
+        /// The `@entity` directive accepts two flags `immutable` and
         /// `timeseries`, and when `timeseries` is `true`, `immutable` can
         /// not be `false`.
         ///
         /// For timeseries, also check that there is a `timestamp` field of
-        /// type `Int8`
+        /// type `Int8` and that the `id` field has type `Int8`
         fn validate_entity_directives(&self) -> Vec<SchemaValidationError> {
+            fn id_type_is_int8(object_type: &s::ObjectType) -> Option<SchemaValidationError> {
+                let field = match object_type.field(&ID) {
+                    Some(field) => field,
+                    None => {
+                        return Some(Err::IdFieldMissing(object_type.name.to_owned()));
+                    }
+                };
+
+                match field.field_type.value_type() {
+                    Ok(ValueType::Int8) => None,
+                    Ok(_) | Err(_) => Some(Err::IllegalIdType(format!(
+                        "Timeseries `{}` must have an `id` field of type `Int8`",
+                        object_type.name
+                    ))),
+                }
+            }
+
             fn bool_arg(
                 dir: &s::Directive,
                 name: &str,
@@ -1682,13 +2093,23 @@ mod validations {
                         Ok(b) => b.unwrap_or(timeseries),
                         Err(e) => return Some(e),
                     };
+                    let skip_duplicates = match bool_arg(dir, kw::SKIP_DUPLICATES) {
+                        Ok(b) => b.unwrap_or(false),
+                        Err(e) => return Some(e),
+                    };
+                    if skip_duplicates && !immutable {
+                        return Some(SchemaValidationError::SkipDuplicatesRequiresImmutable(
+                            object_type.name.clone(),
+                        ));
+                    }
                     if timeseries {
                         if !immutable {
                             Some(SchemaValidationError::MutableTimeseries(
                                 object_type.name.clone(),
                             ))
                         } else {
-                            Self::valid_timestamp_field(object_type)
+                            id_type_is_int8(object_type)
+                                .or_else(|| Self::valid_timestamp_field(object_type))
                         }
                     } else {
                         None
@@ -1703,7 +2124,7 @@ mod validations {
             self.entity_types
                 .iter()
                 .fold(vec![], |mut errors, object_type| {
-                    match object_type.field(&*ID) {
+                    match object_type.field(&ID) {
                         None => errors.push(SchemaValidationError::IdFieldMissing(
                             object_type.name.clone(),
                         )),
@@ -1883,7 +2304,7 @@ mod validations {
                             object_type,
                             &field.name,
                             "the @derivedFrom `field` argument must be a string",
-                        ))
+                        ));
                     }
                 };
 
@@ -1918,7 +2339,7 @@ mod validations {
                 // when we query, and just assume that that's ok.
                 let target_field_type = target_field.field_type.get_base_type();
                 if target_field_type != object_type.name
-                    && &target_field.name != ID.as_str()
+                    && target_field.name != ID.as_str()
                     && !interface_types
                         .iter()
                         .any(|iface| target_field_type.eq(iface.as_str()))
@@ -1941,11 +2362,11 @@ mod validations {
                     let valid_types = valid_types.join(", ");
 
                     let msg = format!(
-                    "field `{tf}` on type `{tt}` must have one of the following types: {valid_types}",
-                    tf = target_field.name,
-                    tt = target_type_name,
-                    valid_types = valid_types,
-                );
+                        "field `{tf}` on type `{tt}` must have one of the following types: {valid_types}",
+                        tf = target_field.name,
+                        tt = target_type_name,
+                        valid_types = valid_types,
+                    );
                     return Err(invalid(object_type, &field.name, &msg));
                 }
             }
@@ -1957,7 +2378,7 @@ mod validations {
                 let id_types: HashSet<&str> = HashSet::from_iter(
                     obj_types
                         .iter()
-                        .filter_map(|obj_type| obj_type.field(&*ID))
+                        .filter_map(|obj_type| obj_type.field(&ID))
                         .map(|f| f.field_type.get_base_type())
                         .map(|name| if name == "ID" { "String" } else { name }),
                 );
@@ -2003,27 +2424,59 @@ mod validations {
                 }
             }
 
-            fn aggregate_fields_are_numbers(agg_type: &s::ObjectType, errors: &mut Vec<Err>) {
+            fn aggregate_field_types(
+                schema: &Schema,
+                agg_type: &s::ObjectType,
+                errors: &mut Vec<Err>,
+            ) {
+                fn is_first_last(agg_directive: &s::Directive) -> bool {
+                    match agg_directive.argument(kw::FUNC) {
+                        Some(s::Value::Enum(func) | s::Value::String(func)) => {
+                            func == AggregateFn::First.as_str()
+                                || func == AggregateFn::Last.as_str()
+                        }
+                        _ => false,
+                    }
+                }
+
                 let errs = agg_type
                     .fields
                     .iter()
-                    .filter(|field| field.find_directive(kw::AGGREGATE).is_some())
-                    .map(|field| match field.field_type.value_type() {
-                        Ok(vt) => {
-                            if vt.is_numeric() {
-                                Ok(())
-                            } else {
-                                Err(Err::NonNumericAggregate(
+                    .filter_map(|field| {
+                        field
+                            .find_directive(kw::AGGREGATE)
+                            .map(|agg_directive| (field, agg_directive))
+                    })
+                    .map(|(field, agg_directive)| {
+                        let is_first_last = is_first_last(agg_directive);
+
+                        match field.field_type.value_type() {
+                            Ok(value_type) if value_type.is_numeric() => Ok(()),
+                            Ok(ValueType::Bytes | ValueType::String) if is_first_last => Ok(()),
+                            Ok(_) if is_first_last => Err(Err::InvalidFirstLastAggregate(
+                                agg_type.name.clone(),
+                                field.name.clone(),
+                            )),
+                            Ok(_) => Err(Err::NonNumericAggregate(
+                                agg_type.name.to_owned(),
+                                field.name.to_owned(),
+                            )),
+                            Err(_) => {
+                                if is_first_last
+                                    && schema.entity_types.iter().any(|entity_type| {
+                                        entity_type.name.eq(field.field_type.get_base_type())
+                                    })
+                                {
+                                    return Ok(());
+                                }
+
+                                Err(Err::FieldTypeUnknown(
                                     agg_type.name.to_owned(),
                                     field.name.to_owned(),
+                                    field.field_type.get_base_type().to_owned(),
                                 ))
                             }
                         }
-                        Err(_) => Err(Err::FieldTypeUnknown(
-                            agg_type.name.to_owned(),
-                            field.name.to_owned(),
-                            field.field_type.get_base_type().to_owned(),
-                        )),
                     })
                     .filter_map(|err| err.err());
                 errors.extend(errs);
@@ -2031,10 +2484,10 @@ mod validations {
 
             /// * `source` is an existing timeseries type
             /// * all non-aggregate fields are also fields on the `source`
-            /// type and have the same type
+            ///   type and have the same type
             /// * `arg` for each `@aggregate` is a numeric type in the
-            /// timeseries, coercible to the type of the field (e.g. `Int ->
-            /// BigDecimal`, but not `BigInt -> Int8`)
+            ///   timeseries, coercible to the type of the field (e.g. `Int
+            ///   -> BigDecimal`, but not `BigInt -> Int8`)
             fn aggregate_directive(
                 schema: &Schema,
                 agg_type: &s::ObjectType,
@@ -2146,46 +2599,84 @@ mod validations {
                                     }
                                 }
                             };
-                            let arg_type = match source.field(arg) {
-                                Some(arg_field) => match arg_field.field_type.value_type() {
-                                    Ok(arg_type) if arg_type.is_numeric() => arg_type,
-                                    Ok(_) | Err(_) => {
-                                        errors.push(Err::AggregationNonNumericArg(
-                                            agg_type.name.to_owned(),
-                                            field.name.to_owned(),
-                                            source.name.to_owned(),
-                                            arg.to_owned(),
-                                        ));
-                                        continue;
-                                    }
-                                },
-                                None => {
-                                    errors.push(Err::AggregationUnknownArg(
+                            match agg.argument(kw::CUMULATIVE) {
+                                Some(s::Value::Boolean(_)) | None => { /* ok */ }
+                                Some(_) => {
+                                    errors.push(Err::AggregationInvalidCumulative(
                                         agg_type.name.to_owned(),
                                         field.name.to_owned(),
-                                        arg.to_owned(),
                                     ));
                                     continue;
                                 }
                             };
-                            let field_type = match field.field_type.value_type() {
-                                Ok(field_type) => field_type,
-                                Err(_) => {
-                                    errors.push(Err::NonNumericAggregate(
-                                        agg_type.name.to_owned(),
-                                        field.name.to_owned(),
-                                    ));
-                                    continue;
+
+                            let is_first_last =
+                                matches!(func, AggregateFn::First | AggregateFn::Last);
+
+                            // It would be nicer to use a proper struct here
+                            // and have that implement
+                            // `sqlexpr::ExprVisitor` but we need access to
+                            // a bunch of local variables that would make
+                            // setting up that struct a bit awkward, so we
+                            // use a closure instead
+                            let check_ident = |ident: &str| -> Result<(), SchemaValidationError> {
+                                let arg_type = match source.field(ident) {
+                                    Some(arg_field) => match arg_field.field_type.value_type() {
+                                        Ok(arg_type) if arg_type.is_numeric() => arg_type,
+                                        Ok(ValueType::Bytes | ValueType::String)
+                                            if is_first_last =>
+                                        {
+                                            return Ok(());
+                                        }
+                                        Err(_)
+                                            if is_first_last
+                                                && arg_field.field_type.get_base_type()
+                                                    == field.field_type.get_base_type() =>
+                                        {
+                                            return Ok(());
+                                        }
+                                        Ok(_) | Err(_) => {
+                                            return Err(Err::AggregationNonNumericArg(
+                                                agg_type.name.to_owned(),
+                                                field.name.to_owned(),
+                                                source.name.to_owned(),
+                                                arg.to_owned(),
+                                            ));
+                                        }
+                                    },
+                                    None => {
+                                        return Err(Err::AggregationUnknownArg(
+                                            agg_type.name.to_owned(),
+                                            field.name.to_owned(),
+                                            arg.to_owned(),
+                                        ));
+                                    }
+                                };
+
+                                match field.field_type.value_type() {
+                                    Ok(field_type) if field_type.is_numeric() => {
+                                        if arg_type > field_type {
+                                            return Err(Err::AggregationNonMatchingArg(
+                                                agg_type.name.to_owned(),
+                                                field.name.to_owned(),
+                                                arg.to_owned(),
+                                                arg_type.to_str().to_owned(),
+                                                field_type.to_str().to_owned(),
+                                            ));
+                                        }
+                                    }
+                                    Ok(_) | Err(_) => {
+                                        return Err(Err::NonNumericAggregate(
+                                            agg_type.name.to_owned(),
+                                            field.name.to_owned(),
+                                        ));
+                                    }
                                 }
+
+                                Ok(())
                             };
-                            if arg_type > field_type {
-                                errors.push(Err::AggregationNonMatchingArg(
-                                    agg_type.name.to_owned(),
-                                    field.name.to_owned(),
-                                    arg.to_owned(),
-                                    arg_type.to_str().to_owned(),
-                                    field_type.to_str().to_owned(),
-                                ));
+                            if let Err(mut errs) = sqlexpr::parse(arg, check_ident) {
+                                errors.append(&mut errs);
                             }
                         }
                         None => {
@@ -2254,7 +2745,7 @@ mod validations {
                     return;
                 }
                 for interval in intervals {
-                    if let Err(_) = interval.parse::<AggregationInterval>() {
+                    if interval.parse::<AggregationInterval>().is_err() {
                         errors.push(Err::AggregationInvalidInterval(
                             agg_type.name.to_owned(),
                             interval.to_owned(),
@@ -2278,7 +2769,7 @@ mod validations {
                     errors.push(err);
                 }
                 no_derived_fields(agg_type, &mut errors);
-                aggregate_fields_are_numbers(agg_type, &mut errors);
+                aggregate_field_types(self, agg_type, &mut errors);
                 aggregate_directive(self, agg_type, &mut errors);
                 // check timeseries directive has intervals and args
                 aggregation_intervals(agg_type, &mut errors);
@@ -2286,8 +2777,7 @@ mod validations {
             errors
         }
 
-        /// Aggregations must have a `timestamp` field of type Int8
-        /// FIXME: introduce a timestamp type and use that
+        /// Aggregations must have a `timestamp` field of type `Timestamp`
         fn valid_timestamp_field(agg_type: &s::ObjectType) -> Option<Err> {
             let field = match agg_type.field(kw::TIMESTAMP) {
                 Some(field) => field,
@@ -2297,7 +2787,7 @@ mod validations {
             };
 
             match field.field_type.value_type() {
-                Ok(ValueType::Int8) => None,
+                Ok(ValueType::Timestamp) => None,
                 Ok(_) | Err(_) => Some(Err::InvalidTimestampType(
                     agg_type.name.to_owned(),
                     field.field_type.get_base_type().to_owned(),
@@ -2371,9 +2861,9 @@ mod validations {
                     BaseSchema::parse(&schema, DeploymentHash::new("dummy").unwrap()).unwrap();
                 let res = validate(&schema);
                 if ok {
-                    assert!(matches!(res, Ok(_)));
+                    assert!(res.is_ok());
                 } else {
-                    assert!(matches!(res, Err(_)));
+                    assert!(res.is_err());
                     assert!(matches!(
                         res.unwrap_err()[0],
                         SchemaValidationError::InterfaceImplementorsMixId(_, _)
@@ -2405,7 +2895,7 @@ type Account implements Address @entity { id: ID!, txn: Transaction! @derivedFro
             fn validate(field: &str, errmsg: &str) {
                 let raw = format!("type A @entity {{ id: ID!\n {} }}\n{}", field, OTHER_TYPES);
 
-                let document = graphql_parser::parse_schema(&raw)
+                let document = s::parse_schema(&raw)
                     .expect("Failed to parse raw schema")
                     .into_static();
                 let schema = BaseSchema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
@@ -2462,8 +2952,7 @@ type Account implements Address @entity { id: ID!, txn: Transaction! @derivedFro
             const ROOT_SCHEMA: &str = "
 type _Schema_ { id: ID! }";
 
-            let document =
-                graphql_parser::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
+            let document = s::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
             let schema = BaseSchema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
             let schema = Schema::new(LATEST_VERSION, &schema);
             assert_eq!(
@@ -2479,8 +2968,7 @@ type _Schema_ { id: ID! }";
             const ROOT_SCHEMA: &str = "
 type _Schema_ @illegal";
 
-            let document =
-                graphql_parser::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
+            let document = s::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
             let schema = BaseSchema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
             let schema = Schema::new(LATEST_VERSION, &schema);
             assert_eq!(
@@ -2504,8 +2992,7 @@ type A @entity {
   color: Color
 }"#;
 
-            let document =
-                graphql_parser::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
+            let document = s::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
             let schema = BaseSchema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
             let schema = Schema::new(LATEST_VERSION, &schema);
             assert_eq!(schema.validate_fields().len(), 0);
@@ -2613,7 +3100,7 @@ type Gravatar @entity {
   imageUrl: String!
 }"#;
 
-            let document = graphql_parser::parse_schema(SCHEMA).expect("Failed to parse schema");
+            let document = s::parse_schema(SCHEMA).expect("Failed to parse schema");
             let schema = BaseSchema::new(DeploymentHash::new("id1").unwrap(), document).unwrap();
             let schema = Schema::new(LATEST_VERSION, &schema);
             assert_eq!(schema.validate_fulltext_directives(), vec![]);
@@ -2672,7 +3159,6 @@ type Gravatar @entity {
             let files = {
                 let mut files = std::fs::read_dir(dir)
                     .unwrap()
-                    .into_iter()
                     .filter_map(|entry| entry.ok())
                     .map(|entry| entry.path())
                     .filter(|path| path.extension() == Some(OsString::from("graphql").as_os_str()))
@@ -2704,16 +3190,18 @@ type Gravatar @entity {
                         if errs.iter().any(|err| {
                             err.to_string().contains(&msg) || format!("{err:?}").contains(&msg)
                         }) {
-                            println!("{file_name} failed as expected: {errs:?}",)
+                            // println!("{file_name} failed as expected: {errs:?}",)
                         } else {
                             let msgs: Vec<_> = errs.iter().map(|err| err.to_string()).collect();
                             panic!(
-                                    "{file_name} failed but not with the expected error `{msg}`: {errs:?} {msgs:?}",
-                                )
+                                "{file_name} failed but not with the expected error `{msg}`: \n\
+                                    actual: {errs:?}\n\
+                                    or {msgs:?}",
+                            )
                         }
                     }
                     (true, Ok(_)) => {
-                        println!("{file_name} validated as expected")
+                        // println!("{file_name} validated as expected")
                     }
                 }
             }
@@ -2727,8 +3215,8 @@ mod tests {
         data::store::ID,
         prelude::DeploymentHash,
         schema::{
-            input_schema::{POI_DIGEST, POI_OBJECT},
             EntityType,
+            input::{POI_DIGEST, POI_OBJECT},
         },
     };
 
@@ -2757,13 +3245,13 @@ mod tests {
       type HippoData @entity(timeseries: true) {
         id: Int8!
         hippo: Hippo!
-        timestamp: Int8!
+        timestamp: Timestamp!
         weight: BigDecimal!
       }
 
       type HippoStats @aggregation(intervals: ["hour"], source: "HippoData") {
         id: Int8!
-        timestamp: Int8!
+        timestamp: Timestamp!
         hippo: Hippo!
         maxWeight: BigDecimal! @aggregate(fn: "max", arg:"weight")
       }
@@ -2778,10 +3266,10 @@ mod tests {
     fn entity_type() {
         let schema = make_schema();
 
-        assert_eq!("Thing", schema.entity_type("Thing").unwrap().as_str());
+        assert_eq!("Thing", schema.entity_type("Thing").unwrap().typename());
 
         let poi = schema.entity_type(POI_OBJECT).unwrap();
-        assert_eq!(POI_OBJECT, poi.as_str());
+        assert_eq!(POI_OBJECT, poi.typename());
         assert!(poi.has_field(schema.pool().lookup(&ID).unwrap()));
         assert!(poi.has_field(schema.pool().lookup(POI_DIGEST).unwrap()));
         assert!(poi.object_type().is_ok());
diff --git a/graph/src/schema/input/sqlexpr.rs b/graph/src/schema/input/sqlexpr.rs
new file mode 100644
index 00000000000..a215c95b585
--- /dev/null
+++ b/graph/src/schema/input/sqlexpr.rs
@@ -0,0 +1,427 @@
+//! Tools for parsing SQL expressions
+use sqlparser::ast as p;
+use sqlparser::dialect::PostgreSqlDialect;
+use sqlparser::parser::{Parser as SqlParser, ParserError};
+use sqlparser::tokenizer::Tokenizer;
+
+use crate::schema::SchemaValidationError;
+
+pub(crate) trait CheckIdentFn: Fn(&str) -> Result<(), SchemaValidationError> {}
+
+impl<T> CheckIdentFn for T where T: Fn(&str) -> Result<(), SchemaValidationError> {}
+
+/// Parse a SQL expression and check that it only uses whitelisted
+/// operations and functions. The `check_ident` function is called for each
+/// identifier in the expression
+pub(crate) fn parse<F: CheckIdentFn>(
+    sql: &str,
+    check_ident: F,
+) -> Result<(), Vec<SchemaValidationError>> {
+    let mut validator = Validator {
+        check_ident,
+        errors: Vec::new(),
+    };
+    VisitExpr::visit(sql, &mut validator)
+        .map(|_| ())
+        .map_err(|()| validator.errors)
+}
+
+/// A visitor for `VistExpr` that gets called for the constructs for which
+/// we need different behavior between validation and query generation in
+/// `store/postgres/src/relational/rollup.rs`. Note that the visitor can
+/// mutate both itself (e.g., to store errors) and the expression it is
+/// visiting.
+///
+/// The error type is `()`, as the visitor is expected to record any errors
+/// internally
+pub trait ExprVisitor {
+    /// Visit an identifier (column name). Must return `Err` if the
+    /// identifier is not allowed
+    #[allow(clippy::result_unit_err)]
+    fn visit_ident(&mut self, ident: &mut p::Ident) -> Result<(), ()>;
+    /// Visit a function name. Must return `Err` if the function is not
+    /// allowed
+    #[allow(clippy::result_unit_err)]
+    fn visit_func_name(&mut self, func: &mut p::ObjectNamePart) -> Result<(), ()>;
+    /// Called when we encounter a construct that is not supported like a
+    /// subquery
+    fn not_supported(&mut self, msg: String);
+    /// Called if the SQL expression we are visiting has SQL syntax errors
+    fn parse_error(&mut self, e: sqlparser::parser::ParserError);
+}
+
+pub struct VisitExpr<'a> {
+    visitor: &'a mut dyn ExprVisitor,
+}
+
+impl<'a> VisitExpr<'a> {
+    fn nope(&mut self, construct: &str) -> Result<(), ()> {
+        self.not_supported(format!("Expressions using {construct} are not supported"))
+    }
+
+    fn illegal_function(&mut self, msg: String) -> Result<(), ()> {
+        self.not_supported(format!("Illegal function: {msg}"))
+    }
+
+    fn not_supported(&mut self, msg: String) -> Result<(), ()> {
+        self.visitor.not_supported(msg);
+        Err(())
+    }
+
+    /// Parse `sql` into an expression and traverse it, calling back into
+    /// `visitor` at the appropriate places. Return the parsed expression,
+    /// which might have been changed by the visitor, on success. On error,
+    /// return `Err(())`. The visitor will know the details of the error
+    /// since this can only happen if `visit_ident` or `visit_func_name`
+    /// returned an error, or `parse_error` or `not_supported` was called.
+    #[allow(clippy::result_unit_err)]
+    pub fn visit(sql: &str, visitor: &'a mut dyn ExprVisitor) -> Result<p::Expr, ()> {
+        let dialect = PostgreSqlDialect {};
+
+        let mut parser = SqlParser::new(&dialect);
+        let tokens = Tokenizer::new(&dialect, sql)
+            .with_unescape(true)
+            .tokenize_with_location()
+            .unwrap();
+        parser = parser.with_tokens_with_locations(tokens);
+        let mut visit = VisitExpr { visitor };
+        let mut expr = match parser.parse_expr() {
+            Ok(expr) => expr,
+            Err(e) => {
+                visitor.parse_error(e);
+                return Err(());
+            }
+        };
+        visit.visit_expr(&mut expr).map(|()| expr)
+    }
+
+    fn visit_expr(&mut self, expr: &mut p::Expr) -> Result<(), ()> {
+        use p::Expr::*;
+
+        match expr {
+            Identifier(ident) => self.visitor.visit_ident(ident),
+            BinaryOp { left, op, right } => {
+                self.check_binary_op(op)?;
+                self.visit_expr(left)?;
+                self.visit_expr(right)?;
+                Ok(())
+            }
+            UnaryOp { op, expr } => {
+                self.check_unary_op(op)?;
+                self.visit_expr(expr)?;
+                Ok(())
+            }
+            Function(func) => self.visit_func(func),
+            Value(_) => Ok(()),
+            Case {
+                operand,
+                conditions,
+                else_result,
+                case_token: _,
+                end_token: _,
+            } => {
+                if let Some(operand) = operand {
+                    self.visit_expr(operand)?;
+                }
+                for condition in conditions {
+                    self.visit_expr(&mut condition.condition)?;
+                    self.visit_expr(&mut condition.result)?;
+                }
+                if let Some(else_result) = else_result {
+                    self.visit_expr(else_result)?;
+                }
+                Ok(())
+            }
+            Cast {
+                expr,
+                data_type: _,
+                kind,
+                format: _,
+                array: _,
+            } => match kind {
+                // Cast: `CAST(<expr> as <datatype>)`
+                // DoubleColon: `<expr>::<datatype>`
+                p::CastKind::Cast | p::CastKind::DoubleColon => self.visit_expr(expr),
+                // These two are not Postgres syntax
+                p::CastKind::TryCast | p::CastKind::SafeCast => {
+                    self.nope(&format!("non-standard cast '{:?}'", kind))
+                }
+            },
+            Nested(expr) | IsFalse(expr) | IsNotFalse(expr) | IsTrue(expr) | IsNotTrue(expr)
+            | IsNull(expr) | IsNotNull(expr) => self.visit_expr(expr),
+            IsDistinctFrom(expr1, expr2) | IsNotDistinctFrom(expr1, expr2) => {
+                self.visit_expr(expr1)?;
+                self.visit_expr(expr2)?;
+                Ok(())
+            }
+            CompoundIdentifier(_) => self.nope("CompoundIdentifier"),
+            JsonAccess { .. } => self.nope("JsonAccess"),
+            IsUnknown(_) => self.nope("IsUnknown"),
+            IsNotUnknown(_) => self.nope("IsNotUnknown"),
+            InList { .. } => self.nope("InList"),
+            InSubquery { .. } => self.nope("InSubquery"),
+            InUnnest { .. } => self.nope("InUnnest"),
+            Between { .. } => self.nope("Between"),
+            Like { .. } => self.nope("Like"),
+            ILike { .. } => self.nope("ILike"),
+            SimilarTo { .. } => self.nope("SimilarTo"),
+            RLike { .. } => self.nope("RLike"),
+            AnyOp { .. } => self.nope("AnyOp"),
+            AllOp { .. } => self.nope("AllOp"),
+            Convert { .. } => self.nope("Convert"),
+            AtTimeZone { .. } => self.nope("AtTimeZone"),
+            Extract { .. } => self.nope("Extract"),
+            Ceil { .. } => self.nope("Ceil"),
+            Floor { .. } => self.nope("Floor"),
+            Position { .. } => self.nope("Position"),
+            Substring { .. } => self.nope("Substring"),
+            Trim { .. } => self.nope("Trim"),
+            Overlay { .. } => self.nope("Overlay"),
+            Collate { .. } => self.nope("Collate"),
+            TypedString { .. } => self.nope("TypedString"),
+            Exists { .. } => self.nope("Exists"),
+            Subquery(_) => self.nope("Subquery"),
+            GroupingSets(_) => self.nope("GroupingSets"),
+            Cube(_) => self.nope("Cube"),
+            Rollup(_) => self.nope("Rollup"),
+            Tuple(_) => self.nope("Tuple"),
+            Struct { .. } => self.nope("Struct"),
+            Named { .. } => self.nope("Named"),
+            Array(_) => self.nope("Array"),
+            Interval(_) => self.nope("Interval"),
+            MatchAgainst { .. } => self.nope("MatchAgainst"),
+            Wildcard(_) => self.nope("Wildcard"),
+            QualifiedWildcard(_, _) => self.nope("QualifiedWildcard"),
+            Dictionary(_) => self.nope("Dictionary"),
+            OuterJoin(_) => self.nope("OuterJoin"),
+            Prior(_) => self.nope("Prior"),
+            CompoundFieldAccess { .. } => self.nope("CompoundFieldAccess"),
+            IsNormalized { .. } => self.nope("IsNormalized"),
+            Prefixed { .. } => self.nope("Prefixed"),
+            Map(_) => self.nope("Map"),
+            Lambda(_) => self.nope("Lambda"),
+            MemberOf(_) => self.nope("MemberOf"),
+        }
+    }
+
+    fn visit_func(&mut self, func: &mut p::Function) -> Result<(), ()> {
+        let p::Function {
+            name,
+            parameters,
+            args: pargs,
+            filter,
+            null_treatment,
+            over,
+            within_group,
+            uses_odbc_syntax,
+        } = func;
+
+        if filter.is_some()
+            || null_treatment.is_some()
+            || over.is_some()
+            || !within_group.is_empty()
+            || *uses_odbc_syntax
+            || !matches!(parameters, p::FunctionArguments::None)
+        {
+            return self.illegal_function(format!("call to {name} uses an illegal feature"));
+        }
+
+        let idents = &mut name.0;
+        if idents.len() != 1 {
+            return self.illegal_function(format!(
+                "function name {name} uses a qualified name with '.'"
+            ));
+        }
+        self.visitor.visit_func_name(&mut idents[0])?;
+        match pargs {
+            p::FunctionArguments::None => { /* nothing to do */ }
+            p::FunctionArguments::Subquery(_) => {
+                return self.illegal_function(format!("call to {name} uses a subquery argument"));
+            }
+            p::FunctionArguments::List(pargs) => {
+                let p::FunctionArgumentList {
+                    duplicate_treatment,
+                    args,
+                    clauses,
+                } = pargs;
+                if duplicate_treatment.is_some() {
+                    return self
+                        .illegal_function(format!("call to {name} uses a duplicate treatment"));
+                }
+                if !clauses.is_empty() {
+                    return self.illegal_function(format!("call to {name} uses a clause"));
+                }
+                for arg in args {
+                    use p::FunctionArg::*;
+                    match arg {
+                        Named { .. } => {
+                            return self
+                                .illegal_function(format!("call to {name} uses a named argument"));
+                        }
+                        Unnamed(arg) => match arg {
+                            p::FunctionArgExpr::Expr(expr) => {
+                                self.visit_expr(expr)?;
+                            }
+                            p::FunctionArgExpr::QualifiedWildcard(_)
+                            | p::FunctionArgExpr::Wildcard
+                            | p::FunctionArgExpr::WildcardWithOptions(_) => {
+                                return self.illegal_function(format!(
+                                    "call to {name} uses a wildcard argument"
+                                ));
+                            }
+                        },
+                        ExprNamed {
+                            name: expr_name,
+                            arg: _,
+                            operator: _,
+                        } => {
+                            return self.illegal_function(format!(
+                                "call to {name} uses illegal ExprNamed {expr_name}"
+                            ));
+                        }
+                    };
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn check_binary_op(&mut self, op: &p::BinaryOperator) -> Result<(), ()> {
+        use p::BinaryOperator::*;
+        match op {
+            Plus | Minus | Multiply | Divide | Modulo | PGExp | Gt | Lt | GtEq | LtEq
+            | Spaceship | Eq | NotEq | And | Or => Ok(()),
+            StringConcat
+            | Xor
+            | BitwiseOr
+            | BitwiseAnd
+            | BitwiseXor
+            | DuckIntegerDivide
+            | MyIntegerDivide
+            | Custom(_)
+            | PGBitwiseXor
+            | PGBitwiseShiftLeft
+            | PGBitwiseShiftRight
+            | PGOverlap
+            | PGRegexMatch
+            | PGRegexIMatch
+            | PGRegexNotMatch
+            | PGRegexNotIMatch
+            | PGLikeMatch
+            | PGILikeMatch
+            | PGNotLikeMatch
+            | PGNotILikeMatch
+            | PGStartsWith
+            | PGCustomBinaryOperator(_)
+            | Arrow
+            | LongArrow
+            | HashArrow
+            | HashLongArrow
+            | AtAt
+            | AtArrow
+            | ArrowAt
+            | HashMinus
+            | AtQuestion
+            | Question
+            | QuestionAnd
+            | QuestionPipe
+            | Match
+            | Regexp
+            | Overlaps
+            | DoubleHash
+            | LtDashGt
+            | AndLt
+            | AndGt
+            | LtLtPipe
+            | PipeGtGt
+            | AndLtPipe
+            | PipeAndGt
+            | LtCaret
+            | GtCaret
+            | QuestionHash
+            | QuestionDash
+            | QuestionDashPipe
+            | QuestionDoublePipe
+            | At
+            | TildeEq
+            | Assignment => self.not_supported(format!("binary operator {op} is not supported")),
+        }
+    }
+
+    fn check_unary_op(&mut self, op: &p::UnaryOperator) -> Result<(), ()> {
+        use p::UnaryOperator::*;
+        match op {
+            Plus | Minus | Not => Ok(()),
+            BitwiseNot | PGSquareRoot | PGCubeRoot | PGPostfixFactorial | PGPrefixFactorial
+            | PGAbs | BangNot | Hash | AtDashAt | DoubleAt | QuestionDash | QuestionPipe => {
+                self.not_supported(format!("unary operator {op} is not supported"))
+            }
+        }
+    }
+}
+
+/// An `ExprVisitor` that validates an expression
+struct Validator<F> {
+    check_ident: F,
+    errors: Vec<SchemaValidationError>,
+}
+
+const FN_WHITELIST: [&str; 14] = [
+    // Clearly deterministic functions from
+    // https://www.postgresql.org/docs/current/functions-math.html, Table
+    // 9.5. We could also add trig functions (Table 9.7 and 9.8), but under
+    // no circumstances random functions from Table 9.6
+    "abs", "ceil", "ceiling", "div", "floor", "gcd", "lcm", "mod", "power", "sign",
+    // Conditional functions from
+    // https://www.postgresql.org/docs/current/functions-conditional.html.
+    "coalesce", "nullif", "greatest", "least",
+];
+
+impl<F: CheckIdentFn> ExprVisitor for Validator<F> {
+    fn visit_ident(&mut self, ident: &mut p::Ident) -> Result<(), ()> {
+        match (self.check_ident)(&ident.value) {
+            Ok(()) => Ok(()),
+            Err(e) => {
+                self.errors.push(e);
+                Err(())
+            }
+        }
+    }
+
+    fn visit_func_name(&mut self, func: &mut p::ObjectNamePart) -> Result<(), ()> {
+        let func = match func {
+            p::ObjectNamePart::Identifier(ident) => ident,
+            p::ObjectNamePart::Function(p::ObjectNamePartFunction { name, args: _ }) => {
+                self.not_supported(format!("function {name} is an object naming function"));
+                return Err(());
+            }
+        };
+        let p::Ident {
+            value,
+            quote_style,
+            span: _,
+        } = &func;
+        let whitelisted = match quote_style {
+            Some(_) => FN_WHITELIST.contains(&value.as_str()),
+            None => FN_WHITELIST
+                .iter()
+                .any(|name| name.eq_ignore_ascii_case(value)),
+        };
+        if whitelisted {
+            Ok(())
+        } else {
+            self.not_supported(format!("Function {func} is not supported"));
+            Err(())
+        }
+    }
+
+    fn not_supported(&mut self, msg: String) {
+        self.errors
+            .push(SchemaValidationError::ExprNotSupported(msg));
+    }
+
+    fn parse_error(&mut self, e: ParserError) {
+        self.errors
+            .push(SchemaValidationError::ExprParseError(e.to_string()));
+    }
+}
diff --git a/graph/src/schema/logs.graphql b/graph/src/schema/logs.graphql
new file mode 100644
index 00000000000..16a12160cd4
--- /dev/null
+++ b/graph/src/schema/logs.graphql
@@ -0,0 +1,71 @@
+"""
+The severity level of a log entry.
+Log levels are ordered from most to least severe: CRITICAL > ERROR > WARNING > INFO > DEBUG
+"""
+enum LogLevel {
+  "Critical errors that require immediate attention"
+  CRITICAL
+  "Error conditions that indicate a failure"
+  ERROR
+  "Warning conditions that may require attention"
+  WARNING
+  "Informational messages about normal operations"
+  INFO
+  "Detailed diagnostic information for debugging"
+  DEBUG
+}
+
+"""
+Sort direction for query results.
+"""
+enum OrderDirection {
+  "Ascending order (oldest first for timestamps)"
+  asc
+  "Descending order (newest first for timestamps)"
+  desc
+}
+
+"""
+A log entry emitted by a subgraph during indexing.
+Logs can be generated by the subgraph's AssemblyScript code using the `log.*` functions.
+"""
+type _Log_ {
+  "Unique identifier for this log entry"
+  id: String!
+  "The deployment hash of the subgraph that emitted this log"
+  subgraphId: String!
+  "The timestamp when the log was emitted, in RFC3339 format (e.g., '2024-01-15T10:30:00Z')"
+  timestamp: String!
+  "The severity level of the log entry"
+  level: LogLevel!
+  "The log message text"
+  text: String!
+  "Additional structured data passed to the log function as key-value pairs"
+  arguments: [_LogArgument_!]!
+  "Metadata about the source location in the subgraph code where the log was emitted"
+  meta: _LogMeta_!
+}
+
+"""
+A key-value pair of additional data associated with a log entry.
+These correspond to arguments passed to the log function in the subgraph code.
+"""
+type _LogArgument_ {
+  "The parameter name"
+  key: String!
+  "The parameter value, serialized as a string"
+  value: String!
+}
+
+"""
+Source code location metadata for a log entry.
+Indicates where in the subgraph's AssemblyScript code the log statement was executed.
+"""
+type _LogMeta_ {
+  "The module or file path where the log was emitted"
+  module: String!
+  "The line number in the source file"
+  line: Int!
+  "The column number in the source file"
+  column: Int!
+}
diff --git a/graph/src/schema/meta.graphql b/graph/src/schema/meta.graphql
index ff543b1f9c8..729874d8b9d 100644
--- a/graph/src/schema/meta.graphql
+++ b/graph/src/schema/meta.graphql
@@ -1,7 +1,9 @@
 # GraphQL core functionality
 scalar Boolean
 scalar ID
-""" 4 bytes signed integer """
+"""
+4 bytes signed integer
+"""
 scalar Int
 scalar Float
 scalar String
@@ -24,8 +26,14 @@ directive @derivedFrom(field: String!) on FIELD_DEFINITION
 scalar BigDecimal
 scalar Bytes
 scalar BigInt
-""" 8 bytes signed integer """
+"""
+8 bytes signed integer
+"""
 scalar Int8
+"""
+A string representation of microseconds UNIX timestamp (16 digits)
+"""
+scalar Timestamp
 
 # The type names are purposely awkward to minimize the risk of them
 # colliding with user-supplied types
@@ -59,13 +67,15 @@ type _Block_ {
   hash: Bytes
   "The block number"
   number: Int!
-  "Integer representation of the timestamp stored in blocks for the chain" 
+  "Integer representation of the timestamp stored in blocks for the chain"
   timestamp: Int
+  "The hash of the parent block"
+  parentHash: Bytes
 }
 
 enum _SubgraphErrorPolicy_ {
   "Data will be returned even if the subgraph has indexing errors"
-  allow,
+  allow
 
   "If the subgraph has indexing errors, data will be omitted. The default."
   deny
@@ -78,7 +88,7 @@ input Block_height {
   "Value containing a block number"
   number: Int
   """
-  Value containing the minimum block number. 
+  Value containing the minimum block number.
   In the case of `number_gte`, the query will be executed on the latest block only if
   the subgraph has progressed to or past the minimum block number.
   Defaults to the latest block when omitted.
@@ -90,4 +100,18 @@ input Block_height {
 enum OrderDirection {
   asc
   desc
-}
\ No newline at end of file
+}
+
+enum Aggregation_interval {
+  hour
+  day
+}
+
+"Indicates whether the current, partially filled bucket should be included in the response. Defaults to `exclude`"
+enum Aggregation_current {
+    "Exclude the current, partially filled bucket from the response"
+    exclude
+
+    "Include the current, partially filled bucket in the response"
+    include
+}
diff --git a/graph/src/schema/mod.rs b/graph/src/schema/mod.rs
index 251061ea983..0da95598e2e 100644
--- a/graph/src/schema/mod.rs
+++ b/graph/src/schema/mod.rs
@@ -3,7 +3,6 @@ use crate::data::subgraph::DeploymentHash;
 use crate::prelude::{anyhow, s};
 
 use anyhow::Error;
-use graphql_parser::{self, Pos};
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
@@ -21,17 +20,19 @@ pub mod ast;
 mod entity_key;
 mod entity_type;
 mod fulltext;
-mod input_schema;
+pub(crate) mod input;
 
-pub use api::{is_introspection_field, APISchemaError, INTROSPECTION_QUERY_TYPE};
+pub use api::{APISchemaError, INTROSPECTION_QUERY_TYPE, is_introspection_field};
 
 pub use api::{ApiSchema, ErrorPolicy};
 pub use entity_key::EntityKey;
 pub use entity_type::{AsEntityTypeName, EntityType};
 pub use fulltext::{FulltextAlgorithm, FulltextConfig, FulltextDefinition, FulltextLanguage};
-pub use input_schema::{
+pub(crate) use input::POI_OBJECT;
+pub use input::sqlexpr::{ExprVisitor, VisitExpr};
+pub use input::{
     Aggregate, AggregateFn, Aggregation, AggregationInterval, AggregationMapping, Field,
-    InputSchema, InterfaceType, ObjectType, TypeKind,
+    InputSchema, InterfaceType, ObjectOrInterface, ObjectType, TypeKind, kw,
 };
 
 pub const SCHEMA_TYPE_NAME: &str = "_Schema_";
@@ -40,6 +41,9 @@ pub const INTROSPECTION_SCHEMA_FIELD_NAME: &str = "__schema";
 pub const META_FIELD_TYPE: &str = "_Meta_";
 pub const META_FIELD_NAME: &str = "_meta";
 
+pub const LOGS_FIELD_TYPE: &str = "_Log_";
+pub const LOGS_FIELD_NAME: &str = "_logs";
+
 pub const INTROSPECTION_TYPE_FIELD_NAME: &str = "__type";
 
 pub const BLOCK_FIELD_TYPE: &str = "_Block_";
@@ -56,6 +60,8 @@ impl fmt::Display for Strings {
 
 #[derive(Debug, Error, PartialEq, Eq)]
 pub enum SchemaValidationError {
+    #[error("Invalid schema: {0}")]
+    InvalidSchema(String),
     #[error("Interface `{0}` not defined")]
     InterfaceUndefined(String),
 
@@ -69,7 +75,9 @@ pub enum SchemaValidationError {
          the following fields: {2}"
     )]
     InterfaceFieldsMissing(String, String, Strings), // (type, interface, missing_fields)
-    #[error("Implementors of interface `{0}` use different id types `{1}`. They must all use the same type")]
+    #[error(
+        "Implementors of interface `{0}` use different id types `{1}`. They must all use the same type"
+    )]
     InterfaceImplementorsMixId(String, String),
     #[error("Field `{1}` in type `{0}` has invalid @derivedFrom: {2}")]
     InvalidDerivedFrom(String, String, String), // (type, field, reason)
@@ -87,7 +95,9 @@ pub enum SchemaValidationError {
     FulltextNameUndefined,
     #[error("Fulltext directive name overlaps with type: {0}")]
     FulltextNameConflict(String),
-    #[error("Fulltext directive name overlaps with an existing entity field or a top-level query field: {0}")]
+    #[error(
+        "Fulltext directive name overlaps with an existing entity field or a top-level query field: {0}"
+    )]
     FulltextNameCollision(String),
     #[error("Fulltext language is undefined")]
     FulltextLanguageUndefined,
@@ -119,8 +129,14 @@ pub enum SchemaValidationError {
     IllegalIdType(String),
     #[error("Timeseries {0} is missing a `timestamp` field")]
     TimestampFieldMissing(String),
-    #[error("Aggregation {0}, field{1}: aggregates must use a numeric type, one of Int, Int8, BigInt, and BigDecimal")]
+    #[error(
+        "Aggregation {0}, field{1}: aggregates must use a numeric type, one of Int, Int8, BigInt, and BigDecimal"
+    )]
     NonNumericAggregate(String, String),
+    #[error(
+        "Aggregation '{0}', field '{1}': first/last aggregates must use a numeric, byte array, string or a reference type"
+    )]
+    InvalidFirstLastAggregate(String, String),
     #[error("Aggregation {0} is missing the `source` argument")]
     AggregationMissingSource(String),
     #[error(
@@ -143,9 +159,13 @@ pub enum SchemaValidationError {
     AggregationDerivedField(String, String),
     #[error("Timeseries {0} is marked as mutable, it must be immutable")]
     MutableTimeseries(String),
+    #[error(
+        "Entity type `{0}` has skipDuplicates: true but is not immutable; skipDuplicates requires immutable: true"
+    )]
+    SkipDuplicatesRequiresImmutable(String),
     #[error("Timeseries {0} is missing a `timestamp` field")]
     TimeseriesMissingTimestamp(String),
-    #[error("Type {0} has a `timestamp` field of type {1}, but it must be of type Int8")]
+    #[error("Type {0} has a `timestamp` field of type {1}, but it must be of type Timestamp")]
     InvalidTimestampType(String, String),
     #[error("Aggregaton {0} uses {1} as the source, but there is no timeseries of that name")]
     AggregationUnknownSource(String, String),
@@ -161,7 +181,9 @@ pub enum SchemaValidationError {
     AggregationInvalidFn(String, String, String),
     #[error("Field {1} in aggregation {0} is missing the `fn` argument")]
     AggregationMissingFn(String, String),
-    #[error("Field {1} in aggregation {0} is missing the `arg` argument since the function {2} requires it")]
+    #[error(
+        "Field {1} in aggregation {0} is missing the `arg` argument since the function {2} requires it"
+    )]
     AggregationMissingArg(String, String, String),
     #[error(
         "Field {1} in aggregation {0} has `arg` {2} but the source type does not have such a field"
@@ -173,10 +195,24 @@ pub enum SchemaValidationError {
     AggregationNonMatchingArg(String, String, String, String, String),
     #[error("Field {1} in aggregation {0} has arg `{3}` but that is not a numeric field in {2}")]
     AggregationNonNumericArg(String, String, String, String),
-    #[error("Aggregations are not supported with spec version {0}; please migrate the subgraph to the latest version")]
+    #[error(
+        "Field {1} in aggregation {0} has an invalid value for `cumulative`. It needs to be a boolean"
+    )]
+    AggregationInvalidCumulative(String, String),
+    #[error(
+        "Aggregations are not supported with spec version {0}; please migrate the subgraph to the latest version"
+    )]
     AggregationsNotSupported(Version),
-    #[error("Using Int8 as the type for the `id` field is not supported with spec version {0}; please migrate the subgraph to the latest version")]
+    #[error(
+        "Using Int8 as the type for the `id` field is not supported with spec version {0}; please migrate the subgraph to the latest version"
+    )]
     IdTypeInt8NotSupported(Version),
+    #[error("{0}")]
+    ExprNotSupported(String),
+    #[error("Expressions can't us the function {0}")]
+    ExprIllegalFunction(String),
+    #[error("Failed to parse expression: {0}")]
+    ExprParseError(String),
 }
 
 /// A validated and preprocessed GraphQL schema for a subgraph.
@@ -268,7 +304,7 @@ impl Schema {
     }
 
     pub fn parse(raw: &str, id: DeploymentHash) -> Result<Self, Error> {
-        let document = graphql_parser::parse_schema(raw)?.into_static();
+        let document = s::parse_schema(raw)?.into_static();
 
         Schema::new(id, document).map_err(Into::into)
     }
@@ -290,11 +326,11 @@ impl Schema {
 
             let subgraph_id_directive = s::Directive {
                 name: "subgraphId".to_string(),
-                position: Pos::default(),
+                position: s::Pos::default(),
                 arguments: vec![subgraph_id_argument],
             };
 
-            if let s::Definition::TypeDefinition(ref mut type_definition) = definition {
+            if let s::Definition::TypeDefinition(type_definition) = definition {
                 let (name, directives) = match type_definition {
                     s::TypeDefinition::Object(object_type) => {
                         (&object_type.name, &mut object_type.directives)
diff --git a/graph/src/schema/test_schemas/no_aggregations.graphql b/graph/src/schema/test_schemas/no_aggregations.graphql
index 5c0dae2e242..31fee546802 100644
--- a/graph/src/schema/test_schemas/no_aggregations.graphql
+++ b/graph/src/schema/test_schemas/no_aggregations.graphql
@@ -1,12 +1,12 @@
 # fail @ 0.0.9: AggregationsNotSupported
 type Data @entity(timeseries: true) {
   id: Bytes!
-  timestamp: Int8!
+  timestamp: Timestamp!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Bytes!
-  timestamp: Int8!
+  timestamp: Timestamp!
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
 }
diff --git a/graph/src/schema/test_schemas/skip_duplicates_not_a_boolean.graphql b/graph/src/schema/test_schemas/skip_duplicates_not_a_boolean.graphql
new file mode 100644
index 00000000000..ed22d3e8eb8
--- /dev/null
+++ b/graph/src/schema/test_schemas/skip_duplicates_not_a_boolean.graphql
@@ -0,0 +1,5 @@
+# fail: EntityDirectiveNonBooleanArgValue("skipDuplicates")
+
+type Data @entity(immutable: true, skipDuplicates: "yes") {
+  id: Bytes!
+}
diff --git a/graph/src/schema/test_schemas/skip_duplicates_requires_immutable.graphql b/graph/src/schema/test_schemas/skip_duplicates_requires_immutable.graphql
new file mode 100644
index 00000000000..2eeaf6cff09
--- /dev/null
+++ b/graph/src/schema/test_schemas/skip_duplicates_requires_immutable.graphql
@@ -0,0 +1,5 @@
+# fail: SkipDuplicatesRequiresImmutable("Data")
+
+type Data @entity(skipDuplicates: true) {
+  id: Bytes!
+}
diff --git a/graph/src/schema/test_schemas/skip_duplicates_valid.graphql b/graph/src/schema/test_schemas/skip_duplicates_valid.graphql
new file mode 100644
index 00000000000..cdf6ee29b23
--- /dev/null
+++ b/graph/src/schema/test_schemas/skip_duplicates_valid.graphql
@@ -0,0 +1,5 @@
+# valid: Minimal example
+
+type Data @entity(immutable: true, skipDuplicates: true) {
+  id: Bytes!
+}
diff --git a/graph/src/schema/test_schemas/ts_data_mutable.graphql b/graph/src/schema/test_schemas/ts_data_mutable.graphql
index 80f31c6bbf4..5fe0b3a45e9 100644
--- a/graph/src/schema/test_schemas/ts_data_mutable.graphql
+++ b/graph/src/schema/test_schemas/ts_data_mutable.graphql
@@ -1,12 +1,12 @@
 # fail: MutableTimeseries
 type Data @entity(timeseries: true, immutable: false) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
 }
diff --git a/graph/src/schema/test_schemas/ts_data_no_id.graphql b/graph/src/schema/test_schemas/ts_data_no_id.graphql
index a25d96a623d..4ab5b65a505 100644
--- a/graph/src/schema/test_schemas/ts_data_no_id.graphql
+++ b/graph/src/schema/test_schemas/ts_data_no_id.graphql
@@ -1,11 +1,11 @@
 # fail: IdFieldMissing
 type Data @entity(timeseries: true) {
-  timestamp: Int8!
+  timestamp: Timestamp!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
 }
diff --git a/graph/src/schema/test_schemas/ts_data_no_timestamp.graphql b/graph/src/schema/test_schemas/ts_data_no_timestamp.graphql
index 3c5e3e1ee2a..c01086923a3 100644
--- a/graph/src/schema/test_schemas/ts_data_no_timestamp.graphql
+++ b/graph/src/schema/test_schemas/ts_data_no_timestamp.graphql
@@ -6,6 +6,6 @@ type Data @entity(timeseries: true) {
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
 }
diff --git a/graph/src/schema/test_schemas/ts_data_not_timeseries.graphql b/graph/src/schema/test_schemas/ts_data_not_timeseries.graphql
index 51b46e01dfc..3f9370e2409 100644
--- a/graph/src/schema/test_schemas/ts_data_not_timeseries.graphql
+++ b/graph/src/schema/test_schemas/ts_data_not_timeseries.graphql
@@ -1,12 +1,12 @@
 # fail: AggregationNonTimeseriesSource
 type Data @entity {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
 }
diff --git a/graph/src/schema/test_schemas/ts_derived_from.graphql b/graph/src/schema/test_schemas/ts_derived_from.graphql
index f22eaad929d..5f9c3633ca6 100644
--- a/graph/src/schema/test_schemas/ts_derived_from.graphql
+++ b/graph/src/schema/test_schemas/ts_derived_from.graphql
@@ -6,14 +6,14 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Bytes!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token! @derivedFrom(field: "stats")
   max: BigDecimal! @aggregate(fn: "max", arg: "price")
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
diff --git a/graph/src/schema/test_schemas/ts_empty_intervals.graphql b/graph/src/schema/test_schemas/ts_empty_intervals.graphql
index 82088afb4d7..17bac0ee24c 100644
--- a/graph/src/schema/test_schemas/ts_empty_intervals.graphql
+++ b/graph/src/schema/test_schemas/ts_empty_intervals.graphql
@@ -6,14 +6,14 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: [], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   max: BigDecimal! @aggregate(fn: "max", arg: "price")
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
diff --git a/graph/src/schema/test_schemas/ts_expr_random.graphql b/graph/src/schema/test_schemas/ts_expr_random.graphql
new file mode 100644
index 00000000000..dd9790dd66a
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_expr_random.graphql
@@ -0,0 +1,14 @@
+# fail: ExprNotSupported("Function random is not supported")
+# Random must not be allowed as it would introduce nondeterministic behavior
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  price0: BigDecimal!
+  price1: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: Int8!
+  timestamp: Timestamp!
+  max_price: BigDecimal! @aggregate(fn: "max", arg: "random()")
+}
diff --git a/graph/src/schema/test_schemas/ts_expr_simple.graphql b/graph/src/schema/test_schemas/ts_expr_simple.graphql
new file mode 100644
index 00000000000..79d4c5d13d4
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_expr_simple.graphql
@@ -0,0 +1,25 @@
+# valid: Minimal example
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  price0: BigDecimal!
+  price1: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: Int8!
+  timestamp: Timestamp!
+  max_price: BigDecimal! @aggregate(fn: "max", arg: "greatest(price0, price1)")
+  abs_price: BigDecimal! @aggregate(fn: "sum", arg: "abs(price0) + abs(price1)")
+  price0_sq: BigDecimal! @aggregate(fn: "sum", arg: "power(price0, 2)")
+  sum_sq: BigDecimal! @aggregate(fn: "sum", arg: "price0 * price0")
+  sum_sq_cross: BigDecimal! @aggregate(fn: "sum", arg: "price0 * price1")
+
+  max_some: BigDecimal!
+    @aggregate(
+      fn: "max"
+      arg: "case when price0 > price1 then price0 else 0 end"
+    )
+
+  max_cast: BigDecimal! @aggregate(fn: "sum", arg: "(price0/7)::int4")
+}
diff --git a/graph/src/schema/test_schemas/ts_expr_syntax_err.graphql b/graph/src/schema/test_schemas/ts_expr_syntax_err.graphql
new file mode 100644
index 00000000000..72a95e1b821
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_expr_syntax_err.graphql
@@ -0,0 +1,13 @@
+# fail: ExprParseError("sql parser error: Expected: an expression, found: EOF"
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  price0: BigDecimal!
+  price1: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: Int8!
+  timestamp: Timestamp!
+  max_price: BigDecimal! @aggregate(fn: "max", arg: "greatest(price0,")
+}
diff --git a/graph/src/schema/test_schemas/ts_id_type_mismatch.graphql b/graph/src/schema/test_schemas/ts_id_type_mismatch.graphql
index bfd4fd5a146..39510dd79c7 100644
--- a/graph/src/schema/test_schemas/ts_id_type_mismatch.graphql
+++ b/graph/src/schema/test_schemas/ts_id_type_mismatch.graphql
@@ -1,12 +1,12 @@
 # fail: IllegalIdType
 type Data @entity(timeseries: true) {
   id: Bytes!
-  timestamp: Int8!
+  timestamp: Timestamp!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
 }
diff --git a/graph/src/schema/test_schemas/ts_invalid_arg.graphql b/graph/src/schema/test_schemas/ts_invalid_arg.graphql
index c9c8ba48afb..b9728da0fe5 100644
--- a/graph/src/schema/test_schemas/ts_invalid_arg.graphql
+++ b/graph/src/schema/test_schemas/ts_invalid_arg.graphql
@@ -6,14 +6,14 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   max: BigDecimal! @aggregate(fn: "max", arg: "token")
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
diff --git a/graph/src/schema/test_schemas/ts_invalid_cumulative.graphql b/graph/src/schema/test_schemas/ts_invalid_cumulative.graphql
new file mode 100644
index 00000000000..7bfc5b7c982
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_invalid_cumulative.graphql
@@ -0,0 +1,12 @@
+# fail: AggregationInvalidCumulative("Stats", "sum")
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: Int8!
+  timestamp: Timestamp!
+  sum: BigDecimal! @aggregate(fn: "sum", arg: "price", cumulative: "maybe")
+}
diff --git a/graph/src/schema/test_schemas/ts_invalid_first_type_reference.graphql b/graph/src/schema/test_schemas/ts_invalid_first_type_reference.graphql
new file mode 100644
index 00000000000..3f259c732cc
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_invalid_first_type_reference.graphql
@@ -0,0 +1,14 @@
+# fail: FieldTypeUnknown("Stats", "firstBlockNumber", "BlockNumber")
+
+type Data @entity(timeseries: true) {
+    id: Int8!
+    timestamp: Timestamp!
+    blockNumber: Int8!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+    id: Int8!
+    timestamp: Timestamp!
+
+    firstBlockNumber: BlockNumber! @aggregate(fn: "first", arg: "blockNumber")
+}
diff --git a/graph/src/schema/test_schemas/ts_invalid_fn.graphql b/graph/src/schema/test_schemas/ts_invalid_fn.graphql
index db587f991c8..dedf928e607 100644
--- a/graph/src/schema/test_schemas/ts_invalid_fn.graphql
+++ b/graph/src/schema/test_schemas/ts_invalid_fn.graphql
@@ -6,14 +6,14 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   doit: BigDecimal! @aggregate(fn: "doit", arg: "price")
 }
diff --git a/graph/src/schema/test_schemas/ts_invalid_interval.graphql b/graph/src/schema/test_schemas/ts_invalid_interval.graphql
index 417e9a355d6..a74ec505c8c 100644
--- a/graph/src/schema/test_schemas/ts_invalid_interval.graphql
+++ b/graph/src/schema/test_schemas/ts_invalid_interval.graphql
@@ -6,14 +6,14 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["fortnight"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   max: BigDecimal! @aggregate(fn: "max", arg: "price")
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
diff --git a/graph/src/schema/test_schemas/ts_invalid_last_type_reference.graphql b/graph/src/schema/test_schemas/ts_invalid_last_type_reference.graphql
new file mode 100644
index 00000000000..405fde6fd3f
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_invalid_last_type_reference.graphql
@@ -0,0 +1,14 @@
+# fail: FieldTypeUnknown("Stats", "lastBlockNumber", "BlockNumber")
+
+type Data @entity(timeseries: true) {
+    id: Int8!
+    timestamp: Timestamp!
+    blockNumber: Int8!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+    id: Int8!
+    timestamp: Timestamp!
+
+    lastBlockNumber: BlockNumber! @aggregate(fn: "last", arg: "blockNumber")
+}
diff --git a/graph/src/schema/test_schemas/ts_invalid_timestamp_aggregation.graphql b/graph/src/schema/test_schemas/ts_invalid_timestamp_aggregation.graphql
new file mode 100644
index 00000000000..a982f7ff46f
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_invalid_timestamp_aggregation.graphql
@@ -0,0 +1,12 @@
+# fail: InvalidTimestampType("Stats", "Int8")
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: Int8!
+  timestamp: Int8!
+  sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
+}
diff --git a/graph/src/schema/test_schemas/ts_invalid_timestamp_timeseries.graphql b/graph/src/schema/test_schemas/ts_invalid_timestamp_timeseries.graphql
new file mode 100644
index 00000000000..ed88db933dc
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_invalid_timestamp_timeseries.graphql
@@ -0,0 +1,12 @@
+# fail: InvalidTimestampType("Data", "Int8")
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Int8!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: Int8!
+  timestamp: Timestamp!
+  sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
+}
diff --git a/graph/src/schema/test_schemas/ts_missing_arg.graphql b/graph/src/schema/test_schemas/ts_missing_arg.graphql
index 06c2c55ee32..ce874942eb7 100644
--- a/graph/src/schema/test_schemas/ts_missing_arg.graphql
+++ b/graph/src/schema/test_schemas/ts_missing_arg.graphql
@@ -6,14 +6,14 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   max: BigDecimal! @aggregate(fn: "max")
 }
diff --git a/graph/src/schema/test_schemas/ts_missing_fn.graphql b/graph/src/schema/test_schemas/ts_missing_fn.graphql
index 2212ddc7999..30b9b4a5363 100644
--- a/graph/src/schema/test_schemas/ts_missing_fn.graphql
+++ b/graph/src/schema/test_schemas/ts_missing_fn.graphql
@@ -6,14 +6,14 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   max: BigDecimal! @aggregate(arg: "price")
 }
diff --git a/graph/src/schema/test_schemas/ts_missing_type.graphql b/graph/src/schema/test_schemas/ts_missing_type.graphql
index 80d9439d1da..6d8be96b689 100644
--- a/graph/src/schema/test_schemas/ts_missing_type.graphql
+++ b/graph/src/schema/test_schemas/ts_missing_type.graphql
@@ -1,14 +1,14 @@
 # fail: FieldTypeUnknown
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   max: BigDecimal! @aggregate(fn: "max", arg: "price")
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
diff --git a/graph/src/schema/test_schemas/ts_no_aggregate.graphql b/graph/src/schema/test_schemas/ts_no_aggregate.graphql
index 90af3bedba1..2ef903429b2 100644
--- a/graph/src/schema/test_schemas/ts_no_aggregate.graphql
+++ b/graph/src/schema/test_schemas/ts_no_aggregate.graphql
@@ -6,13 +6,13 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
 }
diff --git a/graph/src/schema/test_schemas/ts_no_id.graphql b/graph/src/schema/test_schemas/ts_no_id.graphql
index 3696d2bc2b4..50878765de8 100644
--- a/graph/src/schema/test_schemas/ts_no_id.graphql
+++ b/graph/src/schema/test_schemas/ts_no_id.graphql
@@ -6,13 +6,13 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   max: BigDecimal! @aggregate(fn: "max", arg: "price")
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
diff --git a/graph/src/schema/test_schemas/ts_no_interval.graphql b/graph/src/schema/test_schemas/ts_no_interval.graphql
index 8ffea6cc7e4..42add266d92 100644
--- a/graph/src/schema/test_schemas/ts_no_interval.graphql
+++ b/graph/src/schema/test_schemas/ts_no_interval.graphql
@@ -6,14 +6,14 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   max: BigDecimal! @aggregate(fn: "max", arg: "price")
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
diff --git a/graph/src/schema/test_schemas/ts_no_timeseries.graphql b/graph/src/schema/test_schemas/ts_no_timeseries.graphql
index 6e953a8fe9b..52ad13979c0 100644
--- a/graph/src/schema/test_schemas/ts_no_timeseries.graphql
+++ b/graph/src/schema/test_schemas/ts_no_timeseries.graphql
@@ -1,7 +1,7 @@
 # fail: EntityDirectivesMissing
 type Stats {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Bytes!
   avg: BigDecimal! @aggregate(fn: "avg", arg: "price")
   sum: BigInt! @aggregate(fn: "sum", arg: "price")
diff --git a/graph/src/schema/test_schemas/ts_no_timestamp.graphql b/graph/src/schema/test_schemas/ts_no_timestamp.graphql
index 78345153482..6669920746e 100644
--- a/graph/src/schema/test_schemas/ts_no_timestamp.graphql
+++ b/graph/src/schema/test_schemas/ts_no_timestamp.graphql
@@ -6,7 +6,7 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
diff --git a/graph/src/schema/test_schemas/ts_valid.graphql b/graph/src/schema/test_schemas/ts_valid.graphql
index ecf0c8ca39c..274d6463752 100644
--- a/graph/src/schema/test_schemas/ts_valid.graphql
+++ b/graph/src/schema/test_schemas/ts_valid.graphql
@@ -6,14 +6,14 @@ type Token @entity {
 
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   token: Token!
   max: BigDecimal! @aggregate(fn: "max", arg: "price")
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
diff --git a/graph/src/schema/test_schemas/ts_valid_cumulative.graphql b/graph/src/schema/test_schemas/ts_valid_cumulative.graphql
new file mode 100644
index 00000000000..383dab68742
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_valid_cumulative.graphql
@@ -0,0 +1,12 @@
+# valid: Minimal example
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: Int8!
+  timestamp: Timestamp!
+  sum: BigDecimal! @aggregate(fn: "sum", arg: "price", cumulative: true)
+}
diff --git a/graph/src/schema/test_schemas/ts_valid_minimal.graphql b/graph/src/schema/test_schemas/ts_valid_minimal.graphql
index c588b9500f8..14078ac386d 100644
--- a/graph/src/schema/test_schemas/ts_valid_minimal.graphql
+++ b/graph/src/schema/test_schemas/ts_valid_minimal.graphql
@@ -1,12 +1,12 @@
 # valid: Minimal example
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
 }
diff --git a/graph/src/schema/test_schemas/ts_valid_non_numeric_first_last.graphql b/graph/src/schema/test_schemas/ts_valid_non_numeric_first_last.graphql
new file mode 100644
index 00000000000..fe78dc7463c
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_valid_non_numeric_first_last.graphql
@@ -0,0 +1,43 @@
+# valid: Non-numeric first and last aggregations
+
+type EntityA @entity(immutable: true) {
+    id: ID!
+}
+
+type EntityB @entity(immutable: true) {
+    id: Int8!
+}
+
+type EntityC @entity(immutable: true) {
+    id: Bytes!
+}
+
+type Data @entity(timeseries: true) {
+    id: Int8!
+    timestamp: Timestamp!
+    fieldA: EntityA!
+    fieldB: EntityB!
+    fieldC: EntityC!
+    fieldD: String!
+    fieldE: Bytes!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+    id: Int8!
+    timestamp: Timestamp!
+
+    firstA: EntityA! @aggregate(fn: "first", arg: "fieldA")
+    lastA: EntityA! @aggregate(fn: "last", arg: "fieldA")
+
+    firstB: EntityB! @aggregate(fn: "first", arg: "fieldB")
+    lastB: EntityB! @aggregate(fn: "last", arg: "fieldB")
+
+    firstC: EntityC! @aggregate(fn: "first", arg: "fieldC")
+    lastC: EntityC! @aggregate(fn: "last", arg: "fieldC")
+
+    firstD: String! @aggregate(fn: "first", arg: "fieldD")
+    lastD: String! @aggregate(fn: "last", arg: "fieldD")
+
+    firstE: Bytes! @aggregate(fn: "first", arg: "fieldE")
+    lastE: Bytes! @aggregate(fn: "last", arg: "fieldE")
+}
diff --git a/graph/src/schema/test_schemas/ts_wrong_interval.graphql b/graph/src/schema/test_schemas/ts_wrong_interval.graphql
index daa60a6db16..ea6f9e84c48 100644
--- a/graph/src/schema/test_schemas/ts_wrong_interval.graphql
+++ b/graph/src/schema/test_schemas/ts_wrong_interval.graphql
@@ -1,12 +1,12 @@
 # fail: AggregationWrongIntervals
 type Data @entity(timeseries: true) {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   price: BigDecimal!
 }
 
 type Stats @aggregation(intervals: [60, 1440], source: "Data") {
   id: Int8!
-  timestamp: Int8!
+  timestamp: Timestamp!
   sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
 }
diff --git a/graph/src/substreams/codec.rs b/graph/src/substreams/codec.rs
deleted file mode 100644
index 23edcc3b7c1..00000000000
--- a/graph/src/substreams/codec.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#[rustfmt::skip]
-#[path = "sf.substreams.v1.rs"]
-mod pbsubstreams;
-
-pub use pbsubstreams::*;
diff --git a/graph/src/substreams/mod.rs b/graph/src/substreams/mod.rs
deleted file mode 100644
index a09801b91ee..00000000000
--- a/graph/src/substreams/mod.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-mod codec;
-
-pub use codec::*;
-
-use self::module::input::{Input, Params};
-
-/// Replace all the existing params with the provided ones.
-pub fn patch_module_params(params: String, module: &mut Module) {
-    let mut inputs = vec![crate::substreams::module::Input {
-        input: Some(Input::Params(Params { value: params })),
-    }];
-
-    inputs.extend(module.inputs.iter().flat_map(|input| match input.input {
-        None => None,
-        Some(Input::Params(_)) => None,
-        Some(_) => Some(input.clone()),
-    }));
-
-    module.inputs = inputs;
-}
diff --git a/graph/src/substreams/sf.substreams.v1.rs b/graph/src/substreams/sf.substreams.v1.rs
deleted file mode 100644
index f8af149f6e4..00000000000
--- a/graph/src/substreams/sf.substreams.v1.rs
+++ /dev/null
@@ -1,289 +0,0 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Package {
-    /// Needs to be one so this file can be used _directly_ as a
-    /// buf `Image` andor a ProtoSet for grpcurl and other tools
-    #[prost(message, repeated, tag = "1")]
-    pub proto_files: ::prost::alloc::vec::Vec<::prost_types::FileDescriptorProto>,
-    #[prost(uint64, tag = "5")]
-    pub version: u64,
-    #[prost(message, optional, tag = "6")]
-    pub modules: ::core::option::Option<Modules>,
-    #[prost(message, repeated, tag = "7")]
-    pub module_meta: ::prost::alloc::vec::Vec<ModuleMetadata>,
-    #[prost(message, repeated, tag = "8")]
-    pub package_meta: ::prost::alloc::vec::Vec<PackageMetadata>,
-    /// Source network for Substreams to fetch its data from.
-    #[prost(string, tag = "9")]
-    pub network: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "10")]
-    pub sink_config: ::core::option::Option<::prost_types::Any>,
-    #[prost(string, tag = "11")]
-    pub sink_module: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PackageMetadata {
-    #[prost(string, tag = "1")]
-    pub version: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub url: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(string, tag = "4")]
-    pub doc: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ModuleMetadata {
-    /// Corresponds to the index in `Package.metadata.package_meta`
-    #[prost(uint64, tag = "1")]
-    pub package_index: u64,
-    #[prost(string, tag = "2")]
-    pub doc: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Modules {
-    #[prost(message, repeated, tag = "1")]
-    pub modules: ::prost::alloc::vec::Vec<Module>,
-    #[prost(message, repeated, tag = "2")]
-    pub binaries: ::prost::alloc::vec::Vec<Binary>,
-}
-/// Binary represents some code compiled to its binary form.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Binary {
-    #[prost(string, tag = "1")]
-    pub r#type: ::prost::alloc::string::String,
-    #[prost(bytes = "vec", tag = "2")]
-    pub content: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Module {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(uint32, tag = "4")]
-    pub binary_index: u32,
-    #[prost(string, tag = "5")]
-    pub binary_entrypoint: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "6")]
-    pub inputs: ::prost::alloc::vec::Vec<module::Input>,
-    #[prost(message, optional, tag = "7")]
-    pub output: ::core::option::Option<module::Output>,
-    #[prost(uint64, tag = "8")]
-    pub initial_block: u64,
-    #[prost(oneof = "module::Kind", tags = "2, 3")]
-    pub kind: ::core::option::Option<module::Kind>,
-}
-/// Nested message and enum types in `Module`.
-pub mod module {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct KindMap {
-        #[prost(string, tag = "1")]
-        pub output_type: ::prost::alloc::string::String,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct KindStore {
-        /// The `update_policy` determines the functions available to mutate the store
-        /// (like `set()`, `set_if_not_exists()` or `sum()`, etc..) in
-        /// order to ensure that parallel operations are possible and deterministic
-        ///
-        /// Say a store cumulates keys from block 0 to 1M, and a second store
-        /// cumulates keys from block 1M to 2M. When we want to use this
-        /// store as a dependency for a downstream module, we will merge the
-        /// two stores according to this policy.
-        #[prost(enumeration = "kind_store::UpdatePolicy", tag = "1")]
-        pub update_policy: i32,
-        #[prost(string, tag = "2")]
-        pub value_type: ::prost::alloc::string::String,
-    }
-    /// Nested message and enum types in `KindStore`.
-    pub mod kind_store {
-        #[derive(
-            Clone,
-            Copy,
-            Debug,
-            PartialEq,
-            Eq,
-            Hash,
-            PartialOrd,
-            Ord,
-            ::prost::Enumeration
-        )]
-        #[repr(i32)]
-        pub enum UpdatePolicy {
-            Unset = 0,
-            /// Provides a store where you can `set()` keys, and the latest key wins
-            Set = 1,
-            /// Provides a store where you can `set_if_not_exists()` keys, and the first key wins
-            SetIfNotExists = 2,
-            /// Provides a store where you can `add_*()` keys, where two stores merge by summing its values.
-            Add = 3,
-            /// Provides a store where you can `min_*()` keys, where two stores merge by leaving the minimum value.
-            Min = 4,
-            /// Provides a store where you can `max_*()` keys, where two stores merge by leaving the maximum value.
-            Max = 5,
-            /// Provides a store where you can `append()` keys, where two stores merge by concatenating the bytes in order.
-            Append = 6,
-        }
-        impl UpdatePolicy {
-            /// String value of the enum field names used in the ProtoBuf definition.
-            ///
-            /// The values are not transformed in any way and thus are considered stable
-            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-            pub fn as_str_name(&self) -> &'static str {
-                match self {
-                    UpdatePolicy::Unset => "UPDATE_POLICY_UNSET",
-                    UpdatePolicy::Set => "UPDATE_POLICY_SET",
-                    UpdatePolicy::SetIfNotExists => "UPDATE_POLICY_SET_IF_NOT_EXISTS",
-                    UpdatePolicy::Add => "UPDATE_POLICY_ADD",
-                    UpdatePolicy::Min => "UPDATE_POLICY_MIN",
-                    UpdatePolicy::Max => "UPDATE_POLICY_MAX",
-                    UpdatePolicy::Append => "UPDATE_POLICY_APPEND",
-                }
-            }
-            /// Creates an enum from field names used in the ProtoBuf definition.
-            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-                match value {
-                    "UPDATE_POLICY_UNSET" => Some(Self::Unset),
-                    "UPDATE_POLICY_SET" => Some(Self::Set),
-                    "UPDATE_POLICY_SET_IF_NOT_EXISTS" => Some(Self::SetIfNotExists),
-                    "UPDATE_POLICY_ADD" => Some(Self::Add),
-                    "UPDATE_POLICY_MIN" => Some(Self::Min),
-                    "UPDATE_POLICY_MAX" => Some(Self::Max),
-                    "UPDATE_POLICY_APPEND" => Some(Self::Append),
-                    _ => None,
-                }
-            }
-        }
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct Input {
-        #[prost(oneof = "input::Input", tags = "1, 2, 3, 4")]
-        pub input: ::core::option::Option<input::Input>,
-    }
-    /// Nested message and enum types in `Input`.
-    pub mod input {
-        #[allow(clippy::derive_partial_eq_without_eq)]
-        #[derive(Clone, PartialEq, ::prost::Message)]
-        pub struct Source {
-            /// ex: "sf.ethereum.type.v1.Block"
-            #[prost(string, tag = "1")]
-            pub r#type: ::prost::alloc::string::String,
-        }
-        #[allow(clippy::derive_partial_eq_without_eq)]
-        #[derive(Clone, PartialEq, ::prost::Message)]
-        pub struct Map {
-            /// ex: "block_to_pairs"
-            #[prost(string, tag = "1")]
-            pub module_name: ::prost::alloc::string::String,
-        }
-        #[allow(clippy::derive_partial_eq_without_eq)]
-        #[derive(Clone, PartialEq, ::prost::Message)]
-        pub struct Store {
-            #[prost(string, tag = "1")]
-            pub module_name: ::prost::alloc::string::String,
-            #[prost(enumeration = "store::Mode", tag = "2")]
-            pub mode: i32,
-        }
-        /// Nested message and enum types in `Store`.
-        pub mod store {
-            #[derive(
-                Clone,
-                Copy,
-                Debug,
-                PartialEq,
-                Eq,
-                Hash,
-                PartialOrd,
-                Ord,
-                ::prost::Enumeration
-            )]
-            #[repr(i32)]
-            pub enum Mode {
-                Unset = 0,
-                Get = 1,
-                Deltas = 2,
-            }
-            impl Mode {
-                /// String value of the enum field names used in the ProtoBuf definition.
-                ///
-                /// The values are not transformed in any way and thus are considered stable
-                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-                pub fn as_str_name(&self) -> &'static str {
-                    match self {
-                        Mode::Unset => "UNSET",
-                        Mode::Get => "GET",
-                        Mode::Deltas => "DELTAS",
-                    }
-                }
-                /// Creates an enum from field names used in the ProtoBuf definition.
-                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-                    match value {
-                        "UNSET" => Some(Self::Unset),
-                        "GET" => Some(Self::Get),
-                        "DELTAS" => Some(Self::Deltas),
-                        _ => None,
-                    }
-                }
-            }
-        }
-        #[allow(clippy::derive_partial_eq_without_eq)]
-        #[derive(Clone, PartialEq, ::prost::Message)]
-        pub struct Params {
-            #[prost(string, tag = "1")]
-            pub value: ::prost::alloc::string::String,
-        }
-        #[allow(clippy::derive_partial_eq_without_eq)]
-        #[derive(Clone, PartialEq, ::prost::Oneof)]
-        pub enum Input {
-            #[prost(message, tag = "1")]
-            Source(Source),
-            #[prost(message, tag = "2")]
-            Map(Map),
-            #[prost(message, tag = "3")]
-            Store(Store),
-            #[prost(message, tag = "4")]
-            Params(Params),
-        }
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct Output {
-        #[prost(string, tag = "1")]
-        pub r#type: ::prost::alloc::string::String,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Kind {
-        #[prost(message, tag = "2")]
-        KindMap(KindMap),
-        #[prost(message, tag = "3")]
-        KindStore(KindStore),
-    }
-}
-/// Clock is a pointer to a block with added timestamp
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Clock {
-    #[prost(string, tag = "1")]
-    pub id: ::prost::alloc::string::String,
-    #[prost(uint64, tag = "2")]
-    pub number: u64,
-    #[prost(message, optional, tag = "3")]
-    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
-}
-/// BlockRef is a pointer to a block to which we don't know the timestamp
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockRef {
-    #[prost(string, tag = "1")]
-    pub id: ::prost::alloc::string::String,
-    #[prost(uint64, tag = "2")]
-    pub number: u64,
-}
diff --git a/graph/src/substreams_rpc/codec.rs b/graph/src/substreams_rpc/codec.rs
deleted file mode 100644
index d70a9e53762..00000000000
--- a/graph/src/substreams_rpc/codec.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#[rustfmt::skip]
-#[path = "sf.substreams.rpc.v2.rs"]
-mod pbsubstreamsrpc;
-
-pub use pbsubstreamsrpc::*;
diff --git a/graph/src/substreams_rpc/mod.rs b/graph/src/substreams_rpc/mod.rs
deleted file mode 100644
index 38e96fd598d..00000000000
--- a/graph/src/substreams_rpc/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod codec;
-
-pub use codec::*;
diff --git a/graph/src/substreams_rpc/sf.substreams.rpc.v2.rs b/graph/src/substreams_rpc/sf.substreams.rpc.v2.rs
deleted file mode 100644
index da8b4bf8ad8..00000000000
--- a/graph/src/substreams_rpc/sf.substreams.rpc.v2.rs
+++ /dev/null
@@ -1,596 +0,0 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Request {
-    #[prost(int64, tag = "1")]
-    pub start_block_num: i64,
-    #[prost(string, tag = "2")]
-    pub start_cursor: ::prost::alloc::string::String,
-    #[prost(uint64, tag = "3")]
-    pub stop_block_num: u64,
-    /// With final_block_only, you only receive blocks that are irreversible:
-    /// 'final_block_height' will be equal to current block and no 'undo_signal' will ever be sent
-    #[prost(bool, tag = "4")]
-    pub final_blocks_only: bool,
-    /// Substreams has two mode when executing your module(s) either development mode or production
-    /// mode. Development and production modes impact the execution of Substreams, important aspects
-    /// of execution include:
-    /// * The time required to reach the first byte.
-    /// * The speed that large ranges get executed.
-    /// * The module logs and outputs sent back to the client.
-    ///
-    /// By default, the engine runs in developer mode, with richer and deeper output. Differences
-    /// between production and development modes include:
-    /// * Forward parallel execution is enabled in production mode and disabled in development mode
-    /// * The time required to reach the first byte in development mode is faster than in production mode.
-    ///
-    /// Specific attributes of development mode include:
-    /// * The client will receive all of the executed module's logs.
-    /// * It's possible to request specific store snapshots in the execution tree (via `debug_initial_store_snapshot_for_modules`).
-    /// * Multiple module's output is possible.
-    ///
-    /// With production mode`, however, you trade off functionality for high speed enabling forward
-    /// parallel execution of module ahead of time.
-    #[prost(bool, tag = "5")]
-    pub production_mode: bool,
-    #[prost(string, tag = "6")]
-    pub output_module: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "7")]
-    pub modules: ::core::option::Option<crate::substreams::Modules>,
-    /// Available only in developer mode
-    #[prost(string, repeated, tag = "10")]
-    pub debug_initial_store_snapshot_for_modules: ::prost::alloc::vec::Vec<
-        ::prost::alloc::string::String,
-    >,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Response {
-    #[prost(oneof = "response::Message", tags = "1, 2, 3, 4, 5, 10, 11")]
-    pub message: ::core::option::Option<response::Message>,
-}
-/// Nested message and enum types in `Response`.
-pub mod response {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Message {
-        /// Always sent first
-        #[prost(message, tag = "1")]
-        Session(super::SessionInit),
-        /// Progress of data preparation, before sending in the stream of `data` events.
-        #[prost(message, tag = "2")]
-        Progress(super::ModulesProgress),
-        #[prost(message, tag = "3")]
-        BlockScopedData(super::BlockScopedData),
-        #[prost(message, tag = "4")]
-        BlockUndoSignal(super::BlockUndoSignal),
-        #[prost(message, tag = "5")]
-        FatalError(super::Error),
-        /// Available only in developer mode, and only if `debug_initial_store_snapshot_for_modules` is set.
-        #[prost(message, tag = "10")]
-        DebugSnapshotData(super::InitialSnapshotData),
-        /// Available only in developer mode, and only if `debug_initial_store_snapshot_for_modules` is set.
-        #[prost(message, tag = "11")]
-        DebugSnapshotComplete(super::InitialSnapshotComplete),
-    }
-}
-/// BlockUndoSignal informs you that every bit of data
-/// with a block number above 'last_valid_block' has been reverted
-/// on-chain. Delete that data and restart from 'last_valid_cursor'
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockUndoSignal {
-    #[prost(message, optional, tag = "1")]
-    pub last_valid_block: ::core::option::Option<crate::substreams::BlockRef>,
-    #[prost(string, tag = "2")]
-    pub last_valid_cursor: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockScopedData {
-    #[prost(message, optional, tag = "1")]
-    pub output: ::core::option::Option<MapModuleOutput>,
-    #[prost(message, optional, tag = "2")]
-    pub clock: ::core::option::Option<crate::substreams::Clock>,
-    #[prost(string, tag = "3")]
-    pub cursor: ::prost::alloc::string::String,
-    /// Non-deterministic, allows substreams-sink to let go of their undo data.
-    #[prost(uint64, tag = "4")]
-    pub final_block_height: u64,
-    #[prost(message, repeated, tag = "10")]
-    pub debug_map_outputs: ::prost::alloc::vec::Vec<MapModuleOutput>,
-    #[prost(message, repeated, tag = "11")]
-    pub debug_store_outputs: ::prost::alloc::vec::Vec<StoreModuleOutput>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SessionInit {
-    #[prost(string, tag = "1")]
-    pub trace_id: ::prost::alloc::string::String,
-    #[prost(uint64, tag = "2")]
-    pub resolved_start_block: u64,
-    #[prost(uint64, tag = "3")]
-    pub linear_handoff_block: u64,
-    #[prost(uint64, tag = "4")]
-    pub max_parallel_workers: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct InitialSnapshotComplete {
-    #[prost(string, tag = "1")]
-    pub cursor: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct InitialSnapshotData {
-    #[prost(string, tag = "1")]
-    pub module_name: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "2")]
-    pub deltas: ::prost::alloc::vec::Vec<StoreDelta>,
-    #[prost(uint64, tag = "4")]
-    pub sent_keys: u64,
-    #[prost(uint64, tag = "3")]
-    pub total_keys: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MapModuleOutput {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "2")]
-    pub map_output: ::core::option::Option<::prost_types::Any>,
-    /// DebugOutputInfo is available in non-production mode only
-    #[prost(message, optional, tag = "10")]
-    pub debug_info: ::core::option::Option<OutputDebugInfo>,
-}
-/// StoreModuleOutput are produced for store modules in development mode.
-/// It is not possible to retrieve store models in production, with parallelization
-/// enabled. If you need the deltas directly, write a pass through mapper module
-/// that will get them down to you.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct StoreModuleOutput {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "2")]
-    pub debug_store_deltas: ::prost::alloc::vec::Vec<StoreDelta>,
-    #[prost(message, optional, tag = "10")]
-    pub debug_info: ::core::option::Option<OutputDebugInfo>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct OutputDebugInfo {
-    #[prost(string, repeated, tag = "1")]
-    pub logs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    /// LogsTruncated is a flag that tells you if you received all the logs or if they
-    /// were truncated because you logged too much (fixed limit currently is set to 128 KiB).
-    #[prost(bool, tag = "2")]
-    pub logs_truncated: bool,
-    #[prost(bool, tag = "3")]
-    pub cached: bool,
-}
-/// ModulesProgress is a message that is sent every 500ms
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ModulesProgress {
-    /// List of jobs running on tier2 servers
-    #[prost(message, repeated, tag = "2")]
-    pub running_jobs: ::prost::alloc::vec::Vec<Job>,
-    /// Execution statistics for each module
-    #[prost(message, repeated, tag = "3")]
-    pub modules_stats: ::prost::alloc::vec::Vec<ModuleStats>,
-    /// Stages definition and completed block ranges
-    #[prost(message, repeated, tag = "4")]
-    pub stages: ::prost::alloc::vec::Vec<Stage>,
-    #[prost(message, optional, tag = "5")]
-    pub processed_bytes: ::core::option::Option<ProcessedBytes>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ProcessedBytes {
-    #[prost(uint64, tag = "1")]
-    pub total_bytes_read: u64,
-    #[prost(uint64, tag = "2")]
-    pub total_bytes_written: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Error {
-    #[prost(string, tag = "1")]
-    pub module: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub reason: ::prost::alloc::string::String,
-    #[prost(string, repeated, tag = "3")]
-    pub logs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    /// FailureLogsTruncated is a flag that tells you if you received all the logs or if they
-    /// were truncated because you logged too much (fixed limit currently is set to 128 KiB).
-    #[prost(bool, tag = "4")]
-    pub logs_truncated: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Job {
-    #[prost(uint32, tag = "1")]
-    pub stage: u32,
-    #[prost(uint64, tag = "2")]
-    pub start_block: u64,
-    #[prost(uint64, tag = "3")]
-    pub stop_block: u64,
-    #[prost(uint64, tag = "4")]
-    pub processed_blocks: u64,
-    #[prost(uint64, tag = "5")]
-    pub duration_ms: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Stage {
-    #[prost(string, repeated, tag = "1")]
-    pub modules: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(message, repeated, tag = "2")]
-    pub completed_ranges: ::prost::alloc::vec::Vec<BlockRange>,
-}
-/// ModuleStats gathers metrics and statistics from each module, running on tier1 or tier2
-/// All the 'count' and 'time_ms' values may include duplicate for each stage going over that module
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ModuleStats {
-    /// name of the module
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    /// total_processed_blocks is the sum of blocks sent to that module code
-    #[prost(uint64, tag = "2")]
-    pub total_processed_block_count: u64,
-    /// total_processing_time_ms is the sum of all time spent running that module code
-    #[prost(uint64, tag = "3")]
-    pub total_processing_time_ms: u64,
-    /// // external_calls are chain-specific intrinsics, like "Ethereum RPC calls".
-    #[prost(message, repeated, tag = "4")]
-    pub external_call_metrics: ::prost::alloc::vec::Vec<ExternalCallMetric>,
-    /// total_store_operation_time_ms is the sum of all time spent running that module code waiting for a store operation (ex: read, write, delete...)
-    #[prost(uint64, tag = "5")]
-    pub total_store_operation_time_ms: u64,
-    /// total_store_read_count is the sum of all the store Read operations called from that module code
-    #[prost(uint64, tag = "6")]
-    pub total_store_read_count: u64,
-    /// total_store_write_count is the sum of all store Write operations called from that module code (store-only)
-    #[prost(uint64, tag = "10")]
-    pub total_store_write_count: u64,
-    /// total_store_deleteprefix_count is the sum of all store DeletePrefix operations called from that module code (store-only)
-    /// note that DeletePrefix can be a costly operation on large stores
-    #[prost(uint64, tag = "11")]
-    pub total_store_deleteprefix_count: u64,
-    /// store_size_bytes is the uncompressed size of the full KV store for that module, from the last 'merge' operation (store-only)
-    #[prost(uint64, tag = "12")]
-    pub store_size_bytes: u64,
-    /// total_store_merging_time_ms is the time spent merging partial stores into a full KV store for that module (store-only)
-    #[prost(uint64, tag = "13")]
-    pub total_store_merging_time_ms: u64,
-    /// store_currently_merging is true if there is a merging operation (partial store to full KV store) on the way.
-    #[prost(bool, tag = "14")]
-    pub store_currently_merging: bool,
-    /// highest_contiguous_block is the highest block in the highest merged full KV store of that module (store-only)
-    #[prost(uint64, tag = "15")]
-    pub highest_contiguous_block: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ExternalCallMetric {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(uint64, tag = "2")]
-    pub count: u64,
-    #[prost(uint64, tag = "3")]
-    pub time_ms: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct StoreDelta {
-    #[prost(enumeration = "store_delta::Operation", tag = "1")]
-    pub operation: i32,
-    #[prost(uint64, tag = "2")]
-    pub ordinal: u64,
-    #[prost(string, tag = "3")]
-    pub key: ::prost::alloc::string::String,
-    #[prost(bytes = "vec", tag = "4")]
-    pub old_value: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "5")]
-    pub new_value: ::prost::alloc::vec::Vec<u8>,
-}
-/// Nested message and enum types in `StoreDelta`.
-pub mod store_delta {
-    #[derive(
-        Clone,
-        Copy,
-        Debug,
-        PartialEq,
-        Eq,
-        Hash,
-        PartialOrd,
-        Ord,
-        ::prost::Enumeration
-    )]
-    #[repr(i32)]
-    pub enum Operation {
-        Unset = 0,
-        Create = 1,
-        Update = 2,
-        Delete = 3,
-    }
-    impl Operation {
-        /// String value of the enum field names used in the ProtoBuf definition.
-        ///
-        /// The values are not transformed in any way and thus are considered stable
-        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-        pub fn as_str_name(&self) -> &'static str {
-            match self {
-                Operation::Unset => "UNSET",
-                Operation::Create => "CREATE",
-                Operation::Update => "UPDATE",
-                Operation::Delete => "DELETE",
-            }
-        }
-        /// Creates an enum from field names used in the ProtoBuf definition.
-        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-            match value {
-                "UNSET" => Some(Self::Unset),
-                "CREATE" => Some(Self::Create),
-                "UPDATE" => Some(Self::Update),
-                "DELETE" => Some(Self::Delete),
-                _ => None,
-            }
-        }
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockRange {
-    #[prost(uint64, tag = "2")]
-    pub start_block: u64,
-    #[prost(uint64, tag = "3")]
-    pub end_block: u64,
-}
-/// Generated client implementations.
-pub mod stream_client {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::*;
-    use tonic::codegen::http::Uri;
-    #[derive(Debug, Clone)]
-    pub struct StreamClient<T> {
-        inner: tonic::client::Grpc<T>,
-    }
-    impl StreamClient<tonic::transport::Channel> {
-        /// Attempt to create a new client by connecting to a given endpoint.
-        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
-        where
-            D: std::convert::TryInto<tonic::transport::Endpoint>,
-            D::Error: Into<StdError>,
-        {
-            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
-            Ok(Self::new(conn))
-        }
-    }
-    impl<T> StreamClient<T>
-    where
-        T: tonic::client::GrpcService<tonic::body::BoxBody>,
-        T::Error: Into<StdError>,
-        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
-        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
-    {
-        pub fn new(inner: T) -> Self {
-            let inner = tonic::client::Grpc::new(inner);
-            Self { inner }
-        }
-        pub fn with_origin(inner: T, origin: Uri) -> Self {
-            let inner = tonic::client::Grpc::with_origin(inner, origin);
-            Self { inner }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> StreamClient<InterceptedService<T, F>>
-        where
-            F: tonic::service::Interceptor,
-            T::ResponseBody: Default,
-            T: tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-                Response = http::Response<
-                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                >,
-            >,
-            <T as tonic::codegen::Service<
-                http::Request<tonic::body::BoxBody>,
-            >>::Error: Into<StdError> + Send + Sync,
-        {
-            StreamClient::new(InterceptedService::new(inner, interceptor))
-        }
-        /// Compress requests with the given encoding.
-        ///
-        /// This requires the server to support it otherwise it might respond with an
-        /// error.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.send_compressed(encoding);
-            self
-        }
-        /// Enable decompressing responses.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.inner = self.inner.accept_compressed(encoding);
-            self
-        }
-        pub async fn blocks(
-            &mut self,
-            request: impl tonic::IntoRequest<super::Request>,
-        ) -> Result<
-                tonic::Response<tonic::codec::Streaming<super::Response>>,
-                tonic::Status,
-            > {
-            self.inner
-                .ready()
-                .await
-                .map_err(|e| {
-                    tonic::Status::new(
-                        tonic::Code::Unknown,
-                        format!("Service was not ready: {}", e.into()),
-                    )
-                })?;
-            let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static(
-                "/sf.substreams.rpc.v2.Stream/Blocks",
-            );
-            self.inner.server_streaming(request.into_request(), path, codec).await
-        }
-    }
-}
-/// Generated server implementations.
-pub mod stream_server {
-    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::*;
-    /// Generated trait containing gRPC methods that should be implemented for use with StreamServer.
-    #[async_trait]
-    pub trait Stream: Send + Sync + 'static {
-        /// Server streaming response type for the Blocks method.
-        type BlocksStream: futures_core::Stream<
-                Item = Result<super::Response, tonic::Status>,
-            >
-            + Send
-            + 'static;
-        async fn blocks(
-            &self,
-            request: tonic::Request<super::Request>,
-        ) -> Result<tonic::Response<Self::BlocksStream>, tonic::Status>;
-    }
-    #[derive(Debug)]
-    pub struct StreamServer<T: Stream> {
-        inner: _Inner<T>,
-        accept_compression_encodings: EnabledCompressionEncodings,
-        send_compression_encodings: EnabledCompressionEncodings,
-    }
-    struct _Inner<T>(Arc<T>);
-    impl<T: Stream> StreamServer<T> {
-        pub fn new(inner: T) -> Self {
-            Self::from_arc(Arc::new(inner))
-        }
-        pub fn from_arc(inner: Arc<T>) -> Self {
-            let inner = _Inner(inner);
-            Self {
-                inner,
-                accept_compression_encodings: Default::default(),
-                send_compression_encodings: Default::default(),
-            }
-        }
-        pub fn with_interceptor<F>(
-            inner: T,
-            interceptor: F,
-        ) -> InterceptedService<Self, F>
-        where
-            F: tonic::service::Interceptor,
-        {
-            InterceptedService::new(Self::new(inner), interceptor)
-        }
-        /// Enable decompressing requests with the given encoding.
-        #[must_use]
-        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.accept_compression_encodings.enable(encoding);
-            self
-        }
-        /// Compress responses with the given encoding, if the client supports it.
-        #[must_use]
-        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
-            self.send_compression_encodings.enable(encoding);
-            self
-        }
-    }
-    impl<T, B> tonic::codegen::Service<http::Request<B>> for StreamServer<T>
-    where
-        T: Stream,
-        B: Body + Send + 'static,
-        B::Error: Into<StdError> + Send + 'static,
-    {
-        type Response = http::Response<tonic::body::BoxBody>;
-        type Error = std::convert::Infallible;
-        type Future = BoxFuture<Self::Response, Self::Error>;
-        fn poll_ready(
-            &mut self,
-            _cx: &mut Context<'_>,
-        ) -> Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-        fn call(&mut self, req: http::Request<B>) -> Self::Future {
-            let inner = self.inner.clone();
-            match req.uri().path() {
-                "/sf.substreams.rpc.v2.Stream/Blocks" => {
-                    #[allow(non_camel_case_types)]
-                    struct BlocksSvc<T: Stream>(pub Arc<T>);
-                    impl<T: Stream> tonic::server::ServerStreamingService<super::Request>
-                    for BlocksSvc<T> {
-                        type Response = super::Response;
-                        type ResponseStream = T::BlocksStream;
-                        type Future = BoxFuture<
-                            tonic::Response<Self::ResponseStream>,
-                            tonic::Status,
-                        >;
-                        fn call(
-                            &mut self,
-                            request: tonic::Request<super::Request>,
-                        ) -> Self::Future {
-                            let inner = self.0.clone();
-                            let fut = async move { (*inner).blocks(request).await };
-                            Box::pin(fut)
-                        }
-                    }
-                    let accept_compression_encodings = self.accept_compression_encodings;
-                    let send_compression_encodings = self.send_compression_encodings;
-                    let inner = self.inner.clone();
-                    let fut = async move {
-                        let inner = inner.0;
-                        let method = BlocksSvc(inner);
-                        let codec = tonic::codec::ProstCodec::default();
-                        let mut grpc = tonic::server::Grpc::new(codec)
-                            .apply_compression_config(
-                                accept_compression_encodings,
-                                send_compression_encodings,
-                            );
-                        let res = grpc.server_streaming(method, req).await;
-                        Ok(res)
-                    };
-                    Box::pin(fut)
-                }
-                _ => {
-                    Box::pin(async move {
-                        Ok(
-                            http::Response::builder()
-                                .status(200)
-                                .header("grpc-status", "12")
-                                .header("content-type", "application/grpc")
-                                .body(empty_body())
-                                .unwrap(),
-                        )
-                    })
-                }
-            }
-        }
-    }
-    impl<T: Stream> Clone for StreamServer<T> {
-        fn clone(&self) -> Self {
-            let inner = self.inner.clone();
-            Self {
-                inner,
-                accept_compression_encodings: self.accept_compression_encodings,
-                send_compression_encodings: self.send_compression_encodings,
-            }
-        }
-    }
-    impl<T: Stream> Clone for _Inner<T> {
-        fn clone(&self) -> Self {
-            Self(self.0.clone())
-        }
-    }
-    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            write!(f, "{:?}", self.0)
-        }
-    }
-    impl<T: Stream> tonic::server::NamedService for StreamServer<T> {
-        const NAME: &'static str = "sf.substreams.rpc.v2.Stream";
-    }
-}
diff --git a/graph/src/tls.rs b/graph/src/tls.rs
new file mode 100644
index 00000000000..6c54cfc955d
--- /dev/null
+++ b/graph/src/tls.rs
@@ -0,0 +1,12 @@
+//! Process-wide TLS crypto provider setup.
+//!
+//! Our deps pull in `rustls` with both `aws_lc_rs` (via alloy) and `ring`
+//! (via object_store/reqwest). With multiple providers linked, `rustls`
+//! 0.23 panics on first TLS use unless a default is installed explicitly.
+//! Must be called once per process before any TLS connection is built.
+
+/// Install `aws_lc_rs` as the process-wide default `rustls` crypto provider.
+/// Idempotent: later calls are no-ops.
+pub fn install_default_crypto_provider() {
+    let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
+}
diff --git a/graph/src/task_spawn.rs b/graph/src/tokio.rs
similarity index 52%
rename from graph/src/task_spawn.rs
rename to graph/src/tokio.rs
index c323d6d85a4..1f7cb05f1cd 100644
--- a/graph/src/task_spawn.rs
+++ b/graph/src/tokio.rs
@@ -1,20 +1,49 @@
-//! The functions in this module should be used to execute futures, serving as a facade to the
-//! underlying executor implementation which currently is tokio. This serves a few purposes:
-//! - Avoid depending directly on tokio APIs, making upgrades or a potential switch easier.
-//! - Reflect our chosen default semantics of aborting on task panic, offering `*_allow_panic`
-//!   functions to opt out of that.
-//! - Reflect that historically we've used blocking futures due to making DB calls directly within
-//!   futures. This point should go away once https://github.com/graphprotocol/graph-node/issues/905
-//!   is resolved. Then the blocking flavors should no longer accept futures but closures.
+//! Helpers for dealing with certain aspects of tokio.
 //!
-//! These should not be called from within executors other than tokio, particularly the blocking
-//! functions will panic in that case. We should generally avoid mixing executors whenever possible.
+//! This module sets up a runtime on which all tests should run, as well as
+//! providing some functions for spawning tasks with our desired semantics.
+//!
+//! The functions in this module should be used to execute futures, serving
+//! as a facade to the underlying executor implementation which currently is
+//! tokio. This serves a few purposes:
+//! - Avoid depending directly on tokio APIs, making upgrades or a potential
+//!   switch easier.
+//! - Reflect our chosen default semantics of aborting on task panic,
+//!   offering `*_allow_panic` functions to opt out of that.
+//! - Reflect that historically we've used blocking futures due to making DB
+//!   calls directly within futures. This point should go away once
+//!   https://github.com/graphprotocol/graph-node/issues/905 is resolved.
+//!   Then the blocking flavors should no longer accept futures but
+//!   closures.
+//!
+//! These should not be called from within executors other than tokio,
+//! particularly the blocking functions will panic in that case. We should
+//! generally avoid mixing executors whenever possible.
 
 use futures03::future::{FutureExt, TryFutureExt};
 use std::future::Future as Future03;
 use std::panic::AssertUnwindSafe;
 use tokio::task::JoinHandle;
 
+#[cfg(debug_assertions)]
+use tokio::runtime::{Builder, Runtime};
+
+#[cfg(debug_assertions)]
+lazy_static::lazy_static! {
+    /// The one true runtime for all tests. Tests should use the
+    /// `graph::test` macro to make sure they are using this runtime, the
+    /// same way they would use `#[tokio::test]`.
+    ///
+    /// We need to make sure we use a single runtime because if there are
+    /// multiple runtimes involved, the task that diesel_async spawns to
+    /// drive database connections (see `drive_connection` in the
+    /// `diesel_async` crate) may end up on a different runtime than the one
+    /// the test is using, leading to that task getting dropped, and the
+    /// test using a connection receiving a `Connection closed` error.
+    pub static ref TEST_RUNTIME: Runtime =
+        Builder::new_multi_thread().enable_all().build().unwrap();
+}
+
 fn abort_on_panic<T: Send + 'static>(
     f: impl Future03<Output = T> + Send + 'static,
 ) -> impl Future03<Output = T> {
@@ -51,15 +80,17 @@ pub fn spawn_blocking_allow_panic<R: 'static + Send>(
 }
 
 /// Runs the future on the current thread. Panics if not within a tokio runtime.
+#[track_caller]
 pub fn block_on<T>(f: impl Future03<Output = T>) -> T {
     tokio::runtime::Handle::current().block_on(f)
 }
 
 /// Spawns a thread with access to the tokio runtime. Panics if the thread cannot be spawned.
-pub fn spawn_thread(
-    name: impl Into<String>,
-    f: impl 'static + FnOnce() + Send,
-) -> std::thread::JoinHandle<()> {
+pub fn spawn_thread<F, R>(name: impl Into<String>, f: F) -> std::thread::JoinHandle<R>
+where
+    F: 'static + FnOnce() -> R + Send,
+    R: 'static + Send,
+{
     let conf = std::thread::Builder::new().name(name.into());
     let runtime = tokio::runtime::Handle::current();
     conf.spawn(move || {
diff --git a/graph/src/util/backoff.rs b/graph/src/util/backoff.rs
index ffe8d5bb5d3..2f739a96ea9 100644
--- a/graph/src/util/backoff.rs
+++ b/graph/src/util/backoff.rs
@@ -51,7 +51,7 @@ impl ExponentialBackoff {
         if delay > self.ceiling {
             delay = self.ceiling;
         }
-        let jitter = rand::Rng::gen_range(&mut rand::thread_rng(), -self.jitter..=self.jitter);
+        let jitter = rand::Rng::random_range(&mut rand::rng(), -self.jitter..=self.jitter);
         delay.mul_f64(1.0 + jitter)
     }
 
@@ -132,7 +132,7 @@ mod tests {
         assert_eq!(backoff.next_attempt(), Duration::from_secs(45));
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn test_sleep_async() {
         let mut backoff =
             ExponentialBackoff::new(Duration::from_secs_f32(0.1), Duration::from_secs_f32(0.2));
diff --git a/graph/src/util/bounded_queue.rs b/graph/src/util/bounded_queue.rs
index f618c7eca7d..6129817eabe 100644
--- a/graph/src/util/bounded_queue.rs
+++ b/graph/src/util/bounded_queue.rs
@@ -169,6 +169,6 @@ impl<T: Clone> BoundedQueue<T> {
 
     /// Clear the queue by popping entries until there are none left
     pub fn clear(&self) {
-        while let Some(_) = self.try_pop() {}
+        while self.try_pop().is_some() {}
     }
 }
diff --git a/graph/src/util/cache_weight.rs b/graph/src/util/cache_weight.rs
index 73e207b963a..12bcc2446a8 100644
--- a/graph/src/util/cache_weight.rs
+++ b/graph/src/util/cache_weight.rs
@@ -1,11 +1,15 @@
+use chrono::{DateTime, TimeZone};
+
 use crate::{
     data::value::Word,
-    prelude::{q, BigDecimal, BigInt, Value},
-    schema::{EntityKey, EntityType},
+    prelude::{BigDecimal, BigInt, Value, q},
+    schema::EntityType,
 };
 use std::{
     collections::{BTreeMap, HashMap},
     mem,
+    sync::Arc,
+    time::Duration,
 };
 
 /// Estimate of how much memory a value consumes.
@@ -21,6 +25,54 @@ pub trait CacheWeight {
     fn indirect_weight(&self) -> usize;
 }
 
+impl CacheWeight for () {
+    fn indirect_weight(&self) -> usize {
+        0
+    }
+}
+
+impl CacheWeight for u8 {
+    fn indirect_weight(&self) -> usize {
+        0
+    }
+}
+
+impl CacheWeight for i32 {
+    fn indirect_weight(&self) -> usize {
+        0
+    }
+}
+
+impl CacheWeight for i64 {
+    fn indirect_weight(&self) -> usize {
+        0
+    }
+}
+
+impl CacheWeight for f64 {
+    fn indirect_weight(&self) -> usize {
+        0
+    }
+}
+
+impl CacheWeight for bool {
+    fn indirect_weight(&self) -> usize {
+        0
+    }
+}
+
+impl CacheWeight for Duration {
+    fn indirect_weight(&self) -> usize {
+        0
+    }
+}
+
+impl<T1: CacheWeight, T2: CacheWeight> CacheWeight for (T1, T2) {
+    fn indirect_weight(&self) -> usize {
+        self.0.indirect_weight() + self.1.indirect_weight()
+    }
+}
+
 impl<T: CacheWeight> CacheWeight for Option<T> {
     fn indirect_weight(&self) -> usize {
         match self {
@@ -30,6 +82,12 @@ impl<T: CacheWeight> CacheWeight for Option<T> {
     }
 }
 
+impl<T: CacheWeight> CacheWeight for Arc<T> {
+    fn indirect_weight(&self) -> usize {
+        (**self).indirect_weight()
+    }
+}
+
 impl<T: CacheWeight> CacheWeight for Vec<T> {
     fn indirect_weight(&self) -> usize {
         self.iter().map(CacheWeight::indirect_weight).sum::<usize>()
@@ -37,6 +95,13 @@ impl<T: CacheWeight> CacheWeight for Vec<T> {
     }
 }
 
+impl<T: CacheWeight> CacheWeight for Box<[T]> {
+    fn indirect_weight(&self) -> usize {
+        self.iter().map(CacheWeight::indirect_weight).sum::<usize>()
+            + self.len() * mem::size_of::<T>()
+    }
+}
+
 impl<T: CacheWeight, U: CacheWeight> CacheWeight for BTreeMap<T, U> {
     fn indirect_weight(&self) -> usize {
         self.iter()
@@ -75,13 +140,13 @@ impl CacheWeight for BigDecimal {
 
 impl CacheWeight for BigInt {
     fn indirect_weight(&self) -> usize {
-        self.bits() / 8
+        self.bits().div_ceil(8)
     }
 }
 
-impl CacheWeight for crate::data::store::scalar::Bytes {
+impl<TZ: TimeZone> CacheWeight for DateTime<TZ> {
     fn indirect_weight(&self) -> usize {
-        self.as_slice().len()
+        0
     }
 }
 
@@ -93,7 +158,9 @@ impl CacheWeight for Value {
             Value::List(values) => values.indirect_weight(),
             Value::Bytes(bytes) => bytes.indirect_weight(),
             Value::BigInt(n) => n.indirect_weight(),
-            Value::Int8(_) | Value::Int(_) | Value::Bool(_) | Value::Null => 0,
+            Value::Timestamp(_) | Value::Int8(_) | Value::Int(_) | Value::Bool(_) | Value::Null => {
+                0
+            }
         }
     }
 }
@@ -121,9 +188,9 @@ impl CacheWeight for EntityType {
     }
 }
 
-impl CacheWeight for EntityKey {
+impl CacheWeight for slog::Logger {
     fn indirect_weight(&self) -> usize {
-        self.entity_id.indirect_weight() + self.entity_type.indirect_weight()
+        0
     }
 }
 
@@ -149,6 +216,48 @@ fn big_decimal_cache_weight() {
     assert_eq!(n.indirect_weight(), 3);
 }
 
+#[test]
+fn derive_cache_weight() {
+    use crate::derive::CacheWeight;
+
+    #[derive(CacheWeight)]
+    struct Struct {
+        a: i32,
+        b: String,
+        c: Option<i32>,
+    }
+
+    #[derive(CacheWeight)]
+    enum Enum {
+        A(i32),
+        B(String),
+        C,
+        D(Vec<String>),
+    }
+
+    let s = Struct {
+        a: 42,
+        b: "hello".to_string(),
+        c: Some(42),
+    };
+    assert_eq!(s.weight(), 40 + 5);
+    let s = Struct {
+        a: 42,
+        b: String::new(),
+        c: None,
+    };
+    assert_eq!(s.weight(), 40);
+
+    let e = Enum::A(42);
+    assert_eq!(e.weight(), 32);
+    let e = Enum::B("hello".to_string());
+    assert_eq!(e.weight(), 32 + 5);
+    let e = Enum::C;
+    assert_eq!(e.weight(), 32);
+    let e = Enum::D(vec!["hello".to_string(), "world".to_string()]);
+    assert_eq!(e.weight(), 32 + 2 * (24 + 5));
+}
+
 /// Helpers to estimate the size of a `BTreeMap`. Everything in this module,
 /// except for `node_size()` is copied from `std::collections::btree`.
 ///
@@ -162,13 +271,12 @@ fn big_decimal_cache_weight() {
 /// number of entries divided by `NODE_FILL`, and the number of
 /// interior nodes can be determined by dividing the number of nodes
 /// at the child level by `NODE_FILL`
-
+///
 /// The other difficulty is that the structs with which `BTreeMap`
 /// represents internal and leaf nodes are not public, so we can't
 /// get their size with `std::mem::size_of`; instead, we base our
 /// estimates of their size on the current `std` code, assuming that
 /// these structs will not change
-
 pub mod btree {
     use std::collections::BTreeMap;
     use std::mem;
diff --git a/graph/src/util/futures.rs b/graph/src/util/futures.rs
index 9cb9d407c1e..f263480b063 100644
--- a/graph/src/util/futures.rs
+++ b/graph/src/util/futures.rs
@@ -1,13 +1,15 @@
 use crate::ext::futures::FutureExtension;
 use futures03::{Future, FutureExt, TryFutureExt};
-use slog::{debug, trace, warn, Logger};
+use lazy_static::lazy_static;
+use regex::Regex;
+use slog::{Logger, debug, trace, warn};
 use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::sync::Arc;
 use std::time::Duration;
 use thiserror::Error;
-use tokio_retry::strategy::{jitter, ExponentialBackoff};
 use tokio_retry::Retry;
+use tokio_retry::strategy::{ExponentialBackoff, jitter};
 
 // Use different limits for test and production code to speed up tests
 #[cfg(debug_assertions)]
@@ -61,8 +63,10 @@ pub fn retry<I, E>(operation_name: impl ToString, logger: &Logger) -> RetryConfi
         log_after: 1,
         warn_after: 10,
         limit: RetryConfigProperty::Unknown,
+        redact_log_urls: false,
         phantom_item: PhantomData,
         phantom_error: PhantomData,
+        max_delay: RETRY_DEFAULT_LIMIT,
     }
 }
 
@@ -75,6 +79,8 @@ pub struct RetryConfig<I, E> {
     limit: RetryConfigProperty<usize>,
     phantom_item: PhantomData<I>,
     phantom_error: PhantomData<E>,
+    redact_log_urls: bool,
+    max_delay: Duration,
 }
 
 impl<I, E> RetryConfig<I, E>
@@ -108,8 +114,8 @@ where
     /// Never log failed attempts.
     /// May still log at `trace` logging level.
     pub fn no_logging(mut self) -> Self {
-        self.log_after = u64::max_value();
-        self.warn_after = u64::max_value();
+        self.log_after = u64::MAX;
+        self.warn_after = u64::MAX;
         self
     }
 
@@ -125,6 +131,12 @@ where
         self
     }
 
+    /// Redact alphanumeric URLs from log messages.
+    pub fn redact_log_urls(mut self, redact_log_urls: bool) -> Self {
+        self.redact_log_urls = redact_log_urls;
+        self
+    }
+
     /// Set how long (in seconds) to wait for an attempt to complete before giving up on that
     /// attempt.
     pub fn timeout_secs(self, timeout_secs: u64) -> RetryConfigWithTimeout<I, E> {
@@ -149,6 +161,12 @@ where
     pub fn no_timeout(self) -> RetryConfigNoTimeout<I, E> {
         RetryConfigNoTimeout { inner: self }
     }
+
+    /// Set the maximum delay between retries.
+    pub fn max_delay(mut self, max_delay: Duration) -> Self {
+        self.max_delay = max_delay;
+        self
+    }
 }
 
 pub struct RetryConfigWithTimeout<I, E> {
@@ -173,6 +191,8 @@ where
         let log_after = self.inner.log_after;
         let warn_after = self.inner.warn_after;
         let limit_opt = self.inner.limit.unwrap(&operation_name, "limit");
+        let redact_log_urls = self.inner.redact_log_urls;
+        let max_delay = self.inner.max_delay;
         let timeout = self.timeout;
 
         trace!(logger, "Run with retry: {}", operation_name);
@@ -184,6 +204,8 @@ where
             log_after,
             warn_after,
             limit_opt,
+            redact_log_urls,
+            max_delay,
             move || {
                 try_it()
                     .timeout(timeout)
@@ -214,6 +236,8 @@ impl<I, E> RetryConfigNoTimeout<I, E> {
         let log_after = self.inner.log_after;
         let warn_after = self.inner.warn_after;
         let limit_opt = self.inner.limit.unwrap(&operation_name, "limit");
+        let redact_log_urls = self.inner.redact_log_urls;
+        let max_delay = self.inner.max_delay;
 
         trace!(logger, "Run with retry: {}", operation_name);
 
@@ -224,6 +248,8 @@ impl<I, E> RetryConfigNoTimeout<I, E> {
             log_after,
             warn_after,
             limit_opt,
+            redact_log_urls,
+            max_delay,
             // No timeout, so all errors are inner errors
             move || try_it().map_err(TimeoutError::Inner),
         )
@@ -265,6 +291,8 @@ fn run_retry<O, E, F, R>(
     log_after: u64,
     warn_after: u64,
     limit_opt: Option<usize>,
+    redact_log_urls: bool,
+    max_delay: Duration,
     mut try_it_with_timeout: F,
 ) -> impl Future<Output = Result<O, TimeoutError<E>>> + Send
 where
@@ -277,7 +305,7 @@ where
 
     let mut attempt_count = 0;
 
-    Retry::spawn(retry_strategy(limit_opt, RETRY_DEFAULT_LIMIT), move || {
+    Retry::start(retry_strategy(limit_opt, max_delay), move || {
         let operation_name = operation_name.clone();
         let logger = logger.clone();
         let condition = condition.clone();
@@ -311,25 +339,38 @@ where
 
                 // If needs retry
                 if condition.check(&result) {
+                    let result_str = || {
+                        if redact_log_urls {
+                            lazy_static! {
+                                static ref RE: Regex =
+                                    Regex::new(r#"https?://[a-zA-Z0-9\-\._:/\?#&=]+"#).unwrap();
+                            }
+                            let e = format!("{result:?}");
+                            RE.replace_all(&e, "[REDACTED]").into_owned()
+                        } else {
+                            format!("{result:?}")
+                        }
+                    };
+
                     if attempt_count >= warn_after {
                         // This looks like it would be nice to de-duplicate, but if we try
                         // to use log! slog complains about requiring a const for the log level
                         // See also b05e1594-e408-4047-aefb-71fc60d70e8f
                         warn!(
                             logger,
-                            "Trying again after {} failed (attempt #{}) with result {:?}",
+                            "Trying again after {} failed (attempt #{}) with result {}",
                             &operation_name,
                             attempt_count,
-                            result
+                            result_str(),
                         );
                     } else if attempt_count >= log_after {
                         // See also b05e1594-e408-4047-aefb-71fc60d70e8f
                         debug!(
                             logger,
-                            "Trying again after {} failed (attempt #{}) with result {:?}",
+                            "Trying again after {} failed (attempt #{}) with result {}",
                             &operation_name,
                             attempt_count,
-                            result
+                            result_str(),
                         );
                     }
 
@@ -371,7 +412,8 @@ pub fn retry_strategy(
         Some(limit) => {
             // Items are delays *between* attempts,
             // so subtract 1 from limit.
-            Box::new(backoff.take(limit - 1))
+            // Use saturating_sub to avoid underflow if limit is set to 0
+            Box::new(backoff.take(limit.saturating_sub(1)))
         }
         None => Box::new(backoff),
     }
@@ -439,12 +481,12 @@ where
 mod tests {
     use super::*;
 
-    use futures::future;
+    use futures01::future;
     use futures03::compat::Future01CompatExt;
     use slog::o;
     use std::sync::Mutex;
 
-    #[tokio::test]
+    #[crate::test]
     async fn test() {
         let logger = Logger::root(::slog::Discard, o!());
 
@@ -469,7 +511,7 @@ mod tests {
         assert_eq!(result, Ok(10));
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn limit_reached() {
         let logger = Logger::root(::slog::Discard, o!());
 
@@ -494,7 +536,7 @@ mod tests {
         assert_eq!(result, Err(5));
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn limit_not_reached() {
         let logger = Logger::root(::slog::Discard, o!());
 
@@ -519,7 +561,7 @@ mod tests {
         assert_eq!(result, Ok(10));
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn custom_when() {
         let logger = Logger::root(::slog::Discard, o!());
         let c = Mutex::new(0);
diff --git a/graph/src/util/herd_cache.rs b/graph/src/util/herd_cache.rs
index 0d32d423c7d..88f32ffb861 100644
--- a/graph/src/util/herd_cache.rs
+++ b/graph/src/util/herd_cache.rs
@@ -1,5 +1,5 @@
-use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::collections::hash_map::Entry;
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
@@ -10,6 +10,7 @@ use stable_hash_legacy::crypto::SetHasher;
 use stable_hash_legacy::prelude::*;
 
 use crate::cheap_clone::CheapClone;
+use crate::derive::CheapClone;
 
 use super::timed_rw_lock::TimedMutex;
 
@@ -25,13 +26,11 @@ type PinFut<R> = Pin<Box<dyn Future<Output = R> + 'static + Send>>;
 /// but more specialized. The name alludes to the fact that this data
 /// structure stops a thundering herd from causing the same work to be done
 /// repeatedly.
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 pub struct HerdCache<R> {
     cache: Arc<TimedMutex<HashMap<Hash, Shared<PinFut<R>>>>>,
 }
 
-impl<R: Clone> CheapClone for HerdCache<R> {}
-
 impl<R: CheapClone> HerdCache<R> {
     pub fn new(id: impl Into<String>) -> Self {
         Self {
diff --git a/graph/src/util/intern.rs b/graph/src/util/intern.rs
index ab5da53b485..655d71da9e7 100644
--- a/graph/src/util/intern.rs
+++ b/graph/src/util/intern.rs
@@ -14,6 +14,7 @@ use serde::Serialize;
 
 use crate::cheap_clone::CheapClone;
 use crate::data::value::Word;
+use crate::derive::CheapClone;
 use crate::runtime::gas::{Gas, GasSizeOf};
 
 use super::cache_weight::CacheWeight;
@@ -27,11 +28,12 @@ type AtomInt = u16;
 ///
 /// The ordering for atoms is based on their integer value, and has no
 /// connection to how the strings they represent would be ordered
-#[derive(Eq, Hash, PartialEq, PartialOrd, Ord, Clone, Copy, Debug)]
+#[derive(Eq, Hash, PartialEq, PartialOrd, Ord, Clone, Copy, CheapClone, Debug)]
 pub struct Atom(AtomInt);
 
 /// An atom and the underlying pool. A `FatAtom` can be used in place of a
 /// `String` or `Word`
+#[allow(dead_code)]
 pub struct FatAtom {
     pool: Arc<AtomPool>,
     atom: Atom,
@@ -62,7 +64,7 @@ impl Error {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Default)]
 /// A pool of interned strings. Pools can be organized hierarchically with
 /// lookups in child pools also considering the parent pool. The chain of
 /// pools from a pool through all its ancestors act as one big pool to the
@@ -101,7 +103,7 @@ impl AtomPool {
     /// pool or any of its ancestors.
     pub fn get(&self, atom: Atom) -> Option<&str> {
         if atom.0 < self.base_sym {
-            self.base.as_ref().map(|base| base.get(atom)).flatten()
+            self.base.as_ref().and_then(|base| base.get(atom))
         } else {
             self.atoms
                 .get((atom.0 - self.base_sym) as usize)
@@ -112,10 +114,10 @@ impl AtomPool {
     /// Get the atom for `word`. Return `None` if the word is not in this
     /// pool or any of its ancestors.
     pub fn lookup(&self, word: &str) -> Option<Atom> {
-        if let Some(base) = &self.base {
-            if let Some(atom) = base.lookup(word) {
-                return Some(atom);
-            }
+        if let Some(base) = &self.base
+            && let Some(atom) = base.lookup(word)
+        {
+            return Some(atom);
         }
 
         self.words.get(word).cloned()
@@ -209,6 +211,10 @@ impl<V> Object<V> {
             .count()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     /// Find the value for `key` in the object. Return `None` if the key is
     /// not present.
     pub fn get(&self, key: &str) -> Option<&V> {
@@ -269,7 +275,7 @@ impl<V> Object<V> {
     pub(crate) fn contains_key(&self, key: &str) -> bool {
         self.entries
             .iter()
-            .any(|entry| self.pool.get(entry.key).map_or(false, |k| key == k))
+            .any(|entry| self.pool.get(entry.key) == Some(key))
     }
 
     pub fn merge(&mut self, other: Object<V>) {
@@ -306,6 +312,45 @@ impl<V> Object<V> {
     }
 }
 
+impl<V: PartialEq> Object<V> {
+    fn len_ignore_atom(&self, atom: &Atom) -> usize {
+        // Because of tombstones and the ignored atom, we can't just return `self.entries.len()`.
+        self.entries
+            .iter()
+            .filter(|entry| entry.key != TOMBSTONE_KEY && entry.key != *atom)
+            .count()
+    }
+
+    /// Check for equality while ignoring one particular element
+    pub fn eq_ignore_key(&self, other: &Self, ignore_key: &str) -> bool {
+        let ignore = self.pool.lookup(ignore_key);
+        let len1 = if let Some(to_ignore) = ignore {
+            self.len_ignore_atom(&to_ignore)
+        } else {
+            self.len()
+        };
+        let len2 = if let Some(to_ignore) = other.pool.lookup(ignore_key) {
+            other.len_ignore_atom(&to_ignore)
+        } else {
+            other.len()
+        };
+        if len1 != len2 {
+            return false;
+        }
+
+        if self.same_pool(other) {
+            self.entries
+                .iter()
+                .filter(|e| e.key != TOMBSTONE_KEY && (ignore != Some(e.key)))
+                .all(|Entry { key, value }| other.get_by_atom(key) == Some(value))
+        } else {
+            self.iter()
+                .filter(|(key, _)| *key != ignore_key)
+                .all(|(key, value)| other.get(key) == Some(value))
+        }
+    }
+}
+
 impl<V: NullValue> Object<V> {
     /// Remove `key` from the object and return the value that was
     /// associated with the `key`. The entry is actually not removed for
@@ -344,7 +389,7 @@ impl<'a, V> Iterator for ObjectIter<'a, V> {
     type Item = (&'a str, &'a V);
 
     fn next(&mut self) -> Option<Self::Item> {
-        while let Some(entry) = self.iter.next() {
+        for entry in self.iter.by_ref() {
             if entry.key != TOMBSTONE_KEY {
                 // unwrap: we only add entries that are backed by the pool
                 let key = self.pool.get(entry.key).unwrap();
@@ -383,7 +428,7 @@ impl<V> Iterator for ObjectOwningIter<V> {
     type Item = (Word, V);
 
     fn next(&mut self) -> Option<Self::Item> {
-        while let Some(entry) = self.iter.next() {
+        for entry in self.iter.by_ref() {
             if entry.key != TOMBSTONE_KEY {
                 // unwrap: we only add entries that are backed by the pool
                 let key = self.pool.get(entry.key).unwrap();
@@ -410,7 +455,7 @@ impl<'a, V> Iterator for AtomIter<'a, V> {
     type Item = Atom;
 
     fn next(&mut self) -> Option<Self::Item> {
-        while let Some(entry) = self.iter.next() {
+        for entry in self.iter.by_ref() {
             if entry.key != TOMBSTONE_KEY {
                 return Some(entry.key);
             }
@@ -457,17 +502,15 @@ impl<V: PartialEq> PartialEq for Object<V> {
             self.entries
                 .iter()
                 .filter(|e| e.key != TOMBSTONE_KEY)
-                .all(|Entry { key, value }| other.get_by_atom(key).map_or(false, |o| o == value))
+                .all(|Entry { key, value }| other.get_by_atom(key) == Some(value))
         } else {
             self.iter()
-                .all(|(key, value)| other.get(key).map_or(false, |o| o == value))
+                .all(|(key, value)| other.get(key) == Some(value))
         }
     }
 }
 
-impl<V: Eq> Eq for Object<V> {
-    fn assert_receiver_is_total_eq(&self) {}
-}
+impl<V: Eq> Eq for Object<V> {}
 
 impl<V: Serialize> Serialize for Object<V> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
diff --git a/graph/src/util/jobs.rs b/graph/src/util/jobs.rs
index fdda7d365b4..bd5d10b854d 100644
--- a/graph/src/util/jobs.rs
+++ b/graph/src/util/jobs.rs
@@ -3,9 +3,9 @@
 //! to be done on a tight deadline, solely for work that needs to be done
 //! at reasonably long intervals (like a few hours)
 
-use slog::{debug, info, o, trace, warn, Logger};
-use std::sync::atomic::{AtomicBool, Ordering};
+use slog::{Logger, debug, info, o, trace, warn};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::{Duration, Instant};
 
 use async_trait::async_trait;
@@ -123,7 +123,7 @@ mod tests {
         }
     }
 
-    #[tokio::test(flavor = "multi_thread")]
+    #[crate::test]
     async fn jobs_run() {
         let count = Arc::new(Mutex::new(0));
         let job = CounterJob {
@@ -142,7 +142,7 @@ mod tests {
                 break;
             }
             if start.elapsed() > Duration::from_secs(2) {
-                assert!(false, "Counting to 10 took longer than 2 seconds");
+                panic!("Counting to 10 took longer than 2 seconds");
             }
         }
 
diff --git a/graph/src/util/lfu_cache.rs b/graph/src/util/lfu_cache.rs
index f99d24fc744..12712350a01 100644
--- a/graph/src/util/lfu_cache.rs
+++ b/graph/src/util/lfu_cache.rs
@@ -168,7 +168,9 @@ impl<K: Clone + Ord + Eq + Hash + Debug + CacheWeight, V: CacheWeight + Default>
         // Increment the frequency by 1
         let key_entry = CacheEntry::cache_key(key);
         self.queue
-            .change_priority_by(&key_entry, |(s, Reverse(f))| (s, Reverse(f + 1)));
+            .change_priority_by(&key_entry, |(_, Reverse(f))| {
+                *f += 1;
+            });
         self.accesses += 1;
         self.queue.get_mut(&key_entry).map(|x| {
             self.hits += 1;
@@ -177,7 +179,7 @@ impl<K: Clone + Ord + Eq + Hash + Debug + CacheWeight, V: CacheWeight + Default>
         })
     }
 
-    pub fn iter<'a>(&'a self) -> impl Iterator<Item = (&K, &V)> {
+    pub fn iter(&self) -> impl Iterator<Item = (&K, &V)> {
         self.queue
             .iter()
             .map(|entry| (&entry.0.key, &entry.0.value))
@@ -192,7 +194,7 @@ impl<K: Clone + Ord + Eq + Hash + Debug + CacheWeight, V: CacheWeight + Default>
         // the absolute minimum and popping.
         let key_entry = CacheEntry::cache_key(key.clone());
         self.queue
-            .change_priority(&key_entry, (true, Reverse(u64::min_value())))
+            .change_priority(&key_entry, (true, Reverse(u64::MIN)))
             .and_then(|_| {
                 self.queue.pop().map(|(e, _)| {
                     assert_eq!(e.key, key_entry.key);
diff --git a/graph/src/util/mem.rs b/graph/src/util/mem.rs
index b98b7d5ed87..02982c962d2 100644
--- a/graph/src/util/mem.rs
+++ b/graph/src/util/mem.rs
@@ -1,4 +1,4 @@
-use std::mem::{transmute, MaybeUninit};
+use std::mem::{MaybeUninit, transmute};
 
 /// Temporarily needed until MaybeUninit::write_slice is stabilized.
 pub fn init_slice<'a, T>(src: &[T], dst: &'a mut [MaybeUninit<T>]) -> &'a mut [T]
diff --git a/graph/src/util/mod.rs b/graph/src/util/mod.rs
index 68c86daea3c..7a67c984a63 100644
--- a/graph/src/util/mod.rs
+++ b/graph/src/util/mod.rs
@@ -12,6 +12,8 @@ pub mod error;
 
 pub mod stats;
 
+pub mod ogive;
+
 pub mod cache_weight;
 
 pub mod timed_rw_lock;
@@ -33,3 +35,6 @@ pub mod monitored;
 pub mod intern;
 
 pub mod herd_cache;
+
+/// Test utilities for creating mock blockchain data structures
+pub mod test_utils;
diff --git a/graph/src/util/ogive.rs b/graph/src/util/ogive.rs
new file mode 100644
index 00000000000..a90d414b038
--- /dev/null
+++ b/graph/src/util/ogive.rs
@@ -0,0 +1,301 @@
+use std::ops::RangeInclusive;
+
+use crate::{internal_error, prelude::StoreError};
+
+/// A helper to deal with cumulative histograms, also known as ogives. This
+/// implementation is restricted to histograms where each bin has the same
+/// size. As a cumulative function of a histogram, an ogive is a piecewise
+/// linear function `f` and since it is strictly monotonically increasing,
+/// it has an inverse `g`.
+///
+/// For the given `points`, `f(points[i]) = i * bin_size` and `f` is the
+/// piecewise linear interpolant between those points. The inverse `g` is
+/// the piecewise linear interpolant of `g(i * bin_size) = points[i]`. Note
+/// that that means that `f` divides the y-axis into `points.len()` equal
+/// parts.
+///
+/// The word 'ogive' is somewhat obscure, but has a lot fewer letters than
+/// 'piecewise linear function'. Copolit also claims that it is also a lot
+/// more fun to say.
+pub struct Ogive {
+    /// The breakpoints of the piecewise linear function
+    points: Vec<i64>,
+    /// The size of each bin; the linear piece from `points[i]` to
+    /// `points[i+1]` rises by this much
+    bin_size: f64,
+    /// The range of the ogive, i.e., the minimum and maximum entries from
+    /// points
+    range: RangeInclusive<i64>,
+}
+
+impl Ogive {
+    /// Create an ogive from a histogram with breaks at the given points and
+    /// a total count of `total` entries. As a function, the ogive is 0 at
+    /// `points[0]` and `total` at `points[points.len() - 1]`.
+    ///
+    /// The `points` must have at least one entry. The `points` are sorted
+    /// and deduplicated, i.e., they don't have to be in ascending order.
+    pub fn from_equi_histogram(mut points: Vec<i64>, total: usize) -> Result<Self, StoreError> {
+        if points.is_empty() {
+            return Err(internal_error!("histogram must have at least one point"));
+        }
+
+        points.sort_unstable();
+        points.dedup();
+
+        let bins = points.len() - 1;
+        let bin_size = total as f64 / bins as f64;
+        let range = points[0]..=points[bins];
+        Ok(Self {
+            points,
+            bin_size,
+            range,
+        })
+    }
+
+    pub fn start(&self) -> i64 {
+        *self.range.start()
+    }
+
+    pub fn end(&self) -> i64 {
+        *self.range.end()
+    }
+
+    /// Find the next point `next` such that there are `size` entries
+    /// between `point` and `next`, i.e., such that `f(next) - f(point) =
+    /// size`.
+    ///
+    /// It is an error if `point` is smaller than `points[0]`. If `point` is
+    /// bigger than `points.last()`, that is returned instead.
+    ///
+    /// The method calculates `g(f(point) + size)`
+    pub fn next_point(&self, point: i64, size: usize) -> Result<i64, StoreError> {
+        if point >= *self.range.end() {
+            return Ok(*self.range.end());
+        }
+        // This can only fail if point < self.range.start
+        self.check_in_range(point)?;
+
+        let point_value = self.value(point)?;
+        let next_value = point_value + size as i64;
+        let next_point = self.inverse(next_value)?;
+        Ok(next_point)
+    }
+
+    /// Return the index of the support point immediately preceding `point`.
+    /// It is an error if `point` is outside the range of points of this
+    /// ogive; this also implies that the returned index is always strictly
+    /// less than `self.points.len() - 1`
+    fn interval_start(&self, point: i64) -> Result<usize, StoreError> {
+        self.check_in_range(point)?;
+
+        let idx = self
+            .points
+            .iter()
+            .position(|&p| point < p)
+            .unwrap_or(self.points.len() - 1)
+            - 1;
+        Ok(idx)
+    }
+
+    /// Return the value of the ogive at `point`, i.e., `f(point)`. It is an
+    /// error if `point` is outside the range of points of this ogive.
+    ///
+    /// If `i` is such that
+    /// `points[i] <= point < points[i+1]`, then
+    /// ```text
+    ///   f(point) = i * bin_size + (point - points[i]) / (points[i+1] - points[i]) * bin_size
+    /// ```
+    // See the comment on `inverse` for numerical considerations
+    fn value(&self, point: i64) -> Result<i64, StoreError> {
+        if self.points.len() == 1 {
+            return Ok(*self.range.end());
+        }
+
+        let idx = self.interval_start(point)?;
+        let (a, b) = (self.points[idx], self.points[idx + 1]);
+        let offset = (point - a) as f64 / (b - a) as f64;
+        let value = (idx as f64 + offset) * self.bin_size;
+        Ok(value as i64)
+    }
+
+    /// Return the value of the inverse ogive at `value`, i.e., `g(value)`.
+    /// It is an error if `value` is negative. If `value` is greater than
+    /// the total count of the ogive, the maximum point of the ogive is
+    /// returned.
+    ///
+    /// For `points[j] <= v < points[j+1]`, the value of `g(v)` is
+    /// ```text
+    ///  g(v) = (1-lambda)*points[j] + lambda * points[j+1]
+    /// ```
+    /// where `lambda = (v - j * bin_size) / bin_size`
+    ///
+    // Note that in the definition of `lambda`, the numerator is
+    // `v.rem_euclid(bin_size)`
+    //
+    // Numerical consideration: in these calculations, we need to be careful
+    // to never convert one of the points directly to f64 since they can be
+    // so large that the conversion from i64 to f64 loses precision. That
+    // loss of precision can cause the convex combination of `points[j]` and
+    // `points[j+1]` above to lie outside of that interval when `(points[j]
+    // as f64) as i64 < points[j]`
+    //
+    // We therefore try to only convert differences between points to f64
+    // which are much smaller.
+    fn inverse(&self, value: i64) -> Result<i64, StoreError> {
+        if value < 0 {
+            return Err(internal_error!("value {} can not be negative", value));
+        }
+        let j = (value / self.bin_size as i64) as usize;
+        if j >= self.points.len() - 1 {
+            return Ok(*self.range.end());
+        }
+        let (a, b) = (self.points[j], self.points[j + 1]);
+        // This is the same calculation as in the comment above, but
+        // rewritten to be more friendly to lossy calculations with f64
+        let offset = (value as f64).rem_euclid(self.bin_size) * (b - a) as f64;
+        let x = a + (offset / self.bin_size) as i64;
+        Ok(x)
+    }
+
+    fn check_in_range(&self, point: i64) -> Result<(), StoreError> {
+        if !self.range.contains(&point) {
+            return Err(internal_error!(
+                "point {} is outside of the range [{}, {}]",
+                point,
+                self.range.start(),
+                self.range.end(),
+            ));
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn simple() {
+        // This is just the linear function y = (70 / 5) * (x - 10)
+        let points: Vec<i64> = vec![10, 20, 30, 40, 50, 60];
+        let ogive = Ogive::from_equi_histogram(points, 700).unwrap();
+
+        // The function represented by `points`
+        fn f(x: i64) -> i64 {
+            70 * (x - 10) / 5
+        }
+
+        // The inverse of `f`
+        fn g(x: i64) -> i64 {
+            x * 5 / 70 + 10
+        }
+
+        // Check that the ogive is correct
+        assert_eq!(ogive.bin_size, 700_f64 / 5_f64);
+        assert_eq!(ogive.range, 10..=60);
+
+        // Test value method
+        for point in [20, 30, 45, 50, 60] {
+            assert_eq!(ogive.value(point).unwrap(), f(point), "value for {}", point);
+        }
+
+        // Test next_point method
+        for step in [50, 140, 200] {
+            for value in [10, 20, 30, 35, 45, 50, 60] {
+                assert_eq!(
+                    ogive.next_point(value, step).unwrap(),
+                    g(f(value) + step as i64).min(60),
+                    "inverse for {} with step {}",
+                    value,
+                    step
+                );
+            }
+        }
+
+        // Exceeding the range caps it at the maximum point
+        assert_eq!(ogive.next_point(50, 140).unwrap(), 60);
+        assert_eq!(ogive.next_point(50, 500).unwrap(), 60);
+
+        // Point to the left of the range should return an error
+        assert!(ogive.next_point(9, 140).is_err());
+        // Point to the right of the range gets capped
+        assert_eq!(ogive.next_point(61, 140).unwrap(), 60);
+    }
+
+    #[test]
+    fn single_bin() {
+        // A histogram with only one bin
+        let points: Vec<i64> = vec![10, 20];
+        let ogive = Ogive::from_equi_histogram(points, 700).unwrap();
+
+        // The function represented by `points`
+        fn f(x: i64) -> i64 {
+            700 * (x - 10) / 10
+        }
+
+        // The inverse of `f`
+        fn g(x: i64) -> i64 {
+            x * 10 / 700 + 10
+        }
+
+        // Check that the ogive is correct
+        assert_eq!(ogive.bin_size, 700_f64 / 1_f64);
+        assert_eq!(ogive.range, 10..=20);
+
+        // Test value method
+        for point in [10, 15, 20] {
+            assert_eq!(ogive.value(point).unwrap(), f(point), "value for {}", point);
+        }
+
+        // Test next_point method
+        for step in [50, 140, 200] {
+            for value in [10, 15, 20] {
+                assert_eq!(
+                    ogive.next_point(value, step).unwrap(),
+                    g(f(value) + step as i64).min(20),
+                    "inverse for {} with step {}",
+                    value,
+                    step
+                );
+            }
+        }
+
+        // Exceeding the range caps it at the maximum point
+        assert_eq!(ogive.next_point(20, 140).unwrap(), 20);
+        assert_eq!(ogive.next_point(20, 500).unwrap(), 20);
+
+        // Point to the left of the range should return an error
+        assert!(ogive.next_point(9, 140).is_err());
+        // Point to the right of the range gets capped
+        assert_eq!(ogive.next_point(21, 140).unwrap(), 20);
+    }
+
+    #[test]
+    fn one_bin() {
+        let points: Vec<i64> = vec![10];
+        let ogive = Ogive::from_equi_histogram(points, 700).unwrap();
+
+        assert_eq!(ogive.next_point(10, 1).unwrap(), 10);
+        assert_eq!(ogive.next_point(10, 4).unwrap(), 10);
+        assert_eq!(ogive.next_point(15, 1).unwrap(), 10);
+
+        assert!(ogive.next_point(9, 1).is_err());
+    }
+
+    #[test]
+    fn exponential() {
+        let points: Vec<i64> = vec![32, 48, 56, 60, 62, 64];
+        let ogive = Ogive::from_equi_histogram(points, 100).unwrap();
+
+        assert_eq!(ogive.value(50).unwrap(), 25);
+        assert_eq!(ogive.value(56).unwrap(), 40);
+        assert_eq!(ogive.value(58).unwrap(), 50);
+        assert_eq!(ogive.value(63).unwrap(), 90);
+
+        assert_eq!(ogive.next_point(32, 40).unwrap(), 56);
+        assert_eq!(ogive.next_point(50, 10).unwrap(), 54);
+        assert_eq!(ogive.next_point(50, 50).unwrap(), 61);
+        assert_eq!(ogive.next_point(40, 40).unwrap(), 58);
+    }
+}
diff --git a/graph/src/util/stats.rs b/graph/src/util/stats.rs
index ac608b56dcb..ccfae84574b 100644
--- a/graph/src/util/stats.rs
+++ b/graph/src/util/stats.rs
@@ -1,6 +1,8 @@
 use std::collections::VecDeque;
+use std::sync::atomic::Ordering;
 use std::time::{Duration, Instant};
 
+use portable_atomic::AtomicU128;
 use prometheus::Gauge;
 
 use crate::prelude::ENV_VARS;
@@ -166,6 +168,196 @@ impl MovingStats {
     }
 }
 
+/// Packed bin for atomic operations: epoch (32 bits) | count (32 bits) | duration_nanos (64 bits)
+/// Fits in a single AtomicU128 for lock-free CAS updates.
+#[repr(transparent)]
+struct PackedBin(AtomicU128);
+
+impl PackedBin {
+    fn new() -> Self {
+        Self(AtomicU128::new(0))
+    }
+
+    /// Pack epoch, count, and duration into a single u128 value.
+    fn pack(epoch: u32, count: u32, duration_nanos: u64) -> u128 {
+        ((epoch as u128) << 96) | ((count as u128) << 64) | (duration_nanos as u128)
+    }
+
+    /// Unpack a u128 value into (epoch, count, duration_nanos).
+    fn unpack(packed: u128) -> (u32, u32, u64) {
+        let epoch = (packed >> 96) as u32;
+        let count = (packed >> 64) as u32;
+        let duration_nanos = packed as u64;
+        (epoch, count, duration_nanos)
+    }
+}
+
+/// Lock-free moving statistics using an epoch-based ring buffer.
+///
+/// This is a thread-safe, lock-free alternative to `MovingStats` that uses
+/// atomic operations instead of locks. It tracks durations over a sliding
+/// time window, storing values in fixed-size bins.
+///
+/// Writers use CAS loops to atomically update bins, while readers can
+/// scan all bins without blocking writers.
+pub struct AtomicMovingStats {
+    start_time: Instant,
+    bin_size: Duration,
+    bins: Box<[PackedBin]>,
+}
+
+impl Default for AtomicMovingStats {
+    fn default() -> Self {
+        Self::new(ENV_VARS.load_window_size, ENV_VARS.load_bin_size)
+    }
+}
+
+impl AtomicMovingStats {
+    /// Create a new AtomicMovingStats with the given window and bin sizes.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `window_size` or `bin_size` is `0`, or if `bin_size` >= `window_size`
+    pub fn new(window_size: Duration, bin_size: Duration) -> Self {
+        assert!(window_size.as_millis() > 0);
+        assert!(bin_size.as_millis() > 0);
+        assert!(window_size > bin_size);
+
+        let num_bins = window_size.as_millis() as usize / bin_size.as_millis() as usize;
+        let bins: Vec<PackedBin> = (0..num_bins).map(|_| PackedBin::new()).collect();
+
+        Self {
+            start_time: Instant::now(),
+            bin_size,
+            bins: bins.into_boxed_slice(),
+        }
+    }
+
+    /// Calculate the epoch number for a given instant.
+    fn epoch_at(&self, now: Instant) -> u32 {
+        let elapsed = now.saturating_duration_since(self.start_time);
+        (elapsed.as_millis() / self.bin_size.as_millis()) as u32
+    }
+
+    /// Add a duration measurement at the current time.
+    pub fn add(&self, duration: Duration) {
+        self.add_at(Instant::now(), duration);
+    }
+
+    /// Add a duration measurement at a specific time.
+    ///
+    /// Note: It is expected that subsequent calls to `add_at` happen with
+    /// monotonically increasing `now` values for optimal accuracy.
+    pub fn add_at(&self, now: Instant, duration: Duration) {
+        let current_epoch = self.epoch_at(now);
+        let bin_idx = current_epoch as usize % self.bins.len();
+        let bin = &self.bins[bin_idx];
+        let duration_nanos = duration.as_nanos() as u64;
+
+        loop {
+            let current = bin.0.load(Ordering::Acquire);
+            let (bin_epoch, count, total_nanos) = PackedBin::unpack(current);
+
+            let new_packed = if bin_epoch == current_epoch {
+                // Same epoch: increment existing values
+                PackedBin::pack(
+                    current_epoch,
+                    count.saturating_add(1),
+                    total_nanos.saturating_add(duration_nanos),
+                )
+            } else {
+                // Stale epoch: reset bin with new measurement
+                PackedBin::pack(current_epoch, 1, duration_nanos)
+            };
+
+            match bin.0.compare_exchange_weak(
+                current,
+                new_packed,
+                Ordering::AcqRel,
+                Ordering::Acquire,
+            ) {
+                Ok(_) => break,
+                Err(_) => continue, // CAS failed, retry
+            }
+        }
+    }
+
+    /// Calculate the average duration over the current window.
+    ///
+    /// Returns `None` if no measurements have been recorded in the window.
+    pub fn average(&self) -> Option<Duration> {
+        self.average_at(Instant::now())
+    }
+
+    /// Calculate the average duration at a specific time.
+    fn average_at(&self, now: Instant) -> Option<Duration> {
+        let current_epoch = self.epoch_at(now);
+        let num_bins = self.bins.len() as u32;
+        let mut total_count: u64 = 0;
+        let mut total_nanos: u128 = 0;
+
+        for bin in self.bins.iter() {
+            let (bin_epoch, count, duration_nanos) =
+                PackedBin::unpack(bin.0.load(Ordering::Acquire));
+            // Valid if within window (handles epoch wraparound)
+            if current_epoch.wrapping_sub(bin_epoch) < num_bins {
+                total_count += count as u64;
+                total_nanos += duration_nanos as u128;
+            }
+        }
+
+        if total_count > 0 {
+            Some(Duration::from_nanos(
+                (total_nanos / total_count as u128) as u64,
+            ))
+        } else {
+            None
+        }
+    }
+
+    /// Return `true` if the average of measurements within the window
+    /// is above `duration`.
+    pub fn average_gt(&self, duration: Duration) -> bool {
+        self.average().map(|avg| avg > duration).unwrap_or(false)
+    }
+
+    /// Return `true` if the average at a specific time is above `duration`.
+    #[cfg(test)]
+    fn average_gt_at(&self, now: Instant, duration: Duration) -> bool {
+        self.average_at(now)
+            .map(|avg| avg > duration)
+            .unwrap_or(false)
+    }
+
+    /// Return the total duration recorded in the current window.
+    pub fn duration(&self) -> Duration {
+        self.duration_at(Instant::now())
+    }
+
+    /// Return the total duration at a specific time.
+    fn duration_at(&self, now: Instant) -> Duration {
+        let current_epoch = self.epoch_at(now);
+        let num_bins = self.bins.len() as u32;
+        let mut total_nanos: u128 = 0;
+
+        for bin in self.bins.iter() {
+            let (bin_epoch, _, duration_nanos) = PackedBin::unpack(bin.0.load(Ordering::Acquire));
+            if current_epoch.wrapping_sub(bin_epoch) < num_bins {
+                total_nanos += duration_nanos as u128;
+            }
+        }
+
+        Duration::from_nanos(total_nanos as u64)
+    }
+
+    /// Adds `duration` to the stats, and register the average ms to `avg_gauge`.
+    pub fn add_and_register(&self, duration: Duration, avg_gauge: &Gauge) {
+        self.add(duration);
+        let wait_avg = self.average().map(|avg| avg.as_millis()).unwrap_or(0);
+        avg_gauge.set(wait_avg as f64);
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -219,4 +411,77 @@ mod tests {
         assert_eq!(20, stats.total.count);
         assert_eq!(Duration::from_secs(5 * 86 + 16 * 10), stats.total.duration);
     }
+
+    #[test]
+    fn atomic_add_one_const() {
+        let stats = AtomicMovingStats::new(Duration::from_secs(5), Duration::from_secs(1));
+        let start = stats.start_time;
+        for i in 0..10 {
+            stats.add_at(start + Duration::from_secs(i), Duration::from_secs(1));
+        }
+        // After 10 seconds with 5-second window, only last 5 entries are valid
+        assert_eq!(5, stats.bins.len());
+        // Query at time 10 seconds (end of data range)
+        let query_time = start + Duration::from_secs(10);
+        // Average should be 1 second
+        let avg = stats.average_at(query_time).unwrap();
+        assert_eq!(Duration::from_secs(1), avg);
+        assert!(stats.average_gt_at(query_time, Duration::from_millis(900)));
+        assert!(!stats.average_gt_at(query_time, Duration::from_secs(1)));
+    }
+
+    #[test]
+    fn atomic_add_four_linear() {
+        let stats = AtomicMovingStats::new(Duration::from_secs(5), Duration::from_secs(1));
+        let start = stats.start_time;
+        for i in 0..40u64 {
+            stats.add_at(
+                start + Duration::from_millis(250 * i),
+                Duration::from_secs(i),
+            );
+        }
+        assert_eq!(5, stats.bins.len());
+        // Query at time 9.999 seconds (just before epoch 10 to include epoch 5)
+        // At epoch 9, valid bins are epochs 5-9 (9 - bin_epoch < 5)
+        let query_time = start + Duration::from_millis(9999);
+        // Total duration in window: 4 entries per bin, bins 5-9 contain entries 20-39
+        // Bin 5: entries 20,21,22,23 -> sum = 86
+        // Bin 6: entries 24,25,26,27 -> sum = 102
+        // ...
+        // Total count = 20, total duration = 5*86 + 16*10 = 590
+        assert_eq!(
+            Duration::from_secs(5 * 86 + 16 * 10),
+            stats.duration_at(query_time)
+        );
+    }
+
+    #[test]
+    fn atomic_empty_average() {
+        let stats = AtomicMovingStats::new(Duration::from_secs(5), Duration::from_secs(1));
+        // Query at start_time (no data yet)
+        assert!(stats.average_at(stats.start_time).is_none());
+        assert!(!stats.average_gt_at(stats.start_time, Duration::from_secs(1)));
+    }
+
+    #[test]
+    fn atomic_pack_unpack() {
+        // Test edge cases of packing/unpacking
+        let packed = PackedBin::pack(u32::MAX, u32::MAX, u64::MAX);
+        let (epoch, count, nanos) = PackedBin::unpack(packed);
+        assert_eq!(u32::MAX, epoch);
+        assert_eq!(u32::MAX, count);
+        assert_eq!(u64::MAX, nanos);
+
+        let packed = PackedBin::pack(0, 0, 0);
+        let (epoch, count, nanos) = PackedBin::unpack(packed);
+        assert_eq!(0, epoch);
+        assert_eq!(0, count);
+        assert_eq!(0, nanos);
+
+        let packed = PackedBin::pack(12345, 67890, 123456789012345);
+        let (epoch, count, nanos) = PackedBin::unpack(packed);
+        assert_eq!(12345, epoch);
+        assert_eq!(67890, count);
+        assert_eq!(123456789012345, nanos);
+    }
 }
diff --git a/graph/src/util/test_utils.rs b/graph/src/util/test_utils.rs
new file mode 100644
index 00000000000..0bd954aabf4
--- /dev/null
+++ b/graph/src/util/test_utils.rs
@@ -0,0 +1,61 @@
+use alloy::consensus::TxLegacy;
+use alloy::primitives::Address;
+use alloy::rpc::types::Transaction;
+
+use crate::components::ethereum::{AnyBlock, AnyHeader, AnyTransaction, AnyTxEnvelope};
+use crate::prelude::alloy::consensus::Header as ConsensusHeader;
+use crate::prelude::alloy::primitives::B256;
+use crate::prelude::alloy::rpc::types::{Block, Header};
+
+/// Creates a minimal Alloy Block for testing purposes.
+pub fn create_minimal_block_for_test(block_number: u64, block_hash: B256) -> AnyBlock {
+    // Create consensus header with defaults, but set the specific number
+    let consensus_header = ConsensusHeader {
+        number: block_number,
+        ..Default::default()
+    };
+
+    // Create RPC header with the specific hash and wrap in AnyHeader
+    let rpc_header = Header {
+        hash: block_hash,
+        inner: AnyHeader::from(consensus_header),
+        total_difficulty: None,
+        size: None,
+    };
+
+    Block::empty(rpc_header)
+}
+
+/// Generic function that creates a mock legacy Transaction for testing
+pub fn create_dummy_transaction(
+    block_number: u64,
+    block_hash: B256,
+    transaction_index: Option<u64>,
+    transaction_hash: B256,
+) -> AnyTransaction {
+    use alloy::{
+        consensus::transaction::Recovered,
+        consensus::{Signed, TxEnvelope},
+        primitives::{Signature, U256},
+    };
+
+    let tx = TxLegacy::default();
+
+    // Create a dummy signature
+    let signature = Signature::new(U256::from(0x1111), U256::from(0x2222), false);
+
+    let signed_tx = Signed::new_unchecked(tx, signature, transaction_hash);
+    let envelope = TxEnvelope::Legacy(signed_tx);
+    let any_envelope = AnyTxEnvelope::Ethereum(envelope);
+
+    let recovered = Recovered::new_unchecked(any_envelope, Address::ZERO);
+
+    Transaction {
+        inner: recovered,
+        block_hash: Some(block_hash),
+        block_number: Some(block_number),
+        block_timestamp: None,
+        transaction_index,
+        effective_gas_price: None,
+    }
+}
diff --git a/graph/src/util/timed_cache.rs b/graph/src/util/timed_cache.rs
index 20ac7ba49fd..587a49a176a 100644
--- a/graph/src/util/timed_cache.rs
+++ b/graph/src/util/timed_cache.rs
@@ -3,10 +3,12 @@ use std::{
     cmp::Eq,
     collections::HashMap,
     hash::Hash,
-    sync::{Arc, RwLock},
+    sync::Arc,
     time::{Duration, Instant},
 };
 
+use crate::parking_lot::RwLock;
+
 /// Caching of values for a specified amount of time
 #[derive(Debug)]
 struct CacheEntry<V> {
@@ -36,20 +38,20 @@ impl<K, V> TimedCache<K, V> {
     /// return `None` otherwise. Note that expired entries stay in the cache
     /// as it is assumed that, after returning `None`, the caller will
     /// immediately overwrite that entry with a call to `set`
-    pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<Arc<V>>
+    pub fn get<Q>(&self, key: &Q) -> Option<Arc<V>>
     where
         K: Borrow<Q> + Eq + Hash,
-        Q: Hash + Eq,
+        Q: Hash + Eq + ?Sized,
     {
         self.get_at(key, Instant::now())
     }
 
-    fn get_at<Q: ?Sized>(&self, key: &Q, now: Instant) -> Option<Arc<V>>
+    fn get_at<Q>(&self, key: &Q, now: Instant) -> Option<Arc<V>>
     where
         K: Borrow<Q> + Eq + Hash,
-        Q: Hash + Eq,
+        Q: Hash + Eq + ?Sized,
     {
-        match self.entries.read().unwrap().get(key) {
+        match self.entries.read().get(key) {
             Some(CacheEntry { value, expires }) if expires >= &now => Some(value.clone()),
             _ => None,
         }
@@ -72,11 +74,11 @@ impl<K, V> TimedCache<K, V> {
             value,
             expires: now + self.ttl,
         };
-        self.entries.write().unwrap().insert(key, entry);
+        self.entries.write().insert(key, entry);
     }
 
     pub fn clear(&self) {
-        self.entries.write().unwrap().clear();
+        self.entries.write().clear();
     }
 
     pub fn find<F>(&self, pred: F) -> Option<Arc<V>>
@@ -85,7 +87,6 @@ impl<K, V> TimedCache<K, V> {
     {
         self.entries
             .read()
-            .unwrap()
             .values()
             .find(move |entry| pred(entry.value.as_ref()))
             .map(|entry| entry.value.clone())
@@ -94,14 +95,13 @@ impl<K, V> TimedCache<K, V> {
     /// Remove an entry from the cache. If there was an entry for `key`,
     /// return the value associated with it and whether the entry is still
     /// live
-    pub fn remove<Q: ?Sized>(&self, key: &Q) -> Option<(Arc<V>, bool)>
+    pub fn remove<Q>(&self, key: &Q) -> Option<(Arc<V>, bool)>
     where
         K: Borrow<Q> + Eq + Hash,
-        Q: Hash + Eq,
+        Q: Hash + Eq + ?Sized,
     {
         self.entries
             .write()
-            .unwrap()
             .remove(key)
             .map(|CacheEntry { value, expires }| (value, expires >= Instant::now()))
     }
diff --git a/graph/src/util/timed_rw_lock.rs b/graph/src/util/timed_rw_lock.rs
index 6a9a4868f6c..17befde8636 100644
--- a/graph/src/util/timed_rw_lock.rs
+++ b/graph/src/util/timed_rw_lock.rs
@@ -1,5 +1,5 @@
 use parking_lot::{Mutex, RwLock};
-use slog::{warn, Logger};
+use slog::{Logger, warn};
 use std::time::{Duration, Instant};
 
 use crate::prelude::ENV_VARS;
@@ -20,7 +20,7 @@ impl<T> TimedRwLock<T> {
         }
     }
 
-    pub fn write(&self, logger: &Logger) -> parking_lot::RwLockWriteGuard<T> {
+    pub fn write(&self, logger: &Logger) -> parking_lot::RwLockWriteGuard<'_, T> {
         loop {
             let mut elapsed = Duration::from_secs(0);
             match self.lock.try_write_for(self.log_threshold) {
@@ -36,7 +36,11 @@ impl<T> TimedRwLock<T> {
         }
     }
 
-    pub fn read(&self, logger: &Logger) -> parking_lot::RwLockReadGuard<T> {
+    pub fn try_read(&self) -> Option<parking_lot::RwLockReadGuard<'_, T>> {
+        self.lock.try_read()
+    }
+
+    pub fn read(&self, logger: &Logger) -> parking_lot::RwLockReadGuard<'_, T> {
         loop {
             let mut elapsed = Duration::from_secs(0);
             match self.lock.try_read_for(self.log_threshold) {
@@ -69,7 +73,7 @@ impl<T> TimedMutex<T> {
         }
     }
 
-    pub fn lock(&self, logger: &Logger) -> parking_lot::MutexGuard<T> {
+    pub fn lock(&self, logger: &Logger) -> parking_lot::MutexGuard<'_, T> {
         let start = Instant::now();
         let guard = self.lock.lock();
         let elapsed = start.elapsed();
diff --git a/graph/tests/subgraph_datasource_tests.rs b/graph/tests/subgraph_datasource_tests.rs
new file mode 100644
index 00000000000..9dba0767065
--- /dev/null
+++ b/graph/tests/subgraph_datasource_tests.rs
@@ -0,0 +1,264 @@
+use std::{collections::BTreeMap, ops::Range, sync::Arc};
+
+use graph::{
+    blockchain::{
+        Block, SubgraphFilter, Trigger,
+        block_stream::{
+            EntityOperationKind, EntitySourceOperation, SubgraphTriggerScanRange,
+            TriggersAdapterWrapper,
+        },
+        mock::MockTriggersAdapter,
+    },
+    components::store::SourceableStore,
+    data_source::CausalityRegion,
+    prelude::{BlockHash, BlockNumber, BlockPtr, DeploymentHash, StoreError, Value},
+    schema::{EntityType, InputSchema},
+};
+use slog::Logger;
+use tonic::async_trait;
+
+pub struct MockSourcableStore {
+    entities: BTreeMap<BlockNumber, Vec<EntitySourceOperation>>,
+    schema: InputSchema,
+    block_ptr: Option<BlockPtr>,
+}
+
+impl MockSourcableStore {
+    pub fn new(
+        entities: BTreeMap<BlockNumber, Vec<EntitySourceOperation>>,
+        schema: InputSchema,
+        block_ptr: Option<BlockPtr>,
+    ) -> Self {
+        Self {
+            entities,
+            schema,
+            block_ptr,
+        }
+    }
+
+    pub fn set_block_ptr(&mut self, ptr: BlockPtr) {
+        self.block_ptr = Some(ptr);
+    }
+
+    pub fn clear_block_ptr(&mut self) {
+        self.block_ptr = None;
+    }
+
+    pub fn increment_block(&mut self) -> Result<(), &'static str> {
+        if let Some(ptr) = &self.block_ptr {
+            let new_number = ptr.number + 1;
+            self.block_ptr = Some(BlockPtr::new(ptr.hash.clone(), new_number));
+            Ok(())
+        } else {
+            Err("No block pointer set")
+        }
+    }
+
+    pub fn decrement_block(&mut self) -> Result<(), &'static str> {
+        if let Some(ptr) = &self.block_ptr {
+            if ptr.number == 0 {
+                return Err("Block number already at 0");
+            }
+            let new_number = ptr.number - 1;
+            self.block_ptr = Some(BlockPtr::new(ptr.hash.clone(), new_number));
+            Ok(())
+        } else {
+            Err("No block pointer set")
+        }
+    }
+}
+
+#[async_trait]
+impl SourceableStore for MockSourcableStore {
+    async fn get_range(
+        &self,
+        entity_types: Vec<EntityType>,
+        _causality_region: CausalityRegion,
+        block_range: Range<BlockNumber>,
+    ) -> Result<BTreeMap<BlockNumber, Vec<EntitySourceOperation>>, StoreError> {
+        Ok(self
+            .entities
+            .range(block_range)
+            .map(|(block_num, operations)| {
+                let filtered_ops: Vec<EntitySourceOperation> = operations
+                    .iter()
+                    .filter(|op| entity_types.contains(&op.entity_type))
+                    .cloned()
+                    .collect();
+                (*block_num, filtered_ops)
+            })
+            .filter(|(_, ops)| !ops.is_empty())
+            .collect())
+    }
+
+    fn input_schema(&self) -> InputSchema {
+        self.schema.clone()
+    }
+
+    async fn block_ptr(&self) -> Result<Option<BlockPtr>, StoreError> {
+        Ok(self.block_ptr.clone())
+    }
+}
+
+#[graph::test]
+async fn test_triggers_adapter_with_entities() {
+    let id = DeploymentHash::new("test_deployment").unwrap();
+    let schema = InputSchema::parse_latest(
+        r#"
+        type User @entity { 
+            id: String!
+            name: String!
+            age: Int 
+        }
+        type Post @entity {
+            id: String!
+            title: String!
+            author: String!
+        }
+        "#,
+        id.clone(),
+    )
+    .unwrap();
+
+    let user1 = schema
+        .make_entity(vec![
+            ("id".into(), Value::String("user1".to_owned())),
+            ("name".into(), Value::String("Alice".to_owned())),
+            ("age".into(), Value::Int(30)),
+        ])
+        .unwrap();
+
+    let user2 = schema
+        .make_entity(vec![
+            ("id".into(), Value::String("user2".to_owned())),
+            ("name".into(), Value::String("Bob".to_owned())),
+            ("age".into(), Value::Int(25)),
+        ])
+        .unwrap();
+
+    let post = schema
+        .make_entity(vec![
+            ("id".into(), Value::String("post1".to_owned())),
+            ("title".into(), Value::String("Test Post".to_owned())),
+            ("author".into(), Value::String("user1".to_owned())),
+        ])
+        .unwrap();
+
+    let user_type = schema.entity_type("User").unwrap();
+    let post_type = schema.entity_type("Post").unwrap();
+
+    let entity1 = EntitySourceOperation {
+        entity_type: user_type.clone(),
+        entity: user1,
+        entity_op: EntityOperationKind::Create,
+        vid: 1,
+    };
+
+    let entity2 = EntitySourceOperation {
+        entity_type: user_type,
+        entity: user2,
+        entity_op: EntityOperationKind::Create,
+        vid: 2,
+    };
+
+    let post_entity = EntitySourceOperation {
+        entity_type: post_type,
+        entity: post,
+        entity_op: EntityOperationKind::Create,
+        vid: 3,
+    };
+
+    let mut entities = BTreeMap::new();
+    entities.insert(1, vec![entity1, post_entity]); // Block 1 has both User and Post
+    entities.insert(2, vec![entity2]); // Block 2 has only User
+
+    // Create block hash and store
+    let hash_bytes: [u8; 32] = [0u8; 32];
+    let block_hash = BlockHash(hash_bytes.to_vec().into_boxed_slice());
+    let initial_block = BlockPtr::new(block_hash, 0);
+    let store = Arc::new(MockSourcableStore::new(
+        entities,
+        schema.clone(),
+        Some(initial_block),
+    ));
+
+    let adapter = Arc::new(MockTriggersAdapter {});
+    let wrapper = TriggersAdapterWrapper::new(adapter, vec![store]);
+
+    // Filter only for User entities
+    let filter = SubgraphFilter {
+        subgraph: id,
+        start_block: 0,
+        entities: vec!["User".to_string()], // Only monitoring User entities
+        manifest_idx: 0,
+    };
+
+    let logger = Logger::root(slog::Discard, slog::o!());
+    let result = wrapper
+        .blocks_with_subgraph_triggers(&logger, &[filter], SubgraphTriggerScanRange::Range(1, 3))
+        .await;
+
+    assert!(result.is_ok(), "Failed to get triggers: {:?}", result.err());
+    let blocks = result.unwrap();
+
+    assert_eq!(
+        blocks.len(),
+        3,
+        "Should have found blocks with entities plus the last block"
+    );
+
+    let block1 = &blocks[0];
+    assert_eq!(block1.block.number(), 1, "First block should be number 1");
+    let triggers1 = &block1.trigger_data;
+    assert_eq!(
+        triggers1.len(),
+        1,
+        "Block 1 should have exactly one trigger (User, not Post)"
+    );
+
+    if let Trigger::Subgraph(trigger_data) = &triggers1[0] {
+        assert_eq!(
+            trigger_data.entity.entity_type.as_str(),
+            "User",
+            "Trigger should be for User entity"
+        );
+        assert_eq!(
+            trigger_data.entity.vid, 1,
+            "Should be the first User entity"
+        );
+    } else {
+        panic!("Expected subgraph trigger");
+    }
+
+    let block2 = &blocks[1];
+    assert_eq!(block2.block.number(), 2, "Second block should be number 2");
+    let triggers2 = &block2.trigger_data;
+    assert_eq!(
+        triggers2.len(),
+        1,
+        "Block 2 should have exactly one trigger"
+    );
+
+    if let Trigger::Subgraph(trigger_data) = &triggers2[0] {
+        assert_eq!(
+            trigger_data.entity.entity_type.as_str(),
+            "User",
+            "Trigger should be for User entity"
+        );
+        assert_eq!(
+            trigger_data.entity.vid, 2,
+            "Should be the second User entity"
+        );
+    } else {
+        panic!("Expected subgraph trigger");
+    }
+
+    let block3 = &blocks[2];
+    assert_eq!(block3.block.number(), 3, "Third block should be number 3");
+    let triggers3 = &block3.trigger_data;
+    assert_eq!(
+        triggers3.len(),
+        0,
+        "Block 3 should have no triggers but be included as it's the last block"
+    );
+}
diff --git a/graphql/Cargo.toml b/graphql/Cargo.toml
index c734c0b8d54..cec9330f072 100644
--- a/graphql/Cargo.toml
+++ b/graphql/Cargo.toml
@@ -4,15 +4,16 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
+async-trait = { workspace = true }
 crossbeam = "0.8"
 graph = { path = "../graph" }
-graphql-parser = "0.4.0"
-graphql-tools = "0.2.1"
-indexmap = "2.1"
-Inflector = "0.11.3"
-lazy_static = "1.2.0"
-stable-hash = { git = "https://github.com/graphprotocol/stable-hash", branch = "main"}
-stable-hash_legacy = { git = "https://github.com/graphprotocol/stable-hash", branch = "old", package = "stable-hash" }
+graphql-tools = { workspace = true }
+lazy_static = { workspace = true }
+stable-hash = { git = "https://github.com/graphprotocol/stable-hash", rev = "70300f974e61529675aef3f20803f26a23f0e0ea"}
+stable-hash_legacy = { git = "https://github.com/graphprotocol/stable-hash", rev = "42b85d936c6b9f1b7a4b8385d2f081d5564daa69", package = "stable-hash" }
 parking_lot = "0.12"
 anyhow = "1.0"
-async-recursion = "1.0.5"
+async-recursion = "1.1.1"
+
+[lints]
+workspace = true
diff --git a/graphql/src/execution/ast.rs b/graphql/src/execution/ast.rs
index df1a9b3de5f..cc9eeae5083 100644
--- a/graphql/src/execution/ast.rs
+++ b/graphql/src/execution/ast.rs
@@ -1,17 +1,12 @@
 use std::collections::{BTreeSet, HashSet};
 
 use graph::{
-    components::store::{AttributeNames, ChildMultiplicity},
-    constraint_violation,
-    data::graphql::{ext::DirectiveFinder as _, ObjectOrInterface},
+    components::store::{AggregationCurrent, AttributeNames, ChildMultiplicity, EntityOrder},
+    data::{graphql::ObjectOrInterface, store::ID},
     env::ENV_VARS,
-    prelude::{anyhow, q, r, s, QueryExecutionError, ValueMap},
-    schema::{
-        ast::{self as sast, ObjectType},
-        ApiSchema,
-    },
+    prelude::{QueryExecutionError, ValueMap, anyhow, q, r, s},
+    schema::{AggregationInterval, ApiSchema, EntityType, ast::ObjectType, kw},
 };
-use graphql_parser::Pos;
 
 /// A selection set is a table that maps object types to the fields that
 /// should be selected for objects of that type. The types are always
@@ -195,11 +190,35 @@ impl SelectionSet {
         }
         Ok(())
     }
+
+    /// Dump the selection set as a string for debugging
+    #[cfg(debug_assertions)]
+    pub fn dump(&self) -> String {
+        fn dump_selection_set(selection_set: &SelectionSet, indent: usize, out: &mut String) {
+            for (object_type, fields) in selection_set.interior_fields() {
+                for field in fields {
+                    for _ in 0..indent {
+                        out.push(' ');
+                    }
+                    let intv = field
+                        .aggregation_interval()
+                        .unwrap()
+                        .map(|intv| format!("[{intv}]"))
+                        .unwrap_or_default();
+                    out.push_str(&format!("{}: {}{intv}\n", object_type.name, field.name));
+                    dump_selection_set(&field.selection_set, indent + 2, out);
+                }
+            }
+        }
+        let mut out = String::new();
+        dump_selection_set(self, 0, &mut out);
+        out
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Directive {
-    pub position: Pos,
+    pub position: q::Pos,
     pub name: String,
     pub arguments: Vec<(String, r::Value)>,
 }
@@ -239,7 +258,7 @@ impl Directive {
 /// already been coerced to the appropriate types for the field argument
 #[derive(Debug, Clone, PartialEq)]
 pub struct Field {
-    pub position: Pos,
+    pub position: q::Pos,
     pub alias: Option<String>,
     pub name: String,
     pub arguments: Vec<(String, r::Value)>,
@@ -279,13 +298,14 @@ impl Field {
     /// return `AttributeNames::All
     pub fn selected_attrs(
         &self,
-        object_type: &s::ObjectType,
+        entity_type: &EntityType,
+        order: &EntityOrder,
     ) -> Result<AttributeNames, QueryExecutionError> {
         if !ENV_VARS.enable_select_by_specific_attributes {
             return Ok(AttributeNames::All);
         }
 
-        let fields = self.selection_set.fields_for_name(&object_type.name)?;
+        let fields = self.selection_set.fields_for_name(entity_type.typename())?;
 
         // Extract the attributes we should select from `selection_set`. In
         // particular, disregard derived fields since they are not stored
@@ -293,9 +313,9 @@ impl Field {
             .filter(|field| {
                 // Keep fields that are not derived and for which we
                 // can find the field type
-                sast::get_field(object_type, &field.name)
-                    .map(|field_type| !field_type.is_derived())
-                    .unwrap_or(false)
+                entity_type
+                    .field(&field.name)
+                    .is_some_and(|field| !field.is_derived())
             })
             .filter_map(|field| {
                 if field.name.starts_with("__") {
@@ -306,24 +326,63 @@ impl Field {
             })
             .collect();
 
-        // We need to also select the `orderBy` field if there is one.
-        // Because of how the API Schema is set up, `orderBy` can only have
-        // an enum value
-        match self.argument_value("orderBy") {
-            None => { /* nothing to do */ }
-            Some(r::Value::Enum(e)) => {
-                column_names.insert(e.clone());
+        // We need to also select the `orderBy` field if there is one
+        use EntityOrder::*;
+        let order_field = match order {
+            Ascending(name, _) | Descending(name, _) => Some(name.as_str()),
+            Default => Some(ID.as_str()),
+            ChildAscending(_) | ChildDescending(_) | Unordered => {
+                // No need to select anything for these
+                None
             }
-            Some(v) => {
-                return Err(constraint_violation!(
-                    "'orderBy' attribute must be an enum but is {:?}",
-                    v
-                )
-                .into());
+        };
+        if let Some(order_field) = order_field {
+            // We assume that `order` only contains valid field names
+            column_names.insert(order_field.to_string());
+        }
+        Ok(AttributeNames::Select(column_names))
+    }
+
+    /// Return the value of the `interval` argument if there is one. Return
+    /// `None` if the argument is not present, and an error if the argument
+    /// is present but can not be parsed as an `AggregationInterval`
+    pub fn aggregation_interval(&self) -> Result<Option<AggregationInterval>, QueryExecutionError> {
+        self.argument_value(kw::INTERVAL)
+            .map(|value| match value {
+                r::Value::Enum(interval) => interval.parse::<AggregationInterval>().map_err(|_| {
+                    QueryExecutionError::InvalidArgumentError(
+                        self.position,
+                        kw::INTERVAL.to_string(),
+                        q::Value::from(value.clone()),
+                    )
+                }),
+                _ => Err(QueryExecutionError::InvalidArgumentError(
+                    self.position,
+                    kw::INTERVAL.to_string(),
+                    q::Value::from(value.clone()),
+                )),
+            })
+            .transpose()
+    }
+
+    pub fn aggregation_current(&self) -> Result<Option<AggregationCurrent>, QueryExecutionError> {
+        let Some(value) = self.argument_value(kw::CURRENT) else {
+            return Ok(None);
+        };
+
+        if let r::Value::Enum(current) = value {
+            match current.as_str() {
+                "exclude" => return Ok(Some(AggregationCurrent::Exclude)),
+                "include" => return Ok(Some(AggregationCurrent::Include)),
+                _ => {}
             }
         }
 
-        Ok(AttributeNames::Select(column_names))
+        Err(QueryExecutionError::InvalidArgumentError(
+            self.position,
+            kw::CURRENT.to_string(),
+            q::Value::from(value.clone()),
+        ))
     }
 }
 
diff --git a/graphql/src/execution/cache.rs b/graphql/src/execution/cache.rs
index 099fba25f23..de4387ace46 100644
--- a/graphql/src/execution/cache.rs
+++ b/graphql/src/execution/cache.rs
@@ -1,6 +1,6 @@
-use graph::prelude::{debug, BlockPtr, CheapClone, Logger, QueryResult};
-use std::sync::atomic::{AtomicU64, Ordering};
+use graph::prelude::{BlockPtr, CheapClone, Logger, QueryResult, debug};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::{collections::HashMap, time::Duration};
 use std::{collections::VecDeque, time::Instant};
 
@@ -107,10 +107,10 @@ impl QueryBlockCache {
         // - There are none yet, this is the first query being cached, or
         // - `block_ptr` is of higher or equal number than the most recent block in the cache.
         // Otherwise this is a historical query that does not belong in the block cache.
-        if let Some(highest) = cache.iter().next() {
-            if highest.block.number > block_ptr.number {
-                return false;
-            }
+        if let Some(highest) = cache.iter().next()
+            && highest.block.number > block_ptr.number
+        {
+            return false;
         };
 
         if cache.len() == self.max_blocks {
@@ -164,10 +164,10 @@ impl QueryBlockCache {
             .map(|(_, c)| c)
         {
             // Iterate from the most recent block looking for a block that matches.
-            if let Some(cache_by_block) = cache.iter().find(|c| &c.block == block_ptr) {
-                if let Some(response) = cache_by_block.get(key) {
-                    return Some(response.cheap_clone());
-                }
+            if let Some(cache_by_block) = cache.iter().find(|c| &c.block == block_ptr)
+                && let Some(response) = cache_by_block.get(key)
+            {
+                return Some(response.cheap_clone());
             }
         }
         None
diff --git a/graphql/src/execution/execution.rs b/graphql/src/execution/execution.rs
index b534e372706..c3d116e6c64 100644
--- a/graphql/src/execution/execution.rs
+++ b/graphql/src/execution/execution.rs
@@ -6,8 +6,9 @@ use graph::{
         query::Trace,
         value::{Object, Word},
     },
-    prelude::{s, CheapClone},
-    schema::{is_introspection_field, INTROSPECTION_QUERY_TYPE, META_FIELD_NAME},
+    futures03::future::TryFutureExt,
+    prelude::{CheapClone, s},
+    schema::{INTROSPECTION_QUERY_TYPE, LOGS_FIELD_NAME, META_FIELD_NAME, is_introspection_field},
     util::{herd_cache::HerdCache, lfu_cache::EvictStats, timed_rw_lock::TimedMutex},
 };
 use lazy_static::lazy_static;
@@ -27,18 +28,30 @@ use crate::execution::ast as a;
 use crate::prelude::*;
 
 lazy_static! {
+    // The maximum weight of each cache shard, evenly dividing the total
+    // cache memory across shards
+    static ref MAX_WEIGHT: usize = {
+        let shards = ENV_VARS.graphql.query_block_cache_shards;
+        let blocks = ENV_VARS.graphql.query_cache_blocks;
+
+        ENV_VARS.graphql.query_cache_max_mem / (blocks * shards as usize)
+    };
+
+    // We will not add entries to the cache that exceed this weight.
+    static ref MAX_ENTRY_WEIGHT: usize = {
+        MAX_WEIGHT.checked_div(ENV_VARS.graphql.query_cache_max_entry_ratio).unwrap_or(usize::MAX)
+    };
+
     // Sharded query results cache for recent blocks by network.
     // The `VecDeque` works as a ring buffer with a capacity of `QUERY_CACHE_BLOCKS`.
     static ref QUERY_BLOCK_CACHE: Vec<TimedMutex<QueryBlockCache>> = {
             let shards = ENV_VARS.graphql.query_block_cache_shards;
             let blocks = ENV_VARS.graphql.query_cache_blocks;
 
-            // The memory budget is evenly divided among blocks and their shards.
-            let max_weight = ENV_VARS.graphql.query_cache_max_mem / (blocks * shards as usize);
             let mut caches = Vec::new();
             for i in 0..shards {
                 let id = format!("query_block_cache_{}", i);
-                caches.push(TimedMutex::new(QueryBlockCache::new(blocks, i, max_weight), id))
+                caches.push(TimedMutex::new(QueryBlockCache::new(blocks, i, *MAX_WEIGHT), id))
             }
             caches
     };
@@ -151,8 +164,8 @@ fn log_lfu_evict_stats(
 ) {
     let total_shards = ENV_VARS.graphql.query_lfu_cache_shards as usize;
 
-    if total_shards > 0 {
-        if let Some(EvictStats {
+    if total_shards > 0
+        && let Some(EvictStats {
             new_weight,
             evicted_weight,
             new_count,
@@ -162,27 +175,26 @@ fn log_lfu_evict_stats(
             accesses,
             hits,
         }) = evict_stats
+    {
         {
-            {
-                let shard = (cache_key[0] as usize) % total_shards;
-                let network = network.to_string();
-                let logger = logger.clone();
-
-                graph::spawn(async move {
-                    debug!(logger, "Evicted LFU cache";
-                        "shard" => shard,
-                        "network" => network,
-                        "entries" => new_count,
-                        "entries_evicted" => evicted_count,
-                        "weight" => new_weight,
-                        "weight_evicted" => evicted_weight,
-                        "stale_update" => stale_update,
-                        "hit_rate" => format!("{:.0}%", hits as f64 / accesses as f64 * 100.0),
-                        "accesses" => accesses,
-                        "evict_time_ms" => evict_time.as_millis()
-                    )
-                });
-            }
+            let shard = (cache_key[0] as usize) % total_shards;
+            let network = network.to_string();
+            let logger = logger.clone();
+
+            graph::spawn(async move {
+                debug!(logger, "Evicted LFU cache";
+                    "shard" => shard,
+                    "network" => network,
+                    "entries" => new_count,
+                    "entries_evicted" => evicted_count,
+                    "weight" => new_weight,
+                    "weight_evicted" => evicted_weight,
+                    "stale_update" => stale_update,
+                    "hit_rate" => format!("{:.0}%", hits as f64 / accesses as f64 * 100.0),
+                    "accesses" => accesses,
+                    "evict_time_ms" => evict_time.as_millis()
+                )
+            });
         }
     }
 }
@@ -214,6 +226,9 @@ where
 
     /// Whether to include an execution trace in the result
     pub trace: bool,
+
+    /// The log store to use for querying logs.
+    pub log_store: Arc<dyn graph::components::log_store::LogStore>,
 }
 
 pub(crate) fn get_field<'a>(
@@ -241,12 +256,13 @@ where
             resolver: introspection_resolver,
             query: self.query.cheap_clone(),
             deadline: self.deadline,
-            max_first: std::u32::MAX,
-            max_skip: std::u32::MAX,
+            max_first: u32::MAX,
+            max_skip: u32::MAX,
 
             // `cache_status` is a dead value for the introspection context.
             cache_status: AtomicCell::new(CacheStatus::Miss),
             trace: ENV_VARS.log_sql_timing(),
+            log_store: self.log_store.cheap_clone(),
         }
     }
 }
@@ -256,11 +272,12 @@ pub(crate) async fn execute_root_selection_set_uncached(
     selection_set: &a::SelectionSet,
     root_type: &sast::ObjectType,
 ) -> Result<(Object, Trace), Vec<QueryExecutionError>> {
-    // Split the top-level fields into introspection fields and
-    // regular data fields
+    // Split the top-level fields into introspection fields,
+    // logs fields, meta fields, and regular data fields
     let mut data_set = a::SelectionSet::empty_from(selection_set);
     let mut intro_set = a::SelectionSet::empty_from(selection_set);
     let mut meta_items = Vec::new();
+    let mut logs_fields = Vec::new();
 
     for field in selection_set.fields_for(root_type)? {
         // See if this is an introspection or data field. We don't worry about
@@ -268,6 +285,8 @@ pub(crate) async fn execute_root_selection_set_uncached(
         // the data_set SelectionSet
         if is_introspection_field(&field.name) {
             intro_set.push(field)?
+        } else if field.name == LOGS_FIELD_NAME {
+            logs_fields.push(field)
         } else if field.name == META_FIELD_NAME || field.name == "__typename" {
             meta_items.push(field)
         } else {
@@ -275,11 +294,31 @@ pub(crate) async fn execute_root_selection_set_uncached(
         }
     }
 
+    // Validate that _logs queries cannot be combined with regular entity queries
+    if !logs_fields.is_empty() && !data_set.is_empty() {
+        return Err(vec![QueryExecutionError::ValidationError(
+            None,
+            "The _logs query cannot be combined with other entity queries in the same request"
+                .to_string(),
+        )]);
+    }
+
+    // If a client requests `_logs` but this indexer has no log store
+    // configured, return an error rather than silently returning empty
+    // results, which would otherwise be indistinguishable from a subgraph that
+    // genuinely produced no logs. Checked before prefetch/introspection so we
+    // don't do that work only to error out.
+    if !logs_fields.is_empty() && !ctx.log_store.is_available() {
+        return Err(vec![QueryExecutionError::NotSupported(
+            "the `_logs` query is not enabled on this indexer".to_string(),
+        )]);
+    }
+
     // If we are getting regular data, prefetch it from the database
     let (mut values, trace) = if data_set.is_empty() && meta_items.is_empty() {
         (Object::default(), Trace::None)
     } else {
-        let (initial_data, trace) = ctx.resolver.prefetch(ctx, &data_set)?;
+        let (initial_data, trace) = ctx.resolver.prefetch(ctx, &data_set).await?;
         data_set.push_fields(meta_items)?;
         (
             execute_selection_set_to_map(ctx, &data_set, root_type, initial_data).await?,
@@ -292,16 +331,101 @@ pub(crate) async fn execute_root_selection_set_uncached(
         let ictx = ctx.as_introspection_context();
 
         values.append(
-            execute_selection_set_to_map(
-                &ictx,
-                ctx.query.selection_set.as_ref(),
-                &*INTROSPECTION_QUERY_TYPE,
-                None,
-            )
-            .await?,
+            execute_selection_set_to_map(&ictx, &intro_set, &INTROSPECTION_QUERY_TYPE, None)
+                .await?,
         );
     }
 
+    // Resolve logs fields, if there are any
+    for field in logs_fields {
+        use graph::data::graphql::object;
+
+        // Build log query from field arguments
+        let log_query = crate::store::logs::build_log_query(field, ctx.query.schema.id())
+            .map_err(|e| vec![e])?;
+
+        // Query the log store
+        let log_entries = ctx.log_store.query_logs(log_query).await.map_err(|e| {
+            vec![QueryExecutionError::StoreError(
+                anyhow::Error::from(e).into(),
+            )]
+        })?;
+
+        // Get _Log_ type from schema for field selection
+        let log_type_def = ctx.query.schema.get_named_type("_Log_").ok_or_else(|| {
+            vec![QueryExecutionError::AbstractTypeError(
+                "_Log_ type not found in schema".to_string(),
+            )]
+        })?;
+        let log_object_type = match log_type_def {
+            s::TypeDefinition::Object(obj) => sast::ObjectType::from(Arc::new(obj.clone())),
+            _ => {
+                return Err(vec![QueryExecutionError::AbstractTypeError(
+                    "_Log_ is not an object type".to_string(),
+                )]);
+            }
+        };
+
+        // Convert log entries to GraphQL values, respecting field selection
+        let log_values: Vec<r::Value> = log_entries
+            .into_iter()
+            .map(|entry| {
+                // Convert log level to string (needed by multiple fields)
+                let level_str = entry.level.as_str().to_uppercase();
+                let mut results = Vec::new();
+
+                // Iterate over requested fields (same pattern as entity queries)
+                for log_field in field
+                    .selection_set
+                    .fields_for(&log_object_type)
+                    .map_err(|e| vec![e])?
+                {
+                    let response_key = log_field.response_key();
+
+                    // Map field name to LogEntry value (replaces prefetched_object lookup)
+                    let value = match log_field.name.as_str() {
+                        "id" => entry.id.clone().into_value(),
+                        "subgraphId" => entry.subgraph_id.to_string().into_value(),
+                        "timestamp" => entry.timestamp.clone().into_value(),
+                        "level" => level_str.clone().into_value(),
+                        "text" => entry.text.clone().into_value(),
+                        "arguments" => {
+                            // Convert arguments Vec<(String, String)> to GraphQL objects
+                            let args: Vec<r::Value> = entry
+                                .arguments
+                                .iter()
+                                .map(|(key, value)| {
+                                    object! {
+                                        key: key.clone(),
+                                        value: value.clone(),
+                                        __typename: "_LogArgument_"
+                                    }
+                                })
+                                .collect();
+                            r::Value::List(args)
+                        }
+                        "meta" => object! {
+                            module: entry.meta.module.clone(),
+                            line: r::Value::Int(entry.meta.line),
+                            column: r::Value::Int(entry.meta.column),
+                            __typename: "_LogMeta_"
+                        },
+                        "__typename" => "_Log_".into_value(),
+                        _ => continue, // Unknown field, skip it
+                    };
+
+                    results.push((Word::from(response_key), value));
+                }
+
+                Ok(r::Value::Object(Object::from_iter(results)))
+            })
+            .collect::<Result<Vec<_>, Vec<QueryExecutionError>>>()?;
+
+        let response_key = Word::from(field.response_key());
+        let logs_object = Object::from_iter(vec![(response_key, r::Value::List(log_values))]);
+        values.append(logs_object);
+    }
+
     Ok((values, trace))
 }
 
@@ -324,34 +448,34 @@ pub(crate) async fn execute_root_selection_set<R: Resolver>(
             }
         };
 
-    if should_check_cache {
-        if let (Some(block_ptr), Some(network)) = (block_ptr.as_ref(), &ctx.query.network) {
-            // JSONB and metadata queries use `BLOCK_NUMBER_MAX`. Ignore this case for two reasons:
-            // - Metadata queries are not cacheable.
-            // - Caching `BLOCK_NUMBER_MAX` would make this cache think all other blocks are old.
-            if block_ptr.number != BLOCK_NUMBER_MAX {
-                // Calculate the hash outside of the lock
-                let cache_key = cache_key(&ctx, &selection_set, block_ptr);
-                let shard = (cache_key[0] as usize) % QUERY_BLOCK_CACHE.len();
-
-                // Check if the response is cached, first in the recent blocks cache,
-                // and then in the LfuCache for historical queries
-                // The blocks are used to delimit how long locks need to be held
-                {
-                    let cache = QUERY_BLOCK_CACHE[shard].lock(&ctx.logger);
-                    if let Some(result) = cache.get(network, block_ptr, &cache_key) {
-                        ctx.cache_status.store(CacheStatus::Hit);
-                        return result;
-                    }
-                }
-                if let Some(mut cache) = lfu_cache(&ctx.logger, &cache_key) {
-                    if let Some(weighted) = cache.get(&cache_key) {
-                        ctx.cache_status.store(CacheStatus::Hit);
-                        return weighted.result.cheap_clone();
-                    }
+    if should_check_cache
+        && let (Some(block_ptr), Some(network)) = (block_ptr.as_ref(), &ctx.query.network)
+    {
+        // JSONB and metadata queries use `BLOCK_NUMBER_MAX`. Ignore this case for two reasons:
+        // - Metadata queries are not cacheable.
+        // - Caching `BLOCK_NUMBER_MAX` would make this cache think all other blocks are old.
+        if block_ptr.number != BLOCK_NUMBER_MAX {
+            // Calculate the hash outside of the lock
+            let cache_key = cache_key(&ctx, &selection_set, block_ptr);
+            let shard = (cache_key[0] as usize) % QUERY_BLOCK_CACHE.len();
+
+            // Check if the response is cached, first in the recent blocks cache,
+            // and then in the LfuCache for historical queries
+            // The blocks are used to delimit how long locks need to be held
+            {
+                let cache = QUERY_BLOCK_CACHE[shard].lock(&ctx.logger);
+                if let Some(result) = cache.get(network, block_ptr, &cache_key) {
+                    ctx.cache_status.store(CacheStatus::Hit);
+                    return result;
                 }
-                key = Some(cache_key);
             }
+            if let Some(mut cache) = lfu_cache(&ctx.logger, &cache_key)
+                && let Some(weighted) = cache.get(&cache_key)
+            {
+                ctx.cache_status.store(CacheStatus::Hit);
+                return weighted.result.cheap_clone();
+            }
+            key = Some(cache_key);
         }
     }
 
@@ -360,24 +484,27 @@ pub(crate) async fn execute_root_selection_set<R: Resolver>(
     let execute_root_type = root_type.cheap_clone();
     let run_query = async move {
         let _permit = execute_ctx.resolver.query_permit().await;
+        let query_start = Instant::now();
 
         let logger = execute_ctx.logger.clone();
         let query_text = execute_ctx.query.query_text.cheap_clone();
         let variables_text = execute_ctx.query.variables_text.cheap_clone();
         match graph::spawn_blocking_allow_panic(move || {
-            let mut query_res =
-                QueryResult::from(graph::block_on(execute_root_selection_set_uncached(
+            let mut query_res = QueryResult::from(
+                graph::block_on(execute_root_selection_set_uncached(
                     &execute_ctx,
                     &execute_selection_set,
                     &execute_root_type,
-                )));
+                ))
+                .map(|(obj, mut trace)| {
+                    trace.query_done(query_start.elapsed(), &_permit);
+                    (obj, trace)
+                }),
+            );
 
             // Unwrap: In practice should never fail, but if it does we will catch the panic.
             execute_ctx.resolver.post_process(&mut query_res).unwrap();
             query_res.deployment = Some(execute_ctx.query.schema.id().clone());
-            if let Ok(qp) = _permit {
-                query_res.trace.permit_wait(qp.wait);
-            }
             Arc::new(query_res)
         })
         .await
@@ -416,17 +543,18 @@ pub(crate) async fn execute_root_selection_set<R: Resolver>(
         ctx.cache_status.store(CacheStatus::Shared);
     }
 
+    // Calculate the weight once outside the lock.
+    let weight = result.weight();
+
     // Check if this query should be cached.
     // Share errors from the herd cache, but don't store them in generational cache.
     // In particular, there is a problem where asking for a block pointer beyond the chain
     // head can cause the legitimate cache to be thrown out.
     // It would be redundant to insert herd cache hits.
-    let no_cache = herd_hit || result.has_errors();
+    let no_cache = herd_hit || result.has_errors() || weight > *MAX_ENTRY_WEIGHT;
     if let (false, Some(key), Some(block_ptr), Some(network)) =
         (no_cache, key, block_ptr, &ctx.query.network)
     {
-        // Calculate the weight outside the lock.
-        let weight = result.weight();
         let shard = (key[0] as usize) % QUERY_BLOCK_CACHE.len();
         let inserted = QUERY_BLOCK_CACHE[shard].lock(&ctx.logger).insert(
             network,
@@ -598,7 +726,7 @@ async fn resolve_field_value(
             .await
         }
 
-        s::Type::NamedType(ref name) => {
+        s::Type::NamedType(name) => {
             resolve_field_value_for_named_type(
                 ctx,
                 object_type,
@@ -613,7 +741,6 @@ async fn resolve_field_value(
         s::Type::ListType(inner_type) => {
             resolve_field_value_for_list_type(
                 ctx,
-                object_type,
                 field_value,
                 field,
                 field_definition,
@@ -676,7 +803,6 @@ async fn resolve_field_value_for_named_type(
 #[async_recursion]
 async fn resolve_field_value_for_list_type(
     ctx: &ExecutionContext<impl Resolver>,
-    object_type: &s::ObjectType,
     field_value: Option<r::Value>,
     field: &a::Field,
     field_definition: &s::Field,
@@ -684,18 +810,11 @@ async fn resolve_field_value_for_list_type(
 ) -> Result<r::Value, Vec<QueryExecutionError>> {
     match inner_type {
         s::Type::NonNullType(inner_type) => {
-            resolve_field_value_for_list_type(
-                ctx,
-                object_type,
-                field_value,
-                field,
-                field_definition,
-                inner_type,
-            )
-            .await
+            resolve_field_value_for_list_type(ctx, field_value, field, field_definition, inner_type)
+                .await
         }
 
-        s::Type::NamedType(ref type_name) => {
+        s::Type::NamedType(type_name) => {
             let named_type = ctx
                 .query
                 .schema
@@ -882,8 +1001,8 @@ async fn complete_value(
 }
 
 /// Resolves an abstract type (interface, union) into an object type based on the given value.
-fn resolve_abstract_type<'a>(
-    ctx: &'a ExecutionContext<impl Resolver>,
+fn resolve_abstract_type(
+    ctx: &ExecutionContext<impl Resolver>,
     abstract_type: &s::TypeDefinition,
     object_value: &r::Value,
 ) -> Result<sast::ObjectType, Vec<QueryExecutionError>> {
diff --git a/graphql/src/execution/mod.rs b/graphql/src/execution/mod.rs
index 8e409d66770..d51bf6f5a75 100644
--- a/graphql/src/execution/mod.rs
+++ b/graphql/src/execution/mod.rs
@@ -1,5 +1,6 @@
 mod cache;
 /// Implementation of the GraphQL execution algorithm.
+#[allow(clippy::module_inception)]
 mod execution;
 mod query;
 /// Common trait for field resolvers used in the execution.
@@ -8,7 +9,7 @@ mod resolver;
 /// Our representation of a query AST
 pub mod ast;
 
-use stable_hash_legacy::{crypto::SetHasher, StableHasher};
+use stable_hash_legacy::{StableHasher, crypto::SetHasher};
 
 pub use self::execution::*;
 pub use self::query::Query;
diff --git a/graphql/src/execution/query.rs b/graphql/src/execution/query.rs
index c80eea6fd31..c12d68d7fa9 100644
--- a/graphql/src/execution/query.rs
+++ b/graphql/src/execution/query.rs
@@ -2,9 +2,8 @@ use graph::components::store::ChildMultiplicity;
 use graph::data::graphql::DocumentExt as _;
 use graph::data::value::{Object, Word};
 use graph::schema::ApiSchema;
-use graphql_parser::Pos;
 use graphql_tools::validation::rules::*;
-use graphql_tools::validation::validate::{validate, ValidationPlan};
+use graphql_tools::validation::validate::{ValidationPlan, validate};
 use lazy_static::lazy_static;
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::hash::{Hash, Hasher};
@@ -13,15 +12,15 @@ use std::sync::Arc;
 use std::time::Instant;
 use std::{collections::hash_map::DefaultHasher, convert::TryFrom};
 
-use graph::data::graphql::{ext::TypeExt, ObjectOrInterface};
-use graph::data::query::QueryExecutionError;
+use graph::data::graphql::{ObjectOrInterface, ext::TypeExt};
 use graph::data::query::{Query as GraphDataQuery, QueryVariables};
+use graph::data::query::{QueryExecutionError, Trace};
 use graph::prelude::{
-    info, o, q, r, s, warn, BlockNumber, CheapClone, DeploymentHash, EntityRange, GraphQLMetrics,
-    Logger, TryFromValue, ENV_VARS,
+    BlockNumber, CheapClone, DeploymentHash, ENV_VARS, EntityRange, GraphQLMetrics, Logger,
+    TryFromValue, info, o, q, r, s, warn,
 };
-use graph::schema::ast::{self as sast};
 use graph::schema::ErrorPolicy;
+use graph::schema::ast::{self as sast};
 
 use crate::execution::ast as a;
 use crate::execution::get_field;
@@ -36,7 +35,6 @@ lazy_static! {
             vec![
                 Box::new(UniqueOperationNames::new()),
                 Box::new(LoneAnonymousOperation::new()),
-                Box::new(SingleFieldSubscriptions::new()),
                 Box::new(KnownTypeNames::new()),
                 Box::new(FragmentsOnCompositeTypes::new()),
                 Box::new(VariablesAreInputTypes::new()),
@@ -70,12 +68,6 @@ pub enum ComplexityError {
     CyclicalFragment(String),
 }
 
-#[derive(Copy, Clone)]
-enum Kind {
-    Query,
-    Subscription,
-}
-
 /// Helper to log the fields in a `SelectionSet` without cloning. Writes
 /// a list of field names from the selection set separated by ';'. Using
 /// ';' as a separator makes parsing the log a little easier since slog
@@ -131,8 +123,6 @@ pub struct Query {
 
     start: Instant,
 
-    kind: Kind,
-
     /// Used only for logging; if logging is configured off, these will
     /// have dummy values
     pub query_text: Arc<String>,
@@ -227,27 +217,25 @@ impl Query {
         let operation = operation.ok_or(QueryExecutionError::OperationNameRequired)?;
 
         let variables = coerce_variables(schema.as_ref(), &operation, query.variables)?;
-        let (kind, selection_set) = match operation {
-            q::OperationDefinition::Query(q::Query { selection_set, .. }) => {
-                (Kind::Query, selection_set)
-            }
+        let selection_set = match operation {
+            q::OperationDefinition::Query(q::Query { selection_set, .. }) => selection_set,
             // Queries can be run by just sending a selection set
-            q::OperationDefinition::SelectionSet(selection_set) => (Kind::Query, selection_set),
-            q::OperationDefinition::Subscription(q::Subscription { selection_set, .. }) => {
-                (Kind::Subscription, selection_set)
+            q::OperationDefinition::SelectionSet(selection_set) => selection_set,
+            q::OperationDefinition::Subscription(_) => {
+                return Err(vec![QueryExecutionError::NotSupported(
+                    "Subscriptions are not supported".to_owned(),
+                )]);
             }
             q::OperationDefinition::Mutation(_) => {
                 return Err(vec![QueryExecutionError::NotSupported(
                     "Mutations are not supported".to_owned(),
-                )])
+                )]);
             }
         };
 
         let start = Instant::now();
-        let root_type = match kind {
-            Kind::Query => schema.query_type.as_ref(),
-            Kind::Subscription => schema.subscription_type.as_ref().unwrap(),
-        };
+        let root_type = schema.query_type.as_ref();
+
         // Use an intermediate struct so we can modify the query before
         // enclosing it in an Arc
         let raw_query = RawQuery {
@@ -270,7 +258,6 @@ impl Query {
             schema,
             selection_set: Arc::new(selection_set),
             shape_hash: query.shape_hash,
-            kind,
             network,
             logger,
             start,
@@ -282,6 +269,15 @@ impl Query {
         Ok(Arc::new(query))
     }
 
+    pub fn root_trace(&self, do_trace: bool) -> Trace {
+        Trace::root(
+            &self.query_text,
+            &self.variables_text,
+            &self.query_id,
+            do_trace,
+        )
+    }
+
     /// Return the block constraint for the toplevel query field(s), merging
     /// consecutive fields that have the same block constraint, while making
     /// sure that the fields appear in the same order as they did in the
@@ -301,7 +297,7 @@ impl Query {
             let bc = match field.argument_value("block") {
                 Some(bc) => BlockConstraint::try_from_value(bc).map_err(|_| {
                     vec![QueryExecutionError::InvalidArgumentError(
-                        Pos::default(),
+                        q::Pos::default(),
                         "block".to_string(),
                         bc.clone().into(),
                     )]
@@ -312,7 +308,7 @@ impl Query {
             let field_error_policy = match field.argument_value("subgraphError") {
                 Some(value) => ErrorPolicy::try_from(value).map_err(|_| {
                     vec![QueryExecutionError::InvalidArgumentError(
-                        Pos::default(),
+                        q::Pos::default(),
                         "subgraphError".to_string(),
                         value.clone().into(),
                     )]
@@ -337,23 +333,6 @@ impl Query {
         Ok(bcs)
     }
 
-    /// Return `true` if this is a query, and not a subscription or
-    /// mutation
-    pub fn is_query(&self) -> bool {
-        match self.kind {
-            Kind::Query => true,
-            Kind::Subscription => false,
-        }
-    }
-
-    /// Return `true` if this is a subscription, not a query or a mutation
-    pub fn is_subscription(&self) -> bool {
-        match self.kind {
-            Kind::Subscription => true,
-            Kind::Query => false,
-        }
-    }
-
     /// Log details about the overall execution of the query
     pub fn log_execution(&self, block: BlockNumber) {
         if ENV_VARS.log_gql_timing() {
@@ -489,13 +468,13 @@ impl<'s> RawQuery<'s> {
         max_depth: u8,
     ) -> Result<u64, Vec<QueryExecutionError>> {
         let complexity = self.complexity(max_depth).map_err(|e| vec![e])?;
-        if let Some(max_complexity) = max_complexity {
-            if complexity > max_complexity {
-                return Err(vec![QueryExecutionError::TooComplex(
-                    complexity,
-                    max_complexity,
-                )]);
-            }
+        if let Some(max_complexity) = max_complexity
+            && complexity > max_complexity
+        {
+            return Err(vec![QueryExecutionError::TooComplex(
+                complexity,
+                max_complexity,
+            )]);
         }
         Ok(complexity)
     }
@@ -623,9 +602,7 @@ impl<'s> RawQuery<'s> {
             Ok(complexity) => Ok(complexity),
             Err(ComplexityError::Invalid) => Ok(0),
             Err(ComplexityError::TooDeep) => Err(QueryExecutionError::TooDeep(max_depth)),
-            Err(ComplexityError::Overflow) => {
-                Err(QueryExecutionError::TooComplex(u64::max_value(), 0))
-            }
+            Err(ComplexityError::Overflow) => Err(QueryExecutionError::TooComplex(u64::MAX, 0)),
             Err(ComplexityError::CyclicalFragment(name)) => {
                 Err(QueryExecutionError::CyclicalFragment(name))
             }
@@ -751,21 +728,17 @@ impl Transform {
     }
 
     /// Interpolate variable references in the arguments `args`
-    fn interpolate_arguments(
-        &self,
-        args: Vec<(String, q::Value)>,
-        pos: &Pos,
-    ) -> Vec<(String, r::Value)> {
+    fn interpolate_arguments(&self, args: Vec<(String, q::Value)>) -> Vec<(String, r::Value)> {
         args.into_iter()
             .map(|(name, val)| {
-                let val = self.interpolate_value(val, pos);
+                let val = self.interpolate_value(val);
                 (name, val)
             })
             .collect()
     }
 
     /// Turn `value` into an `r::Value` by resolving variable references
-    fn interpolate_value(&self, value: q::Value, pos: &Pos) -> r::Value {
+    fn interpolate_value(&self, value: q::Value) -> r::Value {
         match value {
             q::Value::Variable(var) => self.variable(&var),
             q::Value::Int(ref num) => {
@@ -779,14 +752,14 @@ impl Transform {
             q::Value::List(vals) => {
                 let vals = vals
                     .into_iter()
-                    .map(|val| self.interpolate_value(val, pos))
+                    .map(|val| self.interpolate_value(val))
                     .collect();
                 r::Value::List(vals)
             }
             q::Value::Object(map) => {
                 let mut rmap = BTreeMap::new();
                 for (key, value) in map.into_iter() {
-                    let value = self.interpolate_value(value, pos);
+                    let value = self.interpolate_value(value);
                     rmap.insert(key.into(), value);
                 }
                 r::Value::object(rmap)
@@ -809,7 +782,7 @@ impl Transform {
                     position,
                     arguments,
                 } = dir;
-                let arguments = self.interpolate_arguments(arguments, &position);
+                let arguments = self.interpolate_arguments(arguments);
                 a::Directive {
                     name,
                     position,
@@ -926,7 +899,7 @@ impl Transform {
             return Ok(None);
         }
 
-        let mut arguments = self.interpolate_arguments(arguments, &position);
+        let mut arguments = self.interpolate_arguments(arguments);
         self.coerce_argument_values(&mut arguments, parent_type, &name)?;
 
         let is_leaf_type = self.schema.document().is_leaf_type(&field_type.field_type);
diff --git a/graphql/src/execution/resolver.rs b/graphql/src/execution/resolver.rs
index 1b139c65828..7e0609e98d4 100644
--- a/graphql/src/execution/resolver.rs
+++ b/graphql/src/execution/resolver.rs
@@ -1,15 +1,17 @@
 use std::time::Duration;
 
-use graph::components::store::{QueryPermit, UnitStream};
+use async_trait::async_trait;
+
+use graph::components::store::QueryPermit;
 use graph::data::query::{CacheStatus, Trace};
-use graph::prelude::{async_trait, s, Error, QueryExecutionError};
+use graph::prelude::{Error, QueryExecutionError, s};
 use graph::schema::ApiSchema;
 use graph::{
     data::graphql::ObjectOrInterface,
-    prelude::{r, QueryResult},
+    prelude::{QueryResult, r},
 };
 
-use crate::execution::{ast as a, ExecutionContext};
+use crate::execution::{ExecutionContext, ast as a};
 
 use super::Query;
 
@@ -18,10 +20,10 @@ use super::Query;
 pub trait Resolver: Sized + Send + Sync + 'static {
     const CACHEABLE: bool;
 
-    async fn query_permit(&self) -> Result<QueryPermit, QueryExecutionError>;
+    async fn query_permit(&self) -> QueryPermit;
 
     /// Prepare for executing a query by prefetching as much data as possible
-    fn prefetch(
+    async fn prefetch(
         &self,
         ctx: &ExecutionContext<Self>,
         selection_set: &a::SelectionSet,
@@ -111,18 +113,6 @@ pub trait Resolver: Sized + Send + Sync + 'static {
         }
     }
 
-    // Resolves a change stream for a given field.
-    fn resolve_field_stream(
-        &self,
-        _schema: &ApiSchema,
-        _object_type: &s::ObjectType,
-        _field: &a::Field,
-    ) -> Result<UnitStream, QueryExecutionError> {
-        Err(QueryExecutionError::NotSupported(String::from(
-            "Resolving field streams is not supported by this resolver",
-        )))
-    }
-
     fn post_process(&self, _result: &mut QueryResult) -> Result<(), Error> {
         Ok(())
     }
diff --git a/graphql/src/introspection/resolver.rs b/graphql/src/introspection/resolver.rs
index 196c30b1df6..39ead572448 100644
--- a/graphql/src/introspection/resolver.rs
+++ b/graphql/src/introspection/resolver.rs
@@ -1,15 +1,15 @@
+use async_trait::async_trait;
 use graph::components::store::QueryPermit;
 use graph::data::graphql::ext::{FieldExt, TypeDefinitionExt};
 use graph::data::query::Trace;
-use graphql_parser::Pos;
 use std::collections::BTreeMap;
 
-use graph::data::graphql::{object, DocumentExt, ObjectOrInterface};
+use graph::data::graphql::{DocumentExt, ObjectOrInterface, object};
 use graph::prelude::*;
 
 use crate::execution::ast as a;
 use crate::prelude::*;
-use graph::schema::{ast as sast, Schema};
+use graph::schema::{Schema, ast as sast};
 
 type TypeObjectsMap = BTreeMap<String, r::Value>;
 
@@ -34,8 +34,8 @@ fn type_object(schema: &Schema, type_objects: &mut TypeObjectsMap, t: &s::Type)
     match t {
         // We store the name of the named type here to be able to resolve it dynamically later
         s::Type::NamedType(s) => r::Value::String(s.clone()),
-        s::Type::ListType(ref inner) => list_type_object(schema, type_objects, inner),
-        s::Type::NonNullType(ref inner) => non_null_type_object(schema, type_objects, inner),
+        s::Type::ListType(inner) => list_type_object(schema, type_objects, inner),
+        s::Type::NonNullType(inner) => non_null_type_object(schema, type_objects, inner),
     }
 }
 
@@ -300,6 +300,8 @@ fn input_value(
                 .map_or(r::Value::Null, |value| {
                     r::Value::String(format!("{}", value))
                 }),
+        isDeprecated: false,
+        deprecationReason: r::Value::Null,
     }
 }
 
@@ -333,10 +335,7 @@ impl IntrospectionResolver {
                 self.type_objects
                     .get(&String::from("Query"))
                     .cloned(),
-            subscriptionType:
-                self.type_objects
-                    .get(&String::from("Subscription"))
-                    .cloned(),
+            subscriptionType: r::Value::Null,
             mutationType: r::Value::Null,
             types: self.type_objects.values().cloned().collect::<Vec<_>>(),
             directives: self.directives.clone(),
@@ -360,11 +359,11 @@ impl Resolver for IntrospectionResolver {
     // see `fn as_introspection_context`, so this value is irrelevant.
     const CACHEABLE: bool = false;
 
-    async fn query_permit(&self) -> Result<QueryPermit, QueryExecutionError> {
+    async fn query_permit(&self) -> QueryPermit {
         unreachable!()
     }
 
-    fn prefetch(
+    async fn prefetch(
         &self,
         _: &ExecutionContext<Self>,
         _: &a::SelectionSet,
@@ -392,7 +391,7 @@ impl Resolver for IntrospectionResolver {
                         type_names
                             .iter()
                             .filter_map(|type_name| match type_name {
-                                r::Value::String(ref type_name) => Some(type_name),
+                                r::Value::String(type_name) => Some(type_name),
                                 _ => None,
                             })
                             .filter_map(|type_name| self.type_objects.get(type_name).cloned())
@@ -425,7 +424,7 @@ impl Resolver for IntrospectionResolver {
             "__type" => {
                 let name = field.argument_value("name").ok_or_else(|| {
                     QueryExecutionError::MissingArgumentError(
-                        Pos::default(),
+                        q::Pos::default(),
                         "missing argument `name` in `__type(name: String!)`".to_owned(),
                     )
                 })?;
diff --git a/graphql/src/lib.rs b/graphql/src/lib.rs
index b167427a369..9869d0a5344 100644
--- a/graphql/src/lib.rs
+++ b/graphql/src/lib.rs
@@ -1,5 +1,3 @@
-pub extern crate graphql_parser;
-
 /// Utilities for schema introspection.
 pub mod introspection;
 
@@ -9,9 +7,6 @@ mod execution;
 /// Utilities for executing GraphQL queries and working with query ASTs.
 pub mod query;
 
-/// Utilities for executing GraphQL subscriptions.
-pub mod subscription;
-
 /// Utilities for working with GraphQL values.
 mod values;
 
@@ -26,11 +21,10 @@ mod metrics;
 
 /// Prelude that exports the most important traits and types.
 pub mod prelude {
-    pub use super::execution::{ast as a, ExecutionContext, Query, Resolver};
+    pub use super::execution::{ExecutionContext, Query, Resolver, ast as a};
     pub use super::introspection::IntrospectionResolver;
-    pub use super::query::{execute_query, ext::BlockConstraint, QueryExecutionOptions};
+    pub use super::query::{QueryExecutionOptions, execute_query, ext::BlockConstraint};
     pub use super::store::StoreResolver;
-    pub use super::subscription::SubscriptionExecutionOptions;
     pub use super::values::MaybeCoercible;
 
     pub use super::metrics::GraphQLMetrics;
diff --git a/graphql/src/query/ext.rs b/graphql/src/query/ext.rs
index 034d37d6e53..c57c35c5392 100644
--- a/graphql/src/query/ext.rs
+++ b/graphql/src/query/ext.rs
@@ -2,13 +2,12 @@
 
 use graph::blockchain::BlockHash;
 use graph::prelude::TryFromValue;
-use graphql_parser::Pos;
 
 use std::collections::{BTreeMap, HashMap};
 
 use anyhow::anyhow;
 use graph::data::query::QueryExecutionError;
-use graph::prelude::{q, r, BlockNumber, Error};
+use graph::prelude::{BlockNumber, Error, q, r};
 
 pub trait ValueExt: Sized {
     fn as_object(&self) -> &BTreeMap<String, q::Value>;
@@ -22,7 +21,7 @@ pub trait ValueExt: Sized {
     fn lookup<'a>(
         &'a self,
         vars: &'a HashMap<String, Self>,
-        pos: Pos,
+        pos: q::Pos,
     ) -> Result<&'a Self, QueryExecutionError>;
 }
 
@@ -44,7 +43,7 @@ impl ValueExt for q::Value {
     fn lookup<'a>(
         &'a self,
         vars: &'a HashMap<String, q::Value>,
-        pos: Pos,
+        pos: q::Pos,
     ) -> Result<&'a q::Value, QueryExecutionError> {
         match self {
             q::Value::Variable(name) => vars
@@ -55,19 +54,26 @@ impl ValueExt for q::Value {
     }
 }
 
-#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+#[derive(Clone, PartialEq, Eq, Hash, Debug, Default)]
 pub enum BlockConstraint {
     Hash(BlockHash),
     Number(BlockNumber),
     /// Execute the query on the latest block only if the the subgraph has progressed to or past the
     /// given block number.
     Min(BlockNumber),
+    #[default]
     Latest,
 }
 
-impl Default for BlockConstraint {
-    fn default() -> Self {
-        BlockConstraint::Latest
+impl BlockConstraint {
+    /// Return the `Some(hash)` if this constraint constrains by hash,
+    /// otherwise return `None`
+    pub fn hash(&self) -> Option<&BlockHash> {
+        use BlockConstraint::*;
+        match self {
+            Hash(hash) => Some(hash),
+            Number(_) | Min(_) | Latest => None,
+        }
     }
 }
 
diff --git a/graphql/src/query/mod.rs b/graphql/src/query/mod.rs
index 9cbe4a405e2..86244c4cc71 100644
--- a/graphql/src/query/mod.rs
+++ b/graphql/src/query/mod.rs
@@ -1,4 +1,7 @@
-use graph::prelude::{BlockPtr, CheapClone, QueryExecutionError, QueryResult};
+use graph::{
+    data::query::CacheStatus,
+    prelude::{BlockPtr, CheapClone, QueryResult},
+};
 use std::sync::Arc;
 use std::time::Instant;
 
@@ -26,6 +29,9 @@ pub struct QueryExecutionOptions<R> {
 
     /// Whether to include an execution trace in the result
     pub trace: bool,
+
+    /// The log store to use for querying logs.
+    pub log_store: Arc<dyn graph::components::log_store::LogStore>,
 }
 
 /// Executes a query and returns a result.
@@ -35,7 +41,7 @@ pub async fn execute_query<R>(
     selection_set: Option<a::SelectionSet>,
     block_ptr: Option<BlockPtr>,
     options: QueryExecutionOptions<R>,
-) -> Arc<QueryResult>
+) -> (Arc<QueryResult>, CacheStatus)
 where
     R: Resolver,
 {
@@ -49,13 +55,9 @@ where
         max_skip: options.max_skip,
         cache_status: Default::default(),
         trace: options.trace,
+        log_store: options.log_store,
     });
 
-    if !query.is_query() {
-        return Arc::new(
-            QueryExecutionError::NotSupported("Only queries are supported".to_string()).into(),
-        );
-    }
     let selection_set = selection_set
         .map(Arc::new)
         .unwrap_or_else(|| query.selection_set.cheap_clone());
@@ -80,5 +82,5 @@ where
         start,
         cache_status.to_string(),
     );
-    result
+    (result, cache_status)
 }
diff --git a/graphql/src/runner.rs b/graphql/src/runner.rs
index 5bc1666ced1..dd4b6919500 100644
--- a/graphql/src/runner.rs
+++ b/graphql/src/runner.rs
@@ -1,32 +1,32 @@
 use std::sync::Arc;
 use std::time::Instant;
 
+use async_trait::async_trait;
+
 use crate::metrics::GraphQLMetrics;
-use crate::prelude::{QueryExecutionOptions, StoreResolver, SubscriptionExecutionOptions};
+use crate::prelude::{QueryExecutionOptions, StoreResolver};
 use crate::query::execute_query;
-use crate::subscription::execute_prepared_subscription;
-use graph::prelude::MetricsRegistry;
-use graph::{
-    components::store::SubscriptionManager,
-    prelude::{
-        async_trait, o, CheapClone, DeploymentState, GraphQLMetrics as GraphQLMetricsTrait,
-        GraphQlRunner as GraphQlRunnerTrait, Logger, Query, QueryExecutionError, Subscription,
-        SubscriptionError, SubscriptionResult, ENV_VARS,
-    },
+use graph::data::query::{CacheStatus, SqlQueryReq};
+use graph::data::store::SqlQueryObject;
+use graph::futures03::future;
+use graph::prelude::{ApiVersion, MetricsRegistry};
+use graph::prelude::{
+    CheapClone, DeploymentState, ENV_VARS, GraphQLMetrics as GraphQLMetricsTrait,
+    GraphQlRunner as GraphQlRunnerTrait, Logger, Query, QueryExecutionError, o,
 };
 use graph::{data::graphql::load_manager::LoadManager, prelude::QueryStoreManager};
 use graph::{
-    data::query::{QueryResults, QueryTarget},
+    data::query::{LatestBlockInfo, QueryResults, QueryTarget},
     prelude::QueryStore,
 };
 
 /// GraphQL runner implementation for The Graph.
-pub struct GraphQlRunner<S, SM> {
+pub struct GraphQlRunner<S> {
     logger: Logger,
     store: Arc<S>,
-    subscription_manager: Arc<SM>,
     load_manager: Arc<LoadManager>,
     graphql_metrics: Arc<GraphQLMetrics>,
+    log_store: Arc<dyn graph::components::log_store::LogStore>,
 }
 
 #[cfg(debug_assertions)]
@@ -35,27 +35,26 @@ lazy_static::lazy_static! {
     pub static ref INITIAL_DEPLOYMENT_STATE_FOR_TESTS: std::sync::Mutex<Option<DeploymentState>> = std::sync::Mutex::new(None);
 }
 
-impl<S, SM> GraphQlRunner<S, SM>
+impl<S> GraphQlRunner<S>
 where
     S: QueryStoreManager,
-    SM: SubscriptionManager,
 {
     /// Creates a new query runner.
     pub fn new(
         logger: &Logger,
         store: Arc<S>,
-        subscription_manager: Arc<SM>,
         load_manager: Arc<LoadManager>,
         registry: Arc<MetricsRegistry>,
+        log_store: Arc<dyn graph::components::log_store::LogStore>,
     ) -> Self {
         let logger = logger.new(o!("component" => "GraphQlRunner"));
         let graphql_metrics = Arc::new(GraphQLMetrics::new(registry));
         GraphQlRunner {
             logger,
             store,
-            subscription_manager,
             load_manager,
             graphql_metrics,
+            log_store,
         }
     }
 
@@ -99,6 +98,8 @@ where
         max_skip: Option<u32>,
         metrics: Arc<GraphQLMetrics>,
     ) -> Result<QueryResults, QueryResults> {
+        let execute_start = Instant::now();
+
         // We need to use the same `QueryStore` for the entire query to ensure
         // we have a consistent view if the world, even when replicas, which
         // are eventually consistent, are in use. If we run different parts
@@ -109,10 +110,24 @@ where
         // point, and everything needs to go through the `store` we are
         // setting up here
 
-        let store = self.store.query_store(target.clone(), false).await?;
+        let store = self.store.query_store(target.clone()).await?;
         let state = store.deployment_state().await?;
         let network = Some(store.network_name().to_string());
-        let schema = store.api_schema()?;
+        let schema = store.api_schema().await?;
+
+        let latest_block = match store.block_ptr().await.ok().flatten() {
+            Some(block) => Some(LatestBlockInfo {
+                timestamp: store
+                    .block_number_with_timestamp_and_parent_hash(&block.hash)
+                    .await
+                    .ok()
+                    .flatten()
+                    .and_then(|(_, t, _)| t),
+                hash: block.hash,
+                number: block.number,
+            }),
+            None => None,
+        };
 
         // Test only, see c435c25decbc4ad7bbbadf8e0ced0ff2
         #[cfg(debug_assertions)]
@@ -123,7 +138,7 @@ where
             .unwrap_or(state);
 
         let max_depth = max_depth.unwrap_or(ENV_VARS.graphql.max_depth);
-        let trace = query.trace;
+        let do_trace = query.trace;
         let query = crate::execution::Query::new(
             &self.logger,
             schema,
@@ -135,26 +150,28 @@ where
         )?;
         self.load_manager
             .decide(
-                &store.wait_stats().map_err(QueryExecutionError::from)?,
+                &store.wait_stats(),
                 store.shard(),
                 store.deployment_id(),
                 query.shape_hash,
                 query.query_text.as_ref(),
             )
             .to_result()?;
-        let by_block_constraint = query.block_constraint()?;
+        let by_block_constraint =
+            StoreResolver::locate_blocks(store.as_ref(), &state, &query).await?;
         let mut max_block = 0;
-        let mut result: QueryResults = QueryResults::empty();
+        let mut result: QueryResults =
+            QueryResults::empty(query.root_trace(do_trace), latest_block);
+        let mut query_res_futures: Vec<_> = vec![];
+        let setup_elapsed = execute_start.elapsed();
 
         // Note: This will always iterate at least once.
-        for (bc, (selection_set, error_policy)) in by_block_constraint {
-            let query_start = Instant::now();
+        for (ptr, (selection_set, error_policy)) in by_block_constraint {
             let resolver = StoreResolver::at_block(
                 &self.logger,
                 store.cheap_clone(),
                 &state,
-                self.subscription_manager.cheap_clone(),
-                bc,
+                ptr,
                 error_policy,
                 query.schema.id().clone(),
                 metrics.cheap_clone(),
@@ -162,24 +179,37 @@ where
             )
             .await?;
             max_block = max_block.max(resolver.block_number());
-            let query_res = execute_query(
+            query_res_futures.push(execute_query(
                 query.clone(),
                 Some(selection_set),
-                resolver.block_ptr.as_ref().map(Into::into).clone(),
+                resolver.block_ptr.clone(),
                 QueryExecutionOptions {
                     resolver,
                     deadline: ENV_VARS.graphql.query_timeout.map(|t| Instant::now() + t),
                     max_first: max_first.unwrap_or(ENV_VARS.graphql.max_first),
                     max_skip: max_skip.unwrap_or(ENV_VARS.graphql.max_skip),
-                    trace,
+                    trace: do_trace,
+                    log_store: self.log_store.cheap_clone(),
                 },
-            )
-            .await;
-            query_res.trace.finish(query_start.elapsed());
-            result.append(query_res);
+            ));
+        }
+
+        let results: Vec<_> = if ENV_VARS.graphql.parallel_block_constraints {
+            future::join_all(query_res_futures).await
+        } else {
+            let mut results = vec![];
+            for query_res_future in query_res_futures {
+                results.push(query_res_future.await);
+            }
+            results
+        };
+
+        for (query_res, cache_status) in results {
+            result.append(query_res, cache_status);
         }
 
         query.log_execution(max_block);
+        result.trace.finish(setup_elapsed, execute_start.elapsed());
         self.deployment_changed(store.as_ref(), state, max_block as u64)
             .await
             .map_err(QueryResults::from)
@@ -188,10 +218,9 @@ where
 }
 
 #[async_trait]
-impl<S, SM> GraphQlRunnerTrait for GraphQlRunner<S, SM>
+impl<S> GraphQlRunnerTrait for GraphQlRunner<S>
 where
     S: QueryStoreManager,
-    SM: SubscriptionManager,
 {
     async fn run_query(self: Arc<Self>, query: Query, target: QueryTarget) -> QueryResults {
         self.run_query_with_complexity(
@@ -227,57 +256,52 @@ where
         .unwrap_or_else(|e| e)
     }
 
-    async fn run_subscription(
+    fn metrics(&self) -> Arc<dyn GraphQLMetricsTrait> {
+        self.graphql_metrics.clone()
+    }
+
+    async fn run_sql_query(
         self: Arc<Self>,
-        subscription: Subscription,
-        target: QueryTarget,
-    ) -> Result<SubscriptionResult, SubscriptionError> {
-        let store = self.store.query_store(target.clone(), true).await?;
-        let schema = store.api_schema()?;
-        let network = store.network_name().to_string();
+        req: SqlQueryReq,
+    ) -> Result<Vec<SqlQueryObject>, QueryExecutionError> {
+        // Check if SQL queries are enabled
+        if !ENV_VARS.sql_queries_enabled() {
+            return Err(QueryExecutionError::SqlError(
+                "SQL queries are disabled. Set GRAPH_ENABLE_SQL_QUERIES=true to enable."
+                    .to_string(),
+            ));
+        }
 
-        let query = crate::execution::Query::new(
-            &self.logger,
-            schema,
-            Some(network),
-            subscription.query,
-            ENV_VARS.graphql.max_complexity,
-            ENV_VARS.graphql.max_depth,
-            self.graphql_metrics.cheap_clone(),
-        )?;
+        let store = self
+            .store
+            .query_store(QueryTarget::Deployment(
+                req.deployment.clone(),
+                ApiVersion::default(),
+            ))
+            .await?;
 
-        if let Err(err) = self
-            .load_manager
+        let query_hash = req.query_hash();
+        self.load_manager
             .decide(
-                &store.wait_stats().map_err(QueryExecutionError::from)?,
+                &store.wait_stats(),
                 store.shard(),
                 store.deployment_id(),
-                query.shape_hash,
-                query.query_text.as_ref(),
+                query_hash,
+                &req.query,
             )
-            .to_result()
-        {
-            return Err(SubscriptionError::GraphQLError(vec![err]));
-        }
+            .to_result()?;
 
-        execute_prepared_subscription(
-            query,
-            SubscriptionExecutionOptions {
-                logger: self.logger.clone(),
-                store,
-                subscription_manager: self.subscription_manager.cheap_clone(),
-                timeout: ENV_VARS.graphql.query_timeout,
-                max_complexity: ENV_VARS.graphql.max_complexity,
-                max_depth: ENV_VARS.graphql.max_depth,
-                max_first: ENV_VARS.graphql.max_first,
-                max_skip: ENV_VARS.graphql.max_skip,
-                graphql_metrics: self.graphql_metrics.clone(),
-                load_manager: self.load_manager.cheap_clone(),
-            },
-        )
-    }
+        let query_start = Instant::now();
+        let result = store.execute_sql(&req.query).await;
 
-    fn metrics(&self) -> Arc<dyn GraphQLMetricsTrait> {
-        self.graphql_metrics.clone()
+        self.load_manager.record_work(
+            store.shard(),
+            store.deployment_id(),
+            query_hash,
+            query_start.elapsed(),
+            CacheStatus::Miss,
+        );
+
+        result
     }
 }
diff --git a/graphql/src/store/logs.rs b/graphql/src/store/logs.rs
new file mode 100644
index 00000000000..57cd4e61ded
--- /dev/null
+++ b/graphql/src/store/logs.rs
@@ -0,0 +1,187 @@
+use graph::components::log_store::LogQuery;
+use graph::prelude::{DeploymentHash, QueryExecutionError, q, r};
+
+use crate::execution::ast as a;
+
+const MAX_FIRST: u32 = 1000;
+const MAX_SKIP: u32 = 10000;
+const MAX_TEXT_LENGTH: usize = 1000;
+
+/// Validate and sanitize text search input to prevent injection attacks
+fn validate_text_input(text: &str) -> Result<(), &'static str> {
+    if text.is_empty() {
+        return Err("search text cannot be empty");
+    }
+
+    if text.len() > MAX_TEXT_LENGTH {
+        return Err("search text exceeds maximum length of 1000 characters");
+    }
+
+    // Reject strings that look like Elasticsearch query DSL to prevent injection
+    if text
+        .chars()
+        .any(|c| matches!(c, '{' | '}' | '[' | ']' | ':' | '"'))
+    {
+        return Err("search text contains invalid characters ({}[]:\")");
+    }
+
+    Ok(())
+}
+
+/// Validate RFC3339 timestamp format
+fn validate_timestamp(timestamp: &str) -> Result<(), &'static str> {
+    if !timestamp.contains('T') {
+        return Err("must be in ISO 8601 format (e.g., 2024-01-15T10:30:00Z)");
+    }
+
+    if !timestamp.ends_with('Z') && !timestamp.contains('+') && !timestamp.contains('-') {
+        return Err("must include timezone (Z or offset like +00:00)");
+    }
+
+    if timestamp.len() > 50 {
+        return Err("timestamp exceeds maximum length");
+    }
+
+    // Check for suspicious characters that could be injection attempts
+    if timestamp
+        .chars()
+        .any(|c| matches!(c, '{' | '}' | ';' | '\'' | '"'))
+    {
+        return Err("timestamp contains invalid characters");
+    }
+
+    Ok(())
+}
+
+pub fn build_log_query(
+    field: &a::Field,
+    subgraph_id: &DeploymentHash,
+) -> Result<LogQuery, QueryExecutionError> {
+    let mut level = None;
+    let mut from = None;
+    let mut to = None;
+    let mut search = None;
+    let mut first = 100;
+    let mut skip = 0;
+    let mut order_direction = graph::components::log_store::OrderDirection::Desc;
+
+    // Parse arguments
+    for (name, value) in &field.arguments {
+        match name.as_str() {
+            "level" => {
+                if let r::Value::Enum(level_str) = value {
+                    level = Some(level_str.parse().map_err(|_| {
+                        QueryExecutionError::InvalidArgumentError(
+                            field.position,
+                            "level".to_string(),
+                            q::Value::String(format!("Invalid log level: {}", level_str)),
+                        )
+                    })?);
+                }
+            }
+            "from" => {
+                if let r::Value::String(from_str) = value {
+                    validate_timestamp(from_str).map_err(|e| {
+                        QueryExecutionError::InvalidArgumentError(
+                            field.position,
+                            "from".to_string(),
+                            q::Value::String(format!("Invalid timestamp: {}", e)),
+                        )
+                    })?;
+                    from = Some(from_str.clone());
+                }
+            }
+            "to" => {
+                if let r::Value::String(to_str) = value {
+                    validate_timestamp(to_str).map_err(|e| {
+                        QueryExecutionError::InvalidArgumentError(
+                            field.position,
+                            "to".to_string(),
+                            q::Value::String(format!("Invalid timestamp: {}", e)),
+                        )
+                    })?;
+                    to = Some(to_str.clone());
+                }
+            }
+            "search" => {
+                if let r::Value::String(search_str) = value {
+                    validate_text_input(search_str).map_err(|e| {
+                        QueryExecutionError::InvalidArgumentError(
+                            field.position,
+                            "search".to_string(),
+                            q::Value::String(format!("Invalid search text: {}", e)),
+                        )
+                    })?;
+                    search = Some(search_str.clone());
+                }
+            }
+            "first" => {
+                if let r::Value::Int(first_val) = value {
+                    let first_i64 = *first_val;
+                    if first_i64 < 0 {
+                        return Err(QueryExecutionError::InvalidArgumentError(
+                            field.position,
+                            "first".to_string(),
+                            q::Value::String("first must be non-negative".to_string()),
+                        ));
+                    }
+                    let first_u32 = first_i64 as u32;
+                    if first_u32 > MAX_FIRST {
+                        return Err(QueryExecutionError::InvalidArgumentError(
+                            field.position,
+                            "first".to_string(),
+                            q::Value::String(format!("first must not exceed {}", MAX_FIRST)),
+                        ));
+                    }
+                    first = first_u32;
+                }
+            }
+            "skip" => {
+                if let r::Value::Int(skip_val) = value {
+                    let skip_i64 = *skip_val;
+                    if skip_i64 < 0 {
+                        return Err(QueryExecutionError::InvalidArgumentError(
+                            field.position,
+                            "skip".to_string(),
+                            q::Value::String("skip must be non-negative".to_string()),
+                        ));
+                    }
+                    let skip_u32 = skip_i64 as u32;
+                    if skip_u32 > MAX_SKIP {
+                        return Err(QueryExecutionError::InvalidArgumentError(
+                            field.position,
+                            "skip".to_string(),
+                            q::Value::String(format!("skip must not exceed {}", MAX_SKIP)),
+                        ));
+                    }
+                    skip = skip_u32;
+                }
+            }
+            "orderDirection" => {
+                if let r::Value::Enum(order_str) = value {
+                    order_direction = order_str.parse().map_err(|e: String| {
+                        QueryExecutionError::InvalidArgumentError(
+                            field.position,
+                            "orderDirection".to_string(),
+                            q::Value::String(e),
+                        )
+                    })?;
+                }
+            }
+            _ => {
+                // Unknown argument, ignore
+            }
+        }
+    }
+
+    Ok(LogQuery {
+        subgraph_id: subgraph_id.clone(),
+        level,
+        from,
+        to,
+        search,
+        first,
+        skip,
+        order_direction,
+    })
+}
diff --git a/graphql/src/store/mod.rs b/graphql/src/store/mod.rs
index 85ceb4275d7..8f77a832b90 100644
--- a/graphql/src/store/mod.rs
+++ b/graphql/src/store/mod.rs
@@ -1,6 +1,6 @@
+pub mod logs;
 mod prefetch;
 mod query;
 mod resolver;
 
-pub use self::query::parse_subgraph_id;
 pub use self::resolver::StoreResolver;
diff --git a/graphql/src/store/prefetch.rs b/graphql/src/store/prefetch.rs
index c8c3e34dafe..e9a04c8c97b 100644
--- a/graphql/src/store/prefetch.rs
+++ b/graphql/src/store/prefetch.rs
@@ -1,30 +1,35 @@
 //! Run a GraphQL query and fetch all the entitied needed to build the
 //! final result
 
+use graph::components::store::AggregationCurrent;
+use graph::data::graphql::ObjectTypeExt;
 use graph::data::query::Trace;
 use graph::data::store::Id;
 use graph::data::store::IdList;
 use graph::data::store::IdType;
 use graph::data::store::QueryObject;
 use graph::data::value::{Object, Word};
-use graph::prelude::{r, CacheWeight, CheapClone};
+use graph::prelude::{CacheWeight, CheapClone, r};
+use graph::schema::AggregationInterval;
+use graph::schema::Field;
 use graph::slog::warn;
 use graph::util::cache_weight;
 use std::collections::{BTreeMap, HashMap};
-use std::rc::Rc;
+use std::sync::Arc;
 use std::time::Instant;
 
-use graph::data::graphql::*;
+use graph::data::graphql::TypeExt;
 use graph::prelude::{
-    s, AttributeNames, ChildMultiplicity, EntityCollection, EntityFilter, EntityLink, EntityOrder,
-    EntityWindow, ParentLink, QueryExecutionError, Value as StoreValue, WindowAttribute, ENV_VARS,
+    AttributeNames, ChildMultiplicity, ENV_VARS, EntityCollection, EntityFilter, EntityLink,
+    EntityOrder, EntityWindow, ParentLink, QueryExecutionError, Value as StoreValue,
+    WindowAttribute,
 };
-use graph::schema::{ast as sast, EntityType, InputSchema};
+use graph::schema::{EntityType, InputSchema, ObjectOrInterface};
 
 use crate::execution::ast as a;
 use crate::metrics::GraphQLMetrics;
-use crate::store::query::build_query;
 use crate::store::StoreResolver;
+use crate::store::query::build_query;
 
 pub const ARG_ID: &str = "id";
 
@@ -85,7 +90,7 @@ struct Node {
     /// copies to the point where we need to convert to `q::Value`, and it
     /// would be desirable to base the data structure that GraphQL execution
     /// uses on a DAG rather than a tree, but that's a good amount of work
-    children: BTreeMap<Word, Vec<Rc<Node>>>,
+    children: BTreeMap<Word, Vec<Arc<Node>>>,
 }
 
 impl From<QueryObject> for Node {
@@ -107,11 +112,11 @@ impl CacheWeight for Node {
 
 /// Convert a list of nodes into a `q::Value::List` where each node has also
 /// been converted to a `q::Value`
-fn node_list_as_value(nodes: Vec<Rc<Node>>) -> r::Value {
+fn node_list_as_value(nodes: Vec<Arc<Node>>) -> r::Value {
     r::Value::List(
         nodes
             .into_iter()
-            .map(|node| Rc::try_unwrap(node).unwrap_or_else(|rc| rc.as_ref().clone()))
+            .map(|node| Arc::try_unwrap(node).unwrap_or_else(|arc| arc.as_ref().clone()))
             .map(Into::into)
             .collect(),
     )
@@ -207,9 +212,9 @@ impl Node {
             .expect("__typename must be a string")
     }
 
-    fn set_children(&mut self, response_key: String, nodes: Vec<Rc<Node>>) {
-        fn nodes_weight(nodes: &Vec<Rc<Node>>) -> usize {
-            let vec_weight = nodes.capacity() * std::mem::size_of::<Rc<Node>>();
+    fn set_children(&mut self, response_key: String, nodes: Vec<Arc<Node>>) {
+        fn nodes_weight(nodes: &Vec<Arc<Node>>) -> usize {
+            let vec_weight = nodes.capacity() * std::mem::size_of::<Arc<Node>>();
             let children_weight = nodes.iter().map(|node| node.weight()).sum::<usize>();
             vec_weight + children_weight
         }
@@ -228,15 +233,15 @@ impl Node {
 /// list is important for generating the right filter, and handling results
 /// correctly
 #[derive(Debug)]
-enum JoinField<'a> {
-    List(&'a str),
-    Scalar(&'a str),
+enum JoinField {
+    List(Word),
+    Scalar(Word),
 }
 
-impl<'a> JoinField<'a> {
-    fn new(field: &'a s::Field) -> Self {
-        let name = field.name.as_str();
-        if sast::is_list_or_non_null_list_field(field) {
+impl JoinField {
+    fn new(field: &Field) -> Self {
+        let name = field.name.clone();
+        if field.is_list() {
             JoinField::List(name)
         } else {
             JoinField::Scalar(name)
@@ -252,43 +257,39 @@ impl<'a> JoinField<'a> {
 }
 
 #[derive(Debug)]
-enum JoinRelation<'a> {
+enum JoinRelation {
     // Name of field in which child stores parent ids
-    Direct(JoinField<'a>),
+    Direct(JoinField),
     // Name of the field in the parent type containing child ids
-    Derived(JoinField<'a>),
+    Derived(JoinField),
 }
 
 #[derive(Debug)]
-struct JoinCond<'a> {
+struct JoinCond {
     /// The (concrete) object type of the parent, interfaces will have
     /// one `JoinCond` for each implementing type
     parent_type: EntityType,
     /// The (concrete) object type of the child, interfaces will have
     /// one `JoinCond` for each implementing type
     child_type: EntityType,
-    relation: JoinRelation<'a>,
+    relation: JoinRelation,
 }
 
-impl<'a> JoinCond<'a> {
+impl JoinCond {
     fn new(
         schema: &InputSchema,
-        parent_type: &'a s::ObjectType,
-        child_type: &'a s::ObjectType,
-        field_name: &str,
+        parent_type: EntityType,
+        child_type: EntityType,
+        field: &Field,
     ) -> Self {
-        let field = parent_type
-            .field(field_name)
-            .expect("field_name is a valid field of parent_type");
-        let relation =
-            if let Some(derived_from_field) = sast::get_derived_from_field(child_type, field) {
-                JoinRelation::Direct(JoinField::new(derived_from_field))
-            } else {
-                JoinRelation::Derived(JoinField::new(field))
-            };
+        let relation = if let Some(derived_from_field) = field.derived_from(schema) {
+            JoinRelation::Direct(JoinField::new(derived_from_field))
+        } else {
+            JoinRelation::Derived(JoinField::new(field))
+        };
         JoinCond {
-            parent_type: schema.entity_type(parent_type).unwrap(),
-            child_type: schema.entity_type(child_type).unwrap(),
+            parent_type,
+            child_type,
             relation,
         }
     }
@@ -302,7 +303,7 @@ impl<'a> JoinCond<'a> {
             JoinRelation::Direct(field) => {
                 // we only need the parent ids
                 let ids = IdList::try_from_iter(
-                    &self.parent_type,
+                    self.parent_type.id_type()?,
                     parents_by_id.into_iter().map(|(id, _)| id),
                 )?;
                 Ok((
@@ -324,9 +325,12 @@ impl<'a> JoinCond<'a> {
                                     .map(|child_id| (id, child_id.to_owned()))
                             })
                             .unzip();
-                        let ids = IdList::try_from_iter(&self.parent_type, ids.into_iter())?;
-                        let child_ids =
-                            IdList::try_from_iter(&self.child_type, child_ids.into_iter())?;
+                        let ids =
+                            IdList::try_from_iter(self.parent_type.id_type()?, ids.into_iter())?;
+                        let child_ids = IdList::try_from_iter(
+                            self.child_type.id_type()?,
+                            child_ids.into_iter(),
+                        )?;
                         (ids, ParentLink::Scalar(child_ids))
                     }
                     JoinField::List(child_field) => {
@@ -355,10 +359,13 @@ impl<'a> JoinCond<'a> {
                                     .map(|child_ids| (id, child_ids))
                             })
                             .unzip();
-                        let ids = IdList::try_from_iter(&self.parent_type, ids.into_iter())?;
+                        let ids =
+                            IdList::try_from_iter(self.parent_type.id_type()?, ids.into_iter())?;
                         let child_ids = child_ids
                             .into_iter()
-                            .map(|ids| IdList::try_from_iter(&self.child_type, ids.into_iter()))
+                            .map(|ids| {
+                                IdList::try_from_iter(self.child_type.id_type()?, ids.into_iter())
+                            })
                             .collect::<Result<Vec<_>, _>>()?;
                         (ids, ParentLink::List(child_ids))
                     }
@@ -378,24 +385,22 @@ impl<'a> JoinCond<'a> {
 struct Join<'a> {
     /// The object type of the child entities
     child_type: ObjectOrInterface<'a>,
-    conds: Vec<JoinCond<'a>>,
+    conds: Vec<JoinCond>,
 }
 
 impl<'a> Join<'a> {
     /// Construct a `Join` based on the parent field pointing to the child
     fn new(
         schema: &'a InputSchema,
-        parent_type: &'a s::ObjectType,
+        parent_type: EntityType,
         child_type: ObjectOrInterface<'a>,
-        field_name: &str,
+        field: &Field,
     ) -> Self {
-        let child_types = child_type
-            .object_types(schema.schema())
-            .expect("the name of the child type is valid");
+        let child_types = child_type.object_types();
 
         let conds = child_types
-            .iter()
-            .map(|child_type| JoinCond::new(schema, parent_type, child_type, field_name))
+            .into_iter()
+            .map(|child_type| JoinCond::new(schema, parent_type.cheap_clone(), child_type, field))
             .collect();
 
         Join { child_type, conds }
@@ -413,7 +418,7 @@ impl<'a> Join<'a> {
         for cond in &self.conds {
             let mut parents_by_id = parents
                 .iter()
-                .filter(|parent| parent.typename() == cond.parent_type.as_str())
+                .filter(|parent| parent.typename() == cond.parent_type.typename())
                 .filter_map(|parent| parent.id(schema).ok().map(|id| (id, &**parent)))
                 .collect::<Vec<_>>();
 
@@ -451,13 +456,13 @@ enum MaybeJoin<'a> {
 }
 
 impl<'a> MaybeJoin<'a> {
-    fn child_type(&self) -> ObjectOrInterface<'_> {
+    fn child_type(&self) -> &ObjectOrInterface<'_> {
         match self {
-            MaybeJoin::Root { child_type } => child_type.clone(),
+            MaybeJoin::Root { child_type } => child_type,
             MaybeJoin::Nested(Join {
                 child_type,
                 conds: _,
-            }) => child_type.clone(),
+            }) => child_type,
         }
     }
 }
@@ -479,7 +484,7 @@ fn add_children(
     children: Vec<Node>,
     response_key: &str,
 ) -> Result<(), QueryExecutionError> {
-    let children: Vec<_> = children.into_iter().map(Rc::new).collect();
+    let children: Vec<_> = children.into_iter().map(Arc::new).collect();
 
     if parents.len() == 1 {
         let parent = parents.first_mut().expect("we just checked");
@@ -491,7 +496,7 @@ fn add_children(
     // children to their parent. This relies on the fact that interfaces
     // make sure that id's are distinct across all implementations of the
     // interface.
-    let mut grouped: HashMap<&Id, Vec<Rc<Node>>> = HashMap::default();
+    let mut grouped: HashMap<&Id, Vec<Arc<Node>>> = HashMap::default();
     for child in children.iter() {
         let parent = child.parent.as_ref().ok_or_else(|| {
             QueryExecutionError::Panic(format!(
@@ -542,7 +547,7 @@ fn add_children(
 /// cases where the store contains data that violates the data model by having
 /// multiple values for what should be a relationship to a single object in
 /// @derivedFrom fields
-pub fn run(
+pub async fn run(
     resolver: &StoreResolver,
     ctx: &ExecutionContext,
     selection_set: &a::SelectionSet,
@@ -550,16 +555,12 @@ pub fn run(
 ) -> Result<(r::Value, Trace), Vec<QueryExecutionError>> {
     let loader = Loader::new(resolver, ctx);
 
-    let trace = Trace::root(
-        &ctx.query.query_text,
-        &ctx.query.variables_text,
-        &ctx.query.query_id,
-        resolver.block_number(),
-        ctx.trace,
-    );
+    let trace = Trace::block(resolver.block_number(), ctx.trace);
 
-    // Execute the root selection set against the root query type
-    let (nodes, trace) = loader.execute_selection_set(make_root_node(), trace, selection_set)?;
+    // Execute the root selection set against the root query type.
+    let (nodes, trace) = loader
+        .execute_selection_set(make_root_node(), trace, selection_set, None)
+        .await?;
 
     graphql_metrics.observe_query_result_size(nodes.weight());
     let obj = Object::from_iter(nodes.into_iter().flat_map(|node| {
@@ -584,24 +585,24 @@ impl<'a> Loader<'a> {
         Loader { resolver, ctx }
     }
 
-    fn execute_selection_set(
+    async fn execute_selection_set(
         &self,
         mut parents: Vec<Node>,
         mut parent_trace: Trace,
         selection_set: &a::SelectionSet,
+        parent_interval: Option<AggregationInterval>,
     ) -> Result<(Vec<Node>, Trace), Vec<QueryExecutionError>> {
-        let schema = &self.ctx.query.schema;
-        let input_schema = self.resolver.store.input_schema()?;
+        let input_schema = self.resolver.store.input_schema().await?;
         let mut errors: Vec<QueryExecutionError> = Vec::new();
         let at_root = is_root_node(parents.iter());
 
         // Process all field groups in order
         for (object_type, fields) in selection_set.interior_fields() {
-            if let Some(deadline) = self.ctx.deadline {
-                if deadline < Instant::now() {
-                    errors.push(QueryExecutionError::Timeout);
-                    break;
-                }
+            if let Some(deadline) = self.ctx.deadline
+                && deadline < Instant::now()
+            {
+                errors.push(QueryExecutionError::Timeout);
+                break;
             }
 
             // Filter out parents that do not match the type condition.
@@ -619,27 +620,53 @@ impl<'a> Loader<'a> {
             }
 
             for field in fields {
+                let child_interval = field.aggregation_interval()?;
                 let field_type = object_type
                     .field(&field.name)
                     .expect("field names are valid");
-                let child_type = schema
-                    .object_or_interface(field_type.field_type.get_base_type())
+                let child_type = input_schema
+                    .object_or_interface(field_type.field_type.get_base_type(), child_interval)
                     .expect("we only collect fields that are objects or interfaces");
+                let aggregation_current = field.aggregation_current()?;
 
                 let join = if at_root {
                     MaybeJoin::Root { child_type }
                 } else {
+                    let object_type = input_schema
+                        .object_or_aggregation(&object_type.name, parent_interval)
+                        .ok_or_else(|| {
+                            vec![QueryExecutionError::InternalError(format!(
+                                "the type `{}`(interval {}) is not an object type",
+                                object_type.name,
+                                parent_interval
+                                    .map(|intv| intv.as_str())
+                                    .unwrap_or("<none>")
+                            ))]
+                        })?;
+                    let field_type = object_type
+                        .field(&field.name)
+                        .expect("field names are valid");
+
                     MaybeJoin::Nested(Join::new(
                         &input_schema,
-                        object_type,
+                        object_type.cheap_clone(),
                         child_type,
-                        &field.name,
+                        field_type,
                     ))
                 };
 
-                match self.fetch(&parents, &join, field) {
+                match self
+                    .fetch(&parents, &join, field, aggregation_current)
+                    .await
+                {
                     Ok((children, trace)) => {
-                        match self.execute_selection_set(children, trace, &field.selection_set) {
+                        let exec_fut = Box::pin(self.execute_selection_set(
+                            children,
+                            trace,
+                            &field.selection_set,
+                            child_interval,
+                        ));
+                        match exec_fut.await {
                             Ok((children, trace)) => {
                                 add_children(
                                     &input_schema,
@@ -670,24 +697,22 @@ impl<'a> Loader<'a> {
     /// Query child entities for `parents` from the store. The `join` indicates
     /// in which child field to look for the parent's id/join field. When
     /// `is_single` is `true`, there is at most one child per parent.
-    fn fetch(
+    async fn fetch(
         &self,
         parents: &[&mut Node],
         join: &MaybeJoin<'_>,
         field: &a::Field,
+        aggregation_current: Option<AggregationCurrent>,
     ) -> Result<(Vec<Node>, Trace), QueryExecutionError> {
-        let input_schema = self.resolver.store.input_schema()?;
+        let input_schema = self.resolver.store.input_schema().await?;
+        let child_type = join.child_type();
         let mut query = build_query(
-            join.child_type(),
+            child_type,
             self.resolver.block_number(),
             field,
-            self.ctx.query.schema.types_for_interface(),
             self.ctx.max_first,
             self.ctx.max_skip,
-            &super::query::SchemaPair {
-                api: self.ctx.query.schema.clone(),
-                input: input_schema.cheap_clone(),
-            },
+            &input_schema,
         )?;
         query.trace = self.ctx.trace;
         query.query_id = Some(self.ctx.query.query_id.clone());
@@ -697,7 +722,6 @@ impl<'a> Loader<'a> {
             // that causes unnecessary work in the database
             query.order = EntityOrder::Unordered;
         }
-
         query.logger = Some(self.ctx.logger.cheap_clone());
         if let Some(r::Value::String(id)) = field.argument_value(ARG_ID) {
             query.filter = Some(
@@ -706,6 +730,10 @@ impl<'a> Loader<'a> {
             );
         }
 
+        if child_type.is_aggregation() {
+            query.aggregation_current = Some(aggregation_current.unwrap_or_default());
+        }
+
         if let MaybeJoin::Nested(join) = join {
             // For anything but the root node, restrict the children we select
             // by the parent list
@@ -723,6 +751,7 @@ impl<'a> Loader<'a> {
         self.resolver
             .store
             .find_query_values(query)
+            .await
             .map(|(values, trace)| (values.into_iter().map(Node::from).collect(), trace))
     }
 
diff --git a/graphql/src/store/query.rs b/graphql/src/store/query.rs
index 23d62020097..f893663b258 100644
--- a/graphql/src/store/query.rs
+++ b/graphql/src/store/query.rs
@@ -1,14 +1,19 @@
-use std::collections::{BTreeMap, BTreeSet, HashSet, VecDeque};
 use std::mem::discriminant;
 
-use graph::data::graphql::ext::DirectiveFinder;
-use graph::data::graphql::ObjectOrInterface;
+use graph::cheap_clone::CheapClone;
+use graph::components::store::{
+    BlockNumber, Child, EntityCollection, EntityFilter, EntityOrder, EntityOrderByChild,
+    EntityOrderByChildInfo, EntityQuery, EntityRange,
+};
 use graph::data::graphql::TypeExt as _;
+use graph::data::query::QueryExecutionError;
+use graph::data::store::{Attribute, Value, ValueType};
 use graph::data::value::Object;
 use graph::data::value::Value as DataValue;
-use graph::prelude::*;
+use graph::prelude::{ENV_VARS, TryFromValue, r};
 use graph::schema::ast::{self as sast, FilterOp};
-use graph::schema::{ApiSchema, EntityType, InputSchema};
+use graph::schema::kw;
+use graph::schema::{EntityType, InputSchema, ObjectOrInterface};
 
 use crate::execution::ast as a;
 
@@ -18,114 +23,32 @@ enum OrderDirection {
     Descending,
 }
 
-pub(crate) struct SchemaPair {
-    pub api: Arc<ApiSchema>,
-    pub input: InputSchema,
-}
-
 /// Builds a EntityQuery from GraphQL arguments.
 ///
 /// Panics if `entity` is not present in `schema`.
 pub(crate) fn build_query<'a>(
-    entity: impl Into<ObjectOrInterface<'a>>,
+    entity: &ObjectOrInterface<'a>,
     block: BlockNumber,
     field: &a::Field,
-    types_for_interface: &'a BTreeMap<String, Vec<s::ObjectType>>,
     max_first: u32,
     max_skip: u32,
-    schema: &SchemaPair,
+    schema: &InputSchema,
 ) -> Result<EntityQuery, QueryExecutionError> {
-    let entity = entity.into();
-    let entity_types = EntityCollection::All(match &entity {
-        ObjectOrInterface::Object(object) => {
-            let selected_columns = field.selected_attrs(object)?;
-            let entity_type = schema.input.entity_type(*object).unwrap();
-            vec![(entity_type, selected_columns)]
-        }
-        ObjectOrInterface::Interface(interface) => types_for_interface[&interface.name]
-            .iter()
-            .map(|o| {
-                let selected_columns = field.selected_attrs(o);
-                let entity_type = schema.input.entity_type(o).unwrap();
-                selected_columns.map(|selected_columns| (entity_type, selected_columns))
-            })
-            .collect::<Result<_, _>>()?,
-    });
-    let mut query = EntityQuery::new(parse_subgraph_id(entity)?, block, entity_types)
+    let order = build_order(entity, field, schema)?;
+    let object_types = entity
+        .object_types()
+        .into_iter()
+        .map(|entity_type| {
+            let selected_columns = field.selected_attrs(&entity_type, &order);
+            selected_columns.map(|selected_columns| (entity_type, selected_columns))
+        })
+        .collect::<Result<_, _>>()?;
+    let entity_types = EntityCollection::All(object_types);
+    let mut query = EntityQuery::new(schema.id().cheap_clone(), block, entity_types)
         .range(build_range(field, max_first, max_skip)?);
     if let Some(filter) = build_filter(entity, field, schema)? {
         query = query.filter(filter);
     }
-    let order = match (
-        build_order_by(entity, field, schema)?,
-        build_order_direction(field)?,
-    ) {
-        (Some((attr, value_type, None)), OrderDirection::Ascending) => {
-            EntityOrder::Ascending(attr, value_type)
-        }
-        (Some((attr, value_type, None)), OrderDirection::Descending) => {
-            EntityOrder::Descending(attr, value_type)
-        }
-        (Some((attr, _, Some(child))), OrderDirection::Ascending) => {
-            if ENV_VARS.graphql.disable_child_sorting {
-                return Err(QueryExecutionError::NotSupported(
-                    "Sorting by child attributes is not supported".to_string(),
-                ));
-            }
-            match child {
-                OrderByChild::Object(child) => {
-                    EntityOrder::ChildAscending(EntityOrderByChild::Object(
-                        EntityOrderByChildInfo {
-                            sort_by_attribute: attr,
-                            join_attribute: child.join_attribute,
-                            derived: child.derived,
-                        },
-                        child.entity_type,
-                    ))
-                }
-                OrderByChild::Interface(child) => {
-                    EntityOrder::ChildAscending(EntityOrderByChild::Interface(
-                        EntityOrderByChildInfo {
-                            sort_by_attribute: attr,
-                            join_attribute: child.join_attribute,
-                            derived: child.derived,
-                        },
-                        child.entity_types,
-                    ))
-                }
-            }
-        }
-        (Some((attr, _, Some(child))), OrderDirection::Descending) => {
-            if ENV_VARS.graphql.disable_child_sorting {
-                return Err(QueryExecutionError::NotSupported(
-                    "Sorting by child attributes is not supported".to_string(),
-                ));
-            }
-            match child {
-                OrderByChild::Object(child) => {
-                    EntityOrder::ChildDescending(EntityOrderByChild::Object(
-                        EntityOrderByChildInfo {
-                            sort_by_attribute: attr,
-                            join_attribute: child.join_attribute,
-                            derived: child.derived,
-                        },
-                        child.entity_type,
-                    ))
-                }
-                OrderByChild::Interface(child) => {
-                    EntityOrder::ChildDescending(EntityOrderByChild::Interface(
-                        EntityOrderByChildInfo {
-                            sort_by_attribute: attr,
-                            join_attribute: child.join_attribute,
-                            derived: child.derived,
-                        },
-                        child.entity_types,
-                    ))
-                }
-            }
-        }
-        (None, _) => EntityOrder::Default,
-    };
     query = query.order(order);
     Ok(query)
 }
@@ -174,9 +97,9 @@ fn build_range(
 
 /// Parses GraphQL arguments into an EntityFilter, if present.
 fn build_filter(
-    entity: ObjectOrInterface,
+    entity: &ObjectOrInterface,
     field: &a::Field,
-    schema: &SchemaPair,
+    schema: &InputSchema,
 ) -> Result<Option<EntityFilter>, QueryExecutionError> {
     let where_filter = match field.argument_value("where") {
         Some(r::Value::Object(object)) => match build_filter_from_object(entity, object, schema) {
@@ -271,8 +194,8 @@ fn build_entity_filter(
 
 /// Iterate over the list and generate an EntityFilter from it
 fn build_list_filter_from_value(
-    entity: ObjectOrInterface,
-    schema: &SchemaPair,
+    entity: &ObjectOrInterface,
+    schema: &InputSchema,
     value: &r::Value,
 ) -> Result<Vec<EntityFilter>, QueryExecutionError> {
     // We have object like this
@@ -297,10 +220,10 @@ fn build_list_filter_from_value(
 }
 
 /// build a filter which has list of nested filters
-fn build_list_filter_from_object<'a>(
-    entity: ObjectOrInterface,
+fn build_list_filter_from_object(
+    entity: &ObjectOrInterface,
     object: &Object,
-    schema: &SchemaPair,
+    schema: &InputSchema,
 ) -> Result<Vec<EntityFilter>, QueryExecutionError> {
     Ok(object
         .iter()
@@ -313,11 +236,37 @@ fn build_list_filter_from_object<'a>(
 }
 
 /// Parses a GraphQL input object into an EntityFilter, if present.
-fn build_filter_from_object<'a>(
-    entity: ObjectOrInterface,
+fn build_filter_from_object(
+    entity: &ObjectOrInterface,
     object: &Object,
-    schema: &SchemaPair,
+    schema: &InputSchema,
 ) -> Result<Vec<EntityFilter>, QueryExecutionError> {
+    // Check if we have both column filters and 'or' operator at the same level
+    if object.get("or").is_some() {
+        let column_filters: Vec<String> = object
+            .iter()
+            .filter_map(|(key, _)| {
+                if key != "or" && key != "and" && key != "_change_block" {
+                    Some(format!("'{}'", key))
+                } else {
+                    None
+                }
+            })
+            .collect();
+
+        if !column_filters.is_empty() {
+            let filter_list = column_filters.join(", ");
+            let example = format!(
+                "Instead of:\nwhere: {{ {}, or: [...] }}\n\nUse:\nwhere: {{ or: [{{ {}, ... }}, {{ {}, ... }}] }}",
+                filter_list, filter_list, filter_list
+            );
+            return Err(QueryExecutionError::InvalidOrFilterStructure(
+                column_filters,
+                example,
+            ));
+        }
+    }
+
     object
         .iter()
         .map(|(key, value)| {
@@ -360,9 +309,9 @@ fn build_filter_from_object<'a>(
                         build_child_filter_from_object(entity, field_name, obj, schema)?
                     }
                     _ => {
-                        let field = sast::get_field(entity, &field_name).ok_or_else(|| {
+                        let field = entity.field(&field_name).ok_or_else(|| {
                             QueryExecutionError::EntityFieldError(
-                                entity.name().to_owned(),
+                                entity.typename().to_owned(),
                                 field_name.clone(),
                             )
                         })?;
@@ -374,9 +323,9 @@ fn build_filter_from_object<'a>(
                     }
                 },
                 _ => {
-                    let field = sast::get_field(entity, &field_name).ok_or_else(|| {
+                    let field = entity.field(&field_name).ok_or_else(|| {
                         QueryExecutionError::EntityFieldError(
-                            entity.name().to_owned(),
+                            entity.typename().to_owned(),
                             field_name.clone(),
                         )
                     })?;
@@ -390,81 +339,63 @@ fn build_filter_from_object<'a>(
 }
 
 fn build_child_filter_from_object(
-    entity: ObjectOrInterface,
+    entity: &ObjectOrInterface,
     field_name: String,
     object: &Object,
-    schema: &SchemaPair,
+    schema: &InputSchema,
 ) -> Result<EntityFilter, QueryExecutionError> {
     let field = entity
         .field(&field_name)
         .ok_or(QueryExecutionError::InvalidFilterError)?;
     let type_name = &field.field_type.get_base_type();
     let child_entity = schema
-        .api
-        .object_or_interface(type_name)
+        .object_or_interface(type_name, None)
         .ok_or(QueryExecutionError::InvalidFilterError)?;
-    let child_entity_type = schema.input.entity_type(child_entity)?;
     let filter = Box::new(EntityFilter::And(build_filter_from_object(
-        child_entity,
+        &child_entity,
         object,
         schema,
     )?));
     let derived = field.is_derived();
-    let attr = match derived {
-        true => sast::get_derived_from_field(child_entity, field)
-            .ok_or(QueryExecutionError::InvalidFilterError)?
-            .name
-            .to_string(),
-        false => field_name.clone(),
+    let attr = match field.derived_from(schema) {
+        Some(field) => field.name.to_string(),
+        None => field_name.clone(),
     };
 
     if child_entity.is_interface() {
         Ok(EntityFilter::Or(
             child_entity
-                .object_types(schema.api.schema())
-                .ok_or(QueryExecutionError::AbstractTypeError(
-                    "Interface is not implemented by any types".to_string(),
-                ))?
-                .iter()
-                .map(|object_type| {
-                    schema.input.entity_type(*object_type).map(|entity_type| {
-                        EntityFilter::Child(Child {
-                            attr: attr.clone(),
-                            entity_type,
-                            filter: filter.clone(),
-                            derived,
-                        })
+                .object_types()
+                .into_iter()
+                .map(|entity_type| {
+                    EntityFilter::Child(Child {
+                        attr: attr.clone(),
+                        entity_type,
+                        filter: filter.clone(),
+                        derived,
                     })
                 })
-                .collect::<Result<_, _>>()?,
+                .collect(),
         ))
     } else if entity.is_interface() {
         Ok(EntityFilter::Or(
             entity
-                .object_types(schema.api.schema())
-                .ok_or(QueryExecutionError::AbstractTypeError(
-                    "Interface is not implemented by any types".to_string(),
-                ))?
-                .iter()
-                .map(|object_type| {
-                    let field = object_type
-                        .fields
-                        .iter()
-                        .find(|f| f.name == field_name.clone())
+                .object_types()
+                .into_iter()
+                .map(|entity_type| {
+                    let field = entity_type
+                        .field(&field_name)
                         .ok_or(QueryExecutionError::InvalidFilterError)?;
                     let derived = field.is_derived();
 
-                    let attr = match derived {
-                        true => sast::get_derived_from_field(child_entity, field)
-                            .ok_or(QueryExecutionError::InvalidFilterError)?
-                            .name
-                            .to_string(),
-                        false => field_name.clone(),
+                    let attr = match field.derived_from(schema) {
+                        Some(derived_from) => derived_from.name.to_string(),
+                        None => field_name.clone(),
                     };
 
                     Ok(EntityFilter::Child(Child {
                         attr,
-                        entity_type: child_entity_type.clone(),
+                        entity_type: child_entity.entity_type(),
                         filter: filter.clone(),
                         derived,
                     }))
@@ -474,7 +405,7 @@ fn build_child_filter_from_object(
     } else {
         Ok(EntityFilter::Child(Child {
             attr,
-            entity_type: schema.input.entity_type(*type_name)?,
+            entity_type: schema.entity_type(*type_name)?,
             filter,
             derived,
         }))
@@ -484,25 +415,22 @@ fn build_child_filter_from_object(
 /// Parses a list of GraphQL values into a vector of entity field values.
 fn list_values(value: Value, filter_type: &str) -> Result<Vec<Value>, QueryExecutionError> {
     match value {
-        Value::List(ref values) if !values.is_empty() => {
+        Value::List(values) => {
+            if values.is_empty() {
+                return Ok(values);
+            }
             // Check that all values in list are of the same type
             let root_discriminant = discriminant(&values[0]);
-            values
-                .iter()
-                .map(|value| {
-                    let current_discriminant = discriminant(value);
-                    if root_discriminant == current_discriminant {
-                        Ok(value.clone())
-                    } else {
-                        Err(QueryExecutionError::ListTypesError(
-                            filter_type.to_string(),
-                            vec![values[0].to_string(), value.to_string()],
-                        ))
-                    }
-                })
-                .collect::<Result<Vec<_>, _>>()
+            for value in &values {
+                if root_discriminant != discriminant(value) {
+                    return Err(QueryExecutionError::ListTypesError(
+                        filter_type.to_string(),
+                        vec![values[0].to_string(), value.to_string()],
+                    ));
+                }
+            }
+            Ok(values)
         }
-        Value::List(ref values) if values.is_empty() => Ok(vec![]),
         _ => Err(QueryExecutionError::ListFilterError(
             filter_type.to_string(),
         )),
@@ -530,131 +458,177 @@ fn parse_order_by(enum_value: &String) -> Result<OrderByValue, QueryExecutionErr
     })
 }
 
+#[derive(Debug)]
 struct ObjectOrderDetails {
     entity_type: EntityType,
     join_attribute: Attribute,
     derived: bool,
 }
 
+#[derive(Debug)]
 struct InterfaceOrderDetails {
     entity_types: Vec<EntityType>,
     join_attribute: Attribute,
     derived: bool,
 }
 
+#[derive(Debug)]
 enum OrderByChild {
     Object(ObjectOrderDetails),
     Interface(InterfaceOrderDetails),
 }
 
+fn build_order(
+    entity: &ObjectOrInterface<'_>,
+    field: &a::Field,
+    schema: &InputSchema,
+) -> Result<EntityOrder, QueryExecutionError> {
+    let order = match (
+        build_order_by(entity, field, schema)?,
+        build_order_direction(field)?,
+    ) {
+        (Some((attr, value_type, None)), OrderDirection::Ascending) => {
+            EntityOrder::Ascending(attr, value_type)
+        }
+        (Some((attr, value_type, None)), OrderDirection::Descending) => {
+            EntityOrder::Descending(attr, value_type)
+        }
+        (Some((attr, _, Some(child))), OrderDirection::Ascending) => {
+            if ENV_VARS.graphql.disable_child_sorting {
+                return Err(QueryExecutionError::NotSupported(
+                    "Sorting by child attributes is not supported".to_string(),
+                ));
+            }
+            match child {
+                OrderByChild::Object(child) => {
+                    EntityOrder::ChildAscending(EntityOrderByChild::Object(
+                        EntityOrderByChildInfo {
+                            sort_by_attribute: attr,
+                            join_attribute: child.join_attribute,
+                            derived: child.derived,
+                        },
+                        child.entity_type,
+                    ))
+                }
+                OrderByChild::Interface(child) => {
+                    EntityOrder::ChildAscending(EntityOrderByChild::Interface(
+                        EntityOrderByChildInfo {
+                            sort_by_attribute: attr,
+                            join_attribute: child.join_attribute,
+                            derived: child.derived,
+                        },
+                        child.entity_types,
+                    ))
+                }
+            }
+        }
+        (Some((attr, _, Some(child))), OrderDirection::Descending) => {
+            if ENV_VARS.graphql.disable_child_sorting {
+                return Err(QueryExecutionError::NotSupported(
+                    "Sorting by child attributes is not supported".to_string(),
+                ));
+            }
+            match child {
+                OrderByChild::Object(child) => {
+                    EntityOrder::ChildDescending(EntityOrderByChild::Object(
+                        EntityOrderByChildInfo {
+                            sort_by_attribute: attr,
+                            join_attribute: child.join_attribute,
+                            derived: child.derived,
+                        },
+                        child.entity_type,
+                    ))
+                }
+                OrderByChild::Interface(child) => {
+                    EntityOrder::ChildDescending(EntityOrderByChild::Interface(
+                        EntityOrderByChildInfo {
+                            sort_by_attribute: attr,
+                            join_attribute: child.join_attribute,
+                            derived: child.derived,
+                        },
+                        child.entity_types,
+                    ))
+                }
+            }
+        }
+        // Apply a default ordering to the aggregations so that the most recent buckets are returned first
+        (None, _) if entity.is_aggregation() => {
+            let ts = entity
+                .field(kw::TIMESTAMP)
+                .expect("aggregation entities have timestamps");
+
+            EntityOrder::Descending(ts.name.to_string(), ts.value_type)
+        }
+        (None, _) => EntityOrder::Default,
+    };
+    Ok(order)
+}
+
 /// Parses GraphQL arguments into an field name to order by, if present.
 fn build_order_by(
-    entity: ObjectOrInterface,
+    entity: &ObjectOrInterface,
     field: &a::Field,
-    schema: &SchemaPair,
+    schema: &InputSchema,
 ) -> Result<Option<(String, ValueType, Option<OrderByChild>)>, QueryExecutionError> {
     match field.argument_value("orderBy") {
         Some(r::Value::Enum(name)) => match parse_order_by(name)? {
             OrderByValue::Direct(name) => {
-                let field = sast::get_field(entity, name.as_str()).ok_or_else(|| {
-                    QueryExecutionError::EntityFieldError(entity.name().to_owned(), name.clone())
+                let field = entity.field(&name).ok_or_else(|| {
+                    QueryExecutionError::EntityFieldError(
+                        entity.typename().to_owned(),
+                        name.clone(),
+                    )
                 })?;
                 sast::get_field_value_type(&field.field_type)
                     .map(|value_type| Some((name.clone(), value_type, None)))
                     .map_err(|_| {
                         QueryExecutionError::OrderByNotSupportedError(
-                            entity.name().to_owned(),
+                            entity.typename().to_owned(),
                             name.clone(),
                         )
                     })
             }
             OrderByValue::Child(parent_field_name, child_field_name) => {
-                // Finds the field that connects the parent entity with the child entity.
-                // In the case of an interface, we need to find the field on one of the types that implement the interface,
-                // as the `@derivedFrom` directive is only allowed on object types.
-                let field = match entity {
-                    ObjectOrInterface::Object(_) => {
-                        sast::get_field(entity, parent_field_name.as_str()).ok_or_else(|| {
-                            QueryExecutionError::EntityFieldError(
-                                entity.name().to_owned(),
-                                parent_field_name.clone(),
-                            )
-                        })?
-                    }
-                    ObjectOrInterface::Interface(_) => {
-                        let object_types =
-                            schema.api.types_for_interface().get(entity.name()).ok_or(
-                                QueryExecutionError::EntityFieldError(
-                                    entity.name().to_owned(),
-                                    parent_field_name.clone(),
-                                ),
-                            )?;
-
-                        if let Some(first_entity) = object_types.first() {
-                            sast::get_field(first_entity, parent_field_name.as_str()).ok_or_else(
-                                || {
-                                    QueryExecutionError::EntityFieldError(
-                                        entity.name().to_owned(),
-                                        parent_field_name.clone(),
-                                    )
-                                },
-                            )?
-                        } else {
-                            Err(QueryExecutionError::EntityFieldError(
-                                entity.name().to_owned(),
-                                parent_field_name.clone(),
-                            ))?
-                        }
-                    }
-                };
-                let derived = field.is_derived();
-                let base_type = field.field_type.get_base_type();
-
-                let child_entity = schema
-                    .api
-                    .object_or_interface(base_type)
-                    .ok_or_else(|| QueryExecutionError::NamedTypeError(base_type.into()))?;
-                let child_field = sast::get_field(child_entity, child_field_name.as_str())
+                // Finds the field that connects the parent entity with the
+                // child entity. Note that `@derivedFrom` is only allowed on
+                // object types.
+                let field = entity
+                    .implemented_field(&parent_field_name)
                     .ok_or_else(|| {
                         QueryExecutionError::EntityFieldError(
-                            child_entity.name().to_owned(),
-                            child_field_name.clone(),
+                            entity.typename().to_owned(),
+                            parent_field_name.clone(),
                         )
                     })?;
+                let derived_from = field.derived_from(schema);
+                let base_type = field.field_type.get_base_type();
 
-                let join_attribute = match derived {
-                    true => sast::get_derived_from_field(child_entity, field)
+                let child_entity = schema
+                    .object_or_interface(base_type, None)
+                    .ok_or_else(|| QueryExecutionError::NamedTypeError(base_type.into()))?;
+                let child_field =
+                    child_entity
+                        .field(child_field_name.as_str())
                         .ok_or_else(|| {
                             QueryExecutionError::EntityFieldError(
-                                entity.name().to_string(),
-                                field.name.to_string(),
+                                child_entity.typename().to_owned(),
+                                child_field_name.clone(),
                             )
-                        })?
-                        .name
-                        .to_string(),
-                    false => parent_field_name,
+                        })?;
+
+                let (join_attribute, derived) = match derived_from {
+                    Some(child_field) => (child_field.name.to_string(), true),
+                    None => (parent_field_name, false),
                 };
 
                 let child = match child_entity {
-                    ObjectOrInterface::Object(_) => OrderByChild::Object(ObjectOrderDetails {
-                        entity_type: schema.input.entity_type(base_type)?,
+                    ObjectOrInterface::Object(_, _) => OrderByChild::Object(ObjectOrderDetails {
+                        entity_type: schema.entity_type(base_type)?,
                         join_attribute,
                         derived,
                     }),
-                    ObjectOrInterface::Interface(interface) => {
-                        let entity_types = schema
-                            .api
-                            .types_for_interface()
-                            .get(&interface.name)
-                            .map(|object_types| {
-                                object_types
-                                    .iter()
-                                    .map(|object_type| schema.input.entity_type(object_type))
-                                    .collect::<Result<Vec<EntityType>, _>>()
-                            })
-                            .ok_or(QueryExecutionError::AbstractTypeError(
-                                "Interface not implemented by any object type".to_string(),
-                            ))??;
+                    ObjectOrInterface::Interface(_, _) => {
+                        let entity_types = child_entity.object_types();
                         OrderByChild::Interface(InterfaceOrderDetails {
                             entity_types,
                             join_attribute,
@@ -667,7 +641,7 @@ fn build_order_by(
                     .map(|value_type| Some((child_field_name.clone(), value_type, Some(child))))
                     .map_err(|_| {
                         QueryExecutionError::OrderByNotSupportedError(
-                            child_entity.name().to_owned(),
+                            child_entity.typename().to_owned(),
                             child_field_name.clone(),
                         )
                     })
@@ -709,100 +683,78 @@ fn build_order_direction(field: &a::Field) -> Result<OrderDirection, QueryExecut
         .unwrap_or(OrderDirection::Ascending))
 }
 
-/// Parses the subgraph ID from the ObjectType directives.
-pub fn parse_subgraph_id<'a>(
-    entity: impl Into<ObjectOrInterface<'a>>,
-) -> Result<DeploymentHash, QueryExecutionError> {
-    let entity = entity.into();
-    let entity_name = entity.name();
-    entity
-        .directives()
-        .iter()
-        .find(|directive| directive.name == "subgraphId")
-        .and_then(|directive| directive.arguments.iter().find(|(name, _)| name == "id"))
-        .and_then(|(_, value)| match value {
-            s::Value::String(id) => Some(id),
-            _ => None,
-        })
-        .ok_or(())
-        .and_then(|id| DeploymentHash::new(id).map_err(|_| ()))
-        .map_err(|_| QueryExecutionError::SubgraphDeploymentIdError(entity_name.to_owned()))
-}
-
-/// Recursively collects entities involved in a query field as `(subgraph ID, name)` tuples.
-pub(crate) fn collect_entities_from_query_field(
-    input_schema: &InputSchema,
-    schema: &ApiSchema,
-    object_type: sast::ObjectType,
-    field: &a::Field,
-) -> Result<BTreeSet<SubscriptionFilter>, QueryExecutionError> {
-    // Output entities
-    let mut entities = HashSet::new();
-
-    // List of objects/fields to visit next
-    let mut queue = VecDeque::new();
-    queue.push_back((object_type, field));
-
-    while let Some((object_type, field)) = queue.pop_front() {
-        // Check if the field exists on the object type
-        if let Some(field_type) = sast::get_field(&object_type, &field.name) {
-            // Check if the field type corresponds to a type definition (in a valid schema,
-            // this should always be the case)
-            if let Some(type_definition) = schema.get_type_definition_from_field(field_type) {
-                // If the field's type definition is an object type, extract that type
-                if let s::TypeDefinition::Object(object_type) = type_definition {
-                    // Only collect whether the field's type has an @entity directive
-                    if sast::get_object_type_directive(object_type, String::from("entity"))
-                        .is_some()
-                    {
-                        // Obtain the subgraph ID from the object type
-                        if let Ok(subgraph_id) = parse_subgraph_id(object_type) {
-                            // Add the (subgraph_id, entity_name) tuple to the result set
-                            entities.insert((subgraph_id, object_type.name.clone()));
-                        }
-                    }
-
-                    // If the query field has a non-empty selection set, this means we
-                    // need to recursively process it
-                    let object_type = schema.object_type(object_type).into();
-                    for sub_field in field.selection_set.fields_for(&object_type)? {
-                        queue.push_back((object_type.cheap_clone(), sub_field))
-                    }
-                }
-            }
-        }
-    }
-
-    entities
-        .into_iter()
-        .map(|(id, entity_type)| {
-            input_schema
-                .entity_type(&entity_type)
-                .map(|entity_type| SubscriptionFilter::Entities(id, entity_type))
-        })
-        .collect::<Result<_, _>>()
-        .map_err(Into::into)
-}
-
 #[cfg(test)]
 mod tests {
+    use graph::components::store::EntityQuery;
+    use graph::data::store::ID;
+    use graph::env::ENV_VARS;
     use graph::{
         components::store::ChildMultiplicity,
         data::value::Object,
+        prelude::lazy_static,
         prelude::{
-            r, AttributeNames, DeploymentHash, EntityCollection, EntityFilter, EntityRange, Value,
-            ValueType, BLOCK_NUMBER_MAX,
-        },
-        prelude::{
+            AttributeNames, BLOCK_NUMBER_MAX, DeploymentHash, EntityCollection, EntityFilter,
+            EntityOrder, EntityRange, Value, ValueType, r,
             s::{self, Directive, Field, InputValue, ObjectType, Type, Value as SchemaValue},
-            EntityOrder,
         },
-        schema::InputSchema,
+        schema::{EntityType, InputSchema},
     };
-    use graphql_parser::Pos;
-    use std::{collections::BTreeMap, iter::FromIterator, sync::Arc};
+    use std::collections::BTreeSet;
+    use std::{iter::FromIterator, sync::Arc};
+
+    use super::{a, build_query};
+
+    const DEFAULT_OBJECT: &str = "DefaultObject";
+    const ENTITY1: &str = "Entity1";
+    const ENTITY2: &str = "Entity2";
+
+    lazy_static! {
+        static ref INPUT_SCHEMA: InputSchema = {
+            const INPUT_SCHEMA: &str = r#"
+            type Entity1 @entity { id: ID! }
+            type Entity2 @entity { id: ID! }
+            type DefaultObject @entity {
+                id: ID!
+                name: String
+                email: String
+            }
+        "#;
+
+            let id = DeploymentHash::new("id").unwrap();
+
+            InputSchema::parse_latest(INPUT_SCHEMA, id.clone()).unwrap()
+        };
+    }
+
+    #[track_caller]
+    fn query(field: &a::Field) -> EntityQuery {
+        // We only allow one entity type in these tests
+        assert_eq!(field.selection_set.fields().count(), 1);
+        let obj_type = field
+            .selection_set
+            .fields()
+            .map(|(obj, _)| &obj.name)
+            .next()
+            .expect("there is one object type");
+        let Some(object) = INPUT_SCHEMA.object_or_interface(obj_type, None) else {
+            panic!("object type {} not found", obj_type);
+        };
 
-    use super::{a, build_query, SchemaPair};
+        build_query(
+            &object,
+            BLOCK_NUMBER_MAX,
+            field,
+            u32::MAX,
+            u32::MAX,
+            &INPUT_SCHEMA,
+        )
+        .unwrap()
+    }
+
+    #[track_caller]
+    fn entity_type(name: &str) -> EntityType {
+        INPUT_SCHEMA.entity_type(name).unwrap()
+    }
 
     fn default_object() -> ObjectType {
         let subgraph_id_argument = (
@@ -811,11 +763,11 @@ mod tests {
         );
         let subgraph_id_directive = Directive {
             name: "subgraphId".to_string(),
-            position: Pos::default(),
+            position: s::Pos::default(),
             arguments: vec![subgraph_id_argument],
         };
         let name_input_value = InputValue {
-            position: Pos::default(),
+            position: s::Pos::default(),
             description: Some("name input".to_string()),
             name: "name".to_string(),
             value_type: Type::NamedType("String".to_string()),
@@ -823,7 +775,7 @@ mod tests {
             directives: vec![],
         };
         let name_field = Field {
-            position: Pos::default(),
+            position: s::Pos::default(),
             description: Some("name field".to_string()),
             name: "name".to_string(),
             arguments: vec![name_input_value.clone()],
@@ -831,7 +783,7 @@ mod tests {
             directives: vec![],
         };
         let email_field = Field {
-            position: Pos::default(),
+            position: s::Pos::default(),
             description: Some("email field".to_string()),
             name: "email".to_string(),
             arguments: vec![name_input_value],
@@ -842,7 +794,7 @@ mod tests {
         ObjectType {
             position: Default::default(),
             description: None,
-            name: "DefaultObject".to_string(),
+            name: DEFAULT_OBJECT.to_string(),
             implements_interfaces: vec![],
             directives: vec![subgraph_id_directive],
             fields: vec![name_field, email_field],
@@ -856,23 +808,12 @@ mod tests {
         }
     }
 
-    fn field(name: &str, field_type: Type) -> Field {
-        Field {
-            position: Default::default(),
-            description: None,
-            name: name.to_owned(),
-            arguments: vec![],
-            field_type,
-            directives: vec![],
-        }
-    }
-
-    fn default_field() -> a::Field {
+    fn field(obj_type: &str) -> a::Field {
         let arguments = vec![
             ("first".to_string(), r::Value::Int(100.into())),
             ("skip".to_string(), r::Value::Int(0.into())),
         ];
-        let obj_type = Arc::new(object("SomeType")).into();
+        let obj_type = Arc::new(object(obj_type)).into();
         a::Field {
             position: Default::default(),
             alias: None,
@@ -884,190 +825,89 @@ mod tests {
         }
     }
 
-    fn default_field_with(arg_name: &str, arg_value: r::Value) -> a::Field {
-        let mut field = default_field();
+    fn default_field() -> a::Field {
+        field(DEFAULT_OBJECT)
+    }
+
+    fn field_with(obj_type: &str, arg_name: &str, arg_value: r::Value) -> a::Field {
+        let mut field = field(obj_type);
         field.arguments.push((arg_name.to_string(), arg_value));
         field
     }
 
-    fn default_field_with_vec(args: Vec<(&str, r::Value)>) -> a::Field {
-        let mut field = default_field();
+    fn default_field_with(arg_name: &str, arg_value: r::Value) -> a::Field {
+        field_with(DEFAULT_OBJECT, arg_name, arg_value)
+    }
+
+    fn field_with_vec(obj_type: &str, args: Vec<(&str, r::Value)>) -> a::Field {
+        let mut field = field(obj_type);
         for (name, value) in args {
             field.arguments.push((name.to_string(), value));
         }
         field
     }
 
-    fn build_default_schema() -> SchemaPair {
-        const INPUT_SCHEMA: &str = r#"
-        type Entity1 @entity { id: ID! }
-        type Entity2 @entity { id: ID! }
-        type DefaultObject @entity {
-            id: ID!
-            name: String
-            email: String
-        }
-    "#;
-
-        let id = DeploymentHash::new("id").unwrap();
-        let input_schema = InputSchema::parse_latest(INPUT_SCHEMA, id.clone()).unwrap();
-        let api_schema = input_schema.api_schema().unwrap();
-
-        SchemaPair {
-            input: input_schema,
-            api: Arc::new(api_schema),
-        }
+    fn default_field_with_vec(args: Vec<(&str, r::Value)>) -> a::Field {
+        field_with_vec(DEFAULT_OBJECT, args)
     }
 
     #[test]
     fn build_query_uses_the_entity_name() {
-        let schema = build_default_schema();
+        let attrs = if ENV_VARS.enable_select_by_specific_attributes {
+            // The query uses the default order, i.e., sorting by id
+            let mut attrs = BTreeSet::new();
+            attrs.insert(ID.to_string());
+            AttributeNames::Select(attrs)
+        } else {
+            AttributeNames::All
+        };
         assert_eq!(
-            build_query(
-                &object("Entity1"),
-                BLOCK_NUMBER_MAX,
-                &default_field(),
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema,
-            )
-            .unwrap()
-            .collection,
-            EntityCollection::All(vec![(
-                schema.input.entity_type("Entity1").unwrap(),
-                AttributeNames::All
-            )])
+            query(&field(ENTITY1)).collection,
+            EntityCollection::All(vec![(entity_type(ENTITY1), attrs.clone())])
         );
         assert_eq!(
-            build_query(
-                &object("Entity2"),
-                BLOCK_NUMBER_MAX,
-                &default_field(),
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema,
-            )
-            .unwrap()
-            .collection,
-            EntityCollection::All(vec![(
-                schema.input.entity_type("Entity2").unwrap(),
-                AttributeNames::All
-            )])
+            query(&field(ENTITY2)).collection,
+            EntityCollection::All(vec![(entity_type(ENTITY2), attrs)])
         );
     }
 
     #[test]
     fn build_query_yields_no_order_if_order_arguments_are_missing() {
-        let schema = build_default_schema();
-        assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &default_field(),
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema,
-            )
-            .unwrap()
-            .order,
-            EntityOrder::Default,
-        );
+        assert_eq!(query(&default_field()).order, EntityOrder::Default);
     }
 
     #[test]
     fn build_query_parses_order_by_from_enum_values_correctly() {
-        let schema = build_default_schema();
         let field = default_field_with("orderBy", r::Value::Enum("name".to_string()));
         assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema,
-            )
-            .unwrap()
-            .order,
+            query(&field).order,
             EntityOrder::Ascending("name".to_string(), ValueType::String)
         );
 
         let field = default_field_with("orderBy", r::Value::Enum("email".to_string()));
         assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema,
-            )
-            .unwrap()
-            .order,
+            query(&field).order,
             EntityOrder::Ascending("email".to_string(), ValueType::String)
         );
     }
 
     #[test]
     fn build_query_ignores_order_by_from_non_enum_values() {
-        let schema = build_default_schema();
         let field = default_field_with("orderBy", r::Value::String("name".to_string()));
-        assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema,
-            )
-            .unwrap()
-            .order,
-            EntityOrder::Default
-        );
+        assert_eq!(query(&field).order, EntityOrder::Default);
 
         let field = default_field_with("orderBy", r::Value::String("email".to_string()));
-        assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema,
-            )
-            .unwrap()
-            .order,
-            EntityOrder::Default
-        );
+        assert_eq!(query(&field).order, EntityOrder::Default);
     }
 
     #[test]
     fn build_query_parses_order_direction_from_enum_values_correctly() {
-        let schema = build_default_schema();
         let field = default_field_with_vec(vec![
             ("orderBy", r::Value::Enum("name".to_string())),
             ("orderDirection", r::Value::Enum("asc".to_string())),
         ]);
         assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema,
-            )
-            .unwrap()
-            .order,
+            query(&field).order,
             EntityOrder::Ascending("name".to_string(), ValueType::String)
         );
 
@@ -1076,17 +916,7 @@ mod tests {
             ("orderDirection", r::Value::Enum("desc".to_string())),
         ]);
         assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema,
-            )
-            .unwrap()
-            .order,
+            query(&field).order,
             EntityOrder::Descending("name".to_string(), ValueType::String)
         );
 
@@ -1098,17 +928,7 @@ mod tests {
             ),
         ]);
         assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema
-            )
-            .unwrap()
-            .order,
+            query(&field).order,
             EntityOrder::Ascending("name".to_string(), ValueType::String)
         );
 
@@ -1117,59 +937,21 @@ mod tests {
             "orderDirection",
             r::Value::Enum("descending...".to_string()),
         );
-        assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema
-            )
-            .unwrap()
-            .order,
-            EntityOrder::Default
-        );
+        assert_eq!(query(&field).order, EntityOrder::Default);
     }
 
     #[test]
     fn build_query_yields_default_range_if_none_is_present() {
-        let schema = build_default_schema();
-        assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &default_field(),
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema
-            )
-            .unwrap()
-            .range,
-            EntityRange::first(100)
-        );
+        assert_eq!(query(&default_field()).range, EntityRange::first(100));
     }
 
     #[test]
     fn build_query_yields_default_first_if_only_skip_is_present() {
-        let schema = build_default_schema();
         let mut field = default_field();
         field.arguments = vec![("skip".to_string(), r::Value::Int(50))];
 
         assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema
-            )
-            .unwrap()
-            .range,
+            query(&field).range,
             EntityRange {
                 first: Some(100),
                 skip: 50,
@@ -1179,7 +961,6 @@ mod tests {
 
     #[test]
     fn build_query_yields_filters() {
-        let schema = build_default_schema();
         let query_field = default_field_with(
             "where",
             r::Value::Object(Object::from_iter(vec![(
@@ -1188,20 +969,7 @@ mod tests {
             )])),
         );
         assert_eq!(
-            build_query(
-                &ObjectType {
-                    fields: vec![field("name", Type::NamedType("string".to_owned()))],
-                    ..default_object()
-                },
-                BLOCK_NUMBER_MAX,
-                &query_field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema
-            )
-            .unwrap()
-            .filter,
+            query(&query_field).filter,
             Some(EntityFilter::And(vec![EntityFilter::EndsWith(
                 "name".to_string(),
                 Value::String("ello".to_string()),
@@ -1209,9 +977,28 @@ mod tests {
         )
     }
 
+    #[test]
+    fn build_query_handles_empty_in_list() {
+        let query_field = default_field_with(
+            "where",
+            r::Value::Object(Object::from_iter(vec![(
+                "id_in".into(),
+                r::Value::List(vec![]),
+            )])),
+        );
+
+        let result = query(&query_field);
+        assert_eq!(
+            result.filter,
+            Some(EntityFilter::And(vec![EntityFilter::In(
+                "id".to_string(),
+                Vec::<Value>::new(),
+            )]))
+        );
+    }
+
     #[test]
     fn build_query_yields_block_change_gte_filter() {
-        let schema = build_default_schema();
         let query_field = default_field_with(
             "where",
             r::Value::Object(Object::from_iter(vec![(
@@ -1223,21 +1010,245 @@ mod tests {
             )])),
         );
         assert_eq!(
-            build_query(
-                &ObjectType {
-                    fields: vec![field("name", Type::NamedType("string".to_owned()))],
-                    ..default_object()
-                },
-                BLOCK_NUMBER_MAX,
-                &query_field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                &schema
-            )
-            .unwrap()
-            .filter,
+            query(&query_field).filter,
             Some(EntityFilter::And(vec![EntityFilter::ChangeBlockGte(10)]))
         )
     }
+
+    #[test]
+    fn build_query_detects_invalid_or_filter_structure() {
+        // Test that mixing column filters with 'or' operator produces a helpful error
+        let query_field = default_field_with(
+            "where",
+            r::Value::Object(Object::from_iter(vec![
+                ("name".into(), r::Value::String("John".to_string())),
+                (
+                    "or".into(),
+                    r::Value::List(vec![r::Value::Object(Object::from_iter(vec![(
+                        "email".into(),
+                        r::Value::String("john@example.com".to_string()),
+                    )]))]),
+                ),
+            ])),
+        );
+
+        // We only allow one entity type in these tests
+        assert_eq!(query_field.selection_set.fields().count(), 1);
+        let obj_type = query_field
+            .selection_set
+            .fields()
+            .map(|(obj, _)| &obj.name)
+            .next()
+            .expect("there is one object type");
+        let Some(object) = INPUT_SCHEMA.object_or_interface(obj_type, None) else {
+            panic!("object type {} not found", obj_type);
+        };
+
+        let result = build_query(
+            &object,
+            BLOCK_NUMBER_MAX,
+            &query_field,
+            u32::MAX,
+            u32::MAX,
+            &INPUT_SCHEMA,
+        );
+
+        assert!(result.is_err());
+        let error = result.unwrap_err();
+
+        // Check that we get the specific error we expect
+        match error {
+            graph::data::query::QueryExecutionError::InvalidOrFilterStructure(fields, example) => {
+                assert_eq!(fields, vec!["'name'"]);
+                assert!(example.contains("Instead of:"));
+                assert!(example.contains("where: { 'name', or: [...] }"));
+                assert!(example.contains("Use:"));
+                assert!(example.contains("where: { or: [{ 'name', ... }, { 'name', ... }] }"));
+            }
+            _ => panic!("Expected InvalidOrFilterStructure error, got: {}", error),
+        }
+    }
+
+    #[test]
+    fn build_query_detects_invalid_or_filter_structure_multiple_fields() {
+        // Test that multiple column filters with 'or' operator are all reported
+        let query_field = default_field_with(
+            "where",
+            r::Value::Object(Object::from_iter(vec![
+                ("name".into(), r::Value::String("John".to_string())),
+                (
+                    "email".into(),
+                    r::Value::String("john@example.com".to_string()),
+                ),
+                (
+                    "or".into(),
+                    r::Value::List(vec![r::Value::Object(Object::from_iter(vec![(
+                        "name".into(),
+                        r::Value::String("Jane".to_string()),
+                    )]))]),
+                ),
+            ])),
+        );
+
+        // We only allow one entity type in these tests
+        assert_eq!(query_field.selection_set.fields().count(), 1);
+        let obj_type = query_field
+            .selection_set
+            .fields()
+            .map(|(obj, _)| &obj.name)
+            .next()
+            .expect("there is one object type");
+        let Some(object) = INPUT_SCHEMA.object_or_interface(obj_type, None) else {
+            panic!("object type {} not found", obj_type);
+        };
+
+        let result = build_query(
+            &object,
+            BLOCK_NUMBER_MAX,
+            &query_field,
+            u32::MAX,
+            u32::MAX,
+            &INPUT_SCHEMA,
+        );
+
+        assert!(result.is_err());
+        let error = result.unwrap_err();
+
+        // Check that we get the specific error we expect
+        match error {
+            graph::data::query::QueryExecutionError::InvalidOrFilterStructure(fields, example) => {
+                // Should detect both column filters
+                assert_eq!(fields.len(), 2);
+                assert!(fields.contains(&"'name'".to_string()));
+                assert!(fields.contains(&"'email'".to_string()));
+                assert!(example.contains("Instead of:"));
+                assert!(example.contains("Use:"));
+            }
+            _ => panic!("Expected InvalidOrFilterStructure error, got: {}", error),
+        }
+    }
+
+    #[test]
+    fn build_query_allows_valid_or_filter_structure() {
+        // Test that valid 'or' filters without column filters at the same level work correctly
+        let query_field = default_field_with(
+            "where",
+            r::Value::Object(Object::from_iter(vec![(
+                "or".into(),
+                r::Value::List(vec![
+                    r::Value::Object(Object::from_iter(vec![(
+                        "name".into(),
+                        r::Value::String("John".to_string()),
+                    )])),
+                    r::Value::Object(Object::from_iter(vec![(
+                        "email".into(),
+                        r::Value::String("john@example.com".to_string()),
+                    )])),
+                ]),
+            )])),
+        );
+
+        // This should not produce an error
+        let result = query(&query_field);
+        assert!(result.filter.is_some());
+
+        // Verify that the filter is correctly structured
+        match result.filter.unwrap() {
+            EntityFilter::And(filters) => {
+                assert_eq!(filters.len(), 1);
+                match &filters[0] {
+                    EntityFilter::Or(_) => {
+                        // This is expected - OR filter should be wrapped in AND
+                    }
+                    _ => panic!("Expected OR filter, got: {:?}", filters[0]),
+                }
+            }
+            _ => panic!("Expected AND filter with OR inside"),
+        }
+    }
+
+    #[test]
+    fn build_query_detects_invalid_or_filter_structure_with_operators() {
+        // Test that column filters with operators (like name_gt) are also detected
+        let query_field = default_field_with(
+            "where",
+            r::Value::Object(Object::from_iter(vec![
+                ("name_gt".into(), r::Value::String("A".to_string())),
+                (
+                    "or".into(),
+                    r::Value::List(vec![r::Value::Object(Object::from_iter(vec![(
+                        "email".into(),
+                        r::Value::String("test@example.com".to_string()),
+                    )]))]),
+                ),
+            ])),
+        );
+
+        // We only allow one entity type in these tests
+        assert_eq!(query_field.selection_set.fields().count(), 1);
+        let obj_type = query_field
+            .selection_set
+            .fields()
+            .map(|(obj, _)| &obj.name)
+            .next()
+            .expect("there is one object type");
+        let Some(object) = INPUT_SCHEMA.object_or_interface(obj_type, None) else {
+            panic!("object type {} not found", obj_type);
+        };
+
+        let result = build_query(
+            &object,
+            BLOCK_NUMBER_MAX,
+            &query_field,
+            u32::MAX,
+            u32::MAX,
+            &INPUT_SCHEMA,
+        );
+
+        assert!(result.is_err());
+        let error = result.unwrap_err();
+
+        // Check that we get the specific error we expect
+        match error {
+            graph::data::query::QueryExecutionError::InvalidOrFilterStructure(fields, example) => {
+                assert_eq!(fields, vec!["'name_gt'"]);
+                assert!(example.contains("Instead of:"));
+                assert!(example.contains("where: { 'name_gt', or: [...] }"));
+                assert!(example.contains("Use:"));
+                assert!(
+                    example.contains("where: { or: [{ 'name_gt', ... }, { 'name_gt', ... }] }")
+                );
+            }
+            _ => panic!("Expected InvalidOrFilterStructure error, got: {}", error),
+        }
+    }
+
+    #[test]
+    fn test_error_message_formatting() {
+        // Test that the error message is properly formatted
+        let fields = vec!["'age_gt'".to_string(), "'name'".to_string()];
+        let example = format!(
+            "Instead of:\nwhere: {{ {}, or: [...] }}\n\nUse:\nwhere: {{ or: [{{ {}, ... }}, {{ {}, ... }}] }}",
+            fields.join(", "),
+            fields.join(", "),
+            fields.join(", ")
+        );
+
+        let error =
+            graph::data::query::QueryExecutionError::InvalidOrFilterStructure(fields, example);
+        let error_msg = format!("{}", error);
+
+        println!("Error message:\n{}", error_msg);
+
+        // Verify the error message contains the key elements
+        assert!(error_msg.contains("Cannot mix column filters with 'or' operator"));
+        assert!(error_msg.contains("'age_gt', 'name'"));
+        assert!(error_msg.contains("Instead of:"));
+        assert!(error_msg.contains("Use:"));
+        assert!(error_msg.contains("where: { 'age_gt', 'name', or: [...] }"));
+        assert!(
+            error_msg
+                .contains("where: { or: [{ 'age_gt', 'name', ... }, { 'age_gt', 'name', ... }] }")
+        );
+    }
 }
diff --git a/graphql/src/store/resolver.rs b/graphql/src/store/resolver.rs
index ed6f02dc955..1cfe64c4cbc 100644
--- a/graphql/src/store/resolver.rs
+++ b/graphql/src/store/resolver.rs
@@ -1,34 +1,34 @@
 use std::collections::BTreeMap;
-use std::result;
 use std::sync::Arc;
 
+use async_trait::async_trait;
 use graph::components::graphql::GraphQLMetrics as _;
-use graph::components::store::{QueryPermit, SubscriptionManager, UnitStream};
+use graph::components::store::QueryPermit;
 use graph::data::graphql::load_manager::LoadManager;
-use graph::data::graphql::{object, ObjectOrInterface};
-use graph::data::query::{CacheStatus, Trace};
+use graph::data::graphql::{ObjectOrInterface, object};
+use graph::data::query::{CacheStatus, QueryResults, Trace};
+use graph::data::store::ID;
 use graph::data::value::{Object, Word};
+use graph::derive::CheapClone;
+use graph::prelude::alloy::primitives::B256;
 use graph::prelude::*;
+use graph::schema::{BLOCK_FIELD_TYPE, ErrorPolicy};
 use graph::schema::{
-    ast as sast, ApiSchema, INTROSPECTION_SCHEMA_FIELD_NAME, INTROSPECTION_TYPE_FIELD_NAME,
-    META_FIELD_NAME, META_FIELD_TYPE,
+    INTROSPECTION_SCHEMA_FIELD_NAME, INTROSPECTION_TYPE_FIELD_NAME, LOGS_FIELD_NAME,
+    META_FIELD_NAME, META_FIELD_TYPE, ast as sast,
 };
-use graph::schema::{ErrorPolicy, BLOCK_FIELD_TYPE};
 
-use crate::execution::{ast as a, Query};
+use crate::execution::{Query, ast as a};
 use crate::metrics::GraphQLMetrics;
 use crate::prelude::{ExecutionContext, Resolver};
 use crate::query::ext::BlockConstraint;
-use crate::store::query::collect_entities_from_query_field;
 
 /// A resolver that fetches entities from a `Store`.
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 pub struct StoreResolver {
-    #[allow(dead_code)]
     logger: Logger,
     pub(crate) store: Arc<dyn QueryStore>,
-    subscription_manager: Arc<dyn SubscriptionManager>,
-    pub(crate) block_ptr: Option<BlockPtrTs>,
+    pub(crate) block_ptr: Option<BlockPtr>,
     deployment: DeploymentHash,
     has_non_fatal_errors: bool,
     error_policy: ErrorPolicy,
@@ -36,57 +36,7 @@ pub struct StoreResolver {
     load_manager: Arc<LoadManager>,
 }
 
-#[derive(Clone, Debug)]
-pub(crate) struct BlockPtrTs {
-    pub ptr: BlockPtr,
-    pub timestamp: Option<u64>,
-}
-
-impl From<BlockPtr> for BlockPtrTs {
-    fn from(ptr: BlockPtr) -> Self {
-        Self {
-            ptr,
-            timestamp: None,
-        }
-    }
-}
-
-impl From<&BlockPtrTs> for BlockPtr {
-    fn from(ptr: &BlockPtrTs) -> Self {
-        ptr.ptr.cheap_clone()
-    }
-}
-
-impl CheapClone for StoreResolver {}
-
 impl StoreResolver {
-    /// Create a resolver that looks up entities at whatever block is the
-    /// latest when the query is run. That means that multiple calls to find
-    /// entities into this resolver might return entities from different
-    /// blocks
-    pub fn for_subscription(
-        logger: &Logger,
-        deployment: DeploymentHash,
-        store: Arc<dyn QueryStore>,
-        subscription_manager: Arc<dyn SubscriptionManager>,
-        graphql_metrics: Arc<GraphQLMetrics>,
-        load_manager: Arc<LoadManager>,
-    ) -> Self {
-        StoreResolver {
-            logger: logger.new(o!("component" => "StoreResolver")),
-            store,
-            subscription_manager,
-            block_ptr: None,
-            deployment,
-
-            // Checking for non-fatal errors does not work with subscriptions.
-            has_non_fatal_errors: false,
-            error_policy: ErrorPolicy::Deny,
-            graphql_metrics,
-            load_manager,
-        }
-    }
-
     /// Create a resolver that looks up entities at the block specified
     /// by `bc`. Any calls to find objects will always return entities as
     /// of that block. Note that if `bc` is `BlockConstraint::Latest` we use
@@ -96,27 +46,20 @@ impl StoreResolver {
         logger: &Logger,
         store: Arc<dyn QueryStore>,
         state: &DeploymentState,
-        subscription_manager: Arc<dyn SubscriptionManager>,
-        bc: BlockConstraint,
+        block_ptr: BlockPtr,
         error_policy: ErrorPolicy,
         deployment: DeploymentHash,
         graphql_metrics: Arc<GraphQLMetrics>,
         load_manager: Arc<LoadManager>,
     ) -> Result<Self, QueryExecutionError> {
-        let store_clone = store.cheap_clone();
-        let block_ptr = Self::locate_block(store_clone.as_ref(), bc, state).await?;
-
-        let blocks_behind = state.latest_block.number - block_ptr.ptr.number;
+        let blocks_behind = state.latest_block.number - block_ptr.number;
         graphql_metrics.observe_query_blocks_behind(blocks_behind, &deployment);
 
-        let has_non_fatal_errors = store
-            .has_deterministic_errors(block_ptr.ptr.block_number())
-            .await?;
+        let has_non_fatal_errors = state.has_deterministic_errors(&block_ptr);
 
         let resolver = StoreResolver {
             logger: logger.new(o!("component" => "StoreResolver")),
             store,
-            subscription_manager,
             block_ptr: Some(block_ptr),
             deployment,
             has_non_fatal_errors,
@@ -130,16 +73,18 @@ impl StoreResolver {
     pub fn block_number(&self) -> BlockNumber {
         self.block_ptr
             .as_ref()
-            .map(|ptr| ptr.ptr.number as BlockNumber)
+            .map(|ptr| ptr.number as BlockNumber)
             .unwrap_or(BLOCK_NUMBER_MAX)
     }
 
-    /// locate_block returns the block pointer and it's timestamp when available.
-    async fn locate_block(
+    /// Locate all the blocks needed for the query by resolving block
+    /// constraints and return the selection sets with the blocks at which
+    /// they should be executed
+    pub async fn locate_blocks(
         store: &dyn QueryStore,
-        bc: BlockConstraint,
         state: &DeploymentState,
-    ) -> Result<BlockPtrTs, QueryExecutionError> {
+        query: &Query,
+    ) -> Result<Vec<(BlockPtr, (a::SelectionSet, ErrorPolicy))>, QueryResults> {
         fn block_queryable(
             state: &DeploymentState,
             block: BlockNumber,
@@ -149,140 +94,160 @@ impl StoreResolver {
                 .map_err(|msg| QueryExecutionError::ValueParseError("block.number".to_owned(), msg))
         }
 
-        async fn get_block_ts(
-            store: &dyn QueryStore,
-            ptr: &BlockPtr,
-        ) -> Result<Option<u64>, QueryExecutionError> {
-            match store
-                .block_number_with_timestamp(&ptr.hash)
+        let by_block_constraint = query.block_constraint()?;
+        let hashes: Vec<_> = by_block_constraint
+            .iter()
+            .filter_map(|(bc, _)| bc.hash())
+            .cloned()
+            .collect();
+        let hashes = store
+            .block_numbers(hashes)
+            .await
+            .map_err(QueryExecutionError::from)?;
+        let mut ptrs_and_sels = Vec::new();
+        for (bc, sel) in by_block_constraint {
+            let ptr = match bc {
+                BlockConstraint::Hash(hash) => {
+                    let Some(number) = hashes.get(&hash) else {
+                        return Err(QueryExecutionError::ValueParseError(
+                            "block.hash".to_owned(),
+                            "no block with that hash found".to_owned(),
+                        )
+                        .into());
+                    };
+                    let ptr = BlockPtr::new(hash, *number);
+                    block_queryable(state, ptr.number)?;
+                    ptr
+                }
+                BlockConstraint::Number(number) => {
+                    block_queryable(state, number)?;
+                    // We don't have a way here to look the block hash up from
+                    // the database, and even if we did, there is no guarantee
+                    // that we have the block in our cache. We therefore
+                    // always return an all zeroes hash when users specify
+                    // a block number
+                    // See 7a7b9708-adb7-4fc2-acec-88680cb07ec1
+                    BlockPtr::new(BlockHash::zero(), number)
+                }
+                BlockConstraint::Min(min) => {
+                    let ptr = state.latest_block.cheap_clone();
+                    if ptr.number < min {
+                        return Err(QueryExecutionError::ValueParseError(
+                                "block.number_gte".to_owned(),
+                                format!(
+                                    "subgraph {} has only indexed up to block number {} \
+                                        and data for block number {} is therefore not yet available",
+                                    state.id, ptr.number, min
+                                ),
+                            ).into());
+                    }
+                    ptr
+                }
+                BlockConstraint::Latest => state.latest_block.cheap_clone(),
+            };
+            ptrs_and_sels.push((ptr, sel));
+        }
+        Ok(ptrs_and_sels)
+    }
+
+    /// Lookup information for the `_meta` field `field`
+    async fn lookup_meta(&self, field: &a::Field) -> Result<r::Value, QueryExecutionError> {
+        // These constants are closely related to the `_Meta_` type in
+        // `graph/src/schema/meta.graphql`
+        const BLOCK: &str = "block";
+        const TIMESTAMP: &str = "timestamp";
+        const PARENT_HASH: &str = "parentHash";
+
+        /// Check if field is of the form `_ { block { X }}` where X is
+        /// either `timestamp` or `parentHash`. In that case, we need to
+        /// query the database
+        fn lookup_needed(field: &a::Field) -> bool {
+            let Some(block) = field
+                .selection_set
+                .fields()
+                .flat_map(|(_, iter)| iter)
+                .find(|f| f.name == BLOCK)
+            else {
+                return false;
+            };
+            block
+                .selection_set
+                .fields()
+                .flat_map(|(_, iter)| iter)
+                .any(|f| f.name == TIMESTAMP || f.name == PARENT_HASH)
+        }
+
+        let Some(block_ptr) = &self.block_ptr else {
+            return Err(QueryExecutionError::ResolveEntitiesError(
+                "cannot resolve _meta without a block pointer".to_string(),
+            ));
+        };
+        let (timestamp, parent_hash) = if lookup_needed(field) {
+            match self
+                .store
+                .block_number_with_timestamp_and_parent_hash(&block_ptr.hash)
                 .await
                 .map_err(Into::<QueryExecutionError>::into)?
             {
-                Some((_, Some(ts))) => Ok(Some(ts)),
-                _ => Ok(None),
+                Some((_, ts, parent_hash)) => (ts, parent_hash),
+                _ => (None, None),
             }
-        }
+        } else {
+            (None, None)
+        };
 
-        match bc {
-            BlockConstraint::Hash(hash) => {
-                let ptr = store
-                    .block_number_with_timestamp(&hash)
-                    .await
-                    .map_err(Into::into)
-                    .and_then(|result| {
-                        result
-                            .ok_or_else(|| {
-                                QueryExecutionError::ValueParseError(
-                                    "block.hash".to_owned(),
-                                    "no block with that hash found".to_owned(),
-                                )
-                            })
-                            .map(|(number, ts)| BlockPtrTs {
-                                ptr: BlockPtr::new(hash, number),
-                                timestamp: ts,
-                            })
-                    })?;
-
-                block_queryable(state, ptr.ptr.number)?;
-                Ok(ptr)
-            }
-            BlockConstraint::Number(number) => {
-                block_queryable(state, number)?;
-                // We don't have a way here to look the block hash up from
-                // the database, and even if we did, there is no guarantee
-                // that we have the block in our cache. We therefore
-                // always return an all zeroes hash when users specify
-                // a block number
+        let hash = self
+            .block_ptr
+            .as_ref()
+            .and_then(|ptr| {
+                // locate_block indicates that we do not have a block hash
+                // by setting the hash to `zero`
                 // See 7a7b9708-adb7-4fc2-acec-88680cb07ec1
-                Ok(BlockPtr::from((web3::types::H256::zero(), number as u64)).into())
-            }
-            BlockConstraint::Min(min) => {
-                let ptr = state.latest_block.cheap_clone();
-                if ptr.number < min {
-                    return Err(QueryExecutionError::ValueParseError(
-                        "block.number_gte".to_owned(),
-                        format!(
-                            "subgraph {} has only indexed up to block number {} \
-                                and data for block number {} is therefore not yet available",
-                            state.id, ptr.number, min
-                        ),
-                    ));
+                let hash_b256 = ptr.hash.as_b256();
+                if hash_b256 == B256::ZERO {
+                    None
+                } else {
+                    Some(r::Value::String(format!("0x{:x}", hash_b256)))
                 }
-                let timestamp = get_block_ts(store, &state.latest_block).await?;
-
-                Ok(BlockPtrTs { ptr, timestamp })
-            }
-            BlockConstraint::Latest => {
-                let timestamp = get_block_ts(store, &state.latest_block).await?;
-
-                Ok(BlockPtrTs {
-                    ptr: state.latest_block.cheap_clone(),
-                    timestamp,
-                })
-            }
-        }
-    }
-
-    fn handle_meta(
-        &self,
-        prefetched_object: Option<r::Value>,
-        object_type: &ObjectOrInterface<'_>,
-    ) -> Result<(Option<r::Value>, Option<r::Value>), QueryExecutionError> {
-        // Pretend that the whole `_meta` field was loaded by prefetch. Eager
-        // loading this is ok until we add more information to this field
-        // that would force us to query the database; when that happens, we
-        // need to switch to loading on demand
-        if object_type.is_meta() {
-            let hash = self
-                .block_ptr
-                .as_ref()
-                .and_then(|ptr| {
-                    // locate_block indicates that we do not have a block hash
-                    // by setting the hash to `zero`
-                    // See 7a7b9708-adb7-4fc2-acec-88680cb07ec1
-                    let hash_h256 = ptr.ptr.hash_as_h256();
-                    if hash_h256 == web3::types::H256::zero() {
-                        None
-                    } else {
-                        Some(r::Value::String(format!("0x{:x}", hash_h256)))
-                    }
-                })
-                .unwrap_or(r::Value::Null);
-            let number = self
-                .block_ptr
-                .as_ref()
-                .map(|ptr| r::Value::Int(ptr.ptr.number.into()))
-                .unwrap_or(r::Value::Null);
-
-            let timestamp = self.block_ptr.as_ref().map(|ptr| {
-                ptr.timestamp
-                    .map(|ts| r::Value::Int(ts as i64))
-                    .unwrap_or(r::Value::Null)
-            });
-
-            let mut map = BTreeMap::new();
-            let block = object! {
-                hash: hash,
-                number: number,
-                timestamp: timestamp,
-                __typename: BLOCK_FIELD_TYPE
-            };
-            map.insert("prefetch:block".into(), r::Value::List(vec![block]));
-            map.insert(
-                "deployment".into(),
-                r::Value::String(self.deployment.to_string()),
-            );
-            map.insert(
-                "hasIndexingErrors".into(),
-                r::Value::Boolean(self.has_non_fatal_errors),
-            );
-            map.insert(
-                "__typename".into(),
-                r::Value::String(META_FIELD_TYPE.to_string()),
-            );
-            return Ok((None, Some(r::Value::object(map))));
-        }
-        Ok((prefetched_object, None))
+            })
+            .unwrap_or(r::Value::Null);
+        let number = self
+            .block_ptr
+            .as_ref()
+            .map(|ptr| r::Value::Int(ptr.number.into()))
+            .unwrap_or(r::Value::Null);
+
+        let timestamp = timestamp
+            .map(|ts| r::Value::Int(ts as i64))
+            .unwrap_or(r::Value::Null);
+
+        let parent_hash = parent_hash
+            .map(|hash| r::Value::String(format!("{}", hash)))
+            .unwrap_or(r::Value::Null);
+
+        let mut map = BTreeMap::new();
+        let block = object! {
+            hash: hash,
+            number: number,
+            timestamp: timestamp,
+            parentHash: parent_hash,
+            __typename: BLOCK_FIELD_TYPE
+        };
+        let block_key = Word::from(format!("prefetch:{BLOCK}"));
+        map.insert(block_key, r::Value::List(vec![block]));
+        map.insert(
+            "deployment".into(),
+            r::Value::String(self.deployment.to_string()),
+        );
+        map.insert(
+            "hasIndexingErrors".into(),
+            r::Value::Boolean(self.has_non_fatal_errors),
+        );
+        map.insert(
+            "__typename".into(),
+            r::Value::String(META_FIELD_TYPE.to_string()),
+        );
+        Ok(r::Value::object(map))
     }
 }
 
@@ -290,16 +255,17 @@ impl StoreResolver {
 impl Resolver for StoreResolver {
     const CACHEABLE: bool = true;
 
-    async fn query_permit(&self) -> Result<QueryPermit, QueryExecutionError> {
-        self.store.query_permit().await.map_err(Into::into)
+    async fn query_permit(&self) -> QueryPermit {
+        self.store.query_permit().await
     }
 
-    fn prefetch(
+    async fn prefetch(
         &self,
         ctx: &ExecutionContext<Self>,
         selection_set: &a::SelectionSet,
     ) -> Result<(Option<r::Value>, Trace), Vec<QueryExecutionError>> {
         super::prefetch::run(self, ctx, selection_set, &self.graphql_metrics)
+            .await
             .map(|(value, trace)| (Some(value), trace))
     }
 
@@ -329,22 +295,49 @@ impl Resolver for StoreResolver {
         field_definition: &s::Field,
         object_type: ObjectOrInterface<'_>,
     ) -> Result<r::Value, QueryExecutionError> {
-        let (prefetched_object, meta) = self.handle_meta(prefetched_object, &object_type)?;
-        if let Some(meta) = meta {
-            return Ok(meta);
+        fn child_id(child: &r::Value) -> String {
+            match child {
+                r::Value::Object(child) => child
+                    .get(&ID)
+                    .map(|id| id.to_string())
+                    .unwrap_or("(no id)".to_string()),
+                _ => "(no child object)".to_string(),
+            }
+        }
+
+        if object_type.is_meta() {
+            return self.lookup_meta(field).await;
         }
         if let Some(r::Value::List(children)) = prefetched_object {
             if children.len() > 1 {
-                let derived_from_field =
-                    sast::get_derived_from_field(object_type, field_definition)
-                        .expect("only derived fields can lead to multiple children here");
-
-                return Err(QueryExecutionError::AmbiguousDerivedFromResult(
-                    field.position,
-                    field.name.clone(),
-                    object_type.name().to_owned(),
-                    derived_from_field.name.clone(),
-                ));
+                // We expected only one child. For derived fields, this can
+                // happen if there are two entities on the derived field
+                // that have the parent's ID as their derivedFrom field. For
+                // non-derived fields, it means that there are two parents
+                // with the same ID. That can happen if the parent is
+                // mutable when we don't enforce the exclusion constraint on
+                // (id, block_range) for performance reasons
+                let error = match sast::get_derived_from_field(object_type, field_definition) {
+                    Some(derived_from_field) => QueryExecutionError::AmbiguousDerivedFromResult(
+                        field.position,
+                        field.name.clone(),
+                        object_type.name().to_owned(),
+                        derived_from_field.name.clone(),
+                    ),
+                    None => {
+                        let child0_id = child_id(&children[0]);
+                        let child1_id = child_id(&children[1]);
+                        QueryExecutionError::InternalError(format!(
+                            "expected only one child for {}.{} but got {}. One child has id {}, another has id {}",
+                            object_type.name(),
+                            field.name,
+                            children.len(),
+                            child0_id,
+                            child1_id
+                        ))
+                    }
+                };
+                return Err(error);
             } else {
                 Ok(children.into_iter().next().unwrap_or(r::Value::Null))
             }
@@ -358,28 +351,29 @@ impl Resolver for StoreResolver {
         }
     }
 
-    fn resolve_field_stream(
-        &self,
-        schema: &ApiSchema,
-        object_type: &s::ObjectType,
-        field: &a::Field,
-    ) -> result::Result<UnitStream, QueryExecutionError> {
-        // Collect all entities involved in the query field
-        let object_type = schema.object_type(object_type).into();
-        let input_schema = self.store.input_schema()?;
-        let entities =
-            collect_entities_from_query_field(&input_schema, schema, object_type, field)?;
-
-        // Subscribe to the store and return the entity change stream
-        Ok(self.subscription_manager.subscribe_no_payload(entities))
-    }
-
     fn post_process(&self, result: &mut QueryResult) -> Result<(), anyhow::Error> {
         // Post-processing is only necessary for queries with indexing errors, and no query errors.
         if !self.has_non_fatal_errors || result.has_errors() {
             return Ok(());
         }
 
+        // Check if the query only contains debugging fields (_meta, _logs).
+        // If so, don't add indexing errors - these queries are specifically for debugging
+        // failed subgraphs and should work without errors.
+        // Introspection queries (__schema, __type) still get the indexing_error to inform
+        // users the subgraph has issues, but they return data.
+        let only_debugging_fields = result
+            .data()
+            .map(|data| {
+                data.iter()
+                    .all(|(key, _)| key == META_FIELD_NAME || key == LOGS_FIELD_NAME)
+            })
+            .unwrap_or(false);
+
+        if only_debugging_fields {
+            return Ok(());
+        }
+
         // Add the "indexing_error" to the response.
         assert!(result.errors_mut().is_empty());
         *result.errors_mut() = vec![QueryError::IndexingError];
@@ -391,9 +385,10 @@ impl Resolver for StoreResolver {
             ErrorPolicy::Deny => {
                 let mut data = result.take_data();
 
-                // Only keep the _meta, __schema and __type fields from the data
+                // Only keep the _meta, _logs, __schema and __type fields from the data
                 let meta_fields = data.as_mut().and_then(|d| {
                     let meta_field = d.remove(META_FIELD_NAME);
+                    let logs_field = d.remove(LOGS_FIELD_NAME);
                     let schema_field = d.remove(INTROSPECTION_SCHEMA_FIELD_NAME);
                     let type_field = d.remove(INTROSPECTION_TYPE_FIELD_NAME);
 
@@ -403,6 +398,9 @@ impl Resolver for StoreResolver {
                     if let Some(meta_field) = meta_field {
                         meta_fields.push((Word::from(META_FIELD_NAME), meta_field));
                     }
+                    if let Some(logs_field) = logs_field {
+                        meta_fields.push((Word::from(LOGS_FIELD_NAME), logs_field));
+                    }
                     if let Some(schema_field) = schema_field {
                         meta_fields
                             .push((Word::from(INTROSPECTION_SCHEMA_FIELD_NAME), schema_field));
diff --git a/graphql/src/subscription/mod.rs b/graphql/src/subscription/mod.rs
deleted file mode 100644
index d916732aa42..00000000000
--- a/graphql/src/subscription/mod.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-use std::result::Result;
-use std::time::{Duration, Instant};
-
-use graph::components::store::UnitStream;
-use graph::data::graphql::load_manager::LoadManager;
-use graph::schema::ApiSchema;
-use graph::{components::store::SubscriptionManager, prelude::*, schema::ErrorPolicy};
-
-use crate::metrics::GraphQLMetrics;
-use crate::{
-    execution::ast as a,
-    execution::*,
-    prelude::{BlockConstraint, StoreResolver},
-};
-
-/// Options available for subscription execution.
-pub struct SubscriptionExecutionOptions {
-    /// The logger to use during subscription execution.
-    pub logger: Logger,
-
-    /// The store to use.
-    pub store: Arc<dyn QueryStore>,
-
-    pub subscription_manager: Arc<dyn SubscriptionManager>,
-
-    /// Individual timeout for each subscription query.
-    pub timeout: Option<Duration>,
-
-    /// Maximum complexity for a subscription query.
-    pub max_complexity: Option<u64>,
-
-    /// Maximum depth for a subscription query.
-    pub max_depth: u8,
-
-    /// Maximum value for the `first` argument.
-    pub max_first: u32,
-
-    /// Maximum value for the `skip` argument.
-    pub max_skip: u32,
-
-    pub graphql_metrics: Arc<GraphQLMetrics>,
-
-    pub load_manager: Arc<LoadManager>,
-}
-
-pub fn execute_subscription(
-    subscription: Subscription,
-    schema: Arc<ApiSchema>,
-    options: SubscriptionExecutionOptions,
-) -> Result<SubscriptionResult, SubscriptionError> {
-    let query = crate::execution::Query::new(
-        &options.logger,
-        schema,
-        None,
-        subscription.query,
-        options.max_complexity,
-        options.max_depth,
-        options.graphql_metrics.cheap_clone(),
-    )?;
-    execute_prepared_subscription(query, options)
-}
-
-pub(crate) fn execute_prepared_subscription(
-    query: Arc<crate::execution::Query>,
-    options: SubscriptionExecutionOptions,
-) -> Result<SubscriptionResult, SubscriptionError> {
-    if !query.is_subscription() {
-        return Err(SubscriptionError::from(QueryExecutionError::NotSupported(
-            "Only subscriptions are supported".to_string(),
-        )));
-    }
-
-    info!(
-        options.logger,
-        "Execute subscription";
-        "query" => &query.query_text,
-    );
-
-    let source_stream = create_source_event_stream(query.clone(), &options)?;
-    let response_stream = map_source_to_response_stream(query, options, source_stream);
-    Ok(response_stream)
-}
-
-fn create_source_event_stream(
-    query: Arc<crate::execution::Query>,
-    options: &SubscriptionExecutionOptions,
-) -> Result<UnitStream, SubscriptionError> {
-    let resolver = StoreResolver::for_subscription(
-        &options.logger,
-        query.schema.id().clone(),
-        options.store.clone(),
-        options.subscription_manager.cheap_clone(),
-        options.graphql_metrics.cheap_clone(),
-        options.load_manager.cheap_clone(),
-    );
-    let ctx = ExecutionContext {
-        logger: options.logger.cheap_clone(),
-        resolver,
-        query,
-        deadline: None,
-        max_first: options.max_first,
-        max_skip: options.max_skip,
-        cache_status: Default::default(),
-        trace: ENV_VARS.log_sql_timing(),
-    };
-
-    let subscription_type = ctx
-        .query
-        .schema
-        .subscription_type
-        .as_ref()
-        .ok_or(QueryExecutionError::NoRootSubscriptionObjectType)?;
-
-    let field = if ctx.query.selection_set.is_empty() {
-        return Err(SubscriptionError::from(QueryExecutionError::EmptyQuery));
-    } else {
-        match ctx.query.selection_set.single_field() {
-            Some(field) => field,
-            None => {
-                return Err(SubscriptionError::from(
-                    QueryExecutionError::MultipleSubscriptionFields,
-                ));
-            }
-        }
-    };
-
-    resolve_field_stream(&ctx, subscription_type, field)
-}
-
-fn resolve_field_stream(
-    ctx: &ExecutionContext<impl Resolver>,
-    object_type: &s::ObjectType,
-    field: &a::Field,
-) -> Result<UnitStream, SubscriptionError> {
-    ctx.resolver
-        .resolve_field_stream(&ctx.query.schema, object_type, field)
-        .map_err(SubscriptionError::from)
-}
-
-fn map_source_to_response_stream(
-    query: Arc<crate::execution::Query>,
-    options: SubscriptionExecutionOptions,
-    source_stream: UnitStream,
-) -> QueryResultStream {
-    // Create a stream with a single empty event. By chaining this in front
-    // of the real events, we trick the subscription into executing its query
-    // at least once. This satisfies the GraphQL over Websocket protocol
-    // requirement of "respond[ing] with at least one GQL_DATA message", see
-    // https://github.com/apollographql/subscriptions-transport-ws/blob/master/PROTOCOL.md#gql_data
-    let trigger_stream = futures03::stream::once(async {});
-
-    let SubscriptionExecutionOptions {
-        logger,
-        store,
-        subscription_manager,
-        timeout,
-        max_complexity: _,
-        max_depth: _,
-        max_first,
-        max_skip,
-        graphql_metrics,
-        load_manager,
-    } = options;
-
-    trigger_stream
-        .chain(source_stream)
-        .then(move |()| {
-            execute_subscription_event(
-                logger.clone(),
-                store.clone(),
-                subscription_manager.cheap_clone(),
-                query.clone(),
-                timeout,
-                max_first,
-                max_skip,
-                graphql_metrics.cheap_clone(),
-                load_manager.cheap_clone(),
-            )
-            .boxed()
-        })
-        .boxed()
-}
-
-async fn execute_subscription_event(
-    logger: Logger,
-    store: Arc<dyn QueryStore>,
-    subscription_manager: Arc<dyn SubscriptionManager>,
-    query: Arc<crate::execution::Query>,
-    timeout: Option<Duration>,
-    max_first: u32,
-    max_skip: u32,
-    metrics: Arc<GraphQLMetrics>,
-    load_manager: Arc<LoadManager>,
-) -> Arc<QueryResult> {
-    async fn make_resolver(
-        store: Arc<dyn QueryStore>,
-        logger: &Logger,
-        subscription_manager: Arc<dyn SubscriptionManager>,
-        query: &Arc<crate::execution::Query>,
-        metrics: Arc<GraphQLMetrics>,
-        load_manager: Arc<LoadManager>,
-    ) -> Result<StoreResolver, QueryExecutionError> {
-        let state = store.deployment_state().await?;
-        StoreResolver::at_block(
-            logger,
-            store,
-            &state,
-            subscription_manager,
-            BlockConstraint::Latest,
-            ErrorPolicy::Deny,
-            query.schema.id().clone(),
-            metrics,
-            load_manager,
-        )
-        .await
-    }
-
-    let resolver = match make_resolver(
-        store,
-        &logger,
-        subscription_manager,
-        &query,
-        metrics,
-        load_manager,
-    )
-    .await
-    {
-        Ok(resolver) => resolver,
-        Err(e) => return Arc::new(e.into()),
-    };
-
-    let block_ptr = resolver.block_ptr.as_ref().map(Into::into);
-
-    // Create a fresh execution context with deadline.
-    let ctx = Arc::new(ExecutionContext {
-        logger,
-        resolver,
-        query,
-        deadline: timeout.map(|t| Instant::now() + t),
-        max_first,
-        max_skip,
-        cache_status: Default::default(),
-        trace: ENV_VARS.log_sql_timing(),
-    });
-
-    let subscription_type = match ctx.query.schema.subscription_type.as_ref() {
-        Some(t) => t.cheap_clone(),
-        None => return Arc::new(QueryExecutionError::NoRootSubscriptionObjectType.into()),
-    };
-
-    execute_root_selection_set(
-        ctx.cheap_clone(),
-        ctx.query.selection_set.cheap_clone(),
-        subscription_type.into(),
-        block_ptr,
-    )
-    .await
-}
diff --git a/graphql/src/values/coercion.rs b/graphql/src/values/coercion.rs
index 343c7264494..bd0bacbf677 100644
--- a/graphql/src/values/coercion.rs
+++ b/graphql/src/values/coercion.rs
@@ -1,5 +1,6 @@
+use graph::data::store::scalar::Timestamp;
 use graph::prelude::s::{EnumType, InputValue, ScalarType, Type, TypeDefinition};
-use graph::prelude::{q, r, QueryExecutionError};
+use graph::prelude::{QueryExecutionError, q, r};
 use graph::schema;
 use std::collections::BTreeMap;
 use std::convert::TryFrom;
@@ -36,7 +37,7 @@ impl MaybeCoercible<ScalarType> for q::Value {
             ("BigDecimal", q::Value::String(s)) => Ok(r::Value::String(s)),
             ("Int", q::Value::Int(num)) => {
                 let n = num.as_i64().ok_or_else(|| q::Value::Int(num.clone()))?;
-                if i32::min_value() as i64 <= n && n <= i32::max_value() as i64 {
+                if i32::MIN as i64 <= n && n <= i32::MAX as i64 {
                     Ok(r::Value::Int((n as i32).into()))
                 } else {
                     Err(q::Value::Int(num))
@@ -46,6 +47,10 @@ impl MaybeCoercible<ScalarType> for q::Value {
                 let n = num.as_i64().ok_or_else(|| q::Value::Int(num.clone()))?;
                 Ok(r::Value::Int(n))
             }
+            ("Timestamp", q::Value::String(str)) => {
+                let ts = Timestamp::parse_timestamp(&str).map_err(|_| q::Value::String(str))?;
+                Ok(r::Value::Timestamp(ts))
+            }
             ("String", q::Value::String(s)) => Ok(r::Value::String(s)),
             ("ID", q::Value::String(s)) => Ok(r::Value::String(s)),
             ("ID", q::Value::Int(n)) => Ok(r::Value::String(
@@ -83,7 +88,7 @@ fn coerce_to_definition<'a>(
                     let def = t
                         .fields
                         .iter()
-                        .find(|f| f.name == &*name)
+                        .find(|f| f.name == *name)
                         .ok_or_else(|| object_for_error.clone())?;
                     coerced_object.insert(
                         name.clone(),
@@ -206,22 +211,20 @@ pub(crate) fn coerce_value<'a>(
 
 #[cfg(test)]
 mod tests {
-    use graph::prelude::r::Value;
-    use graphql_parser::schema::{EnumType, EnumValue, ScalarType, TypeDefinition};
-    use graphql_parser::Pos;
+    use graph::prelude::{r::Value, s};
 
     use super::coerce_to_definition;
 
     #[test]
     fn coercion_using_enum_type_definitions_is_correct() {
-        let enum_type = TypeDefinition::Enum(EnumType {
+        let enum_type = s::TypeDefinition::Enum(s::EnumType {
             name: "Enum".to_string(),
             description: None,
             directives: vec![],
-            position: Pos::default(),
-            values: vec![EnumValue {
+            position: s::Pos::default(),
+            values: vec![s::EnumValue {
                 name: "ValidVariant".to_string(),
-                position: Pos::default(),
+                position: s::Pos::default(),
                 description: None,
                 directives: vec![],
             }],
@@ -255,11 +258,11 @@ mod tests {
 
     #[test]
     fn coercion_using_boolean_type_definitions_is_correct() {
-        let bool_type = TypeDefinition::Scalar(ScalarType {
+        let bool_type = s::TypeDefinition::Scalar(s::ScalarType {
             name: "Boolean".to_string(),
             description: None,
             directives: vec![],
-            position: Pos::default(),
+            position: s::Pos::default(),
         });
         let resolver = |_: &str| Some(&bool_type);
 
@@ -284,7 +287,8 @@ mod tests {
 
     #[test]
     fn coercion_using_big_decimal_type_definitions_is_correct() {
-        let big_decimal_type = TypeDefinition::Scalar(ScalarType::new("BigDecimal".to_string()));
+        let big_decimal_type =
+            s::TypeDefinition::Scalar(s::ScalarType::new("BigDecimal".to_string()));
         let resolver = |_: &str| Some(&big_decimal_type);
 
         // We can coerce from Value::Float -> TypeDefinition::Scalar(BigDecimal)
@@ -324,7 +328,7 @@ mod tests {
 
     #[test]
     fn coercion_using_string_type_definitions_is_correct() {
-        let string_type = TypeDefinition::Scalar(ScalarType::new("String".to_string()));
+        let string_type = s::TypeDefinition::Scalar(s::ScalarType::new("String".to_string()));
         let resolver = |_: &str| Some(&string_type);
 
         // We can coerce from Value::String -> TypeDefinition::Scalar(String)
@@ -348,7 +352,7 @@ mod tests {
 
     #[test]
     fn coercion_using_id_type_definitions_is_correct() {
-        let string_type = TypeDefinition::Scalar(ScalarType::new("ID".to_owned()));
+        let string_type = s::TypeDefinition::Scalar(s::ScalarType::new("ID".to_owned()));
         let resolver = |_: &str| Some(&string_type);
 
         // We can coerce from Value::String -> TypeDefinition::Scalar(ID)
@@ -379,7 +383,7 @@ mod tests {
 
     #[test]
     fn coerce_big_int_scalar() {
-        let big_int_type = TypeDefinition::Scalar(ScalarType::new("BigInt".to_string()));
+        let big_int_type = s::TypeDefinition::Scalar(s::ScalarType::new("BigInt".to_string()));
         let resolver = |_: &str| Some(&big_int_type);
 
         // We can coerce from Value::String -> TypeDefinition::Scalar(BigInt)
@@ -401,7 +405,7 @@ mod tests {
 
     #[test]
     fn coerce_int8_scalar() {
-        let int8_type = TypeDefinition::Scalar(ScalarType::new("Int8".to_string()));
+        let int8_type = s::TypeDefinition::Scalar(s::ScalarType::new("Int8".to_string()));
         let resolver = |_: &str| Some(&int8_type);
 
         assert_eq!(
@@ -416,7 +420,7 @@ mod tests {
 
     #[test]
     fn coerce_bytes_scalar() {
-        let bytes_type = TypeDefinition::Scalar(ScalarType::new("Bytes".to_string()));
+        let bytes_type = s::TypeDefinition::Scalar(s::ScalarType::new("Bytes".to_string()));
         let resolver = |_: &str| Some(&bytes_type);
 
         // We can coerce from Value::String -> TypeDefinition::Scalar(Bytes)
@@ -428,7 +432,7 @@ mod tests {
 
     #[test]
     fn coerce_int_scalar() {
-        let int_type = TypeDefinition::Scalar(ScalarType::new("Int".to_string()));
+        let int_type = s::TypeDefinition::Scalar(s::ScalarType::new("Int".to_string()));
         let resolver = |_: &str| Some(&int_type);
 
         assert_eq!(
diff --git a/justfile b/justfile
new file mode 100644
index 00000000000..a05ef141078
--- /dev/null
+++ b/justfile
@@ -0,0 +1,126 @@
+# Display available commands and their descriptions (default target)
+default:
+    @just --list
+
+# Format all Rust code (cargo fmt)
+format *EXTRA_FLAGS:
+    cargo fmt --all {{EXTRA_FLAGS}}
+
+# Run Clippy linting (cargo clippy)
+lint *EXTRA_FLAGS:
+    cargo clippy --all-targets {{EXTRA_FLAGS}}
+
+# Check Rust code (cargo check)
+check *EXTRA_FLAGS:
+    cargo check {{EXTRA_FLAGS}}
+
+# Check all workspace members, all their targets and all their features
+check-all:
+    cargo check --workspace --all-features --all-targets
+
+# Build graph-node (cargo build --bin graph-node)
+build *EXTRA_FLAGS:
+    cargo build --bin graph-node {{EXTRA_FLAGS}}
+
+# Build both graph-node and gnd binaries
+build-all *EXTRA_FLAGS:
+    cargo build --bin graph-node --bin gnd {{EXTRA_FLAGS}}
+
+_cargo-test *ARGS:
+    #!/usr/bin/env bash
+    set -e # Exit on error
+
+    # Ensure that the `THEGRAPH_STORE_POSTGRES_DIESEL_URL` environment variable is set.
+    if [ -z "$THEGRAPH_STORE_POSTGRES_DIESEL_URL" -a -z "$GRAPH_NODE_TEST_CONFIG" ]; then
+        echo "error: Neither THEGRAPH_STORE_POSTGRES_DIESEL_URL nor GRAPH_NODE_TEST_CONFIG is set"
+        exit 1
+    fi
+
+    cargo test {{ARGS}}
+
+# Run all tests (unit and integration)
+test *EXTRA_FLAGS:
+    @just _cargo-test {{EXTRA_FLAGS}} --workspace -- --nocapture
+
+# Run unit tests
+test-unit *EXTRA_FLAGS:
+    @just _cargo-test {{EXTRA_FLAGS}} --workspace --exclude graph-tests -- --nocapture
+
+# Run runner tests
+test-runner *EXTRA_FLAGS:
+    @just _cargo-test {{EXTRA_FLAGS}} --package graph-tests --test runner_tests -- --nocapture
+
+# Run integration tests
+test-integration *EXTRA_FLAGS:
+    #!/usr/bin/env bash
+    set -e # Exit on error
+
+    # Build graph-node and gnd binaries
+    cargo build --bin graph-node --bin gnd
+
+    just _cargo-test {{EXTRA_FLAGS}} --package graph-tests --test integration_tests -- --nocapture
+
+# Run gnd CLI integration tests (deployment workflow with gnd as CLI)
+# Prerequisites: nix run .#integration (PostgreSQL:3011, IPFS:3001, Anvil:3021)
+test-gnd-cli *EXTRA_FLAGS:
+    #!/usr/bin/env bash
+    set -e # Exit on error
+
+    # Build graph-node and gnd binaries
+    cargo build --bin graph-node --bin gnd
+
+    # Set GRAPH_CLI to use gnd binary
+    export GRAPH_CLI="../target/debug/gnd"
+
+    echo "Running gnd CLI integration tests with GRAPH_CLI=$GRAPH_CLI"
+
+    cargo test {{EXTRA_FLAGS}} --package graph-tests --test gnd_cli_tests -- --nocapture
+
+# Run gnd standalone command tests (init, add, build - no Graph Node required)
+test-gnd-commands *EXTRA_FLAGS:
+    #!/usr/bin/env bash
+    set -e # Exit on error
+
+    # Build gnd binary
+    cargo build --bin gnd
+
+    echo "Running gnd standalone command tests"
+
+    cargo test {{EXTRA_FLAGS}} --package gnd --test cli_commands -- --nocapture
+
+# Run gnd test runner tests (requires asc in PATH, uses pgtemp for PostgreSQL)
+test-gnd-test *EXTRA_FLAGS:
+    #!/usr/bin/env bash
+    set -e # Exit on error
+
+    # Build gnd binary
+    cargo build --bin gnd
+
+    echo "Running gnd test runner tests"
+
+    cargo test {{EXTRA_FLAGS}} --package gnd --test gnd_test -- --nocapture
+
+# Clean workspace (cargo clean)
+clean:
+    cargo clean
+
+compile-contracts:
+    #!/usr/bin/env bash
+    set -e # Exit on error
+
+    if ! command -v "forge" &> /dev/null; then
+        echo "Error: forge must be on your path"
+        exit 1
+    fi
+
+    cd tests/contracts
+
+    forge build
+
+    mkdir -p abis
+    for c in src/*.sol
+    do
+        contract=$(basename $c .sol)
+        echo $contract
+        forge inspect --json "$contract" abi > "abis/$contract.json"
+    done
diff --git a/nix/anvil.nix b/nix/anvil.nix
new file mode 100644
index 00000000000..0c4925b6512
--- /dev/null
+++ b/nix/anvil.nix
@@ -0,0 +1,109 @@
+{
+  pkgs,
+  lib,
+  name,
+  config,
+  ...
+}: {
+  options = {
+    package = lib.mkOption {
+      type = lib.types.package;
+      description = "Foundry package containing anvil";
+    };
+
+    port = lib.mkOption {
+      type = lib.types.port;
+      default = 8545;
+      description = "Port for Anvil RPC server";
+    };
+
+    timestamp = lib.mkOption {
+      type = lib.types.int;
+      default = 1743944919;
+      description = "Timestamp for the genesis block";
+    };
+
+    gasLimit = lib.mkOption {
+      type = lib.types.int;
+      default = 100000000000;
+      description = "Gas limit for the genesis block";
+    };
+
+    baseFee = lib.mkOption {
+      type = lib.types.int;
+      default = 1;
+      description = "Base fee for the genesis block";
+    };
+
+    blockTime = lib.mkOption {
+      type = lib.types.nullOr lib.types.int;
+      default = null;
+      description = "Block time in seconds. Null means instant mining.";
+    };
+
+    state = lib.mkOption {
+      type = lib.types.nullOr lib.types.str;
+      default = null;
+      description = "Path to state file (loads on start, saves on exit)";
+    };
+
+    stateInterval = lib.mkOption {
+      type = lib.types.nullOr lib.types.int;
+      default = null;
+      description = "Interval in seconds to dump state to disk. Useful when graceful shutdown isn't guaranteed.";
+    };
+
+    preserveHistoricalStates = lib.mkOption {
+      type = lib.types.bool;
+      default = false;
+      description = "Preserve historical state snapshots when dumping. Enables RPC calls for older blocks after state reload.";
+    };
+  };
+
+  config = {
+    outputs.settings.processes.${name} = {
+      command = let
+        stateDir =
+          if config.state != null
+          then builtins.dirOf config.state
+          else null;
+        mkdirCmd =
+          if stateDir != null
+          then "mkdir -p ${stateDir} && "
+          else "";
+      in
+        mkdirCmd
+        + builtins.concatStringsSep " " (lib.filter (s: s != "") [
+          "${lib.getExe' config.package "anvil"}"
+          "--gas-limit ${toString config.gasLimit}"
+          "--base-fee ${toString config.baseFee}"
+          "--timestamp ${toString config.timestamp}"
+          "--port ${toString config.port}"
+          (lib.optionalString (config.blockTime != null) "--block-time ${toString config.blockTime}")
+          (lib.optionalString (config.state != null) "--state ${config.state}")
+          (lib.optionalString (config.stateInterval != null) "--state-interval ${toString config.stateInterval}")
+          (lib.optionalString config.preserveHistoricalStates "--preserve-historical-states")
+        ]);
+
+      availability = {
+        restart = "on_failure";
+      };
+
+      shutdown = {
+        command = "kill -TERM $${PROCESS_PID}";
+        timeout_seconds = 10;
+      };
+
+      readiness_probe = {
+        exec = {
+          command = "nc -z localhost ${toString config.port}";
+        };
+        initial_delay_seconds = 3;
+        period_seconds = 2;
+        timeout_seconds = 5;
+        success_threshold = 1;
+        failure_threshold = 10;
+      };
+    };
+  };
+}
diff --git a/nix/ipfs.nix b/nix/ipfs.nix
new file mode 100644
index 00000000000..c5bf407cc29
--- /dev/null
+++ b/nix/ipfs.nix
@@ -0,0 +1,59 @@
+{
+  pkgs,
+  lib,
+  name,
+  config,
+  ...
+}: {
+  options = {
+    package = lib.mkPackageOption pkgs "kubo" {};
+
+    port = lib.mkOption {
+      type = lib.types.port;
+      default = 5001;
+      description = "Port for IPFS API";
+    };
+
+    gateway = lib.mkOption {
+      type = lib.types.port;
+      default = 8080;
+      description = "Port for IPFS gateway";
+    };
+  };
+
+  config = {
+    outputs.settings.processes.${name} = {
+      command = ''
+        export IPFS_PATH="${config.dataDir}"
+        if [ ! -f "${config.dataDir}/config" ]; then
+          mkdir -p "${config.dataDir}"
+          ${lib.getExe config.package} init
+          ${lib.getExe config.package} config Addresses.API /ip4/127.0.0.1/tcp/${toString config.port}
+          ${lib.getExe config.package} config Addresses.Gateway /ip4/127.0.0.1/tcp/${toString config.gateway}
+        fi
+        ${lib.getExe config.package} daemon --offline
+      '';
+
+      environment = {
+        IPFS_PATH = config.dataDir;
+      };
+
+      availability = {
+        restart = "always";
+      };
+
+      readiness_probe = {
+        http_get = {
+          host = "localhost";
+          port = config.port;
+          path = "/version";
+        };
+        initial_delay_seconds = 5;
+        period_seconds = 3;
+        timeout_seconds = 10;
+        success_threshold = 1;
+        failure_threshold = 10;
+      };
+    };
+  };
+}
diff --git a/node/Cargo.toml b/node/Cargo.toml
index 0c8999ea0c3..b08fae8e53e 100644
--- a/node/Cargo.toml
+++ b/node/Cargo.toml
@@ -13,33 +13,38 @@ name = "graphman"
 path = "src/bin/manager.rs"
 
 [dependencies]
-clap = { version = "3.2.25", features = ["derive", "env"] }
-env_logger = "0.10.1"
-git-testament = "0.2"
-graphql-parser = "0.4.0"
-futures = { version = "0.3.1", features = ["compat"] }
-lazy_static = "1.2.0"
-url = "2.5.0"
+anyhow = { workspace = true }
+env_logger = { workspace = true }
+clap.workspace = true
+git-testament = { workspace = true }
+itertools = { workspace = true }
+lazy_static = { workspace = true }
+url = { workspace = true }
 graph = { path = "../graph" }
 graph-core = { path = "../core" }
-graph-chain-arweave = { path = "../chain/arweave" }
 graph-chain-ethereum = { path = "../chain/ethereum" }
 graph-chain-near = { path = "../chain/near" }
-graph-chain-cosmos = { path = "../chain/cosmos" }
-graph-chain-substreams = { path = "../chain/substreams" }
-graph-chain-starknet = { path = "../chain/starknet" }
 graph-graphql = { path = "../graphql" }
-graph-runtime-wasm = { path = "../runtime/wasm" }
 graph-server-http = { path = "../server/http" }
 graph-server-index-node = { path = "../server/index-node" }
 graph-server-json-rpc = { path = "../server/json-rpc" }
-graph-server-websocket = { path = "../server/websocket" }
 graph-server-metrics = { path = "../server/metrics" }
 graph-store-postgres = { path = "../store/postgres" }
-serde = { version = "1.0.126", features = ["derive", "rc"] }
-shellexpand = "3.1.0"
-termcolor = "1.4.0"
-diesel = "1.4.8"
-http = "0.2.5" # must be compatible with the version rust-web3 uses
-prometheus = { version = "0.13.3", features = ["push"] }
-json-structural-diff = { version = "0.1", features = ["colorize"] }
+graphman-server = { workspace = true }
+graphman = { workspace = true }
+serde = { workspace = true }
+shellexpand = "3.1.2"
+termcolor = "1.4.1"
+tokio = { workspace = true }
+diesel = { workspace = true }
+diesel-async = { workspace = true }
+prometheus = { version = "0.14.0", features = ["push"] }
+json-structural-diff = { version = "0.2", features = ["colorize"] }
+indicatif = { workspace = true }
+console = { workspace = true }
+
+# Dependencies related to Amp subgraphs
+tokio-util.workspace = true
+
+[lints]
+workspace = true
diff --git a/node/resources/tests/full_config.toml b/node/resources/tests/full_config.toml
index 1f907539194..6292770a087 100644
--- a/node/resources/tests/full_config.toml
+++ b/node/resources/tests/full_config.toml
@@ -45,15 +45,26 @@ ingestor = "index_0"
 
 [chains.mainnet]
 shard = "primary"
+amp = "ethereum-mainnet"
 provider = [
   { label = "mainnet-0", url = "http://rpc.mainnet.io", features = ["archive", "traces"] },
   { label = "mainnet-1", details = { type = "web3call", url = "http://rpc.mainnet.io", features = ["archive", "traces"] }},
+  { label = "mainnet-2", details = { type = "web3", url = "http://rpc.mainnet.io", features = ["archive", "compression/gzip"] }},
   { label = "firehose", details = { type = "firehose", url = "http://localhost:9000", features = [] }},
-  { label = "substreams", details = { type = "substreams", url = "http://localhost:9000", features = [] }},
 ]
 
 [chains.ropsten]
 shard = "primary"
+json_rpc_timeout = 60
+request_retries = 5
+max_block_range_size = 500
+block_batch_size = 5
+block_ptr_batch_size = 10
+max_event_only_range = 200
+target_triggers_per_block_range = 50
+get_logs_max_contracts = 1000
+block_ingestor_max_concurrent_json_rpc_calls = 500
+genesis_block_number = 0
 provider = [
   { label = "ropsten-0", url = "http://rpc.ropsten.io", transport = "rpc", features = ["archive", "traces"] }
 ]
@@ -69,3 +80,8 @@ shard = "primary"
 provider = [
   { label = "kovan-0", url = "http://rpc.kovan.io", transport = "ws", features = [] }
 ]
+
+[log_store]
+backend = "file"
+directory = "/var/log/graph-node/subgraph-logs"
+retention_hours = 72
diff --git a/node/src/bin/manager.rs b/node/src/bin/manager.rs
index 4bf6c1e85d5..1053c90e300 100644
--- a/node/src/bin/manager.rs
+++ b/node/src/bin/manager.rs
@@ -2,37 +2,39 @@ use clap::{Parser, Subcommand};
 use config::PoolSize;
 use git_testament::{git_testament, render_testament};
 use graph::bail;
+use graph::blockchain::BlockHash;
+use graph::cheap_clone::CheapClone;
+use graph::components::network_provider::ChainName;
 use graph::endpoint::EndpointMetrics;
 use graph::env::ENV_VARS;
 use graph::log::logger_with_levels;
-use graph::prelude::{MetricsRegistry, BLOCK_NUMBER_MAX};
+use graph::prelude::{BLOCK_NUMBER_MAX, BlockNumber, MetricsRegistry};
 use graph::{data::graphql::load_manager::LoadManager, prelude::chrono, prometheus::Registry};
 use graph::{
     prelude::{
-        anyhow::{self, Context as AnyhowContextTrait},
-        info, tokio, Logger, NodeId,
+        Logger, NodeId,
+        anyhow::{self, Context as AnyhowContextTrait, anyhow},
+        info, tokio,
     },
     url::Url,
 };
-use graph_chain_ethereum::{EthereumAdapter, EthereumNetworks};
+use graph_chain_ethereum::EthereumAdapter;
 use graph_graphql::prelude::GraphQlRunner;
 use graph_node::config::{self, Config as Cfg};
 use graph_node::manager::color::Terminal;
 use graph_node::manager::commands;
+use graph_node::network_setup::Networks;
 use graph_node::{
-    chain::create_all_ethereum_networks,
-    manager::{deployment::DeploymentSearch, PanicSubscriptionManager},
-    store_builder::StoreBuilder,
-    MetricsContext,
+    MetricsContext, manager::deployment::DeploymentSearch, store_builder::StoreBuilder,
 };
-use graph_store_postgres::connection_pool::PoolCoordinator;
-use graph_store_postgres::ChainStore;
 use graph_store_postgres::{
-    connection_pool::ConnectionPool, BlockStore, NotificationSender, Shard, Store, SubgraphStore,
-    SubscriptionManager, PRIMARY_SHARD,
+    BlockStore, ChainStore, ConnectionPool, NotificationSender, PRIMARY_SHARD, PoolCoordinator,
+    Shard, Store, SubgraphStore, SubscriptionManager,
 };
+use itertools::Itertools;
 use lazy_static::lazy_static;
-use std::collections::BTreeMap;
+use std::env;
+use std::str::FromStr;
 use std::{collections::HashMap, num::ParseIntError, sync::Arc, time::Duration};
 const VERSION_LABEL_KEY: &str = "version";
 
@@ -104,6 +106,15 @@ pub struct Opt {
     pub fork_base: Option<String>,
     #[clap(long, help = "version label, used for prometheus metrics")]
     pub version_label: Option<String>,
+
+    #[clap(
+        long,
+        value_name = "{HOST:PORT|URL}",
+        env = "GRAPH_AMP_FLIGHT_SERVICE_ADDRESS",
+        help = "The address of the Amp Flight gRPC service"
+    )]
+    pub amp_flight_service_address: Option<String>,
+
     #[clap(subcommand)]
     pub cmd: Command,
 }
@@ -139,6 +150,12 @@ pub enum Command {
         /// List only used (current and pending) versions
         #[clap(long, short)]
         used: bool,
+        /// List names only for the active deployment
+        #[clap(long, short)]
+        brief: bool,
+        /// Do not print subgraph names
+        #[clap(long, short = 'N')]
+        no_name: bool,
     },
     /// Manage unused deployments
     ///
@@ -178,16 +195,16 @@ pub enum Command {
         /// The deployment (see `help info`)
         deployment: DeploymentSearch,
     },
-    /// Pause and resume a deployment
+    /// Pause and resume one or multiple deployments
     Restart {
-        /// The deployment (see `help info`)
-        deployment: DeploymentSearch,
+        /// The deployment(s) (see `help info`)
+        deployments: Vec<DeploymentSearch>,
         /// Sleep for this many seconds after pausing subgraphs
         #[clap(
             long,
             short,
             default_value = "20",
-            parse(try_from_str = parse_duration_in_secs)
+            value_parser = parse_duration_in_secs
         )]
         sleep: Duration,
     },
@@ -205,27 +222,27 @@ pub enum Command {
             long,
             short,
             default_value = "20",
-            parse(try_from_str = parse_duration_in_secs)
+            value_parser = parse_duration_in_secs
         )]
         sleep: Duration,
         /// The block hash of the target block
         #[clap(
-            required_unless_present = "start-block",
-            conflicts_with = "start-block",
+            required_unless_present = "start_block",
+            conflicts_with = "start_block",
             long,
             short = 'H'
         )]
         block_hash: Option<String>,
         /// The block number of the target block
         #[clap(
-            required_unless_present = "start-block",
-            conflicts_with = "start-block",
+            required_unless_present = "start_block",
+            conflicts_with = "start_block",
             long,
             short = 'n'
         )]
         block_number: Option<i32>,
         /// The deployments to rewind (see `help info`)
-        #[clap(required = true, min_values = 1)]
+        #[clap(required = true)]
         deployments: Vec<DeploymentSearch>,
     },
     /// Deploy and run an arbitrary subgraph up to a certain block
@@ -290,64 +307,19 @@ pub enum Command {
     #[clap(subcommand)]
     Index(IndexCommand),
 
-    /// Prune a deployment
+    /// Prune subgraphs by removing old entity versions
     ///
     /// Keep only entity versions that are needed to respond to queries at
     /// block heights that are within `history` blocks of the subgraph head;
     /// all other entity versions are removed.
-    ///
-    /// Unless `--once` is given, this setting is permanent and the subgraph
-    /// will periodically be pruned to remove history as the subgraph head
-    /// moves forward.
-    Prune {
-        /// The deployment to prune (see `help info`)
-        deployment: DeploymentSearch,
-        /// Prune by rebuilding tables when removing more than this fraction
-        /// of history. Defaults to GRAPH_STORE_HISTORY_REBUILD_THRESHOLD
-        #[clap(long, short)]
-        rebuild_threshold: Option<f64>,
-        /// Prune by deleting when removing more than this fraction of
-        /// history but less than rebuild_threshold. Defaults to
-        /// GRAPH_STORE_HISTORY_DELETE_THRESHOLD
-        #[clap(long, short)]
-        delete_threshold: Option<f64>,
-        /// How much history to keep in blocks. Defaults to
-        /// GRAPH_MIN_HISTORY_BLOCKS
-        #[clap(long, short = 'y')]
-        history: Option<usize>,
-        /// Prune only this once
-        #[clap(long, short)]
-        once: bool,
-    },
+    #[clap(subcommand)]
+    Prune(PruneCommand),
 
     /// General database management
     #[clap(subcommand)]
     Database(DatabaseCommand),
 
-    /// Delete a deployment and all it's indexed data
-    ///
-    /// The deployment can be specified as either a subgraph name, an IPFS
-    /// hash `Qm..`, or the database namespace `sgdNNN`. Since the same IPFS
-    /// hash can be deployed in multiple shards, it is possible to specify
-    /// the shard by adding `:shard` to the IPFS hash.
-    Drop {
-        /// The deployment identifier
-        deployment: DeploymentSearch,
-        /// Search only for current version
-        #[clap(long, short)]
-        current: bool,
-        /// Search only for pending versions
-        #[clap(long, short)]
-        pending: bool,
-        /// Search only for used (current and pending) versions
-        #[clap(long, short)]
-        used: bool,
-        /// Skip confirmation prompt
-        #[clap(long, short)]
-        force: bool,
-    },
-
-    // Deploy a subgraph
+    /// Deploy a subgraph
     Deploy {
         name: DeploymentSearch,
         deployment: DeploymentSearch,
@@ -355,10 +327,51 @@ pub enum Command {
         /// The url of the graph-node
         #[clap(long, short, default_value = "http://localhost:8020")]
         url: String,
+    },
 
-        /// Create the subgraph name if it does not exist
-        #[clap(long, short)]
-        create: bool,
+    /// Dump a subgraph deployment into a directory
+    ///
+    /// EXPERIMENTAL - NOT FOR PRODUCTION USE
+    ///
+    /// This will create a dump of the subgraph deployment in the specified
+    /// directory. The dump includes the subgraph manifest, the mapping, and
+    /// the data in the database as parquet files. The dump can be used to
+    /// restore the subgraph deployment later with the `restore` command.
+    Dump {
+        /// The deployment (see `help info`)
+        deployment: DeploymentSearch,
+        /// The name of the directory to dump to
+        directory: String,
+    },
+
+    /// Restore a subgraph deployment from a dump directory
+    ///
+    /// EXPERIMENTAL - NOT FOR PRODUCTION USE
+    ///
+    /// Restore a subgraph deployment from a dump created with the `dump`
+    /// command.
+    Restore {
+        /// Path to the dump directory
+        directory: String,
+        /// The database shard to restore into. When not given, use the
+        /// deployment rules to determine the shard, or default to the
+        /// primary shard if no rules match. This option is required when
+        /// using `--add`
+        #[clap(long)]
+        shard: Option<String>,
+        /// Subgraph name for deployment rule matching and node assignment.
+        /// If omitted, uses an existing name from the database; errors if none found.
+        #[clap(long)]
+        name: Option<String>,
+        /// Drop and recreate if the deployment already exists in the target shard
+        #[clap(long, conflicts_with_all = ["add", "force"])]
+        replace: bool,
+        /// Create a copy in a shard that doesn't have this deployment (requires --shard)
+        #[clap(long, conflicts_with_all = ["replace", "force"])]
+        add: bool,
+        /// Restore no matter what: replace if exists in target shard, add if not
+        #[clap(long, conflicts_with_all = ["replace", "add"])]
+        force: bool,
     },
 }
 
@@ -376,8 +389,12 @@ pub enum UnusedCommand {
     /// List unused deployments
     List {
         /// Only list unused deployments that still exist
-        #[clap(short, long)]
+        #[clap(short, long, conflicts_with = "deployment")]
         existing: bool,
+
+        /// Deployment
+        #[clap(short, long)]
+        deployment: Option<DeploymentSearch>,
     },
     /// Update and record currently unused deployments
     Record,
@@ -431,6 +448,15 @@ pub enum ConfigCommand {
         features: String,
         network: String,
     },
+
+    /// Run all available provider checks against all providers.
+    CheckProviders {
+        /// Maximum duration of all provider checks for a provider.
+        ///
+        /// Defaults to 60 seconds.
+        timeout_seconds: Option<u64>,
+    },
+
     /// Show subgraph-specific settings
     ///
     /// GRAPH_EXPERIMENTAL_SUBGRAPH_SETTINGS can add a file that contains
@@ -446,14 +472,8 @@ pub enum ConfigCommand {
 pub enum ListenCommand {
     /// Listen only to assignment events
     Assignments,
-    /// Listen to events for entities in a specific deployment
-    Entities {
-        /// The deployment (see `help info`).
-        deployment: DeploymentSearch,
-        /// The entity types for which to print change notifications
-        entity_types: Vec<String>,
-    },
 }
+
 #[derive(Clone, Debug, Subcommand)]
 pub enum CopyCommand {
     /// Create a copy of an existing subgraph
@@ -530,41 +550,82 @@ pub enum ChainCommand {
         #[clap(subcommand)] // Note that we mark a field as a subcommand
         method: CheckBlockMethod,
         /// Chain name (must be an existing chain, see 'chain list')
-        #[clap(empty_values = false)]
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
         chain_name: String,
     },
     /// Truncates the whole block cache for the given chain.
     Truncate {
         /// Chain name (must be an existing chain, see 'chain list')
-        #[clap(empty_values = false)]
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
         chain_name: String,
         /// Skips confirmation prompt
         #[clap(long, short)]
         force: bool,
     },
 
+    /// Update the genesis block hash for a chain
+    UpdateGenesis {
+        #[clap(long, short)]
+        force: bool,
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
+        block_hash: String,
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
+        chain_name: String,
+    },
+
+    /// Change the block cache shard for a chain
+    ChangeShard {
+        /// Chain name (must be an existing chain, see 'chain list')
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
+        chain_name: String,
+        /// Shard name
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
+        shard: String,
+    },
+
     /// Execute operations on call cache.
     CallCache {
         #[clap(subcommand)]
         method: CallCacheCommand,
         /// Chain name (must be an existing chain, see 'chain list')
-        #[clap(empty_values = false)]
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
         chain_name: String,
     },
+
+    /// Ingest a block into the block cache.
+    ///
+    /// This will overwrite any blocks we may already have in the block
+    /// cache, and can therefore be used to get rid of duplicate blocks in
+    /// the block cache as well as making sure that a certain block is in
+    /// the cache
+    Ingest {
+        /// The name of the chain
+        name: String,
+        /// The block number to ingest
+        number: BlockNumber,
+    },
 }
 
 #[derive(Clone, Debug, Subcommand)]
 pub enum CallCacheCommand {
     /// Remove the call cache of the specified chain.
     ///
-    /// Either remove entries in the range `--from` and `--to`, or remove
-    /// the entire cache with `--remove-entire-cache`. Removing the entire
+    /// Either remove entries in the range `--from` and `--to`,
+    /// remove the cache for contracts that have not been accessed for the specified duration --ttl_days,
+    /// or remove the entire cache with `--remove-entire-cache`. Removing the entire
     /// cache can reduce indexing performance significantly and should
     /// generally be avoided.
     Remove {
         /// Remove the entire cache
         #[clap(long, conflicts_with_all = &["from", "to"])]
         remove_entire_cache: bool,
+        /// Remove the cache for contracts that have not been accessed in the last <TTL_DAYS> days
+        #[clap(long, conflicts_with_all = &["from", "to", "remove-entire-cache"], value_parser = clap::value_parser!(u32).range(1..))]
+        ttl_days: Option<u32>,
+        /// Maximum number of contracts to evict. When set, the effective TTL
+        /// is increased so that at most this many contracts are deleted.
+        #[clap(long, requires = "ttl_days")]
+        max_contracts: Option<usize>,
         /// Starting block number
         #[clap(long, short, conflicts_with = "remove-entire-cache", requires = "to")]
         from: Option<i32>,
@@ -647,6 +708,67 @@ pub enum StatsCommand {
     },
 }
 
+#[derive(Clone, Debug, Subcommand)]
+pub enum PruneCommand {
+    /// Prune a deployment in the foreground
+    ///
+    /// Unless `--once` is given, this setting is permanent and the subgraph
+    /// will periodically be pruned to remove history as the subgraph head
+    /// moves forward.
+    Run {
+        /// The deployment to prune (see `help info`)
+        deployment: DeploymentSearch,
+        /// Prune by rebuilding tables when removing more than this fraction
+        /// of history. Defaults to GRAPH_STORE_HISTORY_REBUILD_THRESHOLD
+        #[clap(long, short)]
+        rebuild_threshold: Option<f64>,
+        /// Prune by deleting when removing more than this fraction of
+        /// history but less than rebuild_threshold. Defaults to
+        /// GRAPH_STORE_HISTORY_DELETE_THRESHOLD
+        #[clap(long, short)]
+        delete_threshold: Option<f64>,
+        /// How much history to keep in blocks. Defaults to
+        /// GRAPH_MIN_HISTORY_BLOCKS
+        #[clap(long, short = 'y')]
+        history: Option<usize>,
+        /// Prune only this once
+        #[clap(long, short)]
+        once: bool,
+    },
+    /// Prune a deployment in the background
+    ///
+    /// Set the amount of history the subgraph should retain. The actual
+    /// data removal happens in the background and can be monitored with
+    /// `prune status`. It can take several minutes of the first pruning to
+    /// start, during which time `prune status` will not return any
+    /// information
+    Set {
+        /// The deployment to prune (see `help info`)
+        deployment: DeploymentSearch,
+        /// Prune by rebuilding tables when removing more than this fraction
+        /// of history. Defaults to GRAPH_STORE_HISTORY_REBUILD_THRESHOLD
+        #[clap(long, short)]
+        rebuild_threshold: Option<f64>,
+        /// Prune by deleting when removing more than this fraction of
+        /// history but less than rebuild_threshold. Defaults to
+        /// GRAPH_STORE_HISTORY_DELETE_THRESHOLD
+        #[clap(long, short)]
+        delete_threshold: Option<f64>,
+        /// How much history to keep in blocks. Defaults to
+        /// GRAPH_MIN_HISTORY_BLOCKS
+        #[clap(long, short = 'y')]
+        history: Option<usize>,
+    },
+    /// Show the status of a pruning operation
+    Status {
+        /// The number of the pruning run
+        #[clap(long, short)]
+        run: Option<usize>,
+        /// The deployment to check (see `help info`)
+        deployment: DeploymentSearch,
+    },
+}
+
 #[derive(Clone, Debug, Subcommand)]
 pub enum IndexCommand {
     /// Creates a new database index.
@@ -660,26 +782,26 @@ pub enum IndexCommand {
     /// This command may be time-consuming.
     Create {
         /// The deployment (see `help info`).
-        #[clap(empty_values = false)]
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
         deployment: DeploymentSearch,
         /// The Entity name.
         ///
         /// Can be expressed either in upper camel case (as its GraphQL definition) or in snake case
         /// (as its SQL table name).
-        #[clap(empty_values = false)]
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
         entity: String,
         /// The Field names.
         ///
         /// Each field can be expressed either in camel case (as its GraphQL definition) or in snake
         /// case (as its SQL colmun name).
-        #[clap(min_values = 1, required = true)]
+        #[clap(required = true)]
         fields: Vec<String>,
-        /// The index method. Defaults to `btree`.
+        /// The index method. Defaults to `btree` in general, and to `gist` when the index includes the `block_range` column
         #[clap(
             short, long, default_value = "btree",
-            possible_values = &["btree", "hash", "gist", "spgist", "gin", "brin"]
+            value_parser = clap::builder::PossibleValuesParser::new(&["btree", "hash", "gist", "spgist", "gin", "brin"])
         )]
-        method: String,
+        method: Option<String>,
 
         #[clap(long)]
         /// Specifies a starting block number for creating a partial index.
@@ -704,23 +826,21 @@ pub enum IndexCommand {
         #[clap(long, requires = "sql")]
         if_not_exists: bool,
         ///  The deployment (see `help info`).
-        #[clap(empty_values = false)]
         deployment: DeploymentSearch,
         /// The Entity name.
         ///
         /// Can be expressed either in upper camel case (as its GraphQL definition) or in snake case
         /// (as its SQL table name).
-        #[clap(empty_values = false)]
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
         entity: String,
     },
 
     /// Drops an index for a given deployment, concurrently
     Drop {
         /// The deployment (see `help info`).
-        #[clap(empty_values = false)]
         deployment: DeploymentSearch,
         /// The name of the index to be dropped
-        #[clap(empty_values = false)]
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
         index_name: String,
     },
 }
@@ -787,11 +907,12 @@ pub enum CheckBlockMethod {
 
 impl From<Opt> for config::Opt {
     fn from(opt: Opt) -> Self {
-        let mut config_opt = config::Opt::default();
-        config_opt.config = Some(opt.config);
-        config_opt.store_connection_pool_size = 5;
-        config_opt.node_id = opt.node_id;
-        config_opt
+        config::Opt {
+            config: Some(opt.config),
+            store_connection_pool_size: 5,
+            node_id: opt.node_id,
+            ..Default::default()
+        }
     }
 }
 
@@ -864,7 +985,7 @@ impl Context {
 
     fn primary_pool(self) -> ConnectionPool {
         let primary = self.config.primary_store();
-        let coord = Arc::new(PoolCoordinator::new(Arc::new(vec![])));
+        let coord = Arc::new(PoolCoordinator::new(&self.logger, Arc::new(vec![])));
         let pool = StoreBuilder::main_pool(
             &self.logger,
             &self.node_id,
@@ -877,8 +998,8 @@ impl Context {
         pool
     }
 
-    fn subgraph_store(self) -> Arc<SubgraphStore> {
-        self.store_and_pools().0.subgraph_store()
+    async fn subgraph_store(self) -> Arc<SubgraphStore> {
+        self.store_and_pools().await.0.subgraph_store()
     }
 
     fn subscription_manager(&self) -> Arc<SubscriptionManager> {
@@ -891,20 +1012,13 @@ impl Context {
         ))
     }
 
-    fn primary_and_subscription_manager(self) -> (ConnectionPool, Arc<SubscriptionManager>) {
-        let mgr = self.subscription_manager();
-        let primary_pool = self.primary_pool();
-
-        (primary_pool, mgr)
-    }
-
-    fn store(self) -> Arc<Store> {
-        let (store, _) = self.store_and_pools();
+    async fn store(&self) -> Arc<Store> {
+        let (store, _) = self.store_and_pools().await;
         store
     }
 
-    fn pools(self) -> HashMap<Shard, ConnectionPool> {
-        let (_, pools) = self.store_and_pools();
+    async fn pools(self) -> HashMap<Shard, ConnectionPool> {
+        let (_, pools) = self.store_and_pools().await;
         pools
     }
 
@@ -919,12 +1033,12 @@ impl Context {
         .await
     }
 
-    fn store_and_pools(self) -> (Arc<Store>, HashMap<Shard, ConnectionPool>) {
+    async fn store_and_pools(&self) -> (Arc<Store>, HashMap<Shard, ConnectionPool>) {
         let (subgraph_store, pools, _) = StoreBuilder::make_subgraph_store_and_pools(
             &self.logger,
             &self.node_id,
             &self.config,
-            self.fork_base,
+            self.fork_base.clone(),
             self.registry.clone(),
         );
 
@@ -937,56 +1051,59 @@ impl Context {
             pools.clone(),
             subgraph_store,
             HashMap::default(),
-            BTreeMap::new(),
-            self.registry,
-        );
+            Vec::new(),
+            self.registry.cheap_clone(),
+        )
+        .await;
 
         (store, pools)
     }
 
-    fn store_and_primary(self) -> (Arc<Store>, ConnectionPool) {
-        let (store, pools) = self.store_and_pools();
+    async fn store_and_primary(self) -> (Arc<Store>, ConnectionPool) {
+        let (store, pools) = self.store_and_pools().await;
         let primary = pools.get(&*PRIMARY_SHARD).expect("there is a primary pool");
         (store, primary.clone())
     }
 
-    fn block_store_and_primary_pool(self) -> (Arc<BlockStore>, ConnectionPool) {
-        let (store, pools) = self.store_and_pools();
+    async fn block_store_and_primary_pool(self) -> (BlockStore, ConnectionPool) {
+        let (store, pools) = self.store_and_pools().await;
 
         let primary = pools.get(&*PRIMARY_SHARD).unwrap();
         (store.block_store(), primary.clone())
     }
 
-    fn graphql_runner(self) -> Arc<GraphQlRunner<Store, PanicSubscriptionManager>> {
+    async fn graphql_runner(self) -> Arc<GraphQlRunner<Store>> {
         let logger = self.logger.clone();
         let registry = self.registry.clone();
 
-        let store = self.store();
+        let store = self.store().await;
 
-        let subscription_manager = Arc::new(PanicSubscriptionManager);
         let load_manager = Arc::new(LoadManager::new(&logger, vec![], vec![], registry.clone()));
 
         Arc::new(GraphQlRunner::new(
             &logger,
             store,
-            subscription_manager,
             load_manager,
             registry,
+            Arc::new(graph::components::log_store::NoOpLogStore),
         ))
     }
 
-    async fn ethereum_networks(&self) -> anyhow::Result<EthereumNetworks> {
+    async fn networks(&self) -> anyhow::Result<Networks> {
         let logger = self.logger.clone();
         let registry = self.metrics_registry();
         let metrics = Arc::new(EndpointMetrics::mock());
-        create_all_ethereum_networks(logger, registry, &self.config, metrics).await
+
+        Networks::from_config(logger, &self.config, registry, metrics, &[]).await
     }
 
-    fn chain_store(self, chain_name: &str) -> anyhow::Result<Arc<ChainStore>> {
+    async fn chain_store(self, chain_name: &str) -> anyhow::Result<Arc<ChainStore>> {
         use graph::components::store::BlockStore;
         self.store()
+            .await
             .block_store()
             .chain_store(chain_name)
+            .await
             .ok_or_else(|| anyhow::anyhow!("Could not find a network named '{}'", chain_name))
     }
 
@@ -994,12 +1111,24 @@ impl Context {
         self,
         chain_name: &str,
     ) -> anyhow::Result<(Arc<ChainStore>, Arc<EthereumAdapter>)> {
-        let ethereum_networks = self.ethereum_networks().await?;
-        let chain_store = self.chain_store(chain_name)?;
-        let ethereum_adapter = ethereum_networks
-            .networks
-            .get(chain_name)
-            .and_then(|adapters| adapters.cheapest())
+        let logger = self.logger.clone();
+        let registry = self.metrics_registry();
+        let metrics = Arc::new(EndpointMetrics::mock());
+        let networks = Networks::from_config_for_chain(
+            logger,
+            &self.config,
+            registry,
+            metrics,
+            &[],
+            chain_name,
+        )
+        .await?;
+
+        let chain_store = self.chain_store(chain_name).await?;
+        let ethereum_adapter = networks
+            .ethereum_rpcs(chain_name.into())
+            .cheapest()
+            .await
             .ok_or(anyhow::anyhow!(
                 "Failed to obtain an Ethereum adapter for chain '{}'",
                 chain_name
@@ -1010,6 +1139,12 @@ impl Context {
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
+    graph::tls::install_default_crypto_provider();
+    // Disable load management for graphman commands
+    unsafe {
+        env::set_var("GRAPH_LOAD_THRESHOLD", "0");
+    }
+
     let opt = Opt::parse();
 
     Terminal::set_color_preference(&opt.color);
@@ -1026,7 +1161,6 @@ async fn main() -> anyhow::Result<()> {
     );
 
     let mut config = Cfg::load(&logger, &opt.clone().into()).context("Configuration error")?;
-
     if opt.pool_size > 0 && !opt.cmd.use_configured_pool_size() {
         // Override pool size from configuration
         for shard in config.stores.values_mut() {
@@ -1038,8 +1172,8 @@ async fn main() -> anyhow::Result<()> {
     }
 
     let node = match NodeId::new(&opt.node_id) {
-        Err(()) => {
-            eprintln!("invalid node id: {}", opt.node_id);
+        Err(node_id) => {
+            eprintln!("invalid node id: {}", node_id);
             std::process::exit(1);
         }
         Ok(node) => node,
@@ -1079,7 +1213,7 @@ async fn main() -> anyhow::Result<()> {
 
     use Command::*;
     match opt.cmd {
-        TxnSpeed { delay } => commands::txn_speed::run(ctx.primary_pool(), delay),
+        TxnSpeed { delay } => commands::txn_speed::run(ctx.primary_pool(), delay).await,
         Info {
             deployment,
             current,
@@ -1087,37 +1221,39 @@ async fn main() -> anyhow::Result<()> {
             status,
             used,
             all,
+            brief,
+            no_name,
         } => {
-            let (primary, store) = if status {
-                let (store, primary) = ctx.store_and_primary();
-                (primary, Some(store))
-            } else {
-                (ctx.primary_pool(), None)
+            let (store, primary_pool) = ctx.store_and_primary().await;
+
+            let ctx = commands::deployment::info::Context {
+                primary_pool,
+                store,
             };
 
-            match deployment {
-                Some(deployment) => {
-                    commands::info::run(primary, store, deployment, current, pending, used).err();
-                }
-                None => {
-                    if all {
-                        let deployment = DeploymentSearch::All;
-                        commands::info::run(primary, store, deployment, current, pending, used)
-                            .err();
-                    } else {
-                        bail!("Please specify a deployment or use --all to list all deployments");
-                    }
-                }
+            let args = commands::deployment::info::Args {
+                deployment: deployment.map(make_deployment_selector),
+                current,
+                pending,
+                status,
+                used,
+                all,
+                brief,
+                no_name,
             };
-            Ok(())
+
+            commands::deployment::info::run(ctx, args).await
         }
         Unused(cmd) => {
-            let store = ctx.subgraph_store();
+            let store = ctx.subgraph_store().await;
             use UnusedCommand::*;
 
             match cmd {
-                List { existing } => commands::unused_deployments::list(store, existing),
-                Record => commands::unused_deployments::record(store),
+                List {
+                    existing,
+                    deployment,
+                } => commands::unused_deployments::list(store, existing, deployment).await,
+                Record => commands::unused_deployments::record(store).await,
                 Remove {
                     count,
                     deployment,
@@ -1126,6 +1262,7 @@ async fn main() -> anyhow::Result<()> {
                     let count = count.unwrap_or(1_000_000);
                     let older = older.map(|older| chrono::Duration::minutes(older as i64));
                     commands::unused_deployments::remove(store, count, deployment.as_deref(), older)
+                        .await
                 }
             }
         }
@@ -1133,6 +1270,16 @@ async fn main() -> anyhow::Result<()> {
             use ConfigCommand::*;
 
             match cmd {
+                CheckProviders { timeout_seconds } => {
+                    let logger = ctx.logger.clone();
+                    let networks = ctx.networks().await?;
+                    let store = ctx.store().await.block_store();
+                    let timeout = Duration::from_secs(timeout_seconds.unwrap_or(60));
+
+                    commands::provider_checks::execute(&logger, &networks, store, timeout).await;
+
+                    Ok(())
+                }
                 Place { name, network } => {
                     commands::config::place(&ctx.config.deployment, &name, &network)
                 }
@@ -1147,27 +1294,59 @@ async fn main() -> anyhow::Result<()> {
                 Setting { name } => commands::config::setting(&name),
             }
         }
-        Remove { name } => commands::remove::run(ctx.subgraph_store(), &name),
-        Create { name } => commands::create::run(ctx.subgraph_store(), name),
+        Remove { name } => commands::remove::run(ctx.subgraph_store().await, &name).await,
+        Create { name } => commands::create::run(ctx.subgraph_store().await, name).await,
         Unassign { deployment } => {
-            let sender = ctx.notification_sender();
-            commands::assign::unassign(ctx.primary_pool(), &sender, &deployment).await
+            let notifications_sender = ctx.notification_sender();
+            let primary_pool = ctx.primary_pool();
+            let deployment = make_deployment_selector(deployment);
+            commands::deployment::unassign::run(primary_pool, notifications_sender, deployment)
+                .await
         }
         Reassign { deployment, node } => {
-            let sender = ctx.notification_sender();
-            commands::assign::reassign(ctx.primary_pool(), &sender, &deployment, node)
+            let notifications_sender = ctx.notification_sender();
+            let primary_pool = ctx.primary_pool();
+            let deployment = make_deployment_selector(deployment);
+            let node = NodeId::new(node).map_err(|node| anyhow!("invalid node id {:?}", node))?;
+            commands::deployment::reassign::run(
+                primary_pool,
+                notifications_sender,
+                deployment,
+                &node,
+            )
+            .await
         }
         Pause { deployment } => {
-            let sender = ctx.notification_sender();
-            commands::assign::pause_or_resume(ctx.primary_pool(), &sender, &deployment, true)
+            let notifications_sender = ctx.notification_sender();
+            let primary_pool = ctx.primary_pool();
+            let deployment = make_deployment_selector(deployment);
+
+            commands::deployment::pause::run(primary_pool, notifications_sender, deployment).await
         }
         Resume { deployment } => {
-            let sender = ctx.notification_sender();
-            commands::assign::pause_or_resume(ctx.primary_pool(), &sender, &deployment, false)
+            let notifications_sender = ctx.notification_sender();
+            let primary_pool = ctx.primary_pool();
+            let deployment = make_deployment_selector(deployment);
+
+            commands::deployment::resume::run(primary_pool, notifications_sender, deployment).await
         }
-        Restart { deployment, sleep } => {
-            let sender = ctx.notification_sender();
-            commands::assign::restart(ctx.primary_pool(), &sender, &deployment, sleep)
+        Restart { deployments, sleep } => {
+            let notifications_sender = ctx.notification_sender();
+            let primary_pool = ctx.primary_pool();
+
+            for deployment in deployments.into_iter().unique() {
+                let deployment = make_deployment_selector(deployment);
+
+                commands::deployment::restart::run(
+                    primary_pool.clone(),
+                    notifications_sender.clone(),
+                    deployment,
+                    sleep,
+                )
+                .await?;
+            }
+
+            Ok(())
         }
         Rewind {
             force,
@@ -1177,13 +1356,16 @@ async fn main() -> anyhow::Result<()> {
             deployments,
             start_block,
         } => {
-            let (store, primary) = ctx.store_and_primary();
+            let notification_sender = ctx.notification_sender();
+            let (store, primary) = ctx.store_and_primary().await;
+
             commands::rewind::run(
                 primary,
                 store,
                 deployments,
                 block_hash,
                 block_number,
+                &notification_sender,
                 force,
                 sleep,
                 start_block,
@@ -1217,6 +1399,7 @@ async fn main() -> anyhow::Result<()> {
                 network_name,
                 ipfs_url,
                 arweave_url,
+                opt.amp_flight_service_address.clone(),
                 config,
                 metrics_ctx,
                 node_id,
@@ -1229,13 +1412,6 @@ async fn main() -> anyhow::Result<()> {
             use ListenCommand::*;
             match cmd {
                 Assignments => commands::listen::assignments(ctx.subscription_manager()).await,
-                Entities {
-                    deployment,
-                    entity_types,
-                } => {
-                    let (primary, mgr) = ctx.primary_and_subscription_manager();
-                    commands::listen::entities(primary, mgr, &deployment, entity_types).await
-                }
             }
         }
         Copy(cmd) => {
@@ -1250,17 +1426,17 @@ async fn main() -> anyhow::Result<()> {
                     replace,
                 } => {
                     let shards: Vec<_> = ctx.config.stores.keys().cloned().collect();
-                    let (store, primary) = ctx.store_and_primary();
+                    let (store, primary) = ctx.store_and_primary().await;
                     commands::copy::create(
                         store, primary, src, shard, shards, node, offset, activate, replace,
                     )
                     .await
                 }
                 Activate { deployment, shard } => {
-                    commands::copy::activate(ctx.subgraph_store(), deployment, shard)
+                    commands::copy::activate(ctx.subgraph_store().await, deployment, shard).await
                 }
-                List => commands::copy::list(ctx.pools()),
-                Status { dst } => commands::copy::status(ctx.pools(), &dst),
+                List => commands::copy::list(ctx.pools().await).await,
+                Status { dst } => commands::copy::status(ctx.pools().await, &dst).await,
             }
         }
         Query {
@@ -1269,12 +1445,22 @@ async fn main() -> anyhow::Result<()> {
             target,
             query,
             vars,
-        } => commands::query::run(ctx.graphql_runner(), target, query, vars, output, trace).await,
+        } => {
+            commands::query::run(
+                ctx.graphql_runner().await,
+                target,
+                query,
+                vars,
+                output,
+                trace,
+            )
+            .await
+        }
         Chain(cmd) => {
             use ChainCommand::*;
             match cmd {
                 List => {
-                    let (block_store, primary) = ctx.block_store_and_primary_pool();
+                    let (block_store, primary) = ctx.block_store_and_primary_pool().await;
                     commands::chain::list(primary, block_store).await
                 }
                 Info {
@@ -1282,16 +1468,49 @@ async fn main() -> anyhow::Result<()> {
                     reorg_threshold,
                     hashes,
                 } => {
-                    let (block_store, primary) = ctx.block_store_and_primary_pool();
+                    let (block_store, primary) = ctx.block_store_and_primary_pool().await;
                     commands::chain::info(primary, block_store, name, reorg_threshold, hashes).await
                 }
                 Remove { name } => {
-                    let (block_store, primary) = ctx.block_store_and_primary_pool();
-                    commands::chain::remove(primary, block_store, name)
+                    let (block_store, primary) = ctx.block_store_and_primary_pool().await;
+                    commands::chain::remove(primary, block_store, name).await
+                }
+                ChangeShard { chain_name, shard } => {
+                    let (block_store, primary) = ctx.block_store_and_primary_pool().await;
+                    commands::chain::change_block_cache_shard(
+                        primary,
+                        block_store,
+                        chain_name,
+                        shard,
+                    )
+                    .await
                 }
+
+                UpdateGenesis {
+                    force,
+                    block_hash,
+                    chain_name,
+                } => {
+                    let store_builder = ctx.store_builder().await;
+                    let store = ctx.store().await.block_store();
+                    let networks = ctx.networks().await?;
+                    let chain_id = ChainName::from(chain_name);
+                    let block_hash = BlockHash::from_str(&block_hash)?;
+                    commands::chain::update_chain_genesis(
+                        &networks,
+                        store_builder.coord.cheap_clone(),
+                        Box::new(store),
+                        &logger,
+                        chain_id,
+                        block_hash,
+                        force,
+                    )
+                    .await
+                }
+
                 CheckBlocks { method, chain_name } => {
-                    use commands::check_blocks::{by_hash, by_number, by_range};
                     use CheckBlockMethod::*;
+                    use commands::check_blocks::{by_hash, by_number, by_range};
                     let logger = ctx.logger.clone();
                     let (chain_store, ethereum_adapter) =
                         ctx.chain_store_and_adapter(&chain_name).await?;
@@ -1331,8 +1550,8 @@ async fn main() -> anyhow::Result<()> {
                 }
                 Truncate { chain_name, force } => {
                     use commands::check_blocks::truncate;
-                    let chain_store = ctx.chain_store(&chain_name)?;
-                    truncate(chain_store, force)
+                    let chain_store = ctx.chain_store(&chain_name).await?;
+                    truncate(chain_store, force).await
                 }
                 CallCache { method, chain_name } => {
                     match method {
@@ -1340,10 +1559,23 @@ async fn main() -> anyhow::Result<()> {
                             from,
                             to,
                             remove_entire_cache,
+                            ttl_days,
+                            max_contracts,
                         } => {
-                            let chain_store = ctx.chain_store(&chain_name)?;
+                            let chain_store = ctx.chain_store(&chain_name).await?;
+                            if let Some(ttl_days) = ttl_days {
+                                return commands::chain::clear_stale_call_cache(
+                                    chain_store,
+                                    ttl_days as usize,
+                                    max_contracts,
+                                )
+                                .await;
+                            }
+
                             if !remove_entire_cache && from.is_none() && to.is_none() {
-                                bail!("you must specify either --from and --to or --remove-entire-cache");
+                                bail!(
+                                    "you must specify either --from and --to or --remove-entire-cache"
+                                );
                             }
                             let (from, to) = if remove_entire_cache {
                                 (0, BLOCK_NUMBER_MAX)
@@ -1355,6 +1587,12 @@ async fn main() -> anyhow::Result<()> {
                         }
                     }
                 }
+                Ingest { name, number } => {
+                    let logger = ctx.logger.cheap_clone();
+                    let (chain_store, ethereum_adapter) =
+                        ctx.chain_store_and_adapter(&name).await?;
+                    commands::chain::ingest(&logger, chain_store, ethereum_adapter, number).await
+                }
             }
         }
         Stats(cmd) => {
@@ -1365,7 +1603,7 @@ async fn main() -> anyhow::Result<()> {
                     deployment,
                     table,
                 } => {
-                    let (store, primary_pool) = ctx.store_and_primary();
+                    let (store, primary_pool) = ctx.store_and_primary().await;
                     let subgraph_store = store.subgraph_store();
                     commands::stats::account_like(
                         subgraph_store,
@@ -1376,9 +1614,9 @@ async fn main() -> anyhow::Result<()> {
                     )
                     .await
                 }
-                Show { deployment } => commands::stats::show(ctx.pools(), &deployment),
+                Show { deployment } => commands::stats::show(ctx.pools().await, &deployment).await,
                 Analyze { deployment, entity } => {
-                    let (store, primary_pool) = ctx.store_and_primary();
+                    let (store, primary_pool) = ctx.store_and_primary().await;
                     let subgraph_store = store.subgraph_store();
                     commands::stats::analyze(
                         subgraph_store,
@@ -1386,11 +1624,12 @@ async fn main() -> anyhow::Result<()> {
                         deployment,
                         entity.as_deref(),
                     )
+                    .await
                 }
                 Target { deployment } => {
-                    let (store, primary_pool) = ctx.store_and_primary();
+                    let (store, primary_pool) = ctx.store_and_primary().await;
                     let subgraph_store = store.subgraph_store();
-                    commands::stats::target(subgraph_store, primary_pool, &deployment)
+                    commands::stats::target(subgraph_store, primary_pool, &deployment).await
                 }
                 SetTarget {
                     target,
@@ -1400,7 +1639,7 @@ async fn main() -> anyhow::Result<()> {
                     entity,
                     columns,
                 } => {
-                    let (store, primary) = ctx.store_and_primary();
+                    let (store, primary) = ctx.store_and_primary().await;
                     let store = store.subgraph_store();
                     let target = if reset { -1 } else { target as i32 };
                     commands::stats::set_target(
@@ -1412,12 +1651,13 @@ async fn main() -> anyhow::Result<()> {
                         target,
                         no_analyze,
                     )
+                    .await
                 }
             }
         }
         Index(cmd) => {
             use IndexCommand::*;
-            let (store, primary_pool) = ctx.store_and_primary();
+            let (store, primary_pool) = ctx.store_and_primary().await;
             let subgraph_store = store.subgraph_store();
             match cmd {
                 Create {
@@ -1487,60 +1727,88 @@ async fn main() -> anyhow::Result<()> {
                 }
             }
         }
-        Prune {
+        Prune(cmd) => {
+            use PruneCommand::*;
+            match cmd {
+                Run {
+                    deployment,
+                    history,
+                    rebuild_threshold,
+                    delete_threshold,
+                    once,
+                } => {
+                    let (store, primary_pool) = ctx.store_and_primary().await;
+                    let history = history.unwrap_or(ENV_VARS.min_history_blocks.try_into()?);
+                    commands::prune::run(
+                        store,
+                        primary_pool,
+                        deployment,
+                        history,
+                        rebuild_threshold,
+                        delete_threshold,
+                        once,
+                    )
+                    .await
+                }
+                Set {
+                    deployment,
+                    rebuild_threshold,
+                    delete_threshold,
+                    history,
+                } => {
+                    let (store, primary_pool) = ctx.store_and_primary().await;
+                    let history = history.unwrap_or(ENV_VARS.min_history_blocks.try_into()?);
+                    commands::prune::set(
+                        store,
+                        primary_pool,
+                        deployment,
+                        history,
+                        rebuild_threshold,
+                        delete_threshold,
+                    )
+                    .await
+                }
+                Status { run, deployment } => {
+                    let (store, primary_pool) = ctx.store_and_primary().await;
+                    commands::prune::status(store, primary_pool, deployment, run).await
+                }
+            }
+        }
+
+        Deploy {
             deployment,
-            history,
-            rebuild_threshold,
-            delete_threshold,
-            once,
+            name,
+            url,
         } => {
-            let (store, primary_pool) = ctx.store_and_primary();
-            let history = history.unwrap_or(ENV_VARS.min_history_blocks.try_into()?);
-            commands::prune::run(
-                store,
-                primary_pool,
-                deployment,
-                history,
-                rebuild_threshold,
-                delete_threshold,
-                once,
-            )
-            .await
+            let store = ctx.store().await;
+            let subgraph_store = store.subgraph_store();
+
+            commands::deploy::run(subgraph_store, deployment, name, url).await
         }
-        Drop {
+
+        Dump {
             deployment,
-            current,
-            pending,
-            used,
-            force,
+            directory,
         } => {
-            let sender = ctx.notification_sender();
-            let (store, primary_pool) = ctx.store_and_primary();
+            let (store, primary_pool) = ctx.store_and_primary().await;
             let subgraph_store = store.subgraph_store();
 
-            commands::drop::run(
-                primary_pool,
-                subgraph_store,
-                sender,
-                deployment,
-                current,
-                pending,
-                used,
-                force,
-            )
-            .await
+            commands::dump::run(subgraph_store, primary_pool, deployment, directory).await
         }
 
-        Deploy {
-            deployment,
+        Restore {
+            directory,
+            shard,
             name,
-            url,
-            create,
+            replace,
+            add,
+            force,
         } => {
-            let store = ctx.store();
+            let store = ctx.store().await;
             let subgraph_store = store.subgraph_store();
 
-            commands::deploy::run(subgraph_store, deployment, name, url, create).await
+            commands::restore::run(subgraph_store, directory, shard, name, replace, add, force)
+                .await
         }
     }
 }
@@ -1548,3 +1816,16 @@ async fn main() -> anyhow::Result<()> {
 fn parse_duration_in_secs(s: &str) -> Result<Duration, ParseIntError> {
     Ok(Duration::from_secs(s.parse()?))
 }
+
+fn make_deployment_selector(
+    deployment: DeploymentSearch,
+) -> graphman::deployment::DeploymentSelector {
+    use graphman::deployment::DeploymentSelector::*;
+
+    match deployment {
+        DeploymentSearch::Name { name } => Name(name),
+        DeploymentSearch::Hash { hash, shard } => Subgraph { hash, shard },
+        DeploymentSearch::All => All,
+        DeploymentSearch::Deployment { namespace } => Schema(namespace),
+    }
+}
diff --git a/node/src/chain.rs b/node/src/chain.rs
index 6c9946bb66b..824cbf5faeb 100644
--- a/node/src/chain.rs
+++ b/node/src/chain.rs
@@ -1,23 +1,36 @@
-use crate::config::{Config, ProviderDetails};
-use ethereum::{EthereumNetworks, ProviderEthRpcMetrics};
-use futures::future::{join_all, try_join_all};
-use futures::TryFutureExt;
-use graph::anyhow::{bail, Error};
-use graph::blockchain::{Block as BlockchainBlock, BlockchainKind, ChainIdentifier};
+use crate::config::{ChainSettings as ConfigChainSettings, Config, ProviderDetails};
+use crate::network_setup::{
+    AdapterConfiguration, EthAdapterConfig, FirehoseAdapterConfig, Networks,
+};
+use ethereum::ProviderEthRpcMetrics;
+use ethereum::chain::ChainSettings;
+use ethereum::chain::{
+    EthereumAdapterSelector, EthereumBlockRefetcher, EthereumRuntimeAdapterBuilder,
+    EthereumStreamBuilder,
+};
+use ethereum::network::EthereumNetworkAdapter;
+use graph::anyhow::bail;
+use graph::blockchain::client::ChainClient;
+use graph::blockchain::{BlockchainKind, BlockchainMap, ChainIdentifier};
 use graph::cheap_clone::CheapClone;
+use graph::components::network_provider::ChainName;
+use graph::components::store::BlockStore as _;
 use graph::endpoint::EndpointMetrics;
-use graph::firehose::{FirehoseEndpoint, FirehoseNetworks, SubgraphLimit};
-use graph::ipfs_client::IpfsClient;
-use graph::prelude::{anyhow, tokio};
-use graph::prelude::{prost, MetricsRegistry};
-use graph::slog::{debug, error, info, o, Logger};
+use graph::env::{ENV_VARS, EnvVars};
+use graph::firehose::FirehoseEndpoint;
+use graph::futures03::future::try_join_all;
+use graph::itertools::Itertools;
+use graph::log::factory::LoggerFactory;
+use graph::prelude::MetricsRegistry;
+use graph::prelude::anyhow;
+use graph::slog::{Logger, debug, info, o, warn};
 use graph::url::Url;
-use graph::util::futures::retry;
-use graph::util::security::SafeDisplay;
-use graph_chain_ethereum::{self as ethereum, EthereumAdapterTrait, Transport};
-use std::collections::{btree_map, BTreeMap};
+use graph_chain_ethereum::{self as ethereum, Transport};
+use graph_store_postgres::{BlockStore, ChainHeadUpdateListener};
+use std::cmp::Ordering;
+use std::collections::BTreeMap;
 use std::sync::Arc;
-use std::time::Duration;
+use tokio::time::timeout;
 
 // The status of a provider that we learned from connecting to it
 #[derive(PartialEq)]
@@ -32,133 +45,40 @@ pub enum ProviderNetworkStatus {
     },
 }
 
-/// How long we will hold up node startup to get the net version and genesis
-/// hash from the client. If we can't get it within that time, we'll try and
-/// continue regardless.
-const NET_VERSION_WAIT_TIME: Duration = Duration::from_secs(30);
-
-pub fn create_ipfs_clients(logger: &Logger, ipfs_addresses: &Vec<String>) -> Vec<IpfsClient> {
-    // Parse the IPFS URL from the `--ipfs` command line argument
-    let ipfs_addresses: Vec<_> = ipfs_addresses
-        .iter()
-        .map(|uri| {
-            if uri.starts_with("http://") || uri.starts_with("https://") {
-                String::from(uri)
-            } else {
-                format!("http://{}", uri)
-            }
-        })
-        .collect();
-
-    ipfs_addresses
-        .into_iter()
-        .map(|ipfs_address| {
-            info!(
-                logger,
-                "Trying IPFS node at: {}",
-                SafeDisplay(&ipfs_address)
-            );
-
-            let ipfs_client = match IpfsClient::new(&ipfs_address) {
-                Ok(ipfs_client) => ipfs_client,
-                Err(e) => {
-                    error!(
-                        logger,
-                        "Failed to create IPFS client for `{}`: {}",
-                        SafeDisplay(&ipfs_address),
-                        e
-                    );
-                    panic!("Could not connect to IPFS");
-                }
-            };
-
-            // Test the IPFS client by getting the version from the IPFS daemon
-            let ipfs_test = ipfs_client.cheap_clone();
-            let ipfs_ok_logger = logger.clone();
-            let ipfs_err_logger = logger.clone();
-            let ipfs_address_for_ok = ipfs_address.clone();
-            let ipfs_address_for_err = ipfs_address;
-            graph::spawn(async move {
-                ipfs_test
-                    .test()
-                    .map_err(move |e| {
-                        error!(
-                            ipfs_err_logger,
-                            "Is there an IPFS node running at \"{}\"?",
-                            SafeDisplay(ipfs_address_for_err),
-                        );
-                        panic!("Failed to connect to IPFS: {}", e);
-                    })
-                    .map_ok(move |_| {
-                        info!(
-                            ipfs_ok_logger,
-                            "Successfully connected to IPFS node at: {}",
-                            SafeDisplay(ipfs_address_for_ok)
-                        );
-                    })
-                    .await
-            });
-
-            ipfs_client
-        })
-        .collect()
+pub trait ChainFilter: Send + Sync {
+    fn filter(&self, chain_name: &str) -> bool;
 }
 
-pub fn create_substreams_networks(
-    logger: Logger,
-    config: &Config,
-    endpoint_metrics: Arc<EndpointMetrics>,
-) -> BTreeMap<BlockchainKind, FirehoseNetworks> {
-    debug!(
-        logger,
-        "Creating firehose networks [{} chains, ingestor {}]",
-        config.chains.chains.len(),
-        config.chains.ingestor,
-    );
+pub struct AnyChainFilter;
 
-    let mut networks_by_kind = BTreeMap::new();
-
-    for (name, chain) in &config.chains.chains {
-        for provider in &chain.providers {
-            if let ProviderDetails::Substreams(ref firehose) = provider.details {
-                info!(
-                    logger,
-                    "Configuring firehose endpoint";
-                    "provider" => &provider.label,
-                );
+impl ChainFilter for AnyChainFilter {
+    fn filter(&self, _: &str) -> bool {
+        true
+    }
+}
 
-                let parsed_networks = networks_by_kind
-                    .entry(chain.protocol)
-                    .or_insert_with(FirehoseNetworks::new);
+pub struct OneChainFilter {
+    chain_name: String,
+}
 
-                for _ in 0..firehose.conn_pool_size {
-                    parsed_networks.insert(
-                        name.to_string(),
-                        Arc::new(FirehoseEndpoint::new(
-                            // This label needs to be the original label so that the metrics
-                            // can be deduped.
-                            &provider.label,
-                            &firehose.url,
-                            firehose.token.clone(),
-                            firehose.filters_enabled(),
-                            firehose.compression_enabled(),
-                            SubgraphLimit::Unlimited,
-                            endpoint_metrics.clone(),
-                        )),
-                    );
-                }
-            }
-        }
+impl OneChainFilter {
+    pub fn new(chain_name: String) -> Self {
+        Self { chain_name }
     }
+}
 
-    networks_by_kind
+impl ChainFilter for OneChainFilter {
+    fn filter(&self, chain_name: &str) -> bool {
+        self.chain_name == chain_name
+    }
 }
 
 pub fn create_firehose_networks(
     logger: Logger,
     config: &Config,
     endpoint_metrics: Arc<EndpointMetrics>,
-) -> BTreeMap<BlockchainKind, FirehoseNetworks> {
+    chain_filter: &dyn ChainFilter,
+) -> Vec<AdapterConfiguration> {
     debug!(
         logger,
         "Creating firehose networks [{} chains, ingestor {}]",
@@ -166,20 +86,30 @@ pub fn create_firehose_networks(
         config.chains.ingestor,
     );
 
-    let mut networks_by_kind = BTreeMap::new();
+    let mut networks_by_kind: BTreeMap<(BlockchainKind, ChainName), Vec<Arc<FirehoseEndpoint>>> =
+        BTreeMap::new();
 
-    for (name, chain) in &config.chains.chains {
+    let filtered_chains = config
+        .chains
+        .chains
+        .iter()
+        .filter(|(name, _)| chain_filter.filter(name));
+
+    for (name, chain) in filtered_chains {
+        let name: ChainName = name.as_str().into();
         for provider in &chain.providers {
+            let logger = logger.cheap_clone();
             if let ProviderDetails::Firehose(ref firehose) = provider.details {
                 info!(
-                    logger,
+                    &logger,
                     "Configuring firehose endpoint";
                     "provider" => &provider.label,
+                    "network" => &name.to_string(),
                 );
 
                 let parsed_networks = networks_by_kind
-                    .entry(chain.protocol)
-                    .or_insert_with(FirehoseNetworks::new);
+                    .entry((chain.protocol, name.clone()))
+                    .or_default();
 
                 // Create n FirehoseEndpoints where n is the size of the pool. If a
                 // subgraph limit is defined for this endpoint then each endpoint
@@ -188,255 +118,82 @@ pub fn create_firehose_networks(
                 // of FirehoseEndpoint and each of those instance can be used in 2 different
                 // SubgraphInstances.
                 for _ in 0..firehose.conn_pool_size {
-                    parsed_networks.insert(
-                        name.to_string(),
-                        Arc::new(FirehoseEndpoint::new(
-                            // This label needs to be the original label so that the metrics
-                            // can be deduped.
-                            &provider.label,
-                            &firehose.url,
-                            firehose.token.clone(),
-                            firehose.filters_enabled(),
-                            firehose.compression_enabled(),
-                            firehose.limit_for(&config.node),
-                            endpoint_metrics.cheap_clone(),
-                        )),
-                    );
+                    parsed_networks.push(Arc::new(FirehoseEndpoint::new(
+                        // This label needs to be the original label so that the metrics
+                        // can be deduped.
+                        &provider.label,
+                        &firehose.url,
+                        firehose.token.clone(),
+                        firehose.key.clone(),
+                        firehose.filters_enabled(),
+                        firehose.compression_enabled(),
+                        firehose.limit_for(&config.node),
+                        endpoint_metrics.cheap_clone(),
+                    )));
                 }
             }
         }
     }
 
     networks_by_kind
-}
-
-/// Try to connect to all the providers in `eth_networks` and get their net
-/// version and genesis block. Return the same `eth_networks` and the
-/// retrieved net identifiers grouped by network name. Remove all providers
-/// for which trying to connect resulted in an error from the returned
-/// `EthereumNetworks`, since it's likely pointless to try and connect to
-/// them. If the connection attempt to a provider times out after
-/// `NET_VERSION_WAIT_TIME`, keep the provider, but don't report a
-/// version for it.
-pub async fn connect_ethereum_networks(
-    logger: &Logger,
-    mut eth_networks: EthereumNetworks,
-) -> Result<(EthereumNetworks, BTreeMap<String, ChainIdentifier>), anyhow::Error> {
-    // This has one entry for each provider, and therefore multiple entries
-    // for each network
-    let statuses = join_all(
-        eth_networks
-            .flatten()
-            .into_iter()
-            .map(|(network_name, capabilities, eth_adapter)| {
-                (network_name, capabilities, eth_adapter, logger.clone())
+        .into_iter()
+        .map(|((kind, chain_id), endpoints)| {
+            AdapterConfiguration::Firehose(FirehoseAdapterConfig {
+                chain_id,
+                kind,
+                adapters: endpoints,
             })
-            .map(|(network, capabilities, eth_adapter, logger)| async move {
-                let logger = logger.new(o!("provider" => eth_adapter.provider().to_string()));
-                info!(
-                    logger, "Connecting to Ethereum to get network identifier";
-                    "capabilities" => &capabilities
-                );
-                match tokio::time::timeout(NET_VERSION_WAIT_TIME, eth_adapter.net_identifiers())
-                    .await
-                    .map_err(Error::from)
-                {
-                    // An `Err` means a timeout, an `Ok(Err)` means some other error (maybe a typo
-                    // on the URL)
-                    Ok(Err(e)) | Err(e) => {
-                        error!(logger, "Connection to provider failed. Not using this provider";
-                                       "error" =>  e.to_string());
-                        ProviderNetworkStatus::Broken {
-                            chain_id: network,
-                            provider: eth_adapter.provider().to_string(),
-                        }
-                    }
-                    Ok(Ok(ident)) => {
-                        info!(
-                            logger,
-                            "Connected to Ethereum";
-                            "network_version" => &ident.net_version,
-                            "capabilities" => &capabilities
-                        );
-                        ProviderNetworkStatus::Version {
-                            chain_id: network,
-                            ident,
-                        }
-                    }
-                }
-            }),
-    )
-    .await;
-
-    // Group identifiers by network name
-    let idents: BTreeMap<String, ChainIdentifier> =
-        statuses
-            .into_iter()
-            .try_fold(BTreeMap::new(), |mut networks, status| {
-                match status {
-                    ProviderNetworkStatus::Broken {
-                        chain_id: network,
-                        provider,
-                    } => eth_networks.remove(&network, &provider),
-                    ProviderNetworkStatus::Version {
-                        chain_id: network,
-                        ident,
-                    } => match networks.entry(network.clone()) {
-                        btree_map::Entry::Vacant(entry) => {
-                            entry.insert(ident);
-                        }
-                        btree_map::Entry::Occupied(entry) => {
-                            if &ident != entry.get() {
-                                return Err(anyhow!(
-                                    "conflicting network identifiers for chain {}: `{}` != `{}`",
-                                    network,
-                                    ident,
-                                    entry.get()
-                                ));
-                            }
-                        }
-                    },
-                }
-                Ok(networks)
-            })?;
-    Ok((eth_networks, idents))
+        })
+        .collect()
 }
 
-/// Try to connect to all the providers in `firehose_networks` and get their net
-/// version and genesis block. Return the same `eth_networks` and the
-/// retrieved net identifiers grouped by network name. Remove all providers
-/// for which trying to connect resulted in an error from the returned
-/// `EthereumNetworks`, since it's likely pointless to try and connect to
-/// them. If the connection attempt to a provider times out after
-/// `NET_VERSION_WAIT_TIME`, keep the provider, but don't report a
-/// version for it.
-pub async fn connect_firehose_networks<M>(
-    logger: &Logger,
-    mut firehose_networks: FirehoseNetworks,
-) -> Result<(FirehoseNetworks, BTreeMap<String, ChainIdentifier>), Error>
-where
-    M: prost::Message + BlockchainBlock + Default + 'static,
-{
-    // This has one entry for each provider, and therefore multiple entries
-    // for each network
-    let statuses = join_all(
-        firehose_networks
-            .flatten()
-            .into_iter()
-            .map(|(chain_id, endpoint)| (chain_id, endpoint, logger.clone()))
-            .map(|((chain_id, _), endpoint, logger)| async move {
-                let logger = logger.new(o!("provider" => endpoint.provider.to_string()));
-                info!(
-                    logger, "Connecting to Firehose to get chain identifier";
-                    "provider" => &endpoint.provider.to_string(),
-                );
-
-                let retry_endpoint = endpoint.clone();
-                let retry_logger = logger.clone();
-                let req = retry("firehose startup connection test", &logger)
-                    .no_limit()
-                    .no_timeout()
-                    .run(move || {
-                        let retry_endpoint = retry_endpoint.clone();
-                        let retry_logger = retry_logger.clone();
-                        async move { retry_endpoint.genesis_block_ptr::<M>(&retry_logger).await }
-                    });
-
-                match tokio::time::timeout(NET_VERSION_WAIT_TIME, req)
-                    .await
-                    .map_err(Error::from)
-                {
-                    // An `Err` means a timeout, an `Ok(Err)` means some other error (maybe a typo
-                    // on the URL)
-                    Ok(Err(e)) | Err(e) => {
-                        error!(logger, "Connection to provider failed. Not using this provider";
-                                       "error" =>  format!("{:#}", e));
-                        ProviderNetworkStatus::Broken {
-                            chain_id,
-                            provider: endpoint.provider.to_string(),
-                        }
-                    }
-                    Ok(Ok(ptr)) => {
-                        info!(
-                            logger,
-                            "Connected to Firehose";
-                            "provider" => &endpoint.provider.to_string(),
-                            "genesis_block" => format_args!("{}", &ptr),
-                        );
-
-                        // BUG: Firehose doesn't provide the net_version.
-                        // See also: firehose-no-net-version
-                        let ident = ChainIdentifier {
-                            net_version: "0".to_string(),
-                            genesis_block_hash: ptr.hash,
-                        };
-
-                        ProviderNetworkStatus::Version { chain_id, ident }
-                    }
-                }
-            }),
-    )
-    .await;
-
-    // Group identifiers by chain id
-    let idents: BTreeMap<String, ChainIdentifier> =
-        statuses
-            .into_iter()
-            .try_fold(BTreeMap::new(), |mut networks, status| {
-                match status {
-                    ProviderNetworkStatus::Broken { chain_id, provider } => {
-                        firehose_networks.remove(&chain_id, &provider)
-                    }
-                    ProviderNetworkStatus::Version { chain_id, ident } => {
-                        match networks.entry(chain_id.clone()) {
-                            btree_map::Entry::Vacant(entry) => {
-                                entry.insert(ident);
-                            }
-                            btree_map::Entry::Occupied(entry) => {
-                                if &ident != entry.get() {
-                                    return Err(anyhow!(
-                                    "conflicting network identifiers for chain {}: `{}` != `{}`",
-                                    chain_id,
-                                    ident,
-                                    entry.get()
-                                ));
-                                }
-                            }
-                        }
-                    }
-                }
-                Ok(networks)
-            })?;
-
-    // Clean-up chains with 0 provider
-    firehose_networks.networks.retain(|chain_id, endpoints| {
-        if endpoints.len() == 0 {
-            error!(
-                logger,
-                "No non-broken providers available for chain {}; ignoring this chain", chain_id
-            );
+impl From<ConfigChainSettings> for ChainSettings {
+    fn from(c: ConfigChainSettings) -> Self {
+        let ConfigChainSettings {
+            polling_interval,
+            json_rpc_timeout,
+            request_retries,
+            max_block_range_size,
+            block_batch_size,
+            block_ptr_batch_size,
+            max_event_only_range,
+            target_triggers_per_block_range,
+            get_logs_max_contracts,
+            block_ingestor_max_concurrent_json_rpc_calls,
+            genesis_block_number,
+        } = c;
+        ChainSettings {
+            polling_interval,
+            json_rpc_timeout,
+            request_retries,
+            max_block_range_size,
+            block_batch_size,
+            block_ptr_batch_size,
+            max_event_only_range,
+            target_triggers_per_block_range,
+            get_logs_max_contracts,
+            block_ingestor_max_concurrent_json_rpc_calls,
+            genesis_block_number,
         }
-
-        endpoints.len() > 0
-    });
-
-    Ok((firehose_networks, idents))
+    }
 }
 
 /// Parses all Ethereum connection strings and returns their network names and
 /// `EthereumAdapter`.
-pub async fn create_all_ethereum_networks(
+pub async fn create_ethereum_networks(
     logger: Logger,
     registry: Arc<MetricsRegistry>,
     config: &Config,
     endpoint_metrics: Arc<EndpointMetrics>,
-) -> anyhow::Result<EthereumNetworks> {
+    chain_filter: &dyn ChainFilter,
+) -> anyhow::Result<Vec<AdapterConfiguration>> {
     let eth_rpc_metrics = Arc::new(ProviderEthRpcMetrics::new(registry));
     let eth_networks_futures = config
         .chains
         .chains
         .iter()
         .filter(|(_, chain)| chain.protocol == BlockchainKind::Ethereum)
+        .filter(|(name, _)| chain_filter.filter(name))
         .map(|(name, _)| {
             create_ethereum_networks_for_chain(
                 &logger,
@@ -447,14 +204,7 @@ pub async fn create_all_ethereum_networks(
             )
         });
 
-    Ok(try_join_all(eth_networks_futures)
-        .await?
-        .into_iter()
-        .reduce(|mut a, b| {
-            a.extend(b);
-            a
-        })
-        .unwrap_or_else(|| EthereumNetworks::new(endpoint_metrics)))
+    try_join_all(eth_networks_futures).await
 }
 
 /// Parses a single Ethereum connection string and returns its network name and `EthereumAdapter`.
@@ -464,20 +214,21 @@ pub async fn create_ethereum_networks_for_chain(
     config: &Config,
     network_name: &str,
     endpoint_metrics: Arc<EndpointMetrics>,
-) -> anyhow::Result<EthereumNetworks> {
-    let mut parsed_networks = EthereumNetworks::new(endpoint_metrics.cheap_clone());
+) -> anyhow::Result<AdapterConfiguration> {
     let chain = config
         .chains
         .chains
         .get(network_name)
         .ok_or_else(|| anyhow!("unknown network {}", network_name))?;
+    let settings = Arc::new(ChainSettings::from(chain.settings.clone()));
+    let mut adapters = vec![];
+    let mut call_only_adapters = vec![];
 
     for provider in &chain.providers {
         let (web3, call_only) = match &provider.details {
             ProviderDetails::Web3Call(web3) => (web3, true),
             ProviderDetails::Web3(web3) => (web3, false),
             _ => {
-                parsed_networks.insert_empty(network_name.to_string());
                 continue;
             }
         };
@@ -488,30 +239,34 @@ pub async fn create_ethereum_networks_for_chain(
         }
 
         let logger = logger.new(o!("provider" => provider.label.clone()));
+        let compression = web3.compression();
         info!(
             logger,
             "Creating transport";
             "url" => &web3.url,
-            "capabilities" => capabilities
+            "capabilities" => capabilities,
+            "compression" => compression.to_string()
         );
 
         use crate::config::Transport::*;
 
+        let no_eip2718 = web3.features.contains("no_eip2718");
         let transport = match web3.transport {
             Rpc => Transport::new_rpc(
                 Url::parse(&web3.url)?,
                 web3.headers.clone(),
                 endpoint_metrics.cheap_clone(),
                 &provider.label,
+                no_eip2718,
+                compression,
             ),
             Ipc => Transport::new_ipc(&web3.url).await,
             Ws => Transport::new_ws(&web3.url).await,
         };
 
         let supports_eip_1898 = !web3.features.contains("no_eip1898");
-
-        parsed_networks.insert(
-            network_name.to_string(),
+        let adapter = EthereumNetworkAdapter::new(
+            endpoint_metrics.cheap_clone(),
             capabilities,
             Arc::new(
                 graph_chain_ethereum::EthereumAdapter::new(
@@ -521,29 +276,180 @@ pub async fn create_ethereum_networks_for_chain(
                     eth_rpc_metrics.clone(),
                     supports_eip_1898,
                     call_only,
+                    settings.clone(),
                 )
                 .await,
             ),
             web3.limit_for(&config.node),
         );
+
+        if call_only {
+            call_only_adapters.push(adapter);
+        } else {
+            adapters.push(adapter);
+        }
     }
 
-    parsed_networks.sort();
-    Ok(parsed_networks)
+    adapters.sort_by(|a, b| {
+        a.capabilities
+            .partial_cmp(&b.capabilities)
+            // We can't define a total ordering over node capabilities,
+            // so incomparable items are considered equal and end up
+            // near each other.
+            .unwrap_or(Ordering::Equal)
+    });
+
+    Ok(AdapterConfiguration::Rpc(EthAdapterConfig {
+        chain_id: network_name.into(),
+        adapters,
+        call_only: call_only_adapters,
+        settings,
+    }))
+}
+
+/// Networks as chains will create the necessary chains from the adapter information.
+/// There are two major cases that are handled currently:
+/// Deep integration chains (explicitly defined on the graph-node like Ethereum, Near, etc):
+///  - These can have adapter of any type. Adapters of firehose and rpc types are used by the Chain implementation, aka deep integration
+///  - The substreams adapters will trigger the creation of a Substreams chain, the priority for the block ingestor setup depends on the chain, if enabled at all.
+///    Substreams Chain(chains the graph-node knows nothing about and are only accessible through substreams):
+///  - This chain type is more generic and can only have adapters of substreams type.
+///  - Substreams chain are created as a "secondary" chain for deep integrations but in that case the block ingestor should be run by the main/deep integration chain.
+///  - These chains will use SubstreamsBlockIngestor by default.
+pub async fn networks_as_chains(
+    config: &Arc<EnvVars>,
+    blockchain_map: &mut BlockchainMap,
+    logger: &Logger,
+    networks: &Networks,
+    store: BlockStore,
+    logger_factory: &LoggerFactory,
+    metrics_registry: Arc<MetricsRegistry>,
+    chain_head_update_listener: Arc<ChainHeadUpdateListener>,
+) {
+    let adapters = networks
+        .adapters
+        .iter()
+        .sorted_by_key(|a| a.chain_id())
+        .chunk_by(|a| a.chain_id())
+        .into_iter()
+        .map(|(chain_id, adapters)| (chain_id, adapters.into_iter().collect_vec()))
+        .collect_vec();
+
+    let chains = adapters.into_iter().map(|(chain_id, adapters)| {
+        let adapters: Vec<&AdapterConfiguration> = adapters.into_iter().collect();
+        let kind = adapters
+            .first()
+            .map(|a| a.blockchain_kind())
+            .expect("validation should have checked we have at least one provider");
+        (chain_id, adapters, kind)
+    });
+
+    for (chain_id, adapters, kind) in chains.into_iter() {
+        let chain_store = match store.chain_store(chain_id).await {
+            Some(c) => c,
+            None => {
+                let ident = match timeout(
+                    config.genesis_validation_timeout,
+                    networks.chain_identifier(logger, chain_id),
+                )
+                .await
+                {
+                    Ok(Ok(ident)) => ident,
+                    err => {
+                        warn!(
+                            &logger,
+                            "unable to fetch genesis for {}. Err: {:?}.falling back to the default value",
+                            chain_id,
+                            err
+                        );
+                        ChainIdentifier::default()
+                    }
+                };
+                store
+                    .create_chain_store(chain_id, ident)
+                    .await
+                    .expect("must be able to create store if one is not yet setup for the chain")
+            }
+        };
+
+        match kind {
+            BlockchainKind::Ethereum => {
+                // settings come from the first RPC adapter config; falls back to ENV_VAR
+                // defaults for firehose-only chains.
+                let settings = adapters
+                    .iter()
+                    .find_map(|a| a.as_rpc().map(|r| r.settings.clone()))
+                    .unwrap_or_else(|| Arc::new(ChainSettings::from_env_defaults()));
+
+                let firehose_endpoints = networks.firehose_endpoints(chain_id.clone());
+                let eth_adapters = networks.ethereum_rpcs(chain_id.clone());
+
+                let cc = if !firehose_endpoints.is_empty() {
+                    ChainClient::<graph_chain_ethereum::Chain>::new_firehose(firehose_endpoints)
+                } else {
+                    ChainClient::<graph_chain_ethereum::Chain>::new_rpc(eth_adapters.clone())
+                };
+
+                let client = Arc::new(cc);
+                let eth_adapters = Arc::new(eth_adapters);
+                let adapter_selector = EthereumAdapterSelector::new(
+                    logger_factory.clone(),
+                    client.clone(),
+                    metrics_registry.clone(),
+                    chain_store.clone(),
+                    eth_adapters.clone(),
+                );
+
+                let call_cache = chain_store.cheap_clone();
+
+                let chain = ethereum::Chain::new(
+                    logger_factory.clone(),
+                    chain_id.clone(),
+                    metrics_registry.clone(),
+                    chain_store.cheap_clone(),
+                    call_cache,
+                    client,
+                    chain_head_update_listener.clone(),
+                    Arc::new(EthereumStreamBuilder {}),
+                    Arc::new(EthereumBlockRefetcher {}),
+                    Arc::new(adapter_selector),
+                    Arc::new(EthereumRuntimeAdapterBuilder {}),
+                    eth_adapters,
+                    ENV_VARS.reorg_threshold(),
+                    true,
+                    settings,
+                );
+
+                blockchain_map
+                    .insert::<graph_chain_ethereum::Chain>(chain_id.clone(), Arc::new(chain));
+            }
+            BlockchainKind::Near => {
+                let firehose_endpoints = networks.firehose_endpoints(chain_id.clone());
+                let chain = graph_chain_near::Chain::new(
+                    logger_factory.clone(),
+                    chain_id.clone(),
+                    chain_store.cheap_clone(),
+                    firehose_endpoints,
+                    metrics_registry.clone(),
+                );
+                blockchain_map.insert::<graph_chain_near::Chain>(chain_id.clone(), Arc::new(chain));
+            }
+        }
+    }
 }
 
 #[cfg(test)]
 mod test {
-    use crate::chain::create_all_ethereum_networks;
     use crate::config::{Config, Opt};
+    use crate::network_setup::{AdapterConfiguration, Networks};
+    use graph::components::network_provider::ChainName;
     use graph::endpoint::EndpointMetrics;
     use graph::log::logger;
-    use graph::prelude::{tokio, MetricsRegistry};
-    use graph::prometheus::Registry;
+    use graph::prelude::MetricsRegistry;
     use graph_chain_ethereum::NodeCapabilities;
     use std::sync::Arc;
 
-    #[tokio::test]
+    #[graph::test]
     async fn correctly_parse_ethereum_networks() {
         let logger = logger(true);
 
@@ -568,17 +474,16 @@ mod test {
 
         let metrics = Arc::new(EndpointMetrics::mock());
         let config = Config::load(&logger, &opt).expect("can create config");
-        let prometheus_registry = Arc::new(Registry::new());
-        let metrics_registry = Arc::new(MetricsRegistry::new(
-            logger.clone(),
-            prometheus_registry.clone(),
-        ));
-
-        let ethereum_networks =
-            create_all_ethereum_networks(logger, metrics_registry, &config, metrics)
-                .await
-                .expect("Correctly parse Ethereum network args");
-        let mut network_names = ethereum_networks.networks.keys().collect::<Vec<&String>>();
+        let metrics_registry = Arc::new(MetricsRegistry::mock());
+
+        let networks = Networks::from_config(logger, &config, metrics_registry, metrics, &[])
+            .await
+            .expect("can parse config");
+        let mut network_names = networks
+            .adapters
+            .iter()
+            .map(|a| a.chain_id())
+            .collect::<Vec<&ChainName>>();
         network_names.sort();
 
         let traces = NodeCapabilities {
@@ -590,45 +495,26 @@ mod test {
             traces: false,
         };
 
-        let has_mainnet_with_traces = ethereum_networks
-            .adapter_with_capabilities("mainnet".to_string(), &traces)
-            .is_ok();
-        let has_goerli_with_archive = ethereum_networks
-            .adapter_with_capabilities("goerli".to_string(), &archive)
-            .is_ok();
-        let has_mainnet_with_archive = ethereum_networks
-            .adapter_with_capabilities("mainnet".to_string(), &archive)
-            .is_ok();
-        let has_goerli_with_traces = ethereum_networks
-            .adapter_with_capabilities("goerli".to_string(), &traces)
-            .is_ok();
-
-        assert_eq!(has_mainnet_with_traces, true);
-        assert_eq!(has_goerli_with_archive, true);
-        assert_eq!(has_mainnet_with_archive, false);
-        assert_eq!(has_goerli_with_traces, false);
-
-        let goerli_capability = ethereum_networks
-            .networks
-            .get("goerli")
-            .unwrap()
+        let mainnet: Vec<&AdapterConfiguration> = networks
             .adapters
-            .first()
-            .unwrap()
-            .capabilities;
-        let mainnet_capability = ethereum_networks
-            .networks
-            .get("mainnet")
-            .unwrap()
+            .iter()
+            .filter(|a| a.chain_id().as_str().eq("mainnet"))
+            .collect();
+        assert_eq!(mainnet.len(), 1);
+        let mainnet = mainnet.first().unwrap().as_rpc().unwrap();
+        assert_eq!(mainnet.adapters.len(), 1);
+        let mainnet = mainnet.adapters.first().unwrap();
+        assert_eq!(mainnet.capabilities, traces);
+
+        let goerli: Vec<&AdapterConfiguration> = networks
             .adapters
-            .first()
-            .unwrap()
-            .capabilities;
-        assert_eq!(
-            network_names,
-            vec![&"goerli".to_string(), &"mainnet".to_string()]
-        );
-        assert_eq!(goerli_capability, archive);
-        assert_eq!(mainnet_capability, traces);
+            .iter()
+            .filter(|a| a.chain_id().as_str().eq("goerli"))
+            .collect();
+        assert_eq!(goerli.len(), 1);
+        let goerli = goerli.first().unwrap().as_rpc().unwrap();
+        assert_eq!(goerli.adapters.len(), 1);
+        let goerli = goerli.adapters.first().unwrap();
+        assert_eq!(goerli.capabilities, archive);
     }
 }
diff --git a/node/src/config.rs b/node/src/config.rs
index 6e774ceffd4..4c9b776e43a 100644
--- a/node/src/config.rs
+++ b/node/src/config.rs
@@ -1,26 +1,33 @@
 use graph::{
     anyhow::Error,
     blockchain::BlockchainKind,
+    components::{
+        network_provider::{AmpChainNames, ChainName},
+        store::BLOCK_CACHE_SIZE,
+    },
     env::ENV_VARS,
-    firehose::{SubgraphLimit, SUBGRAPHS_PER_CONN},
+    firehose::{SUBGRAPHS_PER_CONN, SubgraphLimit},
     itertools::Itertools,
     prelude::{
-        anyhow::{anyhow, bail, Context, Result},
+        BLOCK_NUMBER_MAX, Logger, NodeId, StoreError,
+        anyhow::{Context, Result, anyhow, bail},
         info,
         regex::Regex,
         serde::{
-            de::{self, value, SeqAccess, Visitor},
-            Deserialize, Deserializer, Serialize,
+            Deserialize, Deserializer,
+            de::{self, SeqAccess, Visitor, value},
         },
-        serde_json, serde_regex, toml, Logger, NodeId, StoreError,
+        serde_json, serde_regex, toml,
     },
 };
-use graph_chain_ethereum::{self as ethereum, NodeCapabilities};
-use graph_store_postgres::{DeploymentPlacer, Shard as ShardName, PRIMARY_SHARD};
+use graph_chain_ethereum as ethereum;
+use graph_chain_ethereum::{Compression, NodeCapabilities};
+use graph_store_postgres::{DeploymentPlacer, PRIMARY_SHARD, Shard as ShardName};
 
-use http::{HeaderMap, Uri};
+use graph::http::{HeaderMap, Uri};
+use serde::Serialize;
 use std::{
-    collections::{BTreeMap, BTreeSet},
+    collections::{BTreeMap, BTreeSet, HashMap},
     fmt,
 };
 use std::{fs::read_to_string, time::Duration};
@@ -69,11 +76,14 @@ impl Default for Opt {
 pub struct Config {
     #[serde(skip, default = "default_node_id")]
     pub node: NodeId,
+    #[serde(skip)]
+    pub disable_block_ingestor: bool,
     pub general: Option<GeneralSection>,
     #[serde(rename = "store")]
     pub stores: BTreeMap<String, Shard>,
     pub chains: ChainSection,
     pub deployment: Deployment,
+    pub log_store: Option<LogStoreSection>,
 }
 
 fn validate_name(s: &str) -> Result<()> {
@@ -101,6 +111,41 @@ fn validate_name(s: &str) -> Result<()> {
 }
 
 impl Config {
+    /// Returns `true` if this node should run block ingestion.
+    ///
+    /// Block ingestion runs when the `--disable-block-ingestor` kill switch
+    /// is **not** set and this node's id matches the `ingestor` value from
+    /// the `[chains]` config section.
+    pub fn is_block_ingestor(&self) -> bool {
+        !self.disable_block_ingestor && self.chains.ingestor == self.node.to_string()
+    }
+
+    pub fn chain_ids(&self) -> Vec<ChainName> {
+        self.chains
+            .chains
+            .keys()
+            .map(|k| k.as_str().into())
+            .collect()
+    }
+
+    /// Build an `AmpChainNames` mapping from the config. Chains with an
+    /// explicit `amp` name map that name to the chain name; chains without
+    /// use identity mapping.
+    pub fn amp_chain_names(&self) -> AmpChainNames {
+        let mapping: HashMap<ChainName, ChainName> = self
+            .chains
+            .chains
+            .iter()
+            .map(|(chain_name, chain)| {
+                let amp_name: ChainName =
+                    chain.amp.as_deref().unwrap_or(chain_name.as_str()).into();
+                let internal_name: ChainName = chain_name.as_str().into();
+                (amp_name, internal_name)
+            })
+            .collect();
+        AmpChainNames::new(mapping)
+    }
+
     /// Check that the config is valid.
     fn validate(&mut self) -> Result<()> {
         if !self.stores.contains_key(PRIMARY_SHARD.as_str()) {
@@ -113,7 +158,7 @@ impl Config {
             ));
         }
         for (key, shard) in self.stores.iter_mut() {
-            shard.validate(key)?;
+            shard.validate(key, &self.node)?;
         }
         self.deployment.validate()?;
 
@@ -153,7 +198,7 @@ impl Config {
     /// a config from the command line arguments in `opt`
     pub fn load(logger: &Logger, opt: &Opt) -> Result<Config> {
         if let Some(config) = &opt.config {
-            Self::from_file(logger, config, &opt.node_id)
+            Self::from_file(logger, config, opt)
         } else {
             info!(
                 logger,
@@ -163,14 +208,16 @@ impl Config {
         }
     }
 
-    pub fn from_file(logger: &Logger, path: &str, node: &str) -> Result<Config> {
+    pub fn from_file(logger: &Logger, path: &str, opt: &Opt) -> Result<Config> {
         info!(logger, "Reading configuration file `{}`", path);
-        Self::from_str(&read_to_string(path)?, node)
+        Self::from_str(&read_to_string(path)?, opt)
     }
 
-    pub fn from_str(config: &str, node: &str) -> Result<Config> {
+    pub fn from_str(config: &str, opt: &Opt) -> Result<Config> {
         let mut config: Config = toml::from_str(config)?;
-        config.node = NodeId::new(node).map_err(|()| anyhow!("invalid node id {}", node))?;
+        config.node =
+            NodeId::new(&opt.node_id).map_err(|node| anyhow!("invalid node id {}", node))?;
+        config.disable_block_ingestor = opt.disable_block_ingestor;
         config.validate()?;
         Ok(config)
     }
@@ -180,14 +227,16 @@ impl Config {
         let mut stores = BTreeMap::new();
         let chains = ChainSection::from_opt(opt)?;
         let node = NodeId::new(opt.node_id.to_string())
-            .map_err(|()| anyhow!("invalid node id {}", opt.node_id))?;
+            .map_err(|node| anyhow!("invalid node id {}", node))?;
         stores.insert(PRIMARY_SHARD.to_string(), Shard::from_opt(true, opt)?);
         Ok(Config {
             node,
+            disable_block_ingestor: opt.disable_block_ingestor,
             general: None,
             stores,
             chains,
             deployment,
+            log_store: None,
         })
     }
 
@@ -224,6 +273,79 @@ pub struct GeneralSection {
     query: Regex,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct LogStoreSection {
+    pub backend: String,
+
+    // File backend
+    pub directory: Option<String>,
+    pub retention_hours: Option<u32>,
+
+    // Elasticsearch backend
+    pub url: Option<String>,
+    pub username: Option<String>,
+    pub password: Option<String>,
+    pub index: Option<String>,
+    pub timeout_secs: Option<u64>,
+
+    // Loki backend (url shared with elasticsearch, differentiated by backend)
+    pub tenant_id: Option<String>,
+}
+
+impl LogStoreSection {
+    pub fn to_log_store_config(&self) -> Result<graph::components::log_store::LogStoreConfig> {
+        use graph::components::log_store::LogStoreConfig;
+
+        match self.backend.to_lowercase().as_str() {
+            "disabled" | "none" => Ok(LogStoreConfig::Disabled),
+
+            "elasticsearch" | "elastic" | "es" => {
+                let endpoint = self.url.clone().ok_or_else(|| {
+                    anyhow!("log_store: 'url' is required for elasticsearch backend")
+                })?;
+
+                Ok(LogStoreConfig::Elasticsearch {
+                    endpoint,
+                    username: self.username.clone(),
+                    password: self.password.clone(),
+                    index: self.index.clone().unwrap_or_else(|| "subgraph".to_string()),
+                    timeout_secs: self.timeout_secs.unwrap_or(10),
+                })
+            }
+
+            "loki" => {
+                let endpoint = self
+                    .url
+                    .clone()
+                    .ok_or_else(|| anyhow!("log_store: 'url' is required for loki backend"))?;
+
+                Ok(LogStoreConfig::Loki {
+                    endpoint,
+                    tenant_id: self.tenant_id.clone(),
+                    username: self.username.clone(),
+                    password: self.password.clone(),
+                })
+            }
+
+            "file" | "files" => {
+                let directory = self.directory.clone().ok_or_else(|| {
+                    anyhow!("log_store: 'directory' is required for file backend")
+                })?;
+
+                Ok(LogStoreConfig::File {
+                    directory: std::path::PathBuf::from(directory),
+                    retention_hours: self.retention_hours.unwrap_or(0),
+                })
+            }
+
+            other => Err(anyhow!(
+                "log_store: unknown backend '{}'. Valid options: disabled, elasticsearch, loki, file",
+                other
+            )),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Shard {
     pub connection: String,
@@ -238,10 +360,10 @@ pub struct Shard {
 }
 
 impl Shard {
-    fn validate(&mut self, name: &str) -> Result<()> {
+    fn validate(&mut self, name: &str, node: &NodeId) -> Result<()> {
         ShardName::new(name.to_string()).map_err(|e| anyhow!(e))?;
 
-        self.connection = shellexpand::env(&self.connection)?.into_owned();
+        self.expand_connection(node)?;
 
         if matches!(self.pool_size, PoolSize::None) {
             return Err(anyhow!("missing pool size definition for shard `{}`", name));
@@ -290,22 +412,39 @@ impl Shard {
             replicas,
         })
     }
+
+    // Put the PGAPPNAME into the URL since tokio-postgres ignores this
+    // environment variable. If PGAPPNAME is not set, use `node`.
+    fn expand_connection(&mut self, node: &NodeId) -> Result<()> {
+        let app_name = std::env::var("PGAPPNAME").unwrap_or(node.to_string());
+
+        let mut url = Url::parse(shellexpand::env(&self.connection)?.as_ref())?;
+
+        let query = match url.query() {
+            Some(query) => {
+                format!("{query}&application_name={app_name}")
+            }
+            None => {
+                format!("application_name={app_name}")
+            }
+        };
+        url.set_query(Some(&query));
+
+        self.connection = url.to_string();
+
+        Ok(())
+    }
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize, Default)]
 #[serde(untagged)]
 pub enum PoolSize {
+    #[default]
     None,
     Fixed(u32),
     Rule(Vec<PoolSizeRule>),
 }
 
-impl Default for PoolSize {
-    fn default() -> Self {
-        Self::None
-    }
-}
-
 impl PoolSize {
     fn five() -> Self {
         Self::Fixed(5)
@@ -396,31 +535,97 @@ pub struct ChainSection {
     pub ingestor: String,
     #[serde(flatten)]
     pub chains: BTreeMap<String, Chain>,
+    /// The default for chains that don't set this explicitly. When running
+    /// without a config file, we use `BLOCK_NUMBER_MAX` to turn off pruning
+    /// the block cache
+    #[serde(default = "default_cache_size")]
+    pub cache_size: i32,
 }
 
 impl ChainSection {
     fn validate(&mut self) -> Result<()> {
         NodeId::new(&self.ingestor)
-            .map_err(|()| anyhow!("invalid node id for ingestor {}", &self.ingestor))?;
-        for (_, chain) in self.chains.iter_mut() {
-            chain.validate()?
+            .map_err(|node| anyhow!("invalid node id for ingestor {}", node))?;
+        let reorg_threshold = ENV_VARS.reorg_threshold();
+
+        if self.cache_size <= reorg_threshold {
+            return Err(anyhow!(
+                "default chains.cache_size ({}) must be greater than reorg_threshold ({})",
+                self.cache_size,
+                reorg_threshold
+            ));
+        }
+
+        // Apply section-level cache_size as default for chains that
+        // don't set their own.
+        for chain in self.chains.values_mut() {
+            if chain.cache_size == 0 {
+                chain.cache_size = self.cache_size;
+            }
+        }
+
+        for (name, chain) in self.chains.iter_mut() {
+            chain
+                .validate()
+                .map_err(|e| anyhow!("chain '{}': {}", name, e))?;
+            if chain.cache_size <= reorg_threshold {
+                return Err(anyhow!(
+                    "chain '{}': cache_size ({}) must be greater than reorg_threshold ({})",
+                    name,
+                    chain.cache_size,
+                    reorg_threshold
+                ));
+            }
+        }
+
+        // Validate that effective AMP names are unique and don't collide
+        // with other chain names.
+        let mut amp_names: BTreeMap<String, String> = BTreeMap::new();
+        for (chain_name, chain) in &self.chains {
+            let effective = chain.amp.as_deref().unwrap_or(chain_name.as_str());
+            if let Some(prev_chain) = amp_names.get(effective) {
+                return Err(anyhow!(
+                    "duplicate AMP name `{}`: used by chains `{}` and `{}`",
+                    effective,
+                    prev_chain,
+                    chain_name
+                ));
+            }
+            // Check that an explicit amp alias doesn't collide with
+            // another chain's own name (which would be ambiguous).
+            if chain.amp.is_some()
+                && let Some(other) = self.chains.get(effective)
+            {
+                // Only a collision if the other chain doesn't also
+                // set the same amp alias (which is covered by the
+                // duplicate check above).
+                if other.amp.as_deref() != Some(effective) {
+                    return Err(anyhow!(
+                        "AMP alias `{}` on chain `{}` collides with chain `{}`",
+                        effective,
+                        chain_name,
+                        effective,
+                    ));
+                }
+            }
+            amp_names.insert(effective.to_string(), chain_name.clone());
         }
+
         Ok(())
     }
 
     fn from_opt(opt: &Opt) -> Result<Self> {
-        // If we are not the block ingestor, set the node name
-        // to something that is definitely not our node_id
-        let ingestor = if opt.disable_block_ingestor {
-            format!("{} is not ingesting", opt.node_id)
-        } else {
-            opt.node_id.clone()
-        };
+        let ingestor = opt.node_id.clone();
         let mut chains = BTreeMap::new();
         Self::parse_networks(&mut chains, Transport::Rpc, &opt.ethereum_rpc)?;
         Self::parse_networks(&mut chains, Transport::Ws, &opt.ethereum_ws)?;
         Self::parse_networks(&mut chains, Transport::Ipc, &opt.ethereum_ipc)?;
-        Ok(Self { ingestor, chains })
+        Ok(Self {
+            ingestor,
+            chains,
+            // When running without a config file, we do not prune the block cache
+            cache_size: BLOCK_NUMBER_MAX,
+        })
     }
 
     pub fn providers(&self) -> Vec<String> {
@@ -439,7 +644,7 @@ impl ChainSection {
     fn parse_networks(
         chains: &mut BTreeMap<String, Chain>,
         transport: Transport,
-        args: &Vec<String>,
+        args: &[String],
     ) -> Result<()> {
         for (nr, arg) in args.iter().enumerate() {
             if arg.starts_with("wss://")
@@ -477,7 +682,7 @@ impl ChainSection {
                 })?;
 
                 let (features, url_str) = rest.split_at(colon);
-                let (url, features) = if vec!["http", "https", "ws", "wss"].contains(&features) {
+                let (url, features) = if ["http", "https", "ws", "wss"].contains(&features) {
                     (rest, DEFAULT_PROVIDER_FEATURES.to_vec())
                 } else {
                     (&url_str[1..], features.split(',').collect())
@@ -496,8 +701,10 @@ impl ChainSection {
                 let entry = chains.entry(name.to_string()).or_insert_with(|| Chain {
                     shard: PRIMARY_SHARD.to_string(),
                     protocol: BlockchainKind::Ethereum,
-                    polling_interval: default_polling_interval(),
                     providers: vec![],
+                    amp: None,
+                    cache_size: 0,
+                    settings: ChainSettings::default(),
                 });
                 entry.providers.push(provider);
             }
@@ -506,18 +713,135 @@ impl ChainSection {
     }
 }
 
+/// Per-chain settings. Flattened into `Chain` so all fields appear as top-level keys in
+/// `[chains.X]` TOML sections. Absent fields fall back to the corresponding `GRAPH_ETHEREUM_*` /
+/// `ETHEREUM_*` environment variable defaults via serde default functions — the same pattern as
+/// `polling_interval`.
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
-pub struct Chain {
-    pub shard: String,
-    #[serde(default = "default_blockchain_kind")]
-    pub protocol: BlockchainKind,
+pub struct ChainSettings {
+    /// Set by `polling_interval` (milliseconds). Defaults to `ETHEREUM_POLLING_INTERVAL`.
     #[serde(
         default = "default_polling_interval",
         deserialize_with = "deserialize_duration_millis"
     )]
     pub polling_interval: Duration,
+    /// Set by `json_rpc_timeout` (seconds). Defaults to `GRAPH_ETHEREUM_JSON_RPC_TIMEOUT`.
+    #[serde(
+        default = "default_json_rpc_timeout",
+        deserialize_with = "deserialize_duration_secs"
+    )]
+    pub json_rpc_timeout: Duration,
+    /// Defaults to `GRAPH_ETHEREUM_REQUEST_RETRIES`.
+    #[serde(default = "default_request_retries")]
+    pub request_retries: usize,
+    /// Defaults to `GRAPH_ETHEREUM_MAX_BLOCK_RANGE_SIZE`.
+    #[serde(default = "default_max_block_range_size")]
+    pub max_block_range_size: i32,
+    /// Defaults to `ETHEREUM_BLOCK_BATCH_SIZE`.
+    #[serde(default = "default_block_batch_size")]
+    pub block_batch_size: usize,
+    /// Defaults to `ETHEREUM_BLOCK_PTR_BATCH_SIZE`.
+    #[serde(default = "default_block_ptr_batch_size")]
+    pub block_ptr_batch_size: usize,
+    /// Defaults to `GRAPH_ETHEREUM_MAX_EVENT_ONLY_RANGE`.
+    #[serde(default = "default_max_event_only_range")]
+    pub max_event_only_range: i32,
+    /// Defaults to `GRAPH_ETHEREUM_TARGET_TRIGGERS_PER_BLOCK_RANGE`.
+    #[serde(default = "default_target_triggers_per_block_range")]
+    pub target_triggers_per_block_range: u64,
+    /// Defaults to `GRAPH_ETH_GET_LOGS_MAX_CONTRACTS`.
+    #[serde(default = "default_get_logs_max_contracts")]
+    pub get_logs_max_contracts: usize,
+    /// Defaults to `GRAPH_ETHEREUM_BLOCK_INGESTOR_MAX_CONCURRENT_JSON_RPC_CALLS_FOR_TXN_RECEIPTS`.
+    #[serde(default = "default_block_ingestor_max_concurrent_json_rpc_calls")]
+    pub block_ingestor_max_concurrent_json_rpc_calls: usize,
+    /// Defaults to `GRAPH_ETHEREUM_GENESIS_BLOCK_NUMBER`.
+    #[serde(default = "default_genesis_block_number")]
+    pub genesis_block_number: u64,
+}
+
+impl Default for ChainSettings {
+    fn default() -> Self {
+        ChainSettings {
+            polling_interval: default_polling_interval(),
+            json_rpc_timeout: default_json_rpc_timeout(),
+            request_retries: default_request_retries(),
+            max_block_range_size: default_max_block_range_size(),
+            block_batch_size: default_block_batch_size(),
+            block_ptr_batch_size: default_block_ptr_batch_size(),
+            max_event_only_range: default_max_event_only_range(),
+            target_triggers_per_block_range: default_target_triggers_per_block_range(),
+            get_logs_max_contracts: default_get_logs_max_contracts(),
+            block_ingestor_max_concurrent_json_rpc_calls:
+                default_block_ingestor_max_concurrent_json_rpc_calls(),
+            genesis_block_number: default_genesis_block_number(),
+        }
+    }
+}
+
+impl ChainSettings {
+    fn validate(&self) -> Result<()> {
+        anyhow::ensure!(
+            !self.polling_interval.is_zero(),
+            "polling_interval must be > 0"
+        );
+        anyhow::ensure!(
+            !self.json_rpc_timeout.is_zero(),
+            "json_rpc_timeout must be > 0"
+        );
+        anyhow::ensure!(self.request_retries > 0, "request_retries must be > 0");
+        anyhow::ensure!(
+            self.max_block_range_size > 0,
+            "max_block_range_size must be > 0"
+        );
+        anyhow::ensure!(
+            self.max_event_only_range > 0,
+            "max_event_only_range must be > 0"
+        );
+        anyhow::ensure!(self.block_batch_size > 0, "block_batch_size must be > 0");
+        anyhow::ensure!(
+            self.block_ptr_batch_size > 0,
+            "block_ptr_batch_size must be > 0"
+        );
+        anyhow::ensure!(
+            self.block_ingestor_max_concurrent_json_rpc_calls > 0,
+            "block_ingestor_max_concurrent_json_rpc_calls must be > 0"
+        );
+        anyhow::ensure!(
+            self.get_logs_max_contracts > 0,
+            "get_logs_max_contracts must be > 0"
+        );
+        anyhow::ensure!(
+            self.target_triggers_per_block_range > 0,
+            "target_triggers_per_block_range must be > 0"
+        );
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
+pub struct Chain {
+    pub shard: String,
+    #[serde(default = "default_blockchain_kind")]
+    pub protocol: BlockchainKind,
     #[serde(rename = "provider")]
     pub providers: Vec<Provider>,
+    /// AMP network name alias. When set, AMP manifests using this name will
+    /// resolve to this chain. Defaults to the chain name.
+    #[serde(default)]
+    pub amp: Option<String>,
+    /// Number of blocks from chain head for which to keep block data
+    /// cached. When `GRAPH_STORE_IGNORE_BLOCK_CACHE` is set, blocks
+    /// older than this are treated as if they have no data.
+    #[serde(default)]
+    pub cache_size: i32,
+    /// Per-chain settings (flat fields). Absent fields fall back to ENV_VAR defaults.
+    #[serde(flatten)]
+    pub settings: ChainSettings,
+}
+
+fn default_cache_size() -> i32 {
+    BLOCK_CACHE_SIZE
 }
 
 fn default_blockchain_kind() -> BlockchainKind {
@@ -530,7 +854,7 @@ impl Chain {
         labels.sort();
         labels.dedup();
         if labels.len() != self.providers.len() {
-            return Err(anyhow!("Provider labels must be unique"));
+            return Err(anyhow!("provider labels must be unique"));
         }
 
         // `Config` validates that `self.shard` references a configured shard
@@ -538,28 +862,8 @@ impl Chain {
             provider.validate()?
         }
 
-        if !matches!(self.protocol, BlockchainKind::Substreams) {
-            let has_only_substreams_providers = self
-                .providers
-                .iter()
-                .all(|provider| matches!(provider.details, ProviderDetails::Substreams(_)));
-            if has_only_substreams_providers {
-                bail!(
-                    "{} protocol requires an rpc or firehose endpoint defined",
-                    self.protocol
-                );
-            }
-        }
-
-        // When using substreams protocol, only substreams endpoints are allowed
-        if matches!(self.protocol, BlockchainKind::Substreams) {
-            let has_non_substreams_providers = self
-                .providers
-                .iter()
-                .any(|provider| !matches!(provider.details, ProviderDetails::Substreams(_)));
-            if has_non_substreams_providers {
-                bail!("Substreams protocol only supports substreams providers");
-            }
+        if self.protocol == BlockchainKind::Ethereum {
+            self.settings.validate()?;
         }
 
         Ok(())
@@ -578,9 +882,9 @@ fn btree_map_to_http_headers(kvs: BTreeMap<String, String>) -> HeaderMap {
     let mut headers = HeaderMap::new();
     for (k, v) in kvs.into_iter() {
         headers.insert(
-            k.parse::<http::header::HeaderName>()
+            k.parse::<graph::http::header::HeaderName>()
                 .unwrap_or_else(|_| panic!("invalid HTTP header name: {}", k)),
-            v.parse::<http::header::HeaderValue>()
+            v.parse::<graph::http::header::HeaderValue>()
                 .unwrap_or_else(|_| panic!("invalid HTTP header value: {}: {}", k, v)),
         );
     }
@@ -598,7 +902,6 @@ pub struct Provider {
 pub enum ProviderDetails {
     Firehose(FirehoseProvider),
     Web3(Web3Provider),
-    Substreams(FirehoseProvider),
     Web3Call(Web3Provider),
 }
 
@@ -615,6 +918,7 @@ fn twenty() -> u16 {
 pub struct FirehoseProvider {
     pub url: String,
     pub token: Option<String>,
+    pub key: Option<String>,
     #[serde(default = "twenty")]
     pub conn_pool_size: u16,
     #[serde(default)]
@@ -703,12 +1007,38 @@ impl Web3Provider {
         }
     }
 
+    pub fn compression(&self) -> Compression {
+        if self.features.contains("compression/gzip") {
+            Compression::Gzip
+        } else if self.features.contains("compression/brotli") {
+            Compression::Brotli
+        } else if self.features.contains("compression/deflate") {
+            Compression::Deflate
+        } else {
+            Compression::None
+        }
+    }
+
     pub fn limit_for(&self, node: &NodeId) -> SubgraphLimit {
         self.rules.limit_for(node)
     }
 }
 
-const PROVIDER_FEATURES: [&str; 3] = ["traces", "archive", "no_eip1898"];
+/// Supported provider features:
+/// - `traces`: Provider supports debug_traceBlockByNumber for call tracing
+/// - `archive`: Provider is an archive node with full historical state
+/// - `no_eip1898`: Provider doesn't support EIP-1898 (block parameter by hash/number object)
+/// - `no_eip2718`: Provider doesn't return the `type` field in transaction receipts.
+///   When set, receipts are patched to add `"type": "0x0"` for legacy transaction compatibility.
+const PROVIDER_FEATURES: [&str; 7] = [
+    "traces",
+    "archive",
+    "no_eip1898",
+    "no_eip2718",
+    "compression/gzip",
+    "compression/brotli",
+    "compression/deflate",
+];
 const DEFAULT_PROVIDER_FEATURES: [&str; 2] = ["traces", "archive"];
 
 impl Provider {
@@ -716,8 +1046,7 @@ impl Provider {
         validate_name(&self.label).context("illegal provider name")?;
 
         match self.details {
-            ProviderDetails::Firehose(ref mut firehose)
-            | ProviderDetails::Substreams(ref mut firehose) => {
+            ProviderDetails::Firehose(ref mut firehose) => {
                 firehose.url = shellexpand::env(&firehose.url)?.into_owned();
 
                 // A Firehose url must be a valid Uri since gRPC library we use (Tonic)
@@ -735,6 +1064,9 @@ impl Provider {
                 if let Some(token) = &firehose.token {
                     firehose.token = Some(shellexpand::env(token)?.into_owned());
                 }
+                if let Some(key) = &firehose.key {
+                    firehose.key = Some(shellexpand::env(key)?.into_owned());
+                }
 
                 if firehose
                     .features
@@ -767,6 +1099,18 @@ impl Provider {
                     }
                 }
 
+                let compression_count = web3
+                    .features
+                    .iter()
+                    .filter(|f| f.starts_with("compression/"))
+                    .count();
+                if compression_count > 1 {
+                    return Err(anyhow!(
+                        "at most one compression method allowed for provider {}",
+                        self.label
+                    ));
+                }
+
                 web3.url = shellexpand::env(&web3.url)?.into_owned();
 
                 let label = &self.label;
@@ -866,15 +1210,13 @@ impl<'de> Deserialize<'de> for Provider {
                             || features.is_some()
                             || headers.is_some()
                         {
-                            return Err(serde::de::Error::custom("when `details` field is provided, deprecated `url`, `transport`, `features` and `headers` cannot be specified"));
+                            return Err(serde::de::Error::custom(
+                                "when `details` field is provided, deprecated `url`, `transport`, `features` and `headers` cannot be specified",
+                            ));
                         }
 
-                        match v {
-                            ProviderDetails::Firehose(ref mut firehose)
-                            | ProviderDetails::Substreams(ref mut firehose) => {
-                                firehose.rules = nodes
-                            }
-                            _ => {}
+                        if let ProviderDetails::Firehose(ref mut firehose) = v {
+                            firehose.rules = nodes
                         }
 
                         v
@@ -919,9 +1261,10 @@ enum ProviderField {
     Headers,
 }
 
-#[derive(Copy, Clone, Debug, Deserialize, Serialize, PartialEq)]
+#[derive(Copy, Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
 pub enum Transport {
     #[serde(rename = "rpc")]
+    #[default]
     Rpc,
     #[serde(rename = "ws")]
     Ws,
@@ -929,12 +1272,6 @@ pub enum Transport {
     Ipc,
 }
 
-impl Default for Transport {
-    fn default() -> Self {
-        Self::Rpc
-    }
-}
-
 impl std::fmt::Display for Transport {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         use Transport::*;
@@ -998,8 +1335,7 @@ impl DeploymentPlacer for Deployment {
                     .indexers
                     .iter()
                     .map(|idx| {
-                        NodeId::new(idx.clone())
-                            .map_err(|()| format!("{} is not a valid node name", idx))
+                        NodeId::new(idx).map_err(|idx| format!("{} is not a valid node name", idx))
                     })
                     .collect::<Result<Vec<_>, _>>()?;
                 Some((shards, indexers))
@@ -1046,7 +1382,7 @@ impl Rule {
             return Err(anyhow!("useless rule without indexers"));
         }
         for indexer in &self.indexers {
-            NodeId::new(indexer).map_err(|()| anyhow!("invalid node id {}", &indexer))?;
+            NodeId::new(indexer).map_err(|indexer| anyhow!("invalid node id {}", indexer))?;
         }
         self.shard_names().map_err(Error::from)?;
         Ok(())
@@ -1066,10 +1402,10 @@ impl Predicate {
     }
 
     pub fn matches(&self, name: &str, network: &str) -> bool {
-        if let Some(n) = &self.network {
-            if !n.matches(network) {
-                return false;
-            }
+        if let Some(n) = &self.network
+            && !n.matches(network)
+        {
+            return false;
         }
 
         match self.name.find(name) {
@@ -1155,6 +1491,46 @@ fn default_polling_interval() -> Duration {
     ENV_VARS.ingestor_polling_interval
 }
 
+fn default_json_rpc_timeout() -> Duration {
+    ethereum::ENV_VARS.json_rpc_timeout
+}
+
+fn default_request_retries() -> usize {
+    ethereum::ENV_VARS.request_retries
+}
+
+fn default_max_block_range_size() -> i32 {
+    ethereum::ENV_VARS.max_block_range_size
+}
+
+fn default_block_batch_size() -> usize {
+    ethereum::ENV_VARS.block_batch_size
+}
+
+fn default_block_ptr_batch_size() -> usize {
+    ethereum::ENV_VARS.block_ptr_batch_size
+}
+
+fn default_max_event_only_range() -> i32 {
+    ethereum::ENV_VARS.max_event_only_range
+}
+
+fn default_target_triggers_per_block_range() -> u64 {
+    ethereum::ENV_VARS.target_triggers_per_block_range
+}
+
+fn default_get_logs_max_contracts() -> usize {
+    ethereum::ENV_VARS.get_logs_max_contracts
+}
+
+fn default_block_ingestor_max_concurrent_json_rpc_calls() -> usize {
+    ethereum::ENV_VARS.block_ingestor_max_concurrent_json_rpc_calls
+}
+
+fn default_genesis_block_number() -> u64 {
+    ethereum::ENV_VARS.genesis_block_number
+}
+
 fn deserialize_duration_millis<'de, D>(data: D) -> Result<Duration, D::Error>
 where
     D: Deserializer<'de>,
@@ -1163,6 +1539,14 @@ where
     Ok(Duration::from_millis(millis))
 }
 
+fn deserialize_duration_secs<'de, D>(data: D) -> Result<Duration, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let secs = u64::deserialize(data)?;
+    Ok(Duration::from_secs(secs))
+}
+
 // From https://github.com/serde-rs/serde/issues/889#issuecomment-295988865
 fn string_or_vec<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
 where
@@ -1198,16 +1582,26 @@ where
 #[cfg(test)]
 mod tests {
 
-    use crate::config::{default_polling_interval, ChainSection, Web3Rule};
+    use std::time::Duration;
+
+    use crate::config::{
+        ChainSection, Web3Rule, default_block_batch_size,
+        default_block_ingestor_max_concurrent_json_rpc_calls, default_block_ptr_batch_size,
+        default_genesis_block_number, default_get_logs_max_contracts, default_json_rpc_timeout,
+        default_max_block_range_size, default_max_event_only_range, default_polling_interval,
+        default_request_retries, default_target_triggers_per_block_range,
+    };
 
     use super::{
-        Chain, Config, FirehoseProvider, Provider, ProviderDetails, Transport, Web3Provider,
+        Chain, ChainSettings, Config, FirehoseProvider, Provider, ProviderDetails, Shard,
+        Transport, Web3Provider,
     };
     use graph::blockchain::BlockchainKind;
     use graph::firehose::SubgraphLimit;
+    use graph::http::{HeaderMap, HeaderValue};
     use graph::prelude::regex::Regex;
-    use graph::prelude::{toml, NodeId};
-    use http::{HeaderMap, HeaderValue};
+    use graph::prelude::{NodeId, toml};
+    use graph_chain_ethereum::Compression;
     use std::collections::BTreeSet;
     use std::fs::read_to_string;
     use std::path::{Path, PathBuf};
@@ -1242,8 +1636,10 @@ mod tests {
             Chain {
                 shard: "primary".to_string(),
                 protocol: BlockchainKind::Ethereum,
-                polling_interval: default_polling_interval(),
                 providers: vec![],
+                amp: None,
+                cache_size: 0,
+                settings: ChainSettings::default(),
             },
             actual
         );
@@ -1264,13 +1660,40 @@ mod tests {
             Chain {
                 shard: "primary".to_string(),
                 protocol: BlockchainKind::Near,
-                polling_interval: default_polling_interval(),
                 providers: vec![],
+                amp: None,
+                cache_size: 0,
+                settings: ChainSettings::default(),
             },
             actual
         );
     }
 
+    #[test]
+    fn chain_inherits_cache_size_from_section() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            cache_size = 1000
+            [mainnet]
+            shard = "primary"
+            provider = []
+            [sepolia]
+            shard = "primary"
+            provider = []
+            cache_size = 2000
+            "#,
+        )
+        .unwrap();
+
+        section.validate().unwrap();
+
+        // mainnet inherits from section
+        assert_eq!(section.chains["mainnet"].cache_size, 1000);
+        // sepolia keeps its explicit value
+        assert_eq!(section.chains["sepolia"].cache_size, 2000);
+    }
+
     #[test]
     fn it_works_on_deprecated_provider_from_toml() {
         let actual = toml::from_str(
@@ -1334,9 +1757,9 @@ mod tests {
         "#,
         );
 
-        assert_eq!(true, actual.is_err());
+        assert!(actual.is_err());
         let err_str = actual.unwrap_err().to_string();
-        assert_eq!(err_str.contains("missing field `url`"), true, "{}", err_str);
+        assert!(err_str.contains("missing field `url`"), "{}", err_str);
     }
 
     #[test]
@@ -1349,55 +1772,9 @@ mod tests {
         "#,
         );
 
-        assert_eq!(true, actual.is_err());
+        assert!(actual.is_err());
         let err_str = actual.unwrap_err().to_string();
-        assert_eq!(
-            err_str.contains("missing field `features`"),
-            true,
-            "{}",
-            err_str
-        );
-    }
-
-    #[test]
-    fn fails_if_non_substreams_provider_for_substreams_protocol() {
-        let mut actual = toml::from_str::<ChainSection>(
-            r#"
-            ingestor = "block_ingestor_node"
-            [mainnet]
-            shard = "primary"
-            protocol = "substreams"
-            provider = [
-              { label = "firehose", details = { type = "firehose", url = "http://127.0.0.1:8888", token = "TOKEN", features = ["filters"] }},
-            ]
-        "#,
-        )
-        .unwrap();
-        let err = actual.validate().unwrap_err().to_string();
-
-        assert!(err.contains("only supports substreams providers"), "{err}");
-    }
-
-    #[test]
-    fn fails_if_only_substreams_provider_for_non_substreams_protocol() {
-        let mut actual = toml::from_str::<ChainSection>(
-            r#"
-            ingestor = "block_ingestor_node"
-            [mainnet]
-            shard = "primary"
-            protocol = "ethereum"
-            provider = [
-              { label = "firehose", details = { type = "substreams", url = "http://127.0.0.1:8888", token = "TOKEN", features = ["filters"] }},
-            ]
-        "#,
-        )
-        .unwrap();
-        let err = actual.validate().unwrap_err().to_string();
-
-        assert!(
-            err.contains("ethereum protocol requires an rpc or firehose endpoint defined"),
-            "{err}"
-        );
+        assert!(err_str.contains("missing field `features`"), "{}", err_str);
     }
 
     #[test]
@@ -1466,9 +1843,9 @@ mod tests {
         "#,
         );
 
-        assert_eq!(true, actual.is_err());
+        assert!(actual.is_err());
         let err_str = actual.unwrap_err().to_string();
-        assert_eq!(err_str.contains("when `details` field is provided, deprecated `url`, `transport`, `features` and `headers` cannot be specified"),true, "{}", err_str);
+        assert!(err_str.contains("when `details` field is provided, deprecated `url`, `transport`, `features` and `headers` cannot be specified"), "{}", err_str);
     }
 
     #[test]
@@ -1487,6 +1864,7 @@ mod tests {
                 details: ProviderDetails::Firehose(FirehoseProvider {
                     url: "http://localhost:9000".to_owned(),
                     token: None,
+                    key: None,
                     features: BTreeSet::new(),
                     conn_pool_size: 20,
                     rules: vec![],
@@ -1497,29 +1875,18 @@ mod tests {
     }
 
     #[test]
-    fn it_works_on_substreams_provider_from_toml() {
-        let actual = toml::from_str(
+    fn it_fails_for_substreams() {
+        let actual: Result<Provider, _> = toml::from_str(
             r#"
                 label = "bananas"
                 details = { type = "substreams", url = "http://localhost:9000", features = [] }
             "#,
-        )
-        .unwrap();
-
-        assert_eq!(
-            Provider {
-                label: "bananas".to_owned(),
-                details: ProviderDetails::Substreams(FirehoseProvider {
-                    url: "http://localhost:9000".to_owned(),
-                    token: None,
-                    features: BTreeSet::new(),
-                    conn_pool_size: 20,
-                    rules: vec![],
-                }),
-            },
-            actual
         );
+        assert!(actual.is_err());
+        let err = actual.unwrap_err().to_string();
+        assert!(err.contains("unknown variant `substreams`"));
     }
+
     #[test]
     fn it_works_on_new_firehose_provider_from_toml_no_features() {
         let mut actual = toml::from_str(
@@ -1536,6 +1903,7 @@ mod tests {
                 details: ProviderDetails::Firehose(FirehoseProvider {
                     url: "http://localhost:9000".to_owned(),
                     token: None,
+                    key: None,
                     features: BTreeSet::new(),
                     conn_pool_size: 20,
                     rules: vec![],
@@ -1565,6 +1933,7 @@ mod tests {
                 details: ProviderDetails::Firehose(FirehoseProvider {
                     url: "http://localhost:9000".to_owned(),
                     token: None,
+                    key: None,
                     features: BTreeSet::new(),
                     conn_pool_size: 20,
                     rules: vec![
@@ -1585,132 +1954,17 @@ mod tests {
     }
 
     #[test]
-    fn it_errors_on_firehose_provider_with_high_limit() {
-        let mut actual = toml::from_str(
+    fn it_works_on_new_firehose_provider_from_toml_unsupported_features() {
+        let actual = toml::from_str::<Provider>(
             r#"
-                label = "substreams"
-                details = { type = "substreams", url = "http://localhost:9000" }
-                match = [
-                  { name = "some_node_.*", limit = 101 },
-                  { name = "other_node_.*", limit = 0 } ]
+                label = "firehose"
+                details = { type = "firehose", url = "http://localhost:9000", features = ["bananas"]}
             "#,
-        )
-        .unwrap();
-
-        assert_eq!(
-            Provider {
-                label: "substreams".to_owned(),
-                details: ProviderDetails::Substreams(FirehoseProvider {
-                    url: "http://localhost:9000".to_owned(),
-                    token: None,
-                    features: BTreeSet::new(),
-                    conn_pool_size: 20,
-                    rules: vec![
-                        Web3Rule {
-                            name: Regex::new("some_node_.*").unwrap(),
-                            limit: 101,
-                        },
-                        Web3Rule {
-                            name: Regex::new("other_node_.*").unwrap(),
-                            limit: 0,
-                        }
-                    ],
-                }),
-            },
-            actual
-        );
-        assert! { actual.validate().is_err()};
-    }
-
-    #[test]
-    fn it_works_on_new_substreams_provider_with_doc_example_match() {
-        let mut actual = toml::from_str(
-            r#"
-                label = "substreams"
-                details = { type = "substreams", url = "http://localhost:9000" }
-                match = [
-                  { name = "some_node_.*", limit = 10 },
-                  { name = "other_node_.*", limit = 0 } ]
-            "#,
-        )
-        .unwrap();
-
-        assert_eq!(
-            Provider {
-                label: "substreams".to_owned(),
-                details: ProviderDetails::Substreams(FirehoseProvider {
-                    url: "http://localhost:9000".to_owned(),
-                    token: None,
-                    features: BTreeSet::new(),
-                    conn_pool_size: 20,
-                    rules: vec![
-                        Web3Rule {
-                            name: Regex::new("some_node_.*").unwrap(),
-                            limit: 10,
-                        },
-                        Web3Rule {
-                            name: Regex::new("other_node_.*").unwrap(),
-                            limit: 0,
-                        }
-                    ],
-                }),
-            },
-            actual
-        );
-        assert! { actual.validate().is_ok()};
-    }
-
-    #[test]
-    fn it_errors_on_substreams_provider_with_high_limit() {
-        let mut actual = toml::from_str(
-            r#"
-                label = "substreams"
-                details = { type = "substreams", url = "http://localhost:9000" }
-                match = [
-                  { name = "some_node_.*", limit = 101 },
-                  { name = "other_node_.*", limit = 0 } ]
-            "#,
-        )
-        .unwrap();
-
-        assert_eq!(
-            Provider {
-                label: "substreams".to_owned(),
-                details: ProviderDetails::Substreams(FirehoseProvider {
-                    url: "http://localhost:9000".to_owned(),
-                    token: None,
-                    features: BTreeSet::new(),
-                    conn_pool_size: 20,
-                    rules: vec![
-                        Web3Rule {
-                            name: Regex::new("some_node_.*").unwrap(),
-                            limit: 101,
-                        },
-                        Web3Rule {
-                            name: Regex::new("other_node_.*").unwrap(),
-                            limit: 0,
-                        }
-                    ],
-                }),
-            },
-            actual
-        );
-        assert! { actual.validate().is_err()};
-    }
-
-    #[test]
-    fn it_works_on_new_firehose_provider_from_toml_unsupported_features() {
-        let actual = toml::from_str::<Provider>(
-            r#"
-                label = "firehose"
-                details = { type = "firehose", url = "http://localhost:9000", features = ["bananas"]}
-            "#,
-        ).unwrap().validate();
-        assert_eq!(true, actual.is_err(), "{:?}", actual);
+        ).unwrap().validate();
+        assert!(actual.is_err(), "{:?}", actual);
 
         if let Err(error) = actual {
-            assert_eq!(
-                true,
+            assert!(
                 error
                     .to_string()
                     .starts_with("supported firehose endpoint filters are:")
@@ -1797,6 +2051,117 @@ mod tests {
         assert!(SubgraphLimit::Limit(10) > SubgraphLimit::Disabled);
     }
 
+    #[test]
+    fn it_parses_web3_provider_with_gzip_compression_feature() {
+        let actual: Provider = toml::from_str(
+            r#"
+            label = "compressed"
+            details = { type = "web3", url = "http://localhost:8545", features = ["archive", "compression/gzip"] }
+        "#,
+        )
+        .unwrap();
+
+        let mut features = BTreeSet::new();
+        features.insert("archive".to_string());
+        features.insert("compression/gzip".to_string());
+
+        assert_eq!(
+            Provider {
+                label: "compressed".to_owned(),
+                details: ProviderDetails::Web3(Web3Provider {
+                    transport: Transport::Rpc,
+                    url: "http://localhost:8545".to_owned(),
+                    features,
+                    headers: HeaderMap::new(),
+                    rules: Vec::new(),
+                }),
+            },
+            actual
+        );
+
+        match actual.details {
+            ProviderDetails::Web3(ref web3) => {
+                assert_eq!(web3.compression(), Compression::Gzip);
+            }
+            _ => panic!("expected Web3 provider"),
+        }
+    }
+
+    #[test]
+    fn it_parses_web3_provider_with_brotli_compression_feature() {
+        let actual: Provider = toml::from_str(
+            r#"
+            label = "compressed"
+            details = { type = "web3", url = "http://localhost:8545", features = ["archive", "compression/brotli"] }
+        "#,
+        )
+        .unwrap();
+
+        match actual.details {
+            ProviderDetails::Web3(ref web3) => {
+                assert_eq!(web3.compression(), Compression::Brotli);
+            }
+            _ => panic!("expected Web3 provider"),
+        }
+    }
+
+    #[test]
+    fn it_parses_web3_provider_with_deflate_compression_feature() {
+        let actual: Provider = toml::from_str(
+            r#"
+            label = "compressed"
+            details = { type = "web3", url = "http://localhost:8545", features = ["archive", "compression/deflate"] }
+        "#,
+        )
+        .unwrap();
+
+        match actual.details {
+            ProviderDetails::Web3(ref web3) => {
+                assert_eq!(web3.compression(), Compression::Deflate);
+            }
+            _ => panic!("expected Web3 provider"),
+        }
+    }
+
+    #[test]
+    fn it_parses_web3_provider_without_compression_feature() {
+        let actual: Provider = toml::from_str(
+            r#"
+            label = "uncompressed"
+            details = { type = "web3", url = "http://localhost:8545", features = ["archive"] }
+        "#,
+        )
+        .unwrap();
+
+        match actual.details {
+            ProviderDetails::Web3(ref web3) => {
+                assert_eq!(web3.compression(), Compression::None);
+            }
+            _ => panic!("expected Web3 provider"),
+        }
+    }
+
+    #[test]
+    fn it_rejects_multiple_compression_features() {
+        let mut actual: Provider = toml::from_str(
+            r#"
+            label = "multi-comp"
+            details = { type = "web3", url = "http://localhost:8545", features = ["compression/gzip", "compression/brotli"] }
+        "#,
+        )
+        .unwrap();
+
+        let err = actual.validate();
+        assert!(err.is_err());
+        let err = err.unwrap_err();
+        assert!(
+            err.to_string()
+                .contains("at most one compression method allowed"),
+            "result: {:?}",
+            err
+        );
+    }
+
     #[test]
     fn duplicated_labels_are_not_allowed_within_chain() {
         let mut actual = toml::from_str::<ChainSection>(
@@ -1813,14 +2178,9 @@ mod tests {
         .unwrap();
 
         let err = actual.validate();
-        assert_eq!(true, err.is_err());
+        assert!(err.is_err());
         let err = err.unwrap_err();
-        assert_eq!(
-            true,
-            err.to_string().contains("unique"),
-            "result: {:?}",
-            err
-        );
+        assert!(err.to_string().contains("unique"), "result: {:?}", err);
     }
 
     #[test]
@@ -1845,7 +2205,7 @@ mod tests {
         .unwrap();
 
         let result = actual.validate();
-        assert_eq!(true, result.is_ok(), "error: {:?}", result.unwrap_err());
+        assert!(result.is_ok(), "error: {:?}", result.unwrap_err());
     }
 
     #[test]
@@ -1865,7 +2225,12 @@ mod tests {
 
         assert_eq!(
             default,
-            actual.chains.get("mainnet").unwrap().polling_interval
+            actual
+                .chains
+                .get("mainnet")
+                .unwrap()
+                .settings
+                .polling_interval
         );
 
         // Polling interval set explicitly, use that
@@ -1885,7 +2250,544 @@ mod tests {
 
         assert_eq!(
             different,
-            actual.chains.get("mainnet").unwrap().polling_interval
+            actual
+                .chains
+                .get("mainnet")
+                .unwrap()
+                .settings
+                .polling_interval
+        );
+    }
+
+    #[test]
+    fn pool_sizes() {
+        let index = NodeId::new("index_node_1").unwrap();
+        let query = NodeId::new("query_node_1").unwrap();
+        let other = NodeId::new("other_node_1").unwrap();
+
+        let appname = std::env::var("PGAPPNAME").ok();
+        unsafe {
+            std::env::set_var("PGAPPNAME", "config-test");
+        }
+        let shard = {
+            let mut shard = toml::from_str::<Shard>(
+                r#"
+            connection = "postgresql://postgres:postgres@postgres/graph"
+pool_size = [
+  { node = "index_node_.*", size = 20 },
+  { node = "query_node_.*", size = 40 }]
+fdw_pool_size = [
+  { node = "index_node_.*", size = 10 },
+  { node = ".*", size = 5 },
+]"#,
+            )
+            .unwrap();
+
+            shard
+                .validate("shard_1", &NodeId::new("index_node_1").unwrap())
+                .unwrap();
+            shard
+        };
+        if let Some(appname) = appname {
+            unsafe {
+                std::env::set_var("PGAPPNAME", appname);
+            }
+        }
+
+        assert_eq!(
+            shard.connection,
+            "postgresql://postgres:postgres@postgres/graph?application_name=config-test"
+        );
+
+        assert_eq!(shard.pool_size.size_for(&index, "ashard").unwrap(), 20);
+        assert_eq!(shard.pool_size.size_for(&query, "ashard").unwrap(), 40);
+        assert!(shard.pool_size.size_for(&other, "ashard").is_err());
+
+        assert_eq!(shard.fdw_pool_size.size_for(&index, "ashard").unwrap(), 10);
+        assert_eq!(shard.fdw_pool_size.size_for(&query, "ashard").unwrap(), 5);
+        assert_eq!(shard.fdw_pool_size.size_for(&other, "ashard").unwrap(), 5);
+    }
+
+    #[test]
+    fn amp_chain_names_parsed_from_toml() {
+        let actual: Chain = toml::from_str(
+            r#"
+            shard = "primary"
+            provider = []
+            amp = "ethereum-mainnet"
+        "#,
+        )
+        .unwrap();
+
+        assert_eq!(actual.amp, Some("ethereum-mainnet".to_string()));
+    }
+
+    #[test]
+    fn amp_chain_names_default_when_absent() {
+        let actual: Chain = toml::from_str(
+            r#"
+            shard = "primary"
+            provider = []
+        "#,
+        )
+        .unwrap();
+
+        assert_eq!(actual.amp, None);
+    }
+
+    #[test]
+    fn amp_chain_names_validation_rejects_duplicate_effective_names() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            provider = []
+            amp = "eth"
+            [sepolia]
+            shard = "primary"
+            provider = []
+            amp = "eth"
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate();
+        assert!(err.is_err());
+        assert!(
+            err.unwrap_err().to_string().contains("duplicate AMP name"),
+            "expected duplicate AMP name error"
+        );
+    }
+
+    #[test]
+    fn amp_chain_names_validation_rejects_alias_colliding_with_chain_name() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            provider = []
+            [sepolia]
+            shard = "primary"
+            provider = []
+            amp = "mainnet"
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate();
+        assert!(err.is_err());
+        let msg = err.unwrap_err().to_string();
+        // The alias "mainnet" on sepolia collides with the chain named
+        // "mainnet" whose effective AMP name is also "mainnet".
+        assert!(
+            msg.contains("duplicate AMP name") || msg.contains("collides with chain"),
+            "expected collision/duplicate error, got: {msg}"
+        );
+    }
+
+    #[test]
+    fn amp_chain_names_builds_correct_mapping() {
+        let section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            provider = []
+            amp = "ethereum-mainnet"
+            [sepolia]
+            shard = "primary"
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let config = Config {
+            node: NodeId::new("test").unwrap(),
+            disable_block_ingestor: false,
+            general: None,
+            stores: {
+                let mut s = std::collections::BTreeMap::new();
+                s.insert(
+                    "primary".to_string(),
+                    toml::from_str::<Shard>(r#"connection = "postgresql://u:p@h/db""#).unwrap(),
+                );
+                s
+            },
+            chains: section,
+            deployment: toml::from_str("[[rule]]\nshards = [\"primary\"]\nindexers = [\"test\"]")
+                .unwrap(),
+            log_store: None,
+        };
+
+        let amp = config.amp_chain_names();
+        // Explicit alias resolves
+        assert_eq!(
+            amp.resolve(&"ethereum-mainnet".into()),
+            graph::components::network_provider::ChainName::from("mainnet")
+        );
+        // Identity for chain without alias
+        assert_eq!(
+            amp.resolve(&"sepolia".into()),
+            graph::components::network_provider::ChainName::from("sepolia")
+        );
+        // Unknown name passes through
+        assert_eq!(
+            amp.resolve(&"unknown".into()),
+            graph::components::network_provider::ChainName::from("unknown")
+        );
+    }
+
+    #[test]
+    fn is_block_ingestor() {
+        let make_config = |node: &str, ingestor: &str, disable: bool| -> Config {
+            let section: ChainSection =
+                toml::from_str(&format!(r#"ingestor = "{}""#, ingestor)).unwrap();
+            Config {
+                node: NodeId::new(node).unwrap(),
+                disable_block_ingestor: disable,
+                general: None,
+                stores: {
+                    let mut s = std::collections::BTreeMap::new();
+                    s.insert(
+                        "primary".to_string(),
+                        toml::from_str::<Shard>(r#"connection = "postgresql://u:p@h/db""#).unwrap(),
+                    );
+                    s
+                },
+                chains: section,
+                deployment: toml::from_str(
+                    "[[rule]]\nshards = [\"primary\"]\nindexers = [\"test\"]",
+                )
+                .unwrap(),
+                log_store: None,
+            }
+        };
+
+        // Node matches ingestor, not disabled
+        assert!(make_config("index-0", "index-0", false).is_block_ingestor());
+
+        // Node does not match ingestor
+        assert!(!make_config("query-0", "index-0", false).is_block_ingestor());
+
+        // Node matches but kill switch is on
+        assert!(!make_config("index-0", "index-0", true).is_block_ingestor());
+
+        // Node does not match and kill switch is on
+        assert!(!make_config("query-0", "index-0", true).is_block_ingestor());
+    }
+
+    #[test]
+    fn chain_settings_valid_overrides() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            json_rpc_timeout = 300
+            request_retries = 15
+            max_block_range_size = 2000
+            block_batch_size = 20
+            block_ptr_batch_size = 50
+            max_event_only_range = 1000
+            target_triggers_per_block_range = 200
+            get_logs_max_contracts = 5000
+            block_ingestor_max_concurrent_json_rpc_calls = 500
+            genesis_block_number = 1
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        assert!(section.validate().is_ok());
+        let settings = &section.chains.get("mainnet").unwrap().settings;
+        assert_eq!(settings.json_rpc_timeout, Duration::from_secs(300));
+        assert_eq!(settings.request_retries, 15);
+        assert_eq!(settings.max_block_range_size, 2000);
+        assert_eq!(settings.block_batch_size, 20);
+        assert_eq!(settings.block_ptr_batch_size, 50);
+        assert_eq!(settings.max_event_only_range, 1000);
+        assert_eq!(settings.target_triggers_per_block_range, 200);
+        assert_eq!(settings.get_logs_max_contracts, 5000);
+        assert_eq!(settings.block_ingestor_max_concurrent_json_rpc_calls, 500);
+        assert_eq!(settings.genesis_block_number, 1);
+    }
+
+    #[test]
+    fn chain_settings_defaults_match_env_vars() {
+        let settings = ChainSettings::default();
+        assert_eq!(settings.polling_interval, default_polling_interval());
+        assert_eq!(settings.json_rpc_timeout, default_json_rpc_timeout());
+        assert_eq!(settings.request_retries, default_request_retries());
+        assert_eq!(
+            settings.max_block_range_size,
+            default_max_block_range_size()
+        );
+        assert_eq!(settings.block_batch_size, default_block_batch_size());
+        assert_eq!(
+            settings.block_ptr_batch_size,
+            default_block_ptr_batch_size()
+        );
+        assert_eq!(
+            settings.max_event_only_range,
+            default_max_event_only_range()
+        );
+        assert_eq!(
+            settings.target_triggers_per_block_range,
+            default_target_triggers_per_block_range()
+        );
+        assert_eq!(
+            settings.get_logs_max_contracts,
+            default_get_logs_max_contracts()
+        );
+        assert_eq!(
+            settings.block_ingestor_max_concurrent_json_rpc_calls,
+            default_block_ingestor_max_concurrent_json_rpc_calls()
+        );
+        assert_eq!(
+            settings.genesis_block_number,
+            default_genesis_block_number()
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_max_block_range_size() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            max_block_range_size = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("max_block_range_size must be > 0"),
+            "expected max_block_range_size error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_negative_max_block_range_size() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            max_block_range_size = -1
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("max_block_range_size must be > 0"),
+            "expected max_block_range_size error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_max_event_only_range() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            max_event_only_range = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("max_event_only_range must be > 0"),
+            "expected max_event_only_range error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_block_batch_size() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            block_batch_size = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("block_batch_size must be > 0"),
+            "expected block_batch_size error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_block_ptr_batch_size() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            block_ptr_batch_size = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("block_ptr_batch_size must be > 0"),
+            "expected block_ptr_batch_size error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_concurrent_json_rpc_calls() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            block_ingestor_max_concurrent_json_rpc_calls = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("block_ingestor_max_concurrent_json_rpc_calls must be > 0"),
+            "expected block_ingestor_max_concurrent_json_rpc_calls error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_get_logs_max_contracts() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            get_logs_max_contracts = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("get_logs_max_contracts must be > 0"),
+            "expected get_logs_max_contracts error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_polling_interval() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            polling_interval = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("polling_interval must be > 0"),
+            "expected polling_interval error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_json_rpc_timeout() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            json_rpc_timeout = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("json_rpc_timeout must be > 0"),
+            "expected json_rpc_timeout error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_request_retries() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            request_retries = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("request_retries must be > 0"),
+            "expected request_retries error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_rejects_zero_target_triggers_per_block_range() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "primary"
+            target_triggers_per_block_range = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("target_triggers_per_block_range must be > 0"),
+            "expected target_triggers_per_block_range error, got: {err}"
+        );
+    }
+
+    #[test]
+    fn chain_settings_validation_error_includes_chain_name() {
+        let mut section = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [my_chain]
+            shard = "primary"
+            block_batch_size = 0
+            provider = []
+            "#,
+        )
+        .unwrap();
+
+        let err = section.validate().unwrap_err().to_string();
+        assert!(
+            err.contains("my_chain"),
+            "expected chain name in error, got: {err}"
         );
     }
 }
diff --git a/node/src/helpers.rs b/node/src/helpers.rs
new file mode 100644
index 00000000000..2cef6c70eb7
--- /dev/null
+++ b/node/src/helpers.rs
@@ -0,0 +1,120 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use graph::prelude::{
+    BlockPtr, DeploymentHash, NodeId, SubgraphRegistrarError, SubgraphStore as SubgraphStoreTrait,
+};
+use graph::slog::{Logger, error, info};
+use graph::{
+    components::store::DeploymentLocator,
+    prelude::{SubgraphName, SubgraphRegistrar},
+};
+use graph_store_postgres::SubgraphStore;
+use tokio::sync::mpsc::Receiver;
+
+/// Cleanup a subgraph
+/// This is used to remove a subgraph before redeploying it when using the watch flag
+async fn cleanup_dev_subgraph(
+    logger: &Logger,
+    subgraph_store: &SubgraphStore,
+    name: &SubgraphName,
+    locator: &DeploymentLocator,
+) -> Result<()> {
+    info!(logger, "Removing subgraph"; "name" => name.to_string(), "id" => locator.id.to_string(), "hash" => locator.hash.to_string());
+    subgraph_store.remove_subgraph(name.clone()).await?;
+    subgraph_store.unassign_subgraph(locator).await?;
+    subgraph_store.remove_deployment(locator.id.into()).await?;
+    info!(logger, "Subgraph removed"; "name" => name.to_string(), "id" => locator.id.to_string(), "hash" => locator.hash.to_string());
+    Ok(())
+}
+
+async fn deploy_subgraph(
+    logger: &Logger,
+    subgraph_registrar: Arc<impl SubgraphRegistrar>,
+    name: SubgraphName,
+    subgraph_id: DeploymentHash,
+    node_id: NodeId,
+    debug_fork: Option<DeploymentHash>,
+    start_block: Option<BlockPtr>,
+) -> Result<DeploymentLocator, SubgraphRegistrarError> {
+    info!(logger, "Re-deploying subgraph"; "name" => name.to_string(), "id" => subgraph_id.to_string());
+    subgraph_registrar.create_subgraph(name.clone()).await?;
+    subgraph_registrar
+        .create_subgraph_version(
+            name.clone(),
+            subgraph_id.clone(),
+            node_id,
+            debug_fork,
+            start_block,
+            None,
+            None,
+            true,
+        )
+        .await
+        .inspect(|locator| {
+            info!(logger, "Subgraph deployed"; "name" => name.to_string(), "id" => subgraph_id.to_string(), "locator" => locator.to_string());
+        })
+}
+
+async fn drop_and_recreate_subgraph(
+    logger: &Logger,
+    subgraph_store: Arc<SubgraphStore>,
+    subgraph_registrar: Arc<impl SubgraphRegistrar>,
+    name: SubgraphName,
+    subgraph_id: DeploymentHash,
+    node_id: NodeId,
+    hash: DeploymentHash,
+) -> Result<DeploymentLocator> {
+    let locator = subgraph_store.active_locator(&hash).await?;
+    if let Some(locator) = locator.clone() {
+        cleanup_dev_subgraph(logger, &subgraph_store, &name, &locator).await?;
+    }
+
+    deploy_subgraph(
+        logger,
+        subgraph_registrar,
+        name,
+        subgraph_id,
+        node_id,
+        None,
+        None,
+    )
+    .await
+    .map_err(|e| anyhow::anyhow!("Failed to deploy subgraph: {}", e))
+}
+
+/// Watch for subgraph updates, drop and recreate them
+/// This is used to listen to file changes in the subgraph directory
+/// And drop and recreate the subgraph when it changes
+pub async fn watch_subgraph_updates(
+    logger: &Logger,
+    subgraph_store: Arc<SubgraphStore>,
+    subgraph_registrar: Arc<impl SubgraphRegistrar>,
+    node_id: NodeId,
+    mut rx: Receiver<(DeploymentHash, SubgraphName)>,
+) {
+    while let Some((hash, name)) = rx.recv().await {
+        let res = drop_and_recreate_subgraph(
+            logger,
+            subgraph_store.clone(),
+            subgraph_registrar.clone(),
+            name.clone(),
+            hash.clone(),
+            node_id.clone(),
+            hash.clone(),
+        )
+        .await;
+
+        if let Err(e) = res {
+            error!(logger, "Failed to drop and recreate subgraph";
+                "name" => name.to_string(),
+                "hash" => hash.to_string(),
+                "error" => e.to_string()
+            );
+            std::process::exit(1);
+        }
+    }
+
+    error!(logger, "Subgraph watcher terminated unexpectedly"; "action" => "exiting");
+    std::process::exit(1);
+}
diff --git a/node/src/launcher.rs b/node/src/launcher.rs
new file mode 100644
index 00000000000..18ee4c727db
--- /dev/null
+++ b/node/src/launcher.rs
@@ -0,0 +1,891 @@
+use std::{
+    io::{BufRead, BufReader},
+    path::Path,
+    time::Duration,
+};
+
+use anyhow::Result;
+use git_testament::{git_testament, render_testament};
+use graph::components::link_resolver::{ArweaveClient, FileSizeLimit};
+use graph::components::subgraph::Settings;
+use graph::data::graphql::load_manager::LoadManager;
+use graph::endpoint::EndpointMetrics;
+use graph::env::EnvVars;
+use graph::futures03::future::TryFutureExt;
+use graph::prelude::*;
+use graph::prometheus::Registry;
+use graph::url::Url;
+use graph::{
+    amp,
+    blockchain::{Blockchain, BlockchainKind, BlockchainMap},
+    components::network_provider::AmpChainNames,
+};
+use graph_core::polling_monitor::{ArweaveService, IpfsService, arweave_service};
+use graph_graphql::prelude::GraphQlRunner;
+use graph_server_http::GraphQLServer as GraphQLQueryServer;
+use graph_server_index_node::IndexNodeServer;
+use graph_server_json_rpc::JsonRpcServer;
+use graph_server_metrics::PrometheusMetricsServer;
+use graph_store_postgres::{
+    ChainHeadUpdateListener, ConnectionPool, NotificationSender, Store, SubgraphStore,
+    SubscriptionManager, register_jobs as register_store_jobs,
+};
+use graphman_server::GraphmanServer;
+use graphman_server::GraphmanServerConfig;
+use tokio::sync::mpsc;
+use tokio_util::sync::CancellationToken;
+
+use crate::config::Config;
+use crate::helpers::watch_subgraph_updates;
+use crate::network_setup::Networks;
+use crate::opt::Opt;
+use crate::store_builder::StoreBuilder;
+
+git_testament!(TESTAMENT);
+
+/// Sets up metrics and monitoring
+pub fn setup_metrics(logger: &Logger) -> (Arc<Registry>, Arc<MetricsRegistry>) {
+    // Set up Prometheus registry
+    let prometheus_registry = Arc::new(Registry::new());
+    let metrics_registry = Arc::new(MetricsRegistry::new(
+        logger.clone(),
+        prometheus_registry.clone(),
+    ));
+
+    (prometheus_registry, metrics_registry)
+}
+
+/// Sets up the store and database connections
+async fn setup_store(
+    logger: &Logger,
+    node_id: &NodeId,
+    config: &Config,
+    fork_base: Option<Url>,
+    metrics_registry: Arc<MetricsRegistry>,
+) -> (
+    ConnectionPool,
+    Arc<SubscriptionManager>,
+    Arc<ChainHeadUpdateListener>,
+    Arc<Store>,
+) {
+    let store_builder = StoreBuilder::new(
+        logger,
+        node_id,
+        config,
+        fork_base,
+        metrics_registry.cheap_clone(),
+    )
+    .await;
+
+    let primary_pool = store_builder.primary_pool();
+    let subscription_manager = store_builder.subscription_manager();
+    let chain_head_update_listener = store_builder.chain_head_update_listener();
+    let network_store = store_builder.network_store(config.chain_ids()).await;
+
+    (
+        primary_pool,
+        subscription_manager,
+        chain_head_update_listener,
+        network_store,
+    )
+}
+
+async fn build_blockchain_map(
+    logger: &Logger,
+    config: &Config,
+    env_vars: &Arc<EnvVars>,
+    network_store: Arc<Store>,
+    metrics_registry: Arc<MetricsRegistry>,
+    endpoint_metrics: Arc<EndpointMetrics>,
+    chain_head_update_listener: Arc<ChainHeadUpdateListener>,
+    logger_factory: &LoggerFactory,
+) -> Arc<BlockchainMap> {
+    use graph::components::network_provider;
+    let block_store = network_store.block_store();
+
+    let mut provider_checks: Vec<Arc<dyn network_provider::ProviderCheck>> = Vec::new();
+
+    if env_vars.genesis_validation_enabled {
+        provider_checks.push(Arc::new(network_provider::GenesisHashCheck::from_id_store(
+            Box::new(block_store.cheap_clone()),
+        )));
+    }
+
+    provider_checks.push(Arc::new(network_provider::ExtendedBlocksCheck::new(
+        env_vars
+            .firehose_disable_extended_blocks_for_chains
+            .iter()
+            .map(|x| x.as_str().into()),
+    )));
+
+    let network_adapters = Networks::from_config(
+        logger.cheap_clone(),
+        config,
+        metrics_registry.cheap_clone(),
+        endpoint_metrics,
+        &provider_checks,
+    )
+    .await
+    .expect("unable to parse network configuration");
+
+    let blockchain_map = network_adapters
+        .blockchain_map(
+            env_vars,
+            logger,
+            block_store,
+            logger_factory,
+            metrics_registry.cheap_clone(),
+            chain_head_update_listener,
+        )
+        .await;
+
+    Arc::new(blockchain_map)
+}
+
+async fn cleanup_ethereum_shallow_blocks(
+    blockchain_map: &BlockchainMap,
+    network_store: &Arc<Store>,
+) {
+    match blockchain_map
+        .get_all_by_kind::<graph_chain_ethereum::Chain>(BlockchainKind::Ethereum)
+        .ok()
+        .map(|chains| {
+            chains
+                .iter()
+                .flat_map(|c| {
+                    if !c.chain_client().is_firehose() {
+                        Some(c.name.to_string())
+                    } else {
+                        None
+                    }
+                })
+                .collect()
+        }) {
+        Some(eth_network_names) => {
+            network_store
+                .block_store()
+                .cleanup_ethereum_shallow_blocks(eth_network_names)
+                .await
+                .unwrap();
+        }
+        // This code path only happens if the downcast on the blockchain map fails, that
+        // probably means we have a problem with the chain loading logic so it's probably
+        // safest to just refuse to start.
+        None => unreachable!(
+            "If you are seeing this message just use a different version of graph-node"
+        ),
+    }
+}
+
+async fn spawn_block_ingestor(
+    logger: &Logger,
+    blockchain_map: &Arc<BlockchainMap>,
+    network_store: &Arc<Store>,
+    primary_pool: ConnectionPool,
+    metrics_registry: &Arc<MetricsRegistry>,
+) {
+    let logger = logger.clone();
+    let ingestors = Networks::block_ingestors(&logger, blockchain_map)
+        .await
+        .expect("unable to start block ingestors");
+
+    ingestors.into_iter().for_each(|ingestor| {
+        let logger = logger.clone();
+        info!(logger,"Starting block ingestor for network";"network_name" => &ingestor.network_name().as_str(), "kind" => ingestor.kind().to_string());
+
+        graph::spawn(ingestor.run());
+    });
+
+    // Start a task runner
+    let mut job_runner = graph::util::jobs::Runner::new(&logger);
+    register_store_jobs(
+        &mut job_runner,
+        network_store.clone(),
+        primary_pool,
+        metrics_registry.clone(),
+    );
+    graph::spawn_blocking(job_runner.start());
+}
+
+fn deploy_subgraph_from_flag(
+    subgraph: String,
+    opt: &Opt,
+    subgraph_registrar: Arc<impl SubgraphRegistrar>,
+    node_id: NodeId,
+) {
+    let (name, hash) = if subgraph.contains(':') {
+        let mut split = subgraph.split(':');
+        (split.next().unwrap(), split.next().unwrap().to_owned())
+    } else {
+        ("cli", subgraph)
+    };
+
+    let name = SubgraphName::new(name)
+        .expect("Subgraph name must contain only a-z, A-Z, 0-9, '-' and '_'");
+    let subgraph_id = DeploymentHash::new(hash).expect("Subgraph hash must be a valid IPFS hash");
+    let debug_fork = opt
+        .debug_fork
+        .clone()
+        .map(DeploymentHash::new)
+        .map(|h| h.expect("Debug fork hash must be a valid IPFS hash"));
+    let start_block = opt
+        .start_block
+        .clone()
+        .map(|block| {
+            let mut split = block.split(':');
+            (
+                // BlockHash
+                split.next().unwrap().to_owned(),
+                // BlockNumber
+                split.next().unwrap().parse::<i64>().unwrap(),
+            )
+        })
+        .map(|(hash, number)| BlockPtr::try_from((hash.as_str(), number)))
+        .map(Result::unwrap);
+
+    graph::spawn(
+        async move {
+            subgraph_registrar.create_subgraph(name.clone()).await?;
+            subgraph_registrar
+                .create_subgraph_version(
+                    name,
+                    subgraph_id,
+                    node_id,
+                    debug_fork,
+                    start_block,
+                    None,
+                    None,
+                    false,
+                )
+                .await
+        }
+        .map_err(|e| panic!("Failed to deploy subgraph from `--subgraph` flag: {}", e)),
+    );
+}
+
+fn build_subgraph_registrar<AC>(
+    metrics_registry: Arc<MetricsRegistry>,
+    network_store: &Arc<Store>,
+    logger_factory: &LoggerFactory,
+    env_vars: &Arc<EnvVars>,
+    blockchain_map: Arc<BlockchainMap>,
+    node_id: NodeId,
+    subgraph_settings: Settings,
+    link_resolver: Arc<dyn LinkResolver>,
+    subscription_manager: Arc<SubscriptionManager>,
+    arweave_service: ArweaveService,
+    ipfs_service: IpfsService,
+    amp_client: Option<Arc<AC>>,
+    cancel_token: CancellationToken,
+    amp_chain_names: Arc<AmpChainNames>,
+) -> Arc<
+    graph_core::subgraph::SubgraphRegistrar<
+        graph_core::subgraph_provider::SubgraphProvider,
+        SubgraphStore,
+        SubscriptionManager,
+        AC,
+    >,
+>
+where
+    AC: amp::Client + Send + Sync + 'static,
+{
+    let static_filters = ENV_VARS.experimental_static_filters;
+    let sg_count = Arc::new(SubgraphCountMetric::new(metrics_registry.cheap_clone()));
+
+    let mut subgraph_instance_managers =
+        graph_core::subgraph_provider::SubgraphInstanceManagers::new();
+
+    if let Some(amp_client) = amp_client.cheap_clone() {
+        let amp_instance_manager = graph_core::amp_subgraph::Manager::new(
+            logger_factory,
+            metrics_registry.cheap_clone(),
+            env_vars.cheap_clone(),
+            &cancel_token,
+            network_store.subgraph_store(),
+            link_resolver.cheap_clone(),
+            amp_client,
+        );
+
+        subgraph_instance_managers.add(
+            graph_core::subgraph_provider::SubgraphProcessingKind::Amp,
+            Arc::new(amp_instance_manager),
+        );
+    }
+
+    let subgraph_instance_manager = graph_core::subgraph::SubgraphInstanceManager::new(
+        logger_factory,
+        env_vars.cheap_clone(),
+        network_store.subgraph_store(),
+        blockchain_map.cheap_clone(),
+        sg_count.cheap_clone(),
+        metrics_registry.clone(),
+        link_resolver.clone(),
+        ipfs_service,
+        arweave_service,
+        amp_client.cheap_clone(),
+        static_filters,
+    );
+
+    subgraph_instance_managers.add(
+        graph_core::subgraph_provider::SubgraphProcessingKind::Trigger,
+        Arc::new(subgraph_instance_manager),
+    );
+
+    let subgraph_provider = graph_core::subgraph_provider::SubgraphProvider::new(
+        logger_factory,
+        sg_count.cheap_clone(),
+        network_store.subgraph_store(),
+        link_resolver.cheap_clone(),
+        tokio_util::sync::CancellationToken::new(),
+        subgraph_instance_managers,
+    );
+
+    // Check version switching mode environment variable
+    let version_switching_mode = ENV_VARS.subgraph_version_switching_mode;
+
+    // Create named subgraph provider for resolving subgraph name->ID mappings
+
+    Arc::new(graph_core::subgraph::SubgraphRegistrar::new(
+        logger_factory,
+        link_resolver,
+        Arc::new(subgraph_provider),
+        network_store.subgraph_store(),
+        subscription_manager,
+        amp_client,
+        blockchain_map,
+        node_id.clone(),
+        version_switching_mode,
+        Arc::new(subgraph_settings),
+        amp_chain_names,
+    ))
+}
+
+fn build_graphql_server(
+    config: &Config,
+    logger: &Logger,
+    expensive_queries: Vec<Arc<q::Document>>,
+    metrics_registry: Arc<MetricsRegistry>,
+    network_store: &Arc<Store>,
+    logger_factory: &LoggerFactory,
+    log_store: Arc<dyn graph::components::log_store::LogStore>,
+) -> GraphQLQueryServer<GraphQlRunner<Store>> {
+    let shards: Vec<_> = config.stores.keys().cloned().collect();
+    let load_manager = Arc::new(LoadManager::new(
+        logger,
+        shards,
+        expensive_queries,
+        metrics_registry.clone(),
+    ));
+    let graphql_runner = Arc::new(GraphQlRunner::new(
+        logger,
+        network_store.clone(),
+        load_manager,
+        metrics_registry,
+        log_store,
+    ));
+
+    GraphQLQueryServer::new(logger_factory, graphql_runner.clone())
+}
+
+/// Runs the Graph Node by initializing all components and starting all required services
+/// This function is the main entry point for running a Graph Node instance
+///
+/// # Arguments
+///
+/// * `opt` - Command line options controlling node behavior and configuration
+/// * `env_vars` - Environment variables for configuring the node
+/// * `ipfs_service` - Service for interacting with IPFS for subgraph deployments
+/// * `link_resolver` - Resolver for IPFS links in subgraph manifests and files
+/// * `dev_updates` - Optional channel for receiving subgraph update notifications in development mode
+pub async fn run(
+    logger: Logger,
+    opt: Opt,
+    env_vars: Arc<EnvVars>,
+    ipfs_service: IpfsService,
+    link_resolver: Arc<dyn LinkResolver>,
+    dev_updates: Option<mpsc::Receiver<(DeploymentHash, SubgraphName)>>,
+    prometheus_registry: Arc<Registry>,
+    metrics_registry: Arc<MetricsRegistry>,
+    cancel_token: CancellationToken,
+) {
+    // Log version information
+    info!(
+        logger,
+        "Graph Node version: {}",
+        render_testament!(TESTAMENT)
+    );
+
+    #[cfg(debug_assertions)]
+    warn!(
+        logger,
+        "This is a DEBUG build — performance is severely degraded. \
+        Use `cargo build --release` for production deployments."
+    );
+
+    if !graph_server_index_node::PoiProtection::from_env(&ENV_VARS).is_active() {
+        warn!(
+            logger,
+            "GRAPH_POI_ACCESS_TOKEN not set; might leak POIs to the public via GraphQL"
+        );
+    }
+
+    // Get configuration
+    let (config, subgraph_settings, fork_base) = setup_configuration(&opt, &logger, &env_vars);
+
+    let node_id = NodeId::new(opt.node_id.clone())
+        .expect("Node ID must be between 1 and 63 characters in length");
+
+    // Obtain subgraph related command-line arguments
+    let subgraph = opt.subgraph.clone();
+
+    // Obtain ports to use for the GraphQL server(s)
+    let http_port = opt.http_port;
+
+    // Obtain JSON-RPC server port
+    let json_rpc_port = opt.admin_port;
+
+    // Obtain index node server port
+    let index_node_port = opt.index_node_port;
+
+    // Obtain metrics server port
+    let metrics_port = opt.metrics_port;
+
+    info!(logger, "Starting up"; "node_id" => &node_id);
+
+    // Resolve log store configuration from [log_store] TOML section
+    let (log_store, log_store_config) = match &config.log_store {
+        Some(section) => match section.to_log_store_config() {
+            Ok(store_config) => {
+                let store = graph::components::log_store::LogStoreFactory::from_config(
+                    store_config.clone(),
+                )
+                .unwrap_or_else(|e| {
+                    warn!(logger, "Failed to initialize log store: {}", e);
+                    Arc::new(graph::components::log_store::NoOpLogStore)
+                });
+                info!(logger, "Log store initialized"; "backend" => format!("{:?}", store_config));
+                (store, Some(store_config))
+            }
+            Err(e) => {
+                warn!(logger, "Invalid [log_store] configuration: {}", e);
+                (
+                    Arc::new(graph::components::log_store::NoOpLogStore)
+                        as Arc<dyn graph::components::log_store::LogStore>,
+                    None,
+                )
+            }
+        },
+        None => {
+            info!(
+                logger,
+                "No [log_store] section in config, log queries will return empty results"
+            );
+            (
+                Arc::new(graph::components::log_store::NoOpLogStore)
+                    as Arc<dyn graph::components::log_store::LogStore>,
+                None,
+            )
+        }
+    };
+
+    // Create a component and subgraph logger factory
+    let logger_factory =
+        LoggerFactory::new(logger.clone(), log_store_config, metrics_registry.clone());
+
+    let arweave_resolver = Arc::new(ArweaveClient::new(
+        logger.cheap_clone(),
+        opt.arweave
+            .parse()
+            .expect("unable to parse arweave gateway address"),
+    ));
+
+    let arweave_service = arweave_service(
+        arweave_resolver.cheap_clone(),
+        env_vars.mappings.ipfs_request_limit,
+        match env_vars.mappings.max_ipfs_file_bytes {
+            0 => FileSizeLimit::Unlimited,
+            n => FileSizeLimit::MaxBytes(n as u64),
+        },
+    );
+
+    let metrics_server = PrometheusMetricsServer::new(&logger_factory, prometheus_registry.clone());
+
+    let endpoint_metrics = Arc::new(EndpointMetrics::new(
+        logger.clone(),
+        &config.chains.providers(),
+        metrics_registry.cheap_clone(),
+    ));
+
+    // TODO: make option loadable from configuration TOML and environment:
+    let expensive_queries =
+        read_expensive_queries(&logger, opt.expensive_queries_filename.clone()).unwrap();
+
+    let (primary_pool, subscription_manager, chain_head_update_listener, network_store) =
+        setup_store(
+            &logger,
+            &node_id,
+            &config,
+            fork_base,
+            metrics_registry.cheap_clone(),
+        )
+        .await;
+
+    let graphman_server_config = make_graphman_server_config(
+        primary_pool.clone(),
+        network_store.cheap_clone(),
+        metrics_registry.cheap_clone(),
+        &env_vars,
+        &logger,
+        &logger_factory,
+    );
+
+    let amp_client = match opt.amp_flight_service_address.as_deref() {
+        Some(amp_flight_service_address) => {
+            let addr: graph::http::Uri = amp_flight_service_address
+                .parse()
+                .expect("Invalid Amp Flight service address");
+
+            debug!(logger, "Connecting to Amp Flight service";
+                "host" => ?addr.host(),
+                "port" => ?addr.port()
+            );
+
+            let mut amp_client = amp::FlightClient::new(addr.clone())
+                .await
+                .expect("Failed to connect to Amp Flight service");
+
+            if let Some(auth_token) = &env_vars.amp.flight_service_token {
+                amp_client.set_auth_token(auth_token);
+            }
+
+            info!(logger, "Amp-powered subgraphs enabled";
+                "amp_flight_service_host" => ?addr.host()
+            );
+
+            Some(Arc::new(amp_client))
+        }
+        None => {
+            warn!(logger, "Amp-powered subgraphs disabled");
+            None
+        }
+    };
+
+    start_graphman_server(opt.graphman_port, graphman_server_config).await;
+
+    let launch_services = |logger: Logger, env_vars: Arc<EnvVars>| async move {
+        let blockchain_map = build_blockchain_map(
+            &logger,
+            &config,
+            &env_vars,
+            network_store.clone(),
+            metrics_registry.clone(),
+            endpoint_metrics,
+            chain_head_update_listener,
+            &logger_factory,
+        )
+        .await;
+
+        if config.is_block_ingestor() {
+            // see comment on cleanup_ethereum_shallow_blocks
+            cleanup_ethereum_shallow_blocks(&blockchain_map, &network_store).await;
+        } else if opt.disable_block_ingestor {
+            info!(
+                logger,
+                "Block ingestor disabled by --disable-block-ingestor"
+            );
+        } else {
+            info!(
+                logger,
+                "Not running block ingestion, ingestor is `{}`", config.chains.ingestor
+            );
+        }
+
+        let graphql_server = build_graphql_server(
+            &config,
+            &logger,
+            expensive_queries,
+            metrics_registry.clone(),
+            &network_store,
+            &logger_factory,
+            log_store.clone(),
+        );
+
+        let index_node_server = IndexNodeServer::new(
+            &logger_factory,
+            blockchain_map.clone(),
+            network_store.clone(),
+            link_resolver.clone(),
+            amp_client.cheap_clone(),
+        );
+
+        if config.is_block_ingestor() {
+            spawn_block_ingestor(
+                &logger,
+                &blockchain_map,
+                &network_store,
+                primary_pool,
+                &metrics_registry,
+            )
+            .await;
+        }
+
+        let amp_chain_names = Arc::new(config.amp_chain_names());
+        let subgraph_registrar = build_subgraph_registrar(
+            metrics_registry.clone(),
+            &network_store,
+            &logger_factory,
+            &env_vars,
+            blockchain_map.clone(),
+            node_id.clone(),
+            subgraph_settings,
+            link_resolver.clone(),
+            subscription_manager,
+            arweave_service,
+            ipfs_service,
+            amp_client,
+            cancel_token,
+            amp_chain_names,
+        );
+
+        graph::spawn(
+            subgraph_registrar
+                .cheap_clone()
+                .start()
+                .map_err(|e| panic!("failed to initialize subgraph provider {}", e)),
+        );
+
+        // Start admin JSON-RPC server.
+        let json_rpc_server = JsonRpcServer::serve(
+            json_rpc_port,
+            http_port,
+            subgraph_registrar.clone(),
+            node_id.clone(),
+            logger.clone(),
+        )
+        .await
+        .expect("failed to start JSON-RPC admin server");
+
+        // Let the server run forever.
+        std::mem::forget(json_rpc_server);
+
+        // Add the CLI subgraph with a REST request to the admin server.
+        if let Some(subgraph) = subgraph {
+            deploy_subgraph_from_flag(subgraph, &opt, subgraph_registrar.clone(), node_id.clone());
+        }
+
+        // Serve GraphQL queries over HTTP
+        graph::spawn(async move { graphql_server.start(http_port).await });
+
+        // Run the index node server
+        graph::spawn(async move { index_node_server.start(index_node_port).await });
+
+        graph::spawn(async move {
+            metrics_server
+                .start(metrics_port)
+                .await
+                .expect("Failed to start metrics server")
+        });
+
+        // If we are in dev mode, watch for subgraph updates
+        // And drop and recreate the subgraph when it changes
+        if let Some(dev_updates) = dev_updates {
+            graph::spawn(async move {
+                watch_subgraph_updates(
+                    &logger,
+                    network_store.subgraph_store(),
+                    subgraph_registrar.clone(),
+                    node_id.clone(),
+                    dev_updates,
+                )
+                .await;
+            });
+        }
+    };
+
+    graph::spawn(launch_services(logger.clone(), env_vars.cheap_clone()));
+
+    spawn_contention_checker(logger.clone());
+
+    graph::futures03::future::pending::<()>().await;
+}
+
+fn spawn_contention_checker(logger: Logger) {
+    // Periodically check for contention in the tokio threadpool. First spawn a
+    // task that simply responds to "ping" requests. Then spawn a separate
+    // thread to periodically ping it and check responsiveness.
+    let (ping_send, mut ping_receive) = mpsc::channel::<std::sync::mpsc::SyncSender<()>>(1);
+    graph::spawn(async move {
+        while let Some(pong_send) = ping_receive.recv().await {
+            let _ = pong_send.clone().send(());
+        }
+        panic!("ping sender dropped");
+    });
+    std::thread::spawn(move || {
+        loop {
+            std::thread::sleep(Duration::from_secs(1));
+            let (pong_send, pong_receive) = std::sync::mpsc::sync_channel(1);
+            if graph::futures03::executor::block_on(ping_send.clone().send(pong_send)).is_err() {
+                debug!(logger, "Shutting down contention checker thread");
+                break;
+            }
+            let mut timeout = Duration::from_millis(10);
+            while pong_receive.recv_timeout(timeout)
+                == Err(std::sync::mpsc::RecvTimeoutError::Timeout)
+            {
+                debug!(logger, "Possible contention in tokio threadpool";
+                                     "timeout_ms" => timeout.as_millis(),
+                                     "code" => LogCode::TokioContention);
+                if timeout < ENV_VARS.kill_if_unresponsive_timeout {
+                    timeout *= 10;
+                } else if ENV_VARS.kill_if_unresponsive {
+                    // The node is unresponsive, kill it in hopes it will be restarted.
+                    crit!(logger, "Node is unresponsive, killing process");
+                    std::process::abort()
+                }
+            }
+        }
+    });
+}
+
+/// Sets up and loads configuration based on command line options
+fn setup_configuration(
+    opt: &Opt,
+    logger: &Logger,
+    env_vars: &Arc<EnvVars>,
+) -> (Config, Settings, Option<Url>) {
+    let config = match Config::load(logger, &opt.clone().into()) {
+        Err(e) => {
+            eprintln!("configuration error: {}", e);
+            std::process::exit(1);
+        }
+        Ok(config) => config,
+    };
+
+    let subgraph_settings = match env_vars.subgraph_settings {
+        Some(ref path) => {
+            info!(logger, "Reading subgraph configuration file `{}`", path);
+            match Settings::from_file(path) {
+                Ok(rules) => rules,
+                Err(e) => {
+                    eprintln!("configuration error in subgraph settings {}: {}", path, e);
+                    std::process::exit(1);
+                }
+            }
+        }
+        None => Settings::default(),
+    };
+
+    if opt.check_config {
+        match config.to_json() {
+            Ok(txt) => println!("{}", txt),
+            Err(e) => eprintln!("error serializing config: {}", e),
+        }
+        eprintln!("Successfully validated configuration");
+        std::process::exit(0);
+    }
+
+    // Obtain the fork base URL
+    let fork_base = match &opt.fork_base {
+        Some(url) => {
+            // Make sure the endpoint ends with a terminating slash.
+            let url = if !url.ends_with('/') {
+                let mut url = url.clone();
+                url.push('/');
+                Url::parse(&url)
+            } else {
+                Url::parse(url)
+            };
+
+            Some(url.expect("Failed to parse the fork base URL"))
+        }
+        None => {
+            warn!(
+                logger,
+                "No fork base URL specified, subgraph forking is disabled"
+            );
+            None
+        }
+    };
+
+    (config, subgraph_settings, fork_base)
+}
+
+async fn start_graphman_server(port: u16, config: Option<GraphmanServerConfig<'_>>) {
+    let Some(config) = config else {
+        return;
+    };
+
+    let server = GraphmanServer::new(config)
+        .unwrap_or_else(|err| panic!("Invalid graphman server configuration: {err:#}"));
+
+    server
+        .start(port)
+        .await
+        .unwrap_or_else(|err| panic!("Failed to start graphman server: {err:#}"));
+}
+
+fn make_graphman_server_config<'a>(
+    pool: ConnectionPool,
+    store: Arc<Store>,
+    metrics_registry: Arc<MetricsRegistry>,
+    env_vars: &EnvVars,
+    logger: &Logger,
+    logger_factory: &'a LoggerFactory,
+) -> Option<GraphmanServerConfig<'a>> {
+    let Some(auth_token) = &env_vars.graphman_server_auth_token else {
+        warn!(
+            logger,
+            "Missing graphman server auth token; graphman server will not start",
+        );
+
+        return None;
+    };
+
+    let notification_sender = Arc::new(NotificationSender::new(metrics_registry.clone()));
+
+    Some(GraphmanServerConfig {
+        pool,
+        notification_sender,
+        store,
+        logger_factory,
+        auth_token: auth_token.to_owned(),
+    })
+}
+
+fn read_expensive_queries(
+    logger: &Logger,
+    expensive_queries_filename: String,
+) -> Result<Vec<Arc<q::Document>>, std::io::Error> {
+    // A file with a list of expensive queries, one query per line
+    // Attempts to run these queries will return a
+    // QueryExecutionError::TooExpensive to clients
+    let path = Path::new(&expensive_queries_filename);
+    let mut queries = Vec::new();
+    if path.exists() {
+        info!(
+            logger,
+            "Reading expensive queries file: {}", expensive_queries_filename
+        );
+        let file = std::fs::File::open(path)?;
+        let reader = BufReader::new(file);
+        for line in reader.lines() {
+            let line = line?;
+            let query = q::parse_query(&line)
+                .map_err(|e| {
+                    let msg = format!(
+                        "invalid GraphQL query in {}: {}\n{}",
+                        expensive_queries_filename, e, line
+                    );
+                    std::io::Error::new(std::io::ErrorKind::InvalidData, msg)
+                })?
+                .into_static();
+            queries.push(Arc::new(query));
+        }
+    } else {
+        warn!(
+            logger,
+            "Expensive queries file not set to a valid file: {}", expensive_queries_filename
+        );
+    }
+    Ok(queries)
+}
diff --git a/node/src/lib.rs b/node/src/lib.rs
index f26f14fef5b..a0fe189f1f7 100644
--- a/node/src/lib.rs
+++ b/node/src/lib.rs
@@ -7,11 +7,12 @@ extern crate diesel;
 
 pub mod chain;
 pub mod config;
+mod helpers;
+pub mod launcher;
+pub mod manager;
+pub mod network_setup;
 pub mod opt;
 pub mod store_builder;
-
-pub mod manager;
-
 pub struct MetricsContext {
     pub prometheus: Arc<Registry>,
     pub registry: Arc<MetricsRegistry>,
diff --git a/node/src/main.rs b/node/src/main.rs
index c6228bd92c5..652258c734d 100644
--- a/node/src/main.rs
+++ b/node/src/main.rs
@@ -1,923 +1,68 @@
 use clap::Parser as _;
-use ethereum::chain::{EthereumAdapterSelector, EthereumBlockRefetcher, EthereumStreamBuilder};
-use ethereum::{BlockIngestor, EthereumNetworks, RuntimeAdapter};
-use git_testament::{git_testament, render_testament};
-use graph::blockchain::client::ChainClient;
-use graph_chain_ethereum::codec::HeaderOnlyBlock;
-
-use graph::blockchain::{
-    BasicBlockchainBuilder, Blockchain, BlockchainBuilder, BlockchainKind, BlockchainMap,
-    ChainIdentifier,
-};
-use graph::components::link_resolver::{ArweaveClient, FileSizeLimit};
-use graph::components::store::BlockStore;
-use graph::components::subgraph::Settings;
-use graph::data::graphql::load_manager::LoadManager;
-use graph::endpoint::EndpointMetrics;
-use graph::env::EnvVars;
-use graph::firehose::{FirehoseEndpoints, FirehoseNetworks};
-use graph::log::logger;
-use graph::prelude::{IndexNodeServer as _, *};
-use graph::prometheus::Registry;
-use graph::url::Url;
-use graph_chain_arweave::{self as arweave, Block as ArweaveBlock};
-use graph_chain_cosmos::{self as cosmos, Block as CosmosFirehoseBlock};
-use graph_chain_ethereum as ethereum;
-use graph_chain_near::{self as near, HeaderOnlyBlock as NearFirehoseHeaderOnlyBlock};
-use graph_chain_starknet::{self as starknet, Block as StarknetBlock};
-use graph_chain_substreams as substreams;
-use graph_core::polling_monitor::{arweave_service, ipfs_service};
-use graph_core::{
-    LinkResolver, SubgraphAssignmentProvider as IpfsSubgraphAssignmentProvider,
-    SubgraphInstanceManager, SubgraphRegistrar as IpfsSubgraphRegistrar,
-};
-use graph_graphql::prelude::GraphQlRunner;
-use graph_node::chain::{
-    connect_ethereum_networks, connect_firehose_networks, create_all_ethereum_networks,
-    create_firehose_networks, create_ipfs_clients, create_substreams_networks,
-};
-use graph_node::config::Config;
-use graph_node::opt;
-use graph_node::store_builder::StoreBuilder;
-use graph_server_http::GraphQLServer as GraphQLQueryServer;
-use graph_server_index_node::IndexNodeServer;
-use graph_server_json_rpc::JsonRpcServer;
-use graph_server_metrics::PrometheusMetricsServer;
-use graph_server_websocket::SubscriptionServer as GraphQLSubscriptionServer;
-use graph_store_postgres::{register_jobs as register_store_jobs, ChainHeadUpdateListener, Store};
-use std::collections::BTreeMap;
-use std::collections::HashMap;
-use std::io::{BufRead, BufReader};
-use std::path::Path;
-use std::time::Duration;
-use tokio::sync::mpsc;
+use git_testament::git_testament;
+use graph::{env::EnvVars, log::logger, prelude::*};
+use graph_core::polling_monitor::ipfs_service;
+use graph_node::{launcher, opt};
+use tokio_util::sync::CancellationToken;
 
 git_testament!(TESTAMENT);
 
-fn read_expensive_queries(
-    logger: &Logger,
-    expensive_queries_filename: String,
-) -> Result<Vec<Arc<q::Document>>, std::io::Error> {
-    // A file with a list of expensive queries, one query per line
-    // Attempts to run these queries will return a
-    // QueryExecutionError::TooExpensive to clients
-    let path = Path::new(&expensive_queries_filename);
-    let mut queries = Vec::new();
-    if path.exists() {
-        info!(
-            logger,
-            "Reading expensive queries file: {}", expensive_queries_filename
-        );
-        let file = std::fs::File::open(path)?;
-        let reader = BufReader::new(file);
-        for line in reader.lines() {
-            let line = line?;
-            let query = graphql_parser::parse_query(&line)
-                .map_err(|e| {
-                    let msg = format!(
-                        "invalid GraphQL query in {}: {}\n{}",
-                        expensive_queries_filename, e, line
-                    );
-                    std::io::Error::new(std::io::ErrorKind::InvalidData, msg)
-                })?
-                .into_static();
-            queries.push(Arc::new(query));
-        }
-    } else {
-        warn!(
-            logger,
-            "Expensive queries file not set to a valid file: {}", expensive_queries_filename
-        );
-    }
-    Ok(queries)
+lazy_static! {
+    pub static ref MAX_BLOCKING_THREADS: usize = std::env::var("GRAPH_MAX_BLOCKING_THREADS")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(512);
 }
 
-macro_rules! collect_ingestors {
-    ($acc:ident, $logger:ident, $($chain:ident),+) => {
-        $(
-        $chain.iter().for_each(|(network_name, chain)| {
-            let logger = $logger.new(o!("network_name" => network_name.clone()));
-            match chain.block_ingestor() {
-                Ok(ingestor) =>{
-                    info!(logger, "Started block ingestor");
-                    $acc.push(ingestor);
-                }
-                Err(err) => error!(&logger,
-                    "Failed to create block ingestor {}",err),
-            }
-        });
-        )+
-    };
+fn main() {
+    graph::tls::install_default_crypto_provider();
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .max_blocking_threads(*MAX_BLOCKING_THREADS)
+        .build()
+        .unwrap()
+        .block_on(async { main_inner().await })
 }
 
-#[tokio::main]
-async fn main() {
+async fn main_inner() {
     env_logger::init();
 
+    let cancel_token = CancellationToken::new();
     let env_vars = Arc::new(EnvVars::from_env().unwrap());
     let opt = opt::Opt::parse();
 
     // Set up logger
     let logger = logger(opt.debug);
-
-    // Log version information
-    info!(
+    debug!(
         logger,
-        "Graph Node version: {}",
-        render_testament!(TESTAMENT)
+        "Runtime configured with {} max blocking threads", *MAX_BLOCKING_THREADS
     );
 
-    if !graph_server_index_node::PoiProtection::from_env(&ENV_VARS).is_active() {
-        warn!(
-            logger,
-            "GRAPH_POI_ACCESS_TOKEN not set; might leak POIs to the public via GraphQL"
-        );
-    }
-
-    let config = match Config::load(&logger, &opt.clone().into()) {
-        Err(e) => {
-            eprintln!("configuration error: {}", e);
-            std::process::exit(1);
-        }
-        Ok(config) => config,
-    };
-
-    let subgraph_settings = match env_vars.subgraph_settings {
-        Some(ref path) => {
-            info!(logger, "Reading subgraph configuration file `{}`", path);
-            match Settings::from_file(path) {
-                Ok(rules) => rules,
-                Err(e) => {
-                    eprintln!("configuration error in subgraph settings {}: {}", path, e);
-                    std::process::exit(1);
-                }
-            }
-        }
-        None => Settings::default(),
-    };
-
-    if opt.check_config {
-        match config.to_json() {
-            Ok(txt) => println!("{}", txt),
-            Err(e) => eprintln!("error serializing config: {}", e),
-        }
-        eprintln!("Successfully validated configuration");
-        std::process::exit(0);
-    }
-
-    let node_id = NodeId::new(opt.node_id.clone())
-        .expect("Node ID must be between 1 and 63 characters in length");
-    let query_only = config.query_only(&node_id);
-
-    // Obtain subgraph related command-line arguments
-    let subgraph = opt.subgraph.clone();
-
-    // Obtain ports to use for the GraphQL server(s)
-    let http_port = opt.http_port;
-    let ws_port = opt.ws_port;
-
-    // Obtain JSON-RPC server port
-    let json_rpc_port = opt.admin_port;
-
-    // Obtain index node server port
-    let index_node_port = opt.index_node_port;
-
-    // Obtain metrics server port
-    let metrics_port = opt.metrics_port;
-
-    // Obtain the fork base URL
-    let fork_base = match &opt.fork_base {
-        Some(url) => {
-            // Make sure the endpoint ends with a terminating slash.
-            let url = if !url.ends_with('/') {
-                let mut url = url.clone();
-                url.push('/');
-                Url::parse(&url)
-            } else {
-                Url::parse(url)
-            };
+    let (prometheus_registry, metrics_registry) = launcher::setup_metrics(&logger);
 
-            Some(url.expect("Failed to parse the fork base URL"))
-        }
-        None => {
-            warn!(
-                logger,
-                "No fork base URL specified, subgraph forking is disabled"
-            );
-            None
-        }
-    };
-
-    info!(logger, "Starting up");
-
-    // Optionally, identify the Elasticsearch logging configuration
-    let elastic_config = opt
-        .elasticsearch_url
-        .clone()
-        .map(|endpoint| ElasticLoggingConfig {
-            endpoint,
-            username: opt.elasticsearch_user.clone(),
-            password: opt.elasticsearch_password.clone(),
-            client: reqwest::Client::new(),
-        });
-
-    // Set up Prometheus registry
-    let prometheus_registry = Arc::new(Registry::new());
-    let metrics_registry = Arc::new(MetricsRegistry::new(
-        logger.clone(),
-        prometheus_registry.clone(),
-    ));
-
-    // Create a component and subgraph logger factory
-    let logger_factory =
-        LoggerFactory::new(logger.clone(), elastic_config, metrics_registry.clone());
+    let ipfs_client = graph::ipfs::new_ipfs_client(&opt.ipfs, &metrics_registry, &logger)
+        .await
+        .unwrap_or_else(|err| panic!("Failed to create IPFS client: {err:#}"));
 
-    // Try to create IPFS clients for each URL specified in `--ipfs`
-    let ipfs_clients: Vec<_> = create_ipfs_clients(&logger, &opt.ipfs);
-    let ipfs_client = ipfs_clients.first().cloned().expect("Missing IPFS client");
     let ipfs_service = ipfs_service(
-        ipfs_client,
-        ENV_VARS.mappings.max_ipfs_file_bytes as u64,
-        ENV_VARS.mappings.ipfs_timeout,
-        ENV_VARS.mappings.ipfs_request_limit,
-    );
-    let arweave_resolver = Arc::new(ArweaveClient::new(
-        logger.cheap_clone(),
-        opt.arweave
-            .parse()
-            .expect("unable to parse arweave gateway address"),
-    ));
-
-    let arweave_service = arweave_service(
-        arweave_resolver.cheap_clone(),
+        ipfs_client.cheap_clone(),
+        env_vars.mappings.max_ipfs_file_bytes,
         env_vars.mappings.ipfs_timeout,
         env_vars.mappings.ipfs_request_limit,
-        match env_vars.mappings.max_ipfs_file_bytes {
-            0 => FileSizeLimit::Unlimited,
-            n => FileSizeLimit::MaxBytes(n as u64),
-        },
     );
 
-    // Convert the clients into a link resolver. Since we want to get past
-    // possible temporary DNS failures, make the resolver retry
-    let link_resolver = Arc::new(LinkResolver::new(ipfs_clients, env_vars.cheap_clone()));
-    let mut metrics_server =
-        PrometheusMetricsServer::new(&logger_factory, prometheus_registry.clone());
-
-    let endpoint_metrics = Arc::new(EndpointMetrics::new(
-        logger.clone(),
-        &config.chains.providers(),
-        metrics_registry.cheap_clone(),
-    ));
-
-    // Ethereum clients; query nodes ignore all ethereum clients and never
-    // connect to them directly
-    let eth_networks = if query_only {
-        EthereumNetworks::new(endpoint_metrics.cheap_clone())
-    } else {
-        create_all_ethereum_networks(
-            logger.clone(),
-            metrics_registry.clone(),
-            &config,
-            endpoint_metrics.cheap_clone(),
-        )
-        .await
-        .expect("Failed to parse Ethereum networks")
-    };
-
-    let mut firehose_networks_by_kind = if query_only {
-        BTreeMap::new()
-    } else {
-        create_firehose_networks(logger.clone(), &config, endpoint_metrics.cheap_clone())
-    };
+    let link_resolver = Arc::new(IpfsResolver::new(ipfs_client, env_vars.cheap_clone()));
 
-    let mut substreams_networks_by_kind = if query_only {
-        BTreeMap::new()
-    } else {
-        create_substreams_networks(logger.clone(), &config, endpoint_metrics.clone())
-    };
-
-    let graphql_metrics_registry = metrics_registry.clone();
-
-    let contention_logger = logger.clone();
-
-    // TODO: make option loadable from configuration TOML and environment:
-    let expensive_queries =
-        read_expensive_queries(&logger, opt.expensive_queries_filename).unwrap();
-
-    let store_builder = StoreBuilder::new(
-        &logger,
-        &node_id,
-        &config,
-        fork_base,
-        metrics_registry.cheap_clone(),
+    launcher::run(
+        logger,
+        opt,
+        env_vars,
+        ipfs_service,
+        link_resolver,
+        None,
+        prometheus_registry,
+        metrics_registry,
+        cancel_token,
     )
     .await;
-
-    let launch_services = |logger: Logger, env_vars: Arc<EnvVars>| async move {
-        let subscription_manager = store_builder.subscription_manager();
-        let chain_head_update_listener = store_builder.chain_head_update_listener();
-        let primary_pool = store_builder.primary_pool();
-
-        // To support the ethereum block ingestor, ethereum networks are referenced both by the
-        // `blockchain_map` and `ethereum_chains`. Future chains should be referred to only in
-        // `blockchain_map`.
-        let mut blockchain_map = BlockchainMap::new();
-
-        // Unwraps: `connect_ethereum_networks` and `connect_firehose_networks` only fail if
-        // mismatching chain identifiers are returned for a same network, which indicates a serious
-        // inconsistency between providers.
-        let (arweave_networks, arweave_idents) = connect_firehose_networks::<ArweaveBlock>(
-            &logger,
-            firehose_networks_by_kind
-                .remove(&BlockchainKind::Arweave)
-                .unwrap_or_else(FirehoseNetworks::new),
-        )
-        .await
-        .unwrap();
-
-        // This only has idents for chains with rpc adapters.
-        let (eth_networks, ethereum_idents) = connect_ethereum_networks(&logger, eth_networks)
-            .await
-            .unwrap();
-
-        let (eth_firehose_only_networks, eth_firehose_only_idents) =
-            connect_firehose_networks::<HeaderOnlyBlock>(
-                &logger,
-                firehose_networks_by_kind
-                    .remove(&BlockchainKind::Ethereum)
-                    .unwrap_or_else(FirehoseNetworks::new),
-            )
-            .await
-            .unwrap();
-
-        let (near_networks, near_idents) =
-            connect_firehose_networks::<NearFirehoseHeaderOnlyBlock>(
-                &logger,
-                firehose_networks_by_kind
-                    .remove(&BlockchainKind::Near)
-                    .unwrap_or_else(FirehoseNetworks::new),
-            )
-            .await
-            .unwrap();
-
-        let (cosmos_networks, cosmos_idents) = connect_firehose_networks::<CosmosFirehoseBlock>(
-            &logger,
-            firehose_networks_by_kind
-                .remove(&BlockchainKind::Cosmos)
-                .unwrap_or_else(FirehoseNetworks::new),
-        )
-        .await
-        .unwrap();
-
-        let substreams_networks = substreams_networks_by_kind
-            .remove(&BlockchainKind::Substreams)
-            .unwrap_or_else(FirehoseNetworks::new);
-
-        let (starknet_networks, starknet_idents) = connect_firehose_networks::<StarknetBlock>(
-            &logger,
-            firehose_networks_by_kind
-                .remove(&BlockchainKind::Starknet)
-                .unwrap_or_else(FirehoseNetworks::new),
-        )
-        .await
-        .unwrap();
-
-        let substream_idents = substreams_networks
-            .networks
-            .keys()
-            .map(|name| {
-                (
-                    name.clone(),
-                    ChainIdentifier {
-                        net_version: name.to_string(),
-                        genesis_block_hash: BlockHash::default(),
-                    },
-                )
-            })
-            .collect::<BTreeMap<String, ChainIdentifier>>();
-
-        // Note that both `eth_firehose_only_idents` and `ethereum_idents` contain Ethereum
-        // networks. If the same network is configured in both RPC and Firehose, the RPC ident takes
-        // precedence. This is necessary because Firehose endpoints currently have no `net_version`.
-        // See also: firehose-no-net-version.
-        let mut network_identifiers = eth_firehose_only_idents;
-        network_identifiers.extend(ethereum_idents);
-        network_identifiers.extend(arweave_idents);
-        network_identifiers.extend(near_idents);
-        network_identifiers.extend(cosmos_idents);
-        network_identifiers.extend(substream_idents);
-        network_identifiers.extend(starknet_idents);
-
-        let network_store = store_builder.network_store(network_identifiers);
-
-        let arweave_chains = networks_as_chains::<arweave::Chain>(
-            &env_vars,
-            &mut blockchain_map,
-            &logger,
-            &arweave_networks,
-            substreams_networks_by_kind.get(&BlockchainKind::Arweave),
-            network_store.as_ref(),
-            &logger_factory,
-            metrics_registry.clone(),
-        );
-
-        let eth_firehose_only_networks = if eth_firehose_only_networks.networks.len() == 0 {
-            None
-        } else {
-            Some(&eth_firehose_only_networks)
-        };
-
-        if !opt.disable_block_ingestor && eth_networks.networks.len() != 0 {
-            let eth_network_names = Vec::from_iter(eth_networks.networks.keys());
-            let fh_only = match eth_firehose_only_networks {
-                Some(firehose_only) => Some(Vec::from_iter(firehose_only.networks.keys())),
-                None => None,
-            };
-            network_store
-                .block_store()
-                .cleanup_ethereum_shallow_blocks(eth_network_names, fh_only)
-                .unwrap();
-        }
-
-        let ethereum_chains = ethereum_networks_as_chains(
-            &mut blockchain_map,
-            &logger,
-            &config,
-            node_id.clone(),
-            metrics_registry.clone(),
-            eth_firehose_only_networks,
-            substreams_networks_by_kind.get(&BlockchainKind::Ethereum),
-            &eth_networks,
-            network_store.as_ref(),
-            chain_head_update_listener,
-            &logger_factory,
-            metrics_registry.clone(),
-        );
-
-        let near_chains = networks_as_chains::<near::Chain>(
-            &env_vars,
-            &mut blockchain_map,
-            &logger,
-            &near_networks,
-            substreams_networks_by_kind.get(&BlockchainKind::Near),
-            network_store.as_ref(),
-            &logger_factory,
-            metrics_registry.clone(),
-        );
-
-        let cosmos_chains = networks_as_chains::<cosmos::Chain>(
-            &env_vars,
-            &mut blockchain_map,
-            &logger,
-            &cosmos_networks,
-            substreams_networks_by_kind.get(&BlockchainKind::Cosmos),
-            network_store.as_ref(),
-            &logger_factory,
-            metrics_registry.clone(),
-        );
-
-        let substreams_chains = networks_as_chains::<substreams::Chain>(
-            &env_vars,
-            &mut blockchain_map,
-            &logger,
-            &substreams_networks,
-            None,
-            network_store.as_ref(),
-            &logger_factory,
-            metrics_registry.clone(),
-        );
-
-        let starknet_chains = networks_as_chains::<starknet::Chain>(
-            &env_vars,
-            &mut blockchain_map,
-            &logger,
-            &starknet_networks,
-            substreams_networks_by_kind.get(&BlockchainKind::Starknet),
-            network_store.as_ref(),
-            &logger_factory,
-            metrics_registry.clone(),
-        );
-
-        let blockchain_map = Arc::new(blockchain_map);
-
-        let shards: Vec<_> = config.stores.keys().cloned().collect();
-        let load_manager = Arc::new(LoadManager::new(
-            &logger,
-            shards,
-            expensive_queries,
-            metrics_registry.clone(),
-        ));
-        let graphql_runner = Arc::new(GraphQlRunner::new(
-            &logger,
-            network_store.clone(),
-            subscription_manager.clone(),
-            load_manager,
-            graphql_metrics_registry,
-        ));
-        let mut graphql_server =
-            GraphQLQueryServer::new(&logger_factory, graphql_runner.clone(), node_id.clone());
-        let subscription_server =
-            GraphQLSubscriptionServer::new(&logger, graphql_runner.clone(), network_store.clone());
-
-        let mut index_node_server = IndexNodeServer::new(
-            &logger_factory,
-            blockchain_map.clone(),
-            graphql_runner.clone(),
-            network_store.clone(),
-            link_resolver.clone(),
-        );
-
-        if !opt.disable_block_ingestor {
-            let logger = logger.clone();
-            let mut ingestors: Vec<Box<dyn BlockIngestor>> = vec![];
-            collect_ingestors!(
-                ingestors,
-                logger,
-                ethereum_chains,
-                arweave_chains,
-                near_chains,
-                cosmos_chains,
-                substreams_chains,
-                starknet_chains
-            );
-
-            ingestors.into_iter().for_each(|ingestor| {
-                let logger = logger.clone();
-                info!(logger,"Starting block ingestor for network";"network_name" => &ingestor.network_name());
-
-                graph::spawn(ingestor.run());
-            });
-
-            // Start a task runner
-            let mut job_runner = graph::util::jobs::Runner::new(&logger);
-            register_store_jobs(
-                &mut job_runner,
-                network_store.clone(),
-                primary_pool,
-                metrics_registry.clone(),
-            );
-            graph::spawn_blocking(job_runner.start());
-        }
-        let static_filters = ENV_VARS.experimental_static_filters;
-
-        let sg_count = Arc::new(SubgraphCountMetric::new(metrics_registry.cheap_clone()));
-
-        let subgraph_instance_manager = SubgraphInstanceManager::new(
-            &logger_factory,
-            env_vars.cheap_clone(),
-            network_store.subgraph_store(),
-            blockchain_map.cheap_clone(),
-            sg_count.cheap_clone(),
-            metrics_registry.clone(),
-            link_resolver.clone(),
-            ipfs_service,
-            arweave_service,
-            static_filters,
-        );
-
-        // Create IPFS-based subgraph provider
-        let subgraph_provider = IpfsSubgraphAssignmentProvider::new(
-            &logger_factory,
-            link_resolver.clone(),
-            subgraph_instance_manager,
-            sg_count,
-        );
-
-        // Check version switching mode environment variable
-        let version_switching_mode = ENV_VARS.subgraph_version_switching_mode;
-
-        // Create named subgraph provider for resolving subgraph name->ID mappings
-        let subgraph_registrar = Arc::new(IpfsSubgraphRegistrar::new(
-            &logger_factory,
-            link_resolver,
-            Arc::new(subgraph_provider),
-            network_store.subgraph_store(),
-            subscription_manager,
-            blockchain_map,
-            node_id.clone(),
-            version_switching_mode,
-            Arc::new(subgraph_settings),
-        ));
-        graph::spawn(
-            subgraph_registrar
-                .start()
-                .map_err(|e| panic!("failed to initialize subgraph provider {}", e))
-                .compat(),
-        );
-
-        // Start admin JSON-RPC server.
-        let json_rpc_server = JsonRpcServer::serve(
-            json_rpc_port,
-            http_port,
-            ws_port,
-            subgraph_registrar.clone(),
-            node_id.clone(),
-            logger.clone(),
-        )
-        .await
-        .expect("failed to start JSON-RPC admin server");
-
-        // Let the server run forever.
-        std::mem::forget(json_rpc_server);
-
-        // Add the CLI subgraph with a REST request to the admin server.
-        if let Some(subgraph) = subgraph {
-            let (name, hash) = if subgraph.contains(':') {
-                let mut split = subgraph.split(':');
-                (split.next().unwrap(), split.next().unwrap().to_owned())
-            } else {
-                ("cli", subgraph)
-            };
-
-            let name = SubgraphName::new(name)
-                .expect("Subgraph name must contain only a-z, A-Z, 0-9, '-' and '_'");
-            let subgraph_id =
-                DeploymentHash::new(hash).expect("Subgraph hash must be a valid IPFS hash");
-            let debug_fork = opt
-                .debug_fork
-                .map(DeploymentHash::new)
-                .map(|h| h.expect("Debug fork hash must be a valid IPFS hash"));
-            let start_block = opt
-                .start_block
-                .map(|block| {
-                    let mut split = block.split(':');
-                    (
-                        // BlockHash
-                        split.next().unwrap().to_owned(),
-                        // BlockNumber
-                        split.next().unwrap().parse::<i64>().unwrap(),
-                    )
-                })
-                .map(|(hash, number)| BlockPtr::try_from((hash.as_str(), number)))
-                .map(Result::unwrap);
-
-            graph::spawn(
-                async move {
-                    subgraph_registrar.create_subgraph(name.clone()).await?;
-                    subgraph_registrar
-                        .create_subgraph_version(
-                            name,
-                            subgraph_id,
-                            node_id,
-                            debug_fork,
-                            start_block,
-                            None,
-                            None,
-                        )
-                        .await
-                }
-                .map_err(|e| panic!("Failed to deploy subgraph from `--subgraph` flag: {}", e)),
-            );
-        }
-
-        // Serve GraphQL queries over HTTP
-        graph::spawn(
-            graphql_server
-                .serve(http_port, ws_port)
-                .expect("Failed to start GraphQL query server")
-                .compat(),
-        );
-
-        // Serve GraphQL subscriptions over WebSockets
-        graph::spawn(subscription_server.serve(ws_port));
-
-        // Run the index node server
-        graph::spawn(
-            index_node_server
-                .serve(index_node_port)
-                .expect("Failed to start index node server")
-                .compat(),
-        );
-
-        graph::spawn(async move {
-            metrics_server
-                .serve(metrics_port)
-                .await
-                .expect("Failed to start metrics server")
-        });
-    };
-
-    graph::spawn(launch_services(logger.clone(), env_vars.cheap_clone()));
-
-    // Periodically check for contention in the tokio threadpool. First spawn a
-    // task that simply responds to "ping" requests. Then spawn a separate
-    // thread to periodically ping it and check responsiveness.
-    let (ping_send, mut ping_receive) = mpsc::channel::<std::sync::mpsc::SyncSender<()>>(1);
-    graph::spawn(async move {
-        while let Some(pong_send) = ping_receive.recv().await {
-            let _ = pong_send.clone().send(());
-        }
-        panic!("ping sender dropped");
-    });
-    std::thread::spawn(move || loop {
-        std::thread::sleep(Duration::from_secs(1));
-        let (pong_send, pong_receive) = std::sync::mpsc::sync_channel(1);
-        if futures::executor::block_on(ping_send.clone().send(pong_send)).is_err() {
-            debug!(contention_logger, "Shutting down contention checker thread");
-            break;
-        }
-        let mut timeout = Duration::from_millis(10);
-        while pong_receive.recv_timeout(timeout) == Err(std::sync::mpsc::RecvTimeoutError::Timeout)
-        {
-            debug!(contention_logger, "Possible contention in tokio threadpool";
-                                     "timeout_ms" => timeout.as_millis(),
-                                     "code" => LogCode::TokioContention);
-            if timeout < ENV_VARS.kill_if_unresponsive_timeout {
-                timeout *= 10;
-            } else if ENV_VARS.kill_if_unresponsive {
-                // The node is unresponsive, kill it in hopes it will be restarted.
-                crit!(contention_logger, "Node is unresponsive, killing process");
-                std::process::abort()
-            }
-        }
-    });
-
-    futures::future::pending::<()>().await;
-}
-
-/// Return the hashmap of chains and also add them to `blockchain_map`.
-fn networks_as_chains<C>(
-    config: &Arc<EnvVars>,
-    blockchain_map: &mut BlockchainMap,
-    logger: &Logger,
-    firehose_networks: &FirehoseNetworks,
-    substreams_networks: Option<&FirehoseNetworks>,
-    store: &Store,
-    logger_factory: &LoggerFactory,
-    metrics_registry: Arc<MetricsRegistry>,
-) -> HashMap<String, Arc<C>>
-where
-    C: Blockchain,
-    BasicBlockchainBuilder: BlockchainBuilder<C>,
-{
-    let chains: Vec<_> = firehose_networks
-        .networks
-        .iter()
-        .filter_map(|(chain_id, endpoints)| {
-            store
-                .block_store()
-                .chain_store(chain_id)
-                .map(|chain_store| (chain_id, chain_store, endpoints))
-                .or_else(|| {
-                    error!(
-                        logger,
-                        "No store configured for {} chain {}; ignoring this chain",
-                        C::KIND,
-                        chain_id
-                    );
-                    None
-                })
-        })
-        .map(|(chain_id, chain_store, endpoints)| {
-            (
-                chain_id.clone(),
-                Arc::new(
-                    BasicBlockchainBuilder {
-                        logger_factory: logger_factory.clone(),
-                        name: chain_id.clone(),
-                        chain_store,
-                        firehose_endpoints: endpoints.clone(),
-                        metrics_registry: metrics_registry.clone(),
-                    }
-                    .build(config),
-                ),
-            )
-        })
-        .collect();
-
-    for (chain_id, chain) in chains.iter() {
-        blockchain_map.insert::<C>(chain_id.clone(), chain.clone())
-    }
-
-    if let Some(substreams_networks) = substreams_networks {
-        for (network_name, firehose_endpoints) in substreams_networks.networks.iter() {
-            let chain_store = blockchain_map
-                .get::<C>(network_name.clone())
-                .expect(&format!(
-                    "{} requires an rpc or firehose endpoint defined",
-                    network_name
-                ))
-                .chain_store();
-
-            blockchain_map.insert::<substreams::Chain>(
-                network_name.clone(),
-                Arc::new(substreams::Chain::new(
-                    logger_factory.clone(),
-                    firehose_endpoints.clone(),
-                    metrics_registry.clone(),
-                    chain_store,
-                    Arc::new(substreams::BlockStreamBuilder::new()),
-                )),
-            );
-        }
-    }
-
-    HashMap::from_iter(chains)
-}
-
-/// Return the hashmap of ethereum chains and also add them to `blockchain_map`.
-fn ethereum_networks_as_chains(
-    blockchain_map: &mut BlockchainMap,
-    logger: &Logger,
-    config: &Config,
-    node_id: NodeId,
-    registry: Arc<MetricsRegistry>,
-    firehose_networks: Option<&FirehoseNetworks>,
-    substreams_networks: Option<&FirehoseNetworks>,
-    eth_networks: &EthereumNetworks,
-    store: &Store,
-    chain_head_update_listener: Arc<ChainHeadUpdateListener>,
-    logger_factory: &LoggerFactory,
-    metrics_registry: Arc<MetricsRegistry>,
-) -> HashMap<String, Arc<ethereum::Chain>> {
-    let chains: Vec<_> = eth_networks
-        .networks
-        .iter()
-        .filter_map(|(network_name, eth_adapters)| {
-            store
-                .block_store()
-                .chain_store(network_name)
-                .map(|chain_store| {
-                    let is_ingestible = chain_store.is_ingestible();
-                    (network_name, eth_adapters, chain_store, is_ingestible)
-                })
-                .or_else(|| {
-                    error!(
-                        logger,
-                        "No store configured for Ethereum chain {}; ignoring this chain",
-                        network_name
-                    );
-                    None
-                })
-        })
-        .map(|(network_name, eth_adapters, chain_store, is_ingestible)| {
-            let firehose_endpoints = firehose_networks
-                .and_then(|v| v.networks.get(network_name))
-                .map_or_else(FirehoseEndpoints::new, |v| v.clone());
-
-            let client = Arc::new(ChainClient::<graph_chain_ethereum::Chain>::new(
-                firehose_endpoints,
-                eth_adapters.clone(),
-            ));
-            let adapter_selector = EthereumAdapterSelector::new(
-                logger_factory.clone(),
-                client.clone(),
-                registry.clone(),
-                chain_store.clone(),
-            );
-
-            let runtime_adapter = Arc::new(RuntimeAdapter {
-                eth_adapters: Arc::new(eth_adapters.clone()),
-                call_cache: chain_store.cheap_clone(),
-                chain_identifier: Arc::new(chain_store.chain_identifier.clone()),
-            });
-
-            let chain_config = config.chains.chains.get(network_name).unwrap();
-            let chain = ethereum::Chain::new(
-                logger_factory.clone(),
-                network_name.clone(),
-                node_id.clone(),
-                registry.clone(),
-                chain_store.cheap_clone(),
-                chain_store,
-                client,
-                chain_head_update_listener.clone(),
-                Arc::new(EthereumStreamBuilder {}),
-                Arc::new(EthereumBlockRefetcher {}),
-                Arc::new(adapter_selector),
-                runtime_adapter,
-                ENV_VARS.reorg_threshold,
-                chain_config.polling_interval,
-                is_ingestible,
-            );
-            (network_name.clone(), Arc::new(chain))
-        })
-        .collect();
-
-    for (network_name, chain) in chains.iter().cloned() {
-        blockchain_map.insert::<graph_chain_ethereum::Chain>(network_name, chain)
-    }
-
-    if let Some(substreams_networks) = substreams_networks {
-        for (network_name, firehose_endpoints) in substreams_networks.networks.iter() {
-            let chain_store = blockchain_map
-                .get::<graph_chain_ethereum::Chain>(network_name.clone())
-                .expect("any substreams endpoint needs an rpc or firehose chain defined")
-                .chain_store();
-
-            blockchain_map.insert::<substreams::Chain>(
-                network_name.clone(),
-                Arc::new(substreams::Chain::new(
-                    logger_factory.clone(),
-                    firehose_endpoints.clone(),
-                    metrics_registry.clone(),
-                    chain_store,
-                    Arc::new(substreams::BlockStreamBuilder::new()),
-                )),
-            );
-        }
-    }
-
-    HashMap::from_iter(chains)
 }
diff --git a/node/src/manager/color.rs b/node/src/manager/color.rs
index 3b1f4dfe4fa..9e4541c55ca 100644
--- a/node/src/manager/color.rs
+++ b/node/src/manager/color.rs
@@ -1,7 +1,10 @@
-use std::sync::Mutex;
+use std::{
+    io::{self, IsTerminal as _},
+    sync::Mutex,
+};
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
-use graph::prelude::{isatty, lazy_static};
+use graph::prelude::lazy_static;
 
 use super::CmdResult;
 
@@ -15,13 +18,19 @@ pub struct Terminal {
     spec: ColorSpec,
 }
 
+impl Default for Terminal {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Terminal {
     pub fn set_color_preference(pref: &str) {
         let choice = match pref {
             "always" => ColorChoice::Always,
             "ansi" => ColorChoice::AlwaysAnsi,
             "auto" => {
-                if isatty::stdout_isatty() {
+                if io::stdout().is_terminal() {
                     ColorChoice::Auto
                 } else {
                     ColorChoice::Never
@@ -53,6 +62,11 @@ impl Terminal {
         self.out.set_color(&self.spec).map_err(Into::into)
     }
 
+    pub fn red(&mut self) -> CmdResult {
+        self.spec.set_fg(Some(Color::Red));
+        self.out.set_color(&self.spec).map_err(Into::into)
+    }
+
     pub fn dim(&mut self) -> CmdResult {
         self.spec.set_dimmed(true);
         self.out.set_color(&self.spec).map_err(Into::into)
@@ -67,6 +81,18 @@ impl Terminal {
         self.spec = ColorSpec::new();
         self.out.reset().map_err(Into::into)
     }
+
+    pub fn with_color<F, R>(&mut self, color: Color, f: F) -> io::Result<R>
+    where
+        F: FnOnce(&mut Self) -> io::Result<R>,
+    {
+        self.spec.set_fg(Some(color));
+        self.out.set_color(&self.spec)?;
+        let res = f(self);
+        self.spec = ColorSpec::new();
+        self.out.set_color(&self.spec)?;
+        res
+    }
 }
 
 impl std::io::Write for Terminal {
diff --git a/node/src/manager/commands/assign.rs b/node/src/manager/commands/assign.rs
index 23864d544b4..3787145fb29 100644
--- a/node/src/manager/commands/assign.rs
+++ b/node/src/manager/commands/assign.rs
@@ -1,9 +1,8 @@
-use graph::prelude::{anyhow::anyhow, Error, NodeId, StoreEvent};
-use graph_store_postgres::{
-    command_support::catalog, connection_pool::ConnectionPool, NotificationSender,
-};
-use std::thread;
+use graph::components::store::DeploymentLocator;
+use graph::prelude::{Error, NodeId, StoreEvent, anyhow::anyhow};
+use graph_store_postgres::{ConnectionPool, NotificationSender, command_support::catalog};
 use std::time::Duration;
+use tokio;
 
 use crate::manager::deployment::DeploymentSearch;
 
@@ -12,59 +11,63 @@ pub async fn unassign(
     sender: &NotificationSender,
     search: &DeploymentSearch,
 ) -> Result<(), Error> {
-    let locator = search.locate_unique(&primary)?;
+    let locator = search.locate_unique(&primary).await?;
 
-    let conn = primary.get()?;
-    let conn = catalog::Connection::new(conn);
+    let pconn = primary.get_permitted().await?;
+    let mut conn = catalog::Connection::new(pconn);
 
     let site = conn
-        .locate_site(locator.clone())?
+        .locate_site(locator.clone())
+        .await?
         .ok_or_else(|| anyhow!("failed to locate site for {locator}"))?;
 
     println!("unassigning {locator}");
-    let changes = conn.unassign_subgraph(&site)?;
-    conn.send_store_event(sender, &StoreEvent::new(changes))?;
+    let changes = conn.unassign_subgraph(&site).await?;
+    conn.send_store_event(sender, &StoreEvent::new(changes))
+        .await?;
 
     Ok(())
 }
 
-pub fn reassign(
+pub async fn reassign(
     primary: ConnectionPool,
     sender: &NotificationSender,
     search: &DeploymentSearch,
     node: String,
 ) -> Result<(), Error> {
-    let node = NodeId::new(node.clone()).map_err(|()| anyhow!("illegal node id `{}`", node))?;
-    let locator = search.locate_unique(&primary)?;
+    let node = NodeId::new(node).map_err(|node| anyhow!("illegal node id `{}`", node))?;
+    let locator = search.locate_unique(&primary).await?;
 
-    let conn = primary.get()?;
-    let conn = catalog::Connection::new(conn);
+    let pconn = primary.get_permitted().await?;
+    let mut conn = catalog::Connection::new(pconn);
 
     let site = conn
-        .locate_site(locator.clone())?
+        .locate_site(locator.clone())
+        .await?
         .ok_or_else(|| anyhow!("failed to locate site for {locator}"))?;
-    let changes = match conn.assigned_node(&site)? {
+    let changes = match conn.assigned_node(&site).await? {
         Some(cur) => {
             if cur == node {
                 println!("deployment {locator} is already assigned to {cur}");
                 vec![]
             } else {
                 println!("reassigning {locator} to {node} (was {cur})");
-                conn.reassign_subgraph(&site, &node)?
+                conn.reassign_subgraph(&site, &node).await?
             }
         }
         None => {
             println!("assigning {locator} to {node}");
-            conn.assign_subgraph(&site, &node)?
+            conn.assign_subgraph(&site, &node).await?
         }
     };
-    conn.send_store_event(sender, &StoreEvent::new(changes))?;
+    conn.send_store_event(sender, &StoreEvent::new(changes))
+        .await?;
 
     // It's easy to make a typo in the name of the node; if this operation
     // assigns to a node that wasn't used before, warn the user that they
     // might have mistyped the node name
     let mirror = catalog::Mirror::primary_only(primary);
-    let count = mirror.assignments(&node)?.len();
+    let count = mirror.assignments(&node).await?.len();
     if count == 1 {
         println!("warning: this is the only deployment assigned to {node}");
         println!("         are you sure it is spelled correctly?");
@@ -72,22 +75,21 @@ pub fn reassign(
     Ok(())
 }
 
-pub fn pause_or_resume(
+pub async fn pause_or_resume(
     primary: ConnectionPool,
     sender: &NotificationSender,
-    search: &DeploymentSearch,
+    locator: &DeploymentLocator,
     should_pause: bool,
 ) -> Result<(), Error> {
-    let locator = search.locate_unique(&primary)?;
-
-    let conn = primary.get()?;
-    let conn = catalog::Connection::new(conn);
+    let pconn = primary.get_permitted().await?;
+    let mut conn = catalog::Connection::new(pconn);
 
     let site = conn
-        .locate_site(locator.clone())?
+        .locate_site(locator.clone())
+        .await?
         .ok_or_else(|| anyhow!("failed to locate site for {locator}"))?;
 
-    let change = match conn.assignment_status(&site)? {
+    let change = match conn.assignment_status(&site).await? {
         Some((_, is_paused)) => {
             if should_pause {
                 if is_paused {
@@ -95,10 +97,10 @@ pub fn pause_or_resume(
                     return Ok(());
                 }
                 println!("pausing {locator}");
-                conn.pause_subgraph(&site)?
+                conn.pause_subgraph(&site).await?
             } else {
                 println!("resuming {locator}");
-                conn.resume_subgraph(&site)?
+                conn.resume_subgraph(&site).await?
             }
         }
         None => {
@@ -107,23 +109,24 @@ pub fn pause_or_resume(
         }
     };
     println!("Operation completed");
-    conn.send_store_event(sender, &StoreEvent::new(change))?;
+    conn.send_store_event(sender, &StoreEvent::new(change))
+        .await?;
 
     Ok(())
 }
 
-pub fn restart(
+pub async fn restart(
     primary: ConnectionPool,
     sender: &NotificationSender,
-    search: &DeploymentSearch,
+    locator: &DeploymentLocator,
     sleep: Duration,
 ) -> Result<(), Error> {
-    pause_or_resume(primary.clone(), sender, search, true)?;
+    pause_or_resume(primary.clone(), sender, locator, true).await?;
     println!(
         "Waiting {}s to make sure pausing was processed",
         sleep.as_secs()
     );
-    thread::sleep(sleep);
-    pause_or_resume(primary, sender, search, false)?;
+    tokio::time::sleep(sleep).await;
+    pause_or_resume(primary, sender, locator, false).await?;
     Ok(())
 }
diff --git a/node/src/manager/commands/chain.rs b/node/src/manager/commands/chain.rs
index 31978ebb7d5..ffce3c738a6 100644
--- a/node/src/manager/commands/chain.rs
+++ b/node/src/manager/commands/chain.rs
@@ -1,25 +1,43 @@
 use std::sync::Arc;
 
+use diesel::sql_query;
+use diesel_async::AsyncConnection;
+use diesel_async::RunQueryDsl;
+use graph::blockchain::BlockHash;
 use graph::blockchain::BlockPtr;
+use graph::blockchain::ChainIdentifier;
 use graph::cheap_clone::CheapClone;
+use graph::components::network_provider::ChainName;
+use graph::components::store::ChainIdStore;
+use graph::components::store::StoreError;
 use graph::prelude::BlockNumber;
 use graph::prelude::ChainStore as _;
-use graph::prelude::EthereumBlock;
-use graph::prelude::LightEthereumBlockExt as _;
+use graph::prelude::LightEthereumBlock;
 use graph::prelude::{anyhow, anyhow::bail};
+use graph::slog::Logger;
 use graph::{
-    components::store::BlockStore as _, prelude::anyhow::Error, prelude::serde_json as json,
+    components::store::BlockStore as _, components::store::ChainHeadStore as _,
+    prelude::anyhow::Error,
 };
+use graph_chain_ethereum::EthereumAdapter;
+use graph_chain_ethereum::EthereumAdapterTrait as _;
+use graph_chain_ethereum::chain::BlockFinality;
 use graph_store_postgres::BlockStore;
 use graph_store_postgres::ChainStore;
-use graph_store_postgres::{
-    command_support::catalog::block_store, connection_pool::ConnectionPool,
-};
+use graph_store_postgres::PoolCoordinator;
+use graph_store_postgres::Shard;
+use graph_store_postgres::add_chain;
+use graph_store_postgres::find_chain;
+use graph_store_postgres::update_chain_name;
+use graph_store_postgres::{ConnectionPool, command_support::catalog::block_store};
+
+use crate::manager::prompt::prompt_for_confirmation;
+use crate::network_setup::Networks;
 
-pub async fn list(primary: ConnectionPool, store: Arc<BlockStore>) -> Result<(), Error> {
+pub async fn list(primary: ConnectionPool, store: BlockStore) -> Result<(), Error> {
     let mut chains = {
-        let conn = primary.get()?;
-        block_store::load_chains(&conn)?
+        let mut conn = primary.get().await?;
+        block_store::load_chains(&mut conn).await?
     };
     chains.sort_by_key(|chain| chain.name.clone());
 
@@ -34,7 +52,7 @@ pub async fn list(primary: ConnectionPool, store: Arc<BlockStore>) -> Result<(),
         );
     }
     for chain in chains {
-        let head_block = match store.chain_store(&chain.name) {
+        let head_block = match store.chain_store(&chain.name).await {
             None => "no chain".to_string(),
             Some(chain_store) => chain_store
                 .chain_head_ptr()
@@ -63,9 +81,36 @@ pub async fn clear_call_cache(
     Ok(())
 }
 
+pub async fn clear_stale_call_cache(
+    chain_store: Arc<ChainStore>,
+    ttl_days: usize,
+    max_contracts: Option<usize>,
+) -> Result<(), Error> {
+    println!(
+        "Removing stale entries from the call cache for `{}`",
+        chain_store.chain
+    );
+    let result = chain_store
+        .clear_stale_call_cache(ttl_days, max_contracts)
+        .await?;
+    if result.effective_ttl_days != ttl_days {
+        println!(
+            "Effective TTL: {} days (adjusted from {} to stay within {} contracts)",
+            result.effective_ttl_days,
+            ttl_days,
+            max_contracts.unwrap()
+        );
+    }
+    println!(
+        "Deleted {} cache entries for {} contracts",
+        result.cache_entries_deleted, result.contracts_deleted
+    );
+    Ok(())
+}
+
 pub async fn info(
     primary: ConnectionPool,
-    store: Arc<BlockStore>,
+    store: BlockStore,
     name: String,
     offset: BlockNumber,
     hashes: bool,
@@ -88,23 +133,24 @@ pub async fn info(
         }
     }
 
-    let conn = primary.get()?;
+    let mut conn = primary.get().await?;
 
-    let chain =
-        block_store::find_chain(&conn, &name)?.ok_or_else(|| anyhow!("unknown chain: {}", name))?;
+    let chain = block_store::find_chain(&mut conn, &name)
+        .await?
+        .ok_or_else(|| anyhow!("unknown chain: {}", name))?;
 
     let chain_store = store
         .chain_store(&chain.name)
+        .await
         .ok_or_else(|| anyhow!("unknown chain: {}", name))?;
     let head_block = chain_store.cheap_clone().chain_head_ptr().await?;
     let ancestor = match &head_block {
         None => None,
-        Some(head_block) => chain_store
-            .ancestor_block(head_block.clone(), offset)
-            .await?
-            .map(json::from_value::<EthereumBlock>)
-            .transpose()?
-            .map(|b| b.block.block_ptr()),
+        Some(head_block) => {
+            chain_store
+                .ancestor_block_ptr(head_block.clone(), offset, None)
+                .await?
+        }
     };
 
     row("name", chain.name);
@@ -121,10 +167,12 @@ pub async fn info(
     Ok(())
 }
 
-pub fn remove(primary: ConnectionPool, store: Arc<BlockStore>, name: String) -> Result<(), Error> {
+pub async fn remove(primary: ConnectionPool, store: BlockStore, name: String) -> Result<(), Error> {
     let sites = {
-        let conn = graph_store_postgres::command_support::catalog::Connection::new(primary.get()?);
-        conn.find_sites_for_network(&name)?
+        let mut conn = graph_store_postgres::command_support::catalog::Connection::new(
+            primary.get_permitted().await?,
+        );
+        conn.find_sites_for_network(&name).await?
     };
 
     if !sites.is_empty() {
@@ -139,7 +187,215 @@ pub fn remove(primary: ConnectionPool, store: Arc<BlockStore>, name: String) ->
         bail!("remove all deployments using chain {} first", name);
     }
 
-    store.drop_chain(&name)?;
+    store.drop_chain(&name).await?;
+
+    Ok(())
+}
+
+pub async fn update_chain_genesis(
+    networks: &Networks,
+    coord: Arc<PoolCoordinator>,
+    store: Box<dyn ChainIdStore>,
+    logger: &Logger,
+    chain_id: ChainName,
+    genesis_hash: BlockHash,
+    force: bool,
+) -> Result<(), Error> {
+    let ident = networks.chain_identifier(logger, &chain_id).await?;
+    if !genesis_hash.eq(&ident.genesis_block_hash) {
+        println!(
+            "Expected adapter for chain {} to return genesis hash {} but got {}",
+            chain_id, genesis_hash, ident.genesis_block_hash
+        );
+        if !force {
+            println!("Not performing update");
+            return Ok(());
+        } else {
+            println!("--force used, updating anyway");
+        }
+    }
+
+    println!("Updating shard...");
+    // Update the local shard's genesis, whether or not it is the primary.
+    // The chains table is replicated from the primary and keeps another genesis hash.
+    // To keep those in sync we need to update the primary and then refresh the shard tables.
+    store
+        .set_chain_identifier(
+            &chain_id,
+            &ChainIdentifier {
+                net_version: ident.net_version.clone(),
+                genesis_block_hash: genesis_hash,
+            },
+        )
+        .await?;
+
+    // Refresh the new values
+    println!("Refresh mappings");
+    crate::manager::commands::database::remap(&coord, None, None, false).await?;
+
+    Ok(())
+}
+
+pub async fn change_block_cache_shard(
+    primary_store: ConnectionPool,
+    store: BlockStore,
+    chain_name: String,
+    shard: String,
+) -> Result<(), Error> {
+    println!("Changing block cache shard for {} to {}", chain_name, shard);
+
+    let mut conn = primary_store.get().await?;
+
+    let chain = find_chain(&mut conn, &chain_name)
+        .await?
+        .ok_or_else(|| anyhow!("unknown chain: {}", chain_name))?;
+    let old_shard = chain.shard;
+    let canonical_backup_name = format!("{chain_name}-old");
+
+    let existing_backup = find_chain(&mut conn, &canonical_backup_name).await?;
+
+    println!("Current shard: {}", old_shard);
+
+    let chain_store = store
+        .chain_store(&chain_name)
+        .await
+        .ok_or_else(|| anyhow!("unknown chain: {}", &chain_name))?;
+    let ident = chain_store.chain_identifier().await?;
+    let target_shard = Shard::new(shard)?;
+
+    let reuse_existing_backup = match existing_backup.as_ref() {
+        None => false,
+        Some(backup) if backup.shard != target_shard => {
+            bail!(
+                "`{}` already exists on shard `{}`. Remove it with `graphman chain remove {}` before changing `{}` to shard `{}`",
+                canonical_backup_name,
+                backup.shard,
+                canonical_backup_name,
+                chain_name,
+                target_shard,
+            );
+        }
+        Some(backup) => {
+            let backup_ident = backup.network_identifier()?;
+            if backup_ident != ident {
+                bail!(
+                    "`{}` has a different chain identifier ({}) than `{}` ({}). Remove it with `graphman chain remove {}` before changing `{}` to shard `{}`",
+                    canonical_backup_name,
+                    backup_ident,
+                    chain_name,
+                    ident,
+                    canonical_backup_name,
+                    chain_name,
+                    target_shard,
+                );
+            }
+            let prompt = format!(
+                "`{}` already exists on shard `{}` and will be reused as the active `{}` chain.\nProceed?",
+                canonical_backup_name, target_shard, chain_name
+            );
+            if !prompt_for_confirmation(&prompt)? {
+                println!(
+                    "Aborting. Remove `{}` with `graphman chain remove {}` if you want to create a fresh cache on shard `{}`.",
+                    canonical_backup_name, canonical_backup_name, target_shard
+                );
+                return Ok(());
+            }
+            true
+        }
+    };
+
+    let existing_backup_store = if reuse_existing_backup {
+        store.chain_store(&canonical_backup_name).await
+    } else {
+        None
+    };
+
+    if !reuse_existing_backup {
+        let chain =
+            BlockStore::allocate_chain(&mut conn, &chain_name, &target_shard, &ident).await?;
+        store.add_chain_store(&chain, true).await?;
+    }
+
+    let temp_backup_name = format!("{chain_name}-old-temp");
+    if reuse_existing_backup && find_chain(&mut conn, &temp_backup_name).await?.is_some() {
+        bail!(
+            "`{}` already exists. Remove it with `graphman chain remove {}` before changing `{}` to shard `{}`",
+            temp_backup_name,
+            temp_backup_name,
+            chain_name,
+            target_shard,
+        );
+    }
+
+    conn.transaction::<(), StoreError, _>(async |conn| {
+        sql_query(
+            "alter table deployment_schemas drop constraint deployment_schemas_network_fkey;",
+        )
+        .execute(conn)
+        .await?;
+
+        if let Some(backup) = existing_backup.as_ref() {
+            update_chain_name(conn, &backup.name, &temp_backup_name).await?;
+        }
+
+        update_chain_name(conn, &chain_name, &canonical_backup_name).await?;
+
+        if reuse_existing_backup {
+            update_chain_name(conn, &temp_backup_name, &chain_name).await?;
+        } else {
+            add_chain(conn, &chain_name, &target_shard, ident.clone()).await?;
+        }
+
+        sql_query(
+            "alter table deployment_schemas add constraint deployment_schemas_network_fkey foreign key (network) references chains(name);",
+        )
+        .execute(conn)
+        .await?;
+        Ok(())
+    })
+    .await?;
+
+    chain_store.update_name(&canonical_backup_name).await?;
+
+    if reuse_existing_backup && let Some(backup_store) = existing_backup_store.as_ref() {
+        backup_store.update_name(&chain_name).await?;
+    }
+
+    println!(
+        "Changed block cache shard for {} from {} to {}",
+        chain_name, old_shard, target_shard
+    );
 
     Ok(())
 }
+
+pub async fn ingest(
+    logger: &Logger,
+    chain_store: Arc<ChainStore>,
+    ethereum_adapter: Arc<EthereumAdapter>,
+    number: BlockNumber,
+) -> Result<(), Error> {
+    let Some(block) = ethereum_adapter
+        .block_by_number(logger, number)
+        .await
+        .map_err(|e| anyhow!("error getting block number {number}: {}", e))?
+    else {
+        bail!("block number {number} not found");
+    };
+    let hash = block.header.hash;
+    let number = block.header.number;
+    // For inserting the block, it doesn't matter whether the block is final or not.
+    let block = Arc::new(BlockFinality::Final(Arc::new(LightEthereumBlock::new(
+        block,
+    ))));
+    chain_store.upsert_block(block).await?;
+
+    let hash = hash.into();
+    let rows = chain_store.confirm_block_hash(number as i32, &hash).await?;
+
+    println!("Inserted block {}", hash);
+    if rows > 0 {
+        println!("    (also deleted {rows} duplicate row(s) with that number)");
+    }
+    Ok(())
+}
diff --git a/node/src/manager/commands/check_blocks.rs b/node/src/manager/commands/check_blocks.rs
index 6502b2d1963..d7014bd4b1c 100644
--- a/node/src/manager/commands/check_blocks.rs
+++ b/node/src/manager/commands/check_blocks.rs
@@ -2,10 +2,13 @@ use crate::manager::prompt::prompt_for_confirmation;
 use graph::{
     anyhow::{bail, ensure},
     cheap_clone::CheapClone,
-    components::store::ChainStore as ChainStoreTrait,
+    components::{
+        ethereum::{CachedBlock, LightEthereumBlock},
+        store::ChainStore as ChainStoreTrait,
+    },
     prelude::{
-        anyhow::{self, anyhow, Context},
-        web3::types::H256,
+        alloy::primitives::B256,
+        anyhow::{self, Context, anyhow},
     },
     slog::Logger,
 };
@@ -30,7 +33,7 @@ pub async fn by_number(
     logger: &Logger,
     delete_duplicates: bool,
 ) -> anyhow::Result<()> {
-    let block_hashes = steps::resolve_block_hash_from_block_number(number, &chain_store)?;
+    let block_hashes = steps::resolve_block_hash_from_block_number(number, &chain_store).await?;
 
     match &block_hashes.as_slice() {
         [] => bail!("Could not find a block with number {} in store", number),
@@ -54,14 +57,15 @@ pub async fn by_range(
     let range = ranges::Range::new(range_from, range_to)?;
     let max = match range.upper_bound {
         // When we have an open upper bound, we use the chain head's block number
-        None => steps::find_chain_head(&chain_store)?,
+        None => steps::find_chain_head(&chain_store).await?,
         Some(x) => x,
     };
     // FIXME: This performs poorly.
     // TODO: This could be turned into async code
     for block_number in range.lower_bound..=max {
         println!("Checking block [{block_number}/{max}]");
-        let block_hashes = steps::resolve_block_hash_from_block_number(block_number, &chain_store)?;
+        let block_hashes =
+            steps::resolve_block_hash_from_block_number(block_number, &chain_store).await?;
         match &block_hashes.as_slice() {
             [] => eprintln!("Found no block hash with number {block_number}"),
             [block_hash] => {
@@ -87,7 +91,7 @@ pub async fn by_range(
     Ok(())
 }
 
-pub fn truncate(chain_store: Arc<ChainStore>, skip_confirmation: bool) -> anyhow::Result<()> {
+pub async fn truncate(chain_store: Arc<ChainStore>, skip_confirmation: bool) -> anyhow::Result<()> {
     let prompt = format!(
         "This will delete all cached blocks for {}.\nProceed?",
         chain_store.chain
@@ -99,11 +103,12 @@ pub fn truncate(chain_store: Arc<ChainStore>, skip_confirmation: bool) -> anyhow
 
     chain_store
         .truncate_block_cache()
+        .await
         .with_context(|| format!("Failed to truncate block cache for {}", chain_store.chain))
 }
 
 async fn run(
-    block_hash: &H256,
+    block_hash: &B256,
     chain_store: Arc<ChainStore>,
     ethereum_adapter: &EthereumAdapter,
     logger: &Logger,
@@ -112,17 +117,17 @@ async fn run(
         steps::fetch_single_cached_block(*block_hash, chain_store.cheap_clone()).await?;
     let provider_block =
         steps::fetch_single_provider_block(block_hash, ethereum_adapter, logger).await?;
-    let diff = steps::diff_block_pair(&cached_block, &provider_block);
+    let diff = steps::diff_block_pair(&cached_block, &provider_block)?;
     steps::report_difference(diff.as_deref(), block_hash);
     if diff.is_some() {
-        steps::delete_block(block_hash, &chain_store)?;
+        steps::delete_block(block_hash, &chain_store).await?;
     }
     Ok(())
 }
 
 async fn handle_multiple_block_hashes(
     block_number: i32,
-    block_hashes: &[H256],
+    block_hashes: &[B256],
     chain_store: &ChainStore,
     delete_duplicates: bool,
 ) -> anyhow::Result<()> {
@@ -138,7 +143,7 @@ async fn handle_multiple_block_hashes(
     if delete_duplicates {
         println!("Deleting duplicated blocks...");
         for hash in block_hashes {
-            steps::delete_block(hash, chain_store)?;
+            steps::delete_block(hash, chain_store).await?;
         }
     } else {
         eprintln!(
@@ -153,26 +158,28 @@ async fn handle_multiple_block_hashes(
 mod steps {
     use super::*;
 
-    use futures::compat::Future01CompatExt;
     use graph::{
         anyhow::bail,
-        prelude::serde_json::{self, Value},
+        prelude::{
+            alloy::primitives::B256,
+            serde_json::{self, Value},
+        },
     };
-    use json_structural_diff::{colorize as diff_to_string, JsonDiff};
+    use json_structural_diff::{JsonDiff, colorize as diff_to_string};
 
     /// Queries the [`ChainStore`] about the block hash for the given block number.
     ///
     /// Multiple block hashes can be returned as the store does not enforce uniqueness based on
     /// block numbers.
     /// Returns an empty vector if no block hash is found.
-    pub(super) fn resolve_block_hash_from_block_number(
+    pub(super) async fn resolve_block_hash_from_block_number(
         number: i32,
         chain_store: &ChainStore,
-    ) -> anyhow::Result<Vec<H256>> {
-        let block_hashes = chain_store.block_hashes_by_block_number(number)?;
+    ) -> anyhow::Result<Vec<B256>> {
+        let block_hashes = chain_store.block_hashes_by_block_number(number).await?;
         Ok(block_hashes
             .into_iter()
-            .map(|x| H256::from_slice(&x.as_slice()[..32]))
+            .map(|x| B256::from_slice(&x.as_slice()[..32]))
             .collect())
     }
 
@@ -180,46 +187,57 @@ mod steps {
     ///
     /// Errors on a non-unary result.
     pub(super) async fn fetch_single_cached_block(
-        block_hash: H256,
+        block_hash: B256,
         chain_store: Arc<ChainStore>,
-    ) -> anyhow::Result<Value> {
-        let blocks = chain_store.blocks(vec![block_hash.into()]).await?;
+    ) -> anyhow::Result<CachedBlock> {
+        let mut blocks = chain_store.blocks(vec![block_hash.into()]).await?;
         match blocks.len() {
             0 => bail!("Failed to locate block with hash {} in store", block_hash),
-            1 => {}
+            1 => Ok(blocks.pop().unwrap()),
             _ => bail!("Found multiple blocks with hash {} in store", block_hash),
-        };
-        // Unwrap: We just checked that the vector has a single element
-        Ok(blocks.into_iter().next().unwrap())
+        }
     }
 
-    /// Fetches a block from a JRPC endpoint.
+    /// Fetches a block from an RPC endpoint.
     ///
     /// Errors on provider failure or if the returned block has a different hash than the one
     /// requested.
     pub(super) async fn fetch_single_provider_block(
-        block_hash: &H256,
+        block_hash: &B256,
         ethereum_adapter: &EthereumAdapter,
         logger: &Logger,
-    ) -> anyhow::Result<Value> {
+    ) -> anyhow::Result<LightEthereumBlock> {
         let provider_block = ethereum_adapter
             .block_by_hash(logger, *block_hash)
-            .compat()
             .await
             .with_context(|| format!("failed to fetch block {block_hash}"))?
-            .ok_or_else(|| anyhow!("JRPC provider found no block with hash {block_hash:?}"))?;
+            .ok_or_else(|| anyhow!("RPC provider found no block with hash {block_hash:?}"))?;
         ensure!(
-            provider_block.hash == Some(*block_hash),
+            provider_block.header.hash == *block_hash,
             "Provider responded with a different block hash"
         );
-        serde_json::to_value(provider_block)
-            .context("failed to parse provider block as a JSON value")
+        Ok(LightEthereumBlock::new(provider_block))
     }
 
-    /// Compares two [`serde_json::Value`] values.
+    /// Compares a cached block against a provider block.
     ///
+    /// Only compares the block data (without receipts) since the provider's
+    /// `eth_getBlockByHash` does not return receipts. Both sides are serialized
+    /// through the same alloy types for a fair comparison.
     /// If they are different, returns a user-friendly string ready to be displayed.
-    pub(super) fn diff_block_pair(a: &Value, b: &Value) -> Option<String> {
+    pub(super) fn diff_block_pair(
+        cached: &CachedBlock,
+        provider: &LightEthereumBlock,
+    ) -> anyhow::Result<Option<String>> {
+        let cached_json = serde_json::to_value(cached.light_block())
+            .context("failed to serialize cached block")?;
+        let provider_json =
+            serde_json::to_value(provider).context("failed to serialize provider block")?;
+
+        Ok(diff_json(&cached_json, &provider_json))
+    }
+
+    fn diff_json(a: &Value, b: &Value) -> Option<String> {
         if a == b {
             None
         } else {
@@ -237,7 +255,7 @@ mod steps {
     }
 
     /// Prints the difference between two [`serde_json::Value`] values to the user.
-    pub(super) fn report_difference(difference: Option<&str>, hash: &H256) {
+    pub(super) fn report_difference(difference: Option<&str>, hash: &B256) {
         if let Some(diff) = difference {
             eprintln!("block {hash} diverges from cache:");
             eprintln!("{diff}");
@@ -247,29 +265,29 @@ mod steps {
     }
 
     /// Attempts to delete a block from the block cache.
-    pub(super) fn delete_block(hash: &H256, chain_store: &ChainStore) -> anyhow::Result<()> {
+    pub(super) async fn delete_block(hash: &B256, chain_store: &ChainStore) -> anyhow::Result<()> {
         println!("Deleting block {hash} from cache.");
-        chain_store.delete_blocks(&[hash])?;
+        chain_store.delete_blocks(&[hash]).await?;
         println!("Done.");
         Ok(())
     }
 
     /// Queries the [`ChainStore`] about the chain head.
-    pub(super) fn find_chain_head(chain_store: &ChainStore) -> anyhow::Result<i32> {
-        let chain_head: Option<i32> = chain_store.chain_head_block(&chain_store.chain)?;
+    pub(super) async fn find_chain_head(chain_store: &ChainStore) -> anyhow::Result<i32> {
+        let chain_head: Option<i32> = chain_store.chain_head_block(&chain_store.chain).await?;
         chain_head.ok_or_else(|| anyhow!("Could not find the chain head for {}", chain_store.chain))
     }
 }
 
 mod helpers {
     use super::*;
-    use graph::prelude::hex;
+    use graph::prelude::{alloy::primitives::B256, hex};
 
-    /// Tries to parse a [`H256`] from a hex string.
-    pub(super) fn parse_block_hash(hash: &str) -> anyhow::Result<H256> {
+    /// Tries to parse a [`B256`] from a hex string.
+    pub(super) fn parse_block_hash(hash: &str) -> anyhow::Result<B256> {
         let hash = hash.trim_start_matches("0x");
         let hash = hex::decode(hash)?;
-        Ok(H256::from_slice(&hash))
+        Ok(B256::from_slice(&hash))
     }
 }
 
diff --git a/node/src/manager/commands/config.rs b/node/src/manager/commands/config.rs
index 7f595e97e5d..35ee9ed573a 100644
--- a/node/src/manager/commands/config.rs
+++ b/node/src/manager/commands/config.rs
@@ -1,21 +1,22 @@
 use std::{collections::BTreeMap, sync::Arc};
 
+use graph::components::network_provider::ChainName;
 use graph::{
-    anyhow::{bail, Context},
+    anyhow::{Context, bail},
     components::subgraph::{Setting, Settings},
     endpoint::EndpointMetrics,
     env::EnvVars,
     itertools::Itertools,
     prelude::{
-        anyhow::{anyhow, Error},
         MetricsRegistry, NodeId, SubgraphName,
+        anyhow::{Error, anyhow},
     },
     slog::Logger,
 };
-use graph_chain_ethereum::{NodeCapabilities, ProviderEthRpcMetrics};
+use graph_chain_ethereum::NodeCapabilities;
 use graph_store_postgres::DeploymentPlacer;
 
-use crate::{chain::create_ethereum_networks_for_chain, config::Config};
+use crate::{config::Config, network_setup::Networks};
 
 pub fn place(placer: &dyn DeploymentPlacer, name: &str, network: &str) -> Result<(), Error> {
     match placer.place(name, network).map_err(|s| anyhow!(s))? {
@@ -71,7 +72,7 @@ pub fn pools(config: &Config, nodes: Vec<String>, shard: bool) -> Result<(), Err
         .into_iter()
         .map(|name| {
             NodeId::new(name.replace('-', "_"))
-                .map_err(|()| anyhow!("illegal node name `{}`", name))
+                .map_err(|name| anyhow!("illegal node name `{}`", name))
         })
         .collect::<Result<_, _>>()?;
     // node -> shard_name -> size
@@ -138,15 +139,11 @@ pub async fn provider(
 
     let metrics = Arc::new(EndpointMetrics::mock());
     let caps = caps_from_features(features)?;
-    let eth_rpc_metrics = Arc::new(ProviderEthRpcMetrics::new(registry));
-    let networks =
-        create_ethereum_networks_for_chain(&logger, eth_rpc_metrics, config, &network, metrics)
-            .await?;
-    let adapters = networks
-        .networks
-        .get(&network)
-        .ok_or_else(|| anyhow!("unknown network {}", network))?;
-    let adapters = adapters.all_cheapest_with(&caps);
+    let networks = Networks::from_config(logger, config, registry, metrics, &[]).await?;
+    let network: ChainName = network.into();
+    let adapters = networks.ethereum_rpcs(network.clone());
+
+    let adapters = adapters.all_cheapest_with(&caps).await;
     println!(
         "deploy on network {} with features [{}] on node {}\neligible providers: {}",
         network,
@@ -160,7 +157,7 @@ pub async fn provider(
 }
 
 pub fn setting(name: &str) -> Result<(), Error> {
-    let name = SubgraphName::new(name).map_err(|()| anyhow!("illegal subgraph name `{}`", name))?;
+    let name = SubgraphName::new(name).map_err(|name| anyhow!("illegal subgraph name `{name}`"))?;
     let env_vars = EnvVars::from_env().unwrap();
     if let Some(path) = &env_vars.subgraph_settings {
         let settings = Settings::from_file(path)
diff --git a/node/src/manager/commands/copy.rs b/node/src/manager/commands/copy.rs
index 91921fad0fa..9d158dcd231 100644
--- a/node/src/manager/commands/copy.rs
+++ b/node/src/manager/commands/copy.rs
@@ -1,31 +1,33 @@
-use diesel::{ExpressionMethods, JoinOnDsl, OptionalExtension, QueryDsl, RunQueryDsl};
-use std::{collections::HashMap, sync::Arc, time::SystemTime};
+use diesel::{ExpressionMethods, JoinOnDsl, OptionalExtension, QueryDsl};
+use diesel_async::RunQueryDsl;
+use std::{collections::HashMap, sync::Arc};
 
 use graph::{
-    components::store::{BlockStore as _, DeploymentId},
+    components::store::{BlockStore as _, DeploymentId, DeploymentLocator},
     data::query::QueryTarget,
     prelude::{
-        anyhow::{anyhow, bail, Error},
-        chrono::{DateTime, Duration, SecondsFormat, Utc},
         BlockPtr, ChainStore, DeploymentHash, NodeId, QueryStoreManager,
+        anyhow::{Error, anyhow, bail},
+        chrono::{DateTime, Duration, SecondsFormat, Utc},
     },
 };
+use graph_store_postgres::{ConnectionPool, Shard, Store, SubgraphStore};
 use graph_store_postgres::{
+    PRIMARY_SHARD,
     command_support::{
+        OnSync,
         catalog::{self, copy_state, copy_table_state},
-        on_sync, OnSync,
+        on_sync,
     },
-    PRIMARY_SHARD,
 };
-use graph_store_postgres::{connection_pool::ConnectionPool, Shard, Store, SubgraphStore};
 
-use crate::manager::deployment::DeploymentSearch;
 use crate::manager::display::List;
+use crate::manager::{deployment::DeploymentSearch, fmt};
 
 type UtcDateTime = DateTime<Utc>;
 
 #[derive(Queryable, QueryableByName, Debug)]
-#[table_name = "copy_state"]
+#[diesel(table_name = copy_state)]
 struct CopyState {
     src: i32,
     dst: i32,
@@ -38,7 +40,7 @@ struct CopyState {
 }
 
 #[derive(Queryable, QueryableByName, Debug)]
-#[table_name = "copy_table_state"]
+#[diesel(table_name = copy_table_state)]
 struct CopyTableState {
     #[allow(dead_code)]
     id: i32,
@@ -55,7 +57,7 @@ struct CopyTableState {
 }
 
 impl CopyState {
-    fn find(
+    async fn find(
         pools: &HashMap<Shard, ConnectionPool>,
         shard: &Shard,
         dst: i32,
@@ -67,27 +69,28 @@ impl CopyState {
             .get(shard)
             .ok_or_else(|| anyhow!("can not find pool for shard {}", shard))?;
 
-        let dconn = dpool.get()?;
+        let mut dconn = dpool.get().await?;
 
         let tables = cts::table
             .filter(cts::dst.eq(dst))
             .order_by(cts::entity_type)
-            .load::<CopyTableState>(&dconn)?;
+            .load::<CopyTableState>(&mut dconn)
+            .await?;
 
-        let on_sync = on_sync(&dconn, DeploymentId(dst))?;
+        let on_sync = on_sync(&mut dconn, DeploymentId(dst)).await?;
 
         Ok(cs::table
             .filter(cs::dst.eq(dst))
-            .get_result::<CopyState>(&dconn)
+            .get_result::<CopyState>(&mut dconn)
+            .await
             .optional()?
             .map(|state| (state, tables, on_sync)))
     }
 }
 
-pub async fn create(
+async fn create_inner(
     store: Arc<Store>,
-    primary: ConnectionPool,
-    src: DeploymentSearch,
+    src: &DeploymentLocator,
     shard: String,
     shards: Vec<String>,
     node: String,
@@ -104,27 +107,47 @@ pub async fn create(
     };
 
     let subgraph_store = store.subgraph_store();
-    let src = src.locate_unique(&primary)?;
     let query_store = store
-        .query_store(
-            QueryTarget::Deployment(src.hash.clone(), Default::default()),
-            true,
-        )
+        .query_store(QueryTarget::Deployment(
+            src.hash.clone(),
+            Default::default(),
+        ))
         .await?;
     let network = query_store.network_name();
 
-    let src_ptr = query_store.block_ptr().await?.ok_or_else(|| anyhow!("subgraph {} has not indexed any blocks yet and can not be used as the source of a copy", src))?;
-    let src_number = if src_ptr.number <= block_offset {
-        bail!("subgraph {} has only indexed up to block {}, but we need at least block {} before we can copy from it", src, src_ptr.number, block_offset);
-    } else {
-        src_ptr.number - block_offset
-    };
+    let src_ptr = query_store
+        .block_ptr()
+        .await?
+        .ok_or_else(|| anyhow!("subgraph {} has not indexed any blocks yet and can not be used as the source of a copy", src))?;
+
+    if src_ptr.number <= block_offset {
+        bail!(
+            "subgraph {} has only indexed up to block {}, but we need at least block {} before we can copy from it",
+            src,
+            src_ptr.number,
+            block_offset
+        );
+    }
+
+    // Validate that the offset block does not fall behind the subgraph's earliest block.
+    let src_state = query_store.deployment_state().await?;
+    let src_number = src_ptr.number - block_offset;
+    if src_number < src_state.earliest_block_number {
+        bail!(
+            "cannot copy subgraph {} with --offset {}: the offset block number {} is behind the subgraph's earliest_block_number {}",
+            src,
+            block_offset,
+            src_number,
+            src_state.earliest_block_number,
+        );
+    }
 
     let chain_store = store
         .block_store()
         .chain_store(network)
+        .await
         .ok_or_else(|| anyhow!("could not find chain store for network {}", network))?;
-    let mut hashes = chain_store.block_hashes_by_block_number(src_number)?;
+    let mut hashes = chain_store.block_hashes_by_block_number(src_number).await?;
     let hash = match hashes.len() {
         0 => bail!(
             "could not find a block with number {} in our cache",
@@ -146,20 +169,53 @@ pub async fn create(
         )
     }
     let shard = Shard::new(shard)?;
-    let node = NodeId::new(node.clone()).map_err(|()| anyhow!("invalid node id `{}`", node))?;
+    let node = NodeId::new(node).map_err(|node| anyhow!("invalid node id `{}`", node))?;
 
-    let dst = subgraph_store.copy_deployment(&src, shard, node, base_ptr, on_sync)?;
+    let dst = subgraph_store
+        .copy_deployment(src, shard, node, base_ptr, on_sync)
+        .await?;
 
     println!("created deployment {} as copy of {}", dst, src);
     Ok(())
 }
 
-pub fn activate(store: Arc<SubgraphStore>, deployment: String, shard: String) -> Result<(), Error> {
+pub async fn create(
+    store: Arc<Store>,
+    primary: ConnectionPool,
+    src: DeploymentSearch,
+    shard: String,
+    shards: Vec<String>,
+    node: String,
+    block_offset: u32,
+    activate: bool,
+    replace: bool,
+) -> Result<(), Error> {
+    let src = src.locate_unique(&primary).await?;
+    create_inner(
+        store,
+        &src,
+        shard,
+        shards,
+        node,
+        block_offset,
+        activate,
+        replace,
+    )
+    .await
+    .map_err(|e| anyhow!("cannot copy {src}: {e}"))
+}
+
+pub async fn activate(
+    store: Arc<SubgraphStore>,
+    deployment: String,
+    shard: String,
+) -> Result<(), Error> {
     let shard = Shard::new(shard)?;
     let deployment =
         DeploymentHash::new(deployment).map_err(|s| anyhow!("illegal deployment hash `{}`", s))?;
     let deployment = store
-        .locate_in_shard(&deployment, shard.clone())?
+        .locate_in_shard(&deployment, shard.clone())
+        .await?
         .ok_or_else(|| {
             anyhow!(
                 "could not find a copy for {} in shard {}",
@@ -167,17 +223,17 @@ pub fn activate(store: Arc<SubgraphStore>, deployment: String, shard: String) ->
                 shard
             )
         })?;
-    store.activate(&deployment)?;
+    store.activate(&deployment).await?;
     println!("activated copy {}", deployment);
     Ok(())
 }
 
-pub fn list(pools: HashMap<Shard, ConnectionPool>) -> Result<(), Error> {
+pub async fn list(pools: HashMap<Shard, ConnectionPool>) -> Result<(), Error> {
     use catalog::active_copies as ac;
     use catalog::deployment_schemas as ds;
 
     let primary = pools.get(&*PRIMARY_SHARD).expect("there is a primary pool");
-    let conn = primary.get()?;
+    let mut conn = primary.get().await?;
 
     let copies = ac::table
         .inner_join(ds::table.on(ds::id.eq(ac::dst)))
@@ -189,7 +245,8 @@ pub fn list(pools: HashMap<Shard, ConnectionPool>) -> Result<(), Error> {
             ds::subgraph,
             ds::shard,
         ))
-        .load::<(i32, i32, Option<UtcDateTime>, UtcDateTime, String, Shard)>(&conn)?;
+        .load::<(i32, i32, Option<UtcDateTime>, UtcDateTime, String, Shard)>(&mut conn)
+        .await?;
     if copies.is_empty() {
         println!("no active copies");
     } else {
@@ -206,7 +263,7 @@ pub fn list(pools: HashMap<Shard, ConnectionPool>) -> Result<(), Error> {
 
             println!("{:20} | {}", "deployment", deployment_hash);
             println!("{:20} | sgd{} -> sgd{} ({})", "action", src, dst, shard);
-            match CopyState::find(&pools, &shard, dst)? {
+            match CopyState::find(&pools, &shard, dst).await? {
                 Some((state, tables, _)) => match cancelled_at {
                     Some(cancel_requested) => match state.cancelled_at {
                         Some(cancelled_at) => status("cancelled", cancelled_at),
@@ -230,54 +287,37 @@ pub fn list(pools: HashMap<Shard, ConnectionPool>) -> Result<(), Error> {
     Ok(())
 }
 
-pub fn status(pools: HashMap<Shard, ConnectionPool>, dst: &DeploymentSearch) -> Result<(), Error> {
+pub async fn status(
+    pools: HashMap<Shard, ConnectionPool>,
+    dst: &DeploymentSearch,
+) -> Result<(), Error> {
+    const CHECK: &str = "✓";
+
     use catalog::active_copies as ac;
     use catalog::deployment_schemas as ds;
 
-    fn done(ts: &Option<UtcDateTime>) -> String {
-        ts.map(|_| "✓").unwrap_or(".").to_string()
-    }
-
-    fn duration(start: &UtcDateTime, end: &Option<UtcDateTime>) -> String {
-        let start = *start;
-        let end = *end;
-
-        let end = end.unwrap_or(UtcDateTime::from(SystemTime::now()));
-        let duration = end - start;
-
-        human_duration(duration)
-    }
-
-    fn human_duration(duration: Duration) -> String {
-        if duration.num_seconds() < 5 {
-            format!("{}ms", duration.num_milliseconds())
-        } else if duration.num_minutes() < 5 {
-            format!("{}s", duration.num_seconds())
-        } else {
-            format!("{}m", duration.num_minutes())
-        }
-    }
-
     let primary = pools
         .get(&*PRIMARY_SHARD)
         .ok_or_else(|| anyhow!("can not find deployment with id {}", dst))?;
-    let pconn = primary.get()?;
-    let dst = dst.locate_unique(primary)?.id.0;
+    let mut pconn = primary.get().await?;
+    let dst = dst.locate_unique(primary).await?.id.0;
 
     let (shard, deployment) = ds::table
         .filter(ds::id.eq(dst))
         .select((ds::shard, ds::subgraph))
-        .get_result::<(Shard, String)>(&pconn)?;
+        .get_result::<(Shard, String)>(&mut pconn)
+        .await?;
 
     let (active, cancelled_at) = ac::table
         .filter(ac::dst.eq(dst))
         .select((ac::src, ac::cancelled_at))
-        .get_result::<(i32, Option<UtcDateTime>)>(&pconn)
+        .get_result::<(i32, Option<UtcDateTime>)>(&mut pconn)
+        .await
         .optional()?
         .map(|(_, cancelled_at)| (true, cancelled_at))
         .unwrap_or((false, None));
 
-    let (state, tables, on_sync) = match CopyState::find(&pools, &shard, dst)? {
+    let (state, tables, on_sync) = match CopyState::find(&pools, &shard, dst).await? {
         Some((state, tables, on_sync)) => (state, tables, on_sync),
         None => {
             if active {
@@ -290,7 +330,7 @@ pub fn status(pools: HashMap<Shard, ConnectionPool>, dst: &DeploymentSearch) ->
     };
 
     let progress = match &state.finished_at {
-        Some(_) => done(&state.finished_at),
+        Some(_) => CHECK.to_string(),
         None => {
             let target: i64 = tables.iter().map(|table| table.target_vid).sum();
             let next: i64 = tables.iter().map(|table| table.next_vid).sum();
@@ -314,7 +354,7 @@ pub fn status(pools: HashMap<Shard, ConnectionPool>, dst: &DeploymentSearch) ->
         state.dst.to_string(),
         state.target_block_number.to_string(),
         on_sync.to_str().to_string(),
-        duration(&state.started_at, &state.finished_at),
+        fmt::duration(&state.started_at, &state.finished_at),
         progress,
     ];
     match (cancelled_at, state.cancelled_at) {
@@ -334,27 +374,29 @@ pub fn status(pools: HashMap<Shard, ConnectionPool>, dst: &DeploymentSearch) ->
     println!();
 
     println!(
-        "{:^30} | {:^8} | {:^8} | {:^8} | {:^8}",
+        "{:^30} | {:^10} | {:^10} | {:^8} | {:^10}",
         "entity type", "next", "target", "batch", "duration"
     );
-    println!("{:-<74}", "-");
+    println!("{:-<80}", "-");
     for table in tables {
-        let status = if table.next_vid > 0 && table.next_vid < table.target_vid {
-            ">".to_string()
-        } else if table.target_vid < 0 {
+        let status = match &table.finished_at {
+            // table finished
+            Some(_) => CHECK,
             // empty source table
-            "✓".to_string()
-        } else {
-            done(&table.finished_at)
+            None if table.target_vid < 0 => CHECK,
+            // copying in progress
+            None if table.duration_ms > 0 => ">",
+            // not started
+            None => ".",
         };
         println!(
-            "{} {:<28} | {:>8} | {:>8} | {:>8} | {:>8}",
+            "{} {:<28} | {:>10} | {:>10} | {:>8} | {:>10}",
             status,
             table.entity_type,
             table.next_vid,
             table.target_vid,
             table.batch_size,
-            human_duration(Duration::milliseconds(table.duration_ms)),
+            fmt::human_duration(Duration::milliseconds(table.duration_ms)),
         );
     }
 
diff --git a/node/src/manager/commands/create.rs b/node/src/manager/commands/create.rs
index 02e1184684f..8ab34a0d487 100644
--- a/node/src/manager/commands/create.rs
+++ b/node/src/manager/commands/create.rs
@@ -1,14 +1,14 @@
 use std::sync::Arc;
 
-use graph::prelude::{anyhow, Error, SubgraphName, SubgraphStore as _};
+use graph::prelude::{Error, SubgraphName, SubgraphStore as _, anyhow};
 use graph_store_postgres::SubgraphStore;
 
-pub fn run(store: Arc<SubgraphStore>, name: String) -> Result<(), Error> {
+pub async fn run(store: Arc<SubgraphStore>, name: String) -> Result<(), Error> {
     let name = SubgraphName::new(name.clone())
-        .map_err(|()| anyhow!("illegal subgraph name `{}`", name))?;
+        .map_err(|name| anyhow!("illegal subgraph name `{name}`"))?;
 
     println!("creating subgraph {}", name);
-    store.create_subgraph(name)?;
+    store.create_subgraph(name).await?;
 
     Ok(())
 }
diff --git a/node/src/manager/commands/database.rs b/node/src/manager/commands/database.rs
index 17d11c041cf..69c7ad932af 100644
--- a/node/src/manager/commands/database.rs
+++ b/node/src/manager/commands/database.rs
@@ -1,7 +1,7 @@
 use std::{io::Write, time::Instant};
 
 use graph::prelude::anyhow;
-use graph_store_postgres::connection_pool::PoolCoordinator;
+use graph_store_postgres::PoolCoordinator;
 
 pub async fn remap(
     coord: &PoolCoordinator,
@@ -16,15 +16,15 @@ pub async fn remap(
     };
     let servers = coord.servers();
 
-    if let Some(src) = &src {
-        if !servers.iter().any(|srv| srv.shard.as_str() == src) {
-            return Err(anyhow!("unknown source shard {src}"));
-        }
+    if let Some(src) = &src
+        && !servers.iter().any(|srv| srv.shard.as_str() == src)
+    {
+        return Err(anyhow!("unknown source shard {src}"));
     }
-    if let Some(dst) = &dst {
-        if !pools.iter().any(|pool| pool.shard.as_str() == dst) {
-            return Err(anyhow!("unknown destination shard {dst}"));
-        }
+    if let Some(dst) = &dst
+        && !pools.iter().any(|pool| pool.shard.as_str() == dst)
+    {
+        return Err(anyhow!("unknown destination shard {dst}"));
     }
 
     let servers = servers.iter().filter(|srv| match &src {
@@ -45,7 +45,7 @@ pub async fn remap(
                 server.shard, pool.shard
             );
             std::io::stdout().flush().ok();
-            if let Err(e) = pool.remap(server) {
+            if let Err(e) = pool.remap(server).await {
                 println!(" FAILED");
                 println!("  error: {e}");
                 if !force {
diff --git a/node/src/manager/commands/deploy.rs b/node/src/manager/commands/deploy.rs
index 5fa187615a5..603d09b63ca 100644
--- a/node/src/manager/commands/deploy.rs
+++ b/node/src/manager/commands/deploy.rs
@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
 use graph::prelude::{
-    anyhow::{anyhow, bail, Result},
-    reqwest,
-    serde_json::{json, Value},
     SubgraphName, SubgraphStore,
+    anyhow::{Result, anyhow, bail},
+    reqwest,
+    serde_json::{Value, json},
 };
 
 use crate::manager::deployment::DeploymentSearch;
@@ -68,7 +68,6 @@ pub async fn run(
     deployment: DeploymentSearch,
     search: DeploymentSearch,
     url: String,
-    create: bool,
 ) -> Result<()> {
     let hash = match deployment {
         DeploymentSearch::Hash { hash, shard: _ } => hash,
@@ -80,16 +79,13 @@ pub async fn run(
         _ => bail!("The `name` must be a valid subgraph name"),
     };
 
-    if create {
-        println!("Creating subgraph `{}`", name);
-        let subgraph_name =
-            SubgraphName::new(name.clone()).map_err(|_| anyhow!("Invalid subgraph name"))?;
+    let subgraph_name =
+        SubgraphName::new(name.clone()).map_err(|_| anyhow!("Invalid subgraph name"))?;
 
-        let exists = subgraph_store.subgraph_exists(&subgraph_name)?;
+    let exists = subgraph_store.subgraph_exists(&subgraph_name).await?;
 
-        if exists {
-            bail!("Subgraph with name `{}` already exists", name);
-        }
+    if !exists {
+        println!("Creating subgraph `{}`", name);
 
         // Send the subgraph_create request
         send_create_request(&name, &url).await?;
diff --git a/node/src/manager/commands/deployment/info.rs b/node/src/manager/commands/deployment/info.rs
new file mode 100644
index 00000000000..14151664bda
--- /dev/null
+++ b/node/src/manager/commands/deployment/info.rs
@@ -0,0 +1,173 @@
+use std::collections::BTreeMap;
+use std::collections::HashMap;
+use std::io;
+use std::sync::Arc;
+
+use anyhow::Result;
+use anyhow::bail;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::Store;
+use graphman::commands::deployment::info::DeploymentStatus;
+use graphman::commands::deployment::info::load_deployment_statuses;
+use graphman::commands::deployment::info::load_deployments;
+use graphman::deployment::Deployment;
+use graphman::deployment::DeploymentSelector;
+use graphman::deployment::DeploymentVersionSelector;
+
+use crate::manager::display::Columns;
+use crate::manager::display::Row;
+
+pub struct Context {
+    pub primary_pool: ConnectionPool,
+    pub store: Arc<Store>,
+}
+
+pub struct Args {
+    pub deployment: Option<DeploymentSelector>,
+    pub current: bool,
+    pub pending: bool,
+    pub status: bool,
+    pub used: bool,
+    pub all: bool,
+    pub brief: bool,
+    pub no_name: bool,
+}
+
+pub async fn run(ctx: Context, args: Args) -> Result<()> {
+    let Context {
+        primary_pool,
+        store,
+    } = ctx;
+
+    let Args {
+        deployment,
+        current,
+        pending,
+        status,
+        used,
+        all,
+        brief,
+        no_name,
+    } = args;
+
+    let deployment = match deployment {
+        Some(deployment) => deployment,
+        None if all => DeploymentSelector::All,
+        None => {
+            bail!("Please specify a deployment or use --all to list all deployments");
+        }
+    };
+
+    let version = make_deployment_version_selector(current, pending, used);
+    let deployments = load_deployments(primary_pool.clone(), &deployment, &version).await?;
+
+    if deployments.is_empty() {
+        println!("No matches");
+        return Ok(());
+    }
+
+    let statuses = if status {
+        Some(load_deployment_statuses(store, &deployments).await?)
+    } else {
+        None
+    };
+
+    render(brief, no_name, deployments, statuses);
+    Ok(())
+}
+
+fn make_deployment_version_selector(
+    current: bool,
+    pending: bool,
+    used: bool,
+) -> DeploymentVersionSelector {
+    use DeploymentVersionSelector::*;
+
+    match (current || used, pending || used) {
+        (false, false) => All,
+        (true, false) => Current,
+        (false, true) => Pending,
+        (true, true) => Used,
+    }
+}
+
+const NONE: &str = "---";
+
+fn optional(s: Option<impl ToString>) -> String {
+    s.map(|x| x.to_string()).unwrap_or(NONE.to_owned())
+}
+
+fn render(
+    brief: bool,
+    no_name: bool,
+    deployments: Vec<Deployment>,
+    statuses: Option<HashMap<i32, DeploymentStatus>>,
+) {
+    fn name_and_status(deployment: &Deployment) -> String {
+        format!("{} ({})", deployment.name, deployment.version_status)
+    }
+
+    fn number(n: Option<i32>) -> String {
+        n.map(|x| format!("{x}")).unwrap_or(NONE.to_owned())
+    }
+
+    let mut table = Columns::default();
+
+    let mut combined: BTreeMap<_, Vec<_>> = BTreeMap::new();
+    for deployment in deployments {
+        let status = statuses.as_ref().and_then(|x| x.get(&deployment.id));
+        combined
+            .entry(deployment.id)
+            .or_default()
+            .push((deployment, status));
+    }
+
+    let mut first = true;
+    for (_, deployments) in combined {
+        let deployment = &deployments[0].0;
+        if first {
+            first = false;
+        } else {
+            table.push_row(Row::separator());
+        }
+        table.push_row([
+            "Namespace",
+            &format!("{} [{}]", deployment.namespace, deployment.shard),
+        ]);
+        table.push_row(["Hash", &deployment.hash]);
+        if !no_name && (!brief || deployment.is_active) {
+            if deployments.len() > 1 {
+                table.push_row(["Versions", &name_and_status(deployment)]);
+                for (d, _) in &deployments[1..] {
+                    table.push_row(["", &name_and_status(d)]);
+                }
+            } else {
+                table.push_row(["Version", &name_and_status(deployment)]);
+            }
+            table.push_row(["Chain", &deployment.chain]);
+        }
+        table.push_row(["Node ID", &optional(deployment.node_id.as_ref())]);
+        table.push_row(["Active", &deployment.is_active.to_string()]);
+        if let Some((_, Some(status))) = deployments.first() {
+            table.push_row(["Paused", &optional(status.is_paused)]);
+            table.push_row(["Synced", &status.is_synced.to_string()]);
+            table.push_row(["Health", status.health.as_str()]);
+            let earliest = status.earliest_block_number;
+            let latest = status.latest_block.as_ref().map(|x| x.number);
+            let chain_head = status.chain_head_block.as_ref().map(|x| x.number);
+            let behind = match (latest, chain_head) {
+                (Some(latest), Some(chain_head)) => Some(chain_head - latest),
+                _ => None,
+            };
+
+            table.push_row(["Earliest Block", &earliest.to_string()]);
+            table.push_row(["Latest Block", &number(latest)]);
+            table.push_row(["Chain Head Block", &number(chain_head)]);
+            if let Some(behind) = behind {
+                table.push_row(["   Blocks behind", &behind.to_string()]);
+            }
+        }
+    }
+
+    table.render(&mut io::stdout()).ok();
+}
diff --git a/node/src/manager/commands/deployment/mod.rs b/node/src/manager/commands/deployment/mod.rs
new file mode 100644
index 00000000000..8fd0237d3a7
--- /dev/null
+++ b/node/src/manager/commands/deployment/mod.rs
@@ -0,0 +1,6 @@
+pub mod info;
+pub mod pause;
+pub mod reassign;
+pub mod restart;
+pub mod resume;
+pub mod unassign;
diff --git a/node/src/manager/commands/deployment/pause.rs b/node/src/manager/commands/deployment/pause.rs
new file mode 100644
index 00000000000..2dd913df300
--- /dev/null
+++ b/node/src/manager/commands/deployment/pause.rs
@@ -0,0 +1,34 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graphman::commands::deployment::pause::{
+    PauseDeploymentError, load_active_deployment, pause_active_deployment,
+};
+use graphman::deployment::DeploymentSelector;
+
+pub async fn run(
+    primary_pool: ConnectionPool,
+    notification_sender: Arc<NotificationSender>,
+    deployment: DeploymentSelector,
+) -> Result<()> {
+    let active_deployment = load_active_deployment(primary_pool.clone(), &deployment).await;
+
+    match active_deployment {
+        Ok(active_deployment) => {
+            println!("Pausing deployment {} ...", active_deployment.locator());
+            pause_active_deployment(primary_pool, notification_sender, active_deployment).await?;
+        }
+        Err(PauseDeploymentError::AlreadyPaused(locator)) => {
+            println!("Deployment {} is already paused", locator);
+            return Ok(());
+        }
+        Err(PauseDeploymentError::Common(e)) => {
+            println!("Failed to load active deployment: {}", e);
+            return Err(e.into());
+        }
+    }
+
+    Ok(())
+}
diff --git a/node/src/manager/commands/deployment/reassign.rs b/node/src/manager/commands/deployment/reassign.rs
new file mode 100644
index 00000000000..abd35f42700
--- /dev/null
+++ b/node/src/manager/commands/deployment/reassign.rs
@@ -0,0 +1,55 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use graph::prelude::NodeId;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graphman::commands::deployment::reassign::{
+    ReassignResult, load_deployment, reassign_deployment,
+};
+use graphman::deployment::DeploymentSelector;
+
+pub async fn run(
+    primary_pool: ConnectionPool,
+    notification_sender: Arc<NotificationSender>,
+    deployment: DeploymentSelector,
+    node: &NodeId,
+) -> Result<()> {
+    let deployment = load_deployment(primary_pool.clone(), &deployment).await?;
+    let curr_node = deployment.assigned_node(primary_pool.clone()).await?;
+    let reassign_msg = match &curr_node {
+        Some(curr_node) => format!(
+            "Reassigning deployment {} (was {})",
+            deployment.locator(),
+            curr_node
+        ),
+        None => format!("Reassigning deployment {}", deployment.locator()),
+    };
+    println!("{}", reassign_msg);
+
+    let reassign_result = reassign_deployment(
+        primary_pool,
+        notification_sender,
+        &deployment,
+        node,
+        curr_node,
+    )
+    .await?;
+
+    match reassign_result {
+        ReassignResult::Ok => {
+            println!(
+                "Deployment {} assigned to node {}",
+                deployment.locator(),
+                node
+            );
+        }
+        ReassignResult::CompletedWithWarnings(warnings) => {
+            for msg in warnings {
+                println!("{}", msg);
+            }
+        }
+    }
+
+    Ok(())
+}
diff --git a/node/src/manager/commands/deployment/restart.rs b/node/src/manager/commands/deployment/restart.rs
new file mode 100644
index 00000000000..12c256103b0
--- /dev/null
+++ b/node/src/manager/commands/deployment/restart.rs
@@ -0,0 +1,33 @@
+use std::sync::Arc;
+use std::thread::sleep;
+use std::time::Duration;
+
+use anyhow::Result;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graphman::deployment::DeploymentSelector;
+
+pub async fn run(
+    primary_pool: ConnectionPool,
+    notification_sender: Arc<NotificationSender>,
+    deployment: DeploymentSelector,
+    delay: Duration,
+) -> Result<()> {
+    super::pause::run(
+        primary_pool.clone(),
+        notification_sender.clone(),
+        deployment.clone(),
+    )
+    .await?;
+
+    println!(
+        "Waiting {}s to make sure pausing was processed ...",
+        delay.as_secs()
+    );
+
+    sleep(delay);
+
+    super::resume::run(primary_pool, notification_sender, deployment.clone()).await?;
+
+    Ok(())
+}
diff --git a/node/src/manager/commands/deployment/resume.rs b/node/src/manager/commands/deployment/resume.rs
new file mode 100644
index 00000000000..b83e9e546d9
--- /dev/null
+++ b/node/src/manager/commands/deployment/resume.rs
@@ -0,0 +1,22 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graphman::commands::deployment::resume::load_paused_deployment;
+use graphman::commands::deployment::resume::resume_paused_deployment;
+use graphman::deployment::DeploymentSelector;
+
+pub async fn run(
+    primary_pool: ConnectionPool,
+    notification_sender: Arc<NotificationSender>,
+    deployment: DeploymentSelector,
+) -> Result<()> {
+    let paused_deployment = load_paused_deployment(primary_pool.clone(), &deployment).await?;
+
+    println!("Resuming deployment {} ...", paused_deployment.locator());
+
+    resume_paused_deployment(primary_pool, notification_sender, paused_deployment).await?;
+
+    Ok(())
+}
diff --git a/node/src/manager/commands/deployment/unassign.rs b/node/src/manager/commands/deployment/unassign.rs
new file mode 100644
index 00000000000..8f68aceec90
--- /dev/null
+++ b/node/src/manager/commands/deployment/unassign.rs
@@ -0,0 +1,22 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graphman::commands::deployment::unassign::load_assigned_deployment;
+use graphman::commands::deployment::unassign::unassign_deployment;
+use graphman::deployment::DeploymentSelector;
+
+pub async fn run(
+    primary_pool: ConnectionPool,
+    notification_sender: Arc<NotificationSender>,
+    deployment: DeploymentSelector,
+) -> Result<()> {
+    let assigned_deployment = load_assigned_deployment(primary_pool.clone(), &deployment).await?;
+
+    println!("Unassigning deployment {}", assigned_deployment.locator());
+
+    unassign_deployment(primary_pool, notification_sender, assigned_deployment).await?;
+
+    Ok(())
+}
diff --git a/node/src/manager/commands/drop.rs b/node/src/manager/commands/drop.rs
deleted file mode 100644
index 30d724575c5..00000000000
--- a/node/src/manager/commands/drop.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use crate::manager::{
-    deployment::{Deployment, DeploymentSearch},
-    display::List,
-    prompt::prompt_for_confirmation,
-};
-use graph::anyhow::{self, bail};
-use graph_store_postgres::{connection_pool::ConnectionPool, NotificationSender, SubgraphStore};
-use std::sync::Arc;
-
-/// Finds, unassigns, record and remove matching deployments.
-///
-/// Asks for confirmation before removing any data.
-/// This is a convenience fuction that to call a series of other graphman commands.
-pub async fn run(
-    primary_pool: ConnectionPool,
-    subgraph_store: Arc<SubgraphStore>,
-    sender: Arc<NotificationSender>,
-    search_term: DeploymentSearch,
-    current: bool,
-    pending: bool,
-    used: bool,
-    skip_confirmation: bool,
-) -> anyhow::Result<()> {
-    // call `graphman info` to find matching deployments
-    let deployments = search_term.find(primary_pool.clone(), current, pending, used)?;
-    if deployments.is_empty() {
-        bail!("Found no deployment for search_term: {search_term}")
-    } else {
-        print_deployments(&deployments);
-        if !skip_confirmation && !prompt_for_confirmation("\nContinue?")? {
-            println!("Execution aborted by user");
-            return Ok(());
-        }
-    }
-    // call `graphman unassign` to stop any active deployments
-    crate::manager::commands::assign::unassign(primary_pool, &sender, &search_term).await?;
-
-    // call `graphman remove` to unregister the subgraph's name
-    for deployment in &deployments {
-        crate::manager::commands::remove::run(subgraph_store.clone(), &deployment.name)?;
-    }
-
-    // call `graphman unused record` to register those deployments unused
-    crate::manager::commands::unused_deployments::record(subgraph_store.clone())?;
-
-    // call `graphman unused remove` to remove each deployment's data
-    for deployment in &deployments {
-        crate::manager::commands::unused_deployments::remove(
-            subgraph_store.clone(),
-            1_000_000,
-            Some(&deployment.deployment),
-            None,
-        )?;
-    }
-    Ok(())
-}
-
-fn print_deployments(deployments: &[Deployment]) {
-    let mut list = List::new(vec!["name", "deployment"]);
-    println!("Found {} deployment(s) to remove:", deployments.len());
-    for deployment in deployments {
-        list.append(vec![
-            deployment.name.to_string(),
-            deployment.deployment.to_string(),
-        ]);
-    }
-    list.render();
-}
diff --git a/node/src/manager/commands/dump.rs b/node/src/manager/commands/dump.rs
new file mode 100644
index 00000000000..5dca517f2f7
--- /dev/null
+++ b/node/src/manager/commands/dump.rs
@@ -0,0 +1,149 @@
+use std::fs;
+use std::sync::Arc;
+use std::time::Instant;
+
+use console::style;
+use graph::components::store::DumpReporter;
+use graph::prelude::anyhow::Result;
+use indicatif::ProgressBar;
+
+use graph_store_postgres::{ConnectionPool, SubgraphStore};
+
+use crate::manager::deployment::DeploymentSearch;
+
+struct DumpProgress {
+    spinner: ProgressBar,
+    start: Instant,
+    table_start: Instant,
+    table_rows: usize,
+}
+
+impl DumpProgress {
+    fn new() -> Self {
+        let spinner = ProgressBar::new_spinner();
+        spinner.enable_steady_tick(std::time::Duration::from_millis(80));
+        Self {
+            spinner,
+            start: Instant::now(),
+            table_start: Instant::now(),
+            table_rows: 0,
+        }
+    }
+}
+
+impl DumpReporter for DumpProgress {
+    fn start(&mut self, deployment: &str, table_count: usize) {
+        self.start = Instant::now();
+        self.spinner.set_message(format!(
+            "Dumping deployment {} ({} tables)",
+            style(deployment).cyan(),
+            table_count,
+        ));
+    }
+
+    fn start_table(&mut self, table: &str, rows_approx: usize) {
+        self.table_start = Instant::now();
+        self.table_rows = 0;
+        self.spinner
+            .set_message(format!("{:<32} ~{} rows", table, format_count(rows_approx),));
+    }
+
+    fn batch_dumped(&mut self, table: &str, rows: usize) {
+        self.table_rows += rows;
+        self.spinner.set_message(format!(
+            "{:<32} {} rows",
+            table,
+            format_count(self.table_rows),
+        ));
+    }
+
+    fn finish_table(&mut self, table: &str, rows: usize) {
+        let elapsed = self.table_start.elapsed().as_secs();
+        let line = format!(
+            "  {} {:<32} {:>10} rows {:>4}s",
+            style("\u{2714}").green(),
+            table,
+            format_count(rows),
+            elapsed,
+        );
+        self.spinner.suspend(|| println!("{line}"));
+    }
+
+    fn start_data_sources(&mut self) {
+        self.table_start = Instant::now();
+        self.table_rows = 0;
+        self.spinner.set_message("data_sources$".to_string());
+    }
+
+    fn finish_data_sources(&mut self, rows: usize) {
+        let elapsed = self.table_start.elapsed().as_secs();
+        let line = format!(
+            "  {} {:<32} {:>10} rows {:>4}s",
+            style("\u{2714}").green(),
+            "data_sources$",
+            format_count(rows),
+            elapsed,
+        );
+        self.spinner.suspend(|| println!("{line}"));
+    }
+
+    fn start_clamps(&mut self, table: &str, rows_approx: usize) {
+        self.spinner.set_message(format!(
+            "{:<32} clamps ~{} rows",
+            table,
+            format_count(rows_approx),
+        ));
+    }
+
+    fn finish_clamps(&mut self, table: &str, rows: usize) {
+        if rows > 0 {
+            let line = format!(
+                "  {} {:<32} {:>10} clamps",
+                style("\u{2714}").green(),
+                table,
+                format_count(rows),
+            );
+            self.spinner.suspend(|| println!("{line}"));
+        }
+    }
+
+    fn finish(&mut self) {
+        let elapsed = self.start.elapsed().as_secs();
+        self.spinner.finish_with_message(format!(
+            "{} Dump complete ({}s)",
+            style("\u{2714}").green(),
+            elapsed
+        ));
+    }
+}
+
+fn format_count(n: usize) -> String {
+    if n == 0 {
+        return "0".to_string();
+    }
+    let s = n.to_string();
+    let mut result = String::new();
+    for (i, c) in s.chars().rev().enumerate() {
+        if i > 0 && i % 3 == 0 {
+            result.push(',');
+        }
+        result.push(c);
+    }
+    result.chars().rev().collect()
+}
+
+pub async fn run(
+    subgraph_store: Arc<SubgraphStore>,
+    primary_pool: ConnectionPool,
+    deployment: DeploymentSearch,
+    directory: String,
+) -> Result<()> {
+    fs::create_dir_all(&directory)?;
+    let directory = fs::canonicalize(&directory)?;
+
+    let loc = deployment.locate_unique(&primary_pool).await?;
+
+    let reporter = Box::new(DumpProgress::new());
+    subgraph_store.dump(&loc, directory, reporter).await?;
+    Ok(())
+}
diff --git a/node/src/manager/commands/index.rs b/node/src/manager/commands/index.rs
index 997413516a1..bf14e0ee62a 100644
--- a/node/src/manager/commands/index.rs
+++ b/node/src/manager/commands/index.rs
@@ -1,17 +1,18 @@
-use crate::manager::{color::Terminal, deployment::DeploymentSearch, CmdResult};
+use crate::manager::{CmdResult, color::Terminal, deployment::DeploymentSearch};
 use graph::{
     components::store::DeploymentLocator,
     itertools::Itertools,
-    prelude::{anyhow, StoreError},
+    prelude::{StoreError, anyhow},
 };
 use graph_store_postgres::{
-    command_support::index::{CreateIndex, Method},
-    connection_pool::ConnectionPool,
-    SubgraphStore,
+    ConnectionPool, SubgraphStore,
+    command_support::index::{CreateIndex, IndexCreator, Method},
 };
 use std::io::Write as _;
 use std::{collections::HashSet, sync::Arc};
 
+pub const BLOCK_RANGE_COLUMN: &str = "block_range";
+
 fn validate_fields<T: AsRef<str>>(fields: &[T]) -> Result<(), anyhow::Error> {
     // Must be non-empty. Double checking, since [`StructOpt`] already checks this.
     if fields.is_empty() {
@@ -34,15 +35,27 @@ pub async fn create(
     search: DeploymentSearch,
     entity_name: &str,
     field_names: Vec<String>,
-    index_method: String,
+    index_method: Option<String>,
     after: Option<i32>,
 ) -> Result<(), anyhow::Error> {
     validate_fields(&field_names)?;
-    let deployment_locator = search.locate_unique(&pool)?;
+    let deployment_locator = search.locate_unique(&pool).await?;
     println!("Index creation started. Please wait.");
-    let index_method = index_method
+
+    // If the fields contain the block range column, we use GIN
+    // indexes. Otherwise we default to B-tree indexes.
+    let index_method_str = index_method.as_deref().unwrap_or_else(|| {
+        if field_names.contains(&BLOCK_RANGE_COLUMN.to_string()) {
+            "gist"
+        } else {
+            "btree"
+        }
+    });
+
+    let index_method = index_method_str
         .parse::<Method>()
-        .map_err(|()| anyhow!("unknown index method `{}`", index_method))?;
+        .map_err(|_| anyhow!("unknown index method `{}`", index_method_str))?;
+
     match store
         .create_manual_index(
             &deployment_locator,
@@ -104,11 +117,6 @@ pub async fn list(
         Ok(())
     }
 
-    fn footer(term: &mut Terminal) -> Result<(), anyhow::Error> {
-        writeln!(term, "  (a): account-like flag set")?;
-        Ok(())
-    }
-
     fn print_index(term: &mut Terminal, index: &CreateIndex) -> CmdResult {
         use CreateIndex::*;
 
@@ -158,7 +166,7 @@ pub async fn list(
         Ok(())
     }
 
-    let deployment_locator = search.locate_unique(&pool)?;
+    let deployment_locator = search.locate_unique(&pool).await?;
     let indexes: Vec<_> = {
         let mut indexes = store
             .indexes_for_entity(&deployment_locator, entity_name)
@@ -175,8 +183,9 @@ pub async fn list(
     let mut term = Terminal::new();
 
     if to_sql {
+        let creat = IndexCreator::new(concurrent, if_not_exists, true);
         for index in indexes {
-            writeln!(term, "{};", index.to_sql(concurrent, if_not_exists)?)?;
+            writeln!(term, "{};", creat.to_sql(&index)?)?;
         }
     } else {
         let mut first = true;
@@ -199,7 +208,7 @@ pub async fn drop(
     search: DeploymentSearch,
     index_name: &str,
 ) -> Result<(), anyhow::Error> {
-    let deployment_locator = search.locate_unique(&pool)?;
+    let deployment_locator = search.locate_unique(&pool).await?;
     store
         .drop_index_for_deployment(&deployment_locator, index_name)
         .await?;
diff --git a/node/src/manager/commands/info.rs b/node/src/manager/commands/info.rs
deleted file mode 100644
index 76781d74d57..00000000000
--- a/node/src/manager/commands/info.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use std::sync::Arc;
-
-use graph::{components::store::StatusStore, data::subgraph::status, prelude::anyhow};
-use graph_store_postgres::{connection_pool::ConnectionPool, Store};
-
-use crate::manager::deployment::{Deployment, DeploymentSearch};
-
-pub fn run(
-    pool: ConnectionPool,
-    store: Option<Arc<Store>>,
-    search: DeploymentSearch,
-    current: bool,
-    pending: bool,
-    used: bool,
-) -> Result<(), anyhow::Error> {
-    let deployments = search.find(pool, current, pending, used)?;
-    let ids: Vec<_> = deployments.iter().map(|d| d.locator().id).collect();
-    let statuses = match store {
-        Some(store) => store.status(status::Filter::DeploymentIds(ids))?,
-        None => vec![],
-    };
-
-    if deployments.is_empty() {
-        println!("No matches");
-    } else {
-        Deployment::print_table(deployments, statuses);
-    }
-    Ok(())
-}
diff --git a/node/src/manager/commands/listen.rs b/node/src/manager/commands/listen.rs
index 5c18e3fddb9..2b65fde8006 100644
--- a/node/src/manager/commands/listen.rs
+++ b/node/src/manager/commands/listen.rs
@@ -1,94 +1,33 @@
-use std::iter::FromIterator;
+use std::io::Write;
 use std::sync::Arc;
-use std::{collections::BTreeSet, io::Write};
 
-use futures::compat::Future01CompatExt;
-use graph::prelude::DeploymentHash;
-use graph::schema::{EntityType, InputSchema};
+use graph::futures03::{StreamExt, future};
+
 use graph::{
     components::store::SubscriptionManager as _,
-    prelude::{serde_json, Error, Stream, SubscriptionFilter},
+    prelude::{Error, serde_json},
 };
-use graph_store_postgres::connection_pool::ConnectionPool;
 use graph_store_postgres::SubscriptionManager;
 
-use crate::manager::deployment::DeploymentSearch;
-
-async fn listen(
-    mgr: Arc<SubscriptionManager>,
-    filter: BTreeSet<SubscriptionFilter>,
-) -> Result<(), Error> {
-    let events = mgr.subscribe(filter);
+async fn listen(mgr: Arc<SubscriptionManager>) -> Result<(), Error> {
+    let events = mgr.subscribe();
     println!("press ctrl-c to stop");
-    let res = events
-        .inspect(move |event| {
-            serde_json::to_writer_pretty(std::io::stdout(), event)
+    events
+        .for_each(move |event| {
+            serde_json::to_writer_pretty(std::io::stdout(), &event)
                 .expect("event can be serialized to JSON");
-            writeln!(std::io::stdout()).unwrap();
+            println!();
             std::io::stdout().flush().unwrap();
+            future::ready(())
         })
-        .collect()
-        .compat()
         .await;
 
-    match res {
-        Ok(_) => {
-            println!("stream finished")
-        }
-        Err(()) => {
-            eprintln!("stream failed")
-        }
-    }
     Ok(())
 }
 
 pub async fn assignments(mgr: Arc<SubscriptionManager>) -> Result<(), Error> {
     println!("waiting for assignment events");
-    listen(
-        mgr,
-        FromIterator::from_iter([SubscriptionFilter::Assignment]),
-    )
-    .await?;
-
-    Ok(())
-}
-
-pub async fn entities(
-    primary_pool: ConnectionPool,
-    mgr: Arc<SubscriptionManager>,
-    search: &DeploymentSearch,
-    entity_types: Vec<String>,
-) -> Result<(), Error> {
-    // We convert the entity type names into entity types in this very
-    // awkward way to avoid needing to have a SubgraphStore from which we
-    // load the input schema
-    fn as_entity_types(
-        entity_types: Vec<String>,
-        id: &DeploymentHash,
-    ) -> Result<Vec<EntityType>, Error> {
-        use std::fmt::Write;
-
-        let schema = entity_types
-            .iter()
-            .fold(String::new(), |mut buf, entity_type| {
-                writeln!(buf, "type {entity_type} @entity {{ id: ID! }}").unwrap();
-                buf
-            });
-        let schema = InputSchema::parse_latest(&schema, id.clone()).unwrap();
-        entity_types
-            .iter()
-            .map(|et| schema.entity_type(et))
-            .collect::<Result<_, _>>()
-    }
-
-    let locator = search.locate_unique(&primary_pool)?;
-    let filter = as_entity_types(entity_types, &locator.hash)?
-        .into_iter()
-        .map(|et| SubscriptionFilter::Entities(locator.hash.clone(), et))
-        .collect();
-
-    println!("waiting for store events from {}", locator);
-    listen(mgr, filter).await?;
+    listen(mgr).await?;
 
     Ok(())
 }
diff --git a/node/src/manager/commands/mod.rs b/node/src/manager/commands/mod.rs
index 14fd7632d59..9e5ba8e0b95 100644
--- a/node/src/manager/commands/mod.rs
+++ b/node/src/manager/commands/mod.rs
@@ -6,13 +6,15 @@ pub mod copy;
 pub mod create;
 pub mod database;
 pub mod deploy;
-pub mod drop;
+pub mod deployment;
+pub mod dump;
 pub mod index;
-pub mod info;
 pub mod listen;
+pub mod provider_checks;
 pub mod prune;
 pub mod query;
 pub mod remove;
+pub mod restore;
 pub mod rewind;
 pub mod run;
 pub mod stats;
diff --git a/node/src/manager/commands/provider_checks.rs b/node/src/manager/commands/provider_checks.rs
new file mode 100644
index 00000000000..5154756c8f3
--- /dev/null
+++ b/node/src/manager/commands/provider_checks.rs
@@ -0,0 +1,122 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use graph::components::network_provider::ChainIdentifierValidator;
+use graph::components::network_provider::ChainName;
+use graph::components::network_provider::ExtendedBlocksCheck;
+use graph::components::network_provider::GenesisHashCheck;
+use graph::components::network_provider::NetworkDetails;
+use graph::components::network_provider::ProviderCheck;
+use graph::components::network_provider::ProviderCheckStatus;
+use graph::components::network_provider::chain_id_validator;
+use graph::prelude::CheapClone;
+use graph::prelude::Logger;
+use graph::prelude::tokio;
+use graph_store_postgres::BlockStore;
+use itertools::Itertools;
+
+use crate::network_setup::Networks;
+
+pub async fn execute(logger: &Logger, networks: &Networks, store: BlockStore, timeout: Duration) {
+    let chain_name_iter = networks
+        .adapters
+        .iter()
+        .map(|a| a.chain_id())
+        .sorted()
+        .dedup();
+
+    for chain_name in chain_name_iter {
+        let mut errors = Vec::new();
+
+        for adapter in networks
+            .rpc_provider_manager
+            .providers_unchecked(chain_name)
+            .unique_by(|x| x.provider_name())
+        {
+            let validator = chain_id_validator(Box::new(store.cheap_clone()));
+            match tokio::time::timeout(
+                timeout,
+                run_checks(logger, chain_name, adapter, validator.clone()),
+            )
+            .await
+            {
+                Ok(result) => {
+                    errors.extend(result);
+                }
+                Err(_) => {
+                    errors.push("Timeout".to_owned());
+                }
+            }
+        }
+
+        for adapter in networks
+            .firehose_provider_manager
+            .providers_unchecked(chain_name)
+            .unique_by(|x| x.provider_name())
+        {
+            let validator = chain_id_validator(Box::new(store.cheap_clone()));
+            match tokio::time::timeout(timeout, run_checks(logger, chain_name, adapter, validator))
+                .await
+            {
+                Ok(result) => {
+                    errors.extend(result);
+                }
+                Err(_) => {
+                    errors.push("Timeout".to_owned());
+                }
+            }
+        }
+
+        if errors.is_empty() {
+            println!("Chain: {chain_name}; Status: OK");
+            continue;
+        }
+
+        println!("Chain: {chain_name}; Status: ERROR");
+        for error in errors.into_iter().unique() {
+            println!("ERROR: {error}");
+        }
+    }
+}
+
+async fn run_checks(
+    logger: &Logger,
+    chain_name: &ChainName,
+    adapter: &dyn NetworkDetails,
+    store: Arc<dyn ChainIdentifierValidator>,
+) -> Vec<String> {
+    let provider_name = adapter.provider_name();
+
+    let mut errors = Vec::new();
+
+    let genesis_check = GenesisHashCheck::new(store);
+
+    let status = genesis_check
+        .check(logger, chain_name, &provider_name, adapter)
+        .await;
+
+    errors_from_status(status, &mut errors);
+
+    let blocks_check = ExtendedBlocksCheck::new([]);
+
+    let status = blocks_check
+        .check(logger, chain_name, &provider_name, adapter)
+        .await;
+
+    errors_from_status(status, &mut errors);
+
+    errors
+}
+
+fn errors_from_status(status: ProviderCheckStatus, out: &mut Vec<String>) {
+    match status {
+        ProviderCheckStatus::NotChecked => {}
+        ProviderCheckStatus::TemporaryFailure { message, .. } => {
+            out.push(message);
+        }
+        ProviderCheckStatus::Valid => {}
+        ProviderCheckStatus::Failed { message, .. } => {
+            out.push(message);
+        }
+    }
+}
diff --git a/node/src/manager/commands/prune.rs b/node/src/manager/commands/prune.rs
index c169577ee65..82f4387dd4d 100644
--- a/node/src/manager/commands/prune.rs
+++ b/node/src/manager/commands/prune.rs
@@ -6,19 +6,25 @@ use std::{
 };
 
 use graph::{
-    components::store::{PrunePhase, PruneRequest},
+    components::store::{DeploymentLocator, PrunePhase, PruneRequest},
     env::ENV_VARS,
 };
 use graph::{
     components::store::{PruneReporter, StatusStore},
     data::subgraph::status,
-    prelude::{anyhow, BlockNumber},
+    prelude::{BlockNumber, anyhow},
 };
-use graph_store_postgres::{connection_pool::ConnectionPool, Store};
+use graph_store_postgres::{
+    ConnectionPool, Store,
+    command_support::{Phase, PruneTableState},
+};
+use termcolor::Color;
 
 use crate::manager::{
-    commands::stats::{abbreviate_table_name, show_stats},
+    color::Terminal,
+    commands::stats::show_stats,
     deployment::DeploymentSearch,
+    fmt::{self, MapOrNull as _},
 };
 
 struct Progress {
@@ -66,7 +72,7 @@ fn print_batch(
     };
     print!(
         "\r{:<30} | {:>10} | {:>9}s {phase}",
-        abbreviate_table_name(table, 30),
+        fmt::abbreviate(table, 30),
         total_rows,
         elapsed.as_secs()
     );
@@ -80,7 +86,7 @@ impl PruneReporter for Progress {
 
     fn start_analyze(&mut self) {
         if !self.initial_analyze {
-            println!("");
+            println!();
         }
         print!("Analyze tables");
         self.analyze_start = Instant::now();
@@ -99,7 +105,7 @@ impl PruneReporter for Progress {
         let stats: Vec<_> = stats
             .iter()
             .filter(|stat| self.initial_analyze || analyzed.contains(&stat.tablename.as_str()))
-            .map(|stats| stats.clone())
+            .cloned()
             .collect();
         println!(
             "\rAnalyzed {} tables in {}s{: ^30}",
@@ -156,19 +162,24 @@ impl PruneReporter for Progress {
     }
 }
 
-pub async fn run(
-    store: Arc<Store>,
+struct Args {
+    history: BlockNumber,
+    deployment: DeploymentLocator,
+    earliest_block: BlockNumber,
+    latest_block: BlockNumber,
+}
+
+async fn check_args(
+    store: &Arc<Store>,
     primary_pool: ConnectionPool,
     search: DeploymentSearch,
     history: usize,
-    rebuild_threshold: Option<f64>,
-    delete_threshold: Option<f64>,
-    once: bool,
-) -> Result<(), anyhow::Error> {
+) -> Result<Args, anyhow::Error> {
     let history = history as BlockNumber;
-    let deployment = search.locate_unique(&primary_pool)?;
+    let deployment = search.locate_unique(&primary_pool).await?;
     let mut info = store
-        .status(status::Filter::DeploymentIds(vec![deployment.id]))?
+        .status(status::Filter::DeploymentIds(vec![deployment.id]))
+        .await?
         .pop()
         .ok_or_else(|| anyhow!("deployment {deployment} not found"))?;
     if info.chains.len() > 1 {
@@ -181,22 +192,40 @@ pub async fn run(
         .chains
         .pop()
         .ok_or_else(|| anyhow!("deployment {} does not index any chain", deployment))?;
-    let latest = status.latest_block.map(|ptr| ptr.number()).unwrap_or(0);
-    if latest <= history {
-        return Err(anyhow!("deployment {deployment} has only indexed up to block {latest} and we can't preserve {history} blocks of history"));
+    let latest_block = status.latest_block.map(|ptr| ptr.number()).unwrap_or(0);
+    if latest_block <= history {
+        return Err(anyhow!(
+            "deployment {deployment} has only indexed up to block {latest_block} and we can't preserve {history} blocks of history"
+        ));
     }
+    Ok(Args {
+        history,
+        deployment,
+        earliest_block: status.earliest_block_number,
+        latest_block,
+    })
+}
 
-    println!("prune {deployment}");
-    println!("    latest: {latest}");
-    println!("     final: {}", latest - ENV_VARS.reorg_threshold);
-    println!("  earliest: {}\n", latest - history);
+async fn first_prune(
+    store: &Arc<Store>,
+    args: &Args,
+    rebuild_threshold: Option<f64>,
+    delete_threshold: Option<f64>,
+) -> Result<(), anyhow::Error> {
+    println!("prune {}", args.deployment);
+    println!(
+        "     range: {} - {} ({} blocks)",
+        args.earliest_block,
+        args.latest_block,
+        args.latest_block - args.earliest_block
+    );
 
     let mut req = PruneRequest::new(
-        &deployment,
-        history,
-        ENV_VARS.reorg_threshold,
-        status.earliest_block_number,
-        latest,
+        &args.deployment,
+        args.history,
+        ENV_VARS.reorg_threshold(),
+        args.earliest_block,
+        args.latest_block,
     )?;
     if let Some(rebuild_threshold) = rebuild_threshold {
         req.rebuild_threshold = rebuild_threshold;
@@ -209,17 +238,201 @@ pub async fn run(
 
     store
         .subgraph_store()
-        .prune(reporter, &deployment, req)
+        .prune(reporter, &args.deployment, req)
         .await?;
+    Ok(())
+}
+
+async fn run_inner(
+    store: Arc<Store>,
+    primary_pool: ConnectionPool,
+    search: DeploymentSearch,
+    history: usize,
+    rebuild_threshold: Option<f64>,
+    delete_threshold: Option<f64>,
+    once: bool,
+    do_first_prune: bool,
+) -> Result<(), anyhow::Error> {
+    let args = check_args(&store, primary_pool, search, history).await?;
+
+    if do_first_prune {
+        first_prune(&store, &args, rebuild_threshold, delete_threshold).await?;
+    }
 
     // Only after everything worked out, make the history setting permanent
     if !once {
-        store.subgraph_store().set_history_blocks(
-            &deployment,
-            history,
-            ENV_VARS.reorg_threshold,
-        )?;
+        store
+            .subgraph_store()
+            .set_history_blocks(&args.deployment, args.history, ENV_VARS.reorg_threshold())
+            .await?;
     }
 
     Ok(())
 }
+
+pub async fn run(
+    store: Arc<Store>,
+    primary_pool: ConnectionPool,
+    search: DeploymentSearch,
+    history: usize,
+    rebuild_threshold: Option<f64>,
+    delete_threshold: Option<f64>,
+    once: bool,
+) -> Result<(), anyhow::Error> {
+    run_inner(
+        store,
+        primary_pool,
+        search,
+        history,
+        rebuild_threshold,
+        delete_threshold,
+        once,
+        true,
+    )
+    .await
+}
+
+pub async fn set(
+    store: Arc<Store>,
+    primary_pool: ConnectionPool,
+    search: DeploymentSearch,
+    history: usize,
+    rebuild_threshold: Option<f64>,
+    delete_threshold: Option<f64>,
+) -> Result<(), anyhow::Error> {
+    run_inner(
+        store,
+        primary_pool,
+        search,
+        history,
+        rebuild_threshold,
+        delete_threshold,
+        false,
+        false,
+    )
+    .await
+}
+
+pub async fn status(
+    store: Arc<Store>,
+    primary_pool: ConnectionPool,
+    search: DeploymentSearch,
+    run: Option<usize>,
+) -> Result<(), anyhow::Error> {
+    fn percentage(left: Option<i64>, x: Option<i64>, right: Option<i64>) -> String {
+        match (left, x, right) {
+            (Some(left), Some(x), Some(right)) => {
+                let range = right - left;
+                if range == 0 {
+                    return fmt::null();
+                }
+                let percent = (x - left) as f64 / range as f64 * 100.0;
+                format!("{:.0}%", percent.min(100.0))
+            }
+            _ => fmt::null(),
+        }
+    }
+
+    let mut term = Terminal::new();
+
+    let deployment = search.locate_unique(&primary_pool).await?;
+
+    let viewer = store.subgraph_store().prune_viewer(&deployment).await?;
+    let runs = viewer.runs().await?;
+    if runs.is_empty() {
+        return Err(anyhow!("No prune runs found for deployment {deployment}"));
+    }
+    let run = run.unwrap_or(*runs.last().unwrap());
+    let Some((state, table_states)) = viewer.state(run).await? else {
+        let runs = match runs.len() {
+            0 => unreachable!("we checked that runs is not empty"),
+            1 => format!("There is only one prune run #{}", runs[0]),
+            2 => format!("Only prune runs #{} and #{} exist", runs[0], runs[1]),
+            _ => format!(
+                "Only prune runs #{} and #{} up to #{} exist",
+                runs[0],
+                runs[1],
+                runs.last().unwrap()
+            ),
+        };
+        return Err(anyhow!(
+            "No information about prune run #{run} found for deployment {deployment}.\n  {runs}"
+        ));
+    };
+    writeln!(term, "prune {deployment} (run #{run})")?;
+
+    if let (Some(errored_at), Some(error)) = (&state.errored_at, &state.error) {
+        term.with_color(Color::Red, |term| {
+            writeln!(term, "     error: {error}")?;
+            writeln!(term, "        at: {}", fmt::date_time(errored_at))
+        })?;
+    }
+    writeln!(
+        term,
+        "     range: {} - {} ({} blocks, should keep {} blocks)",
+        state.first_block,
+        state.latest_block,
+        state.latest_block - state.first_block,
+        state.history_blocks
+    )?;
+    writeln!(term, "   started: {}", fmt::date_time(&state.started_at))?;
+    match &state.finished_at {
+        Some(finished_at) => writeln!(term, "  finished: {}", fmt::date_time(finished_at))?,
+        None => writeln!(term, "  finished: still running")?,
+    }
+    writeln!(
+        term,
+        "  duration: {}",
+        fmt::duration(&state.started_at, &state.finished_at)
+    )?;
+
+    writeln!(
+        term,
+        "\n{:^30} | {:^22} | {:^8} | {:^11} | {:^8}",
+        "table", "status", "rows", "batch_size", "duration"
+    )?;
+    writeln!(
+        term,
+        "{:-^30}-+-{:-^22}-+-{:-^8}-+-{:-^11}-+-{:-^8}",
+        "", "", "", "", ""
+    )?;
+    for ts in table_states {
+        #[allow(unused_variables)]
+        let PruneTableState {
+            vid: _,
+            id: _,
+            run: _,
+            table_name,
+            strategy,
+            phase,
+            start_vid,
+            final_vid,
+            nonfinal_vid,
+            rows,
+            next_vid,
+            batch_size,
+            started_at,
+            finished_at,
+        } = ts;
+
+        let complete = match phase {
+            Phase::Queued | Phase::Started => "0%".to_string(),
+            Phase::CopyFinal => percentage(start_vid, next_vid, final_vid),
+            Phase::CopyNonfinal | Phase::Delete => percentage(start_vid, next_vid, nonfinal_vid),
+            Phase::Done => fmt::check(),
+            Phase::Unknown => fmt::null(),
+        };
+
+        let table_name = fmt::abbreviate(&table_name, 30);
+        let rows = rows.map_or_null(|rows| rows.to_string());
+        let batch_size = batch_size.map_or_null(|b| b.to_string());
+        let duration = started_at.map_or_null(|s| fmt::duration(s, &finished_at));
+        let phase = phase.as_str();
+        writeln!(
+            term,
+            "{table_name:<30} | {:<15} {complete:>6} | {rows:>8} | {batch_size:>11} | {duration:>8}",
+            format!("{strategy}/{phase}")
+        )?;
+    }
+    Ok(())
+}
diff --git a/node/src/manager/commands/query.rs b/node/src/manager/commands/query.rs
index ff3c5e7952f..57937200839 100644
--- a/node/src/manager/commands/query.rs
+++ b/node/src/manager/commands/query.rs
@@ -1,26 +1,24 @@
 use std::fs::File;
 use std::io::Write;
 use std::iter::FromIterator;
-use std::time::Duration;
 use std::{collections::HashMap, sync::Arc};
 
 use graph::data::query::Trace;
 use graph::log::escape_control_chars;
-use graph::prelude::r;
+use graph::prelude::{q, r};
 use graph::{
     data::query::QueryTarget,
     prelude::{
+        DeploymentHash, GraphQlRunner as _, Query, QueryVariables, SubgraphName,
         anyhow::{self, anyhow},
-        serde_json, DeploymentHash, GraphQlRunner as _, Query, QueryVariables, SubgraphName,
+        serde_json,
     },
 };
 use graph_graphql::prelude::GraphQlRunner;
 use graph_store_postgres::Store;
 
-use crate::manager::PanicSubscriptionManager;
-
 pub async fn run(
-    runner: Arc<GraphQlRunner<Store, PanicSubscriptionManager>>,
+    runner: Arc<GraphQlRunner<Store>>,
     target: String,
     query: String,
     vars: Vec<String>,
@@ -33,11 +31,11 @@ pub async fn run(
         QueryTarget::Deployment(id, Default::default())
     } else {
         let name = SubgraphName::new(target.clone())
-            .map_err(|()| anyhow!("illegal subgraph name `{}`", target))?;
+            .map_err(|name| anyhow!("illegal subgraph name `{name}`"))?;
         QueryTarget::Name(name, Default::default())
     };
 
-    let document = graphql_parser::parse_query(&query)?.into_static();
+    let document = q::parse_query(&query)?.into_static();
     let vars: Vec<(String, r::Value)> = vars
         .into_iter()
         .map(|v| {
@@ -77,53 +75,52 @@ pub async fn run(
     // interesting SQL queries
     if let Some(trace) = trace {
         let mut f = File::create(trace)?;
-        let json = serde_json::to_string(&res.traces())?;
+        let json = serde_json::to_string(&res.trace)?;
         writeln!(f, "{}", json)?;
     }
 
-    for trace in res.traces() {
-        print_brief_trace("root", trace, 0)?;
-    }
+    print_brief_trace("root", &res.trace, 0)?;
+
     Ok(())
 }
 
 fn print_brief_trace(name: &str, trace: &Trace, indent: usize) -> Result<(), anyhow::Error> {
     use Trace::*;
 
-    fn query_time(trace: &Trace) -> Duration {
-        match trace {
-            None => Duration::from_millis(0),
-            Root { children, .. } => children.iter().map(|(_, trace)| query_time(trace)).sum(),
-            Query {
-                elapsed, children, ..
-            } => *elapsed + children.iter().map(|(_, trace)| query_time(trace)).sum(),
-        }
-    }
-
     match trace {
         None => { /* do nothing */ }
         Root {
-            elapsed, children, ..
+            elapsed,
+            setup,
+            blocks: children,
+            ..
         } => {
-            let elapsed = *elapsed.lock().unwrap();
-            let qt = query_time(trace);
-            let pt = elapsed - qt;
+            let elapsed = *elapsed;
+            let qt = trace.query_total();
+            let pt = elapsed - qt.elapsed;
 
             println!(
-                "{space:indent$}{name:rest$} {elapsed:7}ms",
+                "{space:indent$}{name:rest$} {setup:7}ms {elapsed:7}ms",
                 space = " ",
                 indent = indent,
                 rest = 48 - indent,
                 name = name,
+                setup = setup.as_millis(),
                 elapsed = elapsed.as_millis(),
             );
-            for (name, trace) in children {
-                print_brief_trace(name, trace, indent + 2)?;
+            for twc in children {
+                print_brief_trace(name, &twc.trace, indent + 2)?;
             }
-            println!("\nquery:      {:7}ms", qt.as_millis());
+            println!("\nquery:      {:7}ms", qt.elapsed.as_millis());
             println!("other:      {:7}ms", pt.as_millis());
             println!("total:      {:7}ms", elapsed.as_millis())
         }
+        Block { children, .. } => {
+            for (name, trace) in children {
+                print_brief_trace(name, trace, indent + 2)?;
+            }
+        }
+
         Query {
             elapsed,
             entity_count,
diff --git a/node/src/manager/commands/remove.rs b/node/src/manager/commands/remove.rs
index e89c3642215..44a5e888f46 100644
--- a/node/src/manager/commands/remove.rs
+++ b/node/src/manager/commands/remove.rs
@@ -1,13 +1,13 @@
 use std::sync::Arc;
 
-use graph::prelude::{anyhow, Error, SubgraphName, SubgraphStore as _};
+use graph::prelude::{Error, SubgraphName, SubgraphStore as _, anyhow};
 use graph_store_postgres::SubgraphStore;
 
-pub fn run(store: Arc<SubgraphStore>, name: &str) -> Result<(), Error> {
-    let name = SubgraphName::new(name).map_err(|()| anyhow!("illegal subgraph name `{}`", name))?;
+pub async fn run(store: Arc<SubgraphStore>, name: &str) -> Result<(), Error> {
+    let name = SubgraphName::new(name).map_err(|name| anyhow!("illegal subgraph name `{name}`"))?;
 
     println!("Removing subgraph {}", name);
-    store.remove_subgraph(name)?;
+    store.remove_subgraph(name).await?;
 
     Ok(())
 }
diff --git a/node/src/manager/commands/restore.rs b/node/src/manager/commands/restore.rs
new file mode 100644
index 00000000000..432b65a85a1
--- /dev/null
+++ b/node/src/manager/commands/restore.rs
@@ -0,0 +1,235 @@
+use std::sync::Arc;
+use std::time::Instant;
+
+use console::style;
+use graph::components::store::RestoreReporter;
+use graph::env::ENV_VARS;
+use graph::{bail, prelude::anyhow::Result};
+use indicatif::ProgressBar;
+
+use graph::prelude::SubgraphName;
+use graph_store_postgres::{RestoreMode, Shard, SubgraphStore};
+
+struct RestoreProgress {
+    spinner: ProgressBar,
+    start: Instant,
+    phase_start: Instant,
+    table_rows: usize,
+    table_total: usize,
+    deployment: String,
+    namespace: String,
+    shard: String,
+}
+
+impl RestoreProgress {
+    fn new() -> Self {
+        let spinner = ProgressBar::new_spinner();
+        spinner.enable_steady_tick(std::time::Duration::from_millis(80));
+        Self {
+            spinner,
+            start: Instant::now(),
+            phase_start: Instant::now(),
+            table_rows: 0,
+            table_total: 0,
+            deployment: String::new(),
+            namespace: String::new(),
+            shard: String::new(),
+        }
+    }
+}
+
+impl RestoreReporter for RestoreProgress {
+    fn start(&mut self, deployment: &str, table_count: usize) {
+        self.deployment = deployment.to_string();
+        self.start = Instant::now();
+        self.spinner.set_message(format!(
+            "Restoring deployment {} ({} tables)",
+            style(deployment).cyan(),
+            table_count,
+        ));
+    }
+
+    fn start_create_schema(&mut self, namespace: &str, shard: &str) {
+        self.namespace = namespace.to_string();
+        self.shard = shard.to_string();
+        self.phase_start = Instant::now();
+        self.spinner.set_message(format!(
+            "Creating schema for {} in shard {}",
+            namespace, shard
+        ));
+    }
+
+    fn finish_create_schema(&mut self) {
+        let elapsed = self.phase_start.elapsed().as_secs();
+        let line = format!(
+            "  {} {:<32} {:>15} {:>4}s",
+            style("\u{2714}").green(),
+            format!("Schema for {} created", self.namespace),
+            "",
+            elapsed,
+        );
+        self.spinner.suspend(|| println!("{line}"));
+    }
+
+    fn start_table(&mut self, table: &str, total_rows: usize) {
+        self.phase_start = Instant::now();
+        self.table_rows = 0;
+        self.table_total = total_rows;
+        self.spinner
+            .set_message(format!("{:<32} 0/{} rows", table, format_count(total_rows),));
+    }
+
+    fn batch_imported(&mut self, table: &str, rows: usize) {
+        self.table_rows += rows;
+        self.spinner.set_message(format!(
+            "{:<32} {}/{} rows",
+            table,
+            format_count(self.table_rows),
+            format_count(self.table_total),
+        ));
+    }
+
+    fn skip_table(&mut self, table: &str) {
+        let line = format!(
+            "  {} {:<32} {:>15}",
+            style("\u{2714}").green(),
+            table,
+            "skipped",
+        );
+        self.spinner.suspend(|| println!("{line}"));
+    }
+
+    fn finish_table(&mut self, table: &str, rows: usize) {
+        let elapsed = self.phase_start.elapsed().as_secs();
+        let line = format!(
+            "  {} {:<32} {:>10} rows {:>4}s",
+            style("\u{2714}").green(),
+            table,
+            format_count(rows),
+            elapsed,
+        );
+        self.spinner.suspend(|| println!("{line}"));
+    }
+
+    fn start_data_sources(&mut self, total_rows: usize) {
+        self.phase_start = Instant::now();
+        self.table_rows = 0;
+        self.table_total = total_rows;
+        self.spinner.set_message(format!(
+            "data_sources$  0/{} rows",
+            format_count(total_rows)
+        ));
+    }
+
+    fn finish_data_sources(&mut self, rows: usize) {
+        let elapsed = self.phase_start.elapsed().as_secs();
+        let line = format!(
+            "  {} {:<32} {:>10} rows {:>4}s",
+            style("\u{2714}").green(),
+            "data_sources$",
+            format_count(rows),
+            elapsed,
+        );
+        self.spinner.suspend(|| println!("{line}"));
+    }
+
+    fn start_finalize(&mut self) {
+        self.phase_start = Instant::now();
+        self.spinner.set_message("Finalizing".to_string());
+    }
+
+    fn finish_finalize(&mut self) {
+        let elapsed = self.phase_start.elapsed().as_secs();
+        let line = format!(
+            "  {} {:<32} {:>15} {:>4}s",
+            style("\u{2714}").green(),
+            "Finalized",
+            "",
+            elapsed,
+        );
+        self.spinner.suspend(|| println!("{line}"));
+    }
+
+    fn finish(&mut self) {
+        let elapsed = self.start.elapsed().as_secs();
+        self.spinner.finish_with_message(format!(
+            "{} Restore complete ({}s)",
+            style("\u{2714}").green(),
+            elapsed,
+        ));
+    }
+}
+
+fn format_count(n: usize) -> String {
+    if n == 0 {
+        return "0".to_string();
+    }
+    let s = n.to_string();
+    let mut result = String::new();
+    for (i, c) in s.chars().rev().enumerate() {
+        if i > 0 && i % 3 == 0 {
+            result.push(',');
+        }
+        result.push(c);
+    }
+    result.chars().rev().collect()
+}
+
+pub async fn run(
+    subgraph_store: Arc<SubgraphStore>,
+    directory: String,
+    shard: Option<String>,
+    name: Option<String>,
+    replace: bool,
+    add: bool,
+    force: bool,
+) -> Result<()> {
+    if add && shard.is_none() {
+        bail!("--add requires --shard");
+    }
+
+    let directory = std::path::Path::new(&directory).canonicalize()?;
+    let stat = std::fs::metadata(&directory)?;
+
+    if !stat.is_dir() {
+        bail!(
+            "The path `{}` is not a directory",
+            directory.to_string_lossy()
+        );
+    }
+
+    let name = name
+        .map(|n| SubgraphName::new(n.clone()).map_err(|_| anyhow::anyhow!("invalid name `{n}`")))
+        .transpose()?;
+
+    let mode = if replace {
+        RestoreMode::Replace
+    } else if add {
+        RestoreMode::Add
+    } else if force {
+        RestoreMode::Force
+    } else {
+        RestoreMode::Default
+    };
+
+    let shard = shard.map(Shard::new).transpose()?;
+
+    let version_switching_mode = ENV_VARS.subgraph_version_switching_mode;
+
+    let mut reporter = Box::new(RestoreProgress::new());
+    subgraph_store
+        .restore(
+            &directory,
+            shard,
+            name,
+            mode,
+            version_switching_mode,
+            &mut *reporter,
+        )
+        .await?;
+    println!(
+        "Restored {} into {} in shard {}",
+        reporter.deployment, reporter.namespace, reporter.shard
+    );
+    Ok(())
+}
diff --git a/node/src/manager/commands/rewind.rs b/node/src/manager/commands/rewind.rs
index 2ba682296b2..55628c2de3c 100644
--- a/node/src/manager/commands/rewind.rs
+++ b/node/src/manager/commands/rewind.rs
@@ -3,18 +3,20 @@ use std::thread;
 use std::time::Duration;
 use std::{collections::HashSet, convert::TryFrom};
 
+use crate::manager::commands::assign::pause_or_resume;
+use crate::manager::deployment::DeploymentSearch;
 use graph::anyhow::bail;
-use graph::components::store::{BlockStore as _, ChainStore as _};
-use graph::prelude::{anyhow, BlockNumber, BlockPtr, NodeId, SubgraphStore};
-use graph_store_postgres::BlockStore;
-use graph_store_postgres::{connection_pool::ConnectionPool, Store};
-
-use crate::manager::deployment::{Deployment, DeploymentSearch};
+use graph::components::store::{BlockStore as _, ChainStore as _, DeploymentLocator};
+use graph::env::ENV_VARS;
+use graph::prelude::{BlockNumber, BlockPtr, anyhow};
+use graph_store_postgres::command_support::catalog::{self as store_catalog};
+use graph_store_postgres::{BlockStore, NotificationSender};
+use graph_store_postgres::{ConnectionPool, Store};
 
 async fn block_ptr(
-    store: Arc<BlockStore>,
+    store: BlockStore,
+    locators: &HashSet<(String, DeploymentLocator)>,
     searches: &[DeploymentSearch],
-    deployments: &[Deployment],
     hash: &str,
     number: BlockNumber,
     force: bool,
@@ -22,7 +24,11 @@ async fn block_ptr(
     let block_ptr_to = BlockPtr::try_from((hash, number as i64))
         .map_err(|e| anyhow!("error converting to block pointer: {}", e))?;
 
-    let chains = deployments.iter().map(|d| &d.chain).collect::<HashSet<_>>();
+    let chains = locators
+        .iter()
+        .map(|(chain, _)| chain)
+        .collect::<HashSet<_>>();
+
     if chains.len() > 1 {
         let names = searches
             .iter()
@@ -31,12 +37,14 @@ async fn block_ptr(
             .join(", ");
         bail!("the deployments matching `{names}` are on different chains");
     }
-    let chain = chains.iter().next().unwrap();
-    let chain_store = match store.chain_store(chain) {
+
+    let chain = chains.iter().next().unwrap().to_string();
+
+    let chain_store = match store.chain_store(&chain).await {
         None => bail!("can not find chain store for {}", chain),
         Some(store) => store,
     };
-    if let Some((_, number, _)) = chain_store.block_number(&block_ptr_to.hash).await? {
+    if let Some((_, number, _, _)) = chain_store.block_number(&block_ptr_to.hash).await? {
         if number != block_ptr_to.number {
             bail!(
                 "the given hash is for block number {} but the command specified block number {}",
@@ -61,29 +69,42 @@ pub async fn run(
     searches: Vec<DeploymentSearch>,
     block_hash: Option<String>,
     block_number: Option<BlockNumber>,
+    sender: &NotificationSender,
     force: bool,
     sleep: Duration,
     start_block: bool,
 ) -> Result<(), anyhow::Error> {
-    const PAUSED: &str = "paused_";
-
     // Sanity check
     if !start_block && (block_hash.is_none() || block_number.is_none()) {
         bail!("--block-hash and --block-number must be specified when --start-block is not set");
     }
+    let pconn = primary.get_permitted().await?;
+    let mut conn = store_catalog::Connection::new(pconn);
 
     let subgraph_store = store.subgraph_store();
     let block_store = store.block_store();
 
-    let deployments = searches
-        .iter()
-        .map(|search| search.lookup(&primary))
-        .collect::<Result<Vec<_>, _>>()?
-        .into_iter()
-        .flatten()
-        .collect::<Vec<_>>();
-    if deployments.is_empty() {
-        println!("nothing to do");
+    let mut locators = HashSet::new();
+
+    for search in &searches {
+        let results = search.lookup(&primary).await?;
+
+        let deployment_locators: HashSet<(String, DeploymentLocator)> = results
+            .iter()
+            .map(|deployment| (deployment.chain.clone(), deployment.locator()))
+            .collect();
+
+        if deployment_locators.len() > 1 {
+            bail!(
+                "Multiple deployments found for the search : {}. Try using the id of the deployment (eg: sgd143) to uniquely identify the deployment.",
+                search
+            );
+        }
+        locators.extend(deployment_locators);
+    }
+
+    if locators.is_empty() {
+        println!("No deployments found");
         return Ok(());
     }
 
@@ -93,8 +114,8 @@ pub async fn run(
         Some(
             block_ptr(
                 block_store,
+                &locators,
                 &searches,
-                &deployments,
                 block_hash.as_deref().unwrap_or_default(),
                 block_number.unwrap_or_default(),
                 force,
@@ -103,51 +124,65 @@ pub async fn run(
         )
     };
 
-    println!("Pausing deployments");
-    let mut paused = false;
-    for deployment in &deployments {
-        if let Some(node) = &deployment.node_id {
-            if !node.starts_with(PAUSED) {
-                let loc = deployment.locator();
-                let node =
-                    NodeId::new(format!("{}{}", PAUSED, node)).expect("paused_ node id is valid");
-                subgraph_store.reassign_subgraph(&loc, &node)?;
-                println!("  ... paused {}", loc);
-                paused = true;
-            }
+    println!("Checking if its safe to rewind deployments");
+    for (_, locator) in &locators {
+        let site = conn
+            .locate_site(locator.clone())
+            .await?
+            .ok_or_else(|| anyhow!("failed to locate site for {locator}"))?;
+        let deployment_store = subgraph_store.for_site(&site)?;
+        let deployment_details = deployment_store.deployment_details_for_id(locator).await?;
+        let block_number_to = block_ptr_to.as_ref().map(|b| b.number).unwrap_or(0);
+
+        if block_number_to < deployment_details.earliest_block_number + ENV_VARS.reorg_threshold() {
+            bail!(
+                "The block number {} is not safe to rewind to for deployment {}. The earliest block number of this deployment is {}. You can only safely rewind to block number {}",
+                block_ptr_to.as_ref().map(|b| b.number).unwrap_or(0),
+                locator,
+                deployment_details.earliest_block_number,
+                deployment_details.earliest_block_number + ENV_VARS.reorg_threshold()
+            );
         }
     }
 
-    if paused {
-        // There's no good way to tell that a subgraph has in fact stopped
-        // indexing. We sleep and hope for the best.
-        println!(
-            "\nWaiting {}s to make sure pausing was processed",
-            sleep.as_secs()
-        );
-        thread::sleep(sleep);
+    println!("Pausing deployments");
+    for (_, locator) in &locators {
+        pause_or_resume(primary.clone(), sender, locator, true).await?;
     }
 
+    // There's no good way to tell that a subgraph has in fact stopped
+    // indexing. We sleep and hope for the best.
+    println!(
+        "\nWaiting {}s to make sure pausing was processed",
+        sleep.as_secs()
+    );
+    thread::sleep(sleep);
+
     println!("\nRewinding deployments");
-    for deployment in &deployments {
-        let loc = deployment.locator();
+    for (chain, loc) in &locators {
         let block_store = store.block_store();
-        let deployment_details = subgraph_store.load_deployment_by_id(loc.clone().into())?;
+        let deployment_details = subgraph_store
+            .load_deployment_by_id(loc.clone().into())
+            .await?;
         let block_ptr_to = block_ptr_to.clone();
 
-        let start_block = deployment_details.start_block.or_else(|| {
-            block_store
-                .chain_store(&deployment.chain)
-                .and_then(|chain_store| chain_store.genesis_block_ptr().ok())
-        });
+        let start_block = match deployment_details.start_block {
+            Some(ptr) => Some(ptr),
+            None => match block_store.chain_store(chain).await {
+                Some(chain_store) => chain_store.genesis_block_ptr().await.ok(),
+                None => None,
+            },
+        };
 
         match (block_ptr_to, start_block) {
             (Some(block_ptr), _) => {
-                subgraph_store.rewind(loc.hash.clone(), block_ptr)?;
+                subgraph_store.rewind(loc.id.into(), block_ptr).await?;
                 println!("  ... rewound {}", loc);
             }
             (None, Some(start_block_ptr)) => {
-                subgraph_store.truncate(loc.hash.clone(), start_block_ptr)?;
+                subgraph_store
+                    .truncate(loc.id.into(), start_block_ptr)
+                    .await?;
                 println!("  ... truncated {}", loc);
             }
             (None, None) => {
@@ -157,12 +192,8 @@ pub async fn run(
     }
 
     println!("Resuming deployments");
-    for deployment in &deployments {
-        if let Some(node) = &deployment.node_id {
-            let loc = deployment.locator();
-            let node = NodeId::new(node.clone()).expect("node id is valid");
-            subgraph_store.reassign_subgraph(&loc, &node)?;
-        }
+    for (_, locator) in &locators {
+        pause_or_resume(primary.clone(), sender, locator, false).await?;
     }
     Ok(())
 }
diff --git a/node/src/manager/commands/run.rs b/node/src/manager/commands/run.rs
index a558139e84c..bbe9e1faf18 100644
--- a/node/src/manager/commands/run.rs
+++ b/node/src/manager/commands/run.rs
@@ -2,41 +2,31 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
 
-use crate::chain::{
-    connect_ethereum_networks, create_ethereum_networks_for_chain, create_firehose_networks,
-    create_ipfs_clients,
-};
+use crate::MetricsContext;
 use crate::config::Config;
 use crate::manager::PanicSubscriptionManager;
+use crate::network_setup::Networks;
 use crate::store_builder::StoreBuilder;
-use crate::MetricsContext;
-use ethereum::chain::{EthereumAdapterSelector, EthereumBlockRefetcher, EthereumStreamBuilder};
-use ethereum::{ProviderEthRpcMetrics, RuntimeAdapter as EthereumRuntimeAdapter};
-use graph::anyhow::{bail, format_err};
-use graph::blockchain::client::ChainClient;
-use graph::blockchain::{BlockchainKind, BlockchainMap};
+use graph::amp;
+use graph::anyhow::bail;
 use graph::cheap_clone::CheapClone;
 use graph::components::link_resolver::{ArweaveClient, FileSizeLimit};
-use graph::components::store::{BlockStore as _, DeploymentLocator};
-use graph::components::subgraph::Settings;
+use graph::components::network_provider::chain_id_validator;
+use graph::components::store::DeploymentLocator;
+use graph::components::subgraph::{Settings, SubgraphInstanceManager as _};
 use graph::endpoint::EndpointMetrics;
 use graph::env::EnvVars;
-use graph::firehose::FirehoseEndpoints;
 use graph::prelude::{
-    anyhow, tokio, BlockNumber, DeploymentHash, LoggerFactory, NodeId, SubgraphAssignmentProvider,
+    BlockNumber, DeploymentHash, ENV_VARS, IpfsResolver, LoggerFactory, NodeId,
     SubgraphCountMetric, SubgraphName, SubgraphRegistrar, SubgraphStore,
-    SubgraphVersionSwitchingMode, ENV_VARS,
+    SubgraphVersionSwitchingMode, anyhow, tokio,
 };
-use graph::slog::{debug, info, Logger};
-use graph_chain_ethereum as ethereum;
+use graph::slog::{Logger, debug, info};
 use graph_core::polling_monitor::{arweave_service, ipfs_service};
-use graph_core::{
-    LinkResolver, SubgraphAssignmentProvider as IpfsSubgraphAssignmentProvider,
-    SubgraphInstanceManager, SubgraphRegistrar as IpfsSubgraphRegistrar,
-};
+use tokio_util::sync::CancellationToken;
 
-fn locate(store: &dyn SubgraphStore, hash: &str) -> Result<DeploymentLocator, anyhow::Error> {
-    let mut locators = store.locators(hash)?;
+async fn locate(store: &dyn SubgraphStore, hash: &str) -> Result<DeploymentLocator, anyhow::Error> {
+    let mut locators = store.locators(hash).await?;
     match locators.len() {
         0 => bail!("could not find subgraph {hash} we just created"),
         1 => Ok(locators.pop().unwrap()),
@@ -47,9 +37,10 @@ fn locate(store: &dyn SubgraphStore, hash: &str) -> Result<DeploymentLocator, an
 pub async fn run(
     logger: Logger,
     store_builder: StoreBuilder,
-    network_name: String,
+    _network_name: String,
     ipfs_url: Vec<String>,
     arweave_url: String,
+    amp_flight_service_address: Option<String>,
     config: Config,
     metrics_ctx: MetricsContext,
     node_id: NodeId,
@@ -61,26 +52,27 @@ pub async fn run(
         subgraph, stop_block
     );
 
+    let cancel_token = CancellationToken::new();
     let env_vars = Arc::new(EnvVars::from_env().unwrap());
     let metrics_registry = metrics_ctx.registry.clone();
     let logger_factory = LoggerFactory::new(logger.clone(), None, metrics_ctx.registry.clone());
 
     // FIXME: Hard-coded IPFS config, take it from config file instead?
-    let ipfs_clients: Vec<_> = create_ipfs_clients(&logger, &ipfs_url);
-    let ipfs_client = ipfs_clients.first().cloned().expect("Missing IPFS client");
+    let ipfs_client = graph::ipfs::new_ipfs_client(&ipfs_url, &metrics_registry, &logger).await?;
+
     let ipfs_service = ipfs_service(
-        ipfs_client,
-        env_vars.mappings.max_ipfs_file_bytes as u64,
+        ipfs_client.cheap_clone(),
+        env_vars.mappings.max_ipfs_file_bytes,
         env_vars.mappings.ipfs_timeout,
         env_vars.mappings.ipfs_request_limit,
     );
+
     let arweave_resolver = Arc::new(ArweaveClient::new(
         logger.cheap_clone(),
         arweave_url.parse().expect("invalid arweave url"),
     ));
     let arweave_service = arweave_service(
         arweave_resolver.cheap_clone(),
-        env_vars.mappings.ipfs_timeout,
         env_vars.mappings.ipfs_request_limit,
         match env_vars.mappings.max_ipfs_file_bytes {
             0 => FileSizeLimit::Unlimited,
@@ -96,95 +88,98 @@ pub async fn run(
 
     // Convert the clients into a link resolver. Since we want to get past
     // possible temporary DNS failures, make the resolver retry
-    let link_resolver = Arc::new(LinkResolver::new(ipfs_clients, env_vars.cheap_clone()));
+    let link_resolver = Arc::new(IpfsResolver::new(ipfs_client, env_vars.cheap_clone()));
 
-    let eth_rpc_metrics = Arc::new(ProviderEthRpcMetrics::new(metrics_registry.clone()));
-    let eth_networks = create_ethereum_networks_for_chain(
-        &logger,
-        eth_rpc_metrics,
-        &config,
-        &network_name,
-        endpoint_metrics.cheap_clone(),
-    )
-    .await
-    .expect("Failed to parse Ethereum networks");
-    let firehose_networks_by_kind =
-        create_firehose_networks(logger.clone(), &config, endpoint_metrics);
-    let firehose_networks = firehose_networks_by_kind.get(&BlockchainKind::Ethereum);
-    let firehose_endpoints = firehose_networks
-        .and_then(|v| v.networks.get(&network_name))
-        .map_or_else(FirehoseEndpoints::new, |v| v.clone());
-
-    let eth_adapters = match eth_networks.networks.get(&network_name) {
-        Some(adapters) => adapters.clone(),
-        None => {
-            return Err(format_err!(
-                "No ethereum adapters found, but required in this state of graphman run command"
-            ))
-        }
-    };
+    let chain_head_update_listener = store_builder.chain_head_update_listener();
+    let network_store = store_builder.network_store(config.chain_ids()).await;
+    let block_store = network_store.block_store();
 
-    let eth_adapters2 = eth_adapters.clone();
+    let mut provider_checks: Vec<Arc<dyn graph::components::network_provider::ProviderCheck>> =
+        Vec::new();
 
-    let (_, ethereum_idents) = connect_ethereum_networks(&logger, eth_networks).await?;
-    // let (near_networks, near_idents) = connect_firehose_networks::<NearFirehoseHeaderOnlyBlock>(
-    //     &logger,
-    //     firehose_networks_by_kind
-    //         .remove(&BlockchainKind::Near)
-    //         .unwrap_or_else(|| FirehoseNetworks::new()),
-    // )
-    // .await;
+    if env_vars.genesis_validation_enabled {
+        let store = chain_id_validator(Box::new(network_store.block_store()));
+        provider_checks.push(Arc::new(
+            graph::components::network_provider::GenesisHashCheck::new(store),
+        ));
+    }
 
-    let chain_head_update_listener = store_builder.chain_head_update_listener();
-    let network_identifiers = ethereum_idents.into_iter().collect();
-    let network_store = store_builder.network_store(network_identifiers);
+    provider_checks.push(Arc::new(
+        graph::components::network_provider::ExtendedBlocksCheck::new(
+            env_vars
+                .firehose_disable_extended_blocks_for_chains
+                .iter()
+                .map(|x| x.as_str().into()),
+        ),
+    ));
 
-    let subgraph_store = network_store.subgraph_store();
-    let chain_store = network_store
-        .block_store()
-        .chain_store(network_name.as_ref())
-        .unwrap_or_else(|| panic!("No chain store for {}", &network_name));
+    let networks = Networks::from_config(
+        logger.cheap_clone(),
+        &config,
+        metrics_registry.cheap_clone(),
+        endpoint_metrics,
+        &provider_checks,
+    )
+    .await
+    .expect("unable to parse network configuration");
 
-    let client = Arc::new(ChainClient::new(firehose_endpoints, eth_adapters));
+    let subgraph_store = network_store.subgraph_store();
 
-    let chain_config = config.chains.chains.get(&network_name).unwrap();
-    let chain = ethereum::Chain::new(
-        logger_factory.clone(),
-        network_name.clone(),
-        node_id.clone(),
-        metrics_registry.clone(),
-        chain_store.cheap_clone(),
-        chain_store.cheap_clone(),
-        client.clone(),
-        chain_head_update_listener,
-        Arc::new(EthereumStreamBuilder {}),
-        Arc::new(EthereumBlockRefetcher {}),
-        Arc::new(EthereumAdapterSelector::new(
-            logger_factory.clone(),
-            client,
-            metrics_registry.clone(),
-            chain_store.cheap_clone(),
-        )),
-        Arc::new(EthereumRuntimeAdapter {
-            call_cache: chain_store.cheap_clone(),
-            eth_adapters: Arc::new(eth_adapters2),
-            chain_identifier: Arc::new(chain_store.chain_identifier.clone()),
-        }),
-        graph::env::ENV_VARS.reorg_threshold,
-        chain_config.polling_interval,
-        // We assume the tested chain is always ingestible for now
-        true,
+    let blockchain_map = Arc::new(
+        networks
+            .blockchain_map(
+                &env_vars,
+                &logger,
+                block_store,
+                &logger_factory,
+                metrics_registry.cheap_clone(),
+                chain_head_update_listener,
+            )
+            .await,
     );
 
-    let mut blockchain_map = BlockchainMap::new();
-    blockchain_map.insert(network_name.clone(), Arc::new(chain));
-
     let static_filters = ENV_VARS.experimental_static_filters;
-
     let sg_metrics = Arc::new(SubgraphCountMetric::new(metrics_registry.clone()));
 
-    let blockchain_map = Arc::new(blockchain_map);
-    let subgraph_instance_manager = SubgraphInstanceManager::new(
+    let mut subgraph_instance_managers =
+        graph_core::subgraph_provider::SubgraphInstanceManagers::new();
+
+    let amp_client = match amp_flight_service_address {
+        Some(amp_flight_service_address) => {
+            let addr = amp_flight_service_address
+                .parse()
+                .expect("Invalid Amp Flight service address");
+
+            let mut amp_client = amp::FlightClient::new(addr)
+                .await
+                .expect("Failed to connect to Amp Flight service");
+
+            if let Some(auth_token) = &env_vars.amp.flight_service_token {
+                amp_client.set_auth_token(auth_token);
+            }
+
+            let amp_client = Arc::new(amp_client);
+            let amp_instance_manager = graph_core::amp_subgraph::Manager::new(
+                &logger_factory,
+                metrics_registry.cheap_clone(),
+                env_vars.cheap_clone(),
+                &cancel_token,
+                network_store.subgraph_store(),
+                link_resolver.cheap_clone(),
+                amp_client.cheap_clone(),
+            );
+
+            subgraph_instance_managers.add(
+                graph_core::subgraph_provider::SubgraphProcessingKind::Amp,
+                Arc::new(amp_instance_manager),
+            );
+
+            Some(amp_client)
+        }
+        None => None,
+    };
+
+    let subgraph_instance_manager = graph_core::subgraph::SubgraphInstanceManager::new(
         &logger_factory,
         env_vars.cheap_clone(),
         subgraph_store.clone(),
@@ -194,29 +189,39 @@ pub async fn run(
         link_resolver.cheap_clone(),
         ipfs_service,
         arweave_service,
+        amp_client.cheap_clone(),
         static_filters,
     );
 
-    // Create IPFS-based subgraph provider
-    let subgraph_provider = Arc::new(IpfsSubgraphAssignmentProvider::new(
+    subgraph_instance_managers.add(
+        graph_core::subgraph_provider::SubgraphProcessingKind::Trigger,
+        Arc::new(subgraph_instance_manager),
+    );
+
+    let subgraph_provider = Arc::new(graph_core::subgraph_provider::SubgraphProvider::new(
         &logger_factory,
+        sg_metrics.cheap_clone(),
+        subgraph_store.clone(),
         link_resolver.cheap_clone(),
-        subgraph_instance_manager,
-        sg_metrics,
+        cancel_token.clone(),
+        subgraph_instance_managers,
     ));
 
     let panicking_subscription_manager = Arc::new(PanicSubscriptionManager {});
 
-    let subgraph_registrar = Arc::new(IpfsSubgraphRegistrar::new(
+    let amp_chain_names = Arc::new(config.amp_chain_names());
+    let subgraph_registrar = Arc::new(graph_core::subgraph::SubgraphRegistrar::new(
         &logger_factory,
         link_resolver.cheap_clone(),
-        subgraph_provider.clone(),
+        subgraph_provider.cheap_clone(),
         subgraph_store.clone(),
         panicking_subscription_manager,
+        amp_client,
         blockchain_map,
         node_id.clone(),
         SubgraphVersionSwitchingMode::Instant,
         Arc::new(Settings::default()),
+        amp_chain_names,
     ));
 
     let (name, hash) = if subgraph.contains(':') {
@@ -253,13 +258,15 @@ pub async fn run(
         None,
         None,
         None,
+        false,
     )
     .await?;
 
-    let locator = locate(subgraph_store.as_ref(), &hash)?;
+    let locator = locate(subgraph_store.as_ref(), &hash).await?;
 
-    SubgraphAssignmentProvider::start(subgraph_provider.as_ref(), locator, Some(stop_block))
-        .await?;
+    subgraph_provider
+        .start_subgraph(locator, Some(stop_block))
+        .await;
 
     loop {
         tokio::time::sleep(Duration::from_millis(1000)).await;
@@ -282,7 +289,10 @@ pub async fn run(
     }
 
     info!(&logger, "Removing subgraph {}", name);
-    subgraph_store.clone().remove_subgraph(subgraph_name)?;
+    subgraph_store
+        .clone()
+        .remove_subgraph(subgraph_name)
+        .await?;
 
     if let Some(host) = metrics_ctx.prometheus_host {
         let mfs = metrics_ctx.prometheus.gather();
diff --git a/node/src/manager/commands/stats.rs b/node/src/manager/commands/stats.rs
index c7f768c436b..bbb219bf11c 100644
--- a/node/src/manager/commands/stats.rs
+++ b/node/src/manager/commands/stats.rs
@@ -3,34 +3,36 @@ use std::collections::HashSet;
 use std::sync::Arc;
 
 use crate::manager::deployment::DeploymentSearch;
-use diesel::r2d2::ConnectionManager;
-use diesel::r2d2::PooledConnection;
-use diesel::PgConnection;
+use crate::manager::fmt;
 use graph::components::store::DeploymentLocator;
 use graph::components::store::VersionStats;
+use graph::prelude::CheapClone as _;
 use graph::prelude::anyhow;
-use graph_store_postgres::command_support::catalog as store_catalog;
-use graph_store_postgres::command_support::catalog::Site;
-use graph_store_postgres::connection_pool::ConnectionPool;
+use graph_store_postgres::AsyncPgConnection;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::PRIMARY_SHARD;
 use graph_store_postgres::Shard;
 use graph_store_postgres::SubgraphStore;
-use graph_store_postgres::PRIMARY_SHARD;
+use graph_store_postgres::command_support::catalog as store_catalog;
+use graph_store_postgres::command_support::catalog::Site;
 
-fn site_and_conn(
+async fn site_and_conn(
     pools: HashMap<Shard, ConnectionPool>,
     search: &DeploymentSearch,
-) -> Result<(Site, PooledConnection<ConnectionManager<PgConnection>>), anyhow::Error> {
+) -> Result<(Arc<Site>, AsyncPgConnection), anyhow::Error> {
     let primary_pool = pools.get(&*PRIMARY_SHARD).unwrap();
-    let locator = search.locate_unique(primary_pool)?;
+    let locator = search.locate_unique(primary_pool).await?;
 
-    let conn = primary_pool.get()?;
-    let conn = store_catalog::Connection::new(conn);
+    let pconn = primary_pool.get_permitted().await?;
+    let mut conn = store_catalog::Connection::new(pconn);
 
     let site = conn
-        .locate_site(locator)?
+        .locate_site(locator)
+        .await?
         .ok_or_else(|| anyhow!("deployment `{}` does not exist", search))?;
+    let site = Arc::new(site);
 
-    let conn = pools.get(&site.shard).unwrap().get()?;
+    let conn = pools.get(&site.shard).unwrap().get().await?;
 
     Ok((site, conn))
 }
@@ -42,7 +44,7 @@ pub async fn account_like(
     search: &DeploymentSearch,
     table: String,
 ) -> Result<(), anyhow::Error> {
-    let locator = search.locate_unique(&primary_pool)?;
+    let locator = search.locate_unique(&primary_pool).await?;
 
     store.set_account_like(&locator, &table, !clear).await?;
     let clear_text = if clear { "cleared" } else { "set" };
@@ -51,19 +53,6 @@ pub async fn account_like(
     Ok(())
 }
 
-pub fn abbreviate_table_name(table: &str, size: usize) -> String {
-    if table.len() > size {
-        let fragment = size / 2 - 2;
-        let last = table.len() - fragment;
-        let mut table = table.to_string();
-        table.replace_range(fragment..last, "..");
-        let table = table.trim().to_string();
-        table
-    } else {
-        table.to_string()
-    }
-}
-
 pub fn show_stats(
     stats: &[VersionStats],
     account_like: HashSet<String>,
@@ -83,7 +72,7 @@ pub fn show_stats(
     fn print_stats(s: &VersionStats, account_like: bool) {
         println!(
             "{:<26} {:3} | {:>10} | {:>10} | {:>5.1}%",
-            abbreviate_table_name(&s.tablename, 26),
+            fmt::abbreviate(&s.tablename, 26),
             if account_like { "(a)" } else { "   " },
             s.entities,
             s.versions,
@@ -102,30 +91,32 @@ pub fn show_stats(
     Ok(())
 }
 
-pub fn show(
+pub async fn show(
     pools: HashMap<Shard, ConnectionPool>,
     search: &DeploymentSearch,
 ) -> Result<(), anyhow::Error> {
-    let (site, conn) = site_and_conn(pools, search)?;
+    let (site, mut conn) = site_and_conn(pools, search).await?;
 
-    let stats = store_catalog::stats(&conn, &site)?;
+    let catalog =
+        store_catalog::Catalog::load(&mut conn, site.cheap_clone(), false, vec![]).await?;
+    let stats = catalog.stats(&mut conn).await?;
 
-    let account_like = store_catalog::account_like(&conn, &site)?;
+    let account_like = store_catalog::account_like(&mut conn, &site).await?;
 
     show_stats(stats.as_slice(), account_like)
 }
 
-pub fn analyze(
+pub async fn analyze(
     store: Arc<SubgraphStore>,
     pool: ConnectionPool,
     search: DeploymentSearch,
     entity_name: Option<&str>,
 ) -> Result<(), anyhow::Error> {
-    let locator = search.locate_unique(&pool)?;
-    analyze_loc(store, &locator, entity_name)
+    let locator = search.locate_unique(&pool).await?;
+    analyze_loc(store, &locator, entity_name).await
 }
 
-fn analyze_loc(
+async fn analyze_loc(
     store: Arc<SubgraphStore>,
     locator: &DeploymentLocator,
     entity_name: Option<&str>,
@@ -134,16 +125,19 @@ fn analyze_loc(
         Some(entity_name) => println!("Analyzing table sgd{}.{entity_name}", locator.id),
         None => println!("Analyzing all tables for sgd{}", locator.id),
     }
-    store.analyze(locator, entity_name).map_err(|e| anyhow!(e))
+    store
+        .analyze(locator, entity_name)
+        .await
+        .map_err(|e| anyhow!(e))
 }
 
-pub fn target(
+pub async fn target(
     store: Arc<SubgraphStore>,
     primary: ConnectionPool,
     search: &DeploymentSearch,
 ) -> Result<(), anyhow::Error> {
-    let locator = search.locate_unique(&primary)?;
-    let (default, targets) = store.stats_targets(&locator)?;
+    let locator = search.locate_unique(&primary).await?;
+    let (default, targets) = store.stats_targets(&locator).await?;
 
     let has_targets = targets
         .values()
@@ -175,7 +169,7 @@ pub fn target(
     Ok(())
 }
 
-pub fn set_target(
+pub async fn set_target(
     store: Arc<SubgraphStore>,
     primary: ConnectionPool,
     search: &DeploymentSearch,
@@ -190,12 +184,14 @@ pub fn set_target(
         columns
     };
 
-    let locator = search.locate_unique(&primary)?;
+    let locator = search.locate_unique(&primary).await?;
 
-    store.set_stats_target(&locator, entity, columns, target)?;
+    store
+        .set_stats_target(&locator, entity, columns, target)
+        .await?;
 
     if !no_analyze {
-        analyze_loc(store, &locator, entity)?;
+        analyze_loc(store, &locator, entity).await?;
     }
     Ok(())
 }
diff --git a/node/src/manager/commands/txn_speed.rs b/node/src/manager/commands/txn_speed.rs
index 024ad6427ce..766904cbe6b 100644
--- a/node/src/manager/commands/txn_speed.rs
+++ b/node/src/manager/commands/txn_speed.rs
@@ -1,27 +1,28 @@
-use diesel::PgConnection;
 use std::{collections::HashMap, thread::sleep, time::Duration};
 
+use diesel::dsl::sql;
 use graph::prelude::anyhow;
-use graph_store_postgres::connection_pool::ConnectionPool;
+use graph_store_postgres::{AsyncPgConnection, ConnectionPool};
 
 use crate::manager::catalog;
 
-pub fn run(pool: ConnectionPool, delay: u64) -> Result<(), anyhow::Error> {
-    fn query(conn: &PgConnection) -> Result<Vec<(String, i64, i64)>, anyhow::Error> {
+pub async fn run(pool: ConnectionPool, delay: u64) -> Result<(), anyhow::Error> {
+    async fn query(conn: &mut AsyncPgConnection) -> Result<Vec<(String, i64, i64)>, anyhow::Error> {
         use catalog::pg_catalog::pg_stat_database as d;
-        use diesel::dsl::*;
         use diesel::sql_types::BigInt;
-        use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl};
+        use diesel::{ExpressionMethods, QueryDsl};
+        use diesel_async::RunQueryDsl;
 
         let rows = d::table
-            .filter(d::datname.eq(any(vec!["explorer", "graph"])))
+            .filter(d::datname.eq_any(vec!["explorer", "graph"]))
             .select((
                 d::datname,
                 sql::<BigInt>("(xact_commit + xact_rollback)::bigint"),
                 sql::<BigInt>("txid_current()::bigint"),
             ))
             //.select((d::datname))
-            .load::<(Option<String>, i64, i64)>(conn)?;
+            .load::<(Option<String>, i64, i64)>(conn)
+            .await?;
         Ok(rows
             .into_iter()
             .map(|(datname, all_txn, write_txn)| {
@@ -31,8 +32,8 @@ pub fn run(pool: ConnectionPool, delay: u64) -> Result<(), anyhow::Error> {
     }
 
     let mut speeds = HashMap::new();
-    let conn = pool.get()?;
-    for (datname, all_txn, write_txn) in query(&conn)? {
+    let mut conn = pool.get().await?;
+    for (datname, all_txn, write_txn) in query(&mut conn).await? {
         speeds.insert(datname, (all_txn, write_txn));
     }
     println!(
@@ -42,7 +43,7 @@ pub fn run(pool: ConnectionPool, delay: u64) -> Result<(), anyhow::Error> {
     sleep(Duration::from_secs(delay));
     println!("Number of transactions/minute");
     println!("{:10} {:>7} write", "database", "all");
-    for (datname, all_txn, write_txn) in query(&conn)? {
+    for (datname, all_txn, write_txn) in query(&mut conn).await? {
         let (all_speed, write_speed) = speeds
             .get(&datname)
             .map(|(all_txn_old, write_txn_old)| {
diff --git a/node/src/manager/commands/unused_deployments.rs b/node/src/manager/commands/unused_deployments.rs
index 2bd4f9fc5db..c14f7662d7a 100644
--- a/node/src/manager/commands/unused_deployments.rs
+++ b/node/src/manager/commands/unused_deployments.rs
@@ -1,9 +1,9 @@
 use std::{sync::Arc, time::Instant};
 
 use graph::prelude::{anyhow::Error, chrono};
-use graph_store_postgres::{unused, SubgraphStore, UnusedDeployment};
+use graph_store_postgres::{SubgraphStore, UnusedDeployment, unused};
 
-use crate::manager::display::List;
+use crate::manager::{deployment::DeploymentSearch, display::List};
 
 fn make_list() -> List {
     List::new(vec!["id", "shard", "namespace", "subgraphs", "entities"])
@@ -29,16 +29,22 @@ fn add_row(list: &mut List, deployment: UnusedDeployment) {
     ])
 }
 
-pub fn list(store: Arc<SubgraphStore>, existing: bool) -> Result<(), Error> {
+pub async fn list(
+    store: Arc<SubgraphStore>,
+    existing: bool,
+    deployment: Option<DeploymentSearch>,
+) -> Result<(), Error> {
     let mut list = make_list();
 
-    let filter = if existing {
-        unused::Filter::New
-    } else {
-        unused::Filter::All
+    let filter = match deployment {
+        Some(deployment) => deployment.to_unused_filter(existing),
+        None => match existing {
+            true => unused::Filter::New,
+            false => unused::Filter::All,
+        },
     };
 
-    for deployment in store.list_unused_deployments(filter)? {
+    for deployment in store.list_unused_deployments(filter).await? {
         add_row(&mut list, deployment);
     }
 
@@ -51,14 +57,14 @@ pub fn list(store: Arc<SubgraphStore>, existing: bool) -> Result<(), Error> {
     Ok(())
 }
 
-pub fn record(store: Arc<SubgraphStore>) -> Result<(), Error> {
+pub async fn record(store: Arc<SubgraphStore>) -> Result<(), Error> {
     let mut list = make_list();
 
     println!("Recording unused deployments. This might take a while.");
-    let recorded = store.record_unused_deployments()?;
+    let recorded = store.record_unused_deployments().await?;
 
-    for unused in store.list_unused_deployments(unused::Filter::New)? {
-        if recorded.iter().any(|r| r.deployment == unused.deployment) {
+    for unused in store.list_unused_deployments(unused::Filter::New).await? {
+        if recorded.iter().any(|r| r.subgraph == unused.deployment) {
             add_row(&mut list, unused);
         }
     }
@@ -69,7 +75,7 @@ pub fn record(store: Arc<SubgraphStore>) -> Result<(), Error> {
     Ok(())
 }
 
-pub fn remove(
+pub async fn remove(
     store: Arc<SubgraphStore>,
     count: usize,
     deployment: Option<&str>,
@@ -79,7 +85,7 @@ pub fn remove(
         Some(duration) => unused::Filter::UnusedLongerThan(duration),
         None => unused::Filter::New,
     };
-    let unused = store.list_unused_deployments(filter)?;
+    let unused = store.list_unused_deployments(filter).await?;
     let unused = match &deployment {
         None => unused,
         Some(deployment) => unused
@@ -117,7 +123,7 @@ pub fn remove(
         }
 
         let start = Instant::now();
-        match store.remove_deployment(deployment.id) {
+        match store.remove_deployment(deployment.id).await {
             Ok(()) => {
                 println!(
                     "done removing {} from {} in {:.1}s\n",
diff --git a/node/src/manager/deployment.rs b/node/src/manager/deployment.rs
index 41173b67608..4dd31fbbec0 100644
--- a/node/src/manager/deployment.rs
+++ b/node/src/manager/deployment.rs
@@ -2,32 +2,34 @@ use std::collections::HashSet;
 use std::fmt;
 use std::str::FromStr;
 
-use diesel::{dsl::sql, prelude::*};
-use diesel::{sql_types::Text, PgConnection};
+use diesel::dsl::sql;
+use diesel::sql_types::Text;
+use diesel::{
+    ExpressionMethods, JoinOnDsl, NullableExpressionMethods, PgTextExpressionMethods, QueryDsl,
+};
+use diesel_async::RunQueryDsl;
 
 use graph::components::store::DeploymentId;
 use graph::{
     components::store::DeploymentLocator,
-    data::subgraph::status,
-    prelude::{anyhow, lazy_static, regex::Regex, DeploymentHash},
+    prelude::{DeploymentHash, anyhow, lazy_static, regex::Regex},
 };
 use graph_store_postgres::command_support::catalog as store_catalog;
-use graph_store_postgres::connection_pool::ConnectionPool;
-
-use crate::manager::display::List;
+use graph_store_postgres::unused;
+use graph_store_postgres::{AsyncPgConnection, ConnectionPool};
 
 lazy_static! {
     // `Qm...` optionally follow by `:$shard`
     static ref HASH_RE: Regex = Regex::new("\\A(?P<hash>Qm[^:]+)(:(?P<shard>[a-z0-9_]+))?\\z").unwrap();
     // `sgdNNN`
-    static ref DEPLOYMENT_RE: Regex = Regex::new("\\A(?P<nsp>sgd[0-9]+)\\z").unwrap();
+    static ref DEPLOYMENT_RE: Regex = Regex::new("\\A(?P<nsp>(sgd)?[0-9]+)\\z").unwrap();
 }
 
 /// A search for one or multiple deployments to make it possible to search
 /// by subgraph name, IPFS hash, or namespace. Since there can be multiple
 /// deployments for the same IPFS hash, the search term for a hash can
 /// optionally specify a shard.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum DeploymentSearch {
     Name { name: String },
     Hash { hash: String, shard: Option<String> },
@@ -60,7 +62,12 @@ impl FromStr for DeploymentSearch {
             Ok(DeploymentSearch::Hash { hash, shard })
         } else if let Some(caps) = DEPLOYMENT_RE.captures(s) {
             let namespace = caps.name("nsp").unwrap().as_str().to_string();
-            Ok(DeploymentSearch::Deployment { namespace })
+            if namespace.starts_with("sgd") {
+                Ok(DeploymentSearch::Deployment { namespace })
+            } else {
+                let namespace = format!("sgd{namespace}");
+                Ok(DeploymentSearch::Deployment { namespace })
+            }
         } else {
             Ok(DeploymentSearch::Name {
                 name: s.to_string(),
@@ -70,12 +77,30 @@ impl FromStr for DeploymentSearch {
 }
 
 impl DeploymentSearch {
-    pub fn lookup(&self, primary: &ConnectionPool) -> Result<Vec<Deployment>, anyhow::Error> {
-        let conn = primary.get()?;
-        self.lookup_with_conn(&conn)
+    pub fn to_unused_filter(self, existing: bool) -> unused::Filter {
+        match self {
+            DeploymentSearch::Name { name } => unused::Filter::Name(name),
+            DeploymentSearch::Hash { hash, shard: _ } => unused::Filter::Hash(hash),
+            DeploymentSearch::All => {
+                if existing {
+                    unused::Filter::New
+                } else {
+                    unused::Filter::All
+                }
+            }
+            DeploymentSearch::Deployment { namespace } => unused::Filter::Deployment(namespace),
+        }
     }
 
-    pub fn lookup_with_conn(&self, conn: &PgConnection) -> Result<Vec<Deployment>, anyhow::Error> {
+    pub async fn lookup(&self, primary: &ConnectionPool) -> Result<Vec<Deployment>, anyhow::Error> {
+        let mut conn = primary.get().await?;
+        self.lookup_with_conn(&mut conn).await
+    }
+
+    pub async fn lookup_with_conn(
+        &self,
+        conn: &mut AsyncPgConnection,
+    ) -> Result<Vec<Deployment>, anyhow::Error> {
         use store_catalog::deployment_schemas as ds;
         use store_catalog::subgraph as s;
         use store_catalog::subgraph_deployment_assignment as a;
@@ -105,25 +130,25 @@ impl DeploymentSearch {
         let deployments: Vec<Deployment> = match self {
             DeploymentSearch::Name { name } => {
                 let pattern = format!("%{}%", name);
-                query.filter(s::name.ilike(&pattern)).load(conn)?
+                query.filter(s::name.ilike(&pattern)).load(conn).await?
             }
             DeploymentSearch::Hash { hash, shard } => {
                 let query = query.filter(ds::subgraph.eq(&hash));
                 match shard {
-                    Some(shard) => query.filter(ds::shard.eq(shard)).load(conn)?,
-                    None => query.load(conn)?,
+                    Some(shard) => query.filter(ds::shard.eq(shard)).load(conn).await?,
+                    None => query.load(conn).await?,
                 }
             }
             DeploymentSearch::Deployment { namespace } => {
-                query.filter(ds::name.eq(&namespace)).load(conn)?
+                query.filter(ds::name.eq(&namespace)).load(conn).await?
             }
-            DeploymentSearch::All => query.load(conn)?,
+            DeploymentSearch::All => query.load(conn).await?,
         };
         Ok(deployments)
     }
 
     /// Finds all [`Deployment`]s for this [`DeploymentSearch`].
-    pub fn find(
+    pub async fn find(
         &self,
         pool: ConnectionPool,
         current: bool,
@@ -133,7 +158,7 @@ impl DeploymentSearch {
         let current = current || used;
         let pending = pending || used;
 
-        let deployments = self.lookup(&pool)?;
+        let deployments = self.lookup(&pool).await?;
         // Filter by status; if neither `current` or `pending` are set, list
         // all deployments
         let deployments: Vec<_> = deployments
@@ -149,9 +174,10 @@ impl DeploymentSearch {
     }
 
     /// Finds a single deployment locator for the given deployment identifier.
-    pub fn locate_unique(&self, pool: &ConnectionPool) -> anyhow::Result<DeploymentLocator> {
+    pub async fn locate_unique(&self, pool: &ConnectionPool) -> anyhow::Result<DeploymentLocator> {
         let mut locators: Vec<DeploymentLocator> = HashSet::<DeploymentLocator>::from_iter(
-            self.lookup(pool)?
+            self.lookup(pool)
+                .await?
                 .into_iter()
                 .map(|deployment| deployment.locator()),
         )
@@ -186,71 +212,4 @@ impl Deployment {
             DeploymentHash::new(self.deployment.clone()).unwrap(),
         )
     }
-
-    pub fn print_table(deployments: Vec<Self>, statuses: Vec<status::Info>) {
-        let mut rows = vec![
-            "name",
-            "status",
-            "id",
-            "namespace",
-            "shard",
-            "active",
-            "chain",
-            "node_id",
-        ];
-        if !statuses.is_empty() {
-            rows.extend(vec![
-                "paused",
-                "synced",
-                "health",
-                "earliest block",
-                "latest block",
-                "chain head block",
-            ]);
-        }
-
-        let mut list = List::new(rows);
-
-        for deployment in deployments {
-            let status = statuses
-                .iter()
-                .find(|status| &status.id.0 == &deployment.id);
-
-            let mut rows = vec![
-                deployment.name,
-                deployment.status,
-                deployment.deployment,
-                deployment.namespace,
-                deployment.shard,
-                deployment.active.to_string(),
-                deployment.chain,
-                deployment.node_id.unwrap_or("---".to_string()),
-            ];
-            if let Some(status) = status {
-                let chain = &status.chains[0];
-                rows.extend(vec![
-                    status
-                        .paused
-                        .map(|b| b.to_string())
-                        .unwrap_or("---".to_string()),
-                    status.synced.to_string(),
-                    status.health.as_str().to_string(),
-                    chain.earliest_block_number.to_string(),
-                    chain
-                        .latest_block
-                        .as_ref()
-                        .map(|b| b.number().to_string())
-                        .unwrap_or("-".to_string()),
-                    chain
-                        .chain_head_block
-                        .as_ref()
-                        .map(|b| b.number().to_string())
-                        .unwrap_or("-".to_string()),
-                ])
-            }
-            list.append(rows);
-        }
-
-        list.render();
-    }
 }
diff --git a/node/src/manager/display.rs b/node/src/manager/display.rs
index 694eaf629bf..cda62f6ea74 100644
--- a/node/src/manager/display.rs
+++ b/node/src/manager/display.rs
@@ -1,3 +1,7 @@
+use std::io::{self, Write};
+
+const LINE_WIDTH: usize = 78;
+
 pub struct List {
     pub headers: Vec<String>,
     pub rows: Vec<Vec<String>>,
@@ -29,8 +33,6 @@ impl List {
     }
 
     pub fn render(&self) {
-        const LINE_WIDTH: usize = 78;
-
         let header_width = self.headers.iter().map(|h| h.len()).max().unwrap_or(0);
         let header_width = if header_width < 5 { 5 } else { header_width };
         let mut first = true;
@@ -52,3 +54,85 @@ impl List {
         }
     }
 }
+
+/// A more general list of columns than `List`. In practical terms, this is
+/// a very simple table with two columns, where both columns are
+/// left-aligned
+#[derive(Default)]
+pub struct Columns {
+    widths: Vec<usize>,
+    rows: Vec<Row>,
+}
+
+impl Columns {
+    pub fn push_row<R: Into<Row>>(&mut self, row: R) {
+        let row = row.into();
+        for (idx, width) in row.widths().iter().enumerate() {
+            if idx >= self.widths.len() {
+                self.widths.push(*width);
+            } else {
+                self.widths[idx] = (*width).max(self.widths[idx]);
+            }
+        }
+        self.rows.push(row);
+    }
+
+    pub fn render(&self, out: &mut dyn Write) -> io::Result<()> {
+        for row in &self.rows {
+            row.render(out, &self.widths)?;
+        }
+        Ok(())
+    }
+}
+
+pub enum Row {
+    Cells(Vec<String>),
+    Separator,
+}
+
+impl Row {
+    pub fn separator() -> Self {
+        Self::Separator
+    }
+
+    fn widths(&self) -> Vec<usize> {
+        match self {
+            Row::Cells(cells) => cells.iter().map(|cell| cell.len()).collect(),
+            Row::Separator => vec![],
+        }
+    }
+
+    fn render(&self, out: &mut dyn Write, widths: &[usize]) -> io::Result<()> {
+        match self {
+            Row::Cells(cells) => {
+                for (idx, cell) in cells.iter().enumerate() {
+                    if idx > 0 {
+                        write!(out, " | ")?;
+                    }
+                    write!(out, "{cell:width$}", width = widths[idx])?;
+                }
+            }
+            Row::Separator => {
+                let total_width = widths.iter().sum::<usize>();
+                let extra_width = LINE_WIDTH.saturating_sub(total_width);
+                for (idx, width) in widths.iter().enumerate() {
+                    if idx > 0 {
+                        write!(out, "-+-")?;
+                    }
+                    if idx == widths.len() - 1 {
+                        write!(out, "{:-<width$}", "", width = width + extra_width)?;
+                    } else {
+                        write!(out, "{:-<width$}", "")?;
+                    }
+                }
+            }
+        }
+        writeln!(out)
+    }
+}
+
+impl From<[&str; 2]> for Row {
+    fn from(row: [&str; 2]) -> Self {
+        Self::Cells(row.iter().map(|s| s.to_string()).collect())
+    }
+}
diff --git a/node/src/manager/fmt.rs b/node/src/manager/fmt.rs
new file mode 100644
index 00000000000..e476bb876dd
--- /dev/null
+++ b/node/src/manager/fmt.rs
@@ -0,0 +1,121 @@
+use std::time::SystemTime;
+
+use graph::prelude::chrono::{DateTime, Duration, Local, Utc};
+
+pub const NULL: &str = "ø";
+const CHECK: &str = "✓";
+
+pub fn null() -> String {
+    NULL.to_string()
+}
+
+pub fn check() -> String {
+    CHECK.to_string()
+}
+
+pub trait MapOrNull<T> {
+    fn map_or_null<F>(&self, f: F) -> String
+    where
+        F: FnOnce(&T) -> String;
+}
+
+impl<T> MapOrNull<T> for Option<T> {
+    fn map_or_null<F>(&self, f: F) -> String
+    where
+        F: FnOnce(&T) -> String,
+    {
+        self.as_ref().map(f).unwrap_or_else(|| NULL.to_string())
+    }
+}
+
+/// Return the duration from `start` to `end` formatted using
+/// `human_duration`. Use now if `end` is `None`
+pub fn duration(start: &DateTime<Utc>, end: &Option<DateTime<Utc>>) -> String {
+    let start = *start;
+    let end = *end;
+
+    let end = end.unwrap_or(DateTime::<Utc>::from(SystemTime::now()));
+    let duration = end - start;
+
+    human_duration(duration)
+}
+
+/// Format a duration using ms/s/m as units depending on how long the
+/// duration was
+pub fn human_duration(duration: Duration) -> String {
+    if duration.num_seconds() < 5 {
+        format!("{}ms", duration.num_milliseconds())
+    } else if duration.num_minutes() < 5 {
+        format!("{}s", duration.num_seconds())
+    } else {
+        let minutes = duration.num_minutes();
+        if minutes < 90 {
+            format!("{}m", duration.num_minutes())
+        } else {
+            let hours = minutes / 60;
+            let minutes = minutes % 60;
+            if hours < 24 {
+                format!("{}h {}m", hours, minutes)
+            } else {
+                let days = hours / 24;
+                let hours = hours % 24;
+                format!("{}d {}h {}m", days, hours, minutes)
+            }
+        }
+    }
+}
+
+/// Abbreviate a long name to fit into `size` characters. The abbreviation
+/// is done by replacing the middle of the name with `..`. For example, if
+/// `name` is `foo_bar_baz` and `size` is 10, the result will be
+/// `foo.._baz`. If the name is shorter than `size`, it is returned
+/// unchanged.
+pub fn abbreviate(name: &str, size: usize) -> String {
+    if name.len() > size {
+        let fragment = size / 2 - 2;
+        let last = name.len() - fragment;
+        let mut name = name.to_string();
+        name.replace_range(fragment..last, "..");
+
+        name.trim().to_string()
+    } else {
+        name.to_string()
+    }
+}
+
+pub fn date_time(date: &DateTime<Utc>) -> String {
+    let date = DateTime::<Local>::from(*date);
+    date.format("%Y-%m-%d %H:%M:%S%Z").to_string()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_human_duration() {
+        let duration = Duration::seconds(1);
+        assert_eq!(human_duration(duration), "1000ms");
+
+        let duration = Duration::seconds(10);
+        assert_eq!(human_duration(duration), "10s");
+
+        let duration = Duration::minutes(5);
+        assert_eq!(human_duration(duration), "5m");
+
+        let duration = Duration::hours(1);
+        assert_eq!(human_duration(duration), "60m");
+
+        let duration = Duration::minutes(100);
+        assert_eq!(human_duration(duration), "1h 40m");
+
+        let duration = Duration::days(1);
+        assert_eq!(human_duration(duration), "1d 0h 0m");
+
+        let duration = Duration::days(1) + Duration::minutes(35);
+        assert_eq!(human_duration(duration), "1d 0h 35m");
+
+        let duration = Duration::days(1) + Duration::minutes(95);
+        assert_eq!(human_duration(duration), "1d 1h 35m");
+    }
+}
diff --git a/node/src/manager/mod.rs b/node/src/manager/mod.rs
index b2eccaf6e9a..7c3ae84793d 100644
--- a/node/src/manager/mod.rs
+++ b/node/src/manager/mod.rs
@@ -1,8 +1,6 @@
-use std::collections::BTreeSet;
-
 use graph::{
-    components::store::{SubscriptionManager, UnitStream},
-    prelude::{anyhow, StoreEventStreamBox, SubscriptionFilter},
+    components::store::SubscriptionManager,
+    prelude::{StoreEventStreamBox, anyhow},
 };
 
 pub mod catalog;
@@ -10,19 +8,16 @@ pub mod color;
 pub mod commands;
 pub mod deployment;
 mod display;
+pub mod fmt;
 pub mod prompt;
 
 /// A dummy subscription manager that always panics
 pub struct PanicSubscriptionManager;
 
 impl SubscriptionManager for PanicSubscriptionManager {
-    fn subscribe(&self, _: BTreeSet<SubscriptionFilter>) -> StoreEventStreamBox {
+    fn subscribe(&self) -> StoreEventStreamBox {
         panic!("we were never meant to call `subscribe`");
     }
-
-    fn subscribe_no_payload(&self, _: BTreeSet<SubscriptionFilter>) -> UnitStream {
-        panic!("we were never meant to call `subscribe_no_payload`");
-    }
 }
 
 pub type CmdResult = Result<(), anyhow::Error>;
diff --git a/node/src/network_setup.rs b/node/src/network_setup.rs
new file mode 100644
index 00000000000..e1630786345
--- /dev/null
+++ b/node/src/network_setup.rs
@@ -0,0 +1,373 @@
+use ethereum::{
+    BlockIngestor,
+    chain::ChainSettings,
+    network::{EthereumNetworkAdapter, EthereumNetworkAdapters},
+};
+use graph::components::network_provider::ChainName;
+use graph::components::network_provider::NetworkDetails;
+use graph::components::network_provider::ProviderCheck;
+use graph::components::network_provider::ProviderCheckStrategy;
+use graph::components::network_provider::ProviderManager;
+use graph::{
+    anyhow::{self, bail},
+    blockchain::{Blockchain, BlockchainKind, BlockchainMap, ChainIdentifier},
+    cheap_clone::CheapClone,
+    components::metrics::MetricsRegistry,
+    endpoint::EndpointMetrics,
+    env::EnvVars,
+    firehose::{FirehoseEndpoint, FirehoseEndpoints},
+    futures03::future::TryFutureExt,
+    itertools::Itertools,
+    log::factory::LoggerFactory,
+    prelude::{
+        Logger,
+        anyhow::{Result, anyhow},
+        info,
+    },
+    slog::{Discard, o, warn},
+};
+use graph_chain_ethereum as ethereum;
+use graph_store_postgres::{BlockStore, ChainHeadUpdateListener};
+
+use std::{any::Any, cmp::Ordering, sync::Arc};
+
+use crate::chain::{
+    AnyChainFilter, ChainFilter, OneChainFilter, create_ethereum_networks,
+    create_firehose_networks, networks_as_chains,
+};
+
+#[derive(Debug, Clone)]
+pub struct EthAdapterConfig {
+    pub chain_id: ChainName,
+    pub adapters: Vec<EthereumNetworkAdapter>,
+    pub call_only: Vec<EthereumNetworkAdapter>,
+    pub settings: Arc<ChainSettings>,
+}
+
+#[derive(Debug, Clone)]
+pub struct FirehoseAdapterConfig {
+    pub chain_id: ChainName,
+    pub kind: BlockchainKind,
+    pub adapters: Vec<Arc<FirehoseEndpoint>>,
+}
+
+#[derive(Debug, Clone)]
+pub enum AdapterConfiguration {
+    Rpc(EthAdapterConfig),
+    Firehose(FirehoseAdapterConfig),
+}
+
+impl AdapterConfiguration {
+    pub fn blockchain_kind(&self) -> &BlockchainKind {
+        match self {
+            AdapterConfiguration::Rpc(_) => &BlockchainKind::Ethereum,
+            AdapterConfiguration::Firehose(fh) => &fh.kind,
+        }
+    }
+    pub fn chain_id(&self) -> &ChainName {
+        match self {
+            AdapterConfiguration::Rpc(EthAdapterConfig { chain_id, .. })
+            | AdapterConfiguration::Firehose(FirehoseAdapterConfig { chain_id, .. }) => chain_id,
+        }
+    }
+
+    pub fn as_rpc(&self) -> Option<&EthAdapterConfig> {
+        match self {
+            AdapterConfiguration::Rpc(rpc) => Some(rpc),
+            _ => None,
+        }
+    }
+
+    pub fn as_firehose(&self) -> Option<&FirehoseAdapterConfig> {
+        match self {
+            AdapterConfiguration::Firehose(fh) => Some(fh),
+            _ => None,
+        }
+    }
+
+    pub fn is_firehose(&self) -> bool {
+        self.as_firehose().is_none()
+    }
+}
+
+pub struct Networks {
+    pub adapters: Vec<AdapterConfiguration>,
+    pub rpc_provider_manager: ProviderManager<EthereumNetworkAdapter>,
+    pub firehose_provider_manager: ProviderManager<Arc<FirehoseEndpoint>>,
+}
+
+impl Networks {
+    // noop is important for query_nodes as it shortcuts a lot of the process.
+    fn noop() -> Self {
+        Self {
+            adapters: vec![],
+            rpc_provider_manager: ProviderManager::new(
+                Logger::root(Discard, o!()),
+                vec![],
+                ProviderCheckStrategy::MarkAsValid,
+            ),
+            firehose_provider_manager: ProviderManager::new(
+                Logger::root(Discard, o!()),
+                vec![],
+                ProviderCheckStrategy::MarkAsValid,
+            ),
+        }
+    }
+
+    pub async fn chain_identifier(
+        &self,
+        logger: &Logger,
+        chain_id: &ChainName,
+    ) -> Result<ChainIdentifier> {
+        async fn get_identifier<T: NetworkDetails + Clone>(
+            pm: ProviderManager<T>,
+            logger: &Logger,
+            chain_id: &ChainName,
+            provider_type: &str,
+        ) -> Result<ChainIdentifier> {
+            for adapter in pm.providers_unchecked(chain_id) {
+                match adapter.chain_identifier().await {
+                    Ok(ident) => return Ok(ident),
+                    Err(err) => {
+                        warn!(
+                            logger,
+                            "unable to get chain identification from {} provider {} for chain {}, err: {}",
+                            provider_type,
+                            adapter.provider_name(),
+                            chain_id,
+                            err.to_string(),
+                        );
+                    }
+                }
+            }
+
+            bail!("no working adapters for chain {}", chain_id);
+        }
+
+        get_identifier(self.rpc_provider_manager.clone(), logger, chain_id, "rpc")
+            .or_else(|_| {
+                get_identifier(
+                    self.firehose_provider_manager.clone(),
+                    logger,
+                    chain_id,
+                    "firehose",
+                )
+            })
+            .await
+    }
+
+    async fn from_config_inner(
+        logger: Logger,
+        config: &crate::config::Config,
+        registry: Arc<MetricsRegistry>,
+        endpoint_metrics: Arc<EndpointMetrics>,
+        provider_checks: &[Arc<dyn ProviderCheck>],
+        chain_filter: &dyn ChainFilter,
+    ) -> Result<Networks> {
+        if config.query_only(&config.node) {
+            return Ok(Networks::noop());
+        }
+
+        let eth = create_ethereum_networks(
+            logger.cheap_clone(),
+            registry,
+            config,
+            endpoint_metrics.cheap_clone(),
+            chain_filter,
+        )
+        .await?;
+        let firehose = create_firehose_networks(
+            logger.cheap_clone(),
+            config,
+            endpoint_metrics.cheap_clone(),
+            chain_filter,
+        );
+        let adapters: Vec<_> = eth.into_iter().chain(firehose).collect();
+
+        Ok(Networks::new(&logger, adapters, provider_checks))
+    }
+
+    pub async fn from_config_for_chain(
+        logger: Logger,
+        config: &crate::config::Config,
+        registry: Arc<MetricsRegistry>,
+        endpoint_metrics: Arc<EndpointMetrics>,
+        provider_checks: &[Arc<dyn ProviderCheck>],
+        chain_name: &str,
+    ) -> Result<Networks> {
+        let filter = OneChainFilter::new(chain_name.to_string());
+        Self::from_config_inner(
+            logger,
+            config,
+            registry,
+            endpoint_metrics,
+            provider_checks,
+            &filter,
+        )
+        .await
+    }
+
+    pub async fn from_config(
+        logger: Logger,
+        config: &crate::config::Config,
+        registry: Arc<MetricsRegistry>,
+        endpoint_metrics: Arc<EndpointMetrics>,
+        provider_checks: &[Arc<dyn ProviderCheck>],
+    ) -> Result<Networks> {
+        Self::from_config_inner(
+            logger,
+            config,
+            registry,
+            endpoint_metrics,
+            provider_checks,
+            &AnyChainFilter,
+        )
+        .await
+    }
+
+    fn new(
+        logger: &Logger,
+        adapters: Vec<AdapterConfiguration>,
+        provider_checks: &[Arc<dyn ProviderCheck>],
+    ) -> Self {
+        let adapters2 = adapters.clone();
+        let eth_adapters = adapters.iter().flat_map(|a| a.as_rpc()).cloned().map(
+            |EthAdapterConfig {
+                 chain_id,
+                 mut adapters,
+                 call_only: _,
+                 settings: _,
+             }| {
+                adapters.sort_by(|a, b| {
+                    a.capabilities
+                        .partial_cmp(&b.capabilities)
+                        .unwrap_or(Ordering::Equal)
+                });
+
+                (chain_id, adapters)
+            },
+        );
+
+        let firehose_adapters = adapters
+            .iter()
+            .flat_map(|a| a.as_firehose())
+            .cloned()
+            .map(
+                |FirehoseAdapterConfig {
+                     chain_id,
+                     kind: _,
+                     adapters,
+                 }| { (chain_id, adapters) },
+            )
+            .collect_vec();
+
+        Self {
+            adapters: adapters2,
+            rpc_provider_manager: ProviderManager::new(
+                logger.clone(),
+                eth_adapters,
+                ProviderCheckStrategy::RequireAll(provider_checks),
+            ),
+            firehose_provider_manager: ProviderManager::new(
+                logger.clone(),
+                firehose_adapters,
+                ProviderCheckStrategy::RequireAll(provider_checks),
+            ),
+        }
+    }
+
+    pub async fn block_ingestors(
+        logger: &Logger,
+        blockchain_map: &Arc<BlockchainMap>,
+    ) -> anyhow::Result<Vec<Box<dyn BlockIngestor>>> {
+        async fn block_ingestor<C: Blockchain>(
+            logger: &Logger,
+            chain_id: &ChainName,
+            chain: &Arc<dyn Any + Send + Sync>,
+            ingestors: &mut Vec<Box<dyn BlockIngestor>>,
+        ) -> anyhow::Result<()> {
+            let chain: Arc<C> = chain.cheap_clone().downcast().map_err(|_| {
+                anyhow!("unable to downcast, wrong type for blockchain {}", C::KIND)
+            })?;
+
+            let logger = logger.new(o!("network_name" => chain_id.to_string()));
+
+            match chain.block_ingestor().await {
+                Ok(ingestor) => {
+                    info!(&logger, "Creating block ingestor");
+                    ingestors.push(ingestor)
+                }
+                Err(err) => graph::slog::error!(
+                    &logger,
+                    "unable to create block_ingestor for {}: {}",
+                    chain_id,
+                    err.to_string()
+                ),
+            }
+
+            Ok(())
+        }
+
+        let mut res = vec![];
+        for ((kind, id), chain) in blockchain_map.iter() {
+            match kind {
+                BlockchainKind::Ethereum => {
+                    block_ingestor::<graph_chain_ethereum::Chain>(logger, id, chain, &mut res)
+                        .await?
+                }
+                BlockchainKind::Near => {
+                    block_ingestor::<graph_chain_near::Chain>(logger, id, chain, &mut res).await?
+                }
+            }
+        }
+
+        Ok(res)
+    }
+
+    pub async fn blockchain_map(
+        &self,
+        config: &Arc<EnvVars>,
+        logger: &Logger,
+        store: BlockStore,
+        logger_factory: &LoggerFactory,
+        metrics_registry: Arc<MetricsRegistry>,
+        chain_head_update_listener: Arc<ChainHeadUpdateListener>,
+    ) -> BlockchainMap {
+        let mut bm = BlockchainMap::new();
+
+        networks_as_chains(
+            config,
+            &mut bm,
+            logger,
+            self,
+            store,
+            logger_factory,
+            metrics_registry,
+            chain_head_update_listener,
+        )
+        .await;
+
+        bm
+    }
+
+    pub fn firehose_endpoints(&self, chain_id: ChainName) -> FirehoseEndpoints {
+        FirehoseEndpoints::new(chain_id, self.firehose_provider_manager.clone())
+    }
+
+    pub fn ethereum_rpcs(&self, chain_id: ChainName) -> EthereumNetworkAdapters {
+        let eth_adapters = self
+            .adapters
+            .iter()
+            .filter(|a| a.chain_id().eq(&chain_id))
+            .flat_map(|a| a.as_rpc())
+            .flat_map(|eth_c| eth_c.call_only.clone())
+            .collect_vec();
+
+        EthereumNetworkAdapters::new(
+            chain_id,
+            self.rpc_provider_manager.clone(),
+            eth_adapters,
+            None,
+        )
+    }
+}
diff --git a/node/src/opt.rs b/node/src/opt.rs
index 06eb161c431..dbcd3b68cf9 100644
--- a/node/src/opt.rs
+++ b/node/src/opt.rs
@@ -20,8 +20,8 @@ pub struct Opt {
     #[clap(
         long,
         env = "GRAPH_NODE_CONFIG",
-        conflicts_with_all = &["postgres-url", "postgres-secondary-hosts", "postgres-host-weights"],
-        required_unless = "postgres-url",
+        conflicts_with_all = &["postgres_url", "postgres_secondary_hosts", "postgres_host_weights"],
+        required_unless_present = "postgres_url",
         help = "the name of the configuration file",
     )]
     pub config: Option<String>,
@@ -48,14 +48,14 @@ pub struct Opt {
         value_name = "URL",
         env = "POSTGRES_URL",
         conflicts_with = "config",
-        required_unless = "config",
+        required_unless_present = "config",
         help = "Location of the Postgres database used for storing entities"
     )]
     pub postgres_url: Option<String>,
     #[clap(
         long,
         value_name = "URL,",
-        use_delimiter = true,
+        use_value_delimiter = true,
         env = "GRAPH_POSTGRES_SECONDARY_HOSTS",
         conflicts_with = "config",
         help = "Comma-separated list of host names/IP's for read-only Postgres replicas, \
@@ -66,7 +66,7 @@ pub struct Opt {
     #[clap(
         long,
         value_name = "WEIGHT,",
-        use_delimiter = true,
+        use_value_delimiter = true,
         env = "GRAPH_POSTGRES_HOST_WEIGHTS",
         conflicts_with = "config",
         help = "Comma-separated list of relative weights for selecting the main database \
@@ -77,35 +77,36 @@ pub struct Opt {
     pub postgres_host_weights: Vec<usize>,
     #[clap(
         long,
-        min_values=0,
-        required_unless_one = &["ethereum-ws", "ethereum-ipc", "config"],
-        conflicts_with_all = &["ethereum-ws", "ethereum-ipc", "config"],
+        allow_negative_numbers = false,
+        required_unless_present_any = &["ethereum_ws", "ethereum_ipc", "config"],
+        conflicts_with_all = &["ethereum_ws", "ethereum_ipc", "config"],
         value_name="NETWORK_NAME:[CAPABILITIES]:URL",
         env="ETHEREUM_RPC",
-        help= "Ethereum network name (e.g. 'mainnet'), optional comma-seperated capabilities (eg 'full,archive'), and an Ethereum RPC URL, separated by a ':'",
+        help= "Ethereum network name (e.g. 'mainnet'), optional comma-separated capabilities (eg 'full,archive'), and an Ethereum RPC URL, separated by a ':'",
     )]
     pub ethereum_rpc: Vec<String>,
-    #[clap(long, min_values=0,
-        required_unless_one = &["ethereum-rpc", "ethereum-ipc", "config"],
-        conflicts_with_all = &["ethereum-rpc", "ethereum-ipc", "config"],
+    #[clap(long, allow_negative_numbers = false,
+        required_unless_present_any = &["ethereum_rpc", "ethereum_ipc", "config"],
+        conflicts_with_all = &["ethereum_rpc", "ethereum_ipc", "config"],
         value_name="NETWORK_NAME:[CAPABILITIES]:URL",
         env="ETHEREUM_WS",
-        help= "Ethereum network name (e.g. 'mainnet'), optional comma-seperated capabilities (eg 'full,archive`, and an Ethereum WebSocket URL, separated by a ':'",
+        help= "Ethereum network name (e.g. 'mainnet'), optional comma-separated capabilities (eg 'full,archive`, and an Ethereum WebSocket URL, separated by a ':'",
     )]
     pub ethereum_ws: Vec<String>,
-    #[clap(long, min_values=0,
-        required_unless_one = &["ethereum-rpc", "ethereum-ws", "config"],
-        conflicts_with_all = &["ethereum-rpc", "ethereum-ws", "config"],
+    #[clap(long,
+        allow_negative_numbers = false,
+        required_unless_present_any = &["ethereum_rpc", "ethereum_ws", "config"],
+        conflicts_with_all = &["ethereum_rpc", "ethereum_ws", "config"],
         value_name="NETWORK_NAME:[CAPABILITIES]:FILE",
         env="ETHEREUM_IPC",
-        help= "Ethereum network name (e.g. 'mainnet'), optional comma-seperated capabilities (eg 'full,archive'), and an Ethereum IPC pipe, separated by a ':'",
+        help= "Ethereum network name (e.g. 'mainnet'), optional comma-separated capabilities (eg 'full,archive'), and an Ethereum IPC pipe, separated by a ':'",
     )]
     pub ethereum_ipc: Vec<String>,
     #[clap(
         long,
         value_name = "HOST:PORT",
         env = "IPFS",
-        help = "HTTP addresses of IPFS nodes"
+        help = "HTTP addresses of IPFS servers (RPC, Gateway)"
     )]
     pub ipfs: Vec<String>,
     #[clap(
@@ -131,14 +132,6 @@ pub struct Opt {
         help = "Port for the index node server"
     )]
     pub index_node_port: u16,
-    #[clap(
-        long,
-        default_value = "8001",
-        value_name = "PORT",
-        help = "Port for the GraphQL WebSocket server",
-        env = "GRAPH_GRAPHQL_WS_PORT"
-    )]
-    pub ws_port: u16,
     #[clap(
         long,
         default_value = "8020",
@@ -172,28 +165,6 @@ pub struct Opt {
     #[clap(long, help = "Enable debug logging")]
     pub debug: bool,
 
-    #[clap(
-        long,
-        value_name = "URL",
-        env = "ELASTICSEARCH_URL",
-        help = "Elasticsearch service to write subgraph logs to"
-    )]
-    pub elasticsearch_url: Option<String>,
-    #[clap(
-        long,
-        value_name = "USER",
-        env = "ELASTICSEARCH_USER",
-        help = "User to use for Elasticsearch logging"
-    )]
-    pub elasticsearch_user: Option<String>,
-    #[clap(
-        long,
-        value_name = "PASSWORD",
-        env = "ELASTICSEARCH_PASSWORD",
-        hide_env_values = true,
-        help = "Password to use for Elasticsearch logging"
-    )]
-    pub elasticsearch_password: Option<String>,
     #[clap(
         long,
         value_name = "DISABLE_BLOCK_INGESTOR",
@@ -230,6 +201,21 @@ pub struct Opt {
         help = "Base URL for forking subgraphs"
     )]
     pub fork_base: Option<String>,
+    #[clap(
+        long,
+        default_value = "8050",
+        value_name = "GRAPHMAN_PORT",
+        help = "Port for the graphman GraphQL server"
+    )]
+    pub graphman_port: u16,
+
+    #[clap(
+        long,
+        value_name = "{HOST:PORT|URL}",
+        env = "GRAPH_AMP_FLIGHT_SERVICE_ADDRESS",
+        help = "The address of the Amp Flight gRPC service"
+    )]
+    pub amp_flight_service_address: Option<String>,
 }
 
 impl From<Opt> for config::Opt {
diff --git a/node/src/store_builder.rs b/node/src/store_builder.rs
index 8ececd9d851..fb3737e5b89 100644
--- a/node/src/store_builder.rs
+++ b/node/src/store_builder.rs
@@ -1,22 +1,19 @@
-use std::collections::BTreeMap;
 use std::iter::FromIterator;
 use std::{collections::HashMap, sync::Arc};
 
-use futures::future::join_all;
-use graph::blockchain::ChainIdentifier;
-use graph::prelude::{o, MetricsRegistry, NodeId};
+use graph::components::store::BLOCK_CACHE_SIZE;
+use graph::prelude::{MetricsRegistry, NodeId, o};
+use graph::slog::warn;
 use graph::url::Url;
 use graph::{
-    prelude::{info, CheapClone, Logger},
+    prelude::{CheapClone, Logger, info},
     util::security::SafeDisplay,
 };
-use graph_store_postgres::connection_pool::{
-    ConnectionPool, ForeignServer, PoolCoordinator, PoolName,
-};
 use graph_store_postgres::{
     BlockStore as DieselBlockStore, ChainHeadUpdateListener as PostgresChainHeadUpdateListener,
-    ChainStoreMetrics, NotificationSender, Shard as ShardName, Store as DieselStore, SubgraphStore,
-    SubscriptionManager, PRIMARY_SHARD,
+    ChainStoreMetrics, ConnectionPool, ForeignServer, NotificationSender, PRIMARY_SHARD,
+    PoolCoordinator, PoolRole, Shard as ShardName, Store as DieselStore, SubgraphStore,
+    SubscriptionManager,
 };
 
 use crate::config::{Config, Shard};
@@ -28,7 +25,8 @@ pub struct StoreBuilder {
     subscription_manager: Arc<SubscriptionManager>,
     chain_head_update_listener: Arc<PostgresChainHeadUpdateListener>,
     /// Map network names to the shards where they are/should be stored
-    chains: HashMap<String, ShardName>,
+    /// and their cache_size setting
+    chains: HashMap<String, (ShardName, i32)>,
     pub coord: Arc<PoolCoordinator>,
     registry: Arc<MetricsRegistry>,
 }
@@ -64,12 +62,12 @@ impl StoreBuilder {
         // attempt doesn't work for all of them because the database is
         // unavailable, they will try again later in the normal course of
         // using the pool
-        join_all(pools.values().map(|pool| pool.setup())).await;
+        coord.setup_all(logger).await;
 
         let chains = HashMap::from_iter(config.chains.chains.iter().map(|(name, chain)| {
             let shard = ShardName::new(chain.shard.to_string())
                 .expect("config validation catches invalid names");
-            (name.to_string(), shard)
+            (name.to_string(), (shard, chain.cache_size))
         }));
 
         let chain_head_update_listener = Arc::new(PostgresChainHeadUpdateListener::new(
@@ -113,13 +111,28 @@ impl StoreBuilder {
             .collect::<Result<Vec<_>, _>>()
             .expect("connection url's contain enough detail");
         let servers = Arc::new(servers);
-        let coord = Arc::new(PoolCoordinator::new(servers));
+        let coord = Arc::new(PoolCoordinator::new(logger, servers));
 
         let shards: Vec<_> = config
             .stores
             .iter()
-            .map(|(name, shard)| {
+            .filter_map(|(name, shard)| {
                 let logger = logger.new(o!("shard" => name.to_string()));
+                let pool_size = shard.pool_size.size_for(node, name).unwrap_or_else(|_| {
+                    panic!("cannot determine the pool size for store {}", name)
+                });
+                if pool_size == 0 {
+                    if name == PRIMARY_SHARD.as_str() {
+                        panic!("pool size for primary shard must be greater than 0");
+                    } else {
+                        warn!(
+                            logger,
+                            "pool size for shard {} is 0, ignoring this shard", name
+                        );
+                        return None;
+                    }
+                }
+
                 let conn_pool = Self::main_pool(
                     &logger,
                     node,
@@ -140,7 +153,7 @@ impl StoreBuilder {
 
                 let name =
                     ShardName::new(name.to_string()).expect("shard names have been validated");
-                (name, conn_pool, read_only_conn_pools, weights)
+                Some((name, conn_pool, read_only_conn_pools, weights))
             })
             .collect();
 
@@ -162,44 +175,47 @@ impl StoreBuilder {
         (store, pools, coord)
     }
 
-    pub fn make_store(
+    pub async fn make_store(
         logger: &Logger,
         pools: HashMap<ShardName, ConnectionPool>,
         subgraph_store: Arc<SubgraphStore>,
-        chains: HashMap<String, ShardName>,
-        networks: BTreeMap<String, ChainIdentifier>,
+        chains: HashMap<String, (ShardName, i32)>,
+        networks: Vec<String>,
         registry: Arc<MetricsRegistry>,
     ) -> Arc<DieselStore> {
         let networks = networks
             .into_iter()
-            .map(|(name, idents)| {
-                let shard = chains.get(&name).unwrap_or(&*PRIMARY_SHARD).clone();
-                (name, idents, shard)
+            .map(|name| {
+                let (shard, cache_size) = chains
+                    .get(&name)
+                    .cloned()
+                    .unwrap_or_else(|| (PRIMARY_SHARD.clone(), BLOCK_CACHE_SIZE));
+                (name, shard, cache_size)
             })
             .collect();
 
         let logger = logger.new(o!("component" => "BlockStore"));
 
         let chain_store_metrics = Arc::new(ChainStoreMetrics::new(registry));
-        let block_store = Arc::new(
-            DieselBlockStore::new(
-                logger,
-                networks,
-                pools,
-                subgraph_store.notification_sender(),
-                chain_store_metrics,
-            )
-            .expect("Creating the BlockStore works"),
-        );
+        let block_store = DieselBlockStore::new(
+            logger,
+            networks,
+            pools,
+            subgraph_store.notification_sender(),
+            chain_store_metrics,
+        )
+        .await
+        .expect("Creating the BlockStore works");
         block_store
             .update_db_version()
-            .expect("Updating `db_version` works");
+            .await
+            .expect("Updating `db_version` should work");
 
         Arc::new(DieselStore::new(subgraph_store, block_store))
     }
 
-    /// Create a connection pool for the main database of the primary shard
-    /// without connecting to all the other configured databases
+    /// Create a connection pool for the main (non-replica) database of a
+    /// shard
     pub fn main_pool(
         logger: &Logger,
         node: &NodeId,
@@ -227,7 +243,7 @@ impl StoreBuilder {
         coord.create_pool(
             &logger,
             name,
-            PoolName::Main,
+            PoolRole::Main,
             shard.connection.clone(),
             pool_size,
             Some(fdw_pool_size),
@@ -267,7 +283,7 @@ impl StoreBuilder {
                     coord.clone().create_pool(
                         &logger,
                         name,
-                        PoolName::Replica(pool),
+                        PoolRole::Replica(pool),
                         replica.connection.clone(),
                         pool_size,
                         None,
@@ -281,15 +297,16 @@ impl StoreBuilder {
 
     /// Return a store that combines both a `Store` for subgraph data
     /// and a `BlockStore` for all chain related data
-    pub fn network_store(self, networks: BTreeMap<String, ChainIdentifier>) -> Arc<DieselStore> {
+    pub async fn network_store(self, networks: Vec<impl Into<String>>) -> Arc<DieselStore> {
         Self::make_store(
             &self.logger,
             self.pools,
             self.subgraph_store,
             self.chains,
-            networks,
+            networks.into_iter().map(Into::into).collect(),
             self.registry,
         )
+        .await
     }
 
     pub fn subscription_manager(&self) -> Arc<SubscriptionManager> {
diff --git a/package.json b/package.json
new file mode 100644
index 00000000000..9b54a0cd667
--- /dev/null
+++ b/package.json
@@ -0,0 +1,7 @@
+{
+  "private": true,
+  "packageManager": "pnpm@10.14.0+sha512.ad27a79641b49c3e481a16a805baa71817a04bbe06a38d17e60e2eaee83f6a146c6a688125f5792e48dd5ba30e7da52a5cda4c3992b9ccf333f9ce223af84748",
+  "devDependencies": {
+    "assemblyscript": "0.19.23"
+  }
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
new file mode 100644
index 00000000000..deb287d228f
--- /dev/null
+++ b/pnpm-lock.yaml
@@ -0,0 +1,6748 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    devDependencies:
+      assemblyscript:
+        specifier: 0.19.23
+        version: 0.19.23
+
+  tests/integration-tests/base:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/block-handlers:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/declared-calls-basic:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.33.0
+        version: 0.33.0
+
+  tests/integration-tests/declared-calls-struct-fields:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.33.0
+        version: 0.33.0
+
+  tests/integration-tests/ethereum-api-tests:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.36.0-alpha-20240422133139-8761ea3
+        version: 0.36.0-alpha-20240422133139-8761ea3
+
+  tests/integration-tests/grafted:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/host-exports:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/int8:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/logs-query:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.69.0
+        version: 0.69.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/multiple-subgraph-datasources:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.36.0-alpha-20241129215038-b75cda9
+        version: 0.36.0-alpha-20241129215038-b75cda9
+
+  tests/integration-tests/non-fatal-errors:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/overloaded-functions:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/poi-for-failed-subgraph:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/remove-then-update:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/reverted-calls:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/source-subgraph:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.36.0-alpha-20241129215038-b75cda9
+        version: 0.36.0-alpha-20241129215038-b75cda9
+
+  tests/integration-tests/source-subgraph-a:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/source-subgraph-b:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/subgraph-data-sources:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.36.0-alpha-20241129215038-b75cda9
+        version: 0.36.0-alpha-20241129215038-b75cda9
+
+  tests/integration-tests/timestamp:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/integration-tests/topic-filter:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.35.0
+        version: 0.35.0
+
+  tests/integration-tests/value-roundtrip:
+    devDependencies:
+      '@graphprotocol/graph-ts':
+        specifier: 0.34.0
+        version: 0.34.0
+
+  tests/runner-tests/aggregation-current-bucket:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.98.1
+        version: 0.98.1(@types/node@24.3.0)(bufferutil@4.0.9)(typescript@5.9.2)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@graphprotocol/graph-ts':
+        specifier: 0.35.0
+        version: 0.35.0
+
+  tests/runner-tests/api-version:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+      mustache:
+        specifier: ^4.2.0
+        version: 4.2.0
+
+  tests/runner-tests/arweave-file-data-sources:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/block-handlers:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/data-source-revert:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/data-source-revert2:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/data-sources:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/derived-loaders:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/dynamic-data-source:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/end-block:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.54.0-alpha-20230727052453-1e0e6e5
+        version: 0.54.0-alpha-20230727052453-1e0e6e5(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.30.0
+        version: 0.30.0
+
+  tests/runner-tests/fatal-error:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/file-data-sources:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/file-link-resolver:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/skip-duplicates:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.60.0
+        version: 0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.31.0
+        version: 0.31.0
+
+  tests/runner-tests/typename:
+    devDependencies:
+      '@graphprotocol/graph-cli':
+        specifier: 0.50.0
+        version: 0.50.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)
+      '@graphprotocol/graph-ts':
+        specifier: 0.30.0
+        version: 0.30.0
+
+packages:
+
+  '@babel/code-frame@7.27.1':
+    resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-identifier@7.27.1':
+    resolution: {integrity: sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==}
+    engines: {node: '>=6.9.0'}
+
+  '@chainsafe/is-ip@2.1.0':
+    resolution: {integrity: sha512-KIjt+6IfysQ4GCv66xihEitBjvhU/bixbbbFxdJ1sqCp4uJ0wuZiYBPhksZoy4lfaF0k9cwNzY5upEW/VWdw3w==}
+
+  '@chainsafe/netmask@2.0.0':
+    resolution: {integrity: sha512-I3Z+6SWUoaljh3TBzCnCxjlUyN8tA+NAk5L6m9IxvCf1BENQTePzPMis97CoN/iMW1St3WN+AWCCRp+TTBRiDg==}
+
+  '@cspotcode/source-map-support@0.8.1':
+    resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
+    engines: {node: '>=12'}
+
+  '@ethersproject/abi@5.0.7':
+    resolution: {integrity: sha512-Cqktk+hSIckwP/W8O47Eef60VwmoSC/L3lY0+dIBhQPCNn9E4V7rwmm2aFrNRRDJfFlGuZ1khkQUOc3oBX+niw==}
+
+  '@ethersproject/abstract-provider@5.8.0':
+    resolution: {integrity: sha512-wC9SFcmh4UK0oKuLJQItoQdzS/qZ51EJegK6EmAWlh+OptpQ/npECOR3QqECd8iGHC0RJb4WKbVdSfif4ammrg==}
+
+  '@ethersproject/abstract-signer@5.8.0':
+    resolution: {integrity: sha512-N0XhZTswXcmIZQdYtUnd79VJzvEwXQw6PK0dTl9VoYrEBxxCPXqS0Eod7q5TNKRxe1/5WUMuR0u0nqTF/avdCA==}
+
+  '@ethersproject/address@5.8.0':
+    resolution: {integrity: sha512-GhH/abcC46LJwshoN+uBNoKVFPxUuZm6dA257z0vZkKmU1+t8xTn8oK7B9qrj8W2rFRMch4gbJl6PmVxjxBEBA==}
+
+  '@ethersproject/base64@5.8.0':
+    resolution: {integrity: sha512-lN0oIwfkYj9LbPx4xEkie6rAMJtySbpOAFXSDVQaBnAzYfB4X2Qr+FXJGxMoc3Bxp2Sm8OwvzMrywxyw0gLjIQ==}
+
+  '@ethersproject/bignumber@5.8.0':
+    resolution: {integrity: sha512-ZyaT24bHaSeJon2tGPKIiHszWjD/54Sz8t57Toch475lCLljC6MgPmxk7Gtzz+ddNN5LuHea9qhAe0x3D+uYPA==}
+
+  '@ethersproject/bytes@5.8.0':
+    resolution: {integrity: sha512-vTkeohgJVCPVHu5c25XWaWQOZ4v+DkGoC42/TS2ond+PARCxTJvgTFUNDZovyQ/uAQ4EcpqqowKydcdmRKjg7A==}
+
+  '@ethersproject/constants@5.8.0':
+    resolution: {integrity: sha512-wigX4lrf5Vu+axVTIvNsuL6YrV4O5AXl5ubcURKMEME5TnWBouUh0CDTWxZ2GpnRn1kcCgE7l8O5+VbV9QTTcg==}
+
+  '@ethersproject/hash@5.8.0':
+    resolution: {integrity: sha512-ac/lBcTbEWW/VGJij0CNSw/wPcw9bSRgCB0AIBz8CvED/jfvDoV9hsIIiWfvWmFEi8RcXtlNwp2jv6ozWOsooA==}
+
+  '@ethersproject/keccak256@5.8.0':
+    resolution: {integrity: sha512-A1pkKLZSz8pDaQ1ftutZoaN46I6+jvuqugx5KYNeQOPqq+JZ0Txm7dlWesCHB5cndJSu5vP2VKptKf7cksERng==}
+
+  '@ethersproject/logger@5.8.0':
+    resolution: {integrity: sha512-Qe6knGmY+zPPWTC+wQrpitodgBfH7XoceCGL5bJVejmH+yCS3R8jJm8iiWuvWbG76RUmyEG53oqv6GMVWqunjA==}
+
+  '@ethersproject/networks@5.8.0':
+    resolution: {integrity: sha512-egPJh3aPVAzbHwq8DD7Po53J4OUSsA1MjQp8Vf/OZPav5rlmWUaFLiq8cvQiGK0Z5K6LYzm29+VA/p4RL1FzNg==}
+
+  '@ethersproject/properties@5.8.0':
+    resolution: {integrity: sha512-PYuiEoQ+FMaZZNGrStmN7+lWjlsoufGIHdww7454FIaGdbe/p5rnaCXTr5MtBYl3NkeoVhHZuyzChPeGeKIpQw==}
+
+  '@ethersproject/rlp@5.8.0':
+    resolution: {integrity: sha512-LqZgAznqDbiEunaUvykH2JAoXTT9NV0Atqk8rQN9nx9SEgThA/WMx5DnW8a9FOufo//6FZOCHZ+XiClzgbqV9Q==}
+
+  '@ethersproject/signing-key@5.8.0':
+    resolution: {integrity: sha512-LrPW2ZxoigFi6U6aVkFN/fa9Yx/+4AtIUe4/HACTvKJdhm0eeb107EVCIQcrLZkxaSIgc/eCrX8Q1GtbH+9n3w==}
+
+  '@ethersproject/strings@5.8.0':
+    resolution: {integrity: sha512-qWEAk0MAvl0LszjdfnZ2uC8xbR2wdv4cDabyHiBh3Cldq/T8dPH3V4BbBsAYJUeonwD+8afVXld274Ls+Y1xXg==}
+
+  '@ethersproject/transactions@5.8.0':
+    resolution: {integrity: sha512-UglxSDjByHG0TuU17bDfCemZ3AnKO2vYrL5/2n2oXvKzvb7Cz+W9gOWXKARjp2URVwcWlQlPOEQyAviKwT4AHg==}
+
+  '@ethersproject/web@5.8.0':
+    resolution: {integrity: sha512-j7+Ksi/9KfGviws6Qtf9Q7KCqRhpwrYKQPs+JBA/rKVFF/yaWLHJEH3zfVP2plVu+eys0d2DlFmhoQJayFewcw==}
+
+  '@fastify/busboy@3.2.0':
+    resolution: {integrity: sha512-m9FVDXU3GT2ITSe0UaMA5rU3QkfC/UXtCU8y0gSN/GugTqtVldOBWIB5V6V3sbmenVZUIpU6f+mPEO2+m5iTaA==}
+
+  '@float-capital/float-subgraph-uncrashable@0.0.0-internal-testing.5':
+    resolution: {integrity: sha512-yZ0H5e3EpAYKokX/AbtplzlvSxEJY7ZfpvQyDzyODkks0hakAAlDG6fQu1SlDJMWorY7bbq1j7fCiFeTWci6TA==}
+    hasBin: true
+
+  '@graphprotocol/graph-cli@0.50.0':
+    resolution: {integrity: sha512-Fw46oN06ec1pf//vTPFzmyL0LRD9ed/XXfibQQClyMLfNlYAATZvz930RH3SHb2N4ZLdfKDDkY1SLgtDghtrow==}
+    engines: {node: '>=14'}
+    hasBin: true
+
+  '@graphprotocol/graph-cli@0.54.0-alpha-20230727052453-1e0e6e5':
+    resolution: {integrity: sha512-pxZAJvUXHRMtPIoMTSvVyIjqrfMGCtaqWG9qdRDrLMxUKrIuGWniMKntxaFnHPlgz6OQznN9Zt8wV6uScD/4Sg==}
+    engines: {node: '>=14'}
+    hasBin: true
+
+  '@graphprotocol/graph-cli@0.60.0':
+    resolution: {integrity: sha512-8tGaQJ0EzAPtkDXCAijFGoVdJXM+pKFlGxjiU31TdG5bS4cIUoSB6yWojVsFFod0yETAwf+giel/0/8sudYsDw==}
+    engines: {node: '>=14'}
+    hasBin: true
+
+  '@graphprotocol/graph-cli@0.69.0':
+    resolution: {integrity: sha512-DoneR0TRkZYumsygdi/RST+OB55TgwmhziredI21lYzfj0QNXGEHZOagTOKeFKDFEpP3KR6BAq6rQIrkprJ1IQ==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  '@graphprotocol/graph-cli@0.98.1':
+    resolution: {integrity: sha512-GrWFcRCBlLcRT+gIGundQl7yyrX3YWUPj66bxThKf5CJvvWXdZoNxrj27dMMqulsSwYmpCkb3YmpCiVJFGdpHw==}
+    engines: {node: '>=20.18.1'}
+    hasBin: true
+
+  '@graphprotocol/graph-ts@0.30.0':
+    resolution: {integrity: sha512-h5tJqlsZXglGYM0PcBsBOqof4PT0Fr4Z3QBTYN/IjMF3VvRX2A8/bdpqaAnva+2N0uAfXXwRcwcOcW5O35yzXw==}
+
+  '@graphprotocol/graph-ts@0.31.0':
+    resolution: {integrity: sha512-xreRVM6ho2BtolyOh2flDkNoGZximybnzUnF53zJVp0+Ed0KnAlO1/KOCUYw06euVI9tk0c9nA2Z/D5SIQV2Rg==}
+
+  '@graphprotocol/graph-ts@0.33.0':
+    resolution: {integrity: sha512-HBUVblHUdjQZ/MEjjYPzVgmh+SiuF9VV0D8KubYfFAtzkqpVJlvdyk+RZTAJUiu8hpyYy0EVIcAnLEPtKlwMGQ==}
+
+  '@graphprotocol/graph-ts@0.34.0':
+    resolution: {integrity: sha512-gnhjai65AV4YMYe9QHGz+HP/jdzI54z/nOfEXZFfh6m987EP2iy3ycLXrTi+ahcogHH7vtoWFdXbUzZbE8bCAg==}
+
+  '@graphprotocol/graph-ts@0.35.0':
+    resolution: {integrity: sha512-dM+I/e/WeBa8Q3m4ZLFfJjKBS9YwV+DLggWi8oEIGmnhPAZ298QB6H4hquvxqaOTSXJ2j9tPsw3xSmbRLwk39A==}
+
+  '@graphprotocol/graph-ts@0.36.0-alpha-20240422133139-8761ea3':
+    resolution: {integrity: sha512-EMSKzLWCsUqHDAR+86EoFnx0tTDgVjABeviSm9hMmT5vJPB0RGP/4fRx/Qvq88QQ5YGEQdU9/9vD8U++h90y0Q==}
+
+  '@graphprotocol/graph-ts@0.36.0-alpha-20241129215038-b75cda9':
+    resolution: {integrity: sha512-DPLx/owGh38n6HCQaxO6rk40zfYw3EYqSvyHp+s3ClMCxQET9x4/hberkOXrPaxxiPxgUTVa6ie4mwc7GTroEw==}
+
+  '@inquirer/checkbox@4.2.1':
+    resolution: {integrity: sha512-bevKGO6kX1eM/N+pdh9leS5L7TBF4ICrzi9a+cbWkrxeAeIcwlo/7OfWGCDERdRCI2/Q6tjltX4bt07ALHDwFw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/confirm@5.1.15':
+    resolution: {integrity: sha512-SwHMGa8Z47LawQN0rog0sT+6JpiL0B7eW9p1Bb7iCeKDGTI5Ez25TSc2l8kw52VV7hA4sX/C78CGkMrKXfuspA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/core@10.1.15':
+    resolution: {integrity: sha512-8xrp836RZvKkpNbVvgWUlxjT4CraKk2q+I3Ksy+seI2zkcE+y6wNs1BVhgcv8VyImFecUhdQrYLdW32pAjwBdA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/editor@4.2.17':
+    resolution: {integrity: sha512-r6bQLsyPSzbWrZZ9ufoWL+CztkSatnJ6uSxqd6N+o41EZC51sQeWOzI6s5jLb+xxTWxl7PlUppqm8/sow241gg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/expand@4.0.17':
+    resolution: {integrity: sha512-PSqy9VmJx/VbE3CT453yOfNa+PykpKg/0SYP7odez1/NWBGuDXgPhp4AeGYYKjhLn5lUUavVS/JbeYMPdH50Mw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/external-editor@1.0.1':
+    resolution: {integrity: sha512-Oau4yL24d2B5IL4ma4UpbQigkVhzPDXLoqy1ggK4gnHg/stmkffJE4oOXHXF3uz0UEpywG68KcyXsyYpA1Re/Q==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/figures@1.0.13':
+    resolution: {integrity: sha512-lGPVU3yO9ZNqA7vTYz26jny41lE7yoQansmqdMLBEfqaGsmdg7V3W9mK9Pvb5IL4EVZ9GnSDGMO/cJXud5dMaw==}
+    engines: {node: '>=18'}
+
+  '@inquirer/input@4.2.1':
+    resolution: {integrity: sha512-tVC+O1rBl0lJpoUZv4xY+WGWY8V5b0zxU1XDsMsIHYregdh7bN5X5QnIONNBAl0K765FYlAfNHS2Bhn7SSOVow==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/number@3.0.17':
+    resolution: {integrity: sha512-GcvGHkyIgfZgVnnimURdOueMk0CztycfC8NZTiIY9arIAkeOgt6zG57G+7vC59Jns3UX27LMkPKnKWAOF5xEYg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/password@4.0.17':
+    resolution: {integrity: sha512-DJolTnNeZ00E1+1TW+8614F7rOJJCM4y4BAGQ3Gq6kQIG+OJ4zr3GLjIjVVJCbKsk2jmkmv6v2kQuN/vriHdZA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/prompts@7.8.3':
+    resolution: {integrity: sha512-iHYp+JCaCRktM/ESZdpHI51yqsDgXu+dMs4semzETftOaF8u5hwlqnbIsuIR/LrWZl8Pm1/gzteK9I7MAq5HTA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/rawlist@4.1.5':
+    resolution: {integrity: sha512-R5qMyGJqtDdi4Ht521iAkNqyB6p2UPuZUbMifakg1sWtu24gc2Z8CJuw8rP081OckNDMgtDCuLe42Q2Kr3BolA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/search@3.1.0':
+    resolution: {integrity: sha512-PMk1+O/WBcYJDq2H7foV0aAZSmDdkzZB9Mw2v/DmONRJopwA/128cS9M/TXWLKKdEQKZnKwBzqu2G4x/2Nqx8Q==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/select@4.3.1':
+    resolution: {integrity: sha512-Gfl/5sqOF5vS/LIrSndFgOh7jgoe0UXEizDqahFRkq5aJBLegZ6WjuMh/hVEJwlFQjyLq1z9fRtvUMkb7jM1LA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@inquirer/type@3.0.8':
+    resolution: {integrity: sha512-lg9Whz8onIHRthWaN1Q9EGLa/0LFJjyM8mEUbL1eTi6yMGvBf8gvyDLtxSXztQsxMvhxxNpJYrwa1YHdq+w4Jw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@types/node': '>=18'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
+  '@ipld/dag-cbor@7.0.3':
+    resolution: {integrity: sha512-1VVh2huHsuohdXC1bGJNE8WR72slZ9XE2T3wbBBq31dm7ZBatmKLLxrB+XAqafxfRFjv08RZmj/W/ZqaM13AuA==}
+
+  '@ipld/dag-cbor@9.2.4':
+    resolution: {integrity: sha512-GbDWYl2fdJgkYtIJN0HY9oO0o50d1nB4EQb7uYWKUd2ztxCjxiEW3PjwGG0nqUpN1G4Cug6LX8NzbA7fKT+zfA==}
+    engines: {node: '>=16.0.0', npm: '>=7.0.0'}
+
+  '@ipld/dag-json@10.2.5':
+    resolution: {integrity: sha512-Q4Fr3IBDEN8gkpgNefynJ4U/ZO5Kwr7WSUMBDbZx0c37t0+IwQCTM9yJh8l5L4SRFjm31MuHwniZ/kM+P7GQ3Q==}
+    engines: {node: '>=16.0.0', npm: '>=7.0.0'}
+
+  '@ipld/dag-json@8.0.11':
+    resolution: {integrity: sha512-Pea7JXeYHTWXRTIhBqBlhw7G53PJ7yta3G/sizGEZyzdeEwhZRr0od5IQ0r2ZxOt1Do+2czddjeEPp+YTxDwCA==}
+
+  '@ipld/dag-pb@2.1.18':
+    resolution: {integrity: sha512-ZBnf2fuX9y3KccADURG5vb9FaOeMjFkCrNysB0PtftME/4iCTjxfaLoNq/IAh5fTqUOMXvryN6Jyka4ZGuMLIg==}
+
+  '@ipld/dag-pb@4.1.5':
+    resolution: {integrity: sha512-w4PZ2yPqvNmlAir7/2hsCRMqny1EY5jj26iZcSgxREJexmbAc2FI21jp26MqiNdfgAxvkCnf2N/TJI18GaDNwA==}
+    engines: {node: '>=16.0.0', npm: '>=7.0.0'}
+
+  '@isaacs/balanced-match@4.0.1':
+    resolution: {integrity: sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==}
+    engines: {node: 20 || >=22}
+
+  '@isaacs/brace-expansion@5.0.0':
+    resolution: {integrity: sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA==}
+    engines: {node: 20 || >=22}
+
+  '@isaacs/cliui@8.0.2':
+    resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
+    engines: {node: '>=12'}
+
+  '@jridgewell/resolve-uri@3.1.2':
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+  '@jridgewell/trace-mapping@0.3.9':
+    resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
+
+  '@leichtgewicht/ip-codec@2.0.5':
+    resolution: {integrity: sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==}
+
+  '@libp2p/crypto@5.1.7':
+    resolution: {integrity: sha512-7DO0piidLEKfCuNfS420BlHG0e2tH7W/zugdsPSiC/1Apa/s1B1dBkaIEgfDkGjrRP4S/8Or86Rtq7zXeEu67g==}
+
+  '@libp2p/interface@2.10.5':
+    resolution: {integrity: sha512-Z52n04Mph/myGdwyExbFi5S/HqrmZ9JOmfLc2v4r2Cik3GRdw98vrGH19PFvvwjLwAjaqsweCtlGaBzAz09YDw==}
+
+  '@libp2p/logger@5.1.21':
+    resolution: {integrity: sha512-V1TWlZM5BuKkiGQ7En4qOnseVP82JwDIpIfNjceUZz1ArL32A5HXJjLQnJchkZ3VW8PVciJzUos/vP6slhPY6Q==}
+
+  '@libp2p/peer-id@5.1.8':
+    resolution: {integrity: sha512-pGaM4BwjnXdGtAtd84L4/wuABpsnFYE+AQ+h3GxNFme0IsTaTVKWd1jBBE5YFeKHBHGUOhF3TlHsdjFfjQA7TA==}
+
+  '@multiformats/dns@1.0.6':
+    resolution: {integrity: sha512-nt/5UqjMPtyvkG9BQYdJ4GfLK3nMqGpFZOzf4hAmIa0sJh2LlS9YKXZ4FgwBDsaHvzZqR/rUFIywIc7pkHNNuw==}
+
+  '@multiformats/multiaddr-to-uri@11.0.2':
+    resolution: {integrity: sha512-SiLFD54zeOJ0qMgo9xv1Tl9O5YktDKAVDP4q4hL16mSq4O4sfFNagNADz8eAofxd6TfQUzGQ3TkRRG9IY2uHRg==}
+
+  '@multiformats/multiaddr@12.5.1':
+    resolution: {integrity: sha512-+DDlr9LIRUS8KncI1TX/FfUn8F2dl6BIxJgshS/yFQCNB5IAF0OGzcwB39g5NLE22s4qqDePv0Qof6HdpJ/4aQ==}
+
+  '@noble/curves@1.4.2':
+    resolution: {integrity: sha512-TavHr8qycMChk8UwMld0ZDRvatedkzWfH8IiaeGCfymOP5i0hSCozz9vHOL0nkwk7HRMlFnAiKpS2jrUmSybcw==}
+
+  '@noble/curves@1.9.7':
+    resolution: {integrity: sha512-gbKGcRUYIjA3/zCCNaWDciTMFI0dCkvou3TL8Zmy5Nc7sJ47a0jtOeZoTaMxkuqRo9cRhjOdZJXegxYE5FN/xw==}
+    engines: {node: ^14.21.3 || >=16}
+
+  '@noble/hashes@1.4.0':
+    resolution: {integrity: sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==}
+    engines: {node: '>= 16'}
+
+  '@noble/hashes@1.8.0':
+    resolution: {integrity: sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==}
+    engines: {node: ^14.21.3 || >=16}
+
+  '@nodelib/fs.scandir@2.1.5':
+    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.stat@2.0.5':
+    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.walk@1.2.8':
+    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
+    engines: {node: '>= 8'}
+
+  '@oclif/core@2.16.0':
+    resolution: {integrity: sha512-dL6atBH0zCZl1A1IXCKJgLPrM/wR7K+Wi401E/IvqsK8m2iCHW+0TEOGrans/cuN3oTW+uxIyJFHJ8Im0k4qBw==}
+    engines: {node: '>=14.0.0'}
+
+  '@oclif/core@2.8.4':
+    resolution: {integrity: sha512-VlFDhoAJ1RDwcpDF46wAlciWTIryapMUViACttY9GwX6Ci6Lud1awe/pC3k4jad5472XshnPQV4bHAl4a/yxpA==}
+    engines: {node: '>=14.0.0'}
+
+  '@oclif/core@2.8.6':
+    resolution: {integrity: sha512-1QlPaHMhOORySCXkQyzjsIsy2GYTilOw3LkjeHkCgsPJQjAT4IclVytJusWktPbYNys9O+O4V23J44yomQvnBQ==}
+    engines: {node: '>=14.0.0'}
+
+  '@oclif/core@4.5.5':
+    resolution: {integrity: sha512-iQzlaJQgPeUXrtrX71OzDwxPikQ7c2FhNd8U8rBB7BCtj2XYfmzBT/Hmbc+g9OKDIG/JkbJT0fXaWMMBrhi+1A==}
+    engines: {node: '>=18.0.0'}
+
+  '@oclif/plugin-autocomplete@2.3.10':
+    resolution: {integrity: sha512-Ow1AR8WtjzlyCtiWWPgzMyT8SbcDJFr47009riLioHa+MHX2BCDtVn2DVnN/E6b9JlPV5ptQpjefoRSNWBesmg==}
+    engines: {node: '>=12.0.0'}
+
+  '@oclif/plugin-autocomplete@3.2.34':
+    resolution: {integrity: sha512-KhbPcNjitAU7jUojMXJ3l7duWVub0L0pEr3r3bLrpJBNuIJhoIJ7p56Ropcb7OMH2xcaz5B8HGq56cTOe1FHEg==}
+    engines: {node: '>=18.0.0'}
+
+  '@oclif/plugin-not-found@2.4.3':
+    resolution: {integrity: sha512-nIyaR4y692frwh7wIHZ3fb+2L6XEecQwRDIb4zbEam0TvaVmBQWZoColQyWA84ljFBPZ8XWiQyTz+ixSwdRkqg==}
+    engines: {node: '>=12.0.0'}
+
+  '@oclif/plugin-not-found@3.2.65':
+    resolution: {integrity: sha512-WgP78eBiRsQYxRIkEui/eyR0l3a2w6LdGMoZTg3DvFwKqZ2X542oUfUmTSqvb19LxdS4uaQ+Mwp4DTVHw5lk/A==}
+    engines: {node: '>=18.0.0'}
+
+  '@oclif/plugin-warn-if-update-available@3.1.46':
+    resolution: {integrity: sha512-YDlr//SHmC80eZrt+0wNFWSo1cOSU60RoWdhSkAoPB3pUGPSNHZDquXDpo7KniinzYPsj1rfetCYk7UVXwYu7A==}
+    engines: {node: '>=18.0.0'}
+
+  '@peculiar/asn1-schema@2.4.0':
+    resolution: {integrity: sha512-umbembjIWOrPSOzEGG5vxFLkeM8kzIhLkgigtsOrfLKnuzxWxejAcUX+q/SoZCdemlODOcr5WiYa7+dIEzBXZQ==}
+
+  '@peculiar/json-schema@1.1.12':
+    resolution: {integrity: sha512-coUfuoMeIB7B8/NMekxaDzLhaYmp0HZNPEjYRm9goRou8UZIC3z21s0sL9AWoCw4EG876QyO3kYrc61WNF9B/w==}
+    engines: {node: '>=8.0.0'}
+
+  '@peculiar/webcrypto@1.5.0':
+    resolution: {integrity: sha512-BRs5XUAwiyCDQMsVA9IDvDa7UBR9gAvPHgugOeGng3YN6vJ9JYonyDc0lNczErgtCWtucjR5N7VtaonboD/ezg==}
+    engines: {node: '>=10.12.0'}
+
+  '@pinax/graph-networks-registry@0.7.1':
+    resolution: {integrity: sha512-Gn2kXRiEd5COAaMY/aDCRO0V+zfb1uQKCu5HFPoWka+EsZW27AlTINA7JctYYYEMuCbjMia5FBOzskjgEvj6LA==}
+
+  '@pnpm/config.env-replace@1.1.0':
+    resolution: {integrity: sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w==}
+    engines: {node: '>=12.22.0'}
+
+  '@pnpm/network.ca-file@1.0.2':
+    resolution: {integrity: sha512-YcPQ8a0jwYU9bTdJDpXjMi7Brhkr1mXsXrUJvjqM2mQDgkRiz8jFaQGOdaLxgjtUfQgZhKy/O3cG/YwmgKaxLA==}
+    engines: {node: '>=12.22.0'}
+
+  '@pnpm/npm-conf@2.3.1':
+    resolution: {integrity: sha512-c83qWb22rNRuB0UaVCI0uRPNRr8Z0FWnEIvT47jiHAmOIUHbBOg5XvV7pM5x+rKn9HRpjxquDbXYSXr3fAKFcw==}
+    engines: {node: '>=12'}
+
+  '@protobufjs/aspromise@1.1.2':
+    resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==}
+
+  '@protobufjs/base64@1.1.2':
+    resolution: {integrity: sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==}
+
+  '@protobufjs/codegen@2.0.4':
+    resolution: {integrity: sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==}
+
+  '@protobufjs/eventemitter@1.1.0':
+    resolution: {integrity: sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==}
+
+  '@protobufjs/fetch@1.1.0':
+    resolution: {integrity: sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==}
+
+  '@protobufjs/float@1.0.2':
+    resolution: {integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==}
+
+  '@protobufjs/inquire@1.1.0':
+    resolution: {integrity: sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==}
+
+  '@protobufjs/path@1.1.2':
+    resolution: {integrity: sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==}
+
+  '@protobufjs/pool@1.1.0':
+    resolution: {integrity: sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==}
+
+  '@protobufjs/utf8@1.1.0':
+    resolution: {integrity: sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==}
+
+  '@rescript/std@9.0.0':
+    resolution: {integrity: sha512-zGzFsgtZ44mgL4Xef2gOy1hrRVdrs9mcxCOOKZrIPsmbZW14yTkaF591GXxpQvjXiHtgZ/iA9qLyWH6oSReIxQ==}
+
+  '@scure/base@1.1.9':
+    resolution: {integrity: sha512-8YKhl8GHiNI/pU2VMaofa2Tor7PJRAjwQLBBuilkJ9L5+13yVbC7JO/wS7piioAvPSwR3JKM1IJ/u4xQzbcXKg==}
+
+  '@scure/bip32@1.4.0':
+    resolution: {integrity: sha512-sVUpc0Vq3tXCkDGYVWGIZTRfnvu8LoTDaev7vbwh0omSvVORONr960MQWdKqJDCReIEmTj3PAr73O3aoxz7OPg==}
+
+  '@scure/bip39@1.3.0':
+    resolution: {integrity: sha512-disdg7gHuTDZtY+ZdkmLpPCk7fxZSu3gBiEGuoC1XYxv9cGx3Z6cpTggCgW6odSOOIXCiDjuGejW+aJKCY/pIQ==}
+
+  '@tsconfig/node10@1.0.11':
+    resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==}
+
+  '@tsconfig/node12@1.0.11':
+    resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==}
+
+  '@tsconfig/node14@1.0.3':
+    resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==}
+
+  '@tsconfig/node16@1.0.4':
+    resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==}
+
+  '@types/bn.js@5.2.0':
+    resolution: {integrity: sha512-DLbJ1BPqxvQhIGbeu8VbUC1DiAiahHtAYvA0ZEAa4P31F7IaArc8z3C3BRQdWX4mtLQuABG4yzp76ZrS02Ui1Q==}
+
+  '@types/cli-progress@3.11.6':
+    resolution: {integrity: sha512-cE3+jb9WRlu+uOSAugewNpITJDt1VF8dHOopPO4IABFc3SXYL5WE/+PTz/FCdZRRfIujiWW3n3aMbv1eIGVRWA==}
+
+  '@types/concat-stream@1.6.1':
+    resolution: {integrity: sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==}
+
+  '@types/connect@3.4.38':
+    resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==}
+
+  '@types/dns-packet@5.6.5':
+    resolution: {integrity: sha512-qXOC7XLOEe43ehtWJCMnQXvgcIpv6rPmQ1jXT98Ad8A3TB1Ue50jsCbSSSyuazScEuZ/Q026vHbrOTVkmwA+7Q==}
+
+  '@types/form-data@0.0.33':
+    resolution: {integrity: sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw==}
+
+  '@types/long@4.0.2':
+    resolution: {integrity: sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==}
+
+  '@types/minimatch@3.0.5':
+    resolution: {integrity: sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ==}
+
+  '@types/node@10.17.60':
+    resolution: {integrity: sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==}
+
+  '@types/node@12.20.55':
+    resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==}
+
+  '@types/node@24.3.0':
+    resolution: {integrity: sha512-aPTXCrfwnDLj4VvXrm+UUCQjNEvJgNA8s5F1cvwQU+3KNltTOkBm1j30uNLyqqPNe7gE3KFzImYoZEfLhp4Yow==}
+
+  '@types/node@8.10.66':
+    resolution: {integrity: sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw==}
+
+  '@types/parse-json@4.0.2':
+    resolution: {integrity: sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==}
+
+  '@types/pbkdf2@3.1.2':
+    resolution: {integrity: sha512-uRwJqmiXmh9++aSu1VNEn3iIxWOhd8AHXNSdlaLfdAAdSTY9jYVeGWnzejM3dvrkbqE3/hyQkQQ29IFATEGlew==}
+
+  '@types/qs@6.14.0':
+    resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==}
+
+  '@types/secp256k1@4.0.6':
+    resolution: {integrity: sha512-hHxJU6PAEUn0TP4S/ZOzuTUvJWuZ6eIKeNKb5RBpODvSl6hp1Wrw4s7ATY50rklRCScUDpHzVA/DQdSjJ3UoYQ==}
+
+  '@types/ws@7.4.7':
+    resolution: {integrity: sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==}
+
+  '@whatwg-node/disposablestack@0.0.6':
+    resolution: {integrity: sha512-LOtTn+JgJvX8WfBVJtF08TGrdjuFzGJc4mkP8EdDI8ADbvO7kiexYep1o8dwnt0okb0jYclCDXF13xU7Ge4zSw==}
+    engines: {node: '>=18.0.0'}
+
+  '@whatwg-node/events@0.0.3':
+    resolution: {integrity: sha512-IqnKIDWfXBJkvy/k6tzskWTc2NK3LcqHlb+KHGCrjOCH4jfQckRX0NAiIcC/vIqQkzLYw2r2CTSwAxcrtcD6lA==}
+
+  '@whatwg-node/fetch@0.10.10':
+    resolution: {integrity: sha512-watz4i/Vv4HpoJ+GranJ7HH75Pf+OkPQ63NoVmru6Srgc8VezTArB00i/oQlnn0KWh14gM42F22Qcc9SU9mo/w==}
+    engines: {node: '>=18.0.0'}
+
+  '@whatwg-node/fetch@0.8.8':
+    resolution: {integrity: sha512-CdcjGC2vdKhc13KKxgsc6/616BQ7ooDIgPeTuAiE8qfCnS0mGzcfCOoZXypQSz73nxI+GWc7ZReIAVhxoE1KCg==}
+
+  '@whatwg-node/node-fetch@0.3.6':
+    resolution: {integrity: sha512-w9wKgDO4C95qnXZRwZTfCmLWqyRnooGjcIwG0wADWjw9/HN0p7dtvtgSvItZtUyNteEvgTrd8QojNEqV6DAGTA==}
+
+  '@whatwg-node/node-fetch@0.7.25':
+    resolution: {integrity: sha512-szCTESNJV+Xd56zU6ShOi/JWROxE9IwCic8o5D9z5QECZloas6Ez5tUuKqXTAdu6fHFx1t6C+5gwj8smzOLjtg==}
+    engines: {node: '>=18.0.0'}
+
+  '@whatwg-node/promise-helpers@1.3.2':
+    resolution: {integrity: sha512-Nst5JdK47VIl9UcGwtv2Rcgyn5lWtZ0/mhRQ4G8NN2isxpq2TO30iqHzmwoJycjWuyUfg3GFXqP/gFHXeV57IA==}
+    engines: {node: '>=16.0.0'}
+
+  JSONStream@1.3.2:
+    resolution: {integrity: sha512-mn0KSip7N4e0UDPZHnqDsHECo5uGQrixQKnAskOM1BIB8hd7QKbd6il8IPRPudPHOeHiECoCFqhyMaRO9+nWyA==}
+    hasBin: true
+
+  JSONStream@1.3.5:
+    resolution: {integrity: sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==}
+    hasBin: true
+
+  abitype@0.7.1:
+    resolution: {integrity: sha512-VBkRHTDZf9Myaek/dO3yMmOzB/y2s3Zo6nVU7yaw1G+TvCHAjwaJzNGN9yo4K5D8bU/VZXKP1EJpRhFr862PlQ==}
+    peerDependencies:
+      typescript: '>=4.9.4'
+      zod: ^3 >=3.19.1
+    peerDependenciesMeta:
+      zod:
+        optional: true
+
+  abort-controller@3.0.0:
+    resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==}
+    engines: {node: '>=6.5'}
+
+  abort-error@1.0.1:
+    resolution: {integrity: sha512-fxqCblJiIPdSXIUrxI0PL+eJG49QdP9SQ70qtB65MVAoMr2rASlOyAbJFOylfB467F/f+5BCLJJq58RYi7mGfg==}
+
+  acorn-walk@8.3.4:
+    resolution: {integrity: sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==}
+    engines: {node: '>=0.4.0'}
+
+  acorn@8.15.0:
+    resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
+  ajv@6.12.6:
+    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
+
+  ansi-colors@4.1.3:
+    resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
+    engines: {node: '>=6'}
+
+  ansi-escapes@4.3.2:
+    resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==}
+    engines: {node: '>=8'}
+
+  ansi-regex@4.1.1:
+    resolution: {integrity: sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==}
+    engines: {node: '>=6'}
+
+  ansi-regex@5.0.1:
+    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+    engines: {node: '>=8'}
+
+  ansi-regex@6.2.0:
+    resolution: {integrity: sha512-TKY5pyBkHyADOPYlRT9Lx6F544mPl0vS5Ew7BJ45hA08Q+t3GjbueLliBWN3sMICk6+y7HdyxSzC4bWS8baBdg==}
+    engines: {node: '>=12'}
+
+  ansi-styles@3.2.1:
+    resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==}
+    engines: {node: '>=4'}
+
+  ansi-styles@4.3.0:
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
+
+  ansi-styles@6.2.1:
+    resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==}
+    engines: {node: '>=12'}
+
+  ansicolors@0.3.2:
+    resolution: {integrity: sha512-QXu7BPrP29VllRxH8GwB7x5iX5qWKAAMLqKQGWTeLWVlNHNOpVMJ91dsxQAIWXpjuW5wqvxu3Jd/nRjrJ+0pqg==}
+
+  ansis@3.17.0:
+    resolution: {integrity: sha512-0qWUglt9JEqLFr3w1I1pbrChn1grhaiAR2ocX1PP/flRmxgtwTzPFFFnfIlD6aMOLQZgSuCRlidD70lvx8yhzg==}
+    engines: {node: '>=14'}
+
+  any-signal@2.1.2:
+    resolution: {integrity: sha512-B+rDnWasMi/eWcajPcCWSlYc7muXOrcYrqgyzcdKisl2H/WTlQ0gip1KyQfr0ZlxJdsuWCj/LWwQm7fhyhRfIQ==}
+
+  any-signal@3.0.1:
+    resolution: {integrity: sha512-xgZgJtKEa9YmDqXodIgl7Fl1C8yNXr8w6gXjqK3LW4GcEiYT+6AQfJSE/8SPsEpLLmcvbv8YU+qet94UewHxqg==}
+
+  any-signal@4.1.1:
+    resolution: {integrity: sha512-iADenERppdC+A2YKbOXXB2WUeABLaM6qnpZ70kZbPZ1cZMMJ7eF+3CaYm+/PhBizgkzlvssC7QuHS30oOiQYWA==}
+    engines: {node: '>=16.0.0', npm: '>=7.0.0'}
+
+  anymatch@3.1.3:
+    resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
+    engines: {node: '>= 8'}
+
+  apisauce@2.1.6:
+    resolution: {integrity: sha512-MdxR391op/FucS2YQRfB/NMRyCnHEPDd4h17LRIuVYi0BpGmMhpxc0shbOpfs5ahABuBEffNCGal5EcsydbBWg==}
+
+  app-module-path@2.2.0:
+    resolution: {integrity: sha512-gkco+qxENJV+8vFcDiiFhuoSvRXb2a/QPqpSoWhVz829VNJfOTnELbBmPmNKFxf3xdNnw4DWCkzkDaavcX/1YQ==}
+
+  arg@4.1.3:
+    resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==}
+
+  argparse@1.0.10:
+    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
+
+  argparse@2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+
+  array-union@2.1.0:
+    resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
+    engines: {node: '>=8'}
+
+  asap@2.0.6:
+    resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==}
+
+  asn1@0.2.6:
+    resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==}
+
+  asn1js@3.0.6:
+    resolution: {integrity: sha512-UOCGPYbl0tv8+006qks/dTgV9ajs97X2p0FAbyS2iyCRrmLSRolDaHdp+v/CLgnzHc3fVB+CwYiUmei7ndFcgA==}
+    engines: {node: '>=12.0.0'}
+
+  assemblyscript@0.19.10:
+    resolution: {integrity: sha512-HavcUBXB3mBTRGJcpvaQjmnmaqKHBGREjSPNsIvnAk2f9dj78y4BkMaSSdvBQYWcDDzsHQjyUC8stICFkD1Odg==}
+    hasBin: true
+
+  assemblyscript@0.19.23:
+    resolution: {integrity: sha512-fwOQNZVTMga5KRsfY80g7cpOl4PsFQczMwHzdtgoqLXaYhkhavufKb0sB0l3T1DUxpAufA0KNhlbpuuhZUwxMA==}
+    hasBin: true
+
+  assert-plus@1.0.0:
+    resolution: {integrity: sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==}
+    engines: {node: '>=0.8'}
+
+  astral-regex@2.0.0:
+    resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==}
+    engines: {node: '>=8'}
+
+  async@3.2.6:
+    resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==}
+
+  asynckit@0.4.0:
+    resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
+
+  at-least-node@1.0.0:
+    resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==}
+    engines: {node: '>= 4.0.0'}
+
+  available-typed-arrays@1.0.7:
+    resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
+    engines: {node: '>= 0.4'}
+
+  aws-sign2@0.7.0:
+    resolution: {integrity: sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==}
+
+  aws4@1.13.2:
+    resolution: {integrity: sha512-lHe62zvbTB5eEABUVi/AwVh0ZKY9rMMDhmm+eeyuuUQbQ3+J+fONVQOZyj+DdrvD4BY33uYniyRJ4UJIaSKAfw==}
+
+  axios@0.21.4:
+    resolution: {integrity: sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==}
+
+  balanced-match@1.0.2:
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+
+  base-x@3.0.11:
+    resolution: {integrity: sha512-xz7wQ8xDhdyP7tQxwdteLYeFfS68tSMNCZ/Y37WJ4bhGfKPpqEIlmIyueQHqOyoPhE6xNUqjzRr8ra0eF9VRvA==}
+
+  base64-js@1.5.1:
+    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
+
+  bcrypt-pbkdf@1.0.2:
+    resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==}
+
+  binary-extensions@2.3.0:
+    resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==}
+    engines: {node: '>=8'}
+
+  binary-install-raw@0.0.13:
+    resolution: {integrity: sha512-v7ms6N/H7iciuk6QInon3/n2mu7oRX+6knJ9xFPsJ3rQePgAqcR3CRTwUheFd8SLbiq4LL7Z4G/44L9zscdt9A==}
+    engines: {node: '>=10'}
+
+  binaryen@101.0.0-nightly.20210723:
+    resolution: {integrity: sha512-eioJNqhHlkguVSbblHOtLqlhtC882SOEPKmNFZaDuz1hzQjolxZ+eu3/kaS10n3sGPONsIZsO7R9fR00UyhEUA==}
+    hasBin: true
+
+  binaryen@102.0.0-nightly.20211028:
+    resolution: {integrity: sha512-GCJBVB5exbxzzvyt8MGDv/MeUjs6gkXDvf4xOIItRBptYl0Tz5sm1o/uG95YK0L0VeG5ajDu3hRtkBP2kzqC5w==}
+    hasBin: true
+
+  bl@1.2.3:
+    resolution: {integrity: sha512-pvcNpa0UU69UT341rO6AYy4FVAIkUHuZXRIWbq+zHnsVcRzDDjIAhGuuYoi0d//cwIwtt4pkpKycWEfjdV+vww==}
+
+  blakejs@1.2.1:
+    resolution: {integrity: sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==}
+
+  blob-to-it@1.0.4:
+    resolution: {integrity: sha512-iCmk0W4NdbrWgRRuxOriU8aM5ijeVLI61Zulsmg/lUHNr7pYjoj+U77opLefNagevtrrbMt3JQ5Qip7ar178kA==}
+
+  blob-to-it@2.0.10:
+    resolution: {integrity: sha512-I39vO57y+LBEIcAV7fif0sn96fYOYVqrPiOD+53MxQGv4DBgt1/HHZh0BHheWx2hVe24q5LTSXxqeV1Y3Nzkgg==}
+
+  bn.js@4.11.6:
+    resolution: {integrity: sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==}
+
+  bn.js@4.12.2:
+    resolution: {integrity: sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==}
+
+  bn.js@5.2.2:
+    resolution: {integrity: sha512-v2YAxEmKaBLahNwE1mjp4WON6huMNeuDvagFZW+ASCuA/ku0bXR9hSMw0XpiqMoA3+rmnyck/tPRSFQkoC9Cuw==}
+
+  brace-expansion@1.1.12:
+    resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==}
+
+  brace-expansion@2.0.2:
+    resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==}
+
+  braces@3.0.3:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
+
+  brorand@1.1.0:
+    resolution: {integrity: sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==}
+
+  browser-readablestream-to-it@1.0.3:
+    resolution: {integrity: sha512-+12sHB+Br8HIh6VAMVEG5r3UXCyESIgDW7kzk3BjIXa43DVqVwL7GC5TW3jeh+72dtcH99pPVpw0X8i0jt+/kw==}
+
+  browser-readablestream-to-it@2.0.10:
+    resolution: {integrity: sha512-I/9hEcRtjct8CzD9sVo9Mm4ntn0D+7tOVrjbPl69XAoOfgJ8NBdOQU+WX+5SHhcELJDb14mWt7zuvyqha+MEAQ==}
+
+  browserify-aes@1.2.0:
+    resolution: {integrity: sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==}
+
+  bs58@4.0.1:
+    resolution: {integrity: sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==}
+
+  bs58check@2.1.2:
+    resolution: {integrity: sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==}
+
+  buffer-alloc-unsafe@1.1.0:
+    resolution: {integrity: sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==}
+
+  buffer-alloc@1.2.0:
+    resolution: {integrity: sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==}
+
+  buffer-crc32@0.2.13:
+    resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==}
+
+  buffer-fill@1.0.0:
+    resolution: {integrity: sha512-T7zexNBwiiaCOGDg9xNX9PBmjrubblRkENuptryuI64URkXDFum9il/JGL8Lm8wYfAXpredVXXZz7eMHilimiQ==}
+
+  buffer-from@1.1.2:
+    resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
+
+  buffer-xor@1.0.3:
+    resolution: {integrity: sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==}
+
+  buffer@5.7.1:
+    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
+
+  buffer@6.0.3:
+    resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==}
+
+  bufferutil@4.0.9:
+    resolution: {integrity: sha512-WDtdLmJvAuNNPzByAYpRo2rF1Mmradw6gvWsQKf63476DDXmomT9zUiGypLcG4ibIM67vhAj8jJRdbmEws2Aqw==}
+    engines: {node: '>=6.14.2'}
+
+  bundle-name@4.1.0:
+    resolution: {integrity: sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==}
+    engines: {node: '>=18'}
+
+  busboy@1.6.0:
+    resolution: {integrity: sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==}
+    engines: {node: '>=10.16.0'}
+
+  call-bind-apply-helpers@1.0.2:
+    resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
+    engines: {node: '>= 0.4'}
+
+  call-bind@1.0.8:
+    resolution: {integrity: sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==}
+    engines: {node: '>= 0.4'}
+
+  call-bound@1.0.4:
+    resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
+    engines: {node: '>= 0.4'}
+
+  callsites@3.1.0:
+    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+    engines: {node: '>=6'}
+
+  cardinal@2.1.1:
+    resolution: {integrity: sha512-JSr5eOgoEymtYHBjNWyjrMqet9Am2miJhlfKNdqLp6zoeAh0KN5dRAcxlecj5mAJrmQomgiOBj35xHLrFjqBpw==}
+    hasBin: true
+
+  caseless@0.12.0:
+    resolution: {integrity: sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==}
+
+  cborg@1.10.2:
+    resolution: {integrity: sha512-b3tFPA9pUr2zCUiCfRd2+wok2/LBSNUMKOuRRok+WlvvAgEt/PlbgPTsZUcwCOs53IJvLgTp0eotwtosE6njug==}
+    hasBin: true
+
+  cborg@4.2.13:
+    resolution: {integrity: sha512-HAiZCITe/5Av0ukt6rOYE+VjnuFGfujN3NUKgEbIlONpRpsYMZAa+Bjk16mj6dQMuB0n81AuNrcB9YVMshcrfA==}
+    hasBin: true
+
+  chalk@2.4.2:
+    resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==}
+    engines: {node: '>=4'}
+
+  chalk@3.0.0:
+    resolution: {integrity: sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==}
+    engines: {node: '>=8'}
+
+  chalk@4.1.2:
+    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
+    engines: {node: '>=10'}
+
+  chardet@2.1.0:
+    resolution: {integrity: sha512-bNFETTG/pM5ryzQ9Ad0lJOTa6HWD/YsScAR3EnCPZRPlQh77JocYktSHOUHelyhm8IARL+o4c4F1bP5KVOjiRA==}
+
+  chokidar@3.5.3:
+    resolution: {integrity: sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==}
+    engines: {node: '>= 8.10.0'}
+
+  chokidar@4.0.3:
+    resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==}
+    engines: {node: '>= 14.16.0'}
+
+  chownr@1.1.4:
+    resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==}
+
+  chownr@2.0.0:
+    resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==}
+    engines: {node: '>=10'}
+
+  cipher-base@1.0.6:
+    resolution: {integrity: sha512-3Ek9H3X6pj5TgenXYtNWdaBon1tgYCaebd+XPg0keyjEbEfkD4KkmAxkQ/i1vYvxdcT5nscLBfq9VJRmCBcFSw==}
+    engines: {node: '>= 0.10'}
+
+  clean-stack@3.0.1:
+    resolution: {integrity: sha512-lR9wNiMRcVQjSB3a7xXGLuz4cr4wJuuXlaAEbRutGowQTmlp7R72/DOgN21e8jdwblMWl9UOJMJXarX94pzKdg==}
+    engines: {node: '>=10'}
+
+  cli-cursor@3.1.0:
+    resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==}
+    engines: {node: '>=8'}
+
+  cli-progress@3.12.0:
+    resolution: {integrity: sha512-tRkV3HJ1ASwm19THiiLIXLO7Im7wlTuKnvkYaTkyoAPefqjNg7W7DHKUlGRxy9vxDvbyCYQkQozvptuMkGCg8A==}
+    engines: {node: '>=4'}
+
+  cli-spinners@2.9.2:
+    resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==}
+    engines: {node: '>=6'}
+
+  cli-table3@0.6.0:
+    resolution: {integrity: sha512-gnB85c3MGC7Nm9I/FkiasNBOKjOiO1RNuXXarQms37q4QMpWdlbBgD/VnOStA2faG1dpXMv31RFApjX1/QdgWQ==}
+    engines: {node: 10.* || >= 12.*}
+
+  cli-width@4.1.0:
+    resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==}
+    engines: {node: '>= 12'}
+
+  clone@1.0.4:
+    resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==}
+    engines: {node: '>=0.8'}
+
+  color-convert@1.9.3:
+    resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}
+
+  color-convert@2.0.1:
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
+
+  color-name@1.1.3:
+    resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==}
+
+  color-name@1.1.4:
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+
+  colors@1.4.0:
+    resolution: {integrity: sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==}
+    engines: {node: '>=0.1.90'}
+
+  combined-stream@1.0.8:
+    resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
+    engines: {node: '>= 0.8'}
+
+  commander@2.20.3:
+    resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
+
+  concat-map@0.0.1:
+    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
+
+  concat-stream@1.6.2:
+    resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==}
+    engines: {'0': node >= 0.8}
+
+  config-chain@1.1.13:
+    resolution: {integrity: sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==}
+
+  content-type@1.0.5:
+    resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
+    engines: {node: '>= 0.6'}
+
+  core-util-is@1.0.2:
+    resolution: {integrity: sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==}
+
+  core-util-is@1.0.3:
+    resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
+
+  cosmiconfig@7.0.1:
+    resolution: {integrity: sha512-a1YWNUV2HwGimB7dU2s1wUMurNKjpx60HxBB6xUM8Re+2s1g1IIfJvFR0/iCF+XHdE0GMTKTuLR32UQff4TEyQ==}
+    engines: {node: '>=10'}
+
+  create-hash@1.1.3:
+    resolution: {integrity: sha512-snRpch/kwQhcdlnZKYanNF1m0RDlrCdSKQaH87w1FCFPVPNCQ/Il9QJKAX2jVBZddRdaHBMC+zXa9Gw9tmkNUA==}
+
+  create-hash@1.2.0:
+    resolution: {integrity: sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==}
+
+  create-hmac@1.1.7:
+    resolution: {integrity: sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==}
+
+  create-require@1.1.1:
+    resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
+
+  cross-spawn@7.0.3:
+    resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==}
+    engines: {node: '>= 8'}
+
+  cross-spawn@7.0.6:
+    resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
+    engines: {node: '>= 8'}
+
+  dag-jose@5.1.1:
+    resolution: {integrity: sha512-9alfZ8Wh1XOOMel8bMpDqWsDT72ojFQCJPtwZSev9qh4f8GoCV9qrJW8jcOUhcstO8Kfm09FHGo//jqiZq3z9w==}
+
+  dashdash@1.14.1:
+    resolution: {integrity: sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==}
+    engines: {node: '>=0.10'}
+
+  debug@3.2.7:
+    resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  debug@4.3.4:
+    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  debug@4.4.1:
+    resolution: {integrity: sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  decompress-tar@4.1.1:
+    resolution: {integrity: sha512-JdJMaCrGpB5fESVyxwpCx4Jdj2AagLmv3y58Qy4GE6HMVjWz1FeVQk1Ct4Kye7PftcdOo/7U7UKzYBJgqnGeUQ==}
+    engines: {node: '>=4'}
+
+  decompress-tarbz2@4.1.1:
+    resolution: {integrity: sha512-s88xLzf1r81ICXLAVQVzaN6ZmX4A6U4z2nMbOwobxkLoIIfjVMBg7TeguTUXkKeXni795B6y5rnvDw7rxhAq9A==}
+    engines: {node: '>=4'}
+
+  decompress-targz@4.1.1:
+    resolution: {integrity: sha512-4z81Znfr6chWnRDNfFNqLwPvm4db3WuZkqV+UgXQzSngG3CEKdBkw5jrv3axjjL96glyiiKjsxJG3X6WBZwX3w==}
+    engines: {node: '>=4'}
+
+  decompress-unzip@4.0.1:
+    resolution: {integrity: sha512-1fqeluvxgnn86MOh66u8FjbtJpAFv5wgCT9Iw8rcBqQcCo5tO8eiJw7NNTrvt9n4CRBVq7CstiS922oPgyGLrw==}
+    engines: {node: '>=4'}
+
+  decompress@4.2.1:
+    resolution: {integrity: sha512-e48kc2IjU+2Zw8cTb6VZcJQ3lgVbS4uuB1TfCHbiZIP/haNXm+SVyhu+87jts5/3ROpd82GSVCoNs/z8l4ZOaQ==}
+    engines: {node: '>=4'}
+
+  default-browser-id@5.0.0:
+    resolution: {integrity: sha512-A6p/pu/6fyBcA1TRz/GqWYPViplrftcW2gZC9q79ngNCKAeR/X3gcEdXQHl4KNXV+3wgIJ1CPkJQ3IHM6lcsyA==}
+    engines: {node: '>=18'}
+
+  default-browser@5.2.1:
+    resolution: {integrity: sha512-WY/3TUME0x3KPYdRRxEJJvXRHV4PyPoUsxtZa78lwItwRQRHhd2U9xOscaT/YTf8uCXIAjeJOFBVEh/7FtD8Xg==}
+    engines: {node: '>=18'}
+
+  defaults@1.0.4:
+    resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==}
+
+  define-data-property@1.1.4:
+    resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==}
+    engines: {node: '>= 0.4'}
+
+  define-lazy-prop@3.0.0:
+    resolution: {integrity: sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==}
+    engines: {node: '>=12'}
+
+  delay@5.0.0:
+    resolution: {integrity: sha512-ReEBKkIfe4ya47wlPYf/gu5ib6yUG0/Aez0JQZQz94kiWtRQvZIQbTiehsnwHvLSWJnQdhVeqYue7Id1dKr0qw==}
+    engines: {node: '>=10'}
+
+  delayed-stream@1.0.0:
+    resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}
+    engines: {node: '>=0.4.0'}
+
+  diff@4.0.2:
+    resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
+    engines: {node: '>=0.3.1'}
+
+  dir-glob@3.0.1:
+    resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
+    engines: {node: '>=8'}
+
+  dns-over-http-resolver@1.2.3:
+    resolution: {integrity: sha512-miDiVSI6KSNbi4SVifzO/reD8rMnxgrlnkrlkugOLQpWQTe2qMdHsZp5DmfKjxNE+/T3VAAYLQUZMv9SMr6+AA==}
+
+  dns-packet@5.6.1:
+    resolution: {integrity: sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==}
+    engines: {node: '>=6'}
+
+  docker-compose@0.23.19:
+    resolution: {integrity: sha512-v5vNLIdUqwj4my80wxFDkNH+4S85zsRuH29SO7dCWVWPCMt/ohZBsGN6g6KXWifT0pzQ7uOxqEKCYCDPJ8Vz4g==}
+    engines: {node: '>= 6.0.0'}
+
+  docker-compose@1.3.0:
+    resolution: {integrity: sha512-7Gevk/5eGD50+eMD+XDnFnOrruFkL0kSd7jEG4cjmqweDSUhB7i0g8is/nBdVpl+Bx338SqIB2GLKm32M+Vs6g==}
+    engines: {node: '>= 6.0.0'}
+
+  docker-modem@1.0.9:
+    resolution: {integrity: sha512-lVjqCSCIAUDZPAZIeyM125HXfNvOmYYInciphNrLrylUtKyW66meAjSPXWchKVzoIYZx69TPnAepVSSkeawoIw==}
+    engines: {node: '>= 0.8'}
+
+  dockerode@2.5.8:
+    resolution: {integrity: sha512-+7iOUYBeDTScmOmQqpUYQaE7F4vvIt6+gIZNHWhqAQEI887tiPFB9OvXI/HzQYqfUNvukMK+9myLW63oTJPZpw==}
+    engines: {node: '>= 0.8'}
+
+  dunder-proto@1.0.1:
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
+
+  eastasianwidth@0.2.0:
+    resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
+
+  ecc-jsbn@0.1.2:
+    resolution: {integrity: sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==}
+
+  ejs@3.1.10:
+    resolution: {integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==}
+    engines: {node: '>=0.10.0'}
+    hasBin: true
+
+  ejs@3.1.6:
+    resolution: {integrity: sha512-9lt9Zse4hPucPkoP7FHDF0LQAlGyF9JVpnClFLFH3aSSbxmyoqINRpp/9wePWJTUl4KOQwRL72Iw3InHPDkoGw==}
+    engines: {node: '>=0.10.0'}
+    hasBin: true
+
+  ejs@3.1.8:
+    resolution: {integrity: sha512-/sXZeMlhS0ArkfX2Aw780gJzXSMPnKjtspYZv+f3NiKLlubezAHDU5+9xz6gd3/NhG3txQCo6xlglmTS+oTGEQ==}
+    engines: {node: '>=0.10.0'}
+    hasBin: true
+
+  electron-fetch@1.9.1:
+    resolution: {integrity: sha512-M9qw6oUILGVrcENMSRRefE1MbHPIz0h79EKIeJWK9v563aT9Qkh8aEHPO1H5vi970wPirNY+jO9OpFoLiMsMGA==}
+    engines: {node: '>=6'}
+
+  elliptic@6.6.1:
+    resolution: {integrity: sha512-RaddvvMatK2LJHqFJ+YA4WysVN5Ita9E35botqIYspQ4TkRAlCicdzKOjlyv/1Za5RyTNn7di//eEV0uTAfe3g==}
+
+  emoji-regex@8.0.0:
+    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
+
+  emoji-regex@9.2.2:
+    resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
+
+  encoding@0.1.13:
+    resolution: {integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==}
+
+  end-of-stream@1.4.5:
+    resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==}
+
+  enquirer@2.3.6:
+    resolution: {integrity: sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==}
+    engines: {node: '>=8.6'}
+
+  err-code@3.0.1:
+    resolution: {integrity: sha512-GiaH0KJUewYok+eeY05IIgjtAe4Yltygk9Wqp1V5yVWLdhf0hYZchRjNIT9bb0mSwRcIusT3cx7PJUf3zEIfUA==}
+
+  error-ex@1.3.2:
+    resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}
+
+  es-define-property@1.0.1:
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
+
+  es-errors@1.3.0:
+    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
+    engines: {node: '>= 0.4'}
+
+  es-object-atoms@1.1.1:
+    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
+    engines: {node: '>= 0.4'}
+
+  es-set-tostringtag@2.1.0:
+    resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
+    engines: {node: '>= 0.4'}
+
+  es6-promise@4.2.8:
+    resolution: {integrity: sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==}
+
+  es6-promisify@5.0.0:
+    resolution: {integrity: sha512-C+d6UdsYDk0lMebHNR4S2NybQMMngAOnOwYBQjTOiv0MkoJMP0Myw2mgpDLBcpfCmRLxyFqYhS/CfOENq4SJhQ==}
+
+  escape-string-regexp@1.0.5:
+    resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==}
+    engines: {node: '>=0.8.0'}
+
+  escape-string-regexp@4.0.0:
+    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
+    engines: {node: '>=10'}
+
+  esprima@4.0.1:
+    resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  ethereum-bloom-filters@1.2.0:
+    resolution: {integrity: sha512-28hyiE7HVsWubqhpVLVmZXFd4ITeHi+BUu05o9isf0GUpMtzBUi+8/gFrGaGYzvGAJQmJ3JKj77Mk9G98T84rA==}
+
+  ethereum-cryptography@0.1.3:
+    resolution: {integrity: sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==}
+
+  ethereum-cryptography@2.2.1:
+    resolution: {integrity: sha512-r/W8lkHSiTLxUxW8Rf3u4HGB0xQweG2RyETjywylKZSzLWoWAijRz8WCuOtJ6wah+avllXBqZuk29HCCvhEIRg==}
+
+  ethereumjs-util@7.1.5:
+    resolution: {integrity: sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==}
+    engines: {node: '>=10.0.0'}
+
+  ethjs-unit@0.1.6:
+    resolution: {integrity: sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw==}
+    engines: {node: '>=6.5.0', npm: '>=3'}
+
+  event-target-shim@5.0.1:
+    resolution: {integrity: sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==}
+    engines: {node: '>=6'}
+
+  eventemitter3@5.0.1:
+    resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==}
+
+  evp_bytestokey@1.0.3:
+    resolution: {integrity: sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==}
+
+  execa@5.1.1:
+    resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
+    engines: {node: '>=10'}
+
+  extend@3.0.2:
+    resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
+
+  extsprintf@1.3.0:
+    resolution: {integrity: sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==}
+    engines: {'0': node >=0.6.0}
+
+  eyes@0.1.8:
+    resolution: {integrity: sha512-GipyPsXO1anza0AOZdy69Im7hGFCNB7Y/NGjDlZGJ3GJJLtwNSb2vrzYrTYJRrRloVx7pl+bhUaTB8yiccPvFQ==}
+    engines: {node: '> 0.1.90'}
+
+  fast-decode-uri-component@1.0.1:
+    resolution: {integrity: sha512-WKgKWg5eUxvRZGwW8FvfbaH7AXSh2cL+3j5fMGzUMCxWBJ3dV3a7Wz8y2f/uQ0e3B6WmodD3oS54jTQ9HVTIIg==}
+
+  fast-deep-equal@3.1.3:
+    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
+
+  fast-fifo@1.3.2:
+    resolution: {integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==}
+
+  fast-glob@3.3.3:
+    resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
+    engines: {node: '>=8.6.0'}
+
+  fast-json-stable-stringify@2.1.0:
+    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
+
+  fast-levenshtein@3.0.0:
+    resolution: {integrity: sha512-hKKNajm46uNmTlhHSyZkmToAc56uZJwYq7yrciZjqOxnlfQwERDQJmHPUp7m1m9wx8vgOe8IaCKZ5Kv2k1DdCQ==}
+
+  fast-querystring@1.1.2:
+    resolution: {integrity: sha512-g6KuKWmFXc0fID8WWH0jit4g0AGBoJhCkJMb1RmbsSEUNvQ+ZC8D6CUZ+GtF8nMzSPXnhiePyyqqipzNNEnHjg==}
+
+  fast-url-parser@1.1.3:
+    resolution: {integrity: sha512-5jOCVXADYNuRkKFzNJ0dCCewsZiYo0dz8QNYljkOpFC6r2U4OBmKtvm/Tsuh4w1YYdDqDb31a8TVhBJ2OJKdqQ==}
+
+  fastest-levenshtein@1.0.16:
+    resolution: {integrity: sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==}
+    engines: {node: '>= 4.9.1'}
+
+  fastq@1.19.1:
+    resolution: {integrity: sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==}
+
+  fd-slicer@1.1.0:
+    resolution: {integrity: sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==}
+
+  fdir@6.5.0:
+    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+    engines: {node: '>=12.0.0'}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
+  file-type@3.9.0:
+    resolution: {integrity: sha512-RLoqTXE8/vPmMuTI88DAzhMYC99I8BWv7zYP4A1puo5HIjEJ5EX48ighy4ZyKMG9EDXxBgW6e++cn7d1xuFghA==}
+    engines: {node: '>=0.10.0'}
+
+  file-type@5.2.0:
+    resolution: {integrity: sha512-Iq1nJ6D2+yIO4c8HHg4fyVb8mAJieo1Oloy1mLLaB2PvezNedhBVm+QU7g0qM42aiMbRXTxKKwGD17rjKNJYVQ==}
+    engines: {node: '>=4'}
+
+  file-type@6.2.0:
+    resolution: {integrity: sha512-YPcTBDV+2Tm0VqjybVd32MHdlEGAtuxS3VAYsumFokDSMG+ROT5wawGlnHDoz7bfMcMDt9hxuXvXwoKUx2fkOg==}
+    engines: {node: '>=4'}
+
+  filelist@1.0.4:
+    resolution: {integrity: sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==}
+
+  fill-range@7.1.1:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
+
+  follow-redirects@1.15.11:
+    resolution: {integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+
+  for-each@0.3.5:
+    resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==}
+    engines: {node: '>= 0.4'}
+
+  foreground-child@3.3.1:
+    resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
+    engines: {node: '>=14'}
+
+  forever-agent@0.6.1:
+    resolution: {integrity: sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==}
+
+  form-data@2.3.3:
+    resolution: {integrity: sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==}
+    engines: {node: '>= 0.12'}
+
+  form-data@2.5.5:
+    resolution: {integrity: sha512-jqdObeR2rxZZbPSGL+3VckHMYtu+f9//KXBsVny6JSX/pa38Fy+bGjuG8eW/H6USNQWhLi8Num++cU2yOCNz4A==}
+    engines: {node: '>= 0.12'}
+
+  fs-constants@1.0.0:
+    resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
+
+  fs-extra@11.3.2:
+    resolution: {integrity: sha512-Xr9F6z6up6Ws+NjzMCZc6WXg2YFRlrLP9NQDO3VQrWrfiojdhS56TzueT88ze0uBdCTwEIhQ3ptnmKeWGFAe0A==}
+    engines: {node: '>=14.14'}
+
+  fs-extra@9.1.0:
+    resolution: {integrity: sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==}
+    engines: {node: '>=10'}
+
+  fs-jetpack@4.3.1:
+    resolution: {integrity: sha512-dbeOK84F6BiQzk2yqqCVwCPWTxAvVGJ3fMQc6E2wuEohS28mR6yHngbrKuVCK1KHRx/ccByDylqu4H5PCP2urQ==}
+
+  fs-minipass@2.1.0:
+    resolution: {integrity: sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==}
+    engines: {node: '>= 8'}
+
+  fs.realpath@1.0.0:
+    resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==}
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  function-bind@1.1.2:
+    resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
+
+  get-intrinsic@1.3.0:
+    resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
+    engines: {node: '>= 0.4'}
+
+  get-iterator@1.0.2:
+    resolution: {integrity: sha512-v+dm9bNVfOYsY1OrhaCrmyOcYoSeVvbt+hHZ0Au+T+p1y+0Uyj9aMaGIeUTT6xdpRbWzDeYKvfOslPhggQMcsg==}
+
+  get-package-type@0.1.0:
+    resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==}
+    engines: {node: '>=8.0.0'}
+
+  get-port@3.2.0:
+    resolution: {integrity: sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==}
+    engines: {node: '>=4'}
+
+  get-proto@1.0.1:
+    resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
+    engines: {node: '>= 0.4'}
+
+  get-stream@2.3.1:
+    resolution: {integrity: sha512-AUGhbbemXxrZJRD5cDvKtQxLuYaIbNtDTK8YqupCI393Q2KSTreEsLUN3ZxAWFGiKTzL6nKuzfcIvieflUX9qA==}
+    engines: {node: '>=0.10.0'}
+
+  get-stream@6.0.1:
+    resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
+    engines: {node: '>=10'}
+
+  getpass@0.1.7:
+    resolution: {integrity: sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==}
+
+  glob-parent@5.1.2:
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
+
+  glob@11.0.3:
+    resolution: {integrity: sha512-2Nim7dha1KVkaiF4q6Dj+ngPPMdfvLJEOpZk/jKiUAkqKebpGAWQXAq9z1xu9HKu5lWfqw/FASuccEjyznjPaA==}
+    engines: {node: 20 || >=22}
+    hasBin: true
+
+  glob@7.2.3:
+    resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
+    deprecated: Glob versions prior to v9 are no longer supported
+
+  glob@9.3.5:
+    resolution: {integrity: sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  globby@11.1.0:
+    resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
+    engines: {node: '>=10'}
+
+  gluegun@5.1.2:
+    resolution: {integrity: sha512-Cwx/8S8Z4YQg07a6AFsaGnnnmd8mN17414NcPS3OoDtZRwxgsvwRNJNg69niD6fDa8oNwslCG0xH7rEpRNNE/g==}
+    hasBin: true
+
+  gluegun@5.1.6:
+    resolution: {integrity: sha512-9zbi4EQWIVvSOftJWquWzr9gLX2kaDgPkNR5dYWbM53eVvCI3iKuxLlnKoHC0v4uPoq+Kr/+F569tjoFbA4DSA==}
+    hasBin: true
+
+  gluegun@5.2.0:
+    resolution: {integrity: sha512-jSUM5xUy2ztYFQANne17OUm/oAd7qSX7EBksS9bQDt9UvLPqcEkeWUebmaposb8Tx7eTTD8uJVWGRe6PYSsYkg==}
+    hasBin: true
+
+  gopd@1.2.0:
+    resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
+    engines: {node: '>= 0.4'}
+
+  graceful-fs@4.2.10:
+    resolution: {integrity: sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==}
+
+  graceful-fs@4.2.11:
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
+
+  graphql-import-node@0.0.5:
+    resolution: {integrity: sha512-OXbou9fqh9/Lm7vwXT0XoRN9J5+WCYKnbiTalgFDvkQERITRmcfncZs6aVABedd5B85yQU5EULS4a5pnbpuI0Q==}
+    peerDependencies:
+      graphql: '*'
+
+  graphql@15.5.0:
+    resolution: {integrity: sha512-OmaM7y0kaK31NKG31q4YbD2beNYa6jBBKtMFT6gLYJljHLJr42IqJ8KX08u3Li/0ifzTU5HjmoOOrwa5BRLeDA==}
+    engines: {node: '>= 10.x'}
+
+  graphql@16.11.0:
+    resolution: {integrity: sha512-mS1lbMsxgQj6hge1XZ6p7GPhbrtFwUFYi3wRzXAC/FmYnyXMTvvI3td3rjmQ2u8ewXueaSvRPWaEcgVVOT9Jnw==}
+    engines: {node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0}
+
+  har-schema@2.0.0:
+    resolution: {integrity: sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==}
+    engines: {node: '>=4'}
+
+  har-validator@5.1.5:
+    resolution: {integrity: sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==}
+    engines: {node: '>=6'}
+    deprecated: this library is no longer supported
+
+  has-flag@3.0.0:
+    resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==}
+    engines: {node: '>=4'}
+
+  has-flag@4.0.0:
+    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+    engines: {node: '>=8'}
+
+  has-property-descriptors@1.0.2:
+    resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==}
+
+  has-symbols@1.1.0:
+    resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
+    engines: {node: '>= 0.4'}
+
+  has-tostringtag@1.0.2:
+    resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
+    engines: {node: '>= 0.4'}
+
+  hash-base@2.0.2:
+    resolution: {integrity: sha512-0TROgQ1/SxE6KmxWSvXHvRj90/Xo1JvZShofnYF+f6ZsGtR4eES7WfrQzPalmyagfKZCXpVnitiRebZulWsbiw==}
+
+  hash-base@3.1.0:
+    resolution: {integrity: sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==}
+    engines: {node: '>=4'}
+
+  hash.js@1.1.7:
+    resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==}
+
+  hashlru@2.3.0:
+    resolution: {integrity: sha512-0cMsjjIC8I+D3M44pOQdsy0OHXGLVz6Z0beRuufhKa0KfaD2wGwAev6jILzXsd3/vpnNQJmWyZtIILqM1N+n5A==}
+
+  hasown@2.0.2:
+    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+    engines: {node: '>= 0.4'}
+
+  hmac-drbg@1.0.1:
+    resolution: {integrity: sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==}
+
+  http-basic@8.1.3:
+    resolution: {integrity: sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw==}
+    engines: {node: '>=6.0.0'}
+
+  http-call@5.3.0:
+    resolution: {integrity: sha512-ahwimsC23ICE4kPl9xTBjKB4inbRaeLyZeRunC/1Jy/Z6X8tv22MEAjK+KBOMSVLaqXPTTmd8638waVIKLGx2w==}
+    engines: {node: '>=8.0.0'}
+
+  http-response-object@3.0.2:
+    resolution: {integrity: sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA==}
+
+  http-signature@1.2.0:
+    resolution: {integrity: sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==}
+    engines: {node: '>=0.8', npm: '>=1.3.7'}
+
+  human-signals@2.1.0:
+    resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
+    engines: {node: '>=10.17.0'}
+
+  hyperlinker@1.0.0:
+    resolution: {integrity: sha512-Ty8UblRWFEcfSuIaajM34LdPXIhbs1ajEX/BBPv24J+enSVaEVY63xQ6lTO9VRYS5LAoghIG0IDJ+p+IPzKUQQ==}
+    engines: {node: '>=4'}
+
+  iconv-lite@0.6.3:
+    resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
+    engines: {node: '>=0.10.0'}
+
+  ieee754@1.2.1:
+    resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
+
+  ignore@5.3.2:
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
+
+  immutable@4.2.1:
+    resolution: {integrity: sha512-7WYV7Q5BTs0nlQm7tl92rDYYoyELLKHoDMBKhrxEoiV4mrfVdRz8hzPiYOzH7yWjzoVEamxRuAqhxL2PLRwZYQ==}
+
+  immutable@5.1.4:
+    resolution: {integrity: sha512-p6u1bG3YSnINT5RQmx/yRZBpenIl30kVxkTLDyHLIMk0gict704Q9n+thfDI7lTRm9vXdDYutVzXhzcThxTnXA==}
+
+  import-fresh@3.3.1:
+    resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
+    engines: {node: '>=6'}
+
+  indent-string@4.0.0:
+    resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==}
+    engines: {node: '>=8'}
+
+  inflight@1.0.6:
+    resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
+    deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.
+
+  inherits@2.0.4:
+    resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
+
+  ini@1.3.8:
+    resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
+
+  interface-datastore@6.1.1:
+    resolution: {integrity: sha512-AmCS+9CT34pp2u0QQVXjKztkuq3y5T+BIciuiHDDtDZucZD8VudosnSdUyXJV6IsRkN5jc4RFDhCk1O6Q3Gxjg==}
+
+  interface-datastore@8.3.2:
+    resolution: {integrity: sha512-R3NLts7pRbJKc3qFdQf+u40hK8XWc0w4Qkx3OFEstC80VoaDUABY/dXA2EJPhtNC+bsrf41Ehvqb6+pnIclyRA==}
+
+  interface-store@2.0.2:
+    resolution: {integrity: sha512-rScRlhDcz6k199EkHqT8NpM87ebN89ICOzILoBHgaG36/WX50N32BnU/kpZgCGPLhARRAWUUX5/cyaIjt7Kipg==}
+
+  interface-store@6.0.3:
+    resolution: {integrity: sha512-+WvfEZnFUhRwFxgz+QCQi7UC6o9AM0EHM9bpIe2Nhqb100NHCsTvNAn4eJgvgV2/tmLo1MP9nGxQKEcZTAueLA==}
+
+  ip-regex@4.3.0:
+    resolution: {integrity: sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==}
+    engines: {node: '>=8'}
+
+  ipfs-core-types@0.9.0:
+    resolution: {integrity: sha512-VJ8vJSHvI1Zm7/SxsZo03T+zzpsg8pkgiIi5hfwSJlsrJ1E2v68QPlnLshGHUSYw89Oxq0IbETYl2pGTFHTWfg==}
+    deprecated: js-IPFS has been deprecated in favour of Helia - please see https://github.com/ipfs/js-ipfs/issues/4336 for details
+
+  ipfs-core-utils@0.13.0:
+    resolution: {integrity: sha512-HP5EafxU4/dLW3U13CFsgqVO5Ika8N4sRSIb/dTg16NjLOozMH31TXV0Grtu2ZWo1T10ahTzMvrfT5f4mhioXw==}
+    deprecated: js-IPFS has been deprecated in favour of Helia - please see https://github.com/ipfs/js-ipfs/issues/4336 for details
+
+  ipfs-http-client@55.0.0:
+    resolution: {integrity: sha512-GpvEs7C7WL9M6fN/kZbjeh4Y8YN7rY8b18tVWZnKxRsVwM25cIFrRI8CwNt3Ugin9yShieI3i9sPyzYGMrLNnQ==}
+    engines: {node: '>=14.0.0', npm: '>=3.0.0'}
+    deprecated: js-IPFS has been deprecated in favour of Helia - please see https://github.com/ipfs/js-ipfs/issues/4336 for details
+
+  ipfs-unixfs@11.2.5:
+    resolution: {integrity: sha512-uasYJ0GLPbViaTFsOLnL9YPjX5VmhnqtWRriogAHOe4ApmIi9VAOFBzgDHsUW2ub4pEa/EysbtWk126g2vkU/g==}
+
+  ipfs-unixfs@6.0.9:
+    resolution: {integrity: sha512-0DQ7p0/9dRB6XCb0mVCTli33GzIzSVx5udpJuVM47tGcD+W+Bl4LsnoLswd3ggNnNEakMv1FdoFITiEnchXDqQ==}
+    engines: {node: '>=16.0.0', npm: '>=7.0.0'}
+
+  ipfs-utils@9.0.14:
+    resolution: {integrity: sha512-zIaiEGX18QATxgaS0/EOQNoo33W0islREABAcxXE8n7y2MGAlB+hdsxXn4J0hGZge8IqVQhW8sWIb+oJz2yEvg==}
+    engines: {node: '>=16.0.0', npm: '>=7.0.0'}
+
+  is-arguments@1.2.0:
+    resolution: {integrity: sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==}
+    engines: {node: '>= 0.4'}
+
+  is-arrayish@0.2.1:
+    resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
+
+  is-binary-path@2.1.0:
+    resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
+    engines: {node: '>=8'}
+
+  is-callable@1.2.7:
+    resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
+    engines: {node: '>= 0.4'}
+
+  is-docker@2.2.1:
+    resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  is-docker@3.0.0:
+    resolution: {integrity: sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    hasBin: true
+
+  is-electron@2.2.2:
+    resolution: {integrity: sha512-FO/Rhvz5tuw4MCWkpMzHFKWD2LsfHzIb7i6MdPYZ/KW7AlxawyLkqdy+jPZP1WubqEADE3O4FUENlJHDfQASRg==}
+
+  is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-fullwidth-code-point@3.0.0:
+    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
+    engines: {node: '>=8'}
+
+  is-generator-function@1.1.0:
+    resolution: {integrity: sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==}
+    engines: {node: '>= 0.4'}
+
+  is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
+  is-hex-prefixed@1.0.0:
+    resolution: {integrity: sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==}
+    engines: {node: '>=6.5.0', npm: '>=3'}
+
+  is-inside-container@1.0.0:
+    resolution: {integrity: sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==}
+    engines: {node: '>=14.16'}
+    hasBin: true
+
+  is-interactive@1.0.0:
+    resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==}
+    engines: {node: '>=8'}
+
+  is-ip@3.1.0:
+    resolution: {integrity: sha512-35vd5necO7IitFPjd/YBeqwWnyDWbuLH9ZXQdMfDA8TEo7pv5X8yfrvVO3xbJbLUlERCMvf6X0hTUamQxCYJ9Q==}
+    engines: {node: '>=8'}
+
+  is-natural-number@4.0.1:
+    resolution: {integrity: sha512-Y4LTamMe0DDQIIAlaer9eKebAlDSV6huy+TWhJVPlzZh2o4tRP5SQWFlLn5N0To4mDD22/qdOq+veo1cSISLgQ==}
+
+  is-number@7.0.0:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+
+  is-plain-obj@2.1.0:
+    resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==}
+    engines: {node: '>=8'}
+
+  is-regex@1.2.1:
+    resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==}
+    engines: {node: '>= 0.4'}
+
+  is-retry-allowed@1.2.0:
+    resolution: {integrity: sha512-RUbUeKwvm3XG2VYamhJL1xFktgjvPzL0Hq8C+6yrWIswDy3BIXGqCxhxkc30N9jqK311gVU137K8Ei55/zVJRg==}
+    engines: {node: '>=0.10.0'}
+
+  is-stream@1.1.0:
+    resolution: {integrity: sha512-uQPm8kcs47jx38atAcWTVxyltQYoPT68y9aWYdV6yWXSyW8mzSat0TL6CiWdZeCdF3KrAvpVtnHbTv4RN+rqdQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-stream@2.0.1:
+    resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
+    engines: {node: '>=8'}
+
+  is-typed-array@1.1.15:
+    resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==}
+    engines: {node: '>= 0.4'}
+
+  is-typedarray@1.0.0:
+    resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==}
+
+  is-wsl@2.2.0:
+    resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==}
+    engines: {node: '>=8'}
+
+  is-wsl@3.1.0:
+    resolution: {integrity: sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==}
+    engines: {node: '>=16'}
+
+  isarray@0.0.1:
+    resolution: {integrity: sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==}
+
+  isarray@1.0.0:
+    resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==}
+
+  isarray@2.0.5:
+    resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
+
+  isexe@2.0.0:
+    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
+
+  iso-url@1.2.1:
+    resolution: {integrity: sha512-9JPDgCN4B7QPkLtYAAOrEuAWvP9rWvR5offAr0/SeF046wIkglqH3VXgYYP6NcsKslH80UIVgmPqNe3j7tG2ng==}
+    engines: {node: '>=12'}
+
+  isomorphic-ws@4.0.1:
+    resolution: {integrity: sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w==}
+    peerDependencies:
+      ws: '*'
+
+  isstream@0.1.2:
+    resolution: {integrity: sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==}
+
+  it-all@1.0.6:
+    resolution: {integrity: sha512-3cmCc6Heqe3uWi3CVM/k51fa/XbMFpQVzFoDsV0IZNHSQDyAXl3c4MjHkFX5kF3922OGj7Myv1nSEUgRtcuM1A==}
+
+  it-all@3.0.9:
+    resolution: {integrity: sha512-fz1oJJ36ciGnu2LntAlE6SA97bFZpW7Rnt0uEc1yazzR2nKokZLr8lIRtgnpex4NsmaBcvHF+Z9krljWFy/mmg==}
+
+  it-first@1.0.7:
+    resolution: {integrity: sha512-nvJKZoBpZD/6Rtde6FXqwDqDZGF1sCADmr2Zoc0hZsIvnE449gRFnGctxDf09Bzc/FWnHXAdaHVIetY6lrE0/g==}
+
+  it-first@3.0.9:
+    resolution: {integrity: sha512-ZWYun273Gbl7CwiF6kK5xBtIKR56H1NoRaiJek2QzDirgen24u8XZ0Nk+jdnJSuCTPxC2ul1TuXKxu/7eK6NuA==}
+
+  it-glob@1.0.2:
+    resolution: {integrity: sha512-Ch2Dzhw4URfB9L/0ZHyY+uqOnKvBNeS/SMcRiPmJfpHiM0TsUZn+GkpcZxAoF3dJVdPm/PuIk3A4wlV7SUo23Q==}
+
+  it-glob@3.0.4:
+    resolution: {integrity: sha512-73PbGBTK/dHp5PX4l8pkQH1ozCONP0U+PB3qMqltxPonRJQNomINE3Hn9p02m2GOu95VoeVvSZdHI2N+qub0pw==}
+
+  it-last@1.0.6:
+    resolution: {integrity: sha512-aFGeibeiX/lM4bX3JY0OkVCFkAw8+n9lkukkLNivbJRvNz8lI3YXv5xcqhFUV2lDJiraEK3OXRDbGuevnnR67Q==}
+
+  it-last@3.0.9:
+    resolution: {integrity: sha512-AtfUEnGDBHBEwa1LjrpGHsJMzJAWDipD6zilvhakzJcm+BCvNX8zlX2BsHClHJLLTrsY4lY9JUjc+TQV4W7m1w==}
+
+  it-map@1.0.6:
+    resolution: {integrity: sha512-XT4/RM6UHIFG9IobGlQPFQUrlEKkU4eBUFG3qhWhfAdh1JfF2x11ShCrKCdmZ0OiZppPfoLuzcfA4cey6q3UAQ==}
+
+  it-map@3.1.4:
+    resolution: {integrity: sha512-QB9PYQdE9fUfpVFYfSxBIyvKynUCgblb143c+ktTK6ZuKSKkp7iH58uYFzagqcJ5HcqIfn1xbfaralHWam+3fg==}
+
+  it-peekable@1.0.3:
+    resolution: {integrity: sha512-5+8zemFS+wSfIkSZyf0Zh5kNN+iGyccN02914BY4w/Dj+uoFEoPSvj5vaWn8pNZJNSxzjW0zHRxC3LUb2KWJTQ==}
+
+  it-peekable@3.0.8:
+    resolution: {integrity: sha512-7IDBQKSp/dtBxXV3Fj0v3qM1jftJ9y9XrWLRIuU1X6RdKqWiN60syNwP0fiDxZD97b8SYM58dD3uklIk1TTQAw==}
+
+  it-pushable@3.2.3:
+    resolution: {integrity: sha512-gzYnXYK8Y5t5b/BnJUr7glfQLO4U5vyb05gPx/TyTw+4Bv1zM9gFk4YsOrnulWefMewlphCjKkakFvj1y99Tcg==}
+
+  it-stream-types@2.0.2:
+    resolution: {integrity: sha512-Rz/DEZ6Byn/r9+/SBCuJhpPATDF9D+dz5pbgSUyBsCDtza6wtNATrz/jz1gDyNanC3XdLboriHnOC925bZRBww==}
+
+  it-to-stream@1.0.0:
+    resolution: {integrity: sha512-pLULMZMAB/+vbdvbZtebC0nWBTbG581lk6w8P7DfIIIKUfa8FbY7Oi0FxZcFPbxvISs7A9E+cMpLDBc1XhpAOA==}
+
+  jackspeak@4.1.1:
+    resolution: {integrity: sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==}
+    engines: {node: 20 || >=22}
+
+  jake@10.9.4:
+    resolution: {integrity: sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  jayson@4.0.0:
+    resolution: {integrity: sha512-v2RNpDCMu45fnLzSk47vx7I+QUaOsox6f5X0CUlabAFwxoP+8MfAY0NQRFwOEYXIxm8Ih5y6OaEa5KYiQMkyAA==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  jayson@4.2.0:
+    resolution: {integrity: sha512-VfJ9t1YLwacIubLhONk0KFeosUBwstRWQ0IRT1KDjEjnVnSOVHC3uwugyV7L0c7R9lpVyrUGT2XWiBA1UTtpyg==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  js-sha3@0.8.0:
+    resolution: {integrity: sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==}
+
+  js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+
+  js-yaml@3.14.1:
+    resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==}
+    hasBin: true
+
+  js-yaml@4.1.0:
+    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+    hasBin: true
+
+  jsbn@0.1.1:
+    resolution: {integrity: sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==}
+
+  json-parse-better-errors@1.0.2:
+    resolution: {integrity: sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==}
+
+  json-parse-even-better-errors@2.3.1:
+    resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
+
+  json-schema-traverse@0.4.1:
+    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
+
+  json-schema@0.4.0:
+    resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==}
+
+  json-stringify-safe@5.0.1:
+    resolution: {integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==}
+
+  jsonfile@6.2.0:
+    resolution: {integrity: sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==}
+
+  jsonparse@1.3.1:
+    resolution: {integrity: sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==}
+    engines: {'0': node >= 0.2.0}
+
+  jsprim@1.4.2:
+    resolution: {integrity: sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==}
+    engines: {node: '>=0.6.0'}
+
+  keccak@3.0.4:
+    resolution: {integrity: sha512-3vKuW0jV8J3XNTzvfyicFR5qvxrSAGl7KIhvgOu5cmWwM7tZRj3fMbj/pfIf4be7aznbc+prBWGjywox/g2Y6Q==}
+    engines: {node: '>=10.0.0'}
+
+  kubo-rpc-client@5.2.0:
+    resolution: {integrity: sha512-J3ppL1xf7f27NDI9jUPGkr1QiExXLyxUTUwHUMMB1a4AZR4s6113SVXPHRYwe1pFIO3hRb5G+0SuHaxYSfhzBA==}
+
+  lilconfig@3.1.3:
+    resolution: {integrity: sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==}
+    engines: {node: '>=14'}
+
+  lines-and-columns@1.2.4:
+    resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
+
+  lodash.camelcase@4.3.0:
+    resolution: {integrity: sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==}
+
+  lodash.kebabcase@4.1.1:
+    resolution: {integrity: sha512-N8XRTIMMqqDgSy4VLKPnJ/+hpGZN+PHQiJnSenYqPaVV/NCqEogTnAdZLQiGKhxX+JCs8waWq2t1XHWKOmlY8g==}
+
+  lodash.lowercase@4.3.0:
+    resolution: {integrity: sha512-UcvP1IZYyDKyEL64mmrwoA1AbFu5ahojhTtkOUr1K9dbuxzS9ev8i4TxMMGCqRC9TE8uDaSoufNAXxRPNTseVA==}
+
+  lodash.lowerfirst@4.3.1:
+    resolution: {integrity: sha512-UUKX7VhP1/JL54NXg2aq/E1Sfnjjes8fNYTNkPU8ZmsaVeBvPHKdbNaN79Re5XRL01u6wbq3j0cbYZj71Fcu5w==}
+
+  lodash.pad@4.5.1:
+    resolution: {integrity: sha512-mvUHifnLqM+03YNzeTBS1/Gr6JRFjd3rRx88FHWUvamVaT9k2O/kXha3yBSOwB9/DTQrSTLJNHvLBBt2FdX7Mg==}
+
+  lodash.padend@4.6.1:
+    resolution: {integrity: sha512-sOQs2aqGpbl27tmCS1QNZA09Uqp01ZzWfDUoD+xzTii0E7dSQfRKcRetFwa+uXaxaqL+TKm7CgD2JdKP7aZBSw==}
+
+  lodash.padstart@4.6.1:
+    resolution: {integrity: sha512-sW73O6S8+Tg66eY56DBk85aQzzUJDtpoXFBgELMd5P/SotAguo+1kYO6RuYgXxA4HJH3LFTFPASX6ET6bjfriw==}
+
+  lodash.repeat@4.1.0:
+    resolution: {integrity: sha512-eWsgQW89IewS95ZOcr15HHCX6FVDxq3f2PNUIng3fyzsPev9imFQxIYdFZ6crl8L56UR6ZlGDLcEb3RZsCSSqw==}
+
+  lodash.snakecase@4.1.1:
+    resolution: {integrity: sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==}
+
+  lodash.startcase@4.4.0:
+    resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==}
+
+  lodash.trim@4.5.1:
+    resolution: {integrity: sha512-nJAlRl/K+eiOehWKDzoBVrSMhK0K3A3YQsUNXHQa5yIrKBAhsZgSu3KoAFoFT+mEgiyBHddZ0pRk1ITpIp90Wg==}
+
+  lodash.trimend@4.5.1:
+    resolution: {integrity: sha512-lsD+k73XztDsMBKPKvzHXRKFNMohTjoTKIIo4ADLn5dA65LZ1BqlAvSXhR2rPEC3BgAUQnzMnorqDtqn2z4IHA==}
+
+  lodash.trimstart@4.5.1:
+    resolution: {integrity: sha512-b/+D6La8tU76L/61/aN0jULWHkT0EeJCmVstPBn/K9MtD2qBW83AsBNrr63dKuWYwVMO7ucv13QNO/Ek/2RKaQ==}
+
+  lodash.uppercase@4.3.0:
+    resolution: {integrity: sha512-+Nbnxkj7s8K5U8z6KnEYPGUOGp3woZbB7Ecs7v3LkkjLQSm2kP9SKIILitN1ktn2mB/tmM9oSlku06I+/lH7QA==}
+
+  lodash.upperfirst@4.3.1:
+    resolution: {integrity: sha512-sReKOYJIJf74dhJONhU4e0/shzi1trVbSWDOhKYE5XV2O+H7Sb2Dihwuc7xWxVl+DgFPyTqIN3zMfT9cq5iWDg==}
+
+  lodash@4.17.21:
+    resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
+
+  log-symbols@3.0.0:
+    resolution: {integrity: sha512-dSkNGuI7iG3mfvDzUuYZyvk5dD9ocYCYzNU6CYDE6+Xqd+gwme6Z00NS3dUh8mq/73HaEtT7m6W+yUPtU6BZnQ==}
+    engines: {node: '>=8'}
+
+  long@4.0.0:
+    resolution: {integrity: sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==}
+
+  long@5.3.2:
+    resolution: {integrity: sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==}
+
+  lru-cache@10.4.3:
+    resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
+
+  lru-cache@11.1.0:
+    resolution: {integrity: sha512-QIXZUBJUx+2zHUdQujWejBkcD9+cs94tLn0+YL8UrCh+D5sCXZ4c7LaEH48pNwRY3MLDgqUFyhlCyjJPf1WP0A==}
+    engines: {node: 20 || >=22}
+
+  lru-cache@6.0.0:
+    resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==}
+    engines: {node: '>=10'}
+
+  main-event@1.0.1:
+    resolution: {integrity: sha512-NWtdGrAca/69fm6DIVd8T9rtfDII4Q8NQbIbsKQq2VzS9eqOGYs8uaNQjcuaCq/d9H/o625aOTJX2Qoxzqw0Pw==}
+
+  make-dir@1.3.0:
+    resolution: {integrity: sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==}
+    engines: {node: '>=4'}
+
+  make-error@1.3.6:
+    resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==}
+
+  math-intrinsics@1.1.0:
+    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
+    engines: {node: '>= 0.4'}
+
+  md5.js@1.3.5:
+    resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==}
+
+  merge-options@3.0.4:
+    resolution: {integrity: sha512-2Sug1+knBjkaMsMgf1ctR1Ujx+Ayku4EdJN4Z+C2+JzoeF7A3OZ9KM2GY0CpQS51NR61LTurMJrRKPhSs3ZRTQ==}
+    engines: {node: '>=10'}
+
+  merge-stream@2.0.0:
+    resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
+
+  merge2@1.4.1:
+    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
+    engines: {node: '>= 8'}
+
+  micromatch@4.0.8:
+    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+    engines: {node: '>=8.6'}
+
+  mime-db@1.52.0:
+    resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==}
+    engines: {node: '>= 0.6'}
+
+  mime-types@2.1.35:
+    resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
+    engines: {node: '>= 0.6'}
+
+  mimic-fn@2.1.0:
+    resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
+    engines: {node: '>=6'}
+
+  minimalistic-assert@1.0.1:
+    resolution: {integrity: sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==}
+
+  minimalistic-crypto-utils@1.0.1:
+    resolution: {integrity: sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==}
+
+  minimatch@10.0.3:
+    resolution: {integrity: sha512-IPZ167aShDZZUMdRk66cyQAW3qr0WzbHkPdMYa8bzZhlHhO3jALbKdxcaak7W9FfT2rZNpQuUu4Od7ILEpXSaw==}
+    engines: {node: 20 || >=22}
+
+  minimatch@3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+
+  minimatch@5.1.6:
+    resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==}
+    engines: {node: '>=10'}
+
+  minimatch@8.0.4:
+    resolution: {integrity: sha512-W0Wvr9HyFXZRGIDgCicunpQ299OKXs9RgZfaukz4qAW/pJhcpUfupc9c+OObPOFueNy8VSrZgEmDtk6Kh4WzDA==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  minimatch@9.0.5:
+    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  minimist@1.2.8:
+    resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
+
+  minipass@3.3.6:
+    resolution: {integrity: sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==}
+    engines: {node: '>=8'}
+
+  minipass@4.2.8:
+    resolution: {integrity: sha512-fNzuVyifolSLFL4NzpF+wEF4qrgqaaKX0haXPQEdQ7NKAN+WecoKMHV09YcuL/DHxrUsYQOK3MiuDf7Ip2OXfQ==}
+    engines: {node: '>=8'}
+
+  minipass@5.0.0:
+    resolution: {integrity: sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==}
+    engines: {node: '>=8'}
+
+  minipass@7.1.2:
+    resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  minizlib@2.1.2:
+    resolution: {integrity: sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==}
+    engines: {node: '>= 8'}
+
+  mkdirp@0.5.6:
+    resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==}
+    hasBin: true
+
+  mkdirp@1.0.4:
+    resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  ms@2.1.2:
+    resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  ms@3.0.0-canary.1:
+    resolution: {integrity: sha512-kh8ARjh8rMN7Du2igDRO9QJnqCb2xYTJxyQYK7vJJS4TvLLmsbyhiKpSW+t+y26gyOyMd0riphX0GeWKU3ky5g==}
+    engines: {node: '>=12.13'}
+
+  multiaddr-to-uri@8.0.0:
+    resolution: {integrity: sha512-dq4p/vsOOUdVEd1J1gl+R2GFrXJQH8yjLtz4hodqdVbieg39LvBOdMQRdQnfbg5LSM/q1BYNVf5CBbwZFFqBgA==}
+    deprecated: This module is deprecated, please upgrade to @multiformats/multiaddr-to-uri
+
+  multiaddr@10.0.1:
+    resolution: {integrity: sha512-G5upNcGzEGuTHkzxezPrrD6CaIHR9uo+7MwqhNVcXTs33IInon4y7nMiGxl2CY5hG7chvYQUQhz5V52/Qe3cbg==}
+    deprecated: This module is deprecated, please upgrade to @multiformats/multiaddr
+
+  multiformats@13.1.3:
+    resolution: {integrity: sha512-CZPi9lFZCM/+7oRolWYsvalsyWQGFo+GpdaTmjxXXomC+nP/W1Rnxb9sUgjvmNmRZ5bOPqRAl4nuK+Ydw/4tGw==}
+
+  multiformats@13.4.0:
+    resolution: {integrity: sha512-Mkb/QcclrJxKC+vrcIFl297h52QcKh2Az/9A5vbWytbQt4225UWWWmIuSsKksdww9NkIeYcA7DkfftyLuC/JSg==}
+
+  multiformats@9.9.0:
+    resolution: {integrity: sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg==}
+
+  mustache@4.2.0:
+    resolution: {integrity: sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==}
+    hasBin: true
+
+  mute-stream@2.0.0:
+    resolution: {integrity: sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==}
+    engines: {node: ^18.17.0 || >=20.5.0}
+
+  nanoid@3.3.11:
+    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  nanoid@5.1.5:
+    resolution: {integrity: sha512-Ir/+ZpE9fDsNH0hQ3C68uyThDXzYcim2EqcZ8zn8Chtt1iylPT9xXJB0kPCnqzgcEGikO9RxSrh63MsmVCU7Fw==}
+    engines: {node: ^18 || >=20}
+    hasBin: true
+
+  native-abort-controller@1.0.4:
+    resolution: {integrity: sha512-zp8yev7nxczDJMoP6pDxyD20IU0T22eX8VwN2ztDccKvSZhRaV33yP1BGwKSZfXuqWUzsXopVFjBdau9OOAwMQ==}
+    peerDependencies:
+      abort-controller: '*'
+
+  native-fetch@3.0.0:
+    resolution: {integrity: sha512-G3Z7vx0IFb/FQ4JxvtqGABsOTIqRWvgQz6e+erkB+JJD6LrszQtMozEHI4EkmgZQvnGHrpLVzUWk7t4sJCIkVw==}
+    peerDependencies:
+      node-fetch: '*'
+
+  native-fetch@4.0.2:
+    resolution: {integrity: sha512-4QcVlKFtv2EYVS5MBgsGX5+NWKtbDbIECdUXDBGDMAZXq3Jkv9zf+y8iS7Ub8fEdga3GpYeazp9gauNqXHJOCg==}
+    peerDependencies:
+      undici: '*'
+
+  natural-orderby@2.0.3:
+    resolution: {integrity: sha512-p7KTHxU0CUrcOXe62Zfrb5Z13nLvPhSWR/so3kFulUQU0sgUll2Z0LwpsLN351eOOD+hRGu/F1g+6xDfPeD++Q==}
+
+  node-addon-api@2.0.2:
+    resolution: {integrity: sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==}
+
+  node-addon-api@5.1.0:
+    resolution: {integrity: sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA==}
+
+  node-fetch@2.7.0:
+    resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==}
+    engines: {node: 4.x || >=6.0.0}
+    peerDependencies:
+      encoding: ^0.1.0
+    peerDependenciesMeta:
+      encoding:
+        optional: true
+
+  node-gyp-build@4.8.4:
+    resolution: {integrity: sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==}
+    hasBin: true
+
+  normalize-path@3.0.0:
+    resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
+    engines: {node: '>=0.10.0'}
+
+  npm-run-path@4.0.1:
+    resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==}
+    engines: {node: '>=8'}
+
+  number-to-bn@1.7.0:
+    resolution: {integrity: sha512-wsJ9gfSz1/s4ZsJN01lyonwuxA1tml6X1yBDnfpMglypcBRFZZkus26EdPSlqS5GJfYddVZa22p3VNb3z5m5Ig==}
+    engines: {node: '>=6.5.0', npm: '>=3'}
+
+  oauth-sign@0.9.0:
+    resolution: {integrity: sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==}
+
+  object-assign@4.1.1:
+    resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
+    engines: {node: '>=0.10.0'}
+
+  object-inspect@1.13.4:
+    resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==}
+    engines: {node: '>= 0.4'}
+
+  object-treeify@1.1.33:
+    resolution: {integrity: sha512-EFVjAYfzWqWsBMRHPMAXLCDIJnpMhdWAqR7xG6M6a2cs6PMFpl/+Z20w9zDW4vkxOFfddegBKq9Rehd0bxWE7A==}
+    engines: {node: '>= 10'}
+
+  once@1.4.0:
+    resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
+
+  onetime@5.1.2:
+    resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==}
+    engines: {node: '>=6'}
+
+  open@10.2.0:
+    resolution: {integrity: sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==}
+    engines: {node: '>=18'}
+
+  ora@4.0.2:
+    resolution: {integrity: sha512-YUOZbamht5mfLxPmk4M35CD/5DuOkAacxlEUbStVXpBAt4fyhBf+vZHI/HRkI++QUp3sNoeA2Gw4C+hi4eGSig==}
+    engines: {node: '>=8'}
+
+  p-defer@3.0.0:
+    resolution: {integrity: sha512-ugZxsxmtTln604yeYd29EGrNhazN2lywetzpKhfmQjW/VJmhpDmWbiX+h0zL8V91R0UXkhb3KtPmyq9PZw3aYw==}
+    engines: {node: '>=8'}
+
+  p-defer@4.0.1:
+    resolution: {integrity: sha512-Mr5KC5efvAK5VUptYEIopP1bakB85k2IWXaRC0rsh1uwn1L6M0LVml8OIQ4Gudg4oyZakf7FmeRLkMMtZW1i5A==}
+    engines: {node: '>=12'}
+
+  p-fifo@1.0.0:
+    resolution: {integrity: sha512-IjoCxXW48tqdtDFz6fqo5q1UfFVjjVZe8TC1QRflvNUJtNfCUhxOUw6MOVZhDPjqhSzc26xKdugsO17gmzd5+A==}
+
+  p-queue@8.1.0:
+    resolution: {integrity: sha512-mxLDbbGIBEXTJL0zEx8JIylaj3xQ7Z/7eEVjcF9fJX4DBiH9oqe+oahYnlKKxm0Ci9TlWTyhSHgygxMxjIB2jw==}
+    engines: {node: '>=18'}
+
+  p-timeout@6.1.4:
+    resolution: {integrity: sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg==}
+    engines: {node: '>=14.16'}
+
+  package-json-from-dist@1.0.1:
+    resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
+
+  parent-module@1.0.1:
+    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+    engines: {node: '>=6'}
+
+  parse-cache-control@1.0.1:
+    resolution: {integrity: sha512-60zvsJReQPX5/QP0Kzfd/VrpjScIQ7SHBW6bFCYfEP+fp0Eppr1SHhIO5nd1PjZtvclzSzES9D/p5nFJurwfWg==}
+
+  parse-duration@1.1.2:
+    resolution: {integrity: sha512-p8EIONG8L0u7f8GFgfVlL4n8rnChTt8O5FSxgxMz2tjc9FMP199wxVKVB6IbKx11uTbKHACSvaLVIKNnoeNR/A==}
+
+  parse-duration@2.1.4:
+    resolution: {integrity: sha512-b98m6MsCh+akxfyoz9w9dt0AlH2dfYLOBss5SdDsr9pkhKNvkWBXU/r8A4ahmIGByBOLV2+4YwfCuFxbDDaGyg==}
+
+  parse-json@4.0.0:
+    resolution: {integrity: sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw==}
+    engines: {node: '>=4'}
+
+  parse-json@5.2.0:
+    resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
+    engines: {node: '>=8'}
+
+  password-prompt@1.1.3:
+    resolution: {integrity: sha512-HkrjG2aJlvF0t2BMH0e2LB/EHf3Lcq3fNMzy4GYHcQblAvOl+QQji1Lx7WRBMqpVK8p+KR7bCg7oqAMXtdgqyw==}
+
+  path-is-absolute@1.0.1:
+    resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==}
+    engines: {node: '>=0.10.0'}
+
+  path-key@3.1.1:
+    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
+    engines: {node: '>=8'}
+
+  path-scurry@1.11.1:
+    resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
+    engines: {node: '>=16 || 14 >=14.18'}
+
+  path-scurry@2.0.0:
+    resolution: {integrity: sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg==}
+    engines: {node: 20 || >=22}
+
+  path-type@4.0.0:
+    resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
+    engines: {node: '>=8'}
+
+  pbkdf2@3.1.3:
+    resolution: {integrity: sha512-wfRLBZ0feWRhCIkoMB6ete7czJcnNnqRpcoWQBLqatqXXmelSRqfdDK4F3u9T2s2cXas/hQJcryI/4lAL+XTlA==}
+    engines: {node: '>=0.12'}
+
+  pend@1.2.0:
+    resolution: {integrity: sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==}
+
+  performance-now@2.1.0:
+    resolution: {integrity: sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@2.3.1:
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+    engines: {node: '>=8.6'}
+
+  picomatch@4.0.3:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
+    engines: {node: '>=12'}
+
+  pify@2.3.0:
+    resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==}
+    engines: {node: '>=0.10.0'}
+
+  pify@3.0.0:
+    resolution: {integrity: sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==}
+    engines: {node: '>=4'}
+
+  pinkie-promise@2.0.1:
+    resolution: {integrity: sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==}
+    engines: {node: '>=0.10.0'}
+
+  pinkie@2.0.4:
+    resolution: {integrity: sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==}
+    engines: {node: '>=0.10.0'}
+
+  pluralize@8.0.0:
+    resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==}
+    engines: {node: '>=4'}
+
+  possible-typed-array-names@1.1.0:
+    resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==}
+    engines: {node: '>= 0.4'}
+
+  prettier@1.19.1:
+    resolution: {integrity: sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  prettier@3.0.3:
+    resolution: {integrity: sha512-L/4pUDMxcNa8R/EthV08Zt42WBO4h1rarVtK0K+QJG0X187OLo7l699jWw0GKuwzkPQ//jMFA/8Xm6Fh3J/DAg==}
+    engines: {node: '>=14'}
+    hasBin: true
+
+  prettier@3.6.2:
+    resolution: {integrity: sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==}
+    engines: {node: '>=14'}
+    hasBin: true
+
+  process-nextick-args@2.0.1:
+    resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
+
+  progress-events@1.0.1:
+    resolution: {integrity: sha512-MOzLIwhpt64KIVN64h1MwdKWiyKFNc/S6BoYKPIVUHFg0/eIEyBulhWCgn678v/4c0ri3FdGuzXymNCv02MUIw==}
+
+  progress@2.0.3:
+    resolution: {integrity: sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==}
+    engines: {node: '>=0.4.0'}
+
+  promise@8.3.0:
+    resolution: {integrity: sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==}
+
+  proto-list@1.2.4:
+    resolution: {integrity: sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==}
+
+  protobufjs@6.11.4:
+    resolution: {integrity: sha512-5kQWPaJHi1WoCpjTGszzQ32PG2F4+wRY6BmAT4Vfw56Q2FZ4YZzK20xUYQH4YkfehY1e6QSICrJquM6xXZNcrw==}
+    hasBin: true
+
+  protons-runtime@5.6.0:
+    resolution: {integrity: sha512-/Kde+sB9DsMFrddJT/UZWe6XqvL7SL5dbag/DBCElFKhkwDj7XKt53S+mzLyaDP5OqS0wXjV5SA572uWDaT0Hg==}
+
+  psl@1.15.0:
+    resolution: {integrity: sha512-JZd3gMVBAVQkSs6HdNZo9Sdo0LNcQeMNP3CozBJb3JYC/QUYZTnKxP+f8oWRX4rHP5EurWxqAHTSwUCjlNKa1w==}
+
+  pump@1.0.3:
+    resolution: {integrity: sha512-8k0JupWme55+9tCVE+FS5ULT3K6AbgqrGa58lTT49RpyfwwcGedHqaC5LlQNdEAumn/wFsu6aPwkuPMioy8kqw==}
+
+  punycode@1.4.1:
+    resolution: {integrity: sha512-jmYNElW7yvO7TV33CjSmvSiE2yco3bV2czu/OzDKdMNVZQWfxCblURLhf+47syQRBntjfLdd/H0egrzIG+oaFQ==}
+
+  punycode@2.3.1:
+    resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
+    engines: {node: '>=6'}
+
+  pvtsutils@1.3.6:
+    resolution: {integrity: sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==}
+
+  pvutils@1.1.3:
+    resolution: {integrity: sha512-pMpnA0qRdFp32b1sJl1wOJNxZLQ2cbQx+k6tjNtZ8CpvVhNqEPRgivZ2WOUev2YMajecdH7ctUPDvEe87nariQ==}
+    engines: {node: '>=6.0.0'}
+
+  qs@6.14.0:
+    resolution: {integrity: sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==}
+    engines: {node: '>=0.6'}
+
+  qs@6.5.3:
+    resolution: {integrity: sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==}
+    engines: {node: '>=0.6'}
+
+  queue-microtask@1.2.3:
+    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
+
+  randombytes@2.1.0:
+    resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==}
+
+  react-native-fetch-api@3.0.0:
+    resolution: {integrity: sha512-g2rtqPjdroaboDKTsJCTlcmtw54E25OjyaunUP0anOZn4Fuo2IKs8BVfe02zVggA/UysbmfSnRJIqtNkAgggNA==}
+
+  readable-stream@1.0.34:
+    resolution: {integrity: sha512-ok1qVCJuRkNmvebYikljxJA/UEsKwLl2nI1OmaqAu4/UE+h0wKCHok4XkL/gvi39OacXvw59RJUOFUkDib2rHg==}
+
+  readable-stream@2.3.8:
+    resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==}
+
+  readable-stream@3.6.2:
+    resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}
+    engines: {node: '>= 6'}
+
+  readdirp@3.6.0:
+    resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
+    engines: {node: '>=8.10.0'}
+
+  readdirp@4.1.2:
+    resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
+    engines: {node: '>= 14.18.0'}
+
+  receptacle@1.3.2:
+    resolution: {integrity: sha512-HrsFvqZZheusncQRiEE7GatOAETrARKV/lnfYicIm8lbvp/JQOdADOfhjBd2DajvoszEyxSM6RlAAIZgEoeu/A==}
+
+  redeyed@2.1.1:
+    resolution: {integrity: sha512-FNpGGo1DycYAdnrKFxCMmKYgo/mILAqtRYbkdQD8Ep/Hk2PQ5+aEAEx+IU713RTDmuBaH0c8P5ZozurNu5ObRQ==}
+
+  registry-auth-token@5.1.0:
+    resolution: {integrity: sha512-GdekYuwLXLxMuFTwAPg5UKGLW/UXzQrZvH/Zj791BQif5T05T0RsaLfHc9q3ZOKi7n+BoprPD9mJ0O0k4xzUlw==}
+    engines: {node: '>=14'}
+
+  request@2.88.2:
+    resolution: {integrity: sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==}
+    engines: {node: '>= 6'}
+    deprecated: request has been deprecated, see https://github.com/request/request/issues/3142
+
+  resolve-from@4.0.0:
+    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+    engines: {node: '>=4'}
+
+  restore-cursor@3.1.0:
+    resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==}
+    engines: {node: '>=8'}
+
+  retimer@3.0.0:
+    resolution: {integrity: sha512-WKE0j11Pa0ZJI5YIk0nflGI7SQsfl2ljihVy7ogh7DeQSeYAUi0ubZ/yEueGtDfUPk6GH5LRw1hBdLq4IwUBWA==}
+
+  reusify@1.1.0:
+    resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
+    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
+
+  rimraf@2.7.1:
+    resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==}
+    deprecated: Rimraf versions prior to v4 are no longer supported
+    hasBin: true
+
+  rimraf@3.0.2:
+    resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
+    deprecated: Rimraf versions prior to v4 are no longer supported
+    hasBin: true
+
+  ripemd160@2.0.1:
+    resolution: {integrity: sha512-J7f4wutN8mdbV08MJnXibYpCOPHR+yzy+iQ/AsjMv2j8cLavQ8VGagDFUwwTAdF8FmRKVeNpbTTEwNHCW1g94w==}
+
+  ripemd160@2.0.2:
+    resolution: {integrity: sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==}
+
+  rlp@2.2.7:
+    resolution: {integrity: sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==}
+    hasBin: true
+
+  run-applescript@7.0.0:
+    resolution: {integrity: sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==}
+    engines: {node: '>=18'}
+
+  run-parallel@1.2.0:
+    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
+
+  safe-buffer@5.1.2:
+    resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}
+
+  safe-buffer@5.2.1:
+    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
+
+  safe-regex-test@1.1.0:
+    resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==}
+    engines: {node: '>= 0.4'}
+
+  safer-buffer@2.1.2:
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
+
+  scrypt-js@3.0.1:
+    resolution: {integrity: sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==}
+
+  secp256k1@4.0.4:
+    resolution: {integrity: sha512-6JfvwvjUOn8F/jUoBY2Q1v5WY5XS+rj8qSe0v8Y4ezH4InLgTEeOOPQsRll9OV429Pvo6BCHGavIyJfr3TAhsw==}
+    engines: {node: '>=18.0.0'}
+
+  seek-bzip@1.0.6:
+    resolution: {integrity: sha512-e1QtP3YL5tWww8uKaOCQ18UxIT2laNBXHjV/S2WYCiK4udiv8lkG89KRIoCjUagnAmCBurjF4zEVX2ByBbnCjQ==}
+    hasBin: true
+
+  semver@7.3.5:
+    resolution: {integrity: sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  semver@7.4.0:
+    resolution: {integrity: sha512-RgOxM8Mw+7Zus0+zcLEUn8+JfoLpj/huFTItQy2hsM4khuC1HYRDp0cU482Ewn/Fcy6bCjufD8vAj7voC66KQw==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  semver@7.7.2:
+    resolution: {integrity: sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  semver@7.7.3:
+    resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  set-function-length@1.2.2:
+    resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
+    engines: {node: '>= 0.4'}
+
+  setimmediate@1.0.5:
+    resolution: {integrity: sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==}
+
+  sha.js@2.4.12:
+    resolution: {integrity: sha512-8LzC5+bvI45BjpfXU8V5fdU2mfeKiQe1D1gIMn7XUlF3OTUrpdJpPPH4EMAnF0DsHHdSZqCdSss5qCmJKuiO3w==}
+    engines: {node: '>= 0.10'}
+    hasBin: true
+
+  shebang-command@2.0.0:
+    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
+    engines: {node: '>=8'}
+
+  shebang-regex@3.0.0:
+    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
+    engines: {node: '>=8'}
+
+  side-channel-list@1.0.0:
+    resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==}
+    engines: {node: '>= 0.4'}
+
+  side-channel-map@1.0.1:
+    resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==}
+    engines: {node: '>= 0.4'}
+
+  side-channel-weakmap@1.0.2:
+    resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==}
+    engines: {node: '>= 0.4'}
+
+  side-channel@1.1.0:
+    resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==}
+    engines: {node: '>= 0.4'}
+
+  signal-exit@3.0.7:
+    resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
+
+  signal-exit@4.1.0:
+    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
+    engines: {node: '>=14'}
+
+  slash@3.0.0:
+    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
+    engines: {node: '>=8'}
+
+  slice-ansi@4.0.0:
+    resolution: {integrity: sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==}
+    engines: {node: '>=10'}
+
+  source-map-support@0.5.21:
+    resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
+
+  source-map@0.6.1:
+    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
+    engines: {node: '>=0.10.0'}
+
+  split-ca@1.0.1:
+    resolution: {integrity: sha512-Q5thBSxp5t8WPTTJQS59LrGqOZqOsrhDGDVm8azCqIBjSBd7nd9o2PM+mDulQQkh8h//4U6hFZnc/mul8t5pWQ==}
+
+  sprintf-js@1.0.3:
+    resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
+
+  sshpk@1.18.0:
+    resolution: {integrity: sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==}
+    engines: {node: '>=0.10.0'}
+    hasBin: true
+
+  stream-chain@2.2.5:
+    resolution: {integrity: sha512-1TJmBx6aSWqZ4tx7aTpBDXK0/e2hhcNSTV8+CbFJtDjbb+I1mZ8lHit0Grw9GRT+6JbIrrDd8esncgBi8aBXGA==}
+
+  stream-json@1.9.1:
+    resolution: {integrity: sha512-uWkjJ+2Nt/LO9Z/JyKZbMusL8Dkh97uUBTv3AJQ74y07lVahLY4eEFsPsE97pxYBwr8nnjMAIch5eqI0gPShyw==}
+
+  stream-to-it@0.2.4:
+    resolution: {integrity: sha512-4vEbkSs83OahpmBybNJXlJd7d6/RxzkkSdT3I0mnGt79Xd2Kk+e1JqbvAvsQfCeKj3aKb0QIWkyK3/n0j506vQ==}
+
+  stream-to-it@1.0.1:
+    resolution: {integrity: sha512-AqHYAYPHcmvMrcLNgncE/q0Aj/ajP6A4qGhxP6EVn7K3YTNs0bJpJyk57wc2Heb7MUL64jurvmnmui8D9kjZgA==}
+
+  streamsearch@1.1.0:
+    resolution: {integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==}
+    engines: {node: '>=10.0.0'}
+
+  string-width@4.2.3:
+    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
+    engines: {node: '>=8'}
+
+  string-width@5.1.2:
+    resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==}
+    engines: {node: '>=12'}
+
+  string_decoder@0.10.31:
+    resolution: {integrity: sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==}
+
+  string_decoder@1.1.1:
+    resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==}
+
+  string_decoder@1.3.0:
+    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
+
+  strip-ansi@5.2.0:
+    resolution: {integrity: sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==}
+    engines: {node: '>=6'}
+
+  strip-ansi@6.0.1:
+    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
+    engines: {node: '>=8'}
+
+  strip-ansi@7.1.0:
+    resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==}
+    engines: {node: '>=12'}
+
+  strip-dirs@2.1.0:
+    resolution: {integrity: sha512-JOCxOeKLm2CAS73y/U4ZeZPTkE+gNVCzKt7Eox84Iej1LT/2pTWYpZKJuxwQpvX1LiZb1xokNR7RLfuBAa7T3g==}
+
+  strip-final-newline@2.0.0:
+    resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==}
+    engines: {node: '>=6'}
+
+  strip-hex-prefix@1.0.0:
+    resolution: {integrity: sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==}
+    engines: {node: '>=6.5.0', npm: '>=3'}
+
+  supports-color@5.5.0:
+    resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
+    engines: {node: '>=4'}
+
+  supports-color@7.2.0:
+    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+    engines: {node: '>=8'}
+
+  supports-color@8.1.1:
+    resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==}
+    engines: {node: '>=10'}
+
+  supports-color@9.4.0:
+    resolution: {integrity: sha512-VL+lNrEoIXww1coLPOmiEmK/0sGigko5COxI09KzHc2VJXJsQ37UaQ+8quuxjDeA7+KnLGTWRyOXSLLR2Wb4jw==}
+    engines: {node: '>=12'}
+
+  supports-hyperlinks@2.3.0:
+    resolution: {integrity: sha512-RpsAZlpWcDwOPQA22aCH4J0t7L8JmAvsCxfOSEwm7cQs3LshN36QaTkwd70DnBOXDWGssw2eUoc8CaRWT0XunA==}
+    engines: {node: '>=8'}
+
+  sync-request@6.1.0:
+    resolution: {integrity: sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw==}
+    engines: {node: '>=8.0.0'}
+
+  sync-rpc@1.3.6:
+    resolution: {integrity: sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw==}
+
+  tar-fs@1.16.5:
+    resolution: {integrity: sha512-1ergVCCysmwHQNrOS+Pjm4DQ4nrGp43+Xnu4MRGjCnQu/m3hEgLNS78d5z+B8OJ1hN5EejJdCSFZE1oM6AQXAQ==}
+
+  tar-stream@1.6.2:
+    resolution: {integrity: sha512-rzS0heiNf8Xn7/mpdSVVSMAWAoy9bfb1WOTYC78Z0UQKeKa/CWS8FOq0lKGNa8DWKAn9gxjCvMLYc5PGXYlK2A==}
+    engines: {node: '>= 0.8.0'}
+
+  tar@6.2.1:
+    resolution: {integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==}
+    engines: {node: '>=10'}
+
+  then-request@6.0.2:
+    resolution: {integrity: sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA==}
+    engines: {node: '>=6.0.0'}
+
+  through@2.3.8:
+    resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
+
+  timeout-abort-controller@2.0.0:
+    resolution: {integrity: sha512-2FAPXfzTPYEgw27bQGTHc0SzrbmnU2eso4qo172zMLZzaGqeu09PFa5B2FCUHM1tflgRqPgn5KQgp6+Vex4uNA==}
+
+  tinyglobby@0.2.14:
+    resolution: {integrity: sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==}
+    engines: {node: '>=12.0.0'}
+
+  tmp-promise@3.0.3:
+    resolution: {integrity: sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==}
+
+  tmp@0.2.5:
+    resolution: {integrity: sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==}
+    engines: {node: '>=14.14'}
+
+  to-buffer@1.2.1:
+    resolution: {integrity: sha512-tB82LpAIWjhLYbqjx3X4zEeHN6M8CiuOEy2JY8SEQVdYRe3CCHOFaqrBW1doLDrfpWhplcW7BL+bO3/6S3pcDQ==}
+    engines: {node: '>= 0.4'}
+
+  to-regex-range@5.0.1:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+
+  tough-cookie@2.5.0:
+    resolution: {integrity: sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==}
+    engines: {node: '>=0.8'}
+
+  tr46@0.0.3:
+    resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
+
+  ts-node@10.9.2:
+    resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==}
+    hasBin: true
+    peerDependencies:
+      '@swc/core': '>=1.2.50'
+      '@swc/wasm': '>=1.2.50'
+      '@types/node': '*'
+      typescript: '>=2.7'
+    peerDependenciesMeta:
+      '@swc/core':
+        optional: true
+      '@swc/wasm':
+        optional: true
+
+  tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+
+  tunnel-agent@0.6.0:
+    resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
+
+  tweetnacl@0.14.5:
+    resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==}
+
+  type-fest@0.21.3:
+    resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
+    engines: {node: '>=10'}
+
+  typed-array-buffer@1.0.3:
+    resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==}
+    engines: {node: '>= 0.4'}
+
+  typedarray@0.0.6:
+    resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==}
+
+  typescript@5.9.2:
+    resolution: {integrity: sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  uint8-varint@2.0.4:
+    resolution: {integrity: sha512-FwpTa7ZGA/f/EssWAb5/YV6pHgVF1fViKdW8cWaEarjB8t7NyofSWBdOTyFPaGuUG4gx3v1O3PQ8etsiOs3lcw==}
+
+  uint8arraylist@2.4.8:
+    resolution: {integrity: sha512-vc1PlGOzglLF0eae1M8mLRTBivsvrGsdmJ5RbK3e+QRvRLOZfZhQROTwH/OfyF3+ZVUg9/8hE8bmKP2CvP9quQ==}
+
+  uint8arrays@3.1.1:
+    resolution: {integrity: sha512-+QJa8QRnbdXVpHYjLoTpJIdCTiw9Ir62nocClWuXIq2JIh4Uta0cQsTSpFL678p2CN8B+XSApwcU+pQEqVpKWg==}
+
+  uint8arrays@5.1.0:
+    resolution: {integrity: sha512-vA6nFepEmlSKkMBnLBaUMVvAC4G3CTmO58C12y4sq6WPDOR7mOFYOi7GlrQ4djeSbP6JG9Pv9tJDM97PedRSww==}
+
+  unbzip2-stream@1.4.3:
+    resolution: {integrity: sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==}
+
+  undici-types@7.10.0:
+    resolution: {integrity: sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag==}
+
+  undici@7.16.0:
+    resolution: {integrity: sha512-QEg3HPMll0o3t2ourKwOeUAZ159Kn9mx5pnzHRQO8+Wixmh88YdZRiIwat0iNzNNXn0yoEtXJqFpyW7eM8BV7g==}
+    engines: {node: '>=20.18.1'}
+
+  universalify@2.0.1:
+    resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
+    engines: {node: '>= 10.0.0'}
+
+  uri-js@4.4.1:
+    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
+
+  urlpattern-polyfill@10.1.0:
+    resolution: {integrity: sha512-IGjKp/o0NL3Bso1PymYURCJxMPNAf/ILOpendP9f5B6e1rTJgdgiOvgfoT8VxCAdY+Wisb9uhGaJJf3yZ2V9nw==}
+
+  urlpattern-polyfill@8.0.2:
+    resolution: {integrity: sha512-Qp95D4TPJl1kC9SKigDcqgyM2VDVO4RiJc2d4qe5GrYm+zbIQCWWKAFaJNQ4BhdFeDGwBmAxqJBwWSJDb9T3BQ==}
+
+  utf-8-validate@5.0.10:
+    resolution: {integrity: sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==}
+    engines: {node: '>=6.14.2'}
+
+  utf8@3.0.0:
+    resolution: {integrity: sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ==}
+
+  util-deprecate@1.0.2:
+    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
+
+  util@0.12.5:
+    resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==}
+
+  uuid@3.4.0:
+    resolution: {integrity: sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==}
+    deprecated: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
+    hasBin: true
+
+  uuid@8.3.2:
+    resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==}
+    hasBin: true
+
+  v8-compile-cache-lib@3.0.1:
+    resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
+
+  varint@6.0.0:
+    resolution: {integrity: sha512-cXEIW6cfr15lFv563k4GuVuW/fiwjknytD37jIOLSdSWuOI6WnO/oKwmP2FQTU2l01LP8/M5TSAJpzUaGe3uWg==}
+
+  verror@1.10.0:
+    resolution: {integrity: sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==}
+    engines: {'0': node >=0.6.0}
+
+  wcwidth@1.0.1:
+    resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==}
+
+  weald@1.0.4:
+    resolution: {integrity: sha512-+kYTuHonJBwmFhP1Z4YQK/dGi3jAnJGCYhyODFpHK73rbxnp9lnZQj7a2m+WVgn8fXr5bJaxUpF6l8qZpPeNWQ==}
+
+  web-streams-polyfill@3.3.3:
+    resolution: {integrity: sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==}
+    engines: {node: '>= 8'}
+
+  web3-errors@1.3.1:
+    resolution: {integrity: sha512-w3NMJujH+ZSW4ltIZZKtdbkbyQEvBzyp3JRn59Ckli0Nz4VMsVq8aF1bLWM7A2kuQ+yVEm3ySeNU+7mSRwx7RQ==}
+    engines: {node: '>=14', npm: '>=6.12.0'}
+
+  web3-eth-abi@1.7.0:
+    resolution: {integrity: sha512-heqR0bWxgCJwjWIhq2sGyNj9bwun5+Xox/LdZKe+WMyTSy0cXDXEAgv3XKNkXC4JqdDt/ZlbTEx4TWak4TRMSg==}
+    engines: {node: '>=8.0.0'}
+
+  web3-eth-abi@4.4.1:
+    resolution: {integrity: sha512-60ecEkF6kQ9zAfbTY04Nc9q4eEYM0++BySpGi8wZ2PD1tw/c0SDvsKhV6IKURxLJhsDlb08dATc3iD6IbtWJmg==}
+    engines: {node: '>=14', npm: '>=6.12.0'}
+
+  web3-types@1.10.0:
+    resolution: {integrity: sha512-0IXoaAFtFc8Yin7cCdQfB9ZmjafrbP6BO0f0KT/khMhXKUpoJ6yShrVhiNpyRBo8QQjuOagsWzwSK2H49I7sbw==}
+    engines: {node: '>=14', npm: '>=6.12.0'}
+
+  web3-utils@1.7.0:
+    resolution: {integrity: sha512-O8Tl4Ky40Sp6pe89Olk2FsaUkgHyb5QAXuaKo38ms3CxZZ4d3rPGfjP9DNKGm5+IUgAZBNpF1VmlSmNCqfDI1w==}
+    engines: {node: '>=8.0.0'}
+
+  web3-utils@4.3.3:
+    resolution: {integrity: sha512-kZUeCwaQm+RNc2Bf1V3BYbF29lQQKz28L0y+FA4G0lS8IxtJVGi5SeDTUkpwqqkdHHC7JcapPDnyyzJ1lfWlOw==}
+    engines: {node: '>=14', npm: '>=6.12.0'}
+
+  web3-validator@2.0.6:
+    resolution: {integrity: sha512-qn9id0/l1bWmvH4XfnG/JtGKKwut2Vokl6YXP5Kfg424npysmtRLe9DgiNBM9Op7QL/aSiaA0TVXibuIuWcizg==}
+    engines: {node: '>=14', npm: '>=6.12.0'}
+
+  webcrypto-core@1.8.1:
+    resolution: {integrity: sha512-P+x1MvlNCXlKbLSOY4cYrdreqPG5hbzkmawbcXLKN/mf6DZW0SdNNkZ+sjwsqVkI4A4Ko2sPZmkZtCKY58w83A==}
+
+  webidl-conversions@3.0.1:
+    resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
+
+  whatwg-url@5.0.0:
+    resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
+
+  wherearewe@2.0.1:
+    resolution: {integrity: sha512-XUguZbDxCA2wBn2LoFtcEhXL6AXo+hVjGonwhSTTTU9SzbWG8Xu3onNIpzf9j/mYUcJQ0f+m37SzG77G851uFw==}
+    engines: {node: '>=16.0.0', npm: '>=7.0.0'}
+
+  which-typed-array@1.1.19:
+    resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==}
+    engines: {node: '>= 0.4'}
+
+  which@2.0.2:
+    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
+    engines: {node: '>= 8'}
+    hasBin: true
+
+  widest-line@3.1.0:
+    resolution: {integrity: sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==}
+    engines: {node: '>=8'}
+
+  wordwrap@1.0.0:
+    resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==}
+
+  wrap-ansi@6.2.0:
+    resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
+    engines: {node: '>=8'}
+
+  wrap-ansi@7.0.0:
+    resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==}
+    engines: {node: '>=10'}
+
+  wrap-ansi@8.1.0:
+    resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==}
+    engines: {node: '>=12'}
+
+  wrappy@1.0.2:
+    resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
+
+  ws@7.5.10:
+    resolution: {integrity: sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==}
+    engines: {node: '>=8.3.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: ^5.0.2
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  wsl-utils@0.1.0:
+    resolution: {integrity: sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==}
+    engines: {node: '>=18'}
+
+  xtend@4.0.2:
+    resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
+    engines: {node: '>=0.4'}
+
+  yallist@4.0.0:
+    resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
+
+  yaml@1.10.2:
+    resolution: {integrity: sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==}
+    engines: {node: '>= 6'}
+
+  yaml@2.8.1:
+    resolution: {integrity: sha512-lcYcMxX2PO9XMGvAJkJ3OsNMw+/7FKes7/hgerGUYWIoWu5j/+YQqcZr5JnPZWzOsEBgMbSbiSTn/dv/69Mkpw==}
+    engines: {node: '>= 14.6'}
+    hasBin: true
+
+  yargs-parser@21.1.1:
+    resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
+    engines: {node: '>=12'}
+
+  yauzl@2.10.0:
+    resolution: {integrity: sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==}
+
+  yn@3.1.1:
+    resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==}
+    engines: {node: '>=6'}
+
+  yoctocolors-cjs@2.1.2:
+    resolution: {integrity: sha512-cYVsTjKl8b+FrnidjibDWskAv7UKOfcwaVZdp/it9n1s9fU3IkgDbhdIRKCW4JDsAlECJY0ytoVPT3sK6kideA==}
+    engines: {node: '>=18'}
+
+  zod@3.25.76:
+    resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==}
+
+snapshots:
+
+  '@babel/code-frame@7.27.1':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.27.1
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
+  '@babel/helper-validator-identifier@7.27.1': {}
+
+  '@chainsafe/is-ip@2.1.0': {}
+
+  '@chainsafe/netmask@2.0.0':
+    dependencies:
+      '@chainsafe/is-ip': 2.1.0
+
+  '@cspotcode/source-map-support@0.8.1':
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.9
+
+  '@ethersproject/abi@5.0.7':
+    dependencies:
+      '@ethersproject/address': 5.8.0
+      '@ethersproject/bignumber': 5.8.0
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/constants': 5.8.0
+      '@ethersproject/hash': 5.8.0
+      '@ethersproject/keccak256': 5.8.0
+      '@ethersproject/logger': 5.8.0
+      '@ethersproject/properties': 5.8.0
+      '@ethersproject/strings': 5.8.0
+
+  '@ethersproject/abstract-provider@5.8.0':
+    dependencies:
+      '@ethersproject/bignumber': 5.8.0
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/logger': 5.8.0
+      '@ethersproject/networks': 5.8.0
+      '@ethersproject/properties': 5.8.0
+      '@ethersproject/transactions': 5.8.0
+      '@ethersproject/web': 5.8.0
+
+  '@ethersproject/abstract-signer@5.8.0':
+    dependencies:
+      '@ethersproject/abstract-provider': 5.8.0
+      '@ethersproject/bignumber': 5.8.0
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/logger': 5.8.0
+      '@ethersproject/properties': 5.8.0
+
+  '@ethersproject/address@5.8.0':
+    dependencies:
+      '@ethersproject/bignumber': 5.8.0
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/keccak256': 5.8.0
+      '@ethersproject/logger': 5.8.0
+      '@ethersproject/rlp': 5.8.0
+
+  '@ethersproject/base64@5.8.0':
+    dependencies:
+      '@ethersproject/bytes': 5.8.0
+
+  '@ethersproject/bignumber@5.8.0':
+    dependencies:
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/logger': 5.8.0
+      bn.js: 5.2.2
+
+  '@ethersproject/bytes@5.8.0':
+    dependencies:
+      '@ethersproject/logger': 5.8.0
+
+  '@ethersproject/constants@5.8.0':
+    dependencies:
+      '@ethersproject/bignumber': 5.8.0
+
+  '@ethersproject/hash@5.8.0':
+    dependencies:
+      '@ethersproject/abstract-signer': 5.8.0
+      '@ethersproject/address': 5.8.0
+      '@ethersproject/base64': 5.8.0
+      '@ethersproject/bignumber': 5.8.0
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/keccak256': 5.8.0
+      '@ethersproject/logger': 5.8.0
+      '@ethersproject/properties': 5.8.0
+      '@ethersproject/strings': 5.8.0
+
+  '@ethersproject/keccak256@5.8.0':
+    dependencies:
+      '@ethersproject/bytes': 5.8.0
+      js-sha3: 0.8.0
+
+  '@ethersproject/logger@5.8.0': {}
+
+  '@ethersproject/networks@5.8.0':
+    dependencies:
+      '@ethersproject/logger': 5.8.0
+
+  '@ethersproject/properties@5.8.0':
+    dependencies:
+      '@ethersproject/logger': 5.8.0
+
+  '@ethersproject/rlp@5.8.0':
+    dependencies:
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/logger': 5.8.0
+
+  '@ethersproject/signing-key@5.8.0':
+    dependencies:
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/logger': 5.8.0
+      '@ethersproject/properties': 5.8.0
+      bn.js: 5.2.2
+      elliptic: 6.6.1
+      hash.js: 1.1.7
+
+  '@ethersproject/strings@5.8.0':
+    dependencies:
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/constants': 5.8.0
+      '@ethersproject/logger': 5.8.0
+
+  '@ethersproject/transactions@5.8.0':
+    dependencies:
+      '@ethersproject/address': 5.8.0
+      '@ethersproject/bignumber': 5.8.0
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/constants': 5.8.0
+      '@ethersproject/keccak256': 5.8.0
+      '@ethersproject/logger': 5.8.0
+      '@ethersproject/properties': 5.8.0
+      '@ethersproject/rlp': 5.8.0
+      '@ethersproject/signing-key': 5.8.0
+
+  '@ethersproject/web@5.8.0':
+    dependencies:
+      '@ethersproject/base64': 5.8.0
+      '@ethersproject/bytes': 5.8.0
+      '@ethersproject/logger': 5.8.0
+      '@ethersproject/properties': 5.8.0
+      '@ethersproject/strings': 5.8.0
+
+  '@fastify/busboy@3.2.0': {}
+
+  '@float-capital/float-subgraph-uncrashable@0.0.0-internal-testing.5':
+    dependencies:
+      '@rescript/std': 9.0.0
+      graphql: 16.11.0
+      graphql-import-node: 0.0.5(graphql@16.11.0)
+      js-yaml: 4.1.0
+
+  '@graphprotocol/graph-cli@0.50.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)':
+    dependencies:
+      '@float-capital/float-subgraph-uncrashable': 0.0.0-internal-testing.5
+      '@oclif/core': 2.8.4(@types/node@24.3.0)(typescript@5.9.2)
+      '@whatwg-node/fetch': 0.8.8
+      assemblyscript: 0.19.23
+      binary-install-raw: 0.0.13(debug@4.3.4)
+      chalk: 3.0.0
+      chokidar: 3.5.3
+      debug: 4.3.4
+      docker-compose: 0.23.19
+      dockerode: 2.5.8
+      fs-extra: 9.1.0
+      glob: 9.3.5
+      gluegun: 5.1.2(debug@4.3.4)
+      graphql: 15.5.0
+      immutable: 4.2.1
+      ipfs-http-client: 55.0.0(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))
+      jayson: 4.0.0(bufferutil@4.0.9)(utf-8-validate@5.0.10)
+      js-yaml: 3.14.1
+      prettier: 1.19.1
+      request: 2.88.2
+      semver: 7.4.0
+      sync-request: 6.1.0
+      tmp-promise: 3.0.3
+      web3-eth-abi: 1.7.0
+      which: 2.0.2
+      yaml: 1.10.2
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+      - '@types/node'
+      - bufferutil
+      - encoding
+      - node-fetch
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  '@graphprotocol/graph-cli@0.54.0-alpha-20230727052453-1e0e6e5(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)':
+    dependencies:
+      '@float-capital/float-subgraph-uncrashable': 0.0.0-internal-testing.5
+      '@oclif/core': 2.8.6(@types/node@24.3.0)(typescript@5.9.2)
+      '@whatwg-node/fetch': 0.8.8
+      assemblyscript: 0.19.23
+      binary-install-raw: 0.0.13(debug@4.3.4)
+      chalk: 3.0.0
+      chokidar: 3.5.3
+      debug: 4.3.4
+      docker-compose: 0.23.19
+      dockerode: 2.5.8
+      fs-extra: 9.1.0
+      glob: 9.3.5
+      gluegun: 5.1.2(debug@4.3.4)
+      graphql: 15.5.0
+      immutable: 4.2.1
+      ipfs-http-client: 55.0.0(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))
+      jayson: 4.0.0(bufferutil@4.0.9)(utf-8-validate@5.0.10)
+      js-yaml: 3.14.1
+      prettier: 1.19.1
+      request: 2.88.2
+      semver: 7.4.0
+      sync-request: 6.1.0
+      tmp-promise: 3.0.3
+      web3-eth-abi: 1.7.0
+      which: 2.0.2
+      yaml: 1.10.2
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+      - '@types/node'
+      - bufferutil
+      - encoding
+      - node-fetch
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  '@graphprotocol/graph-cli@0.60.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)':
+    dependencies:
+      '@float-capital/float-subgraph-uncrashable': 0.0.0-internal-testing.5
+      '@oclif/core': 2.8.6(@types/node@24.3.0)(typescript@5.9.2)
+      '@oclif/plugin-autocomplete': 2.3.10(@types/node@24.3.0)(typescript@5.9.2)
+      '@oclif/plugin-not-found': 2.4.3(@types/node@24.3.0)(typescript@5.9.2)
+      '@whatwg-node/fetch': 0.8.8
+      assemblyscript: 0.19.23
+      binary-install-raw: 0.0.13(debug@4.3.4)
+      chalk: 3.0.0
+      chokidar: 3.5.3
+      debug: 4.3.4
+      docker-compose: 0.23.19
+      dockerode: 2.5.8
+      fs-extra: 9.1.0
+      glob: 9.3.5
+      gluegun: 5.1.2(debug@4.3.4)
+      graphql: 15.5.0
+      immutable: 4.2.1
+      ipfs-http-client: 55.0.0(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))
+      jayson: 4.0.0(bufferutil@4.0.9)(utf-8-validate@5.0.10)
+      js-yaml: 3.14.1
+      prettier: 1.19.1
+      request: 2.88.2
+      semver: 7.4.0
+      sync-request: 6.1.0
+      tmp-promise: 3.0.3
+      web3-eth-abi: 1.7.0
+      which: 2.0.2
+      yaml: 1.10.2
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+      - '@types/node'
+      - bufferutil
+      - encoding
+      - node-fetch
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  '@graphprotocol/graph-cli@0.69.0(@types/node@24.3.0)(bufferutil@4.0.9)(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))(typescript@5.9.2)(utf-8-validate@5.0.10)':
+    dependencies:
+      '@float-capital/float-subgraph-uncrashable': 0.0.0-internal-testing.5
+      '@oclif/core': 2.8.6(@types/node@24.3.0)(typescript@5.9.2)
+      '@oclif/plugin-autocomplete': 2.3.10(@types/node@24.3.0)(typescript@5.9.2)
+      '@oclif/plugin-not-found': 2.4.3(@types/node@24.3.0)(typescript@5.9.2)
+      '@whatwg-node/fetch': 0.8.8
+      assemblyscript: 0.19.23
+      binary-install-raw: 0.0.13(debug@4.3.4)
+      chalk: 3.0.0
+      chokidar: 3.5.3
+      debug: 4.3.4
+      docker-compose: 0.23.19
+      dockerode: 2.5.8
+      fs-extra: 9.1.0
+      glob: 9.3.5
+      gluegun: 5.1.6(debug@4.3.4)
+      graphql: 15.5.0
+      immutable: 4.2.1
+      ipfs-http-client: 55.0.0(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))
+      jayson: 4.0.0(bufferutil@4.0.9)(utf-8-validate@5.0.10)
+      js-yaml: 3.14.1
+      prettier: 3.0.3
+      semver: 7.4.0
+      sync-request: 6.1.0
+      tmp-promise: 3.0.3
+      web3-eth-abi: 1.7.0
+      which: 2.0.2
+      yaml: 1.10.2
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+      - '@types/node'
+      - bufferutil
+      - encoding
+      - node-fetch
+      - supports-color
+      - typescript
+      - utf-8-validate
+
+  '@graphprotocol/graph-cli@0.98.1(@types/node@24.3.0)(bufferutil@4.0.9)(typescript@5.9.2)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@float-capital/float-subgraph-uncrashable': 0.0.0-internal-testing.5
+      '@oclif/core': 4.5.5
+      '@oclif/plugin-autocomplete': 3.2.34
+      '@oclif/plugin-not-found': 3.2.65(@types/node@24.3.0)
+      '@oclif/plugin-warn-if-update-available': 3.1.46
+      '@pinax/graph-networks-registry': 0.7.1
+      '@whatwg-node/fetch': 0.10.10
+      assemblyscript: 0.19.23
+      chokidar: 4.0.3
+      debug: 4.4.3(supports-color@8.1.1)
+      decompress: 4.2.1
+      docker-compose: 1.3.0
+      fs-extra: 11.3.2
+      glob: 11.0.3
+      gluegun: 5.2.0(debug@4.4.3)
+      graphql: 16.11.0
+      immutable: 5.1.4
+      jayson: 4.2.0(bufferutil@4.0.9)(utf-8-validate@5.0.10)
+      js-yaml: 4.1.0
+      kubo-rpc-client: 5.2.0(undici@7.16.0)
+      open: 10.2.0
+      prettier: 3.6.2
+      progress: 2.0.3
+      semver: 7.7.3
+      tmp-promise: 3.0.3
+      undici: 7.16.0
+      web3-eth-abi: 4.4.1(typescript@5.9.2)(zod@3.25.76)
+      yaml: 2.8.1
+    transitivePeerDependencies:
+      - '@types/node'
+      - bufferutil
+      - supports-color
+      - typescript
+      - utf-8-validate
+      - zod
+
+  '@graphprotocol/graph-ts@0.30.0':
+    dependencies:
+      assemblyscript: 0.19.10
+
+  '@graphprotocol/graph-ts@0.31.0':
+    dependencies:
+      assemblyscript: 0.19.10
+
+  '@graphprotocol/graph-ts@0.33.0':
+    dependencies:
+      assemblyscript: 0.19.10
+
+  '@graphprotocol/graph-ts@0.34.0':
+    dependencies:
+      assemblyscript: 0.19.10
+
+  '@graphprotocol/graph-ts@0.35.0':
+    dependencies:
+      assemblyscript: 0.19.10
+
+  '@graphprotocol/graph-ts@0.36.0-alpha-20240422133139-8761ea3':
+    dependencies:
+      assemblyscript: 0.19.10
+
+  '@graphprotocol/graph-ts@0.36.0-alpha-20241129215038-b75cda9':
+    dependencies:
+      assemblyscript: 0.19.10
+
+  '@inquirer/checkbox@4.2.1(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/core': 10.1.15(@types/node@24.3.0)
+      '@inquirer/figures': 1.0.13
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+      ansi-escapes: 4.3.2
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/confirm@5.1.15(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/core': 10.1.15(@types/node@24.3.0)
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/core@10.1.15(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/figures': 1.0.13
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+      ansi-escapes: 4.3.2
+      cli-width: 4.1.0
+      mute-stream: 2.0.0
+      signal-exit: 4.1.0
+      wrap-ansi: 6.2.0
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/editor@4.2.17(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/core': 10.1.15(@types/node@24.3.0)
+      '@inquirer/external-editor': 1.0.1(@types/node@24.3.0)
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/expand@4.0.17(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/core': 10.1.15(@types/node@24.3.0)
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/external-editor@1.0.1(@types/node@24.3.0)':
+    dependencies:
+      chardet: 2.1.0
+      iconv-lite: 0.6.3
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/figures@1.0.13': {}
+
+  '@inquirer/input@4.2.1(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/core': 10.1.15(@types/node@24.3.0)
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/number@3.0.17(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/core': 10.1.15(@types/node@24.3.0)
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/password@4.0.17(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/core': 10.1.15(@types/node@24.3.0)
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+      ansi-escapes: 4.3.2
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/prompts@7.8.3(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/checkbox': 4.2.1(@types/node@24.3.0)
+      '@inquirer/confirm': 5.1.15(@types/node@24.3.0)
+      '@inquirer/editor': 4.2.17(@types/node@24.3.0)
+      '@inquirer/expand': 4.0.17(@types/node@24.3.0)
+      '@inquirer/input': 4.2.1(@types/node@24.3.0)
+      '@inquirer/number': 3.0.17(@types/node@24.3.0)
+      '@inquirer/password': 4.0.17(@types/node@24.3.0)
+      '@inquirer/rawlist': 4.1.5(@types/node@24.3.0)
+      '@inquirer/search': 3.1.0(@types/node@24.3.0)
+      '@inquirer/select': 4.3.1(@types/node@24.3.0)
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/rawlist@4.1.5(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/core': 10.1.15(@types/node@24.3.0)
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/search@3.1.0(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/core': 10.1.15(@types/node@24.3.0)
+      '@inquirer/figures': 1.0.13
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/select@4.3.1(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/core': 10.1.15(@types/node@24.3.0)
+      '@inquirer/figures': 1.0.13
+      '@inquirer/type': 3.0.8(@types/node@24.3.0)
+      ansi-escapes: 4.3.2
+      yoctocolors-cjs: 2.1.2
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@inquirer/type@3.0.8(@types/node@24.3.0)':
+    optionalDependencies:
+      '@types/node': 24.3.0
+
+  '@ipld/dag-cbor@7.0.3':
+    dependencies:
+      cborg: 1.10.2
+      multiformats: 9.9.0
+
+  '@ipld/dag-cbor@9.2.4':
+    dependencies:
+      cborg: 4.2.13
+      multiformats: 13.4.0
+
+  '@ipld/dag-json@10.2.5':
+    dependencies:
+      cborg: 4.2.13
+      multiformats: 13.4.0
+
+  '@ipld/dag-json@8.0.11':
+    dependencies:
+      cborg: 1.10.2
+      multiformats: 9.9.0
+
+  '@ipld/dag-pb@2.1.18':
+    dependencies:
+      multiformats: 9.9.0
+
+  '@ipld/dag-pb@4.1.5':
+    dependencies:
+      multiformats: 13.4.0
+
+  '@isaacs/balanced-match@4.0.1': {}
+
+  '@isaacs/brace-expansion@5.0.0':
+    dependencies:
+      '@isaacs/balanced-match': 4.0.1
+
+  '@isaacs/cliui@8.0.2':
+    dependencies:
+      string-width: 5.1.2
+      string-width-cjs: string-width@4.2.3
+      strip-ansi: 7.1.0
+      strip-ansi-cjs: strip-ansi@6.0.1
+      wrap-ansi: 8.1.0
+      wrap-ansi-cjs: wrap-ansi@7.0.0
+
+  '@jridgewell/resolve-uri@3.1.2': {}
+
+  '@jridgewell/sourcemap-codec@1.5.5': {}
+
+  '@jridgewell/trace-mapping@0.3.9':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  '@leichtgewicht/ip-codec@2.0.5': {}
+
+  '@libp2p/crypto@5.1.7':
+    dependencies:
+      '@libp2p/interface': 2.10.5
+      '@noble/curves': 1.9.7
+      '@noble/hashes': 1.8.0
+      multiformats: 13.4.0
+      protons-runtime: 5.6.0
+      uint8arraylist: 2.4.8
+      uint8arrays: 5.1.0
+
+  '@libp2p/interface@2.10.5':
+    dependencies:
+      '@multiformats/dns': 1.0.6
+      '@multiformats/multiaddr': 12.5.1
+      it-pushable: 3.2.3
+      it-stream-types: 2.0.2
+      main-event: 1.0.1
+      multiformats: 13.4.0
+      progress-events: 1.0.1
+      uint8arraylist: 2.4.8
+
+  '@libp2p/logger@5.1.21':
+    dependencies:
+      '@libp2p/interface': 2.10.5
+      '@multiformats/multiaddr': 12.5.1
+      interface-datastore: 8.3.2
+      multiformats: 13.4.0
+      weald: 1.0.4
+
+  '@libp2p/peer-id@5.1.8':
+    dependencies:
+      '@libp2p/crypto': 5.1.7
+      '@libp2p/interface': 2.10.5
+      multiformats: 13.4.0
+      uint8arrays: 5.1.0
+
+  '@multiformats/dns@1.0.6':
+    dependencies:
+      '@types/dns-packet': 5.6.5
+      buffer: 6.0.3
+      dns-packet: 5.6.1
+      hashlru: 2.3.0
+      p-queue: 8.1.0
+      progress-events: 1.0.1
+      uint8arrays: 5.1.0
+
+  '@multiformats/multiaddr-to-uri@11.0.2':
+    dependencies:
+      '@multiformats/multiaddr': 12.5.1
+
+  '@multiformats/multiaddr@12.5.1':
+    dependencies:
+      '@chainsafe/is-ip': 2.1.0
+      '@chainsafe/netmask': 2.0.0
+      '@multiformats/dns': 1.0.6
+      abort-error: 1.0.1
+      multiformats: 13.4.0
+      uint8-varint: 2.0.4
+      uint8arrays: 5.1.0
+
+  '@noble/curves@1.4.2':
+    dependencies:
+      '@noble/hashes': 1.4.0
+
+  '@noble/curves@1.9.7':
+    dependencies:
+      '@noble/hashes': 1.8.0
+
+  '@noble/hashes@1.4.0': {}
+
+  '@noble/hashes@1.8.0': {}
+
+  '@nodelib/fs.scandir@2.1.5':
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      run-parallel: 1.2.0
+
+  '@nodelib/fs.stat@2.0.5': {}
+
+  '@nodelib/fs.walk@1.2.8':
+    dependencies:
+      '@nodelib/fs.scandir': 2.1.5
+      fastq: 1.19.1
+
+  '@oclif/core@2.16.0(@types/node@24.3.0)(typescript@5.9.2)':
+    dependencies:
+      '@types/cli-progress': 3.11.6
+      ansi-escapes: 4.3.2
+      ansi-styles: 4.3.0
+      cardinal: 2.1.1
+      chalk: 4.1.2
+      clean-stack: 3.0.1
+      cli-progress: 3.12.0
+      debug: 4.4.1(supports-color@8.1.1)
+      ejs: 3.1.10
+      get-package-type: 0.1.0
+      globby: 11.1.0
+      hyperlinker: 1.0.0
+      indent-string: 4.0.0
+      is-wsl: 2.2.0
+      js-yaml: 3.14.1
+      natural-orderby: 2.0.3
+      object-treeify: 1.1.33
+      password-prompt: 1.1.3
+      slice-ansi: 4.0.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+      supports-color: 8.1.1
+      supports-hyperlinks: 2.3.0
+      ts-node: 10.9.2(@types/node@24.3.0)(typescript@5.9.2)
+      tslib: 2.8.1
+      widest-line: 3.1.0
+      wordwrap: 1.0.0
+      wrap-ansi: 7.0.0
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+      - '@types/node'
+      - typescript
+
+  '@oclif/core@2.8.4(@types/node@24.3.0)(typescript@5.9.2)':
+    dependencies:
+      '@types/cli-progress': 3.11.6
+      ansi-escapes: 4.3.2
+      ansi-styles: 4.3.0
+      cardinal: 2.1.1
+      chalk: 4.1.2
+      clean-stack: 3.0.1
+      cli-progress: 3.12.0
+      debug: 4.4.1(supports-color@8.1.1)
+      ejs: 3.1.10
+      fs-extra: 9.1.0
+      get-package-type: 0.1.0
+      globby: 11.1.0
+      hyperlinker: 1.0.0
+      indent-string: 4.0.0
+      is-wsl: 2.2.0
+      js-yaml: 3.14.1
+      natural-orderby: 2.0.3
+      object-treeify: 1.1.33
+      password-prompt: 1.1.3
+      semver: 7.7.2
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+      supports-color: 8.1.1
+      supports-hyperlinks: 2.3.0
+      ts-node: 10.9.2(@types/node@24.3.0)(typescript@5.9.2)
+      tslib: 2.8.1
+      widest-line: 3.1.0
+      wordwrap: 1.0.0
+      wrap-ansi: 7.0.0
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+      - '@types/node'
+      - typescript
+
+  '@oclif/core@2.8.6(@types/node@24.3.0)(typescript@5.9.2)':
+    dependencies:
+      '@types/cli-progress': 3.11.6
+      ansi-escapes: 4.3.2
+      ansi-styles: 4.3.0
+      cardinal: 2.1.1
+      chalk: 4.1.2
+      clean-stack: 3.0.1
+      cli-progress: 3.12.0
+      debug: 4.4.1(supports-color@8.1.1)
+      ejs: 3.1.10
+      fs-extra: 9.1.0
+      get-package-type: 0.1.0
+      globby: 11.1.0
+      hyperlinker: 1.0.0
+      indent-string: 4.0.0
+      is-wsl: 2.2.0
+      js-yaml: 3.14.1
+      natural-orderby: 2.0.3
+      object-treeify: 1.1.33
+      password-prompt: 1.1.3
+      semver: 7.7.2
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+      supports-color: 8.1.1
+      supports-hyperlinks: 2.3.0
+      ts-node: 10.9.2(@types/node@24.3.0)(typescript@5.9.2)
+      tslib: 2.8.1
+      widest-line: 3.1.0
+      wordwrap: 1.0.0
+      wrap-ansi: 7.0.0
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+      - '@types/node'
+      - typescript
+
+  '@oclif/core@4.5.5':
+    dependencies:
+      ansi-escapes: 4.3.2
+      ansis: 3.17.0
+      clean-stack: 3.0.1
+      cli-spinners: 2.9.2
+      debug: 4.4.3(supports-color@8.1.1)
+      ejs: 3.1.10
+      get-package-type: 0.1.0
+      indent-string: 4.0.0
+      is-wsl: 2.2.0
+      lilconfig: 3.1.3
+      minimatch: 9.0.5
+      semver: 7.7.3
+      string-width: 4.2.3
+      supports-color: 8.1.1
+      tinyglobby: 0.2.14
+      widest-line: 3.1.0
+      wordwrap: 1.0.0
+      wrap-ansi: 7.0.0
+
+  '@oclif/plugin-autocomplete@2.3.10(@types/node@24.3.0)(typescript@5.9.2)':
+    dependencies:
+      '@oclif/core': 2.16.0(@types/node@24.3.0)(typescript@5.9.2)
+      chalk: 4.1.2
+      debug: 4.4.1(supports-color@8.1.1)
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+      - '@types/node'
+      - supports-color
+      - typescript
+
+  '@oclif/plugin-autocomplete@3.2.34':
+    dependencies:
+      '@oclif/core': 4.5.5
+      ansis: 3.17.0
+      debug: 4.4.3(supports-color@8.1.1)
+      ejs: 3.1.10
+    transitivePeerDependencies:
+      - supports-color
+
+  '@oclif/plugin-not-found@2.4.3(@types/node@24.3.0)(typescript@5.9.2)':
+    dependencies:
+      '@oclif/core': 2.16.0(@types/node@24.3.0)(typescript@5.9.2)
+      chalk: 4.1.2
+      fast-levenshtein: 3.0.0
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+      - '@types/node'
+      - typescript
+
+  '@oclif/plugin-not-found@3.2.65(@types/node@24.3.0)':
+    dependencies:
+      '@inquirer/prompts': 7.8.3(@types/node@24.3.0)
+      '@oclif/core': 4.5.5
+      ansis: 3.17.0
+      fast-levenshtein: 3.0.0
+    transitivePeerDependencies:
+      - '@types/node'
+
+  '@oclif/plugin-warn-if-update-available@3.1.46':
+    dependencies:
+      '@oclif/core': 4.5.5
+      ansis: 3.17.0
+      debug: 4.4.3(supports-color@8.1.1)
+      http-call: 5.3.0
+      lodash: 4.17.21
+      registry-auth-token: 5.1.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@peculiar/asn1-schema@2.4.0':
+    dependencies:
+      asn1js: 3.0.6
+      pvtsutils: 1.3.6
+      tslib: 2.8.1
+
+  '@peculiar/json-schema@1.1.12':
+    dependencies:
+      tslib: 2.8.1
+
+  '@peculiar/webcrypto@1.5.0':
+    dependencies:
+      '@peculiar/asn1-schema': 2.4.0
+      '@peculiar/json-schema': 1.1.12
+      pvtsutils: 1.3.6
+      tslib: 2.8.1
+      webcrypto-core: 1.8.1
+
+  '@pinax/graph-networks-registry@0.7.1': {}
+
+  '@pnpm/config.env-replace@1.1.0': {}
+
+  '@pnpm/network.ca-file@1.0.2':
+    dependencies:
+      graceful-fs: 4.2.10
+
+  '@pnpm/npm-conf@2.3.1':
+    dependencies:
+      '@pnpm/config.env-replace': 1.1.0
+      '@pnpm/network.ca-file': 1.0.2
+      config-chain: 1.1.13
+
+  '@protobufjs/aspromise@1.1.2': {}
+
+  '@protobufjs/base64@1.1.2': {}
+
+  '@protobufjs/codegen@2.0.4': {}
+
+  '@protobufjs/eventemitter@1.1.0': {}
+
+  '@protobufjs/fetch@1.1.0':
+    dependencies:
+      '@protobufjs/aspromise': 1.1.2
+      '@protobufjs/inquire': 1.1.0
+
+  '@protobufjs/float@1.0.2': {}
+
+  '@protobufjs/inquire@1.1.0': {}
+
+  '@protobufjs/path@1.1.2': {}
+
+  '@protobufjs/pool@1.1.0': {}
+
+  '@protobufjs/utf8@1.1.0': {}
+
+  '@rescript/std@9.0.0': {}
+
+  '@scure/base@1.1.9': {}
+
+  '@scure/bip32@1.4.0':
+    dependencies:
+      '@noble/curves': 1.4.2
+      '@noble/hashes': 1.4.0
+      '@scure/base': 1.1.9
+
+  '@scure/bip39@1.3.0':
+    dependencies:
+      '@noble/hashes': 1.4.0
+      '@scure/base': 1.1.9
+
+  '@tsconfig/node10@1.0.11': {}
+
+  '@tsconfig/node12@1.0.11': {}
+
+  '@tsconfig/node14@1.0.3': {}
+
+  '@tsconfig/node16@1.0.4': {}
+
+  '@types/bn.js@5.2.0':
+    dependencies:
+      '@types/node': 24.3.0
+
+  '@types/cli-progress@3.11.6':
+    dependencies:
+      '@types/node': 24.3.0
+
+  '@types/concat-stream@1.6.1':
+    dependencies:
+      '@types/node': 24.3.0
+
+  '@types/connect@3.4.38':
+    dependencies:
+      '@types/node': 12.20.55
+
+  '@types/dns-packet@5.6.5':
+    dependencies:
+      '@types/node': 24.3.0
+
+  '@types/form-data@0.0.33':
+    dependencies:
+      '@types/node': 24.3.0
+
+  '@types/long@4.0.2': {}
+
+  '@types/minimatch@3.0.5': {}
+
+  '@types/node@10.17.60': {}
+
+  '@types/node@12.20.55': {}
+
+  '@types/node@24.3.0':
+    dependencies:
+      undici-types: 7.10.0
+
+  '@types/node@8.10.66': {}
+
+  '@types/parse-json@4.0.2': {}
+
+  '@types/pbkdf2@3.1.2':
+    dependencies:
+      '@types/node': 24.3.0
+
+  '@types/qs@6.14.0': {}
+
+  '@types/secp256k1@4.0.6':
+    dependencies:
+      '@types/node': 24.3.0
+
+  '@types/ws@7.4.7':
+    dependencies:
+      '@types/node': 12.20.55
+
+  '@whatwg-node/disposablestack@0.0.6':
+    dependencies:
+      '@whatwg-node/promise-helpers': 1.3.2
+      tslib: 2.8.1
+
+  '@whatwg-node/events@0.0.3': {}
+
+  '@whatwg-node/fetch@0.10.10':
+    dependencies:
+      '@whatwg-node/node-fetch': 0.7.25
+      urlpattern-polyfill: 10.1.0
+
+  '@whatwg-node/fetch@0.8.8':
+    dependencies:
+      '@peculiar/webcrypto': 1.5.0
+      '@whatwg-node/node-fetch': 0.3.6
+      busboy: 1.6.0
+      urlpattern-polyfill: 8.0.2
+      web-streams-polyfill: 3.3.3
+
+  '@whatwg-node/node-fetch@0.3.6':
+    dependencies:
+      '@whatwg-node/events': 0.0.3
+      busboy: 1.6.0
+      fast-querystring: 1.1.2
+      fast-url-parser: 1.1.3
+      tslib: 2.8.1
+
+  '@whatwg-node/node-fetch@0.7.25':
+    dependencies:
+      '@fastify/busboy': 3.2.0
+      '@whatwg-node/disposablestack': 0.0.6
+      '@whatwg-node/promise-helpers': 1.3.2
+      tslib: 2.8.1
+
+  '@whatwg-node/promise-helpers@1.3.2':
+    dependencies:
+      tslib: 2.8.1
+
+  JSONStream@1.3.2:
+    dependencies:
+      jsonparse: 1.3.1
+      through: 2.3.8
+
+  JSONStream@1.3.5:
+    dependencies:
+      jsonparse: 1.3.1
+      through: 2.3.8
+
+  abitype@0.7.1(typescript@5.9.2)(zod@3.25.76):
+    dependencies:
+      typescript: 5.9.2
+    optionalDependencies:
+      zod: 3.25.76
+
+  abort-controller@3.0.0:
+    dependencies:
+      event-target-shim: 5.0.1
+
+  abort-error@1.0.1: {}
+
+  acorn-walk@8.3.4:
+    dependencies:
+      acorn: 8.15.0
+
+  acorn@8.15.0: {}
+
+  ajv@6.12.6:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-json-stable-stringify: 2.1.0
+      json-schema-traverse: 0.4.1
+      uri-js: 4.4.1
+
+  ansi-colors@4.1.3: {}
+
+  ansi-escapes@4.3.2:
+    dependencies:
+      type-fest: 0.21.3
+
+  ansi-regex@4.1.1: {}
+
+  ansi-regex@5.0.1: {}
+
+  ansi-regex@6.2.0: {}
+
+  ansi-styles@3.2.1:
+    dependencies:
+      color-convert: 1.9.3
+
+  ansi-styles@4.3.0:
+    dependencies:
+      color-convert: 2.0.1
+
+  ansi-styles@6.2.1: {}
+
+  ansicolors@0.3.2: {}
+
+  ansis@3.17.0: {}
+
+  any-signal@2.1.2:
+    dependencies:
+      abort-controller: 3.0.0
+      native-abort-controller: 1.0.4(abort-controller@3.0.0)
+
+  any-signal@3.0.1: {}
+
+  any-signal@4.1.1: {}
+
+  anymatch@3.1.3:
+    dependencies:
+      normalize-path: 3.0.0
+      picomatch: 2.3.1
+
+  apisauce@2.1.6(debug@4.3.4):
+    dependencies:
+      axios: 0.21.4(debug@4.3.4)
+    transitivePeerDependencies:
+      - debug
+
+  apisauce@2.1.6(debug@4.4.3):
+    dependencies:
+      axios: 0.21.4(debug@4.4.3)
+    transitivePeerDependencies:
+      - debug
+
+  app-module-path@2.2.0: {}
+
+  arg@4.1.3: {}
+
+  argparse@1.0.10:
+    dependencies:
+      sprintf-js: 1.0.3
+
+  argparse@2.0.1: {}
+
+  array-union@2.1.0: {}
+
+  asap@2.0.6: {}
+
+  asn1@0.2.6:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  asn1js@3.0.6:
+    dependencies:
+      pvtsutils: 1.3.6
+      pvutils: 1.1.3
+      tslib: 2.8.1
+
+  assemblyscript@0.19.10:
+    dependencies:
+      binaryen: 101.0.0-nightly.20210723
+      long: 4.0.0
+
+  assemblyscript@0.19.23:
+    dependencies:
+      binaryen: 102.0.0-nightly.20211028
+      long: 5.3.2
+      source-map-support: 0.5.21
+
+  assert-plus@1.0.0: {}
+
+  astral-regex@2.0.0: {}
+
+  async@3.2.6: {}
+
+  asynckit@0.4.0: {}
+
+  at-least-node@1.0.0: {}
+
+  available-typed-arrays@1.0.7:
+    dependencies:
+      possible-typed-array-names: 1.1.0
+
+  aws-sign2@0.7.0: {}
+
+  aws4@1.13.2: {}
+
+  axios@0.21.4(debug@4.3.4):
+    dependencies:
+      follow-redirects: 1.15.11(debug@4.3.4)
+    transitivePeerDependencies:
+      - debug
+
+  axios@0.21.4(debug@4.4.3):
+    dependencies:
+      follow-redirects: 1.15.11(debug@4.4.3)
+    transitivePeerDependencies:
+      - debug
+
+  balanced-match@1.0.2: {}
+
+  base-x@3.0.11:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  base64-js@1.5.1: {}
+
+  bcrypt-pbkdf@1.0.2:
+    dependencies:
+      tweetnacl: 0.14.5
+
+  binary-extensions@2.3.0: {}
+
+  binary-install-raw@0.0.13(debug@4.3.4):
+    dependencies:
+      axios: 0.21.4(debug@4.3.4)
+      rimraf: 3.0.2
+      tar: 6.2.1
+    transitivePeerDependencies:
+      - debug
+
+  binaryen@101.0.0-nightly.20210723: {}
+
+  binaryen@102.0.0-nightly.20211028: {}
+
+  bl@1.2.3:
+    dependencies:
+      readable-stream: 2.3.8
+      safe-buffer: 5.2.1
+
+  blakejs@1.2.1: {}
+
+  blob-to-it@1.0.4:
+    dependencies:
+      browser-readablestream-to-it: 1.0.3
+
+  blob-to-it@2.0.10:
+    dependencies:
+      browser-readablestream-to-it: 2.0.10
+
+  bn.js@4.11.6: {}
+
+  bn.js@4.12.2: {}
+
+  bn.js@5.2.2: {}
+
+  brace-expansion@1.1.12:
+    dependencies:
+      balanced-match: 1.0.2
+      concat-map: 0.0.1
+
+  brace-expansion@2.0.2:
+    dependencies:
+      balanced-match: 1.0.2
+
+  braces@3.0.3:
+    dependencies:
+      fill-range: 7.1.1
+
+  brorand@1.1.0: {}
+
+  browser-readablestream-to-it@1.0.3: {}
+
+  browser-readablestream-to-it@2.0.10: {}
+
+  browserify-aes@1.2.0:
+    dependencies:
+      buffer-xor: 1.0.3
+      cipher-base: 1.0.6
+      create-hash: 1.2.0
+      evp_bytestokey: 1.0.3
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+
+  bs58@4.0.1:
+    dependencies:
+      base-x: 3.0.11
+
+  bs58check@2.1.2:
+    dependencies:
+      bs58: 4.0.1
+      create-hash: 1.2.0
+      safe-buffer: 5.2.1
+
+  buffer-alloc-unsafe@1.1.0: {}
+
+  buffer-alloc@1.2.0:
+    dependencies:
+      buffer-alloc-unsafe: 1.1.0
+      buffer-fill: 1.0.0
+
+  buffer-crc32@0.2.13: {}
+
+  buffer-fill@1.0.0: {}
+
+  buffer-from@1.1.2: {}
+
+  buffer-xor@1.0.3: {}
+
+  buffer@5.7.1:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
+  buffer@6.0.3:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
+  bufferutil@4.0.9:
+    dependencies:
+      node-gyp-build: 4.8.4
+    optional: true
+
+  bundle-name@4.1.0:
+    dependencies:
+      run-applescript: 7.0.0
+
+  busboy@1.6.0:
+    dependencies:
+      streamsearch: 1.1.0
+
+  call-bind-apply-helpers@1.0.2:
+    dependencies:
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+
+  call-bind@1.0.8:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      get-intrinsic: 1.3.0
+      set-function-length: 1.2.2
+
+  call-bound@1.0.4:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      get-intrinsic: 1.3.0
+
+  callsites@3.1.0: {}
+
+  cardinal@2.1.1:
+    dependencies:
+      ansicolors: 0.3.2
+      redeyed: 2.1.1
+
+  caseless@0.12.0: {}
+
+  cborg@1.10.2: {}
+
+  cborg@4.2.13: {}
+
+  chalk@2.4.2:
+    dependencies:
+      ansi-styles: 3.2.1
+      escape-string-regexp: 1.0.5
+      supports-color: 5.5.0
+
+  chalk@3.0.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      supports-color: 7.2.0
+
+  chalk@4.1.2:
+    dependencies:
+      ansi-styles: 4.3.0
+      supports-color: 7.2.0
+
+  chardet@2.1.0: {}
+
+  chokidar@3.5.3:
+    dependencies:
+      anymatch: 3.1.3
+      braces: 3.0.3
+      glob-parent: 5.1.2
+      is-binary-path: 2.1.0
+      is-glob: 4.0.3
+      normalize-path: 3.0.0
+      readdirp: 3.6.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  chokidar@4.0.3:
+    dependencies:
+      readdirp: 4.1.2
+
+  chownr@1.1.4: {}
+
+  chownr@2.0.0: {}
+
+  cipher-base@1.0.6:
+    dependencies:
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+
+  clean-stack@3.0.1:
+    dependencies:
+      escape-string-regexp: 4.0.0
+
+  cli-cursor@3.1.0:
+    dependencies:
+      restore-cursor: 3.1.0
+
+  cli-progress@3.12.0:
+    dependencies:
+      string-width: 4.2.3
+
+  cli-spinners@2.9.2: {}
+
+  cli-table3@0.6.0:
+    dependencies:
+      object-assign: 4.1.1
+      string-width: 4.2.3
+    optionalDependencies:
+      colors: 1.4.0
+
+  cli-width@4.1.0: {}
+
+  clone@1.0.4: {}
+
+  color-convert@1.9.3:
+    dependencies:
+      color-name: 1.1.3
+
+  color-convert@2.0.1:
+    dependencies:
+      color-name: 1.1.4
+
+  color-name@1.1.3: {}
+
+  color-name@1.1.4: {}
+
+  colors@1.4.0: {}
+
+  combined-stream@1.0.8:
+    dependencies:
+      delayed-stream: 1.0.0
+
+  commander@2.20.3: {}
+
+  concat-map@0.0.1: {}
+
+  concat-stream@1.6.2:
+    dependencies:
+      buffer-from: 1.1.2
+      inherits: 2.0.4
+      readable-stream: 2.3.8
+      typedarray: 0.0.6
+
+  config-chain@1.1.13:
+    dependencies:
+      ini: 1.3.8
+      proto-list: 1.2.4
+
+  content-type@1.0.5: {}
+
+  core-util-is@1.0.2: {}
+
+  core-util-is@1.0.3: {}
+
+  cosmiconfig@7.0.1:
+    dependencies:
+      '@types/parse-json': 4.0.2
+      import-fresh: 3.3.1
+      parse-json: 5.2.0
+      path-type: 4.0.0
+      yaml: 1.10.2
+
+  create-hash@1.1.3:
+    dependencies:
+      cipher-base: 1.0.6
+      inherits: 2.0.4
+      ripemd160: 2.0.2
+      sha.js: 2.4.12
+
+  create-hash@1.2.0:
+    dependencies:
+      cipher-base: 1.0.6
+      inherits: 2.0.4
+      md5.js: 1.3.5
+      ripemd160: 2.0.2
+      sha.js: 2.4.12
+
+  create-hmac@1.1.7:
+    dependencies:
+      cipher-base: 1.0.6
+      create-hash: 1.2.0
+      inherits: 2.0.4
+      ripemd160: 2.0.2
+      safe-buffer: 5.2.1
+      sha.js: 2.4.12
+
+  create-require@1.1.1: {}
+
+  cross-spawn@7.0.3:
+    dependencies:
+      path-key: 3.1.1
+      shebang-command: 2.0.0
+      which: 2.0.2
+
+  cross-spawn@7.0.6:
+    dependencies:
+      path-key: 3.1.1
+      shebang-command: 2.0.0
+      which: 2.0.2
+
+  dag-jose@5.1.1:
+    dependencies:
+      '@ipld/dag-cbor': 9.2.4
+      multiformats: 13.1.3
+
+  dashdash@1.14.1:
+    dependencies:
+      assert-plus: 1.0.0
+
+  debug@3.2.7:
+    dependencies:
+      ms: 2.1.3
+
+  debug@4.3.4:
+    dependencies:
+      ms: 2.1.2
+
+  debug@4.4.1(supports-color@8.1.1):
+    dependencies:
+      ms: 2.1.3
+    optionalDependencies:
+      supports-color: 8.1.1
+
+  debug@4.4.3(supports-color@8.1.1):
+    dependencies:
+      ms: 2.1.3
+    optionalDependencies:
+      supports-color: 8.1.1
+
+  decompress-tar@4.1.1:
+    dependencies:
+      file-type: 5.2.0
+      is-stream: 1.1.0
+      tar-stream: 1.6.2
+
+  decompress-tarbz2@4.1.1:
+    dependencies:
+      decompress-tar: 4.1.1
+      file-type: 6.2.0
+      is-stream: 1.1.0
+      seek-bzip: 1.0.6
+      unbzip2-stream: 1.4.3
+
+  decompress-targz@4.1.1:
+    dependencies:
+      decompress-tar: 4.1.1
+      file-type: 5.2.0
+      is-stream: 1.1.0
+
+  decompress-unzip@4.0.1:
+    dependencies:
+      file-type: 3.9.0
+      get-stream: 2.3.1
+      pify: 2.3.0
+      yauzl: 2.10.0
+
+  decompress@4.2.1:
+    dependencies:
+      decompress-tar: 4.1.1
+      decompress-tarbz2: 4.1.1
+      decompress-targz: 4.1.1
+      decompress-unzip: 4.0.1
+      graceful-fs: 4.2.11
+      make-dir: 1.3.0
+      pify: 2.3.0
+      strip-dirs: 2.1.0
+
+  default-browser-id@5.0.0: {}
+
+  default-browser@5.2.1:
+    dependencies:
+      bundle-name: 4.1.0
+      default-browser-id: 5.0.0
+
+  defaults@1.0.4:
+    dependencies:
+      clone: 1.0.4
+
+  define-data-property@1.1.4:
+    dependencies:
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  define-lazy-prop@3.0.0: {}
+
+  delay@5.0.0: {}
+
+  delayed-stream@1.0.0: {}
+
+  diff@4.0.2: {}
+
+  dir-glob@3.0.1:
+    dependencies:
+      path-type: 4.0.0
+
+  dns-over-http-resolver@1.2.3(node-fetch@2.7.0(encoding@0.1.13)):
+    dependencies:
+      debug: 4.4.3(supports-color@8.1.1)
+      native-fetch: 3.0.0(node-fetch@2.7.0(encoding@0.1.13))
+      receptacle: 1.3.2
+    transitivePeerDependencies:
+      - node-fetch
+      - supports-color
+
+  dns-packet@5.6.1:
+    dependencies:
+      '@leichtgewicht/ip-codec': 2.0.5
+
+  docker-compose@0.23.19:
+    dependencies:
+      yaml: 1.10.2
+
+  docker-compose@1.3.0:
+    dependencies:
+      yaml: 2.8.1
+
+  docker-modem@1.0.9:
+    dependencies:
+      JSONStream: 1.3.2
+      debug: 3.2.7
+      readable-stream: 1.0.34
+      split-ca: 1.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  dockerode@2.5.8:
+    dependencies:
+      concat-stream: 1.6.2
+      docker-modem: 1.0.9
+      tar-fs: 1.16.5
+    transitivePeerDependencies:
+      - supports-color
+
+  dunder-proto@1.0.1:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  eastasianwidth@0.2.0: {}
+
+  ecc-jsbn@0.1.2:
+    dependencies:
+      jsbn: 0.1.1
+      safer-buffer: 2.1.2
+
+  ejs@3.1.10:
+    dependencies:
+      jake: 10.9.4
+
+  ejs@3.1.6:
+    dependencies:
+      jake: 10.9.4
+
+  ejs@3.1.8:
+    dependencies:
+      jake: 10.9.4
+
+  electron-fetch@1.9.1:
+    dependencies:
+      encoding: 0.1.13
+
+  elliptic@6.6.1:
+    dependencies:
+      bn.js: 4.12.2
+      brorand: 1.1.0
+      hash.js: 1.1.7
+      hmac-drbg: 1.0.1
+      inherits: 2.0.4
+      minimalistic-assert: 1.0.1
+      minimalistic-crypto-utils: 1.0.1
+
+  emoji-regex@8.0.0: {}
+
+  emoji-regex@9.2.2: {}
+
+  encoding@0.1.13:
+    dependencies:
+      iconv-lite: 0.6.3
+
+  end-of-stream@1.4.5:
+    dependencies:
+      once: 1.4.0
+
+  enquirer@2.3.6:
+    dependencies:
+      ansi-colors: 4.1.3
+
+  err-code@3.0.1: {}
+
+  error-ex@1.3.2:
+    dependencies:
+      is-arrayish: 0.2.1
+
+  es-define-property@1.0.1: {}
+
+  es-errors@1.3.0: {}
+
+  es-object-atoms@1.1.1:
+    dependencies:
+      es-errors: 1.3.0
+
+  es-set-tostringtag@2.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      has-tostringtag: 1.0.2
+      hasown: 2.0.2
+
+  es6-promise@4.2.8: {}
+
+  es6-promisify@5.0.0:
+    dependencies:
+      es6-promise: 4.2.8
+
+  escape-string-regexp@1.0.5: {}
+
+  escape-string-regexp@4.0.0: {}
+
+  esprima@4.0.1: {}
+
+  ethereum-bloom-filters@1.2.0:
+    dependencies:
+      '@noble/hashes': 1.8.0
+
+  ethereum-cryptography@0.1.3:
+    dependencies:
+      '@types/pbkdf2': 3.1.2
+      '@types/secp256k1': 4.0.6
+      blakejs: 1.2.1
+      browserify-aes: 1.2.0
+      bs58check: 2.1.2
+      create-hash: 1.2.0
+      create-hmac: 1.1.7
+      hash.js: 1.1.7
+      keccak: 3.0.4
+      pbkdf2: 3.1.3
+      randombytes: 2.1.0
+      safe-buffer: 5.2.1
+      scrypt-js: 3.0.1
+      secp256k1: 4.0.4
+      setimmediate: 1.0.5
+
+  ethereum-cryptography@2.2.1:
+    dependencies:
+      '@noble/curves': 1.4.2
+      '@noble/hashes': 1.4.0
+      '@scure/bip32': 1.4.0
+      '@scure/bip39': 1.3.0
+
+  ethereumjs-util@7.1.5:
+    dependencies:
+      '@types/bn.js': 5.2.0
+      bn.js: 5.2.2
+      create-hash: 1.2.0
+      ethereum-cryptography: 0.1.3
+      rlp: 2.2.7
+
+  ethjs-unit@0.1.6:
+    dependencies:
+      bn.js: 4.11.6
+      number-to-bn: 1.7.0
+
+  event-target-shim@5.0.1: {}
+
+  eventemitter3@5.0.1: {}
+
+  evp_bytestokey@1.0.3:
+    dependencies:
+      md5.js: 1.3.5
+      safe-buffer: 5.2.1
+
+  execa@5.1.1:
+    dependencies:
+      cross-spawn: 7.0.6
+      get-stream: 6.0.1
+      human-signals: 2.1.0
+      is-stream: 2.0.1
+      merge-stream: 2.0.0
+      npm-run-path: 4.0.1
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+      strip-final-newline: 2.0.0
+
+  extend@3.0.2: {}
+
+  extsprintf@1.3.0: {}
+
+  eyes@0.1.8: {}
+
+  fast-decode-uri-component@1.0.1: {}
+
+  fast-deep-equal@3.1.3: {}
+
+  fast-fifo@1.3.2: {}
+
+  fast-glob@3.3.3:
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      '@nodelib/fs.walk': 1.2.8
+      glob-parent: 5.1.2
+      merge2: 1.4.1
+      micromatch: 4.0.8
+
+  fast-json-stable-stringify@2.1.0: {}
+
+  fast-levenshtein@3.0.0:
+    dependencies:
+      fastest-levenshtein: 1.0.16
+
+  fast-querystring@1.1.2:
+    dependencies:
+      fast-decode-uri-component: 1.0.1
+
+  fast-url-parser@1.1.3:
+    dependencies:
+      punycode: 1.4.1
+
+  fastest-levenshtein@1.0.16: {}
+
+  fastq@1.19.1:
+    dependencies:
+      reusify: 1.1.0
+
+  fd-slicer@1.1.0:
+    dependencies:
+      pend: 1.2.0
+
+  fdir@6.5.0(picomatch@4.0.3):
+    optionalDependencies:
+      picomatch: 4.0.3
+
+  file-type@3.9.0: {}
+
+  file-type@5.2.0: {}
+
+  file-type@6.2.0: {}
+
+  filelist@1.0.4:
+    dependencies:
+      minimatch: 5.1.6
+
+  fill-range@7.1.1:
+    dependencies:
+      to-regex-range: 5.0.1
+
+  follow-redirects@1.15.11(debug@4.3.4):
+    optionalDependencies:
+      debug: 4.3.4
+
+  follow-redirects@1.15.11(debug@4.4.3):
+    optionalDependencies:
+      debug: 4.4.3(supports-color@8.1.1)
+
+  for-each@0.3.5:
+    dependencies:
+      is-callable: 1.2.7
+
+  foreground-child@3.3.1:
+    dependencies:
+      cross-spawn: 7.0.6
+      signal-exit: 4.1.0
+
+  forever-agent@0.6.1: {}
+
+  form-data@2.3.3:
+    dependencies:
+      asynckit: 0.4.0
+      combined-stream: 1.0.8
+      mime-types: 2.1.35
+
+  form-data@2.5.5:
+    dependencies:
+      asynckit: 0.4.0
+      combined-stream: 1.0.8
+      es-set-tostringtag: 2.1.0
+      hasown: 2.0.2
+      mime-types: 2.1.35
+      safe-buffer: 5.2.1
+
+  fs-constants@1.0.0: {}
+
+  fs-extra@11.3.2:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 6.2.0
+      universalify: 2.0.1
+
+  fs-extra@9.1.0:
+    dependencies:
+      at-least-node: 1.0.0
+      graceful-fs: 4.2.11
+      jsonfile: 6.2.0
+      universalify: 2.0.1
+
+  fs-jetpack@4.3.1:
+    dependencies:
+      minimatch: 3.1.2
+      rimraf: 2.7.1
+
+  fs-minipass@2.1.0:
+    dependencies:
+      minipass: 3.3.6
+
+  fs.realpath@1.0.0: {}
+
+  fsevents@2.3.3:
+    optional: true
+
+  function-bind@1.1.2: {}
+
+  get-intrinsic@1.3.0:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      function-bind: 1.1.2
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.2
+      math-intrinsics: 1.1.0
+
+  get-iterator@1.0.2: {}
+
+  get-package-type@0.1.0: {}
+
+  get-port@3.2.0: {}
+
+  get-proto@1.0.1:
+    dependencies:
+      dunder-proto: 1.0.1
+      es-object-atoms: 1.1.1
+
+  get-stream@2.3.1:
+    dependencies:
+      object-assign: 4.1.1
+      pinkie-promise: 2.0.1
+
+  get-stream@6.0.1: {}
+
+  getpass@0.1.7:
+    dependencies:
+      assert-plus: 1.0.0
+
+  glob-parent@5.1.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  glob@11.0.3:
+    dependencies:
+      foreground-child: 3.3.1
+      jackspeak: 4.1.1
+      minimatch: 10.0.3
+      minipass: 7.1.2
+      package-json-from-dist: 1.0.1
+      path-scurry: 2.0.0
+
+  glob@7.2.3:
+    dependencies:
+      fs.realpath: 1.0.0
+      inflight: 1.0.6
+      inherits: 2.0.4
+      minimatch: 3.1.2
+      once: 1.4.0
+      path-is-absolute: 1.0.1
+
+  glob@9.3.5:
+    dependencies:
+      fs.realpath: 1.0.0
+      minimatch: 8.0.4
+      minipass: 4.2.8
+      path-scurry: 1.11.1
+
+  globby@11.1.0:
+    dependencies:
+      array-union: 2.1.0
+      dir-glob: 3.0.1
+      fast-glob: 3.3.3
+      ignore: 5.3.2
+      merge2: 1.4.1
+      slash: 3.0.0
+
+  gluegun@5.1.2(debug@4.3.4):
+    dependencies:
+      apisauce: 2.1.6(debug@4.3.4)
+      app-module-path: 2.2.0
+      cli-table3: 0.6.0
+      colors: 1.4.0
+      cosmiconfig: 7.0.1
+      cross-spawn: 7.0.3
+      ejs: 3.1.6
+      enquirer: 2.3.6
+      execa: 5.1.1
+      fs-jetpack: 4.3.1
+      lodash.camelcase: 4.3.0
+      lodash.kebabcase: 4.1.1
+      lodash.lowercase: 4.3.0
+      lodash.lowerfirst: 4.3.1
+      lodash.pad: 4.5.1
+      lodash.padend: 4.6.1
+      lodash.padstart: 4.6.1
+      lodash.repeat: 4.1.0
+      lodash.snakecase: 4.1.1
+      lodash.startcase: 4.4.0
+      lodash.trim: 4.5.1
+      lodash.trimend: 4.5.1
+      lodash.trimstart: 4.5.1
+      lodash.uppercase: 4.3.0
+      lodash.upperfirst: 4.3.1
+      ora: 4.0.2
+      pluralize: 8.0.0
+      semver: 7.3.5
+      which: 2.0.2
+      yargs-parser: 21.1.1
+    transitivePeerDependencies:
+      - debug
+
+  gluegun@5.1.6(debug@4.3.4):
+    dependencies:
+      apisauce: 2.1.6(debug@4.3.4)
+      app-module-path: 2.2.0
+      cli-table3: 0.6.0
+      colors: 1.4.0
+      cosmiconfig: 7.0.1
+      cross-spawn: 7.0.3
+      ejs: 3.1.8
+      enquirer: 2.3.6
+      execa: 5.1.1
+      fs-jetpack: 4.3.1
+      lodash.camelcase: 4.3.0
+      lodash.kebabcase: 4.1.1
+      lodash.lowercase: 4.3.0
+      lodash.lowerfirst: 4.3.1
+      lodash.pad: 4.5.1
+      lodash.padend: 4.6.1
+      lodash.padstart: 4.6.1
+      lodash.repeat: 4.1.0
+      lodash.snakecase: 4.1.1
+      lodash.startcase: 4.4.0
+      lodash.trim: 4.5.1
+      lodash.trimend: 4.5.1
+      lodash.trimstart: 4.5.1
+      lodash.uppercase: 4.3.0
+      lodash.upperfirst: 4.3.1
+      ora: 4.0.2
+      pluralize: 8.0.0
+      semver: 7.3.5
+      which: 2.0.2
+      yargs-parser: 21.1.1
+    transitivePeerDependencies:
+      - debug
+
+  gluegun@5.2.0(debug@4.4.3):
+    dependencies:
+      apisauce: 2.1.6(debug@4.4.3)
+      app-module-path: 2.2.0
+      cli-table3: 0.6.0
+      colors: 1.4.0
+      cosmiconfig: 7.0.1
+      cross-spawn: 7.0.3
+      ejs: 3.1.8
+      enquirer: 2.3.6
+      execa: 5.1.1
+      fs-jetpack: 4.3.1
+      lodash.camelcase: 4.3.0
+      lodash.kebabcase: 4.1.1
+      lodash.lowercase: 4.3.0
+      lodash.lowerfirst: 4.3.1
+      lodash.pad: 4.5.1
+      lodash.padend: 4.6.1
+      lodash.padstart: 4.6.1
+      lodash.repeat: 4.1.0
+      lodash.snakecase: 4.1.1
+      lodash.startcase: 4.4.0
+      lodash.trim: 4.5.1
+      lodash.trimend: 4.5.1
+      lodash.trimstart: 4.5.1
+      lodash.uppercase: 4.3.0
+      lodash.upperfirst: 4.3.1
+      ora: 4.0.2
+      pluralize: 8.0.0
+      semver: 7.3.5
+      which: 2.0.2
+      yargs-parser: 21.1.1
+    transitivePeerDependencies:
+      - debug
+
+  gopd@1.2.0: {}
+
+  graceful-fs@4.2.10: {}
+
+  graceful-fs@4.2.11: {}
+
+  graphql-import-node@0.0.5(graphql@16.11.0):
+    dependencies:
+      graphql: 16.11.0
+
+  graphql@15.5.0: {}
+
+  graphql@16.11.0: {}
+
+  har-schema@2.0.0: {}
+
+  har-validator@5.1.5:
+    dependencies:
+      ajv: 6.12.6
+      har-schema: 2.0.0
+
+  has-flag@3.0.0: {}
+
+  has-flag@4.0.0: {}
+
+  has-property-descriptors@1.0.2:
+    dependencies:
+      es-define-property: 1.0.1
+
+  has-symbols@1.1.0: {}
+
+  has-tostringtag@1.0.2:
+    dependencies:
+      has-symbols: 1.1.0
+
+  hash-base@2.0.2:
+    dependencies:
+      inherits: 2.0.4
+
+  hash-base@3.1.0:
+    dependencies:
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+      safe-buffer: 5.2.1
+
+  hash.js@1.1.7:
+    dependencies:
+      inherits: 2.0.4
+      minimalistic-assert: 1.0.1
+
+  hashlru@2.3.0: {}
+
+  hasown@2.0.2:
+    dependencies:
+      function-bind: 1.1.2
+
+  hmac-drbg@1.0.1:
+    dependencies:
+      hash.js: 1.1.7
+      minimalistic-assert: 1.0.1
+      minimalistic-crypto-utils: 1.0.1
+
+  http-basic@8.1.3:
+    dependencies:
+      caseless: 0.12.0
+      concat-stream: 1.6.2
+      http-response-object: 3.0.2
+      parse-cache-control: 1.0.1
+
+  http-call@5.3.0:
+    dependencies:
+      content-type: 1.0.5
+      debug: 4.4.3(supports-color@8.1.1)
+      is-retry-allowed: 1.2.0
+      is-stream: 2.0.1
+      parse-json: 4.0.0
+      tunnel-agent: 0.6.0
+    transitivePeerDependencies:
+      - supports-color
+
+  http-response-object@3.0.2:
+    dependencies:
+      '@types/node': 10.17.60
+
+  http-signature@1.2.0:
+    dependencies:
+      assert-plus: 1.0.0
+      jsprim: 1.4.2
+      sshpk: 1.18.0
+
+  human-signals@2.1.0: {}
+
+  hyperlinker@1.0.0: {}
+
+  iconv-lite@0.6.3:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  ieee754@1.2.1: {}
+
+  ignore@5.3.2: {}
+
+  immutable@4.2.1: {}
+
+  immutable@5.1.4: {}
+
+  import-fresh@3.3.1:
+    dependencies:
+      parent-module: 1.0.1
+      resolve-from: 4.0.0
+
+  indent-string@4.0.0: {}
+
+  inflight@1.0.6:
+    dependencies:
+      once: 1.4.0
+      wrappy: 1.0.2
+
+  inherits@2.0.4: {}
+
+  ini@1.3.8: {}
+
+  interface-datastore@6.1.1:
+    dependencies:
+      interface-store: 2.0.2
+      nanoid: 3.3.11
+      uint8arrays: 3.1.1
+
+  interface-datastore@8.3.2:
+    dependencies:
+      interface-store: 6.0.3
+      uint8arrays: 5.1.0
+
+  interface-store@2.0.2: {}
+
+  interface-store@6.0.3: {}
+
+  ip-regex@4.3.0: {}
+
+  ipfs-core-types@0.9.0(node-fetch@2.7.0(encoding@0.1.13)):
+    dependencies:
+      interface-datastore: 6.1.1
+      multiaddr: 10.0.1(node-fetch@2.7.0(encoding@0.1.13))
+      multiformats: 9.9.0
+    transitivePeerDependencies:
+      - node-fetch
+      - supports-color
+
+  ipfs-core-utils@0.13.0(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13)):
+    dependencies:
+      any-signal: 2.1.2
+      blob-to-it: 1.0.4
+      browser-readablestream-to-it: 1.0.3
+      debug: 4.4.3(supports-color@8.1.1)
+      err-code: 3.0.1
+      ipfs-core-types: 0.9.0(node-fetch@2.7.0(encoding@0.1.13))
+      ipfs-unixfs: 6.0.9
+      ipfs-utils: 9.0.14(encoding@0.1.13)
+      it-all: 1.0.6
+      it-map: 1.0.6
+      it-peekable: 1.0.3
+      it-to-stream: 1.0.0
+      merge-options: 3.0.4
+      multiaddr: 10.0.1(node-fetch@2.7.0(encoding@0.1.13))
+      multiaddr-to-uri: 8.0.0(node-fetch@2.7.0(encoding@0.1.13))
+      multiformats: 9.9.0
+      nanoid: 3.3.11
+      parse-duration: 1.1.2
+      timeout-abort-controller: 2.0.0
+      uint8arrays: 3.1.1
+    transitivePeerDependencies:
+      - encoding
+      - node-fetch
+      - supports-color
+
+  ipfs-http-client@55.0.0(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13)):
+    dependencies:
+      '@ipld/dag-cbor': 7.0.3
+      '@ipld/dag-json': 8.0.11
+      '@ipld/dag-pb': 2.1.18
+      abort-controller: 3.0.0
+      any-signal: 2.1.2
+      debug: 4.4.3(supports-color@8.1.1)
+      err-code: 3.0.1
+      ipfs-core-types: 0.9.0(node-fetch@2.7.0(encoding@0.1.13))
+      ipfs-core-utils: 0.13.0(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13))
+      ipfs-utils: 9.0.14(encoding@0.1.13)
+      it-first: 1.0.7
+      it-last: 1.0.6
+      merge-options: 3.0.4
+      multiaddr: 10.0.1(node-fetch@2.7.0(encoding@0.1.13))
+      multiformats: 9.9.0
+      native-abort-controller: 1.0.4(abort-controller@3.0.0)
+      parse-duration: 1.1.2
+      stream-to-it: 0.2.4
+      uint8arrays: 3.1.1
+    transitivePeerDependencies:
+      - encoding
+      - node-fetch
+      - supports-color
+
+  ipfs-unixfs@11.2.5:
+    dependencies:
+      protons-runtime: 5.6.0
+      uint8arraylist: 2.4.8
+
+  ipfs-unixfs@6.0.9:
+    dependencies:
+      err-code: 3.0.1
+      protobufjs: 6.11.4
+
+  ipfs-utils@9.0.14(encoding@0.1.13):
+    dependencies:
+      any-signal: 3.0.1
+      browser-readablestream-to-it: 1.0.3
+      buffer: 6.0.3
+      electron-fetch: 1.9.1
+      err-code: 3.0.1
+      is-electron: 2.2.2
+      iso-url: 1.2.1
+      it-all: 1.0.6
+      it-glob: 1.0.2
+      it-to-stream: 1.0.0
+      merge-options: 3.0.4
+      nanoid: 3.3.11
+      native-fetch: 3.0.0(node-fetch@2.7.0(encoding@0.1.13))
+      node-fetch: 2.7.0(encoding@0.1.13)
+      react-native-fetch-api: 3.0.0
+      stream-to-it: 0.2.4
+    transitivePeerDependencies:
+      - encoding
+
+  is-arguments@1.2.0:
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+
+  is-arrayish@0.2.1: {}
+
+  is-binary-path@2.1.0:
+    dependencies:
+      binary-extensions: 2.3.0
+
+  is-callable@1.2.7: {}
+
+  is-docker@2.2.1: {}
+
+  is-docker@3.0.0: {}
+
+  is-electron@2.2.2: {}
+
+  is-extglob@2.1.1: {}
+
+  is-fullwidth-code-point@3.0.0: {}
+
+  is-generator-function@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      get-proto: 1.0.1
+      has-tostringtag: 1.0.2
+      safe-regex-test: 1.1.0
+
+  is-glob@4.0.3:
+    dependencies:
+      is-extglob: 2.1.1
+
+  is-hex-prefixed@1.0.0: {}
+
+  is-inside-container@1.0.0:
+    dependencies:
+      is-docker: 3.0.0
+
+  is-interactive@1.0.0: {}
+
+  is-ip@3.1.0:
+    dependencies:
+      ip-regex: 4.3.0
+
+  is-natural-number@4.0.1: {}
+
+  is-number@7.0.0: {}
+
+  is-plain-obj@2.1.0: {}
+
+  is-regex@1.2.1:
+    dependencies:
+      call-bound: 1.0.4
+      gopd: 1.2.0
+      has-tostringtag: 1.0.2
+      hasown: 2.0.2
+
+  is-retry-allowed@1.2.0: {}
+
+  is-stream@1.1.0: {}
+
+  is-stream@2.0.1: {}
+
+  is-typed-array@1.1.15:
+    dependencies:
+      which-typed-array: 1.1.19
+
+  is-typedarray@1.0.0: {}
+
+  is-wsl@2.2.0:
+    dependencies:
+      is-docker: 2.2.1
+
+  is-wsl@3.1.0:
+    dependencies:
+      is-inside-container: 1.0.0
+
+  isarray@0.0.1: {}
+
+  isarray@1.0.0: {}
+
+  isarray@2.0.5: {}
+
+  isexe@2.0.0: {}
+
+  iso-url@1.2.1: {}
+
+  isomorphic-ws@4.0.1(ws@7.5.10(bufferutil@4.0.9)(utf-8-validate@5.0.10)):
+    dependencies:
+      ws: 7.5.10(bufferutil@4.0.9)(utf-8-validate@5.0.10)
+
+  isstream@0.1.2: {}
+
+  it-all@1.0.6: {}
+
+  it-all@3.0.9: {}
+
+  it-first@1.0.7: {}
+
+  it-first@3.0.9: {}
+
+  it-glob@1.0.2:
+    dependencies:
+      '@types/minimatch': 3.0.5
+      minimatch: 3.1.2
+
+  it-glob@3.0.4:
+    dependencies:
+      fast-glob: 3.3.3
+
+  it-last@1.0.6: {}
+
+  it-last@3.0.9: {}
+
+  it-map@1.0.6: {}
+
+  it-map@3.1.4:
+    dependencies:
+      it-peekable: 3.0.8
+
+  it-peekable@1.0.3: {}
+
+  it-peekable@3.0.8: {}
+
+  it-pushable@3.2.3:
+    dependencies:
+      p-defer: 4.0.1
+
+  it-stream-types@2.0.2: {}
+
+  it-to-stream@1.0.0:
+    dependencies:
+      buffer: 6.0.3
+      fast-fifo: 1.3.2
+      get-iterator: 1.0.2
+      p-defer: 3.0.0
+      p-fifo: 1.0.0
+      readable-stream: 3.6.2
+
+  jackspeak@4.1.1:
+    dependencies:
+      '@isaacs/cliui': 8.0.2
+
+  jake@10.9.4:
+    dependencies:
+      async: 3.2.6
+      filelist: 1.0.4
+      picocolors: 1.1.1
+
+  jayson@4.0.0(bufferutil@4.0.9)(utf-8-validate@5.0.10):
+    dependencies:
+      '@types/connect': 3.4.38
+      '@types/node': 12.20.55
+      '@types/ws': 7.4.7
+      JSONStream: 1.3.5
+      commander: 2.20.3
+      delay: 5.0.0
+      es6-promisify: 5.0.0
+      eyes: 0.1.8
+      isomorphic-ws: 4.0.1(ws@7.5.10(bufferutil@4.0.9)(utf-8-validate@5.0.10))
+      json-stringify-safe: 5.0.1
+      uuid: 8.3.2
+      ws: 7.5.10(bufferutil@4.0.9)(utf-8-validate@5.0.10)
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  jayson@4.2.0(bufferutil@4.0.9)(utf-8-validate@5.0.10):
+    dependencies:
+      '@types/connect': 3.4.38
+      '@types/node': 12.20.55
+      '@types/ws': 7.4.7
+      commander: 2.20.3
+      delay: 5.0.0
+      es6-promisify: 5.0.0
+      eyes: 0.1.8
+      isomorphic-ws: 4.0.1(ws@7.5.10(bufferutil@4.0.9)(utf-8-validate@5.0.10))
+      json-stringify-safe: 5.0.1
+      stream-json: 1.9.1
+      uuid: 8.3.2
+      ws: 7.5.10(bufferutil@4.0.9)(utf-8-validate@5.0.10)
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  js-sha3@0.8.0: {}
+
+  js-tokens@4.0.0: {}
+
+  js-yaml@3.14.1:
+    dependencies:
+      argparse: 1.0.10
+      esprima: 4.0.1
+
+  js-yaml@4.1.0:
+    dependencies:
+      argparse: 2.0.1
+
+  jsbn@0.1.1: {}
+
+  json-parse-better-errors@1.0.2: {}
+
+  json-parse-even-better-errors@2.3.1: {}
+
+  json-schema-traverse@0.4.1: {}
+
+  json-schema@0.4.0: {}
+
+  json-stringify-safe@5.0.1: {}
+
+  jsonfile@6.2.0:
+    dependencies:
+      universalify: 2.0.1
+    optionalDependencies:
+      graceful-fs: 4.2.11
+
+  jsonparse@1.3.1: {}
+
+  jsprim@1.4.2:
+    dependencies:
+      assert-plus: 1.0.0
+      extsprintf: 1.3.0
+      json-schema: 0.4.0
+      verror: 1.10.0
+
+  keccak@3.0.4:
+    dependencies:
+      node-addon-api: 2.0.2
+      node-gyp-build: 4.8.4
+      readable-stream: 3.6.2
+
+  kubo-rpc-client@5.2.0(undici@7.16.0):
+    dependencies:
+      '@ipld/dag-cbor': 9.2.4
+      '@ipld/dag-json': 10.2.5
+      '@ipld/dag-pb': 4.1.5
+      '@libp2p/crypto': 5.1.7
+      '@libp2p/interface': 2.10.5
+      '@libp2p/logger': 5.1.21
+      '@libp2p/peer-id': 5.1.8
+      '@multiformats/multiaddr': 12.5.1
+      '@multiformats/multiaddr-to-uri': 11.0.2
+      any-signal: 4.1.1
+      blob-to-it: 2.0.10
+      browser-readablestream-to-it: 2.0.10
+      dag-jose: 5.1.1
+      electron-fetch: 1.9.1
+      err-code: 3.0.1
+      ipfs-unixfs: 11.2.5
+      iso-url: 1.2.1
+      it-all: 3.0.9
+      it-first: 3.0.9
+      it-glob: 3.0.4
+      it-last: 3.0.9
+      it-map: 3.1.4
+      it-peekable: 3.0.8
+      it-to-stream: 1.0.0
+      merge-options: 3.0.4
+      multiformats: 13.4.0
+      nanoid: 5.1.5
+      native-fetch: 4.0.2(undici@7.16.0)
+      parse-duration: 2.1.4
+      react-native-fetch-api: 3.0.0
+      stream-to-it: 1.0.1
+      uint8arrays: 5.1.0
+      wherearewe: 2.0.1
+    transitivePeerDependencies:
+      - undici
+
+  lilconfig@3.1.3: {}
+
+  lines-and-columns@1.2.4: {}
+
+  lodash.camelcase@4.3.0: {}
+
+  lodash.kebabcase@4.1.1: {}
+
+  lodash.lowercase@4.3.0: {}
+
+  lodash.lowerfirst@4.3.1: {}
+
+  lodash.pad@4.5.1: {}
+
+  lodash.padend@4.6.1: {}
+
+  lodash.padstart@4.6.1: {}
+
+  lodash.repeat@4.1.0: {}
+
+  lodash.snakecase@4.1.1: {}
+
+  lodash.startcase@4.4.0: {}
+
+  lodash.trim@4.5.1: {}
+
+  lodash.trimend@4.5.1: {}
+
+  lodash.trimstart@4.5.1: {}
+
+  lodash.uppercase@4.3.0: {}
+
+  lodash.upperfirst@4.3.1: {}
+
+  lodash@4.17.21: {}
+
+  log-symbols@3.0.0:
+    dependencies:
+      chalk: 2.4.2
+
+  long@4.0.0: {}
+
+  long@5.3.2: {}
+
+  lru-cache@10.4.3: {}
+
+  lru-cache@11.1.0: {}
+
+  lru-cache@6.0.0:
+    dependencies:
+      yallist: 4.0.0
+
+  main-event@1.0.1: {}
+
+  make-dir@1.3.0:
+    dependencies:
+      pify: 3.0.0
+
+  make-error@1.3.6: {}
+
+  math-intrinsics@1.1.0: {}
+
+  md5.js@1.3.5:
+    dependencies:
+      hash-base: 3.1.0
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+
+  merge-options@3.0.4:
+    dependencies:
+      is-plain-obj: 2.1.0
+
+  merge-stream@2.0.0: {}
+
+  merge2@1.4.1: {}
+
+  micromatch@4.0.8:
+    dependencies:
+      braces: 3.0.3
+      picomatch: 2.3.1
+
+  mime-db@1.52.0: {}
+
+  mime-types@2.1.35:
+    dependencies:
+      mime-db: 1.52.0
+
+  mimic-fn@2.1.0: {}
+
+  minimalistic-assert@1.0.1: {}
+
+  minimalistic-crypto-utils@1.0.1: {}
+
+  minimatch@10.0.3:
+    dependencies:
+      '@isaacs/brace-expansion': 5.0.0
+
+  minimatch@3.1.2:
+    dependencies:
+      brace-expansion: 1.1.12
+
+  minimatch@5.1.6:
+    dependencies:
+      brace-expansion: 2.0.2
+
+  minimatch@8.0.4:
+    dependencies:
+      brace-expansion: 2.0.2
+
+  minimatch@9.0.5:
+    dependencies:
+      brace-expansion: 2.0.2
+
+  minimist@1.2.8: {}
+
+  minipass@3.3.6:
+    dependencies:
+      yallist: 4.0.0
+
+  minipass@4.2.8: {}
+
+  minipass@5.0.0: {}
+
+  minipass@7.1.2: {}
+
+  minizlib@2.1.2:
+    dependencies:
+      minipass: 3.3.6
+      yallist: 4.0.0
+
+  mkdirp@0.5.6:
+    dependencies:
+      minimist: 1.2.8
+
+  mkdirp@1.0.4: {}
+
+  ms@2.1.2: {}
+
+  ms@2.1.3: {}
+
+  ms@3.0.0-canary.1: {}
+
+  multiaddr-to-uri@8.0.0(node-fetch@2.7.0(encoding@0.1.13)):
+    dependencies:
+      multiaddr: 10.0.1(node-fetch@2.7.0(encoding@0.1.13))
+    transitivePeerDependencies:
+      - node-fetch
+      - supports-color
+
+  multiaddr@10.0.1(node-fetch@2.7.0(encoding@0.1.13)):
+    dependencies:
+      dns-over-http-resolver: 1.2.3(node-fetch@2.7.0(encoding@0.1.13))
+      err-code: 3.0.1
+      is-ip: 3.1.0
+      multiformats: 9.9.0
+      uint8arrays: 3.1.1
+      varint: 6.0.0
+    transitivePeerDependencies:
+      - node-fetch
+      - supports-color
+
+  multiformats@13.1.3: {}
+
+  multiformats@13.4.0: {}
+
+  multiformats@9.9.0: {}
+
+  mustache@4.2.0: {}
+
+  mute-stream@2.0.0: {}
+
+  nanoid@3.3.11: {}
+
+  nanoid@5.1.5: {}
+
+  native-abort-controller@1.0.4(abort-controller@3.0.0):
+    dependencies:
+      abort-controller: 3.0.0
+
+  native-fetch@3.0.0(node-fetch@2.7.0(encoding@0.1.13)):
+    dependencies:
+      node-fetch: 2.7.0(encoding@0.1.13)
+
+  native-fetch@4.0.2(undici@7.16.0):
+    dependencies:
+      undici: 7.16.0
+
+  natural-orderby@2.0.3: {}
+
+  node-addon-api@2.0.2: {}
+
+  node-addon-api@5.1.0: {}
+
+  node-fetch@2.7.0(encoding@0.1.13):
+    dependencies:
+      whatwg-url: 5.0.0
+    optionalDependencies:
+      encoding: 0.1.13
+
+  node-gyp-build@4.8.4: {}
+
+  normalize-path@3.0.0: {}
+
+  npm-run-path@4.0.1:
+    dependencies:
+      path-key: 3.1.1
+
+  number-to-bn@1.7.0:
+    dependencies:
+      bn.js: 4.11.6
+      strip-hex-prefix: 1.0.0
+
+  oauth-sign@0.9.0: {}
+
+  object-assign@4.1.1: {}
+
+  object-inspect@1.13.4: {}
+
+  object-treeify@1.1.33: {}
+
+  once@1.4.0:
+    dependencies:
+      wrappy: 1.0.2
+
+  onetime@5.1.2:
+    dependencies:
+      mimic-fn: 2.1.0
+
+  open@10.2.0:
+    dependencies:
+      default-browser: 5.2.1
+      define-lazy-prop: 3.0.0
+      is-inside-container: 1.0.0
+      wsl-utils: 0.1.0
+
+  ora@4.0.2:
+    dependencies:
+      chalk: 2.4.2
+      cli-cursor: 3.1.0
+      cli-spinners: 2.9.2
+      is-interactive: 1.0.0
+      log-symbols: 3.0.0
+      strip-ansi: 5.2.0
+      wcwidth: 1.0.1
+
+  p-defer@3.0.0: {}
+
+  p-defer@4.0.1: {}
+
+  p-fifo@1.0.0:
+    dependencies:
+      fast-fifo: 1.3.2
+      p-defer: 3.0.0
+
+  p-queue@8.1.0:
+    dependencies:
+      eventemitter3: 5.0.1
+      p-timeout: 6.1.4
+
+  p-timeout@6.1.4: {}
+
+  package-json-from-dist@1.0.1: {}
+
+  parent-module@1.0.1:
+    dependencies:
+      callsites: 3.1.0
+
+  parse-cache-control@1.0.1: {}
+
+  parse-duration@1.1.2: {}
+
+  parse-duration@2.1.4: {}
+
+  parse-json@4.0.0:
+    dependencies:
+      error-ex: 1.3.2
+      json-parse-better-errors: 1.0.2
+
+  parse-json@5.2.0:
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      error-ex: 1.3.2
+      json-parse-even-better-errors: 2.3.1
+      lines-and-columns: 1.2.4
+
+  password-prompt@1.1.3:
+    dependencies:
+      ansi-escapes: 4.3.2
+      cross-spawn: 7.0.6
+
+  path-is-absolute@1.0.1: {}
+
+  path-key@3.1.1: {}
+
+  path-scurry@1.11.1:
+    dependencies:
+      lru-cache: 10.4.3
+      minipass: 7.1.2
+
+  path-scurry@2.0.0:
+    dependencies:
+      lru-cache: 11.1.0
+      minipass: 7.1.2
+
+  path-type@4.0.0: {}
+
+  pbkdf2@3.1.3:
+    dependencies:
+      create-hash: 1.1.3
+      create-hmac: 1.1.7
+      ripemd160: 2.0.1
+      safe-buffer: 5.2.1
+      sha.js: 2.4.12
+      to-buffer: 1.2.1
+
+  pend@1.2.0: {}
+
+  performance-now@2.1.0: {}
+
+  picocolors@1.1.1: {}
+
+  picomatch@2.3.1: {}
+
+  picomatch@4.0.3: {}
+
+  pify@2.3.0: {}
+
+  pify@3.0.0: {}
+
+  pinkie-promise@2.0.1:
+    dependencies:
+      pinkie: 2.0.4
+
+  pinkie@2.0.4: {}
+
+  pluralize@8.0.0: {}
+
+  possible-typed-array-names@1.1.0: {}
+
+  prettier@1.19.1: {}
+
+  prettier@3.0.3: {}
+
+  prettier@3.6.2: {}
+
+  process-nextick-args@2.0.1: {}
+
+  progress-events@1.0.1: {}
+
+  progress@2.0.3: {}
+
+  promise@8.3.0:
+    dependencies:
+      asap: 2.0.6
+
+  proto-list@1.2.4: {}
+
+  protobufjs@6.11.4:
+    dependencies:
+      '@protobufjs/aspromise': 1.1.2
+      '@protobufjs/base64': 1.1.2
+      '@protobufjs/codegen': 2.0.4
+      '@protobufjs/eventemitter': 1.1.0
+      '@protobufjs/fetch': 1.1.0
+      '@protobufjs/float': 1.0.2
+      '@protobufjs/inquire': 1.1.0
+      '@protobufjs/path': 1.1.2
+      '@protobufjs/pool': 1.1.0
+      '@protobufjs/utf8': 1.1.0
+      '@types/long': 4.0.2
+      '@types/node': 24.3.0
+      long: 4.0.0
+
+  protons-runtime@5.6.0:
+    dependencies:
+      uint8-varint: 2.0.4
+      uint8arraylist: 2.4.8
+      uint8arrays: 5.1.0
+
+  psl@1.15.0:
+    dependencies:
+      punycode: 2.3.1
+
+  pump@1.0.3:
+    dependencies:
+      end-of-stream: 1.4.5
+      once: 1.4.0
+
+  punycode@1.4.1: {}
+
+  punycode@2.3.1: {}
+
+  pvtsutils@1.3.6:
+    dependencies:
+      tslib: 2.8.1
+
+  pvutils@1.1.3: {}
+
+  qs@6.14.0:
+    dependencies:
+      side-channel: 1.1.0
+
+  qs@6.5.3: {}
+
+  queue-microtask@1.2.3: {}
+
+  randombytes@2.1.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  react-native-fetch-api@3.0.0:
+    dependencies:
+      p-defer: 3.0.0
+
+  readable-stream@1.0.34:
+    dependencies:
+      core-util-is: 1.0.3
+      inherits: 2.0.4
+      isarray: 0.0.1
+      string_decoder: 0.10.31
+
+  readable-stream@2.3.8:
+    dependencies:
+      core-util-is: 1.0.3
+      inherits: 2.0.4
+      isarray: 1.0.0
+      process-nextick-args: 2.0.1
+      safe-buffer: 5.1.2
+      string_decoder: 1.1.1
+      util-deprecate: 1.0.2
+
+  readable-stream@3.6.2:
+    dependencies:
+      inherits: 2.0.4
+      string_decoder: 1.3.0
+      util-deprecate: 1.0.2
+
+  readdirp@3.6.0:
+    dependencies:
+      picomatch: 2.3.1
+
+  readdirp@4.1.2: {}
+
+  receptacle@1.3.2:
+    dependencies:
+      ms: 2.1.3
+
+  redeyed@2.1.1:
+    dependencies:
+      esprima: 4.0.1
+
+  registry-auth-token@5.1.0:
+    dependencies:
+      '@pnpm/npm-conf': 2.3.1
+
+  request@2.88.2:
+    dependencies:
+      aws-sign2: 0.7.0
+      aws4: 1.13.2
+      caseless: 0.12.0
+      combined-stream: 1.0.8
+      extend: 3.0.2
+      forever-agent: 0.6.1
+      form-data: 2.3.3
+      har-validator: 5.1.5
+      http-signature: 1.2.0
+      is-typedarray: 1.0.0
+      isstream: 0.1.2
+      json-stringify-safe: 5.0.1
+      mime-types: 2.1.35
+      oauth-sign: 0.9.0
+      performance-now: 2.1.0
+      qs: 6.5.3
+      safe-buffer: 5.2.1
+      tough-cookie: 2.5.0
+      tunnel-agent: 0.6.0
+      uuid: 3.4.0
+
+  resolve-from@4.0.0: {}
+
+  restore-cursor@3.1.0:
+    dependencies:
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+
+  retimer@3.0.0: {}
+
+  reusify@1.1.0: {}
+
+  rimraf@2.7.1:
+    dependencies:
+      glob: 7.2.3
+
+  rimraf@3.0.2:
+    dependencies:
+      glob: 7.2.3
+
+  ripemd160@2.0.1:
+    dependencies:
+      hash-base: 2.0.2
+      inherits: 2.0.4
+
+  ripemd160@2.0.2:
+    dependencies:
+      hash-base: 3.1.0
+      inherits: 2.0.4
+
+  rlp@2.2.7:
+    dependencies:
+      bn.js: 5.2.2
+
+  run-applescript@7.0.0: {}
+
+  run-parallel@1.2.0:
+    dependencies:
+      queue-microtask: 1.2.3
+
+  safe-buffer@5.1.2: {}
+
+  safe-buffer@5.2.1: {}
+
+  safe-regex-test@1.1.0:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-regex: 1.2.1
+
+  safer-buffer@2.1.2: {}
+
+  scrypt-js@3.0.1: {}
+
+  secp256k1@4.0.4:
+    dependencies:
+      elliptic: 6.6.1
+      node-addon-api: 5.1.0
+      node-gyp-build: 4.8.4
+
+  seek-bzip@1.0.6:
+    dependencies:
+      commander: 2.20.3
+
+  semver@7.3.5:
+    dependencies:
+      lru-cache: 6.0.0
+
+  semver@7.4.0:
+    dependencies:
+      lru-cache: 6.0.0
+
+  semver@7.7.2: {}
+
+  semver@7.7.3: {}
+
+  set-function-length@1.2.2:
+    dependencies:
+      define-data-property: 1.1.4
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+      get-intrinsic: 1.3.0
+      gopd: 1.2.0
+      has-property-descriptors: 1.0.2
+
+  setimmediate@1.0.5: {}
+
+  sha.js@2.4.12:
+    dependencies:
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+      to-buffer: 1.2.1
+
+  shebang-command@2.0.0:
+    dependencies:
+      shebang-regex: 3.0.0
+
+  shebang-regex@3.0.0: {}
+
+  side-channel-list@1.0.0:
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.4
+
+  side-channel-map@1.0.1:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      object-inspect: 1.13.4
+
+  side-channel-weakmap@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      object-inspect: 1.13.4
+      side-channel-map: 1.0.1
+
+  side-channel@1.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.4
+      side-channel-list: 1.0.0
+      side-channel-map: 1.0.1
+      side-channel-weakmap: 1.0.2
+
+  signal-exit@3.0.7: {}
+
+  signal-exit@4.1.0: {}
+
+  slash@3.0.0: {}
+
+  slice-ansi@4.0.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      astral-regex: 2.0.0
+      is-fullwidth-code-point: 3.0.0
+
+  source-map-support@0.5.21:
+    dependencies:
+      buffer-from: 1.1.2
+      source-map: 0.6.1
+
+  source-map@0.6.1: {}
+
+  split-ca@1.0.1: {}
+
+  sprintf-js@1.0.3: {}
+
+  sshpk@1.18.0:
+    dependencies:
+      asn1: 0.2.6
+      assert-plus: 1.0.0
+      bcrypt-pbkdf: 1.0.2
+      dashdash: 1.14.1
+      ecc-jsbn: 0.1.2
+      getpass: 0.1.7
+      jsbn: 0.1.1
+      safer-buffer: 2.1.2
+      tweetnacl: 0.14.5
+
+  stream-chain@2.2.5: {}
+
+  stream-json@1.9.1:
+    dependencies:
+      stream-chain: 2.2.5
+
+  stream-to-it@0.2.4:
+    dependencies:
+      get-iterator: 1.0.2
+
+  stream-to-it@1.0.1:
+    dependencies:
+      it-stream-types: 2.0.2
+
+  streamsearch@1.1.0: {}
+
+  string-width@4.2.3:
+    dependencies:
+      emoji-regex: 8.0.0
+      is-fullwidth-code-point: 3.0.0
+      strip-ansi: 6.0.1
+
+  string-width@5.1.2:
+    dependencies:
+      eastasianwidth: 0.2.0
+      emoji-regex: 9.2.2
+      strip-ansi: 7.1.0
+
+  string_decoder@0.10.31: {}
+
+  string_decoder@1.1.1:
+    dependencies:
+      safe-buffer: 5.1.2
+
+  string_decoder@1.3.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  strip-ansi@5.2.0:
+    dependencies:
+      ansi-regex: 4.1.1
+
+  strip-ansi@6.0.1:
+    dependencies:
+      ansi-regex: 5.0.1
+
+  strip-ansi@7.1.0:
+    dependencies:
+      ansi-regex: 6.2.0
+
+  strip-dirs@2.1.0:
+    dependencies:
+      is-natural-number: 4.0.1
+
+  strip-final-newline@2.0.0: {}
+
+  strip-hex-prefix@1.0.0:
+    dependencies:
+      is-hex-prefixed: 1.0.0
+
+  supports-color@5.5.0:
+    dependencies:
+      has-flag: 3.0.0
+
+  supports-color@7.2.0:
+    dependencies:
+      has-flag: 4.0.0
+
+  supports-color@8.1.1:
+    dependencies:
+      has-flag: 4.0.0
+
+  supports-color@9.4.0: {}
+
+  supports-hyperlinks@2.3.0:
+    dependencies:
+      has-flag: 4.0.0
+      supports-color: 7.2.0
+
+  sync-request@6.1.0:
+    dependencies:
+      http-response-object: 3.0.2
+      sync-rpc: 1.3.6
+      then-request: 6.0.2
+
+  sync-rpc@1.3.6:
+    dependencies:
+      get-port: 3.2.0
+
+  tar-fs@1.16.5:
+    dependencies:
+      chownr: 1.1.4
+      mkdirp: 0.5.6
+      pump: 1.0.3
+      tar-stream: 1.6.2
+
+  tar-stream@1.6.2:
+    dependencies:
+      bl: 1.2.3
+      buffer-alloc: 1.2.0
+      end-of-stream: 1.4.5
+      fs-constants: 1.0.0
+      readable-stream: 2.3.8
+      to-buffer: 1.2.1
+      xtend: 4.0.2
+
+  tar@6.2.1:
+    dependencies:
+      chownr: 2.0.0
+      fs-minipass: 2.1.0
+      minipass: 5.0.0
+      minizlib: 2.1.2
+      mkdirp: 1.0.4
+      yallist: 4.0.0
+
+  then-request@6.0.2:
+    dependencies:
+      '@types/concat-stream': 1.6.1
+      '@types/form-data': 0.0.33
+      '@types/node': 8.10.66
+      '@types/qs': 6.14.0
+      caseless: 0.12.0
+      concat-stream: 1.6.2
+      form-data: 2.5.5
+      http-basic: 8.1.3
+      http-response-object: 3.0.2
+      promise: 8.3.0
+      qs: 6.14.0
+
+  through@2.3.8: {}
+
+  timeout-abort-controller@2.0.0:
+    dependencies:
+      abort-controller: 3.0.0
+      native-abort-controller: 1.0.4(abort-controller@3.0.0)
+      retimer: 3.0.0
+
+  tinyglobby@0.2.14:
+    dependencies:
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+
+  tmp-promise@3.0.3:
+    dependencies:
+      tmp: 0.2.5
+
+  tmp@0.2.5: {}
+
+  to-buffer@1.2.1:
+    dependencies:
+      isarray: 2.0.5
+      safe-buffer: 5.2.1
+      typed-array-buffer: 1.0.3
+
+  to-regex-range@5.0.1:
+    dependencies:
+      is-number: 7.0.0
+
+  tough-cookie@2.5.0:
+    dependencies:
+      psl: 1.15.0
+      punycode: 2.3.1
+
+  tr46@0.0.3: {}
+
+  ts-node@10.9.2(@types/node@24.3.0)(typescript@5.9.2):
+    dependencies:
+      '@cspotcode/source-map-support': 0.8.1
+      '@tsconfig/node10': 1.0.11
+      '@tsconfig/node12': 1.0.11
+      '@tsconfig/node14': 1.0.3
+      '@tsconfig/node16': 1.0.4
+      '@types/node': 24.3.0
+      acorn: 8.15.0
+      acorn-walk: 8.3.4
+      arg: 4.1.3
+      create-require: 1.1.1
+      diff: 4.0.2
+      make-error: 1.3.6
+      typescript: 5.9.2
+      v8-compile-cache-lib: 3.0.1
+      yn: 3.1.1
+
+  tslib@2.8.1: {}
+
+  tunnel-agent@0.6.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  tweetnacl@0.14.5: {}
+
+  type-fest@0.21.3: {}
+
+  typed-array-buffer@1.0.3:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-typed-array: 1.1.15
+
+  typedarray@0.0.6: {}
+
+  typescript@5.9.2: {}
+
+  uint8-varint@2.0.4:
+    dependencies:
+      uint8arraylist: 2.4.8
+      uint8arrays: 5.1.0
+
+  uint8arraylist@2.4.8:
+    dependencies:
+      uint8arrays: 5.1.0
+
+  uint8arrays@3.1.1:
+    dependencies:
+      multiformats: 9.9.0
+
+  uint8arrays@5.1.0:
+    dependencies:
+      multiformats: 13.4.0
+
+  unbzip2-stream@1.4.3:
+    dependencies:
+      buffer: 5.7.1
+      through: 2.3.8
+
+  undici-types@7.10.0: {}
+
+  undici@7.16.0: {}
+
+  universalify@2.0.1: {}
+
+  uri-js@4.4.1:
+    dependencies:
+      punycode: 2.3.1
+
+  urlpattern-polyfill@10.1.0: {}
+
+  urlpattern-polyfill@8.0.2: {}
+
+  utf-8-validate@5.0.10:
+    dependencies:
+      node-gyp-build: 4.8.4
+    optional: true
+
+  utf8@3.0.0: {}
+
+  util-deprecate@1.0.2: {}
+
+  util@0.12.5:
+    dependencies:
+      inherits: 2.0.4
+      is-arguments: 1.2.0
+      is-generator-function: 1.1.0
+      is-typed-array: 1.1.15
+      which-typed-array: 1.1.19
+
+  uuid@3.4.0: {}
+
+  uuid@8.3.2: {}
+
+  v8-compile-cache-lib@3.0.1: {}
+
+  varint@6.0.0: {}
+
+  verror@1.10.0:
+    dependencies:
+      assert-plus: 1.0.0
+      core-util-is: 1.0.2
+      extsprintf: 1.3.0
+
+  wcwidth@1.0.1:
+    dependencies:
+      defaults: 1.0.4
+
+  weald@1.0.4:
+    dependencies:
+      ms: 3.0.0-canary.1
+      supports-color: 9.4.0
+
+  web-streams-polyfill@3.3.3: {}
+
+  web3-errors@1.3.1:
+    dependencies:
+      web3-types: 1.10.0
+
+  web3-eth-abi@1.7.0:
+    dependencies:
+      '@ethersproject/abi': 5.0.7
+      web3-utils: 1.7.0
+
+  web3-eth-abi@4.4.1(typescript@5.9.2)(zod@3.25.76):
+    dependencies:
+      abitype: 0.7.1(typescript@5.9.2)(zod@3.25.76)
+      web3-errors: 1.3.1
+      web3-types: 1.10.0
+      web3-utils: 4.3.3
+      web3-validator: 2.0.6
+    transitivePeerDependencies:
+      - typescript
+      - zod
+
+  web3-types@1.10.0: {}
+
+  web3-utils@1.7.0:
+    dependencies:
+      bn.js: 4.12.2
+      ethereum-bloom-filters: 1.2.0
+      ethereumjs-util: 7.1.5
+      ethjs-unit: 0.1.6
+      number-to-bn: 1.7.0
+      randombytes: 2.1.0
+      utf8: 3.0.0
+
+  web3-utils@4.3.3:
+    dependencies:
+      ethereum-cryptography: 2.2.1
+      eventemitter3: 5.0.1
+      web3-errors: 1.3.1
+      web3-types: 1.10.0
+      web3-validator: 2.0.6
+
+  web3-validator@2.0.6:
+    dependencies:
+      ethereum-cryptography: 2.2.1
+      util: 0.12.5
+      web3-errors: 1.3.1
+      web3-types: 1.10.0
+      zod: 3.25.76
+
+  webcrypto-core@1.8.1:
+    dependencies:
+      '@peculiar/asn1-schema': 2.4.0
+      '@peculiar/json-schema': 1.1.12
+      asn1js: 3.0.6
+      pvtsutils: 1.3.6
+      tslib: 2.8.1
+
+  webidl-conversions@3.0.1: {}
+
+  whatwg-url@5.0.0:
+    dependencies:
+      tr46: 0.0.3
+      webidl-conversions: 3.0.1
+
+  wherearewe@2.0.1:
+    dependencies:
+      is-electron: 2.2.2
+
+  which-typed-array@1.1.19:
+    dependencies:
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      for-each: 0.3.5
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-tostringtag: 1.0.2
+
+  which@2.0.2:
+    dependencies:
+      isexe: 2.0.0
+
+  widest-line@3.1.0:
+    dependencies:
+      string-width: 4.2.3
+
+  wordwrap@1.0.0: {}
+
+  wrap-ansi@6.2.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+
+  wrap-ansi@7.0.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+
+  wrap-ansi@8.1.0:
+    dependencies:
+      ansi-styles: 6.2.1
+      string-width: 5.1.2
+      strip-ansi: 7.1.0
+
+  wrappy@1.0.2: {}
+
+  ws@7.5.10(bufferutil@4.0.9)(utf-8-validate@5.0.10):
+    optionalDependencies:
+      bufferutil: 4.0.9
+      utf-8-validate: 5.0.10
+
+  wsl-utils@0.1.0:
+    dependencies:
+      is-wsl: 3.1.0
+
+  xtend@4.0.2: {}
+
+  yallist@4.0.0: {}
+
+  yaml@1.10.2: {}
+
+  yaml@2.8.1: {}
+
+  yargs-parser@21.1.1: {}
+
+  yauzl@2.10.0:
+    dependencies:
+      buffer-crc32: 0.2.13
+      fd-slicer: 1.1.0
+
+  yn@3.1.1: {}
+
+  yoctocolors-cjs@2.1.2: {}
+
+  zod@3.25.76: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
new file mode 100644
index 00000000000..fda7eb3689b
--- /dev/null
+++ b/pnpm-workspace.yaml
@@ -0,0 +1,5 @@
+packages:
+  - tests/integration-tests/*
+  - tests/runner-tests/*
+
+onlyBuiltDependencies:
diff --git a/resources/construction.svg b/resources/construction.svg
deleted file mode 100644
index e4d4ce95625..00000000000
--- a/resources/construction.svg
+++ /dev/null
@@ -1,168 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="842px" height="245px" viewBox="0 0 842 245" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <!-- Generator: Sketch 50 (54983) - http://www.bohemiancoding.com/sketch -->
-    <title>under consctruction 2</title>
-    <desc>Created with Sketch.</desc>
-    <defs></defs>
-    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd" stroke-linecap="round" stroke-linejoin="round">
-        <g id="under-consctruction-2" transform="translate(1.000000, 20.000000)" stroke="#3537C8" stroke-width="0.5">
-            <g id="Group-3" transform="translate(147.000000, 77.000000)">
-                <circle id="Oval" cx="420" cy="13" r="3"></circle>
-                <circle id="Oval" cx="420" cy="37" r="3"></circle>
-                <path d="M405,48 L405,2" id="Shape"></path>
-                <path d="M424,36.75 C424,43.5154882 418.403559,49 411.5,49 C404.596441,49 399,43.5154882 399,36.75 L399,12.25 C399,5.48451181 404.596441,0 411.5,0 C418.403559,0 424,5.48451181 424,12.25" id="Shape"></path>
-                <circle id="Oval" cx="205" cy="13" r="3"></circle>
-                <circle id="Oval" cx="205" cy="37" r="3"></circle>
-                <path d="M190,48 L190,2" id="Shape"></path>
-                <path d="M209,36.75 C209,43.5154882 203.403559,49 196.5,49 C189.596441,49 184,43.5154882 184,36.75 L184,12.25 C184,5.48451181 189.596441,0 196.5,0 C203.403559,0 209,5.48451181 209,12.25" id="Shape"></path>
-                <path d="M61,0 L61,12" id="Shape"></path>
-                <path d="M61,37 L61,49" id="Shape"></path>
-                <path d="M61,0 L67.25,0 C77.6053391,0 86,8.28273213 86,18.5 C86,28.7172679 77.6053391,37 67.25,37 L61,37" id="Shape"></path>
-                <path d="M61,50 L67.25,50 C77.6053391,50 86,41.7172679 86,31.5 C86,21.2827321 77.6053391,13 67.25,13 L61,13" id="Shape"></path>
-                <path d="M61,19 L61,31" id="Shape"></path>
-                <path d="M288,13 L288,38" id="Shape"></path>
-                <path d="M301,12.3265198 C301.000154,6.34521926 296.645124,1.22719469 290.671475,0.188452998 C284.697826,-0.850288697 278.830119,2.49013176 276.755438,8.1106984 C274.680757,13.731265 276.998052,20.0093497 282.251206,23 L282.251206,1.69001466" id="Shape"></path>
-                <path d="M276,37.6734802 C275.999846,43.6547807 280.354876,48.7728053 286.328525,49.811547 C292.302174,50.8502887 298.169881,47.5098682 300.244562,41.8893016 C302.319243,36.268735 300.001948,29.9906503 294.748794,27 L294.748794,48.3469604" id="Shape"></path>
-                <path d="M344,25 L362,43" id="Shape"></path>
-                <path d="M344,31 L362,49" id="Shape"></path>
-                <path d="M337,31 L337,49" id="Shape"></path>
-                <path d="M343.25,6 L349.5,6 C356.40356,6.00000029 362,11.5964408 362,18.5 C362,25.4035592 356.40356,30.9999997 349.5,31 L337,31" id="Shape"></path>
-                <path d="M337,0 L349.5,0 C356.40356,2.90963271e-07 362,5.59644083 362,12.5 C362,19.4035592 356.40356,24.9999997 349.5,25 L343.25,25" id="Shape"></path>
-                <path d="M129,25 L147,43" id="Shape"></path>
-                <path d="M129,31 L147,49" id="Shape"></path>
-                <path d="M123,31 L123,49" id="Shape"></path>
-                <path d="M129.25,6 L135.5,6 C142.40356,6.00000029 148,11.5964408 148,18.5 C148,25.4035592 142.40356,30.9999997 135.5,31 L123,31" id="Shape"></path>
-                <path d="M123,0 L135.5,0 C142.40356,2.90963236e-07 148,5.59644083 148,12.5 C148,19.4035592 142.40356,24.9999997 135.5,25 L129.25,25" id="Shape"></path>
-                <path d="M98,6 L110,6" id="Shape"></path>
-                <path d="M98,43 L110,43" id="Shape"></path>
-                <polyline id="Shape" points="92 12 104.5 0 117 0"></polyline>
-                <polyline id="Shape" points="92 37 104.5 49 117 49"></polyline>
-                <polyline id="Shape" points="98 0 92 0 92 12.25 92 12.25 104 24.5 104 24.5 92 36.75 92 36.75 92 49 98 49"></polyline>
-                <path d="M221,12 C221,8.6862915 223.686292,6 227,6 C230.313708,6 233,8.6862915 233,12" id="Shape"></path>
-                <path d="M240,36.75 L240,12.25 C240,5.48451181 234.403559,0 227.5,0 C220.596441,0 215,5.48451181 215,12.25 L215,36.75 C215,43.5154882 220.596441,49 227.5,49 C234.403559,49 240,43.5154882 240,36.75 Z" id="Shape"></path>
-                <path d="M221,37 C221,40.3137085 223.686292,43 227,43 C230.313708,43 233,40.3137085 233,37" id="Shape"></path>
-                <path d="M227,13 L227,38" id="Shape"></path>
-                <path d="M497,12 C497,8.6862915 499.686292,6 503,6 C506.313708,6 509,8.6862915 509,12" id="Shape"></path>
-                <path d="M516,36.75 L516,12.25 C516,5.48451181 510.403559,0 503.5,0 C496.596441,0 491,5.48451181 491,12.25 L491,36.75 C491,43.5154882 496.596441,49 503.5,49 C510.403559,49 516,43.5154882 516,36.75 Z" id="Shape"></path>
-                <path d="M497,37 C497,40.3137085 499.686292,43 503,43 C506.313708,43 509,40.3137085 509,37" id="Shape"></path>
-                <path d="M503,13 L503,38" id="Shape"></path>
-                <path d="M522,25 L547,50" id="Shape"></path>
-                <path d="M546,43 L534,31" id="Shape"></path>
-                <path d="M540,31 L546,37" id="Shape"></path>
-                <path d="M522,0 L547,25" id="Shape"></path>
-                <path d="M522,6 L534,18" id="Shape"></path>
-                <path d="M528,19 L522,13" id="Shape"></path>
-                <path d="M522,49 L522,0" id="Shape"></path>
-                <path d="M546,49 L546,0" id="Shape"></path>
-                <path d="M528,25 L540,25" id="Shape"></path>
-                <path d="M30,25 L55,50" id="Shape"></path>
-                <path d="M55,43 L43,31" id="Shape"></path>
-                <path d="M49,31 L55,37" id="Shape"></path>
-                <path d="M30,0 L55,25" id="Shape"></path>
-                <path d="M30,6 L42,18" id="Shape"></path>
-                <path d="M36,19 L30,13" id="Shape"></path>
-                <path d="M30,49 L30,0" id="Shape"></path>
-                <path d="M55,49 L55,0" id="Shape"></path>
-                <path d="M37,25 L49,25" id="Shape"></path>
-                <path d="M245,25 L270,50" id="Shape"></path>
-                <path d="M270,43 L258,31" id="Shape"></path>
-                <path d="M264,31 L270,37" id="Shape"></path>
-                <path d="M245,0 L270,25" id="Shape"></path>
-                <path d="M245,6 L257,18" id="Shape"></path>
-                <path d="M251,19 L245,13" id="Shape"></path>
-                <path d="M245,49 L245,0" id="Shape"></path>
-                <path d="M270,49 L270,0" id="Shape"></path>
-                <path d="M251,25 L263,25" id="Shape"></path>
-                <path d="M319,0 L319,49" id="Shape"></path>
-                <path d="M307,6 L332,6" id="Shape"></path>
-                <polyline id="Shape" points="332 12 319.5 0 307 12"></polyline>
-                <polyline id="Shape" points="307 12 307 0 332 0 332 12"></polyline>
-                <path d="M313,50 L325,50" id="Shape"></path>
-                <path d="M442,0 L442,49" id="Shape"></path>
-                <path d="M430,6 L455,6" id="Shape"></path>
-                <polyline id="Shape" points="455 12 442.5 0 430 12"></polyline>
-                <polyline id="Shape" points="430 12 430 0 455 0 455 12"></polyline>
-                <path d="M436,50 L448,50" id="Shape"></path>
-                <path d="M374,0 L374,48" id="Shape"></path>
-                <path d="M387,0 L387,48" id="Shape"></path>
-                <path d="M386.75,0 C386.75,3.38274409 389.54822,6.125 393,6.125 L393,36.75 C393,43.5154882 387.403559,49 380.5,49 C373.596441,49 368,43.5154882 368,36.75 L368,6.125 C371.45178,6.125 374.25,3.38274409 374.25,0" id="Shape"></path>
-                <path d="M6,0 L6,48" id="Shape"></path>
-                <path d="M18,0 L18,48" id="Shape"></path>
-                <path d="M18.75,0 C18.75,3.38274409 21.5482203,6.125 25,6.125 L25,36.75 C25,43.5154882 19.4035594,49 12.5,49 C5.59644063,49 0,43.5154882 0,36.75 L0,6.125 C3.45177969,6.125 6.25,3.38274409 6.25,0" id="Shape"></path>
-                <path d="M473,6 L473,43" id="Shape"></path>
-                <path d="M466,0 L466,49" id="Shape"></path>
-                <path d="M479,49 L479,0" id="Shape"></path>
-                <polyline id="Shape" points="460 0 466.25 0 466.25 0 472.5 6 478.75 0 478.75 0 485 0"></polyline>
-                <polyline id="Shape" points="460 49 466.25 49 466.25 49 472.5 43 478.75 49 485 49"></polyline>
-            </g>
-            <g id="Group-2" transform="translate(0.000000, 193.000000)">
-                <path d="M320.08,0.81 L330.08,10.81" id="Shape"></path>
-                <path d="M330.08,0.81 L340.08,10.81" id="Shape"></path>
-                <path d="M340.08,0.81 L350.08,10.81" id="Shape"></path>
-                <path d="M350.08,0.81 L360.08,10.81" id="Shape"></path>
-                <path d="M360.08,0.81 L370.08,10.81" id="Shape"></path>
-                <path d="M370.08,0.81 L380.08,10.81" id="Shape"></path>
-                <path d="M380.08,0.81 L390.08,10.81" id="Shape"></path>
-                <path d="M390.08,0.81 L400.08,10.81" id="Shape"></path>
-                <path d="M400.08,0.81 L410.08,10.81" id="Shape"></path>
-                <path d="M410.08,0.81 L420.08,10.81" id="Shape"></path>
-                <path d="M420.08,0.81 L430.08,10.81" id="Shape"></path>
-                <path d="M430.08,0.81 L440.08,10.81" id="Shape"></path>
-                <path d="M440.08,0.81 L450.08,10.81" id="Shape"></path>
-                <path d="M450.08,0.81 L460.08,10.81" id="Shape"></path>
-                <path d="M520.08,0.81 L510.08,10.81" id="Shape"></path>
-                <path d="M510.08,0.81 L500.08,10.81" id="Shape"></path>
-                <path d="M500.08,0.81 L490.08,10.81" id="Shape"></path>
-                <path d="M490.08,0.81 L480.08,10.81" id="Shape"></path>
-                <path d="M480.08,0.81 L470.08,10.81" id="Shape"></path>
-                <path d="M470.08,0.81 L460.08,10.81" id="Shape"></path>
-                <path d="M460.08,0.81 L450.08,10.81" id="Shape"></path>
-                <path d="M450.08,0.81 L440.08,10.81" id="Shape"></path>
-                <path d="M440.08,0.81 L430.08,10.81" id="Shape"></path>
-                <path d="M430.08,0.81 L420.08,10.81" id="Shape"></path>
-                <path d="M420.08,0.81 L410.08,10.81" id="Shape"></path>
-                <path d="M410.08,0.81 L400.08,10.81" id="Shape"></path>
-                <path d="M400.08,0.81 L390.08,10.81" id="Shape"></path>
-                <path d="M390.08,0.81 L380.08,10.81" id="Shape"></path>
-                <path d="M308.66,5.81 L16.17,5.81" id="Shape"></path>
-                <rect id="Rectangle-path" transform="translate(5.240088, 5.812538) rotate(-45.000000) translate(-5.240088, -5.812538) " x="1.70508807" y="2.27753793" width="7.07" height="7.07"></rect>
-                <path d="M531.51,5.81 L824,5.81" id="Shape"></path>
-                <rect id="Rectangle-path" transform="translate(834.915371, 5.807255) rotate(-45.000000) translate(-834.915371, -5.807255) " x="831.380371" y="2.27225479" width="7.07" height="7.07"></rect>
-            </g>
-            <g id="Group">
-                <path d="M520.08,10.25 L510.08,0.25" id="Shape"></path>
-                <path d="M510.08,10.25 L500.08,0.25" id="Shape"></path>
-                <path d="M500.08,10.25 L490.08,0.25" id="Shape"></path>
-                <path d="M490.08,10.25 L480.08,0.25" id="Shape"></path>
-                <path d="M480.08,10.25 L470.08,0.25" id="Shape"></path>
-                <path d="M470.08,10.25 L460.08,0.25" id="Shape"></path>
-                <path d="M460.08,10.25 L450.08,0.25" id="Shape"></path>
-                <path d="M450.08,10.25 L440.08,0.25" id="Shape"></path>
-                <path d="M440.08,10.25 L430.08,0.25" id="Shape"></path>
-                <path d="M430.08,10.25 L420.08,0.25" id="Shape"></path>
-                <path d="M420.08,10.25 L410.08,0.25" id="Shape"></path>
-                <path d="M410.08,10.25 L400.08,0.25" id="Shape"></path>
-                <path d="M400.08,10.25 L390.08,0.25" id="Shape"></path>
-                <path d="M390.08,10.25 L380.08,0.25" id="Shape"></path>
-                <path d="M320.08,10.25 L330.08,0.25" id="Shape"></path>
-                <path d="M330.08,10.25 L340.08,0.25" id="Shape"></path>
-                <path d="M340.08,10.25 L350.08,0.25" id="Shape"></path>
-                <path d="M350.08,10.25 L360.08,0.25" id="Shape"></path>
-                <path d="M360.08,10.25 L370.08,0.25" id="Shape"></path>
-                <path d="M370.08,10.25 L380.08,0.25" id="Shape"></path>
-                <path d="M380.08,10.25 L390.08,0.25" id="Shape"></path>
-                <path d="M390.08,10.25 L400.08,0.25" id="Shape"></path>
-                <path d="M400.08,10.25 L410.08,0.25" id="Shape"></path>
-                <path d="M410.08,10.25 L420.08,0.25" id="Shape"></path>
-                <path d="M420.08,10.25 L430.08,0.25" id="Shape"></path>
-                <path d="M430.08,10.25 L440.08,0.25" id="Shape"></path>
-                <path d="M440.08,10.25 L450.08,0.25" id="Shape"></path>
-                <path d="M450.08,10.25 L460.08,0.25" id="Shape"></path>
-                <path d="M531.51,5.25 L824,5.25" id="Shape"></path>
-                <rect id="Rectangle-path" transform="translate(834.912833, 5.254717) rotate(-45.000000) translate(-834.912833, -5.254717) " x="831.377833" y="1.71971685" width="7.07" height="7.07"></rect>
-                <path d="M308.66,5.25 L16.17,5.25" id="Shape"></path>
-                <rect id="Rectangle-path" transform="translate(5.247550, 5.250000) rotate(-45.000000) translate(-5.247550, -5.250000) " x="1.71255013" y="1.715" width="7.07" height="7.07"></rect>
-            </g>
-        </g>
-    </g>
-</svg>
\ No newline at end of file
diff --git a/runtime/derive/Cargo.toml b/runtime/derive/Cargo.toml
index ecf7cb3818f..82f46d5e560 100644
--- a/runtime/derive/Cargo.toml
+++ b/runtime/derive/Cargo.toml
@@ -7,7 +7,5 @@ edition.workspace = true
 proc-macro = true
 
 [dependencies]
-syn = { version = "1.0.98", features = ["full"] }
+syn = { workspace = true }
 quote = "1.0"
-proc-macro2 = "1.0.73"
-heck = "0.4"
diff --git a/runtime/derive/src/generate_array_type.rs b/runtime/derive/src/generate_array_type.rs
deleted file mode 100644
index f690b1ebd5a..00000000000
--- a/runtime/derive/src/generate_array_type.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::{Ident, Span};
-use quote::quote;
-use syn::{self, parse_macro_input, AttributeArgs, ItemStruct, Meta, NestedMeta, Path};
-
-pub fn generate_array_type(metadata: TokenStream, input: TokenStream) -> TokenStream {
-    let item_struct = parse_macro_input!(input as ItemStruct);
-    let name = item_struct.ident.clone();
-
-    let asc_name = Ident::new(&format!("Asc{}", name), Span::call_site());
-    let asc_name_array = Ident::new(&format!("Asc{}Array", name), Span::call_site());
-
-    let args = parse_macro_input!(metadata as AttributeArgs);
-
-    let args = args
-        .iter()
-        .filter_map(|a| {
-            if let NestedMeta::Meta(Meta::Path(Path { segments, .. })) = a {
-                if let Some(p) = segments.last() {
-                    return Some(p.ident.to_string());
-                }
-            }
-            None
-        })
-        .collect::<Vec<String>>();
-
-    assert!(
-        !args.is_empty(),
-        "arguments not found! generate_array_type(<network-name>)"
-    );
-
-    let no_asc_name = if name.to_string().to_uppercase().starts_with("ASC") {
-        name.to_string()[3..].to_owned()
-    } else {
-        name.to_string()
-    };
-
-    let index_asc_type_id_array = format!("{}{}Array", args[0], no_asc_name)
-        .parse::<proc_macro2::TokenStream>()
-        .unwrap();
-
-    quote! {
-        #item_struct
-
-        #[automatically_derived]
-        pub struct #asc_name_array(pub  graph_runtime_wasm::asc_abi::class::Array<graph::runtime::AscPtr<#asc_name>>);
-
-        impl graph::runtime::ToAscObj<#asc_name_array> for Vec<#name> {
-            fn to_asc_obj<H: graph::runtime::AscHeap + ?Sized>(
-                &self,
-                heap: &mut H,
-                gas: &graph::runtime::gas::GasCounter,
-            ) -> Result<#asc_name_array, graph::runtime::HostExportError> {
-                let content: Result<Vec<_>, _> = self.iter().map(|x| graph::runtime::asc_new(heap, x, gas)).collect();
-
-                Ok(#asc_name_array(graph_runtime_wasm::asc_abi::class::Array::new(&content?, heap, gas)?))
-            }
-        }
-
-        impl graph::runtime::AscType for #asc_name_array {
-            fn to_asc_bytes(&self) -> Result<Vec<u8>, graph::runtime::DeterministicHostError> {
-                self.0.to_asc_bytes()
-            }
-
-            fn from_asc_bytes(
-                asc_obj: &[u8],
-                api_version: &graph::semver::Version,
-            ) -> Result<Self, graph::runtime::DeterministicHostError> {
-                Ok(Self(graph_runtime_wasm::asc_abi::class::Array::from_asc_bytes(asc_obj, api_version)?))
-            }
-        }
-
-        #[automatically_derived]
-        impl graph::runtime::AscIndexId for #asc_name_array {
-            const INDEX_ASC_TYPE_ID: graph::runtime::IndexForAscTypeId = graph::runtime::IndexForAscTypeId::#index_asc_type_id_array ;
-        }
-
-    }
-    .into()
-}
diff --git a/runtime/derive/src/generate_asc_type.rs b/runtime/derive/src/generate_asc_type.rs
deleted file mode 100644
index 0d79f08482c..00000000000
--- a/runtime/derive/src/generate_asc_type.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::{Ident, Span};
-use quote::quote;
-use syn::{self, parse_macro_input, Field, ItemStruct};
-
-pub fn generate_asc_type(metadata: TokenStream, input: TokenStream) -> TokenStream {
-    let item_struct = parse_macro_input!(input as ItemStruct);
-    let args = parse_macro_input!(metadata as super::Args);
-
-    let name = item_struct.ident.clone();
-    let asc_name = Ident::new(&format!("Asc{}", name), Span::call_site());
-
-    let enum_names = args
-        .vars
-        .iter()
-        .filter(|f| f.ident != super::REQUIRED_IDENT_NAME)
-        .map(|f| f.ident.to_string())
-        .collect::<Vec<String>>();
-
-    //struct's fields -> need to skip enum fields
-    let mut fields = item_struct
-        .fields
-        .iter()
-        .filter(|f| !enum_names.contains(&f.ident.as_ref().unwrap().to_string()))
-        .collect::<Vec<&Field>>();
-
-    //extend fields list with enum's variants
-    args.vars
-        .iter()
-        .filter(|f| f.ident != super::REQUIRED_IDENT_NAME)
-        .flat_map(|f| f.fields.named.iter())
-        .for_each(|f| fields.push(f));
-
-    let m_fields: Vec<proc_macro2::TokenStream> = fields
-        .iter()
-        .map(|f| {
-            let fld_name = f.ident.clone().unwrap();
-            let typ = field_type_map(field_type(f));
-            let fld_type = typ.parse::<proc_macro2::TokenStream>().unwrap();
-
-            quote! {
-                pub #fld_name : #fld_type ,
-            }
-        })
-        .collect();
-
-    let expanded = quote! {
-
-        #item_struct
-
-        #[automatically_derived]
-
-        #[repr(C)]
-        #[derive(graph_runtime_derive::AscType)]
-        #[derive(Debug, Default)]
-        pub struct #asc_name {
-            #(#m_fields)*
-        }
-    };
-
-    expanded.into()
-}
-
-fn is_scalar(nm: &str) -> bool {
-    match nm {
-        "i8" | "u8" => true,
-        "i16" | "u16" => true,
-        "i32" | "u32" => true,
-        "i64" | "u64" => true,
-        "usize" | "isize" => true,
-        "bool" => true,
-        _ => false,
-    }
-}
-
-fn field_type_map(tp: String) -> String {
-    if is_scalar(&tp) {
-        tp
-    } else {
-        match tp.as_ref() {
-            "String" => "graph_runtime_wasm::asc_abi::class::AscString".into(),
-            _ => tp.clone(),
-        }
-    }
-}
-
-fn field_type(fld: &syn::Field) -> String {
-    if let syn::Type::Path(tp) = &fld.ty {
-        if let Some(ps) = tp.path.segments.last() {
-            let name = ps.ident.to_string();
-            //TODO - this must be optimized
-            match name.as_ref() {
-                "Vec" => match &ps.arguments {
-                    syn::PathArguments::AngleBracketed(v) => {
-                        if let syn::GenericArgument::Type(syn::Type::Path(p)) = &v.args[0] {
-                            let nm = path_to_string(&p.path);
-
-                            match nm.as_ref(){
-                                    "u8" => "graph::runtime::AscPtr<graph_runtime_wasm::asc_abi::class::Uint8Array>".to_owned(),
-                                    "Vec<u8>" => "graph::runtime::AscPtr<crate::protobuf::AscBytesArray>".to_owned(),
-                                    "String" => "graph::runtime::AscPtr<crate::protobuf::Array<graph::runtime::AscPtr<graph_runtime_wasm::asc_abi::class::AscString>>>".to_owned(),
-                                    _ => format!("graph::runtime::AscPtr<crate::protobuf::Asc{}Array>", path_to_string(&p.path))
-                                }
-                        } else {
-                            name
-                        }
-                    }
-
-                    syn::PathArguments::None => name,
-                    syn::PathArguments::Parenthesized(_v) => {
-                        panic!("syn::PathArguments::Parenthesized is not implemented")
-                    }
-                },
-                "Option" => match &ps.arguments {
-                    syn::PathArguments::AngleBracketed(v) => {
-                        if let syn::GenericArgument::Type(syn::Type::Path(p)) = &v.args[0] {
-                            let tp_nm = path_to_string(&p.path);
-                            if is_scalar(&tp_nm) {
-                                format!("Option<{}>", tp_nm)
-                            } else {
-                                format!("graph::runtime::AscPtr<crate::protobuf::Asc{}>", tp_nm)
-                            }
-                        } else {
-                            name
-                        }
-                    }
-
-                    syn::PathArguments::None => name,
-                    syn::PathArguments::Parenthesized(_v) => {
-                        panic!("syn::PathArguments::Parenthesized is not implemented")
-                    }
-                },
-                "String" => {
-                    //format!("graph::runtime::AscPtr<Asc{}>", name)
-                    "graph::runtime::AscPtr<graph_runtime_wasm::asc_abi::class::AscString>"
-                        .to_owned()
-                }
-
-                _ => {
-                    if is_scalar(&name) {
-                        name
-                    } else {
-                        format!("graph::runtime::AscPtr<Asc{}>", name)
-                    }
-                }
-            }
-        } else {
-            "N/A".into()
-        }
-    } else {
-        "N/A".into()
-    }
-}
-
-//recursive
-fn path_to_string(path: &syn::Path) -> String {
-    if let Some(ps) = path.segments.last() {
-        let nm = ps.ident.to_string();
-
-        if let syn::PathArguments::AngleBracketed(v) = &ps.arguments {
-            if let syn::GenericArgument::Type(syn::Type::Path(p)) = &v.args[0] {
-                format!("{}<{}>", nm, path_to_string(&p.path))
-            } else {
-                nm
-            }
-        } else {
-            nm
-        }
-    } else {
-        panic!("path_to_string - can't get last segment!")
-    }
-}
diff --git a/runtime/derive/src/generate_from_rust_type.rs b/runtime/derive/src/generate_from_rust_type.rs
deleted file mode 100644
index 6e24ad78c8c..00000000000
--- a/runtime/derive/src/generate_from_rust_type.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::{Ident, Span};
-use quote::quote;
-use syn::{self, parse_macro_input, Field, ItemStruct};
-
-pub fn generate_from_rust_type(metadata: TokenStream, input: TokenStream) -> TokenStream {
-    let item_struct = parse_macro_input!(input as ItemStruct);
-    let args = parse_macro_input!(metadata as super::Args);
-
-    let enum_names = args
-        .vars
-        .iter()
-        .filter(|f| f.ident != super::REQUIRED_IDENT_NAME)
-        .map(|f| f.ident.to_string())
-        .collect::<Vec<String>>();
-
-    let required_flds = args
-        .vars
-        .iter()
-        .filter(|f| f.ident == super::REQUIRED_IDENT_NAME)
-        .flat_map(|f| f.fields.named.iter())
-        .map(|f| f.ident.as_ref().unwrap().to_string())
-        .collect::<Vec<String>>();
-
-    //struct's standard fields
-    let fields = item_struct
-        .fields
-        .iter()
-        .filter(|f| {
-            let nm = f.ident.as_ref().unwrap().to_string();
-            !enum_names.contains(&nm) && !nm.starts_with('_')
-        })
-        .collect::<Vec<&Field>>();
-
-    //struct's enum fields
-    let enum_fields = item_struct
-        .fields
-        .iter()
-        .filter(|f| enum_names.contains(&f.ident.as_ref().unwrap().to_string()))
-        .collect::<Vec<&Field>>();
-
-    //module name
-    let mod_name = Ident::new(
-        &format!("__{}__", item_struct.ident.to_string().to_lowercase()),
-        item_struct.ident.span(),
-    );
-
-    let name = item_struct.ident.clone();
-    let asc_name = Ident::new(&format!("Asc{}", name), Span::call_site());
-
-    //generate enum fields validator
-    let enum_validation = enum_fields.iter().map(|f|{
-        let fld_name = f.ident.as_ref().unwrap(); //empty, maybe call it "sum"?
-        let type_nm = format!("\"{}\"", name).parse::<proc_macro2::TokenStream>().unwrap();
-        let fld_nm = format!("\"{}\"", fld_name).parse::<proc_macro2::TokenStream>().unwrap();
-
-        quote! {
-            let #fld_name = self.#fld_name.as_ref()
-                .ok_or_else(||  graph::runtime::HostExportError::from(graph::runtime::DeterministicHostError::from(anyhow::anyhow!("{} missing {}", #type_nm, #fld_nm))))?;
-            }
-    });
-
-    let mut methods:Vec<proc_macro2::TokenStream> =
-        fields.iter().map(|f| {
-            let fld_name = f.ident.as_ref().unwrap();
-            let self_ref =
-                if is_byte_array(f){
-                    quote! { graph_runtime_wasm::asc_abi::class::Bytes(&self.#fld_name) }
-                }else{
-                    quote!{ self.#fld_name }
-                };
-
-            let is_required = is_required(f, &required_flds);
-
-            let setter =
-                if is_nullable(f) {
-                    if is_required{
-                        let type_nm = format!("\"{}\"", name).parse::<proc_macro2::TokenStream>().unwrap();
-                        let fld_nm = format!("\"{}\"", fld_name).parse::<proc_macro2::TokenStream>().unwrap();
-
-                        quote! {
-                            #fld_name: graph::runtime::asc_new_or_missing(heap, &#self_ref, gas, #type_nm, #fld_nm)?,
-                        }
-                    }else{
-                        quote! {
-                            #fld_name: graph::runtime::asc_new_or_null(heap, &#self_ref, gas)?,
-                        }
-                    }
-                } else if is_scalar(&field_type(f)){
-                    quote!{
-                        #fld_name: #self_ref,
-                    }
-                }else{
-                    quote! {
-                        #fld_name: graph::runtime::asc_new(heap, &#self_ref, gas)?,
-                    }
-                };
-            setter
-        })
-        .collect();
-
-    for var in args.vars {
-        let var_nm = var.ident.to_string();
-        if var_nm == super::REQUIRED_IDENT_NAME {
-            continue;
-        }
-
-        let mut c = var_nm.chars();
-        let var_type_name = c.next().unwrap().to_uppercase().collect::<String>() + c.as_str();
-
-        var.fields.named.iter().map(|f|{
-
-            let fld_nm = f.ident.as_ref().unwrap();
-            let var_nm = var.ident.clone();
-
-            use heck::{ToUpperCamelCase, ToSnakeCase};
-
-            let varian_type_name = fld_nm.to_string().to_upper_camel_case();
-            let mod_name = item_struct.ident.to_string().to_snake_case();
-            let varian_type_name = format!("{}::{}::{}",mod_name, var_type_name, varian_type_name).parse::<proc_macro2::TokenStream>().unwrap();
-
-            if is_byte_array(f){
-                    quote! {
-                        #fld_nm: if let #varian_type_name(v) = #var_nm {graph::runtime::asc_new(heap, &graph_runtime_wasm::asc_abi::class::Bytes(v), gas)? } else {graph::runtime::AscPtr::null()},
-                    }
-                }else{
-                    quote! {
-                        #fld_nm: if let #varian_type_name(v) = #var_nm {graph::runtime::asc_new(heap, v, gas)? } else {graph::runtime::AscPtr::null()},
-                    }
-                }
-        })
-        .for_each(|ts| methods.push(ts));
-    }
-
-    let expanded = quote! {
-        #item_struct
-
-        #[automatically_derived]
-        mod #mod_name{
-            use super::*;
-
-            use crate::protobuf::*;
-
-            impl graph::runtime::ToAscObj<#asc_name> for #name {
-
-                #[allow(unused_variables)]
-                fn to_asc_obj<H: graph::runtime::AscHeap + ?Sized>(
-                    &self,
-                    heap: &mut H,
-                    gas: &graph::runtime::gas::GasCounter,
-                ) -> Result<#asc_name, graph::runtime::HostExportError> {
-
-                    #(#enum_validation)*
-
-                    Ok(
-                         #asc_name {
-                            #(#methods)*
-                            ..Default::default()
-                        }
-                    )
-                }
-            }
-        } // -------- end of mod
-
-
-    };
-
-    expanded.into()
-}
-
-fn is_scalar(fld: &str) -> bool {
-    match fld {
-        "i8" | "u8" => true,
-        "i16" | "u16" => true,
-        "i32" | "u32" => true,
-        "i64" | "u64" => true,
-        "usize" | "isize" => true,
-        "bool" => true,
-        _ => false,
-    }
-}
-
-fn field_type(fld: &syn::Field) -> String {
-    if let syn::Type::Path(tp) = &fld.ty {
-        if let Some(ps) = tp.path.segments.last() {
-            ps.ident.to_string()
-        } else {
-            "N/A".into()
-        }
-    } else {
-        "N/A".into()
-    }
-}
-
-fn is_required(fld: &syn::Field, req_list: &[String]) -> bool {
-    let fld_name = fld.ident.as_ref().unwrap().to_string();
-    req_list.iter().any(|r| r == &fld_name)
-}
-
-fn is_nullable(fld: &syn::Field) -> bool {
-    if let syn::Type::Path(tp) = &fld.ty {
-        if let Some(last) = tp.path.segments.last() {
-            return last.ident == "Option";
-        }
-    }
-    false
-}
-
-fn is_byte_array(fld: &syn::Field) -> bool {
-    if let syn::Type::Path(tp) = &fld.ty {
-        if let Some(last) = tp.path.segments.last() {
-            if last.ident == "Vec" {
-                if let syn::PathArguments::AngleBracketed(ref v) = last.arguments {
-                    if let Some(last) = v.args.last() {
-                        if let syn::GenericArgument::Type(t) = last {
-                            if let syn::Type::Path(p) = t {
-                                if let Some(a) = p.path.segments.last() {
-                                    return a.ident == "u8";
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    false
-}
diff --git a/runtime/derive/src/generate_network_type_id.rs b/runtime/derive/src/generate_network_type_id.rs
deleted file mode 100644
index a3672a92c7c..00000000000
--- a/runtime/derive/src/generate_network_type_id.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::{Ident, Span};
-use quote::quote;
-use syn::{self, parse_macro_input, AttributeArgs, ItemStruct, Meta, NestedMeta, Path};
-
-pub fn generate_network_type_id(metadata: TokenStream, input: TokenStream) -> TokenStream {
-    let item_struct = parse_macro_input!(input as ItemStruct);
-    let name = item_struct.ident.clone();
-
-    let asc_name = if name.to_string().to_uppercase().starts_with("ASC") {
-        name.clone()
-    } else {
-        Ident::new(&format!("Asc{}", name), Span::call_site())
-    };
-
-    let no_asc_name = if name.to_string().to_uppercase().starts_with("ASC") {
-        name.to_string()[3..].to_owned()
-    } else {
-        name.to_string()
-    };
-
-    let args = parse_macro_input!(metadata as AttributeArgs);
-
-    let args = args
-        .iter()
-        .filter_map(|a| {
-            if let NestedMeta::Meta(Meta::Path(Path { segments, .. })) = a {
-                if let Some(p) = segments.last() {
-                    return Some(p.ident.to_string());
-                }
-            }
-            None
-        })
-        .collect::<Vec<String>>();
-
-    assert!(
-        !args.is_empty(),
-        "arguments not found! generate_network_type_id(<network-name>)"
-    );
-
-    //type_id variant name
-    let index_asc_type_id = format!("{}{}", args[0], no_asc_name)
-        .parse::<proc_macro2::TokenStream>()
-        .unwrap();
-
-    let expanded = quote! {
-        #item_struct
-
-        #[automatically_derived]
-        impl graph::runtime::AscIndexId for #asc_name {
-            const INDEX_ASC_TYPE_ID: graph::runtime::IndexForAscTypeId = graph::runtime::IndexForAscTypeId::#index_asc_type_id ;
-        }
-    };
-
-    expanded.into()
-}
diff --git a/runtime/derive/src/lib.rs b/runtime/derive/src/lib.rs
index f95c11fac4b..6238797ce50 100644
--- a/runtime/derive/src/lib.rs
+++ b/runtime/derive/src/lib.rs
@@ -4,162 +4,7 @@ extern crate proc_macro;
 
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{
-    parse::{Parse, ParseStream},
-    Fields, FieldsNamed, Ident, Item, ItemEnum, ItemStruct, Token,
-};
-
-const REQUIRED_IDENT_NAME: &str = "__required__";
-
-struct Args {
-    vars: Vec<ArgsField>,
-}
-
-struct ArgsField {
-    ident: Ident,
-    fields: FieldsNamed,
-}
-
-impl Parse for Args {
-    fn parse(input: ParseStream) -> syn::Result<Self> {
-        let mut idents = Vec::<ArgsField>::new();
-
-        while input.peek(syn::Ident) {
-            let ident = input.call(Ident::parse)?;
-            idents.push(ArgsField {
-                ident,
-                fields: input.call(FieldsNamed::parse)?,
-            });
-            let _: Option<Token![,]> = input.parse()?;
-        }
-
-        Ok(Args { vars: idents })
-    }
-}
-
-#[derive(Debug)]
-struct TypeParam(syn::Ident);
-
-impl syn::parse::Parse for TypeParam {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let content;
-        syn::parenthesized!(content in input);
-        let typ = content.parse()?;
-        Ok(TypeParam(typ))
-    }
-}
-
-#[derive(Debug)]
-struct TypeParamList(Vec<syn::Ident>);
-
-impl syn::parse::Parse for TypeParamList {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let content;
-        syn::parenthesized!(content in input);
-
-        let mut params: Vec<syn::Ident> = Vec::new();
-
-        while !content.is_empty() {
-            let typ = content.parse()?;
-            params.push(typ);
-
-            if !content.is_empty() {
-                let _comma: syn::Token![,] = content.parse()?;
-            }
-        }
-
-        Ok(TypeParamList(params))
-    }
-}
-
-//generates graph::runtime::ToAscObj implementation for the type
-//takes optional optional list of required fields '__required__{name:TypeName}' and enumerations field decraration with types, i.e. sum{single: ModeInfoSingle,multi: ModeInfoMulti}
-//intended use is in build.rs with tonic_build's type_attribute(<...>, <...>) to generate type implementation of graph::runtime::ToAscObj
-//Annotation example:
-//#[graph_runtime_derive::generate_from_rust_type(...)]
-// pub struct MyMessageType {
-//    ..
-// }
-//the above annotation will produce following implementation
-//  impl graph::runtime::ToAscObj<AscMyMessageType> for MyMessageType {
-//    ...
-//  }
-mod generate_from_rust_type;
-#[proc_macro_attribute]
-pub fn generate_from_rust_type(args: TokenStream, input: TokenStream) -> TokenStream {
-    generate_from_rust_type::generate_from_rust_type(args, input)
-}
-
-//generates graph::runtime::AscIndexId implementation for the type
-//takes required network name attribute to form variant name graph::runtime::IndexForAscTypeId::<NetworkName>+<TypeName>
-//Annotation example:
-//#[graph_runtime_derive::generate_network_type_id(Cosmos)]
-// pub struct MyMessageType {
-//    ..
-// }
-//the above annotation will produce following implementation
-//  impl graph::runtime::AscIndexId for AscMyMessageType {
-//     const INDEX_ASC_TYPE_ID: graph::runtime::IndexForAscTypeId = graph::runtime::IndexForAscTypeId::CosmosMyMessageType ;
-//  }
-
-mod generate_network_type_id;
-#[proc_macro_attribute]
-pub fn generate_network_type_id(args: TokenStream, input: TokenStream) -> TokenStream {
-    generate_network_type_id::generate_network_type_id(args, input)
-}
-
-//generates AscType for Type. Takes optional list of non-optional field+type
-//Annotation example:
-//#[graph_runtime_derive::generate_asc_type(non-optional-field-name: non-optional-field-type,...)]
-// pub struct MyMessageType {
-//    ..
-// }
-//the above annotation will produce following implementation
-// #[repr(C)]
-// #[derive(graph_runtime_derive::AscType)]
-// #[derive(Debug, Default)]
-// pub struct AscMyMessageType {
-//    ...
-// }
-//
-//Note: this macro makes heavy reliance on types to be available via crate::protobuf (network chain crate root/src/protobuf/lib.rs)
-//please see usage exmple in chain::cosmos crate... lib.rs imports generates protobuf bindings, as well as any other needed types
-mod generate_asc_type;
-#[proc_macro_attribute]
-pub fn generate_asc_type(args: TokenStream, input: TokenStream) -> TokenStream {
-    generate_asc_type::generate_asc_type(args, input)
-}
-
-//generates array type for a type.
-//Annotation example:
-// #[graph_runtime_derive::generate_array_type(<network name, i.e. Cosmos>>)]
-// pub struct MyMessageType {
-//    ..
-// }
-//the above annoation will generate code for MyMessageType type
-//Example:
-//  pub struct AscMyMessageTypeArray(pub  graph_runtime_wasm::asc_abi::class::Array<graph::runtime::AscPtr<AscMyMessageType>>)
-//where "AscMyMessageTypeArray" is an array type for "AscMyMessageType" (AscMyMessageType is generated by asc_type derive macro above)
-//Macro, also, will generate code for the following 3 trait implementations
-//1. graph::runtime::ToAscObj trait
-//Example:
-//  impl graph::runtime::ToAscObj<AscMyMessageTypeArray> for Vec<AscMyMessageType> {
-//     ...
-//  }
-//2. graph::runtime::AscType
-//Example:
-//  impl graph::runtime::AscType for AscMyMessageTypeArray {
-//    ...
-//    }
-//3. graph::runtime::AscIndexId (adding expected <NetworkName><BaseType>>Array (CosmosMyMessageTypeArray)  variant to graph::runtime::IndexForAscTypeId is manual step)
-//impl graph::runtime::AscIndexId for MyMessageTypeArray {
-//    const INDEX_ASC_TYPE_ID: graph::runtime::IndexForAscTypeId = graph::runtime::IndexForAscTypeId::CosmosMyMessageTypeArray ;
-//}
-mod generate_array_type;
-#[proc_macro_attribute]
-pub fn generate_array_type(args: TokenStream, input: TokenStream) -> TokenStream {
-    generate_array_type::generate_array_type(args, input)
-}
+use syn::{Fields, Item, ItemEnum, ItemStruct};
 
 #[proc_macro_derive(AscType)]
 pub fn asc_type_derive(input: TokenStream) -> TokenStream {
diff --git a/runtime/test/Cargo.toml b/runtime/test/Cargo.toml
index 2cc71f39944..783596feb40 100644
--- a/runtime/test/Cargo.toml
+++ b/runtime/test/Cargo.toml
@@ -4,14 +4,13 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-semver = "1.0"
-wasmtime = "0.27.0"
+async-trait = { workspace = true }
+semver = { workspace = true }
+wasmtime = { workspace = true }
 graph = { path = "../../graph" }
 graph-chain-ethereum = { path = "../../chain/ethereum" }
 graph-runtime-wasm = { path = "../wasm" }
-graph-core = { path = "../../core" }
-graph-runtime-derive = { path = "../derive" }
-rand = "0.8.5"
+rand = { workspace = true }
 
 
 [dev-dependencies]
diff --git a/runtime/test/src/common.rs b/runtime/test/src/common.rs
index 06dc526bc94..b08251c8604 100644
--- a/runtime/test/src/common.rs
+++ b/runtime/test/src/common.rs
@@ -1,20 +1,20 @@
-use ethabi::Contract;
 use graph::blockchain::BlockTime;
-use graph::components::store::DeploymentLocator;
+use graph::components::store::{DeploymentLocator, SeqGenerator};
+use graph::components::subgraph::SharedProofOfIndexing;
 use graph::data::subgraph::*;
 use graph::data_source;
+use graph::data_source::common::MappingABI;
 use graph::env::EnvVars;
-use graph::ipfs_client::IpfsClient;
+use graph::ipfs::{IpfsMetrics, IpfsRpcClient, ServerAddress};
 use graph::log;
+use graph::prelude::alloy::primitives::Address;
 use graph::prelude::*;
-use graph_chain_ethereum::{
-    Chain, DataSource, DataSourceTemplate, Mapping, MappingABI, TemplateSource,
-};
+use graph_chain_ethereum::{Chain, DataSource, DataSourceTemplate, Mapping, TemplateSource};
+use graph_runtime_wasm::host_exports::DataSourceDetails;
 use graph_runtime_wasm::{HostExports, MappingContext};
 use semver::Version;
 use std::env;
 use std::str::FromStr;
-use web3::types::Address;
 
 lazy_static! {
     pub static ref LOGGER: Logger = match env::var_os("GRAPH_LOG") {
@@ -28,8 +28,8 @@ fn mock_host_exports(
     data_source: DataSource,
     store: Arc<impl SubgraphStore>,
     api_version: Version,
-) -> HostExports<Chain> {
-    let templates = vec![data_source::DataSourceTemplate::Onchain(
+) -> HostExports {
+    let templates = [data_source::DataSourceTemplate::Onchain::<Chain>(
         DataSourceTemplate {
             kind: String::from("ethereum/contract"),
             name: String::from("example template"),
@@ -57,13 +57,22 @@ fn mock_host_exports(
 
     let network = data_source.network.clone().unwrap();
     let ens_lookup = store.ens_lookup();
+
+    let ds_details = DataSourceDetails::from_data_source(
+        &graph::data_source::DataSource::Onchain::<Chain>(data_source),
+        Arc::new(templates.iter().map(|t| t.into()).collect()),
+    );
+
+    let client =
+        IpfsRpcClient::new_unchecked(ServerAddress::test_rpc_api(), IpfsMetrics::test(), &LOGGER)
+            .unwrap();
+
     HostExports::new(
         subgraph_id,
-        &data_source::DataSource::Onchain(data_source),
         network,
-        Arc::new(templates),
-        Arc::new(graph_core::LinkResolver::new(
-            vec![IpfsClient::localhost()],
+        ds_details,
+        Arc::new(IpfsResolver::new(
+            Arc::new(client),
             Arc::new(EnvVars::default()),
         )),
         ens_lookup,
@@ -73,7 +82,7 @@ fn mock_host_exports(
 fn mock_abi() -> MappingABI {
     MappingABI {
         name: "mock_abi".to_string(),
-        contract: Contract::load(
+        contract: serde_json::from_str(
             r#"[
             {
                 "inputs": [
@@ -84,8 +93,7 @@ fn mock_abi() -> MappingABI {
                 ],
                 "type": "constructor"
             }
-        ]"#
-            .as_bytes(),
+        ]"#,
         )
         .unwrap(),
     }
@@ -96,7 +104,7 @@ pub fn mock_context(
     data_source: DataSource,
     store: Arc<impl SubgraphStore>,
     api_version: Version,
-) -> MappingContext<Chain> {
+) -> MappingContext {
     MappingContext {
         logger: Logger::root(slog::Discard, o!()),
         block_ptr: BlockPtr {
@@ -111,15 +119,16 @@ pub fn mock_context(
             api_version,
         )),
         state: BlockState::new(
-            futures03::executor::block_on(store.writable(
+            graph::futures03::executor::block_on(store.writable(
                 LOGGER.clone(),
                 deployment.id,
                 Arc::new(Vec::new()),
             ))
             .unwrap(),
             Default::default(),
+            SeqGenerator::new(12),
         ),
-        proof_of_indexing: None,
+        proof_of_indexing: SharedProofOfIndexing::ignored(),
         host_fns: Arc::new(Vec::new()),
         debug_fork: None,
         mapping_logger: Logger::root(slog::Discard, o!()),
diff --git a/runtime/test/src/test.rs b/runtime/test/src/test.rs
index 1a05a8713f7..14af4d0f8e3 100644
--- a/runtime/test/src/test.rs
+++ b/runtime/test/src/test.rs
@@ -1,27 +1,28 @@
+use async_trait::async_trait;
 use graph::blockchain::BlockTime;
 use graph::components::metrics::gas::GasMetrics;
-use graph::data::store::{scalar, Id, IdType};
+use graph::components::store::*;
+use graph::data::store::{Id, IdType, scalar};
 use graph::data::subgraph::*;
 use graph::data::value::Word;
-use graph::prelude::web3::types::U256;
+use graph::futures03::future::BoxFuture;
+use graph::ipfs::test_utils::add_files_to_local_ipfs_node_for_testing;
+use graph::prelude::alloy::primitives::U256;
 use graph::runtime::gas::GasCounter;
 use graph::runtime::{AscIndexId, AscType, HostExportError};
 use graph::runtime::{AscPtr, ToAscObj};
 use graph::schema::{EntityType, InputSchema};
-use graph::{components::store::*, ipfs_client::IpfsClient};
 use graph::{entity, prelude::*};
-use graph_chain_ethereum::{Chain, DataSource};
+use graph_chain_ethereum::DataSource;
 use graph_runtime_wasm::asc_abi::class::{Array, AscBigInt, AscEntity, AscString, Uint8Array};
 use graph_runtime_wasm::{
-    host_exports, ExperimentalFeatures, MappingContext, ValidModule, WasmInstance,
+    ExperimentalFeatures, MappingContext, ValidModule, WasmInstance, host_exports,
 };
-
 use semver::Version;
-use std::borrow::Cow;
 use std::collections::{BTreeMap, HashMap};
 use std::str::FromStr;
-use test_store::{LOGGER, STORE};
-use web3::types::H160;
+use test_store::{LOGGER, STOPWATCH, STORE, SUBGRAPH_STORE};
+use wasmtime::{AsContext, AsContextMut};
 
 use crate::common::{mock_context, mock_data_source};
 
@@ -44,237 +45,312 @@ fn subgraph_id_with_api_version(subgraph_id: &str, api_version: Version) -> Stri
     )
 }
 
-async fn test_valid_module_and_store(
+async fn test_module_and_deployment(
     subgraph_id: &str,
     data_source: DataSource,
     api_version: Version,
-) -> (
-    WasmInstance<Chain>,
-    Arc<impl SubgraphStore>,
-    DeploymentLocator,
-) {
-    test_valid_module_and_store_with_timeout(subgraph_id, data_source, api_version, None).await
+) -> (WasmInstance, DeploymentLocator) {
+    test_module_and_deployment_with_timeout(subgraph_id, data_source, api_version, None).await
 }
 
-async fn test_valid_module_and_store_with_timeout(
-    subgraph_id: &str,
+fn test_module_and_deployment_with_timeout<'a>(
+    subgraph_id: &'a str,
     data_source: DataSource,
     api_version: Version,
     timeout: Option<Duration>,
-) -> (
-    WasmInstance<Chain>,
-    Arc<impl SubgraphStore>,
-    DeploymentLocator,
-) {
-    let logger = Logger::root(slog::Discard, o!());
-    let subgraph_id_with_api_version =
-        subgraph_id_with_api_version(subgraph_id, api_version.clone());
-
-    let store = STORE.clone();
-    let metrics_registry = Arc::new(MetricsRegistry::mock());
-    let deployment_id = DeploymentHash::new(&subgraph_id_with_api_version).unwrap();
-    let deployment = test_store::create_test_subgraph(
-        &deployment_id,
-        "type User @entity {
-            id: ID!,
-            name: String,
-            count: BigInt,
-        }
+) -> BoxFuture<'a, (WasmInstance, DeploymentLocator)> {
+    Box::pin(async move {
+        let logger = Logger::root(slog::Discard, o!());
+        let subgraph_id_with_api_version =
+            subgraph_id_with_api_version(subgraph_id, api_version.clone());
 
-        type Thing @entity {
-            id: ID!,
-            value: String,
-            extra: String
-        }",
-    )
-    .await;
-    let stopwatch_metrics = StopwatchMetrics::new(
-        logger.clone(),
-        deployment_id.clone(),
-        "test",
-        metrics_registry.clone(),
-        "test_shard".to_string(),
-    );
+        let store = STORE.clone();
+        let metrics_registry = Arc::new(MetricsRegistry::mock());
+        let deployment_id = DeploymentHash::new(&subgraph_id_with_api_version).unwrap();
+        let deployment = test_store::create_test_subgraph(
+            &deployment_id,
+            "type User @entity {
+                id: ID!,
+                name: String,
+                count: BigInt,
+            }
 
-    let gas_metrics = GasMetrics::new(deployment_id.clone(), metrics_registry.clone());
+            type Thing @entity {
+                id: ID!,
+                value: String,
+                extra: String
+            }",
+        )
+        .await;
+        let stopwatch = StopwatchMetrics::new(
+            logger.clone(),
+            deployment_id.clone(),
+            "test",
+            metrics_registry.clone(),
+            "test_shard".to_string(),
+        );
 
-    let host_metrics = Arc::new(HostMetrics::new(
-        metrics_registry,
-        deployment_id.as_str(),
-        stopwatch_metrics,
-        gas_metrics,
-    ));
+        let gas_metrics = GasMetrics::new(deployment_id.clone(), metrics_registry.clone());
 
-    let experimental_features = ExperimentalFeatures {
-        allow_non_deterministic_ipfs: true,
-    };
+        let host_metrics = Arc::new(HostMetrics::new(
+            metrics_registry,
+            deployment_id.as_str(),
+            stopwatch.cheap_clone(),
+            gas_metrics,
+        ));
 
-    let module = WasmInstance::from_valid_module_with_ctx(
-        Arc::new(ValidModule::new(&logger, data_source.mapping.runtime.as_ref()).unwrap()),
-        mock_context(
-            deployment.clone(),
-            data_source,
-            store.subgraph_store(),
-            api_version,
-        ),
-        host_metrics,
-        timeout,
-        experimental_features,
-    )
-    .unwrap();
+        let experimental_features = ExperimentalFeatures {
+            allow_non_deterministic_ipfs: true,
+        };
 
-    (module, store.subgraph_store(), deployment)
+        let module = WasmInstance::from_valid_module_with_ctx(
+            Arc::new(
+                ValidModule::new(&logger, data_source.mapping.runtime.as_ref(), timeout).unwrap(),
+            ),
+            mock_context(
+                deployment.clone(),
+                data_source,
+                store.subgraph_store(),
+                api_version,
+            ),
+            host_metrics,
+            experimental_features,
+        )
+        .await
+        .unwrap();
+
+        (module, deployment)
+    })
 }
 
 pub async fn test_module(
     subgraph_id: &str,
     data_source: DataSource,
     api_version: Version,
-) -> WasmInstance<Chain> {
-    test_valid_module_and_store(subgraph_id, data_source, api_version)
+) -> WasmInstance {
+    test_module_and_deployment(subgraph_id, data_source, api_version)
         .await
         .0
 }
 
 // A test module using the latest API version
-pub async fn test_module_latest(subgraph_id: &str, wasm_file: &str) -> WasmInstance<Chain> {
+pub async fn test_module_latest(subgraph_id: &str, wasm_file: &str) -> WasmInstance {
     let version = ENV_VARS.mappings.max_api_version.clone();
     let ds = mock_data_source(
         &wasm_file_path(wasm_file, API_VERSION_0_0_5),
         version.clone(),
     );
-    test_valid_module_and_store(subgraph_id, ds, version)
-        .await
-        .0
+    test_module_and_deployment(subgraph_id, ds, version).await.0
 }
 
+pub trait SyncWasmTy: wasmtime::WasmTy + Sync {}
+impl<T: wasmtime::WasmTy + Sync> SyncWasmTy for T {}
+
+#[async_trait]
 pub trait WasmInstanceExt {
-    fn invoke_export0_void(&self, f: &str) -> Result<(), wasmtime::Trap>;
-    fn invoke_export1_val_void<V: wasmtime::WasmTy>(
-        &self,
-        f: &str,
-        v: V,
-    ) -> Result<(), wasmtime::Trap>;
-    fn invoke_export0<R>(&self, f: &str) -> AscPtr<R>;
-    fn invoke_export1<C, T, R>(&mut self, f: &str, arg: &T) -> AscPtr<R>
+    async fn invoke_export0_void(&mut self, f: &str) -> Result<(), Error>;
+    async fn invoke_export1_val_void<V: SyncWasmTy>(&mut self, f: &str, v: V) -> Result<(), Error>;
+    #[allow(dead_code)]
+    async fn invoke_export0<R>(&mut self, f: &str) -> AscPtr<R>;
+    async fn invoke_export1<C, T, R>(&mut self, f: &str, arg: &T) -> AscPtr<R>
     where
-        C: AscType + AscIndexId,
-        T: ToAscObj<C> + ?Sized;
-    fn invoke_export2<C1, T1, T2, C2, R>(&mut self, f: &str, arg0: &T1, arg1: &T2) -> AscPtr<R>
+        C: AscType + AscIndexId + Send,
+        T: ToAscObj<C> + Sync + ?Sized;
+    async fn invoke_export2<C1, T1, T2, C2, R>(
+        &mut self,
+        f: &str,
+        arg0: &T1,
+        arg1: &T2,
+    ) -> AscPtr<R>
     where
-        C1: AscType + AscIndexId,
-        C2: AscType + AscIndexId,
-        T1: ToAscObj<C1> + ?Sized,
-        T2: ToAscObj<C2> + ?Sized;
-    fn invoke_export2_void<C1, T1, T2, C2>(
+        C1: AscType + AscIndexId + Send,
+        C2: AscType + AscIndexId + Send,
+        T1: ToAscObj<C1> + Sync + ?Sized,
+        T2: ToAscObj<C2> + Sync + ?Sized;
+    async fn invoke_export2_void<C1, T1, T2, C2>(
         &mut self,
         f: &str,
         arg0: &T1,
         arg1: &T2,
-    ) -> Result<(), wasmtime::Trap>
+    ) -> Result<(), Error>
     where
-        C1: AscType + AscIndexId,
-        C2: AscType + AscIndexId,
-        T1: ToAscObj<C1> + ?Sized,
-        T2: ToAscObj<C2> + ?Sized;
-    fn invoke_export0_val<V: wasmtime::WasmTy>(&mut self, func: &str) -> V;
-    fn invoke_export1_val<V: wasmtime::WasmTy, C, T>(&mut self, func: &str, v: &T) -> V
+        C1: AscType + AscIndexId + Send,
+        C2: AscType + AscIndexId + Send,
+        T1: ToAscObj<C1> + Sync + ?Sized,
+        T2: ToAscObj<C2> + Sync + ?Sized;
+    async fn invoke_export0_val<V: SyncWasmTy>(&mut self, func: &str) -> V;
+    async fn invoke_export1_val<V: SyncWasmTy, C, T>(&mut self, func: &str, v: &T) -> V
     where
-        C: AscType + AscIndexId,
-        T: ToAscObj<C> + ?Sized;
-    fn takes_ptr_returns_ptr<C, R>(&self, f: &str, arg: AscPtr<C>) -> AscPtr<R>;
-    fn takes_val_returns_ptr<P>(&mut self, fn_name: &str, val: impl wasmtime::WasmTy) -> AscPtr<P>;
-}
-
-impl WasmInstanceExt for WasmInstance<Chain> {
-    fn invoke_export0_void(&self, f: &str) -> Result<(), wasmtime::Trap> {
-        let func = self.get_func(f).typed().unwrap().clone();
-        func.call(())
+        C: AscType + AscIndexId + Send,
+        T: ToAscObj<C> + Sync + ?Sized;
+    async fn takes_ptr_returns_ptr<C: Send, R>(&mut self, f: &str, arg: AscPtr<C>) -> AscPtr<R>;
+    async fn takes_val_returns_ptr<P>(&mut self, fn_name: &str, val: impl SyncWasmTy) -> AscPtr<P>;
+}
+
+#[async_trait]
+impl WasmInstanceExt for WasmInstance {
+    async fn invoke_export0_void(&mut self, f: &str) -> Result<(), Error> {
+        let func = self
+            .get_func(f)
+            .typed(self.store.as_context())
+            .unwrap()
+            .clone();
+        func.call_async(&mut self.store.as_context_mut(), ())
+            .await
+            .map_err(anyhow::Error::from)
     }
 
-    fn invoke_export0<R>(&self, f: &str) -> AscPtr<R> {
-        let func = self.get_func(f).typed().unwrap().clone();
-        let ptr: u32 = func.call(()).unwrap();
+    async fn invoke_export0<R>(&mut self, f: &str) -> AscPtr<R> {
+        let func = self
+            .get_func(f)
+            .typed(self.store.as_context())
+            .unwrap()
+            .clone();
+        let ptr: u32 = func
+            .call_async(&mut self.store.as_context_mut(), ())
+            .await
+            .unwrap();
         ptr.into()
     }
 
-    fn takes_ptr_returns_ptr<C, R>(&self, f: &str, arg: AscPtr<C>) -> AscPtr<R> {
-        let func = self.get_func(f).typed().unwrap().clone();
-        let ptr: u32 = func.call(arg.wasm_ptr()).unwrap();
+    async fn takes_ptr_returns_ptr<C: Send, R>(&mut self, f: &str, arg: AscPtr<C>) -> AscPtr<R> {
+        let func = self
+            .get_func(f)
+            .typed(self.store.as_context())
+            .unwrap()
+            .clone();
+        let ptr: u32 = func
+            .call_async(&mut self.store.as_context_mut(), arg.wasm_ptr())
+            .await
+            .unwrap();
         ptr.into()
     }
 
-    fn invoke_export1<C, T, R>(&mut self, f: &str, arg: &T) -> AscPtr<R>
+    async fn invoke_export1<C, T, R>(&mut self, f: &str, arg: &T) -> AscPtr<R>
     where
-        C: AscType + AscIndexId,
-        T: ToAscObj<C> + ?Sized,
+        C: AscType + AscIndexId + Send,
+        T: ToAscObj<C> + Sync + ?Sized,
     {
-        let func = self.get_func(f).typed().unwrap().clone();
-        let ptr = self.asc_new(arg).unwrap();
-        let ptr: u32 = func.call(ptr.wasm_ptr()).unwrap();
+        let func = self
+            .get_func(f)
+            .typed(self.store.as_context())
+            .unwrap()
+            .clone();
+        let ptr = self.asc_new(arg).await.unwrap();
+        let ptr: u32 = func
+            .call_async(&mut self.store.as_context_mut(), ptr.wasm_ptr())
+            .await
+            .unwrap();
         ptr.into()
     }
 
-    fn invoke_export1_val_void<V: wasmtime::WasmTy>(
-        &self,
+    async fn invoke_export1_val_void<V: wasmtime::WasmTy + Sync>(
+        &mut self,
         f: &str,
         v: V,
-    ) -> Result<(), wasmtime::Trap> {
-        let func = self.get_func(f).typed().unwrap().clone();
-        func.call(v)?;
+    ) -> Result<(), Error> {
+        let func = self
+            .get_func(f)
+            .typed::<V, ()>(&self.store.as_context())
+            .unwrap()
+            .clone();
+        func.call_async(&mut self.store.as_context_mut(), v).await?;
         Ok(())
     }
 
-    fn invoke_export2<C1, T1, T2, C2, R>(&mut self, f: &str, arg0: &T1, arg1: &T2) -> AscPtr<R>
+    async fn invoke_export2<C1, T1, T2, C2, R>(
+        &mut self,
+        f: &str,
+        arg0: &T1,
+        arg1: &T2,
+    ) -> AscPtr<R>
     where
-        C1: AscType + AscIndexId,
-        C2: AscType + AscIndexId,
-        T1: ToAscObj<C1> + ?Sized,
-        T2: ToAscObj<C2> + ?Sized,
+        C1: AscType + AscIndexId + Send,
+        C2: AscType + AscIndexId + Send,
+        T1: ToAscObj<C1> + Sync + ?Sized,
+        T2: ToAscObj<C2> + Sync + ?Sized,
     {
-        let func = self.get_func(f).typed().unwrap().clone();
-        let arg0 = self.asc_new(arg0).unwrap();
-        let arg1 = self.asc_new(arg1).unwrap();
-        let ptr: u32 = func.call((arg0.wasm_ptr(), arg1.wasm_ptr())).unwrap();
+        let func = self
+            .get_func(f)
+            .typed(self.store.as_context())
+            .unwrap()
+            .clone();
+        let arg0 = self.asc_new(arg0).await.unwrap();
+        let arg1 = self.asc_new(arg1).await.unwrap();
+        let ptr: u32 = func
+            .call_async(
+                &mut self.store.as_context_mut(),
+                (arg0.wasm_ptr(), arg1.wasm_ptr()),
+            )
+            .await
+            .unwrap();
         ptr.into()
     }
 
-    fn invoke_export2_void<C1, T1, T2, C2>(
+    async fn invoke_export2_void<C1, T1, T2, C2>(
         &mut self,
         f: &str,
         arg0: &T1,
         arg1: &T2,
-    ) -> Result<(), wasmtime::Trap>
+    ) -> Result<(), Error>
     where
-        C1: AscType + AscIndexId,
-        C2: AscType + AscIndexId,
-        T1: ToAscObj<C1> + ?Sized,
-        T2: ToAscObj<C2> + ?Sized,
+        C1: AscType + AscIndexId + Send,
+        C2: AscType + AscIndexId + Send,
+        T1: ToAscObj<C1> + Sync + ?Sized,
+        T2: ToAscObj<C2> + Sync + ?Sized,
     {
-        let func = self.get_func(f).typed().unwrap().clone();
-        let arg0 = self.asc_new(arg0).unwrap();
-        let arg1 = self.asc_new(arg1).unwrap();
-        func.call((arg0.wasm_ptr(), arg1.wasm_ptr()))
+        let func = self
+            .get_func(f)
+            .typed(self.store.as_context())
+            .unwrap()
+            .clone();
+        let arg0 = self.asc_new(arg0).await.unwrap();
+        let arg1 = self.asc_new(arg1).await.unwrap();
+        func.call_async(
+            &mut self.store.as_context_mut(),
+            (arg0.wasm_ptr(), arg1.wasm_ptr()),
+        )
+        .await
+        .map_err(anyhow::Error::from)
     }
 
-    fn invoke_export0_val<V: wasmtime::WasmTy>(&mut self, func: &str) -> V {
-        let func = self.get_func(func).typed().unwrap().clone();
-        func.call(()).unwrap()
+    async fn invoke_export0_val<V: wasmtime::WasmTy + Sync>(&mut self, func: &str) -> V {
+        let func = self
+            .get_func(func)
+            .typed(self.store.as_context())
+            .unwrap()
+            .clone();
+        func.call_async(&mut self.store.as_context_mut(), ())
+            .await
+            .unwrap()
     }
 
-    fn invoke_export1_val<V: wasmtime::WasmTy, C, T>(&mut self, func: &str, v: &T) -> V
+    async fn invoke_export1_val<V: SyncWasmTy, C, T>(&mut self, func: &str, v: &T) -> V
     where
-        C: AscType + AscIndexId,
-        T: ToAscObj<C> + ?Sized,
+        C: AscType + AscIndexId + Send,
+        T: ToAscObj<C> + Sync + ?Sized,
     {
-        let func = self.get_func(func).typed().unwrap().clone();
-        let ptr = self.asc_new(v).unwrap();
-        func.call(ptr.wasm_ptr()).unwrap()
+        let func = self
+            .get_func(func)
+            .typed(self.store.as_context())
+            .unwrap()
+            .clone();
+        let ptr = self.asc_new(v).await.unwrap();
+        func.call_async(&mut self.store.as_context_mut(), ptr.wasm_ptr())
+            .await
+            .unwrap()
     }
 
-    fn takes_val_returns_ptr<P>(&mut self, fn_name: &str, val: impl wasmtime::WasmTy) -> AscPtr<P> {
-        let func = self.get_func(fn_name).typed().unwrap().clone();
-        let ptr: u32 = func.call(val).unwrap();
+    async fn takes_val_returns_ptr<P>(&mut self, fn_name: &str, val: impl SyncWasmTy) -> AscPtr<P> {
+        let func = self
+            .get_func(fn_name)
+            .typed(self.store.as_context())
+            .unwrap()
+            .clone();
+        let ptr: u32 = func
+            .call_async(&mut self.store.as_context_mut(), val)
+            .await
+            .unwrap();
         ptr.into()
     }
 }
@@ -292,22 +368,28 @@ async fn test_json_conversions(api_version: Version, gas_used: u64) {
 
     // test u64 conversion
     let number = 9223372036850770800;
-    let converted: i64 = module.invoke_export1_val("testToU64", &number.to_string());
+    let converted: i64 = module
+        .invoke_export1_val("testToU64", &number.to_string())
+        .await;
     assert_eq!(number, u64::from_le_bytes(converted.to_le_bytes()));
 
     // test i64 conversion
     let number = -9223372036850770800;
-    let converted: i64 = module.invoke_export1_val("testToI64", &number.to_string());
+    let converted: i64 = module
+        .invoke_export1_val("testToI64", &number.to_string())
+        .await;
     assert_eq!(number, converted);
 
     // test f64 conversion
     let number = -9223372036850770.92345034;
-    let converted: f64 = module.invoke_export1_val("testToF64", &number.to_string());
+    let converted: f64 = module
+        .invoke_export1_val("testToF64", &number.to_string())
+        .await;
     assert_eq!(number, converted);
 
     // test BigInt conversion
     let number = "-922337203685077092345034";
-    let big_int_obj: AscPtr<AscBigInt> = module.invoke_export1("testToBigInt", number);
+    let big_int_obj: AscPtr<AscBigInt> = module.invoke_export1("testToBigInt", number).await;
     let bytes: Vec<u8> = module.asc_get(big_int_obj).unwrap();
 
     assert_eq!(
@@ -318,14 +400,14 @@ async fn test_json_conversions(api_version: Version, gas_used: u64) {
     assert_eq!(module.gas_used(), gas_used);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn json_conversions_v0_0_4() {
     test_json_conversions(API_VERSION_0_0_4, 52976429).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn json_conversions_v0_0_5() {
-    test_json_conversions(API_VERSION_0_0_5, 2289897).await;
+    test_json_conversions(API_VERSION_0_0_5, 2214813).await;
 }
 
 async fn test_json_parsing(api_version: Version, gas_used: u64) {
@@ -342,7 +424,7 @@ async fn test_json_parsing(api_version: Version, gas_used: u64) {
     // Parse valid JSON and get it back
     let s = "\"foo\""; // Valid because there are quotes around `foo`
     let bytes: &[u8] = s.as_ref();
-    let return_value: AscPtr<AscString> = module.invoke_export1("handleJsonError", bytes);
+    let return_value: AscPtr<AscString> = module.invoke_export1("handleJsonError", bytes).await;
 
     let output: String = module.asc_get(return_value).unwrap();
     assert_eq!(output, "OK: foo, ERROR: false");
@@ -351,101 +433,86 @@ async fn test_json_parsing(api_version: Version, gas_used: u64) {
     // Parse invalid JSON and handle the error gracefully
     let s = "foo"; // Invalid because there are no quotes around `foo`
     let bytes: &[u8] = s.as_ref();
-    let return_value: AscPtr<AscString> = module.invoke_export1("handleJsonError", bytes);
+    let return_value: AscPtr<AscString> = module.invoke_export1("handleJsonError", bytes).await;
     let output: String = module.asc_get(return_value).unwrap();
     assert_eq!(output, "ERROR: true");
 
     // Parse JSON that's too long and handle the error gracefully
     let s = format!("\"f{}\"", "o".repeat(10_000_000));
     let bytes: &[u8] = s.as_ref();
-    let return_value: AscPtr<AscString> = module.invoke_export1("handleJsonError", bytes);
+    let return_value: AscPtr<AscString> = module.invoke_export1("handleJsonError", bytes).await;
 
     let output: String = module.asc_get(return_value).unwrap();
     assert_eq!(output, "ERROR: true");
 }
 
-#[tokio::test]
+#[graph::test]
 async fn json_parsing_v0_0_4() {
     test_json_parsing(API_VERSION_0_0_4, 4373087).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn json_parsing_v0_0_5() {
     test_json_parsing(API_VERSION_0_0_5, 5153540).await;
 }
 
 async fn test_ipfs_cat(api_version: Version) {
-    // Ipfs host functions use `block_on` which must be called from a sync context,
-    // so we replicate what we do `spawn_module`.
-    let runtime = tokio::runtime::Handle::current();
-    std::thread::spawn(move || {
-        let _runtime_guard = runtime.enter();
-
-        let ipfs = IpfsClient::localhost();
-        let hash = graph::block_on(ipfs.add("42".into())).unwrap().hash;
-
-        let mut module = graph::block_on(test_module(
-            "ipfsCat",
-            mock_data_source(
-                &wasm_file_path("ipfs_cat.wasm", api_version.clone()),
-                api_version.clone(),
-            ),
-            api_version,
-        ));
-        let converted: AscPtr<AscString> = module.invoke_export1("ipfsCatString", &hash);
-        let data: String = module.asc_get(converted).unwrap();
-        assert_eq!(data, "42");
-    })
-    .join()
-    .unwrap();
+    let fut = add_files_to_local_ipfs_node_for_testing(["42".as_bytes().to_vec()]);
+    let hash = fut.await.unwrap()[0].hash.to_owned();
+
+    let mut module = test_module(
+        "ipfsCat",
+        mock_data_source(
+            &wasm_file_path("ipfs_cat.wasm", api_version.clone()),
+            api_version.clone(),
+        ),
+        api_version,
+    )
+    .await;
+    let converted: AscPtr<AscString> = module.invoke_export1("ipfsCatString", &hash).await;
+    let data: String = module.asc_get(converted).unwrap();
+    assert_eq!(data, "42");
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[graph::test]
 async fn ipfs_cat_v0_0_4() {
     test_ipfs_cat(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[graph::test]
 async fn ipfs_cat_v0_0_5() {
     test_ipfs_cat(API_VERSION_0_0_5).await;
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[graph::test]
 async fn test_ipfs_block() {
-    // Ipfs host functions use `block_on` which must be called from a sync context,
-    // so we replicate what we do `spawn_module`.
-    let runtime = tokio::runtime::Handle::current();
-    std::thread::spawn(move || {
-        let _runtime_guard = runtime.enter();
-
-        let ipfs = IpfsClient::localhost();
-        let hash = graph::block_on(ipfs.add("42".into())).unwrap().hash;
-        let mut module = graph::block_on(test_module(
-            "ipfsBlock",
-            mock_data_source(
-                &wasm_file_path("ipfs_block.wasm", API_VERSION_0_0_5),
-                API_VERSION_0_0_5,
-            ),
+    let fut = add_files_to_local_ipfs_node_for_testing(["42".as_bytes().to_vec()]);
+    let hash = fut.await.unwrap()[0].hash.to_owned();
+
+    let mut module = test_module(
+        "ipfsBlock",
+        mock_data_source(
+            &wasm_file_path("ipfs_block.wasm", API_VERSION_0_0_5),
             API_VERSION_0_0_5,
-        ));
-        let converted: AscPtr<AscString> = module.invoke_export1("ipfsBlockHex", &hash);
-        let data: String = module.asc_get(converted).unwrap();
-        assert_eq!(data, "0x0a080802120234321802");
-    })
-    .join()
-    .unwrap();
+        ),
+        API_VERSION_0_0_5,
+    )
+    .await;
+    let converted: AscPtr<AscString> = module.invoke_export1("ipfsBlockHex", &hash).await;
+    let data: String = module.asc_get(converted).unwrap();
+    assert_eq!(data, "0x0a080802120234321802");
 }
 
 // The user_data value we use with calls to ipfs_map
 const USER_DATA: &str = "user_data";
 
-fn make_thing(id: &str, value: &str) -> (String, EntityModification) {
+fn make_thing(id: &str, value: &str, vid: i64) -> (String, EntityModification) {
     const DOCUMENT: &str = " type Thing @entity { id: String!, value: String!, extra: String }";
     lazy_static! {
         static ref SCHEMA: InputSchema = InputSchema::raw(DOCUMENT, "doesntmatter");
         static ref THING_TYPE: EntityType = SCHEMA.entity_type("Thing").unwrap();
     }
-    let data = entity! { SCHEMA => id: id, value: value, extra: USER_DATA };
+    let data = entity! { SCHEMA => id: id, value: value, extra: USER_DATA, vid: vid };
     let key = THING_TYPE.parse_key(id).unwrap();
     (
         format!("{{ \"id\": \"{}\", \"value\": \"{}\"}}", id, value),
@@ -456,63 +523,62 @@ fn make_thing(id: &str, value: &str) -> (String, EntityModification) {
 const BAD_IPFS_HASH: &str = "bad-ipfs-hash";
 
 async fn run_ipfs_map(
-    ipfs: IpfsClient,
     subgraph_id: &'static str,
     json_string: String,
     api_version: Version,
-) -> Result<Vec<EntityModification>, anyhow::Error> {
+) -> Result<Vec<EntityModification>, Error> {
     let hash = if json_string == BAD_IPFS_HASH {
         "Qm".to_string()
     } else {
-        ipfs.add(json_string.into()).await.unwrap().hash
+        add_files_to_local_ipfs_node_for_testing([json_string.as_bytes().to_vec()]).await?[0]
+            .hash
+            .to_owned()
     };
 
-    // Ipfs host functions use `block_on` which must be called from a sync context,
-    // so we replicate what we do `spawn_module`.
-    let runtime = tokio::runtime::Handle::current();
-    std::thread::spawn(move || {
-        let _runtime_guard = runtime.enter();
+    let mut instance = test_module(
+        subgraph_id,
+        mock_data_source(
+            &wasm_file_path("ipfs_map.wasm", api_version.clone()),
+            api_version.clone(),
+        ),
+        api_version,
+    )
+    .await;
 
-        let (mut module, _, _) = graph::block_on(test_valid_module_and_store(
-            subgraph_id,
-            mock_data_source(
-                &wasm_file_path("ipfs_map.wasm", api_version.clone()),
-                api_version.clone(),
-            ),
-            api_version,
-        ));
+    let value = instance.asc_new(&hash).await.unwrap();
+    let user_data = instance.asc_new(USER_DATA).await.unwrap();
 
-        let value = module.asc_new(&hash).unwrap();
-        let user_data = module.asc_new(USER_DATA).unwrap();
-
-        // Invoke the callback
-        let func = module.get_func("ipfsMap").typed().unwrap().clone();
-        func.call((value.wasm_ptr(), user_data.wasm_ptr()))?;
-        let mut mods = module
-            .take_ctx()
-            .ctx
-            .state
-            .entity_cache
-            .as_modifications(0)?
-            .modifications;
-
-        // Bring the modifications into a predictable order (by entity_id)
-        mods.sort_by(|a, b| a.key().entity_id.partial_cmp(&b.key().entity_id).unwrap());
-        Ok(mods)
-    })
-    .join()
-    .unwrap()
+    // Invoke the callback
+    let func = instance
+        .get_func("ipfsMap")
+        .typed::<(u32, u32), ()>(&instance.store.as_context())
+        .unwrap()
+        .clone();
+    func.call_async(
+        &mut instance.store.as_context_mut(),
+        (value.wasm_ptr(), user_data.wasm_ptr()),
+    )
+    .await?;
+    let mut mods = instance
+        .take_ctx()
+        .take_state()
+        .entity_cache
+        .as_modifications(0, &STOPWATCH)
+        .await?
+        .modifications;
+
+    // Bring the modifications into a predictable order (by entity_id)
+    mods.sort_by(|a, b| a.key().entity_id.partial_cmp(&b.key().entity_id).unwrap());
+    Ok(mods)
 }
 
 async fn test_ipfs_map(api_version: Version, json_error_msg: &str) {
-    let ipfs = IpfsClient::localhost();
     let subgraph_id = "ipfsMap";
 
     // Try it with two valid objects
-    let (str1, thing1) = make_thing("one", "eins");
-    let (str2, thing2) = make_thing("two", "zwei");
+    let (str1, thing1) = make_thing("one", "eins", 100);
+    let (str2, thing2) = make_thing("two", "zwei", 100);
     let ops = run_ipfs_map(
-        ipfs.clone(),
         subgraph_id,
         format!("{}\n{}", str1, str2),
         api_version.clone(),
@@ -524,14 +590,9 @@ async fn test_ipfs_map(api_version: Version, json_error_msg: &str) {
 
     // Valid JSON, but not what the callback expected; it will
     // fail on an assertion
-    let err = run_ipfs_map(
-        ipfs.clone(),
-        subgraph_id,
-        format!("{}\n[1,2]", str1),
-        api_version.clone(),
-    )
-    .await
-    .unwrap_err();
+    let err = run_ipfs_map(subgraph_id, format!("{}\n[1,2]", str1), api_version.clone())
+        .await
+        .unwrap_err();
     assert!(
         format!("{:#}", err).contains("JSON value is not an object."),
         "{:#}",
@@ -539,33 +600,21 @@ async fn test_ipfs_map(api_version: Version, json_error_msg: &str) {
     );
 
     // Malformed JSON
-    let errmsg = run_ipfs_map(
-        ipfs.clone(),
-        subgraph_id,
-        format!("{}\n[", str1),
-        api_version.clone(),
-    )
-    .await
-    .unwrap_err()
-    .to_string();
-    assert!(errmsg.contains("EOF while parsing a list"));
+    let err = run_ipfs_map(subgraph_id, format!("{}\n[", str1), api_version.clone())
+        .await
+        .unwrap_err();
+    assert!(format!("{err:?}").contains("EOF while parsing a list"));
 
     // Empty input
-    let ops = run_ipfs_map(
-        ipfs.clone(),
-        subgraph_id,
-        "".to_string(),
-        api_version.clone(),
-    )
-    .await
-    .expect("call failed for emoty string");
+    let ops = run_ipfs_map(subgraph_id, "".to_string(), api_version.clone())
+        .await
+        .expect("call failed for emoty string");
     assert_eq!(0, ops.len());
 
     // Missing entry in the JSON object
     let errmsg = format!(
         "{:#}",
         run_ipfs_map(
-            ipfs.clone(),
             subgraph_id,
             "{\"value\": \"drei\"}".to_string(),
             api_version.clone(),
@@ -576,59 +625,46 @@ async fn test_ipfs_map(api_version: Version, json_error_msg: &str) {
     assert!(errmsg.contains(json_error_msg));
 
     // Bad IPFS hash.
-    let errmsg = run_ipfs_map(
-        ipfs.clone(),
-        subgraph_id,
-        BAD_IPFS_HASH.to_string(),
-        api_version.clone(),
-    )
-    .await
-    .unwrap_err()
-    .to_string();
-    assert!(errmsg.contains("500 Internal Server Error"));
+    let err = run_ipfs_map(subgraph_id, BAD_IPFS_HASH.to_string(), api_version.clone())
+        .await
+        .unwrap_err();
+    assert!(format!("{err:?}").contains("invalid CID"));
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[graph::test]
 async fn ipfs_map_v0_0_4() {
     test_ipfs_map(API_VERSION_0_0_4, "JSON value is not a string.").await;
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[graph::test]
 async fn ipfs_map_v0_0_5() {
     test_ipfs_map(API_VERSION_0_0_5, "'id' should not be null").await;
 }
 
 async fn test_ipfs_fail(api_version: Version) {
-    let runtime = tokio::runtime::Handle::current();
-
-    // Ipfs host functions use `block_on` which must be called from a sync context,
-    // so we replicate what we do `spawn_module`.
-    std::thread::spawn(move || {
-        let _runtime_guard = runtime.enter();
-
-        let mut module = graph::block_on(test_module(
-            "ipfsFail",
-            mock_data_source(
-                &wasm_file_path("ipfs_cat.wasm", api_version.clone()),
-                api_version.clone(),
-            ),
-            api_version,
-        ));
+    let mut module = test_module(
+        "ipfsFail",
+        mock_data_source(
+            &wasm_file_path("ipfs_cat.wasm", api_version.clone()),
+            api_version.clone(),
+        ),
+        api_version,
+    )
+    .await;
 
-        assert!(module
-            .invoke_export1::<_, _, AscString>("ipfsCat", "invalid hash")
-            .is_null());
-    })
-    .join()
-    .unwrap();
+    // ipfs_cat failures are surfaced as null pointers. See PR #749
+    let ptr = module
+        .invoke_export1::<_, _, AscString>("ipfsCat", "invalid hash")
+        .await;
+    assert!(ptr.is_null());
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[graph::test]
 async fn ipfs_fail_v0_0_4() {
     test_ipfs_fail(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[graph::test]
 async fn ipfs_fail_v0_0_5() {
     test_ipfs_fail(API_VERSION_0_0_5).await;
 }
@@ -645,7 +681,7 @@ async fn test_crypto_keccak256(api_version: Version) {
     .await;
     let input: &[u8] = "eth".as_ref();
 
-    let hash: AscPtr<Uint8Array> = module.invoke_export1("hash", input);
+    let hash: AscPtr<Uint8Array> = module.invoke_export1("hash", input).await;
     let hash: Vec<u8> = module.asc_get(hash).unwrap();
     assert_eq!(
         hex::encode(hash),
@@ -653,18 +689,18 @@ async fn test_crypto_keccak256(api_version: Version) {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn crypto_keccak256_v0_0_4() {
     test_crypto_keccak256(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn crypto_keccak256_v0_0_5() {
     test_crypto_keccak256(API_VERSION_0_0_5).await;
 }
 
 async fn test_big_int_to_hex(api_version: Version, gas_used: u64) {
-    let mut module = test_module(
+    let mut instance = test_module(
         "BigIntToHex",
         mock_data_source(
             &wasm_file_path("big_int_to_hex.wasm", api_version.clone()),
@@ -675,32 +711,33 @@ async fn test_big_int_to_hex(api_version: Version, gas_used: u64) {
     .await;
 
     // Convert zero to hex
-    let zero = BigInt::from_unsigned_u256(&U256::zero());
-    let zero_hex_ptr: AscPtr<AscString> = module.invoke_export1("big_int_to_hex", &zero);
-    let zero_hex_str: String = module.asc_get(zero_hex_ptr).unwrap();
+    let zero = BigInt::from_unsigned_u256(&U256::ZERO);
+    let zero_hex_ptr: AscPtr<AscString> = instance.invoke_export1("big_int_to_hex", &zero).await;
+    let zero_hex_str: String = instance.asc_get(zero_hex_ptr).unwrap();
     assert_eq!(zero_hex_str, "0x0");
 
     // Convert 1 to hex
-    let one = BigInt::from_unsigned_u256(&U256::one());
-    let one_hex_ptr: AscPtr<AscString> = module.invoke_export1("big_int_to_hex", &one);
-    let one_hex_str: String = module.asc_get(one_hex_ptr).unwrap();
+    let one = BigInt::from_unsigned_u256(&U256::ONE);
+    let one_hex_ptr: AscPtr<AscString> = instance.invoke_export1("big_int_to_hex", &one).await;
+    let one_hex_str: String = instance.asc_get(one_hex_ptr).unwrap();
     assert_eq!(one_hex_str, "0x1");
 
     // Convert U256::max_value() to hex
-    let u256_max = BigInt::from_unsigned_u256(&U256::max_value());
-    let u256_max_hex_ptr: AscPtr<AscString> = module.invoke_export1("big_int_to_hex", &u256_max);
-    let u256_max_hex_str: String = module.asc_get(u256_max_hex_ptr).unwrap();
+    let u256_max = BigInt::from_unsigned_u256(&U256::MAX);
+    let u256_max_hex_ptr: AscPtr<AscString> =
+        instance.invoke_export1("big_int_to_hex", &u256_max).await;
+    let u256_max_hex_str: String = instance.asc_get(u256_max_hex_ptr).unwrap();
     assert_eq!(
         u256_max_hex_str,
         "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
     );
 
-    assert_eq!(module.gas_used(), gas_used);
+    assert_eq!(instance.gas_used(), gas_used);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn test_big_int_size_limit() {
-    let module = test_module(
+    let mut module = test_module(
         "BigIntSizeLimit",
         mock_data_source(
             &wasm_file_path("big_int_size_limit.wasm", API_VERSION_0_0_5),
@@ -713,24 +750,29 @@ async fn test_big_int_size_limit() {
     let len = BigInt::MAX_BITS / 8;
     module
         .invoke_export1_val_void("bigIntWithLength", len)
+        .await
         .unwrap();
 
     let len = BigInt::MAX_BITS / 8 + 1;
-    assert!(module
+    let err = module
         .invoke_export1_val_void("bigIntWithLength", len)
-        .unwrap_err()
-        .to_string()
-        .contains("BigInt is too big, total bits 435416 (max 435412)"));
+        .await
+        .unwrap_err();
+    assert!(
+        format!("{err:?}").contains("BigInt is too big, total bits 435416 (max 435412)"),
+        "{}",
+        err
+    );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn big_int_to_hex_v0_0_4() {
     test_big_int_to_hex(API_VERSION_0_0_4, 53113760).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn big_int_to_hex_v0_0_5() {
-    test_big_int_to_hex(API_VERSION_0_0_5, 2858580).await;
+    test_big_int_to_hex(API_VERSION_0_0_5, 2565990).await;
 }
 
 async fn test_big_int_arithmetic(api_version: Version, gas_used: u64) {
@@ -747,60 +789,60 @@ async fn test_big_int_arithmetic(api_version: Version, gas_used: u64) {
     // 0 + 1 = 1
     let zero = BigInt::from(0);
     let one = BigInt::from(1);
-    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("plus", &zero, &one);
+    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("plus", &zero, &one).await;
     let result: BigInt = module.asc_get(result_ptr).unwrap();
     assert_eq!(result, BigInt::from(1));
 
     // 127 + 1 = 128
     let zero = BigInt::from(127);
     let one = BigInt::from(1);
-    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("plus", &zero, &one);
+    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("plus", &zero, &one).await;
     let result: BigInt = module.asc_get(result_ptr).unwrap();
     assert_eq!(result, BigInt::from(128));
 
     // 5 - 10 = -5
     let five = BigInt::from(5);
     let ten = BigInt::from(10);
-    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("minus", &five, &ten);
+    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("minus", &five, &ten).await;
     let result: BigInt = module.asc_get(result_ptr).unwrap();
     assert_eq!(result, BigInt::from(-5));
 
     // -20 * 5 = -100
     let minus_twenty = BigInt::from(-20);
     let five = BigInt::from(5);
-    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("times", &minus_twenty, &five);
+    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("times", &minus_twenty, &five).await;
     let result: BigInt = module.asc_get(result_ptr).unwrap();
     assert_eq!(result, BigInt::from(-100));
 
     // 5 / 2 = 2
     let five = BigInt::from(5);
     let two = BigInt::from(2);
-    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("dividedBy", &five, &two);
+    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("dividedBy", &five, &two).await;
     let result: BigInt = module.asc_get(result_ptr).unwrap();
     assert_eq!(result, BigInt::from(2));
 
     // 5 % 2 = 1
     let five = BigInt::from(5);
     let two = BigInt::from(2);
-    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("mod", &five, &two);
+    let result_ptr: AscPtr<AscBigInt> = module.invoke_export2("mod", &five, &two).await;
     let result: BigInt = module.asc_get(result_ptr).unwrap();
     assert_eq!(result, BigInt::from(1));
 
     assert_eq!(module.gas_used(), gas_used);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn big_int_arithmetic_v0_0_4() {
     test_big_int_arithmetic(API_VERSION_0_0_4, 54962411).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn big_int_arithmetic_v0_0_5() {
-    test_big_int_arithmetic(API_VERSION_0_0_5, 7318364).await;
+    test_big_int_arithmetic(API_VERSION_0_0_5, 5256825).await;
 }
 
 async fn test_abort(api_version: Version, error_msg: &str) {
-    let module = test_module(
+    let mut instance = test_module(
         "abort",
         mock_data_source(
             &wasm_file_path("abort.wasm", api_version.clone()),
@@ -809,11 +851,17 @@ async fn test_abort(api_version: Version, error_msg: &str) {
         api_version,
     )
     .await;
-    let res: Result<(), _> = module.get_func("abort").typed().unwrap().call(());
-    assert!(res.unwrap_err().to_string().contains(error_msg));
+    let res: Result<(), _> = instance
+        .get_func("abort")
+        .typed(instance.store.as_context())
+        .unwrap()
+        .call_async(&mut instance.store.as_context_mut(), ())
+        .await;
+    let err = res.unwrap_err();
+    assert!(format!("{err:?}").contains(error_msg));
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abort_v0_0_4() {
     test_abort(
         API_VERSION_0_0_4,
@@ -822,7 +870,7 @@ async fn abort_v0_0_4() {
     .await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abort_v0_0_5() {
     test_abort(
         API_VERSION_0_0_5,
@@ -843,19 +891,21 @@ async fn test_bytes_to_base58(api_version: Version, gas_used: u64) {
     .await;
     let bytes = hex::decode("12207D5A99F603F231D53A4F39D1521F98D2E8BB279CF29BEBFD0687DC98458E7F89")
         .unwrap();
-    let result_ptr: AscPtr<AscString> = module.invoke_export1("bytes_to_base58", bytes.as_slice());
+    let result_ptr: AscPtr<AscString> = module
+        .invoke_export1("bytes_to_base58", bytes.as_slice())
+        .await;
     let base58: String = module.asc_get(result_ptr).unwrap();
 
     assert_eq!(base58, "QmWmyoMoctfbAaiEs2G46gpeUmhqFRDW6KWo64y5r581Vz");
     assert_eq!(module.gas_used(), gas_used);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn bytes_to_base58_v0_0_4() {
     test_bytes_to_base58(API_VERSION_0_0_4, 52301689).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn bytes_to_base58_v0_0_5() {
     test_bytes_to_base58(API_VERSION_0_0_5, 1310019).await;
 }
@@ -880,7 +930,7 @@ async fn test_data_source_create(api_version: Version, gas_used: u64) {
     let params = vec![String::from("0xc000000000000000000000000000000000000000")];
     match run_data_source_create(template.clone(), params.clone(), api_version, gas_used).await {
         Ok(_) => panic!("expected an error because the template does not exist"),
-        Err(e) => assert!(e.to_string().contains(
+        Err(e) => assert!(format!("{e:?}").contains(
             "Failed to create data source from name `nonexistent template`: \
              No template with this name in parent data source `example data source`. \
              Available names: example template."
@@ -893,8 +943,8 @@ async fn run_data_source_create(
     params: Vec<String>,
     api_version: Version,
     gas_used: u64,
-) -> Result<Vec<DataSourceTemplateInfo<Chain>>, wasmtime::Trap> {
-    let mut module = test_module(
+) -> Result<Vec<InstanceDSTemplateInfo>, Error> {
+    let mut instance = test_module(
         "DataSourceCreate",
         mock_data_source(
             &wasm_file_path("data_source_create.wasm", api_version.clone()),
@@ -904,23 +954,29 @@ async fn run_data_source_create(
     )
     .await;
 
-    module.instance_ctx_mut().ctx.state.enter_handler();
-    module.invoke_export2_void("dataSourceCreate", &name, &params)?;
-    module.instance_ctx_mut().ctx.state.exit_handler();
+    instance.store.data_mut().ctx.state.enter_handler();
+    instance
+        .invoke_export2_void("dataSourceCreate", &name, &params)
+        .await?;
+    instance.store.data_mut().ctx.state.exit_handler();
 
-    assert_eq!(module.gas_used(), gas_used);
+    assert_eq!(instance.gas_used(), gas_used);
 
-    Ok(module.take_ctx().ctx.state.drain_created_data_sources())
+    Ok(instance
+        .store
+        .into_data()
+        .take_state()
+        .drain_created_data_sources())
 }
 
-#[tokio::test]
+#[graph::test]
 async fn data_source_create_v0_0_4() {
     test_data_source_create(API_VERSION_0_0_4, 152102833).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn data_source_create_v0_0_5() {
-    test_data_source_create(API_VERSION_0_0_5, 101450079).await;
+    test_data_source_create(API_VERSION_0_0_5, 101425051).await;
 }
 
 async fn test_ens_name_by_hash(api_version: Version) {
@@ -936,28 +992,32 @@ async fn test_ens_name_by_hash(api_version: Version) {
 
     let hash = "0x7f0c1b04d1a4926f9c635a030eeb611d4c26e5e73291b32a1c7a4ac56935b5b3";
     let name = "dealdrafts";
-    test_store::insert_ens_name(hash, name);
-    let converted: AscPtr<AscString> = module.invoke_export1("nameByHash", hash);
+    test_store::insert_ens_name(hash, name).await;
+    let converted: AscPtr<AscString> = module.invoke_export1("nameByHash", hash).await;
     let data: String = module.asc_get(converted).unwrap();
     assert_eq!(data, name);
 
-    assert!(module
-        .invoke_export1::<_, _, AscString>("nameByHash", "impossible keccak hash")
-        .is_null());
+    assert!(
+        module
+            .invoke_export1::<_, _, AscString>("nameByHash", "impossible keccak hash")
+            .await
+            .is_null()
+    );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn ens_name_by_hash_v0_0_4() {
     test_ens_name_by_hash(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn ens_name_by_hash_v0_0_5() {
     test_ens_name_by_hash(API_VERSION_0_0_5).await;
 }
 
 async fn test_entity_store(api_version: Version) {
-    let (mut module, store, deployment) = test_valid_module_and_store(
+    let store = SUBGRAPH_STORE.clone();
+    let (mut instance, deployment) = test_module_and_deployment(
         "entityStore",
         mock_data_source(
             &wasm_file_path("store.wasm", api_version.clone()),
@@ -967,10 +1027,10 @@ async fn test_entity_store(api_version: Version) {
     )
     .await;
 
-    let schema = store.input_schema(&deployment.hash).unwrap();
+    let schema = store.input_schema(&deployment.hash).await.unwrap();
 
-    let alex = entity! { schema => id: "alex", name: "Alex" };
-    let steve = entity! { schema => id: "steve", name: "Steve" };
+    let alex = entity! { schema => id: "alex", name: "Alex", vid: 0i64 };
+    let steve = entity! { schema => id: "steve", name: "Steve", vid: 1i64 };
     let user_type = schema.entity_type("User").unwrap();
     test_store::insert_entities(
         &deployment,
@@ -979,8 +1039,8 @@ async fn test_entity_store(api_version: Version) {
     .await
     .unwrap();
 
-    let get_user = move |module: &mut WasmInstance<Chain>, id: &str| -> Option<Entity> {
-        let entity_ptr: AscPtr<AscEntity> = module.invoke_export1("getUser", id);
+    let get_user = async move |module: &mut WasmInstance, id: &str| -> Option<Entity> {
+        let entity_ptr: AscPtr<AscEntity> = module.invoke_export1("getUser", id).await;
         if entity_ptr.is_null() {
             None
         } else {
@@ -996,52 +1056,58 @@ async fn test_entity_store(api_version: Version) {
         }
     };
 
-    let load_and_set_user_name = |module: &mut WasmInstance<Chain>, id: &str, name: &str| {
+    let load_and_set_user_name = async |module: &mut WasmInstance, id: &str, name: &str| {
         module
             .invoke_export2_void("loadAndSetUserName", id, name)
+            .await
             .unwrap();
     };
 
     // store.get of a nonexistent user
-    assert_eq!(None, get_user(&mut module, "herobrine"));
+    assert_eq!(None, get_user(&mut instance, "herobrine").await);
     // store.get of an existing user
-    let steve = get_user(&mut module, "steve").unwrap();
+    let steve = get_user(&mut instance, "steve").await.unwrap();
     assert_eq!(Some(&Value::from("Steve")), steve.get("name"));
 
     // Load, set, save cycle for an existing entity
-    load_and_set_user_name(&mut module, "steve", "Steve-O");
+    load_and_set_user_name(&mut instance, "steve", "Steve-O").await;
 
     // We need to empty the cache for the next test
     let writable = store
         .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
         .await
         .unwrap();
+    let ctx = instance.store.data_mut();
     let cache = std::mem::replace(
-        &mut module.instance_ctx_mut().ctx.state.entity_cache,
-        EntityCache::new(Arc::new(writable.clone())),
+        &mut ctx.ctx.state.entity_cache,
+        EntityCache::new(Arc::new(writable.clone()), SeqGenerator::new(12)),
     );
-    let mut mods = cache.as_modifications(0).unwrap().modifications;
+    let mut mods = cache
+        .as_modifications(0, &STOPWATCH)
+        .await
+        .unwrap()
+        .modifications;
     assert_eq!(1, mods.len());
     match mods.pop().unwrap() {
         EntityModification::Overwrite { data, .. } => {
             assert_eq!(Some(&Value::from("steve")), data.get("id"));
             assert_eq!(Some(&Value::from("Steve-O")), data.get("name"));
         }
-        _ => assert!(false, "expected Overwrite modification"),
+        _ => panic!("expected Overwrite modification"),
     }
 
     // Load, set, save cycle for a new entity with fulltext API
-    load_and_set_user_name(&mut module, "herobrine", "Brine-O");
+    load_and_set_user_name(&mut instance, "herobrine", "Brine-O").await;
     let mut fulltext_entities = BTreeMap::new();
     let mut fulltext_fields = BTreeMap::new();
     fulltext_fields.insert("name".to_string(), vec!["search".to_string()]);
     fulltext_entities.insert("User".to_string(), fulltext_fields);
-    let mut mods = module
+    let mut mods = instance
         .take_ctx()
-        .ctx
-        .state
+        .take_state()
         .entity_cache
-        .as_modifications(0)
+        .as_modifications(0, &STOPWATCH)
+        .await
         .unwrap()
         .modifications;
     assert_eq!(1, mods.len());
@@ -1050,16 +1116,16 @@ async fn test_entity_store(api_version: Version) {
             assert_eq!(Some(&Value::from("herobrine")), data.get("id"));
             assert_eq!(Some(&Value::from("Brine-O")), data.get("name"));
         }
-        _ => assert!(false, "expected Insert modification"),
+        _ => panic!("expected Insert modification"),
     };
 }
 
-#[tokio::test]
+#[graph::test]
 async fn entity_store_v0_0_4() {
     test_entity_store(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn entity_store_v0_0_5() {
     test_entity_store(API_VERSION_0_0_5).await;
 }
@@ -1069,36 +1135,32 @@ fn test_detect_contract_calls(api_version: Version) {
         &wasm_file_path("abi_store_value.wasm", api_version.clone()),
         api_version.clone(),
     );
-    assert_eq!(
-        data_source_without_calls
+    assert!(
+        !data_source_without_calls
             .mapping
             .requires_archive()
-            .unwrap(),
-        false
+            .unwrap()
     );
 
     let data_source_with_calls = mock_data_source(
         &wasm_file_path("contract_calls.wasm", api_version.clone()),
         api_version,
     );
-    assert_eq!(
-        data_source_with_calls.mapping.requires_archive().unwrap(),
-        true
-    );
+    assert!(data_source_with_calls.mapping.requires_archive().unwrap());
 }
 
-#[tokio::test]
+#[graph::test]
 async fn detect_contract_calls_v0_0_4() {
     test_detect_contract_calls(API_VERSION_0_0_4);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn detect_contract_calls_v0_0_5() {
     test_detect_contract_calls(API_VERSION_0_0_5);
 }
 
 async fn test_allocate_global(api_version: Version) {
-    let module = test_module(
+    let mut instance = test_module(
         "AllocateGlobal",
         mock_data_source(
             &wasm_file_path("allocate_global.wasm", api_version.clone()),
@@ -1109,10 +1171,13 @@ async fn test_allocate_global(api_version: Version) {
     .await;
 
     // Assert globals can be allocated and don't break the heap
-    module.invoke_export0_void("assert_global_works").unwrap();
+    instance
+        .invoke_export0_void("assert_global_works")
+        .await
+        .unwrap();
 }
 
-#[tokio::test]
+#[graph::test]
 async fn allocate_global_v0_0_5() {
     // Only in apiVersion v0.0.5 because there's no issue in older versions.
     // The problem with the new one is related to the AS stub runtime `offset`
@@ -1122,8 +1187,8 @@ async fn allocate_global_v0_0_5() {
     test_allocate_global(API_VERSION_0_0_5).await;
 }
 
-async fn test_null_ptr_read(api_version: Version) {
-    let module = test_module(
+async fn test_null_ptr_read(api_version: Version) -> Result<(), Error> {
+    let mut module = test_module(
         "NullPtrRead",
         mock_data_source(
             &wasm_file_path("null_ptr_read.wasm", api_version.clone()),
@@ -1133,17 +1198,21 @@ async fn test_null_ptr_read(api_version: Version) {
     )
     .await;
 
-    module.invoke_export0_void("nullPtrRead").unwrap();
+    module.invoke_export0_void("nullPtrRead").await
 }
 
-#[tokio::test]
-#[should_panic(expected = "Tried to read AssemblyScript value that is 'null'")]
+#[graph::test]
 async fn null_ptr_read_0_0_5() {
-    test_null_ptr_read(API_VERSION_0_0_5).await;
+    let err = test_null_ptr_read(API_VERSION_0_0_5).await.unwrap_err();
+    assert!(
+        format!("{err:?}").contains("Tried to read AssemblyScript value that is 'null'"),
+        "{}",
+        err.to_string()
+    );
 }
 
-async fn test_safe_null_ptr_read(api_version: Version) {
-    let module = test_module(
+async fn test_safe_null_ptr_read(api_version: Version) -> Result<(), Error> {
+    let mut module = test_module(
         "SafeNullPtrRead",
         mock_data_source(
             &wasm_file_path("null_ptr_read.wasm", api_version.clone()),
@@ -1153,81 +1222,102 @@ async fn test_safe_null_ptr_read(api_version: Version) {
     )
     .await;
 
-    module.invoke_export0_void("safeNullPtrRead").unwrap();
+    module.invoke_export0_void("safeNullPtrRead").await
 }
 
-#[tokio::test]
-#[should_panic(expected = "Failed to sum BigInts because left hand side is 'null'")]
+#[graph::test]
 async fn safe_null_ptr_read_0_0_5() {
-    test_safe_null_ptr_read(API_VERSION_0_0_5).await;
+    let err = test_safe_null_ptr_read(API_VERSION_0_0_5)
+        .await
+        .unwrap_err();
+    assert!(
+        format!("{err:?}").contains("Failed to sum BigInts because left hand side is 'null'"),
+        "{}",
+        err.to_string()
+    );
 }
 
 #[ignore] // Ignored because of long run time in debug build.
-#[tokio::test]
+#[graph::test]
 async fn test_array_blowup() {
-    let module = test_module_latest("ArrayBlowup", "array_blowup.wasm").await;
-
-    assert!(module
-        .invoke_export0_void("arrayBlowup")
-        .unwrap_err()
-        .to_string()
-        .contains("Gas limit exceeded. Used: 11286295575421"));
+    let mut module = test_module_latest("ArrayBlowup", "array_blowup.wasm").await;
+    let err = module.invoke_export0_void("arrayBlowup").await.unwrap_err();
+    assert!(format!("{err:?}").contains("Gas limit exceeded. Used: 11286295575421"));
 }
 
-#[tokio::test]
+#[graph::test]
 async fn test_boolean() {
     let mut module = test_module_latest("boolean", "boolean.wasm").await;
 
-    let true_: i32 = module.invoke_export0_val("testReturnTrue");
+    let true_: i32 = module.invoke_export0_val("testReturnTrue").await;
     assert_eq!(true_, 1);
 
-    let false_: i32 = module.invoke_export0_val("testReturnFalse");
+    let false_: i32 = module.invoke_export0_val("testReturnFalse").await;
     assert_eq!(false_, 0);
 
     // non-zero values are true
     for x in (-10i32..10).filter(|&x| x != 0) {
-        assert!(module.invoke_export1_val_void("testReceiveTrue", x).is_ok(),);
+        assert!(
+            module
+                .invoke_export1_val_void("testReceiveTrue", x)
+                .await
+                .is_ok(),
+        );
     }
 
     // zero is not true
-    assert!(module
-        .invoke_export1_val_void("testReceiveTrue", 0i32)
-        .is_err());
+    assert!(
+        module
+            .invoke_export1_val_void("testReceiveTrue", 0i32)
+            .await
+            .is_err()
+    );
 
     // zero is false
-    assert!(module
-        .invoke_export1_val_void("testReceiveFalse", 0i32)
-        .is_ok());
+    assert!(
+        module
+            .invoke_export1_val_void("testReceiveFalse", 0i32)
+            .await
+            .is_ok()
+    );
 
     // non-zero values are not false
     for x in (-10i32..10).filter(|&x| x != 0) {
-        assert!(module
-            .invoke_export1_val_void("testReceiveFalse", x)
-            .is_err());
+        assert!(
+            module
+                .invoke_export1_val_void("testReceiveFalse", x)
+                .await
+                .is_err()
+        );
     }
 }
 
-#[tokio::test]
+#[graph::test]
 async fn recursion_limit() {
-    let module = test_module_latest("RecursionLimit", "recursion_limit.wasm").await;
+    let mut module = test_module_latest("RecursionLimit", "recursion_limit.wasm").await;
 
     // An error about 'unknown key' means the entity was fully read with no stack overflow.
     module
         .invoke_export1_val_void("recursionLimit", 128)
+        .await
         .unwrap_err()
         .to_string()
         .contains("Unknown key `foobar`");
 
-    assert!(module
+    let err = module
         .invoke_export1_val_void("recursionLimit", 129)
-        .unwrap_err()
-        .to_string()
-        .contains("recursion limit reached"));
+        .await
+        .unwrap_err();
+    assert!(
+        format!("{err:?}").contains("recursion limit reached"),
+        "{}",
+        err.to_string()
+    );
 }
 
 struct Host {
-    ctx: MappingContext<Chain>,
-    host_exports: host_exports::test_support::HostExports<Chain>,
+    ctx: MappingContext,
+    host_exports: host_exports::test_support::HostExports,
     stopwatch: StopwatchMetrics,
     gas: GasCounter,
 }
@@ -1270,17 +1360,17 @@ impl Host {
         }
     }
 
-    fn store_set(
+    async fn store_set(
         &mut self,
         entity_type: &str,
         id: &str,
         data: Vec<(&str, &str)>,
     ) -> Result<(), HostExportError> {
         let data: Vec<_> = data.into_iter().map(|(k, v)| (k, Value::from(v))).collect();
-        self.store_setv(entity_type, id, data)
+        self.store_setv(entity_type, id, data).await
     }
 
-    fn store_setv(
+    async fn store_setv(
         &mut self,
         entity_type: &str,
         id: &str,
@@ -1288,31 +1378,34 @@ impl Host {
     ) -> Result<(), HostExportError> {
         let id = String::from(id);
         let data = HashMap::from_iter(data.into_iter().map(|(k, v)| (Word::from(k), v)));
-        self.host_exports.store_set(
-            &self.ctx.logger,
-            &mut self.ctx.state,
-            12, // Arbitrary block number
-            &self.ctx.proof_of_indexing,
-            entity_type.to_string(),
-            id,
-            data,
-            &self.stopwatch,
-            &self.gas,
-        )
+        self.host_exports
+            .store_set(
+                &self.ctx.logger,
+                &mut self.ctx.state,
+                &self.ctx.proof_of_indexing,
+                entity_type.to_string(),
+                id,
+                data,
+                &self.stopwatch,
+                &self.gas,
+            )
+            .await
     }
 
-    fn store_get(
+    async fn store_get(
         &mut self,
         entity_type: &str,
         id: &str,
-    ) -> Result<Option<Cow<Entity>>, anyhow::Error> {
+    ) -> Result<Option<Arc<Entity>>, anyhow::Error> {
         let user_id = String::from(id);
-        self.host_exports.store_get(
-            &mut self.ctx.state,
-            entity_type.to_string(),
-            user_id,
-            &self.gas,
-        )
+        self.host_exports
+            .store_get(
+                &mut self.ctx.state,
+                entity_type.to_string(),
+                user_id,
+                &self.gas,
+            )
+            .await
     }
 }
 
@@ -1324,7 +1417,7 @@ fn err_says<E: std::fmt::Debug + std::fmt::Display>(err: E, exp: &str) {
 
 /// Test the various ways in which `store_set` sets the `id` of entities and
 /// errors when there are issues
-#[tokio::test]
+#[graph::test]
 async fn test_store_set_id() {
     const UID: &str = "u1";
     const USER: &str = "User";
@@ -1344,17 +1437,20 @@ async fn test_store_set_id() {
     let mut host = Host::new(schema, "hostStoreSetId", "boolean.wasm", None).await;
 
     host.store_set(USER, UID, vec![("id", "u1"), ("name", "user1")])
+        .await
         .expect("setting with same id works");
 
     let err = host
         .store_set(USER, UID, vec![("id", "ux"), ("name", "user1")])
+        .await
         .expect_err("setting with different id fails");
     err_says(err, "conflicts with ID passed");
 
     host.store_set(USER, UID, vec![("name", "user2")])
+        .await
         .expect("setting with no id works");
 
-    let entity = host.store_get(USER, UID).unwrap().unwrap();
+    let entity = host.store_get(USER, UID).await.unwrap().unwrap();
     assert_eq!(
         "u1",
         entity.id().to_string(),
@@ -1364,6 +1460,7 @@ async fn test_store_set_id() {
     let beef = Value::Bytes("0xbeef".parse().unwrap());
     let err = host
         .store_setv(USER, "0xbeef", vec![("id", beef)])
+        .await
         .expect_err("setting with Bytes id fails");
     err_says(
         err,
@@ -1371,6 +1468,7 @@ async fn test_store_set_id() {
     );
 
     host.store_setv(USER, UID, vec![("id", Value::Int(32))])
+        .await
         .expect_err("id must be a string");
 
     //
@@ -1380,6 +1478,7 @@ async fn test_store_set_id() {
 
     let err = host
         .store_set(BINARY, BID, vec![("id", BID), ("name", "user1")])
+        .await
         .expect_err("setting with string id in values fails");
     err_says(
         err,
@@ -1391,18 +1490,21 @@ async fn test_store_set_id() {
         BID,
         vec![("id", bid_bytes), ("name", Value::from("user1"))],
     )
+    .await
     .expect("setting with bytes id in values works");
 
     let beef = Value::Bytes("0xbeef".parse().unwrap());
     let err = host
         .store_setv(BINARY, BID, vec![("id", beef)])
+        .await
         .expect_err("setting with different id fails");
     err_says(err, "conflicts with ID passed");
 
     host.store_set(BINARY, BID, vec![("name", "user2")])
+        .await
         .expect("setting with no id works");
 
-    let entity = host.store_get(BINARY, BID).unwrap().unwrap();
+    let entity = host.store_get(BINARY, BID).await.unwrap().unwrap();
     assert_eq!(
         BID,
         entity.id().to_string(),
@@ -1411,6 +1513,7 @@ async fn test_store_set_id() {
 
     let err = host
         .store_setv(BINARY, BID, vec![("id", Value::Int(32))])
+        .await
         .expect_err("id must be Bytes");
     err_says(
         err,
@@ -1420,12 +1523,10 @@ async fn test_store_set_id() {
 
 /// Test setting fields that are not defined in the schema
 /// This should return an error
-#[tokio::test]
+#[graph::test]
 async fn test_store_set_invalid_fields() {
     const UID: &str = "u1";
     const USER: &str = "User";
-    const BID: &str = "0xdeadbeef";
-    const BINARY: &str = "Binary";
     let schema = "
     type User @entity {
         id: ID!,
@@ -1447,6 +1548,7 @@ async fn test_store_set_invalid_fields() {
     .await;
 
     host.store_set(USER, UID, vec![("id", "u1"), ("name", "user1")])
+        .await
         .unwrap();
 
     let err = host
@@ -1460,6 +1562,7 @@ async fn test_store_set_invalid_fields() {
                 ("test2", "invalid_field"),
             ],
         )
+        .await
         .err()
         .unwrap();
 
@@ -1474,10 +1577,14 @@ async fn test_store_set_invalid_fields() {
             UID,
             vec![("id", "u1"), ("name", "user1"), ("test3", "invalid_field")],
         )
+        .await
         .err()
         .unwrap();
 
-    err_says(err, "Attempted to set undefined fields [test3] for the entity type `User`. Make sure those fields are defined in the schema.");
+    err_says(
+        err,
+        "Attempted to set undefined fields [test3] for the entity type `User`. Make sure those fields are defined in the schema.",
+    );
 
     // For apiVersion below 0.0.8, we should not error out
     let mut host2 = Host::new(
@@ -1499,6 +1606,7 @@ async fn test_store_set_invalid_fields() {
                 ("test2", "invalid_field"),
             ],
         )
+        .await
         .err()
         .is_none();
 
@@ -1506,7 +1614,7 @@ async fn test_store_set_invalid_fields() {
 }
 
 /// Test generating ids through `store_set`
-#[tokio::test]
+#[graph::test]
 async fn generate_id() {
     const AUTO: &str = "auto";
     const INT8: &str = "Int8";
@@ -1529,16 +1637,24 @@ async fn generate_id() {
     // new id. Note that the types of the ids have an incorrect type, but
     // that doesn't matter since they get overwritten.
     host.store_set(INT8, AUTO, vec![("id", "u1"), ("name", "int1")])
+        .await
         .expect("setting auto works");
     host.store_set(INT8, AUTO, vec![("id", "u1"), ("name", "int2")])
+        .await
         .expect("setting auto works");
     host.store_set(BINARY, AUTO, vec![("id", "u1"), ("name", "bin1")])
+        .await
         .expect("setting auto works");
     host.store_set(BINARY, AUTO, vec![("id", "u1"), ("name", "bin2")])
+        .await
         .expect("setting auto works");
 
     let entity_cache = host.ctx.state.entity_cache;
-    let mods = entity_cache.as_modifications(12).unwrap().modifications;
+    let mods = entity_cache
+        .as_modifications(12, &STOPWATCH)
+        .await
+        .unwrap()
+        .modifications;
     let id_map: HashMap<&str, Id> = HashMap::from_iter(
         vec![
             (
@@ -1549,8 +1665,8 @@ async fn generate_id() {
                 "bin2",
                 IdType::Bytes.parse("0x0000000c00000003".into()).unwrap(),
             ),
-            ("int1", Id::Int8(0x0000_000c__0000_0000)),
-            ("int2", Id::Int8(0x0000_000c__0000_0001)),
+            ("int1", Id::Int8(0x0000_000c_0000_0000)),
+            ("int2", Id::Int8(0x0000_000c_0000_0001)),
         ]
         .into_iter(),
     );
@@ -1568,7 +1684,7 @@ async fn generate_id() {
     }
 }
 
-#[tokio::test]
+#[graph::test]
 async fn test_store_intf() {
     const UID: &str = "u1";
     const USER: &str = "User";
@@ -1587,16 +1703,19 @@ async fn test_store_intf() {
     let mut host = Host::new(schema, "hostStoreSetIntf", "boolean.wasm", None).await;
 
     host.store_set(PERSON, UID, vec![("id", "u1"), ("name", "user1")])
+        .await
         .expect_err("can not use store_set with an interface");
 
     host.store_set(USER, UID, vec![("id", "u1"), ("name", "user1")])
+        .await
         .expect("storing user works");
 
     host.store_get(PERSON, UID)
+        .await
         .expect_err("store_get with interface does not work");
 }
 
-#[tokio::test]
+#[graph::test]
 async fn test_store_ts() {
     const DATA: &str = "Data";
     const STATS: &str = "Stats";
@@ -1605,14 +1724,14 @@ async fn test_store_ts() {
 
     let schema = r#"
     type Data @entity(timeseries: true) {
-        id: Bytes!
-        timestamp: Int8!
+        id: Int8!
+        timestamp: Timestamp!
         amount: BigDecimal!
     }
 
     type Stats @aggregation(intervals: ["hour"], source: "Data") {
-        id: Bytes!
-        timestamp: Int8!
+        id: Int8!
+        timestamp: Timestamp!
         max: BigDecimal! @aggregate(fn: "max", arg:"amount")
     }"#;
 
@@ -1633,19 +1752,105 @@ async fn test_store_ts() {
             ("amount", b20.clone()),
         ],
     )
+    .await
     .expect("Setting 'Data' is allowed");
 
+    // This is very backhanded: we generate an id the same way that
+    // `store_setv` should have.
+    let did = IdType::Int8.generate_id(12, 0).unwrap();
+
     // Set overrides the user-supplied timestamp for timeseries
-    let data = host.store_get(DATA, DID).unwrap().unwrap();
+    let data = host
+        .store_get(DATA, &did.to_string())
+        .await
+        .unwrap()
+        .unwrap();
     assert_eq!(Some(&Value::from(block_time)), data.get("timestamp"));
 
     let err = host
         .store_setv(STATS, SID, vec![("amount", b20)])
+        .await
         .expect_err("store_set must fail for aggregations");
-    err_says(err, "entity type `Stats` does not exist in hostStoreTs");
+    err_says(
+        err,
+        "Cannot set entity of type `Stats`. The type must be an @entity type",
+    );
 
     let err = host
         .store_get(STATS, SID)
+        .await
         .expect_err("store_get must fail for timeseries");
-    err_says(err, "entity type `Stats` does not exist in hostStoreTs");
+    err_says(
+        err,
+        "Cannot get entity of type `Stats`. The type must be an @entity type",
+    );
+}
+
+async fn test_yaml_parsing(api_version: Version, gas_used: u64) {
+    let mut module = test_module(
+        "yamlParsing",
+        mock_data_source(
+            &wasm_file_path("yaml_parsing.wasm", api_version.clone()),
+            api_version.clone(),
+        ),
+        api_version,
+    )
+    .await;
+
+    let mut test = async |input: &str, expected: &str| {
+        let ptr: AscPtr<AscString> = module.invoke_export1("handleYaml", input.as_bytes()).await;
+        let resp: String = module.asc_get(ptr).unwrap();
+        assert_eq!(resp, expected, "failed on input: {input}");
+    };
+
+    // Test invalid YAML;
+    test("{a: 1, - b: 2}", "error").await;
+
+    // Test size limit;
+    test(&"x".repeat(10_000_001), "error").await;
+
+    // Test nulls;
+    test("null", "(0) null").await;
+
+    // Test booleans;
+    test("false", "(1) false").await;
+    test("true", "(1) true").await;
+
+    // Test numbers;
+    test("12345", "(2) 12345").await;
+    test("12345.6789", "(2) 12345.6789").await;
+
+    // Test strings;
+    test("aa bb cc", "(3) aa bb cc").await;
+    test("\"aa bb cc\"", "(3) aa bb cc").await;
+
+    // Test arrays;
+    test("[1, 2, 3, 4]", "(4) [(2) 1, (2) 2, (2) 3, (2) 4]").await;
+    test("- 1\n- 2\n- 3\n- 4", "(4) [(2) 1, (2) 2, (2) 3, (2) 4]").await;
+
+    // Test objects;
+    test("{a: 1, b: 2, c: 3}", "(5) {a: (2) 1, b: (2) 2, c: (2) 3}").await;
+    test("a: 1\nb: 2\nc: 3", "(5) {a: (2) 1, b: (2) 2, c: (2) 3}").await;
+
+    // Test tagged values;
+    test("!AA bb cc", "(6) !AA (3) bb cc").await;
+
+    // Test nesting;
+    test(
+        "aa:\n  bb:\n    - cc: !DD ee",
+        "(5) {aa: (5) {bb: (4) [(5) {cc: (6) !DD (3) ee}]}}",
+    )
+    .await;
+
+    assert_eq!(module.gas_used(), gas_used, "gas used");
+}
+
+#[graph::test]
+async fn yaml_parsing_v0_0_4() {
+    test_yaml_parsing(API_VERSION_0_0_4, 1066812580659).await;
+}
+
+#[graph::test]
+async fn yaml_parsing_v0_0_5() {
+    test_yaml_parsing(API_VERSION_0_0_5, 1066831062419).await;
 }
diff --git a/runtime/test/src/test/abi.rs b/runtime/test/src/test/abi.rs
index 3c7c2ea13f4..bd1b2de04d9 100644
--- a/runtime/test/src/test/abi.rs
+++ b/runtime/test/src/test/abi.rs
@@ -1,4 +1,4 @@
-use graph::prelude::{ethabi::Token, web3::types::U256};
+use graph::{abi, prelude::alloy::primitives::Address};
 use graph_runtime_wasm::asc_abi::class::{
     ArrayBuffer, AscAddress, AscEnum, AscEnumArray, EthereumValueKind, StoreValueKind, TypedArray,
 };
@@ -7,7 +7,7 @@ use super::*;
 
 async fn test_unbounded_loop(api_version: Version) {
     // Set handler timeout to 3 seconds.
-    let module = test_valid_module_and_store_with_timeout(
+    let mut instance = test_module_and_deployment_with_timeout(
         "unboundedLoop",
         mock_data_source(
             &wasm_file_path("non_terminating.wasm", api_version.clone()),
@@ -18,25 +18,32 @@ async fn test_unbounded_loop(api_version: Version) {
     )
     .await
     .0;
-    let res: Result<(), _> = module.get_func("loop").typed().unwrap().call(());
-    assert_eq!(
-        res.unwrap_err().to_string().lines().next().unwrap(),
-        "wasm trap: interrupt"
+    let res: Result<(), _> = instance
+        .get_func("loop")
+        .typed(instance.store.as_context_mut())
+        .unwrap()
+        .call_async(&mut instance.store.as_context_mut(), ())
+        .await;
+    let err = res.unwrap_err();
+    assert!(
+        format!("{err:?}").contains("wasm trap: interrupt"),
+        "{}",
+        err
     );
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[graph::test]
 async fn unbounded_loop_v0_0_4() {
     test_unbounded_loop(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test(flavor = "multi_thread")]
+#[graph::test]
 async fn unbounded_loop_v0_0_5() {
     test_unbounded_loop(API_VERSION_0_0_5).await;
 }
 
 async fn test_unbounded_recursion(api_version: Version) {
-    let module = test_module(
+    let mut instance = test_module(
         "unboundedRecursion",
         mock_data_source(
             &wasm_file_path("non_terminating.wasm", api_version.clone()),
@@ -45,17 +52,26 @@ async fn test_unbounded_recursion(api_version: Version) {
         api_version,
     )
     .await;
-    let res: Result<(), _> = module.get_func("rabbit_hole").typed().unwrap().call(());
-    let err_msg = res.unwrap_err().to_string();
-    assert!(err_msg.contains("call stack exhausted"), "{:#?}", err_msg);
+    let res: Result<(), _> = instance
+        .get_func("rabbit_hole")
+        .typed(instance.store.as_context_mut())
+        .unwrap()
+        .call_async(&mut instance.store.as_context_mut(), ())
+        .await;
+    let err_msg = res.unwrap_err();
+    assert!(
+        format!("{err_msg:?}").contains("call stack exhausted"),
+        "{:#?}",
+        err_msg
+    );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn unbounded_recursion_v0_0_4() {
     test_unbounded_recursion(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn unbounded_recursion_v0_0_5() {
     test_unbounded_recursion(API_VERSION_0_0_5).await;
 }
@@ -77,7 +93,8 @@ async fn test_abi_array(api_version: Version, gas_used: u64) {
         "3".to_owned(),
         "4".to_owned(),
     ];
-    let new_vec_obj: AscPtr<Array<AscPtr<AscString>>> = module.invoke_export1("test_array", &vec);
+    let new_vec_obj: AscPtr<Array<AscPtr<AscString>>> =
+        module.invoke_export1("test_array", &vec).await;
     let new_vec: Vec<String> = module.asc_get(new_vec_obj).unwrap();
 
     assert_eq!(module.gas_used(), gas_used);
@@ -93,14 +110,14 @@ async fn test_abi_array(api_version: Version, gas_used: u64) {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_array_v0_0_4() {
     test_abi_array(API_VERSION_0_0_4, 695935).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_array_v0_0_5() {
-    test_abi_array(API_VERSION_0_0_5, 1636130).await;
+    test_abi_array(API_VERSION_0_0_5, 1561046).await;
 }
 
 async fn test_abi_subarray(api_version: Version) {
@@ -115,19 +132,20 @@ async fn test_abi_subarray(api_version: Version) {
     .await;
 
     let vec: Vec<u8> = vec![1, 2, 3, 4];
-    let new_vec_obj: AscPtr<TypedArray<u8>> =
-        module.invoke_export1("byte_array_third_quarter", vec.as_slice());
+    let new_vec_obj: AscPtr<TypedArray<u8>> = module
+        .invoke_export1("byte_array_third_quarter", vec.as_slice())
+        .await;
     let new_vec: Vec<u8> = module.asc_get(new_vec_obj).unwrap();
 
     assert_eq!(new_vec, vec![3]);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_subarray_v0_0_4() {
     test_abi_subarray(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_subarray_v0_0_5() {
     test_abi_subarray(API_VERSION_0_0_5).await;
 }
@@ -144,7 +162,7 @@ async fn test_abi_bytes_and_fixed_bytes(api_version: Version) {
     .await;
     let bytes1: Vec<u8> = vec![42, 45, 7, 245, 45];
     let bytes2: Vec<u8> = vec![3, 12, 0, 1, 255];
-    let new_vec_obj: AscPtr<Uint8Array> = module.invoke_export2("concat", &*bytes1, &*bytes2);
+    let new_vec_obj: AscPtr<Uint8Array> = module.invoke_export2("concat", &*bytes1, &*bytes2).await;
 
     // This should be bytes1 and bytes2 concatenated.
     let new_vec: Vec<u8> = module.asc_get(new_vec_obj).unwrap();
@@ -154,19 +172,19 @@ async fn test_abi_bytes_and_fixed_bytes(api_version: Version) {
     assert_eq!(new_vec, concated);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_bytes_and_fixed_bytes_v0_0_4() {
     test_abi_bytes_and_fixed_bytes(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_bytes_and_fixed_bytes_v0_0_5() {
     test_abi_bytes_and_fixed_bytes(API_VERSION_0_0_5).await;
 }
 
-async fn test_abi_ethabi_token_identity(api_version: Version) {
-    let mut module = test_module(
-        "abiEthabiTokenIdentity",
+async fn test_abi_alloy_token_identity(api_version: Version) {
+    let mut instance = test_module(
+        "abiAlloyTokenIdentity",
         mock_data_source(
             &wasm_file_path("abi_token.wasm", api_version.clone()),
             api_version.clone(),
@@ -176,92 +194,126 @@ async fn test_abi_ethabi_token_identity(api_version: Version) {
     .await;
 
     // Token::Address
-    let address = H160([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
-    let token_address = Token::Address(address);
+    let address = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
+    let token_address = abi::DynSolValue::Address(address.into());
 
-    let new_address_obj: AscPtr<AscAddress> =
-        module.invoke_export1("token_to_address", &token_address);
+    let new_address_obj: AscPtr<AscAddress> = instance
+        .invoke_export1("token_to_address", &token_address)
+        .await;
 
-    let new_token_ptr = module.takes_ptr_returns_ptr("token_from_address", new_address_obj);
-    let new_token = module.asc_get(new_token_ptr).unwrap();
+    let new_token_ptr = instance
+        .takes_ptr_returns_ptr("token_from_address", new_address_obj)
+        .await;
+    let new_token = instance.asc_get(new_token_ptr).unwrap();
 
     assert_eq!(token_address, new_token);
 
     // Token::Bytes
-    let token_bytes = Token::Bytes(vec![42, 45, 7, 245, 45]);
-    let new_bytes_obj: AscPtr<ArrayBuffer> = module.invoke_export1("token_to_bytes", &token_bytes);
-    let new_token_ptr = module.takes_ptr_returns_ptr("token_from_bytes", new_bytes_obj);
-    let new_token = module.asc_get(new_token_ptr).unwrap();
+    let token_bytes = abi::DynSolValue::Bytes(vec![42, 45, 7, 245, 45]);
+    let new_bytes_obj: AscPtr<ArrayBuffer> = instance
+        .invoke_export1("token_to_bytes", &token_bytes)
+        .await;
+    let new_token_ptr = instance
+        .takes_ptr_returns_ptr("token_from_bytes", new_bytes_obj)
+        .await;
+    let new_token = instance.asc_get(new_token_ptr).unwrap();
 
     assert_eq!(token_bytes, new_token);
 
     // Token::Int
-    let int_token = Token::Int(U256([256, 453452345, 0, 42]));
-    let new_int_obj: AscPtr<ArrayBuffer> = module.invoke_export1("token_to_int", &int_token);
+    let int = abi::I256::from_limbs([256, 453452345, 0, 42]);
+    let int_token = abi::DynSolValue::Int(int, int.bits() as usize);
+    let new_int_obj: AscPtr<ArrayBuffer> =
+        instance.invoke_export1("token_to_int", &int_token).await;
 
-    let new_token_ptr = module.takes_ptr_returns_ptr("token_from_int", new_int_obj);
-    let new_token = module.asc_get(new_token_ptr).unwrap();
+    let new_token_ptr = instance
+        .takes_ptr_returns_ptr("token_from_int", new_int_obj)
+        .await;
+    let new_token = instance.asc_get(new_token_ptr).unwrap();
 
     assert_eq!(int_token, new_token);
 
     // Token::Uint
-    let uint_token = Token::Uint(U256([256, 453452345, 0, 42]));
+    let uint = U256::from_limbs([256, 453452345, 0, 42]);
+    let uint_token = abi::DynSolValue::Uint(uint, uint.bit_len());
 
-    let new_uint_obj: AscPtr<ArrayBuffer> = module.invoke_export1("token_to_uint", &uint_token);
-    let new_token_ptr = module.takes_ptr_returns_ptr("token_from_uint", new_uint_obj);
-    let new_token = module.asc_get(new_token_ptr).unwrap();
+    let new_uint_obj: AscPtr<ArrayBuffer> =
+        instance.invoke_export1("token_to_uint", &uint_token).await;
+    let new_token_ptr = instance
+        .takes_ptr_returns_ptr("token_from_uint", new_uint_obj)
+        .await;
+    let new_token = instance.asc_get(new_token_ptr).unwrap();
 
     assert_eq!(uint_token, new_token);
     assert_ne!(uint_token, int_token);
 
     // Token::Bool
-    let token_bool = Token::Bool(true);
+    let token_bool = abi::DynSolValue::Bool(true);
 
-    let token_bool_ptr = module.asc_new(&token_bool).unwrap();
-    let func = module.get_func("token_to_bool").typed().unwrap().clone();
-    let boolean: i32 = func.call(token_bool_ptr.wasm_ptr()).unwrap();
+    let token_bool_ptr = instance.asc_new(&token_bool).await.unwrap();
+    let func = instance
+        .get_func("token_to_bool")
+        .typed(instance.store.as_context_mut())
+        .unwrap()
+        .clone();
+    let boolean: i32 = func
+        .call_async(
+            &mut instance.store.as_context_mut(),
+            token_bool_ptr.wasm_ptr(),
+        )
+        .await
+        .unwrap();
 
-    let new_token_ptr = module.takes_val_returns_ptr("token_from_bool", boolean);
-    let new_token = module.asc_get(new_token_ptr).unwrap();
+    let new_token_ptr = instance
+        .takes_val_returns_ptr("token_from_bool", boolean)
+        .await;
+    let new_token = instance.asc_get(new_token_ptr).unwrap();
 
     assert_eq!(token_bool, new_token);
 
     // Token::String
-    let token_string = Token::String("漢字Go🇧🇷".into());
-    let new_string_obj: AscPtr<AscString> = module.invoke_export1("token_to_string", &token_string);
-    let new_token_ptr = module.takes_ptr_returns_ptr("token_from_string", new_string_obj);
-    let new_token = module.asc_get(new_token_ptr).unwrap();
+    let token_string = abi::DynSolValue::String("漢字Go🇧🇷".into());
+    let new_string_obj: AscPtr<AscString> = instance
+        .invoke_export1("token_to_string", &token_string)
+        .await;
+    let new_token_ptr = instance
+        .takes_ptr_returns_ptr("token_from_string", new_string_obj)
+        .await;
+    let new_token = instance.asc_get(new_token_ptr).unwrap();
 
     assert_eq!(token_string, new_token);
 
     // Token::Array
-    let token_array = Token::Array(vec![token_address, token_bytes, token_bool]);
-    let token_array_nested = Token::Array(vec![token_string, token_array]);
-    let new_array_obj: AscEnumArray<EthereumValueKind> =
-        module.invoke_export1("token_to_array", &token_array_nested);
+    let token_array = abi::DynSolValue::Array(vec![token_address, token_bytes, token_bool]);
+    let token_array_nested = abi::DynSolValue::Array(vec![token_string, token_array]);
+    let new_array_obj: AscEnumArray<EthereumValueKind> = instance
+        .invoke_export1("token_to_array", &token_array_nested)
+        .await;
 
-    let new_token_ptr = module.takes_ptr_returns_ptr("token_from_array", new_array_obj);
-    let new_token: Token = module.asc_get(new_token_ptr).unwrap();
+    let new_token_ptr = instance
+        .takes_ptr_returns_ptr("token_from_array", new_array_obj)
+        .await;
+    let new_token: abi::DynSolValue = instance.asc_get(new_token_ptr).unwrap();
 
     assert_eq!(new_token, token_array_nested);
 }
 
 /// Test a roundtrip Token -> Payload -> Token identity conversion through asc,
 /// and assert the final token is the same as the starting one.
-#[tokio::test]
+#[graph::test]
 async fn abi_ethabi_token_identity_v0_0_4() {
-    test_abi_ethabi_token_identity(API_VERSION_0_0_4).await;
+    test_abi_alloy_token_identity(API_VERSION_0_0_4).await;
 }
 
 /// Test a roundtrip Token -> Payload -> Token identity conversion through asc,
 /// and assert the final token is the same as the starting one.
-#[tokio::test]
+#[graph::test]
 async fn abi_ethabi_token_identity_v0_0_5() {
-    test_abi_ethabi_token_identity(API_VERSION_0_0_5).await;
+    test_abi_alloy_token_identity(API_VERSION_0_0_5).await;
 }
 
 async fn test_abi_store_value(api_version: Version) {
-    let mut module = test_module(
+    let mut instance = test_module(
         "abiStoreValue",
         mock_data_source(
             &wasm_file_path("abi_store_value.wasm", api_version.clone()),
@@ -272,58 +324,76 @@ async fn test_abi_store_value(api_version: Version) {
     .await;
 
     // Value::Null
-    let func = module.get_func("value_null").typed().unwrap().clone();
-    let ptr: u32 = func.call(()).unwrap();
+    let func = instance
+        .get_func("value_null")
+        .typed(instance.store.as_context_mut())
+        .unwrap()
+        .clone();
+    let ptr: u32 = func
+        .call_async(&mut instance.store.as_context_mut(), ())
+        .await
+        .unwrap();
     let null_value_ptr: AscPtr<AscEnum<StoreValueKind>> = ptr.into();
-    let null_value: Value = module.asc_get(null_value_ptr).unwrap();
+    let null_value: Value = instance.asc_get(null_value_ptr).unwrap();
     assert_eq!(null_value, Value::Null);
 
     // Value::String
     let string = "some string";
-    let new_value_ptr = module.invoke_export1("value_from_string", string);
-    let new_value: Value = module.asc_get(new_value_ptr).unwrap();
+    let new_value_ptr = instance.invoke_export1("value_from_string", string).await;
+    let new_value: Value = instance.asc_get(new_value_ptr).unwrap();
     assert_eq!(new_value, Value::from(string));
 
     // Value::Int
-    let int = i32::min_value();
-    let new_value_ptr = module.takes_val_returns_ptr("value_from_int", int);
-    let new_value: Value = module.asc_get(new_value_ptr).unwrap();
+    let int = i32::MIN;
+    let new_value_ptr = instance.takes_val_returns_ptr("value_from_int", int).await;
+    let new_value: Value = instance.asc_get(new_value_ptr).unwrap();
     assert_eq!(new_value, Value::Int(int));
 
     // Value::Int8
-    let int8 = i64::min_value();
-    let new_value_ptr = module.takes_val_returns_ptr("value_from_int8", int8);
-    let new_value: Value = module.asc_get(new_value_ptr).unwrap();
+    let int8 = i64::MIN;
+    let new_value_ptr = instance
+        .takes_val_returns_ptr("value_from_int8", int8)
+        .await;
+    let new_value: Value = instance.asc_get(new_value_ptr).unwrap();
     assert_eq!(new_value, Value::Int8(int8));
 
     // Value::BigDecimal
     let big_decimal = BigDecimal::from_str("3.14159001").unwrap();
-    let new_value_ptr = module.invoke_export1("value_from_big_decimal", &big_decimal);
-    let new_value: Value = module.asc_get(new_value_ptr).unwrap();
+    let new_value_ptr = instance
+        .invoke_export1("value_from_big_decimal", &big_decimal)
+        .await;
+    let new_value: Value = instance.asc_get(new_value_ptr).unwrap();
     assert_eq!(new_value, Value::BigDecimal(big_decimal));
 
     let big_decimal = BigDecimal::new(10.into(), 5);
-    let new_value_ptr = module.invoke_export1("value_from_big_decimal", &big_decimal);
-    let new_value: Value = module.asc_get(new_value_ptr).unwrap();
+    let new_value_ptr = instance
+        .invoke_export1("value_from_big_decimal", &big_decimal)
+        .await;
+    let new_value: Value = instance.asc_get(new_value_ptr).unwrap();
     assert_eq!(new_value, Value::BigDecimal(1_000_000.into()));
 
     // Value::Bool
     let boolean = true;
-    let new_value_ptr = module.takes_val_returns_ptr("value_from_bool", boolean as i32);
-    let new_value: Value = module.asc_get(new_value_ptr).unwrap();
+    let new_value_ptr = instance
+        .takes_val_returns_ptr("value_from_bool", boolean as i32)
+        .await;
+    let new_value: Value = instance.asc_get(new_value_ptr).unwrap();
     assert_eq!(new_value, Value::Bool(boolean));
 
     // Value::List
-    let func = module
+    let func = instance
         .get_func("array_from_values")
-        .typed()
+        .typed(instance.store.as_context_mut())
         .unwrap()
         .clone();
+
+    let wasm_ptr = instance.asc_new(string).await.unwrap().wasm_ptr();
     let new_value_ptr: u32 = func
-        .call((module.asc_new(string).unwrap().wasm_ptr(), int))
+        .call_async(&mut instance.store.as_context_mut(), (wasm_ptr, int))
+        .await
         .unwrap();
     let new_value_ptr = AscPtr::from(new_value_ptr);
-    let new_value: Value = module.asc_get(new_value_ptr).unwrap();
+    let new_value: Value = instance.asc_get(new_value_ptr).unwrap();
     assert_eq!(
         new_value,
         Value::List(vec![Value::from(string), Value::Int(int)])
@@ -333,8 +403,8 @@ async fn test_abi_store_value(api_version: Version) {
         Value::String("foo".to_owned()),
         Value::String("bar".to_owned()),
     ];
-    let new_value_ptr = module.invoke_export1("value_from_array", array);
-    let new_value: Value = module.asc_get(new_value_ptr).unwrap();
+    let new_value_ptr = instance.invoke_export1("value_from_array", array).await;
+    let new_value: Value = instance.asc_get(new_value_ptr).unwrap();
     assert_eq!(
         new_value,
         Value::List(vec![
@@ -345,26 +415,26 @@ async fn test_abi_store_value(api_version: Version) {
 
     // Value::Bytes
     let bytes: &[u8] = &[0, 2, 5];
-    let new_value_ptr = module.invoke_export1("value_from_bytes", bytes);
-    let new_value: Value = module.asc_get(new_value_ptr).unwrap();
+    let new_value_ptr = instance.invoke_export1("value_from_bytes", bytes).await;
+    let new_value: Value = instance.asc_get(new_value_ptr).unwrap();
     assert_eq!(new_value, Value::Bytes(bytes.into()));
 
     // Value::BigInt
     let bytes: &[u8] = &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
-    let new_value_ptr = module.invoke_export1("value_from_bigint", bytes);
-    let new_value: Value = module.asc_get(new_value_ptr).unwrap();
+    let new_value_ptr = instance.invoke_export1("value_from_bigint", bytes).await;
+    let new_value: Value = instance.asc_get(new_value_ptr).unwrap();
     assert_eq!(
         new_value,
         Value::BigInt(::graph::data::store::scalar::BigInt::from_unsigned_bytes_le(bytes).unwrap())
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_store_value_v0_0_4() {
     test_abi_store_value(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_store_value_v0_0_5() {
     test_abi_store_value(API_VERSION_0_0_5).await;
 }
@@ -379,26 +449,26 @@ async fn test_abi_h160(api_version: Version) {
         api_version,
     )
     .await;
-    let address = H160::zero();
+    let address = Address::ZERO;
 
     // As an `Uint8Array`
-    let new_address_obj: AscPtr<Uint8Array> = module.invoke_export1("test_address", &address);
+    let new_address_obj: AscPtr<Uint8Array> = module.invoke_export1("test_address", &address).await;
 
     // This should have 1 added to the first and last byte.
-    let new_address: H160 = module.asc_get(new_address_obj).unwrap();
+    let new_address: Address = module.asc_get(new_address_obj).unwrap();
 
     assert_eq!(
         new_address,
-        H160([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+        Address::from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_h160_v0_0_4() {
     test_abi_h160(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_h160_v0_0_5() {
     test_abi_h160(API_VERSION_0_0_5).await;
 }
@@ -414,17 +484,17 @@ async fn test_string(api_version: Version) {
     )
     .await;
     let string = "    漢字Double_Me🇧🇷  ";
-    let trimmed_string_obj: AscPtr<AscString> = module.invoke_export1("repeat_twice", string);
+    let trimmed_string_obj: AscPtr<AscString> = module.invoke_export1("repeat_twice", string).await;
     let doubled_string: String = module.asc_get(trimmed_string_obj).unwrap();
     assert_eq!(doubled_string, string.repeat(2));
 }
 
-#[tokio::test]
+#[graph::test]
 async fn string_v0_0_4() {
     test_string(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn string_v0_0_5() {
     test_string(API_VERSION_0_0_5).await;
 }
@@ -441,29 +511,30 @@ async fn test_abi_big_int(api_version: Version) {
     .await;
 
     // Test passing in 0 and increment it by 1
-    let old_uint = U256::zero();
-    let new_uint_obj: AscPtr<AscBigInt> =
-        module.invoke_export1("test_uint", &BigInt::from_unsigned_u256(&old_uint));
+    let old_uint = U256::ZERO;
+    let new_uint_obj: AscPtr<AscBigInt> = module
+        .invoke_export1("test_uint", &BigInt::from_unsigned_u256(&old_uint))
+        .await;
     let new_uint: BigInt = module.asc_get(new_uint_obj).unwrap();
     assert_eq!(new_uint, BigInt::from(1_i32));
-    let new_uint = new_uint.to_unsigned_u256();
-    assert_eq!(new_uint, U256([1, 0, 0, 0]));
+    let new_uint = new_uint.to_unsigned_u256().unwrap();
+    assert_eq!(new_uint, U256::from_limbs([1, 0, 0, 0]));
 
     // Test passing in -50 and increment it by 1
     let old_uint = BigInt::from(-50);
-    let new_uint_obj: AscPtr<AscBigInt> = module.invoke_export1("test_uint", &old_uint);
+    let new_uint_obj: AscPtr<AscBigInt> = module.invoke_export1("test_uint", &old_uint).await;
     let new_uint: BigInt = module.asc_get(new_uint_obj).unwrap();
     assert_eq!(new_uint, BigInt::from(-49_i32));
-    let new_uint_from_u256 = BigInt::from_signed_u256(&new_uint.to_signed_u256());
-    assert_eq!(new_uint, new_uint_from_u256);
+    let new_uint_from_i256 = BigInt::from_i256(&new_uint.to_i256().unwrap());
+    assert_eq!(new_uint, new_uint_from_i256);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_big_int_v0_0_4() {
     test_abi_big_int(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn abi_big_int_v0_0_5() {
     test_abi_big_int(API_VERSION_0_0_5).await;
 }
@@ -481,23 +552,23 @@ async fn test_big_int_to_string(api_version: Version) {
 
     let big_int_str = "30145144166666665000000000000000000";
     let big_int = BigInt::from_str(big_int_str).unwrap();
-    let string_obj: AscPtr<AscString> = module.invoke_export1("big_int_to_string", &big_int);
+    let string_obj: AscPtr<AscString> = module.invoke_export1("big_int_to_string", &big_int).await;
     let string: String = module.asc_get(string_obj).unwrap();
     assert_eq!(string, big_int_str);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn big_int_to_string_v0_0_4() {
     test_big_int_to_string(API_VERSION_0_0_4).await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn big_int_to_string_v0_0_5() {
     test_big_int_to_string(API_VERSION_0_0_5).await;
 }
 
 async fn test_invalid_discriminant(api_version: Version) {
-    let module = test_module(
+    let mut instance = test_module(
         "invalidDiscriminant",
         mock_data_source(
             &wasm_file_path("abi_store_value.wasm", api_version.clone()),
@@ -507,18 +578,21 @@ async fn test_invalid_discriminant(api_version: Version) {
     )
     .await;
 
-    let func = module
+    let func = instance
         .get_func("invalid_discriminant")
-        .typed()
+        .typed(instance.store.as_context_mut())
         .unwrap()
         .clone();
-    let ptr: u32 = func.call(()).unwrap();
-    let _value: Value = module.asc_get(ptr.into()).unwrap();
+    let ptr: u32 = func
+        .call_async(&mut instance.store.as_context_mut(), ())
+        .await
+        .unwrap();
+    let _value: Value = instance.asc_get(ptr.into()).unwrap();
 }
 
 // This should panic rather than exhibiting UB. It's hard to test for UB, but
 // when reproducing a SIGILL was observed which would be caught by this.
-#[tokio::test]
+#[graph::test]
 #[should_panic]
 async fn invalid_discriminant_v0_0_4() {
     test_invalid_discriminant(API_VERSION_0_0_4).await;
@@ -526,7 +600,7 @@ async fn invalid_discriminant_v0_0_4() {
 
 // This should panic rather than exhibiting UB. It's hard to test for UB, but
 // when reproducing a SIGILL was observed which would be caught by this.
-#[tokio::test]
+#[graph::test]
 #[should_panic]
 async fn invalid_discriminant_v0_0_5() {
     test_invalid_discriminant(API_VERSION_0_0_5).await;
diff --git a/runtime/test/src/test_padding.rs b/runtime/test/src/test_padding.rs
index 968677bd087..89cab5b7231 100644
--- a/runtime/test/src/test_padding.rs
+++ b/runtime/test/src/test_padding.rs
@@ -1,5 +1,5 @@
 use crate::protobuf;
-use graph::prelude::tokio;
+use wasmtime::AsContextMut;
 
 use self::data::BadFixed;
 
@@ -7,8 +7,8 @@ const WASM_FILE_NAME: &str = "test_padding.wasm";
 
 //for tests, to run in parallel, sub graph name has be unique
 fn rnd_sub_graph_name(size: usize) -> String {
-    use rand::{distributions::Alphanumeric, Rng};
-    rand::thread_rng()
+    use rand::{Rng, distr::Alphanumeric};
+    rand::rng()
         .sample_iter(&Alphanumeric)
         .take(size)
         .map(char::from)
@@ -16,56 +16,6 @@ fn rnd_sub_graph_name(size: usize) -> String {
 }
 
 pub mod data {
-    #[graph_runtime_derive::generate_asc_type()]
-    #[graph_runtime_derive::generate_network_type_id(UnitTestNetwork)]
-    #[graph_runtime_derive::generate_from_rust_type()]
-    #[graph_runtime_derive::generate_array_type(UnitTestNetwork)]
-    #[derive(Debug, PartialEq)]
-    pub struct UnitTestTypeBool {
-        pub str_pref: String,
-        pub under_test: bool,
-        pub str_suff: String,
-        pub large: i64,
-        pub tail: bool,
-    }
-
-    #[graph_runtime_derive::generate_asc_type()]
-    #[graph_runtime_derive::generate_network_type_id(UnitTestNetwork)]
-    #[graph_runtime_derive::generate_from_rust_type()]
-    #[graph_runtime_derive::generate_array_type(UnitTestNetwork)]
-    #[derive(Debug, PartialEq)]
-    pub struct UnitTestTypeI8 {
-        pub str_pref: String,
-        pub under_test: i8,
-        pub str_suff: String,
-        pub large: i64,
-        pub tail: bool,
-    }
-    #[graph_runtime_derive::generate_asc_type()]
-    #[graph_runtime_derive::generate_network_type_id(UnitTestNetwork)]
-    #[graph_runtime_derive::generate_from_rust_type()]
-    #[graph_runtime_derive::generate_array_type(UnitTestNetwork)]
-    #[derive(Debug, PartialEq)]
-    pub struct UnitTestTypeU16 {
-        pub str_pref: String,
-        pub under_test: u16,
-        pub str_suff: String,
-        pub large: i64,
-        pub tail: bool,
-    }
-    #[graph_runtime_derive::generate_asc_type()]
-    #[graph_runtime_derive::generate_network_type_id(UnitTestNetwork)]
-    #[graph_runtime_derive::generate_from_rust_type()]
-    #[graph_runtime_derive::generate_array_type(UnitTestNetwork)]
-    #[derive(Debug, PartialEq)]
-    pub struct UnitTestTypeU32 {
-        pub str_pref: String,
-        pub under_test: u32,
-        pub str_suff: String,
-        pub large: i64,
-        pub tail: bool,
-    }
-
     pub struct Bad {
         pub nonce: u64,
         pub str_suff: String,
@@ -75,7 +25,7 @@ pub mod data {
     #[repr(C)]
     pub struct AscBad {
         pub nonce: u64,
-        pub str_suff: graph::runtime::AscPtr<graph_runtime_wasm::asc_abi::class::AscString>,
+        pub str_suff: AscPtr<AscString>,
         pub tail: u64,
     }
 
@@ -109,21 +59,24 @@ pub mod data {
             IndexForAscTypeId::UnitTestNetworkUnitTestTypeBool;
     }
 
+    use async_trait::async_trait;
     use graph::runtime::HostExportError;
     pub use graph::runtime::{
-        asc_new, gas::GasCounter, AscHeap, AscIndexId, AscPtr, AscType, AscValue,
-        DeterministicHostError, IndexForAscTypeId, ToAscObj,
+        AscHeap, AscIndexId, AscPtr, AscType, AscValue, DeterministicHostError, IndexForAscTypeId,
+        ToAscObj, asc_new, gas::GasCounter,
     };
+    use graph_runtime_wasm::asc_abi::class::AscString;
 
+    #[async_trait]
     impl ToAscObj<AscBad> for Bad {
-        fn to_asc_obj<H: AscHeap + ?Sized>(
+        async fn to_asc_obj<H: AscHeap + ?Sized>(
             &self,
             heap: &mut H,
             gas: &GasCounter,
         ) -> Result<AscBad, HostExportError> {
             Ok(AscBad {
                 nonce: self.nonce,
-                str_suff: asc_new(heap, &self.str_suff, gas)?,
+                str_suff: asc_new(heap, &self.str_suff, gas).await?,
                 tail: self.tail,
             })
         }
@@ -174,15 +127,16 @@ pub mod data {
             IndexForAscTypeId::UnitTestNetworkUnitTestTypeBool;
     }
 
+    #[async_trait]
     impl ToAscObj<AscBadFixed> for BadFixed {
-        fn to_asc_obj<H: AscHeap + ?Sized>(
+        async fn to_asc_obj<H: AscHeap + ?Sized>(
             &self,
             heap: &mut H,
             gas: &GasCounter,
         ) -> Result<AscBadFixed, HostExportError> {
             Ok(AscBadFixed {
                 nonce: self.nonce,
-                str_suff: asc_new(heap, &self.str_suff, gas)?,
+                str_suff: asc_new(heap, &self.str_suff, gas).await?,
                 _padding: 0,
                 tail: self.tail,
             })
@@ -190,68 +144,28 @@ pub mod data {
     }
 }
 
-#[tokio::test]
+#[graph::test]
 async fn test_v5_manual_padding_manualy_fixed_ok() {
     manual_padding_manualy_fixed_ok(super::test::API_VERSION_0_0_5).await
 }
 
-#[tokio::test]
+#[graph::test]
 async fn test_v4_manual_padding_manualy_fixed_ok() {
     manual_padding_manualy_fixed_ok(super::test::API_VERSION_0_0_4).await
 }
 
-#[tokio::test]
+#[graph::test]
 async fn test_v5_manual_padding_should_fail() {
     manual_padding_should_fail(super::test::API_VERSION_0_0_5).await
 }
 
-#[tokio::test]
+#[graph::test]
 async fn test_v4_manual_padding_should_fail() {
     manual_padding_should_fail(super::test::API_VERSION_0_0_4).await
 }
 
-#[tokio::test]
-async fn test_v5_bool_padding_ok() {
-    bool_padding_ok(super::test::API_VERSION_0_0_5).await
-}
-
-#[tokio::test]
-async fn test_v4_bool_padding_ok() {
-    bool_padding_ok(super::test::API_VERSION_0_0_4).await
-}
-
-#[tokio::test]
-async fn test_v5_i8_padding_ok() {
-    i8_padding_ok(super::test::API_VERSION_0_0_5).await
-}
-
-#[tokio::test]
-async fn test_v4_i8_padding_ok() {
-    i8_padding_ok(super::test::API_VERSION_0_0_4).await
-}
-
-#[tokio::test]
-async fn test_v5_u16_padding_ok() {
-    u16_padding_ok(super::test::API_VERSION_0_0_5).await
-}
-
-#[tokio::test]
-async fn test_v4_u16_padding_ok() {
-    u16_padding_ok(super::test::API_VERSION_0_0_4).await
-}
-
-#[tokio::test]
-async fn test_v5_u32_padding_ok() {
-    u32_padding_ok(super::test::API_VERSION_0_0_5).await
-}
-
-#[tokio::test]
-async fn test_v4_u32_padding_ok() {
-    u32_padding_ok(super::test::API_VERSION_0_0_4).await
-}
-
 async fn manual_padding_should_fail(api_version: semver::Version) {
-    let mut module = super::test::test_module(
+    let mut instance = super::test::test_module(
         &rnd_sub_graph_name(12),
         super::common::mock_data_source(
             &super::test::wasm_file_path(WASM_FILE_NAME, api_version.clone()),
@@ -267,15 +181,17 @@ async fn manual_padding_should_fail(api_version: semver::Version) {
         tail: i64::MAX as u64,
     };
 
-    let new_obj = module.asc_new(&parm).unwrap();
+    let new_obj = instance.asc_new(&parm).await.unwrap();
 
-    let func = module
+    let func = instance
         .get_func("test_padding_manual")
-        .typed()
+        .typed(instance.store.as_context_mut())
         .unwrap()
         .clone();
 
-    let res: Result<(), _> = func.call(new_obj.wasm_ptr());
+    let res: Result<(), _> = func
+        .call_async(&mut instance.store.as_context_mut(), new_obj.wasm_ptr())
+        .await;
 
     assert!(
         res.is_err(),
@@ -290,7 +206,7 @@ async fn manual_padding_manualy_fixed_ok(api_version: semver::Version) {
         tail: i64::MAX as u64,
     };
 
-    let mut module = super::test::test_module(
+    let mut instance = super::test::test_module(
         &rnd_sub_graph_name(12),
         super::common::mock_data_source(
             &super::test::wasm_file_path(WASM_FILE_NAME, api_version.clone()),
@@ -300,131 +216,17 @@ async fn manual_padding_manualy_fixed_ok(api_version: semver::Version) {
     )
     .await;
 
-    let new_obj = module.asc_new(&parm).unwrap();
+    let new_obj = instance.asc_new(&parm).await.unwrap();
 
-    let func = module
+    let func = instance
         .get_func("test_padding_manual")
-        .typed()
+        .typed(instance.store.as_context_mut())
         .unwrap()
         .clone();
 
-    let res: Result<(), _> = func.call(new_obj.wasm_ptr());
-
-    assert!(res.is_ok(), "{:?}", res.err());
-}
-
-async fn bool_padding_ok(api_version: semver::Version) {
-    let mut module = super::test::test_module(
-        &rnd_sub_graph_name(12),
-        super::common::mock_data_source(
-            &super::test::wasm_file_path(WASM_FILE_NAME, api_version.clone()),
-            api_version.clone(),
-        ),
-        api_version,
-    )
-    .await;
-
-    let parm = protobuf::UnitTestTypeBool {
-        str_pref: "pref".into(),
-        under_test: true,
-        str_suff: "suff".into(),
-        large: i64::MAX,
-        tail: true,
-    };
-
-    let new_obj = module.asc_new(&parm).unwrap();
-
-    let func = module
-        .get_func("test_padding_bool")
-        .typed()
-        .unwrap()
-        .clone();
-
-    let res: Result<(), _> = func.call(new_obj.wasm_ptr());
-
-    assert!(res.is_ok(), "{:?}", res.err());
-}
-
-async fn i8_padding_ok(api_version: semver::Version) {
-    let mut module = super::test::test_module(
-        &rnd_sub_graph_name(12),
-        super::common::mock_data_source(
-            &super::test::wasm_file_path(WASM_FILE_NAME, api_version.clone()),
-            api_version.clone(),
-        ),
-        api_version,
-    )
-    .await;
-
-    let parm = protobuf::UnitTestTypeI8 {
-        str_pref: "pref".into(),
-        under_test: i8::MAX,
-        str_suff: "suff".into(),
-        large: i64::MAX,
-        tail: true,
-    };
-
-    let new_obj = module.asc_new(&parm).unwrap();
-
-    let func = module.get_func("test_padding_i8").typed().unwrap().clone();
-
-    let res: Result<(), _> = func.call(new_obj.wasm_ptr());
-
-    assert!(res.is_ok(), "{:?}", res.err());
-}
-
-async fn u16_padding_ok(api_version: semver::Version) {
-    let mut module = super::test::test_module(
-        &rnd_sub_graph_name(12),
-        super::common::mock_data_source(
-            &super::test::wasm_file_path(WASM_FILE_NAME, api_version.clone()),
-            api_version.clone(),
-        ),
-        api_version,
-    )
-    .await;
-
-    let parm = protobuf::UnitTestTypeU16 {
-        str_pref: "pref".into(),
-        under_test: i16::MAX as u16,
-        str_suff: "suff".into(),
-        large: i64::MAX,
-        tail: true,
-    };
-
-    let new_obj = module.asc_new(&parm).unwrap();
-
-    let func = module.get_func("test_padding_i16").typed().unwrap().clone();
-
-    let res: Result<(), _> = func.call(new_obj.wasm_ptr());
-
-    assert!(res.is_ok(), "{:?}", res.err());
-}
-
-async fn u32_padding_ok(api_version: semver::Version) {
-    let mut module = super::test::test_module(
-        &rnd_sub_graph_name(12),
-        super::common::mock_data_source(
-            &super::test::wasm_file_path(WASM_FILE_NAME, api_version.clone()),
-            api_version.clone(),
-        ),
-        api_version,
-    )
-    .await;
-
-    let parm = protobuf::UnitTestTypeU32 {
-        str_pref: "pref".into(),
-        under_test: i32::MAX as u32,
-        str_suff: "suff".into(),
-        large: i64::MAX,
-        tail: true,
-    };
-
-    let new_obj = module.asc_new(&parm).unwrap();
-
-    let func = module.get_func("test_padding_i32").typed().unwrap().clone();
-
-    let res: Result<(), _> = func.call(new_obj.wasm_ptr());
+    let res: Result<(), _> = func
+        .call_async(&mut instance.store.as_context_mut(), new_obj.wasm_ptr())
+        .await;
 
     assert!(res.is_ok(), "{:?}", res.err());
 }
diff --git a/runtime/test/wasm_test/api_version_0_0_4/abi_store_value.ts b/runtime/test/wasm_test/api_version_0_0_4/abi_store_value.ts
index d95a0402a3b..570f4271fb8 100644
--- a/runtime/test/wasm_test/api_version_0_0_4/abi_store_value.ts
+++ b/runtime/test/wasm_test/api_version_0_0_4/abi_store_value.ts
@@ -12,6 +12,7 @@ enum ValueKind {
     BYTES = 6,
     BIG_INT = 7,
     INT8 = 8,
+    TIMESTAMP = 9,
 }
 
 // Big enough to fit any pointer or native `this.data`.
@@ -44,6 +45,13 @@ export function value_from_int(int: i32): Value {
     return value
 }
 
+export function value_from_timestamp(ts: i64): Value {
+    let value = new Value();
+    value.kind = ValueKind.TIMESTAMP;
+    value.data = ts as i64
+    return value
+}
+
 export function value_from_int8(int: i64): Value {
     let value = new Value();
     value.kind = ValueKind.INT8;
diff --git a/runtime/test/wasm_test/api_version_0_0_4/abi_store_value.wasm b/runtime/test/wasm_test/api_version_0_0_4/abi_store_value.wasm
index 8e2be6f47a6..28cf7d12a5a 100644
Binary files a/runtime/test/wasm_test/api_version_0_0_4/abi_store_value.wasm and b/runtime/test/wasm_test/api_version_0_0_4/abi_store_value.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_4/abi_token.wasm b/runtime/test/wasm_test/api_version_0_0_4/abi_token.wasm
index edf14dcf1db..b48707f2f1a 100644
Binary files a/runtime/test/wasm_test/api_version_0_0_4/abi_token.wasm and b/runtime/test/wasm_test/api_version_0_0_4/abi_token.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_4/abort.wasm b/runtime/test/wasm_test/api_version_0_0_4/abort.wasm
index 2fbfbab5488..cb7873ad591 100644
Binary files a/runtime/test/wasm_test/api_version_0_0_4/abort.wasm and b/runtime/test/wasm_test/api_version_0_0_4/abort.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_4/ens_name_by_hash.wasm b/runtime/test/wasm_test/api_version_0_0_4/ens_name_by_hash.wasm
index c7e21be7c70..2f76b38938c 100644
Binary files a/runtime/test/wasm_test/api_version_0_0_4/ens_name_by_hash.wasm and b/runtime/test/wasm_test/api_version_0_0_4/ens_name_by_hash.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_4/ipfs_map.wasm b/runtime/test/wasm_test/api_version_0_0_4/ipfs_map.wasm
index 5776f0ff269..71cf223242d 100644
Binary files a/runtime/test/wasm_test/api_version_0_0_4/ipfs_map.wasm and b/runtime/test/wasm_test/api_version_0_0_4/ipfs_map.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_4/json_parsing.wasm b/runtime/test/wasm_test/api_version_0_0_4/json_parsing.wasm
index ad6a93257ab..6546d6b27bc 100644
Binary files a/runtime/test/wasm_test/api_version_0_0_4/json_parsing.wasm and b/runtime/test/wasm_test/api_version_0_0_4/json_parsing.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_4/store.wasm b/runtime/test/wasm_test/api_version_0_0_4/store.wasm
index ec7027c19ab..7b3f1a487de 100644
Binary files a/runtime/test/wasm_test/api_version_0_0_4/store.wasm and b/runtime/test/wasm_test/api_version_0_0_4/store.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_4/test_padding.wasm b/runtime/test/wasm_test/api_version_0_0_4/test_padding.wasm
index af72b0f0384..85a46503635 100644
Binary files a/runtime/test/wasm_test/api_version_0_0_4/test_padding.wasm and b/runtime/test/wasm_test/api_version_0_0_4/test_padding.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_4/yaml_parsing.ts b/runtime/test/wasm_test/api_version_0_0_4/yaml_parsing.ts
new file mode 100644
index 00000000000..b3efc9ba205
--- /dev/null
+++ b/runtime/test/wasm_test/api_version_0_0_4/yaml_parsing.ts
@@ -0,0 +1,20 @@
+import "allocator/arena";
+
+import {Bytes, Result} from "../api_version_0_0_5/common/types";
+import {debug, YAMLValue} from "../api_version_0_0_5/common/yaml";
+
+export {memory};
+
+declare namespace yaml {
+    function try_fromBytes(data: Bytes): Result<YAMLValue, boolean>;
+}
+
+export function handleYaml(data: Bytes): string {
+    let result = yaml.try_fromBytes(data);
+
+    if (result.isError) {
+        return "error";
+    }
+
+    return debug(result.value);
+}
diff --git a/runtime/test/wasm_test/api_version_0_0_4/yaml_parsing.wasm b/runtime/test/wasm_test/api_version_0_0_4/yaml_parsing.wasm
new file mode 100644
index 00000000000..cb132344ce3
Binary files /dev/null and b/runtime/test/wasm_test/api_version_0_0_4/yaml_parsing.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_5/abi_classes.wasm b/runtime/test/wasm_test/api_version_0_0_5/abi_classes.wasm
index 8a29ed1866e..56f95d23f98 100644
Binary files a/runtime/test/wasm_test/api_version_0_0_5/abi_classes.wasm and b/runtime/test/wasm_test/api_version_0_0_5/abi_classes.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_5/abi_store_value.ts b/runtime/test/wasm_test/api_version_0_0_5/abi_store_value.ts
index 25c96b5b741..2838358ce7d 100644
--- a/runtime/test/wasm_test/api_version_0_0_5/abi_store_value.ts
+++ b/runtime/test/wasm_test/api_version_0_0_5/abi_store_value.ts
@@ -22,6 +22,12 @@ export function value_from_int8(int: i64): Value {
     return value
 }
 
+export function value_from_timestamp(ts: i64): Value {
+    let value = new Value();
+    value.kind = ValueKind.TIMESTAMP;
+    value.data = ts as i64
+    return value
+}
 
 export function value_from_big_decimal(float: BigInt): Value {
     let value = new Value();
diff --git a/runtime/test/wasm_test/api_version_0_0_5/abi_store_value.wasm b/runtime/test/wasm_test/api_version_0_0_5/abi_store_value.wasm
index 69e3621f090..8a9ccfa0fc8 100644
Binary files a/runtime/test/wasm_test/api_version_0_0_5/abi_store_value.wasm and b/runtime/test/wasm_test/api_version_0_0_5/abi_store_value.wasm differ
diff --git a/runtime/test/wasm_test/api_version_0_0_5/common/types.ts b/runtime/test/wasm_test/api_version_0_0_5/common/types.ts
index ab1acadf0a6..a60ddfdd99b 100644
--- a/runtime/test/wasm_test/api_version_0_0_5/common/types.ts
+++ b/runtime/test/wasm_test/api_version_0_0_5/common/types.ts
@@ -30,7 +30,8 @@ export enum ValueKind {
   NULL = 5,
   BYTES = 6,
   BIG_INT = 7,
-  INT8 = 8
+  INT8 = 8,
+  TIMESTAMP = 9
 }
 // Big enough to fit any pointer or native `this.data`.
 export type Payload = u64
diff --git a/runtime/test/wasm_test/api_version_0_0_5/common/yaml.ts b/runtime/test/wasm_test/api_version_0_0_5/common/yaml.ts
new file mode 100644
index 00000000000..135635475f1
--- /dev/null
+++ b/runtime/test/wasm_test/api_version_0_0_5/common/yaml.ts
@@ -0,0 +1,139 @@
+import {TypedMap} from './types';
+
+export enum YAMLValueKind {
+    NULL = 0,
+    BOOL = 1,
+    NUMBER = 2,
+    STRING = 3,
+    ARRAY = 4,
+    OBJECT = 5,
+    TAGGED = 6,
+}
+
+export class YAMLValue {
+    kind: YAMLValueKind;
+    data: u64;
+
+    isBool(): boolean {
+        return this.kind == YAMLValueKind.BOOL;
+    }
+
+    isNumber(): boolean {
+        return this.kind == YAMLValueKind.NUMBER;
+    }
+
+    isString(): boolean {
+        return this.kind == YAMLValueKind.STRING;
+    }
+
+    isArray(): boolean {
+        return this.kind == YAMLValueKind.ARRAY;
+    }
+
+    isObject(): boolean {
+        return this.kind == YAMLValueKind.OBJECT;
+    }
+
+    isTagged(): boolean {
+        return this.kind == YAMLValueKind.TAGGED;
+    }
+
+
+    toBool(): boolean {
+        assert(this.isBool(), 'YAML value is not a boolean');
+        return this.data != 0;
+    }
+
+    toNumber(): string {
+        assert(this.isNumber(), 'YAML value is not a number');
+        return changetype<string>(this.data as usize);
+    }
+
+    toString(): string {
+        assert(this.isString(), 'YAML value is not a string');
+        return changetype<string>(this.data as usize);
+    }
+
+    toArray(): Array<YAMLValue> {
+        assert(this.isArray(), 'YAML value is not an array');
+        return changetype<Array<YAMLValue>>(this.data as usize);
+    }
+
+    toObject(): TypedMap<YAMLValue, YAMLValue> {
+        assert(this.isObject(), 'YAML value is not an object');
+        return changetype<TypedMap<YAMLValue, YAMLValue>>(this.data as usize);
+    }
+
+    toTagged(): YAMLTaggedValue {
+        assert(this.isTagged(), 'YAML value is not tagged');
+        return changetype<YAMLTaggedValue>(this.data as usize);
+    }
+}
+
+export class YAMLTaggedValue {
+    tag: string;
+    value: YAMLValue;
+}
+
+
+export function debug(value: YAMLValue): string {
+    return "(" + value.kind.toString() + ") " + debug_value(value);
+}
+
+function debug_value(value: YAMLValue): string {
+    switch (value.kind) {
+        case YAMLValueKind.NULL:
+            return "null";
+        case YAMLValueKind.BOOL:
+            return value.toBool() ? "true" : "false";
+        case YAMLValueKind.NUMBER:
+            return value.toNumber();
+        case YAMLValueKind.STRING:
+            return value.toString();
+        case YAMLValueKind.ARRAY: {
+            let arr = value.toArray();
+
+            let s = "[";
+            for (let i = 0; i < arr.length; i++) {
+                if (i > 0) {
+                    s += ", ";
+                }
+                s += debug(arr[i]);
+            }
+            s += "]";
+
+            return s;
+        }
+        case YAMLValueKind.OBJECT: {
+            let arr = value.toObject().entries.sort((a, b) => {
+                if (a.key.toString() < b.key.toString()) {
+                    return -1;
+                }
+
+                if (a.key.toString() > b.key.toString()) {
+                    return 1;
+                }
+
+                return 0;
+            });
+
+            let s = "{";
+            for (let i = 0; i < arr.length; i++) {
+                if (i > 0) {
+                    s += ", ";
+                }
+                s += debug_value(arr[i].key) + ": " + debug(arr[i].value);
+            }
+            s += "}";
+
+            return s;
+        }
+        case YAMLValueKind.TAGGED: {
+            let tagged = value.toTagged();
+
+            return tagged.tag + " " + debug(tagged.value);
+        }
+        default:
+            return "undefined";
+    }
+}
diff --git a/runtime/test/wasm_test/api_version_0_0_5/yaml_parsing.ts b/runtime/test/wasm_test/api_version_0_0_5/yaml_parsing.ts
new file mode 100644
index 00000000000..c89eb611bb2
--- /dev/null
+++ b/runtime/test/wasm_test/api_version_0_0_5/yaml_parsing.ts
@@ -0,0 +1,62 @@
+import {debug, YAMLValue, YAMLTaggedValue} from './common/yaml';
+import {Bytes, Result, TypedMap, TypedMapEntry, Wrapped} from './common/types';
+
+enum TypeId {
+    STRING = 0,
+    UINT8_ARRAY = 6,
+
+    YamlValue = 5500,
+    YamlTaggedValue = 5501,
+    YamlTypedMapEntryValueValue = 5502,
+    YamlTypedMapValueValue = 5503,
+    YamlArrayValue = 5504,
+    YamlArrayTypedMapEntryValueValue = 5505,
+    YamlWrappedValue = 5506,
+    YamlResultValueBool = 5507,
+}
+
+export function id_of_type(type_id_index: TypeId): usize {
+    switch (type_id_index) {
+        case TypeId.STRING:
+            return idof<string>();
+        case TypeId.UINT8_ARRAY:
+            return idof<Uint8Array>();
+
+        case TypeId.YamlValue:
+            return idof<YAMLValue>();
+        case TypeId.YamlTaggedValue:
+            return idof<YAMLTaggedValue>();
+        case TypeId.YamlTypedMapEntryValueValue:
+            return idof<TypedMapEntry<YAMLValue, YAMLValue>>();
+        case TypeId.YamlTypedMapValueValue:
+            return idof<TypedMap<YAMLValue, YAMLValue>>();
+        case TypeId.YamlArrayValue:
+            return idof<Array<YAMLValue>>();
+        case TypeId.YamlArrayTypedMapEntryValueValue:
+            return idof<Array<TypedMapEntry<YAMLValue, YAMLValue>>>();
+        case TypeId.YamlWrappedValue:
+            return idof<Wrapped<YAMLValue>>();
+        case TypeId.YamlResultValueBool:
+            return idof<Result<YAMLValue, boolean>>();
+        default:
+            return 0;
+    }
+}
+
+export function allocate(n: usize): usize {
+    return __alloc(n);
+}
+
+declare namespace yaml {
+    function try_fromBytes(data: Bytes): Result<YAMLValue, boolean>;
+}
+
+export function handleYaml(data: Bytes): string {
+    let result = yaml.try_fromBytes(data);
+
+    if (result.isError) {
+        return "error";
+    }
+
+    return debug(result.value);
+}
diff --git a/runtime/test/wasm_test/api_version_0_0_5/yaml_parsing.wasm b/runtime/test/wasm_test/api_version_0_0_5/yaml_parsing.wasm
new file mode 100644
index 00000000000..131ded5d04c
Binary files /dev/null and b/runtime/test/wasm_test/api_version_0_0_5/yaml_parsing.wasm differ
diff --git a/runtime/wasm/Cargo.toml b/runtime/wasm/Cargo.toml
index b33cf071487..abf96ddc0ff 100644
--- a/runtime/wasm/Cargo.toml
+++ b/runtime/wasm/Cargo.toml
@@ -4,26 +4,22 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-async-trait = "0.1.50"
-atomic_refcell = "0.1.13"
-ethabi = "17.2"
-futures = "0.1.21"
+async-trait = { workspace = true }
 hex = "0.4.3"
 graph = { path = "../../graph" }
 bs58 = "0.4.0"
 graph-runtime-derive = { path = "../derive" }
-semver = "1.0.21"
-lazy_static = "1.4"
-uuid = { version = "1.6.1", features = ["v4"] }
-strum = "0.21.0"
-strum_macros = "0.25.3"
-bytes = "1.0"
-anyhow = "1.0"
-wasmtime = "0.27.0"
-defer = "0.1"
+semver = { workspace = true }
+anyhow = { workspace = true }
 never = "0.1"
 
-wasm-instrument = { version = "0.2.0", features = ["std", "sign_ext"] }
+wasmtime.workspace = true
+wasm-instrument = { version = "0.4.0", features = ["std", "sign_ext"] }
 
 # AssemblyScript uses sign extensions
 parity-wasm = { version = "0.45", features = ["std", "sign_ext"] }
+
+serde_yaml = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/runtime/wasm/src/asc_abi/class.rs b/runtime/wasm/src/asc_abi/class.rs
index 7da371e9d34..ac3256661b2 100644
--- a/runtime/wasm/src/asc_abi/class.rs
+++ b/runtime/wasm/src/asc_abi/class.rs
@@ -1,11 +1,15 @@
-use ethabi;
-use semver::Version;
-
+//! Rust types that have with a direct correspondence to an Asc class,
+//! with their `AscType` implementations.
+use async_trait::async_trait;
+use graph::abi;
 use graph::{
-    data::store,
+    data::{
+        store::{self, scalar::Timestamp},
+        subgraph::API_VERSION_0_0_4,
+    },
     runtime::{
-        gas::GasCounter, AscHeap, AscIndexId, AscType, AscValue, HostExportError,
-        IndexForAscTypeId, ToAscObj,
+        AscHeap, AscIndexId, AscType, AscValue, HostExportError, IndexForAscTypeId, ToAscObj,
+        gas::GasCounter,
     },
 };
 use graph::{prelude::serde_json, runtime::DeterministicHostError};
@@ -13,9 +17,7 @@ use graph::{prelude::slog, runtime::AscPtr};
 use graph_runtime_derive::AscType;
 
 use crate::asc_abi::{v0_0_4, v0_0_5};
-
-///! Rust types that have with a direct correspondence to an Asc class,
-///! with their `AscType` implementations.
+use semver::Version;
 
 /// Wrapper of ArrayBuffer for multiple AssemblyScript versions.
 /// It just delegates its method calls to the correct mappings apiVersion.
@@ -27,10 +29,10 @@ pub enum ArrayBuffer {
 impl ArrayBuffer {
     pub(crate) fn new<T: AscType>(
         values: &[T],
-        api_version: Version,
+        api_version: &Version,
     ) -> Result<Self, DeterministicHostError> {
         match api_version {
-            version if version <= Version::new(0, 0, 4) => {
+            version if version <= &API_VERSION_0_0_4 => {
                 Ok(Self::ApiVersion0_0_4(v0_0_4::ArrayBuffer::new(values)?))
             }
             _ => Ok(Self::ApiVersion0_0_5(v0_0_5::ArrayBuffer::new(values)?)),
@@ -89,18 +91,18 @@ pub enum TypedArray<T> {
 }
 
 impl<T: AscValue> TypedArray<T> {
-    pub fn new<H: AscHeap + ?Sized>(
+    pub async fn new<H: AscHeap + ?Sized>(
         content: &[T],
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<Self, HostExportError> {
         match heap.api_version() {
-            version if version <= Version::new(0, 0, 4) => Ok(Self::ApiVersion0_0_4(
-                v0_0_4::TypedArray::new(content, heap, gas)?,
+            version if version <= &API_VERSION_0_0_4 => Ok(Self::ApiVersion0_0_4(
+                v0_0_4::TypedArray::new(content, heap, gas).await?,
+            )),
+            _ => Ok(Self::ApiVersion0_0_5(
+                v0_0_5::TypedArray::new(content, heap, gas).await?,
             )),
-            _ => Ok(Self::ApiVersion0_0_5(v0_0_5::TypedArray::new(
-                content, heap, gas,
-            )?)),
         }
     }
 
@@ -143,13 +145,14 @@ impl<T> AscType for TypedArray<T> {
 pub struct Bytes<'a>(pub &'a Vec<u8>);
 
 pub type Uint8Array = TypedArray<u8>;
+#[async_trait]
 impl ToAscObj<Uint8Array> for Bytes<'_> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + Send + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<Uint8Array, HostExportError> {
-        self.0.to_asc_obj(heap, gas)
+        self.0.to_asc_obj(heap, gas).await
     }
 }
 
@@ -201,9 +204,9 @@ pub enum AscString {
 }
 
 impl AscString {
-    pub fn new(content: &[u16], api_version: Version) -> Result<Self, DeterministicHostError> {
+    pub fn new(content: &[u16], api_version: &Version) -> Result<Self, DeterministicHostError> {
         match api_version {
-            version if version <= Version::new(0, 0, 4) => {
+            version if version <= &API_VERSION_0_0_4 => {
                 Ok(Self::ApiVersion0_0_4(v0_0_4::AscString::new(content)?))
             }
             _ => Ok(Self::ApiVersion0_0_5(v0_0_5::AscString::new(content)?)),
@@ -269,18 +272,18 @@ pub enum Array<T> {
 }
 
 impl<T: AscValue> Array<T> {
-    pub fn new<H: AscHeap + ?Sized>(
+    pub async fn new<H: AscHeap + ?Sized>(
         content: &[T],
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<Self, HostExportError> {
         match heap.api_version() {
-            version if version <= Version::new(0, 0, 4) => Ok(Self::ApiVersion0_0_4(
-                v0_0_4::Array::new(content, heap, gas)?,
+            version if version <= &API_VERSION_0_0_4 => Ok(Self::ApiVersion0_0_4(
+                v0_0_4::Array::new(content, heap, gas).await?,
+            )),
+            _ => Ok(Self::ApiVersion0_0_5(
+                v0_0_5::Array::new(content, heap, gas).await?,
             )),
-            _ => Ok(Self::ApiVersion0_0_5(v0_0_5::Array::new(
-                content, heap, gas,
-            )?)),
         }
     }
 
@@ -398,6 +401,17 @@ impl AscIndexId for Array<AscPtr<AscBigDecimal>> {
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArrayBigDecimal;
 }
 
+impl AscIndexId for Array<AscPtr<AscEnum<YamlValueKind>>> {
+    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::YamlArrayValue;
+}
+
+impl AscIndexId
+    for Array<AscPtr<AscTypedMapEntry<AscEnum<YamlValueKind>, AscEnum<YamlValueKind>>>>
+{
+    const INDEX_ASC_TYPE_ID: IndexForAscTypeId =
+        IndexForAscTypeId::YamlArrayTypedMapEntryValueValue;
+}
+
 /// Represents any `AscValue` since they all fit in 64 bits.
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
@@ -464,6 +478,12 @@ impl From<i64> for EnumPayload {
     }
 }
 
+impl From<&Timestamp> for EnumPayload {
+    fn from(x: &Timestamp) -> EnumPayload {
+        EnumPayload::from(x.as_microseconds_since_epoch())
+    }
+}
+
 impl<C> From<EnumPayload> for AscPtr<C> {
     fn from(payload: EnumPayload) -> Self {
         AscPtr::new(payload.0 as u32)
@@ -499,11 +519,16 @@ impl AscIndexId for AscEnum<JsonValueKind> {
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::JsonValue;
 }
 
+impl AscIndexId for AscEnum<YamlValueKind> {
+    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::YamlValue;
+}
+
 pub type AscEnumArray<D> = AscPtr<Array<AscPtr<AscEnum<D>>>>;
 
 #[repr(u32)]
-#[derive(AscType, Copy, Clone)]
+#[derive(AscType, Copy, Clone, Default)]
 pub enum EthereumValueKind {
+    #[default]
     Address,
     FixedBytes,
     Bytes,
@@ -514,45 +539,45 @@ pub enum EthereumValueKind {
     FixedArray,
     Array,
     Tuple,
+    Function,
 }
 
 impl EthereumValueKind {
-    pub(crate) fn get_kind(token: &ethabi::Token) -> Self {
-        match token {
-            ethabi::Token::Address(_) => EthereumValueKind::Address,
-            ethabi::Token::FixedBytes(_) => EthereumValueKind::FixedBytes,
-            ethabi::Token::Bytes(_) => EthereumValueKind::Bytes,
-            ethabi::Token::Int(_) => EthereumValueKind::Int,
-            ethabi::Token::Uint(_) => EthereumValueKind::Uint,
-            ethabi::Token::Bool(_) => EthereumValueKind::Bool,
-            ethabi::Token::String(_) => EthereumValueKind::String,
-            ethabi::Token::FixedArray(_) => EthereumValueKind::FixedArray,
-            ethabi::Token::Array(_) => EthereumValueKind::Array,
-            ethabi::Token::Tuple(_) => EthereumValueKind::Tuple,
-        }
-    }
-}
+    pub(crate) fn get_kind(value: &abi::DynSolValue) -> Self {
+        use graph::abi::DynSolValue;
 
-impl Default for EthereumValueKind {
-    fn default() -> Self {
-        EthereumValueKind::Address
+        match value {
+            DynSolValue::Bool(_) => Self::Bool,
+            DynSolValue::Int(_, _) => Self::Int,
+            DynSolValue::Uint(_, _) => Self::Uint,
+            DynSolValue::FixedBytes(_, _) => Self::FixedBytes,
+            DynSolValue::Address(_) => Self::Address,
+            DynSolValue::Function(_) => Self::Function,
+            DynSolValue::Bytes(_) => Self::Bytes,
+            DynSolValue::String(_) => Self::String,
+            DynSolValue::Array(_) => Self::Array,
+            DynSolValue::FixedArray(_) => Self::FixedArray,
+            DynSolValue::Tuple(_) => Self::Tuple,
+        }
     }
 }
 
 impl AscValue for EthereumValueKind {}
 
 #[repr(u32)]
-#[derive(AscType, Copy, Clone)]
+#[derive(AscType, Copy, Clone, Default)]
 pub enum StoreValueKind {
     String,
     Int,
     BigDecimal,
     Bool,
     Array,
+    #[default]
     Null,
     Bytes,
     BigInt,
     Int8,
+    Timestamp,
 }
 
 impl StoreValueKind {
@@ -563,6 +588,7 @@ impl StoreValueKind {
             Value::String(_) => StoreValueKind::String,
             Value::Int(_) => StoreValueKind::Int,
             Value::Int8(_) => StoreValueKind::Int8,
+            Value::Timestamp(_) => StoreValueKind::Timestamp,
             Value::BigDecimal(_) => StoreValueKind::BigDecimal,
             Value::Bool(_) => StoreValueKind::Bool,
             Value::List(_) => StoreValueKind::Array,
@@ -573,12 +599,6 @@ impl StoreValueKind {
     }
 }
 
-impl Default for StoreValueKind {
-    fn default() -> Self {
-        StoreValueKind::Null
-    }
-}
-
 impl AscValue for StoreValueKind {}
 
 /// Big ints are represented using signed number representation. Note: This differs
@@ -605,6 +625,10 @@ impl AscIndexId for AscTypedMapEntry<AscString, AscEnum<JsonValueKind>> {
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::TypedMapEntryStringJsonValue;
 }
 
+impl AscIndexId for AscTypedMapEntry<AscEnum<YamlValueKind>, AscEnum<YamlValueKind>> {
+    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::YamlTypedMapEntryValueValue;
+}
+
 pub(crate) type AscTypedMapEntryArray<K, V> = Array<AscPtr<AscTypedMapEntry<K, V>>>;
 
 #[repr(C)]
@@ -630,12 +654,17 @@ impl AscIndexId for AscTypedMap<AscString, AscTypedMap<AscString, AscEnum<JsonVa
         IndexForAscTypeId::TypedMapStringTypedMapStringJsonValue;
 }
 
+impl AscIndexId for AscTypedMap<AscEnum<YamlValueKind>, AscEnum<YamlValueKind>> {
+    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::YamlTypedMapValueValue;
+}
+
 pub type AscEntity = AscTypedMap<AscString, AscEnum<StoreValueKind>>;
 pub(crate) type AscJson = AscTypedMap<AscString, AscEnum<JsonValueKind>>;
 
 #[repr(u32)]
-#[derive(AscType, Copy, Clone)]
+#[derive(AscType, Copy, Clone, Default)]
 pub enum JsonValueKind {
+    #[default]
     Null,
     Bool,
     Number,
@@ -644,12 +673,6 @@ pub enum JsonValueKind {
     Object,
 }
 
-impl Default for JsonValueKind {
-    fn default() -> Self {
-        JsonValueKind::Null
-    }
-}
-
 impl AscValue for JsonValueKind {}
 
 impl JsonValueKind {
@@ -717,6 +740,10 @@ impl AscIndexId for AscResult<AscPtr<AscEnum<JsonValueKind>>, bool> {
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ResultJsonValueBool;
 }
 
+impl AscIndexId for AscResult<AscPtr<AscEnum<YamlValueKind>>, bool> {
+    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::YamlResultValueBool;
+}
+
 #[repr(C)]
 #[derive(AscType, Copy, Clone)]
 pub struct AscWrapped<V: AscValue> {
@@ -734,3 +761,49 @@ impl AscIndexId for AscWrapped<bool> {
 impl AscIndexId for AscWrapped<AscPtr<AscEnum<JsonValueKind>>> {
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::WrappedJsonValue;
 }
+
+impl AscIndexId for AscWrapped<AscPtr<AscEnum<YamlValueKind>>> {
+    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::YamlWrappedValue;
+}
+
+#[repr(u32)]
+#[derive(AscType, Clone, Copy, Default)]
+pub enum YamlValueKind {
+    #[default]
+    Null,
+    Bool,
+    Number,
+    String,
+    Array,
+    Object,
+    Tagged,
+}
+
+impl AscValue for YamlValueKind {}
+
+impl YamlValueKind {
+    pub(crate) fn get_kind(value: &serde_yaml::Value) -> Self {
+        use serde_yaml::Value;
+
+        match value {
+            Value::Null => Self::Null,
+            Value::Bool(_) => Self::Bool,
+            Value::Number(_) => Self::Number,
+            Value::String(_) => Self::String,
+            Value::Sequence(_) => Self::Array,
+            Value::Mapping(_) => Self::Object,
+            Value::Tagged(_) => Self::Tagged,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(AscType)]
+pub struct AscYamlTaggedValue {
+    pub tag: AscPtr<AscString>,
+    pub value: AscPtr<AscEnum<YamlValueKind>>,
+}
+
+impl AscIndexId for AscYamlTaggedValue {
+    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::YamlTaggedValue;
+}
diff --git a/runtime/wasm/src/asc_abi/v0_0_4.rs b/runtime/wasm/src/asc_abi/v0_0_4.rs
index 39123f96efd..3eb796434e6 100644
--- a/runtime/wasm/src/asc_abi/v0_0_4.rs
+++ b/runtime/wasm/src/asc_abi/v0_0_4.rs
@@ -12,7 +12,7 @@ use graph_runtime_derive::AscType;
 use crate::asc_abi::class;
 
 /// Module related to AssemblyScript version v0.6.
-
+///
 /// Asc std ArrayBuffer: "a generic, fixed-length raw binary data buffer".
 /// See https://github.com/AssemblyScript/assemblyscript/wiki/Memory-Layout-&-Management/86447e88be5aa8ec633eaf5fe364651136d136ab#arrays
 pub struct ArrayBuffer {
@@ -35,7 +35,7 @@ impl ArrayBuffer {
             content.extend(&asc_bytes);
         }
 
-        if content.len() > u32::max_value() as usize {
+        if content.len() > u32::MAX as usize {
             return Err(DeterministicHostError::from(anyhow::anyhow!(
                 "slice cannot fit in WASM memory"
             )));
@@ -54,7 +54,7 @@ impl ArrayBuffer {
         &self,
         byte_offset: u32,
         length: u32,
-        api_version: Version,
+        api_version: &Version,
     ) -> Result<Vec<T>, DeterministicHostError> {
         let length = length as usize;
         let byte_offset = byte_offset as usize;
@@ -62,7 +62,7 @@ impl ArrayBuffer {
         self.content[byte_offset..]
             .chunks(size_of::<T>())
             .take(length)
-            .map(|asc_obj| T::from_asc_bytes(asc_obj, &api_version))
+            .map(|asc_obj| T::from_asc_bytes(asc_obj, api_version))
             .collect()
 
         // TODO: This code is preferred as it validates the length of the array.
@@ -96,7 +96,7 @@ impl AscType for ArrayBuffer {
         let total_size = self.byte_length as usize + header_size;
         let total_capacity = total_size.next_power_of_two();
         let extra_capacity = total_capacity - total_size;
-        asc_layout.extend(std::iter::repeat(0).take(extra_capacity));
+        asc_layout.extend(std::iter::repeat_n(0, extra_capacity));
         assert_eq!(asc_layout.len(), total_capacity);
 
         Ok(asc_layout)
@@ -149,7 +149,7 @@ pub struct TypedArray<T> {
 }
 
 impl<T: AscValue> TypedArray<T> {
-    pub(crate) fn new<H: AscHeap + ?Sized>(
+    pub(crate) async fn new<H: AscHeap + ?Sized>(
         content: &[T],
         heap: &mut H,
         gas: &GasCounter,
@@ -160,7 +160,7 @@ impl<T: AscValue> TypedArray<T> {
         } else {
             unreachable!("Only the correct ArrayBuffer will be constructed")
         };
-        let ptr = AscPtr::alloc_obj(buffer, heap, gas)?;
+        let ptr = AscPtr::alloc_obj(buffer, heap, gas).await?;
         Ok(TypedArray {
             byte_length: buffer_byte_length,
             buffer: AscPtr::new(ptr.wasm_ptr()),
@@ -194,7 +194,7 @@ pub struct AscString {
 
 impl AscString {
     pub fn new(content: &[u16]) -> Result<Self, DeterministicHostError> {
-        if size_of_val(content) > u32::max_value() as usize {
+        if size_of_val(content) > u32::MAX as usize {
             return Err(DeterministicHostError::from(anyhow!(
                 "string cannot fit in WASM memory"
             )));
@@ -249,7 +249,7 @@ impl AscType for AscString {
         }
 
         // Prevents panic when accessing offset + 1 in the loop
-        if asc_obj.len() % 2 != 0 {
+        if !asc_obj.len().is_multiple_of(2) {
             return Err(DeterministicHostError::from(anyhow::anyhow!(
                 "Invalid string length"
             )));
@@ -303,13 +303,13 @@ pub struct Array<T> {
 }
 
 impl<T: AscValue> Array<T> {
-    pub fn new<H: AscHeap + ?Sized>(
+    pub async fn new<H: AscHeap + ?Sized>(
         content: &[T],
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<Self, HostExportError> {
         let arr_buffer = class::ArrayBuffer::new(content, heap.api_version())?;
-        let arr_buffer_ptr = AscPtr::alloc_obj(arr_buffer, heap, gas)?;
+        let arr_buffer_ptr = AscPtr::alloc_obj(arr_buffer, heap, gas).await?;
         Ok(Array {
             buffer: AscPtr::new(arr_buffer_ptr.wasm_ptr()),
             // If this cast would overflow, the above line has already panicked.
diff --git a/runtime/wasm/src/asc_abi/v0_0_5.rs b/runtime/wasm/src/asc_abi/v0_0_5.rs
index 183aad0f2a6..c09ce7a167f 100644
--- a/runtime/wasm/src/asc_abi/v0_0_5.rs
+++ b/runtime/wasm/src/asc_abi/v0_0_5.rs
@@ -2,13 +2,13 @@ use std::marker::PhantomData;
 use std::mem::{size_of, size_of_val};
 
 use anyhow::anyhow;
+use graph_runtime_derive::AscType;
 use semver::Version;
 
 use graph::runtime::gas::GasCounter;
 use graph::runtime::{
-    AscHeap, AscPtr, AscType, AscValue, DeterministicHostError, HostExportError, HEADER_SIZE,
+    AscHeap, AscPtr, AscType, AscValue, DeterministicHostError, HEADER_SIZE, HostExportError,
 };
-use graph_runtime_derive::AscType;
 
 use crate::asc_abi::class;
 
@@ -16,7 +16,7 @@ use crate::asc_abi::class;
 /// All `to_asc_bytes`/`from_asc_bytes` only consider the #data/content/payload
 /// not the #header, that's handled on `AscPtr`.
 /// Header in question: https://www.assemblyscript.org/memory.html#common-header-layout
-
+///
 /// Similar as JS ArrayBuffer, "a generic, fixed-length raw binary data buffer".
 /// See https://www.assemblyscript.org/memory.html#arraybuffer-layout
 pub struct ArrayBuffer {
@@ -34,7 +34,7 @@ impl ArrayBuffer {
             content.extend(&asc_bytes);
         }
 
-        if content.len() > u32::max_value() as usize {
+        if content.len() > u32::MAX as usize {
             return Err(DeterministicHostError::from(anyhow::anyhow!(
                 "slice cannot fit in WASM memory"
             )));
@@ -52,7 +52,7 @@ impl ArrayBuffer {
         &self,
         byte_offset: u32,
         length: u32,
-        api_version: Version,
+        api_version: &Version,
     ) -> Result<Vec<T>, DeterministicHostError> {
         let length = length as usize;
         let byte_offset = byte_offset as usize;
@@ -60,7 +60,7 @@ impl ArrayBuffer {
         self.content[byte_offset..]
             .chunks(size_of::<T>())
             .take(length)
-            .map(|asc_obj| T::from_asc_bytes(asc_obj, &api_version))
+            .map(|asc_obj| T::from_asc_bytes(asc_obj, api_version))
             .collect()
     }
 }
@@ -75,7 +75,7 @@ impl AscType for ArrayBuffer {
         let total_size = self.byte_length as usize + HEADER_SIZE;
         let total_capacity = total_size.next_power_of_two();
         let extra_capacity = total_capacity - total_size;
-        asc_layout.extend(std::iter::repeat(0).take(extra_capacity));
+        asc_layout.extend(std::iter::repeat_n(0, extra_capacity));
 
         Ok(asc_layout)
     }
@@ -114,14 +114,14 @@ pub struct TypedArray<T> {
 }
 
 impl<T: AscValue> TypedArray<T> {
-    pub(crate) fn new<H: AscHeap + ?Sized>(
+    pub(crate) async fn new<H: AscHeap + ?Sized>(
         content: &[T],
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<Self, HostExportError> {
         let buffer = class::ArrayBuffer::new(content, heap.api_version())?;
         let byte_length = content.len() as u32;
-        let ptr = AscPtr::alloc_obj(buffer, heap, gas)?;
+        let ptr = AscPtr::alloc_obj(buffer, heap, gas).await?;
         Ok(TypedArray {
             buffer: AscPtr::new(ptr.wasm_ptr()), // new AscPtr necessary to convert type parameter
             data_start: ptr.wasm_ptr(),
@@ -176,7 +176,7 @@ pub struct AscString {
 
 impl AscString {
     pub fn new(content: &[u16]) -> Result<Self, DeterministicHostError> {
-        if size_of_val(content) > u32::max_value() as usize {
+        if size_of_val(content) > u32::MAX as usize {
             return Err(DeterministicHostError::from(anyhow!(
                 "string cannot fit in WASM memory"
             )));
@@ -205,7 +205,7 @@ impl AscType for AscString {
         let total_size = (self.byte_length as usize * 2) + header_size;
         let total_capacity = total_size.next_power_of_two();
         let extra_capacity = total_capacity - total_size;
-        content.extend(std::iter::repeat(0).take(extra_capacity));
+        content.extend(std::iter::repeat_n(0, extra_capacity));
 
         Ok(content)
     }
@@ -264,13 +264,13 @@ pub struct Array<T> {
 }
 
 impl<T: AscValue> Array<T> {
-    pub fn new<H: AscHeap + ?Sized>(
+    pub async fn new<H: AscHeap + ?Sized>(
         content: &[T],
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<Self, HostExportError> {
         let arr_buffer = class::ArrayBuffer::new(content, heap.api_version())?;
-        let buffer = AscPtr::alloc_obj(arr_buffer, heap, gas)?;
+        let buffer = AscPtr::alloc_obj(arr_buffer, heap, gas).await?;
         let buffer_data_length = buffer.read_len(heap, gas)?;
         Ok(Array {
             buffer: AscPtr::new(buffer.wasm_ptr()),
diff --git a/runtime/wasm/src/error.rs b/runtime/wasm/src/error.rs
index e3852b3130e..50e87acbc67 100644
--- a/runtime/wasm/src/error.rs
+++ b/runtime/wasm/src/error.rs
@@ -1,5 +1,3 @@
-use wasmtime::Trap;
-
 use graph::runtime::DeterministicHostError;
 
 use crate::module::IntoTrap;
@@ -11,7 +9,6 @@ pub enum DeterminismLevel {
     Deterministic,
 
     /// This error is known to be non-deterministic. For example, an intermittent http failure.
-    #[allow(dead_code)]
     NonDeterministic,
 
     /// The runtime is processing a given block, but there is an indication that the blockchain client
@@ -27,7 +24,4 @@ impl IntoTrap for DeterministicHostError {
     fn determinism_level(&self) -> DeterminismLevel {
         DeterminismLevel::Deterministic
     }
-    fn into_trap(self) -> Trap {
-        Trap::from(self.inner())
-    }
 }
diff --git a/runtime/wasm/src/gas_rules.rs b/runtime/wasm/src/gas_rules.rs
index 10717f92542..7a375f9e346 100644
--- a/runtime/wasm/src/gas_rules.rs
+++ b/runtime/wasm/src/gas_rules.rs
@@ -165,4 +165,8 @@ impl Rules for GasRules {
 
         MemoryGrowCost::Linear(gas_per_page)
     }
+
+    fn call_per_local_cost(&self) -> u32 {
+        0
+    }
 }
diff --git a/runtime/wasm/src/host.rs b/runtime/wasm/src/host.rs
index 5413f9d6193..77b03594a5e 100644
--- a/runtime/wasm/src/host.rs
+++ b/runtime/wasm/src/host.rs
@@ -2,15 +2,17 @@ use std::cmp::PartialEq;
 use std::time::Instant;
 
 use async_trait::async_trait;
-use futures::sync::mpsc::Sender;
-use futures03::channel::oneshot::channel;
+use graph::futures01::sync::mpsc::Sender;
+use graph::futures03::channel::oneshot::channel;
 
-use graph::blockchain::{BlockTime, Blockchain, HostFn, RuntimeAdapter};
+use graph::blockchain::{Blockchain, HostFn, RuntimeAdapter};
 use graph::components::store::{EnsLookup, SubgraphFork};
 use graph::components::subgraph::{MappingError, SharedProofOfIndexing};
 use graph::data_source::{
     DataSource, DataSourceTemplate, MappingTrigger, TriggerData, TriggerWithHandler,
 };
+use graph::futures01::Sink as _;
+use graph::futures03::compat::Future01CompatExt;
 use graph::prelude::{
     RuntimeHost as RuntimeHostTrait, RuntimeHostBuilder as RuntimeHostBuilderTrait, *,
 };
@@ -20,6 +22,8 @@ use crate::module::ToAscPtr;
 use crate::{host_exports::HostExports, module::ExperimentalFeatures};
 use graph::runtime::gas::Gas;
 
+use super::host_exports::DataSourceDetails;
+
 pub struct RuntimeHostBuilder<C: Blockchain> {
     runtime_adapter: Arc<dyn RuntimeAdapter<C>>,
     link_resolver: Arc<dyn LinkResolver>,
@@ -104,7 +108,7 @@ pub struct RuntimeHost<C: Blockchain> {
     host_fns: Arc<Vec<HostFn>>,
     data_source: DataSource<C>,
     mapping_request_sender: Sender<WasmRequest<C>>,
-    host_exports: Arc<HostExports<C>>,
+    host_exports: Arc<HostExports>,
     metrics: Arc<HostMetrics>,
 }
 
@@ -123,22 +127,22 @@ where
         metrics: Arc<HostMetrics>,
         ens_lookup: Arc<dyn EnsLookup>,
     ) -> Result<Self, Error> {
+        let ds_details = DataSourceDetails::from_data_source(
+            &data_source,
+            Arc::new(templates.iter().map(|t| t.into()).collect()),
+        );
+
         // Create new instance of externally hosted functions invoker. The `Arc` is simply to avoid
         // implementing `Clone` for `HostExports`.
         let host_exports = Arc::new(HostExports::new(
             subgraph_id,
-            &data_source,
             network_name,
-            templates,
+            ds_details,
             link_resolver,
             ens_lookup,
         ));
 
-        let host_fns = data_source
-            .as_onchain()
-            .map(|ds| runtime_adapter.host_fns(ds))
-            .transpose()?
-            .unwrap_or_default();
+        let host_fns = runtime_adapter.host_fns(&data_source).unwrap_or_default();
 
         Ok(RuntimeHost {
             host_fns: Arc::new(host_fns),
@@ -154,12 +158,12 @@ where
     async fn send_mapping_request(
         &self,
         logger: &Logger,
-        state: BlockState<C>,
+        state: BlockState,
         trigger: TriggerWithHandler<MappingTrigger<C>>,
         proof_of_indexing: SharedProofOfIndexing,
         debug_fork: &Option<Arc<dyn SubgraphFork>>,
         instrument: bool,
-    ) -> Result<BlockState<C>, MappingError> {
+    ) -> Result<BlockState, MappingError> {
         let handler = trigger.handler_name().to_string();
 
         let extras = trigger.logging_extras();
@@ -186,7 +190,7 @@ where
                     proof_of_indexing,
                     host_fns: self.host_fns.cheap_clone(),
                     debug_fork: debug_fork.cheap_clone(),
-                    mapping_logger: Logger::new(&logger, o!("component" => "UserMapping")),
+                    mapping_logger: Logger::new(logger, o!("component" => "UserMapping")),
                     instrument,
                 },
                 trigger,
@@ -205,7 +209,7 @@ where
 
         // If there is an error, "gas_used" is incorrectly reported as 0.
         let gas_used = result.as_ref().map(|(_, gas)| gas).unwrap_or(&Gas::ZERO);
-        info!(
+        debug!(
             logger, "Done processing trigger";
             &extras,
             "total_ms" => elapsed.as_millis(),
@@ -217,74 +221,6 @@ where
         // Discard the gas value
         result.map(|(block_state, _)| block_state)
     }
-
-    async fn send_wasm_block_request(
-        &self,
-        logger: &Logger,
-        state: BlockState<C>,
-        block_ptr: BlockPtr,
-        timestamp: BlockTime,
-        block_data: Box<[u8]>,
-        handler: String,
-        proof_of_indexing: SharedProofOfIndexing,
-        debug_fork: &Option<Arc<dyn SubgraphFork>>,
-        instrument: bool,
-    ) -> Result<BlockState<C>, MappingError> {
-        trace!(
-            logger, "Start processing wasm block";
-            "block_ptr" => &block_ptr,
-            "handler" => &handler,
-            "data_source" => &self.data_source.name(),
-        );
-
-        let (result_sender, result_receiver) = channel();
-        let start_time = Instant::now();
-        let metrics = self.metrics.clone();
-
-        self.mapping_request_sender
-            .clone()
-            .send(WasmRequest::new_block(
-                MappingContext {
-                    logger: logger.cheap_clone(),
-                    state,
-                    host_exports: self.host_exports.cheap_clone(),
-                    block_ptr: block_ptr.clone(),
-                    timestamp,
-                    proof_of_indexing,
-                    host_fns: self.host_fns.cheap_clone(),
-                    debug_fork: debug_fork.cheap_clone(),
-                    mapping_logger: Logger::new(&logger, o!("component" => "UserBlockMapping")),
-                    instrument,
-                },
-                handler.clone(),
-                block_data,
-                result_sender,
-            ))
-            .compat()
-            .await
-            .context("Mapping terminated before passing in wasm block")?;
-
-        let result = result_receiver
-            .await
-            .context("Mapping terminated before handling block")?;
-
-        let elapsed = start_time.elapsed();
-        metrics.observe_handler_execution_time(elapsed.as_secs_f64(), &handler);
-
-        // If there is an error, "gas_used" is incorrectly reported as 0.
-        let gas_used = result.as_ref().map(|(_, gas)| gas).unwrap_or(&Gas::ZERO);
-        info!(
-            logger, "Done processing wasm block";
-            "block_ptr" => &block_ptr,
-            "total_ms" => elapsed.as_millis(),
-            "handler" => handler,
-            "data_source" => &self.data_source.name(),
-            "gas_used" => gas_used.to_string(),
-        );
-
-        // Discard the gas value
-        result.map(|(block_state, _)| block_state)
-    }
 }
 
 #[async_trait]
@@ -302,41 +238,15 @@ impl<C: Blockchain> RuntimeHostTrait<C> for RuntimeHost<C> {
         self.data_source.match_and_decode(trigger, block, logger)
     }
 
-    async fn process_block(
-        &self,
-        logger: &Logger,
-        block_ptr: BlockPtr,
-        block_time: BlockTime,
-        block_data: Box<[u8]>,
-        handler: String,
-        state: BlockState<C>,
-        proof_of_indexing: SharedProofOfIndexing,
-        debug_fork: &Option<Arc<dyn SubgraphFork>>,
-        instrument: bool,
-    ) -> Result<BlockState<C>, MappingError> {
-        self.send_wasm_block_request(
-            logger,
-            state,
-            block_ptr,
-            block_time,
-            block_data,
-            handler,
-            proof_of_indexing,
-            debug_fork,
-            instrument,
-        )
-        .await
-    }
-
     async fn process_mapping_trigger(
         &self,
         logger: &Logger,
         trigger: TriggerWithHandler<MappingTrigger<C>>,
-        state: BlockState<C>,
+        state: BlockState,
         proof_of_indexing: SharedProofOfIndexing,
         debug_fork: &Option<Arc<dyn SubgraphFork>>,
         instrument: bool,
-    ) -> Result<BlockState<C>, MappingError> {
+    ) -> Result<BlockState, MappingError> {
         self.send_mapping_request(
             logger,
             state,
@@ -358,6 +268,8 @@ impl<C: Blockchain> RuntimeHostTrait<C> for RuntimeHost<C> {
         match self.data_source() {
             DataSource::Onchain(_) => None,
             DataSource::Offchain(ds) => ds.done_at(),
+            DataSource::Subgraph(_) => None,
+            DataSource::Amp(_) => None,
         }
     }
 
@@ -365,8 +277,14 @@ impl<C: Blockchain> RuntimeHostTrait<C> for RuntimeHost<C> {
         match self.data_source() {
             DataSource::Onchain(_) => {}
             DataSource::Offchain(ds) => ds.set_done_at(block),
+            DataSource::Subgraph(_) => {}
+            DataSource::Amp(_) => {}
         }
     }
+
+    fn host_metrics(&self) -> Arc<HostMetrics> {
+        self.metrics.cheap_clone()
+    }
 }
 
 impl<C: Blockchain> PartialEq for RuntimeHost<C> {
diff --git a/runtime/wasm/src/host_exports.rs b/runtime/wasm/src/host_exports.rs
index eb94bda45f7..b6ab94a066f 100644
--- a/runtime/wasm/src/host_exports.rs
+++ b/runtime/wasm/src/host_exports.rs
@@ -1,47 +1,36 @@
-use std::borrow::Cow;
 use std::collections::HashMap;
-use std::ops::Deref;
 use std::str::FromStr;
 use std::time::{Duration, Instant};
 
 use graph::data::subgraph::API_VERSION_0_0_8;
 use graph::data::value::Word;
 
-use graph::schema::{EntityType, TypeKind};
+use graph::futures03::stream::StreamExt;
+use graph::prelude::alloy::primitives::Address;
+use graph::schema::EntityType;
 use never::Never;
 use semver::Version;
-use wasmtime::Trap;
-use web3::types::H160;
 
-use graph::blockchain::{BlockTime, Blockchain};
+use graph::abi;
+use graph::blockchain::BlockTime;
+use graph::blockchain::Blockchain;
+use graph::components::link_resolver::LinkResolverContext;
 use graph::components::store::{EnsLookup, GetScope, LoadRelatedRequest};
 use graph::components::subgraph::{
-    PoICausalityRegion, ProofOfIndexingEvent, SharedProofOfIndexing,
+    InstanceDSTemplate, PoICausalityRegion, ProofOfIndexingEvent, SharedProofOfIndexing,
 };
-use graph::data::store;
-use graph::data_source::{CausalityRegion, DataSource, DataSourceTemplate, EntityTypeAccess};
+use graph::data::store::{self};
+use graph::data_source::{CausalityRegion, DataSource, EntityTypeAccess};
 use graph::ensure;
-use graph::prelude::ethabi::param_type::Reader;
-use graph::prelude::ethabi::{decode, encode, Token};
 use graph::prelude::serde_json;
 use graph::prelude::{slog::b, slog::record_static, *};
-use graph::runtime::gas::{self, complexity, Gas, GasCounter};
+use graph::runtime::gas::{self, Gas, GasCounter, complexity};
 pub use graph::runtime::{DeterministicHostError, HostExportError};
 
-use crate::module::{WasmInstance, WasmInstanceContext};
+use crate::module::WasmInstance;
 use crate::{error::DeterminismLevel, module::IntoTrap};
 
-fn write_poi_event(
-    proof_of_indexing: &SharedProofOfIndexing,
-    poi_event: &ProofOfIndexingEvent,
-    causality_region: &str,
-    logger: &Logger,
-) {
-    if let Some(proof_of_indexing) = proof_of_indexing {
-        let mut proof_of_indexing = proof_of_indexing.deref().borrow_mut();
-        proof_of_indexing.write(logger, causality_region, poi_event);
-    }
-}
+use super::module::WasmInstanceData;
 
 impl IntoTrap for HostExportError {
     fn determinism_level(&self) -> DeterminismLevel {
@@ -51,71 +40,91 @@ impl IntoTrap for HostExportError {
             HostExportError::PossibleReorg(_) => DeterminismLevel::PossibleReorg,
         }
     }
-    fn into_trap(self) -> Trap {
-        match self {
-            HostExportError::Unknown(e)
-            | HostExportError::PossibleReorg(e)
-            | HostExportError::Deterministic(e) => Trap::from(e),
-        }
-    }
 }
 
-pub struct HostExports<C: Blockchain> {
+pub struct HostExports {
     pub(crate) subgraph_id: DeploymentHash,
-    pub api_version: Version,
-    data_source_name: String,
-    data_source_address: Vec<u8>,
     subgraph_network: String,
-    data_source_context: Arc<Option<DataSourceContext>>,
-    entity_type_access: EntityTypeAccess,
-    data_source_causality_region: CausalityRegion,
+    pub data_source: DataSourceDetails,
 
     /// Some data sources have indeterminism or different notions of time. These
     /// need to be each be stored separately to separate causality between them,
     /// and merge the results later. Right now, this is just the ethereum
     /// networks but will be expanded for ipfs and the availability chain.
     poi_causality_region: String,
-    templates: Arc<Vec<DataSourceTemplate<C>>>,
     pub(crate) link_resolver: Arc<dyn LinkResolver>,
     ens_lookup: Arc<dyn EnsLookup>,
 }
 
-impl<C: Blockchain> HostExports<C> {
+pub struct DataSourceDetails {
+    pub api_version: Version,
+    pub name: String,
+    pub address: Vec<u8>,
+    pub context: Arc<Option<DataSourceContext>>,
+    pub entity_type_access: EntityTypeAccess,
+    pub templates: Arc<Vec<InstanceDSTemplate>>,
+    pub causality_region: CausalityRegion,
+}
+
+impl DataSourceDetails {
+    pub fn from_data_source<C: Blockchain>(
+        ds: &DataSource<C>,
+        templates: Arc<Vec<InstanceDSTemplate>>,
+    ) -> Self {
+        Self {
+            api_version: ds.api_version(),
+            name: ds.name().to_string(),
+            address: ds.address().unwrap_or_default(),
+            context: ds.context(),
+            entity_type_access: ds.entities(),
+            templates,
+            causality_region: ds.causality_region(),
+        }
+    }
+}
+
+impl HostExports {
     pub fn new(
         subgraph_id: DeploymentHash,
-        data_source: &DataSource<C>,
         subgraph_network: String,
-        templates: Arc<Vec<DataSourceTemplate<C>>>,
+        data_source_details: DataSourceDetails,
         link_resolver: Arc<dyn LinkResolver>,
         ens_lookup: Arc<dyn EnsLookup>,
     ) -> Self {
         Self {
             subgraph_id,
-            api_version: data_source.api_version(),
-            data_source_name: data_source.name().to_owned(),
-            data_source_address: data_source.address().unwrap_or_default(),
-            data_source_context: data_source.context().cheap_clone(),
-            entity_type_access: data_source.entities(),
-            data_source_causality_region: data_source.causality_region(),
+            data_source: data_source_details,
             poi_causality_region: PoICausalityRegion::from_network(&subgraph_network),
             subgraph_network,
-            templates,
             link_resolver,
             ens_lookup,
         }
     }
 
+    pub fn track_gas_and_ops(
+        gas: &GasCounter,
+        state: &mut BlockState,
+        gas_used: Gas,
+        method: &str,
+    ) -> Result<(), DeterministicHostError> {
+        gas.consume_host_fn_with_metrics(gas_used, method)?;
+
+        state.metrics.track_gas_and_ops(gas_used, method);
+
+        Ok(())
+    }
+
     /// Enfore the entity type access restrictions. See also: entity-type-access
     fn check_entity_type_access(&self, entity_type: &EntityType) -> Result<(), HostExportError> {
-        match self.entity_type_access.allows(entity_type) {
+        match self.data_source.entity_type_access.allows(entity_type) {
             true => Ok(()),
             false => Err(HostExportError::Deterministic(anyhow!(
                 "entity type `{}` is not on the 'entities' list for data source `{}`. \
                  Hint: Add `{}` to the 'entities' list, which currently is: `{}`.",
                 entity_type,
-                self.data_source_name,
+                self.data_source.name,
                 entity_type,
-                self.entity_type_access
+                self.data_source.entity_type_access
             ))),
         }
     }
@@ -127,8 +136,9 @@ impl<C: Blockchain> HostExports<C> {
         line_number: Option<u32>,
         column_number: Option<u32>,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<Never, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(Gas::new(gas::DEFAULT_BASE_COST), "abort")?;
+        Self::track_gas_and_ops(gas, state, Gas::new(gas::DEFAULT_BASE_COST), "abort")?;
 
         let message = message
             .map(|message| format!("message: {}", message))
@@ -156,7 +166,7 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         api_version: Version,
         data: &HashMap<Word, Value>,
-        state: &BlockState<C>,
+        state: &BlockState,
         entity_type: &EntityType,
     ) -> Result<(), HostExportError> {
         if api_version >= API_VERSION_0_0_8 {
@@ -164,17 +174,17 @@ impl<C: Blockchain> HostExports<C> {
                 !state
                     .entity_cache
                     .schema
-                    .has_field_with_name(entity_type, &field_name)
+                    .has_field_with_name(entity_type, field_name)
             });
 
             if has_invalid_fields {
                 let mut invalid_fields: Vec<Word> = data
-                    .iter()
-                    .filter_map(|(field_name, _)| {
+                    .keys()
+                    .filter_map(|field_name| {
                         if !state
                             .entity_cache
                             .schema
-                            .has_field_with_name(entity_type, &field_name)
+                            .has_field_with_name(entity_type, field_name)
                         {
                             Some(field_name.clone())
                         } else {
@@ -202,21 +212,19 @@ impl<C: Blockchain> HostExports<C> {
 
     /// Ensure that `entity_type` is of the right kind
     fn expect_object_type(entity_type: &EntityType, op: &str) -> Result<(), HostExportError> {
-        if entity_type.kind() != TypeKind::Object {
-            Err(HostExportError::Deterministic(anyhow!(
-                "Cannot {op} entity of type `{}`. The type must be an @entity type",
-                entity_type.as_str()
-            )))
-        } else {
-            Ok(())
+        if entity_type.is_object_type() {
+            return Ok(());
         }
+        Err(HostExportError::Deterministic(anyhow!(
+            "Cannot {op} entity of type `{}`. The type must be an @entity type",
+            entity_type.as_str()
+        )))
     }
 
-    pub(crate) fn store_set(
+    pub(crate) async fn store_set(
         &self,
         logger: &Logger,
-        state: &mut BlockState<C>,
-        block: BlockNumber,
+        state: &mut BlockState,
         proof_of_indexing: &SharedProofOfIndexing,
         block_time: BlockTime,
         entity_type: String,
@@ -229,25 +237,32 @@ impl<C: Blockchain> HostExports<C> {
 
         Self::expect_object_type(&entity_type, "set")?;
 
-        let entity_id = if entity_id == "auto" {
-            if self.data_source_causality_region != CausalityRegion::ONCHAIN {
+        let entity_id = if entity_id == "auto"
+            || entity_type
+                .object_type()
+                .map(|ot| ot.timeseries)
+                .unwrap_or(false)
+        {
+            if self.data_source.causality_region != CausalityRegion::ONCHAIN {
                 return Err(anyhow!(
                     "Autogenerated IDs are only supported for onchain data sources"
                 )
                 .into());
             }
             let id_type = entity_type.id_type()?;
-            let id = state.entity_cache.generate_id(id_type, block)?;
+            let id = state.entity_cache.seq_gen.id(id_type)?;
             data.insert(store::ID.clone(), id.clone().into());
             id.to_string()
         } else {
             entity_id
         };
 
-        let key = entity_type.parse_key_in(entity_id, self.data_source_causality_region)?;
+        let key = entity_type.parse_key_in(entity_id, self.data_source.causality_region)?;
         self.check_entity_type_access(&key.entity_type)?;
 
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::STORE_SET.with_args(complexity::Linear, (&key, &data)),
             "store_set",
         )?;
@@ -286,7 +301,12 @@ impl<C: Blockchain> HostExports<C> {
             }
         }
 
-        self.check_invalid_fields(self.api_version.clone(), &data, state, &key.entity_type)?;
+        self.check_invalid_fields(
+            self.data_source.api_version.clone(),
+            &data,
+            state,
+            &key.entity_type,
+        )?;
 
         // Filter out fields that are not in the schema
         let filtered_entity_data = data.into_iter().filter(|(field_name, _)| {
@@ -302,10 +322,9 @@ impl<C: Blockchain> HostExports<C> {
             .map_err(|e| HostExportError::Deterministic(anyhow!(e)))?;
 
         let poi_section = stopwatch.start_section("host_export_store_set__proof_of_indexing");
-        write_poi_event(
-            proof_of_indexing,
+        proof_of_indexing.write_event(
             &ProofOfIndexingEvent::SetEntity {
-                entity_type: &key.entity_type.as_str(),
+                entity_type: key.entity_type.typename(),
                 id: &key.entity_id.to_string(),
                 data: &entity,
             },
@@ -314,7 +333,12 @@ impl<C: Blockchain> HostExports<C> {
         );
         poi_section.end();
 
-        state.entity_cache.set(key, entity)?;
+        state.metrics.track_entity_write(&entity_type, &entity);
+
+        state
+            .entity_cache
+            .set(key, entity, Some(&mut state.write_capacity_remaining))
+            .await?;
 
         Ok(())
     }
@@ -322,14 +346,13 @@ impl<C: Blockchain> HostExports<C> {
     pub(crate) fn store_remove(
         &self,
         logger: &Logger,
-        state: &mut BlockState<C>,
+        state: &mut BlockState,
         proof_of_indexing: &SharedProofOfIndexing,
         entity_type: String,
         entity_id: String,
         gas: &GasCounter,
     ) -> Result<(), HostExportError> {
-        write_poi_event(
-            proof_of_indexing,
+        proof_of_indexing.write_event(
             &ProofOfIndexingEvent::RemoveEntity {
                 entity_type: &entity_type,
                 id: &entity_id,
@@ -340,10 +363,12 @@ impl<C: Blockchain> HostExports<C> {
         let entity_type = state.entity_cache.schema.entity_type(&entity_type)?;
         Self::expect_object_type(&entity_type, "remove")?;
 
-        let key = entity_type.parse_key_in(entity_id, self.data_source_causality_region)?;
+        let key = entity_type.parse_key_in(entity_id, self.data_source.causality_region)?;
         self.check_entity_type_access(&key.entity_type)?;
 
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::STORE_REMOVE.with_args(complexity::Size, &key),
             "store_remove",
         )?;
@@ -353,23 +378,25 @@ impl<C: Blockchain> HostExports<C> {
         Ok(())
     }
 
-    pub(crate) fn store_get<'a>(
+    pub(crate) async fn store_get(
         &self,
-        state: &'a mut BlockState<C>,
+        state: &mut BlockState,
         entity_type: String,
         entity_id: String,
         gas: &GasCounter,
         scope: GetScope,
-    ) -> Result<Option<Cow<'a, Entity>>, anyhow::Error> {
+    ) -> Result<Option<Arc<Entity>>, anyhow::Error> {
         let entity_type = state.entity_cache.schema.entity_type(&entity_type)?;
         Self::expect_object_type(&entity_type, "get")?;
 
-        let store_key = entity_type.parse_key_in(entity_id, self.data_source_causality_region)?;
+        let store_key = entity_type.parse_key_in(entity_id, self.data_source.causality_region)?;
         self.check_entity_type_access(&store_key.entity_type)?;
 
-        let result = state.entity_cache.get(&store_key, scope)?;
+        let result = state.entity_cache.get(&store_key, scope).await?;
 
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::STORE_GET.with_args(
                 complexity::Linear,
                 (&store_key, result.as_ref().map(|e| e.as_ref())),
@@ -377,33 +404,42 @@ impl<C: Blockchain> HostExports<C> {
             "store_get",
         )?;
 
+        if let Some(ref entity) = result {
+            state.metrics.track_entity_read(&entity_type, entity)
+        }
+
         Ok(result)
     }
 
-    pub(crate) fn store_load_related(
+    pub(crate) async fn store_load_related(
         &self,
-        state: &mut BlockState<C>,
+        state: &mut BlockState,
         entity_type: String,
         entity_id: String,
         entity_field: String,
         gas: &GasCounter,
     ) -> Result<Vec<Entity>, anyhow::Error> {
         let entity_type = state.entity_cache.schema.entity_type(&entity_type)?;
-        let key = entity_type.parse_key_in(entity_id, self.data_source_causality_region)?;
+        let key = entity_type.parse_key_in(entity_id, self.data_source.causality_region)?;
         let store_key = LoadRelatedRequest {
             entity_type: key.entity_type,
             entity_id: key.entity_id,
             entity_field: entity_field.into(),
-            causality_region: self.data_source_causality_region,
+            causality_region: self.data_source.causality_region,
         };
         self.check_entity_type_access(&store_key.entity_type)?;
 
-        let result = state.entity_cache.load_related(&store_key)?;
-        gas.consume_host_fn_with_metrics(
+        let result = state.entity_cache.load_related(&store_key).await?;
+
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::STORE_GET.with_args(complexity::Linear, (&store_key, &result)),
             "store_load_related",
         )?;
 
+        state.metrics.track_entity_read_batch(&entity_type, &result);
+
         Ok(result)
     }
 
@@ -416,8 +452,11 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         n: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<String, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &n),
             "big_int_to_hex",
         )?;
@@ -433,14 +472,23 @@ impl<C: Blockchain> HostExports<C> {
         ))
     }
 
-    pub(crate) fn ipfs_cat(&self, logger: &Logger, link: String) -> Result<Vec<u8>, anyhow::Error> {
+    pub(crate) async fn ipfs_cat(
+        &self,
+        logger: &Logger,
+        link: String,
+    ) -> Result<Vec<u8>, anyhow::Error> {
         // Does not consume gas because this is not a part of the deterministic feature set.
         // Ideally this would first consume gas for fetching the file stats, and then again
         // for the bytes of the file.
-        graph::block_on(self.link_resolver.cat(logger, &Link { link }))
+        self.link_resolver
+            .cat(
+                &LinkResolverContext::new(&self.subgraph_id, logger),
+                &Link { link },
+            )
+            .await
     }
 
-    pub(crate) fn ipfs_get_block(
+    pub(crate) async fn ipfs_get_block(
         &self,
         logger: &Logger,
         link: String,
@@ -448,7 +496,12 @@ impl<C: Blockchain> HostExports<C> {
         // Does not consume gas because this is not a part of the deterministic feature set.
         // Ideally this would first consume gas for fetching the file stats, and then again
         // for the bytes of the file.
-        graph::block_on(self.link_resolver.get_block(logger, &Link { link }))
+        self.link_resolver
+            .get_block(
+                &LinkResolverContext::new(&self.subgraph_id, logger),
+                &Link { link },
+            )
+            .await
     }
 
     // Read the IPFS file `link`, split it into JSON objects, and invoke the
@@ -458,14 +511,14 @@ impl<C: Blockchain> HostExports<C> {
     // which is identical to `module` when it was first started. The signature
     // of the callback must be `callback(JSONValue, Value)`, and the `userData`
     // parameter is passed to the callback without any changes
-    pub(crate) fn ipfs_map(
-        link_resolver: &Arc<dyn LinkResolver>,
-        module: &mut WasmInstanceContext<C>,
+    pub(crate) async fn ipfs_map(
+        &self,
+        wasm_ctx: &WasmInstanceData,
         link: String,
         callback: &str,
         user_data: store::Value,
         flags: Vec<String>,
-    ) -> Result<Vec<BlockState<C>>, anyhow::Error> {
+    ) -> Result<Vec<BlockState>, anyhow::Error> {
         // Does not consume gas because this is not a part of deterministic APIs.
         // Ideally we would consume gas the same as ipfs_cat and then share
         // gas across the spawned modules for callbacks.
@@ -476,9 +529,9 @@ impl<C: Blockchain> HostExports<C> {
             "Flags must contain 'json'"
         );
 
-        let host_metrics = module.host_metrics.clone();
-        let valid_module = module.valid_module.clone();
-        let ctx = module.ctx.derive_with_empty_block_state();
+        let host_metrics = wasm_ctx.host_metrics.clone();
+        let valid_module = wasm_ctx.valid_module.clone();
+        let ctx = wasm_ctx.ctx.derive_with_empty_block_state();
         let callback = callback.to_owned();
         // Create a base error message to avoid borrowing headaches
         let errmsg = format!(
@@ -491,19 +544,26 @@ impl<C: Blockchain> HostExports<C> {
         let logger = ctx.logger.new(o!("ipfs_map" => link.clone()));
 
         let result = {
-            let mut stream: JsonValueStream =
-                graph::block_on(link_resolver.json_stream(&logger, &Link { link }))?;
+            let mut stream: JsonValueStream = self
+                .link_resolver
+                .json_stream(
+                    &LinkResolverContext::new(&self.subgraph_id, &logger),
+                    &Link { link },
+                )
+                .await?;
             let mut v = Vec::new();
-            while let Some(sv) = graph::block_on(stream.next()) {
+            while let Some(sv) = stream.next().await {
                 let sv = sv?;
-                let module = WasmInstance::from_valid_module_with_ctx(
+                let module = WasmInstance::from_valid_module_with_ctx_boxed(
                     valid_module.clone(),
                     ctx.derive_with_empty_block_state(),
                     host_metrics.clone(),
-                    module.timeout,
-                    module.experimental_features,
-                )?;
-                let result = module.handle_json_callback(&callback, &sv.value, &user_data)?;
+                    wasm_ctx.experimental_features,
+                )
+                .await?;
+                let result = module
+                    .handle_json_callback(&callback, &sv.value, &user_data)
+                    .await?;
                 // Log progress every 15s
                 if last_log.elapsed() > Duration::from_secs(15) {
                     debug!(
@@ -518,7 +578,7 @@ impl<C: Blockchain> HostExports<C> {
             }
             Ok(v)
         };
-        result.map_err(move |e: Error| anyhow::anyhow!("{}: {}", errmsg, e.to_string()))
+        result.map_err(move |e: Error| anyhow::anyhow!("{}: {}", errmsg, e))
     }
 
     /// Expects a decimal string.
@@ -526,8 +586,11 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         json: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<i64, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json),
             "json_to_i64",
         )?;
@@ -541,8 +604,11 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         json: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<u64, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json),
             "json_to_u64",
         )?;
@@ -557,8 +623,11 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         json: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<f64, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json),
             "json_to_f64",
         )?;
@@ -573,8 +642,11 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         json: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<Vec<u8>, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json),
             "json_to_big_int",
         )?;
@@ -589,13 +661,16 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         input: Vec<u8>,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<[u8; 32], DeterministicHostError> {
         let data = &input[..];
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, data),
             "crypto_keccak_256",
         )?;
-        Ok(tiny_keccak::keccak256(data))
+        Ok(alloy::primitives::keccak256(data).0)
     }
 
     pub(crate) fn big_int_plus(
@@ -603,8 +678,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Max, (&x, &y)),
             "big_int_plus",
         )?;
@@ -616,8 +694,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Max, (&x, &y)),
             "big_int_minus",
         )?;
@@ -629,8 +710,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)),
             "big_int_times",
         )?;
@@ -642,8 +726,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)),
             "big_int_divided_by",
         )?;
@@ -661,8 +748,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)),
             "big_int_mod",
         )?;
@@ -681,8 +771,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         exp: u8,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP
                 .with_args(complexity::Exponential, (&x, (exp as f32).log2() as u8)),
             "big_int_pow",
@@ -694,8 +787,11 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         s: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &s),
             "big_int_from_string",
         )?;
@@ -709,8 +805,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Max, (&x, &y)),
             "big_int_bit_or",
         )?;
@@ -722,8 +821,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Min, (&x, &y)),
             "big_int_bit_and",
         )?;
@@ -735,8 +837,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         bits: u8,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &bits)),
             "big_int_left_shift",
         )?;
@@ -748,8 +853,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         bits: u8,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &bits)),
             "big_int_right_shift",
         )?;
@@ -761,8 +869,11 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         bytes: Vec<u8>,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<String, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &bytes),
             "bytes_to_base58",
         )?;
@@ -774,8 +885,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigDecimal,
         y: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigDecimal, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &y)),
             "big_decimal_plus",
         )?;
@@ -787,8 +901,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigDecimal,
         y: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigDecimal, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &y)),
             "big_decimal_minus",
         )?;
@@ -800,8 +917,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigDecimal,
         y: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigDecimal, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)),
             "big_decimal_times",
         )?;
@@ -814,8 +934,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigDecimal,
         y: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigDecimal, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)),
             "big_decimal_divided_by",
         )?;
@@ -833,8 +956,11 @@ impl<C: Blockchain> HostExports<C> {
         x: BigDecimal,
         y: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<bool, HostExportError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::BIG_MATH_GAS_OP.with_args(complexity::Min, (&x, &y)),
             "big_decimal_equals",
         )?;
@@ -845,8 +971,11 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         x: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<String, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Mul, (&x, &x)),
             "big_decimal_to_string",
         )?;
@@ -857,8 +986,11 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         s: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigDecimal, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &s),
             "big_decimal_from_string",
         )?;
@@ -870,14 +1002,14 @@ impl<C: Blockchain> HostExports<C> {
     pub(crate) fn data_source_create(
         &self,
         logger: &Logger,
-        state: &mut BlockState<C>,
+        state: &mut BlockState,
         name: String,
         params: Vec<String>,
         context: Option<DataSourceContext>,
         creation_block: BlockNumber,
         gas: &GasCounter,
     ) -> Result<(), HostExportError> {
-        gas.consume_host_fn_with_metrics(gas::CREATE_DATA_SOURCE, "data_source_create")?;
+        Self::track_gas_and_ops(gas, state, gas::CREATE_DATA_SOURCE, "data_source_create")?;
         info!(
             logger,
             "Create data source";
@@ -887,19 +1019,21 @@ impl<C: Blockchain> HostExports<C> {
 
         // Resolve the name into the right template
         let template = self
+            .data_source
             .templates
             .iter()
-            .find(|template| template.name() == name)
+            .find(|template| template.name().eq(&name))
             .with_context(|| {
                 format!(
                     "Failed to create data source from name `{}`: \
                      No template with this name in parent data source `{}`. \
                      Available names: {}.",
                     name,
-                    self.data_source_name,
-                    self.templates
+                    self.data_source.name,
+                    self.data_source
+                        .templates
                         .iter()
-                        .map(|template| template.name())
+                        .map(|t| t.name())
                         .collect::<Vec<_>>()
                         .join(", ")
                 )
@@ -908,7 +1042,7 @@ impl<C: Blockchain> HostExports<C> {
             .clone();
 
         // Remember that we need to create this data source
-        state.push_created_data_source(DataSourceTemplateInfo {
+        state.push_created_data_source(InstanceDSTemplateInfo {
             template,
             params,
             context,
@@ -918,17 +1052,18 @@ impl<C: Blockchain> HostExports<C> {
         Ok(())
     }
 
-    pub(crate) fn ens_name_by_hash(
+    pub(crate) async fn ens_name_by_hash(
         &self,
         hash: &str,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<Option<String>, anyhow::Error> {
-        gas.consume_host_fn_with_metrics(gas::ENS_NAME_BY_HASH, "ens_name_by_hash")?;
-        Ok(self.ens_lookup.find_name(hash)?)
+        Self::track_gas_and_ops(gas, state, gas::ENS_NAME_BY_HASH, "ens_name_by_hash")?;
+        Ok(self.ens_lookup.find_name(hash).await?)
     }
 
-    pub(crate) fn is_ens_data_empty(&self) -> Result<bool, anyhow::Error> {
-        Ok(self.ens_lookup.is_table_empty()?)
+    pub(crate) async fn is_ens_data_empty(&self) -> Result<bool, anyhow::Error> {
+        Ok(self.ens_lookup.is_table_empty().await?)
     }
 
     pub(crate) fn log_log(
@@ -937,20 +1072,27 @@ impl<C: Blockchain> HostExports<C> {
         level: slog::Level,
         msg: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<(), DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(gas::LOG_OP.with_args(complexity::Size, &msg), "log_log")?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::LOG_OP.with_args(complexity::Size, &msg),
+            "log_log",
+        )?;
 
-        let rs = record_static!(level, self.data_source_name.as_str());
+        let rs = record_static!(level, self.data_source.name.as_str());
 
         logger.log(&slog::Record::new(
             &rs,
             &format_args!("{}", msg),
-            b!("data_source" => &self.data_source_name),
+            b!("data_source" => &self.data_source.name),
         ));
 
         if level == slog::Level::Critical {
             return Err(DeterministicHostError::from(anyhow!(
-                "Critical error logged in mapping"
+                "Critical error logged in mapping with log message: {}",
+                msg
             )));
         }
         Ok(())
@@ -959,60 +1101,85 @@ impl<C: Blockchain> HostExports<C> {
     pub(crate) fn data_source_address(
         &self,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<Vec<u8>, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(Gas::new(gas::DEFAULT_BASE_COST), "data_source_address")?;
-        Ok(self.data_source_address.clone())
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            Gas::new(gas::DEFAULT_BASE_COST),
+            "data_source_address",
+        )?;
+        Ok(self.data_source.address.clone())
     }
 
     pub(crate) fn data_source_network(
         &self,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<String, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(Gas::new(gas::DEFAULT_BASE_COST), "data_source_network")?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            Gas::new(gas::DEFAULT_BASE_COST),
+            "data_source_network",
+        )?;
         Ok(self.subgraph_network.clone())
     }
 
     pub(crate) fn data_source_context(
         &self,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<Option<DataSourceContext>, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(Gas::new(gas::DEFAULT_BASE_COST), "data_source_context")?;
-        Ok(self.data_source_context.as_ref().clone())
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            Gas::new(gas::DEFAULT_BASE_COST),
+            "data_source_context",
+        )?;
+        Ok(self.data_source.context.as_ref().clone())
     }
 
     pub(crate) fn json_from_bytes(
         &self,
         bytes: &Vec<u8>,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<serde_json::Value, DeterministicHostError> {
         // Max JSON size is 10MB.
         const MAX_JSON_SIZE: usize = 10_000_000;
 
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::JSON_FROM_BYTES.with_args(gas::complexity::Size, &bytes),
             "json_from_bytes",
         )?;
 
         if bytes.len() > MAX_JSON_SIZE {
-            return Err(DeterministicHostError::Other(
-                anyhow!("JSON size exceeds max size of {}", MAX_JSON_SIZE).into(),
-            ));
+            return Err(DeterministicHostError::Other(anyhow!(
+                "JSON size exceeds max size of {}",
+                MAX_JSON_SIZE
+            )));
         }
 
         serde_json::from_slice(bytes.as_slice())
             .map_err(|e| DeterministicHostError::from(Error::from(e)))
     }
 
-    pub(crate) fn string_to_h160(
+    pub(crate) fn string_to_address(
         &self,
         string: &str,
         gas: &GasCounter,
-    ) -> Result<H160, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        state: &mut BlockState,
+    ) -> Result<Address, DeterministicHostError> {
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &string),
             "string_to_h160",
         )?;
-        string_to_h160(string)
+        string_to_address(string)
     }
 
     pub(crate) fn bytes_to_string(
@@ -1020,8 +1187,11 @@ impl<C: Blockchain> HostExports<C> {
         logger: &Logger,
         bytes: Vec<u8>,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<String, DeterministicHostError> {
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &bytes),
             "bytes_to_string",
         )?;
@@ -1031,12 +1201,15 @@ impl<C: Blockchain> HostExports<C> {
 
     pub(crate) fn ethereum_encode(
         &self,
-        token: Token,
+        value: abi::DynSolValue,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<Vec<u8>, DeterministicHostError> {
-        let encoded = encode(&[token]);
+        let encoded = value.abi_encode();
 
-        gas.consume_host_fn_with_metrics(
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &encoded),
             "ethereum_encode",
         )?;
@@ -1049,29 +1222,75 @@ impl<C: Blockchain> HostExports<C> {
         types: String,
         data: Vec<u8>,
         gas: &GasCounter,
-    ) -> Result<Token, anyhow::Error> {
-        gas.consume_host_fn_with_metrics(
+        state: &mut BlockState,
+    ) -> Result<abi::DynSolValue, anyhow::Error> {
+        Self::track_gas_and_ops(
+            gas,
+            state,
             gas::DEFAULT_GAS_OP.with_args(complexity::Size, &data),
             "ethereum_decode",
         )?;
 
-        let param_types =
-            Reader::read(&types).map_err(|e| anyhow::anyhow!("Failed to read types: {}", e))?;
+        let ty: abi::DynSolType = types.parse().context("Failed to read types")?;
+
+        ty.abi_decode(&data).context("Failed to decode")
+    }
+
+    /// Like [`Self::ethereum_decode`], but decodes `data` as ABI function
+    /// parameters (the layout used by transaction calldata and event data)
+    /// rather than as a single ABI value. The two differ only for a top-level
+    /// tuple with at least one dynamic field: calldata has no leading offset
+    /// word, which `abi_decode` would otherwise expect.
+    pub(crate) fn ethereum_decode_params(
+        &self,
+        types: String,
+        data: Vec<u8>,
+        gas: &GasCounter,
+        state: &mut BlockState,
+    ) -> Result<abi::DynSolValue, anyhow::Error> {
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &data),
+            "ethereum_decode_params",
+        )?;
+
+        let ty: abi::DynSolType = types.parse().context("Failed to read types")?;
+
+        ty.abi_decode_params(&data).context("Failed to decode")
+    }
+
+    pub(crate) fn yaml_from_bytes(
+        &self,
+        bytes: &[u8],
+        gas: &GasCounter,
+        state: &mut BlockState,
+    ) -> Result<serde_yaml::Value, DeterministicHostError> {
+        const YAML_MAX_SIZE_BYTES: usize = 10_000_000;
+
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::YAML_FROM_BYTES.with_args(complexity::Size, bytes),
+            "yaml_from_bytes",
+        )?;
+
+        if bytes.len() > YAML_MAX_SIZE_BYTES {
+            return Err(DeterministicHostError::Other(anyhow!(
+                "YAML size exceeds max size of {} bytes",
+                YAML_MAX_SIZE_BYTES
+            )));
+        }
 
-        decode(&[param_types], &data)
-            // The `.pop().unwrap()` here is ok because we're always only passing one
-            // `param_types` to `decode`, so the returned `Vec` has always size of one.
-            // We can't do `tokens[0]` because the value can't be moved out of the `Vec`.
-            .map(|mut tokens| tokens.pop().unwrap())
-            .context("Failed to decode")
+        serde_yaml::from_slice(bytes)
+            .context("failed to parse YAML from bytes")
+            .map_err(DeterministicHostError::from)
     }
 }
 
-fn string_to_h160(string: &str) -> Result<H160, DeterministicHostError> {
-    // `H160::from_str` takes a hex string with no leading `0x`.
-    let s = string.trim_start_matches("0x");
-    H160::from_str(s)
-        .with_context(|| format!("Failed to convert string to Address/H160: '{}'", s))
+fn string_to_address(string: &str) -> Result<Address, DeterministicHostError> {
+    Address::from_str(string)
+        .with_context(|| format!("Failed to convert string to Address: '{}'", string))
         .map_err(DeterministicHostError::from)
 }
 
@@ -1097,40 +1316,36 @@ fn bytes_to_string(logger: &Logger, bytes: Vec<u8>) -> String {
 /// Expose some host functions for testing only
 #[cfg(debug_assertions)]
 pub mod test_support {
-    use std::{borrow::Cow, collections::HashMap, sync::Arc};
+    use std::{collections::HashMap, sync::Arc};
 
     use graph::{
-        blockchain::{BlockTime, Blockchain},
-        components::{
-            store::{BlockNumber, GetScope},
-            subgraph::SharedProofOfIndexing,
-        },
+        blockchain::BlockTime,
+        components::{store::GetScope, subgraph::SharedProofOfIndexing},
         data::value::Word,
         prelude::{BlockState, Entity, StopwatchMetrics, Value},
-        runtime::{gas::GasCounter, HostExportError},
+        runtime::{HostExportError, gas::GasCounter},
         slog::Logger,
     };
 
     use crate::MappingContext;
 
-    pub struct HostExports<C: Blockchain> {
-        host_exports: Arc<super::HostExports<C>>,
+    pub struct HostExports {
+        host_exports: Arc<super::HostExports>,
         block_time: BlockTime,
     }
 
-    impl<C: Blockchain> HostExports<C> {
-        pub fn new(ctx: &MappingContext<C>) -> Self {
+    impl HostExports {
+        pub fn new(ctx: &MappingContext) -> Self {
             HostExports {
                 host_exports: ctx.host_exports.clone(),
                 block_time: ctx.timestamp,
             }
         }
 
-        pub fn store_set(
+        pub async fn store_set(
             &self,
             logger: &Logger,
-            state: &mut BlockState<C>,
-            block: BlockNumber,
+            state: &mut BlockState,
             proof_of_indexing: &SharedProofOfIndexing,
             entity_type: String,
             entity_id: String,
@@ -1138,37 +1353,39 @@ pub mod test_support {
             stopwatch: &StopwatchMetrics,
             gas: &GasCounter,
         ) -> Result<(), HostExportError> {
-            self.host_exports.store_set(
-                logger,
-                state,
-                block,
-                proof_of_indexing,
-                self.block_time,
-                entity_type,
-                entity_id,
-                data,
-                stopwatch,
-                gas,
-            )
+            self.host_exports
+                .store_set(
+                    logger,
+                    state,
+                    proof_of_indexing,
+                    self.block_time,
+                    entity_type,
+                    entity_id,
+                    data,
+                    stopwatch,
+                    gas,
+                )
+                .await
         }
 
-        pub fn store_get<'a>(
+        pub async fn store_get(
             &self,
-            state: &'a mut BlockState<C>,
+            state: &mut BlockState,
             entity_type: String,
             entity_id: String,
             gas: &GasCounter,
-        ) -> Result<Option<Cow<'a, Entity>>, anyhow::Error> {
+        ) -> Result<Option<Arc<Entity>>, anyhow::Error> {
             self.host_exports
                 .store_get(state, entity_type, entity_id, gas, GetScope::Store)
+                .await
         }
     }
 }
 #[test]
 fn test_string_to_h160_with_0x() {
     assert_eq!(
-        H160::from_str("A16081F360e3847006dB660bae1c6d1b2e17eC2A").unwrap(),
-        string_to_h160("0xA16081F360e3847006dB660bae1c6d1b2e17eC2A").unwrap()
+        Address::from_str("A16081F360e3847006dB660bae1c6d1b2e17eC2A").unwrap(),
+        string_to_address("0xA16081F360e3847006dB660bae1c6d1b2e17eC2A").unwrap()
     )
 }
 
@@ -1178,7 +1395,9 @@ fn bytes_to_string_is_lossy() {
         "Downcoin WETH-USDT",
         bytes_to_string(
             &graph::log::logger(true),
-            vec![68, 111, 119, 110, 99, 111, 105, 110, 32, 87, 69, 84, 72, 45, 85, 83, 68, 84],
+            vec![
+                68, 111, 119, 110, 99, 111, 105, 110, 32, 87, 69, 84, 72, 45, 85, 83, 68, 84
+            ],
         )
     );
 
diff --git a/runtime/wasm/src/lib.rs b/runtime/wasm/src/lib.rs
index a9b28f872f1..7c543a4c128 100644
--- a/runtime/wasm/src/lib.rs
+++ b/runtime/wasm/src/lib.rs
@@ -4,7 +4,7 @@ mod host;
 pub mod to_from;
 
 /// Public interface of the crate, receives triggers to be processed.
-
+///
 /// Pre-processes modules and manages their threads. Serves as an interface from `host` to `module`.
 pub mod mapping;
 
diff --git a/runtime/wasm/src/mapping.rs b/runtime/wasm/src/mapping.rs
index 719ca00a4d3..c185148bff0 100644
--- a/runtime/wasm/src/mapping.rs
+++ b/runtime/wasm/src/mapping.rs
@@ -1,16 +1,21 @@
 use crate::gas_rules::GasRules;
-use crate::module::{ExperimentalFeatures, ToAscPtr, WasmInstance};
-use futures::sync::mpsc;
-use futures03::channel::oneshot::Sender;
+use crate::module::{ExperimentalFeatures, ToAscPtr, WasmInstance, WasmInstanceData};
 use graph::blockchain::{BlockTime, Blockchain, HostFn};
 use graph::components::store::SubgraphFork;
 use graph::components::subgraph::{MappingError, SharedProofOfIndexing};
 use graph::data_source::{MappingTrigger, TriggerWithHandler};
+use graph::futures01::sync::mpsc;
+use graph::futures01::{Future as _, Stream as _};
+use graph::futures03::channel::oneshot::Sender;
+use graph::parking_lot::RwLock;
 use graph::prelude::*;
+use graph::runtime::IndexForAscTypeId;
 use graph::runtime::gas::Gas;
-use std::collections::BTreeMap;
+use parity_wasm::elements::ExportEntry;
+use std::collections::{BTreeMap, HashMap};
 use std::panic::AssertUnwindSafe;
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::{panic, thread};
 
 /// Spawn a wasm module in its own thread.
@@ -26,19 +31,29 @@ pub fn spawn_module<C: Blockchain>(
 where
     <C as Blockchain>::MappingTrigger: ToAscPtr,
 {
-    let valid_module = Arc::new(ValidModule::new(&logger, raw_module)?);
+    static THREAD_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+    let valid_module = Arc::new(ValidModule::new(&logger, raw_module, timeout)?);
 
     // Create channel for event handling requests
     let (mapping_request_sender, mapping_request_receiver) = mpsc::channel(100);
 
-    // wasmtime instances are not `Send` therefore they cannot be scheduled by
-    // the regular tokio executor, so we create a dedicated thread.
+    // It used to be that we had to create a dedicated thread since wasmtime
+    // instances were not `Send` and could therefore not be scheduled by the
+    // regular tokio executor. This isn't an issue anymore, but we still
+    // spawn a dedicated thread since running WASM code async can block and
+    // lock up the executor. See [the wasmtime
+    // docs](https://docs.rs/wasmtime/latest/wasmtime/struct.Config.html#execution-in-poll)
+    // on how this should be handled properly. As that is a fairly large
+    // change to how we use wasmtime, we keep the threading model for now.
+    // Once we are confident that things are working that way, we should
+    // revisit this and remove the dedicated thread.
     //
     // In case of failure, this thread may panic or simply terminate,
     // dropping the `mapping_request_receiver` which ultimately causes the
     // subgraph to fail the next time it tries to handle an event.
-    let conf =
-        thread::Builder::new().name(format!("mapping-{}-{}", &subgraph_id, uuid::Uuid::new_v4()));
+    let next_id = THREAD_COUNT.fetch_add(1, Ordering::SeqCst);
+    let conf = thread::Builder::new().name(format!("mapping-{}-{:0>4}", &subgraph_id, next_id));
     conf.spawn(move || {
         let _runtime_guard = runtime.enter();
 
@@ -54,25 +69,25 @@ where
                 } = request;
                 let logger = ctx.logger.clone();
 
-                let result = panic::catch_unwind(AssertUnwindSafe(|| {
-                    instantiate_module(
+                let handle_fut = async {
+                    let result = instantiate_module::<C>(
                         valid_module.cheap_clone(),
                         ctx,
                         host_metrics.cheap_clone(),
-                        timeout,
                         experimental_features,
                     )
-                    .map_err(Into::into)
-                    .and_then(|module| match inner {
-                        WasmRequestInner::TriggerRequest(trigger) => {
-                            handle_trigger(&logger, module, trigger, host_metrics.cheap_clone())
-                        }
-                        WasmRequestInner::BlockRequest(BlockRequest {
-                            block_data,
-                            handler,
-                        }) => module.handle_block(&logger, &handler, block_data),
-                    })
-                }));
+                    .await;
+                    match result {
+                        Ok(module) => match inner {
+                            WasmRequestInner::TriggerRequest(trigger) => {
+                                handle_trigger(&logger, module, trigger, host_metrics.cheap_clone())
+                                    .await
+                            }
+                        },
+                        Err(e) => Err(MappingError::Unknown(e)),
+                    }
+                };
+                let result = panic::catch_unwind(AssertUnwindSafe(|| graph::block_on(handle_fut)));
 
                 let result = match result {
                     Ok(result) => result,
@@ -107,13 +122,12 @@ where
     Ok(mapping_request_sender)
 }
 
-fn instantiate_module<C: Blockchain>(
+async fn instantiate_module<C: Blockchain>(
     valid_module: Arc<ValidModule>,
-    ctx: MappingContext<C>,
+    ctx: MappingContext,
     host_metrics: Arc<HostMetrics>,
-    timeout: Option<Duration>,
     experimental_features: ExperimentalFeatures,
-) -> Result<WasmInstance<C>, anyhow::Error>
+) -> Result<WasmInstance, anyhow::Error>
 where
     <C as Blockchain>::MappingTrigger: ToAscPtr,
 {
@@ -123,18 +137,18 @@ where
         valid_module,
         ctx,
         host_metrics.cheap_clone(),
-        timeout,
         experimental_features,
     )
+    .await
     .context("module instantiation failed")
 }
 
-fn handle_trigger<C: Blockchain>(
+async fn handle_trigger<C: Blockchain>(
     logger: &Logger,
-    module: WasmInstance<C>,
+    module: WasmInstance,
     trigger: TriggerWithHandler<MappingTrigger<C>>,
     host_metrics: Arc<HostMetrics>,
-) -> Result<(BlockState<C>, Gas), MappingError>
+) -> Result<(BlockState, Gas), MappingError>
 where
     <C as Blockchain>::MappingTrigger: ToAscPtr,
 {
@@ -144,20 +158,20 @@ where
     if ENV_VARS.log_trigger_data {
         debug!(logger, "trigger data: {:?}", trigger);
     }
-    module.handle_trigger(trigger)
+    module.handle_trigger(trigger).await
 }
 
 pub struct WasmRequest<C: Blockchain> {
-    pub(crate) ctx: MappingContext<C>,
+    pub(crate) ctx: MappingContext,
     pub(crate) inner: WasmRequestInner<C>,
-    pub(crate) result_sender: Sender<Result<(BlockState<C>, Gas), MappingError>>,
+    pub(crate) result_sender: Sender<Result<(BlockState, Gas), MappingError>>,
 }
 
 impl<C: Blockchain> WasmRequest<C> {
     pub(crate) fn new_trigger(
-        ctx: MappingContext<C>,
+        ctx: MappingContext,
         trigger: TriggerWithHandler<MappingTrigger<C>>,
-        result_sender: Sender<Result<(BlockState<C>, Gas), MappingError>>,
+        result_sender: Sender<Result<(BlockState, Gas), MappingError>>,
     ) -> Self {
         WasmRequest {
             ctx,
@@ -165,40 +179,18 @@ impl<C: Blockchain> WasmRequest<C> {
             result_sender,
         }
     }
-
-    pub(crate) fn new_block(
-        ctx: MappingContext<C>,
-        handler: String,
-        block_data: Box<[u8]>,
-        result_sender: Sender<Result<(BlockState<C>, Gas), MappingError>>,
-    ) -> Self {
-        WasmRequest {
-            ctx,
-            inner: WasmRequestInner::BlockRequest(BlockRequest {
-                handler,
-                block_data,
-            }),
-            result_sender,
-        }
-    }
 }
 
 pub enum WasmRequestInner<C: Blockchain> {
     TriggerRequest(TriggerWithHandler<MappingTrigger<C>>),
-    BlockRequest(BlockRequest),
 }
 
-pub struct BlockRequest {
-    pub(crate) handler: String,
-    pub(crate) block_data: Box<[u8]>,
-}
-
-pub struct MappingContext<C: Blockchain> {
+pub struct MappingContext {
     pub logger: Logger,
-    pub host_exports: Arc<crate::host_exports::HostExports<C>>,
+    pub host_exports: Arc<crate::host_exports::HostExports>,
     pub block_ptr: BlockPtr,
     pub timestamp: BlockTime,
-    pub state: BlockState<C>,
+    pub state: BlockState,
     pub proof_of_indexing: SharedProofOfIndexing,
     pub host_fns: Arc<Vec<HostFn>>,
     pub debug_fork: Option<Arc<dyn SubgraphFork>>,
@@ -208,14 +200,18 @@ pub struct MappingContext<C: Blockchain> {
     pub instrument: bool,
 }
 
-impl<C: Blockchain> MappingContext<C> {
+impl MappingContext {
     pub fn derive_with_empty_block_state(&self) -> Self {
         MappingContext {
             logger: self.logger.cheap_clone(),
             host_exports: self.host_exports.cheap_clone(),
             block_ptr: self.block_ptr.cheap_clone(),
             timestamp: self.timestamp,
-            state: BlockState::new(self.state.entity_cache.store.clone(), Default::default()),
+            state: BlockState::new(
+                self.state.entity_cache.store.clone(),
+                Default::default(),
+                self.state.seq_gen(),
+            ),
             proof_of_indexing: self.proof_of_indexing.cheap_clone(),
             host_fns: self.host_fns.cheap_clone(),
             debug_fork: self.debug_fork.cheap_clone(),
@@ -225,10 +221,24 @@ impl<C: Blockchain> MappingContext<C> {
     }
 }
 
+// See the start_index comment below for more information.
+const GN_START_FUNCTION_NAME: &str = "gn::start";
+
 /// A pre-processed and valid WASM module, ready to be started as a WasmModule.
 pub struct ValidModule {
     pub module: wasmtime::Module,
 
+    /// Pre-linked instance template. Created once at module validation time and reused for every
+    /// trigger instantiation, avoiding the cost of rebuilding the linker (~60 host function
+    /// registrations) and resolving imports on each trigger.
+    pub instance_pre: wasmtime::InstancePre<WasmInstanceData>,
+
+    // Due to our internal architecture we don't want to run the start function at instantiation time,
+    // so we track it separately so that we can run it at an appropriate time.
+    // Since the start function is not an export, we will also create an export for it.
+    // It's an option because start might not be present.
+    pub start_function: Option<String>,
+
     // A wasm import consists of a `module` and a `name`. AS will generate imports such that they
     // have `module` set to the name of the file it is imported from and `name` set to the imported
     // function name or `namespace.function` if inside a namespace. We'd rather not specify names of
@@ -238,16 +248,30 @@ pub struct ValidModule {
     // AS now has an `@external("module", "name")` decorator which would make things cleaner, but
     // the ship has sailed.
     pub import_name_to_modules: BTreeMap<String, Vec<String>>,
+
+    // The timeout for the module.
+    pub timeout: Option<Duration>,
+
+    // Used as a guard to terminate this task dependency.
+    epoch_counter_abort_handle: Option<tokio::task::AbortHandle>,
+
+    /// Cache for asc_type_id results. Maps IndexForAscTypeId to their WASM runtime
+    /// type IDs. Populated lazily on first use; deterministic per compiled module.
+    asc_type_id_cache: RwLock<HashMap<IndexForAscTypeId, u32>>,
 }
 
 impl ValidModule {
     /// Pre-process and validate the module.
-    pub fn new(logger: &Logger, raw_module: &[u8]) -> Result<Self, anyhow::Error> {
+    pub fn new(
+        logger: &Logger,
+        raw_module: &[u8],
+        timeout: Option<Duration>,
+    ) -> Result<Self, anyhow::Error> {
         // Add the gas calls here. Module name "gas" must match. See also
         // e3f03e62-40e4-4f8c-b4a1-d0375cca0b76. We do this by round-tripping the module through
         // parity - injecting gas then serializing again.
         let parity_module = parity_wasm::elements::Module::from_bytes(raw_module)?;
-        let parity_module = match parity_module.parse_names() {
+        let mut parity_module = match parity_module.parse_names() {
             Ok(module) => module,
             Err((errs, module)) => {
                 for (index, err) in errs {
@@ -262,21 +286,42 @@ impl ValidModule {
                 module
             }
         };
-        let parity_module = wasm_instrument::gas_metering::inject(parity_module, &GasRules, "gas")
-            .map_err(|_| anyhow!("Failed to inject gas counter"))?;
+
+        let start_function = parity_module.start_section().map(|index| {
+            let name = GN_START_FUNCTION_NAME.to_string();
+
+            parity_module.clear_start_section();
+            parity_module
+                .export_section_mut()
+                .unwrap()
+                .entries_mut()
+                .push(ExportEntry::new(
+                    name.clone(),
+                    parity_wasm::elements::Internal::Function(index),
+                ));
+
+            name
+        });
+        let backend = wasm_instrument::gas_metering::host_function::Injector::new("gas", "gas");
+        let parity_module =
+            wasm_instrument::gas_metering::inject(parity_module, backend, &GasRules)
+                .map_err(|_| anyhow!("Failed to inject gas counter"))?;
         let raw_module = parity_module.into_bytes()?;
 
-        // We currently use Cranelift as a compilation engine. Cranelift is an optimizing compiler,
-        // but that should not cause determinism issues since it adheres to the Wasm spec. Still we
-        // turn off optional optimizations to be conservative.
+        // We use Cranelift as a compilation engine. Cranelift is an optimizing compiler, but that
+        // should not cause determinism issues since it adheres to the Wasm spec and NaN
+        // canonicalization is enabled below. The optimization level is configurable via
+        // GRAPH_WASM_OPT_LEVEL (default: speed).
         let mut config = wasmtime::Config::new();
-        config.strategy(wasmtime::Strategy::Cranelift).unwrap();
-        config.interruptable(true); // For timeouts.
+        config.strategy(wasmtime::Strategy::Cranelift);
+        config.epoch_interruption(true);
         config.cranelift_nan_canonicalization(true); // For NaN determinism.
-        config.cranelift_opt_level(wasmtime::OptLevel::None);
-        config
-            .max_wasm_stack(ENV_VARS.mappings.max_stack_size)
-            .unwrap(); // Safe because this only panics if size passed is 0.
+        config.cranelift_opt_level(match ENV_VARS.mappings.wasm_opt_level {
+            graph::env::WasmOptLevel::None => wasmtime::OptLevel::None,
+            graph::env::WasmOptLevel::Speed => wasmtime::OptLevel::Speed,
+            graph::env::WasmOptLevel::SpeedAndSize => wasmtime::OptLevel::SpeedAndSize,
+        });
+        config.max_wasm_stack(ENV_VARS.mappings.max_stack_size);
 
         let engine = &wasmtime::Engine::new(&config)?;
         let module = wasmtime::Module::from_binary(engine, &raw_module)?;
@@ -286,7 +331,7 @@ impl ValidModule {
         // Unwrap: Module linking is disabled.
         for (name, module) in module
             .imports()
-            .map(|import| (import.name().unwrap(), import.module()))
+            .map(|import| (import.name(), import.module()))
         {
             import_name_to_modules
                 .entry(name.to_string())
@@ -294,9 +339,50 @@ impl ValidModule {
                 .push(module.to_string());
         }
 
+        let mut epoch_counter_abort_handle = None;
+        if let Some(timeout) = timeout {
+            let engine = engine.clone();
+
+            // The epoch counter task will perpetually increment the epoch every `timeout` seconds.
+            // Timeouts on instantiated modules will trigger on epoch deltas.
+            // Note: The epoch is an u64 so it will never overflow.
+            // See also: runtime-timeouts
+            let epoch_counter = async move {
+                loop {
+                    tokio::time::sleep(timeout).await;
+                    engine.increment_epoch();
+                }
+            };
+            epoch_counter_abort_handle = Some(graph::spawn(epoch_counter).abort_handle());
+        }
+
+        let linker = crate::module::build_linker(engine, &import_name_to_modules)?;
+        let instance_pre = linker.instantiate_pre(&module)?;
+
         Ok(ValidModule {
             module,
+            instance_pre,
             import_name_to_modules,
+            start_function,
+            timeout,
+            epoch_counter_abort_handle,
+            asc_type_id_cache: RwLock::new(HashMap::new()),
         })
     }
+
+    pub fn get_cached_type_id(&self, idx: IndexForAscTypeId) -> Option<u32> {
+        self.asc_type_id_cache.read().get(&idx).copied()
+    }
+
+    pub fn cache_type_id(&self, idx: IndexForAscTypeId, type_id: u32) {
+        self.asc_type_id_cache.write().insert(idx, type_id);
+    }
+}
+
+impl Drop for ValidModule {
+    fn drop(&mut self) {
+        if let Some(handle) = self.epoch_counter_abort_handle.take() {
+            handle.abort();
+        }
+    }
 }
diff --git a/runtime/wasm/src/module/context.rs b/runtime/wasm/src/module/context.rs
new file mode 100644
index 00000000000..70d65489304
--- /dev/null
+++ b/runtime/wasm/src/module/context.rs
@@ -0,0 +1,1284 @@
+use graph::data::value::Word;
+use graph::runtime::gas;
+use graph::util::lfu_cache::LfuCache;
+use std::collections::HashMap;
+use wasmtime::AsContext;
+use wasmtime::AsContextMut;
+use wasmtime::StoreContextMut;
+
+use std::sync::Arc;
+use std::time::Instant;
+
+use anyhow::Error;
+use graph::components::store::{GetScope, SeqGenerator};
+use never::Never;
+
+use crate::HostExports;
+use crate::asc_abi::class::*;
+use graph::data::store;
+
+use crate::ExperimentalFeatures;
+use crate::asc_abi::class::AscEntity;
+use crate::asc_abi::class::AscString;
+use crate::mapping::MappingContext;
+use crate::mapping::ValidModule;
+use graph::prelude::*;
+use graph::runtime::AscPtr;
+use graph::runtime::{DeterministicHostError, HostExportError, asc_new, gas::GasCounter};
+
+use super::AscHeapCtx;
+use super::asc_get;
+
+pub(crate) struct WasmInstanceContext<'a> {
+    inner: StoreContextMut<'a, WasmInstanceData>,
+}
+
+impl WasmInstanceContext<'_> {
+    pub fn new(ctx: &mut impl AsContextMut<Data = WasmInstanceData>) -> WasmInstanceContext<'_> {
+        WasmInstanceContext {
+            inner: ctx.as_context_mut(),
+        }
+    }
+
+    pub fn as_ref(&self) -> &WasmInstanceData {
+        self.inner.data()
+    }
+
+    pub fn as_mut(&mut self) -> &mut WasmInstanceData {
+        self.inner.data_mut()
+    }
+
+    pub fn asc_heap(&self) -> &Arc<AscHeapCtx> {
+        self.as_ref().asc_heap()
+    }
+
+    pub fn suspend_timeout(&mut self) {
+        // See also: runtime-timeouts
+        self.inner.set_epoch_deadline(u64::MAX);
+    }
+
+    pub fn start_timeout(&mut self) {
+        // See also: runtime-timeouts
+        self.inner.set_epoch_deadline(2);
+    }
+}
+
+impl AsContext for WasmInstanceContext<'_> {
+    type Data = WasmInstanceData;
+
+    fn as_context(&self) -> wasmtime::StoreContext<'_, Self::Data> {
+        self.inner.as_context()
+    }
+}
+
+impl AsContextMut for WasmInstanceContext<'_> {
+    fn as_context_mut(&mut self) -> wasmtime::StoreContextMut<'_, Self::Data> {
+        self.inner.as_context_mut()
+    }
+}
+
+pub struct WasmInstanceData {
+    pub ctx: MappingContext,
+    pub valid_module: Arc<ValidModule>,
+    pub host_metrics: Arc<HostMetrics>,
+
+    // Per-trigger gas counter, shared via Arc so clones refer to the same counter.
+    pub gas: GasCounter,
+
+    // A trap ocurred due to a possible reorg detection.
+    pub possible_reorg: bool,
+
+    // A host export trap ocurred for a deterministic reason.
+    pub deterministic_host_trap: bool,
+
+    pub(crate) experimental_features: ExperimentalFeatures,
+
+    // This option is needed to break the cyclic dependency between, instance, store, and context.
+    // during execution it should always be populated.
+    asc_heap: Option<Arc<AscHeapCtx>>,
+}
+
+impl WasmInstanceData {
+    pub fn from_instance(
+        ctx: MappingContext,
+        valid_module: Arc<ValidModule>,
+        host_metrics: Arc<HostMetrics>,
+        gas: GasCounter,
+        experimental_features: ExperimentalFeatures,
+    ) -> Self {
+        WasmInstanceData {
+            asc_heap: None,
+            ctx,
+            valid_module,
+            host_metrics,
+            gas,
+            possible_reorg: false,
+            deterministic_host_trap: false,
+            experimental_features,
+        }
+    }
+
+    pub fn set_asc_heap(&mut self, asc_heap: Arc<AscHeapCtx>) {
+        self.asc_heap = Some(asc_heap);
+    }
+
+    pub fn asc_heap(&self) -> &Arc<AscHeapCtx> {
+        self.asc_heap.as_ref().expect("asc_heap not set")
+    }
+
+    pub fn take_state(mut self) -> BlockState {
+        let state = &mut self.ctx.state;
+
+        std::mem::replace(
+            state,
+            BlockState::new(
+                state.entity_cache.store.cheap_clone(),
+                LfuCache::default(),
+                SeqGenerator::new(self.ctx.block_ptr.number),
+            ),
+        )
+    }
+}
+
+impl WasmInstanceContext<'_> {
+    async fn store_get_scoped(
+        &mut self,
+        gas: &GasCounter,
+        entity_ptr: AscPtr<AscString>,
+        id_ptr: AscPtr<AscString>,
+        scope: GetScope,
+    ) -> Result<AscPtr<AscEntity>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let _timer = self
+            .as_ref()
+            .host_metrics
+            .cheap_clone()
+            .time_host_fn_execution_region("store_get");
+
+        let entity_type: String = asc_get(self, entity_ptr, gas)?;
+        let id: String = asc_get(self, id_ptr, gas)?;
+        let entity_option = host_exports
+            .store_get(
+                &mut self.as_mut().ctx.state,
+                entity_type.clone(),
+                id.clone(),
+                gas,
+                scope,
+            )
+            .await?;
+
+        if self.as_ref().ctx.instrument {
+            debug!(self.as_ref().ctx.logger, "store_get";
+                    "type" => &entity_type,
+                    "id" => &id,
+                    "found" => entity_option.is_some());
+        }
+        let host_metrics = self.as_ref().host_metrics.cheap_clone();
+        let debug_fork = self.as_ref().ctx.debug_fork.cheap_clone();
+
+        let ret = match entity_option {
+            Some(entity) => {
+                let _section = host_metrics.stopwatch.start_section("store_get_asc_new");
+                asc_new(self, &entity.sorted_ref(), gas).await?
+            }
+            None => match &debug_fork {
+                Some(fork) => {
+                    let entity_option = fork.fetch(entity_type, id).await.map_err(|e| {
+                        HostExportError::Unknown(anyhow!(
+                            "store_get: failed to fetch entity from the debug fork: {}",
+                            e
+                        ))
+                    })?;
+                    match entity_option {
+                        Some(entity) => {
+                            let _section =
+                                host_metrics.stopwatch.start_section("store_get_asc_new");
+                            let entity = asc_new(self, &entity.sorted(), gas).await?;
+                            self.store_set(gas, entity_ptr, id_ptr, entity).await?;
+                            entity
+                        }
+                        None => AscPtr::null(),
+                    }
+                }
+                None => AscPtr::null(),
+            },
+        };
+
+        Ok(ret)
+    }
+}
+
+// Implementation of externals.
+impl WasmInstanceContext<'_> {
+    /// function abort(message?: string | null, fileName?: string | null, lineNumber?: u32, columnNumber?: u32): void
+    /// Always returns a trap.
+    pub async fn abort(
+        &mut self,
+        gas: &GasCounter,
+        message_ptr: AscPtr<AscString>,
+        file_name_ptr: AscPtr<AscString>,
+        line_number: u32,
+        column_number: u32,
+    ) -> Result<Never, DeterministicHostError> {
+        let message = match message_ptr.is_null() {
+            false => Some(asc_get(self, message_ptr, gas)?),
+            true => None,
+        };
+        let file_name = match file_name_ptr.is_null() {
+            false => Some(asc_get(self, file_name_ptr, gas)?),
+            true => None,
+        };
+        let line_number = match line_number {
+            0 => None,
+            _ => Some(line_number),
+        };
+        let column_number = match column_number {
+            0 => None,
+            _ => Some(column_number),
+        };
+
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        host_exports.abort(
+            message,
+            file_name,
+            line_number,
+            column_number,
+            gas,
+            &mut ctx.state,
+        )
+    }
+
+    /// function store.set(entity: string, id: string, data: Entity): void
+    pub async fn store_set(
+        &mut self,
+        gas: &GasCounter,
+        entity_ptr: AscPtr<AscString>,
+        id_ptr: AscPtr<AscString>,
+        data_ptr: AscPtr<AscEntity>,
+    ) -> Result<(), HostExportError> {
+        let stopwatch = self.as_ref().host_metrics.stopwatch.cheap_clone();
+        let logger = self.as_ref().ctx.logger.cheap_clone();
+        stopwatch.start_section("host_export_store_set__wasm_instance_context_store_set");
+
+        let entity: String = asc_get(self, entity_ptr, gas)?;
+        let id: String = asc_get(self, id_ptr, gas)?;
+        let data = asc_get(self, data_ptr, gas)?;
+
+        if self.as_ref().ctx.instrument {
+            debug!(self.as_ref().ctx.logger, "store_set";
+                    "type" => &entity,
+                    "id" => &id);
+        }
+
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        host_exports
+            .store_set(
+                &logger,
+                &mut ctx.state,
+                &ctx.proof_of_indexing,
+                ctx.timestamp,
+                entity,
+                id,
+                data,
+                &stopwatch,
+                gas,
+            )
+            .await?;
+
+        Ok(())
+    }
+
+    /// function store.remove(entity: string, id: string): void
+    pub async fn store_remove(
+        &mut self,
+        gas: &GasCounter,
+        entity_ptr: AscPtr<AscString>,
+        id_ptr: AscPtr<AscString>,
+    ) -> Result<(), HostExportError> {
+        let logger = self.as_ref().ctx.logger.cheap_clone();
+
+        let entity: String = asc_get(self, entity_ptr, gas)?;
+        let id: String = asc_get(self, id_ptr, gas)?;
+        if self.as_ref().ctx.instrument {
+            debug!(self.as_ref().ctx.logger, "store_remove";
+                    "type" => &entity,
+                    "id" => &id);
+        }
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        host_exports.store_remove(
+            &logger,
+            &mut ctx.state,
+            &ctx.proof_of_indexing,
+            entity,
+            id,
+            gas,
+        )
+    }
+
+    /// function store.get(entity: string, id: string): Entity | null
+    pub async fn store_get(
+        &mut self,
+        gas: &GasCounter,
+        entity_ptr: AscPtr<AscString>,
+        id_ptr: AscPtr<AscString>,
+    ) -> Result<AscPtr<AscEntity>, HostExportError> {
+        self.store_get_scoped(gas, entity_ptr, id_ptr, GetScope::Store)
+            .await
+    }
+
+    /// function store.get_in_block(entity: string, id: string): Entity | null
+    pub async fn store_get_in_block(
+        &mut self,
+        gas: &GasCounter,
+        entity_ptr: AscPtr<AscString>,
+        id_ptr: AscPtr<AscString>,
+    ) -> Result<AscPtr<AscEntity>, HostExportError> {
+        self.store_get_scoped(gas, entity_ptr, id_ptr, GetScope::InBlock)
+            .await
+    }
+
+    /// function store.loadRelated(entity_type: string, id: string, field: string): Array<Entity>
+    pub async fn store_load_related(
+        &mut self,
+
+        gas: &GasCounter,
+        entity_type_ptr: AscPtr<AscString>,
+        id_ptr: AscPtr<AscString>,
+        field_ptr: AscPtr<AscString>,
+    ) -> Result<AscPtr<Array<AscPtr<AscEntity>>>, HostExportError> {
+        let entity_type: String = asc_get(self, entity_type_ptr, gas)?;
+        let id: String = asc_get(self, id_ptr, gas)?;
+        let field: String = asc_get(self, field_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let entities = host_exports
+            .store_load_related(
+                &mut self.as_mut().ctx.state,
+                entity_type.clone(),
+                id.clone(),
+                field.clone(),
+                gas,
+            )
+            .await?;
+
+        let entities: Vec<Vec<(Word, Value)>> =
+            entities.into_iter().map(|entity| entity.sorted()).collect();
+        let ret = asc_new(self, &entities, gas).await?;
+        Ok(ret)
+    }
+
+    /// function typeConversion.bytesToString(bytes: Bytes): string
+    pub async fn bytes_to_string(
+        &mut self,
+        gas: &GasCounter,
+        bytes_ptr: AscPtr<Uint8Array>,
+    ) -> Result<AscPtr<AscString>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let bytes = asc_get(self, bytes_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+
+        let string = host_exports.bytes_to_string(&ctx.logger, bytes, gas, &mut ctx.state)?;
+        asc_new(self, &string, gas).await
+    }
+    /// Converts bytes to a hex string.
+    /// function typeConversion.bytesToHex(bytes: Bytes): string
+    /// References:
+    /// https://godoc.org/github.com/ethereum/go-ethereum/common/hexutil#hdr-Encoding_Rules
+    /// https://github.com/ethereum/web3.js/blob/f98fe1462625a6c865125fecc9cb6b414f0a5e83/packages/web3-utils/src/utils.js#L283
+    pub async fn bytes_to_hex(
+        &mut self,
+        gas: &GasCounter,
+        bytes_ptr: AscPtr<Uint8Array>,
+    ) -> Result<AscPtr<AscString>, HostExportError> {
+        let bytes: Vec<u8> = asc_get(self, bytes_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+
+        HostExports::track_gas_and_ops(
+            gas,
+            &mut ctx.state,
+            gas::DEFAULT_GAS_OP.with_args(gas::complexity::Size, &bytes),
+            "bytes_to_hex",
+        )?;
+
+        // Even an empty string must be prefixed with `0x`.
+        // Encodes each byte as a two hex digits.
+        let hex = format!("0x{}", hex::encode(bytes));
+        asc_new(self, &hex, gas).await
+    }
+
+    /// function typeConversion.bigIntToString(n: Uint8Array): string
+    pub async fn big_int_to_string(
+        &mut self,
+        gas: &GasCounter,
+        big_int_ptr: AscPtr<AscBigInt>,
+    ) -> Result<AscPtr<AscString>, HostExportError> {
+        let n: BigInt = asc_get(self, big_int_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+        HostExports::track_gas_and_ops(
+            gas,
+            &mut ctx.state,
+            gas::DEFAULT_GAS_OP.with_args(gas::complexity::Mul, (&n, &n)),
+            "big_int_to_string",
+        )?;
+        asc_new(self, &n.to_string(), gas).await
+    }
+
+    /// function bigInt.fromString(x: string): BigInt
+    pub async fn big_int_from_string(
+        &mut self,
+        gas: &GasCounter,
+        string_ptr: AscPtr<AscString>,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let s = asc_get(self, string_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports.big_int_from_string(s, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function typeConversion.bigIntToHex(n: Uint8Array): string
+    pub async fn big_int_to_hex(
+        &mut self,
+        gas: &GasCounter,
+        big_int_ptr: AscPtr<AscBigInt>,
+    ) -> Result<AscPtr<AscString>, HostExportError> {
+        let n: BigInt = asc_get(self, big_int_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let hex = host_exports.big_int_to_hex(n, gas, &mut ctx.state)?;
+        asc_new(self, &hex, gas).await
+    }
+
+    /// function typeConversion.stringToH160(s: String): H160
+    pub async fn string_to_h160(
+        &mut self,
+        gas: &GasCounter,
+        str_ptr: AscPtr<AscString>,
+    ) -> Result<AscPtr<AscH160>, HostExportError> {
+        let s: String = asc_get(self, str_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let h160 = host_exports.string_to_address(&s, gas, &mut ctx.state)?;
+        asc_new(self, &h160, gas).await
+    }
+
+    /// function json.fromBytes(bytes: Bytes): JSONValue
+    pub async fn json_from_bytes(
+        &mut self,
+        gas: &GasCounter,
+        bytes_ptr: AscPtr<Uint8Array>,
+    ) -> Result<AscPtr<AscEnum<JsonValueKind>>, HostExportError> {
+        let bytes: Vec<u8> = asc_get(self, bytes_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports
+            .json_from_bytes(&bytes, gas, &mut ctx.state)
+            .with_context(|| {
+                format!(
+                    "Failed to parse JSON from byte array. Bytes (truncated to 1024 chars): `{:?}`",
+                    &bytes[..bytes.len().min(1024)],
+                )
+            })
+            .map_err(DeterministicHostError::from)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function json.try_fromBytes(bytes: Bytes): Result<JSONValue, boolean>
+    pub async fn json_try_from_bytes(
+        &mut self,
+        gas: &GasCounter,
+        bytes_ptr: AscPtr<Uint8Array>,
+    ) -> Result<AscPtr<AscResult<AscPtr<AscEnum<JsonValueKind>>, bool>>, HostExportError> {
+        let bytes: Vec<u8> = asc_get(self, bytes_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports
+            .json_from_bytes(&bytes, gas, &mut ctx.state)
+            .map_err(|e| {
+                warn!(
+                    &self.as_ref().ctx.logger,
+                    "Failed to parse JSON from byte array";
+                    "bytes" => format!("{:?}", bytes),
+                    "error" => format!("{}", e)
+                );
+
+                // Map JSON errors to boolean to match the `Result<JSONValue, boolean>`
+                // result type expected by mappings
+                true
+            });
+        asc_new(self, &result, gas).await
+    }
+
+    /// function ipfs.cat(link: String): Bytes
+    pub async fn ipfs_cat(
+        &mut self,
+        gas: &GasCounter,
+        link_ptr: AscPtr<AscString>,
+    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
+        // Note on gas: There is no gas costing for the ipfs call itself,
+        // since it's not enabled on the network.
+
+        if !self
+            .as_ref()
+            .experimental_features
+            .allow_non_deterministic_ipfs
+        {
+            return Err(HostExportError::Deterministic(anyhow!(
+                "`ipfs.cat` is deprecated. Improved support for IPFS will be added in the future"
+            )));
+        }
+
+        let link = asc_get(self, link_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let logger = self.as_ref().ctx.logger.cheap_clone();
+        let ipfs_res = host_exports.ipfs_cat(&logger, link).await;
+        let logger = self.as_ref().ctx.logger.cheap_clone();
+        match ipfs_res {
+            Ok(bytes) => asc_new(self, &*bytes, gas).await,
+
+            // Return null in case of error.
+            Err(e) => {
+                info!(&logger, "Failed ipfs.cat, returning `null`";
+                                    "link" => asc_get::<String, _, _>( self, link_ptr, gas)?,
+                                    "error" => e.to_string());
+                Ok(AscPtr::null())
+            }
+        }
+    }
+
+    /// function ipfs.getBlock(link: String): Bytes
+    pub async fn ipfs_get_block(
+        &mut self,
+        gas: &GasCounter,
+        link_ptr: AscPtr<AscString>,
+    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
+        // Note on gas: There is no gas costing for the ipfs call itself,
+        // since it's not enabled on the network.
+
+        if !self
+            .as_ref()
+            .experimental_features
+            .allow_non_deterministic_ipfs
+        {
+            return Err(HostExportError::Deterministic(anyhow!(
+                "`ipfs.getBlock` is deprecated. Improved support for IPFS will be added in the future"
+            )));
+        }
+
+        let link = asc_get(self, link_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ipfs_res = host_exports
+            .ipfs_get_block(&self.as_ref().ctx.logger, link)
+            .await;
+        match ipfs_res {
+            Ok(bytes) => asc_new(self, &*bytes, gas).await,
+
+            // Return null in case of error.
+            Err(e) => {
+                info!(&self.as_ref().ctx.logger, "Failed ipfs.getBlock, returning `null`";
+                                    "link" => asc_get::<String, _, _>( self, link_ptr, gas)?,
+                                    "error" => e.to_string());
+                Ok(AscPtr::null())
+            }
+        }
+    }
+
+    /// function ipfs.map(link: String, callback: String, flags: String[]): void
+    pub async fn ipfs_map(
+        &mut self,
+        gas: &GasCounter,
+        link_ptr: AscPtr<AscString>,
+        callback: AscPtr<AscString>,
+        user_data: AscPtr<AscEnum<StoreValueKind>>,
+        flags: AscPtr<Array<AscPtr<AscString>>>,
+    ) -> Result<(), HostExportError> {
+        // Note on gas:
+        // Ideally we would consume gas the same as ipfs_cat and then share
+        // gas across the spawned modules for callbacks.
+
+        if !self
+            .as_ref()
+            .experimental_features
+            .allow_non_deterministic_ipfs
+        {
+            return Err(HostExportError::Deterministic(anyhow!(
+                "`ipfs.map` is deprecated. Improved support for IPFS will be added in the future"
+            )));
+        }
+
+        let link: String = asc_get(self, link_ptr, gas)?;
+        let callback: String = asc_get(self, callback, gas)?;
+        let user_data: store::Value = asc_get(self, user_data, gas)?;
+
+        let flags = asc_get(self, flags, gas)?;
+
+        // Pause the timeout while running ipfs_map, and resume it when done.
+        self.suspend_timeout();
+        let start_time = Instant::now();
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let output_states = host_exports
+            .ipfs_map(self.as_ref(), link.clone(), &callback, user_data, flags)
+            .await?;
+        self.start_timeout();
+
+        debug!(
+            &self.as_ref().ctx.logger,
+            "Successfully processed file with ipfs.map";
+            "link" => &link,
+            "callback" => &*callback,
+            "n_calls" => output_states.len(),
+            "time" => format!("{}ms", start_time.elapsed().as_millis())
+        );
+        for output_state in output_states {
+            self.as_mut().ctx.state.extend(output_state);
+        }
+
+        Ok(())
+    }
+
+    /// Expects a decimal string.
+    /// function json.toI64(json: String): i64
+    pub async fn json_to_i64(
+        &mut self,
+        gas: &GasCounter,
+        json_ptr: AscPtr<AscString>,
+    ) -> Result<i64, DeterministicHostError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let json = asc_get(self, json_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+        host_exports.json_to_i64(json, gas, &mut ctx.state)
+    }
+
+    /// Expects a decimal string.
+    /// function json.toU64(json: String): u64
+    pub async fn json_to_u64(
+        &mut self,
+
+        gas: &GasCounter,
+        json_ptr: AscPtr<AscString>,
+    ) -> Result<u64, DeterministicHostError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let json: String = asc_get(self, json_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+        host_exports.json_to_u64(json, gas, &mut ctx.state)
+    }
+
+    /// Expects a decimal string.
+    /// function json.toF64(json: String): f64
+    pub async fn json_to_f64(
+        &mut self,
+        gas: &GasCounter,
+        json_ptr: AscPtr<AscString>,
+    ) -> Result<f64, DeterministicHostError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let json = asc_get(self, json_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+        host_exports.json_to_f64(json, gas, &mut ctx.state)
+    }
+
+    /// Expects a decimal string.
+    /// function json.toBigInt(json: String): BigInt
+    pub async fn json_to_big_int(
+        &mut self,
+
+        gas: &GasCounter,
+        json_ptr: AscPtr<AscString>,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let json = asc_get(self, json_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+        let big_int = host_exports.json_to_big_int(json, gas, &mut ctx.state)?;
+        asc_new(self, &*big_int, gas).await
+    }
+
+    /// function crypto.keccak256(input: Bytes): Bytes
+    pub async fn crypto_keccak_256(
+        &mut self,
+
+        gas: &GasCounter,
+        input_ptr: AscPtr<Uint8Array>,
+    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let input = asc_get(self, input_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+
+        let input = host_exports.crypto_keccak_256(input, gas, &mut ctx.state)?;
+        asc_new(self, input.as_ref(), gas).await
+    }
+
+    /// function bigInt.plus(x: BigInt, y: BigInt): BigInt
+    pub async fn big_int_plus(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        y_ptr: AscPtr<AscBigInt>,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_int_plus(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigInt.minus(x: BigInt, y: BigInt): BigInt
+    pub async fn big_int_minus(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        y_ptr: AscPtr<AscBigInt>,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_int_minus(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigInt.times(x: BigInt, y: BigInt): BigInt
+    pub async fn big_int_times(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        y_ptr: AscPtr<AscBigInt>,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_int_times(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigInt.dividedBy(x: BigInt, y: BigInt): BigInt
+    pub async fn big_int_divided_by(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        y_ptr: AscPtr<AscBigInt>,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports.big_int_divided_by(x, y, gas, &mut ctx.state)?;
+
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigInt.dividedByDecimal(x: BigInt, y: BigDecimal): BigDecimal
+    pub async fn big_int_divided_by_decimal(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        y_ptr: AscPtr<AscBigDecimal>,
+    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
+        let x = BigDecimal::new(asc_get(self, x_ptr, gas)?, 0);
+
+        let y = asc_get(self, y_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_decimal_divided_by(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigInt.mod(x: BigInt, y: BigInt): BigInt
+    pub async fn big_int_mod(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        y_ptr: AscPtr<AscBigInt>,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_int_mod(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigInt.pow(x: BigInt, exp: u8): BigInt
+    pub async fn big_int_pow(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        exp: u32,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let exp = u8::try_from(exp).map_err(|e| DeterministicHostError::from(Error::from(e)))?;
+        let x = asc_get(self, x_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports.big_int_pow(x, exp, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigInt.bitOr(x: BigInt, y: BigInt): BigInt
+    pub async fn big_int_bit_or(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        y_ptr: AscPtr<AscBigInt>,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_int_bit_or(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigInt.bitAnd(x: BigInt, y: BigInt): BigInt
+    pub async fn big_int_bit_and(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        y_ptr: AscPtr<AscBigInt>,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_int_bit_and(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigInt.leftShift(x: BigInt, bits: u8): BigInt
+    pub async fn big_int_left_shift(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        bits: u32,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let bits = u8::try_from(bits).map_err(|e| DeterministicHostError::from(Error::from(e)))?;
+        let x = asc_get(self, x_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports.big_int_left_shift(x, bits, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigInt.rightShift(x: BigInt, bits: u8): BigInt
+    pub async fn big_int_right_shift(
+        &mut self,
+
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigInt>,
+        bits: u32,
+    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
+        let bits = u8::try_from(bits).map_err(|e| DeterministicHostError::from(Error::from(e)))?;
+        let x = asc_get(self, x_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports.big_int_right_shift(x, bits, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function typeConversion.bytesToBase58(bytes: Bytes): string
+    pub async fn bytes_to_base58(
+        &mut self,
+
+        gas: &GasCounter,
+        bytes_ptr: AscPtr<Uint8Array>,
+    ) -> Result<AscPtr<AscString>, HostExportError> {
+        let bytes = asc_get(self, bytes_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports.bytes_to_base58(bytes, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigDecimal.toString(x: BigDecimal): string
+    pub async fn big_decimal_to_string(
+        &mut self,
+
+        gas: &GasCounter,
+        big_decimal_ptr: AscPtr<AscBigDecimal>,
+    ) -> Result<AscPtr<AscString>, HostExportError> {
+        let x = asc_get(self, big_decimal_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports.big_decimal_to_string(x, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigDecimal.fromString(x: string): BigDecimal
+    pub async fn big_decimal_from_string(
+        &mut self,
+
+        gas: &GasCounter,
+        string_ptr: AscPtr<AscString>,
+    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
+        let s = asc_get(self, string_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports.big_decimal_from_string(s, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigDecimal.plus(x: BigDecimal, y: BigDecimal): BigDecimal
+    pub async fn big_decimal_plus(
+        &mut self,
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigDecimal>,
+        y_ptr: AscPtr<AscBigDecimal>,
+    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_decimal_plus(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigDecimal.minus(x: BigDecimal, y: BigDecimal): BigDecimal
+    pub async fn big_decimal_minus(
+        &mut self,
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigDecimal>,
+        y_ptr: AscPtr<AscBigDecimal>,
+    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_decimal_minus(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigDecimal.times(x: BigDecimal, y: BigDecimal): BigDecimal
+    pub async fn big_decimal_times(
+        &mut self,
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigDecimal>,
+        y_ptr: AscPtr<AscBigDecimal>,
+    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_decimal_times(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigDecimal.dividedBy(x: BigDecimal, y: BigDecimal): BigDecimal
+    pub async fn big_decimal_divided_by(
+        &mut self,
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigDecimal>,
+        y_ptr: AscPtr<AscBigDecimal>,
+    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports.big_decimal_divided_by(x, y, gas, &mut ctx.state)?;
+        asc_new(self, &result, gas).await
+    }
+
+    /// function bigDecimal.equals(x: BigDecimal, y: BigDecimal): bool
+    pub async fn big_decimal_equals(
+        &mut self,
+        gas: &GasCounter,
+        x_ptr: AscPtr<AscBigDecimal>,
+        y_ptr: AscPtr<AscBigDecimal>,
+    ) -> Result<bool, HostExportError> {
+        let x = asc_get(self, x_ptr, gas)?;
+        let y = asc_get(self, y_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        host_exports.big_decimal_equals(x, y, gas, &mut ctx.state)
+    }
+
+    /// function dataSource.create(name: string, params: Array<string>): void
+    pub async fn data_source_create(
+        &mut self,
+        gas: &GasCounter,
+        name_ptr: AscPtr<AscString>,
+        params_ptr: AscPtr<Array<AscPtr<AscString>>>,
+    ) -> Result<(), HostExportError> {
+        let logger = self.as_ref().ctx.logger.cheap_clone();
+        let block_number = self.as_ref().ctx.block_ptr.number;
+        let name: String = asc_get(self, name_ptr, gas)?;
+        let params: Vec<String> = asc_get(self, params_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        host_exports.data_source_create(
+            &logger,
+            &mut self.as_mut().ctx.state,
+            name,
+            params,
+            None,
+            block_number,
+            gas,
+        )
+    }
+
+    /// function createWithContext(name: string, params: Array<string>, context: DataSourceContext): void
+    pub async fn data_source_create_with_context(
+        &mut self,
+        gas: &GasCounter,
+        name_ptr: AscPtr<AscString>,
+        params_ptr: AscPtr<Array<AscPtr<AscString>>>,
+        context_ptr: AscPtr<AscEntity>,
+    ) -> Result<(), HostExportError> {
+        let logger = self.as_ref().ctx.logger.cheap_clone();
+        let block_number = self.as_ref().ctx.block_ptr.number;
+        let name: String = asc_get(self, name_ptr, gas)?;
+        let params: Vec<String> = asc_get(self, params_ptr, gas)?;
+        let context: HashMap<_, _> = asc_get(self, context_ptr, gas)?;
+        let context = DataSourceContext::from(context);
+
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        host_exports.data_source_create(
+            &logger,
+            &mut self.as_mut().ctx.state,
+            name,
+            params,
+            Some(context),
+            block_number,
+            gas,
+        )
+    }
+
+    /// function dataSource.address(): Bytes
+    pub async fn data_source_address(
+        &mut self,
+        gas: &GasCounter,
+    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let addr = host_exports.data_source_address(gas, &mut ctx.state)?;
+        asc_new(self, addr.as_slice(), gas).await
+    }
+
+    /// function dataSource.network(): String
+    pub async fn data_source_network(
+        &mut self,
+        gas: &GasCounter,
+    ) -> Result<AscPtr<AscString>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let data_source_network = host_exports.data_source_network(gas, &mut ctx.state)?;
+        asc_new(self, &data_source_network, gas).await
+    }
+
+    /// function dataSource.context(): DataSourceContext
+    pub async fn data_source_context(
+        &mut self,
+        gas: &GasCounter,
+    ) -> Result<AscPtr<AscEntity>, HostExportError> {
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let ds_ctx = &host_exports
+            .data_source_context(gas, &mut ctx.state)?
+            .map(|e| e.sorted())
+            .unwrap_or(vec![]);
+
+        asc_new(self, &ds_ctx, gas).await
+    }
+
+    pub async fn ens_name_by_hash(
+        &mut self,
+        gas: &GasCounter,
+        hash_ptr: AscPtr<AscString>,
+    ) -> Result<AscPtr<AscString>, HostExportError> {
+        let hash: String = asc_get(self, hash_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let name = host_exports
+            .ens_name_by_hash(&hash, gas, &mut ctx.state)
+            .await?;
+        if name.is_none() && self.as_ref().ctx.host_exports.is_ens_data_empty().await? {
+            return Err(anyhow!(
+                "Missing ENS data: see https://github.com/graphprotocol/ens-rainbow"
+            )
+            .into());
+        }
+
+        // map `None` to `null`, and `Some(s)` to a runtime string
+        match name {
+            Some(name) => asc_new(self, &*name, gas).await,
+            None => Ok(AscPtr::null()),
+        }
+    }
+
+    pub async fn log_log(
+        &mut self,
+        gas: &GasCounter,
+        level: u32,
+        msg: AscPtr<AscString>,
+    ) -> Result<(), DeterministicHostError> {
+        let level = LogLevel::from(level).into();
+        let msg: String = asc_get(self, msg, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        host_exports.log_log(&ctx.mapping_logger, level, msg, gas, &mut ctx.state)
+    }
+
+    /// function encode(token: ethereum.Value): Bytes | null
+    pub async fn ethereum_encode(
+        &mut self,
+        gas: &GasCounter,
+        token_ptr: AscPtr<AscEnum<EthereumValueKind>>,
+    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
+        let token = asc_get(self, token_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let data = host_exports.ethereum_encode(token, gas, &mut ctx.state);
+        // return `null` if it fails
+        match data {
+            Ok(bytes) => asc_new(self, &*bytes, gas).await,
+            Err(_) => Ok(AscPtr::null()),
+        }
+    }
+
+    /// function decode(types: String, data: Bytes): ethereum.Value | null
+    pub async fn ethereum_decode(
+        &mut self,
+        gas: &GasCounter,
+        types_ptr: AscPtr<AscString>,
+        data_ptr: AscPtr<Uint8Array>,
+    ) -> Result<AscPtr<AscEnum<EthereumValueKind>>, HostExportError> {
+        let types = asc_get(self, types_ptr, gas)?;
+        let data = asc_get(self, data_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports.ethereum_decode(types, data, gas, &mut ctx.state);
+
+        // return `null` if it fails
+        match result {
+            Ok(token) => asc_new(self, &token, gas).await,
+            Err(_) => Ok(AscPtr::null()),
+        }
+    }
+
+    /// function decodeParams(types: String, data: Bytes): ethereum.Value | null
+    pub async fn ethereum_decode_params(
+        &mut self,
+        gas: &GasCounter,
+        types_ptr: AscPtr<AscString>,
+        data_ptr: AscPtr<Uint8Array>,
+    ) -> Result<AscPtr<AscEnum<EthereumValueKind>>, HostExportError> {
+        let types = asc_get(self, types_ptr, gas)?;
+        let data = asc_get(self, data_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+        let result = host_exports.ethereum_decode_params(types, data, gas, &mut ctx.state);
+
+        // return `null` if it fails
+        match result {
+            Ok(token) => asc_new(self, &token, gas).await,
+            Err(_) => Ok(AscPtr::null()),
+        }
+    }
+
+    /// function arweave.transactionData(txId: string): Bytes | null
+    pub async fn arweave_transaction_data(
+        &self,
+        _gas: &GasCounter,
+        _tx_id: AscPtr<AscString>,
+    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
+        Err(HostExportError::Deterministic(anyhow!(
+            "`arweave.transactionData` has been removed."
+        )))
+    }
+
+    /// function box.profile(address: string): JSONValue | null
+    pub async fn box_profile(
+        &self,
+        _gas: &GasCounter,
+        _address: AscPtr<AscString>,
+    ) -> Result<AscPtr<AscJson>, HostExportError> {
+        Err(HostExportError::Deterministic(anyhow!(
+            "`box.profile` has been removed."
+        )))
+    }
+
+    /// function yaml.fromBytes(bytes: Bytes): YAMLValue
+    pub async fn yaml_from_bytes(
+        &mut self,
+        gas: &GasCounter,
+        bytes_ptr: AscPtr<Uint8Array>,
+    ) -> Result<AscPtr<AscEnum<YamlValueKind>>, HostExportError> {
+        let bytes: Vec<u8> = asc_get(self, bytes_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        let yaml_value = host_exports
+            .yaml_from_bytes(&bytes, gas, &mut ctx.state)
+            .inspect_err(|_| {
+                debug!(
+                    &self.as_ref().ctx.logger,
+                    "Failed to parse YAML from byte array";
+                    "bytes" => truncate_yaml_bytes_for_logging(&bytes),
+                );
+            })?;
+
+        asc_new(self, &yaml_value, gas).await
+    }
+
+    /// function yaml.try_fromBytes(bytes: Bytes): Result<YAMLValue, bool>
+    pub async fn yaml_try_from_bytes(
+        &mut self,
+        gas: &GasCounter,
+        bytes_ptr: AscPtr<Uint8Array>,
+    ) -> Result<AscPtr<AscResult<AscPtr<AscEnum<YamlValueKind>>, bool>>, HostExportError> {
+        let bytes: Vec<u8> = asc_get(self, bytes_ptr, gas)?;
+        let host_exports = self.as_ref().ctx.host_exports.cheap_clone();
+        let ctx = &mut self.as_mut().ctx;
+
+        let result = host_exports
+            .yaml_from_bytes(&bytes, gas, &mut ctx.state)
+            .map_err(|err| {
+                warn!(
+                    &self.as_ref().ctx.logger,
+                    "Failed to parse YAML from byte array";
+                    "bytes" => truncate_yaml_bytes_for_logging(&bytes),
+                    "error" => format!("{:#}", err),
+                );
+
+                true
+            });
+
+        asc_new(self, &result, gas).await
+    }
+}
+
+/// For debugging, it might be useful to know exactly which bytes could not be parsed as YAML, but
+/// since we can parse large YAML documents, even one bad mapping could produce terabytes of logs.
+/// To avoid this, we only log the first 1024 bytes of the failed YAML source.
+fn truncate_yaml_bytes_for_logging(bytes: &[u8]) -> String {
+    if bytes.len() > 1024 {
+        return format!("(truncated) 0x{}", hex::encode(&bytes[..1024]));
+    }
+
+    format!("0x{}", hex::encode(bytes))
+}
diff --git a/runtime/wasm/src/module/instance.rs b/runtime/wasm/src/module/instance.rs
new file mode 100644
index 00000000000..79017beadc1
--- /dev/null
+++ b/runtime/wasm/src/module/instance.rs
@@ -0,0 +1,711 @@
+use std::collections::BTreeMap;
+use std::time::Instant;
+
+use anyhow::Error;
+use graph::futures03::FutureExt as _;
+use graph::futures03::future::BoxFuture;
+use graph::slog::SendSyncRefUnwindSafeKV;
+
+use semver::Version;
+use wasmtime::{AsContextMut, Linker, Store, Trap};
+
+use graph::blockchain::{Blockchain, HostFnCtx};
+use graph::data::store;
+use graph::data::subgraph::schema::SubgraphError;
+use graph::data_source::{MappingTrigger, TriggerWithHandler};
+use graph::prelude::*;
+use graph::runtime::{
+    HostExportError, asc_new,
+    gas::{Gas, GasCounter},
+};
+use graph::{components::subgraph::MappingError, runtime::AscPtr};
+
+use super::IntoWasmRet;
+use super::{IntoTrap, WasmInstanceContext};
+use crate::ExperimentalFeatures;
+use crate::error::DeterminismLevel;
+use crate::mapping::MappingContext;
+use crate::mapping::ValidModule;
+use crate::module::WasmInstanceData;
+
+use super::{AscHeapCtx, ToAscPtr, is_trap_deterministic};
+
+/// Handle to a WASM instance, which is terminated if and only if this is dropped.
+pub struct WasmInstance {
+    pub instance: wasmtime::Instance,
+    pub store: wasmtime::Store<WasmInstanceData>,
+
+    // A reference to the gas counter used for reporting the gas used.
+    pub gas: GasCounter,
+}
+
+#[cfg(debug_assertions)]
+mod impl_for_tests {
+    use graph::runtime::{
+        AscIndexId, AscPtr, AscType, DeterministicHostError, FromAscObj, HostExportError, ToAscObj,
+        asc_new,
+    };
+
+    use crate::module::{WasmInstanceContext, asc_get};
+
+    impl super::WasmInstance {
+        pub fn asc_get<T, P>(&mut self, asc_ptr: AscPtr<P>) -> Result<T, DeterministicHostError>
+        where
+            P: AscType + AscIndexId,
+            T: FromAscObj<P>,
+        {
+            let ctx = WasmInstanceContext::new(&mut self.store);
+            asc_get(&ctx, asc_ptr, &self.gas)
+        }
+
+        pub async fn asc_new<P, T>(&mut self, rust_obj: &T) -> Result<AscPtr<P>, HostExportError>
+        where
+            P: AscType + AscIndexId,
+            T: ToAscObj<P> + ?Sized,
+        {
+            let mut ctx = WasmInstanceContext::new(&mut self.store);
+            asc_new(&mut ctx, rust_obj, &self.gas).await
+        }
+    }
+}
+
+impl WasmInstance {
+    pub(crate) async fn handle_json_callback(
+        mut self,
+        handler_name: &str,
+        value: &serde_json::Value,
+        user_data: &store::Value,
+    ) -> Result<BlockState, anyhow::Error> {
+        let gas_metrics = self.store.data().host_metrics.gas_metrics.clone();
+        let gas = GasCounter::new(gas_metrics);
+        let mut ctx = self.instance_ctx();
+        let (value, user_data) = {
+            let value = asc_new(&mut ctx, value, &gas).await;
+
+            let user_data = asc_new(&mut ctx, user_data, &gas).await;
+
+            (value, user_data)
+        };
+
+        self.instance_ctx().as_mut().ctx.state.enter_handler();
+
+        // Invoke the callback
+        self.instance
+            .get_func(self.store.as_context_mut(), handler_name)
+            .with_context(|| format!("function {} not found", handler_name))?
+            .typed::<(u32, u32), ()>(self.store.as_context_mut())
+            .map_err(anyhow::Error::from)?
+            .call_async(
+                self.store.as_context_mut(),
+                (value?.wasm_ptr(), user_data?.wasm_ptr()),
+            )
+            .await
+            .map_err(anyhow::Error::from)
+            .with_context(|| format!("Failed to handle callback '{}'", handler_name))?;
+
+        let mut wasm_ctx = self.store.into_data();
+        wasm_ctx.ctx.state.exit_handler();
+
+        Ok(wasm_ctx.take_state())
+    }
+
+    pub(crate) async fn handle_trigger<C: Blockchain>(
+        mut self,
+        trigger: TriggerWithHandler<MappingTrigger<C>>,
+    ) -> Result<(BlockState, Gas), MappingError>
+    where
+        <C as Blockchain>::MappingTrigger: ToAscPtr,
+    {
+        let handler_name = trigger.handler_name().to_owned();
+        let gas = self.gas.clone();
+        let logging_extras = trigger.logging_extras().cheap_clone();
+        let error_context = trigger.trigger.error_context();
+        let mut ctx = self.instance_ctx();
+        let asc_trigger = trigger.to_asc_ptr(&mut ctx, &gas).await?;
+
+        self.invoke_handler(&handler_name, asc_trigger, logging_extras, error_context)
+            .await
+    }
+
+    pub fn take_ctx(self) -> WasmInstanceData {
+        self.store.into_data()
+    }
+
+    pub(crate) fn instance_ctx(&mut self) -> WasmInstanceContext<'_> {
+        WasmInstanceContext::new(&mut self.store)
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn get_func(&mut self, func_name: &str) -> wasmtime::Func {
+        self.instance
+            .get_func(self.store.as_context_mut(), func_name)
+            .unwrap()
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn gas_used(&self) -> u64 {
+        self.gas.get().value()
+    }
+
+    async fn invoke_handler<T>(
+        mut self,
+        handler: &str,
+        arg: AscPtr<T>,
+        logging_extras: Arc<dyn SendSyncRefUnwindSafeKV>,
+        error_context: Option<String>,
+    ) -> Result<(BlockState, Gas), MappingError> {
+        let func = self
+            .instance
+            .get_func(self.store.as_context_mut(), handler)
+            .with_context(|| format!("function {} not found", handler))?;
+
+        let func = func
+            .typed(self.store.as_context_mut())
+            .map_err(anyhow::Error::from)
+            .context("wasm function has incorrect signature")?;
+
+        // Caution: Make sure all exit paths from this function call `exit_handler`.
+        self.instance_ctx().as_mut().ctx.state.enter_handler();
+
+        // This `match` will return early if there was a non-deterministic trap.
+        let deterministic_error: Option<Error> = match func
+            .call_async(self.store.as_context_mut(), arg.wasm_ptr())
+            .await
+            .map_err(anyhow::Error::from)
+        {
+            Ok(()) => {
+                assert!(!self.instance_ctx().as_ref().possible_reorg);
+                assert!(!self.instance_ctx().as_ref().deterministic_host_trap);
+                None
+            }
+            Err(trap) if self.instance_ctx().as_ref().possible_reorg => {
+                self.instance_ctx().as_mut().ctx.state.exit_handler();
+                return Err(MappingError::PossibleReorg(trap));
+            }
+
+            // Treat timeouts anywhere in the error chain as a special case to have a better error
+            // message. Any `TrapCode::Interrupt` is assumed to be a timeout.
+            // See also: runtime-timeouts
+            Err(trap)
+                if trap
+                    .chain()
+                    .any(|e| e.downcast_ref::<Trap>() == Some(&Trap::Interrupt)) =>
+            {
+                self.instance_ctx().as_mut().ctx.state.exit_handler();
+                return Err(MappingError::Unknown(trap.context(format!(
+                        "Handler '{}' hit the timeout of '{}' seconds",
+                        handler,
+                        self.instance_ctx().as_ref().valid_module.timeout.unwrap().as_secs()
+                    ))));
+            }
+            Err(trap) => {
+                let trap_is_deterministic = is_trap_deterministic(&trap)
+                    || self.instance_ctx().as_ref().deterministic_host_trap;
+                match trap_is_deterministic {
+                    true => Some(trap),
+                    false => {
+                        self.instance_ctx().as_mut().ctx.state.exit_handler();
+                        return Err(MappingError::Unknown(trap));
+                    }
+                }
+            }
+        };
+
+        if let Some(deterministic_error) = deterministic_error {
+            let deterministic_error = match error_context {
+                Some(error_context) => deterministic_error.context(error_context),
+                None => deterministic_error,
+            };
+            let message = format!("{:#}", deterministic_error).replace('\n', "\t");
+
+            // Log the error and restore the updates snapshot, effectively reverting the handler.
+            error!(&self.instance_ctx().as_ref().ctx.logger,
+                "Handler skipped due to execution failure";
+                "handler" => handler,
+                "error" => &message,
+                logging_extras
+            );
+            let subgraph_error = SubgraphError {
+                subgraph_id: self
+                    .instance_ctx()
+                    .as_ref()
+                    .ctx
+                    .host_exports
+                    .subgraph_id
+                    .clone(),
+                message,
+                block_ptr: Some(self.instance_ctx().as_ref().ctx.block_ptr.cheap_clone()),
+                handler: Some(handler.to_string()),
+                deterministic: true,
+            };
+            self.instance_ctx()
+                .as_mut()
+                .ctx
+                .state
+                .exit_handler_and_discard_changes_due_to_error(subgraph_error);
+        } else {
+            self.instance_ctx().as_mut().ctx.state.exit_handler();
+        }
+
+        let gas = self.gas.get();
+        Ok((self.take_ctx().take_state(), gas))
+    }
+}
+
+/// Register a chain-specific host function dispatcher for the given import name.
+/// The registered closure looks up the `HostFn` by name from `caller.data().ctx.host_fns`
+/// at call time. If the module doesn't import this function, this is a no-op.
+fn link_chain_host_fn(
+    linker: &mut Linker<WasmInstanceData>,
+    import_name_to_modules: &BTreeMap<String, Vec<String>>,
+    name: &'static str,
+) -> Result<(), anyhow::Error> {
+    let modules = match import_name_to_modules.get(name) {
+        Some(m) => m,
+        None => return Ok(()),
+    };
+
+    let name_for_metrics = name.replace('.', "_");
+    let section_name = format!("host_export_{}", name_for_metrics);
+
+    for module in modules {
+        let name_for_metrics = name_for_metrics.clone();
+        let section_name = section_name.clone();
+        linker.func_wrap_async(
+            module,
+            name,
+            move |mut caller: wasmtime::Caller<'_, WasmInstanceData>, (call_ptr,): (u32,)| {
+                let name_for_metrics = name_for_metrics.clone();
+                let section_name = section_name.clone();
+                Box::new(async move {
+                    let host_fn = caller
+                        .data()
+                        .ctx
+                        .host_fns
+                        .iter()
+                        .find(|hf| hf.name == name)
+                        .ok_or_else(|| {
+                            wasmtime::Error::msg(format!(
+                                "chain host function '{}' is not available for this chain",
+                                name
+                            ))
+                        })?
+                        .cheap_clone();
+
+                    let start = Instant::now();
+
+                    let gas = caller.data().gas.cheap_clone();
+                    let host_metrics = caller.data().host_metrics.cheap_clone();
+                    let stopwatch = host_metrics.stopwatch.cheap_clone();
+                    let _section = stopwatch.start_section(&section_name);
+
+                    let ctx = HostFnCtx {
+                        logger: caller.data().ctx.logger.cheap_clone(),
+                        block_ptr: caller.data().ctx.block_ptr.cheap_clone(),
+                        gas: gas.cheap_clone(),
+                        metrics: host_metrics.cheap_clone(),
+                        heap: &mut WasmInstanceContext::new(&mut caller),
+                    };
+                    let ret = (host_fn.func)(ctx, call_ptr)
+                        .await
+                        .map_err(|e| match e {
+                            HostExportError::Deterministic(e) => {
+                                caller.data_mut().deterministic_host_trap = true;
+                                e
+                            }
+                            HostExportError::PossibleReorg(e) => {
+                                caller.data_mut().possible_reorg = true;
+                                e
+                            }
+                            HostExportError::Unknown(e) => e,
+                        })
+                        .map_err(wasmtime::Error::from_anyhow)?;
+                    host_metrics.observe_host_fn_execution_time(
+                        start.elapsed().as_secs_f64(),
+                        &name_for_metrics,
+                    );
+                    Ok(ret)
+                })
+            },
+        )?;
+    }
+    Ok(())
+}
+
+/// Build a pre-linked `Linker` for a WASM module. This linker can be reused across triggers by
+/// calling `linker.instantiate_pre()` once and then `instance_pre.instantiate_async()` per trigger.
+///
+/// All host functions (builtins + chain-specific) are registered here. Chain-specific host functions
+/// are dispatched generically by looking up the `HostFn` by name from `caller.data().ctx.host_fns`
+/// at call time rather than capturing concrete closures at link time.
+pub(crate) fn build_linker(
+    engine: &wasmtime::Engine,
+    import_name_to_modules: &BTreeMap<String, Vec<String>>,
+) -> Result<Linker<WasmInstanceData>, anyhow::Error> {
+    let mut linker: Linker<WasmInstanceData> = wasmtime::Linker::new(engine);
+
+    // Helper to turn a parameter name into 'u32' for a tuple type
+    // (param1, parma2, ..) : (u32, u32, ..)
+    macro_rules! param_u32 {
+        ($param:ident) => {
+            u32
+        };
+    }
+
+    // The difficulty with this macro is that it needs to turn a list of
+    // parameter names into a tuple declaration (param1, parma2, ..) :
+    // (u32, u32, ..), but also for an empty parameter list, it needs to
+    // produce '(): ()'. In the first case we need a trailing comma, in
+    // the second case we don't. That's why there are two separate
+    // expansions, one with and one without params
+    macro_rules! link {
+        ($wasm_name:expr, $rust_name:ident, $($param:ident),*) => {
+            link!($wasm_name, $rust_name, "host_export_other",$($param),*)
+        };
+
+        ($wasm_name:expr, $rust_name:ident, $section:expr, $($param:ident),+) => {
+            let modules = import_name_to_modules
+                .get($wasm_name)
+                .into_iter()
+                .flatten();
+
+            // link an import with all the modules that require it.
+            for module in modules {
+                linker.func_wrap_async(
+                    module,
+                    $wasm_name,
+                    move |mut caller: wasmtime::Caller<'_, WasmInstanceData>,
+                          ($($param),*,) : ($(param_u32!($param)),*,)|  {
+                        Box::new(async move {
+                            let gas = caller.data().gas.cheap_clone();
+                            let host_metrics = caller.data().host_metrics.cheap_clone();
+                            let _section = host_metrics.stopwatch.start_section($section);
+
+                            #[allow(unused_mut)]
+                            let mut ctx = std::pin::pin!(WasmInstanceContext::new(&mut caller));
+                            let result = ctx.$rust_name(
+                                &gas,
+                                $($param.into()),*
+                            ).await;
+                            let ctx = ctx.get_mut();
+                            match result {
+                                Ok(result) => Ok(result.into_wasm_ret()),
+                                Err(e) => {
+                                    match IntoTrap::determinism_level(&e) {
+                                        DeterminismLevel::Deterministic => {
+                                            ctx.as_mut().deterministic_host_trap = true;
+                                        }
+                                        DeterminismLevel::PossibleReorg => {
+                                            ctx.as_mut().possible_reorg = true;
+                                        }
+                                        DeterminismLevel::Unimplemented
+                                        | DeterminismLevel::NonDeterministic => {}
+                                    }
+
+                                    Err(e.into())
+                                }
+                            }
+                    }) },
+                )?;
+            }
+        };
+
+        ($wasm_name:expr, $rust_name:ident, $section:expr,) => {
+            let modules = import_name_to_modules
+                .get($wasm_name)
+                .into_iter()
+                .flatten();
+
+            // link an import with all the modules that require it.
+            for module in modules {
+                linker.func_wrap_async(
+                    module,
+                    $wasm_name,
+                    move |mut caller: wasmtime::Caller<'_, WasmInstanceData>,
+                          _ : ()|  {
+                        Box::new(async move {
+                            let gas = caller.data().gas.cheap_clone();
+                            let host_metrics = caller.data().host_metrics.cheap_clone();
+                            let _section = host_metrics.stopwatch.start_section($section);
+
+                            #[allow(unused_mut)]
+                            let mut ctx = WasmInstanceContext::new(&mut caller);
+                            let result = ctx.$rust_name(&gas).await;
+                            match result {
+                                Ok(result) => Ok(result.into_wasm_ret()),
+                                Err(e) => {
+                                    match IntoTrap::determinism_level(&e) {
+                                        DeterminismLevel::Deterministic => {
+                                            ctx.as_mut().deterministic_host_trap = true;
+                                        }
+                                        DeterminismLevel::PossibleReorg => {
+                                            ctx.as_mut().possible_reorg = true;
+                                        }
+                                        DeterminismLevel::Unimplemented
+                                        | DeterminismLevel::NonDeterministic => {}
+                                    }
+
+                                    Err(e.into())
+                                }
+                            }
+                    }) },
+                )?;
+            }
+        };
+    }
+
+    // Chain-specific host functions. Each is registered explicitly rather than
+    // discovered dynamically from imports.
+    link_chain_host_fn(&mut linker, import_name_to_modules, "ethereum.call")?;
+    link_chain_host_fn(&mut linker, import_name_to_modules, "ethereum.getBalance")?;
+    link_chain_host_fn(&mut linker, import_name_to_modules, "ethereum.hasCode")?;
+
+    link!("ethereum.encode", ethereum_encode, params_ptr);
+    link!("ethereum.decode", ethereum_decode, params_ptr, data_ptr);
+    link!(
+        "ethereum.decodeParams",
+        ethereum_decode_params,
+        params_ptr,
+        data_ptr
+    );
+
+    link!("abort", abort, message_ptr, file_name_ptr, line, column);
+
+    link!("store.get", store_get, "host_export_store_get", entity, id);
+    link!(
+        "store.loadRelated",
+        store_load_related,
+        "host_export_store_load_related",
+        entity,
+        id,
+        field
+    );
+    link!(
+        "store.get_in_block",
+        store_get_in_block,
+        "host_export_store_get_in_block",
+        entity,
+        id
+    );
+    link!(
+        "store.set",
+        store_set,
+        "host_export_store_set",
+        entity,
+        id,
+        data
+    );
+
+    // All IPFS-related functions exported by the host WASM runtime should be listed in the
+    // graph::data::subgraph::features::IPFS_ON_ETHEREUM_CONTRACTS_FUNCTION_NAMES array for
+    // automatic feature detection to work.
+    //
+    // For reference, search this codebase for: ff652476-e6ad-40e4-85b8-e815d6c6e5e2
+    link!("ipfs.cat", ipfs_cat, "host_export_ipfs_cat", hash_ptr);
+    link!(
+        "ipfs.map",
+        ipfs_map,
+        "host_export_ipfs_map",
+        link_ptr,
+        callback,
+        user_data,
+        flags
+    );
+    // ipfs.getBlock checks the experimental_features flag internally via
+    // caller.data().experimental_features, so it can be linked unconditionally.
+    link!(
+        "ipfs.getBlock",
+        ipfs_get_block,
+        "host_export_ipfs_get_block",
+        hash_ptr
+    );
+
+    link!("store.remove", store_remove, entity_ptr, id_ptr);
+
+    link!("typeConversion.bytesToString", bytes_to_string, ptr);
+    link!("typeConversion.bytesToHex", bytes_to_hex, ptr);
+    link!("typeConversion.bigIntToString", big_int_to_string, ptr);
+    link!("typeConversion.bigIntToHex", big_int_to_hex, ptr);
+    link!("typeConversion.stringToH160", string_to_h160, ptr);
+    link!("typeConversion.bytesToBase58", bytes_to_base58, ptr);
+
+    link!("json.fromBytes", json_from_bytes, ptr);
+    link!("json.try_fromBytes", json_try_from_bytes, ptr);
+    link!("json.toI64", json_to_i64, ptr);
+    link!("json.toU64", json_to_u64, ptr);
+    link!("json.toF64", json_to_f64, ptr);
+    link!("json.toBigInt", json_to_big_int, ptr);
+
+    link!("yaml.fromBytes", yaml_from_bytes, ptr);
+    link!("yaml.try_fromBytes", yaml_try_from_bytes, ptr);
+
+    link!("crypto.keccak256", crypto_keccak_256, ptr);
+
+    link!("bigInt.plus", big_int_plus, x_ptr, y_ptr);
+    link!("bigInt.minus", big_int_minus, x_ptr, y_ptr);
+    link!("bigInt.times", big_int_times, x_ptr, y_ptr);
+    link!("bigInt.dividedBy", big_int_divided_by, x_ptr, y_ptr);
+    link!("bigInt.dividedByDecimal", big_int_divided_by_decimal, x, y);
+    link!("bigInt.mod", big_int_mod, x_ptr, y_ptr);
+    link!("bigInt.pow", big_int_pow, x_ptr, exp);
+    link!("bigInt.fromString", big_int_from_string, ptr);
+    link!("bigInt.bitOr", big_int_bit_or, x_ptr, y_ptr);
+    link!("bigInt.bitAnd", big_int_bit_and, x_ptr, y_ptr);
+    link!("bigInt.leftShift", big_int_left_shift, x_ptr, bits);
+    link!("bigInt.rightShift", big_int_right_shift, x_ptr, bits);
+
+    link!("bigDecimal.toString", big_decimal_to_string, ptr);
+    link!("bigDecimal.fromString", big_decimal_from_string, ptr);
+    link!("bigDecimal.plus", big_decimal_plus, x_ptr, y_ptr);
+    link!("bigDecimal.minus", big_decimal_minus, x_ptr, y_ptr);
+    link!("bigDecimal.times", big_decimal_times, x_ptr, y_ptr);
+    link!("bigDecimal.dividedBy", big_decimal_divided_by, x, y);
+    link!("bigDecimal.equals", big_decimal_equals, x_ptr, y_ptr);
+
+    link!("dataSource.create", data_source_create, name, params);
+    link!(
+        "dataSource.createWithContext",
+        data_source_create_with_context,
+        name,
+        params,
+        context
+    );
+    link!("dataSource.address", data_source_address,);
+    link!("dataSource.network", data_source_network,);
+    link!("dataSource.context", data_source_context,);
+
+    link!("ens.nameByHash", ens_name_by_hash, ptr);
+
+    link!("log.log", log_log, level, msg_ptr);
+
+    // `arweave` and `box` functionality was removed. The implementations return deterministic
+    // errors. Linked unconditionally since import_name_to_modules ensures they're only
+    // registered if the module actually imports them.
+    link!("arweave.transactionData", arweave_transaction_data, ptr);
+    link!("box.profile", box_profile, ptr);
+
+    // link the `gas` function
+    // See also e3f03e62-40e4-4f8c-b4a1-d0375cca0b76
+    linker.func_wrap(
+        "gas",
+        "gas",
+        |mut caller: wasmtime::Caller<'_, WasmInstanceData>,
+         gas_used: u64|
+         -> wasmtime::Result<()> {
+            // Gas metering has a relevant execution cost cost, being called tens of thousands
+            // of times per handler, but it's not worth having a stopwatch section here because
+            // the cost of measuring would be greater than the cost of `consume_host_fn`. Last
+            // time this was benchmarked it took < 100ns to run.
+            if let Err(e) = caller
+                .data()
+                .gas
+                .consume_host_fn_with_metrics(Gas::new(gas_used), "gas")
+            {
+                caller.data_mut().deterministic_host_trap = true;
+                return Err(wasmtime::Error::from_anyhow(e.into()));
+            }
+
+            Ok(())
+        },
+    )?;
+
+    Ok(linker)
+}
+
+impl WasmInstance {
+    /// Instantiates the module and sets it to be interrupted after `timeout`.
+    pub async fn from_valid_module_with_ctx(
+        valid_module: Arc<ValidModule>,
+        ctx: MappingContext,
+        host_metrics: Arc<HostMetrics>,
+        experimental_features: ExperimentalFeatures,
+    ) -> Result<WasmInstance, anyhow::Error> {
+        let engine = valid_module.module.engine();
+        let api_version = ctx.host_exports.data_source.api_version.clone();
+
+        let gas = GasCounter::new(host_metrics.gas_metrics.clone());
+
+        let wasm_ctx = WasmInstanceData::from_instance(
+            ctx,
+            valid_module.cheap_clone(),
+            host_metrics.cheap_clone(),
+            gas.cheap_clone(),
+            experimental_features,
+        );
+        let mut store = Store::new(engine, wasm_ctx);
+
+        // The epoch on the engine will only ever be incremeted if increment_epoch() is explicitly
+        // called, we only do so if a timeout has been set, it will run forever. When a timeout is
+        // set, the timeout duration is used as the duration of one epoch.
+        //
+        // Therefore, the setting of 2 here means that if a `timeout` is provided, then this
+        // interrupt will be triggered between a duration of `timeout` and `timeout * 2`.
+        //
+        // See also: runtime-timeouts
+        store.set_epoch_deadline(2);
+
+        let instance = valid_module
+            .instance_pre
+            .instantiate_async(store.as_context_mut())
+            .await?;
+
+        let asc_heap = AscHeapCtx::new(
+            &instance,
+            &mut WasmInstanceContext::new(&mut store),
+            api_version.clone(),
+        )?;
+        store.data_mut().set_asc_heap(asc_heap);
+
+        // See start_function comment for more information
+        // TL;DR; we need the wasmtime::Instance to create the heap, therefore
+        // we cannot execute anything that requires access to the heap before it's created.
+        if let Some(start_func) = valid_module.start_function.as_ref() {
+            instance
+                .get_func(store.as_context_mut(), start_func)
+                .context(format!("`{start_func}` function not found"))?
+                .typed::<(), ()>(store.as_context_mut())?
+                .call_async(store.as_context_mut(), ())
+                .await?;
+        }
+
+        match api_version {
+            version if version <= Version::new(0, 0, 4) => {}
+            _ => {
+                instance
+                    .get_func(store.as_context_mut(), "_start")
+                    .context("`_start` function not found")?
+                    .typed::<(), ()>(store.as_context_mut())?
+                    .call_async(store.as_context_mut(), ())
+                    .await?;
+            }
+        }
+
+        Ok(WasmInstance {
+            instance,
+            gas,
+            store,
+        })
+    }
+
+    /// Similar to `from_valid_module_with_ctx` but returns a boxed future.
+    /// This is needed to allow mutually recursive calls of futures, e.g.,
+    /// in `ipfs_map` as that is a host function that calls back into WASM
+    /// code which in turn might call back into host functions.
+    pub fn from_valid_module_with_ctx_boxed(
+        valid_module: Arc<ValidModule>,
+        ctx: MappingContext,
+        host_metrics: Arc<HostMetrics>,
+        experimental_features: ExperimentalFeatures,
+    ) -> BoxFuture<'static, Result<WasmInstance, anyhow::Error>> {
+        async move {
+            WasmInstance::from_valid_module_with_ctx(
+                valid_module,
+                ctx,
+                host_metrics,
+                experimental_features,
+            )
+            .await
+        }
+        .boxed()
+    }
+}
diff --git a/runtime/wasm/src/module/into_wasm_ret.rs b/runtime/wasm/src/module/into_wasm_ret.rs
index 444c9eb24f5..07d5abf4312 100644
--- a/runtime/wasm/src/module/into_wasm_ret.rs
+++ b/runtime/wasm/src/module/into_wasm_ret.rs
@@ -1,5 +1,5 @@
+use anyhow::Error;
 use never::Never;
-use wasmtime::Trap;
 
 use graph::runtime::AscPtr;
 
@@ -66,13 +66,14 @@ impl<C> IntoWasmRet for AscPtr<C> {
     }
 }
 
-impl<T> IntoWasmRet for Result<T, Trap>
+impl<T> IntoWasmRet for Result<T, Error>
 where
     T: IntoWasmRet,
     T::Ret: wasmtime::WasmTy,
 {
-    type Ret = Result<T::Ret, Trap>;
+    type Ret = Result<T::Ret, wasmtime::Error>;
     fn into_wasm_ret(self) -> Self::Ret {
         self.map(|x| x.into_wasm_ret())
+            .map_err(wasmtime::Error::from_anyhow)
     }
 }
diff --git a/runtime/wasm/src/module/mod.rs b/runtime/wasm/src/module/mod.rs
index 1d5f657ea18..fc9b5e0ca09 100644
--- a/runtime/wasm/src/module/mod.rs
+++ b/runtime/wasm/src/module/mod.rs
@@ -1,50 +1,40 @@
-use std::cell::RefCell;
-use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::mem::MaybeUninit;
-use std::ops::{Deref, DerefMut};
-use std::rc::Rc;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::time::Instant;
 
-use anyhow::anyhow;
 use anyhow::Error;
-use graph::components::store::GetScope;
-use graph::data::value::Word;
-use graph::slog::SendSyncRefUnwindSafeKV;
-use never::Never;
+use anyhow::anyhow;
+use async_trait::async_trait;
+use graph::blockchain::Blockchain;
+use graph::data_source::subgraph;
+use graph::parking_lot::RwLock;
+use graph::util::mem::init_slice;
 use semver::Version;
-use wasmtime::{Memory, Trap, TrapCode};
+use wasmtime::AsContext;
+use wasmtime::AsContextMut;
+use wasmtime::Memory;
 
-use graph::blockchain::{Blockchain, HostFnCtx};
-use graph::data::store;
-use graph::data::subgraph::schema::SubgraphError;
-use graph::data_source::{offchain, MappingTrigger, TriggerWithHandler};
+use graph::data_source::{MappingTrigger, TriggerWithHandler, offchain};
 use graph::prelude::*;
+use graph::runtime::AscPtr;
 use graph::runtime::{
-    asc_new,
-    gas::{self, Gas, GasCounter, SaturatingInto},
     AscHeap, AscIndexId, AscType, DeterministicHostError, FromAscObj, HostExportError,
-    IndexForAscTypeId, ToAscObj,
+    IndexForAscTypeId, asc_new,
+    gas::{Gas, GasCounter},
 };
-use graph::util::mem::init_slice;
-use graph::{components::subgraph::MappingError, runtime::AscPtr};
 pub use into_wasm_ret::IntoWasmRet;
-pub use stopwatch::TimeoutStopwatch;
 
-use crate::asc_abi::class::*;
 use crate::error::DeterminismLevel;
 use crate::gas_rules::{GAS_COST_LOAD, GAS_COST_STORE};
 pub use crate::host_exports;
-use crate::host_exports::HostExports;
-use crate::mapping::MappingContext;
-use crate::mapping::ValidModule;
 
+pub use context::*;
+pub use instance::*;
+mod context;
+mod instance;
 mod into_wasm_ret;
-pub mod stopwatch;
 
 // Convenience for a 'top-level' asc_get, with depth 0.
-fn asc_get<T, C: AscType, H: AscHeap + ?Sized>(
+fn asc_get<T, C, H: AscHeap + ?Sized>(
     heap: &H,
     ptr: AscPtr<C>,
     gas: &GasCounter,
@@ -58,307 +48,112 @@ where
 
 pub trait IntoTrap {
     fn determinism_level(&self) -> DeterminismLevel;
-    fn into_trap(self) -> Trap;
+    // fn into_trap(self) -> Trap;
 }
 
 /// A flexible interface for writing a type to AS memory, any pointer can be returned.
 /// Use `AscPtr::erased` to convert `AscPtr<T>` into `AscPtr<()>`.
+#[async_trait]
 pub trait ToAscPtr {
-    fn to_asc_ptr<H: AscHeap>(
+    async fn to_asc_ptr<H: AscHeap + Send>(
         self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscPtr<()>, HostExportError>;
 }
 
+#[async_trait]
 impl ToAscPtr for offchain::TriggerData {
-    fn to_asc_ptr<H: AscHeap>(
+    async fn to_asc_ptr<H: AscHeap + Send>(
+        self,
+        heap: &mut H,
+        gas: &GasCounter,
+    ) -> Result<AscPtr<()>, HostExportError> {
+        asc_new(heap, self.data.as_ref() as &[u8], gas)
+            .await
+            .map(|ptr| ptr.erase())
+    }
+}
+
+#[async_trait]
+impl ToAscPtr for subgraph::MappingEntityTrigger {
+    async fn to_asc_ptr<H: AscHeap>(
         self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscPtr<()>, HostExportError> {
-        asc_new(heap, self.data.as_ref() as &[u8], gas).map(|ptr| ptr.erase())
+        asc_new(heap, &self.data.entity.entity.sorted_ref(), gas)
+            .await
+            .map(|ptr| ptr.erase())
     }
 }
 
+#[async_trait]
 impl<C: Blockchain> ToAscPtr for MappingTrigger<C>
 where
     C::MappingTrigger: ToAscPtr,
 {
-    fn to_asc_ptr<H: AscHeap>(
+    async fn to_asc_ptr<H: AscHeap>(
         self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscPtr<()>, HostExportError> {
         match self {
-            MappingTrigger::Onchain(trigger) => trigger.to_asc_ptr(heap, gas),
-            MappingTrigger::Offchain(trigger) => trigger.to_asc_ptr(heap, gas),
+            MappingTrigger::Onchain(trigger) => trigger.to_asc_ptr(heap, gas).await,
+            MappingTrigger::Offchain(trigger) => trigger.to_asc_ptr(heap, gas).await,
+            MappingTrigger::Subgraph(trigger) => trigger.to_asc_ptr(heap, gas).await,
         }
     }
 }
 
-impl<T: ToAscPtr> ToAscPtr for TriggerWithHandler<T> {
-    fn to_asc_ptr<H: AscHeap>(
+#[async_trait]
+impl<T: ToAscPtr + Send> ToAscPtr for TriggerWithHandler<T> {
+    async fn to_asc_ptr<H: AscHeap>(
         self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscPtr<()>, HostExportError> {
-        self.trigger.to_asc_ptr(heap, gas)
+        self.trigger.to_asc_ptr(heap, gas).await
     }
 }
 
-/// Handle to a WASM instance, which is terminated if and only if this is dropped.
-pub struct WasmInstance<C: Blockchain> {
-    pub instance: wasmtime::Instance,
-
-    // This is the only reference to `WasmInstanceContext` that's not within the instance itself, so
-    // we can always borrow the `RefCell` with no concern for race conditions.
-    //
-    // Also this is the only strong reference, so the instance will be dropped once this is dropped.
-    // The weak references are circulary held by instance itself through host exports.
-    pub instance_ctx: Rc<RefCell<Option<WasmInstanceContext<C>>>>,
+fn is_trap_deterministic(trap: &Error) -> bool {
+    let trap = match trap.downcast_ref() {
+        Some(trap) => trap,
+        None => return false,
+    };
 
-    // A reference to the gas counter used for reporting the gas used.
-    pub gas: GasCounter,
-}
-
-impl<C: Blockchain> Drop for WasmInstance<C> {
-    fn drop(&mut self) {
-        // Assert that the instance will be dropped.
-        assert_eq!(Rc::strong_count(&self.instance_ctx), 1);
-    }
-}
-
-impl<C: Blockchain> WasmInstance<C> {
-    pub fn asc_get<T, P>(&self, asc_ptr: AscPtr<P>) -> Result<T, DeterministicHostError>
-    where
-        P: AscType + AscIndexId,
-        T: FromAscObj<P>,
-    {
-        asc_get(self.instance_ctx().deref(), asc_ptr, &self.gas)
-    }
-
-    pub fn asc_new<P, T: ?Sized>(&mut self, rust_obj: &T) -> Result<AscPtr<P>, HostExportError>
-    where
-        P: AscType + AscIndexId,
-        T: ToAscObj<P>,
-    {
-        asc_new(self.instance_ctx_mut().deref_mut(), rust_obj, &self.gas)
-    }
-}
-
-fn is_trap_deterministic(trap: &Trap) -> bool {
-    use wasmtime::TrapCode::*;
+    use wasmtime::Trap::*;
 
     // We try to be exhaustive, even though `TrapCode` is non-exhaustive.
-    match trap.trap_code() {
-        Some(MemoryOutOfBounds)
-        | Some(HeapMisaligned)
-        | Some(TableOutOfBounds)
-        | Some(IndirectCallToNull)
-        | Some(BadSignature)
-        | Some(IntegerOverflow)
-        | Some(IntegerDivisionByZero)
-        | Some(BadConversionToInteger)
-        | Some(UnreachableCodeReached) => true,
+    match trap {
+        MemoryOutOfBounds
+        | HeapMisaligned
+        | TableOutOfBounds
+        | IndirectCallToNull
+        | BadSignature
+        | IntegerOverflow
+        | IntegerDivisionByZero
+        | BadConversionToInteger
+        | UnreachableCodeReached => true,
 
         // `Interrupt`: Can be a timeout, at least as wasmtime currently implements it.
         // `StackOverflow`: We may want to have a configurable stack size.
         // `None`: A host trap, so we need to check the `deterministic_host_trap` flag in the context.
-        Some(Interrupt) | Some(StackOverflow) | None | _ => false,
+        Interrupt | StackOverflow | _ => false,
     }
 }
 
-impl<C: Blockchain> WasmInstance<C> {
-    pub(crate) fn handle_json_callback(
-        mut self,
-        handler_name: &str,
-        value: &serde_json::Value,
-        user_data: &store::Value,
-    ) -> Result<BlockState<C>, anyhow::Error> {
-        let gas_metrics = self.instance_ctx().host_metrics.gas_metrics.clone();
-        let gas = GasCounter::new(gas_metrics);
-        let value = asc_new(self.instance_ctx_mut().deref_mut(), value, &gas)?;
-        let user_data = asc_new(self.instance_ctx_mut().deref_mut(), user_data, &gas)?;
-
-        self.instance_ctx_mut().ctx.state.enter_handler();
-
-        // Invoke the callback
-        self.instance
-            .get_func(handler_name)
-            .with_context(|| format!("function {} not found", handler_name))?
-            .typed()?
-            .call((value.wasm_ptr(), user_data.wasm_ptr()))
-            .with_context(|| format!("Failed to handle callback '{}'", handler_name))?;
-
-        self.instance_ctx_mut().ctx.state.exit_handler();
-
-        Ok(self.take_ctx().ctx.state)
-    }
-
-    pub(crate) fn handle_block(
-        mut self,
-        _logger: &Logger,
-        handler_name: &str,
-        block_data: Box<[u8]>,
-    ) -> Result<(BlockState<C>, Gas), MappingError> {
-        let obj = block_data
-            .to_vec()
-            .to_asc_obj(self.instance_ctx_mut().deref_mut(), &self.gas)?;
-
-        let obj = AscPtr::alloc_obj(obj, self.instance_ctx_mut().deref_mut(), &self.gas)?;
-
-        self.invoke_handler(handler_name, obj, Arc::new(o!()), None)
-    }
-
-    pub(crate) fn handle_trigger(
-        mut self,
-        trigger: TriggerWithHandler<MappingTrigger<C>>,
-    ) -> Result<(BlockState<C>, Gas), MappingError>
-    where
-        <C as Blockchain>::MappingTrigger: ToAscPtr,
-    {
-        let handler_name = trigger.handler_name().to_owned();
-        let gas = self.gas.clone();
-        let logging_extras = trigger.logging_extras().cheap_clone();
-        let error_context = trigger.trigger.error_context();
-        let asc_trigger = trigger.to_asc_ptr(self.instance_ctx_mut().deref_mut(), &gas)?;
-
-        self.invoke_handler(&handler_name, asc_trigger, logging_extras, error_context)
-    }
-
-    pub fn take_ctx(&mut self) -> WasmInstanceContext<C> {
-        self.instance_ctx.borrow_mut().take().unwrap()
-    }
-
-    pub(crate) fn instance_ctx(&self) -> std::cell::Ref<'_, WasmInstanceContext<C>> {
-        std::cell::Ref::map(self.instance_ctx.borrow(), |i| i.as_ref().unwrap())
-    }
-
-    pub fn instance_ctx_mut(&self) -> std::cell::RefMut<'_, WasmInstanceContext<C>> {
-        std::cell::RefMut::map(self.instance_ctx.borrow_mut(), |i| i.as_mut().unwrap())
-    }
-
-    #[cfg(debug_assertions)]
-    pub fn get_func(&self, func_name: &str) -> wasmtime::Func {
-        self.instance.get_func(func_name).unwrap()
-    }
-
-    #[cfg(debug_assertions)]
-    pub fn gas_used(&self) -> u64 {
-        self.gas.get().value()
-    }
-
-    fn invoke_handler<T>(
-        &mut self,
-        handler: &str,
-        arg: AscPtr<T>,
-        logging_extras: Arc<dyn SendSyncRefUnwindSafeKV>,
-        error_context: Option<String>,
-    ) -> Result<(BlockState<C>, Gas), MappingError> {
-        let func = self
-            .instance
-            .get_func(handler)
-            .with_context(|| format!("function {} not found", handler));
-
-        // Caution: Make sure all exit paths from this function call `exit_handler`.
-        self.instance_ctx_mut().ctx.state.enter_handler();
-
-        // `handle_func_call` evaluates the outcome of a WASM function call:
-        // - For non-deterministic traps, it terminates early with a `MappingError`.
-        // - In case of deterministic errors, it returns `Ok(Some(Error))`.
-        // - On successful execution, it returns `Ok(None)`.
-        let handle_func_call = |res: Result<_, Trap>, handler| {
-            match res {
-                Ok(()) => {
-                    assert!(self.instance_ctx().possible_reorg == false);
-                    assert!(self.instance_ctx().deterministic_host_trap == false);
-                    Ok(None)
-                }
-                Err(trap) if self.instance_ctx().possible_reorg => {
-                    self.instance_ctx_mut().ctx.state.exit_handler();
-                    Err(MappingError::PossibleReorg(trap.into()))
-                }
-
-                // Treat timeouts anywhere in the error chain as a special case to have a better error
-                // message. Any `TrapCode::Interrupt` is assumed to be a timeout.
-                Err(trap)
-                    if Error::from(trap.clone()).chain().any(|e| {
-                        e.downcast_ref::<Trap>().and_then(|t| t.trap_code())
-                            == Some(TrapCode::Interrupt)
-                    }) =>
-                {
-                    self.instance_ctx_mut().ctx.state.exit_handler();
-                    Err(MappingError::Unknown(Error::from(trap).context(format!(
-                        "Handler '{}' hit the timeout of '{}' seconds",
-                        handler,
-                        self.instance_ctx().timeout.unwrap().as_secs()
-                    ))))
-                }
-                Err(trap) => {
-                    let trap_is_deterministic =
-                        is_trap_deterministic(&trap) || self.instance_ctx().deterministic_host_trap;
-                    let e = Error::from(trap);
-                    match trap_is_deterministic {
-                        true => Ok(Some(e)),
-                        false => {
-                            self.instance_ctx_mut().ctx.state.exit_handler();
-                            Err(MappingError::Unknown(e))
-                        }
-                    }
-                }
-            }
-        };
-
-        let deterministic_error = match func {
-            Ok(func) => match func
-                .typed()
-                .context("wasm function has incorrect signature")
-            {
-                Ok(typed_func) => {
-                    match handle_func_call(typed_func.call(arg.wasm_ptr()), handler) {
-                        Ok(e) => e,
-                        Err(e) => {
-                            return Err(e);
-                        }
-                    }
-                }
-                Err(e) => Some(e),
-            },
-            Err(e) => Some(e),
-        };
-
-        if let Some(deterministic_error) = deterministic_error {
-            let deterministic_error = match error_context {
-                Some(error_context) => deterministic_error.context(error_context),
-                None => deterministic_error,
-            };
-            let message = format!("{:#}", deterministic_error).replace('\n', "\t");
-
-            // Log the error and restore the updates snapshot, effectively reverting the handler.
-            error!(&self.instance_ctx().ctx.logger,
-                "Handler skipped due to execution failure";
-                "handler" => handler,
-                "error" => &message,
-                logging_extras
-            );
-            let subgraph_error = SubgraphError {
-                subgraph_id: self.instance_ctx().ctx.host_exports.subgraph_id.clone(),
-                message,
-                block_ptr: Some(self.instance_ctx().ctx.block_ptr.cheap_clone()),
-                handler: Some(handler.to_string()),
-                deterministic: true,
-            };
-            self.instance_ctx_mut()
-                .ctx
-                .state
-                .exit_handler_and_discard_changes_due_to_error(subgraph_error);
-        } else {
-            self.instance_ctx_mut().ctx.state.exit_handler();
-        }
+struct Arena {
+    // First free byte in the current arena. Set on the first call to `raw_new`.
+    start: i32,
+    // Number of free bytes starting from `arena_start_ptr`.
+    size: i32,
+}
 
-        let gas = self.gas.get();
-        Ok((self.take_ctx().ctx.state, gas))
+impl Arena {
+    fn new() -> Self {
+        Self { start: 0, size: 0 }
     }
 }
 
@@ -367,27 +162,7 @@ pub struct ExperimentalFeatures {
     pub allow_non_deterministic_ipfs: bool,
 }
 
-pub struct WasmInstanceContext<C: Blockchain> {
-    pub ctx: MappingContext<C>,
-    pub valid_module: Arc<ValidModule>,
-    pub host_metrics: Arc<HostMetrics>,
-    pub(crate) timeout: Option<Duration>,
-
-    // Used by ipfs.map.
-    pub(crate) timeout_stopwatch: Arc<std::sync::Mutex<TimeoutStopwatch>>,
-
-    // A trap ocurred due to a possible reorg detection.
-    pub possible_reorg: bool,
-
-    // A host export trap ocurred for a deterministic reason.
-    pub deterministic_host_trap: bool,
-
-    pub(crate) experimental_features: ExperimentalFeatures,
-
-    asc_heap: AscHeapCtx,
-}
-
-struct AscHeapCtx {
+pub struct AscHeapCtx {
     // Function wrapper for `idof<T>` from AssemblyScript
     id_of_type: Option<wasmtime::TypedFunc<u32, u32>>,
 
@@ -402,402 +177,88 @@ struct AscHeapCtx {
     // is zeroed when initialized or grown.
     memory: Memory,
 
-    // First free byte in the current arena. Set on the first call to `raw_new`.
-    arena_start_ptr: i32,
-
-    // Number of free bytes starting from `arena_start_ptr`.
-    arena_free_size: i32,
+    arena: RwLock<Arena>,
 }
 
-impl<C: Blockchain> WasmInstance<C> {
-    /// Instantiates the module and sets it to be interrupted after `timeout`.
-    pub fn from_valid_module_with_ctx(
-        valid_module: Arc<ValidModule>,
-        ctx: MappingContext<C>,
-        host_metrics: Arc<HostMetrics>,
-        timeout: Option<Duration>,
-        experimental_features: ExperimentalFeatures,
-    ) -> Result<WasmInstance<C>, anyhow::Error> {
-        let mut linker = wasmtime::Linker::new(&wasmtime::Store::new(valid_module.module.engine()));
-        let host_fns = ctx.host_fns.cheap_clone();
-        let api_version = ctx.host_exports.api_version.clone();
-
-        // Used by exports to access the instance context. There are two ways this can be set:
-        // - After instantiation, if no host export is called in the start function.
-        // - During the start function, if it calls a host export.
-        // Either way, after instantiation this will have been set.
-        let shared_ctx: Rc<RefCell<Option<WasmInstanceContext<C>>>> = Rc::new(RefCell::new(None));
-
-        // We will move the ctx only once, to init `shared_ctx`. But we don't statically know where
-        // it will be moved so we need this ugly thing.
-        let ctx: Rc<RefCell<Option<MappingContext<C>>>> = Rc::new(RefCell::new(Some(ctx)));
-
-        // Start the timeout watchdog task.
-        let timeout_stopwatch = Arc::new(std::sync::Mutex::new(TimeoutStopwatch::start_new()));
-        if let Some(timeout) = timeout {
-            // This task is likely to outlive the instance, which is fine.
-            let interrupt_handle = linker.store().interrupt_handle().unwrap();
-            let timeout_stopwatch = timeout_stopwatch.clone();
-            graph::spawn_allow_panic(async move {
-                let minimum_wait = Duration::from_secs(1);
-                loop {
-                    let time_left =
-                        timeout.checked_sub(timeout_stopwatch.lock().unwrap().elapsed());
-                    match time_left {
-                        None => break interrupt_handle.interrupt(), // Timed out.
-
-                        Some(time) if time < minimum_wait => break interrupt_handle.interrupt(),
-                        Some(time) => tokio::time::sleep(time).await,
-                    }
-                }
-            });
-        }
-
-        // Because `gas` and `deterministic_host_trap` need to be accessed from the gas
-        // host fn, they need to be separate from the rest of the context.
-        let gas = GasCounter::new(host_metrics.gas_metrics.clone());
-        let deterministic_host_trap = Rc::new(AtomicBool::new(false));
-
-        macro_rules! link {
-            ($wasm_name:expr, $rust_name:ident, $($param:ident),*) => {
-                link!($wasm_name, $rust_name, "host_export_other", $($param),*)
-            };
-
-            ($wasm_name:expr, $rust_name:ident, $section:expr, $($param:ident),*) => {
-                let modules = valid_module
-                    .import_name_to_modules
-                    .get($wasm_name)
-                    .into_iter()
-                    .flatten();
-
-                // link an import with all the modules that require it.
-                for module in modules {
-                    let func_shared_ctx = Rc::downgrade(&shared_ctx);
-                    let valid_module = valid_module.cheap_clone();
-                    let host_metrics = host_metrics.cheap_clone();
-                    let timeout_stopwatch = timeout_stopwatch.cheap_clone();
-                    let ctx = ctx.cheap_clone();
-                    let gas = gas.cheap_clone();
-                    linker.func(
-                        module,
-                        $wasm_name,
-                        move |caller: wasmtime::Caller, $($param: u32),*| {
-                            let instance = func_shared_ctx.upgrade().unwrap();
-                            let mut instance = instance.borrow_mut();
-
-                            // Happens when calling a host fn in Wasm start.
-                            if instance.is_none() {
-                                *instance = Some(WasmInstanceContext::from_caller(
-                                    caller,
-                                    ctx.borrow_mut().take().unwrap(),
-                                    valid_module.cheap_clone(),
-                                    host_metrics.cheap_clone(),
-                                    timeout,
-                                    timeout_stopwatch.cheap_clone(),
-                                    experimental_features.clone()
-                                ).unwrap())
-                            }
-
-                            let instance = instance.as_mut().unwrap();
-                            let _section = instance.host_metrics.stopwatch.start_section($section);
-
-                            let result = instance.$rust_name(
-                                &gas,
-                                $($param.into()),*
-                            );
-                            match result {
-                                Ok(result) => Ok(result.into_wasm_ret()),
-                                Err(e) => {
-                                    match IntoTrap::determinism_level(&e) {
-                                        DeterminismLevel::Deterministic => {
-                                            instance.deterministic_host_trap = true;
-                                        },
-                                        DeterminismLevel::PossibleReorg => {
-                                            instance.possible_reorg = true;
-                                        },
-                                        DeterminismLevel::Unimplemented | DeterminismLevel::NonDeterministic => {},
-                                    }
-
-                                    Err(IntoTrap::into_trap(e))
-                                }
-                            }
-                        }
-                    )?;
-                }
-            };
-        }
-
-        // Link chain-specifc host fns.
-        for host_fn in host_fns.iter() {
-            let modules = valid_module
-                .import_name_to_modules
-                .get(host_fn.name)
-                .into_iter()
-                .flatten();
-
-            for module in modules {
-                let func_shared_ctx = Rc::downgrade(&shared_ctx);
-                let host_fn = host_fn.cheap_clone();
-                let gas = gas.cheap_clone();
-                linker.func(module, host_fn.name, move |call_ptr: u32| {
-                    let start = Instant::now();
-                    let instance = func_shared_ctx.upgrade().unwrap();
-                    let mut instance = instance.borrow_mut();
-
-                    let instance = match &mut *instance {
-                        Some(instance) => instance,
-
-                        // Happens when calling a host fn in Wasm start.
-                        None => {
-                            return Err(anyhow!(
-                                "{} is not allowed in global variables",
-                                host_fn.name
-                            )
-                            .into());
-                        }
-                    };
-
-                    let name_for_metrics = host_fn.name.replace('.', "_");
-                    let stopwatch = &instance.host_metrics.stopwatch;
-                    let _section =
-                        stopwatch.start_section(&format!("host_export_{}", name_for_metrics));
-                    let metrics = instance.host_metrics.cheap_clone();
-
-                    let ctx = HostFnCtx {
-                        logger: instance.ctx.logger.cheap_clone(),
-                        block_ptr: instance.ctx.block_ptr.cheap_clone(),
-                        heap: instance,
-                        gas: gas.cheap_clone(),
-                        metrics,
-                    };
-                    let ret = (host_fn.func)(ctx, call_ptr).map_err(|e| match e {
-                        HostExportError::Deterministic(e) => {
-                            instance.deterministic_host_trap = true;
-                            e
-                        }
-                        HostExportError::PossibleReorg(e) => {
-                            instance.possible_reorg = true;
-                            e
-                        }
-                        HostExportError::Unknown(e) => e,
-                    })?;
-                    instance.host_metrics.observe_host_fn_execution_time(
-                        start.elapsed().as_secs_f64(),
-                        &name_for_metrics,
-                    );
-                    Ok(ret)
-                })?;
-            }
-        }
-
-        link!("ethereum.encode", ethereum_encode, params_ptr);
-        link!("ethereum.decode", ethereum_decode, params_ptr, data_ptr);
-
-        link!("abort", abort, message_ptr, file_name_ptr, line, column);
-
-        link!("store.get", store_get, "host_export_store_get", entity, id);
-        link!(
-            "store.loadRelated",
-            store_load_related,
-            "host_export_store_load_related",
-            entity,
-            id,
-            field
-        );
-        link!(
-            "store.get_in_block",
-            store_get_in_block,
-            "host_export_store_get_in_block",
-            entity,
-            id
-        );
-        link!(
-            "store.set",
-            store_set,
-            "host_export_store_set",
-            entity,
-            id,
-            data
-        );
-
-        // All IPFS-related functions exported by the host WASM runtime should be listed in the
-        // graph::data::subgraph::features::IPFS_ON_ETHEREUM_CONTRACTS_FUNCTION_NAMES array for
-        // automatic feature detection to work.
-        //
-        // For reference, search this codebase for: ff652476-e6ad-40e4-85b8-e815d6c6e5e2
-        link!("ipfs.cat", ipfs_cat, "host_export_ipfs_cat", hash_ptr);
-        link!(
-            "ipfs.map",
-            ipfs_map,
-            "host_export_ipfs_map",
-            link_ptr,
-            callback,
-            user_data,
-            flags
-        );
-        // The previous ipfs-related functions are unconditionally linked for backward compatibility
-        if experimental_features.allow_non_deterministic_ipfs {
-            link!(
-                "ipfs.getBlock",
-                ipfs_get_block,
-                "host_export_ipfs_get_block",
-                hash_ptr
-            );
-        }
-
-        link!("store.remove", store_remove, entity_ptr, id_ptr);
-
-        link!("typeConversion.bytesToString", bytes_to_string, ptr);
-        link!("typeConversion.bytesToHex", bytes_to_hex, ptr);
-        link!("typeConversion.bigIntToString", big_int_to_string, ptr);
-        link!("typeConversion.bigIntToHex", big_int_to_hex, ptr);
-        link!("typeConversion.stringToH160", string_to_h160, ptr);
-        link!("typeConversion.bytesToBase58", bytes_to_base58, ptr);
-
-        link!("json.fromBytes", json_from_bytes, ptr);
-        link!("json.try_fromBytes", json_try_from_bytes, ptr);
-        link!("json.toI64", json_to_i64, ptr);
-        link!("json.toU64", json_to_u64, ptr);
-        link!("json.toF64", json_to_f64, ptr);
-        link!("json.toBigInt", json_to_big_int, ptr);
-
-        link!("crypto.keccak256", crypto_keccak_256, ptr);
-
-        link!("bigInt.plus", big_int_plus, x_ptr, y_ptr);
-        link!("bigInt.minus", big_int_minus, x_ptr, y_ptr);
-        link!("bigInt.times", big_int_times, x_ptr, y_ptr);
-        link!("bigInt.dividedBy", big_int_divided_by, x_ptr, y_ptr);
-        link!("bigInt.dividedByDecimal", big_int_divided_by_decimal, x, y);
-        link!("bigInt.mod", big_int_mod, x_ptr, y_ptr);
-        link!("bigInt.pow", big_int_pow, x_ptr, exp);
-        link!("bigInt.fromString", big_int_from_string, ptr);
-        link!("bigInt.bitOr", big_int_bit_or, x_ptr, y_ptr);
-        link!("bigInt.bitAnd", big_int_bit_and, x_ptr, y_ptr);
-        link!("bigInt.leftShift", big_int_left_shift, x_ptr, bits);
-        link!("bigInt.rightShift", big_int_right_shift, x_ptr, bits);
-
-        link!("bigDecimal.toString", big_decimal_to_string, ptr);
-        link!("bigDecimal.fromString", big_decimal_from_string, ptr);
-        link!("bigDecimal.plus", big_decimal_plus, x_ptr, y_ptr);
-        link!("bigDecimal.minus", big_decimal_minus, x_ptr, y_ptr);
-        link!("bigDecimal.times", big_decimal_times, x_ptr, y_ptr);
-        link!("bigDecimal.dividedBy", big_decimal_divided_by, x, y);
-        link!("bigDecimal.equals", big_decimal_equals, x_ptr, y_ptr);
-
-        link!("dataSource.create", data_source_create, name, params);
-        link!(
-            "dataSource.createWithContext",
-            data_source_create_with_context,
-            name,
-            params,
-            context
-        );
-        link!("dataSource.address", data_source_address,);
-        link!("dataSource.network", data_source_network,);
-        link!("dataSource.context", data_source_context,);
-
-        link!("ens.nameByHash", ens_name_by_hash, ptr);
-
-        link!("log.log", log_log, level, msg_ptr);
+impl AscHeapCtx {
+    pub(crate) fn new(
+        instance: &wasmtime::Instance,
+        ctx: &mut WasmInstanceContext<'_>,
+        api_version: Version,
+    ) -> anyhow::Result<Arc<AscHeapCtx>> {
+        // Provide access to the WASM runtime linear memory
+        let memory = instance
+            .get_memory(ctx.as_context_mut(), "memory")
+            .context("Failed to find memory export in the WASM module")?;
 
-        // `arweave and `box` functionality was removed, but apiVersion <= 0.0.4 must link it.
-        if api_version <= Version::new(0, 0, 4) {
-            link!("arweave.transactionData", arweave_transaction_data, ptr);
-            link!("box.profile", box_profile, ptr);
-        }
+        let memory_allocate = match &api_version {
+            version if *version <= Version::new(0, 0, 4) => instance
+                .get_func(ctx.as_context_mut(), "memory.allocate")
+                .context("`memory.allocate` function not found"),
+            _ => instance
+                .get_func(ctx.as_context_mut(), "allocate")
+                .context("`allocate` function not found"),
+        }?
+        .typed(ctx.as_context())?
+        .clone();
 
-        // link the `gas` function
-        // See also e3f03e62-40e4-4f8c-b4a1-d0375cca0b76
-        {
-            let gas = gas.cheap_clone();
-            linker.func("gas", "gas", move |gas_used: u32| -> Result<(), Trap> {
-                // Gas metering has a relevant execution cost cost, being called tens of thousands
-                // of times per handler, but it's not worth having a stopwatch section here because
-                // the cost of measuring would be greater than the cost of `consume_host_fn`. Last
-                // time this was benchmarked it took < 100ns to run.
-                if let Err(e) = gas.consume_host_fn_with_metrics(gas_used.saturating_into(), "gas")
-                {
-                    deterministic_host_trap.store(true, Ordering::SeqCst);
-                    return Err(e.into_trap());
-                }
+        let id_of_type = match &api_version {
+            version if *version <= Version::new(0, 0, 4) => None,
+            _ => Some(
+                instance
+                    .get_func(ctx.as_context_mut(), "id_of_type")
+                    .context("`id_of_type` function not found")?
+                    .typed(ctx)?
+                    .clone(),
+            ),
+        };
 
-                Ok(())
-            })?;
-        }
+        Ok(Arc::new(AscHeapCtx {
+            memory_allocate,
+            memory,
+            arena: RwLock::new(Arena::new()),
+            api_version,
+            id_of_type,
+        }))
+    }
 
-        let instance = linker.instantiate(&valid_module.module)?;
+    fn arena_start_ptr(&self) -> i32 {
+        self.arena.read().start
+    }
 
-        // Usually `shared_ctx` is still `None` because no host fns were called during start.
-        if shared_ctx.borrow().is_none() {
-            *shared_ctx.borrow_mut() = Some(WasmInstanceContext::from_instance(
-                &instance,
-                ctx.borrow_mut().take().unwrap(),
-                valid_module,
-                host_metrics,
-                timeout,
-                timeout_stopwatch,
-                experimental_features,
-            )?);
-        }
+    fn arena_free_size(&self) -> i32 {
+        self.arena.read().size
+    }
 
-        match api_version {
-            version if version <= Version::new(0, 0, 4) => {}
-            _ => {
-                instance
-                    .get_func("_start")
-                    .context("`_start` function not found")?
-                    .typed::<(), ()>()?
-                    .call(())?;
-            }
-        }
+    fn set_arena(&self, start_ptr: i32, size: i32) {
+        let mut arena = self.arena.write();
+        arena.start = start_ptr;
+        arena.size = size;
+    }
 
-        Ok(WasmInstance {
-            instance,
-            instance_ctx: shared_ctx,
-            gas,
-        })
+    fn allocated(&self, size: i32) {
+        let mut arena = self.arena.write();
+        arena.start += size;
+        arena.size -= size;
     }
 }
 
-fn host_export_error_from_trap(trap: Trap, context: String) -> HostExportError {
+fn host_export_error_from_trap(trap: Error, context: String) -> HostExportError {
     let trap_is_deterministic = is_trap_deterministic(&trap);
-    let e = Error::from(trap).context(context);
+    let e = trap.context(context);
     match trap_is_deterministic {
         true => HostExportError::Deterministic(e),
         false => HostExportError::Unknown(e),
     }
 }
 
-// This impl is a convenience that delegates to `self.asc_heap`.
-impl<C: Blockchain> AscHeap for WasmInstanceContext<C> {
-    fn raw_new(&mut self, bytes: &[u8], gas: &GasCounter) -> Result<u32, DeterministicHostError> {
-        self.asc_heap.raw_new(bytes, gas)
-    }
-
-    fn read<'a>(
-        &self,
-        offset: u32,
-        buffer: &'a mut [MaybeUninit<u8>],
+#[async_trait]
+impl AscHeap for WasmInstanceContext<'_> {
+    async fn raw_new(
+        &mut self,
+        bytes: &[u8],
         gas: &GasCounter,
-    ) -> Result<&'a mut [u8], DeterministicHostError> {
-        self.asc_heap.read(offset, buffer, gas)
-    }
-
-    fn read_u32(&self, offset: u32, gas: &GasCounter) -> Result<u32, DeterministicHostError> {
-        self.asc_heap.read_u32(offset, gas)
-    }
-
-    fn api_version(&self) -> Version {
-        self.asc_heap.api_version()
-    }
-
-    fn asc_type_id(&mut self, type_id_index: IndexForAscTypeId) -> Result<u32, HostExportError> {
-        self.asc_heap.asc_type_id(type_id_index)
-    }
-}
-
-impl AscHeap for AscHeapCtx {
-    fn raw_new(&mut self, bytes: &[u8], gas: &GasCounter) -> Result<u32, DeterministicHostError> {
+    ) -> Result<u32, DeterministicHostError> {
         // The cost of writing to wasm memory from the host is the same as of writing from wasm
         // using load instructions.
         gas.consume_host_fn_with_metrics(
@@ -811,18 +272,21 @@ impl AscHeap for AscHeapCtx {
         static MIN_ARENA_SIZE: i32 = 10_000;
 
         let size = i32::try_from(bytes.len()).unwrap();
-        if size > self.arena_free_size {
+        if size > self.asc_heap().arena_free_size() {
             // Allocate a new arena. Any free space left in the previous arena is left unused. This
             // causes at most half of memory to be wasted, which is acceptable.
-            let arena_size = size.max(MIN_ARENA_SIZE);
+            let mut arena_size = size.max(MIN_ARENA_SIZE);
 
             // Unwrap: This may panic if more memory needs to be requested from the OS and that
             // fails. This error is not deterministic since it depends on the operating conditions
             // of the node.
-            self.arena_start_ptr = self.memory_allocate.call(arena_size).unwrap();
-            self.arena_free_size = arena_size;
+            let memory_allocate = &self.asc_heap().cheap_clone().memory_allocate;
+            let mut start_ptr = memory_allocate
+                .call_async(self.as_context_mut(), arena_size)
+                .await
+                .unwrap();
 
-            match &self.api_version {
+            match &self.asc_heap().api_version {
                 version if *version <= Version::new(0, 0, 4) => {}
                 _ => {
                     // This arithmetic is done because when you call AssemblyScripts's `__alloc`
@@ -831,18 +295,19 @@ impl AscHeap for AscHeapCtx {
                     // `mmInfo` has size of 4, and everything allocated on AssemblyScript memory
                     // should have alignment of 16, this means we need to do a 12 offset on these
                     // big chunks of untyped allocation.
-                    self.arena_start_ptr += 12;
-                    self.arena_free_size -= 12;
+                    start_ptr += 12;
+                    arena_size -= 12;
                 }
             };
+            self.asc_heap().set_arena(start_ptr, arena_size);
         };
 
-        let ptr = self.arena_start_ptr as usize;
+        let ptr = self.asc_heap().arena_start_ptr() as usize;
 
         // Unwrap: We have just allocated enough space for `bytes`.
-        self.memory.write(ptr, bytes).unwrap();
-        self.arena_start_ptr += size;
-        self.arena_free_size -= size;
+        let memory = self.asc_heap().memory;
+        memory.write(self.as_context_mut(), ptr, bytes).unwrap();
+        self.asc_heap().allocated(size);
 
         Ok(ptr as u32)
     }
@@ -850,13 +315,16 @@ impl AscHeap for AscHeapCtx {
     fn read_u32(&self, offset: u32, gas: &GasCounter) -> Result<u32, DeterministicHostError> {
         gas.consume_host_fn_with_metrics(Gas::new(GAS_COST_LOAD as u64 * 4), "read_u32")?;
         let mut bytes = [0; 4];
-        self.memory.read(offset as usize, &mut bytes).map_err(|_| {
-            DeterministicHostError::from(anyhow!(
-                "Heap access out of bounds. Offset: {} Size: {}",
-                offset,
-                4
-            ))
-        })?;
+        self.asc_heap()
+            .memory
+            .read(self, offset as usize, &mut bytes)
+            .map_err(|_| {
+                DeterministicHostError::from(anyhow!(
+                    "Heap access out of bounds. Offset: {} Size: {}",
+                    offset,
+                    4
+                ))
+            })?;
         Ok(u32::from_le_bytes(bytes))
     }
 
@@ -875,1120 +343,53 @@ impl AscHeap for AscHeapCtx {
 
         let offset = offset as usize;
 
-        unsafe {
-            // Safety: This was copy-pasted from Memory::read, and we ensure
-            // nothing else is writing this memory because we don't call into
-            // WASM here.
-            let src = self
-                .memory
-                .data_unchecked()
-                .get(offset..)
-                .and_then(|s| s.get(..buffer.len()))
-                .ok_or(DeterministicHostError::from(anyhow!(
-                    "Heap access out of bounds. Offset: {} Size: {}",
-                    offset,
-                    buffer.len()
-                )))?;
-
-            Ok(init_slice(src, buffer))
-        }
-    }
-
-    fn api_version(&self) -> Version {
-        self.api_version.clone()
-    }
-
-    fn asc_type_id(&mut self, type_id_index: IndexForAscTypeId) -> Result<u32, HostExportError> {
-        self.id_of_type
-            .as_ref()
-            .unwrap() // Unwrap ok because it's only called on correct apiVersion, look for AscPtr::generate_header
-            .call(type_id_index as u32)
-            .map_err(|trap| {
-                host_export_error_from_trap(
-                    trap,
-                    format!("Failed to call 'asc_type_id' with '{:?}'", type_id_index),
-                )
-            })
-    }
-}
-
-impl<C: Blockchain> WasmInstanceContext<C> {
-    pub fn from_instance(
-        instance: &wasmtime::Instance,
-        ctx: MappingContext<C>,
-        valid_module: Arc<ValidModule>,
-        host_metrics: Arc<HostMetrics>,
-        timeout: Option<Duration>,
-        timeout_stopwatch: Arc<std::sync::Mutex<TimeoutStopwatch>>,
-        experimental_features: ExperimentalFeatures,
-    ) -> Result<Self, anyhow::Error> {
-        // Provide access to the WASM runtime linear memory
-        let memory = instance
-            .get_memory("memory")
-            .context("Failed to find memory export in the WASM module")?;
-
-        let memory_allocate = match &ctx.host_exports.api_version {
-            version if *version <= Version::new(0, 0, 4) => instance
-                .get_func("memory.allocate")
-                .context("`memory.allocate` function not found"),
-            _ => instance
-                .get_func("allocate")
-                .context("`allocate` function not found"),
-        }?
-        .typed()?
-        .clone();
-
-        let id_of_type = match &ctx.host_exports.api_version {
-            version if *version <= Version::new(0, 0, 4) => None,
-            _ => Some(
-                instance
-                    .get_func("id_of_type")
-                    .context("`id_of_type` function not found")?
-                    .typed()?
-                    .clone(),
-            ),
-        };
-
-        Ok(WasmInstanceContext {
-            asc_heap: AscHeapCtx {
-                memory_allocate,
-                memory,
-                arena_start_ptr: 0,
-                arena_free_size: 0,
-                api_version: ctx.host_exports.api_version.clone(),
-                id_of_type,
-            },
-            ctx,
-            valid_module,
-            host_metrics,
-            timeout,
-            timeout_stopwatch,
-            possible_reorg: false,
-            deterministic_host_trap: false,
-            experimental_features,
-        })
-    }
-
-    pub fn from_caller(
-        caller: wasmtime::Caller,
-        ctx: MappingContext<C>,
-        valid_module: Arc<ValidModule>,
-        host_metrics: Arc<HostMetrics>,
-        timeout: Option<Duration>,
-        timeout_stopwatch: Arc<std::sync::Mutex<TimeoutStopwatch>>,
-        experimental_features: ExperimentalFeatures,
-    ) -> Result<Self, anyhow::Error> {
-        let memory = caller
-            .get_export("memory")
-            .and_then(|e| e.into_memory())
-            .context("Failed to find memory export in the WASM module")?;
-
-        let memory_allocate = match &ctx.host_exports.api_version {
-            version if *version <= Version::new(0, 0, 4) => caller
-                .get_export("memory.allocate")
-                .and_then(|e| e.into_func())
-                .context("`memory.allocate` function not found"),
-            _ => caller
-                .get_export("allocate")
-                .and_then(|e| e.into_func())
-                .context("`allocate` function not found"),
-        }?
-        .typed()?
-        .clone();
-
-        let id_of_type = match &ctx.host_exports.api_version {
-            version if *version <= Version::new(0, 0, 4) => None,
-            _ => Some(
-                caller
-                    .get_export("id_of_type")
-                    .and_then(|e| e.into_func())
-                    .context("`id_of_type` function not found")?
-                    .typed()?
-                    .clone(),
-            ),
-        };
-
-        Ok(WasmInstanceContext {
-            asc_heap: AscHeapCtx {
-                memory_allocate,
-                memory,
-                arena_start_ptr: 0,
-                arena_free_size: 0,
-                api_version: ctx.host_exports.api_version.clone(),
-                id_of_type,
-            },
-            ctx,
-            valid_module,
-            host_metrics,
-            timeout,
-            timeout_stopwatch,
-            possible_reorg: false,
-            deterministic_host_trap: false,
-            experimental_features,
-        })
-    }
-
-    fn store_get_scoped(
-        &mut self,
-        gas: &GasCounter,
-        entity_ptr: AscPtr<AscString>,
-        id_ptr: AscPtr<AscString>,
-        scope: GetScope,
-    ) -> Result<AscPtr<AscEntity>, HostExportError> {
-        let _timer = self
-            .host_metrics
-            .cheap_clone()
-            .time_host_fn_execution_region("store_get");
-
-        let entity_type: String = asc_get(self, entity_ptr, gas)?;
-        let id: String = asc_get(self, id_ptr, gas)?;
-        let entity_option = self.ctx.host_exports.store_get(
-            &mut self.ctx.state,
-            entity_type.clone(),
-            id.clone(),
-            gas,
-            scope,
-        )?;
-
-        if self.ctx.instrument {
-            debug!(self.ctx.logger, "store_get";
-                    "type" => &entity_type,
-                    "id" => &id,
-                    "found" => entity_option.is_some());
-        }
-
-        let ret = match entity_option {
-            Some(entity) => {
-                let _section = self
-                    .host_metrics
-                    .stopwatch
-                    .start_section("store_get_asc_new");
-                asc_new(&mut self.asc_heap, &entity.sorted_ref(), gas)?
-            }
-            None => match &self.ctx.debug_fork {
-                Some(fork) => {
-                    let entity_option = fork.fetch(entity_type, id).map_err(|e| {
-                        HostExportError::Unknown(anyhow!(
-                            "store_get: failed to fetch entity from the debug fork: {}",
-                            e
-                        ))
-                    })?;
-                    match entity_option {
-                        Some(entity) => {
-                            let _section = self
-                                .host_metrics
-                                .stopwatch
-                                .start_section("store_get_asc_new");
-                            let entity = asc_new(self, &entity.sorted(), gas)?;
-                            self.store_set(gas, entity_ptr, id_ptr, entity)?;
-                            entity
-                        }
-                        None => AscPtr::null(),
-                    }
-                }
-                None => AscPtr::null(),
-            },
-        };
+        // TODO: Do we still need this? Can we use read directly?
+        let src = self
+            .asc_heap()
+            .memory
+            .data(self)
+            .get(offset..)
+            .and_then(|s| s.get(..buffer.len()))
+            .ok_or(DeterministicHostError::from(anyhow!(
+                "Heap access out of bounds. Offset: {} Size: {}",
+                offset,
+                buffer.len()
+            )))?;
 
-        Ok(ret)
+        Ok(init_slice(src, buffer))
     }
-}
 
-// Implementation of externals.
-impl<C: Blockchain> WasmInstanceContext<C> {
-    /// function abort(message?: string | null, fileName?: string | null, lineNumber?: u32, columnNumber?: u32): void
-    /// Always returns a trap.
-    pub fn abort(
-        &mut self,
-        gas: &GasCounter,
-        message_ptr: AscPtr<AscString>,
-        file_name_ptr: AscPtr<AscString>,
-        line_number: u32,
-        column_number: u32,
-    ) -> Result<Never, DeterministicHostError> {
-        let message = match message_ptr.is_null() {
-            false => Some(asc_get(self, message_ptr, gas)?),
-            true => None,
-        };
-        let file_name = match file_name_ptr.is_null() {
-            false => Some(asc_get(self, file_name_ptr, gas)?),
-            true => None,
-        };
-        let line_number = match line_number {
-            0 => None,
-            _ => Some(line_number),
-        };
-        let column_number = match column_number {
-            0 => None,
-            _ => Some(column_number),
-        };
-
-        self.ctx
-            .host_exports
-            .abort(message, file_name, line_number, column_number, gas)
+    fn api_version(&self) -> &Version {
+        &self.asc_heap().api_version
     }
 
-    /// function store.set(entity: string, id: string, data: Entity): void
-    pub fn store_set(
+    async fn asc_type_id(
         &mut self,
-        gas: &GasCounter,
-        entity_ptr: AscPtr<AscString>,
-        id_ptr: AscPtr<AscString>,
-        data_ptr: AscPtr<AscEntity>,
-    ) -> Result<(), HostExportError> {
-        let stopwatch = &self.host_metrics.stopwatch;
-        stopwatch.start_section("host_export_store_set__wasm_instance_context_store_set");
-
-        let entity: String = asc_get(self, entity_ptr, gas)?;
-        let id: String = asc_get(self, id_ptr, gas)?;
-        let data = asc_get(self, data_ptr, gas)?;
-
-        if self.ctx.instrument {
-            debug!(self.ctx.logger, "store_set";
-                    "type" => &entity,
-                    "id" => &id);
+        type_id_index: IndexForAscTypeId,
+    ) -> Result<u32, HostExportError> {
+        // Check the module-level cache. Lives on ValidModule (Arc-shared, persists
+        // across all triggers for this subgraph module).
+        if let Some(type_id) = self.as_ref().valid_module.get_cached_type_id(type_id_index) {
+            return Ok(type_id);
         }
 
-        self.ctx.host_exports.store_set(
-            &self.ctx.logger,
-            &mut self.ctx.state,
-            self.ctx.block_ptr.number,
-            &self.ctx.proof_of_indexing,
-            self.ctx.timestamp,
-            entity,
-            id,
-            data,
-            stopwatch,
-            gas,
-        )?;
-
-        Ok(())
-    }
-
-    /// function store.remove(entity: string, id: string): void
-    pub fn store_remove(
-        &mut self,
-        gas: &GasCounter,
-        entity_ptr: AscPtr<AscString>,
-        id_ptr: AscPtr<AscString>,
-    ) -> Result<(), HostExportError> {
-        let entity: String = asc_get(self, entity_ptr, gas)?;
-        let id: String = asc_get(self, id_ptr, gas)?;
-        if self.ctx.instrument {
-            debug!(self.ctx.logger, "store_remove";
-                    "type" => &entity,
-                    "id" => &id);
-        }
-        self.ctx.host_exports.store_remove(
-            &self.ctx.logger,
-            &mut self.ctx.state,
-            &self.ctx.proof_of_indexing,
-            entity,
-            id,
-            gas,
-        )
-    }
-
-    /// function store.get(entity: string, id: string): Entity | null
-    pub fn store_get(
-        &mut self,
-        gas: &GasCounter,
-        entity_ptr: AscPtr<AscString>,
-        id_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<AscEntity>, HostExportError> {
-        self.store_get_scoped(gas, entity_ptr, id_ptr, GetScope::Store)
-    }
-
-    /// function store.get_in_block(entity: string, id: string): Entity | null
-    pub fn store_get_in_block(
-        &mut self,
-        gas: &GasCounter,
-        entity_ptr: AscPtr<AscString>,
-        id_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<AscEntity>, HostExportError> {
-        self.store_get_scoped(gas, entity_ptr, id_ptr, GetScope::InBlock)
-    }
-
-    /// function store.loadRelated(entity_type: string, id: string, field: string): Array<Entity>
-    pub fn store_load_related(
-        &mut self,
-        gas: &GasCounter,
-        entity_type_ptr: AscPtr<AscString>,
-        id_ptr: AscPtr<AscString>,
-        field_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<Array<AscPtr<AscEntity>>>, HostExportError> {
-        let entity_type: String = asc_get(self, entity_type_ptr, gas)?;
-        let id: String = asc_get(self, id_ptr, gas)?;
-        let field: String = asc_get(self, field_ptr, gas)?;
-        let entities = self.ctx.host_exports.store_load_related(
-            &mut self.ctx.state,
-            entity_type.clone(),
-            id.clone(),
-            field.clone(),
-            gas,
-        )?;
-
-        let entities: Vec<Vec<(Word, Value)>> =
-            entities.into_iter().map(|entity| entity.sorted()).collect();
-        let ret = asc_new(self, &entities, gas)?;
-        Ok(ret)
-    }
-
-    /// function typeConversion.bytesToString(bytes: Bytes): string
-    pub fn bytes_to_string(
-        &mut self,
-        gas: &GasCounter,
-        bytes_ptr: AscPtr<Uint8Array>,
-    ) -> Result<AscPtr<AscString>, HostExportError> {
-        let string = self.ctx.host_exports.bytes_to_string(
-            &self.ctx.logger,
-            asc_get(self, bytes_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &string, gas)
-    }
-
-    /// Converts bytes to a hex string.
-    /// function typeConversion.bytesToHex(bytes: Bytes): string
-    /// References:
-    /// https://godoc.org/github.com/ethereum/go-ethereum/common/hexutil#hdr-Encoding_Rules
-    /// https://github.com/ethereum/web3.js/blob/f98fe1462625a6c865125fecc9cb6b414f0a5e83/packages/web3-utils/src/utils.js#L283
-    pub fn bytes_to_hex(
-        &mut self,
-        gas: &GasCounter,
-        bytes_ptr: AscPtr<Uint8Array>,
-    ) -> Result<AscPtr<AscString>, HostExportError> {
-        let bytes: Vec<u8> = asc_get(self, bytes_ptr, gas)?;
-        gas.consume_host_fn_with_metrics(
-            gas::DEFAULT_GAS_OP.with_args(gas::complexity::Size, &bytes),
-            "bytes_to_hex",
-        )?;
-
-        // Even an empty string must be prefixed with `0x`.
-        // Encodes each byte as a two hex digits.
-        let hex = format!("0x{}", hex::encode(bytes));
-        asc_new(self, &hex, gas)
-    }
-
-    /// function typeConversion.bigIntToString(n: Uint8Array): string
-    pub fn big_int_to_string(
-        &mut self,
-        gas: &GasCounter,
-        big_int_ptr: AscPtr<AscBigInt>,
-    ) -> Result<AscPtr<AscString>, HostExportError> {
-        let n: BigInt = asc_get(self, big_int_ptr, gas)?;
-        gas.consume_host_fn_with_metrics(
-            gas::DEFAULT_GAS_OP.with_args(gas::complexity::Mul, (&n, &n)),
-            "big_int_to_string",
-        )?;
-        asc_new(self, &n.to_string(), gas)
-    }
-
-    /// function bigInt.fromString(x: string): BigInt
-    pub fn big_int_from_string(
-        &mut self,
-        gas: &GasCounter,
-        string_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let result = self
-            .ctx
-            .host_exports
-            .big_int_from_string(asc_get(self, string_ptr, gas)?, gas)?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function typeConversion.bigIntToHex(n: Uint8Array): string
-    pub fn big_int_to_hex(
-        &mut self,
-        gas: &GasCounter,
-        big_int_ptr: AscPtr<AscBigInt>,
-    ) -> Result<AscPtr<AscString>, HostExportError> {
-        let n: BigInt = asc_get(self, big_int_ptr, gas)?;
-        let hex = self.ctx.host_exports.big_int_to_hex(n, gas)?;
-        asc_new(self, &hex, gas)
-    }
-
-    /// function typeConversion.stringToH160(s: String): H160
-    pub fn string_to_h160(
-        &mut self,
-        gas: &GasCounter,
-        str_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<AscH160>, HostExportError> {
-        let s: String = asc_get(self, str_ptr, gas)?;
-        let h160 = self.ctx.host_exports.string_to_h160(&s, gas)?;
-        asc_new(self, &h160, gas)
-    }
-
-    /// function json.fromBytes(bytes: Bytes): JSONValue
-    pub fn json_from_bytes(
-        &mut self,
-        gas: &GasCounter,
-        bytes_ptr: AscPtr<Uint8Array>,
-    ) -> Result<AscPtr<AscEnum<JsonValueKind>>, HostExportError> {
-        let bytes: Vec<u8> = asc_get(self, bytes_ptr, gas)?;
-        let result = self
-            .ctx
-            .host_exports
-            .json_from_bytes(&bytes, gas)
-            .with_context(|| {
-                format!(
-                    "Failed to parse JSON from byte array. Bytes (truncated to 1024 chars): `{:?}`",
-                    &bytes[..bytes.len().min(1024)],
+        // Cache miss: call into WASM.
+        let asc_heap = self.asc_heap().cheap_clone();
+        let func = asc_heap.id_of_type.as_ref().unwrap();
+        let type_id = func
+            .call_async(self.as_context_mut(), type_id_index as u32)
+            .await
+            .map_err(|trap| {
+                host_export_error_from_trap(
+                    trap.into(),
+                    format!("Failed to call 'asc_type_id' with '{:?}'", type_id_index),
                 )
-            })
-            .map_err(DeterministicHostError::from)?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function json.try_fromBytes(bytes: Bytes): Result<JSONValue, boolean>
-    pub fn json_try_from_bytes(
-        &mut self,
-        gas: &GasCounter,
-        bytes_ptr: AscPtr<Uint8Array>,
-    ) -> Result<AscPtr<AscResult<AscPtr<AscEnum<JsonValueKind>>, bool>>, HostExportError> {
-        let bytes: Vec<u8> = asc_get(self, bytes_ptr, gas)?;
-        let result = self
-            .ctx
-            .host_exports
-            .json_from_bytes(&bytes, gas)
-            .map_err(|e| {
-                warn!(
-                    &self.ctx.logger,
-                    "Failed to parse JSON from byte array";
-                    "bytes" => format!("{:?}", bytes),
-                    "error" => format!("{}", e)
-                );
-
-                // Map JSON errors to boolean to match the `Result<JSONValue, boolean>`
-                // result type expected by mappings
-                true
-            });
-        asc_new(self, &result, gas)
-    }
-
-    /// function ipfs.cat(link: String): Bytes
-    pub fn ipfs_cat(
-        &mut self,
-        gas: &GasCounter,
-        link_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
-        // Note on gas: There is no gas costing for the ipfs call itself,
-        // since it's not enabled on the network.
-
-        if !self.experimental_features.allow_non_deterministic_ipfs {
-            return Err(HostExportError::Deterministic(anyhow!(
-                "`ipfs.cat` is deprecated. Improved support for IPFS will be added in the future"
-            )));
-        }
-
-        let link = asc_get(self, link_ptr, gas)?;
-        let ipfs_res = self.ctx.host_exports.ipfs_cat(&self.ctx.logger, link);
-        match ipfs_res {
-            Ok(bytes) => asc_new(self, &*bytes, gas).map_err(Into::into),
-
-            // Return null in case of error.
-            Err(e) => {
-                info!(&self.ctx.logger, "Failed ipfs.cat, returning `null`";
-                                    "link" => asc_get::<String, _, _>(self, link_ptr, gas)?,
-                                    "error" => e.to_string());
-                Ok(AscPtr::null())
-            }
-        }
-    }
-
-    /// function ipfs.getBlock(link: String): Bytes
-    pub fn ipfs_get_block(
-        &mut self,
-        gas: &GasCounter,
-        link_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
-        // Note on gas: There is no gas costing for the ipfs call itself,
-        // since it's not enabled on the network.
-
-        if !self.experimental_features.allow_non_deterministic_ipfs {
-            return Err(HostExportError::Deterministic(anyhow!(
-                "`ipfs.getBlock` is deprecated. Improved support for IPFS will be added in the future"
-            )));
-        }
-
-        let link = asc_get(self, link_ptr, gas)?;
-        let ipfs_res = self.ctx.host_exports.ipfs_get_block(&self.ctx.logger, link);
-        match ipfs_res {
-            Ok(bytes) => asc_new(self, &*bytes, gas).map_err(Into::into),
-
-            // Return null in case of error.
-            Err(e) => {
-                info!(&self.ctx.logger, "Failed ipfs.getBlock, returning `null`";
-                                    "link" => asc_get::<String, _, _>(self, link_ptr, gas)?,
-                                    "error" => e.to_string());
-                Ok(AscPtr::null())
-            }
-        }
-    }
-
-    /// function ipfs.map(link: String, callback: String, flags: String[]): void
-    pub fn ipfs_map(
-        &mut self,
-        gas: &GasCounter,
-        link_ptr: AscPtr<AscString>,
-        callback: AscPtr<AscString>,
-        user_data: AscPtr<AscEnum<StoreValueKind>>,
-        flags: AscPtr<Array<AscPtr<AscString>>>,
-    ) -> Result<(), HostExportError> {
-        // Note on gas:
-        // Ideally we would consume gas the same as ipfs_cat and then share
-        // gas across the spawned modules for callbacks.
-
-        if !self.experimental_features.allow_non_deterministic_ipfs {
-            return Err(HostExportError::Deterministic(anyhow!(
-                "`ipfs.map` is deprecated. Improved support for IPFS will be added in the future"
-            )));
-        }
-
-        let link: String = asc_get(self, link_ptr, gas)?;
-        let callback: String = asc_get(self, callback, gas)?;
-        let user_data: store::Value = asc_get(self, user_data, gas)?;
-
-        let flags = asc_get(self, flags, gas)?;
-
-        // Pause the timeout while running ipfs_map, ensure it will be restarted by using a guard.
-        self.timeout_stopwatch.lock().unwrap().stop();
-        let defer_stopwatch = self.timeout_stopwatch.clone();
-        let _stopwatch_guard = defer::defer(|| defer_stopwatch.lock().unwrap().start());
-
-        let start_time = Instant::now();
-        let output_states = HostExports::ipfs_map(
-            &self.ctx.host_exports.link_resolver.clone(),
-            self,
-            link.clone(),
-            &callback,
-            user_data,
-            flags,
-        )?;
-
-        debug!(
-            &self.ctx.logger,
-            "Successfully processed file with ipfs.map";
-            "link" => &link,
-            "callback" => &*callback,
-            "n_calls" => output_states.len(),
-            "time" => format!("{}ms", start_time.elapsed().as_millis())
-        );
-        for output_state in output_states {
-            self.ctx.state.extend(output_state);
-        }
-
-        Ok(())
-    }
-
-    /// Expects a decimal string.
-    /// function json.toI64(json: String): i64
-    pub fn json_to_i64(
-        &mut self,
-        gas: &GasCounter,
-        json_ptr: AscPtr<AscString>,
-    ) -> Result<i64, DeterministicHostError> {
-        self.ctx
-            .host_exports
-            .json_to_i64(asc_get(self, json_ptr, gas)?, gas)
-    }
-
-    /// Expects a decimal string.
-    /// function json.toU64(json: String): u64
-    pub fn json_to_u64(
-        &mut self,
-        gas: &GasCounter,
-        json_ptr: AscPtr<AscString>,
-    ) -> Result<u64, DeterministicHostError> {
-        self.ctx
-            .host_exports
-            .json_to_u64(asc_get(self, json_ptr, gas)?, gas)
-    }
-
-    /// Expects a decimal string.
-    /// function json.toF64(json: String): f64
-    pub fn json_to_f64(
-        &mut self,
-        gas: &GasCounter,
-        json_ptr: AscPtr<AscString>,
-    ) -> Result<f64, DeterministicHostError> {
-        self.ctx
-            .host_exports
-            .json_to_f64(asc_get(self, json_ptr, gas)?, gas)
-    }
-
-    /// Expects a decimal string.
-    /// function json.toBigInt(json: String): BigInt
-    pub fn json_to_big_int(
-        &mut self,
-        gas: &GasCounter,
-        json_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let big_int = self
-            .ctx
-            .host_exports
-            .json_to_big_int(asc_get(self, json_ptr, gas)?, gas)?;
-        asc_new(self, &*big_int, gas)
-    }
-
-    /// function crypto.keccak256(input: Bytes): Bytes
-    pub fn crypto_keccak_256(
-        &mut self,
-        gas: &GasCounter,
-        input_ptr: AscPtr<Uint8Array>,
-    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
-        let input = self
-            .ctx
-            .host_exports
-            .crypto_keccak_256(asc_get(self, input_ptr, gas)?, gas)?;
-        asc_new(self, input.as_ref(), gas)
-    }
-
-    /// function bigInt.plus(x: BigInt, y: BigInt): BigInt
-    pub fn big_int_plus(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        y_ptr: AscPtr<AscBigInt>,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let result = self.ctx.host_exports.big_int_plus(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigInt.minus(x: BigInt, y: BigInt): BigInt
-    pub fn big_int_minus(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        y_ptr: AscPtr<AscBigInt>,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let result = self.ctx.host_exports.big_int_minus(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigInt.times(x: BigInt, y: BigInt): BigInt
-    pub fn big_int_times(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        y_ptr: AscPtr<AscBigInt>,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let result = self.ctx.host_exports.big_int_times(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigInt.dividedBy(x: BigInt, y: BigInt): BigInt
-    pub fn big_int_divided_by(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        y_ptr: AscPtr<AscBigInt>,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let result = self.ctx.host_exports.big_int_divided_by(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigInt.dividedByDecimal(x: BigInt, y: BigDecimal): BigDecimal
-    pub fn big_int_divided_by_decimal(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        y_ptr: AscPtr<AscBigDecimal>,
-    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
-        let x = BigDecimal::new(asc_get(self, x_ptr, gas)?, 0);
-        let result =
-            self.ctx
-                .host_exports
-                .big_decimal_divided_by(x, asc_get(self, y_ptr, gas)?, gas)?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigInt.mod(x: BigInt, y: BigInt): BigInt
-    pub fn big_int_mod(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        y_ptr: AscPtr<AscBigInt>,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let result = self.ctx.host_exports.big_int_mod(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigInt.pow(x: BigInt, exp: u8): BigInt
-    pub fn big_int_pow(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        exp: u32,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let exp = u8::try_from(exp).map_err(|e| DeterministicHostError::from(Error::from(e)))?;
-        let result = self
-            .ctx
-            .host_exports
-            .big_int_pow(asc_get(self, x_ptr, gas)?, exp, gas)?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigInt.bitOr(x: BigInt, y: BigInt): BigInt
-    pub fn big_int_bit_or(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        y_ptr: AscPtr<AscBigInt>,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let result = self.ctx.host_exports.big_int_bit_or(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigInt.bitAnd(x: BigInt, y: BigInt): BigInt
-    pub fn big_int_bit_and(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        y_ptr: AscPtr<AscBigInt>,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let result = self.ctx.host_exports.big_int_bit_and(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigInt.leftShift(x: BigInt, bits: u8): BigInt
-    pub fn big_int_left_shift(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        bits: u32,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let bits = u8::try_from(bits).map_err(|e| DeterministicHostError::from(Error::from(e)))?;
-        let result =
-            self.ctx
-                .host_exports
-                .big_int_left_shift(asc_get(self, x_ptr, gas)?, bits, gas)?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigInt.rightShift(x: BigInt, bits: u8): BigInt
-    pub fn big_int_right_shift(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigInt>,
-        bits: u32,
-    ) -> Result<AscPtr<AscBigInt>, HostExportError> {
-        let bits = u8::try_from(bits).map_err(|e| DeterministicHostError::from(Error::from(e)))?;
-        let result =
-            self.ctx
-                .host_exports
-                .big_int_right_shift(asc_get(self, x_ptr, gas)?, bits, gas)?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function typeConversion.bytesToBase58(bytes: Bytes): string
-    pub fn bytes_to_base58(
-        &mut self,
-        gas: &GasCounter,
-        bytes_ptr: AscPtr<Uint8Array>,
-    ) -> Result<AscPtr<AscString>, HostExportError> {
-        let result = self
-            .ctx
-            .host_exports
-            .bytes_to_base58(asc_get(self, bytes_ptr, gas)?, gas)?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigDecimal.toString(x: BigDecimal): string
-    pub fn big_decimal_to_string(
-        &mut self,
-        gas: &GasCounter,
-        big_decimal_ptr: AscPtr<AscBigDecimal>,
-    ) -> Result<AscPtr<AscString>, HostExportError> {
-        let result = self
-            .ctx
-            .host_exports
-            .big_decimal_to_string(asc_get(self, big_decimal_ptr, gas)?, gas)?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigDecimal.fromString(x: string): BigDecimal
-    pub fn big_decimal_from_string(
-        &mut self,
-        gas: &GasCounter,
-        string_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
-        let result = self
-            .ctx
-            .host_exports
-            .big_decimal_from_string(asc_get(self, string_ptr, gas)?, gas)?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigDecimal.plus(x: BigDecimal, y: BigDecimal): BigDecimal
-    pub fn big_decimal_plus(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigDecimal>,
-        y_ptr: AscPtr<AscBigDecimal>,
-    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
-        let result = self.ctx.host_exports.big_decimal_plus(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigDecimal.minus(x: BigDecimal, y: BigDecimal): BigDecimal
-    pub fn big_decimal_minus(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigDecimal>,
-        y_ptr: AscPtr<AscBigDecimal>,
-    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
-        let result = self.ctx.host_exports.big_decimal_minus(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigDecimal.times(x: BigDecimal, y: BigDecimal): BigDecimal
-    pub fn big_decimal_times(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigDecimal>,
-        y_ptr: AscPtr<AscBigDecimal>,
-    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
-        let result = self.ctx.host_exports.big_decimal_times(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigDecimal.dividedBy(x: BigDecimal, y: BigDecimal): BigDecimal
-    pub fn big_decimal_divided_by(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigDecimal>,
-        y_ptr: AscPtr<AscBigDecimal>,
-    ) -> Result<AscPtr<AscBigDecimal>, HostExportError> {
-        let result = self.ctx.host_exports.big_decimal_divided_by(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )?;
-        asc_new(self, &result, gas)
-    }
-
-    /// function bigDecimal.equals(x: BigDecimal, y: BigDecimal): bool
-    pub fn big_decimal_equals(
-        &mut self,
-        gas: &GasCounter,
-        x_ptr: AscPtr<AscBigDecimal>,
-        y_ptr: AscPtr<AscBigDecimal>,
-    ) -> Result<bool, HostExportError> {
-        self.ctx.host_exports.big_decimal_equals(
-            asc_get(self, x_ptr, gas)?,
-            asc_get(self, y_ptr, gas)?,
-            gas,
-        )
-    }
-
-    /// function dataSource.create(name: string, params: Array<string>): void
-    pub fn data_source_create(
-        &mut self,
-        gas: &GasCounter,
-        name_ptr: AscPtr<AscString>,
-        params_ptr: AscPtr<Array<AscPtr<AscString>>>,
-    ) -> Result<(), HostExportError> {
-        let name: String = asc_get(self, name_ptr, gas)?;
-        let params: Vec<String> = asc_get(self, params_ptr, gas)?;
-        self.ctx.host_exports.data_source_create(
-            &self.ctx.logger,
-            &mut self.ctx.state,
-            name,
-            params,
-            None,
-            self.ctx.block_ptr.number,
-            gas,
-        )
-    }
-
-    /// function createWithContext(name: string, params: Array<string>, context: DataSourceContext): void
-    pub fn data_source_create_with_context(
-        &mut self,
-        gas: &GasCounter,
-        name_ptr: AscPtr<AscString>,
-        params_ptr: AscPtr<Array<AscPtr<AscString>>>,
-        context_ptr: AscPtr<AscEntity>,
-    ) -> Result<(), HostExportError> {
-        let name: String = asc_get(self, name_ptr, gas)?;
-        let params: Vec<String> = asc_get(self, params_ptr, gas)?;
-        let context: HashMap<_, _> = asc_get(self, context_ptr, gas)?;
-        let context = DataSourceContext::from(context);
-
-        self.ctx.host_exports.data_source_create(
-            &self.ctx.logger,
-            &mut self.ctx.state,
-            name,
-            params,
-            Some(context),
-            self.ctx.block_ptr.number,
-            gas,
-        )
-    }
-
-    /// function dataSource.address(): Bytes
-    pub fn data_source_address(
-        &mut self,
-        gas: &GasCounter,
-    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
-        asc_new(
-            self,
-            self.ctx.host_exports.data_source_address(gas)?.as_slice(),
-            gas,
-        )
-    }
-
-    /// function dataSource.network(): String
-    pub fn data_source_network(
-        &mut self,
-        gas: &GasCounter,
-    ) -> Result<AscPtr<AscString>, HostExportError> {
-        asc_new(self, &self.ctx.host_exports.data_source_network(gas)?, gas)
-    }
-
-    /// function dataSource.context(): DataSourceContext
-    pub fn data_source_context(
-        &mut self,
-        gas: &GasCounter,
-    ) -> Result<AscPtr<AscEntity>, HostExportError> {
-        asc_new(
-            self,
-            &self
-                .ctx
-                .host_exports
-                .data_source_context(gas)?
-                .map(|e| e.sorted())
-                .unwrap_or(vec![]),
-            gas,
-        )
-    }
-
-    pub fn ens_name_by_hash(
-        &mut self,
-        gas: &GasCounter,
-        hash_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<AscString>, HostExportError> {
-        let hash: String = asc_get(self, hash_ptr, gas)?;
-        let name = self.ctx.host_exports.ens_name_by_hash(&hash, gas)?;
-        if name.is_none() && self.ctx.host_exports.is_ens_data_empty()? {
-            return Err(anyhow!(
-                "Missing ENS data: see https://github.com/graphprotocol/ens-rainbow"
-            )
-            .into());
-        }
-
-        // map `None` to `null`, and `Some(s)` to a runtime string
-        name.map(|name| asc_new(self, &*name, gas).map_err(Into::into))
-            .unwrap_or(Ok(AscPtr::null()))
-    }
-
-    pub fn log_log(
-        &mut self,
-        gas: &GasCounter,
-        level: u32,
-        msg: AscPtr<AscString>,
-    ) -> Result<(), DeterministicHostError> {
-        let level = LogLevel::from(level).into();
-        let msg: String = asc_get(self, msg, gas)?;
-        self.ctx
-            .host_exports
-            .log_log(&self.ctx.mapping_logger, level, msg, gas)
-    }
-
-    /// function encode(token: ethereum.Value): Bytes | null
-    pub fn ethereum_encode(
-        &mut self,
-        gas: &GasCounter,
-        token_ptr: AscPtr<AscEnum<EthereumValueKind>>,
-    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
-        let data = self
-            .ctx
-            .host_exports
-            .ethereum_encode(asc_get(self, token_ptr, gas)?, gas);
-
-        // return `null` if it fails
-        data.map(|bytes| asc_new(self, &*bytes, gas))
-            .unwrap_or(Ok(AscPtr::null()))
-    }
-
-    /// function decode(types: String, data: Bytes): ethereum.Value | null
-    pub fn ethereum_decode(
-        &mut self,
-        gas: &GasCounter,
-        types_ptr: AscPtr<AscString>,
-        data_ptr: AscPtr<Uint8Array>,
-    ) -> Result<AscPtr<AscEnum<EthereumValueKind>>, HostExportError> {
-        let result = self.ctx.host_exports.ethereum_decode(
-            asc_get(self, types_ptr, gas)?,
-            asc_get(self, data_ptr, gas)?,
-            gas,
-        );
-
-        // return `null` if it fails
-        result
-            .map(|param| asc_new(self, &param, gas))
-            .unwrap_or(Ok(AscPtr::null()))
-    }
-
-    /// function arweave.transactionData(txId: string): Bytes | null
-    pub fn arweave_transaction_data(
-        &mut self,
-        _gas: &GasCounter,
-        _tx_id: AscPtr<AscString>,
-    ) -> Result<AscPtr<Uint8Array>, HostExportError> {
-        Err(HostExportError::Deterministic(anyhow!(
-            "`arweave.transactionData` has been removed."
-        )))
-    }
+            })?;
 
-    /// function box.profile(address: string): JSONValue | null
-    pub fn box_profile(
-        &mut self,
-        _gas: &GasCounter,
-        _address: AscPtr<AscString>,
-    ) -> Result<AscPtr<AscJson>, HostExportError> {
-        Err(HostExportError::Deterministic(anyhow!(
-            "`box.profile` has been removed."
-        )))
+        // Store for all future triggers.
+        self.as_ref()
+            .valid_module
+            .cache_type_id(type_id_index, type_id);
+        Ok(type_id)
     }
 }
diff --git a/runtime/wasm/src/module/stopwatch.rs b/runtime/wasm/src/module/stopwatch.rs
deleted file mode 100644
index 52d3b716708..00000000000
--- a/runtime/wasm/src/module/stopwatch.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copied from https://github.com/ellisonch/rust-stopwatch
-// Copyright (c) 2014 Chucky Ellison <cme at freefour.com> under MIT license
-
-use std::default::Default;
-use std::time::{Duration, Instant};
-
-#[derive(Clone, Copy)]
-pub struct TimeoutStopwatch {
-    /// The time the stopwatch was started last, if ever.
-    start_time: Option<Instant>,
-    /// The time elapsed while the stopwatch was running (between start() and stop()).
-    pub elapsed: Duration,
-}
-
-impl Default for TimeoutStopwatch {
-    fn default() -> TimeoutStopwatch {
-        TimeoutStopwatch {
-            start_time: None,
-            elapsed: Duration::from_secs(0),
-        }
-    }
-}
-
-impl TimeoutStopwatch {
-    /// Returns a new stopwatch.
-    pub fn new() -> TimeoutStopwatch {
-        let sw: TimeoutStopwatch = Default::default();
-        sw
-    }
-
-    /// Returns a new stopwatch which will immediately be started.
-    pub fn start_new() -> TimeoutStopwatch {
-        let mut sw = TimeoutStopwatch::new();
-        sw.start();
-        sw
-    }
-
-    /// Starts the stopwatch.
-    pub fn start(&mut self) {
-        self.start_time = Some(Instant::now());
-    }
-
-    /// Stops the stopwatch.
-    pub fn stop(&mut self) {
-        self.elapsed = self.elapsed();
-        self.start_time = None;
-    }
-
-    /// Returns the elapsed time since the start of the stopwatch.
-    pub fn elapsed(&self) -> Duration {
-        match self.start_time {
-            // stopwatch is running
-            Some(t1) => t1.elapsed() + self.elapsed,
-            // stopwatch is not running
-            None => self.elapsed,
-        }
-    }
-}
diff --git a/runtime/wasm/src/to_from/external.rs b/runtime/wasm/src/to_from/external.rs
index 83452369e33..e917ffa2fa9 100644
--- a/runtime/wasm/src/to_from/external.rs
+++ b/runtime/wasm/src/to_from/external.rs
@@ -1,28 +1,21 @@
-use ethabi;
-
+use async_trait::async_trait;
+use graph::abi::DynSolValueExt;
+use graph::abi::{self};
+use graph::data::store::scalar::Timestamp;
 use graph::data::value::Word;
+use graph::prelude::alloy::primitives::{Address, B256};
 use graph::prelude::{BigDecimal, BigInt};
+use graph::runtime::AscHeap;
 use graph::runtime::gas::GasCounter;
 use graph::runtime::{
-    asc_get, asc_new, AscIndexId, AscPtr, AscType, AscValue, HostExportError, ToAscObj,
+    AscIndexId, AscPtr, AscType, AscValue, HostExportError, ToAscObj, asc_get, asc_new,
 };
 use graph::{data::store, runtime::DeterministicHostError};
 use graph::{prelude::serde_json, runtime::FromAscObj};
-use graph::{prelude::web3::types as web3, runtime::AscHeap};
 
 use crate::asc_abi::class::*;
 
-impl ToAscObj<Uint8Array> for web3::H160 {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
-        gas: &GasCounter,
-    ) -> Result<Uint8Array, HostExportError> {
-        self.0.to_asc_obj(heap, gas)
-    }
-}
-
-impl FromAscObj<Uint8Array> for web3::H160 {
+impl FromAscObj<Uint8Array> for Address {
     fn from_asc_obj<H: AscHeap + ?Sized>(
         typed_array: Uint8Array,
         heap: &H,
@@ -30,52 +23,53 @@ impl FromAscObj<Uint8Array> for web3::H160 {
         depth: usize,
     ) -> Result<Self, DeterministicHostError> {
         let data = <[u8; 20]>::from_asc_obj(typed_array, heap, gas, depth)?;
-        Ok(Self(data))
+        Ok(Self::from(data))
     }
 }
 
-impl FromAscObj<Uint8Array> for web3::H256 {
-    fn from_asc_obj<H: AscHeap + ?Sized>(
-        typed_array: Uint8Array,
-        heap: &H,
+#[async_trait]
+impl ToAscObj<Uint8Array> for Address {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
+        &self,
+        heap: &mut H,
         gas: &GasCounter,
-        depth: usize,
-    ) -> Result<Self, DeterministicHostError> {
-        let data = <[u8; 32]>::from_asc_obj(typed_array, heap, gas, depth)?;
-        Ok(Self(data))
+    ) -> Result<Uint8Array, HostExportError> {
+        self.as_slice().to_asc_obj(heap, gas).await
     }
 }
 
-impl ToAscObj<Uint8Array> for web3::H256 {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl ToAscObj<Uint8Array> for B256 {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<Uint8Array, HostExportError> {
-        self.0.to_asc_obj(heap, gas)
+        self.as_slice().to_asc_obj(heap, gas).await
     }
 }
 
-impl ToAscObj<AscBigInt> for web3::U128 {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
-        &self,
-        heap: &mut H,
+impl FromAscObj<Uint8Array> for B256 {
+    fn from_asc_obj<H: AscHeap + ?Sized>(
+        typed_array: Uint8Array,
+        heap: &H,
         gas: &GasCounter,
-    ) -> Result<AscBigInt, HostExportError> {
-        let mut bytes: [u8; 16] = [0; 16];
-        self.to_little_endian(&mut bytes);
-        bytes.to_asc_obj(heap, gas)
+        depth: usize,
+    ) -> Result<Self, DeterministicHostError> {
+        let data = <[u8; 32]>::from_asc_obj(typed_array, heap, gas, depth)?;
+        Ok(Self(data))
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscBigInt> for BigInt {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscBigInt, HostExportError> {
         let bytes = self.to_signed_bytes_le();
-        bytes.to_asc_obj(heap, gas)
+        bytes.to_asc_obj(heap, gas).await
     }
 }
 
@@ -91,8 +85,9 @@ impl FromAscObj<AscBigInt> for BigInt {
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscBigDecimal> for BigDecimal {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -101,8 +96,8 @@ impl ToAscObj<AscBigDecimal> for BigDecimal {
         // so "exponent" is the opposite of what you'd expect.
         let (digits, negative_exp) = self.as_bigint_and_exponent();
         Ok(AscBigDecimal {
-            exp: asc_new(heap, &BigInt::from(-negative_exp), gas)?,
-            digits: asc_new(heap, &BigInt::new(digits)?, gas)?,
+            exp: asc_new(heap, &BigInt::from(-negative_exp), gas).await?,
+            digits: asc_new(heap, &BigInt::new(digits)?, gas).await?,
         })
     }
 }
@@ -139,44 +134,63 @@ impl FromAscObj<AscBigDecimal> for BigDecimal {
     }
 }
 
+#[async_trait]
 impl ToAscObj<Array<AscPtr<AscString>>> for Vec<String> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<Array<AscPtr<AscString>>, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Array::new(&content, heap, gas)
+        let mut content = Vec::new();
+        for x in self {
+            content.push(asc_new(heap, x.as_str(), gas).await?);
+        }
+        Array::new(&content, heap, gas).await
     }
 }
 
-impl ToAscObj<AscEnum<EthereumValueKind>> for ethabi::Token {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl ToAscObj<AscEnum<EthereumValueKind>> for abi::DynSolValue {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEnum<EthereumValueKind>, HostExportError> {
-        use ethabi::Token::*;
-
         let kind = EthereumValueKind::get_kind(self);
+
         let payload = match self {
-            Address(address) => asc_new::<AscAddress, _, _>(heap, address, gas)?.to_payload(),
-            FixedBytes(bytes) | Bytes(bytes) => {
-                asc_new::<Uint8Array, _, _>(heap, &**bytes, gas)?.to_payload()
+            Self::Bool(val) => *val as u64,
+            Self::Int(val, _) => {
+                let bytes = val.to_le_bytes::<32>();
+                let n = BigInt::from_signed_bytes_le(&bytes)?;
+
+                asc_new(heap, &n, gas).await?.to_payload()
             }
-            Int(uint) => {
-                let n = BigInt::from_signed_u256(uint);
-                asc_new(heap, &n, gas)?.to_payload()
+            Self::Uint(val, _) => {
+                let bytes = val.to_le_bytes::<32>();
+                let n = BigInt::from_unsigned_bytes_le(&bytes)?;
+
+                asc_new(heap, &n, gas).await?.to_payload()
             }
-            Uint(uint) => {
-                let n = BigInt::from_unsigned_u256(uint);
-                asc_new(heap, &n, gas)?.to_payload()
+            Self::FixedBytes(val, size) => {
+                // FixedBytes stores the value in a 32-byte word, but we only want the first `size` bytes
+                asc_new::<Uint8Array, _, _>(heap, &val.as_slice()[..*size], gas)
+                    .await?
+                    .to_payload()
             }
-            Bool(b) => *b as u64,
-            String(string) => asc_new(heap, &**string, gas)?.to_payload(),
-            FixedArray(tokens) | Array(tokens) => asc_new(heap, &**tokens, gas)?.to_payload(),
-            Tuple(tokens) => asc_new(heap, &**tokens, gas)?.to_payload(),
+            Self::Address(val) => asc_new::<AscAddress, _, _>(heap, val.as_slice(), gas)
+                .await?
+                .to_payload(),
+            Self::Function(val) => asc_new::<Uint8Array, _, _>(heap, val.as_slice(), gas)
+                .await?
+                .to_payload(),
+            Self::Bytes(val) => asc_new::<Uint8Array, _, _>(heap, &**val, gas)
+                .await?
+                .to_payload(),
+            Self::String(val) => asc_new(heap, &**val, gas).await?.to_payload(),
+            Self::Array(values) => asc_new(heap, &**values, gas).await?.to_payload(),
+            Self::FixedArray(values) => asc_new(heap, &**values, gas).await?.to_payload(),
+            Self::Tuple(values) => asc_new(heap, &**values, gas).await?.to_payload(),
         };
 
         Ok(AscEnum {
@@ -187,57 +201,79 @@ impl ToAscObj<AscEnum<EthereumValueKind>> for ethabi::Token {
     }
 }
 
-impl FromAscObj<AscEnum<EthereumValueKind>> for ethabi::Token {
+impl FromAscObj<AscEnum<EthereumValueKind>> for abi::DynSolValue {
     fn from_asc_obj<H: AscHeap + ?Sized>(
         asc_enum: AscEnum<EthereumValueKind>,
         heap: &H,
         gas: &GasCounter,
         depth: usize,
     ) -> Result<Self, DeterministicHostError> {
-        use ethabi::Token;
-
         let payload = asc_enum.payload;
-        Ok(match asc_enum.kind {
-            EthereumValueKind::Bool => Token::Bool(bool::from(payload)),
+
+        let value = match asc_enum.kind {
             EthereumValueKind::Address => {
                 let ptr: AscPtr<AscAddress> = AscPtr::from(payload);
-                Token::Address(asc_get(heap, ptr, gas, depth)?)
+                let bytes: [u8; 20] = asc_get(heap, ptr, gas, depth)?;
+
+                Self::Address(bytes.into())
             }
             EthereumValueKind::FixedBytes => {
                 let ptr: AscPtr<Uint8Array> = AscPtr::from(payload);
-                Token::FixedBytes(asc_get(heap, ptr, gas, depth)?)
+                let bytes: Vec<u8> = asc_get(heap, ptr, gas, depth)?;
+
+                Self::fixed_bytes_from_slice(&bytes)?
             }
             EthereumValueKind::Bytes => {
                 let ptr: AscPtr<Uint8Array> = AscPtr::from(payload);
-                Token::Bytes(asc_get(heap, ptr, gas, depth)?)
+                let bytes: Vec<u8> = asc_get(heap, ptr, gas, depth)?;
+
+                Self::Bytes(bytes)
             }
             EthereumValueKind::Int => {
                 let ptr: AscPtr<AscBigInt> = AscPtr::from(payload);
                 let n: BigInt = asc_get(heap, ptr, gas, depth)?;
-                Token::Int(n.to_signed_u256())
+                let x = n.to_i256().map_err(DeterministicHostError::Other)?;
+
+                Self::Int(x, x.bits() as usize)
             }
             EthereumValueKind::Uint => {
                 let ptr: AscPtr<AscBigInt> = AscPtr::from(payload);
                 let n: BigInt = asc_get(heap, ptr, gas, depth)?;
-                Token::Uint(n.to_unsigned_u256())
+                let uint = n
+                    .to_unsigned_u256()
+                    .map_err(DeterministicHostError::Other)?;
+                Self::Uint(uint, uint.bit_len())
             }
+            EthereumValueKind::Bool => Self::Bool(bool::from(payload)),
             EthereumValueKind::String => {
                 let ptr: AscPtr<AscString> = AscPtr::from(payload);
-                Token::String(asc_get(heap, ptr, gas, depth)?)
+
+                Self::String(asc_get(heap, ptr, gas, depth)?)
             }
             EthereumValueKind::FixedArray => {
                 let ptr: AscEnumArray<EthereumValueKind> = AscPtr::from(payload);
-                Token::FixedArray(asc_get(heap, ptr, gas, depth)?)
+
+                Self::FixedArray(asc_get(heap, ptr, gas, depth)?)
             }
             EthereumValueKind::Array => {
                 let ptr: AscEnumArray<EthereumValueKind> = AscPtr::from(payload);
-                Token::Array(asc_get(heap, ptr, gas, depth)?)
+
+                Self::Array(asc_get(heap, ptr, gas, depth)?)
             }
             EthereumValueKind::Tuple => {
                 let ptr: AscEnumArray<EthereumValueKind> = AscPtr::from(payload);
-                Token::Tuple(asc_get(heap, ptr, gas, depth)?)
+
+                Self::Tuple(asc_get(heap, ptr, gas, depth)?)
             }
-        })
+            EthereumValueKind::Function => {
+                let ptr: AscPtr<Uint8Array> = AscPtr::from(payload);
+                let bytes: [u8; 24] = asc_get(heap, ptr, gas, depth)?;
+
+                Self::Function(bytes.into())
+            }
+        };
+
+        Ok(value)
     }
 }
 
@@ -258,6 +294,12 @@ impl FromAscObj<AscEnum<StoreValueKind>> for store::Value {
             }
             StoreValueKind::Int => Value::Int(i32::from(payload)),
             StoreValueKind::Int8 => Value::Int8(i64::from(payload)),
+            StoreValueKind::Timestamp => {
+                let ts = Timestamp::from_microseconds_since_epoch(i64::from(payload))
+                    .map_err(|e| DeterministicHostError::Other(e.into()))?;
+
+                Value::Timestamp(ts)
+            }
             StoreValueKind::BigDecimal => {
                 let ptr: AscPtr<AscBigDecimal> = AscPtr::from(payload);
                 Value::BigDecimal(asc_get(heap, ptr, gas, depth)?)
@@ -282,8 +324,9 @@ impl FromAscObj<AscEnum<StoreValueKind>> for store::Value {
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscEnum<StoreValueKind>> for store::Value {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -291,20 +334,21 @@ impl ToAscObj<AscEnum<StoreValueKind>> for store::Value {
         use self::store::Value;
 
         let payload = match self {
-            Value::String(string) => asc_new(heap, string.as_str(), gas)?.into(),
+            Value::String(string) => asc_new(heap, string.as_str(), gas).await?.into(),
             Value::Int(n) => EnumPayload::from(*n),
             Value::Int8(n) => EnumPayload::from(*n),
-            Value::BigDecimal(n) => asc_new(heap, n, gas)?.into(),
+            Value::Timestamp(n) => EnumPayload::from(n),
+            Value::BigDecimal(n) => asc_new(heap, n, gas).await?.into(),
             Value::Bool(b) => EnumPayload::from(*b),
-            Value::List(array) => asc_new(heap, array.as_slice(), gas)?.into(),
+            Value::List(array) => asc_new(heap, array.as_slice(), gas).await?.into(),
             Value::Null => EnumPayload(0),
             Value::Bytes(bytes) => {
-                let bytes_obj: AscPtr<Uint8Array> = asc_new(heap, bytes.as_slice(), gas)?;
+                let bytes_obj: AscPtr<Uint8Array> = asc_new(heap, bytes.as_slice(), gas).await?;
                 bytes_obj.into()
             }
             Value::BigInt(big_int) => {
                 let bytes_obj: AscPtr<Uint8Array> =
-                    asc_new(heap, &*big_int.to_signed_bytes_le(), gas)?;
+                    asc_new(heap, &*big_int.to_signed_bytes_le(), gas).await?;
                 bytes_obj.into()
             }
         };
@@ -317,57 +361,64 @@ impl ToAscObj<AscEnum<StoreValueKind>> for store::Value {
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscJson> for serde_json::Map<String, serde_json::Value> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscJson, HostExportError> {
         Ok(AscTypedMap {
-            entries: asc_new(heap, &*self.iter().collect::<Vec<_>>(), gas)?,
+            entries: asc_new(heap, &*self.iter().collect::<Vec<_>>(), gas).await?,
         })
     }
 }
 
 // Used for serializing entities.
+#[async_trait]
 impl ToAscObj<AscEntity> for Vec<(Word, store::Value)> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEntity, HostExportError> {
         Ok(AscTypedMap {
-            entries: asc_new(heap, self.as_slice(), gas)?,
+            entries: asc_new(heap, self.as_slice(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscEntity> for Vec<(&str, &store::Value)> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscEntity, HostExportError> {
         Ok(AscTypedMap {
-            entries: asc_new(heap, self.as_slice(), gas)?,
+            entries: asc_new(heap, self.as_slice(), gas).await?,
         })
     }
 }
 
+#[async_trait]
 impl ToAscObj<Array<AscPtr<AscEntity>>> for Vec<Vec<(Word, store::Value)>> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<Array<AscPtr<AscEntity>>, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, &x, gas)).collect();
-        let content = content?;
-        Array::new(&content, heap, gas)
+        let mut content = Vec::new();
+        for x in self {
+            content.push(asc_new(heap, &x, gas).await?);
+        }
+        Array::new(&content, heap, gas).await
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscEnum<JsonValueKind>> for serde_json::Value {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -377,10 +428,10 @@ impl ToAscObj<AscEnum<JsonValueKind>> for serde_json::Value {
         let payload = match self {
             Value::Null => EnumPayload(0),
             Value::Bool(b) => EnumPayload::from(*b),
-            Value::Number(number) => asc_new(heap, &*number.to_string(), gas)?.into(),
-            Value::String(string) => asc_new(heap, string.as_str(), gas)?.into(),
-            Value::Array(array) => asc_new(heap, array.as_slice(), gas)?.into(),
-            Value::Object(object) => asc_new(heap, object, gas)?.into(),
+            Value::Number(number) => asc_new(heap, &*number.to_string(), gas).await?.into(),
+            Value::String(string) => asc_new(heap, string.as_str(), gas).await?.into(),
+            Value::Array(array) => asc_new(heap, array.as_slice(), gas).await?.into(),
+            Value::Object(object) => asc_new(heap, object, gas).await?.into(),
         };
 
         Ok(AscEnum {
@@ -404,9 +455,11 @@ impl From<u32> for LogLevel {
     }
 }
 
-impl<T: AscValue> ToAscObj<AscWrapped<T>> for AscWrapped<T> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl<T: AscValue + Sync> ToAscObj<AscWrapped<T>> for AscWrapped<T> {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
+
         _heap: &mut H,
         _gas: &GasCounter,
     ) -> Result<AscWrapped<T>, HostExportError> {
@@ -414,13 +467,14 @@ impl<T: AscValue> ToAscObj<AscWrapped<T>> for AscWrapped<T> {
     }
 }
 
+#[async_trait]
 impl<V, VAsc> ToAscObj<AscResult<AscPtr<VAsc>, bool>> for Result<V, bool>
 where
-    V: ToAscObj<VAsc>,
-    VAsc: AscType + AscIndexId,
+    V: ToAscObj<VAsc> + Sync,
+    VAsc: AscType + AscIndexId + Sync + Send,
     AscWrapped<AscPtr<VAsc>>: AscIndexId,
 {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
@@ -428,9 +482,9 @@ where
         Ok(match self {
             Ok(value) => AscResult {
                 value: {
-                    let inner = asc_new(heap, value, gas)?;
+                    let inner = asc_new(heap, value, gas).await?;
                     let wrapped = AscWrapped { inner };
-                    asc_new(heap, &wrapped, gas)?
+                    asc_new(heap, &wrapped, gas).await?
                 },
                 error: AscPtr::null(),
             },
@@ -438,9 +492,63 @@ where
                 value: AscPtr::null(),
                 error: {
                     let wrapped = AscWrapped { inner: true };
-                    asc_new(heap, &wrapped, gas)?
+                    asc_new(heap, &wrapped, gas).await?
                 },
             },
         })
     }
 }
+
+#[async_trait]
+impl ToAscObj<AscEnum<YamlValueKind>> for serde_yaml::Value {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
+        &self,
+        heap: &mut H,
+        gas: &GasCounter,
+    ) -> Result<AscEnum<YamlValueKind>, HostExportError> {
+        use serde_yaml::Value;
+
+        let payload = match self {
+            Value::Null => EnumPayload(0),
+            Value::Bool(val) => EnumPayload::from(*val),
+            Value::Number(val) => asc_new(heap, &val.to_string(), gas).await?.into(),
+            Value::String(val) => asc_new(heap, val, gas).await?.into(),
+            Value::Sequence(val) => asc_new(heap, val.as_slice(), gas).await?.into(),
+            Value::Mapping(val) => asc_new(heap, val, gas).await?.into(),
+            Value::Tagged(val) => asc_new(heap, val.as_ref(), gas).await?.into(),
+        };
+
+        Ok(AscEnum {
+            kind: YamlValueKind::get_kind(self),
+            _padding: 0,
+            payload,
+        })
+    }
+}
+
+#[async_trait]
+impl ToAscObj<AscTypedMap<AscEnum<YamlValueKind>, AscEnum<YamlValueKind>>> for serde_yaml::Mapping {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
+        &self,
+        heap: &mut H,
+        gas: &GasCounter,
+    ) -> Result<AscTypedMap<AscEnum<YamlValueKind>, AscEnum<YamlValueKind>>, HostExportError> {
+        Ok(AscTypedMap {
+            entries: asc_new(heap, &*self.iter().collect::<Vec<_>>(), gas).await?,
+        })
+    }
+}
+
+#[async_trait]
+impl ToAscObj<AscYamlTaggedValue> for serde_yaml::value::TaggedValue {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
+        &self,
+        heap: &mut H,
+        gas: &GasCounter,
+    ) -> Result<AscYamlTaggedValue, HostExportError> {
+        Ok(AscYamlTaggedValue {
+            tag: asc_new(heap, &self.tag.to_string(), gas).await?,
+            value: asc_new(heap, &self.value, gas).await?,
+        })
+    }
+}
diff --git a/runtime/wasm/src/to_from/mod.rs b/runtime/wasm/src/to_from/mod.rs
index 0f53af8f8d1..5318aac2fd2 100644
--- a/runtime/wasm/src/to_from/mod.rs
+++ b/runtime/wasm/src/to_from/mod.rs
@@ -1,4 +1,7 @@
+//! Implementations of `ToAscObj` and `FromAscObj` for Rust types.
+//! Standard Rust types go in `mod.rs` and external types in `external.rs`.
 use anyhow::anyhow;
+use async_trait::async_trait;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::iter::FromIterator;
@@ -6,30 +9,30 @@ use std::iter::FromIterator;
 use graph::{
     data::value::Word,
     runtime::{
-        asc_get, asc_new, gas::GasCounter, AscHeap, AscIndexId, AscPtr, AscType, AscValue,
-        DeterministicHostError, FromAscObj, HostExportError, ToAscObj,
+        AscHeap, AscIndexId, AscPtr, AscType, AscValue, DeterministicHostError, FromAscObj,
+        HostExportError, ToAscObj, asc_get, asc_new, gas::GasCounter,
     },
 };
 
 use crate::asc_abi::class::*;
 
-///! Implementations of `ToAscObj` and `FromAscObj` for Rust types.
-///! Standard Rust types go in `mod.rs` and external types in `external.rs`.
 mod external;
 
-impl<T: AscValue> ToAscObj<TypedArray<T>> for [T] {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl<T: AscValue + Sync> ToAscObj<TypedArray<T>> for [T] {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<TypedArray<T>, HostExportError> {
-        TypedArray::new(self, heap, gas)
+        TypedArray::new(self, heap, gas).await
     }
 }
 
 impl<T: AscValue> FromAscObj<TypedArray<T>> for Vec<T> {
     fn from_asc_obj<H: AscHeap + ?Sized>(
         typed_array: TypedArray<T>,
+
         heap: &H,
         gas: &GasCounter,
         _depth: usize,
@@ -41,6 +44,7 @@ impl<T: AscValue> FromAscObj<TypedArray<T>> for Vec<T> {
 impl<T: AscValue + Send + Sync, const LEN: usize> FromAscObj<TypedArray<T>> for [T; LEN] {
     fn from_asc_obj<H: AscHeap + ?Sized>(
         typed_array: TypedArray<T>,
+
         heap: &H,
         gas: &GasCounter,
         _depth: usize,
@@ -52,8 +56,9 @@ impl<T: AscValue + Send + Sync, const LEN: usize> FromAscObj<TypedArray<T>> for
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscString> for str {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         _gas: &GasCounter,
@@ -65,8 +70,9 @@ impl ToAscObj<AscString> for str {
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscString> for &str {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         _gas: &GasCounter,
@@ -78,23 +84,25 @@ impl ToAscObj<AscString> for &str {
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscString> for String {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscString, HostExportError> {
-        self.as_str().to_asc_obj(heap, gas)
+        self.as_str().to_asc_obj(heap, gas).await
     }
 }
 
+#[async_trait]
 impl ToAscObj<AscString> for Word {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscString, HostExportError> {
-        self.as_str().to_asc_obj(heap, gas)
+        self.as_str().to_asc_obj(heap, gas).await
     }
 }
 
@@ -119,6 +127,7 @@ impl FromAscObj<AscString> for String {
 impl FromAscObj<AscString> for Word {
     fn from_asc_obj<H: AscHeap + ?Sized>(
         asc_string: AscString,
+
         heap: &H,
         gas: &GasCounter,
         depth: usize,
@@ -129,15 +138,20 @@ impl FromAscObj<AscString> for Word {
     }
 }
 
-impl<C: AscType + AscIndexId, T: ToAscObj<C>> ToAscObj<Array<AscPtr<C>>> for [T] {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl<C: AscType + AscIndexId + Send + Sync, T: ToAscObj<C> + Sync> ToAscObj<Array<AscPtr<C>>>
+    for [T]
+{
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<Array<AscPtr<C>>, HostExportError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Array::new(&content, heap, gas)
+        let mut content = Vec::with_capacity(self.len());
+        for x in self {
+            content.push(asc_new(heap, x, gas).await?);
+        }
+        Array::new(&content, heap, gas).await
     }
 }
 
@@ -172,27 +186,32 @@ impl<K: AscType + AscIndexId, V: AscType + AscIndexId, T: FromAscObj<K>, U: From
     }
 }
 
-impl<K: AscType + AscIndexId, V: AscType + AscIndexId, T: ToAscObj<K>, U: ToAscObj<V>>
-    ToAscObj<AscTypedMapEntry<K, V>> for (T, U)
+#[async_trait]
+impl<K, V, T, U> ToAscObj<AscTypedMapEntry<K, V>> for (T, U)
+where
+    K: AscType + AscIndexId + Send,
+    V: AscType + AscIndexId + Send,
+    T: ToAscObj<K> + Sync,
+    U: ToAscObj<V> + Sync,
 {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
     ) -> Result<AscTypedMapEntry<K, V>, HostExportError> {
         Ok(AscTypedMapEntry {
-            key: asc_new(heap, &self.0, gas)?,
-            value: asc_new(heap, &self.1, gas)?,
+            key: asc_new(heap, &self.0, gas).await?,
+            value: asc_new(heap, &self.1, gas).await?,
         })
     }
 }
 
 impl<
-        K: AscType + AscIndexId,
-        V: AscType + AscIndexId,
-        T: FromAscObj<K> + Hash + Eq,
-        U: FromAscObj<V>,
-    > FromAscObj<AscTypedMap<K, V>> for HashMap<T, U>
+    K: AscType + AscIndexId,
+    V: AscType + AscIndexId,
+    T: FromAscObj<K> + Hash + Eq,
+    U: FromAscObj<V>,
+> FromAscObj<AscTypedMap<K, V>> for HashMap<T, U>
 where
     Array<AscPtr<AscTypedMapEntry<K, V>>>: AscIndexId,
     AscTypedMapEntry<K, V>: AscIndexId,
@@ -204,6 +223,6 @@ where
         depth: usize,
     ) -> Result<Self, DeterministicHostError> {
         let entries: Vec<(T, U)> = asc_get(heap, asc_map.entries, gas, depth)?;
-        Ok(HashMap::from_iter(entries.into_iter()))
+        Ok(HashMap::from_iter(entries))
     }
 }
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index d89a6bef65e..529ab8268aa 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,3 +1,9 @@
 [toolchain]
-channel = "1.68.0"
+# Pinned to 1.94.0 because Rust 1.95.0 has a compiler regression where
+# the `core` crate hits a recursion limit resolving NonZero niche types
+# ("queries overflow the depth limit!" in niche_types.rs). See
+# https://github.com/rust-lang/rust/issues/152942 for details. Switch
+# back to "stable" once a fixed release (1.95.1+ or 1.96.0) is available.
+channel = "1.94.0"
 profile = "default"
+components = [ "rustfmt" ]
diff --git a/server/graphman/Cargo.toml b/server/graphman/Cargo.toml
new file mode 100644
index 00000000000..1e5bd2db23e
--- /dev/null
+++ b/server/graphman/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "graphman-server"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+async-graphql = { workspace = true }
+async-graphql-axum = { workspace = true }
+axum = { workspace = true }
+chrono = { workspace = true }
+graph = { workspace = true }
+graph-store-postgres = { workspace = true }
+graphman = { workspace = true }
+graphman-store = { workspace = true }
+serde_json = { workspace = true }
+slog = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
+tower-http = { workspace = true }
+
+[dev-dependencies]
+diesel = { workspace = true }
+diesel-async = { workspace = true }
+lazy_static = { workspace = true }
+reqwest = { workspace = true }
+serde = { workspace = true }
+test-store = { workspace = true }
diff --git a/server/graphman/src/auth.rs b/server/graphman/src/auth.rs
new file mode 100644
index 00000000000..d83dc58856c
--- /dev/null
+++ b/server/graphman/src/auth.rs
@@ -0,0 +1,148 @@
+use anyhow::anyhow;
+use axum::http::HeaderMap;
+use graph::http::header::AUTHORIZATION;
+
+use crate::GraphmanServerError;
+
+/// Contains a valid authentication token and checks HTTP headers for valid tokens.
+#[derive(Clone)]
+pub struct AuthToken {
+    token: Vec<u8>,
+}
+
+impl AuthToken {
+    pub fn new(token: impl AsRef<str>) -> Result<Self, GraphmanServerError> {
+        let token = token.as_ref().trim().as_bytes().to_vec();
+
+        if token.is_empty() {
+            return Err(GraphmanServerError::InvalidAuthToken(anyhow!(
+                "auth token can not be empty"
+            )));
+        }
+
+        Ok(Self { token })
+    }
+
+    pub fn headers_contain_correct_token(&self, headers: &HeaderMap) -> bool {
+        let header_token = headers
+            .get(AUTHORIZATION)
+            .and_then(|header| header.as_bytes().strip_prefix(b"Bearer "));
+
+        let Some(header_token) = header_token else {
+            return false;
+        };
+
+        let mut token_is_correct = true;
+
+        // We compare every byte of the tokens to prevent token size leaks and timing attacks.
+        for i in 0..std::cmp::max(self.token.len(), header_token.len()) {
+            if self.token.get(i) != header_token.get(i) {
+                token_is_correct = false;
+            }
+        }
+
+        token_is_correct
+    }
+}
+
+pub fn unauthorized_graphql_message() -> serde_json::Value {
+    serde_json::json!({
+        "errors": [
+            {
+                "message": "You are not authorized to access this resource",
+                "extensions": {
+                    "code": "UNAUTHORIZED"
+                }
+            }
+        ],
+        "data": null
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use axum::http::HeaderValue;
+
+    use super::*;
+
+    fn header_value(s: &str) -> HeaderValue {
+        s.try_into().unwrap()
+    }
+
+    fn bearer_value(s: &str) -> HeaderValue {
+        header_value(&format!("Bearer {s}"))
+    }
+
+    #[test]
+    fn require_non_empty_tokens() {
+        assert!(AuthToken::new("").is_err());
+        assert!(AuthToken::new("  ").is_err());
+        assert!(AuthToken::new("\n\n").is_err());
+        assert!(AuthToken::new("\t\t").is_err());
+    }
+
+    #[test]
+    fn check_missing_header() {
+        let token_a = AuthToken::new("123").unwrap();
+        let token_b = AuthToken::new("abc").unwrap();
+
+        let headers = HeaderMap::new();
+
+        assert!(!token_a.headers_contain_correct_token(&headers));
+        assert!(!token_b.headers_contain_correct_token(&headers));
+    }
+
+    #[test]
+    fn check_empty_header() {
+        let token_a = AuthToken::new("123").unwrap();
+        let token_b = AuthToken::new("abc").unwrap();
+
+        let mut headers = HeaderMap::new();
+
+        headers.insert(AUTHORIZATION, header_value(""));
+
+        assert!(!token_a.headers_contain_correct_token(&headers));
+        assert!(!token_b.headers_contain_correct_token(&headers));
+
+        headers.insert(AUTHORIZATION, bearer_value(""));
+
+        assert!(!token_a.headers_contain_correct_token(&headers));
+        assert!(!token_b.headers_contain_correct_token(&headers));
+    }
+
+    #[test]
+    fn check_token_prefix() {
+        let token_a = AuthToken::new("123").unwrap();
+        let token_b = AuthToken::new("abc").unwrap();
+
+        let mut headers = HeaderMap::new();
+
+        headers.insert(AUTHORIZATION, header_value("12"));
+
+        assert!(!token_a.headers_contain_correct_token(&headers));
+        assert!(!token_b.headers_contain_correct_token(&headers));
+
+        headers.insert(AUTHORIZATION, bearer_value("12"));
+
+        assert!(!token_a.headers_contain_correct_token(&headers));
+        assert!(!token_b.headers_contain_correct_token(&headers));
+    }
+
+    #[test]
+    fn validate_tokens() {
+        let token_a = AuthToken::new("123").unwrap();
+        let token_b = AuthToken::new("abc").unwrap();
+
+        let mut headers = HeaderMap::new();
+
+        headers.insert(AUTHORIZATION, bearer_value("123"));
+
+        assert!(token_a.headers_contain_correct_token(&headers));
+        assert!(!token_b.headers_contain_correct_token(&headers));
+
+        headers.insert(AUTHORIZATION, bearer_value("abc"));
+
+        assert!(!token_a.headers_contain_correct_token(&headers));
+        assert!(token_b.headers_contain_correct_token(&headers));
+    }
+}
diff --git a/server/graphman/src/entities/block_hash.rs b/server/graphman/src/entities/block_hash.rs
new file mode 100644
index 00000000000..46ca970beee
--- /dev/null
+++ b/server/graphman/src/entities/block_hash.rs
@@ -0,0 +1,31 @@
+use async_graphql::InputValueError;
+use async_graphql::InputValueResult;
+use async_graphql::Scalar;
+use async_graphql::ScalarType;
+use async_graphql::Value;
+
+/// Represents a block hash in hex form.
+#[derive(Clone, Debug)]
+pub struct BlockHash(pub String);
+
+/// Represents a block hash in hex form.
+#[Scalar]
+impl ScalarType for BlockHash {
+    fn parse(value: Value) -> InputValueResult<Self> {
+        let Value::String(value) = value else {
+            return Err(InputValueError::expected_type(value));
+        };
+
+        Ok(BlockHash(value))
+    }
+
+    fn to_value(&self) -> Value {
+        Value::String(self.0.clone())
+    }
+}
+
+impl From<graph::blockchain::BlockHash> for BlockHash {
+    fn from(block_hash: graph::blockchain::BlockHash) -> Self {
+        Self(block_hash.hash_hex())
+    }
+}
diff --git a/server/graphman/src/entities/block_number.rs b/server/graphman/src/entities/block_number.rs
new file mode 100644
index 00000000000..83fe9714265
--- /dev/null
+++ b/server/graphman/src/entities/block_number.rs
@@ -0,0 +1,29 @@
+use async_graphql::InputValueError;
+use async_graphql::InputValueResult;
+use async_graphql::Scalar;
+use async_graphql::ScalarType;
+use async_graphql::Value;
+
+#[derive(Clone, Debug)]
+pub struct BlockNumber(pub i32);
+
+#[Scalar]
+impl ScalarType for BlockNumber {
+    fn parse(value: Value) -> InputValueResult<Self> {
+        let Value::String(value) = value else {
+            return Err(InputValueError::expected_type(value));
+        };
+
+        Ok(value.parse().map(BlockNumber)?)
+    }
+
+    fn to_value(&self) -> Value {
+        Value::String(self.0.to_string())
+    }
+}
+
+impl From<graph::components::store::BlockNumber> for BlockNumber {
+    fn from(block_number: graph::prelude::BlockNumber) -> Self {
+        Self(block_number)
+    }
+}
diff --git a/server/graphman/src/entities/block_ptr.rs b/server/graphman/src/entities/block_ptr.rs
new file mode 100644
index 00000000000..7ae1ed517ba
--- /dev/null
+++ b/server/graphman/src/entities/block_ptr.rs
@@ -0,0 +1,19 @@
+use async_graphql::SimpleObject;
+
+use crate::entities::BlockHash;
+use crate::entities::BlockNumber;
+
+#[derive(Clone, Debug, SimpleObject)]
+pub struct BlockPtr {
+    pub hash: BlockHash,
+    pub number: BlockNumber,
+}
+
+impl From<graph::blockchain::BlockPtr> for BlockPtr {
+    fn from(block_ptr: graph::blockchain::BlockPtr) -> Self {
+        Self {
+            hash: block_ptr.hash.into(),
+            number: block_ptr.number.into(),
+        }
+    }
+}
diff --git a/server/graphman/src/entities/command_kind.rs b/server/graphman/src/entities/command_kind.rs
new file mode 100644
index 00000000000..9fb324680c6
--- /dev/null
+++ b/server/graphman/src/entities/command_kind.rs
@@ -0,0 +1,8 @@
+use async_graphql::Enum;
+
+/// Types of commands that run in the background.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Enum)]
+#[graphql(remote = "graphman_store::CommandKind")]
+pub enum CommandKind {
+    RestartDeployment,
+}
diff --git a/server/graphman/src/entities/deployment_info.rs b/server/graphman/src/entities/deployment_info.rs
new file mode 100644
index 00000000000..804e0d9ae9e
--- /dev/null
+++ b/server/graphman/src/entities/deployment_info.rs
@@ -0,0 +1,44 @@
+use async_graphql::SimpleObject;
+
+use crate::entities::DeploymentStatus;
+
+#[derive(Clone, Debug, SimpleObject)]
+pub struct DeploymentInfo {
+    pub hash: String,
+    pub namespace: String,
+    pub name: String,
+    pub node_id: Option<String>,
+    pub shard: String,
+    pub chain: String,
+    pub version_status: String,
+    pub is_active: bool,
+    pub status: Option<DeploymentStatus>,
+}
+
+impl From<graphman::deployment::Deployment> for DeploymentInfo {
+    fn from(deployment: graphman::deployment::Deployment) -> Self {
+        let graphman::deployment::Deployment {
+            id: _,
+            hash,
+            namespace,
+            name,
+            node_id,
+            shard,
+            chain,
+            version_status,
+            is_active,
+        } = deployment;
+
+        Self {
+            hash,
+            namespace,
+            name,
+            node_id,
+            shard,
+            chain,
+            version_status,
+            is_active,
+            status: None,
+        }
+    }
+}
diff --git a/server/graphman/src/entities/deployment_selector.rs b/server/graphman/src/entities/deployment_selector.rs
new file mode 100644
index 00000000000..f77ab9ee766
--- /dev/null
+++ b/server/graphman/src/entities/deployment_selector.rs
@@ -0,0 +1,46 @@
+use anyhow::Result;
+use anyhow::anyhow;
+use async_graphql::InputObject;
+
+/// Available criteria for selecting one or more deployments.
+/// No more than one criterion can be selected at a time.
+#[derive(Clone, Debug, InputObject)]
+pub struct DeploymentSelector {
+    /// Selects deployments by subgraph name.
+    ///
+    /// It is not necessary to enter the full name, a name prefix or suffix may be sufficient.
+    pub name: Option<String>,
+
+    /// Selects deployments by IPFS hash. The format is `Qm...`.
+    pub hash: Option<String>,
+
+    /// Since the same IPFS hash can be deployed in multiple shards,
+    /// it is possible to specify the shard.
+    ///
+    /// It only works if the IPFS hash is also provided.
+    pub shard: Option<String>,
+
+    /// Selects a deployment by its database namespace. The format is `sgdNNN`.
+    pub schema: Option<String>,
+}
+
+impl TryFrom<DeploymentSelector> for graphman::deployment::DeploymentSelector {
+    type Error = anyhow::Error;
+
+    fn try_from(deployment: DeploymentSelector) -> Result<Self> {
+        let DeploymentSelector {
+            name,
+            hash,
+            shard,
+            schema,
+        } = deployment;
+
+        match (name, hash, shard, schema) {
+            (Some(name), None, None, None) => Ok(Self::Name(name)),
+            (None, Some(hash), shard, None) => Ok(Self::Subgraph { hash, shard }),
+            (None, None, None, Some(name)) => Ok(Self::Schema(name)),
+            (None, None, None, None) => Err(anyhow!("selector can not be empty")),
+            _ => Err(anyhow!("multiple selectors can not be applied at once")),
+        }
+    }
+}
diff --git a/server/graphman/src/entities/deployment_status.rs b/server/graphman/src/entities/deployment_status.rs
new file mode 100644
index 00000000000..ae9df27c82b
--- /dev/null
+++ b/server/graphman/src/entities/deployment_status.rs
@@ -0,0 +1,37 @@
+use async_graphql::SimpleObject;
+
+use crate::entities::BlockNumber;
+use crate::entities::BlockPtr;
+use crate::entities::SubgraphHealth;
+
+#[derive(Clone, Debug, SimpleObject)]
+pub struct DeploymentStatus {
+    pub is_paused: Option<bool>,
+    pub is_synced: bool,
+    pub health: SubgraphHealth,
+    pub earliest_block_number: BlockNumber,
+    pub latest_block: Option<BlockPtr>,
+    pub chain_head_block: Option<BlockPtr>,
+}
+
+impl From<graphman::commands::deployment::info::DeploymentStatus> for DeploymentStatus {
+    fn from(status: graphman::commands::deployment::info::DeploymentStatus) -> Self {
+        let graphman::commands::deployment::info::DeploymentStatus {
+            is_paused,
+            is_synced,
+            health,
+            earliest_block_number,
+            latest_block,
+            chain_head_block,
+        } = status;
+
+        Self {
+            is_paused,
+            is_synced,
+            health: health.into(),
+            earliest_block_number: earliest_block_number.into(),
+            latest_block: latest_block.map(Into::into),
+            chain_head_block: chain_head_block.map(Into::into),
+        }
+    }
+}
diff --git a/server/graphman/src/entities/deployment_version_selector.rs b/server/graphman/src/entities/deployment_version_selector.rs
new file mode 100644
index 00000000000..59e68d8780f
--- /dev/null
+++ b/server/graphman/src/entities/deployment_version_selector.rs
@@ -0,0 +1,19 @@
+use async_graphql::Enum;
+
+/// Used to filter deployments by version.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Enum)]
+pub enum DeploymentVersionSelector {
+    Current,
+    Pending,
+    Used,
+}
+
+impl From<DeploymentVersionSelector> for graphman::deployment::DeploymentVersionSelector {
+    fn from(version: DeploymentVersionSelector) -> Self {
+        match version {
+            DeploymentVersionSelector::Current => Self::Current,
+            DeploymentVersionSelector::Pending => Self::Pending,
+            DeploymentVersionSelector::Used => Self::Used,
+        }
+    }
+}
diff --git a/server/graphman/src/entities/empty_response.rs b/server/graphman/src/entities/empty_response.rs
new file mode 100644
index 00000000000..a66244f899e
--- /dev/null
+++ b/server/graphman/src/entities/empty_response.rs
@@ -0,0 +1,15 @@
+use async_graphql::SimpleObject;
+
+/// This type is used when an operation has been successful,
+/// but there is no output that can be returned.
+#[derive(Clone, Debug, SimpleObject)]
+pub struct EmptyResponse {
+    pub success: bool,
+}
+
+impl EmptyResponse {
+    /// Returns a successful response.
+    pub fn new() -> Self {
+        Self { success: true }
+    }
+}
diff --git a/server/graphman/src/entities/execution.rs b/server/graphman/src/entities/execution.rs
new file mode 100644
index 00000000000..1daae4a7d01
--- /dev/null
+++ b/server/graphman/src/entities/execution.rs
@@ -0,0 +1,56 @@
+use anyhow::Result;
+use async_graphql::Enum;
+use async_graphql::SimpleObject;
+use chrono::DateTime;
+use chrono::Utc;
+
+use crate::entities::CommandKind;
+use crate::entities::ExecutionId;
+
+/// Data stored about a command execution.
+#[derive(Clone, Debug, SimpleObject)]
+pub struct Execution {
+    pub id: ExecutionId,
+    pub kind: CommandKind,
+    pub status: ExecutionStatus,
+    pub error_message: Option<String>,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: Option<DateTime<Utc>>,
+    pub completed_at: Option<DateTime<Utc>>,
+}
+
+/// All possible states of a command execution.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Enum)]
+#[graphql(remote = "graphman_store::ExecutionStatus")]
+pub enum ExecutionStatus {
+    Initializing,
+    Running,
+    Failed,
+    Succeeded,
+}
+
+impl TryFrom<graphman_store::Execution> for Execution {
+    type Error = anyhow::Error;
+
+    fn try_from(execution: graphman_store::Execution) -> Result<Self> {
+        let graphman_store::Execution {
+            id,
+            kind,
+            status,
+            error_message,
+            created_at,
+            updated_at,
+            completed_at,
+        } = execution;
+
+        Ok(Self {
+            id: id.into(),
+            kind: kind.into(),
+            status: status.into(),
+            error_message,
+            created_at,
+            updated_at,
+            completed_at,
+        })
+    }
+}
diff --git a/server/graphman/src/entities/execution_id.rs b/server/graphman/src/entities/execution_id.rs
new file mode 100644
index 00000000000..bfdc350bcab
--- /dev/null
+++ b/server/graphman/src/entities/execution_id.rs
@@ -0,0 +1,35 @@
+use async_graphql::InputValueError;
+use async_graphql::InputValueResult;
+use async_graphql::Scalar;
+use async_graphql::ScalarType;
+use async_graphql::Value;
+
+#[derive(Clone, Debug)]
+pub struct ExecutionId(pub i64);
+
+#[Scalar]
+impl ScalarType for ExecutionId {
+    fn parse(value: Value) -> InputValueResult<Self> {
+        let Value::String(value) = value else {
+            return Err(InputValueError::expected_type(value));
+        };
+
+        Ok(value.parse().map(ExecutionId)?)
+    }
+
+    fn to_value(&self) -> Value {
+        Value::String(self.0.to_string())
+    }
+}
+
+impl From<graphman_store::ExecutionId> for ExecutionId {
+    fn from(id: graphman_store::ExecutionId) -> Self {
+        Self(id.0)
+    }
+}
+
+impl From<ExecutionId> for graphman_store::ExecutionId {
+    fn from(id: ExecutionId) -> Self {
+        Self(id.0)
+    }
+}
diff --git a/server/graphman/src/entities/mod.rs b/server/graphman/src/entities/mod.rs
new file mode 100644
index 00000000000..c8d3330c9f7
--- /dev/null
+++ b/server/graphman/src/entities/mod.rs
@@ -0,0 +1,27 @@
+mod block_hash;
+mod block_number;
+mod block_ptr;
+mod command_kind;
+mod deployment_info;
+mod deployment_selector;
+mod deployment_status;
+mod deployment_version_selector;
+mod empty_response;
+mod execution;
+mod execution_id;
+mod subgraph_health;
+mod warning_response;
+
+pub use self::block_hash::BlockHash;
+pub use self::block_number::BlockNumber;
+pub use self::block_ptr::BlockPtr;
+pub use self::command_kind::CommandKind;
+pub use self::deployment_info::DeploymentInfo;
+pub use self::deployment_selector::DeploymentSelector;
+pub use self::deployment_status::DeploymentStatus;
+pub use self::deployment_version_selector::DeploymentVersionSelector;
+pub use self::empty_response::EmptyResponse;
+pub use self::execution::Execution;
+pub use self::execution_id::ExecutionId;
+pub use self::subgraph_health::SubgraphHealth;
+pub use self::warning_response::CompletedWithWarnings;
diff --git a/server/graphman/src/entities/subgraph_health.rs b/server/graphman/src/entities/subgraph_health.rs
new file mode 100644
index 00000000000..473423f97f0
--- /dev/null
+++ b/server/graphman/src/entities/subgraph_health.rs
@@ -0,0 +1,14 @@
+use async_graphql::Enum;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Enum)]
+#[graphql(remote = "graph::data::subgraph::schema::SubgraphHealth")]
+pub enum SubgraphHealth {
+    /// Syncing without errors.
+    Healthy,
+
+    /// Syncing but has errors.
+    Unhealthy,
+
+    /// No longer syncing due to a fatal error.
+    Failed,
+}
diff --git a/server/graphman/src/entities/warning_response.rs b/server/graphman/src/entities/warning_response.rs
new file mode 100644
index 00000000000..0bb56aab59b
--- /dev/null
+++ b/server/graphman/src/entities/warning_response.rs
@@ -0,0 +1,16 @@
+use async_graphql::SimpleObject;
+
+#[derive(Clone, Debug, SimpleObject)]
+pub struct CompletedWithWarnings {
+    pub success: bool,
+    pub warnings: Vec<String>,
+}
+
+impl CompletedWithWarnings {
+    pub fn new(warnings: Vec<String>) -> Self {
+        Self {
+            success: true,
+            warnings,
+        }
+    }
+}
diff --git a/server/graphman/src/error.rs b/server/graphman/src/error.rs
new file mode 100644
index 00000000000..96dd31d0050
--- /dev/null
+++ b/server/graphman/src/error.rs
@@ -0,0 +1,10 @@
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum GraphmanServerError {
+    #[error("invalid auth token: {0:#}")]
+    InvalidAuthToken(#[source] anyhow::Error),
+
+    #[error("I/O error: {0:#}")]
+    Io(#[source] anyhow::Error),
+}
diff --git a/server/graphman/src/handlers/graphql.rs b/server/graphman/src/handlers/graphql.rs
new file mode 100644
index 00000000000..8390942f018
--- /dev/null
+++ b/server/graphman/src/handlers/graphql.rs
@@ -0,0 +1,36 @@
+use std::sync::Arc;
+
+use async_graphql::http::GraphQLPlaygroundConfig;
+use async_graphql::http::playground_source;
+use async_graphql_axum::GraphQLRequest;
+use async_graphql_axum::GraphQLResponse;
+use axum::extract::Extension;
+use axum::extract::State;
+use axum::http::HeaderMap;
+use axum::response::Html;
+use axum::response::IntoResponse;
+use axum::response::Json;
+use axum::response::Response;
+
+use crate::auth::unauthorized_graphql_message;
+use crate::handlers::state::AppState;
+use crate::schema::GraphmanSchema;
+
+pub async fn graphql_playground_handler() -> impl IntoResponse {
+    Html(playground_source(GraphQLPlaygroundConfig::new("/")))
+}
+
+pub async fn graphql_request_handler(
+    State(state): State<Arc<AppState>>,
+    Extension(schema): Extension<GraphmanSchema>,
+    headers: HeaderMap,
+    req: GraphQLRequest,
+) -> Response {
+    if !state.auth_token.headers_contain_correct_token(&headers) {
+        return Json(unauthorized_graphql_message()).into_response();
+    }
+
+    let resp: GraphQLResponse = schema.execute(req.into_inner()).await.into();
+
+    resp.into_response()
+}
diff --git a/server/graphman/src/handlers/mod.rs b/server/graphman/src/handlers/mod.rs
new file mode 100644
index 00000000000..57ea7d37ec6
--- /dev/null
+++ b/server/graphman/src/handlers/mod.rs
@@ -0,0 +1,6 @@
+mod graphql;
+mod state;
+
+pub use self::graphql::graphql_playground_handler;
+pub use self::graphql::graphql_request_handler;
+pub use self::state::AppState;
diff --git a/server/graphman/src/handlers/state.rs b/server/graphman/src/handlers/state.rs
new file mode 100644
index 00000000000..b0a0a0e1d21
--- /dev/null
+++ b/server/graphman/src/handlers/state.rs
@@ -0,0 +1,6 @@
+use crate::auth::AuthToken;
+
+/// The state that is shared between all request handlers.
+pub struct AppState {
+    pub auth_token: AuthToken,
+}
diff --git a/server/graphman/src/lib.rs b/server/graphman/src/lib.rs
new file mode 100644
index 00000000000..4a0b9df3a11
--- /dev/null
+++ b/server/graphman/src/lib.rs
@@ -0,0 +1,12 @@
+mod auth;
+mod entities;
+mod error;
+mod handlers;
+mod resolvers;
+mod schema;
+mod server;
+
+pub use self::error::GraphmanServerError;
+pub use self::server::GraphmanServer;
+pub use self::server::GraphmanServerConfig;
+pub use self::server::GraphmanServerManager;
diff --git a/server/graphman/src/resolvers/context.rs b/server/graphman/src/resolvers/context.rs
new file mode 100644
index 00000000000..14726b2ae30
--- /dev/null
+++ b/server/graphman/src/resolvers/context.rs
@@ -0,0 +1,27 @@
+use std::sync::Arc;
+
+use async_graphql::Context;
+use async_graphql::Result;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graph_store_postgres::Store;
+
+pub struct GraphmanContext {
+    pub primary_pool: ConnectionPool,
+    pub notification_sender: Arc<NotificationSender>,
+    pub store: Arc<Store>,
+}
+
+impl GraphmanContext {
+    pub fn new(ctx: &Context<'_>) -> Result<GraphmanContext> {
+        let primary_pool = ctx.data::<ConnectionPool>()?.to_owned();
+        let notification_sender = ctx.data::<Arc<NotificationSender>>()?.to_owned();
+        let store = ctx.data::<Arc<Store>>()?.to_owned();
+
+        Ok(GraphmanContext {
+            primary_pool,
+            notification_sender,
+            store,
+        })
+    }
+}
diff --git a/server/graphman/src/resolvers/deployment_mutation.rs b/server/graphman/src/resolvers/deployment_mutation.rs
new file mode 100644
index 00000000000..c4a9b483fa9
--- /dev/null
+++ b/server/graphman/src/resolvers/deployment_mutation.rs
@@ -0,0 +1,130 @@
+use std::sync::Arc;
+
+use anyhow::anyhow;
+use async_graphql::Context;
+use async_graphql::Object;
+use async_graphql::Result;
+use async_graphql::Union;
+use graph::prelude::NodeId;
+use graph_store_postgres::graphman::GraphmanStore;
+use graphman::commands::deployment::reassign::ReassignResult;
+
+use crate::entities::CompletedWithWarnings;
+use crate::entities::DeploymentSelector;
+use crate::entities::EmptyResponse;
+use crate::entities::ExecutionId;
+use crate::resolvers::context::GraphmanContext;
+
+mod create;
+mod pause;
+mod reassign;
+mod remove;
+mod restart;
+mod resume;
+mod unassign;
+
+pub struct DeploymentMutation;
+
+#[derive(Clone, Debug, Union)]
+pub enum ReassignResponse {
+    Ok(EmptyResponse),
+    CompletedWithWarnings(CompletedWithWarnings),
+}
+
+/// Mutations related to one or multiple deployments.
+#[Object]
+impl DeploymentMutation {
+    /// Pauses a deployment that is not already paused.
+    pub async fn pause(
+        &self,
+        ctx: &Context<'_>,
+        deployment: DeploymentSelector,
+    ) -> Result<EmptyResponse> {
+        let ctx = GraphmanContext::new(ctx)?;
+        let deployment = deployment.try_into()?;
+
+        pause::run(&ctx, &deployment).await?;
+
+        Ok(EmptyResponse::new())
+    }
+
+    /// Resumes a deployment that has been previously paused.
+    pub async fn resume(
+        &self,
+        ctx: &Context<'_>,
+        deployment: DeploymentSelector,
+    ) -> Result<EmptyResponse> {
+        let ctx = GraphmanContext::new(ctx)?;
+        let deployment = deployment.try_into()?;
+
+        resume::run(&ctx, &deployment).await?;
+
+        Ok(EmptyResponse::new())
+    }
+
+    /// Pauses a deployment and resumes it after a delay.
+    pub async fn restart(
+        &self,
+        ctx: &Context<'_>,
+        deployment: DeploymentSelector,
+        #[graphql(
+            default = 20,
+            desc = "The number of seconds to wait before resuming the deployment.
+                    When not specified, it defaults to 20 seconds."
+        )]
+        delay_seconds: u64,
+    ) -> Result<ExecutionId> {
+        let store = ctx.data::<Arc<GraphmanStore>>()?.to_owned();
+        let ctx = GraphmanContext::new(ctx)?;
+        let deployment = deployment.try_into()?;
+
+        restart::run_in_background(ctx, store, deployment, delay_seconds).await
+    }
+
+    /// Create a subgraph
+    pub async fn create(&self, ctx: &Context<'_>, name: String) -> Result<EmptyResponse> {
+        let ctx = GraphmanContext::new(ctx)?;
+        create::run(&ctx, &name).await?;
+        Ok(EmptyResponse::new())
+    }
+
+    /// Remove a subgraph
+    pub async fn remove(&self, ctx: &Context<'_>, name: String) -> Result<EmptyResponse> {
+        let ctx = GraphmanContext::new(ctx)?;
+        remove::run(&ctx, &name).await?;
+        Ok(EmptyResponse::new())
+    }
+
+    /// Unassign a deployment
+    pub async fn unassign(
+        &self,
+        ctx: &Context<'_>,
+        deployment: DeploymentSelector,
+    ) -> Result<EmptyResponse> {
+        let ctx = GraphmanContext::new(ctx)?;
+        let deployment = deployment.try_into()?;
+
+        unassign::run(&ctx, &deployment).await?;
+
+        Ok(EmptyResponse::new())
+    }
+
+    /// Assign or reassign a deployment
+    pub async fn reassign(
+        &self,
+        ctx: &Context<'_>,
+        deployment: DeploymentSelector,
+        node: String,
+    ) -> Result<ReassignResponse> {
+        let ctx = GraphmanContext::new(ctx)?;
+        let deployment = deployment.try_into()?;
+        let node = NodeId::new(node).map_err(|node| anyhow!("illegal node id `{}`", node))?;
+        let reassign_result = reassign::run(&ctx, &deployment, &node).await?;
+        match reassign_result {
+            ReassignResult::CompletedWithWarnings(warnings) => Ok(
+                ReassignResponse::CompletedWithWarnings(CompletedWithWarnings::new(warnings)),
+            ),
+            ReassignResult::Ok => Ok(ReassignResponse::Ok(EmptyResponse::new())),
+        }
+    }
+}
diff --git a/server/graphman/src/resolvers/deployment_mutation/create.rs b/server/graphman/src/resolvers/deployment_mutation/create.rs
new file mode 100644
index 00000000000..9c9bd09542e
--- /dev/null
+++ b/server/graphman/src/resolvers/deployment_mutation/create.rs
@@ -0,0 +1,30 @@
+use anyhow::anyhow;
+use async_graphql::Result;
+use graph::prelude::SubgraphName;
+use graph_store_postgres::command_support::catalog;
+
+use crate::resolvers::context::GraphmanContext;
+use graphman::GraphmanError;
+
+pub async fn run(ctx: &GraphmanContext, name: &String) -> Result<()> {
+    let primary_pool = ctx
+        .primary_pool
+        .get_permitted()
+        .await
+        .map_err(GraphmanError::from)?;
+    let mut catalog_conn = catalog::Connection::new(primary_pool);
+
+    let name = match SubgraphName::new(name) {
+        Ok(name) => name,
+        Err(_) => {
+            return Err(GraphmanError::Store(anyhow!(
+                "Subgraph name must contain only a-z, A-Z, 0-9, '-' and '_'"
+            ))
+            .into());
+        }
+    };
+
+    catalog_conn.create_subgraph(&name).await?;
+
+    Ok(())
+}
diff --git a/server/graphman/src/resolvers/deployment_mutation/pause.rs b/server/graphman/src/resolvers/deployment_mutation/pause.rs
new file mode 100644
index 00000000000..386747f1af5
--- /dev/null
+++ b/server/graphman/src/resolvers/deployment_mutation/pause.rs
@@ -0,0 +1,30 @@
+use async_graphql::Result;
+use graphman::commands::deployment::pause::{
+    PauseDeploymentError, load_active_deployment, pause_active_deployment,
+};
+use graphman::deployment::DeploymentSelector;
+
+use crate::resolvers::context::GraphmanContext;
+
+pub async fn run(ctx: &GraphmanContext, deployment: &DeploymentSelector) -> Result<()> {
+    let active_deployment = load_active_deployment(ctx.primary_pool.clone(), deployment).await;
+
+    match active_deployment {
+        Ok(active_deployment) => {
+            pause_active_deployment(
+                ctx.primary_pool.clone(),
+                ctx.notification_sender.clone(),
+                active_deployment,
+            )
+            .await?;
+        }
+        Err(PauseDeploymentError::AlreadyPaused(_)) => {
+            return Ok(());
+        }
+        Err(PauseDeploymentError::Common(e)) => {
+            return Err(e.into());
+        }
+    }
+
+    Ok(())
+}
diff --git a/server/graphman/src/resolvers/deployment_mutation/reassign.rs b/server/graphman/src/resolvers/deployment_mutation/reassign.rs
new file mode 100644
index 00000000000..ee24719c328
--- /dev/null
+++ b/server/graphman/src/resolvers/deployment_mutation/reassign.rs
@@ -0,0 +1,28 @@
+use anyhow::Ok;
+use async_graphql::Result;
+use graph::prelude::NodeId;
+use graphman::commands::deployment::reassign::ReassignResult;
+use graphman::commands::deployment::reassign::load_deployment;
+use graphman::commands::deployment::reassign::reassign_deployment;
+use graphman::deployment::DeploymentSelector;
+
+use crate::resolvers::context::GraphmanContext;
+
+pub async fn run(
+    ctx: &GraphmanContext,
+    deployment: &DeploymentSelector,
+    node: &NodeId,
+) -> Result<ReassignResult, anyhow::Error> {
+    let deployment = load_deployment(ctx.primary_pool.clone(), deployment).await?;
+    let curr_node = deployment.assigned_node(ctx.primary_pool.clone()).await?;
+
+    let reassign_result = reassign_deployment(
+        ctx.primary_pool.clone(),
+        ctx.notification_sender.clone(),
+        &deployment,
+        node,
+        curr_node,
+    )
+    .await?;
+    Ok(reassign_result)
+}
diff --git a/server/graphman/src/resolvers/deployment_mutation/remove.rs b/server/graphman/src/resolvers/deployment_mutation/remove.rs
new file mode 100644
index 00000000000..b310281d52c
--- /dev/null
+++ b/server/graphman/src/resolvers/deployment_mutation/remove.rs
@@ -0,0 +1,33 @@
+use anyhow::anyhow;
+use async_graphql::Result;
+use graph::prelude::{StoreEvent, SubgraphName};
+use graph_store_postgres::command_support::catalog;
+
+use crate::resolvers::context::GraphmanContext;
+use graphman::GraphmanError;
+
+pub async fn run(ctx: &GraphmanContext, name: &String) -> Result<()> {
+    let primary_pool = ctx
+        .primary_pool
+        .get_permitted()
+        .await
+        .map_err(GraphmanError::from)?;
+    let mut catalog_conn = catalog::Connection::new(primary_pool);
+
+    let name = match SubgraphName::new(name) {
+        Ok(name) => name,
+        Err(_) => {
+            return Err(GraphmanError::Store(anyhow!(
+                "Subgraph name must contain only a-z, A-Z, 0-9, '-' and '_'"
+            ))
+            .into());
+        }
+    };
+
+    let changes = catalog_conn.remove_subgraph(name).await?;
+    catalog_conn
+        .send_store_event(&ctx.notification_sender, &StoreEvent::new(changes))
+        .await?;
+
+    Ok(())
+}
diff --git a/server/graphman/src/resolvers/deployment_mutation/restart.rs b/server/graphman/src/resolvers/deployment_mutation/restart.rs
new file mode 100644
index 00000000000..477ee7fb261
--- /dev/null
+++ b/server/graphman/src/resolvers/deployment_mutation/restart.rs
@@ -0,0 +1,51 @@
+use std::sync::Arc;
+use std::time::Duration;
+
+use async_graphql::Result;
+use graph_store_postgres::graphman::GraphmanStore;
+use graphman::GraphmanExecutionTracker;
+use graphman::deployment::DeploymentSelector;
+use graphman_store::CommandKind;
+use graphman_store::GraphmanStore as _;
+
+use crate::entities::ExecutionId;
+use crate::resolvers::context::GraphmanContext;
+
+pub async fn run_in_background(
+    ctx: GraphmanContext,
+    store: Arc<GraphmanStore>,
+    deployment: DeploymentSelector,
+    delay_seconds: u64,
+) -> Result<ExecutionId> {
+    let id = store.new_execution(CommandKind::RestartDeployment).await?;
+
+    graph::spawn(async move {
+        let tracker = GraphmanExecutionTracker::new(store, id);
+        let result = run(&ctx, &deployment, delay_seconds).await;
+
+        match result {
+            Ok(()) => {
+                tracker.track_success().await.unwrap();
+            }
+            Err(err) => {
+                tracker.track_failure(format!("{err:#?}")).await.unwrap();
+            }
+        };
+    });
+
+    Ok(id.into())
+}
+
+async fn run(
+    ctx: &GraphmanContext,
+    deployment: &DeploymentSelector,
+    delay_seconds: u64,
+) -> Result<()> {
+    super::pause::run(ctx, deployment).await?;
+
+    tokio::time::sleep(Duration::from_secs(delay_seconds)).await;
+
+    super::resume::run(ctx, deployment).await?;
+
+    Ok(())
+}
diff --git a/server/graphman/src/resolvers/deployment_mutation/resume.rs b/server/graphman/src/resolvers/deployment_mutation/resume.rs
new file mode 100644
index 00000000000..1a39426be43
--- /dev/null
+++ b/server/graphman/src/resolvers/deployment_mutation/resume.rs
@@ -0,0 +1,19 @@
+use async_graphql::Result;
+use graphman::commands::deployment::resume::load_paused_deployment;
+use graphman::commands::deployment::resume::resume_paused_deployment;
+use graphman::deployment::DeploymentSelector;
+
+use crate::resolvers::context::GraphmanContext;
+
+pub async fn run(ctx: &GraphmanContext, deployment: &DeploymentSelector) -> Result<()> {
+    let paused_deployment = load_paused_deployment(ctx.primary_pool.clone(), deployment).await?;
+
+    resume_paused_deployment(
+        ctx.primary_pool.clone(),
+        ctx.notification_sender.clone(),
+        paused_deployment,
+    )
+    .await?;
+
+    Ok(())
+}
diff --git a/server/graphman/src/resolvers/deployment_mutation/unassign.rs b/server/graphman/src/resolvers/deployment_mutation/unassign.rs
new file mode 100644
index 00000000000..73598259df8
--- /dev/null
+++ b/server/graphman/src/resolvers/deployment_mutation/unassign.rs
@@ -0,0 +1,18 @@
+use async_graphql::Result;
+use graphman::commands::deployment::unassign::load_assigned_deployment;
+use graphman::commands::deployment::unassign::unassign_deployment;
+use graphman::deployment::DeploymentSelector;
+
+use crate::resolvers::context::GraphmanContext;
+
+pub async fn run(ctx: &GraphmanContext, deployment: &DeploymentSelector) -> Result<()> {
+    let deployment = load_assigned_deployment(ctx.primary_pool.clone(), deployment).await?;
+    unassign_deployment(
+        ctx.primary_pool.clone(),
+        ctx.notification_sender.clone(),
+        deployment,
+    )
+    .await?;
+
+    Ok(())
+}
diff --git a/server/graphman/src/resolvers/deployment_query.rs b/server/graphman/src/resolvers/deployment_query.rs
new file mode 100644
index 00000000000..8763f2d5f10
--- /dev/null
+++ b/server/graphman/src/resolvers/deployment_query.rs
@@ -0,0 +1,29 @@
+use async_graphql::Context;
+use async_graphql::Object;
+use async_graphql::Result;
+
+use crate::entities::DeploymentInfo;
+use crate::entities::DeploymentSelector;
+use crate::entities::DeploymentVersionSelector;
+
+mod info;
+
+pub struct DeploymentQuery;
+
+/// Queries related to one or multiple deployments.
+#[Object]
+impl DeploymentQuery {
+    /// Returns the available information about one, multiple, or all deployments.
+    pub async fn info(
+        &self,
+        ctx: &Context<'_>,
+        #[graphql(desc = "A selector for one or multiple deployments.
+                          When not provided, it matches all deployments.")]
+        deployment: Option<DeploymentSelector>,
+        #[graphql(desc = "Applies version filter to the selected deployments.
+                          When not provided, no additional version filter is applied.")]
+        version: Option<DeploymentVersionSelector>,
+    ) -> Result<Vec<DeploymentInfo>> {
+        info::run(ctx, deployment, version).await
+    }
+}
diff --git a/server/graphman/src/resolvers/deployment_query/info.rs b/server/graphman/src/resolvers/deployment_query/info.rs
new file mode 100644
index 00000000000..ce25da2522b
--- /dev/null
+++ b/server/graphman/src/resolvers/deployment_query/info.rs
@@ -0,0 +1,56 @@
+use async_graphql::Context;
+use async_graphql::Result;
+
+use crate::entities::DeploymentInfo;
+use crate::entities::DeploymentSelector;
+use crate::entities::DeploymentVersionSelector;
+use crate::resolvers::context::GraphmanContext;
+
+pub async fn run(
+    ctx: &Context<'_>,
+    deployment: Option<DeploymentSelector>,
+    version: Option<DeploymentVersionSelector>,
+) -> Result<Vec<DeploymentInfo>> {
+    let load_status = ctx.look_ahead().field("status").exists();
+    let ctx = GraphmanContext::new(ctx)?;
+
+    let deployment = deployment
+        .map(TryInto::try_into)
+        .transpose()?
+        .unwrap_or(graphman::deployment::DeploymentSelector::All);
+
+    let version = version
+        .map(Into::into)
+        .unwrap_or(graphman::deployment::DeploymentVersionSelector::All);
+
+    let deployments = graphman::commands::deployment::info::load_deployments(
+        ctx.primary_pool.clone(),
+        &deployment,
+        &version,
+    )
+    .await?;
+
+    let statuses = if load_status {
+        graphman::commands::deployment::info::load_deployment_statuses(
+            ctx.store.clone(),
+            &deployments,
+        )
+        .await?
+    } else {
+        Default::default()
+    };
+
+    let resp = deployments
+        .into_iter()
+        .map(|deployment| {
+            let status = statuses.get(&deployment.id).cloned().map(Into::into);
+
+            let mut info: DeploymentInfo = deployment.into();
+            info.status = status;
+
+            info
+        })
+        .collect();
+
+    Ok(resp)
+}
diff --git a/server/graphman/src/resolvers/execution_query.rs b/server/graphman/src/resolvers/execution_query.rs
new file mode 100644
index 00000000000..44eaf3c9b81
--- /dev/null
+++ b/server/graphman/src/resolvers/execution_query.rs
@@ -0,0 +1,24 @@
+use std::sync::Arc;
+
+use async_graphql::Context;
+use async_graphql::Object;
+use async_graphql::Result;
+use graph_store_postgres::graphman::GraphmanStore;
+use graphman_store::GraphmanStore as _;
+
+use crate::entities::Execution;
+use crate::entities::ExecutionId;
+
+pub struct ExecutionQuery;
+
+/// Queries related to command executions.
+#[Object]
+impl ExecutionQuery {
+    /// Returns all stored command execution data.
+    pub async fn info(&self, ctx: &Context<'_>, id: ExecutionId) -> Result<Execution> {
+        let store = ctx.data::<Arc<GraphmanStore>>()?.to_owned();
+        let execution = store.load_execution(id.into()).await?;
+
+        Ok(execution.try_into()?)
+    }
+}
diff --git a/server/graphman/src/resolvers/mod.rs b/server/graphman/src/resolvers/mod.rs
new file mode 100644
index 00000000000..2f7f225f6f4
--- /dev/null
+++ b/server/graphman/src/resolvers/mod.rs
@@ -0,0 +1,12 @@
+mod context;
+mod deployment_mutation;
+mod deployment_query;
+mod execution_query;
+mod mutation_root;
+mod query_root;
+
+pub use self::deployment_mutation::DeploymentMutation;
+pub use self::deployment_query::DeploymentQuery;
+pub use self::execution_query::ExecutionQuery;
+pub use self::mutation_root::MutationRoot;
+pub use self::query_root::QueryRoot;
diff --git a/server/graphman/src/resolvers/mutation_root.rs b/server/graphman/src/resolvers/mutation_root.rs
new file mode 100644
index 00000000000..566f21ac728
--- /dev/null
+++ b/server/graphman/src/resolvers/mutation_root.rs
@@ -0,0 +1,14 @@
+use async_graphql::Object;
+
+use crate::resolvers::DeploymentMutation;
+
+/// Note: Converted to GraphQL schema as `mutation`.
+pub struct MutationRoot;
+
+#[Object]
+impl MutationRoot {
+    /// Mutations related to one or multiple deployments.
+    pub async fn deployment(&self) -> DeploymentMutation {
+        DeploymentMutation {}
+    }
+}
diff --git a/server/graphman/src/resolvers/query_root.rs b/server/graphman/src/resolvers/query_root.rs
new file mode 100644
index 00000000000..1c105abe40a
--- /dev/null
+++ b/server/graphman/src/resolvers/query_root.rs
@@ -0,0 +1,20 @@
+use async_graphql::Object;
+
+use crate::resolvers::DeploymentQuery;
+use crate::resolvers::ExecutionQuery;
+
+/// Note: Converted to GraphQL schema as `query`.
+pub struct QueryRoot;
+
+#[Object]
+impl QueryRoot {
+    /// Queries related to one or multiple deployments.
+    pub async fn deployment(&self) -> DeploymentQuery {
+        DeploymentQuery {}
+    }
+
+    /// Queries related to command executions.
+    pub async fn execution(&self) -> ExecutionQuery {
+        ExecutionQuery {}
+    }
+}
diff --git a/server/graphman/src/schema.rs b/server/graphman/src/schema.rs
new file mode 100644
index 00000000000..cbbda2b00e1
--- /dev/null
+++ b/server/graphman/src/schema.rs
@@ -0,0 +1,7 @@
+use async_graphql::EmptySubscription;
+use async_graphql::Schema;
+
+use crate::resolvers::MutationRoot;
+use crate::resolvers::QueryRoot;
+
+pub type GraphmanSchema = Schema<QueryRoot, MutationRoot, EmptySubscription>;
diff --git a/server/graphman/src/server.rs b/server/graphman/src/server.rs
new file mode 100644
index 00000000000..a3a4456606b
--- /dev/null
+++ b/server/graphman/src/server.rs
@@ -0,0 +1,148 @@
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use async_graphql::EmptySubscription;
+use async_graphql::Schema;
+use axum::Router;
+use axum::extract::Extension;
+use axum::http::Method;
+use axum::routing::get;
+use graph::log::factory::LoggerFactory;
+use graph::prelude::ComponentLoggerConfig;
+use graph::prelude::ElasticComponentLoggerConfig;
+use graph_store_postgres::ConnectionPool;
+use graph_store_postgres::NotificationSender;
+use graph_store_postgres::Store;
+use graph_store_postgres::graphman::GraphmanStore;
+use slog::{Logger, info};
+use tokio::sync::Notify;
+use tower_http::cors::{Any, CorsLayer};
+
+use crate::GraphmanServerError;
+use crate::auth::AuthToken;
+use crate::handlers::AppState;
+use crate::handlers::graphql_playground_handler;
+use crate::handlers::graphql_request_handler;
+use crate::resolvers::MutationRoot;
+use crate::resolvers::QueryRoot;
+
+#[derive(Clone)]
+pub struct GraphmanServer {
+    pool: ConnectionPool,
+    notification_sender: Arc<NotificationSender>,
+    store: Arc<Store>,
+    graphman_store: Arc<GraphmanStore>,
+    logger: Logger,
+    auth_token: AuthToken,
+}
+
+#[derive(Clone)]
+pub struct GraphmanServerConfig<'a> {
+    pub pool: ConnectionPool,
+    pub notification_sender: Arc<NotificationSender>,
+    pub store: Arc<Store>,
+    pub logger_factory: &'a LoggerFactory,
+    pub auth_token: String,
+}
+
+pub struct GraphmanServerManager {
+    notify: Arc<Notify>,
+}
+
+impl GraphmanServer {
+    pub fn new(config: GraphmanServerConfig) -> Result<Self, GraphmanServerError> {
+        let GraphmanServerConfig {
+            pool,
+            notification_sender,
+            store,
+            logger_factory,
+            auth_token,
+        } = config;
+
+        let graphman_store = Arc::new(GraphmanStore::new(pool.clone()));
+        let auth_token = AuthToken::new(auth_token)?;
+
+        let logger = logger_factory.component_logger(
+            "GraphmanServer",
+            Some(ComponentLoggerConfig {
+                elastic: Some(ElasticComponentLoggerConfig {
+                    index: String::from("graphman-server-logs"),
+                }),
+            }),
+        );
+
+        Ok(Self {
+            pool,
+            notification_sender,
+            store,
+            graphman_store,
+            logger,
+            auth_token,
+        })
+    }
+
+    pub async fn start(self, port: u16) -> Result<GraphmanServerManager, GraphmanServerError> {
+        let Self {
+            pool,
+            notification_sender,
+            store,
+            graphman_store,
+            logger,
+            auth_token,
+        } = self;
+
+        info!(
+            logger,
+            "Starting graphman server at: http://localhost:{}", port,
+        );
+
+        let app_state = Arc::new(AppState { auth_token });
+
+        let cors_layer = CorsLayer::new()
+            .allow_origin(Any)
+            .allow_methods([Method::GET, Method::OPTIONS, Method::POST])
+            .allow_headers(Any);
+
+        let schema = Schema::build(QueryRoot, MutationRoot, EmptySubscription)
+            .data(pool)
+            .data(notification_sender)
+            .data(store)
+            .data(graphman_store)
+            .finish();
+
+        let app = Router::new()
+            .route(
+                "/",
+                get(graphql_playground_handler).post(graphql_request_handler),
+            )
+            .with_state(app_state)
+            .layer(cors_layer)
+            .layer(Extension(schema));
+
+        let addr = SocketAddr::from(([0, 0, 0, 0], port));
+
+        let listener = tokio::net::TcpListener::bind(addr)
+            .await
+            .map_err(|err| GraphmanServerError::Io(err.into()))?;
+
+        let notify = Arc::new(Notify::new());
+        let notify_clone = notify.clone();
+
+        graph::spawn(async move {
+            axum::serve(listener, app)
+                .with_graceful_shutdown(async move {
+                    notify_clone.notified().await;
+                })
+                .await
+                .unwrap_or_else(|err| panic!("Failed to start graphman server: {err}"));
+        });
+
+        Ok(GraphmanServerManager { notify })
+    }
+}
+
+impl GraphmanServerManager {
+    pub fn stop_server(self) {
+        self.notify.notify_one()
+    }
+}
diff --git a/server/graphman/tests/auth.rs b/server/graphman/tests/auth.rs
new file mode 100644
index 00000000000..a5729ef9e66
--- /dev/null
+++ b/server/graphman/tests/auth.rs
@@ -0,0 +1,66 @@
+pub mod util;
+
+use serde_json::json;
+
+use self::util::client::BASE_URL;
+use self::util::client::CLIENT;
+use self::util::client::send_graphql_request;
+use self::util::client::send_request;
+use self::util::run_test;
+use self::util::server::INVALID_TOKEN;
+use self::util::server::VALID_TOKEN;
+
+#[test]
+fn graphql_playground_is_accessible() {
+    run_test(|| async {
+        send_request(CLIENT.head(BASE_URL.as_str())).await;
+    });
+}
+
+#[test]
+fn graphql_requests_are_not_allowed_without_a_valid_token() {
+    run_test(|| async {
+        let resp = send_graphql_request(
+            json!({
+                "query": "{ __typename }"
+            }),
+            INVALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "errors": [
+                {
+                    "message": "You are not authorized to access this resource",
+                    "extensions": {
+                        "code": "UNAUTHORIZED"
+                    }
+                }
+            ],
+            "data": null
+        });
+
+        assert_eq!(resp, expected_resp);
+    });
+}
+
+#[test]
+fn graphql_requests_are_allowed_with_a_valid_token() {
+    run_test(|| async {
+        let resp = send_graphql_request(
+            json!({
+                "query": "{ __typename }"
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "__typename": "QueryRoot"
+            }
+        });
+
+        assert_eq!(resp, expected_resp);
+    });
+}
diff --git a/server/graphman/tests/deployment_mutation.rs b/server/graphman/tests/deployment_mutation.rs
new file mode 100644
index 00000000000..6742b064f20
--- /dev/null
+++ b/server/graphman/tests/deployment_mutation.rs
@@ -0,0 +1,624 @@
+pub mod util;
+
+use std::time::Duration;
+
+use graph::components::store::SubgraphStore;
+use graph::prelude::DeploymentHash;
+use serde::Deserialize;
+use serde_json::json;
+use test_store::SUBGRAPH_STORE;
+use test_store::create_test_subgraph;
+use tokio::time::sleep;
+
+use self::util::client::send_graphql_request;
+use self::util::run_test;
+use self::util::server::VALID_TOKEN;
+
+const TEST_SUBGRAPH_SCHEMA: &str = "type User @entity { id: ID!, name: String }";
+
+async fn is_deployment_paused(hash: &str) -> bool {
+    let query = r#"query DeploymentStatus($hash: String!) {
+        deployment {
+            info(deployment: { hash: $hash }) {
+                status {
+                    isPaused
+                }
+            }
+        }
+    }"#;
+
+    let resp = send_graphql_request(
+        json!({
+            "query": query,
+            "variables": {
+                "hash": hash
+            }
+        }),
+        VALID_TOKEN,
+    )
+    .await;
+
+    resp["data"]["deployment"]["info"][0]["status"]["isPaused"]
+        .as_bool()
+        .unwrap()
+}
+
+async fn assert_deployment_paused(hash: &str, should_be_paused: bool) {
+    let query = r#"query DeploymentStatus($hash: String!) {
+        deployment {
+            info(deployment: { hash: $hash }) {
+                status {
+                    isPaused
+                }
+            }
+        }
+    }"#;
+
+    let resp = send_graphql_request(
+        json!({
+            "query": query,
+            "variables": {
+                "hash": hash
+            }
+        }),
+        VALID_TOKEN,
+    )
+    .await;
+
+    let expected_resp = json!({
+        "data": {
+            "deployment": {
+                "info": [
+                    {
+                        "status": {
+                            "isPaused": should_be_paused
+                        }
+                    }
+                ]
+            }
+        }
+    });
+
+    assert_eq!(resp, expected_resp);
+}
+
+#[test]
+fn graphql_can_pause_deployments() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let deployment_hash = DeploymentHash::new("subgraph_2").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"mutation {
+                    deployment {
+                        pause(deployment: { hash: "subgraph_2" }) {
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "pause": {
+                        "success": true,
+                    }
+                }
+            }
+        });
+
+        assert_eq!(resp, expected_resp);
+
+        assert_deployment_paused("subgraph_2", true).await;
+        assert_deployment_paused("subgraph_1", false).await;
+    });
+}
+
+#[test]
+fn graphql_can_resume_deployments() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        send_graphql_request(
+            json!({
+                "query": r#"mutation {
+                    deployment {
+                        pause(deployment: { hash: "subgraph_1" }) {
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        assert_deployment_paused("subgraph_1", true).await;
+
+        send_graphql_request(
+            json!({
+                "query": r#"mutation {
+                    deployment {
+                        resume(deployment: { hash: "subgraph_1" }) {
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        assert_deployment_paused("subgraph_1", false).await;
+    });
+}
+
+#[test]
+fn graphql_can_restart_deployments() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let deployment_hash = DeploymentHash::new("subgraph_2").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        send_graphql_request(
+            json!({
+                "query": r#"mutation {
+                    deployment {
+                        restart(deployment: { hash: "subgraph_2" }, delaySeconds: 2)
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let start = tokio::time::Instant::now();
+        let mut was_paused = false;
+        loop {
+            let paused = is_deployment_paused("subgraph_2").await;
+            if paused {
+                was_paused = true;
+            }
+            if was_paused && !paused {
+                // Successfully restarted
+                break;
+            }
+            if start.elapsed() > Duration::from_secs(30) {
+                panic!("Deployment 'subgraph_2' was not restarted within 30 seconds");
+            }
+            sleep(Duration::from_millis(200)).await;
+        }
+    });
+}
+
+#[test]
+fn graphql_allows_tracking_restart_deployment_executions() {
+    async fn execution_status(execution_id: &str) -> String {
+        let query = r#"query TrackRestartDeployment($id: String!) {
+            execution {
+                info(id: $id) {
+                    id
+                    kind
+                    status
+                    errorMessage
+                }
+            }
+        }"#;
+
+        let resp = send_graphql_request(
+            json!({
+                "query": query,
+                "variables": {
+                    "id": execution_id
+                }
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let info = &resp["data"]["execution"]["info"];
+        assert_eq!(execution_id, info["id"].as_str().unwrap());
+        assert_eq!("RESTART_DEPLOYMENT", info["kind"].as_str().unwrap());
+        assert!(info["errorMessage"].is_null());
+
+        let status = info["status"].as_str().unwrap();
+
+        status.to_string()
+    }
+
+    async fn wait_for_status(execution_id: &str, desired_status: &str) {
+        let start = tokio::time::Instant::now();
+        loop {
+            let status = execution_status(execution_id).await;
+            if status == desired_status {
+                break;
+            }
+            if start.elapsed() > Duration::from_secs(30) {
+                panic!(
+                    "Execution '{}' did not enter {} state within 30 seconds",
+                    execution_id, desired_status
+                );
+            }
+            sleep(Duration::from_millis(200)).await;
+        }
+    }
+
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"mutation {
+                    deployment {
+                        restart(deployment: { hash: "subgraph_1" }, delaySeconds: 2)
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        #[derive(Deserialize)]
+        struct Response {
+            data: Data,
+        }
+
+        #[derive(Deserialize)]
+        struct Data {
+            deployment: Deployment,
+        }
+
+        #[derive(Deserialize)]
+        struct Deployment {
+            restart: String,
+        }
+
+        let resp: Response = serde_json::from_value(resp).expect("response is valid");
+        let execution_id = resp.data.deployment.restart;
+
+        wait_for_status(&execution_id, "RUNNING").await;
+        wait_for_status(&execution_id, "SUCCEEDED").await;
+    });
+}
+
+#[test]
+fn graphql_can_create_new_subgraph() {
+    run_test(|| async {
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"mutation CreateSubgraph {
+                    deployment {
+                        create(name: "subgraph_1") {
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "create": {
+                        "success": true,
+                    }
+                }
+            }
+        });
+
+        assert_eq!(resp, expected_resp);
+    });
+}
+
+#[test]
+fn graphql_cannot_create_new_subgraph_with_invalid_name() {
+    run_test(|| async {
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"mutation CreateInvalidSubgraph {
+                    deployment {
+                        create(name: "*@$%^subgraph") {
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let success_resp = json!({
+            "data": {
+                "deployment": {
+                    "create": {
+                        "success": true,
+                    }
+                }
+            }
+        });
+
+        assert_ne!(resp, success_resp);
+    });
+}
+
+#[test]
+fn graphql_can_remove_subgraph() {
+    run_test(|| async {
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"mutation RemoveSubgraph {
+                    deployment {
+                        remove(name: "subgraph_1") {
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "remove": {
+                        "success": true,
+                    }
+                }
+            }
+        });
+
+        assert_eq!(resp, expected_resp);
+    });
+}
+
+#[test]
+fn graphql_cannot_remove_subgraph_with_invalid_name() {
+    run_test(|| async {
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"mutation RemoveInvalidSubgraph {
+                    deployment {
+                        remove(name: "*@$%^subgraph") {
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let success_resp = json!({
+            "data": {
+                "deployment": {
+                    "remove": {
+                        "success": true,
+                    }
+                }
+            }
+        });
+
+        assert_ne!(resp, success_resp);
+    });
+}
+
+#[test]
+fn graphql_can_unassign_deployments() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let unassign_req = send_graphql_request(
+            json!({
+                "query": r#"mutation {
+                    deployment {
+                        unassign(deployment: { hash: "subgraph_1" }){
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "unassign": {
+                        "success": true,
+                    }
+                }
+            }
+        });
+
+        let subgraph_node_id = send_graphql_request(
+            json!({
+                "query": r#"{
+                    deployment {
+                        info(deployment: { hash: "subgraph_1" }) {
+                            nodeId
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let is_node_null = subgraph_node_id["data"]["deployment"]["info"][0]["nodeId"].is_null();
+
+        assert_eq!(unassign_req, expected_resp);
+        assert!(is_node_null);
+    });
+}
+
+#[test]
+fn graphql_cannot_unassign_deployments_twice() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        send_graphql_request(
+            json!({
+                "query": r#"mutation {
+                    deployment {
+                        unassign(deployment: { hash: "subgraph_1" }){
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let unassign_again = send_graphql_request(
+            json!({
+                "query": r#"mutation {
+                    deployment {
+                        unassign(deployment: { hash: "subgraph_1" }){
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "unassign": {
+                        "success": true,
+                    }
+                }
+            }
+        });
+
+        assert_ne!(unassign_again, expected_resp);
+    });
+}
+
+#[test]
+fn graphql_can_reassign_deployment() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let deployment_hash = DeploymentHash::new("subgraph_2").unwrap();
+        let locator = create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        send_graphql_request(
+            json!({
+                "query": r#"mutation {
+                    deployment {
+                        unassign(deployment: { hash: "subgraph_1" }){
+                            success
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let node = SUBGRAPH_STORE
+            .assigned_node(&locator)
+            .await
+            .unwrap()
+            .unwrap();
+
+        let reassign = send_graphql_request(
+            json!({
+                "query": r#"mutation ReassignDeployment($node: String!) {
+                    deployment {
+                        reassign(deployment: { hash: "subgraph_1" }, node: $node) {
+                            ... on EmptyResponse {
+                                success
+                            }
+                            ... on CompletedWithWarnings {
+                                success
+                                warnings
+                            }
+                        }
+                    }
+                }"#,
+                "variables": {
+                    "node": node.to_string(),
+                }
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "reassign": {
+                        "success": true,
+                    }
+                }
+            }
+        });
+
+        assert_eq!(reassign, expected_resp);
+    });
+}
+
+#[test]
+fn graphql_warns_reassign_on_wrong_node_id() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let reassign = send_graphql_request(
+            json!({
+                "query": r#"mutation {
+                    deployment {
+                        reassign(deployment: { hash: "subgraph_1" }, node: "invalid_node") {
+                            ... on EmptyResponse {
+                                success
+                            }
+                            ... on CompletedWithWarnings {
+                                success
+                                warnings
+                            }
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "reassign": {
+                        "success": true,
+                        "warnings": ["This is the only deployment assigned to 'invalid_node'. Please make sure that the node ID is spelled correctly."],
+                    }
+                }
+            }
+        });
+
+        assert_eq!(reassign, expected_resp);
+    });
+}
diff --git a/server/graphman/tests/deployment_query.rs b/server/graphman/tests/deployment_query.rs
new file mode 100644
index 00000000000..52006b91b38
--- /dev/null
+++ b/server/graphman/tests/deployment_query.rs
@@ -0,0 +1,255 @@
+pub mod util;
+
+use graph::components::store::{QueryStoreManager, SubgraphStore};
+use graph::data::subgraph::DeploymentHash;
+use graph::prelude::QueryTarget;
+
+use serde_json::json;
+use test_store::STORE;
+use test_store::SUBGRAPH_STORE;
+use test_store::store::NETWORK_NAME;
+use test_store::store::create_test_subgraph;
+
+use self::util::client::send_graphql_request;
+use self::util::run_test;
+use self::util::server::VALID_TOKEN;
+
+const TEST_SUBGRAPH_SCHEMA: &str = "type User @entity { id: ID!, name: String }";
+
+#[test]
+fn graphql_returns_deployment_info() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        let locator = create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"{
+                    deployment {
+                        info {
+                            hash
+                            namespace
+                            name
+                            nodeId
+                            shard
+                            chain
+                            versionStatus
+                            isActive
+                            status {
+                                isPaused
+                                isSynced
+                                health
+                                earliestBlockNumber
+                                latestBlock {
+                                    hash
+                                    number
+                                }
+                                chainHeadBlock {
+                                    hash
+                                    number
+                                }
+                            }
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let namespace = format!("sgd{}", locator.id);
+        let node = SUBGRAPH_STORE
+            .assigned_node(&locator)
+            .await
+            .unwrap()
+            .unwrap();
+        let qs = STORE
+            .query_store(QueryTarget::Deployment(
+                locator.hash.clone(),
+                Default::default(),
+            ))
+            .await
+            .expect("could get a query store");
+        let shard = qs.shard();
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "info": [
+                        {
+                            "hash": "subgraph_1",
+                            "namespace": namespace,
+                            "name": "subgraph_1",
+                            "nodeId": node.to_string(),
+                            "shard": shard,
+                            "chain": NETWORK_NAME,
+                            "versionStatus": "current",
+                            "isActive": true,
+                            "status": {
+                                "isPaused": false,
+                                "isSynced": false,
+                                "health": "HEALTHY",
+                                "earliestBlockNumber": "0",
+                                "latestBlock": null,
+                                "chainHeadBlock": null
+                            }
+                        }
+                    ]
+                }
+            }
+        });
+
+        assert_eq!(resp, expected_resp);
+    });
+}
+
+#[test]
+fn graphql_returns_deployment_info_by_deployment_name() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let deployment_hash = DeploymentHash::new("subgraph_2").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"{
+                    deployment {
+                        info(deployment: { name: "subgraph_1" }) {
+                            name
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "info": [
+                        {
+                            "name": "subgraph_1"
+                        }
+                    ]
+                }
+            }
+        });
+
+        assert_eq!(resp, expected_resp);
+    });
+}
+
+#[test]
+fn graphql_returns_deployment_info_by_deployment_hash() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let deployment_hash = DeploymentHash::new("subgraph_2").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"{
+                    deployment {
+                        info(deployment: { hash: "subgraph_2" }) {
+                            hash
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "info": [
+                        {
+                            "hash": "subgraph_2"
+                        }
+                    ]
+                }
+            }
+        });
+
+        assert_eq!(resp, expected_resp);
+    });
+}
+
+#[test]
+fn graphql_returns_deployment_info_by_deployment_namespace() {
+    run_test(|| async {
+        let deployment_hash = DeploymentHash::new("subgraph_1").unwrap();
+        create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let deployment_hash = DeploymentHash::new("subgraph_2").unwrap();
+        let locator = create_test_subgraph(&deployment_hash, TEST_SUBGRAPH_SCHEMA).await;
+
+        let namespace = format!("sgd{}", locator.id);
+
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"query DeploymentInfo($namespace: String!) {
+                    deployment {
+                        info(deployment: { schema: $namespace }) {
+                            namespace
+                        }
+                    }
+                }"#,
+                "variables": {
+                    "namespace": namespace
+                }
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "info": [
+                        {
+                            "namespace": namespace
+                        }
+                    ]
+                }
+            }
+        });
+
+        assert_eq!(resp, expected_resp);
+    });
+}
+
+#[test]
+fn graphql_returns_empty_deployment_info_when_there_are_no_deployments() {
+    run_test(|| async {
+        let resp = send_graphql_request(
+            json!({
+                "query": r#"{
+                    deployment {
+                        info {
+                            name
+                        }
+                    }
+                }"#
+            }),
+            VALID_TOKEN,
+        )
+        .await;
+
+        let expected_resp = json!({
+            "data": {
+                "deployment": {
+                    "info": []
+                }
+            }
+        });
+
+        assert_eq!(resp, expected_resp);
+    });
+}
diff --git a/server/graphman/tests/util/client.rs b/server/graphman/tests/util/client.rs
new file mode 100644
index 00000000000..fd0f063d83f
--- /dev/null
+++ b/server/graphman/tests/util/client.rs
@@ -0,0 +1,34 @@
+use graph::http::header::AUTHORIZATION;
+use lazy_static::lazy_static;
+use reqwest::Client;
+use reqwest::RequestBuilder;
+use reqwest::Response;
+use serde_json::Value;
+
+use crate::util::server::PORT;
+
+lazy_static! {
+    pub static ref CLIENT: Client = Client::new();
+    pub static ref BASE_URL: String = format!("http://127.0.0.1:{PORT}");
+}
+
+pub async fn send_request(req: RequestBuilder) -> Response {
+    req.send()
+        .await
+        .expect("server is accessible")
+        .error_for_status()
+        .expect("response status is OK")
+}
+
+pub async fn send_graphql_request(data: Value, token: &str) -> Value {
+    send_request(
+        CLIENT
+            .post(BASE_URL.as_str())
+            .json(&data)
+            .header(AUTHORIZATION, format!("Bearer {token}")),
+    )
+    .await
+    .json()
+    .await
+    .expect("GraphQL response is valid JSON")
+}
diff --git a/server/graphman/tests/util/mod.rs b/server/graphman/tests/util/mod.rs
new file mode 100644
index 00000000000..b4409d2d500
--- /dev/null
+++ b/server/graphman/tests/util/mod.rs
@@ -0,0 +1,43 @@
+pub mod client;
+pub mod server;
+
+use std::future::Future;
+use std::sync::Mutex;
+
+use graph::TEST_RUNTIME;
+use lazy_static::lazy_static;
+use test_store::store::PRIMARY_POOL;
+use test_store::store::remove_subgraphs;
+
+lazy_static! {
+    // Used to make sure tests will run sequentially.
+    static ref SEQ_MUX: Mutex<()> = Mutex::new(());
+}
+
+pub fn run_test<T, F>(test: T)
+where
+    T: FnOnce() -> F,
+    F: Future<Output = ()>,
+{
+    let _lock = SEQ_MUX.lock().unwrap_or_else(|err| err.into_inner());
+
+    TEST_RUNTIME.block_on(async {
+        cleanup_graphman_command_executions_table().await;
+        remove_subgraphs().await;
+
+        server::start().await;
+
+        test().await;
+    });
+}
+
+async fn cleanup_graphman_command_executions_table() {
+    use diesel_async::RunQueryDsl;
+
+    let mut conn = PRIMARY_POOL.get().await.unwrap();
+
+    diesel::sql_query("truncate table public.graphman_command_executions;")
+        .execute(&mut conn)
+        .await
+        .expect("truncate is successful");
+}
diff --git a/server/graphman/tests/util/server.rs b/server/graphman/tests/util/server.rs
new file mode 100644
index 00000000000..7fe38bd29b2
--- /dev/null
+++ b/server/graphman/tests/util/server.rs
@@ -0,0 +1,45 @@
+use std::sync::Arc;
+
+use graph::prelude::LoggerFactory;
+use graph_store_postgres::NotificationSender;
+use graphman_server::GraphmanServer;
+use graphman_server::GraphmanServerConfig;
+use lazy_static::lazy_static;
+use test_store::LOGGER;
+use test_store::METRICS_REGISTRY;
+use test_store::PRIMARY_POOL;
+use test_store::STORE;
+use tokio::sync::OnceCell;
+
+pub const VALID_TOKEN: &str = "123";
+pub const INVALID_TOKEN: &str = "abc";
+
+pub const PORT: u16 = 8050;
+
+lazy_static! {
+    static ref SERVER: OnceCell<()> = OnceCell::new();
+}
+
+pub async fn start() {
+    SERVER
+        .get_or_init(|| async {
+            let logger_factory = LoggerFactory::new(LOGGER.clone(), None, METRICS_REGISTRY.clone());
+            let notification_sender = Arc::new(NotificationSender::new(METRICS_REGISTRY.clone()));
+
+            let config = GraphmanServerConfig {
+                pool: PRIMARY_POOL.clone(),
+                notification_sender,
+                store: STORE.clone(),
+                logger_factory: &logger_factory,
+                auth_token: VALID_TOKEN.to_string(),
+            };
+
+            let server = GraphmanServer::new(config).expect("graphman config is valid");
+
+            server
+                .start(PORT)
+                .await
+                .expect("graphman server starts successfully");
+        })
+        .await;
+}
diff --git a/server/http/Cargo.toml b/server/http/Cargo.toml
index 765b74ecd1e..3c1e4b9058c 100644
--- a/server/http/Cargo.toml
+++ b/server/http/Cargo.toml
@@ -4,11 +4,8 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-futures = "0.1.21"
-graphql-parser = "0.4.0"
-http = "0.2"
-hyper = "0.14"
-serde = "1.0"
+async-trait = { workspace = true }
+serde = { workspace = true }
 graph = { path = "../../graph" }
 graph-graphql = { path = "../../graphql" }
 
diff --git a/server/http/src/lib.rs b/server/http/src/lib.rs
index 6efc5d0be71..b1be017783a 100644
--- a/server/http/src/lib.rs
+++ b/server/http/src/lib.rs
@@ -1,9 +1,5 @@
-extern crate futures;
 extern crate graph;
 extern crate graph_graphql;
-extern crate graphql_parser;
-extern crate http;
-extern crate hyper;
 extern crate serde;
 
 mod request;
@@ -11,6 +7,6 @@ mod server;
 mod service;
 
 pub use self::server::GraphQLServer;
-pub use self::service::{GraphQLService, GraphQLServiceResponse};
+pub use self::service::GraphQLService;
 
 pub mod test_utils;
diff --git a/server/http/src/request.rs b/server/http/src/request.rs
index 3ad188ecd6a..4b7fdacdf59 100644
--- a/server/http/src/request.rs
+++ b/server/http/src/request.rs
@@ -1,43 +1,43 @@
 use graph::prelude::serde_json;
-use hyper::body::Bytes;
 
-use graph::components::server::query::GraphQLServerError;
+use graph::components::server::query::ServerError;
+use graph::hyper::body::Bytes;
 use graph::prelude::*;
 
-pub fn parse_graphql_request(body: &Bytes, trace: bool) -> Result<Query, GraphQLServerError> {
+pub fn parse_graphql_request(body: &Bytes, trace: bool) -> Result<Query, ServerError> {
     // Parse request body as JSON
-    let json: serde_json::Value = serde_json::from_slice(body)
-        .map_err(|e| GraphQLServerError::ClientError(format!("{}", e)))?;
+    let json: serde_json::Value =
+        serde_json::from_slice(body).map_err(|e| ServerError::ClientError(format!("{}", e)))?;
 
     // Ensure the JSON data is an object
-    let obj = json.as_object().ok_or_else(|| {
-        GraphQLServerError::ClientError(String::from("Request data is not an object"))
-    })?;
+    let obj = json
+        .as_object()
+        .ok_or_else(|| ServerError::ClientError(String::from("Request data is not an object")))?;
 
     // Ensure the JSON data has a "query" field
     let query_value = obj.get("query").ok_or_else(|| {
-        GraphQLServerError::ClientError(String::from(
+        ServerError::ClientError(String::from(
             "The \"query\" field is missing in request data",
         ))
     })?;
 
     // Ensure the "query" field is a string
     let query_string = query_value.as_str().ok_or_else(|| {
-        GraphQLServerError::ClientError(String::from("The \"query\" field is not a string"))
+        ServerError::ClientError(String::from("The \"query\" field is not a string"))
     })?;
 
     // Parse the "query" field of the JSON body
-    let document = graphql_parser::parse_query(query_string)
-        .map_err(|e| GraphQLServerError::from(QueryError::ParseError(Arc::new(e.into()))))?
+    let document = q::parse_query(query_string)
+        .map_err(|e| ServerError::from(QueryError::ParseError(Arc::new(e.into()))))?
         .into_static();
 
     // Parse the "variables" field of the JSON body, if present
     let variables = match obj.get("variables") {
         None | Some(serde_json::Value::Null) => Ok(None),
         Some(variables @ serde_json::Value::Object(_)) => serde_json::from_value(variables.clone())
-            .map_err(|e| GraphQLServerError::ClientError(e.to_string()))
+            .map_err(|e| ServerError::ClientError(e.to_string()))
             .map(Some),
-        _ => Err(GraphQLServerError::ClientError(
+        _ => Err(ServerError::ClientError(
             "Invalid query variables provided".to_string(),
         )),
     }?;
@@ -55,6 +55,7 @@ mod tests {
             query::QueryTarget,
             value::{Object, Word},
         },
+        hyper::body::Bytes,
         prelude::*,
     };
 
@@ -69,48 +70,43 @@ mod tests {
 
     #[test]
     fn rejects_invalid_json() {
-        let request = parse_graphql_request(&hyper::body::Bytes::from("!@#)%"), false);
+        let request = parse_graphql_request(&Bytes::from("!@#)%"), false);
         request.expect_err("Should reject invalid JSON");
     }
 
     #[test]
     fn rejects_json_without_query_field() {
-        let request = parse_graphql_request(&hyper::body::Bytes::from("{}"), false);
+        let request = parse_graphql_request(&Bytes::from("{}"), false);
         request.expect_err("Should reject JSON without query field");
     }
 
     #[test]
     fn rejects_json_with_non_string_query_field() {
-        let request = parse_graphql_request(&hyper::body::Bytes::from("{\"query\": 5}"), false);
+        let request = parse_graphql_request(&Bytes::from("{\"query\": 5}"), false);
         request.expect_err("Should reject JSON with a non-string query field");
     }
 
     #[test]
     fn rejects_broken_queries() {
-        let request =
-            parse_graphql_request(&hyper::body::Bytes::from("{\"query\": \"foo\"}"), false);
+        let request = parse_graphql_request(&Bytes::from("{\"query\": \"foo\"}"), false);
         request.expect_err("Should reject broken queries");
     }
 
     #[test]
     fn accepts_valid_queries() {
-        let request = parse_graphql_request(
-            &hyper::body::Bytes::from("{\"query\": \"{ user { name } }\"}"),
-            false,
-        );
+        let request =
+            parse_graphql_request(&Bytes::from("{\"query\": \"{ user { name } }\"}"), false);
         let query = request.expect("Should accept valid queries");
         assert_eq!(
             query.document,
-            graphql_parser::parse_query("{ user { name } }")
-                .unwrap()
-                .into_static()
+            q::parse_query("{ user { name } }").unwrap().into_static()
         );
     }
 
     #[test]
     fn accepts_null_variables() {
         let request = parse_graphql_request(
-            &hyper::body::Bytes::from(
+            &Bytes::from(
                 "\
                  {\
                  \"query\": \"{ user { name } }\", \
@@ -121,9 +117,7 @@ mod tests {
         );
         let query = request.expect("Should accept null variables");
 
-        let expected_query = graphql_parser::parse_query("{ user { name } }")
-            .unwrap()
-            .into_static();
+        let expected_query = q::parse_query("{ user { name } }").unwrap().into_static();
         assert_eq!(query.document, expected_query);
         assert_eq!(query.variables, None);
     }
@@ -131,7 +125,7 @@ mod tests {
     #[test]
     fn rejects_non_map_variables() {
         let request = parse_graphql_request(
-            &hyper::body::Bytes::from(
+            &Bytes::from(
                 "\
                  {\
                  \"query\": \"{ user { name } }\", \
@@ -146,7 +140,7 @@ mod tests {
     #[test]
     fn parses_variables() {
         let request = parse_graphql_request(
-            &hyper::body::Bytes::from(
+            &Bytes::from(
                 "\
                  {\
                  \"query\": \"{ user { name } }\", \
@@ -159,22 +153,17 @@ mod tests {
         );
         let query = request.expect("Should accept valid queries");
 
-        let expected_query = graphql_parser::parse_query("{ user { name } }")
-            .unwrap()
-            .into_static();
-        let expected_variables = QueryVariables::new(HashMap::from_iter(
-            vec![
-                (String::from("string"), r::Value::String(String::from("s"))),
-                (
-                    String::from("map"),
-                    r::Value::Object(Object::from_iter(
-                        vec![(Word::from("k"), r::Value::String(String::from("v")))].into_iter(),
-                    )),
-                ),
-                (String::from("int"), r::Value::Int(5)),
-            ]
-            .into_iter(),
-        ));
+        let expected_query = q::parse_query("{ user { name } }").unwrap().into_static();
+        let expected_variables = QueryVariables::new(HashMap::from_iter(vec![
+            (String::from("string"), r::Value::String(String::from("s"))),
+            (
+                String::from("map"),
+                r::Value::Object(Object::from_iter(
+                    vec![(Word::from("k"), r::Value::String(String::from("v")))].into_iter(),
+                )),
+            ),
+            (String::from("int"), r::Value::Int(5)),
+        ]));
 
         assert_eq!(query.document, expected_query);
         assert_eq!(query.variables, Some(expected_variables));
diff --git a/server/http/src/server.rs b/server/http/src/server.rs
index 39c1bd22e66..8aad5eb0d18 100644
--- a/server/http/src/server.rs
+++ b/server/http/src/server.rs
@@ -1,30 +1,23 @@
-use std::net::{Ipv4Addr, SocketAddrV4};
+use std::sync::Arc;
 
-use futures::future::Future;
-use hyper::service::make_service_fn;
-use hyper::Server;
-use thiserror::Error;
+use graph::anyhow;
+use graph::cheap_clone::CheapClone;
+use graph::components::server::server::{ServerHandle, start};
+use graph::log::factory::{ComponentLoggerConfig, ElasticComponentLoggerConfig};
+use graph::slog::info;
 
 use crate::service::GraphQLService;
-use graph::prelude::{GraphQLServer as GraphQLServerTrait, GraphQlRunner, *};
-
-/// Errors that may occur when starting the server.
-#[derive(Debug, Error)]
-pub enum GraphQLServeError {
-    #[error("Bind error: {0}")]
-    BindError(#[from] hyper::Error),
-}
+use graph::prelude::{GraphQlRunner, Logger, LoggerFactory};
 
 /// A GraphQL server based on Hyper.
 pub struct GraphQLServer<Q> {
     logger: Logger,
     graphql_runner: Arc<Q>,
-    node_id: NodeId,
 }
 
-impl<Q> GraphQLServer<Q> {
+impl<Q: GraphQlRunner> GraphQLServer<Q> {
     /// Creates a new GraphQL server.
-    pub fn new(logger_factory: &LoggerFactory, graphql_runner: Arc<Q>, node_id: NodeId) -> Self {
+    pub fn new(logger_factory: &LoggerFactory, graphql_runner: Arc<Q>) -> Self {
         let logger = logger_factory.component_logger(
             "GraphQLServer",
             Some(ComponentLoggerConfig {
@@ -36,22 +29,10 @@ impl<Q> GraphQLServer<Q> {
         GraphQLServer {
             logger,
             graphql_runner,
-            node_id,
         }
     }
-}
 
-impl<Q> GraphQLServerTrait for GraphQLServer<Q>
-where
-    Q: GraphQlRunner,
-{
-    type ServeError = GraphQLServeError;
-
-    fn serve(
-        &mut self,
-        port: u16,
-        ws_port: u16,
-    ) -> Result<Box<dyn Future<Item = (), Error = ()> + Send>, Self::ServeError> {
+    pub async fn start(&self, port: u16) -> Result<ServerHandle, anyhow::Error> {
         let logger = self.logger.clone();
 
         info!(
@@ -59,29 +40,14 @@ where
             "Starting GraphQL HTTP server at: http://localhost:{}", port
         );
 
-        let addr = SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), port);
-
-        // On every incoming request, launch a new GraphQL service that writes
-        // incoming queries to the query sink.
-        let logger_for_service = self.logger.clone();
         let graphql_runner = self.graphql_runner.clone();
-        let node_id = self.node_id.clone();
-        let new_service = make_service_fn(move |_| {
-            let graphql_service = GraphQLService::new(
-                logger_for_service.clone(),
-                graphql_runner.clone(),
-                ws_port,
-                node_id.clone(),
-            );
-
-            futures03::future::ok::<_, Error>(graphql_service)
-        });
 
-        // Create a task to run the server and handle HTTP requests
-        let task = Server::try_bind(&addr.into())?
-            .serve(new_service)
-            .map_err(move |e| error!(logger, "Server error"; "error" => format!("{}", e)));
+        let service = Arc::new(GraphQLService::new(logger.clone(), graphql_runner));
 
-        Ok(Box::new(task.compat()))
+        start(logger, port, move |req| {
+            let service = service.cheap_clone();
+            async move { Ok::<_, _>(service.cheap_clone().call(req).await) }
+        })
+        .await
     }
 }
diff --git a/server/http/src/service.rs b/server/http/src/service.rs
index bee7ab58551..66a799caed3 100644
--- a/server/http/src/service.rs
+++ b/server/http/src/service.rs
@@ -1,49 +1,57 @@
 use std::convert::TryFrom;
 use std::env;
-use std::pin::Pin;
-use std::task::Context;
-use std::task::Poll;
+use std::sync::Arc;
 use std::time::Instant;
 
+use graph::cheap_clone::CheapClone;
+use graph::components::graphql::GraphQlRunner;
+use graph::components::server::query::ServerResponse;
+use graph::components::server::query::ServerResult;
+use graph::components::versions::ApiVersion;
+use graph::data::query::QueryResult;
+use graph::data::query::SqlQueryMode;
+use graph::data::query::SqlQueryReq;
+use graph::data::subgraph::DeploymentHash;
+use graph::data::subgraph::SubgraphName;
+use graph::env::ENV_VARS;
+use graph::http_body_util::{BodyExt, Full};
+use graph::hyper::header::{
+    ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
+    CONTENT_LENGTH, CONTENT_TYPE, LOCATION,
+};
+use graph::hyper::{Method, Request, Response, StatusCode};
+use graph::hyper::{body::Body, header::HeaderValue};
+use graph::prelude::CacheWeight as _;
+use graph::prelude::QueryError;
 use graph::prelude::serde_json;
 use graph::prelude::serde_json::json;
-use graph::prelude::*;
 use graph::semver::VersionReq;
+use graph::slog::Logger;
+use graph::slog::error;
 use graph::url::form_urlencoded;
-use graph::{components::server::query::GraphQLServerError, data::query::QueryTarget};
-use http::header;
-use http::header::{
-    ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
-    CONTENT_TYPE, LOCATION,
-};
-use hyper::service::Service;
-use hyper::{Body, Method, Request, Response, StatusCode};
+use graph::{components::server::query::ServerError, data::query::QueryTarget};
 
 use crate::request::parse_graphql_request;
 
-pub type GraphQLServiceResult = Result<Response<Body>, GraphQLServerError>;
-/// An asynchronous response to a GraphQL request.
-pub type GraphQLServiceResponse =
-    Pin<Box<dyn std::future::Future<Output = GraphQLServiceResult> + Send>>;
+fn client_error(msg: impl Into<String>) -> ServerResponse {
+    let response_obj = json!({
+        "error": msg.into()
+    });
+    let response_str = serde_json::to_string(&response_obj).unwrap();
+
+    Response::builder()
+        .status(400)
+        .header(CONTENT_TYPE, "application/json")
+        .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+        .body(Full::from(response_str))
+        .unwrap()
+}
 
 /// A Hyper Service that serves GraphQL over a POST / endpoint.
 #[derive(Debug)]
 pub struct GraphQLService<Q> {
     logger: Logger,
     graphql_runner: Arc<Q>,
-    ws_port: u16,
-    node_id: NodeId,
-}
-
-impl<Q> Clone for GraphQLService<Q> {
-    fn clone(&self) -> Self {
-        Self {
-            logger: self.logger.clone(),
-            graphql_runner: self.graphql_runner.clone(),
-            ws_port: self.ws_port,
-            node_id: self.node_id.clone(),
-        }
-    }
 }
 
 impl<Q> GraphQLService<Q>
@@ -51,21 +59,18 @@ where
     Q: GraphQlRunner,
 {
     /// Creates a new GraphQL service.
-    pub fn new(logger: Logger, graphql_runner: Arc<Q>, ws_port: u16, node_id: NodeId) -> Self {
+    pub fn new(logger: Logger, graphql_runner: Arc<Q>) -> Self {
         GraphQLService {
             logger,
             graphql_runner,
-            ws_port,
-            node_id,
         }
     }
 
     fn graphiql_html(&self) -> String {
-        include_str!("../assets/index.html")
-            .replace("__WS_PORT__", format!("{}", self.ws_port).as_str())
+        include_str!("../assets/index.html").to_string()
     }
 
-    async fn index(self) -> GraphQLServiceResult {
+    async fn index(&self) -> ServerResult {
         let response_obj = json!({
             "message": "Access deployed subgraphs by deployment ID at \
                         /subgraphs/id/<ID> or by name at /subgraphs/name/<NAME>"
@@ -76,39 +81,33 @@ where
             .status(200)
             .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
             .header(CONTENT_TYPE, "application/json")
-            .body(Body::from(response_str))
+            .body(Full::from(response_str))
             .unwrap())
     }
 
     /// Serves a dynamically created file.
-    fn serve_dynamic_file(&self, contents: String) -> GraphQLServiceResponse {
-        async {
-            Ok(Response::builder()
-                .status(200)
-                .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                .header(CONTENT_TYPE, "text/html; charset=utf-8")
-                .body(Body::from(contents))
-                .unwrap())
-        }
-        .boxed()
+    fn serve_dynamic_file(&self, contents: String) -> ServerResponse {
+        Response::builder()
+            .status(200)
+            .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+            .header(CONTENT_TYPE, "text/html; charset=utf-8")
+            .body(Full::from(contents))
+            .unwrap()
     }
 
-    fn handle_graphiql(&self) -> GraphQLServiceResponse {
-        self.serve_dynamic_file(self.graphiql_html())
+    fn handle_graphiql(&self) -> ServerResult {
+        Ok(self.serve_dynamic_file(self.graphiql_html()))
     }
 
-    fn resolve_api_version(
-        &self,
-        request: &Request<Body>,
-    ) -> Result<ApiVersion, GraphQLServerError> {
+    fn resolve_api_version<T>(&self, request: &Request<T>) -> Result<ApiVersion, ServerError> {
         let mut version = ApiVersion::default();
 
         if let Some(query) = request.uri().query() {
             let potential_version_requirement = query.split('&').find_map(|pair| {
-                if pair.starts_with("api-version=") {
-                    if let Some(version_requirement) = pair.split('=').nth(1) {
-                        return Some(version_requirement);
-                    }
+                if pair.starts_with("api-version=")
+                    && let Some(version_requirement) = pair.split('=').nth(1)
+                {
+                    return Some(version_requirement);
                 }
                 None
             });
@@ -116,56 +115,46 @@ where
             if let Some(version_requirement) = potential_version_requirement {
                 version = ApiVersion::new(
                     &VersionReq::parse(version_requirement)
-                        .map_err(|error| GraphQLServerError::ClientError(error.to_string()))?,
+                        .map_err(|error| ServerError::ClientError(error.to_string()))?,
                 )
-                .map_err(GraphQLServerError::ClientError)?;
+                .map_err(ServerError::ClientError)?;
             }
         }
 
         Ok(version)
     }
 
-    async fn handle_graphql_query_by_name(
-        self,
+    async fn handle_graphql_query_by_name<T: Body>(
+        &self,
         subgraph_name: String,
-        request: Request<Body>,
-    ) -> GraphQLServiceResult {
+        request: Request<T>,
+    ) -> ServerResult {
         let version = self.resolve_api_version(&request)?;
-        let subgraph_name = SubgraphName::new(subgraph_name.as_str()).map_err(|()| {
-            GraphQLServerError::ClientError(format!("Invalid subgraph name {:?}", subgraph_name))
-        })?;
+        let subgraph_name = SubgraphName::new(subgraph_name.as_str())
+            .map_err(|name| ServerError::ClientError(format!("Invalid subgraph name `{name}`")))?;
 
         self.handle_graphql_query(QueryTarget::Name(subgraph_name, version), request)
             .await
     }
 
-    fn handle_graphql_query_by_id(
-        self,
+    async fn handle_graphql_query_by_id<T: Body>(
+        &self,
         id: String,
-        request: Request<Body>,
-    ) -> GraphQLServiceResponse {
-        let res = DeploymentHash::new(id)
-            .map_err(|id| GraphQLServerError::ClientError(format!("Invalid subgraph id `{}`", id)))
-            .and_then(|id| match self.resolve_api_version(&request) {
-                Ok(version) => Ok((id, version)),
-                Err(error) => Err(error),
-            });
+        request: Request<T>,
+    ) -> ServerResult {
+        let id = DeploymentHash::new(id)
+            .map_err(|id| ServerError::ClientError(format!("Invalid subgraph id `{}`", id)))?;
+        let version = self.resolve_api_version(&request)?;
 
-        match res {
-            Err(_) => self.handle_not_found(),
-            Ok((id, version)) => self
-                .handle_graphql_query(QueryTarget::Deployment(id, version), request)
-                .boxed(),
-        }
+        self.handle_graphql_query(QueryTarget::Deployment(id, version), request)
+            .await
     }
 
-    async fn handle_graphql_query(
-        self,
+    async fn handle_graphql_query<T: Body>(
+        &self,
         target: QueryTarget,
-        request: Request<Body>,
-    ) -> GraphQLServiceResult {
-        let service = self.clone();
-
+        request: Request<T>,
+    ) -> ServerResult {
         let start = Instant::now();
         let trace = {
             !ENV_VARS.graphql.query_trace_token.is_empty()
@@ -174,23 +163,31 @@ where
                     .get("X-GraphTraceQuery")
                     .map(|v| {
                         v.to_str()
-                            .map(|s| s == &ENV_VARS.graphql.query_trace_token)
+                            .map(|s| s == ENV_VARS.graphql.query_trace_token)
                             .unwrap_or(false)
                     })
                     .unwrap_or(false)
         };
-        let body = hyper::body::to_bytes(request.into_body())
-            .map_err(|_| GraphQLServerError::InternalError("Failed to read request body".into()))
-            .await?;
+        let body = request
+            .collect()
+            .await
+            .map_err(|_| ServerError::InternalError("Failed to read request body".into()))?
+            .to_bytes();
         let query = parse_graphql_request(&body, trace);
         let query_parsing_time = start.elapsed();
 
-        let result = match query {
-            Ok(query) => service.graphql_runner.run_query(query, target).await,
-            Err(GraphQLServerError::QueryError(e)) => QueryResult::from(e).into(),
+        let mut result = match query {
+            Ok(query) => {
+                self.graphql_runner
+                    .cheap_clone()
+                    .run_query(query, target)
+                    .await
+            }
+            Err(ServerError::QueryError(e)) => QueryResult::from(e).into(),
             Err(e) => return Err(e),
         };
 
+        result.trace.query_parsing(query_parsing_time);
         self.graphql_runner
             .metrics()
             .observe_query_parsing(query_parsing_time, &result);
@@ -201,117 +198,116 @@ where
         Ok(result.as_http_response())
     }
 
+    async fn handle_sql_query<T: Body>(&self, request: Request<T>) -> ServerResult {
+        let body = request
+            .collect()
+            .await
+            .map_err(|_| ServerError::InternalError("Failed to read request body".into()))?
+            .to_bytes();
+        let sql_req: SqlQueryReq = serde_json::from_slice(&body)
+            .map_err(|e| ServerError::ClientError(format!("{}", e)))?;
+
+        let mode = sql_req.mode;
+        let result = self
+            .graphql_runner
+            .cheap_clone()
+            .run_sql_query(sql_req)
+            .await
+            .map_err(|e| ServerError::QueryError(QueryError::from(e)));
+
+        use SqlQueryMode::*;
+        let response_obj = match (result, mode) {
+            (Ok(result), Info) => {
+                json!({
+                    "count": result.len(),
+                    "bytes" : result.weight(),
+                })
+            }
+            (Ok(result), Data) => {
+                json!({
+                    "data": result,
+                })
+            }
+            (Err(e), _) => json!({
+                "error": e.to_string(),
+            }),
+        };
+
+        let response_str = serde_json::to_string(&response_obj).unwrap();
+
+        Ok(Response::builder()
+            .status(200)
+            .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+            .header(CONTENT_TYPE, "application/json")
+            .body(Full::from(response_str))
+            .unwrap())
+    }
+
     // Handles OPTIONS requests
-    fn handle_graphql_options(&self, _request: Request<Body>) -> GraphQLServiceResponse {
-        async {
-            Ok(Response::builder()
-                .status(200)
-                .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                .header(ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type, User-Agent")
-                .header(ACCESS_CONTROL_ALLOW_METHODS, "GET, OPTIONS, POST")
-                .header(CONTENT_TYPE, "text/html; charset=utf-8")
-                .body(Body::from(""))
-                .unwrap())
-        }
-        .boxed()
+    fn handle_graphql_options<T>(&self, _request: Request<T>) -> ServerResult {
+        Ok(Response::builder()
+            .status(200)
+            .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+            .header(ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type, User-Agent")
+            .header(ACCESS_CONTROL_ALLOW_METHODS, "GET, OPTIONS, POST")
+            .header(CONTENT_TYPE, "text/html; charset=utf-8")
+            .body(Full::from(""))
+            .unwrap())
     }
 
     /// Handles 302 redirects
-    async fn handle_temp_redirect(self, destination: String) -> GraphQLServiceResult {
-        header::HeaderValue::try_from(destination)
-            .map_err(|_| {
-                GraphQLServerError::ClientError("invalid characters in redirect URL".into())
-            })
+    fn handle_temp_redirect(&self, destination: String) -> ServerResult {
+        HeaderValue::try_from(destination)
+            .map_err(|_| ServerError::ClientError("invalid characters in redirect URL".into()))
             .map(|loc_header_val| {
                 Response::builder()
                     .status(StatusCode::FOUND)
                     .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
                     .header(LOCATION, loc_header_val)
                     .header(CONTENT_TYPE, "text/plain; charset=utf-8")
-                    .body(Body::from("Redirecting..."))
+                    .body(Full::from("Redirecting..."))
                     .unwrap()
             })
     }
 
-    fn handle_not_found(&self) -> GraphQLServiceResponse {
-        async {
-            let response_obj = json!({
-                "message": "Not found"
-            });
-            let response_str = serde_json::to_string(&response_obj).unwrap();
-
-            Ok(Response::builder()
-                .status(200)
-                .header(CONTENT_TYPE, "application/json")
-                .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                .body(Body::from(response_str))
-                .unwrap())
-        }
-        .boxed()
+    fn handle_not_found(&self) -> ServerResult {
+        let response_obj = json!({
+            "message": "Not found"
+        });
+        let response_str = serde_json::to_string(&response_obj).unwrap();
+
+        Ok(Response::builder()
+            .status(200)
+            .header(CONTENT_TYPE, "application/json")
+            .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+            .body(Full::from(response_str))
+            .unwrap())
     }
 
-    fn handle_mutations(&self) -> GraphQLServiceResponse {
-        async {
-            let response_obj = json!({
-                "error": "Can't use mutations with GET method"
-            });
-            let response_str = serde_json::to_string(&response_obj).unwrap();
-
-            Ok(Response::builder()
-                .status(400)
-                .header(CONTENT_TYPE, "application/json")
-                .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                .body(Body::from(response_str))
-                .unwrap())
-        }
-        .boxed()
+    fn handle_mutations(&self) -> ServerResult {
+        Ok(client_error("Can't use mutations with GET method"))
     }
     /// Handles requests without content type.
-    fn handle_requests_without_content_type(&self) -> GraphQLServiceResponse {
-        async {
-            let response_obj = json!({
-                "message": "Content-Type header is required"
-            });
-            let response_str = serde_json::to_string(&response_obj).unwrap();
-
-            Ok(Response::builder()
-                .status(400)
-                .header(CONTENT_TYPE, "application/json")
-                .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                .body(Body::from(response_str))
-                .unwrap())
-        }
-        .boxed()
+    fn handle_requests_without_content_type(&self) -> ServerResult {
+        Ok(client_error("Content-Type header is required"))
     }
+
     /// Handles requests without body.
-    fn handle_requests_without_body(&self) -> GraphQLServiceResponse {
-        async {
-            let response_obj = json!({
-                "message": "Body is required"
-            });
-            let response_str = serde_json::to_string(&response_obj).unwrap();
-
-            Ok(Response::builder()
-                .status(400)
-                .header(CONTENT_TYPE, "application/json")
-                .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                .body(Body::from(response_str))
-                .unwrap())
-        }
-        .boxed()
+    fn handle_requests_without_body(&self) -> ServerResult {
+        Ok(client_error("Body is required"))
     }
-    fn has_request_body(&self, req: &Request<Body>) -> bool {
-        if let Some(length) = req.headers().get(hyper::header::CONTENT_LENGTH) {
-            if let Ok(length) = length.to_str() {
-                if let Ok(length) = length.parse::<usize>() {
-                    return length > 0;
-                }
-            }
+
+    fn has_request_body<T>(&self, req: &Request<T>) -> bool {
+        if let Some(length) = req.headers().get(CONTENT_LENGTH)
+            && let Ok(length) = length.to_str()
+            && let Ok(length) = length.parse::<usize>()
+        {
+            return length > 0;
         }
         false
     }
 
-    fn handle_call(self, req: Request<Body>) -> GraphQLServiceResponse {
+    async fn handle_call<T: Body>(&self, req: Request<T>) -> ServerResult {
         let method = req.method().clone();
 
         let path = req.uri().path().to_owned();
@@ -331,11 +327,11 @@ where
 
         if !less_strict_graphql_compliance {
             if method == Method::POST && (content_type.is_none()) {
-                return self.handle_requests_without_content_type().boxed();
+                return self.handle_requests_without_content_type();
             }
 
             if method == Method::POST && !self.has_request_body(&req) {
-                return self.handle_requests_without_body().boxed();
+                return self.handle_requests_without_body();
             }
         }
 
@@ -344,7 +340,7 @@ where
             segments
                 .iter()
                 .filter(|&&segment| !segment.is_empty())
-                .map(|&segment| segment)
+                .copied()
                 .collect::<Vec<&str>>()
                 .join("/")
         }
@@ -357,12 +353,12 @@ where
                     .find(|(key, _)| key == "query")
                     .map(|(_, value)| value.into_owned())
             })
-            .unwrap_or_else(|| String::new())
+            .unwrap_or_default()
             .trim()
             .to_lowercase()
             .starts_with("mutation");
         match (method, path_segments.as_slice()) {
-            (Method::GET, [""]) => self.index().boxed(),
+            (Method::GET, [""]) => self.index().await,
             (Method::GET, &["subgraphs", "id", _, "graphql"])
             | (Method::GET, &["subgraphs", "name", .., "graphql"])
             | (Method::GET, &["subgraphs", "network", _, _, "graphql"])
@@ -376,17 +372,19 @@ where
             | (Method::GET, path @ ["subgraphs", "network", _, _]) => {
                 let filtered_path = filter_and_join_segments(path);
                 let dest = format!("/{}/graphql", filtered_path);
-                self.handle_temp_redirect(dest).boxed()
+                self.handle_temp_redirect(dest)
+            }
+            (Method::POST, &["subgraphs", "sql"] | &["subgraphs", "sql", ""]) => {
+                self.handle_sql_query(req).await
             }
-
             (Method::POST, &["subgraphs", "id", subgraph_id]) => {
                 self.handle_graphql_query_by_id(subgraph_id.to_owned(), req)
+                    .await
             }
             (Method::OPTIONS, ["subgraphs", "id", _]) => self.handle_graphql_options(req),
             (Method::POST, path @ ["subgraphs", "name", ..]) => {
                 let subgraph_name = filter_and_join_segments(&path[2..]);
-                self.handle_graphql_query_by_name(subgraph_name, req)
-                    .boxed()
+                self.handle_graphql_query_by_name(subgraph_name, req).await
             }
 
             (Method::OPTIONS, ["subgraphs", "name", ..]) => self.handle_graphql_options(req),
@@ -394,84 +392,68 @@ where
             _ => self.handle_not_found(),
         }
     }
-}
 
-impl<Q> Service<Request<Body>> for GraphQLService<Q>
-where
-    Q: GraphQlRunner,
-{
-    type Response = Response<Body>;
-    type Error = GraphQLServerError;
-    type Future = GraphQLServiceResponse;
+    pub async fn call<T: Body + std::fmt::Debug>(&self, req: Request<T>) -> ServerResponse {
+        // Returning Err here will prevent the client from receiving any response.
+        // Instead, we generate a Response with an error code and return Ok
+        let result = self.handle_call(req).await;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
+        match result {
+            Ok(response) => response,
+            Err(err @ ServerError::ClientError(_)) => {
+                let response_obj = json!({
+                    "error": err.to_string()
+                });
+                let response_str = serde_json::to_string(&response_obj).unwrap();
+
+                Response::builder()
+                    .status(400)
+                    .header(CONTENT_TYPE, "application/json")
+                    .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+                    .body(Full::from(response_str))
+                    .unwrap()
+            }
+            Err(err @ ServerError::QueryError(_)) => {
+                error!(self.logger, "GraphQLService call failed: {}", err);
 
-    fn call(&mut self, req: Request<Body>) -> Self::Future {
-        let logger = self.logger.clone();
-        let service = self.clone();
+                let response_obj = json!({
+                    "QueryError": err.to_string()
+                });
+                let response_str = serde_json::to_string(&response_obj).unwrap();
 
-        // Returning Err here will prevent the client from receiving any response.
-        // Instead, we generate a Response with an error code and return Ok
-        Box::pin(async move {
-            let result = service.handle_call(req).await;
-
-            match result {
-                Ok(response) => Ok(response),
-                Err(err @ GraphQLServerError::ClientError(_)) => {
-                    let response_obj = json!({
-                        "error": err.to_string()
-                    });
-                    let response_str = serde_json::to_string(&response_obj).unwrap();
-
-                    Ok(Response::builder()
-                        .status(400)
-                        .header(CONTENT_TYPE, "application/json")
-                        .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                        .body(Body::from(response_str))
-                        .unwrap())
-                }
-                Err(err @ GraphQLServerError::QueryError(_)) => {
-                    error!(logger, "GraphQLService call failed: {}", err);
-
-                    let response_obj = json!({
-                        "QueryError": err.to_string()
-                    });
-                    let response_str = serde_json::to_string(&response_obj).unwrap();
-
-                    Ok(Response::builder()
-                        .status(400)
-                        .header(CONTENT_TYPE, "application/json")
-                        .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                        .body(Body::from(response_str))
-                        .unwrap())
-                }
-                Err(err @ GraphQLServerError::InternalError(_)) => {
-                    error!(logger, "GraphQLService call failed: {}", err);
-
-                    Ok(Response::builder()
-                        .status(500)
-                        .header(CONTENT_TYPE, "text/plain; charset=utf-8")
-                        .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                        .body(Body::from(format!("Internal server error: {}", err)))
-                        .unwrap())
-                }
+                Response::builder()
+                    .status(400)
+                    .header(CONTENT_TYPE, "application/json")
+                    .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+                    .body(Full::from(response_str))
+                    .unwrap()
+            }
+            Err(err @ ServerError::InternalError(_)) => {
+                error!(self.logger, "GraphQLService call failed: {}", err);
+
+                Response::builder()
+                    .status(500)
+                    .header(CONTENT_TYPE, "text/plain; charset=utf-8")
+                    .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+                    .body(Full::from(format!("Internal server error: {}", err)))
+                    .unwrap()
             }
-        })
+        }
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use async_trait::async_trait;
+    use graph::data::store::SqlQueryObject;
     use graph::data::value::{Object, Word};
+    use graph::http_body_util::{BodyExt, Full};
+    use graph::hyper::body::Bytes;
+    use graph::hyper::header::{CONTENT_LENGTH, CONTENT_TYPE};
+    use graph::hyper::{Method, Request, StatusCode};
     use graph::prelude::serde_json::json;
-    use http::header::{CONTENT_LENGTH, CONTENT_TYPE};
-    use http::status::StatusCode;
-    use hyper::service::Service;
-    use hyper::{Body, Method, Request};
 
-    use graph::data::query::{QueryResults, QueryTarget};
+    use graph::data::query::{QueryResults, QueryTarget, SqlQueryReq};
     use graph::prelude::*;
 
     use crate::test_utils;
@@ -510,41 +492,39 @@ mod tests {
         }
 
         async fn run_query(self: Arc<Self>, _query: Query, _target: QueryTarget) -> QueryResults {
-            QueryResults::from(Object::from_iter(
-                vec![(Word::from("name"), r::Value::String(String::from("Jordi")))].into_iter(),
-            ))
-        }
-
-        async fn run_subscription(
-            self: Arc<Self>,
-            _subscription: Subscription,
-            _target: QueryTarget,
-        ) -> Result<SubscriptionResult, SubscriptionError> {
-            unreachable!();
+            QueryResults::from(Object::from_iter(vec![(
+                Word::from("name"),
+                r::Value::String(String::from("Jordi")),
+            )]))
         }
 
         fn metrics(&self) -> Arc<dyn GraphQLMetrics> {
             Arc::new(TestGraphQLMetrics)
         }
+
+        async fn run_sql_query(
+            self: Arc<Self>,
+            _req: SqlQueryReq,
+        ) -> Result<Vec<SqlQueryObject>, QueryExecutionError> {
+            unimplemented!()
+        }
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn querying_not_found_routes_responds_correctly() {
         let logger = Logger::root(slog::Discard, o!());
         let graphql_runner = Arc::new(TestGraphQlRunner);
 
-        let node_id = NodeId::new("test").unwrap();
-        let mut service = GraphQLService::new(logger, graphql_runner, 8001, node_id);
+        let service = GraphQLService::new(logger, graphql_runner);
 
-        let request = Request::builder()
+        let request: Request<Full<Bytes>> = Request::builder()
             .method(Method::GET)
             .header(CONTENT_TYPE, "text/plain; charset=utf-8")
             .uri("http://localhost:8000/not_found_route".to_string())
-            .body(Body::from("{}"))
+            .body(Full::from("{}"))
             .unwrap();
 
-        let response =
-            futures03::executor::block_on(service.call(request)).expect("Should return a response");
+        let response = service.call(request).await;
 
         let content_type_header = response.status();
         assert_eq!(content_type_header, StatusCode::OK);
@@ -552,7 +532,7 @@ mod tests {
         let content_type_header = response.headers().get(CONTENT_TYPE).unwrap();
         assert_eq!(content_type_header, "application/json");
 
-        let body_bytes = hyper::body::to_bytes(response.into_body()).await.unwrap();
+        let body_bytes = response.body().clone().collect().await.unwrap().to_bytes();
         let json: serde_json::Result<serde_json::Value> =
             serde_json::from_str(String::from_utf8(body_bytes.to_vec()).unwrap().as_str());
 
@@ -561,16 +541,15 @@ mod tests {
         assert_eq!(json.unwrap(), serde_json::json!({"message": "Not found"}));
     }
 
-    #[test]
-    fn posting_invalid_query_yields_error_response() {
+    #[graph::test]
+    async fn posting_invalid_query_yields_error_response() {
         let logger = Logger::root(slog::Discard, o!());
         let subgraph_id = USERS.clone();
         let graphql_runner = Arc::new(TestGraphQlRunner);
 
-        let node_id = NodeId::new("test").unwrap();
-        let mut service = GraphQLService::new(logger, graphql_runner, 8001, node_id);
+        let service = GraphQLService::new(logger, graphql_runner);
 
-        let request = Request::builder()
+        let request: Request<Full<Bytes>> = Request::builder()
             .method(Method::POST)
             .header(CONTENT_TYPE, "text/plain; charset=utf-8")
             .header(CONTENT_LENGTH, 100)
@@ -578,12 +557,12 @@ mod tests {
                 "http://localhost:8000/subgraphs/id/{}",
                 subgraph_id
             ))
-            .body(Body::from("{}"))
+            .body(Full::from("{}"))
             .unwrap();
 
-        let response =
-            futures03::executor::block_on(service.call(request)).expect("Should return a response");
-        let errors = test_utils::assert_error_response(response, StatusCode::BAD_REQUEST, false);
+        let response = service.call(request).await;
+        let errors =
+            test_utils::assert_error_response(response, StatusCode::BAD_REQUEST, false).await;
 
         let message = errors[0].as_str().expect("Error message is not a string");
 
@@ -594,16 +573,15 @@ mod tests {
         assert_eq!(message, response.to_string());
     }
 
-    #[tokio::test(flavor = "multi_thread")]
+    #[graph::test]
     async fn posting_valid_queries_yields_result_response() {
         let logger = Logger::root(slog::Discard, o!());
         let subgraph_id = USERS.clone();
         let graphql_runner = Arc::new(TestGraphQlRunner);
 
-        let node_id = NodeId::new("test").unwrap();
-        let mut service = GraphQLService::new(logger, graphql_runner, 8001, node_id);
+        let service = GraphQLService::new(logger, graphql_runner);
 
-        let request = Request::builder()
+        let request: Request<Full<Bytes>> = Request::builder()
             .method(Method::POST)
             .header(CONTENT_TYPE, "text/plain; charset=utf-8")
             .header(CONTENT_LENGTH, 100)
@@ -611,16 +589,13 @@ mod tests {
                 "http://localhost:8000/subgraphs/id/{}",
                 subgraph_id
             ))
-            .body(Body::from("{\"query\": \"{ name }\"}"))
+            .body(Full::from("{\"query\": \"{ name }\"}"))
             .unwrap();
 
         // The response must be a 200
-        let response = tokio::spawn(service.call(request))
-            .await
-            .unwrap()
-            .expect("Should return a response");
+        let response = service.call(request).await;
 
-        let data = test_utils::assert_successful_response(response);
+        let data = test_utils::assert_successful_response(response).await;
 
         // The body should match the simulated query result
         let name = data
diff --git a/server/http/src/test_utils.rs b/server/http/src/test_utils.rs
index 6f99f5b1d83..114b729e385 100644
--- a/server/http/src/test_utils.rs
+++ b/server/http/src/test_utils.rs
@@ -1,46 +1,35 @@
+use graph::http_body_util::{BodyExt, Full};
+use graph::hyper::{Response, StatusCode, body::Bytes, header::ACCESS_CONTROL_ALLOW_ORIGIN};
 use graph::prelude::serde_json;
-use graph::prelude::*;
-use http::StatusCode;
-use hyper::{header::ACCESS_CONTROL_ALLOW_ORIGIN, Body, Response};
 
 /// Asserts that the response is a successful GraphQL response; returns its `"data"` field.
-pub fn assert_successful_response(
-    response: Response<Body>,
+pub async fn assert_successful_response(
+    response: Response<Full<Bytes>>,
 ) -> serde_json::Map<String, serde_json::Value> {
     assert_expected_headers(&response);
-    futures03::executor::block_on(
-        hyper::body::to_bytes(response.into_body())
-            .map_ok(|chunk| {
-                let json: serde_json::Value =
-                    serde_json::from_slice(&chunk).expect("GraphQL response is not valid JSON");
+    let body = response.collect().await.unwrap().to_bytes();
+    let json: serde_json::Value =
+        serde_json::from_slice(&body).expect("GraphQL response is not valid JSON");
 
-                json.as_object()
-                    .expect("GraphQL response must be an object")
-                    .get("data")
-                    .expect("GraphQL response must contain a \"data\" field")
-                    .as_object()
-                    .expect("GraphQL \"data\" field must be an object")
-                    .clone()
-            })
-            .map_err(|e| panic!("Truncated response body {:?}", e)),
-    )
-    .unwrap()
+    json.as_object()
+        .expect("GraphQL response must be an object")
+        .get("data")
+        .expect("GraphQL response must contain a \"data\" field")
+        .as_object()
+        .expect("GraphQL \"data\" field must be an object")
+        .clone()
 }
 
 /// Asserts that the response is a failed GraphQL response; returns its `"errors"` field.
-pub fn assert_error_response(
-    response: Response<Body>,
+pub async fn assert_error_response(
+    response: Response<Full<Bytes>>,
     expected_status: StatusCode,
     graphql_response: bool,
 ) -> Vec<serde_json::Value> {
     assert_eq!(response.status(), expected_status);
     assert_expected_headers(&response);
-    let body = String::from_utf8(
-        futures03::executor::block_on(hyper::body::to_bytes(response.into_body()))
-            .unwrap()
-            .to_vec(),
-    )
-    .unwrap();
+    let body = response.collect().await.unwrap().to_bytes().to_vec();
+    let body = String::from_utf8(body).unwrap();
 
     // In case of a non-graphql response, return the body.
     if !graphql_response {
@@ -60,7 +49,7 @@ pub fn assert_error_response(
 }
 
 #[track_caller]
-pub fn assert_expected_headers(response: &Response<Body>) {
+pub fn assert_expected_headers(response: &Response<Full<Bytes>>) {
     assert_eq!(
         response
             .headers()
diff --git a/server/http/tests/response.rs b/server/http/tests/response.rs
index 64b1ae04352..cd5041260cf 100644
--- a/server/http/tests/response.rs
+++ b/server/http/tests/response.rs
@@ -3,20 +3,20 @@ use graph::data::{graphql::object, query::QueryResults};
 use graph::prelude::*;
 use graph_server_http::test_utils;
 
-#[test]
-fn generates_200_for_query_results() {
+#[graph::test]
+async fn generates_200_for_query_results() {
     let data = Object::from_iter([]);
     let query_result = QueryResults::from(data).as_http_response();
     test_utils::assert_expected_headers(&query_result);
-    test_utils::assert_successful_response(query_result);
+    test_utils::assert_successful_response(query_result).await;
 }
 
-#[test]
-fn generates_valid_json_for_an_empty_result() {
+#[graph::test]
+async fn generates_valid_json_for_an_empty_result() {
     let data = Object::from_iter([]);
     let query_result = QueryResults::from(data).as_http_response();
     test_utils::assert_expected_headers(&query_result);
-    let data = test_utils::assert_successful_response(query_result);
+    let data = test_utils::assert_successful_response(query_result).await;
     assert!(data.is_empty());
 }
 
@@ -32,7 +32,7 @@ fn canonical_serialization() {
                 use r::Value::*;
                 let _ = match $obj {
                     Object(_) | List(_) | Enum(_) | Null | Int(_) | Float(_) | String(_)
-                    | Boolean(_) => (),
+                    | Timestamp(_) | Boolean(_) => (),
                 };
             }
             let res = QueryResult::try_from($obj).unwrap();
@@ -71,7 +71,12 @@ fn canonical_serialization() {
     );
 
     // Value::Float
-    assert_resp!(r#"{"data":{"float":3.14159}}"#, object! { float: 3.14159 });
+    #[allow(clippy::approx_constant)]
+    let almost_pi = 3.14159_f64;
+    assert_resp!(
+        r#"{"data":{"float":3.14159}}"#,
+        object! { float: almost_pi }
+    );
 
     // Value::String
     assert_resp!(
diff --git a/server/http/tests/server.rs b/server/http/tests/server.rs
index 778498a8ccc..a7d43360cf5 100644
--- a/server/http/tests/server.rs
+++ b/server/http/tests/server.rs
@@ -1,5 +1,8 @@
-use http::StatusCode;
-use hyper::{Body, Client, Request};
+use async_trait::async_trait;
+use graph::{
+    data::{query::SqlQueryReq, store::SqlQueryObject},
+    http::StatusCode,
+};
 use std::time::Duration;
 
 use graph::data::{
@@ -7,8 +10,6 @@ use graph::data::{
     value::{Object, Word},
 };
 use graph::prelude::*;
-
-use graph_server_http::test_utils;
 use graph_server_http::GraphQLServer as HyperGraphQLServer;
 
 use tokio::time::sleep;
@@ -55,237 +56,284 @@ impl GraphQlRunner for TestGraphQlRunner {
                 .unwrap()
                 == &r::Value::String(String::from("John"))
         {
-            Object::from_iter(
-                vec![(Word::from("name"), r::Value::String(String::from("John")))].into_iter(),
-            )
+            Object::from_iter(vec![(
+                Word::from("name"),
+                r::Value::String(String::from("John")),
+            )])
         } else {
-            Object::from_iter(
-                vec![(Word::from("name"), r::Value::String(String::from("Jordi")))].into_iter(),
-            )
+            Object::from_iter(vec![(
+                Word::from("name"),
+                r::Value::String(String::from("Jordi")),
+            )])
         }
         .into()
     }
 
-    async fn run_subscription(
-        self: Arc<Self>,
-        _subscription: Subscription,
-        _target: QueryTarget,
-    ) -> Result<SubscriptionResult, SubscriptionError> {
-        unreachable!();
-    }
-
     fn metrics(&self) -> Arc<dyn GraphQLMetrics> {
         Arc::new(TestGraphQLMetrics)
     }
+
+    async fn run_sql_query(
+        self: Arc<Self>,
+        _req: SqlQueryReq,
+    ) -> Result<Vec<SqlQueryObject>, QueryExecutionError> {
+        unimplemented!();
+    }
 }
 
 #[cfg(test)]
 mod test {
-    use http::header::CONTENT_TYPE;
+    use std::sync::atomic::Ordering;
 
     use super::*;
+    use graph::http::header::{ACCESS_CONTROL_ALLOW_ORIGIN, CONTENT_TYPE};
+    use graph::hyper::header::{ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS};
+    use graph::prelude::reqwest::{Client, Response};
 
     lazy_static! {
         static ref USERS: DeploymentHash = DeploymentHash::new("users").unwrap();
     }
 
-    #[test]
-    fn rejects_empty_json() {
-        let runtime = tokio::runtime::Runtime::new().unwrap();
-        runtime
-            .block_on(async {
-                let logger = Logger::root(slog::Discard, o!());
-                let logger_factory = LoggerFactory::new(logger, None, Arc::new(MetricsRegistry::mock()));
-                let id = USERS.clone();
-                let query_runner = Arc::new(TestGraphQlRunner);
-                let node_id = NodeId::new("test").unwrap();
-                let mut server = HyperGraphQLServer::new(&logger_factory, query_runner, node_id);
-                let http_server = server
-                    .serve(8007, 8008)
-                    .expect("Failed to start GraphQL server");
-
-                // Launch the server to handle a single request
-                tokio::spawn(http_server.fuse().compat());
-                // Give some time for the server to start.
-                sleep(Duration::from_secs(2))
-                    .then(move |()| {
-                        // Send an empty JSON POST request
-                        let client = Client::new();
-                        let request =
-                            Request::post(format!("http://localhost:8007/subgraphs/id/{}", id)).header(CONTENT_TYPE, "text/plain")
-                                .body(Body::from("{}"))
-                                .unwrap();
-
-                        // The response must be a query error
-                        client.request(request)
-                    })
-                    .map_ok(|response| {
-                        let errors =
-                            test_utils::assert_error_response(response, StatusCode::BAD_REQUEST, false);
-
-                        let message = errors[0]
-                            .as_str()
-                            .expect("Error message is not a string");
-                        assert_eq!(message, "{\"error\":\"GraphQL server error (client error): The \\\"query\\\" field is missing in request data\"}");
-                    }).await.unwrap()
-            })
+    pub async fn assert_successful_response(
+        response: Response,
+    ) -> serde_json::Map<String, serde_json::Value> {
+        assert_expected_headers(&response, true);
+        let body = response.bytes().await.unwrap().to_vec();
+        let json: serde_json::Value =
+            serde_json::from_slice(&body).expect("GraphQL response is not valid JSON");
+
+        json.as_object()
+            .expect("GraphQL response must be an object")
+            .get("data")
+            .expect("GraphQL response must contain a \"data\" field")
+            .as_object()
+            .expect("GraphQL \"data\" field must be an object")
+            .clone()
     }
 
-    #[test]
-    fn rejects_invalid_queries() {
-        let runtime = tokio::runtime::Runtime::new().unwrap();
-        runtime.block_on(async {
-            let logger = Logger::root(slog::Discard, o!());
-            let logger_factory =
-                LoggerFactory::new(logger, None, Arc::new(MetricsRegistry::mock()));
-            let id = USERS.clone();
-            let query_runner = Arc::new(TestGraphQlRunner);
-            let node_id = NodeId::new("test").unwrap();
-            let mut server = HyperGraphQLServer::new(&logger_factory, query_runner, node_id);
-            let http_server = server
-                .serve(8002, 8003)
-                .expect("Failed to start GraphQL server");
-
-            // Launch the server to handle a single request
-            tokio::spawn(http_server.fuse().compat());
-            // Give some time for the server to start.
-            sleep(Duration::from_secs(2))
-                .then(move |()| {
-                    // Send an broken query request
-                    let client = Client::new();
-                    let request =
-                        Request::post(format!("http://localhost:8002/subgraphs/id/{}", id))
-                            .header(CONTENT_TYPE, "text/plain")
-                            .body(Body::from("{\"query\": \"<L<G<>M>\"}"))
-                            .unwrap();
-
-                    // The response must be a query error
-                    client.request(request)
-                })
-                .map_ok(|response| {
-                    let errors = test_utils::assert_error_response(response, StatusCode::OK, true);
-
-                    let message = errors[0]
-                        .as_object()
-                        .expect("Query error is not an object")
-                        .get("message")
-                        .expect("Error contains no message")
-                        .as_str()
-                        .expect("Error message is not a string");
-
-                    assert_eq!(
-                        message,
-                        "Unexpected `unexpected character \
-                         \'<\'`\nExpected `{`, `query`, `mutation`, \
-                         `subscription` or `fragment`"
-                    );
-
-                    let locations = errors[0]
-                        .as_object()
-                        .expect("Query error is not an object")
-                        .get("locations")
-                        .expect("Query error contains not locations")
-                        .as_array()
-                        .expect("Query error \"locations\" field is not an array");
-
-                    let location = locations[0]
-                        .as_object()
-                        .expect("Query error location is not an object");
-
-                    let line = location
-                        .get("line")
-                        .expect("Query error location is missing a \"line\" field")
-                        .as_u64()
-                        .expect("Query error location \"line\" field is not a u64");
-
-                    assert_eq!(line, 1);
-
-                    let column = location
-                        .get("column")
-                        .expect("Query error location is missing a \"column\" field")
-                        .as_u64()
-                        .expect("Query error location \"column\" field is not a u64");
-
-                    assert_eq!(column, 1);
-                })
-                .await
-                .unwrap()
-        })
+    pub async fn assert_error_response(
+        response: Response,
+        expected_status: StatusCode,
+        graphql_response: bool,
+    ) -> Vec<serde_json::Value> {
+        assert_eq!(response.status(), expected_status);
+        assert_expected_headers(&response, false);
+        let body = response.bytes().await.unwrap().to_vec();
+        let body = String::from_utf8(body).unwrap();
+
+        // In case of a non-graphql response, return the body.
+        if !graphql_response {
+            return vec![serde_json::Value::String(body)];
+        }
+
+        let json: serde_json::Value =
+            serde_json::from_str(&body).expect("GraphQL response is not valid JSON");
+
+        json.as_object()
+            .expect("GraphQL response must be an object")
+            .get("errors")
+            .expect("GraphQL error response must contain an \"errors\" field")
+            .as_array()
+            .expect("GraphQL \"errors\" field must be a vector")
+            .clone()
     }
 
-    #[test]
-    fn accepts_valid_queries() {
-        let runtime = tokio::runtime::Runtime::new().unwrap();
-        runtime.block_on(async {
-            let logger = Logger::root(slog::Discard, o!());
-            let logger_factory =
-                LoggerFactory::new(logger, None, Arc::new(MetricsRegistry::mock()));
-            let id = USERS.clone();
-            let query_runner = Arc::new(TestGraphQlRunner);
-            let node_id = NodeId::new("test").unwrap();
-            let mut server = HyperGraphQLServer::new(&logger_factory, query_runner, node_id);
-            let http_server = server
-                .serve(8003, 8004)
-                .expect("Failed to start GraphQL server");
-
-            // Launch the server to handle a single request
-            tokio::spawn(http_server.fuse().compat());
-            // Give some time for the server to start.
-            sleep(Duration::from_secs(2))
-                .then(move |()| {
-                    // Send a valid example query
-                    let client = Client::new();
-                    let request =
-                        Request::post(format!("http://localhost:8003/subgraphs/id/{}", id))
-                            .header(CONTENT_TYPE, "plain/text")
-                            .body(Body::from("{\"query\": \"{ name }\"}"))
-                            .unwrap();
-
-                    // The response must be a 200
-                    client.request(request)
-                })
-                .map_ok(|response| {
-                    let data = test_utils::assert_successful_response(response);
-
-                    // The JSON response should match the simulated query result
-                    let name = data
-                        .get("name")
-                        .expect("Query result data has no \"name\" field")
-                        .as_str()
-                        .expect("Query result field \"name\" is not a string");
-                    assert_eq!(name, "Jordi".to_string());
-                })
-                .await
-                .unwrap()
-        });
+    #[track_caller]
+    pub fn assert_expected_headers(response: &Response, success: bool) {
+        #[track_caller]
+        fn assert_header(response: &Response, header: &str, value: &str) {
+            let hdrs = response.headers();
+            let value = Some(value.parse().unwrap());
+            assert_eq!(
+                value.as_ref(),
+                hdrs.get(header),
+                "Header {} has unexpected value",
+                header
+            );
+        }
+
+        assert_header(response, ACCESS_CONTROL_ALLOW_ORIGIN.as_str(), "*");
+        if success {
+            assert_header(
+                response,
+                ACCESS_CONTROL_ALLOW_HEADERS.as_str(),
+                "Content-Type, User-Agent",
+            );
+            assert_header(
+                response,
+                ACCESS_CONTROL_ALLOW_METHODS.as_str(),
+                "GET, OPTIONS, POST",
+            );
+            assert_header(response, CONTENT_TYPE.as_str(), "application/json");
+
+            assert_header(response, "Graph-Attestable", "true");
+        }
+    }
+
+    #[graph::test]
+    async fn rejects_empty_json() {
+        let logger = Logger::root(slog::Discard, o!());
+        let logger_factory = LoggerFactory::new(logger, None, Arc::new(MetricsRegistry::mock()));
+        let id = USERS.clone();
+        let query_runner = Arc::new(TestGraphQlRunner);
+        let server = HyperGraphQLServer::new(&logger_factory, query_runner);
+        let server_handle = server
+            .start(8007)
+            .await
+            .expect("Failed to start GraphQL server");
+        while !server_handle.accepting.load(Ordering::SeqCst) {
+            sleep(Duration::from_millis(20)).await;
+        }
+
+        // Send an empty JSON POST request
+        let client = Client::new();
+        let request = client
+            .post(format!("http://localhost:8007/subgraphs/id/{}", id))
+            .header(CONTENT_TYPE, "text/plain")
+            .body("{}")
+            .build()
+            .unwrap();
+
+        // The response must be a query error
+        let response = client.execute(request).await.unwrap();
+        let errors = assert_error_response(response, StatusCode::BAD_REQUEST, false).await;
+
+        let message = errors[0].as_str().expect("Error message is not a string");
+        assert_eq!(
+            message,
+            "{\"error\":\"GraphQL server error (client error): The \\\"query\\\" field is missing in request data\"}"
+        );
+    }
+
+    #[graph::test]
+    async fn rejects_invalid_queries() {
+        let logger = Logger::root(slog::Discard, o!());
+        let logger_factory = LoggerFactory::new(logger, None, Arc::new(MetricsRegistry::mock()));
+        let id = USERS.clone();
+        let query_runner = Arc::new(TestGraphQlRunner);
+        let server = HyperGraphQLServer::new(&logger_factory, query_runner);
+        let server_handle = server
+            .start(8002)
+            .await
+            .expect("Failed to start GraphQL server");
+        while !server_handle.accepting.load(Ordering::SeqCst) {
+            sleep(Duration::from_millis(20)).await;
+        }
+
+        // Send an broken query request
+        let client = Client::new();
+        let request = client
+            .post(format!("http://localhost:8002/subgraphs/id/{}", id))
+            .header(CONTENT_TYPE, "text/plain")
+            .body("{\"query\": \"<L<G<>M>\"}")
+            .build()
+            .unwrap();
+
+        // The response must be a query error
+        let response = client.execute(request).await.unwrap();
+        let errors = assert_error_response(response, StatusCode::OK, true).await;
+
+        let message = errors[0]
+            .as_object()
+            .expect("Query error is not an object")
+            .get("message")
+            .expect("Error contains no message")
+            .as_str()
+            .expect("Error message is not a string");
+
+        assert_eq!(
+            message,
+            "Unexpected unexpected character '<'\nUnexpected end of input\nExpected {, query, mutation, subscription or fragment"
+        );
+
+        let locations = errors[0]
+            .as_object()
+            .expect("Query error is not an object")
+            .get("locations")
+            .expect("Query error contains not locations")
+            .as_array()
+            .expect("Query error \"locations\" field is not an array");
+
+        let location = locations[0]
+            .as_object()
+            .expect("Query error location is not an object");
+
+        let line = location
+            .get("line")
+            .expect("Query error location is missing a \"line\" field")
+            .as_u64()
+            .expect("Query error location \"line\" field is not a u64");
+
+        assert_eq!(line, 1);
+
+        let column = location
+            .get("column")
+            .expect("Query error location is missing a \"column\" field")
+            .as_u64()
+            .expect("Query error location \"column\" field is not a u64");
+
+        assert_eq!(column, 1);
+    }
+
+    #[graph::test]
+    async fn accepts_valid_queries() {
+        let logger = Logger::root(slog::Discard, o!());
+        let logger_factory = LoggerFactory::new(logger, None, Arc::new(MetricsRegistry::mock()));
+        let id = USERS.clone();
+        let query_runner = Arc::new(TestGraphQlRunner);
+        let server = HyperGraphQLServer::new(&logger_factory, query_runner);
+        let server_handle = server
+            .start(8003)
+            .await
+            .expect("Failed to start GraphQL server");
+        while !server_handle.accepting.load(Ordering::SeqCst) {
+            sleep(Duration::from_millis(20)).await;
+        }
+
+        // Send a valid example query
+        let client = Client::new();
+        let request = client
+            .post(format!("http://localhost:8003/subgraphs/id/{}", id))
+            .header(CONTENT_TYPE, "plain/text")
+            .body("{\"query\": \"{ name }\"}")
+            .build()
+            .unwrap();
+
+        // The response must be a 200
+        let response = client.execute(request).await.unwrap();
+        let data = assert_successful_response(response).await;
+
+        // The JSON response should match the simulated query result
+        let name = data
+            .get("name")
+            .expect("Query result data has no \"name\" field")
+            .as_str()
+            .expect("Query result field \"name\" is not a string");
+        assert_eq!(name, "Jordi".to_string());
     }
 
-    #[test]
-    fn accepts_valid_queries_with_variables() {
-        let runtime = tokio::runtime::Runtime::new().unwrap();
-        let _ = runtime.block_on(async {
-            let logger = Logger::root(slog::Discard, o!());
-            let logger_factory =
-                LoggerFactory::new(logger, None, Arc::new(MetricsRegistry::mock()));
-            let id = USERS.clone();
-            let query_runner = Arc::new(TestGraphQlRunner);
-            let node_id = NodeId::new("test").unwrap();
-            let mut server = HyperGraphQLServer::new(&logger_factory, query_runner, node_id);
-            let http_server = server
-                .serve(8005, 8006)
-                .expect("Failed to start GraphQL server");
-
-            // Launch the server to handle a single request
-            tokio::spawn(http_server.fuse().compat());
-            // Give some time for the server to start.
-            sleep(Duration::from_secs(2))
-                .then(move |()| {
-                    // Send a valid example query
-                    let client = Client::new();
-                    let request =
-                        Request::post(format!("http://localhost:8005/subgraphs/id/{}", id))
-                            .body(Body::from(
-                                "
+    #[graph::test]
+    async fn accepts_valid_queries_with_variables() {
+        let logger = Logger::root(slog::Discard, o!());
+        let logger_factory = LoggerFactory::new(logger, None, Arc::new(MetricsRegistry::mock()));
+        let id = USERS.clone();
+        let query_runner = Arc::new(TestGraphQlRunner);
+        let server = HyperGraphQLServer::new(&logger_factory, query_runner);
+        let server_handle = server
+            .start(8005)
+            .await
+            .expect("Failed to start GraphQL server");
+        while !server_handle.accepting.load(Ordering::SeqCst) {
+            sleep(Duration::from_millis(20)).await;
+        }
+
+        // Send a valid example query
+        let client = Client::new();
+        let request = client
+            .post(format!("http://localhost:8005/subgraphs/id/{}", id))
+            .header(CONTENT_TYPE, "plain/text")
+            .body(
+                "
                             {
                               \"query\": \" \
                                 query name($equals: String!) { \
@@ -295,27 +343,20 @@ mod test {
                               \"variables\": { \"equals\": \"John\" }
                             }
                             ",
-                            ))
-                            .unwrap();
-
-                    // The response must be a 200
-                    client.request(request)
-                })
-                .map_ok(|response| {
-                    async {
-                        let data = test_utils::assert_successful_response(response);
-
-                        // The JSON response should match the simulated query result
-                        let name = data
-                            .get("name")
-                            .expect("Query result data has no \"name\" field")
-                            .as_str()
-                            .expect("Query result field \"name\" is not a string");
-                        assert_eq!(name, "John".to_string());
-                    }
-                })
-                .await
-                .unwrap()
-        });
+            )
+            .build()
+            .unwrap();
+
+        // The response must be a 200
+        let response = client.execute(request).await.unwrap();
+        let data = assert_successful_response(response).await;
+
+        // The JSON response should match the simulated query result
+        let name = data
+            .get("name")
+            .expect("Query result data has no \"name\" field")
+            .as_str()
+            .expect("Query result field \"name\" is not a string");
+        assert_eq!(name, "John".to_string());
     }
 }
diff --git a/server/index-node/Cargo.toml b/server/index-node/Cargo.toml
index 96d049475ca..549b56c4365 100644
--- a/server/index-node/Cargo.toml
+++ b/server/index-node/Cargo.toml
@@ -4,20 +4,10 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-blake3 = "1.5"
-either = "1.9.0"
-futures = "0.3.4"
+async-trait = { workspace = true }
+blake3 = "1.8"
 graph = { path = "../../graph" }
 graph-graphql = { path = "../../graphql" }
-graph-chain-arweave = { path = "../../chain/arweave" }
 graph-chain-ethereum = { path = "../../chain/ethereum" }
 graph-chain-near = { path = "../../chain/near" }
-graph-chain-cosmos = { path = "../../chain/cosmos" }
-graph-chain-starknet = { path = "../../chain/starknet" }
-graph-chain-substreams = { path = "../../chain/substreams" }
-graphql-parser = "0.4.0"
-http = "0.2"
-hyper = "0.14"
-lazy_static = "1.2.0"
-serde = "1.0"
-git-testament = "0.2.5"
+git-testament = { workspace = true }
diff --git a/server/index-node/src/auth.rs b/server/index-node/src/auth.rs
index 7f27a535914..84373daae0d 100644
--- a/server/index-node/src/auth.rs
+++ b/server/index-node/src/auth.rs
@@ -1,6 +1,7 @@
-use hyper::header::AUTHORIZATION;
+use graph::hyper::header::AUTHORIZATION;
 
 use graph::env::EnvVars;
+use graph::hyper::HeaderMap;
 
 /// Validation logic for access tokens required to access POI results.
 pub struct PoiProtection {
@@ -48,7 +49,7 @@ impl PoiProtection {
     }
 }
 
-pub fn bearer_token(headers: &hyper::HeaderMap) -> Option<&[u8]> {
+pub fn bearer_token(headers: &HeaderMap) -> Option<&[u8]> {
     let header = headers.get(AUTHORIZATION)?.as_bytes();
     header.strip_prefix(b"Bearer ")
 }
diff --git a/server/index-node/src/explorer.rs b/server/index-node/src/explorer.rs
index 5c7d0215b40..728fc228129 100644
--- a/server/index-node/src/explorer.rs
+++ b/server/index-node/src/explorer.rs
@@ -1,23 +1,24 @@
 //! Functionality to support the explorer in the hosted service. Everything
 //! in this file is private API and experimental and subject to change at
 //! any time
-use graph::prelude::r;
-use http::{Response, StatusCode};
-use hyper::header::{
+use graph::components::server::query::{ServerResponse, ServerResult};
+use graph::http_body_util::Full;
+use graph::hyper::header::{
     ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
     CONTENT_TYPE,
 };
-use hyper::Body;
+use graph::hyper::{Response, StatusCode};
+use graph::prelude::r;
 use std::{sync::Arc, time::Instant};
 
 use graph::{
     components::{
-        server::{index_node::VersionInfo, query::GraphQLServerError},
+        server::{index_node::VersionInfo, query::ServerError},
         store::StatusStore,
     },
     data::subgraph::status,
     object,
-    prelude::{serde_json, warn, Logger, ENV_VARS},
+    prelude::{ENV_VARS, Logger, serde_json, warn},
     util::timed_cache::TimedCache,
 };
 
@@ -47,32 +48,25 @@ where
         }
     }
 
-    pub fn handle(
-        &self,
-        logger: &Logger,
-        req: &[&str],
-    ) -> Result<Response<Body>, GraphQLServerError> {
+    pub async fn handle(&self, logger: &Logger, req: &[&str]) -> ServerResult {
         match req {
-            ["subgraph-versions", subgraph_id] => self.handle_subgraph_versions(subgraph_id),
-            ["subgraph-version", version] => self.handle_subgraph_version(version),
-            ["subgraph-repo", version] => self.handle_subgraph_repo(version),
-            ["entity-count", deployment] => self.handle_entity_count(logger, deployment),
+            ["subgraph-versions", subgraph_id] => self.handle_subgraph_versions(subgraph_id).await,
+            ["subgraph-version", version] => self.handle_subgraph_version(version).await,
+            ["subgraph-repo", version] => self.handle_subgraph_repo(version).await,
+            ["entity-count", deployment] => self.handle_entity_count(logger, deployment).await,
             ["subgraphs-for-deployment", deployment_hash] => {
-                self.handle_subgraphs_for_deployment(deployment_hash)
+                self.handle_subgraphs_for_deployment(deployment_hash).await
             }
             _ => handle_not_found(),
         }
     }
 
-    fn handle_subgraph_versions(
-        &self,
-        subgraph_id: &str,
-    ) -> Result<Response<Body>, GraphQLServerError> {
+    async fn handle_subgraph_versions(&self, subgraph_id: &str) -> ServerResult {
         if let Some(value) = self.versions.get(subgraph_id) {
             return Ok(as_http_response(value.as_ref()));
         }
 
-        let (current, pending) = self.store.versions_for_subgraph_id(subgraph_id)?;
+        let (current, pending) = self.store.versions_for_subgraph_id(subgraph_id).await?;
 
         let value = object! {
             currentVersion: current,
@@ -84,8 +78,8 @@ where
         Ok(resp)
     }
 
-    fn handle_subgraph_version(&self, version: &str) -> Result<Response<Body>, GraphQLServerError> {
-        let vi = self.version_info(version)?;
+    async fn handle_subgraph_version(&self, version: &str) -> ServerResult {
+        let vi = self.version_info(version).await?;
 
         let latest_ethereum_block_number = vi.latest_ethereum_block_number;
         let total_ethereum_blocks_count = vi.total_ethereum_blocks_count;
@@ -104,8 +98,8 @@ where
         Ok(as_http_response(&value))
     }
 
-    fn handle_subgraph_repo(&self, version: &str) -> Result<Response<Body>, GraphQLServerError> {
-        let vi = self.version_info(version)?;
+    async fn handle_subgraph_repo(&self, version: &str) -> ServerResult {
+        let vi = self.version_info(version).await?;
 
         let value = object! {
             createdAt: vi.created_at.as_str(),
@@ -115,11 +109,7 @@ where
         Ok(as_http_response(&value))
     }
 
-    fn handle_entity_count(
-        &self,
-        logger: &Logger,
-        deployment: &str,
-    ) -> Result<Response<Body>, GraphQLServerError> {
+    async fn handle_entity_count(&self, logger: &Logger, deployment: &str) -> ServerResult {
         let start = Instant::now();
         let count = self.entity_counts.get(deployment);
         if start.elapsed() > ENV_VARS.explorer_lock_threshold {
@@ -140,7 +130,8 @@ where
         let start = Instant::now();
         let infos = self
             .store
-            .status(status::Filter::Deployments(vec![deployment.to_string()]))?;
+            .status(status::Filter::Deployments(vec![deployment.to_string()]))
+            .await?;
         if start.elapsed() > ENV_VARS.explorer_query_threshold {
             warn!(logger, "Getting entity_count takes too long";
             "action" => "query_status",
@@ -177,24 +168,22 @@ where
         Ok(resp)
     }
 
-    fn version_info(&self, version: &str) -> Result<Arc<VersionInfo>, GraphQLServerError> {
+    async fn version_info(&self, version: &str) -> Result<Arc<VersionInfo>, ServerError> {
         match self.version_infos.get(version) {
             Some(vi) => Ok(vi),
             None => {
-                let vi = Arc::new(self.store.version_info(version)?);
+                let vi = Arc::new(self.store.version_info(version).await?);
                 self.version_infos.set(version.to_string(), vi.clone());
                 Ok(vi)
             }
         }
     }
 
-    fn handle_subgraphs_for_deployment(
-        &self,
-        deployment_hash: &str,
-    ) -> Result<Response<Body>, GraphQLServerError> {
+    async fn handle_subgraphs_for_deployment(&self, deployment_hash: &str) -> ServerResult {
         let name_version_pairs: Vec<r::Value> = self
             .store
-            .subgraphs_for_deployment_hash(deployment_hash)?
+            .subgraphs_for_deployment_hash(deployment_hash)
+            .await?
             .into_iter()
             .map(|(name, version)| {
                 object! {
@@ -208,24 +197,24 @@ where
     }
 }
 
-fn handle_not_found() -> Result<Response<Body>, GraphQLServerError> {
+fn handle_not_found() -> ServerResult {
     Ok(Response::builder()
         .status(StatusCode::NOT_FOUND)
         .header(CONTENT_TYPE, "text/plain")
         .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-        .body(Body::from("Not found\n"))
+        .body(Full::from("Not found\n"))
         .unwrap())
 }
 
-fn as_http_response(value: &r::Value) -> http::Response<Body> {
-    let status_code = http::StatusCode::OK;
+fn as_http_response(value: &r::Value) -> ServerResponse {
+    let status_code = StatusCode::OK;
     let json = serde_json::to_string(&value).expect("Failed to serialize response to JSON");
-    http::Response::builder()
+    Response::builder()
         .status(status_code)
         .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
         .header(ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type, User-Agent")
         .header(ACCESS_CONTROL_ALLOW_METHODS, "GET, OPTIONS, POST")
         .header(CONTENT_TYPE, "application/json")
-        .body(Body::from(json))
+        .body(Full::from(json))
         .unwrap()
 }
diff --git a/server/index-node/src/lib.rs b/server/index-node/src/lib.rs
index 1db9861b1e9..7ce6b03cb9d 100644
--- a/server/index-node/src/lib.rs
+++ b/server/index-node/src/lib.rs
@@ -7,7 +7,7 @@ mod service;
 
 pub use self::auth::PoiProtection;
 pub use self::server::IndexNodeServer;
-pub use self::service::{IndexNodeService, IndexNodeServiceResponse};
+pub use self::service::IndexNodeService;
 
 #[cfg(debug_assertions)]
 pub use self::resolver::IndexNodeResolver;
diff --git a/server/index-node/src/resolver.rs b/server/index-node/src/resolver.rs
index 8650a637fce..5d23483265e 100644
--- a/server/index-node/src/resolver.rs
+++ b/server/index-node/src/resolver.rs
@@ -1,20 +1,23 @@
 use std::collections::BTreeMap;
-use std::convert::TryInto;
 
+use async_trait::async_trait;
 use graph::data::query::Trace;
 use graph::data::store::Id;
+use graph::prelude::alloy::primitives::Address;
 use graph::schema::EntityType;
-use web3::types::Address;
 
-use git_testament::{git_testament, CommitKind};
+use git_testament::{CommitKind, git_testament};
+use graph::amp;
 use graph::blockchain::{Blockchain, BlockchainKind, BlockchainMap};
+use graph::components::link_resolver::LinkResolverContext;
 use graph::components::store::{BlockPtrForNumber, BlockStore, QueryPermit, Store};
 use graph::components::versions::VERSIONS;
-use graph::data::graphql::{object, IntoValue, ObjectOrInterface, ValueMap};
-use graph::data::subgraph::{status, DeploymentFeatures};
+use graph::data::graphql::{IntoValue, ObjectOrInterface, ValueMap, object};
+use graph::data::subgraph::{DeploymentFeatures, status};
 use graph::data::value::Object;
+use graph::futures03::TryFutureExt;
 use graph::prelude::*;
-use graph_graphql::prelude::{a, ExecutionContext, Resolver};
+use graph_graphql::prelude::{ExecutionContext, Resolver, a};
 
 use crate::auth::PoiProtection;
 
@@ -93,20 +96,25 @@ impl IntoValue for PublicProofOfIndexingResult {
 
 /// Resolver for the index node GraphQL API.
 #[derive(Clone)]
-pub struct IndexNodeResolver<S: Store> {
+pub struct IndexNodeResolver<S: Store, AC> {
     logger: Logger,
     blockchain_map: Arc<BlockchainMap>,
     store: Arc<S>,
-    #[allow(dead_code)]
     link_resolver: Arc<dyn LinkResolver>,
+    amp_client: Option<Arc<AC>>,
     bearer_token: Option<String>,
 }
 
-impl<S: Store> IndexNodeResolver<S> {
+impl<S, AC> IndexNodeResolver<S, AC>
+where
+    S: Store,
+    AC: amp::Client + Send + Sync + 'static,
+{
     pub fn new(
         logger: &Logger,
         store: Arc<S>,
         link_resolver: Arc<dyn LinkResolver>,
+        amp_client: Option<Arc<AC>>,
         bearer_token: Option<String>,
         blockchain_map: Arc<BlockchainMap>,
     ) -> Self {
@@ -117,11 +125,15 @@ impl<S: Store> IndexNodeResolver<S> {
             blockchain_map,
             store,
             link_resolver,
+            amp_client,
             bearer_token,
         }
     }
 
-    fn resolve_indexing_statuses(&self, field: &a::Field) -> Result<r::Value, QueryExecutionError> {
+    async fn resolve_indexing_statuses(
+        &self,
+        field: &a::Field,
+    ) -> Result<r::Value, QueryExecutionError> {
         let deployments = field
             .argument_value("subgraphs")
             .map(|value| match value {
@@ -134,15 +146,16 @@ impl<S: Store> IndexNodeResolver<S> {
                     .collect(),
                 _ => unreachable!(),
             })
-            .unwrap_or_else(Vec::new);
+            .unwrap_or_default();
 
         let infos = self
             .store
-            .status(status::Filter::Deployments(deployments))?;
+            .status(status::Filter::Deployments(deployments))
+            .await?;
         Ok(infos.into_value())
     }
 
-    fn resolve_indexing_statuses_for_subgraph_name(
+    async fn resolve_indexing_statuses_for_subgraph_name(
         &self,
         field: &a::Field,
     ) -> Result<r::Value, QueryExecutionError> {
@@ -161,12 +174,13 @@ impl<S: Store> IndexNodeResolver<S> {
 
         let infos = self
             .store
-            .status(status::Filter::SubgraphName(subgraph_name))?;
+            .status(status::Filter::SubgraphName(subgraph_name))
+            .await?;
 
         Ok(infos.into_value())
     }
 
-    fn resolve_entity_changes_in_block(
+    async fn resolve_entity_changes_in_block(
         &self,
         field: &a::Field,
     ) -> Result<r::Value, QueryExecutionError> {
@@ -181,7 +195,8 @@ impl<S: Store> IndexNodeResolver<S> {
         let entity_changes = self
             .store
             .subgraph_store()
-            .entity_changes_in_block(&subgraph_id, block_number)?;
+            .entity_changes_in_block(&subgraph_id, block_number)
+            .await?;
 
         Ok(entity_changes_to_graphql(entity_changes))
     }
@@ -195,7 +210,7 @@ impl<S: Store> IndexNodeResolver<S> {
             .get_required::<BlockHash>("blockHash")
             .expect("Valid blockHash required");
 
-        let chain_store = if let Some(cs) = self.store.block_store().chain_store(&network) {
+        let chain_store = if let Some(cs) = self.store.block_store().chain_store(&network).await {
             cs
         } else {
             error!(
@@ -220,7 +235,21 @@ impl<S: Store> IndexNodeResolver<S> {
             }
             Ok(mut blocks) => {
                 assert!(blocks.len() == 1, "Multiple blocks with the same hash");
-                blocks.pop().unwrap().into()
+                let block = blocks.pop().unwrap();
+                let json = block.to_json();
+                match json {
+                    Ok(json) => json.into(),
+                    Err(e) => {
+                        error!(
+                            self.logger,
+                            "Failed to serialize cached block";
+                            "network" => network.as_str(),
+                            "block_hash" => format!("{}", block_hash),
+                            "error" => e.to_string(),
+                        );
+                        r::Value::Null
+                    }
+                }
             }
             Err(e) => {
                 error!(
@@ -266,7 +295,7 @@ impl<S: Store> IndexNodeResolver<S> {
 
         let chain = if let Ok(c) = self
             .blockchain_map
-            .get::<graph_chain_ethereum::Chain>(network.clone())
+            .get::<graph_chain_ethereum::Chain>(network.as_str().into())
         {
             c
         } else {
@@ -278,11 +307,10 @@ impl<S: Store> IndexNodeResolver<S> {
             );
             return Ok(r::Value::Null);
         };
-        let chain_store = chain.chain_store();
         let call_cache = chain.call_cache();
 
-        let (block_number, timestamp) = match chain_store.block_number(&block_hash).await {
-            Ok(Some((_, n, timestamp))) => (n, timestamp),
+        let (block_number, timestamp) = match chain.block_number(&block_hash).await {
+            Ok(Some((_, n, timestamp, _))) => (n, timestamp),
             Ok(None) => {
                 error!(
                     self.logger,
@@ -305,7 +333,7 @@ impl<S: Store> IndexNodeResolver<S> {
         };
         let block_ptr = BlockPtr::new(block_hash.cheap_clone(), block_number);
 
-        let calls = match call_cache.get_calls_in_block(block_ptr) {
+        let calls = match call_cache.get_calls_in_block(block_ptr).await {
             Ok(c) => c,
             Err(e) => {
                 error!(
@@ -345,9 +373,7 @@ impl<S: Store> IndexNodeResolver<S> {
 
         let block_number: i32 = field
             .get_required::<i32>("blockNumber")
-            .expect("Valid blockNumber required")
-            .try_into()
-            .unwrap();
+            .expect("Valid blockNumber required");
 
         let block_hash = field
             .get_required::<BlockHash>("blockHash")
@@ -363,13 +389,13 @@ impl<S: Store> IndexNodeResolver<S> {
         if !poi_protection.validate_access_token(self.bearer_token.as_deref()) {
             // Let's sign the POI with a zero'd address when the access token is
             // invalid.
-            indexer = Some(Address::zero());
+            indexer = Some(Address::ZERO);
         }
 
         let poi_fut = self
             .store
             .get_proof_of_indexing(&deployment_id, &indexer, block.clone());
-        let poi = match futures::executor::block_on(poi_fut) {
+        let poi = match graph::futures03::executor::block_on(poi_fut) {
             Ok(Some(poi)) => r::Value::String(format!("0x{}", hex::encode(poi))),
             Ok(None) => r::Value::Null,
             Err(e) => {
@@ -439,7 +465,7 @@ impl<S: Store> IndexNodeResolver<S> {
         Ok(r::Value::List(public_poi_results))
     }
 
-    fn resolve_indexing_status_for_version(
+    async fn resolve_indexing_status_for_version(
         &self,
         field: &a::Field,
 
@@ -456,10 +482,13 @@ impl<S: Store> IndexNodeResolver<S> {
             "current_version" => current_version,
         );
 
-        let infos = self.store.status(status::Filter::SubgraphVersion(
-            subgraph_name,
-            current_version,
-        ))?;
+        let infos = self
+            .store
+            .status(status::Filter::SubgraphVersion(
+                subgraph_name,
+                current_version,
+            ))
+            .await?;
 
         Ok(infos
             .into_iter()
@@ -492,7 +521,10 @@ impl<S: Store> IndexNodeResolver<S> {
         let raw_yaml: serde_yaml::Mapping = {
             let file_bytes = self
                 .link_resolver
-                .cat(&self.logger, &deployment_hash.to_ipfs_link())
+                .cat(
+                    &LinkResolverContext::new(deployment_hash, &self.logger),
+                    &deployment_hash.to_ipfs_link(),
+                )
                 .await
                 .map_err(SubgraphManifestResolveError::ResolveError)?;
 
@@ -511,23 +543,7 @@ impl<S: Store> IndexNodeResolver<S> {
                         deployment_hash.clone(),
                         raw_yaml,
                         &self.link_resolver,
-                        &self.logger,
-                        max_spec_version,
-                    )
-                    .await?;
-
-                Self::validate_and_extract_features(
-                    &self.store.subgraph_store(),
-                    unvalidated_subgraph_manifest,
-                )
-                .await?
-            }
-            BlockchainKind::Cosmos => {
-                let unvalidated_subgraph_manifest =
-                    UnvalidatedSubgraphManifest::<graph_chain_cosmos::Chain>::resolve(
-                        deployment_hash.clone(),
-                        raw_yaml,
-                        &self.link_resolver,
+                        self.amp_client.cheap_clone(),
                         &self.logger,
                         max_spec_version,
                     )
@@ -545,57 +561,7 @@ impl<S: Store> IndexNodeResolver<S> {
                         deployment_hash.clone(),
                         raw_yaml,
                         &self.link_resolver,
-                        &self.logger,
-                        max_spec_version,
-                    )
-                    .await?;
-
-                Self::validate_and_extract_features(
-                    &self.store.subgraph_store(),
-                    unvalidated_subgraph_manifest,
-                )
-                .await?
-            }
-            BlockchainKind::Arweave => {
-                let unvalidated_subgraph_manifest =
-                    UnvalidatedSubgraphManifest::<graph_chain_arweave::Chain>::resolve(
-                        deployment_hash.clone(),
-                        raw_yaml,
-                        &self.link_resolver,
-                        &self.logger,
-                        max_spec_version,
-                    )
-                    .await?;
-
-                Self::validate_and_extract_features(
-                    &self.store.subgraph_store(),
-                    unvalidated_subgraph_manifest,
-                )
-                .await?
-            }
-            BlockchainKind::Substreams => {
-                let unvalidated_subgraph_manifest =
-                    UnvalidatedSubgraphManifest::<graph_chain_substreams::Chain>::resolve(
-                        deployment_hash.clone(),
-                        raw_yaml,
-                        &self.link_resolver,
-                        &self.logger,
-                        max_spec_version,
-                    )
-                    .await?;
-
-                Self::validate_and_extract_features(
-                    &self.store.subgraph_store(),
-                    unvalidated_subgraph_manifest,
-                )
-                .await?
-            }
-            BlockchainKind::Starknet => {
-                let unvalidated_subgraph_manifest =
-                    UnvalidatedSubgraphManifest::<graph_chain_substreams::Chain>::resolve(
-                        deployment_hash.clone(),
-                        raw_yaml,
-                        &self.link_resolver,
+                        self.amp_client.cheap_clone(),
                         &self.logger,
                         max_spec_version,
                     )
@@ -626,7 +592,24 @@ impl<S: Store> IndexNodeResolver<S> {
 
         let subgraph_store = self.store.subgraph_store();
         let features = match subgraph_store.subgraph_features(&deployment_hash).await? {
-            Some(features) => features,
+            Some(features) => {
+                let mut deployment_features = features.clone();
+                let features = &mut deployment_features.features;
+
+                if deployment_features.has_declared_calls {
+                    features.push("declaredEthCalls".to_string());
+                }
+                if deployment_features.has_aggregations {
+                    features.push("aggregations".to_string());
+                }
+                if !deployment_features.immutable_entities.is_empty() {
+                    features.push("immutableEntities".to_string());
+                }
+                if deployment_features.has_bytes_as_ids {
+                    features.push("bytesAsIds".to_string());
+                }
+                deployment_features
+            }
             None => self.get_features_from_ipfs(&deployment_hash).await?,
         };
 
@@ -658,7 +641,7 @@ impl<S: Store> IndexNodeResolver<S> {
     ) -> Result<Option<BlockPtr>, QueryExecutionError> {
         macro_rules! try_resolve_for_chain {
             ( $typ:path ) => {
-                let blockchain = self.blockchain_map.get::<$typ>(network.to_string()).ok();
+                let blockchain = self.blockchain_map.get::<$typ>(network.as_str().into()).ok();
 
                 if let Some(blockchain) = blockchain {
                     debug!(
@@ -696,10 +679,7 @@ impl<S: Store> IndexNodeResolver<S> {
         // Ugly, but we can't get back an object trait from the `BlockchainMap`,
         // so this seems like the next best thing.
         try_resolve_for_chain!(graph_chain_ethereum::Chain);
-        try_resolve_for_chain!(graph_chain_arweave::Chain);
-        try_resolve_for_chain!(graph_chain_cosmos::Chain);
         try_resolve_for_chain!(graph_chain_near::Chain);
-        try_resolve_for_chain!(graph_chain_starknet::Chain);
 
         // If you're adding support for a new chain and this `match` clause just
         // gave you a compiler error, then this message is for you! You need to
@@ -707,12 +687,7 @@ impl<S: Store> IndexNodeResolver<S> {
         // type.
         match BlockchainKind::Ethereum {
             // Note: we don't actually care about substreams here.
-            BlockchainKind::Substreams
-            | BlockchainKind::Arweave
-            | BlockchainKind::Ethereum
-            | BlockchainKind::Cosmos
-            | BlockchainKind::Near
-            | BlockchainKind::Starknet => (),
+            BlockchainKind::Ethereum | BlockchainKind::Near => (),
         }
 
         // The given network does not exist.
@@ -721,7 +696,11 @@ impl<S: Store> IndexNodeResolver<S> {
 }
 
 #[async_trait]
-impl<S: Store> BlockPtrForNumber for IndexNodeResolver<S> {
+impl<S, AC> BlockPtrForNumber for IndexNodeResolver<S, AC>
+where
+    S: Store,
+    AC: amp::Client + Send + Sync + 'static,
+{
     async fn block_ptr_for_number(
         &self,
         network: String,
@@ -770,7 +749,7 @@ fn entity_changes_to_graphql(entity_changes: Vec<EntityOperation>) -> r::Value {
                         r::Value::object(
                             e.sorted()
                                 .into_iter()
-                                .map(|(name, value)| (name.into(), value.into()))
+                                .map(|(name, value)| (name, value.into()))
                                 .collect(),
                         )
                     })
@@ -794,14 +773,18 @@ fn entity_changes_to_graphql(entity_changes: Vec<EntityOperation>) -> r::Value {
 }
 
 #[async_trait]
-impl<S: Store> Resolver for IndexNodeResolver<S> {
+impl<S, AC> Resolver for IndexNodeResolver<S, AC>
+where
+    S: Store,
+    AC: amp::Client + Send + Sync + 'static,
+{
     const CACHEABLE: bool = false;
 
-    async fn query_permit(&self) -> Result<QueryPermit, QueryExecutionError> {
-        self.store.query_permit().await.map_err(Into::into)
+    async fn query_permit(&self) -> QueryPermit {
+        self.store.query_permit().await
     }
 
-    fn prefetch(
+    async fn prefetch(
         &self,
         _: &ExecutionContext<Self>,
         _: &a::SelectionSet,
@@ -846,10 +829,11 @@ impl<S: Store> Resolver for IndexNodeResolver<S> {
         // Resolves the `field.name` top-level field.
         match (prefetched_objects, object_type.name(), field.name.as_str()) {
             (None, "SubgraphIndexingStatus", "indexingStatuses") => {
-                self.resolve_indexing_statuses(field)
+                self.resolve_indexing_statuses(field).await
             }
             (None, "SubgraphIndexingStatus", "indexingStatusesForSubgraphName") => {
                 self.resolve_indexing_statuses_for_subgraph_name(field)
+                    .await
             }
             (None, "CachedEthereumCall", "cachedEthereumCalls") => {
                 self.resolve_cached_ethereum_calls(field).await
@@ -875,13 +859,13 @@ impl<S: Store> Resolver for IndexNodeResolver<S> {
         // Resolves the `field.name` top-level field.
         match (prefetched_object, field.name.as_str()) {
             (None, "indexingStatusForCurrentVersion") => {
-                self.resolve_indexing_status_for_version(field, true)
+                self.resolve_indexing_status_for_version(field, true).await
             }
             (None, "indexingStatusForPendingVersion") => {
-                self.resolve_indexing_status_for_version(field, false)
+                self.resolve_indexing_status_for_version(field, false).await
             }
             (None, "subgraphFeatures") => self.resolve_subgraph_features(field).await,
-            (None, "entityChangesInBlock") => self.resolve_entity_changes_in_block(field),
+            (None, "entityChangesInBlock") => self.resolve_entity_changes_in_block(field).await,
             // The top-level `subgraphVersions` field
             (None, "apiVersions") => self.resolve_api_versions(field),
             (None, "version") => self.version(),
diff --git a/server/index-node/src/schema.graphql b/server/index-node/src/schema.graphql
index 4d7e0677934..10475d75a0d 100644
--- a/server/index-node/src/schema.graphql
+++ b/server/index-node/src/schema.graphql
@@ -70,9 +70,16 @@ type SubgraphIndexingStatus {
   nonFatalErrors: [SubgraphError!]!
   chains: [ChainIndexingStatus!]!
   entityCount: BigInt!
+
+  "null if deployment is not assigned to an indexing node"
   node: String
-  paused: Boolean!
+  "null if deployment is not assigned to an indexing node"
+  paused: Boolean
+
   historyBlocks: Int!
+
+  "Total size of all tables a deployment's namespace in bytes."
+  subgraphSize: SubgraphSize!
 }
 
 interface ChainIndexingStatus {
@@ -157,6 +164,10 @@ enum Feature {
   grafting
   fullTextSearch
   ipfsOnEthereumContracts
+  aggregations
+  declaredEthCalls
+  immutableEntities
+  bytesAsIds
 }
 
 input BlockInput {
@@ -198,3 +209,11 @@ type ApiVersion {
   """
   version: String!
 }
+
+type SubgraphSize {
+  rowEstimate: BigInt!
+  tableSize: BigInt!
+  indexSize: BigInt!
+  toastSize: BigInt!
+  totalSize: BigInt!
+}
diff --git a/server/index-node/src/schema.rs b/server/index-node/src/schema.rs
index 90b64c82152..957d0b4dd9f 100644
--- a/server/index-node/src/schema.rs
+++ b/server/index-node/src/schema.rs
@@ -6,7 +6,7 @@ use graph::{
 lazy_static! {
     pub static ref SCHEMA: Arc<ApiSchema> = {
         let raw_schema = include_str!("./schema.graphql");
-        let document = graphql_parser::parse_schema(raw_schema).unwrap();
+        let document = s::parse_schema(raw_schema).unwrap();
         Arc::new(
             ApiSchema::from_graphql_schema(
                 Schema::new(DeploymentHash::new("indexnode").unwrap(), document).unwrap(),
diff --git a/server/index-node/src/server.rs b/server/index-node/src/server.rs
index 7222b40e9ca..e59e3407c4d 100644
--- a/server/index-node/src/server.rs
+++ b/server/index-node/src/server.rs
@@ -1,40 +1,37 @@
-use hyper::service::make_service_fn;
-use hyper::Server;
-use std::net::{Ipv4Addr, SocketAddrV4};
-
 use graph::{
+    amp,
     blockchain::BlockchainMap,
-    components::store::Store,
-    prelude::{IndexNodeServer as IndexNodeServerTrait, *},
+    cheap_clone::CheapClone,
+    components::{
+        server::server::{ServerHandle, start},
+        store::Store,
+    },
+    prelude::*,
 };
 
 use crate::service::IndexNodeService;
-use thiserror::Error;
-
-/// Errors that may occur when starting the server.
-#[derive(Debug, Error)]
-pub enum IndexNodeServeError {
-    #[error("Bind error: {0}")]
-    BindError(#[from] hyper::Error),
-}
 
 /// A GraphQL server based on Hyper.
-pub struct IndexNodeServer<Q, S> {
+pub struct IndexNodeServer<S, AC> {
     logger: Logger,
     blockchain_map: Arc<BlockchainMap>,
-    graphql_runner: Arc<Q>,
     store: Arc<S>,
     link_resolver: Arc<dyn LinkResolver>,
+    amp_client: Option<Arc<AC>>,
 }
 
-impl<Q, S> IndexNodeServer<Q, S> {
+impl<S, AC> IndexNodeServer<S, AC>
+where
+    S: Store,
+    AC: amp::Client + Send + Sync + 'static,
+{
     /// Creates a new GraphQL server.
     pub fn new(
         logger_factory: &LoggerFactory,
         blockchain_map: Arc<BlockchainMap>,
-        graphql_runner: Arc<Q>,
         store: Arc<S>,
         link_resolver: Arc<dyn LinkResolver>,
+        amp_client: Option<Arc<AC>>,
     ) -> Self {
         let logger = logger_factory.component_logger(
             "IndexNodeServer",
@@ -48,24 +45,13 @@ impl<Q, S> IndexNodeServer<Q, S> {
         IndexNodeServer {
             logger,
             blockchain_map,
-            graphql_runner,
             store,
             link_resolver,
+            amp_client,
         }
     }
-}
 
-impl<Q, S> IndexNodeServerTrait for IndexNodeServer<Q, S>
-where
-    Q: GraphQlRunner,
-    S: Store,
-{
-    type ServeError = IndexNodeServeError;
-
-    fn serve(
-        &mut self,
-        port: u16,
-    ) -> Result<Box<dyn Future<Item = (), Error = ()> + Send>, Self::ServeError> {
+    pub async fn start(&self, port: u16) -> Result<ServerHandle, anyhow::Error> {
         let logger = self.logger.clone();
 
         info!(
@@ -73,28 +59,22 @@ where
             "Starting index node server at: http://localhost:{}", port
         );
 
-        let addr = SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), port);
-
         // On every incoming request, launch a new GraphQL service that writes
         // incoming queries to the query sink.
         let logger_for_service = self.logger.clone();
-        let graphql_runner = self.graphql_runner.clone();
         let store = self.store.clone();
-        let service = IndexNodeService::new(
+        let service = Arc::new(IndexNodeService::new(
             logger_for_service.clone(),
             self.blockchain_map.clone(),
-            graphql_runner,
             store,
             self.link_resolver.clone(),
-        );
-        let new_service =
-            make_service_fn(move |_| futures03::future::ok::<_, Error>(service.clone()));
-
-        // Create a task to run the server and handle HTTP requests
-        let task = Server::try_bind(&addr.into())?
-            .serve(new_service)
-            .map_err(move |e| error!(logger, "Server error"; "error" => format!("{}", e)));
+            self.amp_client.cheap_clone(),
+        ));
 
-        Ok(Box::new(task.compat()))
+        start(logger_for_service.clone(), port, move |req| {
+            let service = service.clone();
+            async move { Ok::<_, _>(service.call(req).await) }
+        })
+        .await
     }
 }
diff --git a/server/index-node/src/service.rs b/server/index-node/src/service.rs
index df8ba82f978..23e63ebb502 100644
--- a/server/index-node/src/service.rs
+++ b/server/index-node/src/service.rs
@@ -1,19 +1,26 @@
+use std::sync::Arc;
+use std::time::Duration;
+
 use graph::blockchain::BlockchainMap;
-use http::header::{
+use graph::cheap_clone::CheapClone;
+use graph::components::graphql::GraphQLMetrics;
+use graph::components::link_resolver::LinkResolver;
+use graph::components::server::query::{ServerResponse, ServerResult};
+use graph::data::subgraph::DeploymentHash;
+use graph::http_body_util::{BodyExt, Full};
+use graph::hyper::body::{Bytes, Incoming};
+use graph::hyper::header::{
     self, ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
     CONTENT_TYPE, LOCATION,
 };
-use hyper::body::Bytes;
-use hyper::service::Service;
-use hyper::{Body, Method, Request, Response, StatusCode};
-
-use std::task::Context;
-use std::task::Poll;
+use graph::hyper::{Method, Request, Response, StatusCode, body::Body};
 
-use graph::components::{server::query::GraphQLServerError, store::Store};
-use graph::data::query::QueryResults;
-use graph::prelude::*;
-use graph_graphql::prelude::{execute_query, Query as PreparedQuery, QueryExecutionOptions};
+use graph::amp;
+use graph::components::{server::query::ServerError, store::Store};
+use graph::data::query::{Query, QueryError, QueryResult, QueryResults};
+use graph::prelude::{q, serde_json};
+use graph::slog::{Logger, debug, error};
+use graph_graphql::prelude::{Query as PreparedQuery, QueryExecutionOptions, execute_query};
 
 use crate::auth::bearer_token;
 
@@ -31,57 +38,38 @@ impl GraphQLMetrics for NoopGraphQLMetrics {
     fn observe_query_blocks_behind(&self, _blocks_behind: i32, _id: &DeploymentHash) {}
 }
 
-/// An asynchronous response to a GraphQL request.
-pub type IndexNodeServiceResponse = DynTryFuture<'static, Response<Body>, GraphQLServerError>;
-
 /// A Hyper Service that serves GraphQL over a POST / endpoint.
 #[derive(Debug)]
-pub struct IndexNodeService<Q, S> {
+pub struct IndexNodeService<S, AC> {
     logger: Logger,
     blockchain_map: Arc<BlockchainMap>,
-    graphql_runner: Arc<Q>,
     store: Arc<S>,
     explorer: Arc<Explorer<S>>,
     link_resolver: Arc<dyn LinkResolver>,
+    amp_client: Option<Arc<AC>>,
 }
 
-impl<Q, S> Clone for IndexNodeService<Q, S> {
-    fn clone(&self) -> Self {
-        Self {
-            logger: self.logger.clone(),
-            blockchain_map: self.blockchain_map.clone(),
-            graphql_runner: self.graphql_runner.clone(),
-            store: self.store.clone(),
-            explorer: self.explorer.clone(),
-            link_resolver: self.link_resolver.clone(),
-        }
-    }
-}
-
-impl<Q, S> CheapClone for IndexNodeService<Q, S> {}
-
-impl<Q, S> IndexNodeService<Q, S>
+impl<S, AC> IndexNodeService<S, AC>
 where
-    Q: GraphQlRunner,
     S: Store,
+    AC: amp::Client + Send + Sync + 'static,
 {
-    /// Creates a new GraphQL service.
     pub fn new(
         logger: Logger,
         blockchain_map: Arc<BlockchainMap>,
-        graphql_runner: Arc<Q>,
         store: Arc<S>,
         link_resolver: Arc<dyn LinkResolver>,
+        amp_client: Option<Arc<AC>>,
     ) -> Self {
         let explorer = Arc::new(Explorer::new(store.clone()));
 
         IndexNodeService {
             logger,
             blockchain_map,
-            graphql_runner,
             store,
             explorer,
             link_resolver,
+            amp_client,
         }
     }
 
@@ -90,45 +78,50 @@ where
     }
 
     /// Serves a static file.
-    fn serve_file(contents: &'static str, content_type: &'static str) -> Response<Body> {
+    fn serve_file(contents: &'static str, content_type: &'static str) -> ServerResponse {
         Response::builder()
             .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
             .header(CONTENT_TYPE, content_type)
             .status(200)
-            .body(Body::from(contents))
+            .body(Full::from(contents))
             .unwrap()
     }
 
-    fn index() -> Response<Body> {
+    fn index() -> ServerResponse {
         Response::builder()
             .status(200)
             .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
             .header(CONTENT_TYPE, "text/html")
-            .body(Body::from("OK"))
+            .body(Full::from("OK"))
             .unwrap()
     }
 
-    fn handle_graphiql() -> Response<Body> {
+    fn handle_graphiql() -> ServerResponse {
         Self::serve_file(Self::graphiql_html(), "text/html")
     }
 
-    pub async fn handle_graphql_query(
+    pub async fn handle_graphql_query<T: Body>(
         &self,
-        request: Request<Body>,
-    ) -> Result<QueryResults, GraphQLServerError> {
-        let (req_parts, req_body) = request.into_parts();
+        request: Request<T>,
+    ) -> Result<QueryResults, ServerError> {
         let store = self.store.clone();
 
-        // Obtain the schema for the index node GraphQL API
-        let schema = SCHEMA.clone();
+        let bearer_token = bearer_token(request.headers())
+            .map(<[u8]>::to_vec)
+            .map(String::from_utf8)
+            .transpose()
+            .map_err(|_| ServerError::ClientError("Bearer token is invalid UTF-8".to_string()))?;
 
-        let body = hyper::body::to_bytes(req_body)
-            .map_err(|_| GraphQLServerError::InternalError("Failed to read request body".into()))
-            .await?;
+        let body = request
+            .collect()
+            .await
+            .map_err(|_| ServerError::InternalError("Failed to read request body".into()))?
+            .to_bytes();
 
-        let validated = ValidatedRequest::new(body, &req_parts.headers)?;
+        let validated = ValidatedRequest::new(body, bearer_token)?;
         let query = validated.query;
 
+        let schema = SCHEMA.clone();
         let query = match PreparedQuery::new(
             &self.logger,
             schema,
@@ -150,17 +143,19 @@ where
                 &logger,
                 store,
                 self.link_resolver.clone(),
+                self.amp_client.cheap_clone(),
                 validated.bearer_token,
                 self.blockchain_map.clone(),
             );
             let options = QueryExecutionOptions {
                 resolver,
                 deadline: None,
-                max_first: std::u32::MAX,
-                max_skip: std::u32::MAX,
+                max_first: u32::MAX,
+                max_skip: u32::MAX,
                 trace: false,
+                log_store: Arc::new(graph::components::log_store::NoOpLogStore),
             };
-            let result = execute_query(query_clone.cheap_clone(), None, None, options).await;
+            let (result, _) = execute_query(query_clone.cheap_clone(), None, None, options).await;
             query_clone.log_execution(0);
             // Index status queries are not cacheable, so we may unwrap this.
             Arc::try_unwrap(result).unwrap()
@@ -170,45 +165,43 @@ where
     }
 
     // Handles OPTIONS requests
-    fn handle_graphql_options(_request: Request<Body>) -> Response<Body> {
+    fn handle_graphql_options<T>(_request: Request<T>) -> ServerResponse {
         Response::builder()
             .status(200)
             .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
             .header(CONTENT_TYPE, "text/plain")
             .header(ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type, User-Agent")
             .header(ACCESS_CONTROL_ALLOW_METHODS, "GET, OPTIONS, POST")
-            .body(Body::from(""))
+            .body(Full::from(""))
             .unwrap()
     }
 
     /// Handles 302 redirects
-    fn handle_temp_redirect(destination: &str) -> Result<Response<Body>, GraphQLServerError> {
+    fn handle_temp_redirect(destination: &str) -> ServerResult {
         header::HeaderValue::from_str(destination)
-            .map_err(|_| {
-                GraphQLServerError::ClientError("invalid characters in redirect URL".into())
-            })
+            .map_err(|_| ServerError::ClientError("invalid characters in redirect URL".into()))
             .map(|loc_header_val| {
                 Response::builder()
                     .status(StatusCode::FOUND)
                     .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
                     .header(CONTENT_TYPE, "text/plain")
                     .header(LOCATION, loc_header_val)
-                    .body(Body::from("Redirecting..."))
+                    .body(Full::from("Redirecting..."))
                     .unwrap()
             })
     }
 
     /// Handles 404s.
-    pub(crate) fn handle_not_found() -> Response<Body> {
+    pub(crate) fn handle_not_found() -> ServerResponse {
         Response::builder()
             .status(StatusCode::NOT_FOUND)
             .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
             .header(CONTENT_TYPE, "text/plain")
-            .body(Body::from("Not found\n"))
+            .body(Full::from("Not found\n"))
             .unwrap()
     }
 
-    async fn handle_call(self, req: Request<Body>) -> Result<Response<Body>, GraphQLServerError> {
+    async fn handle_call<T: Body>(&self, req: Request<T>) -> ServerResult {
         let method = req.method().clone();
 
         let path = req.uri().path().to_owned();
@@ -243,68 +236,53 @@ where
             }
             (Method::OPTIONS, ["graphql"]) => Ok(Self::handle_graphql_options(req)),
 
-            (Method::GET, ["explorer", rest @ ..]) => self.explorer.handle(&self.logger, rest),
+            (Method::GET, ["explorer", rest @ ..]) => {
+                self.explorer.handle(&self.logger, rest).await
+            }
 
             _ => Ok(Self::handle_not_found()),
         }
     }
-}
-
-impl<Q, S> Service<Request<Body>> for IndexNodeService<Q, S>
-where
-    Q: GraphQlRunner,
-    S: Store,
-{
-    type Response = Response<Body>;
-    type Error = GraphQLServerError;
-    type Future = IndexNodeServiceResponse;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
 
-    fn call(&mut self, req: Request<Body>) -> Self::Future {
+    pub async fn call(&self, req: Request<Incoming>) -> ServerResponse {
         let logger = self.logger.clone();
 
         // Returning Err here will prevent the client from receiving any response.
         // Instead, we generate a Response with an error code and return Ok
-        Box::pin(
-            self.cheap_clone()
-                .handle_call(req)
-                .map(move |result| match result {
-                    Ok(response) => Ok(response),
-                    Err(err @ GraphQLServerError::ClientError(_)) => {
-                        debug!(logger, "IndexNodeService call failed: {}", err);
-
-                        Ok(Response::builder()
-                            .status(400)
-                            .header(CONTENT_TYPE, "text/plain")
-                            .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                            .body(Body::from(format!("Invalid request: {}", err)))
-                            .unwrap())
-                    }
-                    Err(err @ GraphQLServerError::QueryError(_)) => {
-                        error!(logger, "IndexNodeService call failed: {}", err);
-
-                        Ok(Response::builder()
-                            .status(400)
-                            .header(CONTENT_TYPE, "text/plain")
-                            .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                            .body(Body::from(format!("Query error: {}", err)))
-                            .unwrap())
-                    }
-                    Err(err @ GraphQLServerError::InternalError(_)) => {
-                        error!(logger, "IndexNodeService call failed: {}", err);
-
-                        Ok(Response::builder()
-                            .status(500)
-                            .header(CONTENT_TYPE, "text/plain")
-                            .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                            .body(Body::from(format!("Internal server error: {}", err)))
-                            .unwrap())
-                    }
-                }),
-        )
+        let result = self.handle_call(req).await;
+        match result {
+            Ok(response) => response,
+            Err(err @ ServerError::ClientError(_)) => {
+                debug!(logger, "IndexNodeService call failed: {}", err);
+
+                Response::builder()
+                    .status(400)
+                    .header(CONTENT_TYPE, "text/plain")
+                    .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+                    .body(Full::from(format!("Invalid request: {}", err)))
+                    .unwrap()
+            }
+            Err(err @ ServerError::QueryError(_)) => {
+                error!(logger, "IndexNodeService call failed: {}", err);
+
+                Response::builder()
+                    .status(400)
+                    .header(CONTENT_TYPE, "text/plain")
+                    .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+                    .body(Full::from(format!("Query error: {}", err)))
+                    .unwrap()
+            }
+            Err(err @ ServerError::InternalError(_)) => {
+                error!(logger, "IndexNodeService call failed: {}", err);
+
+                Response::builder()
+                    .status(500)
+                    .header(CONTENT_TYPE, "text/plain")
+                    .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+                    .body(Full::from(format!("Internal server error: {}", err)))
+                    .unwrap()
+            }
+        }
     }
 }
 
@@ -314,31 +292,31 @@ struct ValidatedRequest {
 }
 
 impl ValidatedRequest {
-    pub fn new(req_body: Bytes, headers: &hyper::HeaderMap) -> Result<Self, GraphQLServerError> {
+    pub fn new(req_body: Bytes, bearer_token: Option<String>) -> Result<Self, ServerError> {
         // Parse request body as JSON
         let json: serde_json::Value = serde_json::from_slice(&req_body)
-            .map_err(|e| GraphQLServerError::ClientError(format!("{}", e)))?;
+            .map_err(|e| ServerError::ClientError(format!("{}", e)))?;
 
         // Ensure the JSON data is an object
         let obj = json.as_object().ok_or_else(|| {
-            GraphQLServerError::ClientError(String::from("ValidatedRequest data is not an object"))
+            ServerError::ClientError(String::from("ValidatedRequest data is not an object"))
         })?;
 
         // Ensure the JSON data has a "query" field
         let query_value = obj.get("query").ok_or_else(|| {
-            GraphQLServerError::ClientError(String::from(
+            ServerError::ClientError(String::from(
                 "The \"query\" field is missing in request data",
             ))
         })?;
 
         // Ensure the "query" field is a string
         let query_string = query_value.as_str().ok_or_else(|| {
-            GraphQLServerError::ClientError(String::from("The\"query\" field is not a string"))
+            ServerError::ClientError(String::from("The\"query\" field is not a string"))
         })?;
 
         // Parse the "query" field of the JSON body
-        let document = graphql_parser::parse_query(query_string)
-            .map_err(|e| GraphQLServerError::from(QueryError::ParseError(Arc::new(e.into()))))?
+        let document = q::parse_query(query_string)
+            .map_err(|e| ServerError::from(QueryError::ParseError(Arc::new(e.into()))))?
             .into_static();
 
         // Parse the "variables" field of the JSON body, if present
@@ -346,22 +324,15 @@ impl ValidatedRequest {
             None | Some(serde_json::Value::Null) => Ok(None),
             Some(variables @ serde_json::Value::Object(_)) => {
                 serde_json::from_value(variables.clone())
-                    .map_err(|e| GraphQLServerError::ClientError(e.to_string()))
+                    .map_err(|e| ServerError::ClientError(e.to_string()))
                     .map(Some)
             }
-            _ => Err(GraphQLServerError::ClientError(
+            _ => Err(ServerError::ClientError(
                 "Invalid query variables provided".to_string(),
             )),
         }?;
 
         let query = Query::new(document, variables, false);
-        let bearer_token = bearer_token(headers)
-            .map(<[u8]>::to_vec)
-            .map(String::from_utf8)
-            .transpose()
-            .map_err(|_| {
-                GraphQLServerError::ClientError("Bearer token is invalid UTF-8".to_string())
-            })?;
 
         Ok(Self {
             query,
@@ -377,14 +348,13 @@ mod tests {
         prelude::*,
     };
 
-    use hyper::body::Bytes;
-    use hyper::HeaderMap;
+    use graph::hyper::body::Bytes;
     use std::collections::HashMap;
 
-    use super::{GraphQLServerError, ValidatedRequest};
+    use super::{ServerError, ValidatedRequest};
 
-    fn validate_req(req_body: Bytes) -> Result<Query, GraphQLServerError> {
-        Ok(ValidatedRequest::new(req_body, &HeaderMap::new())?.query)
+    fn validate_req(req_body: Bytes) -> Result<Query, ServerError> {
+        Ok(ValidatedRequest::new(req_body, None)?.query)
     }
 
     #[test]
@@ -417,9 +387,7 @@ mod tests {
         let query = request.expect("Should accept valid queries");
         assert_eq!(
             query.document,
-            graphql_parser::parse_query("{ user { name } }")
-                .unwrap()
-                .into_static()
+            q::parse_query("{ user { name } }").unwrap().into_static()
         );
     }
 
@@ -434,9 +402,7 @@ mod tests {
         ));
         let query = request.expect("Should accept null variables");
 
-        let expected_query = graphql_parser::parse_query("{ user { name } }")
-            .unwrap()
-            .into_static();
+        let expected_query = q::parse_query("{ user { name } }").unwrap().into_static();
         assert_eq!(query.document, expected_query);
         assert_eq!(query.variables, None);
     }
@@ -466,22 +432,17 @@ mod tests {
         ));
         let query = request.expect("Should accept valid queries");
 
-        let expected_query = graphql_parser::parse_query("{ user { name } }")
-            .unwrap()
-            .into_static();
-        let expected_variables = QueryVariables::new(HashMap::from_iter(
-            vec![
-                (String::from("string"), r::Value::String(String::from("s"))),
-                (
-                    String::from("map"),
-                    r::Value::Object(Object::from_iter(
-                        vec![(Word::from("k"), r::Value::String(String::from("v")))].into_iter(),
-                    )),
-                ),
-                (String::from("int"), r::Value::Int(5)),
-            ]
-            .into_iter(),
-        ));
+        let expected_query = q::parse_query("{ user { name } }").unwrap().into_static();
+        let expected_variables = QueryVariables::new(HashMap::from_iter(vec![
+            (String::from("string"), r::Value::String(String::from("s"))),
+            (
+                String::from("map"),
+                r::Value::Object(Object::from_iter(
+                    vec![(Word::from("k"), r::Value::String(String::from("v")))].into_iter(),
+                )),
+            ),
+            (String::from("int"), r::Value::Int(5)),
+        ]));
 
         assert_eq!(query.document, expected_query);
         assert_eq!(query.variables, Some(expected_variables));
diff --git a/server/json-rpc/Cargo.toml b/server/json-rpc/Cargo.toml
index 6434dce33ac..65af5d0a280 100644
--- a/server/json-rpc/Cargo.toml
+++ b/server/json-rpc/Cargo.toml
@@ -4,6 +4,10 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
+axum = { workspace = true }
 graph = { path = "../../graph" }
-jsonrpsee = { version = "0.15.1", features = ["http-server"] }
-serde = "1.0"
+serde = { workspace = true }
+serde_json = { workspace = true }
+slog = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
diff --git a/server/json-rpc/src/handlers.rs b/server/json-rpc/src/handlers.rs
new file mode 100644
index 00000000000..442347cfdb5
--- /dev/null
+++ b/server/json-rpc/src/handlers.rs
@@ -0,0 +1,422 @@
+//! JSON-RPC request handlers for subgraph operations.
+//!
+//! This module implements the request dispatch and individual handlers
+//! for each JSON-RPC method.
+
+use std::collections::BTreeMap;
+use std::fmt::Debug;
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use axum::Json;
+use axum::extract::{ConnectInfo, State};
+use axum::http::{HeaderMap, StatusCode};
+use axum::response::IntoResponse;
+use graph::prelude::{
+    DeploymentHash, ENV_VARS, NodeId, SubgraphName, SubgraphRegistrar, SubgraphRegistrarError,
+};
+use serde::Deserialize;
+use serde_json::{self, Value as JsonValue};
+use slog::{Logger, error, info};
+
+use crate::jsonrpc::{JsonRpcError, JsonRpcId, JsonRpcRequest, JsonRpcResponse};
+
+/// Application-specific error codes for subgraph operations.
+mod error_codes {
+    pub const DEPLOY_ERROR: i64 = 0;
+    pub const REMOVE_ERROR: i64 = 1;
+    pub const CREATE_ERROR: i64 = 2;
+    pub const REASSIGN_ERROR: i64 = 3;
+    pub const PAUSE_ERROR: i64 = 4;
+    pub const RESUME_ERROR: i64 = 5;
+}
+
+/// Shared application state for the JSON-RPC server.
+pub struct AppState<R> {
+    pub registrar: Arc<R>,
+    pub http_port: u16,
+    pub node_id: NodeId,
+    pub logger: Logger,
+}
+
+/// Dispatch a single JSON-RPC request to the appropriate method handler.
+///
+/// Returns `None` for notifications (requests without an id), since the
+/// JSON-RPC 2.0 spec says notifications must not produce a response.
+async fn dispatch_request<R: SubgraphRegistrar>(
+    state: &Arc<AppState<R>>,
+    request: JsonRpcRequest,
+) -> Option<JsonRpcResponse> {
+    if !request.is_valid_version() {
+        return Some(JsonRpcResponse::invalid_request());
+    }
+
+    let id = request.id.clone().unwrap_or(JsonRpcId::Null);
+
+    // Notifications (no id) should not produce a response per JSON-RPC 2.0 spec.
+    // But since all our methods have side effects, we still execute them;
+    // we just don't return the response.
+    let is_notification = request.id.is_none();
+
+    let response = match request.method.as_str() {
+        "subgraph_create" => handle_create(state, &request, id).await,
+        "subgraph_deploy" => handle_deploy(state, &request, id).await,
+        "subgraph_remove" => handle_remove(state, &request, id).await,
+        "subgraph_reassign" => handle_reassign(state, &request, id).await,
+        "subgraph_pause" => handle_pause(state, &request, id).await,
+        "subgraph_resume" => handle_resume(state, &request, id).await,
+        _ => JsonRpcResponse::error(id, JsonRpcError::method_not_found()),
+    };
+
+    if is_notification {
+        None
+    } else {
+        Some(response)
+    }
+}
+
+/// Main JSON-RPC request handler.
+///
+/// Supports both single requests and batch requests (JSON arrays).
+/// Per JSON-RPC 2.0 spec, an empty batch array returns an invalid request error.
+pub async fn jsonrpc_handler<R: SubgraphRegistrar>(
+    State(state): State<Arc<AppState<R>>>,
+    ConnectInfo(remote_addr): ConnectInfo<SocketAddr>,
+    headers: HeaderMap,
+    body: String,
+) -> impl IntoResponse {
+    fn header<'a>(headers: &'a HeaderMap, key: &str) -> &'a str {
+        headers
+            .get(key)
+            .and_then(|v| v.to_str().ok())
+            .unwrap_or("unset")
+    }
+
+    let log_request = |method: &str, params: &Option<JsonValue>| {
+        info!(
+            &state.logger,
+            "JSON-RPC call";
+            "method" => method,
+            "params" => ?params,
+            "remote_addr" => %remote_addr,
+            "x_forwarded_for" => header(&headers, "x-forwarded-for"),
+            "x_real_ip" => header(&headers, "x-real-ip"),
+            "x_forwarded_proto" => header(&headers, "x-forwarded-proto")
+        );
+    };
+
+    // Try batch (JSON array) first, then single request.
+    if let Ok(requests) = serde_json::from_str::<Vec<JsonRpcRequest>>(&body) {
+        if requests.is_empty() {
+            let resp = serde_json::to_value(JsonRpcResponse::invalid_request())
+                .expect("failed to serialize response");
+            return (StatusCode::OK, Json(resp));
+        }
+
+        info!(
+            &state.logger,
+            "JSON-RPC batch request";
+            "batch_size" => requests.len(),
+            "remote_addr" => %remote_addr,
+        );
+
+        let mut responses = Vec::new();
+        for request in requests {
+            log_request(&request.method, &request.params);
+            if let Some(resp) = dispatch_request(&state, request).await {
+                responses.push(resp);
+            }
+        }
+
+        let value = serde_json::to_value(responses).expect("failed to serialize responses");
+        return (StatusCode::OK, Json(value));
+    }
+
+    // Single request
+    let request: JsonRpcRequest = match serde_json::from_str(&body) {
+        Ok(req) => req,
+        Err(_) => {
+            let resp = serde_json::to_value(JsonRpcResponse::parse_error())
+                .expect("failed to serialize response");
+            return (StatusCode::OK, Json(resp));
+        }
+    };
+
+    log_request(&request.method, &request.params);
+
+    let response = dispatch_request(&state, request)
+        .await
+        .unwrap_or_else(|| JsonRpcResponse::success(JsonRpcId::Null, JsonValue::Null));
+
+    let value = serde_json::to_value(response).expect("failed to serialize response");
+    (StatusCode::OK, Json(value))
+}
+
+/// Parse parameters from a JSON-RPC request.
+#[allow(clippy::result_large_err)]
+fn parse_params<T: for<'de> Deserialize<'de>>(
+    request: &JsonRpcRequest,
+    id: JsonRpcId,
+) -> Result<T, JsonRpcResponse> {
+    let params = request.params.clone().unwrap_or(JsonValue::Null);
+    serde_json::from_value(params).map_err(|e| {
+        JsonRpcResponse::error(
+            id,
+            JsonRpcError::invalid_params(format!("Invalid params: {}", e)),
+        )
+    })
+}
+
+/// Convert a registrar result to a JSON-RPC response.
+fn to_response<P: Debug>(
+    logger: &Logger,
+    method: &str,
+    error_code: i64,
+    params: &P,
+    result: Result<JsonValue, SubgraphRegistrarError>,
+    id: JsonRpcId,
+) -> JsonRpcResponse {
+    match result {
+        Ok(value) => JsonRpcResponse::success(id, value),
+        Err(e) => {
+            error!(logger, "{} failed", method;
+                "error" => format!("{:?}", e),
+                "params" => format!("{:?}", params));
+
+            let message = if let SubgraphRegistrarError::Unknown(_) = e {
+                "internal error".to_owned()
+            } else {
+                e.to_string()
+            };
+
+            JsonRpcResponse::error(id, JsonRpcError::new(error_code, message))
+        }
+    }
+}
+
+/// Handler for `subgraph_create`.
+async fn handle_create<R: SubgraphRegistrar>(
+    state: &AppState<R>,
+    request: &JsonRpcRequest,
+    id: JsonRpcId,
+) -> JsonRpcResponse {
+    #[derive(Debug, Deserialize)]
+    pub struct SubgraphCreateParams {
+        pub name: SubgraphName,
+    }
+
+    let params: SubgraphCreateParams = match parse_params(request, id.clone()) {
+        Ok(p) => p,
+        Err(resp) => return resp,
+    };
+
+    let result = state
+        .registrar
+        .create_subgraph(params.name.clone())
+        .await
+        .map(|r| serde_json::to_value(r).expect("invalid result"));
+
+    to_response(
+        &state.logger,
+        "subgraph_create",
+        error_codes::CREATE_ERROR,
+        &params,
+        result,
+        id,
+    )
+}
+
+/// Handler for `subgraph_deploy`.
+async fn handle_deploy<R: SubgraphRegistrar>(
+    state: &AppState<R>,
+    request: &JsonRpcRequest,
+    id: JsonRpcId,
+) -> JsonRpcResponse {
+    #[derive(Debug, Deserialize)]
+    pub struct SubgraphDeployParams {
+        pub name: SubgraphName,
+        pub ipfs_hash: DeploymentHash,
+        pub node_id: Option<NodeId>,
+        pub debug_fork: Option<DeploymentHash>,
+        pub history_blocks: Option<i32>,
+    }
+
+    let params: SubgraphDeployParams = match parse_params(request, id.clone()) {
+        Ok(p) => p,
+        Err(resp) => return resp,
+    };
+
+    let node_id = params.node_id.clone().unwrap_or(state.node_id.clone());
+
+    let result = state
+        .registrar
+        .create_subgraph_version(
+            params.name.clone(),
+            params.ipfs_hash.clone(),
+            node_id,
+            params.debug_fork.clone(),
+            // Here it doesn't make sense to receive another
+            // startBlock, we'll use the one from the manifest.
+            None,
+            None,
+            params.history_blocks,
+            false,
+        )
+        .await
+        .map(|_| subgraph_routes(&params.name, state.http_port));
+
+    to_response(
+        &state.logger,
+        "subgraph_deploy",
+        error_codes::DEPLOY_ERROR,
+        &params,
+        result,
+        id,
+    )
+}
+
+/// Handler for `subgraph_remove`.
+async fn handle_remove<R: SubgraphRegistrar>(
+    state: &AppState<R>,
+    request: &JsonRpcRequest,
+    id: JsonRpcId,
+) -> JsonRpcResponse {
+    #[derive(Debug, Deserialize)]
+    pub struct SubgraphRemoveParams {
+        pub name: SubgraphName,
+    }
+
+    let params: SubgraphRemoveParams = match parse_params(request, id.clone()) {
+        Ok(p) => p,
+        Err(resp) => return resp,
+    };
+
+    let result = state
+        .registrar
+        .remove_subgraph(params.name.clone())
+        .await
+        .map(|_| JsonValue::Null);
+
+    to_response(
+        &state.logger,
+        "subgraph_remove",
+        error_codes::REMOVE_ERROR,
+        &params,
+        result,
+        id,
+    )
+}
+
+/// Handler for `subgraph_reassign`.
+async fn handle_reassign<R: SubgraphRegistrar>(
+    state: &AppState<R>,
+    request: &JsonRpcRequest,
+    id: JsonRpcId,
+) -> JsonRpcResponse {
+    #[derive(Debug, Deserialize)]
+    pub struct SubgraphReassignParams {
+        pub ipfs_hash: DeploymentHash,
+        pub node_id: NodeId,
+    }
+
+    let params: SubgraphReassignParams = match parse_params(request, id.clone()) {
+        Ok(p) => p,
+        Err(resp) => return resp,
+    };
+
+    let result = state
+        .registrar
+        .reassign_subgraph(&params.ipfs_hash, &params.node_id)
+        .await
+        .map(|_| JsonValue::Null);
+
+    to_response(
+        &state.logger,
+        "subgraph_reassign",
+        error_codes::REASSIGN_ERROR,
+        &params,
+        result,
+        id,
+    )
+}
+
+// Parameter structs for pause and resume
+
+#[derive(Debug, Deserialize)]
+pub struct SubgraphPauseParams {
+    pub deployment: DeploymentHash,
+}
+
+/// Handler for `subgraph_pause`.
+async fn handle_pause<R: SubgraphRegistrar>(
+    state: &AppState<R>,
+    request: &JsonRpcRequest,
+    id: JsonRpcId,
+) -> JsonRpcResponse {
+    let params: SubgraphPauseParams = match parse_params(request, id.clone()) {
+        Ok(p) => p,
+        Err(resp) => return resp,
+    };
+
+    let result = state
+        .registrar
+        .pause_subgraph(&params.deployment)
+        .await
+        .map(|_| JsonValue::Null);
+
+    to_response(
+        &state.logger,
+        "subgraph_pause",
+        error_codes::PAUSE_ERROR,
+        &params,
+        result,
+        id,
+    )
+}
+
+/// Handler for `subgraph_resume`.
+async fn handle_resume<R: SubgraphRegistrar>(
+    state: &AppState<R>,
+    request: &JsonRpcRequest,
+    id: JsonRpcId,
+) -> JsonRpcResponse {
+    let params: SubgraphPauseParams = match parse_params(request, id.clone()) {
+        Ok(p) => p,
+        Err(resp) => return resp,
+    };
+
+    let result = state
+        .registrar
+        .resume_subgraph(&params.deployment)
+        .await
+        .map(|_| JsonValue::Null);
+
+    to_response(
+        &state.logger,
+        "subgraph_resume",
+        error_codes::RESUME_ERROR,
+        &params,
+        result,
+        id,
+    )
+}
+
+/// Build the subgraph routes response for deploy.
+fn subgraph_routes(name: &SubgraphName, http_port: u16) -> JsonValue {
+    let http_base_url = ENV_VARS
+        .external_http_base_url
+        .clone()
+        .unwrap_or_else(|| format!(":{}", http_port));
+
+    let mut map = BTreeMap::new();
+    map.insert(
+        "playground",
+        format!("{}/subgraphs/name/{}/graphql", http_base_url, name),
+    );
+    map.insert(
+        "queries",
+        format!("{}/subgraphs/name/{}", http_base_url, name),
+    );
+
+    serde_json::to_value(map).expect("invalid subgraph routes")
+}
diff --git a/server/json-rpc/src/jsonrpc.rs b/server/json-rpc/src/jsonrpc.rs
new file mode 100644
index 00000000000..e8a3da155a2
--- /dev/null
+++ b/server/json-rpc/src/jsonrpc.rs
@@ -0,0 +1,253 @@
+//! JSON-RPC 2.0 types for the admin server.
+//!
+//! This module implements the JSON-RPC 2.0 protocol types according to the specification:
+//! https://www.jsonrpc.org/specification
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value as JsonValue;
+
+/// JSON-RPC 2.0 request ID.
+///
+/// The ID can be a string, number, or null (for notifications).
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum JsonRpcId {
+    String(String),
+    Number(i64),
+    #[default]
+    Null,
+}
+
+/// JSON-RPC 2.0 request object.
+#[derive(Debug, Clone, Deserialize)]
+pub struct JsonRpcRequest {
+    /// JSON-RPC version. Must be "2.0".
+    pub jsonrpc: String,
+
+    /// Method name to invoke.
+    pub method: String,
+
+    /// Method parameters (optional).
+    #[serde(default)]
+    pub params: Option<JsonValue>,
+
+    /// Request ID (optional for notifications).
+    #[serde(default)]
+    pub id: Option<JsonRpcId>,
+}
+
+impl JsonRpcRequest {
+    /// Returns true if this request has a valid JSON-RPC version.
+    pub fn is_valid_version(&self) -> bool {
+        self.jsonrpc == "2.0"
+    }
+}
+
+/// JSON-RPC 2.0 error object.
+#[derive(Debug, Clone, Serialize)]
+pub struct JsonRpcError {
+    /// Error code.
+    pub code: i64,
+
+    /// Human-readable error message.
+    pub message: String,
+
+    /// Additional error data (optional).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<JsonValue>,
+}
+
+impl JsonRpcError {
+    /// Create a new error with the given code and message.
+    pub fn new(code: i64, message: impl Into<String>) -> Self {
+        Self {
+            code,
+            message: message.into(),
+            data: None,
+        }
+    }
+
+    /// Parse error (-32700): Invalid JSON was received.
+    pub fn parse_error() -> Self {
+        Self::new(-32700, "Parse error")
+    }
+
+    /// Invalid request (-32600): The JSON sent is not a valid Request object.
+    pub fn invalid_request() -> Self {
+        Self::new(-32600, "Invalid Request")
+    }
+
+    /// Method not found (-32601): The method does not exist / is not available.
+    pub fn method_not_found() -> Self {
+        Self::new(-32601, "Method not found")
+    }
+
+    /// Invalid params (-32602): Invalid method parameter(s).
+    pub fn invalid_params(message: impl Into<String>) -> Self {
+        Self::new(-32602, message)
+    }
+}
+
+/// JSON-RPC 2.0 response object.
+#[derive(Debug, Clone, Serialize)]
+pub struct JsonRpcResponse {
+    /// JSON-RPC version. Always "2.0".
+    pub jsonrpc: &'static str,
+
+    /// Result on success (mutually exclusive with error).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub result: Option<JsonValue>,
+
+    /// Error on failure (mutually exclusive with result).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<JsonRpcError>,
+
+    /// Request ID (same as the request, or null for notifications).
+    pub id: JsonRpcId,
+}
+
+impl JsonRpcResponse {
+    /// Create a successful response.
+    pub fn success(id: JsonRpcId, result: JsonValue) -> Self {
+        Self {
+            jsonrpc: "2.0",
+            result: Some(result),
+            error: None,
+            id,
+        }
+    }
+
+    /// Create an error response.
+    pub fn error(id: JsonRpcId, error: JsonRpcError) -> Self {
+        Self {
+            jsonrpc: "2.0",
+            result: None,
+            error: Some(error),
+            id,
+        }
+    }
+
+    /// Create an error response for a parse error (when we don't have an ID).
+    pub fn parse_error() -> Self {
+        Self::error(JsonRpcId::Null, JsonRpcError::parse_error())
+    }
+
+    /// Create an error response for an invalid request (when we don't have an ID).
+    pub fn invalid_request() -> Self {
+        Self::error(JsonRpcId::Null, JsonRpcError::invalid_request())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deserialize_request_with_string_id() {
+        let json = r#"{"jsonrpc":"2.0","method":"test","id":"abc"}"#;
+        let req: JsonRpcRequest = serde_json::from_str(json).unwrap();
+        assert_eq!(req.id, Some(JsonRpcId::String("abc".to_string())));
+    }
+
+    #[test]
+    fn deserialize_request_with_number_id() {
+        let json = r#"{"jsonrpc":"2.0","method":"test","id":123}"#;
+        let req: JsonRpcRequest = serde_json::from_str(json).unwrap();
+        assert_eq!(req.id, Some(JsonRpcId::Number(123)));
+    }
+
+    #[test]
+    fn deserialize_request_with_null_id() {
+        // When id is explicitly null, serde treats it as None due to Option<JsonRpcId>
+        // This is acceptable per JSON-RPC 2.0 spec as null id means notification
+        let json = r#"{"jsonrpc":"2.0","method":"test","id":null}"#;
+        let req: JsonRpcRequest = serde_json::from_str(json).unwrap();
+        assert_eq!(req.id, None);
+    }
+
+    #[test]
+    fn deserialize_request_without_id() {
+        let json = r#"{"jsonrpc":"2.0","method":"test"}"#;
+        let req: JsonRpcRequest = serde_json::from_str(json).unwrap();
+        assert_eq!(req.id, None);
+    }
+
+    #[test]
+    fn serialize_success_response() {
+        let resp = JsonRpcResponse::success(JsonRpcId::Number(1), serde_json::json!({"ok": true}));
+        let json = serde_json::to_string(&resp).unwrap();
+        assert!(json.contains(r#""jsonrpc":"2.0""#));
+        assert!(json.contains(r#""result":{"ok":true}"#));
+        assert!(json.contains(r#""id":1"#));
+        assert!(!json.contains("error"));
+    }
+
+    #[test]
+    fn serialize_error_response() {
+        let resp = JsonRpcResponse::error(
+            JsonRpcId::String("req-1".to_string()),
+            JsonRpcError::new(-32601, "Method not found"),
+        );
+        let json = serde_json::to_string(&resp).unwrap();
+        assert!(json.contains(r#""jsonrpc":"2.0""#));
+        assert!(json.contains(r#""error""#));
+        assert!(json.contains(r#""code":-32601"#));
+        assert!(json.contains(r#""id":"req-1""#));
+        assert!(!json.contains("result"));
+    }
+
+    #[test]
+    fn deserialize_batch_request() {
+        let json = r#"[
+            {"jsonrpc":"2.0","method":"subgraph_create","id":1},
+            {"jsonrpc":"2.0","method":"subgraph_remove","id":2}
+        ]"#;
+        let requests: Vec<JsonRpcRequest> = serde_json::from_str(json).unwrap();
+        assert_eq!(requests.len(), 2);
+        assert_eq!(requests[0].method, "subgraph_create");
+        assert_eq!(requests[0].id, Some(JsonRpcId::Number(1)));
+        assert_eq!(requests[1].method, "subgraph_remove");
+        assert_eq!(requests[1].id, Some(JsonRpcId::Number(2)));
+    }
+
+    #[test]
+    fn serialize_batch_response() {
+        let responses = vec![
+            JsonRpcResponse::success(JsonRpcId::Number(1), serde_json::json!({"ok": true})),
+            JsonRpcResponse::error(
+                JsonRpcId::Number(2),
+                JsonRpcError::new(-32601, "Method not found"),
+            ),
+        ];
+        let json = serde_json::to_string(&responses).unwrap();
+        // Must be a JSON array
+        assert!(json.starts_with('['));
+        assert!(json.ends_with(']'));
+        // Both responses present
+        let parsed: Vec<serde_json::Value> = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed.len(), 2);
+        assert_eq!(parsed[0]["id"], 1);
+        assert_eq!(parsed[1]["id"], 2);
+    }
+
+    #[test]
+    fn batch_with_notification_omits_response() {
+        // A notification has no id — when filtered, the batch response should
+        // contain fewer entries than the batch request.
+        let json = r#"[
+            {"jsonrpc":"2.0","method":"subgraph_create","id":1},
+            {"jsonrpc":"2.0","method":"subgraph_remove"}
+        ]"#;
+        let requests: Vec<JsonRpcRequest> = serde_json::from_str(json).unwrap();
+        assert_eq!(requests.len(), 2);
+        assert!(requests[0].id.is_some());
+        assert!(requests[1].id.is_none());
+    }
+
+    #[test]
+    fn empty_batch_is_valid_json_array() {
+        let json = "[]";
+        let requests: Vec<JsonRpcRequest> = serde_json::from_str(json).unwrap();
+        assert!(requests.is_empty());
+    }
+}
diff --git a/server/json-rpc/src/lib.rs b/server/json-rpc/src/lib.rs
index 0779a30b73d..401a457c57e 100644
--- a/server/json-rpc/src/lib.rs
+++ b/server/json-rpc/src/lib.rs
@@ -1,252 +1,10 @@
-use graph::prelude::{Value as GraphValue, *};
-use jsonrpsee::core::Error as JsonRpcError;
-use jsonrpsee::http_server::{HttpServerBuilder, HttpServerHandle};
-use jsonrpsee::types::error::CallError;
-use jsonrpsee::types::ErrorObject;
-use jsonrpsee::RpcModule;
-use serde_json::{self, Value as JsonValue};
+//! JSON-RPC admin server for subgraph management.
+//!
+//! This crate provides a JSON-RPC 2.0 server for managing subgraphs,
+//! supporting operations like create, deploy, remove, reassign, pause, and resume.
 
-use std::collections::BTreeMap;
-use std::net::{Ipv4Addr, SocketAddr};
+mod handlers;
+mod jsonrpc;
+mod server;
 
-type JsonRpcResult<T> = Result<T, jsonrpsee::core::Error>;
-
-pub struct JsonRpcServer {
-    // TODO: in the future we might want to have some sort of async drop to stop
-    // the server. For now, we're just letting it run it forever.
-    _handle: HttpServerHandle,
-}
-
-impl JsonRpcServer {
-    pub async fn serve<R>(
-        port: u16,
-        http_port: u16,
-        ws_port: u16,
-        registrar: Arc<R>,
-        node_id: NodeId,
-        logger: Logger,
-    ) -> JsonRpcResult<Self>
-    where
-        R: SubgraphRegistrar,
-    {
-        let logger = logger.new(o!("component" => "JsonRpcServer"));
-
-        info!(
-            logger,
-            "Starting JSON-RPC admin server at: http://localhost:{}", port
-        );
-
-        let state = ServerState {
-            registrar,
-            http_port,
-            ws_port,
-            node_id,
-            logger,
-        };
-
-        let socket_addr: SocketAddr = (Ipv4Addr::new(0, 0, 0, 0), port).into();
-        let http_server = HttpServerBuilder::default().build(socket_addr).await?;
-
-        let mut rpc_module = RpcModule::new(state);
-        rpc_module
-            .register_async_method("subgraph_create", |params, state| async move {
-                state.create_handler(params.parse()?).await
-            })
-            .unwrap();
-        rpc_module
-            .register_async_method("subgraph_deploy", |params, state| async move {
-                state.deploy_handler(params.parse()?).await
-            })
-            .unwrap();
-        rpc_module
-            .register_async_method("subgraph_remove", |params, state| async move {
-                state.remove_handler(params.parse()?).await
-            })
-            .unwrap();
-        rpc_module
-            .register_async_method("subgraph_reassign", |params, state| async move {
-                state.reassign_handler(params.parse()?).await
-            })
-            .unwrap();
-
-        let _handle = http_server.start(rpc_module)?;
-        Ok(Self { _handle })
-    }
-}
-
-struct ServerState<R> {
-    registrar: Arc<R>,
-    http_port: u16,
-    ws_port: u16,
-    node_id: NodeId,
-    logger: Logger,
-}
-
-impl<R: SubgraphRegistrar> ServerState<R> {
-    const DEPLOY_ERROR: i64 = 0;
-    const REMOVE_ERROR: i64 = 1;
-    const CREATE_ERROR: i64 = 2;
-    const REASSIGN_ERROR: i64 = 3;
-
-    /// Handler for the `subgraph_create` endpoint.
-    async fn create_handler(&self, params: SubgraphCreateParams) -> JsonRpcResult<JsonValue> {
-        info!(&self.logger, "Received subgraph_create request"; "params" => format!("{:?}", params));
-
-        match self.registrar.create_subgraph(params.name.clone()).await {
-            Ok(result) => {
-                Ok(serde_json::to_value(result).expect("invalid subgraph creation result"))
-            }
-            Err(e) => Err(json_rpc_error(
-                &self.logger,
-                "subgraph_create",
-                e,
-                Self::CREATE_ERROR,
-                params,
-            )),
-        }
-    }
-
-    /// Handler for the `subgraph_deploy` endpoint.
-    async fn deploy_handler(&self, params: SubgraphDeployParams) -> JsonRpcResult<JsonValue> {
-        info!(&self.logger, "Received subgraph_deploy request"; "params" => format!("{:?}", params));
-
-        let node_id = params.node_id.clone().unwrap_or(self.node_id.clone());
-        let routes = subgraph_routes(&params.name, self.http_port, self.ws_port);
-        match self
-            .registrar
-            .create_subgraph_version(
-                params.name.clone(),
-                params.ipfs_hash.clone(),
-                node_id,
-                params.debug_fork.clone(),
-                // Here it doesn't make sense to receive another
-                // startBlock, we'll use the one from the manifest.
-                None,
-                None,
-                params.history_blocks,
-            )
-            .await
-        {
-            Ok(_) => Ok(routes),
-            Err(e) => Err(json_rpc_error(
-                &self.logger,
-                "subgraph_deploy",
-                e,
-                Self::DEPLOY_ERROR,
-                params,
-            )),
-        }
-    }
-
-    /// Handler for the `subgraph_remove` endpoint.
-    async fn remove_handler(&self, params: SubgraphRemoveParams) -> JsonRpcResult<GraphValue> {
-        info!(&self.logger, "Received subgraph_remove request"; "params" => format!("{:?}", params));
-
-        match self.registrar.remove_subgraph(params.name.clone()).await {
-            Ok(_) => Ok(Value::Null),
-            Err(e) => Err(json_rpc_error(
-                &self.logger,
-                "subgraph_remove",
-                e,
-                Self::REMOVE_ERROR,
-                params,
-            )),
-        }
-    }
-
-    /// Handler for the `subgraph_assign` endpoint.
-    async fn reassign_handler(&self, params: SubgraphReassignParams) -> JsonRpcResult<GraphValue> {
-        info!(&self.logger, "Received subgraph_reassignment request"; "params" => format!("{:?}", params));
-
-        match self
-            .registrar
-            .reassign_subgraph(&params.ipfs_hash, &params.node_id)
-            .await
-        {
-            Ok(_) => Ok(Value::Null),
-            Err(e) => Err(json_rpc_error(
-                &self.logger,
-                "subgraph_reassign",
-                e,
-                Self::REASSIGN_ERROR,
-                params,
-            )),
-        }
-    }
-}
-
-fn json_rpc_error(
-    logger: &Logger,
-    operation: &str,
-    e: SubgraphRegistrarError,
-    code: i64,
-    params: impl std::fmt::Debug,
-) -> JsonRpcError {
-    error!(logger, "{} failed", operation;
-        "error" => format!("{:?}", e),
-        "params" => format!("{:?}", params));
-
-    let message = if let SubgraphRegistrarError::Unknown(_) = e {
-        "internal error".to_owned()
-    } else {
-        e.to_string()
-    };
-
-    JsonRpcError::Call(CallError::Custom(ErrorObject::owned(
-        code as _,
-        message,
-        None::<String>,
-    )))
-}
-
-fn subgraph_routes(name: &SubgraphName, http_port: u16, ws_port: u16) -> JsonValue {
-    let http_base_url = ENV_VARS
-        .external_http_base_url
-        .clone()
-        .unwrap_or_else(|| format!(":{}", http_port));
-    let ws_base_url = ENV_VARS
-        .external_ws_base_url
-        .clone()
-        .unwrap_or_else(|| format!(":{}", ws_port));
-
-    let mut map = BTreeMap::new();
-    map.insert(
-        "playground",
-        format!("{}/subgraphs/name/{}/graphql", http_base_url, name),
-    );
-    map.insert(
-        "queries",
-        format!("{}/subgraphs/name/{}", http_base_url, name),
-    );
-    map.insert(
-        "subscriptions",
-        format!("{}/subgraphs/name/{}", ws_base_url, name),
-    );
-
-    serde_json::to_value(map).expect("invalid subgraph routes")
-}
-
-#[derive(Debug, Deserialize)]
-struct SubgraphCreateParams {
-    name: SubgraphName,
-}
-
-#[derive(Debug, Deserialize)]
-struct SubgraphDeployParams {
-    name: SubgraphName,
-    ipfs_hash: DeploymentHash,
-    node_id: Option<NodeId>,
-    debug_fork: Option<DeploymentHash>,
-    history_blocks: Option<i32>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SubgraphRemoveParams {
-    name: SubgraphName,
-}
-
-#[derive(Debug, Deserialize)]
-struct SubgraphReassignParams {
-    ipfs_hash: DeploymentHash,
-    node_id: NodeId,
-}
+pub use server::{JsonRpcServer, JsonRpcServerError};
diff --git a/server/json-rpc/src/server.rs b/server/json-rpc/src/server.rs
new file mode 100644
index 00000000000..5fe5905ba70
--- /dev/null
+++ b/server/json-rpc/src/server.rs
@@ -0,0 +1,95 @@
+//! Axum-based JSON-RPC server implementation.
+//!
+//! This module provides the `JsonRpcServer` that serves JSON-RPC requests
+//! over HTTP using axum.
+
+use std::net::{Ipv4Addr, SocketAddr};
+use std::sync::Arc;
+
+use axum::Router;
+use axum::routing::post;
+use graph::prelude::{NodeId, SubgraphRegistrar};
+use slog::{Logger, info};
+use thiserror::Error;
+use tokio::sync::Notify;
+
+use crate::handlers::{AppState, jsonrpc_handler};
+
+/// Errors that can occur when starting the JSON-RPC server.
+#[derive(Debug, Error)]
+pub enum JsonRpcServerError {
+    #[error("Failed to bind to address: {0}")]
+    Bind(#[from] std::io::Error),
+}
+
+/// Handle to a running JSON-RPC server.
+///
+/// Dropping this handle does not stop the server. Use `stop()` for graceful shutdown.
+pub struct JsonRpcServer {
+    notify: Arc<Notify>,
+}
+
+impl JsonRpcServer {
+    /// Start the JSON-RPC server.
+    ///
+    /// # Arguments
+    ///
+    /// * `port` - The port to listen on for JSON-RPC requests
+    /// * `http_port` - The HTTP port used for subgraph route URLs in deploy responses
+    /// * `registrar` - The subgraph registrar for handling operations
+    /// * `node_id` - Default node ID for deployments
+    /// * `logger` - Logger for request/response logging
+    pub async fn serve<R>(
+        port: u16,
+        http_port: u16,
+        registrar: Arc<R>,
+        node_id: NodeId,
+        logger: Logger,
+    ) -> Result<Self, JsonRpcServerError>
+    where
+        R: SubgraphRegistrar,
+    {
+        let logger = logger.new(graph::prelude::o!("component" => "JsonRpcServer"));
+
+        info!(
+            logger,
+            "Starting JSON-RPC admin server at: http://localhost:{}", port
+        );
+
+        let state = Arc::new(AppState {
+            registrar,
+            http_port,
+            node_id,
+            logger,
+        });
+
+        let app = Router::new()
+            .route("/", post(jsonrpc_handler::<R>))
+            .with_state(state);
+
+        let addr: SocketAddr = (Ipv4Addr::new(0, 0, 0, 0), port).into();
+        let listener = tokio::net::TcpListener::bind(addr).await?;
+
+        let notify = Arc::new(Notify::new());
+        let notify_clone = notify.clone();
+
+        graph::spawn(async move {
+            axum::serve(
+                listener,
+                app.into_make_service_with_connect_info::<SocketAddr>(),
+            )
+            .with_graceful_shutdown(async move {
+                notify_clone.notified().await;
+            })
+            .await
+            .unwrap_or_else(|err| panic!("JSON-RPC server failed: {err}"));
+        });
+
+        Ok(Self { notify })
+    }
+
+    /// Stop the server gracefully.
+    pub fn stop(self) {
+        self.notify.notify_one();
+    }
+}
diff --git a/server/metrics/Cargo.toml b/server/metrics/Cargo.toml
index 67f6092123f..bf7dabd9c2e 100644
--- a/server/metrics/Cargo.toml
+++ b/server/metrics/Cargo.toml
@@ -5,4 +5,3 @@ edition.workspace = true
 
 [dependencies]
 graph = { path = "../../graph" }
-hyper = { version = "0.14", features = ["server"] }
diff --git a/server/metrics/src/lib.rs b/server/metrics/src/lib.rs
index f67d9dadf32..d2fb2e747fe 100644
--- a/server/metrics/src/lib.rs
+++ b/server/metrics/src/lib.rs
@@ -1,22 +1,13 @@
-use std::net::{Ipv4Addr, SocketAddrV4};
 use std::sync::Arc;
 
-use anyhow::Error;
-use hyper::header::{ACCESS_CONTROL_ALLOW_ORIGIN, CONTENT_TYPE};
-use hyper::service::{make_service_fn, service_fn};
-use hyper::{Body, Response, Server};
-use thiserror::Error;
+use graph::components::server::server::{ServerHandle, start};
+use graph::http_body_util::Full;
+use graph::hyper::Response;
+use graph::hyper::header::{ACCESS_CONTROL_ALLOW_ORIGIN, CONTENT_TYPE};
 
 use graph::prelude::*;
 use graph::prometheus::{Encoder, Registry, TextEncoder};
 
-/// Errors that may occur when starting the server.
-#[derive(Debug, Error)]
-pub enum PrometheusMetricsServeError {
-    #[error("Bind error: {0}")]
-    BindError(#[from] hyper::Error),
-}
-
 #[derive(Clone)]
 pub struct PrometheusMetricsServer {
     logger: Logger,
@@ -32,10 +23,7 @@ impl PrometheusMetricsServer {
     }
 
     /// Creates a new Tokio task that, when spawned, brings up the index node server.
-    pub async fn serve(
-        &mut self,
-        port: u16,
-    ) -> Result<Result<(), ()>, PrometheusMetricsServeError> {
+    pub async fn start(&self, port: u16) -> Result<ServerHandle, anyhow::Error> {
         let logger = self.logger.clone();
 
         info!(
@@ -43,33 +31,22 @@ impl PrometheusMetricsServer {
             "Starting metrics server at: http://localhost:{}", port,
         );
 
-        let addr = SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), port);
-
         let server = self.clone();
-        let new_service = make_service_fn(move |_req| {
+        start(logger, port, move |_| {
             let server = server.clone();
             async move {
-                Ok::<_, Error>(service_fn(move |_| {
-                    let metric_families = server.registry.gather();
-                    let mut buffer = vec![];
-                    let encoder = TextEncoder::new();
-                    encoder.encode(&metric_families, &mut buffer).unwrap();
-                    futures03::future::ok::<_, Error>(
-                        Response::builder()
-                            .status(200)
-                            .header(CONTENT_TYPE, encoder.format_type())
-                            .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                            .body(Body::from(buffer))
-                            .unwrap(),
-                    )
-                }))
+                let metric_families = server.registry.gather();
+                let mut buffer = vec![];
+                let encoder = TextEncoder::new();
+                encoder.encode(&metric_families, &mut buffer).unwrap();
+                Ok(Response::builder()
+                    .status(200)
+                    .header(CONTENT_TYPE, encoder.format_type())
+                    .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+                    .body(Full::from(buffer))
+                    .unwrap())
             }
-        });
-
-        let task = Server::try_bind(&addr.into())?
-            .serve(new_service)
-            .map_err(move |e| error!(logger, "Metrics server error"; "error" => format!("{}", e)));
-
-        Ok(task.await)
+        })
+        .await
     }
 }
diff --git a/server/websocket/Cargo.toml b/server/websocket/Cargo.toml
deleted file mode 100644
index de347a82096..00000000000
--- a/server/websocket/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "graph-server-websocket"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-futures = "0.1.23"
-graph = { path = "../../graph" }
-graphql-parser = "0.4.0"
-http = "0.2"
-lazy_static = "1.2.0"
-serde = "1.0"
-serde_derive = "1.0"
-tokio-tungstenite = "0.17"
-uuid = { version = "1.6.1", features = ["v4"] }
-anyhow = "1.0"
diff --git a/server/websocket/src/connection.rs b/server/websocket/src/connection.rs
deleted file mode 100644
index e424b7090bf..00000000000
--- a/server/websocket/src/connection.rs
+++ /dev/null
@@ -1,433 +0,0 @@
-use futures::sync::mpsc;
-use futures03::stream::SplitStream;
-use graphql_parser::parse_query;
-use http::StatusCode;
-use std::collections::HashMap;
-use tokio::io::{AsyncRead, AsyncWrite};
-use tokio_tungstenite::tungstenite::{Error as WsError, Message as WsMessage};
-use tokio_tungstenite::WebSocketStream;
-use uuid::Uuid;
-
-use graph::{data::query::QueryTarget, prelude::*};
-
-#[derive(Debug, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-struct StartPayload {
-    query: String,
-    variables: Option<serde_json::Value>,
-    operation_name: Option<String>,
-}
-
-/// GraphQL/WebSocket message received from a client.
-#[derive(Debug, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-enum IncomingMessage {
-    ConnectionInit {
-        #[allow(dead_code)]
-        payload: Option<serde_json::Value>,
-    },
-    ConnectionTerminate,
-    Start {
-        id: String,
-        payload: StartPayload,
-    },
-    Stop {
-        id: String,
-    },
-}
-
-impl IncomingMessage {
-    pub fn from_ws_message(msg: WsMessage) -> Result<Self, WsError> {
-        let text = msg.into_text()?;
-        serde_json::from_str(text.as_str()).map_err(|e| {
-            WsError::Http(http::Response::new(Some(format!(
-                "Invalid GraphQL over WebSocket message: {}: {}",
-                text, e
-            ))))
-        })
-    }
-}
-
-/// GraphQL/WebSocket message to be sent to the client.
-#[derive(Debug, Serialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-enum OutgoingMessage {
-    ConnectionAck,
-    Error {
-        id: String,
-        payload: String,
-    },
-    Data {
-        id: String,
-        payload: Arc<QueryResult>,
-    },
-    Complete {
-        id: String,
-    },
-}
-
-impl OutgoingMessage {
-    pub fn from_query_result(id: String, result: Arc<QueryResult>) -> Self {
-        OutgoingMessage::Data {
-            id,
-            payload: result,
-        }
-    }
-
-    pub fn from_error_string(id: String, s: String) -> Self {
-        OutgoingMessage::Error { id, payload: s }
-    }
-}
-
-impl From<OutgoingMessage> for WsMessage {
-    fn from(msg: OutgoingMessage) -> Self {
-        WsMessage::text(serde_json::to_string(&msg).expect("invalid GraphQL/WebSocket message"))
-    }
-}
-
-/// Helper function to send outgoing messages.
-fn send_message(
-    sink: &mpsc::UnboundedSender<WsMessage>,
-    msg: OutgoingMessage,
-) -> Result<(), WsError> {
-    sink.unbounded_send(msg.into()).map_err(|_| {
-        let mut response = http::Response::new(None);
-        *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-        WsError::Http(response)
-    })
-}
-
-/// Helper function to send error messages.
-fn send_error_string(
-    sink: &mpsc::UnboundedSender<WsMessage>,
-    operation_id: String,
-    error: String,
-) -> Result<(), WsError> {
-    sink.unbounded_send(OutgoingMessage::from_error_string(operation_id, error).into())
-        .map_err(|_| {
-            let mut response = http::Response::new(None);
-            *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-            WsError::Http(response)
-        })
-}
-
-/// Responsible for recording operation ids and stopping them.
-/// On drop, cancels all operations.
-struct Operations {
-    operations: HashMap<String, CancelGuard>,
-    msg_sink: mpsc::UnboundedSender<WsMessage>,
-}
-
-impl Operations {
-    fn new(msg_sink: mpsc::UnboundedSender<WsMessage>) -> Self {
-        Self {
-            operations: HashMap::new(),
-            msg_sink,
-        }
-    }
-
-    fn contains(&self, id: &str) -> bool {
-        self.operations.contains_key(id)
-    }
-
-    fn insert(&mut self, id: String, guard: CancelGuard) {
-        self.operations.insert(id, guard);
-    }
-
-    fn stop(&mut self, operation_id: String) -> Result<(), WsError> {
-        // Remove the operation with this ID from the known operations.
-        match self.operations.remove(&operation_id) {
-            Some(stopper) => {
-                // Cancel the subscription result stream.
-                stopper.cancel();
-
-                // Send a GQL_COMPLETE to indicate the operation is been completed.
-                send_message(
-                    &self.msg_sink,
-                    OutgoingMessage::Complete {
-                        id: operation_id.clone(),
-                    },
-                )
-            }
-            None => send_error_string(
-                &self.msg_sink,
-                operation_id.clone(),
-                format!("Unknown operation ID: {}", operation_id),
-            ),
-        }
-    }
-}
-
-impl Drop for Operations {
-    fn drop(&mut self) {
-        let ids = Vec::from_iter(self.operations.keys().cloned());
-        for id in ids {
-            // Discard errors, the connection is being shutdown anyways.
-            let _ = self.stop(id);
-        }
-    }
-}
-
-/// A WebSocket connection implementing the GraphQL over WebSocket protocol.
-pub struct GraphQlConnection<Q, S> {
-    id: String,
-    logger: Logger,
-    graphql_runner: Arc<Q>,
-    stream: WebSocketStream<S>,
-    deployment: DeploymentHash,
-}
-
-impl<Q, S> GraphQlConnection<Q, S>
-where
-    Q: GraphQlRunner,
-    S: AsyncRead + AsyncWrite + Send + 'static + Unpin,
-{
-    /// Creates a new GraphQL subscription service.
-    pub(crate) fn new(
-        logger: &Logger,
-        deployment: DeploymentHash,
-        stream: WebSocketStream<S>,
-        graphql_runner: Arc<Q>,
-    ) -> Self {
-        GraphQlConnection {
-            id: Uuid::new_v4().to_string(),
-            logger: logger.new(o!("component" => "GraphQlConnection")),
-            graphql_runner,
-            stream,
-            deployment,
-        }
-    }
-
-    async fn handle_incoming_messages(
-        mut ws_stream: SplitStream<WebSocketStream<S>>,
-        mut msg_sink: mpsc::UnboundedSender<WsMessage>,
-        logger: Logger,
-        connection_id: String,
-        deployment: DeploymentHash,
-        graphql_runner: Arc<Q>,
-    ) -> Result<(), WsError> {
-        let mut operations = Operations::new(msg_sink.clone());
-
-        // Process incoming messages as long as the WebSocket is open
-        while let Some(ws_msg) = ws_stream.try_next().await? {
-            use self::IncomingMessage::*;
-            use self::OutgoingMessage::*;
-
-            debug!(logger, "Received message";
-                   "connection" => &connection_id,
-                   "msg" => format!("{}", ws_msg).as_str());
-
-            let msg = IncomingMessage::from_ws_message(ws_msg.clone())?;
-
-            debug!(logger, "GraphQL/WebSocket message";
-                   "connection" => &connection_id,
-                   "msg" => format!("{:?}", msg).as_str());
-
-            match msg {
-                // Always accept connection init requests
-                ConnectionInit { payload: _ } => send_message(&msg_sink, ConnectionAck),
-
-                // When receiving a connection termination request
-                ConnectionTerminate => {
-                    // Close the message sink
-                    msg_sink.close().unwrap();
-
-                    // Return an error here to terminate the connection
-                    Err(WsError::ConnectionClosed)
-                }
-
-                // When receiving a stop request
-                Stop { id } => operations.stop(id),
-
-                // When receiving a start request
-                Start { id, payload } => {
-                    // Respond with a GQL_ERROR if we already have an operation with this ID
-                    if operations.contains(&id) {
-                        return send_error_string(
-                            &msg_sink,
-                            id.clone(),
-                            format!("Operation with ID already started: {}", id),
-                        );
-                    }
-
-                    let max_ops = ENV_VARS.graphql.max_operations_per_connection;
-                    if operations.operations.len() >= max_ops {
-                        return send_error_string(
-                            &msg_sink,
-                            id,
-                            format!("Reached the limit of {} operations per connection", max_ops),
-                        );
-                    }
-
-                    // Parse the GraphQL query document; respond with a GQL_ERROR if
-                    // the query is invalid
-                    let query = match parse_query(&payload.query) {
-                        Ok(query) => query.into_static(),
-                        Err(e) => {
-                            return send_error_string(
-                                &msg_sink,
-                                id,
-                                format!("Invalid query: {}: {}", payload.query, e),
-                            );
-                        }
-                    };
-
-                    // Parse the query variables, if present
-                    let variables = match payload.variables {
-                        None | Some(serde_json::Value::Null) => None,
-                        Some(variables @ serde_json::Value::Object(_)) => {
-                            match serde_json::from_value(variables.clone()) {
-                                Ok(variables) => Some(variables),
-                                Err(e) => {
-                                    return send_error_string(
-                                        &msg_sink,
-                                        id,
-                                        format!("Invalid variables provided: {}", e),
-                                    );
-                                }
-                            }
-                        }
-                        _ => {
-                            return send_error_string(
-                                &msg_sink,
-                                id,
-                                "Invalid variables provided (must be an object)".to_string(),
-                            );
-                        }
-                    };
-
-                    // Construct a subscription
-                    let target = QueryTarget::Deployment(deployment.clone(), Default::default());
-                    let subscription = Subscription {
-                        // Subscriptions currently do not benefit from the generational cache
-                        // anyways, so don't bother passing a network.
-                        query: Query::new(query, variables, false),
-                    };
-
-                    debug!(logger, "Start operation";
-                           "connection" => &connection_id,
-                           "id" => &id);
-
-                    // Execute the GraphQL subscription
-                    let error_sink = msg_sink.clone();
-                    let result_sink = msg_sink.clone();
-                    let result_id = id.clone();
-                    let err_id = id.clone();
-                    let err_connection_id = connection_id.clone();
-                    let err_logger = logger.clone();
-                    let run_subscription = graphql_runner
-                        .cheap_clone()
-                        .run_subscription(subscription, target)
-                        .compat()
-                        .map_err(move |e| {
-                            debug!(err_logger, "Subscription error";
-                                               "connection" => &err_connection_id,
-                                               "id" => &err_id,
-                                               "error" => format!("{:?}", e));
-
-                            // Send errors back to the client as GQL_DATA
-                            match e {
-                                SubscriptionError::GraphQLError(e) => {
-                                    // Don't bug clients with transient `TooExpensive` errors,
-                                    // simply skip updating them
-                                    if !e
-                                        .iter()
-                                        .any(|err| matches!(err, QueryExecutionError::TooExpensive))
-                                    {
-                                        let result = Arc::new(QueryResult::from(e));
-                                        let msg = OutgoingMessage::from_query_result(
-                                            err_id.clone(),
-                                            result,
-                                        );
-
-                                        // An error means the client closed the websocket, ignore
-                                        // and let it be handled in the websocket loop above.
-                                        let _ = error_sink.unbounded_send(msg.into());
-                                    }
-                                }
-                            };
-                        })
-                        .and_then(move |result_stream| {
-                            // Send results back to the client as GQL_DATA
-                            result_stream
-                                .map(move |result| {
-                                    OutgoingMessage::from_query_result(result_id.clone(), result)
-                                })
-                                .map(WsMessage::from)
-                                .map(Ok)
-                                .compat()
-                                .forward(result_sink.sink_map_err(|_| ()))
-                                .map(|_| ())
-                        });
-
-                    // Setup cancelation.
-                    let guard = CancelGuard::new();
-                    let logger = logger.clone();
-                    let cancel_id = id.clone();
-                    let connection_id = connection_id.clone();
-                    let run_subscription =
-                        run_subscription.compat().cancelable(&guard, move || {
-                            debug!(logger, "Stopped operation";
-                                       "connection" => &connection_id,
-                                       "id" => &cancel_id);
-                            Ok(())
-                        });
-                    operations.insert(id, guard);
-
-                    graph::spawn_allow_panic(run_subscription);
-                    Ok(())
-                }
-            }?
-        }
-        Ok(())
-    }
-}
-
-impl<Q, S> IntoFuture for GraphQlConnection<Q, S>
-where
-    Q: GraphQlRunner,
-    S: AsyncRead + AsyncWrite + Send + 'static + Unpin,
-{
-    type Future = Box<dyn Future<Item = Self::Item, Error = Self::Error> + Send>;
-    type Item = ();
-    type Error = ();
-
-    fn into_future(self) -> Self::Future {
-        debug!(self.logger, "GraphQL over WebSocket connection opened"; "id" => &self.id);
-
-        // Obtain sink/stream pair to send and receive WebSocket messages
-        let (ws_sink, ws_stream) = self.stream.split();
-
-        // Allocate a channel for writing
-        let (msg_sink, msg_stream) = mpsc::unbounded();
-
-        // Handle incoming messages asynchronously
-        let ws_reader = Self::handle_incoming_messages(
-            ws_stream,
-            msg_sink,
-            self.logger.clone(),
-            self.id.clone(),
-            self.deployment.clone(),
-            self.graphql_runner.clone(),
-        );
-
-        // Send outgoing messages asynchronously
-        let ws_writer = msg_stream.forward(ws_sink.compat().sink_map_err(|_| ()));
-
-        // Silently swallow internal send results and errors. There is nothing
-        // we can do about these errors ourselves. Clients will be disconnected
-        // as a result of this but most will try to reconnect (GraphiQL for sure,
-        // Apollo maybe).
-        let ws_writer = ws_writer.map(|_| ());
-        let ws_reader = Box::pin(ws_reader.map_err(|_| ()));
-
-        // Return a future that is fulfilled when either we or the client close
-        // our/their end of the WebSocket stream
-        let logger = self.logger.clone();
-        let id = self.id.clone();
-        Box::new(ws_reader.compat().select(ws_writer).then(move |_| {
-            debug!(logger, "GraphQL over WebSocket connection closed"; "connection" => id);
-            Ok(())
-        }))
-    }
-}
diff --git a/server/websocket/src/lib.rs b/server/websocket/src/lib.rs
deleted file mode 100644
index 887fed506fe..00000000000
--- a/server/websocket/src/lib.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod connection;
-mod server;
-
-pub use self::server::SubscriptionServer;
diff --git a/server/websocket/src/server.rs b/server/websocket/src/server.rs
deleted file mode 100644
index 62684f38a5c..00000000000
--- a/server/websocket/src/server.rs
+++ /dev/null
@@ -1,214 +0,0 @@
-use graph::{
-    data::query::QueryTarget,
-    prelude::{SubscriptionServer as SubscriptionServerTrait, *},
-};
-use http::header::{ACCESS_CONTROL_ALLOW_ORIGIN, CONTENT_TYPE};
-use http::{HeaderValue, Response, StatusCode};
-use std::net::{IpAddr, Ipv4Addr, SocketAddr};
-use std::sync::Mutex;
-use tokio::net::TcpListener;
-use tokio_tungstenite::accept_hdr_async;
-use tokio_tungstenite::tungstenite::handshake::server::Request;
-
-use crate::connection::GraphQlConnection;
-
-/// A GraphQL subscription server based on Hyper / Websockets.
-pub struct SubscriptionServer<Q, S> {
-    logger: Logger,
-    graphql_runner: Arc<Q>,
-    store: Arc<S>,
-}
-
-impl<Q, S> SubscriptionServer<Q, S>
-where
-    Q: GraphQlRunner,
-    S: QueryStoreManager,
-{
-    pub fn new(logger: &Logger, graphql_runner: Arc<Q>, store: Arc<S>) -> Self {
-        SubscriptionServer {
-            logger: logger.new(o!("component" => "SubscriptionServer")),
-            graphql_runner,
-            store,
-        }
-    }
-
-    async fn subgraph_id_from_url_path(
-        store: Arc<S>,
-        path: &str,
-    ) -> Result<Option<DeploymentState>, Error> {
-        fn target_from_name(name: String, api_version: ApiVersion) -> Option<QueryTarget> {
-            SubgraphName::new(name)
-                .ok()
-                .map(|sub_name| QueryTarget::Name(sub_name, api_version))
-        }
-
-        fn target_from_id(id: &str, api_version: ApiVersion) -> Option<QueryTarget> {
-            DeploymentHash::new(id)
-                .ok()
-                .map(|hash| QueryTarget::Deployment(hash, api_version))
-        }
-
-        async fn state<S: QueryStoreManager>(
-            store: Arc<S>,
-            target: Option<QueryTarget>,
-        ) -> Option<DeploymentState> {
-            let target = match target {
-                Some(target) => target,
-                None => return None,
-            };
-            match store.query_store(target, false).await.ok() {
-                Some(query_store) => query_store.deployment_state().await.ok(),
-                None => None,
-            }
-        }
-
-        let path_segments = {
-            let mut segments = path.split('/');
-
-            // Remove leading '/'
-            let first_segment = segments.next();
-            if first_segment != Some("") {
-                return Ok(None);
-            }
-
-            segments.collect::<Vec<_>>()
-        };
-
-        match path_segments.as_slice() {
-            &["subgraphs", "id", subgraph_id] => {
-                Ok(state(store, target_from_id(subgraph_id, ApiVersion::default())).await)
-            }
-            &["subgraphs", "name", _] | &["subgraphs", "name", _, _] => Ok(state(
-                store,
-                target_from_name(path_segments[2..].join("/"), ApiVersion::default()), // TODO: version
-            )
-            .await),
-            &["subgraphs", "network", _, _] => Ok(state(
-                store,
-                target_from_name(path_segments[1..].join("/"), ApiVersion::default()), // TODO: version
-            )
-            .await),
-            _ => Ok(None),
-        }
-    }
-}
-
-#[async_trait]
-impl<Q, S> SubscriptionServerTrait for SubscriptionServer<Q, S>
-where
-    Q: GraphQlRunner,
-    S: QueryStoreManager,
-{
-    async fn serve(self, port: u16) {
-        info!(
-            self.logger,
-            "Starting GraphQL WebSocket server at: ws://localhost:{}", port
-        );
-
-        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), port);
-        let socket = TcpListener::bind(&addr)
-            .await
-            .expect("Failed to bind WebSocket port");
-
-        loop {
-            let stream = match socket.accept().await {
-                Ok((stream, _)) => stream,
-                Err(e) => {
-                    trace!(self.logger, "Connection error: {}", e);
-                    continue;
-                }
-            };
-            let logger = self.logger.clone();
-            let logger2 = self.logger.clone();
-            let graphql_runner = self.graphql_runner.clone();
-            let store = self.store.clone();
-
-            // Subgraph that the request is resolved to (if any)
-            let subgraph_id = Arc::new(Mutex::new(None));
-            let accept_subgraph_id = subgraph_id.clone();
-
-            accept_hdr_async(stream, move |request: &Request, mut response: Response<()>| {
-                // Try to obtain the subgraph ID or name from the URL path.
-                // Return a 404 if the URL path contains no name/ID segment.
-                let path = request.uri().path();
-
-                // `block_in_place` is not recommended but in this case we have no alternative since
-                // we're in an async context but `tokio_tungstenite` doesn't allow this callback
-                // to be a future.
-                let state = tokio::task::block_in_place(|| {
-                    graph::block_on(Self::subgraph_id_from_url_path(
-                        store.clone(),
-                        path,
-                    ))
-                })
-                .map_err(|e| {
-                    error!(
-                        logger,
-                        "Error resolving subgraph ID from URL path";
-                        "error" => e.to_string()
-                    );
-
-                    Response::builder()
-                        .status(StatusCode::INTERNAL_SERVER_ERROR)
-                        .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                        .header(CONTENT_TYPE, "text/plain")
-                        .body(None)
-                        .unwrap()
-                })
-                .and_then(|state| {
-                    state.ok_or_else(|| {
-                        Response::builder()
-                            .status(StatusCode::NOT_FOUND)
-                            .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                            .header(CONTENT_TYPE, "text/plain")
-                            .body(None)
-                            .unwrap()
-                    })
-                })?;
-
-                // Check if the subgraph is deployed
-                if !state.is_deployed() {
-                        error!(logger, "Failed to establish WS connection, no data found for subgraph";
-                                        "subgraph_id" => state.id.to_string(),
-                        );
-                        return Err(Response::builder()
-                            .status(StatusCode::NOT_FOUND)
-                            .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                            .header(CONTENT_TYPE, "text/plain")
-                            .body(None)
-                            .unwrap());
-                    }
-
-                *accept_subgraph_id.lock().unwrap() = Some(state.id);
-                response.headers_mut().insert(
-                    "Sec-WebSocket-Protocol",
-                    HeaderValue::from_static("graphql-ws"),
-                );
-                Ok(response)
-            })
-            .then(move |result| async move {
-                match result {
-                    Ok(ws_stream) => {
-                        // Obtain the subgraph ID or name that we resolved the request to
-                        let subgraph_id = subgraph_id.lock().unwrap().clone().unwrap();
-
-                        // Spawn a GraphQL over WebSocket connection
-                        let service = GraphQlConnection::new(
-                            &logger2,
-                            subgraph_id,
-                            ws_stream,
-                            graphql_runner.clone(),
-                        );
-
-                        graph::spawn_allow_panic(service.into_future().compat());
-                    }
-                    Err(e) => {
-                        // We gracefully skip over failed connection attempts rather
-                        // than tearing down the entire stream
-                        trace!(logger2, "Failed to establish WebSocket connection: {}", e);
-                    }
-                }
-            }).await
-        }
-    }
-}
diff --git a/store/postgres/Cargo.toml b/store/postgres/Cargo.toml
index 0c901abe186..96732c44c28 100644
--- a/store/postgres/Cargo.toml
+++ b/store/postgres/Cargo.toml
@@ -4,41 +4,45 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-async-trait = "0.1.50"
-blake3 = "1.5"
-derive_more = { version = "0.99.17" }
-diesel = { version = "1.4.8", features = [
-    "postgres",
-    "serde_json",
-    "numeric",
-    "r2d2",
-] }
-# We use diesel-dynamic-schema straight from git as the project has not
-# made a release as a crate yet
-diesel-dynamic-schema = { git = "https://github.com/diesel-rs/diesel-dynamic-schema", rev = "a8ec4fb1" }
-diesel-derive-enum = { version = "1.1", features = ["postgres"] }
-diesel_migrations = "1.3.0"
+async-trait = { workspace = true }
+blake3 = "1.8"
+chrono = { workspace = true }
+deadpool = { workspace = true }
+derive_more = { workspace = true, features = ["full"] }
+diesel = { workspace = true }
+diesel-async = { workspace = true }
+diesel-dynamic-schema = { workspace = true }
+diesel-derive-enum = { workspace = true }
+diesel_derives = { workspace = true }
+diesel_migrations = { workspace = true }
 fallible-iterator = "0.3.0"
 graph = { path = "../../graph" }
-Inflector = "0.11.3"
-lazy_static = "1.1"
+graphman-store = { workspace = true }
+Inflector = { workspace = true }
+lazy_static = { workspace = true }
 lru_time_cache = "0.11"
-maybe-owned = "0.3.4"
 postgres = "0.19.1"
-openssl = "0.10.60"
-postgres-openssl = "0.5.0"
-rand = "0.8.4"
-serde = "1.0"
-uuid = { version = "1.6.1", features = ["v4"] }
-stable-hash_legacy = { git = "https://github.com/graphprotocol/stable-hash", branch = "old", package = "stable-hash" }
-diesel_derives = "1.4.1"
-anyhow = "1.0.75"
-git-testament = "0.2.5"
-itertools = "0.12.0"
-pin-utils = "0.1"
+openssl = { version = "0.10.80", features = ["vendored"] }
+postgres-openssl = "0.5.3"
+rand.workspace = true
+serde = { workspace = true }
+serde_json = { workspace = true }
+stable-hash_legacy = { git = "https://github.com/graphprotocol/stable-hash", rev = "42b85d936c6b9f1b7a4b8385d2f081d5564daa69", package = "stable-hash" }
+tokio = { workspace = true }
+tokio-stream = { workspace = true }
+anyhow = "1.0.102"
+git-testament = { workspace = true }
+itertools = "0.15.0"
 hex = "0.4.3"
-pretty_assertions = "1.4.0"
+pretty_assertions = "1.4.1"
+sqlparser = { workspace = true }
+thiserror = { workspace = true }
+serde_yaml.workspace = true
+arrow = { workspace = true }
+parquet = { workspace = true }
 
 [dev-dependencies]
-clap = "3.2.25"
-graphql-parser = "0.4.0"
+clap.workspace = true
+
+[lints]
+workspace = true
diff --git a/store/postgres/examples/create_index.rs b/store/postgres/examples/create_index.rs
new file mode 100644
index 00000000000..764c50d7ddb
--- /dev/null
+++ b/store/postgres/examples/create_index.rs
@@ -0,0 +1,74 @@
+use std::{collections::HashSet, env, fs, time::Instant};
+
+use graph::anyhow;
+use graph_store_postgres::command_support::index::{CreateIndex, Expr};
+
+/// Parse index definitions from a file and print information about any that
+/// we could not parse.
+///
+/// The easiest way to create a file with index definitions is to run this
+/// query in psql:
+/// ```sql
+/// select indexdef from pg_indexes where schemaname like 'sgd%' \g /tmp/idxs.txt
+/// ```
+pub fn main() -> anyhow::Result<()> {
+    let args: Vec<String> = env::args().collect();
+    if args.len() != 2 {
+        return Err(anyhow::anyhow!("usage: create_index <index_file>"));
+    }
+    let idxs = fs::read_to_string(&args[1])?;
+
+    let mut parsed: usize = 0;
+    let mut failed: usize = 0;
+    let mut skipped: usize = 0;
+    let mut unknown_cols = HashSet::new();
+    let start = Instant::now();
+    for idxdef in idxs.lines() {
+        let idxdef = idxdef.trim();
+        if idxdef.is_empty() || !idxdef.starts_with("CREATE") && !idxdef.starts_with("create") {
+            skipped += 1;
+            continue;
+        }
+
+        let idx = CreateIndex::parse(idxdef.to_string());
+
+        match &idx {
+            CreateIndex::Parsed { columns, .. } => {
+                let mut failed_col = false;
+                for column in columns {
+                    match column {
+                        Expr::Unknown(expr) => {
+                            unknown_cols.insert(expr.clone());
+                            failed_col = true;
+                            break;
+                        }
+                        _ => { /* ok  */ }
+                    }
+                }
+                if failed_col {
+                    failed += 1;
+                } else {
+                    parsed += 1
+                }
+            }
+            CreateIndex::Unknown { defn } => {
+                println!("Can not parse index definition: {}", defn);
+                failed += 1;
+            }
+        }
+    }
+
+    if !unknown_cols.is_empty() {
+        println!("Unknown columns:");
+        for col in unknown_cols {
+            println!("  {}", col);
+        }
+    }
+
+    println!(
+        "total: {}, parsed: {parsed}, failed: {failed}, skipped: {skipped}, elapsed: {}s",
+        parsed + failed + skipped,
+        start.elapsed().as_secs()
+    );
+    Ok(())
+}
diff --git a/store/postgres/examples/layout.rs b/store/postgres/examples/layout.rs
index 25bd1aab5a8..e7fde150fe9 100644
--- a/store/postgres/examples/layout.rs
+++ b/store/postgres/examples/layout.rs
@@ -1,7 +1,7 @@
 extern crate clap;
 extern crate graph_store_postgres;
 
-use clap::{arg, Command};
+use clap::{Parser, ValueEnum};
 use graph::schema::InputSchema;
 use std::collections::BTreeSet;
 use std::process::exit;
@@ -13,10 +13,32 @@ use graph_store_postgres::{
     layout_for_tests::make_dummy_site,
 };
 
-pub fn usage(msg: &str) -> ! {
-    println!("layout: {}", msg);
-    println!("Try 'layout --help' for more information.");
-    std::process::exit(1);
+/// The kind of SQL to generate from a GraphQL schema.
+#[derive(Clone, Copy, Debug, Default, ValueEnum)]
+enum Kind {
+    /// Generate the DDL to create the tables (the default).
+    #[default]
+    Ddl,
+    /// Generate `delete` statements for all tables.
+    Delete,
+    /// Generate `drop table` statements for all tables.
+    Drop,
+    /// Generate Diesel `table!` definitions and Rust structs.
+    Diesel,
+}
+
+/// Information about the database schema for a GraphQL schema
+#[derive(Parser, Debug)]
+#[command(name = "layout")]
+struct Opts {
+    /// What kind of SQL to generate.
+    #[arg(short, long, value_enum, default_value_t = Kind::Ddl)]
+    generate: Kind,
+    /// Path to the GraphQL schema file.
+    schema: String,
+    /// The database schema (namespace) to use.
+    #[arg(default_value = "subgraphs")]
+    db_schema: String,
 }
 
 pub fn ensure<T, E: std::fmt::Display>(res: Result<T, E>, msg: &str) -> T {
@@ -54,6 +76,7 @@ fn print_diesel_tables(layout: &Layout) {
             ColumnType::Bytes => "Binary",
             ColumnType::Int => "Integer",
             ColumnType::Int8 => "Int8",
+            ColumnType::Timestamp => "Timestamp",
             ColumnType::String | ColumnType::Enum(_) | ColumnType::TSVector(_) => "Text",
         }
         .to_owned();
@@ -75,6 +98,7 @@ fn print_diesel_tables(layout: &Layout) {
             ColumnType::Int => "i32",
             ColumnType::Int8 => "i64",
             ColumnType::String | ColumnType::Enum(_) | ColumnType::TSVector(_) => "String",
+            ColumnType::Timestamp => "Timestamp",
         }
         .to_owned();
 
@@ -125,28 +149,15 @@ fn print_diesel_tables(layout: &Layout) {
 }
 
 pub fn main() {
-    let args = Command::new("layout")
-    .version("1.0")
-    .about("Information about the database schema for a GraphQL schema")
-    .arg(arg!(-g --generate <KIND> "what kind of SQL to generate. Can be ddl (the default), migrate, delete, or drop"))
-    .arg(arg!(<schema>))
-    .arg(arg!(<db_schema>))
-    .get_matches();
-
-    let schema = args.get_one::<&str>("schema").unwrap();
-    let namespace = args.get_one::<&str>("db_schema").unwrap_or(&"subgraphs");
-    let kind = args.get_one::<&str>("generate").unwrap_or(&"ddl");
+    let opts = Opts::parse();
 
     let subgraph = DeploymentHash::new("Qmasubgraph").unwrap();
-    let schema = ensure(fs::read_to_string(schema), "Can not read schema file");
+    let schema = ensure(fs::read_to_string(&opts.schema), "Can not read schema file");
     let schema = ensure(
         InputSchema::parse_latest(&schema, subgraph.clone()),
         "Failed to parse schema",
     );
-    let namespace = ensure(
-        Namespace::new(namespace.to_string()),
-        "Invalid database schema",
-    );
+    let namespace = ensure(Namespace::new(opts.db_schema), "Invalid database schema");
     let site = Arc::new(make_dummy_site(subgraph, namespace, "anet".to_string()));
     let catalog = ensure(
         Catalog::for_tests(site.clone(), BTreeSet::new()),
@@ -156,13 +167,10 @@ pub fn main() {
         Layout::new(site, &schema, catalog),
         "Failed to construct Mapping",
     );
-    match *kind {
-        "drop" => print_drop(&layout),
-        "delete" => print_delete_all(&layout),
-        "ddl" => print_ddl(&layout),
-        "diesel" => print_diesel_tables(&layout),
-        _ => {
-            usage(&format!("illegal value {} for --generate", kind));
-        }
+    match opts.generate {
+        Kind::Drop => print_drop(&layout),
+        Kind::Delete => print_delete_all(&layout),
+        Kind::Ddl => print_ddl(&layout),
+        Kind::Diesel => print_diesel_tables(&layout),
     }
 }
diff --git a/store/postgres/migrations/2024-01-25-133200_change_health_column_format/down.sql b/store/postgres/migrations/2024-01-25-133200_change_health_column_format/down.sql
new file mode 100644
index 00000000000..a5c5231714f
--- /dev/null
+++ b/store/postgres/migrations/2024-01-25-133200_change_health_column_format/down.sql
@@ -0,0 +1,30 @@
+
+create type subgraphs."health"
+    as enum ('failed', 'healthy', 'unhealthy');
+
+alter table
+    subgraphs.subgraph_deployment
+add
+    column health_new subgraphs.health;
+
+update
+    subgraphs.subgraph_deployment
+set
+    health_new = health::subgraphs.health;
+
+alter table
+    subgraphs.subgraph_deployment
+drop column
+    health;
+
+alter table
+    subgraphs.subgraph_deployment
+rename column
+    health_new to health;
+
+alter table
+    subgraphs.subgraph_deployment
+alter column
+    health
+set
+    not null;
diff --git a/store/postgres/migrations/2024-01-25-133200_change_health_column_format/up.sql b/store/postgres/migrations/2024-01-25-133200_change_health_column_format/up.sql
new file mode 100644
index 00000000000..89d6242a146
--- /dev/null
+++ b/store/postgres/migrations/2024-01-25-133200_change_health_column_format/up.sql
@@ -0,0 +1,43 @@
+alter table
+    subgraphs.subgraph_deployment
+add
+    column if not exists health_new text not null default 'failed'
+        check (health_new in ('failed', 'healthy', 'unhealthy'));
+
+update
+    subgraphs.subgraph_deployment
+set
+    health_new = health;
+
+alter table
+    subgraphs.subgraph_deployment
+alter column
+    health_new drop default;
+
+alter table
+    subgraphs.subgraph_deployment
+drop column
+    health;
+
+alter table
+    subgraphs.subgraph_deployment
+rename column
+    health_new to health;
+
+-- Drop imported subgraph_deployment tables from other shards so that we
+-- can drop our local 'health' type
+-- graph-node startup will recreate the foreign table import
+do $$
+  declare r record;
+  begin
+    for r in select foreign_table_schema as nsp
+               from information_schema.foreign_tables
+              where foreign_table_schema like 'shard_%'
+                and foreign_table_name = 'subgraph_deployment'
+    loop
+      execute 'drop foreign table ' || r.nsp || '.subgraph_deployment';
+    end loop;
+  end
+$$;
+
+drop type subgraphs."health";
diff --git a/store/postgres/migrations/2024-02-06-002353_arg_minmax/down.sql b/store/postgres/migrations/2024-02-06-002353_arg_minmax/down.sql
new file mode 100644
index 00000000000..6752b8c957a
--- /dev/null
+++ b/store/postgres/migrations/2024-02-06-002353_arg_minmax/down.sql
@@ -0,0 +1,20 @@
+-- This file was generated by generate.sh in this directory
+set search_path = public;
+drop aggregate arg_min_int4(int4_and_value);
+drop aggregate arg_max_int4(int4_and_value);
+drop function arg_from_int4_and_value(int4_and_value);
+drop function arg_max_agg_int4(int4_and_value, int4_and_value);
+drop function arg_min_agg_int4(int4_and_value, int4_and_value);
+drop type int4_and_value;
+drop aggregate arg_min_int8(int8_and_value);
+drop aggregate arg_max_int8(int8_and_value);
+drop function arg_from_int8_and_value(int8_and_value);
+drop function arg_max_agg_int8(int8_and_value, int8_and_value);
+drop function arg_min_agg_int8(int8_and_value, int8_and_value);
+drop type int8_and_value;
+drop aggregate arg_min_numeric(numeric_and_value);
+drop aggregate arg_max_numeric(numeric_and_value);
+drop function arg_from_numeric_and_value(numeric_and_value);
+drop function arg_max_agg_numeric(numeric_and_value, numeric_and_value);
+drop function arg_min_agg_numeric(numeric_and_value, numeric_and_value);
+drop type numeric_and_value;
diff --git a/store/postgres/migrations/2024-02-06-002353_arg_minmax/generate.sh b/store/postgres/migrations/2024-02-06-002353_arg_minmax/generate.sh
new file mode 100755
index 00000000000..d320cf8f175
--- /dev/null
+++ b/store/postgres/migrations/2024-02-06-002353_arg_minmax/generate.sh
@@ -0,0 +1,98 @@
+#! /bin/bash
+
+# Generate up and down migrations to define arg_min and arg_max functions
+# for the types listed in `types`.
+#
+# The functions can all be used like
+#
+#     select first_int4((arg, value)) from t
+#
+# and return the `arg int4` for the smallest value `value int8`. If there
+# are several rows with the smallest value, we try hard to return the first
+# one, but that also depends on how Postgres calculates these
+# aggregations. Note that the relation over which we are aggregating does
+# not need to be ordered.
+#
+# Unfortunately, it is not possible to do this generically, so we have to
+# monomorphize and define an aggregate for each data type that we want to
+# use. The `value` is always an `int8`
+#
+# If changes to these functions are needed, copy this script to a new
+# migration, change it and regenerate the up and down migrations
+
+types="int4 int8 numeric"
+dir=$(dirname $0)
+
+read -d '' -r prelude <<'EOF'
+-- This file was generated by generate.sh in this directory
+set search_path = public;
+EOF
+
+read -d '' -r up_template <<'EOF'
+create type public.@T@_and_value as (
+  arg @T@,
+  value int8
+);
+
+create or replace function arg_min_agg_@T@ (a @T@_and_value, b @T@_and_value)
+  returns @T@_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value <= b.value then a
+             else b end';
+
+create or replace function arg_max_agg_@T@ (a @T@_and_value, b @T@_and_value)
+  returns @T@_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value > b.value then a
+             else b end';
+
+create function arg_from_@T@_and_value(a @T@_and_value)
+  returns @T@
+  language sql immutable strict parallel safe as
+'select a.arg';
+
+create aggregate arg_min_@T@ (@T@_and_value) (
+  sfunc    = arg_min_agg_@T@,
+  stype    = @T@_and_value,
+  finalfunc = arg_from_@T@_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_min_@T@(@T@_and_value) is
+'For ''select arg_min_@T@((arg, value)) from ..'' return the arg for the smallest value';
+
+create aggregate arg_max_@T@ (@T@_and_value) (
+  sfunc    = arg_max_agg_@T@,
+  stype    = @T@_and_value,
+  finalfunc = arg_from_@T@_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_max_@T@(@T@_and_value) is
+'For ''select arg_max_@T@((arg, value)) from ..'' return the arg for the largest value';
+EOF
+
+read -d '' -r down_template <<'EOF'
+drop aggregate arg_min_@T@(@T@_and_value);
+drop aggregate arg_max_@T@(@T@_and_value);
+drop function arg_from_@T@_and_value(@T@_and_value);
+drop function arg_max_agg_@T@(@T@_and_value, @T@_and_value);
+drop function arg_min_agg_@T@(@T@_and_value, @T@_and_value);
+drop type @T@_and_value;
+EOF
+
+echo "$prelude" > $dir/up.sql
+for typ in $types
+do
+    echo "${up_template//@T@/$typ}" >> $dir/up.sql
+done
+
+echo "$prelude" > $dir/down.sql
+for typ in $types
+do
+    echo "${down_template//@T@/$typ}" >> $dir/down.sql
+done
diff --git a/store/postgres/migrations/2024-02-06-002353_arg_minmax/up.sql b/store/postgres/migrations/2024-02-06-002353_arg_minmax/up.sql
new file mode 100644
index 00000000000..8b54b3b628f
--- /dev/null
+++ b/store/postgres/migrations/2024-02-06-002353_arg_minmax/up.sql
@@ -0,0 +1,137 @@
+-- This file was generated by generate.sh in this directory
+set search_path = public;
+create type public.int4_and_value as (
+  arg int4,
+  value int8
+);
+
+create or replace function arg_min_agg_int4 (a int4_and_value, b int4_and_value)
+  returns int4_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value <= b.value then a
+             else b end';
+
+create or replace function arg_max_agg_int4 (a int4_and_value, b int4_and_value)
+  returns int4_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value > b.value then a
+             else b end';
+
+create function arg_from_int4_and_value(a int4_and_value)
+  returns int4
+  language sql immutable strict parallel safe as
+'select a.arg';
+
+create aggregate arg_min_int4 (int4_and_value) (
+  sfunc    = arg_min_agg_int4,
+  stype    = int4_and_value,
+  finalfunc = arg_from_int4_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_min_int4(int4_and_value) is
+'For ''select arg_min_int4((arg, value)) from ..'' return the arg for the smallest value';
+
+create aggregate arg_max_int4 (int4_and_value) (
+  sfunc    = arg_max_agg_int4,
+  stype    = int4_and_value,
+  finalfunc = arg_from_int4_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_max_int4(int4_and_value) is
+'For ''select arg_max_int4((arg, value)) from ..'' return the arg for the largest value';
+create type public.int8_and_value as (
+  arg int8,
+  value int8
+);
+
+create or replace function arg_min_agg_int8 (a int8_and_value, b int8_and_value)
+  returns int8_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value <= b.value then a
+             else b end';
+
+create or replace function arg_max_agg_int8 (a int8_and_value, b int8_and_value)
+  returns int8_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value > b.value then a
+             else b end';
+
+create function arg_from_int8_and_value(a int8_and_value)
+  returns int8
+  language sql immutable strict parallel safe as
+'select a.arg';
+
+create aggregate arg_min_int8 (int8_and_value) (
+  sfunc    = arg_min_agg_int8,
+  stype    = int8_and_value,
+  finalfunc = arg_from_int8_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_min_int8(int8_and_value) is
+'For ''select arg_min_int8((arg, value)) from ..'' return the arg for the smallest value';
+
+create aggregate arg_max_int8 (int8_and_value) (
+  sfunc    = arg_max_agg_int8,
+  stype    = int8_and_value,
+  finalfunc = arg_from_int8_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_max_int8(int8_and_value) is
+'For ''select arg_max_int8((arg, value)) from ..'' return the arg for the largest value';
+create type public.numeric_and_value as (
+  arg numeric,
+  value int8
+);
+
+create or replace function arg_min_agg_numeric (a numeric_and_value, b numeric_and_value)
+  returns numeric_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value <= b.value then a
+             else b end';
+
+create or replace function arg_max_agg_numeric (a numeric_and_value, b numeric_and_value)
+  returns numeric_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value > b.value then a
+             else b end';
+
+create function arg_from_numeric_and_value(a numeric_and_value)
+  returns numeric
+  language sql immutable strict parallel safe as
+'select a.arg';
+
+create aggregate arg_min_numeric (numeric_and_value) (
+  sfunc    = arg_min_agg_numeric,
+  stype    = numeric_and_value,
+  finalfunc = arg_from_numeric_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_min_numeric(numeric_and_value) is
+'For ''select arg_min_numeric((arg, value)) from ..'' return the arg for the smallest value';
+
+create aggregate arg_max_numeric (numeric_and_value) (
+  sfunc    = arg_max_agg_numeric,
+  stype    = numeric_and_value,
+  finalfunc = arg_from_numeric_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_max_numeric(numeric_and_value) is
+'For ''select arg_max_numeric((arg, value)) from ..'' return the arg for the largest value';
diff --git a/store/postgres/migrations/2024-06-11-084227_track-more-features-in-subgraph-features/down.sql b/store/postgres/migrations/2024-06-11-084227_track-more-features-in-subgraph-features/down.sql
new file mode 100644
index 00000000000..8cf6518712d
--- /dev/null
+++ b/store/postgres/migrations/2024-06-11-084227_track-more-features-in-subgraph-features/down.sql
@@ -0,0 +1,5 @@
+ALTER TABLE subgraphs.subgraph_features
+  DROP COLUMN IF EXISTS has_declared_calls,
+  DROP COLUMN IF EXISTS has_bytes_as_ids,
+  DROP COLUMN IF EXISTS has_aggregations,
+  DROP COLUMN IF EXISTS immutable_entities;
\ No newline at end of file
diff --git a/store/postgres/migrations/2024-06-11-084227_track-more-features-in-subgraph-features/up.sql b/store/postgres/migrations/2024-06-11-084227_track-more-features-in-subgraph-features/up.sql
new file mode 100644
index 00000000000..e61ebe27c06
--- /dev/null
+++ b/store/postgres/migrations/2024-06-11-084227_track-more-features-in-subgraph-features/up.sql
@@ -0,0 +1,6 @@
+TRUNCATE TABLE subgraphs.subgraph_features;
+ALTER TABLE subgraphs.subgraph_features
+  ADD COLUMN IF NOT EXISTS has_declared_calls BOOLEAN NOT NULL DEFAULT FALSE,
+  ADD COLUMN IF NOT EXISTS has_bytes_as_ids BOOLEAN NOT NULL DEFAULT FALSE,
+  ADD COLUMN IF NOT EXISTS has_aggregations BOOLEAN NOT NULL DEFAULT FALSE,
+  ADD COLUMN IF NOT EXISTS immutable_entities TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[];
\ No newline at end of file
diff --git a/store/postgres/migrations/2024-07-22-140930_track_synced_date/down.sql b/store/postgres/migrations/2024-07-22-140930_track_synced_date/down.sql
new file mode 100644
index 00000000000..fb6e7f2efc6
--- /dev/null
+++ b/store/postgres/migrations/2024-07-22-140930_track_synced_date/down.sql
@@ -0,0 +1,32 @@
+DROP VIEW info.subgraph_info;
+
+ALTER TABLE subgraphs.subgraph_deployment ADD COLUMN synced BOOLEAN NOT NULL DEFAULT false;
+ALTER TABLE unused_deployments            ADD COLUMN synced BOOLEAN NOT NULL DEFAULT false;
+
+UPDATE subgraphs.subgraph_deployment SET synced = synced_at IS NOT NULL;
+UPDATE unused_deployments            SET synced = synced_at IS NOT NULL;
+
+-- NB: We keep the default on unused_deployment, as it was there before.
+ALTER TABLE subgraphs.subgraph_deployment ALTER COLUMN synced DROP DEFAULT;
+
+ALTER TABLE subgraphs.subgraph_deployment DROP COLUMN synced_at;
+ALTER TABLE unused_deployments            DROP COLUMN synced_at;
+
+CREATE VIEW info.subgraph_info AS
+SELECT ds.id AS schema_id,
+    ds.name AS schema_name,
+    ds.subgraph,
+    ds.version,
+    s.name,
+        CASE
+            WHEN s.pending_version = v.id THEN 'pending'::text
+            WHEN s.current_version = v.id THEN 'current'::text
+            ELSE 'unused'::text
+        END AS status,
+    d.failed,
+    d.synced
+   FROM deployment_schemas ds,
+    subgraphs.subgraph_deployment d,
+    subgraphs.subgraph_version v,
+    subgraphs.subgraph s
+  WHERE d.deployment = ds.subgraph::text AND v.deployment = d.deployment AND v.subgraph = s.id;
diff --git a/store/postgres/migrations/2024-07-22-140930_track_synced_date/up.sql b/store/postgres/migrations/2024-07-22-140930_track_synced_date/up.sql
new file mode 100644
index 00000000000..13b97539f84
--- /dev/null
+++ b/store/postgres/migrations/2024-07-22-140930_track_synced_date/up.sql
@@ -0,0 +1,29 @@
+DROP VIEW info.subgraph_info;
+
+ALTER TABLE subgraphs.subgraph_deployment ADD COLUMN synced_at TIMESTAMPTZ;
+ALTER TABLE unused_deployments            ADD COLUMN synced_at TIMESTAMPTZ;
+
+UPDATE subgraphs.subgraph_deployment SET synced_at = '1970-01-01 00:00:00 UTC' WHERE synced;
+UPDATE unused_deployments            SET synced_at = '1970-01-01 00:00:00 UTC' WHERE synced;
+
+ALTER TABLE subgraphs.subgraph_deployment DROP COLUMN synced;
+ALTER TABLE unused_deployments            DROP COLUMN synced;
+
+CREATE VIEW info.subgraph_info AS
+SELECT ds.id AS schema_id,
+    ds.name AS schema_name,
+    ds.subgraph,
+    ds.version,
+    s.name,
+        CASE
+            WHEN s.pending_version = v.id THEN 'pending'::text
+            WHEN s.current_version = v.id THEN 'current'::text
+            ELSE 'unused'::text
+        END AS status,
+    d.failed,
+    d.synced_at
+   FROM deployment_schemas ds,
+    subgraphs.subgraph_deployment d,
+    subgraphs.subgraph_version v,
+    subgraphs.subgraph s
+  WHERE d.deployment = ds.subgraph::text AND v.deployment = d.deployment AND v.subgraph = s.id;
diff --git a/store/postgres/migrations/2024-08-14-205601_store_synced_at_block/down.sql b/store/postgres/migrations/2024-08-14-205601_store_synced_at_block/down.sql
new file mode 100644
index 00000000000..5229dc8f425
--- /dev/null
+++ b/store/postgres/migrations/2024-08-14-205601_store_synced_at_block/down.sql
@@ -0,0 +1,2 @@
+ALTER TABLE subgraphs.subgraph_deployment DROP COLUMN synced_at_block_number;
+ALTER TABLE unused_deployments            DROP COLUMN synced_at_block_number;
diff --git a/store/postgres/migrations/2024-08-14-205601_store_synced_at_block/up.sql b/store/postgres/migrations/2024-08-14-205601_store_synced_at_block/up.sql
new file mode 100644
index 00000000000..8f5dcaffe4c
--- /dev/null
+++ b/store/postgres/migrations/2024-08-14-205601_store_synced_at_block/up.sql
@@ -0,0 +1,2 @@
+ALTER TABLE subgraphs.subgraph_deployment ADD COLUMN synced_at_block_number INT4;
+ALTER TABLE unused_deployments            ADD COLUMN synced_at_block_number INT4;
diff --git a/store/postgres/migrations/2024-10-01-100427_create_graphman_command_executions_table/down.sql b/store/postgres/migrations/2024-10-01-100427_create_graphman_command_executions_table/down.sql
new file mode 100644
index 00000000000..88eb516c367
--- /dev/null
+++ b/store/postgres/migrations/2024-10-01-100427_create_graphman_command_executions_table/down.sql
@@ -0,0 +1 @@
+drop table public.graphman_command_executions;
diff --git a/store/postgres/migrations/2024-10-01-100427_create_graphman_command_executions_table/up.sql b/store/postgres/migrations/2024-10-01-100427_create_graphman_command_executions_table/up.sql
new file mode 100644
index 00000000000..ab9a1b16eb1
--- /dev/null
+++ b/store/postgres/migrations/2024-10-01-100427_create_graphman_command_executions_table/up.sql
@@ -0,0 +1,10 @@
+create table public.graphman_command_executions
+(
+    id            bigserial primary key,
+    kind          varchar                  not null check (kind in ('restart_deployment')),
+    status        varchar                  not null check (status in ('initializing', 'running', 'failed', 'succeeded')),
+    error_message varchar                  default null,
+    created_at    timestamp with time zone not null,
+    updated_at    timestamp with time zone default null,
+    completed_at  timestamp with time zone default null
+);
diff --git a/store/postgres/migrations/2025-04-08-224710_add_prune_state/down.sql b/store/postgres/migrations/2025-04-08-224710_add_prune_state/down.sql
new file mode 100644
index 00000000000..324bc18f154
--- /dev/null
+++ b/store/postgres/migrations/2025-04-08-224710_add_prune_state/down.sql
@@ -0,0 +1,2 @@
+drop table subgraphs.prune_table_state;
+drop table subgraphs.prune_state;
diff --git a/store/postgres/migrations/2025-04-08-224710_add_prune_state/up.sql b/store/postgres/migrations/2025-04-08-224710_add_prune_state/up.sql
new file mode 100644
index 00000000000..8c767ed7384
--- /dev/null
+++ b/store/postgres/migrations/2025-04-08-224710_add_prune_state/up.sql
@@ -0,0 +1,60 @@
+create table subgraphs.prune_state(
+  -- diesel can't deal with composite primary keys
+  vid            int primary key
+                     generated always as identity,
+
+  -- id of the deployment
+  id             int not null,
+  -- how many times the deployment has been pruned
+  run            int not null,
+
+  -- from PruneRequest
+  first_block    int not null,
+  final_block    int not null,
+  latest_block   int not null,
+  history_blocks int not null,
+
+  started_at     timestamptz not null,
+  finished_at    timestamptz,
+
+  constraint prune_state_id_run_uq unique(id, run)
+);
+
+create table subgraphs.prune_table_state(
+  -- diesel can't deal with composite primary keys
+  vid            int primary key
+                     generated always as identity,
+
+  id             int not null,
+  run            int not null,
+  table_name     text not null,
+  -- 'r' (rebuild) or 'd' (delete)
+  strategy       char not null,
+  phase          text not null,
+
+  start_vid      int8,
+  final_vid      int8,
+  nonfinal_vid   int8,
+  rows           int8,
+
+  next_vid       int8,
+  batch_size     int8,
+
+  started_at     timestamptz,
+  finished_at    timestamptz,
+
+  constraint prune_table_state_id_run_table_name_uq
+    unique(id, run, table_name),
+
+  constraint prune_table_state_strategy_ck
+    check(strategy in ('r', 'd')),
+
+  constraint prune_table_state_phase_ck
+    check(phase in ('queued', 'started', 'copy_final',
+                    'copy_nonfinal', 'delete', 'done')),
+
+  constraint prune_table_state_id_run_fk
+    foreign key(id, run)
+    references subgraphs.prune_state(id, run)
+    on delete cascade
+);
diff --git a/store/postgres/migrations/2025-04-25-163121_prune_error/down.sql b/store/postgres/migrations/2025-04-25-163121_prune_error/down.sql
new file mode 100644
index 00000000000..02c16447136
--- /dev/null
+++ b/store/postgres/migrations/2025-04-25-163121_prune_error/down.sql
@@ -0,0 +1,3 @@
+alter table subgraphs.prune_state
+  drop column errored_at,
+  drop column error;
diff --git a/store/postgres/migrations/2025-04-25-163121_prune_error/up.sql b/store/postgres/migrations/2025-04-25-163121_prune_error/up.sql
new file mode 100644
index 00000000000..39e12cd3508
--- /dev/null
+++ b/store/postgres/migrations/2025-04-25-163121_prune_error/up.sql
@@ -0,0 +1,4 @@
+alter table subgraphs.prune_state
+  add column errored_at timestamptz,
+  add column error text,
+  add constraint error_ck check ((errored_at is null) = (error is null));
diff --git a/store/postgres/migrations/2025-05-13-173523_split_subgraph_deployment/down.sql b/store/postgres/migrations/2025-05-13-173523_split_subgraph_deployment/down.sql
new file mode 100644
index 00000000000..94747c907b6
--- /dev/null
+++ b/store/postgres/migrations/2025-05-13-173523_split_subgraph_deployment/down.sql
@@ -0,0 +1,110 @@
+create table subgraphs.subgraph_deployment (
+    id int4 primary key,
+
+    deployment text unique not null,
+
+    latest_ethereum_block_hash bytea,
+    latest_ethereum_block_number numeric,
+    entity_count numeric NOT NULL,
+    firehose_cursor text,
+
+    earliest_block_number integer DEFAULT 0 NOT NULL,
+
+    graft_base text,
+    graft_block_hash bytea,
+    graft_block_number numeric,
+
+    health text NOT NULL,
+    failed boolean NOT NULL,
+    fatal_error text,
+    non_fatal_errors text[] DEFAULT '{}'::text[],
+
+    reorg_count integer DEFAULT 0 NOT NULL,
+    current_reorg_depth integer DEFAULT 0 NOT NULL,
+    max_reorg_depth integer DEFAULT 0 NOT NULL,
+
+    last_healthy_ethereum_block_hash bytea,
+    last_healthy_ethereum_block_number numeric,
+
+    debug_fork text,
+
+    synced_at timestamp with time zone,
+    synced_at_block_number integer,
+
+    constraint subgraph_deployment_health_new_check
+      check ((health = any (array['failed', 'healthy', 'unhealthy'])))
+);
+
+insert into subgraphs.subgraph_deployment
+ (id, deployment,
+  latest_ethereum_block_hash, latest_ethereum_block_number,
+  entity_count, firehose_cursor,
+  earliest_block_number,
+  graft_base, graft_block_hash, graft_block_number,
+  health, failed, fatal_error, non_fatal_errors,
+  reorg_count, current_reorg_depth, max_reorg_depth,
+  last_healthy_ethereum_block_hash, last_healthy_ethereum_block_number,
+  debug_fork,
+  synced_at, synced_at_block_number)
+select h.id, d.subgraph,
+  h.block_hash, h.block_number,
+  h.entity_count, h.firehose_cursor,
+  earliest_block_number,
+  graft_base, graft_block_hash, graft_block_number,
+  health, failed, fatal_error, non_fatal_errors,
+  reorg_count, current_reorg_depth, max_reorg_depth,
+  last_healthy_block_hash, last_healthy_block_number,
+  debug_fork,
+  synced_at, synced_at_block_number
+  from subgraphs.head h, subgraphs.deployment d
+ where h.id = d.id;
+
+alter table subgraphs.copy_state
+ drop constraint copy_state_dst_fkey,
+  add constraint copy_state_dst_fkey
+      foreign key (dst) references
+      subgraphs.subgraph_deployment(id) on delete cascade;
+
+alter table subgraphs.subgraph_error
+ drop constraint subgraph_error_subgraph_id_fkey,
+  add constraint subgraph_error_subgraph_id_fkey
+      foreign key (subgraph_id) references
+      subgraphs.subgraph_deployment(deployment) on delete cascade;
+
+alter table subgraphs.subgraph_manifest
+ drop constraint subgraph_manifest_id_fkey,
+  add constraint subgraph_manifest_new_id_fkey
+      foreign key (id) references
+      subgraphs.subgraph_deployment(id) on delete cascade;
+
+alter table subgraphs.table_stats
+ drop constraint table_stats_deployment_fkey,
+  add constraint table_stats_deployment_fkey
+      foreign key (deployment) references
+      subgraphs.subgraph_deployment(id) on delete cascade;
+
+drop view info.subgraph_info;
+
+create view info.subgraph_info as
+select ds.id AS schema_id,
+       ds.name AS schema_name,
+       ds.subgraph,
+       ds.version,
+       s.name,
+           CASE
+               WHEN s.pending_version = v.id THEN 'pending'::text
+               WHEN s.current_version = v.id THEN 'current'::text
+               ELSE 'unused'::text
+           END AS status,
+       d.failed,
+       d.synced_at
+  from deployment_schemas ds,
+       subgraphs.subgraph_deployment d,
+       subgraphs.subgraph_version v,
+       subgraphs.subgraph s
+  where d.id = ds.id
+    and v.deployment = d.deployment
+    and v.subgraph = s.id;
+
+drop table subgraphs.deployment;
+drop table subgraphs.head;
diff --git a/store/postgres/migrations/2025-05-13-173523_split_subgraph_deployment/up.sql b/store/postgres/migrations/2025-05-13-173523_split_subgraph_deployment/up.sql
new file mode 100644
index 00000000000..c67b0f83417
--- /dev/null
+++ b/store/postgres/migrations/2025-05-13-173523_split_subgraph_deployment/up.sql
@@ -0,0 +1,125 @@
+
+-- Grab locks on all tables we are going to touch; otherwise, concurrently
+-- running operations might cause deadlocks
+lock table subgraphs.subgraph_deployment in access exclusive mode;
+lock table subgraphs.subgraph_manifest  in access exclusive mode;
+lock table subgraphs.subgraph_error in access exclusive mode;
+lock table subgraphs.table_stats in access exclusive mode;
+lock table subgraphs.copy_state in access exclusive mode;
+
+create table subgraphs.head (
+    id                    int4 primary key,
+    entity_count          int8 not null,
+    block_number          int4,
+    block_hash            bytea,
+    firehose_cursor       text
+);
+
+create table subgraphs.deployment (
+    id                        int4 primary key,
+
+    subgraph                text unique not null,
+
+    earliest_block_number     int4 default 0 not null,
+
+    health                    text not null,
+    failed                    boolean not null,
+    fatal_error               text,
+    non_fatal_errors          text[] default '{}'::text[],
+
+    graft_base                text,
+    graft_block_hash          bytea,
+    graft_block_number        int4,
+
+    reorg_count               int4 default 0 not null,
+    current_reorg_depth       int4 default 0 not null,
+    max_reorg_depth           int4 default 0 not null,
+
+    last_healthy_block_hash   bytea,
+    last_healthy_block_number int4,
+
+    debug_fork                text,
+
+    synced_at                 timestamptz,
+    synced_at_block_number    int4,
+
+    constraint deployment_health_new_check
+      check ((health = any (array['failed', 'healthy', 'unhealthy']))),
+    constraint deployment_id
+      foreign key (id) references subgraphs.head(id) on delete cascade
+);
+
+insert into subgraphs.head
+  (id, block_hash, block_number, entity_count, firehose_cursor)
+select id, latest_ethereum_block_hash,
+       latest_ethereum_block_number, entity_count, firehose_cursor
+  from subgraphs.subgraph_deployment;
+
+insert into subgraphs.deployment
+  (id, subgraph, failed, graft_base, graft_block_hash, graft_block_number,
+   fatal_error, non_fatal_errors, reorg_count, current_reorg_depth,
+   max_reorg_depth,
+   last_healthy_block_hash, last_healthy_block_number,
+   debug_fork, earliest_block_number,
+   health,
+   synced_at, synced_at_block_number)
+select
+   id, deployment, failed, graft_base, graft_block_hash, graft_block_number,
+   fatal_error, non_fatal_errors, reorg_count, current_reorg_depth,
+   max_reorg_depth,
+   last_healthy_ethereum_block_hash, last_healthy_ethereum_block_number,
+   debug_fork, earliest_block_number,
+   health,
+   synced_at, synced_at_block_number
+from subgraphs.subgraph_deployment;
+
+-- Support joining with subgraph_error
+create index deployment_fatal_error
+    on subgraphs.deployment(fatal_error);
+
+alter table subgraphs.copy_state
+ drop constraint copy_state_dst_fkey,
+  add constraint copy_state_dst_fkey
+      foreign key (dst) references subgraphs.deployment(id) on delete cascade;
+
+alter table subgraphs.subgraph_error
+ drop constraint subgraph_error_subgraph_id_fkey,
+  add constraint subgraph_error_subgraph_id_fkey
+      foreign key (subgraph_id) references
+      subgraphs.deployment(subgraph) on delete cascade;
+
+alter table subgraphs.subgraph_manifest
+ drop constraint subgraph_manifest_new_id_fkey,
+  add constraint subgraph_manifest_id_fkey
+      foreign key (id) references subgraphs.deployment(id) on delete cascade;
+
+alter table subgraphs.table_stats
+ drop constraint table_stats_deployment_fkey,
+  add constraint table_stats_deployment_fkey
+      foreign key (deployment) references subgraphs.deployment(id)
+      on delete cascade;
+
+drop view info.subgraph_info;
+
+drop table subgraphs.subgraph_deployment;
+
+create view info.subgraph_info as
+select ds.id as schema_id,
+       ds.name as schema_name,
+       ds.subgraph,
+       ds.version,
+       s.name,
+        CASE
+            WHEN s.pending_version = v.id THEN 'pending'
+            WHEN s.current_version = v.id THEN 'current'
+            ELSE 'unused'
+        END AS status,
+       d.failed,
+       d.synced_at
+  from deployment_schemas ds,
+       subgraphs.deployment d,
+       subgraphs.subgraph_version v,
+       subgraphs.subgraph s
+ where d.id = ds.id
+   and v.deployment = d.subgraph
+   and v.subgraph = s.id;
diff --git a/store/postgres/migrations/2025-12-18-104956-0000_create_entity_version_stats_view/down.sql b/store/postgres/migrations/2025-12-18-104956-0000_create_entity_version_stats_view/down.sql
new file mode 100644
index 00000000000..de9525fbbd6
--- /dev/null
+++ b/store/postgres/migrations/2025-12-18-104956-0000_create_entity_version_stats_view/down.sql
@@ -0,0 +1 @@
+DROP MATERIALIZED VIEW IF EXISTS info.entity_version_stats;
diff --git a/store/postgres/migrations/2025-12-18-104956-0000_create_entity_version_stats_view/up.sql b/store/postgres/migrations/2025-12-18-104956-0000_create_entity_version_stats_view/up.sql
new file mode 100644
index 00000000000..970ed9ee7d7
--- /dev/null
+++ b/store/postgres/migrations/2025-12-18-104956-0000_create_entity_version_stats_view/up.sql
@@ -0,0 +1,35 @@
+CREATE MATERIALIZED VIEW info.entity_version_stats AS
+WITH table_info AS (
+    SELECT
+        s.schemaname AS schema_name,
+        sd.id        AS deployment_id,
+        sd.subgraph  AS subgraph,
+        s.tablename  AS table_name,
+        c.reltuples  AS total_row_count,
+        s.n_distinct AS n_distinct
+    FROM pg_stats s
+    JOIN pg_namespace n ON n.nspname = s.schemaname
+    JOIN pg_class c ON c.relnamespace = n.oid AND c.relname = s.tablename
+    JOIN subgraphs.deployment sd ON sd.id::text = substring(s.schemaname, 4)
+    WHERE
+        s.attname   = 'id'
+        AND s.schemaname LIKE 'sgd%'
+        AND c.relname NOT IN ('poi2$', 'data_sources$')
+)
+SELECT
+    schema_name,
+    deployment_id AS deployment,
+    subgraph,
+    table_name,
+    CASE
+        WHEN n_distinct < 0 THEN (-n_distinct) * total_row_count
+        ELSE n_distinct
+    END::bigint AS entities,
+    total_row_count::bigint AS versions,
+    CASE
+        WHEN total_row_count = 0 THEN 0::float8
+        WHEN n_distinct < 0 THEN (-n_distinct)::float8
+        ELSE n_distinct::numeric / total_row_count::numeric
+    END AS ratio
+FROM table_info
+WITH NO DATA;
diff --git a/store/postgres/migrations/2026-01-09-164812_extend_arg_min_max/down.sql b/store/postgres/migrations/2026-01-09-164812_extend_arg_min_max/down.sql
new file mode 100644
index 00000000000..90de2623327
--- /dev/null
+++ b/store/postgres/migrations/2026-01-09-164812_extend_arg_min_max/down.sql
@@ -0,0 +1,14 @@
+-- This file was generated by generate.sh in this directory
+set search_path = public;
+drop aggregate arg_min_text(text_and_value);
+drop aggregate arg_max_text(text_and_value);
+drop function arg_from_text_and_value(text_and_value);
+drop function arg_max_agg_text(text_and_value, text_and_value);
+drop function arg_min_agg_text(text_and_value, text_and_value);
+drop type text_and_value;
+drop aggregate arg_min_bytea(bytea_and_value);
+drop aggregate arg_max_bytea(bytea_and_value);
+drop function arg_from_bytea_and_value(bytea_and_value);
+drop function arg_max_agg_bytea(bytea_and_value, bytea_and_value);
+drop function arg_min_agg_bytea(bytea_and_value, bytea_and_value);
+drop type bytea_and_value;
diff --git a/store/postgres/migrations/2026-01-09-164812_extend_arg_min_max/up.sql b/store/postgres/migrations/2026-01-09-164812_extend_arg_min_max/up.sql
new file mode 100644
index 00000000000..fc9474011dd
--- /dev/null
+++ b/store/postgres/migrations/2026-01-09-164812_extend_arg_min_max/up.sql
@@ -0,0 +1,92 @@
+-- This file was generated by generate.sh in this directory
+set search_path = public;
+create type public.text_and_value as (
+  arg text,
+  value int8
+);
+
+create or replace function arg_min_agg_text (a text_and_value, b text_and_value)
+  returns text_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value <= b.value then a
+             else b end';
+
+create or replace function arg_max_agg_text (a text_and_value, b text_and_value)
+  returns text_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value > b.value then a
+             else b end';
+
+create function arg_from_text_and_value(a text_and_value)
+  returns text
+  language sql immutable strict parallel safe as
+'select a.arg';
+
+create aggregate arg_min_text (text_and_value) (
+  sfunc    = arg_min_agg_text,
+  stype    = text_and_value,
+  finalfunc = arg_from_text_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_min_text(text_and_value) is
+'For ''select arg_min_text((arg, value)) from ..'' return the arg for the smallest value';
+
+create aggregate arg_max_text (text_and_value) (
+  sfunc    = arg_max_agg_text,
+  stype    = text_and_value,
+  finalfunc = arg_from_text_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_max_text(text_and_value) is
+'For ''select arg_max_text((arg, value)) from ..'' return the arg for the largest value';
+create type public.bytea_and_value as (
+  arg bytea,
+  value int8
+);
+
+create or replace function arg_min_agg_bytea (a bytea_and_value, b bytea_and_value)
+  returns bytea_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value <= b.value then a
+             else b end';
+
+create or replace function arg_max_agg_bytea (a bytea_and_value, b bytea_and_value)
+  returns bytea_and_value
+  language sql immutable strict parallel safe as
+'select case when a.arg is null then b
+             when b.arg is null then a
+             when a.value > b.value then a
+             else b end';
+
+create function arg_from_bytea_and_value(a bytea_and_value)
+  returns bytea
+  language sql immutable strict parallel safe as
+'select a.arg';
+
+create aggregate arg_min_bytea (bytea_and_value) (
+  sfunc    = arg_min_agg_bytea,
+  stype    = bytea_and_value,
+  finalfunc = arg_from_bytea_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_min_bytea(bytea_and_value) is
+'For ''select arg_min_bytea((arg, value)) from ..'' return the arg for the smallest value';
+
+create aggregate arg_max_bytea (bytea_and_value) (
+  sfunc    = arg_max_agg_bytea,
+  stype    = bytea_and_value,
+  finalfunc = arg_from_bytea_and_value,
+  parallel = safe
+);
+
+comment on aggregate arg_max_bytea(bytea_and_value) is
+'For ''select arg_max_bytea((arg, value)) from ..'' return the arg for the largest value';
diff --git a/store/postgres/migrations/2026-05-27-171745_postponed_indexes_created/down.sql b/store/postgres/migrations/2026-05-27-171745_postponed_indexes_created/down.sql
new file mode 100644
index 00000000000..a7b4a25623e
--- /dev/null
+++ b/store/postgres/migrations/2026-05-27-171745_postponed_indexes_created/down.sql
@@ -0,0 +1 @@
+ALTER TABLE subgraphs.deployment DROP COLUMN postponed_indexes_created;
diff --git a/store/postgres/migrations/2026-05-27-171745_postponed_indexes_created/up.sql b/store/postgres/migrations/2026-05-27-171745_postponed_indexes_created/up.sql
new file mode 100644
index 00000000000..34b4f512fda
--- /dev/null
+++ b/store/postgres/migrations/2026-05-27-171745_postponed_indexes_created/up.sql
@@ -0,0 +1,8 @@
+ALTER TABLE subgraphs.deployment
+    ADD COLUMN postponed_indexes_created BOOLEAN NOT NULL DEFAULT FALSE;
+
+-- Existing synced deployments already had their postponed indexes created
+-- eagerly under the old code path; mark them done so we don't try again.
+UPDATE subgraphs.deployment
+    SET postponed_indexes_created = TRUE
+    WHERE synced_at IS NOT NULL;
diff --git a/store/postgres/src/advisory_lock.rs b/store/postgres/src/advisory_lock.rs
index 9a1091b782c..6e9b9fbf0ac 100644
--- a/store/postgres/src/advisory_lock.rs
+++ b/store/postgres/src/advisory_lock.rs
@@ -6,18 +6,18 @@
 //! has more details on advisory locks.
 //!
 //! We use the following 64 bit locks:
-//!   * 1,2: to synchronize on migratons
+//!   * 1: to synchronize on migratons
 //!
 //! We use the following 2x 32-bit locks
-//!   * 1, n: to lock copying of the deployment with id n in the destination
-//!           shard
-//!   * 2, n: to lock the deployment with id n to make sure only one write
-//!           happens to it
+//!   * 1, n: to lock copying of the deployment with id n in the destination shard
+//!   * 2, n: to lock the deployment with id n to make sure only one write happens to it
 
+use diesel::sql_query;
 use diesel::sql_types::Bool;
-use diesel::{sql_query, PgConnection, RunQueryDsl};
+use diesel_async::RunQueryDsl;
 use graph::prelude::StoreError;
 
+use crate::AsyncPgConnection;
 use crate::command_support::catalog::Site;
 use crate::primary::DeploymentId;
 
@@ -31,10 +31,14 @@ struct Scope {
 impl Scope {
     /// Try to lock the deployment in this scope with the given id. Return
     /// `true` if we got the lock, and `false` if it is already locked.
-    fn try_lock(&self, conn: &PgConnection, id: DeploymentId) -> Result<bool, StoreError> {
+    async fn try_lock(
+        &self,
+        conn: &mut AsyncPgConnection,
+        id: DeploymentId,
+    ) -> Result<bool, StoreError> {
         #[derive(QueryableByName)]
         struct Locked {
-            #[sql_type = "Bool"]
+            #[diesel(sql_type = Bool)]
             locked: bool,
         }
 
@@ -43,23 +47,30 @@ impl Scope {
             self.id
         ))
         .get_result::<Locked>(conn)
+        .await
         .map(|res| res.locked)
         .map_err(StoreError::from)
     }
 
     /// Lock the deployment in this scope with the given id. Blocks until we
     /// can get the lock
-    fn lock(&self, conn: &PgConnection, id: DeploymentId) -> Result<(), StoreError> {
+    async fn lock(&self, conn: &mut AsyncPgConnection, id: DeploymentId) -> Result<(), StoreError> {
         sql_query(format!("select pg_advisory_lock({}, {id})", self.id))
             .execute(conn)
+            .await
             .map(|_| ())
             .map_err(StoreError::from)
     }
 
     /// Unlock the deployment in this scope with the given id.
-    fn unlock(&self, conn: &PgConnection, id: DeploymentId) -> Result<(), StoreError> {
+    async fn unlock(
+        &self,
+        conn: &mut AsyncPgConnection,
+        id: DeploymentId,
+    ) -> Result<(), StoreError> {
         sql_query(format!("select pg_advisory_unlock({}, {id})", self.id))
             .execute(conn)
+            .await
             .map(|_| ())
             .map_err(StoreError::from)
     }
@@ -69,55 +80,89 @@ const COPY: Scope = Scope { id: 1 };
 const WRITE: Scope = Scope { id: 2 };
 const PRUNE: Scope = Scope { id: 3 };
 
-/// Get a lock for running migrations. Blocks until we get the lock.
-pub(crate) fn lock_migration(conn: &PgConnection) -> Result<(), StoreError> {
-    sql_query("select pg_advisory_lock(1)").execute(conn)?;
+/// Block until we can get the migration lock, then run `f` and unlock when
+/// it is done. This is used to make sure that only one node runs setup at a
+/// time.
+pub(crate) async fn with_migration_lock<F, Fut, R>(
+    conn: &mut AsyncPgConnection,
+    f: F,
+) -> Result<R, StoreError>
+where
+    F: FnOnce(&mut AsyncPgConnection) -> Fut,
+    Fut: std::future::Future<Output = Result<R, StoreError>>,
+{
+    async fn execute(
+        conn: &mut AsyncPgConnection,
+        query: &str,
+        msg: &str,
+    ) -> Result<(), StoreError> {
+        sql_query(query)
+            .execute(conn)
+            .await
+            .map(|_| ())
+            .map_err(|e| {
+                StoreError::from_diesel_error(&e)
+                    .unwrap_or_else(|| StoreError::Unknown(anyhow::anyhow!("{}: {}", msg, e)))
+            })
+    }
 
-    Ok(())
-}
+    const LOCK: &str = "select pg_advisory_lock(1)";
+    const UNLOCK: &str = "select pg_advisory_unlock(1)";
 
-/// Release the migration lock.
-pub(crate) fn unlock_migration(conn: &PgConnection) -> Result<(), StoreError> {
-    sql_query("select pg_advisory_unlock(1)").execute(conn)?;
-    Ok(())
+    execute(conn, LOCK, "failed to acquire migration lock").await?;
+    let res = f(conn).await;
+    execute(conn, UNLOCK, "failed to release migration lock").await?;
+    res
 }
 
 /// Take the lock used to keep two copy operations to run simultaneously on
 /// the same deployment. Block until we can get the lock
-pub(crate) fn lock_copying(conn: &PgConnection, dst: &Site) -> Result<(), StoreError> {
-    COPY.lock(conn, dst.id)
+pub(crate) async fn lock_copying(
+    conn: &mut AsyncPgConnection,
+    dst: &Site,
+) -> Result<(), StoreError> {
+    COPY.lock(conn, dst.id).await
 }
 
 /// Release the lock acquired with `lock_copying`.
-pub(crate) fn unlock_copying(conn: &PgConnection, dst: &Site) -> Result<(), StoreError> {
-    COPY.unlock(conn, dst.id)
+pub(crate) async fn unlock_copying(
+    conn: &mut AsyncPgConnection,
+    dst: &Site,
+) -> Result<(), StoreError> {
+    COPY.unlock(conn, dst.id).await
 }
 
 /// Take the lock used to keep two operations from writing to the deployment
 /// simultaneously. Return `true` if we got the lock, and `false` if we did
 /// not. You don't want to use this directly. Instead, use
 /// `deployment::with_lock`
-pub(crate) fn lock_deployment_session(
-    conn: &PgConnection,
+pub(crate) async fn lock_deployment_session(
+    conn: &mut AsyncPgConnection,
     site: &Site,
 ) -> Result<bool, StoreError> {
-    WRITE.try_lock(conn, site.id)
+    WRITE.try_lock(conn, site.id).await
 }
 
 /// Release the lock acquired with `lock_deployment_session`.
-pub(crate) fn unlock_deployment_session(
-    conn: &PgConnection,
+pub(crate) async fn unlock_deployment_session(
+    conn: &mut AsyncPgConnection,
     site: &Site,
 ) -> Result<(), StoreError> {
-    WRITE.unlock(conn, site.id)
+    WRITE.unlock(conn, site.id).await
 }
 
 /// Try to take the lock used to prevent two prune operations from running at the
 /// same time. Return `true` if we got the lock, and `false` otherwise.
-pub(crate) fn try_lock_pruning(conn: &PgConnection, site: &Site) -> Result<bool, StoreError> {
-    PRUNE.try_lock(conn, site.id)
+pub(crate) async fn try_lock_pruning(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<bool, StoreError> {
+    PRUNE.try_lock(conn, site.id).await
 }
 
-pub(crate) fn unlock_pruning(conn: &PgConnection, site: &Site) -> Result<(), StoreError> {
-    PRUNE.unlock(conn, site.id)
+pub(crate) async fn unlock_pruning(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<(), StoreError> {
+    PRUNE.unlock(conn, site.id).await
 }
diff --git a/store/postgres/src/block_range.rs b/store/postgres/src/block_range.rs
index 55bf8ec2c67..d6877957dea 100644
--- a/store/postgres/src/block_range.rs
+++ b/store/postgres/src/block_range.rs
@@ -1,20 +1,20 @@
+//! Utilities to deal with block numbers and block ranges
+use derive_more::Constructor;
 use diesel::pg::Pg;
 use diesel::query_builder::{AstPass, QueryFragment};
 use diesel::result::QueryResult;
-///! Utilities to deal with block numbers and block ranges
 use diesel::serialize::{Output, ToSql};
 use diesel::sql_types::{Integer, Range};
 use graph::env::ENV_VARS;
-use std::io::Write;
 use std::ops::{Bound, RangeBounds, RangeFrom};
 
-use graph::prelude::{lazy_static, BlockNumber, BlockPtr, BLOCK_NUMBER_MAX};
+use graph::prelude::{BLOCK_NUMBER_MAX, BlockNumber, BlockPtr, lazy_static};
 
 use crate::relational::{SqlName, Table};
 
 /// The name of the column in which we store the block range for mutable
 /// entities
-pub(crate) const BLOCK_RANGE_COLUMN: &str = "block_range";
+pub const BLOCK_RANGE_COLUMN: &str = "block_range";
 
 /// The name of the column that stores the causality region of an entity.
 pub(crate) const CAUSALITY_REGION_COLUMN: &str = "causality_region";
@@ -31,6 +31,7 @@ pub(crate) const BLOCK_RANGE_CURRENT: &str = "block_range @> 2147483647";
 ///   - any CRUD operation modifies such an entity in place
 ///   - queries by a block number consider such an entity as present for
 ///     any block number
+///
 /// We therefore mark such entities with a block range `[-1,\infinity)`; we
 /// use `-1` as the lower bound to make it easier to identify such entities
 /// for troubleshooting/debugging
@@ -51,7 +52,7 @@ lazy_static! {
 
 /// The range of blocks for which an entity is valid. We need this struct
 /// to bind ranges into Diesel queries.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Copy)]
 pub struct BlockRange(Bound<BlockNumber>, Bound<BlockNumber>);
 
 pub(crate) fn first_block_in_range(
@@ -89,20 +90,20 @@ impl From<std::ops::Range<BlockNumber>> for BlockRange {
 }
 
 impl ToSql<Range<Integer>, Pg> for BlockRange {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> diesel::serialize::Result {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
         let pair = (self.0, self.1);
-        ToSql::<Range<Integer>, Pg>::to_sql(&pair, out)
+        ToSql::<Range<Integer>, Pg>::to_sql(&pair, &mut out.reborrow())
     }
 }
 
-#[derive(Constructor)]
+#[derive(Debug, Constructor)]
 pub struct BlockRangeLowerBoundClause<'a> {
     _table_prefix: &'a str,
     block: BlockNumber,
 }
 
 impl<'a> QueryFragment<Pg> for BlockRangeLowerBoundClause<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
         out.push_sql("lower(");
@@ -114,14 +115,14 @@ impl<'a> QueryFragment<Pg> for BlockRangeLowerBoundClause<'a> {
     }
 }
 
-#[derive(Constructor)]
+#[derive(Debug, Constructor)]
 pub struct BlockRangeUpperBoundClause<'a> {
     _table_prefix: &'a str,
     block: BlockNumber,
 }
 
 impl<'a> QueryFragment<Pg> for BlockRangeUpperBoundClause<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
         out.push_sql("coalesce(upper(");
@@ -133,8 +134,90 @@ impl<'a> QueryFragment<Pg> for BlockRangeUpperBoundClause<'a> {
     }
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum BoundSide {
+    Lower,
+    Upper,
+}
+
+/// Helper for generating SQL fragments for selecting entities in a specific block range
+#[derive(Debug, Clone, Copy)]
+pub enum EntityBlockRange {
+    Mutable((BlockRange, BoundSide)),
+    Immutable(BlockRange),
+}
+
+impl EntityBlockRange {
+    pub fn new(
+        immutable: bool,
+        block_range: std::ops::Range<BlockNumber>,
+        bound_side: BoundSide,
+    ) -> Self {
+        let start: Bound<BlockNumber> = Bound::Included(block_range.start);
+        let end: Bound<BlockNumber> = Bound::Excluded(block_range.end);
+        let block_range: BlockRange = BlockRange(start, end);
+        if immutable {
+            Self::Immutable(block_range)
+        } else {
+            Self::Mutable((block_range, bound_side))
+        }
+    }
+
+    /// Outputs SQL that matches only rows whose entities would trigger a change
+    /// event (Create, Modify, Delete) in a given interval of blocks. Otherwise said
+    /// a block_range border is contained in an interval of blocks. For instance
+    /// one of the following:
+    /// lower(block_range) >= $1 and lower(block_range) <= $2
+    /// upper(block_range) >= $1 and upper(block_range) <= $2
+    /// block$ >= $1 and block$ <= $2
+    pub fn contains<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+        let block_range = match self {
+            EntityBlockRange::Mutable((br, _)) => br,
+            EntityBlockRange::Immutable(br) => br,
+        };
+        let BlockRange(start, finish) = block_range;
+
+        self.compare_column(out);
+        out.push_sql(">= ");
+        match start {
+            Bound::Included(block) => out.push_bind_param::<Integer, _>(block)?,
+            Bound::Excluded(block) => {
+                out.push_bind_param::<Integer, _>(block)?;
+                out.push_sql("+1");
+            }
+            Bound::Unbounded => unimplemented!(),
+        };
+        out.push_sql(" and");
+        self.compare_column(out);
+        out.push_sql("<= ");
+        match finish {
+            Bound::Included(block) => {
+                out.push_bind_param::<Integer, _>(block)?;
+                out.push_sql("+1");
+            }
+            Bound::Excluded(block) => out.push_bind_param::<Integer, _>(block)?,
+            Bound::Unbounded => unimplemented!(),
+        };
+        Ok(())
+    }
+
+    pub fn compare_column(&self, out: &mut AstPass<Pg>) {
+        match self {
+            EntityBlockRange::Mutable((_, BoundSide::Lower)) => {
+                out.push_sql(" lower(block_range) ")
+            }
+            EntityBlockRange::Mutable((_, BoundSide::Upper)) => {
+                out.push_sql(" upper(block_range) ")
+            }
+            EntityBlockRange::Immutable(_) => out.push_sql(" block$ "),
+        }
+    }
+}
+
 /// Helper for generating various SQL fragments for handling the block range
 /// of entity versions
+#[allow(unused)]
 #[derive(Debug, Clone, Copy)]
 pub enum BlockRangeColumn<'a> {
     Mutable {
@@ -172,7 +255,11 @@ impl<'a> BlockRangeColumn<'a> {
     ///
     /// `filters_by_id` has no impact on correctness. It is a heuristic to determine
     /// whether the brin index should be used. If `true`, the brin index is not used.
-    pub fn contains(&self, out: &mut AstPass<Pg>, filters_by_id: bool) -> QueryResult<()> {
+    pub fn contains<'b>(
+        &'b self,
+        out: &mut AstPass<'_, 'b, Pg>,
+        filters_by_id: bool,
+    ) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
         match self {
@@ -216,13 +303,6 @@ impl<'a> BlockRangeColumn<'a> {
         }
     }
 
-    pub fn column_name(&self) -> &str {
-        match self {
-            BlockRangeColumn::Mutable { .. } => BLOCK_RANGE_COLUMN,
-            BlockRangeColumn::Immutable { .. } => BLOCK_COLUMN,
-        }
-    }
-
     /// Output the qualified name of the block range column
     pub fn name(&self, out: &mut AstPass<Pg>) {
         match self {
@@ -252,7 +332,7 @@ impl<'a> BlockRangeColumn<'a> {
     /// # Panics
     ///
     /// If the underlying table is immutable, this method will panic
-    pub fn clamp(&self, out: &mut AstPass<Pg>) -> QueryResult<()> {
+    pub fn clamp<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         match self {
             BlockRangeColumn::Mutable { block, .. } => {
                 self.name(out);
@@ -269,17 +349,9 @@ impl<'a> BlockRangeColumn<'a> {
         }
     }
 
-    /// Output the name of the block range column without the table prefix
-    pub(crate) fn bare_name(&self, out: &mut AstPass<Pg>) {
-        match self {
-            BlockRangeColumn::Mutable { .. } => out.push_sql(BLOCK_RANGE_COLUMN),
-            BlockRangeColumn::Immutable { .. } => out.push_sql(BLOCK_COLUMN),
-        }
-    }
-
     /// Output an expression that matches all rows that have been changed
     /// after `block` (inclusive)
-    pub(crate) fn changed_since(&self, out: &mut AstPass<Pg>) -> QueryResult<()> {
+    pub(crate) fn changed_since<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         match self {
             BlockRangeColumn::Mutable { block, .. } => {
                 out.push_sql("lower(");
@@ -296,6 +368,41 @@ impl<'a> BlockRangeColumn<'a> {
     }
 }
 
+/// The value for the block/block_range column, mostly as a tool for
+/// inserting data
+#[derive(Debug)]
+pub enum BlockRangeValue {
+    Immutable(BlockNumber),
+    Mutable(BlockRange),
+}
+
+impl BlockRangeValue {
+    pub fn new(table: &Table, block: BlockNumber, end: Option<BlockNumber>) -> Self {
+        if table.immutable {
+            BlockRangeValue::Immutable(block)
+        } else {
+            match end {
+                Some(e) => BlockRangeValue::Mutable((block..e).into()),
+                None => BlockRangeValue::Mutable((block..).into()),
+            }
+        }
+    }
+}
+
+impl QueryFragment<Pg> for BlockRangeValue {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        match self {
+            BlockRangeValue::Immutable(block) => {
+                out.push_bind_param::<Integer, _>(block)?;
+            }
+            BlockRangeValue::Mutable(range) => {
+                out.push_bind_param::<Range<Integer>, _>(range)?;
+            }
+        }
+        Ok(())
+    }
+}
+
 #[test]
 fn block_number_max_is_i32_max() {
     // The code in this file embeds i32::MAX aka BLOCK_NUMBER_MAX in strings
diff --git a/store/postgres/src/block_store.rs b/store/postgres/src/block_store.rs
index d1abb82bc70..4bc9b105c57 100644
--- a/store/postgres/src/block_store.rs
+++ b/store/postgres/src/block_store.rs
@@ -1,50 +1,55 @@
-use std::{
-    collections::HashMap,
-    sync::{Arc, RwLock},
-    time::Duration,
-};
+use std::{collections::HashMap, sync::Arc, time::Duration};
+
+use graph::{components::store::BLOCK_CACHE_SIZE, parking_lot::RwLock};
 
+use anyhow::anyhow;
+use async_trait::async_trait;
+use diesel::{ExpressionMethods as _, QueryDsl, sql_query};
+use diesel_async::RunQueryDsl;
 use graph::{
     blockchain::ChainIdentifier,
     components::store::{BlockStore as BlockStoreTrait, QueryPermit},
-    prelude::{error, info, warn, BlockNumber, BlockPtr, Logger, ENV_VARS},
+    derive::CheapClone,
+    prelude::{BlockNumber, BlockPtr, ENV_VARS, Logger, error, info, warn},
     slog::o,
 };
-use graph::{constraint_violation, prelude::CheapClone};
+use graph::{
+    components::{network_provider::ChainName, store::ChainIdStore},
+    prelude::ChainStore as _,
+};
+use graph::{internal_error, prelude::CheapClone};
 use graph::{prelude::StoreError, util::timed_cache::TimedCache};
 
 use crate::{
-    chain_head_listener::ChainHeadUpdateSender, chain_store::ChainStoreMetrics,
-    connection_pool::ConnectionPool, primary::Mirror as PrimaryMirror, ChainStore,
-    NotificationSender, Shard, PRIMARY_SHARD,
+    AsyncPgConnection, ChainStore, NotificationSender, PRIMARY_SHARD, Shard,
+    chain_head_listener::ChainHeadUpdateSender,
+    chain_store::{ChainStoreMetrics, Storage},
+    pool::ConnectionPool,
+    primary::Mirror as PrimaryMirror,
 };
 
+use self::primary::Chain;
+
 #[cfg(debug_assertions)]
 pub const FAKE_NETWORK_SHARED: &str = "fake_network_shared";
 
-/// The status of a chain: whether we can only read from the chain, or
-/// whether it is ok to ingest from it, too
-#[derive(Copy, Clone)]
-pub enum ChainStatus {
-    ReadOnly,
-    Ingestible,
-}
+// Highest version of the database that the executable supports.
+// To be incremented on each breaking change to the database.
+const SUPPORTED_DB_VERSION: i64 = 3;
 
 pub mod primary {
     use std::convert::TryFrom;
 
-    use diesel::{
-        delete, insert_into, ExpressionMethods, OptionalExtension, PgConnection, QueryDsl,
-        RunQueryDsl,
-    };
+    use diesel::{ExpressionMethods, OptionalExtension, QueryDsl, delete, insert_into, update};
+    use diesel_async::RunQueryDsl;
     use graph::{
         blockchain::{BlockHash, ChainIdentifier},
-        constraint_violation,
+        internal_error,
         prelude::StoreError,
     };
 
-    use crate::chain_store::Storage;
-    use crate::{connection_pool::ConnectionPool, Shard};
+    use crate::{AsyncPgConnection, chain_store::Storage};
+    use crate::{ConnectionPool, Shard};
 
     table! {
             chains(id) {
@@ -76,7 +81,7 @@ pub mod primary {
                 net_version: self.net_version.clone(),
                 genesis_block_hash: BlockHash::try_from(self.genesis_block.as_str()).map_err(
                     |e| {
-                        constraint_violation!(
+                        internal_error!(
                             "the genesis block hash `{}` for chain `{}` is not a valid hash: {}",
                             self.genesis_block,
                             self.name,
@@ -88,25 +93,27 @@ pub mod primary {
         }
     }
 
-    pub fn load_chains(conn: &PgConnection) -> Result<Vec<Chain>, StoreError> {
-        Ok(chains::table.load(conn)?)
+    pub async fn load_chains(conn: &mut AsyncPgConnection) -> Result<Vec<Chain>, StoreError> {
+        Ok(chains::table.load(conn).await?)
     }
 
-    pub fn find_chain(conn: &PgConnection, name: &str) -> Result<Option<Chain>, StoreError> {
+    pub async fn find_chain(
+        conn: &mut AsyncPgConnection,
+        name: &str,
+    ) -> Result<Option<Chain>, StoreError> {
         Ok(chains::table
             .filter(chains::name.eq(name))
             .first(conn)
+            .await
             .optional()?)
     }
 
-    pub fn add_chain(
-        pool: &ConnectionPool,
+    pub async fn add_chain(
+        conn: &mut AsyncPgConnection,
         name: &str,
-        ident: &ChainIdentifier,
         shard: &Shard,
+        ident: ChainIdentifier,
     ) -> Result<Chain, StoreError> {
-        let conn = pool.get()?;
-
         // For tests, we want to have a chain that still uses the
         // shared `ethereum_blocks` table
         #[cfg(debug_assertions)]
@@ -120,9 +127,13 @@ pub mod primary {
                     chains::shard.eq(shard.as_str()),
                 ))
                 .returning(chains::namespace)
-                .get_result::<Storage>(&conn)
+                .get_result::<Storage>(conn)
+                .await
                 .map_err(StoreError::from)?;
-            return Ok(chains::table.filter(chains::name.eq(name)).first(&conn)?);
+            return Ok(chains::table
+                .filter(chains::name.eq(name))
+                .first(conn)
+                .await?);
         }
 
         insert_into(chains::table)
@@ -133,15 +144,34 @@ pub mod primary {
                 chains::shard.eq(shard.as_str()),
             ))
             .returning(chains::namespace)
-            .get_result::<Storage>(&conn)
+            .get_result::<Storage>(conn)
+            .await
             .map_err(StoreError::from)?;
-        Ok(chains::table.filter(chains::name.eq(name)).first(&conn)?)
+        Ok(chains::table
+            .filter(chains::name.eq(name))
+            .first(conn)
+            .await?)
     }
 
-    pub(super) fn drop_chain(pool: &ConnectionPool, name: &str) -> Result<(), StoreError> {
-        let conn = pool.get()?;
+    pub(super) async fn drop_chain(pool: &ConnectionPool, name: &str) -> Result<(), StoreError> {
+        let mut conn = pool.get_permitted().await?;
 
-        delete(chains::table.filter(chains::name.eq(name))).execute(&conn)?;
+        delete(chains::table.filter(chains::name.eq(name)))
+            .execute(&mut conn)
+            .await?;
+        Ok(())
+    }
+
+    // update chain name where chain name is 'name'
+    pub async fn update_chain_name(
+        conn: &mut AsyncPgConnection,
+        name: &str,
+        new_name: &str,
+    ) -> Result<(), StoreError> {
+        update(chains::table.filter(chains::name.eq(name)))
+            .set(chains::name.eq(new_name))
+            .execute(conn)
+            .await?;
         Ok(())
     }
 }
@@ -166,7 +196,20 @@ pub mod primary {
 /// not possible to change its configuration, in particular, the database
 /// shard and namespace, and the genesis block and net version must not
 /// change between runs of `graph-node`
+#[derive(Clone, CheapClone)]
 pub struct BlockStore {
+    inner: Arc<Inner>,
+}
+
+impl std::ops::Deref for BlockStore {
+    type Target = Inner;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+pub struct Inner {
     logger: Logger,
     /// Map chain names to the corresponding store. This map is updated
     /// dynamically with new chains if an operation would require a chain
@@ -174,6 +217,9 @@ pub struct BlockStore {
     /// known to the system at startup, either from configuration or from
     /// previous state in the database.
     stores: RwLock<HashMap<String, Arc<ChainStore>>>,
+    /// We keep this information so we can create chain stores during
+    /// startup. The triple is (network, shard, cache_size)
+    shards: Vec<(String, Shard, BlockNumber)>,
     pools: HashMap<Shard, ConnectionPool>,
     sender: Arc<NotificationSender>,
     mirror: PrimaryMirror,
@@ -193,10 +239,10 @@ impl BlockStore {
     /// Each entry in `chains` gives the chain name, the network identifier,
     /// and the name of the database shard for the chain. The `ChainStore` for
     /// a chain uses the pool from `pools` for the given shard.
-    pub fn new(
+    pub async fn new(
         logger: Logger,
-        // (network, ident, shard)
-        chains: Vec<(String, ChainIdentifier, Shard)>,
+        // (network, shard, cache_size)
+        shards: Vec<(String, Shard, BlockNumber)>,
         // shard -> pool
         pools: HashMap<Shard, ConnectionPool>,
         sender: Arc<NotificationSender>,
@@ -207,89 +253,58 @@ impl BlockStore {
         const CHAIN_HEAD_CACHE_TTL: Duration = Duration::from_secs(2);
 
         let mirror = PrimaryMirror::new(&pools);
-        let existing_chains = mirror.read(|conn| primary::load_chains(conn))?;
+        // Treat a chain whose shard has no connection pool (i.e. a shard
+        // configured with `pool_size = 0`, which `store_builder` drops) as if it
+        // doesn't exist: skip it here so we neither create a chain store for it
+        // nor fail startup. See issue #6195.
+        let existing_chains: Vec<_> = mirror
+            .read_async(primary::load_chains)
+            .await?
+            .into_iter()
+            .filter(|chain| {
+                let has_pool = pools.contains_key(&chain.shard);
+                if !has_pool {
+                    warn!(
+                        &logger,
+                        "Ignoring chain `{}`: its shard `{}` has no connection pool (pool_size = 0)",
+                        chain.name,
+                        chain.shard,
+                    );
+                }
+                has_pool
+            })
+            .collect();
         let chain_head_cache = TimedCache::new(CHAIN_HEAD_CACHE_TTL);
+        let chains = shards.clone();
 
-        let block_store = Self {
+        let inner = Arc::new(Inner {
             logger,
             stores: RwLock::new(HashMap::new()),
+            shards,
             pools,
             sender,
             mirror,
             chain_head_cache,
             chain_store_metrics,
-        };
-
-        /// Check that the configuration for `chain` hasn't changed so that
-        /// it is ok to ingest from it
-        fn chain_ingestible(
-            logger: &Logger,
-            chain: &primary::Chain,
-            shard: &Shard,
-            ident: &ChainIdentifier,
-        ) -> bool {
-            if &chain.shard != shard {
-                error!(
-                    logger,
-                    "the chain {} is stored in shard {} but is configured for shard {}",
-                    chain.name,
-                    chain.shard,
-                    shard
-                );
-                return false;
-            }
-            if chain.net_version != ident.net_version {
-                if chain.net_version == "0" {
-                    warn!(logger,
-                        "the net version for chain {} has changed from 0 to {} since the last time we ran, ignoring difference because 0 means UNSET and firehose does not provide it",
-                        chain.name,
-                        ident.net_version,
-                        )
-                } else {
-                    error!(logger,
-                        "the net version for chain {} has changed from {} to {} since the last time we ran",
-                        chain.name,
-                        chain.net_version,
-                        ident.net_version
-                    );
-                    return false;
-                }
-            }
-            if chain.genesis_block != ident.genesis_block_hash.hash_hex() {
-                error!(logger,
-                        "the genesis block hash for chain {} has changed from {} to {} since the last time we ran",
-                        chain.name,
-                        chain.genesis_block,
-                        ident.genesis_block_hash
-                    );
-                return false;
-            }
-            true
-        }
+        });
+        let block_store = Self { inner };
 
         // For each configured chain, add a chain store
-        for (chain_name, ident, shard) in chains {
-            match existing_chains
+        for (chain_name, shard, _cache_size) in chains {
+            if let Some(chain) = existing_chains
                 .iter()
                 .find(|chain| chain.name == chain_name)
             {
-                Some(chain) => {
-                    let status = if chain_ingestible(&block_store.logger, chain, &shard, &ident) {
-                        ChainStatus::Ingestible
-                    } else {
-                        ChainStatus::ReadOnly
-                    };
-                    block_store.add_chain_store(chain, status, false)?;
-                }
-                None => {
-                    let chain = primary::add_chain(
-                        block_store.mirror.primary(),
-                        &chain_name,
-                        &ident,
-                        &shard,
-                    )?;
-                    block_store.add_chain_store(&chain, ChainStatus::Ingestible, true)?;
+                if chain.shard != shard {
+                    warn!(
+                        &block_store.logger,
+                        "The chain `{0}` is stored in shard `{1}` but is configured for shard `{2}`; ignoring config and using shard `{1}`",
+                        chain.name,
+                        chain.shard,
+                        shard,
+                    );
                 }
+                block_store.add_chain_store(chain, false).await?;
             };
         }
 
@@ -298,7 +313,6 @@ impl BlockStore {
         let configured_chains = block_store
             .stores
             .read()
-            .unwrap()
             .keys()
             .cloned()
             .collect::<Vec<_>>();
@@ -306,29 +320,60 @@ impl BlockStore {
             .iter()
             .filter(|chain| !configured_chains.contains(&chain.name))
         {
-            block_store.add_chain_store(chain, ChainStatus::ReadOnly, false)?;
+            block_store.add_chain_store(chain, false).await?;
         }
         Ok(block_store)
     }
 
     pub(crate) async fn query_permit_primary(&self) -> QueryPermit {
-        self.mirror
-            .primary()
-            .query_permit()
-            .await
-            .expect("the primary is never disabled")
+        self.mirror.primary().query_permit().await
+    }
+
+    pub async fn allocate_chain(
+        conn: &mut AsyncPgConnection,
+        name: &str,
+        shard: &Shard,
+        ident: &ChainIdentifier,
+    ) -> Result<Chain, StoreError> {
+        #[derive(QueryableByName, Debug)]
+        struct ChainIdSeq {
+            #[diesel(sql_type = diesel::sql_types::BigInt)]
+            last_value: i64,
+        }
+
+        // Fetch the current last_value from the sequence
+        let result = sql_query("SELECT last_value FROM chains_id_seq")
+            .get_result::<ChainIdSeq>(conn)
+            .await?;
+
+        let last_val = result.last_value;
+
+        let next_val = last_val + 1;
+        let namespace = format!("chain{}", next_val);
+        let storage =
+            Storage::new(namespace.to_string()).map_err(|e| StoreError::Unknown(anyhow!(e)))?;
+
+        let chain = Chain {
+            id: next_val as i32,
+            name: name.to_string(),
+            shard: shard.clone(),
+            net_version: ident.net_version.clone(),
+            genesis_block: ident.genesis_block_hash.hash_hex(),
+            storage: storage.clone(),
+        };
+
+        Ok(chain)
     }
 
-    fn add_chain_store(
+    pub async fn add_chain_store(
         &self,
         chain: &primary::Chain,
-        status: ChainStatus,
         create: bool,
     ) -> Result<Arc<ChainStore>, StoreError> {
         let pool = self
             .pools
             .get(&chain.shard)
-            .ok_or_else(|| constraint_violation!("there is no pool for shard {}", chain.shard))?
+            .ok_or_else(|| internal_error!("there is no pool for shard {}", chain.shard))?
             .clone();
         let sender = ChainHeadUpdateSender::new(
             self.mirror.primary().clone(),
@@ -337,24 +382,33 @@ impl BlockStore {
         );
         let ident = chain.network_identifier()?;
         let logger = self.logger.new(o!("network" => chain.name.clone()));
+        let cache_size = self
+            .shards
+            .iter()
+            .find_map(|(network, _, chain_size)| {
+                if network == &chain.name {
+                    Some(*chain_size)
+                } else {
+                    None
+                }
+            })
+            .unwrap_or(BLOCK_CACHE_SIZE);
         let store = ChainStore::new(
             logger,
             chain.name.clone(),
             chain.storage.clone(),
-            &ident,
-            status,
             sender,
             pool,
             ENV_VARS.store.recent_blocks_cache_capacity,
             self.chain_store_metrics.clone(),
+            cache_size,
         );
         if create {
-            store.create(&ident)?;
+            store.create(&ident).await?;
         }
         let store = Arc::new(store);
         self.stores
             .write()
-            .unwrap()
             .insert(chain.name.clone(), store.clone());
         Ok(store)
     }
@@ -362,18 +416,18 @@ impl BlockStore {
     /// Return a map from network name to the network's chain head pointer.
     /// The information is cached briefly since this method is used heavily
     /// by the indexing status API
-    pub fn chain_head_pointers(&self) -> Result<HashMap<String, BlockPtr>, StoreError> {
+    pub async fn chain_head_pointers(&self) -> Result<HashMap<String, BlockPtr>, StoreError> {
         let mut map = HashMap::new();
         for (shard, pool) in &self.pools {
             let cached = match self.chain_head_cache.get(shard.as_str()) {
                 Some(cached) => cached,
                 None => {
-                    let conn = match pool.get() {
+                    let mut conn = match pool.get_permitted().await {
                         Ok(conn) => conn,
                         Err(StoreError::DatabaseUnavailable) => continue,
                         Err(e) => return Err(e),
                     };
-                    let heads = Arc::new(ChainStore::chain_head_pointers(&conn)?);
+                    let heads = Arc::new(ChainStore::chain_head_pointers(&mut conn).await?);
                     self.chain_head_cache.set(shard.to_string(), heads.clone());
                     heads
                 }
@@ -387,32 +441,34 @@ impl BlockStore {
         Ok(map)
     }
 
-    pub fn chain_head_block(&self, chain: &str) -> Result<Option<BlockNumber>, StoreError> {
+    pub async fn chain_head_block(&self, chain: &str) -> Result<Option<BlockNumber>, StoreError> {
         let store = self
             .store(chain)
-            .ok_or_else(|| constraint_violation!("unknown network `{}`", chain))?;
-        store.chain_head_block(chain)
+            .await
+            .ok_or_else(|| internal_error!("unknown network `{}`", chain))?;
+        store.chain_head_block(chain).await
     }
 
-    fn lookup_chain<'a>(&'a self, chain: &'a str) -> Result<Option<Arc<ChainStore>>, StoreError> {
+    async fn lookup_chain(&self, chain: &str) -> Result<Option<Arc<ChainStore>>, StoreError> {
         // See if we have that chain in the database even if it wasn't one
         // of the configured chains
-        self.mirror.read(|conn| {
-            primary::find_chain(conn, chain).and_then(|chain| {
-                chain
-                    .map(|chain| self.add_chain_store(&chain, ChainStatus::ReadOnly, false))
-                    .transpose()
-            })
-        })
+        let chain = chain.to_string();
+        let this = self.cheap_clone();
+        self.mirror
+            .read_async(
+                async |conn| match primary::find_chain(conn, &chain).await? {
+                    Some(chain) => {
+                        let chain_store = this.add_chain_store(&chain, false).await?;
+                        Ok(Some(chain_store))
+                    }
+                    None => Ok(None),
+                },
+            )
+            .await
     }
 
-    fn store(&self, chain: &str) -> Option<Arc<ChainStore>> {
-        let store = self
-            .stores
-            .read()
-            .unwrap()
-            .get(chain)
-            .map(CheapClone::cheap_clone);
+    async fn store(&self, chain: &str) -> Option<Arc<ChainStore>> {
+        let store = self.stores.read().get(chain).map(CheapClone::cheap_clone);
         if store.is_some() {
             return store;
         }
@@ -420,28 +476,39 @@ impl BlockStore {
         // suppress errors here since it will be very rare that we look up
         // a chain from the database as most of them will be set up when
         // the block store is created
-        self.lookup_chain(chain).unwrap_or_else(|e| {
+        self.lookup_chain(chain).await.unwrap_or_else(|e| {
                 error!(&self.logger, "Error getting chain from store"; "network" => chain, "error" => e.to_string());
                 None
             })
     }
 
-    pub fn drop_chain(&self, chain: &str) -> Result<(), StoreError> {
+    pub async fn drop_chain(&self, chain: &str) -> Result<(), StoreError> {
         let chain_store = self
             .store(chain)
-            .ok_or_else(|| constraint_violation!("unknown chain {}", chain))?;
+            .await
+            .ok_or_else(|| internal_error!("unknown chain {}", chain))?;
 
         // Delete from the primary first since that's where
         // deployment_schemas has a fk constraint on chains
-        primary::drop_chain(self.mirror.primary(), chain)?;
+        primary::drop_chain(self.mirror.primary(), chain).await?;
 
-        chain_store.drop_chain()?;
+        chain_store.drop_chain().await?;
 
-        self.stores.write().unwrap().remove(chain);
+        self.stores.write().remove(chain);
 
         Ok(())
     }
 
+    // Helper to clone the list of chain stores to avoid holding the lock
+    // while awaiting
+    fn stores(&self) -> Vec<Arc<ChainStore>> {
+        self.stores
+            .read()
+            .values()
+            .map(CheapClone::cheap_clone)
+            .collect()
+    }
+
     // cleanup_ethereum_shallow_blocks will delete cached blocks previously produced by firehose on
     // an ethereum chain that is not currently configured to use firehose provider.
     //
@@ -456,58 +523,141 @@ impl BlockStore {
     // hit on graph-node startup.
     //
     // Discussed here: https://github.com/graphprotocol/graph-node/pull/4790
-    pub fn cleanup_ethereum_shallow_blocks(
+    pub async fn cleanup_ethereum_shallow_blocks(
         &self,
-        ethereum_networks: Vec<&String>,
-        firehose_only_networks: Option<Vec<&String>>,
+        eth_rpc_only_nets: Vec<String>,
     ) -> Result<(), StoreError> {
-        for store in self.stores.read().unwrap().values() {
-            if !ethereum_networks.contains(&&store.chain) {
+        for store in self.stores() {
+            if !eth_rpc_only_nets.contains(&store.chain) {
                 continue;
             };
-            if let Some(fh_nets) = firehose_only_networks.clone() {
-                if fh_nets.contains(&&store.chain) {
-                    continue;
-                };
-            }
 
-            if let Some(head_block) = store.remove_cursor(&&store.chain)? {
-                let lower_bound = head_block.saturating_sub(ENV_VARS.reorg_threshold * 2);
+            if let Some(head_block) = store.remove_cursor(&store.chain).await? {
+                let lower_bound = head_block.saturating_sub(ENV_VARS.reorg_threshold() * 2);
                 info!(&self.logger, "Removed cursor for non-firehose chain, now cleaning shallow blocks"; "network" => &store.chain, "lower_bound" => lower_bound);
-                store.cleanup_shallow_blocks(lower_bound)?;
+                store.cleanup_shallow_blocks(lower_bound).await?;
             }
         }
         Ok(())
     }
 
-    fn truncate_block_caches(&self) -> Result<(), StoreError> {
-        for store in self.stores.read().unwrap().values() {
-            store.truncate_block_cache()?
+    async fn truncate_block_caches(&self) -> Result<(), StoreError> {
+        for store in self.stores() {
+            store.truncate_block_cache().await?;
         }
         Ok(())
     }
 
-    pub fn update_db_version(&self) -> Result<(), StoreError> {
+    pub async fn update_db_version(&self) -> Result<(), StoreError> {
         use crate::primary::db_version as dbv;
-        use diesel::prelude::*;
 
         let primary_pool = self.pools.get(&*PRIMARY_SHARD).unwrap();
-        let connection = primary_pool.get()?;
-        let version: i64 = dbv::table.select(dbv::version).get_result(&connection)?;
+        let mut conn = primary_pool.get_permitted().await?;
+        let version: i64 = dbv::table
+            .select(dbv::version)
+            .get_result(&mut conn)
+            .await?;
         if version < 3 {
-            self.truncate_block_caches()?;
+            self.truncate_block_caches().await?;
             diesel::update(dbv::table)
                 .set(dbv::version.eq(3))
-                .execute(&connection)?;
+                .execute(&mut conn)
+                .await?;
+        };
+        if version < SUPPORTED_DB_VERSION {
+            // Bump it to make sure that all executables are working with the same DB format
+            diesel::update(dbv::table)
+                .set(dbv::version.eq(SUPPORTED_DB_VERSION))
+                .execute(&mut conn)
+                .await?;
         };
+        if version > SUPPORTED_DB_VERSION {
+            panic!(
+                "The executable is too old and doesn't support the database version: {}",
+                version
+            )
+        }
         Ok(())
     }
+
+    pub async fn create_chain_store(
+        &self,
+        network: &str,
+        ident: ChainIdentifier,
+    ) -> anyhow::Result<Arc<ChainStore>> {
+        if let Some(chain_store) = self.store(network).await {
+            return Ok(chain_store);
+        }
+
+        let mut conn = self.mirror.primary().get().await?;
+        let shard = self
+            .shards
+            .iter()
+            .find_map(|(chain_id, shard, _cache_size)| {
+                if chain_id.as_str().eq(network) {
+                    Some(shard)
+                } else {
+                    None
+                }
+            })
+            .ok_or_else(|| anyhow!("unable to find shard for network {}", network))?;
+        let chain = primary::add_chain(&mut conn, network, shard, ident).await?;
+        self.add_chain_store(&chain, true)
+            .await
+            .map_err(anyhow::Error::from)
+    }
 }
 
+#[async_trait]
 impl BlockStoreTrait for BlockStore {
     type ChainStore = ChainStore;
 
-    fn chain_store(&self, network: &str) -> Option<Arc<Self::ChainStore>> {
-        self.store(network)
+    async fn chain_store(&self, network: &str) -> Option<Arc<Self::ChainStore>> {
+        self.store(network).await
+    }
+}
+
+#[async_trait]
+impl ChainIdStore for BlockStore {
+    async fn chain_identifier(
+        &self,
+        chain_name: &ChainName,
+    ) -> Result<ChainIdentifier, anyhow::Error> {
+        let chain_store = self
+            .chain_store(chain_name)
+            .await
+            .ok_or_else(|| anyhow!("unable to get store for chain '{chain_name}'"))?;
+
+        chain_store.chain_identifier().await
+    }
+
+    async fn set_chain_identifier(
+        &self,
+        chain_name: &ChainName,
+        ident: &ChainIdentifier,
+    ) -> Result<(), anyhow::Error> {
+        use primary::chains as c;
+
+        // Update the block shard first since that contains a copy from the primary
+        let chain_store = self
+            .chain_store(chain_name)
+            .await
+            .ok_or_else(|| anyhow!("unable to get store for chain '{chain_name}'"))?;
+
+        chain_store.set_chain_identifier(ident).await?;
+
+        // Update the master copy in the primary
+        let primary_pool = self.pools.get(&*PRIMARY_SHARD).unwrap();
+        let mut conn = primary_pool.get_permitted().await?;
+
+        diesel::update(c::table.filter(c::name.eq(chain_name.as_str())))
+            .set((
+                c::genesis_block_hash.eq(ident.genesis_block_hash.hash_hex()),
+                c::net_version.eq(&ident.net_version),
+            ))
+            .execute(&mut conn)
+            .await?;
+
+        Ok(())
     }
 }
diff --git a/store/postgres/src/catalog.rs b/store/postgres/src/catalog.rs
index cc448b9fd1d..0fbee8ff416 100644
--- a/store/postgres/src/catalog.rs
+++ b/store/postgres/src/catalog.rs
@@ -1,11 +1,12 @@
+use diesel::select;
+use diesel::sql_query;
 use diesel::sql_types::{Bool, Integer};
-use diesel::{connection::SimpleConnection, prelude::RunQueryDsl, select};
-use diesel::{insert_into, OptionalExtension};
-use diesel::{pg::PgConnection, sql_query};
 use diesel::{
-    sql_types::{Array, Double, Nullable, Text},
     ExpressionMethods, QueryDsl,
+    sql_types::{Array, BigInt, Double, Nullable, Text},
 };
+use diesel::{OptionalExtension, insert_into};
+use diesel_async::{RunQueryDsl, SimpleAsyncConnection};
 use graph::components::store::VersionStats;
 use graph::prelude::BlockNumber;
 use graph::schema::EntityType;
@@ -19,12 +20,14 @@ use std::time::Duration;
 use graph::prelude::anyhow::anyhow;
 use graph::{
     data::subgraph::schema::POI_TABLE,
-    prelude::{lazy_static, StoreError},
+    prelude::{BLOCK_NUMBER_MAX, StoreError, lazy_static},
 };
 
-use crate::connection_pool::ForeignServer;
+use crate::AsyncPgConnection;
 use crate::{
-    primary::{Namespace, Site, NAMESPACE_PUBLIC},
+    block_range::BLOCK_RANGE_COLUMN,
+    pool::ForeignServer,
+    primary::{NAMESPACE_PUBLIC, Namespace, Site},
     relational::SqlName,
 };
 
@@ -126,7 +129,7 @@ pub struct Locale {
 
 impl Locale {
     /// Load locale information for current database
-    pub fn load(conn: &PgConnection) -> Result<Locale, StoreError> {
+    pub async fn load(conn: &mut AsyncPgConnection) -> Result<Locale, StoreError> {
         use diesel::dsl::sql;
         use pg_database as db;
 
@@ -137,7 +140,8 @@ impl Locale {
                 db::datctype,
                 sql::<Text>("pg_encoding_to_char(encoding)::text"),
             ))
-            .get_result::<(String, String, String)>(conn)?;
+            .get_result::<(String, String, String)>(conn)
+            .await?;
         Ok(Locale {
             collate,
             ctype,
@@ -185,20 +189,26 @@ pub struct Catalog {
 
     /// Whether the database supports `int4_minmax_multi_ops` etc.
     /// See the [Postgres docs](https://www.postgresql.org/docs/15/brin-builtin-opclasses.html)
-    has_minmax_multi_ops: bool,
+    pub has_minmax_multi_ops: bool,
+
+    /// Whether the column `pg_stats.range_bounds_histogram` introduced in
+    /// Postgres 17 exists. See the [Postgres
+    /// docs](https://www.postgresql.org/docs/17/view-pg-stats.html)
+    pg_stats_has_range_bounds_histogram: bool,
 }
 
 impl Catalog {
     /// Load the catalog for an existing subgraph
-    pub fn load(
-        conn: &PgConnection,
+    pub async fn load(
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
         use_bytea_prefix: bool,
         entities_with_causality_region: Vec<EntityType>,
     ) -> Result<Self, StoreError> {
-        let text_columns = get_text_columns(conn, &site.namespace)?;
-        let use_poi = supports_proof_of_indexing(conn, &site.namespace)?;
-        let has_minmax_multi_ops = has_minmax_multi_ops(conn)?;
+        let text_columns = get_text_columns(conn, &site.namespace).await?;
+        let use_poi = supports_proof_of_indexing(conn, &site.namespace).await?;
+        let has_minmax_multi_ops = has_minmax_multi_ops(conn).await?;
+        let pg_stats_has_range_bounds_histogram = pg_stats_has_range_bounds_histogram(conn).await?;
 
         Ok(Catalog {
             site,
@@ -207,16 +217,18 @@ impl Catalog {
             use_bytea_prefix,
             entities_with_causality_region: entities_with_causality_region.into_iter().collect(),
             has_minmax_multi_ops,
+            pg_stats_has_range_bounds_histogram,
         })
     }
 
     /// Return a new catalog suitable for creating a new subgraph
-    pub fn for_creation(
-        conn: &PgConnection,
+    pub async fn for_creation(
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
         entities_with_causality_region: BTreeSet<EntityType>,
     ) -> Result<Self, StoreError> {
-        let has_minmax_multi_ops = has_minmax_multi_ops(conn)?;
+        let has_minmax_multi_ops = has_minmax_multi_ops(conn).await?;
+        let pg_stats_has_range_bounds_histogram = pg_stats_has_range_bounds_histogram(conn).await?;
 
         Ok(Catalog {
             site,
@@ -228,6 +240,7 @@ impl Catalog {
             use_bytea_prefix: true,
             entities_with_causality_region,
             has_minmax_multi_ops,
+            pg_stats_has_range_bounds_histogram,
         })
     }
 
@@ -245,6 +258,7 @@ impl Catalog {
             use_bytea_prefix: true,
             entities_with_causality_region,
             has_minmax_multi_ops: false,
+            pg_stats_has_range_bounds_histogram: false,
         })
     }
 
@@ -269,10 +283,132 @@ impl Catalog {
             MINMAX_OPS
         }
     }
+
+    pub async fn stats(
+        &self,
+        conn: &mut AsyncPgConnection,
+    ) -> Result<Vec<VersionStats>, StoreError> {
+        #[derive(Queryable, QueryableByName)]
+        pub struct DbStats {
+            #[diesel(sql_type = BigInt)]
+            pub entities: i64,
+            #[diesel(sql_type = BigInt)]
+            pub versions: i64,
+            #[diesel(sql_type = Text)]
+            pub tablename: String,
+            /// The ratio `entities / versions`
+            #[diesel(sql_type = Double)]
+            pub ratio: f64,
+            #[diesel(sql_type = Nullable<Integer>)]
+            pub last_pruned_block: Option<i32>,
+        }
+
+        impl From<DbStats> for VersionStats {
+            fn from(s: DbStats) -> Self {
+                VersionStats {
+                    entities: s.entities,
+                    versions: s.versions,
+                    tablename: s.tablename,
+                    ratio: s.ratio,
+                    last_pruned_block: s.last_pruned_block,
+                    block_range_upper: vec![],
+                }
+            }
+        }
+
+        #[derive(Queryable, QueryableByName)]
+        struct RangeHistogram {
+            #[diesel(sql_type = Text)]
+            tablename: String,
+            #[diesel(sql_type = Array<Integer>)]
+            upper: Vec<i32>,
+        }
+
+        async fn block_range_histogram(
+            conn: &mut AsyncPgConnection,
+            namespace: &Namespace,
+        ) -> Result<Vec<RangeHistogram>, StoreError> {
+            let query = format!(
+                "select tablename, \
+                array_agg(coalesce(upper(block_range), {BLOCK_NUMBER_MAX})) upper \
+           from (select tablename,
+                        unnest(range_bounds_histogram::text::int4range[]) block_range
+                   from pg_stats where schemaname = $1 and attname = '{BLOCK_RANGE_COLUMN}') a
+          group by tablename
+          order by tablename"
+            );
+            let result = sql_query(query)
+                .bind::<Text, _>(namespace.as_str())
+                .get_results::<RangeHistogram>(conn)
+                .await?;
+            Ok(result)
+        }
+
+        // Get an estimate of number of rows (pg_class.reltuples) and number of
+        // distinct entities (based on the planners idea of how many distinct
+        // values there are in the `id` column) See the [Postgres
+        // docs](https://www.postgresql.org/docs/current/view-pg-stats.html) for
+        // the precise meaning of n_distinct
+        let query = "select case when s.n_distinct < 0 then (- s.n_distinct * c.reltuples)::int8
+                     else s.n_distinct::int8
+                 end as entities,
+                 c.reltuples::int8 as versions,
+                 c.relname as tablename,
+                case when c.reltuples = 0 then 0::float8
+                     when s.n_distinct < 0 then (-s.n_distinct)::float8
+                     else greatest(s.n_distinct, 1)::float8 / c.reltuples::float8
+                 end as ratio,
+                 ts.last_pruned_block
+           from pg_namespace n, pg_class c, pg_stats s
+                left outer join subgraphs.table_stats ts
+                     on (ts.table_name = s.tablename
+                     and ts.deployment = $1)
+          where n.nspname = $2
+            and c.relnamespace = n.oid
+            and s.schemaname = n.nspname
+            and s.attname = 'id'
+            and c.relname = s.tablename
+          order by c.relname"
+            .to_string();
+
+        let stats = sql_query(query)
+            .bind::<Integer, _>(self.site.id)
+            .bind::<Text, _>(self.site.namespace.as_str())
+            .load::<DbStats>(conn)
+            .await
+            .map_err(StoreError::from)?;
+
+        let mut range_histogram = if self.pg_stats_has_range_bounds_histogram {
+            block_range_histogram(conn, &self.site.namespace).await?
+        } else {
+            vec![]
+        };
+
+        let stats = stats
+            .into_iter()
+            .map(|s| {
+                let pos = range_histogram
+                    .iter()
+                    .position(|h| h.tablename == s.tablename);
+                let mut upper = pos
+                    .map(|pos| range_histogram.swap_remove(pos))
+                    .map(|h| h.upper)
+                    .unwrap_or(vec![]);
+                // Since lower and upper are supposed to be histograms, we
+                // sort them
+                upper.sort_unstable();
+                let mut vs = VersionStats::from(s);
+                vs.block_range_upper = upper;
+                vs
+            })
+            .collect::<Vec<_>>();
+
+        Ok(stats)
+    }
 }
 
-fn get_text_columns(
-    conn: &PgConnection,
+async fn get_text_columns(
+    conn: &mut AsyncPgConnection,
     namespace: &Namespace,
 ) -> Result<HashMap<String, HashSet<String>>, StoreError> {
     const QUERY: &str = "
@@ -282,15 +418,16 @@ fn get_text_columns(
 
     #[derive(Debug, QueryableByName)]
     struct Column {
-        #[sql_type = "Text"]
+        #[diesel(sql_type = Text)]
         pub table_name: String,
-        #[sql_type = "Text"]
+        #[diesel(sql_type = Text)]
         pub column_name: String,
     }
 
     let map: HashMap<String, HashSet<String>> = diesel::sql_query(QUERY)
         .bind::<Text, _>(namespace.as_str())
-        .load::<Column>(conn)?
+        .load::<Column>(conn)
+        .await?
         .into_iter()
         .fold(HashMap::new(), |mut map, col| {
             map.entry(col.table_name)
@@ -301,14 +438,14 @@ fn get_text_columns(
     Ok(map)
 }
 
-pub fn table_exists(
-    conn: &PgConnection,
+pub async fn table_exists(
+    conn: &mut AsyncPgConnection,
     namespace: &str,
     table: &SqlName,
 ) -> Result<bool, StoreError> {
     #[derive(Debug, QueryableByName)]
     struct Table {
-        #[sql_type = "Text"]
+        #[diesel(sql_type = Text)]
         #[allow(dead_code)]
         pub table_name: String,
     }
@@ -317,28 +454,30 @@ pub fn table_exists(
     let result: Vec<Table> = diesel::sql_query(query)
         .bind::<Text, _>(namespace)
         .bind::<Text, _>(table.as_str())
-        .load(conn)?;
+        .load(conn)
+        .await?;
     Ok(!result.is_empty())
 }
 
-pub fn supports_proof_of_indexing(
-    conn: &diesel::pg::PgConnection,
+pub async fn supports_proof_of_indexing(
+    conn: &mut AsyncPgConnection,
     namespace: &Namespace,
 ) -> Result<bool, StoreError> {
     lazy_static! {
         static ref POI_TABLE_NAME: SqlName = SqlName::verbatim(POI_TABLE.to_owned());
     }
-    table_exists(conn, namespace.as_str(), &POI_TABLE_NAME)
+    table_exists(conn, namespace.as_str(), &POI_TABLE_NAME).await
 }
 
-pub fn current_servers(conn: &PgConnection) -> Result<Vec<String>, StoreError> {
+pub async fn current_servers(conn: &mut AsyncPgConnection) -> Result<Vec<String>, StoreError> {
     #[derive(QueryableByName)]
     struct Srv {
-        #[sql_type = "Text"]
+        #[diesel(sql_type = Text)]
         srvname: String,
     }
     Ok(sql_query("select srvname from pg_foreign_server")
-        .get_results::<Srv>(conn)?
+        .get_results::<Srv>(conn)
+        .await?
         .into_iter()
         .map(|srv| srv.srvname)
         .collect())
@@ -346,18 +485,19 @@ pub fn current_servers(conn: &PgConnection) -> Result<Vec<String>, StoreError> {
 
 /// Return the options for the foreign server `name` as a map of option
 /// names to values
-pub fn server_options(
-    conn: &PgConnection,
+pub async fn server_options(
+    conn: &mut AsyncPgConnection,
     name: &str,
 ) -> Result<HashMap<String, Option<String>>, StoreError> {
     #[derive(QueryableByName)]
     struct Srv {
-        #[sql_type = "Array<Text>"]
+        #[diesel(sql_type = Array<Text>)]
         srvoptions: Vec<String>,
     }
     let entries = sql_query("select srvoptions from pg_foreign_server where srvname = $1")
         .bind::<Text, _>(name)
-        .get_result::<Srv>(conn)?
+        .get_result::<Srv>(conn)
+        .await?
         .srvoptions
         .into_iter()
         .filter_map(|opt| {
@@ -370,71 +510,98 @@ pub fn server_options(
     Ok(HashMap::from_iter(entries))
 }
 
-pub fn has_namespace(conn: &PgConnection, namespace: &Namespace) -> Result<bool, StoreError> {
+pub async fn has_namespace(
+    conn: &mut AsyncPgConnection,
+    namespace: &Namespace,
+) -> Result<bool, StoreError> {
     use pg_namespace as nsp;
 
     Ok(select(diesel::dsl::exists(
         nsp::table.filter(nsp::name.eq(namespace.as_str())),
     ))
-    .get_result::<bool>(conn)?)
+    .get_result::<bool>(conn)
+    .await?)
 }
 
 /// Drop the schema for `src` if it is a foreign schema imported from
 /// another database. If the schema does not exist, or is not a foreign
 /// schema, do nothing. This crucially depends on the fact that we never mix
 /// foreign and local tables in the same schema.
-pub fn drop_foreign_schema(conn: &PgConnection, src: &Site) -> Result<(), StoreError> {
+pub async fn drop_foreign_schema(
+    conn: &mut AsyncPgConnection,
+    src: &Site,
+) -> Result<(), StoreError> {
     use foreign_tables as ft;
 
     let is_foreign = select(diesel::dsl::exists(
         ft::table.filter(ft::foreign_table_schema.eq(src.namespace.as_str())),
     ))
-    .get_result::<bool>(conn)?;
+    .get_result::<bool>(conn)
+    .await?;
 
     if is_foreign {
         let query = format!("drop schema if exists {} cascade", src.namespace);
-        conn.batch_execute(&query)?;
+        conn.batch_execute(&query).await?;
     }
     Ok(())
 }
 
+pub async fn foreign_tables(
+    conn: &mut AsyncPgConnection,
+    nsp: &str,
+) -> Result<Vec<String>, StoreError> {
+    use foreign_tables as ft;
+
+    ft::table
+        .filter(ft::foreign_table_schema.eq(nsp))
+        .select(ft::foreign_table_name)
+        .get_results::<String>(conn)
+        .await
+        .map_err(StoreError::from)
+}
+
 /// Drop the schema `nsp` and all its contents if it exists, and create it
 /// again so that `nsp` is an empty schema
-pub fn recreate_schema(conn: &PgConnection, nsp: &str) -> Result<(), StoreError> {
+pub async fn recreate_schema(conn: &mut AsyncPgConnection, nsp: &str) -> Result<(), StoreError> {
     let query = format!(
         "drop schema if exists {nsp} cascade;\
          create schema {nsp};",
         nsp = nsp
     );
-    Ok(conn.batch_execute(&query)?)
+    Ok(conn.batch_execute(&query).await?)
 }
 
 /// Drop the schema `nsp` and all its contents if it exists
-pub fn drop_schema(conn: &PgConnection, nsp: &str) -> Result<(), StoreError> {
+pub async fn drop_schema(conn: &mut AsyncPgConnection, nsp: &str) -> Result<(), StoreError> {
     let query = format!("drop schema if exists {nsp} cascade;", nsp = nsp);
-    Ok(conn.batch_execute(&query)?)
+    Ok(conn.batch_execute(&query).await?)
 }
 
-pub fn migration_count(conn: &PgConnection) -> Result<usize, StoreError> {
+pub async fn migration_count(conn: &mut AsyncPgConnection) -> Result<usize, StoreError> {
     use __diesel_schema_migrations as m;
 
-    if !table_exists(conn, NAMESPACE_PUBLIC, &MIGRATIONS_TABLE)? {
+    if !table_exists(conn, NAMESPACE_PUBLIC, &MIGRATIONS_TABLE).await? {
         return Ok(0);
     }
 
     m::table
         .count()
         .get_result(conn)
+        .await
         .map(|n: i64| n as usize)
         .map_err(StoreError::from)
 }
 
-pub fn account_like(conn: &PgConnection, site: &Site) -> Result<HashSet<String>, StoreError> {
+pub async fn account_like(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<HashSet<String>, StoreError> {
     use table_stats as ts;
     let names = ts::table
         .filter(ts::deployment.eq(site.id))
         .select((ts::table_name, ts::is_account_like))
         .get_results::<(String, Option<bool>)>(conn)
+        .await
         .optional()?
         .unwrap_or_default()
         .into_iter()
@@ -449,8 +616,8 @@ pub fn account_like(conn: &PgConnection, site: &Site) -> Result<HashSet<String>,
     Ok(names)
 }
 
-pub fn set_account_like(
-    conn: &PgConnection,
+pub async fn set_account_like(
+    conn: &mut AsyncPgConnection,
     site: &Site,
     table_name: &SqlName,
     is_account_like: bool,
@@ -465,11 +632,16 @@ pub fn set_account_like(
         .on_conflict((ts::deployment, ts::table_name))
         .do_update()
         .set(ts::is_account_like.eq(is_account_like))
-        .execute(conn)?;
+        .execute(conn)
+        .await?;
     Ok(())
 }
 
-pub fn copy_account_like(conn: &PgConnection, src: &Site, dst: &Site) -> Result<usize, StoreError> {
+pub async fn copy_account_like(
+    conn: &mut AsyncPgConnection,
+    src: &Site,
+    dst: &Site,
+) -> Result<usize, StoreError> {
     let src_nsp = ForeignServer::metadata_schema_in(&src.shard, &dst.shard);
     let query = format!(
         "insert into subgraphs.table_stats(deployment, table_name, is_account_like, last_pruned_block)
@@ -481,11 +653,12 @@ pub fn copy_account_like(conn: &PgConnection, src: &Site, dst: &Site) -> Result<
     Ok(sql_query(query)
         .bind::<Integer, _>(src.id)
         .bind::<Integer, _>(dst.id)
-        .execute(conn)?)
+        .execute(conn)
+        .await?)
 }
 
-pub fn set_last_pruned_block(
-    conn: &PgConnection,
+pub async fn set_last_pruned_block(
+    conn: &mut AsyncPgConnection,
     site: &Site,
     table_name: &SqlName,
     last_pruned_block: BlockNumber,
@@ -501,7 +674,8 @@ pub fn set_last_pruned_block(
         .on_conflict((ts::deployment, ts::table_name))
         .do_update()
         .set(ts::last_pruned_block.eq(last_pruned_block))
-        .execute(conn)?;
+        .execute(conn)
+        .await?;
     Ok(())
 }
 
@@ -517,15 +691,15 @@ pub(crate) mod table_schema {
 
     #[derive(QueryableByName)]
     struct ColumnInfo {
-        #[sql_type = "Text"]
+        #[diesel(sql_type = Text)]
         column_name: String,
-        #[sql_type = "Text"]
+        #[diesel(sql_type = Text)]
         data_type: String,
-        #[sql_type = "Text"]
+        #[diesel(sql_type = Text)]
         udt_name: String,
-        #[sql_type = "Text"]
+        #[diesel(sql_type = Text)]
         udt_schema: String,
-        #[sql_type = "Nullable<Text>"]
+        #[diesel(sql_type = Nullable<Text>)]
         elem_type: Option<String>,
     }
 
@@ -548,8 +722,8 @@ pub(crate) mod table_schema {
         }
     }
 
-    pub fn columns(
-        conn: &PgConnection,
+    pub async fn columns(
+        conn: &mut AsyncPgConnection,
         nsp: &str,
         table_name: &str,
     ) -> Result<Vec<Column>, StoreError> {
@@ -567,7 +741,8 @@ pub(crate) mod table_schema {
         Ok(sql_query(QUERY)
             .bind::<Text, _>(nsp)
             .bind::<Text, _>(table_name)
-            .get_results::<ColumnInfo>(conn)?
+            .get_results::<ColumnInfo>(conn)
+            .await?
             .into_iter()
             .map(|ci| ci.into())
             .collect())
@@ -577,8 +752,8 @@ pub(crate) mod table_schema {
 /// Return a SQL statement to create the foreign table
 /// `{dst_nsp}.{table_name}` for the server `server` which has the same
 /// schema as the (local) table `{src_nsp}.{table_name}`
-pub fn create_foreign_table(
-    conn: &PgConnection,
+pub async fn create_foreign_table(
+    conn: &mut AsyncPgConnection,
     src_nsp: &str,
     table_name: &str,
     dst_nsp: &str,
@@ -611,7 +786,7 @@ pub fn create_foreign_table(
         Ok(query)
     }
 
-    let columns = table_schema::columns(conn, src_nsp, table_name)?;
+    let columns = table_schema::columns(conn, src_nsp, table_name).await?;
     let query = build_query(columns, src_nsp, table_name, dst_nsp, server).map_err(|_| {
         anyhow!(
             "failed to generate 'create foreign table' query for {}.{}",
@@ -622,15 +797,67 @@ pub fn create_foreign_table(
     Ok(query)
 }
 
+/// Create a SQL statement unioning imported tables from all shards,
+/// something like
+///
+/// ```sql
+/// create view "dst_nsp"."src_table" as
+/// select 'shard1' as shard, "col1", "col2" from "shard_shard1_subgraphs"."table_name"
+/// union all
+/// ...
+/// ````
+///
+/// The list `shard_nsps` consists of pairs `(name, namespace)` where `name`
+/// is the name of the shard and `namespace` is the namespace where the
+/// `src_table` is mapped
+pub async fn create_cross_shard_view(
+    conn: &mut AsyncPgConnection,
+    src_nsp: &str,
+    src_table: &str,
+    dst_nsp: &str,
+    shard_nsps: &[(&str, String)],
+) -> Result<String, StoreError> {
+    fn build_query(
+        columns: &[table_schema::Column],
+        table_name: &str,
+        dst_nsp: &str,
+        shard_nsps: &[(&str, String)],
+    ) -> Result<String, std::fmt::Error> {
+        let mut query = String::new();
+        write!(query, "create view \"{}\".\"{}\" as ", dst_nsp, table_name)?;
+        for (idx, (name, nsp)) in shard_nsps.iter().enumerate() {
+            if idx > 0 {
+                write!(query, " union all ")?;
+            }
+            write!(query, "select '{name}' as shard")?;
+            for column in columns {
+                write!(query, ", \"{}\"", column.column_name)?;
+            }
+            writeln!(query, " from \"{}\".\"{}\"", nsp, table_name)?;
+        }
+        Ok(query)
+    }
+
+    let columns = table_schema::columns(conn, src_nsp, src_table).await?;
+    let query = build_query(&columns, src_table, dst_nsp, shard_nsps).map_err(|_| {
+        anyhow!(
+            "failed to generate 'create foreign table' query for {}.{}",
+            dst_nsp,
+            src_table
+        )
+    })?;
+    Ok(query)
+}
+
 /// Checks in the database if a given index is valid.
-pub(crate) fn check_index_is_valid(
-    conn: &PgConnection,
+pub(crate) async fn check_index_is_valid(
+    conn: &mut AsyncPgConnection,
     schema_name: &str,
     index_name: &str,
 ) -> Result<bool, StoreError> {
     #[derive(Queryable, QueryableByName)]
     struct ManualIndexCheck {
-        #[sql_type = "Bool"]
+        #[diesel(sql_type = Bool)]
         is_valid: bool,
     }
 
@@ -648,21 +875,52 @@ pub(crate) fn check_index_is_valid(
         .bind::<Text, _>(schema_name)
         .bind::<Text, _>(index_name)
         .get_result::<ManualIndexCheck>(conn)
+        .await
         .optional()
         .map_err::<StoreError, _>(Into::into)?
         .map(|check| check.is_valid);
     Ok(matches!(result, Some(true)))
 }
 
-pub(crate) fn indexes_for_table(
-    conn: &PgConnection,
+/// Check whether there is an index creation currently running for any index
+/// in the given schema. If there is, return the PID of the backend that is
+/// creating the index and the name of the index being created.
+pub(crate) async fn index_creation_is_running(
+    conn: &mut AsyncPgConnection,
+    schema_name: &str,
+) -> Result<Option<(i32, String)>, StoreError> {
+    #[derive(Queryable, QueryableByName)]
+    struct IndexCreationCheck {
+        #[diesel(sql_type = Integer)]
+        pid: i32,
+        #[diesel(sql_type = Text)]
+        index_name: String,
+    }
+
+    let query = "
+        select ci.pid, ci.index_relid::regclass as index_name \
+        from pg_stat_progress_create_index ci \
+        join pg_class c on ci.relid = c.oid \
+        join pg_namespace n on c.relnamespace = n.oid \
+        where n.nspname = $1";
+    sql_query(query)
+        .bind::<Text, _>(schema_name)
+        .get_result::<IndexCreationCheck>(conn)
+        .await
+        .optional()
+        .map(|check| check.map(|check| (check.pid, check.index_name)))
+        .map_err::<StoreError, _>(Into::into)
+}
+
+pub(crate) async fn indexes_for_table(
+    conn: &mut AsyncPgConnection,
     schema_name: &str,
     table_name: &str,
 ) -> Result<Vec<String>, StoreError> {
     #[derive(Queryable, QueryableByName)]
     struct IndexName {
-        #[sql_type = "Text"]
-        #[column_name = "indexdef"]
+        #[diesel(sql_type = Text)]
+        #[diesel(column_name = indexdef)]
         def: String,
     }
 
@@ -679,12 +937,40 @@ pub(crate) fn indexes_for_table(
         .bind::<Text, _>(schema_name)
         .bind::<Text, _>(table_name)
         .load::<IndexName>(conn)
+        .await
         .map_err::<StoreError, _>(Into::into)?;
 
     Ok(results.into_iter().map(|i| i.def).collect())
 }
-pub(crate) fn drop_index(
-    conn: &PgConnection,
+
+pub(crate) async fn table_has_index(
+    conn: &mut AsyncPgConnection,
+    schema_name: &str,
+    index_name: &str,
+) -> Result<bool, StoreError> {
+    #[derive(QueryableByName)]
+    #[allow(dead_code)]
+    struct Exists {
+        #[diesel(sql_type = diesel::sql_types::Integer)]
+        exists: i32,
+    }
+
+    let exists = sql_query(
+        "SELECT 1 AS exists FROM pg_indexes \
+         WHERE schemaname = $1 AND indexname = $2",
+    )
+    .bind::<Text, _>(schema_name)
+    .bind::<Text, _>(index_name)
+    .get_result::<Exists>(conn)
+    .await
+    .optional()
+    .map_err::<StoreError, _>(Into::into)?;
+
+    Ok(exists.is_some())
+}
+
+pub(crate) async fn drop_index(
+    conn: &mut AsyncPgConnection,
     schema_name: &str,
     index_name: &str,
 ) -> Result<(), StoreError> {
@@ -693,81 +979,18 @@ pub(crate) fn drop_index(
         .bind::<Text, _>(schema_name)
         .bind::<Text, _>(index_name)
         .execute(conn)
+        .await
         .map_err::<StoreError, _>(Into::into)?;
     Ok(())
 }
 
-pub fn stats(conn: &PgConnection, site: &Site) -> Result<Vec<VersionStats>, StoreError> {
-    #[derive(Queryable, QueryableByName)]
-    pub struct DbStats {
-        #[sql_type = "Integer"]
-        pub entities: i32,
-        #[sql_type = "Integer"]
-        pub versions: i32,
-        #[sql_type = "Text"]
-        pub tablename: String,
-        /// The ratio `entities / versions`
-        #[sql_type = "Double"]
-        pub ratio: f64,
-        #[sql_type = "Nullable<Integer>"]
-        pub last_pruned_block: Option<i32>,
-    }
-
-    impl From<DbStats> for VersionStats {
-        fn from(s: DbStats) -> Self {
-            VersionStats {
-                entities: s.entities,
-                versions: s.versions,
-                tablename: s.tablename,
-                ratio: s.ratio,
-                last_pruned_block: s.last_pruned_block,
-            }
-        }
-    }
-
-    // Get an estimate of number of rows (pg_class.reltuples) and number of
-    // distinct entities (based on the planners idea of how many distinct
-    // values there are in the `id` column) See the [Postgres
-    // docs](https://www.postgresql.org/docs/current/view-pg-stats.html) for
-    // the precise meaning of n_distinct
-    let query = "select case when s.n_distinct < 0 then (- s.n_distinct * c.reltuples)::int4
-                     else s.n_distinct::int4
-                 end as entities,
-                 c.reltuples::int4  as versions,
-                 c.relname as tablename,
-                case when c.reltuples = 0 then 0::float8
-                     when s.n_distinct < 0 then (-s.n_distinct)::float8
-                     else greatest(s.n_distinct, 1)::float8 / c.reltuples::float8
-                 end as ratio,
-                 ts.last_pruned_block
-           from pg_namespace n, pg_class c, pg_stats s
-                left outer join subgraphs.table_stats ts
-                     on (ts.table_name = s.tablename
-                     and ts.deployment = $1)
-          where n.nspname = $2
-            and c.relnamespace = n.oid
-            and s.schemaname = n.nspname
-            and s.attname = 'id'
-            and c.relname = s.tablename
-          order by c.relname"
-        .to_string();
-
-    let stats = sql_query(query)
-        .bind::<Integer, _>(site.id)
-        .bind::<Text, _>(site.namespace.as_str())
-        .load::<DbStats>(conn)
-        .map_err(StoreError::from)?;
-
-    Ok(stats.into_iter().map(|s| s.into()).collect())
-}
-
 /// Return by how much the slowest replica connected to the database `conn`
 /// is lagging. The returned value has millisecond precision. If the
 /// database has no replicas, return `0`
-pub(crate) fn replication_lag(conn: &PgConnection) -> Result<Duration, StoreError> {
+pub(crate) async fn replication_lag(conn: &mut AsyncPgConnection) -> Result<Duration, StoreError> {
     #[derive(Queryable, QueryableByName)]
     struct Lag {
-        #[sql_type = "Nullable<Integer>"]
+        #[diesel(sql_type = Nullable<Integer>)]
         ms: Option<i32>,
     }
 
@@ -775,7 +998,7 @@ pub(crate) fn replication_lag(conn: &PgConnection) -> Result<Duration, StoreErro
         "select (extract(epoch from max(greatest(write_lag, flush_lag, replay_lag)))*1000)::int as ms \
            from pg_stat_replication",
     )
-    .get_result::<Lag>(conn)?;
+    .get_result::<Lag>(conn).await?;
 
     let lag = lag
         .ms
@@ -785,7 +1008,10 @@ pub(crate) fn replication_lag(conn: &PgConnection) -> Result<Duration, StoreErro
     Ok(Duration::from_millis(lag))
 }
 
-pub(crate) fn cancel_vacuum(conn: &PgConnection, namespace: &Namespace) -> Result<(), StoreError> {
+pub(crate) async fn cancel_vacuum(
+    conn: &mut AsyncPgConnection,
+    namespace: &Namespace,
+) -> Result<(), StoreError> {
     sql_query(
         "select pg_cancel_backend(v.pid) \
            from pg_stat_progress_vacuum v, \
@@ -796,25 +1022,27 @@ pub(crate) fn cancel_vacuum(conn: &PgConnection, namespace: &Namespace) -> Resul
             and n.nspname = $1",
     )
     .bind::<Text, _>(namespace)
-    .execute(conn)?;
+    .execute(conn)
+    .await?;
     Ok(())
 }
 
-pub(crate) fn default_stats_target(conn: &PgConnection) -> Result<i32, StoreError> {
+pub(crate) async fn default_stats_target(conn: &mut AsyncPgConnection) -> Result<i32, StoreError> {
     #[derive(Queryable, QueryableByName)]
     struct Target {
-        #[sql_type = "Integer"]
+        #[diesel(sql_type = Integer)]
         setting: i32,
     }
 
     let target =
         sql_query("select setting::int from pg_settings where name = 'default_statistics_target'")
-            .get_result::<Target>(conn)?;
+            .get_result::<Target>(conn)
+            .await?;
     Ok(target.setting)
 }
 
-pub(crate) fn stats_targets(
-    conn: &PgConnection,
+pub(crate) async fn stats_targets(
+    conn: &mut AsyncPgConnection,
     namespace: &Namespace,
 ) -> Result<BTreeMap<SqlName, BTreeMap<SqlName, i32>>, StoreError> {
     use pg_attribute as a;
@@ -828,7 +1056,8 @@ pub(crate) fn stats_targets(
         .filter(n::name.eq(namespace.as_str()))
         .filter(a::num.ge(1))
         .select((c::name, a::name, a::stats_target))
-        .load::<(String, String, i32)>(conn)?
+        .load::<(String, String, i32)>(conn)
+        .await?
         .into_iter()
         .map(|(table, column, target)| (SqlName::from(table), SqlName::from(column), target));
 
@@ -842,8 +1071,8 @@ pub(crate) fn stats_targets(
     Ok(map)
 }
 
-pub(crate) fn set_stats_target(
-    conn: &PgConnection,
+pub(crate) async fn set_stats_target(
+    conn: &mut AsyncPgConnection,
     namespace: &Namespace,
     table: &SqlName,
     columns: &[&SqlName],
@@ -854,7 +1083,7 @@ pub(crate) fn set_stats_target(
         .map(|column| format!("alter column {} set statistics {}", column.quoted(), target))
         .join(", ");
     let query = format!("alter table {}.{} {}", namespace, table.quoted(), columns);
-    conn.batch_execute(&query)?;
+    conn.batch_execute(&query).await?;
     Ok(())
 }
 
@@ -863,8 +1092,8 @@ pub(crate) fn set_stats_target(
 /// same logic that Postgres' [autovacuum
 /// daemon](https://www.postgresql.org/docs/current/routine-vacuuming.html#AUTOVACUUM)
 /// uses
-pub(crate) fn needs_autoanalyze(
-    conn: &PgConnection,
+pub(crate) async fn needs_autoanalyze(
+    conn: &mut AsyncPgConnection,
     namespace: &Namespace,
 ) -> Result<Vec<SqlName>, StoreError> {
     const QUERY: &str = "select relname \
@@ -875,13 +1104,14 @@ pub(crate) fn needs_autoanalyze(
 
     #[derive(Queryable, QueryableByName)]
     struct TableName {
-        #[sql_type = "Text"]
+        #[diesel(sql_type = Text)]
         name: SqlName,
     }
 
     let tables = sql_query(QUERY)
         .bind::<Text, _>(namespace.as_str())
         .get_results::<TableName>(conn)
+        .await
         .optional()?
         .map(|tables| tables.into_iter().map(|t| t.name).collect())
         .unwrap_or(vec![]);
@@ -891,16 +1121,109 @@ pub(crate) fn needs_autoanalyze(
 
 /// Check whether the database for `conn` supports the `minmax_multi_ops`
 /// introduced in Postgres 14
-fn has_minmax_multi_ops(conn: &PgConnection) -> Result<bool, StoreError> {
+async fn has_minmax_multi_ops(conn: &mut AsyncPgConnection) -> Result<bool, StoreError> {
     const QUERY: &str = "select count(*) = 2 as has_ops \
                            from pg_opclass \
                           where opcname in('int8_minmax_multi_ops', 'int4_minmax_multi_ops')";
 
     #[derive(Queryable, QueryableByName)]
     struct Ops {
-        #[sql_type = "Bool"]
+        #[diesel(sql_type = Bool)]
         has_ops: bool,
     }
 
-    Ok(sql_query(QUERY).get_result::<Ops>(conn)?.has_ops)
+    Ok(sql_query(QUERY).get_result::<Ops>(conn).await?.has_ops)
+}
+
+/// Check whether the database for `conn` has the column
+/// `pg_stats.range_bounds_histogram` introduced in Postgres 17
+async fn pg_stats_has_range_bounds_histogram(
+    conn: &mut AsyncPgConnection,
+) -> Result<bool, StoreError> {
+    #[derive(Queryable, QueryableByName)]
+    struct HasIt {
+        #[diesel(sql_type = Bool)]
+        has_it: bool,
+    }
+
+    let query = "
+          select exists (\
+            select 1 \
+              from information_schema.columns \
+             where table_name = 'pg_stats' \
+               and table_schema = 'pg_catalog' \
+               and column_name = 'range_bounds_histogram') as has_it";
+    sql_query(query)
+        .get_result::<HasIt>(conn)
+        .await
+        .map(|h| h.has_it)
+        .map_err(StoreError::from)
+}
+
+pub(crate) async fn histogram_bounds(
+    conn: &mut AsyncPgConnection,
+    namespace: &Namespace,
+    table: &SqlName,
+    column: &str,
+) -> Result<Vec<i64>, StoreError> {
+    const QUERY: &str = "select coalesce(histogram_bounds::text::int8[], '{}'::int8[]) as bounds \
+                           from pg_stats \
+                          where schemaname = $1 \
+                            and tablename = $2 \
+                            and attname = $3";
+
+    #[derive(Queryable, QueryableByName)]
+    struct Bounds {
+        #[diesel(sql_type = Array<BigInt>)]
+        bounds: Vec<i64>,
+    }
+
+    sql_query(QUERY)
+        .bind::<Text, _>(namespace.as_str())
+        .bind::<Text, _>(table.as_str())
+        .bind::<Text, _>(column)
+        .get_result::<Bounds>(conn)
+        .await
+        .optional()
+        .map(|bounds| bounds.map(|b| b.bounds).unwrap_or_default())
+        .map_err(StoreError::from)
+}
+
+/// Return the name of the sequence that Postgres uses to handle
+/// auto-incrementing columns. This takes Postgres' way of dealing with long
+/// table and sequence names into account.
+pub(crate) fn seq_name(table_name: &str, column_name: &str) -> String {
+    // Postgres limits all identifiers to 63 characters. When it
+    // constructs the name of a sequence for a column in a table, it
+    // truncates the table name so that appending '_{column}_seq' to
+    // it is at most 63 characters
+    let len = 63 - (5 + column_name.len());
+    let len = len.min(table_name.len());
+    format!("{}_{column_name}_seq", &table_name[0..len])
+}
+
+#[cfg(test)]
+mod test {
+    use super::seq_name;
+
+    #[test]
+    fn seq_name_works() {
+        // Pairs of (table_name, vid_seq_name)
+        const DATA: &[(&str, &str)] = &[
+            ("token", "token_vid_seq"),
+            (
+                "frax_vst_curve_strategy_total_reward_token_collected_event",
+                "frax_vst_curve_strategy_total_reward_token_collected_ev_vid_seq",
+            ),
+            (
+                "rolling_asset_sent_for_last_24_hours_per_chain_and_token",
+                "rolling_asset_sent_for_last_24_hours_per_chain_and_toke_vid_seq",
+            ),
+        ];
+
+        for (tbl, exp) in DATA {
+            let act = seq_name(tbl, "vid");
+            assert_eq!(exp, &act);
+        }
+    }
 }
diff --git a/store/postgres/src/chain_head_listener.rs b/store/postgres/src/chain_head_listener.rs
index 91109c46b3b..2502fd7a631 100644
--- a/store/postgres/src/chain_head_listener.rs
+++ b/store/postgres/src/chain_head_listener.rs
@@ -1,28 +1,25 @@
+use graph::futures03::{self, FutureExt};
 use graph::{
     blockchain::ChainHeadUpdateStream,
-    prelude::{
-        futures03::{self, FutureExt},
-        tokio, MetricsRegistry, StoreError,
-    },
+    prelude::{MetricsRegistry, StoreError, tokio},
     prometheus::{CounterVec, GaugeVec},
     util::timed_rw_lock::TimedRwLock,
 };
 use std::collections::BTreeMap;
-use std::sync::atomic;
-use std::sync::{atomic::AtomicBool, Arc};
+use std::sync::Arc;
 
 use lazy_static::lazy_static;
 
 use crate::{
-    connection_pool::ConnectionPool,
-    notification_listener::{JsonNotification, NotificationListener, SafeChannelName},
     NotificationSender,
+    notification_listener::{JsonNotification, NotificationListener, SafeChannelName},
+    pool::ConnectionPool,
 };
 use graph::blockchain::ChainHeadUpdateListener as ChainHeadUpdateListenerTrait;
 use graph::prelude::serde::{Deserialize, Serialize};
 use graph::prelude::serde_json::{self, json};
 use graph::prelude::tokio::sync::{mpsc::Receiver, watch};
-use graph::prelude::{crit, debug, o, CheapClone, Logger, ENV_VARS};
+use graph::prelude::{CheapClone, ENV_VARS, Logger, crit, debug, o};
 
 lazy_static! {
     pub static ref CHANNEL_NAME: SafeChannelName =
@@ -43,7 +40,6 @@ impl Watcher {
         }
     }
 
-    #[allow(dead_code)]
     fn send(&self) {
         // Unwrap: `self` holds a receiver.
         self.sender.send(()).unwrap()
@@ -143,7 +139,6 @@ impl ChainHeadUpdateListener {
     ) {
         // Process chain head updates in a dedicated task
         graph::spawn(async move {
-            let sending_to_watcher = Arc::new(AtomicBool::new(false));
             while let Some(notification) = receiver.recv().await {
                 // Create ChainHeadUpdate from JSON
                 let update: ChainHeadUpdate =
@@ -169,20 +164,13 @@ impl ChainHeadUpdateListener {
                     .set_chain_head_number(&update.network_name, update.head_block_number as i64);
 
                 // If there are subscriptions for this network, notify them.
-                if let Some(watcher) = watchers.read(&logger).get(&update.network_name) {
-                    // Due to a tokio bug, we must assume that the watcher can deadlock, see
-                    // https://github.com/tokio-rs/tokio/issues/4246.
-                    if !sending_to_watcher.load(atomic::Ordering::SeqCst) {
-                        let sending_to_watcher = sending_to_watcher.cheap_clone();
-                        let sender = watcher.sender.cheap_clone();
-                        tokio::task::spawn_blocking(move || {
-                            sending_to_watcher.store(true, atomic::Ordering::SeqCst);
-                            sender.send(()).unwrap();
-                            sending_to_watcher.store(false, atomic::Ordering::SeqCst);
-                        });
-                    } else {
-                        debug!(logger, "skipping chain head update, watcher is deadlocked"; "network" => &update.network_name);
-                    }
+                // To be extra paranoid to not block this task, use `try_read`.
+                if let Some(watcher) = watchers
+                    .try_read()
+                    .as_ref()
+                    .and_then(|w| w.get(&update.network_name))
+                {
+                    watcher.send();
                 }
             }
         });
@@ -265,15 +253,21 @@ impl ChainHeadUpdateSender {
         }
     }
 
-    pub fn send(&self, hash: &str, number: i64) -> Result<(), StoreError> {
+    pub async fn send(&self, hash: &str, number: i64) -> Result<(), StoreError> {
         let msg = json! ({
             "network_name": &self.chain_name,
             "head_block_hash": hash,
             "head_block_number": number
         });
 
-        let conn = self.pool.get()?;
+        let mut conn = self.pool.get_permitted().await?;
         self.sender
-            .notify(&conn, CHANNEL_NAME.as_str(), Some(&self.chain_name), &msg)
+            .notify(
+                &mut conn,
+                CHANNEL_NAME.as_str(),
+                Some(&self.chain_name),
+                &msg,
+            )
+            .await
     }
 }
diff --git a/store/postgres/src/chain_store.rs b/store/postgres/src/chain_store.rs
index ee0e1193024..3160afebfab 100644
--- a/store/postgres/src/chain_store.rs
+++ b/store/postgres/src/chain_store.rs
@@ -1,16 +1,24 @@
-use diesel::pg::PgConnection;
-use diesel::prelude::*;
-use diesel::r2d2::{ConnectionManager, PooledConnection};
+use anyhow::anyhow;
+use async_trait::async_trait;
 use diesel::sql_types::Text;
-use diesel::{insert_into, update};
+use diesel::{ExpressionMethods, OptionalExtension, QueryDsl, insert_into, update};
+use diesel_async::RunQueryDsl;
+
+use graph::components::store::ChainHeadStore;
+use graph::data::store::ethereum::call;
 use graph::env::ENV_VARS;
 use graph::parking_lot::RwLock;
 use graph::prelude::MetricsRegistry;
+use graph::prelude::alloy::primitives::B256;
 use graph::prometheus::{CounterVec, GaugeVec};
-use graph::slog::Logger;
+use graph::slog::{Logger, info, o};
 use graph::stable_hash::crypto_stable_hash;
 use graph::util::herd_cache::HerdCache;
 
+use std::collections::BTreeMap;
+use std::future::Future;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, Instant};
 use std::{
     collections::HashMap,
     convert::{TryFrom, TryInto},
@@ -18,21 +26,20 @@ use std::{
     sync::Arc,
 };
 
-use graph::blockchain::{Block, BlockHash, ChainIdentifier};
+use graph::blockchain::{Block, BlockHash, ChainIdentifier, ExtendedBlockPtr};
 use graph::cheap_clone::CheapClone;
-use graph::prelude::web3::types::H256;
+use graph::components::ethereum::CachedBlock;
 use graph::prelude::{
-    async_trait, ethabi, serde_json as json, transaction_receipt::LightTransactionReceipt,
-    BlockNumber, BlockPtr, CachedEthereumCall, CancelableError, ChainStore as ChainStoreTrait,
-    Error, EthereumCallCache, StoreError,
+    BlockNumber, BlockPtr, CachedEthereumCall, ChainStore as ChainStoreTrait, Error,
+    EthereumCallCache, StaleCallCacheResult, StoreError, serde_json as json,
+    transaction_receipt::LightTransactionReceipt,
 };
-use graph::{constraint_violation, ensure};
+use graph::{ensure, internal_error};
 
 use self::recent_blocks_cache::RecentBlocksCache;
-use crate::{
-    block_store::ChainStatus, chain_head_listener::ChainHeadUpdateSender,
-    connection_pool::ConnectionPool,
-};
+use crate::AsyncPgConnection;
+use crate::vid_batcher::AdaptiveBatchSize;
+use crate::{chain_head_listener::ChainHeadUpdateSender, pool::ConnectionPool};
 
 /// Our own internal notion of a block
 #[derive(Clone, Debug)]
@@ -50,6 +57,53 @@ impl JsonBlock {
             data,
         }
     }
+
+    fn timestamp(&self) -> Option<u64> {
+        self.data
+            .as_ref()
+            .and_then(|data| data.get("timestamp"))
+            .and_then(|ts| ts.as_str())
+            .and_then(|ts| ts.parse::<u64>().ok())
+    }
+
+    fn into_cache_block(self) -> CacheBlock {
+        let data = self.data.and_then(CachedBlock::from_json);
+        CacheBlock {
+            ptr: self.ptr,
+            parent_hash: self.parent_hash,
+            data,
+        }
+    }
+}
+
+/// Typed version of JsonBlock for the in-memory cache.
+#[derive(Clone, Debug)]
+struct CacheBlock {
+    ptr: BlockPtr,
+    parent_hash: BlockHash,
+    data: Option<CachedBlock>,
+}
+
+impl CacheBlock {
+    fn timestamp(&self) -> Option<u64> {
+        self.data.as_ref().and_then(|d| d.timestamp())
+    }
+
+    fn to_extended_block_ptr(&self) -> Result<ExtendedBlockPtr, Error> {
+        let hash = self.ptr.hash.clone();
+        let number = self.ptr.number;
+        let parent_hash = self.parent_hash.clone();
+
+        let timestamp = self
+            .timestamp()
+            .ok_or_else(|| anyhow!("Timestamp is missing"))?;
+
+        let ptr =
+            ExtendedBlockPtr::try_from((hash.as_b256(), number, parent_hash.as_b256(), timestamp))
+                .map_err(|e| anyhow!("Failed to convert to ExtendedBlockPtr: {}", e))?;
+
+        Ok(ptr)
+    }
 }
 
 /// Tables in the 'public' database schema that store chain-specific data
@@ -71,32 +125,42 @@ pub use data::Storage;
 
 /// Encapuslate access to the blocks table for a chain.
 mod data {
-    use diesel::sql_types::{Array, Binary};
-    use diesel::{connection::SimpleConnection, insert_into};
-    use diesel::{delete, prelude::*, sql_query};
-    use diesel::{dsl::sql, pg::PgConnection};
+    use crate::diesel::dsl::IntervalDsl;
+    use crate::{AsyncPgConnection, catalog};
+    use diesel::dsl::sql;
+    use diesel::insert_into;
+    use diesel::sql_types::{Array, Binary, Bool, Nullable, Text};
+    use diesel::{
+        BoolExpressionMethods, ExpressionMethods, JoinOnDsl, NullableExpressionMethods,
+        OptionalExtension, QueryDsl, delete, sql_query,
+    };
     use diesel::{
+        deserialize::FromSql,
         pg::Pg,
-        serialize::Output,
-        sql_types::Text,
-        types::{FromSql, ToSql},
+        serialize::{Output, ToSql},
     };
     use diesel::{
         sql_types::{BigInt, Bytea, Integer, Jsonb},
         update,
     };
+    use diesel_async::{RunQueryDsl, SimpleAsyncConnection};
     use graph::blockchain::{Block, BlockHash};
-    use graph::constraint_violation;
-    use graph::prelude::ethabi::ethereum_types::H160;
+    use graph::data::store::scalar::Bytes;
+    use graph::internal_error;
+    use graph::prelude::alloy::primitives::{Address, B256};
     use graph::prelude::transaction_receipt::LightTransactionReceipt;
-    use graph::prelude::web3::types::H256;
     use graph::prelude::{
-        serde_json as json, BlockNumber, BlockPtr, CachedEthereumCall, Error, StoreError,
+        BlockNumber, BlockPtr, CachedEthereumCall, Error, Logger, StoreError, info,
+        serde_json as json,
     };
+
+    use std::collections::HashMap;
+    use std::convert::TryFrom;
     use std::fmt;
     use std::iter::FromIterator;
     use std::str::FromStr;
-    use std::{convert::TryFrom, io::Write};
+
+    use std::time::Instant;
 
     use crate::transaction_receipt::RawTransactionReceipt;
 
@@ -105,6 +169,7 @@ mod data {
     pub(crate) const ETHEREUM_BLOCKS_TABLE_NAME: &str = "public.ethereum_blocks";
 
     pub(crate) const ETHEREUM_CALL_CACHE_TABLE_NAME: &str = "public.eth_call_cache";
+    pub(crate) const ETHEREUM_CALL_META_TABLE_NAME: &str = "public.eth_call_meta";
 
     mod public {
         pub(super) use super::super::public::ethereum_networks;
@@ -146,27 +211,27 @@ mod data {
     // Helper for literal SQL queries that look up a block hash
     #[derive(QueryableByName)]
     struct BlockHashText {
-        #[sql_type = "Text"]
+        #[diesel(sql_type = Text)]
         hash: String,
     }
 
     #[derive(QueryableByName)]
     struct BlockHashBytea {
-        #[sql_type = "Bytea"]
+        #[diesel(sql_type = Bytea)]
         hash: Vec<u8>,
     }
 
-    // Like H256::from_slice, but returns an error instead of panicking
+    // Like B256::from_slice, but returns an error instead of panicking
     // when `bytes` does not have the right length
-    fn h256_from_bytes(bytes: &[u8]) -> Result<H256, StoreError> {
-        if bytes.len() == H256::len_bytes() {
-            Ok(H256::from_slice(bytes))
+    fn b256_from_bytes(bytes: &[u8]) -> Result<B256, StoreError> {
+        if bytes.len() == B256::len_bytes() {
+            Ok(B256::from_slice(bytes))
         } else {
-            Err(constraint_violation!(
+            Err(internal_error!(
                 "invalid H256 value `{}` has {} bytes instead of {}",
                 graph::prelude::hex::encode(bytes),
                 bytes.len(),
-                H256::len_bytes()
+                B256::len_bytes()
             ))
         }
     }
@@ -304,7 +369,8 @@ mod data {
     }
 
     #[derive(Clone, Debug, AsExpression, FromSqlRow)]
-    #[sql_type = "diesel::sql_types::Text"]
+    #[diesel(sql_type = Text)]
+    #[allow(clippy::large_enum_variant)]
     /// Storage for a chain. The underlying namespace (database schema) is either
     /// `public` or of the form `chain[0-9]+`.
     pub enum Storage {
@@ -325,15 +391,16 @@ mod data {
     }
 
     impl FromSql<Text, Pg> for Storage {
-        fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
+        fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
             let s = <String as FromSql<Text, Pg>>::from_sql(bytes)?;
             Self::new(s).map_err(Into::into)
         }
     }
 
     impl ToSql<Text, Pg> for Storage {
-        fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> diesel::serialize::Result {
-            <String as ToSql<Text, Pg>>::to_sql(&self.to_string(), out)
+        fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
+            let s = self.to_string();
+            <String as ToSql<Text, Pg>>::to_sql(&s, &mut out.reborrow())
         }
     }
 
@@ -341,7 +408,7 @@ mod data {
         const PREFIX: &'static str = "chain";
         const PUBLIC: &'static str = "public";
 
-        fn new(s: String) -> Result<Self, String> {
+        pub fn new(s: String) -> Result<Self, String> {
             if s.as_str() == Self::PUBLIC {
                 return Ok(Self::Shared);
             }
@@ -362,7 +429,7 @@ mod data {
         /// `Storage::Private`. If it uses `Storage::Shared`, do nothing since
         /// a regular migration will already have created the `ethereum_blocks`
         /// table
-        pub(super) fn create(&self, conn: &PgConnection) -> Result<(), Error> {
+        pub(super) async fn create(&self, conn: &mut AsyncPgConnection) -> Result<(), Error> {
             fn make_ddl(nsp: &str) -> String {
                 format!(
                     "
@@ -376,10 +443,10 @@ mod data {
                 create index blocks_number ON {nsp}.blocks using btree(number);
 
                 create table {nsp}.call_cache (
-	              id               bytea not null primary key,
-	              return_value     bytea not null,
-	              contract_address bytea not null,
-	              block_number     int4 not null
+                  id               bytea not null primary key,
+                  return_value     bytea not null,
+                  contract_address bytea not null,
+                  block_number     int4 not null
                 );
                 create index call_cache_block_number_idx ON {nsp}.call_cache(block_number);
 
@@ -395,7 +462,7 @@ mod data {
             match self {
                 Storage::Shared => Ok(()),
                 Storage::Private(Schema { name, .. }) => {
-                    conn.batch_execute(&make_ddl(name))?;
+                    conn.batch_execute(&make_ddl(name)).await?;
                     Ok(())
                 }
             }
@@ -410,45 +477,56 @@ mod data {
             }
         }
 
-        pub(super) fn drop_storage(
+        pub(super) async fn drop_storage(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             name: &str,
         ) -> Result<(), StoreError> {
             match &self {
                 Storage::Shared => {
                     use public::ethereum_blocks as b;
-                    delete(b::table.filter(b::network_name.eq(name))).execute(conn)?;
+                    delete(b::table.filter(b::network_name.eq(name)))
+                        .execute(conn)
+                        .await?;
                     Ok(())
                 }
                 Storage::Private(Schema { name, .. }) => {
-                    conn.batch_execute(&format!("drop schema {} cascade", name))?;
+                    conn.batch_execute(&format!("drop schema {} cascade", name))
+                        .await?;
                     Ok(())
                 }
             }
         }
 
-        pub(super) fn truncate_block_cache(&self, conn: &PgConnection) -> Result<(), StoreError> {
+        pub(super) async fn truncate_block_cache(
+            &self,
+            conn: &mut AsyncPgConnection,
+        ) -> Result<(), StoreError> {
             let table_name = match &self {
                 Storage::Shared => ETHEREUM_BLOCKS_TABLE_NAME,
                 Storage::Private(Schema { blocks, .. }) => &blocks.qname,
             };
-            conn.batch_execute(&format!("truncate table {} restart identity", table_name))?;
+            conn.batch_execute(&format!("truncate table {} restart identity", table_name))
+                .await?;
             Ok(())
         }
 
-        fn truncate_call_cache(&self, conn: &PgConnection) -> Result<(), StoreError> {
+        async fn truncate_call_cache(
+            &self,
+            conn: &mut AsyncPgConnection,
+        ) -> Result<(), StoreError> {
             let table_name = match &self {
                 Storage::Shared => ETHEREUM_CALL_CACHE_TABLE_NAME,
                 Storage::Private(Schema { call_cache, .. }) => &call_cache.qname,
             };
-            conn.batch_execute(&format!("truncate table {} restart identity", table_name))?;
+            conn.batch_execute(&format!("truncate table {} restart identity", table_name))
+                .await?;
             Ok(())
         }
 
-        pub(super) fn cleanup_shallow_blocks(
+        pub(super) async fn cleanup_shallow_blocks(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             lowest_block: i32,
         ) -> Result<(), StoreError> {
             let table_name = match &self {
@@ -458,47 +536,42 @@ mod data {
             conn.batch_execute(&format!(
                 "delete from {} WHERE number >= {} AND data->'block'->'data' = 'null'::jsonb;",
                 table_name, lowest_block,
-            ))?;
+            ))
+            .await?;
             Ok(())
         }
 
-        pub(super) fn remove_cursor(
+        pub(super) async fn remove_cursor(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             chain: &str,
         ) -> Result<Option<BlockNumber>, StoreError> {
             use diesel::dsl::not;
-            use public::ethereum_networks::dsl::*;
+            use public::ethereum_networks as n;
 
-            match update(
-                ethereum_networks
-                    .filter(name.eq(chain))
-                    .filter(not(head_block_cursor.is_null())),
+            let head_block_number = update(
+                n::table
+                    .filter(n::name.eq(chain))
+                    .filter(not(n::head_block_cursor.is_null())),
             )
-            .set(head_block_cursor.eq(None as Option<String>))
-            .returning(head_block_number)
+            .set(n::head_block_cursor.eq(None as Option<String>))
+            .returning(n::head_block_number)
             .get_result::<Option<i64>>(conn)
-            .optional()
-            {
-                Ok(res) => match res {
-                    Some(opt_num) => match opt_num {
-                        Some(num) => Ok(Some(num as i32)),
-                        None => Ok(None),
-                    },
-                    None => Ok(None),
-                },
-                Err(e) => Err(e),
-            }
-            .map_err(Into::into)
+            .await
+            .optional()?
+            .flatten()
+            .map(|num| num as i32);
+
+            Ok(head_block_number)
         }
 
         /// Insert a block. If the table already contains a block with the
         /// same hash, then overwrite that block since it may be adding
         /// transaction receipts. If `overwrite` is `true`, overwrite a
         /// possibly existing entry. If it is `false`, keep the old entry.
-        pub(super) fn upsert_block(
+        pub(super) async fn upsert_block(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             chain: &str,
             block: &dyn Block,
             overwrite: bool,
@@ -534,13 +607,15 @@ mod data {
                             .on_conflict(b::hash)
                             .do_update()
                             .set(values)
-                            .execute(conn)?;
+                            .execute(conn)
+                            .await?;
                     } else {
                         insert_into(b::table)
                             .values(values.clone())
                             .on_conflict(b::hash)
                             .do_nothing()
-                            .execute(conn)?;
+                            .execute(conn)
+                            .await?;
                     }
                 }
                 Storage::Private(Schema { blocks, .. }) => {
@@ -565,20 +640,67 @@ mod data {
                         .bind::<BigInt, _>(number)
                         .bind::<Bytea, _>(parent_hash.as_slice())
                         .bind::<Jsonb, _>(data)
-                        .execute(conn)?;
+                        .execute(conn)
+                        .await?;
                 }
             };
             Ok(())
         }
 
-        pub(super) fn blocks(
+        pub(super) async fn block_ptrs_by_numbers(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             chain: &str,
-            hashes: &[BlockHash],
+            numbers: &[BlockNumber],
         ) -> Result<Vec<JsonBlock>, StoreError> {
-            use diesel::dsl::any;
+            let x = match self {
+                Storage::Shared => {
+                    use public::ethereum_blocks as b;
+
+                    b::table
+                        .select((
+                            b::hash,
+                            b::number,
+                            b::parent_hash,
+                            sql::<Jsonb>("coalesce(data -> 'block', data)"),
+                        ))
+                        .filter(b::network_name.eq(chain))
+                        .filter(b::number.eq_any(Vec::from_iter(numbers.iter().map(|&n| n as i64))))
+                        .load::<(BlockHash, i64, BlockHash, json::Value)>(conn)
+                        .await
+                }
+                Storage::Private(Schema { blocks, .. }) => {
+                    blocks
+                        .table()
+                        .select((
+                            blocks.hash(),
+                            blocks.number(),
+                            blocks.parent_hash(),
+                            sql::<Jsonb>("coalesce(data -> 'block', data)"),
+                        ))
+                        .filter(
+                            blocks
+                                .number()
+                                .eq_any(Vec::from_iter(numbers.iter().map(|&n| n as i64))),
+                        )
+                        .load::<(BlockHash, i64, BlockHash, json::Value)>(conn)
+                        .await
+                }
+            }?;
+
+            Ok(x.into_iter()
+                .map(|(hash, nr, parent, data)| {
+                    JsonBlock::new(BlockPtr::new(hash, nr as i32), parent, Some(data))
+                })
+                .collect())
+        }
 
+        pub(super) async fn blocks(
+            &self,
+            conn: &mut AsyncPgConnection,
+            chain: &str,
+            hashes: &[BlockHash],
+        ) -> Result<Vec<JsonBlock>, StoreError> {
             // We need to deal with chain stores where some entries have a
             // toplevel 'block' field and others directly contain what would
             // be in the 'block' field. Make sure we return the contents of
@@ -598,25 +720,30 @@ mod data {
                             sql::<Jsonb>("coalesce(data -> 'block', data)"),
                         ))
                         .filter(b::network_name.eq(chain))
-                        .filter(b::hash.eq(any(Vec::from_iter(
-                            hashes.iter().map(|h| format!("{:x}", h)),
-                        ))))
+                        .filter(
+                            b::hash
+                                .eq_any(Vec::from_iter(hashes.iter().map(|h| format!("{:x}", h)))),
+                        )
                         .load::<(BlockHash, i64, BlockHash, json::Value)>(conn)
+                        .await
+                }
+                Storage::Private(Schema { blocks, .. }) => {
+                    blocks
+                        .table()
+                        .select((
+                            blocks.hash(),
+                            blocks.number(),
+                            blocks.parent_hash(),
+                            sql::<Jsonb>("coalesce(data -> 'block', data)"),
+                        ))
+                        .filter(
+                            blocks
+                                .hash()
+                                .eq_any(Vec::from_iter(hashes.iter().map(|h| h.as_slice()))),
+                        )
+                        .load::<(BlockHash, i64, BlockHash, json::Value)>(conn)
+                        .await
                 }
-                Storage::Private(Schema { blocks, .. }) => blocks
-                    .table()
-                    .select((
-                        blocks.hash(),
-                        blocks.number(),
-                        blocks.parent_hash(),
-                        sql::<Jsonb>("coalesce(data -> 'block', data)"),
-                    ))
-                    .filter(
-                        blocks
-                            .hash()
-                            .eq(any(Vec::from_iter(hashes.iter().map(|h| h.as_slice())))),
-                    )
-                    .load::<(BlockHash, i64, BlockHash, json::Value)>(conn),
             }?;
             Ok(x.into_iter()
                 .map(|(hash, nr, parent, data)| {
@@ -625,9 +752,76 @@ mod data {
                 .collect())
         }
 
-        pub(super) fn block_hashes_by_block_number(
+        /// Return the parent block pointer for the block with the given hash.
+        /// Only reads header columns, not the data column.
+        pub(super) async fn block_parent_ptr(
+            &self,
+            conn: &mut AsyncPgConnection,
+            chain: &str,
+            hash: &BlockHash,
+        ) -> Result<Option<BlockPtr>, Error> {
+            let result = match self {
+                Storage::Shared => {
+                    use public::ethereum_blocks as b;
+
+                    let (child, parent) = diesel::alias!(
+                        public::ethereum_blocks as child,
+                        public::ethereum_blocks as parent
+                    );
+
+                    child
+                        .inner_join(
+                            parent.on(child
+                                .field(b::parent_hash)
+                                .assume_not_null()
+                                .eq(parent.field(b::hash))
+                                .and(parent.field(b::network_name).eq(chain))),
+                        )
+                        .select((parent.field(b::hash), parent.field(b::number)))
+                        .filter(child.field(b::hash).eq(format!("{:x}", hash)))
+                        .filter(child.field(b::network_name).eq(chain))
+                        .first::<(String, i64)>(conn)
+                        .await
+                        .optional()?
+                        .map(|(h, n)| {
+                            Ok::<_, Error>(BlockPtr::new(h.parse()?, i32::try_from(n).unwrap()))
+                        })
+                        .transpose()?
+                }
+                Storage::Private(Schema { blocks, .. }) => {
+                    // We can't use diesel::alias! here because the table is
+                    // dynamic, so we write the SQL query manually
+
+                    let query = format!(
+                        "SELECT parent.hash, parent.number \
+                         FROM {qname} child, {qname} parent \
+                         WHERE child.hash = $1 \
+                         AND child.parent_hash = parent.hash",
+                        qname = blocks.qname
+                    );
+
+                    #[derive(QueryableByName)]
+                    struct BlockHashAndNumber {
+                        #[diesel(sql_type = Bytea)]
+                        hash: Vec<u8>,
+                        #[diesel(sql_type = BigInt)]
+                        number: i64,
+                    }
+
+                    sql_query(query)
+                        .bind::<Bytea, _>(hash.as_slice())
+                        .get_result::<BlockHashAndNumber>(conn)
+                        .await
+                        .optional()?
+                        .map(|block| BlockPtr::from((block.hash, block.number)))
+                }
+            };
+            Ok(result)
+        }
+
+        pub(super) async fn block_hashes_by_block_number(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             chain: &str,
             number: BlockNumber,
         ) -> Result<Vec<BlockHash>, Error> {
@@ -639,26 +833,27 @@ mod data {
                         .select(b::hash)
                         .filter(b::network_name.eq(&chain))
                         .filter(b::number.eq(number as i64))
-                        .get_results::<String>(conn)?
+                        .get_results::<String>(conn)
+                        .await?
                         .into_iter()
                         .map(|h| h.parse())
                         .collect::<Result<Vec<BlockHash>, _>>()
-                        .map_err(Error::from)
                 }
                 Storage::Private(Schema { blocks, .. }) => Ok(blocks
                     .table()
                     .select(blocks.hash())
                     .filter(blocks.number().eq(number as i64))
-                    .get_results::<Vec<u8>>(conn)?
+                    .get_results::<Vec<u8>>(conn)
+                    .await?
                     .into_iter()
                     .map(BlockHash::from)
                     .collect::<Vec<BlockHash>>()),
             }
         }
 
-        pub(super) fn confirm_block_hash(
+        pub(super) async fn confirm_block_hash(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             chain: &str,
             number: BlockNumber,
             hash: &BlockHash,
@@ -675,6 +870,7 @@ mod data {
                         .filter(b::number.eq(number))
                         .filter(b::hash.ne(&hash))
                         .execute(conn)
+                        .await
                         .map_err(Error::from)
                 }
                 Storage::Private(Schema { blocks, .. }) => {
@@ -686,6 +882,7 @@ mod data {
                         .bind::<BigInt, _>(number)
                         .bind::<Bytea, _>(hash.as_slice())
                         .execute(conn)
+                        .await
                         .map_err(Error::from)
                 }
             }
@@ -693,11 +890,11 @@ mod data {
 
         /// timestamp's representation depends the blockchain::Block implementation, on
         /// ethereum this is a U256 but on different chains it will most likely be different.
-        pub(super) fn block_number(
+        pub(super) async fn block_number(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             hash: &BlockHash,
-        ) -> Result<Option<(BlockNumber, Option<u64>)>, StoreError> {
+        ) -> Result<Option<(BlockNumber, Option<u64>, Option<BlockHash>)>, StoreError> {
             const TIMESTAMP_QUERY: &str =
                 "coalesce(data->'block'->>'timestamp', data->>'timestamp')";
 
@@ -706,40 +903,104 @@ mod data {
                     use public::ethereum_blocks as b;
 
                     b::table
-                        .select((b::number, sql(TIMESTAMP_QUERY)))
+                        .select((
+                            b::number,
+                            sql::<Nullable<Text>>(TIMESTAMP_QUERY),
+                            b::parent_hash,
+                        ))
                         .filter(b::hash.eq(format!("{:x}", hash)))
-                        .first::<(i64, Option<String>)>(conn)
+                        .first::<(i64, Option<String>, Option<String>)>(conn)
+                        .await
                         .optional()?
+                        .map(|(number, ts, parent_hash)| {
+                            // Convert parent_hash from Hex String to Vec<u8>
+                            let parent_hash_bytes = parent_hash
+                                .map(|h| hex::decode(&h).expect("Invalid hex in parent_hash"));
+                            (number, ts, parent_hash_bytes)
+                        })
                 }
                 Storage::Private(Schema { blocks, .. }) => blocks
                     .table()
-                    .select((blocks.number(), sql(TIMESTAMP_QUERY)))
+                    .select((
+                        blocks.number(),
+                        sql::<Nullable<Text>>(TIMESTAMP_QUERY),
+                        blocks.parent_hash(),
+                    ))
                     .filter(blocks.hash().eq(hash.as_slice()))
-                    .first::<(i64, Option<String>)>(conn)
-                    .optional()?,
+                    .first::<(i64, Option<String>, Vec<u8>)>(conn)
+                    .await
+                    .optional()?
+                    .map(|(number, ts, parent_hash)| (number, ts, Some(parent_hash))),
             };
 
             match number {
                 None => Ok(None),
-                Some((number, ts)) => {
+                Some((number, ts, parent_hash)) => {
                     let number = BlockNumber::try_from(number)
                         .map_err(|e| StoreError::QueryExecutionError(e.to_string()))?;
-                    Ok(Some((number, crate::chain_store::try_parse_timestamp(ts)?)))
+                    Ok(Some((
+                        number,
+                        crate::chain_store::try_parse_timestamp(ts)?,
+                        parent_hash.map(BlockHash::from),
+                    )))
                 }
             }
         }
 
+        pub(super) async fn block_numbers(
+            &self,
+            conn: &mut AsyncPgConnection,
+            hashes: &[BlockHash],
+        ) -> Result<HashMap<BlockHash, BlockNumber>, StoreError> {
+            let pairs = match self {
+                Storage::Shared => {
+                    use public::ethereum_blocks as b;
+
+                    let hashes = hashes
+                        .iter()
+                        .map(|h| format!("{:x}", h))
+                        .collect::<Vec<String>>();
+
+                    b::table
+                        .select((b::hash, b::number))
+                        .filter(b::hash.eq_any(hashes))
+                        .load::<(String, i64)>(conn)
+                        .await?
+                        .into_iter()
+                        .map(|(hash, n)| {
+                            let hash = hex::decode(&hash).expect("Invalid hex in parent_hash");
+                            (BlockHash::from(hash), n)
+                        })
+                        .collect::<Vec<_>>()
+                }
+                Storage::Private(Schema { blocks, .. }) => {
+                    // let hashes: Vec<_> = hashes.into_iter().map(|hash| &hash.0).collect();
+                    blocks
+                        .table()
+                        .select((blocks.hash(), blocks.number()))
+                        .filter(blocks.hash().eq_any(hashes))
+                        .load::<(BlockHash, i64)>(conn)
+                        .await?
+                }
+            };
+
+            let pairs = pairs
+                .into_iter()
+                .map(|(hash, number)| (hash, number as i32));
+            Ok(HashMap::from_iter(pairs))
+        }
+
         /// Find the first block that is missing from the database needed to
         /// complete the chain from block `hash` to the block with number
         /// `first_block`.
-        pub(super) fn missing_parent(
+        pub(super) async fn missing_parent(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             chain: &str,
             first_block: i64,
-            hash: H256,
-            genesis: H256,
-        ) -> Result<Option<H256>, Error> {
+            hash: B256,
+            genesis: B256,
+        ) -> Result<Option<B256>, Error> {
             match self {
                 Storage::Shared => {
                     // We recursively build a temp table 'chain' containing the hash and
@@ -780,7 +1041,8 @@ mod data {
                         .bind::<Text, _>(&hash)
                         .bind::<Text, _>(&genesis)
                         .bind::<BigInt, _>(first_block)
-                        .load::<BlockHashText>(conn)?;
+                        .load::<BlockHashText>(conn)
+                        .await?;
 
                     let missing = match missing.len() {
                         0 => None,
@@ -822,14 +1084,15 @@ mod data {
                     );
 
                     let missing = sql_query(query)
-                        .bind::<Bytea, _>(hash.as_bytes())
-                        .bind::<Bytea, _>(genesis.as_bytes())
+                        .bind::<Bytea, _>(hash.as_slice())
+                        .bind::<Bytea, _>(genesis.as_slice())
                         .bind::<BigInt, _>(first_block)
-                        .load::<BlockHashBytea>(conn)?;
+                        .load::<BlockHashBytea>(conn)
+                        .await?;
 
                     let missing = match missing.len() {
                         0 => None,
-                        1 => Some(h256_from_bytes(&missing[0].hash)?),
+                        1 => Some(b256_from_bytes(&missing[0].hash)?),
                         _ => {
                             unreachable!("the query can only return no or one row")
                         }
@@ -843,9 +1106,9 @@ mod data {
         /// with a higher block number than the current chain head. The returned
         /// value if the hash and number of the candidate and the genesis block
         /// hash for the chain
-        pub(super) fn chain_head_candidate(
+        pub(super) async fn chain_head_candidate(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             chain: &str,
         ) -> Result<Option<BlockPtr>, Error> {
             use public::ethereum_networks as n;
@@ -853,7 +1116,8 @@ mod data {
             let head = n::table
                 .filter(n::name.eq(chain))
                 .select(n::head_block_number)
-                .first::<Option<i64>>(conn)?
+                .first::<Option<i64>>(conn)
+                .await?
                 .unwrap_or(-1);
 
             match self {
@@ -865,6 +1129,7 @@ mod data {
                         .order_by((b::number.desc(), b::hash))
                         .select((b::hash, b::number))
                         .first::<(String, i64)>(conn)
+                        .await
                         .optional()?
                         .map(|(hash, number)| BlockPtr::try_from((hash.as_str(), number)))
                         .transpose()
@@ -875,84 +1140,135 @@ mod data {
                     .order_by((blocks.number().desc(), blocks.hash()))
                     .select((blocks.hash(), blocks.number()))
                     .first::<(Vec<u8>, i64)>(conn)
+                    .await
                     .optional()?
                     .map(|(hash, number)| BlockPtr::try_from((hash.as_slice(), number)))
                     .transpose(),
             }
         }
 
-        pub(super) fn ancestor_block(
+        fn ancestor_block_query(
+            &self,
+            short_circuit_predicate: &str,
+            blocks_table_name: &str,
+        ) -> String {
+            format!(
+                "
+                with recursive ancestors(block_hash, block_offset) as (
+                    values ($1, 0)
+                    union all
+                    select b.parent_hash, a.block_offset + 1
+                    from ancestors a, {blocks_table_name} b
+                    where a.block_hash = b.hash
+                    and a.block_offset < $2
+                    {short_circuit_predicate}
+                )
+                select a.block_hash as hash, b.number as number
+                from ancestors a
+                inner join {blocks_table_name} b on a.block_hash = b.hash
+                order by a.block_offset desc limit 1
+                ",
+                blocks_table_name = blocks_table_name,
+                short_circuit_predicate = short_circuit_predicate,
+            )
+        }
+
+        /// Returns an ancestor of a specified block at a given offset, with an option to specify a `root` hash
+        /// for a targeted search. If a `root` hash is provided, the search stops at the block whose parent hash
+        /// matches the `root`.
+        pub(super) async fn ancestor_block(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             block_ptr: BlockPtr,
             offset: BlockNumber,
+            root: Option<BlockHash>,
         ) -> Result<Option<(json::Value, BlockPtr)>, Error> {
-            let data_and_hash = match self {
+            let short_circuit_predicate = match root {
+                Some(_) => "and b.parent_hash <> $3",
+                None => "",
+            };
+
+            let data_and_ptr = match self {
                 Storage::Shared => {
-                    const ANCESTOR_SQL: &str = "
-        with recursive ancestors(block_hash, block_offset) as (
-            values ($1, 0)
-            union all
-            select b.parent_hash, a.block_offset+1
-              from ancestors a, ethereum_blocks b
-             where a.block_hash = b.hash
-               and a.block_offset < $2
-        )
-        select a.block_hash as hash
-          from ancestors a
-         where a.block_offset = $2;";
+                    let query =
+                        self.ancestor_block_query(short_circuit_predicate, "ethereum_blocks");
+
+                    // type Result = (Text, i64);
+                    #[derive(QueryableByName)]
+                    struct BlockHashAndNumber {
+                        #[diesel(sql_type = Text)]
+                        hash: String,
+                        #[diesel(sql_type = BigInt)]
+                        number: i64,
+                    }
 
-                    let hash = sql_query(ANCESTOR_SQL)
-                        .bind::<Text, _>(block_ptr.hash_hex())
-                        .bind::<BigInt, _>(offset as i64)
-                        .get_result::<BlockHashText>(conn)
-                        .optional()?;
+                    let block = match root {
+                        Some(root) => sql_query(query)
+                            .bind::<Text, _>(block_ptr.hash_hex())
+                            .bind::<BigInt, _>(offset as i64)
+                            .bind::<Text, _>(root.hash_hex())
+                            .get_result::<BlockHashAndNumber>(conn),
+                        None => sql_query(query)
+                            .bind::<Text, _>(block_ptr.hash_hex())
+                            .bind::<BigInt, _>(offset as i64)
+                            .get_result::<BlockHashAndNumber>(conn),
+                    }
+                    .await
+                    .optional()?;
 
                     use public::ethereum_blocks as b;
 
-                    match hash {
+                    match block {
                         None => None,
-                        Some(hash) => Some((
+                        Some(block) => Some((
                             b::table
-                                .filter(b::hash.eq(&hash.hash))
+                                .filter(b::hash.eq(&block.hash))
                                 .select(b::data)
-                                .first::<json::Value>(conn)?,
-                            BlockHash::from_str(&hash.hash)?,
+                                .first::<json::Value>(conn)
+                                .await?,
+                            BlockPtr::new(
+                                BlockHash::from_str(&block.hash)?,
+                                i32::try_from(block.number).unwrap(),
+                            ),
                         )),
                     }
                 }
                 Storage::Private(Schema { blocks, .. }) => {
-                    // Same as ANCESTOR_SQL except for the table name
-                    let query = format!(
-                        "
-        with recursive ancestors(block_hash, block_offset) as (
-            values ($1, 0)
-            union all
-            select b.parent_hash, a.block_offset+1
-              from ancestors a, {} b
-             where a.block_hash = b.hash
-               and a.block_offset < $2
-        )
-        select a.block_hash as hash
-          from ancestors a
-         where a.block_offset = $2;",
-                        blocks.qname
-                    );
+                    let query =
+                        self.ancestor_block_query(short_circuit_predicate, blocks.qname.as_str());
+
+                    #[derive(QueryableByName)]
+                    struct BlockHashAndNumber {
+                        #[diesel(sql_type = Bytea)]
+                        hash: Vec<u8>,
+                        #[diesel(sql_type = BigInt)]
+                        number: i64,
+                    }
+
+                    let block = match &root {
+                        Some(root) => sql_query(query)
+                            .bind::<Bytea, _>(block_ptr.hash_slice())
+                            .bind::<BigInt, _>(offset as i64)
+                            .bind::<Bytea, _>(root.as_slice())
+                            .get_result::<BlockHashAndNumber>(conn),
+                        None => sql_query(query)
+                            .bind::<Bytea, _>(block_ptr.hash_slice())
+                            .bind::<BigInt, _>(offset as i64)
+                            .get_result::<BlockHashAndNumber>(conn),
+                    }
+                    .await
+                    .optional()?;
 
-                    let hash = sql_query(query)
-                        .bind::<Bytea, _>(block_ptr.hash_slice())
-                        .bind::<BigInt, _>(offset as i64)
-                        .get_result::<BlockHashBytea>(conn)
-                        .optional()?;
-                    match hash {
+                    match block {
                         None => None,
-                        Some(hash) => Some((
+                        Some(block) => Some((
                             blocks
                                 .table()
-                                .filter(blocks.hash().eq(&hash.hash))
+                                .filter(blocks.hash().eq(&block.hash))
                                 .select(blocks.data())
-                                .first::<json::Value>(conn)?,
-                            BlockHash::from(hash.hash),
+                                .first::<json::Value>(conn)
+                                .await?,
+                            BlockPtr::from((block.hash, block.number)),
                         )),
                     }
                 }
@@ -967,22 +1283,105 @@ mod data {
             let data_and_ptr = {
                 use graph::prelude::serde_json::json;
 
-                data_and_hash.map(|(data, hash)| {
+                data_and_ptr.map(|(data, ptr)| {
                     (
                         match data.get("block") {
                             Some(_) => data,
                             None => json!({ "block": data, "transaction_receipts": [] }),
                         },
-                        BlockPtr::new(hash, block_ptr.number - offset),
+                        ptr,
                     )
                 })
             };
             Ok(data_and_ptr)
         }
 
-        pub(super) fn delete_blocks_before(
+        /// Like `ancestor_block` but returns only the `BlockPtr` without
+        /// fetching the `data` column.
+        pub(super) async fn ancestor_block_ptr(
+            &self,
+            conn: &mut AsyncPgConnection,
+            block_ptr: BlockPtr,
+            offset: BlockNumber,
+            root: Option<BlockHash>,
+        ) -> Result<Option<BlockPtr>, Error> {
+            let short_circuit_predicate = match root {
+                Some(_) => "and b.parent_hash <> $3",
+                None => "",
+            };
+
+            match self {
+                Storage::Shared => {
+                    let query =
+                        self.ancestor_block_query(short_circuit_predicate, "ethereum_blocks");
+
+                    #[derive(QueryableByName)]
+                    struct BlockHashAndNumber {
+                        #[diesel(sql_type = Text)]
+                        hash: String,
+                        #[diesel(sql_type = BigInt)]
+                        number: i64,
+                    }
+
+                    let block = match root {
+                        Some(root) => sql_query(query)
+                            .bind::<Text, _>(block_ptr.hash_hex())
+                            .bind::<BigInt, _>(offset as i64)
+                            .bind::<Text, _>(root.hash_hex())
+                            .get_result::<BlockHashAndNumber>(conn),
+                        None => sql_query(query)
+                            .bind::<Text, _>(block_ptr.hash_hex())
+                            .bind::<BigInt, _>(offset as i64)
+                            .get_result::<BlockHashAndNumber>(conn),
+                    }
+                    .await
+                    .optional()?;
+
+                    match block {
+                        None => Ok(None),
+                        Some(block) => Ok(Some(BlockPtr::new(
+                            BlockHash::from_str(&block.hash)?,
+                            i32::try_from(block.number).unwrap(),
+                        ))),
+                    }
+                }
+                Storage::Private(Schema { blocks, .. }) => {
+                    let query =
+                        self.ancestor_block_query(short_circuit_predicate, blocks.qname.as_str());
+
+                    #[derive(QueryableByName)]
+                    struct BlockHashAndNumber {
+                        #[diesel(sql_type = Bytea)]
+                        hash: Vec<u8>,
+                        #[diesel(sql_type = BigInt)]
+                        number: i64,
+                    }
+
+                    let block = match &root {
+                        Some(root) => sql_query(query)
+                            .bind::<Bytea, _>(block_ptr.hash_slice())
+                            .bind::<BigInt, _>(offset as i64)
+                            .bind::<Bytea, _>(root.as_slice())
+                            .get_result::<BlockHashAndNumber>(conn),
+                        None => sql_query(query)
+                            .bind::<Bytea, _>(block_ptr.hash_slice())
+                            .bind::<BigInt, _>(offset as i64)
+                            .get_result::<BlockHashAndNumber>(conn),
+                    }
+                    .await
+                    .optional()?;
+
+                    match block {
+                        None => Ok(None),
+                        Some(block) => Ok(Some(BlockPtr::from((block.hash, block.number)))),
+                    }
+                }
+            }
+        }
+
+        pub(super) async fn delete_blocks_before(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             chain: &str,
             block: i64,
         ) -> Result<usize, Error> {
@@ -995,6 +1394,7 @@ mod data {
                         .filter(b::number.lt(block))
                         .filter(b::number.gt(0))
                         .execute(conn)
+                        .await
                         .map_err(Error::from)
                 }
                 Storage::Private(Schema { blocks, .. }) => {
@@ -1005,18 +1405,18 @@ mod data {
                     sql_query(query)
                         .bind::<BigInt, _>(block)
                         .execute(conn)
+                        .await
                         .map_err(Error::from)
                 }
             }
         }
 
-        pub(super) fn delete_blocks_by_hash(
+        pub(super) async fn delete_blocks_by_hash(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             chain: &str,
-            block_hashes: &[&H256],
+            block_hashes: &[&B256],
         ) -> Result<usize, Error> {
-            use diesel::dsl::any;
             match self {
                 Storage::Shared => {
                     use public::ethereum_blocks as b;
@@ -1028,9 +1428,10 @@ mod data {
 
                     diesel::delete(b::table)
                         .filter(b::network_name.eq(chain))
-                        .filter(b::hash.eq(any(hashes)))
+                        .filter(b::hash.eq_any(hashes))
                         .filter(b::number.gt(0)) // keep genesis
                         .execute(conn)
+                        .await
                         .map_err(Error::from)
                 }
                 Storage::Private(Schema { blocks, .. }) => {
@@ -1040,21 +1441,22 @@ mod data {
                     );
 
                     let hashes: Vec<&[u8]> =
-                        block_hashes.iter().map(|hash| hash.as_bytes()).collect();
+                        block_hashes.iter().map(|hash| hash.as_slice()).collect();
 
                     sql_query(query)
                         .bind::<Array<Bytea>, _>(hashes)
                         .execute(conn)
+                        .await
                         .map_err(Error::from)
                 }
             }
         }
 
-        pub(super) fn get_call_and_access(
+        pub(super) async fn get_call_and_access(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             id: &[u8],
-        ) -> Result<Option<(Vec<u8>, bool)>, Error> {
+        ) -> Result<Option<(Bytes, bool)>, Error> {
             match self {
                 Storage::Shared => {
                     use public::eth_call_cache as cache;
@@ -1065,9 +1467,10 @@ mod data {
                         .inner_join(meta::table)
                         .select((
                             cache::return_value,
-                            sql("CURRENT_DATE > eth_call_meta.accessed_at"),
+                            sql::<Bool>("CURRENT_DATE > eth_call_meta.accessed_at"),
                         ))
                         .get_result(conn)
+                        .await
                         .optional()
                         .map_err(Error::from)
                 }
@@ -1085,21 +1488,76 @@ mod data {
                     .filter(call_cache.id().eq(id))
                     .select((
                         call_cache.return_value(),
-                        sql(&format!(
+                        sql::<Bool>(&format!(
                             "CURRENT_DATE > {}.{}",
                             CallMetaTable::TABLE_NAME,
                             CallMetaTable::ACCESSED_AT
                         )),
                     ))
-                    .first(conn)
+                    .first::<(Vec<u8>, bool)>(conn)
+                    .await
                     .optional()
                     .map_err(Error::from),
             }
+            .map(|row| row.map(|(return_value, expired)| (Bytes::from(return_value), expired)))
+        }
+
+        pub(super) async fn get_calls_and_access(
+            &self,
+            conn: &mut AsyncPgConnection,
+            ids: &[&[u8]],
+        ) -> Result<Vec<(Vec<u8>, Bytes, bool)>, Error> {
+            let rows = match self {
+                Storage::Shared => {
+                    use public::eth_call_cache as cache;
+                    use public::eth_call_meta as meta;
+
+                    cache::table
+                        .inner_join(meta::table)
+                        .filter(cache::id.eq_any(ids))
+                        .select((
+                            cache::id,
+                            cache::return_value,
+                            sql::<Bool>("CURRENT_DATE > eth_call_meta.accessed_at"),
+                        ))
+                        .load(conn)
+                        .await
+                        .map_err(Error::from)
+                }
+                Storage::Private(Schema {
+                    call_cache,
+                    call_meta,
+                    ..
+                }) => call_cache
+                    .table()
+                    .inner_join(
+                        call_meta.table().on(call_meta
+                            .contract_address()
+                            .eq(call_cache.contract_address())),
+                    )
+                    .filter(call_cache.id().eq_any(ids))
+                    .select((
+                        call_cache.id(),
+                        call_cache.return_value(),
+                        sql::<Bool>(&format!(
+                            "CURRENT_DATE > {}.{}",
+                            CallMetaTable::TABLE_NAME,
+                            CallMetaTable::ACCESSED_AT
+                        )),
+                    ))
+                    .load::<(Vec<u8>, Vec<u8>, bool)>(conn)
+                    .await
+                    .map_err(Error::from),
+            }?;
+            Ok(rows
+                .into_iter()
+                .map(|(id, return_value, expired)| (id, Bytes::from(return_value), expired))
+                .collect())
         }
 
-        pub(super) fn get_calls_in_block(
+        pub(super) async fn get_calls_in_block(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             block_ptr: BlockPtr,
         ) -> Result<Vec<CachedEthereumCall>, Error> {
             let block_num = block_ptr.block_number();
@@ -1112,18 +1570,22 @@ mod data {
                         .select((cache::id, cache::return_value, cache::contract_address))
                         .filter(cache::block_number.eq(block_num))
                         .order(cache::contract_address)
-                        .get_results::<(Vec<u8>, Vec<u8>, Vec<u8>)>(conn)?
+                        .get_results::<(Vec<u8>, Vec<u8>, Vec<u8>)>(conn)
+                        .await?
+                }
+                Storage::Private(Schema { call_cache, .. }) => {
+                    call_cache
+                        .table()
+                        .select((
+                            call_cache.id(),
+                            call_cache.return_value(),
+                            call_cache.contract_address(),
+                        ))
+                        .filter(call_cache.block_number().eq(block_num as i64))
+                        .order(call_cache.contract_address())
+                        .get_results::<(Vec<u8>, Vec<u8>, Vec<u8>)>(conn)
+                        .await?
                 }
-                Storage::Private(Schema { call_cache, .. }) => call_cache
-                    .table()
-                    .select((
-                        call_cache.id(),
-                        call_cache.return_value(),
-                        call_cache.contract_address(),
-                    ))
-                    .filter(call_cache.block_number().eq(block_num as i64))
-                    .order(call_cache.contract_address())
-                    .get_results::<(Vec<u8>, Vec<u8>, Vec<u8>)>(conn)?,
             };
 
             Ok(rows
@@ -1131,15 +1593,15 @@ mod data {
                 .map(|row| CachedEthereumCall {
                     blake3_id: row.0,
                     block_ptr: block_ptr.clone(),
-                    contract_address: H160::from_slice(&row.2[..]),
+                    contract_address: Address::from_slice(&row.2[..]),
                     return_value: row.1,
                 })
                 .collect())
         }
 
-        pub(super) fn clear_call_cache(
+        pub(super) async fn clear_call_cache(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             head: BlockNumber,
             from: BlockNumber,
             to: BlockNumber,
@@ -1147,7 +1609,7 @@ mod data {
             if from <= 0 && to >= head {
                 // We are removing the entire cache. Truncating is much
                 // faster in that case
-                self.truncate_call_cache(conn)?;
+                self.truncate_call_cache(conn).await?;
                 return Ok(());
             }
             match self {
@@ -1159,6 +1621,7 @@ mod data {
                             .filter(cache::block_number.le(to)),
                     )
                     .execute(conn)
+                    .await
                     .map_err(Error::from)?;
                     Ok(())
                 }
@@ -1174,24 +1637,208 @@ mod data {
                         .bind::<Integer, _>(from)
                         .bind::<Integer, _>(to)
                         .execute(conn)
+                        .await
                         .map_err(Error::from)
                         .map(|_| ())
                 }
             }
         }
 
-        pub(super) fn update_accessed_at(
+        /// Ensure that an index on `contract_address` exists on the
+        /// call_cache table to speed up deletion queries. If the index does
+        /// not exist, create it concurrently.
+        pub(super) async fn ensure_contract_address_index(
             &self,
-            conn: &PgConnection,
-            contract_address: &[u8],
-        ) -> Result<(), Error> {
-            let result = match self {
-                Storage::Shared => {
-                    use public::eth_call_meta as meta;
+            conn: &mut AsyncPgConnection,
+            logger: &Logger,
+        ) -> Result<(), StoreError> {
+            const CONTRACT_INDEX: &str = "call_cache_contract_address";
+
+            let (schema_name, table_qname) = match self {
+                Storage::Shared => ("public", "public.eth_call_cache".to_string()),
+                Storage::Private(Schema {
+                    name, call_cache, ..
+                }) => (name.as_str(), call_cache.qname.clone()),
+            };
+
+            let has_index = catalog::table_has_index(conn, schema_name, CONTRACT_INDEX).await?;
+
+            let idx_valid =
+                catalog::check_index_is_valid(conn, schema_name, CONTRACT_INDEX).await?;
+
+            if has_index && idx_valid {
+                return Ok(());
+            }
+
+            if !idx_valid {
+                conn.batch_execute(&format!(
+                    "drop index concurrently if exists {schema_name}.{}",
+                    CONTRACT_INDEX
+                ))
+                .await?;
+            }
+
+            let start = Instant::now();
+            info!(
+                logger,
+                "Creating index {} on {}.contract_address; \
+                     this may take a long time",
+                CONTRACT_INDEX,
+                table_qname
+            );
+            conn.batch_execute(&format!(
+                "create index concurrently {} on {}(contract_address)",
+                CONTRACT_INDEX, table_qname
+            ))
+            .await?;
+            let duration = start.elapsed();
+            info!(
+                logger,
+                "Finished creating index {} on {}.contract_address in {:?}",
+                CONTRACT_INDEX,
+                table_qname,
+                duration
+            );
+
+            Ok(())
+        }
+
+        /// Delete up to `batch_size` call_cache rows whose contract_address
+        /// appears in call_meta with accessed_at older than `ttl_days`.
+        /// Returns the number of deleted rows.
+        pub(super) async fn delete_stale_calls_batch(
+            &self,
+            conn: &mut AsyncPgConnection,
+            ttl_days: i64,
+            batch_size: i64,
+        ) -> Result<usize, StoreError> {
+            let (cache, meta) = match self {
+                Storage::Shared => (
+                    ETHEREUM_CALL_CACHE_TABLE_NAME,
+                    ETHEREUM_CALL_META_TABLE_NAME,
+                ),
+                Storage::Private(Schema {
+                    call_cache,
+                    call_meta,
+                    ..
+                }) => (call_cache.qname.as_str(), call_meta.qname.as_str()),
+            };
+            let query = format!(
+                "/* controller='call_cache_cleanup',days={ttl_days},batch_size={batch_size} */ \
+                 delete from {cache}
+                    where ctid in (
+                        select cc.ctid
+                        from {cache} cc
+                        join {meta} cm
+                          on cc.contract_address = cm.contract_address
+                        where cm.accessed_at < current_date - $1 * interval '1 day'
+                        limit $2
+                    )"
+            );
+            sql_query(&query)
+                .bind::<BigInt, _>(ttl_days)
+                .bind::<BigInt, _>(batch_size)
+                .execute(conn)
+                .await
+                .map_err(StoreError::from)
+        }
+
+        /// Given `ttl_days` and `max_contracts`, compute an effective
+        /// TTL in days such that at most `max_contracts` contracts would
+        /// be evicted. Returns a value >= `ttl_days`.
+        ///
+        /// We look at the (max_contracts+1)th oldest stale contract. If
+        /// it exists with `accessed_at = D`, the effective TTL is set to
+        /// `current_date - D` days, making the deletion cutoff exactly
+        /// `D`. Since the deletion query uses `accessed_at < cutoff`,
+        /// contracts with `accessed_at = D` are excluded, guaranteeing
+        /// at most `max_contracts` deletions.
+        ///
+        /// When multiple contracts share the boundary date, we may
+        /// delete fewer than `max_contracts` since we can only control
+        /// the cutoff at date granularity.
+        pub(super) async fn effective_ttl(
+            &self,
+            conn: &mut AsyncPgConnection,
+            ttl_days: i64,
+            max_contracts: i64,
+        ) -> Result<i64, StoreError> {
+            #[derive(QueryableByName)]
+            struct Row {
+                #[diesel(sql_type = diesel::sql_types::BigInt)]
+                effective_ttl: i64,
+            }
+
+            let meta_table = match self {
+                Storage::Shared => ETHEREUM_CALL_META_TABLE_NAME,
+                Storage::Private(Schema { call_meta, .. }) => call_meta.qname.as_str(),
+            };
+            let query = format!(
+                "select extract(day from current_date - accessed_at)::int8 + 1\
+                        as effective_ttl \
+                   from {meta_table} \
+                  where accessed_at < current_date - $1 * interval '1 day' \
+                  order by accessed_at asc \
+                 offset $2 \
+                  limit 1"
+            );
+            let effective_ttl: Option<i64> = sql_query(&query)
+                .bind::<BigInt, _>(ttl_days)
+                .bind::<BigInt, _>(max_contracts)
+                .get_result::<Row>(conn)
+                .await
+                .optional()?
+                .map(|r| r.effective_ttl);
+
+            Ok(effective_ttl.unwrap_or(ttl_days))
+        }
+
+        /// Delete all call_meta entries with accessed_at older than
+        /// `ttl_days`. Should be called after all corresponding
+        /// call_cache rows have been deleted.
+        pub(super) async fn delete_stale_meta(
+            &self,
+            conn: &mut AsyncPgConnection,
+            ttl_days: i64,
+        ) -> Result<usize, StoreError> {
+            match self {
+                Storage::Shared => {
+                    use public::eth_call_meta as meta;
+
+                    diesel::delete(meta::table.filter(
+                        meta::accessed_at.lt(diesel::dsl::date(diesel::dsl::now - ttl_days.days())),
+                    ))
+                    .execute(conn)
+                    .await
+                    .map_err(StoreError::from)
+                }
+                Storage::Private(Schema { call_meta, .. }) => {
+                    let query = format!(
+                        "delete from {} where accessed_at < current_date - $1 * interval '1 day'",
+                        call_meta.qname
+                    );
+                    sql_query(&query)
+                        .bind::<BigInt, _>(ttl_days)
+                        .execute(conn)
+                        .await
+                        .map_err(StoreError::from)
+                }
+            }
+        }
+
+        pub(super) async fn update_accessed_at(
+            &self,
+            conn: &mut AsyncPgConnection,
+            contract_address: &[u8],
+        ) -> Result<(), Error> {
+            let result = match self {
+                Storage::Shared => {
+                    use public::eth_call_meta as meta;
 
                     update(meta::table.find::<&[u8]>(contract_address.as_ref()))
                         .set(meta::accessed_at.eq(sql("CURRENT_DATE")))
                         .execute(conn)
+                        .await
                 }
                 Storage::Private(Schema { call_meta, .. }) => {
                     let query = format!(
@@ -1201,14 +1848,15 @@ mod data {
                     sql_query(query)
                         .bind::<Bytea, _>(contract_address)
                         .execute(conn)
+                        .await
                 }
             };
             result.map(|_| ()).map_err(Error::from)
         }
 
-        pub(super) fn set_call(
+        pub(super) async fn set_call(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             id: &[u8],
             contract_address: &[u8],
             block_number: i32,
@@ -1227,14 +1875,16 @@ mod data {
                             cache::return_value.eq(return_value),
                         ))
                         .on_conflict_do_nothing()
-                        .execute(conn)?;
+                        .execute(conn)
+                        .await?;
 
                     // See comment in the Private branch for why the
                     // raciness of this check is ok
                     let update_meta = meta::table
                         .filter(meta::contract_address.eq(contract_address))
-                        .select(sql("accessed_at < current_date"))
+                        .select(sql::<Bool>("accessed_at < current_date"))
                         .first::<bool>(conn)
+                        .await
                         .optional()?
                         .unwrap_or(true);
                     if update_meta {
@@ -1251,6 +1901,7 @@ mod data {
                             // branch to avoid unnecessary updates (not entirely
                             // trivial with diesel)
                             .execute(conn)
+                            .await
                     } else {
                         Ok(0)
                     }
@@ -1270,7 +1921,8 @@ mod data {
                         .bind::<Bytea, _>(contract_address)
                         .bind::<Integer, _>(block_number)
                         .bind::<Bytea, _>(return_value)
-                        .execute(conn)?;
+                        .execute(conn)
+                        .await?;
 
                     // Check whether we need to update `call_meta`. The
                     // check is racy, since an update can happen between the
@@ -1281,8 +1933,9 @@ mod data {
                     let update_meta = call_meta
                         .table()
                         .filter(call_meta.contract_address().eq(contract_address))
-                        .select(sql("accessed_at < current_date"))
+                        .select(sql::<Bool>("accessed_at < current_date"))
                         .first::<bool>(conn)
+                        .await
                         .optional()?
                         .unwrap_or(true);
 
@@ -1298,6 +1951,7 @@ mod data {
                         sql_query(query)
                             .bind::<Bytea, _>(contract_address)
                             .execute(conn)
+                            .await
                     } else {
                         Ok(0)
                     }
@@ -1308,7 +1962,7 @@ mod data {
 
         #[cfg(debug_assertions)]
         // used by `super::set_chain` for test support
-        pub(super) fn remove_chain(&self, conn: &PgConnection, chain_name: &str) {
+        pub(super) async fn remove_chain(&self, conn: &mut AsyncPgConnection, chain_name: &str) {
             match self {
                 Storage::Shared => {
                     use public::eth_call_cache as c;
@@ -1317,11 +1971,12 @@ mod data {
 
                     diesel::delete(b::table.filter(b::network_name.eq(chain_name)))
                         .execute(conn)
+                        .await
                         .expect("Failed to delete ethereum_blocks");
                     // We don't have a good way to clean out the call cache
                     // per chain; just nuke everything
-                    diesel::delete(c::table).execute(conn).unwrap();
-                    diesel::delete(m::table).execute(conn).unwrap();
+                    diesel::delete(c::table).execute(conn).await.unwrap();
+                    diesel::delete(m::table).execute(conn).await.unwrap();
                 }
                 Storage::Private(Schema {
                     blocks,
@@ -1333,6 +1988,7 @@ mod data {
                         let query = format!("delete from {}", qname);
                         sql_query(query)
                             .execute(conn)
+                            .await
                             .unwrap_or_else(|_| panic!("Failed to delete {}", qname));
                     }
                 }
@@ -1340,10 +1996,10 @@ mod data {
         }
 
         /// Queries the database for all the transaction receipts in a given block.
-        pub(crate) fn find_transaction_receipts_in_block(
+        pub(crate) async fn find_transaction_receipts_in_block(
             &self,
-            conn: &PgConnection,
-            block_hash: H256,
+            conn: &mut AsyncPgConnection,
+            block_hash: B256,
         ) -> anyhow::Result<Vec<LightTransactionReceipt>> {
             let query = sql_query(format!(
                 "
@@ -1369,12 +2025,18 @@ from (
                 // `chain*.blocks` tables, so we must check which one is being queried to bind the
                 // `block_hash` parameter to the correct type
                 match self {
-                    Storage::Shared => query
-                        .bind::<Text, _>(format!("{:x}", block_hash))
-                        .get_results(conn),
-                    Storage::Private(_) => query
-                        .bind::<Binary, _>(block_hash.as_bytes())
-                        .get_results(conn),
+                    Storage::Shared => {
+                        query
+                            .bind::<Text, _>(format!("{:x}", block_hash))
+                            .get_results(conn)
+                            .await
+                    }
+                    Storage::Private(_) => {
+                        query
+                            .bind::<Binary, _>(block_hash.as_slice())
+                            .get_results(conn)
+                            .await
+                    }
                 }
             };
             query_results
@@ -1398,6 +2060,10 @@ pub struct ChainStoreMetrics {
     chain_head_cache_latest_block_num: Box<GaugeVec>,
     chain_head_cache_hits: Box<CounterVec>,
     chain_head_cache_misses: Box<CounterVec>,
+    // Metrics for chain_head_ptr() cache
+    chain_head_ptr_cache_hits: Box<CounterVec>,
+    chain_head_ptr_cache_misses: Box<CounterVec>,
+    chain_head_ptr_cache_block_time_ms: Box<GaugeVec>,
 }
 
 impl ChainStoreMetrics {
@@ -1439,12 +2105,37 @@ impl ChainStoreMetrics {
             )
             .expect("Can't register the counter");
 
+        let chain_head_ptr_cache_hits = registry
+            .new_counter_vec(
+                "chain_head_ptr_cache_hits",
+                "Number of times the chain_head_ptr cache was hit",
+                vec!["network".to_string()],
+            )
+            .expect("Can't register the counter");
+        let chain_head_ptr_cache_misses = registry
+            .new_counter_vec(
+                "chain_head_ptr_cache_misses",
+                "Number of times the chain_head_ptr cache was missed",
+                vec!["network".to_string()],
+            )
+            .expect("Can't register the counter");
+        let chain_head_ptr_cache_block_time_ms = registry
+            .new_gauge_vec(
+                "chain_head_ptr_cache_block_time_ms",
+                "Estimated block time in milliseconds used for adaptive cache TTL",
+                vec!["network".to_string()],
+            )
+            .expect("Can't register the gauge");
+
         Self {
             chain_head_cache_size,
             chain_head_cache_oldest_block_num,
             chain_head_cache_latest_block_num,
             chain_head_cache_hits,
             chain_head_cache_misses,
+            chain_head_ptr_cache_hits,
+            chain_head_ptr_cache_misses,
+            chain_head_ptr_cache_block_time_ms,
         }
     }
 
@@ -1484,21 +2175,156 @@ impl ChainStoreMetrics {
             .unwrap()
             .inc_by(misses as f64);
     }
+
+    pub fn record_chain_head_ptr_cache_hit(&self, network: &str) {
+        self.chain_head_ptr_cache_hits
+            .with_label_values(&[network])
+            .inc();
+    }
+
+    pub fn record_chain_head_ptr_cache_miss(&self, network: &str) {
+        self.chain_head_ptr_cache_misses
+            .with_label_values(&[network])
+            .inc();
+    }
+
+    pub fn set_chain_head_ptr_block_time(&self, network: &str, block_time_ms: u64) {
+        self.chain_head_ptr_cache_block_time_ms
+            .with_label_values(&[network])
+            .set(block_time_ms as f64);
+    }
 }
 
-#[derive(Clone)]
-struct BlocksLookupResult(Arc<Result<Vec<JsonBlock>, StoreError>>);
+const MIN_TTL_MS: u64 = 20;
+const MAX_TTL_MS: u64 = 2000;
+const MIN_OBSERVATIONS: u64 = 5;
+
+/// Adaptive cache for chain_head_ptr() that learns optimal TTL from block frequency.
+struct ChainHeadPtrCache {
+    /// Cached value and when it expires
+    entry: RwLock<Option<(BlockPtr, Instant)>>,
+    /// Estimated milliseconds between blocks (EWMA)
+    estimated_block_time_ms: AtomicU64,
+    /// When we last observed the chain head change
+    last_change: RwLock<Instant>,
+    /// Number of block changes observed (for warmup)
+    observations: AtomicU64,
+    /// Metrics for recording cache hits/misses
+    metrics: Arc<ChainStoreMetrics>,
+    /// Chain name for metric labels
+    chain: String,
+}
 
-impl CheapClone for BlocksLookupResult {}
+impl ChainHeadPtrCache {
+    fn new(metrics: Arc<ChainStoreMetrics>, chain: String) -> Self {
+        Self {
+            entry: RwLock::new(None),
+            estimated_block_time_ms: AtomicU64::new(0),
+            last_change: RwLock::new(Instant::now()),
+            observations: AtomicU64::new(0),
+            metrics,
+            chain,
+        }
+    }
+
+    /// Returns cached value if still valid, or None if cache is disabled/missed.
+    /// Records hit/miss metrics automatically.
+    fn get(&self) -> Option<BlockPtr> {
+        if ENV_VARS.store.disable_chain_head_ptr_cache {
+            return None;
+        }
+        let guard = self.entry.read();
+        if let Some((value, expires)) = guard.as_ref()
+            && Instant::now() < *expires
+        {
+            self.metrics.record_chain_head_ptr_cache_hit(&self.chain);
+            return Some(value.clone());
+        }
+        self.metrics.record_chain_head_ptr_cache_miss(&self.chain);
+        None
+    }
+
+    /// Compute current TTL - MIN_TTL during warmup, then 1/4 of estimated block time
+    fn current_ttl(&self) -> Duration {
+        let obs = AtomicU64::load(&self.observations, Ordering::Relaxed);
+        if obs < MIN_OBSERVATIONS {
+            return Duration::from_millis(MIN_TTL_MS);
+        }
+
+        let block_time = AtomicU64::load(&self.estimated_block_time_ms, Ordering::Relaxed);
+        let ttl_ms = (block_time / 4).clamp(MIN_TTL_MS, MAX_TTL_MS);
+        Duration::from_millis(ttl_ms)
+    }
+
+    /// Cache a new value, updating block time estimate if value changed.
+    /// Does nothing if cache is disabled.
+    fn set(&self, new_value: BlockPtr) {
+        if ENV_VARS.store.disable_chain_head_ptr_cache {
+            return;
+        }
+        let now = Instant::now();
+
+        // Check if block changed
+        let old_value = {
+            let guard = self.entry.read();
+            guard.as_ref().map(|(v, _)| v.clone())
+        };
+
+        // Only update estimate if we have a previous value and block number advanced
+        // (skip reorgs where new block number <= old)
+        if let Some(old_ptr) = old_value.as_ref()
+            && new_value.number > old_ptr.number
+        {
+            let mut last_change = self.last_change.write();
+            let delta_ms = now.duration_since(*last_change).as_millis() as u64;
+            *last_change = now;
+
+            let blocks_advanced = (new_value.number - old_ptr.number) as u64;
+
+            // Increment observation count
+            let obs = AtomicU64::fetch_add(&self.observations, 1, Ordering::Relaxed);
+
+            // Ignore unreasonable deltas (> 60s)
+            if delta_ms > 0 && delta_ms < 60_000 {
+                let per_block_ms = delta_ms / blocks_advanced;
+                let new_estimate = if obs == 0 {
+                    // First observation - use as initial estimate
+                    per_block_ms
+                } else {
+                    // EWMA: new = 0.8 * old + 0.2 * observed
+                    let old_estimate =
+                        AtomicU64::load(&self.estimated_block_time_ms, Ordering::Relaxed);
+                    (old_estimate * 4 + per_block_ms) / 5
+                };
+                AtomicU64::store(
+                    &self.estimated_block_time_ms,
+                    new_estimate,
+                    Ordering::Relaxed,
+                );
+
+                // Update metric gauge
+                self.metrics
+                    .set_chain_head_ptr_block_time(&self.chain, new_estimate);
+            }
+        }
+
+        // Compute TTL and store with expiry
+        let ttl = self.current_ttl();
+        *self.entry.write() = Some((new_value, now + ttl));
+    }
+
+    /// Clear the cached value. Used in tests when chain is reset.
+    #[cfg(debug_assertions)]
+    fn clear(&self) {
+        *self.entry.write() = None;
+    }
+}
 
 pub struct ChainStore {
     logger: Logger,
     pool: ConnectionPool,
     pub chain: String,
     pub(crate) storage: data::Storage,
-    pub chain_identifier: ChainIdentifier,
-    genesis_block_ptr: BlockPtr,
-    status: ChainStatus,
     chain_head_update_sender: ChainHeadUpdateSender,
     // TODO: We currently only use this cache for
     // [`ChainStore::ancestor_block`], but it could very well be expanded to
@@ -1507,7 +2333,18 @@ pub struct ChainStore {
     // with the database and to correctly implement invalidation. So, a
     // conservative approach is acceptable.
     recent_blocks_cache: RecentBlocksCache,
-    lookup_herd: HerdCache<BlocksLookupResult>,
+    // Typed herd caches to avoid thundering herd on concurrent lookups
+    blocks_by_hash_cache: HerdCache<Arc<Result<Vec<JsonBlock>, StoreError>>>,
+    blocks_by_number_cache:
+        HerdCache<Arc<Result<BTreeMap<BlockNumber, Vec<JsonBlock>>, StoreError>>>,
+    ancestor_cache: HerdCache<Arc<Result<Option<(CachedBlock, BlockPtr)>, StoreError>>>,
+    /// Adaptive cache for chain_head_ptr()
+    chain_head_ptr_cache: ChainHeadPtrCache,
+    /// Herd cache to prevent thundering herd on chain_head_ptr() lookups
+    chain_head_ptr_herd: HerdCache<Arc<Result<Option<BlockPtr>, StoreError>>>,
+    /// Number of blocks from chain head for which to keep block data cached.
+    /// Used with `GRAPH_STORE_IGNORE_BLOCK_CACHE` to simulate block data eviction.
+    cache_size: BlockNumber,
 }
 
 impl ChainStore {
@@ -1515,43 +2352,74 @@ impl ChainStore {
         logger: Logger,
         chain: String,
         storage: data::Storage,
-        net_identifier: &ChainIdentifier,
-        status: ChainStatus,
         chain_head_update_sender: ChainHeadUpdateSender,
         pool: ConnectionPool,
         recent_blocks_cache_capacity: usize,
         metrics: Arc<ChainStoreMetrics>,
+        cache_size: BlockNumber,
     ) -> Self {
         let recent_blocks_cache =
-            RecentBlocksCache::new(recent_blocks_cache_capacity, chain.clone(), metrics);
-        let lookup_herd = HerdCache::new(format!("chain_{}_herd_cache", chain));
+            RecentBlocksCache::new(recent_blocks_cache_capacity, chain.clone(), metrics.clone());
+        let blocks_by_hash_cache = HerdCache::new(format!("chain_{}_blocks_by_hash", chain));
+        let blocks_by_number_cache = HerdCache::new(format!("chain_{}_blocks_by_number", chain));
+        let ancestor_cache = HerdCache::new(format!("chain_{}_ancestor", chain));
+        let chain_head_ptr_cache = ChainHeadPtrCache::new(metrics, chain.clone());
+        let chain_head_ptr_herd = HerdCache::new(format!("chain_{}_head_ptr", chain));
         ChainStore {
             logger,
             pool,
             chain,
             storage,
-            genesis_block_ptr: BlockPtr::new(net_identifier.genesis_block_hash.clone(), 0),
-            status,
             chain_head_update_sender,
-            chain_identifier: net_identifier.clone(),
             recent_blocks_cache,
-            lookup_herd,
+            blocks_by_hash_cache,
+            blocks_by_number_cache,
+            ancestor_cache,
+            chain_head_ptr_cache,
+            chain_head_ptr_herd,
+            cache_size,
         }
     }
 
-    pub fn is_ingestible(&self) -> bool {
-        matches!(self.status, ChainStatus::Ingestible)
+    /// Return the block number below which blocks should be treated as
+    /// not cached. Returns `0` when the feature is disabled (effectively
+    /// no cutoff). Returns `i32::MAX` when no chain head is known to
+    /// avoid serving stale data.
+    async fn cache_cutoff(self: &Arc<Self>) -> BlockNumber {
+        if !ENV_VARS.store.ignore_block_cache {
+            return 0;
+        }
+        match self.clone().chain_head_ptr().await {
+            Ok(Some(head)) => head.block_number().saturating_sub(self.cache_size),
+            _ => i32::MAX,
+        }
     }
 
-    fn get_conn(&self) -> Result<PooledConnection<ConnectionManager<PgConnection>>, Error> {
-        self.pool.get().map_err(Error::from)
+    /// Execute a cached query, avoiding thundering herd for identical requests.
+    /// Returns `(result, was_cached)`.
+    async fn cached_lookup<K, T, F>(
+        &self,
+        cache: &HerdCache<Arc<Result<T, StoreError>>>,
+        key: &K,
+        lookup: F,
+    ) -> (Result<T, StoreError>, bool)
+    where
+        K: graph::stable_hash::StableHash,
+        T: Clone + Send + 'static,
+        F: Future<Output = Result<T, StoreError>> + Send + 'static,
+    {
+        let hash = crypto_stable_hash(key);
+        let lookup_fut = async move { Arc::new(lookup.await) };
+        let (arc_result, cached) = cache.cached_query(hash, lookup_fut, &self.logger).await;
+        let result = Arc::try_unwrap(arc_result).unwrap_or_else(|arc| (*arc).clone());
+        (result, cached)
     }
 
-    pub(crate) fn create(&self, ident: &ChainIdentifier) -> Result<(), Error> {
+    pub(crate) async fn create(&self, ident: &ChainIdentifier) -> Result<(), Error> {
         use public::ethereum_networks::dsl::*;
 
-        let conn = self.get_conn()?;
-        conn.transaction(|| {
+        let mut conn = self.pool.get_permitted().await?;
+        conn.transaction(async move |conn| {
             insert_into(ethereum_networks)
                 .values((
                     name.eq(&self.chain),
@@ -1563,34 +2431,52 @@ impl ChainStore {
                 ))
                 .on_conflict(name)
                 .do_nothing()
-                .execute(&conn)?;
-            self.storage.create(&conn)
-        })?;
+                .execute(conn)
+                .await?;
+            self.storage.create(conn).await
+        })
+        .await?;
 
         Ok(())
     }
 
-    pub(crate) fn drop_chain(&self) -> Result<(), Error> {
-        use diesel::dsl::delete;
+    pub async fn update_name(&self, name: &str) -> Result<(), Error> {
         use public::ethereum_networks as n;
+        let mut conn = self.pool.get_permitted().await?;
+        conn.transaction(async |conn| {
+            update(n::table.filter(n::name.eq(&self.chain)))
+                .set(n::name.eq(name))
+                .execute(conn)
+                .await?;
+            Ok(())
+        })
+        .await
+    }
 
-        let conn = self.get_conn()?;
-        conn.transaction(|| {
-            self.storage.drop_storage(&conn, &self.chain)?;
+    pub(crate) async fn drop_chain(&self) -> Result<(), Error> {
+        use diesel::dsl::delete;
+        use public::ethereum_networks as n;
 
-            delete(n::table.filter(n::name.eq(&self.chain))).execute(&conn)?;
+        let mut conn = self.pool.get_permitted().await?;
+        conn.transaction(async |conn| {
+            self.storage.drop_storage(conn, &self.chain).await?;
+            delete(n::table.filter(n::name.eq(&self.chain)))
+                .execute(conn)
+                .await?;
             Ok(())
         })
+        .await
     }
 
-    pub fn chain_head_pointers(
-        conn: &PgConnection,
+    pub async fn chain_head_pointers(
+        conn: &mut AsyncPgConnection,
     ) -> Result<HashMap<String, BlockPtr>, StoreError> {
         use public::ethereum_networks as n;
 
         let pointers: Vec<(String, BlockPtr)> = n::table
             .select((n::name, n::head_block_hash, n::head_block_number))
-            .load::<(String, Option<String>, Option<i64>)>(conn)?
+            .load::<(String, Option<String>, Option<i64>)>(conn)
+            .await?
             .into_iter()
             .filter_map(|(name, hash, number)| match (hash, number) {
                 (Some(hash), Some(number)) => Some((name, hash, number)),
@@ -1603,19 +2489,20 @@ impl ChainStore {
         Ok(HashMap::from_iter(pointers))
     }
 
-    pub fn chain_head_block(&self, chain: &str) -> Result<Option<BlockNumber>, StoreError> {
+    pub async fn chain_head_block(&self, chain: &str) -> Result<Option<BlockNumber>, StoreError> {
         use public::ethereum_networks as n;
 
         let number: Option<i64> = n::table
             .filter(n::name.eq(chain))
             .select(n::head_block_number)
-            .first::<Option<i64>>(&self.get_conn()?)
+            .first::<Option<i64>>(&mut self.pool.get_permitted().await?)
+            .await
             .optional()?
             .flatten();
 
         number.map(|number| number.try_into()).transpose().map_err(
             |e: std::num::TryFromIntError| {
-                constraint_violation!(
+                internal_error!(
                     "head block number for {} is {:?} which does not fit into a u32: {}",
                     chain,
                     number,
@@ -1625,6 +2512,30 @@ impl ChainStore {
         )
     }
 
+    pub(crate) async fn set_chain_identifier(&self, ident: &ChainIdentifier) -> Result<(), Error> {
+        use public::ethereum_networks as n;
+
+        let mut conn = self.pool.get_permitted().await?;
+
+        diesel::update(n::table.filter(n::name.eq(&self.chain)))
+            .set((
+                n::genesis_block_hash.eq(ident.genesis_block_hash.hash_hex()),
+                n::net_version.eq(&ident.net_version),
+            ))
+            .execute(&mut conn)
+            .await?;
+
+        Ok(())
+    }
+
+    #[cfg(debug_assertions)]
+    pub async fn set_chain_identifier_for_tests(
+        &self,
+        ident: &ChainIdentifier,
+    ) -> Result<(), Error> {
+        self.set_chain_identifier(ident).await
+    }
+
     /// Store the given chain as the blocks for the `network` set the
     /// network's genesis block to `genesis_hash`, and head block to
     /// `null`
@@ -1634,15 +2545,27 @@ impl ChainStore {
         genesis_hash: &str,
         chain: Vec<Arc<dyn Block>>,
     ) -> Vec<(BlockPtr, BlockHash)> {
-        let conn = self.pool.get().expect("can get a database connection");
+        let mut conn = self
+            .pool
+            .get()
+            .await
+            .expect("can get a database connection");
 
-        self.storage.remove_chain(&conn, &self.chain);
+        self.storage.remove_chain(&mut conn, &self.chain).await;
         self.recent_blocks_cache.clear();
+        self.chain_head_ptr_cache.clear();
 
         for block in chain {
             self.upsert_block(block).await.expect("can upsert block");
         }
 
+        self.set_chain_identifier(&ChainIdentifier {
+            net_version: "0".to_string(),
+            genesis_block_hash: BlockHash::try_from(genesis_hash).expect("valid block hash"),
+        })
+        .await
+        .expect("unable to set chain identifier");
+
         use public::ethereum_networks as n;
         diesel::update(n::table.filter(n::name.eq(&self.chain)))
             .set((
@@ -1650,32 +2573,36 @@ impl ChainStore {
                 n::head_block_hash.eq::<Option<&str>>(None),
                 n::head_block_number.eq::<Option<i64>>(None),
             ))
-            .execute(&conn)
+            .execute(&mut conn)
+            .await
             .unwrap();
         self.recent_blocks_cache.blocks()
     }
 
-    pub fn delete_blocks(&self, block_hashes: &[&H256]) -> Result<usize, Error> {
-        let conn = self.get_conn()?;
+    pub async fn delete_blocks(&self, block_hashes: &[&B256]) -> Result<usize, Error> {
+        let mut conn = self.pool.get_permitted().await?;
         self.storage
-            .delete_blocks_by_hash(&conn, &self.chain, block_hashes)
+            .delete_blocks_by_hash(&mut conn, &self.chain, block_hashes)
+            .await
     }
 
-    pub fn cleanup_shallow_blocks(&self, lowest_block: i32) -> Result<(), StoreError> {
-        let conn = self.get_conn()?;
-        self.storage.cleanup_shallow_blocks(&conn, lowest_block)?;
+    pub async fn cleanup_shallow_blocks(&self, lowest_block: i32) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        self.storage
+            .cleanup_shallow_blocks(&mut conn, lowest_block)
+            .await?;
         Ok(())
     }
 
     // remove_cursor delete the chain_store cursor and return true if it was present
-    pub fn remove_cursor(&self, chain: &str) -> Result<Option<BlockNumber>, StoreError> {
-        let conn = self.get_conn()?;
-        self.storage.remove_cursor(&conn, chain)
+    pub async fn remove_cursor(&self, chain: &str) -> Result<Option<BlockNumber>, StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        self.storage.remove_cursor(&mut conn, chain).await
     }
 
-    pub fn truncate_block_cache(&self) -> Result<(), StoreError> {
-        let conn = self.get_conn()?;
-        self.storage.truncate_block_cache(&conn)?;
+    pub async fn truncate_block_cache(&self) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        self.storage.truncate_block_cache(&mut conn).await?;
         Ok(())
     }
 
@@ -1683,160 +2610,186 @@ impl ChainStore {
         self: &Arc<Self>,
         hashes: Vec<BlockHash>,
     ) -> Result<Vec<JsonBlock>, StoreError> {
-        let store = self.cheap_clone();
-        let pool = self.pool.clone();
-        let values = pool
-            .with_conn(move |conn, _| {
-                store
-                    .storage
-                    .blocks(&conn, &store.chain, &hashes)
-                    .map_err(CancelableError::from)
-            })
-            .await?;
-        Ok(values)
-    }
-}
-
-#[async_trait]
-impl ChainStoreTrait for ChainStore {
-    fn genesis_block_ptr(&self) -> Result<BlockPtr, Error> {
-        Ok(self.genesis_block_ptr.clone())
+        let cutoff = self.cache_cutoff().await;
+        let mut conn = self.pool.get_permitted().await?;
+        let values = self.storage.blocks(&mut conn, &self.chain, &hashes).await?;
+        Ok(values
+            .into_iter()
+            .filter(|b| b.ptr.block_number() >= cutoff)
+            .collect())
     }
 
-    async fn upsert_block(&self, block: Arc<dyn Block>) -> Result<(), Error> {
-        // We should always have the parent block available to us at this point.
-        if let Some(parent_hash) = block.parent_hash() {
-            let block = JsonBlock::new(block.ptr(), parent_hash, block.data().ok());
-            self.recent_blocks_cache.insert_block(block);
-        }
+    async fn blocks_from_store_by_numbers(
+        self: &Arc<Self>,
+        numbers: Vec<BlockNumber>,
+    ) -> Result<BTreeMap<BlockNumber, Vec<JsonBlock>>, StoreError> {
+        let cutoff = self.cache_cutoff().await;
+        let mut conn = self.pool.get_permitted().await?;
+        let values = self
+            .storage
+            .block_ptrs_by_numbers(&mut conn, &self.chain, &numbers)
+            .await?;
 
-        let pool = self.pool.clone();
-        let network = self.chain.clone();
-        let storage = self.storage.clone();
-        pool.with_conn(move |conn, _| {
-            conn.transaction(|| {
-                storage
-                    .upsert_block(conn, &network, block.as_ref(), true)
-                    .map_err(CancelableError::from)
-            })
-        })
-        .await
-        .map_err(Error::from)
-    }
+        let mut block_map = BTreeMap::new();
 
-    fn upsert_light_blocks(&self, blocks: &[&dyn Block]) -> Result<(), Error> {
-        let conn = self.pool.get()?;
-        for block in blocks {
-            self.storage
-                .upsert_block(&conn, &self.chain, *block, false)?;
+        for block in values
+            .into_iter()
+            .filter(|b| b.ptr.block_number() >= cutoff)
+        {
+            let block_number = block.ptr.block_number();
+            block_map
+                .entry(block_number)
+                .or_insert_with(Vec::new)
+                .push(block);
         }
-        Ok(())
+
+        Ok(block_map)
     }
 
-    async fn attempt_chain_head_update(
-        self: Arc<Self>,
+    async fn attempt_chain_head_update_inner(
+        &self,
         ancestor_count: BlockNumber,
-    ) -> Result<Option<H256>, Error> {
+    ) -> Result<(Option<B256>, Option<(String, i64)>), StoreError> {
         use public::ethereum_networks as n;
 
-        let (missing, ptr) = {
-            let chain_store = self.clone();
-            self.pool
-                .with_conn(move |conn, _| {
-                    let candidate = chain_store
-                        .storage
-                        .chain_head_candidate(conn, &chain_store.chain)
-                        .map_err(CancelableError::from)?;
-                    let (ptr, first_block) = match &candidate {
-                        None => return Ok((None, None)),
-                        Some(ptr) => (ptr, 0.max(ptr.number.saturating_sub(ancestor_count))),
-                    };
-
-                    match chain_store
-                        .storage
-                        .missing_parent(
-                            conn,
-                            &chain_store.chain,
-                            first_block as i64,
-                            ptr.hash_as_h256(),
-                            chain_store.genesis_block_ptr.hash_as_h256(),
-                        )
-                        .map_err(CancelableError::from)?
-                    {
-                        Some(missing) => {
-                            return Ok((Some(missing), None));
-                        }
-                        None => { /* we have a complete chain, no missing parents */ }
-                    }
+        let genesis_block_ptr = self.genesis_block_ptr().await?.hash.as_b256();
 
-                    let hash = ptr.hash_hex();
-                    let number = ptr.number as i64;
-
-                    conn.transaction(
-                        || -> Result<(Option<H256>, Option<(String, i64)>), StoreError> {
-                            update(n::table.filter(n::name.eq(&chain_store.chain)))
-                                .set((
-                                    n::head_block_hash.eq(&hash),
-                                    n::head_block_number.eq(number),
-                                ))
-                                .execute(conn)?;
-                            Ok((None, Some((hash, number))))
-                        },
-                    )
-                    .map_err(CancelableError::from)
-                })
-                .await?
+        let mut conn = self.pool.get_permitted().await?;
+        let candidate = self
+            .storage
+            .chain_head_candidate(&mut conn, &self.chain)
+            .await?;
+        let (ptr, first_block) = match &candidate {
+            None => return Ok((None, None)),
+            Some(ptr) => (ptr, 0.max(ptr.number.saturating_sub(ancestor_count))),
         };
-        if let Some((hash, number)) = ptr {
-            self.chain_head_update_sender.send(&hash, number)?;
+
+        match self
+            .storage
+            .missing_parent(
+                &mut conn,
+                &self.chain,
+                first_block as i64,
+                ptr.hash.as_b256(),
+                genesis_block_ptr,
+            )
+            .await?
+        {
+            Some(missing) => {
+                return Ok((Some(missing), None));
+            }
+            None => { /* we have a complete chain, no missing parents */ }
         }
 
-        Ok(missing)
+        let hash = ptr.hash_hex();
+        let number = ptr.number as i64;
+        conn.transaction::<(Option<B256>, Option<(String, i64)>), StoreError, _>(
+            async move |conn| {
+                update(n::table.filter(n::name.eq(&self.chain)))
+                    .set((
+                        n::head_block_hash.eq(&hash),
+                        n::head_block_number.eq(number),
+                    ))
+                    .execute(conn)
+                    .await?;
+                Ok((None, Some((hash, number))))
+            },
+        )
+        .await
     }
 
+    /// Helper for tests that need to directly modify the tables for the
+    /// chain store
+    #[cfg(debug_assertions)]
+    pub async fn get_conn_for_test(&self) -> Result<crate::pool::PermittedConnection, Error> {
+        let conn = self.pool.get_permitted().await?;
+        Ok(conn)
+    }
+}
+
+fn json_block_to_block_ptr_ext(json_block: &JsonBlock) -> Result<ExtendedBlockPtr, Error> {
+    let hash = json_block.ptr.hash.clone();
+    let number = json_block.ptr.number;
+    let parent_hash = json_block.parent_hash.clone();
+
+    let timestamp = json_block
+        .timestamp()
+        .ok_or_else(|| anyhow!("Timestamp is missing"))?;
+
+    let ptr =
+        ExtendedBlockPtr::try_from((hash.as_b256(), number, parent_hash.as_b256(), timestamp))
+            .map_err(|e| anyhow!("Failed to convert to ExtendedBlockPtr: {}", e))?;
+
+    Ok(ptr)
+}
+
+#[async_trait]
+impl ChainHeadStore for ChainStore {
     async fn chain_head_ptr(self: Arc<Self>) -> Result<Option<BlockPtr>, Error> {
         use public::ethereum_networks::dsl::*;
 
-        Ok(self
-            .cheap_clone()
-            .pool
-            .with_conn(move |conn, _| {
-                ethereum_networks
-                    .select((head_block_hash, head_block_number))
-                    .filter(name.eq(&self.chain))
-                    .load::<(Option<String>, Option<i64>)>(conn)
-                    .map(|rows| {
-                        rows.first()
-                            .map(|(hash_opt, number_opt)| match (hash_opt, number_opt) {
-                                (Some(hash), Some(number)) => Some(
-                                    (
-                                        // FIXME:
-                                        //
-                                        // workaround for arweave
-                                        H256::from_slice(&hex::decode(hash).unwrap()[..32]),
-                                        *number,
-                                    )
-                                        .into(),
-                                ),
-                                (None, None) => None,
-                                _ => unreachable!(),
-                            })
-                            .and_then(|opt: Option<BlockPtr>| opt)
-                    })
-                    .map_err(|e| CancelableError::from(StoreError::from(e)))
-            })
-            .await?)
+        // Check TTL cache first (handles disabled check and metrics internally)
+        if let Some(cached) = self.chain_head_ptr_cache.get() {
+            return Ok(Some(cached));
+        }
+
+        // Use HerdCache to ensure only one caller does the DB lookup
+        // when cache is expired. Other callers await the in-flight query.
+        let pool = self.pool.clone();
+        let chain = self.chain.clone();
+        let lookup = async move {
+            let mut conn = pool.get_permitted().await?;
+            ethereum_networks
+                .select((head_block_hash, head_block_number))
+                .filter(name.eq(&chain))
+                .load::<(Option<String>, Option<i64>)>(&mut conn)
+                .await
+                .map(|rows| {
+                    rows.as_slice()
+                        .first()
+                        .map(|(hash_opt, number_opt)| match (hash_opt, number_opt) {
+                            (Some(hash), Some(number)) => Some(
+                                (
+                                    // FIXME:
+                                    //
+                                    // workaround for arweave
+                                    B256::from_slice(&hex::decode(hash).unwrap()[..32]),
+                                    *number,
+                                )
+                                    .into(),
+                            ),
+                            (None, None) => None,
+                            _ => unreachable!(),
+                        })
+                        .and_then(|opt: Option<BlockPtr>| opt)
+                })
+                .map_err(StoreError::from)
+        };
+
+        let (result, _cached) = self
+            .cached_lookup(&self.chain_head_ptr_herd, &self.chain, lookup)
+            .await;
+
+        // Update TTL cache with the result
+        // (set() handles disabled check internally)
+        if let Ok(Some(ref ptr)) = result {
+            self.chain_head_ptr_cache.set(ptr.clone());
+        }
+
+        result.map_err(Error::from)
     }
 
-    fn chain_head_cursor(&self) -> Result<Option<String>, Error> {
+    async fn chain_head_cursor(&self) -> Result<Option<String>, Error> {
         use public::ethereum_networks::dsl::*;
 
         ethereum_networks
             .select(head_block_cursor)
             .filter(name.eq(&self.chain))
-            .load::<Option<String>>(&*self.get_conn()?)
+            .load::<Option<String>>(&mut self.pool.get_permitted().await?)
+            .await
             .map(|rows| {
-                rows.first()
+                rows.as_slice()
+                    .first()
                     .map(|cursor_opt| cursor_opt.as_ref().cloned())
                     .and_then(|opt| opt)
             })
@@ -1850,108 +2803,222 @@ impl ChainStoreTrait for ChainStore {
     ) -> Result<(), Error> {
         use public::ethereum_networks as n;
 
-        let pool = self.pool.clone();
-        let network = self.chain.clone();
-        let storage = self.storage.clone();
-
         let ptr = block.ptr();
         let hash = ptr.hash_hex();
         let number = ptr.number as i64; //block height
 
         //this will send an update via postgres, channel: chain_head_updates
-        self.chain_head_update_sender.send(&hash, number)?;
-
-        pool.with_conn(move |conn, _| {
-            conn.transaction(|| -> Result<(), StoreError> {
-                storage
-                    .upsert_block(conn, &network, block.as_ref(), true)
-                    .map_err(CancelableError::from)?;
+        self.chain_head_update_sender.send(&hash, number).await?;
 
-                update(n::table.filter(n::name.eq(&self.chain)))
-                    .set((
-                        n::head_block_hash.eq(&hash),
-                        n::head_block_number.eq(number),
-                        n::head_block_cursor.eq(cursor),
-                    ))
-                    .execute(conn)?;
+        let mut conn = self.pool.get_permitted().await?;
+        conn.transaction(async |conn| {
+            self.storage
+                .upsert_block(conn, &self.chain, block.as_ref(), true)
+                .await?;
+
+            update(n::table.filter(n::name.eq(&self.chain)))
+                .set((
+                    n::head_block_hash.eq(&hash),
+                    n::head_block_number.eq(number),
+                    n::head_block_cursor.eq(cursor),
+                ))
+                .execute(conn)
+                .await?;
 
-                Ok(())
-            })
-            .map_err(CancelableError::from)
+            Ok::<(), StoreError>(())
         })
         .await?;
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl ChainStoreTrait for ChainStore {
+    async fn genesis_block_ptr(&self) -> Result<BlockPtr, Error> {
+        let ident = self.chain_identifier().await?;
+
+        Ok(BlockPtr {
+            hash: ident.genesis_block_hash,
+            number: 0,
+        })
+    }
+
+    async fn upsert_block(&self, block: Arc<dyn Block>) -> Result<(), Error> {
+        // We should always have the parent block available to us at this point.
+        if let Some(parent_hash) = block.parent_hash() {
+            let json_block = JsonBlock::new(block.ptr(), parent_hash, block.data().ok());
+            self.recent_blocks_cache.insert_json_block(json_block);
+        }
 
+        let mut conn = self.pool.get_permitted().await?;
+        conn.transaction(async |conn| {
+            self.storage
+                .upsert_block(conn, &self.chain, block.as_ref(), true)
+                .await
+        })
+        .await
+        .map_err(Error::from)
+    }
+
+    async fn upsert_light_blocks(&self, blocks: &[&dyn Block]) -> Result<(), Error> {
+        let mut conn = self.pool.get_permitted().await?;
+        for block in blocks {
+            self.storage
+                .upsert_block(&mut conn, &self.chain, *block, false)
+                .await?;
+        }
         Ok(())
     }
 
-    async fn blocks(self: Arc<Self>, hashes: Vec<BlockHash>) -> Result<Vec<json::Value>, Error> {
+    async fn attempt_chain_head_update(
+        self: Arc<Self>,
+        ancestor_count: BlockNumber,
+    ) -> Result<Option<B256>, Error> {
+        let (missing, ptr) = self.attempt_chain_head_update_inner(ancestor_count).await?;
+
+        if let Some((hash, number)) = ptr {
+            self.chain_head_update_sender.send(&hash, number).await?;
+        }
+
+        Ok(missing)
+    }
+
+    async fn block_ptrs_by_numbers(
+        self: Arc<Self>,
+        numbers: Vec<BlockNumber>,
+    ) -> Result<BTreeMap<BlockNumber, Vec<ExtendedBlockPtr>>, Error> {
+        if ENV_VARS.store.disable_block_cache_for_lookup {
+            let values = self.blocks_from_store_by_numbers(numbers).await?;
+
+            let ptrs = values
+                .into_iter()
+                .map(|(num, blocks)| {
+                    let ptrs = blocks
+                        .into_iter()
+                        .filter_map(|block| json_block_to_block_ptr_ext(&block).ok())
+                        .collect();
+                    (num, ptrs)
+                })
+                .collect();
+
+            return Ok(ptrs);
+        }
+
+        let cached = self.recent_blocks_cache.get_block_ptrs_by_numbers(&numbers);
+
+        let stored = if cached.len() < numbers.len() {
+            let missing_numbers = numbers
+                .iter()
+                .filter(|num| !cached.iter().any(|(ptr, _)| ptr.block_number() == **num))
+                .cloned()
+                .collect::<Vec<_>>();
+
+            let this = self.clone();
+            let missing_clone = missing_numbers.clone();
+            let (res, _) = self
+                .cached_lookup(&self.blocks_by_number_cache, &missing_numbers, async move {
+                    this.blocks_from_store_by_numbers(missing_clone).await
+                })
+                .await;
+
+            match res {
+                Ok(blocks) => {
+                    for blocks_for_num in blocks.values() {
+                        if blocks_for_num.len() == 1 {
+                            self.recent_blocks_cache
+                                .insert_json_block(blocks_for_num[0].clone());
+                        }
+                    }
+                    blocks
+                }
+                Err(e) => {
+                    return Err(e.into());
+                }
+            }
+        } else {
+            BTreeMap::new()
+        };
+
+        let cached_map: BTreeMap<BlockNumber, Vec<ExtendedBlockPtr>> = cached
+            .into_iter()
+            .filter_map(|(_, block)| {
+                block
+                    .to_extended_block_ptr()
+                    .ok()
+                    .map(|ptr| (block.ptr.number, vec![ptr]))
+            })
+            .collect();
+
+        let mut result = cached_map;
+        for (num, json_blocks) in stored {
+            let ptrs: Vec<_> = json_blocks
+                .into_iter()
+                .filter_map(|block| json_block_to_block_ptr_ext(&block).ok())
+                .collect();
+            result.entry(num).or_insert(ptrs);
+        }
+
+        Ok(result)
+    }
+
+    async fn blocks(self: Arc<Self>, hashes: Vec<BlockHash>) -> Result<Vec<CachedBlock>, Error> {
         if ENV_VARS.store.disable_block_cache_for_lookup {
             let values = self
                 .blocks_from_store(hashes)
                 .await?
                 .into_iter()
-                .filter_map(|block| block.data)
+                .filter_map(|block| block.data.and_then(CachedBlock::from_json))
                 .collect();
-            Ok(values)
+            return Ok(values);
+        }
+
+        let cached = self.recent_blocks_cache.get_blocks_by_hash(&hashes);
+        let stored = if cached.len() < hashes.len() {
+            let hashes = hashes
+                .iter()
+                .filter(|hash| !cached.iter().any(|(ptr, _)| &ptr.hash == *hash))
+                .cloned()
+                .collect::<Vec<_>>();
+            // We key this off the entire list of hashes, which means
+            // that concurrent attempts that look up `[h1, h2]` and
+            // `[h1, h3]` will still run two queries and duplicate the
+            // lookup of `h1`. Noticing that the two requests should be
+            // serialized would require a lot more work, and going to
+            // the database for one block hash, `h3`, is not much faster
+            // than looking up `[h1, h3]` though it would require less
+            // IO bandwidth
+            let this = self.clone();
+            let hashes_clone = hashes.clone();
+            let (res, _) = self
+                .cached_lookup(&self.blocks_by_hash_cache, &hashes, async move {
+                    this.blocks_from_store(hashes_clone).await
+                })
+                .await;
+
+            match res {
+                Ok(blocks) => blocks
+                    .into_iter()
+                    .filter_map(|block| self.recent_blocks_cache.insert_json_block(block))
+                    .collect(),
+                Err(e) => {
+                    return Err(e.into());
+                }
+            }
         } else {
-            let cached = self.recent_blocks_cache.get_blocks_by_hash(&hashes);
-            let stored = if cached.len() < hashes.len() {
-                let hashes = hashes
-                    .iter()
-                    .filter(|hash| cached.iter().find(|(ptr, _)| &ptr.hash == *hash).is_none())
-                    .cloned()
-                    .collect::<Vec<_>>();
-                // We key this off the entire list of hashes, which means
-                // that concurrent attempts that look up `[h1, h2]` and
-                // `[h1, h3]` will still run two queries and duplicate the
-                // lookup of `h1`. Noticing that the two requests should be
-                // serialized would require a lot more work, and going to
-                // the database for one block hash, `h3`, is not much faster
-                // than looking up `[h1, h3]` though it would require less
-                // IO bandwidth
-                let hash = crypto_stable_hash(&hashes);
-                let this = self.clone();
-                let lookup_fut = async move {
-                    let res = this.blocks_from_store(hashes).await;
-                    BlocksLookupResult(Arc::new(res))
-                };
-                let lookup_herd = self.lookup_herd.cheap_clone();
-                let logger = self.logger.cheap_clone();
-                let (BlocksLookupResult(res), _) =
-                    lookup_herd.cached_query(hash, lookup_fut, &logger).await;
-                // Try to avoid cloning a non-concurrent lookup; it's not
-                // entirely clear whether that will actually avoid a clone
-                // since it depends on a lot of the details of how the
-                // `HerdCache` is implemented
-                let res = Arc::try_unwrap(res).unwrap_or_else(|arc| (*arc).clone());
-                let stored = match res {
-                    Ok(blocks) => {
-                        for block in &blocks {
-                            self.recent_blocks_cache.insert_block(block.clone());
-                        }
-                        blocks
-                    }
-                    Err(e) => {
-                        return Err(e.into());
-                    }
-                };
-                stored
-            } else {
-                Vec::new()
-            };
+            Vec::new()
+        };
 
-            let mut result = cached.into_iter().map(|(_, data)| data).collect::<Vec<_>>();
-            let stored = stored.into_iter().filter_map(|block| block.data);
-            result.extend(stored);
-            Ok(result)
-        }
+        let mut result: Vec<CachedBlock> = cached.into_iter().map(|(_, data)| data).collect();
+        result.extend(stored);
+        Ok(result)
     }
 
     async fn ancestor_block(
         self: Arc<Self>,
         block_ptr: BlockPtr,
         offset: BlockNumber,
-    ) -> Result<Option<json::Value>, Error> {
+        root: Option<BlockHash>,
+    ) -> Result<Option<(CachedBlock, BlockPtr)>, Error> {
         ensure!(
             block_ptr.number >= offset,
             "block offset {} for block `{}` points to before genesis block",
@@ -1959,27 +3026,114 @@ impl ChainStoreTrait for ChainStore {
             block_ptr.hash_hex()
         );
 
-        // Check the local cache first.
-        if let Some(data) = self.recent_blocks_cache.get_ancestor(&block_ptr, offset) {
-            return Ok(data.1);
+        let target_number = block_ptr.block_number() - offset;
+        let cutoff = self.cache_cutoff().await;
+        if target_number < cutoff {
+            return Ok(None);
         }
 
+        // Use herd cache to avoid thundering herd when multiple callers
+        // request the same ancestor block simultaneously. The cache check
+        // is inside the future so that only one caller checks and populates
+        // the cache.
+        let key = (&block_ptr, offset, &root);
+        let this = self.cheap_clone();
         let block_ptr_clone = block_ptr.clone();
-        let chain_store = self.cheap_clone();
-        Ok(self
-            .pool
-            .with_conn(move |conn, _| {
-                chain_store
+        let root_clone = root.clone();
+        let (res, cached) = self
+            .cached_lookup(&self.ancestor_cache, &key, async move {
+                // Check the local cache first.
+                let block_cache = this
+                    .recent_blocks_cache
+                    .get_ancestor(&block_ptr_clone, offset)
+                    .and_then(|x| Some(x.0).zip(x.1));
+                if let Some((ptr, data)) = block_cache {
+                    return Ok(Some((data, ptr)));
+                }
+
+                // Cache miss, query the database
+                let mut conn = this.pool.get_permitted().await?;
+                let json_result = this
                     .storage
-                    .ancestor_block(conn, block_ptr_clone, offset)
-                    .map_err(StoreError::from)
-                    .map_err(CancelableError::from)
+                    .ancestor_block(&mut conn, block_ptr_clone, offset, root_clone)
+                    .await
+                    .map_err(StoreError::from)?;
+
+                // Insert into cache and reuse the typed block
+                match json_result {
+                    Some((data, ptr)) => {
+                        let cached = if let Some(parent_hash) = data
+                            .get("block")
+                            .unwrap_or(&data)
+                            .get("parentHash")
+                            .and_then(|h| h.as_str())
+                            .and_then(|h| h.parse().ok())
+                        {
+                            let json_block = JsonBlock::new(ptr.clone(), parent_hash, Some(data));
+                            this.recent_blocks_cache.insert_json_block(json_block)
+                        } else {
+                            CachedBlock::from_json(data)
+                        };
+                        Ok(cached.map(|c| (c, ptr)))
+                    }
+                    None => Ok(None),
+                }
             })
-            .await?
-            .map(|b| b.0))
+            .await;
+        let result = res?;
+
+        if cached {
+            // If we had a hit in the herd cache, we never ran the future
+            // that we pass to cached_lookup but we want to pretend that we
+            // actually looked the value up from the recent blocks cache
+            self.recent_blocks_cache.register_hit();
+        }
+
+        Ok(result)
+    }
+
+    async fn ancestor_block_ptr(
+        self: Arc<Self>,
+        block_ptr: BlockPtr,
+        offset: BlockNumber,
+        root: Option<BlockHash>,
+    ) -> Result<Option<BlockPtr>, Error> {
+        ensure!(
+            block_ptr.number >= offset,
+            "block offset {} for block `{}` points to before genesis block",
+            offset,
+            block_ptr.hash_hex()
+        );
+
+        // Check the in-memory cache first.
+        if let Some((ptr, _)) = self.recent_blocks_cache.get_ancestor(&block_ptr, offset) {
+            return Ok(Some(ptr));
+        }
+
+        // Cache miss, query the database (CTE only, no data fetch).
+        let mut conn = self.pool.get_permitted().await?;
+        self.storage
+            .ancestor_block_ptr(&mut conn, block_ptr, offset, root)
+            .await
     }
 
-    fn cleanup_cached_blocks(
+    async fn block_parent_ptr(
+        self: Arc<Self>,
+        hash: &BlockHash,
+    ) -> Result<Option<BlockPtr>, Error> {
+        // Check the in-memory cache first.
+        if let Some(parent_ptr) = self.recent_blocks_cache.get_parent_ptr_by_hash(hash) {
+            return Ok(Some(parent_ptr));
+        }
+
+        // Cache miss, query the database.
+        let mut conn = self.pool.get_permitted().await?;
+        self.storage
+            .block_parent_ptr(&mut conn, &self.chain, hash)
+            .await
+    }
+
+    async fn cleanup_cached_blocks(
         &self,
         ancestor_count: BlockNumber,
     ) -> Result<Option<(BlockNumber, usize)>, Error> {
@@ -1987,7 +3141,7 @@ impl ChainStoreTrait for ChainStore {
 
         #[derive(QueryableByName)]
         struct MinBlock {
-            #[sql_type = "Integer"]
+            #[diesel(sql_type = Integer)]
             block: i32,
         }
 
@@ -2010,7 +3164,7 @@ impl ChainStoreTrait for ChainStore {
         //
         // See 8b6ad0c64e244023ac20ced7897fe666
 
-        let conn = self.get_conn()?;
+        let mut conn = self.pool.get_permitted().await?;
         let query = "
             select coalesce(
                    least(a.block,
@@ -2018,85 +3172,212 @@ impl ChainStoreTrait for ChainStore {
                            from ethereum_networks
                           where name = $2)), -1)::int as block
               from (
-                select min(d.latest_ethereum_block_number) as block
-                  from subgraphs.subgraph_deployment d,
+                select min(h.block_number) as block
+                  from subgraphs.deployment d,
+                       subgraphs.head h,
                        subgraphs.subgraph_deployment_assignment a,
                        deployment_schemas ds
-                 where ds.subgraph = d.deployment
+                 where ds.id = d.id
+                   and h.id = d.id
                    and a.id = d.id
                    and not d.failed
                    and ds.network = $2) a;";
-        diesel::sql_query(query)
+        let Some(block) = diesel::sql_query(query)
             .bind::<Integer, _>(ancestor_count)
             .bind::<Text, _>(&self.chain)
-            .load::<MinBlock>(&conn)?
+            .load::<MinBlock>(&mut conn)
+            .await?
+            .as_slice()
             .first()
-            .map(|MinBlock { block }| {
-                // If we could not determine a minimum block, the query
-                // returns -1, and we should not do anything. We also guard
-                // against removing the genesis block
-                if *block > 0 {
-                    self.storage
-                        .delete_blocks_before(&conn, &self.chain, *block as i64)
-                        .map(|rows| Some((*block, rows)))
-                } else {
-                    Ok(None)
-                }
-            })
-            .unwrap_or(Ok(None))
-            .map_err(Into::into)
+            .map(|MinBlock { block }| *block)
+        else {
+            return Ok(None);
+        };
+        // If we could not determine a minimum block, the query
+        // returns -1, and we should not do anything. We also guard
+        // against removing the genesis block
+        if block > 0 {
+            self.storage
+                .delete_blocks_before(&mut conn, &self.chain, block as i64)
+                .await
+                .map(|rows| Some((block, rows)))
+        } else {
+            Ok(None)
+        }
     }
 
-    fn block_hashes_by_block_number(&self, number: BlockNumber) -> Result<Vec<BlockHash>, Error> {
-        let conn = self.get_conn()?;
+    async fn block_hashes_by_block_number(
+        &self,
+        number: BlockNumber,
+    ) -> Result<Vec<BlockHash>, Error> {
+        let mut conn = self.pool.get_permitted().await?;
         self.storage
-            .block_hashes_by_block_number(&conn, &self.chain, number)
+            .block_hashes_by_block_number(&mut conn, &self.chain, number)
+            .await
     }
 
-    fn confirm_block_hash(&self, number: BlockNumber, hash: &BlockHash) -> Result<usize, Error> {
-        let conn = self.get_conn()?;
+    async fn confirm_block_hash(
+        &self,
+        number: BlockNumber,
+        hash: &BlockHash,
+    ) -> Result<usize, Error> {
+        let mut conn = self.pool.get_permitted().await?;
         self.storage
-            .confirm_block_hash(&conn, &self.chain, number, hash)
+            .confirm_block_hash(&mut conn, &self.chain, number, hash)
+            .await
     }
 
     async fn block_number(
         &self,
         hash: &BlockHash,
-    ) -> Result<Option<(String, BlockNumber, Option<u64>)>, StoreError> {
-        let hash = hash.clone();
-        let storage = self.storage.clone();
-        let chain = self.chain.clone();
-        self.pool
-            .with_conn(move |conn, _| {
-                storage
-                    .block_number(conn, &hash)
-                    .map(|opt| opt.map(|(number, timestamp)| (chain.clone(), number, timestamp)))
-                    .map_err(|e| e.into())
+    ) -> Result<Option<(String, BlockNumber, Option<u64>, Option<BlockHash>)>, StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        self.storage.block_number(&mut conn, hash).await.map(|opt| {
+            opt.map(|(number, timestamp, parent_hash)| {
+                (self.chain.clone(), number, timestamp, parent_hash)
             })
+        })
+    }
+
+    async fn block_numbers(
+        &self,
+        hashes: Vec<BlockHash>,
+    ) -> Result<HashMap<BlockHash, BlockNumber>, StoreError> {
+        if hashes.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        let mut conn = self.pool.get_permitted().await?;
+        self.storage
+            .block_numbers(&mut conn, hashes.as_slice())
             .await
     }
 
     async fn clear_call_cache(&self, from: BlockNumber, to: BlockNumber) -> Result<(), Error> {
-        let conn = self.get_conn()?;
-        if let Some(head) = self.chain_head_block(&self.chain)? {
-            self.storage.clear_call_cache(&conn, head, from, to)?;
+        let mut conn = self.pool.get_permitted().await?;
+        if let Some(head) = self.chain_head_block(&self.chain).await? {
+            self.storage
+                .clear_call_cache(&mut conn, head, from, to)
+                .await?;
         }
         Ok(())
     }
 
+    async fn clear_stale_call_cache(
+        &self,
+        ttl_days: usize,
+        max_contracts: Option<usize>,
+    ) -> Result<StaleCallCacheResult, Error> {
+        const LOG_INTERVAL: Duration = Duration::from_mins(5);
+
+        let conn = &mut self.pool.get_permitted().await?;
+
+        let logger = self.logger.new(o!("component" => "CallCacheCleanup"));
+
+        self.storage
+            .ensure_contract_address_index(conn, &self.logger)
+            .await?;
+
+        let ttl_days = ttl_days as i64;
+        let effective_ttl = match max_contracts {
+            Some(max) => {
+                self.storage
+                    .effective_ttl(conn, ttl_days, max as i64)
+                    .await?
+            }
+            None => ttl_days,
+        };
+
+        if effective_ttl != ttl_days {
+            info!(
+                logger,
+                "adjusted ttl from {} to {} days to stay within {} contracts",
+                ttl_days,
+                effective_ttl,
+                max_contracts.unwrap()
+            );
+        }
+
+        let mut total_deleted: usize = 0;
+        let mut batch_count: usize = 0;
+        let mut batch_size = AdaptiveBatchSize::with_size(100);
+        let mut last_log = Instant::now();
+
+        loop {
+            let current_size = batch_size.size;
+            let start = Instant::now();
+            let deleted = self
+                .storage
+                .delete_stale_calls_batch(conn, effective_ttl, current_size)
+                .await?;
+
+            batch_size.adapt(start.elapsed());
+            total_deleted += deleted;
+            batch_count += 1;
+
+            if last_log.elapsed() >= LOG_INTERVAL {
+                info!(
+                    logger,
+                    "deleted {} entries in this batch \
+                     ({} total in {} batches, batch_size now {})",
+                    deleted,
+                    total_deleted,
+                    batch_count,
+                    batch_size.size
+                );
+                last_log = Instant::now();
+            }
+
+            if (deleted as i64) < current_size {
+                break;
+            }
+        }
+
+        let contracts_deleted = self.storage.delete_stale_meta(conn, effective_ttl).await?;
+
+        info!(
+            logger,
+            "deleted {} cache entries and {} contract entries in {} batches",
+            total_deleted,
+            contracts_deleted,
+            batch_count
+        );
+
+        Ok(StaleCallCacheResult {
+            effective_ttl_days: effective_ttl as usize,
+            cache_entries_deleted: total_deleted,
+            contracts_deleted,
+        })
+    }
+
     async fn transaction_receipts_in_block(
         &self,
-        block_hash: &H256,
+        block_hash: &B256,
     ) -> Result<Vec<LightTransactionReceipt>, StoreError> {
-        let pool = self.pool.clone();
-        let storage = self.storage.clone();
-        let block_hash = *block_hash;
-        pool.with_conn(move |conn, _| {
-            storage
-                .find_transaction_receipts_in_block(conn, block_hash)
-                .map_err(|e| StoreError::from(e).into())
+        let mut conn = self.pool.get_permitted().await?;
+        self.storage
+            .find_transaction_receipts_in_block(&mut conn, *block_hash)
+            .await
+            .map_err(StoreError::from)
+    }
+
+    async fn chain_identifier(&self) -> Result<ChainIdentifier, Error> {
+        let mut conn = self.pool.get_permitted().await?;
+        use public::ethereum_networks as n;
+        let (genesis_block_hash, net_version) = n::table
+            .select((n::genesis_block_hash, n::net_version))
+            .filter(n::name.eq(&self.chain))
+            .get_result::<(BlockHash, String)>(&mut conn)
+            .await?;
+
+        Ok(ChainIdentifier {
+            net_version,
+            genesis_block_hash,
         })
-        .await
+    }
+
+    fn as_head_store(self: Arc<Self>) -> Arc<dyn ChainHeadStore> {
+        self.clone()
     }
 }
 
@@ -2111,24 +3392,36 @@ mod recent_blocks_cache {
         // entries. If there are multiple writes for the same block number,
         // the last one wins. Note that because of NEAR, the block numbers
         // might have gaps.
-        blocks: BTreeMap<BlockNumber, JsonBlock>,
+        blocks: BTreeMap<BlockNumber, CacheBlock>,
         // We only store these many blocks.
         capacity: usize,
     }
 
     impl Inner {
-        fn get_block_by_hash(&self, hash: &BlockHash) -> Option<(&BlockPtr, &json::Value)> {
+        fn get_block_by_hash(&self, hash: &BlockHash) -> Option<(&BlockPtr, &CachedBlock)> {
             self.blocks
                 .values()
                 .find(|block| &block.ptr.hash == hash)
                 .and_then(|block| block.data.as_ref().map(|data| (&block.ptr, data)))
         }
 
+        fn get_parent_ptr_by_hash(&self, hash: &BlockHash) -> Option<BlockPtr> {
+            let block = self.blocks.values().find(|b| &b.ptr.hash == hash)?;
+            self.blocks
+                .values()
+                .find(|b| b.ptr.hash == block.parent_hash)
+                .map(|parent| parent.ptr.clone())
+        }
+
+        fn get_block_by_number(&self, number: BlockNumber) -> Option<&CacheBlock> {
+            self.blocks.get(&number)
+        }
+
         fn get_ancestor(
             &self,
             child_ptr: &BlockPtr,
             offset: BlockNumber,
-        ) -> Option<(&BlockPtr, Option<&json::Value>)> {
+        ) -> Option<(&BlockPtr, Option<&CachedBlock>)> {
             let child = self.blocks.get(&child_ptr.number)?;
             if &child.ptr != child_ptr {
                 return None;
@@ -2149,7 +3442,7 @@ mod recent_blocks_cache {
             self.blocks.last_key_value().map(|b| &b.1.ptr)
         }
 
-        fn earliest_block(&self) -> Option<&JsonBlock> {
+        fn earliest_block(&self) -> Option<&CacheBlock> {
             self.blocks.first_key_value().map(|b| b.1)
         }
 
@@ -2179,7 +3472,7 @@ mod recent_blocks_cache {
                 .set(self.chain_head().map(|b| b.number).unwrap_or(0) as f64);
         }
 
-        fn insert_block(&mut self, block: JsonBlock) {
+        fn insert_block(&mut self, block: CacheBlock) {
             self.blocks.insert(block.ptr.number, block);
             self.evict_if_necessary();
         }
@@ -2205,6 +3498,11 @@ mod recent_blocks_cache {
             }
         }
 
+        pub fn register_hit(&self) {
+            let inner = self.inner.read();
+            inner.metrics.record_cache_hit(&inner.network);
+        }
+
         pub fn clear(&self) {
             self.inner.write().blocks.clear();
             self.inner.read().update_write_metrics();
@@ -2214,7 +3512,7 @@ mod recent_blocks_cache {
             &self,
             child: &BlockPtr,
             offset: BlockNumber,
-        ) -> Option<(BlockPtr, Option<json::Value>)> {
+        ) -> Option<(BlockPtr, Option<CachedBlock>)> {
             let block_opt = self
                 .inner
                 .read()
@@ -2231,7 +3529,18 @@ mod recent_blocks_cache {
             block_opt
         }
 
-        pub fn get_blocks_by_hash(&self, hashes: &[BlockHash]) -> Vec<(BlockPtr, json::Value)> {
+        pub fn get_parent_ptr_by_hash(&self, hash: &BlockHash) -> Option<BlockPtr> {
+            let inner = self.inner.read();
+            let result = inner.get_parent_ptr_by_hash(hash);
+            if result.is_some() {
+                inner.metrics.record_cache_hit(&inner.network);
+            } else {
+                inner.metrics.record_cache_miss(&inner.network);
+            }
+            result
+        }
+
+        pub fn get_blocks_by_hash(&self, hashes: &[BlockHash]) -> Vec<(BlockPtr, CachedBlock)> {
             let inner = self.inner.read();
             let blocks: Vec<_> = hashes
                 .iter()
@@ -2246,15 +3555,46 @@ mod recent_blocks_cache {
             blocks
         }
 
+        pub fn get_block_ptrs_by_numbers(
+            &self,
+            numbers: &[BlockNumber],
+        ) -> Vec<(BlockPtr, CacheBlock)> {
+            let inner = self.inner.read();
+            let mut blocks: Vec<(BlockPtr, CacheBlock)> = Vec::new();
+
+            for &number in numbers {
+                if let Some(block) = inner.get_block_by_number(number) {
+                    blocks.push((block.ptr.clone(), block.clone()));
+                }
+            }
+
+            inner.metrics.record_hit_and_miss(
+                &inner.network,
+                blocks.len(),
+                numbers.len() - blocks.len(),
+            );
+
+            blocks
+        }
+
         /// Tentatively caches the `ancestor` of a [`BlockPtr`] (`child`), together with
         /// its associated `data`. Note that for this to work, `child` must be
         /// in the cache already. The first block in the cache should be
         /// inserted via [`RecentBlocksCache::set_chain_head`].
-        pub(super) fn insert_block(&self, block: JsonBlock) {
+        pub(super) fn insert_block(&self, block: CacheBlock) {
             self.inner.write().insert_block(block);
             self.inner.read().update_write_metrics();
         }
 
+        /// Deserialize a JsonBlock into a typed CacheBlock and insert it into the cache.
+        /// Returns the deserialized data so callers can reuse it without re-deserializing.
+        pub(super) fn insert_json_block(&self, block: JsonBlock) -> Option<CachedBlock> {
+            let cache_block = block.into_cache_block();
+            let data = cache_block.data.clone();
+            self.insert_block(cache_block);
+            data
+        }
+
         #[cfg(debug_assertions)]
         pub fn blocks(&self) -> Vec<(BlockPtr, BlockHash)> {
             self.inner
@@ -2289,71 +3629,145 @@ fn try_parse_timestamp(ts: Option<String>) -> Result<Option<u64>, StoreError> {
         .map(Some)
 }
 
+#[async_trait]
 impl EthereumCallCache for ChainStore {
-    fn get_call(
+    async fn get_call(
         &self,
-        contract_address: ethabi::Address,
-        encoded_call: &[u8],
+        req: &call::Request,
         block: BlockPtr,
-    ) -> Result<Option<Vec<u8>>, Error> {
-        let id = contract_call_id(&contract_address, encoded_call, &block);
-        let conn = &*self.get_conn()?;
-        if let Some(call_output) = conn.transaction::<_, Error, _>(|| {
-            if let Some((return_value, update_accessed_at)) =
-                self.storage.get_call_and_access(conn, id.as_ref())?
-            {
-                if update_accessed_at {
-                    self.storage
-                        .update_accessed_at(conn, contract_address.as_ref())?;
+    ) -> Result<Option<call::Response>, Error> {
+        if ENV_VARS.store_call_cache_disabled() {
+            return Ok(None);
+        }
+
+        let id = contract_call_id(req, &block);
+        let conn = &mut self.pool.get_permitted().await?;
+        let return_value = conn
+            .transaction::<_, Error, _>(async |conn| {
+                if let Some((return_value, update_accessed_at)) =
+                    self.storage.get_call_and_access(conn, id.as_ref()).await?
+                {
+                    if update_accessed_at {
+                        self.storage
+                            .update_accessed_at(conn, req.address.as_ref())
+                            .await?;
+                    }
+                    Ok(Some(return_value))
+                } else {
+                    Ok(None)
                 }
-                Ok(Some(return_value))
-            } else {
-                Ok(None)
-            }
-        })? {
-            Ok(Some(call_output))
-        } else {
-            Ok(None)
+            })
+            .await?;
+        Ok(return_value.map(|return_value| {
+            req.cheap_clone()
+                .response(call::Retval::Value(return_value), call::Source::Store)
+        }))
+    }
+
+    async fn get_calls(
+        &self,
+        reqs: &[call::Request],
+        block: BlockPtr,
+    ) -> Result<(Vec<call::Response>, Vec<call::Request>), Error> {
+        if reqs.is_empty() {
+            return Ok((Vec::new(), Vec::new()));
         }
+
+        let ids: Vec<_> = reqs
+            .iter()
+            .map(|req| contract_call_id(req, &block))
+            .collect();
+        let id_refs: Vec<_> = ids.iter().map(|id| id.as_slice()).collect();
+
+        let conn = &mut self.pool.get_permitted().await?;
+        let rows = conn
+            .transaction::<_, Error, _>(async |conn| {
+                self.storage.get_calls_and_access(conn, &id_refs).await
+            })
+            .await?;
+
+        let mut found: Vec<usize> = Vec::new();
+        let mut resps = Vec::new();
+        for (id, retval, _) in rows {
+            let idx = ids.iter().position(|i| i.as_ref() == id).ok_or_else(|| {
+                internal_error!(
+                    "get_calls returned a call id that was not requested: {}",
+                    hex::encode(id)
+                )
+            })?;
+            found.push(idx);
+            let resp = reqs[idx]
+                .cheap_clone()
+                .response(call::Retval::Value(retval), call::Source::Store);
+            resps.push(resp);
+        }
+        let calls = reqs
+            .iter()
+            .enumerate()
+            .filter(|(idx, _)| !found.contains(idx))
+            .map(|(_, call)| call.cheap_clone())
+            .collect();
+        Ok((resps, calls))
     }
 
-    fn get_calls_in_block(&self, block: BlockPtr) -> Result<Vec<CachedEthereumCall>, Error> {
-        let conn = &*self.get_conn()?;
-        conn.transaction::<_, Error, _>(|| self.storage.get_calls_in_block(conn, block))
+    async fn get_calls_in_block(&self, block: BlockPtr) -> Result<Vec<CachedEthereumCall>, Error> {
+        let conn = &mut self.pool.get_permitted().await?;
+        conn.transaction::<_, Error, _>(async |conn| {
+            self.storage.get_calls_in_block(conn, block).await
+        })
+        .await
     }
 
-    fn set_call(
-        &self,
-        contract_address: ethabi::Address,
-        encoded_call: &[u8],
+    async fn set_call(
+        self: Arc<Self>,
+        _: &Logger,
+        call: call::Request,
         block: BlockPtr,
-        return_value: &[u8],
+        return_value: call::Retval,
     ) -> Result<(), Error> {
-        let id = contract_call_id(&contract_address, encoded_call, &block);
-        let conn = &*self.get_conn()?;
-        conn.transaction(|| {
-            self.storage.set_call(
-                conn,
-                id.as_ref(),
-                contract_address.as_ref(),
-                block.number,
-                return_value,
-            )
+        if ENV_VARS.store_call_cache_disabled() {
+            return Ok(());
+        }
+
+        let return_value = match return_value {
+            call::Retval::Value(return_value) if !return_value.is_empty() => return_value,
+            _ => {
+                // We do not want to cache unsuccessful calls as some RPC nodes
+                // have weird behavior near the chain head. The details are lost
+                // to time, but we had issues with some RPC clients in the past
+                // where calls first failed and later succeeded
+                // Also in some cases RPC nodes may return empty ("0x") values
+                // which in the context of graph-node most likely means an issue
+                // with the RPC node rather than a successful call.
+                return Ok(());
+            }
+        };
+
+        let id = contract_call_id(&call, &block);
+        let conn = &mut self.pool.get_permitted().await?;
+        conn.transaction::<_, anyhow::Error, _>(async |conn| {
+            self.storage
+                .set_call(
+                    conn,
+                    id.as_ref(),
+                    call.address.as_ref(),
+                    block.number,
+                    &return_value,
+                )
+                .await
         })
+        .await?;
+        Ok(())
     }
 }
 
 /// The id is the hashed encoded_call + contract_address + block hash to uniquely identify the call.
 /// 256 bits of output, and therefore 128 bits of security against collisions, are needed since this
 /// could be targeted by a birthday attack.
-fn contract_call_id(
-    contract_address: &ethabi::Address,
-    encoded_call: &[u8],
-    block: &BlockPtr,
-) -> [u8; 32] {
+fn contract_call_id(call: &call::Request, block: &BlockPtr) -> [u8; 32] {
     let mut hash = blake3::Hasher::new();
-    hash.update(encoded_call);
-    hash.update(contract_address.as_ref());
+    hash.update(&call.encoded_call);
+    hash.update(call.address.as_ref());
     hash.update(block.hash_slice());
     *hash.finalize().as_bytes()
 }
diff --git a/store/postgres/src/connection_pool.rs b/store/postgres/src/connection_pool.rs
deleted file mode 100644
index 112bb72787f..00000000000
--- a/store/postgres/src/connection_pool.rs
+++ /dev/null
@@ -1,1264 +0,0 @@
-use diesel::r2d2::Builder;
-use diesel::{connection::SimpleConnection, pg::PgConnection};
-use diesel::{
-    r2d2::{self, event as e, ConnectionManager, HandleEvent, Pool, PooledConnection},
-    Connection,
-};
-use diesel::{sql_query, RunQueryDsl};
-
-use graph::cheap_clone::CheapClone;
-use graph::components::store::QueryPermit;
-use graph::constraint_violation;
-use graph::prelude::tokio::time::Instant;
-use graph::prelude::{tokio, MetricsRegistry};
-use graph::slog::warn;
-use graph::util::timed_rw_lock::TimedMutex;
-use graph::{
-    prelude::{
-        anyhow::{self, anyhow, bail},
-        crit, debug, error, info, o,
-        tokio::sync::Semaphore,
-        CancelGuard, CancelHandle, CancelToken as _, CancelableError, Counter, Gauge, Logger,
-        MovingStats, PoolWaitStats, StoreError, ENV_VARS,
-    },
-    util::security::SafeDisplay,
-};
-
-use std::fmt::{self, Write};
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-use std::{collections::HashMap, sync::RwLock};
-
-use postgres::config::{Config, Host};
-
-use crate::primary::{self, NAMESPACE_PUBLIC};
-use crate::{advisory_lock, catalog};
-use crate::{Shard, PRIMARY_SHARD};
-
-pub struct ForeignServer {
-    pub name: String,
-    pub shard: Shard,
-    pub user: String,
-    pub password: String,
-    pub host: String,
-    pub port: u16,
-    pub dbname: String,
-}
-
-impl ForeignServer {
-    pub(crate) const PRIMARY_PUBLIC: &'static str = "primary_public";
-
-    /// The name of the foreign server under which data for `shard` is
-    /// accessible
-    pub fn name(shard: &Shard) -> String {
-        format!("shard_{}", shard.as_str())
-    }
-
-    /// The name of the schema under which the `subgraphs` schema for
-    /// `shard` is accessible in shards that are not `shard`. In most cases
-    /// you actually want to use `metadata_schema_in`
-    pub fn metadata_schema(shard: &Shard) -> String {
-        format!("{}_subgraphs", Self::name(shard))
-    }
-
-    /// The name of the schema under which the `subgraphs` schema for
-    /// `shard` is accessible in the shard `current`. It is permissible for
-    /// `shard` and `current` to be the same.
-    pub fn metadata_schema_in(shard: &Shard, current: &Shard) -> String {
-        if shard == current {
-            "subgraphs".to_string()
-        } else {
-            Self::metadata_schema(&shard)
-        }
-    }
-
-    pub fn new_from_raw(shard: String, postgres_url: &str) -> Result<Self, anyhow::Error> {
-        Self::new(Shard::new(shard)?, postgres_url)
-    }
-
-    pub fn new(shard: Shard, postgres_url: &str) -> Result<Self, anyhow::Error> {
-        let config: Config = match postgres_url.parse() {
-            Ok(config) => config,
-            Err(e) => panic!(
-                "failed to parse Postgres connection string `{}`: {}",
-                SafeDisplay(postgres_url),
-                e
-            ),
-        };
-
-        let host = match config.get_hosts().get(0) {
-            Some(Host::Tcp(host)) => host.to_string(),
-            _ => bail!("can not find host name in `{}`", SafeDisplay(postgres_url)),
-        };
-
-        let user = config
-            .get_user()
-            .ok_or_else(|| anyhow!("could not find user in `{}`", SafeDisplay(postgres_url)))?
-            .to_string();
-        let password = String::from_utf8(
-            config
-                .get_password()
-                .ok_or_else(|| {
-                    anyhow!(
-                        "could not find password in `{}`; you must provide one.",
-                        SafeDisplay(postgres_url)
-                    )
-                })?
-                .into(),
-        )?;
-        let port = config.get_ports().first().cloned().unwrap_or(5432u16);
-        let dbname = config
-            .get_dbname()
-            .map(|s| s.to_string())
-            .ok_or_else(|| anyhow!("could not find user in `{}`", SafeDisplay(postgres_url)))?;
-
-        Ok(Self {
-            name: Self::name(&shard),
-            shard,
-            user,
-            password,
-            host,
-            port,
-            dbname,
-        })
-    }
-
-    /// Create a new foreign server and user mapping on `conn` for this foreign
-    /// server
-    fn create(&self, conn: &PgConnection) -> Result<(), StoreError> {
-        let query = format!(
-            "\
-        create server \"{name}\"
-               foreign data wrapper postgres_fdw
-               options (host '{remote_host}', port '{remote_port}', dbname '{remote_db}', updatable 'false');
-        create user mapping
-               for current_user server \"{name}\"
-               options (user '{remote_user}', password '{remote_password}');",
-            name = self.name,
-            remote_host = self.host,
-            remote_port = self.port,
-            remote_db = self.dbname,
-            remote_user = self.user,
-            remote_password = self.password,
-        );
-        Ok(conn.batch_execute(&query)?)
-    }
-
-    /// Update an existing user mapping with possibly new details
-    fn update(&self, conn: &PgConnection) -> Result<(), StoreError> {
-        let options = catalog::server_options(conn, &self.name)?;
-        let set_or_add = |option: &str| -> &'static str {
-            if options.contains_key(option) {
-                "set"
-            } else {
-                "add"
-            }
-        };
-
-        let query = format!(
-            "\
-        alter server \"{name}\"
-              options (set host '{remote_host}', {set_port} port '{remote_port}', set dbname '{remote_db}');
-        alter user mapping
-              for current_user server \"{name}\"
-              options (set user '{remote_user}', set password '{remote_password}');",
-            name = self.name,
-            remote_host = self.host,
-            set_port = set_or_add("port"),
-            remote_port = self.port,
-            remote_db = self.dbname,
-            remote_user = self.user,
-            remote_password = self.password,
-        );
-        Ok(conn.batch_execute(&query)?)
-    }
-
-    /// Map key tables from the primary into our local schema. If we are the
-    /// primary, set them up as views.
-    fn map_primary(conn: &PgConnection, shard: &Shard) -> Result<(), StoreError> {
-        catalog::recreate_schema(conn, Self::PRIMARY_PUBLIC)?;
-
-        let mut query = String::new();
-        for table_name in ["deployment_schemas", "chains", "active_copies"] {
-            let create_stmt = if shard == &*PRIMARY_SHARD {
-                format!(
-                    "create view {nsp}.{table_name} as select * from public.{table_name};",
-                    nsp = Self::PRIMARY_PUBLIC,
-                    table_name = table_name
-                )
-            } else {
-                catalog::create_foreign_table(
-                    conn,
-                    NAMESPACE_PUBLIC,
-                    table_name,
-                    Self::PRIMARY_PUBLIC,
-                    Self::name(&PRIMARY_SHARD).as_str(),
-                )?
-            };
-            write!(query, "{}", create_stmt)?;
-        }
-        conn.batch_execute(&query)?;
-        Ok(())
-    }
-
-    /// Map the `subgraphs` schema from the foreign server `self` into the
-    /// database accessible through `conn`
-    fn map_metadata(&self, conn: &PgConnection) -> Result<(), StoreError> {
-        let nsp = Self::metadata_schema(&self.shard);
-        catalog::recreate_schema(conn, &nsp)?;
-        let mut query = String::new();
-        for table_name in [
-            "subgraph_error",
-            "dynamic_ethereum_contract_data_source",
-            "table_stats",
-            "subgraph_deployment_assignment",
-            "subgraph",
-            "subgraph_version",
-            "subgraph_deployment",
-            "subgraph_manifest",
-        ] {
-            let create_stmt =
-                catalog::create_foreign_table(conn, "subgraphs", table_name, &nsp, &self.name)?;
-            write!(query, "{}", create_stmt)?;
-        }
-        Ok(conn.batch_execute(&query)?)
-    }
-}
-
-/// How long to keep connections in the `fdw_pool` around before closing
-/// them on idle. This is much shorter than the default of 10 minutes.
-const FDW_IDLE_TIMEOUT: Duration = Duration::from_secs(60);
-
-/// A pool goes through several states, and this enum tracks what state we
-/// are in, together with the `state_tracker` field on `ConnectionPool`.
-/// When first created, the pool is in state `Created`; once we successfully
-/// called `setup` on it, it moves to state `Ready`. During use, we use the
-/// r2d2 callbacks to determine if the database is available or not, and set
-/// the `available` field accordingly. Tracking that allows us to fail fast
-/// and avoids having to wait for a connection timeout every time we need a
-/// database connection. That avoids overall undesirable states like buildup
-/// of queries; instead of queueing them until the database is available,
-/// they return almost immediately with an error
-enum PoolState {
-    /// A connection pool, and all the servers for which we need to
-    /// establish fdw mappings when we call `setup` on the pool
-    Created(Arc<PoolInner>, Arc<PoolCoordinator>),
-    /// The pool has been successfully set up
-    Ready(Arc<PoolInner>),
-    /// The pool has been disabled by setting its size to 0
-    Disabled,
-}
-
-#[derive(Clone)]
-pub struct ConnectionPool {
-    inner: Arc<TimedMutex<PoolState>>,
-    logger: Logger,
-    pub shard: Shard,
-    state_tracker: PoolStateTracker,
-}
-
-impl fmt::Debug for ConnectionPool {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ConnectionPool")
-            .field("shard", &self.shard)
-            .finish()
-    }
-}
-
-/// The name of the pool, mostly for logging, and what purpose it serves.
-/// The main pool will always be called `main`, and can be used for reading
-/// and writing. Replica pools can only be used for reading, and don't
-/// require any setup (migrations etc.)
-pub enum PoolName {
-    Main,
-    Replica(String),
-}
-
-impl PoolName {
-    fn as_str(&self) -> &str {
-        match self {
-            PoolName::Main => "main",
-            PoolName::Replica(name) => name,
-        }
-    }
-
-    fn is_replica(&self) -> bool {
-        match self {
-            PoolName::Main => false,
-            PoolName::Replica(_) => true,
-        }
-    }
-}
-
-#[derive(Clone)]
-struct PoolStateTracker {
-    available: Arc<AtomicBool>,
-}
-
-impl PoolStateTracker {
-    fn new() -> Self {
-        Self {
-            available: Arc::new(AtomicBool::new(true)),
-        }
-    }
-
-    fn mark_available(&self) {
-        self.available.store(true, Ordering::Relaxed);
-    }
-
-    fn mark_unavailable(&self) {
-        self.available.store(false, Ordering::Relaxed);
-    }
-
-    fn is_available(&self) -> bool {
-        self.available.load(Ordering::Relaxed)
-    }
-}
-
-impl ConnectionPool {
-    fn create(
-        shard_name: &str,
-        pool_name: PoolName,
-        postgres_url: String,
-        pool_size: u32,
-        fdw_pool_size: Option<u32>,
-        logger: &Logger,
-        registry: Arc<MetricsRegistry>,
-        coord: Arc<PoolCoordinator>,
-    ) -> ConnectionPool {
-        let state_tracker = PoolStateTracker::new();
-        let shard =
-            Shard::new(shard_name.to_string()).expect("shard_name is a valid name for a shard");
-        let pool_state = {
-            if pool_size == 0 {
-                PoolState::Disabled
-            } else {
-                let pool = PoolInner::create(
-                    shard.clone(),
-                    pool_name.as_str(),
-                    postgres_url,
-                    pool_size,
-                    fdw_pool_size,
-                    logger,
-                    registry,
-                    state_tracker.clone(),
-                );
-                if pool_name.is_replica() {
-                    PoolState::Ready(Arc::new(pool))
-                } else {
-                    PoolState::Created(Arc::new(pool), coord)
-                }
-            }
-        };
-        ConnectionPool {
-            inner: Arc::new(TimedMutex::new(pool_state, format!("pool-{}", shard_name))),
-            logger: logger.clone(),
-            shard,
-            state_tracker,
-        }
-    }
-
-    /// This is only used for `graphman` to ensure it doesn't run migrations
-    /// or other setup steps
-    pub fn skip_setup(&self) {
-        let mut guard = self.inner.lock(&self.logger);
-        match &*guard {
-            PoolState::Created(pool, _) => *guard = PoolState::Ready(pool.clone()),
-            PoolState::Ready(_) | PoolState::Disabled => { /* nothing to do */ }
-        }
-    }
-
-    /// Return a pool that is ready, i.e., connected to the database. If the
-    /// pool has not been set up yet, call `setup`. If there are any errors
-    /// or the pool is marked as unavailable, return
-    /// `StoreError::DatabaseUnavailable`
-    fn get_ready(&self) -> Result<Arc<PoolInner>, StoreError> {
-        let mut guard = self.inner.lock(&self.logger);
-        if !self.state_tracker.is_available() {
-            // We know that trying to use this pool is pointless since the
-            // database is not available, and will only lead to other
-            // operations having to wait until the connection timeout is
-            // reached.
-            return Err(StoreError::DatabaseUnavailable);
-        }
-
-        match &*guard {
-            PoolState::Created(pool, servers) => {
-                pool.setup(servers.clone())?;
-                let pool2 = pool.clone();
-                *guard = PoolState::Ready(pool.clone());
-                self.state_tracker.mark_available();
-                Ok(pool2)
-            }
-            PoolState::Ready(pool) => Ok(pool.clone()),
-            PoolState::Disabled => Err(StoreError::DatabaseDisabled),
-        }
-    }
-
-    /// Execute a closure with a connection to the database.
-    ///
-    /// # API
-    ///   The API of using a closure to bound the usage of the connection serves several
-    ///   purposes:
-    ///
-    ///   * Moves blocking database access out of the `Future::poll`. Within
-    ///     `Future::poll` (which includes all `async` methods) it is illegal to
-    ///     perform a blocking operation. This includes all accesses to the
-    ///     database, acquiring of locks, etc. Calling a blocking operation can
-    ///     cause problems with `Future` combinators (including but not limited
-    ///     to select, timeout, and FuturesUnordered) and problems with
-    ///     executors/runtimes. This method moves the database work onto another
-    ///     thread in a way which does not block `Future::poll`.
-    ///
-    ///   * Limit the total number of connections. Because the supplied closure
-    ///     takes a reference, we know the scope of the usage of all entity
-    ///     connections and can limit their use in a non-blocking way.
-    ///
-    /// # Cancellation
-    ///   The normal pattern for futures in Rust is drop to cancel. Once we
-    ///   spawn the database work in a thread though, this expectation no longer
-    ///   holds because the spawned task is the independent of this future. So,
-    ///   this method provides a cancel token which indicates that the `Future`
-    ///   has been dropped. This isn't *quite* as good as drop on cancel,
-    ///   because a drop on cancel can do things like cancel http requests that
-    ///   are in flight, but checking for cancel periodically is a significant
-    ///   improvement.
-    ///
-    ///   The implementation of the supplied closure should check for cancel
-    ///   between every operation that is potentially blocking. This includes
-    ///   any method which may interact with the database. The check can be
-    ///   conveniently written as `token.check_cancel()?;`. It is low overhead
-    ///   to check for cancel, so when in doubt it is better to have too many
-    ///   checks than too few.
-    ///
-    /// # Panics:
-    ///   * This task will panic if the supplied closure panics
-    ///   * This task will panic if the supplied closure returns Err(Cancelled)
-    ///     when the supplied cancel token is not cancelled.
-    pub(crate) async fn with_conn<T: Send + 'static>(
-        &self,
-        f: impl 'static
-            + Send
-            + FnOnce(
-                &PooledConnection<ConnectionManager<PgConnection>>,
-                &CancelHandle,
-            ) -> Result<T, CancelableError<StoreError>>,
-    ) -> Result<T, StoreError> {
-        let pool = self.get_ready()?;
-        pool.with_conn(f).await
-    }
-
-    pub fn get(&self) -> Result<PooledConnection<ConnectionManager<PgConnection>>, StoreError> {
-        self.get_ready()?.get()
-    }
-
-    /// Get a connection from the pool for foreign data wrapper access;
-    /// since that pool can be very contended, periodically log that we are
-    /// still waiting for a connection
-    ///
-    /// The `timeout` is called every time we time out waiting for a
-    /// connection. If `timeout` returns `true`, `get_fdw` returns with that
-    /// error, otherwise we try again to get a connection.
-    pub fn get_fdw<F>(
-        &self,
-        logger: &Logger,
-        timeout: F,
-    ) -> Result<PooledConnection<ConnectionManager<PgConnection>>, StoreError>
-    where
-        F: FnMut() -> bool,
-    {
-        self.get_ready()?.get_fdw(logger, timeout)
-    }
-
-    pub fn connection_detail(&self) -> Result<ForeignServer, StoreError> {
-        let pool = self.get_ready()?;
-        ForeignServer::new(pool.shard.clone(), &pool.postgres_url).map_err(|e| e.into())
-    }
-
-    /// Check that we can connect to the database
-    pub fn check(&self) -> bool {
-        true
-    }
-
-    /// Setup the database for this pool. This includes configuring foreign
-    /// data wrappers for cross-shard communication, and running any pending
-    /// schema migrations for this database.
-    ///
-    /// # Panics
-    ///
-    /// If any errors happen during the migration, the process panics
-    pub async fn setup(&self) {
-        let pool = self.clone();
-        graph::spawn_blocking_allow_panic(move || {
-            pool.get_ready().ok();
-        })
-        .await
-        // propagate panics
-        .unwrap();
-    }
-
-    pub(crate) async fn query_permit(&self) -> Result<QueryPermit, StoreError> {
-        let pool = match &*self.inner.lock(&self.logger) {
-            PoolState::Created(pool, _) | PoolState::Ready(pool) => pool.clone(),
-            PoolState::Disabled => {
-                return Err(StoreError::DatabaseDisabled);
-            }
-        };
-        let start = Instant::now();
-        let permit = pool.query_permit().await;
-        Ok(QueryPermit {
-            permit,
-            wait: start.elapsed(),
-        })
-    }
-
-    pub(crate) fn wait_stats(&self) -> Result<PoolWaitStats, StoreError> {
-        match &*self.inner.lock(&self.logger) {
-            PoolState::Created(pool, _) | PoolState::Ready(pool) => Ok(pool.wait_stats.clone()),
-            PoolState::Disabled => Err(StoreError::DatabaseDisabled),
-        }
-    }
-
-    /// Mirror key tables from the primary into our own schema. We do this
-    /// by manually inserting or deleting rows through comparing it with the
-    /// table on the primary. Once we drop support for PG 9.6, we can
-    /// simplify all this and achieve the same result with logical
-    /// replication.
-    pub(crate) async fn mirror_primary_tables(&self) -> Result<(), StoreError> {
-        let pool = self.get_ready()?;
-        pool.mirror_primary_tables().await
-    }
-}
-
-fn brief_error_msg(error: &dyn std::error::Error) -> String {
-    // For 'Connection refused' errors, Postgres includes the IP and
-    // port number in the error message. We want to suppress that and
-    // only use the first line from the error message. For more detailed
-    // analysis, 'Connection refused' manifests as a
-    // `ConnectionError(BadConnection("could not connect to server:
-    // Connection refused.."))`
-    error
-        .to_string()
-        .split('\n')
-        .next()
-        .unwrap_or("no error details provided")
-        .to_string()
-}
-
-#[derive(Clone)]
-struct ErrorHandler {
-    logger: Logger,
-    counter: Counter,
-    state_tracker: PoolStateTracker,
-}
-
-impl ErrorHandler {
-    fn new(logger: Logger, counter: Counter, state_tracker: PoolStateTracker) -> Self {
-        Self {
-            logger,
-            counter,
-            state_tracker,
-        }
-    }
-}
-impl std::fmt::Debug for ErrorHandler {
-    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Result::Ok(())
-    }
-}
-
-impl r2d2::HandleError<r2d2::Error> for ErrorHandler {
-    fn handle_error(&self, error: r2d2::Error) {
-        let msg = brief_error_msg(&error);
-
-        // Don't count canceling statements for timeouts etc. as a
-        // connection error. Unfortunately, we only have the textual error
-        // and need to infer whether the error indicates that the database
-        // is down or if something else happened. When querying a replica,
-        // these messages indicate that a query was canceled because it
-        // conflicted with replication, but does not indicate that there is
-        // a problem with the database itself.
-        //
-        // This check will break if users run Postgres (or even graph-node)
-        // in a locale other than English. In that case, their database will
-        // be marked as unavailable even though it is perfectly fine.
-        if msg.contains("canceling statement")
-            || msg.contains("terminating connection due to conflict with recovery")
-        {
-            return;
-        }
-
-        self.counter.inc();
-        if self.state_tracker.is_available() {
-            error!(self.logger, "Postgres connection error"; "error" => msg);
-        }
-        self.state_tracker.mark_unavailable();
-    }
-}
-
-#[derive(Clone)]
-struct EventHandler {
-    logger: Logger,
-    count_gauge: Gauge,
-    wait_gauge: Gauge,
-    size_gauge: Gauge,
-    wait_stats: PoolWaitStats,
-    state_tracker: PoolStateTracker,
-}
-
-impl EventHandler {
-    fn new(
-        logger: Logger,
-        registry: Arc<MetricsRegistry>,
-        wait_stats: PoolWaitStats,
-        const_labels: HashMap<String, String>,
-        state_tracker: PoolStateTracker,
-    ) -> Self {
-        let count_gauge = registry
-            .global_gauge(
-                "store_connection_checkout_count",
-                "The number of Postgres connections currently checked out",
-                const_labels.clone(),
-            )
-            .expect("failed to create `store_connection_checkout_count` counter");
-        let wait_gauge = registry
-            .global_gauge(
-                "store_connection_wait_time_ms",
-                "Average connection wait time",
-                const_labels.clone(),
-            )
-            .expect("failed to create `store_connection_wait_time_ms` counter");
-        let size_gauge = registry
-            .global_gauge(
-                "store_connection_pool_size_count",
-                "Overall size of the connection pool",
-                const_labels,
-            )
-            .expect("failed to create `store_connection_pool_size_count` counter");
-        EventHandler {
-            logger,
-            count_gauge,
-            wait_gauge,
-            wait_stats,
-            size_gauge,
-            state_tracker,
-        }
-    }
-
-    fn add_conn_wait_time(&self, duration: Duration) {
-        self.wait_stats
-            .write()
-            .unwrap()
-            .add_and_register(duration, &self.wait_gauge);
-    }
-}
-
-impl std::fmt::Debug for EventHandler {
-    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Result::Ok(())
-    }
-}
-
-impl HandleEvent for EventHandler {
-    fn handle_acquire(&self, _: e::AcquireEvent) {
-        self.size_gauge.inc();
-        self.state_tracker.mark_available();
-    }
-
-    fn handle_release(&self, _: e::ReleaseEvent) {
-        self.size_gauge.dec();
-    }
-
-    fn handle_checkout(&self, event: e::CheckoutEvent) {
-        self.count_gauge.inc();
-        self.add_conn_wait_time(event.duration());
-        self.state_tracker.mark_available();
-    }
-
-    fn handle_timeout(&self, event: e::TimeoutEvent) {
-        self.add_conn_wait_time(event.timeout());
-        if self.state_tracker.is_available() {
-            error!(self.logger, "Connection checkout timed out";
-               "wait_ms" => event.timeout().as_millis()
-            )
-        }
-        self.state_tracker.mark_unavailable();
-    }
-
-    fn handle_checkin(&self, _: e::CheckinEvent) {
-        self.count_gauge.dec();
-    }
-}
-
-#[derive(Clone)]
-pub struct PoolInner {
-    logger: Logger,
-    pub shard: Shard,
-    pool: Pool<ConnectionManager<PgConnection>>,
-    // A separate pool for connections that will use foreign data wrappers.
-    // Once such a connection accesses a foreign table, Postgres keeps a
-    // connection to the foreign server until the connection is closed.
-    // Normal pooled connections live quite long (up to 10 minutes) and can
-    // therefore keep a lot of connections into foreign databases open. We
-    // mitigate this by using a separate small pool with a much shorter
-    // connection lifetime. Starting with postgres_fdw 1.1 in Postgres 14,
-    // this will no longer be needed since it will then be possible to
-    // explicitly close connections to foreign servers when a connection is
-    // returned to the pool.
-    fdw_pool: Option<Pool<ConnectionManager<PgConnection>>>,
-    limiter: Arc<Semaphore>,
-    postgres_url: String,
-    pub(crate) wait_stats: PoolWaitStats,
-
-    // Limits the number of graphql queries that may execute concurrently. Since one graphql query
-    // may require multiple DB queries, it is useful to organize the queue at the graphql level so
-    // that waiting queries consume few resources. Still this is placed here because the semaphore
-    // is sized acording to the DB connection pool size.
-    query_semaphore: Arc<tokio::sync::Semaphore>,
-    semaphore_wait_stats: Arc<RwLock<MovingStats>>,
-    semaphore_wait_gauge: Box<Gauge>,
-}
-
-impl PoolInner {
-    fn create(
-        shard: Shard,
-        pool_name: &str,
-        postgres_url: String,
-        pool_size: u32,
-        fdw_pool_size: Option<u32>,
-        logger: &Logger,
-        registry: Arc<MetricsRegistry>,
-        state_tracker: PoolStateTracker,
-    ) -> PoolInner {
-        let logger_store = logger.new(o!("component" => "Store"));
-        let logger_pool = logger.new(o!("component" => "ConnectionPool"));
-        let const_labels = {
-            let mut map = HashMap::new();
-            map.insert("pool".to_owned(), pool_name.to_owned());
-            map.insert("shard".to_string(), shard.to_string());
-            map
-        };
-        let error_counter = registry
-            .global_counter(
-                "store_connection_error_count",
-                "The number of Postgres connections errors",
-                const_labels.clone(),
-            )
-            .expect("failed to create `store_connection_error_count` counter");
-        let error_handler = Box::new(ErrorHandler::new(
-            logger_pool.clone(),
-            error_counter,
-            state_tracker.clone(),
-        ));
-        let wait_stats = Arc::new(RwLock::new(MovingStats::default()));
-        let event_handler = Box::new(EventHandler::new(
-            logger_pool.clone(),
-            registry.cheap_clone(),
-            wait_stats.clone(),
-            const_labels.clone(),
-            state_tracker,
-        ));
-
-        // Connect to Postgres
-        let conn_manager = ConnectionManager::new(postgres_url.clone());
-        let min_idle = ENV_VARS.store.connection_min_idle.filter(|min_idle| {
-            if *min_idle <= pool_size {
-                true
-            } else {
-                warn!(
-                    logger_pool,
-                    "Configuration error: min idle {} exceeds pool size {}, ignoring min idle",
-                    min_idle,
-                    pool_size
-                );
-                false
-            }
-        });
-        let builder: Builder<ConnectionManager<PgConnection>> = Pool::builder()
-            .error_handler(error_handler.clone())
-            .event_handler(event_handler.clone())
-            .connection_timeout(ENV_VARS.store.connection_timeout)
-            .max_size(pool_size)
-            .min_idle(min_idle)
-            .idle_timeout(Some(ENV_VARS.store.connection_idle_timeout));
-        let pool = builder.build_unchecked(conn_manager);
-        let fdw_pool = fdw_pool_size.map(|pool_size| {
-            let conn_manager = ConnectionManager::new(postgres_url.clone());
-            let builder: Builder<ConnectionManager<PgConnection>> = Pool::builder()
-                .error_handler(error_handler)
-                .event_handler(event_handler)
-                .connection_timeout(ENV_VARS.store.connection_timeout)
-                .max_size(pool_size)
-                .min_idle(Some(1))
-                .idle_timeout(Some(FDW_IDLE_TIMEOUT));
-            builder.build_unchecked(conn_manager)
-        });
-
-        let limiter = Arc::new(Semaphore::new(pool_size as usize));
-        info!(logger_store, "Pool successfully connected to Postgres");
-
-        let semaphore_wait_gauge = registry
-            .new_gauge(
-                "query_semaphore_wait_ms",
-                "Moving average of time spent on waiting for postgres query semaphore",
-                const_labels,
-            )
-            .expect("failed to create `query_effort_ms` counter");
-        let max_concurrent_queries = pool_size as usize + ENV_VARS.store.extra_query_permits;
-        let query_semaphore = Arc::new(tokio::sync::Semaphore::new(max_concurrent_queries));
-        PoolInner {
-            logger: logger_pool,
-            shard,
-            postgres_url,
-            pool,
-            fdw_pool,
-            limiter,
-            wait_stats,
-            semaphore_wait_stats: Arc::new(RwLock::new(MovingStats::default())),
-            query_semaphore,
-            semaphore_wait_gauge,
-        }
-    }
-
-    /// Execute a closure with a connection to the database.
-    ///
-    /// # API
-    ///   The API of using a closure to bound the usage of the connection serves several
-    ///   purposes:
-    ///
-    ///   * Moves blocking database access out of the `Future::poll`. Within
-    ///     `Future::poll` (which includes all `async` methods) it is illegal to
-    ///     perform a blocking operation. This includes all accesses to the
-    ///     database, acquiring of locks, etc. Calling a blocking operation can
-    ///     cause problems with `Future` combinators (including but not limited
-    ///     to select, timeout, and FuturesUnordered) and problems with
-    ///     executors/runtimes. This method moves the database work onto another
-    ///     thread in a way which does not block `Future::poll`.
-    ///
-    ///   * Limit the total number of connections. Because the supplied closure
-    ///     takes a reference, we know the scope of the usage of all entity
-    ///     connections and can limit their use in a non-blocking way.
-    ///
-    /// # Cancellation
-    ///   The normal pattern for futures in Rust is drop to cancel. Once we
-    ///   spawn the database work in a thread though, this expectation no longer
-    ///   holds because the spawned task is the independent of this future. So,
-    ///   this method provides a cancel token which indicates that the `Future`
-    ///   has been dropped. This isn't *quite* as good as drop on cancel,
-    ///   because a drop on cancel can do things like cancel http requests that
-    ///   are in flight, but checking for cancel periodically is a significant
-    ///   improvement.
-    ///
-    ///   The implementation of the supplied closure should check for cancel
-    ///   between every operation that is potentially blocking. This includes
-    ///   any method which may interact with the database. The check can be
-    ///   conveniently written as `token.check_cancel()?;`. It is low overhead
-    ///   to check for cancel, so when in doubt it is better to have too many
-    ///   checks than too few.
-    ///
-    /// # Panics:
-    ///   * This task will panic if the supplied closure panics
-    ///   * This task will panic if the supplied closure returns Err(Cancelled)
-    ///     when the supplied cancel token is not cancelled.
-    pub(crate) async fn with_conn<T: Send + 'static>(
-        &self,
-        f: impl 'static
-            + Send
-            + FnOnce(
-                &PooledConnection<ConnectionManager<PgConnection>>,
-                &CancelHandle,
-            ) -> Result<T, CancelableError<StoreError>>,
-    ) -> Result<T, StoreError> {
-        let _permit = self.limiter.acquire().await;
-        let pool = self.clone();
-
-        let cancel_guard = CancelGuard::new();
-        let cancel_handle = cancel_guard.handle();
-
-        let result = graph::spawn_blocking_allow_panic(move || {
-            // It is possible time has passed between scheduling on the
-            // threadpool and being executed. Time to check for cancel.
-            cancel_handle.check_cancel()?;
-
-            // A failure to establish a connection is propagated as though the
-            // closure failed.
-            let conn = pool
-                .get()
-                .map_err(|_| CancelableError::Error(StoreError::DatabaseUnavailable))?;
-
-            // It is possible time has passed while establishing a connection.
-            // Time to check for cancel.
-            cancel_handle.check_cancel()?;
-
-            f(&conn, &cancel_handle)
-        })
-        .await
-        .unwrap(); // Propagate panics, though there shouldn't be any.
-
-        drop(cancel_guard);
-
-        // Finding cancel isn't technically unreachable, since there is nothing
-        // stopping the supplied closure from returning Canceled even if the
-        // supplied handle wasn't canceled. That would be very unexpected, the
-        // doc comment for this function says we will panic in this scenario.
-        match result {
-            Ok(t) => Ok(t),
-            Err(CancelableError::Error(e)) => Err(e),
-            Err(CancelableError::Cancel) => panic!("The closure supplied to with_entity_conn must not return Err(Canceled) unless the supplied token was canceled."),
-        }
-    }
-
-    pub fn get(&self) -> Result<PooledConnection<ConnectionManager<PgConnection>>, StoreError> {
-        self.pool.get().map_err(|_| StoreError::DatabaseUnavailable)
-    }
-
-    pub fn get_with_timeout_warning(
-        &self,
-        logger: &Logger,
-    ) -> Result<PooledConnection<ConnectionManager<PgConnection>>, StoreError> {
-        loop {
-            match self.pool.get_timeout(ENV_VARS.store.connection_timeout) {
-                Ok(conn) => return Ok(conn),
-                Err(e) => error!(logger, "Error checking out connection, retrying";
-                   "error" => brief_error_msg(&e),
-                ),
-            }
-        }
-    }
-
-    /// Get a connection from the pool for foreign data wrapper access;
-    /// since that pool can be very contended, periodically log that we are
-    /// still waiting for a connection
-    ///
-    /// The `timeout` is called every time we time out waiting for a
-    /// connection. If `timeout` returns `true`, `get_fdw` returns with that
-    /// error, otherwise we try again to get a connection.
-    pub fn get_fdw<F>(
-        &self,
-        logger: &Logger,
-        mut timeout: F,
-    ) -> Result<PooledConnection<ConnectionManager<PgConnection>>, StoreError>
-    where
-        F: FnMut() -> bool,
-    {
-        let pool = match &self.fdw_pool {
-            Some(pool) => pool,
-            None => {
-                const MSG: &str =
-                    "internal error: trying to get fdw connection on a pool that doesn't have any";
-                error!(logger, "{}", MSG);
-                return Err(constraint_violation!(MSG));
-            }
-        };
-        loop {
-            match pool.get() {
-                Ok(conn) => return Ok(conn),
-                Err(e) => {
-                    if timeout() {
-                        return Err(e.into());
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn connection_detail(&self) -> Result<ForeignServer, StoreError> {
-        ForeignServer::new(self.shard.clone(), &self.postgres_url).map_err(|e| e.into())
-    }
-
-    /// Check that we can connect to the database
-    pub fn check(&self) -> bool {
-        self.pool
-            .get()
-            .ok()
-            .map(|conn| sql_query("select 1").execute(&conn).is_ok())
-            .unwrap_or(false)
-    }
-
-    /// Setup the database for this pool. This includes configuring foreign
-    /// data wrappers for cross-shard communication, and running any pending
-    /// schema migrations for this database.
-    ///
-    /// Returns `StoreError::DatabaseUnavailable` if we can't connect to the
-    /// database. Any other error causes a panic.
-    ///
-    /// # Panics
-    ///
-    /// If any errors happen during the migration, the process panics
-    fn setup(&self, coord: Arc<PoolCoordinator>) -> Result<(), StoreError> {
-        fn die(logger: &Logger, msg: &'static str, err: &dyn std::fmt::Display) -> ! {
-            crit!(logger, "{}", msg; "error" => format!("{:#}", err));
-            panic!("{}: {}", msg, err);
-        }
-
-        let pool = self.clone();
-        let conn = self.get().map_err(|_| StoreError::DatabaseUnavailable)?;
-
-        let start = Instant::now();
-
-        advisory_lock::lock_migration(&conn)
-            .unwrap_or_else(|err| die(&pool.logger, "failed to get migration lock", &err));
-        // This code can cause a race in database setup: if pool A has had
-        // schema changes and pool B then tries to map tables from pool A,
-        // but does so before the concurrent thread running this code for
-        // pool B has at least finished `configure_fdw`, mapping tables will
-        // fail. In that case, the node must be restarted. The restart is
-        // guaranteed because this failure will lead to a panic in the setup
-        // for pool A
-        //
-        // This code can also leave the table mappings in a state where they
-        // have not been updated if the process is killed after migrating
-        // the schema but before finishing remapping in all shards.
-        // Addressing that would require keeping track of the need to remap
-        // in the database instead of just in memory
-        let result = pool
-            .configure_fdw(coord.servers.as_ref())
-            .and_then(|()| migrate_schema(&pool.logger, &conn))
-            .and_then(|count| coord.propagate(&pool, count));
-        debug!(&pool.logger, "Release migration lock");
-        advisory_lock::unlock_migration(&conn).unwrap_or_else(|err| {
-            die(&pool.logger, "failed to release migration lock", &err);
-        });
-        result.unwrap_or_else(|err| die(&pool.logger, "migrations failed", &err));
-
-        // Locale check
-        if let Err(msg) = catalog::Locale::load(&conn)?.suitable() {
-            if &self.shard == &*PRIMARY_SHARD && primary::is_empty(&conn)? {
-                die(
-                    &pool.logger,
-                    "Database does not use C locale. \
-                    Please check the graph-node documentation for how to set up the database locale",
-                    &msg,
-                );
-            } else {
-                warn!(pool.logger, "{}.\nPlease check the graph-node documentation for how to set up the database locale", msg);
-            }
-        }
-
-        debug!(&pool.logger, "Setup finished"; "setup_time_s" => start.elapsed().as_secs());
-        Ok(())
-    }
-
-    pub(crate) async fn query_permit(&self) -> tokio::sync::OwnedSemaphorePermit {
-        let start = Instant::now();
-        let permit = self.query_semaphore.cheap_clone().acquire_owned().await;
-        self.semaphore_wait_stats
-            .write()
-            .unwrap()
-            .add_and_register(start.elapsed(), &self.semaphore_wait_gauge);
-        permit.unwrap()
-    }
-
-    fn configure_fdw(&self, servers: &[ForeignServer]) -> Result<(), StoreError> {
-        info!(&self.logger, "Setting up fdw");
-        let conn = self.get()?;
-        conn.batch_execute("create extension if not exists postgres_fdw")?;
-        conn.transaction(|| {
-            let current_servers: Vec<String> = crate::catalog::current_servers(&conn)?;
-            for server in servers.iter().filter(|server| server.shard != self.shard) {
-                if current_servers.contains(&server.name) {
-                    server.update(&conn)?;
-                } else {
-                    server.create(&conn)?;
-                }
-            }
-            Ok(())
-        })
-    }
-
-    /// Copy the data from key tables in the primary into our local schema
-    /// so it can be used as a fallback when the primary goes down
-    pub async fn mirror_primary_tables(&self) -> Result<(), StoreError> {
-        if self.shard == *PRIMARY_SHARD {
-            return Ok(());
-        }
-        self.with_conn(|conn, handle| {
-            conn.transaction(|| {
-                primary::Mirror::refresh_tables(conn, handle).map_err(CancelableError::from)
-            })
-        })
-        .await
-    }
-
-    // The foreign server `server` had schema changes, and we therefore need
-    // to remap anything that we are importing via fdw to make sure we are
-    // using this updated schema
-    pub fn remap(&self, server: &ForeignServer) -> Result<(), StoreError> {
-        if &server.shard == &*PRIMARY_SHARD {
-            info!(&self.logger, "Mapping primary");
-            let conn = self.get()?;
-            conn.transaction(|| ForeignServer::map_primary(&conn, &self.shard))?;
-        }
-        if &server.shard != &self.shard {
-            info!(
-                &self.logger,
-                "Mapping metadata from {}",
-                server.shard.as_str()
-            );
-            let conn = self.get()?;
-            conn.transaction(|| server.map_metadata(&conn))?;
-        }
-        Ok(())
-    }
-}
-
-embed_migrations!("./migrations");
-
-struct MigrationCount {
-    old: usize,
-    new: usize,
-}
-
-impl MigrationCount {
-    fn new(old: usize, new: usize) -> Self {
-        Self { old, new }
-    }
-
-    fn had_migrations(&self) -> bool {
-        self.old != self.new
-    }
-
-    fn is_new(&self) -> bool {
-        self.old == 0
-    }
-}
-
-/// Run all schema migrations.
-///
-/// When multiple `graph-node` processes start up at the same time, we ensure
-/// that they do not run migrations in parallel by using `blocking_conn` to
-/// serialize them. The `conn` is used to run the actual migration.
-fn migrate_schema(logger: &Logger, conn: &PgConnection) -> Result<MigrationCount, StoreError> {
-    // Collect migration logging output
-    let mut output = vec![];
-
-    let old_count = catalog::migration_count(conn)?;
-
-    info!(logger, "Running migrations");
-    let result = embedded_migrations::run_with_output(conn, &mut output);
-    info!(logger, "Migrations finished");
-
-    let new_count = catalog::migration_count(conn)?;
-
-    // If there was any migration output, log it now
-    let msg = String::from_utf8(output).unwrap_or_else(|_| String::from("<unreadable>"));
-    let msg = msg.trim();
-    if !msg.is_empty() {
-        let msg = msg.replace('\n', " ");
-        if let Err(e) = result {
-            error!(logger, "Postgres migration error"; "output" => msg);
-            return Err(StoreError::Unknown(e.into()));
-        } else {
-            debug!(logger, "Postgres migration output"; "output" => msg);
-        }
-    }
-    let count = MigrationCount::new(old_count, new_count);
-
-    if count.had_migrations() {
-        // Reset the query statistics since a schema change makes them not
-        // all that useful. An error here is not serious and can be ignored.
-        conn.batch_execute("select pg_stat_statements_reset()").ok();
-    }
-
-    Ok(count)
-}
-
-/// Helper to coordinate propagating schema changes from the database that
-/// changes schema to all other shards so they can update their fdw mappings
-/// of tables imported from that shard
-pub struct PoolCoordinator {
-    pools: Mutex<HashMap<Shard, Arc<PoolInner>>>,
-    servers: Arc<Vec<ForeignServer>>,
-}
-
-impl PoolCoordinator {
-    pub fn new(servers: Arc<Vec<ForeignServer>>) -> Self {
-        Self {
-            pools: Mutex::new(HashMap::new()),
-            servers,
-        }
-    }
-
-    pub fn create_pool(
-        self: Arc<Self>,
-        logger: &Logger,
-        name: &str,
-        pool_name: PoolName,
-        postgres_url: String,
-        pool_size: u32,
-        fdw_pool_size: Option<u32>,
-        registry: Arc<MetricsRegistry>,
-    ) -> ConnectionPool {
-        let is_writable = !pool_name.is_replica();
-
-        let pool = ConnectionPool::create(
-            name,
-            pool_name,
-            postgres_url,
-            pool_size,
-            fdw_pool_size,
-            logger,
-            registry,
-            self.cheap_clone(),
-        );
-
-        // Ignore non-writable pools (replicas), there is no need (and no
-        // way) to coordinate schema changes with them
-        if is_writable {
-            // It is safe to take this lock here since nobody has seen the pool
-            // yet. We remember the `PoolInner` so that later, when we have to
-            // call `remap()`, we do not have to take this lock as that will be
-            // already held in `get_ready()`
-            match &*pool.inner.lock(logger) {
-                PoolState::Created(inner, _) | PoolState::Ready(inner) => {
-                    self.pools
-                        .lock()
-                        .unwrap()
-                        .insert(pool.shard.clone(), inner.clone());
-                }
-                PoolState::Disabled => { /* nothing to do */ }
-            }
-        }
-        pool
-    }
-
-    /// Propagate changes to the schema in `shard` to all other pools. Those
-    /// other pools will then recreate any tables that they imported from
-    /// `shard`. If `pool` is a new shard, we also map all other shards into
-    /// it.
-    fn propagate(&self, pool: &PoolInner, count: MigrationCount) -> Result<(), StoreError> {
-        // pool is a new shard, map all other shards into it
-        if count.is_new() {
-            for server in self.servers.iter() {
-                pool.remap(server)?;
-            }
-        }
-        // pool had schema changes, refresh the import from pool into all other shards
-        if count.had_migrations() {
-            let server = self.server(&pool.shard)?;
-            for pool in self.pools.lock().unwrap().values() {
-                if let Err(e) = pool.remap(server) {
-                    error!(pool.logger, "Failed to map imports from {}", server.shard; "error" => e.to_string());
-                    return Err(e);
-                }
-            }
-        }
-        Ok(())
-    }
-
-    pub fn pools(&self) -> Vec<Arc<PoolInner>> {
-        self.pools.lock().unwrap().values().cloned().collect()
-    }
-
-    pub fn servers(&self) -> Arc<Vec<ForeignServer>> {
-        self.servers.clone()
-    }
-
-    fn server(&self, shard: &Shard) -> Result<&ForeignServer, StoreError> {
-        self.servers
-            .iter()
-            .find(|server| &server.shard == shard)
-            .ok_or_else(|| constraint_violation!("unknown shard {shard}"))
-    }
-}
diff --git a/store/postgres/src/copy.rs b/store/postgres/src/copy.rs
index bc05fbc899a..d35e585a653 100644
--- a/store/postgres/src/copy.rs
+++ b/store/postgres/src/copy.rs
@@ -12,45 +12,40 @@
 //! operation can resume after an interruption, for example, because
 //! `graph-node` was restarted while the copy was running.
 use std::{
+    collections::HashSet,
     convert::TryFrom,
-    io::Write,
-    sync::Arc,
+    future::Future,
+    pin::Pin,
+    sync::{
+        Arc, Mutex,
+        atomic::{AtomicBool, AtomicI64, Ordering},
+    },
     time::{Duration, Instant},
 };
 
 use diesel::{
-    dsl::sql,
-    insert_into,
-    pg::Pg,
-    r2d2::{ConnectionManager, PooledConnection},
-    select,
-    serialize::Output,
-    sql_query,
-    sql_types::{BigInt, Integer},
-    types::{FromSql, ToSql},
-    update, Connection as _, ExpressionMethods, OptionalExtension, PgConnection, QueryDsl,
-    RunQueryDsl,
-};
-use graph::{
-    constraint_violation,
-    prelude::{info, o, warn, BlockNumber, BlockPtr, Logger, StoreError, ENV_VARS},
-    schema::EntityType,
+    ExpressionMethods, OptionalExtension, QueryDsl, dsl::sql, insert_into, select, update,
 };
+use diesel_async::{AsyncConnection, RunQueryDsl, SimpleAsyncConnection};
 
 use crate::{
-    advisory_lock, catalog,
+    AsyncPgConnection, ConnectionPool, advisory_lock, catalog, deployment,
     dynds::DataSourcesTable,
-    primary::{DeploymentId, Site},
+    pool::TxnCallback,
+    primary::{DeploymentId, Primary, Site},
+    relational::{Layout, Table, index::IndexList},
+    relational_queries as rq,
+    vid_batcher::{VidBatcher, VidRange},
+};
+use graph::{
+    futures03::{FutureExt as _, future::select_all},
+    internal_error,
+    prelude::{
+        BlockNumber, BlockPtr, CheapClone, ENV_VARS, Logger, StoreError, info, lazy_static, o, warn,
+    },
+    schema::EntityType,
+    slog::error,
 };
-use crate::{connection_pool::ConnectionPool, relational::Layout};
-use crate::{relational::Table, relational_queries as rq};
-
-/// The initial batch size for tables that do not have an array column
-const INITIAL_BATCH_SIZE: i64 = 10_000;
-/// The initial batch size for tables that do have an array column; those
-/// arrays can be large and large arrays will slow down copying a lot. We
-/// therefore tread lightly in that case
-const INITIAL_BATCH_SIZE_LIST: i64 = 100;
 
 const LOG_INTERVAL: Duration = Duration::from_secs(3 * 60);
 
@@ -64,6 +59,13 @@ const ACCEPTABLE_REPLICATION_LAG: Duration = Duration::from_secs(30);
 /// the lag again
 const REPLICATION_SLEEP: Duration = Duration::from_secs(10);
 
+lazy_static! {
+    pub(crate) static ref BATCH_STATEMENT_TIMEOUT: Option<String> = ENV_VARS
+        .store
+        .batch_timeout
+        .map(|duration| format!("set local statement_timeout={}", duration.as_millis()));
+}
+
 table! {
     subgraphs.copy_state(dst) {
         // deployment_schemas.id
@@ -95,32 +97,24 @@ table! {
     }
 }
 
-// This is the same as primary::active_copies, but mapped into each shard
-table! {
-    primary_public.active_copies(dst) {
-        src -> Integer,
-        dst -> Integer,
-        cancelled_at -> Nullable<Date>,
-    }
-}
-
-#[derive(Copy, Clone, PartialEq, Eq)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum Status {
     Finished,
     Cancelled,
 }
 
-#[allow(dead_code)]
 struct CopyState {
     src: Arc<Layout>,
     dst: Arc<Layout>,
     target_block: BlockPtr,
-    tables: Vec<TableState>,
+    finished: Vec<TableState>,
+    unfinished: Vec<TableState>,
 }
 
 impl CopyState {
-    fn new(
-        conn: &PgConnection,
+    async fn new(
+        conn: &mut AsyncPgConnection,
+        primary: Primary,
         src: Arc<Layout>,
         dst: Arc<Layout>,
         target_block: BlockPtr,
@@ -129,28 +123,30 @@ impl CopyState {
 
         let crosses_shards = dst.site.shard != src.site.shard;
         if crosses_shards {
-            src.import_schema(conn)?;
+            src.import_schema(conn).await?;
         }
 
         let state = match cs::table
             .filter(cs::dst.eq(dst.site.id))
             .select((cs::src, cs::target_block_hash, cs::target_block_number))
             .first::<(DeploymentId, Vec<u8>, BlockNumber)>(conn)
+            .await
             .optional()?
         {
             Some((src_id, hash, number)) => {
                 let stored_target_block = BlockPtr::from((hash, number));
                 if stored_target_block != target_block {
-                    return Err(constraint_violation!(
+                    return Err(internal_error!(
                         "CopyState {} for copying {} to {} has incompatible block pointer {} instead of {}",
                         dst.site.id,
                         src.site.deployment,
                         dst.site.deployment,
                         stored_target_block,
-                        target_block));
+                        target_block
+                    ));
                 }
                 if src_id != src.site.id {
-                    return Err(constraint_violation!(
+                    return Err(internal_error!(
                         "CopyState {} for copying {} to {} has incompatible source {} instead of {}",
                         dst.site.id,
                         src.site.deployment,
@@ -159,31 +155,44 @@ impl CopyState {
                         src.site.id
                     ));
                 }
-                Self::load(conn, src, dst, target_block)
+                Self::load(conn, primary, src, dst, target_block).await
             }
-            None => Self::create(conn, src, dst, target_block),
+            None => Self::create(conn, primary.cheap_clone(), src, dst, target_block).await,
         }?;
 
         Ok(state)
     }
 
-    fn load(
-        conn: &PgConnection,
+    async fn load(
+        conn: &mut AsyncPgConnection,
+        primary: Primary,
         src: Arc<Layout>,
         dst: Arc<Layout>,
         target_block: BlockPtr,
     ) -> Result<CopyState, StoreError> {
-        let tables = TableState::load(conn, src.as_ref(), dst.as_ref())?;
+        let tables = TableState::load(
+            conn,
+            primary,
+            src.as_ref(),
+            dst.as_ref(),
+            target_block.number,
+        )
+        .await?;
+        let (finished, mut unfinished): (Vec<_>, Vec<_>) =
+            tables.into_iter().partition(|table| table.finished());
+        unfinished.sort_by_key(|table| table.dst.object.to_string());
         Ok(CopyState {
             src,
             dst,
             target_block,
-            tables,
+            finished,
+            unfinished,
         })
     }
 
-    fn create(
-        conn: &PgConnection,
+    async fn create(
+        conn: &mut AsyncPgConnection,
+        primary: Primary,
         src: Arc<Layout>,
         dst: Arc<Layout>,
         target_block: BlockPtr,
@@ -198,46 +207,48 @@ impl CopyState {
                 cs::target_block_hash.eq(target_block.hash_slice()),
                 cs::target_block_number.eq(target_block.number),
             ))
-            .execute(conn)?;
-
-        let mut tables: Vec<_> = dst
-            .tables
-            .values()
-            .filter_map(|dst_table| {
-                src.table_for_entity(&dst_table.object)
-                    .ok()
-                    .map(|src_table| {
-                        TableState::init(
-                            conn,
-                            dst.site.clone(),
-                            src_table.clone(),
-                            dst_table.clone(),
-                            &target_block,
-                        )
-                    })
-            })
-            .collect::<Result<_, _>>()?;
-        tables.sort_by_key(|table| table.batch.dst.object.to_string());
+            .execute(conn)
+            .await?;
+
+        let mut unfinished = Vec::new();
+        for dst_table in dst.tables.values() {
+            if let Ok(src_table) = src.table_for_entity(&dst_table.object) {
+                unfinished.push(
+                    TableState::init(
+                        conn,
+                        primary.cheap_clone(),
+                        dst.site.clone(),
+                        &src,
+                        src_table.clone(),
+                        dst_table.clone(),
+                        &target_block,
+                    )
+                    .await?,
+                );
+            }
+        }
+        unfinished.sort_by_key(|table| table.dst.object.to_string());
 
-        let values = tables
+        let values = unfinished
             .iter()
             .map(|table| {
                 (
-                    cts::entity_type.eq(table.batch.dst.object.as_str()),
+                    cts::entity_type.eq(table.dst.object.as_str()),
                     cts::dst.eq(dst.site.id),
-                    cts::next_vid.eq(table.batch.next_vid),
-                    cts::target_vid.eq(table.batch.target_vid),
-                    cts::batch_size.eq(table.batch.batch_size.size),
+                    cts::next_vid.eq(table.batcher.next_vid()),
+                    cts::target_vid.eq(table.batcher.target_vid()),
+                    cts::batch_size.eq(table.batcher.batch_size() as i64),
                 )
             })
             .collect::<Vec<_>>();
-        insert_into(cts::table).values(values).execute(conn)?;
+        insert_into(cts::table).values(values).execute(conn).await?;
 
         Ok(CopyState {
             src,
             dst,
             target_block,
-            tables,
+            finished: Vec::new(),
+            unfinished,
         })
     }
 
@@ -245,12 +256,13 @@ impl CopyState {
         self.dst.site.shard != self.src.site.shard
     }
 
-    fn finished(&self, conn: &PgConnection) -> Result<(), StoreError> {
+    async fn finished(&self, conn: &mut AsyncPgConnection) -> Result<(), StoreError> {
         use copy_state as cs;
 
         update(cs::table.filter(cs::dst.eq(self.dst.site.id)))
             .set(cs::finished_at.eq(sql("now()")))
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
 
         // If we imported the schema for `src`, and no other in-progress
         // copy is using it, get rid of it again
@@ -260,14 +272,15 @@ impl CopyState {
                     .filter(cs::src.eq(self.src.site.id))
                     .filter(cs::finished_at.is_null()),
             ))
-            .get_result::<bool>(conn)?;
+            .get_result::<bool>(conn)
+            .await?;
             if !has_active_copies {
                 // This is a foreign schema that nobody is using anymore,
                 // get rid of it. As a safety check (on top of the one that
                 // drop_foreign_schema does), see that we do not have
                 // metadata for `src`
-                if crate::deployment::exists(conn, &self.src.site)? {
-                    return Err(constraint_violation!(
+                if crate::deployment::exists(conn, &self.src.site).await? {
+                    return Err(internal_error!(
                         "we think we are copying {}[{}] across shards from {} to {}, but the \
                         source subgraph is actually in this shard",
                         self.src.site.deployment,
@@ -276,175 +289,127 @@ impl CopyState {
                         self.dst.site.shard
                     ));
                 }
-                crate::catalog::drop_foreign_schema(conn, self.src.site.as_ref())?;
+                crate::catalog::drop_foreign_schema(conn, self.src.site.as_ref()).await?;
             }
         }
         Ok(())
     }
+
+    fn all_tables(&self) -> impl Iterator<Item = &TableState> {
+        self.finished.iter().chain(self.unfinished.iter())
+    }
+
+    /// Create the indexes that were postponed at the start of the
+    /// copy/graft operation: first the ones that existed in the source
+    /// subgraph, then any indexes for new fields that don't exist in the
+    /// source.
+    async fn create_indexes(
+        &self,
+        conn: &mut AsyncPgConnection,
+        index_list: &IndexList,
+    ) -> Result<(), StoreError> {
+        let creat = self.dst.index_creator(false, true);
+        let dst_nsp = self.dst.site.namespace.to_string();
+
+        // Create the indexes that existed in the source subgraph
+        for table in self.all_tables() {
+            let idxs = index_list
+                .indexes_for_table(&table.dst)
+                .filter(|idx| idx.to_postpone())
+                .map(|idx| idx.with_nsp(dst_nsp.clone()))
+                .collect::<Result<Vec<_>, _>>()?;
+
+            creat.execute_many(conn, &idxs).await?;
+        }
+
+        // Create indexes for new fields that don't exist in the source
+        for table in self.all_tables() {
+            let src_columns: HashSet<&str> =
+                table.src.columns.iter().map(|c| c.name.as_str()).collect();
+            let new_idxs: Vec<_> = table
+                .dst
+                .indexes(&self.dst.input_schema)
+                .map_err(|_| internal_error!("failed to generate indexes for copy"))?
+                .into_iter()
+                .filter(|idx| idx.to_postpone() && idx.references_column_not_in(&src_columns))
+                .collect();
+            creat.execute_many(conn, &new_idxs).await?;
+        }
+
+        conn.transaction(async |conn| {
+            deployment::set_postponed_indexes_created(conn, &self.dst.site).await
+        })
+        .await?;
+
+        Ok(())
+    }
 }
 
-pub(crate) fn source(conn: &PgConnection, dst: &Site) -> Result<Option<DeploymentId>, StoreError> {
+pub(crate) async fn source(
+    conn: &mut AsyncPgConnection,
+    dst: &Site,
+) -> Result<Option<DeploymentId>, StoreError> {
     use copy_state as cs;
 
     cs::table
         .filter(cs::dst.eq(dst.id))
         .select(cs::src)
         .get_result::<DeploymentId>(conn)
+        .await
         .optional()
         .map_err(StoreError::from)
 }
 
-/// Track the desired size of a batch in such a way that doing the next
-/// batch gets close to TARGET_DURATION for the time it takes to copy one
-/// batch, but don't step up the size by more than 2x at once
-#[derive(Debug, Queryable)]
-pub(crate) struct AdaptiveBatchSize {
-    pub size: i64,
-}
-
-impl AdaptiveBatchSize {
-    pub fn new(table: &Table) -> Self {
-        let size = if table.columns.iter().any(|col| col.is_list()) {
-            INITIAL_BATCH_SIZE_LIST
-        } else {
-            INITIAL_BATCH_SIZE
-        };
-
-        Self { size }
-    }
-
-    // adjust batch size by trying to extrapolate in such a way that we
-    // get close to TARGET_DURATION for the time it takes to copy one
-    // batch, but don't step up batch_size by more than 2x at once
-    pub fn adapt(&mut self, duration: Duration) {
-        // Avoid division by zero
-        let duration = duration.as_millis().max(1);
-        let new_batch_size = self.size as f64
-            * ENV_VARS.store.batch_target_duration.as_millis() as f64
-            / duration as f64;
-        self.size = (2 * self.size).min(new_batch_size.round() as i64);
-    }
-}
-
-impl ToSql<BigInt, Pg> for AdaptiveBatchSize {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> diesel::serialize::Result {
-        <i64 as ToSql<BigInt, Pg>>::to_sql(&self.size, out)
-    }
-}
-
-impl FromSql<BigInt, Pg> for AdaptiveBatchSize {
-    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
-        let size = <i64 as FromSql<BigInt, Pg>>::from_sql(bytes)?;
-        Ok(AdaptiveBatchSize { size })
-    }
-}
-
 /// A helper to copy entities from one table to another in batches that are
 /// small enough to not interfere with the rest of the operations happening
 /// in the database. The `src` and `dst` table must have the same structure
 /// so that we can copy rows from one to the other with very little
 /// transformation. See `CopyEntityBatchQuery` for the details of what
 /// exactly that means
-pub(crate) struct BatchCopy {
+struct TableState {
+    primary: Primary,
     src: Arc<Table>,
     dst: Arc<Table>,
-    /// The `vid` of the next entity version that we will copy
-    next_vid: i64,
-    /// The last `vid` that should be copied
-    target_vid: i64,
-    batch_size: AdaptiveBatchSize,
-}
-
-impl BatchCopy {
-    pub fn new(src: Arc<Table>, dst: Arc<Table>, first_vid: i64, last_vid: i64) -> Self {
-        let batch_size = AdaptiveBatchSize::new(&dst);
-
-        Self {
-            src,
-            dst,
-            next_vid: first_vid,
-            target_vid: last_vid,
-            batch_size,
-        }
-    }
-
-    /// Copy one batch of entities and update internal state so that the
-    /// next call to `run` will copy the next batch
-    pub fn run(&mut self, conn: &PgConnection) -> Result<Duration, StoreError> {
-        let start = Instant::now();
-
-        // Copy all versions with next_vid <= vid <= next_vid + batch_size - 1,
-        // but do not go over target_vid
-        let last_vid = (self.next_vid + self.batch_size.size - 1).min(self.target_vid);
-        rq::CopyEntityBatchQuery::new(self.dst.as_ref(), &self.src, self.next_vid, last_vid)?
-            .execute(conn)?;
-
-        let duration = start.elapsed();
-
-        // remember how far we got
-        self.next_vid = last_vid + 1;
-
-        self.batch_size.adapt(duration);
-
-        Ok(duration)
-    }
-
-    pub fn finished(&self) -> bool {
-        self.next_vid > self.target_vid
-    }
-}
-
-struct TableState {
-    batch: BatchCopy,
     dst_site: Arc<Site>,
+    batcher: VidBatcher,
     duration_ms: i64,
+    target_block: BlockNumber,
 }
 
 impl TableState {
-    fn init(
-        conn: &PgConnection,
+    async fn init(
+        conn: &mut AsyncPgConnection,
+        primary: Primary,
         dst_site: Arc<Site>,
+        src_layout: &Layout,
         src: Arc<Table>,
         dst: Arc<Table>,
         target_block: &BlockPtr,
     ) -> Result<Self, StoreError> {
-        #[derive(QueryableByName)]
-        struct MaxVid {
-            #[sql_type = "diesel::sql_types::BigInt"]
-            max_vid: i64,
-        }
-
-        let max_block_clause = if src.immutable {
-            "block$ <= $1"
-        } else {
-            "lower(block_range) <= $1"
-        };
-        let target_vid = sql_query(format!(
-            "select coalesce(max(vid), -1) as max_vid from {} where {}",
-            src.qualified_name.as_str(),
-            max_block_clause
-        ))
-        .bind::<Integer, _>(&target_block.number)
-        .load::<MaxVid>(conn)?
-        .first()
-        .map(|v| v.max_vid)
-        .unwrap_or(-1);
-
+        let vid_range = VidRange::for_copy(conn, &src, target_block).await?;
+        let batcher =
+            VidBatcher::load(conn, &src_layout.site.namespace, src.as_ref(), vid_range).await?;
         Ok(Self {
-            batch: BatchCopy::new(src, dst, 0, target_vid),
+            primary,
+            src,
+            dst,
             dst_site,
+            batcher,
             duration_ms: 0,
+            target_block: target_block.number,
         })
     }
 
     fn finished(&self) -> bool {
-        self.batch.finished()
+        self.batcher.finished()
     }
 
-    fn load(
-        conn: &PgConnection,
+    async fn load(
+        conn: &mut AsyncPgConnection,
+        primary: Primary,
         src_layout: &Layout,
         dst_layout: &Layout,
+        target_block: BlockNumber,
     ) -> Result<Vec<TableState>, StoreError> {
         use copy_table_state as cts;
 
@@ -458,7 +423,7 @@ impl TableState {
             layout
                 .table_for_entity(entity_type)
                 .map_err(|e| {
-                    constraint_violation!(
+                    internal_error!(
                         "invalid {} table {} in CopyState {} (table {}): {}",
                         kind,
                         entity_type,
@@ -467,10 +432,11 @@ impl TableState {
                         e
                     )
                 })
-                .map(|table| table.clone())
+                .cloned()
         }
 
-        cts::table
+        let mut states = Vec::new();
+        for (id, entity_type, current_vid, target_vid, size, duration_ms) in cts::table
             .filter(cts::dst.eq(dst_layout.site.id))
             .select((
                 cts::id,
@@ -481,46 +447,46 @@ impl TableState {
                 cts::duration_ms,
             ))
             .order_by(cts::entity_type)
-            .load::<(i32, String, i64, i64, i64, i64)>(conn)?
+            .load::<(i32, String, i64, i64, i64, i64)>(conn)
+            .await?
             .into_iter()
-            .map(
-                |(id, entity_type, current_vid, target_vid, size, duration_ms)| {
-                    let entity_type = src_layout.input_schema.entity_type(&entity_type)?;
-                    let src =
-                        resolve_entity(src_layout, "source", &entity_type, dst_layout.site.id, id);
-                    let dst = resolve_entity(
-                        dst_layout,
-                        "destination",
-                        &entity_type,
-                        dst_layout.site.id,
-                        id,
-                    );
-                    match (src, dst) {
-                        (Ok(src), Ok(dst)) => {
-                            let mut batch = BatchCopy::new(src, dst, current_vid, target_vid);
-                            let batch_size = AdaptiveBatchSize { size };
-
-                            batch.batch_size = batch_size;
-
-                            Ok(TableState {
-                                batch,
-                                dst_site: dst_layout.site.clone(),
-                                duration_ms,
-                            })
-                        }
-                        (Err(e), _) => Err(e),
-                        (_, Err(e)) => Err(e),
-                    }
-                },
+        {
+            let entity_type = src_layout.input_schema.entity_type(&entity_type)?;
+            let src = resolve_entity(src_layout, "source", &entity_type, dst_layout.site.id, id)?;
+            let dst = resolve_entity(
+                dst_layout,
+                "destination",
+                &entity_type,
+                dst_layout.site.id,
+                id,
+            )?;
+            let batcher = VidBatcher::load(
+                conn,
+                &src_layout.site.namespace,
+                &src,
+                VidRange::new(current_vid, target_vid),
             )
-            .collect()
+            .await?
+            .with_batch_size(size as usize);
+
+            let state = TableState {
+                primary: primary.cheap_clone(),
+                src,
+                dst,
+                dst_site: dst_layout.site.clone(),
+                batcher,
+                duration_ms,
+                target_block,
+            };
+            states.push(state);
+        }
+        Ok(states)
     }
 
-    fn record_progress(
+    async fn record_progress(
         &mut self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         elapsed: Duration,
-        first_batch: bool,
     ) -> Result<(), StoreError> {
         use copy_table_state as cts;
 
@@ -528,107 +494,149 @@ impl TableState {
         // 300B years
         self.duration_ms += i64::try_from(elapsed.as_millis()).unwrap_or(0);
 
-        if first_batch {
-            // Reset started_at so that finished_at - started_at is an
-            // accurate indication of how long we worked on a table.
-            update(
-                cts::table
-                    .filter(cts::dst.eq(self.dst_site.id))
-                    .filter(cts::entity_type.eq(self.batch.dst.object.as_str())),
-            )
-            .set(cts::started_at.eq(sql("now()")))
-            .execute(conn)?;
-        }
+        // Reset started_at so that finished_at - started_at is an accurate
+        // indication of how long we worked on a table if we haven't worked
+        // on the table yet.
+        update(
+            cts::table
+                .filter(cts::dst.eq(self.dst_site.id))
+                .filter(cts::entity_type.eq(self.dst.object.as_str()))
+                .filter(cts::duration_ms.eq(0)),
+        )
+        .set(cts::started_at.eq(sql("now()")))
+        .execute(conn)
+        .await?;
         let values = (
-            cts::next_vid.eq(self.batch.next_vid),
-            cts::batch_size.eq(self.batch.batch_size.size),
+            cts::next_vid.eq(self.batcher.next_vid()),
+            cts::batch_size.eq(self.batcher.batch_size() as i64),
             cts::duration_ms.eq(self.duration_ms),
         );
         update(
             cts::table
                 .filter(cts::dst.eq(self.dst_site.id))
-                .filter(cts::entity_type.eq(self.batch.dst.object.as_str())),
+                .filter(cts::entity_type.eq(self.dst.object.as_str())),
         )
         .set(values)
-        .execute(conn)?;
+        .execute(conn)
+        .await?;
         Ok(())
     }
 
-    fn record_finished(&self, conn: &PgConnection) -> Result<(), StoreError> {
+    async fn record_finished(&self, conn: &mut AsyncPgConnection) -> Result<(), StoreError> {
         use copy_table_state as cts;
 
         update(
             cts::table
                 .filter(cts::dst.eq(self.dst_site.id))
-                .filter(cts::entity_type.eq(self.batch.dst.object.as_str())),
+                .filter(cts::entity_type.eq(self.dst.object.as_str())),
         )
         .set(cts::finished_at.eq(sql("now()")))
-        .execute(conn)?;
+        .execute(conn)
+        .await?;
         Ok(())
     }
 
-    fn is_cancelled(&self, conn: &PgConnection) -> Result<bool, StoreError> {
-        use active_copies as ac;
-
+    async fn is_cancelled(&self, conn: &mut AsyncPgConnection) -> Result<bool, StoreError> {
         let dst = self.dst_site.as_ref();
-        let canceled = ac::table
-            .filter(ac::dst.eq(dst.id))
-            .select(ac::cancelled_at.is_not_null())
-            .get_result::<bool>(conn)?;
+        let canceled = self.primary.is_copy_cancelled(dst).await?;
         if canceled {
             use copy_state as cs;
 
             update(cs::table.filter(cs::dst.eq(dst.id)))
                 .set(cs::cancelled_at.eq(sql("now()")))
-                .execute(conn)?;
+                .execute(conn)
+                .await?;
         }
         Ok(canceled)
     }
 
-    fn copy_batch(&mut self, conn: &PgConnection) -> Result<Status, StoreError> {
-        let first_batch = self.batch.next_vid == 0;
+    async fn copy_batch(&mut self, conn: &mut AsyncPgConnection) -> Result<Status, StoreError> {
+        let (duration, count): (_, Option<i32>) = self
+            .batcher
+            .step(async |start: i64, end: i64| {
+                let count = rq::CopyEntityBatchQuery::new(
+                    self.dst.as_ref(),
+                    &self.src,
+                    start,
+                    end,
+                    self.target_block,
+                )?
+                .count_current()
+                .get_result::<i64>(conn)
+                .await
+                .optional()?;
+                Ok(count.unwrap_or(0) as i32)
+            })
+            .await?;
+
+        let count = count.unwrap_or(0);
 
-        let duration = self.batch.run(conn)?;
+        deployment::update_entity_count(conn, &self.dst_site, count).await?;
 
-        self.record_progress(conn, duration, first_batch)?;
+        self.record_progress(conn, duration).await?;
 
         if self.finished() {
-            self.record_finished(conn)?;
+            self.record_finished(conn).await?;
         }
 
         Ok(Status::Finished)
     }
+
+    async fn set_batch_size(
+        &mut self,
+        conn: &mut AsyncPgConnection,
+        size: usize,
+    ) -> Result<(), StoreError> {
+        use copy_table_state as cts;
+
+        self.batcher.set_batch_size(size);
+
+        update(
+            cts::table
+                .filter(cts::dst.eq(self.dst_site.id))
+                .filter(cts::entity_type.eq(self.dst.object.as_str())),
+        )
+        .set(cts::batch_size.eq(self.batcher.batch_size() as i64))
+        .execute(conn)
+        .await?;
+
+        Ok(())
+    }
 }
 
-// A helper for logging progress while data is being copied
-struct CopyProgress<'a> {
-    logger: &'a Logger,
-    last_log: Instant,
+// A helper for logging progress while data is being copied and
+// communicating across all copy workers
+struct CopyProgress {
+    logger: Logger,
+    last_log: Arc<Mutex<Instant>>,
     src: Arc<Site>,
     dst: Arc<Site>,
-    current_vid: i64,
+    /// The sum of all `target_vid` of tables that have finished
+    current_vid: AtomicI64,
     target_vid: i64,
+    cancelled: AtomicBool,
 }
 
-impl<'a> CopyProgress<'a> {
-    fn new(logger: &'a Logger, state: &CopyState) -> Self {
+impl CopyProgress {
+    fn new(logger: Logger, state: &CopyState) -> Self {
         let target_vid: i64 = state
-            .tables
-            .iter()
-            .map(|table| table.batch.target_vid)
+            .all_tables()
+            .map(|table| table.batcher.target_vid())
             .sum();
         let current_vid = state
-            .tables
-            .iter()
-            .map(|table| table.batch.next_vid.min(table.batch.target_vid))
+            .all_tables()
+            .filter(|table| table.finished())
+            .map(|table| table.batcher.next_vid())
             .sum();
+        let current_vid = AtomicI64::new(current_vid);
         Self {
             logger,
-            last_log: Instant::now(),
+            last_log: Arc::new(Mutex::new(Instant::now())),
             src: state.src.site.clone(),
             dst: state.dst.site.clone(),
             current_vid,
             target_vid,
+            cancelled: AtomicBool::new(false),
         }
     }
 
@@ -643,6 +651,16 @@ impl<'a> CopyProgress<'a> {
         );
     }
 
+    fn start_table(&self, table: &TableState) {
+        info!(
+            self.logger,
+            "Starting to copy `{}` entities from {} to {}",
+            table.dst.object,
+            table.src.qualified_name,
+            table.dst.qualified_name
+        );
+    }
+
     fn progress_pct(current_vid: i64, target_vid: i64) -> f64 {
         // When a step is done, current_vid == target_vid + 1; don't report
         // more than 100% completion
@@ -653,23 +671,38 @@ impl<'a> CopyProgress<'a> {
         }
     }
 
-    fn update(&mut self, batch: &BatchCopy) {
-        if self.last_log.elapsed() > LOG_INTERVAL {
+    fn update(&self, entity_type: &EntityType, batcher: &VidBatcher) {
+        let mut last_log = self.last_log.lock().unwrap_or_else(|err| {
+            // Better to clear the poison error and skip a log message than
+            // crash for no important reason
+            warn!(
+                self.logger,
+                "Lock for progress locking was poisoned, skipping a log message"
+            );
+            let mut last_log = err.into_inner();
+            *last_log = Instant::now();
+            self.last_log.clear_poison();
+            last_log
+        });
+        if last_log.elapsed() > LOG_INTERVAL {
+            let total_current_vid =
+                AtomicI64::load(&self.current_vid, Ordering::SeqCst) + batcher.next_vid();
             info!(
                 self.logger,
                 "Copied {:.2}% of `{}` entities ({}/{} entity versions), {:.2}% of overall data",
-                Self::progress_pct(batch.next_vid, batch.target_vid),
-                batch.dst.object,
-                batch.next_vid,
-                batch.target_vid,
-                Self::progress_pct(self.current_vid + batch.next_vid, self.target_vid)
+                Self::progress_pct(batcher.next_vid(), batcher.target_vid()),
+                entity_type,
+                batcher.next_vid(),
+                batcher.target_vid(),
+                Self::progress_pct(total_current_vid, self.target_vid)
             );
-            self.last_log = Instant::now();
+            *last_log = Instant::now();
         }
     }
 
-    fn table_finished(&mut self, batch: &BatchCopy) {
-        self.current_vid += batch.next_vid;
+    fn table_finished(&self, batcher: &VidBatcher) {
+        self.current_vid
+            .fetch_add(batcher.next_vid(), Ordering::SeqCst);
     }
 
     fn finished(&self) {
@@ -678,6 +711,264 @@ impl<'a> CopyProgress<'a> {
             "Finished copying data into {}[{}]", self.dst.deployment, self.dst.namespace
         );
     }
+
+    fn cancel(&self) {
+        self.cancelled.store(true, Ordering::SeqCst);
+    }
+
+    fn is_cancelled(&self) -> bool {
+        AtomicBool::load(&self.cancelled, Ordering::SeqCst)
+    }
+}
+
+enum WorkerResult {
+    Ok(Box<CopyTableWorker>),
+    Err(StoreError),
+    Wake,
+}
+
+impl From<Result<CopyTableWorker, StoreError>> for WorkerResult {
+    fn from(result: Result<CopyTableWorker, StoreError>) -> Self {
+        match result {
+            Ok(worker) => WorkerResult::Ok(Box::new(worker)),
+            Err(e) => WorkerResult::Err(e),
+        }
+    }
+}
+
+/// We pass connections back and forth between the control loop and various
+/// workers. We need to make sure that we end up with the connection that
+/// was used to acquire the copy lock in the right place so we can release
+/// the copy lock which is only possible with the connection that acquired
+/// it.
+///
+/// This struct helps us with that. It wraps a connection and tracks whether
+/// the connection was used to acquire the copy lock
+struct LockTrackingConnection {
+    inner: AsyncPgConnection,
+    has_lock: bool,
+}
+
+impl LockTrackingConnection {
+    fn new(inner: AsyncPgConnection) -> Self {
+        Self {
+            inner,
+            has_lock: false,
+        }
+    }
+
+    /// Put `self` into `other` if `self` has the lock.
+    fn extract(self, other: &mut Option<Self>) {
+        if self.has_lock {
+            *other = Some(self);
+        }
+    }
+
+    async fn lock(&mut self, logger: &Logger, dst: &Site) -> Result<(), StoreError> {
+        if self.has_lock {
+            warn!(logger, "already acquired copy lock for {}", dst);
+            return Ok(());
+        }
+        advisory_lock::lock_copying(&mut self.inner, dst).await?;
+        self.has_lock = true;
+        Ok(())
+    }
+
+    async fn unlock(&mut self, logger: &Logger, dst: &Site) -> Result<(), StoreError> {
+        if !self.has_lock {
+            error!(
+                logger,
+                "tried to release copy lock for {} even though we are not the owner", dst
+            );
+            return Ok(());
+        }
+        advisory_lock::unlock_copying(&mut self.inner, dst).await?;
+        self.has_lock = false;
+        Ok(())
+    }
+}
+
+/// A helper to run copying of one table. We need to thread `conn` and
+/// `table` from the control loop to the background worker and back again to
+/// the control loop. This worker facilitates that
+struct CopyTableWorker {
+    conn: LockTrackingConnection,
+    table: TableState,
+    result: Result<Status, StoreError>,
+}
+
+impl CopyTableWorker {
+    fn new(conn: LockTrackingConnection, table: TableState) -> Self {
+        Self {
+            conn,
+            table,
+            result: Ok(Status::Cancelled),
+        }
+    }
+
+    async fn run(mut self, logger: Logger, progress: Arc<CopyProgress>) -> WorkerResult {
+        let object = self.table.dst.object.cheap_clone();
+        graph::spawn_blocking_allow_panic(move || {
+            self.result = graph::block_on(self.run_inner(logger, &progress));
+            self
+        })
+        .await
+        .map_err(|e| internal_error!("copy worker for {} panicked: {}", object, e))
+        .into()
+    }
+
+    async fn run_inner(
+        &mut self,
+        logger: Logger,
+        progress: &CopyProgress,
+    ) -> Result<Status, StoreError> {
+        use Status::*;
+
+        let conn = &mut self.conn.inner;
+        progress.start_table(&self.table);
+        while !self.table.finished() {
+            // It is important that this check happens outside the write
+            // transaction so that we do not hold on to locks acquired
+            // by the check
+            if self.table.is_cancelled(conn).await? || progress.is_cancelled() {
+                progress.cancel();
+                return Ok(Cancelled);
+            }
+
+            // Pause copying if replication is lagging behind to avoid
+            // overloading replicas
+            let mut lag = catalog::replication_lag(conn).await?;
+            if lag > MAX_REPLICATION_LAG {
+                loop {
+                    info!(logger,
+                             "Replicas are lagging too much; pausing copying for {}s to allow them to catch up",
+                             REPLICATION_SLEEP.as_secs();
+                             "lag_s" => lag.as_secs());
+                    std::thread::sleep(REPLICATION_SLEEP);
+                    lag = catalog::replication_lag(conn).await?;
+                    if lag <= ACCEPTABLE_REPLICATION_LAG {
+                        break;
+                    }
+                }
+            }
+
+            let status = {
+                loop {
+                    if progress.is_cancelled() {
+                        break Cancelled;
+                    }
+
+                    match conn
+                        .transaction(async |conn| {
+                            if let Some(timeout) = BATCH_STATEMENT_TIMEOUT.as_ref() {
+                                conn.batch_execute(timeout).await?;
+                            }
+                            self.table.copy_batch(conn).await
+                        })
+                        .await
+                    {
+                        Ok(status) => {
+                            break status;
+                        }
+                        Err(StoreError::StatementTimeout) => {
+                            let timeout = ENV_VARS
+                                .store
+                                .batch_timeout
+                                .map(|t| t.as_secs().to_string())
+                                .unwrap_or_else(|| "unlimted".to_string());
+                            warn!(
+                                logger,
+                                "Current batch timed out. Retrying with a smaller batch size.";
+                                "timeout_s" => timeout,
+                                "table" => self.table.dst.qualified_name.as_str(),
+                                "current_vid" => self.table.batcher.next_vid(),
+                                "current_batch_size" => self.table.batcher.batch_size(),
+                            );
+                        }
+                        Err(e) => {
+                            return Err(e);
+                        }
+                    }
+                    // We hit a timeout. Reset the batch size to 1.
+                    // That's small enough that we will make _some_
+                    // progress, assuming the timeout is set to a
+                    // reasonable value (several minutes)
+                    //
+                    // Our estimation of batch sizes is generally good
+                    // and stays within the prescribed bounds, but there
+                    // are cases where proper estimation of the batch
+                    // size is nearly impossible since the size of the
+                    // rows in the table jumps sharply at some point
+                    // that is hard to predict. This mechanism ensures
+                    // that if our estimation is wrong, the consequences
+                    // aren't too severe.
+                    conn.transaction(async |conn| self.table.set_batch_size(conn, 1).await)
+                        .await?;
+                }
+            };
+
+            if status == Cancelled {
+                progress.cancel();
+                return Ok(Cancelled);
+            }
+            progress.update(&self.table.dst.object, &self.table.batcher);
+        }
+        progress.table_finished(&self.table.batcher);
+        Ok(Finished)
+    }
+}
+
+type WorkerFuture = Pin<Box<dyn Future<Output = WorkerResult> + Send>>;
+
+/// A helper to manage the workers that are copying data. Besides the actual
+/// workers it also keeps a worker that wakes us up periodically to give us
+/// a chance to create more workers if there are database connections
+/// available
+struct Workers {
+    /// The list of workers that are currently running. This will always
+    /// include a future that wakes us up periodically
+    futures: Vec<WorkerFuture>,
+}
+
+impl Workers {
+    fn new() -> Self {
+        Self {
+            futures: vec![Self::waker()],
+        }
+    }
+
+    fn add(&mut self, worker: WorkerFuture) {
+        self.futures.push(worker);
+    }
+
+    fn has_work(&self) -> bool {
+        self.futures.len() > 1
+    }
+
+    async fn select(&mut self) -> WorkerResult {
+        use WorkerResult::*;
+
+        let futures = std::mem::take(&mut self.futures);
+        let (result, _idx, remaining) = select_all(futures).await;
+        self.futures = remaining;
+        match result {
+            Ok(_) | Err(_) => { /* nothing to do */ }
+            Wake => {
+                self.futures.push(Self::waker());
+            }
+        }
+        result
+    }
+
+    fn waker() -> WorkerFuture {
+        let sleep = tokio::time::sleep(ENV_VARS.store.batch_target_duration);
+        Box::pin(sleep.map(|()| WorkerResult::Wake))
+    }
+
+    /// Return the number of workers that are not the waker
+    fn len(&self) -> usize {
+        self.futures.len() - 1
+    }
 }
 
 /// A helper for copying subgraphs
@@ -685,12 +976,25 @@ pub struct Connection {
     /// The connection pool for the shard that will contain the destination
     /// of the copy
     logger: Logger,
-    conn: PooledConnection<ConnectionManager<PgConnection>>,
+    /// We always have one database connection to make sure that copy jobs,
+    /// once started, can eventually finished so that we don't have
+    /// different copy jobs that are all half done and have to wait for
+    /// other jobs to finish
+    ///
+    /// This is an `Option` because we need to take this connection out of
+    /// `self` at some point to spawn a background task to copy an
+    /// individual table. Except for that case, this will always be
+    /// `Some(..)`. Most code shouldn't access `self.conn` directly, but use
+    /// `self.transaction`
+    conn: Option<LockTrackingConnection>,
+    pool: ConnectionPool,
+    primary: Primary,
+    workers: usize,
     src: Arc<Layout>,
     dst: Arc<Layout>,
     target_block: BlockPtr,
-    src_manifest_idx_and_name: Vec<(i32, String)>,
-    dst_manifest_idx_and_name: Vec<(i32, String)>,
+    src_manifest_idx_and_name: Arc<Vec<(i32, String)>>,
+    dst_manifest_idx_and_name: Arc<Vec<(i32, String)>>,
 }
 
 impl Connection {
@@ -700,8 +1004,9 @@ impl Connection {
     /// will block until it was able to get a fdw connection. The overall
     /// effect is that new copy requests will not start until a connection
     /// is available.
-    pub fn new(
+    pub async fn new(
         logger: &Logger,
+        primary: Primary,
         pool: ConnectionPool,
         src: Arc<Layout>,
         dst: Arc<Layout>,
@@ -712,7 +1017,7 @@ impl Connection {
         let logger = logger.new(o!("dst" => dst.site.namespace.to_string()));
 
         if src.site.schema_version != dst.site.schema_version {
-            return Err(StoreError::ConstraintViolation(format!(
+            return Err(StoreError::InternalError(format!(
                 "attempted to copy between different schema versions, \
                  source version is {} but destination version is {}",
                 src.site.schema_version, dst.site.schema_version
@@ -720,16 +1025,24 @@ impl Connection {
         }
 
         let mut last_log = Instant::now();
-        let conn = pool.get_fdw(&logger, || {
-            if last_log.elapsed() > LOG_INTERVAL {
-                info!(&logger, "waiting for other copy operations to finish");
-                last_log = Instant::now();
-            }
-            false
-        })?;
+        let conn = pool
+            .get_fdw(&logger, || {
+                if last_log.elapsed() > LOG_INTERVAL {
+                    info!(&logger, "waiting for other copy operations to finish");
+                    last_log = Instant::now();
+                }
+                false
+            })
+            .await?;
+        let src_manifest_idx_and_name = Arc::new(src_manifest_idx_and_name);
+        let dst_manifest_idx_and_name = Arc::new(dst_manifest_idx_and_name);
+        let conn = Some(LockTrackingConnection::new(conn));
         Ok(Self {
             logger,
             conn,
+            pool,
+            primary,
+            workers: ENV_VARS.store.batch_workers,
             src,
             dst,
             target_block,
@@ -738,77 +1051,243 @@ impl Connection {
         })
     }
 
-    fn transaction<T, F>(&self, f: F) -> Result<T, StoreError>
+    /// Run `callback` in a transaction using the connection in `self.conn`.
+    /// This will return an error if `self.conn` is `None`, which happens
+    /// while a background task is copying a table.
+    fn get_conn(&mut self) -> Result<&mut AsyncPgConnection, StoreError> {
+        let Some(conn) = self.conn.as_mut() else {
+            return Err(internal_error!(
+                "copy connection has been handed to background task but not returned yet (get_conn)"
+            ));
+        };
+        Ok(&mut conn.inner)
+    }
+
+    /// Run `callback` in a transaction using the connection in `self.conn`.
+    /// This will return an error if `self.conn` is `None`, which happens
+    /// while a background task is copying a table.
+    fn transaction<'a, 'conn, R, F>(
+        &'conn mut self,
+        callback: F,
+    ) -> Result<impl Future<Output = Result<R, StoreError>> + Send + 'conn, StoreError>
     where
-        F: FnOnce(&PgConnection) -> Result<T, StoreError>,
+        F: TxnCallback<R, StoreError> + 'a,
+        R: Send + 'a,
+        'a: 'conn,
     {
-        self.conn.transaction(|| f(&self.conn))
+        let conn = self.get_conn()?;
+        Ok(conn.transaction(callback))
     }
 
-    fn copy_private_data_sources(&self, state: &CopyState) -> Result<(), StoreError> {
+    /// Copy private data sources if the source uses a schema version that
+    /// has a private data sources table. The copying is done in its own
+    /// transaction.
+    async fn copy_private_data_sources(&mut self, state: &CopyState) -> Result<(), StoreError> {
+        let src_manifest_idx_and_name = self.src_manifest_idx_and_name.cheap_clone();
+        let dst_manifest_idx_and_name = self.dst_manifest_idx_and_name.cheap_clone();
         if state.src.site.schema_version.private_data_sources() {
-            DataSourcesTable::new(state.src.site.namespace.clone()).copy_to(
-                &self.conn,
-                &DataSourcesTable::new(state.dst.site.namespace.clone()),
-                state.target_block.number,
-                &self.src_manifest_idx_and_name,
-                &self.dst_manifest_idx_and_name,
-            )?;
+            let src_ns = state.src.site.namespace.clone();
+            let dst_ns = state.dst.site.namespace.clone();
+            let target_block = state.target_block.number;
+            self.transaction(async move |conn| {
+                DataSourcesTable::new(src_ns)
+                    .copy_to(
+                        conn,
+                        &DataSourcesTable::new(dst_ns),
+                        target_block,
+                        &src_manifest_idx_and_name,
+                        &dst_manifest_idx_and_name,
+                    )
+                    .await
+            })?
+            .await?;
         }
         Ok(())
     }
 
-    pub fn copy_data_internal(&self) -> Result<Status, StoreError> {
-        let mut state = self.transaction(|conn| {
-            CopyState::new(
-                conn,
-                self.src.clone(),
-                self.dst.clone(),
-                self.target_block.clone(),
-            )
-        })?;
+    /// Create a worker using the connection in `self.conn`. This may return
+    /// `None` if there are no more tables that need to be copied. It is an
+    /// error to call this if `self.conn` is `None`
+    fn default_worker(
+        &mut self,
+        state: &mut CopyState,
+        progress: &Arc<CopyProgress>,
+    ) -> Option<WorkerFuture> {
+        let conn = self.conn.take()?;
+        let Some(table) = state.unfinished.pop() else {
+            self.conn = Some(conn);
+            return None;
+        };
 
-        let mut progress = CopyProgress::new(&self.logger, &state);
+        let worker = CopyTableWorker::new(conn, table);
+        Some(Box::pin(
+            worker.run(self.logger.cheap_clone(), progress.cheap_clone()),
+        ))
+    }
+
+    /// Opportunistically create an extra worker if we have more tables to
+    /// copy and there are idle fdw connections. If there are no more tables
+    /// or no idle connections, this will return `None`.
+    async fn extra_worker(
+        &mut self,
+        state: &mut CopyState,
+        progress: &Arc<CopyProgress>,
+    ) -> Option<WorkerFuture> {
+        // It's important that we get the connection before the table since
+        // we remove the table from the state and could drop it otherwise
+        let conn = self
+            .pool
+            .try_get_fdw(&self.logger, ENV_VARS.store.batch_worker_wait)
+            .await?;
+        let table = state.unfinished.pop()?;
+        let conn = LockTrackingConnection::new(conn);
+
+        let worker = CopyTableWorker::new(conn, table);
+        Some(Box::pin(
+            worker.run(self.logger.cheap_clone(), progress.cheap_clone()),
+        ))
+    }
+
+    /// Check that we can make progress, i.e., that we have at least one
+    /// worker that copies as long as there are unfinished tables. This is a
+    /// safety check to guard against `copy_data_internal` looping forever
+    /// because of some internal inconsistency
+    fn assert_progress(&self, num_workers: usize, state: &CopyState) -> Result<(), StoreError> {
+        if num_workers == 0 && !state.unfinished.is_empty() {
+            // Something bad happened. We should have at least one
+            // worker if there are still tables to copy
+            if self.conn.is_none() {
+                return Err(internal_error!(
+                    "copy connection has been handed to background task but not returned yet (copy_data_internal)"
+                ));
+            } else {
+                return Err(internal_error!("no workers left but still tables to copy"));
+            }
+        }
+        Ok(())
+    }
+
+    /// Wait for all workers to finish. This is called when we a worker has
+    /// failed with an error that forces us to abort copying
+    async fn cancel_workers(&mut self, progress: Arc<CopyProgress>, mut workers: Workers) {
+        progress.cancel();
+        error!(
+            self.logger,
+            "copying encountered an error; waiting for all workers to finish"
+        );
+        while workers.has_work() {
+            use WorkerResult::*;
+            let result = workers.select().await;
+            match result {
+                Ok(worker) => {
+                    worker.conn.extract(&mut self.conn);
+                }
+                Err(e) => {
+                    /* Ignore; we had an error previously */
+                    error!(self.logger, "copy worker panicked: {}", e);
+                }
+                Wake => { /* Ignore; this is just a waker */ }
+            }
+        }
+    }
+
+    async fn copy_data_internal(&mut self, index_list: IndexList) -> Result<Status, StoreError> {
+        let src = self.src.clone();
+        let dst = self.dst.clone();
+        let target_block = self.target_block.clone();
+        let primary = self.primary.cheap_clone();
+        let mut state = self
+            .transaction(async move |conn| {
+                CopyState::new(conn, primary, src, dst, target_block).await
+            })?
+            .await?;
+
+        let progress = Arc::new(CopyProgress::new(self.logger.cheap_clone(), &state));
         progress.start();
 
-        for table in state.tables.iter_mut().filter(|table| !table.finished()) {
-            while !table.finished() {
-                // It is important that this check happens outside the write
-                // transaction so that we do not hold on to locks acquired
-                // by the check
-                if table.is_cancelled(&self.conn)? {
-                    return Ok(Status::Cancelled);
+        // Run as many copy jobs as we can in parallel, up to `self.workers`
+        // many. We can always start at least one worker because of the
+        // connection in `self.conn`. If the fdw pool has idle connections
+        // and there are more tables to be copied, we can start more
+        // workers, up to `self.workers` many
+        //
+        // The loop has to be very careful about terminating early so that
+        // we do not ever leave the loop with `self.conn == None`
+        let mut workers = Workers::new();
+        while !state.unfinished.is_empty() || workers.has_work() {
+            // We usually add at least one job here, except if we are out of
+            // tables to copy. In that case, we go through the `while` loop
+            // every time one of the tables we are currently copying
+            // finishes
+            if let Some(worker) = self.default_worker(&mut state, &progress) {
+                workers.add(worker);
+            }
+            loop {
+                if workers.len() >= self.workers {
+                    break;
                 }
+                let Some(worker) = self.extra_worker(&mut state, &progress).await else {
+                    break;
+                };
+                workers.add(worker);
+            }
 
-                // Pause copying if replication is lagging behind to avoid
-                // overloading replicas
-                let mut lag = catalog::replication_lag(&self.conn)?;
-                if lag > MAX_REPLICATION_LAG {
-                    loop {
-                        info!(&self.logger,
-                             "Replicas are lagging too much; pausing copying for {}s to allow them to catch up",
-                             REPLICATION_SLEEP.as_secs();
-                             "lag_s" => lag.as_secs());
-                        std::thread::sleep(REPLICATION_SLEEP);
-                        lag = catalog::replication_lag(&self.conn)?;
-                        if lag <= ACCEPTABLE_REPLICATION_LAG {
-                            break;
+            self.assert_progress(workers.len(), &state)?;
+            let result = workers.select().await;
+
+            // Analyze `result` and take another trip through the loop if
+            // everything is ok; wait for pending workers and return if
+            // there was an error or if copying was cancelled.
+            use WorkerResult as W;
+            match result {
+                W::Err(e) => {
+                    // This is a panic in the background task. We need to
+                    // cancel all other tasks and return the error
+                    error!(self.logger, "copy worker panicked: {}", e);
+                    self.cancel_workers(progress, workers).await;
+                    return Err(e);
+                }
+                W::Ok(worker) => {
+                    // Put the connection back into self.conn so that we can use it
+                    // in the next iteration.
+                    worker.conn.extract(&mut self.conn);
+
+                    match (worker.result, progress.is_cancelled()) {
+                        (Ok(Status::Finished), false) => {
+                            // The worker finished successfully, and nothing was
+                            // cancelled; take another trip through the loop
+                            state.finished.push(worker.table);
+                        }
+                        (Ok(Status::Finished), true) => {
+                            state.finished.push(worker.table);
+                            self.cancel_workers(progress, workers).await;
+                            return Ok(Status::Cancelled);
+                        }
+                        (Ok(Status::Cancelled), _) => {
+                            self.cancel_workers(progress, workers).await;
+                            return Ok(Status::Cancelled);
+                        }
+                        (Err(e), _) => {
+                            error!(self.logger, "copy worker had an error: {}", e);
+                            self.cancel_workers(progress, workers).await;
+                            return Err(e);
                         }
                     }
                 }
-
-                let status = self.transaction(|conn| table.copy_batch(conn))?;
-                if status == Status::Cancelled {
-                    return Ok(status);
+                W::Wake => {
+                    // nothing to do, just try to create more workers by
+                    // going through the loop again
                 }
-                progress.update(&table.batch);
-            }
-            progress.table_finished(&table.batch);
+            };
         }
+        debug_assert!(self.conn.is_some());
+
+        state.create_indexes(self.get_conn()?, &index_list).await?;
 
-        self.copy_private_data_sources(&state)?;
+        self.copy_private_data_sources(&state).await?;
 
-        self.transaction(|conn| state.finished(conn))?;
+        self.transaction(async |conn| state.finished(conn).await)?
+            .await?;
         progress.finished();
 
         Ok(Status::Finished)
@@ -820,6 +1299,8 @@ impl Connection {
     /// block is guaranteed to not be subject to chain reorgs. All data up
     /// to and including `target_block` will be copied.
     ///
+    /// The parameter index_list is a list of indexes that exist on the `src`.
+    ///
     /// The copy logic makes heavy use of the fact that the `vid` and
     /// `block_range` of entity versions are related since for two entity
     /// versions `v1` and `v2` such that `v1.vid <= v2.vid`, we know that
@@ -828,7 +1309,7 @@ impl Connection {
     /// lower(v1.block_range) => v2.vid > v1.vid` and we can therefore stop
     /// the copying of each table as soon as we hit `max_vid = max { v.vid |
     /// lower(v.block_range) <= target_block.number }`.
-    pub fn copy_data(&self) -> Result<Status, StoreError> {
+    pub async fn copy_data(mut self, index_list: IndexList) -> Result<Status, StoreError> {
         // We require sole access to the destination site, and that we get a
         // consistent view of what has been copied so far. In general, that
         // is always true. It can happen though that this function runs when
@@ -841,9 +1322,31 @@ impl Connection {
             &self.logger,
             "Obtaining copy lock (this might take a long time if another process is still copying)"
         );
-        advisory_lock::lock_copying(&self.conn, self.dst.site.as_ref())?;
-        let res = self.copy_data_internal();
-        advisory_lock::unlock_copying(&self.conn, self.dst.site.as_ref())?;
+
+        let dst_site = self.dst.site.cheap_clone();
+        let Some(conn) = self.conn.as_mut() else {
+            return Err(internal_error!("copy connection went missing (copy_data)"));
+        };
+        conn.lock(&self.logger, &dst_site).await?;
+
+        let res = self.copy_data_internal(index_list).await;
+
+        match self.conn.as_mut() {
+            None => {
+                // A background worker panicked and left us without our
+                // dedicated connection; we would need to get that
+                // connection to unlock the advisory lock. We can't do that,
+                // so we just log an error
+                warn!(
+                    self.logger,
+                    "can't unlock copy lock since the default worker panicked; lock will linger until session ends"
+                );
+            }
+            Some(conn) => {
+                conn.unlock(&self.logger, &dst_site).await?;
+            }
+        }
+
         if matches!(res, Ok(Status::Cancelled)) {
             warn!(&self.logger, "Copying was cancelled and is incomplete");
         }
diff --git a/store/postgres/src/deployment.rs b/store/postgres/src/deployment.rs
index 6593491bb6e..76cde305bcb 100644
--- a/store/postgres/src/deployment.rs
+++ b/store/postgres/src/deployment.rs
@@ -1,45 +1,44 @@
 //! Utilities for dealing with deployment metadata. Any connection passed
 //! into these methods must be for the shard that holds the actual
 //! deployment data and metadata
-use crate::{advisory_lock, detail::GraphNodeVersion, primary::DeploymentId};
+use crate::{AsyncPgConnection, advisory_lock, detail::GraphNodeVersion, primary::DeploymentId};
 use diesel::{
-    connection::SimpleConnection,
-    dsl::{count, delete, insert_into, select, sql, update},
-    sql_types::Integer,
+    dsl::{count, delete, insert_into, now, select, sql, update},
+    sql_types::{Bool, Integer},
 };
-use diesel::{expression::SqlLiteral, pg::PgConnection, sql_types::Numeric};
 use diesel::{
-    prelude::{ExpressionMethods, OptionalExtension, QueryDsl, RunQueryDsl},
+    prelude::{ExpressionMethods, OptionalExtension, QueryDsl},
     sql_query,
     sql_types::{Nullable, Text},
 };
+use diesel_async::{RunQueryDsl, SimpleAsyncConnection};
+use graph::prelude::alloy::primitives::B256;
 use graph::{
-    blockchain::block_stream::FirehoseCursor, data::subgraph::schema::SubgraphError,
+    blockchain::block_stream::FirehoseCursor,
+    data::subgraph::schema::SubgraphError,
+    env::ENV_VARS,
     schema::EntityType,
+    slog::{Logger, debug},
 };
+use graph::{components::store::StoreResult, semver::Version};
 use graph::{
-    data::subgraph::{
-        schema::{DeploymentCreate, SubgraphManifestEntity},
-        SubgraphFeature,
-    },
+    data::subgraph::schema::{DeploymentCreate, SubgraphManifestEntity},
     util::backoff::ExponentialBackoff,
 };
 use graph::{
-    prelude::{
-        anyhow, bigdecimal::ToPrimitive, hex, web3::types::H256, BigDecimal, BlockNumber, BlockPtr,
-        DeploymentHash, DeploymentState, StoreError,
-    },
+    prelude::{BlockNumber, BlockPtr, DeploymentHash, DeploymentState, StoreError, anyhow, hex},
     schema::InputSchema,
 };
 use stable_hash_legacy::crypto::SetHasher;
-use std::{collections::BTreeSet, convert::TryFrom, ops::Bound, time::Duration};
-use std::{str::FromStr, sync::Arc};
+use std::sync::Arc;
+use std::{convert::TryFrom, ops::Bound, time::Duration};
 
-use crate::connection_pool::ForeignServer;
+use crate::ForeignServer;
 use crate::{block_range::BLOCK_RANGE_COLUMN, primary::Site};
-use graph::constraint_violation;
+use graph::internal_error;
 
 #[derive(DbEnum, Debug, Clone, Copy)]
+#[PgType = "text"]
 pub enum SubgraphHealth {
     Failed,
     Healthy,
@@ -56,8 +55,8 @@ impl SubgraphHealth {
 
 impl From<SubgraphHealth> for graph::data::subgraph::schema::SubgraphHealth {
     fn from(health: SubgraphHealth) -> Self {
-        use graph::data::subgraph::schema::SubgraphHealth as H;
         use SubgraphHealth as Db;
+        use graph::data::subgraph::schema::SubgraphHealth as H;
 
         match health {
             Db::Failed => H::Failed,
@@ -86,7 +85,7 @@ impl TryFrom<Option<&str>> for OnSync {
             None => Ok(OnSync::None),
             Some("activate") => Ok(OnSync::Activate),
             Some("replace") => Ok(OnSync::Replace),
-            _ => Err(constraint_violation!("illegal value for on_sync: {value}")),
+            _ => Err(internal_error!("illegal value for on_sync: {value}")),
         }
     }
 }
@@ -108,7 +107,7 @@ impl OnSync {
         }
     }
 
-    pub fn to_str(&self) -> &str {
+    pub fn to_str(&self) -> &'static str {
         match self {
             OnSync::None => "none",
             OnSync::Activate => "activate",
@@ -116,7 +115,7 @@ impl OnSync {
         }
     }
 
-    fn to_sql(&self) -> Option<&str> {
+    fn to_sql(self) -> Option<&'static str> {
         match self {
             OnSync::None => None,
             OnSync::Activate | OnSync::Replace => Some(self.to_str()),
@@ -125,28 +124,54 @@ impl OnSync {
 }
 
 table! {
-    subgraphs.subgraph_deployment (id) {
+    /// Deployment metadata that changes on every block
+    subgraphs.head (id) {
         id -> Integer,
-        deployment -> Text,
-        failed -> Bool,
+        block_hash -> Nullable<Binary>,
+        block_number -> Nullable<Integer>,
+        entity_count -> Int8,
+        firehose_cursor -> Nullable<Text>,
+    }
+}
+
+table! {
+    /// Deployment metadata that changes less frequently
+    subgraphs.deployment (id) {
+        id -> Integer,
+
+        /// The IPFS hash of the deployment. We would like to call this
+        /// 'deployment', but Diesel doesn't let us have a column with the
+        /// same name as the table
+        subgraph -> Text,
+
+        earliest_block_number -> Integer,
+
         health -> crate::deployment::SubgraphHealthMapping,
-        synced -> Bool,
+        failed -> Bool,
         fatal_error -> Nullable<Text>,
         non_fatal_errors -> Array<Text>,
-        earliest_block_number -> Integer,
-        latest_ethereum_block_hash -> Nullable<Binary>,
-        latest_ethereum_block_number -> Nullable<Numeric>,
-        last_healthy_ethereum_block_hash -> Nullable<Binary>,
-        last_healthy_ethereum_block_number -> Nullable<Numeric>,
-        entity_count -> Numeric,
+
         graft_base -> Nullable<Text>,
         graft_block_hash -> Nullable<Binary>,
-        graft_block_number -> Nullable<Numeric>,
-        debug_fork -> Nullable<Text>,
+        graft_block_number -> Nullable<Integer>,
+
         reorg_count -> Integer,
         current_reorg_depth -> Integer,
         max_reorg_depth -> Integer,
-        firehose_cursor -> Nullable<Text>,
+
+        last_healthy_ethereum_block_hash -> Nullable<Binary>,
+        last_healthy_ethereum_block_number -> Nullable<Integer>,
+
+        debug_fork -> Nullable<Text>,
+
+        synced_at -> Nullable<Timestamptz>,
+        synced_at_block_number -> Nullable<Int4>,
+
+        /// `true` once the postponed (deferred) attribute indexes have been
+        /// created. Persisted so that we create them exactly once even
+        /// across restarts, and so that we don't recreate indexes that an
+        /// external process removed because they were unused.
+        postponed_indexes_created -> Bool,
     }
 }
 
@@ -200,32 +225,38 @@ table! {
     }
 }
 
-allow_tables_to_appear_in_same_query!(subgraph_deployment, subgraph_error, subgraph_manifest);
+allow_tables_to_appear_in_same_query!(subgraph_error, subgraph_manifest, head, deployment);
+
+joinable!(head -> deployment(id));
 
 /// Look up the graft point for the given subgraph in the database and
 /// return it. If `pending_only` is `true`, only return `Some(_)` if the
 /// deployment has not progressed past the graft point, i.e., data has not
 /// been copied for the graft
-fn graft(
-    conn: &PgConnection,
+async fn graft(
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
     pending_only: bool,
 ) -> Result<Option<(DeploymentHash, BlockPtr)>, StoreError> {
-    use subgraph_deployment as sd;
+    use deployment as sd;
+    use head as h;
 
     let graft_query = sd::table
         .select((sd::graft_base, sd::graft_block_hash, sd::graft_block_number))
-        .filter(sd::deployment.eq(id.as_str()));
+        .filter(sd::subgraph.eq(id.as_str()));
     // The name of the base subgraph, the hash, and block number
-    let graft: (Option<String>, Option<Vec<u8>>, Option<BigDecimal>) = if pending_only {
+    let graft: (Option<String>, Option<Vec<u8>>, Option<BlockNumber>) = if pending_only {
         graft_query
-            .filter(sd::latest_ethereum_block_number.is_null())
+            .inner_join(h::table)
+            .filter(h::block_number.is_null())
             .first(conn)
+            .await
             .optional()?
             .unwrap_or((None, None, None))
     } else {
         graft_query
             .first(conn)
+            .await
             .optional()?
             .unwrap_or((None, None, None))
     };
@@ -235,8 +266,7 @@ fn graft(
             // FIXME:
             //
             // workaround for arweave
-            let hash = H256::from_slice(&hash.as_slice()[..32]);
-            let block = block.to_u64().expect("block numbers fit into a u64");
+            let hash = B256::from_slice(&hash.as_slice()[..32]);
             let subgraph = DeploymentHash::new(subgraph.clone()).map_err(|_| {
                 StoreError::Unknown(anyhow!(
                     "the base subgraph for a graft must be a valid subgraph id but is `{}`",
@@ -255,36 +285,37 @@ fn graft(
 /// return it. Returns `None` if the deployment does not have
 /// a graft or if the subgraph has already progress past the graft point,
 /// indicating that the data copying for grafting has been performed
-pub fn graft_pending(
-    conn: &PgConnection,
+pub async fn graft_pending(
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
 ) -> Result<Option<(DeploymentHash, BlockPtr)>, StoreError> {
-    graft(conn, id, true)
+    graft(conn, id, true).await
 }
 
 /// Look up the graft point for the given subgraph in the database and
 /// return it. Returns `None` if the deployment does not have
 /// a graft.
-pub fn graft_point(
-    conn: &PgConnection,
+pub async fn graft_point(
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
 ) -> Result<Option<(DeploymentHash, BlockPtr)>, StoreError> {
-    graft(conn, id, false)
+    graft(conn, id, false).await
 }
 
 /// Look up the debug fork for the given subgraph in the database and
 /// return it. Returns `None` if the deployment does not have
 /// a debug fork.
-pub fn debug_fork(
-    conn: &PgConnection,
+pub async fn debug_fork(
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
 ) -> Result<Option<DeploymentHash>, StoreError> {
-    use subgraph_deployment as sd;
+    use deployment as sd;
 
     let debug_fork: Option<String> = sd::table
         .select(sd::debug_fork)
-        .filter(sd::deployment.eq(id.as_str()))
-        .first(conn)?;
+        .filter(sd::subgraph.eq(id.as_str()))
+        .first(conn)
+        .await?;
 
     match debug_fork {
         Some(fork) => Ok(Some(DeploymentHash::new(fork.clone()).map_err(|_| {
@@ -297,19 +328,24 @@ pub fn debug_fork(
     }
 }
 
-pub fn schema(conn: &PgConnection, site: &Site) -> Result<(InputSchema, bool), StoreError> {
+pub async fn schema(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<(InputSchema, bool), StoreError> {
     use subgraph_manifest as sm;
-    let (s, use_bytea_prefix) = sm::table
-        .select((sm::schema, sm::use_bytea_prefix))
+    let (s, spec_ver, use_bytea_prefix) = sm::table
+        .select((sm::schema, sm::spec_version, sm::use_bytea_prefix))
         .filter(sm::id.eq(site.id))
-        .first::<(String, bool)>(conn)?;
-    InputSchema::parse_latest(s.as_str(), site.deployment.clone())
+        .first::<(String, String, bool)>(conn)
+        .await?;
+    let spec_version =
+        Version::parse(spec_ver.as_str()).map_err(|err| StoreError::Unknown(err.into()))?;
+    InputSchema::parse(&spec_version, s.as_str(), site.deployment.clone())
         .map_err(StoreError::Unknown)
         .map(|schema| (schema, use_bytea_prefix))
 }
 
 pub struct ManifestInfo {
-    pub input_schema: InputSchema,
     pub description: Option<String>,
     pub repository: Option<String>,
     pub spec_version: String,
@@ -317,25 +353,26 @@ pub struct ManifestInfo {
 }
 
 impl ManifestInfo {
-    pub fn load(conn: &PgConnection, site: &Site) -> Result<ManifestInfo, StoreError> {
+    pub async fn load(
+        conn: &mut AsyncPgConnection,
+        site: &Site,
+    ) -> Result<ManifestInfo, StoreError> {
         use subgraph_manifest as sm;
-        let (s, description, repository, spec_version, features): (
-            String,
+        let (description, repository, spec_version, features): (
             Option<String>,
             Option<String>,
             String,
             Vec<String>,
         ) = sm::table
             .select((
-                sm::schema,
                 sm::description,
                 sm::repository,
                 sm::spec_version,
                 sm::features,
             ))
             .filter(sm::id.eq(site.id))
-            .first(conn)?;
-        let input_schema = InputSchema::parse_latest(s.as_str(), site.deployment.clone())?;
+            .first(conn)
+            .await?;
 
         // Using the features field to store the instrument flag is a bit
         // backhanded, but since this will be used very rarely, should not
@@ -343,7 +380,6 @@ impl ManifestInfo {
         let instrument = features.iter().any(|s| s == "instrument");
 
         Ok(ManifestInfo {
-            input_schema,
             description,
             repository,
             spec_version,
@@ -353,17 +389,21 @@ impl ManifestInfo {
 }
 
 // Return how many blocks of history this subgraph should keep
-pub fn history_blocks(conn: &PgConnection, site: &Site) -> Result<BlockNumber, StoreError> {
+pub async fn history_blocks(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<BlockNumber, StoreError> {
     use subgraph_manifest as sm;
     sm::table
         .select(sm::history_blocks)
         .filter(sm::id.eq(site.id))
         .first::<BlockNumber>(conn)
+        .await
         .map_err(StoreError::from)
 }
 
-pub fn set_history_blocks(
-    conn: &PgConnection,
+pub async fn set_history_blocks(
+    conn: &mut AsyncPgConnection,
     site: &Site,
     history_blocks: BlockNumber,
 ) -> Result<(), StoreError> {
@@ -372,122 +412,149 @@ pub fn set_history_blocks(
     update(sm::table.filter(sm::id.eq(site.id)))
         .set(sm::history_blocks.eq(history_blocks))
         .execute(conn)
+        .await
         .map(|_| ())
         .map_err(StoreError::from)
 }
 
-#[allow(dead_code)]
-pub fn features(conn: &PgConnection, site: &Site) -> Result<BTreeSet<SubgraphFeature>, StoreError> {
-    use subgraph_manifest as sm;
-
-    let features: Vec<String> = sm::table
-        .select(sm::features)
-        .filter(sm::id.eq(site.id))
-        .first(conn)
-        .unwrap();
-    features
-        .iter()
-        .map(|f| SubgraphFeature::from_str(f).map_err(StoreError::from))
-        .collect()
-}
-
-/// This migrates subgraphs that existed before the raw_yaml column was added.
-pub fn set_manifest_raw_yaml(
-    conn: &PgConnection,
+/// Sets the raw subgraph manifest for the given `site`, if not previously set.
+///
+/// Returns `Ok(())` regardless of whether the value was updated.
+pub async fn set_raw_manifest_once(
+    conn: &mut AsyncPgConnection,
     site: &Site,
-    raw_yaml: &str,
+    raw_manifest: &str,
 ) -> Result<(), StoreError> {
     use subgraph_manifest as sm;
 
     update(sm::table.filter(sm::id.eq(site.id)))
         .filter(sm::raw_yaml.is_null())
-        .set(sm::raw_yaml.eq(raw_yaml))
+        .set(sm::raw_yaml.eq(raw_manifest))
         .execute(conn)
+        .await
         .map(|_| ())
         .map_err(|e| e.into())
 }
 
-pub fn transact_block(
-    conn: &PgConnection,
+/// Returns the raw subgraph manifest for the given `site`, if one exists.
+///
+/// Returns `None` if no manifest is found for this `site`.
+pub async fn load_raw_manifest(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<Option<String>, StoreError> {
+    use subgraph_manifest as sm;
+
+    sm::table
+        .select(sm::raw_yaml)
+        .filter(sm::id.eq(site.id))
+        .first(conn)
+        .await
+        .map_err(StoreError::from)
+}
+
+/// Most of the time, this will be a noop; the only time we actually modify
+/// the deployment table is the first forward block after a reorg
+async fn reset_reorg_count(conn: &mut AsyncPgConnection, site: &Site) -> StoreResult<()> {
+    use deployment as d;
+
+    update(d::table.filter(d::id.eq(site.id)))
+        .filter(d::current_reorg_depth.gt(0))
+        .set(d::current_reorg_depth.eq(0))
+        .execute(conn)
+        .await?;
+    Ok(())
+}
+
+pub async fn transact_block(
+    conn: &mut AsyncPgConnection,
     site: &Site,
     ptr: &BlockPtr,
     firehose_cursor: &FirehoseCursor,
     count: i32,
 ) -> Result<BlockNumber, StoreError> {
-    use crate::diesel::BoolExpressionMethods;
-    use subgraph_deployment as d;
-
-    // Work around a Diesel issue with serializing BigDecimals to numeric
-    let number = format!("{}::numeric", ptr.number);
+    use deployment as d;
+    use head as h;
 
     let count_sql = entity_count_sql(count);
 
-    let rows = update(
-        d::table.filter(d::id.eq(site.id)).filter(
-            // Asserts that the processing direction is forward.
-            d::latest_ethereum_block_number
-                .lt(sql(&number))
-                .or(d::latest_ethereum_block_number.is_null()),
-        ),
-    )
-    .set((
-        d::latest_ethereum_block_number.eq(sql(&number)),
-        d::latest_ethereum_block_hash.eq(ptr.hash_slice()),
-        d::firehose_cursor.eq(firehose_cursor.as_ref()),
-        d::entity_count.eq(sql(&count_sql)),
-        d::current_reorg_depth.eq(0),
-    ))
-    .returning(d::earliest_block_number)
-    .get_results::<BlockNumber>(conn)
-    .map_err(StoreError::from)?;
+    // Sanity check: The processing direction is forward.
+    //
+    // Performance note: This costs us an extra DB query on every update. We used to put this in the
+    // `where` clause of the `update` statement, but that caused Postgres to use bitmap scans instead
+    // of a simple primary key lookup. So a separate query it is.
+    let block_ptr = block_ptr(conn, site).await?;
+    if let Some(block_ptr_from) = block_ptr
+        && block_ptr_from.number >= ptr.number
+    {
+        return Err(StoreError::DuplicateBlockProcessing(
+            site.deployment.clone(),
+            ptr.number,
+        ));
+    }
+
+    reset_reorg_count(conn, site).await?;
 
-    match rows.len() {
+    let rows = update(h::table.filter(h::id.eq(site.id)))
+        .set((
+            h::block_number.eq(ptr.number),
+            h::block_hash.eq(ptr.hash_slice()),
+            h::firehose_cursor.eq(firehose_cursor.as_ref()),
+            h::entity_count.eq(sql(&count_sql)),
+        ))
+        .execute(conn)
+        .await
+        .map_err(StoreError::from)?;
+
+    match rows {
         // Common case: A single row was updated.
-        1 => Ok(rows[0]),
+        1 => {
+            // It's not strictly necessary to load the earliest block every
+            // time this method is called; if these queries slow things down
+            // too much, we should cache the earliest block number since it
+            // is only needed to determine whether a pruning run should be
+            // kicked off
+            d::table
+                .filter(d::id.eq(site.id))
+                .select(d::earliest_block_number)
+                .get_result::<BlockNumber>(conn)
+                .await
+                .map_err(StoreError::from)
+        }
 
-        // No matching rows were found. This is an error. By the filter conditions, this can only be
-        // due to a missing deployment (which `block_ptr` catches) or duplicate block processing.
-        0 => match block_ptr(conn, &site.deployment)? {
-            Some(block_ptr_from) if block_ptr_from.number >= ptr.number => Err(
-                StoreError::DuplicateBlockProcessing(site.deployment.clone(), ptr.number),
-            ),
-            None | Some(_) => Err(StoreError::Unknown(anyhow!(
-                "unknown error forwarding block ptr"
-            ))),
-        },
+        // No matching rows were found. This is logically impossible, as the `block_ptr` would have
+        // caught a non-existing deployment.
+        0 => Err(StoreError::Unknown(anyhow!(
+            "unknown error forwarding block ptr"
+        ))),
 
         // More than one matching row was found.
-        _ => Err(StoreError::ConstraintViolation(
+        _ => Err(StoreError::InternalError(
             "duplicate deployments in shard".to_owned(),
         )),
     }
 }
 
-pub fn forward_block_ptr(
-    conn: &PgConnection,
-    id: &DeploymentHash,
+pub async fn forward_block_ptr(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
     ptr: &BlockPtr,
 ) -> Result<(), StoreError> {
     use crate::diesel::BoolExpressionMethods;
-    use subgraph_deployment as d;
+    use head as h;
 
-    // Work around a Diesel issue with serializing BigDecimals to numeric
-    let number = format!("{}::numeric", ptr.number);
+    reset_reorg_count(conn, site).await?;
 
-    let row_count = update(
-        d::table.filter(d::deployment.eq(id.as_str())).filter(
-            // Asserts that the processing direction is forward.
-            d::latest_ethereum_block_number
-                .lt(sql(&number))
-                .or(d::latest_ethereum_block_number.is_null()),
-        ),
-    )
+    let row_count = update(h::table.filter(h::id.eq(site.id)).filter(
+        // Asserts that the processing direction is forward.
+        h::block_number.lt(ptr.number).or(h::block_number.is_null()),
+    ))
     .set((
-        d::latest_ethereum_block_number.eq(sql(&number)),
-        d::latest_ethereum_block_hash.eq(ptr.hash_slice()),
-        d::current_reorg_depth.eq(0),
+        h::block_number.eq(ptr.number),
+        h::block_hash.eq(ptr.hash_slice()),
     ))
     .execute(conn)
+    .await
     .map_err(StoreError::from)?;
 
     match row_count {
@@ -496,94 +563,127 @@ pub fn forward_block_ptr(
 
         // No matching rows were found. This is an error. By the filter conditions, this can only be
         // due to a missing deployment (which `block_ptr` catches) or duplicate block processing.
-        0 => match block_ptr(conn, id)? {
-            Some(block_ptr_from) if block_ptr_from.number >= ptr.number => {
-                Err(StoreError::DuplicateBlockProcessing(id.clone(), ptr.number))
-            }
+        0 => match block_ptr(conn, site).await? {
+            Some(block_ptr_from) if block_ptr_from.number >= ptr.number => Err(
+                StoreError::DuplicateBlockProcessing(site.deployment.clone(), ptr.number),
+            ),
             None | Some(_) => Err(StoreError::Unknown(anyhow!(
                 "unknown error forwarding block ptr"
             ))),
         },
 
         // More than one matching row was found.
-        _ => Err(StoreError::ConstraintViolation(
+        _ => Err(StoreError::InternalError(
             "duplicate deployments in shard".to_owned(),
         )),
     }
 }
 
-pub fn get_subgraph_firehose_cursor(
-    conn: &PgConnection,
+pub async fn get_subgraph_firehose_cursor(
+    conn: &mut AsyncPgConnection,
     site: Arc<Site>,
 ) -> Result<Option<String>, StoreError> {
-    use subgraph_deployment as d;
+    use head as h;
 
-    let res = d::table
-        .filter(d::deployment.eq(site.deployment.as_str()))
-        .select(d::firehose_cursor)
+    h::table
+        .filter(h::id.eq(site.id))
+        .select(h::firehose_cursor)
         .first::<Option<String>>(conn)
-        .map_err(StoreError::from);
-    res
+        .await
+        .map_err(StoreError::from)
 }
 
-pub fn revert_block_ptr(
-    conn: &PgConnection,
-    id: &DeploymentHash,
+pub async fn revert_block_ptr(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
     ptr: BlockPtr,
     firehose_cursor: &FirehoseCursor,
 ) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
-
-    // Work around a Diesel issue with serializing BigDecimals to numeric
-    let number = format!("{}::numeric", ptr.number);
+    use deployment as d;
+    use head as h;
+
+    // Intention is to revert to a block lower than the reorg threshold, on the other
+    // hand the earliest we can possibly go is genesys block, so go to genesys even
+    // if it's within the reorg threshold.
+    let earliest_block = i32::max(ptr.number - ENV_VARS.reorg_threshold(), 0);
+    let affected_rows = update(
+        d::table
+            .filter(d::id.eq(site.id))
+            .filter(d::earliest_block_number.le(earliest_block)),
+    )
+    .set((
+        d::reorg_count.eq(d::reorg_count + 1),
+        d::current_reorg_depth.eq(d::current_reorg_depth + 1),
+        d::max_reorg_depth.eq(sql("greatest(current_reorg_depth + 1, max_reorg_depth)")),
+    ))
+    .execute(conn)
+    .await?;
 
-    update(d::table.filter(d::deployment.eq(id.as_str())))
+    update(h::table.filter(h::id.eq(site.id)))
         .set((
-            d::latest_ethereum_block_number.eq(sql(&number)),
-            d::latest_ethereum_block_hash.eq(ptr.hash_slice()),
-            d::firehose_cursor.eq(firehose_cursor.as_ref()),
-            d::reorg_count.eq(d::reorg_count + 1),
-            d::current_reorg_depth.eq(d::current_reorg_depth + 1),
-            d::max_reorg_depth.eq(sql("greatest(current_reorg_depth + 1, max_reorg_depth)")),
+            h::block_number.eq(ptr.number),
+            h::block_hash.eq(ptr.hash_slice()),
+            h::firehose_cursor.eq(firehose_cursor.as_ref()),
         ))
         .execute(conn)
-        .map(|_| ())
-        .map_err(|e| e.into())
-}
+        .await?;
 
-pub fn block_ptr(conn: &PgConnection, id: &DeploymentHash) -> Result<Option<BlockPtr>, StoreError> {
-    use subgraph_deployment as d;
+    match affected_rows {
+        1 => Ok(()),
+        0 => Err(StoreError::Unknown(anyhow!(
+            "No rows affected. This could be due to an attempt to revert beyond earliest_block + reorg_threshold",
+        ))),
+        _ => Err(StoreError::Unknown(anyhow!(
+            "Expected to update 1 row, but {} rows were affected",
+            affected_rows
+        ))),
+    }
+}
 
-    let (number, hash) = d::table
-        .filter(d::deployment.eq(id.as_str()))
-        .select((
-            d::latest_ethereum_block_number,
-            d::latest_ethereum_block_hash,
-        ))
-        .first::<(Option<BigDecimal>, Option<Vec<u8>>)>(conn)
+pub async fn block_ptr(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<Option<BlockPtr>, StoreError> {
+    use head as h;
+
+    let (number, hash) = h::table
+        .filter(h::id.eq(site.id))
+        .select((h::block_number, h::block_hash))
+        .first::<(Option<BlockNumber>, Option<Vec<u8>>)>(conn)
+        .await
         .map_err(|e| match e {
-            diesel::result::Error::NotFound => StoreError::DeploymentNotFound(id.to_string()),
+            diesel::result::Error::NotFound => {
+                StoreError::DeploymentNotFound(site.deployment.to_string())
+            }
             e => e.into(),
         })?;
 
-    let ptr = crate::detail::block(id.as_str(), "latest_ethereum_block", hash, number)?
-        .map(|block| block.to_ptr());
+    let ptr = crate::detail::block(
+        site.deployment.as_str(),
+        "latest_ethereum_block",
+        hash,
+        number,
+    )?
+    .map(|block| block.to_ptr());
     Ok(ptr)
 }
 
 /// Initialize the subgraph's block pointer. If the block pointer in
 /// `latest_ethereum_block` is set already, do nothing. If it is still
 /// `null`, set it to `start_ethereum_block` from `subgraph_manifest`
-pub fn initialize_block_ptr(conn: &PgConnection, site: &Site) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+pub async fn initialize_block_ptr(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<(), StoreError> {
+    use head as h;
     use subgraph_manifest as m;
 
-    let needs_init = d::table
-        .filter(d::id.eq(site.id))
-        .select(d::latest_ethereum_block_hash)
-        .first::<Option<Vec<u8>>>(conn)
+    let needs_init = h::table
+        .filter(h::id.eq(site.id))
+        .select(h::block_hash)
+        .first::<Option<Vec<u8>>>(conn).await
         .map_err(|e| {
-            constraint_violation!(
+            internal_error!(
                 "deployment sgd{} must have been created before calling initialize_block_ptr but we got {}",
                 site.id, e
             )
@@ -594,16 +694,13 @@ pub fn initialize_block_ptr(conn: &PgConnection, site: &Site) -> Result<(), Stor
         if let (Some(hash), Some(number)) = m::table
             .filter(m::id.eq(site.id))
             .select((m::start_block_hash, m::start_block_number))
-            .first::<(Option<Vec<u8>>, Option<BlockNumber>)>(conn)?
+            .first::<(Option<Vec<u8>>, Option<BlockNumber>)>(conn)
+            .await?
         {
-            let number = format!("{}::numeric", number);
-
-            update(d::table.filter(d::id.eq(site.id)))
-                .set((
-                    d::latest_ethereum_block_hash.eq(&hash),
-                    d::latest_ethereum_block_number.eq(sql(&number)),
-                ))
+            update(h::table.filter(h::id.eq(site.id)))
+                .set((h::block_hash.eq(&hash), h::block_number.eq(number)))
                 .execute(conn)
+                .await
                 .map(|_| ())
                 .map_err(|e| e.into())
         } else {
@@ -616,10 +713,10 @@ pub fn initialize_block_ptr(conn: &PgConnection, site: &Site) -> Result<(), Stor
 
 fn convert_to_u32(number: Option<i32>, field: &str, subgraph: &str) -> Result<u32, StoreError> {
     number
-        .ok_or_else(|| constraint_violation!("missing {} for subgraph `{}`", field, subgraph))
+        .ok_or_else(|| internal_error!("missing {} for subgraph `{}`", field, subgraph))
         .and_then(|number| {
             u32::try_from(number).map_err(|_| {
-                constraint_violation!(
+                internal_error!(
                     "invalid value {:?} for {} in subgraph {}",
                     number,
                     field,
@@ -629,32 +726,43 @@ fn convert_to_u32(number: Option<i32>, field: &str, subgraph: &str) -> Result<u3
         })
 }
 
-pub fn state(conn: &PgConnection, id: DeploymentHash) -> Result<DeploymentState, StoreError> {
-    use subgraph_deployment as d;
+pub async fn state(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<DeploymentState, StoreError> {
+    use deployment as d;
+    use head as h;
+    use subgraph_error as e;
 
     match d::table
-        .filter(d::deployment.eq(id.as_str()))
+        .inner_join(h::table)
+        .filter(d::id.eq(site.id))
         .select((
-            d::deployment,
+            d::subgraph,
             d::reorg_count,
             d::max_reorg_depth,
-            d::latest_ethereum_block_number,
-            d::latest_ethereum_block_hash,
+            h::block_number,
+            h::block_hash,
             d::earliest_block_number,
+            d::failed,
+            d::health,
         ))
         .first::<(
             String,
             i32,
             i32,
-            Option<BigDecimal>,
+            Option<BlockNumber>,
             Option<Vec<u8>>,
             BlockNumber,
+            bool,
+            SubgraphHealth,
         )>(conn)
+        .await
         .optional()?
     {
         None => Err(StoreError::QueryExecutionError(format!(
             "No data found for subgraph {}",
-            id
+            site.deployment
         ))),
         Some((
             _,
@@ -663,12 +771,14 @@ pub fn state(conn: &PgConnection, id: DeploymentHash) -> Result<DeploymentState,
             latest_block_number,
             latest_block_hash,
             earliest_block_number,
+            failed,
+            health,
         )) => {
-            let reorg_count = convert_to_u32(Some(reorg_count), "reorg_count", id.as_str())?;
+            let reorg_count = convert_to_u32(Some(reorg_count), "reorg_count", &site.deployment)?;
             let max_reorg_depth =
-                convert_to_u32(Some(max_reorg_depth), "max_reorg_depth", id.as_str())?;
+                convert_to_u32(Some(max_reorg_depth), "max_reorg_depth", &site.deployment)?;
             let latest_block = crate::detail::block(
-                id.as_str(),
+                &site.deployment,
                 "latest_block",
                 latest_block_hash,
                 latest_block_number,
@@ -677,62 +787,121 @@ pub fn state(conn: &PgConnection, id: DeploymentHash) -> Result<DeploymentState,
                 StoreError::QueryExecutionError(format!(
                     "Subgraph `{}` has not started syncing yet. Wait for it to ingest \
                  a few blocks before querying it",
-                    id
+                    site.deployment
                 ))
             })?
             .to_ptr();
+            // We skip checking for errors if the subgraph is healthy; since
+            // that is a lot harder to determine than one would assume, we try
+            // to err on the side of caution
+            let first_error_block = if failed || !matches!(health, SubgraphHealth::Healthy) {
+                e::table
+                    .filter(e::subgraph_id.eq(site.deployment.as_str()))
+                    .filter(e::deterministic)
+                    .select(sql::<Nullable<Integer>>("min(lower(block_range))"))
+                    .first::<Option<i32>>(conn)
+                    .await?
+            } else {
+                None
+            };
             Ok(DeploymentState {
-                id,
+                id: site.deployment.clone(),
                 reorg_count,
                 max_reorg_depth,
                 latest_block,
                 earliest_block_number,
+                first_error_block,
             })
         }
     }
 }
 
 /// Mark the deployment `id` as synced
-pub fn set_synced(conn: &PgConnection, id: &DeploymentHash) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+pub async fn set_synced(
+    conn: &mut AsyncPgConnection,
+    id: &DeploymentHash,
+    block_ptr: BlockPtr,
+) -> Result<(), StoreError> {
+    use deployment as d;
 
     update(
         d::table
-            .filter(d::deployment.eq(id.as_str()))
-            .filter(d::synced.eq(false)),
+            .filter(d::subgraph.eq(id.as_str()))
+            .filter(d::synced_at.is_null()),
     )
-    .set(d::synced.eq(true))
-    .execute(conn)?;
+    .set((
+        d::synced_at.eq(now),
+        d::synced_at_block_number.eq(block_ptr.number),
+    ))
+    .execute(conn)
+    .await?;
+    Ok(())
+}
+
+/// Returns whether the postponed (deferred) attribute indexes have already
+/// been created for this deployment.
+pub async fn postponed_indexes_created(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<bool, StoreError> {
+    use deployment as d;
+
+    let created = d::table
+        .filter(d::id.eq(site.id))
+        .select(d::postponed_indexes_created)
+        .first::<bool>(conn)
+        .await?;
+    Ok(created)
+}
+
+/// Mark the postponed (deferred) attribute indexes as created for this
+/// deployment. Once set, we never recreate these indexes — even if an
+/// external process removes them.
+pub async fn set_postponed_indexes_created(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<(), StoreError> {
+    use deployment as d;
+
+    update(d::table.filter(d::id.eq(site.id)))
+        .set(d::postponed_indexes_created.eq(true))
+        .execute(conn)
+        .await?;
     Ok(())
 }
 
 /// Returns `true` if the deployment (as identified by `site.id`)
-pub fn exists(conn: &PgConnection, site: &Site) -> Result<bool, StoreError> {
-    use subgraph_deployment as d;
+pub async fn exists(conn: &mut AsyncPgConnection, site: &Site) -> Result<bool, StoreError> {
+    use deployment as d;
 
     let exists = d::table
         .filter(d::id.eq(site.id))
         .count()
-        .get_result::<i64>(conn)?
+        .get_result::<i64>(conn)
+        .await?
         > 0;
     Ok(exists)
 }
 
 /// Returns `true` if the deployment `id` exists and is synced
-pub fn exists_and_synced(conn: &PgConnection, id: &str) -> Result<bool, StoreError> {
-    use subgraph_deployment as d;
+pub async fn exists_and_synced(conn: &mut AsyncPgConnection, id: &str) -> Result<bool, StoreError> {
+    use deployment as d;
 
     let synced = d::table
-        .filter(d::deployment.eq(id))
-        .select(d::synced)
+        .filter(d::subgraph.eq(id))
+        .select(d::synced_at.is_not_null())
         .first(conn)
+        .await
         .optional()?
         .unwrap_or(false);
     Ok(synced)
 }
 
 // Does nothing if the error already exists. Returns the error id.
-fn insert_subgraph_error(conn: &PgConnection, error: &SubgraphError) -> anyhow::Result<String> {
+async fn insert_subgraph_error(
+    conn: &mut AsyncPgConnection,
+    error: &SubgraphError,
+) -> anyhow::Result<String> {
     use subgraph_error as e;
 
     let error_id = hex::encode(stable_hash_legacy::utils::stable_hash::<SetHasher, _>(
@@ -747,10 +916,7 @@ fn insert_subgraph_error(conn: &PgConnection, error: &SubgraphError) -> anyhow::
     } = error;
 
     let block_num = match &block_ptr {
-        None => {
-            assert_eq!(*deterministic, false);
-            crate::block_range::BLOCK_UNVERSIONED
-        }
+        None => crate::block_range::BLOCK_UNVERSIONED,
         Some(block) => crate::block_range::block_number(block),
     };
 
@@ -765,25 +931,26 @@ fn insert_subgraph_error(conn: &PgConnection, error: &SubgraphError) -> anyhow::
             e::block_range.eq((Bound::Included(block_num), Bound::Unbounded)),
         ))
         .on_conflict_do_nothing()
-        .execute(conn)?;
+        .execute(conn)
+        .await?;
 
     Ok(error_id)
 }
 
-pub fn fail(
-    conn: &PgConnection,
+pub async fn fail(
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
     error: &SubgraphError,
 ) -> Result<(), StoreError> {
-    let error_id = insert_subgraph_error(conn, error)?;
+    let error_id = insert_subgraph_error(conn, error).await?;
 
-    update_deployment_status(conn, id, SubgraphHealth::Failed, Some(error_id), None)?;
+    update_deployment_status(conn, id, SubgraphHealth::Failed, Some(error_id), None).await?;
 
     Ok(())
 }
 
-pub fn update_non_fatal_errors(
-    conn: &PgConnection,
+pub async fn update_non_fatal_errors(
+    conn: &mut AsyncPgConnection,
     deployment_id: &DeploymentHash,
     health: SubgraphHealth,
     non_fatal_errors: Option<&[SubgraphError]>,
@@ -799,14 +966,14 @@ pub fn update_non_fatal_errors(
             .collect::<Vec<_>>()
     });
 
-    update_deployment_status(conn, deployment_id, health, None, error_ids)?;
+    update_deployment_status(conn, deployment_id, health, None, error_ids).await?;
 
     Ok(())
 }
 
 /// If `block` is `None`, assumes the latest block.
-pub(crate) fn has_deterministic_errors(
-    conn: &PgConnection,
+pub(crate) async fn has_deterministic_errors(
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
     block: BlockNumber,
 ) -> Result<bool, StoreError> {
@@ -815,29 +982,31 @@ pub(crate) fn has_deterministic_errors(
         e::table
             .filter(e::subgraph_id.eq(id.as_str()))
             .filter(e::deterministic)
-            .filter(sql("block_range @> ").bind::<Integer, _>(block)),
+            .filter(sql::<Bool>("block_range @> ").bind::<Integer, _>(block)),
     ))
     .get_result(conn)
+    .await
     .map_err(|e| e.into())
 }
 
-pub fn update_deployment_status(
-    conn: &PgConnection,
+pub async fn update_deployment_status(
+    conn: &mut AsyncPgConnection,
     deployment_id: &DeploymentHash,
     health: SubgraphHealth,
     fatal_error: Option<String>,
     non_fatal_errors: Option<Vec<String>>,
 ) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+    use deployment as d;
 
-    update(d::table.filter(d::deployment.eq(deployment_id.as_str())))
+    update(d::table.filter(d::subgraph.eq(deployment_id.as_str())))
         .set((
             d::failed.eq(health.is_failed()),
             d::health.eq(health),
             d::fatal_error.eq::<Option<String>>(fatal_error),
-            d::non_fatal_errors.eq::<Vec<String>>(non_fatal_errors.unwrap_or(vec![])),
+            d::non_fatal_errors.eq::<Vec<String>>(non_fatal_errors.unwrap_or_default()),
         ))
         .execute(conn)
+        .await
         .map(|_| ())
         .map_err(StoreError::from)
 }
@@ -846,68 +1015,94 @@ pub fn update_deployment_status(
 /// unhealthy. The `latest_block` is only used to check whether the subgraph
 /// is healthy as of that block; errors are inserted according to the
 /// `block_ptr` they contain
-pub(crate) fn insert_subgraph_errors(
-    conn: &PgConnection,
+pub(crate) async fn insert_subgraph_errors(
+    logger: &Logger,
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
     deterministic_errors: &[SubgraphError],
     latest_block: BlockNumber,
 ) -> Result<(), StoreError> {
+    debug!(
+        logger,
+        "Inserting deterministic errors to the db";
+        "subgraph" => id.to_string(),
+        "errors" => deterministic_errors.len()
+    );
+
     for error in deterministic_errors {
-        insert_subgraph_error(conn, error)?;
+        insert_subgraph_error(conn, error).await?;
     }
 
-    check_health(conn, id, latest_block)
+    check_health(logger, conn, id, latest_block).await
 }
 
 #[cfg(debug_assertions)]
-pub(crate) fn error_count(conn: &PgConnection, id: &DeploymentHash) -> Result<usize, StoreError> {
+pub(crate) async fn error_count(
+    conn: &mut AsyncPgConnection,
+    id: &DeploymentHash,
+) -> Result<usize, StoreError> {
     use subgraph_error as e;
 
     Ok(e::table
         .filter(e::subgraph_id.eq(id.as_str()))
         .count()
-        .get_result::<i64>(conn)? as usize)
+        .get_result::<i64>(conn)
+        .await? as usize)
 }
 
 /// Checks if the subgraph is healthy or unhealthy as of the given block, or the subgraph latest
 /// block if `None`, based on the presence of deterministic errors. Has no effect on failed subgraphs.
-fn check_health(
-    conn: &PgConnection,
+async fn check_health(
+    logger: &Logger,
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
     block: BlockNumber,
 ) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+    use deployment as d;
 
-    let has_errors = has_deterministic_errors(conn, id, block)?;
+    let has_errors = has_deterministic_errors(conn, id, block).await?;
 
     let (new, old) = match has_errors {
-        true => (SubgraphHealth::Unhealthy, SubgraphHealth::Healthy),
+        true => {
+            debug!(
+                logger,
+                "Subgraph has deterministic errors. Marking as unhealthy";
+                "subgraph" => id.to_string(),
+                "block" => block
+            );
+            (SubgraphHealth::Unhealthy, SubgraphHealth::Healthy)
+        }
         false => (SubgraphHealth::Healthy, SubgraphHealth::Unhealthy),
     };
 
     update(
         d::table
-            .filter(d::deployment.eq(id.as_str()))
+            .filter(d::subgraph.eq(id.as_str()))
             .filter(d::health.eq(old)),
     )
     .set(d::health.eq(new))
     .execute(conn)
+    .await
     .map(|_| ())
     .map_err(|e| e.into())
 }
 
-pub(crate) fn health(conn: &PgConnection, id: DeploymentId) -> Result<SubgraphHealth, StoreError> {
-    use subgraph_deployment as d;
+pub(crate) async fn health(
+    conn: &mut AsyncPgConnection,
+    id: DeploymentId,
+) -> Result<SubgraphHealth, StoreError> {
+    use deployment as d;
 
     d::table
         .filter(d::id.eq(id))
         .select(d::health)
         .get_result(conn)
+        .await
         .map_err(|e| e.into())
 }
 
-pub(crate) fn entities_with_causality_region(
-    conn: &PgConnection,
+pub(crate) async fn entities_with_causality_region(
+    conn: &mut AsyncPgConnection,
     id: DeploymentId,
     schema: &InputSchema,
 ) -> Result<Vec<EntityType>, StoreError> {
@@ -917,6 +1112,7 @@ pub(crate) fn entities_with_causality_region(
         .filter(sm::id.eq(id))
         .select(sm::entities_with_causality_region)
         .get_result::<Vec<String>>(conn)
+        .await
         .map_err(|e| e.into())
         .map(|ents| {
             // It is possible to have entity types in
@@ -929,54 +1125,61 @@ pub(crate) fn entities_with_causality_region(
 }
 
 /// Reverts the errors and updates the subgraph health if necessary.
-pub(crate) fn revert_subgraph_errors(
-    conn: &PgConnection,
+pub(crate) async fn revert_subgraph_errors(
+    logger: &Logger,
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
     reverted_block: BlockNumber,
 ) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+    use deployment as d;
     use subgraph_error as e;
 
     let lower_geq = format!("lower({}) >= ", BLOCK_RANGE_COLUMN);
     delete(
         e::table
             .filter(e::subgraph_id.eq(id.as_str()))
-            .filter(sql(&lower_geq).bind::<Integer, _>(reverted_block)),
+            .filter(sql::<Bool>(&lower_geq).bind::<Integer, _>(reverted_block)),
     )
-    .execute(conn)?;
+    .execute(conn)
+    .await?;
 
     // The result will be the same at `reverted_block` or `reverted_block - 1` since the errors at
     // `reverted_block` were just deleted, but semantically we care about `reverted_block - 1` which
     // is the block being reverted to.
-    check_health(conn, id, reverted_block - 1)?;
+    check_health(logger, conn, id, reverted_block - 1).await?;
 
     // If the deployment is failed in both `failed` and `status` columns,
     // update both values respectively to `false` and `healthy`. Basically
     // unfail the statuses.
     update(
         d::table
-            .filter(d::deployment.eq(id.as_str()))
+            .filter(d::subgraph.eq(id.as_str()))
             .filter(d::failed.eq(true))
             .filter(d::health.eq(SubgraphHealth::Failed)),
     )
     .set((d::failed.eq(false), d::health.eq(SubgraphHealth::Healthy)))
     .execute(conn)
+    .await
     .map(|_| ())
     .map_err(StoreError::from)
 }
 
-pub(crate) fn delete_error(conn: &PgConnection, error_id: &str) -> Result<(), StoreError> {
+pub(crate) async fn delete_error(
+    conn: &mut AsyncPgConnection,
+    error_id: &str,
+) -> Result<(), StoreError> {
     use subgraph_error as e;
     delete(e::table.filter(e::id.eq(error_id)))
         .execute(conn)
+        .await
         .map(|_| ())
         .map_err(StoreError::from)
 }
 
 /// Copy the dynamic data sources for `src` to `dst`. All data sources that
 /// were created up to and including `target_block` will be copied.
-pub(crate) fn copy_errors(
-    conn: &PgConnection,
+pub(crate) async fn copy_errors(
+    conn: &mut AsyncPgConnection,
     src: &Site,
     dst: &Site,
     target_block: &BlockPtr,
@@ -990,7 +1193,8 @@ pub(crate) fn copy_errors(
     let count = e::table
         .filter(e::subgraph_id.eq(dst.deployment.as_str()))
         .select(count(e::vid))
-        .get_result::<i64>(conn)?;
+        .get_result::<i64>(conn)
+        .await?;
     if count > 0 {
         return Ok(count as usize);
     }
@@ -1020,7 +1224,8 @@ pub(crate) fn copy_errors(
         .bind::<Text, _>(src.deployment.as_str())
         .bind::<Text, _>(dst.deployment.as_str())
         .bind::<Integer, _>(target_block.number)
-        .execute(conn)?)
+        .execute(conn)
+        .await?)
 }
 
 /// Drop the schema `namespace`. This deletes all data for the subgraph, and
@@ -1029,47 +1234,47 @@ pub(crate) fn copy_errors(
 ///
 /// Since long-running operations, like a vacuum on one of the tables in the
 /// schema, could block dropping the schema indefinitely, this operation
-/// will wait at most 2s to aquire all necessary locks, and fail if that is
+/// will wait at most 2s to acquire all necessary locks, and fail if that is
 /// not possible.
-pub fn drop_schema(
-    conn: &diesel::pg::PgConnection,
+pub async fn drop_schema(
+    conn: &mut AsyncPgConnection,
     namespace: &crate::primary::Namespace,
 ) -> Result<(), StoreError> {
     let query = format!(
         "set local lock_timeout=2000; drop schema if exists {} cascade",
         namespace
     );
-    Ok(conn.batch_execute(&query)?)
+    Ok(conn.batch_execute(&query).await?)
 }
 
-pub fn drop_metadata(conn: &PgConnection, site: &Site) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+pub async fn drop_metadata(conn: &mut AsyncPgConnection, site: &Site) -> Result<(), StoreError> {
+    use head as h;
 
-    // We don't need to delete from subgraph_manifest or subgraph_error
-    // since that cascades from deleting the subgraph_deployment
-    delete(d::table.filter(d::id.eq(site.id))).execute(conn)?;
+    // We don't need to delete from `deployment`, `subgraph_manifest`,  or
+    // `subgraph_error` since that cascades from deleting `head`
+    delete(h::table.filter(h::id.eq(site.id)))
+        .execute(conn)
+        .await?;
     Ok(())
 }
 
-pub fn create_deployment(
-    conn: &PgConnection,
+pub async fn create_deployment(
+    conn: &mut AsyncPgConnection,
     site: &Site,
-    deployment: DeploymentCreate,
+    create: DeploymentCreate,
     exists: bool,
     replace: bool,
 ) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+    use deployment as d;
+    use head as h;
     use subgraph_manifest as m;
 
     fn b(ptr: &Option<BlockPtr>) -> Option<&[u8]> {
         ptr.as_ref().map(|ptr| ptr.hash_slice())
     }
 
-    fn n(ptr: &Option<BlockPtr>) -> SqlLiteral<Nullable<Numeric>> {
-        match ptr {
-            None => sql("null"),
-            Some(ptr) => sql(&format!("{}::numeric", ptr.number)),
-        }
+    fn n(ptr: &Option<BlockPtr>) -> Option<BlockNumber> {
+        ptr.as_ref().map(|ptr| ptr.number)
     }
 
     let DeploymentCreate {
@@ -1089,33 +1294,37 @@ pub fn create_deployment(
         graft_block,
         debug_fork,
         history_blocks_override,
-    } = deployment;
+    } = create;
     let earliest_block_number = start_block.as_ref().map(|ptr| ptr.number).unwrap_or(0);
     let entities_with_causality_region = Vec::from_iter(
         entities_with_causality_region
             .into_iter()
-            .map(|et| et.as_str().to_owned()),
+            .map(|et| et.typename().to_owned()),
+    );
+
+    let head_values = (
+        h::id.eq(site.id),
+        h::block_number.eq(sql("null")),
+        h::block_hash.eq(sql("null")),
+        h::firehose_cursor.eq(sql("null")),
+        h::entity_count.eq(sql("0")),
     );
 
     let deployment_values = (
         d::id.eq(site.id),
-        d::deployment.eq(site.deployment.as_str()),
+        d::subgraph.eq(site.deployment.as_str()),
         d::failed.eq(false),
-        d::synced.eq(false),
         d::health.eq(SubgraphHealth::Healthy),
         d::fatal_error.eq::<Option<String>>(None),
         d::non_fatal_errors.eq::<Vec<String>>(vec![]),
         d::earliest_block_number.eq(earliest_block_number),
-        d::latest_ethereum_block_hash.eq(sql("null")),
-        d::latest_ethereum_block_number.eq(sql("null")),
-        d::entity_count.eq(sql("0")),
         d::graft_base.eq(graft_base.as_ref().map(|s| s.as_str())),
         d::graft_block_hash.eq(b(&graft_block)),
         d::graft_block_number.eq(n(&graft_block)),
         d::debug_fork.eq(debug_fork.as_ref().map(|s| s.as_str())),
     );
 
-    let graph_node_version_id = GraphNodeVersion::create_or_get(conn)?;
+    let graph_node_version_id = GraphNodeVersion::create_or_get(conn).await?;
 
     let manifest_values = (
         m::id.eq(site.id),
@@ -1136,21 +1345,35 @@ pub fn create_deployment(
     );
 
     if exists && replace {
-        update(d::table.filter(d::deployment.eq(site.deployment.as_str())))
+        update(h::table.filter(h::id.eq(site.id)))
+            .set(head_values)
+            .execute(conn)
+            .await?;
+
+        update(d::table.filter(d::subgraph.eq(site.deployment.as_str())))
             .set(deployment_values)
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
 
         update(m::table.filter(m::id.eq(site.id)))
             .set(manifest_values)
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
     } else {
+        insert_into(h::table)
+            .values(head_values)
+            .execute(conn)
+            .await?;
+
         insert_into(d::table)
             .values(deployment_values)
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
 
         insert_into(m::table)
             .values(manifest_values)
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
     }
     Ok(())
 }
@@ -1159,32 +1382,36 @@ fn entity_count_sql(count: i32) -> String {
     format!("entity_count + ({count})")
 }
 
-pub fn update_entity_count(conn: &PgConnection, site: &Site, count: i32) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+pub async fn update_entity_count(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+    count: i32,
+) -> Result<(), StoreError> {
+    use head as h;
 
     if count == 0 {
         return Ok(());
     }
 
     let count_sql = entity_count_sql(count);
-    update(d::table.filter(d::id.eq(site.id)))
-        .set(d::entity_count.eq(sql(&count_sql)))
-        .execute(conn)?;
+    update(h::table.filter(h::id.eq(site.id)))
+        .set(h::entity_count.eq(sql(&count_sql)))
+        .execute(conn)
+        .await?;
     Ok(())
 }
 
-/// Set the deployment's entity count to whatever `full_count_query` produces
-pub fn set_entity_count(
-    conn: &PgConnection,
+/// Set the deployment's entity count back to `0`
+pub async fn clear_entity_count(
+    conn: &mut AsyncPgConnection,
     site: &Site,
-    full_count_query: &str,
 ) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+    use head as h;
 
-    let full_count_query = format!("({})", full_count_query);
-    update(d::table.filter(d::id.eq(site.id)))
-        .set(d::entity_count.eq(sql(&full_count_query)))
-        .execute(conn)?;
+    update(h::table.filter(h::id.eq(site.id)))
+        .set(h::entity_count.eq(0))
+        .execute(conn)
+        .await?;
     Ok(())
 }
 
@@ -1193,61 +1420,76 @@ pub fn set_entity_count(
 /// go backwards, only forward. This is important so that copying into
 /// `site` can not move the earliest block backwards if `site` was also
 /// pruned while the copy was running.
-pub fn set_earliest_block(
-    conn: &PgConnection,
+pub async fn set_earliest_block(
+    conn: &mut AsyncPgConnection,
     site: &Site,
     earliest_block: BlockNumber,
 ) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+    use deployment as d;
 
     update(d::table.filter(d::id.eq(site.id)))
         .set(d::earliest_block_number.eq(earliest_block))
         .filter(d::earliest_block_number.lt(earliest_block))
-        .execute(conn)?;
+        .execute(conn)
+        .await?;
     Ok(())
 }
 
 /// Copy the `earliest_block` attribute from `src` to `dst`. The copy might
 /// go across shards and use the metadata tables mapped into the shard for
 /// `conn` which must be the shard for `dst`
-pub fn copy_earliest_block(conn: &PgConnection, src: &Site, dst: &Site) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+pub async fn copy_earliest_block(
+    conn: &mut AsyncPgConnection,
+    src: &Site,
+    dst: &Site,
+) -> Result<(), StoreError> {
+    use deployment as d;
 
     let src_nsp = ForeignServer::metadata_schema_in(&src.shard, &dst.shard);
 
     let query = format!(
-        "(select earliest_block_number from {src_nsp}.subgraph_deployment where id = {})",
+        "(select earliest_block_number from {src_nsp}.deployment where id = {})",
         src.id
     );
 
     update(d::table.filter(d::id.eq(dst.id)))
         .set(d::earliest_block_number.eq(sql(&query)))
-        .execute(conn)?;
+        .execute(conn)
+        .await?;
 
     Ok(())
 }
 
-pub fn on_sync(conn: &PgConnection, id: impl Into<DeploymentId>) -> Result<OnSync, StoreError> {
+pub async fn on_sync(
+    conn: &mut AsyncPgConnection,
+    id: impl Into<DeploymentId>,
+) -> Result<OnSync, StoreError> {
     use subgraph_manifest as m;
 
     let s = m::table
         .filter(m::id.eq(id.into()))
         .select(m::on_sync)
-        .get_result::<Option<String>>(conn)?;
+        .get_result::<Option<String>>(conn)
+        .await?;
     OnSync::try_from(s.as_deref())
 }
 
-pub fn set_on_sync(conn: &PgConnection, site: &Site, on_sync: OnSync) -> Result<(), StoreError> {
+pub async fn set_on_sync(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+    on_sync: OnSync,
+) -> Result<(), StoreError> {
     use subgraph_manifest as m;
 
     let n = update(m::table.filter(m::id.eq(site.id)))
         .set(m::on_sync.eq(on_sync.to_sql()))
-        .execute(conn)?;
+        .execute(conn)
+        .await?;
 
     match n {
         0 => Err(StoreError::DeploymentNotFound(site.to_string())),
         1 => Ok(()),
-        _ => Err(constraint_violation!(
+        _ => Err(internal_error!(
             "multiple manifests for deployment {}",
             site.to_string()
         )),
@@ -1259,15 +1501,19 @@ pub fn set_on_sync(conn: &PgConnection, site: &Site, on_sync: OnSync) -> Result<
 /// while other write activity for that deployment is locked out. Block the
 /// current thread until we can acquire the lock.
 //  see also: deployment-lock-for-update
-pub fn with_lock<F, R>(conn: &PgConnection, site: &Site, f: F) -> Result<R, StoreError>
+pub async fn with_lock<F, R>(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+    f: F,
+) -> Result<R, StoreError>
 where
-    F: FnOnce() -> Result<R, StoreError>,
+    F: AsyncFnOnce(&mut AsyncPgConnection) -> Result<R, StoreError>,
 {
     let mut backoff = ExponentialBackoff::new(Duration::from_millis(100), Duration::from_secs(15));
-    while !advisory_lock::lock_deployment_session(conn, site)? {
+    while !advisory_lock::lock_deployment_session(conn, site).await? {
         backoff.sleep();
     }
-    let res = f();
-    advisory_lock::unlock_deployment_session(conn, site)?;
+    let res = f(conn).await;
+    advisory_lock::unlock_deployment_session(conn, site).await?;
     res
 }
diff --git a/store/postgres/src/deployment_store.rs b/store/postgres/src/deployment_store.rs
index 5d96031f2d0..d764d451ad6 100644
--- a/store/postgres/src/deployment_store.rs
+++ b/store/postgres/src/deployment_store.rs
@@ -1,61 +1,62 @@
 use detail::DeploymentDetail;
-use diesel::connection::SimpleConnection;
-use diesel::pg::PgConnection;
-use diesel::prelude::*;
-use diesel::r2d2::{ConnectionManager, PooledConnection};
+use diesel::sql_query;
+use diesel_async::{AsyncConnection as _, RunQueryDsl, SimpleAsyncConnection};
+use graph::util::backoff::ExponentialBackoff;
+use tokio::task::JoinHandle;
+
 use graph::anyhow::Context;
-use graph::blockchain::block_stream::FirehoseCursor;
 use graph::blockchain::BlockTime;
+use graph::blockchain::block_stream::{EntitySourceOperation, FirehoseCursor};
 use graph::components::store::write::RowGroup;
 use graph::components::store::{
-    Batch, DerivedEntityQuery, PrunePhase, PruneReporter, PruneRequest, PruningStrategy,
-    QueryPermit, StoredDynamicDataSource, VersionStats,
+    Batch, DeploymentLocator, DerivedEntityQuery, DumpReporter, PrunePhase, PruneReporter,
+    PruneRequest, PruningStrategy, QueryPermit, RestoreReporter, StoredDynamicDataSource,
+    VersionStats,
 };
 use graph::components::versions::VERSIONS;
+use graph::data::graphql::IntoValue;
 use graph::data::query::Trace;
-use graph::data::store::{Id, IdList};
-use graph::data::subgraph::{status, SPEC_VERSION_0_0_6};
+use graph::data::store::{IdList, SqlQueryObject};
+use graph::data::subgraph::{SPEC_VERSION_0_0_6, status};
 use graph::data_source::CausalityRegion;
-use graph::prelude::futures03::FutureExt;
-use graph::prelude::{
-    ApiVersion, CancelHandle, CancelToken, CancelableError, EntityOperation, PoolWaitStats,
-    SubgraphDeploymentEntity,
-};
+use graph::derive::CheapClone;
+use graph::futures03::FutureExt;
+use graph::prelude::alloy::primitives::Address;
+use graph::prelude::{ApiVersion, EntityOperation, PoolWaitStats, SubgraphDeploymentEntity};
 use graph::semver::Version;
-use graph::tokio::task::JoinHandle;
 use itertools::Itertools;
 use lru_time_cache::LruCache;
-use rand::{seq::SliceRandom, thread_rng};
+use rand::{rng, seq::SliceRandom};
 use std::collections::{BTreeMap, HashMap};
 use std::convert::Into;
 use std::ops::Bound;
-use std::ops::Deref;
+use std::ops::{Deref, Range};
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
-use std::sync::{atomic::AtomicUsize, Arc, Mutex};
+use std::sync::{Arc, Mutex, atomic::AtomicUsize};
 use std::time::{Duration, Instant};
 
 use graph::components::store::EntityCollection;
 use graph::components::subgraph::{ProofOfIndexingFinisher, ProofOfIndexingVersion};
-use graph::constraint_violation;
 use graph::data::subgraph::schema::{DeploymentCreate, SubgraphError};
+use graph::internal_error;
 use graph::prelude::{
-    anyhow, debug, info, o, warn, web3, AttributeNames, BlockNumber, BlockPtr, CheapClone,
-    DeploymentHash, DeploymentState, Entity, EntityQuery, Error, Logger, QueryExecutionError,
-    StopwatchMetrics, StoreError, StoreEvent, UnfailOutcome, Value, ENV_VARS,
+    AttributeNames, BlockNumber, BlockPtr, CheapClone, DeploymentHash, DeploymentState, ENV_VARS,
+    Entity, EntityQuery, Error, Logger, QueryExecutionError, StopwatchMetrics, StoreError,
+    UnfailOutcome, Value, anyhow, debug, error, info, o, warn,
 };
 use graph::schema::{ApiSchema, EntityKey, EntityType, InputSchema};
-use web3::types::Address;
 
 use crate::block_range::{BLOCK_COLUMN, BLOCK_RANGE_COLUMN};
 use crate::deployment::{self, OnSync};
 use crate::detail::ErrorDetail;
 use crate::dynds::DataSourcesTable;
-use crate::primary::DeploymentId;
-use crate::relational::index::{CreateIndex, Method};
-use crate::relational::{Layout, LayoutCache, SqlName, Table};
-use crate::relational_queries::FromEntityData;
-use crate::{advisory_lock, catalog, retry};
-use crate::{connection_pool::ConnectionPool, detail};
+use crate::primary::{DeploymentId, Primary};
+use crate::relational::index::{CreateIndex, IndexCreator, IndexList, Method};
+use crate::relational::{self, Layout, LayoutCache, STATEMENT_TIMEOUT, SqlName, Table};
+use crate::relational_queries::{FromEntityData, JSONData};
+use crate::{AsyncPgConnection, advisory_lock, catalog, retry};
+use crate::{ConnectionPool, detail};
 use crate::{dynds, primary::Site};
 
 /// When connected to read replicas, this allows choosing which DB server to use for an operation.
@@ -73,8 +74,6 @@ pub enum ReplicaId {
 /// way as the cache lives for the lifetime of the `Store` object
 #[derive(Clone)]
 pub(crate) struct SubgraphInfo {
-    /// The schema as supplied by the user
-    pub(crate) input: InputSchema,
     /// The schema we derive from `input` with `graphql::schema::api::api_schema`
     pub(crate) api: HashMap<ApiVersion, Arc<ApiSchema>>,
     /// The block number at which this subgraph was grafted onto
@@ -94,6 +93,8 @@ type PruneHandle = JoinHandle<Result<(), StoreError>>;
 pub struct StoreInner {
     logger: Logger,
 
+    primary: Primary,
+
     pool: ConnectionPool,
     read_only_pools: Vec<ConnectionPool>,
 
@@ -118,11 +119,9 @@ pub struct StoreInner {
 
 /// Storage of the data for individual deployments. Each `DeploymentStore`
 /// corresponds to one of the database shards that `SubgraphStore` manages.
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 pub struct DeploymentStore(Arc<StoreInner>);
 
-impl CheapClone for DeploymentStore {}
-
 impl Deref for DeploymentStore {
     type Target = StoreInner;
     fn deref(&self) -> &Self::Target {
@@ -133,6 +132,7 @@ impl Deref for DeploymentStore {
 impl DeploymentStore {
     pub fn new(
         logger: &Logger,
+        primary: Primary,
         pool: ConnectionPool,
         read_only_pools: Vec<ConnectionPool>,
         mut pool_weights: Vec<usize>,
@@ -156,13 +156,14 @@ impl DeploymentStore {
                 vec![replica; *weight]
             })
             .collect();
-        let mut rng = thread_rng();
+        let mut rng = rng();
         replica_order.shuffle(&mut rng);
         debug!(logger, "Using postgres host order {:?}", replica_order);
 
         // Create the store
         let store = StoreInner {
             logger: logger.clone(),
+            primary,
             pool,
             read_only_pools,
             replica_order,
@@ -175,18 +176,17 @@ impl DeploymentStore {
         DeploymentStore(Arc::new(store))
     }
 
-    pub(crate) fn create_deployment(
+    pub(crate) async fn create_deployment(
         &self,
         schema: &InputSchema,
         deployment: DeploymentCreate,
         site: Arc<Site>,
-        graft_base: Option<Arc<Layout>>,
         replace: bool,
         on_sync: OnSync,
     ) -> Result<(), StoreError> {
-        let conn = self.get_conn()?;
-        conn.transaction(|| -> Result<_, StoreError> {
-            let exists = deployment::exists(&conn, &site)?;
+        let mut conn = self.pool.get_permitted().await?;
+        conn.transaction::<_, StoreError, _>(async |conn| {
+            let exists = deployment::exists(conn, &site).await?;
 
             // Create (or update) the metadata. Update only happens in tests
             let entities_with_causality_region =
@@ -202,123 +202,135 @@ impl DeploymentStore {
                 };
 
             if replace || !exists {
-                deployment::create_deployment(&conn, &site, deployment, exists, replace)?;
+                deployment::create_deployment(conn, &site, deployment, exists, replace).await?;
             };
 
             // Create the schema for the subgraph data
             if !exists {
                 let query = format!("create schema {}", &site.namespace);
-                conn.batch_execute(&query)?;
+                conn.batch_execute(&query).await?;
 
-                let layout = Layout::create_relational_schema(
-                    &conn,
+                let _ = Layout::create_relational_schema(
+                    conn,
                     site.clone(),
                     schema,
                     entities_with_causality_region.into_iter().collect(),
-                )?;
-                // See if we are grafting and check that the graft is permissible
-                if let Some(base) = graft_base {
-                    let errors = layout.can_copy_from(&base);
-                    if !errors.is_empty() {
-                        return Err(StoreError::Unknown(anyhow!(
-                            "The subgraph `{}` cannot be used as the graft base \
-                             for `{}` because the schemas are incompatible:\n    - {}",
-                            &base.catalog.site.namespace,
-                            &layout.catalog.site.namespace,
-                            errors.join("\n    - ")
-                        )));
-                    }
-                }
+                )
+                .await?;
 
                 // Create data sources table
                 if site.schema_version.private_data_sources() {
-                    conn.batch_execute(&DataSourcesTable::new(site.namespace.clone()).as_ddl())?;
+                    conn.batch_execute(&DataSourcesTable::new(site.namespace.clone()).as_ddl())
+                        .await?;
                 }
             }
 
-            deployment::set_on_sync(&conn, &site, on_sync)?;
+            deployment::set_on_sync(conn, &site, on_sync).await?;
 
             Ok(())
         })
+        .await
     }
 
-    pub(crate) fn load_deployment(
+    pub(crate) async fn load_deployment(
         &self,
         site: Arc<Site>,
     ) -> Result<SubgraphDeploymentEntity, StoreError> {
-        let conn = self.get_conn()?;
-        let layout = self.layout(&conn, site.clone())?;
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site.clone()).await?;
         Ok(
-            detail::deployment_entity(&conn, &site, &layout.input_schema)
+            detail::deployment_entity(&mut conn, &site, &layout.input_schema)
+                .await
                 .with_context(|| format!("Deployment details not found for {}", site.deployment))?,
         )
     }
 
     // Remove the data and metadata for the deployment `site`. This operation
     // is not reversible
-    pub(crate) fn drop_deployment(&self, site: &Site) -> Result<(), StoreError> {
-        let conn = self.get_conn()?;
-        conn.transaction(|| {
-            crate::deployment::drop_schema(&conn, &site.namespace)?;
+    pub(crate) async fn drop_deployment(&self, site: &Site) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        conn.transaction(async |conn| {
+            crate::deployment::drop_schema(conn, &site.namespace).await?;
             if !site.schema_version.private_data_sources() {
-                crate::dynds::shared::drop(&conn, &site.deployment)?;
+                crate::dynds::shared::drop(conn, &site.deployment).await?;
             }
-            crate::deployment::drop_metadata(&conn, site)
+            crate::deployment::drop_metadata(conn, site).await
         })
+        .await
     }
 
-    pub(crate) fn execute_query<T: FromEntityData>(
+    pub(crate) async fn execute_query<T: FromEntityData>(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
         query: EntityQuery,
     ) -> Result<(Vec<T>, Trace), QueryExecutionError> {
-        let layout = self.layout(conn, site)?;
+        let layout = self.layout(conn, site).await?;
 
         let logger = query
             .logger
             .cheap_clone()
             .unwrap_or_else(|| self.logger.cheap_clone());
-        layout.query(&logger, conn, query)
+        layout.query(&logger, conn, query).await
     }
 
-    fn check_interface_entity_uniqueness(
+    pub(crate) async fn execute_sql(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
+        query: &str,
+    ) -> Result<Vec<SqlQueryObject>, QueryExecutionError> {
+        let query = format!(
+            "select to_jsonb(sub.*) as data from ({}) as sub limit {}",
+            query, ENV_VARS.graphql.max_first
+        );
+        let query = diesel::sql_query(query);
+
+        let results = conn
+            .transaction(async |conn| {
+                if let Some(ref timeout_sql) = *STATEMENT_TIMEOUT {
+                    conn.batch_execute(timeout_sql).await?;
+                }
+
+                // Execute the provided SQL query
+                query.load::<JSONData>(conn).await
+            })
+            .await
+            .map_err(|e| QueryExecutionError::SqlError(e.to_string()))?;
+
+        Ok(results
+            .into_iter()
+            .map(|e| SqlQueryObject(e.into_value()))
+            .collect::<Vec<_>>())
+    }
+
+    async fn check_intf_uniqueness(
+        &self,
+        conn: &mut AsyncPgConnection,
         layout: &Layout,
-        entity_type: &EntityType,
-        entity_id: &Id,
+        group: &RowGroup,
     ) -> Result<(), StoreError> {
-        // Collect all types that share an interface implementation with this
-        // entity type, and make sure there are no conflicting IDs.
-        //
-        // To understand why this is necessary, suppose that `Dog` and `Cat` are
-        // types and both implement an interface `Pet`, and both have instances
-        // with `id: "Fred"`. If a type `PetOwner` has a field `pets: [Pet]`
-        // then with the value `pets: ["Fred"]`, there's no way to disambiguate
-        // if that's Fred the Dog, Fred the Cat or both.
-        //
-        // This assumes that there are no concurrent writes to a subgraph.
-        let entity_type_str = entity_type.to_string();
-        let types_with_shared_interface = entity_type.share_interfaces()?;
-
-        if !types_with_shared_interface.is_empty() {
-            if let Some(conflicting_entity) =
-                layout.conflicting_entity(conn, entity_id, types_with_shared_interface)?
-            {
-                return Err(StoreError::ConflictingId(
-                    entity_type_str,
-                    entity_id.to_string(),
-                    conflicting_entity,
-                ));
-            }
+        let types_with_shared_interface = group.entity_type.share_interfaces()?;
+        if types_with_shared_interface.is_empty() {
+            return Ok(());
+        }
+
+        if let Some((conflicting_entity, id)) = layout
+            .conflicting_entities(conn, &types_with_shared_interface, group)
+            .await?
+        {
+            return Err(StoreError::ConflictingId(
+                group.entity_type.to_string(),
+                id,
+                conflicting_entity,
+            ));
         }
         Ok(())
     }
 
-    fn apply_entity_modifications<'a>(
+    async fn apply_entity_modifications<'a>(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
+        logger: &Logger,
         layout: &Layout,
         groups: impl Iterator<Item = &'a RowGroup>,
         stopwatch: &StopwatchMetrics,
@@ -331,101 +343,41 @@ impl DeploymentStore {
             // Clamp entities before inserting them to avoid having versions
             // with overlapping block ranges
             let section = stopwatch.start_section("apply_entity_modifications_delete");
-            layout.delete(conn, group, stopwatch)?;
+            layout.delete(conn, group, stopwatch).await?;
             section.end();
 
             let section = stopwatch.start_section("check_interface_entity_uniqueness");
-            for row in group.writes().filter(|emod| emod.creates_entity()) {
-                // WARNING: This will potentially execute 2 queries for each entity key.
-                self.check_interface_entity_uniqueness(conn, layout, &group.entity_type, row.id())?;
-            }
+            self.check_intf_uniqueness(conn, layout, group).await?;
             section.end();
 
             let section = stopwatch.start_section("apply_entity_modifications_insert");
-            layout.insert(conn, group, stopwatch)?;
+            layout.insert(logger, conn, group, stopwatch).await?;
             section.end();
         }
 
         Ok(count)
     }
 
-    /// Execute a closure with a connection to the database.
-    ///
-    /// # API
-    ///   The API of using a closure to bound the usage of the connection serves several
-    ///   purposes:
-    ///
-    ///   * Moves blocking database access out of the `Future::poll`. Within
-    ///     `Future::poll` (which includes all `async` methods) it is illegal to
-    ///     perform a blocking operation. This includes all accesses to the
-    ///     database, acquiring of locks, etc. Calling a blocking operation can
-    ///     cause problems with `Future` combinators (including but not limited
-    ///     to select, timeout, and FuturesUnordered) and problems with
-    ///     executors/runtimes. This method moves the database work onto another
-    ///     thread in a way which does not block `Future::poll`.
-    ///
-    ///   * Limit the total number of connections. Because the supplied closure
-    ///     takes a reference, we know the scope of the usage of all entity
-    ///     connections and can limit their use in a non-blocking way.
-    ///
-    /// # Cancellation
-    ///   The normal pattern for futures in Rust is drop to cancel. Once we
-    ///   spawn the database work in a thread though, this expectation no longer
-    ///   holds because the spawned task is the independent of this future. So,
-    ///   this method provides a cancel token which indicates that the `Future`
-    ///   has been dropped. This isn't *quite* as good as drop on cancel,
-    ///   because a drop on cancel can do things like cancel http requests that
-    ///   are in flight, but checking for cancel periodically is a significant
-    ///   improvement.
-    ///
-    ///   The implementation of the supplied closure should check for cancel
-    ///   between every operation that is potentially blocking. This includes
-    ///   any method which may interact with the database. The check can be
-    ///   conveniently written as `token.check_cancel()?;`. It is low overhead
-    ///   to check for cancel, so when in doubt it is better to have too many
-    ///   checks than too few.
-    ///
-    /// # Panics:
-    ///   * This task will panic if the supplied closure panics
-    ///   * This task will panic if the supplied closure returns Err(Cancelled)
-    ///     when the supplied cancel token is not cancelled.
-    pub(crate) async fn with_conn<T: Send + 'static>(
-        &self,
-        f: impl 'static
-            + Send
-            + FnOnce(
-                &PooledConnection<ConnectionManager<PgConnection>>,
-                &CancelHandle,
-            ) -> Result<T, CancelableError<StoreError>>,
-    ) -> Result<T, StoreError> {
-        self.pool.with_conn(f).await
-    }
-
-    /// Deprecated. Use `with_conn` instead.
-    fn get_conn(&self) -> Result<PooledConnection<ConnectionManager<PgConnection>>, StoreError> {
-        self.pool.get()
-    }
-
     /// Panics if `idx` is not a valid index for a read only pool.
-    fn read_only_conn(
-        &self,
-        idx: usize,
-    ) -> Result<PooledConnection<ConnectionManager<PgConnection>>, Error> {
-        self.read_only_pools[idx].get().map_err(Error::from)
+    async fn read_only_conn(&self, idx: usize) -> Result<crate::pool::PermittedConnection, Error> {
+        self.read_only_pools[idx]
+            .get_permitted()
+            .await
+            .map_err(Error::from)
     }
 
-    pub(crate) fn get_replica_conn(
+    pub(crate) async fn get_replica_conn(
         &self,
         replica: ReplicaId,
-    ) -> Result<PooledConnection<ConnectionManager<PgConnection>>, Error> {
+    ) -> Result<crate::pool::PermittedConnection, Error> {
         let conn = match replica {
-            ReplicaId::Main => self.get_conn()?,
-            ReplicaId::ReadOnly(idx) => self.read_only_conn(idx)?,
+            ReplicaId::Main => self.pool.get_permitted().await?,
+            ReplicaId::ReadOnly(idx) => self.read_only_conn(idx).await?,
         };
         Ok(conn)
     }
 
-    pub(crate) async fn query_permit(&self, replica: ReplicaId) -> Result<QueryPermit, StoreError> {
+    pub(crate) async fn query_permit(&self, replica: ReplicaId) -> QueryPermit {
         let pool = match replica {
             ReplicaId::Main => &self.pool,
             ReplicaId::ReadOnly(idx) => &self.read_only_pools[idx],
@@ -433,7 +385,7 @@ impl DeploymentStore {
         pool.query_permit().await
     }
 
-    pub(crate) fn wait_stats(&self, replica: ReplicaId) -> Result<PoolWaitStats, StoreError> {
+    pub(crate) fn wait_stats(&self, replica: ReplicaId) -> PoolWaitStats {
         match replica {
             ReplicaId::Main => self.pool.wait_stats(),
             ReplicaId::ReadOnly(idx) => self.read_only_pools[idx].wait_stats(),
@@ -446,41 +398,43 @@ impl DeploymentStore {
     /// the Store. Layout objects with a pending migration can not be
     /// cached for longer than a transaction since they might change
     /// without us knowing
-    pub(crate) fn layout(
+    pub(crate) async fn layout(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
     ) -> Result<Arc<Layout>, StoreError> {
-        self.layout_cache.get(&self.logger, conn, site)
+        self.layout_cache.get(&self.logger, conn, site).await
     }
 
     /// Return the layout for a deployment. This might use a database
     /// connection for the lookup and should only be called if the caller
     /// does not have a connection currently. If it does, use `layout`
-    pub(crate) fn find_layout(&self, site: Arc<Site>) -> Result<Arc<Layout>, StoreError> {
+    pub(crate) async fn find_layout(&self, site: Arc<Site>) -> Result<Arc<Layout>, StoreError> {
         if let Some(layout) = self.layout_cache.find(site.as_ref()) {
             return Ok(layout);
         }
 
-        let conn = self.get_conn()?;
-        self.layout(&conn, site)
+        let mut conn = self.pool.get_permitted().await?;
+        self.layout(&mut conn, site).await
     }
 
-    fn subgraph_info_with_conn(
+    async fn subgraph_info_with_conn(
         &self,
-        conn: &PgConnection,
-        site: &Site,
+        conn: &mut AsyncPgConnection,
+        site: Arc<Site>,
     ) -> Result<SubgraphInfo, StoreError> {
         if let Some(info) = self.subgraph_cache.lock().unwrap().get(&site.deployment) {
             return Ok(info.clone());
         }
 
-        let manifest_info = deployment::ManifestInfo::load(conn, site)?;
+        let layout = self.layout(conn, site.cheap_clone()).await?;
+        let manifest_info = deployment::ManifestInfo::load(conn, &site).await?;
 
-        let graft_block =
-            deployment::graft_point(conn, &site.deployment)?.map(|(_, ptr)| ptr.number);
+        let graft_block = deployment::graft_point(conn, &site.deployment)
+            .await?
+            .map(|(_, ptr)| ptr.number);
 
-        let debug_fork = deployment::debug_fork(conn, &site.deployment)?;
+        let debug_fork = deployment::debug_fork(conn, &site.deployment).await?;
 
         // Generate an API schema for the subgraph and make sure all types in the
         // API schema have a @subgraphId directive as well
@@ -488,7 +442,7 @@ impl DeploymentStore {
 
         for version in VERSIONS.iter() {
             let api_version = ApiVersion::from_version(version).expect("Invalid API version");
-            let schema = manifest_info.input_schema.api_schema()?;
+            let schema = layout.input_schema.api_schema()?;
             api.insert(api_version, Arc::new(schema));
         }
 
@@ -501,7 +455,6 @@ impl DeploymentStore {
         };
 
         let info = SubgraphInfo {
-            input: manifest_info.input_schema,
             api,
             graft_block,
             debug_fork,
@@ -511,93 +464,110 @@ impl DeploymentStore {
             instrument: manifest_info.instrument,
         };
 
-        // Insert the schema into the cache.
-        let mut cache = self.subgraph_cache.lock().unwrap();
-        cache.insert(site.deployment.clone(), info);
-
-        Ok(cache.get(&site.deployment).unwrap().clone())
+        if ENV_VARS.store.query_stats_refresh_interval > Duration::ZERO {
+            let mut cache = self.subgraph_cache.lock().unwrap();
+            cache.insert(site.deployment.clone(), info.clone());
+            Ok(cache.get(&site.deployment).unwrap().clone())
+        } else {
+            Ok(info)
+        }
     }
 
-    pub(crate) fn subgraph_info(&self, site: &Site) -> Result<SubgraphInfo, StoreError> {
+    pub(crate) async fn subgraph_info(&self, site: Arc<Site>) -> Result<SubgraphInfo, StoreError> {
         if let Some(info) = self.subgraph_cache.lock().unwrap().get(&site.deployment) {
             return Ok(info.clone());
         }
 
-        let conn = self.get_conn()?;
-        self.subgraph_info_with_conn(&conn, site)
+        let mut conn = self.pool.get_permitted().await?;
+        self.subgraph_info_with_conn(&mut conn, site).await
     }
 
-    fn block_ptr_with_conn(
-        conn: &PgConnection,
+    async fn block_ptr_with_conn(
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
     ) -> Result<Option<BlockPtr>, StoreError> {
-        deployment::block_ptr(conn, &site.deployment)
+        deployment::block_ptr(conn, &site).await
     }
 
-    pub(crate) fn deployment_details(
+    pub(crate) async fn deployment_details(
         &self,
         ids: Vec<String>,
     ) -> Result<Vec<DeploymentDetail>, StoreError> {
-        let conn = self.get_conn()?;
-        conn.transaction(|| -> Result<_, StoreError> { detail::deployment_details(&conn, ids) })
+        let conn = &mut self.pool.get_permitted().await?;
+        detail::deployment_details(conn, ids).await
+    }
+
+    pub async fn deployment_details_for_id(
+        &self,
+        locator: &DeploymentLocator,
+    ) -> Result<DeploymentDetail, StoreError> {
+        let id = DeploymentId::from(locator.clone());
+        let conn = &mut self.pool.get_permitted().await?;
+        detail::deployment_details_for_id(conn, &id).await
     }
 
-    pub(crate) fn deployment_statuses(
+    pub(crate) async fn deployment_statuses(
         &self,
         sites: &[Arc<Site>],
     ) -> Result<Vec<status::Info>, StoreError> {
-        let conn = self.get_conn()?;
-        conn.transaction(|| -> Result<Vec<status::Info>, StoreError> {
-            detail::deployment_statuses(&conn, sites)
-        })
+        let conn = &mut self.pool.get_permitted().await?;
+        detail::deployment_statuses(conn, sites).await
     }
 
-    pub(crate) fn deployment_exists_and_synced(
+    pub(crate) async fn deployment_exists_and_synced(
         &self,
         id: &DeploymentHash,
     ) -> Result<bool, StoreError> {
-        let conn = self.get_conn()?;
-        deployment::exists_and_synced(&conn, id.as_str())
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::exists_and_synced(&mut conn, id.as_str()).await
     }
 
-    pub(crate) fn deployment_synced(&self, id: &DeploymentHash) -> Result<(), StoreError> {
-        let conn = self.get_conn()?;
-        conn.transaction(|| deployment::set_synced(&conn, id))
+    pub(crate) async fn deployment_synced(
+        &self,
+        id: &DeploymentHash,
+        block_ptr: BlockPtr,
+    ) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        conn.transaction(async |conn| deployment::set_synced(conn, id, block_ptr).await)
+            .await
     }
 
     /// Look up the on_sync action for this deployment
-    pub(crate) fn on_sync(&self, site: &Site) -> Result<OnSync, StoreError> {
-        let conn = self.get_conn()?;
-        deployment::on_sync(&conn, site.id)
+    pub(crate) async fn on_sync(&self, site: &Site) -> Result<OnSync, StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::on_sync(&mut conn, site.id).await
     }
 
     /// Return the source if `site` or `None` if `site` is neither a graft
     /// nor a copy
-    pub(crate) fn source_of_copy(&self, site: &Site) -> Result<Option<DeploymentId>, StoreError> {
-        let conn = self.get_conn()?;
-        crate::copy::source(&conn, site)
+    pub(crate) async fn source_of_copy(
+        &self,
+        site: &Site,
+    ) -> Result<Option<DeploymentId>, StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        crate::copy::source(&mut conn, site).await
     }
 
     // Only used for tests
     #[cfg(debug_assertions)]
-    pub(crate) fn drop_deployment_schema(
+    pub(crate) async fn drop_deployment_schema(
         &self,
         namespace: &crate::primary::Namespace,
     ) -> Result<(), StoreError> {
-        let conn = self.get_conn()?;
-        deployment::drop_schema(&conn, namespace)
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::drop_schema(&mut conn, namespace).await
     }
 
     // Only used for tests
     #[cfg(debug_assertions)]
-    pub(crate) fn drop_all_metadata(&self) -> Result<(), StoreError> {
+    pub(crate) async fn drop_all_metadata(&self) -> Result<(), StoreError> {
         // Delete metadata entities in each shard
 
         // This needs to touch all the tables in the subgraphs schema
         const QUERY: &str = "
         delete from subgraphs.dynamic_ethereum_contract_data_source;
         delete from subgraphs.subgraph;
-        delete from subgraphs.subgraph_deployment;
+        delete from subgraphs.head;
         delete from subgraphs.subgraph_deployment_assignment;
         delete from subgraphs.subgraph_version;
         delete from subgraphs.subgraph_manifest;
@@ -606,55 +576,59 @@ impl DeploymentStore {
         delete from active_copies;
     ";
 
-        let conn = self.get_conn()?;
-        conn.batch_execute(QUERY)?;
-        conn.batch_execute("delete from deployment_schemas;")?;
+        let mut conn = self.pool.get_permitted().await?;
+        conn.batch_execute(QUERY).await?;
+        conn.batch_execute("delete from deployment_schemas;")
+            .await?;
         Ok(())
     }
 
     pub(crate) async fn vacuum(&self) -> Result<(), StoreError> {
-        self.with_conn(|conn, _| {
-            conn.batch_execute("vacuum (analyze) subgraphs.subgraph_deployment")?;
-            Ok(())
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        conn.batch_execute("vacuum (analyze) subgraphs.head, subgraphs.deployment")
+            .await?;
+        Ok(())
     }
 
     /// Runs the SQL `ANALYZE` command in a table.
-    pub(crate) fn analyze(&self, site: Arc<Site>, entity: Option<&str>) -> Result<(), StoreError> {
-        let conn = self.get_conn()?;
-        let layout = self.layout(&conn, site)?;
+    pub(crate) async fn analyze(
+        &self,
+        site: Arc<Site>,
+        entity: Option<&str>,
+    ) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site).await?;
         let tables = entity
             .map(|entity| resolve_table_name(&layout, entity))
             .transpose()?
             .map(|table| vec![table])
             .unwrap_or_else(|| layout.tables.values().map(Arc::as_ref).collect());
         for table in tables {
-            table.analyze(&conn)?;
+            table.analyze(&mut conn).await?;
         }
         Ok(())
     }
 
-    pub(crate) fn stats_targets(
+    pub(crate) async fn stats_targets(
         &self,
         site: Arc<Site>,
     ) -> Result<(i32, BTreeMap<SqlName, BTreeMap<SqlName, i32>>), StoreError> {
-        let conn = self.get_conn()?;
-        let default = catalog::default_stats_target(&conn)?;
-        let targets = catalog::stats_targets(&conn, &site.namespace)?;
+        let mut conn = self.pool.get_permitted().await?;
+        let default = catalog::default_stats_target(&mut conn).await?;
+        let targets = catalog::stats_targets(&mut conn, &site.namespace).await?;
 
         Ok((default, targets))
     }
 
-    pub(crate) fn set_stats_target(
+    pub(crate) async fn set_stats_target(
         &self,
         site: Arc<Site>,
         entity: Option<&str>,
         columns: Vec<String>,
         target: i32,
     ) -> Result<(), StoreError> {
-        let conn = self.get_conn()?;
-        let layout = self.layout(&conn, site.clone())?;
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site.clone()).await?;
 
         let tables = entity
             .map(|entity| resolve_table_name(&layout, entity))
@@ -662,28 +636,30 @@ impl DeploymentStore {
             .map(|table| vec![table])
             .unwrap_or_else(|| layout.tables.values().map(Arc::as_ref).collect());
 
-        conn.transaction(|| {
+        conn.transaction(async |conn| {
             for table in tables {
                 let (columns, _) = resolve_column_names_and_index_exprs(table, &columns)?;
 
-                catalog::set_stats_target(&conn, &site.namespace, &table.name, &columns, target)?;
+                catalog::set_stats_target(conn, &site.namespace, &table.name, &columns, target)
+                    .await?;
             }
             Ok(())
         })
+        .await
     }
 
     /// Runs the SQL `ANALYZE` command in a table, with a shared connection.
-    pub(crate) fn analyze_with_conn(
+    pub(crate) async fn analyze_with_conn(
         &self,
         site: Arc<Site>,
         entity_name: &str,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
     ) -> Result<(), StoreError> {
         let store = self.clone();
         let entity_name = entity_name.to_owned();
-        let layout = store.layout(conn, site)?;
+        let layout = store.layout(conn, site).await?;
         let table = resolve_table_name(&layout, &entity_name)?;
-        table.analyze(conn)
+        table.analyze(conn).await
     }
 
     /// Creates a new index in the specified Entity table if it doesn't already exist.
@@ -699,59 +675,26 @@ impl DeploymentStore {
     ) -> Result<(), StoreError> {
         let store = self.clone();
         let entity_name = entity_name.to_owned();
-        self.with_conn(move |conn, _| {
-            let schema_name = site.namespace.clone();
-            let layout = store.layout(conn, site)?;
-            let table = resolve_table_name(&layout, &entity_name)?;
-            let (column_names, index_exprs) =
-                resolve_column_names_and_index_exprs(table, &field_names)?;
-
-            let column_names_sep_by_underscores = column_names.join("_");
-            let index_exprs_joined = index_exprs.join(", ");
-            let table_name = &table.name;
-            let index_name = format!(
-                "manual_{table_name}_{column_names_sep_by_underscores}{}",
-                after.map_or_else(String::new, |a| format!("_{}", a))
-            );
-
-            let mut sql = format!(
-                "create index concurrently if not exists {index_name} \
-                 on {schema_name}.{table_name} using {index_method} \
-                 ({index_exprs_joined}) ",
-            );
-
-            // If 'after' is provided and the table is not immutable, add a WHERE clause for partial indexing
-            if let Some(after) = after {
-                if !table.immutable {
-                    sql.push_str(&format!(
-                        " where coalesce(upper({}), 2147483647) > {}",
-                        BLOCK_RANGE_COLUMN, after
-                    ));
-                } else {
-                    return Err(CancelableError::Error(StoreError::Unknown(anyhow!(
-                        "Partial index not allowed on immutable table `{}`",
-                        table_name
-                    ))));
-                }
-            }
-
-            // This might take a long time.
-            conn.execute(&sql)?;
-            // check if the index creation was successfull
-            let index_is_valid =
-                catalog::check_index_is_valid(conn, schema_name.as_str(), &index_name)?;
-            if index_is_valid {
-                Ok(())
-            } else {
-                // Index creation falied. We should drop the index before returning.
-                let drop_index_sql =
-                    format!("drop index concurrently if exists {schema_name}.{index_name}");
-                conn.execute(&drop_index_sql)?;
-                Err(StoreError::Canceled)
-            }
-            .map_err(Into::into)
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        let schema_name = site.namespace.clone();
+        let layout = store.layout(&mut conn, site).await?;
+        let (index_name, sql) =
+            generate_index_creation_sql(layout, &entity_name, field_names, index_method, after)?;
+
+        // This might take a long time.
+        sql_query(sql).execute(&mut conn).await?;
+        // check if the index creation was successfull
+        let index_is_valid =
+            catalog::check_index_is_valid(&mut conn, schema_name.as_str(), &index_name).await?;
+        if index_is_valid {
+            Ok(())
+        } else {
+            // Index creation falied. We should drop the index before returning.
+            let drop_index_sql =
+                format!("drop index concurrently if exists {schema_name}.{index_name}");
+            sql_query(drop_index_sql).execute(&mut conn).await?;
+            Err(StoreError::Canceled)
+        }
     }
 
     /// Returns a list of all existing indexes for the specified Entity table.
@@ -762,17 +705,22 @@ impl DeploymentStore {
     ) -> Result<Vec<CreateIndex>, StoreError> {
         let store = self.clone();
         let entity_name = entity_name.to_owned();
-        self.with_conn(move |conn, _| {
-            let schema_name = site.namespace.clone();
-            let layout = store.layout(conn, site)?;
-            let table = resolve_table_name(&layout, &entity_name)?;
-            let table_name = &table.name;
-            let indexes =
-                catalog::indexes_for_table(conn, schema_name.as_str(), table_name.as_str())
-                    .map_err(StoreError::from)?;
-            Ok(indexes.into_iter().map(CreateIndex::parse).collect())
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        let schema_name = site.namespace.clone();
+        let layout = store.layout(&mut conn, site).await?;
+        let table = resolve_table_name(&layout, &entity_name)?;
+        let table_name = &table.name;
+        let indexes =
+            catalog::indexes_for_table(&mut conn, schema_name.as_str(), table_name.as_str())
+                .await?;
+        Ok(indexes.into_iter().map(CreateIndex::parse).collect())
+    }
+
+    pub(crate) async fn load_indexes(&self, site: Arc<Site>) -> Result<IndexList, StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site).await?;
+
+        IndexList::load(&mut conn, &layout).await
     }
 
     /// Drops an index for a given deployment, concurrently.
@@ -782,11 +730,52 @@ impl DeploymentStore {
         index_name: &str,
     ) -> Result<(), StoreError> {
         let index_name = String::from(index_name);
-        self.with_conn(move |conn, _| {
-            let schema_name = site.namespace.clone();
-            catalog::drop_index(conn, schema_name.as_str(), &index_name).map_err(Into::into)
+        let mut conn = self.pool.get_permitted().await?;
+        let schema_name = site.namespace.clone();
+        catalog::drop_index(&mut conn, schema_name.as_str(), &index_name).await
+    }
+
+    pub(crate) async fn identify_account_like_candidates(
+        &self,
+        min_versions: u64,
+        ratio: f64,
+    ) -> Result<Vec<(String, String)>, StoreError> {
+        #[derive(QueryableByName)]
+        struct TableStat {
+            #[diesel(sql_type = diesel::sql_types::Text)]
+            subgraph: String,
+            #[diesel(sql_type = diesel::sql_types::Text)]
+            table_name: String,
+        }
+
+        let mut conn = self.pool.get().await?;
+        let query = r#"
+                    SELECT
+                        stats.subgraph,
+                        stats.table_name
+                    FROM info.entity_version_stats AS stats
+                    LEFT JOIN subgraphs.table_stats ts
+                        ON ts.deployment = stats.deployment
+                        AND ts.table_name = stats.table_name
+                    WHERE
+                        stats.versions > $1
+                        AND stats.ratio < $2
+                        AND ts.is_account_like IS NOT TRUE
+                "#;
+
+        let result = diesel::sql_query(query)
+            .bind::<diesel::sql_types::BigInt, _>(min_versions as i64)
+            .bind::<diesel::sql_types::Double, _>(ratio)
+            .load::<TableStat>(&mut conn)
+            .await
+            .map_err(Into::into);
+
+        result.map(|tables| {
+            tables
+                .into_iter()
+                .map(|table_stat| (table_stat.subgraph, table_stat.table_name))
+                .collect()
         })
-        .await
     }
 
     pub(crate) async fn set_account_like(
@@ -797,22 +786,20 @@ impl DeploymentStore {
     ) -> Result<(), StoreError> {
         let store = self.clone();
         let table = table.to_string();
-        self.with_conn(move |conn, _| {
-            let layout = store.layout(conn, site.clone())?;
-            let table = resolve_table_name(&layout, &table)?;
-            catalog::set_account_like(conn, &site, &table.name, is_account_like).map_err(Into::into)
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = store.layout(&mut conn, site.clone()).await?;
+        let table = resolve_table_name(&layout, &table)?;
+        catalog::set_account_like(&mut conn, &site, &table.name, is_account_like).await
     }
 
-    pub(crate) fn set_history_blocks(
+    pub(crate) async fn set_history_blocks(
         &self,
         site: &Site,
         history_blocks: BlockNumber,
         reorg_threshold: BlockNumber,
     ) -> Result<(), StoreError> {
         if history_blocks <= reorg_threshold {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "the amount of history to keep for sgd{} can not be set to \
                  {history_blocks} since it must be more than the \
                  reorg threshold {reorg_threshold}",
@@ -824,8 +811,8 @@ impl DeploymentStore {
         // will use the updated value
         self.layout_cache.remove(site);
 
-        let conn = self.get_conn()?;
-        deployment::set_history_blocks(&conn, site, history_blocks)
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::set_history_blocks(&mut conn, site, history_blocks).await
     }
 
     pub(crate) async fn prune(
@@ -834,17 +821,15 @@ impl DeploymentStore {
         site: Arc<Site>,
         req: PruneRequest,
     ) -> Result<Box<dyn PruneReporter>, StoreError> {
-        fn do_prune(
+        async fn do_prune(
             store: Arc<DeploymentStore>,
-            conn: &PooledConnection<ConnectionManager<PgConnection>>,
+            conn: &mut AsyncPgConnection,
             site: Arc<Site>,
-            cancel: &CancelHandle,
             req: PruneRequest,
             mut reporter: Box<dyn PruneReporter>,
-        ) -> Result<Box<dyn PruneReporter>, CancelableError<StoreError>> {
-            let layout = store.layout(conn, site.clone())?;
-            cancel.check_cancel()?;
-            let state = deployment::state(conn, site.deployment.clone())?;
+        ) -> Result<Box<dyn PruneReporter>, StoreError> {
+            let layout = store.layout(conn, site.clone()).await?;
+            let state = deployment::state(conn, &site).await?;
 
             if state.latest_block.number <= req.history_blocks {
                 // We haven't accumulated enough history yet, nothing to prune
@@ -857,84 +842,122 @@ impl DeploymentStore {
                 return Ok(reporter);
             }
 
-            conn.transaction(|| {
-                deployment::set_earliest_block(conn, site.as_ref(), req.earliest_block)
-            })?;
-
-            cancel.check_cancel()?;
+            conn.transaction(async |conn| {
+                deployment::set_earliest_block(conn, site.as_ref(), req.earliest_block).await
+            })
+            .await?;
 
-            layout.prune(&store.logger, reporter.as_mut(), conn, &req, cancel)?;
+            layout
+                .prune(&store.logger, reporter.as_mut(), conn, &req)
+                .await?;
             Ok(reporter)
         }
 
         let store = self.clone();
-        self.with_conn(move |conn, cancel| {
-            // We lock pruning for this deployment to make sure that if the
-            // deployment is reassigned to another node, that node won't
-            // kick off a pruning run while this node might still be pruning
-            if advisory_lock::try_lock_pruning(conn, &site)? {
-                let res = do_prune(store, conn, site.cheap_clone(), cancel, req, reporter);
-                advisory_lock::unlock_pruning(conn, &site)?;
-                res
-            } else {
-                Ok(reporter)
-            }
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        // We lock pruning for this deployment to make sure that if the
+        // deployment is reassigned to another node, that node won't
+        // kick off a pruning run while this node might still be pruning
+        if advisory_lock::try_lock_pruning(&mut conn, &site).await? {
+            let res = do_prune(store, &mut conn, site.cheap_clone(), req, reporter).await;
+            advisory_lock::unlock_pruning(&mut conn, &site).await?;
+            res
+        } else {
+            Ok(reporter)
+        }
+    }
+
+    pub(crate) async fn prune_viewer(
+        self: &Arc<Self>,
+        site: Arc<Site>,
+    ) -> Result<relational::prune::Viewer, StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site.clone()).await?;
+
+        Ok(relational::prune::Viewer::new(self.pool.clone(), layout))
+    }
+
+    pub(crate) async fn dump(
+        &self,
+        site: Arc<Site>,
+        dir: PathBuf,
+        mut reporter: Box<dyn DumpReporter>,
+    ) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        // Layout and index list are schema metadata — safe to load outside
+        // the snapshot transaction
+        let layout = self.layout(&mut conn, site.cheap_clone()).await?;
+        let index_list = IndexList::load(&mut conn, &layout).await?;
+
+        // Use REPEATABLE READ to get a consistent MVCC snapshot for the
+        // entire dump. All queries inside see the same database state,
+        // regardless of concurrent indexing or pruning.
+        conn.build_transaction()
+            .repeatable_read()
+            .read_only()
+            .run(async move |conn| {
+                let entity_count = crate::detail::entity_count(conn, &site).await?;
+                layout
+                    .dump(
+                        conn,
+                        index_list,
+                        dir,
+                        &site.network,
+                        entity_count,
+                        &mut *reporter,
+                    )
+                    .await
+            })
+            .await
+    }
+
+    pub(crate) async fn restore(
+        &self,
+        site: Arc<Site>,
+        dir: &Path,
+        metadata: &crate::relational::dump::Metadata,
+        reporter: &mut dyn RestoreReporter,
+    ) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        reporter.start_create_schema(site.namespace.as_str(), site.shard.as_str());
+        let layout =
+            crate::relational::restore::create_schema(&mut conn, site, metadata, dir).await?;
+        reporter.finish_create_schema();
+        crate::relational::restore::import_data(&mut conn, &layout, metadata, dir, reporter)
+            .await?;
+        crate::relational::restore::finalize(&mut conn, &layout, metadata, reporter).await?;
+        reporter.finish();
+        Ok(())
     }
 }
 
-/// Methods that back the trait `graph::components::Store`, but have small
-/// variations in their signatures
+/// Methods that back the trait `WritableStore`, but have small variations in their signatures
 impl DeploymentStore {
     pub(crate) async fn block_ptr(&self, site: Arc<Site>) -> Result<Option<BlockPtr>, StoreError> {
         let site = site.cheap_clone();
 
-        self.with_conn(|conn, cancel| {
-            cancel.check_cancel()?;
-
-            Self::block_ptr_with_conn(conn, site).map_err(Into::into)
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        Self::block_ptr_with_conn(&mut conn, site).await
     }
 
     pub(crate) async fn block_cursor(&self, site: Arc<Site>) -> Result<FirehoseCursor, StoreError> {
         let site = site.cheap_clone();
 
-        self.with_conn(|conn, cancel| {
-            cancel.check_cancel()?;
-
-            deployment::get_subgraph_firehose_cursor(conn, site)
-                .map(FirehoseCursor::from)
-                .map_err(Into::into)
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::get_subgraph_firehose_cursor(&mut conn, site)
+            .await
+            .map(FirehoseCursor::from)
     }
 
-    pub(crate) fn block_time(
+    pub(crate) async fn block_time(
         &self,
         site: Arc<Site>,
-        block: BlockNumber,
     ) -> Result<Option<BlockTime>, StoreError> {
         let store = self.cheap_clone();
 
-        let conn = self.get_conn()?;
-        let layout = store.layout(&conn, site.cheap_clone())?;
-        layout.block_time(&conn, block)
-    }
-
-    pub(crate) async fn supports_proof_of_indexing<'a>(
-        &self,
-        site: Arc<Site>,
-    ) -> Result<bool, StoreError> {
-        let store = self.clone();
-        self.with_conn(move |conn, cancel| {
-            cancel.check_cancel()?;
-            let layout = store.layout(conn, site)?;
-            Ok(layout.supports_proof_of_indexing())
-        })
-        .await
-        .map_err(Into::into)
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = store.layout(&mut conn, site.cheap_clone()).await?;
+        layout.last_rollup(&mut conn).await
     }
 
     pub(crate) async fn get_proof_of_indexing(
@@ -946,68 +969,57 @@ impl DeploymentStore {
         let indexer = *indexer;
         let site2 = site.cheap_clone();
         let store = self.cheap_clone();
-        let info = self.subgraph_info(&site)?;
-        let poi_digest = info.input.poi_digest();
+        let layout = self.find_layout(site.cheap_clone()).await?;
+        let info = self.subgraph_info(site.cheap_clone()).await?;
+        let poi_digest = layout.input_schema.poi_digest();
 
-        let entities: Option<(Vec<Entity>, BlockPtr)> = self
-            .with_conn(move |conn, cancel| {
-                let site = site.clone();
-                cancel.check_cancel()?;
+        let mut conn = self.pool.get_permitted().await?;
+        let entities: Option<(Vec<Entity>, BlockPtr)> = {
+            let site = site.clone();
 
-                let layout = store.layout(conn, site.cheap_clone())?;
+            let layout = store.layout(&mut conn, site.cheap_clone()).await?;
 
-                if !layout.supports_proof_of_indexing() {
-                    return Ok(None);
-                }
-
-                conn.transaction::<_, CancelableError<anyhow::Error>, _>(move || {
-                    let mut block_ptr = block.cheap_clone();
-                    let latest_block_ptr =
-                        match Self::block_ptr_with_conn(conn, site.cheap_clone())? {
-                            Some(inner) => inner,
-                            None => return Ok(None),
-                        };
-
-                    cancel.check_cancel()?;
+            let mut block_ptr = block.cheap_clone();
+            let latest_block_ptr =
+                match Self::block_ptr_with_conn(&mut conn, site.cheap_clone()).await? {
+                    Some(inner) => inner,
+                    None => return Ok(None),
+                };
 
-                    // FIXME: (Determinism)
-                    //
-                    // It is vital to ensure that the block hash given in the query
-                    // is a parent of the latest block indexed for the subgraph.
-                    // Unfortunately the machinery needed to do this is not yet in place.
-                    // The best we can do right now is just to make sure that the block number
-                    // is high enough.
-                    if latest_block_ptr.number < block.number {
-                        // If a subgraph has failed deterministically then any blocks past head
-                        // should return the same POI
-                        let fatal_error = ErrorDetail::fatal(conn, &site.deployment)?;
-                        block_ptr = match fatal_error {
-                            Some(se) => TryInto::<SubgraphError>::try_into(se)?
-                                .block_ptr
-                                .unwrap_or(block_ptr),
-                            None => return Ok(None),
-                        };
-                    };
-
-                    let query = EntityQuery::new(
-                        site.deployment.cheap_clone(),
-                        block_ptr.number,
-                        EntityCollection::All(vec![(
-                            info.input.poi_type().clone(),
-                            AttributeNames::All,
-                        )]),
-                    );
-                    let entities = store
-                        .execute_query::<Entity>(conn, site, query)
-                        .map(|(entities, _)| entities)
-                        .map_err(anyhow::Error::from)?;
-
-                    Ok(Some((entities, block_ptr)))
-                })
-                .map_err(Into::into)
-            })
-            .await?;
+            // FIXME: (Determinism)
+            //
+            // It is vital to ensure that the block hash given in the query
+            // is a parent of the latest block indexed for the subgraph.
+            // Unfortunately the machinery needed to do this is not yet in place.
+            // The best we can do right now is just to make sure that the block number
+            // is high enough.
+            if latest_block_ptr.number < block.number {
+                // If a subgraph has failed deterministically then any blocks past head
+                // should return the same POI
+                let fatal_error = ErrorDetail::fatal(&mut conn, &site.deployment).await?;
+                block_ptr = match fatal_error {
+                    Some(se) => TryInto::<SubgraphError>::try_into(se)?
+                        .block_ptr
+                        .unwrap_or(block_ptr),
+                    None => return Ok(None),
+                };
+            };
 
+            let query = EntityQuery::new(
+                site.deployment.cheap_clone(),
+                block_ptr.number,
+                EntityCollection::All(vec![(
+                    layout.input_schema.poi_type().clone(),
+                    AttributeNames::All,
+                )]),
+            );
+            let entities = store
+                .execute_query::<Entity>(&mut conn, site, query)
+                .await
+                .map(|(entities, _)| entities)
+                .map_err(StoreError::from)?;
+            Some((entities, block_ptr))
+        };
         let (entities, block_ptr) = if let Some((entities, bp)) = entities {
             (entities, bp)
         } else {
@@ -1041,20 +1053,20 @@ impl DeploymentStore {
 
     /// Get the entity matching `key` from the deployment `site`. Only
     /// consider entities as of the given `block`
-    pub(crate) fn get(
+    pub(crate) async fn get(
         &self,
         site: Arc<Site>,
         key: &EntityKey,
         block: BlockNumber,
     ) -> Result<Option<Entity>, StoreError> {
-        let conn = self.get_conn()?;
-        let layout = self.layout(&conn, site)?;
-        layout.find(&conn, key, block)
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site).await?;
+        layout.find(&mut conn, key, block).await
     }
 
     /// Retrieve all the entities matching `ids_for_type`, both the type and causality region, from
     /// the deployment `site`. Only consider entities as of the given `block`
-    pub(crate) fn get_many(
+    pub(crate) async fn get_many(
         &self,
         site: Arc<Site>,
         ids_for_type: &BTreeMap<(EntityType, CausalityRegion), IdList>,
@@ -1063,49 +1075,66 @@ impl DeploymentStore {
         if ids_for_type.is_empty() {
             return Ok(BTreeMap::new());
         }
-        let conn = self.get_conn()?;
-        let layout = self.layout(&conn, site)?;
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site).await?;
+
+        layout.find_many(&mut conn, ids_for_type, block).await
+    }
 
-        layout.find_many(&conn, ids_for_type, block)
+    pub(crate) async fn get_range(
+        &self,
+        site: Arc<Site>,
+        entity_types: Vec<EntityType>,
+        causality_region: CausalityRegion,
+        block_range: Range<BlockNumber>,
+    ) -> Result<BTreeMap<BlockNumber, Vec<EntitySourceOperation>>, StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site).await?;
+        layout
+            .find_range(&mut conn, entity_types, causality_region, block_range)
+            .await
     }
 
-    pub(crate) fn get_derived(
+    pub(crate) async fn get_derived(
         &self,
         site: Arc<Site>,
         derived_query: &DerivedEntityQuery,
         block: BlockNumber,
-        excluded_keys: &Vec<EntityKey>,
+        excluded_keys: &[EntityKey],
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
-        let conn = self.get_conn()?;
-        let layout = self.layout(&conn, site)?;
-        layout.find_derived(&conn, derived_query, block, excluded_keys)
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site).await?;
+        layout
+            .find_derived(&mut conn, derived_query, block, excluded_keys)
+            .await
     }
 
-    pub(crate) fn get_changes(
+    pub(crate) async fn get_changes(
         &self,
         site: Arc<Site>,
         block: BlockNumber,
     ) -> Result<Vec<EntityOperation>, StoreError> {
-        let conn = self.get_conn()?;
-        let layout = self.layout(&conn, site)?;
-        let changes = layout.find_changes(&conn, block)?;
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site).await?;
+        let changes = layout.find_changes(&mut conn, block).await?;
 
         Ok(changes)
     }
 
     // Only used by tests
     #[cfg(debug_assertions)]
-    pub(crate) fn find(
+    pub(crate) async fn find(
         &self,
         site: Arc<Site>,
         query: EntityQuery,
     ) -> Result<Vec<Entity>, QueryExecutionError> {
-        let conn = self.get_conn()?;
-        self.execute_query(&conn, site, query)
+        let mut conn = self.pool.get_permitted().await?;
+        self.execute_query(&mut conn, site, query)
+            .await
             .map(|(entities, _)| entities)
     }
 
-    pub(crate) fn transact_block_operations(
+    pub(crate) async fn transact_block_operations(
         self: &Arc<Self>,
         logger: &Logger,
         site: Arc<Site>,
@@ -1113,67 +1142,76 @@ impl DeploymentStore {
         last_rollup: Option<BlockTime>,
         stopwatch: &StopwatchMetrics,
         manifest_idx_and_name: &[(u32, String)],
-    ) -> Result<StoreEvent, StoreError> {
-        let conn = {
+    ) -> Result<(), StoreError> {
+        let mut conn = {
             let _section = stopwatch.start_section("transact_blocks_get_conn");
-            self.get_conn()?
+            self.pool.get_permitted().await?
         };
 
-        // Emit a store event for the changes we are about to make. We
-        // wait with sending it until we have done all our other work
-        // so that we do not hold a lock on the notification queue
-        // for longer than we have to
-        let event: StoreEvent = batch.store_event(&site.deployment);
-
-        let (layout, earliest_block) = deployment::with_lock(&conn, &site, || {
-            conn.transaction(|| -> Result<_, StoreError> {
+        let (layout, earliest_block) = deployment::with_lock(&mut conn, &site, async |conn| {
+            conn.transaction(async |conn| {
                 // Make the changes
-                let layout = self.layout(&conn, site.clone())?;
+                let layout = self.layout(conn, site.clone()).await?;
 
                 let section = stopwatch.start_section("apply_entity_modifications");
-                let count = self.apply_entity_modifications(
-                    &conn,
-                    layout.as_ref(),
-                    batch.groups(),
-                    stopwatch,
-                )?;
+                let count = self
+                    .apply_entity_modifications(
+                        conn,
+                        logger,
+                        layout.as_ref(),
+                        batch.groups(),
+                        stopwatch,
+                    )
+                    .await?;
                 section.end();
 
-                layout.rollup(&conn, last_rollup, &batch.block_times)?;
+                layout.rollup(conn, last_rollup, &batch.block_times).await?;
 
-                dynds::insert(&conn, &site, &batch.data_sources, manifest_idx_and_name)?;
+                dynds::insert(conn, &site, &batch.data_sources, manifest_idx_and_name).await?;
 
-                dynds::update_offchain_status(&conn, &site, &batch.offchain_to_remove)?;
+                dynds::update_offchain_status(conn, &site, &batch.offchain_to_remove).await?;
 
                 if !batch.deterministic_errors.is_empty() {
                     deployment::insert_subgraph_errors(
-                        &conn,
+                        &self.logger,
+                        conn,
                         &site.deployment,
                         &batch.deterministic_errors,
                         batch.block_ptr.number,
-                    )?;
+                    )
+                    .await?;
 
                     if batch.is_non_fatal_errors_active {
+                        debug!(
+                            logger,
+                            "Updating non-fatal errors for subgraph";
+                            "subgraph" => site.deployment.to_string(),
+                            "block" => batch.block_ptr.number,
+                        );
                         deployment::update_non_fatal_errors(
-                            &conn,
+                            conn,
                             &site.deployment,
                             deployment::SubgraphHealth::Unhealthy,
                             Some(&batch.deterministic_errors),
-                        )?;
+                        )
+                        .await?;
                     }
                 }
 
                 let earliest_block = deployment::transact_block(
-                    &conn,
+                    conn,
                     &site,
                     &batch.block_ptr,
                     &batch.firehose_cursor,
                     count,
-                )?;
+                )
+                .await?;
 
                 Ok((layout, earliest_block))
             })
-        })?;
+            .await
+        })
+        .await?;
 
         if batch.block_ptr.number as f64
             > earliest_block as f64
@@ -1183,16 +1221,23 @@ impl DeploymentStore {
             // how long pruning itself takes
             let _section = stopwatch.start_section("transact_blocks_prune");
 
-            self.spawn_prune(
+            if let Err(res) = self.spawn_prune(
                 logger,
-                site,
+                site.cheap_clone(),
                 layout.history_blocks,
                 earliest_block,
                 batch.block_ptr.number,
-            )?;
+            ) {
+                warn!(
+                    logger,
+                    "Failed to spawn prune task. Will try to prune again later";
+                    "subgraph" => site.deployment.to_string(),
+                    "error" => res.to_string(),
+                );
+            }
         }
 
-        Ok(event)
+        Ok(())
     }
 
     fn spawn_prune(
@@ -1223,9 +1268,7 @@ impl DeploymentStore {
                         Some(Ok(Ok(()))) => Ok(false),
                         Some(Ok(Err(err))) => Err(StoreError::PruneFailure(err.to_string())),
                         Some(Err(join_err)) => Err(StoreError::PruneFailure(join_err.to_string())),
-                        None => Err(constraint_violation!(
-                            "prune handle is finished but not ready"
-                        )),
+                        None => Err(internal_error!("prune handle is finished but not ready")),
                     }
                 }
                 Some(false) => {
@@ -1245,8 +1288,17 @@ impl DeploymentStore {
             site: Arc<Site>,
             req: PruneRequest,
         ) -> Result<(), StoreError> {
+            {
+                if store.is_source(&site).await? {
+                    debug!(
+                        logger,
+                        "Skipping pruning since this deployment is being copied"
+                    );
+                    return Ok(());
+                }
+            }
             let logger2 = logger.cheap_clone();
-            retry::forever_async(&logger2, "prune", move || {
+            retry::forever(&logger2, "prune", move || {
                 let store = store.cheap_clone();
                 let reporter = OngoingPruneReporter::new(logger.cheap_clone());
                 let site = site.cheap_clone();
@@ -1255,17 +1307,18 @@ impl DeploymentStore {
             .await
         }
 
-        if !prune_in_progress(&self, &site)? {
+        if !prune_in_progress(self, &site)? {
             let req = PruneRequest::new(
                 &site.as_ref().into(),
                 history_blocks,
-                ENV_VARS.reorg_threshold,
+                ENV_VARS.reorg_threshold(),
                 earliest_block,
                 latest_block,
             )?;
 
             let deployment_id = site.id;
-            let handle = graph::spawn(run(logger.cheap_clone(), self.clone(), site, req));
+            let logger = Logger::new(logger, o!("component" => "Prune"));
+            let handle = graph::spawn(run(logger, self.clone(), site, req));
             self.prune_handles
                 .lock()
                 .unwrap()
@@ -1274,140 +1327,156 @@ impl DeploymentStore {
         Ok(())
     }
 
-    fn rewind_or_truncate_with_conn(
+    async fn rewind_or_truncate_with_conn(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
         block_ptr_to: BlockPtr,
         firehose_cursor: &FirehoseCursor,
         truncate: bool,
-    ) -> Result<StoreEvent, StoreError> {
-        let event = deployment::with_lock(conn, &site, || {
-            conn.transaction(|| -> Result<_, StoreError> {
+    ) -> Result<(), StoreError> {
+        let logger = self.logger.cheap_clone();
+        deployment::with_lock(conn, &site, async |conn| {
+            conn.transaction(async |conn| {
                 // The revert functions want the number of the first block that we need to get rid of
                 let block = block_ptr_to.number + 1;
 
-                deployment::revert_block_ptr(
-                    conn,
-                    &site.deployment,
-                    block_ptr_to,
-                    firehose_cursor,
-                )?;
+                deployment::revert_block_ptr(conn, &site, block_ptr_to, firehose_cursor).await?;
 
                 // Revert the data
-                let layout = self.layout(conn, site.clone())?;
+                let layout = self.layout(conn, site.clone()).await?;
 
-                let event = if truncate {
-                    let event = layout.truncate_tables(conn)?;
-                    deployment::set_entity_count(conn, site.as_ref(), layout.count_query.as_str())?;
-                    event
+                if truncate {
+                    layout.truncate_tables(conn).await?;
+                    deployment::clear_entity_count(conn, site.as_ref()).await?;
                 } else {
-                    let (event, count) = layout.revert_block(conn, block)?;
-                    deployment::update_entity_count(conn, site.as_ref(), count)?;
-                    event
-                };
+                    let count = layout.revert_block(conn, block).await?;
+                    deployment::update_entity_count(conn, site.as_ref(), count).await?;
+                }
 
                 // Revert the meta data changes that correspond to this subgraph.
                 // Only certain meta data changes need to be reverted, most
                 // importantly creation of dynamic data sources. We ensure in the
                 // rest of the code that we only record history for those meta data
                 // changes that might need to be reverted
-                Layout::revert_metadata(conn, &site, block)?;
+                Layout::revert_metadata(&logger, conn, &site, block).await?;
 
-                Ok(event)
+                Ok(())
             })
-        })?;
-
-        Ok(event)
+            .await
+        })
+        .await
     }
 
-    pub(crate) fn truncate(
+    pub(crate) async fn truncate(
         &self,
         site: Arc<Site>,
         block_ptr_to: BlockPtr,
-    ) -> Result<StoreEvent, StoreError> {
-        let conn = self.get_conn()?;
+    ) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
 
-        // Unwrap: If we are reverting then the block ptr is not `None`.
-        let block_ptr_from = Self::block_ptr_with_conn(&conn, site.cheap_clone())?.unwrap();
+        let block_ptr_from = Self::block_ptr_with_conn(&mut conn, site.cheap_clone()).await?;
 
         // Sanity check on block numbers
-        if block_ptr_from.number <= block_ptr_to.number {
-            constraint_violation!(
+        let from_number = block_ptr_from.map(|ptr| ptr.number);
+        if from_number <= Some(block_ptr_to.number) {
+            internal_error!(
                 "truncate must go backwards, but would go from block {} to block {}",
-                block_ptr_from.number,
+                from_number.unwrap_or(0),
                 block_ptr_to.number
             );
         }
 
         // When rewinding, we reset the firehose cursor. That way, on resume, Firehose will start
         // from the block_ptr instead (with sanity check to ensure it's resume at the exact block).
-        self.rewind_or_truncate_with_conn(&conn, site, block_ptr_to, &FirehoseCursor::None, true)
+        self.rewind_or_truncate_with_conn(
+            &mut conn,
+            site,
+            block_ptr_to,
+            &FirehoseCursor::None,
+            true,
+        )
+        .await
     }
 
-    pub(crate) fn rewind(
+    pub(crate) async fn rewind(
         &self,
         site: Arc<Site>,
         block_ptr_to: BlockPtr,
-    ) -> Result<StoreEvent, StoreError> {
-        let conn = self.get_conn()?;
+    ) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
 
-        // Unwrap: If we are reverting then the block ptr is not `None`.
-        let block_ptr_from = Self::block_ptr_with_conn(&conn, site.cheap_clone())?.unwrap();
+        let block_ptr_from = Self::block_ptr_with_conn(&mut conn, site.cheap_clone()).await?;
 
         // Sanity check on block numbers
-        if block_ptr_from.number <= block_ptr_to.number {
-            constraint_violation!(
+        let from_number = block_ptr_from.map(|ptr| ptr.number);
+        if from_number <= Some(block_ptr_to.number) {
+            internal_error!(
                 "rewind must go backwards, but would go from block {} to block {}",
-                block_ptr_from.number,
+                from_number.unwrap_or(0),
                 block_ptr_to.number
             );
         }
 
         // When rewinding, we reset the firehose cursor. That way, on resume, Firehose will start
         // from the block_ptr instead (with sanity check to ensure it's resume at the exact block).
-        self.rewind_or_truncate_with_conn(&conn, site, block_ptr_to, &FirehoseCursor::None, false)
+        self.rewind_or_truncate_with_conn(
+            &mut conn,
+            site,
+            block_ptr_to,
+            &FirehoseCursor::None,
+            false,
+        )
+        .await
     }
 
-    pub(crate) fn revert_block_operations(
+    pub(crate) async fn revert_block_operations(
         &self,
         site: Arc<Site>,
         block_ptr_to: BlockPtr,
         firehose_cursor: &FirehoseCursor,
-    ) -> Result<StoreEvent, StoreError> {
-        let conn = self.get_conn()?;
+    ) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
         // Unwrap: If we are reverting then the block ptr is not `None`.
-        let deployment_head = Self::block_ptr_with_conn(&conn, site.cheap_clone())?.unwrap();
+        let deployment_head = Self::block_ptr_with_conn(&mut conn, site.cheap_clone())
+            .await?
+            .unwrap();
 
         // Confidence check on revert to ensure we go backward only
         if block_ptr_to.number >= deployment_head.number {
-            panic!("revert_block_operations must revert only backward, you are trying to revert forward going from subgraph block {} to new block {}", deployment_head, block_ptr_to);
+            panic!(
+                "revert_block_operations must revert only backward, you are trying to revert forward going from subgraph block {} to new block {}",
+                deployment_head, block_ptr_to
+            );
         }
 
         // Don't revert past a graft point
-        let info = self.subgraph_info_with_conn(&conn, site.as_ref())?;
-        if let Some(graft_block) = info.graft_block {
-            if graft_block > block_ptr_to.number {
-                return Err(constraint_violation!(
-                    "Can not revert subgraph `{}` to block {} as it was \
+        let info = self
+            .subgraph_info_with_conn(&mut conn, site.cheap_clone())
+            .await?;
+        if let Some(graft_block) = info.graft_block
+            && graft_block > block_ptr_to.number
+        {
+            return Err(internal_error!(
+                "Can not revert subgraph `{}` to block {} as it was \
                         grafted at block {} and reverting past a graft point \
                         is not possible",
-                    site.deployment.clone(),
-                    block_ptr_to.number,
-                    graft_block
-                ));
-            }
+                site.deployment.clone(),
+                block_ptr_to.number,
+                graft_block
+            ));
         }
 
-        self.rewind_or_truncate_with_conn(&conn, site, block_ptr_to, firehose_cursor, false)
+        self.rewind_or_truncate_with_conn(&mut conn, site, block_ptr_to, firehose_cursor, false)
+            .await
     }
 
-    pub(crate) async fn deployment_state_from_id(
+    pub(crate) async fn deployment_state(
         &self,
-        id: DeploymentHash,
+        site: Arc<Site>,
     ) -> Result<DeploymentState, StoreError> {
-        self.with_conn(|conn, _| deployment::state(conn, id).map_err(|e| e.into()))
-            .await
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::state(&mut conn, &site).await
     }
 
     pub(crate) async fn fail_subgraph(
@@ -1415,31 +1484,21 @@ impl DeploymentStore {
         id: DeploymentHash,
         error: SubgraphError,
     ) -> Result<(), StoreError> {
-        self.with_conn(move |conn, _| {
-            conn.transaction(|| deployment::fail(conn, &id, &error))
-                .map_err(Into::into)
-        })
-        .await?;
-        Ok(())
+        let mut conn = self.pool.get_permitted().await?;
+        conn.transaction(async |conn| deployment::fail(conn, &id, &error).await)
+            .await
     }
 
-    pub(crate) fn replica_for_query(
-        &self,
-        for_subscription: bool,
-    ) -> Result<ReplicaId, StoreError> {
+    pub(crate) fn replica_for_query(&self) -> Result<ReplicaId, StoreError> {
         use std::sync::atomic::Ordering;
 
-        let replica_id = match for_subscription {
-            // Pick a weighted ReplicaId. `replica_order` contains a list of
-            // replicas with repetitions according to their weight
-            false => {
-                let weights_count = self.replica_order.len();
-                let index =
-                    self.conn_round_robin_counter.fetch_add(1, Ordering::SeqCst) % weights_count;
-                *self.replica_order.get(index).unwrap()
-            }
-            // Subscriptions always go to the main replica.
-            true => ReplicaId::Main,
+        // Pick a weighted ReplicaId. `replica_order` contains a list of
+        // replicas with repetitions according to their weight
+        let replica_id = {
+            let weights_count = self.replica_order.len();
+            let index =
+                self.conn_round_robin_counter.fetch_add(1, Ordering::SeqCst) % weights_count;
+            *self.replica_order.get(index).unwrap()
         };
 
         Ok(replica_id)
@@ -1451,37 +1510,29 @@ impl DeploymentStore {
         block: BlockNumber,
         manifest_idx_and_name: Vec<(u32, String)>,
     ) -> Result<Vec<StoredDynamicDataSource>, StoreError> {
-        self.with_conn(move |conn, _| {
-            conn.transaction(|| crate::dynds::load(conn, &site, block, manifest_idx_and_name))
-                .map_err(Into::into)
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        crate::dynds::load(&mut conn, &site, block, manifest_idx_and_name).await
     }
 
     pub(crate) async fn causality_region_curr_val(
         &self,
         site: Arc<Site>,
     ) -> Result<Option<CausalityRegion>, StoreError> {
-        self.with_conn(move |conn, _| {
-            Ok(conn.transaction(|| crate::dynds::causality_region_curr_val(conn, &site))?)
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        crate::dynds::causality_region_curr_val(&mut conn, &site).await
     }
 
     pub(crate) async fn exists_and_synced(&self, id: DeploymentHash) -> Result<bool, StoreError> {
-        self.with_conn(move |conn, _| {
-            conn.transaction(|| deployment::exists_and_synced(conn, &id))
-                .map_err(Into::into)
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::exists_and_synced(&mut conn, &id).await
     }
 
-    pub(crate) fn graft_pending(
+    pub(crate) async fn graft_pending(
         &self,
         id: &DeploymentHash,
     ) -> Result<Option<(DeploymentHash, BlockPtr)>, StoreError> {
-        let conn = self.get_conn()?;
-        deployment::graft_pending(&conn, id)
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::graft_pending(&mut conn, id).await
     }
 
     /// Bring the subgraph into a state where we can start or resume
@@ -1494,16 +1545,16 @@ impl DeploymentStore {
     /// to the graph point, so that calling this needlessly with `Some(..)`
     /// will remove any progress that might have been made since the last
     /// time the deployment was started.
-    pub(crate) fn start_subgraph(
+    pub(crate) async fn start_subgraph(
         &self,
         logger: &Logger,
         site: Arc<Site>,
-        graft_src: Option<(Arc<Layout>, BlockPtr, SubgraphDeploymentEntity)>,
+        graft_src: Option<(Arc<Layout>, BlockPtr, SubgraphDeploymentEntity, IndexList)>,
     ) -> Result<(), StoreError> {
-        let dst = self.find_layout(site.cheap_clone())?;
+        let dst = self.find_layout(site.cheap_clone()).await?;
 
         // If `graft_src` is `Some`, then there is a pending graft.
-        if let Some((src, block, src_deployment)) = graft_src {
+        if let Some((src, block, src_deployment, index_list)) = graft_src {
             info!(
                 logger,
                 "Initializing graft by copying data from {} to {}",
@@ -1513,7 +1564,8 @@ impl DeploymentStore {
 
             let src_manifest_idx_and_name = src_deployment.manifest.template_idx_and_name()?;
             let dst_manifest_idx_and_name = self
-                .load_deployment(dst.site.clone())?
+                .load_deployment(dst.site.clone())
+                .await?
                 .manifest
                 .template_idx_and_name()?;
 
@@ -1524,67 +1576,80 @@ impl DeploymentStore {
             // with the corresponding tables in `self`
             let copy_conn = crate::copy::Connection::new(
                 logger,
+                self.primary.cheap_clone(),
                 self.pool.clone(),
                 src.clone(),
                 dst.clone(),
                 block.clone(),
                 src_manifest_idx_and_name,
                 dst_manifest_idx_and_name,
-            )?;
-            let status = copy_conn.copy_data()?;
+            )
+            .await?;
+            let status = copy_conn.copy_data(index_list).await?;
             if status == crate::copy::Status::Cancelled {
                 return Err(StoreError::Canceled);
             }
 
-            let conn = self.get_conn()?;
-            conn.transaction(|| -> Result<(), StoreError> {
+            let mut conn = self.pool.get_permitted().await?;
+            conn.transaction::<(), StoreError, _>(async |conn| {
                 // Copy shared dynamic data sources and adjust their ID; if
                 // the subgraph uses private data sources, that is done by
                 // `copy::Connection::copy_data` since it requires access to
                 // the source schema which in sharded setups is only
                 // available while that function runs
                 let start = Instant::now();
-                let count = dynds::shared::copy(&conn, &src.site, &dst.site, block.number)?;
+                let count = dynds::shared::copy(conn, &src.site, &dst.site, block.number).await?;
                 info!(logger, "Copied {} dynamic data sources", count;
-                      "time_ms" => start.elapsed().as_millis());
+                  "time_ms" => start.elapsed().as_millis());
 
                 // Copy errors across
                 let start = Instant::now();
-                let count = deployment::copy_errors(&conn, &src.site, &dst.site, &block)?;
+                let count = deployment::copy_errors(conn, &src.site, &dst.site, &block).await?;
                 info!(logger, "Copied {} existing errors", count;
-                      "time_ms" => start.elapsed().as_millis());
+                  "time_ms" => start.elapsed().as_millis());
 
-                catalog::copy_account_like(&conn, &src.site, &dst.site)?;
+                catalog::copy_account_like(conn, &src.site, &dst.site).await?;
 
-                // Rewind the subgraph so that entity versions that are
-                // clamped in the future (beyond `block`) become valid for
-                // all blocks after `block`. `revert_block` gets rid of
-                // everything including the block passed to it. We want to
-                // preserve `block` and therefore revert `block+1`
+                // Analyze all tables for this deployment
+                info!(logger, "Analyzing all {} tables", dst.tables.len());
+                for entity_name in dst.tables.keys() {
+                    self.analyze_with_conn(site.cheap_clone(), entity_name.as_str(), conn)
+                        .await?;
+                }
+
+                // CopyEntityBatchQuery now reverts entity versions
+                // during copying, making this rewind redundant for new
+                // copies. We keep it for backward compatibility: a copy
+                // that was started before this change and is resumed
+                // after upgrading will have already-copied rows that
+                // weren't reverted during copy. For data that was
+                // already reverted during copy, this is a no-op. This
+                // code can be removed once a release with this change
+                // has been out for a while and we are sure that there
+                // are no more copies in progress that started before
+                // the change
+                //
+                // `revert_block` gets rid of everything including the
+                // block passed to it. We want to preserve `block` and
+                // therefore revert `block+1`
                 let start = Instant::now();
                 let block_to_revert: BlockNumber = block
                     .number
                     .checked_add(1)
                     .expect("block numbers fit into an i32");
-                dst.revert_block(&conn, block_to_revert)?;
-                info!(logger, "Rewound subgraph to block {}", block.number;
-                      "time_ms" => start.elapsed().as_millis());
+                info!(logger, "Rewinding to block {}", block.number);
+                let count = dst.revert_block(conn, block_to_revert).await?;
+                deployment::update_entity_count(conn, &dst.site, count).await?;
 
-                let start = Instant::now();
-                deployment::set_entity_count(&conn, &dst.site, &dst.count_query)?;
-                info!(logger, "Counted the entities";
-                      "time_ms" => start.elapsed().as_millis());
+                info!(logger, "Rewound subgraph to block {}", block.number;
+                  "time_ms" => start.elapsed().as_millis());
 
                 deployment::set_history_blocks(
-                    &conn,
+                    conn,
                     &dst.site,
                     src_deployment.manifest.history_blocks,
-                )?;
-
-                // Analyze all tables for this deployment
-                for entity_name in dst.tables.keys() {
-                    self.analyze_with_conn(site.cheap_clone(), entity_name.as_str(), &conn)?;
-                }
+                )
+                .await?;
 
                 // The `earliest_block` for `src` might have changed while
                 // we did the copy if `src` was pruned while we copied;
@@ -1593,24 +1658,183 @@ impl DeploymentStore {
                 // `earliest_block` and do not inadvertently expose data
                 // that might be incomplete because a prune on the source
                 // removed data just before we copied it
-                deployment::copy_earliest_block(&conn, &src.site, &dst.site)?;
+                deployment::copy_earliest_block(conn, &src.site, &dst.site).await?;
 
                 // Set the block ptr to the graft point to signal that we successfully
                 // performed the graft
-                crate::deployment::forward_block_ptr(&conn, &dst.site.deployment, &block)?;
+                crate::deployment::forward_block_ptr(conn, &dst.site, &block).await?;
                 info!(logger, "Subgraph successfully initialized";
-                    "time_ms" => start.elapsed().as_millis());
+                "time_ms" => start.elapsed().as_millis());
                 Ok(())
-            })?;
+            })
+            .await?;
         }
+
         // Make sure the block pointer is set. This is important for newly
         // deployed subgraphs so that we respect the 'startBlock' setting
         // the first time the subgraph is started
-        let conn = self.get_conn()?;
-        conn.transaction(|| crate::deployment::initialize_block_ptr(&conn, &dst.site))?;
+        let mut conn = self.pool.get_permitted().await?;
+        conn.transaction(async |conn| {
+            crate::deployment::initialize_block_ptr(conn, &dst.site).await
+        })
+        .await?;
         Ok(())
     }
 
+    /// Create all indexes whose creation was postponed when the
+    /// deployment was first created. The decision is persisted in the
+    /// `postponed_indexes_created` flag on `subgraphs.deployment` so that
+    /// this is a one-shot operation: indexes are created exactly once,
+    /// and we never recreate them — even if an external process removes
+    /// indexes that it considers unused.
+    ///
+    /// The actual index creation runs in the background so that callers are
+    /// not blocked while the (potentially long-running) `CREATE INDEX
+    /// CONCURRENTLY` statements execute. Because of that, errors are only
+    /// logged and not returned to the caller. The `postponed_indexes_created`
+    /// flag is only set once all indexes have been created successfully, so a
+    /// failed run is retried the next time `graph-node` starts the
+    /// deployment. A run that was interrupted (for example by a restart while
+    /// a `CREATE INDEX CONCURRENTLY` was still in flight) can leave an invalid
+    /// index behind; such remnants are dropped and rebuilt on the next run.
+    pub(crate) fn create_postponed_indexes(&self, logger: &Logger, site: Arc<Site>) {
+        async fn index_creation_is_running(
+            store: &DeploymentStore,
+            site: &Site,
+        ) -> Result<Option<(i32, String)>, StoreError> {
+            let mut conn = store.pool.get_permitted().await?;
+            catalog::index_creation_is_running(&mut conn, site.namespace.as_str()).await
+        }
+
+        async fn postponed_indexes_created(
+            store: &DeploymentStore,
+            site: &Site,
+        ) -> Result<bool, StoreError> {
+            let mut conn = store.pool.get_permitted().await?;
+            deployment::postponed_indexes_created(&mut conn, site).await
+        }
+
+        async fn wait_for_concurrent_index_creation(
+            logger: &Logger,
+            store: &DeploymentStore,
+            site: &Site,
+        ) -> Result<(), StoreError> {
+            let mut backoff =
+                ExponentialBackoff::new(Duration::from_secs(1), Duration::from_mins(5));
+            let mut last_log = Instant::now() - Duration::from_mins(2);
+            while let Some((pid, index_name)) = index_creation_is_running(store, site).await? {
+                if last_log.elapsed() > Duration::from_mins(1) {
+                    info!(logger,
+                        "Waiting for concurrent index creation to finish";
+                        "pid" => pid,
+                        "index_name" => index_name,
+                    );
+                    last_log = Instant::now();
+                }
+                backoff.sleep_async().await;
+            }
+            Ok(())
+        }
+
+        async fn create_index(
+            logger: &Logger,
+            store: &DeploymentStore,
+            layout: &Layout,
+            site: &Site,
+            idx: &CreateIndex,
+        ) -> Result<(), StoreError> {
+            let mut last_log = Instant::now() - Duration::from_mins(2);
+            // We (ab)use the fdw pool here since `create index` can take a
+            // very long time; with many subgraphs creating indexes, we
+            // might starve the main connection pool which would block the
+            // progress of many subgraphs.
+            let mut conn = store.pool.get_fdw(logger, move || {
+                if last_log.elapsed() > Duration::from_mins(1) {
+                    debug!(logger, "Waiting for a connection to become available so we can create index"; "index_name" => idx.name().unwrap_or("<unknown>"));
+                    last_log = Instant::now();
+                }
+                false
+            }).await?;
+            let schema_name = site.namespace.as_str();
+
+            // A previous run that was interrupted (e.g. by a node
+            // restart) can leave an invalid index behind. Since we
+            // create indexes with `if not exists`, such a leftover
+            // would be skipped and never rebuilt, so drop it first.
+            // `check_index_is_valid` returns `false` both when the
+            // index is missing and when it is invalid; the
+            // `drop index ... if exists` is a no-op in the former
+            // case and removes the invalid remnant in the latter.
+            if let Some(name) = idx.name()
+                && !catalog::check_index_is_valid(&mut conn, schema_name, name).await?
+            {
+                let drop_sql = format!("drop index concurrently if exists {schema_name}.{name}");
+                sql_query(drop_sql).execute(&mut conn).await?;
+            }
+
+            let creat = layout.index_creator(true, true);
+            IndexCreator::execute(&creat, &mut conn, idx).await
+        }
+
+        async fn run(
+            logger: Logger,
+            store: DeploymentStore,
+            site: Arc<Site>,
+        ) -> Result<(), StoreError> {
+            let layout = store.find_layout(site.cheap_clone()).await?;
+
+            // Since this entire run can take many hours, we avoid holding a
+            // connection for the whole time. Instead, we get a new
+            // connection for each index that we create.
+
+            if postponed_indexes_created(&store, &site).await? {
+                return Ok(());
+            }
+
+            for table in layout.tables.values() {
+                let indexes = table.indexes(&layout.input_schema).map_err(|e| {
+                    StoreError::ConstraintViolation(format!("failed to generate indexes: {}", e))
+                })?;
+                for idx in indexes {
+                    if !idx.to_postpone() {
+                        continue;
+                    }
+
+                    wait_for_concurrent_index_creation(&logger, &store, &site).await?;
+
+                    create_index(&logger, &store, &layout, &site, &idx).await?;
+
+                    debug!(logger, "Created index";
+                        "index_name" => idx.name().unwrap_or("<unknown>"),
+                        "table_name" => table.name.as_str(),
+                    );
+                }
+            }
+
+            let mut conn = store.pool.get_permitted().await?;
+            deployment::set_postponed_indexes_created(&mut conn, &site).await?;
+            Ok(())
+        }
+
+        let store = self.cheap_clone();
+        let logger = Logger::new(logger, o!("component" => "IndexCreation"));
+        graph::spawn(async move {
+            let logger2 = logger.cheap_clone();
+            let res = retry::forever(&logger2, "create_postponed_indexes", || {
+                let store = store.cheap_clone();
+                let site = site.cheap_clone();
+                let logger = logger2.cheap_clone();
+                async move { run(logger, store, site).await }
+            })
+            .await;
+            match res {
+                Ok(()) => debug!(logger, "Created postponed indexes"),
+                Err(e) => error!(logger, "Failed to create postponed indexes";
+                    "error" => e.to_string()),
+            }
+        });
+    }
+
     // If the current block of the deployment is the same as the fatal error,
     // we revert all block operations to it's parent/previous block.
     //
@@ -1621,18 +1845,18 @@ impl DeploymentStore {
     //
     // - There's no fatal error for the subgraph
     // - The error is NOT deterministic
-    pub(crate) fn unfail_deterministic_error(
+    pub(crate) async fn unfail_deterministic_error(
         &self,
         site: Arc<Site>,
         current_ptr: &BlockPtr,
         parent_ptr: &BlockPtr,
     ) -> Result<UnfailOutcome, StoreError> {
-        let conn = &self.get_conn()?;
+        let mut conn = self.pool.get_permitted().await?;
         let deployment_id = &site.deployment;
 
-        conn.transaction(|| {
+        conn.transaction(async |conn| {
             // We'll only unfail subgraphs that had fatal errors
-            let subgraph_error = match ErrorDetail::fatal(conn, deployment_id)? {
+            let subgraph_error = match ErrorDetail::fatal(conn, deployment_id).await? {
                 Some(fatal_error) => fatal_error,
                 // If the subgraph is not failed then there is nothing to do.
                 None => return Ok(UnfailOutcome::Noop),
@@ -1646,7 +1870,7 @@ impl DeploymentStore {
             use deployment::SubgraphHealth::*;
             // Decide status based on if there are any errors for the previous/parent block
             let prev_health =
-                if deployment::has_deterministic_errors(conn, deployment_id, parent_ptr.number)? {
+                if deployment::has_deterministic_errors(conn, deployment_id, parent_ptr.number).await? {
                     Unhealthy
                 } else {
                     Healthy
@@ -1672,10 +1896,10 @@ impl DeploymentStore {
                     // We reset the firehose cursor. That way, on resume, Firehose will start from
                     // the block_ptr instead (with sanity checks to ensure it's resuming at the
                     // correct block).
-                    let _ = self.revert_block_operations(site.clone(), parent_ptr.clone(), &FirehoseCursor::None)?;
+                    self.revert_block_operations(site.clone(), parent_ptr.clone(), &FirehoseCursor::None).await?;
 
                     // Unfail the deployment.
-                    deployment::update_deployment_status(conn, deployment_id, prev_health, None,None)?;
+                    deployment::update_deployment_status(conn, deployment_id, prev_health, None,None).await?;
 
                     Ok(UnfailOutcome::Unfailed)
                 }
@@ -1705,7 +1929,7 @@ impl DeploymentStore {
                     Ok(UnfailOutcome::Noop)
                 }
             }
-        })
+        }).await
     }
 
     // If a non-deterministic error happens and the deployment head advances,
@@ -1718,17 +1942,17 @@ impl DeploymentStore {
     //
     // - There's no fatal error for the subgraph
     // - The error IS deterministic
-    pub(crate) fn unfail_non_deterministic_error(
+    pub(crate) async fn unfail_non_deterministic_error(
         &self,
         site: Arc<Site>,
         current_ptr: &BlockPtr,
     ) -> Result<UnfailOutcome, StoreError> {
-        let conn = &self.get_conn()?;
+        let mut conn = self.pool.get_permitted().await?;
         let deployment_id = &site.deployment;
 
-        conn.transaction(|| {
+        conn.transaction(async |conn| {
             // We'll only unfail subgraphs that had fatal errors
-            let subgraph_error = match ErrorDetail::fatal(conn, deployment_id)? {
+            let subgraph_error = match ErrorDetail::fatal(conn, deployment_id).await? {
                 Some(fatal_error) => fatal_error,
                 // If the subgraph is not failed then there is nothing to do.
                 None => return Ok(UnfailOutcome::Noop),
@@ -1759,14 +1983,15 @@ impl DeploymentStore {
                             deployment::SubgraphHealth::Healthy,
                             None,
                             None,
-                        )?;
+                        ).await?;
 
                         // Delete the fatal error.
-                        deployment::delete_error(conn, &subgraph_error.id)?;
+                        deployment::delete_error(conn, &subgraph_error.id).await?;
 
                         Ok(UnfailOutcome::Unfailed)
                     }
-                // NOOP, the deployment head is still before where non-deterministic error happened.
+                // The deployment head is still before where non-deterministic error happened.
+                // Return BehindErrorBlock so the caller knows to retry on subsequent blocks.
                 block_range => {
                     info!(
                         self.logger,
@@ -1778,16 +2003,16 @@ impl DeploymentStore {
                         "error_block_hash" => subgraph_error.block_hash.as_ref().map(|hash| format!("0x{}", hex::encode(hash))),
                     );
 
-                    Ok(UnfailOutcome::Noop)
+                    Ok(UnfailOutcome::BehindErrorBlock)
                 }
             }
-        })
+        }).await
     }
 
     #[cfg(debug_assertions)]
-    pub fn error_count(&self, id: &DeploymentHash) -> Result<usize, StoreError> {
-        let conn = self.get_conn()?;
-        deployment::error_count(&conn, id)
+    pub async fn error_count(&self, id: &DeploymentHash) -> Result<usize, StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::error_count(&mut conn, id).await
     }
 
     pub(crate) async fn mirror_primary_tables(&self, logger: &Logger) {
@@ -1803,21 +2028,18 @@ impl DeploymentStore {
             // We hardcode our materialized views, but could also use
             // pg_matviews to list all of them, though that might inadvertently
             // refresh materialized views that operators created themselves
-            const VIEWS: [&str; 3] = [
+            const VIEWS: [&str; 4] = [
                 "info.table_sizes",
                 "info.subgraph_sizes",
                 "info.chain_sizes",
+                "info.entity_version_stats",
             ];
-            store
-                .with_conn(|conn, cancel| {
-                    for view in VIEWS {
-                        let query = format!("refresh materialized view {}", view);
-                        diesel::sql_query(&query).execute(conn)?;
-                        cancel.check_cancel()?;
-                    }
-                    Ok(())
-                })
-                .await
+            let mut conn = store.pool.get_permitted().await?;
+            for view in VIEWS {
+                let query = format!("refresh materialized view {}", view);
+                diesel::sql_query(&query).execute(&mut conn).await?;
+            }
+            Ok(())
         }
 
         run(self).await.unwrap_or_else(|e| {
@@ -1832,19 +2054,32 @@ impl DeploymentStore {
         site: &Site,
     ) -> Result<deployment::SubgraphHealth, StoreError> {
         let id = site.id;
-        self.with_conn(move |conn, _| deployment::health(conn, id).map_err(Into::into))
-            .await
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::health(&mut conn, id).await
+    }
+
+    async fn is_source(&self, site: &Site) -> Result<bool, StoreError> {
+        self.primary.is_source(site).await
     }
 
-    pub(crate) async fn set_manifest_raw_yaml(
+    /// Sets the raw subgraph manifest for the given `site`, if not previously set.
+    ///
+    /// Returns `Ok(())` regardless of whether the value was updated.
+    pub(crate) async fn set_raw_manifest_once(
         &self,
         site: Arc<Site>,
-        raw_yaml: String,
+        raw_manifest: String,
     ) -> Result<(), StoreError> {
-        self.with_conn(move |conn, _| {
-            deployment::set_manifest_raw_yaml(conn, &site, &raw_yaml).map_err(Into::into)
-        })
-        .await
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::set_raw_manifest_once(&mut conn, &site, &raw_manifest).await
+    }
+
+    /// Returns the raw subgraph manifest for the given `site`, if one exists.
+    ///
+    /// Returns `None` if no manifest is found for this `site`.
+    pub(crate) async fn raw_manifest(&self, site: Arc<Site>) -> Result<Option<String>, StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::load_raw_manifest(&mut conn, &site).await
     }
 }
 
@@ -1867,6 +2102,49 @@ fn resolve_table_name<'a>(layout: &'a Layout, name: &'_ str) -> Result<&'a Table
         })
 }
 
+pub fn generate_index_creation_sql(
+    layout: Arc<Layout>,
+    entity_name: &str,
+    field_names: Vec<String>,
+    index_method: Method,
+    after: Option<BlockNumber>,
+) -> Result<(String, String), StoreError> {
+    let schema_name = layout.site.namespace.clone();
+    let table = resolve_table_name(&layout, entity_name)?;
+    let (column_names, index_exprs) = resolve_column_names_and_index_exprs(table, &field_names)?;
+
+    let column_names_sep_by_underscores = column_names.join("_");
+    let index_exprs_joined = index_exprs.join(", ");
+    let table_name = &table.name;
+    let index_name = format!(
+        "manual_{table_name}_{column_names_sep_by_underscores}{}",
+        after.map_or_else(String::new, |a| format!("_{}", a))
+    );
+
+    let mut sql = format!(
+        "create index concurrently if not exists {index_name} \
+         on {schema_name}.{table_name} using {index_method} \
+         ({index_exprs_joined}) ",
+    );
+
+    // If 'after' is provided and the table is immutable, throw an error because partial indexing is not allowed
+    if let Some(after) = after {
+        if table.immutable {
+            return Err(StoreError::Unknown(anyhow!(
+                "Partial index not allowed on immutable table `{}`",
+                table_name
+            )));
+        } else {
+            sql.push_str(&format!(
+                " where coalesce(upper({}), 2147483647) > {}",
+                BLOCK_RANGE_COLUMN, after
+            ));
+        }
+    }
+
+    Ok((index_name, sql))
+}
+
 /// Resolves column names against the `table`. The `field_names` can be
 /// either GraphQL attributes or the SQL names of columns. We also accept
 /// the names `block_range` and `block$` and map that to the correct name
@@ -1903,11 +2181,10 @@ fn resolve_column<'a>(table: &'a Table, field: &str) -> Result<(&'a SqlName, Str
             let sql_name = SqlName::from(field);
             table
                 .column(&sql_name)
-                .ok_or_else(|| StoreError::UnknownField(field.to_string()))
+                .ok_or_else(|| StoreError::UnknownField(table.name.to_string(), field.to_string()))
         })
         .map(|column| {
-            let index_expr =
-                Table::calculate_index_method_and_expression(table.immutable, column).1;
+            let index_expr = Table::calculate_index_method_and_expression(column).1;
             (&column.name, index_expr)
         })
 }
diff --git a/store/postgres/src/detail.rs b/store/postgres/src/detail.rs
index f35b6dfcbff..b59a53cdca4 100644
--- a/store/postgres/src/detail.rs
+++ b/store/postgres/src/detail.rs
@@ -2,29 +2,35 @@
 //!
 // For git_testament_macros
 #![allow(unused_macros)]
-use diesel::dsl;
+use diesel::dsl::sql;
 use diesel::prelude::{
-    ExpressionMethods, JoinOnDsl, NullableExpressionMethods, OptionalExtension, PgConnection,
-    QueryDsl, RunQueryDsl,
+    ExpressionMethods, JoinOnDsl, NullableExpressionMethods, OptionalExtension, QueryDsl,
+    SelectableHelper as _,
 };
+use diesel::sql_types::{Array, BigInt, Integer};
+use diesel_async::RunQueryDsl;
 use diesel_derives::Associations;
 use git_testament::{git_testament, git_testament_macros};
 use graph::blockchain::BlockHash;
+use graph::data::store::scalar::ToPrimitive;
 use graph::data::subgraph::schema::{SubgraphError, SubgraphManifestEntity};
+use graph::prelude::BlockNumber;
+use graph::prelude::alloy::primitives::B256;
 use graph::prelude::{
-    bigdecimal::ToPrimitive, BigDecimal, BlockPtr, DeploymentHash, StoreError,
-    SubgraphDeploymentEntity,
+    BlockPtr, DeploymentHash, StoreError, SubgraphDeploymentEntity,
+    chrono::{DateTime, Utc},
 };
 use graph::schema::InputSchema;
-use graph::{constraint_violation, data::subgraph::status, prelude::web3::types::H256};
+use graph::{data::subgraph::status, internal_error};
 use itertools::Itertools;
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::{ops::Bound, sync::Arc};
 
+use crate::AsyncPgConnection;
 use crate::deployment::{
-    graph_node_versions, subgraph_deployment, subgraph_error, subgraph_manifest,
-    SubgraphHealth as HealthType,
+    SubgraphHealth as HealthType, deployment as subgraph_deployment, graph_node_versions,
+    head as subgraph_head, subgraph_error, subgraph_manifest,
 };
 use crate::primary::{DeploymentId, Site};
 
@@ -38,43 +44,107 @@ const CARGO_PKG_VERSION_PATCH: &str = env!("CARGO_PKG_VERSION_PATCH");
 
 type Bytes = Vec<u8>;
 
-#[derive(Queryable, QueryableByName)]
-#[table_name = "subgraph_deployment"]
-// We map all fields to make loading `Detail` with diesel easier, but we
-// don't need all the fields
-#[allow(dead_code)]
 pub struct DeploymentDetail {
     pub id: DeploymentId,
-    pub deployment: String,
-    pub failed: bool,
+    pub subgraph: String,
+    /// The earliest block for which we have history
+    pub earliest_block_number: i32,
     health: HealthType,
-    pub synced: bool,
-    fatal_error: Option<String>,
-    non_fatal_errors: Vec<String>,
+    pub failed: bool,
+    graft_base: Option<String>,
+    graft_block_hash: Option<Bytes>,
+    graft_block_number: Option<BlockNumber>,
+    reorg_count: i32,
+    current_reorg_depth: i32,
+    max_reorg_depth: i32,
+    debug_fork: Option<String>,
+    pub synced_at: Option<DateTime<Utc>>,
+    pub synced_at_block_number: Option<i32>,
+    pub block_hash: Option<Bytes>,
+    pub block_number: Option<BlockNumber>,
+    pub entity_count: usize,
+}
+
+#[derive(Queryable, Selectable)]
+#[diesel(table_name = subgraph_deployment)]
+struct Deployment {
+    id: DeploymentId,
+    subgraph: String,
     /// The earliest block for which we have history
     earliest_block_number: i32,
-    pub latest_ethereum_block_hash: Option<Bytes>,
-    pub latest_ethereum_block_number: Option<BigDecimal>,
-    last_healthy_ethereum_block_hash: Option<Bytes>,
-    last_healthy_ethereum_block_number: Option<BigDecimal>,
-    pub entity_count: BigDecimal,
+    health: HealthType,
+    failed: bool,
     graft_base: Option<String>,
     graft_block_hash: Option<Bytes>,
-    graft_block_number: Option<BigDecimal>,
-    debug_fork: Option<String>,
+    graft_block_number: Option<BlockNumber>,
     reorg_count: i32,
     current_reorg_depth: i32,
     max_reorg_depth: i32,
-    firehose_cursor: Option<String>,
+    debug_fork: Option<String>,
+    synced_at: Option<DateTime<Utc>>,
+    synced_at_block_number: Option<i32>,
+}
+
+#[derive(Queryable, Selectable)]
+#[diesel(table_name = subgraph_head)]
+struct Head {
+    block_hash: Option<Bytes>,
+    block_number: Option<BlockNumber>,
+    entity_count: i64,
+}
+
+impl From<(Deployment, Head)> for DeploymentDetail {
+    fn from((deployment, head): (Deployment, Head)) -> Self {
+        let Deployment {
+            id,
+            subgraph,
+            earliest_block_number,
+            health,
+            failed,
+            graft_base,
+            graft_block_hash,
+            graft_block_number,
+            reorg_count,
+            current_reorg_depth,
+            max_reorg_depth,
+            debug_fork,
+            synced_at,
+            synced_at_block_number,
+        } = deployment;
+
+        let Head {
+            block_hash,
+            block_number,
+            entity_count,
+        } = head;
+
+        Self {
+            id,
+            subgraph,
+            earliest_block_number,
+            health,
+            failed,
+            graft_base,
+            graft_block_hash,
+            graft_block_number,
+            reorg_count,
+            current_reorg_depth,
+            max_reorg_depth,
+            debug_fork,
+            synced_at,
+            synced_at_block_number,
+            block_hash: block_hash.clone(),
+            block_number,
+            entity_count: entity_count as usize,
+        }
+    }
 }
 
-#[derive(Queryable, QueryableByName)]
-#[table_name = "subgraph_error"]
+#[derive(Queryable, Selectable)]
+#[diesel(table_name = subgraph_error)]
 // We map all fields to make loading `Detail` with diesel easier, but we
 // don't need all the fields
-#[allow(dead_code)]
 pub(crate) struct ErrorDetail {
-    vid: i64,
     pub id: String,
     subgraph_id: String,
     message: String,
@@ -87,18 +157,19 @@ pub(crate) struct ErrorDetail {
 impl ErrorDetail {
     /// Fetches the fatal error, if present, associated with the given
     /// [`DeploymentHash`].
-    pub fn fatal(
-        conn: &PgConnection,
+    pub async fn fatal(
+        conn: &mut AsyncPgConnection,
         deployment_id: &DeploymentHash,
     ) -> Result<Option<Self>, StoreError> {
         use subgraph_deployment as d;
         use subgraph_error as e;
 
         d::table
-            .filter(d::deployment.eq(deployment_id.as_str()))
+            .filter(d::subgraph.eq(deployment_id.as_str()))
             .inner_join(e::table.on(e::id.nullable().eq(d::fatal_error)))
-            .select(e::all_columns)
+            .select(ErrorDetail::as_select())
             .get_result(conn)
+            .await
             .optional()
             .map_err(StoreError::from)
     }
@@ -109,7 +180,6 @@ impl TryFrom<ErrorDetail> for SubgraphError {
 
     fn try_from(value: ErrorDetail) -> Result<Self, Self::Error> {
         let ErrorDetail {
-            vid: _,
             id: _,
             subgraph_id,
             message,
@@ -122,7 +192,7 @@ impl TryFrom<ErrorDetail> for SubgraphError {
         // FIXME:
         //
         // workaround for arweave
-        let block_hash = block_hash.map(|hash| H256::from_slice(&hash.as_slice()[..32]));
+        let block_hash = block_hash.map(|hash| B256::from_slice(&hash.as_slice()[..32]));
         // In existing databases, we have errors that have a `block_range` of
         // `UNVERSIONED_RANGE`, which leads to `None` as the block number, but
         // has a hash. Conversely, it is also possible for an error to not have a
@@ -132,7 +202,7 @@ impl TryFrom<ErrorDetail> for SubgraphError {
             _ => None,
         };
         let subgraph_id = DeploymentHash::new(subgraph_id).map_err(|id| {
-            StoreError::ConstraintViolation(format!("invalid subgraph id `{}` in fatal error", id))
+            StoreError::InternalError(format!("invalid subgraph id `{}` in fatal error", id))
         })?;
         Ok(SubgraphError {
             subgraph_id,
@@ -148,25 +218,15 @@ pub(crate) fn block(
     id: &str,
     name: &str,
     hash: Option<Vec<u8>>,
-    number: Option<BigDecimal>,
+    number: Option<BlockNumber>,
 ) -> Result<Option<status::EthereumBlock>, StoreError> {
     match (hash, number) {
-        (Some(hash), Some(number)) => {
-            let number = number.to_i32().ok_or_else(|| {
-                constraint_violation!(
-                    "the block number {} for {} in {} is not representable as an i32",
-                    number,
-                    name,
-                    id
-                )
-            })?;
-            Ok(Some(status::EthereumBlock::new(
-                BlockHash(hash.into_boxed_slice()),
-                number,
-            )))
-        }
+        (Some(hash), Some(number)) => Ok(Some(status::EthereumBlock::new(
+            BlockHash(hash.into_boxed_slice()),
+            number,
+        ))),
         (None, None) => Ok(None),
-        (hash, number) => Err(constraint_violation!(
+        (hash, number) => Err(internal_error!(
             "the hash and number \
         of a block pointer must either both be null or both have a \
         value, but for `{}` the hash of {} is `{:?}` and the number is `{:?}`",
@@ -184,39 +244,37 @@ pub(crate) fn info_from_details(
     non_fatal: Vec<ErrorDetail>,
     sites: &[Arc<Site>],
     subgraph_history_blocks: i32,
+    subgraph_size: status::SubgraphSize,
 ) -> Result<status::Info, StoreError> {
     let DeploymentDetail {
         id,
-        deployment,
+        subgraph,
         failed: _,
         health,
-        synced,
-        fatal_error: _,
-        non_fatal_errors: _,
+        synced_at,
         earliest_block_number,
-        latest_ethereum_block_hash,
-        latest_ethereum_block_number,
+        block_hash,
+        block_number,
         entity_count,
         graft_base: _,
         graft_block_hash: _,
         graft_block_number: _,
-        ..
+        synced_at_block_number: _,
+        debug_fork: _,
+        reorg_count: _,
+        current_reorg_depth: _,
+        max_reorg_depth: _,
     } = detail;
 
     let site = sites
         .iter()
-        .find(|site| site.deployment.as_str() == deployment)
-        .ok_or_else(|| constraint_violation!("missing site for subgraph `{}`", deployment))?;
+        .find(|site| site.deployment.as_str() == subgraph)
+        .ok_or_else(|| internal_error!("missing site for subgraph `{}`", subgraph))?;
 
     // This needs to be filled in later since it lives in a
     // different shard
     let chain_head_block = None;
-    let latest_block = block(
-        &deployment,
-        "latest_ethereum_block",
-        latest_ethereum_block_hash,
-        latest_ethereum_block_number,
-    )?;
+    let latest_block = block(&subgraph, "latest_ethereum_block", block_hash, block_number)?;
     let health = health.into();
     let chain = status::ChainInfo {
         network: site.network.clone(),
@@ -225,9 +283,9 @@ pub(crate) fn info_from_details(
         latest_block,
     };
     let entity_count = entity_count.to_u64().ok_or_else(|| {
-        constraint_violation!(
+        internal_error!(
             "the entityCount for {} is not representable as a u64",
-            deployment
+            subgraph
         )
     })?;
     let fatal_error = fatal.map(SubgraphError::try_from).transpose()?;
@@ -239,8 +297,8 @@ pub(crate) fn info_from_details(
     // 'node' needs to be filled in later from a different shard
     Ok(status::Info {
         id: id.into(),
-        subgraph: deployment,
-        synced,
+        subgraph,
+        synced: synced_at.is_some(),
         health,
         paused: None,
         fatal_error,
@@ -249,33 +307,68 @@ pub(crate) fn info_from_details(
         entity_count,
         node: None,
         history_blocks: subgraph_history_blocks,
+        subgraph_size,
     })
 }
 
 /// Return the details for `deployments`
-pub(crate) fn deployment_details(
-    conn: &PgConnection,
+pub(crate) async fn deployment_details(
+    conn: &mut AsyncPgConnection,
     deployments: Vec<String>,
 ) -> Result<Vec<DeploymentDetail>, StoreError> {
     use subgraph_deployment as d;
+    use subgraph_head as h;
+
+    let cols = <(Deployment, Head)>::as_select();
 
     // Empty deployments means 'all of them'
     let details = if deployments.is_empty() {
-        d::table.load::<DeploymentDetail>(conn)?
+        d::table
+            .inner_join(h::table)
+            .select(cols)
+            .load::<(Deployment, Head)>(conn)
+            .await?
     } else {
         d::table
-            .filter(d::deployment.eq_any(&deployments))
-            .load::<DeploymentDetail>(conn)?
-    };
+            .inner_join(h::table)
+            .filter(d::subgraph.eq_any(&deployments))
+            .select(cols)
+            .load::<(Deployment, Head)>(conn)
+            .await?
+    }
+    .into_iter()
+    .map(DeploymentDetail::from)
+    .collect();
     Ok(details)
 }
 
-pub(crate) fn deployment_statuses(
-    conn: &PgConnection,
+/// Return the details for `deployment`
+pub(crate) async fn deployment_details_for_id(
+    conn: &mut AsyncPgConnection,
+    deployment: &DeploymentId,
+) -> Result<DeploymentDetail, StoreError> {
+    use subgraph_deployment as d;
+    use subgraph_head as h;
+
+    let cols = <(Deployment, Head)>::as_select();
+
+    d::table
+        .inner_join(h::table)
+        .filter(d::id.eq(&deployment))
+        .select(cols)
+        .first::<(Deployment, Head)>(conn)
+        .await
+        .map_err(StoreError::from)
+        .map(DeploymentDetail::from)
+}
+
+pub(crate) async fn deployment_statuses(
+    conn: &mut AsyncPgConnection,
     sites: &[Arc<Site>],
 ) -> Result<Vec<status::Info>, StoreError> {
     use subgraph_deployment as d;
     use subgraph_error as e;
+    use subgraph_head as h;
     use subgraph_manifest as sm;
 
     // First, we fetch all deployment information along with any fatal errors.
@@ -285,33 +378,44 @@ pub(crate) fn deployment_statuses(
     let details_with_fatal_error = {
         let join = e::table.on(e::id.nullable().eq(d::fatal_error));
 
+        let cols = <(Deployment, Head, Option<ErrorDetail>)>::as_select();
+
         // Empty deployments means 'all of them'
         if sites.is_empty() {
             d::table
+                .inner_join(h::table)
                 .left_outer_join(join)
-                .load::<(DeploymentDetail, Option<ErrorDetail>)>(conn)?
+                .select(cols)
+                .load::<(Deployment, Head, Option<ErrorDetail>)>(conn)
+                .await?
         } else {
             d::table
+                .inner_join(h::table)
                 .left_outer_join(join)
                 .filter(d::id.eq_any(sites.iter().map(|site| site.id)))
-                .load::<(DeploymentDetail, Option<ErrorDetail>)>(conn)?
+                .select(cols)
+                .load::<(Deployment, Head, Option<ErrorDetail>)>(conn)
+                .await?
         }
     };
 
     let mut non_fatal_errors = {
-        let join = e::table.on(e::id.eq(dsl::any(d::non_fatal_errors)));
+        #[allow(deprecated)]
+        let join = e::table.on(e::id.eq(sql("any(subgraphs.deployment.non_fatal_errors)")));
 
         if sites.is_empty() {
             d::table
                 .inner_join(join)
-                .select((d::id, e::all_columns))
-                .load::<(DeploymentId, ErrorDetail)>(conn)?
+                .select((d::id, ErrorDetail::as_select()))
+                .load::<(DeploymentId, ErrorDetail)>(conn)
+                .await?
         } else {
             d::table
                 .inner_join(join)
                 .filter(d::id.eq_any(sites.iter().map(|site| site.id)))
-                .select((d::id, e::all_columns))
-                .load::<(DeploymentId, ErrorDetail)>(conn)?
+                .select((d::id, ErrorDetail::as_select()))
+                .load::<(DeploymentId, ErrorDetail)>(conn)
+                .await?
         }
         .into_iter()
         .into_group_map()
@@ -321,33 +425,112 @@ pub(crate) fn deployment_statuses(
         if sites.is_empty() {
             sm::table
                 .select((sm::id, sm::history_blocks))
-                .load::<(DeploymentId, i32)>(conn)?
+                .load::<(DeploymentId, i32)>(conn)
+                .await?
         } else {
             sm::table
                 .filter(sm::id.eq_any(sites.iter().map(|site| site.id)))
                 .select((sm::id, sm::history_blocks))
-                .load::<(DeploymentId, i32)>(conn)?
+                .load::<(DeploymentId, i32)>(conn)
+                .await?
         }
         .into_iter()
         .collect()
     };
 
+    let mut deployment_sizes = deployment_sizes(conn, sites).await?;
+
     details_with_fatal_error
         .into_iter()
-        .map(|(detail, fatal)| {
+        .map(|(deployment, head, fatal)| {
+            let detail = DeploymentDetail::from((deployment, head));
             let non_fatal = non_fatal_errors.remove(&detail.id).unwrap_or_default();
             let subgraph_history_blocks = history_blocks_map.remove(&detail.id).unwrap_or_default();
-            info_from_details(detail, fatal, non_fatal, sites, subgraph_history_blocks)
+            let table_sizes = deployment_sizes.remove(&detail.id).unwrap_or_default();
+            info_from_details(
+                detail,
+                fatal,
+                non_fatal,
+                sites,
+                subgraph_history_blocks,
+                table_sizes,
+            )
         })
         .collect()
 }
 
-#[derive(Queryable, QueryableByName, Identifiable, Associations)]
-#[table_name = "subgraph_manifest"]
-#[belongs_to(GraphNodeVersion)]
+async fn deployment_sizes(
+    conn: &mut AsyncPgConnection,
+    sites: &[Arc<Site>],
+) -> Result<HashMap<DeploymentId, status::SubgraphSize>, StoreError> {
+    #[derive(QueryableByName)]
+    struct SubgraphSizeRow {
+        #[diesel(sql_type = Integer)]
+        id: DeploymentId,
+        #[diesel(sql_type = BigInt)]
+        row_estimate: i64,
+        #[diesel(sql_type = BigInt)]
+        table_bytes: i64,
+        #[diesel(sql_type = BigInt)]
+        index_bytes: i64,
+        #[diesel(sql_type = BigInt)]
+        toast_bytes: i64,
+        #[diesel(sql_type = BigInt)]
+        total_bytes: i64,
+    }
+
+    let mut query = String::from(
+        r#"
+        SELECT
+            ds.id,
+            ss.row_estimate::bigint,
+            ss.table_bytes::bigint,
+            ss.index_bytes::bigint,
+            ss.toast_bytes::bigint,
+            ss.total_bytes::bigint
+        FROM deployment_schemas ds
+        JOIN info.subgraph_sizes as ss on ss.name = ds.name
+    "#,
+    );
+
+    let result = if sites.is_empty() {
+        diesel::sql_query(query).load::<SubgraphSizeRow>(conn).await
+    } else {
+        query.push_str(" WHERE ds.id = ANY($1)");
+        diesel::sql_query(query)
+            .bind::<Array<Integer>, _>(sites.iter().map(|site| site.id).collect::<Vec<_>>())
+            .load::<SubgraphSizeRow>(conn)
+            .await
+    };
+
+    let rows = match result {
+        Ok(rows) => rows,
+        Err(e) if e.to_string().contains("has not been populated") => Vec::new(),
+        Err(e) => return Err(e.into()),
+    };
+
+    let mut sizes: HashMap<DeploymentId, status::SubgraphSize> = HashMap::new();
+    for row in rows {
+        sizes.insert(
+            row.id,
+            status::SubgraphSize {
+                row_estimate: row.row_estimate,
+                table_bytes: row.table_bytes,
+                index_bytes: row.index_bytes,
+                toast_bytes: row.toast_bytes,
+                total_bytes: row.total_bytes,
+            },
+        );
+    }
+
+    Ok(sizes)
+}
+
+#[derive(Queryable, Selectable, Identifiable, Associations)]
+#[diesel(table_name = subgraph_manifest)]
+#[diesel(belongs_to(GraphNodeVersion))]
 // We never read the id field but map it to make the interaction with Diesel
 // simpler
-#[allow(dead_code)]
 struct StoredSubgraphManifest {
     id: i32,
     spec_version: String,
@@ -356,17 +539,15 @@ struct StoredSubgraphManifest {
     features: Vec<String>,
     schema: String,
     graph_node_version_id: Option<i32>,
-    use_bytea_prefix: bool,
     start_block_number: Option<i32>,
     start_block_hash: Option<Bytes>,
     raw_yaml: Option<String>,
     entities_with_causality_region: Vec<String>,
-    on_sync: Option<String>,
     history_blocks: i32,
 }
 
 impl StoredSubgraphManifest {
-    fn as_manifest(self, schema: &InputSchema) -> SubgraphManifestEntity {
+    fn into_manifest_entity(self, schema: &InputSchema) -> SubgraphManifestEntity {
         let e: Vec<_> = self
             .entities_with_causality_region
             .into_iter()
@@ -388,30 +569,30 @@ impl StoredSubgraphManifest {
 struct StoredDeploymentEntity(crate::detail::DeploymentDetail, StoredSubgraphManifest);
 
 impl StoredDeploymentEntity {
-    fn as_subgraph_deployment(
+    fn into_subgraph_deployment_entity(
         self,
         schema: &InputSchema,
     ) -> Result<SubgraphDeploymentEntity, StoreError> {
         let (detail, manifest) = (self.0, self.1);
 
         let start_block = block(
-            &detail.deployment,
+            &detail.subgraph,
             "start_block",
             manifest.start_block_hash.clone(),
-            manifest.start_block_number.map(|n| n.into()),
+            manifest.start_block_number,
         )?
         .map(|block| block.to_ptr());
 
         let latest_block = block(
-            &detail.deployment,
+            &detail.subgraph,
             "latest_block",
-            detail.latest_ethereum_block_hash,
-            detail.latest_ethereum_block_number,
+            detail.block_hash,
+            detail.block_number,
         )?
         .map(|block| block.to_ptr());
 
         let graft_block = block(
-            &detail.deployment,
+            &detail.subgraph,
             "graft_block",
             detail.graft_block_hash,
             detail.graft_block_number,
@@ -422,19 +603,19 @@ impl StoredDeploymentEntity {
             .graft_base
             .map(DeploymentHash::new)
             .transpose()
-            .map_err(|b| constraint_violation!("invalid graft base `{}`", b))?;
+            .map_err(|b| internal_error!("invalid graft base `{}`", b))?;
 
         let debug_fork = detail
             .debug_fork
             .map(DeploymentHash::new)
             .transpose()
-            .map_err(|b| constraint_violation!("invalid debug fork `{}`", b))?;
+            .map_err(|b| internal_error!("invalid debug fork `{}`", b))?;
 
         Ok(SubgraphDeploymentEntity {
-            manifest: manifest.as_manifest(schema),
+            manifest: manifest.into_manifest_entity(schema),
             failed: detail.failed,
             health: detail.health.into(),
-            synced: detail.synced,
+            synced_at: detail.synced_at,
             fatal_error: None,
             non_fatal_errors: vec![],
             earliest_block_number: detail.earliest_block_number,
@@ -450,27 +631,46 @@ impl StoredDeploymentEntity {
     }
 }
 
-pub fn deployment_entity(
-    conn: &PgConnection,
+pub async fn deployment_entity(
+    conn: &mut AsyncPgConnection,
     site: &Site,
     schema: &InputSchema,
 ) -> Result<SubgraphDeploymentEntity, StoreError> {
     use subgraph_deployment as d;
+    use subgraph_head as h;
     use subgraph_manifest as m;
 
     let manifest = m::table
         .find(site.id)
-        .first::<StoredSubgraphManifest>(conn)?;
+        .select(StoredSubgraphManifest::as_select())
+        .first::<StoredSubgraphManifest>(conn)
+        .await?;
 
     let detail = d::table
-        .find(site.id)
-        .first::<crate::detail::DeploymentDetail>(conn)?;
+        .inner_join(h::table)
+        .filter(d::id.eq(site.id))
+        .select(<(Deployment, Head)>::as_select())
+        .first::<(Deployment, Head)>(conn)
+        .await
+        .map(DeploymentDetail::from)?;
+
+    StoredDeploymentEntity(detail, manifest).into_subgraph_deployment_entity(schema)
+}
+
+/// Load the entity count for a deployment from `subgraphs.head`.
+pub async fn entity_count(conn: &mut AsyncPgConnection, site: &Site) -> Result<usize, StoreError> {
+    use subgraph_head as h;
 
-    StoredDeploymentEntity(detail, manifest).as_subgraph_deployment(schema)
+    let count: i64 = h::table
+        .find(site.id)
+        .select(h::entity_count)
+        .first(conn)
+        .await?;
+    Ok(count as usize)
 }
 
 #[derive(Queryable, Identifiable, Insertable)]
-#[table_name = "graph_node_versions"]
+#[diesel(table_name = graph_node_versions)]
 pub struct GraphNodeVersion {
     pub id: i32,
     pub git_commit_hash: String,
@@ -482,7 +682,7 @@ pub struct GraphNodeVersion {
 }
 
 impl GraphNodeVersion {
-    pub(crate) fn create_or_get(conn: &PgConnection) -> anyhow::Result<i32> {
+    pub(crate) async fn create_or_get(conn: &mut AsyncPgConnection) -> anyhow::Result<i32> {
         let git_commit_hash = version_commit_hash!();
         let git_repository_dirty = !&TESTAMENT.modifications.is_empty();
         let crate_version = CARGO_PKG_VERSION;
@@ -510,7 +710,8 @@ impl GraphNodeVersion {
                     g::patch.eq(&patch),
                 ))
                 .on_conflict_do_nothing()
-                .execute(conn)?;
+                .execute(conn)
+                .await?;
 
             // select the id for the row we just inserted
             g::graph_node_versions
@@ -521,7 +722,8 @@ impl GraphNodeVersion {
                 .filter(g::major.eq(&major))
                 .filter(g::minor.eq(&minor))
                 .filter(g::patch.eq(&patch))
-                .get_result(conn)?
+                .get_result(conn)
+                .await?
         };
         Ok(graph_node_version_id)
     }
diff --git a/store/postgres/src/dynds/mod.rs b/store/postgres/src/dynds/mod.rs
index b62957d1e91..e53474ae280 100644
--- a/store/postgres/src/dynds/mod.rs
+++ b/store/postgres/src/dynds/mod.rs
@@ -3,52 +3,63 @@ pub(crate) mod shared;
 
 pub(crate) use private::DataSourcesTable;
 
-use crate::primary::Site;
-use diesel::PgConnection;
+use crate::{AsyncPgConnection, primary::Site};
 use graph::{
-    components::store::{write, StoredDynamicDataSource},
-    constraint_violation,
+    components::store::{StoredDynamicDataSource, write},
     data_source::CausalityRegion,
+    internal_error,
     prelude::{BlockNumber, StoreError},
 };
 
-pub fn load(
-    conn: &PgConnection,
+pub async fn load(
+    conn: &mut AsyncPgConnection,
     site: &Site,
     block: BlockNumber,
     manifest_idx_and_name: Vec<(u32, String)>,
 ) -> Result<Vec<StoredDynamicDataSource>, StoreError> {
     match site.schema_version.private_data_sources() {
-        true => DataSourcesTable::new(site.namespace.clone()).load(conn, block),
-        false => shared::load(conn, site.deployment.as_str(), block, manifest_idx_and_name),
+        true => {
+            DataSourcesTable::new(site.namespace.clone())
+                .load(conn, block)
+                .await
+        }
+        false => shared::load(conn, site.deployment.as_str(), block, manifest_idx_and_name).await,
     }
 }
 
-pub(crate) fn insert(
-    conn: &PgConnection,
+pub(crate) async fn insert(
+    conn: &mut AsyncPgConnection,
     site: &Site,
     data_sources: &write::DataSources,
     manifest_idx_and_name: &[(u32, String)],
 ) -> Result<usize, StoreError> {
     match site.schema_version.private_data_sources() {
-        true => DataSourcesTable::new(site.namespace.clone()).insert(conn, data_sources),
-        false => shared::insert(conn, &site.deployment, data_sources, manifest_idx_and_name),
+        true => {
+            DataSourcesTable::new(site.namespace.clone())
+                .insert(conn, data_sources)
+                .await
+        }
+        false => shared::insert(conn, &site.deployment, data_sources, manifest_idx_and_name).await,
     }
 }
 
-pub(crate) fn revert(
-    conn: &PgConnection,
+pub(crate) async fn revert(
+    conn: &mut AsyncPgConnection,
     site: &Site,
     block: BlockNumber,
 ) -> Result<(), StoreError> {
     match site.schema_version.private_data_sources() {
-        true => DataSourcesTable::new(site.namespace.clone()).revert(conn, block),
-        false => shared::revert(conn, &site.deployment, block),
+        true => {
+            DataSourcesTable::new(site.namespace.clone())
+                .revert(conn, block)
+                .await
+        }
+        false => shared::revert(conn, &site.deployment, block).await,
     }
 }
 
-pub(crate) fn update_offchain_status(
-    conn: &PgConnection,
+pub(crate) async fn update_offchain_status(
+    conn: &mut AsyncPgConnection,
     site: &Site,
     data_sources: &write::DataSources,
 ) -> Result<(), StoreError> {
@@ -58,21 +69,27 @@ pub(crate) fn update_offchain_status(
 
     match site.schema_version.private_data_sources() {
         true => {
-            DataSourcesTable::new(site.namespace.clone()).update_offchain_status(conn, data_sources)
+            DataSourcesTable::new(site.namespace.clone())
+                .update_offchain_status(conn, data_sources)
+                .await
         }
-        false => Err(constraint_violation!(
+        false => Err(internal_error!(
             "shared schema does not support data source offchain_found",
         )),
     }
 }
 
 /// The maximum assigned causality region. Any higher number is therefore free to be assigned.
-pub(crate) fn causality_region_curr_val(
-    conn: &PgConnection,
+pub(crate) async fn causality_region_curr_val(
+    conn: &mut AsyncPgConnection,
     site: &Site,
 ) -> Result<Option<CausalityRegion>, StoreError> {
     match site.schema_version.private_data_sources() {
-        true => DataSourcesTable::new(site.namespace.clone()).causality_region_curr_val(conn),
+        true => {
+            DataSourcesTable::new(site.namespace.clone())
+                .causality_region_curr_val(conn)
+                .await
+        }
 
         // Subgraphs on the legacy shared table do not use offchain data sources.
         false => Ok(None),
diff --git a/store/postgres/src/dynds/private.rs b/store/postgres/src/dynds/private.rs
index 5b8a6a746a0..714e1741245 100644
--- a/store/postgres/src/dynds/private.rs
+++ b/store/postgres/src/dynds/private.rs
@@ -1,22 +1,25 @@
-use std::ops::Bound;
+use std::{collections::HashMap, ops::Bound};
 
 use diesel::{
-    pg::types::sql_types,
-    prelude::*,
+    ExpressionMethods, OptionalExtension, QueryDsl, QueryResult,
+    pg::{Pg, sql_types},
+    query_builder::{AstPass, QueryFragment, QueryId},
     sql_query,
-    sql_types::{Binary, Integer, Jsonb, Nullable},
-    PgConnection, QueryDsl, RunQueryDsl,
+    sql_types::{BigInt, Binary, Bool, Integer, Jsonb, Nullable, Text},
 };
+use diesel_async::RunQueryDsl;
 
 use graph::{
-    anyhow::Context,
-    components::store::{write, StoredDynamicDataSource},
-    constraint_violation,
+    anyhow::{Context, anyhow},
+    components::store::{StoredDynamicDataSource, write},
     data_source::CausalityRegion,
-    prelude::{serde_json, BlockNumber, StoreError},
+    internal_error,
+    prelude::{BlockNumber, StoreError, serde_json},
 };
 
-use crate::primary::Namespace;
+use crate::parquet::convert::DataSourceRestoreRow;
+
+use crate::{AsyncPgConnection, primary::Namespace, relational_queries::POSTGRES_MAX_PARAMETERS};
 
 type DynTable = diesel_dynamic_schema::Table<String, Namespace>;
 type DynColumn<ST> = diesel_dynamic_schema::Column<DynTable, &'static str, ST>;
@@ -56,6 +59,10 @@ impl DataSourcesTable {
         }
     }
 
+    pub(crate) fn qualified_name(&self) -> &str {
+        &self.qname
+    }
+
     pub(crate) fn as_ddl(&self) -> String {
         format!(
             "
@@ -82,9 +89,9 @@ impl DataSourcesTable {
     // Query to load the data sources which are live at `block`. Ordering by the creation block and
     // `vid` makes sure they are in insertion order which is important for the correctness of
     // reverts and the execution order of triggers. See also 8f1bca33-d3b7-4035-affc-fd6161a12448.
-    pub(super) fn load(
+    pub(super) async fn load(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         block: BlockNumber,
     ) -> Result<Vec<StoredDynamicDataSource>, StoreError> {
         type Tuple = (
@@ -98,7 +105,7 @@ impl DataSourcesTable {
         let tuples = self
             .table
             .clone()
-            .filter(diesel::dsl::sql("block_range @> ").bind::<Integer, _>(block))
+            .filter(diesel::dsl::sql::<Bool>("block_range @> ").bind::<Integer, _>(block))
             .select((
                 &self.block_range,
                 &self.manifest_idx,
@@ -108,7 +115,8 @@ impl DataSourcesTable {
                 &self.done_at,
             ))
             .order_by(&self.vid)
-            .load::<Tuple>(conn)?;
+            .load::<Tuple>(conn)
+            .await?;
 
         let mut dses: Vec<_> = tuples
             .into_iter()
@@ -141,9 +149,9 @@ impl DataSourcesTable {
         Ok(dses)
     }
 
-    pub(crate) fn insert(
+    pub(crate) async fn insert(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         data_sources: &write::DataSources,
     ) -> Result<usize, StoreError> {
         let mut inserted_total = 0;
@@ -163,7 +171,7 @@ impl DataSourcesTable {
                 // Nested offchain data sources might not pass this check, as their `creation_block`
                 // will be their parent's `creation_block`, not necessarily `block`.
                 if causality_region == &CausalityRegion::ONCHAIN && creation_block != &Some(block) {
-                    return Err(constraint_violation!(
+                    return Err(internal_error!(
                         "mismatching creation blocks `{:?}` and `{}`",
                         creation_block,
                         block
@@ -173,10 +181,10 @@ impl DataSourcesTable {
                 // Offchain data sources have a unique causality region assigned from a sequence in the
                 // database, while onchain data sources always have causality region 0.
                 let query = format!(
-                "insert into {}(block_range, manifest_idx, param, context, causality_region, done_at) \
+                    "insert into {}(block_range, manifest_idx, param, context, causality_region, done_at) \
                             values (int4range($1, null), $2, $3, $4, $5, $6)",
-                self.qname
-            );
+                    self.qname
+                );
 
                 let query = sql_query(query)
                     .bind::<Nullable<Integer>, _>(creation_block)
@@ -186,13 +194,17 @@ impl DataSourcesTable {
                     .bind::<Integer, _>(causality_region)
                     .bind::<Nullable<Integer>, _>(done_at);
 
-                inserted_total += query.execute(conn)?;
+                inserted_total += query.execute(conn).await?;
             }
         }
         Ok(inserted_total)
     }
 
-    pub(crate) fn revert(&self, conn: &PgConnection, block: BlockNumber) -> Result<(), StoreError> {
+    pub(crate) async fn revert(
+        &self,
+        conn: &mut AsyncPgConnection,
+        block: BlockNumber,
+    ) -> Result<(), StoreError> {
         // Use the 'does not extend to the left of' operator `&>` to leverage the gist index, this
         // is equivalent to lower(block_range) >= $1.
         //
@@ -202,39 +214,40 @@ impl DataSourcesTable {
             "delete from {} where block_range &> int4range($1, null)",
             self.qname
         );
-        sql_query(query).bind::<Integer, _>(block).execute(conn)?;
+        sql_query(query)
+            .bind::<Integer, _>(block)
+            .execute(conn)
+            .await?;
         Ok(())
     }
 
     /// Copy the dynamic data sources from `self` to `dst`. All data sources that
     /// were created up to and including `target_block` will be copied.
-    pub(crate) fn copy_to(
+    pub(crate) async fn copy_to(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         dst: &DataSourcesTable,
         target_block: BlockNumber,
         src_manifest_idx_and_name: &[(i32, String)],
         dst_manifest_idx_and_name: &[(i32, String)],
     ) -> Result<usize, StoreError> {
         // Check if there are any data sources for dst which indicates we already copied
-        let count = dst.table.clone().count().get_result::<i64>(conn)?;
+        let count = dst.table.clone().count().get_result::<i64>(conn).await?;
         if count > 0 {
             return Ok(count as usize);
         }
 
-        type Tuple = (
-            (Bound<i32>, Bound<i32>),
-            i32,
-            Option<Vec<u8>>,
-            Option<serde_json::Value>,
-            i32,
-            Option<i32>,
-        );
+        let manifest_map =
+            ManifestIdxMap::new(src_manifest_idx_and_name, dst_manifest_idx_and_name);
 
-        let src_tuples = self
+        // Load all data sources that were created up to and including
+        // `target_block` and transform them ready for insertion
+        let dss: Vec<_> = self
             .table
             .clone()
-            .filter(diesel::dsl::sql("lower(block_range) <= ").bind::<Integer, _>(target_block))
+            .filter(
+                diesel::dsl::sql::<Bool>("lower(block_range) <= ").bind::<Integer, _>(target_block),
+            )
             .select((
                 &self.block_range,
                 &self.manifest_idx,
@@ -244,51 +257,32 @@ impl DataSourcesTable {
                 &self.done_at,
             ))
             .order_by(&self.vid)
-            .load::<Tuple>(conn)?;
+            .load::<DsForCopy>(conn)
+            .await?
+            .into_iter()
+            .map(|ds| ds.src_to_dst(target_block, &manifest_map, &self.namespace, &dst.namespace))
+            .collect::<Result<_, _>>()?;
 
+        // Split all dss into chunks so that we never use more than
+        // `POSTGRES_MAX_PARAMETERS` bind variables per chunk
+        let chunk_size = POSTGRES_MAX_PARAMETERS / CopyDsQuery::BIND_PARAMS;
         let mut count = 0;
-        for (block_range, src_manifest_idx, param, context, causality_region, done_at) in src_tuples
-        {
-            let name = &src_manifest_idx_and_name
-                .iter()
-                .find(|(idx, _)| idx == &src_manifest_idx)
-                .context("manifest_idx not found in src")?
-                .1;
-            let dst_manifest_idx = dst_manifest_idx_and_name
-                .iter()
-                .find(|(_, n)| n == name)
-                .context("name not found in dst")?
-                .0;
-
-            let query = format!(
-                "\
-             insert into {dst}(block_range, manifest_idx, param, context, causality_region, done_at)
-             values(case
-                 when upper($2) <= $1 then $2
-                 else int4range(lower($2), null)
-             end,
-             $3, $4, $5, $6, $7)
-             ",
-                dst = dst.qname
-            );
-
-            count += sql_query(query)
-                .bind::<Integer, _>(target_block)
-                .bind::<sql_types::Range<Integer>, _>(block_range)
-                .bind::<Integer, _>(dst_manifest_idx)
-                .bind::<Nullable<Binary>, _>(param)
-                .bind::<Nullable<Jsonb>, _>(context)
-                .bind::<Integer, _>(causality_region)
-                .bind::<Nullable<Integer>, _>(done_at)
-                .execute(conn)?;
+        for chunk in dss.chunks(chunk_size) {
+            let query = CopyDsQuery::new(dst, chunk)?;
+            count += query.execute(conn).await?;
         }
 
         // If the manifest idxes remained constant, we can test that both tables have the same
         // contents.
         if src_manifest_idx_and_name == dst_manifest_idx_and_name {
             debug_assert!(
-                self.load(conn, target_block).map_err(|e| e.to_string())
-                    == dst.load(conn, target_block).map_err(|e| e.to_string())
+                self.load(conn, target_block)
+                    .await
+                    .map_err(|e| e.to_string())
+                    == dst
+                        .load(conn, target_block)
+                        .await
+                        .map_err(|e| e.to_string())
             );
         }
 
@@ -297,9 +291,9 @@ impl DataSourcesTable {
 
     // Remove offchain data sources by checking the causality region, which currently uniquely
     // identifies an offchain data source.
-    pub(super) fn update_offchain_status(
+    pub(super) async fn update_offchain_status(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         data_sources: &write::DataSources,
     ) -> Result<(), StoreError> {
         for (_, dss) in &data_sources.entries {
@@ -312,14 +306,15 @@ impl DataSourcesTable {
                 let count = sql_query(query)
                     .bind::<Nullable<Integer>, _>(ds.done_at)
                     .bind::<Integer, _>(ds.causality_region)
-                    .execute(conn)?;
+                    .execute(conn)
+                    .await?;
 
                 if count > 1 {
-                    return Err(constraint_violation!(
-                    "expected to remove at most one offchain data source but would remove {}, causality region: {}",
-                    count,
-                    ds.causality_region
-                ));
+                    return Err(internal_error!(
+                        "expected to remove at most one offchain data source but would remove {}, causality region: {}",
+                        count,
+                        ds.causality_region
+                    ));
                 }
             }
         }
@@ -329,9 +324,9 @@ impl DataSourcesTable {
 
     /// The current causality sequence according to the store, which is infered to be the maximum
     /// value existing in the table.
-    pub(super) fn causality_region_curr_val(
+    pub(super) async fn causality_region_curr_val(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
     ) -> Result<Option<CausalityRegion>, StoreError> {
         // Get the maximum `causality_region` leveraging the btree index.
         Ok(self
@@ -340,6 +335,217 @@ impl DataSourcesTable {
             .select(&self.causality_region)
             .order_by((&self.causality_region).desc())
             .first::<CausalityRegion>(conn)
+            .await
             .optional()?)
     }
+
+    /// Insert rows from a dump/restore into the `data_sources$` table.
+    /// Rows are batched to stay within PostgreSQL's bind parameter limit.
+    pub(crate) async fn insert_rows(
+        &self,
+        conn: &mut AsyncPgConnection,
+        rows: &[DataSourceRestoreRow],
+    ) -> Result<usize, StoreError> {
+        let chunk_size = POSTGRES_MAX_PARAMETERS / RestoreDsQuery::BIND_PARAMS;
+        let mut count = 0;
+        for chunk in rows.chunks(chunk_size) {
+            let query = RestoreDsQuery {
+                qname: &self.qname,
+                rows: chunk,
+            };
+            count += query.execute(conn).await?;
+        }
+        Ok(count)
+    }
+}
+
+/// Map src manifest indexes to dst manifest indexes. If the
+/// destination is missing an entry, put `None` as the value for the
+/// source index
+struct ManifestIdxMap {
+    map: HashMap<i32, (Option<i32>, String)>,
+}
+
+impl ManifestIdxMap {
+    fn new(src: &[(i32, String)], dst: &[(i32, String)]) -> Self {
+        let dst_idx_map: HashMap<&String, i32> =
+            HashMap::from_iter(dst.iter().map(|(idx, name)| (name, *idx)));
+        let map = src
+            .iter()
+            .map(|(src_idx, src_name)| {
+                (
+                    *src_idx,
+                    (dst_idx_map.get(src_name).copied(), src_name.to_string()),
+                )
+            })
+            .collect();
+        ManifestIdxMap { map }
+    }
+
+    fn dst_idx(
+        &self,
+        src_idx: i32,
+        src_nsp: &Namespace,
+        src_created: BlockNumber,
+        dst_nsp: &Namespace,
+    ) -> Result<i32, StoreError> {
+        let (dst_idx, name) = self.map.get(&src_idx).with_context(|| {
+            anyhow!(
+                "the source {src_nsp} does not have a template with \
+              index {src_idx} but created one at block {src_created}"
+            )
+        })?;
+        let dst_idx = dst_idx.with_context(|| {
+            anyhow!(
+                "the destination {dst_nsp} is missing a template with \
+                name {name}. The source {src_nsp} created one at block {src_created}"
+            )
+        })?;
+        Ok(dst_idx)
+    }
+}
+
+#[derive(Queryable)]
+struct DsForCopy {
+    block_range: (Bound<i32>, Bound<i32>),
+    idx: i32,
+    param: Option<Vec<u8>>,
+    context: Option<serde_json::Value>,
+    causality_region: i32,
+    done_at: Option<i32>,
+}
+
+impl DsForCopy {
+    fn src_to_dst(
+        mut self,
+        target_block: BlockNumber,
+        map: &ManifestIdxMap,
+        src_nsp: &Namespace,
+        dst_nsp: &Namespace,
+    ) -> Result<Self, StoreError> {
+        // unclamp block range if it ends beyond target block
+        match self.block_range.1 {
+            Bound::Included(block) if block > target_block => self.block_range.1 = Bound::Unbounded,
+            Bound::Excluded(block) if block - 1 > target_block => {
+                self.block_range.1 = Bound::Unbounded
+            }
+            _ => { /* use block range as is */ }
+        }
+        // Translate manifest index
+        let src_created = match self.block_range.0 {
+            Bound::Included(block) => block,
+            Bound::Excluded(block) => block + 1,
+            Bound::Unbounded => 0,
+        };
+        self.idx = map.dst_idx(self.idx, src_nsp, src_created, dst_nsp)?;
+        Ok(self)
+    }
+}
+
+struct CopyDsQuery<'a> {
+    dst: &'a DataSourcesTable,
+    dss: &'a [DsForCopy],
+}
+
+impl<'a> CopyDsQuery<'a> {
+    const BIND_PARAMS: usize = 6;
+
+    fn new(dst: &'a DataSourcesTable, dss: &'a [DsForCopy]) -> Result<Self, StoreError> {
+        Ok(CopyDsQuery { dst, dss })
+    }
+}
+
+impl<'a> QueryFragment<Pg> for CopyDsQuery<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+        out.push_sql("insert into ");
+        out.push_sql(&self.dst.qname);
+        out.push_sql(
+            "(block_range, manifest_idx, param, context, causality_region, done_at) values ",
+        );
+        let mut first = true;
+        for ds in self.dss.iter() {
+            if first {
+                first = false;
+            } else {
+                out.push_sql(", ");
+            }
+            out.push_sql("(");
+            out.push_bind_param::<sql_types::Range<Integer>, _>(&ds.block_range)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Integer, _>(&ds.idx)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Nullable<Binary>, _>(&ds.param)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Nullable<Jsonb>, _>(&ds.context)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Integer, _>(&ds.causality_region)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Nullable<Integer>, _>(&ds.done_at)?;
+            out.push_sql(")");
+        }
+
+        Ok(())
+    }
+}
+
+impl<'a> QueryId for CopyDsQuery<'a> {
+    type QueryId = ();
+
+    const HAS_STATIC_QUERY_ID: bool = false;
+}
+
+struct RestoreDsQuery<'a> {
+    qname: &'a str,
+    rows: &'a [DataSourceRestoreRow],
+}
+
+impl<'a> RestoreDsQuery<'a> {
+    const BIND_PARAMS: usize = 10;
+}
+
+impl<'a> QueryFragment<Pg> for RestoreDsQuery<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+        out.push_sql("insert into ");
+        out.push_sql(self.qname);
+        out.push_sql(
+            "(vid, block_range, causality_region, manifest_idx, \
+             parent, id, param, context, done_at) values ",
+        );
+        for (i, row) in self.rows.iter().enumerate() {
+            if i > 0 {
+                out.push_sql(", ");
+            }
+            out.push_sql("(");
+            out.push_bind_param::<BigInt, _>(&row.vid)?;
+            out.push_sql(", int4range(");
+            out.push_bind_param::<Integer, _>(&row.block_range_start)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Nullable<Integer>, _>(&row.block_range_end)?;
+            out.push_sql("), ");
+            out.push_bind_param::<Integer, _>(&row.causality_region)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Integer, _>(&row.manifest_idx)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Nullable<Integer>, _>(&row.parent)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Nullable<Binary>, _>(&row.id)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Nullable<Binary>, _>(&row.param)?;
+            out.push_sql(", ");
+            out.push_bind_param::<Nullable<Text>, _>(&row.context)?;
+            out.push_sql("::jsonb, ");
+            out.push_bind_param::<Nullable<Integer>, _>(&row.done_at)?;
+            out.push_sql(")");
+        }
+
+        Ok(())
+    }
+}
+
+impl<'a> QueryId for RestoreDsQuery<'a> {
+    type QueryId = ();
+
+    const HAS_STATIC_QUERY_ID: bool = false;
 }
diff --git a/store/postgres/src/dynds/shared.rs b/store/postgres/src/dynds/shared.rs
index ed4e400fcba..d5e86332115 100644
--- a/store/postgres/src/dynds/shared.rs
+++ b/store/postgres/src/dynds/shared.rs
@@ -1,24 +1,25 @@
 //! SQL queries to load dynamic data sources
 
+use diesel::insert_into;
 use diesel::{
     delete,
     dsl::{count, sql},
-    prelude::{ExpressionMethods, QueryDsl, RunQueryDsl},
+    prelude::{ExpressionMethods, QueryDsl},
     sql_query,
     sql_types::{Integer, Text},
 };
-use diesel::{insert_into, pg::PgConnection};
+use diesel_async::RunQueryDsl;
 
 use graph::{
-    components::store::{write, StoredDynamicDataSource},
-    constraint_violation,
+    components::store::{StoredDynamicDataSource, write},
+    data::store::scalar::ToPrimitive,
     data_source::CausalityRegion,
-    prelude::{
-        bigdecimal::ToPrimitive, serde_json, BigDecimal, BlockNumber, DeploymentHash, StoreError,
-    },
+    internal_error,
+    prelude::{BigDecimal, BlockNumber, DeploymentHash, StoreError, serde_json},
 };
 
-use crate::connection_pool::ForeignServer;
+use crate::AsyncPgConnection;
+use crate::ForeignServer;
 use crate::primary::Site;
 
 table! {
@@ -36,8 +37,8 @@ table! {
     }
 }
 
-pub(super) fn load(
-    conn: &PgConnection,
+pub(super) async fn load(
+    conn: &mut AsyncPgConnection,
     id: &str,
     block: BlockNumber,
     manifest_idx_and_name: Vec<(u32, String)>,
@@ -58,22 +59,24 @@ pub(super) fn load(
         ))
         .filter(decds::ethereum_block_number.le(sql(&format!("{}::numeric", block))))
         .order_by((decds::ethereum_block_number, decds::vid))
-        .load::<(i64, String, Option<String>, Vec<u8>, BigDecimal)>(conn)?;
+        .load::<(i64, String, Option<String>, Vec<u8>, BigDecimal)>(conn)
+        .await?;
 
     let mut data_sources: Vec<StoredDynamicDataSource> = Vec::new();
     for (vid, name, context, address, creation_block) in dds.into_iter() {
         if address.len() != 20 {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "Data source address `0x{:?}` for dynamic data source {} should be 20 bytes long but is {} bytes long",
-                address, vid,
-            address.len()
-        ));
+                address,
+                vid,
+                address.len()
+            ));
         }
 
         let manifest_idx = manifest_idx_and_name
             .iter()
             .find(|(_, manifest_name)| manifest_name == &name)
-            .ok_or_else(|| constraint_violation!("data source name {} not found", name))?
+            .ok_or_else(|| internal_error!("data source name {} not found", name))?
             .0;
         let creation_block = creation_block.to_i32();
         let data_source = StoredDynamicDataSource {
@@ -89,7 +92,7 @@ pub(super) fn load(
         };
 
         if data_sources.last().and_then(|d| d.creation_block) > data_source.creation_block {
-            return Err(StoreError::ConstraintViolation(
+            return Err(StoreError::InternalError(
                 "data sources not ordered by creation block".to_string(),
             ));
         }
@@ -99,8 +102,8 @@ pub(super) fn load(
     Ok(data_sources)
 }
 
-pub(super) fn insert(
-    conn: &PgConnection,
+pub(super) async fn insert(
+    conn: &mut AsyncPgConnection,
     deployment: &DeploymentHash,
     data_sources: &write::DataSources,
     manifest_idx_and_name: &[(u32, String)],
@@ -115,7 +118,7 @@ pub(super) fn insert(
     let dds: Vec<_> = data_sources
         .entries
         .iter()
-        .map(|(block_ptr, dds)| {
+        .flat_map(|(block_ptr, dds)| {
             dds.iter().map(|ds| {
                 let StoredDynamicDataSource {
                     manifest_idx: _,
@@ -127,7 +130,7 @@ pub(super) fn insert(
                 } = ds;
 
                 if causality_region != &CausalityRegion::ONCHAIN {
-                    return Err(constraint_violation!(
+                    return Err(internal_error!(
                         "using shared data source schema with file data sources"
                     ));
                 }
@@ -135,17 +138,13 @@ pub(super) fn insert(
                 let address = match param {
                     Some(param) => param,
                     None => {
-                        return Err(constraint_violation!(
-                            "dynamic data sources must have an addres",
-                        ));
+                        return Err(internal_error!("dynamic data sources must have an address",));
                     }
                 };
                 let name = manifest_idx_and_name
                     .iter()
                     .find(|(idx, _)| *idx == ds.manifest_idx)
-                    .ok_or_else(|| {
-                        constraint_violation!("manifest idx {} not found", ds.manifest_idx)
-                    })?
+                    .ok_or_else(|| internal_error!("manifest idx {} not found", ds.manifest_idx))?
                     .1
                     .clone();
                 Ok((
@@ -162,19 +161,19 @@ pub(super) fn insert(
                 ))
             })
         })
-        .flatten()
         .collect::<Result<_, _>>()?;
 
     insert_into(decds::table)
         .values(dds)
         .execute(conn)
+        .await
         .map_err(|e| e.into())
 }
 
 /// Copy the dynamic data sources for `src` to `dst`. All data sources that
 /// were created up to and including `target_block` will be copied.
-pub(crate) fn copy(
-    conn: &PgConnection,
+pub(crate) async fn copy(
+    conn: &mut AsyncPgConnection,
     src: &Site,
     dst: &Site,
     target_block: BlockNumber,
@@ -194,7 +193,8 @@ pub(crate) fn copy(
     let count = decds::table
         .filter(decds::deployment.eq(dst.deployment.as_str()))
         .select(count(decds::vid))
-        .get_result::<i64>(conn)?;
+        .get_result::<i64>(conn)
+        .await?;
     if count > 0 {
         return Ok(count as usize);
     }
@@ -217,25 +217,32 @@ pub(crate) fn copy(
         .bind::<Text, _>(src.deployment.as_str())
         .bind::<Text, _>(dst.deployment.as_str())
         .bind::<Integer, _>(target_block)
-        .execute(conn)?)
+        .execute(conn)
+        .await?)
 }
 
-pub(super) fn revert(
-    conn: &PgConnection,
+pub(super) async fn revert(
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
     block: BlockNumber,
 ) -> Result<(), StoreError> {
     use dynamic_ethereum_contract_data_source as decds;
 
     let dds = decds::table.filter(decds::deployment.eq(id.as_str()));
-    delete(dds.filter(decds::ethereum_block_number.ge(sql(&block.to_string())))).execute(conn)?;
+    delete(dds.filter(decds::ethereum_block_number.ge(sql(&block.to_string()))))
+        .execute(conn)
+        .await?;
     Ok(())
 }
 
-pub(crate) fn drop(conn: &PgConnection, id: &DeploymentHash) -> Result<usize, StoreError> {
+pub(crate) async fn drop(
+    conn: &mut AsyncPgConnection,
+    id: &DeploymentHash,
+) -> Result<usize, StoreError> {
     use dynamic_ethereum_contract_data_source as decds;
 
     delete(decds::table.filter(decds::deployment.eq(id.as_str())))
         .execute(conn)
+        .await
         .map_err(|e| e.into())
 }
diff --git a/store/postgres/src/fork.rs b/store/postgres/src/fork.rs
index 2d7879fbdd5..07241577a53 100644
--- a/store/postgres/src/fork.rs
+++ b/store/postgres/src/fork.rs
@@ -4,13 +4,13 @@ use std::{
     sync::Mutex,
 };
 
+use async_trait::async_trait;
 use graph::{
-    block_on,
     components::store::SubgraphFork as SubgraphForkTrait,
-    constraint_violation,
+    internal_error,
     prelude::{
-        info, r::Value as RValue, reqwest, serde_json, DeploymentHash, Entity, Logger, Serialize,
-        StoreError, Value, ValueType,
+        DeploymentHash, Entity, Logger, Serialize, StoreError, Value, ValueType, anyhow, info,
+        r::Value as RValue, reqwest, serde_json,
     },
     schema::Field,
     url::Url,
@@ -44,8 +44,13 @@ pub(crate) struct SubgraphFork {
     logger: Logger,
 }
 
+#[async_trait]
 impl SubgraphForkTrait for SubgraphFork {
-    fn fetch(&self, entity_type_name: String, id: String) -> Result<Option<Entity>, StoreError> {
+    async fn fetch(
+        &self,
+        entity_type_name: String,
+        id: String,
+    ) -> Result<Option<Entity>, StoreError> {
         {
             let mut fids = self.fetched_ids.lock().map_err(|e| {
                 StoreError::ForkFailure(format!(
@@ -69,16 +74,14 @@ impl SubgraphForkTrait for SubgraphFork {
         let entity_type = self.schema.entity_type(&entity_type_name)?;
         let fields = &entity_type
             .object_type()
-            .map_err(|_| {
-                constraint_violation!("no object type called `{}` found", entity_type_name)
-            })?
+            .map_err(|_| internal_error!("no object type called `{}` found", entity_type_name))?
             .fields;
 
         let query = Query {
             query: self.query_string(&entity_type_name, fields)?,
             variables: Variables { id },
         };
-        let raw_json = block_on(self.send(&query))?;
+        let raw_json = self.send(&query).await?;
         if !raw_json.contains("data") {
             return Err(StoreError::ForkFailure(format!(
                 "the GraphQL query \"{:?}\" to `{}` failed with \"{}\"",
@@ -177,7 +180,7 @@ query Query ($id: String) {{
         let map: HashMap<Word, Value> = {
             let mut map = HashMap::new();
             for f in fields {
-                if f.is_derived {
+                if f.is_derived() {
                     // Derived fields are not resolved, so it's safe to ignore them.
                     continue;
                 }
@@ -206,16 +209,14 @@ query Query ($id: String) {{
                         e
                     ))
                 })?;
-                map.insert(Word::from(f.name.clone()), value);
+                map.insert(f.name.clone(), value);
             }
             map
         };
 
-        Ok(Some(
-            schema
-                .make_entity(map)
-                .map_err(|e| StoreError::EntityValidationError(e))?,
-        ))
+        Ok(Some(schema.make_entity(map).map_err(|e| {
+            StoreError::Unknown(anyhow!("entity validation failed: {e}"))
+        })?))
     }
 }
 
@@ -227,7 +228,7 @@ mod tests {
 
     use graph::{
         data::store::scalar,
-        prelude::{s::Type, DeploymentHash},
+        prelude::{DeploymentHash, s::Type},
         slog::{self, o},
     };
 
@@ -263,10 +264,10 @@ mod tests {
 
         let schema = schema.schema();
         vec![
-            Field::new(schema, "id", &non_null_type("ID"), false),
-            Field::new(schema, "owner", &non_null_type("Bytes"), false),
-            Field::new(schema, "displayName", &non_null_type("String"), false),
-            Field::new(schema, "imageUrl", &non_null_type("String"), false),
+            Field::new(schema, "id", &non_null_type("ID"), None),
+            Field::new(schema, "owner", &non_null_type("Bytes"), None),
+            Field::new(schema, "displayName", &non_null_type("String"), None),
+            Field::new(schema, "imageUrl", &non_null_type("String"), None),
         ]
     }
 
diff --git a/store/postgres/src/functions.rs b/store/postgres/src/functions.rs
index 13e4c7dfab2..d9c4bd57e3b 100644
--- a/store/postgres/src/functions.rs
+++ b/store/postgres/src/functions.rs
@@ -1,22 +1,22 @@
 use diesel::sql_types::{Binary, Bool, Integer, Nullable, Numeric, Range, Text};
 
 // Create modules for hosting stored procedures
-sql_function! { fn current_setting(setting_name: Text, missing_ok: Bool) }
+define_sql_function! { fn current_setting(setting_name: Text, missing_ok: Bool) }
 
-sql_function! {
+define_sql_function! {
     fn set_config(setting_name: Text, new_value: Text, is_local: Bool)
 }
 
-sql_function! {
+define_sql_function! {
     fn lower(range: Range<Integer>) -> Integer
 }
 
-sql_function! {
+define_sql_function! {
     #[sql_name="coalesce"]
     fn coalesce_numeric(first: Nullable<Numeric>, second: Nullable<Numeric>) -> Nullable<Numeric>
 }
 
-sql_function! {
+define_sql_function! {
     #[sql_name="coalesce"]
     fn coalesce_binary(first: Nullable<Binary>, second: Nullable<Binary>) -> Nullable<Binary>
 }
diff --git a/store/postgres/src/graphman/mod.rs b/store/postgres/src/graphman/mod.rs
new file mode 100644
index 00000000000..0c856c0e75b
--- /dev/null
+++ b/store/postgres/src/graphman/mod.rs
@@ -0,0 +1,99 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use chrono::Utc;
+use diesel::prelude::*;
+use diesel_async::RunQueryDsl;
+use graphman_store::CommandKind;
+use graphman_store::Execution;
+use graphman_store::ExecutionId;
+use graphman_store::ExecutionStatus;
+
+use crate::ConnectionPool;
+
+mod schema;
+
+use self::schema::graphman_command_executions as gce;
+
+#[derive(Clone)]
+pub struct GraphmanStore {
+    primary_pool: ConnectionPool,
+}
+
+impl GraphmanStore {
+    pub fn new(primary_pool: ConnectionPool) -> Self {
+        Self { primary_pool }
+    }
+}
+
+#[async_trait]
+impl graphman_store::GraphmanStore for GraphmanStore {
+    async fn new_execution(&self, kind: CommandKind) -> Result<ExecutionId> {
+        let mut conn = self.primary_pool.get_permitted().await?;
+
+        let id: i64 = diesel::insert_into(gce::table)
+            .values((
+                gce::kind.eq(kind),
+                gce::status.eq(ExecutionStatus::Initializing),
+                gce::created_at.eq(Utc::now()),
+            ))
+            .returning(gce::id)
+            .get_result(&mut conn)
+            .await?;
+
+        Ok(ExecutionId(id))
+    }
+
+    async fn load_execution(&self, id: ExecutionId) -> Result<Execution> {
+        let mut conn = self.primary_pool.get_permitted().await?;
+        let execution = gce::table.find(id).first(&mut conn).await?;
+
+        Ok(execution)
+    }
+
+    async fn mark_execution_as_running(&self, id: ExecutionId) -> Result<()> {
+        let mut conn = self.primary_pool.get_permitted().await?;
+
+        diesel::update(gce::table)
+            .set((
+                gce::status.eq(ExecutionStatus::Running),
+                gce::updated_at.eq(Utc::now()),
+            ))
+            .filter(gce::id.eq(id))
+            .filter(gce::completed_at.is_null())
+            .execute(&mut conn)
+            .await?;
+
+        Ok(())
+    }
+
+    async fn mark_execution_as_failed(&self, id: ExecutionId, error_message: String) -> Result<()> {
+        let mut conn = self.primary_pool.get_permitted().await?;
+
+        diesel::update(gce::table)
+            .set((
+                gce::status.eq(ExecutionStatus::Failed),
+                gce::error_message.eq(error_message),
+                gce::completed_at.eq(Utc::now()),
+            ))
+            .filter(gce::id.eq(id))
+            .execute(&mut conn)
+            .await?;
+
+        Ok(())
+    }
+
+    async fn mark_execution_as_succeeded(&self, id: ExecutionId) -> Result<()> {
+        let mut conn = self.primary_pool.get_permitted().await?;
+
+        diesel::update(gce::table)
+            .set((
+                gce::status.eq(ExecutionStatus::Succeeded),
+                gce::completed_at.eq(Utc::now()),
+            ))
+            .filter(gce::id.eq(id))
+            .execute(&mut conn)
+            .await?;
+
+        Ok(())
+    }
+}
diff --git a/store/postgres/src/graphman/schema.rs b/store/postgres/src/graphman/schema.rs
new file mode 100644
index 00000000000..fc721894a33
--- /dev/null
+++ b/store/postgres/src/graphman/schema.rs
@@ -0,0 +1,11 @@
+diesel::table! {
+    public.graphman_command_executions {
+        id -> BigSerial,
+        kind -> Varchar,
+        status -> Varchar,
+        error_message -> Nullable<Varchar>,
+        created_at -> Timestamptz,
+        updated_at -> Nullable<Timestamptz>,
+        completed_at -> Nullable<Timestamptz>,
+    }
+}
diff --git a/store/postgres/src/jobs.rs b/store/postgres/src/jobs.rs
index 1cff94f3648..7a90fcdd811 100644
--- a/store/postgres/src/jobs.rs
+++ b/store/postgres/src/jobs.rs
@@ -4,14 +4,15 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use async_trait::async_trait;
-use diesel::{prelude::RunQueryDsl, sql_query, sql_types::Double};
+use diesel::{sql_query, sql_types::Double};
+use diesel_async::RunQueryDsl;
 
-use graph::prelude::{error, Logger, MetricsRegistry, StoreError, ENV_VARS};
+use graph::prelude::{ENV_VARS, Logger, MetricsRegistry, StoreError, error};
 use graph::prometheus::Gauge;
 use graph::util::jobs::{Job, Runner};
 
-use crate::connection_pool::ConnectionPool;
-use crate::{unused, Store, SubgraphStore};
+use crate::ConnectionPool;
+use crate::{Store, SubgraphStore, unused};
 
 pub fn register(
     runner: &mut Runner,
@@ -47,12 +48,20 @@ pub fn register(
         Arc::new(RefreshMaterializedView::new(store.subgraph_store())),
         6 * ONE_HOUR,
     );
+
+    if let Some(interval) = ENV_VARS.store.account_like_scan_interval_hours {
+        runner.register(
+            Arc::new(AccountLikeJob::new(store.subgraph_store())),
+            interval * ONE_HOUR,
+        );
+    }
 }
 
-/// A job that vacuums `subgraphs.subgraph_deployment`. With a large number
-/// of subgraphs, the autovacuum daemon might not run often enough to keep
-/// this table, which is _very_ write-heavy, from getting bloated. We
-/// therefore set up a separate job that vacuums the table once a minute
+/// A job that vacuums `subgraphs.deployment` and `subgraphs.head`. With a
+/// large number of subgraphs, the autovacuum daemon might not run often
+/// enough to keep this table, which is _very_ write-heavy, from getting
+/// bloated. We therefore set up a separate job that vacuums the table once
+/// a minute
 struct VacuumDeploymentsJob {
     store: Arc<SubgraphStore>,
 }
@@ -66,16 +75,13 @@ impl VacuumDeploymentsJob {
 #[async_trait]
 impl Job for VacuumDeploymentsJob {
     fn name(&self) -> &str {
-        "Vacuum subgraphs.subgraph_deployment"
+        "Vacuum subgraphs.deployment and subgraphs.head"
     }
 
     async fn run(&self, logger: &Logger) {
         for res in self.store.vacuum().await {
             if let Err(e) = res {
-                error!(
-                    logger,
-                    "Vacuum of subgraphs.subgraph_deployment failed: {}", e
-                );
+                error!(logger, "Vacuum of subgraphs.deployment failed: {}", e);
             }
         }
     }
@@ -104,18 +110,16 @@ impl NotificationQueueUsage {
     async fn update(&self) -> Result<(), StoreError> {
         #[derive(QueryableByName)]
         struct Usage {
-            #[sql_type = "Double"]
+            #[diesel(sql_type = Double)]
             usage: f64,
         }
         let usage_gauge = self.usage_gauge.clone();
-        self.primary
-            .with_conn(move |conn, _| {
-                let res = sql_query("select pg_notification_queue_usage() as usage")
-                    .get_result::<Usage>(conn)?;
-                usage_gauge.set(res.usage);
-                Ok(())
-            })
-            .await
+        let mut conn = self.primary.get().await?;
+        let res = sql_query("select pg_notification_queue_usage() as usage")
+            .get_result::<Usage>(&mut conn)
+            .await?;
+        usage_gauge.set(res.usage);
+        Ok(())
     }
 }
 
@@ -201,7 +205,7 @@ impl Job for UnusedJob {
 
         let start = Instant::now();
 
-        if let Err(e) = self.store.record_unused_deployments() {
+        if let Err(e) = self.store.record_unused_deployments().await {
             error!(logger, "failed to record unused deployments"; "error" => e.to_string());
             return;
         }
@@ -210,7 +214,9 @@ impl Job for UnusedJob {
             .store
             .list_unused_deployments(unused::Filter::UnusedLongerThan(
                 ENV_VARS.store.remove_unused_interval,
-            )) {
+            ))
+            .await
+        {
             Ok(remove) => remove,
             Err(e) => {
                 error!(logger, "failed to list removable deployments"; "error" => e.to_string());
@@ -219,7 +225,7 @@ impl Job for UnusedJob {
         };
 
         for deployment in remove {
-            match self.store.remove_deployment(deployment.id) {
+            match self.store.remove_deployment(deployment.id).await {
                 Ok(()) => { /* ignore */ }
                 Err(e) => {
                     error!(logger, "failed to remove unused deployment";
@@ -236,3 +242,37 @@ impl Job for UnusedJob {
         }
     }
 }
+
+struct AccountLikeJob {
+    store: Arc<SubgraphStore>,
+}
+
+impl AccountLikeJob {
+    fn new(store: Arc<SubgraphStore>) -> AccountLikeJob {
+        AccountLikeJob { store }
+    }
+}
+
+#[async_trait]
+impl Job for AccountLikeJob {
+    fn name(&self) -> &str {
+        "Set account-like flag on eligible tables"
+    }
+
+    async fn run(&self, logger: &Logger) {
+        // Safe to unwrap due to a startup validation
+        // which ensures these values are present when account_like_scan_interval_hours is set.
+        let min_versions_count = ENV_VARS.store.account_like_min_versions_count.unwrap();
+        let ratio = ENV_VARS.store.account_like_max_unique_ratio.unwrap();
+
+        self.store
+            .identify_and_set_account_like(logger, min_versions_count, ratio)
+            .await
+            .unwrap_or_else(|e| {
+                error!(
+                    logger,
+                    "Failed to set account-like flag on eligible tables: {}", e
+                )
+            });
+    }
+}
diff --git a/store/postgres/src/jsonb.rs b/store/postgres/src/jsonb.rs
deleted file mode 100644
index b1657aface8..00000000000
--- a/store/postgres/src/jsonb.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use diesel::expression::helper_types::AsExprOf;
-use diesel::expression::{AsExpression, Expression};
-use diesel::sql_types::Jsonb;
-
-mod operators {
-    use diesel::sql_types::Jsonb;
-
-    // restrict to backend: Pg
-    diesel_infix_operator!(JsonbMerge, " || ", Jsonb, backend: diesel::pg::Pg);
-}
-
-// This is currently unused, but allowing JSONB merging in the database
-// is generally useful. We'll leave it here until we can merge it upstream
-// See https://github.com/diesel-rs/diesel/issues/2036
-#[allow(dead_code)]
-pub type JsonbMerge<Lhs, Rhs> = operators::JsonbMerge<Lhs, AsExprOf<Rhs, Jsonb>>;
-
-pub trait PgJsonbExpressionMethods: Expression<SqlType = Jsonb> + Sized {
-    fn merge<T: AsExpression<Jsonb>>(self, other: T) -> JsonbMerge<Self, T::Expression> {
-        JsonbMerge::<Self, T::Expression>::new(self, other.as_expression())
-    }
-}
-
-impl<T: Expression<SqlType = Jsonb>> PgJsonbExpressionMethods for T where
-    T: Expression<SqlType = Jsonb>
-{
-}
diff --git a/store/postgres/src/lib.rs b/store/postgres/src/lib.rs
index 11b1988c091..10cdf2ff627 100644
--- a/store/postgres/src/lib.rs
+++ b/store/postgres/src/lib.rs
@@ -2,8 +2,6 @@
 //! [Store] for the details of how the store is organized across
 //! different databases/shards.
 
-#[macro_use]
-extern crate derive_more;
 #[macro_use]
 extern crate diesel;
 #[macro_use]
@@ -17,7 +15,6 @@ mod block_store;
 mod catalog;
 mod chain_head_listener;
 mod chain_store;
-pub mod connection_pool;
 mod copy;
 mod deployment;
 mod deployment_store;
@@ -26,61 +23,70 @@ mod dynds;
 mod fork;
 mod functions;
 mod jobs;
-mod jsonb;
 mod notification_listener;
+mod parquet;
+mod pool;
 mod primary;
 pub mod query_store;
 mod relational;
 mod relational_queries;
 mod retry;
+mod sql;
 mod store;
 mod store_events;
 mod subgraph_store;
 pub mod transaction_receipt;
+mod vid_batcher;
 mod writable;
 
+pub mod graphman;
+
 #[cfg(debug_assertions)]
 pub mod layout_for_tests {
     pub use crate::block_range::*;
     pub use crate::block_store::FAKE_NETWORK_SHARED;
     pub use crate::catalog::set_account_like;
     pub use crate::primary::{
-        make_dummy_site, Connection, Mirror, Namespace, EVENT_TAP, EVENT_TAP_ENABLED,
+        Connection, EVENT_TAP, EVENT_TAP_ENABLED, Mirror, Namespace, make_dummy_site,
     };
     pub use crate::relational::*;
+    pub use crate::relational_queries::CopyEntityBatchQuery;
     pub mod writable {
         pub use crate::writable::test_support::allow_steps;
     }
 }
 
 pub use self::block_store::BlockStore;
+pub use self::block_store::primary::{add_chain, find_chain, update_chain_name};
 pub use self::chain_head_listener::ChainHeadUpdateListener;
-pub use self::chain_store::{ChainStore, ChainStoreMetrics};
+pub use self::chain_store::{ChainStore, ChainStoreMetrics, Storage};
 pub use self::detail::DeploymentDetail;
 pub use self::jobs::register as register_jobs;
 pub use self::notification_listener::NotificationSender;
-pub use self::primary::{db_version, UnusedDeployment};
+pub use self::pool::{AsyncPgConnection, ConnectionPool, ForeignServer, PoolCoordinator, PoolRole};
+pub use self::primary::{RestoreMode, UnusedDeployment, db_version};
 pub use self::store::Store;
 pub use self::store_events::SubscriptionManager;
-pub use self::subgraph_store::{unused, DeploymentPlacer, Shard, SubgraphStore, PRIMARY_SHARD};
+pub use self::subgraph_store::{DeploymentPlacer, PRIMARY_SHARD, Shard, SubgraphStore, unused};
 
 /// This module is only meant to support command line tooling. It must not
 /// be used in 'normal' graph-node code
 pub mod command_support {
     pub mod catalog {
         pub use crate::block_store::primary as block_store;
-        pub use crate::catalog::{account_like, stats};
+        pub use crate::catalog::{Catalog, account_like};
         pub use crate::copy::{copy_state, copy_table_state};
+        pub use crate::primary::{Connection, Mirror};
         pub use crate::primary::{
-            active_copies, deployment_schemas, ens_names, subgraph, subgraph_deployment_assignment,
-            subgraph_version, Site,
+            Site, active_copies, deployment_schemas, ens_names, subgraph,
+            subgraph_deployment_assignment, subgraph_version,
         };
-        pub use crate::primary::{Connection, Mirror};
     }
     pub mod index {
-        pub use crate::relational::index::{CreateIndex, Method};
+        pub use crate::relational::index::{CreateIndex, Expr, IndexCreator, Method};
     }
-    pub use crate::deployment::{on_sync, OnSync};
+    pub use crate::deployment::{OnSync, on_sync};
     pub use crate::primary::Namespace;
+    pub use crate::relational::prune::{Phase, PruneState, PruneTableState, Viewer};
     pub use crate::relational::{Catalog, Column, ColumnType, Layout, SqlName};
 }
diff --git a/store/postgres/src/notification_listener.rs b/store/postgres/src/notification_listener.rs
index 9ae012246e0..c72bf4f309d 100644
--- a/store/postgres/src/notification_listener.rs
+++ b/store/postgres/src/notification_listener.rs
@@ -1,4 +1,3 @@
-use diesel::pg::PgConnection;
 use diesel::select;
 use diesel::sql_types::Text;
 use graph::prelude::tokio::sync::mpsc::error::SendTimeoutError;
@@ -6,17 +5,20 @@ use graph::util::backoff::ExponentialBackoff;
 use lazy_static::lazy_static;
 use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
 use postgres::Notification;
-use postgres::{fallible_iterator::FallibleIterator, Client};
+use postgres::{Client, fallible_iterator::FallibleIterator};
 use postgres_openssl::MakeTlsConnector;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Barrier, Mutex};
+use std::sync::{Arc, Barrier};
 use std::thread;
 use std::time::{Duration, Instant};
-use tokio::sync::mpsc::{channel, Receiver};
+use tokio::sync::Mutex;
+use tokio::sync::mpsc::{Receiver, channel};
 
 use graph::prelude::serde_json;
 use graph::prelude::*;
 
+use crate::AsyncPgConnection;
+
 #[cfg(debug_assertions)]
 lazy_static::lazy_static! {
     /// Tests set this to true so that `send_store_event` will store a copy
@@ -284,6 +286,7 @@ impl NotificationListener {
                         }
                     }
                 }
+                warn!(logger, "Listener dropped. Terminating listener thread");
             }))
             .unwrap_or_else(|_| std::process::exit(1))
         });
@@ -323,8 +326,6 @@ mod public {
 // the `large_notifications` table.
 #[derive(Debug)]
 pub struct JsonNotification {
-    pub process_id: i32,
-    pub channel: String,
     pub payload: serde_json::Value,
 }
 
@@ -346,8 +347,7 @@ impl JsonNotification {
                     anyhow!("Invalid notification ID, not compatible with i64: {}", n)
                 })?;
 
-                if payload_id < (i32::min_value() as i64) || payload_id > (i32::max_value() as i64)
-                {
+                if payload_id < (i32::MIN as i64) || payload_id > (i32::MAX as i64) {
                     Err(anyhow!(
                         "Invalid notification ID, value exceeds i32: {}",
                         payload_id
@@ -367,22 +367,16 @@ impl JsonNotification {
                         )
                     })?;
 
-                if payload_rows.is_empty() || payload_rows.get(0).is_none() {
+                if payload_rows.is_empty() || payload_rows.is_empty() {
                     return Err(anyhow!("No payload found for notification {}", payload_id))?;
                 }
-                let payload: String = payload_rows.get(0).unwrap().get(0);
+                let payload: String = payload_rows.first().unwrap().get(0);
 
                 Ok(JsonNotification {
-                    process_id: notification.process_id(),
-                    channel: notification.channel().to_string(),
                     payload: serde_json::from_str(&payload)?,
                 })
             }
-            serde_json::Value::Object(_) => Ok(JsonNotification {
-                process_id: notification.process_id(),
-                channel: notification.channel().to_string(),
-                payload: value,
-            }),
+            serde_json::Value::Object(_) => Ok(JsonNotification { payload: value }),
             _ => Err(anyhow!("JSON notifications must be numbers or objects"))?,
         }
     }
@@ -411,34 +405,37 @@ impl NotificationSender {
     /// connection `conn` must be into the primary database as that's the
     /// only place where listeners connect. The `network` is only used for
     /// metrics gathering and does not affect how the notification is sent
-    pub fn notify(
+    pub async fn notify(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         channel: &str,
         network: Option<&str>,
         data: &serde_json::Value,
     ) -> Result<(), StoreError> {
         use diesel::ExpressionMethods;
-        use diesel::RunQueryDsl;
+        use diesel_async::RunQueryDsl;
         use public::large_notifications::dsl::*;
 
-        sql_function! {
+        define_sql_function! {
             fn pg_notify(channel: Text, msg: Text)
         }
 
         let msg = data.to_string();
 
         if msg.len() <= LARGE_NOTIFICATION_THRESHOLD {
-            select(pg_notify(channel, &msg)).execute(conn)?;
+            select(pg_notify(channel, &msg)).execute(conn).await?;
         } else {
             // Write the notification payload to the large_notifications table
             let payload_id: i32 = diesel::insert_into(large_notifications)
                 .values(payload.eq(&msg))
                 .returning(id)
-                .get_result(conn)?;
+                .get_result(conn)
+                .await?;
 
             // Use the large_notifications row ID as the payload for NOTIFY
-            select(pg_notify(channel, &payload_id.to_string())).execute(conn)?;
+            select(pg_notify(channel, &payload_id.to_string()))
+                .execute(conn)
+                .await?;
 
             // Prune old large_notifications. We want to keep the size of the
             // table manageable, but there's a lot of latitude in how often
@@ -456,16 +453,17 @@ impl NotificationSender {
 
             // If we can't get the lock, another thread in this process is
             // already checking, and we can just skip checking
-            if let Ok(mut last_check) = LAST_CLEANUP_CHECK.try_lock() {
-                if last_check.elapsed() > ENV_VARS.store.large_notification_cleanup_interval {
-                    diesel::sql_query(format!(
-                        "delete from large_notifications
+            if let Ok(mut last_check) = LAST_CLEANUP_CHECK.try_lock()
+                && last_check.elapsed() > ENV_VARS.store.large_notification_cleanup_interval
+            {
+                diesel::sql_query(format!(
+                    "delete from large_notifications
                          where created_at < current_timestamp - interval '{}s'",
-                        ENV_VARS.store.large_notification_cleanup_interval.as_secs(),
-                    ))
-                    .execute(conn)?;
-                    *last_check = Instant::now();
-                }
+                    ENV_VARS.store.large_notification_cleanup_interval.as_secs(),
+                ))
+                .execute(conn)
+                .await?;
+                *last_check = Instant::now();
             }
         }
         self.sent_counter
diff --git a/store/postgres/src/parquet/convert.rs b/store/postgres/src/parquet/convert.rs
new file mode 100644
index 00000000000..193a7b3e0bf
--- /dev/null
+++ b/store/postgres/src/parquet/convert.rs
@@ -0,0 +1,1259 @@
+use std::collections::HashMap;
+use std::path::Path;
+use std::str::FromStr;
+use std::sync::Arc;
+
+use arrow::array::{
+    Array, ArrayRef, BinaryArray, BinaryBuilder, BooleanArray, BooleanBuilder, Int32Array,
+    Int32Builder, Int64Array, Int64Builder, ListArray, ListBuilder, RecordBatch, StringArray,
+    StringBuilder, TimestampMicrosecondArray, TimestampMicrosecondBuilder,
+};
+use arrow::datatypes::{DataType, Schema};
+
+use graph::components::store::StoreError;
+use graph::data::store::Value;
+use graph::data::store::scalar;
+use graph::data::value::Word;
+use graph::prelude::BlockNumber;
+
+use crate::relational::value::{OidRow, OidValue};
+use crate::relational::{ColumnType, Table};
+
+/// Convert a batch of `DynamicRow<OidValue>` rows into an Arrow `RecordBatch`.
+///
+/// The `schema` defines the expected column names, types, and nullability.
+/// Each row must have exactly `schema.fields().len()` values, positionally
+/// matching the schema fields.
+///
+/// The dump query selects `lower(block_range)` and `upper(block_range)` as
+/// separate Int32 columns, so the converter never sees `OidValue::Int4Range`.
+pub fn rows_to_record_batch(schema: &Schema, rows: &[OidRow]) -> Result<RecordBatch, StoreError> {
+    let num_fields = schema.fields().len();
+    let num_rows = rows.len();
+
+    // Create builders for each column
+    let mut builders: Vec<ColumnBuilder> = schema
+        .fields()
+        .iter()
+        .map(|field| ColumnBuilder::new(field.data_type(), num_rows))
+        .collect::<Result<_, _>>()?;
+
+    // Append each row's values to the builders
+    for (row_idx, row) in rows.iter().enumerate() {
+        if row.len() != num_fields {
+            return Err(StoreError::InternalError(format!(
+                "row {row_idx} has {} values but schema has {num_fields} fields",
+                row.len()
+            )));
+        }
+        for (col_idx, value) in row.into_iter().enumerate() {
+            builders[col_idx].append(value, row_idx)?;
+        }
+    }
+
+    // Finish builders into arrays
+    let arrays: Vec<ArrayRef> = builders.into_iter().map(|b| b.finish()).collect();
+
+    RecordBatch::try_new(Arc::new(schema.clone()), arrays)
+        .map_err(|e| StoreError::InternalError(format!("failed to build RecordBatch: {e}")))
+}
+
+/// Conservative estimate of the number of payload bytes a row contributes to an
+/// Arrow `RecordBatch`. The dumper uses this to bound batch size so that no
+/// single 32-bit-offset string/binary column can exceed Arrow's 2 GiB offset
+/// limit while a large table is dumped (issue #6609). Variable-length payloads
+/// (`String`/`Bytes`) dominate that limit and are counted exactly; fixed-width
+/// values use their in-memory width.
+pub(crate) fn estimate_row_bytes(row: &OidRow) -> usize {
+    row.into_iter().map(estimate_value_bytes).sum()
+}
+
+fn estimate_value_bytes(value: &OidValue) -> usize {
+    match value {
+        OidValue::Null => 0,
+        OidValue::Bool(_) => 1,
+        OidValue::Int(_) => 4,
+        OidValue::Int8(_) => 8,
+        OidValue::Timestamp(_) => 8,
+        OidValue::Int4Range(_, _) => 8,
+        OidValue::Bytes(v) => v.as_ref().len(),
+        OidValue::String(v) => v.len(),
+        // Decimals are dumped as their decimal-string representation; 64 bytes
+        // is a comfortable upper bound for realistic values.
+        OidValue::BigDecimal(_) => 64,
+        OidValue::BoolArray(v) => v.len(),
+        OidValue::Ints(v) => v.len() * 4,
+        OidValue::Int8Array(v) => v.len() * 8,
+        OidValue::TimestampArray(v) => v.len() * 8,
+        OidValue::BytesArray(v) => v.iter().map(|b| b.as_ref().len()).sum(),
+        OidValue::StringArray(v) => v.iter().map(|s| s.len()).sum(),
+        OidValue::BigDecimalArray(v) => v.len() * 64,
+    }
+}
+
+/// A type-erased column builder that wraps the appropriate Arrow array builder.
+enum ColumnBuilder {
+    Boolean(BooleanBuilder),
+    Int32(Int32Builder),
+    Int64(Int64Builder),
+    Binary(BinaryBuilder),
+    Utf8(StringBuilder),
+    TimestampMicro(TimestampMicrosecondBuilder),
+    BooleanList(ListBuilder<BooleanBuilder>),
+    Int32List(ListBuilder<Int32Builder>),
+    Int64List(ListBuilder<Int64Builder>),
+    BinaryList(ListBuilder<BinaryBuilder>),
+    Utf8List(ListBuilder<StringBuilder>),
+    TimestampMicroList(ListBuilder<TimestampMicrosecondBuilder>),
+}
+
+impl ColumnBuilder {
+    fn new(data_type: &DataType, capacity: usize) -> Result<Self, StoreError> {
+        match data_type {
+            DataType::Boolean => Ok(Self::Boolean(BooleanBuilder::with_capacity(capacity))),
+            DataType::Int32 => Ok(Self::Int32(Int32Builder::with_capacity(capacity))),
+            DataType::Int64 => Ok(Self::Int64(Int64Builder::with_capacity(capacity))),
+            DataType::Binary => Ok(Self::Binary(BinaryBuilder::with_capacity(capacity, 0))),
+            DataType::Utf8 => Ok(Self::Utf8(StringBuilder::with_capacity(capacity, 0))),
+            DataType::Timestamp(arrow::datatypes::TimeUnit::Microsecond, None) => Ok(
+                Self::TimestampMicro(TimestampMicrosecondBuilder::with_capacity(capacity)),
+            ),
+            DataType::List(inner) => match inner.data_type() {
+                DataType::Boolean => Ok(Self::BooleanList(ListBuilder::with_capacity(
+                    BooleanBuilder::new(),
+                    capacity,
+                ))),
+                DataType::Int32 => Ok(Self::Int32List(ListBuilder::with_capacity(
+                    Int32Builder::new(),
+                    capacity,
+                ))),
+                DataType::Int64 => Ok(Self::Int64List(ListBuilder::with_capacity(
+                    Int64Builder::new(),
+                    capacity,
+                ))),
+                DataType::Binary => Ok(Self::BinaryList(ListBuilder::with_capacity(
+                    BinaryBuilder::new(),
+                    capacity,
+                ))),
+                DataType::Utf8 => Ok(Self::Utf8List(ListBuilder::with_capacity(
+                    StringBuilder::new(),
+                    capacity,
+                ))),
+                DataType::Timestamp(arrow::datatypes::TimeUnit::Microsecond, None) => {
+                    Ok(Self::TimestampMicroList(ListBuilder::with_capacity(
+                        TimestampMicrosecondBuilder::new(),
+                        capacity,
+                    )))
+                }
+                other => Err(StoreError::InternalError(format!(
+                    "unsupported list element type: {other:?}"
+                ))),
+            },
+            other => Err(StoreError::InternalError(format!(
+                "unsupported Arrow data type for column builder: {other:?}"
+            ))),
+        }
+    }
+
+    fn append(&mut self, value: &OidValue, row_idx: usize) -> Result<(), StoreError> {
+        match (self, value) {
+            // Null for any builder type
+            (Self::Boolean(b), OidValue::Null) => b.append_null(),
+            (Self::Int32(b), OidValue::Null) => b.append_null(),
+            (Self::Int64(b), OidValue::Null) => b.append_null(),
+            (Self::Binary(b), OidValue::Null) => b.append_null(),
+            (Self::Utf8(b), OidValue::Null) => b.append_null(),
+            (Self::TimestampMicro(b), OidValue::Null) => b.append_null(),
+            (Self::BooleanList(b), OidValue::Null) => b.append_null(),
+            (Self::Int32List(b), OidValue::Null) => b.append_null(),
+            (Self::Int64List(b), OidValue::Null) => b.append_null(),
+            (Self::BinaryList(b), OidValue::Null) => b.append_null(),
+            (Self::Utf8List(b), OidValue::Null) => b.append_null(),
+            (Self::TimestampMicroList(b), OidValue::Null) => b.append_null(),
+
+            // Scalar values
+            (Self::Boolean(b), OidValue::Bool(v)) => b.append_value(*v),
+            (Self::Int32(b), OidValue::Int(v)) => b.append_value(*v),
+            (Self::Int64(b), OidValue::Int8(v)) => b.append_value(*v),
+            (Self::Int64(b), OidValue::Int(v)) => b.append_value(*v as i64),
+            (Self::Binary(b), OidValue::Bytes(v)) => b.append_value(v.as_ref()),
+            (Self::Utf8(b), OidValue::String(v)) => b.append_value(v),
+            (Self::Utf8(b), OidValue::BigDecimal(v)) => b.append_value(v.to_string()),
+            (Self::TimestampMicro(b), OidValue::Timestamp(v)) => {
+                b.append_value(v.as_microseconds_since_epoch())
+            }
+
+            // Array values
+            (Self::BooleanList(b), OidValue::BoolArray(vals)) => {
+                for v in vals {
+                    b.values().append_value(*v);
+                }
+                b.append(true);
+            }
+            (Self::Int32List(b), OidValue::Ints(vals)) => {
+                for v in vals {
+                    b.values().append_value(*v);
+                }
+                b.append(true);
+            }
+            (Self::Int64List(b), OidValue::Int8Array(vals)) => {
+                for v in vals {
+                    b.values().append_value(*v);
+                }
+                b.append(true);
+            }
+            (Self::BinaryList(b), OidValue::BytesArray(vals)) => {
+                for v in vals {
+                    b.values().append_value(v.as_ref());
+                }
+                b.append(true);
+            }
+            (Self::Utf8List(b), OidValue::StringArray(vals)) => {
+                for v in vals {
+                    b.values().append_value(v);
+                }
+                b.append(true);
+            }
+            (Self::Utf8List(b), OidValue::BigDecimalArray(vals)) => {
+                for v in vals {
+                    b.values().append_value(v.to_string());
+                }
+                b.append(true);
+            }
+            (Self::TimestampMicroList(b), OidValue::TimestampArray(vals)) => {
+                for v in vals {
+                    b.values().append_value(v.as_microseconds_since_epoch());
+                }
+                b.append(true);
+            }
+
+            (builder, value) => {
+                return Err(StoreError::InternalError(format!(
+                    "row {row_idx}: type mismatch - cannot append {value:?} to {builder_type}",
+                    builder_type = builder.type_name()
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    fn finish(self) -> ArrayRef {
+        match self {
+            Self::Boolean(mut b) => Arc::new(b.finish()),
+            Self::Int32(mut b) => Arc::new(b.finish()),
+            Self::Int64(mut b) => Arc::new(b.finish()),
+            Self::Binary(mut b) => Arc::new(b.finish()),
+            Self::Utf8(mut b) => Arc::new(b.finish()),
+            Self::TimestampMicro(mut b) => Arc::new(b.finish()),
+            Self::BooleanList(mut b) => Arc::new(b.finish()),
+            Self::Int32List(mut b) => Arc::new(b.finish()),
+            Self::Int64List(mut b) => Arc::new(b.finish()),
+            Self::BinaryList(mut b) => Arc::new(b.finish()),
+            Self::Utf8List(mut b) => Arc::new(b.finish()),
+            Self::TimestampMicroList(mut b) => Arc::new(b.finish()),
+        }
+    }
+
+    fn type_name(&self) -> &'static str {
+        match self {
+            Self::Boolean(_) => "Boolean",
+            Self::Int32(_) => "Int32",
+            Self::Int64(_) => "Int64",
+            Self::Binary(_) => "Binary",
+            Self::Utf8(_) => "Utf8",
+            Self::TimestampMicro(_) => "TimestampMicrosecond",
+            Self::BooleanList(_) => "List<Boolean>",
+            Self::Int32List(_) => "List<Int32>",
+            Self::Int64List(_) => "List<Int64>",
+            Self::BinaryList(_) => "List<Binary>",
+            Self::Utf8List(_) => "List<Utf8>",
+            Self::TimestampMicroList(_) => "List<TimestampMicrosecond>",
+        }
+    }
+}
+
+/// A row extracted from a Parquet file, ready for insertion into an entity table.
+pub struct RestoreRow {
+    pub vid: i64,
+    pub block: BlockNumber,
+    /// `None` for immutable entities, `Some` for mutable (block_range_end).
+    pub block_range_end: Option<Option<BlockNumber>>,
+    pub causality_region: Option<i32>,
+    pub values: Vec<(Word, Value)>,
+}
+
+/// Convert an Arrow `RecordBatch` back into `RestoreRow`s using the entity
+/// table's schema to guide type interpretation.
+///
+/// The batch must follow the column layout produced by `schema::arrow_schema`:
+/// `vid`, block tracking columns, optional `causality_region`, then data columns.
+pub fn record_batch_to_restore_rows(
+    batch: &RecordBatch,
+    table: &Table,
+) -> Result<Vec<RestoreRow>, StoreError> {
+    let num_rows = batch.num_rows();
+    let mut rows = Vec::with_capacity(num_rows);
+
+    // System column indices follow the layout in schema::arrow_schema
+    let vid_array = downcast_i64(batch.column(0), "vid")?;
+
+    let mut col_idx = 1;
+
+    // Block tracking
+    let block_array = downcast_i32(batch.column(col_idx), "block")?;
+    col_idx += 1;
+
+    let block_end_array = if !table.immutable {
+        let arr = downcast_i32(batch.column(col_idx), "block_range_end")?;
+        col_idx += 1;
+        Some(arr)
+    } else {
+        None
+    };
+
+    // Causality region
+    let cr_array = if table.has_causality_region {
+        let arr = downcast_i32(batch.column(col_idx), "causality_region")?;
+        col_idx += 1;
+        Some(arr)
+    } else {
+        None
+    };
+
+    // Data columns: iterate table columns, skip fulltext
+    let data_columns: Vec<_> = table.columns.iter().filter(|c| !c.is_fulltext()).collect();
+
+    // Pre-resolve Arrow column references for data columns
+    let arrow_data_cols: Vec<_> = data_columns
+        .iter()
+        .enumerate()
+        .map(|(i, _)| batch.column(col_idx + i))
+        .collect();
+
+    for row in 0..num_rows {
+        let vid = vid_array.value(row);
+        let block = block_array.value(row);
+
+        let block_range_end = block_end_array.as_ref().map(|arr| {
+            if arr.is_null(row) {
+                None
+            } else {
+                Some(arr.value(row))
+            }
+        });
+
+        let causality_region = cr_array.as_ref().map(|arr| arr.value(row));
+
+        let mut values = Vec::with_capacity(data_columns.len());
+        for (i, col) in data_columns.iter().enumerate() {
+            let arrow_col = arrow_data_cols[i].as_ref();
+            let value = if arrow_col.is_null(row) {
+                Value::Null
+            } else if col.is_list() {
+                extract_list_value(arrow_col, row, &col.column_type)?
+            } else {
+                extract_scalar_value(arrow_col, row, &col.column_type)?
+            };
+            values.push((Word::from(col.name.as_str()), value));
+        }
+
+        rows.push(RestoreRow {
+            vid,
+            block,
+            block_range_end,
+            causality_region,
+            values,
+        });
+    }
+
+    Ok(rows)
+}
+
+/// A row extracted from a `data_sources$` Parquet file.
+pub struct DataSourceRestoreRow {
+    pub vid: i64,
+    pub block_range_start: BlockNumber,
+    pub block_range_end: Option<BlockNumber>,
+    pub causality_region: i32,
+    pub manifest_idx: i32,
+    pub parent: Option<i32>,
+    pub id: Option<Vec<u8>>,
+    pub param: Option<Vec<u8>>,
+    pub context: Option<String>,
+    pub done_at: Option<i32>,
+}
+
+/// Convert an Arrow `RecordBatch` from a `data_sources$` Parquet file
+/// into `DataSourceRestoreRow`s.
+///
+/// The batch must follow the fixed column layout from
+/// `schema::data_sources_arrow_schema`.
+pub fn record_batch_to_data_source_rows(
+    batch: &RecordBatch,
+) -> Result<Vec<DataSourceRestoreRow>, StoreError> {
+    let num_rows = batch.num_rows();
+    let mut rows = Vec::with_capacity(num_rows);
+
+    let vid = downcast_i64(batch.column(0), "vid")?;
+    let block_start = downcast_i32(batch.column(1), "block_range_start")?;
+    let block_end = downcast_i32(batch.column(2), "block_range_end")?;
+    let cr = downcast_i32(batch.column(3), "causality_region")?;
+    let manifest_idx = downcast_i32(batch.column(4), "manifest_idx")?;
+    let parent = downcast_i32(batch.column(5), "parent")?;
+    let id_arr = downcast_binary(batch.column(6), "id")?;
+    let param_arr = downcast_binary(batch.column(7), "param")?;
+    let context_arr = downcast_utf8(batch.column(8), "context")?;
+    let done_at = downcast_i32(batch.column(9), "done_at")?;
+
+    for row in 0..num_rows {
+        rows.push(DataSourceRestoreRow {
+            vid: vid.value(row),
+            block_range_start: block_start.value(row),
+            block_range_end: if block_end.is_null(row) {
+                None
+            } else {
+                Some(block_end.value(row))
+            },
+            causality_region: cr.value(row),
+            manifest_idx: manifest_idx.value(row),
+            parent: if parent.is_null(row) {
+                None
+            } else {
+                Some(parent.value(row))
+            },
+            id: if id_arr.is_null(row) {
+                None
+            } else {
+                Some(id_arr.value(row).to_vec())
+            },
+            param: if param_arr.is_null(row) {
+                None
+            } else {
+                Some(param_arr.value(row).to_vec())
+            },
+            context: if context_arr.is_null(row) {
+                None
+            } else {
+                Some(context_arr.value(row).to_string())
+            },
+            done_at: if done_at.is_null(row) {
+                None
+            } else {
+                Some(done_at.value(row))
+            },
+        });
+    }
+
+    Ok(rows)
+}
+
+/// Load clamp files and build a `vid → block_range_end` map.
+///
+/// Each clamp parquet file contains rows with `(vid: i64, block_range_end: i32)`.
+/// Later clamp files overwrite earlier ones for the same vid (only the
+/// latest value matters).
+pub fn load_clamps(
+    dir: &Path,
+    clamps: &[crate::parquet::writer::ChunkInfo],
+) -> Result<HashMap<i64, i32>, StoreError> {
+    let mut map = HashMap::new();
+    for chunk_info in clamps {
+        let path = dir.join(&chunk_info.file);
+        let batches = crate::parquet::reader::read_batches(&path)?;
+        for batch in batches {
+            let batch = batch?;
+            let vid_arr = downcast_i64(batch.column(0), "vid")?;
+            let bre_arr = downcast_i32(batch.column(1), "block_range_end")?;
+            for row in 0..batch.num_rows() {
+                map.insert(vid_arr.value(row), bre_arr.value(row));
+            }
+        }
+    }
+    Ok(map)
+}
+
+// -- Downcasting helpers --
+
+fn downcast_i64<'a>(array: &'a ArrayRef, name: &str) -> Result<&'a Int64Array, StoreError> {
+    array.as_any().downcast_ref::<Int64Array>().ok_or_else(|| {
+        StoreError::InternalError(format!("expected Int64Array for column '{name}'"))
+    })
+}
+
+fn downcast_i32<'a>(array: &'a ArrayRef, name: &str) -> Result<&'a Int32Array, StoreError> {
+    array.as_any().downcast_ref::<Int32Array>().ok_or_else(|| {
+        StoreError::InternalError(format!("expected Int32Array for column '{name}'"))
+    })
+}
+
+fn downcast_binary<'a>(array: &'a ArrayRef, name: &str) -> Result<&'a BinaryArray, StoreError> {
+    array.as_any().downcast_ref::<BinaryArray>().ok_or_else(|| {
+        StoreError::InternalError(format!("expected BinaryArray for column '{name}'"))
+    })
+}
+
+fn downcast_utf8<'a>(array: &'a ArrayRef, name: &str) -> Result<&'a StringArray, StoreError> {
+    array.as_any().downcast_ref::<StringArray>().ok_or_else(|| {
+        StoreError::InternalError(format!("expected StringArray for column '{name}'"))
+    })
+}
+
+/// Extract a scalar `Value` from an Arrow array at the given row.
+///
+/// The `column_type` determines how to interpret the Arrow data (e.g.
+/// a Utf8 array might be String, BigInt, or BigDecimal).
+fn extract_scalar_value(
+    array: &dyn Array,
+    row: usize,
+    column_type: &ColumnType,
+) -> Result<Value, StoreError> {
+    match column_type {
+        ColumnType::Boolean => {
+            let arr = array
+                .as_any()
+                .downcast_ref::<BooleanArray>()
+                .ok_or_else(|| err("BooleanArray", "Boolean"))?;
+            Ok(Value::Bool(arr.value(row)))
+        }
+        ColumnType::Int => {
+            let arr = array
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .ok_or_else(|| err("Int32Array", "Int"))?;
+            Ok(Value::Int(arr.value(row)))
+        }
+        ColumnType::Int8 => {
+            let arr = array
+                .as_any()
+                .downcast_ref::<Int64Array>()
+                .ok_or_else(|| err("Int64Array", "Int8"))?;
+            Ok(Value::Int8(arr.value(row)))
+        }
+        ColumnType::Bytes => {
+            let arr = array
+                .as_any()
+                .downcast_ref::<BinaryArray>()
+                .ok_or_else(|| err("BinaryArray", "Bytes"))?;
+            Ok(Value::Bytes(scalar::Bytes::from(arr.value(row))))
+        }
+        ColumnType::BigInt => {
+            let arr = array
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .ok_or_else(|| err("StringArray", "BigInt"))?;
+            let s = arr.value(row);
+            let big = scalar::BigInt::from_str(s)
+                .map_err(|e| StoreError::InternalError(format!("invalid BigInt '{s}': {e}")))?;
+            Ok(Value::BigInt(big))
+        }
+        ColumnType::BigDecimal => {
+            let arr = array
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .ok_or_else(|| err("StringArray", "BigDecimal"))?;
+            let s = arr.value(row);
+            let bd = scalar::BigDecimal::from_str(s)
+                .map_err(|e| StoreError::InternalError(format!("invalid BigDecimal '{s}': {e}")))?;
+            Ok(Value::BigDecimal(bd))
+        }
+        ColumnType::Timestamp => {
+            let arr = array
+                .as_any()
+                .downcast_ref::<TimestampMicrosecondArray>()
+                .ok_or_else(|| err("TimestampMicrosecondArray", "Timestamp"))?;
+            let micros = arr.value(row);
+            let ts = scalar::Timestamp::from_microseconds_since_epoch(micros).map_err(|e| {
+                StoreError::InternalError(format!("invalid Timestamp {micros}: {e}"))
+            })?;
+            Ok(Value::Timestamp(ts))
+        }
+        ColumnType::String | ColumnType::Enum(_) => {
+            let arr = array
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .ok_or_else(|| err("StringArray", "String/Enum"))?;
+            Ok(Value::String(arr.value(row).to_string()))
+        }
+        ColumnType::TSVector(_) => Err(StoreError::InternalError(
+            "TSVector columns should not appear in parquet data".into(),
+        )),
+    }
+}
+
+/// Extract a list `Value` from a `ListArray` at the given row.
+fn extract_list_value(
+    array: &dyn Array,
+    row: usize,
+    column_type: &ColumnType,
+) -> Result<Value, StoreError> {
+    let list_arr = array
+        .as_any()
+        .downcast_ref::<ListArray>()
+        .ok_or_else(|| StoreError::InternalError("expected ListArray for list column".into()))?;
+
+    let inner = list_arr.value(row);
+    let len = inner.len();
+    let mut items = Vec::with_capacity(len);
+
+    for i in 0..len {
+        if inner.is_null(i) {
+            items.push(Value::Null);
+        } else {
+            items.push(extract_scalar_value(inner.as_ref(), i, column_type)?);
+        }
+    }
+
+    Ok(Value::List(items))
+}
+
+fn err(expected: &str, column_type: &str) -> StoreError {
+    StoreError::InternalError(format!("expected {expected} for {column_type} column"))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeSet;
+
+    use arrow::array::{
+        Array, BinaryArray, BooleanArray, Int32Array, Int64Array, ListArray, StringArray,
+        TimestampMicrosecondArray,
+    };
+    use arrow::datatypes::{Field, Schema, TimeUnit};
+    use graph::data::store::scalar::{BigDecimal, Bytes, Timestamp};
+    use graph::prelude::DeploymentHash;
+    use graph::schema::InputSchema;
+    use std::str::FromStr;
+    use std::sync::Arc;
+
+    use super::*;
+    use crate::layout_for_tests::{Catalog, Layout, Namespace, make_dummy_site};
+    use crate::parquet::schema::arrow_schema;
+
+    fn make_row(values: Vec<OidValue>) -> OidRow {
+        values.into_iter().collect()
+    }
+
+    #[test]
+    fn scalar_columns() {
+        let schema = Schema::new(vec![
+            Field::new("vid", DataType::Int64, false),
+            Field::new("block$", DataType::Int32, false),
+            Field::new("id", DataType::Utf8, false),
+            Field::new("flag", DataType::Boolean, false),
+            Field::new("data", DataType::Binary, false),
+            Field::new("amount", DataType::Utf8, false),
+            Field::new(
+                "ts",
+                DataType::Timestamp(TimeUnit::Microsecond, None),
+                false,
+            ),
+        ]);
+
+        let rows = vec![
+            make_row(vec![
+                OidValue::Int8(1),
+                OidValue::Int(100),
+                OidValue::String("token-1".to_string()),
+                OidValue::Bool(true),
+                OidValue::Bytes(Bytes::from(vec![0xab, 0xcd])),
+                OidValue::BigDecimal(BigDecimal::from_str("12345678901234567890").unwrap()),
+                OidValue::Timestamp(
+                    Timestamp::from_microseconds_since_epoch(1_000_000_000_000).unwrap(),
+                ),
+            ]),
+            make_row(vec![
+                OidValue::Int8(2),
+                OidValue::Int(101),
+                OidValue::String("token-2".to_string()),
+                OidValue::Bool(false),
+                OidValue::Bytes(Bytes::from(vec![0xff])),
+                OidValue::BigDecimal(BigDecimal::from_str("999").unwrap()),
+                OidValue::Timestamp(
+                    Timestamp::from_microseconds_since_epoch(2_000_000_000_000).unwrap(),
+                ),
+            ]),
+        ];
+
+        let batch = rows_to_record_batch(&schema, &rows).unwrap();
+        assert_eq!(batch.num_rows(), 2);
+        assert_eq!(batch.num_columns(), 7);
+
+        // vid
+        let vid = batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<Int64Array>()
+            .unwrap();
+        assert_eq!(vid.value(0), 1);
+        assert_eq!(vid.value(1), 2);
+
+        // block$
+        let block = batch
+            .column(1)
+            .as_any()
+            .downcast_ref::<Int32Array>()
+            .unwrap();
+        assert_eq!(block.value(0), 100);
+        assert_eq!(block.value(1), 101);
+
+        // id
+        let id = batch
+            .column(2)
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+        assert_eq!(id.value(0), "token-1");
+        assert_eq!(id.value(1), "token-2");
+
+        // flag
+        let flag = batch
+            .column(3)
+            .as_any()
+            .downcast_ref::<BooleanArray>()
+            .unwrap();
+        assert!(flag.value(0));
+        assert!(!flag.value(1));
+
+        // data
+        let data = batch
+            .column(4)
+            .as_any()
+            .downcast_ref::<BinaryArray>()
+            .unwrap();
+        assert_eq!(data.value(0), &[0xab, 0xcd]);
+        assert_eq!(data.value(1), &[0xff]);
+
+        // amount (BigDecimal → Utf8)
+        let amount = batch
+            .column(5)
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+        assert_eq!(amount.value(0), "12345678901234567890");
+        assert_eq!(amount.value(1), "999");
+
+        // ts
+        let ts = batch
+            .column(6)
+            .as_any()
+            .downcast_ref::<TimestampMicrosecondArray>()
+            .unwrap();
+        assert_eq!(ts.value(0), 1_000_000_000_000);
+        assert_eq!(ts.value(1), 2_000_000_000_000);
+    }
+
+    #[test]
+    fn nullable_columns() {
+        let schema = Schema::new(vec![
+            Field::new("vid", DataType::Int64, false),
+            Field::new("name", DataType::Utf8, true),
+            Field::new("count", DataType::Int32, true),
+        ]);
+
+        let rows = vec![
+            make_row(vec![
+                OidValue::Int8(1),
+                OidValue::String("hello".to_string()),
+                OidValue::Int(42),
+            ]),
+            make_row(vec![OidValue::Int8(2), OidValue::Null, OidValue::Null]),
+        ];
+
+        let batch = rows_to_record_batch(&schema, &rows).unwrap();
+        assert_eq!(batch.num_rows(), 2);
+
+        let name = batch
+            .column(1)
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+        assert!(!name.is_null(0));
+        assert_eq!(name.value(0), "hello");
+        assert!(name.is_null(1));
+
+        let count = batch
+            .column(2)
+            .as_any()
+            .downcast_ref::<Int32Array>()
+            .unwrap();
+        assert_eq!(count.value(0), 42);
+        assert!(count.is_null(1));
+    }
+
+    #[test]
+    fn list_columns() {
+        let schema = Schema::new(vec![
+            Field::new("vid", DataType::Int64, false),
+            Field::new(
+                "tags",
+                DataType::List(Arc::new(Field::new("item", DataType::Utf8, true))),
+                false,
+            ),
+            Field::new(
+                "scores",
+                DataType::List(Arc::new(Field::new("item", DataType::Int32, true))),
+                true,
+            ),
+        ]);
+
+        let rows = vec![
+            make_row(vec![
+                OidValue::Int8(1),
+                OidValue::StringArray(vec!["foo".to_string(), "bar".to_string()]),
+                OidValue::Ints(vec![10, 20, 30]),
+            ]),
+            make_row(vec![
+                OidValue::Int8(2),
+                OidValue::StringArray(vec![]),
+                OidValue::Null,
+            ]),
+        ];
+
+        let batch = rows_to_record_batch(&schema, &rows).unwrap();
+        assert_eq!(batch.num_rows(), 2);
+
+        // tags
+        let tags = batch
+            .column(1)
+            .as_any()
+            .downcast_ref::<ListArray>()
+            .unwrap();
+        let tags_0 = tags.value(0);
+        let tags_0_str = tags_0.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(tags_0_str.len(), 2);
+        assert_eq!(tags_0_str.value(0), "foo");
+        assert_eq!(tags_0_str.value(1), "bar");
+
+        let tags_1 = tags.value(1);
+        let tags_1_str = tags_1.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(tags_1_str.len(), 0);
+
+        // scores
+        let scores = batch
+            .column(2)
+            .as_any()
+            .downcast_ref::<ListArray>()
+            .unwrap();
+        let scores_0 = scores.value(0);
+        let scores_0_int = scores_0.as_any().downcast_ref::<Int32Array>().unwrap();
+        assert_eq!(scores_0_int.len(), 3);
+        assert_eq!(scores_0_int.value(0), 10);
+        assert_eq!(scores_0_int.value(2), 30);
+        assert!(scores.is_null(1));
+    }
+
+    #[test]
+    fn empty_batch() {
+        let schema = Schema::new(vec![
+            Field::new("vid", DataType::Int64, false),
+            Field::new("name", DataType::Utf8, false),
+        ]);
+
+        let batch = rows_to_record_batch(&schema, &[]).unwrap();
+        assert_eq!(batch.num_rows(), 0);
+        assert_eq!(batch.num_columns(), 2);
+    }
+
+    #[test]
+    fn column_count_mismatch_errors() {
+        let schema = Schema::new(vec![
+            Field::new("vid", DataType::Int64, false),
+            Field::new("name", DataType::Utf8, false),
+        ]);
+
+        let rows = vec![make_row(vec![OidValue::Int8(1)])];
+        let err = rows_to_record_batch(&schema, &rows).unwrap_err();
+        assert!(err.to_string().contains("1 values but schema has 2 fields"));
+    }
+
+    #[test]
+    fn type_mismatch_errors() {
+        let schema = Schema::new(vec![Field::new("vid", DataType::Int64, false)]);
+        let rows = vec![make_row(vec![OidValue::String("wrong".to_string())])];
+        let err = rows_to_record_batch(&schema, &rows).unwrap_err();
+        assert!(err.to_string().contains("type mismatch"));
+    }
+
+    // -- Restore direction tests --
+
+    fn test_layout(gql: &str) -> Layout {
+        let subgraph = DeploymentHash::new("subgraph").unwrap();
+        let schema = InputSchema::parse_latest(gql, subgraph.clone()).expect("Test schema invalid");
+        let namespace = Namespace::new("sgd0815".to_owned()).unwrap();
+        let site = Arc::new(make_dummy_site(subgraph, namespace, "anet".to_string()));
+        let catalog =
+            Catalog::for_tests(site.clone(), BTreeSet::new()).expect("Can not create catalog");
+        Layout::new(site, &schema, catalog).expect("Failed to construct Layout")
+    }
+
+    fn test_layout_with_causality(gql: &str, entity_name: &str) -> Layout {
+        let subgraph = DeploymentHash::new("subgraph").unwrap();
+        let schema = InputSchema::parse_latest(gql, subgraph.clone()).expect("Test schema invalid");
+        let namespace = Namespace::new("sgd0815".to_owned()).unwrap();
+        let site = Arc::new(make_dummy_site(subgraph, namespace, "anet".to_string()));
+        let entity_type = schema.entity_type(entity_name).unwrap();
+        let ents = BTreeSet::from_iter(vec![entity_type]);
+        let catalog = Catalog::for_tests(site.clone(), ents).expect("Can not create catalog");
+        Layout::new(site, &schema, catalog).expect("Failed to construct Layout")
+    }
+
+    #[test]
+    fn restore_immutable_entity() {
+        let layout = test_layout(
+            "type Token @entity(immutable: true) { id: ID!, name: String!, decimals: Int! }",
+        );
+        let table = layout.table("token").unwrap();
+        let schema = arrow_schema(table);
+
+        // Build a RecordBatch via the dump direction
+        let rows = vec![
+            make_row(vec![
+                OidValue::Int8(1),
+                OidValue::Int(100),
+                OidValue::String("token-1".into()),
+                OidValue::String("Token One".into()),
+                OidValue::Int(18),
+            ]),
+            make_row(vec![
+                OidValue::Int8(2),
+                OidValue::Int(101),
+                OidValue::String("token-2".into()),
+                OidValue::String("Token Two".into()),
+                OidValue::Int(6),
+            ]),
+        ];
+
+        let batch = rows_to_record_batch(&schema, &rows).unwrap();
+        let restore_rows = record_batch_to_restore_rows(&batch, table).unwrap();
+
+        assert_eq!(restore_rows.len(), 2);
+
+        // Row 0
+        assert_eq!(restore_rows[0].vid, 1);
+        assert_eq!(restore_rows[0].block, 100);
+        assert!(restore_rows[0].block_range_end.is_none()); // immutable
+        assert!(restore_rows[0].causality_region.is_none());
+
+        assert_eq!(restore_rows[0].values.len(), 3); // id, name, decimals
+        assert_eq!(restore_rows[0].values[0].0.as_str(), "id");
+        assert_eq!(restore_rows[0].values[0].1, Value::String("token-1".into()));
+        assert_eq!(restore_rows[0].values[1].0.as_str(), "name");
+        assert_eq!(
+            restore_rows[0].values[1].1,
+            Value::String("Token One".into())
+        );
+        assert_eq!(restore_rows[0].values[2].0.as_str(), "decimals");
+        assert_eq!(restore_rows[0].values[2].1, Value::Int(18));
+
+        // Row 1
+        assert_eq!(restore_rows[1].vid, 2);
+        assert_eq!(restore_rows[1].block, 101);
+        assert_eq!(restore_rows[1].values[2].1, Value::Int(6));
+    }
+
+    #[test]
+    fn restore_mutable_entity_with_causality() {
+        let layout = test_layout_with_causality(
+            "type Transfer @entity { id: ID!, amount: BigInt! }",
+            "Transfer",
+        );
+        let table = layout.table("transfer").unwrap();
+        let schema = arrow_schema(table);
+
+        let rows = vec![
+            make_row(vec![
+                OidValue::Int8(10),
+                OidValue::Int(500),
+                OidValue::Int(600),
+                OidValue::Int(0),
+                OidValue::String("tx-1".into()),
+                OidValue::String("12345678901234567890".into()),
+            ]),
+            make_row(vec![
+                OidValue::Int8(11),
+                OidValue::Int(550),
+                OidValue::Null, // unbounded (current)
+                OidValue::Int(1),
+                OidValue::String("tx-2".into()),
+                OidValue::String("99999".into()),
+            ]),
+        ];
+
+        let batch = rows_to_record_batch(&schema, &rows).unwrap();
+        let restore_rows = record_batch_to_restore_rows(&batch, table).unwrap();
+
+        assert_eq!(restore_rows.len(), 2);
+
+        // Row 0: closed block range
+        assert_eq!(restore_rows[0].vid, 10);
+        assert_eq!(restore_rows[0].block, 500);
+        assert_eq!(restore_rows[0].block_range_end, Some(Some(600)));
+        assert_eq!(restore_rows[0].causality_region, Some(0));
+        assert_eq!(restore_rows[0].values[0].0.as_str(), "id");
+        assert_eq!(restore_rows[0].values[0].1, Value::String("tx-1".into()));
+        assert_eq!(restore_rows[0].values[1].0.as_str(), "amount");
+        assert_eq!(
+            restore_rows[0].values[1].1,
+            Value::BigInt(scalar::BigInt::from_str("12345678901234567890").unwrap())
+        );
+
+        // Row 1: open block range (current)
+        assert_eq!(restore_rows[1].vid, 11);
+        assert_eq!(restore_rows[1].block, 550);
+        assert_eq!(restore_rows[1].block_range_end, Some(None)); // unbounded
+        assert_eq!(restore_rows[1].causality_region, Some(1));
+    }
+
+    #[test]
+    fn restore_nullable_and_list_columns() {
+        let layout = test_layout(
+            "type Pool @entity(immutable: true) { id: ID!, tags: [String!]!, description: String }",
+        );
+        let table = layout.table("pool").unwrap();
+        let schema = arrow_schema(table);
+
+        let rows = vec![
+            make_row(vec![
+                OidValue::Int8(1),
+                OidValue::Int(100),
+                OidValue::String("pool-1".into()),
+                OidValue::StringArray(vec!["defi".into(), "amm".into()]),
+                OidValue::String("A pool".into()),
+            ]),
+            make_row(vec![
+                OidValue::Int8(2),
+                OidValue::Int(101),
+                OidValue::String("pool-2".into()),
+                OidValue::StringArray(vec![]),
+                OidValue::Null,
+            ]),
+        ];
+
+        let batch = rows_to_record_batch(&schema, &rows).unwrap();
+        let restore_rows = record_batch_to_restore_rows(&batch, table).unwrap();
+
+        assert_eq!(restore_rows.len(), 2);
+
+        // Row 0: tags is a list of strings
+        let tags_val = &restore_rows[0].values[1].1;
+        match tags_val {
+            Value::List(items) => {
+                assert_eq!(items.len(), 2);
+                assert_eq!(items[0], Value::String("defi".into()));
+                assert_eq!(items[1], Value::String("amm".into()));
+            }
+            other => panic!("expected List, got {:?}", other),
+        }
+        assert_eq!(restore_rows[0].values[2].1, Value::String("A pool".into()));
+
+        // Row 1: empty list and null description
+        let tags_val = &restore_rows[1].values[1].1;
+        match tags_val {
+            Value::List(items) => assert_eq!(items.len(), 0),
+            other => panic!("expected List, got {:?}", other),
+        }
+        assert_eq!(restore_rows[1].values[2].1, Value::Null);
+    }
+
+    #[test]
+    fn restore_all_scalar_types() {
+        let layout = test_layout(
+            "type Everything @entity(immutable: true) { \
+                id: ID!, \
+                flag: Boolean!, \
+                small: Int!, \
+                big: Int8!, \
+                amount: BigInt!, \
+                price: BigDecimal!, \
+                data: Bytes!, \
+                ts: Timestamp!, \
+                label: String! \
+            }",
+        );
+        let table = layout.table("everything").unwrap();
+        let schema = arrow_schema(table);
+
+        let rows = vec![make_row(vec![
+            OidValue::Int8(1),
+            OidValue::Int(100),
+            OidValue::String("thing-1".into()),
+            OidValue::Bool(true),
+            OidValue::Int(42),
+            OidValue::Int8(9_999_999),
+            OidValue::String("12345678901234567890".into()),
+            OidValue::BigDecimal(BigDecimal::from_str("3.14159").unwrap()),
+            OidValue::Bytes(Bytes::from(vec![0xab, 0xcd])),
+            OidValue::Timestamp(Timestamp::from_microseconds_since_epoch(1_000_000).unwrap()),
+            OidValue::String("hello".into()),
+        ])];
+
+        let batch = rows_to_record_batch(&schema, &rows).unwrap();
+        let restore_rows = record_batch_to_restore_rows(&batch, table).unwrap();
+
+        assert_eq!(restore_rows.len(), 1);
+        let vals = &restore_rows[0].values;
+
+        // id
+        assert_eq!(vals[0].1, Value::String("thing-1".into()));
+        // flag
+        assert_eq!(vals[1].1, Value::Bool(true));
+        // small
+        assert_eq!(vals[2].1, Value::Int(42));
+        // big
+        assert_eq!(vals[3].1, Value::Int8(9_999_999));
+        // amount (BigInt)
+        assert_eq!(
+            vals[4].1,
+            Value::BigInt(scalar::BigInt::from_str("12345678901234567890").unwrap())
+        );
+        // price (BigDecimal)
+        assert_eq!(
+            vals[5].1,
+            Value::BigDecimal(BigDecimal::from_str("3.14159").unwrap())
+        );
+        // data (Bytes)
+        assert_eq!(vals[6].1, Value::Bytes(Bytes::from(vec![0xab, 0xcd])));
+        // ts (Timestamp)
+        assert_eq!(
+            vals[7].1,
+            Value::Timestamp(Timestamp::from_microseconds_since_epoch(1_000_000).unwrap())
+        );
+        // label
+        assert_eq!(vals[8].1, Value::String("hello".into()));
+    }
+
+    #[test]
+    fn restore_data_source_rows() {
+        use crate::parquet::schema::data_sources_arrow_schema;
+
+        let schema = data_sources_arrow_schema();
+        let rows = vec![
+            make_row(vec![
+                OidValue::Int8(1),
+                OidValue::Int(100),
+                OidValue::Int(200),
+                OidValue::Int(1),
+                OidValue::Int(0),
+                OidValue::Null,
+                OidValue::Null,
+                OidValue::Bytes(Bytes::from(vec![0x01, 0x02])),
+                OidValue::String(r#"{"key":"value"}"#.into()),
+                OidValue::Null,
+            ]),
+            make_row(vec![
+                OidValue::Int8(2),
+                OidValue::Int(150),
+                OidValue::Null, // unbounded
+                OidValue::Int(2),
+                OidValue::Int(1),
+                OidValue::Int(5),
+                OidValue::Bytes(Bytes::from(vec![0xaa])),
+                OidValue::Null,
+                OidValue::Null,
+                OidValue::Int(300),
+            ]),
+        ];
+
+        let batch = rows_to_record_batch(&schema, &rows).unwrap();
+        let ds_rows = record_batch_to_data_source_rows(&batch).unwrap();
+
+        assert_eq!(ds_rows.len(), 2);
+
+        // Row 0
+        assert_eq!(ds_rows[0].vid, 1);
+        assert_eq!(ds_rows[0].block_range_start, 100);
+        assert_eq!(ds_rows[0].block_range_end, Some(200));
+        assert_eq!(ds_rows[0].causality_region, 1);
+        assert_eq!(ds_rows[0].manifest_idx, 0);
+        assert!(ds_rows[0].parent.is_none());
+        assert!(ds_rows[0].id.is_none());
+        assert_eq!(ds_rows[0].param.as_deref(), Some(&[0x01, 0x02][..]));
+        assert_eq!(ds_rows[0].context.as_deref(), Some(r#"{"key":"value"}"#));
+        assert!(ds_rows[0].done_at.is_none());
+
+        // Row 1
+        assert_eq!(ds_rows[1].vid, 2);
+        assert_eq!(ds_rows[1].block_range_start, 150);
+        assert!(ds_rows[1].block_range_end.is_none());
+        assert_eq!(ds_rows[1].causality_region, 2);
+        assert_eq!(ds_rows[1].manifest_idx, 1);
+        assert_eq!(ds_rows[1].parent, Some(5));
+        assert_eq!(ds_rows[1].id.as_deref(), Some(&[0xaa][..]));
+        assert!(ds_rows[1].param.is_none());
+        assert!(ds_rows[1].context.is_none());
+        assert_eq!(ds_rows[1].done_at, Some(300));
+    }
+
+    #[test]
+    fn restore_empty_batch() {
+        let layout = test_layout("type Token @entity(immutable: true) { id: ID!, name: String! }");
+        let table = layout.table("token").unwrap();
+        let schema = arrow_schema(table);
+
+        let batch = rows_to_record_batch(&schema, &[]).unwrap();
+        let restore_rows = record_batch_to_restore_rows(&batch, table).unwrap();
+        assert!(restore_rows.is_empty());
+    }
+
+    #[test]
+    fn load_clamps_roundtrip() {
+        use crate::parquet::schema::clamp_arrow_schema;
+        use crate::parquet::writer::{ChunkInfo, ParquetChunkWriter};
+
+        let tmp_dir =
+            std::env::temp_dir().join(format!("graph_node_clamp_test_{}", std::process::id()));
+        std::fs::create_dir_all(&tmp_dir).unwrap();
+
+        let schema = clamp_arrow_schema();
+
+        // Write clamp file 1
+        let path1 = tmp_dir.join("clamp_000000.parquet");
+        let mut writer1 =
+            ParquetChunkWriter::new(path1, "clamp_000000.parquet".into(), &schema).unwrap();
+        let batch1 = arrow::array::RecordBatch::try_new(
+            Arc::new(schema.clone()),
+            vec![
+                Arc::new(Int64Array::from(vec![10, 20])),
+                Arc::new(Int32Array::from(vec![500, 600])),
+            ],
+        )
+        .unwrap();
+        writer1.write_batch(&batch1, 10, 20).unwrap();
+        let chunk1 = writer1.finish().unwrap();
+
+        // Write clamp file 2 (overwrites vid 20 with a different end)
+        let path2 = tmp_dir.join("clamp_000001.parquet");
+        let mut writer2 =
+            ParquetChunkWriter::new(path2, "clamp_000001.parquet".into(), &schema).unwrap();
+        let batch2 = arrow::array::RecordBatch::try_new(
+            Arc::new(schema.clone()),
+            vec![
+                Arc::new(Int64Array::from(vec![20, 30])),
+                Arc::new(Int32Array::from(vec![700, 800])),
+            ],
+        )
+        .unwrap();
+        writer2.write_batch(&batch2, 20, 30).unwrap();
+        let chunk2 = writer2.finish().unwrap();
+
+        let clamps = vec![
+            ChunkInfo {
+                file: chunk1.file,
+                ..chunk1
+            },
+            ChunkInfo {
+                file: chunk2.file,
+                ..chunk2
+            },
+        ];
+
+        let map = load_clamps(&tmp_dir, &clamps).unwrap();
+        assert_eq!(map.len(), 3);
+        assert_eq!(map[&10], 500);
+        assert_eq!(map[&20], 700); // overwritten by second clamp file
+        assert_eq!(map[&30], 800);
+
+        // Cleanup
+        let _ = std::fs::remove_dir_all(&tmp_dir);
+    }
+}
diff --git a/store/postgres/src/parquet/mod.rs b/store/postgres/src/parquet/mod.rs
new file mode 100644
index 00000000000..d436709199f
--- /dev/null
+++ b/store/postgres/src/parquet/mod.rs
@@ -0,0 +1,4 @@
+pub(crate) mod convert;
+pub(crate) mod reader;
+pub(crate) mod schema;
+pub(crate) mod writer;
diff --git a/store/postgres/src/parquet/reader.rs b/store/postgres/src/parquet/reader.rs
new file mode 100644
index 00000000000..38aaecf0523
--- /dev/null
+++ b/store/postgres/src/parquet/reader.rs
@@ -0,0 +1,310 @@
+use std::fs;
+use std::path::Path;
+
+use arrow::array::RecordBatch;
+use graph::components::store::StoreError;
+use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
+
+/// Open a Parquet file and return a lazy iterator over its record batches.
+///
+/// Each call to `next()` on the returned iterator reads one row group
+/// from disk, so only one batch is in memory at a time. The caller is
+/// responsible for iterating and processing batches incrementally.
+pub fn read_batches(
+    path: &Path,
+) -> Result<impl Iterator<Item = Result<RecordBatch, StoreError>>, StoreError> {
+    let display = path.display().to_string();
+    let file = fs::File::open(path).map_err(|e| {
+        StoreError::InternalError(format!("failed to open parquet file {display}: {e}"))
+    })?;
+
+    let reader = ParquetRecordBatchReaderBuilder::try_new(file)
+        .map_err(|e| {
+            StoreError::InternalError(format!(
+                "failed to create parquet reader for {display}: {e}"
+            ))
+        })?
+        .build()
+        .map_err(|e| {
+            StoreError::InternalError(format!("failed to build parquet reader for {display}: {e}"))
+        })?;
+
+    Ok(reader.into_iter().map(move |batch| {
+        batch.map_err(|e| {
+            StoreError::InternalError(format!("failed to read record batch from {display}: {e}"))
+        })
+    }))
+}
+
+/// Read all record batches from a Parquet file into memory.
+///
+/// This is a convenience wrapper around `read_batches` that collects
+/// all batches. Prefer `read_batches` for production code to avoid
+/// loading the entire file at once.
+#[cfg(test)]
+pub fn read_all_batches(path: &Path) -> Result<Vec<RecordBatch>, StoreError> {
+    read_batches(path)?.collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow::array::{
+        Array, BinaryArray, BooleanArray, Int32Array, Int64Array, ListArray, StringArray,
+        TimestampMicrosecondArray,
+    };
+    use arrow::datatypes::{DataType, Field, Schema, TimeUnit};
+    use graph::data::store::scalar::{BigDecimal, Bytes, Timestamp};
+    use std::str::FromStr;
+
+    use super::*;
+    use crate::parquet::convert::rows_to_record_batch;
+    use crate::parquet::writer::ParquetChunkWriter;
+    use crate::relational::value::{OidRow, OidValue};
+
+    fn make_row(values: Vec<OidValue>) -> OidRow {
+        values.into_iter().collect()
+    }
+
+    struct TempFile(std::path::PathBuf);
+
+    impl TempFile {
+        fn new(name: &str) -> Self {
+            let path = std::env::temp_dir().join(format!(
+                "graph_node_reader_test_{}_{name}.parquet",
+                std::process::id()
+            ));
+            Self(path)
+        }
+
+        fn path(&self) -> &Path {
+            &self.0
+        }
+    }
+
+    impl Drop for TempFile {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_file(&self.0);
+        }
+    }
+
+    fn write_and_read(name: &str, schema: &Schema, rows: &[OidRow]) -> Vec<RecordBatch> {
+        let tmp = TempFile::new(name);
+        let batch = rows_to_record_batch(schema, rows).unwrap();
+
+        let min_vid = if rows.is_empty() { 0 } else { 1 };
+        let max_vid = rows.len() as i64;
+
+        let mut writer = ParquetChunkWriter::new(
+            tmp.path().to_path_buf(),
+            "test/chunk_000000.parquet".into(),
+            schema,
+        )
+        .unwrap();
+        writer.write_batch(&batch, min_vid, max_vid).unwrap();
+        writer.finish().unwrap();
+
+        read_all_batches(tmp.path()).unwrap()
+    }
+
+    #[test]
+    fn roundtrip_scalar_columns() {
+        let schema = Schema::new(vec![
+            Field::new("vid", DataType::Int64, false),
+            Field::new("block$", DataType::Int32, false),
+            Field::new("id", DataType::Utf8, false),
+            Field::new("flag", DataType::Boolean, true),
+            Field::new("data", DataType::Binary, true),
+            Field::new("amount", DataType::Utf8, false),
+            Field::new("ts", DataType::Timestamp(TimeUnit::Microsecond, None), true),
+        ]);
+
+        let rows = vec![
+            make_row(vec![
+                OidValue::Int8(1),
+                OidValue::Int(100),
+                OidValue::String("token-1".into()),
+                OidValue::Bool(true),
+                OidValue::Bytes(Bytes::from(vec![0xab, 0xcd])),
+                OidValue::BigDecimal(BigDecimal::from_str("12345678901234567890").unwrap()),
+                OidValue::Timestamp(Timestamp::from_microseconds_since_epoch(1_000_000).unwrap()),
+            ]),
+            make_row(vec![
+                OidValue::Int8(2),
+                OidValue::Int(101),
+                OidValue::String("token-2".into()),
+                OidValue::Null,
+                OidValue::Null,
+                OidValue::BigDecimal(BigDecimal::from_str("999").unwrap()),
+                OidValue::Null,
+            ]),
+        ];
+
+        let batches = write_and_read("scalar", &schema, &rows);
+        assert_eq!(batches.len(), 1);
+        let batch = &batches[0];
+        assert_eq!(batch.num_rows(), 2);
+        assert_eq!(batch.num_columns(), 7);
+        assert_eq!(batch.schema().fields().len(), schema.fields().len());
+
+        // Verify schema matches
+        for (got, expected) in batch.schema().fields().iter().zip(schema.fields().iter()) {
+            assert_eq!(got.name(), expected.name());
+            assert_eq!(got.data_type(), expected.data_type());
+        }
+
+        // Spot-check values
+        let vid = batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<Int64Array>()
+            .unwrap();
+        assert_eq!(vid.value(0), 1);
+        assert_eq!(vid.value(1), 2);
+
+        let id = batch
+            .column(2)
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+        assert_eq!(id.value(0), "token-1");
+        assert_eq!(id.value(1), "token-2");
+
+        let flag = batch
+            .column(3)
+            .as_any()
+            .downcast_ref::<BooleanArray>()
+            .unwrap();
+        assert!(flag.value(0));
+        assert!(flag.is_null(1));
+
+        let data = batch
+            .column(4)
+            .as_any()
+            .downcast_ref::<BinaryArray>()
+            .unwrap();
+        assert_eq!(data.value(0), &[0xab, 0xcd]);
+        assert!(data.is_null(1));
+
+        let ts = batch
+            .column(6)
+            .as_any()
+            .downcast_ref::<TimestampMicrosecondArray>()
+            .unwrap();
+        assert_eq!(ts.value(0), 1_000_000);
+        assert!(ts.is_null(1));
+    }
+
+    #[test]
+    fn roundtrip_list_columns() {
+        let schema = Schema::new(vec![
+            Field::new("vid", DataType::Int64, false),
+            Field::new(
+                "tags",
+                DataType::List(Arc::new(Field::new("item", DataType::Utf8, true))),
+                false,
+            ),
+            Field::new(
+                "scores",
+                DataType::List(Arc::new(Field::new("item", DataType::Int32, true))),
+                true,
+            ),
+        ]);
+
+        let rows = vec![
+            make_row(vec![
+                OidValue::Int8(1),
+                OidValue::StringArray(vec!["foo".into(), "bar".into()]),
+                OidValue::Ints(vec![10, 20]),
+            ]),
+            make_row(vec![
+                OidValue::Int8(2),
+                OidValue::StringArray(vec![]),
+                OidValue::Null,
+            ]),
+        ];
+
+        let batches = write_and_read("list", &schema, &rows);
+        assert_eq!(batches.len(), 1);
+        let batch = &batches[0];
+        assert_eq!(batch.num_rows(), 2);
+
+        let tags = batch
+            .column(1)
+            .as_any()
+            .downcast_ref::<ListArray>()
+            .unwrap();
+        let tags_0 = tags.value(0);
+        let tags_0_str = tags_0.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(tags_0_str.len(), 2);
+        assert_eq!(tags_0_str.value(0), "foo");
+        assert_eq!(tags_0_str.value(1), "bar");
+
+        let tags_1 = tags.value(1);
+        let tags_1_str = tags_1.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(tags_1_str.len(), 0);
+
+        let scores = batch
+            .column(2)
+            .as_any()
+            .downcast_ref::<ListArray>()
+            .unwrap();
+        assert!(!scores.is_null(0));
+        assert!(scores.is_null(1));
+    }
+
+    #[test]
+    fn roundtrip_mutable_block_range() {
+        let schema = Schema::new(vec![
+            Field::new("vid", DataType::Int64, false),
+            Field::new("block_range_start", DataType::Int32, false),
+            Field::new("block_range_end", DataType::Int32, true),
+            Field::new("id", DataType::Utf8, false),
+        ]);
+
+        let rows = vec![
+            make_row(vec![
+                OidValue::Int8(1),
+                OidValue::Int(100),
+                OidValue::Int(200),
+                OidValue::String("a".into()),
+            ]),
+            make_row(vec![
+                OidValue::Int8(2),
+                OidValue::Int(150),
+                OidValue::Null, // unbounded (current)
+                OidValue::String("b".into()),
+            ]),
+        ];
+
+        let batches = write_and_read("mutable", &schema, &rows);
+        let batch = &batches[0];
+        assert_eq!(batch.num_rows(), 2);
+
+        let start = batch
+            .column(1)
+            .as_any()
+            .downcast_ref::<Int32Array>()
+            .unwrap();
+        assert_eq!(start.value(0), 100);
+        assert_eq!(start.value(1), 150);
+
+        let end = batch
+            .column(2)
+            .as_any()
+            .downcast_ref::<Int32Array>()
+            .unwrap();
+        assert_eq!(end.value(0), 200);
+        assert!(end.is_null(1));
+    }
+
+    #[test]
+    fn nonexistent_file_returns_error() {
+        let err = read_batches(Path::new("/tmp/nonexistent_graph_node_test.parquet"))
+            .err()
+            .expect("should fail for nonexistent file")
+            .to_string();
+        assert!(err.contains("failed to open parquet file"));
+    }
+}
diff --git a/store/postgres/src/parquet/schema.rs b/store/postgres/src/parquet/schema.rs
new file mode 100644
index 00000000000..f5c06643be0
--- /dev/null
+++ b/store/postgres/src/parquet/schema.rs
@@ -0,0 +1,426 @@
+use std::sync::Arc;
+
+use arrow::datatypes::{DataType, Field, Schema, TimeUnit};
+
+use crate::relational::{ColumnType, Table};
+
+/// Map a relational `Table` to an Arrow `Schema`.
+///
+/// System columns are emitted first (`vid`, then block tracking, then
+/// `causality_region`), followed by data columns in declaration order.
+/// Fulltext (TSVector) columns are skipped — they are generated and
+/// rebuilt on restore.
+pub fn arrow_schema(table: &Table) -> Schema {
+    let mut fields = Vec::new();
+
+    // vid — always present, non-nullable
+    fields.push(Field::new("vid", DataType::Int64, false));
+
+    // Block tracking
+    if table.immutable {
+        fields.push(Field::new("block$", DataType::Int32, false));
+    } else {
+        fields.push(Field::new("block_range_start", DataType::Int32, false));
+        fields.push(Field::new("block_range_end", DataType::Int32, true));
+    }
+
+    // Causality region
+    if table.has_causality_region {
+        fields.push(Field::new("causality_region", DataType::Int32, false));
+    }
+
+    // Data columns
+    for col in &table.columns {
+        if col.is_fulltext() {
+            continue;
+        }
+        let base_type = column_type_to_arrow(&col.column_type);
+        let dt = if col.is_list() {
+            DataType::List(Arc::new(Field::new("item", base_type, true)))
+        } else {
+            base_type
+        };
+        fields.push(Field::new(col.name.as_str(), dt, col.is_nullable()));
+    }
+
+    Schema::new(fields)
+}
+
+/// Fixed Arrow schema for the `data_sources$` table.
+pub fn data_sources_arrow_schema() -> Schema {
+    Schema::new(vec![
+        Field::new("vid", DataType::Int64, false),
+        Field::new("block_range_start", DataType::Int32, false),
+        Field::new("block_range_end", DataType::Int32, true),
+        Field::new("causality_region", DataType::Int32, false),
+        Field::new("manifest_idx", DataType::Int32, false),
+        Field::new("parent", DataType::Int32, true),
+        Field::new("id", DataType::Binary, true),
+        Field::new("param", DataType::Binary, true),
+        Field::new("context", DataType::Utf8, true),
+        Field::new("done_at", DataType::Int32, true),
+    ])
+}
+
+/// Arrow schema for clamp files: records which rows had their
+/// `block_range` upper bound set (clamped) since a previous dump.
+pub fn clamp_arrow_schema() -> Schema {
+    Schema::new(vec![
+        Field::new("vid", DataType::Int64, false),
+        Field::new("block_range_end", DataType::Int32, false),
+    ])
+}
+
+fn column_type_to_arrow(ct: &ColumnType) -> DataType {
+    match ct {
+        ColumnType::Boolean => DataType::Boolean,
+        ColumnType::Int => DataType::Int32,
+        ColumnType::Int8 => DataType::Int64,
+        ColumnType::Bytes => DataType::Binary,
+        ColumnType::BigInt | ColumnType::BigDecimal => DataType::Utf8,
+        ColumnType::Timestamp => DataType::Timestamp(TimeUnit::Microsecond, None),
+        ColumnType::String | ColumnType::Enum(_) => DataType::Utf8,
+        ColumnType::TSVector(_) => {
+            unreachable!("TSVector columns should be skipped before calling column_type_to_arrow")
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeSet;
+    use std::sync::Arc;
+
+    use arrow::datatypes::{DataType, TimeUnit};
+    use graph::prelude::DeploymentHash;
+    use graph::schema::InputSchema;
+
+    use crate::layout_for_tests::{Catalog, Layout, Namespace, make_dummy_site};
+
+    use super::*;
+
+    fn test_layout(gql: &str) -> Layout {
+        let subgraph = DeploymentHash::new("subgraph").unwrap();
+        let schema = InputSchema::parse_latest(gql, subgraph.clone()).expect("Test schema invalid");
+        let namespace = Namespace::new("sgd0815".to_owned()).unwrap();
+        let site = Arc::new(make_dummy_site(subgraph, namespace, "anet".to_string()));
+        let catalog =
+            Catalog::for_tests(site.clone(), BTreeSet::new()).expect("Can not create catalog");
+        Layout::new(site, &schema, catalog).expect("Failed to construct Layout")
+    }
+
+    fn test_layout_with_causality(gql: &str, entity_name: &str) -> Layout {
+        let subgraph = DeploymentHash::new("subgraph").unwrap();
+        let schema = InputSchema::parse_latest(gql, subgraph.clone()).expect("Test schema invalid");
+        let namespace = Namespace::new("sgd0815".to_owned()).unwrap();
+        let site = Arc::new(make_dummy_site(subgraph, namespace, "anet".to_string()));
+        let entity_type = schema.entity_type(entity_name).unwrap();
+        let ents = BTreeSet::from_iter(vec![entity_type]);
+        let catalog = Catalog::for_tests(site.clone(), ents).expect("Can not create catalog");
+        Layout::new(site, &schema, catalog).expect("Failed to construct Layout")
+    }
+
+    #[test]
+    fn immutable_table_schema() {
+        let layout = test_layout(
+            "type Token @entity(immutable: true) { id: ID!, name: String!, decimals: Int! }",
+        );
+        let table = layout.table("token").unwrap();
+        let schema = arrow_schema(table);
+
+        let names: Vec<&str> = schema.fields().iter().map(|f| f.name().as_str()).collect();
+        assert_eq!(names, &["vid", "block$", "id", "name", "decimals"]);
+
+        assert_eq!(
+            schema.field_with_name("vid").unwrap().data_type(),
+            &DataType::Int64
+        );
+        assert!(!schema.field_with_name("vid").unwrap().is_nullable());
+
+        assert_eq!(
+            schema.field_with_name("block$").unwrap().data_type(),
+            &DataType::Int32
+        );
+        assert!(!schema.field_with_name("block$").unwrap().is_nullable());
+
+        assert_eq!(
+            schema.field_with_name("id").unwrap().data_type(),
+            &DataType::Utf8
+        );
+        assert!(!schema.field_with_name("id").unwrap().is_nullable());
+
+        assert_eq!(
+            schema.field_with_name("name").unwrap().data_type(),
+            &DataType::Utf8
+        );
+        assert_eq!(
+            schema.field_with_name("decimals").unwrap().data_type(),
+            &DataType::Int32
+        );
+    }
+
+    #[test]
+    fn mutable_table_with_causality_region() {
+        let layout = test_layout_with_causality(
+            "type Transfer @entity { id: ID!, amount: BigInt! }",
+            "Transfer",
+        );
+        let table = layout.table("transfer").unwrap();
+        let schema = arrow_schema(table);
+
+        let names: Vec<&str> = schema.fields().iter().map(|f| f.name().as_str()).collect();
+        assert_eq!(
+            names,
+            &[
+                "vid",
+                "block_range_start",
+                "block_range_end",
+                "causality_region",
+                "id",
+                "amount"
+            ]
+        );
+
+        assert_eq!(
+            schema
+                .field_with_name("block_range_start")
+                .unwrap()
+                .data_type(),
+            &DataType::Int32
+        );
+        assert!(
+            !schema
+                .field_with_name("block_range_start")
+                .unwrap()
+                .is_nullable()
+        );
+
+        assert_eq!(
+            schema
+                .field_with_name("block_range_end")
+                .unwrap()
+                .data_type(),
+            &DataType::Int32
+        );
+        assert!(
+            schema
+                .field_with_name("block_range_end")
+                .unwrap()
+                .is_nullable()
+        );
+
+        assert_eq!(
+            schema
+                .field_with_name("causality_region")
+                .unwrap()
+                .data_type(),
+            &DataType::Int32
+        );
+
+        assert_eq!(
+            schema.field_with_name("amount").unwrap().data_type(),
+            &DataType::Utf8
+        );
+    }
+
+    #[test]
+    fn mutable_table_without_causality_region() {
+        let layout = test_layout("type Pair @entity { id: ID!, price: BigDecimal! }");
+        let table = layout.table("pair").unwrap();
+        let schema = arrow_schema(table);
+
+        let names: Vec<&str> = schema.fields().iter().map(|f| f.name().as_str()).collect();
+        assert_eq!(
+            names,
+            &["vid", "block_range_start", "block_range_end", "id", "price"]
+        );
+
+        // No causality_region field
+        assert!(schema.field_with_name("causality_region").is_err());
+    }
+
+    #[test]
+    fn nullable_and_list_columns() {
+        let layout = test_layout(
+            "type Pool @entity(immutable: true) { id: ID!, tags: [String!]!, description: String }",
+        );
+        let table = layout.table("pool").unwrap();
+        let schema = arrow_schema(table);
+
+        // tags is a non-nullable list of strings
+        let tags = schema.field_with_name("tags").unwrap();
+        assert!(!tags.is_nullable());
+        match tags.data_type() {
+            DataType::List(inner) => {
+                assert_eq!(inner.data_type(), &DataType::Utf8);
+            }
+            other => panic!("expected List, got {:?}", other),
+        }
+
+        // description is nullable
+        let desc = schema.field_with_name("description").unwrap();
+        assert!(desc.is_nullable());
+        assert_eq!(desc.data_type(), &DataType::Utf8);
+    }
+
+    #[test]
+    fn all_scalar_column_types() {
+        let layout = test_layout(
+            "type Everything @entity(immutable: true) { \
+                id: ID!, \
+                flag: Boolean!, \
+                small: Int!, \
+                big: Int8!, \
+                amount: BigInt!, \
+                price: BigDecimal!, \
+                data: Bytes!, \
+                ts: Timestamp!, \
+                label: String! \
+            }",
+        );
+        let table = layout.table("everything").unwrap();
+        let schema = arrow_schema(table);
+
+        assert_eq!(
+            schema.field_with_name("flag").unwrap().data_type(),
+            &DataType::Boolean
+        );
+        assert_eq!(
+            schema.field_with_name("small").unwrap().data_type(),
+            &DataType::Int32
+        );
+        assert_eq!(
+            schema.field_with_name("big").unwrap().data_type(),
+            &DataType::Int64
+        );
+        assert_eq!(
+            schema.field_with_name("amount").unwrap().data_type(),
+            &DataType::Utf8
+        );
+        assert_eq!(
+            schema.field_with_name("price").unwrap().data_type(),
+            &DataType::Utf8
+        );
+        assert_eq!(
+            schema.field_with_name("data").unwrap().data_type(),
+            &DataType::Binary
+        );
+        assert_eq!(
+            schema.field_with_name("ts").unwrap().data_type(),
+            &DataType::Timestamp(TimeUnit::Microsecond, None)
+        );
+        assert_eq!(
+            schema.field_with_name("label").unwrap().data_type(),
+            &DataType::Utf8
+        );
+    }
+
+    #[test]
+    fn data_sources_schema() {
+        let schema = data_sources_arrow_schema();
+        let names: Vec<&str> = schema.fields().iter().map(|f| f.name().as_str()).collect();
+        assert_eq!(
+            names,
+            &[
+                "vid",
+                "block_range_start",
+                "block_range_end",
+                "causality_region",
+                "manifest_idx",
+                "parent",
+                "id",
+                "param",
+                "context",
+                "done_at"
+            ]
+        );
+
+        // Check nullability
+        assert!(!schema.field_with_name("vid").unwrap().is_nullable());
+        assert!(
+            !schema
+                .field_with_name("block_range_start")
+                .unwrap()
+                .is_nullable()
+        );
+        assert!(
+            schema
+                .field_with_name("block_range_end")
+                .unwrap()
+                .is_nullable()
+        );
+        assert!(
+            !schema
+                .field_with_name("causality_region")
+                .unwrap()
+                .is_nullable()
+        );
+        assert!(
+            !schema
+                .field_with_name("manifest_idx")
+                .unwrap()
+                .is_nullable()
+        );
+        assert!(schema.field_with_name("parent").unwrap().is_nullable());
+        assert!(schema.field_with_name("id").unwrap().is_nullable());
+        assert!(schema.field_with_name("param").unwrap().is_nullable());
+        assert!(schema.field_with_name("context").unwrap().is_nullable());
+        assert!(schema.field_with_name("done_at").unwrap().is_nullable());
+
+        // Check types
+        assert_eq!(
+            schema.field_with_name("vid").unwrap().data_type(),
+            &DataType::Int64
+        );
+        assert_eq!(
+            schema.field_with_name("context").unwrap().data_type(),
+            &DataType::Utf8
+        );
+        assert_eq!(
+            schema.field_with_name("param").unwrap().data_type(),
+            &DataType::Binary
+        );
+    }
+
+    #[test]
+    fn clamp_schema() {
+        let schema = clamp_arrow_schema();
+        let names: Vec<&str> = schema.fields().iter().map(|f| f.name().as_str()).collect();
+        assert_eq!(names, &["vid", "block_range_end"]);
+
+        assert_eq!(
+            schema.field_with_name("vid").unwrap().data_type(),
+            &DataType::Int64
+        );
+        assert!(!schema.field_with_name("vid").unwrap().is_nullable());
+
+        assert_eq!(
+            schema
+                .field_with_name("block_range_end")
+                .unwrap()
+                .data_type(),
+            &DataType::Int32
+        );
+        assert!(
+            !schema
+                .field_with_name("block_range_end")
+                .unwrap()
+                .is_nullable()
+        );
+    }
+
+    #[test]
+    fn enum_columns_map_to_utf8() {
+        let layout = test_layout(
+            "enum Status { Active, Inactive } \
+             type Item @entity(immutable: true) { id: ID!, status: Status! }",
+        );
+        let table = layout.table("item").unwrap();
+        let schema = arrow_schema(table);
+
+        assert_eq!(
+            schema.field_with_name("status").unwrap().data_type(),
+            &DataType::Utf8
+        );
+    }
+}
diff --git a/store/postgres/src/parquet/writer.rs b/store/postgres/src/parquet/writer.rs
new file mode 100644
index 00000000000..9ab6df53c20
--- /dev/null
+++ b/store/postgres/src/parquet/writer.rs
@@ -0,0 +1,354 @@
+use std::fs;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use arrow::array::RecordBatch;
+use arrow::datatypes::Schema;
+use graph::components::store::StoreError;
+use parquet::arrow::ArrowWriter;
+use parquet::basic::{Compression, ZstdLevel};
+use parquet::file::properties::WriterProperties;
+
+use serde::{Deserialize, Serialize};
+
+/// Per-chunk metadata recorded in `metadata.json`.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ChunkInfo {
+    pub file: String,
+    pub min_vid: i64,
+    pub max_vid: i64,
+    pub row_count: usize,
+}
+
+/// Writes `RecordBatch`es into a single Parquet file using ZSTD compression.
+///
+/// Tracks row count and vid range across all written batches. Call
+/// `finish()` to flush and close the file, returning a `ChunkInfo`
+/// summary.
+pub struct ParquetChunkWriter {
+    writer: ArrowWriter<fs::File>,
+    /// Relative path from the dump directory (e.g. `"Token/chunk_000000.parquet"`).
+    relative_path: String,
+    row_count: usize,
+    min_vid: i64,
+    max_vid: i64,
+}
+
+impl ParquetChunkWriter {
+    /// Create a new writer for a Parquet chunk file.
+    ///
+    /// `path` is the absolute file path. `relative_path` is stored in the
+    /// resulting `ChunkInfo` (e.g. `"Token/chunk_000000.parquet"`).
+    pub fn new(path: PathBuf, relative_path: String, schema: &Schema) -> Result<Self, StoreError> {
+        let props = WriterProperties::builder()
+            .set_compression(Compression::ZSTD(ZstdLevel::default()))
+            .build();
+
+        let file = fs::File::create(&path).map_err(|e| {
+            StoreError::InternalError(format!(
+                "failed to create parquet file {}: {e}",
+                path.display()
+            ))
+        })?;
+
+        let writer =
+            ArrowWriter::try_new(file, Arc::new(schema.clone()), Some(props)).map_err(|e| {
+                StoreError::InternalError(format!(
+                    "failed to create ArrowWriter for {}: {e}",
+                    path.display()
+                ))
+            })?;
+
+        Ok(Self {
+            writer,
+            relative_path,
+            row_count: 0,
+            min_vid: i64::MAX,
+            max_vid: i64::MIN,
+        })
+    }
+
+    /// Write a `RecordBatch` and update tracking stats.
+    ///
+    /// `batch_min_vid` and `batch_max_vid` are the vid bounds of this
+    /// batch (typically the first and last vid values).
+    pub fn write_batch(
+        &mut self,
+        batch: &RecordBatch,
+        batch_min_vid: i64,
+        batch_max_vid: i64,
+    ) -> Result<(), StoreError> {
+        if batch.num_rows() == 0 {
+            return Ok(());
+        }
+        self.writer
+            .write(batch)
+            .map_err(|e| StoreError::InternalError(format!("failed to write RecordBatch: {e}")))?;
+        self.row_count += batch.num_rows();
+        self.min_vid = self.min_vid.min(batch_min_vid);
+        self.max_vid = self.max_vid.max(batch_max_vid);
+        Ok(())
+    }
+
+    /// Flush and close the Parquet file, returning chunk metadata.
+    pub fn finish(self) -> Result<ChunkInfo, StoreError> {
+        self.writer.close().map_err(|e| {
+            StoreError::InternalError(format!("failed to close parquet writer: {e}"))
+        })?;
+        Ok(ChunkInfo {
+            file: self.relative_path,
+            min_vid: self.min_vid,
+            max_vid: self.max_vid,
+            row_count: self.row_count,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow::array::{
+        Array, BinaryArray, BooleanArray, Int32Array, Int64Array, StringArray,
+        TimestampMicrosecondArray,
+    };
+    use arrow::datatypes::{DataType, Field, Schema, TimeUnit};
+    use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
+    use std::sync::Arc;
+
+    use super::*;
+
+    /// Create a unique temp file path for a test. The caller is responsible
+    /// for cleanup via the returned `TempFile` guard.
+    struct TempFile(PathBuf);
+
+    impl TempFile {
+        fn new(name: &str) -> Self {
+            let path = std::env::temp_dir().join(format!(
+                "graph_node_test_{}_{name}.parquet",
+                std::process::id()
+            ));
+            Self(path)
+        }
+
+        fn path(&self) -> &std::path::Path {
+            &self.0
+        }
+    }
+
+    impl Drop for TempFile {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_file(&self.0);
+        }
+    }
+
+    fn test_schema() -> Schema {
+        Schema::new(vec![
+            Field::new("vid", DataType::Int64, false),
+            Field::new("block$", DataType::Int32, false),
+            Field::new("id", DataType::Utf8, false),
+            Field::new("flag", DataType::Boolean, true),
+            Field::new("data", DataType::Binary, true),
+            Field::new("ts", DataType::Timestamp(TimeUnit::Microsecond, None), true),
+        ])
+    }
+
+    fn test_batch(schema: &Schema) -> RecordBatch {
+        RecordBatch::try_new(
+            Arc::new(schema.clone()),
+            vec![
+                Arc::new(Int64Array::from(vec![1, 2, 3])),
+                Arc::new(Int32Array::from(vec![100, 101, 102])),
+                Arc::new(StringArray::from(vec!["a", "b", "c"])),
+                Arc::new(BooleanArray::from(vec![Some(true), None, Some(false)])),
+                Arc::new(BinaryArray::from_opt_vec(vec![
+                    Some(b"\xab\xcd"),
+                    None,
+                    Some(b"\xff"),
+                ])),
+                Arc::new(TimestampMicrosecondArray::from(vec![
+                    Some(1_000_000),
+                    Some(2_000_000),
+                    None,
+                ])),
+            ],
+        )
+        .unwrap()
+    }
+
+    /// Read all record batches from a parquet file.
+    fn read_parquet(path: &std::path::Path) -> Vec<RecordBatch> {
+        let file = std::fs::File::open(path).unwrap();
+        let reader = ParquetRecordBatchReaderBuilder::try_new(file)
+            .unwrap()
+            .build()
+            .unwrap();
+        reader.map(|r| r.unwrap()).collect()
+    }
+
+    #[test]
+    fn write_and_read_back() {
+        let schema = test_schema();
+        let batch = test_batch(&schema);
+        let tmp = TempFile::new("write_read");
+
+        let mut writer = ParquetChunkWriter::new(
+            tmp.path().to_path_buf(),
+            "Test/chunk_000000.parquet".into(),
+            &schema,
+        )
+        .unwrap();
+        writer.write_batch(&batch, 1, 3).unwrap();
+        let chunk_info = writer.finish().unwrap();
+
+        assert_eq!(chunk_info.file, "Test/chunk_000000.parquet");
+        assert_eq!(chunk_info.min_vid, 1);
+        assert_eq!(chunk_info.max_vid, 3);
+        assert_eq!(chunk_info.row_count, 3);
+
+        // Read back and verify
+        let batches = read_parquet(tmp.path());
+        assert_eq!(batches.len(), 1);
+        let read_batch = &batches[0];
+
+        assert_eq!(read_batch.num_rows(), 3);
+        assert_eq!(read_batch.num_columns(), 6);
+
+        let vid = read_batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<Int64Array>()
+            .unwrap();
+        assert_eq!(vid.values(), &[1, 2, 3]);
+
+        let block = read_batch
+            .column(1)
+            .as_any()
+            .downcast_ref::<Int32Array>()
+            .unwrap();
+        assert_eq!(block.values(), &[100, 101, 102]);
+
+        let id = read_batch
+            .column(2)
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+        assert_eq!(id.value(0), "a");
+        assert_eq!(id.value(2), "c");
+
+        let flag = read_batch
+            .column(3)
+            .as_any()
+            .downcast_ref::<BooleanArray>()
+            .unwrap();
+        assert!(flag.value(0));
+        assert!(flag.is_null(1));
+        assert!(!flag.value(2));
+
+        let data = read_batch
+            .column(4)
+            .as_any()
+            .downcast_ref::<BinaryArray>()
+            .unwrap();
+        assert_eq!(data.value(0), b"\xab\xcd");
+        assert!(data.is_null(1));
+
+        let ts = read_batch
+            .column(5)
+            .as_any()
+            .downcast_ref::<TimestampMicrosecondArray>()
+            .unwrap();
+        assert_eq!(ts.value(0), 1_000_000);
+        assert!(ts.is_null(2));
+    }
+
+    #[test]
+    fn multiple_batches_accumulate_stats() {
+        let schema = test_schema();
+
+        let batch1 = RecordBatch::try_new(
+            Arc::new(schema.clone()),
+            vec![
+                Arc::new(Int64Array::from(vec![10, 20])),
+                Arc::new(Int32Array::from(vec![1, 1])),
+                Arc::new(StringArray::from(vec!["x", "y"])),
+                Arc::new(BooleanArray::from(vec![true, false])),
+                Arc::new(BinaryArray::from_vec(vec![b"a", b"b"])),
+                Arc::new(TimestampMicrosecondArray::from(vec![100, 200])),
+            ],
+        )
+        .unwrap();
+
+        let batch2 = RecordBatch::try_new(
+            Arc::new(schema.clone()),
+            vec![
+                Arc::new(Int64Array::from(vec![30])),
+                Arc::new(Int32Array::from(vec![2])),
+                Arc::new(StringArray::from(vec!["z"])),
+                Arc::new(BooleanArray::from(vec![true])),
+                Arc::new(BinaryArray::from_vec(vec![b"c"])),
+                Arc::new(TimestampMicrosecondArray::from(vec![300])),
+            ],
+        )
+        .unwrap();
+
+        let tmp = TempFile::new("multi_batch");
+
+        let mut writer = ParquetChunkWriter::new(
+            tmp.path().to_path_buf(),
+            "Foo/chunk_000000.parquet".into(),
+            &schema,
+        )
+        .unwrap();
+        writer.write_batch(&batch1, 10, 20).unwrap();
+        writer.write_batch(&batch2, 30, 30).unwrap();
+        let chunk_info = writer.finish().unwrap();
+
+        assert_eq!(chunk_info.min_vid, 10);
+        assert_eq!(chunk_info.max_vid, 30);
+        assert_eq!(chunk_info.row_count, 3);
+
+        // Verify all 3 rows readable
+        let batches = read_parquet(tmp.path());
+        let total_rows: usize = batches.iter().map(|b| b.num_rows()).sum();
+        assert_eq!(total_rows, 3);
+    }
+
+    #[test]
+    fn empty_batch_is_noop() {
+        let schema = test_schema();
+        let empty = RecordBatch::new_empty(Arc::new(schema.clone()));
+        let tmp = TempFile::new("empty_batch");
+
+        let mut writer = ParquetChunkWriter::new(
+            tmp.path().to_path_buf(),
+            "X/chunk_000000.parquet".into(),
+            &schema,
+        )
+        .unwrap();
+        writer.write_batch(&empty, 0, 0).unwrap();
+        let chunk_info = writer.finish().unwrap();
+
+        assert_eq!(chunk_info.row_count, 0);
+        // min_vid/max_vid stay at initial sentinel values when nothing was written
+        assert_eq!(chunk_info.min_vid, i64::MAX);
+        assert_eq!(chunk_info.max_vid, i64::MIN);
+    }
+
+    #[test]
+    fn chunk_info_serialization() {
+        let info = ChunkInfo {
+            file: "Token/chunk_000000.parquet".into(),
+            min_vid: 0,
+            max_vid: 50000,
+            row_count: 50000,
+        };
+        let json = serde_json::to_string_pretty(&info).unwrap();
+        assert!(json.contains("Token/chunk_000000.parquet"));
+        assert!(json.contains("50000"));
+
+        let deserialized: ChunkInfo = serde_json::from_str(&json).unwrap();
+        assert_eq!(deserialized.file, info.file);
+        assert_eq!(deserialized.min_vid, info.min_vid);
+        assert_eq!(deserialized.max_vid, info.max_vid);
+        assert_eq!(deserialized.row_count, info.row_count);
+    }
+}
diff --git a/store/postgres/src/pool/coordinator.rs b/store/postgres/src/pool/coordinator.rs
new file mode 100644
index 00000000000..cf733deb3f3
--- /dev/null
+++ b/store/postgres/src/pool/coordinator.rs
@@ -0,0 +1,314 @@
+use graph::cheap_clone::CheapClone;
+use graph::futures03::FutureExt as _;
+use graph::futures03::future::join_all;
+use graph::internal_error;
+use graph::prelude::MetricsRegistry;
+use graph::prelude::{StoreError, crit, debug, error, info, o};
+use graph::slog::Logger;
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+use crate::advisory_lock::with_migration_lock;
+use crate::{PRIMARY_SHARD, Shard};
+
+use super::{ConnectionPool, ForeignServer, MigrationCount, PoolInner, PoolRole, PoolState};
+
+/// Helper to coordinate propagating schema changes from the database that
+/// changes schema to all other shards so they can update their fdw mappings
+/// of tables imported from that shard
+pub struct PoolCoordinator {
+    logger: Logger,
+    pools: Mutex<HashMap<Shard, PoolState>>,
+    servers: Arc<Vec<ForeignServer>>,
+}
+
+impl PoolCoordinator {
+    pub fn new(logger: &Logger, servers: Arc<Vec<ForeignServer>>) -> Self {
+        let logger = logger.new(o!("component" => "ConnectionPool", "component" => "Coordinator"));
+        Self {
+            logger,
+            pools: Mutex::new(HashMap::new()),
+            servers,
+        }
+    }
+
+    pub fn create_pool(
+        self: Arc<Self>,
+        logger: &Logger,
+        name: &str,
+        pool_name: PoolRole,
+        postgres_url: String,
+        pool_size: u32,
+        fdw_pool_size: Option<u32>,
+        registry: Arc<MetricsRegistry>,
+    ) -> ConnectionPool {
+        let is_writable = !pool_name.is_replica();
+
+        let pool = ConnectionPool::create(
+            name,
+            pool_name,
+            postgres_url,
+            pool_size,
+            fdw_pool_size,
+            logger,
+            registry,
+            self.cheap_clone(),
+        );
+
+        // Ignore non-writable pools (replicas), there is no need (and no
+        // way) to coordinate schema changes with them
+        if is_writable {
+            self.pools
+                .lock()
+                .unwrap()
+                .insert(pool.shard.clone(), pool.inner.cheap_clone());
+        }
+
+        pool
+    }
+
+    /// Propagate changes to the schema in `shard` to all other pools. Those
+    /// other pools will then recreate any tables that they imported from
+    /// `shard`. If `pool` is a new shard, we also map all other shards into
+    /// it.
+    ///
+    /// This tries to take the migration lock and must therefore be run from
+    /// code that does _not_ hold the migration lock as it will otherwise
+    /// deadlock
+    async fn propagate(&self, pool: &PoolInner, count: MigrationCount) -> Result<(), StoreError> {
+        // We need to remap all these servers into `pool` if the list of
+        // tables that are mapped have changed from the code of the previous
+        // version. Since dropping and recreating the foreign table
+        // definitions can slow the startup of other nodes down because of
+        // locking, we try to only do this when it is actually needed
+        for server in self.servers.iter() {
+            if pool.needs_remap(server).await? {
+                pool.remap(server).await?;
+            }
+        }
+
+        // pool had schema changes, refresh the import from pool into all
+        // other shards. This makes sure that schema changes to
+        // already-mapped tables are propagated to all other shards. Since
+        // we run `propagate` after migrations have been applied to `pool`,
+        // we can be sure that these mappings use the correct schema
+        if count.had_migrations() {
+            let server = self.server(&pool.shard)?;
+            for pool in self.pools() {
+                let remap_res = pool.remap(server).await;
+                if let Err(e) = remap_res {
+                    error!(pool.logger, "Failed to map imports from {}", server.shard; "error" => e.to_string());
+                    return Err(e);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Return a list of all pools, regardless of whether they are ready or
+    /// not.
+    pub fn pools(&self) -> Vec<Arc<PoolInner>> {
+        self.pools
+            .lock()
+            .unwrap()
+            .values()
+            .map(|state| state.get_unready())
+            .collect::<Vec<_>>()
+    }
+
+    pub fn servers(&self) -> Arc<Vec<ForeignServer>> {
+        self.servers.clone()
+    }
+
+    fn server(&self, shard: &Shard) -> Result<&ForeignServer, StoreError> {
+        self.servers
+            .iter()
+            .find(|server| &server.shard == shard)
+            .ok_or_else(|| internal_error!("unknown shard {shard}"))
+    }
+
+    fn primary(&self) -> Result<Arc<PoolInner>, StoreError> {
+        let map = self.pools.lock().unwrap();
+        let pool_state = map.get(&PRIMARY_SHARD).ok_or_else(|| {
+            internal_error!("internal error: primary shard not found in pool coordinator")
+        })?;
+
+        Ok(pool_state.get_unready())
+    }
+
+    /// Setup all pools the coordinator knows about and return the number of
+    /// pools that were successfully set up.
+    ///
+    /// # Panics
+    ///
+    /// If any errors besides a database not being available happen during
+    /// the migration, the process panics
+    pub async fn setup_all(&self, logger: &Logger) -> usize {
+        let pools = self
+            .pools
+            .lock()
+            .unwrap()
+            .values()
+            .cloned()
+            .collect::<Vec<_>>();
+
+        let res = self.setup(pools).await;
+
+        match res {
+            Ok(count) => {
+                info!(logger, "Setup finished"; "shards" => count);
+                count
+            }
+            Err(e) => {
+                crit!(logger, "database setup failed"; "error" => format!("{e}"));
+                panic!("database setup failed: {}", e);
+            }
+        }
+    }
+
+    /// A helper to call `setup` from a non-async context. Returns `true` if
+    /// the setup was actually run, i.e. if `pool` was available
+    pub(crate) fn setup_bg(self: Arc<Self>, pool: PoolState) -> Result<bool, StoreError> {
+        let migrated = graph::spawn_thread("database-setup", move || {
+            graph::block_on(self.setup(vec![pool.clone()]))
+        })
+        .join()
+        // unwrap: propagate panics
+        .unwrap()?;
+        Ok(migrated == 1)
+    }
+
+    /// Setup all pools by doing the following steps:
+    /// 1. Get the migration lock in the primary. This makes sure that only
+    ///    one node runs migrations
+    /// 2. Remove the views in `sharded` as they might interfere with
+    ///    running migrations
+    /// 3. In parallel, do the following in each pool:
+    ///    1. Configure fdw servers
+    ///    2. Run migrations in all pools in parallel
+    /// 4. In parallel, do the following in each pool:
+    ///    1. Create/update the mappings in `shard_<shard>_subgraphs` and in
+    ///       `primary_public`
+    /// 5. Create the views in `sharded` again
+    /// 6. Release the migration lock
+    ///
+    /// This method tolerates databases that are not available and will
+    /// simply ignore them. The returned count is the number of pools that
+    /// were successfully set up.
+    ///
+    /// When this method returns, the entries from `states` that were
+    /// successfully set up will be marked as ready. The method returns the
+    /// number of pools that were set up
+    async fn setup(&self, states: Vec<PoolState>) -> Result<usize, StoreError> {
+        type MigrationCounts = Vec<(PoolState, MigrationCount)>;
+
+        /// Filter out pools that are not available. We don't want to fail
+        /// because one of the pools is not available. We will just ignore
+        /// them and continue with the others.
+        fn filter_unavailable<T>(
+            (state, res): (PoolState, Result<T, StoreError>),
+        ) -> Option<Result<(PoolState, T), StoreError>> {
+            if let Err(StoreError::DatabaseUnavailable) = res {
+                error!(
+                    state.logger,
+                    "migrations failed because database was unavailable"
+                );
+                None
+            } else {
+                Some(res.map(|count| (state, count)))
+            }
+        }
+
+        /// Migrate all pools in parallel
+        async fn migrate(
+            pools: &[PoolState],
+            servers: &[ForeignServer],
+        ) -> Result<MigrationCounts, StoreError> {
+            let futures = pools
+                .iter()
+                .map(|state| {
+                    state
+                        .get_unready()
+                        .cheap_clone()
+                        .migrate(servers)
+                        .map(|res| (state.cheap_clone(), res))
+                })
+                .collect::<Vec<_>>();
+            join_all(futures)
+                .await
+                .into_iter()
+                .filter_map(filter_unavailable)
+                .collect::<Result<Vec<_>, _>>()
+        }
+
+        /// Propagate the schema changes to all other pools in parallel
+        async fn propagate(
+            this: &PoolCoordinator,
+            migrated: MigrationCounts,
+        ) -> Result<Vec<PoolState>, StoreError> {
+            let futures = migrated
+                .into_iter()
+                .map(|(state, count)| async move {
+                    let pool = state.get_unready();
+                    let res = this.propagate(&pool, count).await;
+                    (state.cheap_clone(), res)
+                })
+                .collect::<Vec<_>>();
+            join_all(futures)
+                .await
+                .into_iter()
+                .filter_map(filter_unavailable)
+                .map(|res| res.map(|(state, ())| state))
+                .collect::<Result<Vec<_>, _>>()
+        }
+
+        let primary = self.primary()?;
+
+        let mut pconn = primary.get_for_setup().await?;
+
+        let states: Vec<_> = states
+            .into_iter()
+            .filter(|pool| pool.needs_setup())
+            .collect();
+        if states.is_empty() {
+            return Ok(0);
+        }
+
+        // Everything here happens under the migration lock. Anything called
+        // from here should not try to get that lock, otherwise the process
+        // will deadlock
+        debug!(self.logger, "Waiting for migration lock");
+        let res = with_migration_lock(&mut pconn, |_| async {
+            debug!(self.logger, "Migration lock acquired");
+
+            // While we were waiting for the migration lock, another thread
+            // might have already run this
+            let states: Vec<_> = states
+                .into_iter()
+                .filter(|pool| pool.needs_setup())
+                .collect();
+            if states.is_empty() {
+                debug!(self.logger, "No pools to set up");
+                return Ok(0);
+            }
+
+            primary.drop_cross_shard_views().await?;
+
+            let migrated = migrate(&states, self.servers.as_ref()).await?;
+
+            let propagated = propagate(self, migrated).await?;
+
+            primary.create_cross_shard_views(&self.servers).await?;
+
+            for state in &propagated {
+                state.set_ready();
+            }
+            Ok(propagated.len())
+        })
+        .await;
+        debug!(self.logger, "Database setup finished");
+
+        res
+    }
+}
diff --git a/store/postgres/src/pool/foreign_server.rs b/store/postgres/src/pool/foreign_server.rs
new file mode 100644
index 00000000000..c2883eb929b
--- /dev/null
+++ b/store/postgres/src/pool/foreign_server.rs
@@ -0,0 +1,248 @@
+use diesel_async::SimpleAsyncConnection;
+use graph::{
+    prelude::{
+        ENV_VARS, StoreError,
+        anyhow::{self, anyhow, bail},
+    },
+    util::security::SafeDisplay,
+};
+
+use std::fmt::Write;
+
+use postgres::config::{Config, Host};
+
+use crate::primary::NAMESPACE_PUBLIC;
+use crate::{AsyncPgConnection, catalog};
+use crate::{PRIMARY_SHARD, Shard};
+
+use super::{PRIMARY_PUBLIC, PRIMARY_TABLES, SHARDED_TABLES};
+
+#[derive(Clone)]
+pub struct ForeignServer {
+    pub name: String,
+    pub shard: Shard,
+    pub user: String,
+    pub password: String,
+    pub host: String,
+    pub port: u16,
+    pub dbname: String,
+}
+
+impl ForeignServer {
+    /// The name of the foreign server under which data for `shard` is
+    /// accessible
+    pub fn name(shard: &Shard) -> String {
+        format!("shard_{}", shard.as_str())
+    }
+
+    /// The name of the schema under which the `subgraphs` schema for
+    /// `shard` is accessible in shards that are not `shard`. In most cases
+    /// you actually want to use `metadata_schema_in`
+    pub fn metadata_schema(shard: &Shard) -> String {
+        format!("{}_subgraphs", Self::name(shard))
+    }
+
+    /// The name of the schema under which the `subgraphs` schema for
+    /// `shard` is accessible in the shard `current`. It is permissible for
+    /// `shard` and `current` to be the same.
+    pub fn metadata_schema_in(shard: &Shard, current: &Shard) -> String {
+        if shard == current {
+            "subgraphs".to_string()
+        } else {
+            Self::metadata_schema(shard)
+        }
+    }
+
+    pub fn new_from_raw(shard: String, postgres_url: &str) -> Result<Self, anyhow::Error> {
+        Self::new(Shard::new(shard)?, postgres_url)
+    }
+
+    pub fn new(shard: Shard, postgres_url: &str) -> Result<Self, anyhow::Error> {
+        let config: Config = match postgres_url.parse() {
+            Ok(config) => config,
+            Err(e) => panic!(
+                "failed to parse Postgres connection string `{}`: {}",
+                SafeDisplay(postgres_url),
+                e
+            ),
+        };
+
+        let host = match config.get_hosts().first() {
+            Some(Host::Tcp(host)) => host.to_string(),
+            _ => bail!("can not find host name in `{}`", SafeDisplay(postgres_url)),
+        };
+
+        let user = config
+            .get_user()
+            .ok_or_else(|| anyhow!("could not find user in `{}`", SafeDisplay(postgres_url)))?
+            .to_string();
+        let password = String::from_utf8(
+            config
+                .get_password()
+                .ok_or_else(|| {
+                    anyhow!(
+                        "could not find password in `{}`; you must provide one.",
+                        SafeDisplay(postgres_url)
+                    )
+                })?
+                .into(),
+        )?;
+        let port = config.get_ports().first().cloned().unwrap_or(5432u16);
+        let dbname = config
+            .get_dbname()
+            .map(|s| s.to_string())
+            .ok_or_else(|| anyhow!("could not find user in `{}`", SafeDisplay(postgres_url)))?;
+
+        Ok(Self {
+            name: Self::name(&shard),
+            shard,
+            user,
+            password,
+            host,
+            port,
+            dbname,
+        })
+    }
+
+    /// Create a new foreign server and user mapping on `conn` for this foreign
+    /// server
+    pub(super) async fn create(&self, conn: &mut AsyncPgConnection) -> Result<(), StoreError> {
+        let query = format!(
+            "\
+        create server \"{name}\"
+               foreign data wrapper postgres_fdw
+               options (host '{remote_host}', \
+                        port '{remote_port}', \
+                        dbname '{remote_db}', \
+                        fetch_size '{fetch_size}', \
+                        updatable 'false');
+        create user mapping
+               for current_user server \"{name}\"
+               options (user '{remote_user}', password '{remote_password}');",
+            name = self.name,
+            remote_host = self.host,
+            remote_port = self.port,
+            remote_db = self.dbname,
+            remote_user = self.user,
+            remote_password = self.password,
+            fetch_size = ENV_VARS.store.fdw_fetch_size,
+        );
+        Ok(conn.batch_execute(&query).await?)
+    }
+
+    /// Update an existing user mapping with possibly new details
+    pub(super) async fn update(&self, conn: &mut AsyncPgConnection) -> Result<(), StoreError> {
+        let options = catalog::server_options(conn, &self.name).await?;
+        let set_or_add = |option: &str| -> &'static str {
+            if options.contains_key(option) {
+                "set"
+            } else {
+                "add"
+            }
+        };
+
+        let query = format!(
+            "\
+        alter server \"{name}\"
+              options (set host '{remote_host}', \
+                       {set_port} port '{remote_port}', \
+                       set dbname '{remote_db}', \
+                       {set_fetch_size} fetch_size '{fetch_size}');
+        alter user mapping
+              for current_user server \"{name}\"
+              options (set user '{remote_user}', set password '{remote_password}');",
+            name = self.name,
+            remote_host = self.host,
+            set_port = set_or_add("port"),
+            set_fetch_size = set_or_add("fetch_size"),
+            remote_port = self.port,
+            remote_db = self.dbname,
+            remote_user = self.user,
+            remote_password = self.password,
+            fetch_size = ENV_VARS.store.fdw_fetch_size,
+        );
+        Ok(conn.batch_execute(&query).await?)
+    }
+
+    /// Map key tables from the primary into our local schema. If we are the
+    /// primary, set them up as views.
+    pub(super) async fn map_primary(
+        conn: &mut AsyncPgConnection,
+        shard: &Shard,
+    ) -> Result<(), StoreError> {
+        catalog::recreate_schema(conn, PRIMARY_PUBLIC).await?;
+
+        let mut query = String::new();
+        for table_name in PRIMARY_TABLES {
+            let create_stmt = if shard == &*PRIMARY_SHARD {
+                format!(
+                    "create view {nsp}.{table_name} as select * from public.{table_name};",
+                    nsp = PRIMARY_PUBLIC,
+                    table_name = table_name
+                )
+            } else {
+                catalog::create_foreign_table(
+                    conn,
+                    NAMESPACE_PUBLIC,
+                    table_name,
+                    PRIMARY_PUBLIC,
+                    Self::name(&PRIMARY_SHARD).as_str(),
+                )
+                .await?
+            };
+            write!(query, "{}", create_stmt)?;
+        }
+        conn.batch_execute(&query).await?;
+        Ok(())
+    }
+
+    /// Map the `subgraphs` schema from the foreign server `self` into the
+    /// database accessible through `conn`
+    pub(super) async fn map_metadata(
+        &self,
+        conn: &mut AsyncPgConnection,
+    ) -> Result<(), StoreError> {
+        let nsp = Self::metadata_schema(&self.shard);
+        catalog::recreate_schema(conn, &nsp).await?;
+        let mut query = String::new();
+        for (src_nsp, src_tables) in SHARDED_TABLES {
+            for src_table in src_tables {
+                let create_stmt =
+                    catalog::create_foreign_table(conn, src_nsp, src_table, &nsp, &self.name)
+                        .await?;
+                write!(query, "{}", create_stmt)?;
+            }
+        }
+        Ok(conn.batch_execute(&query).await?)
+    }
+
+    pub(super) async fn needs_remap(
+        &self,
+        conn: &mut AsyncPgConnection,
+    ) -> Result<bool, StoreError> {
+        fn different(mut existing: Vec<String>, mut needed: Vec<String>) -> bool {
+            existing.sort();
+            needed.sort();
+            existing != needed
+        }
+
+        if self.shard == *PRIMARY_SHARD {
+            let existing = catalog::foreign_tables(conn, PRIMARY_PUBLIC).await?;
+            let needed = PRIMARY_TABLES
+                .into_iter()
+                .map(String::from)
+                .collect::<Vec<_>>();
+            if different(existing, needed) {
+                return Ok(true);
+            }
+        }
+
+        let existing = catalog::foreign_tables(conn, &Self::metadata_schema(&self.shard)).await?;
+        let needed = SHARDED_TABLES
+            .iter()
+            .flat_map(|(_, tables)| *tables)
+            .map(|table| table.to_string())
+            .collect::<Vec<_>>();
+        Ok(different(existing, needed))
+    }
+}
diff --git a/store/postgres/src/pool/manager.rs b/store/postgres/src/pool/manager.rs
new file mode 100644
index 00000000000..5ff0198a36e
--- /dev/null
+++ b/store/postgres/src/pool/manager.rs
@@ -0,0 +1,366 @@
+//! Connection management for Postgres connection pools
+//!
+//! This module provides helpers for collecting metrics for a pool and
+//! tracking availability of the underlying database
+
+use deadpool::managed::{Hook, RecycleError, RecycleResult};
+use diesel::IntoSql;
+
+use diesel_async::pooled_connection::{PoolError as DieselPoolError, PoolableConnection};
+use diesel_async::{AsyncConnection, RunQueryDsl};
+use graph::env::ENV_VARS;
+use graph::prelude::AtomicMovingStats;
+use graph::prelude::Counter;
+use graph::prelude::Gauge;
+use graph::prelude::MetricsRegistry;
+use graph::prelude::PoolWaitStats;
+use graph::prelude::error;
+use graph::slog::Logger;
+use graph::slog::info;
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+
+use crate::pool::AsyncPool;
+
+/// Our own connection manager. It is pretty much the same as
+/// `AsyncDieselConnectionManager` but makes it easier to instrument and
+/// track connection errors
+#[derive(Clone)]
+pub struct ConnectionManager {
+    logger: Logger,
+    connection_url: String,
+    state_tracker: StateTracker,
+    error_counter: Counter,
+    /// Connections idle for less than this threshold skip the SELECT 67 health check
+    validation_idle_threshold: Duration,
+}
+
+impl ConnectionManager {
+    pub(super) fn new(
+        logger: Logger,
+        connection_url: String,
+        state_tracker: StateTracker,
+        registry: &MetricsRegistry,
+        const_labels: HashMap<String, String>,
+        validation_idle_threshold: Duration,
+    ) -> Self {
+        let error_counter = registry
+            .global_counter(
+                "store_connection_error_count",
+                "The number of Postgres connections errors",
+                const_labels,
+            )
+            .expect("failed to create `store_connection_error_count` counter");
+
+        Self {
+            logger,
+            connection_url,
+            state_tracker,
+            error_counter,
+            validation_idle_threshold,
+        }
+    }
+
+    fn handle_error(&self, error: &dyn std::error::Error) {
+        let msg = brief_error_msg(&error);
+
+        // Don't count canceling statements for timeouts etc. as a
+        // connection error. Unfortunately, we only have the textual error
+        // and need to infer whether the error indicates that the database
+        // is down or if something else happened. When querying a replica,
+        // these messages indicate that a query was canceled because it
+        // conflicted with replication, but does not indicate that there is
+        // a problem with the database itself.
+        //
+        // This check will break if users run Postgres (or even graph-node)
+        // in a locale other than English. In that case, their database will
+        // be marked as unavailable even though it is perfectly fine.
+        if msg.contains("canceling statement")
+            || msg.contains("terminating connection due to conflict with recovery")
+        {
+            return;
+        }
+
+        self.error_counter.inc();
+        if self.state_tracker.is_available() {
+            error!(self.logger, "Connection checkout"; "error" => msg);
+        }
+        self.state_tracker.mark_unavailable(Duration::from_secs(0));
+    }
+}
+
+impl deadpool::managed::Manager for ConnectionManager {
+    type Type = diesel_async::AsyncPgConnection;
+
+    type Error = DieselPoolError;
+
+    async fn create(&self) -> Result<Self::Type, Self::Error> {
+        let res = diesel_async::AsyncPgConnection::establish(&self.connection_url).await;
+        if let Err(ref e) = res {
+            self.handle_error(e);
+        }
+        res.map_err(DieselPoolError::ConnectionError)
+    }
+
+    async fn recycle(
+        &self,
+        obj: &mut Self::Type,
+        metrics: &deadpool::managed::Metrics,
+    ) -> RecycleResult<Self::Error> {
+        if std::thread::panicking() || obj.is_broken() {
+            return Err(RecycleError::Message("Broken connection".into()));
+        }
+
+        // Skip health check if connection was used recently
+        if self.validation_idle_threshold > Duration::ZERO
+            && metrics.last_used() < self.validation_idle_threshold
+        {
+            return Ok(());
+        }
+
+        // Run SELECT 67 only for idle connections
+        let res = diesel::select(67_i32.into_sql::<diesel::sql_types::Integer>())
+            .execute(obj)
+            .await
+            .map(|_| ());
+        if let Err(ref e) = res {
+            self.handle_error(e);
+        }
+        res.map_err(DieselPoolError::QueryError)?;
+        Ok(())
+    }
+}
+
+/// Track whether a database is available or not
+#[derive(Clone)]
+pub(super) struct StateTracker {
+    logger: Logger,
+    available: Arc<AtomicBool>,
+    ignore_timeout: Arc<AtomicBool>,
+    /// Timestamp (as millis since UNIX_EPOCH) when we can next probe.
+    /// 0 means available/no limit.
+    next_probe_at: Arc<AtomicU64>,
+}
+
+impl StateTracker {
+    pub(super) fn new(logger: Logger) -> Self {
+        Self {
+            logger,
+            available: Arc::new(AtomicBool::new(true)),
+            ignore_timeout: Arc::new(AtomicBool::new(false)),
+            next_probe_at: Arc::new(AtomicU64::new(0)),
+        }
+    }
+
+    pub(super) fn mark_available(&self) {
+        if !self.is_available() {
+            info!(self.logger, "Connection checkout"; "event" => "available");
+        }
+        self.available.store(true, Ordering::Relaxed);
+        self.next_probe_at.store(0, Ordering::Relaxed);
+    }
+
+    pub(super) fn mark_unavailable(&self, waited: Duration) {
+        if self.is_available() {
+            if waited.as_nanos() > 0 {
+                error!(self.logger, "Connection checkout timed out";
+                   "event" => "unavailable",
+                   "wait_ms" => waited.as_millis()
+                )
+            } else {
+                error!(self.logger, "Connection checkout"; "event" => "unavailable");
+            }
+        }
+        self.available.store(false, Ordering::Relaxed);
+
+        // Set next probe time
+        let retry_interval = ENV_VARS.store.connection_unavailable_retry.as_millis() as u64;
+        let next_probe = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_millis() as u64
+            + retry_interval;
+        self.next_probe_at.store(next_probe, Ordering::Relaxed);
+    }
+
+    pub(super) fn is_available(&self) -> bool {
+        if AtomicBool::load(&self.available, Ordering::Relaxed) {
+            return true;
+        }
+
+        // Allow one probe through every `connection_unavailable_retry` interval
+        let next_probe = AtomicU64::load(&self.next_probe_at, Ordering::Relaxed);
+        let now_millis = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_millis() as u64;
+
+        if now_millis >= next_probe {
+            // Try to claim this probe slot with CAS
+            let retry_interval = ENV_VARS.store.connection_unavailable_retry.as_millis() as u64;
+            if self
+                .next_probe_at
+                .compare_exchange(
+                    next_probe,
+                    now_millis + retry_interval,
+                    Ordering::Relaxed,
+                    Ordering::Relaxed,
+                )
+                .is_ok()
+            {
+                // We claimed the probe - allow this request through
+                return true;
+            }
+        }
+        false
+    }
+
+    pub(super) fn timeout_is_ignored(&self) -> bool {
+        AtomicBool::load(&self.ignore_timeout, Ordering::Relaxed)
+    }
+
+    /// Run the given async function while ignoring timeouts; if `f` causes
+    /// a timeout, the database is not marked as unavailable
+    pub(super) async fn ignore_timeout<F, R>(&self, f: F) -> R
+    where
+        F: AsyncFnOnce() -> R,
+    {
+        self.ignore_timeout.store(true, Ordering::Relaxed);
+        let res = f().await;
+        self.ignore_timeout.store(false, Ordering::Relaxed);
+        res
+    }
+
+    /// Return a deadpool hook that marks the database as available
+    pub(super) fn mark_available_hook(&self) -> Hook<ConnectionManager> {
+        let state_tracker = self.clone();
+        Hook::async_fn(move |_conn, _metrics| {
+            let state_tracker = state_tracker.clone();
+            Box::pin(async move {
+                state_tracker.mark_available();
+                Ok(())
+            })
+        })
+    }
+}
+
+fn brief_error_msg(error: &dyn std::error::Error) -> String {
+    // For 'Connection refused' errors, Postgres includes the IP and
+    // port number in the error message. We want to suppress that and
+    // only use the first line from the error message. For more detailed
+    // analysis, 'Connection refused' manifests as a
+    // `ConnectionError(BadConnection("could not connect to server:
+    // Connection refused.."))`
+    error
+        .to_string()
+        .split('\n')
+        .next()
+        .unwrap_or("no error details provided")
+        .to_string()
+}
+
+pub(crate) fn spawn_size_stat_collector(
+    pool: AsyncPool,
+    registry: &MetricsRegistry,
+    const_labels: HashMap<String, String>,
+) {
+    let count_gauge = registry
+        .global_gauge(
+            "store_connection_checkout_count",
+            "The number of Postgres connections currently checked out",
+            const_labels.clone(),
+        )
+        .expect("failed to create `store_connection_checkout_count` counter");
+    let size_gauge = registry
+        .global_gauge(
+            "store_connection_pool_size_count",
+            "Overall size of the connection pool",
+            const_labels,
+        )
+        .expect("failed to create `store_connection_pool_size_count` counter");
+    tokio::task::spawn(async move {
+        loop {
+            let status = pool.status();
+            count_gauge.set((status.size - status.available) as f64);
+            size_gauge.set(status.size as f64);
+            tokio::time::sleep(Duration::from_secs(15)).await;
+        }
+    });
+}
+
+/// Reap connections that are too old (older than 30 minutes) or if there
+/// are more than `connection_min_idle` connections in the pool that have
+/// been idle for longer than `idle_timeout`
+pub(crate) fn spawn_connection_reaper(
+    pool: AsyncPool,
+    idle_timeout: Duration,
+    wait_gauge: Option<Gauge>,
+) {
+    const MAX_LIFETIME: Duration = Duration::from_secs(30 * 60);
+    const CHECK_INTERVAL: Duration = Duration::from_secs(30);
+    let Some(min_idle) = ENV_VARS.store.connection_min_idle else {
+        // If this is None, we will never reap anything
+        return;
+    };
+    // What happens here isn't exactly what we would like to have: we would
+    // like to have at any point `min_idle` unused connections in the pool,
+    // but there is no way to achieve that with deadpool. Instead, we try to
+    // keep `min_idle` connections around if they exist
+    tokio::task::spawn(async move {
+        loop {
+            let mut idle_count = 0;
+            let mut last_used = Instant::now() - 2 * CHECK_INTERVAL;
+            pool.retain(|_, metrics| {
+                last_used = last_used.max(metrics.recycled.unwrap_or(metrics.created));
+                if metrics.age() > MAX_LIFETIME {
+                    return false;
+                }
+                if metrics.last_used() > idle_timeout {
+                    idle_count += 1;
+                    return idle_count <= min_idle;
+                }
+                true
+            });
+            if last_used.elapsed() > CHECK_INTERVAL {
+                // Reset wait time if there was no activity recently so that
+                // we don't report stale wait times
+                if let Some(wait_gauge) = wait_gauge.as_ref() {
+                    wait_gauge.set(0.0)
+                }
+            }
+            tokio::time::sleep(CHECK_INTERVAL).await;
+        }
+    });
+}
+
+pub(crate) struct WaitMeter {
+    pub(crate) wait_gauge: Gauge,
+    pub(crate) wait_stats: PoolWaitStats,
+}
+
+impl WaitMeter {
+    pub(crate) fn new(registry: &MetricsRegistry, const_labels: HashMap<String, String>) -> Self {
+        let wait_gauge = registry
+            .global_gauge(
+                "store_connection_wait_time_ms",
+                "Average connection wait time",
+                const_labels,
+            )
+            .expect("failed to create `store_connection_wait_time_ms` counter");
+        let wait_stats = Arc::new(AtomicMovingStats::default());
+
+        Self {
+            wait_gauge,
+            wait_stats,
+        }
+    }
+
+    pub(crate) fn add_conn_wait_time(&self, duration: Duration) {
+        self.wait_stats.add_and_register(duration, &self.wait_gauge);
+    }
+}
diff --git a/store/postgres/src/pool/mod.rs b/store/postgres/src/pool/mod.rs
new file mode 100644
index 00000000000..c479c2263a2
--- /dev/null
+++ b/store/postgres/src/pool/mod.rs
@@ -0,0 +1,1143 @@
+use deadpool::Runtime;
+use deadpool::managed::{PoolError, Timeouts};
+use diesel::sql_query;
+use diesel_async::async_connection_wrapper::AsyncConnectionWrapper;
+use diesel_async::{AsyncConnection as _, RunQueryDsl, SimpleAsyncConnection};
+use diesel_migrations::{EmbeddedMigrations, HarnessWithOutput};
+
+use graph::cheap_clone::CheapClone;
+use graph::components::store::QueryPermit;
+use graph::derive::CheapClone;
+use graph::internal_error;
+use graph::prelude::tokio::time::Instant;
+use graph::prelude::{
+    AtomicMovingStats, ENV_VARS, Gauge, Logger, PoolWaitStats, StoreError, anyhow::anyhow, crit,
+    debug, error, info, o,
+};
+use graph::prelude::{MetricsRegistry, tokio};
+use graph::slog::warn;
+use graph::util::timed_rw_lock::TimedMutex;
+use tokio::sync::OwnedSemaphorePermit;
+
+use std::collections::HashMap;
+use std::fmt::{self};
+use std::future::Future;
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+use std::time::Duration;
+
+use crate::catalog;
+use crate::pool::manager::{ConnectionManager, WaitMeter};
+use crate::primary::{self, Mirror, Namespace};
+use crate::{PRIMARY_SHARD, Shard};
+
+/// A helper trait that names the future type returned by an async closure.
+/// This is the local equivalent of `diesel_async::transaction_manager::AsyncFunc`,
+/// which is not a public API. Adding the `Fut: Send` bound on this trait in
+/// function signatures allows the compiler to prove that the futures produced
+/// by async closures are `Send`, preventing "Send not general enough" errors
+/// that arise when using plain `for<'r> F: AsyncFnOnce(...)` bounds.
+pub trait AsyncFunc<T, R>:
+    AsyncFnOnce(T) -> R + FnOnce(T) -> <Self as AsyncFunc<T, R>>::Fut
+{
+    type Fut: Future<Output = R>;
+}
+
+impl<F, T, Fut, R> AsyncFunc<T, R> for F
+where
+    F: AsyncFnOnce(T) -> R + FnOnce(T) -> Fut,
+    Fut: Future<Output = R>,
+{
+    type Fut = Fut;
+}
+
+pub trait AsyncMutFunc<T, R>:
+    AsyncFnMut(T) -> R + FnMut(T) -> <Self as AsyncMutFunc<T, R>>::Fut
+{
+    type Fut: Future<Output = R>;
+}
+
+impl<F, T, Fut, R> AsyncMutFunc<T, R> for F
+where
+    F: AsyncFnMut(T) -> R + FnMut(T) -> Fut,
+    Fut: Future<Output = R>,
+{
+    type Fut = Fut;
+}
+
+/// Shorthand for an async closure that may be used as a transaction
+/// callback in our own `fn transaction` implementations in a few places.
+pub(crate) trait TxnCallback<R, E, C = AsyncPgConnection>:
+    for<'r> AsyncFunc<&'r mut C, Result<R, E>, Fut: Send> + Send
+{
+}
+
+impl<F, C, R, E> TxnCallback<R, E, C> for F where
+    F: for<'r> AsyncFunc<&'r mut C, Result<R, E>, Fut: Send> + Send
+{
+}
+
+pub(crate) trait TxnMutCallback<R, E, C = AsyncPgConnection>:
+    for<'r> AsyncMutFunc<&'r mut C, Result<R, E>, Fut: Send> + Send
+{
+}
+
+impl<F, C, R, E> TxnMutCallback<R, E, C> for F where
+    F: for<'r> AsyncMutFunc<&'r mut C, Result<R, E>, Fut: Send> + Send
+{
+}
+
+mod coordinator;
+mod foreign_server;
+mod manager;
+
+pub use coordinator::PoolCoordinator;
+pub use foreign_server::ForeignServer;
+use manager::StateTracker;
+
+type AsyncPool = deadpool::managed::Pool<ConnectionManager>;
+/// A database connection for asynchronous diesel operations
+pub type AsyncPgConnection = deadpool::managed::Object<ConnectionManager>;
+
+/// A database connection bundled with a semaphore permit.
+/// The permit is held for the lifetime of the connection, providing
+/// backpressure to prevent pool exhaustion during mass operations.
+pub struct PermittedConnection {
+    conn: AsyncPgConnection,
+    _permit: OwnedSemaphorePermit,
+}
+
+impl Deref for PermittedConnection {
+    type Target = AsyncPgConnection;
+    fn deref(&self) -> &Self::Target {
+        &self.conn
+    }
+}
+
+impl DerefMut for PermittedConnection {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.conn
+    }
+}
+
+impl PermittedConnection {
+    /// Build a transaction with custom isolation level and read mode.
+    ///
+    /// This is analogous to `diesel_async::pg::TransactionBuilder` but
+    /// works with the pool-wrapped connection type. The closure receives
+    /// `&mut AsyncPgConnection`, the inner connection, so it can be passed
+    /// directly to functions that take `&mut AsyncPgConnection`.
+    pub(crate) fn build_transaction(&mut self) -> TransactionBuilder<'_> {
+        TransactionBuilder::new(self)
+    }
+
+    /// Run `callback` inside a transaction on this connection. Commits on
+    /// `Ok`, rolls back on `Err`. The callback receives `&mut PermittedConnection`;
+    /// pass it to functions needing `&mut AsyncPgConnection` via deref coercion.
+    pub(crate) fn transaction<'a, 'conn, R, E, F>(
+        &'conn mut self,
+        callback: F,
+    ) -> impl Future<Output = Result<R, E>> + Send + 'conn
+    where
+        F: TxnCallback<R, E> + 'a,
+        E: From<diesel::result::Error> + Send + 'a,
+        R: Send + 'a,
+        'a: 'conn,
+    {
+        self.conn.transaction(callback)
+    }
+}
+
+/// Builder for a PostgreSQL transaction with configurable isolation level
+/// and read mode. Created via [`PermittedConnection::build_transaction`].
+///
+/// We can't use diesel-async's `TransactionBuilder` because it requires
+/// `C: AsyncConnection<TransactionManager = AnsiTransactionManager>`. Our
+/// connection types don't satisfy that: the blanket deref impl in
+/// diesel-async wraps the transaction manager at each deref level, so
+/// `Object<ConnectionManager>` gets `PoolTransactionManager<AnsiTransactionManager>`
+/// and `PermittedConnection` gets
+/// `PoolTransactionManager<PoolTransactionManager<AnsiTransactionManager>>`.
+/// Neither matches `AnsiTransactionManager`.
+#[must_use = "Transaction builder does nothing unless you call `run` on it"]
+pub(crate) struct TransactionBuilder<'a> {
+    conn: &'a mut PermittedConnection,
+    isolation_level: Option<&'static str>,
+    read_only: bool,
+}
+
+impl<'a> TransactionBuilder<'a> {
+    fn new(conn: &'a mut PermittedConnection) -> Self {
+        Self {
+            conn,
+            isolation_level: None,
+            read_only: false,
+        }
+    }
+
+    /// Set the transaction isolation level to `REPEATABLE READ`.
+    pub(crate) fn repeatable_read(mut self) -> Self {
+        self.isolation_level = Some("REPEATABLE READ");
+        self
+    }
+
+    /// Make the transaction `READ ONLY`.
+    pub(crate) fn read_only(mut self) -> Self {
+        self.read_only = true;
+        self
+    }
+
+    /// Execute `f` inside the configured transaction. Commits on `Ok`,
+    /// rolls back on `Err`. The callback receives `&mut PermittedConnection`;
+    /// pass it to functions needing `&mut AsyncPgConnection` via deref coercion.
+    pub(crate) async fn run<T, E, F>(self, f: F) -> Result<T, E>
+    where
+        F: TxnCallback<T, E>,
+        E: From<diesel::result::Error>,
+    {
+        let mut sql = String::from("BEGIN TRANSACTION");
+        if let Some(level) = self.isolation_level {
+            sql.push_str(" ISOLATION LEVEL ");
+            sql.push_str(level);
+        }
+        if self.read_only {
+            sql.push_str(" READ ONLY");
+        }
+        self.conn.batch_execute(&sql).await?;
+        match f(self.conn).await {
+            Ok(value) => {
+                self.conn.batch_execute("COMMIT").await?;
+                Ok(value)
+            }
+            Err(e) => {
+                self.conn.batch_execute("ROLLBACK").await.ok();
+                Err(e)
+            }
+        }
+    }
+}
+
+/// The namespace under which the `PRIMARY_TABLES` are mapped into each
+/// shard
+pub(crate) const PRIMARY_PUBLIC: &str = "primary_public";
+
+/// Tables that we map from the primary into `primary_public` in each shard
+const PRIMARY_TABLES: [&str; 3] = ["deployment_schemas", "chains", "active_copies"];
+
+/// The namespace under which we create views in the primary that union all
+/// the `SHARDED_TABLES`
+pub(crate) const CROSS_SHARD_NSP: &str = "sharded";
+
+/// Tables that we map from each shard into each other shard into the
+/// `shard_<name>_subgraphs` namespace
+const SHARDED_TABLES: [(&str, &[&str]); 2] = [
+    ("public", &["ethereum_networks"]),
+    (
+        "subgraphs",
+        &[
+            "copy_state",
+            "copy_table_state",
+            "dynamic_ethereum_contract_data_source",
+            "head",
+            "deployment",
+            "subgraph_error",
+            "subgraph_manifest",
+            "table_stats",
+            "subgraph",
+            "subgraph_version",
+            "subgraph_deployment_assignment",
+            "prune_state",
+            "prune_table_state",
+        ],
+    ),
+];
+
+/// Make sure that the tables that `jobs::MirrorJob` wants to mirror are
+/// actually mapped into the various shards. A failure here is simply a
+/// coding mistake
+fn check_mirrored_tables() {
+    for table in Mirror::PUBLIC_TABLES {
+        if !PRIMARY_TABLES.contains(&table) {
+            panic!("table {} is not in PRIMARY_TABLES", table);
+        }
+    }
+
+    let subgraphs_tables = *SHARDED_TABLES
+        .iter()
+        .find(|(nsp, _)| *nsp == "subgraphs")
+        .map(|(_, tables)| tables)
+        .unwrap();
+
+    for table in Mirror::SUBGRAPHS_TABLES {
+        if !subgraphs_tables.contains(&table) {
+            panic!("table {} is not in SHARDED_TABLES[subgraphs]", table);
+        }
+    }
+}
+
+/// How long to keep connections in the `fdw_pool` around before closing
+/// them on idle. This is much shorter than the default of 10 minutes.
+const FDW_IDLE_TIMEOUT: Duration = Duration::from_secs(60);
+
+enum PoolStateInner {
+    /// A connection pool, and all the servers for which we need to
+    /// establish fdw mappings when we call `setup` on the pool
+    Created(Arc<PoolInner>, Arc<PoolCoordinator>),
+    /// The pool has been successfully set up
+    Ready(Arc<PoolInner>),
+}
+
+/// A pool goes through several states, and this struct tracks what state we
+/// are in, together with the `state_tracker` field on `ConnectionPool`.
+/// When first created, the pool is in state `Created`; once we successfully
+/// called `setup` on it, it moves to state `Ready`. During use, we use the
+/// r2d2 callbacks to determine if the database is available or not, and set
+/// the `available` field accordingly. Tracking that allows us to fail fast
+/// and avoids having to wait for a connection timeout every time we need a
+/// database connection. That avoids overall undesirable states like buildup
+/// of queries; instead of queueing them until the database is available,
+/// they return almost immediately with an error
+#[derive(Clone, CheapClone)]
+pub(super) struct PoolState {
+    logger: Logger,
+    inner: Arc<TimedMutex<PoolStateInner>>,
+}
+
+impl PoolState {
+    fn new(logger: Logger, inner: PoolStateInner, name: String) -> Self {
+        let pool_name = format!("pool-{}", name);
+        Self {
+            logger,
+            inner: Arc::new(TimedMutex::new(inner, pool_name)),
+        }
+    }
+
+    fn created(pool: Arc<PoolInner>, coord: Arc<PoolCoordinator>) -> Self {
+        let logger = pool.logger.clone();
+        let name = pool.shard.to_string();
+        let inner = PoolStateInner::Created(pool, coord);
+        Self::new(logger, inner, name)
+    }
+
+    fn ready(pool: Arc<PoolInner>) -> Self {
+        let logger = pool.logger.clone();
+        let name = pool.shard.to_string();
+        let inner = PoolStateInner::Ready(pool);
+        Self::new(logger, inner, name)
+    }
+
+    fn set_ready(&self) {
+        use PoolStateInner::*;
+
+        let mut guard = self.inner.lock(&self.logger);
+        match &*guard {
+            Created(pool, _) => *guard = Ready(pool.clone()),
+            Ready(_) => { /* nothing to do */ }
+        }
+    }
+
+    /// Get a connection pool that is ready, i.e., has been through setup
+    /// and running migrations
+    fn get_ready(&self) -> Result<Arc<PoolInner>, StoreError> {
+        // We have to be careful here that we do not hold a lock when we
+        // call `setup_bg`, otherwise we will deadlock
+        let (pool, coord) = {
+            let guard = self.inner.lock(&self.logger);
+
+            use PoolStateInner::*;
+            match &*guard {
+                Created(pool, coord) => (pool.cheap_clone(), coord.cheap_clone()),
+                Ready(pool) => return Ok(pool.clone()),
+            }
+        };
+
+        // self is `Created` and needs to have setup run
+        coord.setup_bg(self.cheap_clone())?;
+
+        // We just tried to set up the pool; if it is still not set up and
+        // we didn't have an error, it means the database is not available
+        if self.needs_setup() {
+            error!(self.logger, "Database is not available, setup did not work");
+            Err(StoreError::DatabaseUnavailable)
+        } else {
+            Ok(pool)
+        }
+    }
+
+    /// Get the inner pool, regardless of whether it has been set up or not.
+    /// Most uses should use `get_ready` instead
+    fn get_unready(&self) -> Arc<PoolInner> {
+        use PoolStateInner::*;
+
+        match &*self.inner.lock(&self.logger) {
+            Created(pool, _) | Ready(pool) => pool.cheap_clone(),
+        }
+    }
+
+    fn needs_setup(&self) -> bool {
+        let guard = self.inner.lock(&self.logger);
+
+        use PoolStateInner::*;
+        match &*guard {
+            Created(_, _) => true,
+            Ready(_) => false,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct ConnectionPool {
+    inner: PoolState,
+    pub shard: Shard,
+    state_tracker: StateTracker,
+}
+
+impl fmt::Debug for ConnectionPool {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ConnectionPool")
+            .field("shard", &self.shard)
+            .finish()
+    }
+}
+
+/// The role of the pool, mostly for logging, and what purpose it serves.
+/// The main pool will always be called `main`, and can be used for reading
+/// and writing. Replica pools can only be used for reading, and don't
+/// require any setup (migrations etc.)
+pub enum PoolRole {
+    Main,
+    Replica(String),
+}
+
+impl PoolRole {
+    fn as_str(&self) -> &str {
+        match self {
+            PoolRole::Main => "main",
+            PoolRole::Replica(name) => name,
+        }
+    }
+
+    fn is_replica(&self) -> bool {
+        match self {
+            PoolRole::Main => false,
+            PoolRole::Replica(_) => true,
+        }
+    }
+}
+
+impl ConnectionPool {
+    fn create(
+        shard_name: &str,
+        pool_name: PoolRole,
+        postgres_url: String,
+        pool_size: u32,
+        fdw_pool_size: Option<u32>,
+        logger: &Logger,
+        registry: Arc<MetricsRegistry>,
+        coord: Arc<PoolCoordinator>,
+    ) -> ConnectionPool {
+        let shard =
+            Shard::new(shard_name.to_string()).expect("shard_name is a valid name for a shard");
+        let (inner, state_tracker) = {
+            let pool = PoolInner::create(
+                shard.clone(),
+                pool_name.as_str(),
+                postgres_url,
+                pool_size,
+                fdw_pool_size,
+                logger,
+                registry,
+            );
+            let state_tracker = pool.state_tracker.clone();
+            if pool_name.is_replica() {
+                (PoolState::ready(Arc::new(pool)), state_tracker)
+            } else {
+                (PoolState::created(Arc::new(pool), coord), state_tracker)
+            }
+        };
+        ConnectionPool {
+            inner,
+            shard,
+            state_tracker,
+        }
+    }
+
+    /// This is only used for `graphman` to ensure it doesn't run migrations
+    /// or other setup steps
+    pub fn skip_setup(&self) {
+        self.inner.set_ready();
+    }
+
+    /// Return a pool that is ready, i.e., connected to the database. If the
+    /// pool has not been set up yet, call `setup`. If there are any errors
+    /// or the pool is marked as unavailable, return
+    /// `StoreError::DatabaseUnavailable`
+    fn get_ready(&self) -> Result<Arc<PoolInner>, StoreError> {
+        if !self.state_tracker.is_available() {
+            // We know that trying to use this pool is pointless since the
+            // database is not available, and will only lead to other
+            // operations having to wait until the connection timeout is
+            // reached.
+            return Err(StoreError::DatabaseUnavailable);
+        }
+
+        match self.inner.get_ready() {
+            Ok(pool) => {
+                self.state_tracker.mark_available();
+                Ok(pool)
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    pub async fn get(&self) -> Result<AsyncPgConnection, StoreError> {
+        self.get_ready()?.get().await
+    }
+
+    /// Get a connection with backpressure via semaphore permit. Use this
+    /// for indexing operations to prevent pool exhaustion. This method will
+    /// wait indefinitely until a permit, and with that, a connection is
+    /// available.
+    pub async fn get_permitted(&self) -> Result<PermittedConnection, StoreError> {
+        self.get_ready()?.get_permitted().await
+    }
+
+    /// Get a connection from the pool for foreign data wrapper access;
+    /// since that pool can be very contended, periodically log that we are
+    /// still waiting for a connection
+    ///
+    /// The `timeout` is called every time we time out waiting for a
+    /// connection. If `timeout` returns `true`, `get_fdw` returns with that
+    /// error, otherwise we try again to get a connection.
+    pub async fn get_fdw<F>(
+        &self,
+        logger: &Logger,
+        timeout: F,
+    ) -> Result<AsyncPgConnection, StoreError>
+    where
+        F: FnMut() -> bool,
+    {
+        self.get_ready()?.get_fdw(logger, timeout).await
+    }
+
+    /// Get a connection from the pool for foreign data wrapper access if
+    /// one is available
+    pub async fn try_get_fdw(
+        &self,
+        logger: &Logger,
+        timeout: Duration,
+    ) -> Option<AsyncPgConnection> {
+        let Ok(inner) = self.get_ready() else {
+            return None;
+        };
+        self.state_tracker
+            .ignore_timeout(|| inner.try_get_fdw(logger, timeout))
+            .await
+    }
+
+    pub(crate) async fn query_permit(&self) -> QueryPermit {
+        let pool = self.inner.get_unready();
+        let start = Instant::now();
+        let permit = pool.query_permit().await;
+        QueryPermit {
+            permit,
+            wait: start.elapsed(),
+        }
+    }
+
+    pub(crate) fn wait_stats(&self) -> PoolWaitStats {
+        self.inner.get_unready().wait_meter.wait_stats.cheap_clone()
+    }
+
+    /// Mirror key tables from the primary into our own schema. We do this
+    /// by manually inserting or deleting rows through comparing it with the
+    /// table on the primary. Once we drop support for PG 9.6, we can
+    /// simplify all this and achieve the same result with logical
+    /// replication.
+    pub(crate) async fn mirror_primary_tables(&self) -> Result<(), StoreError> {
+        let pool = self.get_ready()?;
+        pool.mirror_primary_tables().await
+    }
+}
+
+pub struct PoolInner {
+    logger: Logger,
+    pub shard: Shard,
+    pool: AsyncPool,
+    // A separate pool for connections that will use foreign data wrappers.
+    // Once such a connection accesses a foreign table, Postgres keeps a
+    // connection to the foreign server until the connection is closed.
+    // Normal pooled connections live quite long (up to 10 minutes) and can
+    // therefore keep a lot of connections into foreign databases open. We
+    // mitigate this by using a separate small pool with a much shorter
+    // connection lifetime. Starting with postgres_fdw 1.1 in Postgres 14,
+    // this will no longer be needed since it will then be possible to
+    // explicitly close connections to foreign servers when a connection is
+    // returned to the pool.
+    fdw_pool: Option<AsyncPool>,
+    postgres_url: String,
+    /// Measures how long we spend getting connections from the main `pool`
+    wait_meter: WaitMeter,
+    state_tracker: StateTracker,
+
+    // Limits the number of graphql queries that may execute concurrently. Since one graphql query
+    // may require multiple DB queries, it is useful to organize the queue at the graphql level so
+    // that waiting queries consume few resources. Still this is placed here because the semaphore
+    // is sized acording to the DB connection pool size.
+    query_semaphore: Arc<tokio::sync::Semaphore>,
+    semaphore_wait_stats: Arc<AtomicMovingStats>,
+    semaphore_wait_gauge: Box<Gauge>,
+
+    // Limits concurrent indexing operations to prevent pool exhaustion
+    // during mass subgraph startup or high write load. Provides
+    // backpressure similar to the old `with_conn` limiter that was removed
+    // during diesel-async migration. It also avoids timeouts because of
+    // pool exhaustion when getting a connection.
+    indexing_semaphore: Arc<tokio::sync::Semaphore>,
+    indexing_semaphore_wait_stats: Arc<AtomicMovingStats>,
+    indexing_semaphore_wait_gauge: Box<Gauge>,
+}
+
+impl PoolInner {
+    fn create(
+        shard: Shard,
+        pool_name: &str,
+        postgres_url: String,
+        pool_size: u32,
+        fdw_pool_size: Option<u32>,
+        logger: &Logger,
+        registry: Arc<MetricsRegistry>,
+    ) -> PoolInner {
+        check_mirrored_tables();
+
+        let logger_store = logger.new(o!("component" => "Store"));
+        let logger_pool = logger.new(o!("component" => "ConnectionPool"));
+        let const_labels = {
+            let mut map = HashMap::new();
+            map.insert("pool".to_owned(), pool_name.to_owned());
+            map.insert("shard".to_string(), shard.to_string());
+            map
+        };
+
+        let state_tracker = StateTracker::new(logger_pool.cheap_clone());
+
+        // Connect to Postgres
+        let conn_manager = ConnectionManager::new(
+            logger_pool.clone(),
+            postgres_url.clone(),
+            state_tracker.clone(),
+            &registry,
+            const_labels.clone(),
+            ENV_VARS.store.connection_validation_idle_secs,
+        );
+
+        let timeouts = Timeouts {
+            wait: Some(ENV_VARS.store.connection_timeout),
+            create: Some(ENV_VARS.store.connection_timeout),
+            recycle: Some(ENV_VARS.store.connection_timeout),
+        };
+
+        // The post_create and post_recycle hooks are only called when
+        // create and recycle succeed; we can therefore mark the pool
+        // available
+        let pool = AsyncPool::builder(conn_manager.clone())
+            .max_size(pool_size as usize)
+            .timeouts(timeouts)
+            .runtime(Runtime::Tokio1)
+            .post_create(state_tracker.mark_available_hook())
+            .post_recycle(state_tracker.mark_available_hook())
+            .build()
+            .expect("failed to create connection pool");
+
+        manager::spawn_size_stat_collector(pool.clone(), &registry, const_labels.clone());
+
+        let wait_meter = WaitMeter::new(&registry, const_labels.clone());
+
+        manager::spawn_connection_reaper(
+            pool.clone(),
+            ENV_VARS.store.connection_idle_timeout,
+            Some(wait_meter.wait_gauge.clone()),
+        );
+
+        let fdw_pool = fdw_pool_size.map(|pool_size| {
+            let fdw_timeouts = Timeouts {
+                wait: Some(ENV_VARS.store.connection_timeout),
+                create: None,
+                recycle: Some(FDW_IDLE_TIMEOUT),
+            };
+
+            let fdw_pool = AsyncPool::builder(conn_manager)
+                .max_size(pool_size as usize)
+                .timeouts(fdw_timeouts)
+                .runtime(Runtime::Tokio1)
+                .post_create(state_tracker.mark_available_hook())
+                .post_recycle(state_tracker.mark_available_hook())
+                .build()
+                .expect("failed to create fdw connection pool");
+
+            manager::spawn_connection_reaper(fdw_pool.clone(), FDW_IDLE_TIMEOUT, None);
+            fdw_pool
+        });
+
+        info!(logger_store, "Pool successfully connected to Postgres");
+
+        let max_concurrent_queries = pool_size as usize + ENV_VARS.store.extra_query_permits;
+
+        // Query semaphore for GraphQL queries
+        let semaphore_wait_gauge = registry
+            .new_gauge(
+                "query_semaphore_wait_ms",
+                "Moving average of time spent on waiting for postgres query semaphore",
+                const_labels.clone(),
+            )
+            .expect("failed to create `query_effort_ms` counter");
+        let query_semaphore = Arc::new(tokio::sync::Semaphore::new(max_concurrent_queries));
+
+        // Semaphore for getting PermittedConnection
+        let indexing_semaphore_wait_gauge = registry
+            .new_gauge(
+                "store_semaphore_wait_ms",
+                "Moving average of time spent waiting for connection semaphore",
+                const_labels,
+            )
+            .expect("failed to create store_semaphore_wait_ms gauge");
+        let indexing_semaphore = Arc::new(tokio::sync::Semaphore::new(max_concurrent_queries));
+
+        PoolInner {
+            logger: logger_pool,
+            shard,
+            postgres_url,
+            pool,
+            fdw_pool,
+            wait_meter,
+            state_tracker,
+            semaphore_wait_stats: Arc::new(AtomicMovingStats::default()),
+            query_semaphore,
+            semaphore_wait_gauge,
+            indexing_semaphore,
+            indexing_semaphore_wait_stats: Arc::new(AtomicMovingStats::default()),
+            indexing_semaphore_wait_gauge,
+        }
+    }
+
+    /// Helper so that getting a connection from the main pool and the
+    /// fdw_pool collect the same metrics.
+    ///
+    /// If `timeouts` is `None`, the default pool timeouts are used.
+    ///
+    /// The `prev_wait` duration is the time already spent waiting for a
+    /// permit to get a connection; that time is added to the total wait
+    /// time recorded.
+    ///
+    /// On error, returns `StoreError::DatabaseUnavailable` and marks the
+    /// pool as unavailable if we can tell that the error is due to the pool
+    /// being closed. Returns `StoreError::StatementTimeout` if the error is
+    /// due to a timeout.
+    async fn get_from_pool(
+        &self,
+        pool: &AsyncPool,
+        timeouts: Option<Timeouts>,
+        prev_wait: Duration,
+    ) -> Result<AsyncPgConnection, StoreError> {
+        let start = Instant::now();
+        let res = match timeouts {
+            Some(timeouts) => pool.timeout_get(&timeouts).await,
+            None => pool.get().await,
+        };
+        let elapsed = start.elapsed() + prev_wait;
+        self.wait_meter.add_conn_wait_time(elapsed);
+        match res {
+            Ok(conn) => {
+                self.state_tracker.mark_available();
+                Ok(conn)
+            }
+            Err(PoolError::Closed) | Err(PoolError::Backend(_)) => {
+                self.state_tracker.mark_unavailable(Duration::from_nanos(0));
+                Err(StoreError::DatabaseUnavailable)
+            }
+            Err(PoolError::Timeout(_)) => {
+                if !self.state_tracker.timeout_is_ignored() {
+                    self.state_tracker.mark_unavailable(elapsed);
+                }
+                Err(StoreError::StatementTimeout)
+            }
+            Err(PoolError::NoRuntimeSpecified) | Err(PoolError::PostCreateHook(_)) => {
+                let e = res.err().unwrap();
+                unreachable!("impossible error {e}");
+            }
+        }
+    }
+
+    async fn get(&self) -> Result<AsyncPgConnection, StoreError> {
+        self.get_from_pool(&self.pool, None, Duration::ZERO).await
+    }
+
+    /// Get a connection using the setup timeout. Use only during database
+    /// initialization where operations can legitimately take longer.
+    async fn get_for_setup(&self) -> Result<AsyncPgConnection, StoreError> {
+        let setup_timeouts = Timeouts {
+            wait: Some(ENV_VARS.store.setup_timeout),
+            create: Some(ENV_VARS.store.setup_timeout),
+            recycle: Some(ENV_VARS.store.setup_timeout),
+        };
+        self.get_from_pool(&self.pool, Some(setup_timeouts), Duration::ZERO)
+            .await
+    }
+
+    /// Get the pool for fdw connections. It is an error if none is configured
+    fn fdw_pool(&self, logger: &Logger) -> Result<&AsyncPool, StoreError> {
+        let pool = match &self.fdw_pool {
+            Some(pool) => pool,
+            None => {
+                const MSG: &str =
+                    "internal error: trying to get fdw connection on a pool that doesn't have any";
+                error!(logger, "{}", MSG);
+                return Err(internal_error!(MSG));
+            }
+        };
+        Ok(pool)
+    }
+
+    /// Get a connection from the pool for foreign data wrapper access;
+    /// since that pool can be very contended, periodically log that we are
+    /// still waiting for a connection
+    ///
+    /// The `timeout` is called every time we time out waiting for a
+    /// connection. If `timeout` returns `true`, `get_fdw` returns with that
+    /// error, otherwise we try again to get a connection.
+    async fn get_fdw<F>(
+        &self,
+        logger: &Logger,
+        mut timeout: F,
+    ) -> Result<AsyncPgConnection, StoreError>
+    where
+        F: FnMut() -> bool,
+    {
+        let pool = self.fdw_pool(logger)?;
+        loop {
+            match self.get_from_pool(pool, None, Duration::ZERO).await {
+                Ok(conn) => return Ok(conn),
+                Err(e) => {
+                    if timeout() {
+                        return Err(anyhow!("timeout in get_fdw: {e}").into());
+                    }
+                }
+            }
+        }
+    }
+
+    /// Get a connection from the fdw pool if one is available. We wait for
+    /// `timeout` for a connection which should be set just big enough to
+    /// allow establishing a connection
+    async fn try_get_fdw(&self, logger: &Logger, timeout: Duration) -> Option<AsyncPgConnection> {
+        // Any error trying to get a connection is treated as "couldn't get
+        // a connection in time". If there is a serious error with the
+        // database, e.g., because it's not available, the next database
+        // operation will run into it and report it.
+        let Ok(fdw_pool) = self.fdw_pool(logger) else {
+            return None;
+        };
+        let timeouts = Timeouts {
+            wait: Some(timeout),
+            create: None,
+            recycle: None,
+        };
+        let Ok(conn) = self
+            .get_from_pool(fdw_pool, Some(timeouts), Duration::ZERO)
+            .await
+        else {
+            return None;
+        };
+        Some(conn)
+    }
+
+    pub fn connection_detail(&self) -> Result<ForeignServer, StoreError> {
+        ForeignServer::new(self.shard.clone(), &self.postgres_url).map_err(|e| e.into())
+    }
+
+    /// Check that we can connect to the database
+    pub async fn check(&self) -> bool {
+        let Ok(mut conn) = self.get().await else {
+            return false;
+        };
+
+        sql_query("select 1").execute(&mut conn).await.is_ok()
+    }
+
+    async fn locale_check(&self, logger: &Logger) -> Result<(), StoreError> {
+        let mut conn = self.get_for_setup().await?;
+        let _: () = if let Err(msg) = catalog::Locale::load(&mut conn).await?.suitable() {
+            if self.shard == *PRIMARY_SHARD && primary::is_empty(&mut conn).await? {
+                const MSG: &str = "Database does not use C locale. \
+                Please check the graph-node documentation for how to set up the database locale";
+
+                crit!(logger, "{}: {}", MSG, msg);
+                panic!("{}: {}", MSG, msg);
+            } else {
+                warn!(
+                    logger,
+                    "{}.\nPlease check the graph-node documentation for how to set up the database locale",
+                    msg
+                );
+            }
+        };
+        Ok(())
+    }
+
+    pub(crate) async fn query_permit(&self) -> OwnedSemaphorePermit {
+        let start = Instant::now();
+        let permit = self.query_semaphore.cheap_clone().acquire_owned().await;
+        self.semaphore_wait_stats
+            .add_and_register(start.elapsed(), &self.semaphore_wait_gauge);
+        permit.unwrap()
+    }
+
+    /// Acquire a permit for indexing operations. This provides backpressure
+    /// to prevent connection pool exhaustion during mass subgraph startup
+    /// or high write load.
+    async fn indexing_permit(&self) -> (OwnedSemaphorePermit, Duration) {
+        let start = Instant::now();
+        let permit = self.indexing_semaphore.cheap_clone().acquire_owned().await;
+        let elapsed = start.elapsed();
+        self.indexing_semaphore_wait_stats
+            .add_and_register(elapsed, &self.indexing_semaphore_wait_gauge);
+        (permit.unwrap(), elapsed)
+    }
+
+    /// Get a connection with backpressure via semaphore permit. Use this
+    /// for indexing operations to prevent pool exhaustion. This method will
+    /// wait indefinitely until a permit, and with that, a connection is
+    /// available.
+    pub(crate) async fn get_permitted(&self) -> Result<PermittedConnection, StoreError> {
+        let (permit, permit_wait) = self.indexing_permit().await;
+        let conn = self.get_from_pool(&self.pool, None, permit_wait).await?;
+        Ok(PermittedConnection {
+            conn,
+            _permit: permit,
+        })
+    }
+
+    async fn configure_fdw(&self, servers: &[ForeignServer]) -> Result<(), StoreError> {
+        info!(&self.logger, "Setting up fdw");
+        let mut conn = self.get_for_setup().await?;
+        conn.batch_execute("create extension if not exists postgres_fdw")
+            .await?;
+        conn.transaction(async |conn| {
+            let current_servers: Vec<String> = crate::catalog::current_servers(conn).await?;
+            for server in servers.iter().filter(|server| server.shard != self.shard) {
+                if current_servers.contains(&server.name) {
+                    server.update(conn).await?;
+                } else {
+                    server.create(conn).await?;
+                }
+            }
+            Ok(())
+        })
+        .await
+    }
+
+    /// Do the part of database setup that only affects this pool. Those
+    /// steps are
+    /// 1. Configuring foreign servers and user mappings for talking to the
+    ///    other shards
+    /// 2. Migrating the schema to the latest version
+    /// 3. Checking that the locale is set to C
+    async fn migrate(
+        self: Arc<Self>,
+        servers: &[ForeignServer],
+    ) -> Result<MigrationCount, StoreError> {
+        self.locale_check(&self.logger).await?;
+
+        self.configure_fdw(servers).await?;
+
+        // We use AsyncConnectionWrapper here since diesel_async doesn't
+        // offer a truly async way to run migrations, and we need to be very
+        // careful that block_on only gets called on a blocking thread to
+        // avoid errors from the tokio runtime
+        let logger = self.logger.cheap_clone();
+        let mut conn = self
+            .get_for_setup()
+            .await
+            .map(AsyncConnectionWrapper::from)?;
+
+        tokio::task::spawn_blocking(move || {
+            diesel::Connection::transaction::<_, StoreError, _>(&mut conn, |conn| {
+                migrate_schema(&logger, conn)
+            })
+        })
+        .await
+        .expect("migration task panicked")
+    }
+
+    /// If this is the primary shard, drop the namespace `CROSS_SHARD_NSP`
+    async fn drop_cross_shard_views(&self) -> Result<(), StoreError> {
+        if self.shard != *PRIMARY_SHARD {
+            return Ok(());
+        }
+
+        info!(&self.logger, "Dropping cross-shard views");
+        let mut conn = self.get_for_setup().await?;
+        conn.transaction(async move |conn| {
+            let query = format!("drop schema if exists {} cascade", CROSS_SHARD_NSP);
+            conn.batch_execute(&query).await?;
+            Ok(())
+        })
+        .await
+    }
+
+    /// If this is the primary shard, create the namespace `CROSS_SHARD_NSP`
+    /// and populate it with tables that union various imported tables
+    async fn create_cross_shard_views(&self, servers: &[ForeignServer]) -> Result<(), StoreError> {
+        fn shard_nsp_pairs<'a>(
+            current: &Shard,
+            local_nsp: &str,
+            servers: &'a [ForeignServer],
+        ) -> Vec<(&'a str, String)> {
+            servers
+                .iter()
+                .map(|server| {
+                    let nsp = if &server.shard == current {
+                        local_nsp.to_string()
+                    } else {
+                        ForeignServer::metadata_schema(&server.shard)
+                    };
+                    (server.shard.as_str(), nsp)
+                })
+                .collect::<Vec<_>>()
+        }
+
+        if self.shard != *PRIMARY_SHARD {
+            return Ok(());
+        }
+
+        let mut conn = self.get_for_setup().await?;
+        let sharded = Namespace::special(CROSS_SHARD_NSP);
+        if catalog::has_namespace(&mut conn, &sharded).await? {
+            // We dropped the namespace before, but another node must have
+            // recreated it in the meantime so we don't need to do anything
+            return Ok(());
+        }
+
+        info!(&self.logger, "Creating cross-shard views");
+        conn.transaction(async |conn| {
+            let query = format!("create schema {}", CROSS_SHARD_NSP);
+            conn.batch_execute(&query).await?;
+            for (src_nsp, src_tables) in SHARDED_TABLES {
+                // Pairs of (shard, nsp) for all servers
+                let nsps = shard_nsp_pairs(&self.shard, src_nsp, servers);
+                for src_table in src_tables {
+                    let create_view = catalog::create_cross_shard_view(
+                        conn,
+                        src_nsp,
+                        src_table,
+                        CROSS_SHARD_NSP,
+                        &nsps,
+                    )
+                    .await?;
+                    conn.batch_execute(&create_view).await?;
+                }
+            }
+            Ok(())
+        })
+        .await
+    }
+
+    /// Copy the data from key tables in the primary into our local schema
+    /// so it can be used as a fallback when the primary goes down
+    pub async fn mirror_primary_tables(&self) -> Result<(), StoreError> {
+        if self.shard == *PRIMARY_SHARD {
+            return Ok(());
+        }
+        let mut conn = self.get().await?;
+        conn.transaction(async |conn| primary::Mirror::refresh_tables(conn).await)
+            .await
+    }
+
+    /// The foreign server `server` had schema changes, and we therefore
+    /// need to remap anything that we are importing via fdw to make sure we
+    /// are using this updated schema
+    pub async fn remap(&self, server: &ForeignServer) -> Result<(), StoreError> {
+        if server.shard == *PRIMARY_SHARD {
+            info!(&self.logger, "Mapping primary");
+            let mut conn = self.get_for_setup().await?;
+            conn.transaction(async |conn| ForeignServer::map_primary(conn, &self.shard).await)
+                .await?;
+        }
+        if server.shard != self.shard {
+            info!(
+                &self.logger,
+                "Mapping metadata from {}",
+                server.shard.as_str()
+            );
+            let mut conn = self.get_for_setup().await?;
+            conn.transaction(async |conn| server.map_metadata(conn).await)
+                .await?;
+        }
+        Ok(())
+    }
+
+    pub async fn needs_remap(&self, server: &ForeignServer) -> Result<bool, StoreError> {
+        if server.shard == self.shard {
+            return Ok(false);
+        }
+
+        let mut conn = self.get_for_setup().await?;
+        server.needs_remap(&mut conn).await
+    }
+}
+
+pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("./migrations");
+
+struct MigrationCount {
+    old: usize,
+    new: usize,
+}
+
+impl MigrationCount {
+    fn had_migrations(&self) -> bool {
+        self.old != self.new
+    }
+}
+
+/// Run all schema migrations.
+fn migrate_schema(
+    logger: &Logger,
+    conn: &mut AsyncConnectionWrapper<AsyncPgConnection>,
+) -> Result<MigrationCount, StoreError> {
+    use diesel_migrations::MigrationHarness;
+
+    // Collect migration logging output
+    let mut output = vec![];
+
+    let old_count = graph::block_on(catalog::migration_count(conn))?;
+    let mut harness = HarnessWithOutput::new(conn, &mut output);
+
+    info!(logger, "Running migrations");
+    let result = harness.run_pending_migrations(MIGRATIONS);
+    info!(logger, "Migrations finished");
+
+    if let Err(e) = result {
+        let msg = String::from_utf8(output).unwrap_or_else(|_| String::from("<unreadable>"));
+        let mut msg = msg.trim().to_string();
+        if !msg.is_empty() {
+            msg = msg.replace('\n', " ");
+        }
+
+        error!(logger, "Postgres migration error"; "output" => msg);
+        return Err(StoreError::Unknown(anyhow!(e.to_string())));
+    } else {
+        let msg = String::from_utf8(output).unwrap_or_else(|_| String::from("<unreadable>"));
+        let mut msg = msg.trim().to_string();
+        if !msg.is_empty() {
+            msg = msg.replace('\n', " ");
+        }
+        debug!(logger, "Postgres migration output"; "output" => msg);
+    }
+
+    let migrations = graph::block_on(catalog::migration_count(conn))?;
+
+    Ok(MigrationCount {
+        new: migrations,
+        old: old_count,
+    })
+}
diff --git a/store/postgres/src/primary.rs b/store/postgres/src/primary.rs
index d4c87cb003f..6e6ffd11086 100644
--- a/store/postgres/src/primary.rs
+++ b/store/postgres/src/primary.rs
@@ -1,61 +1,57 @@
 //! Utilities for dealing with subgraph metadata that resides in the primary
 //! shard. Anything in this module can only be used with a database connection
 //! for the primary shard.
-use diesel::{
-    connection::SimpleConnection,
-    data_types::PgTimestamp,
-    dsl::{any, exists, not, select},
-    pg::Pg,
-    serialize::Output,
-    sql_types::{Array, Integer, Text},
-    types::{FromSql, ToSql},
+use crate::{
+    AsyncPgConnection, ConnectionPool, ForeignServer, NotificationSender,
+    block_range::UNVERSIONED_RANGE,
+    detail::DeploymentDetail,
+    pool::{PRIMARY_PUBLIC, PermittedConnection, TxnCallback, TxnMutCallback},
+    subgraph_store::{PRIMARY_SHARD, Shard, unused},
 };
-use diesel::{
-    dsl::{delete, insert_into, sql, update},
-    r2d2::PooledConnection,
+use diesel::dsl::{delete, insert_into, sql, update};
+use diesel::prelude::{
+    BoolExpressionMethods, ExpressionMethods, JoinOnDsl, NullableExpressionMethods,
+    OptionalExtension, QueryDsl,
 };
-use diesel::{pg::PgConnection, r2d2::ConnectionManager};
 use diesel::{
-    prelude::{
-        BoolExpressionMethods, ExpressionMethods, GroupByDsl, JoinOnDsl, NullableExpressionMethods,
-        OptionalExtension, QueryDsl, RunQueryDsl,
-    },
-    Connection as _,
+    data_types::PgTimestamp,
+    deserialize::FromSql,
+    dsl::{exists, not, select},
+    pg::Pg,
+    serialize::{Output, ToSql},
+    sql_types::{Array, BigInt, Bool, Integer, Text},
 };
+use diesel_async::{RunQueryDsl, SimpleAsyncConnection as _, TransactionManager};
 use graph::{
     components::store::DeploymentLocator,
-    constraint_violation,
-    data::subgraph::{status, DeploymentFeatures},
+    data::{
+        store::scalar::ToPrimitive,
+        subgraph::{DeploymentFeatures, status},
+    },
+    derive::CheapClone,
+    internal_error,
     prelude::{
-        anyhow, bigdecimal::ToPrimitive, serde_json, DeploymentHash, EntityChange,
-        EntityChangeOperation, NodeId, StoreError, SubgraphName, SubgraphVersionSwitchingMode,
+        AssignmentChange, DeploymentHash, NodeId, StoreError, SubgraphName,
+        SubgraphVersionSwitchingMode, anyhow,
+        chrono::{DateTime, Utc},
+        serde_json,
     },
 };
 use graph::{
     components::store::{DeploymentId as GraphDeploymentId, DeploymentSchemaVersion},
-    prelude::{chrono, CancelHandle, CancelToken},
+    prelude::chrono,
 };
 use graph::{data::subgraph::schema::generate_entity_id, prelude::StoreEvent};
 use itertools::Itertools;
-use maybe_owned::MaybeOwned;
 use std::{
     borrow::Borrow,
     collections::HashMap,
-    convert::TryFrom,
-    convert::TryInto,
+    convert::{TryFrom, TryInto},
     fmt,
-    io::Write,
+    sync::Arc,
     time::{SystemTime, UNIX_EPOCH},
 };
 
-use crate::{
-    block_range::UNVERSIONED_RANGE,
-    connection_pool::{ConnectionPool, ForeignServer},
-    detail::DeploymentDetail,
-    subgraph_store::{unused, Shard, PRIMARY_SHARD},
-    NotificationSender,
-};
-
 #[cfg(debug_assertions)]
 use std::sync::Mutex;
 #[cfg(debug_assertions)]
@@ -87,6 +83,10 @@ table! {
         data_sources -> Array<Text>,
         handlers -> Array<Text>,
         network -> Text,
+        has_declared_calls -> Bool,
+        has_bytes_as_ids -> Bool,
+        has_aggregations -> Bool,
+        immutable_entities -> Array<Text>
     }
 }
 
@@ -172,7 +172,8 @@ table! {
         latest_ethereum_block_hash -> Nullable<Binary>,
         latest_ethereum_block_number -> Nullable<Integer>,
         failed -> Bool,
-        synced -> Bool,
+        synced_at -> Nullable<Timestamptz>,
+        synced_at_block_number -> Nullable<Int4>,
     }
 }
 
@@ -195,7 +196,7 @@ allow_tables_to_appear_in_same_query!(
 /// Information about the database schema that stores the entities for a
 /// subgraph.
 #[derive(Clone, Queryable, QueryableByName, Debug)]
-#[table_name = "deployment_schemas"]
+#[diesel(table_name = deployment_schemas)]
 struct Schema {
     id: DeploymentId,
     #[allow(dead_code)]
@@ -209,7 +210,7 @@ struct Schema {
 }
 
 #[derive(Clone, Queryable, QueryableByName, Debug)]
-#[table_name = "unused_deployments"]
+#[diesel(table_name = unused_deployments)]
 pub struct UnusedDeployment {
     pub id: DeploymentId,
     pub deployment: String,
@@ -225,11 +226,12 @@ pub struct UnusedDeployment {
     pub latest_ethereum_block_hash: Option<Vec<u8>>,
     pub latest_ethereum_block_number: Option<i32>,
     pub failed: bool,
-    pub synced: bool,
+    pub synced_at: Option<DateTime<Utc>>,
+    pub synced_at_block_number: Option<i32>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, AsExpression, FromSqlRow)]
-#[sql_type = "diesel::sql_types::Text"]
+#[diesel(sql_type = Text)]
 /// A namespace (schema) in the database
 pub struct Namespace(String);
 
@@ -257,6 +259,13 @@ impl Namespace {
         Namespace(format!("prune{id}"))
     }
 
+    /// A namespace that is not a deployment namespace. This is used for
+    /// special namespaces we use. No checking is done on `s` and the caller
+    /// must ensure it's a valid namespace name
+    pub fn special(s: impl Into<String>) -> Self {
+        Namespace(s.into())
+    }
+
     pub fn as_str(&self) -> &str {
         &self.0
     }
@@ -269,14 +278,14 @@ impl fmt::Display for Namespace {
 }
 
 impl FromSql<Text, Pg> for Namespace {
-    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
+    fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
         let s = <String as FromSql<Text, Pg>>::from_sql(bytes)?;
         Namespace::new(s).map_err(Into::into)
     }
 }
 
 impl ToSql<Text, Pg> for Namespace {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> diesel::serialize::Result {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
         <String as ToSql<Text, Pg>>::to_sql(&self.0, out)
     }
 }
@@ -287,10 +296,16 @@ impl Borrow<str> for Namespace {
     }
 }
 
+impl Borrow<str> for &Namespace {
+    fn borrow(&self) -> &str {
+        &self.0
+    }
+}
+
 /// A marker that an `i32` references a deployment. Values of this type hold
 /// the primary key from the `deployment_schemas` table
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, AsExpression, FromSqlRow)]
-#[sql_type = "diesel::sql_types::Integer"]
+#[diesel(sql_type = Integer)]
 pub struct DeploymentId(i32);
 
 impl fmt::Display for DeploymentId {
@@ -318,14 +333,14 @@ impl From<DeploymentLocator> for DeploymentId {
 }
 
 impl FromSql<Integer, Pg> for DeploymentId {
-    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
+    fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
         let id = <i32 as FromSql<Integer, Pg>>::from_sql(bytes)?;
         Ok(DeploymentId(id))
     }
 }
 
 impl ToSql<Integer, Pg> for DeploymentId {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> diesel::serialize::Result {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
         <i32 as ToSql<Integer, Pg>>::to_sql(&self.0, out)
     }
 }
@@ -361,9 +376,9 @@ impl TryFrom<Schema> for Site {
 
     fn try_from(schema: Schema) -> Result<Self, Self::Error> {
         let deployment = DeploymentHash::new(&schema.subgraph)
-            .map_err(|s| constraint_violation!("Invalid deployment id {}", s))?;
+            .map_err(|s| internal_error!("Invalid deployment id {}", s))?;
         let namespace = Namespace::new(schema.name.clone()).map_err(|nsp| {
-            constraint_violation!(
+            internal_error!(
                 "Invalid schema name {} for deployment {}",
                 nsp,
                 &schema.subgraph
@@ -418,22 +433,23 @@ pub fn make_dummy_site(deployment: DeploymentHash, namespace: Namespace, network
 /// read-only
 mod queries {
     use diesel::data_types::PgTimestamp;
-    use diesel::dsl::{any, exists, sql};
-    use diesel::pg::PgConnection;
+    use diesel::dsl::{exists, sql};
     use diesel::prelude::{
         BoolExpressionMethods, ExpressionMethods, JoinOnDsl, NullableExpressionMethods,
-        OptionalExtension, QueryDsl, RunQueryDsl,
+        OptionalExtension, QueryDsl,
     };
     use diesel::sql_types::Text;
+    use diesel_async::RunQueryDsl;
     use graph::prelude::NodeId;
     use graph::{
-        constraint_violation,
+        components::store::DeploymentId as GraphDeploymentId,
         data::subgraph::status,
+        internal_error,
         prelude::{DeploymentHash, StoreError, SubgraphName},
     };
     use std::{collections::HashMap, convert::TryFrom, convert::TryInto};
 
-    use crate::Shard;
+    use crate::{AsyncPgConnection, Shard};
 
     use super::{DeploymentId, Schema, Site};
 
@@ -445,38 +461,40 @@ mod queries {
     use super::subgraph_deployment_assignment as a;
     use super::subgraph_version as v;
 
-    pub(super) fn find_active_site(
-        conn: &PgConnection,
+    pub(super) async fn find_active_site(
+        conn: &mut AsyncPgConnection,
         subgraph: &DeploymentHash,
     ) -> Result<Option<Site>, StoreError> {
         let schema = ds::table
             .filter(ds::subgraph.eq(subgraph.to_string()))
             .filter(ds::active.eq(true))
             .first::<Schema>(conn)
+            .await
             .optional()?;
         schema.map(|schema| schema.try_into()).transpose()
     }
 
-    pub(super) fn find_site_by_ref(
-        conn: &PgConnection,
+    pub(super) async fn find_site_by_ref(
+        conn: &mut AsyncPgConnection,
         id: DeploymentId,
     ) -> Result<Option<Site>, StoreError> {
-        let schema = ds::table.find(id).first::<Schema>(conn).optional()?;
+        let schema = ds::table.find(id).first::<Schema>(conn).await.optional()?;
         schema.map(|schema| schema.try_into()).transpose()
     }
 
-    pub(super) fn subgraph_exists(
-        conn: &PgConnection,
+    pub(super) async fn subgraph_exists(
+        conn: &mut AsyncPgConnection,
         name: &SubgraphName,
     ) -> Result<bool, StoreError> {
         Ok(
             diesel::select(exists(s::table.filter(s::name.eq(name.as_str()))))
-                .get_result::<bool>(conn)?,
+                .get_result::<bool>(conn)
+                .await?,
         )
     }
 
-    pub(super) fn current_deployment_for_subgraph(
-        conn: &PgConnection,
+    pub(super) async fn current_deployment_for_subgraph(
+        conn: &mut AsyncPgConnection,
         name: &SubgraphName,
     ) -> Result<DeploymentHash, StoreError> {
         let id = v::table
@@ -484,16 +502,17 @@ mod queries {
             .filter(s::name.eq(name.as_str()))
             .select(v::deployment)
             .first::<String>(conn)
+            .await
             .optional()?;
         match id {
             Some(id) => DeploymentHash::new(id)
-                .map_err(|id| constraint_violation!("illegal deployment id: {}", id)),
+                .map_err(|id| internal_error!("illegal deployment id: {}", id)),
             None => Err(StoreError::DeploymentNotFound(name.to_string())),
         }
     }
 
-    pub(super) fn deployments_for_subgraph(
-        conn: &PgConnection,
+    pub(super) async fn deployments_for_subgraph(
+        conn: &mut AsyncPgConnection,
         name: &str,
     ) -> Result<Vec<Site>, StoreError> {
         ds::table
@@ -503,14 +522,15 @@ mod queries {
             .filter(ds::active)
             .order_by(v::created_at.asc())
             .select(ds::all_columns)
-            .load::<Schema>(conn)?
+            .load::<Schema>(conn)
+            .await?
             .into_iter()
             .map(Site::try_from)
             .collect::<Result<Vec<Site>, _>>()
     }
 
-    pub(super) fn subgraph_version(
-        conn: &PgConnection,
+    pub(super) async fn subgraph_version(
+        conn: &mut AsyncPgConnection,
         name: &str,
         use_current: bool,
     ) -> Result<Option<Site>, StoreError> {
@@ -522,6 +542,7 @@ mod queries {
                 .filter(s::name.eq(&name))
                 .filter(ds::active)
                 .first::<Schema>(conn)
+                .await
         } else {
             ds::table
                 .select(ds::all_columns)
@@ -530,32 +551,35 @@ mod queries {
                 .filter(s::name.eq(&name))
                 .filter(ds::active)
                 .first::<Schema>(conn)
+                .await
         };
         deployment.optional()?.map(Site::try_from).transpose()
     }
 
     /// Find sites by their subgraph deployment hashes. If `ids` is empty,
     /// return all sites
-    pub(super) fn find_sites(
-        conn: &PgConnection,
+    pub(super) async fn find_sites(
+        conn: &mut AsyncPgConnection,
         ids: &[String],
         only_active: bool,
     ) -> Result<Vec<Site>, StoreError> {
         let schemas = if ids.is_empty() {
             if only_active {
-                ds::table.filter(ds::active).load::<Schema>(conn)?
+                ds::table.filter(ds::active).load::<Schema>(conn).await?
             } else {
-                ds::table.load::<Schema>(conn)?
+                ds::table.load::<Schema>(conn).await?
             }
         } else if only_active {
             ds::table
                 .filter(ds::active)
                 .filter(ds::subgraph.eq_any(ids))
-                .load::<Schema>(conn)?
+                .load::<Schema>(conn)
+                .await?
         } else {
             ds::table
                 .filter(ds::subgraph.eq_any(ids))
-                .load::<Schema>(conn)?
+                .load::<Schema>(conn)
+                .await?
         };
         schemas
             .into_iter()
@@ -565,19 +589,22 @@ mod queries {
 
     /// Find sites by their subgraph deployment ids. If `ids` is empty,
     /// return no sites
-    pub(super) fn find_sites_by_id(
-        conn: &PgConnection,
+    pub(super) async fn find_sites_by_id(
+        conn: &mut AsyncPgConnection,
         ids: &[DeploymentId],
     ) -> Result<Vec<Site>, StoreError> {
-        let schemas = ds::table.filter(ds::id.eq_any(ids)).load::<Schema>(conn)?;
+        let schemas = ds::table
+            .filter(ds::id.eq_any(ids))
+            .load::<Schema>(conn)
+            .await?;
         schemas
             .into_iter()
             .map(|schema| schema.try_into())
             .collect()
     }
 
-    pub(super) fn find_site_in_shard(
-        conn: &PgConnection,
+    pub(super) async fn find_site_in_shard(
+        conn: &mut AsyncPgConnection,
         subgraph: &DeploymentHash,
         shard: &Shard,
     ) -> Result<Option<Site>, StoreError> {
@@ -585,24 +612,29 @@ mod queries {
             .filter(ds::subgraph.eq(subgraph.as_str()))
             .filter(ds::shard.eq(shard.as_str()))
             .first::<Schema>(conn)
+            .await
             .optional()?;
         schema.map(|schema| schema.try_into()).transpose()
     }
 
-    pub(super) fn assignments(conn: &PgConnection, node: &NodeId) -> Result<Vec<Site>, StoreError> {
+    pub(super) async fn assignments(
+        conn: &mut AsyncPgConnection,
+        node: &NodeId,
+    ) -> Result<Vec<Site>, StoreError> {
         ds::table
             .inner_join(a::table.on(a::id.eq(ds::id)))
             .filter(a::node_id.eq(node.as_str()))
             .select(ds::all_columns)
-            .load::<Schema>(conn)?
+            .load::<Schema>(conn)
+            .await?
             .into_iter()
             .map(Site::try_from)
             .collect::<Result<Vec<Site>, _>>()
     }
 
     // All assignments for a node that are currently not paused
-    pub(super) fn active_assignments(
-        conn: &PgConnection,
+    pub(super) async fn active_assignments(
+        conn: &mut AsyncPgConnection,
         node: &NodeId,
     ) -> Result<Vec<Site>, StoreError> {
         ds::table
@@ -610,44 +642,43 @@ mod queries {
             .filter(a::node_id.eq(node.as_str()))
             .filter(a::paused_at.is_null())
             .select(ds::all_columns)
-            .load::<Schema>(conn)?
+            .load::<Schema>(conn)
+            .await?
             .into_iter()
             .map(Site::try_from)
             .collect::<Result<Vec<Site>, _>>()
     }
 
-    pub(super) fn fill_assignments(
-        conn: &PgConnection,
-        infos: &mut [status::Info],
-    ) -> Result<(), StoreError> {
-        let ids: Vec<_> = infos.iter().map(|info| &info.subgraph).collect();
+    pub(super) async fn fill_assignments(
+        conn: &mut AsyncPgConnection,
+        infos: &[status::Info],
+    ) -> Result<HashMap<GraphDeploymentId, (String, bool)>, StoreError> {
+        let ids: Vec<_> = infos.iter().map(|info| &info.id).collect();
         let nodes: HashMap<_, _> = a::table
             .inner_join(ds::table.on(ds::id.eq(a::id)))
-            .filter(ds::subgraph.eq(any(ids)))
-            .select((ds::subgraph, a::node_id, a::paused_at.is_not_null()))
-            .load::<(String, String, bool)>(conn)?
+            .filter(ds::id.eq_any(ids))
+            .select((ds::id, a::node_id, a::paused_at.is_not_null()))
+            .load::<(GraphDeploymentId, String, bool)>(conn)
+            .await?
             .into_iter()
-            .map(|(subgraph, node, paused)| (subgraph, (node, paused)))
+            .map(|(id, node, paused)| (id, (node, paused)))
             .collect();
-        for mut info in infos {
-            info.node = nodes.get(&info.subgraph).map(|(node, _)| node.clone());
-            info.paused = nodes.get(&info.subgraph).map(|(_, paused)| *paused);
-        }
-        Ok(())
+        Ok(nodes)
     }
 
-    pub(super) fn assigned_node(
-        conn: &PgConnection,
+    pub(super) async fn assigned_node(
+        conn: &mut AsyncPgConnection,
         site: &Site,
     ) -> Result<Option<NodeId>, StoreError> {
         a::table
             .filter(a::id.eq(site.id))
             .select(a::node_id)
             .first::<String>(conn)
+            .await
             .optional()?
             .map(|node| {
-                NodeId::new(&node).map_err(|()| {
-                    constraint_violation!(
+                NodeId::new(node).map_err(|node| {
+                    internal_error!(
                         "invalid node id `{}` in assignment for `{}`",
                         node,
                         site.deployment
@@ -661,18 +692,19 @@ mod queries {
     /// the subgraph is assigned to, and `is_paused` is true if the
     /// subgraph is paused.
     /// Returns None if the deployment does not exist.
-    pub(super) fn assignment_status(
-        conn: &PgConnection,
+    pub(super) async fn assignment_status(
+        conn: &mut AsyncPgConnection,
         site: &Site,
     ) -> Result<Option<(NodeId, bool)>, StoreError> {
         a::table
             .filter(a::id.eq(site.id))
             .select((a::node_id, a::paused_at))
             .first::<(String, Option<PgTimestamp>)>(conn)
+            .await
             .optional()?
             .map(|(node, ts)| {
-                let node_id = NodeId::new(&node).map_err(|()| {
-                    constraint_violation!(
+                let node_id = NodeId::new(node).map_err(|node| {
+                    internal_error!(
                         "invalid node id `{}` in assignment for `{}`",
                         node,
                         site.deployment
@@ -687,32 +719,34 @@ mod queries {
             .transpose()
     }
 
-    pub(super) fn version_info(
-        conn: &PgConnection,
+    pub(super) async fn version_info(
+        conn: &mut AsyncPgConnection,
         version: &str,
     ) -> Result<Option<(String, String)>, StoreError> {
         Ok(v::table
-            .select((v::deployment, sql("created_at::text")))
+            .select((v::deployment, sql::<Text>("created_at::text")))
             .filter(v::id.eq(version))
             .first::<(String, String)>(conn)
+            .await
             .optional()?)
     }
 
-    pub(super) fn versions_for_subgraph_id(
-        conn: &PgConnection,
+    pub(super) async fn versions_for_subgraph_id(
+        conn: &mut AsyncPgConnection,
         subgraph_id: &str,
     ) -> Result<(Option<String>, Option<String>), StoreError> {
         Ok(s::table
             .select((s::current_version.nullable(), s::pending_version.nullable()))
             .filter(s::id.eq(subgraph_id))
             .first::<(Option<String>, Option<String>)>(conn)
+            .await
             .optional()?
             .unwrap_or((None, None)))
     }
 
     /// Returns all (subgraph_name, version) pairs for a given deployment hash.
-    pub fn subgraphs_by_deployment_hash(
-        conn: &PgConnection,
+    pub async fn subgraphs_by_deployment_hash(
+        conn: &mut AsyncPgConnection,
         deployment_hash: &str,
     ) -> Result<Vec<(String, String)>, StoreError> {
         v::table
@@ -733,51 +767,98 @@ mod queries {
                     ),
                 ))
                 .get_results(conn)
+                .await
                 .map_err(Into::into)
     }
 }
 
+/// How to handle conflicts when restoring a deployment.
+/// Constructed from CLI flags --replace, --add, --force.
+pub enum RestoreMode {
+    /// No conflict flags given — error if deployment exists anywhere
+    Default,
+    /// --replace: drop and recreate in the target shard
+    Replace,
+    /// --add: create a copy in a shard that doesn't have the deployment
+    Add,
+    /// --force: restore no matter what (replace if in shard, add if not)
+    Force,
+}
+
+/// The action `plan_restore` decided on based on `RestoreMode` and current
+/// state.
+pub enum RestoreAction {
+    /// Create a new site (active=true if fresh, active=false if copy
+    /// exists elsewhere)
+    Create { active: bool },
+    /// Drop existing site in target shard, then recreate
+    Replace { existing: Site },
+}
+
 /// A wrapper for a database connection that provides access to functionality
 /// that works only on the primary database
-pub struct Connection<'a> {
-    conn: MaybeOwned<'a, PooledConnection<ConnectionManager<PgConnection>>>,
+pub struct Connection {
+    conn: PermittedConnection,
 }
 
-impl<'a> Connection<'a> {
-    pub fn new(
-        conn: impl Into<MaybeOwned<'a, PooledConnection<ConnectionManager<PgConnection>>>>,
-    ) -> Self {
-        Self { conn: conn.into() }
+impl Connection {
+    pub fn new(conn: PermittedConnection) -> Self {
+        Self { conn }
     }
 
-    pub(crate) fn transaction<T, E, F>(&self, f: F) -> Result<T, E>
+    /// Run an async `callback` inside a database transaction on the
+    /// connection that `self` contains. If `callback` returns `Ok(T)`, the
+    /// transaction is committed and `Ok(T)` is returned. If `callback`
+    /// returns `Err(E)`, the transaction is rolled back and `Err(E)` is
+    /// returned. If committing or rolling back the transaction fails,
+    /// return an error
+    pub(crate) async fn transaction<R, F>(&mut self, callback: F) -> Result<R, StoreError>
     where
-        F: FnOnce() -> Result<T, E>,
-        E: From<diesel::result::Error>,
+        F: TxnCallback<R, StoreError, Self>,
+        R: Send,
     {
-        self.conn.transaction(f)
+        type TM = <AsyncPgConnection as diesel_async::AsyncConnection>::TransactionManager;
+
+        TM::begin_transaction(&mut *self.conn).await?;
+        match callback(self).await {
+            Ok(value) => {
+                TM::commit_transaction(&mut *self.conn).await?;
+                Ok(value)
+            }
+            Err(user_error) => match TM::rollback_transaction(&mut *self.conn).await {
+                Ok(()) => Err(user_error),
+                Err(diesel::result::Error::BrokenTransactionManager) => {
+                    // In this case we are probably more interested by the
+                    // original error, which likely caused this
+                    Err(user_error)
+                }
+                Err(rollback_error) => Err(rollback_error.into()),
+            },
+        }
     }
 
     /// Signal any copy process that might be copying into one of these
     /// deployments that it should stop. Copying is cancelled whenever we
     /// remove the assignment for a deployment
-    fn cancel_copies(&self, ids: Vec<DeploymentId>) -> Result<(), StoreError> {
+    async fn cancel_copies(&mut self, ids: Vec<DeploymentId>) -> Result<(), StoreError> {
         use active_copies as ac;
 
         update(ac::table.filter(ac::dst.eq_any(ids)))
             .set(ac::cancelled_at.eq(sql("now()")))
-            .execute(self.conn.as_ref())?;
+            .execute(&mut self.conn)
+            .await?;
         Ok(())
     }
 
     /// Delete all assignments for deployments that are neither the current nor the
     /// pending version of a subgraph and return the deployment id's
-    fn remove_unused_assignments(&self) -> Result<Vec<EntityChange>, StoreError> {
+    async fn remove_unused_assignments(&mut self) -> Result<Vec<AssignmentChange>, StoreError> {
         use deployment_schemas as ds;
         use subgraph as s;
         use subgraph_deployment_assignment as a;
         use subgraph_version as v;
 
+        let conn = &mut self.conn;
         let named = v::table
             .inner_join(
                 s::table.on(v::id
@@ -791,31 +872,28 @@ impl<'a> Connection<'a> {
 
         let removed = delete(a::table.filter(not(exists(named))))
             .returning(a::id)
-            .load::<i32>(self.conn.as_ref())?;
+            .load::<i32>(conn)
+            .await?;
 
         let removed: Vec<_> = ds::table
             .filter(ds::id.eq_any(removed))
             .select((ds::id, ds::subgraph))
-            .load::<(DeploymentId, String)>(self.conn.as_ref())?
+            .load::<(DeploymentId, String)>(conn)
+            .await?
             .into_iter()
             .collect();
 
         // Stop ongoing copies
         let removed_ids: Vec<_> = removed.iter().map(|(id, _)| *id).collect();
-        self.cancel_copies(removed_ids)?;
+        self.cancel_copies(removed_ids).await?;
 
         let events = removed
             .into_iter()
             .map(|(id, hash)| {
                 DeploymentHash::new(hash)
-                    .map(|hash| {
-                        EntityChange::for_assignment(
-                            DeploymentLocator::new(id.into(), hash),
-                            EntityChangeOperation::Removed,
-                        )
-                    })
+                    .map(|hash| AssignmentChange::removed(DeploymentLocator::new(id.into(), hash)))
                     .map_err(|id| {
-                        StoreError::ConstraintViolation(format!(
+                        StoreError::InternalError(format!(
                             "invalid id `{}` for deployment assignment",
                             id
                         ))
@@ -829,11 +907,14 @@ impl<'a> Connection<'a> {
     /// the pending version so far, and remove any assignments that are not needed
     /// any longer as a result. Return the changes that were made to assignments
     /// in the process
-    pub fn promote_deployment(&self, id: &DeploymentHash) -> Result<Vec<EntityChange>, StoreError> {
+    pub async fn promote_deployment(
+        &mut self,
+        id: &DeploymentHash,
+    ) -> Result<Vec<AssignmentChange>, StoreError> {
         use subgraph as s;
         use subgraph_version as v;
 
-        let conn = self.conn.as_ref();
+        let conn = &mut self.conn;
 
         // Subgraphs where we need to promote the version
         let pending_subgraph_versions: Vec<(String, String)> = s::table
@@ -841,7 +922,8 @@ impl<'a> Connection<'a> {
             .filter(v::deployment.eq(id.as_str()))
             .select((s::id, v::id))
             .for_update()
-            .load(conn)?;
+            .load(conn)
+            .await?;
 
         // Switch the pending version to the current version
         for (subgraph, version) in &pending_subgraph_versions {
@@ -850,7 +932,8 @@ impl<'a> Connection<'a> {
                     s::current_version.eq(version),
                     s::pending_version.eq::<Option<&str>>(None),
                 ))
-                .execute(conn)?;
+                .execute(conn)
+                .await?;
         }
 
         // Clean up assignments if we could possibly have changed any
@@ -858,7 +941,7 @@ impl<'a> Connection<'a> {
         let changes = if pending_subgraph_versions.is_empty() {
             vec![]
         } else {
-            self.remove_unused_assignments()?
+            self.remove_unused_assignments().await?
         };
         Ok(changes)
     }
@@ -866,10 +949,10 @@ impl<'a> Connection<'a> {
     /// Create a new subgraph with the given name. If one already exists, use
     /// the existing one. Return the `id` of the newly created or existing
     /// subgraph
-    pub fn create_subgraph(&self, name: &SubgraphName) -> Result<String, StoreError> {
+    pub async fn create_subgraph(&mut self, name: &SubgraphName) -> Result<String, StoreError> {
         use subgraph as s;
 
-        let conn = self.conn.as_ref();
+        let conn = &mut self.conn;
         let id = generate_entity_id();
         let created_at = SystemTime::now()
             .duration_since(UNIX_EPOCH)
@@ -885,35 +968,35 @@ impl<'a> Connection<'a> {
             ))
             .on_conflict(s::name)
             .do_nothing()
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
         if inserted == 0 {
             let existing_id = s::table
                 .filter(s::name.eq(name.as_str()))
                 .select(s::id)
-                .first::<String>(conn)?;
+                .first::<String>(conn)
+                .await?;
             Ok(existing_id)
         } else {
             Ok(id)
         }
     }
 
-    pub fn create_subgraph_version<F>(
-        &self,
+    pub async fn create_subgraph_version<F>(
+        &mut self,
         name: SubgraphName,
         site: &Site,
         node_id: NodeId,
         mode: SubgraphVersionSwitchingMode,
         exists_and_synced: F,
-    ) -> Result<Vec<EntityChange>, StoreError>
+    ) -> Result<Vec<AssignmentChange>, StoreError>
     where
-        F: Fn(&DeploymentHash) -> Result<bool, StoreError>,
+        F: AsyncFn(&DeploymentHash) -> Result<bool, StoreError>,
     {
+        use SubgraphVersionSwitchingMode::*;
         use subgraph as s;
         use subgraph_deployment_assignment as a;
         use subgraph_version as v;
-        use SubgraphVersionSwitchingMode::*;
-
-        let conn = self.conn.as_ref();
 
         let created_at = SystemTime::now()
             .duration_since(UNIX_EPOCH)
@@ -926,38 +1009,38 @@ impl<'a> Connection<'a> {
             .left_outer_join(v::table.on(s::current_version.eq(v::id.nullable())))
             .filter(s::name.eq(name.as_str()))
             .select((s::id, v::deployment.nullable()))
-            .first::<(String, Option<String>)>(conn)
+            .first::<(String, Option<String>)>(&mut self.conn)
+            .await
             .optional()?;
         let (subgraph_id, current_deployment) = match info {
-            Some((subgraph_id, current_deployment)) => (subgraph_id, current_deployment),
-            None => (self.create_subgraph(&name)?, None),
+            Some((subgraph_id, current_deployment)) => {
+                let current_deployment = current_deployment
+                    .map(|d| DeploymentHash::new(d).map_err(StoreError::DeploymentNotFound))
+                    .transpose()?;
+                (subgraph_id, current_deployment)
+            }
+            None => (self.create_subgraph(&name).await?, None),
         };
         let pending_deployment = s::table
             .left_outer_join(v::table.on(s::pending_version.eq(v::id.nullable())))
             .filter(s::id.eq(&subgraph_id))
             .select(v::deployment.nullable())
-            .first::<Option<String>>(conn)?;
+            .first::<Option<String>>(&mut self.conn)
+            .await?;
 
         // See if the current version of that subgraph is synced. If the subgraph
         // has no current version, we treat it the same as if it were not synced
         // The `optional` below only comes into play if data is corrupted/missing;
         // ignoring that via `optional` makes it possible to fix a missing version
         // or deployment by deploying over it.
-        let current_exists_and_synced = current_deployment
-            .as_deref()
-            .map(|id| {
-                DeploymentHash::new(id)
-                    .map_err(StoreError::DeploymentNotFound)
-                    .and_then(|id| exists_and_synced(&id))
-            })
-            .transpose()?
-            .unwrap_or(false);
+        let current_exists_and_synced = match current_deployment {
+            None => false,
+            Some(ref id) => exists_and_synced(id).await?,
+        };
 
         // Check if we even need to make any changes
         let change_needed = match (mode, current_exists_and_synced) {
-            (Instant, _) | (Synced, false) => {
-                current_deployment.as_deref() != Some(site.deployment.as_str())
-            }
+            (Instant, _) | (Synced, false) => current_deployment.as_ref() != Some(&site.deployment),
             (Synced, true) => pending_deployment.as_deref() != Some(site.deployment.as_str()),
         };
         if !change_needed {
@@ -975,26 +1058,29 @@ impl<'a> Connection<'a> {
                 v::created_at.eq(sql(&format!("{}", created_at))),
                 v::block_range.eq(UNVERSIONED_RANGE),
             ))
-            .execute(conn)?;
+            .execute(&mut self.conn)
+            .await?;
 
         // Create a subgraph assignment if there isn't one already
         let new_assignment = a::table
             .filter(a::id.eq(site.id))
             .select(a::id)
-            .first::<i32>(conn)
+            .first::<i32>(&mut self.conn)
+            .await
             .optional()?
             .is_none();
         if new_assignment {
             insert_into(a::table)
                 .values((a::id.eq(site.id), a::node_id.eq(node_id.as_str())))
-                .execute(conn)?;
+                .execute(&mut self.conn)
+                .await?;
         }
 
         // See if we should make this the current or pending version
         let subgraph_row = update(s::table.filter(s::id.eq(&subgraph_id)));
         // When the new deployment is also synced already, we always want to
         // overwrite the current version
-        let new_exists_and_synced = exists_and_synced(&site.deployment)?;
+        let new_exists_and_synced = exists_and_synced(&site.deployment).await?;
         match (mode, current_exists_and_synced, new_exists_and_synced) {
             (Instant, _, _) | (Synced, false, _) | (Synced, true, true) => {
                 subgraph_row
@@ -1002,29 +1088,34 @@ impl<'a> Connection<'a> {
                         s::current_version.eq(&version_id),
                         s::pending_version.eq::<Option<&str>>(None),
                     ))
-                    .execute(conn)?;
+                    .execute(&mut self.conn)
+                    .await?;
             }
             (Synced, true, false) => {
                 subgraph_row
                     .set(s::pending_version.eq(&version_id))
-                    .execute(conn)?;
+                    .execute(&mut self.conn)
+                    .await?;
             }
         }
 
         // Clean up any assignments we might have displaced
-        let mut changes = self.remove_unused_assignments()?;
+        let mut changes = self.remove_unused_assignments().await?;
         if new_assignment {
-            let change = EntityChange::for_assignment(site.into(), EntityChangeOperation::Set);
+            let change = AssignmentChange::set(site.into());
             changes.push(change);
         }
         Ok(changes)
     }
 
-    pub fn remove_subgraph(&self, name: SubgraphName) -> Result<Vec<EntityChange>, StoreError> {
+    pub async fn remove_subgraph(
+        &mut self,
+        name: SubgraphName,
+    ) -> Result<Vec<AssignmentChange>, StoreError> {
         use subgraph as s;
         use subgraph_version as v;
 
-        let conn = self.conn.as_ref();
+        let conn = &mut self.conn;
 
         // Get the id of the given subgraph. If no subgraph with the
         // name exists, there is nothing to do
@@ -1032,29 +1123,37 @@ impl<'a> Connection<'a> {
             .filter(s::name.eq(name.as_str()))
             .select(s::id)
             .first(conn)
+            .await
             .optional()?;
         if let Some(subgraph) = subgraph {
-            delete(v::table.filter(v::subgraph.eq(&subgraph))).execute(conn)?;
-            delete(s::table.filter(s::id.eq(subgraph))).execute(conn)?;
-            self.remove_unused_assignments()
+            delete(v::table.filter(v::subgraph.eq(&subgraph)))
+                .execute(conn)
+                .await?;
+            delete(s::table.filter(s::id.eq(subgraph)))
+                .execute(conn)
+                .await?;
+            self.remove_unused_assignments().await
         } else {
             Ok(vec![])
         }
     }
 
-    pub fn pause_subgraph(&self, site: &Site) -> Result<Vec<EntityChange>, StoreError> {
+    pub async fn pause_subgraph(
+        &mut self,
+        site: &Site,
+    ) -> Result<Vec<AssignmentChange>, StoreError> {
         use subgraph_deployment_assignment as a;
 
-        let conn = self.conn.as_ref();
+        let conn = &mut self.conn;
 
         let updates = update(a::table.filter(a::id.eq(site.id)))
             .set(a::paused_at.eq(sql("now()")))
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
         match updates {
             0 => Err(StoreError::DeploymentNotFound(site.deployment.to_string())),
             1 => {
-                let change =
-                    EntityChange::for_assignment(site.into(), EntityChangeOperation::Removed);
+                let change = AssignmentChange::removed(site.into());
                 Ok(vec![change])
             }
             _ => {
@@ -1065,18 +1164,22 @@ impl<'a> Connection<'a> {
         }
     }
 
-    pub fn resume_subgraph(&self, site: &Site) -> Result<Vec<EntityChange>, StoreError> {
+    pub async fn resume_subgraph(
+        &mut self,
+        site: &Site,
+    ) -> Result<Vec<AssignmentChange>, StoreError> {
         use subgraph_deployment_assignment as a;
 
-        let conn = self.conn.as_ref();
+        let conn = &mut self.conn;
 
         let updates = update(a::table.filter(a::id.eq(site.id)))
             .set(a::paused_at.eq(sql("null")))
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
         match updates {
             0 => Err(StoreError::DeploymentNotFound(site.deployment.to_string())),
             1 => {
-                let change = EntityChange::for_assignment(site.into(), EntityChangeOperation::Set);
+                let change = AssignmentChange::set(site.into());
                 Ok(vec![change])
             }
             _ => {
@@ -1087,21 +1190,22 @@ impl<'a> Connection<'a> {
         }
     }
 
-    pub fn reassign_subgraph(
-        &self,
+    pub async fn reassign_subgraph(
+        &mut self,
         site: &Site,
         node: &NodeId,
-    ) -> Result<Vec<EntityChange>, StoreError> {
+    ) -> Result<Vec<AssignmentChange>, StoreError> {
         use subgraph_deployment_assignment as a;
 
-        let conn = self.conn.as_ref();
+        let conn = &mut self.conn;
         let updates = update(a::table.filter(a::id.eq(site.id)))
             .set(a::node_id.eq(node.as_str()))
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
         match updates {
             0 => Err(StoreError::DeploymentNotFound(site.deployment.to_string())),
             1 => {
-                let change = EntityChange::for_assignment(site.into(), EntityChangeOperation::Set);
+                let change = AssignmentChange::set(site.into());
                 Ok(vec![change])
             }
             _ => {
@@ -1112,13 +1216,13 @@ impl<'a> Connection<'a> {
         }
     }
 
-    pub fn get_subgraph_features(
-        &self,
+    pub async fn get_subgraph_features(
+        &mut self,
         id: String,
     ) -> Result<Option<DeploymentFeatures>, StoreError> {
         use subgraph_features as f;
 
-        let conn = self.conn.as_ref();
+        let conn = &mut self.conn;
         let features = f::table
             .filter(f::id.eq(id))
             .select((
@@ -1129,6 +1233,10 @@ impl<'a> Connection<'a> {
                 f::data_sources,
                 f::handlers,
                 f::network,
+                f::has_declared_calls,
+                f::has_bytes_as_ids,
+                f::has_aggregations,
+                f::immutable_entities,
             ))
             .first::<(
                 String,
@@ -1138,11 +1246,28 @@ impl<'a> Connection<'a> {
                 Vec<String>,
                 Vec<String>,
                 String,
+                bool,
+                bool,
+                bool,
+                Vec<String>,
             )>(conn)
+            .await
             .optional()?;
 
         let features = features.map(
-            |(id, spec_version, api_version, features, data_sources, handlers, network)| {
+            |(
+                id,
+                spec_version,
+                api_version,
+                features,
+                data_sources,
+                handlers,
+                network,
+                has_declared_calls,
+                has_bytes_as_ids,
+                has_aggregations,
+                immutable_entities,
+            )| {
                 DeploymentFeatures {
                     id,
                     spec_version,
@@ -1150,7 +1275,11 @@ impl<'a> Connection<'a> {
                     features,
                     data_source_kinds: data_sources,
                     handler_kinds: handlers,
-                    network: network,
+                    network,
+                    has_declared_calls,
+                    has_bytes_as_ids,
+                    has_aggregations,
+                    immutable_entities,
                 }
             },
         );
@@ -1158,7 +1287,10 @@ impl<'a> Connection<'a> {
         Ok(features)
     }
 
-    pub fn create_subgraph_features(&self, features: DeploymentFeatures) -> Result<(), StoreError> {
+    pub async fn create_subgraph_features(
+        &mut self,
+        features: DeploymentFeatures,
+    ) -> Result<(), StoreError> {
         use subgraph_features as f;
 
         let DeploymentFeatures {
@@ -1169,9 +1301,13 @@ impl<'a> Connection<'a> {
             data_source_kinds,
             handler_kinds,
             network,
+            has_declared_calls,
+            has_bytes_as_ids,
+            immutable_entities,
+            has_aggregations,
         } = features;
 
-        let conn = self.conn.as_ref();
+        let conn = &mut self.conn;
         let changes = (
             f::id.eq(id),
             f::spec_version.eq(spec_version),
@@ -1180,44 +1316,54 @@ impl<'a> Connection<'a> {
             f::data_sources.eq(data_source_kinds),
             f::handlers.eq(handler_kinds),
             f::network.eq(network),
+            f::has_declared_calls.eq(has_declared_calls),
+            f::has_bytes_as_ids.eq(has_bytes_as_ids),
+            f::immutable_entities.eq(immutable_entities),
+            f::has_aggregations.eq(has_aggregations),
         );
 
         insert_into(f::table)
             .values(changes.clone())
             .on_conflict_do_nothing()
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
         Ok(())
     }
 
-    pub fn assign_subgraph(
-        &self,
+    pub async fn assign_subgraph(
+        &mut self,
         site: &Site,
         node: &NodeId,
-    ) -> Result<Vec<EntityChange>, StoreError> {
+    ) -> Result<Vec<AssignmentChange>, StoreError> {
         use subgraph_deployment_assignment as a;
 
-        let conn = self.conn.as_ref();
+        let conn = &mut self.conn;
         insert_into(a::table)
             .values((a::id.eq(site.id), a::node_id.eq(node.as_str())))
-            .execute(conn)?;
+            .execute(conn)
+            .await?;
 
-        let change = EntityChange::for_assignment(site.into(), EntityChangeOperation::Set);
+        let change = AssignmentChange::set(site.into());
         Ok(vec![change])
     }
 
-    pub fn unassign_subgraph(&self, site: &Site) -> Result<Vec<EntityChange>, StoreError> {
+    pub async fn unassign_subgraph(
+        &mut self,
+        site: &Site,
+    ) -> Result<Vec<AssignmentChange>, StoreError> {
         use subgraph_deployment_assignment as a;
 
-        let conn = self.conn.as_ref();
-        let delete_count = delete(a::table.filter(a::id.eq(site.id))).execute(conn)?;
+        let conn = &mut self.conn;
+        let delete_count = delete(a::table.filter(a::id.eq(site.id)))
+            .execute(conn)
+            .await?;
 
-        self.cancel_copies(vec![site.id])?;
+        self.cancel_copies(vec![site.id]).await?;
 
         match delete_count {
             0 => Ok(vec![]),
             1 => {
-                let change =
-                    EntityChange::for_assignment(site.into(), EntityChangeOperation::Removed);
+                let change = AssignmentChange::removed(site.into());
                 Ok(vec![change])
             }
             _ => {
@@ -1232,8 +1378,8 @@ impl<'a> Connection<'a> {
     /// function only performs the basic operations for creation, and the
     /// caller must check that other conditions (like whether there already
     /// is an active site for the deployment) are met
-    fn create_site(
-        &self,
+    pub(crate) async fn create_site(
+        &mut self,
         shard: Shard,
         deployment: DeploymentHash,
         network: String,
@@ -1242,7 +1388,7 @@ impl<'a> Connection<'a> {
     ) -> Result<Site, StoreError> {
         use deployment_schemas as ds;
 
-        let conn = self.conn.as_ref();
+        let conn = &mut self.conn;
 
         let schemas: Vec<(DeploymentId, String)> = diesel::insert_into(ds::table)
             .values((
@@ -1253,13 +1399,15 @@ impl<'a> Connection<'a> {
                 ds::active.eq(active),
             ))
             .returning((ds::id, ds::name))
-            .get_results(conn)?;
+            .get_results(conn)
+            .await?;
         let (id, namespace) = schemas
+            .as_slice()
             .first()
             .cloned()
             .ok_or_else(|| anyhow!("failed to read schema name for {} back", deployment))?;
         let namespace = Namespace::new(namespace).map_err(|name| {
-            constraint_violation!("Generated database schema name {} is invalid", name)
+            internal_error!("Generated database schema name {} is invalid", name)
         })?;
 
         Ok(Site {
@@ -1268,7 +1416,7 @@ impl<'a> Connection<'a> {
             shard,
             namespace,
             network,
-            active: true,
+            active,
             schema_version,
             _creation_disallowed: (),
         })
@@ -1278,21 +1426,22 @@ impl<'a> Connection<'a> {
     /// If it already exists, return the existing site
     /// and a boolean indicating whether a new site was created.
     /// `false` means the site already existed.
-    pub fn allocate_site(
-        &self,
+    pub async fn allocate_site(
+        &mut self,
         shard: Shard,
         subgraph: &DeploymentHash,
         network: String,
         graft_base: Option<&DeploymentHash>,
     ) -> Result<(Site, bool), StoreError> {
-        if let Some(site) = queries::find_active_site(self.conn.as_ref(), subgraph)? {
+        let conn = &mut self.conn;
+        if let Some(site) = queries::find_active_site(conn, subgraph).await? {
             return Ok((site, false));
         }
 
         let site_was_created = true;
         let schema_version = match graft_base {
             Some(graft_base) => {
-                let site = queries::find_active_site(self.conn.as_ref(), graft_base)?;
+                let site = queries::find_active_site(conn, graft_base).await?;
                 site.map(|site| site.schema_version).ok_or_else(|| {
                     StoreError::DeploymentNotFound("graft_base not found".to_string())
                 })
@@ -1301,27 +1450,38 @@ impl<'a> Connection<'a> {
         }?;
 
         self.create_site(shard, subgraph.clone(), network, schema_version, true)
+            .await
             .map(|site| (site, site_was_created))
     }
 
-    pub fn assigned_node(&self, site: &Site) -> Result<Option<NodeId>, StoreError> {
-        queries::assigned_node(self.conn.as_ref(), site)
+    pub async fn find_active_site(
+        &mut self,
+        subgraph: &DeploymentHash,
+    ) -> Result<Option<Site>, StoreError> {
+        queries::find_active_site(&mut self.conn, subgraph).await
+    }
+
+    pub async fn assigned_node(&mut self, site: &Site) -> Result<Option<NodeId>, StoreError> {
+        queries::assigned_node(&mut self.conn, site).await
     }
 
     /// Returns Option<(node_id,is_paused)> where `node_id` is the node that
     /// the subgraph is assigned to, and `is_paused` is true if the
     /// subgraph is paused.
     /// Returns None if the deployment does not exist.
-    pub fn assignment_status(&self, site: &Site) -> Result<Option<(NodeId, bool)>, StoreError> {
-        queries::assignment_status(self.conn.as_ref(), site)
+    pub async fn assignment_status(
+        &mut self,
+        site: &Site,
+    ) -> Result<Option<(NodeId, bool)>, StoreError> {
+        queries::assignment_status(&mut self.conn, site).await
     }
 
     /// Create a copy of the site `src` in the shard `shard`, but mark it as
     /// not active. If there already is a site in `shard`, return that
     /// instead.
-    pub fn copy_site(&self, src: &Site, shard: Shard) -> Result<Site, StoreError> {
+    pub async fn copy_site(&mut self, src: &Site, shard: Shard) -> Result<Site, StoreError> {
         if let Some(site) =
-            queries::find_site_in_shard(self.conn.as_ref(), &src.deployment, &shard)?
+            queries::find_site_in_shard(&mut self.conn, &src.deployment, &shard).await?
         {
             return Ok(site);
         }
@@ -1333,90 +1493,160 @@ impl<'a> Connection<'a> {
             src.schema_version,
             false,
         )
+        .await
     }
 
-    pub(crate) fn activate(&self, deployment: &DeploymentLocator) -> Result<(), StoreError> {
+    pub(crate) async fn activate(
+        &mut self,
+        deployment: &DeploymentLocator,
+    ) -> Result<(), StoreError> {
         use deployment_schemas as ds;
+        let conn = &mut self.conn;
 
         // We need to tread lightly so we do not violate the unique constraint on
         // `subgraph where active`
         update(ds::table.filter(ds::subgraph.eq(deployment.hash.as_str())))
             .set(ds::active.eq(false))
-            .execute(self.conn.as_ref())?;
+            .execute(conn)
+            .await?;
 
         update(ds::table.filter(ds::id.eq(DeploymentId::from(deployment.id))))
             .set(ds::active.eq(true))
-            .execute(self.conn.as_ref())
+            .execute(conn)
+            .await
             .map_err(|e| e.into())
             .map(|_| ())
     }
 
     /// Remove all subgraph versions, the entry in `deployment_schemas` and the entry in
     /// `subgraph_features` for subgraph `id` in a transaction
-    pub fn drop_site(&self, site: &Site) -> Result<(), StoreError> {
+    pub async fn drop_site(&mut self, site: &Site) -> Result<(), StoreError> {
         use deployment_schemas as ds;
         use subgraph_features as f;
         use subgraph_version as v;
         use unused_deployments as u;
 
-        self.transaction(|| {
-            let conn = self.conn.as_ref();
+        self.transaction(async |pconn| {
+            let conn = &mut pconn.conn;
 
-            delete(ds::table.filter(ds::id.eq(site.id))).execute(conn)?;
+            delete(ds::table.filter(ds::id.eq(site.id)))
+                .execute(conn)
+                .await?;
 
             // If there is no site for this deployment any more, we can get
             // rid of versions pointing to it
             let exists = select(exists(
                 ds::table.filter(ds::subgraph.eq(site.deployment.as_str())),
             ))
-            .get_result::<bool>(conn)?;
+            .get_result::<bool>(conn)
+            .await?;
             if !exists {
                 delete(v::table.filter(v::deployment.eq(site.deployment.as_str())))
-                    .execute(conn)?;
+                    .execute(conn)
+                    .await?;
 
                 // Remove the entry in `subgraph_features`
-                delete(f::table.filter(f::id.eq(site.deployment.as_str()))).execute(conn)?;
+                delete(f::table.filter(f::id.eq(site.deployment.as_str())))
+                    .execute(conn)
+                    .await?;
             }
 
             update(u::table.filter(u::id.eq(site.id)))
                 .set(u::removed_at.eq(sql("now()")))
-                .execute(self.conn.as_ref())?;
+                .execute(conn)
+                .await?;
             Ok(())
         })
+        .await
+    }
+
+    /// Determine what action to take when restoring `subgraph` into `shard`
+    /// based on the `mode` and the current state of the deployment.
+    pub async fn plan_restore(
+        &mut self,
+        shard: &Shard,
+        subgraph: &DeploymentHash,
+        mode: &RestoreMode,
+    ) -> Result<RestoreAction, StoreError> {
+        let conn = &mut self.conn;
+        let in_shard = queries::find_site_in_shard(conn, subgraph, shard).await?;
+        let active = queries::find_active_site(conn, subgraph).await?;
+
+        match (in_shard, active, mode) {
+            // Deployment exists in target shard
+            (Some(existing), _, RestoreMode::Replace | RestoreMode::Force) => {
+                Ok(RestoreAction::Replace { existing })
+            }
+            (Some(_), _, RestoreMode::Default | RestoreMode::Add) => {
+                Err(StoreError::Input(format!(
+                    "deployment {} already exists in shard {}; use --replace or --force",
+                    subgraph,
+                    shard.as_str()
+                )))
+            }
+            // Deployment does not exist in target shard but exists elsewhere
+            (None, Some(ref active_site), RestoreMode::Add | RestoreMode::Force) => {
+                let _ = active_site;
+                Ok(RestoreAction::Create { active: false })
+            }
+            (None, Some(active_site), RestoreMode::Default) => Err(StoreError::Input(format!(
+                "deployment {} already exists in shard {}; use --add --shard {} or --force",
+                subgraph,
+                active_site.shard.as_str(),
+                shard.as_str()
+            ))),
+            (None, Some(_), RestoreMode::Replace) => Err(StoreError::Input(format!(
+                "deployment {} is not in shard {}; nothing to replace",
+                subgraph,
+                shard.as_str()
+            ))),
+            // Deployment does not exist anywhere
+            (None, None, RestoreMode::Replace) => Err(StoreError::Input(format!(
+                "deployment {} does not exist; nothing to replace",
+                subgraph
+            ))),
+            (None, None, _) => Ok(RestoreAction::Create { active: true }),
+        }
     }
 
-    pub fn locate_site(&self, locator: DeploymentLocator) -> Result<Option<Site>, StoreError> {
+    pub async fn locate_site(
+        &mut self,
+        locator: DeploymentLocator,
+    ) -> Result<Option<Site>, StoreError> {
         let schema = deployment_schemas::table
             .filter(deployment_schemas::id.eq::<DeploymentId>(locator.into()))
-            .first::<Schema>(self.conn.as_ref())
+            .first::<Schema>(&mut self.conn)
+            .await
             .optional()?;
         schema.map(|schema| schema.try_into()).transpose()
     }
 
-    pub fn find_sites_for_network(&self, network: &str) -> Result<Vec<Site>, StoreError> {
+    pub async fn find_sites_for_network(&mut self, network: &str) -> Result<Vec<Site>, StoreError> {
         use deployment_schemas as ds;
 
         ds::table
             .filter(ds::network.eq(network))
-            .load::<Schema>(self.conn.as_ref())?
+            .load::<Schema>(&mut self.conn)
+            .await?
             .into_iter()
             .map(|schema| schema.try_into())
             .collect()
     }
 
-    pub fn sites(&self) -> Result<Vec<Site>, StoreError> {
+    pub async fn sites(&mut self) -> Result<Vec<Site>, StoreError> {
         use deployment_schemas as ds;
 
         ds::table
             .filter(ds::name.ne("subgraphs"))
-            .load::<Schema>(self.conn.as_ref())?
+            .load::<Schema>(&mut self.conn)
+            .await?
             .into_iter()
             .map(|schema| schema.try_into())
             .collect()
     }
 
-    pub fn send_store_event(
-        &self,
+    pub async fn send_store_event(
+        &mut self,
         sender: &NotificationSender,
         event: &StoreEvent,
     ) -> Result<(), StoreError> {
@@ -1431,22 +1661,30 @@ impl<'a> Connection<'a> {
                 EVENT_TAP.lock().unwrap().push(event.clone());
             }
         }
-        sender.notify(&self.conn, "store_events", None, &v)
+        sender
+            .notify(&mut self.conn, "store_events", None, &v)
+            .await
     }
 
     /// Return the name of the node that has the fewest assignments out of the
     /// given `nodes`. If `nodes` is empty, return `None`
-    pub fn least_assigned_node(&self, nodes: &[NodeId]) -> Result<Option<NodeId>, StoreError> {
+    pub async fn least_assigned_node(
+        &mut self,
+        nodes: &[NodeId],
+    ) -> Result<Option<NodeId>, StoreError> {
         use subgraph_deployment_assignment as a;
 
         let nodes: Vec<_> = nodes.iter().map(|n| n.as_str()).collect();
 
+        let conn = &mut self.conn;
+
         let assigned = a::table
-            .filter(a::node_id.eq(any(&nodes)))
-            .select((a::node_id, sql("count(*)")))
+            .filter(a::node_id.eq_any(&nodes))
+            .select((a::node_id, sql::<BigInt>("count(*)")))
             .group_by(a::node_id)
-            .order_by(sql::<i64>("count(*)"))
-            .load::<(String, i64)>(self.conn.as_ref())?;
+            .order_by(sql::<BigInt>("count(*)"))
+            .load::<(String, i64)>(conn)
+            .await?;
 
         // Any nodes without assignments will be missing from `assigned`
         let missing = nodes
@@ -1459,11 +1697,11 @@ impl<'a> Connection<'a> {
             .map(|(node, count)| (node.as_str(), *count))
             .chain(missing)
             .min_by_key(|(_, count)| *count)
-            .map(|(node, _)| NodeId::new(node).map_err(|()| node))
+            .map(|(node, _)| NodeId::new(node))
             .transpose()
             // This can't really happen since we filtered by valid NodeId's
             .map_err(|node| {
-                constraint_violation!("database has assignment for illegal node name {:?}", node)
+                internal_error!("database has assignment for illegal node name {:?}", node)
             })
     }
 
@@ -1474,17 +1712,23 @@ impl<'a> Connection<'a> {
     /// that are stored in it. Unassigned deployments are ignored; in
     /// particular, that ignores deployments that are going to be removed
     /// soon.
-    pub fn least_used_shard(&self, shards: &[Shard]) -> Result<Option<Shard>, StoreError> {
+    pub async fn least_used_shard(
+        &mut self,
+        shards: &[Shard],
+    ) -> Result<Option<Shard>, StoreError> {
         use deployment_schemas as ds;
         use subgraph_deployment_assignment as a;
 
+        let conn = &mut self.conn;
+
         let used = ds::table
             .inner_join(a::table.on(a::id.eq(ds::id)))
-            .filter(ds::shard.eq(any(shards)))
-            .select((ds::shard, sql("count(*)")))
+            .filter(ds::shard.eq_any(shards))
+            .select((ds::shard, sql::<BigInt>("count(*)")))
             .group_by(ds::shard)
-            .order_by(sql::<i64>("count(*)"))
-            .load::<(String, i64)>(self.conn.as_ref())?;
+            .order_by(sql::<BigInt>("count(*)"))
+            .load::<(String, i64)>(conn)
+            .await?;
 
         // Any shards that have no deployments in them will not be in
         // 'used'; add them in with a count of 0
@@ -1500,12 +1744,12 @@ impl<'a> Connection<'a> {
             .map(|(shard, _)| Shard::new(shard.to_string()))
             .transpose()
             // This can't really happen since we filtered by valid shards
-            .map_err(|e| constraint_violation!("database has illegal shard name: {}", e))
+            .map_err(|e| internal_error!("database has illegal shard name: {}", e))
     }
 
     #[cfg(debug_assertions)]
-    pub fn versions_for_subgraph(
-        &self,
+    pub async fn versions_for_subgraph(
+        &mut self,
         name: &str,
     ) -> Result<(Option<String>, Option<String>), StoreError> {
         use subgraph as s;
@@ -1513,26 +1757,31 @@ impl<'a> Connection<'a> {
         Ok(s::table
             .select((s::current_version.nullable(), s::pending_version.nullable()))
             .filter(s::name.eq(&name))
-            .first::<(Option<String>, Option<String>)>(self.conn.as_ref())
+            .first::<(Option<String>, Option<String>)>(&mut self.conn)
+            .await
             .optional()?
             .unwrap_or((None, None)))
     }
 
     #[cfg(debug_assertions)]
-    pub fn deployment_for_version(&self, name: &str) -> Result<Option<String>, StoreError> {
+    pub async fn deployment_for_version(
+        &mut self,
+        name: &str,
+    ) -> Result<Option<String>, StoreError> {
         use subgraph_version as v;
 
         Ok(v::table
             .select(v::deployment)
             .filter(v::id.eq(name))
-            .first::<String>(self.conn.as_ref())
+            .first::<String>(&mut self.conn)
+            .await
             .optional()?)
     }
 
     /// Find all deployments that are not in use and add them to the
     /// `unused_deployments` table. Only values that are available in the
     /// primary will be filled in `unused_deployments`
-    pub fn detect_unused_deployments(&self) -> Result<Vec<Site>, StoreError> {
+    pub async fn detect_unused_deployments(&mut self) -> Result<Vec<Site>, StoreError> {
         use active_copies as cp;
         use deployment_schemas as ds;
         use subgraph as s;
@@ -1540,6 +1789,7 @@ impl<'a> Connection<'a> {
         use subgraph_version as v;
         use unused_deployments as u;
 
+        let conn = &mut self.conn;
         // Deployment is assigned
         let assigned = a::table.filter(a::id.eq(ds::id));
         // Deployment is current or pending version
@@ -1593,22 +1843,24 @@ impl<'a> Connection<'a> {
             .on_conflict(u::id)
             .do_nothing()
             .returning(u::id)
-            .get_results::<DeploymentId>(self.conn.as_ref())?;
+            .get_results::<DeploymentId>(conn)
+            .await?;
 
         // We need to load again since we do not record the network in
         // unused_deployments
         ds::table
             .filter(ds::id.eq_any(ids))
             .select(ds::all_columns)
-            .load::<Schema>(self.conn.as_ref())?
+            .load::<Schema>(conn)
+            .await?
             .into_iter()
             .map(Site::try_from)
             .collect()
     }
 
     /// Add details from the deployment shard to unused deployments
-    pub fn update_unused_deployments(
-        &self,
+    pub async fn update_unused_deployments(
+        &mut self,
         details: &[DeploymentDetail],
     ) -> Result<(), StoreError> {
         use crate::detail::block;
@@ -1616,10 +1868,10 @@ impl<'a> Connection<'a> {
 
         for detail in details {
             let (latest_hash, latest_number) = block(
-                &detail.deployment,
+                &detail.subgraph,
                 "latest_ethereum_block",
-                detail.latest_ethereum_block_hash.clone(),
-                detail.latest_ethereum_block_number.clone(),
+                detail.block_hash.clone(),
+                detail.block_number,
             )?
             .map(|b| b.to_ptr())
             .map(|ptr| (Some(Vec::from(ptr.hash_slice())), Some(ptr.number)))
@@ -1632,9 +1884,11 @@ impl<'a> Connection<'a> {
                     u::latest_ethereum_block_hash.eq(latest_hash),
                     u::latest_ethereum_block_number.eq(latest_number),
                     u::failed.eq(detail.failed),
-                    u::synced.eq(detail.synced),
+                    u::synced_at.eq(detail.synced_at),
+                    u::synced_at_block_number.eq(detail.synced_at_block_number),
                 ))
-                .execute(self.conn.as_ref())?;
+                .execute(&mut self.conn)
+                .await?;
         }
         Ok(())
     }
@@ -1642,88 +1896,116 @@ impl<'a> Connection<'a> {
     /// The deployment `site` that we marked as unused previously is in fact
     /// now used again, e.g., because it was redeployed in between recording
     /// it as unused and now. Remove it from the `unused_deployments` table
-    pub fn unused_deployment_is_used(&self, site: &Site) -> Result<(), StoreError> {
+    pub async fn unused_deployment_is_used(&mut self, site: &Site) -> Result<(), StoreError> {
         use unused_deployments as u;
         delete(u::table.filter(u::id.eq(site.id)))
-            .execute(self.conn.as_ref())
+            .execute(&mut self.conn)
+            .await
             .map(|_| ())
             .map_err(StoreError::from)
     }
 
-    pub fn list_unused_deployments(
-        &self,
+    pub async fn list_unused_deployments(
+        &mut self,
         filter: unused::Filter,
     ) -> Result<Vec<UnusedDeployment>, StoreError> {
         use unused::Filter::*;
         use unused_deployments as u;
 
+        let conn = &mut self.conn;
         match filter {
-            All => Ok(u::table
-                .order_by(u::unused_at.desc())
-                .load(self.conn.as_ref())?),
+            All => Ok(u::table.order_by(u::unused_at.desc()).load(conn).await?),
             New => Ok(u::table
                 .filter(u::removed_at.is_null())
                 .order_by(u::entity_count)
-                .load(self.conn.as_ref())?),
+                .load(conn)
+                .await?),
             UnusedLongerThan(duration) => {
                 let ts = chrono::offset::Local::now()
                     .checked_sub_signed(duration)
                     .ok_or_else(|| {
-                        StoreError::ConstraintViolation(format!(
-                            "duration {} is too large",
-                            duration
-                        ))
+                        StoreError::InternalError(format!("duration {} is too large", duration))
                     })?;
                 Ok(u::table
                     .filter(u::removed_at.is_null())
                     .filter(u::unused_at.lt(ts))
                     .order_by(u::entity_count)
-                    .load(self.conn.as_ref())?)
+                    .load(conn)
+                    .await?)
             }
+
+            Name(name) => Ok(u::table
+                .filter(u::subgraphs.is_not_null())
+                .filter(
+                    sql::<Bool>("ARRAY[")
+                        .bind::<Text, _>(name)
+                        .sql("] <@ subgraphs"),
+                )
+                .order_by(u::entity_count)
+                .load(conn)
+                .await?),
+
+            Hash(hash) => Ok(u::table
+                .filter(u::deployment.eq(hash))
+                .order_by(u::entity_count)
+                .load(conn)
+                .await?),
+
+            Deployment(id) => Ok(u::table
+                .filter(u::namespace.eq(id))
+                .order_by(u::entity_count)
+                .load(conn)
+                .await?),
         }
     }
 
-    pub fn subgraphs_using_deployment(&self, site: &Site) -> Result<Vec<String>, StoreError> {
+    pub async fn subgraphs_using_deployment(
+        &mut self,
+        site: &Site,
+    ) -> Result<Vec<String>, StoreError> {
         use subgraph as s;
         use subgraph_version as v;
 
         Ok(s::table
             .inner_join(
-                v::table.on(v::subgraph
+                v::table.on(v::id
                     .nullable()
                     .eq(s::current_version)
-                    .or(v::subgraph.nullable().eq(s::pending_version))),
+                    .or(v::id.nullable().eq(s::pending_version))),
             )
             .filter(v::deployment.eq(site.deployment.as_str()))
             .select(s::name)
             .distinct()
-            .load(self.conn.as_ref())?)
+            .load(&mut self.conn)
+            .await?)
     }
 
-    pub fn find_ens_name(&self, hash: &str) -> Result<Option<String>, StoreError> {
+    pub async fn find_ens_name(&mut self, hash: &str) -> Result<Option<String>, StoreError> {
         use ens_names as dsl;
 
         dsl::table
             .select(dsl::name)
             .find(hash)
-            .get_result::<String>(self.conn.as_ref())
+            .get_result::<String>(&mut self.conn)
+            .await
             .optional()
             .map_err(|e| anyhow!("error looking up ens_name for hash {}: {}", hash, e).into())
     }
 
-    pub fn is_ens_table_empty(&self) -> Result<bool, StoreError> {
+    pub async fn is_ens_table_empty(&mut self) -> Result<bool, StoreError> {
         use ens_names as dsl;
 
         dsl::table
             .select(dsl::name)
             .limit(1)
-            .get_result::<String>(self.conn.as_ref())
+            .get_result::<String>(&mut self.conn)
+            .await
             .optional()
             .map(|r| r.is_none())
             .map_err(|e| anyhow!("error if ens table is empty: {}", e).into())
     }
 
-    pub fn record_active_copy(&self, src: &Site, dst: &Site) -> Result<(), StoreError> {
+    pub async fn record_active_copy(&mut self, src: &Site, dst: &Site) -> Result<(), StoreError> {
         use active_copies as cp;
 
         insert_into(cp::table)
@@ -1733,28 +2015,79 @@ impl<'a> Connection<'a> {
                 cp::queued_at.eq(sql("now()")),
             ))
             .on_conflict_do_nothing()
-            .execute(self.conn.as_ref())?;
+            .execute(&mut self.conn)
+            .await?;
 
         Ok(())
     }
 
-    pub fn copy_finished(&self, dst: &Site) -> Result<(), StoreError> {
+    pub async fn copy_finished(&mut self, dst: &Site) -> Result<(), StoreError> {
         use active_copies as cp;
 
-        delete(cp::table.filter(cp::dst.eq(dst.id))).execute(self.conn.as_ref())?;
+        delete(cp::table.filter(cp::dst.eq(dst.id)))
+            .execute(&mut self.conn)
+            .await?;
 
         Ok(())
     }
 }
 
+/// A limited interface to query the primary database.
+#[derive(Clone, CheapClone)]
+pub struct Primary {
+    pool: Arc<ConnectionPool>,
+}
+
+impl Primary {
+    pub fn new(pool: Arc<ConnectionPool>) -> Self {
+        // This really indicates a programming error
+        if pool.shard != *PRIMARY_SHARD {
+            panic!("Primary pool must be the primary shard");
+        }
+
+        Primary { pool }
+    }
+
+    /// Return `true` if the site is the source of a copy operation. The copy
+    /// operation might be just queued or in progress already. This method will
+    /// block until a fdw connection becomes available.
+    pub async fn is_source(&self, site: &Site) -> Result<bool, StoreError> {
+        use active_copies as ac;
+
+        let mut conn = self.pool.get_permitted().await?;
+
+        select(diesel::dsl::exists(
+            ac::table
+                .filter(ac::src.eq(site.id))
+                .filter(ac::cancelled_at.is_null()),
+        ))
+        .get_result::<bool>(&mut conn)
+        .await
+        .map_err(StoreError::from)
+    }
+
+    pub async fn is_copy_cancelled(&self, dst: &Site) -> Result<bool, StoreError> {
+        use active_copies as ac;
+
+        let mut conn = self.pool.get_permitted().await?;
+
+        ac::table
+            .filter(ac::dst.eq(dst.id))
+            .select(ac::cancelled_at.is_not_null())
+            .get_result::<bool>(&mut conn)
+            .await
+            .map_err(StoreError::from)
+    }
+}
+
 /// Return `true` if we deem this installation to be empty, defined as
 /// having no deployments and no subgraph names in the database
-pub fn is_empty(conn: &PgConnection) -> Result<bool, StoreError> {
+pub async fn is_empty(conn: &mut AsyncPgConnection) -> Result<bool, StoreError> {
     use deployment_schemas as ds;
     use subgraph as s;
 
-    let empty = ds::table.count().get_result::<i64>(conn)? == 0
-        && s::table.count().get_result::<i64>(conn)? == 0;
+    let empty = ds::table.count().get_result::<i64>(conn).await? == 0
+        && s::table.count().get_result::<i64>(conn).await? == 0;
     Ok(empty)
 }
 
@@ -1762,11 +2095,26 @@ pub fn is_empty(conn: &PgConnection) -> Result<bool, StoreError> {
 /// a query returns either success or anything but a
 /// `Err(StoreError::DatabaseUnavailable)`. This only works for tables that
 /// are mirrored through `refresh_tables`
+#[derive(Clone, CheapClone)]
 pub struct Mirror {
-    pools: Vec<ConnectionPool>,
+    pools: Arc<Vec<ConnectionPool>>,
 }
 
 impl Mirror {
+    // The tables that we mirror
+    //
+    // `chains` needs to be mirrored before `deployment_schemas` because
+    // of the fk constraint on `deployment_schemas.network`. We don't
+    // care much about mirroring `active_copies` but it has a fk
+    // constraint on `deployment_schemas` and is tiny, therefore it's
+    // easiest to just mirror it
+    pub(crate) const PUBLIC_TABLES: [&str; 3] = ["chains", "deployment_schemas", "active_copies"];
+    pub(crate) const SUBGRAPHS_TABLES: [&str; 3] = [
+        "subgraph_deployment_assignment",
+        "subgraph",
+        "subgraph_version",
+    ];
+
     pub fn new(pools: &HashMap<Shard, ConnectionPool>) -> Mirror {
         let primary = pools
             .get(&PRIMARY_SHARD)
@@ -1779,6 +2127,7 @@ impl Mirror {
                 pools.push(pool.clone());
                 pools
             });
+        let pools = Arc::new(pools);
         Mirror { pools }
     }
 
@@ -1787,28 +2136,30 @@ impl Mirror {
     /// used for non-critical uses like command line tools
     pub fn primary_only(primary: ConnectionPool) -> Mirror {
         Mirror {
-            pools: vec![primary],
+            pools: Arc::new(vec![primary]),
         }
     }
 
-    /// Execute the function `f` with connections from each of our pools in
+    /// Execute the `callback` with connections from each of our pools in
     /// order until for one of them we get any result other than
     /// `Err(StoreError::DatabaseUnavailable)`. In other words, we try to
-    /// execute `f` against our pools in order until we can be sure that we
-    /// talked to a database that is up. The function `f` must only access
-    /// tables that are mirrored through `refresh_tables`
-    pub(crate) fn read<'a, T>(
-        &self,
-        mut f: impl 'a
-            + FnMut(&PooledConnection<ConnectionManager<PgConnection>>) -> Result<T, StoreError>,
-    ) -> Result<T, StoreError> {
-        for pool in &self.pools {
-            let conn = match pool.get() {
+    /// execute `callback` against our pools in order until we can be sure
+    /// that we talked to a database that is up. The function `callback`
+    /// must only access tables that are mirrored through `refresh_tables`
+    ///
+    /// The function `callback` must not do any blocking work itself
+    pub(crate) async fn read_async<R, F>(&self, mut callback: F) -> Result<R, StoreError>
+    where
+        F: TxnMutCallback<R, StoreError> + Send,
+        R: Send,
+    {
+        for pool in self.pools.as_ref() {
+            let mut conn = match pool.get_permitted().await {
                 Ok(conn) => conn,
                 Err(StoreError::DatabaseUnavailable) => continue,
                 Err(e) => return Err(e),
             };
-            match f(&conn) {
+            match callback(&mut conn).await {
                 Ok(v) => return Ok(v),
                 Err(StoreError::DatabaseUnavailable) => continue,
                 Err(e) => return Err(e),
@@ -1819,28 +2170,13 @@ impl Mirror {
 
     /// Refresh the contents of mirrored tables from the primary (through
     /// the fdw mapping that `ForeignServer` establishes)
-    pub(crate) fn refresh_tables(
-        conn: &PgConnection,
-        handle: &CancelHandle,
-    ) -> Result<(), StoreError> {
-        // `chains` needs to be mirrored before `deployment_schemas` because
-        // of the fk constraint on `deployment_schemas.network`. We don't
-        // care much about mirroring `active_copies` but it has a fk
-        // constraint on `deployment_schemas` and is tiny, therefore it's
-        // easiest to just mirror it
-        const PUBLIC_TABLES: [&str; 3] = ["chains", "deployment_schemas", "active_copies"];
-        const SUBGRAPHS_TABLES: [&str; 3] = [
-            "subgraph_deployment_assignment",
-            "subgraph",
-            "subgraph_version",
-        ];
-
-        fn run_query(conn: &PgConnection, query: String) -> Result<(), StoreError> {
-            conn.batch_execute(&query).map_err(StoreError::from)
+    pub(crate) async fn refresh_tables(conn: &mut AsyncPgConnection) -> Result<(), StoreError> {
+        async fn run_query(conn: &mut AsyncPgConnection, query: String) -> Result<(), StoreError> {
+            conn.batch_execute(&query).await.map_err(StoreError::from)
         }
 
-        fn copy_table(
-            conn: &PgConnection,
+        async fn copy_table(
+            conn: &mut AsyncPgConnection,
             src_nsp: &str,
             dst_nsp: &str,
             table_name: &str,
@@ -1854,41 +2190,35 @@ impl Mirror {
                     table_name = table_name
                 ),
             )
+            .await
         }
 
-        let check_cancel = || {
-            if handle.is_canceled() {
-                Err(StoreError::Canceled)
-            } else {
-                Ok(())
-            }
-        };
+        // Prevent FDW zombie connections from holding ACCESS EXCLUSIVE locks
+        // indefinitely. lock_timeout prevents TRUNCATE stampede when multiple
+        // nodes mirror simultaneously. statement_timeout kills stuck FDW
+        // queries. SET LOCAL scopes these to this transaction only.
+        conn.batch_execute("SET LOCAL statement_timeout = '60s'; SET LOCAL lock_timeout = '10s';")
+            .await
+            .map_err(StoreError::from)?;
 
         // Truncate all tables at once, otherwise truncation can fail
         // because of foreign key constraints
-        let tables = PUBLIC_TABLES
+        let tables = Self::PUBLIC_TABLES
             .iter()
             .map(|name| (NAMESPACE_PUBLIC, name))
             .chain(
-                SUBGRAPHS_TABLES
+                Self::SUBGRAPHS_TABLES
                     .iter()
                     .map(|name| (NAMESPACE_SUBGRAPHS, name)),
             )
             .map(|(nsp, name)| format!("{}.{}", nsp, name))
             .join(", ");
         let query = format!("truncate table {};", tables);
-        conn.batch_execute(&query)?;
-        check_cancel()?;
+        conn.batch_execute(&query).await?;
 
         // Repopulate `PUBLIC_TABLES` by copying their data wholesale
-        for table_name in PUBLIC_TABLES {
-            copy_table(
-                conn,
-                ForeignServer::PRIMARY_PUBLIC,
-                NAMESPACE_PUBLIC,
-                table_name,
-            )?;
-            check_cancel()?;
+        for table_name in Self::PUBLIC_TABLES {
+            copy_table(conn, PRIMARY_PUBLIC, NAMESPACE_PUBLIC, table_name).await?;
         }
 
         // Repopulate `SUBGRAPHS_TABLES` but only copy the data we actually
@@ -1903,7 +2233,8 @@ impl Mirror {
                      select * from {src_nsp}.subgraph
                      where current_version is not null;"
             ),
-        )?;
+        )
+        .await?;
         run_query(
             conn,
             format!(
@@ -1911,8 +2242,9 @@ impl Mirror {
                  select v.* from {src_nsp}.subgraph_version v, {src_nsp}.subgraph s
                   where v.id = s.current_version;"
             ),
-        )?;
-        copy_table(conn, &src_nsp, dst_nsp, "subgraph_deployment_assignment")?;
+        )
+        .await?;
+        copy_table(conn, &src_nsp, dst_nsp, "subgraph_deployment_assignment").await?;
 
         Ok(())
     }
@@ -1925,97 +2257,132 @@ impl Mirror {
         &self.pools[0]
     }
 
-    pub fn assignments(&self, node: &NodeId) -> Result<Vec<Site>, StoreError> {
-        self.read(|conn| queries::assignments(conn, node))
+    pub async fn assignments(&self, node: &NodeId) -> Result<Vec<Site>, StoreError> {
+        self.read_async(async |conn| queries::assignments(conn, node).await)
+            .await
     }
 
-    pub fn active_assignments(&self, node: &NodeId) -> Result<Vec<Site>, StoreError> {
-        self.read(|conn| queries::active_assignments(conn, node))
+    pub async fn active_assignments(&self, node: &NodeId) -> Result<Vec<Site>, StoreError> {
+        self.read_async(async |conn| queries::active_assignments(conn, node).await)
+            .await
     }
 
-    pub fn assigned_node(&self, site: &Site) -> Result<Option<NodeId>, StoreError> {
-        self.read(|conn| queries::assigned_node(conn, site))
+    pub async fn assigned_node(&self, site: &Site) -> Result<Option<NodeId>, StoreError> {
+        self.read_async(async |conn| queries::assigned_node(conn, site).await)
+            .await
     }
 
     /// Returns Option<(node_id,is_paused)> where `node_id` is the node that
     /// the subgraph is assigned to, and `is_paused` is true if the
     /// subgraph is paused.
     /// Returns None if the deployment does not exist.
-    pub fn assignment_status(&self, site: &Site) -> Result<Option<(NodeId, bool)>, StoreError> {
-        self.read(|conn| queries::assignment_status(conn, site))
+    pub async fn assignment_status(
+        &self,
+        site: Arc<Site>,
+    ) -> Result<Option<(NodeId, bool)>, StoreError> {
+        self.read_async(async |conn| queries::assignment_status(conn, &site).await)
+            .await
     }
 
-    pub fn find_active_site(&self, subgraph: &DeploymentHash) -> Result<Option<Site>, StoreError> {
-        self.read(|conn| queries::find_active_site(conn, subgraph))
+    pub async fn find_active_site(
+        &self,
+        subgraph: &DeploymentHash,
+    ) -> Result<Option<Site>, StoreError> {
+        self.read_async(async |conn| queries::find_active_site(conn, subgraph).await)
+            .await
     }
 
-    pub fn find_site_by_ref(&self, id: DeploymentId) -> Result<Option<Site>, StoreError> {
-        self.read(|conn| queries::find_site_by_ref(conn, id))
+    pub async fn find_site_by_ref(&self, id: DeploymentId) -> Result<Option<Site>, StoreError> {
+        self.read_async(async |conn| queries::find_site_by_ref(conn, id).await)
+            .await
     }
 
-    pub fn current_deployment_for_subgraph(
+    pub async fn current_deployment_for_subgraph(
         &self,
         name: &SubgraphName,
     ) -> Result<DeploymentHash, StoreError> {
-        self.read(|conn| queries::current_deployment_for_subgraph(conn, name))
+        self.read_async(async |conn| queries::current_deployment_for_subgraph(conn, name).await)
+            .await
     }
 
-    pub fn deployments_for_subgraph(&self, name: &str) -> Result<Vec<Site>, StoreError> {
-        self.read(|conn| queries::deployments_for_subgraph(conn, name))
+    pub async fn deployments_for_subgraph(&self, name: &str) -> Result<Vec<Site>, StoreError> {
+        self.read_async(async |conn| queries::deployments_for_subgraph(conn, name).await)
+            .await
     }
 
-    pub fn subgraph_exists(&self, name: &SubgraphName) -> Result<bool, StoreError> {
-        self.read(|conn| queries::subgraph_exists(conn, name))
+    pub async fn subgraph_exists(&self, name: &SubgraphName) -> Result<bool, StoreError> {
+        self.read_async(async |conn| queries::subgraph_exists(conn, name).await)
+            .await
     }
 
-    pub fn subgraph_version(
+    pub async fn subgraph_version(
         &self,
         name: &str,
         use_current: bool,
     ) -> Result<Option<Site>, StoreError> {
-        self.read(|conn| queries::subgraph_version(conn, name, use_current))
+        self.read_async(async |conn| queries::subgraph_version(conn, name, use_current).await)
+            .await
     }
 
     /// Find sites by their subgraph deployment hashes. If `ids` is empty,
     /// return all sites
-    pub fn find_sites(&self, ids: &[String], only_active: bool) -> Result<Vec<Site>, StoreError> {
-        self.read(|conn| queries::find_sites(conn, ids, only_active))
+    pub async fn find_sites(
+        &self,
+        ids: &[String],
+        only_active: bool,
+    ) -> Result<Vec<Site>, StoreError> {
+        self.read_async(async |conn| queries::find_sites(conn, ids, only_active).await)
+            .await
     }
 
     /// Find sites by their subgraph deployment ids. If `ids` is empty,
     /// return no sites
-    pub fn find_sites_by_id(&self, ids: &[DeploymentId]) -> Result<Vec<Site>, StoreError> {
-        self.read(|conn| queries::find_sites_by_id(conn, ids))
+    pub async fn find_sites_by_id(&self, ids: &[DeploymentId]) -> Result<Vec<Site>, StoreError> {
+        self.read_async(async |conn| queries::find_sites_by_id(conn, ids).await)
+            .await
     }
 
-    pub fn fill_assignments(&self, infos: &mut [status::Info]) -> Result<(), StoreError> {
-        self.read(|conn| queries::fill_assignments(conn, infos))
+    pub async fn fill_assignments(
+        &self,
+        infos: &[status::Info],
+    ) -> Result<HashMap<GraphDeploymentId, (String, bool)>, StoreError> {
+        self.read_async(async |conn| queries::fill_assignments(conn, infos).await)
+            .await
     }
 
-    pub fn version_info(&self, version: &str) -> Result<Option<(String, String)>, StoreError> {
-        self.read(|conn| queries::version_info(conn, version))
+    pub async fn version_info(
+        &self,
+        version: &str,
+    ) -> Result<Option<(String, String)>, StoreError> {
+        self.read_async(async |conn| queries::version_info(conn, version).await)
+            .await
     }
 
-    pub fn versions_for_subgraph_id(
+    pub async fn versions_for_subgraph_id(
         &self,
         subgraph_id: &str,
     ) -> Result<(Option<String>, Option<String>), StoreError> {
-        self.read(|conn| queries::versions_for_subgraph_id(conn, subgraph_id))
+        self.read_async(async |conn| queries::versions_for_subgraph_id(conn, subgraph_id).await)
+            .await
     }
 
     /// Returns all (subgraph_name, version) pairs for a given deployment hash.
-    pub fn subgraphs_by_deployment_hash(
+    pub async fn subgraphs_by_deployment_hash(
         &self,
         deployment_hash: &str,
     ) -> Result<Vec<(String, String)>, StoreError> {
-        self.read(|conn| queries::subgraphs_by_deployment_hash(conn, deployment_hash))
+        self.read_async(async |conn| {
+            queries::subgraphs_by_deployment_hash(conn, deployment_hash).await
+        })
+        .await
     }
 
-    pub fn find_site_in_shard(
+    pub async fn find_site_in_shard(
         &self,
         subgraph: &DeploymentHash,
         shard: &Shard,
     ) -> Result<Option<Site>, StoreError> {
-        self.read(|conn| queries::find_site_in_shard(conn, subgraph, shard))
+        self.read_async(async |conn| queries::find_site_in_shard(conn, subgraph, shard).await)
+            .await
     }
 }
diff --git a/store/postgres/src/query_store.rs b/store/postgres/src/query_store.rs
index 16624550663..f36ac542799 100644
--- a/store/postgres/src/query_store.rs
+++ b/store/postgres/src/query_store.rs
@@ -1,9 +1,12 @@
+use std::collections::HashMap;
 use std::time::Instant;
 
 use crate::deployment_store::{DeploymentStore, ReplicaId};
+use crate::sql::Parser;
+use async_trait::async_trait;
 use graph::components::store::{DeploymentId, QueryPermit, QueryStore as QueryStoreTrait};
 use graph::data::query::Trace;
-use graph::data::store::QueryObject;
+use graph::data::store::{QueryObject, SqlQueryObject};
 use graph::prelude::*;
 use graph::schema::{ApiSchema, InputSchema};
 
@@ -15,47 +18,83 @@ pub(crate) struct QueryStore {
     store: Arc<DeploymentStore>,
     chain_store: Arc<crate::ChainStore>,
     api_version: Arc<ApiVersion>,
+    sql_parser: Result<Parser, StoreError>,
 }
 
 impl QueryStore {
-    pub(crate) fn new(
+    pub(crate) async fn new(
         store: Arc<DeploymentStore>,
         chain_store: Arc<crate::ChainStore>,
         site: Arc<Site>,
         replica_id: ReplicaId,
         api_version: Arc<ApiVersion>,
     ) -> Self {
+        let sql_parser = store
+            .find_layout(site.clone())
+            .await
+            .map(|layout| Parser::new(layout, BLOCK_NUMBER_MAX));
         QueryStore {
             site,
             replica_id,
             store,
             chain_store,
             api_version,
+            sql_parser,
         }
     }
 }
 
 #[async_trait]
 impl QueryStoreTrait for QueryStore {
-    fn find_query_values(
+    async fn find_query_values(
         &self,
         query: EntityQuery,
     ) -> Result<(Vec<QueryObject>, Trace), graph::prelude::QueryExecutionError> {
         assert_eq!(&self.site.deployment, &query.subgraph_id);
         let start = Instant::now();
-        let conn = self
+        let mut conn = self
             .store
             .get_replica_conn(self.replica_id)
+            .await
             .map_err(|e| QueryExecutionError::StoreError(e.into()))?;
         let wait = start.elapsed();
         self.store
-            .execute_query(&conn, self.site.clone(), query)
+            .execute_query(&mut conn, self.site.clone(), query)
+            .await
             .map(|(entities, mut trace)| {
                 trace.conn_wait(wait);
                 (entities, trace)
             })
     }
 
+    async fn execute_sql(
+        &self,
+        sql: &str,
+    ) -> Result<Vec<SqlQueryObject>, graph::prelude::QueryExecutionError> {
+        // Check if SQL queries are enabled
+        if !ENV_VARS.sql_queries_enabled() {
+            return Err(QueryExecutionError::SqlError(
+                "SQL queries are disabled. Set GRAPH_ENABLE_SQL_QUERIES=true to enable."
+                    .to_string(),
+            ));
+        }
+
+        let mut conn = self
+            .store
+            .get_replica_conn(self.replica_id)
+            .await
+            .map_err(|e| QueryExecutionError::SqlError(format!("SQL error: {}", e)))?;
+
+        let parser = self
+            .sql_parser
+            .as_ref()
+            .map_err(|e| QueryExecutionError::SqlError(format!("SQL error: {}", e)))?;
+
+        let sql = parser.parse_and_validate(sql)?;
+
+        self.store.execute_sql(&mut conn, &sql).await
+    }
+
     /// Return true if the deployment with the given id is fully synced,
     /// and return false otherwise. Errors from the store are passed back up
     async fn is_deployment_synced(&self) -> Result<bool, Error> {
@@ -68,10 +107,10 @@ impl QueryStoreTrait for QueryStore {
     async fn block_ptr(&self) -> Result<Option<BlockPtr>, StoreError> {
         self.store.block_ptr(self.site.cheap_clone()).await
     }
-    async fn block_number_with_timestamp(
+    async fn block_number_with_timestamp_and_parent_hash(
         &self,
         block_hash: &BlockHash,
-    ) -> Result<Option<(BlockNumber, Option<u64>)>, StoreError> {
+    ) -> Result<Option<(BlockNumber, Option<u64>, Option<BlockHash>)>, StoreError> {
         // We should also really check that the block with the given hash is
         // on the chain starting at the subgraph's current head. That check is
         // very expensive though with the data structures we have currently
@@ -82,9 +121,9 @@ impl QueryStoreTrait for QueryStore {
         self.chain_store
             .block_number(block_hash)
             .await?
-            .map(|(network_name, number, timestamp)| {
+            .map(|(network_name, number, timestamp, parent_hash)| {
                 if network_name == subgraph_network {
-                    Ok((number, timestamp))
+                    Ok((number, timestamp, parent_hash))
                 } else {
                     Err(StoreError::QueryExecutionError(format!(
                         "subgraph {} belongs to network {} but block {:x} belongs to network {}",
@@ -99,46 +138,41 @@ impl QueryStoreTrait for QueryStore {
         &self,
         block_hash: &BlockHash,
     ) -> Result<Option<BlockNumber>, StoreError> {
-        self.block_number_with_timestamp(block_hash)
+        self.block_number_with_timestamp_and_parent_hash(block_hash)
             .await
-            .map(|opt| opt.map(|(number, _)| number))
+            .map(|opt| opt.map(|(number, _, _)| number))
     }
 
-    fn wait_stats(&self) -> Result<PoolWaitStats, StoreError> {
-        self.store.wait_stats(self.replica_id)
+    async fn block_numbers(
+        &self,
+        block_hashes: Vec<BlockHash>,
+    ) -> Result<HashMap<BlockHash, BlockNumber>, StoreError> {
+        self.chain_store.block_numbers(block_hashes).await
     }
 
-    async fn has_deterministic_errors(&self, block: BlockNumber) -> Result<bool, StoreError> {
-        let id = self.site.deployment.clone();
-        self.store
-            .with_conn(move |conn, _| {
-                crate::deployment::has_deterministic_errors(conn, &id, block).map_err(|e| e.into())
-            })
-            .await
+    fn wait_stats(&self) -> PoolWaitStats {
+        self.store.wait_stats(self.replica_id)
     }
 
     async fn deployment_state(&self) -> Result<DeploymentState, QueryExecutionError> {
-        Ok(self
-            .store
-            .deployment_state_from_id(self.site.deployment.clone())
-            .await?)
+        Ok(self.store.deployment_state(self.site.cheap_clone()).await?)
     }
 
-    fn api_schema(&self) -> Result<Arc<ApiSchema>, QueryExecutionError> {
-        let info = self.store.subgraph_info(&self.site)?;
+    async fn api_schema(&self) -> Result<Arc<ApiSchema>, QueryExecutionError> {
+        let info = self.store.subgraph_info(self.site.cheap_clone()).await?;
         Ok(info.api.get(&self.api_version).unwrap().clone())
     }
 
-    fn input_schema(&self) -> Result<InputSchema, QueryExecutionError> {
-        let info = self.store.subgraph_info(&self.site)?;
-        Ok(info.input)
+    async fn input_schema(&self) -> Result<InputSchema, QueryExecutionError> {
+        let layout = self.store.find_layout(self.site.cheap_clone()).await?;
+        Ok(layout.input_schema.cheap_clone())
     }
 
     fn network_name(&self) -> &str {
         &self.site.network
     }
 
-    async fn query_permit(&self) -> Result<QueryPermit, StoreError> {
+    async fn query_permit(&self) -> QueryPermit {
         self.store.query_permit(self.replica_id).await
     }
 
diff --git a/store/postgres/src/relational.rs b/store/postgres/src/relational.rs
index 04a61c57936..4059e736635 100644
--- a/store/postgres/src/relational.rs
+++ b/store/postgres/src/relational.rs
@@ -14,30 +14,36 @@ mod ddl_tests;
 #[cfg(test)]
 mod query_tests;
 
+pub(crate) mod dsl;
+pub(crate) mod dump;
 pub(crate) mod index;
-mod prune;
-mod rollup;
+pub(crate) mod prune;
+pub(crate) mod restore;
+pub(crate) mod rollup;
+pub(crate) mod value;
 
+use diesel::deserialize::FromSql;
 use diesel::pg::Pg;
-use diesel::serialize::Output;
+use diesel::serialize::{Output, ToSql};
 use diesel::sql_types::Text;
-use diesel::types::{FromSql, ToSql};
-use diesel::{connection::SimpleConnection, Connection};
-use diesel::{debug_query, OptionalExtension, PgConnection, QueryResult, RunQueryDsl};
+use diesel::{OptionalExtension, QueryDsl, QueryResult, debug_query, sql_query};
+use diesel_async::{AsyncConnection, RunQueryDsl, SimpleAsyncConnection};
+
 use graph::blockchain::BlockTime;
+use graph::blockchain::block_stream::{EntityOperationKind, EntitySourceOperation};
 use graph::cheap_clone::CheapClone;
-use graph::components::store::write::RowGroup;
-use graph::components::subgraph::PoICausalityRegion;
-use graph::constraint_violation;
+use graph::components::store::write::{RowGroup, WriteChunk};
 use graph::data::graphql::TypeExt as _;
 use graph::data::query::Trace;
 use graph::data::value::Word;
 use graph::data_source::CausalityRegion;
-use graph::prelude::{q, EntityQuery, StopwatchMetrics, ENV_VARS};
+use graph::internal_error;
+use graph::prelude::{ENV_VARS, EntityQuery, StopwatchMetrics, q};
 use graph::schema::{
-    EntityKey, EntityType, Field, FulltextConfig, FulltextDefinition, InputSchema,
+    AggregationInterval, EntityKey, EntityType, Field, FulltextConfig, FulltextDefinition,
+    InputSchema,
 };
-use graph::slog::warn;
+use graph::slog::{debug, warn};
 use inflector::Inflector;
 use itertools::Itertools;
 use lazy_static::lazy_static;
@@ -45,30 +51,35 @@ use std::borrow::Borrow;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::convert::{From, TryFrom};
 use std::fmt::{self, Write};
+use std::ops::Range;
 use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
-use crate::relational_queries::{FindChangesQuery, FindDerivedQuery, FindPossibleDeletionsQuery};
+use crate::relational::value::{FromOidRow, OidRow};
+use crate::relational_queries::{
+    ConflictingEntitiesData, ConflictingEntitiesQuery, EntityDataExt, FindChangesQuery,
+    FindDerivedQuery, FindPossibleDeletionsQuery, ReturnedEntityData,
+};
 use crate::{
     primary::{Namespace, Site},
     relational_queries::{
-        ClampRangeQuery, ConflictingEntityQuery, EntityData, EntityDeletion, FilterCollection,
-        FilterQuery, FindManyQuery, FindQuery, InsertQuery, RevertClampQuery, RevertRemoveQuery,
+        ClampRangeQuery, EntityData, EntityDeletion, FilterCollection, FilterQuery, FindManyQuery,
+        FindRangeQuery, InsertQuery, RevertClampQuery, RevertRemoveQuery,
     },
 };
-use graph::components::store::DerivedEntityQuery;
-use graph::data::store::{Id, IdList, IdType, BYTES_SCALAR};
+use graph::components::store::{AttributeNames, DerivedEntityQuery};
+use graph::data::store::{BYTES_SCALAR, IdList, IdType};
 use graph::data::subgraph::schema::POI_TABLE;
 use graph::prelude::{
-    anyhow, info, BlockNumber, DeploymentHash, Entity, EntityChange, EntityOperation, Logger,
-    QueryExecutionError, StoreError, StoreEvent, ValueType, BLOCK_NUMBER_MAX,
+    BlockNumber, DeploymentHash, Entity, EntityOperation, Logger, QueryExecutionError, StoreError,
+    ValueType, anyhow, info,
 };
 
-use crate::block_range::{BLOCK_COLUMN, BLOCK_RANGE_COLUMN};
+use crate::ForeignServer;
+use crate::block_range::{BLOCK_COLUMN, BLOCK_RANGE_COLUMN, BoundSide, CAUSALITY_REGION_COLUMN};
 pub use crate::catalog::Catalog;
-use crate::connection_pool::ForeignServer;
-use crate::{catalog, deployment};
+use crate::{AsyncPgConnection, catalog, deployment};
 
 use self::rollup::Rollup;
 
@@ -84,7 +95,7 @@ pub const STRING_PREFIX_SIZE: usize = 256;
 pub const BYTE_ARRAY_PREFIX_SIZE: usize = 64;
 
 lazy_static! {
-    static ref STATEMENT_TIMEOUT: Option<String> = ENV_VARS
+    pub(crate) static ref STATEMENT_TIMEOUT: Option<String> = ENV_VARS
         .graphql
         .sql_statement_timeout
         .map(|duration| format!("set local statement_timeout={}", duration.as_millis()));
@@ -168,6 +179,12 @@ impl From<String> for SqlName {
     }
 }
 
+impl From<SqlName> for Word {
+    fn from(name: SqlName) -> Self {
+        Word::from(name.0)
+    }
+}
+
 impl fmt::Display for SqlName {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)
@@ -180,14 +197,20 @@ impl Borrow<str> for &SqlName {
     }
 }
 
+impl PartialEq<str> for SqlName {
+    fn eq(&self, other: &str) -> bool {
+        self.0 == other
+    }
+}
+
 impl FromSql<Text, Pg> for SqlName {
-    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
-        <String as FromSql<Text, Pg>>::from_sql(bytes).map(|s| SqlName::verbatim(s))
+    fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
+        <String as FromSql<Text, Pg>>::from_sql(bytes).map(SqlName::verbatim)
     }
 }
 
 impl ToSql<Text, Pg> for SqlName {
-    fn to_sql<W: std::io::Write>(&self, out: &mut Output<W, Pg>) -> diesel::serialize::Result {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
         <String as ToSql<Text, Pg>>::to_sql(&self.0, out)
     }
 }
@@ -208,15 +231,13 @@ pub struct Layout {
     pub tables: HashMap<EntityType, Arc<Table>>,
     /// The database schema for this subgraph
     pub catalog: Catalog,
-    /// The query to count all entities
-    pub count_query: String,
     /// How many blocks of history the subgraph should keep
     pub history_blocks: BlockNumber,
 
     pub input_schema: InputSchema,
 
     /// The rollups for aggregations in this layout
-    rollups: Vec<Rollup>,
+    pub(crate) rollups: Vec<Rollup>,
 }
 
 impl Layout {
@@ -260,32 +281,13 @@ impl Layout {
 
         if catalog.use_poi {
             tables.push(Self::make_poi_table(
-                &schema,
+                schema,
                 &catalog,
                 has_ts_tables,
                 tables.len(),
             ))
         }
 
-        let count_query = tables
-            .iter()
-            .map(|table| {
-                if table.immutable {
-                    format!(
-                        "select count(*) from \"{}\".\"{}\"",
-                        &catalog.site.namespace, table.name
-                    )
-                } else {
-                    format!(
-                        "select count(*) from \"{}\".\"{}\" where block_range @> {}",
-                        &catalog.site.namespace, table.name, BLOCK_NUMBER_MAX
-                    )
-                }
-            })
-            .collect::<Vec<_>>()
-            .join("\nunion all\n");
-        let count_query = format!("select sum(e.count) from ({}) e", count_query);
-
         let tables: HashMap<_, _> = tables
             .into_iter()
             .fold(HashMap::new(), |mut tables, table| {
@@ -293,13 +295,12 @@ impl Layout {
                 tables
             });
 
-        let rollups = Self::rollups(&tables, &schema)?;
+        let rollups = Self::rollups(&tables, schema)?;
 
         Ok(Layout {
             site,
             catalog,
             tables,
-            count_query,
             history_blocks: i32::MAX,
             input_schema: schema.cheap_clone(),
             rollups,
@@ -357,38 +358,37 @@ impl Layout {
         }
 
         let table_name = SqlName::verbatim(POI_TABLE.to_owned());
+        let nsp = catalog.site.namespace.clone();
         Table {
             object: poi_type.to_owned(),
             qualified_name: SqlName::qualified_name(&catalog.site.namespace, &table_name),
+            nsp,
             name: table_name,
             columns,
-            /// The position of this table in all the tables for this layout; this
-            /// is really only needed for the tests to make the names of indexes
-            /// predictable
+            // The position of this table in all the tables for this layout; this
+            // is really only needed for the tests to make the names of indexes
+            // predictable
             position: position as u32,
             is_account_like: false,
             immutable: false,
+            skip_duplicates: false,
             has_causality_region: false,
         }
     }
 
-    pub fn supports_proof_of_indexing(&self) -> bool {
-        self.tables.contains_key(&self.input_schema.poi_type())
-    }
-
-    pub fn create_relational_schema(
-        conn: &PgConnection,
+    pub async fn create_relational_schema(
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
         schema: &InputSchema,
         entities_with_causality_region: BTreeSet<EntityType>,
     ) -> Result<Layout, StoreError> {
         let catalog =
-            Catalog::for_creation(conn, site.cheap_clone(), entities_with_causality_region)?;
+            Catalog::for_creation(conn, site.cheap_clone(), entities_with_causality_region).await?;
         let layout = Self::new(site, schema, catalog)?;
         let sql = layout
             .as_ddl()
             .map_err(|_| StoreError::Unknown(anyhow!("failed to generate DDL for layout")))?;
-        conn.batch_execute(&sql)?;
+        conn.batch_execute(&sql).await?;
         Ok(layout)
     }
 
@@ -411,7 +411,7 @@ impl Layout {
     /// Import the database schema for this layout from its own database
     /// shard (in `self.site.shard`) into the database represented by `conn`
     /// if the schema for this layout does not exist yet
-    pub fn import_schema(&self, conn: &PgConnection) -> Result<(), StoreError> {
+    pub async fn import_schema(&self, conn: &mut AsyncPgConnection) -> Result<(), StoreError> {
         let make_query = || -> Result<String, fmt::Error> {
             let nsp = self.site.namespace.as_str();
             let srvname = ForeignServer::name(&self.site.shard);
@@ -430,7 +430,7 @@ impl Layout {
             Ok(query)
         };
 
-        if !catalog::has_namespace(conn, &self.site.namespace)? {
+        if !catalog::has_namespace(conn, &self.site.namespace).await? {
             let query = make_query().map_err(|_| {
                 StoreError::Unknown(anyhow!(
                     "failed to generate SQL to import foreign schema {}",
@@ -438,17 +438,18 @@ impl Layout {
                 ))
             })?;
 
-            conn.batch_execute(&query)?;
+            conn.batch_execute(&query).await?;
         }
         Ok(())
     }
 
-    /// Find the table with the provided `name`. The name must exactly match
-    /// the name of an existing table. No conversions of the name are done
-    pub fn table(&self, name: &SqlName) -> Option<&Table> {
+    /// Find the table with the provided `sql_name`. The name must exactly
+    /// match the name of an existing table. No conversions of the name are
+    /// done
+    pub fn table(&self, sql_name: &str) -> Option<&Table> {
         self.tables
             .values()
-            .find(|table| &table.name == name)
+            .find(|table| &table.name == sql_name)
             .map(|rc| rc.as_ref())
     }
 
@@ -458,24 +459,33 @@ impl Layout {
             .ok_or_else(|| StoreError::UnknownTable(entity.to_string()))
     }
 
-    pub fn find(
+    pub async fn find(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         key: &EntityKey,
         block: BlockNumber,
     ) -> Result<Option<Entity>, StoreError> {
-        let table = self.table_for_entity(&key.entity_type)?;
-        FindQuery::new(table.as_ref(), key, block)
-            .get_result::<EntityData>(conn)
+        let table = self.table_for_entity(&key.entity_type)?.dsl_table();
+        let columns = table.selected_columns::<Entity>(&AttributeNames::All, None)?;
+
+        let query = table
+            .select_cols(&columns)
+            .filter(table.id_eq(&key.entity_id))
+            .filter(table.at_block(block))
+            .filter(table.belongs_to_causality_region(key.causality_region));
+
+        query
+            .get_result::<OidRow>(conn)
+            .await
             .optional()?
-            .map(|entity_data| entity_data.deserialize_with_layout(self, None))
+            .map(|row| Entity::from_oid_row(row, &self.input_schema, &columns))
             .transpose()
     }
 
     // An optimization when looking up multiple entities, it will generate a single sql query using `UNION ALL`.
-    pub fn find_many(
+    pub async fn find_many(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         ids_for_type: &BTreeMap<(EntityType, CausalityRegion), IdList>,
         block: BlockNumber,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
@@ -489,14 +499,15 @@ impl Layout {
         }
         let query = FindManyQuery::new(tables, ids_for_type, block);
         let mut entities: BTreeMap<EntityKey, Entity> = BTreeMap::new();
-        for data in query.load::<EntityData>(conn)? {
+        for data in query.load::<EntityData>(conn).await? {
             let entity_type = data.entity_type(&self.input_schema);
             let entity_data: Entity = data.deserialize_with_layout(self, None)?;
 
             let key =
                 entity_type.key_in(entity_data.id(), CausalityRegion::from_entity(&entity_data));
+            #[allow(clippy::map_entry)]
             if entities.contains_key(&key) {
-                return Err(constraint_violation!(
+                return Err(internal_error!(
                     "duplicate entity {}[{}] in result set, block = {}",
                     key.entity_type,
                     key.entity_id,
@@ -509,19 +520,160 @@ impl Layout {
         Ok(entities)
     }
 
-    pub fn find_derived(
+    pub async fn find_range(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
+        entity_types: Vec<EntityType>,
+        causality_region: CausalityRegion,
+        block_range: Range<BlockNumber>,
+    ) -> Result<BTreeMap<BlockNumber, Vec<EntitySourceOperation>>, StoreError> {
+        let mut tables = vec![];
+        for et in entity_types {
+            tables.push(self.table_for_entity(&et)?.as_ref());
+        }
+        let mut entities: BTreeMap<BlockNumber, Vec<EntitySourceOperation>> = BTreeMap::new();
+
+        // Collect all entities that have their 'lower(block_range)' attribute in the
+        // interval of blocks defined by the variable block_range. For the immutable
+        // entities the respective attribute is 'block$'.
+        // Here are all entities that are created or modified in the block_range.
+        let lower_vec = FindRangeQuery::new(
+            &tables,
+            causality_region,
+            BoundSide::Lower,
+            block_range.clone(),
+        )
+        .get_results::<EntityDataExt>(conn)
+        .await
+        .optional()?
+        .unwrap_or_default();
+        // Collect all entities that have their 'upper(block_range)' attribute in the
+        // interval of blocks defined by the variable block_range. For the immutable
+        // entities no entries are returned.
+        // Here are all entities that are modified or deleted in the block_range,
+        // but will have the previous versions, i.e. in the case of an update, it's
+        // the version before the update, and lower_vec will have a corresponding
+        // entry with the new version.
+        let upper_vec =
+            FindRangeQuery::new(&tables, causality_region, BoundSide::Upper, block_range)
+                .get_results::<EntityDataExt>(conn)
+                .await
+                .optional()?
+                .unwrap_or_default();
+        let mut lower_iter = lower_vec.iter().fuse().peekable();
+        let mut upper_iter = upper_vec.iter().fuse().peekable();
+        let mut lower_now = lower_iter.next();
+        let mut upper_now = upper_iter.next();
+        // A closure to convert the entity data from the database into entity operation.
+        let transform = |ede: &EntityDataExt,
+                         entity_op: EntityOperationKind|
+         -> Result<(EntitySourceOperation, BlockNumber), StoreError> {
+            let e = EntityData::new(ede.entity.clone(), ede.data.clone());
+            let block = ede.block_number;
+            let entity_type = e.entity_type(&self.input_schema);
+            let entity = e.deserialize_with_layout::<Entity>(self, None)?;
+            let vid = ede.vid;
+            let ewt = EntitySourceOperation {
+                entity_op,
+                entity_type,
+                entity,
+                vid,
+            };
+            Ok((ewt, block))
+        };
+
+        fn compare_entity_data_ext(a: &EntityDataExt, b: &EntityDataExt) -> std::cmp::Ordering {
+            a.block_number
+                .cmp(&b.block_number)
+                .then_with(|| a.entity.cmp(&b.entity))
+                .then_with(|| a.id.cmp(&b.id))
+        }
+
+        // The algorithm is a similar to merge sort algorithm and it relays on the fact that both vectors
+        // are ordered by (block_number, entity_type, entity_id). It advances simultaneously entities from
+        // both lower_vec and upper_vec and tries to match entities that have entries in both vectors for
+        // a particular block. The match is successful if an entry in one array has the same values in the
+        // other one for the number of the block, entity type and the entity id. The comparison operation
+        // over the EntityDataExt implements that check. If there is a match it’s a modification operation,
+        // since both sides of a range are present for that block, entity type and id. If one side of the
+        // range exists and the other is missing it is a creation or deletion depending on which side is
+        // present. For immutable entities the entries in upper_vec are missing, hence they are considered
+        // having a lower bound at particular block and upper bound at infinity.
+        while lower_now.is_some() || upper_now.is_some() {
+            let (ewt, block) = match (lower_now, upper_now) {
+                (Some(lower), Some(upper)) => {
+                    match compare_entity_data_ext(lower, upper) {
+                        std::cmp::Ordering::Greater => {
+                            // we have upper bound at this block, but no lower bounds at the same block so it's deletion
+                            let (ewt, block) = transform(upper, EntityOperationKind::Delete)?;
+                            // advance upper_vec pointer
+                            upper_now = upper_iter.next();
+                            (ewt, block)
+                        }
+                        std::cmp::Ordering::Less => {
+                            // we have lower bound at this block but no upper bound at the same block so its creation
+                            let (ewt, block) = transform(lower, EntityOperationKind::Create)?;
+                            // advance lower_vec pointer
+                            lower_now = lower_iter.next();
+                            (ewt, block)
+                        }
+                        std::cmp::Ordering::Equal => {
+                            let (ewt, block) = transform(lower, EntityOperationKind::Modify)?;
+                            // advance both lower_vec and upper_vec pointers
+                            lower_now = lower_iter.next();
+                            upper_now = upper_iter.next();
+                            (ewt, block)
+                        }
+                    }
+                }
+                (Some(lower), None) => {
+                    // we have lower bound at this block but no upper bound at the same block so its creation
+                    let (ewt, block) = transform(lower, EntityOperationKind::Create)?;
+                    // advance lower_vec pointer
+                    lower_now = lower_iter.next();
+                    (ewt, block)
+                }
+                (None, Some(upper)) => {
+                    // we have upper bound at this block, but no lower bounds at all so it's deletion
+                    let (ewt, block) = transform(upper, EntityOperationKind::Delete)?;
+                    // advance upper_vec pointer
+                    upper_now = upper_iter.next();
+                    (ewt, block)
+                }
+                _ => panic!("Imposible case to happen"),
+            };
+
+            match entities.get_mut(&block) {
+                Some(vec) => vec.push(ewt),
+                None => {
+                    let _ = entities.insert(block, vec![ewt]);
+                }
+            };
+        }
+
+        // sort the elements in each blocks bucket by vid
+        for vec in entities.values_mut() {
+            vec.sort_by_key(|a| a.vid);
+        }
+
+        Ok(entities)
+    }
+
+    pub async fn find_derived(
+        &self,
+        conn: &mut AsyncPgConnection,
         derived_query: &DerivedEntityQuery,
         block: BlockNumber,
-        excluded_keys: &Vec<EntityKey>,
+        excluded_keys: &[EntityKey],
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         let table = self.table_for_entity(&derived_query.entity_type)?;
+        let ids = excluded_keys.iter().map(|key| &key.entity_id).cloned();
+        let excluded_keys = IdList::try_from_iter(derived_query.entity_type.id_type()?, ids)?;
         let query = FindDerivedQuery::new(table, derived_query, block, excluded_keys);
 
         let mut entities = BTreeMap::new();
 
-        for data in query.load::<EntityData>(conn)? {
+        for data in query.load::<EntityData>(conn).await? {
             let entity_type = data.entity_type(&self.input_schema);
             let entity_data: Entity = data.deserialize_with_layout(self, None)?;
             let key =
@@ -532,9 +684,9 @@ impl Layout {
         Ok(entities)
     }
 
-    pub fn find_changes(
+    pub async fn find_changes(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         block: BlockNumber,
     ) -> Result<Vec<EntityOperation>, StoreError> {
         let mut tables = Vec::new();
@@ -544,12 +696,12 @@ impl Layout {
             }
         }
 
-        let inserts_or_updates =
-            FindChangesQuery::new(&self.catalog.site.namespace, &tables[..], block)
-                .load::<EntityData>(conn)?;
-        let deletions =
-            FindPossibleDeletionsQuery::new(&self.catalog.site.namespace, &tables[..], block)
-                .load::<EntityDeletion>(conn)?;
+        let inserts_or_updates = FindChangesQuery::new(&tables[..], block)
+            .load::<EntityData>(conn)
+            .await?;
+        let deletions = FindPossibleDeletionsQuery::new(&tables[..], block)
+            .load::<EntityDeletion>(conn)
+            .await?;
 
         let mut processed_entities = HashSet::new();
         let mut changes = Vec::new();
@@ -582,44 +734,114 @@ impl Layout {
         Ok(changes)
     }
 
-    pub fn insert<'a>(
+    pub async fn insert<'a>(
         &'a self,
-        conn: &PgConnection,
+        logger: &Logger,
+        conn: &mut AsyncPgConnection,
         group: &'a RowGroup,
         stopwatch: &StopwatchMetrics,
     ) -> Result<(), StoreError> {
+        fn chunk_details(chunk: &WriteChunk) -> (BlockNumber, String) {
+            let count = chunk.len();
+            let first = chunk.iter().map(|row| row.block).min().unwrap_or(0);
+            let last = chunk.iter().map(|row| row.block).max().unwrap_or(0);
+            let ids = if chunk.len() < 20 {
+                format!(
+                    " with ids [{}]",
+                    chunk.iter().map(|row| row.to_string()).join(", ")
+                )
+            } else {
+                "".to_string()
+            };
+            let details = if first == last {
+                format!("insert {count} rows{ids}")
+            } else {
+                format!("insert {count} rows at blocks [{first}, {last}]{ids}")
+            };
+            (last, details)
+        }
+
         let table = self.table_for_entity(&group.entity_type)?;
         let _section = stopwatch.start_section("insert_modification_insert_query");
 
         // We insert the entities in chunks to make sure each operation does
         // not exceed the maximum number of bindings allowed in queries
         let chunk_size = InsertQuery::chunk_size(table);
+        let mut affected_rows: usize = 0;
+        let mut expected_rows: usize = 0;
         for chunk in group.write_chunks(chunk_size) {
             // Empty chunks would lead to invalid SQL
             if !chunk.is_empty() {
-                InsertQuery::new(table, &chunk)?.execute(conn)?;
+                expected_rows += chunk.len();
+                match InsertQuery::new(table, &chunk)?.execute(conn).await {
+                    Ok(count) => {
+                        affected_rows += count;
+                    }
+                    Err(e) => {
+                        // We occasionally get these errors but it's entirely
+                        // unclear what causes them. We work around that by
+                        // switching to row-by-row inserts until we can figure
+                        // out what the underlying cause is
+                        let err_msg = e.to_string();
+                        if !err_msg.contains("value too large to transmit") {
+                            let (block, msg) = chunk_details(&chunk);
+                            return Err(StoreError::write_failure(
+                                e,
+                                table.object.as_str(),
+                                block,
+                                msg,
+                            ));
+                        }
+                        let (block, msg) = chunk_details(&chunk);
+                        warn!(logger, "Insert of entire chunk failed. Trying row by row insert.";
+                            "table" => table.object.as_str(),
+                            "block" => block,
+                            "error" => err_msg,
+                            "details" => msg
+                        );
+                        for single_chunk in chunk.as_single_writes() {
+                            let count = InsertQuery::new(table, &single_chunk)?
+                                .execute(conn)
+                                .await
+                                .map_err(|e| {
+                                    let (block, msg) = chunk_details(&single_chunk);
+                                    let msg = format!("{}: offending row {:?}", msg, single_chunk);
+                                    StoreError::write_failure(e, table.object.as_str(), block, msg)
+                                })?;
+                            affected_rows += count;
+                        }
+                    }
+                }
             }
         }
+        if affected_rows < expected_rows && table.immutable && table.skip_duplicates {
+            debug!(logger, "Cross-batch duplicate inserts skipped by ON CONFLICT DO NOTHING";
+                "entity_type" => table.object.as_str(),
+                "expected_rows" => expected_rows,
+                "affected_rows" => affected_rows,
+                "skipped" => expected_rows - affected_rows);
+        }
         Ok(())
     }
 
-    pub fn conflicting_entity(
+    pub async fn conflicting_entities(
         &self,
-        conn: &PgConnection,
-        entity_id: &Id,
-        entities: Vec<EntityType>,
-    ) -> Result<Option<String>, StoreError> {
-        Ok(ConflictingEntityQuery::new(self, entities, entity_id)?
-            .load(conn)?
+        conn: &mut AsyncPgConnection,
+        entities: &[EntityType],
+        group: &RowGroup,
+    ) -> Result<Option<(String, String)>, StoreError> {
+        Ok(ConflictingEntitiesQuery::new(self, entities, group)?
+            .load(conn)
+            .await?
             .pop()
-            .map(|data| data.entity))
+            .map(|data: ConflictingEntitiesData| (data.entity, data.id)))
     }
 
     /// order is a tuple (attribute, value_type, direction)
-    pub fn query<T: crate::relational_queries::FromEntityData>(
+    pub async fn query<T: crate::relational_queries::FromEntityData>(
         &self,
         logger: &Logger,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         query: EntityQuery,
     ) -> Result<(Vec<T>, Trace), QueryExecutionError> {
         fn log_query_timing(
@@ -676,18 +898,20 @@ impl Layout {
             query.block,
             query.query_id,
             &self.site,
+            query.aggregation_current,
         )?;
 
         let query_clone = query.clone();
 
         let start = Instant::now();
         let values = conn
-            .transaction(|| {
+            .transaction(async |conn| {
                 if let Some(ref timeout_sql) = *STATEMENT_TIMEOUT {
-                    conn.batch_execute(timeout_sql)?;
+                    conn.batch_execute(timeout_sql).await?;
                 }
-                query.load::<EntityData>(conn)
+                query.load::<EntityData>(conn).await
             })
+            .await
             .map_err(|e| {
                 use diesel::result::DatabaseErrorKind;
                 use diesel::result::Error::*;
@@ -704,7 +928,7 @@ impl Layout {
                     }
                 };
                 match e {
-                    DatabaseError(DatabaseErrorKind::__Unknown, ref info)
+                    DatabaseError(DatabaseErrorKind::Unknown, ref info)
                         if info.message().starts_with("syntax error in tsquery") =>
                     {
                         QueryExecutionError::FulltextQueryInvalidSyntax(info.message().to_string())
@@ -728,20 +952,23 @@ impl Layout {
             .map(|values| (values, trace))
     }
 
-    pub fn update<'a>(
+    pub async fn update<'a>(
         &'a self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         group: &'a RowGroup,
         stopwatch: &StopwatchMetrics,
     ) -> Result<usize, StoreError> {
         let table = self.table_for_entity(&group.entity_type)?;
         if table.immutable && group.has_clamps() {
+            if table.skip_duplicates {
+                return Ok(0);
+            }
             let ids = group
                 .ids()
                 .map(|id| id.to_string())
                 .collect::<Vec<_>>()
                 .join(", ");
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "entities of type `{}` can not be updated since they are immutable. Entity ids are [{}]",
                 group.entity_type,
                 ids
@@ -753,10 +980,12 @@ impl Layout {
             let entity_keys: Vec<_> = rows.iter().map(|row| row.id()).collect();
             // FIXME: we clone all the ids here
             let entity_keys = IdList::try_from_iter(
-                &group.entity_type,
+                group.entity_type.id_type()?,
                 entity_keys.into_iter().map(|id| id.to_owned()),
             )?;
-            ClampRangeQuery::new(table, &entity_keys, block)?.execute(conn)?;
+            ClampRangeQuery::new(table, &entity_keys, block)?
+                .execute(conn)
+                .await?;
         }
         section.end();
 
@@ -767,18 +996,31 @@ impl Layout {
         // not exceed the maximum number of bindings allowed in queries
         let chunk_size = InsertQuery::chunk_size(table);
         for chunk in group.write_chunks(chunk_size) {
-            count += InsertQuery::new(table, &chunk)?.execute(conn)?;
+            count += InsertQuery::new(table, &chunk)?.execute(conn).await?;
         }
 
         Ok(count)
     }
 
-    pub fn delete(
+    pub async fn delete(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         group: &RowGroup,
         stopwatch: &StopwatchMetrics,
     ) -> Result<usize, StoreError> {
+        fn chunk_details(chunk: &IdList) -> String {
+            if chunk.len() < 20 {
+                let ids = chunk
+                    .iter()
+                    .map(|id| id.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("clamp ids [{ids}]")
+            } else {
+                format!("clamp {} ids", chunk.len())
+            }
+        }
+
         if !group.has_clamps() {
             // Nothing to do
             return Ok(0);
@@ -786,9 +1028,13 @@ impl Layout {
 
         let table = self.table_for_entity(&group.entity_type)?;
         if table.immutable {
-            return Err(constraint_violation!(
+            if table.skip_duplicates {
+                return Ok(0);
+            }
+            return Err(internal_error!(
                 "entities of type `{}` can not be deleted since they are immutable. Entity ids are [{}]",
-                table.object, group.ids().join(", ")
+                table.object,
+                group.ids().join(", ")
             ));
         }
 
@@ -799,41 +1045,56 @@ impl Layout {
             for chunk in ids.chunks(DELETE_OPERATION_CHUNK_SIZE) {
                 // FIXME: we clone all the ids here
                 let chunk = IdList::try_from_iter(
-                    &group.entity_type,
-                    chunk.into_iter().map(|id| (*id).to_owned()),
+                    group.entity_type.id_type()?,
+                    chunk.iter().map(|id| (*id).to_owned()),
                 )?;
-                count += ClampRangeQuery::new(table, &chunk, block)?.execute(conn)?
+                count += ClampRangeQuery::new(table, &chunk, block)?
+                    .execute(conn)
+                    .await
+                    .map_err(|e| {
+                        StoreError::write_failure(
+                            e,
+                            group.entity_type.as_str(),
+                            block,
+                            chunk_details(&chunk),
+                        )
+                    })?
             }
         }
         Ok(count)
     }
 
-    pub fn truncate_tables(&self, conn: &PgConnection) -> Result<StoreEvent, StoreError> {
+    pub async fn truncate_tables(&self, conn: &mut AsyncPgConnection) -> Result<(), StoreError> {
         for table in self.tables.values() {
-            conn.execute(&format!("TRUNCATE TABLE {}", table.qualified_name))?;
+            sql_query(format!("TRUNCATE TABLE {}", table.qualified_name))
+                .execute(conn)
+                .await?;
         }
-        Ok(StoreEvent::new(vec![]))
+        Ok(())
     }
 
     /// Revert the block with number `block` and all blocks with higher
     /// numbers. After this operation, only entity versions inserted or
     /// updated at blocks with numbers strictly lower than `block` will
     /// remain
-    pub fn revert_block(
+    ///
+    /// The `i32` that is returned is the amount by which the entity count
+    /// for the subgraph needs to be adjusted
+    pub async fn revert_block(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         block: BlockNumber,
-    ) -> Result<(StoreEvent, i32), StoreError> {
-        let mut changes: Vec<EntityChange> = Vec::new();
+    ) -> Result<i32, StoreError> {
         let mut count: i32 = 0;
 
         for table in self.tables.values() {
             // Remove all versions whose entire block range lies beyond
             // `block`
-            let removed = RevertRemoveQuery::new(table, block)
-                .get_results(conn)?
+            let removed: HashSet<_> = RevertRemoveQuery::new(table, block)
+                .get_results::<ReturnedEntityData>(conn)
+                .await?
                 .into_iter()
-                .collect::<HashSet<_>>();
+                .collect();
             // Make the versions current that existed at `block - 1` but that
             // are not current yet. Those are the ones that were updated or
             // deleted at `block`
@@ -841,7 +1102,8 @@ impl Layout {
                 HashSet::new()
             } else {
                 RevertClampQuery::new(table, block - 1)?
-                    .get_results(conn)?
+                    .get_results(conn)
+                    .await?
                     .into_iter()
                     .collect::<HashSet<_>>()
             };
@@ -853,23 +1115,8 @@ impl Layout {
             let deleted = removed.difference(&unclamped).count() as i32;
             let inserted = unclamped.difference(&removed).count() as i32;
             count += inserted - deleted;
-            // EntityChange for versions we just deleted
-            let deleted = removed
-                .into_iter()
-                .filter(|id| !unclamped.contains(id))
-                .map(|_| EntityChange::Data {
-                    subgraph_id: self.site.deployment.clone(),
-                    entity_type: table.object.to_string(),
-                });
-            changes.extend(deleted);
-            // EntityChange for versions that we just updated or inserted
-            let set = unclamped.into_iter().map(|_| EntityChange::Data {
-                subgraph_id: self.site.deployment.clone(),
-                entity_type: table.object.to_string(),
-            });
-            changes.extend(set);
         }
-        Ok((StoreEvent::new(changes), count))
+        Ok(count)
     }
 
     /// Revert the metadata (dynamic data sources and related entities) for
@@ -877,13 +1124,14 @@ impl Layout {
     ///
     /// For metadata, reversion always means deletion since the metadata that
     /// is subject to reversion is only ever created but never updated
-    pub fn revert_metadata(
-        conn: &PgConnection,
+    pub async fn revert_metadata(
+        logger: &Logger,
+        conn: &mut AsyncPgConnection,
         site: &Site,
         block: BlockNumber,
     ) -> Result<(), StoreError> {
-        crate::dynds::revert(conn, site, block)?;
-        crate::deployment::revert_subgraph_errors(conn, &site.deployment, block)?;
+        crate::dynds::revert(conn, site, block).await?;
+        crate::deployment::revert_subgraph_errors(logger, conn, &site.deployment, block).await?;
 
         Ok(())
     }
@@ -903,13 +1151,13 @@ impl Layout {
     /// This is tied closely to how the `LayoutCache` works and called from
     /// it right after creating a `Layout`, and periodically to update the
     /// `Layout` in case changes were made
-    fn refresh(
+    async fn refresh(
         self: Arc<Self>,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
     ) -> Result<Arc<Self>, StoreError> {
-        let account_like = crate::catalog::account_like(conn, &self.site)?;
-        let history_blocks = deployment::history_blocks(conn, &self.site)?;
+        let account_like = crate::catalog::account_like(conn, &self.site).await?;
+        let history_blocks = deployment::history_blocks(conn, &self.site).await?;
 
         let is_account_like = { |table: &Table| account_like.contains(table.name.as_str()) };
 
@@ -933,30 +1181,18 @@ impl Layout {
         Ok(Arc::new(layout))
     }
 
-    pub(crate) fn block_time(
+    /// Find the time of the last rollup for the subgraph. We do this by
+    /// looking for the maximum timestamp in any aggregation table and
+    /// adding a little bit more than the corresponding interval to it. This
+    /// method crucially depends on the fact that we always write the rollup
+    /// for all aggregations, meaning that if some aggregations do not have
+    /// an entry with the maximum timestamp that there was just no data for
+    /// that interval, but we did try to aggregate at that time.
+    pub(crate) async fn last_rollup(
         &self,
-        conn: &PgConnection,
-        block: BlockNumber,
+        conn: &mut AsyncPgConnection,
     ) -> Result<Option<BlockTime>, StoreError> {
-        let block_time_name = self.input_schema.poi_block_time();
-        let poi_type = self.input_schema.poi_type();
-        let id = Id::String(Word::from(PoICausalityRegion::from_network(
-            &self.site.network,
-        )));
-        let key = poi_type.key(id);
-
-        let block_time = self
-            .find(conn, &key, block)?
-            .and_then(|entity| {
-                entity.get(&block_time_name).map(|value| {
-                    value
-                        .as_int8()
-                        .ok_or_else(|| constraint_violation!("block_time must have type Int8"))
-                })
-            })
-            .transpose()?
-            .map(|value| BlockTime::since_epoch(value, 0));
-        Ok(block_time)
+        Rollup::last_rollup(&self.rollups, conn).await
     }
 
     /// Construct `Rolllup` for each of the aggregation mappings
@@ -971,11 +1207,11 @@ impl Layout {
             let source_type = mapping.source_type(schema);
             let source_table = tables
                 .get(&source_type)
-                .ok_or_else(|| constraint_violation!("Table for {source_type} is missing"))?;
+                .ok_or_else(|| internal_error!("Table for {source_type} is missing"))?;
             let agg_type = mapping.agg_type(schema);
             let agg_table = tables
                 .get(&agg_type)
-                .ok_or_else(|| constraint_violation!("Table for {agg_type} is missing"))?;
+                .ok_or_else(|| internal_error!("Table for {agg_type} is missing"))?;
             let aggregation = mapping.aggregation(schema);
             let rollup = Rollup::new(
                 mapping.interval,
@@ -988,6 +1224,27 @@ impl Layout {
         Ok(rollups)
     }
 
+    /// Given an aggregation name that is already snake-cased like `stats`
+    /// (for an an aggregation `type Stats @aggregation(..)`) and an
+    /// interval, return the table that holds the aggregated data, like
+    /// `stats_hour`.
+    pub fn aggregation_table(
+        &self,
+        aggregation: &str,
+        interval: AggregationInterval,
+    ) -> Option<&Table> {
+        let sql_name = format!("{}_{interval}", aggregation);
+        self.table(&sql_name)
+    }
+
+    /// Return true if the layout has an aggregation with the given name
+    /// like `stats` (already snake_cased)
+    pub fn has_aggregation(&self, aggregation: &str) -> bool {
+        self.input_schema
+            .aggregation_names()
+            .any(|agg_name| SqlName::from(agg_name).as_str() == aggregation)
+    }
+
     /// Roll up all timeseries for each entry in `block_times`. The overall
     /// effect is that all buckets that end after `last_rollup` and before
     /// the last entry in `block_times` are filled. This will fill all
@@ -1014,28 +1271,60 @@ impl Layout {
     ///
     /// Changing this would require that we have a complete list of block
     /// numbers and block times which we do not have anywhere in graph-node.
-    pub(crate) fn rollup(
+    pub(crate) async fn rollup(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         last_rollup: Option<BlockTime>,
         block_times: &[(BlockNumber, BlockTime)],
     ) -> Result<(), StoreError> {
+        if block_times.is_empty() {
+            return Ok(());
+        }
+
+        // If we have never done a rollup, we can just use the smallest
+        // block time we are getting as the time for the last rollup
+        let mut last_rollup = last_rollup.unwrap_or_else(|| {
+            block_times
+                .iter()
+                .map(|(_, block_time)| *block_time)
+                .min()
+                .unwrap()
+        });
         // The for loop could be eliminated if the rollup queries could deal
         // with the full `block_times` vector, but the SQL for that will be
         // very complicated and is left for a future improvement.
-        let mut last_rollup = last_rollup.unwrap_or(BlockTime::NONE);
         for (block, block_time) in block_times {
             for rollup in &self.rollups {
                 let buckets = rollup.interval.buckets(last_rollup, *block_time);
-                if buckets.is_empty() {
-                    // The rollups are in increasing order of interval size, so
-                    // if a smaller interval doesn't have a bucket between
-                    // last_rollup and block_time, a larger one can't either and
-                    // we are done with this rollup.
-                    break;
-                }
-                for bucket in buckets {
-                    rollup.insert(conn, &bucket, *block)?;
+                // We only need to pay attention to the first bucket; if
+                // there are more buckets, there's nothing to rollup for
+                // them as the next changes we wrote are for `block_time`,
+                // and we'll catch that on the next iteration of the loop.
+                //
+                // Assume we are passed `block_times = [b1, b2, b3, .. ]`
+                // but b1 and b2 are far apart. We call
+                // `rollup.interval.buckets(b1, b2)` at some point in the
+                // iteration which produces timestamps `[t1, t2, ..]`. Since
+                // b1 and b2 are far apart, we have something like `t1 <= b1
+                // < t2 < t3 < t4 < t5 <= b2` but we know that there are no
+                // writes between `b1` and `b2` - if there were, we'd have
+                // some block time in `block_times` between `b1` and `b2`.
+                // So we only need to do a rollup for `t1 < b1 < t2`. After
+                // that, we set `last_rollup = b2` and repeat the loop for
+                // that, which will roll up the bucket `t5 <= b2 < t6`. So
+                // there's no need to worry about the buckets starting at
+                // `t2`, `t3`, and `t4`.
+                match buckets.as_slice().first() {
+                    None => {
+                        // The rollups are in increasing order of interval size, so
+                        // if a smaller interval doesn't have a bucket between
+                        // last_rollup and block_time, a larger one can't either and
+                        // we are done with this rollup.
+                        break;
+                    }
+                    Some(bucket) => {
+                        rollup.insert(conn, bucket, *block).await?;
+                    }
                 }
             }
             last_rollup = *block_time;
@@ -1077,6 +1366,7 @@ pub enum ColumnType {
     Bytes,
     Int,
     Int8,
+    Timestamp,
     String,
     TSVector(FulltextConfig),
     Enum(EnumType),
@@ -1092,6 +1382,23 @@ impl From<IdType> for ColumnType {
     }
 }
 
+impl std::fmt::Display for ColumnType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ColumnType::Boolean => write!(f, "Boolean"),
+            ColumnType::BigDecimal => write!(f, "BigDecimal"),
+            ColumnType::BigInt => write!(f, "BigInt"),
+            ColumnType::Bytes => write!(f, "Bytes"),
+            ColumnType::Int => write!(f, "Int"),
+            ColumnType::Int8 => write!(f, "Int8"),
+            ColumnType::Timestamp => write!(f, "Timestamp"),
+            ColumnType::String => write!(f, "String"),
+            ColumnType::TSVector(_) => write!(f, "TSVector"),
+            ColumnType::Enum(enum_type) => write!(f, "Enum({})", enum_type.name),
+        }
+    }
+}
+
 impl ColumnType {
     fn from_field_type(
         schema: &InputSchema,
@@ -1105,7 +1412,7 @@ impl ColumnType {
         if let Some(id_type) = schema
             .entity_type(name)
             .ok()
-            .and_then(|entity_type| Some(entity_type.id_type()))
+            .map(|entity_type| entity_type.id_type())
             .transpose()?
         {
             return Ok(id_type.into());
@@ -1140,6 +1447,7 @@ impl ColumnType {
             ValueType::Bytes => Ok(ColumnType::Bytes),
             ValueType::Int => Ok(ColumnType::Int),
             ValueType::Int8 => Ok(ColumnType::Int8),
+            ValueType::Timestamp => Ok(ColumnType::Timestamp),
             ValueType::String => Ok(ColumnType::String),
         }
     }
@@ -1150,8 +1458,9 @@ impl ColumnType {
             ColumnType::BigDecimal => "numeric",
             ColumnType::BigInt => "numeric",
             ColumnType::Bytes => "bytea",
-            ColumnType::Int => "integer",
+            ColumnType::Int => "int4",
             ColumnType::Int8 => "int8",
+            ColumnType::Timestamp => "timestamptz",
             ColumnType::String => "text",
             ColumnType::TSVector(_) => "tsvector",
             ColumnType::Enum(enum_type) => enum_type.name.as_str(),
@@ -1200,7 +1509,7 @@ impl Column {
 
         let sql_name = SqlName::from(&*field.name);
 
-        let is_reference = schema.is_reference(&field.field_type.get_base_type());
+        let is_reference = schema.is_reference(field.field_type.get_base_type());
 
         let column_type = if sql_name.as_str() == PRIMARY_KEY_COLUMN {
             IdType::try_from(&field.field_type)?.into()
@@ -1243,6 +1552,21 @@ impl Column {
         })
     }
 
+    pub fn pseudo_column(name: &str, column_type: ColumnType) -> Column {
+        let field_type = q::Type::NamedType(column_type.to_string());
+        let name = SqlName::verbatim(name.to_string());
+        let field = Word::from(name.as_str());
+        Column {
+            name,
+            field,
+            field_type,
+            column_type,
+            fulltext_fields: None,
+            is_reference: false,
+            use_prefix_comparison: false,
+        }
+    }
+
     fn new_fulltext(def: &FulltextDefinition) -> Result<Column, StoreError> {
         SqlName::check_valid_identifier(&def.name, "attribute")?;
         let sql_name = SqlName::from(def.name.as_str());
@@ -1263,13 +1587,7 @@ impl Column {
     }
 
     pub fn is_nullable(&self) -> bool {
-        fn is_nullable(field_type: &q::Type) -> bool {
-            match field_type {
-                q::Type::NonNullType(_) => false,
-                _ => true,
-            }
-        }
-        is_nullable(&self.field_type)
+        !matches!(&self.field_type, q::Type::NonNullType(_))
     }
 
     pub fn is_list(&self) -> bool {
@@ -1330,8 +1648,14 @@ pub(crate) const VID_COLUMN: &str = "vid";
 
 #[derive(Debug, Clone)]
 pub struct Table {
-    /// The name of the GraphQL object type ('Thing')
+    /// The reference to the underlying type in the input schema. For
+    /// aggregations, this is the object type for a specific interval, like
+    /// `Stats_hour`, not the overall aggregation type `Stats`.
     pub object: EntityType,
+
+    /// The namespace in which the table lives
+    nsp: Namespace,
+
     /// The name of the database table for this type ('thing'), snakecased
     /// version of `object`
     pub name: SqlName,
@@ -1356,6 +1680,8 @@ pub struct Table {
     /// deleted
     pub(crate) immutable: bool,
 
+    pub(crate) skip_duplicates: bool,
+
     /// Whether this table has an explicit `causality_region` column. If `false`, then the column is
     /// not present and the causality region for all rows is implicitly `0` (equivalent to CasualityRegion::ONCHAIN).
     pub(crate) has_causality_region: bool,
@@ -1372,24 +1698,26 @@ impl Table {
     ) -> Result<Table, StoreError> {
         SqlName::check_valid_identifier(defn.as_str(), "object")?;
 
-        let object_type = defn.object_type().map_err(|_| {
-            constraint_violation!("The type `{}` is not an object type", defn.as_str())
-        })?;
+        let object_type = defn
+            .object_type()
+            .map_err(|_| internal_error!("The type `{}` is not an object type", defn.as_str()))?;
 
         let table_name = SqlName::from(defn.as_str());
         let columns = object_type
             .fields
-            .into_iter()
-            .filter(|field| !field.is_derived)
+            .iter()
+            .filter(|field| !field.is_derived())
             .map(|field| Column::new(schema, &table_name, field, catalog))
             .chain(fulltexts.iter().map(Column::new_fulltext))
             .collect::<Result<Vec<Column>, StoreError>>()?;
         let qualified_name = SqlName::qualified_name(&catalog.site.namespace, &table_name);
         let immutable = defn.is_immutable();
-
+        let skip_duplicates = defn.skip_duplicates();
+        let nsp = catalog.site.namespace.clone();
         let table = Table {
             object: defn.cheap_clone(),
             name: table_name,
+            nsp,
             qualified_name,
             // Default `is_account_like` to `false`; the caller should call
             // `refresh` after constructing the layout, but that requires a
@@ -1398,6 +1726,7 @@ impl Table {
             columns,
             position,
             immutable,
+            skip_duplicates,
             has_causality_region,
         };
         Ok(table)
@@ -1408,12 +1737,14 @@ impl Table {
     pub fn new_like(&self, namespace: &Namespace, name: &SqlName) -> Arc<Table> {
         let other = Table {
             object: self.object.clone(),
+            nsp: namespace.clone(),
             name: name.clone(),
             qualified_name: SqlName::qualified_name(namespace, name),
             columns: self.columns.clone(),
             is_account_like: self.is_account_like,
             position: self.position,
             immutable: self.immutable,
+            skip_duplicates: self.skip_duplicates,
             has_causality_region: self.has_causality_region,
         };
 
@@ -1421,24 +1752,33 @@ impl Table {
     }
 
     /// Find the column `name` in this table. The name must be in snake case,
-    /// i.e., use SQL conventions
+    /// i.e., use SQL conventions.
+    ///
+    /// Fulltext search columns (`ColumnType::TSVector`) are deliberately
+    /// skipped since they are not queryable entity attributes. Use
+    /// [`Table::column_including_fulltext`] when the fulltext columns are
+    /// needed, e.g. when copying a table.
     pub fn column(&self, name: &SqlName) -> Option<&Column> {
         self.columns
             .iter()
-            .filter(|column| match column.column_type {
-                ColumnType::TSVector(_) => false,
-                _ => true,
-            })
+            .filter(|column| !matches!(column.column_type, ColumnType::TSVector(_)))
             .find(|column| &column.name == name)
     }
 
+    /// Find the column `name` in this table, including fulltext search
+    /// columns which [`Table::column`] hides. The name must be in snake
+    /// case, i.e., use SQL conventions.
+    pub fn column_including_fulltext(&self, name: &SqlName) -> Option<&Column> {
+        self.columns.iter().find(|column| &column.name == name)
+    }
+
     /// Find the column for `field` in this table. The name must be the
     /// GraphQL name of an entity field
     pub fn column_for_field(&self, field: &str) -> Result<&Column, StoreError> {
         self.columns
             .iter()
             .find(|column| column.field == field)
-            .ok_or_else(|| StoreError::UnknownField(field.to_string()))
+            .ok_or_else(|| StoreError::UnknownField(self.name.to_string(), field.to_string()))
     }
 
     fn can_copy_from(&self, source: &Self) -> Vec<String> {
@@ -1468,10 +1808,10 @@ impl Table {
             .expect("every table has a primary key")
     }
 
-    pub(crate) fn analyze(&self, conn: &PgConnection) -> Result<(), StoreError> {
+    pub(crate) async fn analyze(&self, conn: &mut AsyncPgConnection) -> Result<(), StoreError> {
         let table_name = &self.qualified_name;
-        let sql = format!("analyze {table_name}");
-        conn.execute(&sql)?;
+        let sql = format!("analyze (skip_locked) {table_name}");
+        sql_query(&sql).execute(conn).await?;
         Ok(())
     }
 
@@ -1482,6 +1822,10 @@ impl Table {
             &crate::block_range::BLOCK_RANGE_COLUMN_SQL
         }
     }
+
+    pub fn dsl_table(&self) -> dsl::Table<'_> {
+        dsl::Table::new(self)
+    }
 }
 
 #[derive(Clone)]
@@ -1499,7 +1843,8 @@ pub struct LayoutCache {
     ttl: Duration,
     /// Use this so that we only refresh one layout at any given time to
     /// avoid refreshing the same layout multiple times
-    refresh: Mutex<()>,
+    refresh: tokio::sync::Mutex<()>,
+    last_sweep: Mutex<Instant>,
 }
 
 impl LayoutCache {
@@ -1507,21 +1852,26 @@ impl LayoutCache {
         Self {
             entries: Mutex::new(HashMap::new()),
             ttl,
-            refresh: Mutex::new(()),
+            refresh: tokio::sync::Mutex::new(()),
+            last_sweep: Mutex::new(Instant::now()),
         }
     }
 
-    fn load(conn: &PgConnection, site: Arc<Site>) -> Result<Arc<Layout>, StoreError> {
-        let (subgraph_schema, use_bytea_prefix) = deployment::schema(conn, site.as_ref())?;
+    async fn load(
+        conn: &mut AsyncPgConnection,
+        site: Arc<Site>,
+    ) -> Result<Arc<Layout>, StoreError> {
+        let (subgraph_schema, use_bytea_prefix) = deployment::schema(conn, site.as_ref()).await?;
         let has_causality_region =
-            deployment::entities_with_causality_region(conn, site.id, &subgraph_schema)?;
-        let catalog = Catalog::load(conn, site.clone(), use_bytea_prefix, has_causality_region)?;
+            deployment::entities_with_causality_region(conn, site.id, &subgraph_schema).await?;
+        let catalog =
+            Catalog::load(conn, site.clone(), use_bytea_prefix, has_causality_region).await?;
         let layout = Arc::new(Layout::new(site.clone(), &subgraph_schema, catalog)?);
-        layout.refresh(conn, site)
+        layout.refresh(conn, site).await
     }
 
     fn cache(&self, layout: Arc<Layout>) {
-        if layout.is_cacheable() {
+        if self.ttl > Duration::ZERO && layout.is_cacheable() {
             let deployment = layout.site.deployment.clone();
             let entry = CacheEntry {
                 expires: Instant::now() + self.ttl,
@@ -1544,10 +1894,10 @@ impl LayoutCache {
     /// Get the layout for `site`. If it's not in cache, load it. If it is
     /// expired, try to refresh it if there isn't another refresh happening
     /// already
-    pub fn get(
+    pub async fn get(
         &self,
         logger: &Logger,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
     ) -> Result<Arc<Layout>, StoreError> {
         let now = Instant::now();
@@ -1555,11 +1905,11 @@ impl LayoutCache {
             let lock = self.entries.lock().unwrap();
             lock.get(&site.deployment).cloned()
         };
-        match entry {
+        let layout = match entry {
             Some(CacheEntry { value, expires }) => {
                 if now <= expires {
                     // Entry is not expired; use it
-                    Ok(value)
+                    value
                 } else {
                     // Only do a cache refresh once; we don't want to have
                     // multiple threads refreshing the same layout
@@ -1567,32 +1917,45 @@ impl LayoutCache {
                     // layout globally
                     let refresh = self.refresh.try_lock();
                     if refresh.is_err() {
-                        return Ok(value);
-                    }
-                    match value.cheap_clone().refresh(conn, site) {
-                        Err(e) => {
-                            warn!(
-                                logger,
-                                "failed to refresh statistics. Continuing with old statistics";
-                                "deployment" => &value.site.deployment,
-                                "error" => e.to_string()
-                            );
-                            // Update the timestamp so we don't retry
-                            // refreshing too often
-                            self.cache(value.cheap_clone());
-                            Ok(value)
-                        }
-                        Ok(layout) => {
-                            self.cache(layout.cheap_clone());
-                            Ok(layout)
-                        }
+                        value
+                    } else {
+                        self.refresh(logger, conn, site, value).await
                     }
                 }
             }
             None => {
-                let layout = Self::load(conn, site)?;
+                let layout = Self::load(conn, site).await?;
+                self.cache(layout.cheap_clone());
+                layout
+            }
+        };
+        self.sweep(now);
+        Ok(layout)
+    }
+
+    async fn refresh(
+        &self,
+        logger: &Logger,
+        conn: &mut AsyncPgConnection,
+        site: Arc<Site>,
+        value: Arc<Layout>,
+    ) -> Arc<Layout> {
+        match value.cheap_clone().refresh(conn, site).await {
+            Err(e) => {
+                warn!(
+                    logger,
+                    "failed to refresh statistics. Continuing with old statistics";
+                    "deployment" => &value.site.deployment,
+                    "error" => e.to_string()
+                );
+                // Update the timestamp so we don't retry
+                // refreshing too often
+                self.cache(value.cheap_clone());
+                value
+            }
+            Ok(layout) => {
                 self.cache(layout.cheap_clone());
-                Ok(layout)
+                layout
             }
         }
     }
@@ -1610,4 +1973,17 @@ impl LayoutCache {
     pub(crate) fn clear(&self) {
         self.entries.lock().unwrap().clear()
     }
+
+    /// Periodically sweep the cache to remove expired entries; an entry is
+    /// expired if it was last updated more than 2*self.ttl ago
+    fn sweep(&self, now: Instant) {
+        if now - *self.last_sweep.lock().unwrap() < ENV_VARS.store.schema_cache_ttl {
+            return;
+        }
+        let mut entries = self.entries.lock().unwrap();
+        // We allow entries to stick around for 2*ttl; if an entry was used
+        // in that time, it will get refreshed and have its expiry updated
+        entries.retain(|_, entry| entry.expires + self.ttl > now);
+        *self.last_sweep.lock().unwrap() = now;
+    }
 }
diff --git a/store/postgres/src/relational/ddl.rs b/store/postgres/src/relational/ddl.rs
index f7fe014a3cf..c1179b5b1a1 100644
--- a/store/postgres/src/relational/ddl.rs
+++ b/store/postgres/src/relational/ddl.rs
@@ -3,15 +3,18 @@ use std::{
     iter,
 };
 
-use graph::prelude::{BLOCK_NUMBER_MAX, ENV_VARS};
+use graph::{prelude::ENV_VARS, schema::InputSchema};
 
-use crate::block_range::CAUSALITY_REGION_COLUMN;
 use crate::relational::{
-    ColumnType, BLOCK_COLUMN, BLOCK_RANGE_COLUMN, BYTE_ARRAY_PREFIX_SIZE, STRING_PREFIX_SIZE,
+    BLOCK_COLUMN, BLOCK_RANGE_COLUMN, BYTE_ARRAY_PREFIX_SIZE, ColumnType, STRING_PREFIX_SIZE,
     VID_COLUMN,
 };
+use crate::{block_range::CAUSALITY_REGION_COLUMN, relational::index::Cond};
 
-use super::{Catalog, Column, Layout, SqlName, Table};
+use super::{
+    Column, Layout, SqlName, Table,
+    index::{CreateIndex, Expr, IndexCreator, Method, PrefixKind},
+};
 
 // In debug builds (for testing etc.) unconditionally create exclusion constraints, in release
 // builds for production, skip them
@@ -37,8 +40,9 @@ impl Layout {
         let mut tables = self.tables.values().collect::<Vec<_>>();
         tables.sort_by_key(|table| table.position);
         // Output 'create table' statements for all tables
+        let creat = self.index_creator(false, false);
         for table in tables {
-            table.as_ddl(&self.catalog, &mut out)?;
+            table.as_ddl(&self.input_schema, &creat, &mut out)?;
         }
 
         Ok(out)
@@ -108,12 +112,18 @@ impl Table {
             Ok(cols)
         }
 
+        let vid_type = if self.object.has_vid_seq() {
+            "bigint"
+        } else {
+            "bigserial"
+        };
+
         if self.immutable {
             writeln!(
                 out,
                 "
     create table {qname} (
-        {vid}                  bigserial primary key,
+        {vid}                  {vid_type} primary key,
         {block}                int not null,\n\
         {cols},
         unique({id})
@@ -121,6 +131,7 @@ impl Table {
                 qname = self.qualified_name,
                 cols = columns_ddl(self)?,
                 vid = VID_COLUMN,
+                vid_type = vid_type,
                 block = BLOCK_COLUMN,
                 id = self.primary_key().name
             )
@@ -129,13 +140,14 @@ impl Table {
                 out,
                 r#"
     create table {qname} (
-        {vid}                  bigserial primary key,
+        {vid}                  {vid_type} primary key,
         {block_range}          int4range not null,
         {cols}
     );"#,
                 qname = self.qualified_name,
                 cols = columns_ddl(self)?,
                 vid = VID_COLUMN,
+                vid_type = vid_type,
                 block_range = BLOCK_RANGE_COLUMN
             )?;
 
@@ -143,19 +155,28 @@ impl Table {
         }
     }
 
-    fn create_time_travel_indexes(&self, catalog: &Catalog, out: &mut String) -> fmt::Result {
-        let (int4, int8) = catalog.minmax_ops();
+    /// Create a `CreateIndex` for an index on this table with the given
+    /// name over the given columns. The index will be a non-unique BTree
+    /// index
+    fn create_index(&self, name: &str, columns: Vec<Expr>) -> CreateIndex {
+        CreateIndex::create(
+            name,
+            &format!("\"{}\"", self.nsp),
+            &self.name.quoted(),
+            false,
+            Method::BTree,
+            columns,
+            None,
+            None,
+        )
+    }
 
+    fn time_travel_indexes(&self) -> Vec<CreateIndex> {
+        let mut idxs = Vec::new();
         if self.immutable {
-            write!(
-                out,
-                "create index brin_{table_name}\n    \
-                on {qname}\n \
-                   using brin({block} {int4}, vid {int8});\n",
-                table_name = self.name,
-                qname = self.qualified_name,
-                block = BLOCK_COLUMN
-            )
+            // For immutable entities, a simple BTree on block$ is sufficient
+            let idx = self.create_index(&format!("{}_block", self.name), vec![Expr::Block]);
+            idxs.push(idx);
         } else {
             // Add a BRIN index on the block_range bounds to exploit the fact
             // that block ranges closely correlate with where in a table an
@@ -178,80 +199,56 @@ impl Table {
             //
             // We also index `vid` as that correlates with the order in which
             // entities are stored.
-            write!(out,"create index brin_{table_name}\n    \
-                on {qname}\n \
-                   using brin(lower(block_range) {int4}, coalesce(upper(block_range), {block_max}) {int4}, vid {int8});\n",
-                table_name = self.name,
-                qname = self.qualified_name,
-                block_max = BLOCK_NUMBER_MAX)?;
+
+            let idx = self
+                .create_index(
+                    &format!("brin_{table_name}", table_name = self.name),
+                    vec![Expr::BlockRangeLower, Expr::BlockRangeUpper, Expr::Vid],
+                )
+                .method(Method::Brin);
+            idxs.push(idx);
 
             // Add a BTree index that helps with the `RevertClampQuery` by making
             // it faster to find entity versions that have been modified
-            write!(
-                out,
-                "create index {table_name}_block_range_closed\n    \
-                 on {qname}(coalesce(upper(block_range), {block_max}))\n \
-                 where coalesce(upper(block_range), {block_max}) < {block_max};\n",
-                table_name = self.name,
-                qname = self.qualified_name,
-                block_max = BLOCK_NUMBER_MAX
-            )
+            let idx = self
+                .create_index(
+                    &format!("{table_name}_block_range_closed", table_name = self.name),
+                    vec![Expr::BlockRangeUpper],
+                )
+                .cond(Cond::Closed);
+            idxs.push(idx);
         }
+        idxs
     }
 
-    /// Calculates the indexing method and expression for a database column.
-    ///
-    /// ### Parameters
-    /// * `immutable`: A boolean flag indicating whether the table is immutable.
-    /// * `column`: A reference to the `Column` struct, representing the database column for which the index method and expression are being calculated.
-    ///
-    /// ### Returns
-    /// A tuple `(String, String)` where:
-    /// - The first element is the indexing method ("btree", "gist", or "gin"),
-    /// - The second element is the index expression as a string.
-    pub fn calculate_index_method_and_expression(
-        immutable: bool,
-        column: &Column,
-    ) -> (String, String) {
-        if column.is_reference() && !column.is_list() {
-            if immutable {
-                let index_expr = format!("{}, {}", column.name.quoted(), BLOCK_COLUMN);
-                ("btree".to_string(), index_expr)
-            } else {
-                let index_expr = format!("{}, {}", column.name.quoted(), BLOCK_RANGE_COLUMN);
-                ("gist".to_string(), index_expr)
+    pub fn calculate_index_method_and_expression(column: &Column) -> (String, String) {
+        let index_expr = if column.use_prefix_comparison {
+            match column.column_type {
+                ColumnType::String => {
+                    format!("left({}, {})", column.name.quoted(), STRING_PREFIX_SIZE)
+                }
+                ColumnType::Bytes => format!(
+                    "substring({}, 1, {})",
+                    column.name.quoted(),
+                    BYTE_ARRAY_PREFIX_SIZE
+                ),
+                // Handle other types if necessary, or maintain the unreachable statement
+                _ => unreachable!("only String and Bytes can have arbitrary size"),
             }
         } else {
-            let index_expr = if column.use_prefix_comparison {
-                match column.column_type {
-                    ColumnType::String => {
-                        format!("left({}, {})", column.name.quoted(), STRING_PREFIX_SIZE)
-                    }
-                    ColumnType::Bytes => format!(
-                        "substring({}, 1, {})",
-                        column.name.quoted(),
-                        BYTE_ARRAY_PREFIX_SIZE
-                    ),
-                    // Handle other types if necessary, or maintain the unreachable statement
-                    _ => unreachable!("only String and Bytes can have arbitrary size"),
-                }
-            } else {
-                column.name.quoted()
-            };
+            column.name.quoted()
+        };
 
-            let method = if column.is_list() || column.is_fulltext() {
-                "gin".to_string()
-            } else {
-                "btree".to_string()
-            };
+        let method = if column.is_list() || column.is_fulltext() {
+            "gin".to_string()
+        } else {
+            "btree".to_string()
+        };
 
-            (method, index_expr)
-        }
+        (method, index_expr)
     }
 
-    fn create_attribute_indexes(&self, out: &mut String) -> fmt::Result {
-        // Create indexes.
-
+    fn columns_to_index(&self) -> impl Iterator<Item = &Column> {
         // Skip columns whose type is an array of enum, since there is no
         // good way to index them with Postgres 9.6. Once we move to
         // Postgres 11, we can enable that (tracked in graph-node issue
@@ -269,33 +266,143 @@ impl Table {
                 && [ColumnType::BigDecimal, ColumnType::BigInt, ColumnType::Int]
                     .contains(&col.column_type))
         };
-        let columns = self
-            .columns
+
+        self.columns
             .iter()
             .filter(not_enum_list)
             .filter(not_immutable_pk)
-            .filter(not_numeric_list);
-
-        for (column_index, column) in columns.enumerate() {
-            let (method, index_expr) =
-                Self::calculate_index_method_and_expression(self.immutable, column);
-            // If `create_gin_indexes` is set to false, we don't create
-            // indexes on array attributes. Experience has shown that these
-            // indexes are very expensive to update and can have a very bad
-            // impact on the write performance of the database, but are
-            // hardly ever used or needed by queries.
-            if !column.is_list() || ENV_VARS.store.create_gin_indexes {
-                write!(
-                    out,
-                    "create index attr_{table_index}_{column_index}_{table_name}_{column_name}\n    on {qname} using {method}({index_expr});\n",
-                    table_index = self.position,
-                    table_name = self.name,
-                    column_name = column.name,
-                    qname = self.qualified_name,
-                )?;
+            .filter(not_numeric_list)
+    }
+
+    /// Return the index method and expressions for an attribute column.
+    fn attr_index_spec(immutable: bool, column: &Column) -> (Method, Vec<Expr>) {
+        if column.is_reference() && !column.is_list() {
+            if immutable {
+                (
+                    Method::BTree,
+                    vec![Expr::Column(column.name.as_str().to_string()), Expr::Block],
+                )
+            } else {
+                (
+                    Method::Gist,
+                    vec![
+                        Expr::Column(column.name.as_str().to_string()),
+                        Expr::BlockRange,
+                    ],
+                )
+            }
+        } else if column.use_prefix_comparison {
+            match column.column_type {
+                ColumnType::String => (
+                    Method::BTree,
+                    vec![Expr::Prefix(
+                        column.name.as_str().to_string(),
+                        PrefixKind::Left,
+                    )],
+                ),
+                ColumnType::Bytes => (
+                    Method::BTree,
+                    vec![Expr::Prefix(
+                        column.name.as_str().to_string(),
+                        PrefixKind::Substring,
+                    )],
+                ),
+                _ => unreachable!("only String and Bytes can have arbitrary size"),
+            }
+        } else if column.is_list() || column.is_fulltext() {
+            (
+                Method::Gin,
+                vec![Expr::Column(column.name.as_str().to_string())],
+            )
+        } else {
+            (
+                Method::BTree,
+                vec![Expr::Column(column.name.as_str().to_string())],
+            )
+        }
+    }
+
+    fn add_attribute_indexes(&self, indexes: &mut Vec<CreateIndex>) {
+        for (column_index, column) in self.columns_to_index().enumerate() {
+            if column.is_list() && !ENV_VARS.store.create_gin_indexes {
+                continue;
             }
+            let (method, columns) = Self::attr_index_spec(self.immutable, column);
+            let name = format!(
+                "attr_{}_{}_{}_{}",
+                self.position, column_index, self.name, column.name
+            );
+            indexes.push(CreateIndex::create(
+                &name,
+                &format!("\"{}\"", self.nsp),
+                &self.name.quoted(),
+                false,
+                method,
+                columns,
+                None,
+                None,
+            ));
         }
-        writeln!(out)
+    }
+
+    /// Add an index `<table>_dims` for aggregation tables if the
+    /// aggregation has cumulative aggregates; the index is needed to speed
+    /// up the rollup query as that has to, for cumulative aggregates,
+    /// access this table when we calculate the aggregations for the next
+    /// bucket.
+    ///
+    /// The index we create is made up of the dimensions of the aggregation
+    /// plus the `timestamp` column as the last entry in the index to make
+    /// it usable for rollup queries.
+    ///
+    /// see also: #rollup-query-indexing for the exact query
+    fn add_aggregate_indexes(
+        &self,
+        schema: &InputSchema,
+        indexes: &mut Vec<CreateIndex>,
+    ) -> Result<(), fmt::Error> {
+        let agg = schema
+            .agg_mappings()
+            .find(|mapping| mapping.agg_type(schema) == self.object)
+            .map(|mapping| mapping.aggregation(schema))
+            .filter(|agg| agg.aggregates.iter().any(|a| a.cumulative))
+            .filter(|agg| agg.dimensions().count() > 0);
+
+        let Some(agg) = agg else {
+            return Ok(());
+        };
+
+        let mut columns: Vec<Expr> = agg
+            .dimensions()
+            .map(|dim| {
+                self.column_for_field(&dim.name)
+                    .map(|col| Expr::Column(col.name.as_str().to_string()))
+                    .map_err(|_| fmt::Error)
+            })
+            .collect::<Result<_, _>>()?;
+        columns.push(Expr::Column("timestamp".to_string()));
+
+        let name = format!("{}_dims", self.name);
+        indexes.push(CreateIndex::create(
+            &name,
+            &format!("\"{}\"", self.nsp),
+            &self.name.quoted(),
+            false,
+            Method::BTree,
+            columns,
+            None,
+            None,
+        ));
+        Ok(())
+    }
+
+    /// Return all indexes for this table as `CreateIndex` objects
+    pub(crate) fn indexes(&self, schema: &InputSchema) -> Result<Vec<CreateIndex>, fmt::Error> {
+        let mut indexes = Vec::new();
+        indexes.extend(self.time_travel_indexes());
+        self.add_attribute_indexes(&mut indexes);
+        self.add_aggregate_indexes(schema, &mut indexes)?;
+        Ok(indexes)
     }
 
     /// Generate the DDL for one table, i.e. one `create table` statement
@@ -303,10 +410,19 @@ impl Table {
     ///
     /// See the unit tests at the end of this file for the actual DDL that
     /// gets generated
-    pub(crate) fn as_ddl(&self, catalog: &Catalog, out: &mut String) -> fmt::Result {
+    pub(crate) fn as_ddl(
+        &self,
+        schema: &InputSchema,
+        creat: &IndexCreator,
+        out: &mut String,
+    ) -> fmt::Result {
         self.create_table(out)?;
-        self.create_time_travel_indexes(catalog, out)?;
-        self.create_attribute_indexes(out)
+        for idx in self.indexes(schema)? {
+            if !idx.to_postpone() {
+                writeln!(out, "{};", creat.to_sql(&idx)?)?;
+            }
+        }
+        Ok(())
     }
 
     pub fn exclusion_ddl(&self, out: &mut String) -> fmt::Result {
diff --git a/store/postgres/src/relational/ddl_tests.rs b/store/postgres/src/relational/ddl_tests.rs
index a17544cf2ba..f32aa46d97e 100644
--- a/store/postgres/src/relational/ddl_tests.rs
+++ b/store/postgres/src/relational/ddl_tests.rs
@@ -1,13 +1,13 @@
 use itertools::Itertools;
-// use pretty_assertions::assert_eq;
+use pretty_assertions::assert_eq;
 
 use super::*;
 
-use crate::layout_for_tests::make_dummy_site;
+use crate::{deployment_store::generate_index_creation_sql, layout_for_tests::make_dummy_site};
 
 const ID_TYPE: ColumnType = ColumnType::String;
 
-fn test_layout(gql: &str) -> Layout {
+fn test_layout(gql: &str) -> Arc<Layout> {
     let subgraph = DeploymentHash::new("subgraph").unwrap();
     let schema = InputSchema::parse_latest(gql, subgraph.clone()).expect("Test schema invalid");
     let namespace = Namespace::new("sgd0815".to_owned()).unwrap();
@@ -19,15 +19,13 @@ fn test_layout(gql: &str) -> Layout {
         }
     };
     let catalog = Catalog::for_tests(site.clone(), ents).expect("Can not create catalog");
-    Layout::new(site, &schema, catalog).expect("Failed to construct Layout")
+    Arc::new(Layout::new(site, &schema, catalog).expect("Failed to construct Layout"))
 }
 
 #[test]
 fn table_is_sane() {
     let layout = test_layout(THING_GQL);
-    let table = layout
-        .table(&"thing".into())
-        .expect("failed to get 'thing' table");
+    let table = layout.table("thing").expect("failed to get 'thing' table");
     assert_eq!(SqlName::from("thing"), table.name);
     assert_eq!("Thing", table.object.as_str());
 
@@ -54,12 +52,141 @@ fn table_is_sane() {
 fn check_eqv(left: &str, right: &str) {
     let left_s = left.split_whitespace().join(" ");
     let right_s = right.split_whitespace().join(" ");
-    if left_s != right_s {
-        // Make sure the original strings show up in the error message
-        assert_eq!(left, right);
+    assert_eq!(left_s, right_s);
+}
+
+#[test]
+fn test_manual_index_creation_ddl() {
+    let layout = test_layout(BOOKS_GQL);
+
+    #[track_caller]
+    fn assert_generated_sql(
+        layout: Arc<Layout>,
+        entity_name: &str,
+        field_names: Vec<String>,
+        index_method: &str,
+        expected_format: &str,
+        after: Option<BlockNumber>,
+    ) {
+        let namespace = layout.site.namespace.clone();
+        let expected = expected_format.replace("{namespace}", namespace.as_str());
+
+        let (_, sql): (String, String) = generate_index_creation_sql(
+            layout.clone(),
+            entity_name,
+            field_names,
+            index::Method::from_str(index_method).unwrap(),
+            after,
+        )
+        .unwrap();
+
+        check_eqv(&expected, sql.trim());
     }
+
+    const BTREE: &str = "btree"; // Assuming index::Method is the enum containing the BTree variant
+    const GIST: &str = "gist";
+
+    assert_generated_sql(
+        layout.clone(),
+        "Book",
+        vec!["id".to_string()],
+        BTREE,
+        "create index concurrently if not exists manual_book_id on {namespace}.book using btree (\"id\")",
+        None,
+    );
+
+    assert_generated_sql(
+        layout.clone(),
+        "Book",
+        vec!["content".to_string()],
+        BTREE,
+        "create index concurrently if not exists manual_book_content on {namespace}.book using btree (substring(\"content\", 1, 64))",
+        None,
+    );
+
+    assert_generated_sql(
+        layout.clone(),
+        "Book",
+        vec!["title".to_string()],
+        BTREE,
+        "create index concurrently if not exists manual_book_title on {namespace}.book using btree (left(\"title\", 256))",
+        None,
+    );
+
+    assert_generated_sql(
+        layout.clone(),
+        "Book",
+        vec!["page_count".to_string()],
+        BTREE,
+        "create index concurrently if not exists manual_book_page_count on {namespace}.book using btree (\"page_count\")",
+        None,
+    );
+
+    assert_generated_sql(
+        layout.clone(),
+        "Book",
+        vec!["page_count".to_string(), "title".to_string()],
+        BTREE,
+        "create index concurrently if not exists manual_book_page_count_title on {namespace}.book using btree (\"page_count\", left(\"title\", 256))",
+        None,
+    );
+
+    assert_generated_sql(
+        layout.clone(),
+        "Book",
+        vec!["content".to_string(), "block_range".to_string()], // Explicitly including 'block_range'
+        GIST,
+        "create index concurrently if not exists manual_book_content_block_range on {namespace}.book using gist (substring(\"content\", 1, 64), block_range)",
+        None,
+    );
+
+    assert_generated_sql(
+        layout.clone(),
+        "Book",
+        vec!["page_count".to_string()],
+        BTREE,
+        "create index concurrently if not exists manual_book_page_count_12345 on sgd0815.book using btree (\"page_count\")  where coalesce(upper(block_range), 2147483647) > 12345",
+        Some(12345),
+    );
 }
 
+#[test]
+fn generate_postponed_indexes() {
+    let layout = test_layout(THING_GQL);
+    let table = layout.table(&SqlName::from("Scalar")).unwrap();
+    let postponed: Vec<_> = table
+        .indexes(&layout.input_schema)
+        .unwrap()
+        .into_iter()
+        .filter(|idx| idx.to_postpone())
+        .collect();
+    assert_eq!(7, postponed.len());
+
+    let creat = layout.index_creator(true, true);
+    let queries: Vec<_> = postponed
+        .iter()
+        .map(|idx| creat.to_sql(idx).unwrap())
+        .collect();
+    let queries = queries.join(";\n");
+    check_eqv(THING_POSTPONED_INDEXES, &queries);
+}
+const THING_POSTPONED_INDEXES: &str = r#"
+create index concurrently if not exists attr_1_1_scalar_bool
+    on "sgd0815"."scalar" using btree ("bool");
+create index concurrently if not exists attr_1_2_scalar_int
+    on "sgd0815"."scalar" using btree ("int");
+create index concurrently if not exists attr_1_3_scalar_big_decimal
+    on "sgd0815"."scalar" using btree ("big_decimal");
+create index concurrently if not exists attr_1_4_scalar_string
+    on "sgd0815"."scalar" using btree (left("string", 256));
+create index concurrently if not exists attr_1_5_scalar_bytes
+    on "sgd0815"."scalar" using btree (substring("bytes", 1, 64));
+create index concurrently if not exists attr_1_6_scalar_big_int
+    on "sgd0815"."scalar" using btree ("big_int");
+create index concurrently if not exists attr_1_7_scalar_color
+    on "sgd0815"."scalar" using btree ("color")
+"#;
+
 #[test]
 fn generate_ddl() {
     let layout = test_layout(THING_GQL);
@@ -85,6 +212,10 @@ fn generate_ddl() {
     let layout = test_layout(TS_GQL);
     let sql = layout.as_ddl().expect("Failed to generate DDL");
     check_eqv(TS_SQL, &sql);
+
+    let layout = test_layout(LIFETIME_GQL);
+    let sql = layout.as_ddl().expect("Failed to generate DDL");
+    check_eqv(LIFETIME_SQL, &sql);
 }
 
 #[test]
@@ -191,6 +322,46 @@ fn can_copy_from() {
     );
 }
 
+/// Check that we do not create the index on `block$` twice. With the new
+/// `Table::indexes()` approach, the `block$` index (time-travel) and the
+/// `attr_*_block` index (attribute) are both generated by `indexes()` but
+/// only the attribute one can be postponed.
+#[test]
+fn postponed_indexes_with_block_column() {
+    fn cr(index: &str) -> String {
+        format!("create index{}", index)
+    }
+
+    // Names of the two indexes we are interested in. Note the leading space
+    // to guard a little against overlapping names
+    const BLOCK_IDX: &str = " data_block";
+    const ATTR_IDX: &str = " attr_1_0_data_block";
+
+    let layout = test_layout(BLOCK_GQL);
+
+    // Create everything; when postpone is enabled (debug builds), the
+    // attribute btree index is omitted from the DDL
+    let sql = layout.as_ddl().unwrap();
+    assert!(sql.contains(&cr(BLOCK_IDX)));
+    // The block$ time-travel index appears exactly once
+    let count = sql.matches(BLOCK_IDX).count();
+    assert_eq!(1, count);
+
+    let table = layout.table(&SqlName::from("Data")).unwrap();
+    let postponed: Vec<_> = table
+        .indexes(&layout.input_schema)
+        .unwrap()
+        .into_iter()
+        .filter(|idx| idx.to_postpone())
+        .collect();
+    assert_eq!(1, postponed.len());
+
+    let creat = layout.index_creator(false, false);
+    let sql = creat.to_sql(&postponed[0]).unwrap();
+    assert!(!sql.contains(BLOCK_IDX));
+    assert!(sql.contains(&cr(ATTR_IDX)));
+}
+
 const THING_GQL: &str = r#"
         type Thing @entity {
             id: ID!
@@ -223,7 +394,7 @@ create type sgd0815."size"
     as enum ('large', 'medium', 'small');
 
     create table "sgd0815"."thing" (
-        vid                  bigserial primary key,
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null,
         "big_thing"          text not null
@@ -231,24 +402,17 @@ create type sgd0815."size"
 
     alter table "sgd0815"."thing"
         add constraint thing_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_thing
-    on "sgd0815"."thing"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index thing_block_range_closed
-    on "sgd0815"."thing"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_0_0_thing_id
-    on "sgd0815"."thing" using btree("id");
-create index attr_0_1_thing_big_thing
-    on "sgd0815"."thing" using gist("big_thing", block_range);
-
+create index brin_thing on "sgd0815"."thing" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index thing_block_range_closed on "sgd0815"."thing" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_0_0_thing_id on "sgd0815"."thing" using btree ("id");
+create index attr_0_1_thing_big_thing on "sgd0815"."thing" using gist ("big_thing", block_range);
 
     create table "sgd0815"."scalar" (
-        vid                  bigserial primary key,
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null,
         "bool"               boolean,
-        "int"                integer,
+        "int"                int4,
         "big_decimal"        numeric,
         "string"             text,
         "bytes"              bytea,
@@ -258,32 +422,12 @@ create index attr_0_1_thing_big_thing
 
     alter table "sgd0815"."scalar"
         add constraint scalar_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_scalar
-    on "sgd0815"."scalar"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index scalar_block_range_closed
-    on "sgd0815"."scalar"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_1_0_scalar_id
-    on "sgd0815"."scalar" using btree("id");
-create index attr_1_1_scalar_bool
-    on "sgd0815"."scalar" using btree("bool");
-create index attr_1_2_scalar_int
-    on "sgd0815"."scalar" using btree("int");
-create index attr_1_3_scalar_big_decimal
-    on "sgd0815"."scalar" using btree("big_decimal");
-create index attr_1_4_scalar_string
-    on "sgd0815"."scalar" using btree(left("string", 256));
-create index attr_1_5_scalar_bytes
-    on "sgd0815"."scalar" using btree(substring("bytes", 1, 64));
-create index attr_1_6_scalar_big_int
-    on "sgd0815"."scalar" using btree("big_int");
-create index attr_1_7_scalar_color
-    on "sgd0815"."scalar" using btree("color");
-
+create index brin_scalar on "sgd0815"."scalar" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index scalar_block_range_closed on "sgd0815"."scalar" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_1_0_scalar_id on "sgd0815"."scalar" using btree ("id");
 
     create table "sgd0815"."file_thing" (
-        vid                  bigserial primary key,
+        vid                  bigint primary key,
         block_range          int4range not null,
         causality_region     int not null,
         "id"                 text not null
@@ -291,17 +435,25 @@ create index attr_1_7_scalar_color
 
     alter table "sgd0815"."file_thing"
         add constraint file_thing_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_file_thing
-    on "sgd0815"."file_thing"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index file_thing_block_range_closed
-    on "sgd0815"."file_thing"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_2_0_file_thing_id
-    on "sgd0815"."file_thing" using btree("id");
-
+create index brin_file_thing on "sgd0815"."file_thing" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index file_thing_block_range_closed on "sgd0815"."file_thing" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_2_0_file_thing_id on "sgd0815"."file_thing" using btree ("id");
 "#;
 
+const BOOKS_GQL: &str = r#"type Author @entity {
+    id: ID!
+    name: String!
+    books: [Book!]! @derivedFrom(field: "author")
+}
+
+type Book @entity {
+    id: ID!
+    title: String!
+    content: Bytes!
+    pageCount: BigInt!
+    author: Author!
+}"#;
+
 const MUSIC_GQL: &str = r#"type Musician @entity {
     id: ID!
     name: String!
@@ -329,85 +481,59 @@ type SongStat @entity {
     song: Song @derivedFrom(field: "id")
     played: Int!
 }"#;
-const MUSIC_DDL: &str = r#"create table "sgd0815"."musician" (
-        vid                  bigserial primary key,
+const MUSIC_DDL: &str = r#"
+    create table "sgd0815"."musician" (
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null,
         "name"               text not null,
         "main_band"          text,
         "bands"              text[] not null
-);
-alter table "sgd0815"."musician"
-  add constraint musician_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_musician
-    on "sgd0815"."musician"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index musician_block_range_closed
-    on "sgd0815"."musician"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_0_0_musician_id
-    on "sgd0815"."musician" using btree("id");
-create index attr_0_1_musician_name
-    on "sgd0815"."musician" using btree(left("name", 256));
-create index attr_0_2_musician_main_band
-    on "sgd0815"."musician" using gist("main_band", block_range);
-
-create table "sgd0815"."band" (
-        vid                  bigserial primary key,
+    );
+
+    alter table "sgd0815"."musician"
+        add constraint musician_id_block_range_excl exclude using gist (id with =, block_range with &&);
+create index brin_musician on "sgd0815"."musician" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index musician_block_range_closed on "sgd0815"."musician" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_0_0_musician_id on "sgd0815"."musician" using btree ("id");
+create index attr_0_2_musician_main_band on "sgd0815"."musician" using gist ("main_band", block_range);
+
+    create table "sgd0815"."band" (
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null,
         "name"               text not null,
         "original_songs"     text[] not null
-);
-alter table "sgd0815"."band"
-  add constraint band_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_band
-    on "sgd0815"."band"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index band_block_range_closed
-    on "sgd0815"."band"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_1_0_band_id
-    on "sgd0815"."band" using btree("id");
-create index attr_1_1_band_name
-    on "sgd0815"."band" using btree(left("name", 256));
-
-create table "sgd0815"."song" (
-        vid                    bigserial primary key,
-        block$                 int not null,
-        "id"                 text not null,
+    );
+
+    alter table "sgd0815"."band"
+        add constraint band_id_block_range_excl exclude using gist (id with =, block_range with &&);
+create index brin_band on "sgd0815"."band" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index band_block_range_closed on "sgd0815"."band" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_1_0_band_id on "sgd0815"."band" using btree ("id");
+
+    create table "sgd0815"."song" (
+        vid                  bigint primary key,
+        block$                int not null,
+"id"                 text not null,
         "title"              text not null,
         "written_by"         text not null,
-
         unique(id)
-);
-create index brin_song
-    on "sgd0815"."song"
- using brin(block$ int4_minmax_ops, vid int8_minmax_ops);
-create index attr_2_0_song_title
-    on "sgd0815"."song" using btree(left("title", 256));
-create index attr_2_1_song_written_by
-    on "sgd0815"."song" using btree("written_by", block$);
-
-create table "sgd0815"."song_stat" (
-        vid                  bigserial primary key,
+    );
+create index song_block on "sgd0815"."song" using btree (block$);
+
+    create table "sgd0815"."song_stat" (
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null,
-        "played"             integer not null
-);
-alter table "sgd0815"."song_stat"
-  add constraint song_stat_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_song_stat
-    on "sgd0815"."song_stat"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index song_stat_block_range_closed
-    on "sgd0815"."song_stat"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_3_0_song_stat_id
-    on "sgd0815"."song_stat" using btree("id");
-create index attr_3_1_song_stat_played
-    on "sgd0815"."song_stat" using btree("played");
+        "played"             int4 not null
+    );
 
+    alter table "sgd0815"."song_stat"
+        add constraint song_stat_id_block_range_excl exclude using gist (id with =, block_range with &&);
+create index brin_song_stat on "sgd0815"."song_stat" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index song_stat_block_range_closed on "sgd0815"."song_stat" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_3_0_song_stat_id on "sgd0815"."song_stat" using btree ("id");
 "#;
 
 const FOREST_GQL: &str = r#"
@@ -431,61 +557,47 @@ type Habitat @entity {
     dwellers: [ForestDweller!]!
 }"#;
 
-const FOREST_DDL: &str = r#"create table "sgd0815"."animal" (
-        vid                  bigserial primary key,
+const FOREST_DDL: &str = r#"
+    create table "sgd0815"."animal" (
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null,
         "forest"             text
-);
-alter table "sgd0815"."animal"
-  add constraint animal_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_animal
-    on "sgd0815"."animal"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index animal_block_range_closed
-    on "sgd0815"."animal"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_0_0_animal_id
-    on "sgd0815"."animal" using btree("id");
-create index attr_0_1_animal_forest
-    on "sgd0815"."animal" using gist("forest", block_range);
-
-create table "sgd0815"."forest" (
-        vid                  bigserial primary key,
+    );
+
+    alter table "sgd0815"."animal"
+        add constraint animal_id_block_range_excl exclude using gist (id with =, block_range with &&);
+create index brin_animal on "sgd0815"."animal" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index animal_block_range_closed on "sgd0815"."animal" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_0_0_animal_id on "sgd0815"."animal" using btree ("id");
+create index attr_0_1_animal_forest on "sgd0815"."animal" using gist ("forest", block_range);
+
+    create table "sgd0815"."forest" (
+        vid                  bigint primary key,
         block_range          int4range not null,
-        "id"               text not null
-);
-alter table "sgd0815"."forest"
-  add constraint forest_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_forest
-    on "sgd0815"."forest"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index forest_block_range_closed
-    on "sgd0815"."forest"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_1_0_forest_id
-    on "sgd0815"."forest" using btree("id");
-
-create table "sgd0815"."habitat" (
-        vid                  bigserial primary key,
+        "id"                 text not null
+    );
+
+    alter table "sgd0815"."forest"
+        add constraint forest_id_block_range_excl exclude using gist (id with =, block_range with &&);
+create index brin_forest on "sgd0815"."forest" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index forest_block_range_closed on "sgd0815"."forest" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_1_0_forest_id on "sgd0815"."forest" using btree ("id");
+
+    create table "sgd0815"."habitat" (
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null,
         "most_common"        text not null,
         "dwellers"           text[] not null
-);
-alter table "sgd0815"."habitat"
-  add constraint habitat_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_habitat
-    on "sgd0815"."habitat"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index habitat_block_range_closed
-    on "sgd0815"."habitat"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_2_0_habitat_id
-    on "sgd0815"."habitat" using btree("id");
-create index attr_2_1_habitat_most_common
-    on "sgd0815"."habitat" using gist("most_common", block_range);
+    );
 
+    alter table "sgd0815"."habitat"
+        add constraint habitat_id_block_range_excl exclude using gist (id with =, block_range with &&);
+create index brin_habitat on "sgd0815"."habitat" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index habitat_block_range_closed on "sgd0815"."habitat" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_2_0_habitat_id on "sgd0815"."habitat" using btree ("id");
+create index attr_2_1_habitat_most_common on "sgd0815"."habitat" using gist ("most_common", block_range);
 "#;
 const FULLTEXT_GQL: &str = r#"
 type _Schema_ @fulltext(
@@ -518,71 +630,51 @@ type Habitat @entity {
     dwellers: [Animal!]!
 }"#;
 
-const FULLTEXT_DDL: &str = r#"create table "sgd0815"."animal" (
-        vid                  bigserial primary key,
+const FULLTEXT_DDL: &str = r#"
+    create table "sgd0815"."animal" (
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null,
         "name"               text not null,
         "species"            text not null,
         "forest"             text,
         "search"             tsvector
-);
-alter table "sgd0815"."animal"
-  add constraint animal_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_animal
-    on "sgd0815"."animal"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index animal_block_range_closed
-    on "sgd0815"."animal"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_0_0_animal_id
-    on "sgd0815"."animal" using btree("id");
-create index attr_0_1_animal_name
-    on "sgd0815"."animal" using btree(left("name", 256));
-create index attr_0_2_animal_species
-    on "sgd0815"."animal" using btree(left("species", 256));
-create index attr_0_3_animal_forest
-    on "sgd0815"."animal" using gist("forest", block_range);
-create index attr_0_4_animal_search
-    on "sgd0815"."animal" using gin("search");
-
-create table "sgd0815"."forest" (
-        vid                  bigserial primary key,
+    );
+
+    alter table "sgd0815"."animal"
+        add constraint animal_id_block_range_excl exclude using gist (id with =, block_range with &&);
+create index brin_animal on "sgd0815"."animal" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index animal_block_range_closed on "sgd0815"."animal" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_0_0_animal_id on "sgd0815"."animal" using btree ("id");
+create index attr_0_3_animal_forest on "sgd0815"."animal" using gist ("forest", block_range);
+create index attr_0_4_animal_search on "sgd0815"."animal" using gin ("search");
+
+    create table "sgd0815"."forest" (
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null
-);
-alter table "sgd0815"."forest"
-  add constraint forest_id_block_range_excl exclude using gist (id with =, block_range with &&);
-
-create index brin_forest
-    on "sgd0815"."forest"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index forest_block_range_closed
-    on "sgd0815"."forest"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_1_0_forest_id
-    on "sgd0815"."forest" using btree("id");
-
-create table "sgd0815"."habitat" (
-        vid                  bigserial primary key,
+    );
+
+    alter table "sgd0815"."forest"
+        add constraint forest_id_block_range_excl exclude using gist (id with =, block_range with &&);
+create index brin_forest on "sgd0815"."forest" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index forest_block_range_closed on "sgd0815"."forest" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_1_0_forest_id on "sgd0815"."forest" using btree ("id");
+
+    create table "sgd0815"."habitat" (
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null,
         "most_common"        text not null,
         "dwellers"           text[] not null
-);
-alter table "sgd0815"."habitat"
-  add constraint habitat_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_habitat
-    on "sgd0815"."habitat"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index habitat_block_range_closed
-    on "sgd0815"."habitat"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_2_0_habitat_id
-    on "sgd0815"."habitat" using btree("id");
-create index attr_2_1_habitat_most_common
-    on "sgd0815"."habitat" using gist("most_common", block_range);
+    );
 
+    alter table "sgd0815"."habitat"
+        add constraint habitat_id_block_range_excl exclude using gist (id with =, block_range with &&);
+create index brin_habitat on "sgd0815"."habitat" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index habitat_block_range_closed on "sgd0815"."habitat" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_2_0_habitat_id on "sgd0815"."habitat" using btree ("id");
+create index attr_2_1_habitat_most_common on "sgd0815"."habitat" using gist ("most_common", block_range);
 "#;
 
 const FORWARD_ENUM_GQL: &str = r#"
@@ -598,93 +690,201 @@ enum Orientation {
 
 const FORWARD_ENUM_SQL: &str = r#"create type sgd0815."orientation"
     as enum ('DOWN', 'UP');
-create table "sgd0815"."thing" (
-        vid                  bigserial primary key,
+
+    create table "sgd0815"."thing" (
+        vid                  bigint primary key,
         block_range          int4range not null,
         "id"                 text not null,
         "orientation"        "sgd0815"."orientation" not null
-);
-alter table "sgd0815"."thing"
-  add constraint thing_id_block_range_excl exclude using gist (id with =, block_range with &&);
-create index brin_thing
-    on "sgd0815"."thing"
- using brin(lower(block_range) int4_minmax_ops, coalesce(upper(block_range), 2147483647) int4_minmax_ops, vid int8_minmax_ops);
-create index thing_block_range_closed
-    on "sgd0815"."thing"(coalesce(upper(block_range), 2147483647))
- where coalesce(upper(block_range), 2147483647) < 2147483647;
-create index attr_0_0_thing_id
-    on "sgd0815"."thing" using btree("id");
-create index attr_0_1_thing_orientation
-    on "sgd0815"."thing" using btree("orientation");
+    );
 
+    alter table "sgd0815"."thing"
+        add constraint thing_id_block_range_excl exclude using gist (id with =, block_range with &&);
+create index brin_thing on "sgd0815"."thing" using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid);
+create index thing_block_range_closed on "sgd0815"."thing" using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647);
+create index attr_0_0_thing_id on "sgd0815"."thing" using btree ("id");
 "#;
 
 const TS_GQL: &str = r#"
 type Data @entity(timeseries: true) {
     id: Int8!
-    timestamp: Int8!
+    timestamp: Timestamp!
     amount: BigDecimal!
 }
 
 type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
     id:        Int8!
-    timestamp: Int8!
+    timestamp: Timestamp!
     volume:    BigDecimal! @aggregate(fn: "sum", arg: "amount")
     maxPrice:  BigDecimal! @aggregate(fn: "max", arg: "amount")
 }
 "#;
 
 const TS_SQL: &str = r#"
-create table "sgd0815"."data" (
-    vid                  bigserial primary key,
-    block$                int not null,
-    "id"                 int8 not null,
-    "timestamp"          int8 not null,
-    "amount"             numeric not null,
-    unique(id)
-);
-create index brin_data
-    on "sgd0815"."data"
- using brin(block$ int4_minmax_ops, vid int8_minmax_ops);
-create index attr_0_0_data_timestamp
-    on "sgd0815"."data" using btree("timestamp");
-create index attr_0_1_data_amount
-    on "sgd0815"."data" using btree("amount");
-
-create table "sgd0815"."stats_hour" (
-    vid                  bigserial primary key,
-    block$                int not null,
-    "id"                 int8 not null,
-    "timestamp"          int8 not null,
-    "volume"             numeric not null,
-    "max_price"          numeric not null,
-    unique(id)
-);
-create index brin_stats_hour
-    on "sgd0815"."stats_hour"
- using brin(block$ int4_minmax_ops, vid int8_minmax_ops);
-create index attr_1_0_stats_hour_timestamp
-    on "sgd0815"."stats_hour" using btree("timestamp");
-create index attr_1_1_stats_hour_volume
-    on "sgd0815"."stats_hour" using btree("volume");
-create index attr_1_2_stats_hour_max_price
-    on "sgd0815"."stats_hour" using btree("max_price");
-
-create table "sgd0815"."stats_day" (
-    vid                  bigserial primary key,
-    block$               int not null,
-    "id"                 int8 not null,
-    "timestamp"          int8 not null,
-    "volume"             numeric not null,
-    "max_price"          numeric not null,
-    unique(id)
-);
-create index brin_stats_day
-    on "sgd0815"."stats_day"
- using brin(block$ int4_minmax_ops, vid int8_minmax_ops);
-create index attr_2_0_stats_day_timestamp
-    on "sgd0815"."stats_day" using btree("timestamp");
-create index attr_2_1_stats_day_volume
-    on "sgd0815"."stats_day" using btree("volume");
-create index attr_2_2_stats_day_max_price
-    on "sgd0815"."stats_day" using btree("max_price");"#;
+    create table "sgd0815"."data" (
+        vid                  bigint primary key,
+        block$                int not null,
+"id"                 int8 not null,
+        "timestamp"          timestamptz not null,
+        "amount"             numeric not null,
+        unique(id)
+    );
+create index data_block on "sgd0815"."data" using btree (block$);
+
+    create table "sgd0815"."stats_hour" (
+        vid                  bigserial primary key,
+        block$                int not null,
+"id"                 int8 not null,
+        "timestamp"          timestamptz not null,
+        "volume"             numeric not null,
+        "max_price"          numeric not null,
+        unique(id)
+    );
+create index stats_hour_block on "sgd0815"."stats_hour" using btree (block$);
+
+    create table "sgd0815"."stats_day" (
+        vid                  bigserial primary key,
+        block$                int not null,
+"id"                 int8 not null,
+        "timestamp"          timestamptz not null,
+        "volume"             numeric not null,
+        "max_price"          numeric not null,
+        unique(id)
+    );
+create index stats_day_block on "sgd0815"."stats_day" using btree (block$);
+"#;
+
+const LIFETIME_GQL: &str = r#"
+    type Data @entity(timeseries: true) {
+        id: Int8!
+        timestamp: Timestamp!
+        group1: Int!
+        group2: Int!
+        amount: BigDecimal!
+    }
+
+    type Stats1 @aggregation(intervals: ["hour", "day"], source: "Data") {
+        id:        Int8!
+        timestamp: Timestamp!
+        volume:    BigDecimal! @aggregate(fn: "sum", arg: "amount", cumulative: true)
+    }
+
+    type Stats2 @aggregation(intervals: ["hour", "day"], source: "Data") {
+        id:        Int8!
+        timestamp: Timestamp!
+        group1: Int!
+        volume:    BigDecimal! @aggregate(fn: "sum", arg: "amount", cumulative: true)
+    }
+
+    type Stats3 @aggregation(intervals: ["hour", "day"], source: "Data") {
+        id:        Int8!
+        timestamp: Timestamp!
+        group2: Int!
+        group1: Int!
+        volume:    BigDecimal! @aggregate(fn: "sum", arg: "amount", cumulative: true)
+    }
+
+    type Stats2 @aggregation(intervals: ["hour", "day"], source: "Data") {
+        id:        Int8!
+        timestamp: Timestamp!
+        group1: Int!
+        group2: Int!
+        volume:    BigDecimal! @aggregate(fn: "sum", arg: "amount", cumulative: true)
+    }
+    "#;
+
+const LIFETIME_SQL: &str = r#"
+    create table "sgd0815"."data" (
+        vid                  bigint primary key,
+        block$                int not null,
+"id"                 int8 not null,
+        "timestamp"          timestamptz not null,
+        "group_1"            int4 not null,
+        "group_2"            int4 not null,
+        "amount"             numeric not null,
+        unique(id)
+    );
+create index data_block on "sgd0815"."data" using btree (block$);
+
+    create table "sgd0815"."stats_1_hour" (
+        vid                  bigserial primary key,
+        block$                int not null,
+"id"                 int8 not null,
+        "timestamp"          timestamptz not null,
+        "volume"             numeric not null,
+        unique(id)
+    );
+create index stats_1_hour_block on "sgd0815"."stats_1_hour" using btree (block$);
+
+    create table "sgd0815"."stats_1_day" (
+        vid                  bigserial primary key,
+        block$                int not null,
+"id"                 int8 not null,
+        "timestamp"          timestamptz not null,
+        "volume"             numeric not null,
+        unique(id)
+    );
+create index stats_1_day_block on "sgd0815"."stats_1_day" using btree (block$);
+
+    create table "sgd0815"."stats_2_hour" (
+        vid                  bigserial primary key,
+        block$                int not null,
+"id"                 int8 not null,
+        "timestamp"          timestamptz not null,
+        "group_1"            int4 not null,
+        "volume"             numeric not null,
+        unique(id)
+    );
+create index stats_2_hour_block on "sgd0815"."stats_2_hour" using btree (block$);
+create index stats_2_hour_dims on "sgd0815"."stats_2_hour" using btree ("group_1", "timestamp");
+
+    create table "sgd0815"."stats_2_day" (
+        vid                  bigserial primary key,
+        block$                int not null,
+"id"                 int8 not null,
+        "timestamp"          timestamptz not null,
+        "group_1"            int4 not null,
+        "volume"             numeric not null,
+        unique(id)
+    );
+create index stats_2_day_block on "sgd0815"."stats_2_day" using btree (block$);
+create index stats_2_day_dims on "sgd0815"."stats_2_day" using btree ("group_1", "timestamp");
+
+    create table "sgd0815"."stats_3_hour" (
+        vid                  bigserial primary key,
+        block$                int not null,
+"id"                 int8 not null,
+        "timestamp"          timestamptz not null,
+        "group_2"            int4 not null,
+        "group_1"            int4 not null,
+        "volume"             numeric not null,
+        unique(id)
+    );
+create index stats_3_hour_block on "sgd0815"."stats_3_hour" using btree (block$);
+create index stats_3_hour_dims on "sgd0815"."stats_3_hour" using btree ("group_2", "group_1", "timestamp");
+
+    create table "sgd0815"."stats_3_day" (
+        vid                  bigserial primary key,
+        block$                int not null,
+"id"                 int8 not null,
+        "timestamp"          timestamptz not null,
+        "group_2"            int4 not null,
+        "group_1"            int4 not null,
+        "volume"             numeric not null,
+        unique(id)
+    );
+create index stats_3_day_block on "sgd0815"."stats_3_day" using btree (block$);
+create index stats_3_day_dims on "sgd0815"."stats_3_day" using btree ("group_2", "group_1", "timestamp");
+"#;
+
+const BLOCK_GQL: &str = r#"
+type Block @entity(immutable: true) {
+    id: ID!
+    number: Int!
+}
+
+type Data @entity(immutable: true) {
+    id: ID!
+    block: Block!
+}
+"#;
diff --git a/store/postgres/src/relational/dsl.rs b/store/postgres/src/relational/dsl.rs
new file mode 100644
index 00000000000..9d53bc1a66c
--- /dev/null
+++ b/store/postgres/src/relational/dsl.rs
@@ -0,0 +1,812 @@
+//! Helpers for creating relational queries using diesel. A lot of this code
+//! is copied from `diesel_dynamic_schema` and adapted to our data
+//! structures, especially the `Table` and `Column` types.
+
+use std::marker::PhantomData;
+
+use diesel::backend::Backend;
+use diesel::dsl::sql;
+use diesel::expression::{TypedExpressionType, ValidGrouping, expression_types, is_aggregate};
+use diesel::pg::Pg;
+use diesel::query_builder::{
+    AsQuery, AstPass, BoxedSelectStatement, FromClause, Query, QueryFragment, QueryId,
+    SelectStatement,
+};
+use diesel::query_dsl::methods::SelectDsl;
+use diesel::query_source::QuerySource;
+
+use diesel::sql_types::{
+    Array, BigInt, Binary, Bool, Integer, Nullable, Numeric, Range, SingleValue, Text, Timestamptz,
+    Untyped,
+};
+use diesel::{AppearsOnTable, Expression, QueryDsl, QueryResult, SelectableExpression};
+use diesel_dynamic_schema::DynamicSelectClause;
+use graph::components::store::{AttributeNames, BLOCK_NUMBER_MAX, BlockNumber, StoreError};
+use graph::data::store::{ID, Id, IdType, VID};
+use graph::data_source::CausalityRegion;
+use graph::prelude::{ENV_VARS, lazy_static};
+
+use crate::relational::ColumnType;
+use crate::relational_queries::PARENT_ID;
+
+use super::Column as RelColumn;
+use super::SqlName;
+use super::value::FromOidRow;
+use super::{BLOCK_COLUMN, BLOCK_RANGE_COLUMN, CAUSALITY_REGION_COLUMN};
+
+const TYPENAME: &str = "__typename";
+
+lazy_static! {
+    pub static ref TYPENAME_SQL: SqlName = TYPENAME.into();
+    pub static ref VID_SQL: SqlName = "vid".into();
+    pub static ref PARENT_SQL: SqlName = PARENT_ID.into();
+    pub static ref TYPENAME_COL: RelColumn = RelColumn::pseudo_column(TYPENAME, ColumnType::String);
+    pub static ref VID_COL: RelColumn = RelColumn::pseudo_column("vid", ColumnType::Int8);
+    pub static ref BLOCK_COL: RelColumn = RelColumn::pseudo_column(BLOCK_COLUMN, ColumnType::Int8);
+    // The column type is a placeholder; block_range is deserialized as
+    // int4range via special handling in select_cols
+    pub static ref BLOCK_RANGE_COL: RelColumn =
+        RelColumn::pseudo_column(BLOCK_RANGE_COLUMN, ColumnType::Bytes);
+    pub static ref PARENT_STRING_COL: RelColumn = RelColumn::pseudo_column(PARENT_ID, ColumnType::String);
+    pub static ref PARENT_BYTES_COL: RelColumn = RelColumn::pseudo_column(PARENT_ID, ColumnType::Bytes);
+    pub static ref PARENT_INT_COL: RelColumn = RelColumn::pseudo_column(PARENT_ID, ColumnType::Int8);
+    pub static ref CAUSALITY_REGION_COL: RelColumn =
+        RelColumn::pseudo_column(CAUSALITY_REGION_COLUMN, ColumnType::Int);
+
+    pub static ref META_COLS: [&'static RelColumn; 2] = [&*TYPENAME_COL, &*VID_COL];
+}
+
+#[doc(hidden)]
+/// A dummy expression.
+pub struct DummyExpression;
+
+impl DummyExpression {
+    pub(crate) fn new() -> Self {
+        DummyExpression
+    }
+}
+
+impl<QS> SelectableExpression<QS> for DummyExpression {}
+
+impl<QS> AppearsOnTable<QS> for DummyExpression {}
+
+impl Expression for DummyExpression {
+    type SqlType = expression_types::NotSelectable;
+}
+
+impl ValidGrouping<()> for DummyExpression {
+    type IsAggregate = is_aggregate::No;
+}
+
+/// A fixed size string for the table alias. We want to make sure that
+/// converting these to `&str` doesn't allocate and that they are small
+/// enough that the `Table` struct is only 16 bytes and can be `Copy`
+#[derive(Debug, Clone, Copy)]
+pub struct ChildAliasStr {
+    alias: [u8; 4],
+}
+
+impl ChildAliasStr {
+    fn new(idx: u8) -> Self {
+        let c = b'i';
+        let alias = if idx == 0 {
+            [c, 0, 0, 0]
+        } else if idx < 10 {
+            let ones = char::from_digit(idx as u32, 10).unwrap() as u8;
+            [c, ones, 0, 0]
+        } else if idx < 100 {
+            let tens = char::from_digit((idx / 10) as u32, 10).unwrap() as u8;
+            let ones = char::from_digit((idx % 10) as u32, 10).unwrap() as u8;
+            [c, tens, ones, 0]
+        } else {
+            let hundreds = char::from_digit((idx / 100) as u32, 10).unwrap() as u8;
+            let idx = idx % 100;
+            let tens = char::from_digit((idx / 10) as u32, 10).unwrap() as u8;
+            let ones = char::from_digit((idx % 10) as u32, 10).unwrap() as u8;
+            [c, hundreds, tens, ones]
+        };
+        ChildAliasStr { alias }
+    }
+
+    fn as_str(&self) -> &str {
+        let alias = if self.alias[1] == 0 {
+            return "i";
+        } else if self.alias[2] == 0 {
+            &self.alias[..2]
+        } else if self.alias[3] == 0 {
+            &self.alias[..3]
+        } else {
+            &self.alias
+        };
+        unsafe { std::str::from_utf8_unchecked(alias) }
+    }
+}
+
+/// A table alias. We use `c` as the main table alias and `i`, `i1`, `i2`,
+/// ... for child tables. The fact that we use these specific letters is
+/// historical and doesn't have any meaning.
+#[derive(Debug, Clone, Copy)]
+pub enum Alias {
+    Main,
+    Child(ChildAliasStr),
+}
+
+impl Alias {
+    pub(crate) fn as_str(&self) -> &str {
+        match self {
+            Alias::Main => "c",
+            Alias::Child(idx) => idx.as_str(),
+        }
+    }
+
+    fn child(idx: u8) -> Self {
+        Alias::Child(ChildAliasStr::new(idx))
+    }
+}
+
+#[test]
+fn alias() {
+    assert_eq!(Alias::Main.as_str(), "c");
+    assert_eq!(Alias::Child(ChildAliasStr::new(0)).as_str(), "i");
+    assert_eq!(Alias::Child(ChildAliasStr::new(1)).as_str(), "i1");
+    assert_eq!(Alias::Child(ChildAliasStr::new(10)).as_str(), "i10");
+    assert_eq!(Alias::Child(ChildAliasStr::new(100)).as_str(), "i100");
+    assert_eq!(Alias::Child(ChildAliasStr::new(255)).as_str(), "i255");
+}
+
+#[derive(Debug, Clone, Copy)]
+/// A wrapper around the `super::Table` struct that provides helper
+/// functions for generating SQL queries
+pub struct Table<'a> {
+    /// The metadata for this table
+    pub meta: &'a super::Table,
+    pub(crate) alias: Alias,
+}
+
+impl<'a> Table<'a> {
+    pub(crate) fn new(meta: &'a super::Table) -> Self {
+        Self {
+            meta,
+            alias: Alias::Main,
+        }
+    }
+
+    /// Change the alias for this table to be a child table.
+    pub fn child(mut self, idx: u8) -> Self {
+        self.alias = Alias::child(idx);
+        self
+    }
+
+    /// Reference a column in this table and use the correct SQL type `ST`
+    fn bind<ST>(&self, name: &str) -> Option<BoundColumn<'_, ST>> {
+        self.column(name).map(|c| c.bind())
+    }
+
+    /// Reference a column without regard to the underlying SQL type. This
+    /// is useful if just the name of the column qualified with the table
+    /// name/alias is needed
+    pub fn column(&self, name: &str) -> Option<Column<'a>> {
+        let block_col: &RelColumn = if self.meta.immutable {
+            &BLOCK_COL
+        } else {
+            &BLOCK_RANGE_COL
+        };
+        let cr_col: Option<&RelColumn> = if self.meta.has_causality_region {
+            Some(&*CAUSALITY_REGION_COL)
+        } else {
+            None
+        };
+        self.meta
+            .columns
+            .iter()
+            .chain(*META_COLS)
+            .chain(std::iter::once(block_col))
+            .chain(cr_col)
+            .find(|c| &c.name == name)
+            .map(|c| Column::new(*self, c))
+    }
+
+    pub fn name(&self) -> &str {
+        &self.meta.name
+    }
+
+    pub fn column_for_field(&self, field: &str) -> Result<Column<'a>, StoreError> {
+        self.meta
+            .column_for_field(field)
+            .map(|column| Column::new(*self, column))
+    }
+
+    pub fn primary_key(&self) -> Column<'a> {
+        Column::new(*self, self.meta.primary_key())
+    }
+
+    /// Return a filter expression that generates the SQL for `id = $id`
+    pub fn id_eq(&'a self, id: &'a Id) -> IdEq<'a> {
+        IdEq::new(*self, id)
+    }
+
+    /// Return an expression that generates the SQL for `block_range @>
+    /// $block` or `block = $block` depending on whether the table is
+    /// mutable or not
+    pub fn at_block(&self, block: BlockNumber) -> AtBlock<'a> {
+        AtBlock::new(*self, block)
+    }
+
+    /// The block column for this table for places where the just the
+    /// qualified name is needed
+    pub fn block_column(&self) -> BlockColumn<'a> {
+        BlockColumn::new(*self)
+    }
+
+    /// An expression that is true if the entity has changed since `block`
+    pub fn changed_since(&self, block: BlockNumber) -> ChangedSince<'a> {
+        let column = self.block_column();
+        ChangedSince { column, block }
+    }
+
+    /// Return an expression that generates the SQL for `causality_region =
+    /// $cr` if the table uses causality regions
+    pub fn belongs_to_causality_region(
+        &'a self,
+        cr: CausalityRegion,
+    ) -> BelongsToCausalityRegion<'a> {
+        BelongsToCausalityRegion::new(*self, cr)
+    }
+
+    /// Produce a list of the columns that should be selected for a query
+    /// based on `column_names`. The result needs to be used both to create
+    /// the actual select statement with `Self::select_cols` and to decode
+    /// query results with `FromOidRow`.
+    pub fn selected_columns<T: FromOidRow>(
+        &self,
+        column_names: &'a AttributeNames,
+        parent_type: Option<IdType>,
+    ) -> Result<Vec<&'a super::Column>, StoreError> {
+        let mut cols = Vec::new();
+        if T::WITH_INTERNAL_KEYS {
+            cols.push(&*TYPENAME_COL);
+        }
+
+        match column_names {
+            AttributeNames::All => {
+                cols.extend(self.meta.columns.iter());
+            }
+            AttributeNames::Select(names) => {
+                let pk = self.meta.primary_key();
+                cols.push(pk);
+                let mut names: Vec<_> = names
+                    .iter()
+                    .filter(|name| *name != &*ID && *name != &*VID)
+                    .collect();
+                names.sort();
+                for name in names {
+                    let column = self.meta.column_for_field(name)?;
+                    cols.push(column);
+                }
+            }
+        };
+
+        // NB: Exclude full-text search columns from selection. These columns are used for indexing
+        // and searching but are not part of the entity's data model.
+        cols.retain(|c| !c.is_fulltext());
+
+        if T::WITH_INTERNAL_KEYS {
+            match parent_type {
+                Some(IdType::String) => cols.push(&*PARENT_STRING_COL),
+                Some(IdType::Bytes) => cols.push(&*PARENT_BYTES_COL),
+                Some(IdType::Int8) => cols.push(&*PARENT_INT_COL),
+                None => (),
+            }
+        }
+
+        cols.push(&*VID_COL);
+
+        if T::WITH_SYSTEM_COLUMNS {
+            if self.meta.immutable {
+                cols.push(&*BLOCK_COL);
+            } else {
+                cols.push(&*BLOCK_RANGE_COL);
+            }
+        }
+        Ok(cols)
+    }
+
+    /// Create a Diesel select statement that selects the columns in
+    /// `columns`. Use to generate a query via
+    /// `table.select_cols(columns).filter(...)`. For a full example, see
+    /// `Layout::find`
+    pub fn select_cols(
+        &'a self,
+        columns: &[&'a RelColumn],
+    ) -> BoxedSelectStatement<'a, Untyped, FromClause<Table<'a>>, Pg> {
+        type SelectClause<'b> = DynamicSelectClause<'b, Pg, Table<'b>>;
+
+        fn add_field<'b, ST: SingleValue + Send>(
+            select: &mut SelectClause<'b>,
+            table: &'b Table<'b>,
+            column: &'b RelColumn,
+        ) {
+            let name = &column.name;
+
+            match (column.is_list(), column.is_nullable()) {
+                (true, true) => select.add_field(table.bind::<Nullable<Array<ST>>>(name).unwrap()),
+                (true, false) => select.add_field(table.bind::<Array<ST>>(name).unwrap()),
+                (false, true) => select.add_field(table.bind::<Nullable<ST>>(name).unwrap()),
+                (false, false) => select.add_field(table.bind::<ST>(name).unwrap()),
+            }
+        }
+
+        fn add_enum_field<'b>(
+            select: &mut SelectClause<'b>,
+            table: &'b Table<'b>,
+            column: &'b RelColumn,
+        ) {
+            let cast = if column.is_list() { "text[]" } else { "text" };
+            let name = format!("{}.{}::{}", table.alias.as_str(), &column.name, cast);
+
+            match (column.is_list(), column.is_nullable()) {
+                (true, true) => select.add_field(sql::<Nullable<Array<Text>>>(&name)),
+                (true, false) => select.add_field(sql::<Array<Text>>(&name)),
+                (false, true) => select.add_field(sql::<Nullable<Text>>(&name)),
+                (false, false) => select.add_field(sql::<Text>(&name)),
+            }
+        }
+
+        let mut selection = DynamicSelectClause::new();
+        for column in columns {
+            if column.name == TYPENAME_COL.name {
+                selection.add_field(sql::<Text>(&format!(
+                    "'{}' as __typename",
+                    self.meta.object.typename()
+                )));
+                continue;
+            }
+            if column.name == BLOCK_RANGE_COL.name {
+                selection.add_field(self.bind::<Range<Integer>>(&column.name).unwrap());
+                continue;
+            }
+            match column.column_type {
+                ColumnType::Boolean => add_field::<Bool>(&mut selection, self, column),
+                ColumnType::BigDecimal => add_field::<Numeric>(&mut selection, self, column),
+                ColumnType::BigInt => add_field::<Numeric>(&mut selection, self, column),
+                ColumnType::Bytes => add_field::<Binary>(&mut selection, self, column),
+                ColumnType::Int => add_field::<Integer>(&mut selection, self, column),
+                ColumnType::Int8 => add_field::<BigInt>(&mut selection, self, column),
+                ColumnType::Timestamp => add_field::<Timestamptz>(&mut selection, self, column),
+                ColumnType::String => add_field::<Text>(&mut selection, self, column),
+                ColumnType::TSVector(_) => {
+                    // Skip tsvector columns in SELECT as they are for full-text search only and not
+                    // meant to be directly queried or returned
+                }
+                ColumnType::Enum(_) => add_enum_field(&mut selection, self, column),
+            };
+        }
+        <Self as SelectDsl<SelectClause<'a>>>::select(*self, selection).into_boxed()
+    }
+}
+
+/// Generate the SQL to use a table in the `from` clause, complete with
+/// giving the table an alias
+#[derive(Debug, Clone, Copy)]
+pub struct FromTable<'a>(Table<'a>);
+
+impl<'a, DB> QueryFragment<DB> for FromTable<'a>
+where
+    DB: Backend,
+{
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+
+        out.push_identifier(self.0.meta.nsp.as_str())?;
+        out.push_sql(".");
+        out.push_identifier(&self.0.meta.name)?;
+        out.push_sql(" as ");
+        out.push_sql(self.0.alias.as_str());
+        Ok(())
+    }
+}
+
+impl std::fmt::Display for Table<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{} as {}", self.meta.name, self.alias.as_str())
+    }
+}
+
+impl std::fmt::Display for FromTable<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl<'a> QuerySource for Table<'a> {
+    type FromClause = FromTable<'a>;
+    type DefaultSelection = DummyExpression;
+
+    fn from_clause(&self) -> FromTable<'a> {
+        FromTable(*self)
+    }
+
+    fn default_selection(&self) -> Self::DefaultSelection {
+        DummyExpression::new()
+    }
+}
+
+impl<'a> AsQuery for Table<'a>
+where
+    SelectStatement<FromClause<Self>>: Query<SqlType = expression_types::NotSelectable>,
+{
+    type SqlType = expression_types::NotSelectable;
+    type Query = SelectStatement<FromClause<Self>>;
+
+    fn as_query(self) -> Self::Query {
+        SelectStatement::simple(self)
+    }
+}
+
+impl<'a> diesel::Table for Table<'a>
+where
+    Self: QuerySource + AsQuery,
+{
+    type PrimaryKey = DummyExpression;
+    type AllColumns = DummyExpression;
+
+    fn primary_key(&self) -> Self::PrimaryKey {
+        DummyExpression::new()
+    }
+
+    fn all_columns() -> Self::AllColumns {
+        DummyExpression::new()
+    }
+}
+
+impl<'a, DB> QueryFragment<DB> for Table<'a>
+where
+    DB: Backend,
+{
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+
+        out.push_sql(self.alias.as_str());
+        Ok(())
+    }
+}
+
+impl<'a> QueryId for Table<'a> {
+    type QueryId = ();
+    const HAS_STATIC_QUERY_ID: bool = false;
+}
+
+/// Generated by `Table.id_eq`
+pub struct IdEq<'a> {
+    table: Table<'a>,
+    id: &'a Id,
+}
+
+impl<'a> IdEq<'a> {
+    fn new(table: Table<'a>, id: &'a Id) -> Self {
+        IdEq { table, id }
+    }
+}
+
+impl Expression for IdEq<'_> {
+    type SqlType = Bool;
+}
+
+impl<'a> QueryFragment<Pg> for IdEq<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+        self.table.walk_ast(out.reborrow())?;
+        out.push_sql(".id = ");
+        match self.id {
+            Id::String(s) => out.push_bind_param::<Text, _>(s.as_str())?,
+            Id::Bytes(b) => out.push_bind_param::<Binary, _>(b)?,
+            Id::Int8(i) => out.push_bind_param::<BigInt, _>(i)?,
+        }
+        Ok(())
+    }
+}
+
+impl ValidGrouping<()> for IdEq<'_> {
+    type IsAggregate = is_aggregate::No;
+}
+
+impl<'a> AppearsOnTable<Table<'a>> for IdEq<'a> {}
+
+/// Generated by `Table.block_column`
+#[derive(Debug, Clone, Copy)]
+pub struct BlockColumn<'a> {
+    table: Table<'a>,
+}
+
+impl<'a> BlockColumn<'a> {
+    fn new(table: Table<'a>) -> Self {
+        BlockColumn { table }
+    }
+
+    fn immutable(&self) -> bool {
+        self.table.meta.immutable
+    }
+
+    pub fn name(&self) -> &str {
+        if self.immutable() {
+            BLOCK_COLUMN
+        } else {
+            BLOCK_RANGE_COLUMN
+        }
+    }
+}
+
+impl std::fmt::Display for BlockColumn<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}.{}", self.table.alias.as_str(), self.name())
+    }
+}
+
+impl QueryFragment<Pg> for BlockColumn<'_> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+        self.table.walk_ast(out.reborrow())?;
+        out.push_sql(".");
+        out.push_sql(self.name());
+        Ok(())
+    }
+}
+
+/// Generated by `Table.at_block`
+#[derive(Debug, Clone, Copy)]
+pub struct AtBlock<'a> {
+    column: BlockColumn<'a>,
+    block: BlockNumber,
+    filters_by_id: bool,
+}
+
+impl<'a> AtBlock<'a> {
+    fn new(table: Table<'a>, block: BlockNumber) -> Self {
+        let column = BlockColumn::new(table);
+        AtBlock {
+            column,
+            block,
+            filters_by_id: false,
+        }
+    }
+
+    pub fn filters_by_id(mut self, by_id: bool) -> Self {
+        self.filters_by_id = by_id;
+        self
+    }
+}
+
+impl Expression for AtBlock<'_> {
+    type SqlType = Bool;
+}
+
+impl<'a> QueryFragment<Pg> for AtBlock<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+
+        if self.column.immutable() {
+            if self.block == BLOCK_NUMBER_MAX {
+                // `self.block <= BLOCK_NUMBER_MAX` is always true
+                out.push_sql("true");
+            } else {
+                self.column.walk_ast(out.reborrow())?;
+                out.push_sql(" <= ");
+                out.push_bind_param::<Integer, _>(&self.block)?;
+            }
+        } else {
+            // Table is mutable and has a block_range column
+            self.column.walk_ast(out.reborrow())?;
+            out.push_sql(" @> ");
+            out.push_bind_param::<Integer, _>(&self.block)?;
+
+            let should_use_brin =
+                !self.filters_by_id || ENV_VARS.store.use_brin_for_all_query_types;
+            if self.column.table.meta.is_account_like
+                && self.block < BLOCK_NUMBER_MAX
+                && should_use_brin
+            {
+                // When block is BLOCK_NUMBER_MAX, these checks would be wrong; we
+                // don't worry about adding the equivalent in that case since
+                // we generally only see BLOCK_NUMBER_MAX here for metadata
+                // queries where block ranges don't matter anyway.
+                //
+                // We also don't need to add these if the query already filters by ID,
+                // because the ideal index is the GiST index on id and block_range.
+                out.push_sql(" and coalesce(upper(");
+                self.column.walk_ast(out.reborrow())?;
+                out.push_sql("), 2147483647) > ");
+                out.push_bind_param::<Integer, _>(&self.block)?;
+                out.push_sql(" and lower(");
+                self.column.walk_ast(out.reborrow())?;
+                out.push_sql(") <= ");
+                out.push_bind_param::<Integer, _>(&self.block)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl ValidGrouping<()> for AtBlock<'_> {
+    type IsAggregate = is_aggregate::No;
+}
+
+impl<'a> AppearsOnTable<Table<'a>> for AtBlock<'a> {}
+
+/// Generated by `Table.changed_since`
+#[derive(Debug)]
+pub struct ChangedSince<'a> {
+    column: BlockColumn<'a>,
+    block: BlockNumber,
+}
+
+impl std::fmt::Display for ChangedSince<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{} >= {}", self.column, self.block)
+    }
+}
+
+impl Expression for ChangedSince<'_> {
+    type SqlType = Bool;
+}
+
+impl QueryFragment<Pg> for ChangedSince<'_> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        if self.column.table.meta.immutable {
+            self.column.walk_ast(out.reborrow())?;
+            out.push_sql(" >= ");
+            out.push_bind_param::<Integer, _>(&self.block)
+        } else {
+            out.push_sql("lower(");
+            self.column.walk_ast(out.reborrow())?;
+            out.push_sql(") >= ");
+            out.push_bind_param::<Integer, _>(&self.block)
+        }
+    }
+}
+
+/// Generated by `Table.belongs_to_causality_region`
+pub struct BelongsToCausalityRegion<'a> {
+    table: Table<'a>,
+    cr: CausalityRegion,
+}
+
+impl<'a> BelongsToCausalityRegion<'a> {
+    fn new(table: Table<'a>, cr: CausalityRegion) -> Self {
+        BelongsToCausalityRegion { table, cr }
+    }
+}
+
+impl Expression for BelongsToCausalityRegion<'_> {
+    type SqlType = Bool;
+}
+
+impl<'a> QueryFragment<Pg> for BelongsToCausalityRegion<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+
+        if self.table.meta.has_causality_region {
+            self.table.walk_ast(out.reborrow())?;
+            out.push_sql(".causality_region");
+            out.push_sql(" = ");
+            out.push_bind_param::<Integer, _>(&self.cr)?;
+        } else {
+            out.push_sql("true");
+        }
+        Ok(())
+    }
+}
+
+impl ValidGrouping<()> for BelongsToCausalityRegion<'_> {
+    type IsAggregate = is_aggregate::No;
+}
+
+impl<'a> AppearsOnTable<Table<'a>> for BelongsToCausalityRegion<'a> {}
+
+/// A specific column in a specific table
+#[derive(Debug, Clone, Copy)]
+pub struct Column<'a> {
+    table: Table<'a>,
+    column: &'a super::Column,
+}
+
+impl<'a> Column<'a> {
+    fn new(table: Table<'a>, column: &'a super::Column) -> Self {
+        Column { table, column }
+    }
+
+    /// Bind this column to a specific SQL type for use in contexts where
+    /// Diesel requires that
+    pub fn bind<ST>(&self) -> BoundColumn<'a, ST> {
+        BoundColumn::new(self.table, self.column)
+    }
+
+    pub fn name(&self) -> &'a str {
+        &self.column.name
+    }
+
+    pub(crate) fn is_list(&self) -> bool {
+        self.column.is_list()
+    }
+
+    pub(crate) fn is_primary_key(&self) -> bool {
+        self.column.is_primary_key()
+    }
+
+    pub(crate) fn is_fulltext(&self) -> bool {
+        self.column.is_fulltext()
+    }
+
+    pub(crate) fn column_type(&self) -> &'a ColumnType {
+        &self.column.column_type
+    }
+
+    pub(crate) fn use_prefix_comparison(&self) -> bool {
+        self.column.use_prefix_comparison
+    }
+}
+
+impl std::fmt::Display for Column<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}.{}", self.table.alias.as_str(), self.column.name)
+    }
+}
+
+impl<'a, DB> QueryFragment<DB> for Column<'a>
+where
+    DB: Backend,
+{
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+        self.table.walk_ast(out.reborrow())?;
+        out.push_sql(".");
+        out.push_identifier(&self.column.name)?;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+/// A database table column bound to the SQL type for the column
+pub struct BoundColumn<'a, ST> {
+    column: Column<'a>,
+    _sql_type: PhantomData<ST>,
+}
+
+impl<'a, ST> BoundColumn<'a, ST> {
+    fn new(table: Table<'a>, column: &'a super::Column) -> Self {
+        let column = Column::new(table, column);
+        Self {
+            column,
+            _sql_type: PhantomData,
+        }
+    }
+}
+
+impl<'a, ST> QueryId for BoundColumn<'a, ST> {
+    type QueryId = ();
+    const HAS_STATIC_QUERY_ID: bool = false;
+}
+
+impl<'a, ST, QS> SelectableExpression<QS> for BoundColumn<'a, ST> where Self: Expression {}
+
+impl<'a, ST, QS> AppearsOnTable<QS> for BoundColumn<'a, ST> where Self: Expression {}
+
+impl<'a, ST> Expression for BoundColumn<'a, ST>
+where
+    ST: TypedExpressionType,
+{
+    type SqlType = ST;
+}
+
+impl<'a, ST> ValidGrouping<()> for BoundColumn<'a, ST> {
+    type IsAggregate = is_aggregate::No;
+}
+
+impl<'a, ST, DB> QueryFragment<DB> for BoundColumn<'a, ST>
+where
+    DB: Backend,
+{
+    fn walk_ast<'b>(&'b self, out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
+        self.column.walk_ast(out)
+    }
+}
diff --git a/store/postgres/src/relational/dump.rs b/store/postgres/src/relational/dump.rs
new file mode 100644
index 00000000000..c50fb6ef64c
--- /dev/null
+++ b/store/postgres/src/relational/dump.rs
@@ -0,0 +1,1309 @@
+use std::collections::BTreeMap;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::{collections::HashMap, fs};
+
+use diesel::QueryDsl;
+use diesel::dsl::sql;
+use diesel::sql_types::{
+    Array, BigInt, Binary, Bool, Integer, Nullable, Numeric, Text, Timestamptz, Untyped,
+};
+use diesel_async::RunQueryDsl;
+use diesel_dynamic_schema::DynamicSelectClause;
+
+use graph::components::store::DumpReporter;
+use graph::data::subgraph::schema::{SubgraphError, SubgraphHealth, SubgraphManifestEntity};
+use graph::prelude::{DeploymentHash, StoreError, SubgraphDeploymentEntity};
+use serde::{Deserialize, Serialize};
+
+use crate::AsyncPgConnection;
+use crate::catalog;
+use crate::detail::deployment_entity;
+use crate::parquet::convert::{estimate_row_bytes, rows_to_record_batch};
+use crate::parquet::schema::{arrow_schema, clamp_arrow_schema, data_sources_arrow_schema};
+use crate::parquet::writer::{ChunkInfo, ParquetChunkWriter};
+use crate::relational::dsl;
+use crate::relational::index::{IndexCreator, IndexList};
+use crate::relational::value::OidRow;
+use crate::relational::{ColumnType, SqlName, Table as RelTable};
+use crate::vid_batcher::{VidBatcher, VidRange};
+
+use super::Layout;
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct Manifest {
+    pub spec_version: String,
+    pub description: Option<String>,
+    pub repository: Option<String>,
+    pub features: Vec<String>,
+    pub entities_with_causality_region: Vec<String>,
+    pub history_blocks: i32,
+}
+
+impl Manifest {
+    fn new(data: SubgraphManifestEntity) -> (Self, String, Option<String>) {
+        let SubgraphManifestEntity {
+            spec_version,
+            description,
+            repository,
+            features,
+            schema,
+            raw_yaml,
+            entities_with_causality_region,
+            history_blocks,
+        } = data;
+        let this = Self {
+            spec_version,
+            description,
+            repository,
+            features,
+            entities_with_causality_region: entities_with_causality_region
+                .into_iter()
+                .map(|v| v.to_string())
+                .collect(),
+            history_blocks,
+        };
+        (this, schema, raw_yaml)
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct BlockPtr {
+    pub number: i32,
+    pub hash: String,
+}
+
+impl BlockPtr {
+    fn new(block_ptr: graph::prelude::BlockPtr) -> Self {
+        let graph::prelude::BlockPtr { number, hash } = block_ptr;
+        let hash = hash.hash_hex();
+        Self { number, hash }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct Error {
+    pub message: String,
+    pub block_ptr: Option<BlockPtr>,
+    pub handler: Option<String>,
+    pub deterministic: bool,
+}
+
+impl Error {
+    fn new(error: SubgraphError) -> Self {
+        let SubgraphError {
+            subgraph_id: _,
+            message,
+            block_ptr,
+            handler,
+            deterministic,
+        } = error;
+        let block_ptr = block_ptr.map(BlockPtr::new);
+        Self {
+            message,
+            block_ptr,
+            handler,
+            deterministic,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct Health {
+    pub failed: bool,
+    pub health: String,
+    pub fatal_error: Option<Error>,
+    pub non_fatal_errors: Vec<Error>,
+}
+
+impl Health {
+    fn new(
+        failed: bool,
+        health: SubgraphHealth,
+        fatal_error: Option<SubgraphError>,
+        non_fatal_errors: Vec<SubgraphError>,
+    ) -> Self {
+        let health = health.as_str().to_string();
+        let fatal_error = fatal_error.map(Error::new);
+        let non_fatal_errors = non_fatal_errors.into_iter().map(Error::new).collect();
+        Self {
+            failed,
+            health,
+            fatal_error,
+            non_fatal_errors,
+        }
+    }
+}
+
+/// Per-table metadata recorded in `metadata.json`.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub(crate) struct TableInfo {
+    pub immutable: bool,
+    pub has_causality_region: bool,
+    pub chunks: Vec<ChunkInfo>,
+    /// Clamp files for mutable tables: record rows whose `block_range`
+    /// upper bound was set since a previous dump. Empty for immutable
+    /// tables and for full (non-incremental) dumps.
+    #[serde(default)]
+    pub clamps: Vec<ChunkInfo>,
+    pub max_vid: i64,
+}
+
+/// Top-level metadata for a subgraph dump (written as `metadata.json`).
+///
+/// The `tables` field is initially empty and populated during the dump
+/// as entity tables are written to Parquet files.
+#[derive(Serialize, Deserialize)]
+pub(crate) struct Metadata {
+    pub version: u32,
+    pub deployment: DeploymentHash,
+    pub network: String,
+    pub manifest: Manifest,
+    pub earliest_block_number: i32,
+    pub start_block: Option<BlockPtr>,
+    pub head_block: Option<BlockPtr>,
+    pub entity_count: usize,
+    pub graft_base: Option<DeploymentHash>,
+    pub graft_block: Option<BlockPtr>,
+    pub debug_fork: Option<DeploymentHash>,
+    pub health: Health,
+    pub indexes: HashMap<String, Vec<String>>,
+    pub tables: BTreeMap<String, TableInfo>,
+}
+
+impl Metadata {
+    /// Read and validate a dump's `metadata.json`.
+    pub fn from_file(path: &Path) -> Result<Self, StoreError> {
+        let content = fs::read_to_string(path).map_err(|e| {
+            StoreError::InternalError(format!("failed to read {}: {e}", path.display()))
+        })?;
+        let metadata: Self = serde_json::from_str(&content).map_err(|e| {
+            StoreError::InternalError(format!("failed to parse {}: {e}", path.display()))
+        })?;
+        if metadata.version != 1 {
+            return Err(StoreError::InternalError(format!(
+                "unsupported dump version {} (expected 1)",
+                metadata.version
+            )));
+        }
+        Ok(metadata)
+    }
+
+    fn new(
+        deployment: DeploymentHash,
+        network: String,
+        entity_count: usize,
+        data: SubgraphDeploymentEntity,
+        index_list: IndexList,
+    ) -> (Self, String, Option<String>) {
+        let indexes = Self::indexes(index_list);
+        let SubgraphDeploymentEntity {
+            manifest,
+            failed,
+            health,
+            synced_at: _,
+            fatal_error,
+            non_fatal_errors,
+            earliest_block_number,
+            start_block,
+            latest_block,
+            graft_base,
+            graft_block,
+            debug_fork,
+            reorg_count: _,
+            current_reorg_depth: _,
+            max_reorg_depth: _,
+        } = data;
+        let (manifest, schema, yaml) = Manifest::new(manifest);
+        let health = Health::new(failed, health, fatal_error, non_fatal_errors);
+        let start_block = start_block.map(BlockPtr::new);
+        let head_block = latest_block.map(BlockPtr::new);
+        let graft_block = graft_block.map(BlockPtr::new);
+        let this = Self {
+            version: 1,
+            deployment,
+            network,
+            manifest,
+            earliest_block_number,
+            start_block,
+            head_block,
+            entity_count,
+            graft_base,
+            graft_block,
+            debug_fork,
+            health,
+            indexes,
+            tables: BTreeMap::new(),
+        };
+        (this, schema, yaml)
+    }
+
+    fn indexes(index_list: IndexList) -> HashMap<String, Vec<String>> {
+        let mut res = HashMap::new();
+        let creat = IndexCreator::new(false, true, false);
+        for (name, indexes) in index_list.indexes {
+            let mut indexes2 = Vec::new();
+            for index in indexes {
+                let Ok(index) = index.with_nsp("sgd".to_string()) else {
+                    continue;
+                };
+                let Ok(index) = creat.to_sql(&index) else {
+                    continue;
+                };
+                indexes2.push(index);
+            }
+            res.insert(name, indexes2);
+        }
+        res
+    }
+}
+
+fn chunk_filename(index: usize) -> String {
+    format!("chunk_{:06}.parquet", index)
+}
+
+/// Maximum estimated payload size of a single Arrow `RecordBatch`. Kept well
+/// under Arrow's 2 GiB i32 offset limit so that no single string/binary column
+/// can overflow while a large table is dumped. The adaptive `VidBatcher` sizes
+/// fetches by elapsed time with no byte ceiling, so a single fetch can hold far
+/// more than this; we therefore split each fetched batch into byte-bounded
+/// `RecordBatch`es before writing (issue #6609).
+const MAX_RECORD_BATCH_BYTES: usize = 256 * 1024 * 1024;
+
+/// Split `rows` (ordered by vid) into contiguous sub-slices whose estimated
+/// payload size each stays at or below `max_bytes`. Always emits at least one
+/// row per slice, so an oversized single row still makes progress (a lone row
+/// can never overflow a column, since Postgres caps any field at ~1 GiB).
+fn byte_bounded_slices(rows: &[OidRow], max_bytes: usize) -> Vec<&[OidRow]> {
+    let mut slices = Vec::new();
+    let mut start = 0;
+    let mut acc = 0usize;
+    for (i, row) in rows.iter().enumerate() {
+        let sz = estimate_row_bytes(row);
+        if i > start && acc + sz > max_bytes {
+            slices.push(&rows[start..i]);
+            start = i;
+            acc = 0;
+        }
+        acc += sz;
+    }
+    if start < rows.len() {
+        slices.push(&rows[start..]);
+    }
+    slices
+}
+
+fn clamp_filename(index: usize) -> String {
+    format!("clamp_{:06}.parquet", index)
+}
+
+/// Build a `DynamicSelectClause` for dumping an entity table. The
+/// selected columns match the Arrow schema from `parquet::schema::arrow_schema`:
+/// `vid`, block columns (split for mutable), `causality_region`, then data columns.
+fn dump_select<'a>(
+    table: &'a dsl::Table<'a>,
+    meta: &'a RelTable,
+) -> diesel::query_builder::BoxedSelectStatement<
+    'a,
+    Untyped,
+    diesel::query_builder::FromClause<dsl::Table<'a>>,
+    diesel::pg::Pg,
+> {
+    type SelectClause<'b> = DynamicSelectClause<'b, diesel::pg::Pg, dsl::Table<'b>>;
+
+    fn add_data_field<'b>(
+        select: &mut SelectClause<'b>,
+        table: &'b dsl::Table<'b>,
+        column: &'b crate::relational::Column,
+    ) {
+        fn add_typed<'c, ST: diesel::sql_types::SingleValue + Send>(
+            select: &mut SelectClause<'c>,
+            table: &'c dsl::Table<'c>,
+            name: &str,
+            is_list: bool,
+            is_nullable: bool,
+        ) {
+            match (is_list, is_nullable) {
+                (true, true) => {
+                    select.add_field(table.column(name).unwrap().bind::<Nullable<Array<ST>>>())
+                }
+                (true, false) => select.add_field(table.column(name).unwrap().bind::<Array<ST>>()),
+                (false, true) => {
+                    select.add_field(table.column(name).unwrap().bind::<Nullable<ST>>())
+                }
+                (false, false) => select.add_field(table.column(name).unwrap().bind::<ST>()),
+            }
+        }
+
+        let name = column.name.as_str();
+        let is_list = column.is_list();
+        let is_nullable = column.is_nullable();
+
+        match &column.column_type {
+            ColumnType::Boolean => add_typed::<Bool>(select, table, name, is_list, is_nullable),
+            ColumnType::BigDecimal | ColumnType::BigInt => {
+                add_typed::<Numeric>(select, table, name, is_list, is_nullable)
+            }
+            ColumnType::Bytes => add_typed::<Binary>(select, table, name, is_list, is_nullable),
+            ColumnType::Int => add_typed::<Integer>(select, table, name, is_list, is_nullable),
+            ColumnType::Int8 => add_typed::<BigInt>(select, table, name, is_list, is_nullable),
+            ColumnType::Timestamp => {
+                add_typed::<Timestamptz>(select, table, name, is_list, is_nullable)
+            }
+            ColumnType::String => add_typed::<Text>(select, table, name, is_list, is_nullable),
+            ColumnType::Enum(_) => {
+                // Cast enum to text for dump
+                let alias = table.alias.as_str();
+                let cast = if is_list { "text[]" } else { "text" };
+                let expr = format!("{alias}.\"{name}\"::{cast}");
+                match (is_list, is_nullable) {
+                    (true, true) => select.add_field(sql::<Nullable<Array<Text>>>(&expr)),
+                    (true, false) => select.add_field(sql::<Array<Text>>(&expr)),
+                    (false, true) => select.add_field(sql::<Nullable<Text>>(&expr)),
+                    (false, false) => select.add_field(sql::<Text>(&expr)),
+                }
+                let _ = alias;
+            }
+            ColumnType::TSVector(_) => { /* skip fulltext columns */ }
+        }
+    }
+
+    let mut selection = DynamicSelectClause::new();
+
+    // vid
+    selection.add_field(table.column("vid").unwrap().bind::<BigInt>());
+
+    // Block columns
+    if meta.immutable {
+        selection.add_field(table.column("block$").unwrap().bind::<Integer>());
+    } else {
+        selection.add_field(sql::<Integer>("lower(c.block_range)"));
+        selection.add_field(sql::<Nullable<Integer>>("upper(c.block_range)"));
+    }
+
+    // Causality region
+    if meta.has_causality_region {
+        selection.add_field(table.column("causality_region").unwrap().bind::<Integer>());
+    }
+
+    // Data columns
+    for col in &meta.columns {
+        if col.is_fulltext() {
+            continue;
+        }
+        add_data_field(&mut selection, table, col);
+    }
+
+    diesel::QueryDsl::select(*table, selection).into_boxed()
+}
+
+/// Query the vid range for a table. Returns `(min_vid, max_vid)`.
+async fn vid_range(conn: &mut AsyncPgConnection, table: &RelTable) -> Result<VidRange, StoreError> {
+    let query = format!(
+        "select coalesce(min(vid), 0)::int8 as min_vid, coalesce(max(vid), -1)::int8 as max_vid from {}",
+        table.qualified_name
+    );
+    diesel::sql_query(&query)
+        .get_result::<VidRange>(conn)
+        .await
+        .map_err(StoreError::from)
+}
+
+/// Row type for clamp queries.
+#[derive(diesel::QueryableByName)]
+struct ClampRow {
+    #[diesel(sql_type = BigInt)]
+    vid: i64,
+    #[diesel(sql_type = Integer)]
+    block_range_end: i32,
+}
+
+/// Convert `ClampRow`s into an Arrow `RecordBatch`.
+fn clamp_rows_to_record_batch(
+    schema: &arrow::datatypes::Schema,
+    rows: &[ClampRow],
+) -> Result<arrow::array::RecordBatch, StoreError> {
+    use arrow::array::{Int32Builder, Int64Builder, RecordBatch};
+    use std::sync::Arc;
+
+    let n = rows.len();
+    let mut vid_b = Int64Builder::with_capacity(n);
+    let mut bre_b = Int32Builder::with_capacity(n);
+
+    for row in rows {
+        vid_b.append_value(row.vid);
+        bre_b.append_value(row.block_range_end);
+    }
+
+    let arrays: Vec<arrow::array::ArrayRef> =
+        vec![Arc::new(vid_b.finish()), Arc::new(bre_b.finish())];
+
+    RecordBatch::try_new(Arc::new(schema.clone()), arrays)
+        .map_err(|e| StoreError::InternalError(format!("failed to build clamp batch: {e}")))
+}
+
+const CLAMP_BATCH_SIZE: i64 = 50_000;
+
+/// Query rows whose `block_range` was closed since the previous dump
+/// and write them to a clamp Parquet file.
+async fn dump_clamp(
+    conn: &mut AsyncPgConnection,
+    table: &RelTable,
+    dir: &Path,
+    prev_max_vid: i64,
+    prev_head_block_number: i32,
+    clamp_index: usize,
+    reporter: &mut dyn DumpReporter,
+) -> Result<Option<ChunkInfo>, StoreError> {
+    let table_dir_name = table.object.as_str();
+    let qualified = &table.qualified_name;
+    let schema = clamp_arrow_schema();
+
+    // Count rows to dump
+    let count_query = format!(
+        "select count(*)::int8 as cnt from {} \
+         where vid <= $1 \
+           and upper(block_range) is not null \
+           and upper(block_range) > $2",
+        qualified,
+    );
+    let count: i64 = diesel::sql_query(&count_query)
+        .bind::<BigInt, _>(prev_max_vid)
+        .bind::<Integer, _>(prev_head_block_number)
+        .get_result::<CountRow>(conn)
+        .await
+        .map_err(StoreError::from)?
+        .cnt;
+
+    if count == 0 {
+        return Ok(None);
+    }
+
+    reporter.start_clamps(table_dir_name, count as usize);
+
+    let table_dir = dir.join(table_dir_name);
+    fs::create_dir_all(&table_dir)
+        .map_err(|e| StoreError::InternalError(format!("failed to create dir: {e}")))?;
+
+    let clamp_file = clamp_filename(clamp_index);
+    let relative_path = format!("{}/{}", table_dir_name, clamp_file);
+    let abs_path = table_dir.join(&clamp_file);
+    let mut writer = ParquetChunkWriter::new(abs_path, relative_path, &schema)?;
+
+    let mut total_rows = 0usize;
+    let mut start_vid: i64 = 0;
+    loop {
+        let query = format!(
+            "select vid::int8, upper(block_range)::int4 as block_range_end \
+               from {} \
+              where vid <= $1 \
+                and vid > $2 \
+                and upper(block_range) is not null \
+                and upper(block_range) > $3 \
+              order by vid \
+              limit $4",
+            qualified,
+        );
+        let rows: Vec<ClampRow> = diesel::sql_query(&query)
+            .bind::<BigInt, _>(prev_max_vid)
+            .bind::<BigInt, _>(start_vid)
+            .bind::<Integer, _>(prev_head_block_number)
+            .bind::<BigInt, _>(CLAMP_BATCH_SIZE)
+            .load(conn)
+            .await
+            .map_err(StoreError::from)?;
+
+        if rows.is_empty() {
+            break;
+        }
+
+        let batch_max_vid = rows[rows.len() - 1].vid;
+        let batch_min_vid = rows[0].vid;
+        let batch = clamp_rows_to_record_batch(&schema, &rows)?;
+        total_rows += rows.len();
+        writer.write_batch(&batch, batch_min_vid, batch_max_vid)?;
+        start_vid = batch_max_vid;
+
+        if (rows.len() as i64) < CLAMP_BATCH_SIZE {
+            break;
+        }
+    }
+
+    let chunk_info = writer.finish()?;
+    reporter.finish_clamps(table_dir_name, total_rows);
+
+    if chunk_info.row_count > 0 {
+        Ok(Some(chunk_info))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Dump clamps for the `data_sources$` table.
+async fn dump_data_sources_clamp(
+    conn: &mut AsyncPgConnection,
+    namespace: &str,
+    dir: &Path,
+    prev_max_vid: i64,
+    prev_head_block_number: i32,
+    clamp_index: usize,
+    reporter: &mut dyn DumpReporter,
+) -> Result<Option<ChunkInfo>, StoreError> {
+    let qualified = format!("\"{}\".\"{}\"", namespace, DATA_SOURCES_TABLE);
+    let schema = clamp_arrow_schema();
+
+    let count_query = format!(
+        "select count(*)::int8 as cnt from {} \
+         where vid <= $1 \
+           and upper(block_range) is not null \
+           and upper(block_range) > $2",
+        qualified,
+    );
+    let count: i64 = diesel::sql_query(&count_query)
+        .bind::<BigInt, _>(prev_max_vid)
+        .bind::<Integer, _>(prev_head_block_number)
+        .get_result::<CountRow>(conn)
+        .await
+        .map_err(StoreError::from)?
+        .cnt;
+
+    if count == 0 {
+        return Ok(None);
+    }
+
+    reporter.start_clamps(DATA_SOURCES_TABLE, count as usize);
+
+    let ds_dir = dir.join(DATA_SOURCES_TABLE);
+    fs::create_dir_all(&ds_dir)
+        .map_err(|e| StoreError::InternalError(format!("failed to create dir: {e}")))?;
+
+    let clamp_file = clamp_filename(clamp_index);
+    let relative_path = format!("{}/{}", DATA_SOURCES_TABLE, clamp_file);
+    let abs_path = ds_dir.join(&clamp_file);
+    let mut writer = ParquetChunkWriter::new(abs_path, relative_path, &schema)?;
+
+    let mut total_rows = 0usize;
+    let mut start_vid: i64 = 0;
+    loop {
+        let query = format!(
+            "select vid::int8, upper(block_range)::int4 as block_range_end \
+               from {} \
+              where vid <= $1 \
+                and vid > $2 \
+                and upper(block_range) is not null \
+                and upper(block_range) > $3 \
+              order by vid \
+              limit $4",
+            qualified,
+        );
+        let rows: Vec<ClampRow> = diesel::sql_query(&query)
+            .bind::<BigInt, _>(prev_max_vid)
+            .bind::<BigInt, _>(start_vid)
+            .bind::<Integer, _>(prev_head_block_number)
+            .bind::<BigInt, _>(CLAMP_BATCH_SIZE)
+            .load(conn)
+            .await
+            .map_err(StoreError::from)?;
+
+        if rows.is_empty() {
+            break;
+        }
+
+        let batch_max_vid = rows[rows.len() - 1].vid;
+        let batch_min_vid = rows[0].vid;
+        let batch = clamp_rows_to_record_batch(&schema, &rows)?;
+        total_rows += rows.len();
+        writer.write_batch(&batch, batch_min_vid, batch_max_vid)?;
+        start_vid = batch_max_vid;
+
+        if (rows.len() as i64) < CLAMP_BATCH_SIZE {
+            break;
+        }
+    }
+
+    let chunk_info = writer.finish()?;
+    reporter.finish_clamps(DATA_SOURCES_TABLE, total_rows);
+
+    if chunk_info.row_count > 0 {
+        Ok(Some(chunk_info))
+    } else {
+        Ok(None)
+    }
+}
+
+#[derive(diesel::QueryableByName)]
+struct CountRow {
+    #[diesel(sql_type = BigInt)]
+    cnt: i64,
+}
+
+/// Dump a single entity table to a Parquet file.
+///
+/// When `prev` is `Some`, performs an incremental dump: only new rows
+/// (vid > prev.max_vid) are written, and clamps are generated for
+/// mutable tables.
+async fn dump_entity_table(
+    conn: &mut AsyncPgConnection,
+    table: &RelTable,
+    dir: &Path,
+    prev: Option<&TableInfo>,
+    prev_head_block_number: Option<i32>,
+    reporter: &mut dyn DumpReporter,
+) -> Result<TableInfo, StoreError> {
+    let arrow_schema = arrow_schema(table);
+    let table_dir_name = table.object.as_str();
+    let table_dir = dir.join(table_dir_name);
+    fs::create_dir_all(&table_dir)
+        .map_err(|e| StoreError::InternalError(format!("failed to create dir: {e}")))?;
+
+    let range = vid_range(conn, table).await?;
+
+    // For incremental dumps, adjust the start of the vid range
+    let (effective_range, chunk_index, mut chunks, mut clamps) = match prev {
+        Some(prev_info) => {
+            let new_min = prev_info.max_vid + 1;
+            let effective = VidRange {
+                min: new_min,
+                max: range.max,
+            };
+            (
+                effective,
+                prev_info.chunks.len(),
+                prev_info.chunks.clone(),
+                prev_info.clamps.clone(),
+            )
+        }
+        None => (range, 0, vec![], vec![]),
+    };
+
+    let rows_approx = if effective_range.is_empty() {
+        0
+    } else {
+        (effective_range.max - effective_range.min + 1) as usize
+    };
+    reporter.start_table(table_dir_name, rows_approx);
+
+    if effective_range.is_empty() {
+        // No new rows, but for incremental mutable tables we still
+        // need to check for clamps
+        if let (Some(prev_info), Some(prev_head)) = (prev, prev_head_block_number)
+            && !table.immutable
+        {
+            let clamp_index = prev_info.clamps.len();
+            if let Some(clamp_info) = dump_clamp(
+                conn,
+                table,
+                dir,
+                prev_info.max_vid,
+                prev_head,
+                clamp_index,
+                reporter,
+            )
+            .await?
+            {
+                clamps.push(clamp_info);
+            }
+        }
+
+        let max_vid = prev.map_or(-1, |p| p.max_vid);
+        reporter.finish_table(table_dir_name, 0);
+        return Ok(TableInfo {
+            immutable: table.immutable,
+            has_causality_region: table.has_causality_region,
+            chunks,
+            clamps,
+            max_vid,
+        });
+    }
+
+    let chunk_file = chunk_filename(chunk_index);
+    let relative_path = format!("{}/{}", table_dir_name, chunk_file);
+    let abs_path = table_dir.join(&chunk_file);
+    let mut writer = ParquetChunkWriter::new(abs_path, relative_path, &arrow_schema)?;
+
+    let dsl_table = dsl::Table::new(table);
+    let mut batcher = VidBatcher::load(conn, &table.nsp, table, effective_range).await?;
+    let mut total_rows = 0usize;
+
+    while !batcher.finished() {
+        let (_, rows_opt) = batcher
+            .step(async |start, end| {
+                let query = dump_select(&dsl_table, table)
+                    .filter(sql::<Bool>("vid >= ").bind::<BigInt, _>(start))
+                    .filter(sql::<Bool>("vid <= ").bind::<BigInt, _>(end))
+                    .order(sql::<Untyped>("vid"));
+
+                let rows: Vec<OidRow> = query.load(conn).await?;
+                if rows.is_empty() {
+                    return Ok(0usize);
+                }
+
+                let count = rows.len();
+                // A single adaptive fetch can hold far more than Arrow's 2 GiB
+                // per-column offset limit allows; split it into byte-bounded
+                // `RecordBatch`es so no string/binary column can overflow (#6609).
+                for sub in byte_bounded_slices(&rows, MAX_RECORD_BATCH_BYTES) {
+                    let batch = rows_to_record_batch(&arrow_schema, sub)?;
+                    writer.write_batch(&batch, start, end)?;
+                }
+                Ok(count)
+            })
+            .await?;
+        if let Some(rows) = rows_opt {
+            total_rows += rows;
+            reporter.batch_dumped(table_dir_name, rows);
+        }
+    }
+
+    let chunk_info = writer.finish()?;
+
+    let max_vid = if chunk_info.row_count > 0 {
+        chunk_info.max_vid
+    } else {
+        prev.map_or(-1, |p| p.max_vid)
+    };
+
+    if chunk_info.row_count > 0 {
+        chunks.push(chunk_info);
+    }
+
+    // For incremental mutable tables, dump clamps
+    if let (Some(prev_info), Some(prev_head)) = (prev, prev_head_block_number)
+        && !table.immutable
+    {
+        let clamp_index = prev_info.clamps.len();
+        if let Some(clamp_info) = dump_clamp(
+            conn,
+            table,
+            dir,
+            prev_info.max_vid,
+            prev_head,
+            clamp_index,
+            reporter,
+        )
+        .await?
+        {
+            clamps.push(clamp_info);
+        }
+    }
+
+    reporter.finish_table(table_dir_name, total_rows);
+
+    Ok(TableInfo {
+        immutable: table.immutable,
+        has_causality_region: table.has_causality_region,
+        chunks,
+        clamps,
+        max_vid,
+    })
+}
+
+/// Row type for the `data_sources$` table dump query.
+#[derive(diesel::QueryableByName)]
+struct DataSourceRow {
+    #[diesel(sql_type = BigInt)]
+    vid: i64,
+    #[diesel(sql_type = Integer)]
+    block_range_start: i32,
+    #[diesel(sql_type = Nullable<Integer>)]
+    block_range_end: Option<i32>,
+    #[diesel(sql_type = Integer)]
+    causality_region: i32,
+    #[diesel(sql_type = Integer)]
+    manifest_idx: i32,
+    #[diesel(sql_type = Nullable<Integer>)]
+    parent: Option<i32>,
+    #[diesel(sql_type = Nullable<Binary>)]
+    id: Option<Vec<u8>>,
+    #[diesel(sql_type = Nullable<Binary>)]
+    param: Option<Vec<u8>>,
+    #[diesel(sql_type = Nullable<Text>)]
+    context: Option<String>,
+    #[diesel(sql_type = Nullable<Integer>)]
+    done_at: Option<i32>,
+}
+
+/// Convert `DataSourceRow`s to an Arrow `RecordBatch` using the fixed
+/// `data_sources$` schema.
+fn data_source_rows_to_record_batch(
+    schema: &arrow::datatypes::Schema,
+    rows: &[DataSourceRow],
+) -> Result<arrow::array::RecordBatch, StoreError> {
+    use arrow::array::{BinaryBuilder, Int32Builder, Int64Builder, RecordBatch, StringBuilder};
+    use std::sync::Arc;
+
+    let n = rows.len();
+    let mut vid_b = Int64Builder::with_capacity(n);
+    let mut brs_b = Int32Builder::with_capacity(n);
+    let mut bre_b = Int32Builder::with_capacity(n);
+    let mut cr_b = Int32Builder::with_capacity(n);
+    let mut mi_b = Int32Builder::with_capacity(n);
+    let mut parent_b = Int32Builder::with_capacity(n);
+    let mut id_b = BinaryBuilder::with_capacity(n, 0);
+    let mut param_b = BinaryBuilder::with_capacity(n, 0);
+    let mut ctx_b = StringBuilder::with_capacity(n, 0);
+    let mut da_b = Int32Builder::with_capacity(n);
+
+    for row in rows {
+        vid_b.append_value(row.vid);
+        brs_b.append_value(row.block_range_start);
+        match row.block_range_end {
+            Some(v) => bre_b.append_value(v),
+            None => bre_b.append_null(),
+        }
+        cr_b.append_value(row.causality_region);
+        mi_b.append_value(row.manifest_idx);
+        match row.parent {
+            Some(v) => parent_b.append_value(v),
+            None => parent_b.append_null(),
+        }
+        match &row.id {
+            Some(v) => id_b.append_value(v),
+            None => id_b.append_null(),
+        }
+        match &row.param {
+            Some(v) => param_b.append_value(v),
+            None => param_b.append_null(),
+        }
+        match &row.context {
+            Some(v) => ctx_b.append_value(v),
+            None => ctx_b.append_null(),
+        }
+        match row.done_at {
+            Some(v) => da_b.append_value(v),
+            None => da_b.append_null(),
+        }
+    }
+
+    let arrays: Vec<arrow::array::ArrayRef> = vec![
+        Arc::new(vid_b.finish()),
+        Arc::new(brs_b.finish()),
+        Arc::new(bre_b.finish()),
+        Arc::new(cr_b.finish()),
+        Arc::new(mi_b.finish()),
+        Arc::new(parent_b.finish()),
+        Arc::new(id_b.finish()),
+        Arc::new(param_b.finish()),
+        Arc::new(ctx_b.finish()),
+        Arc::new(da_b.finish()),
+    ];
+
+    RecordBatch::try_new(Arc::new(schema.clone()), arrays)
+        .map_err(|e| StoreError::InternalError(format!("failed to build data_sources batch: {e}")))
+}
+
+const DATA_SOURCES_TABLE: &str = "data_sources$";
+const DATA_SOURCES_BATCH_SIZE: i64 = 10_000;
+
+/// Dump the `data_sources$` table to a Parquet file, if it exists.
+async fn dump_data_sources(
+    conn: &mut AsyncPgConnection,
+    namespace: &str,
+    dir: &Path,
+    prev: Option<&TableInfo>,
+    prev_head_block_number: Option<i32>,
+    reporter: &mut dyn DumpReporter,
+) -> Result<Option<TableInfo>, StoreError> {
+    let table_name = SqlName::verbatim(DATA_SOURCES_TABLE.to_string());
+    if !catalog::table_exists(conn, namespace, &table_name).await? {
+        return Ok(None);
+    }
+
+    reporter.start_data_sources();
+
+    let qualified = format!("\"{}\".\"{}\"", namespace, DATA_SOURCES_TABLE);
+
+    // Get vid range
+    let range_query = format!(
+        "select coalesce(min(vid), 0)::int8 as min_vid, coalesce(max(vid), -1)::int8 as max_vid from {}",
+        qualified,
+    );
+    let range: VidRange = diesel::sql_query(&range_query)
+        .get_result(conn)
+        .await
+        .map_err(StoreError::from)?;
+
+    // For incremental dumps, adjust start
+    let (effective_min, chunk_index, mut chunks, mut clamps) = match prev {
+        Some(prev_info) => (
+            prev_info.max_vid + 1,
+            prev_info.chunks.len(),
+            prev_info.chunks.clone(),
+            prev_info.clamps.clone(),
+        ),
+        None => (range.min, 0, vec![], vec![]),
+    };
+
+    let effective_empty = range.is_empty() || effective_min > range.max;
+
+    if effective_empty {
+        // No new rows, but still check for clamps on incremental
+        if let (Some(prev_info), Some(prev_head)) = (prev, prev_head_block_number) {
+            let clamp_index = prev_info.clamps.len();
+            if let Some(clamp_info) = dump_data_sources_clamp(
+                conn,
+                namespace,
+                dir,
+                prev_info.max_vid,
+                prev_head,
+                clamp_index,
+                reporter,
+            )
+            .await?
+            {
+                clamps.push(clamp_info);
+            }
+        }
+
+        let max_vid = prev.map_or(-1, |p| p.max_vid);
+        reporter.finish_data_sources(0);
+        return Ok(Some(TableInfo {
+            immutable: false,
+            has_causality_region: true,
+            chunks,
+            clamps,
+            max_vid,
+        }));
+    }
+
+    let schema = data_sources_arrow_schema();
+    let ds_dir = dir.join(DATA_SOURCES_TABLE);
+    fs::create_dir_all(&ds_dir)
+        .map_err(|e| StoreError::InternalError(format!("failed to create dir: {e}")))?;
+
+    let chunk_file = chunk_filename(chunk_index);
+    let relative_path = format!("{}/{}", DATA_SOURCES_TABLE, chunk_file);
+    let abs_path = ds_dir.join(&chunk_file);
+    let mut writer = ParquetChunkWriter::new(abs_path, relative_path, &schema)?;
+
+    let mut total_rows = 0usize;
+    let mut start = effective_min;
+    while start <= range.max {
+        let end = (start + DATA_SOURCES_BATCH_SIZE - 1).min(range.max);
+        let query = format!(
+            "select vid::int8, \
+                    lower(block_range) as block_range_start, \
+                    upper(block_range) as block_range_end, \
+                    causality_region, \
+                    manifest_idx, \
+                    parent, \
+                    id, \
+                    param, \
+                    context::text, \
+                    done_at \
+               from {} \
+              where vid >= $1 and vid <= $2 \
+              order by vid",
+            qualified,
+        );
+        let rows: Vec<DataSourceRow> = diesel::sql_query(&query)
+            .bind::<BigInt, _>(start)
+            .bind::<BigInt, _>(end)
+            .load(conn)
+            .await
+            .map_err(StoreError::from)?;
+
+        if !rows.is_empty() {
+            total_rows += rows.len();
+            let batch = data_source_rows_to_record_batch(&schema, &rows)?;
+            writer.write_batch(&batch, start, end)?;
+        }
+
+        start = end + 1;
+    }
+
+    let chunk_info = writer.finish()?;
+
+    let max_vid = if chunk_info.row_count > 0 {
+        chunk_info.max_vid
+    } else {
+        prev.map_or(-1, |p| p.max_vid)
+    };
+
+    if chunk_info.row_count > 0 {
+        chunks.push(chunk_info);
+    }
+
+    // Dump clamps for incremental
+    if let (Some(prev_info), Some(prev_head)) = (prev, prev_head_block_number) {
+        let clamp_index = prev_info.clamps.len();
+        if let Some(clamp_info) = dump_data_sources_clamp(
+            conn,
+            namespace,
+            dir,
+            prev_info.max_vid,
+            prev_head,
+            clamp_index,
+            reporter,
+        )
+        .await?
+        {
+            clamps.push(clamp_info);
+        }
+    }
+
+    reporter.finish_data_sources(total_rows);
+
+    Ok(Some(TableInfo {
+        immutable: false,
+        has_causality_region: true,
+        chunks,
+        clamps,
+        max_vid,
+    }))
+}
+
+impl Layout {
+    pub(crate) async fn dump(
+        &self,
+        conn: &mut AsyncPgConnection,
+        index_list: IndexList,
+        dir: PathBuf,
+        network: &str,
+        entity_count: usize,
+        reporter: &mut dyn DumpReporter,
+    ) -> Result<(), StoreError> {
+        fn write_file(name: PathBuf, contents: &str) -> Result<(), StoreError> {
+            let mut file = fs::File::create(name).map_err(|e| StoreError::Unknown(e.into()))?;
+            file.write_all(contents.as_bytes())
+                .map_err(|e| StoreError::Unknown(e.into()))?;
+            Ok(())
+        }
+
+        // Check for a previous dump (incremental mode)
+        let metadata_path = dir.join("metadata.json");
+        let prev = if metadata_path.exists() {
+            let prev = Metadata::from_file(&metadata_path)?;
+            if prev.deployment != self.site.deployment {
+                return Err(StoreError::InternalError(format!(
+                    "incremental dump refused: previous dump is for deployment '{}' \
+                     but current deployment is '{}'",
+                    prev.deployment, self.site.deployment
+                )));
+            }
+            Some(prev)
+        } else {
+            None
+        };
+
+        let prev_head_block_number = prev
+            .as_ref()
+            .and_then(|p| p.head_block.as_ref())
+            .map(|b| b.number);
+
+        let deployment = deployment_entity(conn, &self.site, &self.input_schema).await?;
+        let (mut metadata, schema, yaml) = Metadata::new(
+            self.site.deployment.clone(),
+            network.to_string(),
+            entity_count,
+            deployment,
+            index_list,
+        );
+
+        // Guard: refuse incremental if current head ≤ previous head
+        // (could indicate a reorg)
+        if let (Some(prev_head), Some(curr_head)) = (
+            prev_head_block_number,
+            metadata.head_block.as_ref().map(|b| b.number),
+        ) && curr_head <= prev_head
+        {
+            return Err(StoreError::InternalError(format!(
+                "incremental dump refused: current head block ({}) <= previous head block ({}); \
+                     possible reorg — delete the dump directory and re-dump",
+                curr_head, prev_head
+            )));
+        }
+
+        write_file(dir.join("schema.graphql"), &schema)?;
+
+        if let Some(yaml) = yaml {
+            write_file(dir.join("subgraph.yaml"), &yaml)?;
+        }
+
+        // Dump entity tables sorted by name for determinism
+        let mut tables: Vec<_> = self.tables.values().collect();
+        tables.sort_by_key(|t| t.name.as_str().to_string());
+
+        reporter.start(self.site.deployment.as_str(), tables.len());
+
+        for table in &tables {
+            let table_name = table.object.as_str();
+            let prev_table = prev.as_ref().and_then(|p| p.tables.get(table_name));
+            let table_info = dump_entity_table(
+                conn,
+                table,
+                &dir,
+                prev_table,
+                prev_head_block_number,
+                reporter,
+            )
+            .await?;
+            metadata.tables.insert(table_name.to_string(), table_info);
+        }
+
+        // Carry forward tables from previous dump that are no longer in
+        // the current layout (schema evolution — rare but possible)
+        if let Some(ref prev_meta) = prev {
+            for (name, info) in &prev_meta.tables {
+                if name == DATA_SOURCES_TABLE {
+                    continue;
+                }
+                if !metadata.tables.contains_key(name) {
+                    metadata.tables.insert(name.clone(), info.clone());
+                }
+            }
+        }
+
+        // Dump data_sources$ if it exists
+        let namespace = self.site.namespace.as_str();
+        let prev_ds = prev.as_ref().and_then(|p| p.tables.get(DATA_SOURCES_TABLE));
+        if let Some(ds_info) = dump_data_sources(
+            conn,
+            namespace,
+            &dir,
+            prev_ds,
+            prev_head_block_number,
+            reporter,
+        )
+        .await?
+        {
+            metadata
+                .tables
+                .insert(DATA_SOURCES_TABLE.to_string(), ds_info);
+        } else if let Some(prev_ds_info) = prev_ds {
+            // Carry forward from previous dump
+            metadata
+                .tables
+                .insert(DATA_SOURCES_TABLE.to_string(), prev_ds_info.clone());
+        }
+
+        // Write metadata.json atomically via tmp file + rename
+        let tmp_path = dir.join("metadata.json.tmp");
+        write_file(tmp_path.clone(), &serde_json::to_string_pretty(&metadata)?)?;
+        fs::rename(&tmp_path, dir.join("metadata.json")).map_err(|e| {
+            StoreError::InternalError(format!("failed to rename metadata.json.tmp: {e}"))
+        })?;
+
+        reporter.finish();
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn table_info_without_clamps_field() {
+        // Old dumps don't have a `clamps` field. Verify deserialization
+        // works and produces an empty vec.
+        let json = r#"{
+            "immutable": false,
+            "has_causality_region": true,
+            "chunks": [],
+            "max_vid": 42
+        }"#;
+        let info: TableInfo = serde_json::from_str(json).unwrap();
+        assert!(info.clamps.is_empty());
+        assert_eq!(info.max_vid, 42);
+        assert!(!info.immutable);
+    }
+
+    #[test]
+    fn table_info_with_clamps_field() {
+        let json = r#"{
+            "immutable": false,
+            "has_causality_region": false,
+            "chunks": [],
+            "clamps": [{"file": "Foo/clamp_000000.parquet", "min_vid": 1, "max_vid": 10, "row_count": 5}],
+            "max_vid": 100
+        }"#;
+        let info: TableInfo = serde_json::from_str(json).unwrap();
+        assert_eq!(info.clamps.len(), 1);
+        assert_eq!(info.clamps[0].file, "Foo/clamp_000000.parquet");
+        assert_eq!(info.clamps[0].row_count, 5);
+    }
+
+    #[test]
+    fn chunk_and_clamp_filenames() {
+        assert_eq!(chunk_filename(0), "chunk_000000.parquet");
+        assert_eq!(chunk_filename(1), "chunk_000001.parquet");
+        assert_eq!(chunk_filename(999), "chunk_000999.parquet");
+
+        assert_eq!(clamp_filename(0), "clamp_000000.parquet");
+        assert_eq!(clamp_filename(1), "clamp_000001.parquet");
+    }
+
+    #[test]
+    fn byte_bounded_slices_split_and_preserve_rows() {
+        use crate::relational::value::{OidRow, OidValue};
+
+        // Each row is a single string of `n` bytes, so its estimated size is `n`.
+        fn row_of(n: usize) -> OidRow {
+            vec![OidValue::String("x".repeat(n))].into_iter().collect()
+        }
+
+        // Empty input yields no slices.
+        assert!(byte_bounded_slices(&[], 1024).is_empty());
+
+        // Five 100-byte rows with a 250-byte cap pack as 2 + 2 + 1.
+        let rows: Vec<OidRow> = (0..5).map(|_| row_of(100)).collect();
+        let slices = byte_bounded_slices(&rows, 250);
+        let lens: Vec<usize> = slices.iter().map(|s| s.len()).collect();
+        assert_eq!(lens, vec![2, 2, 1]);
+        // No data lost, and no slice exceeds the cap.
+        assert_eq!(slices.iter().map(|s| s.len()).sum::<usize>(), rows.len());
+        for s in &slices {
+            assert!(s.iter().map(estimate_row_bytes).sum::<usize>() <= 250);
+        }
+
+        // A single row larger than the cap still makes progress as its own slice.
+        let big = vec![row_of(1000)];
+        let slices = byte_bounded_slices(&big, 250);
+        assert_eq!(slices.len(), 1);
+        assert_eq!(slices[0].len(), 1);
+    }
+
+    #[test]
+    fn clamp_record_batch_construction() {
+        use crate::parquet::schema::clamp_arrow_schema;
+
+        let schema = clamp_arrow_schema();
+        let rows = vec![
+            ClampRow {
+                vid: 10,
+                block_range_end: 500,
+            },
+            ClampRow {
+                vid: 20,
+                block_range_end: 600,
+            },
+            ClampRow {
+                vid: 30,
+                block_range_end: 700,
+            },
+        ];
+        let batch = clamp_rows_to_record_batch(&schema, &rows).unwrap();
+        assert_eq!(batch.num_rows(), 3);
+        assert_eq!(batch.num_columns(), 2);
+
+        let vid = batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<arrow::array::Int64Array>()
+            .unwrap();
+        assert_eq!(vid.value(0), 10);
+        assert_eq!(vid.value(1), 20);
+        assert_eq!(vid.value(2), 30);
+
+        let bre = batch
+            .column(1)
+            .as_any()
+            .downcast_ref::<arrow::array::Int32Array>()
+            .unwrap();
+        assert_eq!(bre.value(0), 500);
+        assert_eq!(bre.value(1), 600);
+        assert_eq!(bre.value(2), 700);
+    }
+}
diff --git a/store/postgres/src/relational/index.rs b/store/postgres/src/relational/index.rs
index 9458ff55917..dc66a04f9a7 100644
--- a/store/postgres/src/relational/index.rs
+++ b/store/postgres/src/relational/index.rs
@@ -1,19 +1,25 @@
 //! Parse Postgres index definition into a form that is meaningful for us.
+use anyhow::{Error, anyhow};
+use graph::env::ENV_VARS;
+use std::collections::HashMap;
 use std::fmt::{Display, Write};
 
+use diesel::sql_query;
+use diesel_async::RunQueryDsl;
+use graph::components::store::StoreError;
 use graph::itertools::Itertools;
 use graph::prelude::{
-    lazy_static,
+    BlockNumber, lazy_static,
     regex::{Captures, Regex},
-    BlockNumber,
 };
 
 use crate::block_range::{BLOCK_COLUMN, BLOCK_RANGE_COLUMN};
 use crate::relational::{BYTE_ARRAY_PREFIX_SIZE, STRING_PREFIX_SIZE};
+use crate::{AsyncPgConnection, catalog};
 
-use super::VID_COLUMN;
+use super::{Layout, Table, VID_COLUMN};
 
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum Method {
     Brin,
     BTree,
@@ -38,7 +44,7 @@ impl Display for Method {
 
 impl Method {
     fn parse(method: String) -> Self {
-        method.parse().unwrap_or_else(|()| Method::Unknown(method))
+        method.parse().unwrap_or(Method::Unknown(method))
     }
 }
 
@@ -113,7 +119,7 @@ impl Display for Expr {
             Expr::Column(s) => write!(f, "{s}")?,
             Expr::Prefix(s, _) => write!(f, "{s}")?,
             Expr::Vid => write!(f, "vid")?,
-            Expr::Block => write!(f, "block")?,
+            Expr::Block => write!(f, "{BLOCK_COLUMN}")?,
             Expr::BlockRange => write!(f, "block_range")?,
             Expr::BlockRangeLower => write!(f, "lower(block_range)")?,
             Expr::BlockRangeUpper => write!(f, "upper(block_range)")?,
@@ -124,6 +130,13 @@ impl Display for Expr {
 }
 
 impl Expr {
+    const LBR: &str = "lower(block_range)";
+    const LBR_MULTI: &str = "lower(block_range) int4_minmax_multi_ops";
+    const UBR: &str = "coalesce(upper(block_range), 2147483647)";
+    const UBR_MULTI: &str = "coalesce(upper(block_range), 2147483647) int4_minmax_multi_ops";
+    const VID_MULTI: &str = "vid int8_minmax_multi_ops";
+    const BLOCK_MULTI: &str = "block$ int4_minmax_multi_ops";
+
     fn parse(expr: &str) -> Self {
         use Expr::*;
 
@@ -131,15 +144,19 @@ impl Expr {
 
         let prefix_rx = Regex::new("^(?P<kind>substring|left)\\((?P<name>[a-z0-9$_]+)").unwrap();
 
-        if expr == VID_COLUMN {
+        // We strip out the minmax_multi_ops operator class from the
+        // expression for the columns where we usually use them. They will
+        // be put back when we create an index, but whether they should be
+        // used depends on the database in which the index is created
+        if expr == VID_COLUMN || expr == Self::VID_MULTI {
             Vid
-        } else if expr == "lower(block_range)" {
+        } else if expr == Self::LBR || expr == Self::LBR_MULTI {
             BlockRangeLower
-        } else if expr == "coalesce(upper(block_range), 2147483647)" {
+        } else if expr == Self::UBR || expr == Self::UBR_MULTI {
             BlockRangeUpper
         } else if expr == "block_range" {
             BlockRange
-        } else if expr == "block$" {
+        } else if expr == BLOCK_COLUMN || expr == Self::BLOCK_MULTI {
             Block
         } else if expr
             .chars()
@@ -180,23 +197,50 @@ impl Expr {
         }
     }
 
-    fn to_sql(&self) -> String {
-        match self {
-            Expr::Column(name) => name.to_string(),
-            Expr::Prefix(name, kind) => kind.to_sql(name),
-            Expr::Vid => VID_COLUMN.to_string(),
-            Expr::Block => BLOCK_COLUMN.to_string(),
-            Expr::BlockRange => BLOCK_RANGE_COLUMN.to_string(),
-            Expr::BlockRangeLower => "lower(block_range)".to_string(),
-            Expr::BlockRangeUpper => "coalesce(upper(block_range), 2147483647)".to_string(),
-            Expr::Unknown(expr) => expr.to_string(),
+    /// Here we check if all the columns expressions of the two indexes are "kind of same".
+    /// We ignore the operator class of the expression by checking if the string of the
+    /// original expression is a prexif of the string of the current one.
+    fn is_same_kind_columns(current: &[Expr], orig: &[Expr]) -> bool {
+        if orig.len() != current.len() {
+            return false;
+        }
+        for i in 0..orig.len() {
+            let o = orig[i].to_sql(false);
+            let n = current[i].to_sql(false);
+
+            // check that string n starts with o
+            if n.len() < o.len() || n[0..o.len()] != o {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Generate a SQL expression for this index expression. The `multi_ops`
+    /// indicates whether we should also print the `minmax_multi_ops`
+    /// operator class used for BRIN indexes. This is needed because it is
+    /// not the default operator class, and only supported in Postgres 14+.
+    fn to_sql(&self, multi_ops: bool) -> String {
+        match (self, multi_ops) {
+            (Expr::Column(name), _) => format!("\"{}\"", name),
+            (Expr::Prefix(name, kind), _) => kind.to_sql(&format!("\"{}\"", name)),
+            (Expr::Vid, true) => Self::VID_MULTI.to_string(),
+            (Expr::Vid, false) => VID_COLUMN.to_string(),
+            (Expr::Block, false) => BLOCK_COLUMN.to_string(),
+            (Expr::Block, true) => Self::BLOCK_MULTI.to_string(),
+            (Expr::BlockRange, _) => BLOCK_RANGE_COLUMN.to_string(),
+            (Expr::BlockRangeLower, false) => Self::LBR.to_string(),
+            (Expr::BlockRangeLower, true) => Self::LBR_MULTI.to_string(),
+            (Expr::BlockRangeUpper, false) => Self::UBR.to_string(),
+            (Expr::BlockRangeUpper, true) => Self::UBR_MULTI.to_string(),
+            (Expr::Unknown(expr), _) => expr.to_string(),
         }
     }
 }
 
 /// The condition for a partial index, i.e., the statement after `where ..`
 /// in a `create index` statement
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum Cond {
     /// The expression `coalesce(upper(block_range), 2147483647) > $number`
     Partial(BlockNumber),
@@ -232,23 +276,32 @@ impl Cond {
                 .map(Cond::Partial)
         }
 
-        if &cond == "coalesce(upper(block_range), 2147483647) < 2147483647" {
+        let cond = cond.trim();
+        let cond = if cond.starts_with("(") && cond.ends_with(")") {
+            &cond[1..cond.len() - 1]
+        } else {
+            cond
+        };
+        let cond = cond.trim();
+        if cond == "coalesce(upper(block_range), 2147483647) < 2147483647" {
             Cond::Closed
         } else {
-            parse_partial(&cond).unwrap_or(Cond::Unknown(cond))
+            parse_partial(cond).unwrap_or(Cond::Unknown(cond.to_string()))
         }
     }
 
     fn to_sql(&self) -> String {
         match self {
-            Cond::Partial(number) => format!("coalesce(upper(block_range), 2147483647) > {number}"),
-            Cond::Closed => "coalesce(upper(block_range), 2147483647) < 2147483647".to_string(),
+            Cond::Partial(number) => {
+                format!("(coalesce(upper(block_range), 2147483647) > {number})")
+            }
+            Cond::Closed => "(coalesce(upper(block_range), 2147483647) < 2147483647)".to_string(),
             Cond::Unknown(cond) => cond.to_string(),
         }
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum CreateIndex {
     /// The literal index definition passed to `parse`. This is used when we
     /// can't parse a `create index` statement, e.g. because it uses
@@ -354,11 +407,11 @@ impl CreateIndex {
 
         fn new_parsed(defn: &str) -> Option<CreateIndex> {
             let rx = Regex::new(
-                "create (?P<unique>unique )?index (?P<name>[a-z0-9$_]+) \
-            on (?P<nsp>sgd[0-9]+)\\.(?P<table>[a-z$_]+) \
+                "create (?P<unique>unique )?index (?P<name>\"?[a-z0-9$_]+\"?) \
+            on (?P<nsp>sgd[0-9]+)\\.(?P<table>\"?[a-z0-9$_]+\"?) \
             using (?P<method>[a-z]+) \\((?P<columns>.*?)\\)\
-            ( where \\((?P<cond>.*)\\))?\
-            ( with \\((?P<with>.*)\\))?$",
+            ( with \\((?P<with>.*)\\))?\
+            ( where (?P<cond>.*))?$",
             )
             .unwrap();
 
@@ -411,6 +464,32 @@ impl CreateIndex {
         }
     }
 
+    pub(crate) fn with_nsp(&self, nsp2: String) -> Result<Self, Error> {
+        let s = self.clone();
+        match s {
+            CreateIndex::Unknown { defn: _ } => Err(anyhow!("Failed to parse the index")),
+            CreateIndex::Parsed {
+                unique,
+                name,
+                nsp: _,
+                table,
+                method,
+                columns,
+                cond,
+                with,
+            } => Ok(CreateIndex::Parsed {
+                unique,
+                name,
+                nsp: nsp2,
+                table,
+                method,
+                columns,
+                cond,
+                with,
+            }),
+        }
+    }
+
     pub fn is_attribute_index(&self) -> bool {
         use CreateIndex::*;
         match self {
@@ -433,20 +512,36 @@ impl CreateIndex {
                             && columns[1] == Expr::BlockRange
                     }
                     Method::Brin => false,
-                    Method::BTree | Method::Gin => {
+                    Method::Gin => {
+                        // 'using gin(<attr>)'
                         columns.len() == 1
                             && columns[0].is_attribute()
                             && cond.is_none()
                             && with.is_none()
                     }
+                    Method::BTree => {
+                        match columns.len() {
+                            1 => {
+                                // 'using btree(<attr>)'
+                                columns[0].is_attribute() && cond.is_none() && with.is_none()
+                            }
+                            2 => {
+                                // 'using btree(<attr>, block$)'
+                                columns[0].is_attribute()
+                                    && columns[1] == Expr::Block
+                                    && cond.is_none()
+                                    && with.is_none()
+                            }
+                            _ => false,
+                        }
+                    }
                     Method::Unknown(_) => false,
                 }
             }
         }
     }
 
-    /// Return `true` if `self` is one of the indexes we create by default
-    pub fn is_default_index(&self) -> bool {
+    pub fn is_default_non_attr_index(&self) -> bool {
         lazy_static! {
             static ref DEFAULT_INDEXES: Vec<CreateIndex> = {
                 fn dummy(
@@ -483,11 +578,17 @@ impl CreateIndex {
                         None,
                     ),
                     dummy(false, BTree, &[Expr::BlockRangeUpper], Some(Cond::Closed)),
+                    dummy(false, BTree, &[Expr::Block], None),
                 ]
             };
         }
 
-        self.is_attribute_index() || DEFAULT_INDEXES.iter().any(|idx| self.is_same_index(idx))
+        DEFAULT_INDEXES.iter().any(|idx| self.is_same_index(idx))
+    }
+
+    /// Return `true` if `self` is one of the indexes we create by default
+    pub fn is_default_index(&self) -> bool {
+        self.is_attribute_index() || self.is_default_non_attr_index()
     }
 
     fn is_same_index(&self, other: &CreateIndex) -> bool {
@@ -517,17 +618,136 @@ impl CreateIndex {
             ) => {
                 unique == o_unique
                     && method == o_method
-                    && columns == o_columns
+                    && Expr::is_same_kind_columns(columns, o_columns)
                     && cond == o_cond
                     && with == o_with
             }
         }
     }
 
+    pub fn is_id(&self) -> bool {
+        // on imutable tables the id constraint is specified at table creation
+        match self {
+            CreateIndex::Unknown { .. } => (),
+            CreateIndex::Parsed { columns, .. } => {
+                if columns.len() == 1 && columns[0].is_id() {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
+    pub fn to_postpone(&self) -> bool {
+        if !ENV_VARS.postpone_attribute_index_creation {
+            return false;
+        }
+
+        fn has_prefix(s: &str, prefix: &str) -> bool {
+            s.starts_with(prefix)
+                || s.ends_with("\"") && s.starts_with(format!("\"{}", prefix).as_str())
+        }
+        match self {
+            CreateIndex::Unknown { .. } => false,
+            CreateIndex::Parsed {
+                name,
+                columns,
+                method,
+                ..
+            } => {
+                if *method != Method::BTree {
+                    return false;
+                }
+                if columns.len() == 1 && columns[0].is_id() {
+                    return false;
+                }
+                has_prefix(name, "attr_") && self.is_attribute_index()
+            }
+        }
+    }
+
+    pub fn name(&self) -> Option<&str> {
+        match self {
+            CreateIndex::Unknown { .. } => None,
+            CreateIndex::Parsed { name, .. } => Some(name.as_str()),
+        }
+    }
+
+    /// Return `true` if any of the attribute columns (user-defined columns,
+    /// not infrastructure columns like `vid`, `block$`, etc.) referenced by
+    /// this index are NOT in `columns`.
+    pub fn references_column_not_in(&self, columns: &std::collections::HashSet<&str>) -> bool {
+        match self {
+            CreateIndex::Unknown { .. } => false,
+            CreateIndex::Parsed { columns: exprs, .. } => exprs.iter().any(|expr| match expr {
+                Expr::Column(name) | Expr::Prefix(name, _) => !columns.contains(name.as_str()),
+                _ => false,
+            }),
+        }
+    }
+
+    pub fn fields_exist_in_dest(&self, dest_table: &Table) -> bool {
+        fn column_exists(dest_table: &Table, column_name: &str) -> bool {
+            dest_table
+                .columns
+                .iter()
+                .any(|c| c.name.as_str() == column_name)
+        }
+
+        match self {
+            CreateIndex::Unknown { defn: _ } => return true,
+            CreateIndex::Parsed {
+                columns: parsed_cols,
+                ..
+            } => {
+                for c in parsed_cols {
+                    match c {
+                        Expr::Column(column_name) => {
+                            if !column_exists(dest_table, column_name) {
+                                return false;
+                            }
+                        }
+                        Expr::Prefix(column_name, _) => {
+                            if !column_exists(dest_table, column_name) {
+                                return false;
+                            }
+                        }
+                        Expr::BlockRange | Expr::BlockRangeLower | Expr::BlockRangeUpper => {
+                            if dest_table.immutable {
+                                return false;
+                            }
+                        }
+                        Expr::Vid => (),
+                        Expr::Block => {
+                            if !dest_table.immutable {
+                                return false;
+                            }
+                        }
+                        Expr::Unknown(expression) => {
+                            if expression.contains("block_range") && dest_table.immutable {
+                                return false;
+                            }
+                            if !dest_table
+                                .columns
+                                .iter()
+                                .any(|c| expression.contains(c.name.as_str()))
+                                && !expression.contains("block_range")
+                                && !expression.contains("vid")
+                            {
+                                return false;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        true
+    }
+
     /// Generate a SQL statement that creates this index. If `concurrent` is
     /// `true`, make it a concurrent index creation. If `if_not_exists` is
     /// `true` add a `if not exists` clause to the index creation.
-    pub fn to_sql(&self, concurrent: bool, if_not_exists: bool) -> Result<String, std::fmt::Error> {
+    fn to_sql(&self, creat: &IndexCreator) -> Result<String, std::fmt::Error> {
         match self {
             CreateIndex::Unknown { defn } => Ok(defn.to_string()),
             CreateIndex::Parsed {
@@ -540,306 +760,592 @@ impl CreateIndex {
                 cond,
                 with,
             } => {
+                let IndexCreator {
+                    concurrently,
+                    if_not_exists,
+                    multi_ops,
+                } = creat;
+                // Explicit operator classes are only needed for BRIN indexes
+                let multi_ops = *multi_ops && method == &Method::Brin;
                 let unique = if *unique { "unique " } else { "" };
-                let concurrent = if concurrent { "concurrently " } else { "" };
-                let if_not_exists = if if_not_exists { "if not exists " } else { "" };
-                let columns = columns.iter().map(|c| c.to_sql()).join(", ");
+                let concurrent = if *concurrently { "concurrently " } else { "" };
+                let if_not_exists = if *if_not_exists { "if not exists " } else { "" };
+                let columns = columns.iter().map(|c| c.to_sql(multi_ops)).join(", ");
 
-                let mut sql = format!("create {unique}index {concurrent}{if_not_exists}{name} on {nsp}.{table} using {method} ({columns})");
+                let mut sql = format!(
+                    "create {unique}index {concurrent}{if_not_exists}{name} on {nsp}.{table} using {method} ({columns})"
+                );
                 if let Some(with) = with {
                     write!(sql, " with ({with})")?;
                 }
                 if let Some(cond) = cond {
-                    write!(sql, " where ({})", cond.to_sql())?;
+                    write!(sql, " where {}", cond.to_sql())?;
                 }
                 Ok(sql)
             }
         }
     }
-}
-
-#[test]
-fn parse() {
-    use Method::*;
-
-    #[derive(Debug)]
-    enum TestExpr {
-        Name(&'static str),
-        Prefix(&'static str, &'static str),
-        Vid,
-        Block,
-        BlockRange,
-        BlockRangeLower,
-        BlockRangeUpper,
-        #[allow(dead_code)]
-        Unknown(&'static str),
-    }
-
-    impl<'a> From<&'a TestExpr> for Expr {
-        fn from(expr: &'a TestExpr) -> Self {
-            match expr {
-                TestExpr::Name(name) => Expr::Column(name.to_string()),
-                TestExpr::Prefix(name, kind) => {
-                    Expr::Prefix(name.to_string(), PrefixKind::parse(kind).unwrap())
-                }
-                TestExpr::Vid => Expr::Vid,
-                TestExpr::Block => Expr::Block,
-                TestExpr::BlockRange => Expr::BlockRange,
-                TestExpr::BlockRangeLower => Expr::BlockRangeLower,
-                TestExpr::BlockRangeUpper => Expr::BlockRangeUpper,
-                TestExpr::Unknown(s) => Expr::Unknown(s.to_string()),
-            }
-        }
-    }
 
-    #[derive(Debug)]
-    enum TestCond {
-        Partial(BlockNumber),
-        Closed,
-        Unknown(&'static str),
-    }
-
-    impl From<TestCond> for Cond {
-        fn from(expr: TestCond) -> Self {
-            match expr {
-                TestCond::Partial(number) => Cond::Partial(number),
-                TestCond::Unknown(s) => Cond::Unknown(s.to_string()),
-                TestCond::Closed => Cond::Closed,
-            }
+    pub(crate) fn method(self, method: Method) -> CreateIndex {
+        match self {
+            CreateIndex::Unknown { defn } => CreateIndex::Unknown { defn },
+            CreateIndex::Parsed {
+                unique,
+                name,
+                nsp,
+                table,
+                method: _,
+                columns,
+                cond,
+                with,
+            } => CreateIndex::Parsed {
+                unique,
+                name,
+                nsp,
+                table,
+                method,
+                columns,
+                cond,
+                with,
+            },
         }
     }
 
-    #[derive(Debug)]
-    struct Parsed {
-        unique: bool,
-        name: &'static str,
-        nsp: &'static str,
-        table: &'static str,
-        method: Method,
-        columns: &'static [TestExpr],
-        cond: Option<TestCond>,
-    }
-
-    impl From<Parsed> for CreateIndex {
-        fn from(p: Parsed) -> Self {
-            let Parsed {
+    pub(crate) fn cond(self, cond: Cond) -> CreateIndex {
+        match self {
+            CreateIndex::Unknown { defn } => CreateIndex::Unknown { defn },
+            CreateIndex::Parsed {
                 unique,
                 name,
                 nsp,
                 table,
                 method,
                 columns,
-                cond,
-            } = p;
-            let columns: Vec<_> = columns.iter().map(Expr::from).collect();
-            let cond = cond.map(Cond::from);
-            CreateIndex::Parsed {
+                cond: _,
+                with,
+            } => CreateIndex::Parsed {
                 unique,
-                name: name.to_string(),
-                nsp: nsp.to_string(),
-                table: table.to_string(),
+                name,
+                nsp,
+                table,
                 method,
                 columns,
-                cond,
-                with: None,
+                cond: Some(cond),
+                with,
+            },
+        }
+    }
+}
+
+/// A helper to run or write index creation statements with options as to
+/// whether to create them concurrently or only of they do not exist
+pub struct IndexCreator {
+    concurrently: bool,
+    if_not_exists: bool,
+    /// Whether the shard supports the multi_ops operator classes
+    multi_ops: bool,
+}
+
+impl IndexCreator {
+    /// Create an index creator with the given options. The `multi_ops` flag
+    /// indicates whether the database in which we will create indexes
+    /// supports the `minmax_multi_ops` operator classes
+    pub fn new(concurrently: bool, if_not_exists: bool, multi_ops: bool) -> Self {
+        IndexCreator {
+            concurrently,
+            if_not_exists,
+            multi_ops,
+        }
+    }
+
+    /// Create the index `idx` in the transaction that is currently active
+    /// on `conn`, i.e., do not start a new transaction
+    pub async fn execute(
+        &self,
+        conn: &mut AsyncPgConnection,
+        idx: &CreateIndex,
+    ) -> Result<(), StoreError> {
+        let sql = idx.to_sql(self)?;
+        sql_query(sql).execute(conn).await?;
+        Ok(())
+    }
+
+    /// Create all indexes in `idxs`. Each index creation happens in its own
+    /// transaction, and `conn` should therefore not be in a transaction
+    /// when this method is called.
+    pub async fn execute_many(
+        &self,
+        conn: &mut AsyncPgConnection,
+        idxs: &[CreateIndex],
+    ) -> Result<(), StoreError> {
+        for idx in idxs {
+            self.execute(conn, idx).await?;
+        }
+        Ok(())
+    }
+
+    pub fn to_sql(&self, index: &CreateIndex) -> Result<String, std::fmt::Error> {
+        index.to_sql(self)
+    }
+}
+
+impl Layout {
+    /// Create an index creator with the given options for creating indexes
+    /// in this layout
+    pub fn index_creator(&self, concurrently: bool, if_not_exists: bool) -> IndexCreator {
+        let multi_ops = self.catalog.has_minmax_multi_ops;
+        IndexCreator::new(concurrently, if_not_exists, multi_ops)
+    }
+}
+
+#[derive(Debug)]
+pub struct IndexList {
+    pub(crate) indexes: HashMap<String, Vec<CreateIndex>>,
+}
+
+impl IndexList {
+    pub fn new(indexes: HashMap<String, Vec<CreateIndex>>) -> Self {
+        IndexList { indexes }
+    }
+
+    pub async fn load(conn: &mut AsyncPgConnection, layout: &Layout) -> Result<Self, StoreError> {
+        let mut indexes = HashMap::new();
+        let schema_name = layout.site.namespace.clone();
+        for table in layout.tables.values() {
+            let indexes_from_table =
+                catalog::indexes_for_table(conn, schema_name.as_str(), table.name.as_str())
+                    .await?
+                    .into_iter()
+                    .map(CreateIndex::parse)
+                    .collect();
+            indexes.insert(table.name.to_string(), indexes_from_table);
+        }
+        Ok(Self::new(indexes))
+    }
+
+    /// Return all indexes for `table` from this list. Only indexes that are
+    /// for columns that actually exist on `table` are returned. In
+    /// addition, indexes that are always created when a deployment is
+    /// created independent of the configuration are also not returned.
+    pub fn indexes_for_table<'a>(
+        &'a self,
+        table: &'a Table,
+    ) -> impl Iterator<Item = &'a CreateIndex> {
+        static EMPTY: Vec<CreateIndex> = vec![];
+        let indexes = self.indexes.get(table.name.as_str()).unwrap_or(&EMPTY);
+
+        indexes.iter().filter(move |ci| {
+            // First we check if the fields do exist in the destination subgraph.
+            // In case of grafting that is not given.
+            ci.fields_exist_in_dest(table)
+                // Then we check if the index is one of the default indexes not based on
+                // the attributes. Those will be created anyway and we should skip them.
+                && !ci.is_default_non_attr_index()
+                // Then ID based indexes in the immutable tables are also created initially
+                // and should be skipped.
+                && !(ci.is_id() && table.immutable)
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeSet;
+    use std::sync::Arc;
+
+    use graph::prelude::{BlockNumber, DeploymentHash};
+    use graph::schema::InputSchema;
+
+    use crate::layout_for_tests::{Namespace, make_dummy_site};
+    use crate::relational::Catalog;
+
+    use super::*;
+
+    fn test_layout(gql: &str) -> Layout {
+        let subgraph = DeploymentHash::new("subgraph").unwrap();
+        let schema = InputSchema::parse_latest(gql, subgraph.clone()).expect("Test schema invalid");
+        let namespace = Namespace::new("sgd0815".to_owned()).unwrap();
+        let site = Arc::new(make_dummy_site(subgraph, namespace, "anet".to_string()));
+        let catalog =
+            Catalog::for_tests(site.clone(), BTreeSet::new()).expect("Can not create catalog");
+        Layout::new(site, &schema, catalog).expect("Failed to construct Layout")
+    }
+
+    #[test]
+    fn parse() {
+        use Method::*;
+
+        #[derive(Debug)]
+        enum TestExpr {
+            Name(&'static str),
+            Prefix(&'static str, &'static str),
+            Vid,
+            Block,
+            BlockRange,
+            BlockRangeLower,
+            BlockRangeUpper,
+            #[allow(dead_code)]
+            Unknown(&'static str),
+        }
+
+        impl<'a> From<&'a TestExpr> for Expr {
+            fn from(expr: &'a TestExpr) -> Self {
+                match expr {
+                    TestExpr::Name(name) => Expr::Column(name.to_string()),
+                    TestExpr::Prefix(name, kind) => {
+                        Expr::Prefix(name.to_string(), PrefixKind::parse(kind).unwrap())
+                    }
+                    TestExpr::Vid => Expr::Vid,
+                    TestExpr::Block => Expr::Block,
+                    TestExpr::BlockRange => Expr::BlockRange,
+                    TestExpr::BlockRangeLower => Expr::BlockRangeLower,
+                    TestExpr::BlockRangeUpper => Expr::BlockRangeUpper,
+                    TestExpr::Unknown(s) => Expr::Unknown(s.to_string()),
+                }
+            }
+        }
+
+        #[derive(Debug, Clone)]
+        enum TestCond {
+            Partial(BlockNumber),
+            Closed,
+            Unknown(&'static str),
+        }
+
+        impl From<TestCond> for Cond {
+            fn from(expr: TestCond) -> Self {
+                match expr {
+                    TestCond::Partial(number) => Cond::Partial(number),
+                    TestCond::Unknown(s) => Cond::Unknown(s.to_string()),
+                    TestCond::Closed => Cond::Closed,
+                }
+            }
+        }
+
+        #[derive(Debug, Clone)]
+        struct Parsed {
+            unique: bool,
+            name: &'static str,
+            nsp: &'static str,
+            table: &'static str,
+            method: Method,
+            columns: &'static [TestExpr],
+            cond: Option<TestCond>,
+        }
+
+        impl From<Parsed> for CreateIndex {
+            fn from(p: Parsed) -> Self {
+                let Parsed {
+                    unique,
+                    name,
+                    nsp,
+                    table,
+                    method,
+                    columns,
+                    cond,
+                } = p;
+                let columns: Vec<_> = columns.iter().map(Expr::from).collect();
+                let cond = cond.map(Cond::from);
+                CreateIndex::Parsed {
+                    unique,
+                    name: name.to_string(),
+                    nsp: nsp.to_string(),
+                    table: table.to_string(),
+                    method,
+                    columns,
+                    cond,
+                    with: None,
+                }
             }
         }
+
+        #[track_caller]
+        fn parses_to(defn: &str, exp: &Parsed) -> CreateIndex {
+            let act = CreateIndex::parse(defn.to_string());
+            let exp = CreateIndex::from(exp.clone());
+            assert_eq!(exp, act);
+            act
+        }
+
+        #[track_caller]
+        fn parse_one(defn: &str, exp: Parsed) {
+            let act = parses_to(defn, &exp);
+
+            let defn = defn.to_ascii_lowercase();
+            let creat = IndexCreator::new(false, false, false);
+            assert_eq!(defn, creat.to_sql(&act).unwrap());
+        }
+
+        // Test that the equivalent index definitions in `defns` are parsed to
+        // the same `CreateIndex` and that turning those index definitions into
+        // a SQL string produces `defns[0]`
+        #[track_caller]
+        fn parse_many(defns: &[&str], exp: Parsed) {
+            let act = parses_to(defns[0], &exp);
+            for defn in &defns[1..] {
+                parses_to(defn, &exp);
+            }
+
+            let defn = defns[0].to_ascii_lowercase();
+            let creat = IndexCreator::new(false, false, false);
+            assert_eq!(defn, creat.to_sql(&act).unwrap());
+        }
+
+        use TestCond::*;
+        use TestExpr::*;
+
+        let sql = "create index attr_1_0_token_id on sgd44.token using btree (\"id\")";
+        let exp = Parsed {
+            unique: false,
+            name: "attr_1_0_token_id",
+            nsp: "sgd44",
+            table: "token",
+            method: BTree,
+            columns: &[Name("id")],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sql =
+            "create index attr_1_1_token_symbol on sgd44.token using btree (left(\"symbol\", 256))";
+        let exp = Parsed {
+            unique: false,
+            name: "attr_1_1_token_symbol",
+            nsp: "sgd44",
+            table: "token",
+            method: BTree,
+            columns: &[Prefix("symbol", "left")],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sql = "create index attr_1_5_token_trade_volume on sgd44.token using btree (\"trade_volume\")";
+        let exp = Parsed {
+            unique: false,
+            name: "attr_1_5_token_trade_volume",
+            nsp: "sgd44",
+            table: "token",
+            method: BTree,
+            columns: &[Name("trade_volume")],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sql = "create unique index token_pkey on sgd44.token using btree (vid)";
+        let exp = Parsed {
+            unique: true,
+            name: "token_pkey",
+            nsp: "sgd44",
+            table: "token",
+            method: BTree,
+            columns: &[Vid],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sql = "create index brin_token on sgd44.token using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid)";
+        let exp = Parsed {
+            unique: false,
+            name: "brin_token",
+            nsp: "sgd44",
+            table: "token",
+            method: Brin,
+            columns: &[BlockRangeLower, BlockRangeUpper, Vid],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sql = "CREATE INDEX brin_nft_transfer ON sgd4.nft_transfer USING brin (lower(block_range) int4_minmax_multi_ops, COALESCE(upper(block_range), 2147483647) int4_minmax_multi_ops, vid int8_minmax_multi_ops)";
+        let act = CreateIndex::parse(sql.to_string());
+        let CreateIndex::Parsed { columns, .. } = act else {
+            panic!("Failed to parse index");
+        };
+        assert_eq!(
+            vec![Expr::BlockRangeLower, Expr::BlockRangeUpper, Expr::Vid],
+            columns
+        );
+
+        let sql = "create index token_block_range_closed on sgd44.token using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647)";
+        let exp = Parsed {
+            unique: false,
+            name: "token_block_range_closed",
+            nsp: "sgd44",
+            table: "token",
+            method: BTree,
+            columns: &[BlockRangeUpper],
+            cond: Some(Closed),
+        };
+        parse_one(sql, exp);
+
+        let sql = "create index token_id_block_range_excl on sgd44.token using gist (\"id\", block_range)";
+        let exp = Parsed {
+            unique: false,
+            name: "token_id_block_range_excl",
+            nsp: "sgd44",
+            table: "token",
+            method: Gist,
+            columns: &[Name("id"), BlockRange],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sql = "create index attr_1_11_pool_owner on sgd411585.pool using btree (substring(\"owner\", 1, 64))";
+        let exp = Parsed {
+            unique: false,
+            name: "attr_1_11_pool_owner",
+            nsp: "sgd411585",
+            table: "pool",
+            method: BTree,
+            columns: &[Prefix("owner", "substring")],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sql = "create index attr_1_20_pool_vault_id on sgd411585.pool using gist (\"vault_id\", block_range)";
+        let exp = Parsed {
+            unique: false,
+            name: "attr_1_20_pool_vault_id",
+            nsp: "sgd411585",
+            table: "pool",
+            method: Gist,
+            columns: &[Name("vault_id"), BlockRange],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sql =
+            "create index attr_1_22_pool_tokens_list on sgd411585.pool using gin (\"tokens_list\")";
+        let exp = Parsed {
+            unique: false,
+            name: "attr_1_22_pool_tokens_list",
+            nsp: "sgd411585",
+            table: "pool",
+            method: Gin,
+            columns: &[Name("tokens_list")],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sql = "create index manual_partial_pool_total_liquidity on sgd411585.pool using btree (\"total_liquidity\") where (coalesce(upper(block_range), 2147483647) > 15635000)";
+        let exp = Parsed {
+            unique: false,
+            name: "manual_partial_pool_total_liquidity",
+            nsp: "sgd411585",
+            table: "pool",
+            method: BTree,
+            columns: &[Name("total_liquidity")],
+            cond: Some(Partial(15635000)),
+        };
+        parse_one(sql, exp);
+
+        let sql = "create index manual_swap_pool_timestamp_id on sgd217942.swap using btree (\"pool\", \"timestamp\", \"id\")";
+        let exp = Parsed {
+            unique: false,
+            name: "manual_swap_pool_timestamp_id",
+            nsp: "sgd217942",
+            table: "swap",
+            method: BTree,
+            columns: &[Name("pool"), Name("timestamp"), Name("id")],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sql = "CREATE INDEX brin_scy ON sgd314614.scy USING brin (block$, vid)";
+        let exp = Parsed {
+            unique: false,
+            name: "brin_scy",
+            nsp: "sgd314614",
+            table: "scy",
+            method: Brin,
+            columns: &[Block, Vid],
+            cond: None,
+        };
+        parse_one(sql, exp);
+
+        let sqls = &[
+            "CREATE INDEX brin_scy ON sgd314614.scy USING brin (block$, vid) where amount > 0",
+            "CREATE INDEX brin_scy ON sgd314614.scy USING brin (block$, vid) where (amount > 0)",
+        ];
+        let exp = Parsed {
+            unique: false,
+            name: "brin_scy",
+            nsp: "sgd314614",
+            table: "scy",
+            method: Brin,
+            columns: &[Block, Vid],
+            cond: Some(TestCond::Unknown("amount > 0")),
+        };
+        parse_many(sqls, exp);
+
+        let sqls = &[
+            "CREATE INDEX manual_token_random_cond ON sgd44.token USING btree (\"decimals\") WHERE decimals > (5)::numeric",
+            "CREATE INDEX manual_token_random_cond ON sgd44.token USING btree (decimals) WHERE decimals > (5)::numeric",
+            "CREATE INDEX manual_token_random_cond ON sgd44.token USING btree (decimals) WHERE ( decimals > (5)::numeric )",
+            "CREATE INDEX manual_token_random_cond ON sgd44.token USING btree (\"decimals\") WHERE ( decimals > (5)::numeric )",
+        ];
+        let exp = Parsed {
+            unique: false,
+            name: "manual_token_random_cond",
+            nsp: "sgd44",
+            table: "token",
+            method: BTree,
+            columns: &[Name("decimals")],
+            cond: Some(TestCond::Unknown("decimals > (5)::numeric")),
+        };
+        parse_many(sqls, exp);
+
+        let sqls = &[
+            "CREATE INDEX manual_pool_swap_enabled_total_liquidity ON sgd12.pool USING btree (\"total_liquidity\") WHERE swap_enabled",
+            "CREATE INDEX manual_pool_swap_enabled_total_liquidity ON sgd12.pool USING btree (total_liquidity) WHERE swap_enabled",
+        ];
+        let exp = Parsed {
+            unique: false,
+            name: "manual_pool_swap_enabled_total_liquidity",
+            nsp: "sgd12",
+            table: "pool",
+            method: BTree,
+            columns: &[Name("total_liquidity")],
+            cond: Some(TestCond::Unknown("swap_enabled")),
+        };
+        parse_many(sqls, exp);
     }
 
-    #[track_caller]
-    fn parse_one(defn: &str, exp: Parsed) {
-        let act = CreateIndex::parse(defn.to_string());
-        let exp = CreateIndex::from(exp);
-        assert_eq!(exp, act);
-
-        let defn = defn.replace('\"', "").to_ascii_lowercase();
-        assert_eq!(defn, act.to_sql(false, false).unwrap());
-    }
-
-    use TestCond::*;
-    use TestExpr::*;
-
-    let sql = "create index attr_1_0_token_id on sgd44.token using btree (id)";
-    let exp = Parsed {
-        unique: false,
-        name: "attr_1_0_token_id",
-        nsp: "sgd44",
-        table: "token",
-        method: BTree,
-        columns: &[Name("id")],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql =
-        "create index attr_1_1_token_symbol on sgd44.token using btree (\"left\"(symbol, 256))";
-    let exp = Parsed {
-        unique: false,
-        name: "attr_1_1_token_symbol",
-        nsp: "sgd44",
-        table: "token",
-        method: BTree,
-        columns: &[Prefix("symbol", "left")],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql = "create index attr_1_5_token_trade_volume on sgd44.token using btree (trade_volume)";
-    let exp = Parsed {
-        unique: false,
-        name: "attr_1_5_token_trade_volume",
-        nsp: "sgd44",
-        table: "token",
-        method: BTree,
-        columns: &[Name("trade_volume")],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql = "create unique index token_pkey on sgd44.token using btree (vid)";
-    let exp = Parsed {
-        unique: true,
-        name: "token_pkey",
-        nsp: "sgd44",
-        table: "token",
-        method: BTree,
-        columns: &[Vid],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql = "create index brin_token on sgd44.token using brin (lower(block_range), coalesce(upper(block_range), 2147483647), vid)";
-    let exp = Parsed {
-        unique: false,
-        name: "brin_token",
-        nsp: "sgd44",
-        table: "token",
-        method: Brin,
-        columns: &[BlockRangeLower, BlockRangeUpper, Vid],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql = "create index token_block_range_closed on sgd44.token using btree (coalesce(upper(block_range), 2147483647)) where (coalesce(upper(block_range), 2147483647) < 2147483647)";
-    let exp = Parsed {
-        unique: false,
-        name: "token_block_range_closed",
-        nsp: "sgd44",
-        table: "token",
-        method: BTree,
-        columns: &[BlockRangeUpper],
-        cond: Some(Closed),
-    };
-    parse_one(sql, exp);
-
-    let sql = "create index token_id_block_range_excl on sgd44.token using gist (id, block_range)";
-    let exp = Parsed {
-        unique: false,
-        name: "token_id_block_range_excl",
-        nsp: "sgd44",
-        table: "token",
-        method: Gist,
-        columns: &[Name("id"), BlockRange],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql="create index attr_1_11_pool_owner on sgd411585.pool using btree (\"substring\"(owner, 1, 64))";
-    let exp = Parsed {
-        unique: false,
-        name: "attr_1_11_pool_owner",
-        nsp: "sgd411585",
-        table: "pool",
-        method: BTree,
-        columns: &[Prefix("owner", "substring")],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql =
-        "create index attr_1_20_pool_vault_id on sgd411585.pool using gist (vault_id, block_range)";
-    let exp = Parsed {
-        unique: false,
-        name: "attr_1_20_pool_vault_id",
-        nsp: "sgd411585",
-        table: "pool",
-        method: Gist,
-        columns: &[Name("vault_id"), BlockRange],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql = "create index attr_1_22_pool_tokens_list on sgd411585.pool using gin (tokens_list)";
-    let exp = Parsed {
-        unique: false,
-        name: "attr_1_22_pool_tokens_list",
-        nsp: "sgd411585",
-        table: "pool",
-        method: Gin,
-        columns: &[Name("tokens_list")],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql = "create index manual_partial_pool_total_liquidity on sgd411585.pool using btree (total_liquidity) where (coalesce(upper(block_range), 2147483647) > 15635000)";
-    let exp = Parsed {
-        unique: false,
-        name: "manual_partial_pool_total_liquidity",
-        nsp: "sgd411585",
-        table: "pool",
-        method: BTree,
-        columns: &[Name("total_liquidity")],
-        cond: Some(Partial(15635000)),
-    };
-    parse_one(sql, exp);
-
-    let sql = "create index manual_swap_pool_timestamp_id on sgd217942.swap using btree (pool, \"timestamp\", id)";
-    let exp = Parsed {
-        unique: false,
-        name: "manual_swap_pool_timestamp_id",
-        nsp: "sgd217942",
-        table: "swap",
-        method: BTree,
-        columns: &[Name("pool"), Name("timestamp"), Name("id")],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql = "CREATE INDEX brin_scy ON sgd314614.scy USING brin (\"block$\", vid)";
-    let exp = Parsed {
-        unique: false,
-        name: "brin_scy",
-        nsp: "sgd314614",
-        table: "scy",
-        method: Brin,
-        columns: &[Block, Vid],
-        cond: None,
-    };
-    parse_one(sql, exp);
-
-    let sql =
-        "CREATE INDEX brin_scy ON sgd314614.scy USING brin (\"block$\", vid) where (amount > 0)";
-    let exp = Parsed {
-        unique: false,
-        name: "brin_scy",
-        nsp: "sgd314614",
-        table: "scy",
-        method: Brin,
-        columns: &[Block, Vid],
-        cond: Some(TestCond::Unknown("amount > 0")),
-    };
-    parse_one(sql, exp);
-
-    let sql =
-        "CREATE INDEX manual_token_random_cond ON sgd44.token USING btree (decimals) WHERE (decimals > (5)::numeric)";
-    let exp = Parsed {
-        unique: false,
-        name: "manual_token_random_cond",
-        nsp: "sgd44",
-        table: "token",
-        method: BTree,
-        columns: &[Name("decimals")],
-        cond: Some(TestCond::Unknown("decimals > (5)::numeric")),
-    };
-    parse_one(sql, exp);
+    #[test]
+    fn fields_exist_in_dest_out_of_order() {
+        let gql = "type Thing @entity {
+            id: Bytes!
+            early: String!
+            mid: String!
+            late: String!
+        }";
+        let layout = test_layout(gql);
+        let table = layout
+            .table_for_entity(&layout.input_schema.entity_type("Thing").unwrap())
+            .unwrap();
+
+        // Index references columns in reverse order vs the table definition.
+        // Table columns: id, early, mid, late
+        // Index columns: late, mid, early
+        // The consuming iterator finds 'late', advances past 'mid' and 'early',
+        // then can't find 'mid' because the iterator is already past it.
+        let index = CreateIndex::Parsed {
+            unique: false,
+            name: "test_reverse".to_string(),
+            nsp: "sgd0815".to_string(),
+            table: "thing".to_string(),
+            method: Method::BTree,
+            columns: vec![
+                Expr::Column("late".to_string()),
+                Expr::Column("mid".to_string()),
+                Expr::Column("early".to_string()),
+            ],
+            cond: None,
+            with: None,
+        };
+
+        assert!(
+            index.fields_exist_in_dest(table),
+            "index columns exist in table regardless of order"
+        );
+    }
 }
diff --git a/store/postgres/src/relational/prune.rs b/store/postgres/src/relational/prune.rs
index c068bb4a25a..2bfb7e6c9c9 100644
--- a/store/postgres/src/relational/prune.rs
+++ b/store/postgres/src/relational/prune.rs
@@ -1,66 +1,28 @@
-use std::{fmt::Write, sync::Arc, time::Instant};
+use std::{fmt::Write, future::Future, pin::Pin, sync::Arc};
 
 use diesel::{
-    connection::SimpleConnection,
     sql_query,
     sql_types::{BigInt, Integer},
-    Connection, PgConnection, RunQueryDsl,
 };
+use diesel_async::{AsyncConnection, RunQueryDsl, SimpleAsyncConnection};
 use graph::{
     components::store::{PrunePhase, PruneReporter, PruneRequest, PruningStrategy, VersionStats},
-    prelude::{
-        BlockNumber, CancelHandle, CancelToken, CancelableError, CheapClone, StoreError,
-        BLOCK_NUMBER_MAX,
-    },
-    slog::{warn, Logger},
+    prelude::{BLOCK_NUMBER_MAX, BlockNumber, CancelableError, CheapClone, StoreError},
+    slog::{Logger, warn},
 };
 use itertools::Itertools;
 
 use crate::{
-    catalog,
-    copy::AdaptiveBatchSize,
+    AsyncPgConnection, catalog,
+    copy::BATCH_STATEMENT_TIMEOUT,
     deployment,
     relational::{Table, VID_COLUMN},
+    vid_batcher::{VidBatcher, VidRange},
 };
 
-use super::{Catalog, Layout, Namespace};
+use super::{Layout, Namespace};
 
-// Additions to `Table` that are useful for pruning
-impl Table {
-    /// Return the first and last vid of any entity that is visible in the
-    /// block range from `first_block` (inclusive) to `last_block`
-    /// (exclusive)
-    fn vid_range(
-        &self,
-        conn: &PgConnection,
-        first_block: BlockNumber,
-        last_block: BlockNumber,
-    ) -> Result<(i64, i64), StoreError> {
-        #[derive(QueryableByName)]
-        struct VidRange {
-            #[sql_type = "BigInt"]
-            min_vid: i64,
-            #[sql_type = "BigInt"]
-            max_vid: i64,
-        }
-
-        // Determine the last vid that we need to copy
-        let VidRange { min_vid, max_vid } = sql_query(format!(
-            "/* controller=prune,first={first_block},last={last_block} */ \
-                     select coalesce(min(vid), 0) as min_vid, \
-                            coalesce(max(vid), -1) as max_vid from {src} \
-                      where lower(block_range) <= $2 \
-                        and coalesce(upper(block_range), 2147483647) > $1 \
-                        and coalesce(upper(block_range), 2147483647) <= $2 \
-                        and block_range && int4range($1, $2)",
-            src = self.qualified_name,
-        ))
-        .bind::<Integer, _>(first_block)
-        .bind::<Integer, _>(last_block)
-        .get_result::<VidRange>(conn)?;
-        Ok((min_vid, max_vid))
-    }
-}
+pub use status::{Phase, PruneState, PruneTableState, Viewer};
 
 /// Utility to copy relevant data out of a source table and into a new
 /// destination table and replace the source table with the destination
@@ -79,22 +41,25 @@ impl TablePair {
     /// Create a `TablePair` for `src`. This creates a new table `dst` with
     /// the same structure as the `src` table in the database, but in a
     /// different namespace so that the names of indexes etc. don't clash
-    fn create(
-        conn: &PgConnection,
+    async fn create(
+        conn: &mut AsyncPgConnection,
+        src_layout: &Layout,
         src: Arc<Table>,
-        src_nsp: Namespace,
         dst_nsp: Namespace,
-        catalog: &Catalog,
     ) -> Result<Self, StoreError> {
+        let src_nsp = src_layout.site.namespace.clone();
         let dst = src.new_like(&dst_nsp, &src.name);
 
         let mut query = String::new();
-        if catalog::table_exists(conn, dst_nsp.as_str(), &dst.name)? {
+        if catalog::table_exists(conn, dst_nsp.as_str(), &dst.name).await? {
             writeln!(query, "truncate table {};", dst.qualified_name)?;
         } else {
-            dst.as_ddl(catalog, &mut query)?;
+            // In case of pruning we don't do delayed creation of indexes,
+            // as the asumption is that there is not that much data inserted.
+            let creat = src_layout.index_creator(false, false);
+            dst.as_ddl(&src_layout.input_schema, &creat, &mut query)?;
         }
-        conn.batch_execute(&query)?;
+        conn.batch_execute(&query).await?;
 
         Ok(TablePair {
             src,
@@ -108,63 +73,70 @@ impl TablePair {
     /// `final_block` in batches, where each batch is a separate
     /// transaction. Write activity for nonfinal blocks can happen
     /// concurrently to this copy
-    fn copy_final_entities(
+    async fn copy_final_entities(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         reporter: &mut dyn PruneReporter,
+        tracker: &status::Tracker,
         earliest_block: BlockNumber,
         final_block: BlockNumber,
-        cancel: &CancelHandle,
     ) -> Result<(), CancelableError<StoreError>> {
-        let column_list = self.column_list();
+        let column_list = Arc::new(self.column_list());
 
         // Determine the last vid that we need to copy
-        let (min_vid, max_vid) = self.src.vid_range(conn, earliest_block, final_block)?;
-
-        let mut batch_size = AdaptiveBatchSize::new(&self.src);
-        // The first vid we still need to copy
-        let mut next_vid = min_vid;
-        while next_vid <= max_vid {
-            let start = Instant::now();
-            let rows = conn.transaction(|| {
-                // Page through all rows in `src` in batches of `batch_size`
-                // and copy the ones that are visible to queries at block
-                // heights between `earliest_block` and `final_block`, but
-                // whose block_range does not extend past `final_block`
-                // since they could still be reverted while we copy.
-                // The conditions on `block_range` are expressed redundantly
-                // to make more indexes useable
-                sql_query(format!(
-                    "/* controller=prune,phase=final,start_vid={next_vid},batch_size={batch_size} */ \
+        let range = VidRange::for_prune(conn, &self.src, earliest_block, final_block).await?;
+        let mut batcher = VidBatcher::load(conn, &self.src_nsp, &self.src, range).await?;
+        tracker.start_copy_final(conn, &self.src, range).await?;
+
+        let src_name = self.src.qualified_name.clone();
+        let dst_name = self.dst.qualified_name.clone();
+        while !batcher.finished() {
+            let rows = batch_with_timeout(conn, &mut batcher, |conn, start, end| {
+                let column_list = column_list.cheap_clone();
+                let src_name = src_name.clone();
+                let dst_name = dst_name.clone();
+                Box::pin(async move {
+                    // Page through all rows in `src` in batches of `batch_size`
+                    // and copy the ones that are visible to queries at block
+                    // heights between `earliest_block` and `final_block`, but
+                    // whose block_range does not extend past `final_block`
+                    // since they could still be reverted while we copy.
+                    // The conditions on `block_range` are expressed redundantly
+                    // to make more indexes useable
+                    sql_query(format!(
+                        "/* controller=prune,phase=final,start_vid={start},batch_size={batch_size} */ \
                      insert into {dst}({column_list}) \
                      select {column_list} from {src} \
                       where lower(block_range) <= $2 \
                         and coalesce(upper(block_range), 2147483647) > $1 \
                         and coalesce(upper(block_range), 2147483647) <= $2 \
                         and block_range && int4range($1, $2, '[]') \
-                        and vid >= $3 and vid < $3 + $4 \
+                        and vid >= $3 and vid <= $4 \
                       order by vid",
-                    src = self.src.qualified_name,
-                    dst = self.dst.qualified_name,
-                    batch_size = batch_size.size,
-                ))
-                .bind::<Integer, _>(earliest_block)
-                .bind::<Integer, _>(final_block)
-                .bind::<BigInt, _>(next_vid)
-                .bind::<BigInt, _>(&batch_size)
-                .execute(conn)
-            })?;
-            cancel.check_cancel()?;
-
-            next_vid += batch_size.size;
-
-            batch_size.adapt(start.elapsed());
+                        src = src_name,
+                        dst = dst_name,
+                        batch_size = end - start + 1,
+                    ))
+                    .bind::<Integer, _>(earliest_block)
+                    .bind::<Integer, _>(final_block)
+                    .bind::<BigInt, _>(start)
+                    .bind::<BigInt, _>(end)
+                    .execute(conn)
+                    .await
+                    .map_err(StoreError::from)
+                })
+            })
+            .await?;
+            let rows = rows.unwrap_or(0);
+            tracker
+                .finish_batch(conn, &self.src, rows as i64, &batcher)
+                .await?;
 
             reporter.prune_batch(
                 self.src.name.as_str(),
                 rows,
                 PrunePhase::CopyFinal,
-                next_vid > max_vid,
+                batcher.finished(),
             );
         }
         Ok(())
@@ -173,91 +145,103 @@ impl TablePair {
     /// Copy all entity versions visible after `final_block` in batches,
     /// where each batch is a separate transaction. This assumes that all
     /// other write activity to the source table is blocked while we copy
-    fn copy_nonfinal_entities(
+    async fn copy_nonfinal_entities(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         reporter: &mut dyn PruneReporter,
+        tracker: &status::Tracker,
         final_block: BlockNumber,
     ) -> Result<(), StoreError> {
-        let column_list = self.column_list();
+        let column_list = Arc::new(self.column_list());
 
         // Determine the last vid that we need to copy
-        let (min_vid, max_vid) = self
-            .src
-            .vid_range(conn, final_block + 1, BLOCK_NUMBER_MAX)?;
-
-        let mut batch_size = AdaptiveBatchSize::new(&self.src);
-        // The first vid we still need to copy
-        let mut next_vid = min_vid;
-        while next_vid <= max_vid {
-            let start = Instant::now();
-            let rows = conn.transaction(|| {
-                // Page through all the rows in `src` in batches of
-                // `batch_size` that are visible to queries at block heights
-                // starting right after `final_block`.
-                // The conditions on `block_range` are expressed redundantly
-                // to make more indexes useable
-                sql_query(format!(
-                    "/* controller=prune,phase=nonfinal,start_vid={next_vid},batch_size={batch_size} */ \
+        let range = VidRange::for_prune(conn, &self.src, final_block, BLOCK_NUMBER_MAX).await?;
+        let mut batcher = VidBatcher::load(conn, &self.src.nsp, &self.src, range).await?;
+        tracker.start_copy_nonfinal(conn, &self.src, range).await?;
+
+        let src_name = self.src.qualified_name.clone();
+        let dst_name = self.dst.qualified_name.clone();
+        while !batcher.finished() {
+            let rows = batch_with_timeout(conn, &mut batcher, |conn, start, end| {
+                let column_list = column_list.cheap_clone();
+                let src_name = src_name.clone();
+                let dst_name = dst_name.clone();
+                Box::pin(async move {
+                    // Page through all the rows in `src` in batches of
+                    // `batch_size` that are visible to queries at block heights
+                    // starting right after `final_block`. The conditions on
+                    // `block_range` are expressed redundantly to make more
+                    // indexes useable
+                    sql_query(format!(
+                        "/* controller=prune,phase=nonfinal,start_vid={start},batch_size={batch_size} */ \
                      insert into {dst}({column_list}) \
                      select {column_list} from {src} \
                       where coalesce(upper(block_range), 2147483647) > $1 \
                         and block_range && int4range($1, null) \
-                        and vid >= $2 and vid < $2 + $3 \
+                        and vid >= $2 and vid <= $3 \
                       order by vid",
-                    dst = self.dst.qualified_name,
-                    src = self.src.qualified_name,
-                    batch_size = batch_size.size
-                ))
-                .bind::<Integer, _>(final_block)
-                .bind::<BigInt, _>(next_vid)
-                .bind::<BigInt, _>(&batch_size)
-                .execute(conn)
-                .map_err(StoreError::from)
-            })?;
+                        dst = dst_name,
+                        src = src_name,
+                        batch_size = end - start + 1,
+                    ))
+                    .bind::<Integer, _>(final_block)
+                    .bind::<BigInt, _>(start)
+                    .bind::<BigInt, _>(end)
+                    .execute(conn)
+                    .await
+                    .map_err(StoreError::from)
+                })
+            }).await?;
+            let rows = rows.unwrap_or(0);
 
-            next_vid += batch_size.size;
-
-            batch_size.adapt(start.elapsed());
+            tracker
+                .finish_batch(conn, &self.src, rows as i64, &batcher)
+                .await?;
 
             reporter.prune_batch(
                 self.src.name.as_str(),
                 rows,
                 PrunePhase::CopyNonfinal,
-                next_vid > max_vid,
+                batcher.finished(),
             );
         }
         Ok(())
     }
 
     /// Replace the `src` table with the `dst` table
-    fn switch(self, logger: &Logger, conn: &PgConnection) -> Result<(), StoreError> {
+    async fn switch(self, logger: &Logger, conn: &mut AsyncPgConnection) -> Result<(), StoreError> {
         let src_qname = &self.src.qualified_name;
         let dst_qname = &self.dst.qualified_name;
         let src_nsp = &self.src_nsp;
         let dst_nsp = &self.dst_nsp;
 
-        let vid_seq = format!("{}_{VID_COLUMN}_seq", self.src.name);
-
         let mut query = String::new();
 
         // What we are about to do would get blocked by autovacuum on our
         // tables, so just kill the autovacuum
-        if let Err(e) = catalog::cancel_vacuum(conn, src_nsp) {
+        if let Err(e) = catalog::cancel_vacuum(conn, src_nsp).await {
             warn!(logger, "Failed to cancel vacuum during pruning; trying to carry on regardless";
                   "src" => src_nsp.as_str(), "error" => e.to_string());
         }
 
-        // Make sure the vid sequence
-        // continues from where it was
-        writeln!(
-            query,
-            "select setval('{dst_nsp}.{vid_seq}', nextval('{src_nsp}.{vid_seq}'));"
-        )?;
+        // Make sure the vid sequence continues from where it was in case
+        // that we use autoincrementing order of the DB
+        if !self.src.object.has_vid_seq() {
+            let vid_seq = catalog::seq_name(&self.src.name, VID_COLUMN);
+
+            writeln!(
+                query,
+                "select setval('{dst_nsp}.{vid_seq}', nextval('{src_nsp}.{vid_seq}'));"
+            )?;
+            writeln!(query, "drop sequence {src_nsp}.{vid_seq} cascade;")?;
+        }
 
         writeln!(query, "drop table {src_qname};")?;
         writeln!(query, "alter table {dst_qname} set schema {src_nsp}")?;
-        conn.transaction(|| conn.batch_execute(&query))?;
+        conn.transaction(async move |conn| {
+            conn.batch_execute(&query).await.map_err(StoreError::from)
+        })
+        .await?;
 
         Ok(())
     }
@@ -273,22 +257,20 @@ impl TablePair {
 impl Layout {
     /// Analyze the `tables` and return `VersionStats` for all tables in
     /// this `Layout`
-    fn analyze_tables(
+    async fn analyze_tables(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         reporter: &mut dyn PruneReporter,
         mut tables: Vec<&Arc<Table>>,
-        cancel: &CancelHandle,
-    ) -> Result<Vec<VersionStats>, CancelableError<StoreError>> {
+    ) -> Result<Vec<VersionStats>, StoreError> {
         reporter.start_analyze();
         tables.sort_by_key(|table| table.name.as_str());
         for table in &tables {
             reporter.start_analyze_table(table.name.as_str());
-            table.analyze(conn)?;
+            table.analyze(conn).await?;
             reporter.finish_analyze_table(table.name.as_str());
-            cancel.check_cancel()?;
         }
-        let stats = catalog::stats(conn, &self.site)?;
+        let stats = self.catalog.stats(conn).await?;
 
         let analyzed: Vec<_> = tables.iter().map(|table| table.name.as_str()).collect();
         reporter.finish_analyze(&stats, &analyzed);
@@ -300,17 +282,16 @@ impl Layout {
     /// is `true`, analyze all tables before getting statistics. If it is
     /// `false`, only analyze tables that Postgres' autovacuum daemon would
     /// consider needing analysis.
-    fn version_stats(
+    async fn version_stats(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         reporter: &mut dyn PruneReporter,
         analyze_all: bool,
-        cancel: &CancelHandle,
-    ) -> Result<Vec<VersionStats>, CancelableError<StoreError>> {
+    ) -> Result<Vec<VersionStats>, StoreError> {
         let needs_analyze = if analyze_all {
             vec![]
         } else {
-            catalog::needs_autoanalyze(conn, &self.site.namespace)?
+            catalog::needs_autoanalyze(conn, &self.site.namespace).await?
         };
         let tables: Vec<_> = self
             .tables
@@ -318,7 +299,7 @@ impl Layout {
             .filter(|table| analyze_all || needs_analyze.contains(&table.name))
             .collect();
 
-        self.analyze_tables(conn, reporter, tables, cancel)
+        self.analyze_tables(conn, reporter, tables).await
     }
 
     /// Return all tables and the strategy to prune them withir stats whose ratio of distinct entities
@@ -382,22 +363,51 @@ impl Layout {
     /// also block queries to the deployment, often for extended periods of
     /// time. The rebuild strategy never blocks reads, it only ever blocks
     /// writes.
-    pub fn prune(
-        &self,
+    ///
+    /// This method will only return an `Err` if storing pruning status
+    /// fails, e.g. because the database is not available. All errors that
+    /// happen during pruning itself will be stored in the `prune_state`
+    /// table and this method will return `Ok`
+    pub async fn prune(
+        self: Arc<Self>,
         logger: &Logger,
         reporter: &mut dyn PruneReporter,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         req: &PruneRequest,
-        cancel: &CancelHandle,
     ) -> Result<(), CancelableError<StoreError>> {
-        reporter.start(req);
+        let tracker = status::Tracker::new(conn, self.clone()).await?;
 
-        let stats = self.version_stats(conn, reporter, true, cancel)?;
+        let res = self
+            .prune_inner(logger, reporter, conn, req, &tracker)
+            .await;
 
-        let prunable_tables: Vec<_> = self.prunable_tables(&stats, req).into_iter().collect();
+        match res {
+            Ok(_) => {
+                tracker.finish(conn).await?;
+            }
+            Err(e) => {
+                // If we get an error, we need to set the error in the
+                // database and finish the tracker
+                let err = e.to_string();
+                tracker.error(conn, &err).await?;
+            }
+        }
 
-        // create a shadow namespace where we will put the copies of our
-        // tables, but only create it in the database if we really need it
+        Ok(())
+    }
+
+    async fn prune_inner(
+        self: Arc<Self>,
+        logger: &Logger,
+        reporter: &mut dyn PruneReporter,
+        conn: &mut AsyncPgConnection,
+        req: &PruneRequest,
+        tracker: &status::Tracker,
+    ) -> Result<(), CancelableError<StoreError>> {
+        reporter.start(req);
+        let stats = self.version_stats(conn, reporter, true).await?;
+        let prunable_tables: Vec<_> = self.prunable_tables(&stats, req).into_iter().collect();
+        tracker.start(conn, req, &prunable_tables).await?;
         let dst_nsp = Namespace::prune(self.site.id);
         let mut recreate_dst_nsp = true;
 
@@ -413,94 +423,646 @@ impl Layout {
         // is the definition of 'final'
         for (table, strat) in &prunable_tables {
             reporter.start_table(table.name.as_str());
+            tracker.start_table(conn, table).await?;
             match strat {
                 PruningStrategy::Rebuild => {
                     if recreate_dst_nsp {
-                        catalog::recreate_schema(conn, dst_nsp.as_str())?;
+                        catalog::recreate_schema(conn, dst_nsp.as_str()).await?;
                         recreate_dst_nsp = false;
                     }
-                    let pair = TablePair::create(
-                        conn,
-                        table.cheap_clone(),
-                        self.site.namespace.clone(),
-                        dst_nsp.clone(),
-                        &self.catalog,
-                    )?;
+                    let pair = TablePair::create(conn, &self, table.cheap_clone(), dst_nsp.clone())
+                        .await?;
                     // Copy final entities. This can happen in parallel to indexing as
                     // that part of the table will not change
                     pair.copy_final_entities(
                         conn,
                         reporter,
+                        tracker,
                         req.earliest_block,
                         req.final_block,
-                        cancel,
-                    )?;
+                    )
+                    .await?;
                     // Copy nonfinal entities, and replace the original `src` table with
                     // the smaller `dst` table
                     // see also: deployment-lock-for-update
                     reporter.start_switch();
-                    deployment::with_lock(conn, &self.site, || -> Result<_, StoreError> {
-                        pair.copy_nonfinal_entities(conn, reporter, req.final_block)?;
-                        cancel.check_cancel().map_err(CancelableError::from)?;
+                    deployment::with_lock(
+                        conn,
+                        &self.site,
+                        async |conn| -> Result<_, StoreError> {
+                            pair.copy_nonfinal_entities(conn, reporter, tracker, req.final_block)
+                                .await?;
 
-                        conn.transaction(|| pair.switch(logger, conn))?;
-                        cancel.check_cancel().map_err(CancelableError::from)?;
+                            pair.switch(logger, conn).await?;
 
-                        Ok(())
-                    })?;
+                            Ok(())
+                        },
+                    )
+                    .await?;
                     reporter.finish_switch();
                 }
                 PruningStrategy::Delete => {
                     // Delete all entity versions whose range was closed
                     // before `req.earliest_block`
-                    let (min_vid, max_vid) = table.vid_range(conn, 0, req.earliest_block)?;
-                    let mut batch_size = AdaptiveBatchSize::new(&table);
-                    let mut next_vid = min_vid;
-                    while next_vid <= max_vid {
-                        let start = Instant::now();
-                        let rows = sql_query(format!(
-                            "/* controller=prune,phase=delete,start_vid={next_vid},batch_size={batch_size} */ \
-                             delete from {qname} \
-                                          where coalesce(upper(block_range), 2147483647) <= $1 \
-                                            and vid >= $2 and vid < $2 + $3",
-                            qname = table.qualified_name,
-                            batch_size = batch_size.size
-                        ))
-                        .bind::<Integer, _>(req.earliest_block)
-                        .bind::<BigInt, _>(next_vid)
-                        .bind::<BigInt, _>(&batch_size)
-                        .execute(conn)?;
+                    let range = VidRange::for_prune(conn, table, 0, req.earliest_block).await?;
+                    let mut batcher =
+                        VidBatcher::load(conn, &self.site.namespace, table, range).await?;
 
-                        next_vid += batch_size.size;
+                    tracker.start_delete(conn, table, range, &batcher).await?;
+                    let qname = table.qualified_name.clone();
+                    let earliest_block = req.earliest_block;
+                    while !batcher.finished() {
+                        let rows = batch_with_timeout(conn, &mut batcher, |conn, start, end| {
+                            let qname = qname.clone();
+                            Box::pin(async move {
+                                sql_query(format!(
+                                "/* controller=prune,phase=delete,start_vid={start},batch_size={batch_size} */ \
+                                 delete from {qname} \
+                                              where coalesce(upper(block_range), 2147483647) <= $1 \
+                                                and vid >= $2 and vid <= $3",
+                                batch_size = end - start + 1
+                            ))
+                            .bind::<Integer, _>(earliest_block)
+                            .bind::<BigInt, _>(start)
+                            .bind::<BigInt, _>(end)
+                            .execute(conn)
+                            .await
+                            .map_err(StoreError::from)
+                            })
+                        }).await?;
+                        let rows = rows.unwrap_or(0);
 
-                        batch_size.adapt(start.elapsed());
+                        tracker
+                            .finish_batch(conn, table, -(rows as i64), &batcher)
+                            .await?;
 
                         reporter.prune_batch(
                             table.name.as_str(),
-                            rows as usize,
+                            rows,
                             PrunePhase::Delete,
-                            next_vid > max_vid,
+                            batcher.finished(),
                         );
                     }
                 }
             }
             reporter.finish_table(table.name.as_str());
+            tracker.finish_table(conn, table).await?;
         }
-        // Get rid of the temporary prune schema if we actually created it
         if !recreate_dst_nsp {
-            catalog::drop_schema(conn, dst_nsp.as_str())?;
+            catalog::drop_schema(conn, dst_nsp.as_str()).await?;
         }
-
         for (table, _) in &prunable_tables {
-            catalog::set_last_pruned_block(conn, &self.site, &table.name, req.earliest_block)?;
+            catalog::set_last_pruned_block(conn, &self.site, &table.name, req.earliest_block)
+                .await?;
         }
-
-        // Analyze the new tables
         let tables = prunable_tables.iter().map(|(table, _)| *table).collect();
-        self.analyze_tables(conn, reporter, tables, cancel)?;
-
+        self.analyze_tables(conn, reporter, tables).await?;
         reporter.finish();
-
         Ok(())
     }
 }
+
+/// The type of per-batch query closure expected by `batch_with_timeout`.
+/// Callers wrap their async body in `Box::pin(async move { ... })` so that
+/// the future is type-erased and explicitly `Send`. This sidesteps the
+/// limitation that async closures don't implement `Fn`/`FnMut`, which
+/// would prevent us from calling the closure again on the timeout-retry
+/// path.
+type BatchQuery<'r, R> = Pin<Box<dyn Future<Output = Result<R, StoreError>> + Send + 'r>>;
+
+/// Perform a step with the `batcher`. If that step takes longer than
+/// `BATCH_STATEMENT_TIMEOUT`, kill the query and reset the batch size of
+/// the batcher to 1 and perform a step with that size which we assume takes
+/// less than `BATCH_STATEMENT_TIMEOUT`.
+///
+/// Doing this serves as a safeguard against very bad batch size estimations
+/// so that batches never take longer than `BATCH_SIZE_TIMEOUT`
+async fn batch_with_timeout<R, F>(
+    conn: &mut AsyncPgConnection,
+    batcher: &mut VidBatcher,
+    mut query: F,
+) -> Result<Option<R>, StoreError>
+where
+    R: Send,
+    F: for<'r> FnMut(&'r mut AsyncPgConnection, i64, i64) -> BatchQuery<'r, R> + Send,
+{
+    async fn run_attempt<R, F>(
+        conn: &mut AsyncPgConnection,
+        batcher: &mut VidBatcher,
+        query: &mut F,
+        with_timeout: bool,
+    ) -> Result<Option<R>, StoreError>
+    where
+        R: Send,
+        F: for<'r> FnMut(&'r mut AsyncPgConnection, i64, i64) -> BatchQuery<'r, R> + Send,
+    {
+        batcher
+            .step(async |start, end| {
+                conn.transaction(async |conn| {
+                    if with_timeout && let Some(timeout) = BATCH_STATEMENT_TIMEOUT.as_ref() {
+                        conn.batch_execute(timeout).await?;
+                    }
+                    query(conn, start, end).await
+                })
+                .await
+            })
+            .await
+            .map(|(_, res)| res)
+    }
+
+    let res = run_attempt(conn, batcher, &mut query, true).await;
+    let Err(StoreError::StatementTimeout) = res else {
+        return res;
+    };
+
+    // Timeout fired. Shrink to one row and retry without the timeout — at
+    // this size we expect the query to complete.
+    batcher.set_batch_size(1);
+    run_attempt(conn, batcher, &mut query, false).await
+}
+
+mod status {
+    use std::sync::Arc;
+
+    use chrono::{DateTime, Utc};
+    use diesel::{
+        AsChangeset, ExpressionMethods as _, OptionalExtension, QueryDsl as _,
+        deserialize::FromSql,
+        dsl::insert_into,
+        pg::{Pg, PgValue},
+        query_builder::QueryFragment,
+        serialize::{Output, ToSql},
+        sql_types::Text,
+        table, update,
+    };
+    use diesel_async::{AsyncConnection, RunQueryDsl as _};
+    use graph::{
+        components::store::{PruneRequest, PruningStrategy, StoreResult},
+        env::ENV_VARS,
+        prelude::StoreError,
+    };
+
+    use crate::{
+        AsyncPgConnection, ConnectionPool,
+        relational::{Layout, Table},
+        vid_batcher::{VidBatcher, VidRange},
+    };
+
+    table! {
+        subgraphs.prune_state(vid) {
+            vid -> Integer,
+            // Deployment id (sgd)
+            id -> Integer,
+            run -> Integer,
+            // The first block in the subgraph when the prune started
+            first_block -> Integer,
+            final_block -> Integer,
+            latest_block -> Integer,
+            // The amount of history configured
+            history_blocks -> Integer,
+
+            started_at -> Timestamptz,
+            finished_at -> Nullable<Timestamptz>,
+            errored_at -> Nullable<Timestamptz>,
+            error -> Nullable<Text>,
+        }
+    }
+
+    table! {
+        subgraphs.prune_table_state(vid) {
+            vid -> Integer,
+            // Deployment id (sgd)
+            id -> Integer,
+            run -> Integer,
+            table_name -> Text,
+
+            strategy -> Char,
+            // see enum Phase
+            phase -> Text,
+
+            start_vid -> Nullable<BigInt>,
+            final_vid -> Nullable<BigInt>,
+            nonfinal_vid -> Nullable<BigInt>,
+            rows -> Nullable<BigInt>,
+
+            next_vid -> Nullable<BigInt>,
+            batch_size -> Nullable<BigInt>,
+
+            started_at -> Nullable<Timestamptz>,
+            finished_at -> Nullable<Timestamptz>,
+        }
+    }
+
+    #[derive(Clone, Copy, Debug, AsExpression, FromSqlRow)]
+    #[diesel(sql_type = Text)]
+    pub enum Phase {
+        Queued,
+        Started,
+        /// Only used when strategy is Rebuild
+        CopyFinal,
+        /// Only used when strategy is Rebuild
+        CopyNonfinal,
+        /// Only used when strategy is Delete
+        Delete,
+        Done,
+        /// Not a real phase, indicates that the database has an invalid
+        /// value
+        Unknown,
+    }
+
+    impl Phase {
+        fn from_str(phase: &str) -> Self {
+            use Phase::*;
+            match phase {
+                "queued" => Queued,
+                "started" => Started,
+                "copy_final" => CopyFinal,
+                "copy_nonfinal" => CopyNonfinal,
+                "delete" => Delete,
+                "done" => Done,
+                _ => Unknown,
+            }
+        }
+
+        pub fn as_str(&self) -> &str {
+            use Phase::*;
+            match self {
+                Queued => "queued",
+                Started => "started",
+                CopyFinal => "copy_final",
+                CopyNonfinal => "copy_nonfinal",
+                Delete => "delete",
+                Done => "done",
+                Unknown => "*unknown*",
+            }
+        }
+    }
+
+    impl ToSql<diesel::sql_types::Text, Pg> for Phase {
+        fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
+            let phase = self.as_str();
+            <str as ToSql<Text, Pg>>::to_sql(phase, &mut out.reborrow())
+        }
+    }
+
+    impl FromSql<Text, Pg> for Phase {
+        fn from_sql(bytes: PgValue) -> diesel::deserialize::Result<Self> {
+            Ok(Phase::from_str(std::str::from_utf8(bytes.as_bytes())?))
+        }
+    }
+
+    /// Information about one pruning run for a deployment
+    #[derive(Queryable)]
+    pub struct PruneState {
+        pub vid: i32,
+        pub id: i32,
+        pub run: i32,
+        pub first_block: i32,
+        pub final_block: i32,
+        pub latest_block: i32,
+        pub history_blocks: i32,
+
+        pub started_at: DateTime<Utc>,
+        pub finished_at: Option<DateTime<Utc>>,
+
+        pub errored_at: Option<DateTime<Utc>>,
+        pub error: Option<String>,
+    }
+
+    /// Per-table information about the pruning run for a deployment
+    #[derive(Queryable)]
+    pub struct PruneTableState {
+        pub vid: i32,
+        pub id: i32,
+        pub run: i32,
+        pub table_name: String,
+
+        // 'r' for rebuild or 'd' for delete
+        pub strategy: String,
+        pub phase: Phase,
+
+        pub start_vid: Option<i64>,
+        pub final_vid: Option<i64>,
+        pub nonfinal_vid: Option<i64>,
+        pub rows: Option<i64>,
+
+        pub next_vid: Option<i64>,
+        pub batch_size: Option<i64>,
+
+        pub started_at: Option<DateTime<Utc>>,
+        pub finished_at: Option<DateTime<Utc>>,
+    }
+
+    /// A helper to persist pruning progress in the database
+    pub(super) struct Tracker {
+        layout: Arc<Layout>,
+        run: i32,
+    }
+
+    impl Tracker {
+        pub(super) async fn new(
+            conn: &mut AsyncPgConnection,
+            layout: Arc<Layout>,
+        ) -> StoreResult<Self> {
+            use prune_state as ps;
+            let run = ps::table
+                .filter(ps::id.eq(layout.site.id))
+                .order(ps::run.desc())
+                .select(ps::run)
+                .get_result::<i32>(conn)
+                .await
+                .optional()
+                .map_err(StoreError::from)?
+                .unwrap_or(0)
+                + 1;
+
+            // Delete old prune state. Keep the initial run and the last
+            // `prune_keep_history` runs (including this one)
+            diesel::delete(ps::table)
+                .filter(ps::id.eq(layout.site.id))
+                .filter(ps::run.gt(1))
+                .filter(ps::run.lt(run - (ENV_VARS.store.prune_keep_history as i32 - 1)))
+                .execute(conn)
+                .await
+                .map_err(StoreError::from)?;
+
+            Ok(Tracker { layout, run })
+        }
+
+        pub(super) async fn start(
+            &self,
+            conn: &mut AsyncPgConnection,
+            req: &PruneRequest,
+            prunable_tables: &[(&Arc<Table>, PruningStrategy)],
+        ) -> StoreResult<()> {
+            use prune_state as ps;
+            use prune_table_state as pts;
+
+            let site_id = self.layout.site.id;
+            let run = self.run;
+            let first_block = req.first_block;
+            let final_block = req.final_block;
+            let latest_block = req.latest_block;
+            let history_blocks = req.history_blocks;
+            let table_entries: Vec<(String, &'static str)> = prunable_tables
+                .iter()
+                .map(|(table, strat)| {
+                    let strat = match strat {
+                        PruningStrategy::Rebuild => "r",
+                        PruningStrategy::Delete => "d",
+                    };
+                    (table.name.to_string(), strat)
+                })
+                .collect();
+
+            conn.transaction(async move |conn| {
+                insert_into(ps::table)
+                    .values((
+                        ps::id.eq(site_id),
+                        ps::run.eq(run),
+                        ps::first_block.eq(first_block),
+                        ps::final_block.eq(final_block),
+                        ps::latest_block.eq(latest_block),
+                        ps::history_blocks.eq(history_blocks),
+                        ps::started_at.eq(diesel::dsl::now),
+                    ))
+                    .execute(conn)
+                    .await?;
+
+                for (table_name, strat) in &table_entries {
+                    insert_into(pts::table)
+                        .values((
+                            pts::id.eq(site_id),
+                            pts::run.eq(run),
+                            pts::table_name.eq(table_name.as_str()),
+                            pts::strategy.eq(*strat),
+                            pts::phase.eq(Phase::Queued),
+                        ))
+                        .execute(conn)
+                        .await?;
+                }
+                Ok(())
+            })
+            .await
+        }
+
+        pub(crate) async fn start_table(
+            &self,
+            conn: &mut AsyncPgConnection,
+            table: &Table,
+        ) -> StoreResult<()> {
+            use prune_table_state as pts;
+
+            self.update_table_state(
+                conn,
+                table,
+                (
+                    pts::started_at.eq(diesel::dsl::now),
+                    pts::phase.eq(Phase::Started),
+                ),
+            )
+            .await?;
+
+            Ok(())
+        }
+
+        pub(crate) async fn start_copy_final(
+            &self,
+            conn: &mut AsyncPgConnection,
+            table: &Table,
+            range: VidRange,
+        ) -> StoreResult<()> {
+            use prune_table_state as pts;
+
+            let values = (
+                pts::phase.eq(Phase::CopyFinal),
+                pts::start_vid.eq(range.min),
+                pts::next_vid.eq(range.min),
+                pts::final_vid.eq(range.max),
+                pts::rows.eq(0),
+            );
+
+            self.update_table_state(conn, table, values).await
+        }
+
+        pub(crate) async fn start_copy_nonfinal(
+            &self,
+            conn: &mut AsyncPgConnection,
+            table: &Table,
+            range: VidRange,
+        ) -> StoreResult<()> {
+            use prune_table_state as pts;
+
+            let values = (
+                pts::phase.eq(Phase::CopyNonfinal),
+                pts::start_vid.eq(range.min),
+                pts::next_vid.eq(range.min),
+                pts::nonfinal_vid.eq(range.max),
+            );
+            self.update_table_state(conn, table, values).await
+        }
+
+        pub(crate) async fn finish_batch(
+            &self,
+            conn: &mut AsyncPgConnection,
+            src: &Table,
+            rows: i64,
+            batcher: &VidBatcher,
+        ) -> StoreResult<()> {
+            use prune_table_state as pts;
+
+            let values = (
+                pts::next_vid.eq(batcher.next_vid()),
+                pts::batch_size.eq(batcher.batch_size() as i64),
+                pts::rows.eq(pts::rows + rows),
+            );
+
+            self.update_table_state(conn, src, values).await
+        }
+
+        pub(crate) async fn finish_table(
+            &self,
+            conn: &mut AsyncPgConnection,
+            table: &Table,
+        ) -> StoreResult<()> {
+            use prune_table_state as pts;
+
+            let values = (
+                pts::finished_at.eq(diesel::dsl::now),
+                pts::phase.eq(Phase::Done),
+            );
+
+            self.update_table_state(conn, table, values).await
+        }
+
+        pub(crate) async fn start_delete(
+            &self,
+            conn: &mut AsyncPgConnection,
+            table: &Table,
+            range: VidRange,
+            batcher: &VidBatcher,
+        ) -> StoreResult<()> {
+            use prune_table_state as pts;
+
+            let values = (
+                pts::phase.eq(Phase::Delete),
+                pts::start_vid.eq(range.min),
+                pts::final_vid.eq(range.max),
+                pts::nonfinal_vid.eq(range.max),
+                pts::rows.eq(0),
+                pts::next_vid.eq(range.min),
+                pts::batch_size.eq(batcher.batch_size() as i64),
+            );
+
+            self.update_table_state(conn, table, values).await
+        }
+
+        async fn update_table_state<V, C>(
+            &self,
+            conn: &mut AsyncPgConnection,
+            table: &Table,
+            values: V,
+        ) -> StoreResult<()>
+        where
+            V: AsChangeset<Target = prune_table_state::table, Changeset = C>,
+            C: QueryFragment<diesel::pg::Pg> + Send,
+        {
+            use prune_table_state as pts;
+
+            update(pts::table)
+                .filter(pts::id.eq(self.layout.site.id))
+                .filter(pts::run.eq(self.run))
+                .filter(pts::table_name.eq(table.name.as_str()))
+                .set(values)
+                .execute(conn)
+                .await?;
+            Ok(())
+        }
+
+        pub(crate) async fn finish(&self, conn: &mut AsyncPgConnection) -> StoreResult<()> {
+            use prune_state as ps;
+
+            update(ps::table)
+                .filter(ps::id.eq(self.layout.site.id))
+                .filter(ps::run.eq(self.run))
+                .set((ps::finished_at.eq(diesel::dsl::now),))
+                .execute(conn)
+                .await?;
+            Ok(())
+        }
+
+        pub(crate) async fn error(
+            &self,
+            conn: &mut AsyncPgConnection,
+            err: &str,
+        ) -> StoreResult<()> {
+            use prune_state as ps;
+
+            update(ps::table)
+                .filter(ps::id.eq(self.layout.site.id))
+                .filter(ps::run.eq(self.run))
+                .set((
+                    ps::finished_at.eq(diesel::dsl::now),
+                    ps::errored_at.eq(diesel::dsl::now),
+                    ps::error.eq(err),
+                ))
+                .execute(conn)
+                .await?;
+            Ok(())
+        }
+    }
+
+    /// A helper to read pruning progress from the database
+    pub struct Viewer {
+        pool: ConnectionPool,
+        layout: Arc<Layout>,
+    }
+
+    impl Viewer {
+        pub fn new(pool: ConnectionPool, layout: Arc<Layout>) -> Self {
+            Self { pool, layout }
+        }
+
+        pub async fn runs(&self) -> StoreResult<Vec<usize>> {
+            use prune_state as ps;
+
+            let mut conn = self.pool.get_permitted().await?;
+            let runs = ps::table
+                .filter(ps::id.eq(self.layout.site.id))
+                .select(ps::run)
+                .order(ps::run.asc())
+                .load::<i32>(&mut conn)
+                .await
+                .map_err(StoreError::from)?;
+            let runs = runs.into_iter().map(|run| run as usize).collect::<Vec<_>>();
+            Ok(runs)
+        }
+
+        pub async fn state(
+            &self,
+            run: usize,
+        ) -> StoreResult<Option<(PruneState, Vec<PruneTableState>)>> {
+            use prune_state as ps;
+            use prune_table_state as pts;
+
+            let mut conn = self.pool.get_permitted().await?;
+
+            let ptss = pts::table
+                .filter(pts::id.eq(self.layout.site.id))
+                .filter(pts::run.eq(run as i32))
+                .order(pts::table_name.asc())
+                .load::<PruneTableState>(&mut conn)
+                .await
+                .map_err(StoreError::from)?;
+
+            ps::table
+                .filter(ps::id.eq(self.layout.site.id))
+                .filter(ps::run.eq(run as i32))
+                .first::<PruneState>(&mut conn)
+                .await
+                .optional()
+                .map_err(StoreError::from)
+                .map(|state| state.map(|state| (state, ptss)))
+        }
+    }
+}
diff --git a/store/postgres/src/relational/query_tests.rs b/store/postgres/src/relational/query_tests.rs
index 5d47b4a1921..3b4582c5b5b 100644
--- a/store/postgres/src/relational/query_tests.rs
+++ b/store/postgres/src/relational/query_tests.rs
@@ -2,17 +2,21 @@ use std::{collections::BTreeSet, sync::Arc};
 
 use diesel::{debug_query, pg::Pg};
 use graph::{
-    prelude::{r, serde_json as json, DeploymentHash, EntityFilter},
+    components::store::write::RowGroup,
+    data_source::CausalityRegion,
+    entity,
+    prelude::{DeploymentHash, EntityFilter, r, serde_json as json},
     schema::InputSchema,
 };
 
 use crate::{
-    layout_for_tests::{make_dummy_site, Namespace},
+    block_range::BoundSide,
+    layout_for_tests::{Namespace, make_dummy_site},
     relational::{Catalog, ColumnType, Layout},
-    relational_queries::FromColumnValue,
+    relational_queries::{FindRangeQuery, FromColumnValue, InsertQuery},
 };
 
-use crate::relational_queries::QueryFilter;
+use crate::relational_queries::Filter;
 
 #[test]
 fn gql_value_from_bytes() {
@@ -49,8 +53,9 @@ fn filter_contains(filter: EntityFilter, sql: &str) {
     let layout = test_layout(SCHEMA);
     let table = layout
         .table_for_entity(&layout.input_schema.entity_type("Thing").unwrap())
-        .unwrap();
-    let filter = QueryFilter::new(&filter, table.as_ref(), &layout, Default::default()).unwrap();
+        .unwrap()
+        .dsl_table();
+    let filter = Filter::main(&layout, table, &filter, Default::default()).unwrap();
     let query = debug_query::<Pg, _>(&filter);
     assert!(
         query.to_string().contains(sql),
@@ -66,22 +71,191 @@ fn prefix() {
     let filter = EntityFilter::Equal("name".to_string(), "Bibi".into());
     filter_contains(
         filter,
-        r#"left("name", 256) = left($1, 256) -- binds: ["Bibi"]"#,
+        r#"left(c."name", 256) = left($1, 256) -- binds: ["Bibi"]"#,
     );
 
     let filter = EntityFilter::In("name".to_string(), vec!["Bibi".into(), "Julian".into()]);
     filter_contains(
         filter,
-        r#"left("name", 256) in ($1, $2) -- binds: ["Bibi", "Julian"]"#,
+        r#"left(c."name", 256) in ($1, $2) -- binds: ["Bibi", "Julian"]"#,
     );
 
     // Bytes prefixes
     let filter = EntityFilter::Equal("address".to_string(), "0xbeef".into());
     filter_contains(
         filter,
-        r#"substring("address", 1, 64) = substring($1, 1, 64)"#,
+        r#"substring(c."address", 1, 64) = substring($1, 1, 64)"#,
     );
 
     let filter = EntityFilter::In("address".to_string(), vec!["0xbeef".into()]);
-    filter_contains(filter, r#"substring("address", 1, 64) in ($1)"#);
+    filter_contains(filter, r#"substring(c."address", 1, 64) in ($1)"#);
+}
+
+#[test]
+fn find_range_query_id_type_casting() {
+    let string_schema = "
+    type StringEntity @entity {
+        id: String!,
+        name: String
+    }";
+
+    let bytes_schema = "
+    type BytesEntity @entity {
+        id: Bytes!,
+        address: Bytes
+    }";
+
+    let int8_schema = "
+    type Int8Entity @entity {
+        id: Int8!,
+        value: Int8
+    }";
+
+    let string_layout = test_layout(string_schema);
+    let bytes_layout = test_layout(bytes_schema);
+    let int8_layout = test_layout(int8_schema);
+
+    let string_table = string_layout
+        .table_for_entity(
+            &string_layout
+                .input_schema
+                .entity_type("StringEntity")
+                .unwrap(),
+        )
+        .unwrap();
+    let bytes_table = bytes_layout
+        .table_for_entity(
+            &bytes_layout
+                .input_schema
+                .entity_type("BytesEntity")
+                .unwrap(),
+        )
+        .unwrap();
+    let int8_table = int8_layout
+        .table_for_entity(&int8_layout.input_schema.entity_type("Int8Entity").unwrap())
+        .unwrap();
+
+    let causality_region = CausalityRegion::ONCHAIN;
+    let bound_side = BoundSide::Lower;
+    let block_range = 100..200;
+
+    test_id_type_casting(
+        string_table.as_ref(),
+        "id::bytea",
+        "String ID should be cast to bytea",
+    );
+    test_id_type_casting(bytes_table.as_ref(), "id", "Bytes ID should remain as id");
+    test_id_type_casting(
+        int8_table.as_ref(),
+        "id::text::bytea",
+        "Int8 ID should be cast to text then bytea",
+    );
+
+    let tables = vec![
+        string_table.as_ref(),
+        bytes_table.as_ref(),
+        int8_table.as_ref(),
+    ];
+    let query = FindRangeQuery::new(&tables, causality_region, bound_side, block_range);
+    let sql = debug_query::<Pg, _>(&query).to_string();
+
+    assert!(
+        sql.contains("id::bytea"),
+        "String entity ID casting should be present in UNION query"
+    );
+    assert!(
+        sql.contains("id as id"),
+        "Bytes entity ID should be present in UNION query"
+    );
+    assert!(
+        sql.contains("id::text::bytea"),
+        "Int8 entity ID casting should be present in UNION query"
+    );
+
+    assert!(
+        sql.contains("union all"),
+        "Multiple tables should generate UNION ALL queries"
+    );
+    assert!(
+        sql.contains("order by block_number, entity, id"),
+        "Query should end with proper ordering"
+    );
+}
+
+fn test_id_type_casting(table: &crate::relational::Table, expected_cast: &str, test_name: &str) {
+    let causality_region = CausalityRegion::ONCHAIN;
+    let bound_side = BoundSide::Lower;
+    let block_range = 100..200;
+
+    let tables = vec![table];
+    let query = FindRangeQuery::new(&tables, causality_region, bound_side, block_range);
+    let sql = debug_query::<Pg, _>(&query).to_string();
+
+    assert!(
+        sql.contains(expected_cast),
+        "{}: Expected '{}' in SQL, got: {}",
+        test_name,
+        expected_cast,
+        sql
+    );
+}
+
+fn insert_sql_for_schema(gql: &str, entity_type_name: &str) -> String {
+    use graph::components::store::write::EntityModification;
+
+    let layout = test_layout(gql);
+    let schema = &layout.input_schema;
+    let et = schema.entity_type(entity_type_name).unwrap();
+    let table = layout.table_for_entity(&et).unwrap();
+
+    let mut entity = entity! { schema => id: "test1" };
+    entity.set_vid(1).unwrap();
+    let key = et.key(graph::data::store::Id::String("test1".into()));
+    let emod = EntityModification::Insert {
+        key,
+        data: Arc::new(entity),
+        block: 1,
+        end: None,
+    };
+
+    let mut group = RowGroup::new(et);
+    group.push(emod, 1).unwrap();
+
+    let chunks: Vec<_> = group.write_chunks(100).collect();
+    let chunk = &chunks[0];
+    let query = InsertQuery::new(table.as_ref(), chunk).unwrap();
+    debug_query::<Pg, _>(&query).to_string()
+}
+
+#[test]
+fn skip_duplicates_insert_generates_on_conflict() {
+    let schema = "
+    type Thing @entity(immutable: true, skipDuplicates: true) {
+        id: String!
+    }";
+    let sql = insert_sql_for_schema(schema, "Thing");
+    assert!(
+        sql.contains("ON CONFLICT"),
+        "Expected ON CONFLICT in SQL for skip_duplicates immutable table, got: {}",
+        sql
+    );
+    assert!(
+        sql.contains("DO NOTHING"),
+        "Expected DO NOTHING in SQL for skip_duplicates immutable table, got: {}",
+        sql
+    );
+}
+
+#[test]
+fn default_immutable_insert_has_no_on_conflict_skip_duplicates() {
+    let schema = "
+    type Thing @entity(immutable: true) {
+        id: String!
+    }";
+    let sql = insert_sql_for_schema(schema, "Thing");
+    assert!(
+        !sql.contains("ON CONFLICT"),
+        "Default immutable table should NOT have ON CONFLICT, got: {}",
+        sql
+    );
 }
diff --git a/store/postgres/src/relational/restore.rs b/store/postgres/src/relational/restore.rs
new file mode 100644
index 00000000000..081e6eebc3b
--- /dev/null
+++ b/store/postgres/src/relational/restore.rs
@@ -0,0 +1,473 @@
+//! Restore a subgraph deployment from a dump directory.
+//!
+//! The dump directory must contain:
+//! - `metadata.json` — deployment metadata and per-table state
+//! - `schema.graphql` — raw GraphQL schema text
+//! - Per-entity Parquet files in subdirectories
+
+use std::collections::BTreeSet;
+use std::fs;
+use std::path::Path;
+use std::sync::Arc;
+
+use diesel::dsl::update;
+use diesel::prelude::{ExpressionMethods, QueryDsl};
+use diesel_async::{RunQueryDsl, SimpleAsyncConnection};
+use graph::blockchain::BlockHash;
+use graph::components::store::RestoreReporter;
+use graph::data::subgraph::schema::{DeploymentCreate, SubgraphManifestEntity};
+use graph::prelude::{BlockPtr as GraphBlockPtr, StoreError};
+use graph::schema::{EntityType, InputSchema};
+use graph::semver::Version;
+
+use crate::AsyncPgConnection;
+use crate::catalog;
+use crate::deployment::create_deployment;
+use crate::dynds::DataSourcesTable;
+use crate::parquet::convert::{
+    load_clamps, record_batch_to_data_source_rows, record_batch_to_restore_rows,
+};
+use crate::parquet::reader::read_batches;
+use crate::primary::Site;
+use crate::relational::dump::{Metadata, TableInfo};
+use crate::relational::{Layout, Table, VID_COLUMN};
+use crate::relational_queries::InsertQuery;
+use crate::vid_batcher::VidRange;
+
+const DATA_SOURCES_TABLE: &str = "data_sources$";
+
+/// Convert a dump `BlockPtr` (hex hash string) to a graph `BlockPtr`.
+fn to_graph_block_ptr(bp: &super::dump::BlockPtr) -> Result<GraphBlockPtr, StoreError> {
+    let hash = BlockHash::try_from(bp.hash.as_str())
+        .map_err(|e| StoreError::InternalError(format!("invalid block hash '{}': {e}", bp.hash)))?;
+    Ok(GraphBlockPtr {
+        number: bp.number,
+        hash,
+    })
+}
+
+/// Query the current max(vid) for a table. Returns -1 if the table is empty.
+async fn current_max_vid(
+    conn: &mut AsyncPgConnection,
+    qualified_name: &str,
+) -> Result<i64, StoreError> {
+    let query = format!(
+        "select coalesce(min(vid), 0)::int8 as min_vid, \
+                coalesce(max(vid), -1)::int8 as max_vid \
+           from {}",
+        qualified_name
+    );
+    let range: VidRange = diesel::sql_query(&query)
+        .get_result(conn)
+        .await
+        .map_err(StoreError::from)?;
+    Ok(range.max)
+}
+
+/// Import a single entity table from Parquet chunks.
+///
+/// Supports resumability: checks the current max(vid) in the DB table
+/// and skips already-imported rows.
+async fn import_entity_table(
+    conn: &mut AsyncPgConnection,
+    table: &Table,
+    table_info: &TableInfo,
+    dir: &Path,
+    reporter: &mut dyn RestoreReporter,
+) -> Result<usize, StoreError> {
+    let table_name = table.object.as_str();
+    let total_rows: usize = table_info.chunks.iter().map(|c| c.row_count).sum();
+
+    if table_info.chunks.is_empty() || table_info.max_vid < 0 {
+        reporter.start_table(table_name, 0);
+        reporter.finish_table(table_name, 0);
+        return Ok(0);
+    }
+
+    let max_vid_db = current_max_vid(conn, table.qualified_name.as_str()).await?;
+    if max_vid_db >= table_info.max_vid {
+        reporter.skip_table(table_name);
+        return Ok(0);
+    }
+
+    reporter.start_table(table_name, total_rows);
+
+    // Load clamps (if any) so we can patch block_range_end during import
+    let clamp_map = if !table_info.clamps.is_empty() {
+        load_clamps(dir, &table_info.clamps)?
+    } else {
+        std::collections::HashMap::new()
+    };
+
+    let chunk_size = InsertQuery::chunk_size(table);
+    let mut total_inserted = 0usize;
+
+    for chunk_info in &table_info.chunks {
+        // Skip chunks that are fully imported
+        if chunk_info.max_vid <= max_vid_db {
+            continue;
+        }
+
+        let chunk_path = dir.join(&chunk_info.file);
+        let batches = read_batches(&chunk_path)?;
+
+        for batch in batches {
+            let batch = batch?;
+            let mut rows = record_batch_to_restore_rows(&batch, table)?;
+
+            // Filter out already-imported rows (for boundary chunks on resume)
+            if max_vid_db >= 0 {
+                rows.retain(|row| row.vid > max_vid_db);
+            }
+
+            if rows.is_empty() {
+                continue;
+            }
+
+            // Apply clamps: update block_range_end for rows that were
+            // clamped after the chunk was originally written
+            if !clamp_map.is_empty() {
+                for row in &mut rows {
+                    if let Some(&end) = clamp_map.get(&row.vid) {
+                        row.block_range_end = Some(Some(end));
+                    }
+                }
+            }
+
+            // Split into InsertQuery-sized chunks and execute
+            for chunk in rows.chunks(chunk_size) {
+                InsertQuery::for_restore(table, chunk)?
+                    .execute(conn)
+                    .await?;
+                total_inserted += chunk.len();
+                reporter.batch_imported(table_name, chunk.len());
+            }
+        }
+    }
+
+    reporter.finish_table(table_name, total_inserted);
+    Ok(total_inserted)
+}
+
+/// Import the `data_sources$` table from Parquet chunks.
+async fn import_data_sources(
+    conn: &mut AsyncPgConnection,
+    ds_table: &DataSourcesTable,
+    table_info: &TableInfo,
+    dir: &Path,
+    reporter: &mut dyn RestoreReporter,
+) -> Result<usize, StoreError> {
+    let total_rows: usize = table_info.chunks.iter().map(|c| c.row_count).sum();
+
+    if table_info.chunks.is_empty() || table_info.max_vid < 0 {
+        reporter.start_data_sources(0);
+        reporter.finish_data_sources(0);
+        return Ok(0);
+    }
+
+    let qualified = ds_table.qualified_name();
+    let max_vid_db = current_max_vid(conn, qualified).await?;
+    if max_vid_db >= table_info.max_vid {
+        reporter.skip_table(DATA_SOURCES_TABLE);
+        return Ok(0);
+    }
+
+    reporter.start_data_sources(total_rows);
+
+    // Load clamps for data_sources$ if any
+    let clamp_map = if !table_info.clamps.is_empty() {
+        load_clamps(dir, &table_info.clamps)?
+    } else {
+        std::collections::HashMap::new()
+    };
+
+    let mut total_inserted = 0usize;
+
+    for chunk_info in &table_info.chunks {
+        if chunk_info.max_vid <= max_vid_db {
+            continue;
+        }
+
+        let chunk_path = dir.join(&chunk_info.file);
+        let batches = read_batches(&chunk_path)?;
+
+        for batch in batches {
+            let batch = batch?;
+            let mut rows = record_batch_to_data_source_rows(&batch)?;
+
+            if max_vid_db >= 0 {
+                rows.retain(|row| row.vid > max_vid_db);
+            }
+
+            // Apply clamps
+            if !clamp_map.is_empty() {
+                for row in &mut rows {
+                    if let Some(&end) = clamp_map.get(&row.vid) {
+                        row.block_range_end = Some(end);
+                    }
+                }
+            }
+
+            let inserted = ds_table.insert_rows(conn, &rows).await?;
+            total_inserted += inserted;
+            reporter.batch_imported(DATA_SOURCES_TABLE, inserted);
+        }
+    }
+
+    reporter.finish_data_sources(total_inserted);
+    Ok(total_inserted)
+}
+
+/// Restore a subgraph deployment's schema and metadata from a dump
+/// directory.
+///
+/// This creates the deployment metadata rows (`subgraphs.head`,
+/// `subgraphs.deployment`, `subgraphs.subgraph_manifest`), entity
+/// tables, and optionally the `data_sources$` table.
+///
+/// The caller is responsible for:
+/// - Reading `metadata.json` via `Metadata::from_file()`
+/// - Site allocation and conflict resolution (force-drop)
+/// - Obtaining the right shard connection
+///
+/// Entity data import and finalization are handled separately.
+pub async fn create_schema(
+    conn: &mut AsyncPgConnection,
+    site: Arc<Site>,
+    metadata: &Metadata,
+    dir: &Path,
+) -> Result<Layout, StoreError> {
+    // 1. Read schema.graphql
+    let schema_path = dir.join("schema.graphql");
+    let schema_text = fs::read_to_string(&schema_path).map_err(|e| {
+        StoreError::InternalError(format!("failed to read {}: {e}", schema_path.display()))
+    })?;
+
+    // 2. Read subgraph.yaml (optional)
+    let yaml_path = dir.join("subgraph.yaml");
+    let raw_yaml = fs::read_to_string(&yaml_path).ok();
+
+    // 3. Parse schema
+    let spec_version = Version::parse(&metadata.manifest.spec_version).map_err(|e| {
+        StoreError::InternalError(format!(
+            "invalid spec_version '{}': {e}",
+            metadata.manifest.spec_version
+        ))
+    })?;
+    let input_schema = InputSchema::parse(&spec_version, &schema_text, site.deployment.clone())?;
+
+    // 4. Resolve entities_with_causality_region from names
+    let entities_with_causality_region: BTreeSet<EntityType> = metadata
+        .manifest
+        .entities_with_causality_region
+        .iter()
+        .map(|name| input_schema.entity_type(name))
+        .collect::<Result<_, _>>()
+        .map_err(StoreError::from)?;
+
+    // 5. Build SubgraphManifestEntity for create_deployment
+    let manifest_entity = SubgraphManifestEntity {
+        spec_version: metadata.manifest.spec_version.clone(),
+        description: metadata.manifest.description.clone(),
+        repository: metadata.manifest.repository.clone(),
+        features: metadata.manifest.features.clone(),
+        schema: schema_text,
+        raw_yaml,
+        entities_with_causality_region: entities_with_causality_region.iter().cloned().collect(),
+        history_blocks: metadata.manifest.history_blocks,
+    };
+
+    let start_block = metadata
+        .start_block
+        .as_ref()
+        .map(to_graph_block_ptr)
+        .transpose()?;
+    let graft_block = metadata
+        .graft_block
+        .as_ref()
+        .map(to_graph_block_ptr)
+        .transpose()?;
+
+    let create = DeploymentCreate {
+        manifest: manifest_entity,
+        start_block,
+        graft_base: metadata.graft_base.clone(),
+        graft_block,
+        debug_fork: metadata.debug_fork.clone(),
+        history_blocks_override: None,
+    };
+
+    // 6. Create deployment metadata rows
+    create_deployment(conn, &site, create, false, false).await?;
+
+    // 7. Create database schema and entity tables
+    let query = format!("create schema {}", &site.namespace);
+    conn.batch_execute(&query).await?;
+
+    let layout = Layout::create_relational_schema(
+        conn,
+        site.clone(),
+        &input_schema,
+        entities_with_causality_region,
+    )
+    .await?;
+
+    // 8. Create data_sources$ table if present in dump
+    if metadata.tables.contains_key(DATA_SOURCES_TABLE) {
+        let ds_table = DataSourcesTable::new(site.namespace.clone());
+        let ddl = ds_table.as_ddl();
+        conn.batch_execute(&ddl).await?;
+    }
+
+    Ok(layout)
+}
+
+/// Import entity data and data_sources$ from Parquet files into the
+/// database tables created by `create_schema`.
+///
+/// This is resumable: if interrupted, it can be called again and will
+/// skip already-imported rows by checking the current max(vid) in each
+/// table.
+pub async fn import_data(
+    conn: &mut AsyncPgConnection,
+    layout: &Layout,
+    metadata: &Metadata,
+    dir: &Path,
+    reporter: &mut dyn RestoreReporter,
+) -> Result<(), StoreError> {
+    // Import entity tables (sorted by name for determinism)
+    let mut table_names: Vec<_> = metadata
+        .tables
+        .keys()
+        .filter(|name| name.as_str() != DATA_SOURCES_TABLE)
+        .collect();
+    table_names.sort();
+
+    let table_count = table_names.len();
+    reporter.start(metadata.deployment.as_str(), table_count);
+
+    for table_name in table_names {
+        let table_info = &metadata.tables[table_name];
+        let table = layout
+            .tables
+            .values()
+            .find(|t| t.object.as_str() == table_name)
+            .ok_or_else(|| {
+                StoreError::InternalError(format!(
+                    "table '{}' from dump not found in layout",
+                    table_name,
+                ))
+            })?;
+        import_entity_table(conn, table, table_info, dir, reporter).await?;
+    }
+
+    // Import data_sources$ if present
+    if let Some(ds_info) = metadata.tables.get(DATA_SOURCES_TABLE) {
+        let ds_table = DataSourcesTable::new(layout.site.namespace.clone());
+        import_data_sources(conn, &ds_table, ds_info, dir, reporter).await?;
+    }
+
+    Ok(())
+}
+
+/// Finalize a restored deployment by resetting vid sequences and setting
+/// the head block pointer.
+///
+/// This must be called after `import_data` has completed successfully.
+/// Setting the head block is the very last operation — it marks the
+/// deployment as "ready".
+pub async fn finalize(
+    conn: &mut AsyncPgConnection,
+    layout: &Layout,
+    metadata: &Metadata,
+    reporter: &mut dyn RestoreReporter,
+) -> Result<(), StoreError> {
+    reporter.start_finalize();
+
+    let nsp = layout.site.namespace.as_str();
+
+    // 1. Reset vid sequences for entity tables that use bigserial.
+    //    Tables where has_vid_seq() is true use plain bigint (no sequence).
+    let mut table_names: Vec<_> = metadata
+        .tables
+        .keys()
+        .filter(|name| name.as_str() != DATA_SOURCES_TABLE)
+        .collect();
+    table_names.sort();
+
+    for table_name in table_names {
+        let table_info = &metadata.tables[table_name];
+        if table_info.max_vid < 0 {
+            continue;
+        }
+
+        let table = layout
+            .tables
+            .values()
+            .find(|t| t.object.as_str() == table_name)
+            .ok_or_else(|| {
+                StoreError::InternalError(format!(
+                    "table '{}' from dump not found in layout",
+                    table_name,
+                ))
+            })?;
+
+        if table.object.has_vid_seq() {
+            continue;
+        }
+
+        let vid_seq = catalog::seq_name(&table.name, VID_COLUMN);
+        let query = format!(
+            "SELECT setval('\"{nsp}\".\"{vid_seq}\"', {})",
+            table_info.max_vid
+        );
+        conn.batch_execute(&query).await.map_err(|e| {
+            StoreError::InternalError(format!("reset vid seq for {table_name}: {e}"))
+        })?;
+    }
+
+    // 2. Reset data_sources$ vid sequence if present
+    if let Some(ds_info) = metadata.tables.get(DATA_SOURCES_TABLE)
+        && ds_info.max_vid >= 0
+    {
+        let qualified = format!("\"{nsp}\".\"{DATA_SOURCES_TABLE}\"");
+        let query = format!(
+            "SELECT setval(pg_get_serial_sequence('{qualified}', 'vid'), {})",
+            ds_info.max_vid
+        );
+        conn.batch_execute(&query)
+            .await
+            .map_err(|e| StoreError::InternalError(format!("reset data_sources$ vid seq: {e}")))?;
+    }
+
+    // 3. Update earliest_block_number (may differ from start_block after
+    //    pruning) and set the head block pointer. Setting the head block
+    //    is the very last step: it makes the deployment "ready".
+    {
+        use crate::deployment::deployment as d;
+        use crate::deployment::head as h;
+
+        update(d::table.filter(d::id.eq(layout.site.id)))
+            .set(d::earliest_block_number.eq(metadata.earliest_block_number))
+            .execute(conn)
+            .await
+            .map_err(StoreError::from)?;
+
+        if let Some(head) = &metadata.head_block {
+            let head_ptr = to_graph_block_ptr(head)?;
+            update(h::table.filter(h::id.eq(layout.site.id)))
+                .set((
+                    h::block_number.eq(head_ptr.number),
+                    h::block_hash.eq(head_ptr.hash_slice()),
+                    h::entity_count.eq(metadata.entity_count as i64),
+                ))
+                .execute(conn)
+                .await
+                .map_err(StoreError::from)?;
+        }
+    }
+
+    reporter.finish_finalize();
+
+    Ok(())
+}
diff --git a/store/postgres/src/relational/rollup.rs b/store/postgres/src/relational/rollup.rs
index b8f3588b8c5..2c1ae754e95 100644
--- a/store/postgres/src/relational/rollup.rs
+++ b/store/postgres/src/relational/rollup.rs
@@ -1,25 +1,155 @@
 //! Queries and helpers to do rollups for aggregations, i.e., the queries
-//! that aggregate source data into aggregations
-use std::fmt::{self, Write as _};
+//! that aggregate source data into aggregations.
+//!
+//! There are two different kinds of queries that we generate: one for
+//! aggregations that do not contain any cumulative aggregates, and one for
+//! those that do.
+//!
+//! When there are no cumulative aggregates, the query is relatively
+//! straightforward: we form a `group by` query that groups by timestamp
+//! rounded to the beginning of the interval and all the dimensions. We
+//! select the required source columns over the interval and aggregate over
+//! them. For the `id` of the aggregation, we use the max of the ids we
+//! aggregate over; the actual value doesn't matter much, we just need it to
+//! be unique. The query has the overall shape
+//!
+//! ```text
+//!   select id, timestamp, <dimensions>, <aggregates> from ( select max(id)
+//!     as id, date_trunc(interval, timestamp), <source_columns> from
+//!       <timeseries> where timestamp >= $start and timestamp < $end) data
+//!      group by timestamp, <dimensions>
+//! ```
+//!
+//! When there are cumulative aggregations, things get more complicated. We
+//! form the aggregations for the current interval as in the previous case,
+//! but also need to find the corresponding previous aggregated values for
+//! each group, taking into account that the previous value might not be in
+//! the previous bucket for groups that only receive updates sporadically.
+//! We find those previous values through a lateral join subquery that looks
+//! for the latest aggregate with a given group key. We only want previous
+//! values for cumulative aggregates, and therefore select `null` for the
+//! non-cumulative ones when forming the list of previous values. We then
+//! combine the two by aggregating over the combined set of rows. We need to
+//! be careful to do the combination in the correct order, expressed by the
+//! `seq` variable in the combined query. We also need to be carful to use
+//! the right aggregation function for combining aggregates; in particular,
+//! counts need to be combined with `sum` and not `count`. That query looks
+//! like
+//!
+//! ```text
+//!   with bucket as (<query from above>),
+//!        prev as (select bucket.id, bucket.timestamp, bucket.<dimensions>,
+//!                        <null for non-cumulative aggregates>,
+//!                        <values of cumulative aggregates>
+//!                   from bucket cross join lateral (
+//!                        select * from <aggregation> prev
+//!                         where prev.timestamp < $start
+//!                           and prev.<dimensions> = bucket.<dimensions>
+//!                         order by prev.timestamp desc limit 1) prev),
+//!       combined as (select id, timestamp, <dimensions>, <combined aggregates>
+//!                      from (select *, 1 as seq from prev
+//!                             union all
+//!                            select *, 2 as seq from bucket) u
+//!                    group by id, timestamp, <dimensions>)
+//!   select id, timestamp, <dimensions>, <aggregates> from combined
+//! ```
+//!
+//! see also: #rollup-query-indexing for how we make sure that the `prev`
+//! query is efficient
+use std::collections::HashSet;
+use std::fmt;
 use std::ops::Range;
 use std::sync::Arc;
 
-use diesel::{sql_query, PgConnection, RunQueryDsl as _};
+use diesel::sql_query;
+use diesel::sql_types::{Integer, Nullable, Timestamptz};
+use diesel_async::RunQueryDsl;
 
-use diesel::sql_types::{BigInt, Integer};
 use graph::blockchain::BlockTime;
 use graph::components::store::{BlockNumber, StoreError};
 use graph::data::store::IdType;
-use graph::schema::{Aggregate, AggregateFn, Aggregation, AggregationInterval};
+use graph::internal_error;
+use graph::schema::{
+    Aggregate, AggregateFn, Aggregation, AggregationInterval, ExprVisitor, VisitExpr,
+};
+use graph::sqlparser::ast as p;
+use graph::sqlparser::parser::ParserError;
+use itertools::Itertools;
 
+use crate::AsyncPgConnection;
 use crate::relational::Table;
 
 use super::{Column, SqlName};
 
+/// Rewrite `expr` by replacing field names with column names and return the
+/// rewritten SQL expression and the columns used in the expression
+fn rewrite<'a>(table: &'a Table, expr: &str) -> Result<(String, Vec<&'a str>), StoreError> {
+    struct Rewriter<'a> {
+        table: &'a Table,
+        // All columns used in the expression
+        columns: HashSet<&'a str>,
+        // The first error we encounter. Any error here is really an
+        // oversight in the schema validation; that should have caught all
+        // possible problems
+        error: Option<StoreError>,
+    }
+
+    impl<'a> ExprVisitor for Rewriter<'a> {
+        fn visit_ident(&mut self, ident: &mut p::Ident) -> Result<(), ()> {
+            match self.table.column_for_field(&ident.value) {
+                Ok(column) => {
+                    self.columns.insert(&column.name);
+                    ident.value = column.name.to_string();
+                    ident.quote_style = Some('"');
+                    Ok(())
+                }
+                Err(e) => {
+                    self.not_supported(e.to_string());
+                    Err(())
+                }
+            }
+        }
+
+        fn visit_func_name(&mut self, _func: &mut p::ObjectNamePart) -> Result<(), ()> {
+            Ok(())
+        }
+
+        fn not_supported(&mut self, msg: String) {
+            if self.error.is_none() {
+                self.error = Some(internal_error!(
+                    "Schema validation should have found expression errors: {}",
+                    msg
+                ));
+            }
+        }
+
+        fn parse_error(&mut self, e: ParserError) {
+            self.not_supported(e.to_string())
+        }
+    }
+
+    let mut visitor = Rewriter {
+        table,
+        columns: HashSet::new(),
+        error: None,
+    };
+    let expr = match VisitExpr::visit(expr, &mut visitor) {
+        Ok(expr) => expr,
+        Err(()) => return Err(visitor.error.unwrap()),
+    };
+    if let Some(e) = visitor.error {
+        return Err(e);
+    }
+    let mut columns = visitor.columns.into_iter().collect::<Vec<_>>();
+    columns.sort();
+    Ok((expr.to_string(), columns))
+}
+
 #[derive(Debug, Clone)]
 pub(crate) struct Agg<'a> {
     aggregate: &'a Aggregate,
-    src_column: Option<&'a Column>,
+    src_columns: Vec<&'a str>,
+    expr: String,
     agg_column: &'a Column,
 }
 
@@ -29,40 +159,91 @@ impl<'a> Agg<'a> {
         src_table: &'a Table,
         agg_table: &'a Table,
     ) -> Result<Self, StoreError> {
-        let src_column = aggregate
-            .arg
-            .as_ref()
-            .map(|arg| src_table.column_for_field(&arg.name))
-            .transpose()?;
+        let (expr, src_columns) = rewrite(src_table, &aggregate.arg)?;
         let agg_column = agg_table.column_for_field(&aggregate.name)?;
         Ok(Self {
             aggregate,
-            src_column,
+            src_columns,
+            expr,
             agg_column,
         })
     }
 
-    fn aggregate(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+    fn aggregate_over(&self, src: &str, time: &str, w: &mut dyn fmt::Write) -> fmt::Result {
         use AggregateFn::*;
 
         match self.aggregate.func {
-            Sum => write!(w, "sum(\"{}\")", self.src_column.unwrap().name)?,
-            Max => write!(w, "max(\"{}\")", self.src_column.unwrap().name)?,
-            Min => write!(w, "min(\"{}\")", self.src_column.unwrap().name)?,
-            First => write!(w, "first(\"{}\")", self.src_column.unwrap().name)?,
-            Last => write!(w, "last(\"{}\")", self.src_column.unwrap().name)?,
+            Sum => write!(w, "sum({})", src)?,
+            Max => write!(w, "max({})", src)?,
+            Min => write!(w, "min({})", src)?,
+            First => {
+                let sql_type = self.agg_column.column_type.sql_type();
+                write!(w, "arg_min_{}(({}, {time}))", sql_type, src)?
+            }
+            Last => {
+                let sql_type = self.agg_column.column_type.sql_type();
+                write!(w, "arg_max_{}(({}, {time}))", sql_type, src)?
+            }
             Count => write!(w, "count(*)")?,
         }
         write!(w, " as \"{}\"", self.agg_column.name)
     }
+
+    /// Generate a SQL fragment `func(expr) as agg_column` where
+    /// `func` is the aggregation function. The `time` parameter is the name
+    /// of the column with respect to which `first` and `last` should decide
+    /// which values are earlier or later
+    fn aggregate(&self, time: &str, w: &mut dyn fmt::Write) -> fmt::Result {
+        self.aggregate_over(&self.expr, time, w)
+    }
+
+    /// Generate a SQL fragment `func(src_column) as agg_column` where
+    /// `func` is a function that combines preaggregated values into a
+    /// combined aggregate. The `time` parameter has the same meaning as for
+    /// `aggregate` are earlier or later
+    fn combine(&self, time: &str, w: &mut dyn fmt::Write) -> fmt::Result {
+        use AggregateFn::*;
+
+        match self.aggregate.func {
+            Sum | Max | Min | First | Last => {
+                // For these, combining and aggregating is done by the same
+                // function
+                let name = format!("\"{}\"", self.agg_column.name);
+                return self.aggregate_over(&name, time, w);
+            }
+            Count => write!(w, "sum(\"{}\")", self.agg_column.name)?,
+        }
+        write!(w, " as \"{}\"", self.agg_column.name)
+    }
+
+    /// Generate a SQL fragment that computes that selects the previous
+    /// value from an aggregation when the aggregation is cumulative and
+    /// `null` when it is not
+    fn prev_agg(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        if self.aggregate.cumulative {
+            write!(w, "prev.\"{}\"", self.agg_column.name)
+        } else {
+            let sql_type = self.agg_column.column_type.sql_type();
+            write!(w, "null::{sql_type} as \"{}\"", self.agg_column.name)
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
 pub(crate) struct Rollup {
     pub(crate) interval: AggregationInterval,
-    #[allow(dead_code)]
-    agg_table: Arc<Table>,
+    pub(crate) agg_table: Arc<Table>,
     insert_sql: String,
+    /// A query that determines the last time a rollup was done. The query
+    /// finds the latest timestamp in the aggregation table and adds the
+    /// length of the aggregation interval to deduce the last rollup time
+    last_rollup_sql: String,
+
+    /// The SQL query that loads the current, partially filled bucket.
+    ///
+    /// Contains a `/*FILTERS*/` comment that can be replaced with additional filters like `and c.block$ <= $1`.
+    /// The filters are applied to the SQL query that loads the time series entities, not to the aggregated values.
+    pub(crate) select_current_sql: String,
 }
 
 impl Rollup {
@@ -81,137 +262,479 @@ impl Rollup {
             .iter()
             .map(|aggregate| Agg::new(aggregate, src_table, &agg_table))
             .collect::<Result<_, _>>()?;
-        let insert_sql = Self::insert_sql(
+        let sql = RollupSql::new(
             interval,
             &src_table.qualified_name,
             &agg_table,
             &dimensions,
             &aggregates,
-        )?;
+        );
+        let mut insert_sql = String::new();
+        sql.insert(&mut insert_sql)?;
+        let last_rollup_sql = sql.last_rollup();
+        let mut select_current_sql = String::new();
+        sql.select_current(&mut select_current_sql)?;
+
         Ok(Self {
             interval,
             agg_table,
             insert_sql,
+            last_rollup_sql,
+            select_current_sql,
         })
     }
 
-    /// Generate a query
+    pub(crate) async fn insert(
+        &self,
+        conn: &mut AsyncPgConnection,
+        bucket: &Range<BlockTime>,
+        block: BlockNumber,
+    ) -> Result<usize, diesel::result::Error> {
+        let query = sql_query(&self.insert_sql)
+            .bind::<Timestamptz, _>(bucket.start)
+            .bind::<Timestamptz, _>(bucket.end)
+            .bind::<Integer, _>(block);
+        query.execute(conn).await
+    }
+
+    pub(crate) async fn last_rollup(
+        rollups: &[Rollup],
+        conn: &mut AsyncPgConnection,
+    ) -> Result<Option<BlockTime>, StoreError> {
+        #[derive(QueryableByName)]
+        #[diesel(check_for_backend(diesel::pg::Pg))]
+        struct BlockTimeRes {
+            #[diesel(sql_type = Nullable<Timestamptz>)]
+            last_rollup: Option<BlockTime>,
+        }
+
+        if rollups.is_empty() {
+            return Ok(None);
+        }
+
+        let union_all = rollups
+            .iter()
+            .map(|rollup| &rollup.last_rollup_sql)
+            .join(" union all ");
+        let query = format!("select max(last_rollup) as last_rollup from ({union_all}) as a");
+        let last_rollup = sql_query(&query)
+            .get_result::<BlockTimeRes>(conn)
+            .await
+            .map(|res| res.last_rollup)?;
+        Ok(last_rollup)
+    }
+}
+
+struct RollupSql<'a> {
+    interval: AggregationInterval,
+    src_table: &'a SqlName,
+    agg_table: &'a Table,
+    dimensions: &'a [&'a Column],
+    aggregates: &'a [Agg<'a>],
+}
+
+impl<'a> RollupSql<'a> {
+    fn new(
+        interval: AggregationInterval,
+        src_table: &'a SqlName,
+        agg_table: &'a Table,
+        dimensions: &'a [&Column],
+        aggregates: &'a [Agg],
+    ) -> Self {
+        Self {
+            interval,
+            src_table,
+            agg_table,
+            dimensions,
+            aggregates,
+        }
+    }
+
+    fn has_cumulative_aggregates(&self) -> bool {
+        self.aggregates.iter().any(|agg| agg.aggregate.cumulative)
+    }
+
+    /// Generate a query to roll up the source timeseries into an
+    /// aggregation over one time window
     ///
-    /// insert into <aggregation>(id, timestamp, block$, <dimensions>,
-    /// <aggregates>) select id, $ts, $block, <dimensions>, <aggregates> from
-    /// (select max(id) as id, <dimensions>, <agggregates> from (select id, <dimensions>,
-    ///         <source cols> from <source> where timestamp >= $ts and
-    ///                 timestamp < $ts + $interval order by timestamp) data
-    ///                group by <dimensions>) agg;
+    /// select id, $ts, $block, <dimensions>, <aggregates>
+    ///   from (select
+    ///           max(id) as id,
+    ///           <dimensions>,
+    ///           <agggregates> from (
+    ///           select id, rounded_timestamp, <dimensions>, <source cols>
+    ///             from <source>
+    ///            where timestamp >= $start
+    ///              and timestamp < $end
+    ///             order by timestamp) data
+    ///  group by <dimensions>) agg;
     ///
-    /// The 'order by' is only necessary once we support first/last as
-    /// aggregates following this:
-    /// https://wiki.postgresql.org/wiki/First/last_(aggregate)
     ///
     /// Bind variables:
     ///   $1: beginning timestamp (inclusive)
     ///   $2: end timestamp (exclusive)
     ///   $3: block number
-    fn insert_sql(
-        interval: AggregationInterval,
-        src_table: &SqlName,
-        agg_table: &Table,
-        dimensions: &[&Column],
-        aggregates: &[Agg],
-    ) -> Result<String, fmt::Error> {
-        fn comma_sep<T, F>(
-            list: impl IntoIterator<Item = T>,
-            mut first: bool,
-            w: &mut dyn fmt::Write,
-            out: F,
-        ) -> fmt::Result
-        where
-            F: Fn(&mut dyn fmt::Write, T) -> fmt::Result,
-        {
-            for elem in list {
-                if !first {
-                    write!(w, ", ")?;
-                }
-                first = false;
-                out(w, elem)?;
-            }
-            Ok(())
+    fn select_bucket(&self, with_block: bool, w: &mut dyn fmt::Write) -> fmt::Result {
+        write!(
+            w,
+            "select {max_id} as id, timestamp",
+            max_id = self.max_id(),
+        )?;
+        if with_block {
+            write!(w, ", $3")?;
         }
+        write_dims(self.dimensions, w, true)?;
+        comma_sep(self.aggregates, w, true, |w, agg| agg.aggregate("id", w))?;
+        let secs = self.interval.as_duration().as_secs();
+        write!(
+            w,
+            " from (select id, date_bin('{secs}s', timestamp, 'epoch'::timestamptz) as timestamp"
+        )?;
+        write_dims(self.dimensions, w, true)?;
+        let agg_srcs: Vec<&str> = {
+            let mut agg_srcs: Vec<_> = self
+                .aggregates
+                .iter()
+                .flat_map(|agg| &agg.src_columns)
+                .copied()
+                .filter(|&col| col != "id" && col != "timestamp")
+                .collect();
+            agg_srcs.sort();
+            agg_srcs.dedup();
+            agg_srcs
+        };
+        comma_sep(agg_srcs, w, true, |w, col: &str| write!(w, "\"{}\"", col))?;
+        write!(
+            w,
+            " from {src_table} where {src_table}.timestamp >= $1 and {src_table}.timestamp < $2",
+            src_table = self.src_table
+        )?;
+        write!(
+            w,
+            " order by {src_table}.timestamp) data group by timestamp",
+            src_table = self.src_table
+        )?;
+        write_dims(self.dimensions, w, true)
+    }
+
+    fn select(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        self.select_bucket(true, w)
+    }
 
-        fn write_dims(dimensions: &[&Column], w: &mut dyn fmt::Write) -> fmt::Result {
-            comma_sep(dimensions, true, w, |w, col| write!(w, "\"{}\"", col.name))
+    /// Generate the insert into statement
+    ///
+    /// insert into <aggregation>(id, timestamp, <dimensions>,
+    /// <aggregates>, block$)
+    fn insert_into(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        write!(
+            w,
+            "insert into {}(id, timestamp, block$",
+            self.agg_table.qualified_name
+        )?;
+        write_dims(self.dimensions, w, true)?;
+        comma_sep(self.aggregates, w, true, |w, agg| {
+            write!(w, "\"{}\"", agg.agg_column.name)
+        })?;
+        write!(w, ") ")
+    }
+
+    /// Generate a query
+    ///
+    /// insert into <aggregation>(id, timestamp, block$, <dimensions>,
+    /// <aggregates>) <select>;
+    ///
+    /// where `select` is the result of `Self::select`
+    fn insert_bucket(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        self.insert_into(w)?;
+        self.select(w)
+    }
+
+    /// Generate a query that selects the previous value of the aggregates
+    /// for any group keys that appear in `bucket`
+    ///
+    /// see also: #rollup-query-indexing Changes to this query might need to
+    /// reconsider the index that we build to make this query efficient
+    fn select_prev(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        write!(w, "select bucket.id, bucket.timestamp")?;
+        comma_sep(self.dimensions, w, true, |w, col| {
+            write!(w, "bucket.\"{}\"", col.name)
+        })?;
+        comma_sep(self.aggregates, w, true, |w, agg| agg.prev_agg(w))?;
+        write!(w, " from bucket cross join lateral (")?;
+        write!(w, "select * from {} prev", self.agg_table.qualified_name)?;
+        write!(w, " where prev.timestamp < $1")?;
+        for dim in self.dimensions {
+            write!(
+                w,
+                " and prev.\"{name}\" = bucket.\"{name}\"",
+                name = dim.name
+            )?;
         }
+        write!(w, " order by prev.timestamp desc limit 1) prev")
+    }
 
-        let mut s = String::new();
+    fn select_combined(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        write!(w, "select id, timestamp")?;
+        comma_sep(self.dimensions, w, true, |w, col| {
+            write!(w, "\"{}\"", col.name)
+        })?;
+        comma_sep(self.aggregates, w, true, |w, agg| agg.combine("seq", w))?;
         write!(
-            s,
-            "insert into {agg}(id, timestamp, block$, ",
-            agg = agg_table.qualified_name
+            w,
+            " from (select *, 1 as seq from prev union all select *, 2 as seq from bucket) u "
         )?;
-        write_dims(dimensions, &mut s)?;
-        comma_sep(aggregates, dimensions.is_empty(), &mut s, |w, agg| {
+        write!(w, " group by id, timestamp")?;
+        write_dims(self.dimensions, w, true)?;
+        Ok(())
+    }
+
+    /// Generate the common table expression for the select query when we
+    /// have cumulative aggregates
+    ///
+    /// with bucket as (<select_bucket>),
+    ///      prev as (<select_prev>),
+    ///      combined as (<select_combined>)
+    fn select_cte(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        write!(w, "with bucket as (")?;
+        self.select_bucket(false, w)?;
+        write!(w, "), prev as (")?;
+        self.select_prev(w)?;
+        write!(w, "), combined as (")?;
+        self.select_combined(w)?;
+        write!(w, ")")
+    }
+
+    /// Generate a query for inserting aggregates if some of them are
+    /// cumulative
+    ///
+    /// with bucket as (select <select>),
+    ///      prev as (select ..),
+    /// combined as (select .. )
+    /// insert into (..)
+    /// select ..;
+    fn insert_cumulative(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        self.select_cte(w)?;
+        write!(w, " ")?;
+        self.insert_into(w)?;
+        write!(w, "select id, timestamp, $3 as block$")?;
+        write_dims(self.dimensions, w, true)?;
+        comma_sep(self.aggregates, w, true, |w, agg| {
             write!(w, "\"{}\"", agg.agg_column.name)
         })?;
-        write!(s, ") ")?;
-        // We need the id of the aggregation to be something unique, and use
-        // the `max(id)` from the rows that we are aggregating over.
-        // Surprisingly, Postgres doesn't have a `max(bytea)`, so we do a
-        // funky roundtrip between bytea and string
-        let max_id = match agg_table.primary_key().column_type.id_type() {
+        write!(w, " from combined")
+    }
+
+    fn insert(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        if self.has_cumulative_aggregates() {
+            self.insert_cumulative(w)
+        } else {
+            self.insert_bucket(w)
+        }
+    }
+
+    /// Generate a query that selects the timestamp of the last rollup
+    fn last_rollup(&self) -> String {
+        // The timestamp column contains the timestamp of the start of the
+        // last bucket. The last rollup was therefore at least
+        // `self.interval` after that. We add 1 second to make sure we are
+        // well within the next bucket
+        let secs = self.interval.as_duration().as_secs() + 1;
+        format!(
+            "select max(timestamp) + '{} s'::interval as last_rollup from {}",
+            secs, self.agg_table.qualified_name
+        )
+    }
+
+    fn max_id(&self) -> &'static str {
+        match self.agg_table.primary_key().column_type.id_type() {
             Ok(IdType::Bytes) => "max(id::text)::bytea",
             Ok(IdType::String) | Ok(IdType::Int8) => "max(id)",
             Err(_) => unreachable!("we make sure that the primary key has an id_type"),
-        };
-        write!(s, "select {max_id} as id, timestamp, $3, ")?;
-        write_dims(dimensions, &mut s)?;
-        comma_sep(aggregates, dimensions.is_empty(), &mut s, |w, agg| {
-            agg.aggregate(w)
+        }
+    }
+
+    /// Generates the SQL query that loads the current, partially filled bucket.
+    ///
+    /// The generated SQL query contains a `/*FILTERS*/` comment that can be replaced
+    /// with additional filters like `and c.block$ <= $1`. The filters are applied to
+    /// the SQL query that loads the time series entities, not to the aggregated values.
+    fn select_current(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        if self.has_cumulative_aggregates() {
+            self.select_current_bucket_cumulative(w)?;
+        } else {
+            self.select_current_bucket(w)?;
+        }
+        Ok(())
+    }
+
+    /// Generates the SQL query that loads the current, partially filled bucket when
+    /// the aggregation has cumulative aggregates.
+    ///
+    /// The generated query has the following structure:
+    ///
+    ///   with bucket as (
+    ///     {select current bucket query}
+    ///   ), prev as (
+    ///     select
+    ///         bucket.id,
+    ///         bucket.vid,
+    ///         bucket.block$
+    ///         bucket.timestamp,
+    ///         {dimensions},
+    ///         {prev aggregates}
+    ///     from bucket cross join lateral (
+    ///         select * from {agg table} where timestamp < {last rollup timestamp}
+    ///         order by timestamp desc limit 1
+    ///     )
+    ///   ), combined (
+    ///    {select * from bucket and prev}
+    ///    group by
+    ///        id,
+    ///        vid,
+    ///        block$,
+    ///        timestamp,
+    ///        {dimensions}
+    ///   )
+    ///   select
+    ///     id,
+    ///     vid,
+    ///     block$,
+    ///     timestamp,
+    ///     {dimensions},
+    ///     {aggregates}
+    ///   from combined;
+    fn select_current_bucket_cumulative(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        write!(w, "with bucket as (")?;
+        self.select_current_bucket(w)?;
+        write!(w, "), prev as (")?;
+        write!(
+            w,
+            "select bucket.id, bucket.vid, bucket.block$, bucket.timestamp"
+        )?;
+        comma_sep(self.dimensions, w, true, |w, col| {
+            write!(w, "bucket.\"{}\"", col.name)
+        })?;
+        comma_sep(self.aggregates, w, true, |w, agg| agg.prev_agg(w))?;
+        write!(w, " from bucket cross join lateral (")?;
+        write!(w, "select * from {} prev", self.agg_table.qualified_name)?;
+        write!(
+            w,
+            " where prev.timestamp < coalesce(({last_rollup}), '-infinity'::timestamptz)",
+            last_rollup = self.last_rollup()
+        )?;
+        for dim in self.dimensions {
+            write!(
+                w,
+                " and prev.\"{name}\" = bucket.\"{name}\"",
+                name = dim.name
+            )?;
+        }
+        write!(w, " order by prev.timestamp desc limit 1) prev")?;
+        write!(w, "), combined as (")?;
+        write!(w, "select id, vid, block$, timestamp")?;
+        comma_sep(self.dimensions, w, true, |w, col| {
+            write!(w, "\"{}\"", col.name)
         })?;
-        let secs = interval.as_duration().as_secs();
+        comma_sep(self.aggregates, w, true, |w, agg| agg.combine("seq", w))?;
         write!(
-            s,
-            " from (select id, timestamp/{secs}*{secs} as timestamp, "
+            w,
+            " from (select *, 1 as seq from prev union all select *, 2 as seq from bucket) u "
         )?;
-        write_dims(dimensions, &mut s)?;
+        write!(w, " group by id, vid, block$, timestamp")?;
+        write_dims(self.dimensions, w, true)?;
+        write!(w, ")")?;
+        write!(w, "select id, vid, block$, timestamp")?;
+        write_dims(self.dimensions, w, true)?;
+        comma_sep(self.aggregates, w, true, |w, agg| {
+            write!(w, "\"{}\"", agg.agg_column.name)
+        })?;
+        write!(w, " from combined as c")
+    }
 
-        // List of unique source column names
-        let agg_srcs = {
-            let mut agg_srcs: Vec<_> = aggregates
+    /// Generates the SQL query that loads the current, partially filled bucket when
+    /// the aggregation does not have cumulative aggregates.
+    ///
+    /// The generated query has the following structure:
+    ///
+    ///   select
+    ///     max(id) as id,
+    ///     max(vid) as vid,
+    ///     max(block$) as block$,
+    ///     max(timestamp) as timestamp,
+    ///     {dimensions},
+    ///     {aggregates}
+    ///   from
+    ///     ({select timeseries entities} where timestamp >= {last rollup timestamp} {/*FILTERS*/})
+    ///   group by
+    ///     {dimensions};
+    fn select_current_bucket(&self, w: &mut dyn fmt::Write) -> fmt::Result {
+        write!(
+            w,
+            "select {max_id} as id, max(vid) as vid, max(block$) as block$, max(timestamp) as timestamp",
+            max_id = self.max_id(),
+        )?;
+        write_dims(self.dimensions, w, true)?;
+        comma_sep(self.aggregates, w, true, |w, agg| agg.aggregate("id", w))?;
+        write!(
+            w,
+            " from (select id, vid, block$, date_bin('{secs}s', timestamp, 'epoch'::timestamptz) as timestamp",
+            secs = self.interval.as_duration().as_secs(),
+        )?;
+        write_dims(self.dimensions, w, true)?;
+        let agg_srcs: Vec<&str> = {
+            let mut agg_srcs: Vec<_> = self
+                .aggregates
                 .iter()
-                .filter_map(|agg| agg.src_column.map(|col| col.name.as_str()))
+                .flat_map(|agg| &agg.src_columns)
+                .copied()
+                .filter(|&col| col != "id" && col != "timestamp")
                 .collect();
             agg_srcs.sort();
             agg_srcs.dedup();
             agg_srcs
         };
-        comma_sep(agg_srcs, dimensions.is_empty(), &mut s, |w, col: &str| {
-            write!(w, "\"{}\"", col)
-        })?;
-
+        comma_sep(agg_srcs, w, true, |w, col: &str| write!(w, "\"{}\"", col))?;
         write!(
-            s,
-            " from {src_table} where timestamp >= $1 and timestamp < $2",
+            w,
+            " from {src_table} as c where c.timestamp >= coalesce(({last_rollup}), '-infinity'::timestamptz)",
+            src_table = self.src_table,
+            last_rollup = self.last_rollup(),
         )?;
-        write!(s, " order by timestamp) data group by timestamp")?;
-        if !dimensions.is_empty() {
-            write!(s, ", ")?;
-            write_dims(dimensions, &mut s)?;
+        write!(w, " /*FILTERS*/) c")?;
+        if !self.dimensions.is_empty() {
+            write!(w, " group by ")?;
+            write_dims(self.dimensions, w, false)?;
         }
-        Ok(s)
+        Ok(())
     }
+}
 
-    pub(crate) fn insert(
-        &self,
-        conn: &PgConnection,
-        bucket: &Range<BlockTime>,
-        block: BlockNumber,
-    ) -> Result<usize, diesel::result::Error> {
-        let query = sql_query(&self.insert_sql)
-            .bind::<BigInt, _>(bucket.start.as_secs_since_epoch())
-            .bind::<BigInt, _>(bucket.end.as_secs_since_epoch())
-            .bind::<Integer, _>(block);
-        query.execute(conn)
+/// Write the elements in `list` separated by commas into `w`. The list
+/// elements are written by calling `out` with each of them.
+fn comma_sep<T, F>(
+    list: impl IntoIterator<Item = T>,
+    w: &mut dyn fmt::Write,
+    comma_prefix: bool,
+    out: F,
+) -> fmt::Result
+where
+    F: Fn(&mut dyn fmt::Write, T) -> fmt::Result,
+{
+    for (i, elem) in list.into_iter().enumerate() {
+        if comma_prefix || i != 0 {
+            write!(w, ", ")?;
+        }
+        out(w, elem)?;
     }
+    Ok(())
+}
+
+/// Write the names of the columns in `dimensions` into `w` as a
+/// comma-separated list of quoted column names.
+fn write_dims(dimensions: &[&Column], w: &mut dyn fmt::Write, comma_prefix: bool) -> fmt::Result {
+    comma_sep(dimensions, w, comma_prefix, |w, col| {
+        write!(w, "\"{}\"", col.name)
+    })
 }
 
 #[cfg(test)]
@@ -222,8 +745,8 @@ mod tests {
     use itertools::Itertools as _;
 
     use crate::{
-        layout_for_tests::{make_dummy_site, Namespace},
-        relational::{rollup::Rollup, Catalog, Layout},
+        layout_for_tests::{Namespace, make_dummy_site},
+        relational::{Catalog, Layout, rollup::Rollup},
     };
 
     // Check that the two strings are the same after replacing runs of
@@ -249,15 +772,15 @@ mod tests {
         const SCHEMA: &str = r#"
     type Data @entity(timeseries: true) {
         id: Int8!
-        timestamp: Int8!
+        timestamp: Timestamp!
         token: Bytes!
         price: BigDecimal!
-        amount: BigDecimal!
+        amount: Int!
       }
 
       type Stats @aggregation(intervals: ["day", "hour"], source: "Data") {
         id: Int8!
-        timestamp: Int8!
+        timestamp: Timestamp!
         token: Bytes!
         sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
         max: BigDecimal! @aggregate(fn: "max", arg: "amount")
@@ -265,34 +788,194 @@ mod tests {
 
       type TotalStats @aggregation(intervals: ["day"], source: "Data") {
         id: Int8!
-        timestamp: Int8!
+        timestamp: Timestamp!
         max: BigDecimal! @aggregate(fn: "max", arg: "price")
+        max_value: BigDecimal! @aggregate(fn: "max", arg: "price * amount")
+      }
+
+      type OpenClose @aggregation(intervals: ["day"], source: "Data") {
+        id: Int8!
+        timestamp: Timestamp!
+        open: BigDecimal! @aggregate(fn: "first", arg: "price")
+        close: BigDecimal! @aggregate(fn: "last", arg: "price")
+        first_amt: Int! @aggregate(fn: "first", arg: "amount")
+      }
+
+      type Lifetime @aggregation(intervals: ["day"], source: "Data") {
+        id: Int8!
+        timestamp: Timestamp!
+        count: Int8! @aggregate(fn: "count")
+        sum: BigDecimal! @aggregate(fn: "sum", arg: "amount")
+        total_count: Int8! @aggregate(fn: "count", cumulative: true)
+        total_sum: BigDecimal! @aggregate(fn: "sum", arg: "amount", cumulative: true)
+      }
+
+      type CountOnly @aggregation(intervals: ["day"], source: "Data") {
+        id: Int8!
+        timestamp: Timestamp!
+        count: Int8! @aggregate(fn: "count")
       }
       "#;
 
         const STATS_HOUR_SQL: &str = r#"\
         insert into "sgd007"."stats_hour"(id, timestamp, block$, "token", "sum", "max") \
         select max(id) as id, timestamp, $3, "token", sum("price") as "sum", max("amount") as "max" from (\
-            select id, timestamp/3600*3600 as timestamp, "token", "amount", "price" \
+            select id, date_bin('3600s', timestamp, 'epoch'::timestamptz) as timestamp, "token", "amount", "price" \
               from "sgd007"."data" \
-             where timestamp >= $1 and timestamp < $2 order by timestamp) data \
+             where "sgd007"."data".timestamp >= $1 and "sgd007"."data".timestamp < $2 \
+             order by "sgd007"."data".timestamp) data \
         group by timestamp, "token""#;
 
         const STATS_DAY_SQL: &str = r#"\
         insert into "sgd007"."stats_day"(id, timestamp, block$, "token", "sum", "max") \
         select max(id) as id, timestamp, $3, "token", sum("price") as "sum", max("amount") as "max" from (\
-            select id, timestamp/86400*86400 as timestamp, "token", "amount", "price" \
+            select id, date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp, "token", "amount", "price" \
               from "sgd007"."data" \
-             where timestamp >= $1 and timestamp < $2 order by timestamp) data \
+             where "sgd007"."data".timestamp >= $1 and "sgd007"."data".timestamp < $2 \
+             order by "sgd007"."data".timestamp) data \
         group by timestamp, "token""#;
 
         const TOTAL_SQL: &str = r#"\
-        insert into "sgd007"."total_stats_day"(id, timestamp, block$, "max") \
-        select max(id) as id, timestamp, $3, max("price") as "max" from (\
-            select id, timestamp/86400*86400 as timestamp, "price" from "sgd007"."data" \
-             where timestamp >= $1 and timestamp < $2 order by timestamp) data \
+        insert into "sgd007"."total_stats_day"(id, timestamp, block$, "max", "max_value") \
+        select max(id) as id, timestamp, $3, max("price") as "max", \
+               max("price" * "amount") as "max_value" from (\
+            select id, date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp, "amount", "price" from "sgd007"."data" \
+             where "sgd007"."data".timestamp >= $1 and "sgd007"."data".timestamp < $2 \
+             order by "sgd007"."data".timestamp) data \
+        group by timestamp"#;
+
+        const OPEN_CLOSE_SQL: &str = r#"\
+        insert into "sgd007"."open_close_day"(id, timestamp, block$, "open", "close", "first_amt")
+        select max(id) as id, timestamp, $3, \
+               arg_min_numeric(("price", id)) as "open", \
+               arg_max_numeric(("price", id)) as "close", \
+               arg_min_int4(("amount", id)) as "first_amt" \
+          from (select id, date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp, "amount", "price" \
+                  from "sgd007"."data"
+                 where "sgd007"."data".timestamp >= $1
+                   and "sgd007"."data".timestamp < $2
+                 order by "sgd007"."data".timestamp) data \
+         group by timestamp"#;
+
+        const LIFETIME_SQL: &str = r#"\
+        with bucket as (
+            select max(id) as id, timestamp, count(*) as "count",
+                   sum("amount") as "sum", count(*) as "total_count",
+                   sum("amount") as "total_sum"
+              from (select id, date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp, "amount"
+                      from "sgd007"."data"
+                     where "sgd007"."data".timestamp >= $1
+                       and "sgd007"."data".timestamp < $2
+                     order by "sgd007"."data".timestamp) data
+              group by timestamp),
+             prev as (select bucket.id, bucket.timestamp,
+                             null::int8 as "count", null::numeric as "sum",
+                             prev."total_count", prev."total_sum"
+                        from bucket cross join lateral (
+                             select * from "sgd007"."lifetime_day" prev
+                              where prev.timestamp < $1
+                              order by prev.timestamp desc limit 1) prev),
+             combined as (select id, timestamp,
+                                 sum("count") as "count", sum("sum") as "sum",
+                                 sum("total_count") as "total_count",
+                                 sum("total_sum") as "total_sum" from (
+                            select *, 1 as seq from prev
+                            union all
+                            select *, 2 as seq from bucket) u
+                          group by id, timestamp)
+        insert into "sgd007"."lifetime_day"(id, timestamp, block$, "count", "sum", "total_count", "total_sum")
+        select id, timestamp, $3 as block$, "count", "sum", "total_count", "total_sum" from combined
+        "#;
+
+        const COUNT_ONLY_SQL: &str = r#"\
+        insert into "sgd007"."count_only_day"(id, timestamp, block$, "count") \
+        select max(id) as id, timestamp, $3, count(*) as "count" \
+          from (select id, date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp from "sgd007"."data" \
+             where "sgd007"."data".timestamp >= $1 and "sgd007"."data".timestamp < $2 \
+             order by "sgd007"."data".timestamp) data \
         group by timestamp"#;
 
+        const STATS_HOUR_CURRENT_SQL: &str = r#"\
+        select max(id) as id, max(vid) as vid, max(block$) as block$, max(timestamp) as timestamp, \
+               "token", sum("price") as "sum", max("amount") as "max" \
+          from (select id, vid, block$, date_bin('3600s', timestamp, 'epoch'::timestamptz) as timestamp, \
+                       "token", "amount", "price" \
+                  from "sgd007"."data" as c \
+                 where c.timestamp >= coalesce((select max(timestamp) + '3601 s'::interval as last_rollup \
+                       from "sgd007"."stats_hour"), '-infinity'::timestamptz) /*FILTERS*/) c \
+         group by "token""#;
+
+        const STATS_DAY_CURRENT_SQL: &str = r#"\
+        select max(id) as id, max(vid) as vid, max(block$) as block$, max(timestamp) as timestamp, \
+               "token", sum("price") as "sum", max("amount") as "max" \
+          from (select id, vid, block$, date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp, \
+                       "token", "amount", "price" \
+                  from "sgd007"."data" as c \
+                 where c.timestamp >= coalesce((select max(timestamp) + '86401 s'::interval as last_rollup \
+                       from "sgd007"."stats_day"), '-infinity'::timestamptz) /*FILTERS*/) c \
+         group by "token""#;
+
+        const TOTAL_CURRENT_SQL: &str = r#"\
+        select max(id) as id, max(vid) as vid, max(block$) as block$, max(timestamp) as timestamp, \
+               max("price") as "max", max("price" * "amount") as "max_value" \
+          from (select id, vid, block$, date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp, \
+                       "amount", "price" \
+                  from "sgd007"."data" as c \
+                 where c.timestamp >= coalesce((select max(timestamp) + '86401 s'::interval as last_rollup \
+                       from "sgd007"."total_stats_day"), '-infinity'::timestamptz) /*FILTERS*/) c"#;
+
+        const OPEN_CLOSE_CURRENT_SQL: &str = r#"\
+        select max(id) as id, max(vid) as vid, max(block$) as block$, max(timestamp) as timestamp, \
+               arg_min_numeric(("price", id)) as "open", \
+               arg_max_numeric(("price", id)) as "close", \
+               arg_min_int4(("amount", id)) as "first_amt" \
+          from (select id, vid, block$, date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp, \
+                       "amount", "price" \
+                  from "sgd007"."data" as c \
+                 where c.timestamp >= coalesce((select max(timestamp) + '86401 s'::interval as last_rollup \
+                       from "sgd007"."open_close_day"), '-infinity'::timestamptz) /*FILTERS*/) c"#;
+
+        const LIFETIME_CURRENT_SQL: &str = r#"
+        with bucket as (select max(id) as id, max(vid) as vid, max(block$) as block$,
+               max(timestamp) as timestamp,
+               count(*) as "count", sum("amount") as "sum",
+               count(*) as "total_count", sum("amount") as "total_sum"
+          from (select id, vid, block$,
+                       date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp,
+                       "amount"
+                  from "sgd007"."data" as c
+                 where c.timestamp >= coalesce((select max(timestamp) + '86401 s'::interval
+                       as last_rollup from "sgd007"."lifetime_day"),
+                       '-infinity'::timestamptz) /*FILTERS*/) c),
+             prev as (select bucket.id, bucket.vid, bucket.block$, bucket.timestamp,
+                             null::int8 as "count", null::numeric as "sum",
+                             prev."total_count", prev."total_sum"
+                        from bucket cross join lateral (
+                             select * from "sgd007"."lifetime_day" prev
+                              where prev.timestamp < coalesce((select max(timestamp) + '86401 s'::interval
+                                    as last_rollup from "sgd007"."lifetime_day"),
+                                    '-infinity'::timestamptz)
+                              order by prev.timestamp desc limit 1) prev),
+             combined as (select id, vid, block$, timestamp,
+                                 sum("count") as "count", sum("sum") as "sum",
+                                 sum("total_count") as "total_count",
+                                 sum("total_sum") as "total_sum"
+                            from (select *, 1 as seq from prev
+                                  union all
+                                  select *, 2 as seq from bucket) u
+                            group by id, vid, block$, timestamp)select id, vid, block$, timestamp,
+               "count", "sum", "total_count", "total_sum"
+          from combined as c
+        "#;
+
+        const COUNT_ONLY_CURRENT_SQL: &str = r#"\
+        select max(id) as id, max(vid) as vid, max(block$) as block$, max(timestamp) as timestamp, \
+               count(*) as "count" \
+          from (select id, vid, block$, date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp \
+                  from "sgd007"."data" as c \
+                 where c.timestamp >= coalesce((select max(timestamp) + '86401 s'::interval as last_rollup \
+                       from "sgd007"."count_only_day"), '-infinity'::timestamptz) /*FILTERS*/) c"#;
+
         #[track_caller]
         fn rollup_for<'a>(layout: &'a Layout, table_name: &str) -> &'a Rollup {
             layout
@@ -308,7 +991,7 @@ mod tests {
         let site = Arc::new(make_dummy_site(hash, nsp, "rollup".to_string()));
         let catalog = Catalog::for_tests(site.clone(), BTreeSet::new()).unwrap();
         let layout = Layout::new(site, &schema, catalog).unwrap();
-        assert_eq!(3, layout.rollups.len());
+        assert_eq!(6, layout.rollups.len());
 
         // Intervals are non-decreasing
         assert!(layout.rollups[0].interval <= layout.rollups[1].interval);
@@ -321,5 +1004,22 @@ mod tests {
         check_eqv(STATS_HOUR_SQL, &stats_hour.insert_sql);
         check_eqv(STATS_DAY_SQL, &stats_day.insert_sql);
         check_eqv(TOTAL_SQL, &stats_total.insert_sql);
+
+        let open_close = rollup_for(&layout, "open_close_day");
+        check_eqv(OPEN_CLOSE_SQL, &open_close.insert_sql);
+
+        let lifetime = rollup_for(&layout, "lifetime_day");
+        check_eqv(LIFETIME_SQL, &lifetime.insert_sql);
+
+        let count_only = rollup_for(&layout, "count_only_day");
+        check_eqv(COUNT_ONLY_SQL, &count_only.insert_sql);
+
+        // Generated select_current_sql is correct
+        check_eqv(STATS_HOUR_CURRENT_SQL, &stats_hour.select_current_sql);
+        check_eqv(STATS_DAY_CURRENT_SQL, &stats_day.select_current_sql);
+        check_eqv(TOTAL_CURRENT_SQL, &stats_total.select_current_sql);
+        check_eqv(OPEN_CLOSE_CURRENT_SQL, &open_close.select_current_sql);
+        check_eqv(LIFETIME_CURRENT_SQL, &lifetime.select_current_sql);
+        check_eqv(COUNT_ONLY_CURRENT_SQL, &count_only.select_current_sql);
     }
 }
diff --git a/store/postgres/src/relational/value.rs b/store/postgres/src/relational/value.rs
new file mode 100644
index 00000000000..1217afd6195
--- /dev/null
+++ b/store/postgres/src/relational/value.rs
@@ -0,0 +1,280 @@
+//! Helpers to use diesel dynamic schema to retrieve values from Postgres
+
+use std::num::NonZeroU32;
+use std::ops::Bound;
+
+use diesel::sql_types::{Array, BigInt, Binary, Bool, Integer, Numeric, Range, Text, Timestamptz};
+use diesel::{deserialize::FromSql, pg::Pg};
+use diesel_dynamic_schema::dynamic_value::{Any, DynamicRow};
+
+use graph::{
+    components::store::StoreError,
+    data::{
+        store::{
+            Entity, QueryObject,
+            scalar::{BigDecimal, Bytes, Timestamp},
+        },
+        value::{Object, Word},
+    },
+    prelude::r,
+    schema::InputSchema,
+};
+
+use super::ColumnType;
+use crate::relational::Column;
+
+/// Represent values of the database types we care about as a single value.
+/// The deserialization of these values is completely governed by the oid we
+/// get from Postgres; in a second step, these values need to be transformed
+/// into our internal values using the underlying `ColumnType`. Diesel's API
+/// doesn't let us do that in one go, so we do a first transformation into
+/// `OidValue` and then use `FromOidValue` to transform guided by the
+/// `ColumnType`
+#[derive(Debug)]
+pub enum OidValue {
+    String(String),
+    StringArray(Vec<String>),
+    Bytes(Bytes),
+    BytesArray(Vec<Bytes>),
+    Bool(bool),
+    BoolArray(Vec<bool>),
+    Int(i32),
+    Ints(Vec<i32>),
+    Int8(i64),
+    Int8Array(Vec<i64>),
+    BigDecimal(BigDecimal),
+    BigDecimalArray(Vec<BigDecimal>),
+    Timestamp(Timestamp),
+    TimestampArray(Vec<Timestamp>),
+    Int4Range(Bound<i32>, Bound<i32>),
+    Null,
+}
+
+impl FromSql<Any, Pg> for OidValue {
+    fn from_sql(value: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
+        const VARCHAR_OID: NonZeroU32 = NonZeroU32::new(1043).unwrap();
+        const VARCHAR_ARY_OID: NonZeroU32 = NonZeroU32::new(1015).unwrap();
+        const TEXT_OID: NonZeroU32 = NonZeroU32::new(25).unwrap();
+        const TEXT_ARY_OID: NonZeroU32 = NonZeroU32::new(1009).unwrap();
+        const BYTEA_OID: NonZeroU32 = NonZeroU32::new(17).unwrap();
+        const BYTEA_ARY_OID: NonZeroU32 = NonZeroU32::new(1001).unwrap();
+        const BOOL_OID: NonZeroU32 = NonZeroU32::new(16).unwrap();
+        const BOOL_ARY_OID: NonZeroU32 = NonZeroU32::new(1000).unwrap();
+        const INTEGER_OID: NonZeroU32 = NonZeroU32::new(23).unwrap();
+        const INTEGER_ARY_OID: NonZeroU32 = NonZeroU32::new(1007).unwrap();
+        const INT8_OID: NonZeroU32 = NonZeroU32::new(20).unwrap();
+        const INT8_ARY_OID: NonZeroU32 = NonZeroU32::new(1016).unwrap();
+        const NUMERIC_OID: NonZeroU32 = NonZeroU32::new(1700).unwrap();
+        const NUMERIC_ARY_OID: NonZeroU32 = NonZeroU32::new(1231).unwrap();
+        const TIMESTAMPTZ_OID: NonZeroU32 = NonZeroU32::new(1184).unwrap();
+        const TIMESTAMPTZ_ARY_OID: NonZeroU32 = NonZeroU32::new(1185).unwrap();
+        const INT4RANGE_OID: NonZeroU32 = NonZeroU32::new(3904).unwrap();
+
+        match value.get_oid() {
+            VARCHAR_OID | TEXT_OID => {
+                <String as FromSql<Text, Pg>>::from_sql(value).map(OidValue::String)
+            }
+            VARCHAR_ARY_OID | TEXT_ARY_OID => {
+                <Vec<String> as FromSql<Array<Text>, Pg>>::from_sql(value)
+                    .map(OidValue::StringArray)
+            }
+            BYTEA_OID => <Bytes as FromSql<Binary, Pg>>::from_sql(value).map(OidValue::Bytes),
+            BYTEA_ARY_OID => <Vec<Bytes> as FromSql<Array<Binary>, Pg>>::from_sql(value)
+                .map(OidValue::BytesArray),
+            BOOL_OID => <bool as FromSql<Bool, Pg>>::from_sql(value).map(OidValue::Bool),
+            BOOL_ARY_OID => {
+                <Vec<bool> as FromSql<Array<Bool>, Pg>>::from_sql(value).map(OidValue::BoolArray)
+            }
+            INTEGER_OID => <i32 as FromSql<Integer, Pg>>::from_sql(value).map(OidValue::Int),
+            INTEGER_ARY_OID => {
+                <Vec<i32> as FromSql<Array<Integer>, Pg>>::from_sql(value).map(OidValue::Ints)
+            }
+            INT8_OID => <i64 as FromSql<BigInt, Pg>>::from_sql(value).map(OidValue::Int8),
+            INT8_ARY_OID => {
+                <Vec<i64> as FromSql<Array<BigInt>, Pg>>::from_sql(value).map(OidValue::Int8Array)
+            }
+            NUMERIC_OID => {
+                <BigDecimal as FromSql<Numeric, Pg>>::from_sql(value).map(OidValue::BigDecimal)
+            }
+            NUMERIC_ARY_OID => <Vec<BigDecimal> as FromSql<Array<Numeric>, Pg>>::from_sql(value)
+                .map(OidValue::BigDecimalArray),
+            TIMESTAMPTZ_OID => {
+                <Timestamp as FromSql<Timestamptz, Pg>>::from_sql(value).map(OidValue::Timestamp)
+            }
+            TIMESTAMPTZ_ARY_OID => {
+                <Vec<Timestamp> as FromSql<Array<Timestamptz>, Pg>>::from_sql(value)
+                    .map(OidValue::TimestampArray)
+            }
+            INT4RANGE_OID => {
+                <(Bound<i32>, Bound<i32>) as FromSql<Range<Integer>, Pg>>::from_sql(value)
+                    .map(|(lo, hi)| OidValue::Int4Range(lo, hi))
+            }
+            e => Err(format!("Unknown type: {e}").into()),
+        }
+    }
+
+    fn from_nullable_sql(bytes: Option<diesel::pg::PgValue>) -> diesel::deserialize::Result<Self> {
+        match bytes {
+            Some(bytes) => Self::from_sql(bytes),
+            None => Ok(OidValue::Null),
+        }
+    }
+}
+
+pub trait FromOidValue: Sized {
+    fn from_oid_value(value: OidValue, column_type: &ColumnType) -> Result<Self, StoreError>;
+}
+
+impl FromOidValue for r::Value {
+    fn from_oid_value(value: OidValue, _: &ColumnType) -> Result<Self, StoreError> {
+        fn as_list<T, F>(values: Vec<T>, f: F) -> r::Value
+        where
+            F: Fn(T) -> r::Value,
+        {
+            r::Value::List(values.into_iter().map(f).collect())
+        }
+
+        use OidValue as O;
+        let value = match value {
+            O::String(s) => Self::String(s),
+            O::StringArray(s) => as_list(s, Self::String),
+            O::Bytes(b) => Self::String(b.to_string()),
+            O::BytesArray(b) => as_list(b, |b| Self::String(b.to_string())),
+            O::Bool(b) => Self::Boolean(b),
+            O::BoolArray(b) => as_list(b, Self::Boolean),
+            O::Int(i) => Self::Int(i as i64),
+            O::Ints(i) => as_list(i, |i| Self::Int(i as i64)),
+            O::Int8(i) => Self::String(i.to_string()),
+            O::Int8Array(i) => as_list(i, |i| Self::String(i.to_string())),
+            O::BigDecimal(b) => Self::String(b.to_string()),
+            O::BigDecimalArray(b) => as_list(b, |b| Self::String(b.to_string())),
+            O::Timestamp(t) => Self::Timestamp(t),
+            O::TimestampArray(t) => as_list(t, Self::Timestamp),
+            O::Int4Range(..) => {
+                return Err(StoreError::InternalError(
+                    "int4range can not be converted to r::Value".to_string(),
+                ));
+            }
+            O::Null => Self::Null,
+        };
+        Ok(value)
+    }
+}
+
+impl FromOidValue for graph::prelude::Value {
+    fn from_oid_value(value: OidValue, column_type: &ColumnType) -> Result<Self, StoreError> {
+        fn as_list<T, F>(values: Vec<T>, f: F) -> graph::prelude::Value
+        where
+            F: Fn(T) -> graph::prelude::Value,
+        {
+            graph::prelude::Value::List(values.into_iter().map(f).collect())
+        }
+
+        fn as_list_err<T, F>(values: Vec<T>, f: F) -> Result<graph::prelude::Value, StoreError>
+        where
+            F: Fn(T) -> Result<graph::prelude::Value, StoreError>,
+        {
+            values
+                .into_iter()
+                .map(f)
+                .collect::<Result<_, _>>()
+                .map(graph::prelude::Value::List)
+        }
+
+        use OidValue as O;
+        let value = match value {
+            O::String(s) => Self::String(s),
+            O::StringArray(s) => as_list(s, Self::String),
+            O::Bytes(b) => Self::Bytes(b),
+            O::BytesArray(b) => as_list(b, Self::Bytes),
+            O::Bool(b) => Self::Bool(b),
+            O::BoolArray(b) => as_list(b, Self::Bool),
+            O::Int(i) => Self::Int(i),
+            O::Ints(i) => as_list(i, Self::Int),
+            O::Int8(i) => Self::Int8(i),
+            O::Int8Array(i) => as_list(i, Self::Int8),
+            O::BigDecimal(b) => match column_type {
+                ColumnType::BigDecimal => Self::BigDecimal(b),
+                ColumnType::BigInt => Self::BigInt(b.to_bigint()?),
+                _ => unreachable!("only BigInt and BigDecimal are stored as numeric"),
+            },
+            O::BigDecimalArray(b) => match column_type {
+                ColumnType::BigDecimal => as_list(b, Self::BigDecimal),
+                ColumnType::BigInt => as_list_err(b, |b| {
+                    b.to_bigint().map(Self::BigInt).map_err(StoreError::from)
+                })?,
+                _ => unreachable!("only BigInt and BigDecimal are stored as numeric[]"),
+            },
+            O::Timestamp(t) => Self::Timestamp(t),
+            O::TimestampArray(t) => as_list(t, Self::Timestamp),
+            O::Int4Range(..) => {
+                return Err(StoreError::InternalError(
+                    "int4range can not be converted to Value".to_string(),
+                ));
+            }
+            O::Null => Self::Null,
+        };
+        Ok(value)
+    }
+}
+
+pub type OidRow = DynamicRow<OidValue>;
+
+pub trait FromOidRow: Sized {
+    // Should the columns for `__typename` and `g$parent_id` be selected
+    const WITH_INTERNAL_KEYS: bool;
+    // Should the system columns for block/block_range and vid be selected
+    const WITH_SYSTEM_COLUMNS: bool = false;
+
+    fn from_oid_row(
+        row: DynamicRow<OidValue>,
+        schema: &InputSchema,
+        columns: &[&Column],
+    ) -> Result<Self, StoreError>;
+}
+
+impl FromOidRow for Entity {
+    const WITH_INTERNAL_KEYS: bool = false;
+
+    fn from_oid_row(
+        row: DynamicRow<OidValue>,
+        schema: &InputSchema,
+        columns: &[&Column],
+    ) -> Result<Self, StoreError> {
+        let x = row
+            .into_iter()
+            .zip(columns)
+            .filter(|(value, _)| !matches!(value, OidValue::Null))
+            .map(|(value, column)| {
+                graph::prelude::Value::from_oid_value(value, &column.column_type)
+                    .map(|value| (column.field.clone(), value))
+            });
+        schema.try_make_entity(x).map_err(StoreError::from)
+    }
+}
+
+impl FromOidRow for QueryObject {
+    const WITH_INTERNAL_KEYS: bool = true;
+
+    fn from_oid_row(
+        row: DynamicRow<OidValue>,
+        _schema: &InputSchema,
+        columns: &[&Column],
+    ) -> Result<Self, StoreError> {
+        let pairs = row
+            .into_iter()
+            .zip(columns)
+            .filter(|(value, _)| !matches!(value, OidValue::Null))
+            .map(|(value, column)| -> Result<_, StoreError> {
+                let name = &column.name;
+                let value = r::Value::from_oid_value(value, &column.column_type)?;
+                Ok((Word::from(name.clone()), value))
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        let entity = Object::from_iter(pairs);
+        Ok(QueryObject {
+            entity,
+            parent: None,
+        })
+    }
+}
diff --git a/store/postgres/src/relational_queries.rs b/store/postgres/src/relational_queries.rs
index c435d23c72f..d87b950adc1 100644
--- a/store/postgres/src/relational_queries.rs
+++ b/store/postgres/src/relational_queries.rs
@@ -1,63 +1,76 @@
-///! This module contains the gory details of using Diesel to query
-///! a database schema that is not known at compile time. The code in this
-///! module is mostly concerned with constructing SQL queries and some
-///! helpers for serializing and deserializing entities.
-///!
-///! Code in this module works very hard to minimize the number of allocations
-///! that it performs
-use diesel::pg::{Pg, PgConnection};
-use diesel::query_builder::{AstPass, QueryFragment, QueryId};
-use diesel::query_dsl::{LoadQuery, RunQueryDsl};
+//! This module contains the gory details of using Diesel to query
+//! a database schema that is not known at compile time. The code in this
+//! module is mostly concerned with constructing SQL queries and some
+//! helpers for serializing and deserializing entities.
+//!
+//! Code in this module works very hard to minimize the number of allocations
+//! that it performs
+use diesel::QuerySource as _;
+use diesel::pg::Pg;
+use diesel::query_builder::{AstPass, Query, QueryFragment, QueryId};
+use diesel::query_dsl::RunQueryDsl;
 use diesel::result::{Error as DieselError, QueryResult};
-use diesel::sql_types::{Array, BigInt, Binary, Bool, Int8, Integer, Jsonb, Range, Text};
-use diesel::Connection;
+use diesel::sql_types::Untyped;
+use diesel::sql_types::{Array, BigInt, Binary, Bool, Int8, Integer, Jsonb, Text, Timestamptz};
+use graph::components::store::write::{EntityWrite, RowGroup, WriteChunk};
+use graph::components::store::{Child as StoreChild, DerivedEntityQuery};
 
-use graph::components::store::write::WriteChunk;
-use graph::components::store::DerivedEntityQuery;
+use graph::data::graphql::IntoValue;
 use graph::data::store::{Id, IdType, NULL};
 use graph::data::store::{IdList, IdRef, QueryObject};
 use graph::data::value::{Object, Word};
 use graph::data_source::CausalityRegion;
 use graph::prelude::{
-    anyhow, r, serde_json, Attribute, BlockNumber, ChildMultiplicity, Entity, EntityCollection,
-    EntityFilter, EntityLink, EntityOrder, EntityOrderByChild, EntityOrderByChildInfo, EntityRange,
-    EntityWindow, ParentLink, QueryExecutionError, StoreError, Value, ENV_VARS,
+    BlockNumber, ChildMultiplicity, ENV_VARS, Entity, EntityCollection, EntityFilter, EntityLink,
+    EntityOrder, EntityOrderByChild, EntityOrderByChildInfo, EntityRange, EntityWindow, ParentLink,
+    QueryExecutionError, StoreError, Value, anyhow, r, serde_json,
+};
+use graph::schema::{EntityType, FulltextAlgorithm, FulltextConfig, InputSchema};
+use graph::{
+    components::store::{AggregationCurrent, AttributeNames},
+    data::store::scalar,
 };
-use graph::schema::{EntityKey, EntityType, FulltextAlgorithm, InputSchema};
-use graph::{components::store::AttributeNames, data::store::scalar};
 use inflector::Inflector;
 use itertools::Itertools;
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashSet};
 use std::convert::TryFrom;
 use std::fmt::{self, Display};
 use std::iter::FromIterator;
+use std::ops::Range;
 use std::str::FromStr;
+use std::string::ToString;
 
-use crate::block_range::BlockRange;
+use crate::block_range::{BoundSide, EntityBlockRange};
+use crate::parquet::convert::RestoreRow;
+use crate::relational::dsl::AtBlock;
 use crate::relational::{
-    Column, ColumnType, Layout, SqlName, Table, BYTE_ARRAY_PREFIX_SIZE, PRIMARY_KEY_COLUMN,
-    STRING_PREFIX_SIZE,
+    BYTE_ARRAY_PREFIX_SIZE, Column, ColumnType, Layout, PRIMARY_KEY_COLUMN, STRING_PREFIX_SIZE,
+    SqlName, Table, VID_COLUMN, dsl, rollup::Rollup,
 };
 use crate::{
     block_range::{
-        BlockRangeColumn, BlockRangeLowerBoundClause, BlockRangeUpperBoundClause, BLOCK_COLUMN,
-        BLOCK_RANGE_COLUMN, BLOCK_RANGE_CURRENT, CAUSALITY_REGION_COLUMN,
+        BLOCK_COLUMN, BLOCK_RANGE_COLUMN, BLOCK_RANGE_CURRENT, BlockRangeColumn,
+        BlockRangeLowerBoundClause, BlockRangeUpperBoundClause, BlockRangeValue,
+        CAUSALITY_REGION_COLUMN,
     },
-    primary::{Namespace, Site},
+    primary::Site,
 };
 
 /// Those are columns that we always want to fetch from the database.
 const BASE_SQL_COLUMNS: [&str; 2] = ["id", "vid"];
 
-/// The maximum number of bind variables that can be used in a query
-const POSTGRES_MAX_PARAMETERS: usize = u16::MAX as usize; // 65535
+/// The maximum number of bind variables that can be used in a query.
+/// Because of [this
+/// bug](https://github.com/rust-postgres/rust-postgres/issues/1302) we use
+/// i16::MAX instead of u16::MAX which is what Postgres actually supports
+pub(crate) const POSTGRES_MAX_PARAMETERS: usize = i16::MAX as usize; // 32767
 
 const SORT_KEY_COLUMN: &str = "sort_key$";
 
 /// The name of the parent_id attribute that we inject into queries. Users
 /// outside of this module should access the parent id through the
 /// `QueryObject` struct
-const PARENT_ID: &str = "g$parent_id";
+pub(crate) const PARENT_ID: &str = "g$parent_id";
 
 /// Describes at what level a `SELECT` statement is used.
 enum SelectStatementLevel {
@@ -70,7 +83,7 @@ enum SelectStatementLevel {
 #[derive(Debug)]
 pub(crate) struct UnsupportedFilter {
     pub filter: String,
-    pub value: Value,
+    pub value: String,
 }
 
 impl Display for UnsupportedFilter {
@@ -91,9 +104,9 @@ impl From<UnsupportedFilter> for diesel::result::Error {
     }
 }
 
-// Similar to graph::prelude::constraint_violation, but returns a Diesel
+// Similar to graph::prelude::internal_error, but returns a Diesel
 // error for use in the guts of query generation
-macro_rules! constraint_violation {
+macro_rules! internal_error {
     ($msg:expr) => {{
         diesel::result::Error::QueryBuilderError(anyhow!("{}", $msg).into())
     }};
@@ -102,37 +115,14 @@ macro_rules! constraint_violation {
     }}
 }
 
-/// Conveniences for handling foreign keys depending on whether we are using
-/// `IdType::Bytes` or `IdType::String` as the primary key
-///
-/// This trait adds some capabilities to `Column` that are very specific to
-/// how we generate SQL queries. Using a method like `bind_ids` from this
-/// trait on a given column means "send these values to the database in a form
-/// that can later be used for comparisons with that column"
-trait ForeignKeyClauses {
-    /// The type of the column
-    fn column_type(&self) -> &ColumnType;
-
-    /// The name of the column
-    fn name(&self) -> &str;
-
-    /// Generate a clause `{name()} = $id` using the right types to bind `$id`
-    /// into `out`
-    fn eq(&self, id: &Id, out: &mut AstPass<Pg>) -> QueryResult<()> {
-        out.push_sql(self.name());
-        out.push_sql(" = ");
-        id.push_bind_param(out)
-    }
-
-    /// Generate a clause
-    ///    `exists (select 1 from unnest($ids) as p(g$id) where id = p.g$id)`
-    /// using the right types to bind `$ids` into `out`
-    fn is_in(&self, ids: &IdList, out: &mut AstPass<Pg>) -> QueryResult<()> {
-        out.push_sql("exists (select 1 from unnest(");
-        ids.push_bind_param(out)?;
-        out.push_sql(") as p(g$id) where id = p.g$id)");
-        Ok(())
-    }
+/// Generate a clause
+///    `exists (select 1 from unnest($ids) as p(g$id) where id = p.g$id)`
+/// using the right types to bind `$ids` into `out`
+fn id_is_in<'b>(ids: &'b IdList, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+    out.push_sql("exists (select 1 from unnest(");
+    ids.push_bind_param(out)?;
+    out.push_sql(") as p(g$id) where id = p.g$id)");
+    Ok(())
 }
 
 /// This trait is here to deal with the fact that we can't implement `ToSql`
@@ -141,21 +131,24 @@ trait ForeignKeyClauses {
 /// we have to switch between `Text` and `Binary` and therefore use this
 /// trait to make passing `Id` values to the database convenient
 trait PushBindParam {
-    fn push_bind_param(&self, out: &mut AstPass<Pg>) -> QueryResult<()>;
+    fn push_bind_param<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()>;
 }
 
 impl PushBindParam for Id {
-    fn push_bind_param(&self, out: &mut AstPass<Pg>) -> QueryResult<()> {
+    fn push_bind_param<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         match self {
             Id::String(s) => out.push_bind_param::<Text, _>(s),
-            Id::Bytes(b) => out.push_bind_param::<Binary, _>(&b.as_slice()),
+            Id::Bytes(b) => {
+                let slice = b.as_slice();
+                out.push_bind_param::<Binary, _>(slice)
+            }
             Id::Int8(i) => out.push_bind_param::<Int8, _>(i),
         }
     }
 }
 
 impl PushBindParam for IdList {
-    fn push_bind_param(&self, out: &mut AstPass<Pg>) -> QueryResult<()> {
+    fn push_bind_param<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         match self {
             IdList::String(ids) => out.push_bind_param::<Array<Text>, _>(ids),
             IdList::Bytes(ids) => out.push_bind_param::<Array<Binary>, _>(ids),
@@ -164,26 +157,6 @@ impl PushBindParam for IdList {
     }
 }
 
-impl<'a> PushBindParam for IdRef<'a> {
-    fn push_bind_param(&self, out: &mut AstPass<Pg>) -> QueryResult<()> {
-        match self {
-            IdRef::String(s) => out.push_bind_param::<Text, _>(s),
-            IdRef::Bytes(b) => out.push_bind_param::<Binary, _>(b),
-            IdRef::Int8(i) => out.push_bind_param::<Int8, _>(i),
-        }
-    }
-}
-
-impl ForeignKeyClauses for Column {
-    fn column_type(&self) -> &ColumnType {
-        &self.column_type
-    }
-
-    fn name(&self) -> &str {
-        self.name.as_str()
-    }
-}
-
 pub trait FromEntityData: Sized {
     /// Whether to include the internal keys `__typename` and `g$parent_id`.
     const WITH_INTERNAL_KEYS: bool;
@@ -249,6 +222,8 @@ pub trait FromColumnValue: Sized + std::fmt::Debug {
     // The string returned by the DB, without the leading '\x'
     fn from_bytes(i: &str) -> Result<Self, StoreError>;
 
+    fn from_timestamp(i: &str) -> Result<Self, StoreError>;
+
     fn from_vec(v: Vec<Self>) -> Self;
 
     fn from_column_value(
@@ -300,6 +275,7 @@ pub trait FromColumnValue: Sized + std::fmt::Debug {
                 Ok(Self::from_string(s))
             }
             (j::String(s), ColumnType::Bytes) => Self::from_bytes(s.trim_start_matches("\\x")),
+            (j::String(s), ColumnType::Timestamp) => Self::from_timestamp(&s),
             (j::String(s), column_type) => Err(StoreError::Unknown(anyhow!(
                 "can not convert string {} to {:?}",
                 s,
@@ -362,6 +338,14 @@ impl FromColumnValue for r::Value {
         }
     }
 
+    fn from_timestamp(i: &str) -> Result<Self, StoreError> {
+        scalar::Timestamp::from_rfc3339(i)
+            .map(r::Value::Timestamp)
+            .map_err(|e| {
+                StoreError::Unknown(anyhow!("failed to convert {} to Timestamp: {}", i, e))
+            })
+    }
+
     fn from_vec(v: Vec<Self>) -> Self {
         r::Value::List(v)
     }
@@ -408,6 +392,14 @@ impl FromColumnValue for graph::prelude::Value {
             .map_err(|e| StoreError::Unknown(anyhow!("failed to convert {} to Bytes: {}", b, e)))
     }
 
+    fn from_timestamp(i: &str) -> Result<Self, StoreError> {
+        scalar::Timestamp::from_rfc3339(i)
+            .map(graph::prelude::Value::Timestamp)
+            .map_err(|e| {
+                StoreError::Unknown(anyhow!("failed to convert {} to Timestamp: {}", i, e))
+            })
+    }
+
     fn from_vec(v: Vec<Self>) -> Self {
         graph::prelude::Value::List(v)
     }
@@ -417,11 +409,11 @@ impl FromColumnValue for graph::prelude::Value {
 /// ID. Unlike [`EntityData`], we don't really care about attributes here.
 #[derive(QueryableByName)]
 pub struct EntityDeletion {
-    #[sql_type = "Text"]
+    #[diesel(sql_type = Text)]
     entity: String,
-    #[sql_type = "Text"]
+    #[diesel(sql_type = Text)]
     id: String,
-    #[sql_type = "Integer"]
+    #[diesel(sql_type = Integer)]
     causality_region: CausalityRegion,
 }
 
@@ -449,7 +441,7 @@ pub fn parse_id(id_type: IdType, json: serde_json::Value) -> Result<Id, StoreErr
         };
         id_type.parse(s).map_err(StoreError::from)
     } else {
-        Err(graph::constraint_violation!(
+        Err(graph::internal_error!(
             "the value {:?} can not be converted into an id of type {}",
             json,
             id_type
@@ -457,20 +449,65 @@ pub fn parse_id(id_type: IdType, json: serde_json::Value) -> Result<Id, StoreErr
     }
 }
 
+#[derive(QueryableByName, Debug)]
+pub struct JSONData {
+    #[diesel(sql_type = Jsonb)]
+    pub data: serde_json::Value,
+}
+
+impl IntoValue for JSONData {
+    fn into_value(self) -> r::Value {
+        JSONData::to_value(self.data)
+    }
+}
+
+impl JSONData {
+    pub fn to_value(data: serde_json::Value) -> r::Value {
+        match data {
+            serde_json::Value::Null => r::Value::Null,
+            serde_json::Value::Bool(b) => r::Value::Boolean(b),
+            serde_json::Value::Number(n) => {
+                if let Some(i) = n.as_i64() {
+                    r::Value::Int(i)
+                } else {
+                    r::Value::Float(n.as_f64().unwrap())
+                }
+            }
+            serde_json::Value::String(s) => r::Value::String(s),
+            serde_json::Value::Array(vals) => {
+                let vals: Vec<_> = vals.into_iter().map(JSONData::to_value).collect::<Vec<_>>();
+                r::Value::List(vals)
+            }
+            serde_json::Value::Object(map) => {
+                let mut m = std::collections::BTreeMap::new();
+                for (k, v) in map {
+                    let value = JSONData::to_value(v);
+                    m.insert(Word::from(k), value);
+                }
+                r::Value::object(m)
+            }
+        }
+    }
+}
+
 /// Helper struct for retrieving entities from the database. With diesel, we
 /// can only run queries that return columns whose number and type are known
 /// at compile time. Because of that, we retrieve the actual data for an
 /// entity as Jsonb by converting the row containing the entity using the
 /// `to_jsonb` function.
-#[derive(QueryableByName, Debug)]
+#[derive(QueryableByName, Clone, Debug)]
 pub struct EntityData {
-    #[sql_type = "Text"]
+    #[diesel(sql_type = Text)]
     entity: String,
-    #[sql_type = "Jsonb"]
+    #[diesel(sql_type = Jsonb)]
     data: serde_json::Value,
 }
 
 impl EntityData {
+    pub fn new(entity: String, data: serde_json::Value) -> EntityData {
+        EntityData { entity, data }
+    }
+
     pub fn entity_type(&self, schema: &InputSchema) -> EntityType {
         schema.entity_type(&self.entity).unwrap()
     }
@@ -482,6 +519,7 @@ impl EntityData {
         parent_type: Option<&ColumnType>,
     ) -> Result<T, StoreError> {
         let entity_type = layout.input_schema.entity_type(&self.entity)?;
+        let typename = entity_type.typename();
         let table = layout.table_for_entity(&entity_type)?;
 
         use serde_json::Value as j;
@@ -498,7 +536,7 @@ impl EntityData {
                                 // A query that does not have parents
                                 // somehow returned parent ids. We have no
                                 // idea how to deserialize that
-                                Some(Err(graph::constraint_violation!(
+                                Some(Err(graph::internal_error!(
                                     "query unexpectedly produces parent ids"
                                 )))
                             }
@@ -512,9 +550,12 @@ impl EntityData {
                     })
                     .transpose()?;
                 let map = map;
-                let typname = std::iter::once(self.entity).filter_map(move |e| {
+                let typname = std::iter::once(typename).filter_map(move |e| {
                     if T::WITH_INTERNAL_KEYS {
-                        Some(Ok((Word::from("__typename"), T::Value::from_string(e))))
+                        Some(Ok((
+                            Word::from("__typename"),
+                            T::Value::from_string(e.to_string()),
+                        )))
                     } else {
                         None
                     }
@@ -524,7 +565,14 @@ impl EntityData {
                     // table column; those will be things like the
                     // block_range that `select *` pulls in but that we
                     // don't care about here
-                    if let Some(column) = table.column(&SqlName::verbatim(key)) {
+                    if key == VID_COLUMN {
+                        // VID is not in the input schema but we need it, so deserialize it too
+                        match T::Value::from_column_value(&ColumnType::Int8, json) {
+                            Ok(value) if value.is_null() => None,
+                            Ok(value) => Some(Ok((Word::from(VID_COLUMN), value))),
+                            Err(e) => Some(Err(e)),
+                        }
+                    } else if let Some(column) = table.column(&SqlName::verbatim(key)) {
                         match T::Value::from_column_value(&column.column_type, json) {
                             Ok(value) if value.is_null() => None,
                             Ok(value) => Some(Ok((Word::from(column.field.to_string()), value))),
@@ -543,27 +591,148 @@ impl EntityData {
     }
 }
 
+#[derive(QueryableByName, Clone, Debug, Default)]
+pub struct EntityDataExt {
+    #[diesel(sql_type = Text)]
+    pub entity: String,
+    #[diesel(sql_type = Jsonb)]
+    pub data: serde_json::Value,
+    #[diesel(sql_type = Integer)]
+    pub block_number: i32,
+    #[diesel(sql_type = Binary)]
+    pub id: Vec<u8>,
+    #[diesel(sql_type = BigInt)]
+    pub vid: i64,
+}
+
+/// The equivalent of `graph::data::store::Value` but in a form that does
+/// not require further transformation during `walk_ast`. This form takes
+/// the idiosyncrasies of how we serialize values into account (e.g., that
+/// `BigDecimal` gets serialized as a string)
+#[derive(Debug, Clone)]
+enum SqlValue<'a> {
+    String(String),
+    Text(&'a String),
+    Int(i32),
+    Int8(i64),
+    Timestamp(scalar::Timestamp),
+    Numeric(String),
+    Numerics(Vec<String>),
+    Bool(bool),
+    List(&'a Vec<Value>),
+    Null,
+    Bytes(&'a scalar::Bytes),
+    Binary(scalar::Bytes),
+}
+
+impl<'a> SqlValue<'a> {
+    fn new(value: &'a Value, column_type: &'a ColumnType) -> QueryResult<Self> {
+        use SqlValue as S;
+        use Value::*;
+
+        let value = match value {
+            String(s) => match column_type {
+                ColumnType::String | ColumnType::Enum(_) | ColumnType::TSVector(_) => S::Text(s),
+                ColumnType::Int8 => S::Int8(s.parse::<i64>().map_err(|e| {
+                    internal_error!("failed to convert `{}` to an Int8: {}", s, e.to_string())
+                })?),
+                ColumnType::Bytes => {
+                    let bytes = scalar::Bytes::from_str(s)
+                        .map_err(|e| DieselError::SerializationError(Box::new(e)))?;
+                    S::Binary(bytes)
+                }
+                _ => unreachable!(
+                    "only string, enum and tsvector columns have values of type string but not {column_type}"
+                ),
+            },
+            Int(i) => S::Int(*i),
+            Value::Int8(i) => S::Int8(*i),
+            BigDecimal(d) => S::Numeric(d.to_string()),
+            Timestamp(ts) => S::Timestamp(*ts),
+            Bool(b) => S::Bool(*b),
+            List(values) => match column_type {
+                ColumnType::BigDecimal | ColumnType::BigInt => {
+                    let text_values: Vec<_> = values.iter().map(|v| v.to_string()).collect();
+                    S::Numerics(text_values)
+                }
+                ColumnType::Boolean
+                | ColumnType::Bytes
+                | ColumnType::Int
+                | ColumnType::Int8
+                | ColumnType::String
+                | ColumnType::Timestamp
+                | ColumnType::Enum(_)
+                | ColumnType::TSVector(_) => S::List(values),
+            },
+            Null => S::Null,
+            Bytes(b) => S::Bytes(b),
+            BigInt(i) => S::Numeric(i.to_string()),
+        };
+        Ok(value)
+    }
+}
+
+impl std::fmt::Display for SqlValue<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use SqlValue as S;
+        match self {
+            S::String(s) => write!(f, "{}", s),
+            S::Text(s) => write!(f, "{}", s),
+            S::Int(i) => write!(f, "{}", i),
+            S::Int8(i) => write!(f, "{}", i),
+            S::Numeric(s) => write!(f, "{}", s),
+            S::Timestamp(ts) => write!(f, "{}", ts.as_microseconds_since_epoch()),
+            S::Numerics(values) => write!(f, "{:?}", values),
+            S::Bool(b) => write!(f, "{}", b),
+            S::List(values) => write!(f, "{:?}", values),
+            S::Null => write!(f, "null"),
+            S::Bytes(b) => write!(f, "{}", b),
+            S::Binary(b) => write!(f, "{}", b),
+        }
+    }
+}
+
 /// A `QueryValue` makes it possible to bind a `Value` into a SQL query
 /// using the metadata from Column
-struct QueryValue<'a>(&'a Value, &'a ColumnType);
+#[derive(Debug)]
+pub struct QueryValue<'a> {
+    value: SqlValue<'a>,
+    column_type: &'a ColumnType,
+}
 
-impl<'a> QueryFragment<Pg> for QueryValue<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
-        out.unsafe_to_cache_prepared();
-        let column_type = self.1;
+impl<'a> QueryValue<'a> {
+    fn new(value: &'a Value, column_type: &'a ColumnType) -> QueryResult<Self> {
+        let value = SqlValue::new(value, column_type)?;
+        Ok(Self { value, column_type })
+    }
+
+    fn many(values: &'a [Value], column_type: &'a ColumnType) -> QueryResult<Vec<Self>> {
+        values
+            .iter()
+            .map(|value| Self::new(value, column_type))
+            .collect()
+    }
+
+    fn is_null(&self) -> bool {
+        matches!(&self.value, SqlValue::Null)
+    }
+}
+
+impl<'a> std::fmt::Display for QueryValue<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.value.fmt(f)
+    }
+}
 
-        match self.0 {
-            Value::String(s) => match &column_type {
+impl<'a> QueryFragment<Pg> for QueryValue<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        fn push_string<'c>(
+            s: &'c String,
+            column_type: &ColumnType,
+            out: &mut AstPass<'_, 'c, Pg>,
+        ) -> QueryResult<()> {
+            match column_type {
                 ColumnType::String => out.push_bind_param::<Text, _>(s),
-                ColumnType::Int8 => {
-                    out.push_bind_param::<BigInt, _>(&s.parse::<i64>().map_err(|e| {
-                        constraint_violation!(
-                            "failed to convert `{}` to an Int8: {}",
-                            s,
-                            e.to_string()
-                        )
-                    })?)
-                }
                 ColumnType::Enum(enum_type) => {
                     out.push_bind_param::<Text, _>(s)?;
                     out.push_sql("::");
@@ -576,35 +745,35 @@ impl<'a> QueryFragment<Pg> for QueryValue<'a> {
                     out.push_sql(")");
                     Ok(())
                 }
-                ColumnType::Bytes => {
-                    let bytes = scalar::Bytes::from_str(s)
-                        .map_err(|e| DieselError::SerializationError(Box::new(e)))?;
-                    out.push_bind_param::<Binary, _>(&bytes.as_slice())
-                }
                 _ => unreachable!(
-                    "only string, enum and tsvector columns have values of type string"
+                    "only string, enum and tsvector columns have values of type string but not {column_type}"
                 ),
-            },
-            Value::Int(i) => out.push_bind_param::<Integer, _>(i),
-            Value::Int8(i) => out.push_bind_param::<Int8, _>(i),
-            Value::BigDecimal(d) => {
-                out.push_bind_param::<Text, _>(&d.to_string())?;
+            }
+        }
+
+        out.unsafe_to_cache_prepared();
+        let column_type = self.column_type;
+
+        use SqlValue as S;
+        match &self.value {
+            S::Text(s) => push_string(s, column_type, &mut out),
+            S::String(s) => push_string(s, column_type, &mut out),
+            S::Int(i) => out.push_bind_param::<Integer, _>(i),
+            S::Int8(i) => out.push_bind_param::<Int8, _>(i),
+            S::Timestamp(i) => out.push_bind_param::<Timestamptz, _>(&i.0),
+            S::Numeric(s) => {
+                out.push_bind_param::<Text, _>(s)?;
                 out.push_sql("::numeric");
                 Ok(())
             }
-            Value::Bool(b) => out.push_bind_param::<Bool, _>(b),
-            Value::List(values) => {
+            S::Bool(b) => out.push_bind_param::<Bool, _>(b),
+            S::List(values) => {
                 match &column_type {
-                    ColumnType::BigDecimal | ColumnType::BigInt => {
-                        let text_values: Vec<_> = values.iter().map(|v| v.to_string()).collect();
-                        out.push_bind_param::<Array<Text>, _>(&text_values)?;
-                        out.push_sql("::numeric[]");
-                        Ok(())
-                    }
                     ColumnType::Boolean => out.push_bind_param::<Array<Bool>, _>(values),
                     ColumnType::Bytes => out.push_bind_param::<Array<Binary>, _>(values),
                     ColumnType::Int => out.push_bind_param::<Array<Integer>, _>(values),
-                    ColumnType::Int8 => out.push_bind_param::<Array<Int8>, _>(&values),
+                    ColumnType::Int8 => out.push_bind_param::<Array<Int8>, _>(values),
+                    ColumnType::Timestamp => out.push_bind_param::<Array<Timestamptz>, _>(values),
                     ColumnType::String => out.push_bind_param::<Array<Text>, _>(values),
                     ColumnType::Enum(enum_type) => {
                         out.push_bind_param::<Array<Text>, _>(values)?;
@@ -615,42 +784,56 @@ impl<'a> QueryFragment<Pg> for QueryValue<'a> {
                     }
                     // TSVector will only be in a Value::List() for inserts so "to_tsvector" can always be used here
                     ColumnType::TSVector(config) => {
-                        if values.is_empty() {
-                            out.push_sql("''::tsvector");
-                        } else {
-                            out.push_sql("(");
-                            for (i, value) in values.iter().enumerate() {
-                                if i > 0 {
-                                    out.push_sql(") || ");
-                                }
-                                out.push_sql("to_tsvector(");
-                                out.push_sql(config.language.as_sql());
-                                out.push_sql(", ");
-                                out.push_bind_param::<Text, _>(&value)?;
-                            }
-                            out.push_sql("))");
-                        }
-
+                        process_vec_ast(values, &mut out, config.language.as_sql())?;
                         Ok(())
                     }
+                    ColumnType::BigDecimal | ColumnType::BigInt => {
+                        unreachable!(
+                            "BigDecimal and BigInt use SqlValue::Numerics instead of List"
+                        );
+                    }
                 }
             }
-            Value::Null => {
-                out.push_sql("null");
+            S::Numerics(values) => {
+                out.push_bind_param::<Array<Text>, _>(values)?;
+                out.push_sql("::numeric[]");
                 Ok(())
             }
-            Value::Bytes(b) => out.push_bind_param::<Binary, _>(&b.as_slice()),
-            Value::BigInt(i) => {
-                out.push_bind_param::<Text, _>(&i.to_string())?;
-                out.push_sql("::numeric");
+            S::Null => {
+                out.push_sql("null");
                 Ok(())
             }
+            S::Bytes(b) => out.push_bind_param::<Binary, _>(b.as_slice()),
+            S::Binary(b) => out.push_bind_param::<Binary, _>(b.as_slice()),
         }
     }
 }
 
-#[derive(Copy, Clone, PartialEq)]
-enum Comparison {
+fn process_vec_ast<'a, T: diesel::serialize::ToSql<Text, Pg>>(
+    values: &'a [T],
+    out: &mut AstPass<'_, 'a, Pg>,
+    sql_language: &str,
+) -> Result<(), DieselError> {
+    if values.is_empty() {
+        out.push_sql("''::tsvector");
+    } else {
+        out.push_sql("(");
+        for (i, value) in values.iter().enumerate() {
+            if i > 0 {
+                out.push_sql(") || ");
+            }
+            out.push_sql("to_tsvector(");
+            out.push_sql(sql_language);
+            out.push_sql(", ");
+            out.push_bind_param::<Text, _>(value)?;
+        }
+        out.push_sql("))");
+    }
+    Ok(())
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum Comparison {
     Less,
     LessOrEqual,
     Equal,
@@ -673,21 +856,103 @@ impl Comparison {
             Match => " @@ ",
         }
     }
+
+    fn suitable(&self, value: &Value) -> Result<(), StoreError> {
+        // Anything can be compared for equality; for less than etc., the
+        // type needs to be ordered. For fulltext match, only strings can be
+        // used
+        match (self, value) {
+            (Comparison::Equal | Comparison::NotEqual, _) => Ok(()),
+            (
+                Comparison::Less
+                | Comparison::LessOrEqual
+                | Comparison::GreaterOrEqual
+                | Comparison::Greater,
+                Value::String(_)
+                | Value::Int(_)
+                | Value::Int8(_)
+                | Value::Timestamp(_)
+                | Value::BigDecimal(_)
+                | Value::BigInt(_)
+                | Value::Bytes(_),
+            ) => Ok(()),
+            (Comparison::Match, Value::String(_)) => Ok(()),
+            (
+                Comparison::Less
+                | Comparison::LessOrEqual
+                | Comparison::GreaterOrEqual
+                | Comparison::Greater,
+                Value::Bool(_) | Value::List(_) | Value::Null,
+            )
+            | (Comparison::Match, _) => Err(StoreError::UnsupportedFilter(
+                self.to_string(),
+                value.to_string(),
+            )),
+        }
+    }
+}
+
+impl std::fmt::Display for Comparison {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use Comparison::*;
+        let s = match self {
+            Less => "<",
+            LessOrEqual => "<=",
+            Equal => "=",
+            NotEqual => "!=",
+            GreaterOrEqual => ">=",
+            Greater => ">",
+            Match => "@@",
+        };
+        write!(f, "{s}")
+    }
+}
+
+/// The operators for 'contains' comparisons for strings and byte arrays
+#[derive(Clone, Copy, Debug)]
+pub enum ContainsOp {
+    Like,
+    NotLike,
+    ILike,
+    NotILike,
+}
+impl ContainsOp {
+    fn negated(&self) -> bool {
+        use ContainsOp::*;
+        match self {
+            Like | ILike => false,
+            NotLike | NotILike => true,
+        }
+    }
+}
+
+impl QueryFragment<Pg> for ContainsOp {
+    fn walk_ast<'a>(&self, mut out: AstPass<'_, 'a, Pg>) -> QueryResult<()> {
+        use ContainsOp::*;
+        match self {
+            Like => out.push_sql(" like "),
+            NotLike => out.push_sql(" not like "),
+            ILike => out.push_sql(" ilike "),
+            NotILike => out.push_sql(" not ilike "),
+        }
+        Ok(())
+    }
 }
 
-enum PrefixType<'a> {
-    String(&'a Column),
-    Bytes(&'a Column),
+#[derive(Debug, Clone)]
+enum PrefixType {
+    String,
+    Bytes,
 }
 
-impl<'a> PrefixType<'a> {
-    fn new(column: &'a Column) -> QueryResult<Self> {
-        match column.column_type {
-            ColumnType::String => Ok(PrefixType::String(column)),
-            ColumnType::Bytes => Ok(PrefixType::Bytes(column)),
-            _ => Err(constraint_violation!(
+impl PrefixType {
+    fn new(column: &dsl::Column<'_>) -> QueryResult<Self> {
+        match column.column_type() {
+            ColumnType::String => Ok(PrefixType::String),
+            ColumnType::Bytes => Ok(PrefixType::Bytes),
+            _ => Err(internal_error!(
                 "cannot setup prefix comparison for column {} of type {}",
-                column.name(),
+                column,
                 column.column_type().sql_type()
             )),
         }
@@ -696,18 +961,22 @@ impl<'a> PrefixType<'a> {
     /// Push the SQL expression for a prefix of values in our column. That
     /// should be the same expression that we used when creating an index
     /// for the column
-    fn push_column_prefix(&self, out: &mut AstPass<Pg>) -> QueryResult<()> {
+    fn push_column_prefix<'b>(
+        self,
+        column: &'b dsl::Column<'b>,
+        out: &mut AstPass<'_, 'b, Pg>,
+    ) -> QueryResult<()> {
         match self {
-            PrefixType::String(column) => {
+            PrefixType::String => {
                 out.push_sql("left(");
-                out.push_identifier(column.name.as_str())?;
+                column.walk_ast(out.reborrow())?;
                 out.push_sql(", ");
                 out.push_sql(&STRING_PREFIX_SIZE.to_string());
                 out.push_sql(")");
             }
-            PrefixType::Bytes(column) => {
+            PrefixType::Bytes => {
                 out.push_sql("substring(");
-                out.push_identifier(column.name.as_str())?;
+                column.walk_ast(out.reborrow())?;
                 out.push_sql(", 1, ");
                 out.push_sql(&BYTE_ARRAY_PREFIX_SIZE.to_string());
                 out.push_sql(")");
@@ -716,59 +985,73 @@ impl<'a> PrefixType<'a> {
         Ok(())
     }
 
-    fn is_large(&self, value: &Value) -> Result<bool, ()> {
-        match (self, value) {
-            (PrefixType::String(_), Value::String(s)) => Ok(s.len() > STRING_PREFIX_SIZE - 1),
-            (PrefixType::Bytes(_), Value::Bytes(b)) => Ok(b.len() > BYTE_ARRAY_PREFIX_SIZE - 1),
-            (PrefixType::Bytes(_), Value::String(s)) => {
-                let len = if s.starts_with("0x") {
-                    (s.len() - 2) / 2
-                } else {
-                    s.len() / 2
-                };
-                Ok(len > BYTE_ARRAY_PREFIX_SIZE - 1)
-            }
+    fn is_large(&self, qv: &QueryValue<'_>) -> Result<bool, ()> {
+        use SqlValue as S;
+
+        match (self, &qv.value) {
+            (PrefixType::String, S::String(s)) => Ok(s.len() > STRING_PREFIX_SIZE - 1),
+            (PrefixType::String, S::Text(s)) => Ok(s.len() > STRING_PREFIX_SIZE - 1),
+            (PrefixType::Bytes, S::Bytes(b)) => Ok(b.len() > BYTE_ARRAY_PREFIX_SIZE - 1),
+            (PrefixType::Bytes, S::Binary(b)) => Ok(b.len() > BYTE_ARRAY_PREFIX_SIZE - 1),
+            (PrefixType::Bytes, S::Text(s)) => is_large_string(s),
+            (PrefixType::Bytes, S::String(s)) => is_large_string(s),
             _ => Err(()),
         }
     }
 }
 
+fn is_large_string(s: &str) -> Result<bool, ()> {
+    let len = if s.starts_with("0x") {
+        (s.len() - 2) / 2
+    } else {
+        s.len() / 2
+    };
+    Ok(len > BYTE_ARRAY_PREFIX_SIZE - 1)
+}
+
 /// Produce a comparison between the string column `column` and the string
 /// value `text` that makes it obvious to Postgres' optimizer that it can
 /// first consult the partial index on `left(column, STRING_PREFIX_SIZE)`
 /// instead of going straight to a sequential scan of the underlying table.
 /// We do this by writing the comparison `column op text` in a way that
 /// involves `left(column, STRING_PREFIX_SIZE)`
-struct PrefixComparison<'a> {
+#[derive(Debug)]
+pub struct PrefixComparison<'a> {
     op: Comparison,
-    kind: PrefixType<'a>,
-    column: &'a Column,
-    text: &'a Value,
+    kind: PrefixType,
+    column: dsl::Column<'a>,
+    value: QueryValue<'a>,
 }
 
 impl<'a> PrefixComparison<'a> {
-    fn new(op: Comparison, column: &'a Column, text: &'a Value) -> QueryResult<Self> {
-        let kind = PrefixType::new(column)?;
+    fn new(
+        op: Comparison,
+        column: dsl::Column<'a>,
+        column_type: &'a ColumnType,
+        text: &'a Value,
+    ) -> Result<Self, StoreError> {
+        let kind = PrefixType::new(&column)?;
+        let value = QueryValue::new(text, column_type)?;
         Ok(Self {
             op,
             kind,
             column,
-            text,
+            value,
         })
     }
 
-    fn push_value_prefix(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn push_value_prefix<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         match self.kind {
-            PrefixType::String(column) => {
+            PrefixType::String => {
                 out.push_sql("left(");
-                QueryValue(self.text, &column.column_type).walk_ast(out.reborrow())?;
+                self.value.walk_ast(out.reborrow())?;
                 out.push_sql(", ");
                 out.push_sql(&STRING_PREFIX_SIZE.to_string());
                 out.push_sql(")");
             }
-            PrefixType::Bytes(column) => {
+            PrefixType::Bytes => {
                 out.push_sql("substring(");
-                QueryValue(self.text, &column.column_type).walk_ast(out.reborrow())?;
+                self.value.walk_ast(out.reborrow())?;
                 out.push_sql(", 1, ");
                 out.push_sql(&BYTE_ARRAY_PREFIX_SIZE.to_string());
                 out.push_sql(")");
@@ -777,21 +1060,31 @@ impl<'a> PrefixComparison<'a> {
         Ok(())
     }
 
-    fn push_prefix_cmp(&self, op: Comparison, mut out: AstPass<Pg>) -> QueryResult<()> {
-        self.kind.push_column_prefix(&mut out)?;
+    fn push_prefix_cmp<'b>(
+        &'b self,
+        op: Comparison,
+        mut out: AstPass<'_, 'b, Pg>,
+    ) -> QueryResult<()> {
+        self.kind
+            .clone()
+            .push_column_prefix(&self.column, &mut out)?;
         out.push_sql(op.as_str());
-        self.push_value_prefix(out.reborrow())
+        self.push_value_prefix(&mut out)
     }
 
-    fn push_full_cmp(&self, op: Comparison, mut out: AstPass<Pg>) -> QueryResult<()> {
-        out.push_identifier(self.column.name.as_str())?;
+    fn push_full_cmp<'b>(
+        &'b self,
+        op: Comparison,
+        mut out: AstPass<'_, 'b, Pg>,
+    ) -> QueryResult<()> {
+        self.column.walk_ast(out.reborrow())?;
         out.push_sql(op.as_str());
-        QueryValue(self.text, &self.column.column_type).walk_ast(out)
+        self.value.walk_ast(out)
     }
 }
 
 impl<'a> QueryFragment<Pg> for PrefixComparison<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         use Comparison::*;
 
         // For the various comparison operators, we want to write the condition
@@ -829,12 +1122,12 @@ impl<'a> QueryFragment<Pg> for PrefixComparison<'a> {
         //
         // For `op` either `<=` or `>=`, we can write (using '<=' as an example)
         //   uv <= st <=> u < s || u = s && uv <= st
-        let large = self.kind.is_large(self.text).map_err(|()| {
-            constraint_violation!(
+        let large = self.kind.is_large(&self.value).map_err(|()| {
+            internal_error!(
                 "column {} has type {} and can't be compared with the value `{}` using {}",
-                self.column.name(),
+                self.column,
                 self.column.column_type().sql_type(),
-                self.text,
+                self.value.value,
                 self.op.as_str()
             )
         })?;
@@ -884,404 +1177,548 @@ impl<'a> QueryFragment<Pg> for PrefixComparison<'a> {
     }
 }
 
-/// A `QueryFilter` adds the conditions represented by the `filter` to
-/// the `where` clause of a SQL query. The attributes mentioned in
-/// the `filter` must all come from the given `table`, which is used to
-/// map GraphQL names to column names, and to determine the type of the
-/// column an attribute refers to
-#[derive(Debug, Clone)]
-pub struct QueryFilter<'a> {
-    filter: &'a EntityFilter,
-    layout: &'a Layout,
-    table: &'a Table,
-    table_prefix: &'a str,
-    block: BlockNumber,
-}
-
-/// String representation that is useful for debugging when `walk_ast` fails
-impl<'a> fmt::Display for QueryFilter<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.filter)
-    }
+/// A child filter on `parent_table`. The join between the tables happens
+/// along `parent_column = child_column` and the `child_table` must be
+/// filtered with `child_filter``
+#[derive(Debug)]
+pub struct QueryChild<'a> {
+    parent_column: dsl::Column<'a>,
+    child_from: dsl::FromTable<'a>,
+    child_column: dsl::Column<'a>,
+    child_filter: Filter<'a>,
+    derived: bool,
+    at_block: dsl::AtBlock<'a>,
 }
 
-impl<'a> QueryFilter<'a> {
-    pub fn new(
-        filter: &'a EntityFilter,
-        table: &'a Table,
+impl<'a> QueryChild<'a> {
+    fn new(
         layout: &'a Layout,
+        parent_table: dsl::Table<'a>,
+        child: &'a StoreChild,
         block: BlockNumber,
     ) -> Result<Self, StoreError> {
-        Self::valid_attributes(filter, table, layout, false)?;
-
-        Ok(QueryFilter {
+        let StoreChild {
+            attr,
+            entity_type,
             filter,
-            table,
-            layout,
-            block,
-            table_prefix: "c.",
+            derived,
+        } = child;
+        let derived = *derived;
+        let child_table = layout.table_for_entity(entity_type)?.dsl_table().child(0);
+        let (parent_column, child_column) = if derived {
+            // If the parent is derived, the child column is picked based on
+            // the provided attribute and the parent column is the primary
+            // key of the parent table
+            (
+                parent_table.primary_key(),
+                child_table.column_for_field(attr)?,
+            )
+        } else {
+            // If the parent is not derived, we do the opposite. The parent
+            // column is picked based on the provided attribute and the
+            // child column is the primary key of the child table
+            (
+                parent_table.column_for_field(attr)?,
+                child_table.primary_key(),
+            )
+        };
+        let at_block = child_table.at_block(block).filters_by_id(!derived);
+        let child_filter = Filter::new(layout, child_table, filter, block, ColumnQual::Child)?;
+        let child_from = child_table.from_clause();
+        Ok(Self {
+            parent_column,
+            child_from,
+            child_column,
+            child_filter,
+            derived,
+            at_block,
         })
     }
+}
 
-    fn valid_attributes(
-        filter: &'a EntityFilter,
-        table: &'a Table,
-        layout: &'a Layout,
-        child_filter_ancestor: bool,
-    ) -> Result<(), StoreError> {
-        use EntityFilter::*;
-        match filter {
-            And(filters) | Or(filters) => {
-                for filter in filters {
-                    Self::valid_attributes(filter, table, layout, child_filter_ancestor)?;
-                }
-            }
-            Child(child) => {
-                if child_filter_ancestor {
-                    return Err(StoreError::ChildFilterNestingNotSupportedError(
-                        child.attr.to_string(),
-                        filter.to_string(),
-                    ));
-                }
-
-                if child.derived {
-                    let derived_table = layout.table_for_entity(&child.entity_type)?;
-                    // Make sure that the attribute name is valid for the given table
-                    derived_table.column_for_field(child.attr.as_str())?;
-
-                    Self::valid_attributes(&child.filter, derived_table, layout, true)?;
-                } else {
-                    // Make sure that the attribute name is valid for the given table
-                    table.column_for_field(child.attr.as_str())?;
-
-                    Self::valid_attributes(
-                        &child.filter,
-                        layout.table_for_entity(&child.entity_type)?,
-                        layout,
-                        true,
-                    )?;
-                }
-            }
-            // This is a special case since we want to allow passing "block" column filter, but we dont
-            // want to fail/error when this is passed here, since this column is not really an entity column.
-            ChangeBlockGte(..) => {}
-            Contains(attr, _)
-            | ContainsNoCase(attr, _)
-            | NotContains(attr, _)
-            | NotContainsNoCase(attr, _)
-            | Equal(attr, _)
-            | Fulltext(attr, _)
-            | Not(attr, _)
-            | GreaterThan(attr, _)
-            | LessThan(attr, _)
-            | GreaterOrEqual(attr, _)
-            | LessOrEqual(attr, _)
-            | In(attr, _)
-            | NotIn(attr, _)
-            | StartsWith(attr, _)
-            | StartsWithNoCase(attr, _)
-            | NotStartsWith(attr, _)
-            | NotStartsWithNoCase(attr, _)
-            | EndsWith(attr, _)
-            | EndsWithNoCase(attr, _)
-            | NotEndsWith(attr, _)
-            | NotEndsWithNoCase(attr, _) => {
-                table.column_for_field(attr)?;
-            }
-        }
-        Ok(())
-    }
-
-    fn with(&self, filter: &'a EntityFilter) -> Self {
-        QueryFilter {
-            filter,
-            table: self.table,
-            layout: self.layout,
-            block: self.block,
-            table_prefix: self.table_prefix,
-        }
-    }
-
-    fn child(
-        &self,
-        attribute: &Attribute,
-        entity_type: &'a EntityType,
-        filter: &'a EntityFilter,
-        derived: bool,
-        mut out: AstPass<Pg>,
-    ) -> QueryResult<()> {
-        let child_table = self
-            .layout
-            .table_for_entity(entity_type)
-            .expect("Table for child entity not found");
+impl<'a> QueryFragment<Pg> for QueryChild<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
 
-        let child_prefix = "i.";
-        let parent_prefix = "c.";
+        let QueryChild {
+            parent_column,
+            child_from,
+            child_column,
+            child_filter,
+            derived,
+            at_block,
+        } = self;
+        let derived = *derived;
 
         out.push_sql("exists (select 1 from ");
-        out.push_sql(child_table.qualified_name.as_str());
-        out.push_sql(" as i");
+        child_from.walk_ast(out.reborrow())?;
 
         out.push_sql(" where ");
 
-        let mut is_type_c_or_d = false;
-
         // Join tables
         if derived {
-            // If the parent is derived,
-            // the child column is picked based on the provided attribute
-            // and the parent column is the primary key of the parent table
-            let child_column = child_table
-                .column_for_field(attribute)
-                .expect("Column for an attribute not found");
-            let parent_column = self.table.primary_key();
-
             if child_column.is_list() {
                 // Type A: c.id = any(i.{parent_field})
-                out.push_sql(parent_prefix);
-                out.push_identifier(parent_column.name.as_str())?;
+                parent_column.walk_ast(out.reborrow())?;
                 out.push_sql(" = any(");
-                out.push_sql(child_prefix);
-                out.push_identifier(child_column.name.as_str())?;
+                child_column.walk_ast(out.reborrow())?;
                 out.push_sql(")");
             } else {
                 // Type B: c.id = i.{parent_field}
-                out.push_sql(parent_prefix);
-                out.push_identifier(parent_column.name.as_str())?;
+                parent_column.walk_ast(out.reborrow())?;
                 out.push_sql(" = ");
-                out.push_sql(child_prefix);
-                out.push_identifier(child_column.name.as_str())?;
+                child_column.walk_ast(out.reborrow())?;
             }
+        } else if parent_column.is_list() {
+            // Type C: i.id = any(c.child_ids)
+            child_column.walk_ast(out.reborrow())?;
+            out.push_sql(" = any(");
+            parent_column.walk_ast(out.reborrow())?;
+            out.push_sql(")");
         } else {
-            // If the parent is not derived, we do the opposite.
-            // The parent column is picked based on the provided attribute
-            // and the child column is the primary key of the child table
-            let parent_column = self
-                .table
-                .column_for_field(attribute)
-                .expect("Column for an attribute not found");
-            let child_column = child_table.primary_key();
-            is_type_c_or_d = true;
-
-            if parent_column.is_list() {
-                // Type C: i.id = any(c.child_ids)
-                out.push_sql(child_prefix);
-                out.push_identifier(child_column.name.as_str())?;
-                out.push_sql(" = any(");
-                out.push_sql(parent_prefix);
-                out.push_identifier(parent_column.name.as_str())?;
-                out.push_sql(")");
-            } else {
-                // Type D: i.id = c.child_id
-                out.push_sql(child_prefix);
-                out.push_identifier(child_column.name.as_str())?;
-                out.push_sql(" = ");
-                out.push_sql(parent_prefix);
-                out.push_identifier(parent_column.name.as_str())?;
-            }
+            // Type D: i.id = c.child_id
+            child_column.walk_ast(out.reborrow())?;
+            out.push_sql(" = ");
+            parent_column.walk_ast(out.reborrow())?;
         }
 
         out.push_sql(" and ");
 
         // Match by block
-        BlockRangeColumn::new(child_table, child_prefix, self.block)
-            .contains(&mut out, is_type_c_or_d)?;
+        at_block.walk_ast(out.reborrow())?;
 
         out.push_sql(" and ");
 
-        // Child filters
-        let query_filter = QueryFilter {
-            filter,
-            table: child_table,
-            layout: self.layout,
-            block: self.block,
-            table_prefix: child_prefix,
-        };
-
-        query_filter.walk_ast(out.reborrow())?;
+        child_filter.walk_ast(out.reborrow())?;
 
         out.push_sql(")");
 
         Ok(())
     }
+}
+
+/// The qualifier for a column to indicate whether we use the main table or
+/// a child table
+#[derive(Copy, Clone, Debug)]
+enum ColumnQual {
+    Main,
+    Child,
+}
 
-    fn column(&self, attribute: &Attribute) -> &'a Column {
-        self.table
-            .column_for_field(attribute)
-            .expect("the constructor already checked that all attribute names are valid")
+impl ColumnQual {
+    /// Return `true` if we allow a nested child filter. That's allowed as
+    /// long as we are filtering the main table
+    fn allow_child(&self) -> bool {
+        match self {
+            ColumnQual::Main => true,
+            ColumnQual::Child => false,
+        }
     }
+}
 
-    fn binary_op(
-        &self,
-        filters: &[EntityFilter],
-        op: &str,
-        on_empty: &str,
-        mut out: AstPass<Pg>,
-    ) -> QueryResult<()> {
-        if !filters.is_empty() {
-            out.push_sql("(");
-            for (i, filter) in filters.iter().enumerate() {
-                if i > 0 {
-                    out.push_sql(op);
+/// The equivalent of `EntityFilter` with columns resolved and various
+/// properties checked so that we can generate SQL and be reasonably sure
+/// the SQL does not have a syntax error.
+///
+/// A `Filter` will usually be used in the `where` clause of a SQL query.
+#[derive(Debug)]
+pub enum Filter<'a> {
+    And(Vec<Filter<'a>>),
+    Or(Vec<Filter<'a>>),
+    PrefixCmp(PrefixComparison<'a>),
+    Cmp(dsl::Column<'a>, Comparison, QueryValue<'a>),
+    In(dsl::Column<'a>, Vec<QueryValue<'a>>),
+    NotIn(dsl::Column<'a>, Vec<QueryValue<'a>>),
+    Contains {
+        column: dsl::Column<'a>,
+        op: ContainsOp,
+        pattern: QueryValue<'a>,
+    },
+    StartsOrEndsWith {
+        column: dsl::Column<'a>,
+        op: &'static str,
+        pattern: String,
+    },
+    ChangeBlockGte(dsl::ChangedSince<'a>),
+    Child(Box<QueryChild<'a>>),
+    /// The value is never null for fulltext queries
+    Fulltext(dsl::Column<'a>, QueryValue<'a>),
+}
+
+impl<'a> Filter<'a> {
+    pub fn main(
+        layout: &'a Layout,
+        table: dsl::Table<'a>,
+        filter: &'a EntityFilter,
+        block: BlockNumber,
+    ) -> Result<Self, StoreError> {
+        Self::new(layout, table, filter, block, ColumnQual::Main)
+    }
+
+    fn new(
+        layout: &'a Layout,
+        table: dsl::Table<'a>,
+        filter: &'a EntityFilter,
+        block: BlockNumber,
+        qual: ColumnQual,
+    ) -> Result<Self, StoreError> {
+        fn column_and_value<'v>(
+            table: dsl::Table<'v>,
+            attr: &str,
+            value: &'v Value,
+        ) -> Result<(dsl::Column<'v>, QueryValue<'v>), StoreError> {
+            let column = table.column_for_field(attr)?;
+            let value = QueryValue::new(value, column.column_type())?;
+            let column = table.column_for_field(attr)?;
+            Ok((column, value))
+        }
+
+        fn starts_or_ends_with<'s>(
+            table: dsl::Table<'s>,
+            attr: &str,
+            value: &Value,
+            op: &'static str,
+            starts_with: bool,
+        ) -> Result<Filter<'s>, StoreError> {
+            let column = table.column_for_field(attr)?;
+
+            match value {
+                Value::String(s) => {
+                    let pattern = if starts_with {
+                        format!("{}%", s)
+                    } else {
+                        format!("%{}", s)
+                    };
+                    Ok(Filter::StartsOrEndsWith {
+                        column,
+                        op,
+                        pattern,
+                    })
                 }
-                self.with(filter).walk_ast(out.reborrow())?;
+                Value::Bool(_)
+                | Value::BigInt(_)
+                | Value::Bytes(_)
+                | Value::BigDecimal(_)
+                | Value::Timestamp(_)
+                | Value::Int(_)
+                | Value::Int8(_)
+                | Value::List(_)
+                | Value::Null => Err(StoreError::UnsupportedFilter(
+                    op.to_owned(),
+                    value.to_string(),
+                )),
             }
-            out.push_sql(")");
-        } else {
-            out.push_sql(on_empty);
         }
-        Ok(())
-    }
 
-    fn contains(
-        &self,
-        attribute: &Attribute,
-        value: &Value,
-        negated: bool,
-        strict: bool,
-        mut out: AstPass<Pg>,
-    ) -> QueryResult<()> {
-        let column = self.column(attribute);
-        let operation = match (strict, negated) {
-            (true, true) => " not like ",
-            (true, false) => " like ",
-            (false, true) => " not ilike ",
-            (false, false) => " ilike ",
-        };
-        match value {
-            Value::String(s) => {
-                out.push_sql(self.table_prefix);
-                out.push_identifier(column.name.as_str())?;
-                out.push_sql(operation);
-                if s.starts_with('%') || s.ends_with('%') {
-                    out.push_bind_param::<Text, _>(s)?;
+        fn cmp<'s>(
+            table: dsl::Table<'s>,
+            attr: &str,
+            op: Comparison,
+            value: &'s Value,
+        ) -> Result<Filter<'s>, StoreError> {
+            let column = table.column_for_field(attr)?;
+
+            op.suitable(value)?;
+
+            if column.use_prefix_comparison() && !value.is_null() {
+                let column_type = column.column_type();
+                PrefixComparison::new(op, column, column_type, value).map(Filter::PrefixCmp)
+            } else {
+                let value = QueryValue::new(value, column.column_type())?;
+                Ok(Filter::Cmp(column, op, value))
+            }
+        }
+
+        fn contains<'s>(
+            table: dsl::Table<'s>,
+            attr: &str,
+            op: ContainsOp,
+            value: &'s Value,
+        ) -> Result<Filter<'s>, StoreError> {
+            let column = table.column_for_field(attr)?;
+
+            // Case-insensitive operations only make sense for String columns.
+            // Other types (Bytes, BigInt, Int, etc.) don't have a concept of
+            // case and would fail at the SQL level (e.g. `bytea ~~* bytea`).
+            if matches!(op, ContainsOp::ILike | ContainsOp::NotILike)
+                && !matches!(column.column_type(), ColumnType::String)
+            {
+                let filter = if op.negated() {
+                    "not_contains_nocase"
                 } else {
-                    let s = format!("%{}%", s);
-                    out.push_bind_param::<Text, _>(&s)?;
+                    "contains_nocase"
+                };
+                return Err(StoreError::UnsupportedFilter(
+                    filter.to_owned(),
+                    value.to_string(),
+                ));
+            }
+
+            let pattern = QueryValue::new(value, column.column_type())?;
+            let pattern = match &pattern.value {
+                SqlValue::String(s) => {
+                    if s.starts_with('%') || s.ends_with('%') {
+                        pattern
+                    } else {
+                        let s = format!("%{}%", s);
+                        QueryValue {
+                            value: SqlValue::String(s),
+                            column_type: pattern.column_type,
+                        }
+                    }
+                }
+                SqlValue::Text(s) => {
+                    if s.starts_with('%') || s.ends_with('%') {
+                        pattern
+                    } else {
+                        let s = format!("%{}%", s);
+                        QueryValue {
+                            value: SqlValue::String(s),
+                            column_type: pattern.column_type,
+                        }
+                    }
                 }
+                SqlValue::Int(_)
+                | SqlValue::Int8(_)
+                | SqlValue::Timestamp(_)
+                | SqlValue::Numeric(_)
+                | SqlValue::Numerics(_)
+                | SqlValue::Bool(_)
+                | SqlValue::List(_)
+                | SqlValue::Null
+                | SqlValue::Bytes(_)
+                | SqlValue::Binary(_) => pattern,
+            };
+            Ok(Filter::Contains {
+                column,
+                op,
+                pattern,
+            })
+        }
+
+        use Comparison as C;
+        use ContainsOp as K;
+        use EntityFilter::*;
+        use Filter as F;
+        match filter {
+            And(filters) => Ok(F::And(
+                filters
+                    .iter()
+                    .map(|f| F::new(layout, table, f, block, qual))
+                    .collect::<Result<_, _>>()?,
+            )),
+            Or(filters) => Ok(F::Or(
+                filters
+                    .iter()
+                    .map(|f| F::new(layout, table, f, block, qual))
+                    .collect::<Result<_, _>>()?,
+            )),
+            Equal(attr, value) => cmp(table, attr, C::Equal, value),
+            Not(attr, value) => cmp(table, attr, C::NotEqual, value),
+            GreaterThan(attr, value) => cmp(table, attr, C::Greater, value),
+            LessThan(attr, value) => cmp(table, attr, C::Less, value),
+            GreaterOrEqual(attr, value) => cmp(table, attr, C::GreaterOrEqual, value),
+            LessOrEqual(attr, value) => cmp(table, attr, C::LessOrEqual, value),
+            In(attr, values) => {
+                let column = table.column_for_field(attr.as_str())?;
+                let values = QueryValue::many(values, column.column_type())?;
+                Ok(F::In(column, values))
             }
-            Value::Bytes(b) => {
-                out.push_sql("position(");
-                out.push_bind_param::<Binary, _>(&b.as_slice())?;
-                out.push_sql(" in ");
-                out.push_sql(self.table_prefix);
-                out.push_identifier(column.name.as_str())?;
-                if negated {
-                    out.push_sql(") = 0")
-                } else {
-                    out.push_sql(") > 0");
+            NotIn(attr, values) => {
+                let column = table.column_for_field(attr.as_str())?;
+                let values = QueryValue::many(values, column.column_type())?;
+                Ok(F::NotIn(column, values))
+            }
+            Contains(attr, value) => contains(table, attr, K::Like, value),
+            ContainsNoCase(attr, value) => contains(table, attr, K::ILike, value),
+            NotContains(attr, value) => contains(table, attr, K::NotLike, value),
+            NotContainsNoCase(attr, value) => contains(table, attr, K::NotILike, value),
+
+            StartsWith(attr, value) => starts_or_ends_with(table, attr, value, " like ", true),
+            StartsWithNoCase(attr, value) => {
+                starts_or_ends_with(table, attr, value, " ilike ", true)
+            }
+            NotStartsWith(attr, value) => {
+                starts_or_ends_with(table, attr, value, " not like ", true)
+            }
+            NotStartsWithNoCase(attr, value) => {
+                starts_or_ends_with(table, attr, value, " not ilike ", true)
+            }
+            EndsWith(attr, value) => starts_or_ends_with(table, attr, value, " like ", false),
+            EndsWithNoCase(attr, value) => {
+                starts_or_ends_with(table, attr, value, " ilike ", false)
+            }
+            NotEndsWith(attr, value) => {
+                starts_or_ends_with(table, attr, value, " not like ", false)
+            }
+            NotEndsWithNoCase(attr, value) => {
+                starts_or_ends_with(table, attr, value, " not ilike ", false)
+            }
+
+            ChangeBlockGte(num) => Ok(F::ChangeBlockGte(table.changed_since(*num))),
+            Child(child) => {
+                if !qual.allow_child() {
+                    return Err(StoreError::ChildFilterNestingNotSupportedError(
+                        child.attr.to_string(),
+                        filter.to_string(),
+                    ));
                 }
+                let child = QueryChild::new(layout, table, child, block)?;
+                Ok(F::Child(Box::new(child)))
             }
-            Value::List(_) => {
-                if negated {
-                    out.push_sql(" not ");
-                    out.push_sql(self.table_prefix);
-                    out.push_identifier(column.name.as_str())?;
-                    out.push_sql(" && ");
-                } else {
-                    out.push_sql(self.table_prefix);
-                    out.push_identifier(column.name.as_str())?;
-                    out.push_sql(" @> ");
+            Fulltext(attr, value) => {
+                let (column, value) = column_and_value(table, attr, value)?;
+                if value.is_null() {
+                    return Err(StoreError::UnsupportedFilter(
+                        "fulltext".to_owned(),
+                        value.to_string(),
+                    ));
                 }
-                QueryValue(value, &column.column_type).walk_ast(out)?;
-            }
-            Value::Null
-            | Value::BigDecimal(_)
-            | Value::Int(_)
-            | Value::Int8(_)
-            | Value::Bool(_)
-            | Value::BigInt(_) => {
-                let filter = match negated {
-                    false => "contains",
-                    true => "not_contains",
-                };
-                return Err(UnsupportedFilter {
-                    filter: filter.to_owned(),
-                    value: value.clone(),
+                Ok(F::Fulltext(column, value))
+            }
+        }
+    }
+
+    fn binary_op<'b>(
+        filters: &'b [Filter],
+        op: &'static str,
+        on_empty: &'static str,
+        mut out: AstPass<'_, 'b, Pg>,
+    ) -> QueryResult<()> {
+        if !filters.is_empty() {
+            out.push_sql("(");
+            for (i, filter) in filters.iter().enumerate() {
+                if i > 0 {
+                    out.push_sql(op);
                 }
-                .into());
+                filter.walk_ast(out.reborrow())?;
             }
+            out.push_sql(")");
+        } else {
+            out.push_sql(on_empty);
         }
         Ok(())
     }
 
-    fn equals(
-        &self,
-        attribute: &Attribute,
-        value: &Value,
+    fn cmp<'b>(
+        column: &'b dsl::Column<'b>,
+        qv: &'b QueryValue<'b>,
         op: Comparison,
-        mut out: AstPass<Pg>,
+        mut out: AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
-        let column = self.column(attribute);
-
-        if matches!(value, Value::Null) {
+        if qv.is_null() {
             // Deal with nulls first since they always need special
             // treatment
-            out.push_identifier(column.name.as_str())?;
+            column.walk_ast(out.reborrow())?;
             match op {
                 Comparison::Equal => out.push_sql(" is null"),
                 Comparison::NotEqual => out.push_sql(" is not null"),
-                _ => unreachable!("we only call equals with '=' or '!='"),
+                _ => unreachable!("we check that nulls are only compard with '=' or '!='"),
             }
-        } else if column.use_prefix_comparison {
-            PrefixComparison::new(op, column, value)?.walk_ast(out.reborrow())?;
-        } else if column.is_fulltext() {
-            out.push_sql(self.table_prefix);
-            out.push_identifier(column.name.as_str())?;
-            out.push_sql(Comparison::Match.as_str());
-            QueryValue(value, &column.column_type).walk_ast(out)?;
         } else {
-            out.push_sql(self.table_prefix);
-            out.push_identifier(column.name.as_str())?;
+            column.walk_ast(out.reborrow())?;
             out.push_sql(op.as_str());
-            QueryValue(value, &column.column_type).walk_ast(out)?;
+            qv.walk_ast(out)?;
         }
         Ok(())
     }
 
-    fn compare(
-        &self,
-        attribute: &Attribute,
-        value: &Value,
-        op: Comparison,
-        mut out: AstPass<Pg>,
+    fn fulltext<'b>(
+        column: &'b dsl::Column<'b>,
+        qv: &'b QueryValue,
+        mut out: AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
-        let column = self.column(attribute);
+        assert!(!qv.is_null());
+        column.walk_ast(out.reborrow())?;
+        out.push_sql(Comparison::Match.as_str());
+        qv.walk_ast(out)
+    }
 
-        if column.use_prefix_comparison {
-            PrefixComparison::new(op, column, value)?.walk_ast(out.reborrow())?;
-        } else {
-            out.push_sql(self.table_prefix);
-            out.push_identifier(column.name.as_str())?;
-            out.push_sql(op.as_str());
-            match value {
-                Value::BigInt(_)
-                | Value::Bytes(_)
-                | Value::BigDecimal(_)
-                | Value::Int(_)
-                | Value::Int8(_)
-                | Value::String(_) => QueryValue(value, &column.column_type).walk_ast(out)?,
-                Value::Bool(_) | Value::List(_) | Value::Null => {
-                    return Err(UnsupportedFilter {
-                        filter: op.as_str().to_owned(),
-                        value: value.clone(),
+    fn contains<'b>(
+        column: &'b dsl::Column<'b>,
+        op: &'b ContainsOp,
+        qv: &'b QueryValue,
+        mut out: AstPass<'_, 'b, Pg>,
+    ) -> QueryResult<()> {
+        match &qv.value {
+            SqlValue::String(_) | SqlValue::Text(_) => {
+                column.walk_ast(out.reborrow())?;
+                op.walk_ast(out.reborrow())?;
+                qv.walk_ast(out.reborrow())?;
+            }
+            SqlValue::Bytes(b) => {
+                out.push_sql("position(");
+                out.push_bind_param::<Binary, _>(b)?;
+                out.push_sql(" in ");
+                column.walk_ast(out.reborrow())?;
+                if op.negated() {
+                    out.push_sql(") = 0")
+                } else {
+                    out.push_sql(") > 0");
+                }
+            }
+            SqlValue::Binary(b) => {
+                out.push_sql("position(");
+                out.push_bind_param::<Binary, _>(b)?;
+                out.push_sql(" in ");
+                column.walk_ast(out.reborrow())?;
+                if op.negated() {
+                    out.push_sql(") = 0")
+                } else {
+                    out.push_sql(") > 0");
+                }
+            }
+            SqlValue::List(_) | SqlValue::Numerics(_) => match op {
+                // For case-insensitive operations
+                ContainsOp::ILike | ContainsOp::NotILike => {
+                    if op.negated() {
+                        out.push_sql(" not ");
                     }
-                    .into());
+                    out.push_sql("exists (select 1 from unnest(");
+                    column.walk_ast(out.reborrow())?;
+                    out.push_sql(") as elem where elem ilike any(");
+                    qv.walk_ast(out.reborrow())?;
+                    out.push_sql("))");
+                }
+                _ => {
+                    // For case-sensitive operations
+                    if op.negated() {
+                        out.push_sql(" not ");
+                        column.walk_ast(out.reborrow())?;
+                        out.push_sql(" && ");
+                    } else {
+                        column.walk_ast(out.reborrow())?;
+                        out.push_sql(" @> ");
+                    }
+                    qv.walk_ast(out)?;
+                }
+            },
+            SqlValue::Null
+            | SqlValue::Bool(_)
+            | SqlValue::Numeric(_)
+            | SqlValue::Timestamp(_)
+            | SqlValue::Int(_)
+            | SqlValue::Int8(_) => {
+                let filter = match op.negated() {
+                    false => "contains",
+                    true => "not_contains",
+                };
+                return Err(UnsupportedFilter {
+                    filter: filter.to_owned(),
+                    value: qv.value.to_string(),
                 }
+                .into());
             }
         }
         Ok(())
     }
 
-    fn in_array(
-        &self,
-        attribute: &Attribute,
-        values: &[Value],
+    fn in_array<'b>(
+        column: &'b dsl::Column<'b>,
+        values: &'b [QueryValue],
         negated: bool,
-        mut out: AstPass<Pg>,
+        mut out: AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
-        let column = self.column(attribute);
-
         if values.is_empty() {
             out.push_sql("false");
             return Ok(());
@@ -1300,16 +1737,15 @@ impl<'a> QueryFilter<'a> {
         // is a syntax error
         //
         // Because we checked above, one of these two will be true
-        let have_nulls = values.iter().any(|value| value == &Value::Null);
-        let have_non_nulls = values.iter().any(|value| value != &Value::Null);
+        let have_nulls = values.iter().any(|qv| qv.is_null());
+        let have_non_nulls = values.iter().any(|qv| !qv.is_null());
 
         if have_nulls && have_non_nulls {
             out.push_sql("(");
         }
 
         if have_nulls {
-            out.push_sql(self.table_prefix);
-            out.push_identifier(column.name.as_str())?;
+            column.walk_ast(out.reborrow())?;
             if negated {
                 out.push_sql(" is not null");
             } else {
@@ -1322,10 +1758,13 @@ impl<'a> QueryFilter<'a> {
         }
 
         if have_non_nulls {
-            if column.use_prefix_comparison
-                && values.iter().all(|v| match v {
-                    Value::String(s) => s.len() < STRING_PREFIX_SIZE,
-                    Value::Bytes(b) => b.len() < BYTE_ARRAY_PREFIX_SIZE,
+            if column.use_prefix_comparison()
+                && PrefixType::new(column).is_ok()
+                && values.iter().all(|v| match &v.value {
+                    SqlValue::Text(s) => s.len() < STRING_PREFIX_SIZE,
+                    SqlValue::String(s) => s.len() < STRING_PREFIX_SIZE,
+                    SqlValue::Binary(b) => b.len() < BYTE_ARRAY_PREFIX_SIZE,
+                    SqlValue::Bytes(b) => b.len() < BYTE_ARRAY_PREFIX_SIZE,
                     _ => false,
                 })
             {
@@ -1335,25 +1774,20 @@ impl<'a> QueryFilter<'a> {
                 // query optimizer
                 // See PrefixComparison for a more detailed discussion of what
                 // is happening here
-                PrefixType::new(column)?.push_column_prefix(&mut out)?;
+                PrefixType::new(column)?.push_column_prefix(column, &mut out.reborrow())?;
             } else {
-                out.push_sql(self.table_prefix);
-                out.push_identifier(column.name.as_str())?;
+                column.walk_ast(out.reborrow())?;
             }
             if negated {
                 out.push_sql(" not in (");
             } else {
                 out.push_sql(" in (");
             }
-            for (i, value) in values
-                .iter()
-                .filter(|value| value != &&Value::Null)
-                .enumerate()
-            {
+            for (i, qv) in values.iter().filter(|qv| !qv.is_null()).enumerate() {
                 if i > 0 {
                     out.push_sql(", ");
                 }
-                QueryValue(value, &column.column_type).walk_ast(out.reborrow())?;
+                qv.walk_ast(out.reborrow())?;
             }
             out.push_sql(")");
         }
@@ -1363,178 +1797,230 @@ impl<'a> QueryFilter<'a> {
         }
         Ok(())
     }
+}
 
-    fn filter_block_gte(
-        &self,
-        block_number_gte: &BlockNumber,
-        mut out: AstPass<Pg>,
-    ) -> QueryResult<()> {
-        BlockRangeColumn::new(self.table, "c.", *block_number_gte).changed_since(&mut out)
-    }
+// A somewhat concise string representation of a filter that is useful for
+// debugging when `walk_ast` fails
+impl<'a> fmt::Display for Filter<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Filter::*;
 
-    fn starts_or_ends_with(
-        &self,
-        attribute: &Attribute,
-        value: &Value,
-        op: &str,
-        starts_with: bool,
-        mut out: AstPass<Pg>,
-    ) -> QueryResult<()> {
-        let column = self.column(attribute);
-
-        out.push_sql(self.table_prefix);
-        out.push_identifier(column.name.as_str())?;
-        out.push_sql(op);
-        match value {
-            Value::String(s) => {
-                let s = if starts_with {
-                    format!("{}%", s)
-                } else {
-                    format!("%{}", s)
+        match self {
+            And(fs) => {
+                write!(f, "{}", fs.iter().map(|f| f.to_string()).join(" and "))
+            }
+            Or(fs) => {
+                write!(f, "{}", fs.iter().map(|f| f.to_string()).join(" or "))
+            }
+            Fulltext(a, v) => write!(f, "{a} = {v}"),
+            PrefixCmp(PrefixComparison {
+                op,
+                kind: _,
+                column,
+                value,
+            }) => write!(f, "{column} {op} {value}"),
+            Cmp(a, op, v) => write!(f, "{a} {op} {v}"),
+            In(a, vs) => write!(f, "{a} in ({})", vs.iter().map(|v| v.to_string()).join(",")),
+            NotIn(a, vs) => write!(
+                f,
+                "{a} not in ({})",
+                vs.iter().map(|v| v.to_string()).join(",")
+            ),
+            Contains {
+                column,
+                op,
+                pattern,
+            } => {
+                let (neg, case) = match op {
+                    ContainsOp::Like => ("", ""),
+                    ContainsOp::ILike => ("", "i"),
+                    ContainsOp::NotLike => ("!", ""),
+                    ContainsOp::NotILike => ("!", "i"),
                 };
-                out.push_bind_param::<Text, _>(&s)?
-            }
-            Value::Bool(_)
-            | Value::BigInt(_)
-            | Value::Bytes(_)
-            | Value::BigDecimal(_)
-            | Value::Int(_)
-            | Value::Int8(_)
-            | Value::List(_)
-            | Value::Null => {
-                return Err(UnsupportedFilter {
-                    filter: op.to_owned(),
-                    value: value.clone(),
-                }
-                .into());
+                write!(f, "{column} {neg}~ *{pattern}*{case}")
             }
+            StartsOrEndsWith {
+                column,
+                op,
+                pattern,
+            } => {
+                write!(f, "{column} {op} '{pattern}'")
+            }
+            ChangeBlockGte(b) => write!(f, "{}", b),
+            Child(child /* a, et, cf, _ */) => write!(
+                f,
+                "join on {} with {}({})",
+                child.child_column.name(),
+                child.child_from,
+                child.child_filter
+            ),
         }
-        Ok(())
     }
 }
 
-impl<'a> QueryFragment<Pg> for QueryFilter<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+impl<'a> QueryFragment<Pg> for Filter<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
-        use Comparison as c;
-        use EntityFilter::*;
-        match &self.filter {
-            And(filters) => self.binary_op(filters, " and ", " true ", out)?,
-            Or(filters) => self.binary_op(filters, " or ", " false ", out)?,
-
-            Contains(attr, value) => self.contains(attr, value, false, true, out)?,
-            ContainsNoCase(attr, value) => self.contains(attr, value, false, false, out)?,
-            NotContains(attr, value) => self.contains(attr, value, true, true, out)?,
-            NotContainsNoCase(attr, value) => self.contains(attr, value, true, false, out)?,
+        use Filter::*;
+        match self {
+            And(filters) => Self::binary_op(filters, " and ", " true ", out)?,
+            Or(filters) => Self::binary_op(filters, " or ", " false ", out)?,
 
-            Equal(attr, value) | Fulltext(attr, value) => {
-                self.equals(attr, value, c::Equal, out)?
+            Contains {
+                column,
+                op,
+                pattern,
+            } => Self::contains(column, op, pattern, out)?,
+            PrefixCmp(pc) => pc.walk_ast(out)?,
+            Cmp(column, op, value) => Self::cmp(column, value, *op, out)?,
+            Fulltext(column, value) => Self::fulltext(column, value, out)?,
+            In(attr, values) => Self::in_array(attr, values, false, out)?,
+            NotIn(attr, values) => Self::in_array(attr, values, true, out)?,
+            StartsOrEndsWith {
+                column,
+                op,
+                pattern,
+            } => {
+                column.walk_ast(out.reborrow())?;
+                out.push_sql(op);
+                out.push_bind_param::<Text, _>(pattern)?;
             }
-            Not(attr, value) => self.equals(attr, value, c::NotEqual, out)?,
+            ChangeBlockGte(changed_since) => changed_since.walk_ast(out.reborrow())?,
+            Child(child) => child.walk_ast(out)?,
+        }
+        Ok(())
+    }
+}
 
-            GreaterThan(attr, value) => self.compare(attr, value, c::Greater, out)?,
-            LessThan(attr, value) => self.compare(attr, value, c::Less, out)?,
-            GreaterOrEqual(attr, value) => self.compare(attr, value, c::GreaterOrEqual, out)?,
-            LessOrEqual(attr, value) => self.compare(attr, value, c::LessOrEqual, out)?,
+#[derive(Debug, Clone)]
+pub struct FindRangeQuery<'a> {
+    tables: &'a Vec<&'a Table>,
+    causality_region: CausalityRegion,
+    bound_side: BoundSide,
+    imm_range: EntityBlockRange,
+    mut_range: EntityBlockRange,
+}
 
-            In(attr, values) => self.in_array(attr, values, false, out)?,
-            NotIn(attr, values) => self.in_array(attr, values, true, out)?,
+impl<'a> FindRangeQuery<'a> {
+    pub fn new(
+        tables: &'a Vec<&Table>,
+        causality_region: CausalityRegion,
+        bound_side: BoundSide,
+        block_range: Range<BlockNumber>,
+    ) -> Self {
+        let imm_range = EntityBlockRange::new(true, block_range.clone(), bound_side);
+        let mut_range = EntityBlockRange::new(false, block_range, bound_side);
+        Self {
+            tables,
+            causality_region,
+            bound_side,
+            imm_range,
+            mut_range,
+        }
+    }
+}
 
-            StartsWith(attr, value) => {
-                self.starts_or_ends_with(attr, value, " like ", true, out)?
-            }
-            StartsWithNoCase(attr, value) => {
-                self.starts_or_ends_with(attr, value, " ilike ", true, out)?
-            }
-            NotStartsWith(attr, value) => {
-                self.starts_or_ends_with(attr, value, " not like ", true, out)?
-            }
-            NotStartsWithNoCase(attr, value) => {
-                self.starts_or_ends_with(attr, value, " not ilike ", true, out)?
-            }
-            EndsWith(attr, value) => self.starts_or_ends_with(attr, value, " like ", false, out)?,
-            EndsWithNoCase(attr, value) => {
-                self.starts_or_ends_with(attr, value, " ilike ", false, out)?
-            }
-            NotEndsWith(attr, value) => {
-                self.starts_or_ends_with(attr, value, " not like ", false, out)?
-            }
-            NotEndsWithNoCase(attr, value) => {
-                self.starts_or_ends_with(attr, value, " not ilike ", false, out)?
+impl<'a> QueryFragment<Pg> for FindRangeQuery<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+        let mut first = true;
+
+        for table in self.tables.iter() {
+            // the immutable entities don't have upper range and also can't be modified or deleted
+            if matches!(self.bound_side, BoundSide::Lower) || !table.immutable {
+                if first {
+                    first = false;
+                } else {
+                    out.push_sql("\nunion all\n");
+                }
+
+                // Generate
+                //    select '..' as entity, to_jsonb(e.*) as data, {BLOCK_STATEMENT} as block_number
+                //      from schema.table e where ...
+                // Here the {BLOCK_STATEMENT} is 'block$' for immutable tables and either 'lower(block_range)'
+                // or 'upper(block_range)' depending on the bound_side variable.
+                out.push_sql("select ");
+                out.push_bind_param::<Text, _>(table.object.as_str())?;
+                out.push_sql(" as entity, to_jsonb(e.*) as data,");
+                if table.immutable {
+                    self.imm_range.compare_column(&mut out)
+                } else {
+                    self.mut_range.compare_column(&mut out)
+                }
+                // Cast id to bytea to ensure consistent types across UNION
+                // The actual id type can be text, bytea, or numeric depending on the entity
+                out.push_sql("as block_number, ");
+                let pk_column = table.primary_key();
+
+                // We only support entity id types of string, bytes, and int8.
+                match pk_column.column_type {
+                    ColumnType::String => out.push_sql("id::bytea"),
+                    ColumnType::Bytes => out.push_sql("id"),
+                    ColumnType::Int8 => out.push_sql("id::text::bytea"),
+                    _ => out.push_sql("id::bytea"),
+                }
+                out.push_sql(" as id, vid\n");
+                out.push_sql("  from ");
+                out.push_sql(table.qualified_name.as_str());
+                out.push_sql(" e\n  where");
+                // add casuality region to the query
+                if table.has_causality_region {
+                    out.push_sql("causality_region = ");
+                    out.push_bind_param::<Integer, _>(&self.causality_region)?;
+                    out.push_sql(" and ");
+                }
+                if table.immutable {
+                    self.imm_range.contains(&mut out)?;
+                } else {
+                    self.mut_range.contains(&mut out)?;
+                }
             }
-            ChangeBlockGte(block_number) => self.filter_block_gte(block_number, out)?,
-            Child(child) => self.child(
-                &child.attr,
-                &child.entity_type,
-                &child.filter,
-                child.derived,
-                out,
-            )?,
         }
-        Ok(())
-    }
-}
-
-/// A query that finds an entity by key. Used during indexing.
-/// See also `FindManyQuery`.
-#[derive(Debug, Clone, Constructor)]
-pub struct FindQuery<'a> {
-    table: &'a Table,
-    key: &'a EntityKey,
-    block: BlockNumber,
-}
-
-impl<'a> QueryFragment<Pg> for FindQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
-        out.unsafe_to_cache_prepared();
 
-        // Generate
-        //    select '..' as entity, to_jsonb(e.*) as data
-        //      from schema.table e where id = $1
-        out.push_sql("select ");
-        out.push_bind_param::<Text, _>(&self.table.object.as_str())?;
-        out.push_sql(" as entity, to_jsonb(e.*) as data\n");
-        out.push_sql("  from ");
-        out.push_sql(self.table.qualified_name.as_str());
-        out.push_sql(" e\n where ");
-        self.table.primary_key().eq(&self.key.entity_id, &mut out)?;
-        out.push_sql(" and ");
-        if self.table.has_causality_region {
-            out.push_sql("causality_region = ");
-            out.push_bind_param::<Integer, _>(&self.key.causality_region)?;
-            out.push_sql(" and ");
+        if first {
+            // In case we have only immutable entities, the upper range will not create any
+            // select statement. So here we have to generate an SQL statement thet returns
+            // empty result.
+            out.push_sql("select 'dummy_entity' as entity, to_jsonb(1) as data, 1 as block_number, '\\x'::bytea as id, 1 as vid where false");
+        } else {
+            out.push_sql("\norder by block_number, entity, id");
         }
-        BlockRangeColumn::new(self.table, "e.", self.block).contains(&mut out, true)
+
+        Ok(())
     }
 }
 
-impl<'a> QueryId for FindQuery<'a> {
+impl<'a> QueryId for FindRangeQuery<'a> {
     type QueryId = ();
 
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, EntityData> for FindQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<EntityData>> {
-        conn.query_by_name(&self)
-    }
+impl<'a> Query for FindRangeQuery<'a> {
+    type SqlType = Untyped;
 }
 
-impl<'a, Conn> RunQueryDsl<Conn> for FindQuery<'a> {}
+impl<'a, Conn> RunQueryDsl<Conn> for FindRangeQuery<'a> {}
 
 /// Builds a query over a given set of [`Table`]s in an attempt to find updated
 /// and/or newly inserted entities at a given block number; i.e. such that the
 /// block range's lower bound is equal to said block number.
-#[derive(Debug, Clone, Constructor)]
+#[derive(Debug)]
 pub struct FindChangesQuery<'a> {
-    pub(crate) _namespace: &'a Namespace,
     pub(crate) tables: &'a [&'a Table],
-    pub(crate) block: BlockNumber,
+    br_clause: BlockRangeLowerBoundClause<'a>,
+}
+
+impl<'a> FindChangesQuery<'a> {
+    pub fn new(tables: &'a [&'a Table], block: BlockNumber) -> Self {
+        let br_clause = BlockRangeLowerBoundClause::new("e.", block);
+        Self { tables, br_clause }
+    }
 }
 
 impl<'a> QueryFragment<Pg> for FindChangesQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
         for (i, table) in self.tables.iter().enumerate() {
@@ -1542,12 +2028,12 @@ impl<'a> QueryFragment<Pg> for FindChangesQuery<'a> {
                 out.push_sql("\nunion all\n");
             }
             out.push_sql("select ");
-            out.push_bind_param::<Text, _>(&table.object.as_str())?;
+            out.push_bind_param::<Text, _>(table.object.as_str())?;
             out.push_sql(" as entity, to_jsonb(e.*) as data\n");
             out.push_sql("  from ");
             out.push_sql(table.qualified_name.as_str());
             out.push_sql(" e\n where ");
-            BlockRangeLowerBoundClause::new("e.", self.block).walk_ast(out.reborrow())?;
+            self.br_clause.walk_ast(out.reborrow())?;
         }
 
         Ok(())
@@ -1560,10 +2046,8 @@ impl<'a> QueryId for FindChangesQuery<'a> {
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, EntityData> for FindChangesQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<EntityData>> {
-        conn.query_by_name(&self)
-    }
+impl<'a> Query for FindChangesQuery<'a> {
+    type SqlType = Untyped;
 }
 
 impl<'a, Conn> RunQueryDsl<Conn> for FindChangesQuery<'a> {}
@@ -1576,15 +2060,22 @@ impl<'a, Conn> RunQueryDsl<Conn> for FindChangesQuery<'a> {}
 /// query is intented to be used together with [`FindChangesQuery`]; by
 /// combining the results it's possible to see which entities were *actually*
 /// deleted and which ones were just updated.
-#[derive(Debug, Clone, Constructor)]
+#[derive(Debug)]
 pub struct FindPossibleDeletionsQuery<'a> {
-    pub(crate) _namespace: &'a Namespace,
     pub(crate) tables: &'a [&'a Table],
-    pub(crate) block: BlockNumber,
+    br_clause: BlockRangeUpperBoundClause<'a>,
+}
+
+impl<'a> FindPossibleDeletionsQuery<'a> {
+    pub fn new(tables: &'a [&'a Table], block: BlockNumber) -> Self {
+        let br_clause = BlockRangeUpperBoundClause::new("e.", block);
+        Self { tables, br_clause }
+    }
 }
 
 impl<'a> QueryFragment<Pg> for FindPossibleDeletionsQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        let out = &mut out;
         out.unsafe_to_cache_prepared();
 
         for (i, table) in self.tables.iter().enumerate() {
@@ -1592,7 +2083,7 @@ impl<'a> QueryFragment<Pg> for FindPossibleDeletionsQuery<'a> {
                 out.push_sql("\nunion all\n");
             }
             out.push_sql("select ");
-            out.push_bind_param::<Text, _>(&table.object.as_str())?;
+            out.push_bind_param::<Text, _>(table.object.as_str())?;
             out.push_sql(" as entity, ");
             if table.has_causality_region {
                 out.push_sql("causality_region, ");
@@ -1603,7 +2094,7 @@ impl<'a> QueryFragment<Pg> for FindPossibleDeletionsQuery<'a> {
             out.push_sql("  from ");
             out.push_sql(table.qualified_name.as_str());
             out.push_sql(" e\n where ");
-            BlockRangeUpperBoundClause::new("e.", self.block).walk_ast(out.reborrow())?;
+            self.br_clause.walk_ast(out.reborrow())?;
         }
 
         Ok(())
@@ -1616,25 +2107,42 @@ impl<'a> QueryId for FindPossibleDeletionsQuery<'a> {
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, EntityDeletion> for FindPossibleDeletionsQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<EntityDeletion>> {
-        conn.query_by_name(&self)
-    }
+impl<'a> Query for FindPossibleDeletionsQuery<'a> {
+    type SqlType = Untyped;
 }
 
 impl<'a, Conn> RunQueryDsl<Conn> for FindPossibleDeletionsQuery<'a> {}
 
-#[derive(Debug, Clone, Constructor)]
+#[derive(Debug)]
 pub struct FindManyQuery<'a> {
-    pub(crate) tables: Vec<(&'a Table, CausalityRegion)>,
+    pub(crate) tables: Vec<(&'a Table, CausalityRegion, BlockRangeColumn<'a>)>,
 
     // Maps object name to ids.
     pub(crate) ids_for_type: &'a BTreeMap<(EntityType, CausalityRegion), IdList>,
-    pub(crate) block: BlockNumber,
+}
+
+impl<'a> FindManyQuery<'a> {
+    pub fn new(
+        tables: Vec<(&'a Table, CausalityRegion)>,
+        ids_for_type: &'a BTreeMap<(EntityType, CausalityRegion), IdList>,
+        block: BlockNumber,
+    ) -> Self {
+        let tables = tables
+            .into_iter()
+            .map(|(table, cr)| {
+                let br_column = BlockRangeColumn::new(table, "e.", block);
+                (table, cr, br_column)
+            })
+            .collect();
+        Self {
+            tables,
+            ids_for_type,
+        }
+    }
 }
 
 impl<'a> QueryFragment<Pg> for FindManyQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
         // Generate
@@ -1645,26 +2153,24 @@ impl<'a> QueryFragment<Pg> for FindManyQuery<'a> {
         //      from schema.<table1> e where {id.is_in($ids1))
         //    union all
         //    ...
-        for (i, (table, cr)) in self.tables.iter().enumerate() {
+        for (i, (table, cr, br_column)) in self.tables.iter().enumerate() {
             if i > 0 {
                 out.push_sql("\nunion all\n");
             }
             out.push_sql("select ");
-            out.push_bind_param::<Text, _>(&table.object.as_str())?;
+            out.push_bind_param::<Text, _>(table.object.as_str())?;
             out.push_sql(" as entity, to_jsonb(e.*) as data\n");
             out.push_sql("  from ");
             out.push_sql(table.qualified_name.as_str());
             out.push_sql(" e\n where ");
-            table
-                .primary_key()
-                .is_in(&self.ids_for_type[&(table.object.clone(), *cr)], &mut out)?;
+            id_is_in(&self.ids_for_type[&(table.object.clone(), *cr)], &mut out)?;
             out.push_sql(" and ");
             if table.has_causality_region {
                 out.push_sql("causality_region = ");
                 out.push_bind_param::<Integer, _>(cr)?;
                 out.push_sql(" and ");
             }
-            BlockRangeColumn::new(table, "e.", self.block).contains(&mut out, true)?;
+            br_column.contains(&mut out, true)?;
         }
         Ok(())
     }
@@ -1676,26 +2182,41 @@ impl<'a> QueryId for FindManyQuery<'a> {
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, EntityData> for FindManyQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<EntityData>> {
-        conn.query_by_name(&self)
-    }
+impl<'a> Query for FindManyQuery<'a> {
+    type SqlType = Untyped;
 }
 
 impl<'a, Conn> RunQueryDsl<Conn> for FindManyQuery<'a> {}
 
 /// A query that finds an entity by key. Used during indexing.
 /// See also `FindManyQuery`.
-#[derive(Debug, Clone, Constructor)]
+#[derive(Debug)]
 pub struct FindDerivedQuery<'a> {
     table: &'a Table,
     derived_query: &'a DerivedEntityQuery,
-    block: BlockNumber,
-    excluded_keys: &'a Vec<EntityKey>,
+    excluded_keys: IdList,
+    br_column: BlockRangeColumn<'a>,
+}
+
+impl<'a> FindDerivedQuery<'a> {
+    pub fn new(
+        table: &'a Table,
+        derived_query: &'a DerivedEntityQuery,
+        block: BlockNumber,
+        excluded_keys: IdList,
+    ) -> Self {
+        let br_column = BlockRangeColumn::new(table, "e.", block);
+        Self {
+            table,
+            derived_query,
+            excluded_keys,
+            br_column,
+        }
+    }
 }
 
 impl<'a> QueryFragment<Pg> for FindDerivedQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
         let DerivedEntityQuery {
@@ -1709,23 +2230,19 @@ impl<'a> QueryFragment<Pg> for FindDerivedQuery<'a> {
         //    select '..' as entity, to_jsonb(e.*) as data
         //      from schema.table e where field = $1
         out.push_sql("select ");
-        out.push_bind_param::<Text, _>(&self.table.object.as_str())?;
+        out.push_bind_param::<Text, _>(self.table.object.as_str())?;
         out.push_sql(" as entity, to_jsonb(e.*) as data\n");
         out.push_sql("  from ");
         out.push_sql(self.table.qualified_name.as_str());
         out.push_sql(" e\n where ");
-
-        if self.excluded_keys.len() > 0 {
-            let primary_key = self.table.primary_key();
-            out.push_identifier(primary_key.name.as_str())?;
-            out.push_sql(" not in (");
-            for (i, value) in self.excluded_keys.iter().enumerate() {
-                if i > 0 {
-                    out.push_sql(", ");
-                }
-
-                value.entity_id.push_bind_param(&mut out)?;
-            }
+        // This clause with an empty array would filter out everything
+        if !self.excluded_keys.is_empty() {
+            out.push_identifier(&self.table.primary_key().name)?;
+            // For truly gigantic `excluded_keys` lists, this will be slow, and
+            // we should rewrite this query to use a CTE or a temp table to hold
+            // the excluded keys.
+            out.push_sql(" != any(");
+            self.excluded_keys.push_bind_param(&mut out)?;
             out.push_sql(") and ");
         }
         out.push_identifier(entity_field.to_snake_case().as_str())?;
@@ -1737,7 +2254,7 @@ impl<'a> QueryFragment<Pg> for FindDerivedQuery<'a> {
             out.push_bind_param::<Integer, _>(causality_region)?;
             out.push_sql(" and ");
         }
-        BlockRangeColumn::new(self.table, "e.", self.block).contains(&mut out, false)
+        self.br_column.contains(&mut out, false)
     }
 }
 
@@ -1747,57 +2264,157 @@ impl<'a> QueryId for FindDerivedQuery<'a> {
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, EntityData> for FindDerivedQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<EntityData>> {
-        conn.query_by_name(&self)
-    }
+impl<'a> Query for FindDerivedQuery<'a> {
+    type SqlType = Untyped;
 }
 
 impl<'a, Conn> RunQueryDsl<Conn> for FindDerivedQuery<'a> {}
 
+/// One value for inserting into a column of a table
 #[derive(Debug)]
-struct FulltextValues<'a>(HashMap<&'a Id, Vec<(&'a str, Value)>>);
-
-impl<'a> FulltextValues<'a> {
-    fn new(table: &'a Table, rows: &'a WriteChunk<'a>) -> Self {
-        let mut map: HashMap<&Id, Vec<(&str, Value)>> = HashMap::new();
-        for column in table.columns.iter().filter(|column| column.is_fulltext()) {
-            for row in rows {
-                if let Some(fields) = column.fulltext_fields.as_ref() {
-                    let fulltext_field_values = fields
-                        .iter()
-                        .filter_map(|field| row.entity.get(field))
-                        .cloned()
-                        .collect::<Vec<Value>>();
-                    if !fulltext_field_values.is_empty() {
-                        map.entry(row.id)
-                            .or_default()
-                            .push((column.field.as_str(), Value::List(fulltext_field_values)));
-                    }
-                }
+enum InsertValue<'a> {
+    Value(QueryValue<'a>),
+    Fulltext(Vec<&'a String>, &'a FulltextConfig),
+}
+
+impl<'a> QueryFragment<Pg> for InsertValue<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        match self {
+            InsertValue::Value(qv) => qv.walk_ast(out),
+            InsertValue::Fulltext(qvs, config) => {
+                process_vec_ast(qvs, &mut out, config.language.as_sql())?;
+                Ok(())
             }
         }
-        Self(map)
     }
+}
 
-    fn get(&self, entity_id: &Id, field: &str) -> &Value {
-        self.0
-            .get(entity_id)
-            .and_then(|values| {
-                values
+/// One row for inserting into a table; values are in the same order as in
+/// `InsertQuery.unique_columns``
+#[derive(Debug)]
+struct InsertRow<'a> {
+    values: Vec<InsertValue<'a>>,
+    br_value: BlockRangeValue,
+    causality_region: CausalityRegion,
+    vid: i64,
+}
+
+impl<'a> InsertRow<'a> {
+    fn new(
+        columns: &[&'a Column],
+        row: EntityWrite<'a>,
+        table: &'a Table,
+    ) -> Result<Self, StoreError> {
+        let mut values = Vec::with_capacity(columns.len());
+        for column in columns {
+            let iv = if let Some(fields) = column.fulltext_fields.as_ref() {
+                let fulltext_field_values: Vec<_> = fields
                     .iter()
-                    .find(|(key, _)| field == *key)
-                    .map(|(_, value)| value)
-            })
-            .unwrap_or(&NULL)
+                    .filter_map(|field| row.entity.get(field).filter(|v| !v.is_null()))
+                    .map(|value| match value {
+                        Value::String(s) => Ok(s),
+                        _ => Err(internal_error!(
+                            "fulltext fields must be strings but got {:?}",
+                            value
+                        )),
+                    })
+                    .collect::<Result<_, _>>()?;
+                if let ColumnType::TSVector(config) = &column.column_type {
+                    InsertValue::Fulltext(fulltext_field_values, config)
+                } else {
+                    return Err(StoreError::FulltextColumnMissingConfig);
+                }
+            } else {
+                let value = row.entity.get(&column.field).unwrap_or(&NULL);
+                let qv = QueryValue::new(value, &column.column_type)?;
+                InsertValue::Value(qv)
+            };
+            values.push(iv);
+        }
+        let br_value = BlockRangeValue::new(table, row.block, row.end);
+        let causality_region = row.causality_region;
+        let vid = row.entity.vid();
+        Ok(Self {
+            values,
+            br_value,
+            causality_region,
+            vid,
+        })
+    }
+
+    /// Build an `InsertRow` from a `RestoreRow` (Parquet restore path).
+    ///
+    /// Unlike `new()`, this looks up values by SQL column name rather than
+    /// entity field name, since `RestoreRow.values` is keyed by SQL name.
+    /// Fulltext columns are regenerated from their source fields.
+    fn from_restore(
+        columns: &[&'a Column],
+        row: &'a RestoreRow,
+        table: &'a Table,
+    ) -> Result<Self, StoreError> {
+        let mut values = Vec::with_capacity(columns.len());
+        for column in columns {
+            let iv = if let Some(fields) = column.fulltext_fields.as_ref() {
+                // Fulltext columns: `fields` contains GraphQL field names,
+                // but `RestoreRow.values` is keyed by SQL column names.
+                // Resolve via the table's columns.
+                let fulltext_field_values: Vec<_> = fields
+                    .iter()
+                    .filter_map(|field_name| {
+                        table
+                            .columns
+                            .iter()
+                            .find(|c| c.field.as_str() == field_name.as_str())
+                            .and_then(|src_col| {
+                                row.values
+                                    .iter()
+                                    .find(|(w, _)| w.as_str() == src_col.name.as_str())
+                                    .map(|(_, v)| v)
+                                    .filter(|v| !v.is_null())
+                            })
+                    })
+                    .map(|value| match value {
+                        Value::String(s) => Ok(s),
+                        _ => Err(internal_error!(
+                            "fulltext fields must be strings but got {:?}",
+                            value
+                        )),
+                    })
+                    .collect::<Result<_, _>>()?;
+                if let ColumnType::TSVector(config) = &column.column_type {
+                    InsertValue::Fulltext(fulltext_field_values, config)
+                } else {
+                    return Err(StoreError::FulltextColumnMissingConfig);
+                }
+            } else {
+                let value = row
+                    .values
+                    .iter()
+                    .find(|(w, _)| w.as_str() == column.name.as_str())
+                    .map(|(_, v)| v)
+                    .unwrap_or(&NULL);
+                let qv = QueryValue::new(value, &column.column_type)?;
+                InsertValue::Value(qv)
+            };
+            values.push(iv);
+        }
+        let end = row.block_range_end.flatten();
+        let br_value = BlockRangeValue::new(table, row.block, end);
+        let causality_region = CausalityRegion::from(row.causality_region.unwrap_or(0));
+        let vid = row.vid;
+        Ok(Self {
+            values,
+            br_value,
+            causality_region,
+            vid,
+        })
     }
 }
 
 #[derive(Debug)]
 pub struct InsertQuery<'a> {
     table: &'a Table,
-    rows: &'a WriteChunk<'a>,
-    fulltext_values: FulltextValues<'a>,
+    rows: Vec<InsertRow<'a>>,
     unique_columns: Vec<&'a Column>,
 }
 
@@ -1807,39 +2424,61 @@ impl<'a> InsertQuery<'a> {
             for column in table.columns.iter() {
                 if !column.is_nullable() && !row.entity.contains_key(&column.field) {
                     return Err(StoreError::QueryExecutionError(format!(
-                    "can not insert entity {}[{}] since value for non-nullable attribute {} is missing. \
+                        "can not insert entity {}[{}] since value for non-nullable attribute {} is missing. \
                      To fix this, mark the attribute as nullable in the GraphQL schema or change the \
                      mapping code to always set this attribute.",
-                    table.object, row.id, column.field
-                )));
+                        table.object, row.id, column.field
+                    )));
                 }
             }
         }
 
-        let fulltext_values = FulltextValues::new(table, rows);
-        let unique_columns = InsertQuery::unique_columns(table, rows, &fulltext_values);
+        let unique_columns = InsertQuery::unique_columns(table, rows);
+
+        let rows: Vec<_> = rows
+            .iter()
+            .map(|row| InsertRow::new(&unique_columns, row, table))
+            .collect::<Result<_, _>>()?;
 
         Ok(InsertQuery {
             table,
             rows,
-            fulltext_values,
             unique_columns,
         })
     }
 
-    /// Build the column name list using the subset of all keys among present entities.
-    fn unique_columns(
+    /// Build an `InsertQuery` from restore rows (Parquet restore path).
+    ///
+    /// All data columns from the dump are present, so `unique_columns`
+    /// includes every column in the table. Fulltext columns are
+    /// regenerated from their source fields.
+    pub fn for_restore(
         table: &'a Table,
-        rows: &'a WriteChunk<'a>,
-        fulltext_values: &FulltextValues<'a>,
-    ) -> Vec<&'a Column> {
+        rows: &'a [RestoreRow],
+    ) -> Result<InsertQuery<'a>, StoreError> {
+        let unique_columns: Vec<&Column> = table.columns.iter().collect();
+
+        let rows: Vec<_> = rows
+            .iter()
+            .map(|row| InsertRow::from_restore(&unique_columns, row, table))
+            .collect::<Result<_, _>>()?;
+
+        Ok(InsertQuery {
+            table,
+            rows,
+            unique_columns,
+        })
+    }
+
+    /// Build the column name list using the subset of all keys among present entities.
+    fn unique_columns(table: &'a Table, rows: &'a WriteChunk<'a>) -> Vec<&'a Column> {
         table
             .columns
             .iter()
             .filter(|column| {
                 rows.iter().any(|row| {
-                    if column.is_fulltext() {
-                        !fulltext_values.get(row.id, &column.field).is_null()
+                    if let Some(fields) = column.fulltext_fields.as_ref() {
+                        fields.iter().any(|field| row.entity.contains_key(field))
                     } else {
                         row.entity.get(&column.field).is_some()
                     }
@@ -1854,7 +2493,14 @@ impl<'a> InsertQuery<'a> {
     /// query, and depends on what columns `table` has and how they get put
     /// into the query
     pub fn chunk_size(table: &Table) -> usize {
-        let mut count = 1;
+        // We always have one column for the block number/range
+        let mut count = 1 + ENV_VARS.store.insert_extra_cols;
+        if table.has_causality_region {
+            count += 1;
+        }
+        if table.object.has_vid_seq() {
+            count += 1;
+        }
         for column in table.columns.iter() {
             // This code depends closely on how `walk_ast` and `QueryValue`
             // put values into bind variables
@@ -1869,31 +2515,15 @@ impl<'a> InsertQuery<'a> {
         }
         POSTGRES_MAX_PARAMETERS / count
     }
-
-    /// Output the literal value of the block range `[block,..)`, mostly for
-    /// generating an insert statement containing the block range column
-    pub fn literal_range_current(
-        table: &Table,
-        block: BlockNumber,
-        end: Option<BlockNumber>,
-        out: &mut AstPass<Pg>,
-    ) -> QueryResult<()> {
-        if table.immutable {
-            out.push_bind_param::<Integer, _>(&block)
-        } else {
-            let block_range: BlockRange = match end {
-                Some(end) => (block..end).into(),
-                None => (block..).into(),
-            };
-            out.push_bind_param::<Range<Integer>, _>(&block_range)
-        }
-    }
 }
 
 impl<'a> QueryFragment<Pg> for InsertQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        let out = &mut out;
         out.unsafe_to_cache_prepared();
 
+        let has_vid_seq = self.table.object.has_vid_seq();
+
         // Construct a query
         //   insert into schema.table(column, ...)
         //   values
@@ -1919,32 +2549,37 @@ impl<'a> QueryFragment<Pg> for InsertQuery<'a> {
             out.push_sql(CAUSALITY_REGION_COLUMN);
         };
 
+        if has_vid_seq {
+            out.push_sql(", vid");
+        }
         out.push_sql(") values\n");
 
-        // Use a `Peekable` iterator to help us decide how to finalize each line.
-        let mut iter = self.rows.iter().peekable();
-        while let Some(row) = iter.next() {
+        for (i, row) in self.rows.iter().enumerate() {
+            if i > 0 {
+                out.push_sql(",\n");
+            }
+
             out.push_sql("(");
-            for column in &self.unique_columns {
-                let value = if column.is_fulltext() {
-                    self.fulltext_values.get(row.id, &column.field)
-                } else {
-                    row.entity.get(&column.field).unwrap_or(&NULL)
-                };
-                QueryValue(value, &column.column_type).walk_ast(out.reborrow())?;
+            for iv in &row.values {
+                iv.walk_ast(out.reborrow())?;
                 out.push_sql(", ");
             }
-            Self::literal_range_current(&self.table, row.block, row.end, &mut out)?;
+            row.br_value.walk_ast(out.reborrow())?;
             if self.table.has_causality_region {
                 out.push_sql(", ");
                 out.push_bind_param::<Integer, _>(&row.causality_region)?;
             };
+            if has_vid_seq {
+                out.push_sql(", ");
+                out.push_bind_param::<BigInt, _>(&row.vid)?;
+            }
             out.push_sql(")");
+        }
 
-            // finalize line according to remaining entities to insert
-            if iter.peek().is_some() {
-                out.push_sql(",\n");
-            }
+        if self.table.immutable && self.table.skip_duplicates {
+            out.push_sql("\n ON CONFLICT (");
+            out.push_identifier(self.table.primary_key().name.as_str())?;
+            out.push_sql(") DO NOTHING");
         }
 
         Ok(())
@@ -1960,37 +2595,33 @@ impl<'a> QueryId for InsertQuery<'a> {
 impl<'a, Conn> RunQueryDsl<Conn> for InsertQuery<'a> {}
 
 #[derive(Debug, Clone)]
-pub struct ConflictingEntityQuery<'a> {
-    _layout: &'a Layout,
+pub struct ConflictingEntitiesQuery<'a> {
     tables: Vec<&'a Table>,
-    entity_id: &'a Id,
+    ids: IdList,
 }
-impl<'a> ConflictingEntityQuery<'a> {
+impl<'a> ConflictingEntitiesQuery<'a> {
     pub fn new(
         layout: &'a Layout,
-        entities: Vec<EntityType>,
-        entity_id: &'a Id,
+        entities: &[EntityType],
+        group: &'a RowGroup,
     ) -> Result<Self, StoreError> {
         let tables = entities
             .iter()
             .map(|entity| layout.table_for_entity(entity).map(|table| table.as_ref()))
             .collect::<Result<Vec<_>, _>>()?;
-        Ok(ConflictingEntityQuery {
-            _layout: layout,
-            tables,
-            entity_id,
-        })
+        let ids = IdList::try_from_iter_ref(group.ids().map(IdRef::from))?;
+        Ok(ConflictingEntitiesQuery { tables, ids })
     }
 }
 
-impl<'a> QueryFragment<Pg> for ConflictingEntityQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+impl<'a> QueryFragment<Pg> for ConflictingEntitiesQuery<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
         // Construct a query
-        //   select 'Type1' as entity from schema.table1 where id = $1
+        //   select 'Type1' as entity, id from schema.table1 where id = any($1)
         //   union all
-        //   select 'Type2' as entity from schema.table2 where id = $1
+        //   select 'Type2' as entity, id from schema.table2 where id = any($1)
         //   union all
         //   ...
         for (i, table) in self.tables.iter().enumerate() {
@@ -1998,35 +2629,36 @@ impl<'a> QueryFragment<Pg> for ConflictingEntityQuery<'a> {
                 out.push_sql("\nunion all\n");
             }
             out.push_sql("select ");
-            out.push_bind_param::<Text, _>(&table.object.as_str())?;
-            out.push_sql(" as entity from ");
+            out.push_bind_param::<Text, _>(table.object.as_str())?;
+            out.push_sql(" as entity, id::text from ");
             out.push_sql(table.qualified_name.as_str());
-            out.push_sql(" where id = ");
-            self.entity_id.push_bind_param(&mut out)?;
+            out.push_sql(" where id = any(");
+            self.ids.push_bind_param(&mut out)?;
+            out.push_sql(")");
         }
         Ok(())
     }
 }
 
-impl<'a> QueryId for ConflictingEntityQuery<'a> {
+impl<'a> QueryId for ConflictingEntitiesQuery<'a> {
     type QueryId = ();
 
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
 #[derive(QueryableByName)]
-pub struct ConflictingEntityData {
-    #[sql_type = "Text"]
+pub struct ConflictingEntitiesData {
+    #[diesel(sql_type = Text)]
     pub entity: String,
+    #[diesel(sql_type = Text)]
+    pub id: String,
 }
 
-impl<'a> LoadQuery<PgConnection, ConflictingEntityData> for ConflictingEntityQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<ConflictingEntityData>> {
-        conn.query_by_name(&self)
-    }
+impl<'a> Query for ConflictingEntitiesQuery<'a> {
+    type SqlType = Untyped;
 }
 
-impl<'a, Conn> RunQueryDsl<Conn> for ConflictingEntityQuery<'a> {}
+impl<'a, Conn> RunQueryDsl<Conn> for ConflictingEntitiesQuery<'a> {}
 
 #[derive(Debug, Clone)]
 enum ParentIds {
@@ -2048,7 +2680,7 @@ impl ParentIds {
 /// corresponding table and column
 #[derive(Debug, Clone)]
 enum TableLink<'a> {
-    Direct(&'a Column, ChildMultiplicity),
+    Direct(dsl::Column<'a>, ChildMultiplicity),
     /// The `Table` is the parent table
     Parent(&'a Table, ParentIds),
 }
@@ -2056,7 +2688,7 @@ enum TableLink<'a> {
 impl<'a> TableLink<'a> {
     fn new(
         layout: &'a Layout,
-        child_table: &'a Table,
+        child_table: dsl::Table<'a>,
         link: EntityLink,
     ) -> Result<Self, QueryExecutionError> {
         match link {
@@ -2080,55 +2712,55 @@ impl<'a> TableLink<'a> {
 /// parent `q.id` that an outer query has already set up. In all other
 /// cases, we restrict the children to the top n by ordering by a specific
 /// sort key and limiting
-#[derive(Copy, Clone)]
-enum ParentLimit<'a> {
-    /// Limit children to a specific parent
-    Outer,
+#[derive(Debug, Clone)]
+struct ParentLimit<'a> {
     /// Limit children by sorting and picking top n
-    Ranked(&'a SortKey<'a>, &'a FilterRange),
+    sort_key: SortKey<'a>,
+    range: FilterRange,
 }
 
 impl<'a> ParentLimit<'a> {
-    fn filter(&self, out: &mut AstPass<Pg>) {
-        match self {
-            ParentLimit::Outer => out.push_sql(" and q.id = p.id"),
-            ParentLimit::Ranked(_, _) => (),
+    fn filter(&self, is_outer: bool, out: &mut AstPass<'_, 'a, Pg>) {
+        if is_outer {
+            out.push_sql(" and q.id = p.id")
         }
     }
 
-    fn restrict(&self, out: &mut AstPass<Pg>) -> QueryResult<()> {
-        if let ParentLimit::Ranked(sort_key, range) = self {
+    fn restrict(&'a self, is_outer: bool, out: &mut AstPass<'_, 'a, Pg>) -> QueryResult<()> {
+        if !is_outer {
             out.push_sql(" ");
-            sort_key.order_by(out, false)?;
-            range.walk_ast(out.reborrow())?;
+            self.sort_key.order_by(out, false)?;
+            self.range.walk_ast(out.reborrow())?;
         }
         Ok(())
     }
 
     /// Include a 'limit {num_parents}+1' clause for single-object queries
     /// if that is needed
-    fn single_limit(&self, num_parents: usize, out: &mut AstPass<Pg>) {
-        match self {
-            ParentLimit::Ranked(_, _) => {
-                out.push_sql(" limit ");
-                out.push_sql(&(num_parents + 1).to_string());
-            }
-            ParentLimit::Outer => {
-                // limiting is taken care of in a wrapper around
-                // the query we are currently building
-            }
+    fn single_limit(&self, is_outer: bool, num_parents: usize, out: &mut AstPass<Pg>) {
+        if !is_outer {
+            out.push_sql(" limit ");
+            out.push_sql(&(num_parents + 1).to_string());
         }
+        // limiting is taken care of in a wrapper around
+        // the query we are currently building
+    }
+
+    /// Returns the maximum number of rows that could be requested by this range filter.
+    fn max_num_rows(&self) -> u32 {
+        self.range.0.first.unwrap_or(EntityRange::FIRST) + self.range.0.skip
     }
 }
 
 /// This is the parallel to `EntityWindow`, with names translated to
 /// the relational layout, and checked against it
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FilterWindow<'a> {
     /// The table from which we take entities
-    table: &'a Table,
+    table: dsl::Table<'a>,
+    from_table: dsl::FromTable<'a>,
     /// The overall filter for the entire query
-    query_filter: Option<QueryFilter<'a>>,
+    query_filter: Option<Filter<'a>>,
     /// The parent ids we are interested in. The type in the database
     /// for these is determined by the `IdType` of the parent table. Since
     /// we always compare these ids with a column in `table`, and that
@@ -2138,6 +2770,7 @@ pub struct FilterWindow<'a> {
     /// How to filter by a set of parents
     link: TableLink<'a>,
     column_names: AttributeNames,
+    at_block: AtBlock<'a>,
 }
 
 impl<'a> FilterWindow<'a> {
@@ -2153,7 +2786,7 @@ impl<'a> FilterWindow<'a> {
             link,
             column_names,
         } = window;
-        let table = layout.table_for_entity(&child_type).map(|rc| rc.as_ref())?;
+        let table = layout.table_for_entity(&child_type)?.as_ref().dsl_table();
 
         // Confidence check: ensure that all selected column names exist in the table
         if let AttributeNames::Select(ref selected_field_names) = column_names {
@@ -2163,39 +2796,44 @@ impl<'a> FilterWindow<'a> {
         }
 
         let query_filter = entity_filter
-            .map(|filter| QueryFilter::new(filter, table, layout, block))
+            .map(|filter| Filter::main(layout, table, filter, block))
             .transpose()?;
         let link = TableLink::new(layout, table, link)?;
+        let at_block = table
+            .at_block(block)
+            .filters_by_id(matches!(link, TableLink::Parent(_, _)));
         Ok(FilterWindow {
             table,
+            from_table: table.from_clause(),
             query_filter,
             ids,
             link,
             column_names,
+            at_block,
         })
     }
 
     fn parent_type(&self) -> QueryResult<IdType> {
         match &self.link {
-            TableLink::Direct(column, _) => column.column_type.id_type(),
+            TableLink::Direct(column, _) => column.column_type().id_type(),
             TableLink::Parent(parent_table, _) => parent_table.primary_key().column_type.id_type(),
         }
     }
 
-    fn and_filter(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn and_filter(&'a self, out: &mut AstPass<'_, 'a, Pg>) -> QueryResult<()> {
         if let Some(filter) = &self.query_filter {
             out.push_sql("\n   and ");
-            filter.walk_ast(out)?
+            filter.walk_ast(out.reborrow())?
         }
         Ok(())
     }
 
-    fn children_type_a(
-        &self,
-        column: &Column,
-        limit: ParentLimit<'_>,
-        block: BlockNumber,
-        out: &mut AstPass<Pg>,
+    fn children_type_a<'b>(
+        &'b self,
+        column: &'b dsl::Column<'b>,
+        is_outer: bool,
+        limit: &'b ParentLimit<'_>,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         assert!(column.is_list());
 
@@ -2215,25 +2853,25 @@ impl<'a> FilterWindow<'a> {
         out.push_sql(") as p(id) cross join lateral (select ");
         write_column_names(&self.column_names, self.table, None, out)?;
         out.push_sql(" from ");
-        out.push_sql(self.table.qualified_name.as_str());
-        out.push_sql(" c where ");
-        BlockRangeColumn::new(self.table, "c.", block).contains(out, false)?;
-        limit.filter(out);
-        out.push_sql(" and p.id = any(c.");
-        out.push_identifier(column.name.as_str())?;
+        self.from_table.walk_ast(out.reborrow())?;
+        out.push_sql(" where ");
+        self.at_block.walk_ast(out.reborrow())?;
+        limit.filter(is_outer, out);
+        out.push_sql(" and p.id = any(");
+        column.walk_ast(out.reborrow())?;
         out.push_sql(")");
-        self.and_filter(out.reborrow())?;
-        limit.restrict(out)?;
+        self.and_filter(out)?;
+        limit.restrict(is_outer, out)?;
         out.push_sql(") c");
         Ok(())
     }
 
-    fn child_type_a(
-        &self,
-        column: &Column,
-        limit: ParentLimit<'_>,
-        block: BlockNumber,
-        out: &mut AstPass<Pg>,
+    fn child_type_a<'b>(
+        &'b self,
+        column: &'b dsl::Column<'b>,
+        is_outer: bool,
+        limit: &'b ParentLimit<'_>,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         assert!(column.is_list());
 
@@ -2251,30 +2889,30 @@ impl<'a> FilterWindow<'a> {
         out.push_sql("\n/* child_type_a */ from unnest(");
         self.ids.push_bind_param(out)?;
         out.push_sql(") as p(id), ");
-        out.push_sql(self.table.qualified_name.as_str());
-        out.push_sql(" c where ");
-        BlockRangeColumn::new(self.table, "c.", block).contains(out, false)?;
-        limit.filter(out);
-        out.push_sql(" and c.");
-        out.push_identifier(column.name.as_str())?;
+        self.from_table.walk_ast(out.reborrow())?;
+        out.push_sql(" where ");
+        self.at_block.walk_ast(out.reborrow())?;
+        limit.filter(is_outer, out);
+        out.push_sql(" and ");
+        column.walk_ast(out.reborrow())?;
         out.push_sql(" @> array[p.id]");
         if self.ids.len() < ENV_VARS.store.typea_batch_size {
-            out.push_sql(" and c.");
-            out.push_identifier(column.name.as_str())?;
+            out.push_sql(" and ");
+            column.walk_ast(out.reborrow())?;
             out.push_sql(" && ");
             self.ids.push_bind_param(out)?;
         }
-        self.and_filter(out.reborrow())?;
-        limit.single_limit(self.ids.len(), out);
+        self.and_filter(out)?;
+        limit.single_limit(is_outer, self.ids.len(), out);
         Ok(())
     }
 
-    fn children_type_b(
-        &self,
-        column: &Column,
-        limit: ParentLimit<'_>,
-        block: BlockNumber,
-        out: &mut AstPass<Pg>,
+    fn children_type_b<'b>(
+        &'b self,
+        column: &'b dsl::Column<'b>,
+        is_outer: bool,
+        limit: &'b ParentLimit<'_>,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         assert!(!column.is_list());
 
@@ -2294,24 +2932,24 @@ impl<'a> FilterWindow<'a> {
         out.push_sql(") as p(id) cross join lateral (select ");
         write_column_names(&self.column_names, self.table, None, out)?;
         out.push_sql(" from ");
-        out.push_sql(self.table.qualified_name.as_str());
-        out.push_sql(" c where ");
-        BlockRangeColumn::new(self.table, "c.", block).contains(out, false)?;
-        limit.filter(out);
-        out.push_sql(" and p.id = c.");
-        out.push_identifier(column.name.as_str())?;
-        self.and_filter(out.reborrow())?;
-        limit.restrict(out)?;
+        self.from_table.walk_ast(out.reborrow())?;
+        out.push_sql(" where ");
+        self.at_block.walk_ast(out.reborrow())?;
+        limit.filter(is_outer, out);
+        out.push_sql(" and p.id = ");
+        column.walk_ast(out.reborrow())?;
+        self.and_filter(out)?;
+        limit.restrict(is_outer, out)?;
         out.push_sql(") c");
         Ok(())
     }
 
-    fn child_type_b(
-        &self,
-        column: &Column,
-        limit: ParentLimit<'_>,
-        block: BlockNumber,
-        out: &mut AstPass<Pg>,
+    fn child_type_b<'b>(
+        &'b self,
+        column: &'b dsl::Column<'b>,
+        is_outer: bool,
+        limit: &'b ParentLimit<'_>,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         assert!(!column.is_list());
 
@@ -2324,23 +2962,23 @@ impl<'a> FilterWindow<'a> {
         out.push_sql("\n/* child_type_b */  from unnest(");
         self.ids.push_bind_param(out)?;
         out.push_sql(") as p(id), ");
-        out.push_sql(self.table.qualified_name.as_str());
-        out.push_sql(" c where ");
-        BlockRangeColumn::new(self.table, "c.", block).contains(out, false)?;
-        limit.filter(out);
-        out.push_sql(" and p.id = c.");
-        out.push_identifier(column.name.as_str())?;
-        self.and_filter(out.reborrow())?;
-        limit.single_limit(self.ids.len(), out);
+        self.from_table.walk_ast(out.reborrow())?;
+        out.push_sql(" where ");
+        self.at_block.walk_ast(out.reborrow())?;
+        limit.filter(is_outer, out);
+        out.push_sql(" and p.id = ");
+        column.walk_ast(out.reborrow())?;
+        self.and_filter(out)?;
+        limit.single_limit(is_outer, self.ids.len(), out);
         Ok(())
     }
 
-    fn children_type_c(
-        &self,
-        child_ids: &[IdList],
-        limit: ParentLimit<'_>,
-        block: BlockNumber,
-        out: &mut AstPass<Pg>,
+    fn children_type_c<'b>(
+        &'b self,
+        child_ids: &'b [IdList],
+        is_outer: bool,
+        limit: &'b ParentLimit<'_>,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         out.push_sql("\n/* children_type_c */ ");
 
@@ -2363,14 +3001,13 @@ impl<'a> FilterWindow<'a> {
 
             out.push_sql("from (values ");
             for i in 0..self.ids.len() {
-                let parent_id = self.ids.index(i);
                 let child_ids = &child_ids[i];
                 if i > 0 {
                     out.push_sql(", (");
                 } else {
                     out.push_sql("(");
                 }
-                parent_id.push_bind_param(out)?;
+                self.ids.bind_entry(i, out)?;
                 out.push_sql(",");
                 child_ids.push_bind_param(out)?;
                 out.push_sql(")");
@@ -2379,13 +3016,13 @@ impl<'a> FilterWindow<'a> {
             out.push_sql(" cross join lateral (select ");
             write_column_names(&self.column_names, self.table, None, out)?;
             out.push_sql(" from ");
-            out.push_sql(self.table.qualified_name.as_str());
-            out.push_sql(" c where ");
-            BlockRangeColumn::new(self.table, "c.", block).contains(out, true)?;
-            limit.filter(out);
+            self.from_table.walk_ast(out.reborrow())?;
+            out.push_sql(" where ");
+            self.at_block.walk_ast(out.reborrow())?;
+            limit.filter(is_outer, out);
             out.push_sql(" and c.id = any(p.child_ids)");
-            self.and_filter(out.reborrow())?;
-            limit.restrict(out)?;
+            self.and_filter(out)?;
+            limit.restrict(is_outer, out)?;
             out.push_sql(") c");
         } else {
             // Generate
@@ -2397,18 +3034,18 @@ impl<'a> FilterWindow<'a> {
             out.push_sql("from unnest(array[]::text[]) as p(id) cross join (select ");
             write_column_names(&self.column_names, self.table, None, out)?;
             out.push_sql("  from ");
-            out.push_sql(self.table.qualified_name.as_str());
-            out.push_sql(" c where false) c");
+            self.from_table.walk_ast(out.reborrow())?;
+            out.push_sql(" where false) c");
         }
         Ok(())
     }
 
-    fn child_type_d(
-        &self,
-        child_ids: &IdList,
-        limit: ParentLimit<'_>,
-        block: BlockNumber,
-        out: &mut AstPass<Pg>,
+    fn child_type_d<'b>(
+        &'b self,
+        child_ids: &'b IdList,
+        is_outer: bool,
+        limit: &'b ParentLimit<'_>,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         // Generate
         //      from rows from (unnest({parent_ids}), unnest({child_ids})) as p(id, child_id),
@@ -2421,56 +3058,56 @@ impl<'a> FilterWindow<'a> {
         out.push_sql("), unnest(");
         child_ids.push_bind_param(out)?;
         out.push_sql(")) as p(id, child_id), ");
-        out.push_sql(self.table.qualified_name.as_str());
-        out.push_sql(" c where ");
-        BlockRangeColumn::new(self.table, "c.", block).contains(out, true)?;
-        limit.filter(out);
+        self.from_table.walk_ast(out.reborrow())?;
+        out.push_sql(" where ");
+        self.at_block.walk_ast(out.reborrow())?;
+        limit.filter(is_outer, out);
 
         // Include a constraint on the child IDs as a set if the size of the set
         // is below the threshold set by environment variable. Set it to
         // 0 to turn off this optimization.
         if ENV_VARS.store.typed_children_set_size > 0 {
-            let child_set = child_ids.clone().as_unique();
-
-            if child_set.len() <= ENV_VARS.store.typed_children_set_size {
+            // This check can be misleading because child_ids can contain
+            // duplicates if many parents point to the same child
+            if child_ids.len() <= ENV_VARS.store.typed_children_set_size {
                 out.push_sql(" and c.id = any(");
-                child_set.push_bind_param(out)?;
+                child_ids.push_bind_param(out)?;
                 out.push_sql(")");
             }
         }
         out.push_sql(" and ");
         out.push_sql("c.id = p.child_id");
-        self.and_filter(out.reborrow())?;
-        limit.single_limit(self.ids.len(), out);
+        self.and_filter(out)?;
+        limit.single_limit(is_outer, self.ids.len(), out);
         Ok(())
     }
 
-    fn children(
-        &self,
-        limit: ParentLimit<'_>,
-        block: BlockNumber,
-        mut out: AstPass<Pg>,
+    fn children<'b>(
+        &'b self,
+        is_outer: bool,
+        limit: &'b ParentLimit<'_>,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         match &self.link {
             TableLink::Direct(column, multiplicity) => {
                 use ChildMultiplicity::*;
                 if column.is_list() {
                     match multiplicity {
-                        Many => self.children_type_a(column, limit, block, &mut out),
-                        Single => self.child_type_a(column, limit, block, &mut out),
+                        Many => self.children_type_a(column, is_outer, limit, out),
+                        Single => self.child_type_a(column, is_outer, limit, out),
                     }
                 } else {
                     match multiplicity {
-                        Many => self.children_type_b(column, limit, block, &mut out),
-                        Single => self.child_type_b(column, limit, block, &mut out),
+                        Many => self.children_type_b(column, is_outer, limit, out),
+                        Single => self.child_type_b(column, is_outer, limit, out),
                     }
                 }
             }
             TableLink::Parent(_, ParentIds::List(child_ids)) => {
-                self.children_type_c(child_ids, limit, block, &mut out)
+                self.children_type_c(child_ids, is_outer, limit, out)
             }
             TableLink::Parent(_, ParentIds::Scalar(child_ids)) => {
-                self.child_type_d(child_ids, limit, block, &mut out)
+                self.child_type_d(child_ids, is_outer, limit, out)
             }
         }
     }
@@ -2478,18 +3115,19 @@ impl<'a> FilterWindow<'a> {
     /// Select a basic subset of columns from the child table for use in
     /// the `matches` CTE of queries that need to retrieve entities of
     /// different types or entities that link differently to their parents
-    fn children_uniform(
-        &self,
-        sort_key: &SortKey,
-        block: BlockNumber,
-        mut out: AstPass<Pg>,
+    fn children_uniform<'b>(
+        &'b self,
+        limit: &'b ParentLimit<'_>,
+        mut out: AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         out.push_sql("select '");
-        out.push_sql(self.table.object.as_str());
+        out.push_sql(self.table.meta.object.as_str());
         out.push_sql("' as entity, c.id, c.vid, p.id::text as ");
-        out.push_sql(&*PARENT_ID);
-        sort_key.select(&mut out, SelectStatementLevel::InnerStatement)?;
-        self.children(ParentLimit::Outer, block, out)
+        out.push_sql(PARENT_ID);
+        limit
+            .sort_key
+            .select(&mut out, SelectStatementLevel::InnerStatement)?;
+        self.children(true, limit, &mut out)
     }
 
     /// Collect all the parent id's from all windows
@@ -2500,13 +3138,53 @@ impl<'a> FilterWindow<'a> {
     }
 }
 
+#[derive(Debug)]
+pub struct WholeTable<'a> {
+    table: dsl::Table<'a>,
+    from_table: dsl::FromTable<'a>,
+    filter: Option<Filter<'a>>,
+    column_names: AttributeNames,
+    at_block: AtBlock<'a>,
+}
+
+impl<'a> WholeTable<'a> {
+    fn new(
+        layout: &'a Layout,
+        entity_type: &EntityType,
+        entity_filter: Option<&'a EntityFilter>,
+        column_names: AttributeNames,
+        block: BlockNumber,
+    ) -> Result<Self, QueryExecutionError> {
+        let table = layout
+            .table_for_entity(entity_type)
+            .map(|rc| rc.as_ref())?
+            .dsl_table();
+        let filter = entity_filter
+            .map(|filter| Filter::main(layout, table, filter, block))
+            .transpose()?;
+
+        let filters_by_id = {
+            matches!(filter.as_ref(), Some(Filter::Cmp(column, Comparison::Equal, _)) if column.is_primary_key())
+        };
+
+        let at_block = table.at_block(block).filters_by_id(filters_by_id);
+        Ok(WholeTable {
+            table,
+            from_table: table.from_clause(),
+            filter,
+            column_names,
+            at_block,
+        })
+    }
+}
+
 /// This is a parallel to `EntityCollection`, but with entity type names
 /// and filters translated in a form ready for SQL generation
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum FilterCollection<'a> {
     /// Collection made from all entities in a table; each entry is the table
     /// and the filter to apply to it, checked and bound to that table
-    All(Vec<(&'a Table, Option<QueryFilter<'a>>, AttributeNames)>),
+    All(Vec<WholeTable<'a>>),
     /// Collection made from windows of the same or different entity types
     SingleWindow(FilterWindow<'a>),
     MultiWindow(Vec<FilterWindow<'a>>, IdList),
@@ -2517,11 +3195,15 @@ impl<'a> fmt::Display for FilterCollection<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), std::fmt::Error> {
         fn fmt_table(
             f: &mut fmt::Formatter,
-            table: &Table,
+            table: dsl::Table<'_>,
             attrs: &AttributeNames,
-            filter: &Option<QueryFilter>,
+            filter: &Option<Filter>,
         ) -> Result<(), std::fmt::Error> {
-            write!(f, "{}[", table.qualified_name.as_str().replace("\\\"", ""))?;
+            write!(
+                f,
+                "{}[",
+                table.meta.qualified_name.as_str().replace("\\\"", "")
+            )?;
             match attrs {
                 AttributeNames::All => write!(f, "*")?,
                 AttributeNames::Select(cols) => write!(f, "{}", cols.iter().join(","))?,
@@ -2536,12 +3218,14 @@ impl<'a> fmt::Display for FilterCollection<'a> {
         fn fmt_window(f: &mut fmt::Formatter, w: &FilterWindow) -> Result<(), std::fmt::Error> {
             let FilterWindow {
                 table,
+                from_table: _,
                 query_filter,
                 ids,
                 link,
                 column_names,
+                at_block: _,
             } = w;
-            fmt_table(f, table, column_names, query_filter)?;
+            fmt_table(f, *table, column_names, query_filter)?;
             if !ids.is_empty() {
                 use ChildMultiplicity::*;
 
@@ -2573,8 +3257,8 @@ impl<'a> fmt::Display for FilterCollection<'a> {
 
         match self {
             FilterCollection::All(tables) => {
-                for (table, filter, attrs) in tables {
-                    fmt_table(f, table, attrs, filter)?;
+                for wh in tables {
+                    fmt_table(f, wh.table, &wh.column_names, &wh.filter)?;
                 }
             }
             FilterCollection::SingleWindow(w) => {
@@ -2611,15 +3295,7 @@ impl<'a> FilterCollection<'a> {
                 let entities = entities
                     .iter()
                     .map(|(entity, column_names)| {
-                        layout
-                            .table_for_entity(entity)
-                            .map(|rc| rc.as_ref())
-                            .and_then(|table| {
-                                filter
-                                    .map(|filter| QueryFilter::new(filter, table, layout, block))
-                                    .transpose()
-                                    .map(|filter| (table, filter, column_names.clone()))
-                            })
+                        WholeTable::new(layout, entity, filter, column_names.clone(), block)
                     })
                     .collect::<Result<Vec<_>, _>>()?;
                 Ok(FilterCollection::All(entities))
@@ -2643,9 +3319,9 @@ impl<'a> FilterCollection<'a> {
         }
     }
 
-    fn first_table(&self) -> Option<&Table> {
+    fn first_table(&self) -> Option<dsl::Table<'a>> {
         match self {
-            FilterCollection::All(entities) => entities.first().map(|pair| pair.0),
+            FilterCollection::All(entities) => entities.first().map(|wh| wh.table),
             FilterCollection::SingleWindow(window) => Some(window.table),
             FilterCollection::MultiWindow(windows, _) => windows.first().map(|window| window.table),
         }
@@ -2661,10 +3337,10 @@ impl<'a> FilterCollection<'a> {
 
     fn all_mutable(&self) -> bool {
         match self {
-            FilterCollection::All(entities) => entities.iter().all(|(table, ..)| !table.immutable),
-            FilterCollection::SingleWindow(window) => !window.table.immutable,
+            FilterCollection::All(entities) => entities.iter().all(|wh| !wh.table.meta.immutable),
+            FilterCollection::SingleWindow(window) => !window.table.meta.immutable,
             FilterCollection::MultiWindow(windows, _) => {
-                windows.iter().all(|window| !window.table.immutable)
+                windows.iter().all(|window| !window.table.meta.immutable)
             }
         }
     }
@@ -2680,7 +3356,7 @@ impl<'a> FilterCollection<'a> {
                 if windows.iter().map(FilterWindow::parent_type).all_equal() {
                     Ok(Some(windows[0].parent_type()?))
                 } else {
-                    Err(graph::constraint_violation!(
+                    Err(graph::internal_error!(
                         "all implementors of an interface must use the same type for their `id`"
                     ))
                 }
@@ -2691,62 +3367,74 @@ impl<'a> FilterCollection<'a> {
 
 #[derive(Debug, Clone)]
 pub struct ChildKeyDetails<'a> {
-    /// Table representing the parent entity
-    pub parent_table: &'a Table,
     /// Column in the parent table that stores the connection between the parent and the child
-    pub parent_join_column: &'a Column,
+    pub parent_join_column: dsl::Column<'a>,
     /// Table representing the child entity
-    pub child_table: &'a Table,
+    pub child_table: dsl::Table<'a>,
+    pub child_from: dsl::FromTable<'a>,
     /// Column in the child table that stores the connection between the child and the parent
-    pub child_join_column: &'a Column,
+    pub child_join_column: dsl::Column<'a>,
+    pub child_at_block: dsl::AtBlock<'a>,
     /// Column of the child table that sorting is done on
-    pub sort_by_column: &'a Column,
-    /// Prefix for the child table
-    pub prefix: String,
+    pub sort_by_column: dsl::Column<'a>,
     /// Either `asc` or `desc`
-    pub direction: &'static str,
+    pub direction: SortDirection,
 }
 
 #[derive(Debug, Clone)]
 pub struct ChildKeyAndIdSharedDetails<'a> {
-    /// Table representing the parent entity
-    pub parent_table: &'a Table,
     /// Column in the parent table that stores the connection between the parent and the child
-    pub parent_join_column: &'a Column,
+    pub parent_join_column: dsl::Column<'a>,
     /// Table representing the child entity
-    pub child_table: &'a Table,
+    pub child_table: dsl::Table<'a>,
+    pub child_from: dsl::FromTable<'a>,
     /// Column in the child table that stores the connection between the child and the parent
-    pub child_join_column: &'a Column,
+    pub child_join_column: dsl::Column<'a>,
+    pub child_pk: dsl::Column<'a>,
+    pub child_br: dsl::BlockColumn<'a>,
+    pub child_at_block: dsl::AtBlock<'a>,
     /// Column of the child table that sorting is done on
-    pub sort_by_column: &'a Column,
-    /// Prefix for the child table
-    pub prefix: String,
+    pub sort_by_column: dsl::Column<'a>,
     /// Either `asc` or `desc`
-    pub direction: &'static str,
+    pub direction: SortDirection,
 }
 
+#[allow(unused)]
 #[derive(Debug, Clone)]
 pub struct ChildIdDetails<'a> {
-    /// Table representing the parent entity
-    pub parent_table: &'a Table,
     /// Column in the parent table that stores the connection between the parent and the child
-    pub parent_join_column: &'a Column,
+    pub parent_join_column: dsl::Column<'a>,
     /// Table representing the child entity
-    pub child_table: &'a Table,
+    pub child_table: dsl::Table<'a>,
+    pub child_from: dsl::FromTable<'a>,
     /// Column in the child table that stores the connection between the child and the parent
-    pub child_join_column: &'a Column,
-    /// Prefix for the child table
-    pub prefix: String,
+    pub child_join_column: dsl::Column<'a>,
+    pub child_pk: dsl::Column<'a>,
+    pub child_br: dsl::BlockColumn<'a>,
+    pub child_at_block: dsl::AtBlock<'a>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum UseBlockColumn {
+    Yes,
+    No,
+}
+impl UseBlockColumn {
+    fn block_column<'a>(&self, table: dsl::Table<'a>) -> Option<dsl::BlockColumn<'a>> {
+        match self {
+            UseBlockColumn::Yes => Some(table.block_column()),
+            UseBlockColumn::No => None,
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
 pub enum ChildKey<'a> {
     Single(ChildKeyDetails<'a>),
-    Many(Vec<ChildKeyDetails<'a>>),
-    IdAsc(ChildIdDetails<'a>, Option<BlockRangeColumn<'a>>),
-    IdDesc(ChildIdDetails<'a>, Option<BlockRangeColumn<'a>>),
-    ManyIdAsc(Vec<ChildIdDetails<'a>>, Option<BlockRangeColumn<'a>>),
-    ManyIdDesc(Vec<ChildIdDetails<'a>>, Option<BlockRangeColumn<'a>>),
+    /// First column is the primary key of the parent
+    Many(dsl::Column<'a>, Vec<ChildKeyDetails<'a>>),
+    Id(SortDirection, ChildIdDetails<'a>, UseBlockColumn),
+    ManyId(SortDirection, Vec<ChildIdDetails<'a>>, UseBlockColumn),
 }
 
 /// Convenience to pass the name of the column to order by around. If `name`
@@ -2754,15 +3442,13 @@ pub enum ChildKey<'a> {
 #[derive(Debug, Clone)]
 pub enum SortKey<'a> {
     None,
-    /// Order by `id asc`
-    IdAsc(Option<BlockRangeColumn<'a>>),
-    /// Order by `id desc`
-    IdDesc(Option<BlockRangeColumn<'a>>),
+    /// Order by `id <direction>, [block <direction>]`
+    Id(SortDirection, Option<dsl::BlockColumn<'a>>),
     /// Order by some other column; `column` will never be `id`
     Key {
-        column: &'a Column,
+        column: dsl::Column<'a>,
         value: Option<&'a str>,
-        direction: &'static str,
+        direction: SortDirection,
     },
     /// Order by some other column; `column` will never be `id`
     ChildKey(ChildKey<'a>),
@@ -2773,11 +3459,12 @@ impl<'a> fmt::Display for SortKey<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             SortKey::None => write!(f, "none"),
-            SortKey::IdAsc(Option::None) => write!(f, "{}", PRIMARY_KEY_COLUMN),
-            SortKey::IdAsc(Some(br)) => write!(f, "{}, {}", PRIMARY_KEY_COLUMN, br.column_name()),
-            SortKey::IdDesc(Option::None) => write!(f, "{} desc", PRIMARY_KEY_COLUMN),
-            SortKey::IdDesc(Some(br)) => {
-                write!(f, "{} desc, {} desc", PRIMARY_KEY_COLUMN, br.column_name())
+            SortKey::Id(direction, br) => {
+                write!(f, "{}{}", PRIMARY_KEY_COLUMN, direction)?;
+                if let Some(br) = br {
+                    write!(f, ", {} {}", PRIMARY_KEY_COLUMN, br)?;
+                }
+                Ok(())
             }
             SortKey::Key {
                 column,
@@ -2785,105 +3472,53 @@ impl<'a> fmt::Display for SortKey<'a> {
                 direction,
             } => write!(
                 f,
-                "{} {}, {} {}",
-                column.name.as_str(),
-                direction,
-                PRIMARY_KEY_COLUMN,
-                direction
+                "{}{}, {}{}",
+                column, direction, PRIMARY_KEY_COLUMN, direction
             ),
             SortKey::ChildKey(child) => match child {
                 ChildKey::Single(details) => write!(
                     f,
-                    "{}.{} {}, {}.{} {}",
-                    details.child_table.name.as_str(),
-                    details.sort_by_column.name.as_str(),
+                    "{}{}, {}{}",
+                    details.sort_by_column,
                     details.direction,
-                    details.child_table.name.as_str(),
-                    PRIMARY_KEY_COLUMN,
+                    details.child_table.primary_key(),
                     details.direction
                 ),
-                ChildKey::Many(details) => details.iter().try_for_each(|details| {
+                ChildKey::Many(_, details) => details.iter().try_for_each(|details| {
                     write!(
                         f,
-                        "{}.{} {}, {}.{} {}",
-                        details.child_table.name.as_str(),
-                        details.sort_by_column.name.as_str(),
+                        "{}{}, {}{}",
+                        details.sort_by_column,
                         details.direction,
-                        details.child_table.name.as_str(),
-                        PRIMARY_KEY_COLUMN,
+                        details.child_table.primary_key(),
                         details.direction
                     )
                 }),
 
-                ChildKey::ManyIdAsc(details, Option::None) => {
-                    details.iter().try_for_each(|details| {
-                        write!(
-                            f,
-                            "{}.{}",
-                            details.child_table.name.as_str(),
-                            PRIMARY_KEY_COLUMN
-                        )
-                    })
-                }
-                ChildKey::ManyIdAsc(details, Some(br)) => details.iter().try_for_each(|details| {
-                    write!(
-                        f,
-                        "{}.{}, {}.{}",
-                        details.child_table.name.as_str(),
-                        PRIMARY_KEY_COLUMN,
-                        details.child_table.name.as_str(),
-                        br.column_name()
-                    )
-                }),
-                ChildKey::ManyIdDesc(details, Option::None) => {
+                ChildKey::ManyId(direction, details, UseBlockColumn::No) => {
                     details.iter().try_for_each(|details| {
-                        write!(
-                            f,
-                            "{}.{} desc",
-                            details.child_table.name.as_str(),
-                            PRIMARY_KEY_COLUMN
-                        )
+                        write!(f, "{}{direction}", details.child_table.primary_key())
                     })
                 }
-                ChildKey::ManyIdDesc(details, Some(br)) => details.iter().try_for_each(|details| {
-                    write!(
-                        f,
-                        "{}.{} desc, {}.{} desc",
-                        details.child_table.name.as_str(),
-                        PRIMARY_KEY_COLUMN,
-                        details.child_table.name.as_str(),
-                        br.column_name()
-                    )
-                }),
-
-                ChildKey::IdAsc(details, Option::None) => write!(
-                    f,
-                    "{}.{}",
-                    details.child_table.name.as_str(),
-                    PRIMARY_KEY_COLUMN
-                ),
-                ChildKey::IdAsc(details, Some(br)) => write!(
-                    f,
-                    "{}.{}, {}.{}",
-                    details.child_table.name.as_str(),
-                    PRIMARY_KEY_COLUMN,
-                    details.child_table.name.as_str(),
-                    br.column_name()
-                ),
-                ChildKey::IdDesc(details, Option::None) => write!(
-                    f,
-                    "{}.{} desc",
-                    details.child_table.name.as_str(),
-                    PRIMARY_KEY_COLUMN
-                ),
-                ChildKey::IdDesc(details, Some(br)) => {
+                ChildKey::ManyId(direction, details, UseBlockColumn::Yes) => {
+                    details.iter().try_for_each(|details| {
+                        write!(
+                            f,
+                            "{}{direction}, {}{direction}",
+                            details.child_table.primary_key(),
+                            details.child_table.block_column()
+                        )
+                    })
+                }
+                ChildKey::Id(direction, details, UseBlockColumn::No) => {
+                    write!(f, "{}{}", details.child_table.primary_key(), direction)
+                }
+                ChildKey::Id(direction, details, UseBlockColumn::Yes) => {
                     write!(
                         f,
-                        "{}.{} desc, {}.{} desc",
-                        details.child_table.name.as_str(),
-                        PRIMARY_KEY_COLUMN,
-                        details.child_table.name.as_str(),
-                        br.column_name()
+                        "{}{direction}, {}{direction}",
+                        details.child_table.primary_key(),
+                        details.child_br
                     )
                 }
             },
@@ -2891,21 +3526,42 @@ impl<'a> fmt::Display for SortKey<'a> {
     }
 }
 
-const ASC: &str = "asc";
-const DESC: &str = "desc";
+#[derive(Debug, Clone, Copy)]
+pub enum SortDirection {
+    Asc,
+    Desc,
+}
+
+impl SortDirection {
+    /// Generate either `""` or `" desc"`; convenient for SQL generation
+    /// without needing an additional space to separate it from preceding
+    /// text
+    fn as_sql(&self) -> &'static str {
+        match self {
+            SortDirection::Asc => "",
+            SortDirection::Desc => " desc",
+        }
+    }
+}
+
+impl std::fmt::Display for SortDirection {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.as_sql())
+    }
+}
 
 impl<'a> SortKey<'a> {
     fn new(
         order: EntityOrder,
         collection: &'a FilterCollection,
         filter: Option<&'a EntityFilter>,
-        block: BlockNumber,
         layout: &'a Layout,
+        block: BlockNumber,
     ) -> Result<Self, QueryExecutionError> {
         fn sort_key_from_value<'a>(
-            column: &'a Column,
+            column: dsl::Column<'a>,
             value: &'a Value,
-            direction: &'static str,
+            direction: SortDirection,
         ) -> Result<SortKey<'a>, QueryExecutionError> {
             let sort_value = value.as_str();
 
@@ -2917,11 +3573,11 @@ impl<'a> SortKey<'a> {
         }
 
         fn with_key<'a>(
-            table: &'a Table,
+            table: dsl::Table<'a>,
             attribute: String,
             filter: Option<&'a EntityFilter>,
-            direction: &'static str,
-            br_column: Option<BlockRangeColumn<'a>>,
+            direction: SortDirection,
+            use_block_column: UseBlockColumn,
         ) -> Result<SortKey<'a>, QueryExecutionError> {
             let column = table.column_for_field(&attribute)?;
             if column.is_fulltext() {
@@ -2938,11 +3594,8 @@ impl<'a> SortKey<'a> {
                     _ => unreachable!(),
                 }
             } else if column.is_primary_key() {
-                match direction {
-                    ASC => Ok(SortKey::IdAsc(br_column)),
-                    DESC => Ok(SortKey::IdDesc(br_column)),
-                    _ => unreachable!("direction is 'asc' or 'desc'"),
-                }
+                let block_column = use_block_column.block_column(table);
+                Ok(SortKey::Id(direction, block_column))
             } else {
                 Ok(SortKey::Key {
                     column,
@@ -2953,14 +3606,16 @@ impl<'a> SortKey<'a> {
         }
 
         fn with_child_object_key<'a>(
-            parent_table: &'a Table,
-            child_table: &'a Table,
+            block: BlockNumber,
+            parent_table: dsl::Table<'a>,
+            child_table: dsl::Table<'a>,
             join_attribute: String,
             derived: bool,
             attribute: String,
-            br_column: Option<BlockRangeColumn<'a>>,
-            direction: &'static str,
+            use_block_column: UseBlockColumn,
+            direction: SortDirection,
         ) -> Result<SortKey<'a>, QueryExecutionError> {
+            let child_table = child_table.child(1);
             let sort_by_column = child_table.column_for_field(&attribute)?;
             if sort_by_column.is_fulltext() {
                 Err(QueryExecutionError::NotSupported(
@@ -2971,10 +3626,10 @@ impl<'a> SortKey<'a> {
                     true => (
                         parent_table.primary_key(),
                         child_table.column_for_field(&join_attribute).map_err(|_| {
-                            graph::constraint_violation!(
+                            graph::internal_error!(
                                 "Column for a join attribute `{}` of `{}` table not found",
                                 join_attribute,
-                                child_table.name.as_str()
+                                child_table.name()
                             )
                         })?,
                     ),
@@ -2982,10 +3637,10 @@ impl<'a> SortKey<'a> {
                         parent_table
                             .column_for_field(&join_attribute)
                             .map_err(|_| {
-                                graph::constraint_violation!(
+                                graph::internal_error!(
                                     "Column for a join attribute `{}` of `{}` table not found",
                                     join_attribute,
-                                    parent_table.name.as_str()
+                                    parent_table.name()
                                 )
                             })?,
                         child_table.primary_key(),
@@ -2993,39 +3648,37 @@ impl<'a> SortKey<'a> {
                 };
 
                 if sort_by_column.is_primary_key() {
-                    return match direction {
-                        ASC => Ok(SortKey::ChildKey(ChildKey::IdAsc(
-                            ChildIdDetails {
-                                parent_table,
-                                child_table,
-                                parent_join_column: parent_column,
-                                child_join_column: child_column,
-                                prefix: "cc".to_string(),
-                            },
-                            br_column,
-                        ))),
-                        DESC => Ok(SortKey::ChildKey(ChildKey::IdDesc(
-                            ChildIdDetails {
-                                parent_table,
-                                child_table,
-                                parent_join_column: parent_column,
-                                child_join_column: child_column,
-                                prefix: "cc".to_string(),
-                            },
-                            br_column,
-                        ))),
-                        _ => unreachable!("direction is 'asc' or 'desc'"),
-                    };
+                    let child_from = child_table.from_clause();
+                    let child_pk = child_table.primary_key();
+                    let child_br = child_table.block_column();
+                    let child_at_block = child_table.at_block(block);
+
+                    return Ok(SortKey::ChildKey(ChildKey::Id(
+                        direction,
+                        ChildIdDetails {
+                            child_table,
+                            child_from,
+                            parent_join_column: parent_column,
+                            child_join_column: child_column,
+                            child_pk,
+                            child_br,
+                            child_at_block,
+                        },
+                        use_block_column,
+                    )));
                 }
 
+                let child_table = child_table.child(1);
+                let child_at_block = child_table.at_block(block);
+                let child_from = child_table.from_clause();
                 Ok(SortKey::ChildKey(ChildKey::Single(ChildKeyDetails {
-                    parent_table,
-                    child_table,
+                    child_table: child_table.child(1),
+                    child_from,
                     parent_join_column: parent_column,
                     child_join_column: child_column,
-                    /// Sort by this column
+                    child_at_block,
+                    // Sort by this column
                     sort_by_column,
-                    prefix: "cc".to_string(),
                     direction,
                 })))
             }
@@ -3033,16 +3686,21 @@ impl<'a> SortKey<'a> {
 
         fn build_children_vec<'a>(
             layout: &'a Layout,
-            parent_table: &'a Table,
+            block: BlockNumber,
+            parent_table: dsl::Table<'a>,
             entity_types: Vec<EntityType>,
             child: EntityOrderByChildInfo,
-            direction: &'static str,
+            direction: SortDirection,
         ) -> Result<Vec<ChildKeyAndIdSharedDetails<'a>>, QueryExecutionError> {
-            return entity_types
+            assert!(entity_types.len() < 255);
+            entity_types
                 .iter()
                 .enumerate()
                 .map(|(i, entity_type)| {
-                    let child_table = layout.table_for_entity(entity_type)?;
+                    let child_table = layout
+                        .table_for_entity(entity_type)?
+                        .dsl_table()
+                        .child((i + 1) as u8);
                     let sort_by_column = child_table.column_for_field(&child.sort_by_attribute)?;
                     if sort_by_column.is_fulltext() {
                         Err(QueryExecutionError::NotSupported(
@@ -3055,10 +3713,10 @@ impl<'a> SortKey<'a> {
                                 child_table
                                     .column_for_field(&child.join_attribute)
                                     .map_err(|_| {
-                                        graph::constraint_violation!(
+                                        graph::internal_error!(
                                     "Column for a join attribute `{}` of `{}` table not found",
                                     child.join_attribute,
-                                    child_table.name.as_str()
+                                    child_table.name()
                                 )
                                     })?,
                             ),
@@ -3066,106 +3724,106 @@ impl<'a> SortKey<'a> {
                                 parent_table
                                     .column_for_field(&child.join_attribute)
                                     .map_err(|_| {
-                                        graph::constraint_violation!(
+                                        graph::internal_error!(
                                     "Column for a join attribute `{}` of `{}` table not found",
                                     child.join_attribute,
-                                    parent_table.name.as_str()
+                                    parent_table.name()
                                 )
                                     })?,
                                 child_table.primary_key(),
                             ),
                         };
 
+                        let child_pk = child_table.primary_key();
+                        let child_br = child_table.block_column();
+                        let child_at_block = child_table.at_block(block);
+                        let child_from = child_table.from_clause();
                         Ok(ChildKeyAndIdSharedDetails {
-                            parent_table,
                             child_table,
+                            child_from,
                             parent_join_column: parent_column,
                             child_join_column: child_column,
-                            prefix: format!("cc{}", i),
+                            child_pk,
+                            child_br,
+                            child_at_block,
                             sort_by_column,
                             direction,
                         })
                     }
                 })
-                .collect::<Result<Vec<ChildKeyAndIdSharedDetails<'a>>, QueryExecutionError>>();
+                .collect::<Result<Vec<ChildKeyAndIdSharedDetails<'a>>, QueryExecutionError>>()
         }
 
         fn with_child_interface_key<'a>(
             layout: &'a Layout,
-            parent_table: &'a Table,
+            block: BlockNumber,
+            parent_table: dsl::Table<'a>,
             child: EntityOrderByChildInfo,
             entity_types: Vec<EntityType>,
-            br_column: Option<BlockRangeColumn<'a>>,
-            direction: &'static str,
+            use_block_column: UseBlockColumn,
+            direction: SortDirection,
         ) -> Result<SortKey<'a>, QueryExecutionError> {
-            if let Some(first_entity) = entity_types.first() {
-                let child_table = layout.table_for_entity(first_entity)?;
-                let sort_by_column = child_table.column_for_field(&child.sort_by_attribute)?;
+            if entity_types.is_empty() {
+                return Err(QueryExecutionError::InternalError(
+                    "Cannot order by child interface with no implementing entity types".to_string(),
+                ));
+            }
 
-                if sort_by_column.is_fulltext() {
-                    Err(QueryExecutionError::NotSupported(
-                        "Sorting by fulltext fields".to_string(),
-                    ))
-                } else if sort_by_column.is_primary_key() {
-                    if direction == ASC {
-                        Ok(SortKey::ChildKey(ChildKey::ManyIdAsc(
-                            build_children_vec(
-                                layout,
-                                parent_table,
-                                entity_types,
-                                child,
-                                direction,
-                            )?
-                            .iter()
-                            .map(|details| ChildIdDetails {
-                                parent_table: details.parent_table,
-                                child_table: details.child_table,
-                                parent_join_column: details.parent_join_column,
-                                child_join_column: details.child_join_column,
-                                prefix: details.prefix.clone(),
-                            })
-                            .collect(),
-                            br_column,
-                        )))
-                    } else {
-                        Ok(SortKey::ChildKey(ChildKey::ManyIdDesc(
-                            build_children_vec(
-                                layout,
-                                parent_table,
-                                entity_types,
-                                child,
-                                direction,
-                            )?
-                            .iter()
-                            .map(|details| ChildIdDetails {
-                                parent_table: details.parent_table,
-                                child_table: details.child_table,
-                                parent_join_column: details.parent_join_column,
-                                child_join_column: details.child_join_column,
-                                prefix: details.prefix.clone(),
-                            })
-                            .collect(),
-                            br_column,
-                        )))
-                    }
-                } else {
-                    Ok(SortKey::ChildKey(ChildKey::Many(
-                        build_children_vec(layout, parent_table, entity_types, child, direction)?
-                            .iter()
-                            .map(|details| ChildKeyDetails {
-                                parent_table: details.parent_table,
-                                parent_join_column: details.parent_join_column,
-                                child_table: details.child_table,
-                                child_join_column: details.child_join_column,
-                                sort_by_column: details.sort_by_column,
-                                prefix: details.prefix.clone(),
-                                direction: details.direction,
-                            })
-                            .collect(),
-                    )))
-                }
+            let first_entity = entity_types.first().unwrap();
+            let child_table = layout.table_for_entity(first_entity)?;
+            let sort_by_column = child_table.column_for_field(&child.sort_by_attribute)?;
+
+            if sort_by_column.is_fulltext() {
+                Err(QueryExecutionError::NotSupported(
+                    "Sorting by fulltext fields".to_string(),
+                ))
+            } else if sort_by_column.is_primary_key() {
+                Ok(SortKey::ChildKey(ChildKey::ManyId(
+                    direction,
+                    build_children_vec(
+                        layout,
+                        block,
+                        parent_table,
+                        entity_types,
+                        child,
+                        direction,
+                    )?
+                    .iter()
+                    .map(|details| ChildIdDetails {
+                        child_table: details.child_table,
+                        child_from: details.child_from,
+                        parent_join_column: details.parent_join_column,
+                        child_join_column: details.child_join_column,
+                        child_pk: details.child_pk,
+                        child_br: details.child_br,
+                        child_at_block: details.child_at_block,
+                    })
+                    .collect(),
+                    use_block_column,
+                )))
             } else {
-                Ok(SortKey::ChildKey(ChildKey::Many(vec![])))
+                Ok(SortKey::ChildKey(ChildKey::Many(
+                    parent_table.primary_key(),
+                    build_children_vec(
+                        layout,
+                        block,
+                        parent_table,
+                        entity_types,
+                        child,
+                        direction,
+                    )?
+                    .iter()
+                    .map(|details| ChildKeyDetails {
+                        parent_join_column: details.parent_join_column,
+                        child_table: details.child_table,
+                        child_from: details.child_from,
+                        child_join_column: details.child_join_column,
+                        child_at_block: details.child_at_block,
+                        sort_by_column: details.sort_by_column,
+                        direction: details.direction,
+                    })
+                    .collect(),
+                )))
             }
         }
 
@@ -3177,63 +3835,80 @@ impl<'a> SortKey<'a> {
             .first_table()
             .expect("an entity query always contains at least one entity type/table");
 
-        let br_column = if collection.all_mutable() && ENV_VARS.store.order_by_block_range {
-            Some(BlockRangeColumn::new(table, "c.", block))
+        let use_block_column = if collection.all_mutable() && ENV_VARS.store.order_by_block_range {
+            UseBlockColumn::Yes
         } else {
-            None
+            UseBlockColumn::No
         };
 
+        use SortDirection::*;
         match order {
-            EntityOrder::Ascending(attr, _) => with_key(table, attr, filter, ASC, br_column),
-            EntityOrder::Descending(attr, _) => with_key(table, attr, filter, DESC, br_column),
-            EntityOrder::Default => Ok(SortKey::IdAsc(br_column)),
+            EntityOrder::Ascending(attr, _) => with_key(table, attr, filter, Asc, use_block_column),
+            EntityOrder::Descending(attr, _) => {
+                with_key(table, attr, filter, Desc, use_block_column)
+            }
+            EntityOrder::Default => Ok(SortKey::Id(Asc, use_block_column.block_column(table))),
             EntityOrder::Unordered => Ok(SortKey::None),
             EntityOrder::ChildAscending(kind) => match kind {
                 EntityOrderByChild::Object(child, entity_type) => with_child_object_key(
+                    block,
                     table,
-                    layout.table_for_entity(&entity_type)?,
+                    layout.table_for_entity(&entity_type)?.dsl_table(),
                     child.join_attribute,
                     child.derived,
                     child.sort_by_attribute,
-                    br_column,
-                    ASC,
+                    use_block_column,
+                    Asc,
+                ),
+                EntityOrderByChild::Interface(child, entity_types) => with_child_interface_key(
+                    layout,
+                    block,
+                    table,
+                    child,
+                    entity_types,
+                    use_block_column,
+                    Asc,
                 ),
-                EntityOrderByChild::Interface(child, entity_types) => {
-                    with_child_interface_key(layout, table, child, entity_types, br_column, ASC)
-                }
             },
             EntityOrder::ChildDescending(kind) => match kind {
                 EntityOrderByChild::Object(child, entity_type) => with_child_object_key(
+                    block,
                     table,
-                    layout.table_for_entity(&entity_type)?,
+                    layout.table_for_entity(&entity_type)?.dsl_table(),
                     child.join_attribute,
                     child.derived,
                     child.sort_by_attribute,
-                    br_column,
-                    DESC,
+                    use_block_column,
+                    Desc,
+                ),
+                EntityOrderByChild::Interface(child, entity_types) => with_child_interface_key(
+                    layout,
+                    block,
+                    table,
+                    child,
+                    entity_types,
+                    use_block_column,
+                    Desc,
                 ),
-                EntityOrderByChild::Interface(child, entity_types) => {
-                    with_child_interface_key(layout, table, child, entity_types, br_column, DESC)
-                }
             },
         }
     }
 
     /// Generate selecting the sort key if it is needed
-    fn select(
-        &self,
-        out: &mut AstPass<Pg>,
+    fn select<'b>(
+        &'b self,
+        out: &mut AstPass<'_, 'b, Pg>,
         select_statement_level: SelectStatementLevel,
     ) -> QueryResult<()> {
         match self {
             SortKey::None => {}
-            SortKey::IdAsc(br_column) | SortKey::IdDesc(br_column) => {
+            SortKey::Id(_, br_column) => {
                 if let Some(br_column) = br_column {
                     out.push_sql(", ");
 
                     match select_statement_level {
                         SelectStatementLevel::InnerStatement => {
-                            br_column.name(out);
+                            br_column.walk_ast(out.reborrow())?;
                             out.push_sql(" as ");
                             out.push_sql(SORT_KEY_COLUMN);
                         }
@@ -3247,13 +3922,13 @@ impl<'a> SortKey<'a> {
                 direction: _,
             } => {
                 if column.is_primary_key() {
-                    return Err(constraint_violation!("SortKey::Key never uses 'id'"));
+                    return Err(internal_error!("SortKey::Key never uses 'id'"));
                 }
 
                 match select_statement_level {
                     SelectStatementLevel::InnerStatement => {
-                        out.push_sql(", c.");
-                        out.push_identifier(column.name.as_str())?;
+                        out.push_sql(", ");
+                        column.walk_ast(out.reborrow())?;
                         out.push_sql(" as ");
                         out.push_sql(SORT_KEY_COLUMN);
                     }
@@ -3267,15 +3942,13 @@ impl<'a> SortKey<'a> {
                 match nested {
                     ChildKey::Single(child) => {
                         if child.sort_by_column.is_primary_key() {
-                            return Err(constraint_violation!("SortKey::Key never uses 'id'"));
+                            return Err(internal_error!("SortKey::Key never uses 'id'"));
                         }
 
                         match select_statement_level {
                             SelectStatementLevel::InnerStatement => {
                                 out.push_sql(", ");
-                                out.push_sql(child.prefix.as_str());
-                                out.push_sql(".");
-                                out.push_identifier(child.sort_by_column.name.as_str())?;
+                                child.sort_by_column.walk_ast(out.reborrow())?;
                             }
                             SelectStatementLevel::OuterStatement => {
                                 out.push_sql(", ");
@@ -3283,36 +3956,27 @@ impl<'a> SortKey<'a> {
                             }
                         }
                     }
-                    ChildKey::Many(children) => {
+                    ChildKey::Many(_, children) => {
                         for child in children.iter() {
                             if child.sort_by_column.is_primary_key() {
-                                return Err(constraint_violation!("SortKey::Key never uses 'id'"));
+                                return Err(internal_error!("SortKey::Key never uses 'id'"));
                             }
                             out.push_sql(", ");
-                            out.push_sql(child.prefix.as_str());
-                            out.push_sql(".");
-                            out.push_identifier(child.sort_by_column.name.as_str())?;
+                            child.sort_by_column.walk_ast(out.reborrow())?;
                         }
                     }
-                    ChildKey::ManyIdAsc(children, br_column)
-                    | ChildKey::ManyIdDesc(children, br_column) => {
+                    ChildKey::ManyId(_, children, UseBlockColumn::Yes) => {
                         for child in children.iter() {
-                            if let Some(br_column) = br_column {
-                                out.push_sql(", ");
-                                out.push_sql(child.prefix.as_str());
-                                out.push_sql(".");
-                                br_column.name(out);
-                            }
-                        }
-                    }
-                    ChildKey::IdAsc(child, br_column) | ChildKey::IdDesc(child, br_column) => {
-                        if let Some(br_column) = br_column {
                             out.push_sql(", ");
-                            out.push_sql(child.prefix.as_str());
-                            out.push_sql(".");
-                            br_column.name(out);
+                            child.child_br.walk_ast(out.reborrow())?;
                         }
                     }
+                    ChildKey::ManyId(_, _, UseBlockColumn::No) => { /* nothing to do */ }
+                    ChildKey::Id(_, child, UseBlockColumn::Yes) => {
+                        out.push_sql(", ");
+                        child.child_br.walk_ast(out.reborrow())?;
+                    }
+                    ChildKey::Id(_, _, UseBlockColumn::No) => { /* nothing to do  */ }
                 }
 
                 if let SelectStatementLevel::InnerStatement = select_statement_level {
@@ -3326,36 +3990,26 @@ impl<'a> SortKey<'a> {
 
     /// Generate
     ///   order by [name direction], id
-    fn order_by(&self, out: &mut AstPass<Pg>, use_sort_key_alias: bool) -> QueryResult<()> {
+    fn order_by<'b>(
+        &'b self,
+        out: &mut AstPass<'_, 'b, Pg>,
+        use_sort_key_alias: bool,
+    ) -> QueryResult<()> {
         match self {
             SortKey::None => Ok(()),
-            SortKey::IdAsc(br_column) => {
-                out.push_sql("order by ");
-                out.push_identifier(PRIMARY_KEY_COLUMN)?;
-                if let Some(br_column) = br_column {
-                    if use_sort_key_alias {
-                        out.push_sql(", ");
-                        out.push_sql(SORT_KEY_COLUMN);
-                    } else {
-                        out.push_sql(", ");
-                        br_column.bare_name(out);
-                    }
-                }
-                Ok(())
-            }
-            SortKey::IdDesc(br_column) => {
+            SortKey::Id(direction, br_column) => {
                 out.push_sql("order by ");
                 out.push_identifier(PRIMARY_KEY_COLUMN)?;
-                out.push_sql(" desc");
+                out.push_sql(direction.as_sql());
                 if let Some(br_column) = br_column {
                     if use_sort_key_alias {
                         out.push_sql(", ");
                         out.push_sql(SORT_KEY_COLUMN);
                     } else {
                         out.push_sql(", ");
-                        br_column.bare_name(out);
+                        out.push_sql(br_column.name());
                     }
-                    out.push_sql(" desc");
+                    out.push_sql(direction.as_sql());
                 }
                 Ok(())
             }
@@ -3365,75 +4019,37 @@ impl<'a> SortKey<'a> {
                 direction,
             } => {
                 out.push_sql("order by ");
-                SortKey::sort_expr(
-                    column,
-                    value,
-                    direction,
-                    None,
-                    None,
-                    use_sort_key_alias,
-                    out,
-                )
+                SortKey::sort_expr(column, value, direction, None, use_sort_key_alias, out)
             }
             SortKey::ChildKey(child) => {
                 out.push_sql("order by ");
                 match child {
                     ChildKey::Single(child) => SortKey::sort_expr(
-                        child.sort_by_column,
+                        &child.sort_by_column,
                         &None,
-                        child.direction,
-                        Some(&child.prefix),
+                        &child.direction,
                         Some("c"),
                         use_sort_key_alias,
                         out,
                     ),
-                    ChildKey::Many(children) => {
-                        let columns: Vec<(&Column, &str)> = children
-                            .iter()
-                            .map(|child| (child.sort_by_column, child.prefix.as_str()))
-                            .collect();
-                        SortKey::multi_sort_expr(
-                            columns,
-                            children.first().unwrap().direction,
-                            Some("c"),
-                            out,
-                        )
-                    }
+                    ChildKey::Many(parent_pk, children) => SortKey::multi_sort_expr(
+                        parent_pk,
+                        children,
+                        &children.first().unwrap().direction,
+                        out,
+                    ),
 
-                    ChildKey::ManyIdAsc(children, br_column) => {
-                        let prefixes: Vec<&str> =
-                            children.iter().map(|child| child.prefix.as_str()).collect();
-                        SortKey::multi_sort_id_expr(prefixes, ASC, br_column, out)
-                    }
-                    ChildKey::ManyIdDesc(children, br_column) => {
-                        let prefixes: Vec<&str> =
-                            children.iter().map(|child| child.prefix.as_str()).collect();
-                        SortKey::multi_sort_id_expr(prefixes, DESC, br_column, out)
+                    ChildKey::ManyId(direction, children, use_block_column) => {
+                        SortKey::multi_sort_id_expr(children, *direction, *use_block_column, out)
                     }
 
-                    ChildKey::IdAsc(child, br_column) => {
-                        out.push_sql(child.prefix.as_str());
-                        out.push_sql(".");
-                        out.push_identifier(PRIMARY_KEY_COLUMN)?;
-                        if let Some(br_column) = br_column {
-                            out.push_sql(", ");
-                            out.push_sql(child.prefix.as_str());
-                            out.push_sql(".");
-                            br_column.bare_name(out);
-                        }
-                        Ok(())
-                    }
-                    ChildKey::IdDesc(child, br_column) => {
-                        out.push_sql(child.prefix.as_str());
-                        out.push_sql(".");
-                        out.push_identifier(PRIMARY_KEY_COLUMN)?;
-                        out.push_sql(" desc");
-                        if let Some(br_column) = br_column {
+                    ChildKey::Id(direction, child, use_block_column) => {
+                        child.child_pk.walk_ast(out.reborrow())?;
+                        out.push_sql(direction.as_sql());
+                        if UseBlockColumn::Yes == *use_block_column {
                             out.push_sql(", ");
-                            out.push_sql(child.prefix.as_str());
-                            out.push_sql(".");
-                            br_column.bare_name(out);
-                            out.push_sql(" desc");
+                            child.child_br.walk_ast(out.reborrow())?;
+                            out.push_sql(direction.as_sql());
                         }
                         Ok(())
                     }
@@ -3447,23 +4063,23 @@ impl<'a> SortKey<'a> {
     /// TODO: Let's think how to detect if we need to use sort_key$ alias or not
     /// A boolean (use_sort_key_alias) is not a good idea and prone to errors.
     /// We could make it the standard and always use sort_key$ alias.
-    fn order_by_parent(&self, out: &mut AstPass<Pg>, use_sort_key_alias: bool) -> QueryResult<()> {
+    fn order_by_parent<'b>(
+        &'b self,
+        out: &mut AstPass<'_, 'b, Pg>,
+        use_sort_key_alias: bool,
+    ) -> QueryResult<()> {
         fn order_by_parent_id(out: &mut AstPass<Pg>) {
             out.push_sql("order by ");
-            out.push_sql(&*PARENT_ID);
+            out.push_sql(PARENT_ID);
             out.push_sql(", ");
         }
 
         match self {
             SortKey::None => Ok(()),
-            SortKey::IdAsc(_) => {
-                order_by_parent_id(out);
-                out.push_identifier(PRIMARY_KEY_COLUMN)
-            }
-            SortKey::IdDesc(_) => {
+            SortKey::Id(direction, _) => {
                 order_by_parent_id(out);
                 out.push_identifier(PRIMARY_KEY_COLUMN)?;
-                out.push_sql(" desc");
+                out.push_sql(direction.as_sql());
                 Ok(())
             }
             SortKey::Key {
@@ -3472,15 +4088,7 @@ impl<'a> SortKey<'a> {
                 direction,
             } => {
                 order_by_parent_id(out);
-                SortKey::sort_expr(
-                    column,
-                    value,
-                    direction,
-                    None,
-                    None,
-                    use_sort_key_alias,
-                    out,
-                )
+                SortKey::sort_expr(column, value, direction, None, use_sort_key_alias, out)
             }
             SortKey::ChildKey(_) => Err(diesel::result::Error::QueryBuilderError(
                 "SortKey::ChildKey cannot be used for parent ordering (yet)".into(),
@@ -3490,20 +4098,17 @@ impl<'a> SortKey<'a> {
 
     /// Generate
     ///   [name direction,] id
-    fn sort_expr(
-        column: &Column,
-        value: &Option<&str>,
-        direction: &str,
-        column_prefix: Option<&str>,
+    fn sort_expr<'b>(
+        column: &'b dsl::Column<'b>,
+        value: &'b Option<&str>,
+        direction: &'b SortDirection,
         rest_prefix: Option<&str>,
         use_sort_key_alias: bool,
-        out: &mut AstPass<Pg>,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         if column.is_primary_key() {
             // This shouldn't happen since we'd use SortKey::IdAsc/Desc
-            return Err(constraint_violation!(
-                "sort_expr called with primary key column"
-            ));
+            return Err(internal_error!("sort_expr called with primary key column"));
         }
 
         fn push_prefix(prefix: Option<&str>, out: &mut AstPass<Pg>) {
@@ -3513,7 +4118,7 @@ impl<'a> SortKey<'a> {
             }
         }
 
-        match &column.column_type {
+        match column.column_type() {
             ColumnType::TSVector(config) => {
                 let algorithm = match config.algorithm {
                     FulltextAlgorithm::Rank => "ts_rank(",
@@ -3523,238 +4128,200 @@ impl<'a> SortKey<'a> {
                 if use_sort_key_alias {
                     out.push_sql(SORT_KEY_COLUMN);
                 } else {
-                    let name = column.name.as_str();
-                    push_prefix(column_prefix, out);
-                    out.push_identifier(name)?;
+                    column.walk_ast(out.reborrow())?;
                 }
 
                 out.push_sql(", to_tsquery(");
 
-                out.push_bind_param::<Text, _>(&value.unwrap())?;
+                out.push_bind_param::<Text, _>(value.unwrap())?;
                 out.push_sql("))");
             }
             _ => {
                 if use_sort_key_alias {
                     out.push_sql(SORT_KEY_COLUMN);
                 } else {
-                    let name = column.name.as_str();
-                    push_prefix(column_prefix, out);
-                    out.push_identifier(name)?;
+                    column.walk_ast(out.reborrow())?;
                 }
             }
         }
-        out.push_sql(" ");
-        out.push_sql(direction);
+        out.push_sql(direction.as_sql());
         out.push_sql(", ");
         if !use_sort_key_alias {
             push_prefix(rest_prefix, out);
         }
         out.push_identifier(PRIMARY_KEY_COLUMN)?;
-        out.push_sql(" ");
-        out.push_sql(direction);
+        out.push_sql(direction.as_sql());
         Ok(())
     }
 
     /// Generate
     ///   [COALESCE(name1, name2) direction,] id1, id2
-    fn multi_sort_expr(
-        columns: Vec<(&Column, &str)>,
-        direction: &str,
-        rest_prefix: Option<&str>,
-        out: &mut AstPass<Pg>,
+    fn multi_sort_expr<'b>(
+        parent_pk: &'b dsl::Column<'b>,
+        children: &'b [ChildKeyDetails<'b>],
+        direction: &'b SortDirection,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
-        for (column, _) in columns.iter() {
-            if column.is_primary_key() {
+        for child in children {
+            let sort_by = &child.sort_by_column;
+            if sort_by.is_primary_key() {
                 // This shouldn't happen since we'd use SortKey::ManyIdAsc/ManyDesc
-                return Err(constraint_violation!(
+                return Err(internal_error!(
                     "multi_sort_expr called with primary key column"
                 ));
             }
 
-            match column.column_type {
-                ColumnType::TSVector(_) => {
-                    return Err(constraint_violation!("TSVector is not supported"));
-                }
-                _ => {}
-            }
-        }
-
-        fn push_prefix(prefix: Option<&str>, out: &mut AstPass<Pg>) {
-            if let Some(prefix) = prefix {
-                out.push_sql(prefix);
-                out.push_sql(".");
+            if let ColumnType::TSVector(_) = sort_by.column_type() {
+                return Err(internal_error!("TSVector is not supported"));
             }
         }
 
         out.push_sql("coalesce(");
 
-        for (i, (column, prefix)) in columns.iter().enumerate() {
-            if i != 0 {
+        let mut first = true;
+        for child in children {
+            if first {
+                first = false;
+            } else {
                 out.push_sql(", ");
             }
 
-            let name = column.name.as_str();
-            push_prefix(Some(prefix), out);
-            out.push_identifier(name)?;
+            child.sort_by_column.walk_ast(out.reborrow())?;
         }
 
-        out.push_sql(") ");
+        out.push_sql(")");
 
-        out.push_sql(direction);
+        out.push_sql(direction.as_sql());
         out.push_sql(", ");
-        push_prefix(rest_prefix, out);
-        out.push_identifier(PRIMARY_KEY_COLUMN)?;
-        out.push_sql(" ");
-        out.push_sql(direction);
+
+        parent_pk.walk_ast(out.reborrow())?;
+        out.push_sql(direction.as_sql());
         Ok(())
     }
 
     /// Generate
     ///   COALESCE(id1, id2) direction, [COALESCE(br_column1, br_column2) direction]
-    fn multi_sort_id_expr(
-        prefixes: Vec<&str>,
-        direction: &str,
-        br_column: &Option<BlockRangeColumn>,
-        out: &mut AstPass<Pg>,
+    fn multi_sort_id_expr<'b>(
+        children: &'b [ChildIdDetails<'b>],
+        direction: SortDirection,
+        use_block_column: UseBlockColumn,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
-        fn push_prefix(prefix: Option<&str>, out: &mut AstPass<Pg>) {
-            if let Some(prefix) = prefix {
-                out.push_sql(prefix);
-                out.push_sql(".");
-            }
-        }
-
         out.push_sql("coalesce(");
-        for (i, prefix) in prefixes.iter().enumerate() {
-            if i != 0 {
+        let mut first = true;
+        for child in children {
+            if first {
+                first = false;
+            } else {
                 out.push_sql(", ");
             }
 
-            push_prefix(Some(prefix), out);
-            out.push_identifier(PRIMARY_KEY_COLUMN)?;
+            child.child_join_column.walk_ast(out.reborrow())?;
         }
-        out.push_sql(") ");
+        out.push_sql(")");
 
-        out.push_sql(direction);
+        out.push_sql(direction.as_sql());
 
-        if let Some(br_column) = br_column {
+        if UseBlockColumn::Yes == use_block_column {
             out.push_sql(", coalesce(");
-            for (i, prefix) in prefixes.iter().enumerate() {
-                if i != 0 {
+            let mut first = true;
+            for child in children {
+                if first {
+                    first = false;
+                } else {
                     out.push_sql(", ");
                 }
 
-                push_prefix(Some(prefix), out);
-                br_column.bare_name(out);
+                child.child_br.walk_ast(out.reborrow())?;
             }
-            out.push_sql(") ");
-            out.push_sql(direction);
+            out.push_sql(")");
+            out.push_sql(direction.as_sql());
         }
 
         Ok(())
     }
 
-    fn add_child(&self, block: BlockNumber, out: &mut AstPass<Pg>) -> QueryResult<()> {
-        fn add(
-            block: BlockNumber,
-            child_table: &Table,
-            child_column: &Column,
-            parent_column: &Column,
-            prefix: &str,
-            out: &mut AstPass<Pg>,
+    fn add_child<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        fn add<'b>(
+            child_from: &'b dsl::FromTable<'b>,
+            child_column: &'b dsl::Column<'b>,
+            child_at_block: &'b dsl::AtBlock<'b>,
+            parent_column: &'b dsl::Column<'b>,
+            out: &mut AstPass<'_, 'b, Pg>,
         ) -> QueryResult<()> {
             out.push_sql(" left join ");
-            out.push_sql(child_table.qualified_name.as_str());
-            out.push_sql(" as ");
-            out.push_sql(prefix);
+            child_from.walk_ast(out.reborrow())?;
             out.push_sql(" on (");
 
             if child_column.is_list() {
                 // Type C: p.id = any(c.child_ids)
-                out.push_sql("c.");
-                out.push_identifier(parent_column.name.as_str())?;
+                parent_column.walk_ast(out.reborrow())?;
                 out.push_sql(" = any(");
-                out.push_sql(prefix);
-                out.push_sql(".");
-                out.push_identifier(child_column.name.as_str())?;
+                child_column.walk_ast(out.reborrow())?;
                 out.push_sql(")");
             } else if parent_column.is_list() {
                 // Type A: c.id = any(p.{parent_field})
-                out.push_sql(prefix);
-                out.push_sql(".");
-                out.push_identifier(child_column.name.as_str())?;
-                out.push_sql(" = any(c.");
-                out.push_identifier(parent_column.name.as_str())?;
+                child_column.walk_ast(out.reborrow())?;
+                out.push_sql(" = any(");
+                parent_column.walk_ast(out.reborrow())?;
                 out.push_sql(")");
             } else {
                 // Type B: c.id = p.{parent_field}
-                out.push_sql(prefix);
-                out.push_sql(".");
-                out.push_identifier(child_column.name.as_str())?;
+                child_column.walk_ast(out.reborrow())?;
                 out.push_sql(" = ");
-                out.push_sql("c.");
-                out.push_identifier(parent_column.name.as_str())?;
+                parent_column.walk_ast(out.reborrow())?;
             }
 
             out.push_sql(" and ");
-            out.push_sql(prefix);
-            out.push_sql(".");
-            out.push_identifier(BLOCK_RANGE_COLUMN)?;
-            out.push_sql(" @> ");
-            out.push_bind_param::<Integer, _>(&block)?;
+            child_at_block.walk_ast(out.reborrow())?;
             out.push_sql(") ");
 
             Ok(())
         }
 
-        match self {
-            SortKey::ChildKey(nested) => match nested {
+        if let SortKey::ChildKey(nested) = self {
+            match nested {
                 ChildKey::Single(child) => {
                     add(
-                        block,
-                        child.child_table,
-                        child.child_join_column,
-                        child.parent_join_column,
-                        &child.prefix,
+                        &child.child_from,
+                        &child.child_join_column,
+                        &child.child_at_block,
+                        &child.parent_join_column,
                         out,
                     )?;
                 }
-                ChildKey::Many(children) => {
+                ChildKey::Many(_, children) => {
                     for child in children.iter() {
                         add(
-                            block,
-                            child.child_table,
-                            child.child_join_column,
-                            child.parent_join_column,
-                            &child.prefix,
+                            &child.child_from,
+                            &child.child_join_column,
+                            &child.child_at_block,
+                            &child.parent_join_column,
                             out,
                         )?;
                     }
                 }
-                ChildKey::ManyIdAsc(children, _) | ChildKey::ManyIdDesc(children, _) => {
+                ChildKey::ManyId(_, children, _) => {
                     for child in children.iter() {
                         add(
-                            block,
-                            child.child_table,
-                            child.child_join_column,
-                            child.parent_join_column,
-                            &child.prefix,
+                            &child.child_from,
+                            &child.child_join_column,
+                            &child.child_at_block,
+                            &child.parent_join_column,
                             out,
                         )?;
                     }
                 }
-                ChildKey::IdAsc(child, _) | ChildKey::IdDesc(child, _) => {
+                ChildKey::Id(_, child, _) => {
                     add(
-                        block,
-                        child.child_table,
-                        child.child_join_column,
-                        child.parent_join_column,
-                        &child.prefix,
+                        &child.child_from,
+                        &child.child_join_column,
+                        &child.child_at_block,
+                        &child.parent_join_column,
                         out,
                     )?;
                 }
-            },
-            _ => {}
+            }
         }
         Ok(())
     }
@@ -3802,11 +4369,11 @@ impl QueryFragment<Pg> for FilterRange {
 #[derive(Debug, Clone)]
 pub struct FilterQuery<'a> {
     collection: &'a FilterCollection<'a>,
-    sort_key: SortKey<'a>,
-    range: FilterRange,
+    limit: ParentLimit<'a>,
     block: BlockNumber,
     query_id: Option<String>,
     site: &'a Site,
+    rollup: Option<&'a Rollup>,
 }
 
 /// String representation that is useful for debugging when `walk_ast` fails
@@ -3815,7 +4382,7 @@ impl<'a> fmt::Display for FilterQuery<'a> {
         write!(
             f,
             "from {} order {} {} at {}",
-            &self.collection, &self.sort_key, &self.range, self.block
+            &self.collection, &self.limit.sort_key, &self.limit.range, self.block
         )?;
         if let Some(query_id) = &self.query_id {
             write!(f, " query_id {}", query_id)?;
@@ -3834,46 +4401,91 @@ impl<'a> FilterQuery<'a> {
         block: BlockNumber,
         query_id: Option<String>,
         site: &'a Site,
+        aggregation_current: Option<AggregationCurrent>,
     ) -> Result<Self, QueryExecutionError> {
-        let sort_key = SortKey::new(order, collection, filter, block, layout)?;
+        let sort_key = SortKey::new(order, collection, filter, layout, block)?;
+        let range = FilterRange(range);
+        let limit = ParentLimit { sort_key, range };
+        let rollup = Self::find_rollup(collection, layout, aggregation_current)?;
 
         Ok(FilterQuery {
             collection,
-            sort_key,
-            range: FilterRange(range),
+            limit,
             block,
             query_id,
             site,
+            rollup,
         })
     }
 
+    /// Finds the relevant [Rollup] for an aggregation entity query when the query requires the current bucket.
+    ///
+    /// Returns `None` for non-aggregation entity queries.
+    ///
+    /// Returns an error if the query is not supported.
+    fn find_rollup(
+        collection: &'a FilterCollection,
+        layout: &'a Layout,
+        aggregation_current: Option<AggregationCurrent>,
+    ) -> Result<Option<&'a Rollup>, QueryExecutionError> {
+        if !matches!(aggregation_current, Some(AggregationCurrent::Include)) {
+            return Ok(None);
+        }
+
+        // Determine which table and column_names to check based on collection type.
+        // We support root queries (All with 1 entity) and single-window nested queries.
+        let (object_name, column_names) = match collection {
+            FilterCollection::All(entities) if entities.len() == 1 => {
+                let entity = &entities[0];
+                (
+                    entity.table.meta.object.as_str(),
+                    &entity.column_names,
+                )
+            }
+            FilterCollection::SingleWindow(window) => (
+                window.table.meta.object.as_str(),
+                &window.column_names,
+            ),
+            _ => {
+                return Err(QueryExecutionError::NotSupported(
+                    "The current aggregation bucket can only be queried in a root query for one aggregation entity or a single-window nested query".to_string(),
+                ))
+            }
+        };
+
+        // This is not supported because the use of `SELECT *` does not always produce the expected results when combined with `UNION ALL`.
+        if matches!(column_names, AttributeNames::All) {
+            return Err(QueryExecutionError::NotSupported(
+                "The current aggregation bucket can only be queried when fields are explicitly selected".to_string())
+            );
+        }
+
+        Ok(layout
+            .rollups
+            .iter()
+            .find(|rollup| rollup.agg_table.object.as_str() == object_name))
+    }
+
     /// Generate
     ///     from schema.table c
     ///    where block_range @> $block
     ///      and query_filter
     /// Only used when the query is against a `FilterCollection::All`, i.e.
     /// when we do not need to window
-    fn filtered_rows(
-        &self,
-        table: &Table,
-        table_filter: &Option<QueryFilter<'a>>,
-        mut out: AstPass<Pg>,
+    fn filtered_rows<'b>(
+        &'b self,
+        wh: &'b WholeTable<'a>,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         out.push_sql("\n  from ");
-        out.push_sql(table.qualified_name.as_str());
-        out.push_sql(" c");
+        wh.from_table.walk_ast(out.reborrow())?;
 
-        self.sort_key.add_child(self.block, &mut out)?;
+        self.limit.sort_key.add_child(out)?;
 
         out.push_sql("\n where ");
 
-        let filters_by_id = {
-            let entity_filter = table_filter.as_ref().map(|f| f.filter);
-            matches!(entity_filter, Some(EntityFilter::Equal(attr, _)) if attr == "id")
-        };
-
-        BlockRangeColumn::new(table, "c.", self.block).contains(&mut out, filters_by_id)?;
-        if let Some(filter) = table_filter {
+        wh.at_block.walk_ast(out.reborrow())?;
+        if let Some(filter) = &wh.filter {
             out.push_sql(" and ");
             filter.walk_ast(out.reborrow())?;
         }
@@ -3881,9 +4493,9 @@ impl<'a> FilterQuery<'a> {
         Ok(())
     }
 
-    fn select_entity_and_data(table: &Table, out: &mut AstPass<Pg>) {
+    fn select_entity_and_data(table: dsl::Table<'_>, out: &mut AstPass<Pg>) {
         out.push_sql("select '");
-        out.push_sql(table.object.as_str());
+        out.push_sql(table.meta.object.as_str());
         out.push_sql("' as entity, to_jsonb(c.*) as data");
     }
 
@@ -3899,21 +4511,61 @@ impl<'a> FilterQuery<'a> {
     ///         where block_range @> $block
     ///           and filter
     ///         order by .. limit .. skip ..) c
-    fn query_no_window_one_entity(
-        &self,
-        table: &Table,
-        filter: &Option<QueryFilter>,
-        mut out: AstPass<Pg>,
-        column_names: &AttributeNames,
+    ///
+    /// For aggregation entity queries that require the current bucket,
+    /// the generated query has the following structure:
+    ///
+    ///   select '..' as entity, to_jsonb(e.*) as data
+    ///     from (
+    ///       (select {column names} from agg_table c where {filters} limit {limit + skip + 1})
+    ///         union all
+    ///       (select {column names} from ({current bucket query from agg source table} + {filters}) c)
+    ///     ) c order by .. limit .. skip ..
+    fn query_no_window_one_entity<'b>(
+        &'b self,
+        wh: &'b WholeTable<'a>,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
-        Self::select_entity_and_data(table, &mut out);
-        out.push_sql(" from (select ");
-        write_column_names(column_names, table, Some("c."), &mut out)?;
-        self.filtered_rows(table, filter, out.reborrow())?;
-        out.push_sql("\n ");
-        self.sort_key.order_by(&mut out, false)?;
-        self.range.walk_ast(out.reborrow())?;
-        out.push_sql(") c");
+        Self::select_entity_and_data(wh.table, out);
+        out.push_sql(" from (");
+
+        match self.rollup {
+            Some(rollup) => {
+                out.push_sql("(select ");
+                write_column_names(&wh.column_names, wh.table, Some("c."), out)?;
+                self.filtered_rows(wh, out)?;
+                out.push_sql("\n ");
+                self.limit.sort_key.order_by(out, false)?;
+                out.push_sql(" limit ");
+                out.push_sql(&self.limit.max_num_rows().to_string());
+                out.push_sql(") union all (select ");
+                write_column_names(&wh.column_names, wh.table, Some("c."), out)?;
+                out.push_sql(" from (");
+                let mut current_sql_split = rollup.select_current_sql.split("/*FILTERS*/");
+                out.push_sql(current_sql_split.next().unwrap());
+                out.push_sql(" and ");
+                wh.at_block.walk_ast(out.reborrow())?;
+                if let Some(filter) = &wh.filter {
+                    out.push_sql(" and ");
+                    filter.walk_ast(out.reborrow())?;
+                }
+                out.push_sql(current_sql_split.next().unwrap());
+                out.push_sql(") c ) ) c");
+                out.push_sql("\n ");
+                self.limit.sort_key.order_by(out, false)?;
+                self.limit.range.walk_ast(out.reborrow())?;
+            }
+            None => {
+                out.push_sql("select ");
+                write_column_names(&wh.column_names, wh.table, Some("c."), out)?;
+                self.filtered_rows(wh, out)?;
+                out.push_sql("\n ");
+                self.limit.sort_key.order_by(out, false)?;
+                self.limit.range.walk_ast(out.reborrow())?;
+                out.push_sql(") c");
+            }
+        }
+
         Ok(())
     }
 
@@ -3921,33 +4573,92 @@ impl<'a> FilterQuery<'a> {
     ///
     /// Generate a query
     ///   select '..' as entity, to_jsonb(e.*) as data
-    ///     from (select c.*, p.id as g$parent_id from {window.children(...)}) c
+    ///     from (select {column_names}, p.id as g$parent_id from {window.children(...)}) c
     ///     order by c.g$parent_id, {sort_key}
     ///     limit {first} offset {skip}
-    fn query_window_one_entity(
-        &self,
-        window: &FilterWindow,
-        mut out: AstPass<Pg>,
+    ///
+    /// For aggregation entity queries that require the current bucket,
+    /// the generated query has the following structure:
+    ///
+    ///   select '..' as entity, to_jsonb(e.*) as data
+    ///     from (
+    ///       (select {column_names}, p.id::text as g$parent_id from {window.children(...)})
+    ///       union all
+    ///       (select {column_names}, c.{link_col}::text as g$parent_id
+    ///          from ({current bucket query with filters}) c
+    ///         where c.{link_col} = any({parent_ids}))
+    ///     ) c
+    ///     order by c.g$parent_id, {sort_key}
+    fn query_window_one_entity<'b>(
+        &'b self,
+        window: &'b FilterWindow,
+        mut out: AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         Self::select_entity_and_data(window.table, &mut out);
-        out.push_sql(" from (\n");
-        out.push_sql("select c.*, p.id::text as ");
-        out.push_sql(&*PARENT_ID);
-        window.children(
-            ParentLimit::Ranked(&self.sort_key, &self.range),
-            self.block,
-            out.reborrow(),
-        )?;
-        out.push_sql(") c");
-        out.push_sql("\n ");
-        self.sort_key.order_by_parent(&mut out, false)
+
+        match self.rollup {
+            Some(rollup) => {
+                out.push_sql(" from ((select ");
+                write_column_names(&window.column_names, window.table, Some("c."), &mut out)?;
+                out.push_sql(", p.id::text as ");
+                out.push_sql(PARENT_ID);
+                window.children(false, &self.limit, &mut out)?;
+                out.push_sql(") union all (select ");
+                write_column_names(&window.column_names, window.table, Some("c."), &mut out)?;
+
+                // Determine the link column name from the window's link.
+                // For Direct links, the column name on the aggregation table
+                // matches the dimension column on the source timeseries table.
+                let link_col_name = match &window.link {
+                    TableLink::Direct(col, _) => col.name(),
+                    TableLink::Parent(_, _) => {
+                        return Err(diesel::result::Error::QueryBuilderError(
+                            "current aggregation bucket is not supported for Parent-linked nested queries".into(),
+                        ));
+                    }
+                };
+
+                out.push_sql(", c.\"");
+                out.push_sql(link_col_name);
+                out.push_sql("\"::text as ");
+                out.push_sql(PARENT_ID);
+                out.push_sql(" from (");
+
+                let mut current_sql_split = rollup.select_current_sql.split("/*FILTERS*/");
+                out.push_sql(current_sql_split.next().unwrap());
+                out.push_sql(" and ");
+                window.at_block.walk_ast(out.reborrow())?;
+                if let Some(filter) = &window.query_filter {
+                    out.push_sql(" and ");
+                    filter.walk_ast(out.reborrow())?;
+                }
+                out.push_sql(current_sql_split.next().unwrap());
+                out.push_sql(") c where c.\"");
+                out.push_sql(link_col_name);
+                out.push_sql("\" = any(");
+                window.ids.push_bind_param(&mut out)?;
+                out.push_sql("))) c");
+                out.push_sql("\n ");
+                self.limit.sort_key.order_by_parent(&mut out, false)
+            }
+            None => {
+                out.push_sql(" from (select ");
+                write_column_names(&window.column_names, window.table, Some("c."), &mut out)?;
+                out.push_sql(", p.id::text as ");
+                out.push_sql(PARENT_ID);
+                window.children(false, &self.limit, &mut out)?;
+                out.push_sql(") c");
+                out.push_sql("\n ");
+                self.limit.sort_key.order_by_parent(&mut out, false)
+            }
+        }
     }
 
     /// No windowing, but multiple entity types
-    fn query_no_window(
-        &self,
-        entities: &[(&Table, Option<QueryFilter>, AttributeNames)],
-        mut out: AstPass<Pg>,
+    fn query_no_window<'b>(
+        &'b self,
+        entities: &'b [WholeTable<'a>],
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         // We have multiple tables which might have different schemas since
         // the entity_types come from implementing the same interface. We
@@ -3976,7 +4687,7 @@ impl<'a> FilterQuery<'a> {
 
         // Step 1: build matches CTE
         out.push_sql("with matches as (");
-        for (i, (table, filter, _column_names)) in entities.iter().enumerate() {
+        for (i, wh) in entities.iter().enumerate() {
             if i > 0 {
                 out.push_sql("\nunion all\n");
             }
@@ -3985,46 +4696,48 @@ impl<'a> FilterQuery<'a> {
             //        c.vid,
             //        c.${sort_key}
             out.push_sql("select '");
-            out.push_sql(table.object.as_str());
+            out.push_sql(wh.table.meta.object.as_str());
             out.push_sql("' as entity, c.id, c.vid");
-            self.sort_key
-                .select(&mut out, SelectStatementLevel::InnerStatement)?; // here
-            self.filtered_rows(table, filter, out.reborrow())?;
+            self.limit
+                .sort_key
+                .select(out, SelectStatementLevel::InnerStatement)?; // here
+            self.filtered_rows(wh, out)?;
         }
         out.push_sql("\n ");
-        self.sort_key.order_by(&mut out, true)?;
-        self.range.walk_ast(out.reborrow())?;
+        self.limit.sort_key.order_by(out, true)?;
+        self.limit.range.walk_ast(out.reborrow())?;
 
         out.push_sql(")\n");
 
         // Step 2: convert to JSONB
-        for (i, (table, _, column_names)) in entities.iter().enumerate() {
+        for (i, wh) in entities.iter().enumerate() {
             if i > 0 {
                 out.push_sql("\nunion all\n");
             }
             out.push_sql("select m.entity, ");
-            jsonb_build_object(column_names, "c", table, &mut out)?;
+            jsonb_build_object(&wh.column_names, "c", wh.table, out)?;
             out.push_sql(" as data, c.id");
-            self.sort_key
-                .select(&mut out, SelectStatementLevel::OuterStatement)?;
+            self.limit
+                .sort_key
+                .select(out, SelectStatementLevel::OuterStatement)?;
             out.push_sql("\n  from ");
-            out.push_sql(table.qualified_name.as_str());
-            out.push_sql(" c,");
+            wh.from_table.walk_ast(out.reborrow())?;
+            out.push_sql(" ,");
             out.push_sql(" matches m");
             out.push_sql("\n where c.vid = m.vid and m.entity = ");
-            out.push_bind_param::<Text, _>(&table.object.as_str())?;
+            out.push_bind_param::<Text, _>(wh.table.meta.object.as_str())?;
         }
         out.push_sql("\n ");
-        self.sort_key.order_by(&mut out, true)?;
+        self.limit.sort_key.order_by(out, true)?;
         Ok(())
     }
 
     /// Multiple windows
-    fn query_window(
-        &self,
-        windows: &[FilterWindow],
-        parent_ids: &IdList,
-        mut out: AstPass<Pg>,
+    fn query_window<'b>(
+        &'b self,
+        windows: &'b [FilterWindow],
+        parent_ids: &'b IdList,
+        out: &mut AstPass<'_, 'b, Pg>,
     ) -> QueryResult<()> {
         // Note that a CTE is an optimization fence, and since we use
         // `matches` multiple times, we actually want to materialize it first
@@ -4055,18 +4768,18 @@ impl<'a> FilterQuery<'a> {
         out.push_sql("with matches as (");
         out.push_sql("select c.* from ");
         out.push_sql("unnest(");
-        parent_ids.push_bind_param(&mut out)?;
+        parent_ids.push_bind_param(out)?;
         out.push_sql(") as q(id)\n");
         out.push_sql(" cross join lateral (");
         for (i, window) in windows.iter().enumerate() {
             if i > 0 {
                 out.push_sql("\nunion all\n");
             }
-            window.children_uniform(&self.sort_key, self.block, out.reborrow())?;
+            window.children_uniform(&self.limit, out.reborrow())?;
         }
         out.push_sql("\n");
-        self.sort_key.order_by(&mut out, true)?;
-        self.range.walk_ast(out.reborrow())?;
+        self.limit.sort_key.order_by(out, true)?;
+        self.limit.range.walk_ast(out.reborrow())?;
         out.push_sql(") c)\n");
 
         // Step 2: convert to JSONB
@@ -4081,8 +4794,8 @@ impl<'a> FilterQuery<'a> {
             .iter()
             .unique_by(|window| {
                 (
-                    &window.table.qualified_name,
-                    &window.table.object,
+                    &window.table.meta.qualified_name,
+                    &window.table.meta.object,
                     &window.column_names,
                 )
             })
@@ -4093,21 +4806,21 @@ impl<'a> FilterQuery<'a> {
                 out.push_sql("\nunion all\n");
             }
             out.push_sql("select m.*, ");
-            jsonb_build_object(&window.column_names, "c", window.table, &mut out)?;
+            jsonb_build_object(&window.column_names, "c", window.table, out)?;
             out.push_sql("|| jsonb_build_object('g$parent_id', m.g$parent_id) as data");
             out.push_sql("\n  from ");
-            out.push_sql(window.table.qualified_name.as_str());
-            out.push_sql(" c, matches m\n where c.vid = m.vid and m.entity = '");
-            out.push_sql(window.table.object.as_str());
+            window.from_table.walk_ast(out.reborrow())?;
+            out.push_sql(", matches m\n where c.vid = m.vid and m.entity = '");
+            out.push_sql(window.table.meta.object.as_str());
             out.push_sql("'");
         }
         out.push_sql("\n ");
-        self.sort_key.order_by_parent(&mut out, true)
+        self.limit.sort_key.order_by_parent(out, true)
     }
 }
 
 impl<'a> QueryFragment<Pg> for FilterQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
         if self.collection.is_empty() {
             return Ok(());
@@ -4136,17 +4849,17 @@ impl<'a> QueryFragment<Pg> for FilterQuery<'a> {
         match &self.collection {
             FilterCollection::All(entities) => {
                 if entities.len() == 1 {
-                    let (table, filter, column_names) = entities
+                    let wh = entities
                         .first()
                         .expect("a query always uses at least one table");
-                    self.query_no_window_one_entity(table, filter, out, column_names)
+                    self.query_no_window_one_entity(wh, &mut out)
                 } else {
-                    self.query_no_window(entities, out)
+                    self.query_no_window(entities, &mut out)
                 }
             }
             FilterCollection::SingleWindow(window) => self.query_window_one_entity(window, out),
             FilterCollection::MultiWindow(windows, parent_ids) => {
-                self.query_window(windows, parent_ids, out)
+                self.query_window(windows, parent_ids, &mut out)
             }
         }
     }
@@ -4158,10 +4871,8 @@ impl<'a> QueryId for FilterQuery<'a> {
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, EntityData> for FilterQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<EntityData>> {
-        conn.query_by_name(&self)
-    }
+impl<'a> Query for FilterQuery<'a> {
+    type SqlType = Untyped;
 }
 
 impl<'a, Conn> RunQueryDsl<Conn> for FilterQuery<'a> {}
@@ -4182,7 +4893,7 @@ impl<'a> ClampRangeQuery<'a> {
         block: BlockNumber,
     ) -> Result<Self, StoreError> {
         if table.immutable {
-            Err(graph::constraint_violation!(
+            Err(graph::internal_error!(
                 "immutable entities can not be deleted or updated (table `{}`)",
                 table.qualified_name
             ))
@@ -4198,7 +4909,7 @@ impl<'a> ClampRangeQuery<'a> {
 }
 
 impl<'a> QueryFragment<Pg> for ClampRangeQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         // update table
         //    set block_range = int4range(lower(block_range), $block)
         //  where id in (id1, id2, ..., idN)
@@ -4210,7 +4921,7 @@ impl<'a> QueryFragment<Pg> for ClampRangeQuery<'a> {
         self.br_column.clamp(&mut out)?;
         out.push_sql("\n where ");
 
-        self.table.primary_key().is_in(&self.entity_ids, &mut out)?;
+        id_is_in(self.entity_ids, &mut out)?;
         out.push_sql(" and (");
         self.br_column.latest(&mut out);
         out.push_sql(")");
@@ -4230,27 +4941,11 @@ impl<'a, Conn> RunQueryDsl<Conn> for ClampRangeQuery<'a> {}
 /// Helper struct for returning the id's touched by the RevertRemove and
 /// RevertExtend queries
 #[derive(QueryableByName, PartialEq, Eq, Hash)]
-struct ReturnedEntityData {
-    #[sql_type = "Text"]
+pub struct ReturnedEntityData {
+    #[diesel(sql_type = Text)]
     pub id: String,
 }
 
-impl ReturnedEntityData {
-    /// Convert primary key ids from Postgres' internal form to the format we
-    /// use by stripping `\\x` off the front of bytes strings
-    fn as_ids(table: &Table, data: Vec<ReturnedEntityData>) -> QueryResult<Vec<Id>> {
-        let id_type = table.primary_key().column_type.id_type()?;
-
-        data.into_iter()
-            .map(|s| match id_type {
-                IdType::String | IdType::Int8 => id_type.parse(Word::from(s.id)),
-                IdType::Bytes => id_type.parse(Word::from(s.id.trim_start_matches("\\x"))),
-            })
-            .collect::<Result<_, _>>()
-            .map_err(|e| diesel::result::Error::DeserializationError(e.into()))
-    }
-}
-
 /// A query that removes all versions whose block range lies entirely
 /// beyond `block`.
 #[derive(Debug, Clone)]
@@ -4267,7 +4962,7 @@ impl<'a> RevertRemoveQuery<'a> {
 }
 
 impl<'a> QueryFragment<Pg> for RevertRemoveQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
         // Construct a query
@@ -4291,11 +4986,8 @@ impl<'a> QueryId for RevertRemoveQuery<'a> {
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, Id> for RevertRemoveQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<Id>> {
-        conn.query_by_name(&self)
-            .and_then(|data| ReturnedEntityData::as_ids(self.table, data))
-    }
+impl<'a> Query for RevertRemoveQuery<'a> {
+    type SqlType = Untyped;
 }
 
 impl<'a, Conn> RunQueryDsl<Conn> for RevertRemoveQuery<'a> {}
@@ -4310,7 +5002,7 @@ pub struct RevertClampQuery<'a> {
 impl<'a> RevertClampQuery<'a> {
     pub(crate) fn new(table: &'a Table, block: BlockNumber) -> Result<Self, StoreError> {
         if table.immutable {
-            Err(graph::constraint_violation!(
+            Err(graph::internal_error!(
                 "can not revert clamping in immutable table `{}`",
                 table.qualified_name
             ))
@@ -4321,7 +5013,7 @@ impl<'a> RevertClampQuery<'a> {
 }
 
 impl<'a> QueryFragment<Pg> for RevertClampQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
         // Construct a query
@@ -4374,11 +5066,8 @@ impl<'a> QueryId for RevertClampQuery<'a> {
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, Id> for RevertClampQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<Id>> {
-        conn.query_by_name(&self)
-            .and_then(|data| ReturnedEntityData::as_ids(self.table, data))
-    }
+impl<'a> Query for RevertClampQuery<'a> {
+    type SqlType = Untyped;
 }
 
 impl<'a, Conn> RunQueryDsl<Conn> for RevertClampQuery<'a> {}
@@ -4402,6 +5091,7 @@ pub struct CopyEntityBatchQuery<'a> {
     columns: Vec<&'a Column>,
     first_vid: i64,
     last_vid: i64,
+    target_block: BlockNumber,
 }
 
 impl<'a> CopyEntityBatchQuery<'a> {
@@ -4410,10 +5100,17 @@ impl<'a> CopyEntityBatchQuery<'a> {
         src: &'a Table,
         first_vid: i64,
         last_vid: i64,
+        target_block: BlockNumber,
     ) -> Result<Self, StoreError> {
         let mut columns = Vec::new();
         for dcol in &dst.columns {
-            if let Some(scol) = src.column(&dcol.name) {
+            // Match against all source columns, INCLUDING fulltext (tsvector)
+            // columns, which `Table::column` deliberately hides. The stored
+            // tsvector is copied verbatim; without this, fulltext columns
+            // would be silently dropped from the copy (they are nullable, so
+            // the error branch below is not taken) and the destination's
+            // search index would be left empty.
+            if let Some(scol) = src.column_including_fulltext(&dcol.name) {
                 if let Some(msg) = dcol.is_assignable_from(scol, &src.object) {
                     return Err(anyhow!("{}", msg).into());
                 } else {
@@ -4436,17 +5133,26 @@ impl<'a> CopyEntityBatchQuery<'a> {
             columns,
             first_vid,
             last_vid,
+            target_block,
         })
     }
+
+    pub fn count_current(self) -> CountCurrentVersionsQuery<'a> {
+        CountCurrentVersionsQuery::new(self)
+    }
 }
 
 impl<'a> QueryFragment<Pg> for CopyEntityBatchQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
+        let has_vid_seq = self.dst.object.has_vid_seq();
+
         // Construct a query
         //   insert into {dst}({columns})
         //   select {columns} from {src}
+        //    where vid >= {first_vid} and vid <= {last_vid}
+        //   returning {upper_inf(block_range)|true}
         out.push_sql("insert into ");
         out.push_sql(self.dst.qualified_name.as_str());
         out.push_sql("(");
@@ -4464,6 +5170,9 @@ impl<'a> QueryFragment<Pg> for CopyEntityBatchQuery<'a> {
             out.push_sql(", ");
             out.push_sql(CAUSALITY_REGION_COLUMN);
         };
+        if has_vid_seq {
+            out.push_sql(", vid");
+        }
 
         out.push_sql(")\nselect ");
         for column in &self.columns {
@@ -4509,7 +5218,16 @@ impl<'a> QueryFragment<Pg> for CopyEntityBatchQuery<'a> {
                 );
                 out.push_sql(&checked_conversion);
             }
-            (false, false) => out.push_sql(BLOCK_RANGE_COLUMN),
+            (false, false) => {
+                let range_conv = format!(
+                    r#"
+                case when upper({BLOCK_RANGE_COLUMN}) > {}
+                     then int4range(lower({BLOCK_RANGE_COLUMN}), null)
+                     else {BLOCK_RANGE_COLUMN} end"#,
+                    self.target_block
+                );
+                out.push_sql(&range_conv)
+            }
         }
 
         match (self.src.has_causality_region, self.dst.has_causality_region) {
@@ -4522,19 +5240,39 @@ impl<'a> QueryFragment<Pg> for CopyEntityBatchQuery<'a> {
                 out.push_sql(", 0");
             }
             (true, false) => {
-                return Err(constraint_violation!(
+                return Err(internal_error!(
                     "can not copy entity type {} to {} because the src has a causality region but the dst does not",
                     self.src.object.as_str(),
                     self.dst.object.as_str()
                 ));
             }
         }
+        if has_vid_seq {
+            out.push_sql(", vid");
+        }
+
         out.push_sql(" from ");
         out.push_sql(self.src.qualified_name.as_str());
         out.push_sql(" where vid >= ");
         out.push_bind_param::<BigInt, _>(&self.first_vid)?;
         out.push_sql(" and vid <= ");
         out.push_bind_param::<BigInt, _>(&self.last_vid)?;
+        out.push_sql(" and ");
+        if self.src.immutable {
+            out.push_sql(BLOCK_COLUMN);
+        } else {
+            out.push_sql("lower(");
+            out.push_sql(BLOCK_RANGE_COLUMN);
+            out.push_sql(")");
+        }
+        out.push_sql(" <= ");
+        out.push_bind_param::<Integer, _>(&self.target_block)?;
+        out.push_sql("\n returning ");
+        if self.dst.immutable {
+            out.push_sql("true");
+        } else {
+            out.push_sql(BLOCK_RANGE_CURRENT);
+        }
         Ok(())
     }
 }
@@ -4547,17 +5285,43 @@ impl<'a> QueryId for CopyEntityBatchQuery<'a> {
 
 impl<'a, Conn> RunQueryDsl<Conn> for CopyEntityBatchQuery<'a> {}
 
-/// Helper struct for returning the id's touched by the RevertRemove and
-/// RevertExtend queries
-#[derive(QueryableByName, PartialEq, Eq, Hash)]
-pub struct CopyVid {
-    #[sql_type = "BigInt"]
-    pub vid: i64,
+#[derive(Debug, Clone)]
+pub struct CountCurrentVersionsQuery<'a> {
+    copy: CopyEntityBatchQuery<'a>,
 }
 
+impl<'a> CountCurrentVersionsQuery<'a> {
+    pub fn new(copy: CopyEntityBatchQuery<'a>) -> Self {
+        Self { copy }
+    }
+}
+impl<'a> QueryFragment<Pg> for CountCurrentVersionsQuery<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        // Generate a query
+        // with copy_cte as ( {copy} )
+        // select count(*) from copy_cte where {block_range_current}
+        out.push_sql("with copy_cte(current) as (");
+        self.copy.walk_ast(out.reborrow())?;
+        out.push_sql(")\nselect count(*) from copy_cte where current");
+        Ok(())
+    }
+}
+
+impl<'a> QueryId for CountCurrentVersionsQuery<'a> {
+    type QueryId = ();
+
+    const HAS_STATIC_QUERY_ID: bool = false;
+}
+
+impl<'a> Query for CountCurrentVersionsQuery<'a> {
+    type SqlType = BigInt;
+}
+
+impl<'a, Conn> RunQueryDsl<Conn> for CountCurrentVersionsQuery<'a> {}
+
 fn write_column_names(
     column_names: &AttributeNames,
-    table: &Table,
+    table: dsl::Table<'_>,
     prefix: Option<&str>,
     out: &mut AstPass<Pg>,
 ) -> QueryResult<()> {
@@ -4586,7 +5350,7 @@ fn write_column_names(
 fn jsonb_build_object(
     column_names: &AttributeNames,
     table_identifier: &str,
-    table: &Table,
+    table: dsl::Table<'_>,
     out: &mut AstPass<Pg>,
 ) -> QueryResult<()> {
     match column_names {
@@ -4619,13 +5383,17 @@ fn jsonb_build_object(
 
 /// Helper function to iterate over the merged fields of BASE_SQL_COLUMNS and the provided attribute
 /// names, yielding valid SQL names for the given table.
-fn iter_column_names<'a, 'b>(
-    attribute_names: &'a BTreeSet<String>,
-    table: &'b Table,
+fn iter_column_names<'b>(
+    attribute_names: &BTreeSet<String>,
+    table: dsl::Table<'b>,
     include_block_range_column: bool,
 ) -> impl Iterator<Item = &'b str> {
     let extra = if include_block_range_column {
-        [BLOCK_RANGE_COLUMN].iter()
+        if table.meta.immutable {
+            [BLOCK_COLUMN].iter()
+        } else {
+            [BLOCK_RANGE_COLUMN].iter()
+        }
     } else {
         [].iter()
     }
@@ -4637,7 +5405,7 @@ fn iter_column_names<'a, 'b>(
             // Unwrapping: We have already checked that all attribute names exist in table
             table.column_for_field(attribute_name).unwrap()
         })
-        .map(|column| column.name.as_str())
+        .map(|column| column.name())
         .chain(BASE_SQL_COLUMNS.iter().copied())
         .chain(extra)
         .sorted()
diff --git a/store/postgres/src/retry.rs b/store/postgres/src/retry.rs
index d19df52a69b..d0dea82aca9 100644
--- a/store/postgres/src/retry.rs
+++ b/store/postgres/src/retry.rs
@@ -4,7 +4,7 @@ use std::time::Duration;
 
 use graph::{
     prelude::StoreError,
-    slog::{warn, Logger},
+    slog::{Logger, warn},
     util::backoff::ExponentialBackoff,
 };
 
@@ -22,34 +22,7 @@ fn log_backoff_warning(logger: &Logger, op: &str, backoff: &ExponentialBackoff)
 /// Run `f` with exponential backoff until it succeeds or it produces an
 /// error other than `DatabaseUnavailable`. In other words, keep retrying
 /// `f` until the database is available.
-///
-/// Do not use this from an async context since it will block the current
-/// thread. Use `forever_async` instead
-pub(crate) fn forever<T, F>(logger: &Logger, op: &str, f: F) -> Result<T, StoreError>
-where
-    F: Fn() -> Result<T, StoreError>,
-{
-    let mut backoff = ExponentialBackoff::new(BACKOFF_BASE, BACKOFF_CEIL);
-    loop {
-        match f() {
-            Ok(v) => return Ok(v),
-            Err(StoreError::DatabaseUnavailable) => {
-                log_backoff_warning(logger, op, &backoff);
-            }
-            Err(e) => return Err(e),
-        }
-        backoff.sleep();
-    }
-}
-
-/// Run `f` with exponential backoff until it succeeds or it produces an
-/// error other than `DatabaseUnavailable`. In other words, keep retrying
-/// `f` until the database is available.
-pub(crate) async fn forever_async<T, F, Fut>(
-    logger: &Logger,
-    op: &str,
-    f: F,
-) -> Result<T, StoreError>
+pub(crate) async fn forever<T, F, Fut>(logger: &Logger, op: &str, f: F) -> Result<T, StoreError>
 where
     F: Fn() -> Fut,
     Fut: std::future::Future<Output = Result<T, StoreError>>,
diff --git a/store/postgres/src/sql/constants.rs b/store/postgres/src/sql/constants.rs
new file mode 100644
index 00000000000..b24f191f938
--- /dev/null
+++ b/store/postgres/src/sql/constants.rs
@@ -0,0 +1,435 @@
+use std::collections::HashSet;
+
+use lazy_static::lazy_static;
+use sqlparser::dialect::PostgreSqlDialect;
+
+lazy_static! {
+    pub(super) static ref ALLOWED_FUNCTIONS: HashSet<&'static str> = {
+       vec![
+            // Comparison Functions see https://www.postgresql.org/docs/14/functions-comparison.html#FUNCTIONS-COMPARISON-FUNC-TABLE
+            "num_nonnulls", // Number of non-null arguments
+            "num_nulls", // Number of null arguments
+
+            // Mathematical Functions see https://www.postgresql.org/docs/14/functions-math.html#FUNCTIONS-MATH-FUNC-TABLE
+            "abs", // Asolute value
+            "cbrt", // Cube root
+            "ceil", // Nearest integer greater than or equal to argument
+            "ceiling", // Nearest integer greater than or equal to argument
+            "degrees", // Converts radians to degrees
+            "div", // Integer quotient of y/x (truncates towards zero)
+            "exp", // Exponential (e raised to the given power)
+            "factorial", // Factorial
+            "floor", // Nearest integer less than or equal to argument
+            "gcd", // Greatest common divisor (the largest positive number that divides both inputs with no remainder); returns 0 if both inputs are zero; available for integer, bigint, and numeric
+            "lcm", // Least common multiple (the smallest strictly positive number that is an integral multiple of both inputs); returns 0 if either input is zero; available for integer, bigint, and numeric
+            "ln", // Natural logarithm
+            "log", // Base 10 logarithm
+            "log10", // Base 10 logarithm (same as log)
+            "mod", // Remainder of y/x; available for smallint, integer, bigint, and numeric
+            "pi", // Approximate value of π
+            "power", // a raised to the power of b
+            "radians", // Converts degrees to radians
+            "round", // Rounds to nearest integer. For numeric, ties are broken by rounding away from zero. For double precision, the tie-breaking behavior is platform dependent, but “round to nearest even” is the most common rule.
+            "scale", // Scale of the argument (the number of decimal digits in the fractional part)
+            "sign", // Sign of the argument (-1, 0, or +1)
+            "sqrt", // Square root
+            "trim_scale", // Reduces the value's scale (number of fractional decimal digits) by removing trailing zeroes
+            "trunc", // Truncates to integer (towards zero)
+            "width_bucket", // Returns the number of the bucket in which operand falls in a histogram having count equal-width buckets spanning the range low to high. Returns 0 or count+1 for an input outside that range.
+
+            // Random Functions see https://www.postgresql.org/docs/14/functions-math.html#FUNCTIONS-MATH-RANDOM-TABLE
+            "random", // Returns a random value in the range 0.0 <= x < 1.0
+            "setseed", // Sets the seed for subsequent random() calls; argument must be between -1.0 and 1.0, inclusive
+
+            // Trigonometric Functions see https://www.postgresql.org/docs/14/functions-math.html#FUNCTIONS-MATH-TRIG-TABLE
+            "acos", // Arc cosine, result in radians
+            "acosd", // Arc cosine, result in degrees
+            "asin", // Arc sine, result in radians
+            "asind", // Arc sine, result in degrees
+            "atan", // Arc tangent, result in radians
+            "atand", // Arc tangent, result in degrees
+            "atan2", // Arc tangent of y/x, result in radians
+            "atan2d", // Arc tangent of y/x, result in degrees
+            "cos", // Cosine, argument in radians
+            "cosd", // Cosine, argument in degrees
+            "cot", // Cotangent, argument in radians
+            "cotd", // Cotangent, argument in degrees
+            "sin", // Sine, argument in radians
+            "sind", // Sine, argument in degrees
+            "tan", // Tangent, argument in radians
+            "tand", // Tangent, argument in degrees
+
+            // Hyperbolic Functions see https://www.postgresql.org/docs/14/functions-math.html#FUNCTIONS-MATH-HYPERBOLIC-TABLE
+            "sinh", // Hyperbolic sine
+            "cosh", // Hyperbolic cosine
+            "tanh", // Hyperbolic tangent
+            "asinh", // Inverse hyperbolic sine
+            "acosh", // Inverse hyperbolic cosine
+            "atanh", // Inverse hyperbolic tangent
+
+            // String Functions see https://www.postgresql.org/docs/14/functions-string.html#FUNCTIONS-STRING-SQL
+            "bit_length", // Number of bits in string
+            "char_length", // Number of characters in string
+            "character_length", // Synonym for char_length
+            "lower", // Convert string to lower case
+            "normalize", // Convert string to specified Unicode normalization form
+            "octet_length", // Number of bytes in string
+            "overlay", // Replace substring
+            "position", // Location of specified substring
+            "substring", // Extract substring
+            "trim", // Remove leading and trailing characters
+            "upper", // Convert string to upper case
+
+            //Additional string functions see https://www.postgresql.org/docs/14/functions-string.html#FUNCTIONS-STRING-OTHER
+            "ascii", // Convert first character to its numeric code
+            "btrim", // Remove the longest string containing only characters from characters (a space by default) from the start and end of string
+            "chr", // Convert integer to character
+            "concat", // Concatenate strings
+            "concat_ws", // Concatenate with separator
+            "format", // Format arguments according to a format string
+            "initcap", // Convert first letter of each word to upper case and the rest to lower case
+            "left", // Extract substring
+            "length", // Number of characters in string
+            "lpad", // Pad string to length length by prepending the characters fill (a space by default)
+            "ltrim", // Remove the longest string containing only characters from characters (a space by default) from the start of string
+            "md5", // Compute MD5 hash
+            "parse_ident", // Split qualified_identifier into an array of identifiers, removing any quoting of individual identifiers
+            "quote_ident", // Returns the given string suitably quoted to be used as an identifier in an SQL statement string
+            "quote_literal", // Returns the given string suitably quoted to be used as a string literal in an SQL statement string
+            "quote_nullable", // Returns the given string suitably quoted to be used as a string literal in an SQL statement string; or, if the argument is null, returns NULL
+            "regexp_match", // Returns captured substrings resulting from the first match of a POSIX regular expression to the string
+            "regexp_matches", // Returns captured substrings resulting from the first match of a POSIX regular expression to the string, or multiple matches if the g flag is used
+            "regexp_replace", // Replaces substrings resulting from the first match of a POSIX regular expression, or multiple substring matches if the g flag is used
+            "regexp_split_to_array", // Splits string using a POSIX regular expression as the delimiter, producing an array of results
+            "regexp_split_to_table", // Splits string using a POSIX regular expression as the delimiter, producing a set of results
+            "repeat", // Repeats string the specified number of times
+            "replace", // Replaces all occurrences in string of substring from with substring to
+            "reverse", // Reverses the order of the characters in the string
+            "right", // Extract substring
+            "rpad", // Pad string to length length by appending the characters fill (a space by default)
+            "rtrim", // Remove the longest string containing only characters from characters (a space by default) from the end of string
+            "split_part", // Splits string at occurrences of delimiter and returns the n'th field (counting from one), or when n is negative, returns the |n|'th-from-last field
+            "strpos", // Returns first starting index of the specified substring within string, or zero if it's not present
+            "substr", // Extracts the substring of string starting at the start'th character, and extending for count characters if that is specified
+            "starts_with", // Returns true if string starts with prefix
+            "string_to_array", // Splits the string at occurrences of delimiter and forms the resulting fields into a text array
+            "string_to_table", // Splits the string at occurrences of delimiter and returns the resulting fields as a set of text rows
+            "to_ascii", // Converts string to ASCII from another encoding, which may be identified by name or number
+            "to_hex", // Converts the number to its equivalent hexadecimal representation
+            "translate", // Replaces each character in string that matches a character in the from set with the corresponding character in the to set
+            "unistr", // Evaluate escaped Unicode characters in the argument
+
+            // Binary String Functions see https://www.postgresql.org/docs/14/functions-binarystring.html#FUNCTIONS-BINARYSTRING-OTHER
+            "bit_count", // Number of bits set in the argument
+            "get_bit", // Extracts the n'th bit from string
+            "get_byte", // Extracts the n'th byte from string
+            "set_bit", // Sets the n'th bit in string to newvalue
+            "set_byte", // Sets the n'th byte in string to newvalue
+            "sha224", // Compute SHA-224 hash
+            "sha256", // Compute SHA-256 hash
+            "sha384", // Compute SHA-384 hash
+            "sha512", // Compute SHA-512 hash
+
+            // String conversion functions see https://www.postgresql.org/docs/14/functions-binarystring.html#FUNCTIONS-BINARYSTRING-CONVERSIONS
+            "convert", // Converts a binary string representing text in encoding src_encoding to a binary string in encoding dest_encoding
+            "convert_from", // Converts a binary string representing text in encoding src_encoding to text in the database encoding
+            "convert_to", // Converts a text string (in the database encoding) to a binary string encoded in encoding dest_encoding
+            "encode", // Encodes binary data into a textual representation
+            "decode", // Decodes binary data from a textual representation
+
+            // Formatting Functions see https://www.postgresql.org/docs/14/functions-formatting.html#FUNCTIONS-FORMATTING-TABLE
+            "to_char", // Converts number to a string according to the given format
+            "to_date", // Converts string to date
+            "to_number", // Converts string to number
+            "to_timestamp", // Converts string to timestamp with time zone
+
+            // Date/Time Functions see https://www.postgresql.org/docs/14/functions-datetime.html
+            "age", // Subtract arguments, producing a “symbolic” result that uses years and months, rather than just days
+            "clock_timestamp", // Current date and time (changes during statement execution)
+            "current_date", // Current date
+            "current_time", // Current time of day
+            "current_timestamp", // Current date and time (start of current transaction)
+            "date_bin", // Bin input into specified interval aligned with specified origin
+            "date_part", // Get subfield (equivalent to extract)
+            "date_trunc", // Truncate to specified precision
+            "extract", // Get subfield
+            "isfinite", // Test for finite date (not +/-infinity)
+            "justify_days", // Adjust interval so 30-day time periods are represented as months
+            "justify_hours", // Adjust interval so 24-hour time periods are represented as days
+            "justify_interval", // Adjust interval using justify_days and justify_hours, with additional sign adjustments
+            "localtime", // Current time of day
+            "localtimestamp", // Current date and time (start of current transaction)
+            "make_date", // Create date from year, month and day fields (negative years signify BC)
+            "make_interval", // Create interval from years, months, weeks, days, hours, minutes and seconds fields, each of which can default to zero
+            "make_time", // Create time from hour, minute and seconds fields
+            "make_timestamp", // Create timestamp from year, month, day, hour, minute and seconds fields (negative years signify BC)
+            "make_timestamptz", // Create timestamp with time zone from year, month, day, hour, minute and seconds fields (negative years signify BC).
+            "now", // Current date and time (start of current transaction)
+            "statement_timestamp", // Current date and time (start of current statement)
+            "timeofday", // Current date and time (like clock_timestamp, but as a text string)
+            "transaction_timestamp", // Current date and time (start of current transaction)
+
+            // Enum support functions see https://www.postgresql.org/docs/14/functions-enum.html#FUNCTIONS-ENUM-SUPPORT
+            "enum_first", // Returns the first value of an enum type
+            "enum_last", // Returns the last value of an enum type
+            "enum_range", // Returns a range of values of an enum type
+
+            // Geometric Functions see https://www.postgresql.org/docs/14/functions-geometry.html
+            "area", // Computes area
+            "center", // Computes center point
+            "diagonal", // Extracts box's diagonal as a line segment (same as lseg(box))
+            "diameter", // Computes diameter of circle
+            "height", // Computes vertical size of box
+            "isclosed", // Is path closed?
+            "isopen", // Is path open?
+            "length", // Computes the total length
+            "npoints", // Returns the number of points
+            "pclose", // Converts path to closed form
+            "popen", // Converts path to open form
+            "radius", // Computes radius of circle
+            "slope", // Computes slope of a line drawn through the two points
+            "width", // Computes horizontal size of box
+
+            // Geometric Type Conversion Functions see https://www.postgresql.org/docs/14/functions-geometry.html
+            "box", // Convert to a box
+            "circle", // Convert to a circle
+            "line", // Convert to a line
+            "lseg", // Convert to a line segment
+            "path", // Convert to a path
+            "point", // Convert to a point
+            "polygon", // Convert to a polygon
+
+            // IP Address Functions see https://www.postgresql.org/docs/14/functions-net.html
+            "abbrev", // Creates an abbreviated display format as text
+            "broadcast", // Computes the broadcast address for the address's network
+            "family", // Returns the address's family: 4 for IPv4, 6 for IPv6
+            "host", // Returns the IP address as text, ignoring the netmask
+            "hostmask", // Computes the host mask for the address's network
+            "inet_merge", // Computes the smallest network that includes both of the given networks
+            "inet_same_family", // Tests whether the addresses belong to the same IP family
+            "masklen", // Returns the netmask length in bits
+            "netmask", // Computes the network mask for the address's network
+            "network", // Returns the network part of the address, zeroing out whatever is to the right of the netmask
+            "set_masklen", // Sets the netmask length for an inet value. The address part does not change
+            "text", // Returns the unabbreviated IP address and netmask length as text
+
+            // MAC Address Functions see https://www.postgresql.org/docs/14/functions-net.html#MACADDR-FUNCTIONS-TABLE
+            "macaddr8_set7bit", //Sets the 7th bit of the address to one, creating what is known as modified EUI-64, for inclusion in an IPv6 address.
+
+            // Text Search Functions see https://www.postgresql.org/docs/14/functions-textsearch.html
+            "array_to_tsvector", // Converts an array of lexemes to a tsvector
+            "get_current_ts_config", // Returns the OID of the current default text search configuration (as set by default_text_search_config)
+            "numnode", // Returns the number of lexemes plus operators in the tsquery
+            "plainto_tsquery", // Converts text to a tsquery, normalizing words according to the specified or default configuration.
+            "phraseto_tsquery", // Converts text to a tsquery, normalizing words according to the specified or default configuration.
+            "websearch_to_tsquery", // Converts text to a tsquery, normalizing words according to the specified or default configuration.
+            "querytree", // Produces a representation of the indexable portion of a tsquery. A result that is empty or just T indicates a non-indexable query.
+            "setweight", // Assigns the specified weight to each element of the vector.
+            "strip", // Removes positions and weights from the tsvector.
+            "to_tsquery", // Converts text to a tsquery, normalizing words according to the specified or default configuration.
+            "to_tsvector", // Converts text to a tsvector, normalizing words according to the specified or default configuration.
+            "json_to_tsvector", // Selects each item in the JSON document that is requested by the filter and converts each one to a tsvector, normalizing words according to the specified or default configuration.
+            "jsonb_to_tsvector",// Selects each item in the JSON document that is requested by the filter and converts each one to a tsvector, normalizing words according to the specified or default configuration.
+            "ts_delete", // Removes any occurrence of the given lexeme from the vector.
+            "ts_filter", // Selects only elements with the given weights from the vector.
+            "ts_headline", // Displays, in an abbreviated form, the match(es) for the query in the document, which must be raw text not a tsvector.
+            "ts_rank", // Computes a score showing how well the vector matches the query. See Section 12.3.3 for details.
+            "ts_rank_cd", // Computes a score showing how well the vector matches the query, using a cover density algorithm. See Section 12.3.3 for details.
+            "ts_rewrite", // Replaces occurrences of target with substitute within the query. See Section
+            "tsquery_phrase", // Constructs a phrase query that searches for matches of query1 and query2 at successive lexemes (same as <-> operator).
+            "tsvector_to_array", // Converts a tsvector to an array of lexemes.
+
+            // Text search debugging functions see https://www.postgresql.org/docs/14/functions-textsearch.html#TEXTSEARCH-FUNCTIONS-DEBUG-TABLE
+            "ts_debug", // Extracts and normalizes tokens from the document according to the specified or default text search configuration, and returns information about how each token was processed. See Section 12.8.1 for details.
+            "ts_lexize", // Returns an array of replacement lexemes if the input token is known to the dictionary, or an empty array if the token is known to the dictionary but it is a stop word, or NULL if it is not a known word. See Section 12.8.3 for details.
+            "ts_parse", // Extracts tokens from the document using the named parser. See Section 12.8.2 for details.
+            "ts_token_type", // Returns a table that describes each type of token the named parser can recognize. See Section 12.8.2 for details.
+
+            // UUID Functions see https://www.postgresql.org/docs/14/functions-uuid.html
+            "gen_random_uuid", // Generate a version 4 (random) UUID
+
+            // XML Functions see https://www.postgresql.org/docs/14/functions-xml.html
+            "xmlcomment", // Creates an XML comment
+            "xmlconcat", // Concatenates XML values
+            "xmlelement", // Creates an XML element
+            "xmlforest", // Creates an XML forest (sequence) of elements
+            "xmlpi", // Creates an XML processing instruction
+            "xmlagg", // Concatenates the input values to the aggregate function call, much like xmlconcat does, except that concatenation occurs across rows rather than across expressions in a single row.
+            "xmlexists", // Evaluates an XPath 1.0 expression (the first argument), with the passed XML value as its context item.
+            "xml_is_well_formed", // Checks whether the argument is a well-formed XML document or fragment.
+            "xml_is_well_formed_content", // Checks whether the argument is a well-formed XML document or fragment, and that it contains no document type declaration.
+            "xml_is_well_formed_document", // Checks whether the argument is a well-formed XML document.
+            "xpath", // Evaluates the XPath 1.0 expression xpath (given as text) against the XML value xml.
+            "xpath_exists", // Evaluates the XPath 1.0 expression xpath (given as text) against the XML value xml, and returns true if the expression selects at least one node, otherwise false.
+            "xmltable", // Expands an XML value into a table whose columns match the rowtype defined by the function's parameter list.
+            "table_to_xml", // Converts a table to XML.
+            "cursor_to_xml", // Converts a cursor to XML.
+
+                // JSON and JSONB creation functions see https://www.postgresql.org/docs/14/functions-json.html#FUNCTIONS-JSON-CREATION-TABLE
+            "to_json", // Converts any SQL value to JSON.
+            "to_jsonb", // Converts any SQL value to JSONB.
+            "array_to_json", // Converts an SQL array to a JSON array.
+            "row_to_json", // Converts an SQL composite value to a JSON object.
+            "json_build_array", // Builds a possibly-heterogeneously-typed JSON array out of a variadic argument list.
+            "jsonb_build_array", // Builds a possibly-heterogeneously-typed JSON array out of a variadic argument list.
+            "json_build_object", // Builds a JSON object out of a variadic argument list.
+            "json_object", // Builds a JSON object out of a text array.
+            "jsonb_object", // Builds a JSONB object out of a text array.
+
+            // JSON and JSONB processing functions see https://www.postgresql.org/docs/14/functions-json.html#FUNCTIONS-JSON-PROCESSING-TABLE
+            "json_array_elements", // Expands the top-level JSON array into a set of JSON values.
+            "jsonb_array_elements", // Expands the top-level JSON array into a set of JSONB values.
+            "json_array_elements_text", // Expands the top-level JSON array into a set of text values.
+            "jsonb_array_elements_text", // Expands the top-level JSONB array into a set of text values.
+            "json_array_length", // Returns the number of elements in the top-level JSON array.
+            "jsonb_array_length", // Returns the number of elements in the top-level JSONB array.
+            "json_each", // Expands the top-level JSON object into a set of key/value pairs.
+            "jsonb_each", // Expands the top-level JSONB object into a set of key/value pairs.
+            "json_each_text", // Expands the top-level JSON object into a set of key/value pairs. The returned values will be of type text.
+            "jsonb_each_text", // Expands the top-level JSONB object into a set of key/value pairs. The returned values will be of type text.
+            "json_extract_path", // Extracts JSON sub-object at the specified path.
+            "jsonb_extract_path", // Extracts JSONB sub-object at the specified path.
+            "json_extract_path_text", // Extracts JSON sub-object at the specified path as text.
+            "jsonb_extract_path_text", // Extracts JSONB sub-object at the specified path as text.
+            "json_object_keys", // Returns the set of keys in the top-level JSON object.
+            "jsonb_object_keys", // Returns the set of keys in the top-level JSONB object.
+            "json_populate_record", // Expands the top-level JSON object to a row having the composite type of the base argument.
+            "jsonb_populate_record", // Expands the top-level JSON object to a row having the composite type of the base argument.
+            "json_populate_recordset", // Expands the top-level JSON array of objects to a set of rows having the composite type of the base argument.
+            "jsonb_populate_recordset", // Expands the top-level JSONB array of objects to a set of rows having the composite type of the base argument.
+            "json_to_record", // Expands the top-level JSON object to a row having the composite type defined by an AS clause.
+            "jsonb_to_record", // Expands the top-level JSONB object to a row having the composite type defined by an AS clause.
+            "json_to_recordset", // Expands the top-level JSON array of objects to a set of rows having the composite type defined by an AS clause.
+            "jsonb_to_recordset", // Expands the top-level JSONB array of objects to a set of rows having the composite type defined by an AS clause.
+            "json_strip_nulls", // Deletes all object fields that have null values from the given JSON value, recursively.
+            "jsonb_strip_nulls", // Deletes all object fields that have null values from the given JSONB value, recursively.
+            "jsonb_set", // Returns target with the item designated by path replaced by new_value, or with new_value added if create_if_missing is true (which is the default) and the item designated by path does not exist.
+            "jsonb_set_lax", // If new_value is not NULL, behaves identically to jsonb_set. Otherwise behaves according to the value of null_value_treatment which must be one of 'raise_exception', 'use_json_null', 'delete_key', or 'return_target'. The default is 'use_json_null'.
+            "jsonb_insert", //Returns target with new_value inserted.
+            "jsonb_path_exists", // Checks whether the JSON path returns any item for the specified JSON value.
+            "jsonb_path_match", // Returns the result of a JSON path predicate check for the specified JSON value.
+            "jsonb_path_query", // Returns all JSON items returned by the JSON path for the specified JSON value.
+            "jsonb_path_query_array", // Returns all JSON items returned by the JSON path for the specified JSON value, as a JSON array.
+            "jsonb_path_query_first", // Returns the first JSON item returned by the JSON path for the specified JSON value. Returns NULL if there are no results.
+            "jsonb_path_exists_tz", // Support comparisons of date/time values that require timezone-aware conversions.
+            "jsonb_path_match_tz", // Support comparisons of date/time values that require timezone-aware conversions.
+            "jsonb_path_query_tz", // Support comparisons of date/time values that require timezone-aware conversions.
+            "jsonb_path_query_array_tz", // Support comparisons of date/time values that require timezone-aware conversions.
+            "jsonb_path_query_first_tz", // Support comparisons of date/time values that require timezone-aware conversions.
+            "jsonb_pretty", // Converts the given JSON value to pretty-printed, indented text.
+            "json_typeof", // Returns the type of the top-level JSON value as a text string.
+            "jsonb_typeof", // Returns the type of the top-level JSONB value as a text string.
+
+            // Conditional Expressions hhttps://www.postgresql.org/docs/14/functions-conditional.html
+            "coalesce", // Return first non-null argument.
+            "nullif", // Return null if two arguments are equal, otherwise return the first argument.
+            "greatest", // Return greatest of a list of values.
+            "least", // Return smallest of a list of values.
+
+            // Array Functions https://www.postgresql.org/docs/14/functions-array.html#ARRAY-FUNCTIONS-TABLE
+            "array_append", // Appends an element to the end of an array (same as the || operator).
+            "array_cat", // Concatenates two arrays (same as the || operator).
+            "array_dims", // Returns a text representation of the array's dimensions.
+            "array_fill", // Returns an array filled with copies of the given value, having dimensions of the lengths specified by the second argument. The optional third argument supplies lower-bound values for each dimension (which default to all 1).
+            "array_length", // Returns the length of the requested array dimension. (Produces NULL instead of 0 for empty or missing array dimensions.)
+            "array_lower", // Returns the lower bound of the requested array dimension.
+            "array_ndims", // Returns the number of dimensions of the array.
+            "array_position", // Returns the subscript of the first occurrence of the second argument in the array, or NULL if it's not present.
+            "array_prepend", // Prepends an element to the beginning of an array (same as the || operator).
+            "array_remove", // Removes all elements equal to the given value from the array. The array must be one-dimensional. Comparisons are done using IS NOT DISTINCT FROM semantics, so it is possible to remove NULLs.
+            "array_replace", // Replaces each array element equal to the second argument with the third argument.
+            "array_to_string", // Converts each array element to its text representation, and concatenates those separated by the delimiter string. If null_string is given and is not NULL, then NULL array entries are represented by that string; otherwise, they are omitted.
+            "array_upper", // Returns the upper bound of the requested array dimension.
+            "cardinality", // Returns the total number of elements in the array, or 0 if the array is empty.
+            "trim_array", // Trims an array by removing the last n elements. If the array is multidimensional, only the first dimension is trimmed.
+            "unnest", // Expands an array into a set of rows. The array's elements are read out in storage order.
+
+            // Range Functions https://www.postgresql.org/docs/14/functions-range.html#RANGE-FUNCTIONS-TABLE
+            "lower", // Extracts the lower bound of the range (NULL if the range is empty or the lower bound is infinite).
+            "upper", // Extracts the upper bound of the range (NULL if the range is empty or the upper bound is infinite).
+            "isempty", // Is the range empty?
+            "lower_inc", // Is the range's lower bound inclusive?
+            "upper_inc", // Is the range's upper bound inclusive?
+            "lower_inf", // Is the range's lower bound infinite?
+            "upper_inf", // Is the range's upper bound infinite?
+            "range_merge", // Computes the smallest range that includes both of the given ranges.
+
+            // Multi-range Functions https://www.postgresql.org/docs/14/functions-range.html#MULTIRANGE-FUNCTIONS-TABLE
+            "multirange", // Returns a multirange containing just the given range.
+
+            // General purpose aggregate functions https://www.postgresql.org/docs/14/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE
+            "array_agg", // Collects all the input values, including nulls, into an array.
+            "avg", // Computes the average (arithmetic mean) of all the non-null input values.
+            "bit_and", // Computes the bitwise AND of all non-null input values.
+            "bit_or", // Computes the bitwise OR of all non-null input values.
+            "bit_xor", // Computes the bitwise exclusive OR of all non-null input values. Can be useful as a checksum for an unordered set of values.
+            "bool_and", // Returns true if all non-null input values are true, otherwise false.
+            "bool_or", // Returns true if any non-null input value is true, otherwise false.
+            "count", // Computes the number of input rows.
+            "every", // This is the SQL standard's equivalent to bool_and.
+            "json_agg", // Collects all the input values, including nulls, into a JSON array. Values are converted to JSON as per to_json or to_jsonb.
+            "json_object_agg", // Collects all the key/value pairs into a JSON object. Key arguments are coerced to text; value arguments are converted as per to_json or to_jsonb. Values can be null, but not keys.
+            "max", // Computes the maximum of the non-null input values. Available for any numeric, string, date/time, or enum type, as well as inet, interval, money, oid, pg_lsn, tid, and arrays of any of these types.
+            "min", // Computes the minimum of the non-null input values. Available for any numeric, string, date/time, or enum type, as well as inet, interval, money, oid, pg_lsn, tid, and arrays of any of these types.
+            "range_agg", // Computes the union of the non-null input values.
+            "range_intersect_agg", // Computes the intersection of the non-null input values.
+            "string_agg", // Concatenates the non-null input values into a string. Each value after the first is preceded by the corresponding delimiter (if it's not null).
+            "sum", // Computes the sum of the non-null input values.
+            "xmlagg", // Concatenates the non-null XML input values.
+
+            // Statistical aggregate functions https://www.postgresql.org/docs/14/functions-aggregate.html#FUNCTIONS-AGGREGATE-STATISTICS-TABLE
+            "corr", // Computes the correlation coefficient.
+            "covar_pop", // Computes the population covariance.
+            "covar_samp", // Computes the sample covariance.
+            "regr_avgx", // Computes the average of the independent variable, sum(X)/N.
+            "regr_avgy", // Computes the average of the dependent variable, sum(Y)/N.
+            "regr_count", // Computes the number of rows in which both inputs are non-null.
+            "regr_intercept", // Computes the y-intercept of the least-squares-fit linear equation determined by the (X, Y) pairs.
+            "regr_r2", // Computes the square of the correlation coefficient.
+            "regr_slope", // Computes the slope of the least-squares-fit linear equation determined by the (X, Y) pairs.
+            "regr_sxx", // Computes the “sum of squares” of the independent variable, sum(X^2) - sum(X)^2/N.
+            "regr_sxy", // Computes the “sum of products” of independent times dependent variables, sum(X*Y) - sum(X) * sum(Y)/N.
+            "regr_syy", // Computes the “sum of squares” of the dependent variable, sum(Y^2) - sum(Y)^2/N.
+            "stddev", // This is a historical alias for stddev_samp.
+            "stddev_pop", // Computes the population standard deviation of the input values.
+            "stddev_samp", // Computes the sample standard deviation of the input values.
+            "variance", // This is a historical alias for var_samp.
+            "var_pop", // Computes the population variance of the input values (square of the population standard deviation).
+            "var_samp", // Computes the sample variance of the input values (square of the sample standard deviation).
+
+            // Ordered-set aggregate functions https://www.postgresql.org/docs/14/functions-aggregate.html#FUNCTIONS-AGGREGATE-ORDEREDSET-TABLE
+            "mode", // Computes the mode (most frequent value) of the input values.
+            "percentile_cont", // Computes the continuous percentile of the input values.
+            "percentile_disc", // Computes the discrete percentile of the input values.
+
+            // Hypothetical-set aggregate functions https://www.postgresql.org/docs/14/functions-aggregate.html#FUNCTIONS-AGGREGATE-HYPOTHETICAL-TABLE
+            "rank", // Computes the rank of the current row with gaps; same as row_number of its first peer.
+            "dense_rank", // Computes the rank of the current row without gaps; this function counts peer groups.
+            "percent_rank", // Computes the relative rank (percentile) of the current row: (rank - 1) / (total partition rows - 1).
+            "cume_dist", // Computes the relative rank of the current row: (number of partition rows preceding or peer with current row) / (total partition rows).
+
+            // Grouping set aggregate functions https://www.postgresql.org/docs/14/functions-aggregate.html#FUNCTIONS-AGGREGATE-GROUPINGSET-TABLE
+            "grouping", // Returns a bit mask indicating which GROUP BY expressions are not included in the current grouping set.
+
+            // Window functions https://www.postgresql.org/docs/14/functions-window.html#FUNCTIONS-WINDOW-TABLE
+            "row_number", // Number of the current row within its partition, counting from 1.
+            "ntile", // Integer ranging from 1 to the argument value, dividing the partition as equally as possible.
+            "lag", // Returns value evaluated at the row that is offset rows before the current row within the partition; if there is no such row, instead returns default (which must be of a type compatible with value).
+            "lead", // Returns value evaluated at the row that is offset rows after the current row within the partition; if there is no such row, instead returns default (which must be of a type compatible with value).
+            "first_value", // Returns value evaluated at the row that is the first row of the window frame.
+            "last_value", // Returns value evaluated at the row that is the last row of the window frame.
+            "nth_value", // Returns value evaluated at the row that is the n'th row of the window frame (counting from 1); returns NULL if there is no such row.
+
+            // Set returning functions https://www.postgresql.org/docs/14/functions-srf.html
+            "generate_series", // Expands range arguments into a set of rows.
+            "generate_subscripts", // Expands array arguments into a set of rows.
+
+            // Abbreivated syntax for common functions
+            "pow", // see power function
+            "date", // see to_date
+
+       ].into_iter().collect()
+    };
+}
+
+pub(super) static SQL_DIALECT: PostgreSqlDialect = PostgreSqlDialect {};
diff --git a/store/postgres/src/sql/mod.rs b/store/postgres/src/sql/mod.rs
new file mode 100644
index 00000000000..938db9de13d
--- /dev/null
+++ b/store/postgres/src/sql/mod.rs
@@ -0,0 +1,28 @@
+mod constants;
+mod parser;
+mod validation;
+
+pub use parser::Parser;
+
+#[cfg(test)]
+mod test {
+    use std::{collections::BTreeSet, sync::Arc};
+
+    use graph::{prelude::DeploymentHash, schema::InputSchema};
+
+    use crate::{
+        catalog::Catalog,
+        primary::{Namespace, make_dummy_site},
+        relational::Layout,
+    };
+
+    pub(crate) fn make_layout(gql: &str) -> Layout {
+        let subgraph = DeploymentHash::new("Qmasubgraph").unwrap();
+        let schema = InputSchema::parse_latest(gql, subgraph.clone()).unwrap();
+        let namespace = Namespace::new("sgd0815".to_string()).unwrap();
+        let site = Arc::new(make_dummy_site(subgraph, namespace, "anet".to_string()));
+        let catalog = Catalog::for_tests(site.clone(), BTreeSet::new()).unwrap();
+
+        Layout::new(site, &schema, catalog).unwrap()
+    }
+}
diff --git a/store/postgres/src/sql/parser.rs b/store/postgres/src/sql/parser.rs
new file mode 100644
index 00000000000..d800cdab248
--- /dev/null
+++ b/store/postgres/src/sql/parser.rs
@@ -0,0 +1,174 @@
+use super::{constants::SQL_DIALECT, validation::Validator};
+use crate::relational::Layout;
+use anyhow::{Ok, Result, anyhow};
+use graph::{env::ENV_VARS, prelude::BlockNumber};
+use std::sync::Arc;
+
+pub struct Parser {
+    layout: Arc<Layout>,
+    block: BlockNumber,
+}
+
+impl Parser {
+    pub fn new(layout: Arc<Layout>, block: BlockNumber) -> Self {
+        Self { layout, block }
+    }
+
+    pub fn parse_and_validate(&self, sql: &str) -> Result<String> {
+        let mut statements = sqlparser::parser::Parser::parse_sql(&SQL_DIALECT, sql)?;
+
+        let max_offset = ENV_VARS.graphql.max_skip;
+        let max_limit = ENV_VARS.graphql.max_first;
+
+        let mut validator = Validator::new(&self.layout, self.block, max_limit, max_offset);
+        validator.validate_statements(&mut statements)?;
+
+        let statement = statements
+            .first()
+            .ok_or_else(|| anyhow!("No SQL statements found"))?;
+
+        Ok(statement.to_string())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::sync::Arc;
+
+    use crate::sql::{parser::SQL_DIALECT, test::make_layout};
+    use graph::prelude::{BLOCK_NUMBER_MAX, lazy_static, serde_yaml};
+    use serde::{Deserialize, Serialize};
+
+    use pretty_assertions::assert_eq;
+
+    use super::Parser;
+
+    const TEST_GQL: &str = r#"
+        type Swap @entity(immutable: true) {
+            id: Bytes!
+            timestamp: BigInt!
+            pool: Bytes!
+            token0: Bytes!
+            token1: Bytes!
+            sender: Bytes!
+            recipient: Bytes!
+            origin: Bytes! # the EOA that initiated the txn
+            amount0: BigDecimal!
+            amount1: BigDecimal!
+            amountUSD: BigDecimal!
+            sqrtPriceX96: BigInt!
+            tick: BigInt!
+            logIndex: BigInt
+        }
+
+        type Token @entity {
+            id: ID!
+            address: Bytes! # address
+            symbol: String!
+            name: String!
+            decimals: Int!
+        }
+
+        type Data @entity(timeseries: true) {
+            id: Int8!
+            timestamp: Timestamp!
+            price: Int!
+        }
+
+        type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+            id: Int8!
+            timestamp: Timestamp!
+            sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
+        }
+    "#;
+
+    fn parse_and_validate(sql: &str) -> Result<String, anyhow::Error> {
+        let parser = Parser::new(Arc::new(make_layout(TEST_GQL)), BLOCK_NUMBER_MAX);
+
+        parser.parse_and_validate(sql)
+    }
+
+    #[derive(Debug, Serialize, Deserialize)]
+    struct TestCase {
+        name: Option<String>,
+        sql: String,
+        ok: Option<String>,
+        err: Option<String>,
+    }
+
+    impl TestCase {
+        fn fail(
+            &self,
+            name: &str,
+            msg: &str,
+            exp: impl std::fmt::Display,
+            actual: impl std::fmt::Display,
+        ) {
+            panic!(
+                "case {name} failed: {}\n  expected: {}\n  actual: {}",
+                msg, exp, actual
+            );
+        }
+
+        fn run(&self, num: usize) {
+            fn normalize(query: &str) -> String {
+                sqlparser::parser::Parser::parse_sql(&SQL_DIALECT, query)
+                    .unwrap()
+                    .pop()
+                    .unwrap()
+                    .to_string()
+            }
+
+            let name = self
+                .name
+                .as_ref()
+                .map(|name| format!("{num} ({name})"))
+                .unwrap_or_else(|| num.to_string());
+            let result = parse_and_validate(&self.sql);
+
+            match (&self.ok, &self.err, result) {
+                (Some(expected), None, Ok(actual)) => {
+                    let actual = normalize(&actual);
+                    let expected = normalize(expected);
+                    assert_eq!(actual, expected, "case {} failed", name);
+                }
+                (None, Some(expected), Err(actual)) => {
+                    let actual = actual.to_string();
+                    if !actual.contains(expected) {
+                        self.fail(&name, "expected error message not found", expected, actual);
+                    }
+                }
+                (Some(_), Some(_), _) => {
+                    panic!("case {} has both ok and err", name);
+                }
+                (None, None, _) => {
+                    panic!("case {} has neither ok nor err", name)
+                }
+                (None, Some(exp), Ok(actual)) => {
+                    self.fail(&name, "expected an error", exp, actual);
+                }
+                (Some(exp), None, Err(actual)) => self.fail(&name, "expected success", exp, actual),
+            }
+        }
+    }
+
+    lazy_static! {
+        static ref TESTS: Vec<TestCase> = {
+            let file = std::path::PathBuf::from_iter([
+                env!("CARGO_MANIFEST_DIR"),
+                "src",
+                "sql",
+                "parser_tests.yaml",
+            ]);
+            let tests = std::fs::read_to_string(file).unwrap();
+            serde_yaml::from_str(&tests).unwrap()
+        };
+    }
+
+    #[test]
+    fn parse_sql() {
+        for (num, case) in TESTS.iter().enumerate() {
+            case.run(num);
+        }
+    }
+}
diff --git a/store/postgres/src/sql/parser_tests.yaml b/store/postgres/src/sql/parser_tests.yaml
new file mode 100644
index 00000000000..c4155a8deac
--- /dev/null
+++ b/store/postgres/src/sql/parser_tests.yaml
@@ -0,0 +1,133 @@
+# Test cases for the SQL parser. Each test case has the following fields:
+#   name : an optional name for error messages
+#   sql  : the SQL query to parse
+#   ok   : the expected rewritten query
+#   err  : a part of the error message if parsing should fail
+# Of course, only one of ok and err can be specified
+
+- sql: select symbol, address from token where decimals > 10
+  ok: >
+      select symbol, address from (
+        select "id", "address", "symbol", "name", "decimals" from "sgd0815"."token" where block_range @> 2147483647) as token
+      where decimals > 10
+- sql: >
+      with tokens as (
+          select * from (values
+          ('0x0000000000000000000000000000000000000000','eth','ethereum',18),
+          ('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48','usdc','usd coin',6)
+          ) as t(address,symbol,name,decimals))
+      select date, t.symbol, sum(amount)/pow(10,t.decimals) as amount
+        from (select
+               date(to_timestamp(block_timestamp) at time zone 'utc') as date,
+               token, amount
+              from swap as sm,
+                   unnest(sm.amounts_in,sm.tokens_in) as smi(amount,token)
+              union all
+              select
+                date(to_timestamp(block_timestamp) at time zone 'utc') as date,
+                token, amount
+              from swap as sm,
+                   unnest(sm.amounts_out,sm.tokens_out) as smo(amount,token)) as tp
+      inner join
+        tokens as t on t.address = tp.token
+      group by tp.date, t.symbol, t.decimals
+      order by tp.date desc, amount desc
+  ok: >
+      with tokens as (
+        select * from (
+          values ('0x0000000000000000000000000000000000000000', 'eth', 'ethereum', 18),
+                 ('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', 'usdc', 'usd coin', 6))
+          as t (address, symbol, name, decimals))
+      select date, t.symbol, sum(amount) / pow(10, t.decimals) as amount
+        from (select date(to_timestamp(block_timestamp) at time zone 'utc') as date, token, amount
+                from (select "id", "timestamp", "pool", "token_0", "token_1", "sender", "recipient", "origin", "amount_0", "amount_1", "amount_usd", "sqrt_price_x96", "tick", "log_index"
+                        from "sgd0815"."swap" where block$ <= 2147483647) as sm,
+                     unnest(sm.amounts_in, sm.tokens_in) as smi (amount, token)
+              union all
+              select date(to_timestamp(block_timestamp) at time zone 'utc') as date, token, amount
+                from (select "id", "timestamp", "pool", "token_0", "token_1", "sender", "recipient", "origin", "amount_0", "amount_1", "amount_usd", "sqrt_price_x96", "tick", "log_index"
+                        from "sgd0815"."swap" where block$ <= 2147483647) as sm,
+                     unnest(sm.amounts_out, sm.tokens_out) as smo (amount, token)) as tp
+                  inner join tokens as t on t.address = tp.token
+               group by tp.date, t.symbol, t.decimals
+               order by tp.date desc, amount desc
+- name: pg_sleep forbidden
+  sql: select pool from swap where '' = (select cast(pg_sleep(5) as text))
+  err: Unknown or unsupported function pg_sleep
+- name: table functions forbidden
+  sql: >
+    select vid, k.sname
+      from swap,
+        lateral(select current_schemas as sname from current_schemas(true)) as k
+  err: Unknown or unsupported function current_schemas
+- name: function without parens forbidden
+  sql: select input_token from swap where '' = (select user)
+  err: Unknown or unsupported function user
+- name: aggregation allowed
+  sql: >
+    select token0, sum(amount0) as total_amount
+      from swap
+     group by token0
+    having sum(amount0) > 1000
+  ok: >
+    SELECT token0, sum(amount0) AS total_amount
+      FROM (SELECT "id", "timestamp", "pool", "token_0", "token_1", "sender", "recipient", "origin", "amount_0", "amount_1", "amount_usd", "sqrt_price_x96", "tick", "log_index"
+              FROM "sgd0815"."swap" WHERE block$ <= 2147483647) AS swap
+     GROUP BY token0
+    HAVING sum(amount0) > 1000
+- name: arbitrary function forbidden
+  sql: >
+    select token0 from swap
+     where '' = (select cast(do_strange_math(amount_in) as text))
+  err: Unknown or unsupported function do_strange_math
+- name: create table forbidden
+  sql: create table foo (id int primary key);
+  err: Only SELECT query is supported
+- name: insert forbidden
+  sql: insert into foo values (1);
+  err: Only SELECT query is supported
+- name: CTE allowed
+  sql: with foo as (select 1) select * from foo
+  ok:  with foo as (select 1) select * from foo
+- name: CTE with insert forbidden
+  sql: with foo as (insert into target values(1)) select * from bar
+  err: Only SELECT query is supported
+- name: only single statement
+  sql: select 1; select 2;
+  err: Multi statement is not supported
+- name: unknown tables forbidden
+  sql: select * from unknown_table
+  err: Unknown table unknown_table
+- name: qualified tables are forbidden
+  sql: select * from pg_catalog.pg_class
+  err: "Qualified table names are not supported: pg_catalog.pg_class"
+- name: aggregation tables are hidden
+  sql: select * from stats_hour
+  err: Unknown table stats_hour
+- name: CTEs take precedence
+  sql: with stats_hour as (select 1) select * from stats_hour
+  ok: WITH stats_hour AS (SELECT 1) SELECT * FROM stats_hour
+- name: aggregation tables use function syntax
+  sql: select * from stats('hour')
+  ok: SELECT * FROM (SELECT "id", "timestamp", "sum" FROM "sgd0815"."stats_hour" WHERE block$ <= 2147483647) AS stats_hour
+- name: unknown aggregation interval
+  sql: select * from stats('fortnight')
+  err: Unknown aggregation interval `fortnight` for table stats
+- name: aggregation tables with empty arg
+  sql: select * from stats('')
+  err: Unknown aggregation interval `` for table stats
+- name: aggregation tables with no args
+  sql: select * from stats()
+  err: Invalid syntax for aggregation stats
+- name: aggregation tables with multiple args
+  sql: select * from stats('hour', 'day')
+  err: Invalid syntax for aggregation stats
+- name: aggregation tables with alias
+  sql: select * from stats('hour') as sh
+  ok: SELECT * FROM (SELECT "id", "timestamp", "sum" FROM "sgd0815"."stats_hour" WHERE block$ <= 2147483647) AS sh
+- name: nested query with CTE
+  sql: select *, (with pg_user as (select 1) select 1) as one from pg_user
+  err: Unknown table pg_user
+- name: Quoted name in CTE
+  sql: WITH "PG_USER" AS (SELECT 1) SELECT * FROM pg_user;
+  err: Unknown table pg_user
diff --git a/store/postgres/src/sql/validation.rs b/store/postgres/src/sql/validation.rs
new file mode 100644
index 00000000000..430925f08d6
--- /dev/null
+++ b/store/postgres/src/sql/validation.rs
@@ -0,0 +1,406 @@
+use graph::prelude::BlockNumber;
+use graph::schema::AggregationInterval;
+use sqlparser::ast::{
+    Cte, Expr, FunctionArg, FunctionArgExpr, Ident, LimitClause, ObjectName, ObjectNamePart,
+    Offset, Query, SetExpr, Statement, TableAlias, TableFactor, TableFunctionArgs, Value,
+    ValueWithSpan, VisitMut, VisitorMut,
+};
+use sqlparser::parser::Parser;
+use std::fmt::Display;
+use std::result::Result;
+use std::{collections::HashSet, ops::ControlFlow};
+
+use crate::block_range::{BLOCK_COLUMN, BLOCK_RANGE_COLUMN};
+use crate::relational::Layout;
+
+use super::constants::{ALLOWED_FUNCTIONS, SQL_DIALECT};
+
+#[derive(thiserror::Error, Debug, PartialEq)]
+pub enum Error {
+    #[error("Unknown or unsupported function {0}")]
+    UnknownFunction(String),
+    #[error("Multi statement is not supported.")]
+    MultiStatementUnSupported,
+    #[error("Only SELECT query is supported.")]
+    NotSelectQuery,
+    #[error("Unknown table {0}")]
+    UnknownTable(String),
+    #[error("Unknown aggregation interval `{1}` for table {0}")]
+    UnknownAggregationInterval(String, String),
+    #[error("Invalid syntax for aggregation {0}")]
+    InvalidAggregationSyntax(String),
+    #[error("Only constant numbers are supported for LIMIT and OFFSET.")]
+    UnsupportedLimitOffset,
+    #[error("The limit of {0} is greater than the maximum allowed limit of {1}.")]
+    UnsupportedLimit(u32, u32),
+    #[error("The offset of {0} is greater than the maximum allowed offset of {1}.")]
+    UnsupportedOffset(u32, u32),
+    #[error("Qualified table names are not supported: {0}")]
+    NoQualifiedTables(String),
+    #[error("Internal error: {0}")]
+    Internal(String),
+}
+
+/// A wrapper around table names that correctly handles quoted vs unquoted
+/// comparisons of names
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct TableName(String);
+
+impl TableName {
+    fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+impl From<&Ident> for TableName {
+    fn from(ident: &Ident) -> Self {
+        let Ident {
+            value,
+            quote_style,
+            span: _,
+        } = ident;
+        // Use quoted names verbatim, and normalize unquoted names to
+        // lowercase
+        match quote_style {
+            Some(_) => Self(value.clone()),
+            None => Self(value.to_lowercase()),
+        }
+    }
+}
+
+impl Display for TableName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// Helper to track CTEs introduced by the main query or subqueries. Every
+/// time we enter a query, we need to track a new set of CTEs which must be
+/// discarded once we are done with that query. Otherwise, we might allow
+/// access to forbidden tables with a query like `select *, (with pg_user as
+/// (select 1) select 1) as one from pg_user`
+#[derive(Default)]
+struct CteStack {
+    stack: Vec<HashSet<TableName>>,
+}
+
+impl CteStack {
+    fn enter_query(&mut self) {
+        self.stack.push(HashSet::new());
+    }
+
+    fn exit_query(&mut self) {
+        self.stack.pop();
+    }
+
+    fn contains(&self, name: &TableName) -> bool {
+        for entry in self.stack.iter().rev() {
+            if entry.contains(name) {
+                return true;
+            }
+        }
+        false
+    }
+
+    fn clear(&mut self) {
+        self.stack.clear();
+    }
+
+    fn add_ctes(&mut self, ctes: &[Cte]) -> ControlFlow<Error> {
+        let Some(entry) = self.stack.last_mut() else {
+            return ControlFlow::Break(Error::Internal("CTE stack is empty".into()));
+        };
+        for cte in ctes {
+            entry.insert(TableName::from(&cte.alias.name));
+        }
+        ControlFlow::Continue(())
+    }
+}
+
+pub struct Validator<'a> {
+    layout: &'a Layout,
+    ctes: CteStack,
+    block: BlockNumber,
+    max_limit: u32,
+    max_offset: u32,
+}
+
+impl<'a> Validator<'a> {
+    pub fn new(layout: &'a Layout, block: BlockNumber, max_limit: u32, max_offset: u32) -> Self {
+        Self {
+            layout,
+            ctes: Default::default(),
+            block,
+            max_limit,
+            max_offset,
+        }
+    }
+
+    fn validate_function_name(&self, name: &ObjectName) -> ControlFlow<Error> {
+        let name = name.to_string().to_lowercase();
+        if ALLOWED_FUNCTIONS.contains(name.as_str()) {
+            ControlFlow::Continue(())
+        } else {
+            ControlFlow::Break(Error::UnknownFunction(name))
+        }
+    }
+
+    pub fn validate_statements(&mut self, statements: &mut Vec<Statement>) -> Result<(), Error> {
+        self.ctes.clear();
+
+        if statements.len() > 1 {
+            return Err(Error::MultiStatementUnSupported);
+        }
+
+        if let ControlFlow::Break(error) = statements.visit(self) {
+            return Err(error);
+        }
+
+        Ok(())
+    }
+
+    pub fn validate_limit_offset(&mut self, query: &mut Query) -> ControlFlow<Error> {
+        let Query { limit_clause, .. } = query;
+
+        let (limit, offset) = match limit_clause {
+            None => return ControlFlow::Continue(()),
+            Some(LimitClause::LimitOffset {
+                limit,
+                offset,
+                limit_by,
+            }) => {
+                if !limit_by.is_empty() {
+                    return ControlFlow::Break(Error::UnsupportedLimitOffset);
+                }
+                (limit, offset)
+            }
+            Some(LimitClause::OffsetCommaLimit { .. }) => {
+                // MySQL syntax not supported
+                return ControlFlow::Break(Error::UnsupportedLimitOffset);
+            }
+        };
+
+        if let Some(limit) = limit {
+            match limit {
+                Expr::Value(ValueWithSpan {
+                    value: Value::Number(s, _),
+                    span: _,
+                }) => match s.parse::<u32>() {
+                    Err(_) => return ControlFlow::Break(Error::UnsupportedLimitOffset),
+                    Ok(limit) => {
+                        if limit > self.max_limit {
+                            return ControlFlow::Break(Error::UnsupportedLimit(
+                                limit,
+                                self.max_limit,
+                            ));
+                        }
+                    }
+                },
+                _ => return ControlFlow::Break(Error::UnsupportedLimitOffset),
+            }
+
+            if let Some(Offset { value, .. }) = offset {
+                match value {
+                    Expr::Value(ValueWithSpan {
+                        value: Value::Number(s, _),
+                        span: _,
+                    }) => match s.parse::<u32>() {
+                        Err(_) => return ControlFlow::Break(Error::UnsupportedLimitOffset),
+                        Ok(offset) => {
+                            if offset > self.max_offset {
+                                return ControlFlow::Break(Error::UnsupportedOffset(
+                                    offset,
+                                    self.max_offset,
+                                ));
+                            }
+                        }
+                    },
+                    _ => return ControlFlow::Break(Error::UnsupportedLimitOffset),
+                }
+            }
+        }
+        ControlFlow::Continue(())
+    }
+}
+
+impl VisitorMut for Validator<'_> {
+    type Break = Error;
+
+    fn pre_visit_statement(&mut self, statement: &mut Statement) -> ControlFlow<Self::Break> {
+        match statement {
+            Statement::Query(_) => ControlFlow::Continue(()),
+            _ => ControlFlow::Break(Error::NotSelectQuery),
+        }
+    }
+
+    fn pre_visit_query(&mut self, query: &mut Query) -> ControlFlow<Self::Break> {
+        // Add common table expressions to the set of known tables
+        self.ctes.enter_query();
+        if let Some(ref with) = query.with {
+            self.ctes.add_ctes(&with.cte_tables)?;
+        }
+
+        match *query.body {
+            SetExpr::Select(_) | SetExpr::Query(_) => { /* permitted */ }
+            SetExpr::SetOperation { .. } => { /* permitted */ }
+            SetExpr::Table(_) => { /* permitted */ }
+            SetExpr::Values(_) => { /* permitted */ }
+            SetExpr::Insert(_) | SetExpr::Update(_) | SetExpr::Delete(_) | SetExpr::Merge(_) => {
+                return ControlFlow::Break(Error::NotSelectQuery);
+            }
+        }
+
+        self.validate_limit_offset(query)
+    }
+
+    fn post_visit_query(&mut self, _query: &mut Query) -> ControlFlow<Self::Break> {
+        self.ctes.exit_query();
+        ControlFlow::Continue(())
+    }
+
+    /// Invoked for any table function in the AST.
+    /// See [TableFactor::Table.args](sqlparser::ast::TableFactor::Table::args) for more details identifying a table function
+    fn post_visit_table_factor(
+        &mut self,
+        table_factor: &mut TableFactor,
+    ) -> ControlFlow<Self::Break> {
+        /// Check whether `args` is a single string argument and return that
+        /// string
+        fn extract_string_arg(args: &[FunctionArg]) -> Option<String> {
+            if args.len() != 1 {
+                return None;
+            }
+            match &args[0] {
+                FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Value(ValueWithSpan {
+                    value: Value::SingleQuotedString(s),
+                    span: _,
+                }))) => Some(s.clone()),
+                _ => None,
+            }
+        }
+
+        if let TableFactor::Table {
+            name, args, alias, ..
+        } = table_factor
+        {
+            if name.0.len() != 1 {
+                // We do not support schema qualified table names
+                return ControlFlow::Break(Error::NoQualifiedTables(name.to_string()));
+            }
+            let table_name = match &name.0[0] {
+                ObjectNamePart::Identifier(ident) => TableName::from(ident),
+                ObjectNamePart::Function(_) => {
+                    return ControlFlow::Break(Error::NoQualifiedTables(name.to_string()));
+                }
+            };
+
+            // CTES override subgraph tables
+            if self.ctes.contains(&table_name) && args.is_none() {
+                return ControlFlow::Continue(());
+            }
+
+            let table = match (self.layout.table(table_name.as_str()), args) {
+                (None, None) => {
+                    return ControlFlow::Break(Error::UnknownTable(table_name.to_string()));
+                }
+                (Some(_), Some(_)) => {
+                    // Table exists but has args, must be a function
+                    return self.validate_function_name(name);
+                }
+                (None, Some(args)) => {
+                    // Table does not exist but has args, is either an
+                    // aggregation table in the form <name>(<interval>) or
+                    // must be a function
+
+                    if !self.layout.has_aggregation(table_name.as_str()) {
+                        // Not an aggregation, must be a function
+                        return self.validate_function_name(name);
+                    }
+
+                    let TableFunctionArgs { args, settings } = args;
+                    if settings.is_some() {
+                        // We do not support settings on aggregation tables
+                        return ControlFlow::Break(Error::InvalidAggregationSyntax(
+                            table_name.to_string(),
+                        ));
+                    }
+                    let Some(intv) = extract_string_arg(args) else {
+                        // Looks like an aggregation, but argument is not a single string
+                        return ControlFlow::Break(Error::InvalidAggregationSyntax(
+                            table_name.to_string(),
+                        ));
+                    };
+                    let Some(intv) = intv.parse::<AggregationInterval>().ok() else {
+                        return ControlFlow::Break(Error::UnknownAggregationInterval(
+                            table_name.to_string(),
+                            intv,
+                        ));
+                    };
+
+                    let Some(table) = self.layout.aggregation_table(table_name.as_str(), intv)
+                    else {
+                        return self.validate_function_name(name);
+                    };
+                    table
+                }
+                (Some(table), None) => {
+                    if !table.object.is_object_type() {
+                        // Interfaces and aggregations can not be queried
+                        // with the table name directly
+                        return ControlFlow::Break(Error::UnknownTable(table_name.to_string()));
+                    }
+                    table
+                }
+            };
+
+            // Change 'from table [as alias]' to 'from (select {columns} from table) as alias'
+            let columns = table
+                .columns
+                .iter()
+                .map(|column| column.name.quoted())
+                .collect::<Vec<_>>()
+                .join(", ");
+            let query = if table.immutable {
+                format!(
+                    "select {columns} from {} where {} <= {}",
+                    table.qualified_name, BLOCK_COLUMN, self.block
+                )
+            } else {
+                format!(
+                    "select {columns} from {} where {} @> {}",
+                    table.qualified_name, BLOCK_RANGE_COLUMN, self.block
+                )
+            };
+            let Statement::Query(subquery) = Parser::parse_sql(&SQL_DIALECT, &query)
+                .unwrap()
+                .pop()
+                .unwrap()
+            else {
+                unreachable!();
+            };
+            let alias = alias.as_ref().map(|alias| alias.clone()).or_else(|| {
+                Some(TableAlias {
+                    name: Ident::new(table.name.as_str()),
+                    columns: vec![],
+                    explicit: true,
+                    at: None,
+                })
+            });
+            *table_factor = TableFactor::Derived {
+                lateral: false,
+                subquery,
+                alias,
+                sample: None,
+            };
+        }
+        ControlFlow::Continue(())
+    }
+
+    /// Invoked for any function expressions that appear in the AST
+    fn pre_visit_expr(&mut self, _expr: &mut Expr) -> ControlFlow<Self::Break> {
+        if let Expr::Function(function) = _expr {
+            return self.validate_function_name(&function.name);
+        }
+        ControlFlow::Continue(())
+    }
+}
diff --git a/store/postgres/src/store.rs b/store/postgres/src/store.rs
index b663053c3da..2ddc926539a 100644
--- a/store/postgres/src/store.rs
+++ b/store/postgres/src/store.rs
@@ -9,15 +9,15 @@ use graph::{
             StatusStore, Store as StoreTrait,
         },
     },
-    constraint_violation,
     data::subgraph::status,
+    internal_error,
     prelude::{
-        web3::types::Address, BlockNumber, BlockPtr, CheapClone, DeploymentHash, PartialBlockPtr,
-        QueryExecutionError, StoreError,
+        BlockNumber, BlockPtr, CheapClone, DeploymentHash, PartialBlockPtr, QueryExecutionError,
+        StoreError, alloy::primitives::Address,
     },
 };
 
-use crate::{block_store::BlockStore, query_store::QueryStore, SubgraphStore};
+use crate::{SubgraphStore, block_store::BlockStore, query_store::QueryStore};
 
 /// The overall store of the system, consisting of a [`SubgraphStore`] and a
 /// [`BlockStore`], each of which multiplex across multiple database shards.
@@ -32,11 +32,11 @@ use crate::{block_store::BlockStore, query_store::QueryStore, SubgraphStore};
 #[derive(Clone)]
 pub struct Store {
     subgraph_store: Arc<SubgraphStore>,
-    block_store: Arc<BlockStore>,
+    block_store: BlockStore,
 }
 
 impl Store {
-    pub fn new(subgraph_store: Arc<SubgraphStore>, block_store: Arc<BlockStore>) -> Self {
+    pub fn new(subgraph_store: Arc<SubgraphStore>, block_store: BlockStore) -> Self {
         Self {
             subgraph_store,
             block_store,
@@ -47,7 +47,7 @@ impl Store {
         self.subgraph_store.cheap_clone()
     }
 
-    pub fn block_store(&self) -> Arc<BlockStore> {
+    pub fn block_store(&self) -> BlockStore {
         self.block_store.cheap_clone()
     }
 }
@@ -60,7 +60,7 @@ impl StoreTrait for Store {
         self.subgraph_store.cheap_clone()
     }
 
-    fn block_store(&self) -> Arc<Self::BlockStore> {
+    fn block_store(&self) -> Self::BlockStore {
         self.block_store.cheap_clone()
     }
 }
@@ -70,7 +70,6 @@ impl QueryStoreManager for Store {
     async fn query_store(
         &self,
         target: graph::data::query::QueryTarget,
-        for_subscription: bool,
     ) -> Result<
         Arc<dyn graph::prelude::QueryStore + Send + Sync>,
         graph::prelude::QueryExecutionError,
@@ -79,37 +78,38 @@ impl QueryStoreManager for Store {
         let api_version = target.get_version();
         let target = target.clone();
         let (store, site, replica) = graph::spawn_blocking_allow_panic(move || {
-            store
-                .replica_for_query(target.clone(), for_subscription)
-                .map_err(|e| e.into())
+            graph::block_on(store.replica_for_query(target.clone())).map_err(|e| e.into())
         })
         .await
         .map_err(|e| QueryExecutionError::Panic(e.to_string()))
         .and_then(|x| x)?;
 
-        let chain_store = self.block_store.chain_store(&site.network).ok_or_else(|| {
-            constraint_violation!(
+        let chain_store = self.block_store.chain_store(&site.network).await.ok_or_else(|| {
+            internal_error!(
                 "Subgraphs index a known network, but {} indexes `{}` which we do not know about. This is most likely a configuration error.",
                 site.deployment,
                 site.network
             )
         })?;
 
-        Ok(Arc::new(QueryStore::new(
-            store,
-            chain_store,
-            site,
-            replica,
-            Arc::new(api_version.clone()),
-        )))
+        Ok(Arc::new(
+            QueryStore::new(
+                store,
+                chain_store,
+                site,
+                replica,
+                Arc::new(api_version.clone()),
+            )
+            .await,
+        ))
     }
 }
 
 #[async_trait]
 impl StatusStore for Store {
-    fn status(&self, filter: status::Filter) -> Result<Vec<status::Info>, StoreError> {
-        let mut infos = self.subgraph_store.status(filter)?;
-        let ptrs = self.block_store.chain_head_pointers()?;
+    async fn status(&self, filter: status::Filter) -> Result<Vec<status::Info>, StoreError> {
+        let mut infos = self.subgraph_store.status(filter).await?;
+        let ptrs = self.block_store.chain_head_pointers().await?;
         for info in &mut infos {
             for chain in &mut info.chains {
                 chain.chain_head_block = ptrs.get(&chain.network).map(|ptr| ptr.clone().into());
@@ -118,27 +118,30 @@ impl StatusStore for Store {
         Ok(infos)
     }
 
-    fn version_info(&self, version_id: &str) -> Result<VersionInfo, StoreError> {
-        let mut info = self.subgraph_store.version_info(version_id)?;
+    async fn version_info(&self, version_id: &str) -> Result<VersionInfo, StoreError> {
+        let mut info = self.subgraph_store.version_info(version_id).await?;
 
-        info.total_ethereum_blocks_count = self.block_store.chain_head_block(&info.network)?;
+        info.total_ethereum_blocks_count = self.block_store.chain_head_block(&info.network).await?;
 
         Ok(info)
     }
 
-    fn versions_for_subgraph_id(
+    async fn versions_for_subgraph_id(
         &self,
         subgraph_id: &str,
     ) -> Result<(Option<String>, Option<String>), StoreError> {
-        self.subgraph_store.versions_for_subgraph_id(subgraph_id)
+        self.subgraph_store
+            .versions_for_subgraph_id(subgraph_id)
+            .await
     }
 
-    fn subgraphs_for_deployment_hash(
+    async fn subgraphs_for_deployment_hash(
         &self,
         deployment_hash: &str,
     ) -> Result<Vec<(String, String)>, StoreError> {
         self.subgraph_store
             .subgraphs_for_deployment_hash(deployment_hash)
+            .await
     }
 
     async fn get_proof_of_indexing(
@@ -168,8 +171,8 @@ impl StatusStore for Store {
             .await
     }
 
-    async fn query_permit(&self) -> Result<QueryPermit, StoreError> {
+    async fn query_permit(&self) -> QueryPermit {
         // Status queries go to the primary shard.
-        Ok(self.block_store.query_permit_primary().await)
+        self.block_store.query_permit_primary().await
     }
 }
diff --git a/store/postgres/src/store_events.rs b/store/postgres/src/store_events.rs
index a2a760ddbfe..6ed19314649 100644
--- a/store/postgres/src/store_events.rs
+++ b/store/postgres/src/store_events.rs
@@ -1,17 +1,18 @@
-use futures03::TryStreamExt;
-use graph::parking_lot::Mutex;
-use graph::tokio_stream::wrappers::ReceiverStream;
-use std::collections::BTreeSet;
-use std::sync::{atomic::Ordering, Arc, RwLock};
+use graph::futures01::Stream;
+use graph::futures03::TryStreamExt;
+use graph::futures03::compat::Stream01CompatExt;
+use graph::futures03::stream::StreamExt;
+use std::sync::{Arc, atomic::Ordering};
+
+use graph::parking_lot::RwLock;
 use std::{collections::HashMap, sync::atomic::AtomicUsize};
-use tokio::sync::mpsc::{channel, Sender};
-use tokio::sync::watch;
-use uuid::Uuid;
+use tokio::sync::mpsc::{Sender, channel};
+use tokio_stream::wrappers::ReceiverStream;
 
 use crate::notification_listener::{NotificationListener, SafeChannelName};
-use graph::components::store::{SubscriptionManager as SubscriptionManagerTrait, UnitStream};
+use graph::components::store::SubscriptionManager as SubscriptionManagerTrait;
 use graph::prelude::serde_json;
-use graph::{prelude::*, tokio_stream};
+use graph::prelude::*;
 
 pub struct StoreEventListener {
     notification_listener: NotificationListener,
@@ -86,59 +87,28 @@ impl StoreEventListener {
     }
 }
 
-struct Watcher<T> {
-    sender: Arc<watch::Sender<T>>,
-    receiver: watch::Receiver<T>,
-}
-
-impl<T: Clone + Debug + Send + Sync + 'static> Watcher<T> {
-    fn new(init: T) -> Self {
-        let (sender, receiver) = watch::channel(init);
-        Watcher {
-            sender: Arc::new(sender),
-            receiver,
-        }
-    }
-
-    fn send(&self, v: T) {
-        // Unwrap: `self` holds a receiver.
-        self.sender.send(v).unwrap()
-    }
-
-    fn stream(&self) -> Box<dyn futures03::Stream<Item = T> + Unpin + Send + Sync> {
-        Box::new(tokio_stream::wrappers::WatchStream::new(
-            self.receiver.clone(),
-        ))
-    }
-
-    /// Outstanding receivers returned from `Self::stream`.
-    fn receiver_count(&self) -> usize {
-        // Do not count the internal receiver.
-        self.sender.receiver_count() - 1
-    }
-}
-
 /// Manage subscriptions to the `StoreEvent` stream. Keep a list of
 /// currently active subscribers and forward new events to each of them
 pub struct SubscriptionManager {
-    // These are more efficient since only one entry is stored per filter.
-    subscriptions_no_payload: Arc<Mutex<HashMap<BTreeSet<SubscriptionFilter>, Watcher<()>>>>,
-
-    subscriptions:
-        Arc<RwLock<HashMap<String, (Arc<BTreeSet<SubscriptionFilter>>, Sender<Arc<StoreEvent>>)>>>,
+    subscriptions: Arc<RwLock<HashMap<usize, Sender<Arc<StoreEvent>>>>>,
 
     /// Keep the notification listener alive
     listener: StoreEventListener,
+
+    logger: Logger,
 }
 
 impl SubscriptionManager {
     pub fn new(logger: Logger, postgres_url: String, registry: Arc<MetricsRegistry>) -> Self {
-        let (listener, store_events) = StoreEventListener::new(logger, postgres_url, registry);
+        let logger = logger.new(o!("component" => "StoreEventListener"));
+
+        let (listener, store_events) =
+            StoreEventListener::new(logger.cheap_clone(), postgres_url, registry);
 
         let mut manager = SubscriptionManager {
-            subscriptions_no_payload: Arc::new(Mutex::new(HashMap::new())),
             subscriptions: Arc::new(RwLock::new(HashMap::new())),
             listener,
+            logger,
         };
 
         // Deal with store subscriptions
@@ -150,6 +120,32 @@ impl SubscriptionManager {
         manager
     }
 
+    async fn broadcast_event(
+        logger: &Logger,
+        subscriptions: &Arc<RwLock<HashMap<usize, Sender<Arc<StoreEvent>>>>>,
+        event: StoreEvent,
+    ) {
+        let event = Arc::new(event);
+
+        // Send to `subscriptions`.
+        {
+            let senders = subscriptions.read().clone();
+
+            // Write change to all matching subscription streams; remove subscriptions
+            // whose receiving end has been dropped
+            for (id, sender) in senders {
+                if let Err(e) = sender.send(event.cheap_clone()).await {
+                    error!(
+                        logger,
+                        "Failed to send store event to subscriber {}: {}", id, e
+                    );
+                    // Receiver was dropped
+                    subscriptions.write().remove(&id);
+                }
+            }
+        }
+    }
+
     /// Receive store events from Postgres and send them to all active
     /// subscriptions. Detect stale subscriptions in the process and
     /// close them.
@@ -158,40 +154,23 @@ impl SubscriptionManager {
         store_events: Box<dyn Stream<Item = StoreEvent, Error = ()> + Send>,
     ) {
         let subscriptions = self.subscriptions.cheap_clone();
-        let subscriptions_no_payload = self.subscriptions_no_payload.cheap_clone();
         let mut store_events = store_events.compat();
+        let logger = self.logger.cheap_clone();
 
         // This channel is constantly receiving things and there are locks involved,
         // so it's best to use a blocking task.
         graph::spawn_blocking(async move {
-            while let Some(Ok(event)) = store_events.next().await {
-                let event = Arc::new(event);
-
-                // Send to `subscriptions`.
-                {
-                    let senders = subscriptions.read().unwrap().clone();
-
-                    // Write change to all matching subscription streams; remove subscriptions
-                    // whose receiving end has been dropped
-                    for (id, (_, sender)) in senders
-                        .iter()
-                        .filter(|(_, (filter, _))| event.matches(filter))
-                    {
-                        if sender.send(event.cheap_clone()).await.is_err() {
-                            // Receiver was dropped
-                            subscriptions.write().unwrap().remove(id);
-                        }
+            loop {
+                match store_events.next().await {
+                    Some(Ok(event)) => {
+                        Self::broadcast_event(&logger, &subscriptions, event).await;
                     }
-                }
-
-                // Send to `subscriptions_no_payload`.
-                {
-                    let watchers = subscriptions_no_payload.lock();
-
-                    // Write change to all matching subscription streams
-                    for (_, watcher) in watchers.iter().filter(|(filter, _)| event.matches(filter))
-                    {
-                        watcher.send(());
+                    Some(Err(_)) => {
+                        error!(logger, "Error receiving store event");
+                    }
+                    None => {
+                        error!(logger, "Store event stream ended");
+                        break;
                     }
                 }
             }
@@ -200,7 +179,7 @@ impl SubscriptionManager {
 
     fn periodically_clean_up_stale_subscriptions(&self) {
         let subscriptions = self.subscriptions.cheap_clone();
-        let subscriptions_no_payload = self.subscriptions_no_payload.cheap_clone();
+        let logger = self.logger.cheap_clone();
 
         // Clean up stale subscriptions every 5s
         graph::spawn(async move {
@@ -210,38 +189,20 @@ impl SubscriptionManager {
 
                 // Cleanup `subscriptions`.
                 {
-                    let mut subscriptions = subscriptions.write().unwrap();
-
-                    // Obtain IDs of subscriptions whose receiving end has gone
-                    let stale_ids = subscriptions
-                        .iter_mut()
-                        .filter_map(|(id, (_, sender))| match sender.is_closed() {
-                            true => Some(id.clone()),
-                            false => None,
-                        })
-                        .collect::<Vec<_>>();
-
-                    // Remove all stale subscriptions
-                    for id in stale_ids {
-                        subscriptions.remove(&id);
-                    }
-                }
-
-                // Cleanup `subscriptions_no_payload`.
-                {
-                    let mut subscriptions = subscriptions_no_payload.lock();
+                    let mut subscriptions = subscriptions.write();
 
                     // Obtain IDs of subscriptions whose receiving end has gone
                     let stale_ids = subscriptions
                         .iter_mut()
-                        .filter_map(|(id, watcher)| match watcher.receiver_count() == 0 {
-                            true => Some(id.clone()),
+                        .filter_map(|(id, sender)| match sender.is_closed() {
+                            true => Some(*id),
                             false => None,
                         })
                         .collect::<Vec<_>>();
 
                     // Remove all stale subscriptions
                     for id in stale_ids {
+                        warn!(logger, "Removing stale subscription {}", id);
                         subscriptions.remove(&id);
                     }
                 }
@@ -251,28 +212,17 @@ impl SubscriptionManager {
 }
 
 impl SubscriptionManagerTrait for SubscriptionManager {
-    fn subscribe(&self, entities: BTreeSet<SubscriptionFilter>) -> StoreEventStreamBox {
-        let id = Uuid::new_v4().to_string();
+    fn subscribe(&self) -> StoreEventStreamBox {
+        static SUBSCRIPTION_COUNTER: AtomicUsize = AtomicUsize::new(0);
+        let id = SUBSCRIPTION_COUNTER.fetch_add(1, Ordering::SeqCst);
 
         // Prepare the new subscription by creating a channel and a subscription object
         let (sender, receiver) = channel(100);
 
         // Add the new subscription
-        self.subscriptions
-            .write()
-            .unwrap()
-            .insert(id, (Arc::new(entities.clone()), sender));
+        self.subscriptions.write().insert(id, sender);
 
         // Return the subscription ID and entity change stream
-        StoreEventStream::new(Box::new(ReceiverStream::new(receiver).map(Ok).compat()))
-            .filter_by_entities(entities)
-    }
-
-    fn subscribe_no_payload(&self, entities: BTreeSet<SubscriptionFilter>) -> UnitStream {
-        self.subscriptions_no_payload
-            .lock()
-            .entry(entities)
-            .or_insert_with(|| Watcher::new(()))
-            .stream()
+        ReceiverStream::new(receiver)
     }
 }
diff --git a/store/postgres/src/subgraph_store.rs b/store/postgres/src/subgraph_store.rs
index a8a807e4524..b4435cae0cb 100644
--- a/store/postgres/src/subgraph_store.rs
+++ b/store/postgres/src/subgraph_store.rs
@@ -1,14 +1,15 @@
+use async_trait::async_trait;
 use diesel::{
+    deserialize::FromSql,
     pg::Pg,
-    serialize::Output,
-    sql_types::Text,
-    types::{FromSql, ToSql},
+    serialize::{Output, ToSql},
+    sql_types::{self, Text},
 };
+use std::fmt;
 use std::{
     collections::{BTreeMap, HashMap},
-    sync::{atomic::AtomicU8, Arc, Mutex},
+    sync::{Arc, Mutex, atomic::AtomicU8},
 };
-use std::{fmt, io::Write};
 use std::{iter::FromIterator, time::Duration};
 
 use graph::{
@@ -16,43 +17,52 @@ use graph::{
     components::{
         server::index_node::VersionInfo,
         store::{
-            self, BlockPtrForNumber, BlockStore, DeploymentLocator, EnsLookup as EnsLookupTrait,
-            PruneReporter, PruneRequest, SubgraphFork,
+            self, BlockPtrForNumber, BlockStore, DeploymentLocator, DeploymentSchemaVersion,
+            DumpReporter, EnsLookup as EnsLookupTrait, PruneReporter, PruneRequest,
+            RestoreReporter, SubgraphFork,
         },
     },
-    constraint_violation,
-    data::query::QueryTarget,
-    data::subgraph::{schema::DeploymentCreate, status, DeploymentFeatures},
+    data::{
+        query::QueryTarget,
+        store::DEFAULT_NODE_ID,
+        subgraph::{DeploymentFeatures, schema::DeploymentCreate, status},
+    },
+    internal_error,
     prelude::{
-        anyhow, futures03::future::join_all, lazy_static, o, web3::types::Address, ApiVersion,
-        BlockNumber, BlockPtr, ChainStore, DeploymentHash, EntityOperation, Logger,
-        MetricsRegistry, NodeId, PartialBlockPtr, StoreError, SubgraphDeploymentEntity,
-        SubgraphName, SubgraphStore as SubgraphStoreTrait, SubgraphVersionSwitchingMode,
+        ApiVersion, BlockNumber, BlockPtr, ChainStore, DeploymentHash, EntityOperation, Logger,
+        MetricsRegistry, NodeId, PartialBlockPtr, StoreError, StoreEvent, SubgraphDeploymentEntity,
+        SubgraphName, SubgraphStore as SubgraphStoreTrait, SubgraphVersionSwitchingMode, anyhow,
+        lazy_static, o,
     },
-    prelude::{CancelableError, StoreEvent},
     schema::{ApiSchema, InputSchema},
     url::Url,
     util::timed_cache::TimedCache,
 };
+use graph::{derive::CheapClone, futures03::future::join_all, prelude::alloy::primitives::Address};
 
 use crate::{
-    connection_pool::ConnectionPool,
+    ConnectionPool, NotificationSender,
+    catalog::Catalog,
     deployment::{OnSync, SubgraphHealth},
-    primary,
-    primary::{DeploymentId, Mirror as PrimaryMirror, Site},
-    relational::{index::Method, Layout},
-    writable::WritableStore,
-    NotificationSender,
+    primary::{
+        self, DeploymentId, Mirror as PrimaryMirror, Primary, RestoreAction, RestoreMode, Site,
+    },
+    relational::{
+        self, Layout,
+        index::{IndexList, Method},
+    },
+    writable::{SourceableStore, WritableStore},
 };
 use crate::{
     deployment_store::{DeploymentStore, ReplicaId},
     detail::DeploymentDetail,
     primary::UnusedDeployment,
 };
-use crate::{fork, relational::index::CreateIndex, relational::SqlName};
+use crate::{fork, relational::SqlName, relational::index::CreateIndex};
 
 /// The name of a database shard; valid names must match `[a-z0-9_]+`
 #[derive(Clone, Debug, Eq, PartialEq, Hash, AsExpression, FromSqlRow)]
+#[diesel(sql_type = sql_types::Text)]
 pub struct Shard(String);
 
 lazy_static! {
@@ -82,7 +92,7 @@ impl Shard {
             .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
         {
             return Err(StoreError::InvalidIdentifier(format!(
-                "shard name `{}` is invalid: shard names must only contain lowercase alphanumeric characters or '_'", name
+                "shard name `{name}` is invalid: shard names must only contain lowercase alphanumeric characters or '_'"
             )));
         }
         Ok(Shard(name))
@@ -100,14 +110,14 @@ impl fmt::Display for Shard {
 }
 
 impl FromSql<Text, Pg> for Shard {
-    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
+    fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
         let s = <String as FromSql<Text, Pg>>::from_sql(bytes)?;
         Shard::new(s).map_err(Into::into)
     }
 }
 
 impl ToSql<Text, Pg> for Shard {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> diesel::serialize::Result {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
         <String as ToSql<Text, Pg>>::to_sql(&self.0, out)
     }
 }
@@ -120,13 +130,14 @@ impl ToSql<Text, Pg> for Shard {
 /// shards.
 pub trait DeploymentPlacer {
     fn place(&self, name: &str, network: &str)
-        -> Result<Option<(Vec<Shard>, Vec<NodeId>)>, String>;
+    -> Result<Option<(Vec<Shard>, Vec<NodeId>)>, String>;
 }
 
 /// Tools for managing unused deployments
 pub mod unused {
     use graph::prelude::chrono::Duration;
 
+    #[derive(Debug)]
     pub enum Filter {
         /// List all unused deployments
         All,
@@ -135,6 +146,12 @@ pub mod unused {
         /// List only deployments that were recorded as unused at least this
         /// long ago but have not been removed at
         UnusedLongerThan(Duration),
+        /// Lists deployments with a specific name
+        Name(String),
+        /// Lists deployments with a specific hash
+        Hash(String),
+        /// Lists deployments with a specific deployment id
+        Deployment(String),
     }
 }
 
@@ -173,11 +190,12 @@ pub mod unused {
 /// metadata is stored in tables in the `subgraphs` namespace in the same
 /// shard as the deployment data. The most important of these tables are
 ///
-/// - `subgraphs.subgraph_deployment`: the main table for deployment
-///   metadata; most importantly, it stores the pointer to the current
-///   subgraph head, i.e., the block up to which the subgraph has indexed
-///   the chain, together with other things like whether the subgraph has
-///   synced, whether it has failed and whether it encountered any errors
+/// - `subgraphs.deployment` and `subgraphs.head`: the main table for
+///   deployment metadata; most importantly, it stores the pointer to the
+///   current subgraph head, i.e., the block up to which the subgraph has
+///   indexed the chain, together with other things like whether the
+///   subgraph has synced, whether it has failed and whether it encountered
+///   any errors
 /// - `subgraphs.subgraph_manifest`: immutable information derived from the
 ///   YAML manifest for the deployment
 /// - `subgraphs.dynamic_ethereum_contract_data_source`: the data sources
@@ -189,13 +207,9 @@ pub mod unused {
 /// shards.  The actual work is done by code in the `primary` module for
 /// queries against the primary store, and by the `DeploymentStore` for
 /// access to deployment data and metadata.
-#[derive(Clone)]
+#[derive(Clone, CheapClone)]
 pub struct SubgraphStore {
-    inner: Arc<SubgraphStoreInner>,
-    /// Base URL for the GraphQL endpoint from which
-    /// subgraph forks will fetch entities.
-    /// Example: https://api.thegraph.com/subgraphs/
-    fork_base: Option<Url>,
+    inner: Arc<Inner>,
 }
 
 impl SubgraphStore {
@@ -222,10 +236,9 @@ impl SubgraphStore {
         registry: Arc<MetricsRegistry>,
     ) -> Self {
         Self {
-            inner: Arc::new(SubgraphStoreInner::new(
-                logger, stores, placer, sender, registry,
+            inner: Arc::new(Inner::new(
+                logger, stores, placer, sender, registry, fork_base,
             )),
-            fork_base,
         }
     }
 
@@ -242,7 +255,7 @@ impl SubgraphStore {
         &self,
         id: &DeploymentHash,
         block_number: BlockNumber,
-        block_store: Arc<impl BlockStore>,
+        block_store: impl BlockStore,
         fetch_block_ptr: &dyn BlockPtrForNumber,
     ) -> Result<Option<(PartialBlockPtr, [u8; 32])>, StoreError> {
         self.inner
@@ -253,17 +266,342 @@ impl SubgraphStore {
     pub fn notification_sender(&self) -> Arc<NotificationSender> {
         self.sender.clone()
     }
+
+    pub fn for_site(&self, site: &Site) -> Result<&Arc<DeploymentStore>, StoreError> {
+        self.inner.for_site(site)
+    }
+
+    async fn get_or_create_writable_store(
+        self: Arc<Self>,
+        logger: Logger,
+        deployment: graph::components::store::DeploymentId,
+        manifest_idx_and_name: Arc<Vec<(u32, String)>>,
+    ) -> Result<Arc<WritableStore>, StoreError> {
+        let deployment = deployment.into();
+        // We cache writables to make sure calls to this method are
+        // idempotent and there is ever only one `WritableStore` for any
+        // deployment
+        if let Some(writable) = self.writables.lock().unwrap().get(&deployment) {
+            // A poisoned writable will not write anything anymore; we
+            // discard it and create a new one that is properly initialized
+            // according to the state in the database.
+            if !writable.poisoned() {
+                return Ok(writable.cheap_clone());
+            }
+        }
+
+        // Ideally the lower level functions would be asyncified.
+        let this = self.clone();
+        let site = graph::spawn_blocking_allow_panic(move || -> Result<_, StoreError> {
+            graph::block_on(this.find_site(deployment))
+        })
+        .await
+        .unwrap()?; // Propagate panics, there shouldn't be any.
+
+        let writable = Arc::new(
+            WritableStore::new(
+                self.as_ref().clone(),
+                logger,
+                site,
+                manifest_idx_and_name,
+                self.registry.clone(),
+            )
+            .await?,
+        );
+        self.writables
+            .lock()
+            .unwrap()
+            .insert(deployment, writable.cheap_clone());
+        Ok(writable)
+    }
+
+    /// Create a new deployment. This requires creating an entry in
+    /// `deployment_schemas` in the primary, the subgraph schema in another
+    /// shard, assigning the deployment to a node, and handling any changes
+    /// to current/pending versions of the subgraph `name`
+    ///
+    /// This process needs to modify two databases: the primary and the
+    /// shard for the subgraph and is therefore not transactional. The code
+    /// is careful to make sure this process is at least idempotent, so that
+    /// a failed deployment creation operation can be fixed by deploying
+    /// again.
+    async fn create_deployment_internal(
+        &self,
+        name: SubgraphName,
+        schema: &InputSchema,
+        deployment: DeploymentCreate,
+        node_id: NodeId,
+        network_name: String,
+        mode: SubgraphVersionSwitchingMode,
+        // replace == true is only used in tests; for non-test code, it must
+        // be 'false'
+        replace: bool,
+    ) -> Result<DeploymentLocator, StoreError> {
+        #[cfg(not(debug_assertions))]
+        assert!(!replace);
+
+        self.evict(schema.id())?;
+        let graft_base = deployment.graft_base.as_ref();
+
+        let (site, deployment_store, node_id) = {
+            // We need to deal with two situations:
+            //   (1) We are really creating a new subgraph; it therefore needs
+            //       to go in the shard and onto the node that the placement
+            //       rules dictate
+            //   (2) The deployment has previously been created, and either
+            //       failed partway through, or the deployment rules have
+            //       changed since the last time we created the deployment.
+            //       In that case, we need to use the shard and node
+            //       assignment that we used last time to avoid creating
+            //       the same deployment in another shard
+            let (shard, node_id) = self.place(&name, &network_name, node_id).await?;
+
+            let mut pconn = self.primary_conn().await?;
+
+            let (site, site_was_created) = pconn
+                .allocate_site(shard, schema.id(), network_name, graft_base)
+                .await?;
+            let node_id = pconn.assigned_node(&site).await?.unwrap_or(node_id);
+            let site = Arc::new(site);
+            let deployment_store = self
+                .stores
+                .get(&site.shard)
+                .ok_or_else(|| StoreError::UnknownShard(site.shard.to_string()))?;
+
+            if let Some(graft_base) = graft_base {
+                // Perform schema compatibility validation when:
+                // - the site was just created (first-time deployment), or
+                // - the site exists but the deployment is missing (recovering from a failed create).
+                // The `exists` DB call is only made if `site_was_created` is false.
+                let should_validate = {
+                    let mut shard_conn = deployment_store.get_replica_conn(ReplicaId::Main).await?;
+                    site_was_created || !crate::deployment::exists(&mut shard_conn, &site).await?
+                };
+
+                if should_validate {
+                    let base_layout = self.layout(graft_base).await?;
+                    let entities_with_causality_region =
+                        deployment.manifest.entities_with_causality_region.clone();
+                    let mut shard_conn = deployment_store.get_replica_conn(ReplicaId::Main).await?;
+                    let catalog = Catalog::for_creation(
+                        &mut shard_conn,
+                        site.cheap_clone(),
+                        entities_with_causality_region.into_iter().collect(),
+                    )
+                    .await?;
+                    let layout = Layout::new(site.cheap_clone(), schema, catalog)?;
+
+                    let errors = layout.can_copy_from(&base_layout);
+                    if !errors.is_empty() {
+                        return Err(StoreError::Unknown(anyhow!(
+                            "The subgraph `{}` cannot be used as the graft base \
+                                for `{}` because the schemas are incompatible:\n    - {}",
+                            &base_layout.catalog.site.namespace,
+                            &layout.catalog.site.namespace,
+                            errors.join("\n    - ")
+                        )));
+                    }
+
+                    // Only record active copy when the graft check passes and a copy is needed.
+                    // If deployment already exists, the copy has either completed (no active_copies
+                    // record) or is in progress (active_copies record already exists).
+                    pconn
+                        .record_active_copy(base_layout.site.as_ref(), site.as_ref())
+                        .await?;
+                }
+            }
+
+            (site, deployment_store, node_id)
+        };
+
+        // Create the actual databases schema and metadata entries
+        deployment_store
+            .create_deployment(schema, deployment, site.clone(), replace, OnSync::None)
+            .await?;
+
+        // FIXME: This simultaneously holds a `primary_conn` and a shard connection, which can
+        // potentially deadlock.
+        let mut pconn = self.primary_conn().await?;
+        let subgraph_store = self.cheap_clone();
+        let site_clone = site.cheap_clone();
+        pconn
+            .transaction(async move |pconn| {
+                let exists_and_synced = async move |id: &DeploymentHash| {
+                    let (store, _) = subgraph_store.store(id).await?;
+                    store.deployment_exists_and_synced(id).await
+                };
+
+                // Create subgraph, subgraph version, and assignment
+                let changes = pconn
+                    .create_subgraph_version(name, &site_clone, node_id, mode, exists_and_synced)
+                    .await?;
+
+                let event = StoreEvent::new(changes);
+                pconn.send_store_event(&self.sender, &event).await?;
+                Ok(())
+            })
+            .await?;
+        Ok(site.as_ref().into())
+    }
+
+    // Only for tests to simplify their handling of test fixtures, so that
+    // tests can reset the block pointer of a subgraph by recreating it
+    #[cfg(debug_assertions)]
+    pub async fn create_deployment_replace(
+        &self,
+        name: SubgraphName,
+        schema: &InputSchema,
+        deployment: DeploymentCreate,
+        node_id: NodeId,
+        network_name: String,
+        mode: SubgraphVersionSwitchingMode,
+    ) -> Result<DeploymentLocator, StoreError> {
+        self.create_deployment_internal(name, schema, deployment, node_id, network_name, mode, true)
+            .await
+    }
+
+    pub async fn restore(
+        &self,
+        dir: &std::path::Path,
+        shard: Option<Shard>,
+        name: Option<SubgraphName>,
+        mode: RestoreMode,
+        version_switching_mode: SubgraphVersionSwitchingMode,
+        reporter: &mut dyn RestoreReporter,
+    ) -> Result<(), StoreError> {
+        use crate::relational::dump::Metadata;
+
+        let metadata_path = dir.join("metadata.json");
+        let metadata = Metadata::from_file(&metadata_path)?;
+
+        // Resolve the subgraph name for deployment rule matching. If not
+        // supplied, look up an existing name from the DB; error if none.
+        let name = match name {
+            Some(name) => {
+                // Validate that the named subgraph exists. Without this
+                // check the deployment would be created but never linked
+                // to a name, leaving it orphaned.
+                if !self.mirror.subgraph_exists(&name).await? {
+                    return Err(StoreError::Input(format!(
+                        "subgraph `{name}` does not exist; \
+                         create it first with `graphman create {name}`"
+                    )));
+                }
+                name
+            }
+            None => {
+                let names = self
+                    .mirror
+                    .subgraphs_by_deployment_hash(metadata.deployment.as_str())
+                    .await?;
+                let (name, _) = names.into_iter().next().ok_or_else(|| {
+                    StoreError::Input(
+                        "no subgraph name found for this deployment; use --name to specify one"
+                            .into(),
+                    )
+                })?;
+                SubgraphName::new(name).map_err(|n| {
+                    StoreError::InternalError(format!("invalid subgraph name `{n}` in database"))
+                })?
+            }
+        };
+
+        // Use deployment rules to determine which node should index this
+        // deployment and how to place it.
+        let (placed_shard, node) = self
+            .place(&name, &metadata.network, DEFAULT_NODE_ID.clone())
+            .await?;
+        let shard = shard.unwrap_or(placed_shard);
+
+        // Validate that the target shard exists before making any DB changes
+        self.stores
+            .get(&shard)
+            .ok_or_else(|| StoreError::UnknownShard(shard.to_string()))?;
+
+        let mut pconn = self.primary_conn().await?;
+        let action = pconn
+            .plan_restore(&shard, &metadata.deployment, &mode)
+            .await?;
+
+        // Determine schema_version the same way allocate_site does
+        let schema_version = match metadata.graft_base.as_ref() {
+            Some(graft_base) => {
+                let base_site = pconn.find_active_site(graft_base).await?.ok_or_else(|| {
+                    StoreError::DeploymentNotFound("graft_base not found".to_string())
+                })?;
+                base_site.schema_version
+            }
+            None => DeploymentSchemaVersion::LATEST,
+        };
+
+        let site = match action {
+            RestoreAction::Create { active } => {
+                pconn
+                    .create_site(
+                        shard,
+                        metadata.deployment.clone(),
+                        metadata.network.clone(),
+                        schema_version,
+                        active,
+                    )
+                    .await?
+            }
+            RestoreAction::Replace { existing } => {
+                let was_active = existing.active;
+                let existing = Arc::new(existing);
+                let store = self.for_site(&existing)?;
+                store.drop_deployment(&existing).await?;
+                pconn.drop_site(&existing).await?;
+                // Drop and re-acquire the primary connection to avoid pool
+                // deadlock: drop_deployment above used a separate connection
+                // from the same pool, and create_site below needs one too.
+                drop(pconn);
+                let mut pconn = self.primary_conn().await?;
+                pconn
+                    .create_site(
+                        shard,
+                        metadata.deployment.clone(),
+                        metadata.network.clone(),
+                        schema_version,
+                        was_active,
+                    )
+                    .await?
+            }
+        };
+
+        let site = Arc::new(site);
+        let store = self.for_site(&site)?;
+        store
+            .restore(site.cheap_clone(), dir, &metadata, &mut *reporter)
+            .await?;
+
+        // Link the restored deployment to the subgraph name and assign it
+        // to the node determined by deployment rules
+        let mut pconn = self.primary_conn().await?;
+        let subgraph_store = self.cheap_clone();
+        let exists_and_synced = async move |id: &DeploymentHash| {
+            let (store, _) = subgraph_store.store(id).await?;
+            store.deployment_exists_and_synced(id).await
+        };
+        let changes = pconn
+            .create_subgraph_version(name, &site, node, version_switching_mode, exists_and_synced)
+            .await?;
+        let event = StoreEvent::new(changes);
+        pconn.send_store_event(&self.sender, &event).await?;
+
+        Ok(())
+    }
 }
 
 impl std::ops::Deref for SubgraphStore {
-    type Target = SubgraphStoreInner;
+    type Target = Inner;
 
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
 
-pub struct SubgraphStoreInner {
+pub struct Inner {
     mirror: PrimaryMirror,
     stores: HashMap<Shard, Arc<DeploymentStore>>,
     /// Cache for the mapping from deployment id to shard/namespace/id. Only
@@ -277,9 +615,13 @@ pub struct SubgraphStoreInner {
     sender: Arc<NotificationSender>,
     writables: Mutex<HashMap<DeploymentId, Arc<WritableStore>>>,
     registry: Arc<MetricsRegistry>,
+    /// Base URL for the GraphQL endpoint from which
+    /// subgraph forks will fetch entities.
+    /// Example: https://api.thegraph.com/subgraphs/
+    fork_base: Option<Url>,
 }
 
-impl SubgraphStoreInner {
+impl Inner {
     /// Create a new store for subgraphs that distributes deployments across
     /// multiple databases
     ///
@@ -300,7 +642,14 @@ impl SubgraphStoreInner {
         placer: Arc<dyn DeploymentPlacer + Send + Sync + 'static>,
         sender: Arc<NotificationSender>,
         registry: Arc<MetricsRegistry>,
+        fork_base: Option<Url>,
     ) -> Self {
+        let primary = stores
+            .iter()
+            .find(|(name, _, _, _)| name == &*PRIMARY_SHARD)
+            .map(|(_, pool, _, _)| Primary::new(Arc::new(pool.clone())))
+            .expect("primary shard must be present");
+
         let mirror = {
             let pools = HashMap::from_iter(
                 stores
@@ -317,6 +666,7 @@ impl SubgraphStoreInner {
                     name,
                     Arc::new(DeploymentStore::new(
                         &logger,
+                        primary.cheap_clone(),
                         main_pool,
                         read_only_pools,
                         weights,
@@ -325,7 +675,7 @@ impl SubgraphStoreInner {
             },
         ));
         let sites = TimedCache::new(SITES_CACHE_TTL);
-        SubgraphStoreInner {
+        Inner {
             mirror,
             stores,
             sites,
@@ -333,12 +683,13 @@ impl SubgraphStoreInner {
             sender,
             writables: Mutex::new(HashMap::new()),
             registry,
+            fork_base,
         }
     }
 
     // Only needed for tests
     #[cfg(debug_assertions)]
-    pub(crate) fn clear_caches(&self) {
+    pub(crate) async fn clear_caches(&self) {
         for store in self.stores.values() {
             store.layout_cache.clear();
         }
@@ -347,8 +698,9 @@ impl SubgraphStoreInner {
 
     // Only needed for tests
     #[cfg(debug_assertions)]
-    pub fn shard(&self, deployment: &DeploymentLocator) -> Result<Shard, StoreError> {
+    pub async fn shard(&self, deployment: &DeploymentLocator) -> Result<Shard, StoreError> {
         self.find_site(deployment.id.into())
+            .await
             .map(|site| site.shard.clone())
     }
 
@@ -359,14 +711,15 @@ impl SubgraphStoreInner {
     }
 
     /// Return the active `Site` for this deployment hash
-    fn site(&self, id: &DeploymentHash) -> Result<Arc<Site>, StoreError> {
+    async fn site(&self, id: &DeploymentHash) -> Result<Arc<Site>, StoreError> {
         if let Some(site) = self.sites.get(id) {
             return Ok(site);
         }
 
         let site = self
             .mirror
-            .find_active_site(id)?
+            .find_active_site(id)
+            .await?
             .ok_or_else(|| StoreError::DeploymentNotFound(id.to_string()))?;
         let site = Arc::new(site);
 
@@ -377,7 +730,7 @@ impl SubgraphStoreInner {
     fn evict(&self, id: &DeploymentHash) -> Result<(), StoreError> {
         if let Some((site, _)) = self.sites.remove(id) {
             let store = self.stores.get(&site.shard).ok_or_else(|| {
-                constraint_violation!(
+                internal_error!(
                     "shard {} for deployment sgd{} not found when evicting",
                     site.shard,
                     site.id
@@ -388,14 +741,15 @@ impl SubgraphStoreInner {
         Ok(())
     }
 
-    pub(crate) fn find_site(&self, id: DeploymentId) -> Result<Arc<Site>, StoreError> {
+    pub(crate) async fn find_site(&self, id: DeploymentId) -> Result<Arc<Site>, StoreError> {
         if let Some(site) = self.sites.find(|site| site.id == id) {
             return Ok(site);
         }
 
         let site = self
             .mirror
-            .find_site_by_ref(id)?
+            .find_site_by_ref(id)
+            .await?
             .ok_or_else(|| StoreError::DeploymentNotFound(id.to_string()))?;
         let site = Arc::new(site);
 
@@ -405,8 +759,11 @@ impl SubgraphStoreInner {
 
     /// Return the store and site for the active deployment of this
     /// deployment hash
-    fn store(&self, id: &DeploymentHash) -> Result<(&Arc<DeploymentStore>, Arc<Site>), StoreError> {
-        let site = self.site(id)?;
+    async fn store(
+        &self,
+        id: &DeploymentHash,
+    ) -> Result<(&Arc<DeploymentStore>, Arc<Site>), StoreError> {
+        let site = self.site(id).await?;
         let store = self
             .stores
             .get(&site.shard)
@@ -420,12 +777,12 @@ impl SubgraphStoreInner {
             .ok_or_else(|| StoreError::UnknownShard(site.shard.to_string()))
     }
 
-    pub(crate) fn layout(&self, id: &DeploymentHash) -> Result<Arc<Layout>, StoreError> {
-        let (store, site) = self.store(id)?;
-        store.find_layout(site)
+    pub(crate) async fn layout(&self, id: &DeploymentHash) -> Result<Arc<Layout>, StoreError> {
+        let (store, site) = self.store(id).await?;
+        store.find_layout(site).await
     }
 
-    fn place_on_node(
+    async fn place_on_node(
         &self,
         mut nodes: Vec<NodeId>,
         default_node: NodeId,
@@ -437,30 +794,30 @@ impl SubgraphStoreInner {
             }
             1 => Ok(nodes.pop().unwrap()),
             _ => {
-                let conn = self.primary_conn()?;
+                let mut conn = self.primary_conn().await?;
 
                 // unwrap is fine since nodes is not empty
-                let node = conn.least_assigned_node(&nodes)?.unwrap();
+                let node = conn.least_assigned_node(&nodes).await?.unwrap();
                 Ok(node)
             }
         }
     }
 
-    fn place_in_shard(&self, mut shards: Vec<Shard>) -> Result<Shard, StoreError> {
+    async fn place_in_shard(&self, mut shards: Vec<Shard>) -> Result<Shard, StoreError> {
         match shards.len() {
             0 => Ok(PRIMARY_SHARD.clone()),
             1 => Ok(shards.pop().unwrap()),
             _ => {
-                let conn = self.primary_conn()?;
+                let mut conn = self.primary_conn().await?;
 
                 // unwrap is fine since shards is not empty
-                let shard = conn.least_used_shard(&shards)?.unwrap();
+                let shard = conn.least_used_shard(&shards).await?.unwrap();
                 Ok(shard)
             }
         }
     }
 
-    fn place(
+    async fn place(
         &self,
         name: &SubgraphName,
         network_name: &str,
@@ -474,123 +831,20 @@ impl SubgraphStoreInner {
         let placement = self
             .placer
             .place(name.as_str(), network_name)
-            .map_err(|msg| {
-                constraint_violation!("illegal indexer name in deployment rule: {}", msg)
-            })?;
+            .map_err(|msg| internal_error!("illegal indexer name in deployment rule: {}", msg))?;
 
         match placement {
             None => Ok((PRIMARY_SHARD.clone(), default_node)),
             Some((shards, nodes)) => {
-                let node = self.place_on_node(nodes, default_node)?;
-                let shard = self.place_in_shard(shards)?;
+                let node = self.place_on_node(nodes, default_node).await?;
+                let shard = self.place_in_shard(shards).await?;
 
                 Ok((shard, node))
             }
         }
     }
 
-    /// Create a new deployment. This requires creating an entry in
-    /// `deployment_schemas` in the primary, the subgraph schema in another
-    /// shard, assigning the deployment to a node, and handling any changes
-    /// to current/pending versions of the subgraph `name`
-    ///
-    /// This process needs to modify two databases: the primary and the
-    /// shard for the subgraph and is therefore not transactional. The code
-    /// is careful to make sure this process is at least idempotent, so that
-    /// a failed deployment creation operation can be fixed by deploying
-    /// again.
-    fn create_deployment_internal(
-        &self,
-        name: SubgraphName,
-        schema: &InputSchema,
-        deployment: DeploymentCreate,
-        node_id: NodeId,
-        network_name: String,
-        mode: SubgraphVersionSwitchingMode,
-        // replace == true is only used in tests; for non-test code, it must
-        // be 'false'
-        replace: bool,
-    ) -> Result<DeploymentLocator, StoreError> {
-        #[cfg(not(debug_assertions))]
-        assert!(!replace);
-
-        self.evict(schema.id())?;
-        let graft_base = deployment.graft_base.as_ref();
-
-        let (site, exists, node_id) = {
-            // We need to deal with two situations:
-            //   (1) We are really creating a new subgraph; it therefore needs
-            //       to go in the shard and onto the node that the placement
-            //       rules dictate
-            //   (2) The deployment has previously been created, and either
-            //       failed partway through, or the deployment rules have
-            //       changed since the last time we created the deployment.
-            //       In that case, we need to use the shard and node
-            //       assignment that we used last time to avoid creating
-            //       the same deployment in another shard
-            let (shard, node_id) = self.place(&name, &network_name, node_id)?;
-            let conn = self.primary_conn()?;
-            let (site, site_was_created) =
-                conn.allocate_site(shard, schema.id(), network_name, graft_base)?;
-            let node_id = conn.assigned_node(&site)?.unwrap_or(node_id);
-            (site, !site_was_created, node_id)
-        };
-        let site = Arc::new(site);
-
-        // if the deployment already exists, we don't need to perform any copying
-        // so we can set graft_base to None
-        // if it doesn't exist, we need to copy the graft base to the new deployment
-        let graft_base = if !exists {
-            let graft_base = deployment
-                .graft_base
-                .as_ref()
-                .map(|base| self.layout(base))
-                .transpose()?;
-
-            if let Some(graft_base) = &graft_base {
-                self.primary_conn()?
-                    .record_active_copy(graft_base.site.as_ref(), site.as_ref())?;
-            }
-            graft_base
-        } else {
-            None
-        };
-
-        // Create the actual databases schema and metadata entries
-        let deployment_store = self
-            .stores
-            .get(&site.shard)
-            .ok_or_else(|| StoreError::UnknownShard(site.shard.to_string()))?;
-        deployment_store.create_deployment(
-            schema,
-            deployment,
-            site.clone(),
-            graft_base,
-            replace,
-            OnSync::None,
-        )?;
-
-        let exists_and_synced = |id: &DeploymentHash| {
-            let (store, _) = self.store(id)?;
-            store.deployment_exists_and_synced(id)
-        };
-
-        // FIXME: This simultaneously holds a `primary_conn` and a shard connection, which can
-        // potentially deadlock.
-        let pconn = self.primary_conn()?;
-        pconn.transaction(|| -> Result<_, StoreError> {
-            // Create subgraph, subgraph version, and assignment
-            let changes =
-                pconn.create_subgraph_version(name, &site, node_id, mode, exists_and_synced)?;
-
-            let event = StoreEvent::new(changes);
-            pconn.send_store_event(&self.sender, &event)?;
-            Ok(())
-        })?;
-        Ok(site.as_ref().into())
-    }
-
-    pub fn copy_deployment(
+    pub async fn copy_deployment(
         &self,
         src: &DeploymentLocator,
         shard: Shard,
@@ -598,37 +852,32 @@ impl SubgraphStoreInner {
         block: BlockPtr,
         on_sync: OnSync,
     ) -> Result<DeploymentLocator, StoreError> {
-        let src = self.find_site(src.id.into())?;
+        let src = self.find_site(src.id.into()).await?;
         let src_store = self.for_site(src.as_ref())?;
-        let src_info = src_store.subgraph_info(src.as_ref())?;
         let src_loc = DeploymentLocator::from(src.as_ref());
-
-        let dst = Arc::new(self.primary_conn()?.copy_site(&src, shard.clone())?);
+        let src_layout = src_store.find_layout(src.cheap_clone()).await?;
+        let dst = Arc::new(
+            self.primary_conn()
+                .await?
+                .copy_site(&src, shard.clone())
+                .await?,
+        );
         let dst_loc = DeploymentLocator::from(dst.as_ref());
 
         if src.id == dst.id {
             return Err(StoreError::Unknown(anyhow!(
-                "can not copy deployment {} onto itself",
-                src_loc
+                "can not copy deployment {src_loc} onto itself"
             )));
         }
         // The very last thing we do when we set up a copy here is assign it
         // to a node. Therefore, if `dst` is already assigned, this function
         // should not have been called.
-        if let Some(node) = self.mirror.assigned_node(dst.as_ref())? {
+        if let Some(node) = self.mirror.assigned_node(dst.as_ref()).await? {
             return Err(StoreError::Unknown(anyhow!(
-                "can not copy into deployment {} since it is already assigned to node `{}`",
-                dst_loc,
-                node
-            )));
-        }
-        let deployment = src_store.load_deployment(src.clone())?;
-        if deployment.failed {
-            return Err(StoreError::Unknown(anyhow!(
-                "can not copy deployment {} because it has failed",
-                src_loc
+                "can not copy into deployment {dst_loc} since it is already assigned to node `{node}`"
             )));
         }
+        let deployment = src_store.load_deployment(src.clone()).await?;
 
         // Transmogrify the deployment into a new one
         let deployment = DeploymentCreate {
@@ -640,10 +889,10 @@ impl SubgraphStoreInner {
             history_blocks_override: None,
         };
 
-        let graft_base = self.layout(&src.deployment)?;
-
-        self.primary_conn()?
-            .record_active_copy(src.as_ref(), dst.as_ref())?;
+        self.primary_conn()
+            .await?
+            .record_active_copy(src.as_ref(), dst.as_ref())
+            .await?;
 
         // Create the actual databases schema and metadata entries
         let deployment_store = self
@@ -651,94 +900,68 @@ impl SubgraphStoreInner {
             .get(&shard)
             .ok_or_else(|| StoreError::UnknownShard(shard.to_string()))?;
 
-        deployment_store.create_deployment(
-            &src_info.input,
-            deployment,
-            dst.clone(),
-            Some(graft_base),
-            false,
-            on_sync,
-        )?;
-
-        let pconn = self.primary_conn()?;
-        pconn.transaction(|| -> Result<_, StoreError> {
-            // Create subgraph, subgraph version, and assignment. We use the
-            // existence of an assignment as a signal that we already set up
-            // the copy
-            let changes = pconn.assign_subgraph(dst.as_ref(), &node)?;
-            let event = StoreEvent::new(changes);
-            pconn.send_store_event(&self.sender, &event)?;
-            Ok(())
-        })?;
+        deployment_store
+            .create_deployment(
+                &src_layout.input_schema,
+                deployment,
+                dst.clone(),
+                false,
+                on_sync,
+            )
+            .await?;
+
+        let mut pconn = self.primary_conn().await?;
+        let sender = self.sender.clone();
+        let dst_clone = dst.cheap_clone();
+        pconn
+            .transaction(async move |pconn| {
+                // Create subgraph, subgraph version, and assignment. We use the
+                // existence of an assignment as a signal that we already set up
+                // the copy
+                let changes = pconn.assign_subgraph(dst_clone.as_ref(), &node).await?;
+                let event = StoreEvent::new(changes);
+                pconn.send_store_event(&sender, &event).await?;
+                Ok(())
+            })
+            .await?;
         Ok(dst.as_ref().into())
     }
 
     /// Mark `deployment` as the only active deployment amongst all sites
     /// with the same deployment hash. Activating this specific deployment
     /// will make queries use that instead of whatever was active before
-    pub fn activate(&self, deployment: &DeploymentLocator) -> Result<(), StoreError> {
-        self.primary_conn()?.activate(deployment)?;
+    pub async fn activate(&self, deployment: &DeploymentLocator) -> Result<(), StoreError> {
+        self.primary_conn().await?.activate(deployment).await?;
         // As a side-effect, this will update the `self.sites` cache with
         // the new active site
-        self.find_site(deployment.id.into())?;
+        self.find_site(deployment.id.into()).await?;
         Ok(())
     }
 
-    // Only for tests to simplify their handling of test fixtures, so that
-    // tests can reset the block pointer of a subgraph by recreating it
-    #[cfg(debug_assertions)]
-    pub fn create_deployment_replace(
-        &self,
-        name: SubgraphName,
-        schema: &InputSchema,
-        deployment: DeploymentCreate,
-        node_id: NodeId,
-        network_name: String,
-        mode: SubgraphVersionSwitchingMode,
-    ) -> Result<DeploymentLocator, StoreError> {
-        self.create_deployment_internal(name, schema, deployment, node_id, network_name, mode, true)
-    }
-
-    pub(crate) fn send_store_event(&self, event: &StoreEvent) -> Result<(), StoreError> {
-        let conn = self.primary_conn()?;
-        conn.send_store_event(&self.sender, event)
-    }
-
     /// Get a connection to the primary shard. Code must never hold one of these
     /// connections while also accessing a `DeploymentStore`, since both
     /// might draw connections from the same pool, and trying to get two
     /// connections can deadlock the entire process if the pool runs out
     /// of connections in between getting the first one and trying to get the
     /// second one.
-    pub(crate) fn primary_conn(&self) -> Result<primary::Connection, StoreError> {
-        let conn = self.mirror.primary().get()?;
+    pub(crate) async fn primary_conn(&self) -> Result<primary::Connection, StoreError> {
+        let conn = self.mirror.primary().get_permitted().await?;
         Ok(primary::Connection::new(conn))
     }
 
-    pub(crate) async fn with_primary_conn<T: Send + 'static>(
-        &self,
-        f: impl 'static + Send + FnOnce(primary::Connection) -> Result<T, CancelableError<StoreError>>,
-    ) -> Result<T, StoreError> {
-        let pool = self.mirror.primary();
-        pool.with_conn(move |pg_conn, _| {
-            let conn = primary::Connection::new(pg_conn);
-            f(conn)
-        })
-        .await
-    }
-
-    pub(crate) fn replica_for_query(
+    pub(crate) async fn replica_for_query(
         &self,
         target: QueryTarget,
-        for_subscription: bool,
     ) -> Result<(Arc<DeploymentStore>, Arc<Site>, ReplicaId), StoreError> {
         let id = match target {
-            QueryTarget::Name(name, _) => self.mirror.current_deployment_for_subgraph(&name)?,
+            QueryTarget::Name(name, _) => {
+                self.mirror.current_deployment_for_subgraph(&name).await?
+            }
             QueryTarget::Deployment(id, _) => id,
         };
 
-        let (store, site) = self.store(&id)?;
-        let replica = store.replica_for_query(for_subscription)?;
+        let (store, site) = self.store(&id).await?;
+        let replica = store.replica_for_query()?;
 
         Ok((store.clone(), site, replica))
     }
@@ -747,20 +970,20 @@ impl SubgraphStoreInner {
     /// and should never be called from any other code. Unfortunately, Rust makes
     /// it very hard to export items just for testing
     #[cfg(debug_assertions)]
-    pub fn delete_all_entities_for_test_use_only(&self) -> Result<(), StoreError> {
-        let pconn = self.primary_conn()?;
-        let schemas = pconn.sites()?;
+    pub async fn remove_all_subgraphs_for_test_use_only(&self) -> Result<(), StoreError> {
+        let mut pconn = self.primary_conn().await?;
+        let schemas = pconn.sites().await?;
 
         // Delete all subgraph schemas
         for schema in schemas {
-            let (store, _) = self.store(&schema.deployment)?;
-            store.drop_deployment_schema(&schema.namespace)?;
+            let (store, _) = self.store(&schema.deployment).await?;
+            store.drop_deployment_schema(&schema.namespace).await?;
         }
 
         for store in self.stores.values() {
-            store.drop_all_metadata()?;
+            store.drop_all_metadata().await?;
         }
-        self.clear_caches();
+        self.clear_caches().await;
         Ok(())
     }
 
@@ -786,8 +1009,12 @@ impl SubgraphStoreInner {
 
     /// Look for new unused deployments and add them to the `unused_deployments`
     /// table
-    pub fn record_unused_deployments(&self) -> Result<Vec<DeploymentDetail>, StoreError> {
-        let deployments = self.primary_conn()?.detect_unused_deployments()?;
+    pub async fn record_unused_deployments(&self) -> Result<Vec<DeploymentDetail>, StoreError> {
+        let deployments = self
+            .primary_conn()
+            .await?
+            .detect_unused_deployments()
+            .await?;
 
         // deployments_by_shard takes an empty vec to mean 'give me everything',
         // so we short-circuit that here
@@ -807,69 +1034,87 @@ impl SubgraphStoreInner {
                 .into_iter()
                 .map(|site| site.deployment.to_string())
                 .collect();
-            details.extend(store.deployment_details(ids)?);
+            details.extend(store.deployment_details(ids).await?);
         }
 
-        self.primary_conn()?.update_unused_deployments(&details)?;
+        self.primary_conn()
+            .await?
+            .update_unused_deployments(&details)
+            .await?;
         Ok(details)
     }
 
-    pub fn list_unused_deployments(
+    pub async fn list_unused_deployments(
         &self,
         filter: unused::Filter,
     ) -> Result<Vec<UnusedDeployment>, StoreError> {
-        self.primary_conn()?.list_unused_deployments(filter)
+        self.primary_conn()
+            .await?
+            .list_unused_deployments(filter)
+            .await
     }
 
     /// Remove a deployment, i.e., all its data and metadata. This is only permissible
     /// if the deployment is unused in the sense that it is neither the current nor
     /// pending version of any subgraph, and is not currently assigned to any node
-    pub fn remove_deployment(&self, id: DeploymentId) -> Result<(), StoreError> {
-        let site = self.find_site(id)?;
+    pub async fn remove_deployment(&self, id: DeploymentId) -> Result<(), StoreError> {
+        let site = self.find_site(id).await?;
         let store = self.for_site(site.as_ref())?;
 
         // Check that deployment is not assigned
-        let mut removable = self.mirror.assigned_node(site.as_ref())?.is_none();
+        let mut removable = self.mirror.assigned_node(site.as_ref()).await?.is_none();
 
         // Check that it is not current/pending for any subgraph if it is
         // the active deployment of that subgraph
         if site.active
             && !self
-                .primary_conn()?
-                .subgraphs_using_deployment(site.as_ref())?
+                .primary_conn()
+                .await?
+                .subgraphs_using_deployment(site.as_ref())
+                .await?
                 .is_empty()
         {
             removable = false;
         }
 
         if removable {
-            store.drop_deployment(&site)?;
+            store.drop_deployment(&site).await?;
 
-            self.primary_conn()?.drop_site(site.as_ref())?;
+            self.primary_conn().await?.drop_site(site.as_ref()).await?;
         } else {
-            self.primary_conn()?
-                .unused_deployment_is_used(site.as_ref())?;
+            self.primary_conn()
+                .await?
+                .unused_deployment_is_used(site.as_ref())
+                .await?;
         }
 
         Ok(())
     }
 
-    pub fn status_for_id(&self, id: graph::components::store::DeploymentId) -> status::Info {
+    pub async fn status_for_id(&self, id: graph::components::store::DeploymentId) -> status::Info {
         let filter = status::Filter::DeploymentIds(vec![id]);
-        self.status(filter).unwrap().into_iter().next().unwrap()
+        self.status(filter)
+            .await
+            .unwrap()
+            .into_iter()
+            .next()
+            .unwrap()
     }
 
-    pub(crate) fn status(&self, filter: status::Filter) -> Result<Vec<status::Info>, StoreError> {
+    pub(crate) async fn status(
+        &self,
+        filter: status::Filter,
+    ) -> Result<Vec<status::Info>, StoreError> {
         let sites = match filter {
             status::Filter::SubgraphName(name) => {
-                let deployments = self.mirror.deployments_for_subgraph(&name)?;
+                let deployments = self.mirror.deployments_for_subgraph(&name).await?;
                 if deployments.is_empty() {
                     return Ok(Vec::new());
                 }
                 deployments
             }
             status::Filter::SubgraphVersion(name, use_current) => {
-                let deployment = self.mirror.subgraph_version(&name, use_current)?;
+                let deployment = self.mirror.subgraph_version(&name, use_current).await?;
                 match deployment {
                     Some(deployment) => vec![deployment],
                     None => {
@@ -878,11 +1123,11 @@ impl SubgraphStoreInner {
                 }
             }
             status::Filter::Deployments(deployments) => {
-                self.mirror.find_sites(&deployments, true)?
+                self.mirror.find_sites(&deployments, true).await?
             }
             status::Filter::DeploymentIds(ids) => {
                 let ids: Vec<_> = ids.into_iter().map(|id| id.into()).collect();
-                self.mirror.find_sites_by_id(&ids)?
+                self.mirror.find_sites_by_id(&ids).await?
             }
         };
 
@@ -895,28 +1140,36 @@ impl SubgraphStoreInner {
                 .stores
                 .get(&shard)
                 .ok_or_else(|| StoreError::UnknownShard(shard.to_string()))?;
-            infos.extend(store.deployment_statuses(&sites)?);
+            infos.extend(store.deployment_statuses(&sites).await?);
+        }
+        let nodes = self.mirror.fill_assignments(&infos).await?;
+        for info in infos.iter_mut() {
+            info.node = nodes.get(&info.id).map(|(node, _)| node.clone());
+            info.paused = nodes.get(&info.id).map(|(_, paused)| *paused);
         }
-        self.mirror.fill_assignments(&mut infos)?;
+
         Ok(infos)
     }
 
-    pub(crate) fn version_info(&self, version: &str) -> Result<VersionInfo, StoreError> {
-        if let Some((deployment_id, created_at)) = self.mirror.version_info(version)? {
+    pub(crate) async fn version_info(&self, version: &str) -> Result<VersionInfo, StoreError> {
+        if let Some((deployment_id, created_at)) = self.mirror.version_info(version).await? {
             let id = DeploymentHash::new(deployment_id.clone())
-                .map_err(|id| constraint_violation!("illegal deployment id {}", id))?;
-            let (store, site) = self.store(&id)?;
-            let statuses = store.deployment_statuses(&[site.clone()])?;
+                .map_err(|id| internal_error!("illegal deployment id {}", id))?;
+            let (store, site) = self.store(&id).await?;
+            let statuses = store
+                .deployment_statuses(std::slice::from_ref(&site))
+                .await?;
             let status = statuses
                 .first()
                 .ok_or_else(|| StoreError::DeploymentNotFound(deployment_id.clone()))?;
             let chain = status
                 .chains
                 .first()
-                .ok_or_else(|| constraint_violation!("no chain info for {}", deployment_id))?;
+                .ok_or_else(|| internal_error!("no chain info for {}", deployment_id))?;
             let latest_ethereum_block_number =
                 chain.latest_block.as_ref().map(|block| block.number());
-            let subgraph_info = store.subgraph_info(site.as_ref())?;
+            let subgraph_info = store.subgraph_info(site.cheap_clone()).await?;
+            let layout = store.find_layout(site.cheap_clone()).await?;
             let network = site.network.clone();
 
             let info = VersionInfo {
@@ -928,7 +1181,7 @@ impl SubgraphStoreInner {
                 failed: status.health.is_failed(),
                 description: subgraph_info.description,
                 repository: subgraph_info.repository,
-                schema: subgraph_info.input,
+                schema: layout.input_schema.cheap_clone(),
                 network,
             };
             Ok(info)
@@ -937,41 +1190,47 @@ impl SubgraphStoreInner {
         }
     }
 
-    pub(crate) fn versions_for_subgraph_id(
+    pub(crate) async fn versions_for_subgraph_id(
         &self,
         subgraph_id: &str,
     ) -> Result<(Option<String>, Option<String>), StoreError> {
-        self.mirror.versions_for_subgraph_id(subgraph_id)
+        self.mirror.versions_for_subgraph_id(subgraph_id).await
     }
 
-    pub(crate) fn subgraphs_for_deployment_hash(
+    pub(crate) async fn subgraphs_for_deployment_hash(
         &self,
         deployment_hash: &str,
     ) -> Result<Vec<(String, String)>, StoreError> {
-        self.mirror.subgraphs_by_deployment_hash(deployment_hash)
+        self.mirror
+            .subgraphs_by_deployment_hash(deployment_hash)
+            .await
     }
 
     #[cfg(debug_assertions)]
-    pub fn error_count(&self, id: &DeploymentHash) -> Result<usize, StoreError> {
-        let (store, _) = self.store(id)?;
-        store.error_count(id)
+    pub async fn error_count(&self, id: &DeploymentHash) -> Result<usize, StoreError> {
+        let (store, _) = self.store(id).await?;
+        store.error_count(id).await
     }
 
-    /// Vacuum the `subgraph_deployment` table in each shard
+    /// Vacuum the `head` and `deployment` table in each shard
     pub(crate) async fn vacuum(&self) -> Vec<Result<(), StoreError>> {
         join_all(self.stores.values().map(|store| store.vacuum())).await
     }
 
-    pub fn rewind(&self, id: DeploymentHash, block_ptr_to: BlockPtr) -> Result<(), StoreError> {
-        let (store, site) = self.store(&id)?;
-        let event = store.rewind(site, block_ptr_to)?;
-        self.send_store_event(&event)
+    pub async fn rewind(&self, id: DeploymentId, block_ptr_to: BlockPtr) -> Result<(), StoreError> {
+        let site = self.find_site(id).await?;
+        let store = self.for_site(&site)?;
+        store.rewind(site, block_ptr_to).await
     }
 
-    pub fn truncate(&self, id: DeploymentHash, block_ptr_to: BlockPtr) -> Result<(), StoreError> {
-        let (store, site) = self.store(&id)?;
-        let event = store.truncate(site, block_ptr_to)?;
-        self.send_store_event(&event)
+    pub async fn truncate(
+        &self,
+        id: DeploymentId,
+        block_ptr_to: BlockPtr,
+    ) -> Result<(), StoreError> {
+        let site = self.find_site(id).await?;
+        let store = self.for_site(&site)?;
+        store.truncate(site, block_ptr_to).await
     }
 
     pub(crate) async fn get_proof_of_indexing(
@@ -980,7 +1239,7 @@ impl SubgraphStoreInner {
         indexer: &Option<Address>,
         block: BlockPtr,
     ) -> Result<Option<[u8; 32]>, StoreError> {
-        let (store, site) = self.store(id)?;
+        let (store, site) = self.store(id).await?;
         store.get_proof_of_indexing(site, indexer, block).await
     }
 
@@ -988,17 +1247,19 @@ impl SubgraphStoreInner {
         &self,
         id: &DeploymentHash,
         block_number: BlockNumber,
-        block_store: Arc<impl BlockStore>,
+        block_store: impl BlockStore,
         fetch_block_ptr: &dyn BlockPtrForNumber,
     ) -> Result<Option<(PartialBlockPtr, [u8; 32])>, StoreError> {
-        let (store, site) = self.store(id)?;
+        let (store, site) = self.store(id).await?;
 
         let block_hash = {
-            let chain_store = match block_store.chain_store(&site.network) {
+            let chain_store = match block_store.chain_store(&site.network).await {
                 Some(chain_store) => chain_store,
                 None => return Ok(None),
             };
-            let mut hashes = chain_store.block_hashes_by_block_number(block_number)?;
+            let mut hashes = chain_store
+                .block_hashes_by_block_number(block_number)
+                .await?;
 
             // If we have multiple versions of this block using any of them could introduce
             // non-determinism because we don't know which one is the right one
@@ -1018,7 +1279,7 @@ impl SubgraphStoreInner {
         };
 
         let block_for_poi_query = BlockPtr::new(block_hash.clone(), block_number);
-        let indexer = Some(Address::zero());
+        let indexer = Some(Address::ZERO);
         let poi = store
             .get_proof_of_indexing(site, &indexer, block_for_poi_query)
             .await?;
@@ -1036,22 +1297,23 @@ impl SubgraphStoreInner {
 
     // Only used by tests
     #[cfg(debug_assertions)]
-    pub fn find(
+    pub async fn find(
         &self,
         query: graph::prelude::EntityQuery,
     ) -> Result<Vec<graph::prelude::Entity>, graph::prelude::QueryExecutionError> {
-        let (store, site) = self.store(&query.subgraph_id)?;
-        store.find(site, query)
+        let (store, site) = self.store(&query.subgraph_id).await?;
+        store.find(site, query).await
     }
 
-    pub fn locate_in_shard(
+    pub async fn locate_in_shard(
         &self,
         hash: &DeploymentHash,
         shard: Shard,
     ) -> Result<Option<DeploymentLocator>, StoreError> {
         Ok(self
             .mirror
-            .find_site_in_shard(hash, &shard)?
+            .find_site_in_shard(hash, &shard)
+            .await?
             .as_ref()
             .map(|site| site.into()))
     }
@@ -1074,39 +1336,39 @@ impl SubgraphStoreInner {
         .await;
     }
 
-    pub fn analyze(
+    pub async fn analyze(
         &self,
         deployment: &DeploymentLocator,
         entity_name: Option<&str>,
     ) -> Result<(), StoreError> {
-        let (store, site) = self.store(&deployment.hash)?;
-        store.analyze(site, entity_name)
+        let (store, site) = self.store(&deployment.hash).await?;
+        store.analyze(site, entity_name).await
     }
 
     /// Return the statistics targets for all tables of `deployment`. The
     /// first return value is the default target, and the second value maps
     /// the name of each table to a map of column name to its statistics
     /// target. A value of `-1` means that the global default will be used.
-    pub fn stats_targets(
+    pub async fn stats_targets(
         &self,
         deployment: &DeploymentLocator,
     ) -> Result<(i32, BTreeMap<SqlName, BTreeMap<SqlName, i32>>), StoreError> {
-        let (store, site) = self.store(&deployment.hash)?;
-        store.stats_targets(site)
+        let (store, site) = self.store(&deployment.hash).await?;
+        store.stats_targets(site).await
     }
 
     /// Set the statistics target for columns `columns` in `deployment`. If
     /// `entity` is `Some`, only set it for the table for that entity, if it
     /// is `None`, set it for all tables in the deployment.
-    pub fn set_stats_target(
+    pub async fn set_stats_target(
         &self,
         deployment: &DeploymentLocator,
         entity: Option<&str>,
         columns: Vec<String>,
         target: i32,
     ) -> Result<(), StoreError> {
-        let (store, site) = self.store(&deployment.hash)?;
-        store.set_stats_target(site, entity, columns, target)
+        let (store, site) = self.store(&deployment.hash).await?;
+        store.set_stats_target(site, entity, columns, target).await
     }
 
     pub async fn create_manual_index(
@@ -1117,7 +1379,7 @@ impl SubgraphStoreInner {
         index_method: Method,
         after: Option<BlockNumber>,
     ) -> Result<(), StoreError> {
-        let (store, site) = self.store(&deployment.hash)?;
+        let (store, site) = self.store(&deployment.hash).await?;
         store
             .create_manual_index(site, entity_name, field_names, index_method, after)
             .await
@@ -1128,7 +1390,7 @@ impl SubgraphStoreInner {
         deployment: &DeploymentLocator,
         entity_name: &str,
     ) -> Result<Vec<CreateIndex>, StoreError> {
-        let (store, site) = self.store(&deployment.hash)?;
+        let (store, site) = self.store(&deployment.hash).await?;
         store.indexes_for_entity(site, entity_name).await
     }
 
@@ -1137,17 +1399,79 @@ impl SubgraphStoreInner {
         deployment: &DeploymentLocator,
         index_name: &str,
     ) -> Result<(), StoreError> {
-        let (store, site) = self.store(&deployment.hash)?;
+        let (store, site) = self.store(&deployment.hash).await?;
         store.drop_index(site, index_name).await
     }
 
+    pub(crate) async fn identify_and_set_account_like(
+        &self,
+        logger: &Logger,
+        min_records: u64,
+        ratio: f64,
+    ) -> Result<(), StoreError> {
+        for (_shard, store) in &self.stores {
+            let candidates = match store
+                .identify_account_like_candidates(min_records, ratio)
+                .await
+            {
+                Ok(candidates) => candidates,
+                Err(e) => {
+                    graph::slog::error!(
+                        logger,
+                        "Failed to identify account-like candidates in shard {}",
+                        _shard;
+                        "error" => e.to_string()
+                    );
+                    continue;
+                }
+            };
+
+            graph::slog::debug!(
+                logger,
+                "Found {} account-like candidates in shard {}",
+                candidates.len(),
+                _shard
+            );
+
+            for (subgraph, table_name) in candidates {
+                graph::slog::debug!(
+                    logger,
+                    "Setting table {} as account-like for deployment {}",
+                    table_name,
+                    subgraph
+                );
+
+                let res = async {
+                    let hash = DeploymentHash::new(subgraph.clone()).map_err(|_| {
+                        anyhow!("Failed to create deployment hash for subgraph: {subgraph}")
+                    })?;
+                    let (store, site) = self.store(&hash).await?;
+                    store.set_account_like(site, &table_name, true).await
+                }
+                .await;
+
+                if let Err(e) = res {
+                    graph::slog::error!(
+                        logger,
+                        "Failed to set table {} as account-like for deployment {}",
+                        table_name,
+                        subgraph;
+                        "error" => e.to_string()
+                    );
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     pub async fn set_account_like(
         &self,
         deployment: &DeploymentLocator,
         table: &str,
         is_account_like: bool,
     ) -> Result<(), StoreError> {
-        let (store, site) = self.store(&deployment.hash)?;
+        let (store, site) = self.store(&deployment.hash).await?;
         store.set_account_like(site, table, is_account_like).await
     }
 
@@ -1166,36 +1490,68 @@ impl SubgraphStoreInner {
     ) -> Result<Box<dyn PruneReporter>, StoreError> {
         // Find the store by the deployment id; otherwise, we could only
         // prune the active copy of the deployment with `deployment.hash`
-        let site = self.find_site(deployment.id.into())?;
+        let site = self.find_site(deployment.id.into()).await?;
         let store = self.for_site(&site)?;
 
         store.prune(reporter, site, req).await
     }
 
-    pub fn set_history_blocks(
+    pub async fn prune_viewer(
+        &self,
+        deployment: &DeploymentLocator,
+    ) -> Result<relational::prune::Viewer, StoreError> {
+        let site = self.find_site(deployment.id.into()).await?;
+        let store = self.for_site(&site)?;
+
+        store.prune_viewer(site).await
+    }
+
+    pub async fn set_history_blocks(
         &self,
         deployment: &DeploymentLocator,
         history_blocks: BlockNumber,
         reorg_threshold: BlockNumber,
     ) -> Result<(), StoreError> {
-        let site = self.find_site(deployment.id.into())?;
+        let site = self.find_site(deployment.id.into()).await?;
         let store = self.for_site(&site)?;
 
-        store.set_history_blocks(&site, history_blocks, reorg_threshold)
+        store
+            .set_history_blocks(&site, history_blocks, reorg_threshold)
+            .await
     }
 
-    pub fn load_deployment(&self, site: Arc<Site>) -> Result<SubgraphDeploymentEntity, StoreError> {
+    pub async fn load_deployment(
+        &self,
+        site: Arc<Site>,
+    ) -> Result<SubgraphDeploymentEntity, StoreError> {
         let src_store = self.for_site(&site)?;
-        src_store.load_deployment(site)
+        src_store.load_deployment(site).await
     }
 
-    pub fn load_deployment_by_id(
+    pub async fn load_deployment_by_id(
         &self,
         id: DeploymentId,
     ) -> Result<SubgraphDeploymentEntity, StoreError> {
-        let site = self.find_site(id)?;
+        let site = self.find_site(id).await?;
+        let src_store = self.for_site(&site)?;
+        src_store.load_deployment(site).await
+    }
+
+    pub async fn load_indexes(&self, site: Arc<Site>) -> Result<IndexList, StoreError> {
         let src_store = self.for_site(&site)?;
-        src_store.load_deployment(site)
+        src_store.load_indexes(site).await
+    }
+
+    pub async fn dump(
+        &self,
+        loc: &DeploymentLocator,
+        directory: std::path::PathBuf,
+        reporter: Box<dyn DumpReporter>,
+    ) -> Result<(), StoreError> {
+        let site = self.find_site(loc.id.into()).await?;
+        let store = self.for_site(&site)?;
+
+        store.dump(site, directory, reporter).await
     }
 }
 
@@ -1224,19 +1580,20 @@ impl EnsLookup {
         }
     }
 
-    fn is_table_empty(pool: &ConnectionPool) -> Result<bool, StoreError> {
-        let conn = pool.get()?;
-        primary::Connection::new(conn).is_ens_table_empty()
+    async fn is_table_empty(pool: &ConnectionPool) -> Result<bool, StoreError> {
+        let conn = pool.get_permitted().await?;
+        primary::Connection::new(conn).is_ens_table_empty().await
     }
 }
 
+#[async_trait]
 impl EnsLookupTrait for EnsLookup {
-    fn find_name(&self, hash: &str) -> Result<Option<String>, StoreError> {
-        let conn = self.primary.get()?;
-        primary::Connection::new(conn).find_ens_name(hash)
+    async fn find_name(&self, hash: &str) -> Result<Option<String>, StoreError> {
+        let conn = self.primary.get_permitted().await?;
+        primary::Connection::new(conn).find_ens_name(hash).await
     }
 
-    fn is_table_empty(&self) -> Result<bool, StoreError> {
+    async fn is_table_empty(&self) -> Result<bool, StoreError> {
         match self.state.load(std::sync::atomic::Ordering::SeqCst) {
             STATE_ENS_NOT_CHECKED => {}
             STATE_ENS_EMPTY => return Ok(true),
@@ -1244,7 +1601,7 @@ impl EnsLookupTrait for EnsLookup {
             _ => unreachable!("unsupported state"),
         }
 
-        let is_empty = Self::is_table_empty(&self.primary)?;
+        let is_empty = Self::is_table_empty(&self.primary).await?;
         let new_state = match is_empty {
             true => STATE_ENS_EMPTY,
             false => STATE_ENS_NOT_EMPTY,
@@ -1263,7 +1620,7 @@ impl SubgraphStoreTrait for SubgraphStore {
     }
 
     // FIXME: This method should not get a node_id
-    fn create_subgraph_deployment(
+    async fn create_subgraph_deployment(
         &self,
         name: SubgraphName,
         schema: &InputSchema,
@@ -1281,70 +1638,139 @@ impl SubgraphStoreTrait for SubgraphStore {
             mode,
             false,
         )
+        .await
     }
 
-    fn create_subgraph(&self, name: SubgraphName) -> Result<String, StoreError> {
-        let pconn = self.primary_conn()?;
-        pconn.transaction(|| pconn.create_subgraph(&name))
+    async fn create_subgraph(&self, name: SubgraphName) -> Result<String, StoreError> {
+        let mut pconn = self.primary_conn().await?;
+        pconn
+            .transaction(async move |pconn| pconn.create_subgraph(&name).await)
+            .await
     }
 
-    fn create_subgraph_features(&self, features: DeploymentFeatures) -> Result<(), StoreError> {
-        let pconn = self.primary_conn()?;
-        pconn.transaction(|| pconn.create_subgraph_features(features))
+    async fn create_subgraph_features(
+        &self,
+        features: DeploymentFeatures,
+    ) -> Result<(), StoreError> {
+        let mut pconn = self.primary_conn().await?;
+        pconn
+            .transaction(async move |pconn| pconn.create_subgraph_features(features).await)
+            .await
     }
 
-    fn remove_subgraph(&self, name: SubgraphName) -> Result<(), StoreError> {
-        let pconn = self.primary_conn()?;
-        pconn.transaction(|| -> Result<_, StoreError> {
-            let changes = pconn.remove_subgraph(name)?;
-            pconn.send_store_event(&self.sender, &StoreEvent::new(changes))
-        })
+    async fn remove_subgraph(&self, name: SubgraphName) -> Result<Vec<DeploymentHash>, StoreError> {
+        let deployments = self
+            .status(status::Filter::SubgraphName(name.to_string()))
+            .await?
+            .into_iter()
+            .filter_map(|info| DeploymentHash::new(info.subgraph).ok())
+            .collect::<Vec<_>>();
+
+        let mut pconn = self.primary_conn().await?;
+        let sender = self.sender.clone();
+        pconn
+            .transaction(async move |pconn| {
+                let changes = pconn.remove_subgraph(name).await?;
+                pconn
+                    .send_store_event(&sender, &StoreEvent::new(changes))
+                    .await
+            })
+            .await?;
+        Ok(deployments)
     }
 
-    fn reassign_subgraph(
+    async fn reassign_subgraph(
         &self,
         deployment: &DeploymentLocator,
         node_id: &NodeId,
     ) -> Result<(), StoreError> {
-        let site = self.find_site(deployment.id.into())?;
-        let pconn = self.primary_conn()?;
-        pconn.transaction(|| -> Result<_, StoreError> {
-            let changes = pconn.reassign_subgraph(site.as_ref(), node_id)?;
-            pconn.send_store_event(&self.sender, &StoreEvent::new(changes))
-        })
+        let site = self.find_site(deployment.id.into()).await?;
+        let mut pconn = self.primary_conn().await?;
+        let sender = self.sender.clone();
+        pconn
+            .transaction(async move |pconn| {
+                let changes = pconn.reassign_subgraph(site.as_ref(), node_id).await?;
+                pconn
+                    .send_store_event(&sender, &StoreEvent::new(changes))
+                    .await
+            })
+            .await
+    }
+
+    async fn unassign_subgraph(&self, deployment: &DeploymentLocator) -> Result<(), StoreError> {
+        let site = self.find_site(deployment.id.into()).await?;
+        let mut pconn = self.primary_conn().await?;
+        let sender = self.sender.clone();
+        pconn
+            .transaction(async move |pconn| {
+                let changes = pconn.unassign_subgraph(site.as_ref()).await?;
+                pconn
+                    .send_store_event(&sender, &StoreEvent::new(changes))
+                    .await
+            })
+            .await
     }
 
-    fn assigned_node(&self, deployment: &DeploymentLocator) -> Result<Option<NodeId>, StoreError> {
-        let site = self.find_site(deployment.id.into())?;
-        self.mirror.assigned_node(site.as_ref())
+    async fn pause_subgraph(&self, deployment: &DeploymentLocator) -> Result<(), StoreError> {
+        let site = self.find_site(deployment.id.into()).await?;
+        let mut pconn = self.primary_conn().await?;
+        let sender = self.sender.clone();
+        pconn
+            .transaction(async move |pconn| {
+                let changes = pconn.pause_subgraph(site.as_ref()).await?;
+                pconn
+                    .send_store_event(&sender, &StoreEvent::new(changes))
+                    .await
+            })
+            .await
+    }
+
+    async fn resume_subgraph(&self, deployment: &DeploymentLocator) -> Result<(), StoreError> {
+        let site = self.find_site(deployment.id.into()).await?;
+        let mut pconn = self.primary_conn().await?;
+        let sender = self.sender.clone();
+        pconn
+            .transaction(async move |pconn| {
+                let changes = pconn.resume_subgraph(site.as_ref()).await?;
+                pconn
+                    .send_store_event(&sender, &StoreEvent::new(changes))
+                    .await
+            })
+            .await
+    }
+
+    async fn assigned_node(
+        &self,
+        deployment: &DeploymentLocator,
+    ) -> Result<Option<NodeId>, StoreError> {
+        let site = self.find_site(deployment.id.into()).await?;
+        self.mirror.assigned_node(site.as_ref()).await
     }
 
     /// Returns Option<(node_id,is_paused)> where `node_id` is the node that
     /// the subgraph is assigned to, and `is_paused` is true if the
     /// subgraph is paused.
     /// Returns None if the deployment does not exist.
-    fn assignment_status(
+    async fn assignment_status(
         &self,
         deployment: &DeploymentLocator,
     ) -> Result<Option<(NodeId, bool)>, StoreError> {
-        let site = self.find_site(deployment.id.into())?;
-        self.mirror.assignment_status(site.as_ref())
+        let site = self.find_site(deployment.id.into()).await?;
+        self.mirror.assignment_status(site).await
     }
 
-    fn assignments(&self, node: &NodeId) -> Result<Vec<DeploymentLocator>, StoreError> {
-        self.mirror
-            .assignments(node)
-            .map(|sites| sites.iter().map(|site| site.into()).collect())
-    }
-
-    fn active_assignments(&self, node: &NodeId) -> Result<Vec<DeploymentLocator>, StoreError> {
+    async fn active_assignments(
+        &self,
+        node: &NodeId,
+    ) -> Result<Vec<DeploymentLocator>, StoreError> {
         self.mirror
             .active_assignments(node)
+            .await
             .map(|sites| sites.iter().map(|site| site.into()).collect())
     }
 
-    fn subgraph_exists(&self, name: &SubgraphName) -> Result<bool, StoreError> {
-        self.mirror.subgraph_exists(name)
+    async fn subgraph_exists(&self, name: &SubgraphName) -> Result<bool, StoreError> {
+        self.mirror.subgraph_exists(name).await
     }
 
     async fn subgraph_features(
@@ -1352,47 +1778,46 @@ impl SubgraphStoreTrait for SubgraphStore {
         deployment: &DeploymentHash,
     ) -> Result<Option<DeploymentFeatures>, StoreError> {
         let deployment = deployment.to_string();
-        self.with_primary_conn(|conn| {
-            conn.transaction(|| conn.get_subgraph_features(deployment).map_err(|e| e.into()))
-        })
-        .await
+        let mut pconn = self.primary_conn().await?;
+        pconn.get_subgraph_features(deployment).await
     }
 
-    fn entity_changes_in_block(
+    async fn entity_changes_in_block(
         &self,
         subgraph_id: &DeploymentHash,
         block: BlockNumber,
     ) -> Result<Vec<EntityOperation>, StoreError> {
-        let (store, site) = self.store(subgraph_id)?;
-        let changes = store.get_changes(site, block)?;
+        let (store, site) = self.store(subgraph_id).await?;
+        let changes = store.get_changes(site, block).await?;
         Ok(changes)
     }
 
-    fn input_schema(&self, id: &DeploymentHash) -> Result<InputSchema, StoreError> {
-        let (store, site) = self.store(id)?;
-        let info = store.subgraph_info(&site)?;
-        Ok(info.input)
+    async fn input_schema(&self, id: &DeploymentHash) -> Result<InputSchema, StoreError> {
+        let (store, site) = self.store(id).await?;
+        let layout = store.find_layout(site).await?;
+        Ok(layout.input_schema.cheap_clone())
     }
 
-    fn api_schema(
+    async fn api_schema(
         &self,
         id: &DeploymentHash,
         version: &ApiVersion,
     ) -> Result<Arc<ApiSchema>, StoreError> {
-        let (store, site) = self.store(id)?;
-        let info = store.subgraph_info(&site)?;
+        let (store, site) = self.store(id).await?;
+        let info = store.subgraph_info(site).await?;
         Ok(info.api.get(version).unwrap().clone())
     }
 
-    fn debug_fork(
+    async fn debug_fork(
         &self,
         id: &DeploymentHash,
         logger: Logger,
     ) -> Result<Option<Arc<dyn SubgraphFork>>, StoreError> {
-        let (store, site) = self.store(id)?;
-        let info = store.subgraph_info(&site)?;
+        let (store, site) = self.store(id).await?;
+        let info = store.subgraph_info(site.cheap_clone()).await?;
+        let layout = store.find_layout(site).await?;
         let fork_id = info.debug_fork;
-        let schema = info.input;
+        let schema = layout.input_schema.cheap_clone();
 
         match (self.fork_base.as_ref(), fork_id) {
             (Some(base), Some(id)) => Ok(Some(Arc::new(fork::SubgraphFork::new(
@@ -1411,42 +1836,25 @@ impl SubgraphStoreTrait for SubgraphStore {
         deployment: graph::components::store::DeploymentId,
         manifest_idx_and_name: Arc<Vec<(u32, String)>>,
     ) -> Result<Arc<dyn store::WritableStore>, StoreError> {
-        let deployment = deployment.into();
-        // We cache writables to make sure calls to this method are
-        // idempotent and there is ever only one `WritableStore` for any
-        // deployment
-        if let Some(writable) = self.writables.lock().unwrap().get(&deployment) {
-            // A poisoned writable will not write anything anymore; we
-            // discard it and create a new one that is properly initialized
-            // according to the state in the database.
-            if !writable.poisoned() {
-                return Ok(writable.cheap_clone());
-            }
-        }
+        self.get_or_create_writable_store(logger, deployment, manifest_idx_and_name)
+            .await
+            .map(|store| store as Arc<dyn store::WritableStore>)
+    }
 
-        // Ideally the lower level functions would be asyncified.
-        let this = self.clone();
-        let site = graph::spawn_blocking_allow_panic(move || -> Result<_, StoreError> {
-            this.find_site(deployment)
-        })
-        .await
-        .unwrap()?; // Propagate panics, there shouldn't be any.
+    async fn sourceable(
+        self: Arc<Self>,
+        deployment: graph::components::store::DeploymentId,
+    ) -> Result<Arc<dyn store::SourceableStore>, StoreError> {
+        let deployment = deployment.into();
+        let site = self.find_site(deployment).await?;
+        let store = self.for_site(&site)?;
+        let input_schema = self.input_schema(&site.deployment).await?;
 
-        let writable = Arc::new(
-            WritableStore::new(
-                self.as_ref().clone(),
-                logger,
-                site,
-                manifest_idx_and_name,
-                self.registry.clone(),
-            )
-            .await?,
-        );
-        self.writables
-            .lock()
-            .unwrap()
-            .insert(deployment, writable.cheap_clone());
-        Ok(writable)
+        Ok(Arc::new(SourceableStore::new(
+            site,
+            store.clone(),
+            input_schema,
+        )))
     }
 
     async fn stop_subgraph(&self, loc: &DeploymentLocator) -> Result<(), StoreError> {
@@ -1461,45 +1869,52 @@ impl SubgraphStoreTrait for SubgraphStore {
         }
     }
 
-    fn is_deployed(&self, id: &DeploymentHash) -> Result<bool, StoreError> {
-        match self.site(id) {
+    async fn is_deployed(&self, id: &DeploymentHash) -> Result<bool, StoreError> {
+        match self.site(id).await {
             Ok(_) => Ok(true),
             Err(StoreError::DeploymentNotFound(_)) => Ok(false),
             Err(e) => Err(e),
         }
     }
 
-    fn graft_pending(&self, id: &DeploymentHash) -> Result<bool, StoreError> {
-        let (store, _) = self.store(id)?;
-        let graft_detail = store.graft_pending(id)?;
+    async fn graft_pending(&self, id: &DeploymentHash) -> Result<bool, StoreError> {
+        let (store, _) = self.store(id).await?;
+        let graft_detail = store.graft_pending(id).await?;
         Ok(graft_detail.is_some())
     }
 
     async fn least_block_ptr(&self, id: &DeploymentHash) -> Result<Option<BlockPtr>, StoreError> {
-        let (store, site) = self.store(id)?;
+        let (store, site) = self.store(id).await?;
         store.block_ptr(site.cheap_clone()).await
     }
 
+    async fn earliest_block_number(&self, id: &DeploymentHash) -> Result<BlockNumber, StoreError> {
+        let (store, site) = self.store(id).await?;
+        let state = store.deployment_state(site.cheap_clone()).await?;
+        Ok(state.earliest_block_number)
+    }
+
     async fn is_healthy(&self, id: &DeploymentHash) -> Result<bool, StoreError> {
-        let (store, site) = self.store(id)?;
+        let (store, site) = self.store(id).await?;
         let health = store.health(&site).await?;
         Ok(matches!(health, SubgraphHealth::Healthy))
     }
 
     /// Find the deployment locators for the subgraph with the given hash
-    fn locators(&self, hash: &str) -> Result<Vec<DeploymentLocator>, StoreError> {
+    async fn locators(&self, hash: &str) -> Result<Vec<DeploymentLocator>, StoreError> {
         Ok(self
             .mirror
-            .find_sites(&[hash.to_string()], false)?
+            .find_sites(&[hash.to_string()], false)
+            .await?
             .iter()
             .map(|site| site.into())
             .collect())
     }
 
-    fn active_locator(&self, hash: &str) -> Result<Option<DeploymentLocator>, StoreError> {
-        let sites = self.mirror.find_sites(&[hash.to_string()], true)?;
+    async fn active_locator(&self, hash: &str) -> Result<Option<DeploymentLocator>, StoreError> {
+        let sites = self.mirror.find_sites(&[hash.to_string()], true).await?;
         if sites.len() > 1 {
-            return Err(constraint_violation!(
+            return Err(internal_error!(
                 "There are {} active deployments for {hash}, there should only be one",
                 sites.len()
             ));
@@ -1507,20 +1922,48 @@ impl SubgraphStoreTrait for SubgraphStore {
         Ok(sites.first().map(DeploymentLocator::from))
     }
 
-    async fn set_manifest_raw_yaml(
+    async fn instrument(&self, deployment: &DeploymentLocator) -> Result<bool, StoreError> {
+        let site = self.find_site(deployment.id.into()).await?;
+        let store = self.for_site(&site)?;
+
+        let info = store.subgraph_info(site).await?;
+        Ok(info.instrument)
+    }
+
+    async fn set_raw_manifest_once(
         &self,
         hash: &DeploymentHash,
-        raw_yaml: String,
+        raw_manifest: &serde_yaml::Mapping,
     ) -> Result<(), StoreError> {
-        let (store, site) = self.store(hash)?;
-        store.set_manifest_raw_yaml(site, raw_yaml).await
+        let (store, site) = self.store(hash).await?;
+
+        store
+            .set_raw_manifest_once(
+                site,
+                serde_yaml::to_string(raw_manifest).map_err(|_e| {
+                    StoreError::InternalError("invalid subgraph manifest".to_string())
+                })?,
+            )
+            .await
     }
 
-    fn instrument(&self, deployment: &DeploymentLocator) -> Result<bool, StoreError> {
-        let site = self.find_site(deployment.id.into())?;
-        let store = self.for_site(&site)?;
+    async fn raw_manifest(
+        &self,
+        hash: &DeploymentHash,
+    ) -> Result<Option<serde_yaml::Mapping>, StoreError> {
+        let (store, site) = self.store(hash).await?;
 
-        let info = store.subgraph_info(&site)?;
-        Ok(info.instrument)
+        store
+            .raw_manifest(site)
+            .await
+            .and_then(|optional_raw_manifest| {
+                optional_raw_manifest
+                    .map(|raw_manifest| {
+                        serde_yaml::from_str(&raw_manifest).map_err(|_e| {
+                            StoreError::InternalError("invalid subgraph manifest".to_string())
+                        })
+                    })
+                    .transpose()
+            })
     }
 }
diff --git a/store/postgres/src/transaction_receipt.rs b/store/postgres/src/transaction_receipt.rs
index 81da9fbb513..1177422f42b 100644
--- a/store/postgres/src/transaction_receipt.rs
+++ b/store/postgres/src/transaction_receipt.rs
@@ -7,17 +7,17 @@ use std::convert::TryFrom;
 /// Type that comes straight out of a SQL query
 #[derive(QueryableByName)]
 pub(crate) struct RawTransactionReceipt {
-    #[sql_type = "Binary"]
+    #[diesel(sql_type = Binary)]
     transaction_hash: Vec<u8>,
-    #[sql_type = "Binary"]
+    #[diesel(sql_type = Binary)]
     transaction_index: Vec<u8>,
-    #[sql_type = "Nullable<Binary>"]
+    #[diesel(sql_type = Nullable<Binary>)]
     block_hash: Option<Vec<u8>>,
-    #[sql_type = "Nullable<Binary>"]
+    #[diesel(sql_type = Nullable<Binary>)]
     block_number: Option<Vec<u8>>,
-    #[sql_type = "Nullable<Binary>"]
+    #[diesel(sql_type = Nullable<Binary>)]
     gas_used: Option<Vec<u8>>,
-    #[sql_type = "Nullable<Binary>"]
+    #[diesel(sql_type = Nullable<Binary>)]
     status: Option<Vec<u8>>,
 }
 
@@ -39,20 +39,30 @@ impl TryFrom<RawTransactionReceipt> for LightTransactionReceipt {
         let block_hash = block_hash.map(drain_vector).transpose()?;
         let block_number = block_number.map(drain_vector).transpose()?;
         let gas_used = gas_used.map(drain_vector).transpose()?;
-        let status = status.map(drain_vector).transpose()?;
+
+        // Convert big-endian bytes to numbers
+        let transaction_index = u64::from_be_bytes(transaction_index);
+        let block_number = block_number.map(u64::from_be_bytes);
+        let gas_used = gas_used.map(u64::from_be_bytes).unwrap_or(0);
+
+        // Status is non-zero for success, zero for failure. Works for any byte length.
+        // Defaults to true for pre-Byzantium receipts (no status field), consistent with alloy.
+        let status = status
+            .map(|bytes| bytes.iter().any(|&b| b != 0))
+            .unwrap_or(true);
 
         Ok(LightTransactionReceipt {
             transaction_hash: transaction_hash.into(),
-            transaction_index: transaction_index.into(),
+            transaction_index,
             block_hash: block_hash.map(Into::into),
-            block_number: block_number.map(Into::into),
-            gas_used: gas_used.map(Into::into),
-            status: status.map(Into::into),
+            block_number,
+            gas_used,
+            status,
         })
     }
 }
 
-/// Converts Vec<u8> to [u8; N], where N is the vector's expected lenght.
+/// Converts Vec<u8> to [u8; N], where N is the vector's expected length.
 /// Fails if input size is larger than output size.
 pub(crate) fn drain_vector<const N: usize>(input: Vec<u8>) -> Result<[u8; N], anyhow::Error> {
     anyhow::ensure!(input.len() <= N, "source is larger than output");
diff --git a/store/postgres/src/vid_batcher.rs b/store/postgres/src/vid_batcher.rs
new file mode 100644
index 00000000000..1275608e364
--- /dev/null
+++ b/store/postgres/src/vid_batcher.rs
@@ -0,0 +1,582 @@
+use std::time::{Duration, Instant};
+
+use diesel::{
+    sql_query,
+    sql_types::{BigInt, Integer},
+};
+use diesel_async::RunQueryDsl as _;
+use graph::{
+    env::ENV_VARS,
+    prelude::{BlockNumber, BlockPtr, StoreError},
+    util::ogive::Ogive,
+};
+
+use crate::{
+    AsyncPgConnection, catalog,
+    primary::Namespace,
+    relational::{Table, VID_COLUMN},
+};
+
+/// The initial batch size for tables that do not have an array column
+const INITIAL_BATCH_SIZE: i64 = 10_000;
+/// The initial batch size for tables that do have an array column; those
+/// arrays can be large and large arrays will slow down copying a lot. We
+/// therefore tread lightly in that case
+const INITIAL_BATCH_SIZE_LIST: i64 = 100;
+
+/// Track the desired size of a batch in such a way that doing the next
+/// batch gets close to TARGET_DURATION for the time it takes to copy one
+/// batch, but don't step up the size by more than 2x at once
+#[derive(Debug, Queryable)]
+pub(crate) struct AdaptiveBatchSize {
+    pub size: i64,
+    pub target: Duration,
+}
+
+impl AdaptiveBatchSize {
+    pub fn with_size(size: i64) -> Self {
+        Self {
+            size,
+            target: ENV_VARS.store.batch_target_duration,
+        }
+    }
+
+    pub fn new(table: &Table) -> Self {
+        let size = if table.columns.iter().any(|col| col.is_list()) {
+            INITIAL_BATCH_SIZE_LIST
+        } else {
+            INITIAL_BATCH_SIZE
+        };
+
+        Self {
+            size,
+            target: ENV_VARS.store.batch_target_duration,
+        }
+    }
+
+    // adjust batch size by trying to extrapolate in such a way that we
+    // get close to TARGET_DURATION for the time it takes to copy one
+    // batch, but don't step up batch_size by more than 2x at once
+    pub fn adapt(&mut self, duration: Duration) -> i64 {
+        // Avoid division by zero
+        let duration = duration.as_millis().max(1);
+        let new_batch_size = self.size as f64 * self.target.as_millis() as f64 / duration as f64;
+        self.size = (2 * self.size).min(new_batch_size.round() as i64);
+        self.size
+    }
+}
+
+/// A timer that works like `std::time::Instant` in non-test code, but
+/// returns a fake elapsed value in tests
+struct Timer {
+    start: Instant,
+    #[cfg(test)]
+    duration: Duration,
+}
+
+impl Timer {
+    fn new() -> Self {
+        Self {
+            start: Instant::now(),
+            #[cfg(test)]
+            duration: Duration::from_secs(0),
+        }
+    }
+
+    fn start(&mut self) {
+        self.start = Instant::now();
+    }
+
+    #[cfg(test)]
+    fn elapsed(&self) -> Duration {
+        self.duration
+    }
+
+    #[cfg(not(test))]
+    fn elapsed(&self) -> Duration {
+        self.start.elapsed()
+    }
+
+    #[cfg(test)]
+    fn set(&mut self, duration: Duration) {
+        self.duration = duration;
+    }
+}
+
+/// A batcher for moving through a large range of `vid` values in a way such
+/// that each batch takes approximatley the same amount of time. The batcher
+/// takes uneven distributions of `vid` values into account by using the
+/// histogram from `pg_stats` for the table through which we are iterating.
+pub(crate) struct VidBatcher {
+    batch_size: AdaptiveBatchSize,
+    start: i64,
+    end: i64,
+    max_vid: i64,
+
+    ogive: Option<Ogive>,
+
+    step_timer: Timer,
+}
+
+impl VidBatcher {
+    /// Initialize a batcher for batching through entries in `table` with
+    /// `vid` in the given `vid_range`
+    ///
+    /// The `vid_range` is inclusive, i.e., the batcher will iterate over
+    /// all vids `vid_range.0 <= vid <= vid_range.1`; for an empty table,
+    /// the `vid_range` must be set to `(-1, 0)`
+    pub async fn load(
+        conn: &mut AsyncPgConnection,
+        nsp: &Namespace,
+        table: &Table,
+        vid_range: VidRange,
+    ) -> Result<Self, StoreError> {
+        let bounds = catalog::histogram_bounds(conn, nsp, &table.name, VID_COLUMN).await?;
+        let batch_size = AdaptiveBatchSize::new(table);
+        Self::new(bounds, vid_range, batch_size)
+    }
+
+    fn new(
+        bounds: Vec<i64>,
+        range: VidRange,
+        batch_size: AdaptiveBatchSize,
+    ) -> Result<Self, StoreError> {
+        let start = range.min;
+
+        let bounds = {
+            // Keep only histogram bounds that are relevent for the range
+            let mut bounds = bounds
+                .into_iter()
+                .filter(|bound| range.min <= *bound && range.max >= *bound)
+                .collect::<Vec<_>>();
+            // The first and last entry in `bounds` are Postgres' estimates
+            // of the min and max `vid` values in the table. We use the
+            // actual min and max `vid` values from the `vid_range` instead
+            let len = bounds.len();
+            if len > 1 {
+                bounds[0] = range.min;
+                bounds[len - 1] = range.max;
+            } else {
+                // If Postgres doesn't have a histogram, just use one bucket
+                // from min to max
+                bounds = vec![range.min, range.max];
+            }
+            bounds
+        };
+        let mut ogive = if range.is_empty() {
+            None
+        } else {
+            Some(Ogive::from_equi_histogram(bounds, range.size())?)
+        };
+        let end = match ogive.as_mut() {
+            None => start + batch_size.size,
+            Some(ogive) => ogive.next_point(start, batch_size.size as usize)?,
+        };
+
+        Ok(Self {
+            batch_size,
+            start,
+            end,
+            max_vid: range.max,
+            ogive,
+            step_timer: Timer::new(),
+        })
+    }
+
+    /// Explicitly set the batch size
+    pub fn with_batch_size(mut self: VidBatcher, size: usize) -> Self {
+        self.batch_size.size = size as i64;
+        self
+    }
+
+    pub(crate) fn next_vid(&self) -> i64 {
+        self.start
+    }
+
+    pub(crate) fn target_vid(&self) -> i64 {
+        self.max_vid
+    }
+
+    pub fn batch_size(&self) -> usize {
+        self.batch_size.size as usize
+    }
+
+    pub fn finished(&self) -> bool {
+        self.start > self.max_vid
+    }
+
+    /// Perform the work for one batch. The function `f` is called with the
+    /// start and end `vid` for this batch and should perform all the work
+    /// for rows with `start <= vid <= end`, i.e. the start and end values
+    /// are inclusive.
+    ///
+    /// Once `f` returns, the batch size will be adjusted so that the time
+    /// the next batch will take is close to the target duration.
+    ///
+    /// The function returns the time it took to process the batch and the
+    /// result of `f`. If the batcher is finished, `f` will not be called,
+    /// and `None` will be returned as its result.
+    pub async fn step<F, T>(&mut self, f: F) -> Result<(Duration, Option<T>), StoreError>
+    where
+        F: AsyncFnOnce(i64, i64) -> Result<T, StoreError>,
+    {
+        if self.finished() {
+            return Ok((Duration::from_secs(0), None));
+        }
+
+        match self.ogive.as_mut() {
+            None => Ok((Duration::from_secs(0), None)),
+            Some(ogive) => {
+                self.step_timer.start();
+
+                let res = f(self.start, self.end).await?;
+                let duration = self.step_timer.elapsed();
+
+                let batch_size = self.batch_size.adapt(duration);
+                // We can't possibly copy farther than `max_vid`
+                self.start = (self.end + 1).min(self.max_vid + 1);
+                self.end = ogive.next_point(self.start, batch_size as usize)?;
+
+                Ok((duration, Some(res)))
+            }
+        }
+    }
+
+    pub(crate) fn set_batch_size(&mut self, size: usize) {
+        self.batch_size.size = size as i64;
+        self.end = match &self.ogive {
+            Some(ogive) => ogive.next_point(self.start, size).unwrap(),
+            None => self.start + size as i64,
+        };
+    }
+}
+
+#[derive(Debug, Copy, Clone, QueryableByName)]
+pub(crate) struct VidRange {
+    #[diesel(sql_type = BigInt, column_name = "min_vid")]
+    pub min: i64,
+    #[diesel(sql_type = BigInt, column_name = "max_vid")]
+    pub max: i64,
+}
+
+const EMPTY_VID_RANGE: VidRange = VidRange { max: -1, min: 0 };
+
+impl VidRange {
+    pub fn new(min_vid: i64, max_vid: i64) -> Self {
+        Self {
+            min: min_vid,
+            max: max_vid,
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        // min > max can happen when we restart a copy job that has finished
+        // some tables. For those, min (the next_vid) will be larger than
+        // max (the target_vid)
+        self.max == -1 || self.min > self.max
+    }
+
+    pub fn size(&self) -> usize {
+        (self.max - self.min) as usize + 1
+    }
+
+    /// Return the full range of `vid` values in the table `src`
+    pub async fn for_copy(
+        conn: &mut AsyncPgConnection,
+        src: &Table,
+        target_block: &BlockPtr,
+    ) -> Result<Self, StoreError> {
+        let max_block_clause = if src.immutable {
+            "block$ <= $1"
+        } else {
+            "lower(block_range) <= $1"
+        };
+        let vid_range = diesel_async::RunQueryDsl::load::<VidRange>(
+            sql_query(format!(
+                "/* controller=copy,target={target_number} */ \
+                 select coalesce(min(vid), 0) as min_vid, \
+                        coalesce(max(vid), -1) as max_vid \
+                   from {src_name} where {max_block_clause}",
+                target_number = target_block.number,
+                src_name = src.qualified_name.as_str(),
+                max_block_clause = max_block_clause
+            ))
+            .bind::<Integer, _>(&target_block.number),
+            conn,
+        )
+        .await?
+        .pop()
+        .unwrap_or(EMPTY_VID_RANGE);
+        Ok(vid_range)
+    }
+
+    /// Return the first and last vid of any entity that is visible in the
+    /// block range from `first_block` (inclusive) to `last_block`
+    /// (exclusive)
+    pub async fn for_prune(
+        conn: &mut AsyncPgConnection,
+        src: &Table,
+        first_block: BlockNumber,
+        last_block: BlockNumber,
+    ) -> Result<Self, StoreError> {
+        sql_query(format!(
+            "/* controller=prune,first={first_block},last={last_block} */ \
+                     select coalesce(min(vid), 0) as min_vid, \
+                            coalesce(max(vid), -1) as max_vid from {src} \
+                      where lower(block_range) <= $2 \
+                        and coalesce(upper(block_range), 2147483647) > $1 \
+                        and coalesce(upper(block_range), 2147483647) <= $2 \
+                        and block_range && int4range($1, $2)",
+            src = src.qualified_name,
+        ))
+        .bind::<Integer, _>(first_block)
+        .bind::<Integer, _>(last_block)
+        .get_result::<VidRange>(conn)
+        .await
+        .map_err(StoreError::from)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const S001: Duration = Duration::from_secs(1);
+    const S010: Duration = Duration::from_secs(10);
+    const S050: Duration = Duration::from_secs(50);
+    const S100: Duration = Duration::from_secs(100);
+    const S200: Duration = Duration::from_secs(200);
+
+    struct Batcher {
+        vid: VidBatcher,
+    }
+
+    impl Batcher {
+        fn new(bounds: Vec<i64>, size: i64) -> Self {
+            let batch_size = AdaptiveBatchSize { size, target: S100 };
+            let vid_range = VidRange::new(bounds[0], *bounds.last().unwrap());
+            Self {
+                vid: VidBatcher::new(bounds, vid_range, batch_size).unwrap(),
+            }
+        }
+
+        #[track_caller]
+        fn at(&self, start: i64, end: i64, size: i64) {
+            assert_eq!(self.vid.start, start, "at start");
+            assert_eq!(self.vid.end, end, "at end");
+            assert_eq!(self.vid.batch_size.size, size, "at size");
+        }
+
+        async fn step(&mut self, start: i64, end: i64, duration: Duration) {
+            self.vid.step_timer.set(duration);
+
+            match self.vid.step(async |s, e| Ok((s, e))).await.unwrap() {
+                (d, Some((s, e))) => {
+                    // Failing here indicates that our clever Timer is misbehaving
+                    assert_eq!(d, duration, "step duration");
+                    assert_eq!(s, start, "step start");
+                    assert_eq!(e, end, "step end");
+                }
+                (_, None) => {
+                    if start > end {
+                        // Expected, the batcher is exhausted
+                    } else {
+                        panic!("step didn't return start and end")
+                    }
+                }
+            }
+        }
+
+        async fn run(&mut self, start: i64, end: i64, size: i64, duration: Duration) {
+            self.at(start, end, size);
+            self.step(start, end, duration).await;
+        }
+
+        fn finished(&self) -> bool {
+            self.vid.finished()
+        }
+    }
+
+    impl std::fmt::Debug for Batcher {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.debug_struct("Batcher")
+                .field("start", &self.vid.start)
+                .field("end", &self.vid.end)
+                .field("size", &self.vid.batch_size.size)
+                .field("duration", &self.vid.batch_size.target.as_secs())
+                .finish()
+        }
+    }
+
+    #[graph::test]
+    async fn simple() {
+        let bounds = vec![10, 20, 30, 40, 49];
+        let mut batcher = Batcher::new(bounds, 5);
+
+        batcher.at(10, 15, 5);
+
+        batcher.step(10, 15, S001).await;
+        batcher.at(16, 26, 10);
+
+        batcher.step(16, 26, S001).await;
+        batcher.at(27, 46, 20);
+        assert!(!batcher.finished());
+
+        batcher.step(27, 46, S001).await;
+        batcher.at(47, 49, 40);
+        assert!(!batcher.finished());
+
+        batcher.step(47, 49, S001).await;
+        assert!(batcher.finished());
+        batcher.at(50, 49, 80);
+    }
+
+    #[graph::test]
+    async fn non_uniform() {
+        // A distribution that is flat in the beginning and then steeper and
+        // linear towards the end. The easiest way to see this is to graph
+        // `(bounds[i], i*40)`
+        let bounds = vec![40, 180, 260, 300, 320, 330, 340, 350, 359];
+        let mut batcher = Batcher::new(bounds, 10);
+
+        // The schedule of how we move through the bounds above in batches,
+        // with varying timings for each batch
+        #[allow(clippy::zero_prefixed_literal)]
+        {
+            batcher.run(040, 075, 10, S010).await;
+            batcher.run(076, 145, 20, S010).await;
+            batcher.run(146, 240, 40, S200).await;
+            batcher.run(241, 270, 20, S200).await;
+            batcher.run(271, 281, 10, S200).await;
+            batcher.run(282, 287, 05, S050).await;
+            batcher.run(288, 298, 10, S050).await;
+            batcher.run(299, 309, 20, S050).await;
+            batcher.run(310, 325, 40, S100).await;
+            batcher.run(326, 336, 40, S100).await;
+            batcher.run(337, 347, 40, S100).await;
+            batcher.run(348, 357, 40, S100).await;
+            batcher.run(358, 359, 40, S010).await;
+            assert!(batcher.finished());
+        }
+
+        batcher.at(360, 359, 80);
+        batcher.step(360, 359, S010).await;
+    }
+
+    #[test]
+    fn vid_batcher_adjusts_bounds() {
+        // The first and last entry in `bounds` are estimats of the min and
+        // max that are slightly off compared to the actual min and max we
+        // put in `vid_range`. Check that `VidBatcher` uses the actual min
+        // and max from `vid_range`.
+        let bounds = vec![639, 20_000, 40_000, 60_000, 80_000, 90_000];
+        let vid_range = VidRange::new(1, 100_000);
+        let batch_size = AdaptiveBatchSize {
+            size: 1000,
+            target: S100,
+        };
+
+        let vid_batcher = VidBatcher::new(bounds, vid_range, batch_size).unwrap();
+        let ogive = vid_batcher.ogive.as_ref().unwrap();
+        assert_eq!(1, ogive.start());
+        assert_eq!(100_000, ogive.end());
+    }
+
+    #[graph::test]
+    async fn vid_batcher_handles_large_vid() {
+        // An example with very large `vid` values which come from the new
+        // schema of setting the `vid` to `block_num << 32 + sequence_num`.
+        // These values are taken from an actual example subgraph and cuased
+        // errors because of numerical roundoff issues
+        const MIN: i64 = 186155521970012263;
+        const MAX: i64 = 187989601854423140;
+        const BOUNDS: &[i64] = &[
+            186155521970012263,
+            186155552034783334,
+            186166744719556711,
+            187571594162339943,
+            187571628522078310,
+            187576619274076263,
+            187576649338847334,
+            187580570643988583,
+            187590242910339175,
+            187590268680142950,
+            187963647367053415,
+            187970828552372324,
+            187986749996138596,
+            187989601854423140,
+        ];
+
+        // The start, end, and batch size we expect when we run through the
+        // `vid_batcher` we set up below with `MIN`, `MAX` and `BOUNDS`
+        const STEPS: &[(i64, i64, i64)] = &[
+            (186155521970012263, 186155521970012265, 2),
+            (186155521970012266, 186155521970012269, 3),
+            (186155521970012270, 186155521970012276, 6),
+            (186155521970012277, 186155521970012289, 12),
+            (186155521970012290, 186155521970012312, 22),
+            (186155521970012313, 186155521970012353, 40),
+            (186155521970012354, 186155521970012426, 72),
+            (186155521970012427, 186155521970012557, 130),
+            (186155521970012558, 186155521970012792, 234),
+            (186155521970012793, 186155521970013215, 422),
+            (186155521970013216, 186155521970013976, 760),
+            (186155521970013977, 186155521970015346, 1369),
+            (186155521970015347, 186155521970017812, 2465),
+            (186155521970017813, 186155521970022250, 4437),
+            (186155521970022251, 186155521970030238, 7987),
+            (186155521970030239, 186155521970044616, 14377),
+            (186155521970044617, 186155521970070495, 25878),
+            (186155521970070496, 186155521970117077, 46581),
+            (186155521970117078, 186155521970200925, 83847),
+            (186155521970200926, 186155521970351851, 150925),
+            (186155521970351852, 186155521970623517, 271665),
+            (186155521970623518, 186155521971112515, 488997),
+            (186155521971112516, 186155521971992710, 880194),
+            (186155521971992711, 186155521973577061, 1584350),
+            (186155521973577062, 186155521976428893, 2851831),
+            (186155521976428894, 186155521981562190, 5133296),
+            (186155521981562191, 186155521990802124, 9239933),
+            (186155521990802125, 186155522007434004, 16631879),
+            (186155522007434005, 186155522037371388, 29937383),
+            (186155522037371389, 186155522091258678, 53887289),
+            (186155522091258679, 186155522188255800, 96997121),
+            (186155522188255801, 186155522362850619, 174594818),
+            (186155522362850620, 186155522677121292, 314270672),
+            (186155522677121293, 186155523242808503, 565687210),
+            (186155523242808504, 186155524261045483, 1018236979),
+            (186155524261045484, 186155526093872046, 1832826562),
+            (186155526093872047, 186155529392959859, 3299087812),
+            (186155529392959860, 186155535331317922, 5938358062),
+            (186155535331317923, 186155546020362436, 10689044513),
+            (186155546020362437, 186160475833232786, 4929812870349),
+            (186160475833232787, 186998193536485260, 837717703252473),
+            (186998193536485261, 187574948946679478, 576755410194217),
+            (187574948946679479, 187590253155585376, 15304208905897),
+            (187590253155585377, 187989601854423140, 399348698837763),
+        ];
+
+        let vid_range = VidRange::new(MIN, MAX);
+        let batch_size = AdaptiveBatchSize {
+            size: 10000,
+            target: Duration::from_secs(180),
+        };
+
+        let mut vid_batcher = VidBatcher::new(BOUNDS.to_vec(), vid_range, batch_size).unwrap();
+        vid_batcher.step_timer.set(Duration::from_secs(100));
+
+        // Run through the entire `vid_batcher`, collecting start and end in
+        // `steps`
+        let mut steps = Vec::new();
+        while let Some((start, end, step)) = vid_batcher
+            .step(async |start, end| Ok((start, end, end - start)))
+            .await
+            .unwrap()
+            .1
+        {
+            steps.push((start, end, step));
+        }
+
+        assert_eq!(STEPS, &steps);
+    }
+}
diff --git a/store/postgres/src/writable.rs b/store/postgres/src/writable.rs
index 99a46ba4df4..633688aeb1a 100644
--- a/store/postgres/src/writable.rs
+++ b/store/postgres/src/writable.rs
@@ -1,43 +1,47 @@
 use std::collections::BTreeSet;
-use std::ops::Deref;
+use std::ops::{Deref, Range};
+use std::sync::Mutex;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Mutex, RwLock, TryLockError as RwLockError};
-use std::time::{Duration, Instant};
+
+use graph::parking_lot::RwLock;
+use std::time::Instant;
 use std::{collections::BTreeMap, sync::Arc};
 
-use graph::blockchain::block_stream::FirehoseCursor;
+use async_trait::async_trait;
 use graph::blockchain::BlockTime;
+use graph::blockchain::block_stream::{EntitySourceOperation, FirehoseCursor};
 use graph::components::store::{Batch, DeploymentCursorTracker, DerivedEntityQuery, ReadStore};
-use graph::constraint_violation;
 use graph::data::store::IdList;
 use graph::data::subgraph::schema;
 use graph::data_source::CausalityRegion;
+use graph::internal_error;
 use graph::prelude::{
-    BlockNumber, CacheWeight, Entity, MetricsRegistry, SubgraphDeploymentEntity,
-    SubgraphStore as _, BLOCK_NUMBER_MAX,
+    BLOCK_NUMBER_MAX, BlockNumber, CacheWeight, Entity, MetricsRegistry, SubgraphDeploymentEntity,
+    SubgraphStore as _,
 };
 use graph::schema::{EntityKey, EntityType, InputSchema};
-use graph::slog::{info, warn};
-use graph::tokio::select;
-use graph::tokio::sync::Notify;
-use graph::tokio::task::JoinHandle;
+use graph::slog::{debug, info, warn};
 use graph::util::bounded_queue::BoundedQueue;
 use graph::{
     cheap_clone::CheapClone,
-    components::store::{self, write::EntityOp, WritableStore as WritableStoreTrait},
+    components::store::{self, WritableStore as WritableStoreTrait, write::EntityOp},
     data::subgraph::schema::SubgraphError,
     prelude::{
-        BlockPtr, DeploymentHash, EntityModification, Error, Logger, StopwatchMetrics, StoreError,
-        StoreEvent, UnfailOutcome, ENV_VARS,
+        BlockPtr, DeploymentHash, ENV_VARS, EntityModification, Logger, StopwatchMetrics,
+        StoreError, StoreEvent, UnfailOutcome,
     },
     slog::error,
 };
 use store::StoredDynamicDataSource;
+use tokio::select;
+use tokio::sync::Notify;
+use tokio::task::JoinHandle;
 
 use crate::deployment_store::DeploymentStore;
 use crate::primary::DeploymentId;
-use crate::retry;
-use crate::{primary, primary::Site, relational::Layout, SubgraphStore};
+use crate::relational::index::IndexList;
+use crate::{NotificationSender, retry};
+use crate::{SubgraphStore, primary, primary::Site, relational::Layout};
 
 /// A wrapper around `SubgraphStore` that only exposes functions that are
 /// safe to call from `WritableStore`, i.e., functions that either do not
@@ -47,24 +51,31 @@ use crate::{primary, primary::Site, relational::Layout, SubgraphStore};
 struct WritableSubgraphStore(SubgraphStore);
 
 impl WritableSubgraphStore {
-    fn primary_conn(&self) -> Result<primary::Connection, StoreError> {
-        self.0.primary_conn()
+    async fn primary_conn(&self) -> Result<primary::Connection, StoreError> {
+        self.0.primary_conn().await
+    }
+
+    fn notification_sender(&self) -> Arc<NotificationSender> {
+        self.0.notification_sender()
     }
 
-    pub(crate) fn send_store_event(&self, event: &StoreEvent) -> Result<(), StoreError> {
-        self.0.send_store_event(event)
+    async fn layout(&self, id: &DeploymentHash) -> Result<Arc<Layout>, StoreError> {
+        self.0.layout(id).await
     }
 
-    fn layout(&self, id: &DeploymentHash) -> Result<Arc<Layout>, StoreError> {
-        self.0.layout(id)
+    async fn load_deployment(
+        &self,
+        site: Arc<Site>,
+    ) -> Result<SubgraphDeploymentEntity, StoreError> {
+        self.0.load_deployment(site).await
     }
 
-    fn load_deployment(&self, site: Arc<Site>) -> Result<SubgraphDeploymentEntity, StoreError> {
-        self.0.load_deployment(site)
+    async fn find_site(&self, id: DeploymentId) -> Result<Arc<Site>, StoreError> {
+        self.0.find_site(id).await
     }
 
-    fn find_site(&self, id: DeploymentId) -> Result<Arc<Site>, StoreError> {
-        self.0.find_site(id)
+    async fn load_indexes(&self, site: Arc<Site>) -> Result<IndexList, StoreError> {
+        self.0.load_indexes(site).await
     }
 }
 
@@ -80,7 +91,7 @@ pub enum LastRollup {
 }
 
 impl LastRollup {
-    fn new(
+    async fn new(
         store: Arc<DeploymentStore>,
         site: Arc<Site>,
         has_aggregations: bool,
@@ -89,10 +100,10 @@ impl LastRollup {
         let kind = match (has_aggregations, block) {
             (false, _) => LastRollup::NotNeeded,
             (true, None) => LastRollup::Unknown,
-            (true, Some(block)) => {
-                let block_time = store.block_time(site, block)?;
+            (true, Some(_)) => {
+                let block_time = store.block_time(site).await?;
                 block_time
-                    .map(|b| LastRollup::Some(b))
+                    .map(LastRollup::Some)
                     .unwrap_or(LastRollup::Unknown)
             }
         };
@@ -103,7 +114,7 @@ impl LastRollup {
 pub struct LastRollupTracker(Mutex<LastRollup>);
 
 impl LastRollupTracker {
-    fn new(
+    async fn new(
         store: Arc<DeploymentStore>,
         site: Arc<Site>,
         has_aggregations: bool,
@@ -115,7 +126,8 @@ impl LastRollupTracker {
             has_aggregations,
             block,
         )
-        .map(|kind| Mutex::new(kind))?;
+        .await
+        .map(Mutex::new)?;
         Ok(Self(rollup))
     }
 
@@ -127,7 +139,7 @@ impl LastRollupTracker {
                 *last = LastRollup::Some(block_time);
             }
             (LastRollup::Some(_) | LastRollup::Unknown, None) => {
-                constraint_violation!("block time cannot be unset");
+                internal_error!("block time cannot be unset");
             }
         }
 
@@ -166,13 +178,14 @@ impl SyncStore {
     ) -> Result<Self, StoreError> {
         let store = WritableSubgraphStore(subgraph_store.clone());
         let writable = subgraph_store.for_site(site.as_ref())?.clone();
-        let input_schema = subgraph_store.input_schema(&site.deployment)?;
+        let input_schema = subgraph_store.input_schema(&site.deployment).await?;
         let last_rollup = LastRollupTracker::new(
             writable.cheap_clone(),
             site.cheap_clone(),
             input_schema.has_aggregations(),
             block,
-        )?;
+        )
+        .await?;
 
         Ok(Self {
             logger,
@@ -184,25 +197,12 @@ impl SyncStore {
             last_rollup,
         })
     }
-
-    /// Try to send a `StoreEvent`; if sending fails, log the error but
-    /// return `Ok(())`
-    fn try_send_store_event(&self, event: StoreEvent) -> Result<(), StoreError> {
-        if !ENV_VARS.store.disable_subscription_notifications {
-            let _ = self.store.send_store_event(&event).map_err(
-                |e| error!(self.logger, "Could not send store event"; "error" => e.to_string()),
-            );
-            Ok(())
-        } else {
-            Ok(())
-        }
-    }
 }
 
 // Methods that mirror `WritableStoreTrait`
 impl SyncStore {
     async fn block_ptr(&self) -> Result<Option<BlockPtr>, StoreError> {
-        retry::forever_async(&self.logger, "block_ptr", || {
+        retry::forever(&self.logger, "block_ptr", || {
             let site = self.site.clone();
             async move { self.writable.block_ptr(site).await }
         })
@@ -210,72 +210,75 @@ impl SyncStore {
     }
 
     async fn block_cursor(&self) -> Result<FirehoseCursor, StoreError> {
-        self.writable
-            .block_cursor(self.site.cheap_clone())
-            .await
-            .map(FirehoseCursor::from)
+        self.writable.block_cursor(self.site.cheap_clone()).await
     }
 
-    fn start_subgraph_deployment(&self, logger: &Logger) -> Result<(), StoreError> {
-        retry::forever(&self.logger, "start_subgraph_deployment", || {
-            let graft_base = match self.writable.graft_pending(&self.site.deployment)? {
+    async fn start_subgraph_deployment(&self, logger: &Logger) -> Result<(), StoreError> {
+        retry::forever(&self.logger, "start_subgraph_deployment", || async {
+            let graft_base = match self.writable.graft_pending(&self.site.deployment).await? {
                 Some((base_id, base_ptr)) => {
-                    let src = self.store.layout(&base_id)?;
-                    let deployment_entity = self.store.load_deployment(src.site.clone())?;
-                    Some((src, base_ptr, deployment_entity))
+                    let src = self.store.layout(&base_id).await?;
+                    let deployment_entity = self.store.load_deployment(src.site.clone()).await?;
+                    let indexes = self.store.load_indexes(src.site.clone()).await?;
+                    Some((src, base_ptr, deployment_entity, indexes))
                 }
                 None => None,
             };
             self.writable
-                .start_subgraph(logger, self.site.clone(), graft_base)?;
-            self.store.primary_conn()?.copy_finished(self.site.as_ref())
+                .start_subgraph(logger, self.site.clone(), graft_base)
+                .await?;
+            self.store
+                .primary_conn()
+                .await?
+                .copy_finished(self.site.as_ref())
+                .await
         })
+        .await
     }
 
-    fn revert_block_operations(
+    async fn revert_block_operations(
         &self,
         block_ptr_to: BlockPtr,
         firehose_cursor: &FirehoseCursor,
     ) -> Result<(), StoreError> {
-        retry::forever(&self.logger, "revert_block_operations", || {
-            let event = self.writable.revert_block_operations(
-                self.site.clone(),
-                block_ptr_to.clone(),
-                firehose_cursor,
-            )?;
-
-            let block_time = self
-                .writable
-                .block_time(self.site.cheap_clone(), block_ptr_to.number)?;
-            self.last_rollup.set(block_time)?;
+        retry::forever(&self.logger, "revert_block_operations", || async {
+            self.writable
+                .revert_block_operations(self.site.clone(), block_ptr_to.clone(), firehose_cursor)
+                .await?;
 
-            self.try_send_store_event(event)
+            let block_time = self.writable.block_time(self.site.cheap_clone()).await?;
+            self.last_rollup.set(block_time)
         })
+        .await
     }
 
-    fn unfail_deterministic_error(
+    async fn unfail_deterministic_error(
         &self,
         current_ptr: &BlockPtr,
         parent_ptr: &BlockPtr,
     ) -> Result<UnfailOutcome, StoreError> {
-        retry::forever(&self.logger, "unfail_deterministic_error", || {
+        retry::forever(&self.logger, "unfail_deterministic_error", || async {
             self.writable
                 .unfail_deterministic_error(self.site.clone(), current_ptr, parent_ptr)
+                .await
         })
+        .await
     }
 
-    fn unfail_non_deterministic_error(
+    async fn unfail_non_deterministic_error(
         &self,
         current_ptr: &BlockPtr,
     ) -> Result<UnfailOutcome, StoreError> {
-        retry::forever(&self.logger, "unfail_non_deterministic_error", || {
+        retry::forever(&self.logger, "unfail_non_deterministic_error", || async {
             self.writable
                 .unfail_non_deterministic_error(self.site.clone(), current_ptr)
+                .await
         })
+        .await
     }
 
     async fn fail_subgraph(&self, error: SubgraphError) -> Result<(), StoreError> {
-        retry::forever_async(&self.logger, "fail_subgraph", || {
+        retry::forever(&self.logger, "fail_subgraph", || {
             let error = error.clone();
             async {
                 self.writable
@@ -287,46 +290,40 @@ impl SyncStore {
         .await
     }
 
-    async fn supports_proof_of_indexing(&self) -> Result<bool, StoreError> {
-        retry::forever_async(&self.logger, "supports_proof_of_indexing", || async {
-            self.writable
-                .supports_proof_of_indexing(self.site.clone())
-                .await
+    async fn get(&self, key: &EntityKey, block: BlockNumber) -> Result<Option<Entity>, StoreError> {
+        retry::forever(&self.logger, "get", || async {
+            self.writable.get(self.site.cheap_clone(), key, block).await
         })
         .await
     }
 
-    fn get(&self, key: &EntityKey, block: BlockNumber) -> Result<Option<Entity>, StoreError> {
-        retry::forever(&self.logger, "get", || {
-            self.writable.get(self.site.cheap_clone(), key, block)
-        })
-    }
-
-    fn transact_block_operations(
+    async fn transact_block_operations(
         &self,
         batch: &Batch,
         stopwatch: &StopwatchMetrics,
     ) -> Result<(), StoreError> {
         retry::forever(&self.logger, "transact_block_operations", move || {
-            let event = self.writable.transact_block_operations(
-                &self.logger,
-                self.site.clone(),
-                batch,
-                self.last_rollup.get(),
-                stopwatch,
-                &self.manifest_idx_and_name,
-            )?;
-            // unwrap: batch.block_times is never empty
-            let last_block_time = batch.block_times.last().unwrap().1;
-            self.last_rollup.set(Some(last_block_time))?;
-
-            let _section = stopwatch.start_section("send_store_event");
-            self.try_send_store_event(event)?;
-            Ok(())
+            async move {
+                self.writable
+                    .transact_block_operations(
+                        &self.logger,
+                        self.site.clone(),
+                        batch,
+                        self.last_rollup.get(),
+                        stopwatch,
+                        &self.manifest_idx_and_name,
+                    )
+                    .await?;
+                // unwrap: batch.block_times is never empty
+                let last_block_time = batch.block_times.last().unwrap().1;
+                self.last_rollup.set(Some(last_block_time))?;
+                Ok(())
+            }
         })
+        .await
     }
 
-    fn get_many(
+    async fn get_many(
         &self,
         keys: BTreeSet<EntityKey>,
         block: BlockNumber,
@@ -340,26 +337,30 @@ impl SyncStore {
                 .push(key.entity_id)?;
         }
 
-        retry::forever(&self.logger, "get_many", || {
+        retry::forever(&self.logger, "get_many", || async {
             self.writable
                 .get_many(self.site.cheap_clone(), &by_type, block)
+                .await
         })
+        .await
     }
 
-    fn get_derived(
+    async fn get_derived(
         &self,
         key: &DerivedEntityQuery,
         block: BlockNumber,
         excluded_keys: Vec<EntityKey>,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
-        retry::forever(&self.logger, "get_derived", || {
+        retry::forever(&self.logger, "get_derived", || async {
             self.writable
                 .get_derived(self.site.cheap_clone(), key, block, &excluded_keys)
+                .await
         })
+        .await
     }
 
     async fn is_deployment_synced(&self) -> Result<bool, StoreError> {
-        retry::forever_async(&self.logger, "is_deployment_synced", || async {
+        retry::forever(&self.logger, "is_deployment_synced", || async {
             self.writable
                 .exists_and_synced(self.site.deployment.cheap_clone())
                 .await
@@ -367,14 +368,36 @@ impl SyncStore {
         .await
     }
 
-    fn unassign_subgraph(&self, site: &Site) -> Result<(), StoreError> {
-        retry::forever(&self.logger, "unassign_subgraph", || {
-            let pconn = self.store.primary_conn()?;
-            pconn.transaction(|| -> Result<_, StoreError> {
-                let changes = pconn.unassign_subgraph(site)?;
-                self.store.send_store_event(&StoreEvent::new(changes))
-            })
+    async fn unassign_subgraph(&self, site: &Site) -> Result<(), StoreError> {
+        retry::forever(&self.logger, "unassign_subgraph", || async {
+            let mut pconn = self.store.primary_conn().await?;
+            let sender = self.store.notification_sender();
+            pconn
+                .transaction(async move |pconn| {
+                    let changes = pconn.unassign_subgraph(site).await?;
+                    pconn
+                        .send_store_event(&sender, &StoreEvent::new(changes))
+                        .await
+                })
+                .await
+        })
+        .await
+    }
+
+    async fn pause_subgraph(&self, site: &Site) -> Result<(), StoreError> {
+        retry::forever(&self.logger, "pause_subgraph", || async {
+            let mut pconn = self.store.primary_conn().await?;
+            let sender = self.store.notification_sender();
+            pconn
+                .transaction(async move |pconn| {
+                    let changes = pconn.pause_subgraph(site).await?;
+                    pconn
+                        .send_store_event(&sender, &StoreEvent::new(changes))
+                        .await
+                })
+                .await
         })
+        .await
     }
 
     async fn load_dynamic_data_sources(
@@ -382,7 +405,7 @@ impl SyncStore {
         block: BlockNumber,
         manifest_idx_and_name: Vec<(u32, String)>,
     ) -> Result<Vec<StoredDynamicDataSource>, StoreError> {
-        retry::forever_async(&self.logger, "load_dynamic_data_sources", || async {
+        retry::forever(&self.logger, "load_dynamic_data_sources", || async {
             self.writable
                 .load_dynamic_data_sources(
                     self.site.cheap_clone(),
@@ -397,7 +420,7 @@ impl SyncStore {
     pub(crate) async fn causality_region_curr_val(
         &self,
     ) -> Result<Option<CausalityRegion>, StoreError> {
-        retry::forever_async(&self.logger, "causality_region_curr_val", || async {
+        retry::forever(&self.logger, "causality_region_curr_val", || async {
             self.writable
                 .causality_region_curr_val(self.site.cheap_clone())
                 .await
@@ -405,49 +428,58 @@ impl SyncStore {
         .await
     }
 
-    fn maybe_find_site(&self, src: DeploymentId) -> Result<Option<Arc<Site>>, StoreError> {
-        match self.store.find_site(src) {
+    async fn maybe_find_site(&self, src: DeploymentId) -> Result<Option<Arc<Site>>, StoreError> {
+        match self.store.find_site(src).await {
             Ok(site) => Ok(Some(site)),
             Err(StoreError::DeploymentNotFound(_)) => Ok(None),
             Err(e) => Err(e),
         }
     }
 
-    fn deployment_synced(&self) -> Result<(), StoreError> {
-        retry::forever(&self.logger, "deployment_synced", || {
+    async fn deployment_synced(&self, block_ptr: BlockPtr) -> Result<(), StoreError> {
+        retry::forever(&self.logger, "deployment_synced", || async {
             let event = {
                 // Make sure we drop `pconn` before we call into the deployment
                 // store so that we do not hold two database connections which
                 // might come from the same pool and could therefore deadlock
-                let pconn = self.store.primary_conn()?;
-                pconn.transaction(|| -> Result<_, Error> {
-                    let changes = pconn.promote_deployment(&self.site.deployment)?;
-                    Ok(StoreEvent::new(changes))
-                })?
+                let mut pconn = self.store.primary_conn().await?;
+                let deployment = self.site.deployment.clone();
+                pconn
+                    .transaction(async move |pconn| {
+                        let changes = pconn.promote_deployment(&deployment).await?;
+                        Ok(StoreEvent::new(changes))
+                    })
+                    .await?
             };
 
             // Handle on_sync actions. They only apply to copies (not
             // grafts) so we make sure that the source, if it exists, has
             // the same hash as `self.site`
-            if let Some(src) = self.writable.source_of_copy(&self.site)? {
-                if let Some(src) = self.maybe_find_site(src)? {
-                    if src.deployment == self.site.deployment {
-                        let on_sync = self.writable.on_sync(&self.site)?;
-                        if on_sync.activate() {
-                            let pconn = self.store.primary_conn()?;
-                            pconn.activate(&self.site.as_ref().into())?;
-                        }
-                        if on_sync.replace() {
-                            self.unassign_subgraph(&src)?;
-                        }
-                    }
+            if let Some(src) = self.writable.source_of_copy(&self.site).await?
+                && let Some(src) = self.maybe_find_site(src).await?
+                && src.deployment == self.site.deployment
+            {
+                let on_sync = self.writable.on_sync(&self.site).await?;
+                if on_sync.activate() {
+                    let mut pconn = self.store.primary_conn().await?;
+                    pconn.activate(&self.site.as_ref().into()).await?;
+                }
+                if on_sync.replace() {
+                    self.unassign_subgraph(&src).await?;
                 }
             }
 
-            self.writable.deployment_synced(&self.site.deployment)?;
+            self.writable
+                .deployment_synced(&self.site.deployment, block_ptr.clone())
+                .await?;
 
-            self.store.send_store_event(&event)
+            let mut pconn = self.store.primary_conn().await?;
+            let sender = self.store.notification_sender();
+            pconn
+                .transaction(async move |pconn| pconn.send_store_event(&sender, &event).await)
+                .await
         })
+        .await
     }
 
     fn shard(&self) -> &str {
@@ -455,12 +487,18 @@ impl SyncStore {
     }
 
     async fn health(&self) -> Result<schema::SubgraphHealth, StoreError> {
-        retry::forever_async(&self.logger, "health", || async {
+        retry::forever(&self.logger, "health", || async {
             self.writable.health(&self.site).await.map(Into::into)
         })
         .await
     }
 
+    async fn create_postponed_indexes(&self) -> Result<(), StoreError> {
+        self.writable
+            .create_postponed_indexes(&self.logger, self.site.cheap_clone());
+        Ok(())
+    }
+
     fn input_schema(&self) -> InputSchema {
         self.input_schema.cheap_clone()
     }
@@ -534,7 +572,7 @@ impl BlockTracker {
         // processed.
         let res = queue.find_map(|req| match req.as_ref() {
             Request::Write { batch, .. } => {
-                let batch = batch.read().unwrap();
+                let batch = batch.read();
                 tracker.write(&batch.block_ptr);
                 if batch.first_block <= tracker.revert {
                     let res = f(batch.deref(), tracker.revert);
@@ -573,7 +611,7 @@ impl BlockTracker {
         let accum = queue.fold(init, |accum, req| {
             match req.as_ref() {
                 Request::Write { batch, .. } => {
-                    let batch = batch.read().unwrap();
+                    let batch = batch.read();
                     let mut accum = accum;
                     tracker.write(&batch.block_ptr);
                     if batch.first_block <= tracker.revert {
@@ -595,12 +633,79 @@ impl BlockTracker {
     }
 }
 
+/// A batch that is queued for writing. The read methods on the `Queue` like
+/// `get` and `get_many` need to be able to read from a batch until the
+/// database changes that the batch contains have been committed. At the
+/// same time, once the background writer starts processing a batch, it must
+/// not be modified. This enum makes it possible to do this without cloning
+/// the batch or holding a lock across an await point.
+///
+/// When a batch is first added to the queue, it can still be appended to
+/// (`Open`). Once the background writer starts processing the batch, it is
+/// closed (`Closed`) and can no longer be modified.
+///
+/// The `processed` flag in the `Request` is a shortcut to determine whether
+/// a batch can still be appended to
+enum QueuedBatch {
+    /// An open batch that can still be appended to
+    Open(Box<Batch>),
+    /// A closed batch that can no longer be modified
+    Closed(Arc<Batch>),
+    /// Temporary placeholder during state transitions. Must never be
+    /// observed outside of `QueuedBatch::close`.
+    Invalid,
+}
+
+impl Deref for QueuedBatch {
+    type Target = Batch;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            QueuedBatch::Open(batch) => batch,
+            QueuedBatch::Closed(batch) => batch.as_ref(),
+            QueuedBatch::Invalid => unreachable!("deref is never called on a QueuedBatch::Invalid"),
+        }
+    }
+}
+
+impl QueuedBatch {
+    /// Append another batch to this one. Returns an error if this batch is
+    /// closed
+    fn append(&mut self, other: Batch) -> Result<(), StoreError> {
+        match self {
+            QueuedBatch::Open(batch) => batch.append(other),
+            QueuedBatch::Closed(_) => Err(internal_error!("attempt to append to closed batch")),
+            QueuedBatch::Invalid => {
+                unreachable!("append is never called on a QueuedBatch::Invalid")
+            }
+        }
+    }
+
+    /// Close the current batch, i.e., replace it by a `Closed` batch and
+    /// return a clone of the `Arc<Batch>` that the closed batch now holds
+    fn close(&mut self) -> Arc<Batch> {
+        let old = std::mem::replace(self, QueuedBatch::Invalid);
+        *self = match old {
+            QueuedBatch::Open(batch) => QueuedBatch::Closed(Arc::new(*batch)),
+            closed @ QueuedBatch::Closed(_) => closed,
+            QueuedBatch::Invalid => unreachable!("close is never called on a QueuedBatch::Invalid"),
+        };
+        match self {
+            QueuedBatch::Closed(batch) => batch.cheap_clone(),
+            QueuedBatch::Open(_) | QueuedBatch::Invalid => {
+                unreachable!("close must have set self to Closed")
+            }
+        }
+    }
+}
+
 /// A write request received from the `WritableStore` frontend that gets
 /// queued
 ///
 /// The `processed` flag is set to true as soon as the background writer is
 /// working on that request. Once it has been set, no changes can be made to
 /// the request
+#[allow(clippy::large_enum_variant)]
 enum Request {
     Write {
         queued: Instant,
@@ -611,7 +716,12 @@ enum Request {
         // will try to read the batch. The batch only becomes truly readonly
         // when we decide to process it at which point we set `processed` to
         // `true`
-        batch: RwLock<Batch>,
+        batch: RwLock<QueuedBatch>,
+        /// True if the background writer has started processing this
+        /// request. It is guaranteed that once the batch is a
+        /// `QueuedBatch::Closed`, this flag is true. This flag serves as a
+        /// shortcut to check that without having to acquire the lock around
+        /// the batch.
         processed: AtomicBool,
     },
     RevertTo {
@@ -628,7 +738,7 @@ impl std::fmt::Debug for Request {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Write { batch, store, .. } => {
-                let batch = batch.read().unwrap();
+                let batch = batch.read();
                 write!(
                     f,
                     "write[{}, {:p}, {} entities]",
@@ -656,7 +766,7 @@ impl Request {
             queued: Instant::now(),
             store,
             stopwatch,
-            batch: RwLock::new(batch),
+            batch: RwLock::new(QueuedBatch::Open(Box::new(batch))),
             processed: AtomicBool::new(false),
         }
     }
@@ -688,7 +798,7 @@ impl Request {
         }
     }
 
-    fn execute(&self) -> Result<ExecResult, StoreError> {
+    async fn execute(&self) -> Result<ExecResult, StoreError> {
         match self {
             Request::Write {
                 batch,
@@ -698,15 +808,18 @@ impl Request {
                 processed: _,
             } => {
                 let start = Instant::now();
-                let batch = batch.read().unwrap();
+
+                let batch = batch.write().close();
+
                 if let Some(err) = &batch.error {
                     // This can happen when appending to the batch failed
-                    // because of a constraint violation. Returning an `Err`
-                    // here will poison and shut down the queue
+                    // because of an internal error. Returning an `Err` here
+                    // will poison and shut down the queue
                     return Err(err.clone());
                 }
                 let res = store
-                    .transact_block_operations(batch.deref(), stopwatch)
+                    .transact_block_operations(&batch, stopwatch)
+                    .await
                     .map(|()| ExecResult::Continue);
                 info!(store.logger, "Committed write batch";
                         "block_number" => batch.block_ptr.number,
@@ -723,6 +836,7 @@ impl Request {
                 processed: _,
             } => store
                 .revert_block_operations(block_ptr.clone(), firehose_cursor)
+                .await
                 .map(|()| ExecResult::Continue),
             Request::Stop => Ok(ExecResult::Stop),
         }
@@ -734,7 +848,7 @@ impl Request {
     fn should_process(&self) -> bool {
         match self {
             Request::Write { queued, batch, .. } => {
-                batch.read().unwrap().weight() >= ENV_VARS.store.write_batch_size
+                batch.read().weight() >= ENV_VARS.store.write_batch_size
                     || queued.elapsed() >= ENV_VARS.store.write_batch_duration
             }
             Request::RevertTo { .. } | Request::Stop => true,
@@ -873,7 +987,7 @@ impl Queue {
                 // add to it again.
                 if queue.batch_writes() && queue.queue.len() <= 1 {
                     loop {
-                        let _section = queue.stopwatch.start_section("queue_wait");
+                        let _section = queue.stopwatch.start_section("queue_idle");
                         let req = queue.queue.peek().await;
 
                         // When this is true, push_write would never add to
@@ -888,7 +1002,7 @@ impl Queue {
                         // batch should be processed or after some time
                         // passed. The latter is just for safety in case
                         // there is a mistake with notifications.
-                        let sleep = graph::tokio::time::sleep(Duration::from_secs(2));
+                        let sleep = tokio::time::sleep(ENV_VARS.store.write_batch_duration);
                         let notify = batch_stop_notify.notified();
                         select!(
                             () = sleep => (),
@@ -904,7 +1018,7 @@ impl Queue {
                 // the write transaction commits, causing them to return
                 // incorrect results.
                 let req = {
-                    let _section = queue.stopwatch.start_section("queue_wait");
+                    let _section = queue.stopwatch.start_section("queue_idle");
                     // Mark the request as being processed so push_write
                     // will not modify it again, even after we are done with
                     // it here
@@ -912,7 +1026,7 @@ impl Queue {
                 };
                 let res = {
                     let _section = queue.stopwatch.start_section("queue_execute");
-                    graph::spawn_blocking_allow_panic(move || req.execute()).await
+                    graph::spawn_blocking_allow_panic(move || graph::block_on(req.execute())).await
                 };
 
                 let _section = queue.stopwatch.start_section("queue_pop");
@@ -927,6 +1041,7 @@ impl Queue {
                         // Graceful shutdown. We also handled the request
                         // successfully
                         queue.queue.pop().await;
+                        debug!(logger, "Subgraph writer has processed a stop request");
                         return;
                     }
                     Ok(Err(e)) => {
@@ -1013,7 +1128,11 @@ impl Queue {
     /// to fill up before writing them to maximize the chances that we build
     /// a 'full' write batch, i.e., one that is either big enough or old
     /// enough
-    async fn push_write(&self, batch: Batch) -> Result<(), StoreError> {
+    async fn push_write(
+        &self,
+        batch: Batch,
+        stopwatch: &StopwatchMetrics,
+    ) -> Result<(), StoreError> {
         let batch = if ENV_VARS.store.write_batch_size == 0
             || ENV_VARS.store.write_batch_duration.is_zero()
             || !self.batch_writes()
@@ -1052,7 +1171,7 @@ impl Queue {
                             // duration of the write, and we do not want to
                             // slow down queueing requests unnecessarily
                             match existing.try_write() {
-                                Ok(mut existing) => {
+                                Some(mut existing) => {
                                     if existing.weight() < ENV_VARS.store.write_batch_size {
                                         let res = existing.append(batch).map(|()| None);
                                         if existing.weight() >= ENV_VARS.store.write_batch_size {
@@ -1063,15 +1182,12 @@ impl Queue {
                                         Ok(Some(batch))
                                     }
                                 }
-                                Err(RwLockError::WouldBlock) => {
+                                None => {
                                     // This branch can cause batches that
                                     // are not 'full' at the head of the
                                     // queue, something that start_writer
                                     // has to take into account
-                                    return Ok(Some(batch));
-                                }
-                                Err(RwLockError::Poisoned(e)) => {
-                                    panic!("rwlock on batch was poisoned {:?}", e);
+                                    Ok(Some(batch))
                                 }
                             }
                         } else {
@@ -1089,6 +1205,7 @@ impl Queue {
                 self.stopwatch.cheap_clone(),
                 batch,
             );
+            let _section = stopwatch.start_section("queue_push_blocked");
             self.push(req).await?;
         }
         Ok(())
@@ -1137,7 +1254,7 @@ impl Queue {
 
     /// Get the entity for `key` if it exists by looking at both the queue
     /// and the store
-    fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
+    async fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
         enum Op {
             Write(Entity),
             Remove,
@@ -1159,12 +1276,12 @@ impl Queue {
         match op {
             Some(Op::Write(entity)) => Ok(Some(entity)),
             Some(Op::Remove) => Ok(None),
-            None => self.store.get(key, query_block),
+            None => self.store.get(key, query_block).await,
         }
     }
 
     /// Get many entities at once by looking at both the queue and the store
-    fn get_many(
+    async fn get_many(
         &self,
         mut keys: BTreeSet<EntityKey>,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
@@ -1196,7 +1313,7 @@ impl Queue {
 
         // Look entities for the remaining keys up in the store
         keys.retain(|key| !entities_in_queue.contains_key(key));
-        let mut map = self.store.get_many(keys, query_block)?;
+        let mut map = self.store.get_many(keys, query_block).await?;
 
         // Extend the store results with the entities from the queue.
         for (key, entity) in entities_in_queue {
@@ -1209,7 +1326,7 @@ impl Queue {
         Ok(map)
     }
 
-    fn get_derived(
+    async fn get_derived(
         &self,
         derived_query: &DerivedEntityQuery,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
@@ -1245,9 +1362,7 @@ impl Queue {
                 // already existing entries in map as that would make us
                 // produce stale values
                 for (k, v) in effective_ops(batch, derived_query, at) {
-                    if !map.contains_key(&k) {
-                        map.insert(k, v);
-                    }
+                    map.entry(k).or_insert(v);
                 }
                 map
             },
@@ -1256,9 +1371,10 @@ impl Queue {
         let excluded_keys: Vec<EntityKey> = entities_in_queue.keys().cloned().collect();
 
         // We filter to exclude the entities ids that we already have from the queue
-        let mut items_from_database =
-            self.store
-                .get_derived(derived_query, query_block, excluded_keys)?;
+        let mut items_from_database = self
+            .store
+            .get_derived(derived_query, query_block, excluded_keys)
+            .await?;
 
         // Extend the store results with the entities from the queue.
         // This overwrites any entitiy from the database with the same key from queue
@@ -1319,6 +1435,11 @@ impl Queue {
         self.batch_writes.store(false, Ordering::SeqCst);
         self.batch_ready_notify.notify_one();
     }
+
+    fn start_batching(&self) {
+        self.batch_writes.store(true, Ordering::SeqCst);
+        self.batch_ready_notify.notify_one();
+    }
 }
 
 /// A shim to allow bypassing any pipelined store handling if need be
@@ -1353,7 +1474,7 @@ impl Writer {
                 // If there was an error, report that instead of a naked 'writer not running'
                 queue.check_err()?;
                 if join_handle.is_finished() {
-                    Err(constraint_violation!(
+                    Err(internal_error!(
                         "Subgraph writer for {} is not running",
                         queue.store.site
                     ))
@@ -1365,13 +1486,11 @@ impl Writer {
     }
 
     async fn write(&self, batch: Batch, stopwatch: &StopwatchMetrics) -> Result<(), StoreError> {
-        const MAX_BATCH_TIME: Duration = Duration::from_secs(30);
-
         match self {
-            Writer::Sync(store) => store.transact_block_operations(&batch, stopwatch),
+            Writer::Sync(store) => store.transact_block_operations(&batch, stopwatch).await,
             Writer::Async { queue, .. } => {
                 self.check_queue_running()?;
-                queue.push_write(batch).await
+                queue.push_write(batch, stopwatch).await
             }
         }
     }
@@ -1382,7 +1501,11 @@ impl Writer {
         firehose_cursor: FirehoseCursor,
     ) -> Result<(), StoreError> {
         match self {
-            Writer::Sync(store) => store.revert_block_operations(block_ptr_to, &firehose_cursor),
+            Writer::Sync(store) => {
+                store
+                    .revert_block_operations(block_ptr_to, &firehose_cursor)
+                    .await
+            }
             Writer::Async { queue, .. } => {
                 self.check_queue_running()?;
                 let req = Request::revert(queue.store.cheap_clone(), block_ptr_to, firehose_cursor);
@@ -1401,30 +1524,30 @@ impl Writer {
         }
     }
 
-    fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
+    async fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
         match self {
-            Writer::Sync(store) => store.get(key, BLOCK_NUMBER_MAX),
-            Writer::Async { queue, .. } => queue.get(key),
+            Writer::Sync(store) => store.get(key, BLOCK_NUMBER_MAX).await,
+            Writer::Async { queue, .. } => queue.get(key).await,
         }
     }
 
-    fn get_many(
+    async fn get_many(
         &self,
         keys: BTreeSet<EntityKey>,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         match self {
-            Writer::Sync(store) => store.get_many(keys, BLOCK_NUMBER_MAX),
-            Writer::Async { queue, .. } => queue.get_many(keys),
+            Writer::Sync(store) => store.get_many(keys, BLOCK_NUMBER_MAX).await,
+            Writer::Async { queue, .. } => queue.get_many(keys).await,
         }
     }
 
-    fn get_derived(
+    async fn get_derived(
         &self,
         key: &DerivedEntityQuery,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         match self {
-            Writer::Sync(store) => store.get_derived(key, BLOCK_NUMBER_MAX, vec![]),
-            Writer::Async { queue, .. } => queue.get_derived(key),
+            Writer::Sync(store) => store.get_derived(key, BLOCK_NUMBER_MAX, vec![]).await,
+            Writer::Async { queue, .. } => queue.get_derived(key).await,
         }
     }
 
@@ -1464,6 +1587,13 @@ impl Writer {
             Writer::Async { queue, .. } => queue.deployment_synced(),
         }
     }
+
+    fn start_batching(&self) {
+        match self {
+            Writer::Sync(_) => {}
+            Writer::Async { queue, .. } => queue.start_batching(),
+        }
+    }
 }
 
 pub struct WritableStore {
@@ -1471,6 +1601,9 @@ pub struct WritableStore {
     block_ptr: Mutex<Option<BlockPtr>>,
     block_cursor: Mutex<FirehoseCursor>,
     writer: Writer,
+
+    // Cached to avoid querying the database.
+    is_deployment_synced: AtomicBool,
 }
 
 impl WritableStore {
@@ -1504,11 +1637,14 @@ impl WritableStore {
             registry,
         );
 
+        let is_deployment_synced = store.is_deployment_synced().await?;
+
         Ok(Self {
             store,
             block_ptr,
             block_cursor,
             writer,
+            is_deployment_synced: AtomicBool::new(is_deployment_synced),
         })
     }
 
@@ -1521,23 +1657,24 @@ impl WritableStore {
     }
 }
 
+#[async_trait]
 impl ReadStore for WritableStore {
-    fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
-        self.writer.get(key)
+    async fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
+        self.writer.get(key).await
     }
 
-    fn get_many(
+    async fn get_many(
         &self,
         keys: BTreeSet<EntityKey>,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
-        self.writer.get_many(keys)
+        self.writer.get_many(keys).await
     }
 
-    fn get_derived(
+    async fn get_derived(
         &self,
         key: &DerivedEntityQuery,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
-        self.writer.get_derived(key)
+        self.writer.get_derived(key).await
     }
 
     fn input_schema(&self) -> InputSchema {
@@ -1545,6 +1682,49 @@ impl ReadStore for WritableStore {
     }
 }
 
+pub struct SourceableStore {
+    site: Arc<Site>,
+    store: Arc<DeploymentStore>,
+    input_schema: InputSchema,
+}
+
+impl SourceableStore {
+    pub fn new(site: Arc<Site>, store: Arc<DeploymentStore>, input_schema: InputSchema) -> Self {
+        Self {
+            site,
+            store,
+            input_schema,
+        }
+    }
+}
+
+#[async_trait]
+impl store::SourceableStore for SourceableStore {
+    async fn get_range(
+        &self,
+        entity_types: Vec<EntityType>,
+        causality_region: CausalityRegion,
+        block_range: Range<BlockNumber>,
+    ) -> Result<BTreeMap<BlockNumber, Vec<EntitySourceOperation>>, StoreError> {
+        self.store
+            .get_range(
+                self.site.clone(),
+                entity_types,
+                causality_region,
+                block_range,
+            )
+            .await
+    }
+
+    fn input_schema(&self) -> InputSchema {
+        self.input_schema.cheap_clone()
+    }
+
+    async fn block_ptr(&self) -> Result<Option<BlockPtr>, StoreError> {
+        self.store.block_ptr(self.site.cheap_clone()).await
+    }
+}
+
 impl DeploymentCursorTracker for WritableStore {
     fn block_ptr(&self) -> Option<BlockPtr> {
         self.block_ptr.lock().unwrap().clone()
@@ -1564,9 +1744,8 @@ impl WritableStoreTrait for WritableStore {
     async fn start_subgraph_deployment(&self, logger: &Logger) -> Result<(), StoreError> {
         let store = self.store.cheap_clone();
         let logger = logger.cheap_clone();
-        graph::spawn_blocking_allow_panic(move || store.start_subgraph_deployment(&logger))
-            .await
-            .map_err(Error::from)??;
+
+        store.start_subgraph_deployment(&logger).await?;
 
         // Refresh all in memory state in case this instance was used before
         *self.block_ptr.lock().unwrap() = self.store.block_ptr().await?;
@@ -1593,7 +1772,8 @@ impl WritableStoreTrait for WritableStore {
     ) -> Result<UnfailOutcome, StoreError> {
         let outcome = self
             .store
-            .unfail_deterministic_error(current_ptr, parent_ptr)?;
+            .unfail_deterministic_error(current_ptr, parent_ptr)
+            .await?;
 
         if let UnfailOutcome::Unfailed = outcome {
             *self.block_ptr.lock().unwrap() = self.store.block_ptr().await?;
@@ -1603,24 +1783,20 @@ impl WritableStoreTrait for WritableStore {
         Ok(outcome)
     }
 
-    fn unfail_non_deterministic_error(
+    async fn unfail_non_deterministic_error(
         &self,
         current_ptr: &BlockPtr,
     ) -> Result<UnfailOutcome, StoreError> {
         // We don't have to update in memory self.block_ptr
         // because the method call below doesn't rewind/revert
         // any block.
-        self.store.unfail_non_deterministic_error(current_ptr)
+        self.store.unfail_non_deterministic_error(current_ptr).await
     }
 
     async fn fail_subgraph(&self, error: SubgraphError) -> Result<(), StoreError> {
         self.store.fail_subgraph(error).await
     }
 
-    async fn supports_proof_of_indexing(&self) -> Result<bool, StoreError> {
-        self.store.supports_proof_of_indexing().await
-    }
-
     async fn transact_block_operations(
         &self,
         block_ptr_to: BlockPtr,
@@ -1632,7 +1808,24 @@ impl WritableStoreTrait for WritableStore {
         deterministic_errors: Vec<SubgraphError>,
         processed_data_sources: Vec<StoredDynamicDataSource>,
         is_non_fatal_errors_active: bool,
+        is_caught_up_with_chain_head: bool,
     ) -> Result<(), StoreError> {
+        if is_caught_up_with_chain_head {
+            self.deployment_synced(block_ptr_to.clone()).await?;
+        } else {
+            self.writer.start_batching();
+        }
+
+        if let Some(block_ptr) = self.block_ptr.lock().unwrap().as_ref()
+            && block_ptr_to.number <= block_ptr.number
+        {
+            return Err(internal_error!(
+                "transact_block_operations called for block {} but its head is already at {}",
+                block_ptr_to,
+                block_ptr
+            ));
+        }
+
         let batch = Batch::new(
             block_ptr_to.clone(),
             block_time,
@@ -1642,6 +1835,7 @@ impl WritableStoreTrait for WritableStore {
             deterministic_errors,
             processed_data_sources,
             is_non_fatal_errors_active,
+            self.store.logger.clone(),
         )?;
         self.writer.write(batch, stopwatch).await?;
 
@@ -1651,17 +1845,25 @@ impl WritableStoreTrait for WritableStore {
         Ok(())
     }
 
-    fn deployment_synced(&self) -> Result<(), StoreError> {
+    /// If the subgraph is caught up with the chain head, we need to:
+    /// - Disable the time-to-sync metrics gathering.
+    /// - Stop batching writes.
+    /// - Promote it to 'synced' status in the DB, if that hasn't been done already.
+    async fn deployment_synced(&self, block_ptr: BlockPtr) -> Result<(), StoreError> {
         self.writer.deployment_synced();
-        self.store.deployment_synced()
+        if !self.is_deployment_synced.load(Ordering::SeqCst) {
+            self.store.deployment_synced(block_ptr).await?;
+            self.is_deployment_synced.store(true, Ordering::SeqCst);
+        }
+        Ok(())
     }
 
-    async fn is_deployment_synced(&self) -> Result<bool, StoreError> {
-        self.store.is_deployment_synced().await
+    fn is_deployment_synced(&self) -> bool {
+        self.is_deployment_synced.load(Ordering::SeqCst)
     }
 
-    fn unassign_subgraph(&self) -> Result<(), StoreError> {
-        self.store.unassign_subgraph(&self.store.site)
+    async fn pause_subgraph(&self) -> Result<(), StoreError> {
+        self.store.pause_subgraph(&self.store.site).await
     }
 
     async fn load_dynamic_data_sources(
@@ -1687,6 +1889,10 @@ impl WritableStoreTrait for WritableStore {
         self.store.health().await
     }
 
+    async fn create_postponed_indexes(&self) -> Result<(), StoreError> {
+        self.store.create_postponed_indexes().await
+    }
+
     async fn flush(&self) -> Result<(), StoreError> {
         self.writer.flush().await
     }
@@ -1715,7 +1921,7 @@ impl WritableStoreTrait for WritableStore {
             store
                 .writable(logger, self.store.site.id.into(), manifest_idx_and_name)
                 .await
-                .map(|store| Some(store))
+                .map(Some)
         } else {
             Ok(None)
         }
diff --git a/store/test-store/Cargo.toml b/store/test-store/Cargo.toml
index a733b85e804..45027b972d3 100644
--- a/store/test-store/Cargo.toml
+++ b/store/test-store/Cargo.toml
@@ -6,19 +6,23 @@ authors = ["Leonardo Yvens <leoyvens@gmail.com>"]
 description = "Provides static store instance for tests."
 
 [dependencies]
+async-trait = { workspace = true }
 graph-graphql = { path = "../../graphql" }
-graphql-parser = "0.4.0"
-graph-core = { path = "../../core" }
 graph-node = { path = "../../node" }
 graph = { path = "../../graph" }
 graph-store-postgres = { path = "../postgres" }
 graph-chain-ethereum = { path = "../../chain/ethereum" }
-lazy_static = "1.1"
-hex-literal = "0.4"
-diesel = { version = "1.4.8", features = ["postgres", "serde_json", "numeric", "r2d2"] }
-serde = "1.0"
+lazy_static = { workspace = true }
+hex-literal = "1.1"
+diesel = { workspace = true }
+diesel-async = { workspace = true }
 prost-types = { workspace = true }
+tokio = { workspace = true }
 
 [dev-dependencies]
 hex = "0.4.3"
-pretty_assertions = "1.4.0"
+pretty_assertions = "1.4.1"
+serde_json = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/store/test-store/src/block_store.rs b/store/test-store/src/block_store.rs
index b33f256c892..70459d6b39b 100644
--- a/store/test-store/src/block_store.rs
+++ b/store/test-store/src/block_store.rs
@@ -1,19 +1,22 @@
 use std::{convert::TryFrom, str::FromStr, sync::Arc};
 
-use graph::blockchain::BlockTime;
+use graph::blockchain::{BlockTime, ChainIdentifier};
+use graph::prelude::LightEthereumBlock;
+use graph::prelude::alloy::consensus::Header as ConsensusHeader;
+use graph::prelude::alloy::primitives::{B256, Bloom, U256};
+use graph::prelude::alloy::rpc::types::{Block, Header};
 use lazy_static::lazy_static;
 
 use graph::components::store::BlockStore;
 use graph::{
     blockchain::Block as BlockchainBlock,
-    prelude::{
-        serde_json, web3::types::H256, web3::types::U256, BlockHash, BlockNumber, BlockPtr,
-        EthereumBlock, LightEthereumBlock,
-    },
+    prelude::{BlockHash, BlockNumber, BlockPtr, EthereumBlock, serde_json},
 };
-use graph_chain_ethereum::codec::{Block, BlockHeader};
+use graph_chain_ethereum::codec::{Block as FirehoseBlock, BlockHeader};
 use prost_types::Timestamp;
 
+use crate::{GENESIS_PTR, NETWORK_VERSION};
+
 lazy_static! {
     // Genesis block
     pub static ref GENESIS_BLOCK: FakeBlock = FakeBlock {
@@ -33,6 +36,11 @@ lazy_static! {
 
     pub static ref BLOCK_TWO: FakeBlock = BLOCK_ONE.make_child("f8ccbd3877eb98c958614f395dd351211afb9abba187bfc1fb4ac414b099c4a6", None);
     pub static ref BLOCK_TWO_NO_PARENT: FakeBlock = FakeBlock::make_no_parent(2, "3b652b00bff5e168b1218ff47593d516123261c4487629c4175f642ee56113fe");
+    pub static ref BLOCK_THREE_SKIPPED_2: FakeBlock = BLOCK_ONE.make_skipped_child(
+        "d8ccbd3877eb98c958614f395dd351211afb9abba187bfc1fb4ac414b099c4a6",
+        None,
+        1,
+    );
     pub static ref BLOCK_THREE: FakeBlock = BLOCK_TWO.make_child("7347afe69254df06729e123610b00b8b11f15cfae3241f9366fb113aec07489c", None);
     pub static ref BLOCK_THREE_NO_PARENT: FakeBlock = FakeBlock::make_no_parent(3, "fa9ebe3f74de4c56908b49f5c4044e85825f7350f3fa08a19151de82a82a7313");
     pub static ref BLOCK_THREE_TIMESTAMP: FakeBlock = BLOCK_TWO.make_child("6b834521bb753c132fdcf0e1034803ed9068e324112f8750ba93580b393a986b", Some(U256::from(1657712166)));
@@ -41,6 +49,8 @@ lazy_static! {
     // what you are doing, don't use this block for other tests.
     pub static ref BLOCK_THREE_NO_TIMESTAMP: FakeBlock = BLOCK_TWO.make_child("6b834521bb753c132fdcf0e1034803ed9068e324112f8750ba93580b393a986b", None);
     pub static ref BLOCK_FOUR: FakeBlock = BLOCK_THREE.make_child("7cce080f5a49c2997a6cc65fc1cee9910fd8fc3721b7010c0b5d0873e2ac785e", None);
+    pub static ref BLOCK_FOUR_SKIPPED_2_AND_3: FakeBlock = BLOCK_ONE.make_skipped_child("9cce080f5a49c2997a6cc65fc1cee9910fd8fc3721b7010c0b5d0873e2ac785e", None, 2);
+    pub static ref BLOCK_FIVE_AFTER_SKIP: FakeBlock = BLOCK_FOUR_SKIPPED_2_AND_3.make_child("8b0ea919e258eb2b119eb32de56b85d12d50ac6a9f7c5909f843d6172c8ba196", None);
     pub static ref BLOCK_FIVE: FakeBlock = BLOCK_FOUR.make_child("7b0ea919e258eb2b119eb32de56b85d12d50ac6a9f7c5909f843d6172c8ba196", None);
     pub static ref BLOCK_SIX_NO_PARENT: FakeBlock = FakeBlock::make_no_parent(6, "6b834521bb753c132fdcf0e1034803ed9068e324112f8750ba93580b393a986b");
 }
@@ -67,6 +77,15 @@ impl FakeBlock {
         }
     }
 
+    pub fn make_skipped_child(&self, hash: &str, timestamp: Option<U256>, skip: i32) -> Self {
+        FakeBlock {
+            number: self.number + 1 + skip,
+            hash: hash.to_owned(),
+            parent_hash: self.hash.clone(),
+            timestamp,
+        }
+    }
+
     pub fn make_no_parent(number: BlockNumber, hash: &str) -> Self {
         FakeBlock {
             number,
@@ -85,36 +104,48 @@ impl FakeBlock {
     }
 
     pub fn as_ethereum_block(&self) -> EthereumBlock {
-        let parent_hash = H256::from_str(self.parent_hash.as_str()).expect("invalid parent hash");
-
-        let mut block = LightEthereumBlock::default();
-        block.number = Some(self.number.into());
-        block.parent_hash = parent_hash;
-        block.hash = Some(H256(self.block_hash().as_slice().try_into().unwrap()));
-        if let Some(ts) = self.timestamp {
-            block.timestamp = ts;
-        }
+        let parent_hash = B256::from_str(self.parent_hash.as_str()).expect("invalid parent hash");
+        let block_hash = B256::from_str(self.hash.as_str()).expect("invalid block hash");
+
+        let consensus_header = ConsensusHeader {
+            number: self.number as u64,
+            parent_hash,
+            logs_bloom: Bloom::default(), // Empty bloom filter for test blocks
+            timestamp: self.timestamp.map(|ts| ts.to::<u64>()).unwrap_or_default(),
+            ..Default::default()
+        };
+
+        let rpc_header = Header {
+            hash: block_hash,
+            inner: graph::components::ethereum::AnyHeader::from(consensus_header),
+            total_difficulty: None,
+            size: None,
+        };
+
+        let block = Block::empty(rpc_header);
 
         EthereumBlock {
-            block: Arc::new(block),
+            block: Arc::new(LightEthereumBlock::new(block)),
             transaction_receipts: Vec::new(),
         }
     }
 
-    pub fn as_firehose_block(&self) -> Block {
-        let mut block = Block::default();
-        block.hash = self.hash.clone().into_bytes();
-        block.number = self.number as u64;
-
-        let mut header = BlockHeader::default();
-        header.parent_hash = self.parent_hash.clone().into_bytes();
-        header.timestamp = self.timestamp.map(|ts| Timestamp {
-            seconds: i64::from_str_radix(&ts.to_string(), 10).unwrap(),
-            nanos: 0,
-        });
-        block.header = Some(header);
+    pub fn as_firehose_block(&self) -> FirehoseBlock {
+        let header = BlockHeader {
+            parent_hash: self.parent_hash.clone().into_bytes(),
+            timestamp: self.timestamp.map(|ts| Timestamp {
+                seconds: ts.to_string().parse().unwrap(),
+                nanos: 0,
+            }),
+            ..Default::default()
+        };
 
-        block
+        FirehoseBlock {
+            hash: self.hash.clone().into_bytes(),
+            number: self.number as u64,
+            header: Some(header),
+            ..Default::default()
+        }
     }
 }
 
@@ -150,7 +181,7 @@ impl BlockchainBlock for FakeBlock {
         // can never be null and therefore impossible to test without manipulating the JSON blob directly.
         if let serde_json::Value::Object(ref mut map) = value {
             map.entry("block").and_modify(|ref mut block| {
-                if let serde_json::Value::Object(ref mut block) = block {
+                if let serde_json::Value::Object(block) = block {
                     block.remove_entry("timestamp");
                 }
             });
@@ -170,10 +201,20 @@ pub type FakeBlockList = Vec<&'static FakeBlock>;
 /// network's genesis block to `genesis_hash`, and head block to
 /// `null`
 pub async fn set_chain(chain: FakeBlockList, network: &str) -> Vec<(BlockPtr, BlockHash)> {
-    let store = crate::store::STORE
-        .block_store()
-        .chain_store(network)
-        .unwrap();
+    let block_store = crate::store::STORE.block_store();
+    let store = match block_store.chain_store(network).await {
+        Some(cs) => cs,
+        None => block_store
+            .create_chain_store(
+                network,
+                ChainIdentifier {
+                    net_version: NETWORK_VERSION.to_string(),
+                    genesis_block_hash: GENESIS_PTR.hash.clone(),
+                },
+            )
+            .await
+            .unwrap(),
+    };
     let chain: Vec<Arc<dyn BlockchainBlock>> = chain
         .iter()
         .cloned()
diff --git a/store/test-store/src/store.rs b/store/test-store/src/store.rs
index 997a09a9d2b..ba57dff430d 100644
--- a/store/test-store/src/store.rs
+++ b/store/test-store/src/store.rs
@@ -1,33 +1,36 @@
-use diesel::{self, PgConnection};
-use graph::blockchain::mock::MockDataSource;
+use diesel;
 use graph::blockchain::BlockTime;
+use graph::blockchain::ChainIdentifier;
+use graph::blockchain::mock::MockDataSource;
+use graph::components::store::{BlockStore, SeqGenerator};
 use graph::data::graphql::load_manager::LoadManager;
 use graph::data::query::QueryResults;
 use graph::data::query::QueryTarget;
-use graph::data::subgraph::schema::{DeploymentCreate, SubgraphError};
 use graph::data::subgraph::SubgraphFeature;
+use graph::data::subgraph::schema::{DeploymentCreate, SubgraphError};
 use graph::data_source::DataSource;
 use graph::log;
+use graph::prelude::alloy::primitives::B256;
 use graph::prelude::{QueryStoreManager as _, SubgraphStore as _, *};
 use graph::schema::EntityType;
 use graph::schema::InputSchema;
 use graph::semver::Version;
 use graph::{
-    blockchain::block_stream::FirehoseCursor, blockchain::ChainIdentifier,
-    components::store::DeploymentLocator, components::store::StatusStore,
-    components::store::StoredDynamicDataSource, data::subgraph::status, prelude::NodeId,
+    blockchain::block_stream::FirehoseCursor, components::store::DeploymentLocator,
+    components::store::StatusStore, components::store::StoredDynamicDataSource,
+    data::subgraph::status, prelude::NodeId,
 };
 use graph_graphql::prelude::{
-    execute_query, Query as PreparedQuery, QueryExecutionOptions, StoreResolver,
+    Query as PreparedQuery, QueryExecutionOptions, StoreResolver, execute_query,
 };
 use graph_graphql::test_support::GraphQLMetrics;
 use graph_node::config::{Config, Opt};
 use graph_node::store_builder::StoreBuilder;
-use graph_store_postgres::layout_for_tests::FAKE_NETWORK_SHARED;
-use graph_store_postgres::{connection_pool::ConnectionPool, Shard, SubscriptionManager};
+use graph_store_postgres::AsyncPgConnection;
 use graph_store_postgres::{
-    BlockStore as DieselBlockStore, DeploymentPlacer, SubgraphStore as DieselSubgraphStore,
-    PRIMARY_SHARD,
+    BlockStore as DieselBlockStore, ConnectionPool, DeploymentPlacer, PRIMARY_SHARD, Shard,
+    SubgraphStore as DieselSubgraphStore, SubscriptionManager,
+    layout_for_tests::FAKE_NETWORK_SHARED,
 };
 use hex_literal::hex;
 use lazy_static::lazy_static;
@@ -35,8 +38,6 @@ use std::collections::BTreeSet;
 use std::collections::HashMap;
 use std::time::Instant;
 use std::{marker::PhantomData, sync::Mutex};
-use tokio::runtime::{Builder, Runtime};
-use web3::types::H256;
 
 pub const NETWORK_NAME: &str = "fake_network";
 pub const DATA_SOURCE_KIND: &str = "mock/kind";
@@ -52,8 +53,6 @@ lazy_static! {
         None => Logger::root(slog::Discard, o!()),
     };
     static ref SEQ_LOCK: Mutex<()> = Mutex::new(());
-    pub static ref STORE_RUNTIME: Runtime =
-        Builder::new_multi_thread().enable_all().build().unwrap();
     pub static ref METRICS_REGISTRY: Arc<MetricsRegistry> = Arc::new(MetricsRegistry::mock());
     pub static ref LOAD_MANAGER: Arc<LoadManager> = Arc::new(LoadManager::new(
         &LOGGER,
@@ -63,22 +62,28 @@ lazy_static! {
     ));
     static ref STORE_POOL_CONFIG: (Arc<Store>, ConnectionPool, Config, Arc<SubscriptionManager>) =
         build_store();
-    pub(crate) static ref PRIMARY_POOL: ConnectionPool = STORE_POOL_CONFIG.1.clone();
+    pub static ref PRIMARY_POOL: ConnectionPool = STORE_POOL_CONFIG.1.clone();
     pub static ref STORE: Arc<Store> = STORE_POOL_CONFIG.0.clone();
     static ref CONFIG: Config = STORE_POOL_CONFIG.2.clone();
-    pub static ref SUBSCRIPTION_MANAGER: Arc<SubscriptionManager> = STORE_POOL_CONFIG.3.clone();
     pub static ref NODE_ID: NodeId = NodeId::new("test").unwrap();
     pub static ref SUBGRAPH_STORE: Arc<DieselSubgraphStore> = STORE.subgraph_store();
-    static ref BLOCK_STORE: Arc<DieselBlockStore> = STORE.block_store();
+    static ref BLOCK_STORE: DieselBlockStore = STORE.block_store();
+    pub static ref STOPWATCH: StopwatchMetrics = StopwatchMetrics::new(
+        Logger::root(slog::Discard, o!()),
+        DeploymentHash::new("test").unwrap(),
+        "test",
+        METRICS_REGISTRY.clone(),
+        "dummy".to_string(),
+    );
     pub static ref GENESIS_PTR: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "bd34884280958002c51d3f7b5f853e6febeba33de0f40d15b0363006533c924f"
         )),
         0u64
     )
         .into();
     pub static ref BLOCK_ONE: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "8511fa04b64657581e3f00e14543c1d522d5d7e771b54aa3060b662ade47da13"
         )),
         1u64
@@ -86,14 +91,15 @@ lazy_static! {
         .into();
     pub static ref BLOCKS: [BlockPtr; 4] = {
         let two: BlockPtr = (
-            H256::from(hex!(
+            B256::from(hex!(
                 "b98fb783b49de5652097a989414c767824dff7e7fd765a63b493772511db81c1"
             )),
             2u64,
         )
             .into();
+
         let three: BlockPtr = (
-            H256::from(hex!(
+            B256::from(hex!(
                 "977c084229c72a0fa377cae304eda9099b6a2cb5d83b25cdf0f0969b69874255"
             )),
             3u64,
@@ -118,16 +124,17 @@ where
         Err(err) => err.into_inner(),
     };
 
-    STORE_RUNTIME.handle().block_on(async {
+    graph::TEST_RUNTIME.handle().block_on(async {
         let store = STORE.clone();
         test(store).await
     })
 }
 
 /// Run a test with a connection into the primary database, not a full store
-pub fn run_test_with_conn<F>(test: F)
+#[allow(clippy::await_holding_lock)]
+pub async fn run_test_with_conn<F>(test: F)
 where
-    F: FnOnce(&PgConnection),
+    F: AsyncFnOnce(&mut AsyncPgConnection),
 {
     // Lock regardless of poisoning. This also forces sequential test execution.
     let _lock = match SEQ_LOCK.lock() {
@@ -135,16 +142,19 @@ where
         Err(err) => err.into_inner(),
     };
 
-    let conn = PRIMARY_POOL
+    let mut conn = PRIMARY_POOL
         .get()
+        .await
         .expect("failed to get connection for primary database");
 
-    test(&conn);
+    test(&mut conn).await;
 }
 
-pub fn remove_subgraphs() {
+/// Removes test data from the database behind the store.
+pub async fn remove_subgraphs() {
     SUBGRAPH_STORE
-        .delete_all_entities_for_test_use_only()
+        .remove_all_subgraphs_for_test_use_only()
+        .await
         .expect("deleting test entities succeeds");
 }
 
@@ -161,7 +171,7 @@ pub async fn create_subgraph(
 
     let manifest = SubgraphManifest::<graph::blockchain::mock::MockBlockchain> {
         id: subgraph_id.clone(),
-        spec_version: Version::new(1, 0, 0),
+        spec_version: Version::new(1, 3, 0),
         features: BTreeSet::new(),
         description: Some(format!("manifest for {}", subgraph_id)),
         repository: Some(format!("repo for {}", subgraph_id)),
@@ -187,14 +197,16 @@ pub async fn create_subgraph_with_manifest(
     let yaml = serde_yaml::to_string(&yaml).unwrap();
     let deployment = DeploymentCreate::new(yaml, &manifest, None).graft(base);
     let name = SubgraphName::new_unchecked(subgraph_id.to_string());
-    let deployment = SUBGRAPH_STORE.create_deployment_replace(
-        name,
-        &schema,
-        deployment,
-        NODE_ID.clone(),
-        NETWORK_NAME.to_string(),
-        SubgraphVersionSwitchingMode::Instant,
-    )?;
+    let deployment = SUBGRAPH_STORE
+        .create_deployment_replace(
+            name,
+            &schema,
+            deployment,
+            NODE_ID.clone(),
+            NETWORK_NAME.to_string(),
+            SubgraphVersionSwitchingMode::Instant,
+        )
+        .await?;
 
     SUBGRAPH_STORE
         .cheap_clone()
@@ -225,8 +237,8 @@ pub async fn create_test_subgraph_with_features(
 
     let manifest = SubgraphManifest::<graph::blockchain::mock::MockBlockchain> {
         id: subgraph_id.clone(),
-        spec_version: Version::new(1, 0, 0),
-        features: features,
+        spec_version: Version::new(1, 3, 0),
+        features,
         description: Some(format!("manifest for {}", subgraph_id)),
         repository: Some(format!("repo for {}", subgraph_id)),
         schema: schema.clone(),
@@ -249,20 +261,21 @@ pub async fn create_test_subgraph_with_features(
 
     SUBGRAPH_STORE
         .create_subgraph_features(deployment_features)
+        .await
         .unwrap();
 
     locator
 }
 
-pub fn remove_subgraph(id: &DeploymentHash) {
+pub async fn remove_subgraph(id: &DeploymentHash) {
     let name = SubgraphName::new_unchecked(id.to_string());
-    SUBGRAPH_STORE.remove_subgraph(name).unwrap();
-    let locs = SUBGRAPH_STORE.locators(id.as_str()).unwrap();
-    let conn = primary_connection();
+    SUBGRAPH_STORE.remove_subgraph(name).await.unwrap();
+    let locs = SUBGRAPH_STORE.locators(id.as_str()).await.unwrap();
+    let mut conn = primary_connection().await;
     for loc in locs {
-        let site = conn.locate_site(loc.clone()).unwrap().unwrap();
-        conn.unassign_subgraph(&site).unwrap();
-        SUBGRAPH_STORE.remove_deployment(site.id).unwrap();
+        let site = conn.locate_site(loc.clone()).await.unwrap().unwrap();
+        conn.unassign_subgraph(&site).await.unwrap();
+        SUBGRAPH_STORE.remove_deployment(site.id).await.unwrap();
     }
 }
 
@@ -282,7 +295,7 @@ pub async fn transact_errors(
         deployment.hash.clone(),
         "transact",
         metrics_registry.clone(),
-        store.subgraph_store().shard(deployment)?.to_string(),
+        store.subgraph_store().shard(deployment).await?.to_string(),
     );
     let block_time = BlockTime::for_test(&block_ptr_to);
     store
@@ -299,6 +312,7 @@ pub async fn transact_errors(
             errs,
             Vec::new(),
             is_non_fatal_errors_active,
+            false,
         )
         .await?;
     flush(deployment).await
@@ -349,18 +363,12 @@ pub async fn transact_entities_and_dynamic_data_sources(
     ops: Vec<EntityOperation>,
     manifest_idx_and_name: Vec<(u32, String)>,
 ) -> Result<(), StoreError> {
-    let store = futures03::executor::block_on(store.cheap_clone().writable(
+    let store = graph::futures03::executor::block_on(store.cheap_clone().writable(
         LOGGER.clone(),
         deployment.id,
         Arc::new(manifest_idx_and_name),
     ))?;
 
-    let mut entity_cache = EntityCache::new(Arc::new(store.clone()));
-    entity_cache.append(ops);
-    let mods = entity_cache
-        .as_modifications(block_ptr_to.number)
-        .expect("failed to convert to modifications")
-        .modifications;
     let metrics_registry = Arc::new(MetricsRegistry::mock());
     let stopwatch_metrics = StopwatchMetrics::new(
         Logger::root(slog::Discard, o!()),
@@ -369,6 +377,17 @@ pub async fn transact_entities_and_dynamic_data_sources(
         metrics_registry.clone(),
         store.shard().to_string(),
     );
+
+    let mut entity_cache = EntityCache::new(
+        Arc::new(store.clone()),
+        SeqGenerator::new(block_ptr_to.number),
+    );
+    entity_cache.append(ops);
+    let mods = entity_cache
+        .as_modifications(block_ptr_to.number, &stopwatch_metrics)
+        .await
+        .expect("failed to convert to modifications")
+        .modifications;
     let block_time = BlockTime::for_test(&block_ptr_to);
     store
         .transact_block_operations(
@@ -381,6 +400,7 @@ pub async fn transact_entities_and_dynamic_data_sources(
             Vec::new(),
             Vec::new(),
             false,
+            false,
         )
         .await
 }
@@ -398,17 +418,19 @@ pub async fn revert_block(store: &Arc<Store>, deployment: &DeploymentLocator, pt
     flush(deployment).await.unwrap();
 }
 
-pub fn insert_ens_name(hash: &str, name: &str) {
+pub async fn insert_ens_name(hash: &str, name: &str) {
+    use diesel::ExpressionMethods;
     use diesel::insert_into;
-    use diesel::prelude::*;
+    use diesel_async::RunQueryDsl;
     use graph_store_postgres::command_support::catalog::ens_names;
 
-    let conn = PRIMARY_POOL.get().unwrap();
+    let mut conn = PRIMARY_POOL.get().await.unwrap();
 
     insert_into(ens_names::table)
         .values((ens_names::hash.eq(hash), ens_names::name.eq(name)))
         .on_conflict_do_nothing()
-        .execute(&conn)
+        .execute(&mut conn)
+        .await
         .unwrap();
 }
 
@@ -418,12 +440,13 @@ pub async fn insert_entities(
     deployment: &DeploymentLocator,
     entities: Vec<(EntityType, Entity)>,
 ) -> Result<(), StoreError> {
-    let insert_ops = entities
-        .into_iter()
-        .map(|(entity_type, data)| EntityOperation::Set {
+    let insert_ops = entities.into_iter().map(|(entity_type, mut data)| {
+        data.set_vid_if_empty();
+        EntityOperation::Set {
             key: entity_type.key(data.id()),
             data,
-        });
+        }
+    });
 
     transact_entity_operations(
         &SUBGRAPH_STORE,
@@ -452,15 +475,15 @@ pub async fn flush(deployment: &DeploymentLocator) -> Result<(), StoreError> {
 /// requires. Of course, this does not test that events that are sent are
 /// actually received by anything, but makes ensuring that the right events
 /// get sent much more convenient than trying to receive them
-pub fn tap_store_events<F, R>(f: F) -> (R, Vec<StoreEvent>)
+pub async fn tap_store_events<F, R>(f: F) -> (R, Vec<StoreEvent>)
 where
-    F: FnOnce() -> R,
+    F: AsyncFnOnce() -> R,
 {
     use graph_store_postgres::layout_for_tests::{EVENT_TAP, EVENT_TAP_ENABLED};
 
     EVENT_TAP.lock().unwrap().clear();
     *EVENT_TAP_ENABLED.lock().unwrap() = true;
-    let res = f();
+    let res = f().await;
     *EVENT_TAP_ENABLED.lock().unwrap() = false;
     (res, EVENT_TAP.lock().unwrap().clone())
 }
@@ -505,11 +528,15 @@ async fn execute_subgraph_query_internal(
         QueryTarget::Deployment(id, version) => (id, version),
         _ => unreachable!("tests do not use this"),
     };
-    let schema = SUBGRAPH_STORE.api_schema(&id, &Default::default()).unwrap();
+    let schema = SUBGRAPH_STORE
+        .api_schema(&id, &Default::default())
+        .await
+        .unwrap();
     let status = StatusStore::status(
         STORE.as_ref(),
         status::Filter::Deployments(vec![id.to_string()]),
     )
+    .await
     .unwrap();
     let network = Some(status[0].chains[0].network.clone());
     let trace = query.trace;
@@ -522,55 +549,56 @@ async fn execute_subgraph_query_internal(
         100,
         graphql_metrics(),
     ));
-    let mut result = QueryResults::empty();
+    let mut result = QueryResults::empty(query.root_trace(trace), None);
     let deployment = query.schema.id().clone();
     let store = STORE
         .clone()
-        .query_store(QueryTarget::Deployment(deployment, version.clone()), false)
+        .query_store(QueryTarget::Deployment(deployment, version.clone()))
         .await
         .unwrap();
     let state = store.deployment_state().await.unwrap();
-    for (bc, (selection_set, error_policy)) in return_err!(query.block_constraint()) {
+    let by_block_constraint =
+        return_err!(StoreResolver::locate_blocks(store.as_ref(), &state, &query).await);
+    for (ptr, (selection_set, error_policy)) in by_block_constraint {
         let logger = logger.clone();
         let resolver = return_err!(
             StoreResolver::at_block(
                 &logger,
                 store.clone(),
                 &state,
-                SUBSCRIPTION_MANAGER.clone(),
-                bc,
+                ptr,
                 error_policy,
                 query.schema.id().clone(),
                 graphql_metrics(),
-                LOAD_MANAGER.clone()
+                LOAD_MANAGER.clone(),
             )
             .await
         );
-        result.append(
-            execute_query(
-                query.clone(),
-                Some(selection_set),
-                None,
-                QueryExecutionOptions {
-                    resolver,
-                    deadline,
-                    max_first: std::u32::MAX,
-                    max_skip: std::u32::MAX,
-                    trace,
-                },
-            )
-            .await,
+        let (res, status) = execute_query(
+            query.clone(),
+            Some(selection_set),
+            None,
+            QueryExecutionOptions {
+                resolver,
+                deadline,
+                max_first: u32::MAX,
+                max_skip: u32::MAX,
+                trace,
+                log_store: std::sync::Arc::new(graph::components::log_store::NoOpLogStore),
+            },
         )
+        .await;
+        result.append(res, status);
     }
     result
 }
 
 pub async fn deployment_state(store: &Store, subgraph_id: &DeploymentHash) -> DeploymentState {
     store
-        .query_store(
-            QueryTarget::Deployment(subgraph_id.clone(), Default::default()),
-            false,
-        )
+        .query_store(QueryTarget::Deployment(
+            subgraph_id.clone(),
+            Default::default(),
+        ))
         .await
         .expect("could get a query store")
         .deployment_state()
@@ -592,20 +620,25 @@ pub fn all_shards() -> Vec<Shard> {
 }
 
 fn build_store() -> (Arc<Store>, ConnectionPool, Config, Arc<SubscriptionManager>) {
+    graph::tls::install_default_crypto_provider();
     let mut opt = Opt::default();
-    let url = std::env::var_os("THEGRAPH_STORE_POSTGRES_DIESEL_URL").filter(|s| s.len() > 0);
-    let file = std::env::var_os("GRAPH_NODE_TEST_CONFIG").filter(|s| s.len() > 0);
+    let url = std::env::var_os("THEGRAPH_STORE_POSTGRES_DIESEL_URL").filter(|s| !s.is_empty());
+    let file = std::env::var_os("GRAPH_NODE_TEST_CONFIG").filter(|s| !s.is_empty());
     if let Some(file) = file {
         let file = file.into_string().unwrap();
         opt.config = Some(file);
         if url.is_some() {
-            eprintln!("WARNING: ignoring THEGRAPH_STORE_POSTGRES_DIESEL_URL because GRAPH_NODE_TEST_CONFIG is set");
+            eprintln!(
+                "WARNING: ignoring THEGRAPH_STORE_POSTGRES_DIESEL_URL because GRAPH_NODE_TEST_CONFIG is set"
+            );
         }
     } else if let Some(url) = url {
         let url = url.into_string().unwrap();
         opt.postgres_url = Some(url);
     } else {
-        panic!("You must set either THEGRAPH_STORE_POSTGRES_DIESEL_URL or GRAPH_NODE_TEST_CONFIG (see ./CONTRIBUTING.md).");
+        panic!(
+            "You must set either THEGRAPH_STORE_POSTGRES_DIESEL_URL or GRAPH_NODE_TEST_CONFIG (see ./CONTRIBUTING.md)."
+        );
     }
     opt.store_connection_pool_size = CONN_POOL_SIZE;
 
@@ -613,7 +646,7 @@ fn build_store() -> (Arc<Store>, ConnectionPool, Config, Arc<SubscriptionManager
         .unwrap_or_else(|_| panic!("config is not valid (file={:?})", &opt.config));
     let registry = Arc::new(MetricsRegistry::mock());
     std::thread::spawn(move || {
-        STORE_RUNTIME.handle().block_on(async {
+        graph::TEST_RUNTIME.handle().block_on(async {
             let builder = StoreBuilder::new(&LOGGER, &NODE_ID, &config, None, registry).await;
             let subscription_manager = builder.subscription_manager();
             let primary_pool = builder.primary_pool();
@@ -623,27 +656,42 @@ fn build_store() -> (Arc<Store>, ConnectionPool, Config, Arc<SubscriptionManager
                 genesis_block_hash: GENESIS_PTR.hash.clone(),
             };
 
-            (
-                builder.network_store(
+            let store = builder
+                .network_store(
                     vec![
-                        (NETWORK_NAME.to_string(), ident.clone()),
-                        (FAKE_NETWORK_SHARED.to_string(), ident),
+                        (NETWORK_NAME.to_string()),
+                        (FAKE_NETWORK_SHARED.to_string()),
                     ]
                     .into_iter()
                     .collect(),
-                ),
-                primary_pool,
-                config,
-                subscription_manager,
-            )
+                )
+                .await;
+            match store.block_store().chain_store(NETWORK_NAME).await {
+                Some(cs) => {
+                    cs.set_chain_identifier_for_tests(&ChainIdentifier {
+                        net_version: NETWORK_VERSION.to_string(),
+                        genesis_block_hash: GENESIS_PTR.hash.clone(),
+                    })
+                    .await
+                    .expect("unable to set identifier");
+                }
+                None => {
+                    store
+                        .block_store()
+                        .create_chain_store(NETWORK_NAME, ident)
+                        .await
+                        .expect("unable to create test network store");
+                }
+            }
+            (store, primary_pool, config, subscription_manager)
         })
     })
     .join()
     .unwrap()
 }
 
-pub fn primary_connection() -> graph_store_postgres::layout_for_tests::Connection<'static> {
-    let conn = PRIMARY_POOL.get().unwrap();
+pub async fn primary_connection() -> graph_store_postgres::layout_for_tests::Connection {
+    let conn = PRIMARY_POOL.get_permitted().await.unwrap();
     graph_store_postgres::layout_for_tests::Connection::new(conn)
 }
 
diff --git a/store/test-store/tests/chain/ethereum/manifest.rs b/store/test-store/tests/chain/ethereum/manifest.rs
index 2aca9d5f759..b58540679ce 100644
--- a/store/test-store/tests/chain/ethereum/manifest.rs
+++ b/store/test-store/tests/chain/ethereum/manifest.rs
@@ -4,26 +4,30 @@ use std::str::FromStr;
 use std::sync::Arc;
 use std::time::Duration;
 
+use async_trait::async_trait;
+use graph::amp;
 use graph::blockchain::DataSource;
 use graph::components::store::BLOCK_NUMBER_MAX;
-use graph::data::store::scalar::Bytes;
 use graph::data::store::Value;
+use graph::data::store::scalar::Bytes;
 use graph::data::subgraph::schema::SubgraphError;
 use graph::data::subgraph::{
-    Prune, SPEC_VERSION_0_0_4, SPEC_VERSION_0_0_7, SPEC_VERSION_0_0_8, SPEC_VERSION_0_0_9,
-    SPEC_VERSION_1_0_0,
+    LATEST_VERSION, Prune, SPEC_VERSION_0_0_4, SPEC_VERSION_0_0_7, SPEC_VERSION_0_0_8,
+    SPEC_VERSION_0_0_9, SPEC_VERSION_1_0_0, SPEC_VERSION_1_2_0, SPEC_VERSION_1_3_0,
 };
 use graph::data_source::offchain::OffchainDataSourceKind;
-use graph::data_source::DataSourceTemplate;
+use graph::data_source::{DataSourceEnum, DataSourceTemplate};
 use graph::entity;
 use graph::env::ENV_VARS;
+use graph::prelude::alloy::primitives::B256;
 use graph::prelude::{
-    anyhow, async_trait, serde_yaml, tokio, BigDecimal, BigInt, DeploymentHash, Link, Logger,
-    SubgraphManifest, SubgraphManifestValidationError, SubgraphStore, UnvalidatedSubgraphManifest,
+    BigDecimal, BigInt, DeploymentHash, Link, SubgraphManifest, SubgraphManifestResolveError,
+    SubgraphManifestValidationError, SubgraphStore, UnvalidatedSubgraphManifest, anyhow,
+    serde_yaml,
 };
 use graph::{
     blockchain::NodeCapabilities as _,
-    components::link_resolver::{JsonValueStream, LinkResolver as LinkResolverTrait},
+    components::link_resolver::{JsonValueStream, LinkResolver, LinkResolverContext},
     data::subgraph::SubgraphFeature,
 };
 
@@ -36,6 +40,33 @@ const GQL_SCHEMA: &str = r#"
   type TestEntity @entity { id: ID! }
 "#;
 const GQL_SCHEMA_FULLTEXT: &str = include_str!("full-text.graphql");
+const SOURCE_SUBGRAPH_MANIFEST: &str = "
+dataSources: []
+schema:
+  file:
+    /: /ipfs/QmSourceSchema
+specVersion: 1.3.0
+";
+
+const SOURCE_SUBGRAPH_SCHEMA: &str = "
+type TestEntity @entity(immutable: true) { id: ID! }
+type MutableEntity @entity { id: ID! }
+type User @entity(immutable: true) { id: ID! }
+type Profile @entity(immutable: true) { id: ID! }
+
+type TokenData @entity(timeseries: true) {
+    id: Int8!
+    timestamp: Timestamp!
+    amount: BigDecimal!
+}
+
+type TokenStats @aggregation(intervals: [\"hour\", \"day\"], source: \"TokenData\") {
+    id: Int8!
+    timestamp: Timestamp!
+    totalAmount: BigDecimal! @aggregate(fn: \"sum\", arg: \"amount\")
+}
+";
+
 const MAPPING_WITH_IPFS_FUNC_WASM: &[u8] = include_bytes!("ipfs-on-ethereum-contracts.wasm");
 const ABI: &str = "[{\"type\":\"function\", \"inputs\": [{\"name\": \"i\",\"type\": \"uint256\"}],\"name\":\"get\",\"outputs\": [{\"type\": \"address\",\"name\": \"o\"}]}]";
 const FILE: &str = "{}";
@@ -53,39 +84,47 @@ impl TextResolver {
 }
 
 #[async_trait]
-impl LinkResolverTrait for TextResolver {
-    fn with_timeout(&self, _timeout: Duration) -> Box<dyn LinkResolverTrait> {
+impl LinkResolver for TextResolver {
+    fn with_timeout(&self, _timeout: Duration) -> Box<dyn LinkResolver> {
         Box::new(self.clone())
     }
 
-    fn with_retries(&self) -> Box<dyn LinkResolverTrait> {
+    fn with_retries(&self) -> Box<dyn LinkResolver> {
         Box::new(self.clone())
     }
 
-    async fn cat(&self, _logger: &Logger, link: &Link) -> Result<Vec<u8>, anyhow::Error> {
+    fn for_manifest(&self, _manifest_path: &str) -> Result<Box<dyn LinkResolver>, anyhow::Error> {
+        Ok(Box::new(self.clone()))
+    }
+
+    async fn cat(&self, _ctx: &LinkResolverContext, link: &Link) -> Result<Vec<u8>, anyhow::Error> {
         self.texts
             .get(&link.link)
             .ok_or(anyhow!("No text for {}", &link.link))
-            .map(Clone::clone)
+            .cloned()
     }
 
-    async fn get_block(&self, _logger: &Logger, _link: &Link) -> Result<Vec<u8>, anyhow::Error> {
+    async fn get_block(
+        &self,
+        _ctx: &LinkResolverContext,
+        _link: &Link,
+    ) -> Result<Vec<u8>, anyhow::Error> {
         unimplemented!()
     }
 
     async fn json_stream(
         &self,
-        _logger: &Logger,
+        _ctx: &LinkResolverContext,
         _link: &Link,
     ) -> Result<JsonValueStream, anyhow::Error> {
         unimplemented!()
     }
 }
 
-async fn resolve_manifest(
+async fn try_resolve_manifest(
     text: &str,
     max_spec_version: Version,
-) -> SubgraphManifest<graph_chain_ethereum::Chain> {
+) -> Result<SubgraphManifest<graph_chain_ethereum::Chain>, anyhow::Error> {
     let mut resolver = TextResolver::default();
     let id = DeploymentHash::new("Qmmanifest").unwrap();
 
@@ -93,12 +132,30 @@ async fn resolve_manifest(
     resolver.add("/ipfs/Qmschema", &GQL_SCHEMA);
     resolver.add("/ipfs/Qmabi", &ABI);
     resolver.add("/ipfs/Qmmapping", &MAPPING_WITH_IPFS_FUNC_WASM);
+    resolver.add("/ipfs/QmSource", &SOURCE_SUBGRAPH_MANIFEST);
+    resolver.add("/ipfs/QmSource2", &SOURCE_SUBGRAPH_MANIFEST);
+    resolver.add("/ipfs/QmSourceSchema", &SOURCE_SUBGRAPH_SCHEMA);
     resolver.add(FILE_CID, &FILE);
 
-    let resolver: Arc<dyn LinkResolverTrait> = Arc::new(resolver);
+    let resolver: Arc<dyn LinkResolver> = Arc::new(resolver);
+
+    let raw = serde_yaml::from_str(text)?;
+    Ok(SubgraphManifest::resolve_from_raw(
+        id,
+        raw,
+        &resolver,
+        Option::<Arc<amp::FlightClient>>::None,
+        &LOGGER,
+        max_spec_version,
+    )
+    .await?)
+}
 
-    let raw = serde_yaml::from_str(text).unwrap();
-    SubgraphManifest::resolve_from_raw(id, raw, &resolver, &LOGGER, max_spec_version)
+async fn resolve_manifest(
+    text: &str,
+    max_spec_version: Version,
+) -> SubgraphManifest<graph_chain_ethereum::Chain> {
+    try_resolve_manifest(text, max_spec_version)
         .await
         .expect("Parsing simple manifest works")
 }
@@ -110,18 +167,25 @@ async fn resolve_unvalidated(text: &str) -> UnvalidatedSubgraphManifest<Chain> {
     resolver.add(id.as_str(), &text);
     resolver.add("/ipfs/Qmschema", &GQL_SCHEMA);
 
-    let resolver: Arc<dyn LinkResolverTrait> = Arc::new(resolver);
+    let resolver: Arc<dyn LinkResolver> = Arc::new(resolver);
 
     let raw = serde_yaml::from_str(text).unwrap();
-    UnvalidatedSubgraphManifest::resolve(id, raw, &resolver, &LOGGER, SPEC_VERSION_0_0_4.clone())
-        .await
-        .expect("Parsing simple manifest works")
+    UnvalidatedSubgraphManifest::resolve(
+        id,
+        raw,
+        &resolver,
+        Option::<Arc<amp::FlightClient>>::None,
+        &LOGGER,
+        SPEC_VERSION_0_0_4.clone(),
+    )
+    .await
+    .expect("Parsing simple manifest works")
 }
 
 // Some of these manifest tests should be made chain-independent, but for
 // now we just run them for the ethereum `Chain`
 
-#[tokio::test]
+#[graph::test]
 async fn simple_manifest() {
     const YAML: &str = "
 dataSources: []
@@ -137,7 +201,7 @@ specVersion: 0.0.2
     assert!(manifest.graft.is_none());
 }
 
-#[tokio::test]
+#[graph::test]
 async fn ipfs_manifest() {
     let yaml = "
 schema:
@@ -165,11 +229,164 @@ specVersion: 0.0.7
     let data_source = match &manifest.templates[0] {
         DataSourceTemplate::Offchain(ds) => ds,
         DataSourceTemplate::Onchain(_) => unreachable!(),
+        DataSourceTemplate::Subgraph(_) => unreachable!(),
     };
     assert_eq!(data_source.kind, OffchainDataSourceKind::Ipfs);
 }
 
-#[tokio::test]
+#[graph::test]
+async fn subgraph_ds_manifest() {
+    let yaml = "
+schema:
+  file:
+    /: /ipfs/Qmschema
+dataSources:
+  - name: SubgraphSource
+    kind: subgraph
+    entities:
+        - Gravatar
+    network: mainnet
+    source:
+      address: 'QmSource'
+      startBlock: 9562480
+    mapping:
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity
+      file:
+        /: /ipfs/Qmmapping
+      handlers:
+        - handler: handleEntity
+          entity: TestEntity
+specVersion: 1.3.0
+";
+
+    let manifest = resolve_manifest(yaml, SPEC_VERSION_1_3_0).await;
+
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+    assert_eq!(manifest.data_sources.len(), 1);
+    let data_source = &manifest.data_sources[0];
+    match data_source {
+        DataSourceEnum::Subgraph(ds) => {
+            assert_eq!(ds.name, "SubgraphSource");
+            assert_eq!(ds.kind, "subgraph");
+            assert_eq!(ds.source.start_block, 9562480);
+        }
+        _ => panic!("Expected a subgraph data source"),
+    }
+}
+
+#[graph::test]
+async fn subgraph_ds_manifest_aggregations_should_fail() {
+    let yaml = "
+schema:
+  file:
+    /: /ipfs/Qmschema
+dataSources:
+  - name: SubgraphSource
+    kind: subgraph
+    entities:
+        - Gravatar
+    network: mainnet
+    source:
+      address: 'QmSource'
+      startBlock: 9562480
+    mapping:
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity
+      file:
+        /: /ipfs/Qmmapping
+      handlers:
+        - handler: handleEntity
+          entity: TokenStats # This is an aggregation and should fail
+specVersion: 1.3.0
+";
+
+    let result = try_resolve_manifest(yaml, SPEC_VERSION_1_3_0).await;
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(
+        err.to_string()
+            .contains("Entity TokenStats is an aggregation and cannot be used as a mapping entity")
+    );
+}
+
+#[graph::test]
+async fn multiple_subgraph_ds_manifest() {
+    let yaml = "
+schema:
+  file:
+    /: /ipfs/Qmschema
+dataSources:
+  - name: SubgraphSource1
+    kind: subgraph
+    entities:
+        - Gravatar
+    network: mainnet
+    source:
+      address: 'QmSource'
+      startBlock: 9562480
+    mapping:
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity
+      file:
+        /: /ipfs/Qmmapping
+      handlers:
+        - handler: handleEntity
+          entity: User
+  - name: SubgraphSource2
+    kind: subgraph
+    entities:
+        - Profile
+    network: mainnet
+    source:
+      address: 'QmSource2'
+      startBlock: 9562500
+    mapping:
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity2
+      file:
+        /: /ipfs/Qmmapping
+      handlers:
+        - handler: handleProfile
+          entity: Profile
+specVersion: 1.3.0
+";
+
+    let manifest = resolve_manifest(yaml, SPEC_VERSION_1_3_0).await;
+
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+    assert_eq!(manifest.data_sources.len(), 2);
+
+    // Validate first data source
+    match &manifest.data_sources[0] {
+        DataSourceEnum::Subgraph(ds) => {
+            assert_eq!(ds.name, "SubgraphSource1");
+            assert_eq!(ds.kind, "subgraph");
+            assert_eq!(ds.source.start_block, 9562480);
+        }
+        _ => panic!("Expected a subgraph data source"),
+    }
+
+    // Validate second data source
+    match &manifest.data_sources[1] {
+        DataSourceEnum::Subgraph(ds) => {
+            assert_eq!(ds.name, "SubgraphSource2");
+            assert_eq!(ds.kind, "subgraph");
+            assert_eq!(ds.source.start_block, 9562500);
+        }
+        _ => panic!("Expected a subgraph data source"),
+    }
+}
+
+#[graph::test]
 async fn graft_manifest() {
     const YAML: &str = "
 dataSources: []
@@ -190,7 +407,7 @@ specVersion: 0.0.2
     assert_eq!(12345, graft.block);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn parse_indexer_hints() {
     const YAML: &str = "
 dataSources: []
@@ -268,6 +485,7 @@ specVersion: 0.0.2
         let schema = store
             .subgraph_store()
             .input_schema(&deployment.hash)
+            .await
             .unwrap();
 
         // Adds an example entity.
@@ -352,6 +570,7 @@ specVersion: 0.0.2
         let schema = store
             .subgraph_store()
             .input_schema(&deployment.hash)
+            .await
             .unwrap();
         // This check is awkward since the test manifest has other problems
         // that the validation complains about as setting up a valid manifest
@@ -440,7 +659,7 @@ specVersion: 0.0.2
     })
 }
 
-#[tokio::test]
+#[graph::test]
 async fn parse_data_source_context() {
     const YAML: &str = "
 dataSources:
@@ -550,7 +769,78 @@ specVersion: 0.0.8
     );
 }
 
-#[tokio::test]
+#[graph::test]
+async fn parse_event_handlers_with_topics() {
+    const YAML: &str = "
+dataSources:
+  - kind: ethereum/contract
+    name: Factory
+    network: mainnet
+    source:
+      abi: Factory
+      startBlock: 9562480
+      endBlock: 9562481
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.4
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity
+      file:
+        /: /ipfs/Qmmapping
+      abis:
+        - name: Factory
+          file:
+            /: /ipfs/Qmabi
+      eventHandlers:
+        - event: Test(address,string)
+          handler: handleTest
+          topic1: [\"0x0000000000000000000000000000000000000000000000000000000000000000\", \"0x0000000000000000000000000000000000000000000000000000000000000001\", \"0x0000000000000000000000000000000000000000000000000000000000000002\" ]
+          topic2: [\"0x0000000000000000000000000000000000000000000000000000000000000001\"]
+          topic3: [\"0x0000000000000000000000000000000000000000000000000000000000000002\"]
+schema:
+  file:
+    /: /ipfs/Qmschema
+specVersion: 1.2.0
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_1_2_0).await;
+    // Check if end block is parsed correctly
+    let data_source = manifest.data_sources.first().unwrap();
+    let topic1 = &data_source.as_onchain().unwrap().mapping.event_handlers[0].topic1;
+    let topic2 = &data_source.as_onchain().unwrap().mapping.event_handlers[0].topic2;
+    let topic3 = &data_source.as_onchain().unwrap().mapping.event_handlers[0].topic3;
+
+    assert_eq!(
+        Some(vec![
+            B256::from_str("0000000000000000000000000000000000000000000000000000000000000000")
+                .unwrap(),
+            B256::from_str("0000000000000000000000000000000000000000000000000000000000000001")
+                .unwrap(),
+            B256::from_str("0000000000000000000000000000000000000000000000000000000000000002")
+                .unwrap()
+        ]),
+        topic1.clone()
+    );
+
+    assert_eq!(
+        Some(vec![
+            B256::from_str("0000000000000000000000000000000000000000000000000000000000000001")
+                .unwrap()
+        ]),
+        topic2.clone()
+    );
+
+    assert_eq!(
+        Some(vec![
+            B256::from_str("0000000000000000000000000000000000000000000000000000000000000002")
+                .unwrap()
+        ]),
+        topic3.clone()
+    );
+}
+
+#[graph::test]
 async fn parse_block_handlers_with_polling_filter() {
     const YAML: &str = "
 dataSources:
@@ -591,8 +881,8 @@ specVersion: 0.0.8
         .filter_map(|ds| ds.as_onchain().cloned())
         .collect::<Vec<_>>();
 
-    let data_source = onchain_data_sources.get(0).unwrap();
-    let validation_errors = data_source.validate();
+    let data_source = onchain_data_sources.first().unwrap();
+    let validation_errors = data_source.validate(LATEST_VERSION);
     let filter = data_source.mapping.block_handlers[0].filter.clone();
 
     assert_eq!(0, validation_errors.len());
@@ -606,7 +896,7 @@ specVersion: 0.0.8
     assert_eq!("Qmmanifest", manifest.id.as_str());
 }
 
-#[tokio::test]
+#[graph::test]
 async fn parse_data_source_with_end_block() {
     const YAML: &str = "
 dataSources:
@@ -643,7 +933,7 @@ specVersion: 0.0.9
     assert_eq!(Some(9562481), end_block);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn parse_block_handlers_with_both_polling_and_once_filter() {
     const YAML: &str = "
 dataSources:
@@ -687,8 +977,8 @@ specVersion: 0.0.8
         .filter_map(|ds| ds.as_onchain().cloned())
         .collect::<Vec<_>>();
 
-    let data_source = onchain_data_sources.get(0).unwrap();
-    let validation_errors = data_source.validate();
+    let data_source = onchain_data_sources.first().unwrap();
+    let validation_errors = data_source.validate(LATEST_VERSION);
     let filters = data_source
         .mapping
         .block_handlers
@@ -710,7 +1000,7 @@ specVersion: 0.0.8
     assert_eq!("Qmmanifest", manifest.id.as_str());
 }
 
-#[tokio::test]
+#[graph::test]
 async fn should_not_parse_block_handlers_with_both_filtered_and_non_filtered_handlers() {
     const YAML: &str = "
 dataSources:
@@ -752,8 +1042,8 @@ specVersion: 0.0.8
         .filter_map(|ds| ds.as_onchain().cloned())
         .collect::<Vec<_>>();
 
-    let data_source = onchain_data_sources.get(0).unwrap();
-    let validation_errors = data_source.validate();
+    let data_source = onchain_data_sources.first().unwrap();
+    let validation_errors = data_source.validate(LATEST_VERSION);
     let filters = data_source
         .mapping
         .block_handlers
@@ -775,7 +1065,7 @@ specVersion: 0.0.8
     assert_eq!("Qmmanifest", manifest.id.as_str());
 }
 
-#[tokio::test]
+#[graph::test]
 async fn parse_block_handlers_with_call_filter() {
     const YAML: &str = "
 dataSources:
@@ -814,16 +1104,16 @@ specVersion: 0.0.2
         .filter_map(|ds| ds.as_onchain().cloned())
         .collect::<Vec<_>>();
 
-    let data_source = onchain_data_sources.get(0).unwrap();
+    let data_source = onchain_data_sources.first().unwrap();
     let filter = data_source.mapping.block_handlers[0].filter.clone();
     let required_capabilities = NodeCapabilities::from_data_sources(&onchain_data_sources);
 
     assert_eq!(BlockHandlerFilter::Call, filter.unwrap());
-    assert_eq!(true, required_capabilities.traces);
+    assert!(required_capabilities.traces);
     assert_eq!("Qmmanifest", manifest.id.as_str());
 }
 
-#[tokio::test]
+#[graph::test]
 async fn parse_block_handlers_with_once_filter() {
     const YAML: &str = "
 dataSources:
@@ -862,16 +1152,16 @@ specVersion: 0.0.8
         .filter_map(|ds| ds.as_onchain().cloned())
         .collect::<Vec<_>>();
 
-    let data_source = onchain_data_sources.get(0).unwrap();
+    let data_source = onchain_data_sources.first().unwrap();
     let filter = data_source.mapping.block_handlers[0].filter.clone();
     let required_capabilities = NodeCapabilities::from_data_sources(&onchain_data_sources);
 
     assert_eq!(BlockHandlerFilter::Once, filter.unwrap());
-    assert_eq!(false, required_capabilities.traces);
+    assert!(!required_capabilities.traces);
     assert_eq!("Qmmanifest", manifest.id.as_str());
 }
 
-#[tokio::test]
+#[graph::test]
 async fn parse_call_handlers() {
     const YAML: &str = "
 dataSources:
@@ -911,7 +1201,7 @@ specVersion: 0.0.2
     let required_capabilities = NodeCapabilities::from_data_sources(&onchain_data_sources);
 
     assert_eq!("Qmmanifest", manifest.id.as_str());
-    assert_eq!(true, required_capabilities.traces);
+    assert!(required_capabilities.traces);
 }
 
 #[test]
@@ -949,6 +1239,23 @@ graft:
     })
 }
 
+async fn has_feature_validation_error(
+    unvalidated: UnvalidatedSubgraphManifest<Chain>,
+    store: Arc<graph_store_postgres::SubgraphStore>,
+) -> bool {
+    unvalidated
+        .validate(store, true)
+        .await
+        .expect_err("Validation must fail")
+        .into_iter()
+        .any(|e| {
+            matches!(
+                e,
+                SubgraphManifestValidationError::FeatureValidationError(_)
+            )
+        })
+}
+
 #[test]
 fn declared_grafting_feature_causes_no_feature_validation_errors() {
     const YAML: &str = "
@@ -966,18 +1273,8 @@ graft:
     test_store::run_test_sequentially(|store| async move {
         let store = store.subgraph_store();
         let unvalidated = resolve_unvalidated(YAML).await;
-        assert!(unvalidated
-            .validate(store.clone(), true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| {
-                matches!(
-                    e,
-                    SubgraphManifestValidationError::FeatureValidationError(_)
-                )
-            })
-            .is_none());
+        let has_error = has_feature_validation_error(unvalidated, store).await;
+        assert!(!has_error, "There must be no FeatureValidationError");
         let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
         assert!(manifest.features.contains(&SubgraphFeature::Grafting))
     })
@@ -997,18 +1294,8 @@ schema:
     test_store::run_test_sequentially(|store| async move {
         let store = store.subgraph_store();
         let unvalidated = resolve_unvalidated(YAML).await;
-        assert!(unvalidated
-            .validate(store.clone(), true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| {
-                matches!(
-                    e,
-                    SubgraphManifestValidationError::FeatureValidationError(_)
-                )
-            })
-            .is_none());
+        let has_error = has_feature_validation_error(unvalidated, store).await;
+        assert!(!has_error, "There must be no FeatureValidationError");
 
         let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
         assert!(manifest.features.contains(&SubgraphFeature::NonFatalErrors))
@@ -1036,13 +1323,14 @@ schema:
             resolver.add("/ipfs/Qmabi", &ABI);
             resolver.add("/ipfs/Qmschema", &GQL_SCHEMA_FULLTEXT);
 
-            let resolver: Arc<dyn LinkResolverTrait> = Arc::new(resolver);
+            let resolver: Arc<dyn LinkResolver> = Arc::new(resolver);
 
             let raw = serde_yaml::from_str(YAML).unwrap();
             UnvalidatedSubgraphManifest::resolve(
                 id,
                 raw,
                 &resolver,
+                Option::<Arc<amp::FlightClient>>::None,
                 &LOGGER,
                 SPEC_VERSION_0_0_4.clone(),
             )
@@ -1050,18 +1338,8 @@ schema:
             .expect("Parsing simple manifest works")
         };
 
-        assert!(unvalidated
-            .validate(store.clone(), true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| {
-                matches!(
-                    e,
-                    SubgraphManifestValidationError::FeatureValidationError(_)
-                )
-            })
-            .is_none());
+        let has_error = has_feature_validation_error(unvalidated, store).await;
+        assert!(!has_error, "There must be no FeatureValidationError");
 
         let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
         assert!(manifest.features.contains(&SubgraphFeature::FullTextSearch))
@@ -1088,13 +1366,14 @@ schema:
             resolver.add("/ipfs/Qmabi", &ABI);
             resolver.add("/ipfs/Qmschema", &GQL_SCHEMA_FULLTEXT);
 
-            let resolver: Arc<dyn LinkResolverTrait> = Arc::new(resolver);
+            let resolver: Arc<dyn LinkResolver> = Arc::new(resolver);
 
             let raw = serde_yaml::from_str(YAML).unwrap();
             UnvalidatedSubgraphManifest::resolve(
                 id,
                 raw,
                 &resolver,
+                Option::<Arc<amp::FlightClient>>::None,
                 &LOGGER,
                 SPEC_VERSION_0_0_4.clone(),
             )
@@ -1164,13 +1443,14 @@ dataSources:
             resolver.add("/ipfs/Qmschema", &GQL_SCHEMA);
             resolver.add("/ipfs/Qmmapping", &MAPPING_WITH_IPFS_FUNC_WASM);
 
-            let resolver: Arc<dyn LinkResolverTrait> = Arc::new(resolver);
+            let resolver: Arc<dyn LinkResolver> = Arc::new(resolver);
 
             let raw = serde_yaml::from_str(YAML).unwrap();
             UnvalidatedSubgraphManifest::resolve(
                 id,
                 raw,
                 &resolver,
+                Option::<Arc<amp::FlightClient>>::None,
                 &LOGGER,
                 SPEC_VERSION_0_0_4.clone(),
             )
@@ -1242,13 +1522,14 @@ dataSources:
             resolver.add("/ipfs/Qmschema", &GQL_SCHEMA);
             resolver.add("/ipfs/Qmmapping", &MAPPING_WITH_IPFS_FUNC_WASM);
 
-            let resolver: Arc<dyn LinkResolverTrait> = Arc::new(resolver);
+            let resolver: Arc<dyn LinkResolver> = Arc::new(resolver);
 
             let raw = serde_yaml::from_str(YAML).unwrap();
             UnvalidatedSubgraphManifest::resolve(
                 id,
                 raw,
                 &resolver,
+                Option::<Arc<amp::FlightClient>>::None,
                 &LOGGER,
                 SPEC_VERSION_0_0_4.clone(),
             )
@@ -1256,18 +1537,8 @@ dataSources:
             .expect("Parsing simple manifest works")
         };
 
-        assert!(unvalidated
-            .validate(store.clone(), true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| {
-                matches!(
-                    e,
-                    SubgraphManifestValidationError::FeatureValidationError(_)
-                )
-            })
-            .is_none());
+        let has_error = has_feature_validation_error(unvalidated, store).await;
+        assert!(!has_error, "There must be no FeatureValidationError");
     });
 }
 
@@ -1285,20 +1556,384 @@ schema:
     test_store::run_test_sequentially(|store| async move {
         let store = store.subgraph_store();
         let unvalidated = resolve_unvalidated(YAML).await;
-        assert!(unvalidated
-            .validate(store.clone(), true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| {
-                matches!(
-                    e,
-                    SubgraphManifestValidationError::FeatureValidationError(_)
-                )
-            })
-            .is_none());
+        let has_error = has_feature_validation_error(unvalidated, store).await;
+        assert!(!has_error, "There must be no FeatureValidationError");
 
         let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
         assert!(manifest.features.contains(&SubgraphFeature::NonFatalErrors))
     });
 }
+
+#[test]
+fn parses_eth_call_decls() {
+    const YAML: &str = "
+specVersion: 1.2.0
+schema:
+  file:
+    /: /ipfs/Qmschema
+features:
+  - ipfsOnEthereumContracts
+dataSources:
+  - kind: ethereum/contract
+    name: Factory
+    network: mainnet
+    source:
+      abi: Factory
+      startBlock: 9562480
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.4
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity
+      file:
+        /: /ipfs/Qmmapping
+      abis:
+        - name: Factory
+          file:
+            /: /ipfs/Qmabi
+      eventHandlers:
+        - event: Created(address)
+          handler: handleGet
+          calls:
+            fake1: Factory[event.address].get(event.params.address)
+            fake2: Factory[event.params.address].get(event.params.address)
+            fake3: Factory[0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF].get(event.address)
+            fake4: Factory[0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF].get(0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF)
+";
+
+    test_store::run_test_sequentially(|store| async move {
+        let store = store.subgraph_store();
+        let unvalidated: UnvalidatedSubgraphManifest<Chain> = {
+            let mut resolver = TextResolver::default();
+            let id = DeploymentHash::new("Qmmanifest").unwrap();
+            resolver.add(id.as_str(), &YAML);
+            resolver.add("/ipfs/Qmabi", &ABI);
+            resolver.add("/ipfs/Qmschema", &GQL_SCHEMA);
+            resolver.add("/ipfs/Qmmapping", &MAPPING_WITH_IPFS_FUNC_WASM);
+
+            let resolver: Arc<dyn LinkResolver> = Arc::new(resolver);
+
+            let raw = serde_yaml::from_str(YAML).unwrap();
+            UnvalidatedSubgraphManifest::resolve(
+                id,
+                raw,
+                &resolver,
+                Option::<Arc<amp::FlightClient>>::None,
+                &LOGGER,
+                SPEC_VERSION_1_2_0.clone(),
+            )
+            .await
+            .expect("Parsing simple manifest works")
+        };
+
+        let manifest = unvalidated.validate(store.clone(), true).await.unwrap();
+        let ds = &manifest.data_sources[0].as_onchain().unwrap();
+        // For more detailed tests of parsing CallDecls see the data_soure
+        // module in chain/ethereum
+        let decls = &ds.mapping.event_handlers[0].calls.decls;
+        assert_eq!(4, decls.len());
+    });
+}
+
+#[test]
+fn parses_eth_call_decls_for_subgraph_datasource() {
+    const YAML: &str = "
+specVersion: 1.3.0
+schema:
+  file:
+    /: /ipfs/Qmschema
+features:
+  - ipfsOnEthereumContracts
+dataSources:
+  - kind: subgraph
+    name: Factory
+    entities:
+        - Gravatar
+    network: mainnet
+    source:
+      address: 'QmSource'
+      startBlock: 9562480
+    mapping:
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity
+      file:
+        /: /ipfs/Qmmapping
+      abis:
+        - name: Factory
+          file:
+            /: /ipfs/Qmabi
+      handlers:
+        - handler: handleEntity
+          entity: User
+          calls:
+            fake1: Factory[entity.address].get(entity.user)
+            fake3: Factory[0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF].get(entity.address)
+            fake4: Factory[0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF].get(0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF)
+";
+
+    test_store::run_test_sequentially(|store| async move {
+        let store = store.subgraph_store();
+        let unvalidated: UnvalidatedSubgraphManifest<Chain> = {
+            let mut resolver = TextResolver::default();
+            let id = DeploymentHash::new("Qmmanifest").unwrap();
+            resolver.add(id.as_str(), &YAML);
+            resolver.add("/ipfs/Qmabi", &ABI);
+            resolver.add("/ipfs/Qmschema", &GQL_SCHEMA);
+            resolver.add("/ipfs/Qmmapping", &MAPPING_WITH_IPFS_FUNC_WASM);
+            resolver.add("/ipfs/QmSource", &SOURCE_SUBGRAPH_MANIFEST);
+            resolver.add("/ipfs/QmSourceSchema", &SOURCE_SUBGRAPH_SCHEMA);
+
+            let resolver: Arc<dyn LinkResolver> = Arc::new(resolver);
+
+            let raw = serde_yaml::from_str(YAML).unwrap();
+            UnvalidatedSubgraphManifest::resolve(
+                id,
+                raw,
+                &resolver,
+                Option::<Arc<amp::FlightClient>>::None,
+                &LOGGER,
+                SPEC_VERSION_1_3_0.clone(),
+            )
+            .await
+            .expect("Parsing simple manifest works")
+        };
+
+        let manifest = unvalidated.validate(store.clone(), true).await.unwrap();
+        let ds = &manifest.data_sources[0].as_subgraph().unwrap();
+        // For more detailed tests of parsing CallDecls see the data_soure
+        // module in chain/ethereum
+        let decls = &ds.mapping.handlers[0].calls.decls;
+        assert_eq!(3, decls.len());
+    });
+}
+
+#[graph::test]
+async fn mixed_subgraph_and_onchain_ds_manifest_should_fail() {
+    let yaml = "
+schema:
+  file:
+    /: /ipfs/Qmschema
+dataSources:
+  - name: SubgraphSource
+    kind: subgraph
+    entities:
+        - User
+    network: mainnet
+    source:
+      address: 'QmSource'
+      startBlock: 9562480
+    mapping:
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity
+      file:
+        /: /ipfs/Qmmapping
+      handlers:
+        - handler: handleEntity
+          entity: User
+  - kind: ethereum/contract
+    name: Gravity
+    network: mainnet
+    source:
+      address: '0x2E645469f354BB4F5c8a05B3b30A929361cf77eC'
+      abi: Gravity
+      startBlock: 1
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - Gravatar
+      abis:
+        - name: Gravity
+          file:
+            /: /ipfs/Qmabi
+      file:
+        /: /ipfs/Qmmapping
+      handlers:
+        - event: NewGravatar(uint256,address,string,string)
+          handler: handleNewGravatar
+specVersion: 1.3.0
+";
+
+    let result = try_resolve_manifest(yaml, SPEC_VERSION_1_3_0).await;
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    println!("Error: {}", err);
+    assert!(
+        err.to_string()
+            .contains("Subgraph datasources cannot be used alongside onchain datasources")
+    );
+}
+
+#[test]
+fn nested_subgraph_ds_manifest_should_fail() {
+    let yaml = r#"
+schema:
+  file:
+    /: /ipfs/Qmschema
+dataSources:
+- name: SubgraphSource
+  kind: subgraph
+  entities:
+      - User
+  network: mainnet
+  source:
+    address: 'QmNestedSource'
+    startBlock: 9562480
+  mapping:
+    apiVersion: 0.0.6
+    language: wasm/assemblyscript
+    entities:
+      - TestEntity
+    file:
+      /: /ipfs/Qmmapping
+    handlers:
+      - handler: handleEntity
+        entity: User
+specVersion: 1.3.0
+"#;
+
+    // First modify SOURCE_SUBGRAPH_MANIFEST to include a subgraph datasource
+    const NESTED_SOURCE_MANIFEST: &str = r#"
+schema:
+  file:
+    /: /ipfs/QmSourceSchema
+dataSources:
+- kind: subgraph
+  name: NestedSource
+  network: mainnet
+  entities:
+      - User
+  source:
+    address: 'QmSource'
+    startBlock: 1
+  mapping:
+    apiVersion: 0.0.6
+    language: wasm/assemblyscript
+    entities:
+      - User
+    file:
+      /: /ipfs/Qmmapping
+    handlers:
+      - handler: handleNested
+        entity: User
+specVersion: 1.3.0
+"#;
+
+    let mut resolver = TextResolver::default();
+    let id = DeploymentHash::new("Qmmanifest").unwrap();
+
+    resolver.add(id.as_str(), &yaml);
+    resolver.add("/ipfs/Qmabi", &ABI);
+    resolver.add("/ipfs/Qmschema", &GQL_SCHEMA);
+    resolver.add("/ipfs/Qmmapping", &MAPPING_WITH_IPFS_FUNC_WASM);
+    resolver.add("/ipfs/QmNestedSource", &NESTED_SOURCE_MANIFEST);
+    resolver.add("/ipfs/QmSource", &SOURCE_SUBGRAPH_MANIFEST);
+    resolver.add("/ipfs/QmSourceSchema", &SOURCE_SUBGRAPH_SCHEMA);
+
+    let resolver: Arc<dyn LinkResolver> = Arc::new(resolver);
+
+    let raw = serde_yaml::from_str(yaml).unwrap();
+    test_store::run_test_sequentially(|_| async move {
+        let result: Result<UnvalidatedSubgraphManifest<Chain>, _> =
+            UnvalidatedSubgraphManifest::resolve(
+                id,
+                raw,
+                &resolver,
+                Option::<Arc<amp::FlightClient>>::None,
+                &LOGGER,
+                SPEC_VERSION_1_3_0.clone(),
+            )
+            .await;
+
+        match result {
+            Ok(_) => panic!("Expected resolution to fail"),
+            Err(e) => {
+                assert!(matches!(e, SubgraphManifestResolveError::ResolveError(_)));
+                let error_msg = e.to_string();
+                println!("{}", error_msg);
+                assert!(
+                    error_msg.contains(
+                        "Nested subgraph data sources [SubgraphSource] are not supported."
+                    )
+                );
+            }
+        }
+    })
+}
+
+#[graph::test]
+async fn subgraph_ds_manifest_mutable_entities_should_fail() {
+    let yaml = "
+schema:
+  file:
+    /: /ipfs/Qmschema
+dataSources:
+  - name: SubgraphSource
+    kind: subgraph
+    entities:
+        - Gravatar
+    network: mainnet
+    source:
+      address: 'QmSource'
+      startBlock: 9562480
+    mapping:
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity
+      file:
+        /: /ipfs/Qmmapping
+      handlers:
+        - handler: handleEntity
+          entity: MutableEntity # This is a mutable entity and should fail
+specVersion: 1.3.0
+";
+
+    let result = try_resolve_manifest(yaml, SPEC_VERSION_1_3_0).await;
+    assert!(result.is_err());
+    let err = result.unwrap_err();
+    assert!(
+        err.to_string().contains(
+            "Entity MutableEntity is not immutable and cannot be used as a mapping entity"
+        )
+    );
+}
+
+#[graph::test]
+async fn subgraph_ds_manifest_immutable_entities_should_succeed() {
+    let yaml = "
+schema:
+  file:
+    /: /ipfs/Qmschema
+dataSources:
+  - name: SubgraphSource
+    kind: subgraph
+    entities:
+        - Gravatar
+    network: mainnet
+    source:
+      address: 'QmSource'
+      startBlock: 9562480
+    mapping:
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity
+      file:
+        /: /ipfs/Qmmapping
+      handlers:
+        - handler: handleEntity
+          entity: User # This is an immutable entity and should succeed
+specVersion: 1.3.0
+";
+
+    let result = try_resolve_manifest(yaml, SPEC_VERSION_1_3_0).await;
+
+    assert!(result.is_ok());
+}
diff --git a/store/test-store/tests/core/interfaces.rs b/store/test-store/tests/core/interfaces.rs
index 418b0b9a632..6451b173501 100644
--- a/store/test-store/tests/core/interfaces.rs
+++ b/store/test-store/tests/core/interfaces.rs
@@ -25,7 +25,7 @@ async fn insert_and_query(
 
     insert_entities(&deployment, entities).await?;
 
-    let document = graphql_parser::parse_query(query).unwrap().into_static();
+    let document = q::parse_query(query).unwrap().into_static();
     let target = QueryTarget::Deployment(subgraph_id, Default::default());
     let query = Query::new(document, None, false);
     Ok(execute_subgraph_query(query, target)
@@ -45,7 +45,7 @@ macro_rules! extract_data {
     };
 }
 
-#[tokio::test]
+#[graph::test]
 async fn one_interface_zero_entities() {
     let subgraph_id = "oneInterfaceZeroEntities";
     let schema = "interface Legged { legs: Int }
@@ -62,7 +62,7 @@ async fn one_interface_zero_entities() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn one_interface_one_entity() {
     let subgraph_id = "oneInterfaceOneEntity";
     let document = "interface Legged { legs: Int }
@@ -90,7 +90,7 @@ async fn one_interface_one_entity() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn one_interface_one_entity_typename() {
     let subgraph_id = "oneInterfaceOneEntityTypename";
     let document = "interface Legged { legs: Int }
@@ -109,7 +109,7 @@ async fn one_interface_one_entity_typename() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn one_interface_multiple_entities() {
     let subgraph_id = "oneInterfaceMultipleEntities";
     let document = "interface Legged { legs: Int }
@@ -140,7 +140,7 @@ async fn one_interface_multiple_entities() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn reference_interface() {
     let subgraph_id = "ReferenceInterface";
     let document = "type Leg @entity { id: ID! }
@@ -162,7 +162,7 @@ async fn reference_interface() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn reference_interface_derived() {
     // Test the different ways in which interface implementations
     // can reference another entity
@@ -201,9 +201,9 @@ async fn reference_interface_derived() {
 
     let query = "query { events { id transaction { id } } }";
 
-    let buy = ("BuyEvent", entity! { schema => id: "buy" });
-    let sell1 = ("SellEvent", entity! { schema => id: "sell1" });
-    let sell2 = ("SellEvent", entity! { schema => id: "sell2" });
+    let buy = ("BuyEvent", entity! { schema => id: "buy", vid: 0i64 });
+    let sell1 = ("SellEvent", entity! { schema => id: "sell1", vid: 1i64 });
+    let sell2 = ("SellEvent", entity! { schema => id: "sell2", vid: 2i64 });
     let gift = (
         "GiftEvent",
         entity! { schema => id: "gift", transaction: "txn" },
@@ -230,7 +230,7 @@ async fn reference_interface_derived() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn follow_interface_reference_invalid() {
     let subgraph_id = "FollowInterfaceReferenceInvalid";
     let schema = "interface Legged { legs: Int! }
@@ -263,7 +263,7 @@ async fn follow_interface_reference_invalid() {
     }
 }
 
-#[tokio::test]
+#[graph::test]
 async fn follow_interface_reference() {
     let subgraph_id = "FollowInterfaceReference";
     let document = "interface Legged { id: ID!, legs: Int! }
@@ -278,11 +278,11 @@ async fn follow_interface_reference() {
 
     let parent = (
         "Animal",
-        entity! { schema => id: "parent", legs: 4, parent: Value::Null },
+        entity! { schema => id: "parent", legs: 4, parent: Value::Null, vid: 0i64},
     );
     let child = (
         "Animal",
-        entity! { schema => id: "child", legs: 3, parent: "parent" },
+        entity! { schema => id: "child", legs: 3, parent: "parent" , vid: 1i64},
     );
 
     let res = insert_and_query(subgraph_id, document, vec![parent, child], query)
@@ -296,7 +296,7 @@ async fn follow_interface_reference() {
     assert_eq!(data, exp)
 }
 
-#[tokio::test]
+#[graph::test]
 async fn conflicting_implementors_id() {
     let subgraph_id = "ConflictingImplementorsId";
     let document = "interface Legged { legs: Int }
@@ -315,17 +315,15 @@ async fn conflicting_implementors_id() {
     let msg = res.unwrap_err().to_string();
     // We don't know in which order the two entities get inserted; the two
     // error messages only differ in who gets inserted first
-    const EXPECTED1: &str =
-        "tried to set entity of type `Furniture` with ID \"1\" but an entity of type `Animal`, \
+    const EXPECTED1: &str = "tried to set entity of type `Furniture` with ID \"1\" but an entity of type `Animal`, \
          which has an interface in common with `Furniture`, exists with the same ID";
-    const EXPECTED2: &str =
-        "tried to set entity of type `Animal` with ID \"1\" but an entity of type `Furniture`, \
+    const EXPECTED2: &str = "tried to set entity of type `Animal` with ID \"1\" but an entity of type `Furniture`, \
          which has an interface in common with `Animal`, exists with the same ID";
 
     assert!(msg == EXPECTED1 || msg == EXPECTED2);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn derived_interface_relationship() {
     let subgraph_id = "DerivedInterfaceRelationship";
     let document = "interface ForestDweller { id: ID!, forest: Forest }
@@ -349,7 +347,7 @@ async fn derived_interface_relationship() {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn two_interfaces() {
     let subgraph_id = "TwoInterfaces";
     let document = "interface IFoo { foo: String! }
@@ -381,7 +379,7 @@ async fn two_interfaces() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn interface_non_inline_fragment() {
     let subgraph_id = "interfaceNonInlineFragment";
     let document = "interface Legged { legs: Int }
@@ -412,7 +410,7 @@ async fn interface_non_inline_fragment() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn interface_inline_fragment() {
     let subgraph_id = "interfaceInlineFragment";
     let document = "interface Legged { legs: Int }
@@ -436,7 +434,7 @@ async fn interface_inline_fragment() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn interface_inline_fragment_with_subquery() {
     let subgraph_id = "InterfaceInlineFragmentWithSubquery";
     let document = "
@@ -459,16 +457,16 @@ async fn interface_inline_fragment_with_subquery() {
     ";
     let schema = InputSchema::raw(document, subgraph_id);
 
-    let mama_cow = ("Parent", entity! { schema =>  id: "mama_cow" });
+    let mama_cow = ("Parent", entity! { schema =>  id: "mama_cow", vid: 0i64 });
     let cow = (
         "Animal",
-        entity! { schema =>  id: "1", name: "cow", legs: 4, parent: "mama_cow" },
+        entity! { schema =>  id: "1", name: "cow", legs: 4, parent: "mama_cow", vid: 0i64 },
     );
 
-    let mama_bird = ("Parent", entity! { schema =>  id: "mama_bird" });
+    let mama_bird = ("Parent", entity! { schema =>  id: "mama_bird", vid: 1i64 });
     let bird = (
         "Bird",
-        entity! { schema =>  id: "2", airspeed: 5, legs: 2, parent: "mama_bird" },
+        entity! { schema =>  id: "2", airspeed: 5, legs: 2, parent: "mama_bird", vid: 1i64 },
     );
 
     let query = "query { leggeds(orderBy: legs) { legs ... on Bird { airspeed parent { id } } } }";
@@ -488,7 +486,7 @@ async fn interface_inline_fragment_with_subquery() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn invalid_fragment() {
     let subgraph_id = "InvalidFragment";
     let schema = "interface Legged { legs: Int! }
@@ -520,7 +518,7 @@ async fn invalid_fragment() {
     }
 }
 
-#[tokio::test]
+#[graph::test]
 async fn alias() {
     let subgraph_id = "Alias";
     let document = "interface Legged { id: ID!, legs: Int! }
@@ -545,11 +543,11 @@ async fn alias() {
 
     let parent = (
         "Animal",
-        entity! { schema =>  id: "parent", legs: 4, parent: Value::Null },
+        entity! { schema =>  id: "parent", legs: 4, parent: Value::Null, vid: 0i64 },
     );
     let child = (
         "Animal",
-        entity! { schema =>  id: "child", legs: 3, parent: "parent" },
+        entity! { schema =>  id: "child", legs: 3, parent: "parent", vid: 1i64 },
     );
 
     let res = insert_and_query(subgraph_id, document, vec![parent, child], query)
@@ -570,7 +568,7 @@ async fn alias() {
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn fragments_dont_panic() {
     let subgraph_id = "FragmentsDontPanic";
     let document = "
@@ -608,9 +606,15 @@ async fn fragments_dont_panic() {
     ";
 
     // The panic manifests if two parents exist.
-    let parent = ("Parent", entity! { schema => id: "p", child: "c" });
-    let parent2 = ("Parent", entity! { schema => id: "p2", child: Value::Null });
-    let child = ("Child", entity! { schema => id:"c" });
+    let parent = (
+        "Parent",
+        entity! { schema => id: "p", child: "c", vid: 0i64 },
+    );
+    let parent2 = (
+        "Parent",
+        entity! { schema => id: "p2", child: Value::Null, vid: 1i64 },
+    );
+    let child = ("Child", entity! { schema => id:"c", vid: 2i64 });
 
     let res = insert_and_query(subgraph_id, document, vec![parent, parent2, child], query)
         .await
@@ -635,7 +639,7 @@ async fn fragments_dont_panic() {
 }
 
 // See issue #1816
-#[tokio::test]
+#[graph::test]
 async fn fragments_dont_duplicate_data() {
     let subgraph_id = "FragmentsDupe";
     let document = "
@@ -668,12 +672,15 @@ async fn fragments_dont_duplicate_data() {
     ";
 
     // This bug manifests if two parents exist.
-    let parent = ("Parent", entity! { schema => id: "p", children: vec!["c"] });
+    let parent = (
+        "Parent",
+        entity! { schema => id: "p", children: vec!["c"], vid: 0i64 },
+    );
     let parent2 = (
         "Parent",
-        entity! { schema => id: "b", children: Vec::<String>::new() },
+        entity! { schema => id: "b", children: Vec::<String>::new(), vid: 1i64 },
     );
-    let child = ("Child", entity! { schema => id:"c" });
+    let child = ("Child", entity! { schema => id:"c", vid: 2i64 });
 
     let res = insert_and_query(subgraph_id, document, vec![parent, parent2, child], query)
         .await
@@ -700,7 +707,7 @@ async fn fragments_dont_duplicate_data() {
 }
 
 // See also: e0d6da3e-60cf-41a5-b83c-b60a7a766d4a
-#[tokio::test]
+#[graph::test]
 async fn redundant_fields() {
     let subgraph_id = "RedundantFields";
     let document = "interface Legged { id: ID!, parent: Legged }
@@ -721,11 +728,11 @@ async fn redundant_fields() {
 
     let parent = (
         "Animal",
-        entity! { schema => id: "parent", parent: Value::Null },
+        entity! { schema => id: "parent", parent: Value::Null, vid: 0i64 },
     );
     let child = (
         "Animal",
-        entity! { schema => id: "child", parent: "parent" },
+        entity! { schema => id: "child", parent: "parent", vid: 1i64 },
     );
 
     let res = insert_and_query(subgraph_id, document, vec![parent, child], query)
@@ -750,7 +757,7 @@ async fn redundant_fields() {
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn fragments_merge_selections() {
     let subgraph_id = "FragmentsMergeSelections";
     let document = "
@@ -783,8 +790,11 @@ async fn fragments_merge_selections() {
         }
     ";
 
-    let parent = ("Parent", entity! { schema => id: "p", children: vec!["c"] });
-    let child = ("Child", entity! { schema => id: "c", foo: 1 });
+    let parent = (
+        "Parent",
+        entity! { schema => id: "p", children: vec!["c"], vid: 0i64 },
+    );
+    let child = ("Child", entity! { schema => id: "c", foo: 1, vid: 1i64 });
 
     let res = insert_and_query(subgraph_id, document, vec![parent, child], query)
         .await
@@ -808,7 +818,7 @@ async fn fragments_merge_selections() {
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn merge_fields_not_in_interface() {
     let subgraph_id = "MergeFieldsNotInInterface";
     let document = "interface Iface { id: ID! }
@@ -869,7 +879,7 @@ async fn merge_fields_not_in_interface() {
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn nested_interface_fragments() {
     let subgraph_id = "NestedInterfaceFragments";
     let document = "interface I1face { id: ID!, foo1: Foo! }
@@ -966,7 +976,7 @@ async fn nested_interface_fragments() {
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn nested_interface_fragments_overlapping() {
     let subgraph_id = "NestedInterfaceFragmentsOverlapping";
     let document = "interface I1face { id: ID!, foo1: Foo! }
@@ -1059,7 +1069,7 @@ async fn nested_interface_fragments_overlapping() {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn enums() {
     use r::Value::Enum;
     let subgraph_id = "enums";
@@ -1081,11 +1091,11 @@ async fn enums() {
     let entities = vec![
         (
             "Trajectory",
-            entity! { schema =>  id: "1", direction: "EAST", meters: 10 },
+            entity! { schema =>  id: "1", direction: "EAST", meters: 10, vid: 0i64 },
         ),
         (
             "Trajectory",
-            entity! { schema =>  id: "2", direction: "NORTH", meters: 15 },
+            entity! { schema =>  id: "2", direction: "NORTH", meters: 15, vid: 1i64 },
         ),
     ];
     let query = "query { trajectories { id, direction, meters } }";
@@ -1112,7 +1122,7 @@ async fn enums() {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn enum_list_filters() {
     use r::Value::Enum;
     let subgraph_id = "enum_list_filters";
@@ -1134,15 +1144,15 @@ async fn enum_list_filters() {
     let entities = vec![
         (
             "Trajectory",
-            entity! { schema =>  id: "1", direction: "EAST", meters: 10 },
+            entity! { schema =>  id: "1", direction: "EAST", meters: 10, vid: 0i64 },
         ),
         (
             "Trajectory",
-            entity! { schema =>  id: "2", direction: "NORTH", meters: 15 },
+            entity! { schema =>  id: "2", direction: "NORTH", meters: 15, vid: 1i64 },
         ),
         (
             "Trajectory",
-            entity! { schema =>  id: "3", direction: "WEST", meters: 20 },
+            entity! { schema =>  id: "3", direction: "WEST", meters: 20, vid: 2i64 },
         ),
     ];
 
@@ -1187,7 +1197,7 @@ async fn enum_list_filters() {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn recursive_fragment() {
     // Depending on whether `ENABLE_GRAPHQL_VALIDATIONS` is set or not, we
     // get different error messages
@@ -1261,7 +1271,7 @@ async fn recursive_fragment() {
     assert!(FOO_BAR_ERRORS.contains(&data.as_str()));
 }
 
-#[tokio::test]
+#[graph::test]
 async fn mixed_mutability() {
     let subgraph_id = "MixedMutability";
     let document = "interface Event { id: String! }
@@ -1285,7 +1295,7 @@ async fn mixed_mutability() {
         // this. They rely on the EntityCache filtering out entity changes
         // that are already in the store
         let id = DeploymentHash::new(subgraph_id).unwrap();
-        remove_subgraph(&id);
+        remove_subgraph(&id).await;
     }
     let res = insert_and_query(subgraph_id, document, entities, query)
         .await
@@ -1296,7 +1306,7 @@ async fn mixed_mutability() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn derived_interface_bytes() {
     fn b(s: &str) -> Value {
         Value::Bytes(s.parse().unwrap())
@@ -1327,8 +1337,8 @@ async fn derived_interface_bytes() {
 
     let entities = vec![
         ("Pool", entity! { schema =>  id: b("0xf001") }),
-        ("Sell", entity! { schema =>  id: b("0xc0"), pool: "0xf001"}),
-        ("Buy", entity! { schema =>  id: b("0xb0"), pool: "0xf001"}),
+        ("Sell", entity! { schema =>  id: b("0xc0"), pool: "0xf001" }),
+        ("Buy", entity! { schema =>  id: b("0xb0"), pool: "0xf001" }),
     ];
 
     let res = insert_and_query(subgraph_id, document, entities, query)
diff --git a/store/test-store/tests/graph/entity_cache.rs b/store/test-store/tests/graph/entity_cache.rs
index 2a5298c761c..a4fe7b0a3bc 100644
--- a/store/test-store/tests/graph/entity_cache.rs
+++ b/store/test-store/tests/graph/entity_cache.rs
@@ -1,12 +1,15 @@
-use graph::blockchain::block_stream::FirehoseCursor;
+use async_trait::async_trait;
 use graph::blockchain::BlockTime;
+use graph::blockchain::block_stream::FirehoseCursor;
 use graph::components::store::{
-    DeploymentCursorTracker, DerivedEntityQuery, GetScope, LoadRelatedRequest, ReadStore,
-    StoredDynamicDataSource, WritableStore,
+    DeploymentCursorTracker, DerivedEntityQuery, EntityLfuCache, GetScope, LoadRelatedRequest,
+    ReadStore, StoredDynamicDataSource, WritableStore,
 };
+use graph::components::subgraph::BlockState;
 use graph::data::store::Id;
 use graph::data::subgraph::schema::{DeploymentCreate, SubgraphError, SubgraphHealth};
 use graph::data_source::CausalityRegion;
+use graph::prelude::alloy::primitives::B256;
 use graph::schema::{EntityKey, EntityType, InputSchema};
 use graph::{
     components::store::{DeploymentId, DeploymentLocator},
@@ -21,7 +24,6 @@ use slog::Logger;
 use std::collections::{BTreeMap, BTreeSet};
 use std::marker::PhantomData;
 use std::sync::Arc;
-use web3::types::H256;
 
 use graph_store_postgres::SubgraphStore as DieselSubgraphStore;
 use test_store::*;
@@ -54,19 +56,20 @@ impl MockStore {
     }
 }
 
+#[async_trait]
 impl ReadStore for MockStore {
-    fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
+    async fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
         Ok(self.get_many_res.get(key).cloned())
     }
 
-    fn get_many(
+    async fn get_many(
         &self,
         _keys: BTreeSet<EntityKey>,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         Ok(self.get_many_res.clone())
     }
 
-    fn get_derived(
+    async fn get_derived(
         &self,
         _key: &DerivedEntityQuery,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
@@ -113,7 +116,10 @@ impl WritableStore for MockStore {
         unimplemented!()
     }
 
-    fn unfail_non_deterministic_error(&self, _: &BlockPtr) -> Result<UnfailOutcome, StoreError> {
+    async fn unfail_non_deterministic_error(
+        &self,
+        _: &BlockPtr,
+    ) -> Result<UnfailOutcome, StoreError> {
         unimplemented!()
     }
 
@@ -121,10 +127,6 @@ impl WritableStore for MockStore {
         unimplemented!()
     }
 
-    async fn supports_proof_of_indexing(&self) -> Result<bool, StoreError> {
-        unimplemented!()
-    }
-
     async fn transact_block_operations(
         &self,
         _: BlockPtr,
@@ -136,15 +138,16 @@ impl WritableStore for MockStore {
         _: Vec<SubgraphError>,
         _: Vec<StoredDynamicDataSource>,
         _: bool,
+        _: bool,
     ) -> Result<(), StoreError> {
         unimplemented!()
     }
 
-    async fn is_deployment_synced(&self) -> Result<bool, StoreError> {
+    fn is_deployment_synced(&self) -> bool {
         unimplemented!()
     }
 
-    fn unassign_subgraph(&self) -> Result<(), StoreError> {
+    async fn pause_subgraph(&self) -> Result<(), StoreError> {
         unimplemented!()
     }
 
@@ -155,7 +158,7 @@ impl WritableStore for MockStore {
         unimplemented!()
     }
 
-    fn deployment_synced(&self) -> Result<(), StoreError> {
+    async fn deployment_synced(&self, _block_ptr: BlockPtr) -> Result<(), StoreError> {
         unimplemented!()
     }
 
@@ -167,6 +170,10 @@ impl WritableStore for MockStore {
         unimplemented!()
     }
 
+    async fn create_postponed_indexes(&self) -> Result<(), StoreError> {
+        unimplemented!()
+    }
+
     async fn flush(&self) -> Result<(), StoreError> {
         unimplemented!()
     }
@@ -180,7 +187,7 @@ impl WritableStore for MockStore {
     }
 }
 
-fn make_band_key(id: &'static str) -> EntityKey {
+fn make_band_key(id: &str) -> EntityKey {
     SCHEMA.entity_type("Band").unwrap().parse_key(id).unwrap()
 }
 
@@ -189,34 +196,41 @@ fn sort_by_entity_key(mut mods: Vec<EntityModification>) -> Vec<EntityModificati
     mods
 }
 
-#[tokio::test]
+#[graph::test]
 async fn empty_cache_modifications() {
     let store = Arc::new(MockStore::new(BTreeMap::new()));
-    let cache = EntityCache::new(store);
-    let result = cache.as_modifications(0);
+    let cache = EntityCache::new(store, SeqGenerator::new(0));
+    let result = cache.as_modifications(0, &STOPWATCH).await;
     assert_eq!(result.unwrap().modifications, vec![]);
 }
 
-#[test]
-fn insert_modifications() {
+#[graph::test]
+async fn insert_modifications() {
     // Return no entities from the store, forcing the cache to treat any `set`
     // operation as an insert.
     let store = MockStore::new(BTreeMap::new());
 
     let store = Arc::new(store);
-    let mut cache = EntityCache::new(store);
+    let mut cache = EntityCache::new(store, SeqGenerator::new(0));
 
-    let mogwai_data = entity! { SCHEMA => id: "mogwai", name: "Mogwai" };
+    let mut mogwai_data = entity! { SCHEMA => id: "mogwai", name: "Mogwai" };
     let mogwai_key = make_band_key("mogwai");
-    cache.set(mogwai_key.clone(), mogwai_data.clone()).unwrap();
+    cache
+        .set(mogwai_key.clone(), mogwai_data.clone(), None)
+        .await
+        .unwrap();
 
-    let sigurros_data = entity! { SCHEMA => id: "sigurros", name: "Sigur Ros" };
+    let mut sigurros_data = entity! { SCHEMA => id: "sigurros", name: "Sigur Ros" };
     let sigurros_key = make_band_key("sigurros");
     cache
-        .set(sigurros_key.clone(), sigurros_data.clone())
+        .set(sigurros_key.clone(), sigurros_data.clone(), None)
+        .await
         .unwrap();
 
-    let result = cache.as_modifications(0);
+    mogwai_data.set_vid(100).unwrap();
+    sigurros_data.set_vid(101).unwrap();
+
+    let result = cache.as_modifications(0, &STOPWATCH).await;
     assert_eq!(
         sort_by_entity_key(result.unwrap().modifications),
         sort_by_entity_key(vec![
@@ -235,8 +249,8 @@ fn entity_version_map(entity_type: &str, entities: Vec<Entity>) -> BTreeMap<Enti
     map
 }
 
-#[test]
-fn overwrite_modifications() {
+#[graph::test]
+async fn overwrite_modifications() {
     // Pre-populate the store with entities so that the cache treats
     // every set operation as an overwrite.
     let store = {
@@ -248,19 +262,26 @@ fn overwrite_modifications() {
     };
 
     let store = Arc::new(store);
-    let mut cache = EntityCache::new(store);
+    let mut cache = EntityCache::new(store, SeqGenerator::new(0));
 
-    let mogwai_data = entity! { SCHEMA => id: "mogwai", name: "Mogwai", founded: 1995 };
+    let mut mogwai_data = entity! { SCHEMA => id: "mogwai", name: "Mogwai", founded: 1995 };
     let mogwai_key = make_band_key("mogwai");
-    cache.set(mogwai_key.clone(), mogwai_data.clone()).unwrap();
+    cache
+        .set(mogwai_key.clone(), mogwai_data.clone(), None)
+        .await
+        .unwrap();
 
-    let sigurros_data = entity! { SCHEMA => id: "sigurros", name: "Sigur Ros", founded: 1994 };
+    let mut sigurros_data = entity! { SCHEMA => id: "sigurros", name: "Sigur Ros", founded: 1994};
     let sigurros_key = make_band_key("sigurros");
     cache
-        .set(sigurros_key.clone(), sigurros_data.clone())
+        .set(sigurros_key.clone(), sigurros_data.clone(), None)
+        .await
         .unwrap();
 
-    let result = cache.as_modifications(0);
+    mogwai_data.set_vid(100).unwrap();
+    sigurros_data.set_vid(101).unwrap();
+
+    let result = cache.as_modifications(0, &STOPWATCH).await;
     assert_eq!(
         sort_by_entity_key(result.unwrap().modifications),
         sort_by_entity_key(vec![
@@ -270,8 +291,8 @@ fn overwrite_modifications() {
     );
 }
 
-#[test]
-fn consecutive_modifications() {
+#[graph::test]
+async fn consecutive_modifications() {
     // Pre-populate the store with data so that we can test setting a field to
     // `Value::Null`.
     let store = {
@@ -282,32 +303,202 @@ fn consecutive_modifications() {
     };
 
     let store = Arc::new(store);
-    let mut cache = EntityCache::new(store);
+    let mut cache = EntityCache::new(store, SeqGenerator::new(0));
 
     // First, add "founded" and change the "label".
     let update_data =
         entity! { SCHEMA => id: "mogwai", founded: 1995, label: "Rock Action Records" };
     let update_key = make_band_key("mogwai");
-    cache.set(update_key, update_data).unwrap();
+    cache.set(update_key, update_data, None).await.unwrap();
 
     // Then, just reset the "label".
     let update_data = entity! { SCHEMA => id: "mogwai", label: Value::Null };
     let update_key = make_band_key("mogwai");
-    cache.set(update_key.clone(), update_data).unwrap();
+    cache
+        .set(update_key.clone(), update_data, None)
+        .await
+        .unwrap();
 
     // We expect a single overwrite modification for the above that leaves "id"
     // and "name" untouched, sets "founded" and removes the "label" field.
-    let result = cache.as_modifications(0);
+    let result = cache.as_modifications(0, &STOPWATCH).await;
     assert_eq!(
         sort_by_entity_key(result.unwrap().modifications),
         sort_by_entity_key(vec![EntityModification::overwrite(
             update_key,
-            entity! { SCHEMA => id: "mogwai", name: "Mogwai", founded: 1995 },
-            0
+            entity! { SCHEMA => id: "mogwai", name: "Mogwai", founded: 1995, vid: 101i64 },
+            0,
         )])
     );
 }
 
+#[graph::test]
+async fn check_vid_sequence() {
+    let store = MockStore::new(BTreeMap::new());
+    let store = Arc::new(store);
+    let mut cache = EntityCache::new(store, SeqGenerator::new(0));
+
+    for n in 0..10 {
+        let id = (10 - n).to_string();
+        let name = "Mogwai".to_string();
+        let mogwai_key = make_band_key(id.as_str());
+        let mogwai_data = entity! { SCHEMA => id: id, name: name };
+        cache
+            .set(mogwai_key.clone(), mogwai_data.clone(), None)
+            .await
+            .unwrap();
+    }
+
+    let result = cache.as_modifications(0, &STOPWATCH).await;
+    let mods = result.unwrap().modifications;
+    for m in mods {
+        match m {
+            EntityModification::Insert {
+                key: _,
+                data,
+                block: _,
+                end: _,
+            } => {
+                let id = data.id().to_string();
+                let insert_order = data.vid() - 100;
+                // check that the order of the insertions matches VID order by comparing
+                // it to the value of the ID (which is inserted in decreasing order)
+                let id_value = 10 - insert_order;
+                assert_eq!(id, format!("{}", id_value));
+            }
+            _ => panic!("wrong entity modification type"),
+        }
+    }
+}
+
+// Test that demonstrates the VID collision bug when multiple offchain triggers
+// use separate VidGenerators. Each gets its own sequence starting at RESERVED_VIDS
+// (100), so entities in the same block get identical VIDs.
+#[graph::test]
+async fn offchain_trigger_vid_collision_without_shared_generator() {
+    let block: i32 = 2_163_923;
+
+    // Simulate first offchain trigger with its own VidGenerator
+    let store1 = Arc::new(MockStore::new(BTreeMap::new()));
+    let mut cache1 = EntityCache::new(store1, SeqGenerator::new(block));
+    let band1_data = entity! { SCHEMA => id: "band1", name: "First Band" };
+    let band1_key = make_band_key("band1");
+    cache1
+        .set(band1_key.clone(), band1_data, None)
+        .await
+        .unwrap();
+    let result1 = cache1.as_modifications(block, &STOPWATCH).await.unwrap();
+
+    // Simulate second offchain trigger with a SEPARATE VidGenerator
+    let store2 = Arc::new(MockStore::new(BTreeMap::new()));
+    let mut cache2 = EntityCache::new(store2, SeqGenerator::new(block));
+    let band2_data = entity! { SCHEMA => id: "band2", name: "Second Band" };
+    let band2_key = make_band_key("band2");
+    cache2
+        .set(band2_key.clone(), band2_data, None)
+        .await
+        .unwrap();
+    let result2 = cache2.as_modifications(block, &STOPWATCH).await.unwrap();
+
+    let vid1 = match &result1.modifications[0] {
+        EntityModification::Insert { data, .. } => data.vid(),
+        _ => panic!("expected Insert"),
+    };
+    let vid2 = match &result2.modifications[0] {
+        EntityModification::Insert { data, .. } => data.vid(),
+        _ => panic!("expected Insert"),
+    };
+
+    // BUG: Both VIDs are identical because each VidGenerator starts at 100
+    let expected_vid = ((block as i64) << 32) + 100;
+    assert_eq!(vid1, expected_vid);
+    assert_eq!(vid2, expected_vid);
+    assert_eq!(vid1, vid2, "VIDs collide when using separate VidGenerators");
+}
+
+// Test that demonstrates the fix: sharing a single VidGenerator across
+// multiple EntityCaches prevents VID collisions.
+#[graph::test]
+async fn offchain_trigger_vid_no_collision_with_shared_generator() {
+    let block: i32 = 2_163_923;
+    let vid_gen = SeqGenerator::new(block);
+
+    // First offchain trigger
+    let store1 = Arc::new(MockStore::new(BTreeMap::new()));
+    let mut cache1 = EntityCache::new(store1, vid_gen.cheap_clone());
+    let band1_data = entity! { SCHEMA => id: "band1", name: "First Band" };
+    let band1_key = make_band_key("band1");
+    cache1
+        .set(band1_key.clone(), band1_data, None)
+        .await
+        .unwrap();
+    let result1 = cache1.as_modifications(block, &STOPWATCH).await.unwrap();
+
+    // Second offchain trigger shares the same VidGenerator
+    let store2 = Arc::new(MockStore::new(BTreeMap::new()));
+    let mut cache2 = EntityCache::new(store2, vid_gen.cheap_clone());
+    let band2_data = entity! { SCHEMA => id: "band2", name: "Second Band" };
+    let band2_key = make_band_key("band2");
+    cache2
+        .set(band2_key.clone(), band2_data, None)
+        .await
+        .unwrap();
+    let result2 = cache2.as_modifications(block, &STOPWATCH).await.unwrap();
+
+    let vid1 = match &result1.modifications[0] {
+        EntityModification::Insert { data, .. } => data.vid(),
+        _ => panic!("expected Insert"),
+    };
+    let vid2 = match &result2.modifications[0] {
+        EntityModification::Insert { data, .. } => data.vid(),
+        _ => panic!("expected Insert"),
+    };
+
+    // With a shared VidGenerator, VIDs are different
+    assert_ne!(
+        vid1, vid2,
+        "VIDs should NOT collide when sharing a VidGenerator"
+    );
+    let expected_vid1 = ((block as i64) << 32) + 100;
+    let expected_vid2 = ((block as i64) << 32) + 101;
+    assert_eq!(vid1, expected_vid1, "first trigger starts at vid_seq 100");
+    assert_eq!(
+        vid2, expected_vid2,
+        "second trigger continues at vid_seq 101"
+    );
+}
+
+// Simulate the ipfs.map() pattern: multiple EntityCache instances each create
+// an entity using a shared SeqGenerator. VIDs must be unique and sequential.
+#[graph::test]
+async fn ipfs_map_pattern_vid_uniqueness() {
+    let block: i32 = 42;
+    let vid_gen = SeqGenerator::new(block);
+
+    let mut all_vids = Vec::new();
+    for i in 0..5u32 {
+        let store = Arc::new(MockStore::new(BTreeMap::new()));
+        let mut cache = EntityCache::new(store, vid_gen.cheap_clone());
+        let data = entity! { SCHEMA => id: format!("band{i}"), name: format!("Band {i}") };
+        let key = make_band_key(&format!("band{i}"));
+        cache.set(key, data, None).await.unwrap();
+        let result = cache.as_modifications(block, &STOPWATCH).await.unwrap();
+        let vid = match &result.modifications[0] {
+            EntityModification::Insert { data, .. } => data.vid(),
+            _ => panic!("expected Insert"),
+        };
+        all_vids.push(vid);
+    }
+
+    for i in 1..all_vids.len() {
+        assert_eq!(
+            all_vids[i],
+            all_vids[i - 1] + 1,
+            "VIDs should be sequential"
+        );
+    }
+}
+
 const ACCOUNT_GQL: &str = "
     type Account @entity {
         id: ID!
@@ -341,7 +532,7 @@ lazy_static! {
         InputSchema::parse_latest(ACCOUNT_GQL, LOAD_RELATED_ID.clone())
             .expect("Failed to parse user schema");
     static ref TEST_BLOCK_1_PTR: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "8511fa04b64657581e3f00e14543c1d522d5d7e771b54aa3060b662ade47da13"
         )),
         1u64
@@ -352,12 +543,6 @@ lazy_static! {
     static ref PURSE_TYPE: EntityType = LOAD_RELATED_SUBGRAPH.entity_type(PURSE).unwrap();
 }
 
-fn remove_test_data(store: Arc<DieselSubgraphStore>) {
-    store
-        .delete_all_entities_for_test_use_only()
-        .expect("deleting test entities succeeds");
-}
-
 fn run_store_test<R, F>(test: F)
 where
     F: FnOnce(
@@ -373,7 +558,7 @@ where
     run_test_sequentially(|store| async move {
         let subgraph_store = store.subgraph_store();
         // Reset state before starting
-        remove_test_data(subgraph_store.clone());
+        remove_subgraphs().await;
 
         // Seed database with test data
         let deployment = insert_test_data(subgraph_store.clone()).await;
@@ -388,7 +573,7 @@ where
 
         let read_store = Arc::new(writable.clone());
 
-        let cache = EntityCache::new(read_store);
+        let cache = EntityCache::new(read_store, SeqGenerator::new(0));
         // Run test and wait for the background writer to finish its work so
         // it won't conflict with the next test
         test(cache, subgraph_store.clone(), deployment, writable.clone()).await;
@@ -399,7 +584,7 @@ where
 async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator {
     let manifest = SubgraphManifest::<graph_chain_ethereum::Chain> {
         id: LOAD_RELATED_ID.clone(),
-        spec_version: Version::new(1, 0, 0),
+        spec_version: Version::new(1, 3, 0),
         features: Default::default(),
         description: None,
         repository: None,
@@ -424,20 +609,21 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
             NETWORK_NAME.to_string(),
             SubgraphVersionSwitchingMode::Instant,
         )
+        .await
         .unwrap();
 
     // 1 account 3 wallets
-    let test_entity_1 = create_account_entity("1", "Johnton", "tonofjohn@email.com", 67_i32);
+    let test_entity_1 = create_account_entity("1", "Johnton", "tonofjohn@email.com", 67_i32, 1);
     let id_one = WALLET_TYPE.parse_id("1").unwrap();
-    let wallet_entity_1 = create_wallet_operation("1", &id_one, 67_i32);
-    let wallet_entity_2 = create_wallet_operation("2", &id_one, 92_i32);
-    let wallet_entity_3 = create_wallet_operation("3", &id_one, 192_i32);
+    let wallet_entity_1 = create_wallet_operation("1", &id_one, 67_i32, 1);
+    let wallet_entity_2 = create_wallet_operation("2", &id_one, 92_i32, 2);
+    let wallet_entity_3 = create_wallet_operation("3", &id_one, 192_i32, 3);
     // 1 account 1 wallet
-    let test_entity_2 = create_account_entity("2", "Cindini", "dinici@email.com", 42_i32);
+    let test_entity_2 = create_account_entity("2", "Cindini", "dinici@email.com", 42_i32, 2);
     let id_two = WALLET_TYPE.parse_id("2").unwrap();
-    let wallet_entity_4 = create_wallet_operation("4", &id_two, 32_i32);
+    let wallet_entity_4 = create_wallet_operation("4", &id_two, 32_i32, 4);
     // 1 account 0 wallets
-    let test_entity_3 = create_account_entity("3", "Shaqueeena", "queensha@email.com", 28_i32);
+    let test_entity_3 = create_account_entity("3", "Shaqueeena", "queensha@email.com", 28_i32, 3);
     transact_entity_operations(
         &store,
         &deployment,
@@ -457,9 +643,9 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
     deployment
 }
 
-fn create_account_entity(id: &str, name: &str, email: &str, age: i32) -> EntityOperation {
+fn create_account_entity(id: &str, name: &str, email: &str, age: i32, vid: i64) -> EntityOperation {
     let test_entity =
-        entity! { LOAD_RELATED_SUBGRAPH => id: id, name: name, email: email, age: age };
+        entity! { LOAD_RELATED_SUBGRAPH => id: id, name: name, email: email, age: age, vid: vid};
 
     EntityOperation::Set {
         key: ACCOUNT_TYPE.parse_key(id).unwrap(),
@@ -467,12 +653,18 @@ fn create_account_entity(id: &str, name: &str, email: &str, age: i32) -> EntityO
     }
 }
 
-fn create_wallet_entity(id: &str, account_id: &Id, balance: i32) -> Entity {
+fn create_wallet_entity(id: &str, account_id: &Id, balance: i32, vid: i64) -> Entity {
     let account_id = Value::from(account_id.clone());
-    entity! { LOAD_RELATED_SUBGRAPH => id: id, account: account_id, balance: balance }
+    entity! { LOAD_RELATED_SUBGRAPH => id: id, account: account_id, balance: balance, vid: vid}
 }
-fn create_wallet_operation(id: &str, account_id: &Id, balance: i32) -> EntityOperation {
-    let test_wallet = create_wallet_entity(id, account_id, balance);
+
+fn create_wallet_entity_no_vid(id: &str, account_id: &Id, balance: i32) -> Entity {
+    let account_id = Value::from(account_id.clone());
+    entity! { LOAD_RELATED_SUBGRAPH => id: id, account: account_id, balance: balance}
+}
+
+fn create_wallet_operation(id: &str, account_id: &Id, balance: i32, vid: i64) -> EntityOperation {
+    let test_wallet = create_wallet_entity(id, account_id, balance, vid);
     EntityOperation::Set {
         key: WALLET_TYPE.parse_key(id).unwrap(),
         data: test_wallet,
@@ -489,10 +681,10 @@ fn check_for_account_with_multiple_wallets() {
             entity_id: account_id.clone(),
             causality_region: CausalityRegion::ONCHAIN,
         };
-        let result = cache.load_related(&request).unwrap();
-        let wallet_1 = create_wallet_entity("1", &account_id, 67_i32);
-        let wallet_2 = create_wallet_entity("2", &account_id, 92_i32);
-        let wallet_3 = create_wallet_entity("3", &account_id, 192_i32);
+        let result = cache.load_related(&request).await.unwrap();
+        let wallet_1 = create_wallet_entity("1", &account_id, 67_i32, 1);
+        let wallet_2 = create_wallet_entity("2", &account_id, 92_i32, 2);
+        let wallet_3 = create_wallet_entity("3", &account_id, 192_i32, 3);
         let expeted_vec = vec![wallet_1, wallet_2, wallet_3];
 
         assert_eq!(result, expeted_vec);
@@ -509,8 +701,8 @@ fn check_for_account_with_single_wallet() {
             entity_id: account_id.clone(),
             causality_region: CausalityRegion::ONCHAIN,
         };
-        let result = cache.load_related(&request).unwrap();
-        let wallet_1 = create_wallet_entity("4", &account_id, 32_i32);
+        let result = cache.load_related(&request).await.unwrap();
+        let wallet_1 = create_wallet_entity("4", &account_id, 32_i32, 4);
         let expeted_vec = vec![wallet_1];
 
         assert_eq!(result, expeted_vec);
@@ -527,7 +719,7 @@ fn check_for_account_with_no_wallet() {
             entity_id: account_id,
             causality_region: CausalityRegion::ONCHAIN,
         };
-        let result = cache.load_related(&request).unwrap();
+        let result = cache.load_related(&request).await.unwrap();
         let expeted_vec = vec![];
 
         assert_eq!(result, expeted_vec);
@@ -544,7 +736,7 @@ fn check_for_account_that_doesnt_exist() {
             entity_id: account_id,
             causality_region: CausalityRegion::ONCHAIN,
         };
-        let result = cache.load_related(&request).unwrap();
+        let result = cache.load_related(&request).await.unwrap();
         let expeted_vec = vec![];
 
         assert_eq!(result, expeted_vec);
@@ -561,7 +753,7 @@ fn check_for_non_existent_field() {
             entity_id: account_id,
             causality_region: CausalityRegion::ONCHAIN,
         };
-        let result = cache.load_related(&request).unwrap_err();
+        let result = cache.load_related(&request).await.unwrap_err();
         let expected = format!(
             "Entity {}[{}]: unknown field `{}`",
             request.entity_type, request.entity_id, request.entity_field,
@@ -576,8 +768,8 @@ fn check_for_insert_async_store() {
     run_store_test(|mut cache, store, deployment, _writable| async move {
         let account_id = ACCOUNT_TYPE.parse_id("2").unwrap();
         // insert a new wallet
-        let wallet_entity_5 = create_wallet_operation("5", &account_id, 79_i32);
-        let wallet_entity_6 = create_wallet_operation("6", &account_id, 200_i32);
+        let wallet_entity_5 = create_wallet_operation("5", &account_id, 79_i32, 12);
+        let wallet_entity_6 = create_wallet_operation("6", &account_id, 200_i32, 13);
 
         transact_entity_operations(
             &store,
@@ -593,10 +785,10 @@ fn check_for_insert_async_store() {
             entity_id: account_id.clone(),
             causality_region: CausalityRegion::ONCHAIN,
         };
-        let result = cache.load_related(&request).unwrap();
-        let wallet_1 = create_wallet_entity("4", &account_id, 32_i32);
-        let wallet_2 = create_wallet_entity("5", &account_id, 79_i32);
-        let wallet_3 = create_wallet_entity("6", &account_id, 200_i32);
+        let result = cache.load_related(&request).await.unwrap();
+        let wallet_1 = create_wallet_entity("4", &account_id, 32_i32, 4);
+        let wallet_2 = create_wallet_entity("5", &account_id, 79_i32, 12);
+        let wallet_3 = create_wallet_entity("6", &account_id, 200_i32, 13);
         let expeted_vec = vec![wallet_1, wallet_2, wallet_3];
 
         assert_eq!(result, expeted_vec);
@@ -607,8 +799,8 @@ fn check_for_insert_async_not_related() {
     run_store_test(|mut cache, store, deployment, _writable| async move {
         let account_id = ACCOUNT_TYPE.parse_id("2").unwrap();
         // insert a new wallet
-        let wallet_entity_5 = create_wallet_operation("5", &account_id, 79_i32);
-        let wallet_entity_6 = create_wallet_operation("6", &account_id, 200_i32);
+        let wallet_entity_5 = create_wallet_operation("5", &account_id, 79_i32, 5);
+        let wallet_entity_6 = create_wallet_operation("6", &account_id, 200_i32, 6);
 
         transact_entity_operations(
             &store,
@@ -625,10 +817,10 @@ fn check_for_insert_async_not_related() {
             entity_id: account_id.clone(),
             causality_region: CausalityRegion::ONCHAIN,
         };
-        let result = cache.load_related(&request).unwrap();
-        let wallet_1 = create_wallet_entity("1", &account_id, 67_i32);
-        let wallet_2 = create_wallet_entity("2", &account_id, 92_i32);
-        let wallet_3 = create_wallet_entity("3", &account_id, 192_i32);
+        let result = cache.load_related(&request).await.unwrap();
+        let wallet_1 = create_wallet_entity("1", &account_id, 67_i32, 1);
+        let wallet_2 = create_wallet_entity("2", &account_id, 92_i32, 2);
+        let wallet_3 = create_wallet_entity("3", &account_id, 192_i32, 3);
         let expeted_vec = vec![wallet_1, wallet_2, wallet_3];
 
         assert_eq!(result, expeted_vec);
@@ -640,13 +832,13 @@ fn check_for_update_async_related() {
     run_store_test(|mut cache, store, deployment, writable| async move {
         let entity_key = WALLET_TYPE.parse_key("1").unwrap();
         let account_id = entity_key.entity_id.clone();
-        let wallet_entity_update = create_wallet_operation("1", &account_id, 79_i32);
+        let wallet_entity_update = create_wallet_operation("1", &account_id, 79_i32, 11);
 
         let new_data = match wallet_entity_update {
             EntityOperation::Set { ref data, .. } => data.clone(),
             _ => unreachable!(),
         };
-        assert_ne!(writable.get(&entity_key).unwrap().unwrap(), new_data);
+        assert_ne!(writable.get(&entity_key).await.unwrap().unwrap(), new_data);
         // insert a new wallet
         transact_entity_operations(
             &store,
@@ -663,9 +855,9 @@ fn check_for_update_async_related() {
             entity_id: account_id.clone(),
             causality_region: CausalityRegion::ONCHAIN,
         };
-        let result = cache.load_related(&request).unwrap();
-        let wallet_2 = create_wallet_entity("2", &account_id, 92_i32);
-        let wallet_3 = create_wallet_entity("3", &account_id, 192_i32);
+        let result = cache.load_related(&request).await.unwrap();
+        let wallet_2 = create_wallet_entity("2", &account_id, 92_i32, 2);
+        let wallet_3 = create_wallet_entity("3", &account_id, 192_i32, 3);
         let expeted_vec = vec![new_data, wallet_2, wallet_3];
 
         assert_eq!(result, expeted_vec);
@@ -693,53 +885,64 @@ fn check_for_delete_async_related() {
             entity_id: account_id.clone(),
             causality_region: CausalityRegion::ONCHAIN,
         };
-        let result = cache.load_related(&request).unwrap();
-        let wallet_2 = create_wallet_entity("2", &account_id, 92_i32);
-        let wallet_3 = create_wallet_entity("3", &account_id, 192_i32);
+        let result = cache.load_related(&request).await.unwrap();
+        let wallet_2 = create_wallet_entity("2", &account_id, 92_i32, 2);
+        let wallet_3 = create_wallet_entity("3", &account_id, 192_i32, 3);
         let expeted_vec = vec![wallet_2, wallet_3];
 
         assert_eq!(result, expeted_vec);
     });
 }
-
 #[test]
 fn scoped_get() {
     run_store_test(|mut cache, _store, _deployment, _writable| async move {
         // Key for an existing entity that is in the store
         let account1 = ACCOUNT_TYPE.parse_id("1").unwrap();
         let key1 = WALLET_TYPE.parse_key("1").unwrap();
-        let wallet1 = create_wallet_entity("1", &account1, 67);
+        let wallet1 = create_wallet_entity_no_vid("1", &account1, 67);
 
         // Create a new entity that is not in the store
         let account5 = ACCOUNT_TYPE.parse_id("5").unwrap();
-        let wallet5 = create_wallet_entity("5", &account5, 100);
+        let mut wallet5 = create_wallet_entity_no_vid("5", &account5, 100);
         let key5 = WALLET_TYPE.parse_key("5").unwrap();
-        cache.set(key5.clone(), wallet5.clone()).unwrap();
+        cache
+            .set(key5.clone(), wallet5.clone(), None)
+            .await
+            .unwrap();
 
+        wallet5.set_vid(100).unwrap();
         // For the new entity, we can retrieve it with either scope
-        let act5 = cache.get(&key5, GetScope::InBlock).unwrap();
+        let act5 = cache.get(&key5, GetScope::InBlock).await.unwrap();
         assert_eq!(Some(&wallet5), act5.as_ref().map(|e| e.as_ref()));
-        let act5 = cache.get(&key5, GetScope::Store).unwrap();
+        let act5 = cache.get(&key5, GetScope::Store).await.unwrap();
         assert_eq!(Some(&wallet5), act5.as_ref().map(|e| e.as_ref()));
 
+        let mut wallet1a = wallet1.clone();
+        wallet1a.set_vid(1).unwrap();
         // For an entity in the store, we can not get it `InBlock` but with
         // `Store`
-        let act1 = cache.get(&key1, GetScope::InBlock).unwrap();
+        let act1 = cache.get(&key1, GetScope::InBlock).await.unwrap();
         assert_eq!(None, act1);
-        let act1 = cache.get(&key1, GetScope::Store).unwrap();
-        assert_eq!(Some(&wallet1), act1.as_ref().map(|e| e.as_ref()));
+        let act1 = cache.get(&key1, GetScope::Store).await.unwrap();
+        assert_eq!(Some(&wallet1a), act1.as_ref().map(|e| e.as_ref()));
+
         // Even after reading from the store, the entity is not visible with
         // `InBlock`
-        let act1 = cache.get(&key1, GetScope::InBlock).unwrap();
+        let act1 = cache.get(&key1, GetScope::InBlock).await.unwrap();
         assert_eq!(None, act1);
         // But if it gets updated, it becomes visible with either scope
         let mut wallet1 = wallet1;
         wallet1.set("balance", 70).unwrap();
-        cache.set(key1.clone(), wallet1.clone()).unwrap();
-        let act1 = cache.get(&key1, GetScope::InBlock).unwrap();
-        assert_eq!(Some(&wallet1), act1.as_ref().map(|e| e.as_ref()));
-        let act1 = cache.get(&key1, GetScope::Store).unwrap();
-        assert_eq!(Some(&wallet1), act1.as_ref().map(|e| e.as_ref()));
+        cache
+            .set(key1.clone(), wallet1.clone(), None)
+            .await
+            .unwrap();
+        wallet1a = wallet1;
+        wallet1a.set_vid(101).unwrap();
+        let act1 = cache.get(&key1, GetScope::InBlock).await.unwrap();
+        assert_eq!(Some(&wallet1a), act1.as_ref().map(|e| e.as_ref()));
+        let act1 = cache.get(&key1, GetScope::Store).await.unwrap();
+        assert_eq!(Some(&wallet1a), act1.as_ref().map(|e| e.as_ref()));
     })
 }
 
@@ -758,10 +961,10 @@ fn no_internal_keys() {
         }
         let key = WALLET_TYPE.parse_key("1").unwrap();
 
-        let wallet = writable.get(&key).unwrap().unwrap();
+        let wallet = writable.get(&key).await.unwrap().unwrap();
         check(&key, &wallet);
 
-        let wallet = cache.get(&key, GetScope::Store).unwrap().unwrap();
+        let wallet = cache.get(&key, GetScope::Store).await.unwrap().unwrap();
         check(&key, &wallet);
     });
 }
@@ -773,15 +976,391 @@ fn no_interface_mods() {
 
         // This should probably be an error, but changing that would not be
         // backwards compatible
-        assert_eq!(None, cache.get(&key, GetScope::InBlock).unwrap());
+        assert_eq!(None, cache.get(&key, GetScope::InBlock).await.unwrap());
 
         assert!(matches!(
-            cache.get(&key, GetScope::Store),
+            cache.get(&key, GetScope::Store).await,
             Err(StoreError::UnknownTable(_))
         ));
 
         let entity = entity! { LOAD_RELATED_SUBGRAPH => id: "1", balance: 100 };
 
-        cache.set(key, entity).unwrap_err();
+        cache.set(key, entity, None).await.unwrap_err();
     })
 }
+
+// ---------------------------------------------------------------------------
+// Tests for `EntityCache::load_related` under same-block changes to
+// derived field membership. Each test exercises a write that should
+// move an entity into or out of an `account.wallets` derived
+// collection (reassignment, removal, or fresh creation), asserting
+// that the returned collection reflects the entity's final state.
+//
+// Fixture (from `insert_test_data`):
+//   - account "1" owns wallets "1", "2", "3"
+//   - account "2" owns wallet "4"
+//   - account "3" owns no wallets
+//
+// Tests that need writes in `EntityCache::handler_updates` (rather than
+// `updates`) drive a handler lifecycle through `BlockState::enter_handler`
+// / `exit_handler`. `EntityCache` has two in-block write layers: writes
+// outside a handler go to `self.updates`; writes inside an active
+// handler go to `self.handler_updates`. `exit_handler` merges
+// `handler_updates` into `updates`. Driving this lifecycle requires
+// `BlockState` because the `enter`/`exit` methods on `EntityCache` are
+// crate-private.
+// ---------------------------------------------------------------------------
+
+/// Wallet "1" is reassigned from account "1" to account "3" within a
+/// single handler. Account "1"'s derived `wallets` collection must
+/// reflect the final state and exclude wallet "1".
+#[test]
+fn load_related_excludes_wallet_that_leaves_collection() {
+    run_store_test(|mut cache, _store, _deployment, _writable| async move {
+        let acc_1 = ACCOUNT_TYPE.parse_id("1").unwrap();
+        let acc_3 = ACCOUNT_TYPE.parse_id("3").unwrap();
+        let wallet_1_key = WALLET_TYPE.parse_key("1").unwrap();
+
+        // Precondition: fixture placed wallet "1" under account "1".
+        // The `set` below is a reassignment of an existing row.
+        let pre = cache
+            .get(&wallet_1_key, GetScope::Store)
+            .await
+            .unwrap()
+            .expect("fixture should have inserted wallet 1");
+        assert_eq!(pre.get("account").unwrap(), &Value::from(acc_1.clone()));
+
+        let reassigned = create_wallet_entity_no_vid("1", &acc_3, 67_i32);
+        cache.set(wallet_1_key, reassigned, None).await.unwrap();
+
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: acc_1.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        let result = cache.load_related(&request).await.unwrap();
+
+        let result_ids: Vec<_> = result
+            .iter()
+            .map(|e| e.get("id").unwrap().clone())
+            .collect();
+
+        assert_eq!(
+            result.len(),
+            2,
+            "account 1 should own 2 wallets after reassignment, got {:?}",
+            result_ids,
+        );
+        for w in &result {
+            assert_eq!(
+                w.get("account").unwrap(),
+                &Value::from(acc_1.clone()),
+                "every wallet in account 1's collection must have account=1, got {:?}",
+                w,
+            );
+        }
+    });
+}
+
+/// Wallet "4" is moved from account "2" to account "3" in handler 1,
+/// then back to account "2" in handler 2. Account "3"'s derived
+/// `wallets` collection must reflect the final state and exclude
+/// wallet "4".
+#[test]
+fn load_related_excludes_wallet_that_leaves_collection_across_handlers() {
+    run_store_test(|_cache, _store, _deployment, writable| async move {
+        let acc_2 = ACCOUNT_TYPE.parse_id("2").unwrap();
+        let acc_3 = ACCOUNT_TYPE.parse_id("3").unwrap();
+        let wallet_4_key = WALLET_TYPE.parse_key("4").unwrap();
+
+        let mut state = BlockState::new(
+            writable.clone(),
+            EntityLfuCache::new(),
+            SeqGenerator::new(10),
+        );
+
+        // Precondition: fixture placed wallet "4" under account "2".
+        let pre = writable
+            .get(&wallet_4_key)
+            .await
+            .unwrap()
+            .expect("fixture should have inserted wallet 4");
+        assert_eq!(pre.get("account").unwrap(), &Value::from(acc_2.clone()));
+
+        // Handler 1: move wallet "4" to account "3". On exit, this
+        // write is promoted from handler_updates into updates.
+        state.enter_handler();
+        state
+            .entity_cache
+            .set(
+                wallet_4_key.clone(),
+                create_wallet_entity_no_vid("4", &acc_3, 32_i32),
+                None,
+            )
+            .await
+            .unwrap();
+        state.exit_handler();
+
+        // Handler 2: move wallet "4" back to account "2". This write
+        // is in handler_updates; the prior handler's write is in updates.
+        state.enter_handler();
+        state
+            .entity_cache
+            .set(
+                wallet_4_key,
+                create_wallet_entity_no_vid("4", &acc_2, 32_i32),
+                None,
+            )
+            .await
+            .unwrap();
+
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: acc_3.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        let result = state.entity_cache.load_related(&request).await.unwrap();
+
+        assert!(
+            result.is_empty(),
+            "account 3 should own no wallets (wallet 4's final account is 2), got {:?}",
+            result,
+        );
+    });
+}
+
+/// Wallet "4" is touched in handler 1 without changing its `account`,
+/// then reassigned from account "2" to account "3" in handler 2.
+/// Account "3"'s derived `wallets` collection must reflect the final
+/// state and include wallet "4".
+#[test]
+fn load_related_includes_wallet_that_joins_collection_across_handlers() {
+    run_store_test(|_cache, _store, _deployment, writable| async move {
+        let acc_2 = ACCOUNT_TYPE.parse_id("2").unwrap();
+        let acc_3 = ACCOUNT_TYPE.parse_id("3").unwrap();
+        let wallet_4_key = WALLET_TYPE.parse_key("4").unwrap();
+
+        let mut state = BlockState::new(
+            writable.clone(),
+            EntityLfuCache::new(),
+            SeqGenerator::new(10),
+        );
+
+        // Precondition: fixture placed wallet "4" under account "2".
+        let pre = writable
+            .get(&wallet_4_key)
+            .await
+            .unwrap()
+            .expect("fixture should have inserted wallet 4");
+        assert_eq!(pre.get("account").unwrap(), &Value::from(acc_2.clone()));
+
+        // Handler 1: touch wallet "4" (bump balance) but keep its account.
+        // On exit, this write is promoted into updates.
+        state.enter_handler();
+        state
+            .entity_cache
+            .set(
+                wallet_4_key.clone(),
+                create_wallet_entity_no_vid("4", &acc_2, 999_i32),
+                None,
+            )
+            .await
+            .unwrap();
+        state.exit_handler();
+
+        // Handler 2: reassign wallet "4" to account "3". This write is
+        // in handler_updates; handler 1's write remains in updates.
+        state.enter_handler();
+        state
+            .entity_cache
+            .set(
+                wallet_4_key.clone(),
+                create_wallet_entity_no_vid("4", &acc_3, 999_i32),
+                None,
+            )
+            .await
+            .unwrap();
+
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: acc_3.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        let result = state.entity_cache.load_related(&request).await.unwrap();
+
+        assert_eq!(
+            result.len(),
+            1,
+            "account 3 should own wallet 4 after reassignment, got {:?}",
+            result,
+        );
+        assert_eq!(result[0].get("id").unwrap(), &Value::from("4"),);
+        assert_eq!(
+            result[0].get("account").unwrap(),
+            &Value::from(acc_3.clone()),
+            "wallet 4 must carry handler 2's post-merge account=3",
+        );
+    });
+}
+
+/// Wallet "1" is removed via a write that lands directly in
+/// `EntityCache::updates` (no active handler). Account "1"'s derived
+/// `wallets` collection must reflect the final state and exclude
+/// wallet "1".
+#[test]
+fn load_related_excludes_wallet_removed_via_updates() {
+    run_store_test(|mut cache, _store, _deployment, _writable| async move {
+        let acc_1 = ACCOUNT_TYPE.parse_id("1").unwrap();
+        let wallet_1_key = WALLET_TYPE.parse_key("1").unwrap();
+
+        // Precondition: fixture placed wallet "1" under account "1".
+        let pre = cache
+            .get(&wallet_1_key, GetScope::Store)
+            .await
+            .unwrap()
+            .expect("fixture should have inserted wallet 1");
+        assert_eq!(pre.get("account").unwrap(), &Value::from(acc_1.clone()));
+
+        cache.remove(wallet_1_key);
+
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: acc_1.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        let result = cache.load_related(&request).await.unwrap();
+
+        let result_ids: Vec<_> = result
+            .iter()
+            .map(|e| e.get("id").unwrap().clone())
+            .collect();
+
+        assert_eq!(
+            result.len(),
+            2,
+            "account 1 should own 2 wallets after wallet 1 is removed, got {:?}",
+            result_ids,
+        );
+        assert!(
+            !result_ids.contains(&Value::from("1")),
+            "removed wallet 1 must not appear, got {:?}",
+            result_ids,
+        );
+    });
+}
+
+/// Wallet "1" is removed inside an active handler so the Remove op
+/// sits in `EntityCache::handler_updates` at query time. Account "1"'s
+/// derived `wallets` collection must reflect the final state and
+/// exclude wallet "1".
+#[test]
+fn load_related_excludes_wallet_removed_via_handler_updates() {
+    run_store_test(|_cache, _store, _deployment, writable| async move {
+        let acc_1 = ACCOUNT_TYPE.parse_id("1").unwrap();
+        let wallet_1_key = WALLET_TYPE.parse_key("1").unwrap();
+
+        let mut state = BlockState::new(
+            writable.clone(),
+            EntityLfuCache::new(),
+            SeqGenerator::new(10),
+        );
+
+        // Precondition: fixture placed wallet "1" under account "1".
+        let pre = writable
+            .get(&wallet_1_key)
+            .await
+            .unwrap()
+            .expect("fixture should have inserted wallet 1");
+        assert_eq!(pre.get("account").unwrap(), &Value::from(acc_1.clone()));
+
+        // Remove wallet "1" inside an active handler. The Remove op
+        // sits in handler_updates and is queried before exit_handler.
+        state.enter_handler();
+        state.entity_cache.remove(wallet_1_key);
+
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: acc_1.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        let result = state.entity_cache.load_related(&request).await.unwrap();
+
+        let result_ids: Vec<_> = result
+            .iter()
+            .map(|e| e.get("id").unwrap().clone())
+            .collect();
+
+        assert_eq!(
+            result.len(),
+            2,
+            "account 1 should own 2 wallets after wallet 1 is removed, got {:?}",
+            result_ids,
+        );
+        assert!(
+            !result_ids.contains(&Value::from("1")),
+            "removed wallet 1 must not appear, got {:?}",
+            result_ids,
+        );
+    });
+}
+
+/// A wallet is created inside a handler with no prior store baseline.
+/// `load_related` called from the same handler must observe the new
+/// wallet in its parent account's derived collection.
+#[test]
+fn load_related_includes_wallet_created_in_handler() {
+    run_store_test(|_cache, _store, _deployment, writable| async move {
+        let acc_3 = ACCOUNT_TYPE.parse_id("3").unwrap();
+        let new_wallet_key = WALLET_TYPE.parse_key("99").unwrap();
+
+        let mut state = BlockState::new(
+            writable.clone(),
+            EntityLfuCache::new(),
+            SeqGenerator::new(10),
+        );
+
+        // Precondition: account "3" starts with no wallets and
+        // wallet "99" does not exist in the store.
+        assert!(
+            writable.get(&new_wallet_key).await.unwrap().is_none(),
+            "wallet 99 should not exist in the store baseline",
+        );
+
+        // Create a fresh wallet under account "3" inside a handler.
+        state.enter_handler();
+        state
+            .entity_cache
+            .set(
+                new_wallet_key,
+                create_wallet_entity_no_vid("99", &acc_3, 500_i32),
+                None,
+            )
+            .await
+            .unwrap();
+
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: acc_3.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        let result = state.entity_cache.load_related(&request).await.unwrap();
+
+        assert_eq!(
+            result.len(),
+            1,
+            "account 3 should own the newly created wallet 99, got {:?}",
+            result,
+        );
+        assert_eq!(result[0].get("id").unwrap(), &Value::from("99"));
+        assert_eq!(
+            result[0].get("account").unwrap(),
+            &Value::from(acc_3.clone()),
+        );
+    });
+}
diff --git a/store/test-store/tests/graphql.rs b/store/test-store/tests/graphql.rs
index 3ae1fcd2b74..86ed181da39 100644
--- a/store/test-store/tests/graphql.rs
+++ b/store/test-store/tests/graphql.rs
@@ -1,4 +1,5 @@
 pub mod graphql {
     pub mod introspection;
     pub mod query;
+    pub mod sql;
 }
diff --git a/store/test-store/tests/graphql/introspection.rs b/store/test-store/tests/graphql/introspection.rs
index 8793196eefb..bda2cb99b31 100644
--- a/store/test-store/tests/graphql/introspection.rs
+++ b/store/test-store/tests/graphql/introspection.rs
@@ -1,17 +1,20 @@
+use std::fs::File;
+use std::io::Write;
 use std::sync::Arc;
 use std::time::Duration;
 
+use async_trait::async_trait;
 use graph::components::store::QueryPermit;
-use graph::data::graphql::{object_value, ObjectOrInterface};
+use graph::data::graphql::{ObjectOrInterface, object_value};
 use graph::data::query::Trace;
 use graph::prelude::{
-    async_trait, o, r, s, serde_json, slog, tokio, DeploymentHash, Logger, Query,
-    QueryExecutionError, QueryResult,
+    DeploymentHash, Logger, Query, QueryExecutionError, QueryResult, o, q, r, s, serde_json, slog,
+    tokio,
 };
 use graph::schema::{ApiSchema, InputSchema};
 
 use graph_graphql::prelude::{
-    a, execute_query, ExecutionContext, Query as PreparedQuery, QueryExecutionOptions, Resolver,
+    ExecutionContext, Query as PreparedQuery, QueryExecutionOptions, Resolver, a, execute_query,
 };
 use test_store::graphql_metrics;
 
@@ -23,7 +26,7 @@ pub struct MockResolver;
 impl Resolver for MockResolver {
     const CACHEABLE: bool = false;
 
-    fn prefetch(
+    async fn prefetch(
         &self,
         _: &ExecutionContext<Self>,
         _: &a::SelectionSet,
@@ -43,7 +46,7 @@ impl Resolver for MockResolver {
 
     async fn resolve_object(
         &self,
-        __: Option<r::Value>,
+        _: Option<r::Value>,
         _field: &a::Field,
         _field_definition: &s::Field,
         _object_type: ObjectOrInterface<'_>,
@@ -51,15 +54,15 @@ impl Resolver for MockResolver {
         Ok(r::Value::Null)
     }
 
-    async fn query_permit(&self) -> Result<QueryPermit, QueryExecutionError> {
+    async fn query_permit(&self) -> QueryPermit {
         let permit = Arc::new(tokio::sync::Semaphore::new(1))
             .acquire_owned()
             .await
             .unwrap();
-        Ok(QueryPermit {
+        QueryPermit {
             permit,
             wait: Duration::from_secs(0),
-        })
+        }
     }
 }
 
@@ -112,91 +115,150 @@ fn expected_mock_schema_introspection() -> r::Value {
 /// Execute an introspection query.
 async fn introspection_query(schema: Arc<ApiSchema>, query: &str) -> QueryResult {
     // Create the query
-    let query = Query::new(
-        graphql_parser::parse_query(query).unwrap().into_static(),
-        None,
-        false,
-    );
+    let query = Query::new(q::parse_query(query).unwrap().into_static(), None, false);
 
     // Execute it
     let logger = Logger::root(slog::Discard, o!());
     let options = QueryExecutionOptions {
         resolver: MockResolver,
         deadline: None,
-        max_first: std::u32::MAX,
-        max_skip: std::u32::MAX,
+        max_first: u32::MAX,
+        max_skip: u32::MAX,
         trace: false,
+        log_store: Arc::new(graph::components::log_store::NoOpLogStore),
     };
 
     let result =
         match PreparedQuery::new(&logger, schema, None, query, None, 100, graphql_metrics()) {
             Ok(query) => {
-                Ok(Arc::try_unwrap(execute_query(query, None, None, options).await).unwrap())
+                let (res, _) = execute_query(query, None, None, options).await;
+                Ok(Arc::try_unwrap(res).unwrap())
             }
             Err(e) => Err(e),
         };
     QueryResult::from(result)
 }
 
-/// Compare two values and consider them the same if they are identical with
-/// some special treatment meant to mimic what GraphQL users care about in
-/// the resulting JSON value
-///
-/// (1) Objects are the same if they have the same entries, regardless of
-/// order (the PartialEq implementation for Object also requires entries to
-/// be in the same order which should probably be fixed)
-///
-/// (2) Enums and Strings are the same if they have the same string value
-#[track_caller]
-fn same_value(a: &r::Value, b: &r::Value) -> bool {
+fn compare(a: &r::Value, b: &r::Value, path: &mut Vec<String>) -> Option<(r::Value, r::Value)> {
+    fn different(a: &r::Value, b: &r::Value) -> Option<(r::Value, r::Value)> {
+        Some((a.clone(), b.clone()))
+    }
+
     match a {
-        r::Value::Int(_) | r::Value::Float(_) | r::Value::Boolean(_) | r::Value::Null => a == b,
+        r::Value::Int(_)
+        | r::Value::Float(_)
+        | r::Value::Boolean(_)
+        | r::Value::Null
+        | r::Value::Timestamp(_) => {
+            if a != b {
+                different(a, b)
+            } else {
+                None
+            }
+        }
         r::Value::List(la) => match b {
             r::Value::List(lb) => {
-                if la.len() != lb.len() {
-                    return false;
-                }
-                for i in 0..la.len() {
-                    if !same_value(&la[i], &lb[i]) {
-                        return false;
+                for (i, (va, vb)) in la.iter().zip(lb.iter()).enumerate() {
+                    path.push(i.to_string());
+                    let res = compare(va, vb, path);
+                    if res.is_some() {
+                        return res;
                     }
+                    path.pop();
+                }
+                if la.len() > lb.len() {
+                    path.push(lb.len().to_string());
+                    return different(&la[lb.len()], &r::Value::Null);
                 }
-                return true;
+                if lb.len() > la.len() {
+                    path.push(la.len().to_string());
+                    return different(&r::Value::Null, &lb[la.len()]);
+                }
+                None
             }
-            _ => false,
+            _ => different(a, b),
         },
         r::Value::String(sa) | r::Value::Enum(sa) => match b {
-            r::Value::String(sb) | r::Value::Enum(sb) => sa == sb,
-            _ => {
-                println!("STRING/ENUM: {} != {}", sa, b);
-                false
+            r::Value::String(sb) | r::Value::Enum(sb) => {
+                if sa != sb {
+                    different(a, b)
+                } else {
+                    None
+                }
             }
+            _ => different(a, b),
         },
         r::Value::Object(oa) => match b {
             r::Value::Object(ob) => {
                 if oa.len() != ob.len() {
-                    return false;
+                    return different(a, b);
                 }
                 for (ka, va) in oa.iter() {
                     match ob.get(ka) {
                         Some(vb) => {
-                            if !same_value(va, vb) {
-                                return false;
+                            path.push(ka.to_string());
+                            let res = compare(va, vb, path);
+                            if res.is_some() {
+                                return res;
                             }
+                            path.pop();
                         }
                         None => {
-                            return false;
+                            return different(va, &r::Value::Null);
                         }
                     }
                 }
-                return true;
+                None
             }
-            _ => false,
+            _ => different(a, b),
         },
     }
 }
 
-#[tokio::test]
+/// Compare two values and consider them the same if they are identical with
+/// some special treatment meant to mimic what GraphQL users care about in
+/// the resulting JSON value
+///
+/// (1) Objects are the same if they have the same entries, regardless of
+/// order (the PartialEq implementation for Object also requires entries to
+/// be in the same order which should probably be fixed)
+///
+/// (2) Enums and Strings are the same if they have the same string value
+#[track_caller]
+fn same_value(a: &r::Value, b: &r::Value) -> bool {
+    let mut path = Vec::new();
+    if let Some((da, db)) = compare(a, b, &mut path) {
+        println!("Query results differ at path {}", path.join("."));
+        println!("Value A: {da}");
+        println!("Value B: {db}");
+        maybe_save(a);
+        false
+    } else {
+        true
+    }
+}
+
+/// Save `data` into `/tmp/introspection.json` if the environment variable
+/// `INTROSPECTION_SAVE` is set. When one of the tests in this file fails,
+/// use this to save the test output.
+///
+/// It's useful to reformat both that file and the expected value with `jq
+/// .` and then run `diff -u` on the formatted files to see where the
+/// discrepancies are, something like
+///
+/// ```bash
+/// diff -u <(jq . < store/test-store/tests/graphql/mock_introspection.json) \
+///         <(jq . /tmp/introspection.json)
+/// ```
+fn maybe_save(data: &r::Value) {
+    if std::env::var("INTROSPECTION_SAVE").is_ok() {
+        let json = serde_json::to_string_pretty(&data).unwrap();
+        let mut fp = File::create("/tmp/introspection.json").unwrap();
+        writeln!(fp, "{json}").unwrap();
+    }
+}
+
+#[graph::test]
 async fn satisfies_graphiql_introspection_query_without_fragments() {
     let result = introspection_query(
         mock_schema(),
@@ -448,7 +510,7 @@ async fn satisfies_graphiql_introspection_query_without_fragments() {
     assert!(same_value(&data, &expected_mock_schema_introspection()));
 }
 
-#[tokio::test]
+#[graph::test]
 async fn satisfies_graphiql_introspection_query_with_fragments() {
     let result = introspection_query(
         mock_schema(),
@@ -758,7 +820,7 @@ type Parameter @entity {
 }
 ";
 
-#[tokio::test]
+#[graph::test]
 async fn successfully_runs_introspection_query_against_complex_schema() {
     let schema = api_schema(COMPLEX_SCHEMA, "complexschema");
 
@@ -822,6 +884,8 @@ async fn successfully_runs_introspection_query_against_complex_schema() {
           description
           type { ...TypeRef }
           defaultValue
+          isDeprecated
+          deprecationReason
         }
 
         fragment TypeRef on __Type {
@@ -863,7 +927,7 @@ async fn successfully_runs_introspection_query_against_complex_schema() {
     assert!(!result.has_errors(), "{:#?}", result);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn introspection_possible_types() {
     let schema = api_schema(COMPLEX_SCHEMA, "complexschema");
 
diff --git a/store/test-store/tests/graphql/mock_introspection.json b/store/test-store/tests/graphql/mock_introspection.json
index 3e4cf7ef194..802c423bf63 100644
--- a/store/test-store/tests/graphql/mock_introspection.json
+++ b/store/test-store/tests/graphql/mock_introspection.json
@@ -1,169 +1,350 @@
 {
-    "__schema": {
-      "queryType": {
-        "name": "Query"
+  "__schema": {
+    "queryType": {
+      "name": "Query"
+    },
+    "mutationType": null,
+    "subscriptionType": null,
+    "types": [
+      {
+        "kind": "ENUM",
+        "name": "Aggregation_current",
+        "description": "Indicates whether the current, partially filled bucket should be included in the response. Defaults to `exclude`",
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": [
+          {
+            "name": "exclude",
+            "description": "Exclude the current, partially filled bucket from the response",
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "include",
+            "description": "Include the current, partially filled bucket in the response",
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "possibleTypes": null
       },
-      "mutationType": null,
-      "subscriptionType": {
-        "name": "Subscription"
+      {
+        "kind": "ENUM",
+        "name": "Aggregation_interval",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": [
+          {
+            "name": "hour",
+            "description": null,
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "day",
+            "description": null,
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "possibleTypes": null
       },
-      "types": [
-        {
-          "kind": "SCALAR",
-          "name": "BigDecimal",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "SCALAR",
-          "name": "BigInt",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "INPUT_OBJECT",
-          "name": "BlockChangedFilter",
-          "description": null,
-          "fields": null,
-          "inputFields": [
-            {
-              "name": "number_gte",
-              "description": null,
-              "type": {
-                "kind": "NON_NULL",
-                "name": null,
-                "ofType": {
-                  "kind": "SCALAR",
-                  "name": "Int",
-                  "ofType": null
-                }
-              },
-              "defaultValue": null
-            }
-          ],
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "INPUT_OBJECT",
-          "name": "Block_height",
-          "description": null,
-          "fields": null,
-          "inputFields": [
-            {
-              "name": "hash",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "Bytes",
-                "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "number",
-              "description": null,
-              "type": {
+      {
+        "kind": "SCALAR",
+        "name": "BigDecimal",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "BigInt",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "INPUT_OBJECT",
+        "name": "BlockChangedFilter",
+        "description": null,
+        "fields": null,
+        "inputFields": [
+          {
+            "name": "number_gte",
+            "description": null,
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
                 "name": "Int",
                 "ofType": null
-              },
-              "defaultValue": null
+              }
+            },
+            "defaultValue": null
+          }
+        ],
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "INPUT_OBJECT",
+        "name": "Block_height",
+        "description": null,
+        "fields": null,
+        "inputFields": [
+          {
+            "name": "hash",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "Bytes",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "number",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "Int",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "number_gte",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "Int",
+              "ofType": null
             },
-            {
-              "name": "number_gte",
-              "description": null,
-              "type": {
+            "defaultValue": null
+          }
+        ],
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "Boolean",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "Bytes",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "Float",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "ID",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "Int",
+        "description": "4 bytes signed integer",
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "Int8",
+        "description": "8 bytes signed integer",
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "ENUM",
+        "name": "LogLevel",
+        "description": "The severity level of a log entry.\nLog levels are ordered from most to least severe: CRITICAL > ERROR > WARNING > INFO > DEBUG",
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": [
+          {
+            "name": "CRITICAL",
+            "description": "Critical errors that require immediate attention",
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "ERROR",
+            "description": "Error conditions that indicate a failure",
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "WARNING",
+            "description": "Warning conditions that may require attention",
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "INFO",
+            "description": "Informational messages about normal operations",
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "DEBUG",
+            "description": "Detailed diagnostic information for debugging",
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "possibleTypes": null
+      },
+      {
+        "kind": "INTERFACE",
+        "name": "Node",
+        "description": null,
+        "fields": [
+          {
+            "name": "id",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
-                "name": "Int",
+                "name": "ID",
                 "ofType": null
-              },
-              "defaultValue": null
-            }
-          ],
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "SCALAR",
-          "name": "Boolean",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "SCALAR",
-          "name": "Bytes",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "SCALAR",
-          "name": "Float",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "SCALAR",
-          "name": "ID",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "SCALAR",
-          "name": "Int",
-          "description": "4 bytes signed integer\n",
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "SCALAR",
-          "name": "Int8",
-          "description": "8 bytes signed integer\n",
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "INTERFACE",
-          "name": "Node",
-          "description": null,
-          "fields": [
-            {
-              "name": "id",
-              "description": null,
-              "args": [],
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": [
+          {
+            "kind": "OBJECT",
+            "name": "User",
+            "ofType": null
+          }
+        ]
+      },
+      {
+        "kind": "INPUT_OBJECT",
+        "name": "Node_filter",
+        "description": null,
+        "fields": null,
+        "inputFields": [
+          {
+            "name": "id",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_not",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_gt",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_lt",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_gte",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_lte",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_in",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
                 "kind": "NON_NULL",
                 "name": null,
                 "ofType": {
@@ -171,95 +352,124 @@
                   "name": "ID",
                   "ofType": null
                 }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": [
-            {
-              "kind": "OBJECT",
-              "name": "User",
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_not_in",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "NON_NULL",
+                "name": null,
+                "ofType": {
+                  "kind": "SCALAR",
+                  "name": "ID",
+                  "ofType": null
+                }
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "_change_block",
+            "description": "Filter for the block changed event.",
+            "type": {
+              "kind": "INPUT_OBJECT",
+              "name": "BlockChangedFilter",
               "ofType": null
-            }
-          ]
-        },
-        {
-          "kind": "INPUT_OBJECT",
-          "name": "Node_filter",
-          "description": null,
-          "fields": null,
-          "inputFields": [
-            {
-              "name": "id",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
-                "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "id_not",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
-                "ofType": null
-              },
-              "defaultValue": null
             },
-            {
-              "name": "id_gt",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
-                "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "id_lt",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
-                "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "id_gte",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
+            "defaultValue": null
+          },
+          {
+            "name": "and",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "INPUT_OBJECT",
+                "name": "Node_filter",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "id_lte",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "or",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "INPUT_OBJECT",
+                "name": "Node_filter",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "id_in",
-              "description": null,
-              "type": {
-                "kind": "LIST",
-                "name": null,
-                "ofType": {
+              }
+            },
+            "defaultValue": null
+          }
+        ],
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "ENUM",
+        "name": "Node_orderBy",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": [
+          {
+            "name": "id",
+            "description": null,
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "possibleTypes": null
+      },
+      {
+        "kind": "ENUM",
+        "name": "OrderDirection",
+        "description": "Defines the order direction, either ascending or descending",
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": [
+          {
+            "name": "asc",
+            "description": null,
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "desc",
+            "description": null,
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "possibleTypes": null
+      },
+      {
+        "kind": "OBJECT",
+        "name": "Query",
+        "description": null,
+        "fields": [
+          {
+            "name": "user",
+            "description": null,
+            "args": [
+              {
+                "name": "id",
+                "description": null,
+                "type": {
                   "kind": "NON_NULL",
                   "name": null,
                   "ofType": {
@@ -267,822 +477,596 @@
                     "name": "ID",
                     "ofType": null
                   }
-                }
+                },
+                "defaultValue": null
               },
-              "defaultValue": null
-            },
-            {
-              "name": "id_not_in",
-              "description": null,
-              "type": {
-                "kind": "LIST",
-                "name": null,
-                "ofType": {
+              {
+                "name": "block",
+                "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
+                "type": {
+                  "kind": "INPUT_OBJECT",
+                  "name": "Block_height",
+                  "ofType": null
+                },
+                "defaultValue": null
+              },
+              {
+                "name": "subgraphError",
+                "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
+                "type": {
                   "kind": "NON_NULL",
                   "name": null,
                   "ofType": {
-                    "kind": "SCALAR",
-                    "name": "ID",
+                    "kind": "ENUM",
+                    "name": "_SubgraphErrorPolicy_",
                     "ofType": null
                   }
-                }
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "_change_block",
-              "description": "Filter for the block changed event.",
-              "type": {
-                "kind": "INPUT_OBJECT",
-                "name": "BlockChangedFilter",
-                "ofType": null
-              },
-              "defaultValue": null
+                },
+                "defaultValue": "deny"
+              }
+            ],
+            "type": {
+              "kind": "OBJECT",
+              "name": "User",
+              "ofType": null
             },
-            {
-              "name": "and",
-              "description": null,
-              "type": {
-                "kind": "LIST",
-                "name": null,
-                "ofType": {
-                  "kind": "INPUT_OBJECT",
-                  "name": "Node_filter",
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "users",
+            "description": null,
+            "args": [
+              {
+                "name": "skip",
+                "description": null,
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "Int",
                   "ofType": null
-                }
+                },
+                "defaultValue": "0"
               },
-              "defaultValue": null
-            },
-            {
-              "name": "or",
-              "description": null,
-              "type": {
-                "kind": "LIST",
-                "name": null,
-                "ofType": {
-                  "kind": "INPUT_OBJECT",
-                  "name": "Node_filter",
+              {
+                "name": "first",
+                "description": null,
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "Int",
                   "ofType": null
-                }
-              },
-              "defaultValue": null
-            }
-          ],
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "ENUM",
-          "name": "Node_orderBy",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": [
-            {
-              "name": "id",
-              "description": null,
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "possibleTypes": null
-        },
-        {
-          "kind": "ENUM",
-          "name": "OrderDirection",
-          "description": "Defines the order direction, either ascending or descending",
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": [
-            {
-              "name": "asc",
-              "description": null,
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "desc",
-              "description": null,
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "possibleTypes": null
-        },
-        {
-          "kind": "OBJECT",
-          "name": "Query",
-          "description": null,
-          "fields": [
-            {
-              "name": "user",
-              "description": null,
-              "args": [
-                {
-                  "name": "id",
-                  "description": null,
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "SCALAR",
-                      "name": "ID",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": null
                 },
-                {
-                  "name": "block",
-                  "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Block_height",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": "100"
+              },
+              {
+                "name": "orderBy",
+                "description": null,
+                "type": {
+                  "kind": "ENUM",
+                  "name": "User_orderBy",
+                  "ofType": null
                 },
-                {
-                  "name": "subgraphError",
-                  "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "ENUM",
-                      "name": "_SubgraphErrorPolicy_",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": "deny"
-                }
-              ],
-              "type": {
-                "kind": "OBJECT",
-                "name": "User",
-                "ofType": null
+                "defaultValue": null
               },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "users",
-              "description": null,
-              "args": [
-                {
-                  "name": "skip",
-                  "description": null,
-                  "type": {
-                    "kind": "SCALAR",
-                    "name": "Int",
-                    "ofType": null
-                  },
-                  "defaultValue": "0"
+              {
+                "name": "orderDirection",
+                "description": null,
+                "type": {
+                  "kind": "ENUM",
+                  "name": "OrderDirection",
+                  "ofType": null
                 },
-                {
-                  "name": "first",
-                  "description": null,
-                  "type": {
-                    "kind": "SCALAR",
-                    "name": "Int",
-                    "ofType": null
-                  },
-                  "defaultValue": "100"
+                "defaultValue": null
+              },
+              {
+                "name": "where",
+                "description": null,
+                "type": {
+                  "kind": "INPUT_OBJECT",
+                  "name": "User_filter",
+                  "ofType": null
                 },
-                {
-                  "name": "orderBy",
-                  "description": null,
-                  "type": {
-                    "kind": "ENUM",
-                    "name": "User_orderBy",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": null
+              },
+              {
+                "name": "block",
+                "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
+                "type": {
+                  "kind": "INPUT_OBJECT",
+                  "name": "Block_height",
+                  "ofType": null
                 },
-                {
-                  "name": "orderDirection",
-                  "description": null,
-                  "type": {
+                "defaultValue": null
+              },
+              {
+                "name": "subgraphError",
+                "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
+                "type": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
                     "kind": "ENUM",
-                    "name": "OrderDirection",
-                    "ofType": null
-                  },
-                  "defaultValue": null
-                },
-                {
-                  "name": "where",
-                  "description": null,
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "User_filter",
+                    "name": "_SubgraphErrorPolicy_",
                     "ofType": null
-                  },
-                  "defaultValue": null
-                },
-                {
-                  "name": "block",
-                  "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Block_height",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                  }
                 },
-                {
-                  "name": "subgraphError",
-                  "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "ENUM",
-                      "name": "_SubgraphErrorPolicy_",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": "deny"
-                }
-              ],
-              "type": {
-                "kind": "NON_NULL",
+                "defaultValue": "deny"
+              }
+            ],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "LIST",
                 "name": null,
                 "ofType": {
-                  "kind": "LIST",
+                  "kind": "NON_NULL",
                   "name": null,
                   "ofType": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "OBJECT",
-                      "name": "User",
-                      "ofType": null
-                    }
-                  }
-                }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "node",
-              "description": null,
-              "args": [
-                {
-                  "name": "id",
-                  "description": null,
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "SCALAR",
-                      "name": "ID",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": null
-                },
-                {
-                  "name": "block",
-                  "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Block_height",
+                    "kind": "OBJECT",
+                    "name": "User",
                     "ofType": null
-                  },
-                  "defaultValue": null
-                },
-                {
-                  "name": "subgraphError",
-                  "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "ENUM",
-                      "name": "_SubgraphErrorPolicy_",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": "deny"
+                  }
                 }
-              ],
-              "type": {
-                "kind": "INTERFACE",
-                "name": "Node",
-                "ofType": null
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "nodes",
-              "description": null,
-              "args": [
-                {
-                  "name": "skip",
-                  "description": null,
-                  "type": {
-                    "kind": "SCALAR",
-                    "name": "Int",
-                    "ofType": null
-                  },
-                  "defaultValue": "0"
-                },
-                {
-                  "name": "first",
-                  "description": null,
-                  "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "node",
+            "description": null,
+            "args": [
+              {
+                "name": "id",
+                "description": null,
+                "type": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
                     "kind": "SCALAR",
-                    "name": "Int",
+                    "name": "ID",
                     "ofType": null
-                  },
-                  "defaultValue": "100"
+                  }
                 },
-                {
-                  "name": "orderBy",
-                  "description": null,
-                  "type": {
-                    "kind": "ENUM",
-                    "name": "Node_orderBy",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": null
+              },
+              {
+                "name": "block",
+                "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
+                "type": {
+                  "kind": "INPUT_OBJECT",
+                  "name": "Block_height",
+                  "ofType": null
                 },
-                {
-                  "name": "orderDirection",
-                  "description": null,
-                  "type": {
+                "defaultValue": null
+              },
+              {
+                "name": "subgraphError",
+                "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
+                "type": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
                     "kind": "ENUM",
-                    "name": "OrderDirection",
+                    "name": "_SubgraphErrorPolicy_",
                     "ofType": null
-                  },
-                  "defaultValue": null
-                },
-                {
-                  "name": "where",
-                  "description": null,
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Node_filter",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                  }
                 },
-                {
-                  "name": "block",
-                  "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Block_height",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": "deny"
+              }
+            ],
+            "type": {
+              "kind": "INTERFACE",
+              "name": "Node",
+              "ofType": null
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "nodes",
+            "description": null,
+            "args": [
+              {
+                "name": "skip",
+                "description": null,
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "Int",
+                  "ofType": null
                 },
-                {
-                  "name": "subgraphError",
-                  "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "ENUM",
-                      "name": "_SubgraphErrorPolicy_",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": "deny"
-                }
-              ],
-              "type": {
-                "kind": "NON_NULL",
-                "name": null,
-                "ofType": {
-                  "kind": "LIST",
-                  "name": null,
-                  "ofType": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "INTERFACE",
-                      "name": "Node",
-                      "ofType": null
-                    }
-                  }
-                }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "_meta",
-              "description": "Access to subgraph metadata",
-              "args": [
-                {
-                  "name": "block",
-                  "description": null,
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Block_height",
-                    "ofType": null
-                  },
-                  "defaultValue": null
-                }
-              ],
-              "type": {
-                "kind": "OBJECT",
-                "name": "_Meta_",
-                "ofType": null
+                "defaultValue": "0"
               },
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "inputFields": null,
-          "interfaces": [],
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "ENUM",
-          "name": "Role",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": [
-            {
-              "name": "USER",
-              "description": null,
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "ADMIN",
-              "description": null,
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "possibleTypes": null
-        },
-        {
-          "kind": "SCALAR",
-          "name": "String",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "OBJECT",
-          "name": "Subscription",
-          "description": null,
-          "fields": [
-            {
-              "name": "user",
-              "description": null,
-              "args": [
-                {
-                  "name": "id",
-                  "description": null,
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "SCALAR",
-                      "name": "ID",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": null
+              {
+                "name": "first",
+                "description": null,
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "Int",
+                  "ofType": null
                 },
-                {
-                  "name": "block",
-                  "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Block_height",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": "100"
+              },
+              {
+                "name": "orderBy",
+                "description": null,
+                "type": {
+                  "kind": "ENUM",
+                  "name": "Node_orderBy",
+                  "ofType": null
                 },
-                {
-                  "name": "subgraphError",
-                  "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "ENUM",
-                      "name": "_SubgraphErrorPolicy_",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": "deny"
-                }
-              ],
-              "type": {
-                "kind": "OBJECT",
-                "name": "User",
-                "ofType": null
+                "defaultValue": null
               },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "users",
-              "description": null,
-              "args": [
-                {
-                  "name": "skip",
-                  "description": null,
-                  "type": {
-                    "kind": "SCALAR",
-                    "name": "Int",
-                    "ofType": null
-                  },
-                  "defaultValue": "0"
+              {
+                "name": "orderDirection",
+                "description": null,
+                "type": {
+                  "kind": "ENUM",
+                  "name": "OrderDirection",
+                  "ofType": null
                 },
-                {
-                  "name": "first",
-                  "description": null,
-                  "type": {
-                    "kind": "SCALAR",
-                    "name": "Int",
-                    "ofType": null
-                  },
-                  "defaultValue": "100"
+                "defaultValue": null
+              },
+              {
+                "name": "where",
+                "description": null,
+                "type": {
+                  "kind": "INPUT_OBJECT",
+                  "name": "Node_filter",
+                  "ofType": null
                 },
-                {
-                  "name": "orderBy",
-                  "description": null,
-                  "type": {
-                    "kind": "ENUM",
-                    "name": "User_orderBy",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": null
+              },
+              {
+                "name": "block",
+                "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
+                "type": {
+                  "kind": "INPUT_OBJECT",
+                  "name": "Block_height",
+                  "ofType": null
                 },
-                {
-                  "name": "orderDirection",
-                  "description": null,
-                  "type": {
+                "defaultValue": null
+              },
+              {
+                "name": "subgraphError",
+                "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
+                "type": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
                     "kind": "ENUM",
-                    "name": "OrderDirection",
-                    "ofType": null
-                  },
-                  "defaultValue": null
-                },
-                {
-                  "name": "where",
-                  "description": null,
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "User_filter",
-                    "ofType": null
-                  },
-                  "defaultValue": null
-                },
-                {
-                  "name": "block",
-                  "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Block_height",
+                    "name": "_SubgraphErrorPolicy_",
                     "ofType": null
-                  },
-                  "defaultValue": null
+                  }
                 },
-                {
-                  "name": "subgraphError",
-                  "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "ENUM",
-                      "name": "_SubgraphErrorPolicy_",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": "deny"
-                }
-              ],
-              "type": {
-                "kind": "NON_NULL",
+                "defaultValue": "deny"
+              }
+            ],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "LIST",
                 "name": null,
                 "ofType": {
-                  "kind": "LIST",
+                  "kind": "NON_NULL",
                   "name": null,
                   "ofType": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "OBJECT",
-                      "name": "User",
-                      "ofType": null
-                    }
+                    "kind": "INTERFACE",
+                    "name": "Node",
+                    "ofType": null
                   }
                 }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "node",
-              "description": null,
-              "args": [
-                {
-                  "name": "id",
-                  "description": null,
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "SCALAR",
-                      "name": "ID",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "_meta",
+            "description": "Access to subgraph metadata",
+            "args": [
+              {
+                "name": "block",
+                "description": null,
+                "type": {
+                  "kind": "INPUT_OBJECT",
+                  "name": "Block_height",
+                  "ofType": null
                 },
-                {
-                  "name": "block",
-                  "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Block_height",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": null
+              }
+            ],
+            "type": {
+              "kind": "OBJECT",
+              "name": "_Meta_",
+              "ofType": null
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "_logs",
+            "description": "Query execution logs emitted by the subgraph during indexing. Results are sorted by timestamp in descending order (newest first).",
+            "args": [
+              {
+                "name": "level",
+                "description": "Filter logs by severity level. Only logs at this level will be returned.",
+                "type": {
+                  "kind": "ENUM",
+                  "name": "LogLevel",
+                  "ofType": null
                 },
-                {
-                  "name": "subgraphError",
-                  "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "ENUM",
-                      "name": "_SubgraphErrorPolicy_",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": "deny"
-                }
-              ],
-              "type": {
-                "kind": "INTERFACE",
-                "name": "Node",
-                "ofType": null
+                "defaultValue": null
               },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "nodes",
-              "description": null,
-              "args": [
-                {
-                  "name": "skip",
-                  "description": null,
-                  "type": {
-                    "kind": "SCALAR",
-                    "name": "Int",
-                    "ofType": null
-                  },
-                  "defaultValue": "0"
+              {
+                "name": "from",
+                "description": "Filter logs from this timestamp onwards (inclusive). Must be in RFC3339 format (e.g., '2024-01-15T10:30:00Z').",
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "String",
+                  "ofType": null
                 },
-                {
-                  "name": "first",
-                  "description": null,
-                  "type": {
-                    "kind": "SCALAR",
-                    "name": "Int",
-                    "ofType": null
-                  },
-                  "defaultValue": "100"
+                "defaultValue": null
+              },
+              {
+                "name": "to",
+                "description": "Filter logs until this timestamp (inclusive). Must be in RFC3339 format (e.g., '2024-01-15T23:59:59Z').",
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "String",
+                  "ofType": null
                 },
-                {
-                  "name": "orderBy",
-                  "description": null,
-                  "type": {
-                    "kind": "ENUM",
-                    "name": "Node_orderBy",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": null
+              },
+              {
+                "name": "search",
+                "description": "Search for logs containing this text in the message. Case-insensitive substring match. Maximum length: 1000 characters.",
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "String",
+                  "ofType": null
                 },
-                {
-                  "name": "orderDirection",
-                  "description": null,
-                  "type": {
-                    "kind": "ENUM",
-                    "name": "OrderDirection",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": null
+              },
+              {
+                "name": "first",
+                "description": "Maximum number of logs to return. Default: 100, Maximum: 1000.",
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "Int",
+                  "ofType": null
                 },
-                {
-                  "name": "where",
-                  "description": null,
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Node_filter",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": "100"
+              },
+              {
+                "name": "skip",
+                "description": "Number of logs to skip (for pagination). Default: 0, Maximum: 10000.",
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "Int",
+                  "ofType": null
                 },
-                {
-                  "name": "block",
-                  "description": "The block at which the query should be executed. Can either be a `{ hash: Bytes }` value containing a block hash, a `{ number: Int }` containing the block number, or a `{ number_gte: Int }` containing the minimum block number. In the case of `number_gte`, the query will be executed on the latest block only if the subgraph has progressed to or past the minimum block number. Defaults to the latest block when omitted.",
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Block_height",
-                    "ofType": null
-                  },
-                  "defaultValue": null
+                "defaultValue": "0"
+              },
+              {
+                "name": "orderDirection",
+                "description": "Sort direction for results. Default: desc (newest first).",
+                "type": {
+                  "kind": "ENUM",
+                  "name": "OrderDirection",
+                  "ofType": null
                 },
-                {
-                  "name": "subgraphError",
-                  "description": "Set to `allow` to receive data even if the subgraph has skipped over errors while syncing.",
-                  "type": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "ENUM",
-                      "name": "_SubgraphErrorPolicy_",
-                      "ofType": null
-                    }
-                  },
-                  "defaultValue": "deny"
-                }
-              ],
-              "type": {
-                "kind": "NON_NULL",
+                "defaultValue": "desc"
+              }
+            ],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "LIST",
                 "name": null,
                 "ofType": {
-                  "kind": "LIST",
+                  "kind": "NON_NULL",
                   "name": null,
                   "ofType": {
-                    "kind": "NON_NULL",
-                    "name": null,
-                    "ofType": {
-                      "kind": "INTERFACE",
-                      "name": "Node",
-                      "ofType": null
-                    }
-                  }
-                }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "_meta",
-              "description": "Access to subgraph metadata",
-              "args": [
-                {
-                  "name": "block",
-                  "description": null,
-                  "type": {
-                    "kind": "INPUT_OBJECT",
-                    "name": "Block_height",
+                    "kind": "OBJECT",
+                    "name": "_Log_",
                     "ofType": null
-                  },
-                  "defaultValue": null
+                  }
                 }
-              ],
-              "type": {
-                "kind": "OBJECT",
-                "name": "_Meta_",
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "inputFields": null,
+        "interfaces": [],
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "ENUM",
+        "name": "Role",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": [
+          {
+            "name": "USER",
+            "description": null,
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "ADMIN",
+            "description": null,
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "String",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "SCALAR",
+        "name": "Timestamp",
+        "description": "A string representation of microseconds UNIX timestamp (16 digits)",
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "OBJECT",
+        "name": "User",
+        "description": null,
+        "fields": [
+          {
+            "name": "id",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "ID",
                 "ofType": null
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "inputFields": null,
-          "interfaces": [],
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "OBJECT",
-          "name": "User",
-          "description": null,
-          "fields": [
-            {
-              "name": "id",
-              "description": null,
-              "args": [],
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "name",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "role",
+            "description": null,
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "ENUM",
+                "name": "Role",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "inputFields": null,
+        "interfaces": [
+          {
+            "kind": "INTERFACE",
+            "name": "Node",
+            "ofType": null
+          }
+        ],
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "INPUT_OBJECT",
+        "name": "User_filter",
+        "description": null,
+        "fields": null,
+        "inputFields": [
+          {
+            "name": "id",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_not",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_gt",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_lt",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_gte",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_lte",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "ID",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_in",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
                 "kind": "NON_NULL",
                 "name": null,
                 "ofType": {
@@ -1090,15 +1074,95 @@
                   "name": "ID",
                   "ofType": null
                 }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "name",
-              "description": null,
-              "args": [],
-              "type": {
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "id_not_in",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "NON_NULL",
+                "name": null,
+                "ofType": {
+                  "kind": "SCALAR",
+                  "name": "ID",
+                  "ofType": null
+                }
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_not",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_gt",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_lt",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_gte",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_lte",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_in",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
                 "kind": "NON_NULL",
                 "name": null,
                 "ofType": {
@@ -1106,742 +1170,779 @@
                   "name": "String",
                   "ofType": null
                 }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "role",
-              "description": null,
-              "args": [],
-              "type": {
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_in",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
                 "kind": "NON_NULL",
                 "name": null,
                 "ofType": {
-                  "kind": "ENUM",
-                  "name": "Role",
+                  "kind": "SCALAR",
+                  "name": "String",
                   "ofType": null
                 }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "inputFields": null,
-          "interfaces": [
-            {
-              "kind": "INTERFACE",
-              "name": "Node",
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_contains",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
               "ofType": null
-            }
-          ],
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "INPUT_OBJECT",
-          "name": "User_filter",
-          "description": null,
-          "fields": null,
-          "inputFields": [
-            {
-              "name": "id",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
-                "ofType": null
-              },
-              "defaultValue": null
             },
-            {
-              "name": "id_not",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_contains_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "id_gt",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_contains",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "id_lt",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_contains_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "id_gte",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_starts_with",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "id_lte",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "ID",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_starts_with_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "id_in",
-              "description": null,
-              "type": {
-                "kind": "LIST",
-                "name": null,
-                "ofType": {
-                  "kind": "NON_NULL",
-                  "name": null,
-                  "ofType": {
-                    "kind": "SCALAR",
-                    "name": "ID",
-                    "ofType": null
-                  }
-                }
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_starts_with",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "id_not_in",
-              "description": null,
-              "type": {
-                "kind": "LIST",
-                "name": null,
-                "ofType": {
-                  "kind": "NON_NULL",
-                  "name": null,
-                  "ofType": {
-                    "kind": "SCALAR",
-                    "name": "ID",
-                    "ofType": null
-                  }
-                }
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_starts_with_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "name",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "String",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_ends_with",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "name_not",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "String",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_ends_with_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "name_gt",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "String",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_ends_with",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "name_lt",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "String",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_ends_with_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "name_gte",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "String",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "role",
+            "description": null,
+            "type": {
+              "kind": "ENUM",
+              "name": "Role",
+              "ofType": null
             },
-            {
-              "name": "name_lte",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "String",
-                "ofType": null
-              },
-              "defaultValue": null
+            "defaultValue": null
+          },
+          {
+            "name": "role_not",
+            "description": null,
+            "type": {
+              "kind": "ENUM",
+              "name": "Role",
+              "ofType": null
             },
-            {
-              "name": "name_in",
-              "description": null,
-              "type": {
-                "kind": "LIST",
+            "defaultValue": null
+          },
+          {
+            "name": "role_in",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "NON_NULL",
                 "name": null,
                 "ofType": {
-                  "kind": "NON_NULL",
-                  "name": null,
-                  "ofType": {
-                    "kind": "SCALAR",
-                    "name": "String",
-                    "ofType": null
-                  }
+                  "kind": "ENUM",
+                  "name": "Role",
+                  "ofType": null
                 }
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "name_not_in",
-              "description": null,
-              "type": {
-                "kind": "LIST",
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "role_not_in",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "NON_NULL",
                 "name": null,
                 "ofType": {
-                  "kind": "NON_NULL",
-                  "name": null,
-                  "ofType": {
-                    "kind": "SCALAR",
-                    "name": "String",
-                    "ofType": null
-                  }
+                  "kind": "ENUM",
+                  "name": "Role",
+                  "ofType": null
                 }
-              },
-              "defaultValue": null
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "_change_block",
+            "description": "Filter for the block changed event.",
+            "type": {
+              "kind": "INPUT_OBJECT",
+              "name": "BlockChangedFilter",
+              "ofType": null
             },
-            {
-              "name": "name_contains",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "String",
+            "defaultValue": null
+          },
+          {
+            "name": "and",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "INPUT_OBJECT",
+                "name": "User_filter",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "name_contains_nocase",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "String",
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "or",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "INPUT_OBJECT",
+                "name": "User_filter",
                 "ofType": null
-              },
-              "defaultValue": null
+              }
+            },
+            "defaultValue": null
+          }
+        ],
+        "interfaces": null,
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "ENUM",
+        "name": "User_orderBy",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": [
+          {
+            "name": "id",
+            "description": null,
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "name",
+            "description": null,
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "role",
+            "description": null,
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "possibleTypes": null
+      },
+      {
+        "kind": "OBJECT",
+        "name": "_Block_",
+        "description": null,
+        "fields": [
+          {
+            "name": "hash",
+            "description": "The hash of the block",
+            "args": [],
+            "type": {
+              "kind": "SCALAR",
+              "name": "Bytes",
+              "ofType": null
             },
-            {
-              "name": "name_not_contains",
-              "description": null,
-              "type": {
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "number",
+            "description": "The block number",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
-                "name": "String",
+                "name": "Int",
                 "ofType": null
-              },
-              "defaultValue": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "timestamp",
+            "description": "Integer representation of the timestamp stored in blocks for the chain",
+            "args": [],
+            "type": {
+              "kind": "SCALAR",
+              "name": "Int",
+              "ofType": null
             },
-            {
-              "name": "name_not_contains_nocase",
-              "description": null,
-              "type": {
-                "kind": "SCALAR",
-                "name": "String",
-                "ofType": null
-              },
-              "defaultValue": null
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "parentHash",
+            "description": "The hash of the parent block",
+            "args": [],
+            "type": {
+              "kind": "SCALAR",
+              "name": "Bytes",
+              "ofType": null
             },
-            {
-              "name": "name_starts_with",
-              "description": null,
-              "type": {
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "inputFields": null,
+        "interfaces": [],
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "OBJECT",
+        "name": "_LogArgument_",
+        "description": "A key-value pair of additional data associated with a log entry.\nThese correspond to arguments passed to the log function in the subgraph code.",
+        "fields": [
+          {
+            "name": "key",
+            "description": "The parameter name",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
                 "name": "String",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "name_starts_with_nocase",
-              "description": null,
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "value",
+            "description": "The parameter value, serialized as a string",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
                 "name": "String",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "name_not_starts_with",
-              "description": null,
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "inputFields": null,
+        "interfaces": [],
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "OBJECT",
+        "name": "_LogMeta_",
+        "description": "Source code location metadata for a log entry.\nIndicates where in the subgraph's AssemblyScript code the log statement was executed.",
+        "fields": [
+          {
+            "name": "module",
+            "description": "The module or file path where the log was emitted",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
                 "name": "String",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "name_not_starts_with_nocase",
-              "description": null,
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "line",
+            "description": "The line number in the source file",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
-                "name": "String",
+                "name": "Int",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "name_ends_with",
-              "description": null,
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "column",
+            "description": "The column number in the source file",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
-                "name": "String",
+                "name": "Int",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "name_ends_with_nocase",
-              "description": null,
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "inputFields": null,
+        "interfaces": [],
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "OBJECT",
+        "name": "_Log_",
+        "description": "A log entry emitted by a subgraph during indexing.\nLogs can be generated by the subgraph's AssemblyScript code using the `log.*` functions.",
+        "fields": [
+          {
+            "name": "id",
+            "description": "Unique identifier for this log entry",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
                 "name": "String",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "name_not_ends_with",
-              "description": null,
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "subgraphId",
+            "description": "The deployment hash of the subgraph that emitted this log",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
                 "name": "String",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "name_not_ends_with_nocase",
-              "description": null,
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "timestamp",
+            "description": "The timestamp when the log was emitted, in RFC3339 format (e.g., '2024-01-15T10:30:00Z')",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
                 "name": "String",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "role",
-              "description": null,
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "level",
+            "description": "The severity level of the log entry",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "ENUM",
-                "name": "Role",
+                "name": "LogLevel",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "role_not",
-              "description": null,
-              "type": {
-                "kind": "ENUM",
-                "name": "Role",
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "text",
+            "description": "The log message text",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
                 "ofType": null
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "role_in",
-              "description": null,
-              "type": {
-                "kind": "LIST",
-                "name": null,
-                "ofType": {
-                  "kind": "NON_NULL",
-                  "name": null,
-                  "ofType": {
-                    "kind": "ENUM",
-                    "name": "Role",
-                    "ofType": null
-                  }
-                }
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "role_not_in",
-              "description": null,
-              "type": {
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "arguments",
+            "description": "Additional structured data passed to the log function as key-value pairs",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "LIST",
                 "name": null,
                 "ofType": {
                   "kind": "NON_NULL",
                   "name": null,
                   "ofType": {
-                    "kind": "ENUM",
-                    "name": "Role",
+                    "kind": "OBJECT",
+                    "name": "_LogArgument_",
                     "ofType": null
                   }
                 }
-              },
-              "defaultValue": null
-            },
-            {
-              "name": "_change_block",
-              "description": "Filter for the block changed event.",
-              "type": {
-                "kind": "INPUT_OBJECT",
-                "name": "BlockChangedFilter",
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "meta",
+            "description": "Metadata about the source location in the subgraph code where the log was emitted",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "OBJECT",
+                "name": "_LogMeta_",
                 "ofType": null
-              },
-              "defaultValue": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "inputFields": null,
+        "interfaces": [],
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "OBJECT",
+        "name": "_Meta_",
+        "description": "The type for the top-level _meta field",
+        "fields": [
+          {
+            "name": "block",
+            "description": "Information about a specific subgraph block. The hash of the block\nwill be null if the _meta field has a block constraint that asks for\na block number. It will be filled if the _meta field has no block constraint\nand therefore asks for the latest  block",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "OBJECT",
+                "name": "_Block_",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "deployment",
+            "description": "The deployment ID",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "String",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "hasIndexingErrors",
+            "description": "If `true`, the subgraph encountered indexing errors at some past block",
+            "args": [],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "Boolean",
+                "ofType": null
+              }
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "inputFields": null,
+        "interfaces": [],
+        "enumValues": null,
+        "possibleTypes": null
+      },
+      {
+        "kind": "ENUM",
+        "name": "_SubgraphErrorPolicy_",
+        "description": null,
+        "fields": null,
+        "inputFields": null,
+        "interfaces": null,
+        "enumValues": [
+          {
+            "name": "allow",
+            "description": "Data will be returned even if the subgraph has indexing errors",
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "deny",
+            "description": "If the subgraph has indexing errors, data will be omitted. The default.",
+            "isDeprecated": false,
+            "deprecationReason": null
+          }
+        ],
+        "possibleTypes": null
+      }
+    ],
+    "directives": [
+      {
+        "name": "language",
+        "description": null,
+        "locations": [
+          "FIELD_DEFINITION"
+        ],
+        "args": [
+          {
+            "name": "language",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
             },
-            {
-              "name": "and",
-              "description": null,
-              "type": {
-                "kind": "LIST",
-                "name": null,
-                "ofType": {
-                  "kind": "INPUT_OBJECT",
-                  "name": "User_filter",
-                  "ofType": null
-                }
-              },
-              "defaultValue": null
+            "defaultValue": "\"English\""
+          }
+        ]
+      },
+      {
+        "name": "skip",
+        "description": null,
+        "locations": [
+          "FIELD",
+          "FRAGMENT_SPREAD",
+          "INLINE_FRAGMENT"
+        ],
+        "args": [
+          {
+            "name": "if",
+            "description": null,
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "SCALAR",
+                "name": "Boolean",
+                "ofType": null
+              }
             },
-            {
-              "name": "or",
-              "description": null,
-              "type": {
-                "kind": "LIST",
-                "name": null,
-                "ofType": {
-                  "kind": "INPUT_OBJECT",
-                  "name": "User_filter",
-                  "ofType": null
-                }
-              },
-              "defaultValue": null
-            }
-          ],
-          "interfaces": null,
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "ENUM",
-          "name": "User_orderBy",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": [
-            {
-              "name": "id",
-              "description": null,
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "name",
-              "description": null,
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "role",
-              "description": null,
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "possibleTypes": null
-        },
-        {
-          "kind": "OBJECT",
-          "name": "_Block_",
-          "description": null,
-          "fields": [
-            {
-              "name": "hash",
-              "description": "The hash of the block",
-              "args": [],
-              "type": {
+            "defaultValue": null
+          }
+        ]
+      },
+      {
+        "name": "include",
+        "description": null,
+        "locations": [
+          "FIELD",
+          "FRAGMENT_SPREAD",
+          "INLINE_FRAGMENT"
+        ],
+        "args": [
+          {
+            "name": "if",
+            "description": null,
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
-                "name": "Bytes",
+                "name": "Boolean",
                 "ofType": null
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "number",
-              "description": "The block number",
-              "args": [],
-              "type": {
-                "kind": "NON_NULL",
-                "name": null,
-                "ofType": {
-                  "kind": "SCALAR",
-                  "name": "Int",
-                  "ofType": null
-                }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "timestamp",
-              "description": "Integer representation of the timestamp stored in blocks for the chain",
-              "args": [],
-              "type": {
+              }
+            },
+            "defaultValue": null
+          }
+        ]
+      },
+      {
+        "name": "entity",
+        "description": "Marks the GraphQL type as indexable entity.  Each type that should be an entity is required to be annotated with this directive.",
+        "locations": [
+          "OBJECT"
+        ],
+        "args": []
+      },
+      {
+        "name": "subgraphId",
+        "description": "Defined a Subgraph ID for an object type",
+        "locations": [
+          "OBJECT"
+        ],
+        "args": [
+          {
+            "name": "id",
+            "description": null,
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
-                "name": "Int",
+                "name": "String",
                 "ofType": null
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "inputFields": null,
-          "interfaces": [],
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "OBJECT",
-          "name": "_Meta_",
-          "description": "The type for the top-level _meta field",
-          "fields": [
-            {
-              "name": "block",
-              "description": "Information about a specific subgraph block. The hash of the block\nwill be null if the _meta field has a block constraint that asks for\na block number. It will be filled if the _meta field has no block constraint\nand therefore asks for the latest  block\n",
-              "args": [],
-              "type": {
-                "kind": "NON_NULL",
-                "name": null,
-                "ofType": {
-                  "kind": "OBJECT",
-                  "name": "_Block_",
-                  "ofType": null
-                }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "deployment",
-              "description": "The deployment ID",
-              "args": [],
-              "type": {
-                "kind": "NON_NULL",
-                "name": null,
-                "ofType": {
-                  "kind": "SCALAR",
-                  "name": "String",
-                  "ofType": null
-                }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "hasIndexingErrors",
-              "description": "If `true`, the subgraph encountered indexing errors at some past block",
-              "args": [],
-              "type": {
-                "kind": "NON_NULL",
-                "name": null,
-                "ofType": {
-                  "kind": "SCALAR",
-                  "name": "Boolean",
-                  "ofType": null
-                }
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "inputFields": null,
-          "interfaces": [],
-          "enumValues": null,
-          "possibleTypes": null
-        },
-        {
-          "kind": "ENUM",
-          "name": "_SubgraphErrorPolicy_",
-          "description": null,
-          "fields": null,
-          "inputFields": null,
-          "interfaces": null,
-          "enumValues": [
-            {
-              "name": "allow",
-              "description": "Data will be returned even if the subgraph has indexing errors",
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
-            {
-              "name": "deny",
-              "description": "If the subgraph has indexing errors, data will be omitted. The default.",
-              "isDeprecated": false,
-              "deprecationReason": null
-            }
-          ],
-          "possibleTypes": null
-        }
-      ],
-      "directives": [
-        {
-          "name": "language",
-          "description": null,
-          "locations": [
-            "FIELD_DEFINITION"
-          ],
-          "args": [
-            {
-              "name": "language",
-              "description": null,
-              "type": {
+              }
+            },
+            "defaultValue": null
+          }
+        ]
+      },
+      {
+        "name": "derivedFrom",
+        "description": "creates a virtual field on the entity that may be queried but cannot be set manually through the mappings API.",
+        "locations": [
+          "FIELD_DEFINITION"
+        ],
+        "args": [
+          {
+            "name": "field",
+            "description": null,
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
                 "kind": "SCALAR",
                 "name": "String",
                 "ofType": null
-              },
-              "defaultValue": "\"English\""
-            }
-          ]
-        },
-        {
-          "name": "skip",
-          "description": null,
-          "locations": [
-            "FIELD",
-            "FRAGMENT_SPREAD",
-            "INLINE_FRAGMENT"
-          ],
-          "args": [
-            {
-              "name": "if",
-              "description": null,
-              "type": {
-                "kind": "NON_NULL",
-                "name": null,
-                "ofType": {
-                  "kind": "SCALAR",
-                  "name": "Boolean",
-                  "ofType": null
-                }
-              },
-              "defaultValue": null
-            }
-          ]
-        },
-        {
-          "name": "include",
-          "description": null,
-          "locations": [
-            "FIELD",
-            "FRAGMENT_SPREAD",
-            "INLINE_FRAGMENT"
-          ],
-          "args": [
-            {
-              "name": "if",
-              "description": null,
-              "type": {
-                "kind": "NON_NULL",
-                "name": null,
-                "ofType": {
-                  "kind": "SCALAR",
-                  "name": "Boolean",
-                  "ofType": null
-                }
-              },
-              "defaultValue": null
-            }
-          ]
-        },
-        {
-          "name": "entity",
-          "description": "Marks the GraphQL type as indexable entity.  Each type that should be an entity is required to be annotated with this directive.",
-          "locations": [
-            "OBJECT"
-          ],
-          "args": []
-        },
-        {
-          "name": "subgraphId",
-          "description": "Defined a Subgraph ID for an object type",
-          "locations": [
-            "OBJECT"
-          ],
-          "args": [
-            {
-              "name": "id",
-              "description": null,
-              "type": {
-                "kind": "NON_NULL",
-                "name": null,
-                "ofType": {
-                  "kind": "SCALAR",
-                  "name": "String",
-                  "ofType": null
-                }
-              },
-              "defaultValue": null
-            }
-          ]
-        },
-        {
-          "name": "derivedFrom",
-          "description": "creates a virtual field on the entity that may be queried but cannot be set manually through the mappings API.",
-          "locations": [
-            "FIELD_DEFINITION"
-          ],
-          "args": [
-            {
-              "name": "field",
-              "description": null,
-              "type": {
-                "kind": "NON_NULL",
-                "name": null,
-                "ofType": {
-                  "kind": "SCALAR",
-                  "name": "String",
-                  "ofType": null
-                }
-              },
-              "defaultValue": null
-            }
-          ]
-        }
-      ]
-    }
+              }
+            },
+            "defaultValue": null
+          }
+        ]
+      }
+    ]
   }
+}
diff --git a/store/test-store/tests/graphql/query.rs b/store/test-store/tests/graphql/query.rs
index 26cc1d74efe..d2410d62b2e 100644
--- a/store/test-store/tests/graphql/query.rs
+++ b/store/test-store/tests/graphql/query.rs
@@ -1,16 +1,22 @@
+use graph::blockchain::{Block, BlockTime};
+use graph::data::query::Trace;
+use graph::data::store::scalar::Timestamp;
+use graph::data::subgraph::LATEST_VERSION;
 use graph::data::subgraph::schema::DeploymentCreate;
 use graph::entity;
-use graph::prelude::{SubscriptionResult, Value};
+use graph::prelude::Value;
 use graph::schema::InputSchema;
-use graphql_parser::Pos;
 use std::iter::FromIterator;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::Instant;
 use std::{
     collections::{BTreeSet, HashMap},
     marker::PhantomData,
 };
+use test_store::block_store::{
+    BLOCK_FOUR, BLOCK_ONE, BLOCK_THREE, BLOCK_TWO, FakeBlock, GENESIS_BLOCK,
+};
 
 use graph::{
     components::store::DeploymentLocator,
@@ -21,19 +27,15 @@ use graph::{
         subgraph::SubgraphFeature,
     },
     prelude::{
-        futures03::stream::StreamExt, lazy_static, o, q, r, serde_json, slog, BlockPtr,
-        DeploymentHash, Entity, EntityOperation, FutureExtension, GraphQlRunner as _, Logger,
-        NodeId, Query, QueryError, QueryExecutionError, QueryResult, QueryStoreManager,
-        QueryVariables, SubgraphManifest, SubgraphName, SubgraphStore,
-        SubgraphVersionSwitchingMode, Subscription, SubscriptionError,
+        BlockPtr, DeploymentHash, Entity, EntityOperation, GraphQlRunner as _, NodeId, Query,
+        QueryError, QueryExecutionError, QueryResult, QueryVariables, SubgraphManifest,
+        SubgraphName, SubgraphStore, SubgraphVersionSwitchingMode, lazy_static, q, r, serde_json,
     },
-    semver::Version,
 };
-use graph_graphql::{prelude::*, subscription::execute_subscription};
+use graph_graphql::prelude::*;
 use test_store::{
-    deployment_state, execute_subgraph_query, execute_subgraph_query_with_deadline,
-    graphql_metrics, revert_block, run_test_sequentially, transact_errors, Store, BLOCK_ONE,
-    GENESIS_PTR, LOAD_MANAGER, LOGGER, METRICS_REGISTRY, STORE, SUBSCRIPTION_MANAGER,
+    LOAD_MANAGER, LOGGER, METRICS_REGISTRY, STORE, Store, deployment_state, execute_subgraph_query,
+    execute_subgraph_query_with_deadline, revert_block, run_test_sequentially, transact_errors,
 };
 
 /// Ids for the various entities that we create in `insert_entities` and
@@ -49,6 +51,11 @@ const MEDIA_INT: [&str; 7] = ["52", "53", "54", "55", "56", "57", "58"];
 lazy_static! {
     /// The id of the sole publisher in the test data
     static ref PUB1: IdVal = IdType::Bytes.parse("0xb1");
+    /// The chain we actually put into the chain store, blocks 0 to 3
+    static ref CHAIN: Vec<FakeBlock> = vec![GENESIS_BLOCK.clone(), BLOCK_ONE.clone(), BLOCK_TWO.clone(), BLOCK_THREE.clone()];
+    /// The known block pointers for blocks 0 to 3 from the chain plus a
+    /// nonexistent block 4
+    static ref BLOCKS: Vec<BlockPtr> = CHAIN.iter().map(|b| b.ptr().clone()).chain(Some(BLOCK_FOUR.ptr().clone())).collect();
 }
 
 /// A convenience wrapper for `Value` and `r::Value` that clones a lot,
@@ -89,7 +96,7 @@ impl std::fmt::Display for IdVal {
 }
 
 #[derive(Clone, Copy, Debug)]
-enum IdType {
+pub enum IdType {
     String,
     Bytes,
     Int8,
@@ -149,7 +156,7 @@ impl IdType {
         }
     }
 
-    fn deployment_id(&self) -> &str {
+    pub fn deployment_id(&self) -> &str {
         match self {
             IdType::String => "graphqlTestsQuery",
             IdType::Bytes => "graphqlTestsQueryBytes",
@@ -168,13 +175,13 @@ async fn setup_readonly(store: &Store) -> DeploymentLocator {
 /// data. If the `id` is the same as `id_type.deployment_id()`, the test
 /// must not modify the deployment in any way as these are reused for other
 /// tests that expect pristine data
-async fn setup(
+pub async fn setup(
     store: &Store,
     id: &str,
     features: BTreeSet<SubgraphFeature>,
     id_type: IdType,
 ) -> DeploymentLocator {
-    use test_store::block_store::{self, BLOCK_ONE, BLOCK_TWO, GENESIS_BLOCK};
+    use test_store::block_store;
 
     /// Make sure we get rid of all subgraphs once for the entire test run
     async fn global_init() {
@@ -182,9 +189,9 @@ async fn setup(
             static ref STORE_CLEAN: AtomicBool = AtomicBool::new(false);
         }
         if !STORE_CLEAN.load(Ordering::SeqCst) {
-            let chain = vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_TWO];
+            let chain = CHAIN.iter().collect();
             block_store::set_chain(chain, NETWORK_NAME).await;
-            test_store::remove_subgraphs();
+            test_store::remove_subgraphs().await;
             STORE_CLEAN.store(true, Ordering::SeqCst);
         }
     }
@@ -198,7 +205,7 @@ async fn setup(
         let schema = test_schema(id.clone(), id_type);
         let manifest = SubgraphManifest::<graph_chain_ethereum::Chain> {
             id: id.clone(),
-            spec_version: Version::new(1, 0, 0),
+            spec_version: LATEST_VERSION.clone(),
             features,
             description: None,
             repository: None,
@@ -215,12 +222,12 @@ async fn setup(
 
     global_init().await;
     let id = DeploymentHash::new(id).unwrap();
-    let loc = store.subgraph_store().active_locator(&id).unwrap();
+    let loc = store.subgraph_store().active_locator(&id).await.unwrap();
 
     match loc {
         Some(loc) if id_type.deployment_id() == loc.hash.as_str() => loc,
         Some(loc) => {
-            test_store::remove_subgraph(&loc.hash);
+            test_store::remove_subgraph(&loc.hash).await;
             initialize(store, id, features, id_type).await
         }
         None => initialize(store, id, features, id_type).await,
@@ -252,6 +259,7 @@ fn test_schema(id: DeploymentHash, id_type: IdType) -> InputSchema {
         bands: [Band!]!
         writtenSongs: [Song!]! @derivedFrom(field: \"writtenBy\")
         favoriteCount: Int8!
+        birthDate: Timestamp!
     }
 
     type Band @entity {
@@ -272,6 +280,7 @@ fn test_schema(id: DeploymentHash, id_type: IdType) -> InputSchema {
         reviews: [SongReview!]! @derivedFrom(field: \"song\")
         media: [Media!]!
         release: Release! @derivedFrom(field: \"songs\")
+        stats: [SongStat!]! @derivedFrom(field: \"id\")
     }
 
     type SongStat @entity {
@@ -372,6 +381,27 @@ fn test_schema(id: DeploymentHash, id_type: IdType) -> InputSchema {
         bandReviews: [BandReview!]! @derivedFrom(field: \"author\")
         songReviews: [SongReview!]! @derivedFrom(field: \"author\")
     }
+
+    type Plays @entity(timeseries: true) {
+        id: Int8!
+        timestamp: Timestamp!
+        song: Song!
+        user: User!
+    }
+
+    type SongPlays @aggregation(intervals: [\"hour\"], source: \"Plays\") {
+        id: Int8!
+        timestamp: Timestamp!
+        song: Song!
+        played: Int! @aggregate(fn: \"count\")
+    }
+
+    type UserPlays @aggregation(intervals: [\"hour\"], source: \"Plays\") {
+        id: Int8!
+        timestamp: Timestamp!
+        user: User!
+        played: Int! @aggregate(fn: \"count\")
+    }
     ";
 
     InputSchema::parse_latest(&SCHEMA.replace("@ID@", id_type.as_str()), id)
@@ -389,14 +419,16 @@ async fn insert_test_entities(
     ) -> Vec<EntityOperation> {
         entities
             .into_iter()
-            .map(|(typename, entities)| {
+            .flat_map(|(typename, entities)| {
                 let entity_type = schema.entity_type(typename).unwrap();
-                entities.into_iter().map(move |data| EntityOperation::Set {
-                    key: entity_type.key(data.id()),
-                    data,
+                entities.into_iter().map(move |mut data| {
+                    data.set_vid_if_empty();
+                    EntityOperation::Set {
+                        key: entity_type.key(data.id()),
+                        data,
+                    }
                 })
             })
-            .flatten()
             .collect()
     }
 
@@ -422,126 +454,152 @@ async fn insert_test_entities(
             NETWORK_NAME.to_string(),
             SubgraphVersionSwitchingMode::Instant,
         )
+        .await
         .unwrap();
 
     let s = id_type.songs();
     let md = id_type.medias();
     let is = &manifest.schema;
     let pub1 = &*PUB1;
+    let ts0 = BlockTime::for_test(&BLOCKS[0]);
+    let timestamp =
+        Timestamp::from_microseconds_since_epoch(1710837304040956).expect("valid timestamp");
     let entities0 = vec![
         (
             "Musician",
             vec![
-                entity! { is => id: "m1", name: "John", mainBand: "b1", bands: vec!["b1", "b2"], favoriteCount: 10 },
-                entity! { is => id: "m2", name: "Lisa", mainBand: "b1", bands: vec!["b1"], favoriteCount: 100 },
+                entity! { is => id: "m1", name: "John", mainBand: "b1", bands: vec!["b1", "b2"], favoriteCount: 10, birthDate: timestamp, vid: 0i64 },
+                entity! { is => id: "m2", name: "Lisa", mainBand: "b1", bands: vec!["b1"], favoriteCount: 100, birthDate: timestamp, vid: 1i64 },
             ],
         ),
-        ("Publisher", vec![entity! { is => id: pub1 }]),
+        ("Publisher", vec![entity! { is => id: pub1, vid: 0i64 }]),
         (
             "Band",
             vec![
-                entity! { is => id: "b1", name: "The Musicians", originalSongs: vec![s[1], s[2]] },
-                entity! { is => id: "b2", name: "The Amateurs",  originalSongs: vec![s[1], s[3], s[4]] },
+                entity! { is => id: "b1", name: "The Musicians", originalSongs: vec![s[1], s[2]], vid: 0i64 },
+                entity! { is => id: "b2", name: "The Amateurs",  originalSongs: vec![s[1], s[3], s[4]], vid: 1i64 },
             ],
         ),
         (
             "Song",
             vec![
-                entity! { is => id: s[1], sid: "s1", title: "Cheesy Tune",  publisher: pub1, writtenBy: "m1", media: vec![md[1], md[2]] },
-                entity! { is => id: s[2], sid: "s2", title: "Rock Tune",    publisher: pub1, writtenBy: "m2", media: vec![md[3], md[4]] },
-                entity! { is => id: s[3], sid: "s3", title: "Pop Tune",     publisher: pub1, writtenBy: "m1", media: vec![md[5]] },
-                entity! { is => id: s[4], sid: "s4", title: "Folk Tune",    publisher: pub1, writtenBy: "m3", media: vec![md[6]] },
+                entity! { is => id: s[1], sid: "s1", title: "Cheesy Tune",  publisher: pub1, writtenBy: "m1", media: vec![md[1], md[2]], vid: 0i64 },
+                entity! { is => id: s[2], sid: "s2", title: "Rock Tune",    publisher: pub1, writtenBy: "m2", media: vec![md[3], md[4]], vid: 1i64 },
+                entity! { is => id: s[3], sid: "s3", title: "Pop Tune",     publisher: pub1, writtenBy: "m1", media: vec![md[5]], vid: 2i64 },
+                entity! { is => id: s[4], sid: "s4", title: "Folk Tune",    publisher: pub1, writtenBy: "m3", media: vec![md[6]], vid: 3i64 },
             ],
         ),
         (
             "User",
             vec![
-                entity! { is => id: "u1", name: "User 1", latestSongReview: "r3", latestBandReview: "r1", latestReview: "r3" },
+                entity! { is => id: "u1", name: "User 1", latestSongReview: "r3", latestBandReview: "r1", latestReview: "r3", vid: 0i64 },
             ],
         ),
         (
             "SongStat",
             vec![
-                entity! { is => id: s[1], played: 10 },
-                entity! { is => id: s[2], played: 15 },
+                entity! { is => id: s[1], played: 10, vid: 0i64 },
+                entity! { is => id: s[2], played: 15, vid: 1i64 },
             ],
         ),
         (
             "BandReview",
             vec![
-                entity! { is => id: "r1", body: "Bad musicians",        band: "b1", author: "u1" },
-                entity! { is => id: "r2", body: "Good amateurs",        band: "b2", author: "u2" },
-                entity! { is => id: "r5", body: "Very Bad musicians",   band: "b1", author: "u3" },
+                entity! { is => id: "r1", body: "Bad musicians",        band: "b1", author: "u1", vid: 0i64 },
+                entity! { is => id: "r2", body: "Good amateurs",        band: "b2", author: "u2", vid: 1i64 },
+                entity! { is => id: "r5", body: "Very Bad musicians",   band: "b1", author: "u3", vid: 2i64 },
             ],
         ),
         (
             "SongReview",
             vec![
-                entity! { is => id: "r3", body: "Bad",                  song: s[2], author: "u1" },
-                entity! { is => id: "r4", body: "Good",                 song: s[3], author: "u2" },
-                entity! { is => id: "r6", body: "Very Bad",             song: s[2], author: "u3" },
+                entity! { is => id: "r3", body: "Bad",                  song: s[2], author: "u1", vid: 0i64 },
+                entity! { is => id: "r4", body: "Good",                 song: s[3], author: "u2", vid: 1i64 },
+                entity! { is => id: "r6", body: "Very Bad",             song: s[2], author: "u3", vid: 2i64 },
             ],
         ),
         (
             "User",
             vec![
-                entity! { is => id: "u1", name: "Baden",        latestSongReview: "r3", latestBandReview: "r1", latestReview: "r1" },
-                entity! { is => id: "u2", name: "Goodwill",     latestSongReview: "r4", latestBandReview: "r2", latestReview: "r2" },
+                entity! { is => id: "u1", name: "Baden",        latestSongReview: "r3", latestBandReview: "r1", latestReview: "r1", vid: 0i64 },
+                entity! { is => id: "u2", name: "Goodwill",     latestSongReview: "r4", latestBandReview: "r2", latestReview: "r2", vid: 1i64 },
             ],
         ),
         (
             "AnonymousUser",
             vec![
-                entity! { is => id: "u3", name: "Anonymous 3",  latestSongReview: "r6", latestBandReview: "r5", latestReview: "r5" },
+                entity! { is => id: "u3", name: "Anonymous 3",  latestSongReview: "r6", latestBandReview: "r5", latestReview: "r5", vid: 0i64 },
             ],
         ),
         (
             "Photo",
             vec![
-                entity! { is => id: md[1],   title: "Cheesy Tune Single Cover",  author: "u1" },
-                entity! { is => id: md[3],   title: "Rock Tune Single Cover",    author: "u1" },
-                entity! { is => id: md[5],   title: "Pop Tune Single Cover",     author: "u1" },
+                entity! { is => id: md[1],   title: "Cheesy Tune Single Cover",  author: "u1", vid: 0i64 },
+                entity! { is => id: md[3],   title: "Rock Tune Single Cover",    author: "u1", vid: 1i64 },
+                entity! { is => id: md[5],   title: "Pop Tune Single Cover",     author: "u1", vid: 2i64 },
             ],
         ),
         (
             "Video",
             vec![
-                entity! { is => id: md[2],   title: "Cheesy Tune Music Video",   author: "u2" },
-                entity! { is => id: md[4],   title: "Rock Tune Music Video",     author: "u2" },
-                entity! { is => id: md[6],   title: "Folk Tune Music Video",     author: "u2" },
+                entity! { is => id: md[2],   title: "Cheesy Tune Music Video",   author: "u2", vid: 0i64 },
+                entity! { is => id: md[4],   title: "Rock Tune Music Video",     author: "u2", vid: 1i64 },
+                entity! { is => id: md[6],   title: "Folk Tune Music Video",     author: "u2", vid: 2i64 },
             ],
         ),
         (
             "Album",
-            vec![entity! { is => id: "rl1",   title: "Pop and Folk",    songs: vec![s[3], s[4]] }],
+            vec![
+                entity! { is => id: "rl1",   title: "Pop and Folk",    songs: vec![s[3], s[4]], vid: 0i64 },
+            ],
         ),
         (
             "Single",
             vec![
-                entity! { is => id: "rl2",  title: "Rock",           songs: vec![s[2]] },
-                entity! { is => id: "rl3",  title: "Cheesy",         songs: vec![s[1]] },
-                entity! { is => id: "rl4",  title: "Silence",        songs: Vec::<graph::prelude::Value>::new() },
+                entity! { is => id: "rl2",  title: "Rock",           songs: vec![s[2]], vid: 0i64 },
+                entity! { is => id: "rl3",  title: "Cheesy",         songs: vec![s[1]], vid: 1i64 },
+                entity! { is => id: "rl4",  title: "Silence",        songs: Vec::<graph::prelude::Value>::new(), vid: 2i64 },
+            ],
+        ),
+        (
+            "Plays",
+            vec![
+                entity! { is => id: 1i64, timestamp: ts0, song: s[1], user: "u1", vid: 0i64 },
+                entity! { is => id: 2i64, timestamp: ts0, song: s[1], user: "u2", vid: 1i64 },
+                entity! { is => id: 3i64, timestamp: ts0, song: s[2], user: "u1", vid: 2i64 },
+                entity! { is => id: 4i64, timestamp: ts0, song: s[1], user: "u1", vid: 3i64 },
+                entity! { is => id: 5i64, timestamp: ts0, song: s[1], user: "u1", vid: 4i64 },
             ],
         ),
     ];
+
     let entities0 = insert_ops(&manifest.schema, entities0);
 
     let entities1 = vec![(
         "Musician",
         vec![
-            entity! { is => id: "m3", name: "Tom", mainBand: "b2", bands: vec!["b1", "b2"], favoriteCount: 5 },
-            entity! { is => id: "m4", name: "Valerie", bands: Vec::<String>::new(), favoriteCount: 20 },
+            entity! { is => id: "m3", name: "Tom", mainBand: "b2", bands: vec!["b1", "b2"], favoriteCount: 5, birthDate: timestamp, vid: 2i64 },
+            entity! { is => id: "m4", name: "Valerie", bands: Vec::<String>::new(), favoriteCount: 20, birthDate: timestamp, vid: 3i64 },
+            entity! { is => id: "m5", name: "Paul", mainBand: "b2", bands: vec!["b2"], favoriteCount: 2 , birthDate: timestamp, vid: 4i64 },
         ],
     )];
     let entities1 = insert_ops(&manifest.schema, entities1);
 
-    insert_at(entities0, &deployment, GENESIS_PTR.clone()).await;
-    insert_at(entities1, &deployment, BLOCK_ONE.clone()).await;
+    insert_at(entities0, &deployment, BLOCKS[0].clone()).await;
+    insert_at(entities1, &deployment, BLOCKS[1].clone()).await;
+
+    // We ingest block 2 with no changes to the subgraph solely to trigger
+    // an hourly rollup. Make sure that the block times between genesis and
+    // block 2 actually span an hour.
+    let t0 = BlockTime::for_test(&BLOCKS[0]).as_secs_since_epoch();
+    let t2 = BlockTime::for_test(&BLOCKS[2]).as_secs_since_epoch();
+    assert!(t2 - t0 > 3600);
+    insert_at(vec![], &deployment, BLOCKS[2].clone()).await;
     deployment
 }
 
 async fn execute_query(loc: &DeploymentLocator, query: &str) -> QueryResult {
-    let query = graphql_parser::parse_query(query)
+    let query = q::parse_query(query)
         .expect("invalid test query")
         .into_static();
     execute_query_document_with_variables(&loc.hash, query, None).await
@@ -555,9 +613,9 @@ async fn execute_query_document_with_variables(
     let runner = Arc::new(GraphQlRunner::new(
         &LOGGER,
         STORE.clone(),
-        SUBSCRIPTION_MANAGER.clone(),
         LOAD_MANAGER.clone(),
         METRICS_REGISTRY.clone(),
+        Arc::new(graph::components::log_store::NoOpLogStore),
     ));
     let target = QueryTarget::Deployment(id.clone(), Default::default());
     let query = Query::new(query, variables, false);
@@ -656,20 +714,19 @@ where
                 let repl = id.as_gql(id_type);
                 query = query.replace(&pat, &repl);
             }
-            dbg!(&query);
 
             let result = {
                 let id = &deployment.hash;
-                let query = graphql_parser::parse_query(&query)
+                let query = q::parse_query(&query)
                     .expect("Invalid test query")
                     .into_static();
                 let variables = variables.clone();
                 let runner = Arc::new(GraphQlRunner::new(
                     &LOGGER,
                     STORE.clone(),
-                    SUBSCRIPTION_MANAGER.clone(),
                     LOAD_MANAGER.clone(),
                     METRICS_REGISTRY.clone(),
+                    Arc::new(graph::components::log_store::NoOpLogStore),
                 ));
                 let target = QueryTarget::Deployment(id.clone(), Default::default());
                 let query = Query::new(query, variables, false);
@@ -686,47 +743,6 @@ where
     })
 }
 
-/// Helper to run a subscription
-async fn run_subscription(
-    store: &Arc<Store>,
-    query: &str,
-    max_complexity: Option<u64>,
-) -> Result<SubscriptionResult, SubscriptionError> {
-    let deployment = setup_readonly(store.as_ref()).await;
-    let logger = Logger::root(slog::Discard, o!());
-    let query_store = store
-        .query_store(
-            QueryTarget::Deployment(deployment.hash.clone(), Default::default()),
-            true,
-        )
-        .await
-        .unwrap();
-
-    let query = Query::new(
-        graphql_parser::parse_query(query).unwrap().into_static(),
-        None,
-        false,
-    );
-    let options = SubscriptionExecutionOptions {
-        logger: logger.clone(),
-        store: query_store.clone(),
-        subscription_manager: SUBSCRIPTION_MANAGER.clone(),
-        timeout: None,
-        max_complexity,
-        max_depth: 100,
-        max_first: std::u32::MAX,
-        max_skip: std::u32::MAX,
-        graphql_metrics: graphql_metrics(),
-        load_manager: LOAD_MANAGER.clone(),
-    };
-    let schema = STORE
-        .subgraph_store()
-        .api_schema(&deployment.hash, &Default::default())
-        .unwrap();
-
-    execute_subscription(Subscription { query }, schema, options)
-}
-
 #[test]
 fn can_query_one_to_one_relationship() {
     const QUERY: &str = "
@@ -737,6 +753,7 @@ fn can_query_one_to_one_relationship() {
                 name
             }
             favoriteCount
+            birthDate
         }
         songStats(first: 100, orderBy: id) {
             id
@@ -753,10 +770,11 @@ fn can_query_one_to_one_relationship() {
         let s = id_type.songs();
         let exp = object! {
             musicians: vec![
-                object! { name: "John", mainBand: object! { name: "The Musicians" }, favoriteCount: "10" },
-                object! { name: "Lisa", mainBand: object! { name: "The Musicians" }, favoriteCount: "100" },
-                object! { name: "Tom",  mainBand: object! { name: "The Amateurs" }, favoriteCount: "5" },
-                object! { name: "Valerie", mainBand: r::Value::Null, favoriteCount: "20" }
+                object! { name: "John", mainBand: object! { name: "The Musicians" }, favoriteCount: "10", birthDate: "1710837304040956" },
+                object! { name: "Lisa", mainBand: object! { name: "The Musicians" }, favoriteCount: "100", birthDate: "1710837304040956" },
+                object! { name: "Tom",  mainBand: object! { name: "The Amateurs" }, favoriteCount: "5", birthDate: "1710837304040956" },
+                object! { name: "Valerie", mainBand: r::Value::Null, favoriteCount: "20", birthDate: "1710837304040956" },
+                object! { name: "Paul", mainBand: object! { name: "The Amateurs" }, favoriteCount: "2", birthDate: "1710837304040956" }
             ],
             songStats: vec![
                 object! {
@@ -772,6 +790,45 @@ fn can_query_one_to_one_relationship() {
             ]
         };
         let data = extract_data!(result).unwrap();
+        assert_eq!(data.to_string(), exp.to_string());
+    })
+}
+
+#[test]
+fn can_filter_by_timestamp() {
+    const QUERY1: &str = "
+    query {
+        musicians(first: 100, orderBy: id, where: { birthDate_gt: \"1710837304040955\" }) {
+            name
+        }
+    }
+    ";
+
+    const QUERY2: &str = "
+    query {
+        musicians(first: 100, orderBy: id, where: { birthDate_lt: \"1710837304040955\" }) {
+            name
+        }
+    }
+    ";
+
+    run_query(QUERY1, |result, _| {
+        let exp = object! {
+            musicians: vec![
+                object! { name: "John" },
+                object! { name: "Lisa" },
+                object! { name: "Tom" },
+                object! { name: "Valerie" },
+                object! { name: "Paul" },
+            ],
+        };
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
+    });
+
+    run_query(QUERY2, |result, _| {
+        let exp = object! { musicians: Vec::<r::Value>::new() };
+        let data = extract_data!(result).unwrap();
         assert_eq!(data, exp);
     })
 }
@@ -815,6 +872,9 @@ fn can_query_one_to_many_relationships_in_both_directions() {
                 object! {
                     name: "Valerie", writtenSongs: Vec::<String>::new()
                 },
+                object! {
+                    name: "Paul", writtenSongs: Vec::<String>::new()
+                },
             ]
         };
 
@@ -853,15 +913,16 @@ fn can_query_many_to_many_relationship() {
 
         let the_amateurs = object! {
             name: "The Amateurs",
-            members: members(vec![ "John", "Tom" ])
+            members: members(vec![ "John", "Tom", "Paul" ])
         };
 
         let exp = object! {
             musicians: vec![
                 object! { name: "John", bands: vec![ the_musicians.clone(), the_amateurs.clone() ]},
                 object! { name: "Lisa", bands: vec![ the_musicians.clone() ] },
-                object! { name: "Tom", bands: vec![ the_musicians, the_amateurs ] },
-                object! { name: "Valerie", bands: Vec::<String>::new() }
+                object! { name: "Tom", bands: vec![ the_musicians, the_amateurs.clone() ] },
+                object! { name: "Valerie", bands: Vec::<String>::new() },
+                object! { name: "Paul", bands: vec![ the_amateurs ] }
             ]
         };
 
@@ -943,10 +1004,12 @@ fn can_query_with_sorting_by_child_entity() {
                 object! { name: "Valerie", mainBand: r::Value::Null },
                 object! { name: "Lisa", mainBand: object! { name: "The Musicians" } },
                 object! { name: "John", mainBand: object! { name: "The Musicians" } },
+                object! { name: "Paul",  mainBand: object! { name: "The Amateurs"} },
                 object! { name: "Tom",  mainBand: object! { name: "The Amateurs"} },
                 ],
             asc: vec![
                 object! { name: "Tom",  mainBand: object! { name: "The Amateurs"} },
+                object! { name: "Paul",  mainBand: object! { name: "The Amateurs"} },
                 object! { name: "John", mainBand: object! { name: "The Musicians" } },
                 object! { name: "Lisa", mainBand: object! { name: "The Musicians" } },
                 object! { name: "Valerie", mainBand: r::Value::Null },
@@ -1254,7 +1317,8 @@ fn can_query_with_child_filter_on_list_type_field() {
         let exp = object! {
             musicians: vec![
                 object! { name: "John", bands: vec![ the_musicians.clone(), the_amateurs.clone() ]},
-                object! { name: "Tom", bands: vec![ the_musicians, the_amateurs ] },
+                object! { name: "Tom", bands: vec![ the_musicians, the_amateurs.clone() ] },
+                object! { name: "Paul", bands: vec![ the_amateurs ] },
             ]
         };
 
@@ -1299,7 +1363,8 @@ fn can_query_with_child_filter_on_named_type_field() {
     run_query(QUERY, |result, _| {
         let exp = object! {
             musicians: vec![
-                object! { name: "Tom", mainBand: object! { id: "b2"} }
+                object! { name: "Tom", mainBand: object! { id: "b2"} },
+                object! { name: "Paul", mainBand: object! { id: "b2"} }
             ]
         };
 
@@ -1650,7 +1715,7 @@ fn skip_directive_works_with_query_variables() {
 
     run_query((QUERY, object! { skip: true }), |result, _| {
         // Assert that only names are returned
-        let musicians: Vec<_> = ["John", "Lisa", "Tom", "Valerie"]
+        let musicians: Vec<_> = ["John", "Lisa", "Tom", "Valerie", "Paul"]
             .into_iter()
             .map(|name| object! { name: name })
             .collect();
@@ -1666,7 +1731,8 @@ fn skip_directive_works_with_query_variables() {
                 object! { id: "m1", name: "John" },
                 object! { id: "m2", name: "Lisa"},
                 object! { id: "m3", name: "Tom" },
-                object! { id: "m4", name: "Valerie" }
+                object! { id: "m4", name: "Valerie" },
+                object! { id: "m5", name: "Paul" }
             ]
         };
         let data = extract_data!(result).unwrap();
@@ -1692,7 +1758,8 @@ fn include_directive_works_with_query_variables() {
                 object! { id: "m1", name: "John" },
                 object! { id: "m2", name: "Lisa"},
                 object! { id: "m3", name: "Tom" },
-                object! { id: "m4", name: "Valerie" }
+                object! { id: "m4", name: "Valerie" },
+                object! { id: "m5", name: "Paul" }
             ]
         };
         let data = extract_data!(result).unwrap();
@@ -1701,7 +1768,7 @@ fn include_directive_works_with_query_variables() {
 
     run_query((QUERY, object! { include: false }), |result, _| {
         // Assert that only names are returned
-        let musicians: Vec<_> = ["John", "Lisa", "Tom", "Valerie"]
+        let musicians: Vec<_> = ["John", "Lisa", "Tom", "Valerie", "Paul"]
             .into_iter()
             .map(|name| object! { name: name })
             .collect();
@@ -1764,64 +1831,12 @@ fn query_complexity() {
     })
 }
 
-#[test]
-fn query_complexity_subscriptions() {
-    run_test_sequentially(|store| async move {
-        const QUERY1: &str = "subscription {
-                musicians(orderBy: id) {
-                    name
-                    bands(first: 100, orderBy: id) {
-                        name
-                        members(first: 100, orderBy: id) {
-                            name
-                        }
-                    }
-                }
-            }";
-        let max_complexity = Some(1_010_100);
-
-        // This query is exactly at the maximum complexity.
-        // FIXME: Not collecting the stream because that will hang the test.
-        let _ignore_stream = run_subscription(&store, QUERY1, max_complexity)
-            .await
-            .unwrap();
-
-        const QUERY2: &str = "subscription {
-                musicians(orderBy: id) {
-                    name
-                    t1: bands(first: 100, orderBy: id) {
-                        name
-                        members(first: 100, orderBy: id) {
-                            name
-                        }
-                    }
-                    t2: bands(first: 200, orderBy: id) {
-                      name
-                      members(first: 100, orderBy: id) {
-                          name
-                      }
-                  }
-                }
-            }";
-
-        let result = run_subscription(&store, QUERY2, max_complexity).await;
-
-        match result {
-            Err(SubscriptionError::GraphQLError(e)) => match &e[0] {
-                QueryExecutionError::TooComplex(3_030_100, _) => (), // Expected
-                e => panic!("did not catch complexity: {:?}", e),
-            },
-            _ => panic!("did not catch complexity"),
-        }
-    })
-}
-
 #[test]
 fn instant_timeout() {
     run_test_sequentially(|store| async move {
         let deployment = setup_readonly(store.as_ref()).await;
         let query = Query::new(
-            graphql_parser::parse_query("query { musicians(first: 100) { name } }")
+            q::parse_query("query { musicians(first: 100) { name } }")
                 .unwrap()
                 .into_static(),
             None,
@@ -1893,7 +1908,7 @@ fn skip_is_nullable() {
 ";
 
     run_query(QUERY, |result, _| {
-        let musicians: Vec<_> = ["John", "Lisa", "Tom", "Valerie"]
+        let musicians: Vec<_> = ["John", "Lisa", "Tom", "Valerie", "Paul"]
             .into_iter()
             .map(|name| object! { name: name })
             .collect();
@@ -1914,7 +1929,7 @@ fn first_is_nullable() {
 ";
 
     run_query(QUERY, |result, _| {
-        let musicians: Vec<_> = ["John", "Lisa", "Tom", "Valerie"]
+        let musicians: Vec<_> = ["John", "Lisa", "Tom", "Valerie", "Paul"]
             .into_iter()
             .map(|name| object! { name: name })
             .collect();
@@ -1957,7 +1972,7 @@ fn ambiguous_derived_from_result() {
             )) => {
                 assert_eq!(
                     pos,
-                    &Pos {
+                    &q::Pos {
                         line: 1,
                         column: 39
                     }
@@ -1991,7 +2006,8 @@ fn can_filter_by_relationship_fields() {
 
         let exp = object! {
             musicians: vec![
-                object! { id: "m3", name: "Tom", mainBand: object! { id: "b2"} }
+                object! { id: "m3", name: "Tom", mainBand: object! { id: "b2"} },
+                object! { id: "m5", name: "Paul", mainBand: object! { id: "b2"} }
             ],
             bands: vec![
                 object! {
@@ -2044,38 +2060,6 @@ fn cannot_filter_by_derved_relationship_fields() {
     })
 }
 
-#[test]
-fn subscription_gets_result_even_without_events() {
-    run_test_sequentially(|store| async move {
-        const QUERY: &str = "subscription {
-            musicians(orderBy: id, first: 2) {
-              name
-            }
-          }";
-
-        // Execute the subscription and expect at least one result to be
-        // available in the result stream
-        let stream = run_subscription(&store, QUERY, None).await.unwrap();
-        let results: Vec<_> = stream
-            .take(1)
-            .collect()
-            .timeout(Duration::from_secs(3))
-            .await
-            .unwrap();
-
-        assert_eq!(results.len(), 1);
-        let result = Arc::try_unwrap(results.into_iter().next().unwrap()).unwrap();
-        let data = extract_data!(result).unwrap();
-        let exp = object! {
-            musicians: vec![
-                object! { name: "John" },
-                object! { name: "Lisa" }
-            ]
-        };
-        assert_eq!(data, exp);
-    })
-}
-
 #[test]
 fn can_use_nested_filter() {
     const QUERY: &str = "
@@ -2105,6 +2089,10 @@ fn can_use_nested_filter() {
                 object! {
                     name: "Valerie",
                     bands: Vec::<r::Value>::new(),
+                },
+                object! {
+                    name: "Paul",
+                    bands: vec![ object! { id: "b2" }]
                 }
             ]
         };
@@ -2127,13 +2115,13 @@ fn ignores_invalid_field_arguments() {
             // Without validations
             Ok(Some(r::Value::Object(obj))) => match obj.get("musicians").unwrap() {
                 r::Value::List(lst) => {
-                    assert_eq!(4, lst.len());
+                    assert_eq!(5, lst.len());
                 }
                 _ => panic!("expected a list of values"),
             },
             // With validations
             Err(e) => {
-                match e.get(0).unwrap() {
+                match e.first().unwrap() {
                     QueryError::ExecutionError(QueryExecutionError::ValidationError(
                         _pos,
                         message,
@@ -2168,12 +2156,15 @@ fn leaf_selection_mismatch() {
             }
             // With validations
             Err(e) => {
-                match e.get(0).unwrap() {
+                match e.first().unwrap() {
                     QueryError::ExecutionError(QueryExecutionError::ValidationError(
                         _pos,
                         message,
                     )) => {
-                        assert_eq!(message, "Field \"name\" must not have a selection since type \"String!\" has no subfields.");
+                        assert_eq!(
+                            message,
+                            "Field \"name\" must not have a selection since type \"String!\" has no subfields."
+                        );
                     }
                     r => panic!("unexpexted query error: {:?}", r),
                 };
@@ -2204,12 +2195,15 @@ fn leaf_selection_mismatch() {
             }
             // With validations
             Err(e) => {
-                match e.get(0).unwrap() {
+                match e.first().unwrap() {
                     QueryError::ExecutionError(QueryExecutionError::ValidationError(
                         _pos,
                         message,
                     )) => {
-                        assert_eq!(message, "Field \"mainBand\" of type \"Band\" must have a selection of subfields. Did you mean \"mainBand { ... }\"?");
+                        assert_eq!(
+                            message,
+                            "Field \"mainBand\" of type \"Band\" must have a selection of subfields. Did you mean \"mainBand { ... }\"?"
+                        );
                     }
                     r => panic!("unexpexted query error: {:?}", r),
                 };
@@ -2233,6 +2227,7 @@ fn missing_variable() {
                 object! { id: "m2" },
                 object! { id: "m3" },
                 object! { id: "m4" },
+                object! { id: "m5" },
             ]
         };
 
@@ -2242,7 +2237,7 @@ fn missing_variable() {
                 assert_eq!(exp, *data);
             }
             // With GraphQL validations active, this query fails
-            Err(e) => match e.get(0).unwrap() {
+            Err(e) => match e.first().unwrap() {
                 QueryError::ExecutionError(QueryExecutionError::ValidationError(_pos, message)) => {
                     assert_eq!(message, "Variable \"$first\" is not defined.");
                 }
@@ -2263,6 +2258,7 @@ fn missing_variable() {
                 object! { id: "m2" },
                 object! { id: "m3" },
                 object! { id: "m4" },
+                object! { id: "m5" },
             ]
         };
 
@@ -2272,7 +2268,7 @@ fn missing_variable() {
                 assert_eq!(exp, *data);
             }
             // With GraphQL validations active, this query fails
-            Err(e) => match e.get(0).unwrap() {
+            Err(e) => match e.first().unwrap() {
                 QueryError::ExecutionError(QueryExecutionError::ValidationError(_pos, message)) => {
                     assert_eq!(message, "Variable \"$where\" is not defined.");
                 }
@@ -2342,37 +2338,36 @@ fn check_musicians_at(query0: &str, block_var: r::Value, expected: Expected, qid
 
 #[test]
 fn query_at_block() {
-    use test_store::block_store::{FakeBlock, BLOCK_ONE, BLOCK_THREE, BLOCK_TWO, GENESIS_BLOCK};
-
     fn musicians_at(block: &str, expected: Expected, qid: &'static str) {
         let query = format!("query {{ musicians(block: {{ {} }}) {{ id }} }}", block);
         check_musicians_at(&query, object! {}, expected, qid);
     }
 
-    fn hash(block: &FakeBlock) -> String {
+    fn hash(block: &BlockPtr) -> String {
         format!("hash : \"0x{}\"", block.hash)
     }
 
     const BLOCK_NOT_INDEXED: &str = "subgraph @DEPLOYMENT@ has only indexed \
-         up to block number 1 and data for block number 7000 is therefore not yet available";
+         up to block number 2 and data for block number 7000 is therefore not yet available";
     const BLOCK_NOT_INDEXED2: &str = "subgraph @DEPLOYMENT@ has only indexed \
-         up to block number 1 and data for block number 2 is therefore not yet available";
+         up to block number 2 and data for block number 3 is therefore not yet available";
     const BLOCK_HASH_NOT_FOUND: &str = "no block with that hash found";
 
+    let all_musicians = vec!["m1", "m2", "m3", "m4", "m5"];
+
     musicians_at("number: 7000", Err(BLOCK_NOT_INDEXED), "n7000");
     musicians_at("number: 0", Ok(vec!["m1", "m2"]), "n0");
-    musicians_at("number: 1", Ok(vec!["m1", "m2", "m3", "m4"]), "n1");
+    musicians_at("number: 1", Ok(all_musicians.clone()), "n1");
 
-    musicians_at(&hash(&GENESIS_BLOCK), Ok(vec!["m1", "m2"]), "h0");
-    musicians_at(&hash(&BLOCK_ONE), Ok(vec!["m1", "m2", "m3", "m4"]), "h1");
-    musicians_at(&hash(&BLOCK_TWO), Err(BLOCK_NOT_INDEXED2), "h2");
-    musicians_at(&hash(&BLOCK_THREE), Err(BLOCK_HASH_NOT_FOUND), "h3");
+    musicians_at(&hash(&BLOCKS[0]), Ok(vec!["m1", "m2"]), "h0");
+    musicians_at(&hash(&BLOCKS[1]), Ok(all_musicians.clone()), "h1");
+    musicians_at(&hash(&BLOCKS[2]), Ok(all_musicians.clone()), "h2");
+    musicians_at(&hash(&BLOCKS[3]), Err(BLOCK_NOT_INDEXED2), "h3");
+    musicians_at(&hash(&BLOCKS[4]), Err(BLOCK_HASH_NOT_FOUND), "h4");
 }
 
 #[test]
 fn query_at_block_with_vars() {
-    use test_store::block_store::{FakeBlock, BLOCK_ONE, BLOCK_THREE, BLOCK_TWO, GENESIS_BLOCK};
-
     fn musicians_at_nr(block: i32, expected: Expected, qid: &'static str) {
         let query = "query by_nr($block: Int!) { musicians(block: { number: $block }) { id } }";
         let var = object! { block: block };
@@ -2392,7 +2387,7 @@ fn query_at_block_with_vars() {
         check_musicians_at(query, var, expected, qid);
     }
 
-    fn musicians_at_hash(block: &FakeBlock, expected: Expected, qid: &'static str) {
+    fn musicians_at_hash(block: &BlockPtr, expected: Expected, qid: &'static str) {
         let query = "query by_hash($block: Bytes!) { musicians(block: { hash: $block }) { id } }";
         let var = object! { block: block.hash.to_string() };
 
@@ -2400,23 +2395,26 @@ fn query_at_block_with_vars() {
     }
 
     const BLOCK_NOT_INDEXED: &str = "subgraph @DEPLOYMENT@ has only indexed \
-         up to block number 1 and data for block number 7000 is therefore not yet available";
+         up to block number 2 and data for block number 7000 is therefore not yet available";
     const BLOCK_NOT_INDEXED2: &str = "subgraph @DEPLOYMENT@ has only indexed \
-         up to block number 1 and data for block number 2 is therefore not yet available";
+         up to block number 2 and data for block number 3 is therefore not yet available";
     const BLOCK_HASH_NOT_FOUND: &str = "no block with that hash found";
 
+    let all_musicians = vec!["m1", "m2", "m3", "m4", "m5"];
+
     musicians_at_nr(7000, Err(BLOCK_NOT_INDEXED), "n7000");
     musicians_at_nr(0, Ok(vec!["m1", "m2"]), "n0");
-    musicians_at_nr(1, Ok(vec!["m1", "m2", "m3", "m4"]), "n1");
+    musicians_at_nr(1, Ok(all_musicians.clone()), "n1");
 
     musicians_at_nr_gte(7000, Err(BLOCK_NOT_INDEXED), "ngte7000");
-    musicians_at_nr_gte(0, Ok(vec!["m1", "m2", "m3", "m4"]), "ngte0");
-    musicians_at_nr_gte(1, Ok(vec!["m1", "m2", "m3", "m4"]), "ngte1");
+    musicians_at_nr_gte(0, Ok(all_musicians.clone()), "ngte0");
+    musicians_at_nr_gte(1, Ok(all_musicians.clone()), "ngte1");
 
-    musicians_at_hash(&GENESIS_BLOCK, Ok(vec!["m1", "m2"]), "h0");
-    musicians_at_hash(&BLOCK_ONE, Ok(vec!["m1", "m2", "m3", "m4"]), "h1");
-    musicians_at_hash(&BLOCK_TWO, Err(BLOCK_NOT_INDEXED2), "h2");
-    musicians_at_hash(&BLOCK_THREE, Err(BLOCK_HASH_NOT_FOUND), "h3");
+    musicians_at_hash(&BLOCKS[0], Ok(vec!["m1", "m2"]), "h0");
+    musicians_at_hash(&BLOCKS[1], Ok(all_musicians.clone()), "h1");
+    musicians_at_hash(&BLOCKS[2], Ok(all_musicians.clone()), "h2");
+    musicians_at_hash(&BLOCKS[3], Err(BLOCK_NOT_INDEXED2), "h3");
+    musicians_at_hash(&BLOCKS[4], Err(BLOCK_HASH_NOT_FOUND), "h4");
 }
 
 #[test]
@@ -2435,7 +2433,7 @@ fn query_detects_reorg() {
             IdType::String,
         )
         .await;
-        // Initial state with latest block at block 1
+        // Initial state with latest block at block 2
         let state = deployment_state(STORE.as_ref(), &deployment.hash).await;
 
         // Inject a fake initial state; c435c25decbc4ad7bbbadf8e0ced0ff2
@@ -2444,7 +2442,7 @@ fn query_detects_reorg() {
             .unwrap() = Some(state);
 
         // When there is no revert, queries work fine
-        let result = query_at(&deployment, 1).await;
+        let result = query_at(&deployment, 2).await;
 
         assert_eq!(
             extract_data!(result),
@@ -2452,10 +2450,10 @@ fn query_detects_reorg() {
         );
 
         // Revert one block
-        revert_block(&STORE, &deployment, &GENESIS_PTR).await;
+        revert_block(&STORE, &deployment, &BLOCKS[1]).await;
 
         // A query is still fine since we query at block 0; we were at block
-        // 1 when we got `state`, and reorged once by one block, which can
+        // 2 when we got `state`, and reorged once by one block, which can
         // not affect block 0, and it's therefore ok to query at block 0
         // even with a concurrent reorg
         let result = query_at(&deployment, 0).await;
@@ -2465,18 +2463,18 @@ fn query_detects_reorg() {
         );
 
         // We move the subgraph head forward. The state we have is also for
-        // block 1, but with a smaller reorg count and we therefore report
+        // block 2, but with a smaller reorg count and we therefore report
         // an error
         test_store::transact_and_wait(
             &STORE.subgraph_store(),
             &deployment,
-            BLOCK_ONE.clone(),
+            BLOCKS[2].clone(),
             vec![],
         )
         .await
         .unwrap();
 
-        let result = query_at(&deployment, 1).await;
+        let result = query_at(&deployment, 2).await;
         match result.to_result().unwrap_err()[0] {
             QueryError::ExecutionError(QueryExecutionError::DeploymentReverted) => { /* expected */
             }
@@ -2492,16 +2490,17 @@ fn query_detects_reorg() {
 
 #[test]
 fn can_query_meta() {
-    // metadata for the latest block (block 1)
+    // metadata for the latest block (block 2)
     const QUERY1: &str =
-        "query { _meta { deployment block { hash number __typename } __typename } }";
+        "query { _meta { deployment block { hash number parentHash __typename } __typename } }";
     run_query(QUERY1, |result, id_type| {
         let exp = object! {
             _meta: object! {
                 deployment: id_type.deployment_id(),
                 block: object! {
-                    hash: "0x8511fa04b64657581e3f00e14543c1d522d5d7e771b54aa3060b662ade47da13",
-                    number: 1,
+                    hash: "0xf8ccbd3877eb98c958614f395dd351211afb9abba187bfc1fb4ac414b099c4a6",
+                    number: 2,
+                    parentHash: "0x8511fa04b64657581e3f00e14543c1d522d5d7e771b54aa3060b662ade47da13",
                     __typename: "_Block_"
                 },
                 __typename: "_Meta_"
@@ -2542,18 +2541,31 @@ fn can_query_meta() {
         assert_eq!(extract_data!(result), Some(exp));
     });
 
-    // metadata for block 2, which is beyond what the subgraph has indexed
+    // metadata for block 3, which is beyond what the subgraph has indexed
     const QUERY4: &str =
-        "query { _meta(block: { number: 2 }) { deployment block { hash number } } }";
+        "query { _meta(block: { number: 3 }) { deployment block { hash number } } }";
     run_query(QUERY4, |result, _| {
         assert!(result.has_errors());
     });
+
+    // metadata for number_gte 1. Returns subgraph head and a valid hash
+    const QUERY5: &str = "query { _meta(block: { number_gte: 1 }) { block { hash number } } }";
+    run_query(QUERY5, |result, _| {
+        let exp = object! {
+            _meta: object! {
+                block: object! {
+                    hash: BLOCKS[2].hash.to_string(),
+                    number: 2
+                },
+            },
+        };
+        assert_eq!(extract_data!(result), Some(exp));
+    });
 }
 
 #[test]
 fn non_fatal_errors() {
     use serde_json::json;
-    use test_store::block_store::BLOCK_TWO;
 
     run_test_sequentially(|store| async move {
         let deployment = setup(
@@ -2572,7 +2584,7 @@ fn non_fatal_errors() {
             deterministic: true,
         };
 
-        transact_errors(&STORE, &deployment, BLOCK_TWO.block_ptr(), vec![err], true)
+        transact_errors(&STORE, &deployment, BLOCKS[3].clone(), vec![err], true)
             .await
             .unwrap();
 
@@ -2667,7 +2679,7 @@ fn non_fatal_errors() {
         assert_eq!(expected, serde_json::to_value(&result).unwrap());
 
         // Test error reverts.
-        revert_block(&STORE, &deployment, &BLOCK_ONE).await;
+        revert_block(&STORE, &deployment, &BLOCKS[1]).await;
         let query = "query { musician(id: \"m1\") { id }  _meta { hasIndexingErrors } }";
         let result = execute_query(&deployment, query).await;
         let expected = json!({
@@ -2698,7 +2710,7 @@ fn can_query_root_typename() {
 #[test]
 fn deterministic_error() {
     use serde_json::json;
-    use test_store::block_store::BLOCK_TWO;
+    use test_store::block_store::BLOCK_THREE;
 
     run_test_sequentially(|store| async move {
         let deployment = setup(
@@ -2712,14 +2724,20 @@ fn deterministic_error() {
         let err = SubgraphError {
             subgraph_id: deployment.hash.clone(),
             message: "cow template handler could not moo event transaction".to_string(),
-            block_ptr: Some(BLOCK_TWO.block_ptr()),
+            block_ptr: Some(BLOCK_THREE.block_ptr()),
             handler: Some("handleMoo".to_string()),
             deterministic: true,
         };
 
-        transact_errors(&STORE, &deployment, BLOCK_TWO.block_ptr(), vec![err], false)
-            .await
-            .unwrap();
+        transact_errors(
+            &STORE,
+            &deployment,
+            BLOCK_THREE.block_ptr(),
+            vec![err],
+            false,
+        )
+        .await
+        .unwrap();
 
         // `subgraphError` is implicitly `deny`, data is omitted.
         let query = "query { musician(id: \"m1\") { id } }";
@@ -2835,6 +2853,7 @@ fn can_query_with_or_and_filter() {
             musicians: vec![
                 object! { name: "John", id: "m1" },
                 object! { name: "Tom", id: "m3" },
+                object! { name: "Paul", id: "m5" },
             ],
         };
         let data = extract_data!(result).unwrap();
@@ -2860,6 +2879,32 @@ fn can_query_with_or_explicit_and_filter() {
             musicians: vec![
                 object! { name: "John", id: "m1" },
                 object! { name: "Tom", id: "m3" },
+                object! { name: "Paul", id: "m5" },
+            ],
+        };
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
+    })
+}
+
+#[test]
+fn can_query_array_contains_nocase() {
+    const QUERY: &str = "
+    query {
+        musicians(where: { bands_contains_nocase: [\"B1\", \"B2\"] }) {
+            name
+            bands { id }
+        }
+    }
+    ";
+
+    run_query(QUERY, |result, _| {
+        let exp = object! {
+            musicians: vec![
+                object! { name: "John", bands: vec![object! { id: "b1" }, object! { id: "b2" }] },
+                object! { name: "Lisa", bands: vec![object! { id: "b1" }] },
+                object! { name: "Tom", bands: vec![object! { id: "b1" }, object! { id: "b2" }] },
+                object! { name: "Paul", bands: vec![ object! { id: "b2" }] },
             ],
         };
         let data = extract_data!(result).unwrap();
@@ -2894,24 +2939,59 @@ fn can_query_with_or_implicit_and_filter() {
 
 #[test]
 fn trace_works() {
-    run_test_sequentially(|store| async move {
-        let deployment = setup_readonly(store.as_ref()).await;
-        let query = Query::new(
-            graphql_parser::parse_query("query { musicians(first: 100) { name } }")
-                .unwrap()
-                .into_static(),
-            None,
-            true,
-        );
+    const QUERY1: &str = "query { musicians(first: 100) { name } }";
 
-        let result = execute_subgraph_query(
+    const QUERY2: &str = r#"
+    query {
+        m0: musicians(first: 100, block: { number: 0 }) { name }
+        m1: musicians(first: 100, block: { number: 1 }) { name }
+    }"#;
+
+    async fn run_query(deployment: &DeploymentLocator, query: &str) -> QueryResults {
+        let query = Query::new(q::parse_query(query).unwrap().into_static(), None, true);
+        execute_subgraph_query(
             query,
-            QueryTarget::Deployment(deployment.hash, Default::default()),
+            QueryTarget::Deployment(deployment.hash.clone(), Default::default()),
         )
-        .await;
+        .await
+    }
+
+    run_test_sequentially(|store| async move {
+        let deployment = setup_readonly(store.as_ref()).await;
+
+        let result = run_query(&deployment, QUERY1).await;
 
         let trace = &result.first().unwrap().trace;
-        assert!(!trace.is_none(), "result has a trace");
+        assert!(!trace.is_none(), "first result has a trace");
+        assert!(!result.trace.is_none(), "results has a trace");
+
+        // Check that with block constraints we get a trace for each block
+        let result = run_query(&deployment, QUERY2).await;
+        use Trace::*;
+        match &result.trace {
+            None => panic!("expected Root got None"),
+            Root { blocks, .. } => {
+                assert_eq!(2, blocks.len());
+                for twc in blocks {
+                    match twc.trace.as_ref() {
+                        Block {
+                            block, children, ..
+                        } => {
+                            assert!([0, 1].contains(block));
+                            assert_eq!(1, children.len());
+                            assert_eq!(format!("m{}", block), children[0].0);
+                            match &children[0].1 {
+                                Query { .. } => {}
+                                _ => panic!("expected Query got {:?}", children[0]),
+                            }
+                        }
+                        _ => panic!("expected Block got {:?}", twc.trace),
+                    }
+                }
+            }
+            Block { .. } => panic!("expected Root got Block"),
+            Query { .. } => panic!("expected Root got Query"),
+        }
     })
 }
 
@@ -2964,3 +3044,142 @@ fn empty_type_c() {
         assert_eq!(data, exp);
     })
 }
+
+#[test]
+fn simple_aggregation() {
+    fn ts0() -> r::Value {
+        r::Value::Timestamp(Timestamp::since_epoch(0, 0).unwrap())
+    }
+
+    const SONG_QUERY: &str = "
+    query {
+        songPlays_collection(interval: hour) {
+            id
+            timestamp
+            song { id }
+            played
+        }
+    }";
+
+    const USER_QUERY1: &str = "
+    query {
+        userPlays_collection(interval: hour) {
+            id
+            timestamp
+            user { id }
+            played
+        }
+    }";
+
+    const USER_QUERY2: &str = r#"
+    query {
+        userPlays_collection(interval: hour, where: { timestamp_gt: "1000000" }) {
+            id
+        }
+    }"#;
+
+    run_query(SONG_QUERY, |result, id_type| {
+        let s = id_type.songs();
+        let exp = object! {
+            songPlays_collection: vec![
+                object! { id: "5", timestamp: ts0(), song: object! { id: s[1] }, played: 4 },
+                object! { id: "3", timestamp: ts0(), song: object! { id: s[2] }, played: 1 },
+            ]
+        };
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
+    });
+    run_query(USER_QUERY1, |result, _| {
+        let exp = object! {
+            userPlays_collection: vec![
+                object! { id: "5", timestamp: ts0(), user: object! { id: "u1" }, played: 4 },
+                object! { id: "2", timestamp: ts0(), user: object! { id: "u2" }, played: 1 },
+            ]
+        };
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
+    });
+    run_query(USER_QUERY2, |result, _| {
+        let exp = object! {
+            userPlays_collection: Vec::<r::Value>::new()
+        };
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
+    })
+}
+
+/// Check that if we have entities where a related entity is null, followed
+/// by one where it is not null that the children are joined correctly to
+/// their respective parent
+#[test]
+fn children_are_joined_correctly() {
+    // Get just the `id` for the `mainBand` and `bands`
+    const QUERY1: &str = "
+    query {
+        musicians {
+          id
+          mainBand { id }
+          bands { id }
+        }
+      }
+    ";
+
+    // Get the `id` and one more attribute for the `mainBand` and `bands`
+    const QUERY2: &str = "
+    query {
+        musicians {
+          id
+          mainBand { id name }
+          bands { id name }
+        }
+      }
+    ";
+
+    run_query(QUERY1, |result, _| {
+        fn b1() -> r::Value {
+            object! { id: "b1" }
+        }
+        fn b2() -> r::Value {
+            object! { id: "b2" }
+        }
+        let null = r::Value::Null;
+        let none = Vec::<r::Value>::new();
+
+        let exp = object! {
+            musicians: vec![
+                object! { id: "m1", mainBand: b1(), bands: vec![ b1(), b2() ] },
+                object! { id: "m2", mainBand: b1(), bands: vec![ b1() ] },
+                object! { id: "m3", mainBand: b2(), bands: vec![ b1(), b2() ] },
+                object! { id: "m4", mainBand: null, bands: none },
+                object! { id: "m5", mainBand: b2(), bands: vec![ b2() ] },
+            ],
+        };
+
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
+    });
+
+    run_query(QUERY2, |result, _| {
+        fn b1() -> r::Value {
+            object! { id: "b1", name: "The Musicians" }
+        }
+        fn b2() -> r::Value {
+            object! { id: "b2", name: "The Amateurs" }
+        }
+        let null = r::Value::Null;
+        let none = Vec::<r::Value>::new();
+
+        let exp = object! {
+            musicians: vec![
+                object! { id: "m1", mainBand: b1(), bands: vec![ b1(), b2() ] },
+                object! { id: "m2", mainBand: b1(), bands: vec![ b1() ]  },
+                object! { id: "m3", mainBand: b2(), bands: vec![ b1(), b2() ]  },
+                object! { id: "m4", mainBand: null, bands: none },
+                object! { id: "m5", mainBand: b2(), bands: vec![ b2() ]  },
+            ],
+        };
+
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
+    });
+}
diff --git a/store/test-store/tests/graphql/sql.rs b/store/test-store/tests/graphql/sql.rs
new file mode 100644
index 00000000000..27802ef469b
--- /dev/null
+++ b/store/test-store/tests/graphql/sql.rs
@@ -0,0 +1,285 @@
+// SQL Query Tests for Graph Node
+// These tests parallel the GraphQL tests in query.rs but use SQL queries
+
+use graph::components::store::QueryStoreManager;
+use graph::data::query::QueryTarget;
+use graph::data::store::SqlQueryObject;
+use graph::prelude::{QueryExecutionError, r};
+use std::collections::BTreeSet;
+use test_store::{STORE, run_test_sequentially};
+
+#[cfg(debug_assertions)]
+use graph::env::ENV_VARS;
+
+// Import test setup from query.rs module
+use super::query::{IdType, setup};
+
+/// Synchronous wrapper for SQL query execution
+fn run_sql_query<F>(sql: &str, test: F)
+where
+    F: Fn(Result<Vec<SqlQueryObject>, QueryExecutionError>, IdType) + Send + 'static,
+{
+    let sql = sql.to_string(); // Convert to owned String
+    run_test_sequentially(move |store| async move {
+        ENV_VARS.enable_sql_queries_for_tests(true);
+
+        for id_type in [IdType::String, IdType::Bytes, IdType::Int8] {
+            let name = id_type.deployment_id();
+            let deployment = setup(store.as_ref(), name, BTreeSet::new(), id_type).await;
+
+            let query_store = STORE
+                .query_store(QueryTarget::Deployment(
+                    deployment.hash.clone(),
+                    Default::default(),
+                ))
+                .await
+                .unwrap();
+
+            let result = query_store.execute_sql(&sql).await;
+            test(result, id_type);
+        }
+
+        ENV_VARS.enable_sql_queries_for_tests(false);
+    });
+}
+
+#[test]
+fn sql_can_query_simple_select() {
+    const SQL: &str = "SELECT id, name FROM musician ORDER BY id";
+
+    run_sql_query(SQL, |result, _| {
+        let results = result.expect("SQL query should succeed");
+        assert_eq!(results.len(), 5, "Should return 5 musicians");
+
+        // Check first musician
+        if let Some(first) = results.first()
+            && let r::Value::Object(ref obj) = first.0
+            && let Some(r::Value::String(name)) = obj.get("name")
+        {
+            assert_eq!(name, "John", "First musician should be John");
+        }
+    });
+}
+
+#[test]
+fn sql_can_query_with_where_clause() {
+    const SQL: &str = "SELECT id, name FROM musician WHERE name = 'John'";
+
+    run_sql_query(SQL, |result, _| {
+        let results = result.expect("SQL query should succeed");
+        assert_eq!(results.len(), 1, "Should return 1 musician named John");
+
+        if let Some(first) = results.first()
+            && let r::Value::Object(ref obj) = first.0
+            && let Some(r::Value::String(name)) = obj.get("name")
+        {
+            assert_eq!(name, "John", "Should return John");
+        }
+    });
+}
+
+#[test]
+fn sql_can_query_with_aggregation() {
+    const SQL: &str = "SELECT COUNT(*) as total FROM musician";
+
+    run_sql_query(SQL, |result, _| {
+        let results = result.expect("SQL query should succeed");
+        assert_eq!(results.len(), 1, "Should return 1 row with count");
+
+        if let Some(first) = results.first()
+            && let r::Value::Object(ref obj) = first.0
+            && let Some(total) = obj.get("total")
+        {
+            // The count should be a number (could be various forms)
+            match total {
+                r::Value::Int(n) => assert_eq!(*n, 5),
+                r::Value::String(s) => assert_eq!(s, "5"),
+                _ => panic!("Total should be a number: {:?}", total),
+            }
+        }
+    });
+}
+
+#[test]
+fn sql_can_query_with_limit_offset() {
+    const SQL: &str = "SELECT id, name FROM musician ORDER BY id LIMIT 2 OFFSET 1";
+
+    run_sql_query(SQL, |result, _| {
+        let results = result.expect("SQL query should succeed");
+        assert_eq!(results.len(), 2, "Should return 2 musicians with offset");
+
+        // Should skip first musician (order may vary by id type)
+        if let Some(first) = results.first()
+            && let r::Value::Object(ref obj) = first.0
+            && let Some(r::Value::String(name)) = obj.get("name")
+        {
+            // Just check we got a valid musician name
+            assert!(["John", "Lisa", "Tom", "Valerie", "Paul"].contains(&name.as_str()));
+        }
+    });
+}
+
+#[test]
+fn sql_can_query_with_group_by() {
+    const SQL: &str = "
+        SELECT COUNT(*) as musician_count
+        FROM musician
+        GROUP BY name
+        ORDER BY musician_count DESC
+    ";
+
+    run_sql_query(SQL, |result, _| {
+        let results = result.expect("SQL query should succeed");
+        assert!(!results.is_empty(), "Should return grouped musician counts");
+    });
+}
+
+// Validation Tests
+
+#[test]
+fn sql_validates_table_names() {
+    const SQL: &str = "SELECT * FROM invalid_table";
+
+    run_sql_query(SQL, |result, _| {
+        assert!(result.is_err(), "Query with invalid table should fail");
+        if let Err(e) = result {
+            let error_msg = e.to_string();
+            assert!(
+                error_msg.contains("Unknown table") || error_msg.contains("invalid_table"),
+                "Error should mention unknown table: {}",
+                error_msg
+            );
+        }
+    });
+}
+
+#[test]
+fn sql_validates_functions() {
+    // Try to use a potentially dangerous function
+    const SQL: &str = "SELECT pg_sleep(1)";
+
+    run_sql_query(SQL, |result, _| {
+        assert!(result.is_err(), "Query with blocked function should fail");
+        if let Err(e) = result {
+            let error_msg = e.to_string();
+            assert!(
+                error_msg.contains("Unknown or unsupported function")
+                    || error_msg.contains("pg_sleep"),
+                "Error should mention unsupported function: {}",
+                error_msg
+            );
+        }
+    });
+}
+
+#[test]
+fn sql_blocks_ddl_statements() {
+    const SQL: &str = "DROP TABLE musician";
+
+    run_sql_query(SQL, |result, _| {
+        assert!(result.is_err(), "DDL statements should be blocked");
+        if let Err(e) = result {
+            let error_msg = e.to_string();
+            assert!(
+                error_msg.contains("Only SELECT query is supported") || error_msg.contains("DROP"),
+                "Error should mention unsupported statement type: {}",
+                error_msg
+            );
+        }
+    });
+}
+
+#[test]
+fn sql_blocks_dml_statements() {
+    const SQL: &str = "DELETE FROM musician WHERE id = 'm1'";
+
+    run_sql_query(SQL, |result, _| {
+        assert!(result.is_err(), "DML statements should be blocked");
+        if let Err(e) = result {
+            let error_msg = e.to_string();
+            assert!(
+                error_msg.contains("Only SELECT query is supported")
+                    || error_msg.contains("DELETE"),
+                "Error should mention unsupported statement type: {}",
+                error_msg
+            );
+        }
+    });
+}
+
+#[test]
+fn sql_blocks_multi_statement() {
+    const SQL: &str = "SELECT * FROM musician; SELECT * FROM band";
+
+    run_sql_query(SQL, |result, _| {
+        assert!(result.is_err(), "Multi-statement queries should be blocked");
+        if let Err(e) = result {
+            let error_msg = e.to_string();
+            assert!(
+                error_msg.contains("Multi statement is not supported")
+                    || error_msg.contains("multiple statements"),
+                "Error should mention multi-statement restriction: {}",
+                error_msg
+            );
+        }
+    });
+}
+
+#[test]
+fn sql_can_query_with_case_expression() {
+    const SQL: &str = "
+        SELECT
+            id,
+            name,
+            CASE
+                WHEN favorite_count > 10 THEN 'popular'
+                WHEN favorite_count > 5 THEN 'liked'
+                ELSE 'normal'
+            END as popularity
+        FROM musician
+        ORDER BY id
+        LIMIT 5
+    ";
+
+    run_sql_query(SQL, |result, _| {
+        let results = result.expect("SQL query with CASE should succeed");
+        assert!(
+            results.len() <= 5,
+            "Should return limited musicians with popularity"
+        );
+
+        // Check that popularity field exists in first result
+        if let Some(first) = results.first()
+            && let r::Value::Object(ref obj) = first.0
+        {
+            assert!(
+                obj.get("popularity").is_some(),
+                "Should have popularity field"
+            );
+        }
+    });
+}
+
+#[test]
+fn sql_can_query_with_subquery() {
+    const SQL: &str = "
+        WITH active_musicians AS (
+            SELECT id, name
+            FROM musician
+            WHERE name IS NOT NULL
+        )
+        SELECT COUNT(*) as active_count FROM active_musicians
+    ";
+
+    run_sql_query(SQL, |result, _| {
+        let results = result.expect("SQL query with CTE should succeed");
+        assert_eq!(results.len(), 1, "Should return one count result");
+
+        if let Some(first) = results.first()
+            && let r::Value::Object(ref obj) = first.0
+        {
+            let count = obj.get("active_count");
+            assert!(count.is_some(), "Should have active_count field");
+        }
+    });
+}
diff --git a/store/test-store/tests/postgres/aggregation.rs b/store/test-store/tests/postgres/aggregation.rs
index 756d0184d28..f005a15b73d 100644
--- a/store/test-store/tests/postgres/aggregation.rs
+++ b/store/test-store/tests/postgres/aggregation.rs
@@ -1,19 +1,22 @@
+use std::collections::BTreeSet;
 use std::fmt::Write;
 use std::{future::Future, sync::Arc};
 
 use graph::{
-    blockchain::{block_stream::FirehoseCursor, BlockPtr, BlockTime},
+    blockchain::{BlockPtr, BlockTime, block_stream::FirehoseCursor},
     components::{
         metrics::stopwatch::StopwatchMetrics,
         store::{
-            AttributeNames, BlockNumber, DeploymentLocator, EntityCache, EntityCollection,
-            EntityOperation, EntityQuery, ReadStore, StoreError, SubgraphStore as _, WritableStore,
+            AggregationCurrent, AttributeNames, BlockNumber, ChildMultiplicity, DeploymentLocator,
+            EntityCache, EntityCollection, EntityFilter, EntityLink, EntityOperation, EntityQuery,
+            EntityWindow, ReadStore, SeqGenerator, StoreError, SubgraphStore as _, WindowAttribute,
+            WritableStore,
         },
     },
     data::{
         store::{
-            scalar::{BigDecimal, Bytes},
-            Entity, Value,
+            Entity, Id, IdList, Value,
+            scalar::{BigDecimal, Bytes, Timestamp},
         },
         subgraph::DeploymentHash,
     },
@@ -21,31 +24,42 @@ use graph::{
     prelude::lazy_static,
     schema::InputSchema,
 };
-use graph_store_postgres::{Store as DieselStore, SubgraphStore};
-use test_store::{create_test_subgraph, run_test_sequentially, BLOCKS, LOGGER, METRICS_REGISTRY};
+use graph_store_postgres::Store as DieselStore;
+use test_store::{
+    BLOCKS, LOGGER, METRICS_REGISTRY, STOPWATCH, create_test_subgraph, remove_subgraphs,
+    run_test_sequentially,
+};
 
 const SCHEMA: &str = r#"
-type Data @entity(timeseries: true) {
+type Token @entity {
+    id: Bytes!
+    name: String!
+  }
+
+  type Data @entity(timeseries: true) {
     id: Int8!
-    timestamp: Int8!
-    token: Bytes!
+    timestamp: Timestamp!
+    token: Token!
     price: BigDecimal!
     amount: BigDecimal!
   }
 
   type Stats @aggregation(intervals: ["day", "hour"], source: "Data") {
     id: Int8!
-    timestamp: Int8!
-    token: Bytes!
+    timestamp: Timestamp!
+    token: Token!
     sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
+    sum_sq: BigDecimal! @aggregate(fn: "sum", arg: "price * price")
     max: BigDecimal! @aggregate(fn: "max", arg: "amount")
-    first: BigDecimal! @aggregate(fn: "first", arg: "amount")
+    first: BigDecimal @aggregate(fn: "first", arg: "amount")
     last: BigDecimal! @aggregate(fn: "last", arg: "amount")
+    value: BigDecimal! @aggregate(fn: "sum", arg: "price * amount")
+    totalValue: BigDecimal! @aggregate(fn: "sum", arg: "price * amount", cumulative: true)
   }
 
   type TotalStats @aggregation(intervals: ["hour"], source: "Data") {
     id: Int8!
-    timestamp: Int8!
+    timestamp: Timestamp!
     max: BigDecimal! @aggregate(fn: "max", arg: "price")
   }
   "#;
@@ -57,36 +71,51 @@ fn minutes(n: u32) -> BlockTime {
 lazy_static! {
     static ref TOKEN1: Bytes = "0xdeadbeef01".parse().unwrap();
     static ref TOKEN2: Bytes = "0xdeadbeef02".parse().unwrap();
-    static ref TIMES: Vec<BlockTime> = vec![minutes(30), minutes(40), minutes(65), minutes(120)];
+    static ref TOKEN3: Bytes = "0xdeadbeef03".parse().unwrap();
+    static ref TIMES: Vec<BlockTime> = vec![minutes(30), minutes(40), minutes(65), minutes(121)];
 }
 
-fn remove_test_data(store: Arc<SubgraphStore>) {
-    store
-        .delete_all_entities_for_test_use_only()
-        .expect("deleting test entities succeeds");
-}
+const STATS_HOUR_FIELDS: &[&str] = &[
+    "id",
+    "timestamp",
+    "token",
+    "sum",
+    "sum_sq",
+    "max",
+    "first",
+    "last",
+    "value",
+    "totalValue",
+];
 
-pub async fn insert(
+pub async fn insert_entities(
     store: &Arc<dyn WritableStore>,
     deployment: &DeploymentLocator,
     block_ptr_to: BlockPtr,
     block_time: BlockTime,
-    entities: Vec<Entity>,
+    typed_entities: Vec<(&str, Vec<Entity>)>,
 ) -> Result<(), StoreError> {
     let schema = ReadStore::input_schema(store);
-    let ops = entities
+    let ops: Vec<EntityOperation> = typed_entities
         .into_iter()
-        .map(|data| {
-            let data_type = schema.entity_type("Data").unwrap();
-            let key = data_type.key(data.id());
-            EntityOperation::Set { data, key }
+        .flat_map(|(type_name, entities)| {
+            let entity_type = schema.entity_type(type_name).unwrap();
+            entities.into_iter().map(move |mut data| {
+                let key = entity_type.key(data.id());
+                data.set_vid_if_empty();
+                EntityOperation::Set { data, key }
+            })
         })
         .collect();
 
-    let mut entity_cache = EntityCache::new(Arc::new(store.clone()));
+    let mut entity_cache = EntityCache::new(
+        Arc::new(store.clone()),
+        SeqGenerator::new(block_ptr_to.number),
+    );
     entity_cache.append(ops);
     let mods = entity_cache
-        .as_modifications(block_ptr_to.number)
+        .as_modifications(block_ptr_to.number, &STOPWATCH)
+        .await
         .expect("failed to convert to modifications")
         .modifications;
     let metrics_registry = METRICS_REGISTRY.clone();
@@ -108,49 +137,83 @@ pub async fn insert(
             Vec::new(),
             Vec::new(),
             false,
+            false,
         )
         .await
 }
 
+pub async fn insert(
+    store: &Arc<dyn WritableStore>,
+    deployment: &DeploymentLocator,
+    block_ptr_to: BlockPtr,
+    block_time: BlockTime,
+    entities: Vec<Entity>,
+) -> Result<(), StoreError> {
+    insert_entities(
+        store,
+        deployment,
+        block_ptr_to,
+        block_time,
+        vec![("Data", entities)],
+    )
+    .await
+}
+
 fn bd(n: i32) -> Value {
     Value::BigDecimal(BigDecimal::from(n))
 }
 
+fn ts(epoch_secs: i64) -> Value {
+    Value::Timestamp(Timestamp::since_epoch(epoch_secs, 0).unwrap())
+}
+
 async fn insert_test_data(store: Arc<dyn WritableStore>, deployment: DeploymentLocator) {
     let schema = ReadStore::input_schema(&store);
 
-    let ts64 = TIMES[0].as_secs_since_epoch();
-    let entities = vec![
-        entity! { schema => id: 1i64, timestamp: ts64, token: TOKEN1.clone(), price: bd(1), amount: bd(10) },
-        entity! { schema => id: 2i64, timestamp: ts64, token: TOKEN2.clone(), price: bd(1), amount: bd(1) },
+    // Insert Token entities alongside first Data entities at BLOCKS[0]
+    let token_entities = vec![
+        entity! { schema => id: TOKEN1.clone(), name: "Token1", vid: 1i64 },
+        entity! { schema => id: TOKEN2.clone(), name: "Token2", vid: 2i64 },
+        entity! { schema => id: TOKEN3.clone(), name: "Token3", vid: 3i64 },
+    ];
+    let ts64 = TIMES[0];
+    let data_entities = vec![
+        entity! { schema => id: 1i64, timestamp: ts64, token: TOKEN1.clone(), price: bd(1), amount: bd(10), vid: 11i64 },
+        entity! { schema => id: 2i64, timestamp: ts64, token: TOKEN2.clone(), price: bd(1), amount: bd(1), vid: 12i64 },
     ];
 
-    insert(&store, &deployment, BLOCKS[0].clone(), TIMES[0], entities)
-        .await
-        .unwrap();
+    insert_entities(
+        &store,
+        &deployment,
+        BLOCKS[0].clone(),
+        TIMES[0],
+        vec![("Token", token_entities), ("Data", data_entities)],
+    )
+    .await
+    .unwrap();
 
-    let ts64 = TIMES[1].as_secs_since_epoch();
+    let ts64 = TIMES[1];
     let entities = vec![
-        entity! { schema => id: 11i64, timestamp: ts64, token: TOKEN1.clone(), price: bd(2), amount: bd(2) },
-        entity! { schema => id: 12i64, timestamp: ts64, token: TOKEN2.clone(), price: bd(2), amount: bd(20) },
+        entity! { schema => id: 11i64, timestamp: ts64, token: TOKEN1.clone(), price: bd(2), amount: bd(2), vid: 21i64 },
+        entity! { schema => id: 12i64, timestamp: ts64, token: TOKEN2.clone(), price: bd(2), amount: bd(20), vid: 22i64 },
     ];
     insert(&store, &deployment, BLOCKS[1].clone(), TIMES[1], entities)
         .await
         .unwrap();
 
-    let ts64 = TIMES[2].as_secs_since_epoch();
+    let ts64 = TIMES[2];
     let entities = vec![
-        entity! { schema => id: 21i64, timestamp: ts64, token: TOKEN1.clone(), price: bd(3), amount: bd(30) },
-        entity! { schema => id: 22i64, timestamp: ts64, token: TOKEN2.clone(), price: bd(3), amount: bd(3) },
+        entity! { schema => id: 21i64, timestamp: ts64, token: TOKEN1.clone(), price: bd(3), amount: bd(30), vid: 31i64 },
+        entity! { schema => id: 22i64, timestamp: ts64, token: TOKEN2.clone(), price: bd(3), amount: bd(3), vid: 32i64 },
     ];
     insert(&store, &deployment, BLOCKS[2].clone(), TIMES[2], entities)
         .await
         .unwrap();
 
-    let ts64 = TIMES[3].as_secs_since_epoch();
+    let ts64 = TIMES[3];
     let entities = vec![
-        entity! { schema => id: 31i64, timestamp: ts64, token: TOKEN1.clone(), price: bd(4), amount: bd(4) },
-        entity! { schema => id: 32i64, timestamp: ts64, token: TOKEN2.clone(), price: bd(4), amount: bd(40) },
+        entity! { schema => id: 31i64, timestamp: ts64, token: TOKEN1.clone(), price: bd(4), amount: bd(4), vid: 41i64 },
+        entity! { schema => id: 32i64, timestamp: ts64, token: TOKEN2.clone(), price: bd(4), amount: bd(40), vid: 42i64 },
     ];
     insert(&store, &deployment, BLOCKS[3].clone(), TIMES[3], entities)
         .await
@@ -165,17 +228,27 @@ fn stats_hour(schema: &InputSchema) -> Vec<Vec<Entity>> {
     // block after the aggregation interval has finished
 
     // Stats_hour aggregations over BLOCKS[0..=1], i.e., at BLOCKS[2]
+    let ts2 = BlockTime::since_epoch(0, 0);
     let block2 = vec![
-        entity! { schema => id: 11i64, timestamp: 0i64, token: TOKEN1.clone(), sum: bd(3), max: bd(10), first: bd(10), last: bd(2) },
-        entity! { schema => id: 12i64, timestamp: 0i64, token: TOKEN2.clone(), sum: bd(3), max: bd(20), first: bd(1),  last: bd(20) },
+        entity! { schema => id: 11i64, timestamp: ts2, token: TOKEN1.clone(),
+        sum: bd(3), sum_sq: bd(5), max: bd(10), first: bd(10), last: bd(2),
+        value: bd(14), totalValue: bd(14), vid: 1i64 },
+        entity! { schema => id: 12i64, timestamp: ts2, token: TOKEN2.clone(),
+        sum: bd(3), sum_sq: bd(5), max: bd(20), first: bd(1),  last: bd(20),
+        value: bd(41), totalValue: bd(41), vid: 2i64 },
     ];
 
+    let ts3 = BlockTime::since_epoch(3600, 0);
     let block3 = {
         let mut v1 = block2.clone();
         // Stats_hour aggregations over BLOCKS[2], i.e., at BLOCKS[3]
         let mut v2 = vec![
-            entity! { schema => id: 21i64, timestamp: 3600i64, token: TOKEN1.clone(), sum: bd(3), max: bd(30), first: bd(30), last: bd(30) },
-            entity! { schema => id: 22i64, timestamp: 3600i64, token: TOKEN2.clone(), sum: bd(3), max: bd(3),  first: bd(3), last: bd(3) },
+            entity! { schema => id: 21i64, timestamp: ts3, token: TOKEN1.clone(),
+            sum: bd(3), sum_sq: bd(9), max: bd(30), first: bd(30), last: bd(30),
+            value: bd(90), totalValue: bd(104), vid: 3i64 },
+            entity! { schema => id: 22i64, timestamp: ts3, token: TOKEN2.clone(),
+            sum: bd(3), sum_sq: bd(9), max: bd(3),  first: bd(3), last: bd(3),
+            value: bd(9), totalValue: bd(50), vid: 4i64 },
         ];
         v1.append(&mut v2);
         v1
@@ -191,8 +264,7 @@ struct TestEnv {
 }
 
 impl TestEnv {
-    #[track_caller]
-    fn all_entities(&self, entity_type: &str, block: BlockNumber) -> Vec<Entity> {
+    async fn all_entities(&self, entity_type: &str, block: BlockNumber) -> Vec<Entity> {
         let entity_type = self
             .writable
             .input_schema()
@@ -206,8 +278,99 @@ impl TestEnv {
         self.store
             .subgraph_store()
             .find(query)
+            .await
             .expect("query succeeds")
     }
+
+    /// Build an `EntityQuery` for an aggregation entity with explicit column
+    /// selection and configurable `AggregationCurrent`. The current bucket
+    /// UNION ALL query requires `AttributeNames::Select` (not `All`).
+    fn aggregation_query(
+        &self,
+        entity_type_name: &str,
+        current: AggregationCurrent,
+        block: BlockNumber,
+    ) -> EntityQuery {
+        let schema = self.writable.input_schema();
+        let entity_type = schema
+            .entity_type(entity_type_name)
+            .expect("entity type exists");
+
+        let columns: BTreeSet<String> = STATS_HOUR_FIELDS.iter().map(|s| s.to_string()).collect();
+        let mut query = EntityQuery::new(
+            self.deployment.hash.clone(),
+            block,
+            EntityCollection::All(vec![(entity_type, AttributeNames::Select(columns))]),
+        );
+        query.aggregation_current = Some(current);
+        query
+    }
+
+    async fn find_aggregation(
+        &self,
+        entity_type_name: &str,
+        current: AggregationCurrent,
+        block: BlockNumber,
+    ) -> Vec<Entity> {
+        let query = self.aggregation_query(entity_type_name, current, block);
+        self.store
+            .subgraph_store()
+            .find(query)
+            .await
+            .expect("aggregation query succeeds")
+    }
+
+    /// Build an `EntityQuery` for a nested aggregation using
+    /// `EntityCollection::Window` where Token is the parent and Stats_hour
+    /// is the child.
+    fn nested_aggregation_query(
+        &self,
+        current: AggregationCurrent,
+        block: BlockNumber,
+        parent_ids: &[&Bytes],
+    ) -> EntityQuery {
+        let schema = self.writable.input_schema();
+        let child_type = schema.entity_type("Stats_hour").expect("Stats_hour exists");
+
+        let columns: BTreeSet<String> = STATS_HOUR_FIELDS.iter().map(|s| s.to_string()).collect();
+
+        let mut ids = IdList::new(graph::data::store::IdType::Bytes);
+        for pid in parent_ids {
+            ids.push(Id::Bytes((*pid).clone())).expect("push parent id");
+        }
+
+        let window = EntityWindow {
+            child_type,
+            ids,
+            link: EntityLink::Direct(
+                WindowAttribute::Scalar("token".to_string()),
+                ChildMultiplicity::Many,
+            ),
+            column_names: AttributeNames::Select(columns),
+        };
+
+        let mut query = EntityQuery::new(
+            self.deployment.hash.clone(),
+            block,
+            EntityCollection::Window(vec![window]),
+        );
+        query.aggregation_current = Some(current);
+        query
+    }
+
+    async fn find_nested_aggregation(
+        &self,
+        current: AggregationCurrent,
+        block: BlockNumber,
+        parent_ids: &[&Bytes],
+    ) -> Vec<Entity> {
+        let query = self.nested_aggregation_query(current, block, parent_ids);
+        self.store
+            .subgraph_store()
+            .find(query)
+            .await
+            .expect("nested aggregation query succeeds")
+    }
 }
 
 fn run_test<R, F>(test: F)
@@ -216,9 +379,8 @@ where
     R: Future<Output = ()> + Send + 'static,
 {
     run_test_sequentially(|store| async move {
-        let subgraph_store = store.subgraph_store();
         // Reset state before starting
-        remove_test_data(subgraph_store.clone());
+        remove_subgraphs().await;
 
         // Seed database with test data
         let hash = DeploymentHash::new("rollupSubgraph").unwrap();
@@ -273,12 +435,12 @@ fn entity_diff(left: &[Entity], right: &[Entity]) -> Result<String, std::fmt::Er
 #[test]
 fn simple() {
     run_test(|env| async move {
-        let x = env.all_entities("Stats_day", BlockNumber::MAX);
+        let x = env.all_entities("Stats_day", BlockNumber::MAX).await;
         assert_eq!(Vec::<Entity>::new(), x);
 
         let exp = stats_hour(&env.writable.input_schema());
         for i in 0..4 {
-            let act = env.all_entities("Stats_hour", BLOCKS[i].number);
+            let act = env.all_entities("Stats_hour", BLOCKS[i].number).await;
             let diff = entity_diff(&exp[i], &act).unwrap();
             if !diff.is_empty() {
                 panic!("entities for BLOCKS[{}] differ:\n{}", i, diff);
@@ -287,3 +449,401 @@ fn simple() {
         }
     })
 }
+
+/// Query Stats_hour with AggregationCurrent::Include at BLOCKS[3].
+/// Expect 6 rows: 2 rolled-up from hour 0, 2 from hour 1, and 2
+/// current-bucket rows from hour 2 computed on-the-fly.
+#[test]
+fn current_include() {
+    run_test(|env| async move {
+        let result = env
+            .find_aggregation("Stats_hour", AggregationCurrent::Include, BLOCKS[3].number)
+            .await;
+
+        assert_eq!(
+            6,
+            result.len(),
+            "expected 6 rows (2 per hour for hours 0, 1, 2), got {}",
+            result.len()
+        );
+
+        let schema = env.writable.input_schema();
+
+        // The rolled-up rows (hours 0 and 1) should match the existing
+        // stats_hour expected data at BLOCKS[3].
+        let exp_rolled = stats_hour(&schema);
+        let hour2_ts = ts(7200);
+        let rolled_up: Vec<&Entity> = result
+            .iter()
+            .filter(|e| e.get("timestamp").unwrap() != &hour2_ts)
+            .collect();
+        assert_eq!(
+            4,
+            rolled_up.len(),
+            "expected 4 rolled-up rows, got {}",
+            rolled_up.len()
+        );
+
+        // Verify rolled-up entities match
+        for exp_entity in &exp_rolled[3] {
+            let matching = rolled_up.iter().find(|e| e.id() == exp_entity.id());
+            assert!(
+                matching.is_some(),
+                "expected rolled-up entity with id {} not found",
+                exp_entity.id()
+            );
+        }
+
+        // Current bucket rows (hour 2, timestamp = 7200)
+        let current_bucket: Vec<&Entity> = result
+            .iter()
+            .filter(|e| e.get("timestamp").unwrap() == &hour2_ts)
+            .collect();
+        assert_eq!(
+            2,
+            current_bucket.len(),
+            "expected 2 current-bucket rows for hour 2, got {}",
+            current_bucket.len()
+        );
+
+        // Verify current bucket values for TOKEN1:
+        // At BLOCKS[3], minute 120: price=4, amount=4
+        // sum(price) = 4, sum(price*price) = 16, max(amount) = 4,
+        // first(amount) = 4, last(amount) = 4, sum(price*amount) = 16
+        let token1_current = current_bucket
+            .iter()
+            .find(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN1.clone()))
+            .expect("TOKEN1 current bucket row exists");
+        assert_eq!(token1_current.get("sum").unwrap(), &bd(4));
+        assert_eq!(token1_current.get("sum_sq").unwrap(), &bd(16));
+        assert_eq!(token1_current.get("max").unwrap(), &bd(4));
+        assert_eq!(token1_current.get("first").unwrap(), &bd(4));
+        assert_eq!(token1_current.get("last").unwrap(), &bd(4));
+        assert_eq!(token1_current.get("value").unwrap(), &bd(16));
+
+        // Verify current bucket values for TOKEN2:
+        // At BLOCKS[3], minute 120: price=4, amount=40
+        // sum(price) = 4, sum(price*price) = 16, max(amount) = 40,
+        // first(amount) = 40, last(amount) = 40, sum(price*amount) = 160
+        let token2_current = current_bucket
+            .iter()
+            .find(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN2.clone()))
+            .expect("TOKEN2 current bucket row exists");
+        assert_eq!(token2_current.get("sum").unwrap(), &bd(4));
+        assert_eq!(token2_current.get("sum_sq").unwrap(), &bd(16));
+        assert_eq!(token2_current.get("max").unwrap(), &bd(40));
+        assert_eq!(token2_current.get("first").unwrap(), &bd(40));
+        assert_eq!(token2_current.get("last").unwrap(), &bd(40));
+        assert_eq!(token2_current.get("value").unwrap(), &bd(160));
+    })
+}
+
+/// Query Stats_hour with AggregationCurrent::Exclude at BLOCKS[3].
+/// Should return only the 4 rolled-up rows, same as the `simple` test.
+#[test]
+fn current_exclude() {
+    run_test(|env| async move {
+        let result = env
+            .find_aggregation("Stats_hour", AggregationCurrent::Exclude, BLOCKS[3].number)
+            .await;
+
+        let exp = stats_hour(&env.writable.input_schema());
+        assert_eq!(
+            exp[3].len(),
+            result.len(),
+            "expected {} rolled-up rows, got {}",
+            exp[3].len(),
+            result.len()
+        );
+
+        let diff = entity_diff(&exp[3], &result).unwrap();
+        if !diff.is_empty() {
+            panic!(
+                "current_exclude results differ from expected rolled-up data:\n{}",
+                diff
+            );
+        }
+    })
+}
+
+/// Query Stats_hour with AggregationCurrent::Include and an EntityFilter
+/// on token == TOKEN1. Should return 3 rows: TOKEN1 for hours 0, 1, and 2.
+#[test]
+fn current_include_with_filter() {
+    run_test(|env| async move {
+        let mut query =
+            env.aggregation_query("Stats_hour", AggregationCurrent::Include, BLOCKS[3].number);
+        query.filter = Some(EntityFilter::Equal(
+            "token".to_string(),
+            Value::Bytes(TOKEN1.clone()),
+        ));
+
+        let result = env
+            .store
+            .subgraph_store()
+            .find(query)
+            .await
+            .expect("filtered aggregation query succeeds");
+
+        assert_eq!(
+            3,
+            result.len(),
+            "expected 3 rows for TOKEN1 (hours 0, 1, 2), got {}",
+            result.len()
+        );
+
+        // All rows should be for TOKEN1
+        for entity in &result {
+            assert_eq!(
+                entity.get("token").unwrap(),
+                &Value::Bytes(TOKEN1.clone()),
+                "all rows should be for TOKEN1"
+            );
+        }
+
+        // Verify we have one row per hour (timestamps 0, 3600, 7200)
+        for expected_ts in [ts(0), ts(3600), ts(7200)] {
+            assert!(
+                result
+                    .iter()
+                    .any(|e| e.get("timestamp").unwrap() == &expected_ts),
+                "expected a row with timestamp {:?}",
+                expected_ts
+            );
+        }
+    })
+}
+
+/// Query Stats_hour with AggregationCurrent::Include and verify cumulative
+/// aggregate `totalValue` in the current bucket rows.
+/// For TOKEN1: prev hour 1 totalValue=104, current hour 2 value=4*4=16,
+///   so totalValue = 104 + 16 = 120
+/// For TOKEN2: prev hour 1 totalValue=50, current hour 2 value=4*40=160,
+///   so totalValue = 50 + 160 = 210
+#[test]
+fn current_include_cumulative() {
+    run_test(|env| async move {
+        let result = env
+            .find_aggregation("Stats_hour", AggregationCurrent::Include, BLOCKS[3].number)
+            .await;
+
+        let hour2_ts = ts(7200);
+        let current_bucket: Vec<&Entity> = result
+            .iter()
+            .filter(|e| e.get("timestamp").unwrap() == &hour2_ts)
+            .collect();
+        assert_eq!(
+            2,
+            current_bucket.len(),
+            "expected 2 current-bucket rows, got {}",
+            current_bucket.len()
+        );
+
+        let token1 = current_bucket
+            .iter()
+            .find(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN1.clone()))
+            .expect("TOKEN1 current bucket exists");
+        assert_eq!(
+            token1.get("totalValue").unwrap(),
+            &bd(120),
+            "TOKEN1 cumulative totalValue = 104 + 16 = 120"
+        );
+
+        let token2 = current_bucket
+            .iter()
+            .find(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN2.clone()))
+            .expect("TOKEN2 current bucket exists");
+        assert_eq!(
+            token2.get("totalValue").unwrap(),
+            &bd(210),
+            "TOKEN2 cumulative totalValue = 50 + 160 = 210"
+        );
+    })
+}
+
+/// Query Stats_hour as a nested field of Token with
+/// AggregationCurrent::Include at BLOCKS[3]. Each token should have
+/// 2 rolled-up rows (hour 0 and hour 1) + 1 current bucket row (hour 2).
+/// Total: 3 rows per token, 6 rows overall.
+#[test]
+fn nested_current_include() {
+    run_test(|env| async move {
+        let result = env
+            .find_nested_aggregation(
+                AggregationCurrent::Include,
+                BLOCKS[3].number,
+                &[&TOKEN1, &TOKEN2],
+            )
+            .await;
+
+        assert_eq!(
+            6,
+            result.len(),
+            "expected 6 rows (3 per token for hours 0, 1, 2), got {}",
+            result.len()
+        );
+
+        let hour2_ts = ts(7200);
+
+        // Current bucket rows (hour 2, timestamp = 7200)
+        let current_bucket: Vec<&Entity> = result
+            .iter()
+            .filter(|e| e.get("timestamp").unwrap() == &hour2_ts)
+            .collect();
+        assert_eq!(
+            2,
+            current_bucket.len(),
+            "expected 2 current-bucket rows for hour 2, got {}",
+            current_bucket.len()
+        );
+
+        // Verify current bucket values for TOKEN1: sum=4, max=4
+        let token1_current = current_bucket
+            .iter()
+            .find(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN1.clone()))
+            .expect("TOKEN1 current bucket row exists");
+        assert_eq!(token1_current.get("sum").unwrap(), &bd(4));
+        assert_eq!(token1_current.get("max").unwrap(), &bd(4));
+
+        // Verify current bucket values for TOKEN2: sum=4, max=40
+        let token2_current = current_bucket
+            .iter()
+            .find(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN2.clone()))
+            .expect("TOKEN2 current bucket row exists");
+        assert_eq!(token2_current.get("sum").unwrap(), &bd(4));
+        assert_eq!(token2_current.get("max").unwrap(), &bd(40));
+    })
+}
+
+/// Query Stats_hour as a nested field of Token with
+/// AggregationCurrent::Exclude at BLOCKS[3]. Should return only
+/// the 4 rolled-up rows (2 per token, hours 0 and 1).
+#[test]
+fn nested_current_exclude() {
+    run_test(|env| async move {
+        let result = env
+            .find_nested_aggregation(
+                AggregationCurrent::Exclude,
+                BLOCKS[3].number,
+                &[&TOKEN1, &TOKEN2],
+            )
+            .await;
+
+        assert_eq!(
+            4,
+            result.len(),
+            "expected 4 rolled-up rows (2 per token), got {}",
+            result.len()
+        );
+
+        // No current bucket row should appear (no hour 2 timestamp)
+        let hour2_ts = ts(7200);
+        let current_bucket: Vec<&Entity> = result
+            .iter()
+            .filter(|e| e.get("timestamp").unwrap() == &hour2_ts)
+            .collect();
+        assert_eq!(
+            0,
+            current_bucket.len(),
+            "expected no current-bucket rows, got {}",
+            current_bucket.len()
+        );
+    })
+}
+
+/// Query at BLOCKS[3] with AggregationCurrent::Include, including TOKEN3
+/// which has no Data entries at all. TOKEN1 and TOKEN2 each have 3 rows
+/// (2 rolled-up + 1 current bucket). TOKEN3 should have 0 rows because
+/// it has no timeseries data — no rolled-up buckets and no current bucket.
+#[test]
+fn nested_current_include_empty_bucket() {
+    run_test(|env| async move {
+        // Query with TOKEN1, TOKEN2, and TOKEN3
+        let result = env
+            .find_nested_aggregation(
+                AggregationCurrent::Include,
+                BLOCKS[3].number,
+                &[&TOKEN1, &TOKEN2, &TOKEN3],
+            )
+            .await;
+
+        assert_eq!(
+            6,
+            result.len(),
+            "expected 6 rows (3 per token for TOKEN1/TOKEN2, 0 for TOKEN3), got {}",
+            result.len()
+        );
+
+        // TOKEN1 and TOKEN2 each have 3 rows (2 rolled-up + 1 current)
+        let token1_rows: Vec<&Entity> = result
+            .iter()
+            .filter(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN1.clone()))
+            .collect();
+        assert_eq!(
+            3,
+            token1_rows.len(),
+            "expected 3 rows for TOKEN1, got {}",
+            token1_rows.len()
+        );
+
+        let token2_rows: Vec<&Entity> = result
+            .iter()
+            .filter(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN2.clone()))
+            .collect();
+        assert_eq!(
+            3,
+            token2_rows.len(),
+            "expected 3 rows for TOKEN2, got {}",
+            token2_rows.len()
+        );
+
+        // TOKEN3 has no data entries, so no rows should appear
+        let token3_rows: Vec<&Entity> = result
+            .iter()
+            .filter(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN3.clone()))
+            .collect();
+        assert_eq!(
+            0,
+            token3_rows.len(),
+            "expected 0 rows for TOKEN3 (no timeseries data), got {}",
+            token3_rows.len()
+        );
+    })
+}
+
+/// Verify result counts per parent token at BLOCKS[3] with
+/// AggregationCurrent::Include. TOKEN1 should have 3 rows and
+/// TOKEN2 should have 3 rows.
+#[test]
+fn nested_current_include_count() {
+    run_test(|env| async move {
+        let result = env
+            .find_nested_aggregation(
+                AggregationCurrent::Include,
+                BLOCKS[3].number,
+                &[&TOKEN1, &TOKEN2],
+            )
+            .await;
+
+        // Group results by token (dimension) to count per parent
+        let token1_count = result
+            .iter()
+            .filter(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN1.clone()))
+            .count();
+        let token2_count = result
+            .iter()
+            .filter(|e| e.get("token").unwrap() == &Value::Bytes(TOKEN2.clone()))
+            .count();
+
+        assert_eq!(
+            3, token1_count,
+            "TOKEN1 should have 3 rows (2 rolled-up + 1 current), got {}",
+            token1_count
+        );
+        assert_eq!(
+            3, token2_count,
+            "TOKEN2 should have 3 rows (2 rolled-up + 1 current), got {}",
+            token2_count
+        );
+    })
+}
diff --git a/store/test-store/tests/postgres/chain_head.rs b/store/test-store/tests/postgres/chain_head.rs
index ef9e00b3f59..d72641b29b6 100644
--- a/store/test-store/tests/postgres/chain_head.rs
+++ b/store/test-store/tests/postgres/chain_head.rs
@@ -1,26 +1,32 @@
 //! Test ChainStore implementation of Store, in particular, how
 //! the chain head pointer gets updated in various situations
 
+use diesel_async::RunQueryDsl;
 use graph::blockchain::{BlockHash, BlockPtr};
+use graph::data::store::ethereum::call;
+use graph::data::store::scalar::Bytes;
 use graph::env::ENV_VARS;
-use graph::prelude::futures03::executor;
+use graph::futures03::executor;
+use graph::prelude::alloy::primitives::{Address, B256};
 use std::future::Future;
 use std::sync::Arc;
 
-use graph::prelude::web3::types::H256;
-use graph::prelude::{anyhow::anyhow, anyhow::Error};
-use graph::prelude::{serde_json as json, EthereumBlock};
+use graph::cheap_clone::CheapClone;
+use graph::prelude::alloy;
 use graph::prelude::{BlockNumber, QueryStoreManager, QueryTarget};
-use graph::{cheap_clone::CheapClone, prelude::web3::types::H160};
+use graph::prelude::{anyhow::Error, anyhow::anyhow};
 use graph::{components::store::BlockStore as _, prelude::DeploymentHash};
-use graph::{components::store::ChainStore as _, prelude::EthereumCallCache as _};
+use graph::{
+    components::store::ChainHeadStore as _, components::store::ChainStore as _,
+    prelude::EthereumCallCache as _,
+};
 use graph_store_postgres::Store as DieselStore;
-use graph_store_postgres::{layout_for_tests::FAKE_NETWORK_SHARED, ChainStore as DieselChainStore};
+use graph_store_postgres::{ChainStore as DieselChainStore, layout_for_tests::FAKE_NETWORK_SHARED};
 
 use test_store::block_store::{
-    FakeBlock, FakeBlockList, BLOCK_FIVE, BLOCK_FOUR, BLOCK_ONE, BLOCK_ONE_NO_PARENT,
-    BLOCK_ONE_SIBLING, BLOCK_THREE, BLOCK_THREE_NO_PARENT, BLOCK_TWO, BLOCK_TWO_NO_PARENT,
-    GENESIS_BLOCK, NO_PARENT,
+    BLOCK_FIVE, BLOCK_FIVE_AFTER_SKIP, BLOCK_FOUR, BLOCK_FOUR_SKIPPED_2_AND_3, BLOCK_ONE,
+    BLOCK_ONE_NO_PARENT, BLOCK_ONE_SIBLING, BLOCK_THREE, BLOCK_THREE_NO_PARENT, BLOCK_TWO,
+    BLOCK_TWO_NO_PARENT, FakeBlock, FakeBlockList, GENESIS_BLOCK, NO_PARENT,
 };
 use test_store::*;
 
@@ -37,11 +43,19 @@ where
         for name in &[NETWORK_NAME, FAKE_NETWORK_SHARED] {
             block_store::set_chain(chain.clone(), name).await;
 
-            let chain_store = store.block_store().chain_store(name).expect("chain store");
+            let chain_store = store
+                .block_store()
+                .chain_store(name)
+                .await
+                .expect("chain store");
 
             // Run test
-            test(chain_store.cheap_clone(), store.cheap_clone())
-                .unwrap_or_else(|_| panic!("test finishes successfully on network {}", name));
+            test(chain_store.cheap_clone(), store.cheap_clone()).unwrap_or_else(|err| {
+                panic!(
+                    "test finishes successfully on network {} with error {}",
+                    name, err
+                )
+            });
         }
     });
 }
@@ -58,7 +72,11 @@ where
         for name in &[NETWORK_NAME, FAKE_NETWORK_SHARED] {
             let cached = block_store::set_chain(chain.clone(), name).await;
 
-            let chain_store = store.block_store().chain_store(name).expect("chain store");
+            let chain_store = store
+                .block_store()
+                .chain_store(name)
+                .await
+                .expect("chain store");
 
             // Run test
             test(chain_store.cheap_clone(), store.clone(), cached).await;
@@ -213,10 +231,10 @@ fn test_get_block_number() {
             create_test_subgraph(&subgraph, "type Dummy @entity { id: ID! }").await;
 
             let query_store = subgraph_store
-                .query_store(
-                    QueryTarget::Deployment(subgraph.cheap_clone(), Default::default()),
-                    false,
-                )
+                .query_store(QueryTarget::Deployment(
+                    subgraph.cheap_clone(),
+                    Default::default(),
+                ))
                 .await
                 .unwrap();
 
@@ -249,40 +267,42 @@ fn block_hashes_by_number() {
         &*BLOCK_TWO,
         &*BLOCK_TWO_NO_PARENT,
     ];
-    run_test(chain, move |store, _| {
-        let hashes = store.block_hashes_by_block_number(1).unwrap();
+    run_test_async(chain, move |store, _, _| async move {
+        let hashes = store.block_hashes_by_block_number(1).await.unwrap();
         assert_eq!(vec![BLOCK_ONE.block_hash()], hashes);
 
-        let hashes = store.block_hashes_by_block_number(2).unwrap();
+        let hashes = store.block_hashes_by_block_number(2).await.unwrap();
         assert_eq!(2, hashes.len());
         assert!(hashes.contains(&BLOCK_TWO.block_hash()));
         assert!(hashes.contains(&BLOCK_TWO_NO_PARENT.block_hash()));
 
-        let hashes = store.block_hashes_by_block_number(127).unwrap();
+        let hashes = store.block_hashes_by_block_number(127).await.unwrap();
         assert_eq!(0, hashes.len());
 
         let deleted = store
             .confirm_block_hash(1, &BLOCK_ONE.block_hash())
+            .await
             .unwrap();
         assert_eq!(0, deleted);
 
         let deleted = store
             .confirm_block_hash(2, &BLOCK_TWO.block_hash())
+            .await
             .unwrap();
         assert_eq!(1, deleted);
 
         // Make sure that we do not delete anything for a nonexistent block
         let deleted = store
             .confirm_block_hash(127, &GENESIS_BLOCK.block_hash())
+            .await
             .unwrap();
         assert_eq!(0, deleted);
 
-        let hashes = store.block_hashes_by_block_number(1).unwrap();
+        let hashes = store.block_hashes_by_block_number(1).await.unwrap();
         assert_eq!(vec![BLOCK_ONE.block_hash()], hashes);
 
-        let hashes = store.block_hashes_by_block_number(2).unwrap();
+        let hashes = store.block_hashes_by_block_number(2).await.unwrap();
         assert_eq!(vec![BLOCK_TWO.block_hash()], hashes);
-        Ok(())
     })
 }
 
@@ -292,16 +312,23 @@ fn check_ancestor(
     child: &FakeBlock,
     offset: BlockNumber,
     exp: &FakeBlock,
+    root: Option<BlockHash>,
 ) -> Result<(), Error> {
-    let act = executor::block_on(
-        store
-            .cheap_clone()
-            .ancestor_block(child.block_ptr(), offset),
-    )?
-    .map(json::from_value::<EthereumBlock>)
-    .transpose()?
+    let act = executor::block_on(store.cheap_clone().ancestor_block(
+        child.block_ptr(),
+        offset,
+        root,
+    ))?
     .ok_or_else(|| anyhow!("block {} has no ancestor at offset {}", child.hash, offset))?;
-    let act_hash = format!("{:x}", act.block.hash.unwrap());
+
+    let act_ptr = act.1;
+    let exp_ptr = exp.block_ptr();
+
+    if exp_ptr != act_ptr {
+        return Err(anyhow!("expected ptr `{}` but got `{}`", exp_ptr, act_ptr));
+    }
+
+    let act_hash = format!("{:x}", act.0.light_block().hash());
     let exp_hash = &exp.hash;
 
     if &act_hash != exp_hash {
@@ -327,24 +354,25 @@ fn ancestor_block_simple() {
     ];
 
     run_test(chain, move |store, _| -> Result<(), Error> {
-        check_ancestor(&store, &BLOCK_FIVE, 1, &BLOCK_FOUR)?;
-        check_ancestor(&store, &BLOCK_FIVE, 2, &BLOCK_THREE)?;
-        check_ancestor(&store, &BLOCK_FIVE, 3, &BLOCK_TWO)?;
-        check_ancestor(&store, &BLOCK_FIVE, 4, &BLOCK_ONE)?;
-        check_ancestor(&store, &BLOCK_FIVE, 5, &GENESIS_BLOCK)?;
-        check_ancestor(&store, &BLOCK_THREE, 2, &BLOCK_ONE)?;
+        check_ancestor(&store, &BLOCK_FIVE, 1, &BLOCK_FOUR, None)?;
+        check_ancestor(&store, &BLOCK_FIVE, 2, &BLOCK_THREE, None)?;
+        check_ancestor(&store, &BLOCK_FIVE, 3, &BLOCK_TWO, None)?;
+        check_ancestor(&store, &BLOCK_FIVE, 4, &BLOCK_ONE, None)?;
+        check_ancestor(&store, &BLOCK_FIVE, 5, &GENESIS_BLOCK, None)?;
+        check_ancestor(&store, &BLOCK_THREE, 2, &BLOCK_ONE, None)?;
 
         for offset in [6, 7, 8, 50].iter() {
             let offset = *offset;
-            let res = executor::block_on(
-                store
-                    .cheap_clone()
-                    .ancestor_block(BLOCK_FIVE.block_ptr(), offset),
-            );
+            let res = executor::block_on(store.cheap_clone().ancestor_block(
+                BLOCK_FIVE.block_ptr(),
+                offset,
+                None,
+            ));
             assert!(res.is_err());
         }
 
-        let block = executor::block_on(store.ancestor_block(BLOCK_TWO_NO_PARENT.block_ptr(), 1))?;
+        let block =
+            executor::block_on(store.ancestor_block(BLOCK_TWO_NO_PARENT.block_ptr(), 1, None))?;
         assert!(block.is_none());
         Ok(())
     });
@@ -360,10 +388,44 @@ fn ancestor_block_ommers() {
     ];
 
     run_test(chain, move |store, _| -> Result<(), Error> {
-        check_ancestor(&store, &BLOCK_ONE, 1, &GENESIS_BLOCK)?;
-        check_ancestor(&store, &BLOCK_ONE_SIBLING, 1, &GENESIS_BLOCK)?;
-        check_ancestor(&store, &BLOCK_TWO, 1, &BLOCK_ONE)?;
-        check_ancestor(&store, &BLOCK_TWO, 2, &GENESIS_BLOCK)?;
+        check_ancestor(&store, &BLOCK_ONE, 1, &GENESIS_BLOCK, None)?;
+        check_ancestor(&store, &BLOCK_ONE_SIBLING, 1, &GENESIS_BLOCK, None)?;
+        check_ancestor(&store, &BLOCK_TWO, 1, &BLOCK_ONE, None)?;
+        check_ancestor(&store, &BLOCK_TWO, 2, &GENESIS_BLOCK, None)?;
+        Ok(())
+    });
+}
+
+#[test]
+fn ancestor_block_skipped() {
+    let chain = vec![
+        &*GENESIS_BLOCK,
+        &*BLOCK_ONE,
+        &*BLOCK_FOUR_SKIPPED_2_AND_3,
+        &BLOCK_FIVE_AFTER_SKIP,
+    ];
+
+    run_test(chain, move |store, _| -> Result<(), Error> {
+        check_ancestor(&store, &BLOCK_FIVE_AFTER_SKIP, 2, &BLOCK_ONE, None)?;
+
+        check_ancestor(
+            &store,
+            &BLOCK_FIVE_AFTER_SKIP,
+            2,
+            &BLOCK_FOUR_SKIPPED_2_AND_3,
+            Some(BLOCK_ONE.block_hash()),
+        )?;
+
+        check_ancestor(&store, &BLOCK_FIVE_AFTER_SKIP, 5, &GENESIS_BLOCK, None)?;
+
+        check_ancestor(
+            &store,
+            &BLOCK_FIVE_AFTER_SKIP,
+            5,
+            &BLOCK_ONE,
+            Some(GENESIS_BLOCK.block_hash()),
+        )?;
+
         Ok(())
     });
 }
@@ -372,52 +434,227 @@ fn ancestor_block_ommers() {
 fn eth_call_cache() {
     let chain = vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_TWO];
 
-    run_test(chain, |store, _| {
-        let address = H160([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
+    run_test_async(chain, |store, _, _| async move {
+        let logger = LOGGER.cheap_clone();
+        fn ccr(value: &[u8]) -> call::Retval {
+            call::Retval::Value(Bytes::from(value))
+        }
+
+        let address = alloy::primitives::Address::from_slice(&[
+            1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+        ]);
         let call: [u8; 6] = [1, 2, 3, 4, 5, 6];
         let return_value: [u8; 3] = [7, 8, 9];
 
+        let call = call::Request::new(address, call.to_vec(), 0);
         store
-            .set_call(address, &call, BLOCK_ONE.block_ptr(), &return_value)
+            .cheap_clone()
+            .set_call(
+                &logger,
+                call.cheap_clone(),
+                BLOCK_ONE.block_ptr(),
+                ccr(&return_value),
+            )
+            .await
             .unwrap();
 
         let ret = store
-            .get_call(address, &call, GENESIS_BLOCK.block_ptr())
+            .get_call(&call, GENESIS_BLOCK.block_ptr())
+            .await
             .unwrap();
         assert!(ret.is_none());
 
         let ret = store
-            .get_call(address, &call, BLOCK_ONE.block_ptr())
+            .get_call(&call, BLOCK_ONE.block_ptr())
+            .await
+            .unwrap()
             .unwrap()
+            .retval
             .unwrap();
         assert_eq!(&return_value, ret.as_slice());
 
-        let ret = store
-            .get_call(address, &call, BLOCK_TWO.block_ptr())
-            .unwrap();
+        let ret = store.get_call(&call, BLOCK_TWO.block_ptr()).await.unwrap();
         assert!(ret.is_none());
 
         let new_return_value: [u8; 3] = [10, 11, 12];
         store
-            .set_call(address, &call, BLOCK_TWO.block_ptr(), &new_return_value)
+            .cheap_clone()
+            .set_call(
+                &logger,
+                call.cheap_clone(),
+                BLOCK_TWO.block_ptr(),
+                ccr(&new_return_value),
+            )
+            .await
             .unwrap();
         let ret = store
-            .get_call(address, &call, BLOCK_TWO.block_ptr())
+            .get_call(&call, BLOCK_TWO.block_ptr())
+            .await
+            .unwrap()
             .unwrap()
+            .retval
             .unwrap();
         assert_eq!(&new_return_value, ret.as_slice());
 
-        Ok(())
+        // Reverted calls should not be cached
+        store
+            .cheap_clone()
+            .set_call(
+                &logger,
+                call.cheap_clone(),
+                BLOCK_THREE.block_ptr(),
+                call::Retval::Null,
+            )
+            .await
+            .unwrap();
+        let ret = store
+            .get_call(&call, BLOCK_THREE.block_ptr())
+            .await
+            .unwrap();
+        assert_eq!(None, ret);
+
+        // Empty return values should not be cached
+        let return_value: [u8; 0] = [];
+        store
+            .cheap_clone()
+            .set_call(
+                &logger,
+                call.cheap_clone(),
+                BLOCK_FOUR.block_ptr(),
+                ccr(&return_value),
+            )
+            .await
+            .unwrap();
+        let ret = store.get_call(&call, BLOCK_FOUR.block_ptr()).await.unwrap();
+        assert_eq!(None, ret);
     })
 }
 
+#[test]
+fn test_disable_call_cache() {
+    let chain = vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_TWO];
+
+    run_test_async(chain, |store, _, _| async move {
+        ENV_VARS.set_store_call_cache_disabled_for_tests(true);
+
+        let logger = LOGGER.cheap_clone();
+        let address = Address::new([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5]);
+        let call: [u8; 6] = [1, 2, 3, 4, 5, 6];
+        let return_value: [u8; 3] = [7, 8, 9];
+
+        let call = call::Request::new(address, call.to_vec(), 0);
+
+        store
+            .cheap_clone()
+            .set_call(
+                &logger,
+                call.cheap_clone(),
+                BLOCK_ONE.block_ptr(),
+                call::Retval::Value(Bytes::from(return_value)),
+            )
+            .await
+            .unwrap();
+
+        let ret = store
+            .cheap_clone()
+            .get_call(&call, BLOCK_ONE.block_ptr())
+            .await
+            .unwrap();
+
+        assert!(ret.is_none());
+    });
+}
+
+#[test]
+/// Tests mainly query correctness. Requires data in order not to hit early returns when no stale contracts are found.
+fn test_clear_stale_call_cache() {
+    let chain = vec![];
+
+    #[derive(diesel::QueryableByName)]
+    struct Namespace {
+        #[diesel(sql_type = diesel::sql_types::Text)]
+        namespace: String,
+    }
+
+    run_test_async(chain, |chain_store, _, _| async move {
+        let logger = LOGGER.cheap_clone();
+        let address = alloy::primitives::Address::from([
+            1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3,
+        ]);
+        let call: [u8; 6] = [1, 2, 3, 4, 5, 6];
+        let return_value: [u8; 3] = [7, 8, 9];
+
+        // Insert a call cache entry, otherwise it will hit an early return and won't test all queries
+        let call = call::Request::new(address, call.to_vec(), 0);
+        chain_store
+            .cheap_clone()
+            .set_call(
+                &logger,
+                call.cheap_clone(),
+                BLOCK_ONE.block_ptr(),
+                call::Retval::Value(Bytes::from(return_value)),
+            )
+            .await
+            .unwrap();
+
+        // Confirm the call cache entry is there
+        let ret = chain_store
+            .get_call(&call, BLOCK_ONE.block_ptr())
+            .await
+            .unwrap();
+        assert!(ret.is_some());
+
+        // Now we need to update the accessed_at timestamp to be stale, so it gets deleted
+        // Get namespace from chains table in the primary
+        let namespace: String = {
+            let mut conn = PRIMARY_POOL.get().await.unwrap();
+            diesel::sql_query(format!(
+                "SELECT namespace FROM public.chains WHERE name = '{}'",
+                chain_store.chain
+            ))
+            .get_result::<Namespace>(&mut conn)
+            .await
+            .unwrap()
+            .namespace
+        };
+
+        // Determine the correct meta table name
+        let meta_table: String = match namespace.as_str() {
+            "public" => "eth_call_meta".to_owned(),
+            _ => format!("{namespace}.call_meta"),
+        };
+
+        // Update accessed_at to be 8 days ago, so it's stale for a 7 day
+        // threshold in the shard where the chain lives
+        {
+            let mut conn = chain_store.get_conn_for_test().await.unwrap();
+            diesel::sql_query(format!(
+                "UPDATE {meta_table} SET accessed_at = NOW() - INTERVAL '8 days' WHERE contract_address = $1"
+            ))
+            .bind::<diesel::sql_types::Bytea, _>(address.as_slice())
+            .execute(&mut conn)
+            .await
+            .unwrap();
+        }
+        let result = chain_store.clear_stale_call_cache(7, None).await;
+        assert!(result.is_ok());
+
+        // Confirm the call cache entry was removed
+        let ret = chain_store
+            .get_call(&call, BLOCK_ONE.block_ptr())
+            .await
+            .unwrap();
+        assert!(ret.is_none());
+    });
+}
+
 #[test]
 /// Tests only query correctness. No data is involved.
 fn test_transaction_receipts_in_block_function() {
     let chain = vec![];
     run_test_async(chain, move |store, _, _| async move {
         let receipts = store
-            .transaction_receipts_in_block(&H256::zero())
+            .transaction_receipts_in_block(&B256::ZERO)
             .await
             .unwrap();
         assert!(receipts.is_empty())
diff --git a/store/test-store/tests/postgres/graft.rs b/store/test-store/tests/postgres/graft.rs
index 9b4029ed3a5..6536fc3e06c 100644
--- a/store/test-store/tests/postgres/graft.rs
+++ b/store/test-store/tests/postgres/graft.rs
@@ -1,5 +1,5 @@
 use graph::blockchain::block_stream::FirehoseCursor;
-use graph::schema::{EntityType, InputSchema};
+use graph::schema::InputSchema;
 use graph_store_postgres::command_support::OnSync;
 use lazy_static::lazy_static;
 use std::{marker::PhantomData, str::FromStr};
@@ -9,7 +9,7 @@ use graph::components::store::{
     DeploymentLocator, EntityOrder, EntityQuery, PruneReporter, PruneRequest, PruningStrategy,
     VersionStats,
 };
-use graph::data::store::{scalar, Id};
+use graph::data::store::{Id, scalar};
 use graph::data::subgraph::schema::*;
 use graph::data::subgraph::*;
 use graph::semver::Version;
@@ -80,7 +80,7 @@ lazy_static! {
     static ref TEST_SUBGRAPH_SCHEMA: InputSchema =
         InputSchema::parse_latest(USER_GQL, TEST_SUBGRAPH_ID.clone())
             .expect("Failed to parse user schema");
-    static ref BLOCKS: Vec<BlockPtr> = vec![
+    static ref BLOCKS: Vec<BlockPtr> = [
         "bd34884280958002c51d3f7b5f853e6febeba33de0f40d15b0363006533c924f",
         "8511fa04b64657581e3f00e14543c1d522d5d7e771b54aa3060b662ade47da13",
         "b98fb783b49de5652097a989414c767824dff7e7fd765a63b493772511db81c1",
@@ -94,7 +94,6 @@ lazy_static! {
     .enumerate()
     .map(|(idx, hash)| BlockPtr::try_from((*hash, idx as i64)).unwrap())
     .collect();
-    static ref USER_TYPE: EntityType = TEST_SUBGRAPH_SCHEMA.entity_type(USER).unwrap();
 }
 
 /// Test harness for running database integration tests.
@@ -107,7 +106,7 @@ where
         let store = store.subgraph_store();
 
         // Reset state before starting
-        remove_test_data(store.clone());
+        remove_subgraphs().await;
 
         // Seed database with test data
         let deployment = insert_test_data(store.clone()).await;
@@ -137,7 +136,7 @@ where
 async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator {
     let manifest = SubgraphManifest::<graph_chain_ethereum::Chain> {
         id: TEST_SUBGRAPH_ID.clone(),
-        spec_version: Version::new(1, 0, 0),
+        spec_version: Version::new(1, 3, 0),
         features: Default::default(),
         description: None,
         repository: None,
@@ -165,6 +164,7 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
             "fake_network".to_string(),
             SubgraphVersionSwitchingMode::Instant,
         )
+        .await
         .unwrap();
 
     let test_entity_1 = create_test_entity(
@@ -176,6 +176,7 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
         184.4,
         false,
         None,
+        0,
     );
     transact_entity_operations(&store, &deployment, BLOCKS[0].clone(), vec![test_entity_1])
         .await
@@ -190,6 +191,7 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
         159.1,
         true,
         Some("red"),
+        1,
     );
     let test_entity_3_1 = create_test_entity(
         "3",
@@ -200,6 +202,7 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
         111.7,
         false,
         Some("blue"),
+        2,
     );
     transact_entity_operations(
         &store,
@@ -219,6 +222,7 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
         111.7,
         false,
         None,
+        3,
     );
     transact_entity_operations(
         &store,
@@ -242,6 +246,7 @@ fn create_test_entity(
     weight: f64,
     coffee: bool,
     favorite_color: Option<&str>,
+    vid: i64,
 ) -> EntityOperation {
     let bin_name = scalar::Bytes::from_str(&hex::encode(name)).unwrap();
     let test_entity = entity! { TEST_SUBGRAPH_SCHEMA =>
@@ -253,7 +258,8 @@ fn create_test_entity(
         seconds_age: age * 31557600,
         weight: Value::BigDecimal(weight.into()),
         coffee: coffee,
-        favorite_color: favorite_color
+        favorite_color: favorite_color,
+        vid: vid,
     };
 
     let entity_type = TEST_SUBGRAPH_SCHEMA.entity_type(entity_type).unwrap();
@@ -263,13 +269,6 @@ fn create_test_entity(
     }
 }
 
-/// Removes test data from the database behind the store.
-fn remove_test_data(store: Arc<DieselSubgraphStore>) {
-    store
-        .delete_all_entities_for_test_use_only()
-        .expect("deleting test entities succeeds");
-}
-
 async fn create_grafted_subgraph(
     subgraph_id: &DeploymentHash,
     schema: &str,
@@ -280,7 +279,7 @@ async fn create_grafted_subgraph(
     test_store::create_subgraph(subgraph_id, schema, base).await
 }
 
-fn find_entities(
+async fn find_entities(
     store: &DieselSubgraphStore,
     deployment: &DeploymentLocator,
 ) -> (Vec<Entity>, Vec<Id>) {
@@ -297,6 +296,7 @@ fn find_entities(
 
     let entities = store
         .find(query)
+        .await
         .expect("store.find failed to execute query");
 
     let ids = entities
@@ -310,7 +310,7 @@ async fn check_graft(
     store: Arc<DieselSubgraphStore>,
     deployment: DeploymentLocator,
 ) -> Result<(), StoreError> {
-    let (entities, ids) = find_entities(store.as_ref(), &deployment);
+    let (entities, ids) = find_entities(store.as_ref(), &deployment).await;
 
     let ids_str = ids.iter().map(|id| id.to_string()).collect::<Vec<_>>();
     assert_eq!(vec!["3", "1", "2"], ids_str);
@@ -320,10 +320,14 @@ async fn check_graft(
     let mut shaq = entities.first().unwrap().clone();
     assert_eq!(Some(&Value::from("queensha@email.com")), shaq.get("email"));
 
+    let schema = store.input_schema(&deployment.hash).await?;
+    let user_type = schema.entity_type("User").unwrap();
+
     // Make our own entries for block 2
     shaq.set("email", "shaq@gmail.com").unwrap();
+    let _ = shaq.set_vid(3);
     let op = EntityOperation::Set {
-        key: USER_TYPE.parse_key("3").unwrap(),
+        key: user_type.parse_key("3").unwrap(),
         data: shaq,
     };
     transact_and_wait(&store, &deployment, BLOCKS[2].clone(), vec![op])
@@ -401,7 +405,7 @@ fn graft() {
         .await
         .expect("grafting onto block 0 works");
 
-        let (entities, ids) = find_entities(store.as_ref(), &deployment);
+        let (entities, ids) = find_entities(store.as_ref(), &deployment).await;
         let ids_str = ids.iter().map(|id| id.to_string()).collect::<Vec<_>>();
         assert_eq!(vec!["1"], ids_str);
         let shaq = entities.first().unwrap().clone();
@@ -410,11 +414,11 @@ fn graft() {
     })
 }
 
-fn other_shard(
+async fn other_shard(
     store: &DieselSubgraphStore,
     src: &DeploymentLocator,
 ) -> Result<Option<Shard>, StoreError> {
-    let src_shard = store.shard(src)?;
+    let src_shard = store.shard(src).await?;
 
     match all_shards()
         .into_iter()
@@ -434,14 +438,16 @@ fn other_shard(
 #[test]
 fn copy() {
     run_test(|store, src| async move {
-        if let Some(dst_shard) = other_shard(&store, &src)? {
-            let deployment = store.copy_deployment(
-                &src,
-                dst_shard,
-                NODE_ID.clone(),
-                BLOCKS[1].clone(),
-                OnSync::None,
-            )?;
+        if let Some(dst_shard) = other_shard(&store, &src).await? {
+            let deployment = store
+                .copy_deployment(
+                    &src,
+                    dst_shard,
+                    NODE_ID.clone(),
+                    BLOCKS[1].clone(),
+                    OnSync::None,
+                )
+                .await?;
 
             store
                 .cheap_clone()
@@ -450,7 +456,7 @@ fn copy() {
                 .start_subgraph_deployment(&LOGGER)
                 .await?;
 
-            store.activate(&deployment)?;
+            store.activate(&deployment).await?;
 
             check_graft(store, deployment).await?;
         }
@@ -465,14 +471,10 @@ fn copy() {
 fn on_sync() {
     for on_sync in [OnSync::None, OnSync::Activate, OnSync::Replace] {
         run_test(move |store, src| async move {
-            if let Some(dst_shard) = other_shard(&store, &src)? {
-                let dst = store.copy_deployment(
-                    &src,
-                    dst_shard,
-                    NODE_ID.clone(),
-                    BLOCKS[1].clone(),
-                    on_sync,
-                )?;
+            if let Some(dst_shard) = other_shard(&store, &src).await? {
+                let dst = store
+                    .copy_deployment(&src, dst_shard, NODE_ID.clone(), BLOCKS[1].clone(), on_sync)
+                    .await?;
 
                 let writable = store
                     .cheap_clone()
@@ -480,13 +482,13 @@ fn on_sync() {
                     .await?;
 
                 writable.start_subgraph_deployment(&LOGGER).await?;
-                writable.deployment_synced()?;
+                writable.deployment_synced(BLOCKS[0].clone()).await?;
 
-                let primary = primary_connection();
-                let src_site = primary.locate_site(src)?.unwrap();
-                let src_node = primary.assigned_node(&src_site)?;
-                let dst_site = primary.locate_site(dst)?.unwrap();
-                let dst_node = primary.assigned_node(&dst_site)?;
+                let mut primary = primary_connection().await;
+                let src_site = primary.locate_site(src).await?.unwrap();
+                let src_node = primary.assigned_node(&src_site).await?;
+                let dst_site = primary.locate_site(dst).await?.unwrap();
+                let dst_node = primary.assigned_node(&dst_site).await?;
 
                 assert!(dst_node.is_some());
                 match on_sync {
@@ -514,14 +516,16 @@ fn on_sync() {
     // Check that on_sync does not cause an error when the source of the
     // copy has vanished
     run_test(move |store, src| async move {
-        if let Some(dst_shard) = other_shard(&store, &src)? {
-            let dst = store.copy_deployment(
-                &src,
-                dst_shard,
-                NODE_ID.clone(),
-                BLOCKS[1].clone(),
-                OnSync::Replace,
-            )?;
+        if let Some(dst_shard) = other_shard(&store, &src).await? {
+            let dst = store
+                .copy_deployment(
+                    &src,
+                    dst_shard,
+                    NODE_ID.clone(),
+                    BLOCKS[1].clone(),
+                    OnSync::Replace,
+                )
+                .await?;
 
             let writable = store
                 .cheap_clone()
@@ -531,13 +535,13 @@ fn on_sync() {
             // Perform the copy
             writable.start_subgraph_deployment(&LOGGER).await?;
 
-            let primary = primary_connection();
-            let src_site = primary.locate_site(src.clone())?.unwrap();
-            primary.unassign_subgraph(&src_site)?;
-            store.activate(&dst)?;
-            store.remove_deployment(src.id.into())?;
+            let mut primary = primary_connection().await;
+            let src_site = primary.locate_site(src.clone()).await?.unwrap();
+            primary.unassign_subgraph(&src_site).await?;
+            store.activate(&dst).await?;
+            store.remove_deployment(src.id.into()).await?;
 
-            let res = writable.deployment_synced();
+            let res = writable.deployment_synced(BLOCKS[2].clone()).await;
             assert!(res.is_ok());
         }
         Ok(())
@@ -549,7 +553,7 @@ fn prune() {
     struct Progress;
     impl PruneReporter for Progress {}
 
-    fn check_at_block(
+    async fn check_at_block(
         store: &DieselSubgraphStore,
         src: &DeploymentLocator,
         strategy: PruningStrategy,
@@ -569,6 +573,7 @@ fn prune() {
             .collect::<Vec<_>>();
         let act: Vec<_> = store
             .find(query)
+            .await
             .unwrap()
             .into_iter()
             .map(|entity| entity.id())
@@ -583,10 +588,12 @@ fn prune() {
         run_test(move |store, src| async move {
             store
                 .set_history_blocks(&src, -3, 10)
+                .await
                 .expect_err("history_blocks can not be set to a negative number");
 
             store
                 .set_history_blocks(&src, 10, 10)
+                .await
                 .expect_err("history_blocks must be bigger than reorg_threshold");
 
             // Add another version for user 2 at block 4
@@ -599,6 +606,7 @@ fn prune() {
                 157.1,
                 true,
                 Some("red"),
+                4,
             );
             transact_and_wait(&store, &src, BLOCKS[5].clone(), vec![user2])
                 .await
@@ -638,6 +646,7 @@ fn prune() {
                 tablename: USER.to_ascii_lowercase(),
                 ratio: 3.0 / 5.0,
                 last_pruned_block: None,
+                block_range_upper: vec![],
             };
             assert_eq!(
                 Some(strategy),
@@ -652,10 +661,10 @@ fn prune() {
             // Check which versions exist at every block, even if they are
             // before the new earliest block, since we don't have a convenient
             // way to load all entity versions with their block range
-            check_at_block(&store, &src, strategy, 0, vec!["1"]);
-            check_at_block(&store, &src, strategy, 1, vec!["1", "2"]);
+            check_at_block(&store, &src, strategy, 0, vec!["1"]).await;
+            check_at_block(&store, &src, strategy, 1, vec!["1", "2"]).await;
             for block in 2..=5 {
-                check_at_block(&store, &src, strategy, block, vec!["1", "2", "3"]);
+                check_at_block(&store, &src, strategy, block, vec!["1", "2", "3"]).await;
             }
             Ok(())
         })
diff --git a/store/test-store/tests/postgres/relational.rs b/store/test-store/tests/postgres/relational.rs
index 1199c36d78e..c4946b408c5 100644
--- a/store/test-store/tests/postgres/relational.rs
+++ b/store/test-store/tests/postgres/relational.rs
@@ -1,17 +1,19 @@
 //! Test mapping of GraphQL schema to a relational schema
-use diesel::connection::SimpleConnection as _;
-use diesel::pg::PgConnection;
-use graph::data::store::{scalar, Id};
+use diesel_async::SimpleAsyncConnection;
+use graph::components::store::write::{EntityModification, RowGroup};
+use graph::data::store::scalar;
 use graph::entity;
+use graph::prelude::alloy::primitives::B256;
 use graph::prelude::{
-    o, slog, tokio, web3::types::H256, DeploymentHash, Entity, EntityCollection, EntityFilter,
-    EntityOrder, EntityQuery, Logger, StopwatchMetrics, Value, ValueType, BLOCK_NUMBER_MAX,
+    BLOCK_NUMBER_MAX, DeploymentHash, Entity, EntityCollection, EntityFilter, EntityOrder,
+    EntityQuery, Logger, StopwatchMetrics, Value, ValueType, o, slog,
 };
 use graph::prelude::{BlockNumber, MetricsRegistry};
 use graph::schema::{EntityKey, EntityType, InputSchema};
-use graph_store_postgres::layout_for_tests::set_account_like;
+use graph_store_postgres::AsyncPgConnection;
 use graph_store_postgres::layout_for_tests::LayoutCache;
 use graph_store_postgres::layout_for_tests::SqlName;
+use graph_store_postgres::layout_for_tests::set_account_like;
 use hex_literal::hex;
 use lazy_static::lazy_static;
 use std::collections::BTreeSet;
@@ -23,7 +25,7 @@ use std::time::Duration;
 
 use graph::{
     components::store::AttributeNames,
-    data::store::scalar::{BigDecimal, BigInt, Bytes},
+    data::store::scalar::{BigDecimal, BigInt, Bytes, Timestamp},
 };
 use graph_store_postgres::{
     layout_for_tests::make_dummy_site,
@@ -98,6 +100,7 @@ const THINGS_GQL: &str = r#"
         bigIntArray: [BigInt!]!
         color: Color,
         int8: Int8,
+        timestamp: Timestamp
     }
 
     interface Pet {
@@ -125,6 +128,11 @@ const THINGS_GQL: &str = r#"
         order: Int,
     }
 
+    type SkipDupMink @entity(immutable: true, skipDuplicates: true) {
+        id: ID!,
+        order: Int,
+    }
+
     type User @entity {
         id: ID!,
         name: String!,
@@ -165,6 +173,13 @@ const THINGS_GQL: &str = r#"
         id: Bytes!,
         name: String!
     }
+
+    # For testing handling of enums and enum arrays
+    type Spectrum @entity {
+        id: ID!,
+        main: Color!
+        all: [Color!]!
+    }
 "#;
 
 lazy_static! {
@@ -173,16 +188,16 @@ lazy_static! {
         InputSchema::parse_latest(THINGS_GQL, THINGS_SUBGRAPH_ID.clone())
             .expect("failed to parse schema");
     static ref NAMESPACE: Namespace = Namespace::new("sgd0815".to_string()).unwrap();
-    static ref LARGE_INT: BigInt = BigInt::from(std::i64::MAX).pow(17).unwrap();
+    static ref LARGE_INT: BigInt = BigInt::from(i64::MAX).pow(17).unwrap();
     static ref LARGE_DECIMAL: BigDecimal =
         BigDecimal::from(1) / BigDecimal::new(LARGE_INT.clone(), 1);
-    static ref BYTES_VALUE: H256 = H256::from(hex!(
+    static ref BYTES_VALUE: B256 = B256::from(hex!(
         "e8b3b02b936c4a4a331ac691ac9a86e197fb7731f14e3108602c87d4dac55160"
     ));
-    static ref BYTES_VALUE2: H256 = H256::from(hex!(
+    static ref BYTES_VALUE2: B256 = B256::from(hex!(
         "b98fb783b49de5652097a989414c767824dff7e7fd765a63b493772511db81c1"
     ));
-    static ref BYTES_VALUE3: H256 = H256::from(hex!(
+    static ref BYTES_VALUE3: B256 = B256::from(hex!(
         "977c084229c72a0fa377cae304eda9099b6a2cb5d83b25cdf0f0969b69874255"
     ));
     static ref SCALAR_ENTITY: Entity = {
@@ -191,8 +206,9 @@ lazy_static! {
         entity! { THINGS_SCHEMA =>
             id: "one",
             bool: true,
-            int: std::i32::MAX,
-            int8: std::i64::MAX,
+            int: i32::MAX,
+            int8: i64::MAX,
+            timestamp: Value::Timestamp(Timestamp::from_microseconds_since_epoch(1710837304040956).expect("failed to create timestamp")),
             bigDecimal: decimal.clone(),
             bigDecimalArray: vec![decimal.clone(), (decimal + 1.into())],
             string: "scalar",
@@ -202,11 +218,13 @@ lazy_static! {
             bigInt: big_int.clone(),
             bigIntArray: vec![big_int.clone(), (big_int + 1.into())],
             color: "yellow",
+            vid: 0i64,
         }
     };
     static ref EMPTY_NULLABLESTRINGS_ENTITY: Entity = {
         entity! { THINGS_SCHEMA =>
             id: "one",
+            vid: 0i64,
         }
     };
     static ref SCALAR_TYPE: EntityType = THINGS_SCHEMA.entity_type("Scalar").unwrap();
@@ -215,6 +233,7 @@ lazy_static! {
     static ref CAT_TYPE: EntityType = THINGS_SCHEMA.entity_type("Cat").unwrap();
     static ref FERRET_TYPE: EntityType = THINGS_SCHEMA.entity_type("Ferret").unwrap();
     static ref MINK_TYPE: EntityType = THINGS_SCHEMA.entity_type("Mink").unwrap();
+    static ref SKIP_DUP_MINK_TYPE: EntityType = THINGS_SCHEMA.entity_type("SkipDupMink").unwrap();
     static ref CHAIR_TYPE: EntityType = THINGS_SCHEMA.entity_type("Chair").unwrap();
     static ref NULLABLE_STRINGS_TYPE: EntityType =
         THINGS_SCHEMA.entity_type("NullableStrings").unwrap();
@@ -228,14 +247,15 @@ lazy_static! {
 }
 
 /// Removes test data from the database behind the store.
-fn remove_schema(conn: &PgConnection) {
+async fn remove_schema(conn: &mut AsyncPgConnection) {
     let query = format!("drop schema if exists {} cascade", NAMESPACE.as_str());
     conn.batch_execute(&query)
+        .await
         .expect("Failed to drop test schema");
 }
 
-fn insert_entity_at(
-    conn: &PgConnection,
+async fn insert_entity_at(
+    conn: &mut AsyncPgConnection,
     layout: &Layout,
     entity_type: &EntityType,
     mut entities: Vec<Entity>,
@@ -256,25 +276,28 @@ fn insert_entity_at(
         "Failed to insert entities {}[{:?}]",
         entity_type, entities_with_keys
     );
-    let group = row_group_insert(&entity_type, block, entities_with_keys_owned.clone());
-    layout.insert(conn, &group, &MOCK_STOPWATCH).expect(&errmsg);
+    let group = row_group_insert(entity_type, block, entities_with_keys_owned.clone());
+    layout
+        .insert(&LOGGER, conn, &group, &MOCK_STOPWATCH)
+        .await
+        .expect(&errmsg);
     assert_eq!(
         group.entity_count_change(),
         entities_with_keys_owned.len() as i32
     );
 }
 
-fn insert_entity(
-    conn: &PgConnection,
+async fn insert_entity(
+    conn: &mut AsyncPgConnection,
     layout: &Layout,
     entity_type: &EntityType,
     entities: Vec<Entity>,
 ) {
-    insert_entity_at(conn, layout, entity_type, entities, 0);
+    insert_entity_at(conn, layout, entity_type, entities, 0).await;
 }
 
-fn update_entity_at(
-    conn: &PgConnection,
+async fn update_entity_at(
+    conn: &mut AsyncPgConnection,
     layout: &Layout,
     entity_type: &EntityType,
     mut entities: Vec<Entity>,
@@ -296,13 +319,16 @@ fn update_entity_at(
         "Failed to insert entities {}[{:?}]",
         entity_type, entities_with_keys
     );
-    let group = row_group_update(&entity_type, block, entities_with_keys_owned.clone());
-    let updated = layout.update(conn, &group, &MOCK_STOPWATCH).expect(&errmsg);
+    let group = row_group_update(entity_type, block, entities_with_keys_owned.clone());
+    let updated = layout
+        .update(conn, &group, &MOCK_STOPWATCH)
+        .await
+        .expect(&errmsg);
     assert_eq!(updated, entities_with_keys_owned.len());
 }
 
-fn insert_user_entity(
-    conn: &PgConnection,
+async fn insert_user_entity(
+    conn: &mut AsyncPgConnection,
     layout: &Layout,
     id: &str,
     entity_type: &EntityType,
@@ -315,6 +341,7 @@ fn insert_user_entity(
     drinks: Option<Vec<&str>>,
     visits: i64,
     block: BlockNumber,
+    vid: i64,
 ) {
     let user = make_user(
         &layout.input_schema,
@@ -327,9 +354,10 @@ fn insert_user_entity(
         favorite_color,
         drinks,
         visits,
+        vid,
     );
 
-    insert_entity_at(conn, layout, entity_type, vec![user], block);
+    insert_entity_at(conn, layout, entity_type, vec![user], block).await;
 }
 
 fn make_user(
@@ -343,6 +371,7 @@ fn make_user(
     favorite_color: Option<&str>,
     drinks: Option<Vec<&str>>,
     visits: i64,
+    vid: i64,
 ) -> Entity {
     let favorite_color = favorite_color
         .map(|s| Value::String(s.to_owned()))
@@ -358,7 +387,8 @@ fn make_user(
         weight: BigDecimal::from(weight),
         coffee: coffee,
         favorite_color: favorite_color,
-        visits: visits
+        visits: visits,
+        vid: vid,
     };
     if let Some(drinks) = drinks {
         user.insert("drinks", drinks.into()).unwrap();
@@ -366,12 +396,12 @@ fn make_user(
     user
 }
 
-fn insert_users(conn: &PgConnection, layout: &Layout) {
+async fn insert_users(conn: &mut AsyncPgConnection, layout: &Layout) {
     insert_user_entity(
         conn,
         layout,
         "1",
-        &*USER_TYPE,
+        &USER_TYPE,
         "Johnton",
         "tonofjohn@email.com",
         67_i32,
@@ -381,12 +411,14 @@ fn insert_users(conn: &PgConnection, layout: &Layout) {
         None,
         60,
         0,
-    );
+        0,
+    )
+    .await;
     insert_user_entity(
         conn,
         layout,
         "2",
-        &*USER_TYPE,
+        &USER_TYPE,
         "Cindini",
         "dinici@email.com",
         43_i32,
@@ -396,12 +428,14 @@ fn insert_users(conn: &PgConnection, layout: &Layout) {
         Some(vec!["beer", "wine"]),
         50,
         0,
-    );
+        1,
+    )
+    .await;
     insert_user_entity(
         conn,
         layout,
         "3",
-        &*USER_TYPE,
+        &USER_TYPE,
         "Shaqueeena",
         "teeko@email.com",
         28_i32,
@@ -411,11 +445,13 @@ fn insert_users(conn: &PgConnection, layout: &Layout) {
         Some(vec!["coffee", "tea"]),
         22,
         0,
-    );
+        2,
+    )
+    .await;
 }
 
-fn update_user_entity(
-    conn: &PgConnection,
+async fn update_user_entity(
+    conn: &mut AsyncPgConnection,
     layout: &Layout,
     id: &str,
     entity_type: &EntityType,
@@ -428,6 +464,7 @@ fn update_user_entity(
     drinks: Option<Vec<&str>>,
     visits: i64,
     block: BlockNumber,
+    vid: i64,
 ) {
     let user = make_user(
         &layout.input_schema,
@@ -440,31 +477,34 @@ fn update_user_entity(
         favorite_color,
         drinks,
         visits,
+        vid,
     );
-    update_entity_at(conn, layout, entity_type, vec![user], block);
+    update_entity_at(conn, layout, entity_type, vec![user], block).await;
 }
 
-fn insert_pet(
-    conn: &PgConnection,
+async fn insert_pet(
+    conn: &mut AsyncPgConnection,
     layout: &Layout,
     entity_type: &EntityType,
     id: &str,
     name: &str,
     block: BlockNumber,
+    vid: i64,
 ) {
     let pet = entity! { layout.input_schema =>
         id: id,
-        name: name
+        name: name,
+        vid: vid,
     };
-    insert_entity_at(conn, layout, entity_type, vec![pet], block);
+    insert_entity_at(conn, layout, entity_type, vec![pet], block).await;
 }
 
-fn insert_pets(conn: &PgConnection, layout: &Layout) {
-    insert_pet(conn, layout, &*DOG_TYPE, "pluto", "Pluto", 0);
-    insert_pet(conn, layout, &*CAT_TYPE, "garfield", "Garfield", 0);
+async fn insert_pets(conn: &mut AsyncPgConnection, layout: &Layout) {
+    insert_pet(conn, layout, &DOG_TYPE, "pluto", "Pluto", 0, 0).await;
+    insert_pet(conn, layout, &CAT_TYPE, "garfield", "Garfield", 0, 1).await;
 }
 
-fn create_schema(conn: &PgConnection) -> Layout {
+async fn create_schema(conn: &mut AsyncPgConnection) -> Layout {
     let schema = InputSchema::parse_latest(THINGS_GQL, THINGS_SUBGRAPH_ID.clone()).unwrap();
     let site = make_dummy_site(
         THINGS_SUBGRAPH_ID.clone(),
@@ -472,9 +512,10 @@ fn create_schema(conn: &PgConnection) -> Layout {
         NETWORK_NAME.to_string(),
     );
     let query = format!("create schema {}", NAMESPACE.as_str());
-    conn.batch_execute(&query).unwrap();
+    conn.batch_execute(&query).await.unwrap();
 
     Layout::create_relational_schema(conn, Arc::new(site), &schema, BTreeSet::new())
+        .await
         .expect("Failed to create relational schema")
 }
 
@@ -517,26 +558,27 @@ macro_rules! assert_entity_eq {
 }
 
 /// Test harness for running database integration tests.
-fn run_test<F>(test: F)
+async fn run_test<F>(test: F)
 where
-    F: FnOnce(&PgConnection, &Layout),
+    F: AsyncFnOnce(&mut AsyncPgConnection, &Layout),
 {
-    run_test_with_conn(|conn| {
+    run_test_with_conn(async |conn| {
         // Reset state before starting
-        remove_schema(conn);
+        remove_schema(conn).await;
 
         // Create the database schema
-        let layout = create_schema(conn);
+        let layout = create_schema(conn).await;
 
         // Run test
-        test(conn, &layout);
-    });
+        test(conn, &layout).await;
+    })
+    .await;
 }
 
-#[test]
-fn find() {
-    run_test(|conn, layout| {
-        insert_entity(conn, layout, &*SCALAR_TYPE, vec![SCALAR_ENTITY.clone()]);
+#[graph::test]
+async fn find() {
+    run_test(async |conn, layout| {
+        insert_entity(conn, layout, &SCALAR_TYPE, vec![SCALAR_ENTITY.clone()]).await;
 
         // Happy path: find existing entity
         let entity = layout
@@ -545,6 +587,7 @@ fn find() {
                 &SCALAR_TYPE.parse_key("one").unwrap(),
                 BLOCK_NUMBER_MAX,
             )
+            .await
             .expect("Failed to read Scalar[one]")
             .unwrap();
         assert_entity_eq!(scrub(&SCALAR_ENTITY), entity);
@@ -556,20 +599,23 @@ fn find() {
                 &SCALAR_TYPE.parse_key("noone").unwrap(),
                 BLOCK_NUMBER_MAX,
             )
+            .await
             .expect("Failed to read Scalar[noone]");
         assert!(entity.is_none());
-    });
+    })
+    .await;
 }
 
-#[test]
-fn insert_null_fulltext_fields() {
-    run_test(|conn, layout| {
+#[graph::test]
+async fn insert_null_fulltext_fields() {
+    run_test(async |conn, layout| {
         insert_entity(
             conn,
             layout,
-            &*NULLABLE_STRINGS_TYPE,
+            &NULLABLE_STRINGS_TYPE,
             vec![EMPTY_NULLABLESTRINGS_ENTITY.clone()],
-        );
+        )
+        .await;
 
         // Find entity with null string values
         let entity = layout
@@ -578,22 +624,102 @@ fn insert_null_fulltext_fields() {
                 &NULLABLE_STRINGS_TYPE.parse_key("one").unwrap(),
                 BLOCK_NUMBER_MAX,
             )
+            .await
             .expect("Failed to read NullableStrings[one]")
             .unwrap();
         assert_entity_eq!(scrub(&EMPTY_NULLABLESTRINGS_ENTITY), entity);
-    });
+    })
+    .await;
 }
 
-#[test]
-fn update() {
-    run_test(|conn, layout| {
-        insert_entity(conn, layout, &*SCALAR_TYPE, vec![SCALAR_ENTITY.clone()]);
+/// Copying a table must also populate its fulltext (tsvector) search
+/// columns. These columns are not returned by `Table::column`, so a naive
+/// copy would silently drop them and leave the destination's search index
+/// empty. This copies the `User` table into a fresh schema and checks that a
+/// fulltext query against the copy still returns the expected entity.
+#[graph::test]
+async fn copy_populates_fulltext() {
+    use diesel_async::RunQueryDsl;
+    use graph_store_postgres::layout_for_tests::CopyEntityBatchQuery;
+
+    run_test(async |conn, layout| {
+        // Populate the source `User` table with searchable text
+        insert_users(conn, layout).await;
+
+        // Create a destination schema with the same layout in a separate
+        // namespace to copy into. Drop it first in case a previous run left
+        // it behind, since `remove_schema` only cleans up the source
+        // namespace.
+        let dst_namespace = Namespace::new("sgd0816".to_string()).unwrap();
+        conn.batch_execute(&format!(
+            "drop schema if exists {ns} cascade; create schema {ns}",
+            ns = dst_namespace.as_str()
+        ))
+        .await
+        .unwrap();
+        let dst_site = make_dummy_site(
+            THINGS_SUBGRAPH_ID.clone(),
+            dst_namespace,
+            NETWORK_NAME.to_string(),
+        );
+        let dst_layout = Layout::create_relational_schema(
+            conn,
+            Arc::new(dst_site),
+            &THINGS_SCHEMA,
+            BTreeSet::new(),
+        )
+        .await
+        .expect("Failed to create destination relational schema");
+
+        // Copy the `User` table from the source into the destination
+        let src_table = layout.table_for_entity(&USER_TYPE).unwrap();
+        let dst_table = dst_layout.table_for_entity(&USER_TYPE).unwrap();
+        CopyEntityBatchQuery::new(
+            dst_table.as_ref(),
+            src_table.as_ref(),
+            0,
+            i64::MAX,
+            BLOCK_NUMBER_MAX,
+        )
+        .unwrap()
+        .count_current()
+        .get_result::<i64>(conn)
+        .await
+        .expect("Failed to copy User table");
+
+        // A fulltext query against the copy must find the matching user,
+        // which is only possible if the tsvector column was copied.
+        let mut query =
+            user_query().filter(EntityFilter::Fulltext("userSearch".into(), "Shaq:*".into()));
+        query.block = BLOCK_NUMBER_MAX;
+        let entities = dst_layout
+            .query::<Entity>(&LOGGER, conn, query)
+            .await
+            .expect("fulltext query on copy failed")
+            .0;
+        let ids: Vec<_> = entities
+            .iter()
+            .map(|entity| match entity.get("id") {
+                Some(Value::String(id)) => id.clone(),
+                _ => panic!("entity without string id"),
+            })
+            .collect();
+        assert_eq!(ids, vec!["3".to_string()]);
+    })
+    .await;
+}
+
+#[graph::test]
+async fn update() {
+    run_test(async |conn, layout| {
+        insert_entity(conn, layout, &SCALAR_TYPE, vec![SCALAR_ENTITY.clone()]).await;
 
         // Update with overwrite
         let mut entity = SCALAR_ENTITY.clone();
         entity.set("string", "updated").unwrap();
         entity.remove("strings");
         entity.set("bool", Value::Null).unwrap();
+        entity.set("vid", 1i64).unwrap();
         let key = SCALAR_TYPE.key(entity.id());
 
         let entity_type = layout.input_schema.entity_type("Scalar").unwrap();
@@ -601,6 +727,7 @@ fn update() {
         let group = row_group_update(&entity_type, 0, entities);
         layout
             .update(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to update");
 
         let actual = layout
@@ -609,29 +736,34 @@ fn update() {
                 &SCALAR_TYPE.parse_key("one").unwrap(),
                 BLOCK_NUMBER_MAX,
             )
+            .await
             .expect("Failed to read Scalar[one]")
             .unwrap();
         assert_entity_eq!(scrub(&entity), actual);
-    });
+    })
+    .await;
 }
 
-#[test]
-fn update_many() {
-    run_test(|conn, layout| {
+#[graph::test]
+async fn update_many() {
+    run_test(async |conn, layout| {
         let mut one = SCALAR_ENTITY.clone();
         let mut two = SCALAR_ENTITY.clone();
         two.set("id", "two").unwrap();
+        two.set("vid", 1i64).unwrap();
         let mut three = SCALAR_ENTITY.clone();
         three.set("id", "three").unwrap();
+        three.set("vid", 2i64).unwrap();
         insert_entity(
             conn,
             layout,
-            &*SCALAR_TYPE,
+            &SCALAR_TYPE,
             vec![one.clone(), two.clone(), three.clone()],
-        );
+        )
+        .await;
 
         // confidence test: there should be 3 scalar entities in store right now
-        assert_eq!(3, count_scalar_entities(conn, layout));
+        assert_eq!(3, count_scalar_entities(conn, layout).await);
 
         // update with overwrite
         one.set("string", "updated").unwrap();
@@ -644,6 +776,10 @@ fn update_many() {
         three.remove("strings");
         three.set("color", "red").unwrap();
 
+        one.set("vid", 3i64).unwrap();
+        two.set("vid", 4i64).unwrap();
+        three.set("vid", 5i64).unwrap();
+
         // generate keys
         let entity_type = layout.input_schema.entity_type("Scalar").unwrap();
         let keys: Vec<EntityKey> = ["one", "two", "three"]
@@ -656,18 +792,21 @@ fn update_many() {
         let group = row_group_update(&entity_type, 0, entities);
         layout
             .update(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to update");
 
         // check updates took effect
-        let updated: Vec<Entity> = ["one", "two", "three"]
-            .iter()
-            .map(|&id| {
-                layout
-                    .find(conn, &SCALAR_TYPE.parse_key(id).unwrap(), BLOCK_NUMBER_MAX)
-                    .unwrap_or_else(|_| panic!("Failed to read Scalar[{}]", id))
-                    .unwrap()
-            })
-            .collect();
+        let mut updated: Vec<Entity> = Vec::new();
+        for id in &["one", "two", "three"] {
+            let entity = layout
+                .find(conn, &SCALAR_TYPE.parse_key(*id).unwrap(), BLOCK_NUMBER_MAX)
+                .await
+                .unwrap_or_else(|_| panic!("Failed to read Scalar[{}]", id))
+                .unwrap();
+            updated.push(entity);
+        }
+        let updated = updated;
+
         let new_one = &updated[0];
         let new_two = &updated[1];
         let new_three = &updated[2];
@@ -699,21 +838,23 @@ fn update_many() {
             new_three.get("color"),
             Some(&Value::String("red".to_string()))
         );
-    });
+    })
+    .await;
 }
 
 /// Test that we properly handle BigDecimal values with a negative scale.
-#[test]
-fn serialize_bigdecimal() {
-    run_test(|conn, layout| {
-        insert_entity(conn, layout, &*SCALAR_TYPE, vec![SCALAR_ENTITY.clone()]);
+#[graph::test]
+async fn serialize_bigdecimal() {
+    run_test(async |conn, layout| {
+        insert_entity(conn, layout, &SCALAR_TYPE, vec![SCALAR_ENTITY.clone()]).await;
 
         // Update with overwrite
         let mut entity = SCALAR_ENTITY.clone();
 
-        for d in &["50", "50.00", "5000", "0.5000", "0.050", "0.5", "0.05"] {
+        for (vid, d) in (1i64..).zip(&["50", "50.00", "5000", "0.5000", "0.050", "0.5", "0.05"]) {
             let d = BigDecimal::from_str(d).unwrap();
             entity.set("bigDecimal", d).unwrap();
+            entity.set("vid", vid).unwrap();
 
             let key = SCALAR_TYPE.key(entity.id());
             let entity_type = layout.input_schema.entity_type("Scalar").unwrap();
@@ -721,6 +862,7 @@ fn serialize_bigdecimal() {
             let group = row_group_update(&entity_type, 0, entities);
             layout
                 .update(conn, &group, &MOCK_STOPWATCH)
+                .await
                 .expect("Failed to update");
 
             let actual = layout
@@ -729,14 +871,55 @@ fn serialize_bigdecimal() {
                     &SCALAR_TYPE.parse_key("one").unwrap(),
                     BLOCK_NUMBER_MAX,
                 )
+                .await
                 .expect("Failed to read Scalar[one]")
                 .unwrap();
             assert_entity_eq!(entity, actual);
         }
-    });
+    })
+    .await;
+}
+
+#[graph::test]
+async fn enum_arrays() {
+    // We had an issue where we would read an array of enums back as a
+    // single string; for this test, we would get back the string
+    // "{yellow,red,BLUE}" instead of the array ["yellow", "red", "BLUE"]
+    run_test(async |conn, layout| {
+        let spectrum = entity! { THINGS_SCHEMA =>
+            id: "rainbow",
+            main: "yellow",
+            all: vec!["yellow", "red", "BLUE"],
+            vid: 0i64
+        };
+
+        insert_entity(
+            conn,
+            layout,
+            &THINGS_SCHEMA.entity_type("Spectrum").unwrap(),
+            vec![spectrum.clone()],
+        )
+        .await;
+
+        let actual = layout
+            .find(
+                conn,
+                &THINGS_SCHEMA
+                    .entity_type("Spectrum")
+                    .unwrap()
+                    .parse_key("rainbow")
+                    .unwrap(),
+                BLOCK_NUMBER_MAX,
+            )
+            .await
+            .expect("Failed to read Spectrum[rainbow]")
+            .unwrap();
+        assert_entity_eq!(spectrum, actual);
+    })
+    .await
 }
 
-fn count_scalar_entities(conn: &PgConnection, layout: &Layout) -> usize {
+async fn count_scalar_entities(conn: &mut AsyncPgConnection, layout: &Layout) -> usize {
     let filter = EntityFilter::Or(vec![
         EntityFilter::Equal("bool".into(), true.into()),
         EntityFilter::Equal("bool".into(), false.into()),
@@ -747,18 +930,20 @@ fn count_scalar_entities(conn: &PgConnection, layout: &Layout) -> usize {
     query.range.first = None;
     layout
         .query::<Entity>(&LOGGER, conn, query)
+        .await
         .map(|(entities, _)| entities)
         .expect("Count query failed")
         .len()
 }
 
-#[test]
-fn delete() {
-    run_test(|conn, layout| {
-        insert_entity(conn, layout, &*SCALAR_TYPE, vec![SCALAR_ENTITY.clone()]);
+#[graph::test]
+async fn delete() {
+    run_test(async |conn, layout| {
+        insert_entity(conn, layout, &SCALAR_TYPE, vec![SCALAR_ENTITY.clone()]).await;
         let mut two = SCALAR_ENTITY.clone();
         two.set("id", "two").unwrap();
-        insert_entity(conn, layout, &*SCALAR_TYPE, vec![two]);
+        two.set("vid", 1i64).unwrap();
+        insert_entity(conn, layout, &SCALAR_TYPE, vec![two]).await;
 
         // Delete where nothing is getting deleted
         let key = SCALAR_TYPE.parse_key("no such entity").unwrap();
@@ -767,9 +952,10 @@ fn delete() {
         let group = row_group_delete(&entity_type, 1, entity_keys.clone());
         let count = layout
             .delete(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to delete");
         assert_eq!(0, count);
-        assert_eq!(2, count_scalar_entities(conn, layout));
+        assert_eq!(2, count_scalar_entities(conn, layout).await);
 
         // Delete entity two
         entity_keys
@@ -780,179 +966,221 @@ fn delete() {
         let group = row_group_delete(&entity_type, 1, entity_keys);
         let count = layout
             .delete(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to delete");
         assert_eq!(1, count);
-        assert_eq!(1, count_scalar_entities(conn, layout));
-    });
+        assert_eq!(1, count_scalar_entities(conn, layout).await);
+    })
+    .await;
 }
 
-#[test]
-fn insert_many_and_delete_many() {
-    run_test(|conn, layout| {
+#[graph::test]
+async fn insert_many_and_delete_many() {
+    run_test(async |conn, layout| {
         let one = SCALAR_ENTITY.clone();
         let mut two = SCALAR_ENTITY.clone();
         two.set("id", "two").unwrap();
+        two.set("vid", 1i64).unwrap();
         let mut three = SCALAR_ENTITY.clone();
         three.set("id", "three").unwrap();
-        insert_entity(conn, layout, &*SCALAR_TYPE, vec![one, two, three]);
+        three.set("vid", 2i64).unwrap();
+        insert_entity(conn, layout, &SCALAR_TYPE, vec![one, two, three]).await;
 
         // confidence test: there should be 3 scalar entities in store right now
-        assert_eq!(3, count_scalar_entities(conn, layout));
+        assert_eq!(3, count_scalar_entities(conn, layout).await);
 
         // Delete entities with ids equal to "two" and "three"
         let entity_keys: Vec<_> = vec!["two", "three"]
             .into_iter()
             .map(|key| SCALAR_TYPE.parse_key(key).unwrap())
             .collect();
-        let group = row_group_delete(&*SCALAR_TYPE, 1, entity_keys);
+        let group = row_group_delete(&SCALAR_TYPE, 1, entity_keys);
         let num_removed = layout
             .delete(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to delete");
         assert_eq!(2, num_removed);
-        assert_eq!(1, count_scalar_entities(conn, layout));
-    });
+        assert_eq!(1, count_scalar_entities(conn, layout).await);
+    })
+    .await;
 }
 
-#[tokio::test]
+#[graph::test]
 async fn layout_cache() {
-    // We need to use `block_on` to call the `create_test_subgraph` function which must be called
-    // from a sync context, so we replicate what we do `spawn_module`.
-    let runtime = tokio::runtime::Handle::current();
-    std::thread::spawn(move || {
-        run_test_with_conn(|conn| {
-            let _runtime_guard = runtime.enter();
-
-            let id = DeploymentHash::new("primaryLayoutCache").unwrap();
-            let _loc = graph::block_on(create_test_subgraph(&id, THINGS_GQL));
-            let site = Arc::new(primary_mirror().find_active_site(&id).unwrap().unwrap());
-            let table_name = SqlName::verbatim("scalar".to_string());
-
-            let cache = LayoutCache::new(Duration::from_millis(10));
-
-            // Without an entry, account_like is false
-            let layout = cache
-                .get(&LOGGER, conn, site.clone())
-                .expect("we can get the layout");
-            let table = layout.table(&table_name).unwrap();
-            assert_eq!(false, table.is_account_like);
-
-            set_account_like(conn, site.as_ref(), &table_name, true)
-                .expect("we can set 'scalar' to account-like");
-            sleep(Duration::from_millis(50));
-
-            // Flip account_like to true
-            let layout = cache
-                .get(&LOGGER, conn, site.clone())
-                .expect("we can get the layout");
-            let table = layout.table(&table_name).unwrap();
-            assert_eq!(true, table.is_account_like);
-
-            // Set it back to false
-            set_account_like(conn, site.as_ref(), &table_name, false)
-                .expect("we can set 'scalar' to account-like");
-            sleep(Duration::from_millis(50));
-
-            let layout = cache
-                .get(&LOGGER, conn, site)
-                .expect("we can get the layout");
-            let table = layout.table(&table_name).unwrap();
-            assert_eq!(false, table.is_account_like);
-        })
+    run_test_with_conn(async |conn| {
+        let id = DeploymentHash::new("primaryLayoutCache").unwrap();
+        let _loc = create_test_subgraph(&id, THINGS_GQL).await;
+        let site = Arc::new(
+            primary_mirror()
+                .find_active_site(&id)
+                .await
+                .unwrap()
+                .unwrap(),
+        );
+        let table_name = SqlName::verbatim("scalar".to_string());
+
+        let cache = LayoutCache::new(Duration::from_millis(10));
+
+        // Without an entry, account_like is false
+        let layout = cache
+            .get(&LOGGER, conn, site.clone())
+            .await
+            .expect("we can get the layout");
+        let table = layout.table(&table_name).unwrap();
+        assert!(!table.is_account_like);
+
+        set_account_like(conn, site.as_ref(), &table_name, true)
+            .await
+            .expect("we can set 'scalar' to account-like");
+        sleep(Duration::from_millis(50));
+
+        // Flip account_like to true
+        let layout = cache
+            .get(&LOGGER, conn, site.clone())
+            .await
+            .expect("we can get the layout");
+        let table = layout.table(&table_name).unwrap();
+        assert!(table.is_account_like);
+
+        // Set it back to false
+        set_account_like(conn, site.as_ref(), &table_name, false)
+            .await
+            .expect("we can set 'scalar' to account-like");
+        sleep(Duration::from_millis(50));
+
+        let layout = cache
+            .get(&LOGGER, conn, site)
+            .await
+            .expect("we can get the layout");
+        let table = layout.table(&table_name).unwrap();
+        assert!(!table.is_account_like);
     })
-    .join()
-    .unwrap();
+    .await;
 }
 
-#[test]
-fn conflicting_entity() {
+#[graph::test]
+async fn conflicting_entity() {
     // `id` is the id of an entity to create, `cat`, `dog`, and `ferret` are
     // the names of the types for which to check entity uniqueness
-    fn check(conn: &PgConnection, layout: &Layout, id: Value, cat: &str, dog: &str, ferret: &str) {
-        let conflicting = |types: Vec<&EntityType>| {
-            let types = types.into_iter().cloned().collect();
-            let id = Id::try_from(id.clone()).unwrap();
-            layout.conflicting_entity(conn, &id, types)
+    async fn check(
+        conn: &mut AsyncPgConnection,
+        layout: &Layout,
+        id: Value,
+        cat: &str,
+        dog: &str,
+        ferret: &str,
+        vid: i64,
+    ) {
+        let conflicting = async |conn: &mut AsyncPgConnection,
+                                 entity_type: &EntityType,
+                                 types: Vec<&EntityType>| {
+            let fred = entity! { layout.input_schema => id: id.clone(), name: id.clone() };
+            let fred = Arc::new(fred);
+            let types: Vec<_> = types.into_iter().cloned().collect();
+            let mut group = RowGroup::new(entity_type.clone());
+            group
+                .push(
+                    EntityModification::Insert {
+                        key: entity_type.key(fred.id()),
+                        data: fred,
+                        block: 2,
+                        end: None,
+                    },
+                    2,
+                )
+                .unwrap();
+            layout.conflicting_entities(conn, &types, &group).await
         };
 
         let cat_type = layout.input_schema.entity_type(cat).unwrap();
         let dog_type = layout.input_schema.entity_type(dog).unwrap();
         let ferret_type = layout.input_schema.entity_type(ferret).unwrap();
 
-        let fred = entity! { layout.input_schema => id: id.clone(), name: id.clone() };
-        insert_entity(conn, layout, &cat_type, vec![fred]);
+        let fred = entity! { layout.input_schema => id: id.clone(), name: id.clone(), vid: vid };
+        insert_entity(conn, layout, &cat_type, vec![fred]).await;
 
         // If we wanted to create Fred the dog, which is forbidden, we'd run this:
-        let conflict = conflicting(vec![&cat_type, &ferret_type]).unwrap();
-        assert_eq!(Some(cat.to_string()), conflict);
+        let conflict = conflicting(conn, &dog_type, vec![&cat_type, &ferret_type])
+            .await
+            .unwrap();
+        assert_eq!(Some(cat.to_string()), conflict.map(|r| r.0));
 
         // If we wanted to manipulate Fred the cat, which is ok, we'd run:
-        let conflict = conflicting(vec![&dog_type, &ferret_type]).unwrap();
+        let conflict = conflicting(conn, &cat_type, vec![&dog_type, &ferret_type])
+            .await
+            .unwrap();
         assert_eq!(None, conflict);
     }
 
-    run_test(|conn, layout| {
+    run_test(async |conn, layout| {
         let id = Value::String("fred".to_string());
-        check(conn, layout, id, "Cat", "Dog", "Ferret");
+        check(conn, layout, id, "Cat", "Dog", "Ferret", 0).await;
 
         let id = Value::Bytes(scalar::Bytes::from_str("0xf1ed").unwrap());
-        check(conn, layout, id, "ByteCat", "ByteDog", "ByteFerret");
+        check(conn, layout, id, "ByteCat", "ByteDog", "ByteFerret", 1).await;
     })
+    .await
 }
 
-#[test]
-fn revert_block() {
-    fn check_fred(conn: &PgConnection, layout: &Layout) {
+#[graph::test]
+async fn revert_block() {
+    async fn check_fred(conn: &mut AsyncPgConnection, layout: &Layout) {
         let id = "fred";
 
-        let set_fred = |name, block| {
+        let set_fred = async |conn: &mut AsyncPgConnection, name, block| {
             let fred = entity! { layout.input_schema =>
                 id: id,
-                name: name
+                name: name,
+                vid: block as i64,
             };
             if block == 0 {
-                insert_entity_at(conn, layout, &*CAT_TYPE, vec![fred], block);
+                insert_entity_at(conn, layout, &CAT_TYPE, vec![fred], block).await;
             } else {
-                update_entity_at(conn, layout, &*CAT_TYPE, vec![fred], block);
+                update_entity_at(conn, layout, &CAT_TYPE, vec![fred], block).await;
             }
         };
 
-        let assert_fred = |name: &str| {
+        let assert_fred = async |conn: &mut AsyncPgConnection, name: &str| {
             let fred = layout
                 .find(conn, &CAT_TYPE.parse_key(id).unwrap(), BLOCK_NUMBER_MAX)
+                .await
                 .unwrap()
                 .expect("there's a fred");
             assert_eq!(name, fred.get("name").unwrap().as_str().unwrap())
         };
 
-        set_fred("zero", 0);
-        set_fred("one", 1);
-        set_fred("two", 2);
-        set_fred("three", 3);
+        set_fred(conn, "zero", 0).await;
+        set_fred(conn, "one", 1).await;
+        set_fred(conn, "two", 2).await;
+        set_fred(conn, "three", 3).await;
 
-        layout.revert_block(conn, 3).unwrap();
-        assert_fred("two");
-        layout.revert_block(conn, 2).unwrap();
-        assert_fred("one");
+        layout.revert_block(conn, 3).await.unwrap();
+        assert_fred(conn, "two").await;
+        layout.revert_block(conn, 2).await.unwrap();
+        assert_fred(conn, "one").await;
 
-        set_fred("three", 3);
-        assert_fred("three");
-        layout.revert_block(conn, 3).unwrap();
-        assert_fred("one");
+        set_fred(conn, "three", 3).await;
+        assert_fred(conn, "three").await;
+        layout.revert_block(conn, 3).await.unwrap();
+        assert_fred(conn, "one").await;
     }
 
-    fn check_marty(conn: &PgConnection, layout: &Layout) {
-        let set_marties = |from, to| {
+    async fn check_marty(conn: &mut AsyncPgConnection, layout: &Layout) {
+        let set_marties = async |conn: &mut AsyncPgConnection, from, to| {
             for block in from..=to {
                 let id = format!("marty-{}", block);
                 let marty = entity! { layout.input_schema =>
                     id: id,
                     order: block,
+                    vid: (block + 10) as i64
                 };
-                insert_entity_at(conn, layout, &*MINK_TYPE, vec![marty], block);
+                insert_entity_at(conn, layout, &MINK_TYPE, vec![marty], block).await;
             }
         };
 
-        let assert_marties = |max_block, except: Vec<BlockNumber>| {
+        let assert_marties = async |conn: &mut AsyncPgConnection,
+                                    max_block,
+                                    except: Vec<BlockNumber>| {
             let id = DeploymentHash::new("QmXW3qvxV7zXnwRntpj7yoK8HZVtaraZ67uMqaLRvXdxha").unwrap();
             let collection = EntityCollection::All(vec![(MINK_TYPE.clone(), AttributeNames::All)]);
             let filter = EntityFilter::StartsWith("id".to_string(), Value::from("marty"));
@@ -962,6 +1190,7 @@ fn revert_block() {
                 .order(EntityOrder::Ascending("order".to_string(), ValueType::Int));
             let marties: Vec<Entity> = layout
                 .query(&LOGGER, conn, query)
+                .await
                 .map(|(entities, _)| entities)
                 .expect("loading all marties works");
 
@@ -978,43 +1207,46 @@ fn revert_block() {
             }
         };
 
-        let assert_all_marties = |max_block| assert_marties(max_block, vec![]);
+        let assert_all_marties = async |conn: &mut AsyncPgConnection, max_block| {
+            assert_marties(conn, max_block, vec![]).await
+        };
 
-        set_marties(0, 4);
-        assert_all_marties(4);
+        set_marties(conn, 0, 4).await;
+        assert_all_marties(conn, 4).await;
 
-        layout.revert_block(conn, 3).unwrap();
-        assert_all_marties(2);
-        layout.revert_block(conn, 2).unwrap();
-        assert_all_marties(1);
+        layout.revert_block(conn, 3).await.unwrap();
+        assert_all_marties(conn, 2).await;
+        layout.revert_block(conn, 2).await.unwrap();
+        assert_all_marties(conn, 1).await;
 
-        set_marties(4, 4);
+        set_marties(conn, 4, 4).await;
         // We don't have entries for 2 and 3 anymore
-        assert_marties(4, vec![2, 3]);
+        assert_marties(conn, 4, vec![2, 3]).await;
 
-        layout.revert_block(conn, 2).unwrap();
-        assert_all_marties(1);
+        layout.revert_block(conn, 2).await.unwrap();
+        assert_all_marties(conn, 1).await;
     }
 
-    run_test(|conn, layout| {
-        check_fred(conn, layout);
-        check_marty(conn, layout);
-    });
+    run_test(async |conn, layout| {
+        check_fred(conn, layout).await;
+        check_marty(conn, layout).await;
+    })
+    .await;
 }
 
 struct QueryChecker<'a> {
-    conn: &'a PgConnection,
+    conn: &'a mut AsyncPgConnection,
     layout: &'a Layout,
 }
 
 impl<'a> QueryChecker<'a> {
-    fn new(conn: &'a PgConnection, layout: &'a Layout) -> Self {
-        insert_users(conn, layout);
+    async fn new(conn: &'a mut AsyncPgConnection, layout: &'a Layout) -> Self {
+        insert_users(conn, layout).await;
         update_user_entity(
             conn,
             layout,
             "1",
-            &*USER_TYPE,
+            &USER_TYPE,
             "Jono",
             "achangedemail@email.com",
             67_i32,
@@ -1024,19 +1256,22 @@ impl<'a> QueryChecker<'a> {
             None,
             23,
             0,
-        );
-        insert_pets(conn, layout);
+            3,
+        )
+        .await;
+        insert_pets(conn, layout).await;
 
         Self { conn, layout }
     }
 
-    fn check(self, expected_entity_ids: Vec<&'static str>, mut query: EntityQuery) -> Self {
+    async fn check(self, expected_entity_ids: Vec<&'static str>, mut query: EntityQuery) -> Self {
         let q = query.clone();
         let unordered = matches!(query.order, EntityOrder::Unordered);
         query.block = BLOCK_NUMBER_MAX;
         let entities = self
             .layout
             .query::<Entity>(&LOGGER, self.conn, query)
+            .await
             .expect("layout.query failed to execute query")
             .0;
 
@@ -1068,7 +1303,7 @@ fn query(entity_types: &[&EntityType]) -> EntityQuery {
         BLOCK_NUMBER_MAX,
         EntityCollection::All(
             entity_types
-                .into_iter()
+                .iter()
                 .map(|entity_type| ((*entity_type).clone(), AttributeNames::All))
                 .collect(),
         ),
@@ -1076,7 +1311,7 @@ fn query(entity_types: &[&EntityType]) -> EntityQuery {
 }
 
 fn user_query() -> EntityQuery {
-    query(&vec![&*USER_TYPE])
+    query(&[&*USER_TYPE])
 }
 
 trait EasyOrder {
@@ -1101,29 +1336,36 @@ impl EasyOrder for EntityQuery {
     }
 }
 
-#[test]
+#[graph::test]
 #[should_panic(
     expected = "layout.query failed to execute query: FulltextQueryInvalidSyntax(\"syntax error in tsquery: \\\"Jono 'a\\\"\")"
 )]
-fn check_fulltext_search_syntax_error() {
-    run_test(move |conn, layout| {
-        QueryChecker::new(conn, layout).check(
-            vec!["1"],
-            user_query().filter(EntityFilter::Equal("userSearch".into(), "Jono 'a".into())),
-        );
-    });
+async fn check_fulltext_search_syntax_error() {
+    run_test(async |conn, layout| {
+        QueryChecker::new(conn, layout)
+            .await
+            .check(
+                vec!["1"],
+                user_query().filter(EntityFilter::Fulltext(
+                    "userSearch".into(),
+                    "Jono 'a".into(),
+                )),
+            )
+            .await;
+    })
+    .await;
 }
 
-#[test]
-fn check_block_finds() {
-    run_test(move |conn, layout| {
-        let checker = QueryChecker::new(conn, layout);
+#[graph::test]
+async fn check_block_finds() {
+    run_test(async |conn, layout| {
+        let checker = QueryChecker::new(conn, layout).await;
 
         update_user_entity(
-            conn,
+            checker.conn,
             layout,
             "1",
-            &*USER_TYPE,
+            &USER_TYPE,
             "Johnton",
             "tonofjohn@email.com",
             67_i32,
@@ -1133,7 +1375,9 @@ fn check_block_finds() {
             None,
             55,
             1,
-        );
+            4,
+        )
+        .await;
 
         checker
             // Max block, we should get nothing
@@ -1141,64 +1385,82 @@ fn check_block_finds() {
                 vec![],
                 user_query().filter(EntityFilter::ChangeBlockGte(BLOCK_NUMBER_MAX)),
             )
+            .await
             // Initial block, we should get here all data
             .check(
                 vec!["1", "2", "3"],
                 user_query().filter(EntityFilter::ChangeBlockGte(0)),
             )
+            .await
             // Block with an update, we should have one only
             .check(
                 vec!["1"],
                 user_query().filter(EntityFilter::ChangeBlockGte(1)),
-            );
-    });
+            )
+            .await;
+    })
+    .await;
 }
 
-#[test]
-fn check_find() {
-    run_test(move |conn, layout| {
+#[graph::test]
+async fn check_find() {
+    run_test(async |conn, layout| {
         // find with interfaces
         let types = vec![&*CAT_TYPE, &*DOG_TYPE];
         let checker = QueryChecker::new(conn, layout)
+            .await
             .check(vec!["garfield", "pluto"], query(&types))
+            .await
             .check(vec!["pluto", "garfield"], query(&types).desc("name"))
+            .await
             .check(
                 vec!["garfield"],
                 query(&types)
                     .filter(EntityFilter::StartsWith("name".into(), Value::from("Gar")))
                     .desc("name"),
             )
+            .await
             .check(vec!["pluto", "garfield"], query(&types).desc("id"))
+            .await
             .check(vec!["garfield", "pluto"], query(&types).asc("id"))
-            .check(vec!["garfield", "pluto"], query(&types).unordered());
+            .await
+            .check(vec!["garfield", "pluto"], query(&types).unordered())
+            .await;
 
         // fulltext
         let checker = checker
             .check(
                 vec!["3"],
-                user_query().filter(EntityFilter::Equal("userSearch".into(), "Shaq:*".into())),
+                user_query().filter(EntityFilter::Fulltext("userSearch".into(), "Shaq:*".into())),
             )
+            .await
             .check(
                 vec!["1"],
-                user_query().filter(EntityFilter::Equal(
+                user_query().filter(EntityFilter::Fulltext(
                     "userSearch".into(),
                     "Jono & achangedemail@email.com".into(),
                 )),
-            );
+            )
+            .await;
         // Test with a second fulltext search; we had a bug that caused only
         // one search index to be populated (see issue #4794)
         let checker = checker
             .check(
                 vec!["3"],
-                user_query().filter(EntityFilter::Equal("userSearch2".into(), "Shaq:*".into())),
+                user_query().filter(EntityFilter::Fulltext(
+                    "userSearch2".into(),
+                    "Shaq:*".into(),
+                )),
             )
+            .await
             .check(
                 vec!["1"],
-                user_query().filter(EntityFilter::Equal(
+                user_query().filter(EntityFilter::Fulltext(
                     "userSearch2".into(),
                     "Jono & achangedemail@email.com".into(),
                 )),
-            );
+            )
+            .await;
 
         // list contains
         fn drinks_query(v: Vec<&str>) -> EntityQuery {
@@ -1208,11 +1470,16 @@ fn check_find() {
 
         let checker = checker
             .check(vec!["2"], drinks_query(vec!["beer"]))
+            .await
             // Reverse of how we stored it
             .check(vec!["3"], drinks_query(vec!["tea", "coffee"]))
+            .await
             .check(vec![], drinks_query(vec!["beer", "tea"]))
+            .await
             .check(vec![], drinks_query(vec!["beer", "water"]))
-            .check(vec![], drinks_query(vec!["beer", "wine", "water"]));
+            .await
+            .check(vec![], drinks_query(vec!["beer", "wine", "water"]))
+            .await;
 
         // list not contains
         let checker = checker
@@ -1224,6 +1491,7 @@ fn check_find() {
                     vec!["beer"].into(),
                 )),
             )
+            .await
             // Users 2 do not have "tea" on its drinks list.
             .check(
                 vec!["2"],
@@ -1231,7 +1499,8 @@ fn check_find() {
                     "drinks".into(),
                     vec!["tea"].into(),
                 )),
-            );
+            )
+            .await;
 
         // string attributes
         let checker = checker
@@ -1239,10 +1508,12 @@ fn check_find() {
                 vec!["2"],
                 user_query().filter(EntityFilter::Contains("name".into(), "ind".into())),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query().filter(EntityFilter::Equal("name".to_owned(), "Cindini".into())),
             )
+            .await
             // Test that we can order by id
             .check(
                 vec!["2"],
@@ -1250,28 +1521,33 @@ fn check_find() {
                     .filter(EntityFilter::Equal("name".to_owned(), "Cindini".into()))
                     .desc("id"),
             )
+            .await
             .check(
                 vec!["1", "3"],
                 user_query()
                     .filter(EntityFilter::Not("name".to_owned(), "Cindini".into()))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["3"],
                 user_query().filter(EntityFilter::GreaterThan("name".to_owned(), "Kundi".into())),
             )
+            .await
             .check(
                 vec!["2", "1"],
                 user_query()
                     .filter(EntityFilter::LessThan("name".to_owned(), "Kundi".into()))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
                     .filter(EntityFilter::LessThan("name".to_owned(), "Kundi".into()))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query()
@@ -1280,6 +1556,7 @@ fn check_find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -1289,18 +1566,21 @@ fn check_find() {
                     ]))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
                     .filter(EntityFilter::EndsWith("name".to_owned(), "ini".into()))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
                     .filter(EntityFilter::NotEndsWith("name".to_owned(), "ini".into()))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query()
@@ -1310,10 +1590,12 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec![],
                 user_query().filter(EntityFilter::In("name".to_owned(), vec![])),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -1322,7 +1604,8 @@ fn check_find() {
                         vec!["Shaqueeena".into()],
                     ))
                     .desc("name"),
-            );
+            )
+            .await;
         // float attributes
         let checker = checker
             .check(
@@ -1332,6 +1615,7 @@ fn check_find() {
                     Value::BigDecimal(184.4.into()),
                 )),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
@@ -1341,6 +1625,7 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query().filter(EntityFilter::GreaterThan(
@@ -1348,6 +1633,7 @@ fn check_find() {
                     Value::BigDecimal(160.0.into()),
                 )),
             )
+            .await
             .check(
                 vec!["2", "3"],
                 user_query()
@@ -1357,6 +1643,7 @@ fn check_find() {
                     ))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
@@ -1366,6 +1653,7 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -1377,6 +1665,7 @@ fn check_find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -1390,6 +1679,7 @@ fn check_find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -1402,15 +1692,18 @@ fn check_find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
 
         // int 8 attributes
-        let checker = checker.check(
-            vec!["3"],
-            user_query()
-                .filter(EntityFilter::Equal("visits".to_owned(), Value::Int(22_i32)))
-                .desc("name"),
-        );
+        let checker = checker
+            .check(
+                vec!["3"],
+                user_query()
+                    .filter(EntityFilter::Equal("visits".to_owned(), Value::Int(22_i32)))
+                    .desc("name"),
+            )
+            .await;
 
         // int attributes
         let checker = checker
@@ -1420,12 +1713,14 @@ fn check_find() {
                     .filter(EntityFilter::Equal("age".to_owned(), Value::Int(67_i32)))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
                     .filter(EntityFilter::Not("age".to_owned(), Value::Int(67_i32)))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query().filter(EntityFilter::GreaterThan(
@@ -1433,6 +1728,7 @@ fn check_find() {
                     Value::Int(43_i32),
                 )),
             )
+            .await
             .check(
                 vec!["2", "1"],
                 user_query()
@@ -1442,12 +1738,14 @@ fn check_find() {
                     ))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["2", "3"],
                 user_query()
                     .filter(EntityFilter::LessThan("age".to_owned(), Value::Int(50_i32)))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["2", "3"],
                 user_query()
@@ -1457,12 +1755,14 @@ fn check_find() {
                     ))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
                     .filter(EntityFilter::LessThan("age".to_owned(), Value::Int(50_i32)))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -1471,6 +1771,7 @@ fn check_find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -1481,6 +1782,7 @@ fn check_find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["3"],
                 user_query()
@@ -1490,7 +1792,8 @@ fn check_find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
 
         // bool attributes
         let checker = checker
@@ -1500,12 +1803,14 @@ fn check_find() {
                     .filter(EntityFilter::Equal("coffee".to_owned(), Value::Bool(true)))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1", "3"],
                 user_query()
                     .filter(EntityFilter::Not("coffee".to_owned(), Value::Bool(true)))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -1516,6 +1821,7 @@ fn check_find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -1525,7 +1831,8 @@ fn check_find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
         // misc tests
         let checker = checker
             .check(
@@ -1537,6 +1844,7 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["3"],
                 user_query()
@@ -1546,12 +1854,14 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
                     .filter(EntityFilter::Not("favorite_color".to_owned(), Value::Null))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -1561,6 +1871,7 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -1570,16 +1881,27 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(vec!["3", "2", "1"], user_query().asc("weight"))
+            .await
             .check(vec!["1", "2", "3"], user_query().desc("weight"))
+            .await
             .check(vec!["1", "2", "3"], user_query().unordered())
+            .await
             .check(vec!["1", "2", "3"], user_query().asc("id"))
+            .await
             .check(vec!["3", "2", "1"], user_query().desc("id"))
+            .await
             .check(vec!["1", "2", "3"], user_query().unordered())
+            .await
             .check(vec!["3", "2", "1"], user_query().asc("age"))
+            .await
             .check(vec!["1", "2", "3"], user_query().desc("age"))
+            .await
             .check(vec!["2", "1", "3"], user_query().asc("name"))
+            .await
             .check(vec!["3", "1", "2"], user_query().desc("name"))
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -1588,7 +1910,8 @@ fn check_find() {
                         EntityFilter::Equal("id".to_owned(), Value::from("2")),
                     ])]))
                     .asc("id"),
-            );
+            )
+            .await;
 
         // enum attributes
         let checker = checker
@@ -1601,12 +1924,14 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query()
                     .filter(EntityFilter::Not("favorite_color".to_owned(), "red".into()))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -1617,6 +1942,7 @@ fn check_find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query()
@@ -1626,7 +1952,8 @@ fn check_find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
 
         // empty and / or
 
@@ -1640,12 +1967,15 @@ fn check_find() {
                 vec![],
                 user_query().filter(EntityFilter::And(vec![EntityFilter::Or(vec![])])),
             )
+            .await
             // An empty 'and' is 'true'
             .check(
                 vec!["1", "2", "3"],
                 user_query().filter(EntityFilter::Or(vec![EntityFilter::And(vec![])])),
-            );
+            )
+            .await;
     })
+    .await
 }
 
 // We call our test strings aN so that
@@ -1665,30 +1995,35 @@ fn ferrets() -> (String, String, String, String) {
 }
 
 struct FilterChecker<'a> {
-    conn: &'a PgConnection,
+    conn: &'a mut AsyncPgConnection,
     layout: &'a Layout,
 }
 
 impl<'a> FilterChecker<'a> {
-    fn new(conn: &'a PgConnection, layout: &'a Layout) -> Self {
+    async fn new(conn: &'a mut AsyncPgConnection, layout: &'a Layout) -> Self {
         let (a1, a2, a2b, a3) = ferrets();
-        insert_pet(conn, layout, &*FERRET_TYPE, "a1", &a1, 0);
-        insert_pet(conn, layout, &*FERRET_TYPE, "a2", &a2, 0);
-        insert_pet(conn, layout, &*FERRET_TYPE, "a2b", &a2b, 0);
-        insert_pet(conn, layout, &*FERRET_TYPE, "a3", &a3, 0);
+        insert_pet(conn, layout, &FERRET_TYPE, "a1", &a1, 0, 0).await;
+        insert_pet(conn, layout, &FERRET_TYPE, "a2", &a2, 0, 1).await;
+        insert_pet(conn, layout, &FERRET_TYPE, "a2b", &a2b, 0, 2).await;
+        insert_pet(conn, layout, &FERRET_TYPE, "a3", &a3, 0, 3).await;
 
         Self { conn, layout }
     }
 
-    fn check(&self, expected_entity_ids: Vec<&'static str>, filter: EntityFilter) -> &Self {
+    async fn check(
+        &mut self,
+        expected_entity_ids: Vec<&'static str>,
+        filter: EntityFilter,
+    ) -> &mut Self {
         let expected_entity_ids: Vec<String> =
             expected_entity_ids.into_iter().map(str::to_owned).collect();
 
-        let query = query(&vec![&*FERRET_TYPE]).filter(filter).asc("id");
+        let query = query(&[&*FERRET_TYPE]).filter(filter).asc("id");
 
         let entities = self
             .layout
             .query::<Entity>(&LOGGER, self.conn, query)
+            .await
             .expect("layout.query failed to execute query")
             .0;
 
@@ -1706,8 +2041,8 @@ impl<'a> FilterChecker<'a> {
     }
 }
 
-#[test]
-fn check_filters() {
+#[graph::test]
+async fn check_filters() {
     let (a1, a2, a2b, a3) = ferrets();
 
     fn filter_eq(name: &str) -> EntityFilter {
@@ -1758,75 +2093,173 @@ fn check_filters() {
         )
     }
 
-    run_test(move |conn, layout| {
-        let checker = FilterChecker::new(conn, layout);
+    run_test(async |conn, layout| {
+        let mut checker = FilterChecker::new(conn, layout).await;
 
         checker
             .check(vec!["a1"], filter_eq(&a1))
+            .await
             .check(vec!["a2"], filter_eq(&a2))
+            .await
             .check(vec!["a2b"], filter_eq(&a2b))
-            .check(vec!["a3"], filter_eq(&a3));
+            .await
+            .check(vec!["a3"], filter_eq(&a3))
+            .await;
 
         checker
             .check(vec!["a2", "a2b", "a3"], filter_not(&a1))
+            .await
             .check(vec!["a1", "a2b", "a3"], filter_not(&a2))
+            .await
             .check(vec!["a1", "a2", "a3"], filter_not(&a2b))
-            .check(vec!["a1", "a2", "a2b"], filter_not(&a3));
+            .await
+            .check(vec!["a1", "a2", "a2b"], filter_not(&a3))
+            .await;
 
         checker
             .check(vec![], filter_lt(&a1))
+            .await
             .check(vec!["a1"], filter_lt(&a2))
+            .await
             .check(vec!["a1", "a2", "a3"], filter_lt(&a2b))
-            .check(vec!["a1", "a2"], filter_lt(&a3));
+            .await
+            .check(vec!["a1", "a2"], filter_lt(&a3))
+            .await;
 
         checker
             .check(vec!["a1"], filter_le(&a1))
+            .await
             .check(vec!["a1", "a2"], filter_le(&a2))
+            .await
             .check(vec!["a1", "a2", "a2b", "a3"], filter_le(&a2b))
-            .check(vec!["a1", "a2", "a3"], filter_le(&a3));
+            .await
+            .check(vec!["a1", "a2", "a3"], filter_le(&a3))
+            .await;
 
         checker
             .check(vec!["a2", "a2b", "a3"], filter_gt(&a1))
+            .await
             .check(vec!["a2b", "a3"], filter_gt(&a2))
+            .await
             .check(vec![], filter_gt(&a2b))
-            .check(vec!["a2b"], filter_gt(&a3));
+            .await
+            .check(vec!["a2b"], filter_gt(&a3))
+            .await;
 
         checker
             .check(vec!["a1", "a2", "a2b", "a3"], filter_ge(&a1))
+            .await
             .check(vec!["a2", "a2b", "a3"], filter_ge(&a2))
+            .await
             .check(vec!["a2b"], filter_ge(&a2b))
-            .check(vec!["a2b", "a3"], filter_ge(&a3));
+            .await
+            .check(vec!["a2b", "a3"], filter_ge(&a3))
+            .await;
 
         checker
             .check(vec!["a1"], filter_in(vec![&a1]))
+            .await
             .check(vec!["a2"], filter_in(vec![&a2]))
+            .await
             .check(vec!["a2b"], filter_in(vec![&a2b]))
+            .await
             .check(vec!["a3"], filter_in(vec![&a3]))
+            .await
             .check(vec!["a1", "a2"], filter_in(vec![&a1, &a2]))
-            .check(vec!["a1", "a3"], filter_in(vec![&a1, &a3]));
+            .await
+            .check(vec!["a1", "a3"], filter_in(vec![&a1, &a3]))
+            .await;
 
         checker
             .check(vec!["a2", "a2b", "a3"], filter_not_in(vec![&a1]))
+            .await
             .check(vec!["a1", "a2b", "a3"], filter_not_in(vec![&a2]))
+            .await
             .check(vec!["a1", "a2", "a3"], filter_not_in(vec![&a2b]))
+            .await
             .check(vec!["a1", "a2", "a2b"], filter_not_in(vec![&a3]))
+            .await
             .check(vec!["a2b", "a3"], filter_not_in(vec![&a1, &a2]))
-            .check(vec!["a2", "a2b"], filter_not_in(vec![&a1, &a3]));
+            .await
+            .check(vec!["a2", "a2b"], filter_not_in(vec![&a1, &a3]))
+            .await;
 
         update_entity_at(
-            conn,
+            checker.conn,
             layout,
-            &*FERRET_TYPE,
+            &FERRET_TYPE,
             vec![entity! { layout.input_schema =>
               id: "a1",
-              name: "Test"
+              name: "Test",
+              vid: 5i64
             }],
             1,
-        );
+        )
+        .await;
 
         checker
             .check(vec!["a1", "a2", "a2b", "a3"], filter_block_gte(0))
+            .await
             .check(vec!["a1"], filter_block_gte(1))
-            .check(vec![], filter_block_gte(BLOCK_NUMBER_MAX));
-    });
+            .await
+            .check(vec![], filter_block_gte(BLOCK_NUMBER_MAX))
+            .await;
+    })
+    .await;
+}
+
+fn store_layer_row_group_update(
+    entity_type: &EntityType,
+    block: BlockNumber,
+    data: impl IntoIterator<Item = (EntityKey, Entity)>,
+) -> RowGroup {
+    let mut group = RowGroup::new(entity_type.clone());
+    for (key, data) in data {
+        group
+            .push(EntityModification::overwrite(key, data, block), block)
+            .unwrap();
+    }
+    group
+}
+
+fn store_layer_row_group_delete(
+    entity_type: &EntityType,
+    block: BlockNumber,
+    data: impl IntoIterator<Item = EntityKey>,
+) -> RowGroup {
+    let mut group = RowGroup::new(entity_type.clone());
+    for key in data {
+        group
+            .push(EntityModification::remove(key, block), block)
+            .unwrap();
+    }
+    group
+}
+
+#[graph::test]
+async fn skip_duplicates_update_returns_ok() {
+    run_test(async |conn, layout| {
+        let entity = entity! { layout.input_schema =>
+            id: "sd1",
+            order: 1,
+            vid: 0i64
+        };
+        let key = SKIP_DUP_MINK_TYPE.key(entity.id());
+        let entities = vec![(key, entity)];
+        let group = store_layer_row_group_update(&SKIP_DUP_MINK_TYPE, 1, entities);
+        let result = layout.update(conn, &group, &MOCK_STOPWATCH).await;
+        assert_eq!(result.unwrap(), 0);
+    })
+    .await;
+}
+
+#[graph::test]
+async fn skip_duplicates_delete_returns_ok() {
+    run_test(async |conn, layout| {
+        let key = SKIP_DUP_MINK_TYPE.parse_key("sd1").unwrap();
+        let group = store_layer_row_group_delete(&SKIP_DUP_MINK_TYPE, 1, vec![key]);
+        let result = layout.delete(conn, &group, &MOCK_STOPWATCH).await;
+        assert_eq!(result.unwrap(), 0);
+    })
+    .await;
 }
diff --git a/store/test-store/tests/postgres/relational_bytes.rs b/store/test-store/tests/postgres/relational_bytes.rs
index b50e8e14d96..1d608114eac 100644
--- a/store/test-store/tests/postgres/relational_bytes.rs
+++ b/store/test-store/tests/postgres/relational_bytes.rs
@@ -1,24 +1,25 @@
 //! Test relational schemas that use `Bytes` to store ids
-use diesel::connection::SimpleConnection as _;
-use diesel::pg::PgConnection;
+use diesel_async::SimpleAsyncConnection;
+
 use graph::components::store::write::RowGroup;
 use graph::data::store::scalar;
 use graph::data_source::CausalityRegion;
 use graph::entity;
+use graph::prelude::alloy::primitives::B256;
 use graph::prelude::{BlockNumber, EntityModification, EntityQuery, MetricsRegistry, StoreError};
 use graph::schema::{EntityKey, EntityType, InputSchema};
+use graph_store_postgres::AsyncPgConnection;
 use hex_literal::hex;
 use lazy_static::lazy_static;
 use std::collections::BTreeSet;
 use std::str::FromStr;
 use std::{collections::BTreeMap, sync::Arc};
 
-use graph::data::store::scalar::{BigDecimal, BigInt};
 use graph::data::store::IdList;
+use graph::data::store::scalar::{BigDecimal, BigInt};
 use graph::prelude::{
-    o, slog, web3::types::H256, AttributeNames, ChildMultiplicity, DeploymentHash, Entity,
-    EntityCollection, EntityLink, EntityWindow, Logger, ParentLink, StopwatchMetrics,
-    WindowAttribute, BLOCK_NUMBER_MAX,
+    AttributeNames, BLOCK_NUMBER_MAX, ChildMultiplicity, DeploymentHash, Entity, EntityCollection,
+    EntityLink, EntityWindow, Logger, ParentLink, StopwatchMetrics, WindowAttribute, o, slog,
 };
 use graph_store_postgres::{
     layout_for_tests::make_dummy_site,
@@ -42,21 +43,22 @@ lazy_static! {
     static ref THINGS_SCHEMA: InputSchema =
         InputSchema::parse_latest(THINGS_GQL, THINGS_SUBGRAPH_ID.clone())
             .expect("Failed to parse THINGS_GQL");
-    static ref LARGE_INT: BigInt = BigInt::from(std::i64::MAX).pow(17).unwrap();
+    static ref LARGE_INT: BigInt = BigInt::from(i64::MAX).pow(17).unwrap();
     static ref LARGE_DECIMAL: BigDecimal =
         BigDecimal::from(1) / BigDecimal::new(LARGE_INT.clone(), 1);
-    static ref BYTES_VALUE: H256 = H256::from(hex!(
+    static ref BYTES_VALUE: B256 = B256::from(hex!(
         "e8b3b02b936c4a4a331ac691ac9a86e197fb7731f14e3108602c87d4dac55160"
     ));
-    static ref BYTES_VALUE2: H256 = H256::from(hex!(
+    static ref BYTES_VALUE2: B256 = B256::from(hex!(
         "b98fb783b49de5652097a989414c767824dff7e7fd765a63b493772511db81c1"
     ));
-    static ref BYTES_VALUE3: H256 = H256::from(hex!(
+    static ref BYTES_VALUE3: B256 = B256::from(hex!(
         "977c084229c72a0fa377cae304eda9099b6a2cb5d83b25cdf0f0969b69874255"
     ));
     static ref BEEF_ENTITY: Entity = entity! { THINGS_SCHEMA =>
         id: scalar::Bytes::from_str("deadbeef").unwrap(),
         name: "Beef",
+        vid: 0i64
     };
     static ref NAMESPACE: Namespace = Namespace::new("sgd0815".to_string()).unwrap();
     static ref THING_TYPE: EntityType = THINGS_SCHEMA.entity_type("Thing").unwrap();
@@ -70,9 +72,10 @@ lazy_static! {
 }
 
 /// Removes test data from the database behind the store.
-fn remove_test_data(conn: &PgConnection) {
+async fn remove_test_data(conn: &mut AsyncPgConnection) {
     let query = format!("drop schema if exists {} cascade", NAMESPACE.as_str());
     conn.batch_execute(&query)
+        .await
         .expect("Failed to drop test schema");
 }
 
@@ -81,7 +84,7 @@ pub fn row_group_update(
     block: BlockNumber,
     data: impl IntoIterator<Item = (EntityKey, Entity)>,
 ) -> RowGroup {
-    let mut group = RowGroup::new(entity_type.clone(), false);
+    let mut group = RowGroup::new(entity_type.clone());
     for (key, data) in data {
         group
             .push(EntityModification::overwrite(key, data, block), block)
@@ -95,7 +98,7 @@ pub fn row_group_insert(
     block: BlockNumber,
     data: impl IntoIterator<Item = (EntityKey, Entity)>,
 ) -> RowGroup {
-    let mut group = RowGroup::new(entity_type.clone(), false);
+    let mut group = RowGroup::new(entity_type.clone());
     for (key, data) in data {
         group
             .push(EntityModification::insert(key, data, block), block)
@@ -109,7 +112,7 @@ pub fn row_group_delete(
     block: BlockNumber,
     data: impl IntoIterator<Item = EntityKey>,
 ) -> RowGroup {
-    let mut group = RowGroup::new(entity_type.clone(), false);
+    let mut group = RowGroup::new(entity_type.clone());
     for key in data {
         group
             .push(EntityModification::remove(key, block), block)
@@ -118,33 +121,49 @@ pub fn row_group_delete(
     group
 }
 
-fn insert_entity(conn: &PgConnection, layout: &Layout, entity_type: &str, entity: Entity) {
+async fn insert_entity(
+    conn: &mut AsyncPgConnection,
+    layout: &Layout,
+    entity_type: &str,
+    entity: Entity,
+) {
     let entity_type = layout.input_schema.entity_type(entity_type).unwrap();
     let key = entity_type.key(entity.id());
 
     let entities = vec![(key.clone(), entity)];
     let group = row_group_insert(&entity_type, 0, entities);
     let errmsg = format!("Failed to insert entity {}[{}]", entity_type, key.entity_id);
-    layout.insert(conn, &group, &MOCK_STOPWATCH).expect(&errmsg);
+    layout
+        .insert(&LOGGER, conn, &group, &MOCK_STOPWATCH)
+        .await
+        .expect(&errmsg);
 }
 
-fn insert_thing(conn: &PgConnection, layout: &Layout, id: &str, name: &str) {
+async fn insert_thing(
+    conn: &mut AsyncPgConnection,
+    layout: &Layout,
+    id: &str,
+    name: &str,
+    vid: i64,
+) {
     insert_entity(
         conn,
         layout,
         "Thing",
         entity! { layout.input_schema =>
             id: id,
-            name: name
+            name: name,
+            vid: vid,
         },
-    );
+    )
+    .await;
 }
 
-fn create_schema(conn: &PgConnection) -> Layout {
+async fn create_schema(conn: &mut AsyncPgConnection) -> Layout {
     let schema = InputSchema::parse_latest(THINGS_GQL, THINGS_SUBGRAPH_ID.clone()).unwrap();
 
     let query = format!("create schema {}", NAMESPACE.as_str());
-    conn.batch_execute(&query).unwrap();
+    conn.batch_execute(&query).await.unwrap();
 
     let site = make_dummy_site(
         THINGS_SUBGRAPH_ID.clone(),
@@ -152,15 +171,10 @@ fn create_schema(conn: &PgConnection) -> Layout {
         NETWORK_NAME.to_string(),
     );
     Layout::create_relational_schema(conn, Arc::new(site), &schema, BTreeSet::new())
+        .await
         .expect("Failed to create relational schema")
 }
 
-fn scrub(entity: &Entity) -> Entity {
-    let mut scrubbed = entity.clone();
-    scrubbed.remove_null_fields();
-    scrubbed
-}
-
 macro_rules! assert_entity_eq {
     ($left:expr, $right:expr) => {{
         let (left, right) = (&($left), &($right));
@@ -193,38 +207,39 @@ macro_rules! assert_entity_eq {
     }};
 }
 
-fn run_test<F>(test: F)
+async fn run_test<F>(test: F)
 where
-    F: FnOnce(&PgConnection, &Layout),
+    F: AsyncFnOnce(&mut AsyncPgConnection, &Layout),
 {
-    run_test_with_conn(|conn| {
+    run_test_with_conn(async |conn| {
         // Reset state before starting
-        remove_test_data(conn);
+        remove_test_data(conn).await;
 
         // Seed database with test data
-        let layout = create_schema(conn);
+        let layout = create_schema(conn).await;
 
         // Run test
-        test(conn, &layout);
-    });
+        test(conn, &layout).await;
+    })
+    .await;
 }
 
-#[test]
-fn bad_id() {
-    run_test(|conn, layout| {
-        fn find(
-            conn: &PgConnection,
+#[graph::test]
+async fn bad_id() {
+    run_test(async |conn, layout| {
+        async fn find(
+            conn: &mut AsyncPgConnection,
             layout: &Layout,
             id: &str,
         ) -> Result<Option<Entity>, StoreError> {
             let key = THING_TYPE.parse_key(id)?;
-            layout.find(conn, &key, BLOCK_NUMBER_MAX)
+            layout.find(conn, &key, BLOCK_NUMBER_MAX).await
         }
 
         // We test that we get errors for various strings that are not
         // valid 'Bytes' strings; we use `find` to force the conversion
         // from String -> Bytes internally
-        let res = find(conn, layout, "bad");
+        let res = find(conn, layout, "bad").await;
         assert!(res.is_err());
         assert_eq!(
             "store error: can not convert `bad` to Id::Bytes: Odd number of digits",
@@ -232,7 +247,7 @@ fn bad_id() {
         );
 
         // We do not allow the `\x` prefix that Postgres uses
-        let res = find(conn, layout, "\\xbadd");
+        let res = find(conn, layout, "\\xbadd").await;
         assert!(res.is_err());
         assert_eq!(
             "store error: can not convert `\\xbadd` to Id::Bytes: Invalid character '\\\\' at position 0",
@@ -240,57 +255,63 @@ fn bad_id() {
         );
 
         // Having the '0x' prefix is ok
-        let res = find(conn, layout, "0xbadd");
+        let res = find(conn, layout, "0xbadd").await;
         assert!(res.is_ok());
 
         // Using non-hex characters is also bad
-        let res = find(conn, layout, "nope");
+        let res = find(conn, layout, "nope").await;
         assert!(res.is_err());
         assert_eq!(
             "store error: can not convert `nope` to Id::Bytes: Invalid character 'n' at position 0",
             res.err().unwrap().to_string()
         );
-    });
+    }).await;
 }
 
-#[test]
-fn find() {
-    run_test(|conn, layout| {
-        fn find_entity(conn: &PgConnection, layout: &Layout, id: &str) -> Option<Entity> {
+#[graph::test]
+async fn find() {
+    run_test(async |conn, layout| {
+        async fn find_entity(
+            conn: &mut AsyncPgConnection,
+            layout: &Layout,
+            id: &str,
+        ) -> Option<Entity> {
             let key = THING_TYPE.parse_key(id).unwrap();
             layout
                 .find(conn, &key, BLOCK_NUMBER_MAX)
-                .expect(&format!("Failed to read Thing[{}]", id))
+                .await
+                .unwrap_or_else(|_| panic!("Failed to read Thing[{}]", id))
         }
 
         const ID: &str = "deadbeef";
         const NAME: &str = "Beef";
-        insert_thing(conn, layout, ID, NAME);
+        insert_thing(conn, layout, ID, NAME, 0).await;
 
         // Happy path: find existing entity
-        let entity = find_entity(conn, layout, ID).unwrap();
-        assert_entity_eq!(scrub(&BEEF_ENTITY), entity);
+        let entity = find_entity(conn, layout, ID).await.unwrap();
+        assert_entity_eq!(BEEF_ENTITY.clone(), entity);
         assert!(CausalityRegion::from_entity(&entity) == CausalityRegion::ONCHAIN);
 
         // Find non-existing entity
-        let entity = find_entity(conn, layout, "badd");
+        let entity = find_entity(conn, layout, "badd").await;
         assert!(entity.is_none());
-    });
+    })
+    .await;
 }
 
-#[test]
-fn find_many() {
-    run_test(|conn, layout| {
+#[graph::test]
+async fn find_many() {
+    run_test(async |conn, layout| {
         const ID: &str = "0xdeadbeef";
         const NAME: &str = "Beef";
         const ID2: &str = "0xdeadbeef02";
         const NAME2: &str = "Moo";
-        insert_thing(conn, layout, ID, NAME);
-        insert_thing(conn, layout, ID2, NAME2);
+        insert_thing(conn, layout, ID, NAME, 0).await;
+        insert_thing(conn, layout, ID2, NAME2, 1).await;
 
         let mut id_map = BTreeMap::default();
         let ids = IdList::try_from_iter(
-            &*THING_TYPE,
+            THING_TYPE.id_type().unwrap(),
             vec![ID, ID2, "badd"]
                 .into_iter()
                 .map(|id| THING_TYPE.parse_id(id).unwrap()),
@@ -300,6 +321,7 @@ fn find_many() {
 
         let entities = layout
             .find_many(conn, &id_map, BLOCK_NUMBER_MAX)
+            .await
             .expect("Failed to read many things");
         assert_eq!(2, entities.len());
 
@@ -307,17 +329,19 @@ fn find_many() {
         let id2_key = THING_TYPE.parse_key(ID2).unwrap();
         assert!(entities.contains_key(&id_key), "Missing ID");
         assert!(entities.contains_key(&id2_key), "Missing ID2");
-    });
+    })
+    .await;
 }
 
-#[test]
-fn update() {
-    run_test(|conn, layout| {
-        insert_entity(conn, layout, "Thing", BEEF_ENTITY.clone());
+#[graph::test]
+async fn update() {
+    run_test(async |conn, layout| {
+        insert_entity(conn, layout, "Thing", BEEF_ENTITY.clone()).await;
 
         // Update the entity
         let mut entity = BEEF_ENTITY.clone();
         entity.set("name", "Moo").unwrap();
+        entity.set("vid", 1i64).unwrap();
         let key = THING_TYPE.key(entity.id());
 
         let entity_id = entity.id();
@@ -326,26 +350,30 @@ fn update() {
         let group = row_group_update(&entity_type, 1, entities);
         layout
             .update(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to update");
 
         let actual = layout
             .find(conn, &THING_TYPE.key(entity_id), BLOCK_NUMBER_MAX)
+            .await
             .expect("Failed to read Thing[deadbeef]")
             .unwrap();
 
         assert_entity_eq!(entity, actual);
-    });
+    })
+    .await;
 }
 
-#[test]
-fn delete() {
-    run_test(|conn, layout| {
+#[graph::test]
+async fn delete() {
+    run_test(async |conn, layout| {
         const TWO_ID: &str = "deadbeef02";
 
-        insert_entity(conn, layout, "Thing", BEEF_ENTITY.clone());
+        insert_entity(conn, layout, "Thing", BEEF_ENTITY.clone()).await;
         let mut two = BEEF_ENTITY.clone();
         two.set("id", TWO_ID).unwrap();
-        insert_entity(conn, layout, "Thing", two);
+        two.set("vid", 1i64).unwrap();
+        insert_entity(conn, layout, "Thing", two).await;
 
         // Delete where nothing is getting deleted
         let key = THING_TYPE.parse_key("ffff").unwrap();
@@ -354,6 +382,7 @@ fn delete() {
         let group = row_group_delete(&entity_type, 1, entity_keys.clone());
         let count = layout
             .delete(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to delete");
         assert_eq!(0, count);
 
@@ -365,9 +394,11 @@ fn delete() {
         let group = row_group_delete(&entity_type, 1, entity_keys);
         let count = layout
             .delete(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to delete");
         assert_eq!(1, count);
-    });
+    })
+    .await;
 }
 
 //
@@ -388,50 +419,63 @@ const GRANDCHILD2: &str = "0xfafa02";
 ///     +- child2
 ///          +- grandchild2
 ///
-fn make_thing_tree(conn: &PgConnection, layout: &Layout) -> (Entity, Entity, Entity) {
+async fn make_thing_tree(
+    conn: &mut AsyncPgConnection,
+    layout: &Layout,
+) -> (Entity, Entity, Entity) {
     let root = entity! { layout.input_schema =>
         id: ROOT,
         name: "root",
-        children: vec!["babe01", "babe02"]
+        children: vec!["babe01", "babe02"],
+        vid: 0i64,
     };
     let child1 = entity! { layout.input_schema =>
         id: CHILD1,
         name: "child1",
         parent: "dead00",
-        children: vec![GRANDCHILD1]
+        children: vec![GRANDCHILD1],
+        vid: 1i64,
     };
     let child2 = entity! { layout.input_schema =>
         id: CHILD2,
         name: "child2",
         parent: "dead00",
-        children: vec![GRANDCHILD1]
+        children: vec![GRANDCHILD1],
+        vid: 2i64,
     };
     let grand_child1 = entity! { layout.input_schema =>
         id: GRANDCHILD1,
         name: "grandchild1",
-        parent: CHILD1
+        parent: CHILD1,
+        vid: 3i64,
     };
     let grand_child2 = entity! { layout.input_schema =>
         id: GRANDCHILD2,
         name: "grandchild2",
-        parent: CHILD2
+        parent: CHILD2,
+        vid: 4i64,
     };
 
-    insert_entity(conn, layout, "Thing", root.clone());
-    insert_entity(conn, layout, "Thing", child1.clone());
-    insert_entity(conn, layout, "Thing", child2.clone());
-    insert_entity(conn, layout, "Thing", grand_child1);
-    insert_entity(conn, layout, "Thing", grand_child2);
+    insert_entity(conn, layout, "Thing", root.clone()).await;
+    insert_entity(conn, layout, "Thing", child1.clone()).await;
+    insert_entity(conn, layout, "Thing", child2.clone()).await;
+    insert_entity(conn, layout, "Thing", grand_child1).await;
+    insert_entity(conn, layout, "Thing", grand_child2).await;
     (root, child1, child2)
 }
 
-#[test]
-fn query() {
-    fn fetch(conn: &PgConnection, layout: &Layout, coll: EntityCollection) -> Vec<String> {
+#[graph::test]
+async fn query() {
+    async fn fetch(
+        conn: &mut AsyncPgConnection,
+        layout: &Layout,
+        coll: EntityCollection,
+    ) -> Vec<String> {
         let id = DeploymentHash::new("QmXW3qvxV7zXnwRntpj7yoK8HZVtaraZ67uMqaLRvXdxha").unwrap();
         let query = EntityQuery::new(id, BLOCK_NUMBER_MAX, coll).first(10);
         layout
             .query::<Entity>(&LOGGER, conn, query)
+            .await
             .map(|(entities, _)| entities)
             .expect("the query succeeds")
             .into_iter()
@@ -439,21 +483,21 @@ fn query() {
             .collect::<Vec<_>>()
     }
 
-    run_test(|conn, layout| {
+    run_test(async |conn, layout| {
         // This test exercises the different types of queries we generate;
         // the type of query is based on knowledge of what the test data
         // looks like, not on just an inference from the GraphQL model.
         // Especially the multiplicity for type A and B queries is determined
         // by knowing whether there are one or many entities per parent
         // in the test data
-        make_thing_tree(conn, layout);
+        make_thing_tree(conn, layout).await;
 
         // See https://graphprotocol.github.io/rfcs/engineering-plans/0001-graphql-query-prefetching.html#handling-parentchild-relationships
         // for a discussion of the various types of relationships and queries
 
         // EntityCollection::All
         let coll = EntityCollection::All(vec![(THING_TYPE.clone(), AttributeNames::All)]);
-        let things = fetch(conn, layout, coll);
+        let things = fetch(conn, layout, coll).await;
         assert_eq!(vec![CHILD1, CHILD2, ROOT, GRANDCHILD1, GRANDCHILD2], things);
 
         // EntityCollection::Window, type A, many
@@ -467,7 +511,7 @@ fn query() {
             ),
             column_names: AttributeNames::All,
         }]);
-        let things = fetch(conn, layout, coll);
+        let things = fetch(conn, layout, coll).await;
         assert_eq!(vec![ROOT], things);
 
         // EntityCollection::Window, type A, single
@@ -483,7 +527,7 @@ fn query() {
             ),
             column_names: AttributeNames::All,
         }]);
-        let things = fetch(conn, layout, coll);
+        let things = fetch(conn, layout, coll).await;
         assert_eq!(vec![CHILD1, CHILD2], things);
 
         // EntityCollection::Window, type B, many
@@ -497,7 +541,7 @@ fn query() {
             ),
             column_names: AttributeNames::All,
         }]);
-        let things = fetch(conn, layout, coll);
+        let things = fetch(conn, layout, coll).await;
         assert_eq!(vec![CHILD1, CHILD2], things);
 
         // EntityCollection::Window, type B, single
@@ -511,7 +555,7 @@ fn query() {
             ),
             column_names: AttributeNames::All,
         }]);
-        let things = fetch(conn, layout, coll);
+        let things = fetch(conn, layout, coll).await;
         assert_eq!(vec![GRANDCHILD1, GRANDCHILD2], things);
 
         // EntityCollection::Window, type C
@@ -526,7 +570,7 @@ fn query() {
             ),
             column_names: AttributeNames::All,
         }]);
-        let things = fetch(conn, layout, coll);
+        let things = fetch(conn, layout, coll).await;
         assert_eq!(vec![CHILD1, CHILD2], things);
 
         // EntityCollection::Window, type D
@@ -541,7 +585,8 @@ fn query() {
             ),
             column_names: AttributeNames::All,
         }]);
-        let things = fetch(conn, layout, coll);
+        let things = fetch(conn, layout, coll).await;
         assert_eq!(vec![ROOT, ROOT], things);
-    });
+    })
+    .await;
 }
diff --git a/store/test-store/tests/postgres/store.rs b/store/test-store/tests/postgres/store.rs
index ace58486614..f6365d292b3 100644
--- a/store/test-store/tests/postgres/store.rs
+++ b/store/test-store/tests/postgres/store.rs
@@ -1,14 +1,13 @@
-use graph::blockchain::block_stream::FirehoseCursor;
 use graph::blockchain::BlockTime;
+use graph::blockchain::block_stream::FirehoseCursor;
 use graph::data::graphql::ext::TypeDefinitionExt;
-use graph::data::query::QueryTarget;
 use graph::data::subgraph::schema::DeploymentCreate;
+use graph::data_source::common::MappingABI;
+use graph::prelude::alloy::primitives::{Address, B256};
 use graph::schema::{EntityType, InputSchema};
-use graph_chain_ethereum::{Mapping, MappingABI};
+use graph_chain_ethereum::Mapping;
 use hex_literal::hex;
 use lazy_static::lazy_static;
-use std::time::Duration;
-use std::{collections::HashSet, sync::Mutex};
 use std::{marker::PhantomData, str::FromStr};
 use test_store::*;
 
@@ -16,17 +15,12 @@ use graph::components::store::{DeploymentLocator, ReadStore, WritableStore};
 use graph::data::subgraph::*;
 use graph::{
     blockchain::DataSource,
-    components::store::{
-        BlockStore as _, EntityFilter, EntityOrder, EntityQuery, StatusStore,
-        SubscriptionManager as _,
-    },
-    prelude::ethabi::Contract,
+    components::store::{BlockStore as _, EntityFilter, EntityOrder, EntityQuery, StatusStore},
 };
 use graph::{data::store::scalar, semver::Version};
 use graph::{entity, prelude::*};
 use graph_store_postgres::layout_for_tests::STRING_PREFIX_SIZE;
 use graph_store_postgres::{Store as DieselStore, SubgraphStore as DieselSubgraphStore};
-use web3::types::{Address, H256};
 
 const USER_GQL: &str = "
     interface ColorAndAge {
@@ -70,56 +64,56 @@ lazy_static! {
         InputSchema::parse_latest(USER_GQL, TEST_SUBGRAPH_ID.clone())
             .expect("Failed to parse user schema");
     static ref TEST_BLOCK_0_PTR: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "bd34884280958002c51d3f7b5f853e6febeba33de0f40d15b0363006533c924f"
         )),
         0u64
     )
         .into();
     static ref TEST_BLOCK_1_PTR: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "8511fa04b64657581e3f00e14543c1d522d5d7e771b54aa3060b662ade47da13"
         )),
         1u64
     )
         .into();
     static ref TEST_BLOCK_2_PTR: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "b98fb783b49de5652097a989414c767824dff7e7fd765a63b493772511db81c1"
         )),
         2u64
     )
         .into();
     static ref TEST_BLOCK_3_PTR: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "977c084229c72a0fa377cae304eda9099b6a2cb5d83b25cdf0f0969b69874255"
         )),
         3u64
     )
         .into();
     static ref TEST_BLOCK_3A_PTR: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "d163aec0592c7cb00c2700ab65dcaac93289f5d250b3b889b39198b07e1fbe4a"
         )),
         3u64
     )
         .into();
     static ref TEST_BLOCK_4_PTR: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "007a03cdf635ebb66f5e79ae66cc90ca23d98031665649db056ff9c6aac2d74d"
         )),
         4u64
     )
         .into();
     static ref TEST_BLOCK_4A_PTR: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "8fab27e9e9285b0a39110f4d9877f05d0f43d2effa157e55f4dcc49c3cf8cbd7"
         )),
         4u64
     )
         .into();
     static ref TEST_BLOCK_5_PTR: BlockPtr = (
-        H256::from(hex!(
+        B256::from(hex!(
             "e8b3b02b936c4a4a331ac691ac9a86e197fb7731f14e3108602c87d4dac55160"
         )),
         5u64
@@ -138,7 +132,7 @@ where
     run_test_sequentially(|store| async move {
         let subgraph_store = store.subgraph_store();
         // Reset state before starting
-        remove_test_data(subgraph_store.clone());
+        remove_subgraphs().await;
 
         // Seed database with test data
         let deployment = insert_test_data(subgraph_store.clone()).await;
@@ -162,7 +156,7 @@ where
 async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator {
     let manifest = SubgraphManifest::<graph_chain_ethereum::Chain> {
         id: TEST_SUBGRAPH_ID.clone(),
-        spec_version: Version::new(1, 0, 0),
+        spec_version: Version::new(1, 3, 0),
         features: Default::default(),
         description: None,
         repository: None,
@@ -187,17 +181,19 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
             NETWORK_NAME.to_string(),
             SubgraphVersionSwitchingMode::Instant,
         )
+        .await
         .unwrap();
 
     let test_entity_1 = create_test_entity(
         "1",
-        &*USER_TYPE,
+        &USER_TYPE,
         "Johnton",
         "tonofjohn@email.com",
         67_i32,
         184.4,
         false,
         None,
+        0,
     );
     transact_entity_operations(
         &store,
@@ -210,23 +206,25 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
 
     let test_entity_2 = create_test_entity(
         "2",
-        &*USER_TYPE,
+        &USER_TYPE,
         "Cindini",
         "dinici@email.com",
         43_i32,
         159.1,
         true,
         Some("red"),
+        1,
     );
     let test_entity_3_1 = create_test_entity(
         "3",
-        &*USER_TYPE,
+        &USER_TYPE,
         "Shaqueeena",
         "queensha@email.com",
         28_i32,
         111.7,
         false,
         Some("blue"),
+        2,
     );
     transact_entity_operations(
         &store,
@@ -239,13 +237,14 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
 
     let test_entity_3_2 = create_test_entity(
         "3",
-        &*USER_TYPE,
+        &USER_TYPE,
         "Shaqueeena",
         "teeko@email.com",
         28_i32,
         111.7,
         false,
         None,
+        3,
     );
     transact_and_wait(
         &store,
@@ -269,6 +268,7 @@ fn create_test_entity(
     weight: f64,
     coffee: bool,
     favorite_color: Option<&str>,
+    vid: i64,
 ) -> EntityOperation {
     let bin_name = scalar::Bytes::from_str(&hex::encode(name)).unwrap();
     let test_entity = entity! { TEST_SUBGRAPH_SCHEMA =>
@@ -281,6 +281,7 @@ fn create_test_entity(
         weight: Value::BigDecimal(weight.into()),
         coffee: coffee,
         favorite_color: favorite_color,
+        vid: vid,
     };
 
     EntityOperation::Set {
@@ -289,16 +290,10 @@ fn create_test_entity(
     }
 }
 
-/// Removes test data from the database behind the store.
-fn remove_test_data(store: Arc<DieselSubgraphStore>) {
-    store
-        .delete_all_entities_for_test_use_only()
-        .expect("deleting test entities succeeds");
-}
-
-fn get_entity_count(store: Arc<DieselStore>, subgraph_id: &DeploymentHash) -> u64 {
+async fn get_entity_count(store: Arc<DieselStore>, subgraph_id: &DeploymentHash) -> u64 {
     let info = store
         .status(status::Filter::Deployments(vec![subgraph_id.to_string()]))
+        .await
         .unwrap();
     let info = info.first().unwrap();
     info.entity_count
@@ -310,9 +305,9 @@ fn delete_entity() {
         let entity_key = USER_TYPE.parse_key("3").unwrap();
 
         // Check that there is an entity to remove.
-        writable.get(&entity_key).unwrap().unwrap();
+        writable.get(&entity_key).await.unwrap().unwrap();
 
-        let count = get_entity_count(store.clone(), &deployment.hash);
+        let count = get_entity_count(store.clone(), &deployment.hash).await;
         transact_and_wait(
             &store.subgraph_store(),
             &deployment,
@@ -323,10 +318,13 @@ fn delete_entity() {
         )
         .await
         .unwrap();
-        assert_eq!(count, get_entity_count(store.clone(), &deployment.hash) + 1);
+        assert_eq!(
+            count,
+            get_entity_count(store.clone(), &deployment.hash).await + 1
+        );
 
         // Check that that the deleted entity id is not present
-        assert!(writable.get(&entity_key).unwrap().is_none());
+        assert!(writable.get(&entity_key).await.unwrap().is_none());
     })
 }
 
@@ -337,7 +335,7 @@ fn get_entity_1() {
         let schema = ReadStore::input_schema(&writable);
 
         let key = USER_TYPE.parse_key("1").unwrap();
-        let result = writable.get(&key).unwrap();
+        let result = writable.get(&key).await.unwrap();
 
         let bin_name = Value::Bytes("Johnton".as_bytes().into());
         let expected_entity = entity! { schema =>
@@ -349,6 +347,7 @@ fn get_entity_1() {
             seconds_age: Value::BigInt(BigInt::from(2114359200)),
             weight: Value::BigDecimal(184.4.into()),
             coffee: false,
+            vid: 0i64
         };
         // "favorite_color" was set to `Null` earlier and should be absent
 
@@ -363,7 +362,7 @@ fn get_entity_3() {
     run_test(|_, writable, _| async move {
         let schema = ReadStore::input_schema(&writable);
         let key = USER_TYPE.parse_key("3").unwrap();
-        let result = writable.get(&key).unwrap();
+        let result = writable.get(&key).await.unwrap();
 
         let expected_entity = entity! { schema =>
            id: "3",
@@ -374,6 +373,7 @@ fn get_entity_3() {
            seconds_age: Value::BigInt(BigInt::from(883612800)),
            weight: Value::BigDecimal(111.7.into()),
            coffee: false,
+           vid: 3_i64,
         };
         // "favorite_color" was set to `Null` earlier and should be absent
 
@@ -388,15 +388,16 @@ fn insert_entity() {
         let entity_key = USER_TYPE.parse_key("7").unwrap();
         let test_entity = create_test_entity(
             "7",
-            &*USER_TYPE,
+            &USER_TYPE,
             "Wanjon",
             "wanawana@email.com",
             76_i32,
             111.7,
             true,
             Some("green"),
+            5,
         );
-        let count = get_entity_count(store.clone(), &deployment.hash);
+        let count = get_entity_count(store.clone(), &deployment.hash).await;
         transact_and_wait(
             &store.subgraph_store(),
             &deployment,
@@ -405,10 +406,13 @@ fn insert_entity() {
         )
         .await
         .unwrap();
-        assert_eq!(count + 1, get_entity_count(store.clone(), &deployment.hash));
+        assert_eq!(
+            count + 1,
+            get_entity_count(store.clone(), &deployment.hash).await
+        );
 
         // Check that new record is in the store
-        writable.get(&entity_key).unwrap().unwrap();
+        writable.get(&entity_key).await.unwrap().unwrap();
     })
 }
 
@@ -419,13 +423,14 @@ fn update_existing() {
 
         let op = create_test_entity(
             "1",
-            &*USER_TYPE,
+            &USER_TYPE,
             "Wanjon",
             "wanawana@email.com",
             76_i32,
             111.7,
             true,
             Some("green"),
+            6,
         );
         let mut new_data = match op {
             EntityOperation::Set { ref data, .. } => data.clone(),
@@ -433,10 +438,10 @@ fn update_existing() {
         };
 
         // Verify that the entity before updating is different from what we expect afterwards
-        assert_ne!(writable.get(&entity_key).unwrap().unwrap(), new_data);
+        assert_ne!(writable.get(&entity_key).await.unwrap().unwrap(), new_data);
 
         // Set test entity; as the entity already exists an update should be performed
-        let count = get_entity_count(store.clone(), &deployment.hash);
+        let count = get_entity_count(store.clone(), &deployment.hash).await;
         transact_entity_operations(
             &store.subgraph_store(),
             &deployment,
@@ -445,7 +450,10 @@ fn update_existing() {
         )
         .await
         .unwrap();
-        assert_eq!(count, get_entity_count(store.clone(), &deployment.hash));
+        assert_eq!(
+            count,
+            get_entity_count(store.clone(), &deployment.hash).await
+        );
 
         // Verify that the entity in the store has changed to what we have set.
         let bin_name = match new_data.get("bin_name") {
@@ -454,7 +462,7 @@ fn update_existing() {
         };
 
         new_data.insert("bin_name", Value::Bytes(bin_name)).unwrap();
-        assert_eq!(writable.get(&entity_key).unwrap(), Some(new_data));
+        assert_eq!(writable.get(&entity_key).await.unwrap(), Some(new_data));
     })
 }
 
@@ -464,10 +472,12 @@ fn partially_update_existing() {
         let entity_key = USER_TYPE.parse_key("1").unwrap();
         let schema = writable.input_schema();
 
-        let partial_entity = entity! { schema => id: "1", name: "Johnny Boy", email: Value::Null };
+        let partial_entity =
+            entity! { schema => id: "1", name: "Johnny Boy", email: Value::Null, vid: 11i64 };
 
         let original_entity = writable
             .get(&entity_key)
+            .await
             .unwrap()
             .expect("entity not found");
 
@@ -487,6 +497,7 @@ fn partially_update_existing() {
         // Obtain the updated entity from the store
         let updated_entity = writable
             .get(&entity_key)
+            .await
             .unwrap()
             .expect("entity not found");
 
@@ -512,7 +523,7 @@ impl QueryChecker {
         Self { store }
     }
 
-    fn check(self, expected_entity_ids: Vec<&str>, query: EntityQuery) -> Self {
+    async fn check(self, expected_entity_ids: Vec<&str>, query: EntityQuery) -> Self {
         let expected_entity_ids: Vec<String> =
             expected_entity_ids.into_iter().map(str::to_owned).collect();
 
@@ -520,6 +531,7 @@ impl QueryChecker {
             .store
             .subgraph_store()
             .find(query)
+            .await
             .expect("store.find failed to execute query");
 
         let entity_ids: Vec<_> = entities
@@ -570,32 +582,38 @@ fn find() {
                 vec!["2"],
                 user_query().filter(EntityFilter::Contains("name".into(), "ind".into())),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query().filter(EntityFilter::Equal("name".to_owned(), "Cindini".into())),
             )
+            .await
             .check(
                 vec!["1", "3"],
                 user_query()
                     .filter(EntityFilter::Not("name".to_owned(), "Cindini".into()))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["3"],
                 user_query().filter(EntityFilter::GreaterThan("name".to_owned(), "Kundi".into())),
             )
+            .await
             .check(
                 vec!["2", "1"],
                 user_query()
                     .filter(EntityFilter::LessThan("name".to_owned(), "Kundi".into()))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
                     .filter(EntityFilter::LessThan("name".to_owned(), "Kundi".into()))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query()
@@ -604,6 +622,7 @@ fn find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -613,24 +632,28 @@ fn find() {
                     ]))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
                     .filter(EntityFilter::EndsWith("name".to_owned(), "ini".into()))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
                     .filter(EntityFilter::NotEndsWith("name".to_owned(), "ini".into()))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query()
                     .filter(EntityFilter::In("name".to_owned(), vec!["Johnton".into()]))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -639,7 +662,8 @@ fn find() {
                         vec!["Shaqueeena".into()],
                     ))
                     .desc("name"),
-            );
+            )
+            .await;
 
         // Filter tests with float attributes
         QueryChecker::new(store.clone())
@@ -650,6 +674,7 @@ fn find() {
                     Value::BigDecimal(184.4.into()),
                 )),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
@@ -659,6 +684,7 @@ fn find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query().filter(EntityFilter::GreaterThan(
@@ -666,6 +692,7 @@ fn find() {
                     Value::BigDecimal(160.0.into()),
                 )),
             )
+            .await
             .check(
                 vec!["2", "3"],
                 user_query()
@@ -675,6 +702,7 @@ fn find() {
                     ))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
@@ -684,6 +712,7 @@ fn find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -695,6 +724,7 @@ fn find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -708,6 +738,7 @@ fn find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -720,7 +751,8 @@ fn find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
         // Filter tests with int attributes
         QueryChecker::new(store.clone())
             .check(
@@ -729,12 +761,14 @@ fn find() {
                     .filter(EntityFilter::Equal("age".to_owned(), Value::Int(67_i32)))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
                     .filter(EntityFilter::Not("age".to_owned(), Value::Int(67_i32)))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query().filter(EntityFilter::GreaterThan(
@@ -742,6 +776,7 @@ fn find() {
                     Value::Int(43_i32),
                 )),
             )
+            .await
             .check(
                 vec!["2", "1"],
                 user_query()
@@ -751,12 +786,14 @@ fn find() {
                     ))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["2", "3"],
                 user_query()
                     .filter(EntityFilter::LessThan("age".to_owned(), Value::Int(50_i32)))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["2", "3"],
                 user_query()
@@ -766,12 +803,14 @@ fn find() {
                     ))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
                     .filter(EntityFilter::LessThan("age".to_owned(), Value::Int(50_i32)))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -780,6 +819,7 @@ fn find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -790,6 +830,7 @@ fn find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["3"],
                 user_query()
@@ -799,7 +840,8 @@ fn find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
         // Filter tests with bool attributes
         QueryChecker::new(store.clone())
             .check(
@@ -808,12 +850,14 @@ fn find() {
                     .filter(EntityFilter::Equal("coffee".to_owned(), Value::Bool(true)))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1", "3"],
                 user_query()
                     .filter(EntityFilter::Not("coffee".to_owned(), Value::Bool(true)))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -824,6 +868,7 @@ fn find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -833,7 +878,8 @@ fn find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
         // Misc filter tests
         QueryChecker::new(store)
             .check(
@@ -845,6 +891,7 @@ fn find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -854,6 +901,7 @@ fn find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -863,12 +911,14 @@ fn find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
                     .filter(EntityFilter::Not("favorite_color".to_owned(), Value::Null))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -878,14 +928,23 @@ fn find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(vec!["3", "2", "1"], user_query().asc("weight"))
+            .await
             .check(vec!["1", "2", "3"], user_query().desc("weight"))
+            .await
             .check(vec!["1", "2", "3"], user_query().asc("id"))
+            .await
             .check(vec!["3", "2", "1"], user_query().desc("id"))
+            .await
             .check(vec!["3", "2", "1"], user_query().asc("age"))
+            .await
             .check(vec!["1", "2", "3"], user_query().desc("age"))
+            .await
             .check(vec!["2", "1", "3"], user_query().asc("name"))
+            .await
             .check(vec!["3", "1", "2"], user_query().desc("name"))
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -894,82 +953,12 @@ fn find() {
                         EntityFilter::Equal("id".to_owned(), Value::from("2")),
                     ])]))
                     .asc("id"),
-            );
-    });
-}
-
-fn make_entity_change(entity_type: &EntityType) -> EntityChange {
-    EntityChange::Data {
-        subgraph_id: TEST_SUBGRAPH_ID.clone(),
-        entity_type: entity_type.to_string(),
-    }
-}
-
-// Get as events until we've seen all the expected events or we time out waiting
-async fn check_events(
-    stream: StoreEventStream<impl Stream<Item = Arc<StoreEvent>, Error = ()> + Send>,
-    expected: Vec<StoreEvent>,
-) {
-    fn as_set(events: Vec<Arc<StoreEvent>>) -> HashSet<EntityChange> {
-        events.into_iter().fold(HashSet::new(), |mut set, event| {
-            set.extend(event.changes.iter().cloned());
-            set
-        })
-    }
-
-    let expected = Mutex::new(as_set(expected.into_iter().map(Arc::new).collect()));
-    // Capture extra changes here; this is only needed for debugging, really.
-    // It's permissible that we get more changes than we expected because of
-    // how store events group changes together
-    let extra: Mutex<HashSet<EntityChange>> = Mutex::new(HashSet::new());
-    // Get events from the store until we've either seen all the changes we
-    // expected or we timed out waiting for them
-    stream
-        .take_while(|event| {
-            let mut expected = expected.lock().unwrap();
-            for change in &event.changes {
-                if !expected.remove(change) {
-                    extra.lock().unwrap().insert(change.clone());
-                }
-            }
-            future::ok(!expected.is_empty())
-        })
-        .collect()
-        .compat()
-        .timeout(Duration::from_secs(3))
-        .await
-        .unwrap_or_else(|_| {
-            panic!(
-                "timed out waiting for events\n  still waiting for {:?}\n  got extra events {:?}",
-                expected.lock().unwrap().clone(),
-                extra.lock().unwrap().clone()
             )
-        })
-        .expect("something went wrong getting events");
-    // Check again that we really got everything
-    assert_eq!(HashSet::new(), expected.lock().unwrap().clone());
-}
-
-// Subscribe to store events
-fn subscribe(
-    subgraph: &DeploymentHash,
-    entity_type: &EntityType,
-) -> StoreEventStream<impl Stream<Item = Arc<StoreEvent>, Error = ()> + Send> {
-    let subscription =
-        SUBSCRIPTION_MANAGER.subscribe(FromIterator::from_iter([SubscriptionFilter::Entities(
-            subgraph.clone(),
-            entity_type.to_owned(),
-        )]));
-
-    StoreEventStream::new(subscription)
+            .await;
+    });
 }
 
-async fn check_basic_revert(
-    store: Arc<DieselStore>,
-    expected: StoreEvent,
-    deployment: &DeploymentLocator,
-    entity_type: &EntityType,
-) {
+async fn check_basic_revert(store: Arc<DieselStore>, deployment: &DeploymentLocator) {
     let this_query = user_query()
         .filter(EntityFilter::Equal(
             "name".to_owned(),
@@ -977,7 +966,6 @@ async fn check_basic_revert(
         ))
         .desc("name");
 
-    let subscription = subscribe(&deployment.hash, entity_type);
     let state = deployment_state(store.as_ref(), &deployment.hash).await;
     assert_eq!(&deployment.hash, &state.id);
 
@@ -987,6 +975,7 @@ async fn check_basic_revert(
     let returned_entities = store
         .subgraph_store()
         .find(this_query.clone())
+        .await
         .expect("store.find operation failed");
 
     // There should be 1 user returned in results
@@ -1000,18 +989,17 @@ async fn check_basic_revert(
 
     let state = deployment_state(store.as_ref(), &deployment.hash).await;
     assert_eq!(&deployment.hash, &state.id);
-
-    check_events(subscription, vec![expected]).await
 }
 
 #[test]
 fn revert_block_basic_user() {
     run_test(|store, _, deployment| async move {
-        let expected = StoreEvent::new(vec![make_entity_change(&*USER_TYPE)]);
-
-        let count = get_entity_count(store.clone(), &deployment.hash);
-        check_basic_revert(store.clone(), expected, &deployment, &*USER_TYPE).await;
-        assert_eq!(count, get_entity_count(store.clone(), &deployment.hash));
+        let count = get_entity_count(store.clone(), &deployment.hash).await;
+        check_basic_revert(store.clone(), &deployment).await;
+        assert_eq!(
+            count,
+            get_entity_count(store.clone(), &deployment.hash).await
+        );
     })
 }
 
@@ -1038,17 +1026,19 @@ fn revert_block_with_delete() {
         .await
         .unwrap();
 
-        let subscription = subscribe(&deployment.hash, &*USER_TYPE);
-
         // Revert deletion
-        let count = get_entity_count(store.clone(), &deployment.hash);
+        let count = get_entity_count(store.clone(), &deployment.hash).await;
         revert_block(&store, &deployment, &TEST_BLOCK_2_PTR).await;
-        assert_eq!(count + 1, get_entity_count(store.clone(), &deployment.hash));
+        assert_eq!(
+            count + 1,
+            get_entity_count(store.clone(), &deployment.hash).await
+        );
 
         // Query after revert
         let returned_entities = store
             .subgraph_store()
             .find(this_query.clone())
+            .await
             .expect("store.find operation failed");
 
         // There should be 1 entity returned in results
@@ -1059,12 +1049,6 @@ fn revert_block_with_delete() {
         let test_value = Value::String("dinici@email.com".to_owned());
         assert!(returned_name.is_some());
         assert_eq!(&test_value, returned_name.unwrap());
-
-        // Check that the subscription notified us of the changes
-        let expected = StoreEvent::new(vec![make_entity_change(&*USER_TYPE)]);
-
-        // The last event is the one for the reversion
-        check_events(subscription, vec![expected]).await
     })
 }
 
@@ -1074,9 +1058,14 @@ fn revert_block_with_partial_update() {
         let entity_key = USER_TYPE.parse_key("1").unwrap();
         let schema = writable.input_schema();
 
-        let partial_entity = entity! { schema => id: "1", name: "Johnny Boy", email: Value::Null };
+        let partial_entity =
+            entity! { schema => id: "1", name: "Johnny Boy", email: Value::Null, vid: 5i64 };
 
-        let original_entity = writable.get(&entity_key).unwrap().expect("missing entity");
+        let original_entity = writable
+            .get(&entity_key)
+            .await
+            .unwrap()
+            .expect("missing entity");
 
         // Set test entity; as the entity already exists an update should be performed
         transact_entity_operations(
@@ -1085,29 +1074,29 @@ fn revert_block_with_partial_update() {
             TEST_BLOCK_3_PTR.clone(),
             vec![EntityOperation::Set {
                 key: entity_key.clone(),
-                data: partial_entity.clone(),
+                data: partial_entity,
             }],
         )
         .await
         .unwrap();
 
-        let subscription = subscribe(&deployment.hash, &*USER_TYPE);
-
         // Perform revert operation, reversing the partial update
-        let count = get_entity_count(store.clone(), &deployment.hash);
+        let count = get_entity_count(store.clone(), &deployment.hash).await;
         revert_block(&store, &deployment, &TEST_BLOCK_2_PTR).await;
-        assert_eq!(count, get_entity_count(store.clone(), &deployment.hash));
+        assert_eq!(
+            count,
+            get_entity_count(store.clone(), &deployment.hash).await
+        );
 
         // Obtain the reverted entity from the store
-        let reverted_entity = writable.get(&entity_key).unwrap().expect("missing entity");
+        let reverted_entity = writable
+            .get(&entity_key)
+            .await
+            .unwrap()
+            .expect("missing entity");
 
         // Verify that the entity has been returned to its original state
         assert_eq!(reverted_entity, original_entity);
-
-        // Check that the subscription notified us of the changes
-        let expected = StoreEvent::new(vec![make_entity_change(&*USER_TYPE)]);
-
-        check_events(subscription, vec![expected]).await
     })
 }
 
@@ -1143,19 +1132,18 @@ fn mock_data_source() -> graph_chain_ethereum::DataSource {
 fn mock_abi() -> MappingABI {
     MappingABI {
         name: "mock_abi".to_string(),
-        contract: Contract::load(
+        contract: serde_json::from_str(
             r#"[
-            {
-                "inputs": [
-                    {
-                        "name": "a",
-                        "type": "address"
-                    }
-                ],
-                "type": "constructor"
-            }
-        ]"#
-            .as_bytes(),
+                {
+                    "inputs": [
+                        {
+                            "name": "a",
+                            "type": "address"
+                        }
+                    ],
+                    "type": "constructor"
+                }
+            ]"#,
         )
         .unwrap(),
     }
@@ -1169,10 +1157,15 @@ fn revert_block_with_dynamic_data_source_operations() {
 
         // Create operations to add a user
         let user_key = USER_TYPE.parse_key("1").unwrap();
-        let partial_entity = entity! { schema => id: "1", name: "Johnny Boy", email: Value::Null };
+        let partial_entity =
+            entity! { schema => id: "1", name: "Johnny Boy", email: Value::Null, vid: 5i64 };
 
         // Get the original user for comparisons
-        let original_user = writable.get(&user_key).unwrap().expect("missing entity");
+        let original_user = writable
+            .get(&user_key)
+            .await
+            .unwrap()
+            .expect("missing entity");
 
         // Create operations to add a dynamic data source
         let mut data_source = mock_data_source();
@@ -1198,7 +1191,11 @@ fn revert_block_with_dynamic_data_source_operations() {
 
         // Verify that the user is no longer the original
         assert_ne!(
-            writable.get(&user_key).unwrap().expect("missing entity"),
+            writable
+                .get(&user_key)
+                .await
+                .unwrap()
+                .expect("missing entity"),
             original_user
         );
 
@@ -1213,14 +1210,16 @@ fn revert_block_with_dynamic_data_source_operations() {
             **loaded_dds[0].param.as_ref().unwrap()
         );
 
-        let subscription = subscribe(&deployment.hash, &*USER_TYPE);
-
         // Revert block that added the user and the dynamic data source
         revert_block(&store, &deployment, &TEST_BLOCK_2_PTR).await;
 
         // Verify that the user is the original again
         assert_eq!(
-            writable.get(&user_key).unwrap().expect("missing entity"),
+            writable
+                .get(&user_key)
+                .await
+                .unwrap()
+                .expect("missing entity"),
             original_user
         );
 
@@ -1230,224 +1229,6 @@ fn revert_block_with_dynamic_data_source_operations() {
             .await
             .unwrap();
         assert_eq!(0, loaded_dds.len());
-
-        // Verify that the right change events were emitted for the reversion
-        let expected_events = vec![StoreEvent {
-            tag: 3,
-            changes: HashSet::from_iter(
-                vec![EntityChange::Data {
-                    subgraph_id: DeploymentHash::new("testsubgraph").unwrap(),
-                    entity_type: USER_TYPE.to_string(),
-                }]
-                .into_iter(),
-            ),
-        }];
-        check_events(subscription, expected_events).await
-    })
-}
-
-#[test]
-fn entity_changes_are_fired_and_forwarded_to_subscriptions() {
-    run_test(|store, _, _| async move {
-        let subgraph_id = DeploymentHash::new("EntityChangeTestSubgraph").unwrap();
-        let schema = InputSchema::parse_latest(USER_GQL, subgraph_id.clone())
-            .expect("Failed to parse user schema");
-        let manifest = SubgraphManifest::<graph_chain_ethereum::Chain> {
-            id: subgraph_id.clone(),
-            spec_version: Version::new(1, 0, 0),
-            features: Default::default(),
-            description: None,
-            repository: None,
-            schema: schema.clone(),
-            data_sources: vec![],
-            graft: None,
-            templates: vec![],
-            chain: PhantomData,
-            indexer_hints: None,
-        };
-
-        let deployment =
-            DeploymentCreate::new(String::new(), &manifest, Some(TEST_BLOCK_0_PTR.clone()));
-        let name = SubgraphName::new("test/entity-changes-are-fired").unwrap();
-        let node_id = NodeId::new("test").unwrap();
-        let deployment = store
-            .subgraph_store()
-            .create_subgraph_deployment(
-                name,
-                &schema,
-                deployment,
-                node_id,
-                NETWORK_NAME.to_string(),
-                SubgraphVersionSwitchingMode::Instant,
-            )
-            .unwrap();
-
-        let subscription = subscribe(&subgraph_id, &*USER_TYPE);
-
-        // Add two entities to the store
-        let added_entities = vec![
-            (
-                "1".to_owned(),
-                entity! { schema => id: "1", name: "Johnny Boy" },
-            ),
-            ("2".to_owned(), entity! { schema => id: "2", name: "Tessa" }),
-        ];
-        transact_and_wait(
-            &store.subgraph_store(),
-            &deployment,
-            TEST_BLOCK_1_PTR.clone(),
-            added_entities
-                .iter()
-                .map(|(id, data)| EntityOperation::Set {
-                    key: USER_TYPE.parse_key(id.as_str()).unwrap(),
-                    data: data.clone(),
-                })
-                .collect(),
-        )
-        .await
-        .unwrap();
-
-        // Update an entity in the store
-        let updated_entity = entity! { schema => id: "1", name: "Johnny" };
-        let update_op = EntityOperation::Set {
-            key: USER_TYPE.parse_key("1").unwrap(),
-            data: updated_entity.clone(),
-        };
-
-        // Delete an entity in the store
-        let delete_op = EntityOperation::Remove {
-            key: USER_TYPE.parse_key("2").unwrap(),
-        };
-
-        // Commit update & delete ops
-        transact_and_wait(
-            &store.subgraph_store(),
-            &deployment,
-            TEST_BLOCK_2_PTR.clone(),
-            vec![update_op, delete_op],
-        )
-        .await
-        .unwrap();
-
-        // We're expecting two events to be written to the subscription stream
-        let expected = vec![
-            StoreEvent::new(vec![
-                EntityChange::Data {
-                    subgraph_id: subgraph_id.clone(),
-                    entity_type: USER_TYPE.to_string(),
-                },
-                EntityChange::Data {
-                    subgraph_id: subgraph_id.clone(),
-                    entity_type: USER_TYPE.to_string(),
-                },
-            ]),
-            StoreEvent::new(vec![
-                EntityChange::Data {
-                    subgraph_id: subgraph_id.clone(),
-                    entity_type: USER_TYPE.to_string(),
-                },
-                EntityChange::Data {
-                    subgraph_id: subgraph_id.clone(),
-                    entity_type: USER_TYPE.to_string(),
-                },
-            ]),
-        ];
-
-        check_events(subscription, expected).await
-    })
-}
-
-#[test]
-fn throttle_subscription_delivers() {
-    run_test(|store, _, deployment| async move {
-        let subscription = subscribe(&deployment.hash, &*USER_TYPE)
-            .throttle_while_syncing(
-                &LOGGER,
-                store
-                    .clone()
-                    .query_store(
-                        QueryTarget::Deployment(deployment.hash.clone(), Default::default()),
-                        true,
-                    )
-                    .await
-                    .unwrap(),
-                Duration::from_millis(500),
-            )
-            .await;
-
-        let user4 = create_test_entity(
-            "4",
-            &*USER_TYPE,
-            "Steve",
-            "nieve@email.com",
-            72_i32,
-            120.7,
-            false,
-            None,
-        );
-
-        transact_entity_operations(
-            &store.subgraph_store(),
-            &deployment,
-            TEST_BLOCK_3_PTR.clone(),
-            vec![user4],
-        )
-        .await
-        .unwrap();
-
-        let expected = StoreEvent::new(vec![make_entity_change(&*USER_TYPE)]);
-
-        check_events(subscription, vec![expected]).await
-    })
-}
-
-#[test]
-fn throttle_subscription_throttles() {
-    run_test(|store, _, deployment| async move {
-        // Throttle for a very long time (30s)
-        let subscription = subscribe(&deployment.hash, &*USER_TYPE)
-            .throttle_while_syncing(
-                &LOGGER,
-                store
-                    .clone()
-                    .query_store(
-                        QueryTarget::Deployment(deployment.hash.clone(), Default::default()),
-                        true,
-                    )
-                    .await
-                    .unwrap(),
-                Duration::from_secs(30),
-            )
-            .await;
-
-        let user4 = create_test_entity(
-            "4",
-            &*USER_TYPE,
-            "Steve",
-            "nieve@email.com",
-            72_i32,
-            120.7,
-            false,
-            None,
-        );
-
-        transact_entity_operations(
-            &store.subgraph_store(),
-            &deployment,
-            TEST_BLOCK_3_PTR.clone(),
-            vec![user4],
-        )
-        .await
-        .unwrap();
-
-        // Make sure we time out waiting for the subscription
-        let res = subscription
-            .take(1)
-            .collect()
-            .compat()
-            .timeout(Duration::from_millis(500))
-            .await;
-        assert!(res.is_err());
     })
 }
 
@@ -1457,6 +1238,7 @@ fn subgraph_schema_types_have_subgraph_id_directive() {
         let schema = store
             .subgraph_store()
             .api_schema(&deployment.hash, &Default::default())
+            .await
             .expect("test subgraph should have a schema");
         for typedef in schema
             .definitions()
@@ -1502,8 +1284,9 @@ fn handle_large_string_with_index() {
         name: &str,
         schema: &InputSchema,
         block: BlockNumber,
+        vid: i64,
     ) -> EntityModification {
-        let data = entity! { schema => id: id, name: name };
+        let data = entity! { schema => id: id, name: name, vid: vid };
 
         let key = USER_TYPE.parse_key(id).unwrap();
 
@@ -1533,20 +1316,22 @@ fn handle_large_string_with_index() {
         writable
             .transact_block_operations(
                 TEST_BLOCK_3_PTR.clone(),
-                BlockTime::for_test(&*TEST_BLOCK_3_PTR),
+                BlockTime::for_test(&TEST_BLOCK_3_PTR),
                 FirehoseCursor::None,
                 vec![
-                    make_insert_op(ONE, &long_text, &schema, block),
-                    make_insert_op(TWO, &other_text, &schema, block),
+                    make_insert_op(ONE, &long_text, &schema, block, 11),
+                    make_insert_op(TWO, &other_text, &schema, block, 12),
                 ],
                 &stopwatch_metrics,
                 Vec::new(),
                 Vec::new(),
                 Vec::new(),
                 false,
+                false,
             )
             .await
             .expect("Failed to insert large text");
+
         writable.flush().await.unwrap();
 
         let query = user_query()
@@ -1560,6 +1345,7 @@ fn handle_large_string_with_index() {
         let ids: Vec<_> = store
             .subgraph_store()
             .find(query)
+            .await
             .expect("Could not find entity")
             .iter()
             .map(|e| e.id())
@@ -1578,6 +1364,7 @@ fn handle_large_string_with_index() {
         let ids: Vec<_> = store
             .subgraph_store()
             .find(query)
+            .await
             .expect("Could not find entity")
             .iter()
             .map(|e| e.id())
@@ -1600,8 +1387,9 @@ fn handle_large_bytea_with_index() {
         name: &[u8],
         schema: &InputSchema,
         block: BlockNumber,
+        vid: i64,
     ) -> EntityModification {
-        let data = entity! { schema => id: id, bin_name: scalar::Bytes::from(name) };
+        let data = entity! { schema => id: id, bin_name: scalar::Bytes::from(name), vid: vid };
 
         let key = USER_TYPE.parse_key(id).unwrap();
 
@@ -1636,17 +1424,18 @@ fn handle_large_bytea_with_index() {
         writable
             .transact_block_operations(
                 TEST_BLOCK_3_PTR.clone(),
-                BlockTime::for_test(&*TEST_BLOCK_3_PTR),
+                BlockTime::for_test(&TEST_BLOCK_3_PTR),
                 FirehoseCursor::None,
                 vec![
-                    make_insert_op(ONE, &long_bytea, &schema, block),
-                    make_insert_op(TWO, &other_bytea, &schema, block),
+                    make_insert_op(ONE, &long_bytea, &schema, block, 10),
+                    make_insert_op(TWO, &other_bytea, &schema, block, 11),
                 ],
                 &stopwatch_metrics,
                 Vec::new(),
                 Vec::new(),
                 Vec::new(),
                 false,
+                false,
             )
             .await
             .expect("Failed to insert large text");
@@ -1663,6 +1452,7 @@ fn handle_large_bytea_with_index() {
         let ids: Vec<_> = store
             .subgraph_store()
             .find(query)
+            .await
             .expect("Could not find entity")
             .iter()
             .map(|e| e.id())
@@ -1681,6 +1471,7 @@ fn handle_large_bytea_with_index() {
         let ids: Vec<_> = store
             .subgraph_store()
             .find(query)
+            .await
             .expect("Could not find entity")
             .iter()
             .map(|e| e.id())
@@ -1778,12 +1569,13 @@ impl WindowQuery {
         WindowQuery(query, self.1).default_window()
     }
 
-    fn expect(&self, mut expected_ids: Vec<&str>, qid: &str) {
+    async fn expect(&self, mut expected_ids: Vec<&str>, qid: &str) {
         let query = self.0.clone();
         let store = &self.1;
         let unordered = matches!(query.order, EntityOrder::Unordered);
         let mut entity_ids = store
             .find(query)
+            .await
             .expect("store.find failed to execute query")
             .into_iter()
             .map(|entity| match entity.get("id") {
@@ -1807,8 +1599,10 @@ fn window() {
         id: &str,
         color: &str,
         age: i32,
+        vid: i64,
     ) -> EntityOperation {
-        let entity = entity! { TEST_SUBGRAPH_SCHEMA => id: id, age: age, favorite_color: color };
+        let entity =
+            entity! { TEST_SUBGRAPH_SCHEMA => id: id, age: age, favorite_color: color, vid: vid };
 
         EntityOperation::Set {
             key: entity_type.parse_key(id).unwrap(),
@@ -1816,25 +1610,25 @@ fn window() {
         }
     }
 
-    fn make_user(id: &str, color: &str, age: i32) -> EntityOperation {
-        make_color_and_age(&*USER_TYPE, id, color, age)
+    fn make_user(id: &str, color: &str, age: i32, vid: i64) -> EntityOperation {
+        make_color_and_age(&USER_TYPE, id, color, age, vid)
     }
 
-    fn make_person(id: &str, color: &str, age: i32) -> EntityOperation {
-        make_color_and_age(&*PERSON_TYPE, id, color, age)
+    fn make_person(id: &str, color: &str, age: i32, vid: i64) -> EntityOperation {
+        make_color_and_age(&PERSON_TYPE, id, color, age, vid)
     }
 
     let ops = vec![
-        make_user("4", "green", 34),
-        make_user("5", "green", 17),
-        make_user("6", "green", 41),
-        make_user("7", "red", 25),
-        make_user("8", "red", 45),
-        make_user("9", "yellow", 37),
-        make_user("10", "blue", 27),
-        make_user("11", "blue", 19),
-        make_person("p1", "green", 12),
-        make_person("p2", "red", 15),
+        make_user("4", "green", 34, 11),
+        make_user("5", "green", 17, 12),
+        make_user("6", "green", 41, 13),
+        make_user("7", "red", 25, 14),
+        make_user("8", "red", 45, 15),
+        make_user("9", "yellow", 37, 16),
+        make_user("10", "blue", 27, 17),
+        make_user("11", "blue", 19, 18),
+        make_person("p1", "green", 12, 19),
+        make_person("p2", "red", 15, 20),
     ];
 
     run_test(|store, _, deployment| async move {
@@ -1850,35 +1644,41 @@ fn window() {
         // Get the first 2 entries in each 'color group'
         WindowQuery::new(&store)
             .first(2)
-            .expect(vec!["10", "11", "4", "5", "2", "7", "9"], "q1");
+            .expect(vec!["10", "11", "4", "5", "2", "7", "9"], "q1")
+            .await;
 
         WindowQuery::new(&store)
             .first(1)
-            .expect(vec!["10", "4", "2", "9"], "q2");
+            .expect(vec!["10", "4", "2", "9"], "q2")
+            .await;
 
         WindowQuery::new(&store)
             .first(1)
             .skip(1)
-            .expect(vec!["11", "5", "7"], "q3");
+            .expect(vec!["11", "5", "7"], "q3")
+            .await;
 
         WindowQuery::new(&store)
             .first(1)
             .skip(1)
             .desc("id")
-            .expect(vec!["10", "5", "7"], "q4");
+            .expect(vec!["10", "5", "7"], "q4")
+            .await;
 
         WindowQuery::new(&store)
             .first(1)
             .skip(1)
             .desc("favorite_color")
-            .expect(vec!["10", "5", "7"], "q5");
+            .expect(vec!["10", "5", "7"], "q5")
+            .await;
 
         WindowQuery::new(&store)
             .first(1)
             .skip(1)
             .desc("favorite_color")
             .above(25)
-            .expect(vec!["4", "2"], "q6");
+            .expect(vec!["4", "2"], "q6")
+            .await;
 
         // Check queries for interfaces
         WindowQuery::new(&store)
@@ -1887,14 +1687,16 @@ fn window() {
             .desc("favorite_color")
             .above(12)
             .against_color_and_age()
-            .expect(vec!["10", "5", "8"], "q7");
+            .expect(vec!["10", "5", "8"], "q7")
+            .await;
 
         WindowQuery::new(&store)
             .first(1)
             .asc("age")
             .above(12)
             .against_color_and_age()
-            .expect(vec!["11", "5", "p2", "9"], "q8");
+            .expect(vec!["11", "5", "p2", "9"], "q8")
+            .await;
 
         WindowQuery::new(&store)
             .unordered()
@@ -1903,7 +1705,8 @@ fn window() {
             .expect(
                 vec!["10", "11", "2", "4", "5", "6", "7", "8", "9", "p2"],
                 "q9",
-            );
+            )
+            .await;
     });
 }
 
@@ -1919,6 +1722,7 @@ fn find_at_block() {
             let entities = store
                 .subgraph_store()
                 .find(query)
+                .await
                 .expect("store.find failed to execute query");
 
             assert_eq!(1, entities.len());
@@ -1954,9 +1758,11 @@ fn cleanup_cached_blocks() {
         let chain_store = store
             .block_store()
             .chain_store(NETWORK_NAME)
+            .await
             .expect("fake chain store");
         let cleaned = chain_store
             .cleanup_cached_blocks(10)
+            .await
             .expect("cleanup succeeds");
         assert_eq!(Some((2, 1)), cleaned);
     })
@@ -1986,9 +1792,10 @@ fn parse_timestamp() {
         let chain_store = store
             .block_store()
             .chain_store(NETWORK_NAME)
+            .await
             .expect("fake chain store");
 
-        let (_network, number, timestamp) = chain_store
+        let (_network, number, timestamp, _) = chain_store
             .block_number(&BLOCK_THREE_TIMESTAMP.block_hash())
             .await
             .expect("block_number to return correct number and timestamp")
@@ -2020,9 +1827,10 @@ fn parse_timestamp_firehose() {
         let chain_store = store
             .block_store()
             .chain_store(NETWORK_NAME)
+            .await
             .expect("fake chain store");
 
-        let (_network, number, timestamp) = chain_store
+        let (_network, number, timestamp, _) = chain_store
             .block_number(&BLOCK_THREE_TIMESTAMP_FIREHOSE.block_hash())
             .await
             .expect("block_number to return correct number and timestamp")
@@ -2054,15 +1862,16 @@ fn parse_null_timestamp() {
         let chain_store = store
             .block_store()
             .chain_store(NETWORK_NAME)
+            .await
             .expect("fake chain store");
 
-        let (_network, number, timestamp) = chain_store
+        let (_network, number, timestamp, _) = chain_store
             .block_number(&BLOCK_THREE_NO_TIMESTAMP.block_hash())
             .await
             .expect("block_number to return correct number and timestamp")
             .unwrap();
         assert_eq!(number, 3);
-        assert_eq!(true, timestamp.is_none());
+        assert!(timestamp.is_none());
     })
 }
 #[test]
@@ -2072,16 +1881,18 @@ fn reorg_tracking() {
         deployment: &DeploymentLocator,
         age: i32,
         block: &BlockPtr,
+        vid: i64,
     ) {
         let test_entity_1 = create_test_entity(
             "1",
-            &*USER_TYPE,
+            &USER_TYPE,
             "Johnton",
             "tonofjohn@email.com",
             age,
             184.4,
             false,
             None,
+            vid,
         );
         transact_and_wait(store, deployment, block.clone(), vec![test_entity_1])
             .await
@@ -2132,15 +1943,15 @@ fn reorg_tracking() {
         check_state!(store, 2, 2, 2);
 
         // Forward to block 3
-        update_john(&subgraph_store, &deployment, 70, &TEST_BLOCK_3_PTR).await;
+        update_john(&subgraph_store, &deployment, 70, &TEST_BLOCK_3_PTR, 5).await;
         check_state!(store, 2, 2, 3);
 
         // Forward to block 4
-        update_john(&subgraph_store, &deployment, 71, &TEST_BLOCK_4_PTR).await;
+        update_john(&subgraph_store, &deployment, 71, &TEST_BLOCK_4_PTR, 6).await;
         check_state!(store, 2, 2, 4);
 
         // Forward to block 5
-        update_john(&subgraph_store, &deployment, 72, &TEST_BLOCK_5_PTR).await;
+        update_john(&subgraph_store, &deployment, 72, &TEST_BLOCK_5_PTR, 7).await;
         check_state!(store, 2, 2, 5);
 
         // Revert all the way back to block 2
diff --git a/store/test-store/tests/postgres/subgraph.rs b/store/test-store/tests/postgres/subgraph.rs
index 135758770b5..5dd3c273160 100644
--- a/store/test-store/tests/postgres/subgraph.rs
+++ b/store/test-store/tests/postgres/subgraph.rs
@@ -3,27 +3,23 @@ use graph::{
         server::index_node::VersionInfo,
         store::{DeploymentId, DeploymentLocator, StatusStore},
     },
-    data::query::QueryTarget,
-    data::subgraph::{schema::SubgraphHealth, SubgraphFeature},
-    data::subgraph::{
-        schema::{DeploymentCreate, SubgraphError},
-        DeploymentFeatures,
+    data::{
+        query::QueryTarget,
+        subgraph::{
+            DeploymentFeatures, SubgraphFeature,
+            schema::{DeploymentCreate, SubgraphError, SubgraphHealth},
+        },
+    },
+    prelude::{
+        AssignmentChange, BlockPtr, CheapClone, DeploymentHash, NodeId, QueryStoreManager,
+        StoreError, StoreEvent, SubgraphManifest, SubgraphName, SubgraphStore as _,
+        SubgraphVersionSwitchingMode, UnfailOutcome,
     },
-    prelude::BlockPtr,
-    prelude::EntityChange,
-    prelude::EntityChangeOperation,
-    prelude::QueryStoreManager,
-    prelude::SubgraphManifest,
-    prelude::SubgraphName,
-    prelude::SubgraphVersionSwitchingMode,
-    prelude::UnfailOutcome,
-    prelude::{futures03, StoreEvent},
-    prelude::{CheapClone, DeploymentHash, NodeId, SubgraphStore as _},
     schema::InputSchema,
     semver::Version,
 };
-use graph_store_postgres::layout_for_tests::Connection as Primary;
 use graph_store_postgres::SubgraphStore;
+use graph_store_postgres::layout_for_tests::Connection as Primary;
 use std::{collections::HashSet, marker::PhantomData, sync::Arc};
 use test_store::*;
 
@@ -34,30 +30,48 @@ const SUBGRAPH_GQL: &str = "
     }
 ";
 
-fn assigned(deployment: &DeploymentLocator) -> EntityChange {
-    EntityChange::Assignment {
-        deployment: deployment.clone(),
-        operation: EntityChangeOperation::Set,
+const SUBGRAPH_FEATURES_GQL: &str = "
+    type User @entity {
+        id: ID!,
+        name: String
     }
-}
 
-fn unassigned(deployment: &DeploymentLocator) -> EntityChange {
-    EntityChange::Assignment {
-        deployment: deployment.clone(),
-        operation: EntityChangeOperation::Removed,
+    type User2 @entity(immutable: true) {
+        id: Bytes!,
+        name: String
     }
+
+    type Data @entity(timeseries: true) {
+        id: Int8!
+        timestamp: Timestamp!
+        price: BigDecimal!
+    }
+
+    type Stats @aggregation(intervals: [\"hour\", \"day\"], source: \"Data\") {
+        id: Int8!
+        timestamp: Timestamp!
+        sum: BigDecimal! @aggregate(fn: \"sum\", arg: \"price\")
+    }
+";
+
+fn assigned(deployment: &DeploymentLocator) -> AssignmentChange {
+    AssignmentChange::set(deployment.clone())
+}
+
+fn unassigned(deployment: &DeploymentLocator) -> AssignmentChange {
+    AssignmentChange::removed(deployment.clone())
 }
 
-fn get_version_info(store: &Store, subgraph_name: &str) -> VersionInfo {
-    let primary = primary_connection();
-    let (current, _) = primary.versions_for_subgraph(subgraph_name).unwrap();
+async fn get_version_info(store: &Store, subgraph_name: &str) -> VersionInfo {
+    let mut primary = primary_connection().await;
+    let (current, _) = primary.versions_for_subgraph(subgraph_name).await.unwrap();
     let current = current.unwrap();
-    store.version_info(&current).unwrap()
+    store.version_info(&current).await.unwrap()
 }
 
-fn get_subgraph_features(id: String) -> Option<DeploymentFeatures> {
-    let primary = primary_connection();
-    primary.get_subgraph_features(id).unwrap()
+async fn get_subgraph_features(id: String) -> Option<DeploymentFeatures> {
+    let mut primary = primary_connection().await;
+    primary.get_subgraph_features(id).await.unwrap()
 }
 
 async fn latest_block(store: &Store, deployment_id: DeploymentId) -> BlockPtr {
@@ -74,13 +88,17 @@ async fn latest_block(store: &Store, deployment_id: DeploymentId) -> BlockPtr {
 fn reassign_subgraph() {
     async fn setup() -> DeploymentLocator {
         let id = DeploymentHash::new("reassignSubgraph").unwrap();
-        remove_subgraphs();
+        remove_subgraphs().await;
         create_test_subgraph(&id, SUBGRAPH_GQL).await
     }
 
-    fn find_assignment(store: &SubgraphStore, deployment: &DeploymentLocator) -> Option<String> {
+    async fn find_assignment(
+        store: &SubgraphStore,
+        deployment: &DeploymentLocator,
+    ) -> Option<String> {
         store
             .assigned_node(deployment)
+            .await
             .unwrap()
             .map(|node| node.to_string())
     }
@@ -90,7 +108,7 @@ fn reassign_subgraph() {
         let store = store.subgraph_store();
 
         // Check our setup
-        let node = find_assignment(store.as_ref(), &id);
+        let node = find_assignment(store.as_ref(), &id).await;
         let placement = place("test").expect("the test config places deployments");
         if let Some((_, nodes)) = placement {
             // If the test config does not have deployment rules, we can't check
@@ -107,8 +125,9 @@ fn reassign_subgraph() {
             let node = NodeId::new("left").unwrap();
             let expected = vec![StoreEvent::new(vec![assigned(&id)])];
 
-            let (_, events) = tap_store_events(|| store.reassign_subgraph(&id, &node).unwrap());
-            let node = find_assignment(store.as_ref(), &id);
+            let (_, events) =
+                tap_store_events(async || store.reassign_subgraph(&id, &node).await.unwrap()).await;
+            let node = find_assignment(store.as_ref(), &id).await;
             assert_eq!(Some("left"), node.as_deref());
             assert_eq!(expected, events);
         }
@@ -120,32 +139,42 @@ fn create_subgraph() {
     const SUBGRAPH_NAME: &str = "create/subgraph";
 
     // Return the versions (not deployments) for a subgraph
-    fn subgraph_versions(primary: &Primary) -> (Option<String>, Option<String>) {
-        primary.versions_for_subgraph(SUBGRAPH_NAME).unwrap()
+    async fn subgraph_versions(primary: &mut Primary) -> (Option<String>, Option<String>) {
+        primary.versions_for_subgraph(SUBGRAPH_NAME).await.unwrap()
+    }
+
+    async fn deployment_for_version(
+        primary: &mut Primary,
+        name: Option<String>,
+    ) -> Result<Option<String>, StoreError> {
+        match name {
+            None => Ok(None),
+            Some(name) => primary.deployment_for_version(&name).await,
+        }
     }
 
     /// Return the deployment for the current and the pending version of the
     /// subgraph with the given `entity_id`
-    fn subgraph_deployments(primary: &Primary) -> (Option<String>, Option<String>) {
-        let (current, pending) = subgraph_versions(primary);
+    async fn subgraph_deployments(primary: &mut Primary) -> (Option<String>, Option<String>) {
+        let (current, pending) = subgraph_versions(primary).await;
         (
-            current.and_then(|v| primary.deployment_for_version(&v).unwrap()),
-            pending.and_then(|v| primary.deployment_for_version(&v).unwrap()),
+            deployment_for_version(primary, current).await.unwrap(),
+            deployment_for_version(primary, pending).await.unwrap(),
         )
     }
 
-    fn deploy(
+    async fn deploy(
         store: &SubgraphStore,
         id: &str,
         mode: SubgraphVersionSwitchingMode,
-    ) -> (DeploymentLocator, HashSet<EntityChange>) {
+    ) -> (DeploymentLocator, HashSet<AssignmentChange>) {
         let name = SubgraphName::new(SUBGRAPH_NAME.to_string()).unwrap();
         let id = DeploymentHash::new(id.to_string()).unwrap();
         let schema = InputSchema::parse_latest(SUBGRAPH_GQL, id.clone()).unwrap();
 
         let manifest = SubgraphManifest::<graph_chain_ethereum::Chain> {
             id,
-            spec_version: Version::new(1, 0, 0),
+            spec_version: Version::new(1, 3, 0),
             features: Default::default(),
             description: None,
             repository: None,
@@ -159,7 +188,7 @@ fn create_subgraph() {
         let deployment = DeploymentCreate::new(String::new(), &manifest, None);
         let node_id = NodeId::new("left").unwrap();
 
-        let (deployment, events) = tap_store_events(|| {
+        let (deployment, events) = tap_store_events(async || {
             store
                 .create_subgraph_deployment(
                     name,
@@ -169,8 +198,10 @@ fn create_subgraph() {
                     NETWORK_NAME.to_string(),
                     mode,
                 )
+                .await
                 .unwrap()
-        });
+        })
+        .await;
         let events = events
             .into_iter()
             .flat_map(|event| event.changes.into_iter())
@@ -178,26 +209,30 @@ fn create_subgraph() {
         (deployment, events)
     }
 
-    fn deploy_event(deployment: &DeploymentLocator) -> HashSet<EntityChange> {
+    fn deploy_event(deployment: &DeploymentLocator) -> HashSet<AssignmentChange> {
         let mut changes = HashSet::new();
         changes.insert(assigned(deployment));
         changes
     }
 
-    fn deployment_synced(store: &Arc<SubgraphStore>, deployment: &DeploymentLocator) {
-        futures03::executor::block_on(store.cheap_clone().writable(
-            LOGGER.clone(),
-            deployment.id,
-            Arc::new(Vec::new()),
-        ))
-        .expect("can get writable")
-        .deployment_synced()
-        .unwrap();
+    async fn deployment_synced(
+        store: &Arc<SubgraphStore>,
+        deployment: &DeploymentLocator,
+        block_ptr: BlockPtr,
+    ) {
+        store
+            .cheap_clone()
+            .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
+            .await
+            .expect("can get writable")
+            .deployment_synced(block_ptr)
+            .await
+            .unwrap();
     }
 
     // Test VersionSwitchingMode::Instant
     run_test_sequentially(|store| async move {
-        remove_subgraphs();
+        remove_subgraphs().await;
         let store = store.subgraph_store();
 
         const MODE: SubgraphVersionSwitchingMode = SubgraphVersionSwitchingMode::Instant;
@@ -205,51 +240,52 @@ fn create_subgraph() {
         const ID2: &str = "instant2";
         const ID3: &str = "instant3";
 
-        let primary = primary_connection();
+        let mut primary = primary_connection().await;
 
         let name = SubgraphName::new(SUBGRAPH_NAME.to_string()).unwrap();
-        let (_, events) = tap_store_events(|| store.create_subgraph(name.clone()).unwrap());
-        let (current, pending) = subgraph_deployments(&primary);
+        let (_, events) =
+            tap_store_events(async || store.create_subgraph(name.clone()).await.unwrap()).await;
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert!(events.is_empty());
         assert!(current.is_none());
         assert!(pending.is_none());
 
         // Deploy
-        let (deployment1, events) = deploy(store.as_ref(), ID1, MODE);
+        let (deployment1, events) = deploy(store.as_ref(), ID1, MODE).await;
         let expected = deploy_event(&deployment1);
         assert_eq!(expected, events);
 
-        let (current, pending) = subgraph_deployments(&primary);
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert_eq!(Some(ID1), current.as_deref());
         assert!(pending.is_none());
 
         // Deploying again overwrites current
-        let (deployment2, events) = deploy(store.as_ref(), ID2, MODE);
+        let (deployment2, events) = deploy(store.as_ref(), ID2, MODE).await;
         let mut expected = deploy_event(&deployment2);
         expected.insert(unassigned(&deployment1));
         assert_eq!(expected, events);
 
-        let (current, pending) = subgraph_deployments(&primary);
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert_eq!(Some(ID2), current.as_deref());
         assert!(pending.is_none());
 
         // Sync deployment
-        deployment_synced(&store, &deployment2);
+        deployment_synced(&store, &deployment2, GENESIS_PTR.clone()).await;
 
         // Deploying again still overwrites current
-        let (deployment3, events) = deploy(store.as_ref(), ID3, MODE);
+        let (deployment3, events) = deploy(store.as_ref(), ID3, MODE).await;
         let mut expected = deploy_event(&deployment3);
         expected.insert(unassigned(&deployment2));
         assert_eq!(expected, events);
 
-        let (current, pending) = subgraph_deployments(&primary);
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert_eq!(Some(ID3), current.as_deref());
         assert!(pending.is_none());
     });
 
     // Test VersionSwitchingMode::Synced
     run_test_sequentially(|store| async move {
-        remove_subgraphs();
+        remove_subgraphs().await;
         let store = store.subgraph_store();
 
         const MODE: SubgraphVersionSwitchingMode = SubgraphVersionSwitchingMode::Synced;
@@ -257,60 +293,61 @@ fn create_subgraph() {
         const ID2: &str = "synced2";
         const ID3: &str = "synced3";
 
-        let primary = primary_connection();
+        let mut primary = primary_connection().await;
 
         let name = SubgraphName::new(SUBGRAPH_NAME.to_string()).unwrap();
-        let (_, events) = tap_store_events(|| store.create_subgraph(name.clone()).unwrap());
-        let (current, pending) = subgraph_deployments(&primary);
+        let (_, events) =
+            tap_store_events(async || store.create_subgraph(name.clone()).await.unwrap()).await;
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert!(events.is_empty());
         assert!(current.is_none());
         assert!(pending.is_none());
 
         // Deploy
-        let (deployment1, events) = deploy(store.as_ref(), ID1, MODE);
+        let (deployment1, events) = deploy(store.as_ref(), ID1, MODE).await;
         let expected = deploy_event(&deployment1);
         assert_eq!(expected, events);
 
-        let versions = subgraph_versions(&primary);
-        let (current, pending) = subgraph_deployments(&primary);
+        let versions = subgraph_versions(&mut primary).await;
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert_eq!(Some(ID1), current.as_deref());
         assert!(pending.is_none());
 
         // Deploying the same thing again does nothing
-        let (deployment1_again, events) = deploy(store.as_ref(), ID1, MODE);
+        let (deployment1_again, events) = deploy(store.as_ref(), ID1, MODE).await;
         assert!(events.is_empty());
         assert_eq!(&deployment1, &deployment1_again);
-        let versions2 = subgraph_versions(&primary);
+        let versions2 = subgraph_versions(&mut primary).await;
         assert_eq!(versions, versions2);
 
         // Deploy again, current is not synced, so it gets replaced
-        let (deployment2, events) = deploy(store.as_ref(), ID2, MODE);
+        let (deployment2, events) = deploy(store.as_ref(), ID2, MODE).await;
         let mut expected = deploy_event(&deployment2);
         expected.insert(unassigned(&deployment1));
         assert_eq!(expected, events);
 
-        let (current, pending) = subgraph_deployments(&primary);
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert_eq!(Some(ID2), current.as_deref());
         assert!(pending.is_none());
 
         // Deploy when current is synced leaves current alone and adds pending
-        deployment_synced(&store, &deployment2);
-        let (deployment3, events) = deploy(store.as_ref(), ID3, MODE);
+        deployment_synced(&store, &deployment2, GENESIS_PTR.clone()).await;
+        let (deployment3, events) = deploy(store.as_ref(), ID3, MODE).await;
         let expected = deploy_event(&deployment3);
         assert_eq!(expected, events);
 
-        let versions = subgraph_versions(&primary);
-        let (current, pending) = subgraph_deployments(&primary);
+        let versions = subgraph_versions(&mut primary).await;
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert_eq!(Some(ID2), current.as_deref());
         assert_eq!(Some(ID3), pending.as_deref());
 
         // Deploying that same thing again changes nothing
-        let (deployment3_again, events) = deploy(store.as_ref(), ID3, MODE);
+        let (deployment3_again, events) = deploy(store.as_ref(), ID3, MODE).await;
         assert!(events.is_empty());
         assert_eq!(&deployment3, &deployment3_again);
-        let versions2 = subgraph_versions(&primary);
+        let versions2 = subgraph_versions(&mut primary).await;
         assert_eq!(versions, versions2);
-        let (current, pending) = subgraph_deployments(&primary);
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert_eq!(Some(ID2), current.as_deref());
         assert_eq!(Some(ID3), pending.as_deref());
 
@@ -320,22 +357,22 @@ fn create_subgraph() {
         let mut expected = HashSet::new();
         expected.insert(unassigned(&deployment3));
 
-        let (deployment2_again, events) = deploy(store.as_ref(), ID2, MODE);
+        let (deployment2_again, events) = deploy(store.as_ref(), ID2, MODE).await;
         assert_eq!(&deployment2, &deployment2_again);
         assert_eq!(expected, events);
 
-        let (current, pending) = subgraph_deployments(&primary);
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert_eq!(Some(ID2), current.as_deref());
         assert_eq!(None, pending.as_deref());
 
         // Mark `ID3` as synced and deploy that again
-        deployment_synced(&store, &deployment3);
+        deployment_synced(&store, &deployment3, GENESIS_PTR.clone()).await;
         let expected = HashSet::from([unassigned(&deployment2), assigned(&deployment3)]);
-        let (deployment3_again, events) = deploy(store.as_ref(), ID3, MODE);
+        let (deployment3_again, events) = deploy(store.as_ref(), ID3, MODE).await;
         assert_eq!(&deployment3, &deployment3_again);
         assert_eq!(expected, events);
 
-        let (current, pending) = subgraph_deployments(&primary);
+        let (current, pending) = subgraph_deployments(&mut primary).await;
         assert_eq!(Some(ID3), current.as_deref());
         assert_eq!(None, pending.as_deref());
     })
@@ -348,7 +385,7 @@ fn status() {
 
     async fn setup() -> DeploymentLocator {
         let id = DeploymentHash::new(NAME).unwrap();
-        remove_subgraphs();
+        remove_subgraphs().await;
         let deployment = create_test_subgraph(&id, SUBGRAPH_GQL).await;
         create_test_subgraph(&DeploymentHash::new(OTHER).unwrap(), SUBGRAPH_GQL).await;
         deployment
@@ -364,13 +401,17 @@ fn status() {
                 "notASubgraph".to_string(),
                 "not-even-a-valid-id".to_string(),
             ]))
+            .await
             .unwrap();
         assert_eq!(1, infos.len());
         let info = infos.first().unwrap();
         assert_eq!(NAME, info.subgraph);
         assert!(!info.synced);
 
-        let infos = store.status(status::Filter::Deployments(vec![])).unwrap();
+        let infos = store
+            .status(status::Filter::Deployments(vec![]))
+            .await
+            .unwrap();
         assert_eq!(2, infos.len());
         let info = infos
             .into_iter()
@@ -381,6 +422,7 @@ fn status() {
 
         let infos = store
             .status(status::Filter::SubgraphName(NAME.to_string()))
+            .await
             .unwrap();
         assert_eq!(1, infos.len());
         let info = infos.first().unwrap();
@@ -389,6 +431,7 @@ fn status() {
 
         let infos = store
             .status(status::Filter::SubgraphVersion(NAME.to_string(), true))
+            .await
             .unwrap();
         assert_eq!(1, infos.len());
         let info = infos.first().unwrap();
@@ -397,16 +440,19 @@ fn status() {
 
         let infos = store
             .status(status::Filter::SubgraphVersion(NAME.to_string(), false))
+            .await
             .unwrap();
         assert!(infos.is_empty());
 
         let infos = store
             .status(status::Filter::SubgraphName("invalid name".to_string()))
+            .await
             .unwrap();
         assert_eq!(0, infos.len());
 
         let infos = store
             .status(status::Filter::SubgraphName("notASubgraph".to_string()))
+            .await
             .unwrap();
         assert_eq!(0, infos.len());
 
@@ -415,6 +461,7 @@ fn status() {
                 "notASubgraph".to_string(),
                 true,
             ))
+            .await
             .unwrap();
         assert_eq!(0, infos.len());
 
@@ -436,9 +483,10 @@ fn status() {
             .await
             .unwrap();
         let infos = store
-            .status(status::Filter::Deployments(vec![deployment
-                .hash
-                .to_string()]))
+            .status(status::Filter::Deployments(vec![
+                deployment.hash.to_string(),
+            ]))
+            .await
             .unwrap();
         assert_eq!(1, infos.len());
         let info = infos.first().unwrap();
@@ -457,7 +505,7 @@ fn version_info() {
 
     async fn setup() -> DeploymentLocator {
         let id = DeploymentHash::new(NAME).unwrap();
-        remove_subgraphs();
+        remove_subgraphs().await;
         block_store::set_chain(vec![], NETWORK_NAME).await;
         create_test_subgraph(&id, SUBGRAPH_GQL).await
     }
@@ -473,10 +521,10 @@ fn version_info() {
         .await
         .unwrap();
 
-        let vi = get_version_info(&store, NAME);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.synced);
-        assert_eq!(false, vi.failed);
+        assert!(!vi.synced);
+        assert!(!vi.failed);
         assert_eq!(
             Some("manifest for versionInfoSubgraph"),
             vi.description.as_deref()
@@ -499,9 +547,9 @@ fn subgraph_features() {
         const NAME: &str = "subgraph_features";
         let id = DeploymentHash::new(NAME).unwrap();
 
-        remove_subgraphs();
+        remove_subgraphs().await;
         block_store::set_chain(vec![], NETWORK_NAME).await;
-        create_test_subgraph_with_features(&id, SUBGRAPH_GQL).await;
+        create_test_subgraph_with_features(&id, SUBGRAPH_FEATURES_GQL).await;
 
         let DeploymentFeatures {
             id: subgraph_id,
@@ -511,16 +559,20 @@ fn subgraph_features() {
             data_source_kinds,
             network,
             handler_kinds,
-        } = get_subgraph_features(id.to_string()).unwrap();
+            has_declared_calls,
+            has_bytes_as_ids,
+            immutable_entities,
+            has_aggregations,
+        } = get_subgraph_features(id.to_string()).await.unwrap();
 
         assert_eq!(NAME, subgraph_id.as_str());
-        assert_eq!("1.0.0", spec_version);
+        assert_eq!("1.3.0", spec_version);
         assert_eq!("1.0.0", api_version.unwrap());
         assert_eq!(NETWORK_NAME, network);
         assert_eq!(
             vec![
                 SubgraphFeature::NonFatalErrors.to_string(),
-                SubgraphFeature::FullTextSearch.to_string()
+                SubgraphFeature::FullTextSearch.to_string(),
             ],
             features
         );
@@ -528,9 +580,16 @@ fn subgraph_features() {
         assert_eq!(handler_kinds.len(), 2);
         assert!(handler_kinds.contains(&"mock_handler_1".to_string()));
         assert!(handler_kinds.contains(&"mock_handler_2".to_string()));
+        assert!(has_declared_calls);
+        assert!(has_bytes_as_ids);
+        assert!(has_aggregations);
+        assert_eq!(
+            immutable_entities,
+            vec!["User2".to_string(), "Data".to_string()]
+        );
 
-        test_store::remove_subgraph(&id);
-        let features = get_subgraph_features(id.to_string());
+        test_store::remove_subgraph(&id).await;
+        let features = get_subgraph_features(id.to_string()).await;
         // Subgraph was removed, so we expect the entry to be removed from `subgraph_features` table
         assert!(features.is_none());
     })
@@ -543,9 +602,9 @@ fn subgraph_error() {
         let deployment =
             test_store::create_test_subgraph(&subgraph_id, "type Foo @entity { id: ID! }").await;
 
-        let count = || -> usize {
+        let count = async || -> usize {
             let store = store.subgraph_store();
-            store.error_count(&subgraph_id).unwrap()
+            store.error_count(&subgraph_id).await.unwrap()
         };
 
         let error = SubgraphError {
@@ -556,12 +615,12 @@ fn subgraph_error() {
             deterministic: false,
         };
 
-        assert!(count() == 0);
+        assert!(count().await == 0);
 
         transact_errors(&store, &deployment, BLOCKS[1].clone(), vec![error], false)
             .await
             .unwrap();
-        assert!(count() == 1);
+        assert!(count().await == 1);
 
         let error = SubgraphError {
             subgraph_id: subgraph_id.clone(),
@@ -575,7 +634,7 @@ fn subgraph_error() {
         transact_errors(&store, &deployment, BLOCKS[2].clone(), vec![error], false)
             .await
             .unwrap();
-        assert!(count() == 1);
+        assert!(count().await == 1);
 
         let error2 = SubgraphError {
             subgraph_id: subgraph_id.clone(),
@@ -588,9 +647,9 @@ fn subgraph_error() {
         transact_errors(&store, &deployment, BLOCKS[3].clone(), vec![error2], false)
             .await
             .unwrap();
-        assert!(count() == 2);
+        assert!(count().await == 2);
 
-        test_store::remove_subgraph(&subgraph_id);
+        test_store::remove_subgraph(&subgraph_id).await;
     })
 }
 
@@ -602,9 +661,9 @@ fn subgraph_non_fatal_error() {
         let deployment =
             test_store::create_test_subgraph(&subgraph_id, "type Foo @entity { id: ID! }").await;
 
-        let count = || -> usize {
+        let count = async || -> usize {
             let store = store.subgraph_store();
-            let count = store.error_count(&subgraph_id).unwrap();
+            let count = store.error_count(&subgraph_id).await.unwrap();
             println!("count: {}", count);
             count
         };
@@ -617,14 +676,14 @@ fn subgraph_non_fatal_error() {
             deterministic: true,
         };
 
-        assert!(count() == 0);
+        assert!(count().await == 0);
 
         transact_errors(&store, &deployment, BLOCKS[1].clone(), vec![error], true)
             .await
             .unwrap();
-        assert!(count() == 1);
+        assert!(count().await == 1);
 
-        let info = subgraph_store.status_for_id(deployment.id);
+        let info = subgraph_store.status_for_id(deployment.id).await;
 
         assert!(info.non_fatal_errors.len() == 1);
         assert!(info.health == SubgraphHealth::Unhealthy);
@@ -641,14 +700,14 @@ fn subgraph_non_fatal_error() {
         transact_errors(&store, &deployment, BLOCKS[2].clone(), vec![error2], false)
             .await
             .unwrap();
-        assert!(count() == 2);
+        assert!(count().await == 2);
 
-        let info = subgraph_store.status_for_id(deployment.id);
+        let info = subgraph_store.status_for_id(deployment.id).await;
 
         assert!(info.non_fatal_errors.len() == 1);
         assert!(info.health == SubgraphHealth::Unhealthy);
 
-        test_store::remove_subgraph(&subgraph_id);
+        test_store::remove_subgraph(&subgraph_id).await;
     })
 }
 
@@ -656,17 +715,17 @@ fn subgraph_non_fatal_error() {
 fn fatal_vs_non_fatal() {
     async fn setup() -> DeploymentLocator {
         let id = DeploymentHash::new("failUnfail").unwrap();
-        remove_subgraphs();
+        remove_subgraphs().await;
         create_test_subgraph(&id, SUBGRAPH_GQL).await
     }
 
     run_test_sequentially(|store| async move {
         let deployment = setup().await;
         let query_store = store
-            .query_store(
-                QueryTarget::Deployment(deployment.hash.clone(), Default::default()),
-                false,
-            )
+            .query_store(QueryTarget::Deployment(
+                deployment.hash.clone(),
+                Default::default(),
+            ))
             .await
             .unwrap();
 
@@ -697,19 +756,16 @@ fn fatal_vs_non_fatal() {
             .await
             .unwrap();
 
-        assert!(!query_store
-            .has_deterministic_errors(latest_block(&store, deployment.id).await.number)
-            .await
-            .unwrap());
+        let state = query_store.deployment_state().await.unwrap();
+
+        assert!(!state.has_deterministic_errors(&latest_block(&store, deployment.id).await));
 
         transact_errors(&store, &deployment, BLOCKS[1].clone(), vec![error()], false)
             .await
             .unwrap();
 
-        assert!(query_store
-            .has_deterministic_errors(latest_block(&store, deployment.id).await.number)
-            .await
-            .unwrap());
+        let state = query_store.deployment_state().await.unwrap();
+        assert!(state.has_deterministic_errors(&latest_block(&store, deployment.id).await));
     })
 }
 
@@ -719,7 +775,7 @@ fn fail_unfail_deterministic_error() {
 
     async fn setup() -> DeploymentLocator {
         let id = DeploymentHash::new(NAME).unwrap();
-        remove_subgraphs();
+        remove_subgraphs().await;
         create_test_subgraph(&id, SUBGRAPH_GQL).await
     }
 
@@ -727,10 +783,10 @@ fn fail_unfail_deterministic_error() {
         let deployment = setup().await;
 
         let query_store = store
-            .query_store(
-                QueryTarget::Deployment(deployment.hash.clone(), Default::default()),
-                false,
-            )
+            .query_store(QueryTarget::Deployment(
+                deployment.hash.clone(),
+                Default::default(),
+            ))
             .await
             .unwrap();
 
@@ -745,13 +801,11 @@ fn fail_unfail_deterministic_error() {
         .unwrap();
 
         // We don't have any errors and the subgraph is healthy.
-        assert!(!query_store
-            .has_deterministic_errors(latest_block(&store, deployment.id).await.number)
-            .await
-            .unwrap());
-        let vi = get_version_info(&store, NAME);
+        let state = query_store.deployment_state().await.unwrap();
+        assert!(!state.has_deterministic_errors(&latest_block(&store, deployment.id).await));
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(0), vi.latest_ethereum_block_number);
 
         // Process the second block.
@@ -765,13 +819,11 @@ fn fail_unfail_deterministic_error() {
         .unwrap();
 
         // Still no fatal errors.
-        assert!(!query_store
-            .has_deterministic_errors(latest_block(&store, deployment.id).await.number)
-            .await
-            .unwrap());
-        let vi = get_version_info(&store, NAME);
+        let state = query_store.deployment_state().await.unwrap();
+        assert!(!state.has_deterministic_errors(&latest_block(&store, deployment.id).await));
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         let error = SubgraphError {
@@ -792,13 +844,11 @@ fn fail_unfail_deterministic_error() {
         writable.fail_subgraph(error).await.unwrap();
 
         // Now we have a fatal error because the subgraph failed.
-        assert!(query_store
-            .has_deterministic_errors(latest_block(&store, deployment.id).await.number)
-            .await
-            .unwrap());
-        let vi = get_version_info(&store, NAME);
+        let state = query_store.deployment_state().await.unwrap();
+        assert!(state.has_deterministic_errors(&latest_block(&store, deployment.id).await));
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(true, vi.failed);
+        assert!(vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         // Unfail the subgraph.
@@ -809,16 +859,14 @@ fn fail_unfail_deterministic_error() {
 
         // We don't have fatal errors anymore and the block got reverted.
         assert_eq!(outcome, UnfailOutcome::Unfailed);
-        assert!(!query_store
-            .has_deterministic_errors(latest_block(&store, deployment.id).await.number)
-            .await
-            .unwrap());
-        let vi = get_version_info(&store, NAME);
+        let state = query_store.deployment_state().await.unwrap();
+        assert!(!state.has_deterministic_errors(&latest_block(&store, deployment.id).await));
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(0), vi.latest_ethereum_block_number);
 
-        test_store::remove_subgraphs();
+        test_store::remove_subgraphs().await;
     })
 }
 
@@ -828,16 +876,16 @@ fn fail_unfail_deterministic_error_noop() {
 
     async fn setup() -> DeploymentLocator {
         let id = DeploymentHash::new(NAME).unwrap();
-        remove_subgraphs();
+        remove_subgraphs().await;
         create_test_subgraph(&id, SUBGRAPH_GQL).await
     }
 
     run_test_sequentially(|store| async move {
         let deployment = setup().await;
 
-        let count = || -> usize {
+        let count = async || -> usize {
             let store = store.subgraph_store();
-            store.error_count(&deployment.hash).unwrap()
+            store.error_count(&deployment.hash).await.unwrap()
         };
 
         // Process the first block.
@@ -851,10 +899,10 @@ fn fail_unfail_deterministic_error_noop() {
         .unwrap();
 
         // We don't have any errors and the subgraph is healthy.
-        assert_eq!(count(), 0);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 0);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(0), vi.latest_ethereum_block_number);
 
         // Process the second block.
@@ -868,10 +916,10 @@ fn fail_unfail_deterministic_error_noop() {
         .unwrap();
 
         // Still no fatal errors.
-        assert_eq!(count(), 0);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 0);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         let writable = store
@@ -888,10 +936,10 @@ fn fail_unfail_deterministic_error_noop() {
 
         // Nothing to unfail, state continues the same.
         assert_eq!(outcome, UnfailOutcome::Noop);
-        assert_eq!(count(), 0);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 0);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         let error = SubgraphError {
@@ -906,10 +954,10 @@ fn fail_unfail_deterministic_error_noop() {
         writable.fail_subgraph(error).await.unwrap();
 
         // Now we have a fatal error because the subgraph failed.
-        assert_eq!(count(), 1);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 1);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(true, vi.failed);
+        assert!(vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         // Running unfail_deterministic_error against a NON-deterministic error will do nothing.
@@ -921,10 +969,10 @@ fn fail_unfail_deterministic_error_noop() {
         // State continues the same, nothing happened.
         // Neither the block got reverted or error deleted.
         assert_eq!(outcome, UnfailOutcome::Noop);
-        assert_eq!(count(), 1);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 1);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(true, vi.failed);
+        assert!(vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         let error = SubgraphError {
@@ -948,13 +996,13 @@ fn fail_unfail_deterministic_error_noop() {
         // State continues the same.
         // Neither the block got reverted or error deleted.
         assert_eq!(outcome, UnfailOutcome::Noop);
-        assert_eq!(count(), 2);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 2);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(true, vi.failed);
+        assert!(vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
-        test_store::remove_subgraphs();
+        test_store::remove_subgraphs().await;
     })
 }
 
@@ -964,16 +1012,16 @@ fn fail_unfail_non_deterministic_error() {
 
     async fn setup() -> DeploymentLocator {
         let id = DeploymentHash::new(NAME).unwrap();
-        remove_subgraphs();
+        remove_subgraphs().await;
         create_test_subgraph(&id, SUBGRAPH_GQL).await
     }
 
     run_test_sequentially(|store| async move {
         let deployment = setup().await;
 
-        let count = || -> usize {
+        let count = async || -> usize {
             let store = store.subgraph_store();
-            store.error_count(&deployment.hash).unwrap()
+            store.error_count(&deployment.hash).await.unwrap()
         };
 
         // Process the first block.
@@ -987,10 +1035,10 @@ fn fail_unfail_non_deterministic_error() {
         .unwrap();
 
         // We don't have any errors.
-        assert_eq!(count(), 0);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 0);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(0), vi.latest_ethereum_block_number);
 
         let error = SubgraphError {
@@ -1011,10 +1059,10 @@ fn fail_unfail_non_deterministic_error() {
         writable.fail_subgraph(error).await.unwrap();
 
         // Now we have a fatal error because the subgraph failed.
-        assert_eq!(count(), 1);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 1);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(true, vi.failed);
+        assert!(vi.failed);
         assert_eq!(Some(0), vi.latest_ethereum_block_number);
 
         // Process the second block.
@@ -1028,24 +1076,27 @@ fn fail_unfail_non_deterministic_error() {
         .unwrap();
 
         // Subgraph failed but it's deployment head pointer advanced.
-        assert_eq!(count(), 1);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 1);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(true, vi.failed);
+        assert!(vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         // Unfail the subgraph and delete the fatal error.
-        let outcome = writable.unfail_non_deterministic_error(&BLOCKS[1]).unwrap();
+        let outcome = writable
+            .unfail_non_deterministic_error(&BLOCKS[1])
+            .await
+            .unwrap();
 
         // We don't have fatal errors anymore and the subgraph is healthy.
         assert_eq!(outcome, UnfailOutcome::Unfailed);
-        assert_eq!(count(), 0);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 0);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
-        test_store::remove_subgraphs();
+        test_store::remove_subgraphs().await;
     })
 }
 
@@ -1055,16 +1106,16 @@ fn fail_unfail_non_deterministic_error_noop() {
 
     async fn setup() -> DeploymentLocator {
         let id = DeploymentHash::new(NAME).unwrap();
-        remove_subgraphs();
+        remove_subgraphs().await;
         create_test_subgraph(&id, SUBGRAPH_GQL).await
     }
 
     run_test_sequentially(|store| async move {
         let deployment = setup().await;
 
-        let count = || -> usize {
+        let count = async || -> usize {
             let store = store.subgraph_store();
-            store.error_count(&deployment.hash).unwrap()
+            store.error_count(&deployment.hash).await.unwrap()
         };
 
         // Process the first block.
@@ -1078,10 +1129,10 @@ fn fail_unfail_non_deterministic_error_noop() {
         .unwrap();
 
         // We don't have any errors and the subgraph is healthy.
-        assert_eq!(count(), 0);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 0);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(0), vi.latest_ethereum_block_number);
 
         // Process the second block.
@@ -1095,10 +1146,10 @@ fn fail_unfail_non_deterministic_error_noop() {
         .unwrap();
 
         // Still no errors.
-        assert_eq!(count(), 0);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 0);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         let writable = store
@@ -1108,14 +1159,17 @@ fn fail_unfail_non_deterministic_error_noop() {
             .expect("can get writable");
 
         // Running unfail without any errors will do nothing.
-        let outcome = writable.unfail_non_deterministic_error(&BLOCKS[1]).unwrap();
+        let outcome = writable
+            .unfail_non_deterministic_error(&BLOCKS[1])
+            .await
+            .unwrap();
 
         // State continues the same, nothing happened.
         assert_eq!(outcome, UnfailOutcome::Noop);
-        assert_eq!(count(), 0);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 0);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(false, vi.failed);
+        assert!(!vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         let error = SubgraphError {
@@ -1130,21 +1184,24 @@ fn fail_unfail_non_deterministic_error_noop() {
         writable.fail_subgraph(error).await.unwrap();
 
         // We now have a fatal error because the subgraph failed.
-        assert_eq!(count(), 1);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 1);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(true, vi.failed);
+        assert!(vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         // Running unfail_non_deterministic_error will be NOOP, the error is deterministic.
-        let outcome = writable.unfail_non_deterministic_error(&BLOCKS[1]).unwrap();
+        let outcome = writable
+            .unfail_non_deterministic_error(&BLOCKS[1])
+            .await
+            .unwrap();
 
         // Nothing happeened, state continues the same.
         assert_eq!(outcome, UnfailOutcome::Noop);
-        assert_eq!(count(), 1);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(count().await, 1);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(true, vi.failed);
+        assert!(vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
         let error = SubgraphError {
@@ -1158,17 +1215,20 @@ fn fail_unfail_non_deterministic_error_noop() {
         // Fail the subgraph with a non-deterministic error, but with an advanced block.
         writable.fail_subgraph(error).await.unwrap();
 
-        // Since the block range of the block won't match the deployment head, this will be NOOP.
-        let outcome = writable.unfail_non_deterministic_error(&BLOCKS[1]).unwrap();
+        // Since the deployment head is behind the error block, this returns BehindErrorBlock.
+        let outcome = writable
+            .unfail_non_deterministic_error(&BLOCKS[1])
+            .await
+            .unwrap();
 
         // State continues the same besides a new error added to the database.
-        assert_eq!(outcome, UnfailOutcome::Noop);
-        assert_eq!(count(), 2);
-        let vi = get_version_info(&store, NAME);
+        assert_eq!(outcome, UnfailOutcome::BehindErrorBlock);
+        assert_eq!(count().await, 2);
+        let vi = get_version_info(&store, NAME).await;
         assert_eq!(NAME, vi.deployment_id.as_str());
-        assert_eq!(true, vi.failed);
+        assert!(vi.failed);
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
 
-        test_store::remove_subgraphs();
+        test_store::remove_subgraphs().await;
     })
 }
diff --git a/store/test-store/tests/postgres/writable.rs b/store/test-store/tests/postgres/writable.rs
index 4a986e6f3fa..7c17e8f201f 100644
--- a/store/test-store/tests/postgres/writable.rs
+++ b/store/test-store/tests/postgres/writable.rs
@@ -1,29 +1,64 @@
-use graph::blockchain::block_stream::FirehoseCursor;
+use graph::blockchain::block_stream::{EntitySourceOperation, FirehoseCursor};
 use graph::data::subgraph::schema::DeploymentCreate;
 use graph::data::value::Word;
 use graph::data_source::CausalityRegion;
+use graph::prelude::alloy::primitives::B256;
 use graph::schema::{EntityKey, EntityType, InputSchema};
 use lazy_static::lazy_static;
-use std::collections::BTreeSet;
+use std::collections::{BTreeMap, BTreeSet};
+use std::future::Future;
 use std::marker::PhantomData;
+use std::ops::Range;
 use test_store::*;
 
-use graph::components::store::{DeploymentLocator, DerivedEntityQuery, WritableStore};
+use graph::components::store::{
+    DeploymentLocator, DerivedEntityQuery, SourceableStore, WritableStore,
+};
 use graph::data::subgraph::*;
 use graph::semver::Version;
 use graph::{entity, prelude::*};
 use graph_store_postgres::layout_for_tests::writable;
 use graph_store_postgres::{Store as DieselStore, SubgraphStore as DieselSubgraphStore};
-use web3::types::H256;
 
 const SCHEMA_GQL: &str = "
     type Counter @entity {
         id: ID!,
         count: Int!,
     }
+    type Counter2 @entity(immutable: true) {
+        id: ID!,
+        count: Int!,
+    }
+    type BytesId @entity {
+        id: Bytes!,
+        value: String!
+    }
+    type Int8Id @entity {
+        id: Int8!,
+        value: String!
+    }
+    type StringId @entity {
+        id: String!,
+        value: String!
+    }
+    type PoolCreated @entity(immutable: true) {
+        id: Bytes!,
+        token0: Bytes!,
+        token1: Bytes!,
+        fee: Int!,
+        tickSpacing: Int!,
+        pool: Bytes!,
+        blockNumber: BigInt!,
+        blockTimestamp: BigInt!,
+        transactionHash: Bytes!,
+        transactionFrom: Bytes!,
+        transactionGasPrice: BigInt!,
+        logIndex: BigInt!
+    }
 ";
 
 const COUNTER: &str = "Counter";
+const COUNTER2: &str = "Counter2";
 
 lazy_static! {
     static ref TEST_SUBGRAPH_ID_STRING: String = String::from("writableSubgraph");
@@ -33,6 +68,7 @@ lazy_static! {
         InputSchema::parse_latest(SCHEMA_GQL, TEST_SUBGRAPH_ID.clone())
             .expect("Failed to parse user schema");
     static ref COUNTER_TYPE: EntityType = TEST_SUBGRAPH_SCHEMA.entity_type(COUNTER).unwrap();
+    static ref COUNTER2_TYPE: EntityType = TEST_SUBGRAPH_SCHEMA.entity_type(COUNTER2).unwrap();
 }
 
 /// Inserts test data into the store.
@@ -41,7 +77,7 @@ lazy_static! {
 async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator {
     let manifest = SubgraphManifest::<graph_chain_ethereum::Chain> {
         id: TEST_SUBGRAPH_ID.clone(),
-        spec_version: Version::new(1, 0, 0),
+        spec_version: Version::new(1, 3, 0),
         features: Default::default(),
         description: None,
         repository: None,
@@ -67,26 +103,27 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
             NETWORK_NAME.to_string(),
             SubgraphVersionSwitchingMode::Instant,
         )
+        .await
         .unwrap()
 }
 
-/// Removes test data from the database behind the store.
-fn remove_test_data(store: Arc<DieselSubgraphStore>) {
-    store
-        .delete_all_entities_for_test_use_only()
-        .expect("deleting test entities succeeds");
-}
-
 /// Test harness for running database integration tests.
 fn run_test<R, F>(test: F)
 where
-    F: FnOnce(Arc<DieselStore>, Arc<dyn WritableStore>, DeploymentLocator) -> R + Send + 'static,
-    R: std::future::Future<Output = ()> + Send + 'static,
+    F: FnOnce(
+            Arc<DieselStore>,
+            Arc<dyn WritableStore>,
+            Arc<dyn SourceableStore>,
+            DeploymentLocator,
+        ) -> R
+        + Send
+        + 'static,
+    R: Future<Output = ()> + Send + 'static,
 {
     run_test_sequentially(|store| async move {
         let subgraph_store = store.subgraph_store();
         // Reset state before starting
-        remove_test_data(subgraph_store.clone());
+        remove_subgraphs().await;
 
         // Seed database with test data
         let deployment = insert_test_data(subgraph_store.clone()).await;
@@ -95,15 +132,20 @@ where
             .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
             .await
             .expect("we can get a writable store");
+        let sourceable = store
+            .subgraph_store()
+            .sourceable(deployment.id)
+            .await
+            .expect("we can get a writable store");
 
         // Run test and wait for the background writer to finish its work so
         // it won't conflict with the next test
-        test(store, writable, deployment).await;
+        test(store, writable, sourceable, deployment).await;
     });
 }
 
 fn block_pointer(number: u8) -> BlockPtr {
-    let hash = H256::from([number; 32]);
+    let hash = B256::from([number; 32]);
     BlockPtr::from((hash, number as BlockNumber))
 }
 
@@ -111,16 +153,47 @@ fn count_key(id: &str) -> EntityKey {
     COUNTER_TYPE.parse_key(id).unwrap()
 }
 
-async fn insert_count(store: &Arc<DieselSubgraphStore>, deployment: &DeploymentLocator, count: u8) {
+async fn insert_count(
+    store: &Arc<DieselSubgraphStore>,
+    deployment: &DeploymentLocator,
+    block: u8,
+    count: u8,
+    immutable_only: bool,
+) {
+    let count_key_local = |counter_type: &EntityType, id: &str| counter_type.parse_key(id).unwrap();
     let data = entity! { TEST_SUBGRAPH_SCHEMA =>
         id: "1",
-        count: count as i32
+        count: count as i32,
+        vid: block as i64,
+    };
+    let entity_op = if block != 3 && block != 5 && block != 7 {
+        EntityOperation::Set {
+            key: count_key_local(&COUNTER_TYPE, &data.get("id").unwrap().to_string()),
+            data,
+        }
+    } else {
+        EntityOperation::Remove {
+            key: count_key_local(&COUNTER_TYPE, &data.get("id").unwrap().to_string()),
+        }
     };
-    let entity_op = EntityOperation::Set {
-        key: count_key(&data.get("id").unwrap().to_string()),
-        data,
+    let mut ops = if immutable_only {
+        vec![]
+    } else {
+        vec![entity_op]
     };
-    transact_entity_operations(store, deployment, block_pointer(count), vec![entity_op])
+    if block < 6 {
+        let data = entity! { TEST_SUBGRAPH_SCHEMA =>
+            id: &block.to_string(),
+            count :count as i32,
+            vid: block as i64,
+        };
+        let entity_op = EntityOperation::Set {
+            key: count_key_local(&COUNTER2_TYPE, &data.get("id").unwrap().to_string()),
+            data,
+        };
+        ops.push(entity_op);
+    }
+    transact_entity_operations(store, deployment, block_pointer(block), ops)
         .await
         .unwrap();
 }
@@ -136,64 +209,71 @@ async fn pause_writer(deployment: &DeploymentLocator) {
 ///
 /// `read_count` lets us look up entities in different ways to exercise
 /// different methods in `WritableStore`
-fn get_with_pending<F>(batch: bool, read_count: F)
+fn get_with_pending<R, F>(batch: bool, read_count: F)
 where
-    F: Send + Fn(&dyn WritableStore) -> i32 + Sync + 'static,
+    F: Send + Fn(Arc<dyn WritableStore>) -> R + Sync + 'static,
+    R: Future<Output = i32> + Send + 'static,
 {
-    run_test(move |store, writable, deployment| async move {
+    run_test(move |store, writable, _, deployment| async move {
         let subgraph_store = store.subgraph_store();
 
-        let read_count = || read_count(writable.as_ref());
+        let read_count = || read_count(writable.cheap_clone());
 
         if !batch {
-            writable.deployment_synced().unwrap();
+            writable.deployment_synced(block_pointer(0)).await.unwrap();
         }
 
         for count in 1..4 {
-            insert_count(&subgraph_store, &deployment, count).await;
+            insert_count(&subgraph_store, &deployment, count, count, false).await;
         }
 
         // Test reading back with pending writes to the same entity
         pause_writer(&deployment).await;
         for count in 4..7 {
-            insert_count(&subgraph_store, &deployment, count).await;
+            insert_count(&subgraph_store, &deployment, count, count, false).await;
         }
-        assert_eq!(6, read_count());
+        assert_eq!(6, read_count().await);
 
         writable.flush().await.unwrap();
-        assert_eq!(6, read_count());
+        assert_eq!(6, read_count().await);
 
         // Test reading back with pending writes and a pending revert
         for count in 7..10 {
-            insert_count(&subgraph_store, &deployment, count).await;
+            insert_count(&subgraph_store, &deployment, count, count, false).await;
         }
         writable
             .revert_block_operations(block_pointer(2), FirehoseCursor::None)
             .await
             .unwrap();
 
-        assert_eq!(2, read_count());
+        assert_eq!(2, read_count().await);
 
         writable.flush().await.unwrap();
-        assert_eq!(2, read_count());
+        assert_eq!(2, read_count().await);
     })
 }
 
 /// Get the count using `WritableStore::get_many`
-fn count_get_many(writable: &dyn WritableStore) -> i32 {
+async fn count_get_many(writable: Arc<dyn WritableStore>) -> i32 {
     let key = count_key("1");
     let keys = BTreeSet::from_iter(vec![key.clone()]);
-    let counter = writable.get_many(keys).unwrap().get(&key).unwrap().clone();
+    let counter = writable
+        .get_many(keys)
+        .await
+        .unwrap()
+        .get(&key)
+        .unwrap()
+        .clone();
     counter.get("count").unwrap().as_int().unwrap()
 }
 
 /// Get the count using `WritableStore::get`
-fn count_get(writable: &dyn WritableStore) -> i32 {
-    let counter = writable.get(&count_key("1")).unwrap().unwrap();
+async fn count_get(writable: Arc<dyn WritableStore>) -> i32 {
+    let counter = writable.get(&count_key("1")).await.unwrap().unwrap();
     counter.get("count").unwrap().as_int().unwrap()
 }
 
-fn count_get_derived(writable: &dyn WritableStore) -> i32 {
+async fn count_get_derived(writable: Arc<dyn WritableStore>) -> i32 {
     let key = count_key("1");
     let query = DerivedEntityQuery {
         entity_type: key.entity_type.clone(),
@@ -201,7 +281,7 @@ fn count_get_derived(writable: &dyn WritableStore) -> i32 {
         value: key.entity_id.clone(),
         causality_region: CausalityRegion::ONCHAIN,
     };
-    let map = writable.get_derived(&query).unwrap();
+    let map = writable.get_derived(&query).await.unwrap();
     let counter = map.get(&key).unwrap();
     counter.get("count").unwrap().as_int().unwrap()
 }
@@ -238,14 +318,14 @@ fn get_derived_nobatch() {
 
 #[test]
 fn restart() {
-    run_test(|store, writable, deployment| async move {
+    run_test(|store, writable, _, deployment| async move {
         let subgraph_store = store.subgraph_store();
-        let schema = subgraph_store.input_schema(&deployment.hash).unwrap();
+        let schema = subgraph_store.input_schema(&deployment.hash).await.unwrap();
 
         // Cause an error by leaving out the non-nullable `count` attribute
         let entity_ops = vec![EntityOperation::Set {
             key: count_key("1"),
-            data: entity! { schema => id: "1" },
+            data: entity! { schema => id: "1", vid: 0i64},
         }];
         transact_entity_operations(
             &subgraph_store,
@@ -269,7 +349,7 @@ fn restart() {
         // Retry our write with correct data
         let entity_ops = vec![EntityOperation::Set {
             key: count_key("1"),
-            data: entity! { schema => id: "1", count: 1 },
+            data: entity! { schema => id: "1", count: 1, vid: 0i64},
         }];
         // `SubgraphStore` caches the correct writable so that this call
         // uses the restarted writable, and is equivalent to using
@@ -286,3 +366,163 @@ fn restart() {
         writable.flush().await.unwrap();
     })
 }
+
+#[test]
+fn read_range_test() {
+    run_test(|store, writable, sourceable, deployment| async move {
+        let result_entities = [
+            r#"(1, [EntitySourceOperation { entity_op: Create, entity_type: EntityType(Counter), entity: Entity { count: Int(2), id: String("1"), vid: Int8(1) }, vid: 1 }, EntitySourceOperation { entity_op: Create, entity_type: EntityType(Counter2), entity: Entity { count: Int(2), id: String("1"), vid: Int8(1) }, vid: 1 }])"#,
+            r#"(2, [EntitySourceOperation { entity_op: Modify, entity_type: EntityType(Counter), entity: Entity { count: Int(4), id: String("1"), vid: Int8(2) }, vid: 2 }, EntitySourceOperation { entity_op: Create, entity_type: EntityType(Counter2), entity: Entity { count: Int(4), id: String("2"), vid: Int8(2) }, vid: 2 }])"#,
+            r#"(3, [EntitySourceOperation { entity_op: Delete, entity_type: EntityType(Counter), entity: Entity { count: Int(4), id: String("1"), vid: Int8(2) }, vid: 2 }, EntitySourceOperation { entity_op: Create, entity_type: EntityType(Counter2), entity: Entity { count: Int(6), id: String("3"), vid: Int8(3) }, vid: 3 }])"#,
+            r#"(4, [EntitySourceOperation { entity_op: Create, entity_type: EntityType(Counter), entity: Entity { count: Int(8), id: String("1"), vid: Int8(4) }, vid: 4 }, EntitySourceOperation { entity_op: Create, entity_type: EntityType(Counter2), entity: Entity { count: Int(8), id: String("4"), vid: Int8(4) }, vid: 4 }])"#,
+            r#"(5, [EntitySourceOperation { entity_op: Delete, entity_type: EntityType(Counter), entity: Entity { count: Int(8), id: String("1"), vid: Int8(4) }, vid: 4 }, EntitySourceOperation { entity_op: Create, entity_type: EntityType(Counter2), entity: Entity { count: Int(10), id: String("5"), vid: Int8(5) }, vid: 5 }])"#,
+            r#"(6, [EntitySourceOperation { entity_op: Create, entity_type: EntityType(Counter), entity: Entity { count: Int(12), id: String("1"), vid: Int8(6) }, vid: 6 }])"#,
+            r#"(7, [EntitySourceOperation { entity_op: Delete, entity_type: EntityType(Counter), entity: Entity { count: Int(12), id: String("1"), vid: Int8(6) }, vid: 6 }])"#,
+        ];
+        let subgraph_store = store.subgraph_store();
+        writable.deployment_synced(block_pointer(0)).await.unwrap();
+
+        for count in 1..=5 {
+            insert_count(&subgraph_store, &deployment, count, 2 * count, false).await;
+        }
+        writable.flush().await.unwrap();
+        writable.deployment_synced(block_pointer(0)).await.unwrap();
+
+        let br: Range<BlockNumber> = 0..18;
+        let entity_types = vec![COUNTER_TYPE.clone(), COUNTER2_TYPE.clone()];
+        let e: BTreeMap<i32, Vec<EntitySourceOperation>> = sourceable
+            .get_range(entity_types.clone(), CausalityRegion::ONCHAIN, br.clone())
+            .await
+            .unwrap();
+        assert_eq!(e.len(), 5);
+        for en in &e {
+            let index = *en.0 - 1;
+            let a = result_entities[index as usize];
+            assert_eq!(a, format!("{:?}", en));
+        }
+        for count in 6..=7 {
+            insert_count(&subgraph_store, &deployment, count, 2 * count, false).await;
+        }
+        writable.flush().await.unwrap();
+        writable.deployment_synced(block_pointer(0)).await.unwrap();
+        let e: BTreeMap<i32, Vec<EntitySourceOperation>> = sourceable
+            .get_range(entity_types, CausalityRegion::ONCHAIN, br)
+            .await
+            .unwrap();
+        assert_eq!(e.len(), 7);
+        for en in &e {
+            let index = *en.0 - 1;
+            let a = result_entities[index as usize];
+            assert_eq!(a, format!("{:?}", en));
+        }
+    })
+}
+
+#[test]
+fn read_immutable_only_range_test() {
+    run_test(|store, writable, sourceable, deployment| async move {
+        let subgraph_store = store.subgraph_store();
+        writable.deployment_synced(block_pointer(0)).await.unwrap();
+
+        for count in 1..=4 {
+            insert_count(&subgraph_store, &deployment, count, 2 * count, true).await;
+        }
+        writable.flush().await.unwrap();
+        writable.deployment_synced(block_pointer(0)).await.unwrap();
+        let br: Range<BlockNumber> = 0..18;
+        let entity_types = vec![COUNTER2_TYPE.clone()];
+        let e: BTreeMap<i32, Vec<EntitySourceOperation>> = sourceable
+            .get_range(entity_types.clone(), CausalityRegion::ONCHAIN, br.clone())
+            .await
+            .unwrap();
+        assert_eq!(e.len(), 4);
+    })
+}
+
+#[test]
+fn read_range_pool_created_test() {
+    run_test(|store, writable, sourceable, deployment| async move {
+        let result_entities = [
+            "(1, [EntitySourceOperation { entity_op: Create, entity_type: EntityType(PoolCreated), entity: Entity { blockNumber: BigInt(12369621), blockTimestamp: BigInt(1620243254), fee: Int(500), id: Bytes(0xff80818283848586), logIndex: BigInt(0), pool: Bytes(0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8), tickSpacing: Int(10), token0: Bytes(0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48), token1: Bytes(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), transactionFrom: Bytes(0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48), transactionGasPrice: BigInt(100000000000), transactionHash: Bytes(0x12340000000000000000000000000000000000000000000000000000000000000000000000000000), vid: Int8(1) }, vid: 1 }])",
+            "(2, [EntitySourceOperation { entity_op: Create, entity_type: EntityType(PoolCreated), entity: Entity { blockNumber: BigInt(12369622), blockTimestamp: BigInt(1620243255), fee: Int(3000), id: Bytes(0xff90919293949596), logIndex: BigInt(1), pool: Bytes(0x4585fe77225b41b697c938b018e2ac67ac5a20c0), tickSpacing: Int(60), token0: Bytes(0x2260fac5e5542a773aa44fbcfedf7c193bc2c599), token1: Bytes(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), transactionFrom: Bytes(0x2260fac5e5542a773aa44fbcfedf7c193bc2c599), transactionGasPrice: BigInt(100000000000), transactionHash: Bytes(0x12340000000000000000000000000000000000000000000000000000000000000000000000000001), vid: Int8(2) }, vid: 2 }])",
+        ];
+
+        // Rest of the test remains the same
+        let subgraph_store = store.subgraph_store();
+        writable.deployment_synced(block_pointer(0)).await.unwrap();
+
+        let pool_created_type = TEST_SUBGRAPH_SCHEMA.entity_type("PoolCreated").unwrap();
+        let entity_types = vec![pool_created_type.clone()];
+
+        let mut last_op: Option<EntityOperation> = None;
+        for count in (1..=2).map(|x| x as i64) {
+            let id = if count == 1 {
+                "0xff80818283848586"
+            } else {
+                "0xff90919293949596"
+            };
+
+            let data = entity! { TEST_SUBGRAPH_SCHEMA =>
+                id: id,
+                token0: if count == 1 { "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" } else { "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" },
+                token1: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+                fee: if count == 1 { 500 } else { 3000 },
+                tickSpacing: if count == 1 { 10 } else { 60 },
+                pool: if count == 1 { "0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8" } else { "0x4585fe77225b41b697c938b018e2ac67ac5a20c0" },
+                blockNumber: 12369621 + count - 1,
+                blockTimestamp: 1620243254 + count - 1,
+                transactionHash: format!("0x1234{:0>76}", if count == 1 { "0" } else { "1" }),
+                transactionFrom: if count == 1 { "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" } else { "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599" },
+                transactionGasPrice: 100000000000i64,
+                logIndex: count - 1,
+                vid: count
+            };
+
+            let key = pool_created_type.parse_key(id).unwrap();
+            let op = EntityOperation::Set {
+                key: key.clone(),
+                data,
+            };
+
+            last_op = Some(op.clone());
+            transact_entity_operations(
+                &subgraph_store,
+                &deployment,
+                block_pointer(count as u8),
+                vec![op],
+            )
+            .await
+            .unwrap();
+        }
+        writable.flush().await.unwrap();
+        writable.deployment_synced(block_pointer(0)).await.unwrap();
+
+        let br: Range<BlockNumber> = 0..18;
+        let e: BTreeMap<i32, Vec<EntitySourceOperation>> = sourceable
+            .get_range(entity_types.clone(), CausalityRegion::ONCHAIN, br.clone())
+            .await
+            .unwrap();
+        assert_eq!(e.len(), 2);
+        for en in &e {
+            let index = *en.0 - 1;
+            let a = result_entities[index as usize];
+            assert_eq!(a, format!("{:?}", en));
+        }
+
+        // Make sure we get a constraint violation
+        let op = last_op.take().unwrap();
+
+        transact_entity_operations(&subgraph_store, &deployment, block_pointer(3), vec![op])
+            .await
+            .unwrap();
+        let res = writable.flush().await;
+        let exp = "duplicate key value violates unique constraint \"pool_created_pkey\": Key (vid)=(2) already exists.";
+        match res {
+            Ok(_) => panic!("Expected error, but got success"),
+            Err(StoreError::ConstraintViolation(msg)) => {
+                assert_eq!(msg, exp);
+            }
+            Err(e) => panic!("Expected constraint violation, but got {:?}", e),
+        }
+    })
+}
diff --git a/substreams/substreams-head-tracker/Cargo.lock b/substreams/substreams-head-tracker/Cargo.lock
deleted file mode 100755
index 92ad0a04eef..00000000000
--- a/substreams/substreams-head-tracker/Cargo.lock
+++ /dev/null
@@ -1,583 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "aho-corasick"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6748e8def348ed4d14996fa801f4122cd763fff530258cdc03f64b25f89d3a5a"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "anyhow"
-version = "1.0.75"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
-
-[[package]]
-name = "autocfg"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
-
-[[package]]
-name = "base64"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
-
-[[package]]
-name = "bigdecimal"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6773ddc0eafc0e509fb60e48dff7f450f8e674a0686ae8605e8d9901bd5eefa"
-dependencies = [
- "num-bigint",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "bitflags"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
-
-[[package]]
-name = "bytes"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
-
-[[package]]
-name = "cc"
-version = "1.0.83"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "either"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
-
-[[package]]
-name = "equivalent"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
-
-[[package]]
-name = "errno"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b30f669a7961ef1631673d2766cc92f52d64f7ef354d4fe0ddfd30ed52f0f4f"
-dependencies = [
- "errno-dragonfly",
- "libc",
- "windows-sys",
-]
-
-[[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
-dependencies = [
- "cc",
- "libc",
-]
-
-[[package]]
-name = "fastrand"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6999dc1837253364c2ebb0704ba97994bd874e8f195d665c50b7548f6ea92764"
-
-[[package]]
-name = "fixedbitset"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
-
-[[package]]
-name = "hashbrown"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
-
-[[package]]
-name = "heck"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
-
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
-[[package]]
-name = "hex-literal"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
-
-[[package]]
-name = "indexmap"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
-dependencies = [
- "equivalent",
- "hashbrown",
-]
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
-[[package]]
-name = "libc"
-version = "0.2.147"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57bcfdad1b858c2db7c38303a6d2ad4dfaf5eb53dfeb0910128b2c26d6158503"
-
-[[package]]
-name = "log"
-version = "0.4.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
-
-[[package]]
-name = "memchr"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
-
-[[package]]
-name = "multimap"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
-
-[[package]]
-name = "num-bigint"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-integer"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
-dependencies = [
- "autocfg",
- "num-traits",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
-
-[[package]]
-name = "pad"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2ad9b889f1b12e0b9ee24db044b5129150d5eada288edc800f789928dc8c0e3"
-dependencies = [
- "unicode-width",
-]
-
-[[package]]
-name = "petgraph"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
-dependencies = [
- "fixedbitset",
- "indexmap",
-]
-
-[[package]]
-name = "prettyplease"
-version = "0.1.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8646e95016a7a6c4adea95bafa8a16baab64b583356217f2c85db4a39d9a86"
-dependencies = [
- "proc-macro2",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.66"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "prost"
-version = "0.11.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd"
-dependencies = [
- "bytes",
- "prost-derive",
-]
-
-[[package]]
-name = "prost-build"
-version = "0.11.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "119533552c9a7ffacc21e099c24a0ac8bb19c2a2a3f363de84cd9b844feab270"
-dependencies = [
- "bytes",
- "heck",
- "itertools",
- "lazy_static",
- "log",
- "multimap",
- "petgraph",
- "prettyplease",
- "prost",
- "prost-types",
- "regex",
- "syn 1.0.109",
- "tempfile",
- "which",
-]
-
-[[package]]
-name = "prost-derive"
-version = "0.11.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4"
-dependencies = [
- "anyhow",
- "itertools",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "prost-types"
-version = "0.11.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "213622a1460818959ac1181aaeb2dc9c7f63df720db7d788b3e24eacd1983e13"
-dependencies = [
- "prost",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
-dependencies = [
- "bitflags 1.3.2",
-]
-
-[[package]]
-name = "regex"
-version = "1.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12de2eff854e5fa4b1295edd650e227e9d8fb0c9e90b12e7f36d6a6811791a29"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49530408a136e16e5b486e883fbb6ba058e8e4e8ae6621a77b048b314336e629"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
-
-[[package]]
-name = "rustix"
-version = "0.38.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bfe0f2582b4931a45d1fa608f8a8722e8b3c7ac54dd6d5f3b3212791fedef49"
-dependencies = [
- "bitflags 2.4.0",
- "errno",
- "libc",
- "linux-raw-sys",
- "windows-sys",
-]
-
-[[package]]
-name = "substreams"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af972e374502cdfc9998132f5343848d1c58f27a295dc061a89804371f408a46"
-dependencies = [
- "anyhow",
- "bigdecimal",
- "hex",
- "hex-literal",
- "num-bigint",
- "num-traits",
- "pad",
- "prost",
- "prost-build",
- "prost-types",
- "substreams-macro",
- "thiserror",
-]
-
-[[package]]
-name = "substreams-entity-change"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d423d0c12a9284a3d6d4ec288dbc9bfec3d55f9056098ba91a6dcfa64fb3889e"
-dependencies = [
- "base64",
- "prost",
- "prost-types",
- "substreams",
-]
-
-[[package]]
-name = "substreams-head-tracker"
-version = "1.0.0"
-dependencies = [
- "prost",
- "substreams",
- "substreams-entity-change",
-]
-
-[[package]]
-name = "substreams-macro"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6521ccd011a4c3f52cd3c31fc7400733e4feba2094e0e0e6354adca25b2b3f37"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
- "thiserror",
-]
-
-[[package]]
-name = "syn"
-version = "1.0.109"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tempfile"
-version = "3.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef"
-dependencies = [
- "cfg-if",
- "fastrand",
- "redox_syscall",
- "rustix",
- "windows-sys",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97a802ec30afc17eee47b2855fc72e0c4cd62be9b4efe6591edde0ec5bd68d8f"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bb623b56e39ab7dcd4b1b98bb6c8f8d907ed255b18de254088016b27a8ee19b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.29",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
-
-[[package]]
-name = "unicode-width"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
-
-[[package]]
-name = "which"
-version = "4.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269"
-dependencies = [
- "either",
- "libc",
- "once_cell",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
-dependencies = [
- "windows-targets",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
-dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
diff --git a/substreams/substreams-head-tracker/Cargo.toml b/substreams/substreams-head-tracker/Cargo.toml
deleted file mode 100755
index 18b94d6ebcd..00000000000
--- a/substreams/substreams-head-tracker/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[package]
-name = "substreams-head-tracker"
-version = "1.0.0"
-edition = "2021"
-
-[lib]
-crate-type = ["cdylib"]
-
diff --git a/substreams/substreams-head-tracker/Makefile b/substreams/substreams-head-tracker/Makefile
deleted file mode 100755
index 9ef9e5c3f70..00000000000
--- a/substreams/substreams-head-tracker/Makefile
+++ /dev/null
@@ -1,15 +0,0 @@
-ENDPOINT ?= mainnet.eth.streamingfast.io:443
-START_BLOCK ?= 16000000
-STOP_BLOCK ?= +100
-
-.PHONY: build
-build:
-	cargo build --target wasm32-unknown-unknown --release
-
-.PHONY: run
-run: build
-	substreams run -e $(ENDPOINT) substreams.yaml map_blocks -s $(START_BLOCK) -t $(STOP_BLOCK)
-
-.PHONY: pack
-pack: build
-	substreams pack substreams.yaml
diff --git a/substreams/substreams-head-tracker/rust-toolchain.toml b/substreams/substreams-head-tracker/rust-toolchain.toml
deleted file mode 100755
index a09cf93404f..00000000000
--- a/substreams/substreams-head-tracker/rust-toolchain.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[toolchain]
-targets = [ "wasm32-unknown-unknown" ]
\ No newline at end of file
diff --git a/substreams/substreams-head-tracker/src/lib.rs b/substreams/substreams-head-tracker/src/lib.rs
deleted file mode 100644
index ee880963011..00000000000
--- a/substreams/substreams-head-tracker/src/lib.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![cfg(target_arch = "wasm32")]
-
-#[no_mangle]
-pub extern "C" fn map_blocks(_params_ptr: *mut u8, _params_len: usize) {}
-
-#[no_mangle]
-pub fn alloc(size: usize) -> *mut u8 {
-    let mut buf = Vec::with_capacity(size);
-    let ptr = buf.as_mut_ptr();
-
-    // Runtime is responsible of calling dealloc when no longer needed
-    std::mem::forget(buf);
-    ptr
-}
-
-#[no_mangle]
-pub unsafe fn dealloc(ptr: *mut u8, size: usize) {
-    std::mem::drop(Vec::from_raw_parts(ptr, size, size))
-}
diff --git a/substreams/substreams-head-tracker/substreams-head-tracker-v1.0.0.spkg b/substreams/substreams-head-tracker/substreams-head-tracker-v1.0.0.spkg
deleted file mode 100644
index 2e44fdf53c6..00000000000
Binary files a/substreams/substreams-head-tracker/substreams-head-tracker-v1.0.0.spkg and /dev/null differ
diff --git a/substreams/substreams-head-tracker/substreams.yaml b/substreams/substreams-head-tracker/substreams.yaml
deleted file mode 100755
index 07d38afeeca..00000000000
--- a/substreams/substreams-head-tracker/substreams.yaml
+++ /dev/null
@@ -1,17 +0,0 @@
-specVersion: v0.1.0
-package:
-  name: substreams_head_tracker
-  version: v1.0.0
-
-binaries:
-  default:
-    type: wasm/rust-v1
-    file: ./target/wasm32-unknown-unknown/release/substreams.wasm
-
-modules:
-  - name: map_blocks
-    kind: map
-    inputs:
-      - params: string
-    output:
-      type: proto:sf.substreams.entity.v1.EntityChanges
diff --git a/substreams/substreams-trigger-filter/Cargo.lock b/substreams/substreams-trigger-filter/Cargo.lock
deleted file mode 100755
index 5a22905c7f5..00000000000
--- a/substreams/substreams-trigger-filter/Cargo.lock
+++ /dev/null
@@ -1,498 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "anyhow"
-version = "1.0.66"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "216261ddc8289130e551ddcd5ce8a064710c0d064a4d2895c67151c92b5443f6"
-
-[[package]]
-name = "autocfg"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
-
-[[package]]
-name = "base64"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
-
-[[package]]
-name = "bigdecimal"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6aaf33151a6429fe9211d1b276eafdf70cdff28b071e76c0b0e1503221ea3744"
-dependencies = [
- "num-bigint",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "bs58"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
-
-[[package]]
-name = "bytes"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfb24e866b15a1af2a1b663f10c6b6b8f397a84aadb828f12e5b289ec23a3a3c"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "either"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
-
-[[package]]
-name = "fastrand"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
-dependencies = [
- "instant",
-]
-
-[[package]]
-name = "fixedbitset"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
-
-[[package]]
-name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
-[[package]]
-name = "heck"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
-
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
-[[package]]
-name = "hex-literal"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
-
-[[package]]
-name = "indexmap"
-version = "1.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
-dependencies = [
- "autocfg",
- "hashbrown",
-]
-
-[[package]]
-name = "instant"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
-[[package]]
-name = "libc"
-version = "0.2.138"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db6d7e329c562c5dfab7a46a2afabc8b987ab9a4834c9d1ca04dc54c1546cef8"
-
-[[package]]
-name = "log"
-version = "0.4.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "multimap"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
-
-[[package]]
-name = "num-bigint"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-integer"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
-dependencies = [
- "autocfg",
- "num-traits",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
-
-[[package]]
-name = "pad"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2ad9b889f1b12e0b9ee24db044b5129150d5eada288edc800f789928dc8c0e3"
-dependencies = [
- "unicode-width",
-]
-
-[[package]]
-name = "petgraph"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5014253a1331579ce62aa67443b4a658c5e7dd03d4bc6d302b94474888143"
-dependencies = [
- "fixedbitset",
- "indexmap",
-]
-
-[[package]]
-name = "prettyplease"
-version = "0.1.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c142c0e46b57171fe0c528bee8c5b7569e80f0c17e377cd0e30ea57dbc11bb51"
-dependencies = [
- "proc-macro2",
- "syn",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "prost"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0b18e655c21ff5ac2084a5ad0611e827b3f92badf79f4910b5a5c58f4d87ff0"
-dependencies = [
- "bytes",
- "prost-derive",
-]
-
-[[package]]
-name = "prost-build"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e330bf1316db56b12c2bcfa399e8edddd4821965ea25ddb2c134b610b1c1c604"
-dependencies = [
- "bytes",
- "heck",
- "itertools",
- "lazy_static",
- "log",
- "multimap",
- "petgraph",
- "prettyplease",
- "prost",
- "prost-types",
- "regex",
- "syn",
- "tempfile",
- "which",
-]
-
-[[package]]
-name = "prost-derive"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "164ae68b6587001ca506d3bf7f1000bfa248d0e1217b618108fba4ec1d0cc306"
-dependencies = [
- "anyhow",
- "itertools",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "prost-types"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "747761bc3dc48f9a34553bf65605cf6cb6288ba219f3450b4275dbd81539551a"
-dependencies = [
- "bytes",
- "prost",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "regex"
-version = "1.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"
-dependencies = [
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
-
-[[package]]
-name = "remove_dir_all"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "substreams"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ea94f238b54b075ad17894537bdcc20d5fc65cdc199bf1594c9ecfdc6454840"
-dependencies = [
- "anyhow",
- "bigdecimal",
- "hex",
- "hex-literal",
- "num-bigint",
- "num-traits",
- "pad",
- "prost",
- "prost-build",
- "prost-types",
- "substreams-macro",
- "thiserror",
-]
-
-[[package]]
-name = "substreams-entity-change"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d423d0c12a9284a3d6d4ec288dbc9bfec3d55f9056098ba91a6dcfa64fb3889e"
-dependencies = [
- "base64",
- "prost",
- "prost-types",
- "substreams",
-]
-
-[[package]]
-name = "substreams-filter"
-version = "0.0.1"
-dependencies = [
- "hex",
- "prost",
- "substreams",
- "substreams-entity-change",
- "substreams-near-core",
- "tonic-build",
-]
-
-[[package]]
-name = "substreams-macro"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c9df3ebfeefa8958b1de17f7e9e80f9b1d9a78cbe9114716a872a52b60b8343"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "thiserror",
-]
-
-[[package]]
-name = "substreams-near-core"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9922f437e6cb86b62cfd8bdede93937def710616ac2825ffff06b8770bbd06df"
-dependencies = [
- "bs58",
- "prost",
- "prost-build",
- "prost-types",
-]
-
-[[package]]
-name = "syn"
-version = "1.0.105"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60b9b43d45702de4c839cb9b51d9f529c5dd26a4aff255b42b1ebc03e88ee908"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tempfile"
-version = "3.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
-dependencies = [
- "cfg-if",
- "fastrand",
- "libc",
- "redox_syscall",
- "remove_dir_all",
- "winapi",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "tonic-build"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bf5e9b9c0f7e0a7c027dcfaba7b2c60816c7049171f679d99ee2ff65d0de8c4"
-dependencies = [
- "prettyplease",
- "proc-macro2",
- "prost-build",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
-
-[[package]]
-name = "unicode-width"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
-
-[[package]]
-name = "which"
-version = "4.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
-dependencies = [
- "either",
- "libc",
- "once_cell",
-]
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/substreams/substreams-trigger-filter/Cargo.toml b/substreams/substreams-trigger-filter/Cargo.toml
deleted file mode 100755
index 94c5ee13166..00000000000
--- a/substreams/substreams-trigger-filter/Cargo.toml
+++ /dev/null
@@ -1,22 +0,0 @@
-[package]
-name = "substreams-trigger-filter"
-version.workspace = true
-edition.workspace = true
-
-[lib]
-doc = false
-name = "substreams"
-crate-type = ["cdylib"]
-
-[dependencies]
-hex = { version = "0.4", default-features = false }
-prost.workspace = true
-substreams = "0.5"
-substreams-entity-change = "1.3"
-substreams-near-core = "0.10.1"
-anyhow = "1"
-
-trigger-filters.path = "../trigger-filters"
-
-[build-dependencies]
-tonic-build = { version = "0.8.4", features = ["prost"] }
diff --git a/substreams/substreams-trigger-filter/Makefile b/substreams/substreams-trigger-filter/Makefile
deleted file mode 100755
index 365b6f05178..00000000000
--- a/substreams/substreams-trigger-filter/Makefile
+++ /dev/null
@@ -1,35 +0,0 @@
-ENDPOINT ?= mainnet.near.streamingfast.io:443
-START_BLOCK ?= 96764162
-STOP_BLOCK ?= +100
-
-.PHONY: build
-build:
-	cargo build --target wasm32-unknown-unknown --release
-
-.PHONY: run
-run: build
-	substreams run -e $(ENDPOINT) substreams.yaml near_filter -s $(START_BLOCK) -t $(STOP_BLOCK) $(ARGS)
-
-.PHONY: gui
-gui: build
-	substreams gui -e $(ENDPOINT) substreams.yaml map_block -s $(START_BLOCK) -t $(STOP_BLOCK)
-
-# .PHONY: protogen
-# protogen:
-# 	substreams protogen ./substreams.yaml --exclude-paths="sf/substreams,google"
-
-.PHONY: pack
-pack: build
-	substreams pack substreams.yaml
-
-.PHONY: deploy_local
-deploy_local: pack
-	mkdir build 2> /dev/null || true
-	bun x graph build --ipfs http://localhost:5001 subgraph.yaml
-	bun x graph create map_block --node http://127.0.0.1:8020
-	bun x graph deploy --node http://127.0.0.1:8020 --ipfs http://127.0.0.1:5001 --version-label v0.0.1 map_block subgraph.yaml
-
-.PHONY: undeploy_local
-undeploy_local:
-	graphman --config "$(GRAPH_CONFIG)" drop --force uniswap_v3
-
diff --git a/substreams/substreams-trigger-filter/build.rs b/substreams/substreams-trigger-filter/build.rs
deleted file mode 100644
index f29e8ecf091..00000000000
--- a/substreams/substreams-trigger-filter/build.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-fn main() {
-    println!("cargo:rerun-if-changed=proto");
-    tonic_build::configure()
-        .protoc_arg("--experimental_allow_proto3_optional")
-        .extern_path(
-            ".sf.near.codec.v1",
-            "::substreams_near_core::pb::sf::near::type::v1",
-        )
-        // .extern_path(
-        //     ".sf.ethereum.type.v2",
-        //     "graph_chain_ethereum::codec::pbcodec",
-        // )
-        // .extern_path(".sf.arweave.type.v1", "graph_chain_arweave::codec::pbcodec")
-        // .extern_path(".sf.cosmos.type.v1", "graph_chain_cosmos::codec")
-        .out_dir("src/pb")
-        .compile(&["proto/receipts.proto"], &["proto"])
-        .expect("Failed to compile Substreams entity proto(s)");
-}
diff --git a/substreams/substreams-trigger-filter/bun.lockb b/substreams/substreams-trigger-filter/bun.lockb
deleted file mode 100755
index 7f816d7b37d..00000000000
Binary files a/substreams/substreams-trigger-filter/bun.lockb and /dev/null differ
diff --git a/substreams/substreams-trigger-filter/package.json b/substreams/substreams-trigger-filter/package.json
deleted file mode 100644
index 3815b847ded..00000000000
--- a/substreams/substreams-trigger-filter/package.json
+++ /dev/null
@@ -1 +0,0 @@
-{ "dependencies": { "@graphprotocol/graph-cli": "^0.52.0" } }
\ No newline at end of file
diff --git a/substreams/substreams-trigger-filter/proto/near.proto b/substreams/substreams-trigger-filter/proto/near.proto
deleted file mode 100644
index 22a0267669a..00000000000
--- a/substreams/substreams-trigger-filter/proto/near.proto
+++ /dev/null
@@ -1,521 +0,0 @@
-syntax = "proto3";
-
-package sf.near.codec.v1;
-
-option go_package = "github.com/streamingfast/sf-near/pb/sf/near/codec/v1;pbcodec";
-
-message Block {
-  string author = 1;
-  BlockHeader header = 2;
-  repeated ChunkHeader chunk_headers = 3;
-  repeated IndexerShard shards = 4;
-  repeated StateChangeWithCause state_changes = 5;
-}
-
-// HeaderOnlyBlock is a standard [Block] structure where all other fields are
-// removed so that hydrating that object from a [Block] bytes payload will
-// drastically reduced allocated memory required to hold the full block.
-//
-// This can be used to unpack a [Block] when only the [BlockHeader] information
-// is required and greatly reduced required memory.
-message HeaderOnlyBlock {
-  BlockHeader header = 2;
-}
-
-message StateChangeWithCause {
-  StateChangeValue value = 1;
-  StateChangeCause cause = 2;
-}
-
-message StateChangeCause {
-  oneof cause {
-    NotWritableToDisk not_writable_to_disk = 1;
-    InitialState initial_state = 2;
-    TransactionProcessing  transaction_processing = 3;
-    ActionReceiptProcessingStarted action_receipt_processing_started = 4;
-    ActionReceiptGasReward action_receipt_gas_reward = 5;
-    ReceiptProcessing receipt_processing = 6;
-    PostponedReceipt postponed_receipt = 7;
-    UpdatedDelayedReceipts updated_delayed_receipts = 8;
-    ValidatorAccountsUpdate validator_accounts_update = 9;
-    Migration migration = 10;
-  }
-
-  message NotWritableToDisk {}
-  message InitialState {}
-  message TransactionProcessing {CryptoHash tx_hash = 1;}
-  message ActionReceiptProcessingStarted {CryptoHash receipt_hash = 1;}
-  message ActionReceiptGasReward {CryptoHash tx_hash = 1;}
-  message ReceiptProcessing {CryptoHash tx_hash = 1;}
-  message PostponedReceipt {CryptoHash tx_hash = 1;}
-  message UpdatedDelayedReceipts {}
-  message ValidatorAccountsUpdate {}
-  message Migration {}
-}
-
-message StateChangeValue {
-  oneof value {
-    AccountUpdate account_update = 1;
-    AccountDeletion account_deletion = 2;
-    AccessKeyUpdate access_key_update = 3;
-    AccessKeyDeletion access_key_deletion = 4;
-    DataUpdate data_update = 5;
-    DataDeletion data_deletion = 6;
-    ContractCodeUpdate contract_code_update = 7;
-    ContractCodeDeletion contract_deletion = 8;
-  }
-
-  message AccountUpdate {string account_id = 1; Account account = 2;}
-  message AccountDeletion {string account_id = 1;}
-  message AccessKeyUpdate {
-    string account_id = 1;
-    PublicKey public_key = 2;
-    AccessKey access_key = 3;
-  }
-  message AccessKeyDeletion {
-    string account_id = 1;
-    PublicKey public_key = 2;
-  }
-  message DataUpdate {
-    string account_id = 1;
-    bytes key = 2;
-    bytes value = 3;
-  }
-  message DataDeletion {
-    string account_id = 1;
-    bytes key = 2;
-  }
-  message ContractCodeUpdate {
-    string account_id = 1;
-    bytes code = 2;
-  }
-  message ContractCodeDeletion {
-    string account_id = 1;
-  }
-}
-
-message Account {
-  BigInt amount = 1;
-  BigInt locked = 2;
-  CryptoHash code_hash = 3;
-  uint64 storage_usage = 4;
-}
-
-message BlockHeader {
-  uint64 height = 1;
-  uint64 prev_height = 2;
-  CryptoHash epoch_id = 3;
-  CryptoHash next_epoch_id = 4;
-  CryptoHash hash = 5;
-  CryptoHash prev_hash = 6;
-  CryptoHash prev_state_root = 7;
-  CryptoHash chunk_receipts_root = 8;
-  CryptoHash chunk_headers_root = 9;
-  CryptoHash chunk_tx_root = 10;
-  CryptoHash outcome_root = 11;
-  uint64 chunks_included = 12;
-  CryptoHash challenges_root = 13;
-  uint64 timestamp = 14;
-  uint64 timestamp_nanosec = 15;
-  CryptoHash random_value = 16;
-  repeated ValidatorStake validator_proposals = 17;
-  repeated bool chunk_mask = 18;
-  BigInt gas_price = 19;
-  uint64 block_ordinal = 20;
-  BigInt total_supply = 21;
-  repeated SlashedValidator challenges_result = 22;
-  uint64 last_final_block_height = 23;
-  CryptoHash last_final_block = 24;
-  uint64 last_ds_final_block_height = 25;
-  CryptoHash last_ds_final_block = 26;
-  CryptoHash next_bp_hash = 27;
-  CryptoHash block_merkle_root = 28;
-  bytes epoch_sync_data_hash = 29;
-  repeated Signature approvals = 30;
-  Signature signature = 31;
-  uint32 latest_protocol_version = 32;
-}
-
-message BigInt {
-  bytes bytes = 1;
-}
-message CryptoHash {
-  bytes bytes = 1;
-}
-
-enum CurveKind {
-  ED25519 = 0;
-  SECP256K1 = 1;
-}
-
-message Signature {
-  CurveKind type = 1;
-  bytes bytes = 2;
-}
-
-message PublicKey {
-  CurveKind type = 1;
-  bytes bytes = 2;
-}
-
-message ValidatorStake {
-  string account_id = 1;
-  PublicKey public_key = 2;
-  BigInt stake = 3;
-}
-
-message SlashedValidator {
-  string account_id = 1;
-  bool is_double_sign = 2;
-}
-
-message ChunkHeader {
-  bytes chunk_hash = 1;
-  bytes prev_block_hash = 2;
-  bytes outcome_root = 3;
-  bytes prev_state_root = 4;
-  bytes encoded_merkle_root = 5;
-  uint64 encoded_length = 6;
-  uint64 height_created = 7;
-  uint64 height_included = 8;
-  uint64 shard_id = 9;
-  uint64 gas_used = 10;
-  uint64 gas_limit = 11;
-  BigInt validator_reward = 12;
-  BigInt balance_burnt = 13;
-  bytes outgoing_receipts_root = 14;
-  bytes tx_root = 15;
-  repeated ValidatorStake validator_proposals = 16;
-  Signature signature = 17;
-}
-
-message IndexerShard {
-  uint64 shard_id = 1;
-  IndexerChunk chunk = 2;
-  repeated IndexerExecutionOutcomeWithReceipt receipt_execution_outcomes = 3;
-}
-
-message IndexerExecutionOutcomeWithReceipt {
-  ExecutionOutcomeWithId execution_outcome = 1;
-  Receipt receipt = 2;
-}
-
-message IndexerChunk {
-  string author = 1;
-  ChunkHeader header = 2;
-  repeated IndexerTransactionWithOutcome transactions = 3;
-  repeated Receipt receipts = 4;
-}
-
-message IndexerTransactionWithOutcome {
-  SignedTransaction transaction = 1;
-  IndexerExecutionOutcomeWithOptionalReceipt outcome = 2;
-}
-
-message SignedTransaction {
-  string signer_id = 1;
-  PublicKey public_key = 2;
-  uint64 nonce = 3;
-  string receiver_id = 4;
-  repeated Action actions = 5;
-  Signature signature = 6;
-  CryptoHash hash = 7;
-}
-
-message IndexerExecutionOutcomeWithOptionalReceipt {
-  ExecutionOutcomeWithId execution_outcome = 1;
-  Receipt receipt = 2;
-}
-
-message Receipt {
-  string predecessor_id = 1;
-  string receiver_id = 2;
-  CryptoHash receipt_id = 3;
-
-  oneof receipt {
-    ReceiptAction action = 10;
-    ReceiptData data = 11;
-  }
-}
-
-message ReceiptData {
-  CryptoHash data_id = 1;
-  bytes data = 2;
-}
-
-message ReceiptAction {
-  string signer_id = 1;
-  PublicKey signer_public_key = 2;
-  BigInt gas_price = 3;
-  repeated DataReceiver output_data_receivers = 4;
-  repeated CryptoHash input_data_ids = 5;
-  repeated Action actions = 6;
-}
-
-message DataReceiver {
-  CryptoHash data_id = 1;
-  string receiver_id = 2;
-}
-
-message ExecutionOutcomeWithId {
-  MerklePath proof = 1;
-  CryptoHash block_hash = 2;
-  CryptoHash id = 3;
-  ExecutionOutcome outcome = 4;
-}
-
-message ExecutionOutcome {
-  repeated string logs = 1;
-  repeated CryptoHash receipt_ids = 2;
-  uint64 gas_burnt = 3;
-  BigInt tokens_burnt = 4;
-  string executor_id = 5;
-  oneof status {
-    UnknownExecutionStatus unknown = 20;
-    FailureExecutionStatus failure = 21;
-    SuccessValueExecutionStatus success_value = 22;
-    SuccessReceiptIdExecutionStatus success_receipt_id = 23;
-  }
-  ExecutionMetadata metadata = 6;
-}
-
-enum ExecutionMetadata {
-  ExecutionMetadataV1 = 0;
-}
-
-message SuccessValueExecutionStatus {
-  bytes value = 1;
-}
-
-message SuccessReceiptIdExecutionStatus {
-  CryptoHash id = 1;
-}
-
-message UnknownExecutionStatus {}
-message FailureExecutionStatus {
-  oneof failure {
-    ActionError action_error = 1;
-    InvalidTxError invalid_tx_error = 2;
-  }
-}
-
-message ActionError {
-  uint64 index = 1;
-  oneof kind {
-    AccountAlreadyExistsErrorKind account_already_exist = 21;
-    AccountDoesNotExistErrorKind account_does_not_exist = 22;
-    CreateAccountOnlyByRegistrarErrorKind create_account_only_by_registrar = 23;
-    CreateAccountNotAllowedErrorKind create_account_not_allowed = 24;
-    ActorNoPermissionErrorKind actor_no_permission =25;
-    DeleteKeyDoesNotExistErrorKind  delete_key_does_not_exist = 26;
-    AddKeyAlreadyExistsErrorKind  add_key_already_exists = 27;
-    DeleteAccountStakingErrorKind delete_account_staking = 28;
-    LackBalanceForStateErrorKind lack_balance_for_state = 29;
-    TriesToUnstakeErrorKind tries_to_unstake = 30;
-    TriesToStakeErrorKind tries_to_stake = 31;
-    InsufficientStakeErrorKind insufficient_stake = 32;
-    FunctionCallErrorKind function_call = 33;
-    NewReceiptValidationErrorKind new_receipt_validation = 34;
-    OnlyImplicitAccountCreationAllowedErrorKind only_implicit_account_creation_allowed = 35;
-    DeleteAccountWithLargeStateErrorKind delete_account_with_large_state = 36;
-  }
-}
-
-message AccountAlreadyExistsErrorKind {
-  string account_id = 1;
-}
-
-message AccountDoesNotExistErrorKind {
-  string account_id = 1;
-}
-
-/// A top-level account ID can only be created by registrar.
-message CreateAccountOnlyByRegistrarErrorKind{
-  string account_id = 1;
-  string  registrar_account_id = 2;
-  string predecessor_id = 3;
-}
-
-message CreateAccountNotAllowedErrorKind{
-  string account_id = 1;
-  string  predecessor_id = 2;
-}
-
-message ActorNoPermissionErrorKind{
-  string account_id = 1;
-  string actor_id = 2;
-}
-
-message DeleteKeyDoesNotExistErrorKind{
-  string account_id = 1;
-  PublicKey public_key = 2;
-}
-
-message AddKeyAlreadyExistsErrorKind{
-  string account_id = 1;
-  PublicKey public_key = 2;
-}
-
-message DeleteAccountStakingErrorKind{
-  string account_id = 1;
-}
-
-message LackBalanceForStateErrorKind{
-  string account_id = 1;
-  BigInt balance = 2;
-}
-
-message TriesToUnstakeErrorKind{
-  string account_id = 1;
-}
-
-message TriesToStakeErrorKind{
-  string account_id = 1;
-  BigInt stake = 2;
-  BigInt locked = 3;
-  BigInt balance = 4;
-}
-
-message InsufficientStakeErrorKind{
-  string account_id = 1;
-  BigInt stake = 2;
-  BigInt minimum_stake = 3;
-}
-
-message FunctionCallErrorKind {
-  FunctionCallErrorSer error = 1;
-}
-
-enum FunctionCallErrorSer { //todo: add more detail?
-  CompilationError = 0;
-  LinkError = 1;
-  MethodResolveError = 2;
-  WasmTrap = 3;
-  WasmUnknownError = 4;
-  HostError = 5;
-  _EVMError = 6;
-  ExecutionError = 7;
-}
-
-message NewReceiptValidationErrorKind {
-  ReceiptValidationError error = 1;
-}
-
-enum ReceiptValidationError { //todo: add more detail?
-  InvalidPredecessorId = 0;
-  InvalidReceiverAccountId = 1;
-  InvalidSignerAccountId = 2;
-  InvalidDataReceiverId = 3;
-  ReturnedValueLengthExceeded = 4;
-  NumberInputDataDependenciesExceeded = 5;
-  ActionsValidationError = 6;
-}
-
-message OnlyImplicitAccountCreationAllowedErrorKind{
-  string account_id = 1;
-}
-
-message DeleteAccountWithLargeStateErrorKind{
-  string account_id = 1;
-}
-
-enum InvalidTxError { //todo: add more detail?
-  InvalidAccessKeyError = 0;
-  InvalidSignerId = 1;
-  SignerDoesNotExist = 2;
-  InvalidNonce = 3;
-  NonceTooLarge = 4;
-  InvalidReceiverId = 5;
-  InvalidSignature = 6;
-  NotEnoughBalance = 7;
-  LackBalanceForState = 8;
-  CostOverflow = 9;
-  InvalidChain = 10;
-  Expired = 11;
-  ActionsValidation = 12;
-  TransactionSizeExceeded = 13;
-}
-
-message MerklePath {
-  repeated MerklePathItem path = 1;
-}
-
-message MerklePathItem {
-  CryptoHash hash = 1;
-  Direction direction = 2;
-}
-
-enum Direction {
-  left = 0;
-  right = 1;
-}
-
-message Action {
-  oneof action {
-    CreateAccountAction create_account = 1;
-    DeployContractAction deploy_contract = 2;
-    FunctionCallAction function_call = 3;
-    TransferAction transfer = 4;
-    StakeAction stake = 5;
-    AddKeyAction add_key = 6;
-    DeleteKeyAction delete_key = 7;
-    DeleteAccountAction delete_account = 8;
-  }
-}
-
-message CreateAccountAction {
-}
-
-message DeployContractAction {
-  bytes code = 1;
-}
-
-message FunctionCallAction {
-  string method_name = 1;
-  bytes args = 2;
-  uint64 gas = 3;
-  BigInt deposit = 4;
-}
-
-message TransferAction {
-  BigInt deposit = 1;
-}
-
-message StakeAction {
-  BigInt stake = 1;
-  PublicKey public_key = 2;
-}
-
-message AddKeyAction {
-  PublicKey public_key = 1;
-  AccessKey access_key = 2;
-}
-
-message DeleteKeyAction {
-  PublicKey public_key = 1;
-}
-
-message DeleteAccountAction {
-  string beneficiary_id = 1;
-}
-
-message AccessKey {
-  uint64 nonce = 1;
-  AccessKeyPermission permission = 2;
-}
-
-message AccessKeyPermission {
-  oneof permission {
-    FunctionCallPermission function_call = 1;
-    FullAccessPermission full_access = 2;
-  }
-}
-
-message FunctionCallPermission {
-  BigInt allowance = 1;
-  string receiver_id = 2;
-  repeated  string method_names = 3;
-}
-
-message FullAccessPermission {
-}
diff --git a/substreams/substreams-trigger-filter/proto/receipts.proto b/substreams/substreams-trigger-filter/proto/receipts.proto
deleted file mode 100755
index d7e4a822573..00000000000
--- a/substreams/substreams-trigger-filter/proto/receipts.proto
+++ /dev/null
@@ -1,15 +0,0 @@
-syntax = "proto3";
-
-import "near.proto";
-
-package receipts.v1;
-
-message BlockAndReceipts {
-    sf.near.codec.v1.Block block = 1;
-    repeated sf.near.codec.v1.ExecutionOutcomeWithId outcome = 2;
-    repeated sf.near.codec.v1.Receipt receipt = 3;
-}
-
- 
-
-
diff --git a/substreams/substreams-trigger-filter/rust-toolchain.toml b/substreams/substreams-trigger-filter/rust-toolchain.toml
deleted file mode 100755
index fde0e8fe57c..00000000000
--- a/substreams/substreams-trigger-filter/rust-toolchain.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[toolchain]
-targets = [ "wasm32-unknown-unknown" ]
diff --git a/substreams/substreams-trigger-filter/schema.graphql b/substreams/substreams-trigger-filter/schema.graphql
deleted file mode 100644
index 20e5f730423..00000000000
--- a/substreams/substreams-trigger-filter/schema.graphql
+++ /dev/null
@@ -1,4 +0,0 @@
-type Block @entity {
-  id: Bytes!
-}
-
diff --git a/substreams/substreams-trigger-filter/src/lib.rs b/substreams/substreams-trigger-filter/src/lib.rs
deleted file mode 100755
index 01109234fdd..00000000000
--- a/substreams/substreams-trigger-filter/src/lib.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-#![allow(clippy::not_unsafe_ptr_arg_deref)]
-
-mod pb;
-
-use pb::receipts::v1::BlockAndReceipts;
-use substreams_entity_change::pb::entity::EntityChanges;
-use substreams_near_core::pb::sf::near::r#type::v1::{
-    execution_outcome, receipt::Receipt, Block, IndexerExecutionOutcomeWithReceipt,
-};
-use trigger_filters::NearFilter;
-
-fn status(outcome: &IndexerExecutionOutcomeWithReceipt) -> Option<&execution_outcome::Status> {
-    outcome
-        .execution_outcome
-        .as_ref()
-        .and_then(|o| o.outcome.as_ref())
-        .and_then(|o| o.status.as_ref())
-}
-
-fn is_success(outcome: &IndexerExecutionOutcomeWithReceipt) -> bool {
-    status(outcome)
-        .map(|s| {
-            use execution_outcome::Status::*;
-
-            match s {
-                Unknown(_) | Failure(_) => false,
-                SuccessValue(_) | SuccessReceiptId(_) => true,
-            }
-        })
-        .unwrap_or(false)
-}
-
-#[substreams::handlers::map]
-fn near_filter(params: String, blk: Block) -> Result<BlockAndReceipts, substreams::errors::Error> {
-    let mut blk = blk;
-    let filter = NearFilter::try_from(params.as_str())?;
-    let mut out = BlockAndReceipts::default();
-
-    blk.shards = blk
-        .shards
-        .into_iter()
-        .map(|shard| {
-            let mut shard = shard;
-            let receipt_execution_outcomes = shard
-                .receipt_execution_outcomes
-                .into_iter()
-                .filter(|outcome| {
-                    if !is_success(&outcome) {
-                        return false;
-                    }
-
-                    let execution_outcome = match outcome.execution_outcome.as_ref() {
-                        Some(eo) => eo,
-                        None => return false,
-                    };
-
-                    let receipt = match outcome.receipt.as_ref() {
-                        Some(receipt) => receipt,
-                        None => return false,
-                    };
-
-                    if !matches!(receipt.receipt, Some(Receipt::Action(_))) {
-                        return false;
-                    }
-
-                    if !filter.matches(&receipt.receiver_id) {
-                        return false;
-                    }
-
-                    out.outcome.push(execution_outcome.clone());
-                    out.receipt.push(receipt.clone());
-                    true
-                })
-                .collect();
-            shard.receipt_execution_outcomes = receipt_execution_outcomes;
-            shard
-        })
-        .collect();
-
-    out.block = Some(blk.clone());
-
-    Ok(out)
-}
-
-#[substreams::handlers::map]
-fn graph_out(blk: Block) -> Result<EntityChanges, substreams::errors::Error> {
-    let mut out = EntityChanges::default();
-
-    let hex = hex::encode(&blk.header.as_ref().unwrap().hash.as_ref().unwrap().bytes);
-
-    out.push_change(
-        "Block",
-        &hex,
-        blk.header.unwrap().height,
-        substreams_entity_change::pb::entity::entity_change::Operation::Create,
-    );
-
-    Ok(out)
-}
diff --git a/substreams/substreams-trigger-filter/src/pb/mod.rs b/substreams/substreams-trigger-filter/src/pb/mod.rs
deleted file mode 100755
index be6467ea7fd..00000000000
--- a/substreams/substreams-trigger-filter/src/pb/mod.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// @generated
-pub mod receipts {
-    // @@protoc_insertion_point(attribute:receipts.v1)
-    pub mod v1 {
-        include!("receipts.v1.rs");
-        // @@protoc_insertion_point(receipts.v1)
-    }
-}
diff --git a/substreams/substreams-trigger-filter/src/pb/receipts.v1.rs b/substreams/substreams-trigger-filter/src/pb/receipts.v1.rs
deleted file mode 100644
index 91e905a85b1..00000000000
--- a/substreams/substreams-trigger-filter/src/pb/receipts.v1.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockAndReceipts {
-    #[prost(message, optional, tag = "1")]
-    pub block: ::core::option::Option<
-        ::substreams_near_core::pb::sf::near::r#type::v1::Block,
-    >,
-    #[prost(message, repeated, tag = "2")]
-    pub outcome: ::prost::alloc::vec::Vec<
-        ::substreams_near_core::pb::sf::near::r#type::v1::ExecutionOutcomeWithId,
-    >,
-    #[prost(message, repeated, tag = "3")]
-    pub receipt: ::prost::alloc::vec::Vec<
-        ::substreams_near_core::pb::sf::near::r#type::v1::Receipt,
-    >,
-}
diff --git a/substreams/substreams-trigger-filter/src/pb/sf.near.type.v1.rs b/substreams/substreams-trigger-filter/src/pb/sf.near.type.v1.rs
deleted file mode 100644
index ed60d39b47e..00000000000
--- a/substreams/substreams-trigger-filter/src/pb/sf.near.type.v1.rs
+++ /dev/null
@@ -1,1181 +0,0 @@
-// @generated
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Block {
-    #[prost(string, tag="1")]
-    pub author: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
-    pub header: ::core::option::Option<BlockHeader>,
-    #[prost(message, repeated, tag="3")]
-    pub chunk_headers: ::prost::alloc::vec::Vec<ChunkHeader>,
-    #[prost(message, repeated, tag="4")]
-    pub shards: ::prost::alloc::vec::Vec<IndexerShard>,
-    #[prost(message, repeated, tag="5")]
-    pub state_changes: ::prost::alloc::vec::Vec<StateChangeWithCause>,
-}
-/// HeaderOnlyBlock is a standard \[Block\] structure where all other fields are
-/// removed so that hydrating that object from a \[Block\] bytes payload will
-/// drastically reduced allocated memory required to hold the full block.
-///
-/// This can be used to unpack a \[Block\] when only the \[BlockHeader\] information
-/// is required and greatly reduced required memory.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct HeaderOnlyBlock {
-    #[prost(message, optional, tag="2")]
-    pub header: ::core::option::Option<BlockHeader>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct StateChangeWithCause {
-    #[prost(message, optional, tag="1")]
-    pub value: ::core::option::Option<StateChangeValue>,
-    #[prost(message, optional, tag="2")]
-    pub cause: ::core::option::Option<StateChangeCause>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct StateChangeCause {
-    #[prost(oneof="state_change_cause::Cause", tags="1, 2, 3, 4, 5, 6, 7, 8, 9, 10")]
-    pub cause: ::core::option::Option<state_change_cause::Cause>,
-}
-/// Nested message and enum types in `StateChangeCause`.
-pub mod state_change_cause {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct NotWritableToDisk {
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct InitialState {
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct TransactionProcessing {
-        #[prost(message, optional, tag="1")]
-        pub tx_hash: ::core::option::Option<super::CryptoHash>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct ActionReceiptProcessingStarted {
-        #[prost(message, optional, tag="1")]
-        pub receipt_hash: ::core::option::Option<super::CryptoHash>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct ActionReceiptGasReward {
-        #[prost(message, optional, tag="1")]
-        pub tx_hash: ::core::option::Option<super::CryptoHash>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct ReceiptProcessing {
-        #[prost(message, optional, tag="1")]
-        pub tx_hash: ::core::option::Option<super::CryptoHash>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct PostponedReceipt {
-        #[prost(message, optional, tag="1")]
-        pub tx_hash: ::core::option::Option<super::CryptoHash>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct UpdatedDelayedReceipts {
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct ValidatorAccountsUpdate {
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct Migration {
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Cause {
-        #[prost(message, tag="1")]
-        NotWritableToDisk(NotWritableToDisk),
-        #[prost(message, tag="2")]
-        InitialState(InitialState),
-        #[prost(message, tag="3")]
-        TransactionProcessing(TransactionProcessing),
-        #[prost(message, tag="4")]
-        ActionReceiptProcessingStarted(ActionReceiptProcessingStarted),
-        #[prost(message, tag="5")]
-        ActionReceiptGasReward(ActionReceiptGasReward),
-        #[prost(message, tag="6")]
-        ReceiptProcessing(ReceiptProcessing),
-        #[prost(message, tag="7")]
-        PostponedReceipt(PostponedReceipt),
-        #[prost(message, tag="8")]
-        UpdatedDelayedReceipts(UpdatedDelayedReceipts),
-        #[prost(message, tag="9")]
-        ValidatorAccountsUpdate(ValidatorAccountsUpdate),
-        #[prost(message, tag="10")]
-        Migration(Migration),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct StateChangeValue {
-    #[prost(oneof="state_change_value::Value", tags="1, 2, 3, 4, 5, 6, 7, 8")]
-    pub value: ::core::option::Option<state_change_value::Value>,
-}
-/// Nested message and enum types in `StateChangeValue`.
-pub mod state_change_value {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct AccountUpdate {
-        #[prost(string, tag="1")]
-        pub account_id: ::prost::alloc::string::String,
-        #[prost(message, optional, tag="2")]
-        pub account: ::core::option::Option<super::Account>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct AccountDeletion {
-        #[prost(string, tag="1")]
-        pub account_id: ::prost::alloc::string::String,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct AccessKeyUpdate {
-        #[prost(string, tag="1")]
-        pub account_id: ::prost::alloc::string::String,
-        #[prost(message, optional, tag="2")]
-        pub public_key: ::core::option::Option<super::PublicKey>,
-        #[prost(message, optional, tag="3")]
-        pub access_key: ::core::option::Option<super::AccessKey>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct AccessKeyDeletion {
-        #[prost(string, tag="1")]
-        pub account_id: ::prost::alloc::string::String,
-        #[prost(message, optional, tag="2")]
-        pub public_key: ::core::option::Option<super::PublicKey>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct DataUpdate {
-        #[prost(string, tag="1")]
-        pub account_id: ::prost::alloc::string::String,
-        #[prost(bytes="vec", tag="2")]
-        pub key: ::prost::alloc::vec::Vec<u8>,
-        #[prost(bytes="vec", tag="3")]
-        pub value: ::prost::alloc::vec::Vec<u8>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct DataDeletion {
-        #[prost(string, tag="1")]
-        pub account_id: ::prost::alloc::string::String,
-        #[prost(bytes="vec", tag="2")]
-        pub key: ::prost::alloc::vec::Vec<u8>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct ContractCodeUpdate {
-        #[prost(string, tag="1")]
-        pub account_id: ::prost::alloc::string::String,
-        #[prost(bytes="vec", tag="2")]
-        pub code: ::prost::alloc::vec::Vec<u8>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct ContractCodeDeletion {
-        #[prost(string, tag="1")]
-        pub account_id: ::prost::alloc::string::String,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Value {
-        #[prost(message, tag="1")]
-        AccountUpdate(AccountUpdate),
-        #[prost(message, tag="2")]
-        AccountDeletion(AccountDeletion),
-        #[prost(message, tag="3")]
-        AccessKeyUpdate(AccessKeyUpdate),
-        #[prost(message, tag="4")]
-        AccessKeyDeletion(AccessKeyDeletion),
-        #[prost(message, tag="5")]
-        DataUpdate(DataUpdate),
-        #[prost(message, tag="6")]
-        DataDeletion(DataDeletion),
-        #[prost(message, tag="7")]
-        ContractCodeUpdate(ContractCodeUpdate),
-        #[prost(message, tag="8")]
-        ContractDeletion(ContractCodeDeletion),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Account {
-    #[prost(message, optional, tag="1")]
-    pub amount: ::core::option::Option<BigInt>,
-    #[prost(message, optional, tag="2")]
-    pub locked: ::core::option::Option<BigInt>,
-    #[prost(message, optional, tag="3")]
-    pub code_hash: ::core::option::Option<CryptoHash>,
-    #[prost(uint64, tag="4")]
-    pub storage_usage: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BlockHeader {
-    #[prost(uint64, tag="1")]
-    pub height: u64,
-    #[prost(uint64, tag="2")]
-    pub prev_height: u64,
-    #[prost(message, optional, tag="3")]
-    pub epoch_id: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="4")]
-    pub next_epoch_id: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="5")]
-    pub hash: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="6")]
-    pub prev_hash: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="7")]
-    pub prev_state_root: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="8")]
-    pub chunk_receipts_root: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="9")]
-    pub chunk_headers_root: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="10")]
-    pub chunk_tx_root: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="11")]
-    pub outcome_root: ::core::option::Option<CryptoHash>,
-    #[prost(uint64, tag="12")]
-    pub chunks_included: u64,
-    #[prost(message, optional, tag="13")]
-    pub challenges_root: ::core::option::Option<CryptoHash>,
-    #[prost(uint64, tag="14")]
-    pub timestamp: u64,
-    #[prost(uint64, tag="15")]
-    pub timestamp_nanosec: u64,
-    #[prost(message, optional, tag="16")]
-    pub random_value: ::core::option::Option<CryptoHash>,
-    #[prost(message, repeated, tag="17")]
-    pub validator_proposals: ::prost::alloc::vec::Vec<ValidatorStake>,
-    #[prost(bool, repeated, tag="18")]
-    pub chunk_mask: ::prost::alloc::vec::Vec<bool>,
-    #[prost(message, optional, tag="19")]
-    pub gas_price: ::core::option::Option<BigInt>,
-    #[prost(uint64, tag="20")]
-    pub block_ordinal: u64,
-    #[prost(message, optional, tag="21")]
-    pub total_supply: ::core::option::Option<BigInt>,
-    #[prost(message, repeated, tag="22")]
-    pub challenges_result: ::prost::alloc::vec::Vec<SlashedValidator>,
-    #[prost(uint64, tag="23")]
-    pub last_final_block_height: u64,
-    #[prost(message, optional, tag="24")]
-    pub last_final_block: ::core::option::Option<CryptoHash>,
-    #[prost(uint64, tag="25")]
-    pub last_ds_final_block_height: u64,
-    #[prost(message, optional, tag="26")]
-    pub last_ds_final_block: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="27")]
-    pub next_bp_hash: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="28")]
-    pub block_merkle_root: ::core::option::Option<CryptoHash>,
-    #[prost(bytes="vec", tag="29")]
-    pub epoch_sync_data_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, repeated, tag="30")]
-    pub approvals: ::prost::alloc::vec::Vec<Signature>,
-    #[prost(message, optional, tag="31")]
-    pub signature: ::core::option::Option<Signature>,
-    #[prost(uint32, tag="32")]
-    pub latest_protocol_version: u32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BigInt {
-    #[prost(bytes="vec", tag="1")]
-    pub bytes: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CryptoHash {
-    #[prost(bytes="vec", tag="1")]
-    pub bytes: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Signature {
-    #[prost(enumeration="CurveKind", tag="1")]
-    pub r#type: i32,
-    #[prost(bytes="vec", tag="2")]
-    pub bytes: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PublicKey {
-    #[prost(enumeration="CurveKind", tag="1")]
-    pub r#type: i32,
-    #[prost(bytes="vec", tag="2")]
-    pub bytes: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ValidatorStake {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
-    pub public_key: ::core::option::Option<PublicKey>,
-    #[prost(message, optional, tag="3")]
-    pub stake: ::core::option::Option<BigInt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SlashedValidator {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-    #[prost(bool, tag="2")]
-    pub is_double_sign: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ChunkHeader {
-    #[prost(bytes="vec", tag="1")]
-    pub chunk_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes="vec", tag="2")]
-    pub prev_block_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes="vec", tag="3")]
-    pub outcome_root: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes="vec", tag="4")]
-    pub prev_state_root: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes="vec", tag="5")]
-    pub encoded_merkle_root: ::prost::alloc::vec::Vec<u8>,
-    #[prost(uint64, tag="6")]
-    pub encoded_length: u64,
-    #[prost(uint64, tag="7")]
-    pub height_created: u64,
-    #[prost(uint64, tag="8")]
-    pub height_included: u64,
-    #[prost(uint64, tag="9")]
-    pub shard_id: u64,
-    #[prost(uint64, tag="10")]
-    pub gas_used: u64,
-    #[prost(uint64, tag="11")]
-    pub gas_limit: u64,
-    #[prost(message, optional, tag="12")]
-    pub validator_reward: ::core::option::Option<BigInt>,
-    #[prost(message, optional, tag="13")]
-    pub balance_burnt: ::core::option::Option<BigInt>,
-    #[prost(bytes="vec", tag="14")]
-    pub outgoing_receipts_root: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes="vec", tag="15")]
-    pub tx_root: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, repeated, tag="16")]
-    pub validator_proposals: ::prost::alloc::vec::Vec<ValidatorStake>,
-    #[prost(message, optional, tag="17")]
-    pub signature: ::core::option::Option<Signature>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IndexerShard {
-    #[prost(uint64, tag="1")]
-    pub shard_id: u64,
-    #[prost(message, optional, tag="2")]
-    pub chunk: ::core::option::Option<IndexerChunk>,
-    #[prost(message, repeated, tag="3")]
-    pub receipt_execution_outcomes: ::prost::alloc::vec::Vec<IndexerExecutionOutcomeWithReceipt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IndexerExecutionOutcomeWithReceipt {
-    #[prost(message, optional, tag="1")]
-    pub execution_outcome: ::core::option::Option<ExecutionOutcomeWithId>,
-    #[prost(message, optional, tag="2")]
-    pub receipt: ::core::option::Option<Receipt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IndexerChunk {
-    #[prost(string, tag="1")]
-    pub author: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
-    pub header: ::core::option::Option<ChunkHeader>,
-    #[prost(message, repeated, tag="3")]
-    pub transactions: ::prost::alloc::vec::Vec<IndexerTransactionWithOutcome>,
-    #[prost(message, repeated, tag="4")]
-    pub receipts: ::prost::alloc::vec::Vec<Receipt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IndexerTransactionWithOutcome {
-    #[prost(message, optional, tag="1")]
-    pub transaction: ::core::option::Option<SignedTransaction>,
-    #[prost(message, optional, tag="2")]
-    pub outcome: ::core::option::Option<IndexerExecutionOutcomeWithOptionalReceipt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SignedTransaction {
-    #[prost(string, tag="1")]
-    pub signer_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
-    pub public_key: ::core::option::Option<PublicKey>,
-    #[prost(uint64, tag="3")]
-    pub nonce: u64,
-    #[prost(string, tag="4")]
-    pub receiver_id: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag="5")]
-    pub actions: ::prost::alloc::vec::Vec<Action>,
-    #[prost(message, optional, tag="6")]
-    pub signature: ::core::option::Option<Signature>,
-    #[prost(message, optional, tag="7")]
-    pub hash: ::core::option::Option<CryptoHash>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IndexerExecutionOutcomeWithOptionalReceipt {
-    #[prost(message, optional, tag="1")]
-    pub execution_outcome: ::core::option::Option<ExecutionOutcomeWithId>,
-    #[prost(message, optional, tag="2")]
-    pub receipt: ::core::option::Option<Receipt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Receipt {
-    #[prost(string, tag="1")]
-    pub predecessor_id: ::prost::alloc::string::String,
-    #[prost(string, tag="2")]
-    pub receiver_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="3")]
-    pub receipt_id: ::core::option::Option<CryptoHash>,
-    #[prost(oneof="receipt::Receipt", tags="10, 11")]
-    pub receipt: ::core::option::Option<receipt::Receipt>,
-}
-/// Nested message and enum types in `Receipt`.
-pub mod receipt {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Receipt {
-        #[prost(message, tag="10")]
-        Action(super::ReceiptAction),
-        #[prost(message, tag="11")]
-        Data(super::ReceiptData),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ReceiptData {
-    #[prost(message, optional, tag="1")]
-    pub data_id: ::core::option::Option<CryptoHash>,
-    #[prost(bytes="vec", tag="2")]
-    pub data: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ReceiptAction {
-    #[prost(string, tag="1")]
-    pub signer_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
-    pub signer_public_key: ::core::option::Option<PublicKey>,
-    #[prost(message, optional, tag="3")]
-    pub gas_price: ::core::option::Option<BigInt>,
-    #[prost(message, repeated, tag="4")]
-    pub output_data_receivers: ::prost::alloc::vec::Vec<DataReceiver>,
-    #[prost(message, repeated, tag="5")]
-    pub input_data_ids: ::prost::alloc::vec::Vec<CryptoHash>,
-    #[prost(message, repeated, tag="6")]
-    pub actions: ::prost::alloc::vec::Vec<Action>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DataReceiver {
-    #[prost(message, optional, tag="1")]
-    pub data_id: ::core::option::Option<CryptoHash>,
-    #[prost(string, tag="2")]
-    pub receiver_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ExecutionOutcomeWithId {
-    #[prost(message, optional, tag="1")]
-    pub proof: ::core::option::Option<MerklePath>,
-    #[prost(message, optional, tag="2")]
-    pub block_hash: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="3")]
-    pub id: ::core::option::Option<CryptoHash>,
-    #[prost(message, optional, tag="4")]
-    pub outcome: ::core::option::Option<ExecutionOutcome>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ExecutionOutcome {
-    #[prost(string, repeated, tag="1")]
-    pub logs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(message, repeated, tag="2")]
-    pub receipt_ids: ::prost::alloc::vec::Vec<CryptoHash>,
-    #[prost(uint64, tag="3")]
-    pub gas_burnt: u64,
-    #[prost(message, optional, tag="4")]
-    pub tokens_burnt: ::core::option::Option<BigInt>,
-    #[prost(string, tag="5")]
-    pub executor_id: ::prost::alloc::string::String,
-    #[prost(enumeration="ExecutionMetadata", tag="6")]
-    pub metadata: i32,
-    #[prost(oneof="execution_outcome::Status", tags="20, 21, 22, 23")]
-    pub status: ::core::option::Option<execution_outcome::Status>,
-}
-/// Nested message and enum types in `ExecutionOutcome`.
-pub mod execution_outcome {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Status {
-        #[prost(message, tag="20")]
-        Unknown(super::UnknownExecutionStatus),
-        #[prost(message, tag="21")]
-        Failure(super::FailureExecutionStatus),
-        #[prost(message, tag="22")]
-        SuccessValue(super::SuccessValueExecutionStatus),
-        #[prost(message, tag="23")]
-        SuccessReceiptId(super::SuccessReceiptIdExecutionStatus),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SuccessValueExecutionStatus {
-    #[prost(bytes="vec", tag="1")]
-    pub value: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SuccessReceiptIdExecutionStatus {
-    #[prost(message, optional, tag="1")]
-    pub id: ::core::option::Option<CryptoHash>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct UnknownExecutionStatus {
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FailureExecutionStatus {
-    #[prost(oneof="failure_execution_status::Failure", tags="1, 2")]
-    pub failure: ::core::option::Option<failure_execution_status::Failure>,
-}
-/// Nested message and enum types in `FailureExecutionStatus`.
-pub mod failure_execution_status {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Failure {
-        #[prost(message, tag="1")]
-        ActionError(super::ActionError),
-        #[prost(enumeration="super::InvalidTxError", tag="2")]
-        InvalidTxError(i32),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ActionError {
-    #[prost(uint64, tag="1")]
-    pub index: u64,
-    #[prost(oneof="action_error::Kind", tags="21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42")]
-    pub kind: ::core::option::Option<action_error::Kind>,
-}
-/// Nested message and enum types in `ActionError`.
-pub mod action_error {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Kind {
-        #[prost(message, tag="21")]
-        AccountAlreadyExist(super::AccountAlreadyExistsErrorKind),
-        #[prost(message, tag="22")]
-        AccountDoesNotExist(super::AccountDoesNotExistErrorKind),
-        #[prost(message, tag="23")]
-        CreateAccountOnlyByRegistrar(super::CreateAccountOnlyByRegistrarErrorKind),
-        #[prost(message, tag="24")]
-        CreateAccountNotAllowed(super::CreateAccountNotAllowedErrorKind),
-        #[prost(message, tag="25")]
-        ActorNoPermission(super::ActorNoPermissionErrorKind),
-        #[prost(message, tag="26")]
-        DeleteKeyDoesNotExist(super::DeleteKeyDoesNotExistErrorKind),
-        #[prost(message, tag="27")]
-        AddKeyAlreadyExists(super::AddKeyAlreadyExistsErrorKind),
-        #[prost(message, tag="28")]
-        DeleteAccountStaking(super::DeleteAccountStakingErrorKind),
-        #[prost(message, tag="29")]
-        LackBalanceForState(super::LackBalanceForStateErrorKind),
-        #[prost(message, tag="30")]
-        TriesToUnstake(super::TriesToUnstakeErrorKind),
-        #[prost(message, tag="31")]
-        TriesToStake(super::TriesToStakeErrorKind),
-        #[prost(message, tag="32")]
-        InsufficientStake(super::InsufficientStakeErrorKind),
-        #[prost(message, tag="33")]
-        FunctionCall(super::FunctionCallErrorKind),
-        #[prost(message, tag="34")]
-        NewReceiptValidation(super::NewReceiptValidationErrorKind),
-        #[prost(message, tag="35")]
-        OnlyImplicitAccountCreationAllowed(super::OnlyImplicitAccountCreationAllowedErrorKind),
-        #[prost(message, tag="36")]
-        DeleteAccountWithLargeState(super::DeleteAccountWithLargeStateErrorKind),
-        #[prost(message, tag="37")]
-        DelegateActionInvalidSignature(super::DelegateActionInvalidSignatureKind),
-        #[prost(message, tag="38")]
-        DelegateActionSenderDoesNotMatchTxReceiver(super::DelegateActionSenderDoesNotMatchTxReceiverKind),
-        #[prost(message, tag="39")]
-        DelegateActionExpired(super::DelegateActionExpiredKind),
-        #[prost(message, tag="40")]
-        DelegateActionAccessKeyError(super::DelegateActionAccessKeyErrorKind),
-        #[prost(message, tag="41")]
-        DelegateActionInvalidNonce(super::DelegateActionInvalidNonceKind),
-        #[prost(message, tag="42")]
-        DelegateActionNonceTooLarge(super::DelegateActionNonceTooLargeKind),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AccountAlreadyExistsErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AccountDoesNotExistErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-}
-/// / A top-level account ID can only be created by registrar.
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CreateAccountOnlyByRegistrarErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-    #[prost(string, tag="2")]
-    pub registrar_account_id: ::prost::alloc::string::String,
-    #[prost(string, tag="3")]
-    pub predecessor_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CreateAccountNotAllowedErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-    #[prost(string, tag="2")]
-    pub predecessor_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ActorNoPermissionErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-    #[prost(string, tag="2")]
-    pub actor_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DeleteKeyDoesNotExistErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
-    pub public_key: ::core::option::Option<PublicKey>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AddKeyAlreadyExistsErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
-    pub public_key: ::core::option::Option<PublicKey>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DeleteAccountStakingErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LackBalanceForStateErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
-    pub balance: ::core::option::Option<BigInt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TriesToUnstakeErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TriesToStakeErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
-    pub stake: ::core::option::Option<BigInt>,
-    #[prost(message, optional, tag="3")]
-    pub locked: ::core::option::Option<BigInt>,
-    #[prost(message, optional, tag="4")]
-    pub balance: ::core::option::Option<BigInt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct InsufficientStakeErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
-    pub stake: ::core::option::Option<BigInt>,
-    #[prost(message, optional, tag="3")]
-    pub minimum_stake: ::core::option::Option<BigInt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FunctionCallErrorKind {
-    #[prost(enumeration="FunctionCallErrorSer", tag="1")]
-    pub error: i32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct NewReceiptValidationErrorKind {
-    #[prost(enumeration="ReceiptValidationError", tag="1")]
-    pub error: i32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct OnlyImplicitAccountCreationAllowedErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DeleteAccountWithLargeStateErrorKind {
-    #[prost(string, tag="1")]
-    pub account_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DelegateActionInvalidSignatureKind {
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DelegateActionSenderDoesNotMatchTxReceiverKind {
-    #[prost(string, tag="1")]
-    pub sender_id: ::prost::alloc::string::String,
-    #[prost(string, tag="2")]
-    pub receiver_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DelegateActionExpiredKind {
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DelegateActionAccessKeyErrorKind {
-    /// InvalidAccessKeyError
-    #[prost(enumeration="InvalidTxError", tag="1")]
-    pub error: i32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DelegateActionInvalidNonceKind {
-    #[prost(uint64, tag="1")]
-    pub delegate_nonce: u64,
-    #[prost(uint64, tag="2")]
-    pub ak_nonce: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DelegateActionNonceTooLargeKind {
-    #[prost(uint64, tag="1")]
-    pub delegate_nonce: u64,
-    #[prost(uint64, tag="2")]
-    pub upper_bound: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MerklePath {
-    #[prost(message, repeated, tag="1")]
-    pub path: ::prost::alloc::vec::Vec<MerklePathItem>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MerklePathItem {
-    #[prost(message, optional, tag="1")]
-    pub hash: ::core::option::Option<CryptoHash>,
-    #[prost(enumeration="Direction", tag="2")]
-    pub direction: i32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Action {
-    #[prost(oneof="action::Action", tags="1, 2, 3, 4, 5, 6, 7, 8, 9")]
-    pub action: ::core::option::Option<action::Action>,
-}
-/// Nested message and enum types in `Action`.
-pub mod action {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Action {
-        #[prost(message, tag="1")]
-        CreateAccount(super::CreateAccountAction),
-        #[prost(message, tag="2")]
-        DeployContract(super::DeployContractAction),
-        #[prost(message, tag="3")]
-        FunctionCall(super::FunctionCallAction),
-        #[prost(message, tag="4")]
-        Transfer(super::TransferAction),
-        #[prost(message, tag="5")]
-        Stake(super::StakeAction),
-        #[prost(message, tag="6")]
-        AddKey(super::AddKeyAction),
-        #[prost(message, tag="7")]
-        DeleteKey(super::DeleteKeyAction),
-        #[prost(message, tag="8")]
-        DeleteAccount(super::DeleteAccountAction),
-        #[prost(message, tag="9")]
-        Delegate(super::SignedDelegateAction),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CreateAccountAction {
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DeployContractAction {
-    #[prost(bytes="vec", tag="1")]
-    pub code: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FunctionCallAction {
-    #[prost(string, tag="1")]
-    pub method_name: ::prost::alloc::string::String,
-    #[prost(bytes="vec", tag="2")]
-    pub args: ::prost::alloc::vec::Vec<u8>,
-    #[prost(uint64, tag="3")]
-    pub gas: u64,
-    #[prost(message, optional, tag="4")]
-    pub deposit: ::core::option::Option<BigInt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TransferAction {
-    #[prost(message, optional, tag="1")]
-    pub deposit: ::core::option::Option<BigInt>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct StakeAction {
-    #[prost(message, optional, tag="1")]
-    pub stake: ::core::option::Option<BigInt>,
-    #[prost(message, optional, tag="2")]
-    pub public_key: ::core::option::Option<PublicKey>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AddKeyAction {
-    #[prost(message, optional, tag="1")]
-    pub public_key: ::core::option::Option<PublicKey>,
-    #[prost(message, optional, tag="2")]
-    pub access_key: ::core::option::Option<AccessKey>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DeleteKeyAction {
-    #[prost(message, optional, tag="1")]
-    pub public_key: ::core::option::Option<PublicKey>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DeleteAccountAction {
-    #[prost(string, tag="1")]
-    pub beneficiary_id: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SignedDelegateAction {
-    #[prost(message, optional, tag="1")]
-    pub signature: ::core::option::Option<Signature>,
-    #[prost(message, optional, tag="2")]
-    pub delegate_action: ::core::option::Option<DelegateAction>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DelegateAction {
-    #[prost(string, tag="1")]
-    pub sender_id: ::prost::alloc::string::String,
-    #[prost(string, tag="2")]
-    pub receiver_id: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag="3")]
-    pub actions: ::prost::alloc::vec::Vec<Action>,
-    #[prost(uint64, tag="4")]
-    pub nonce: u64,
-    #[prost(uint64, tag="5")]
-    pub max_block_height: u64,
-    #[prost(message, optional, tag="6")]
-    pub public_key: ::core::option::Option<PublicKey>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AccessKey {
-    #[prost(uint64, tag="1")]
-    pub nonce: u64,
-    #[prost(message, optional, tag="2")]
-    pub permission: ::core::option::Option<AccessKeyPermission>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AccessKeyPermission {
-    #[prost(oneof="access_key_permission::Permission", tags="1, 2")]
-    pub permission: ::core::option::Option<access_key_permission::Permission>,
-}
-/// Nested message and enum types in `AccessKeyPermission`.
-pub mod access_key_permission {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Permission {
-        #[prost(message, tag="1")]
-        FunctionCall(super::FunctionCallPermission),
-        #[prost(message, tag="2")]
-        FullAccess(super::FullAccessPermission),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FunctionCallPermission {
-    #[prost(message, optional, tag="1")]
-    pub allowance: ::core::option::Option<BigInt>,
-    #[prost(string, tag="2")]
-    pub receiver_id: ::prost::alloc::string::String,
-    #[prost(string, repeated, tag="3")]
-    pub method_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FullAccessPermission {
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum CurveKind {
-    Ed25519 = 0,
-    Secp256k1 = 1,
-}
-impl CurveKind {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            CurveKind::Ed25519 => "ED25519",
-            CurveKind::Secp256k1 => "SECP256K1",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "ED25519" => Some(Self::Ed25519),
-            "SECP256K1" => Some(Self::Secp256k1),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum ExecutionMetadata {
-    V1 = 0,
-}
-impl ExecutionMetadata {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            ExecutionMetadata::V1 => "ExecutionMetadataV1",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "ExecutionMetadataV1" => Some(Self::V1),
-            _ => None,
-        }
-    }
-}
-/// todo: add more detail?
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum FunctionCallErrorSer {
-    CompilationError = 0,
-    LinkError = 1,
-    MethodResolveError = 2,
-    WasmTrap = 3,
-    WasmUnknownError = 4,
-    HostError = 5,
-    EvmError = 6,
-    ExecutionError = 7,
-}
-impl FunctionCallErrorSer {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            FunctionCallErrorSer::CompilationError => "CompilationError",
-            FunctionCallErrorSer::LinkError => "LinkError",
-            FunctionCallErrorSer::MethodResolveError => "MethodResolveError",
-            FunctionCallErrorSer::WasmTrap => "WasmTrap",
-            FunctionCallErrorSer::WasmUnknownError => "WasmUnknownError",
-            FunctionCallErrorSer::HostError => "HostError",
-            FunctionCallErrorSer::EvmError => "_EVMError",
-            FunctionCallErrorSer::ExecutionError => "ExecutionError",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "CompilationError" => Some(Self::CompilationError),
-            "LinkError" => Some(Self::LinkError),
-            "MethodResolveError" => Some(Self::MethodResolveError),
-            "WasmTrap" => Some(Self::WasmTrap),
-            "WasmUnknownError" => Some(Self::WasmUnknownError),
-            "HostError" => Some(Self::HostError),
-            "_EVMError" => Some(Self::EvmError),
-            "ExecutionError" => Some(Self::ExecutionError),
-            _ => None,
-        }
-    }
-}
-/// todo: add more detail?
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum ReceiptValidationError {
-    InvalidPredecessorId = 0,
-    InvalidReceiverAccountId = 1,
-    InvalidSignerAccountId = 2,
-    InvalidDataReceiverId = 3,
-    ReturnedValueLengthExceeded = 4,
-    NumberInputDataDependenciesExceeded = 5,
-    ActionsValidationError = 6,
-}
-impl ReceiptValidationError {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            ReceiptValidationError::InvalidPredecessorId => "InvalidPredecessorId",
-            ReceiptValidationError::InvalidReceiverAccountId => "InvalidReceiverAccountId",
-            ReceiptValidationError::InvalidSignerAccountId => "InvalidSignerAccountId",
-            ReceiptValidationError::InvalidDataReceiverId => "InvalidDataReceiverId",
-            ReceiptValidationError::ReturnedValueLengthExceeded => "ReturnedValueLengthExceeded",
-            ReceiptValidationError::NumberInputDataDependenciesExceeded => "NumberInputDataDependenciesExceeded",
-            ReceiptValidationError::ActionsValidationError => "ActionsValidationError",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "InvalidPredecessorId" => Some(Self::InvalidPredecessorId),
-            "InvalidReceiverAccountId" => Some(Self::InvalidReceiverAccountId),
-            "InvalidSignerAccountId" => Some(Self::InvalidSignerAccountId),
-            "InvalidDataReceiverId" => Some(Self::InvalidDataReceiverId),
-            "ReturnedValueLengthExceeded" => Some(Self::ReturnedValueLengthExceeded),
-            "NumberInputDataDependenciesExceeded" => Some(Self::NumberInputDataDependenciesExceeded),
-            "ActionsValidationError" => Some(Self::ActionsValidationError),
-            _ => None,
-        }
-    }
-}
-/// todo: add more detail?
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum InvalidTxError {
-    InvalidAccessKeyError = 0,
-    InvalidSignerId = 1,
-    SignerDoesNotExist = 2,
-    InvalidNonce = 3,
-    NonceTooLarge = 4,
-    InvalidReceiverId = 5,
-    InvalidSignature = 6,
-    NotEnoughBalance = 7,
-    LackBalanceForState = 8,
-    CostOverflow = 9,
-    InvalidChain = 10,
-    Expired = 11,
-    ActionsValidation = 12,
-    TransactionSizeExceeded = 13,
-}
-impl InvalidTxError {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            InvalidTxError::InvalidAccessKeyError => "InvalidAccessKeyError",
-            InvalidTxError::InvalidSignerId => "InvalidSignerId",
-            InvalidTxError::SignerDoesNotExist => "SignerDoesNotExist",
-            InvalidTxError::InvalidNonce => "InvalidNonce",
-            InvalidTxError::NonceTooLarge => "NonceTooLarge",
-            InvalidTxError::InvalidReceiverId => "InvalidReceiverId",
-            InvalidTxError::InvalidSignature => "InvalidSignature",
-            InvalidTxError::NotEnoughBalance => "NotEnoughBalance",
-            InvalidTxError::LackBalanceForState => "LackBalanceForState",
-            InvalidTxError::CostOverflow => "CostOverflow",
-            InvalidTxError::InvalidChain => "InvalidChain",
-            InvalidTxError::Expired => "Expired",
-            InvalidTxError::ActionsValidation => "ActionsValidation",
-            InvalidTxError::TransactionSizeExceeded => "TransactionSizeExceeded",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "InvalidAccessKeyError" => Some(Self::InvalidAccessKeyError),
-            "InvalidSignerId" => Some(Self::InvalidSignerId),
-            "SignerDoesNotExist" => Some(Self::SignerDoesNotExist),
-            "InvalidNonce" => Some(Self::InvalidNonce),
-            "NonceTooLarge" => Some(Self::NonceTooLarge),
-            "InvalidReceiverId" => Some(Self::InvalidReceiverId),
-            "InvalidSignature" => Some(Self::InvalidSignature),
-            "NotEnoughBalance" => Some(Self::NotEnoughBalance),
-            "LackBalanceForState" => Some(Self::LackBalanceForState),
-            "CostOverflow" => Some(Self::CostOverflow),
-            "InvalidChain" => Some(Self::InvalidChain),
-            "Expired" => Some(Self::Expired),
-            "ActionsValidation" => Some(Self::ActionsValidation),
-            "TransactionSizeExceeded" => Some(Self::TransactionSizeExceeded),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum Direction {
-    Left = 0,
-    Right = 1,
-}
-impl Direction {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            Direction::Left => "left",
-            Direction::Right => "right",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "left" => Some(Self::Left),
-            "right" => Some(Self::Right),
-            _ => None,
-        }
-    }
-}
-// @@protoc_insertion_point(module)
diff --git a/substreams/substreams-trigger-filter/subgraph.yaml b/substreams/substreams-trigger-filter/subgraph.yaml
deleted file mode 100644
index 88bf9ebcd1e..00000000000
--- a/substreams/substreams-trigger-filter/subgraph.yaml
+++ /dev/null
@@ -1,16 +0,0 @@
-specVersion: 0.0.5
-description: NEAR Blocks Indexing
-repository: git@github.com:streamingfast/graph-node-dev.git
-schema:
-  file: ./schema.graphql
-dataSources:
-  - kind: substreams
-    name: hello-world
-    network: near-mainnet
-    source:
-      package:
-        moduleName: graph_out
-        file: substreams-near-hello-world-v0.1.0.spkg
-    mapping:
-      kind: substreams/graph-entities
-      apiVersion: 0.0.7
diff --git a/substreams/substreams-trigger-filter/substreams-trigger-filter-v0.1.0.spkg b/substreams/substreams-trigger-filter/substreams-trigger-filter-v0.1.0.spkg
deleted file mode 100644
index f1e733c6675..00000000000
Binary files a/substreams/substreams-trigger-filter/substreams-trigger-filter-v0.1.0.spkg and /dev/null differ
diff --git a/substreams/substreams-trigger-filter/substreams.yaml b/substreams/substreams-trigger-filter/substreams.yaml
deleted file mode 100755
index 6352bedce41..00000000000
--- a/substreams/substreams-trigger-filter/substreams.yaml
+++ /dev/null
@@ -1,37 +0,0 @@
-specVersion: v0.1.0
-package:
-  name: substreams_trigger_filter
-  version: v0.1.0
-
-imports:
-  near: https://github.com/streamingfast/firehose-near/releases/download/v1.1.0/substreams-near-v1.1.0.spkg
-
-protobuf:
-  files:
-    - receipts.proto
-    - near.proto
-  importPaths:
-    - ./proto
-
-binaries:
-  default:
-    type: wasm/rust-v1
-    file: ../../target/wasm32-unknown-unknown/release/substreams.wasm
-
-modules:
-  - name: near_filter
-    kind: map
-    initialBlock: 9820214
-    inputs:
-      - params: string
-      - source: sf.near.type.v1.Block
-    output:
-      type: proto:receipts.v1.Receipts
-  - name: graph_out
-    kind: map
-    initialBlock: 9820214
-    inputs:
-      - source: sf.near.type.v1.Block
-    output:
-      type: proto:sf.substreams.entity.v1.EntityChanges
-
diff --git a/substreams/trigger-filters/Cargo.toml b/substreams/trigger-filters/Cargo.toml
deleted file mode 100644
index b1f2db07772..00000000000
--- a/substreams/trigger-filters/Cargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "trigger-filters"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-anyhow = "1"
diff --git a/substreams/trigger-filters/src/lib.rs b/substreams/trigger-filters/src/lib.rs
deleted file mode 100644
index 81bb423f7f5..00000000000
--- a/substreams/trigger-filters/src/lib.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use anyhow::anyhow;
-use std::collections::HashSet;
-
-#[derive(Debug, Default, PartialEq)]
-pub struct NearFilter<'a> {
-    pub accounts: HashSet<&'a str>,
-    pub partial_accounts: HashSet<(Option<&'a str>, Option<&'a str>)>,
-}
-
-impl<'a> NearFilter<'a> {
-    pub fn matches(&self, account: &str) -> bool {
-        let partial_match = self.partial_accounts.iter().any(|partial| match partial {
-            (Some(prefix), Some(suffix)) => {
-                account.starts_with(prefix) && account.ends_with(suffix)
-            }
-            (Some(prefix), None) => account.starts_with(prefix),
-            (None, Some(suffix)) => account.ends_with(suffix),
-            (None, None) => unreachable!(),
-        });
-
-        if !self.accounts.contains(&account) && !partial_match {
-            return false;
-        }
-
-        true
-    }
-}
-
-impl<'a> TryFrom<&'a str> for NearFilter<'a> {
-    type Error = anyhow::Error;
-
-    fn try_from(params: &'a str) -> Result<Self, Self::Error> {
-        let mut accounts: HashSet<&str> = HashSet::default();
-        let mut partial_accounts: HashSet<(Option<&str>, Option<&str>)> = HashSet::default();
-        let mut lines = params.lines();
-        let mut header = lines
-            .next()
-            .ok_or(anyhow!("header line not present"))?
-            .split(",");
-        let accs_len: usize = header
-            .next()
-            .ok_or(anyhow!("header didn't have the expected format"))?
-            .parse()
-            .map_err(|_| anyhow!("accounts len is supposed to be a usize"))?;
-        let partials_len: usize = header
-            .next()
-            .ok_or(anyhow!("header didn't contain patials len"))?
-            .parse()
-            .map_err(|_| anyhow!("partials len is supposed to be a usize"))?;
-
-        let accs_line = lines.next();
-        if accs_len != 0 {
-            accounts.extend(
-                accs_line
-                    .ok_or(anyhow!("full matches line not found"))?
-                    .split(","),
-            );
-        }
-
-        if partials_len != 0 {
-            partial_accounts.extend(lines.take(partials_len).map(|line| {
-                let mut parts = line.split(",");
-                let start = match parts.next() {
-                    Some(x) if x.is_empty() => None,
-                    x => x,
-                };
-                let end = match parts.next() {
-                    Some(x) if x.is_empty() => None,
-                    x => x,
-                };
-                (start, end)
-            }));
-        }
-
-        Ok(NearFilter {
-            accounts,
-            partial_accounts,
-        })
-    }
-}
diff --git a/tests/.gitignore b/tests/.gitignore
index 2015ffcd748..b6f5b85637c 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -1,3 +1,5 @@
 contracts/cache/
+contracts/out/build-info/
 integration-tests/graph-node.log
 integration-tests/*/subgraph.yaml.patched
+runner-tests.log
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
index 856c739e803..547466909a5 100644
--- a/tests/Cargo.toml
+++ b/tests/Cargo.toml
@@ -6,29 +6,27 @@ edition.workspace = true
 [dependencies]
 anyhow = "1.0"
 assert-json-diff = "2.0.2"
-async-stream = "0.3.5"
-futures = { version = "0.3", features = ["compat"] }
+async-stream = "0.3.6"
+async-trait = { workspace = true }
 graph = { path = "../graph" }
 graph-chain-ethereum = { path = "../chain/ethereum" }
-graph-chain-substreams= {path = "../chain/substreams"}
 graph-node = { path = "../node" }
 graph-core = { path = "../core" }
 graph-graphql = { path = "../graphql" }
 graph-store-postgres = { path = "../store/postgres" }
-graph-runtime-wasm = { path = "../runtime/wasm" }
 graph-server-index-node = { path = "../server/index-node" }
-graphql-parser = "0.4.0"
-hyper = "0.14"
-serde = "1.0"
-serde_yaml = "0.9.21"
-slog = { version = "2.7.0", features = ["release_max_level_trace", "max_level_trace"] }
-tokio = { version = "1.35.1", features = ["rt", "macros", "process"] }
-# Once graph upgrades to web3 0.19, we don't need this anymore. The version
-# here needs to be kept in sync with the web3 version that the graph crate
-# uses until then
-secp256k1 = { version = "0.21", features = ["recovery"] }
-termcolor = "1.4.0"
+graph-runtime-wasm = { path = "../runtime/wasm" }
+serde = { workspace = true }
+serde_yaml = { workspace = true }
+slog = { workspace = true }
+slog-async = { workspace = true }
+slog-term = { workspace = true }
+tokio = { version = "1.50.0", features = ["rt", "macros", "process"] }
+tokio-util.workspace = true
 
 [dev-dependencies]
-anyhow = "1.0.75"
+anyhow = "1.0.102"
 tokio-stream = "0.1"
+
+[lints]
+workspace = true
diff --git a/tests/README.md b/tests/README.md
index 2c0f38ce796..c9ffd9b6a8e 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -15,7 +15,7 @@ In addition, the tests require the following:
 
 - `graph-node` must have already been built using `cargo build` and must be
   present at `../target/debug/graph-node`
-- `yarn` (v1) must be installed and on the `PATH`
+- `pnpm` must be installed and on the `PATH`
 
 Once these prerequisites are in place, the tests can be run using:
 
@@ -60,7 +60,7 @@ must be declared as `contract FooContract` in the Solidity source.
 
 ### Testing different version of Graph CLI
 
-The integration tests project is built as Yarn (v1) Workspace, so all dependencies are installed at once for all tests.
+The integration tests project is built as a PNPM Workspace, so all dependencies are installed at once for all tests.
 
 We can still control the version of the Graph CLI installed for each test, by changing the versions of `@graphprotocol/graph-cli` / `@graphprotocol/graph-ts` in `package.json`.
 
diff --git a/tests/common/1_initial_migration.js b/tests/common/1_initial_migration.js
deleted file mode 100644
index 1eb6f9daf69..00000000000
--- a/tests/common/1_initial_migration.js
+++ /dev/null
@@ -1,5 +0,0 @@
-var Migrations = artifacts.require('./Migrations.sol')
-
-module.exports = function(deployer) {
-  deployer.deploy(Migrations)
-}
diff --git a/tests/common/2_deploy_contracts.js b/tests/common/2_deploy_contracts.js
deleted file mode 100644
index ffe0359c95a..00000000000
--- a/tests/common/2_deploy_contracts.js
+++ /dev/null
@@ -1,5 +0,0 @@
-const Contract = artifacts.require('./Contract.sol')
-
-module.exports = async function(deployer) {
-  await deployer.deploy(Contract)
-}
diff --git a/tests/common/Migrations.sol b/tests/common/Migrations.sol
deleted file mode 100644
index 0b571c8e442..00000000000
--- a/tests/common/Migrations.sol
+++ /dev/null
@@ -1,23 +0,0 @@
-pragma solidity ^0.8.0;
-
-contract Migrations {
-  address public owner;
-  uint public last_completed_migration;
-
-  constructor() public {
-    owner = msg.sender;
-  }
-
-  modifier restricted() {
-    if (msg.sender == owner) _;
-  }
-
-  function setCompleted(uint completed) public restricted {
-    last_completed_migration = completed;
-  }
-
-  function upgrade(address new_address) public restricted {
-    Migrations upgraded = Migrations(new_address);
-    upgraded.setCompleted(last_completed_migration);
-  }
-}
diff --git a/tests/common/SimpleContract.sol b/tests/common/SimpleContract.sol
deleted file mode 100644
index c649e8bd864..00000000000
--- a/tests/common/SimpleContract.sol
+++ /dev/null
@@ -1,14 +0,0 @@
-pragma solidity ^0.8.0;
-
-
-contract Contract {
-    event Trigger(uint16 x);
-
-    constructor() public {
-        emit Trigger(0);
-    }
-
-    function emitTrigger(uint16 x) public {
-        emit Trigger(x);
-    }
-}
diff --git a/tests/common/build-contracts.sh b/tests/common/build-contracts.sh
deleted file mode 100755
index 2f35aacc11b..00000000000
--- a/tests/common/build-contracts.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-
-# Builds Solidity contracts for graph-node integration tests.
-#
-# This script is meant to be callde as a yarn "script", defined in each "package.json"
-# file, found on every test subdirectory.
-#
-# It ensures that all integration tests subdirectories have no pre-built artifacts
-# (abis, bin, generated and build directories), and will exctract ABIs and BINs for
-# the artifacts built by truffle.
-
-set -euo pipefail
-
-# Cleanup target directories
-rm -rf abis build generated
-
-# Compile contracts into a temporary directory
-yarn truffle compile
-
-# Move abi to a directory expected by graph-node
-mkdir -p abis bin
-jq -r '.abi' truffle_output/Contract.json > abis/Contract.abi
diff --git a/tests/contracts/abis/DeclaredCallsContract.json b/tests/contracts/abis/DeclaredCallsContract.json
new file mode 100644
index 00000000000..5cce19559ef
--- /dev/null
+++ b/tests/contracts/abis/DeclaredCallsContract.json
@@ -0,0 +1,532 @@
+[
+  {
+    "type": "constructor",
+    "inputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "alwaysReverts",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "assetOwners",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "assets",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "addr",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "active",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "balanceOf",
+    "inputs": [
+      {
+        "name": "account",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "balances",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "conditionalRevert",
+    "inputs": [],
+    "outputs": [],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "counter",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "emitAssetTransfer",
+    "inputs": [
+      {
+        "name": "assetAddr",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "amount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "active",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "emitComplexAssetCreated",
+    "inputs": [
+      {
+        "name": "baseAddr",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "baseAmount",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "baseActive",
+        "type": "bool",
+        "internalType": "bool"
+      },
+      {
+        "name": "metadataStr",
+        "type": "string",
+        "internalType": "string"
+      },
+      {
+        "name": "values",
+        "type": "uint256[]",
+        "internalType": "uint256[]"
+      },
+      {
+        "name": "id",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "emitTransfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "getAssetAmount",
+    "inputs": [
+      {
+        "name": "assetId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getConstant",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "getMetadata",
+    "inputs": [
+      {
+        "name": "assetAddr",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "getOwner",
+    "inputs": [
+      {
+        "name": "assetAddr",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "hiddenFunction",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "incrementCounter",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "isAssetActive",
+    "inputs": [
+      {
+        "name": "assetId",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "metadata",
+    "inputs": [
+      {
+        "name": "",
+        "type": "address",
+        "internalType": "address"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "setShouldRevert",
+    "inputs": [
+      {
+        "name": "_shouldRevert",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "shouldRevert",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "bool",
+        "internalType": "bool"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "function",
+    "name": "sum",
+    "inputs": [
+      {
+        "name": "a",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "b",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "totalSupply",
+    "inputs": [],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "view"
+  },
+  {
+    "type": "event",
+    "name": "AssetTransfer",
+    "inputs": [
+      {
+        "name": "asset",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct DeclaredCallsContract.Asset",
+        "components": [
+          {
+            "name": "addr",
+            "type": "address",
+            "internalType": "address"
+          },
+          {
+            "name": "amount",
+            "type": "uint256",
+            "internalType": "uint256"
+          },
+          {
+            "name": "active",
+            "type": "bool",
+            "internalType": "bool"
+          }
+        ]
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": false,
+        "internalType": "address"
+      },
+      {
+        "name": "blockNumber",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "ComplexAssetCreated",
+    "inputs": [
+      {
+        "name": "complexAsset",
+        "type": "tuple",
+        "indexed": false,
+        "internalType": "struct DeclaredCallsContract.ComplexAsset",
+        "components": [
+          {
+            "name": "base",
+            "type": "tuple",
+            "internalType": "struct DeclaredCallsContract.Asset",
+            "components": [
+              {
+                "name": "addr",
+                "type": "address",
+                "internalType": "address"
+              },
+              {
+                "name": "amount",
+                "type": "uint256",
+                "internalType": "uint256"
+              },
+              {
+                "name": "active",
+                "type": "bool",
+                "internalType": "bool"
+              }
+            ]
+          },
+          {
+            "name": "metadata",
+            "type": "string",
+            "internalType": "string"
+          },
+          {
+            "name": "values",
+            "type": "uint256[]",
+            "internalType": "uint256[]"
+          }
+        ]
+      },
+      {
+        "name": "id",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Transfer",
+    "inputs": [
+      {
+        "name": "from",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "to",
+        "type": "address",
+        "indexed": true,
+        "internalType": "address"
+      },
+      {
+        "name": "value",
+        "type": "uint256",
+        "indexed": false,
+        "internalType": "uint256"
+      }
+    ],
+    "anonymous": false
+  }
+]
diff --git a/tests/contracts/abis/LimitedContract.json b/tests/contracts/abis/LimitedContract.json
new file mode 100644
index 00000000000..6d68554ebad
--- /dev/null
+++ b/tests/contracts/abis/LimitedContract.json
@@ -0,0 +1,32 @@
+[
+  {
+    "type": "constructor",
+    "inputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "inc",
+    "inputs": [
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "event",
+    "name": "Trigger",
+    "inputs": [],
+    "anonymous": false
+  }
+]
diff --git a/tests/contracts/abis/OverloadedContract.json b/tests/contracts/abis/OverloadedContract.json
new file mode 100644
index 00000000000..3c9efcf5215
--- /dev/null
+++ b/tests/contracts/abis/OverloadedContract.json
@@ -0,0 +1,70 @@
+[
+  {
+    "type": "constructor",
+    "inputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "exampleFunction",
+    "inputs": [
+      {
+        "name": "",
+        "type": "bytes32",
+        "internalType": "bytes32"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "exampleFunction",
+    "inputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "function",
+    "name": "exampleFunction",
+    "inputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "event",
+    "name": "Trigger",
+    "inputs": [],
+    "anonymous": false
+  }
+]
diff --git a/tests/contracts/abis/RevertingContract.json b/tests/contracts/abis/RevertingContract.json
new file mode 100644
index 00000000000..6d68554ebad
--- /dev/null
+++ b/tests/contracts/abis/RevertingContract.json
@@ -0,0 +1,32 @@
+[
+  {
+    "type": "constructor",
+    "inputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "inc",
+    "inputs": [
+      {
+        "name": "value",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "",
+        "type": "uint256",
+        "internalType": "uint256"
+      }
+    ],
+    "stateMutability": "pure"
+  },
+  {
+    "type": "event",
+    "name": "Trigger",
+    "inputs": [],
+    "anonymous": false
+  }
+]
diff --git a/tests/contracts/abis/SimpleContract.json b/tests/contracts/abis/SimpleContract.json
new file mode 100644
index 00000000000..a977654ad89
--- /dev/null
+++ b/tests/contracts/abis/SimpleContract.json
@@ -0,0 +1,92 @@
+[
+  {
+    "type": "constructor",
+    "inputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "emitAnotherTrigger",
+    "inputs": [
+      {
+        "name": "a",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "b",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "c",
+        "type": "uint256",
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "string",
+        "internalType": "string"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "function",
+    "name": "emitTrigger",
+    "inputs": [
+      {
+        "name": "x",
+        "type": "uint16",
+        "internalType": "uint16"
+      }
+    ],
+    "outputs": [],
+    "stateMutability": "nonpayable"
+  },
+  {
+    "type": "event",
+    "name": "AnotherTrigger",
+    "inputs": [
+      {
+        "name": "a",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "b",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "c",
+        "type": "uint256",
+        "indexed": true,
+        "internalType": "uint256"
+      },
+      {
+        "name": "data",
+        "type": "string",
+        "indexed": false,
+        "internalType": "string"
+      }
+    ],
+    "anonymous": false
+  },
+  {
+    "type": "event",
+    "name": "Trigger",
+    "inputs": [
+      {
+        "name": "x",
+        "type": "uint16",
+        "indexed": false,
+        "internalType": "uint16"
+      }
+    ],
+    "anonymous": false
+  }
+]
diff --git a/tests/contracts/out/DeclaredCallsContract.sol/DeclaredCallsContract.json b/tests/contracts/out/DeclaredCallsContract.sol/DeclaredCallsContract.json
new file mode 100644
index 00000000000..f88227bbd17
--- /dev/null
+++ b/tests/contracts/out/DeclaredCallsContract.sol/DeclaredCallsContract.json
@@ -0,0 +1 @@
+{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"alwaysReverts","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"pure"},{"type":"function","name":"assetOwners","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"assets","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"addr","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"active","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"balanceOf","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"balances","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"conditionalRevert","inputs":[],"outputs":[],"stateMutability":"view"},{"type":"function","name":"counter","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"emitAssetTransfer","inputs":[{"name":"assetAddr","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"active","type":"bool","internalType":"bool"},{"name":"to","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"emitComplexAssetCreated","inputs":[{"name":"baseAddr","type":"address","internalType":"address"},{"name":"baseAmount","type":"uint256","internalType":"uint256"},{"name":"baseActive","type":"bool","internalType":"bool"},{"name":"metadataStr","type":"string","internalType":"string"},{"name":"values","type":"uint256[]","internalType":"uint256[]"},{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"emitTransfer","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"getAssetAmount","inputs":[{"name":"assetId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"getConstant","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"function","name":"getMetadata","inputs":[{"name":"assetAddr","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"type":"function","name":"getOwner","inputs":[{"name":"assetAddr","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"hiddenFunction","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"function","name":"incrementCounter","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"type":"function","name":"isAssetActive","inputs":[{"name":"assetId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"metadata","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"type":"function","name":"setShouldRevert","inputs":[{"name":"_shouldRevert","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"shouldRevert","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"sum","inputs":[{"name":"a","type":"uint256","internalType":"uint256"},{"name":"b","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"function","name":"totalSupply","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"event","name":"AssetTransfer","inputs":[{"name":"asset","type":"tuple","indexed":false,"internalType":"struct DeclaredCallsContract.Asset","components":[{"name":"addr","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"active","type":"bool","internalType":"bool"}]},{"name":"to","type":"address","indexed":false,"internalType":"address"},{"name":"blockNumber","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"ComplexAssetCreated","inputs":[{"name":"complexAsset","type":"tuple","indexed":false,"internalType":"struct DeclaredCallsContract.ComplexAsset","components":[{"name":"base","type":"tuple","internalType":"struct DeclaredCallsContract.Asset","components":[{"name":"addr","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"active","type":"bool","internalType":"bool"}]},{"name":"metadata","type":"string","internalType":"string"},{"name":"values","type":"uint256[]","internalType":"uint256[]"}]},{"name":"id","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"Transfer","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false}],"bytecode":{"object":"0x60806040525f60055f6101000a81548160ff0219169083151502179055505f6006553480156200002d575f80fd5b506103e85f803373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055506103e85f8073111111111111111111111111111111111111111173ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055506103e85f8073222222222222222222222222222222222222222273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550610bb8600481905550604051806060016040528073111111111111111111111111111111111111111173ffffffffffffffffffffffffffffffffffffffff168152602001606481526020016001151581525060025f600181526020019081526020015f205f820151815f015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550602082015181600101556040820151816002015f6101000a81548160ff0219169083151502179055509050503360035f600181526020019081526020015f205f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040518060400160405280600c81526020017f546573742041737365742031000000000000000000000000000000000000000081525060015f73111111111111111111111111111111111111111173ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f209081620002d89190620006f3565b50604051806060016040528073222222222222222222222222222222222222222273ffffffffffffffffffffffffffffffffffffffff16815260200160c881526020015f151581525060025f600281526020019081526020015f205f820151815f015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550602082015181600101556040820151816002015f6101000a81548160ff0219169083151502179055509050503360035f600281526020019081526020015f205f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040518060400160405280600c81526020017f546573742041737365742032000000000000000000000000000000000000000081525060015f73222222222222222222222222222222222222222273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f209081620004889190620006f3565b50620007d7565b5f81519050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f60028204905060018216806200050b57607f821691505b602082108103620005215762000520620004c6565b5b50919050565b5f819050815f5260205f209050919050565b5f6020601f8301049050919050565b5f82821b905092915050565b5f60088302620005857fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8262000548565b62000591868362000548565b95508019841693508086168417925050509392505050565b5f819050919050565b5f819050919050565b5f620005db620005d5620005cf84620005a9565b620005b2565b620005a9565b9050919050565b5f819050919050565b620005f683620005bb565b6200060e6200060582620005e2565b84845462000554565b825550505050565b5f90565b6200062462000616565b62000631818484620005eb565b505050565b5b8181101562000658576200064c5f826200061a565b60018101905062000637565b5050565b601f821115620006a757620006718162000527565b6200067c8462000539565b810160208510156200068c578190505b620006a46200069b8562000539565b83018262000636565b50505b505050565b5f82821c905092915050565b5f620006c95f1984600802620006ac565b1980831691505092915050565b5f620006e38383620006b8565b9150826002028217905092915050565b620006fe826200048f565b67ffffffffffffffff8111156200071a576200071962000499565b5b620007268254620004f3565b620007338282856200065c565b5f60209050601f83116001811462000769575f841562000754578287015190505b620007608582620006d6565b865550620007cf565b601f198416620007798662000527565b5f5b82811015620007a2578489015182556001820191506020850194506020810190506200077b565b86831015620007c25784890151620007be601f891682620006b8565b8355505b6001600288020188555050505b505050505050565b6115dd80620007e55f395ff3fe608060405234801561000f575f80fd5b5060043610610140575f3560e01c806370a08231116100b6578063cad0899b1161007a578063cad0899b14610388578063cd63468a146103b8578063cf35bdd0146103d4578063d3072d8214610406578063f13a38a614610424578063fa5441611461044257610140565b806370a08231146102e257806392eaff8314610312578063a718c0d914610342578063b4f5537d14610360578063bcd0aaf81461037e57610140565b80632ba21572116101085780632ba215721461020e5780634d6f99821461023e5780635b34b9661461025a57806361bc221a146102785780636813d787146102965780636999f843146102b257610140565b806318160ddd1461014457806322e900c21461016257806323de66511461019257806327e235e3146101ae5780632a50c146146101de575b5f80fd5b61014c610472565b6040516101599190610b16565b60405180910390f35b61017c60048036038101906101779190610b6a565b610478565b6040516101899190610baf565b60405180910390f35b6101ac60048036038101906101a79190610c22565b6104a1565b005b6101c860048036038101906101c39190610c72565b6105af565b6040516101d59190610b16565b60405180910390f35b6101f860048036038101906101f39190610c72565b6105c3565b6040516102059190610d27565b60405180910390f35b61022860048036038101906102239190610c72565b610690565b6040516102359190610d27565b60405180910390f35b61025860048036038101906102539190610d71565b61072b565b005b6102626107a3565b60405161026f9190610b16565b60405180910390f35b6102806107c3565b60405161028d9190610b16565b60405180910390f35b6102b060048036038101906102ab9190610dd5565b6107c9565b005b6102cc60048036038101906102c79190610b6a565b6107e5565b6040516102d99190610e0f565b60405180910390f35b6102fc60048036038101906102f79190610c72565b610815565b6040516103099190610b16565b60405180910390f35b61032c60048036038101906103279190610b6a565b61085a565b6040516103399190610b16565b60405180910390f35b61034a610877565b6040516103579190610b16565b60405180910390f35b610368610880565b6040516103759190610baf565b60405180910390f35b6103866108cc565b005b6103a2600480360381019061039d9190610e28565b61091d565b6040516103af9190610b16565b60405180910390f35b6103d260048036038101906103cd9190611056565b610932565b005b6103ee60048036038101906103e99190610b6a565b6109c9565b6040516103fd93929190611117565b60405180910390f35b61040e610a1a565b60405161041b9190610baf565b60405180910390f35b61042c610a2c565b6040516104399190610b16565b60405180910390f35b61045c60048036038101906104579190610c72565b610a34565b6040516104699190610e0f565b60405180910390f35b60045481565b5f60025f8381526020019081526020015f206002015f9054906101000a900460ff169050919050565b805f808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8282546104ec9190611179565b92505081905550805f808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825461053e91906111ac565b925050819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516105a29190610b16565b60405180910390a3505050565b5f602052805f5260405f205f915090505481565b606060015f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20805461060d9061120c565b80601f01602080910402602001604051908101604052809291908181526020018280546106399061120c565b80156106845780601f1061065b57610100808354040283529160200191610684565b820191905f5260205f20905b81548152906001019060200180831161066757829003601f168201915b50505050509050919050565b6001602052805f5260405f205f9150905080546106ac9061120c565b80601f01602080910402602001604051908101604052809291908181526020018280546106d89061120c565b80156107235780601f106106fa57610100808354040283529160200191610723565b820191905f5260205f20905b81548152906001019060200180831161070657829003601f168201915b505050505081565b5f60405180606001604052808673ffffffffffffffffffffffffffffffffffffffff16815260200185815260200184151581525090507fb316a05559699c6f7bf707596924f7a3dbcdda140602bdecdcf504da557b5a00818343604051610794939291906112a9565b60405180910390a15050505050565b5f60065f8154809291906107b6906112de565b9190505550600654905090565b60065481565b8060055f6101000a81548160ff02191690831515021790555050565b6003602052805f5260405f205f915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f805f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050919050565b5f60025f8381526020019081526020015f20600101549050919050565b5f6103e7905090565b5f80600111156108c5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108bc9061136f565b60405180910390fd5b6001905090565b60055f9054906101000a900460ff161561091b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610912906113d7565b60405180910390fd5b565b5f818361092a91906111ac565b905092915050565b5f60405180606001604052808873ffffffffffffffffffffffffffffffffffffffff16815260200187815260200186151581525090505f60405180606001604052808381526020018681526020018581525090507f22bbb405fdf09441de4475115f78ff52520e05a54678d2e90981609fcff4c77781846040516109b7929190611579565b60405180910390a15050505050505050565b6002602052805f5260405f205f91509050805f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690806001015490806002015f9054906101000a900460ff16905083565b60055f9054906101000a900460ff1681565b5f602a905090565b5f80600190505b600a8111610af4578273ffffffffffffffffffffffffffffffffffffffff1660025f8381526020019081526020015f205f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1603610ae15760035f8281526020019081526020015f205f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16915050610af9565b8080610aec906112de565b915050610a3b565b505f90505b919050565b5f819050919050565b610b1081610afe565b82525050565b5f602082019050610b295f830184610b07565b92915050565b5f604051905090565b5f80fd5b5f80fd5b610b4981610afe565b8114610b53575f80fd5b50565b5f81359050610b6481610b40565b92915050565b5f60208284031215610b7f57610b7e610b38565b5b5f610b8c84828501610b56565b91505092915050565b5f8115159050919050565b610ba981610b95565b82525050565b5f602082019050610bc25f830184610ba0565b92915050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f610bf182610bc8565b9050919050565b610c0181610be7565b8114610c0b575f80fd5b50565b5f81359050610c1c81610bf8565b92915050565b5f805f60608486031215610c3957610c38610b38565b5b5f610c4686828701610c0e565b9350506020610c5786828701610c0e565b9250506040610c6886828701610b56565b9150509250925092565b5f60208284031215610c8757610c86610b38565b5b5f610c9484828501610c0e565b91505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f5b83811015610cd4578082015181840152602081019050610cb9565b5f8484015250505050565b5f601f19601f8301169050919050565b5f610cf982610c9d565b610d038185610ca7565b9350610d13818560208601610cb7565b610d1c81610cdf565b840191505092915050565b5f6020820190508181035f830152610d3f8184610cef565b905092915050565b610d5081610b95565b8114610d5a575f80fd5b50565b5f81359050610d6b81610d47565b92915050565b5f805f8060808587031215610d8957610d88610b38565b5b5f610d9687828801610c0e565b9450506020610da787828801610b56565b9350506040610db887828801610d5d565b9250506060610dc987828801610c0e565b91505092959194509250565b5f60208284031215610dea57610de9610b38565b5b5f610df784828501610d5d565b91505092915050565b610e0981610be7565b82525050565b5f602082019050610e225f830184610e00565b92915050565b5f8060408385031215610e3e57610e3d610b38565b5b5f610e4b85828601610b56565b9250506020610e5c85828601610b56565b9150509250929050565b5f80fd5b5f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b610ea482610cdf565b810181811067ffffffffffffffff82111715610ec357610ec2610e6e565b5b80604052505050565b5f610ed5610b2f565b9050610ee18282610e9b565b919050565b5f67ffffffffffffffff821115610f0057610eff610e6e565b5b610f0982610cdf565b9050602081019050919050565b828183375f83830152505050565b5f610f36610f3184610ee6565b610ecc565b905082815260208101848484011115610f5257610f51610e6a565b5b610f5d848285610f16565b509392505050565b5f82601f830112610f7957610f78610e66565b5b8135610f89848260208601610f24565b91505092915050565b5f67ffffffffffffffff821115610fac57610fab610e6e565b5b602082029050602081019050919050565b5f80fd5b5f610fd3610fce84610f92565b610ecc565b90508083825260208201905060208402830185811115610ff657610ff5610fbd565b5b835b8181101561101f578061100b8882610b56565b845260208401935050602081019050610ff8565b5050509392505050565b5f82601f83011261103d5761103c610e66565b5b813561104d848260208601610fc1565b91505092915050565b5f805f805f8060c087890312156110705761106f610b38565b5b5f61107d89828a01610c0e565b965050602061108e89828a01610b56565b955050604061109f89828a01610d5d565b945050606087013567ffffffffffffffff8111156110c0576110bf610b3c565b5b6110cc89828a01610f65565b935050608087013567ffffffffffffffff8111156110ed576110ec610b3c565b5b6110f989828a01611029565b92505060a061110a89828a01610b56565b9150509295509295509295565b5f60608201905061112a5f830186610e00565b6111376020830185610b07565b6111446040830184610ba0565b949350505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61118382610afe565b915061118e83610afe565b92508282039050818111156111a6576111a561114c565b5b92915050565b5f6111b682610afe565b91506111c183610afe565b92508282019050808211156111d9576111d861114c565b5b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f600282049050600182168061122357607f821691505b602082108103611236576112356111df565b5b50919050565b61124581610be7565b82525050565b61125481610afe565b82525050565b61126381610b95565b82525050565b606082015f82015161127d5f85018261123c565b506020820151611290602085018261124b565b5060408201516112a3604085018261125a565b50505050565b5f60a0820190506112bc5f830186611269565b6112c96060830185610e00565b6112d66080830184610b07565b949350505050565b5f6112e882610afe565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361131a5761131961114c565b5b600182019050919050565b7f546869732066756e6374696f6e20616c776179732072657665727473000000005f82015250565b5f611359601c83610ca7565b915061136482611325565b602082019050919050565b5f6020820190508181035f8301526113868161134d565b9050919050565b7f436f6e646974696f6e616c2072657665727420747269676765726564000000005f82015250565b5f6113c1601c83610ca7565b91506113cc8261138d565b602082019050919050565b5f6020820190508181035f8301526113ee816113b5565b9050919050565b606082015f8201516114095f85018261123c565b50602082015161141c602085018261124b565b50604082015161142f604085018261125a565b50505050565b5f82825260208201905092915050565b5f61144f82610c9d565b6114598185611435565b9350611469818560208601610cb7565b61147281610cdf565b840191505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b5f6114b1838361124b565b60208301905092915050565b5f602082019050919050565b5f6114d38261147d565b6114dd8185611487565b93506114e883611497565b805f5b838110156115185781516114ff88826114a6565b975061150a836114bd565b9250506001810190506114eb565b5085935050505092915050565b5f60a083015f83015161153a5f8601826113f5565b50602083015184820360608601526115528282611445565b9150506040830151848203608086015261156c82826114c9565b9150508091505092915050565b5f6040820190508181035f8301526115918185611525565b90506115a06020830184610b07565b939250505056fea26469706673582212205465cabdbb10fd7ab5c349f524281ac28f3a7e329ede907a8787a65051b4a20a64736f6c63430008160033","sourceMap":"57:4967:0:-:0;;;1050:5;1023:32;;;;;;;;;;;;;;;;;;;;1086:1;1061:26;;1094:933;;;;;;;;;;1178:4;1155:8;:20;1164:10;1155:20;;;;;;;;;;;;;;;:27;;;;1256:4;1192:8;:61;1209:42;1192:61;;;;;;;;;;;;;;;:68;;;;1334:4;1270:8;:61;1287:42;1270:61;;;;;;;;;;;;;;;:68;;;;1362:4;1348:11;:18;;;;1424:139;;;;;;;;1458:42;1424:139;;;;;;1523:3;1424:139;;;;1548:4;1424:139;;;;;1412:6;:9;1419:1;1412:9;;;;;;;;;;;:151;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1590:10;1573:11;:14;1585:1;1573:14;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;1610:100;;;;;;;;;;;;;;;;;:8;:83;1640:42;1610:83;;;;;;;;;;;;;;;:100;;;;;;:::i;:::-;;1733:140;;;;;;;;1767:42;1733:140;;;;;;1832:3;1733:140;;;;1857:5;1733:140;;;;;1721:6;:9;1728:1;1721:9;;;;;;;;;;;:152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1900:10;1883:11;:14;1895:1;1883:14;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;1920:100;;;;;;;;;;;;;;;;;:8;:83;1950:42;1920:83;;;;;;;;;;;;;;;:100;;;;;;:::i;:::-;;57:4967;;7:99:1;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:180::-;160:77;157:1;150:88;257:4;254:1;247:15;281:4;278:1;271:15;298:180;346:77;343:1;336:88;443:4;440:1;433:15;467:4;464:1;457:15;484:320;528:6;565:1;559:4;555:12;545:22;;612:1;606:4;602:12;633:18;623:81;;689:4;681:6;677:17;667:27;;623:81;751:2;743:6;740:14;720:18;717:38;714:84;;770:18;;:::i;:::-;714:84;535:269;484:320;;;:::o;810:141::-;859:4;882:3;874:11;;905:3;902:1;895:14;939:4;936:1;926:18;918:26;;810:141;;;:::o;957:93::-;994:6;1041:2;1036;1029:5;1025:14;1021:23;1011:33;;957:93;;;:::o;1056:107::-;1100:8;1150:5;1144:4;1140:16;1119:37;;1056:107;;;;:::o;1169:393::-;1238:6;1288:1;1276:10;1272:18;1311:97;1341:66;1330:9;1311:97;:::i;:::-;1429:39;1459:8;1448:9;1429:39;:::i;:::-;1417:51;;1501:4;1497:9;1490:5;1486:21;1477:30;;1550:4;1540:8;1536:19;1529:5;1526:30;1516:40;;1245:317;;1169:393;;;;;:::o;1568:77::-;1605:7;1634:5;1623:16;;1568:77;;;:::o;1651:60::-;1679:3;1700:5;1693:12;;1651:60;;;:::o;1717:142::-;1767:9;1800:53;1818:34;1827:24;1845:5;1827:24;:::i;:::-;1818:34;:::i;:::-;1800:53;:::i;:::-;1787:66;;1717:142;;;:::o;1865:75::-;1908:3;1929:5;1922:12;;1865:75;;;:::o;1946:269::-;2056:39;2087:7;2056:39;:::i;:::-;2117:91;2166:41;2190:16;2166:41;:::i;:::-;2158:6;2151:4;2145:11;2117:91;:::i;:::-;2111:4;2104:105;2022:193;1946:269;;;:::o;2221:73::-;2266:3;2221:73;:::o;2300:189::-;2377:32;;:::i;:::-;2418:65;2476:6;2468;2462:4;2418:65;:::i;:::-;2353:136;2300:189;;:::o;2495:186::-;2555:120;2572:3;2565:5;2562:14;2555:120;;;2626:39;2663:1;2656:5;2626:39;:::i;:::-;2599:1;2592:5;2588:13;2579:22;;2555:120;;;2495:186;;:::o;2687:543::-;2788:2;2783:3;2780:11;2777:446;;;2822:38;2854:5;2822:38;:::i;:::-;2906:29;2924:10;2906:29;:::i;:::-;2896:8;2892:44;3089:2;3077:10;3074:18;3071:49;;;3110:8;3095:23;;3071:49;3133:80;3189:22;3207:3;3189:22;:::i;:::-;3179:8;3175:37;3162:11;3133:80;:::i;:::-;2792:431;;2777:446;2687:543;;;:::o;3236:117::-;3290:8;3340:5;3334:4;3330:16;3309:37;;3236:117;;;;:::o;3359:169::-;3403:6;3436:51;3484:1;3480:6;3472:5;3469:1;3465:13;3436:51;:::i;:::-;3432:56;3517:4;3511;3507:15;3497:25;;3410:118;3359:169;;;;:::o;3533:295::-;3609:4;3755:29;3780:3;3774:4;3755:29;:::i;:::-;3747:37;;3817:3;3814:1;3810:11;3804:4;3801:21;3793:29;;3533:295;;;;:::o;3833:1395::-;3950:37;3983:3;3950:37;:::i;:::-;4052:18;4044:6;4041:30;4038:56;;;4074:18;;:::i;:::-;4038:56;4118:38;4150:4;4144:11;4118:38;:::i;:::-;4203:67;4263:6;4255;4249:4;4203:67;:::i;:::-;4297:1;4321:4;4308:17;;4353:2;4345:6;4342:14;4370:1;4365:618;;;;5027:1;5044:6;5041:77;;;5093:9;5088:3;5084:19;5078:26;5069:35;;5041:77;5144:67;5204:6;5197:5;5144:67;:::i;:::-;5138:4;5131:81;5000:222;4335:887;;4365:618;4417:4;4413:9;4405:6;4401:22;4451:37;4483:4;4451:37;:::i;:::-;4510:1;4524:208;4538:7;4535:1;4532:14;4524:208;;;4617:9;4612:3;4608:19;4602:26;4594:6;4587:42;4668:1;4660:6;4656:14;4646:24;;4715:2;4704:9;4700:18;4687:31;;4561:4;4558:1;4554:12;4549:17;;4524:208;;;4760:6;4751:7;4748:19;4745:179;;;4818:9;4813:3;4809:19;4803:26;4861:48;4903:4;4895:6;4891:17;4880:9;4861:48;:::i;:::-;4853:6;4846:64;4768:156;4745:179;4970:1;4966;4958:6;4954:14;4950:22;4944:4;4937:36;4372:611;;;4335:887;;3925:1303;;;3833:1395;;:::o;57:4967:0:-;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"57:4967:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;955:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2769:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3394:181;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;761:43;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2507:133;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;810:42;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3581:325;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3241:103;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1061:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4522:97;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;903:46;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2083:107;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2646:117;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4939:83;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2928:163;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3097:138;;;:::i;:::-;;4710:94;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3912:579;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;858:39;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;1023:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4625:79;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2196:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;955:26;;;;:::o;2769:113::-;2830:4;2853:6;:15;2860:7;2853:15;;;;;;;;;;;:22;;;;;;;;;;;;2846:29;;2769:113;;;:::o;3394:181::-;3492:5;3474:8;:14;3483:4;3474:14;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;3523:5;3507:8;:12;3516:2;3507:12;;;;;;;;;;;;;;;;:21;;;;;;;:::i;:::-;;;;;;;;3558:2;3543:25;;3552:4;3543:25;;;3562:5;3543:25;;;;;;:::i;:::-;;;;;;;;3394:181;;;:::o;761:43::-;;;;;;;;;;;;;;;;;:::o;2507:133::-;2582:13;2614:8;:19;2623:9;2614:19;;;;;;;;;;;;;;;2607:26;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2507:133;;;:::o;810:42::-;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3581:325::-;3723:18;3744:102;;;;;;;;3770:9;3744:102;;;;;;3801:6;3744:102;;;;3829:6;3744:102;;;;;3723:123;;3861:38;3875:5;3882:2;3886:12;3861:38;;;;;;;;:::i;:::-;;;;;;;;3713:193;3581:325;;;;:::o;3241:103::-;3285:7;3304;;:9;;;;;;;;;:::i;:::-;;;;;;3330:7;;3323:14;;3241:103;:::o;1061:26::-;;;;:::o;4522:97::-;4599:13;4584:12;;:28;;;;;;;;;;;;;;;;;;4522:97;:::o;903:46::-;;;;;;;;;;;;;;;;;;;;;;:::o;2083:107::-;2140:7;2166:8;:17;2175:7;2166:17;;;;;;;;;;;;;;;;2159:24;;2083:107;;;:::o;2646:117::-;2708:7;2734:6;:15;2741:7;2734:15;;;;;;;;;;;:22;;;2727:29;;2646:117;;;:::o;4939:83::-;4986:7;5012:3;5005:10;;4939:83;:::o;2928:163::-;2974:4;2998:1;2994;:5;2990:74;;;3015:38;;;;;;;;;;:::i;:::-;;;;;;;;2990:74;3080:4;3073:11;;2928:163;:::o;3097:138::-;3152:12;;;;;;;;;;;3148:81;;;3180:38;;;;;;;;;;:::i;:::-;;;;;;;;3148:81;3097:138::o;4710:94::-;4766:7;4796:1;4792;:5;;;;:::i;:::-;4785:12;;4710:94;;;;:::o;3912:579::-;4135:22;4160:109;;;;;;;;4186:8;4160:109;;;;;;4216:10;4160:109;;;;4248:10;4160:109;;;;;4135:134;;4280:32;4315:116;;;;;;;;4348:9;4315:116;;;;4381:11;4315:116;;;;4414:6;4315:116;;;4280:151;;4447:37;4467:12;4481:2;4447:37;;;;;;;:::i;:::-;;;;;;;;4125:366;;3912:579;;;;;;:::o;858:39::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1023:32::-;;;;;;;;;;;;;:::o;4625:79::-;4669:7;4695:2;4688:9;;4625:79;:::o;2196:305::-;2254:7;2328:9;2340:1;2328:13;;2323:145;2348:2;2343:1;:7;2323:145;;2393:9;2375:27;;:6;:9;2382:1;2375:9;;;;;;;;;;;:14;;;;;;;;;;;;:27;;;2371:87;;2429:11;:14;2441:1;2429:14;;;;;;;;;;;;;;;;;;;;;2422:21;;;;;2371:87;2352:3;;;;;:::i;:::-;;;;2323:145;;;;2492:1;2477:17;;2196:305;;;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:75::-;475:6;508:2;502:9;492:19;;442:75;:::o;523:117::-;632:1;629;622:12;646:117;755:1;752;745:12;769:122;842:24;860:5;842:24;:::i;:::-;835:5;832:35;822:63;;881:1;878;871:12;822:63;769:122;:::o;897:139::-;943:5;981:6;968:20;959:29;;997:33;1024:5;997:33;:::i;:::-;897:139;;;;:::o;1042:329::-;1101:6;1150:2;1138:9;1129:7;1125:23;1121:32;1118:119;;;1156:79;;:::i;:::-;1118:119;1276:1;1301:53;1346:7;1337:6;1326:9;1322:22;1301:53;:::i;:::-;1291:63;;1247:117;1042:329;;;;:::o;1377:90::-;1411:7;1454:5;1447:13;1440:21;1429:32;;1377:90;;;:::o;1473:109::-;1554:21;1569:5;1554:21;:::i;:::-;1549:3;1542:34;1473:109;;:::o;1588:210::-;1675:4;1713:2;1702:9;1698:18;1690:26;;1726:65;1788:1;1777:9;1773:17;1764:6;1726:65;:::i;:::-;1588:210;;;;:::o;1804:126::-;1841:7;1881:42;1874:5;1870:54;1859:65;;1804:126;;;:::o;1936:96::-;1973:7;2002:24;2020:5;2002:24;:::i;:::-;1991:35;;1936:96;;;:::o;2038:122::-;2111:24;2129:5;2111:24;:::i;:::-;2104:5;2101:35;2091:63;;2150:1;2147;2140:12;2091:63;2038:122;:::o;2166:139::-;2212:5;2250:6;2237:20;2228:29;;2266:33;2293:5;2266:33;:::i;:::-;2166:139;;;;:::o;2311:619::-;2388:6;2396;2404;2453:2;2441:9;2432:7;2428:23;2424:32;2421:119;;;2459:79;;:::i;:::-;2421:119;2579:1;2604:53;2649:7;2640:6;2629:9;2625:22;2604:53;:::i;:::-;2594:63;;2550:117;2706:2;2732:53;2777:7;2768:6;2757:9;2753:22;2732:53;:::i;:::-;2722:63;;2677:118;2834:2;2860:53;2905:7;2896:6;2885:9;2881:22;2860:53;:::i;:::-;2850:63;;2805:118;2311:619;;;;;:::o;2936:329::-;2995:6;3044:2;3032:9;3023:7;3019:23;3015:32;3012:119;;;3050:79;;:::i;:::-;3012:119;3170:1;3195:53;3240:7;3231:6;3220:9;3216:22;3195:53;:::i;:::-;3185:63;;3141:117;2936:329;;;;:::o;3271:99::-;3323:6;3357:5;3351:12;3341:22;;3271:99;;;:::o;3376:169::-;3460:11;3494:6;3489:3;3482:19;3534:4;3529:3;3525:14;3510:29;;3376:169;;;;:::o;3551:246::-;3632:1;3642:113;3656:6;3653:1;3650:13;3642:113;;;3741:1;3736:3;3732:11;3726:18;3722:1;3717:3;3713:11;3706:39;3678:2;3675:1;3671:10;3666:15;;3642:113;;;3789:1;3780:6;3775:3;3771:16;3764:27;3613:184;3551:246;;;:::o;3803:102::-;3844:6;3895:2;3891:7;3886:2;3879:5;3875:14;3871:28;3861:38;;3803:102;;;:::o;3911:377::-;3999:3;4027:39;4060:5;4027:39;:::i;:::-;4082:71;4146:6;4141:3;4082:71;:::i;:::-;4075:78;;4162:65;4220:6;4215:3;4208:4;4201:5;4197:16;4162:65;:::i;:::-;4252:29;4274:6;4252:29;:::i;:::-;4247:3;4243:39;4236:46;;4003:285;3911:377;;;;:::o;4294:313::-;4407:4;4445:2;4434:9;4430:18;4422:26;;4494:9;4488:4;4484:20;4480:1;4469:9;4465:17;4458:47;4522:78;4595:4;4586:6;4522:78;:::i;:::-;4514:86;;4294:313;;;;:::o;4613:116::-;4683:21;4698:5;4683:21;:::i;:::-;4676:5;4673:32;4663:60;;4719:1;4716;4709:12;4663:60;4613:116;:::o;4735:133::-;4778:5;4816:6;4803:20;4794:29;;4832:30;4856:5;4832:30;:::i;:::-;4735:133;;;;:::o;4874:759::-;4957:6;4965;4973;4981;5030:3;5018:9;5009:7;5005:23;5001:33;4998:120;;;5037:79;;:::i;:::-;4998:120;5157:1;5182:53;5227:7;5218:6;5207:9;5203:22;5182:53;:::i;:::-;5172:63;;5128:117;5284:2;5310:53;5355:7;5346:6;5335:9;5331:22;5310:53;:::i;:::-;5300:63;;5255:118;5412:2;5438:50;5480:7;5471:6;5460:9;5456:22;5438:50;:::i;:::-;5428:60;;5383:115;5537:2;5563:53;5608:7;5599:6;5588:9;5584:22;5563:53;:::i;:::-;5553:63;;5508:118;4874:759;;;;;;;:::o;5639:323::-;5695:6;5744:2;5732:9;5723:7;5719:23;5715:32;5712:119;;;5750:79;;:::i;:::-;5712:119;5870:1;5895:50;5937:7;5928:6;5917:9;5913:22;5895:50;:::i;:::-;5885:60;;5841:114;5639:323;;;;:::o;5968:118::-;6055:24;6073:5;6055:24;:::i;:::-;6050:3;6043:37;5968:118;;:::o;6092:222::-;6185:4;6223:2;6212:9;6208:18;6200:26;;6236:71;6304:1;6293:9;6289:17;6280:6;6236:71;:::i;:::-;6092:222;;;;:::o;6320:474::-;6388:6;6396;6445:2;6433:9;6424:7;6420:23;6416:32;6413:119;;;6451:79;;:::i;:::-;6413:119;6571:1;6596:53;6641:7;6632:6;6621:9;6617:22;6596:53;:::i;:::-;6586:63;;6542:117;6698:2;6724:53;6769:7;6760:6;6749:9;6745:22;6724:53;:::i;:::-;6714:63;;6669:118;6320:474;;;;;:::o;6800:117::-;6909:1;6906;6899:12;6923:117;7032:1;7029;7022:12;7046:180;7094:77;7091:1;7084:88;7191:4;7188:1;7181:15;7215:4;7212:1;7205:15;7232:281;7315:27;7337:4;7315:27;:::i;:::-;7307:6;7303:40;7445:6;7433:10;7430:22;7409:18;7397:10;7394:34;7391:62;7388:88;;;7456:18;;:::i;:::-;7388:88;7496:10;7492:2;7485:22;7275:238;7232:281;;:::o;7519:129::-;7553:6;7580:20;;:::i;:::-;7570:30;;7609:33;7637:4;7629:6;7609:33;:::i;:::-;7519:129;;;:::o;7654:308::-;7716:4;7806:18;7798:6;7795:30;7792:56;;;7828:18;;:::i;:::-;7792:56;7866:29;7888:6;7866:29;:::i;:::-;7858:37;;7950:4;7944;7940:15;7932:23;;7654:308;;;:::o;7968:146::-;8065:6;8060:3;8055;8042:30;8106:1;8097:6;8092:3;8088:16;8081:27;7968:146;;;:::o;8120:425::-;8198:5;8223:66;8239:49;8281:6;8239:49;:::i;:::-;8223:66;:::i;:::-;8214:75;;8312:6;8305:5;8298:21;8350:4;8343:5;8339:16;8388:3;8379:6;8374:3;8370:16;8367:25;8364:112;;;8395:79;;:::i;:::-;8364:112;8485:54;8532:6;8527:3;8522;8485:54;:::i;:::-;8204:341;8120:425;;;;;:::o;8565:340::-;8621:5;8670:3;8663:4;8655:6;8651:17;8647:27;8637:122;;8678:79;;:::i;:::-;8637:122;8795:6;8782:20;8820:79;8895:3;8887:6;8880:4;8872:6;8868:17;8820:79;:::i;:::-;8811:88;;8627:278;8565:340;;;;:::o;8911:311::-;8988:4;9078:18;9070:6;9067:30;9064:56;;;9100:18;;:::i;:::-;9064:56;9150:4;9142:6;9138:17;9130:25;;9210:4;9204;9200:15;9192:23;;8911:311;;;:::o;9228:117::-;9337:1;9334;9327:12;9368:710;9464:5;9489:81;9505:64;9562:6;9505:64;:::i;:::-;9489:81;:::i;:::-;9480:90;;9590:5;9619:6;9612:5;9605:21;9653:4;9646:5;9642:16;9635:23;;9706:4;9698:6;9694:17;9686:6;9682:30;9735:3;9727:6;9724:15;9721:122;;;9754:79;;:::i;:::-;9721:122;9869:6;9852:220;9886:6;9881:3;9878:15;9852:220;;;9961:3;9990:37;10023:3;10011:10;9990:37;:::i;:::-;9985:3;9978:50;10057:4;10052:3;10048:14;10041:21;;9928:144;9912:4;9907:3;9903:14;9896:21;;9852:220;;;9856:21;9470:608;;9368:710;;;;;:::o;10101:370::-;10172:5;10221:3;10214:4;10206:6;10202:17;10198:27;10188:122;;10229:79;;:::i;:::-;10188:122;10346:6;10333:20;10371:94;10461:3;10453:6;10446:4;10438:6;10434:17;10371:94;:::i;:::-;10362:103;;10178:293;10101:370;;;;:::o;10477:1441::-;10613:6;10621;10629;10637;10645;10653;10702:3;10690:9;10681:7;10677:23;10673:33;10670:120;;;10709:79;;:::i;:::-;10670:120;10829:1;10854:53;10899:7;10890:6;10879:9;10875:22;10854:53;:::i;:::-;10844:63;;10800:117;10956:2;10982:53;11027:7;11018:6;11007:9;11003:22;10982:53;:::i;:::-;10972:63;;10927:118;11084:2;11110:50;11152:7;11143:6;11132:9;11128:22;11110:50;:::i;:::-;11100:60;;11055:115;11237:2;11226:9;11222:18;11209:32;11268:18;11260:6;11257:30;11254:117;;;11290:79;;:::i;:::-;11254:117;11395:63;11450:7;11441:6;11430:9;11426:22;11395:63;:::i;:::-;11385:73;;11180:288;11535:3;11524:9;11520:19;11507:33;11567:18;11559:6;11556:30;11553:117;;;11589:79;;:::i;:::-;11553:117;11694:78;11764:7;11755:6;11744:9;11740:22;11694:78;:::i;:::-;11684:88;;11478:304;11821:3;11848:53;11893:7;11884:6;11873:9;11869:22;11848:53;:::i;:::-;11838:63;;11792:119;10477:1441;;;;;;;;:::o;11924:430::-;12067:4;12105:2;12094:9;12090:18;12082:26;;12118:71;12186:1;12175:9;12171:17;12162:6;12118:71;:::i;:::-;12199:72;12267:2;12256:9;12252:18;12243:6;12199:72;:::i;:::-;12281:66;12343:2;12332:9;12328:18;12319:6;12281:66;:::i;:::-;11924:430;;;;;;:::o;12360:180::-;12408:77;12405:1;12398:88;12505:4;12502:1;12495:15;12529:4;12526:1;12519:15;12546:194;12586:4;12606:20;12624:1;12606:20;:::i;:::-;12601:25;;12640:20;12658:1;12640:20;:::i;:::-;12635:25;;12684:1;12681;12677:9;12669:17;;12708:1;12702:4;12699:11;12696:37;;;12713:18;;:::i;:::-;12696:37;12546:194;;;;:::o;12746:191::-;12786:3;12805:20;12823:1;12805:20;:::i;:::-;12800:25;;12839:20;12857:1;12839:20;:::i;:::-;12834:25;;12882:1;12879;12875:9;12868:16;;12903:3;12900:1;12897:10;12894:36;;;12910:18;;:::i;:::-;12894:36;12746:191;;;;:::o;12943:180::-;12991:77;12988:1;12981:88;13088:4;13085:1;13078:15;13112:4;13109:1;13102:15;13129:320;13173:6;13210:1;13204:4;13200:12;13190:22;;13257:1;13251:4;13247:12;13278:18;13268:81;;13334:4;13326:6;13322:17;13312:27;;13268:81;13396:2;13388:6;13385:14;13365:18;13362:38;13359:84;;13415:18;;:::i;:::-;13359:84;13180:269;13129:320;;;:::o;13455:108::-;13532:24;13550:5;13532:24;:::i;:::-;13527:3;13520:37;13455:108;;:::o;13569:::-;13646:24;13664:5;13646:24;:::i;:::-;13641:3;13634:37;13569:108;;:::o;13683:99::-;13754:21;13769:5;13754:21;:::i;:::-;13749:3;13742:34;13683:99;;:::o;13868:669::-;14005:4;14000:3;13996:14;14092:4;14085:5;14081:16;14075:23;14111:63;14168:4;14163:3;14159:14;14145:12;14111:63;:::i;:::-;14020:164;14268:4;14261:5;14257:16;14251:23;14287:63;14344:4;14339:3;14335:14;14321:12;14287:63;:::i;:::-;14194:166;14444:4;14437:5;14433:16;14427:23;14463:57;14514:4;14509:3;14505:14;14491:12;14463:57;:::i;:::-;14370:160;13974:563;13868:669;;:::o;14543:524::-;14732:4;14770:3;14759:9;14755:19;14747:27;;14784:111;14892:1;14881:9;14877:17;14868:6;14784:111;:::i;:::-;14905:72;14973:2;14962:9;14958:18;14949:6;14905:72;:::i;:::-;14987:73;15055:3;15044:9;15040:19;15031:6;14987:73;:::i;:::-;14543:524;;;;;;:::o;15073:233::-;15112:3;15135:24;15153:5;15135:24;:::i;:::-;15126:33;;15181:66;15174:5;15171:77;15168:103;;15251:18;;:::i;:::-;15168:103;15298:1;15291:5;15287:13;15280:20;;15073:233;;;:::o;15312:178::-;15452:30;15448:1;15440:6;15436:14;15429:54;15312:178;:::o;15496:366::-;15638:3;15659:67;15723:2;15718:3;15659:67;:::i;:::-;15652:74;;15735:93;15824:3;15735:93;:::i;:::-;15853:2;15848:3;15844:12;15837:19;;15496:366;;;:::o;15868:419::-;16034:4;16072:2;16061:9;16057:18;16049:26;;16121:9;16115:4;16111:20;16107:1;16096:9;16092:17;16085:47;16149:131;16275:4;16149:131;:::i;:::-;16141:139;;15868:419;;;:::o;16293:178::-;16433:30;16429:1;16421:6;16417:14;16410:54;16293:178;:::o;16477:366::-;16619:3;16640:67;16704:2;16699:3;16640:67;:::i;:::-;16633:74;;16716:93;16805:3;16716:93;:::i;:::-;16834:2;16829:3;16825:12;16818:19;;16477:366;;;:::o;16849:419::-;17015:4;17053:2;17042:9;17038:18;17030:26;;17102:9;17096:4;17092:20;17088:1;17077:9;17073:17;17066:47;17130:131;17256:4;17130:131;:::i;:::-;17122:139;;16849:419;;;:::o;17354:659::-;17481:4;17476:3;17472:14;17568:4;17561:5;17557:16;17551:23;17587:63;17644:4;17639:3;17635:14;17621:12;17587:63;:::i;:::-;17496:164;17744:4;17737:5;17733:16;17727:23;17763:63;17820:4;17815:3;17811:14;17797:12;17763:63;:::i;:::-;17670:166;17920:4;17913:5;17909:16;17903:23;17939:57;17990:4;17985:3;17981:14;17967:12;17939:57;:::i;:::-;17846:160;17450:563;17354:659;;:::o;18019:159::-;18093:11;18127:6;18122:3;18115:19;18167:4;18162:3;18158:14;18143:29;;18019:159;;;;:::o;18184:357::-;18262:3;18290:39;18323:5;18290:39;:::i;:::-;18345:61;18399:6;18394:3;18345:61;:::i;:::-;18338:68;;18415:65;18473:6;18468:3;18461:4;18454:5;18450:16;18415:65;:::i;:::-;18505:29;18527:6;18505:29;:::i;:::-;18500:3;18496:39;18489:46;;18266:275;18184:357;;;;:::o;18547:114::-;18614:6;18648:5;18642:12;18632:22;;18547:114;;;:::o;18667:174::-;18756:11;18790:6;18785:3;18778:19;18830:4;18825:3;18821:14;18806:29;;18667:174;;;;:::o;18847:132::-;18914:4;18937:3;18929:11;;18967:4;18962:3;18958:14;18950:22;;18847:132;;;:::o;18985:179::-;19054:10;19075:46;19117:3;19109:6;19075:46;:::i;:::-;19153:4;19148:3;19144:14;19130:28;;18985:179;;;;:::o;19170:113::-;19240:4;19272;19267:3;19263:14;19255:22;;19170:113;;;:::o;19319:712::-;19428:3;19457:54;19505:5;19457:54;:::i;:::-;19527:76;19596:6;19591:3;19527:76;:::i;:::-;19520:83;;19627:56;19677:5;19627:56;:::i;:::-;19706:7;19737:1;19722:284;19747:6;19744:1;19741:13;19722:284;;;19823:6;19817:13;19850:63;19909:3;19894:13;19850:63;:::i;:::-;19843:70;;19936:60;19989:6;19936:60;:::i;:::-;19926:70;;19782:224;19769:1;19766;19762:9;19757:14;;19722:284;;;19726:14;20022:3;20015:10;;19433:598;;;19319:712;;;;:::o;20131:933::-;20256:3;20292:4;20287:3;20283:14;20379:4;20372:5;20368:16;20362:23;20398:103;20495:4;20490:3;20486:14;20472:12;20398:103;:::i;:::-;20307:204;20597:4;20590:5;20586:16;20580:23;20650:3;20644:4;20640:14;20633:4;20628:3;20624:14;20617:38;20676:73;20744:4;20730:12;20676:73;:::i;:::-;20668:81;;20521:239;20844:4;20837:5;20833:16;20827:23;20897:3;20891:4;20887:14;20880:4;20875:3;20871:14;20864:38;20923:103;21021:4;21007:12;20923:103;:::i;:::-;20915:111;;20770:267;21054:4;21047:11;;20261:803;20131:933;;;;:::o;21070:495::-;21247:4;21285:2;21274:9;21270:18;21262:26;;21334:9;21328:4;21324:20;21320:1;21309:9;21305:17;21298:47;21362:114;21471:4;21462:6;21362:114;:::i;:::-;21354:122;;21486:72;21554:2;21543:9;21539:18;21530:6;21486:72;:::i;:::-;21070:495;;;;;:::o","linkReferences":{}},"methodIdentifiers":{"alwaysReverts()":"b4f5537d","assetOwners(uint256)":"6999f843","assets(uint256)":"cf35bdd0","balanceOf(address)":"70a08231","balances(address)":"27e235e3","conditionalRevert()":"bcd0aaf8","counter()":"61bc221a","emitAssetTransfer(address,uint256,bool,address)":"4d6f9982","emitComplexAssetCreated(address,uint256,bool,string,uint256[],uint256)":"cd63468a","emitTransfer(address,address,uint256)":"23de6651","getAssetAmount(uint256)":"92eaff83","getConstant()":"f13a38a6","getMetadata(address)":"2a50c146","getOwner(address)":"fa544161","hiddenFunction()":"a718c0d9","incrementCounter()":"5b34b966","isAssetActive(uint256)":"22e900c2","metadata(address)":"2ba21572","setShouldRevert(bool)":"6813d787","shouldRevert()":"d3072d82","sum(uint256,uint256)":"cad0899b","totalSupply()":"18160ddd"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"indexed\":false,\"internalType\":\"struct DeclaredCallsContract.Asset\",\"name\":\"asset\",\"type\":\"tuple\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"AssetTransfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"internalType\":\"struct DeclaredCallsContract.Asset\",\"name\":\"base\",\"type\":\"tuple\"},{\"internalType\":\"string\",\"name\":\"metadata\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"values\",\"type\":\"uint256[]\"}],\"indexed\":false,\"internalType\":\"struct DeclaredCallsContract.ComplexAsset\",\"name\":\"complexAsset\",\"type\":\"tuple\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"ComplexAssetCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"alwaysReverts\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"assetOwners\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"assets\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balances\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"conditionalRevert\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"counter\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"assetAddr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"emitAssetTransfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"baseAddr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"baseAmount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"baseActive\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"metadataStr\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"values\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"emitComplexAssetCreated\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"emitTransfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"assetId\",\"type\":\"uint256\"}],\"name\":\"getAssetAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getConstant\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"assetAddr\",\"type\":\"address\"}],\"name\":\"getMetadata\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"assetAddr\",\"type\":\"address\"}],\"name\":\"getOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"hiddenFunction\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementCounter\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"assetId\",\"type\":\"uint256\"}],\"name\":\"isAssetActive\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"metadata\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_shouldRevert\",\"type\":\"bool\"}],\"name\":\"setShouldRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"shouldRevert\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"}],\"name\":\"sum\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/DeclaredCallsContract.sol\":\"DeclaredCallsContract\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/DeclaredCallsContract.sol\":{\"keccak256\":\"0xb7dd6115ebb33909cd2861b46faf38ee9d054bcb7e47e69824598be15348c72b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://850a9682211cb8dd788de77cb14735d90c8aa4c907a0cf32703af687ce0a48f3\",\"dweb:/ipfs/Qmad15X9aQ3aYWJX71RPVkn42NWW2t5bjFFm1ESqAgRo4b\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"struct DeclaredCallsContract.Asset","name":"asset","type":"tuple","components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"active","type":"bool"}],"indexed":false},{"internalType":"address","name":"to","type":"address","indexed":false},{"internalType":"uint256","name":"blockNumber","type":"uint256","indexed":false}],"type":"event","name":"AssetTransfer","anonymous":false},{"inputs":[{"internalType":"struct DeclaredCallsContract.ComplexAsset","name":"complexAsset","type":"tuple","components":[{"internalType":"struct DeclaredCallsContract.Asset","name":"base","type":"tuple","components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"active","type":"bool"}]},{"internalType":"string","name":"metadata","type":"string"},{"internalType":"uint256[]","name":"values","type":"uint256[]"}],"indexed":false},{"internalType":"uint256","name":"id","type":"uint256","indexed":false}],"type":"event","name":"ComplexAssetCreated","anonymous":false},{"inputs":[{"internalType":"address","name":"from","type":"address","indexed":true},{"internalType":"address","name":"to","type":"address","indexed":true},{"internalType":"uint256","name":"value","type":"uint256","indexed":false}],"type":"event","name":"Transfer","anonymous":false},{"inputs":[],"stateMutability":"pure","type":"function","name":"alwaysReverts","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function","name":"assetOwners","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function","name":"assets","outputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"active","type":"bool"}]},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"stateMutability":"view","type":"function","name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function","name":"balances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"conditionalRevert"},{"inputs":[],"stateMutability":"view","type":"function","name":"counter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"address","name":"assetAddr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"active","type":"bool"},{"internalType":"address","name":"to","type":"address"}],"stateMutability":"nonpayable","type":"function","name":"emitAssetTransfer"},{"inputs":[{"internalType":"address","name":"baseAddr","type":"address"},{"internalType":"uint256","name":"baseAmount","type":"uint256"},{"internalType":"bool","name":"baseActive","type":"bool"},{"internalType":"string","name":"metadataStr","type":"string"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"uint256","name":"id","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"emitComplexAssetCreated"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"emitTransfer"},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"}],"stateMutability":"view","type":"function","name":"getAssetAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"pure","type":"function","name":"getConstant","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"address","name":"assetAddr","type":"address"}],"stateMutability":"view","type":"function","name":"getMetadata","outputs":[{"internalType":"string","name":"","type":"string"}]},{"inputs":[{"internalType":"address","name":"assetAddr","type":"address"}],"stateMutability":"view","type":"function","name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"pure","type":"function","name":"hiddenFunction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"nonpayable","type":"function","name":"incrementCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"}],"stateMutability":"view","type":"function","name":"isAssetActive","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function","name":"metadata","outputs":[{"internalType":"string","name":"","type":"string"}]},{"inputs":[{"internalType":"bool","name":"_shouldRevert","type":"bool"}],"stateMutability":"nonpayable","type":"function","name":"setShouldRevert"},{"inputs":[],"stateMutability":"view","type":"function","name":"shouldRevert","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"}],"stateMutability":"pure","type":"function","name":"sum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":false,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/DeclaredCallsContract.sol":"DeclaredCallsContract"},"evmVersion":"shanghai","libraries":{}},"sources":{"src/DeclaredCallsContract.sol":{"keccak256":"0xb7dd6115ebb33909cd2861b46faf38ee9d054bcb7e47e69824598be15348c72b","urls":["bzz-raw://850a9682211cb8dd788de77cb14735d90c8aa4c907a0cf32703af687ce0a48f3","dweb:/ipfs/Qmad15X9aQ3aYWJX71RPVkn42NWW2t5bjFFm1ESqAgRo4b"],"license":"MIT"}},"version":1},"id":0}
\ No newline at end of file
diff --git a/tests/contracts/out/LimitedContract.sol/LimitedContract.json b/tests/contracts/out/LimitedContract.sol/LimitedContract.json
index e61d9b847c1..bb294ec8664 100644
--- a/tests/contracts/out/LimitedContract.sol/LimitedContract.json
+++ b/tests/contracts/out/LimitedContract.sol/LimitedContract.json
@@ -1,515 +1 @@
-{
-  "abi": [
-    {
-      "inputs": [],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "anonymous": false,
-      "inputs": [],
-      "name": "Trigger",
-      "type": "event"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        }
-      ],
-      "name": "inc",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    }
-  ],
-  "bytecode": {
-    "object": "0x608060405234801561001057600080fd5b506040517f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d90600090a1610120806100496000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063812600df14602d575b600080fd5b603c603836600460b2565b604e565b60405190815260200160405180910390f35b6000600a821060a35760405162461bcd60e51b815260206004820152601b60248201527f63616e206f6e6c792068616e646c652076616c756573203c2031300000000000604482015260640160405180910390fd5b60ac82600160ca565b92915050565b60006020828403121560c357600080fd5b5035919050565b8082018082111560ac57634e487b7160e01b600052601160045260246000fdfea26469706673582212203b86696b857477da4e8dce08502a769c3dae858879eb33d2f187a9793d836ffe64736f6c63430008160033",
-    "sourceMap": "57:257:0:-:0;;;110:45;;;;;;;;;-1:-1:-1;139:9:0;;;;;;;57:257;;;;;;",
-    "linkReferences": {}
-  },
-  "deployedBytecode": {
-    "object": "0x6080604052348015600f57600080fd5b506004361060285760003560e01c8063812600df14602d575b600080fd5b603c603836600460b2565b604e565b60405190815260200160405180910390f35b6000600a821060a35760405162461bcd60e51b815260206004820152601b60248201527f63616e206f6e6c792068616e646c652076616c756573203c2031300000000000604482015260640160405180910390fd5b60ac82600160ca565b92915050565b60006020828403121560c357600080fd5b5035919050565b8082018082111560ac57634e487b7160e01b600052601160045260246000fdfea26469706673582212203b86696b857477da4e8dce08502a769c3dae858879eb33d2f187a9793d836ffe64736f6c63430008160033",
-    "sourceMap": "57:257:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;161:151;;;;;;:::i;:::-;;:::i;:::-;;;345:25:3;;;333:2;318:18;161:151:0;;;;;;;;210:7;245:2;237:5;:10;229:50;;;;-1:-1:-1;;;229:50:0;;583:2:3;229:50:0;;;565:21:3;622:2;602:18;;;595:30;661:29;641:18;;;634:57;708:18;;229:50:0;;;;;;;;296:9;:5;304:1;296:9;:::i;:::-;289:16;161:151;-1:-1:-1;;161:151:0:o;14:180:3:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:3;;14:180;-1:-1:-1;14:180:3:o;737:222::-;802:9;;;823:10;;;820:133;;;875:10;870:3;866:20;863:1;856:31;910:4;907:1;900:15;938:4;935:1;928:15",
-    "linkReferences": {}
-  },
-  "methodIdentifiers": {
-    "inc(uint256)": "812600df"
-  },
-  "rawMetadata": "{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"inc\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/LimitedContract.sol\":\"LimitedContract\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/LimitedContract.sol\":{\"keccak256\":\"0x7b291e6c8d7562ba65f036bd8b25c87587c57f5c35d5a6ea587a4eb6c7de4b02\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b7b7d9ad73d3f266dff610553eac7a1454f71e616036b0b50cee8610b999c2eb\",\"dweb:/ipfs/QmcdMqSxkNDwHJ8pMyh2jK2sA6Xrk4VSdm4nqZ86EK2Vut\"]}},\"version\":1}",
-  "metadata": {
-    "compiler": {
-      "version": "0.8.22+commit.4fc1097e"
-    },
-    "language": "Solidity",
-    "output": {
-      "abi": [
-        {
-          "inputs": [],
-          "stateMutability": "nonpayable",
-          "type": "constructor"
-        },
-        {
-          "inputs": [],
-          "type": "event",
-          "name": "Trigger",
-          "anonymous": false
-        },
-        {
-          "inputs": [
-            {
-              "internalType": "uint256",
-              "name": "value",
-              "type": "uint256"
-            }
-          ],
-          "stateMutability": "pure",
-          "type": "function",
-          "name": "inc",
-          "outputs": [
-            {
-              "internalType": "uint256",
-              "name": "",
-              "type": "uint256"
-            }
-          ]
-        }
-      ],
-      "devdoc": {
-        "kind": "dev",
-        "methods": {},
-        "version": 1
-      },
-      "userdoc": {
-        "kind": "user",
-        "methods": {},
-        "version": 1
-      }
-    },
-    "settings": {
-      "remappings": [],
-      "optimizer": {
-        "enabled": true,
-        "runs": 200
-      },
-      "metadata": {
-        "bytecodeHash": "ipfs"
-      },
-      "compilationTarget": {
-        "src/LimitedContract.sol": "LimitedContract"
-      },
-      "libraries": {}
-    },
-    "sources": {
-      "src/LimitedContract.sol": {
-        "keccak256": "0x7b291e6c8d7562ba65f036bd8b25c87587c57f5c35d5a6ea587a4eb6c7de4b02",
-        "urls": [
-          "bzz-raw://b7b7d9ad73d3f266dff610553eac7a1454f71e616036b0b50cee8610b999c2eb",
-          "dweb:/ipfs/QmcdMqSxkNDwHJ8pMyh2jK2sA6Xrk4VSdm4nqZ86EK2Vut"
-        ],
-        "license": "MIT"
-      }
-    },
-    "version": 1
-  },
-  "ast": {
-    "absolutePath": "src/LimitedContract.sol",
-    "id": 31,
-    "exportedSymbols": {
-      "LimitedContract": [
-        30
-      ]
-    },
-    "nodeType": "SourceUnit",
-    "src": "32:283:0",
-    "nodes": [
-      {
-        "id": 1,
-        "nodeType": "PragmaDirective",
-        "src": "32:23:0",
-        "nodes": [],
-        "literals": [
-          "solidity",
-          "^",
-          "0.8",
-          ".0"
-        ]
-      },
-      {
-        "id": 30,
-        "nodeType": "ContractDefinition",
-        "src": "57:257:0",
-        "nodes": [
-          {
-            "id": 3,
-            "nodeType": "EventDefinition",
-            "src": "88:16:0",
-            "nodes": [],
-            "anonymous": false,
-            "eventSelector": "3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d",
-            "name": "Trigger",
-            "nameLocation": "94:7:0",
-            "parameters": {
-              "id": 2,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "101:2:0"
-            }
-          },
-          {
-            "id": 10,
-            "nodeType": "FunctionDefinition",
-            "src": "110:45:0",
-            "nodes": [],
-            "body": {
-              "id": 9,
-              "nodeType": "Block",
-              "src": "124:31:0",
-              "nodes": [],
-              "statements": [
-                {
-                  "eventCall": {
-                    "arguments": [],
-                    "expression": {
-                      "argumentTypes": [],
-                      "id": 6,
-                      "name": "Trigger",
-                      "nodeType": "Identifier",
-                      "overloadedDeclarations": [],
-                      "referencedDeclaration": 3,
-                      "src": "139:7:0",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_function_event_nonpayable$__$returns$__$",
-                        "typeString": "function ()"
-                      }
-                    },
-                    "id": 7,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": false,
-                    "kind": "functionCall",
-                    "lValueRequested": false,
-                    "nameLocations": [],
-                    "names": [],
-                    "nodeType": "FunctionCall",
-                    "src": "139:9:0",
-                    "tryCall": false,
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_tuple$__$",
-                      "typeString": "tuple()"
-                    }
-                  },
-                  "id": 8,
-                  "nodeType": "EmitStatement",
-                  "src": "134:14:0"
-                }
-              ]
-            },
-            "implemented": true,
-            "kind": "constructor",
-            "modifiers": [],
-            "name": "",
-            "nameLocation": "-1:-1:-1",
-            "parameters": {
-              "id": 4,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "121:2:0"
-            },
-            "returnParameters": {
-              "id": 5,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "124:0:0"
-            },
-            "scope": 30,
-            "stateMutability": "nonpayable",
-            "virtual": false,
-            "visibility": "public"
-          },
-          {
-            "id": 29,
-            "nodeType": "FunctionDefinition",
-            "src": "161:151:0",
-            "nodes": [],
-            "body": {
-              "id": 28,
-              "nodeType": "Block",
-              "src": "219:93:0",
-              "nodes": [],
-              "statements": [
-                {
-                  "expression": {
-                    "arguments": [
-                      {
-                        "commonType": {
-                          "typeIdentifier": "t_uint256",
-                          "typeString": "uint256"
-                        },
-                        "id": 20,
-                        "isConstant": false,
-                        "isLValue": false,
-                        "isPure": false,
-                        "lValueRequested": false,
-                        "leftExpression": {
-                          "id": 18,
-                          "name": "value",
-                          "nodeType": "Identifier",
-                          "overloadedDeclarations": [],
-                          "referencedDeclaration": 12,
-                          "src": "237:5:0",
-                          "typeDescriptions": {
-                            "typeIdentifier": "t_uint256",
-                            "typeString": "uint256"
-                          }
-                        },
-                        "nodeType": "BinaryOperation",
-                        "operator": "<",
-                        "rightExpression": {
-                          "hexValue": "3130",
-                          "id": 19,
-                          "isConstant": false,
-                          "isLValue": false,
-                          "isPure": true,
-                          "kind": "number",
-                          "lValueRequested": false,
-                          "nodeType": "Literal",
-                          "src": "245:2:0",
-                          "typeDescriptions": {
-                            "typeIdentifier": "t_rational_10_by_1",
-                            "typeString": "int_const 10"
-                          },
-                          "value": "10"
-                        },
-                        "src": "237:10:0",
-                        "typeDescriptions": {
-                          "typeIdentifier": "t_bool",
-                          "typeString": "bool"
-                        }
-                      },
-                      {
-                        "hexValue": "63616e206f6e6c792068616e646c652076616c756573203c203130",
-                        "id": 21,
-                        "isConstant": false,
-                        "isLValue": false,
-                        "isPure": true,
-                        "kind": "string",
-                        "lValueRequested": false,
-                        "nodeType": "Literal",
-                        "src": "249:29:0",
-                        "typeDescriptions": {
-                          "typeIdentifier": "t_stringliteral_578cd1fc098748633f5d7d46bba428bb3129c1e63324f2b7151699cae5146449",
-                          "typeString": "literal_string \"can only handle values < 10\""
-                        },
-                        "value": "can only handle values < 10"
-                      }
-                    ],
-                    "expression": {
-                      "argumentTypes": [
-                        {
-                          "typeIdentifier": "t_bool",
-                          "typeString": "bool"
-                        },
-                        {
-                          "typeIdentifier": "t_stringliteral_578cd1fc098748633f5d7d46bba428bb3129c1e63324f2b7151699cae5146449",
-                          "typeString": "literal_string \"can only handle values < 10\""
-                        }
-                      ],
-                      "id": 17,
-                      "name": "require",
-                      "nodeType": "Identifier",
-                      "overloadedDeclarations": [
-                        -18,
-                        -18
-                      ],
-                      "referencedDeclaration": -18,
-                      "src": "229:7:0",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
-                        "typeString": "function (bool,string memory) pure"
-                      }
-                    },
-                    "id": 22,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": false,
-                    "kind": "functionCall",
-                    "lValueRequested": false,
-                    "nameLocations": [],
-                    "names": [],
-                    "nodeType": "FunctionCall",
-                    "src": "229:50:0",
-                    "tryCall": false,
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_tuple$__$",
-                      "typeString": "tuple()"
-                    }
-                  },
-                  "id": 23,
-                  "nodeType": "ExpressionStatement",
-                  "src": "229:50:0"
-                },
-                {
-                  "expression": {
-                    "commonType": {
-                      "typeIdentifier": "t_uint256",
-                      "typeString": "uint256"
-                    },
-                    "id": 26,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": false,
-                    "lValueRequested": false,
-                    "leftExpression": {
-                      "id": 24,
-                      "name": "value",
-                      "nodeType": "Identifier",
-                      "overloadedDeclarations": [],
-                      "referencedDeclaration": 12,
-                      "src": "296:5:0",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_uint256",
-                        "typeString": "uint256"
-                      }
-                    },
-                    "nodeType": "BinaryOperation",
-                    "operator": "+",
-                    "rightExpression": {
-                      "hexValue": "31",
-                      "id": 25,
-                      "isConstant": false,
-                      "isLValue": false,
-                      "isPure": true,
-                      "kind": "number",
-                      "lValueRequested": false,
-                      "nodeType": "Literal",
-                      "src": "304:1:0",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_rational_1_by_1",
-                        "typeString": "int_const 1"
-                      },
-                      "value": "1"
-                    },
-                    "src": "296:9:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_uint256",
-                      "typeString": "uint256"
-                    }
-                  },
-                  "functionReturnParameters": 16,
-                  "id": 27,
-                  "nodeType": "Return",
-                  "src": "289:16:0"
-                }
-              ]
-            },
-            "functionSelector": "812600df",
-            "implemented": true,
-            "kind": "function",
-            "modifiers": [],
-            "name": "inc",
-            "nameLocation": "170:3:0",
-            "parameters": {
-              "id": 13,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 12,
-                  "mutability": "mutable",
-                  "name": "value",
-                  "nameLocation": "182:5:0",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 29,
-                  "src": "174:13:0",
-                  "stateVariable": false,
-                  "storageLocation": "default",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_uint256",
-                    "typeString": "uint256"
-                  },
-                  "typeName": {
-                    "id": 11,
-                    "name": "uint256",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "174:7:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_uint256",
-                      "typeString": "uint256"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "173:15:0"
-            },
-            "returnParameters": {
-              "id": 16,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 15,
-                  "mutability": "mutable",
-                  "name": "",
-                  "nameLocation": "-1:-1:-1",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 29,
-                  "src": "210:7:0",
-                  "stateVariable": false,
-                  "storageLocation": "default",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_uint256",
-                    "typeString": "uint256"
-                  },
-                  "typeName": {
-                    "id": 14,
-                    "name": "uint256",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "210:7:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_uint256",
-                      "typeString": "uint256"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "209:9:0"
-            },
-            "scope": 30,
-            "stateMutability": "pure",
-            "virtual": false,
-            "visibility": "public"
-          }
-        ],
-        "abstract": false,
-        "baseContracts": [],
-        "canonicalName": "LimitedContract",
-        "contractDependencies": [],
-        "contractKind": "contract",
-        "fullyImplemented": true,
-        "linearizedBaseContracts": [
-          30
-        ],
-        "name": "LimitedContract",
-        "nameLocation": "66:15:0",
-        "scope": 31,
-        "usedErrors": [],
-        "usedEvents": [
-          3
-        ]
-      }
-    ],
-    "license": "MIT"
-  },
-  "id": 0
-}
\ No newline at end of file
+{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"inc","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"event","name":"Trigger","inputs":[],"anonymous":false}],"bytecode":{"object":"0x608060405234801561000f575f80fd5b507f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d60405160405180910390a161024d806100495f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063812600df1461002d575b5f80fd5b610047600480360381019061004291906100ec565b61005d565b6040516100549190610126565b60405180910390f35b5f600a82106100a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161009890610199565b60405180910390fd5b6001826100ae91906101e4565b9050919050565b5f80fd5b5f819050919050565b6100cb816100b9565b81146100d5575f80fd5b50565b5f813590506100e6816100c2565b92915050565b5f60208284031215610101576101006100b5565b5b5f61010e848285016100d8565b91505092915050565b610120816100b9565b82525050565b5f6020820190506101395f830184610117565b92915050565b5f82825260208201905092915050565b7f63616e206f6e6c792068616e646c652076616c756573203c20313000000000005f82015250565b5f610183601b8361013f565b915061018e8261014f565b602082019050919050565b5f6020820190508181035f8301526101b081610177565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101ee826100b9565b91506101f9836100b9565b9250828201905080821115610211576102106101b7565b5b9291505056fea264697066735822122016a7fef0e372985eb6471669f69fb86efa228ea461eb16a899a782e4bb3f533b64736f6c63430008160033","sourceMap":"57:257:1:-:0;;;110:45;;;;;;;;;;139:9;;;;;;;;;;57:257;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063812600df1461002d575b5f80fd5b610047600480360381019061004291906100ec565b61005d565b6040516100549190610126565b60405180910390f35b5f600a82106100a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161009890610199565b60405180910390fd5b6001826100ae91906101e4565b9050919050565b5f80fd5b5f819050919050565b6100cb816100b9565b81146100d5575f80fd5b50565b5f813590506100e6816100c2565b92915050565b5f60208284031215610101576101006100b5565b5b5f61010e848285016100d8565b91505092915050565b610120816100b9565b82525050565b5f6020820190506101395f830184610117565b92915050565b5f82825260208201905092915050565b7f63616e206f6e6c792068616e646c652076616c756573203c20313000000000005f82015250565b5f610183601b8361013f565b915061018e8261014f565b602082019050919050565b5f6020820190508181035f8301526101b081610177565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101ee826100b9565b91506101f9836100b9565b9250828201905080821115610211576102106101b7565b5b9291505056fea264697066735822122016a7fef0e372985eb6471669f69fb86efa228ea461eb16a899a782e4bb3f533b64736f6c63430008160033","sourceMap":"57:257:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;161:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;210:7;245:2;237:5;:10;229:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;304:1;296:5;:9;;;;:::i;:::-;289:16;;161:151;;;:::o;88:117:5:-;197:1;194;187:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:118::-;1112:24;1130:5;1112:24;:::i;:::-;1107:3;1100:37;1025:118;;:::o;1149:222::-;1242:4;1280:2;1269:9;1265:18;1257:26;;1293:71;1361:1;1350:9;1346:17;1337:6;1293:71;:::i;:::-;1149:222;;;;:::o;1377:169::-;1461:11;1495:6;1490:3;1483:19;1535:4;1530:3;1526:14;1511:29;;1377:169;;;;:::o;1552:177::-;1692:29;1688:1;1680:6;1676:14;1669:53;1552:177;:::o;1735:366::-;1877:3;1898:67;1962:2;1957:3;1898:67;:::i;:::-;1891:74;;1974:93;2063:3;1974:93;:::i;:::-;2092:2;2087:3;2083:12;2076:19;;1735:366;;;:::o;2107:419::-;2273:4;2311:2;2300:9;2296:18;2288:26;;2360:9;2354:4;2350:20;2346:1;2335:9;2331:17;2324:47;2388:131;2514:4;2388:131;:::i;:::-;2380:139;;2107:419;;;:::o;2532:180::-;2580:77;2577:1;2570:88;2677:4;2674:1;2667:15;2701:4;2698:1;2691:15;2718:191;2758:3;2777:20;2795:1;2777:20;:::i;:::-;2772:25;;2811:20;2829:1;2811:20;:::i;:::-;2806:25;;2854:1;2851;2847:9;2840:16;;2875:3;2872:1;2869:10;2866:36;;;2882:18;;:::i;:::-;2866:36;2718:191;;;;:::o","linkReferences":{}},"methodIdentifiers":{"inc(uint256)":"812600df"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"inc\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/LimitedContract.sol\":\"LimitedContract\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/LimitedContract.sol\":{\"keccak256\":\"0x7b291e6c8d7562ba65f036bd8b25c87587c57f5c35d5a6ea587a4eb6c7de4b02\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b7b7d9ad73d3f266dff610553eac7a1454f71e616036b0b50cee8610b999c2eb\",\"dweb:/ipfs/QmcdMqSxkNDwHJ8pMyh2jK2sA6Xrk4VSdm4nqZ86EK2Vut\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"pure","type":"function","name":"inc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":false,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/LimitedContract.sol":"LimitedContract"},"evmVersion":"shanghai","libraries":{}},"sources":{"src/LimitedContract.sol":{"keccak256":"0x7b291e6c8d7562ba65f036bd8b25c87587c57f5c35d5a6ea587a4eb6c7de4b02","urls":["bzz-raw://b7b7d9ad73d3f266dff610553eac7a1454f71e616036b0b50cee8610b999c2eb","dweb:/ipfs/QmcdMqSxkNDwHJ8pMyh2jK2sA6Xrk4VSdm4nqZ86EK2Vut"],"license":"MIT"}},"version":1},"id":1}
\ No newline at end of file
diff --git a/tests/contracts/out/OverloadedContract.sol/OverloadedContract.json b/tests/contracts/out/OverloadedContract.sol/OverloadedContract.json
index cc00e433f0f..c0d7d2f52a0 100644
--- a/tests/contracts/out/OverloadedContract.sol/OverloadedContract.json
+++ b/tests/contracts/out/OverloadedContract.sol/OverloadedContract.json
@@ -1,680 +1 @@
-{
-  "abi": [
-    {
-      "inputs": [],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "anonymous": false,
-      "inputs": [],
-      "name": "Trigger",
-      "type": "event"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "name": "exampleFunction",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "name": "exampleFunction",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "name": "exampleFunction",
-      "outputs": [
-        {
-          "internalType": "string",
-          "name": "",
-          "type": "string"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    }
-  ],
-  "bytecode": {
-    "object": "0x608060405234801561001057600080fd5b506040517f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d90600090a1610253806100496000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c806331870cbc14610046578063934bc29d1461006e578063bc2d73ba146100b5575b600080fd5b61005b6100543660046100ee565b5061010090565b6040519081526020015b60405180910390f35b6100a861007c3660046100ee565b5060408051808201909152601181527075696e74323536202d3e20737472696e6760781b602082015290565b6040516100659190610107565b6100a86100c336600461016c565b5060408051808201909152601081526f737472696e67202d3e20737472696e6760801b602082015290565b60006020828403121561010057600080fd5b5035919050565b60006020808352835180602085015260005b8181101561013557858101830151858201604001528201610119565b506000604082860101526040601f19601f8301168501019250505092915050565b634e487b7160e01b600052604160045260246000fd5b60006020828403121561017e57600080fd5b813567ffffffffffffffff8082111561019657600080fd5b818401915084601f8301126101aa57600080fd5b8135818111156101bc576101bc610156565b604051601f8201601f19908116603f011681019083821181831017156101e4576101e4610156565b816040528281528760208487010111156101fd57600080fd5b82602086016020830137600092810160200192909252509594505050505056fea2646970667358221220d1711dc79953e77111c03bd6e4fa0a23e5d560f6d7b18401801c111efc075a6d64736f6c63430008160033",
-    "sourceMap": "57:457:0:-:0;;;113:45;;;;;;;;;-1:-1:-1;142:9:0;;;;;;;57:457;;;;;;",
-    "linkReferences": {}
-  },
-  "deployedBytecode": {
-    "object": "0x608060405234801561001057600080fd5b50600436106100415760003560e01c806331870cbc14610046578063934bc29d1461006e578063bc2d73ba146100b5575b600080fd5b61005b6100543660046100ee565b5061010090565b6040519081526020015b60405180910390f35b6100a861007c3660046100ee565b5060408051808201909152601181527075696e74323536202d3e20737472696e6760781b602082015290565b6040516100659190610107565b6100a86100c336600461016c565b5060408051808201909152601081526f737472696e67202d3e20737472696e6760801b602082015290565b60006020828403121561010057600080fd5b5035919050565b60006020808352835180602085015260005b8181101561013557858101830151858201604001528201610119565b506000604082860101526040601f19601f8301168501019250505092915050565b634e487b7160e01b600052604160045260246000fd5b60006020828403121561017e57600080fd5b813567ffffffffffffffff8082111561019657600080fd5b818401915084601f8301126101aa57600080fd5b8135818111156101bc576101bc610156565b604051601f8201601f19908116603f011681019083821181831017156101e4576101e4610156565b816040528281528760208487010111156101fd57600080fd5b82602086016020830137600092810160200192909252509594505050505056fea2646970667358221220d1711dc79953e77111c03bd6e4fa0a23e5d560f6d7b18401801c111efc075a6d64736f6c63430008160033",
-    "sourceMap": "57:457:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;421:91;;;;;;:::i;:::-;-1:-1:-1;502:3:0;;421:91;;;;345:25:1;;;333:2;318:18;421:91:0;;;;;;;;302:113;;;;;;:::i;:::-;-1:-1:-1;382:26:0;;;;;;;;;;;;-1:-1:-1;;;382:26:0;;;;;302:113;;;;;;;;:::i;164:132::-;;;;;;:::i;:::-;-1:-1:-1;264:25:0;;;;;;;;;;;;-1:-1:-1;;;264:25:0;;;;;164:132;14:180:1;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;566:548::-;678:4;707:2;736;725:9;718:21;768:6;762:13;811:6;806:2;795:9;791:18;784:34;836:1;846:140;860:6;857:1;854:13;846:140;;;955:14;;;951:23;;945:30;921:17;;;940:2;917:26;910:66;875:10;;846:140;;;850:3;1035:1;1030:2;1021:6;1010:9;1006:22;1002:31;995:42;1105:2;1098;1094:7;1089:2;1081:6;1077:15;1073:29;1062:9;1058:45;1054:54;1046:62;;;;566:548;;;;:::o;1119:127::-;1180:10;1175:3;1171:20;1168:1;1161:31;1211:4;1208:1;1201:15;1235:4;1232:1;1225:15;1251:922;1320:6;1373:2;1361:9;1352:7;1348:23;1344:32;1341:52;;;1389:1;1386;1379:12;1341:52;1429:9;1416:23;1458:18;1499:2;1491:6;1488:14;1485:34;;;1515:1;1512;1505:12;1485:34;1553:6;1542:9;1538:22;1528:32;;1598:7;1591:4;1587:2;1583:13;1579:27;1569:55;;1620:1;1617;1610:12;1569:55;1656:2;1643:16;1678:2;1674;1671:10;1668:36;;;1684:18;;:::i;:::-;1759:2;1753:9;1727:2;1813:13;;-1:-1:-1;;1809:22:1;;;1833:2;1805:31;1801:40;1789:53;;;1857:18;;;1877:22;;;1854:46;1851:72;;;1903:18;;:::i;:::-;1943:10;1939:2;1932:22;1978:2;1970:6;1963:18;2018:7;2013:2;2008;2004;2000:11;1996:20;1993:33;1990:53;;;2039:1;2036;2029:12;1990:53;2095:2;2090;2086;2082:11;2077:2;2069:6;2065:15;2052:46;2140:1;2118:15;;;2135:2;2114:24;2107:35;;;;-1:-1:-1;2122:6:1;1251:922;-1:-1:-1;;;;;1251:922:1:o",
-    "linkReferences": {}
-  },
-  "methodIdentifiers": {
-    "exampleFunction(bytes32)": "31870cbc",
-    "exampleFunction(string)": "bc2d73ba",
-    "exampleFunction(uint256)": "934bc29d"
-  },
-  "rawMetadata": "{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/OverloadedContract.sol\":\"OverloadedContract\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/OverloadedContract.sol\":{\"keccak256\":\"0xc6734859398f3be8468d6e6c7fd8b03a52243223799ce17d5e4ab9d9aca1fc45\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2c860b9cd7d0a2086e164ce38a2aa24a5b7f681bb575a5a656f732d3742761be\",\"dweb:/ipfs/QmPwazDSTPrNpVrRY2vunso7VXunWp5dn1641TzxK9eZfe\"]}},\"version\":1}",
-  "metadata": {
-    "compiler": {
-      "version": "0.8.22+commit.4fc1097e"
-    },
-    "language": "Solidity",
-    "output": {
-      "abi": [
-        {
-          "inputs": [],
-          "stateMutability": "nonpayable",
-          "type": "constructor"
-        },
-        {
-          "inputs": [],
-          "type": "event",
-          "name": "Trigger",
-          "anonymous": false
-        },
-        {
-          "inputs": [
-            {
-              "internalType": "bytes32",
-              "name": "",
-              "type": "bytes32"
-            }
-          ],
-          "stateMutability": "pure",
-          "type": "function",
-          "name": "exampleFunction",
-          "outputs": [
-            {
-              "internalType": "uint256",
-              "name": "",
-              "type": "uint256"
-            }
-          ]
-        },
-        {
-          "inputs": [
-            {
-              "internalType": "uint256",
-              "name": "",
-              "type": "uint256"
-            }
-          ],
-          "stateMutability": "pure",
-          "type": "function",
-          "name": "exampleFunction",
-          "outputs": [
-            {
-              "internalType": "string",
-              "name": "",
-              "type": "string"
-            }
-          ]
-        },
-        {
-          "inputs": [
-            {
-              "internalType": "string",
-              "name": "",
-              "type": "string"
-            }
-          ],
-          "stateMutability": "pure",
-          "type": "function",
-          "name": "exampleFunction",
-          "outputs": [
-            {
-              "internalType": "string",
-              "name": "",
-              "type": "string"
-            }
-          ]
-        }
-      ],
-      "devdoc": {
-        "kind": "dev",
-        "methods": {},
-        "version": 1
-      },
-      "userdoc": {
-        "kind": "user",
-        "methods": {},
-        "version": 1
-      }
-    },
-    "settings": {
-      "remappings": [],
-      "optimizer": {
-        "enabled": true,
-        "runs": 200
-      },
-      "metadata": {
-        "bytecodeHash": "ipfs"
-      },
-      "compilationTarget": {
-        "src/OverloadedContract.sol": "OverloadedContract"
-      },
-      "libraries": {}
-    },
-    "sources": {
-      "src/OverloadedContract.sol": {
-        "keccak256": "0xc6734859398f3be8468d6e6c7fd8b03a52243223799ce17d5e4ab9d9aca1fc45",
-        "urls": [
-          "bzz-raw://2c860b9cd7d0a2086e164ce38a2aa24a5b7f681bb575a5a656f732d3742761be",
-          "dweb:/ipfs/QmPwazDSTPrNpVrRY2vunso7VXunWp5dn1641TzxK9eZfe"
-        ],
-        "license": "MIT"
-      }
-    },
-    "version": 1
-  },
-  "ast": {
-    "absolutePath": "src/OverloadedContract.sol",
-    "id": 42,
-    "exportedSymbols": {
-      "OverloadedContract": [
-        41
-      ]
-    },
-    "nodeType": "SourceUnit",
-    "src": "32:483:0",
-    "nodes": [
-      {
-        "id": 1,
-        "nodeType": "PragmaDirective",
-        "src": "32:23:0",
-        "nodes": [],
-        "literals": [
-          "solidity",
-          "^",
-          "0.8",
-          ".0"
-        ]
-      },
-      {
-        "id": 41,
-        "nodeType": "ContractDefinition",
-        "src": "57:457:0",
-        "nodes": [
-          {
-            "id": 3,
-            "nodeType": "EventDefinition",
-            "src": "91:16:0",
-            "nodes": [],
-            "anonymous": false,
-            "eventSelector": "3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d",
-            "name": "Trigger",
-            "nameLocation": "97:7:0",
-            "parameters": {
-              "id": 2,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "104:2:0"
-            }
-          },
-          {
-            "id": 10,
-            "nodeType": "FunctionDefinition",
-            "src": "113:45:0",
-            "nodes": [],
-            "body": {
-              "id": 9,
-              "nodeType": "Block",
-              "src": "127:31:0",
-              "nodes": [],
-              "statements": [
-                {
-                  "eventCall": {
-                    "arguments": [],
-                    "expression": {
-                      "argumentTypes": [],
-                      "id": 6,
-                      "name": "Trigger",
-                      "nodeType": "Identifier",
-                      "overloadedDeclarations": [],
-                      "referencedDeclaration": 3,
-                      "src": "142:7:0",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_function_event_nonpayable$__$returns$__$",
-                        "typeString": "function ()"
-                      }
-                    },
-                    "id": 7,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": false,
-                    "kind": "functionCall",
-                    "lValueRequested": false,
-                    "nameLocations": [],
-                    "names": [],
-                    "nodeType": "FunctionCall",
-                    "src": "142:9:0",
-                    "tryCall": false,
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_tuple$__$",
-                      "typeString": "tuple()"
-                    }
-                  },
-                  "id": 8,
-                  "nodeType": "EmitStatement",
-                  "src": "137:14:0"
-                }
-              ]
-            },
-            "implemented": true,
-            "kind": "constructor",
-            "modifiers": [],
-            "name": "",
-            "nameLocation": "-1:-1:-1",
-            "parameters": {
-              "id": 4,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "124:2:0"
-            },
-            "returnParameters": {
-              "id": 5,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "127:0:0"
-            },
-            "scope": 41,
-            "stateMutability": "nonpayable",
-            "virtual": false,
-            "visibility": "public"
-          },
-          {
-            "id": 20,
-            "nodeType": "FunctionDefinition",
-            "src": "164:132:0",
-            "nodes": [],
-            "body": {
-              "id": 19,
-              "nodeType": "Block",
-              "src": "254:42:0",
-              "nodes": [],
-              "statements": [
-                {
-                  "expression": {
-                    "hexValue": "737472696e67202d3e20737472696e67",
-                    "id": 17,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": true,
-                    "kind": "string",
-                    "lValueRequested": false,
-                    "nodeType": "Literal",
-                    "src": "271:18:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_stringliteral_a675d5271e48bf44b2d3a2abcbe5392d4a4159912e3d2d332a49139a8b50d538",
-                      "typeString": "literal_string \"string -> string\""
-                    },
-                    "value": "string -> string"
-                  },
-                  "functionReturnParameters": 16,
-                  "id": 18,
-                  "nodeType": "Return",
-                  "src": "264:25:0"
-                }
-              ]
-            },
-            "functionSelector": "bc2d73ba",
-            "implemented": true,
-            "kind": "function",
-            "modifiers": [],
-            "name": "exampleFunction",
-            "nameLocation": "173:15:0",
-            "parameters": {
-              "id": 13,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 12,
-                  "mutability": "mutable",
-                  "name": "",
-                  "nameLocation": "-1:-1:-1",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 20,
-                  "src": "198:13:0",
-                  "stateVariable": false,
-                  "storageLocation": "memory",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_string_memory_ptr",
-                    "typeString": "string"
-                  },
-                  "typeName": {
-                    "id": 11,
-                    "name": "string",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "198:6:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_string_storage_ptr",
-                      "typeString": "string"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "188:29:0"
-            },
-            "returnParameters": {
-              "id": 16,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 15,
-                  "mutability": "mutable",
-                  "name": "",
-                  "nameLocation": "-1:-1:-1",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 20,
-                  "src": "239:13:0",
-                  "stateVariable": false,
-                  "storageLocation": "memory",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_string_memory_ptr",
-                    "typeString": "string"
-                  },
-                  "typeName": {
-                    "id": 14,
-                    "name": "string",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "239:6:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_string_storage_ptr",
-                      "typeString": "string"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "238:15:0"
-            },
-            "scope": 41,
-            "stateMutability": "pure",
-            "virtual": false,
-            "visibility": "public"
-          },
-          {
-            "id": 30,
-            "nodeType": "FunctionDefinition",
-            "src": "302:113:0",
-            "nodes": [],
-            "body": {
-              "id": 29,
-              "nodeType": "Block",
-              "src": "372:43:0",
-              "nodes": [],
-              "statements": [
-                {
-                  "expression": {
-                    "hexValue": "75696e74323536202d3e20737472696e67",
-                    "id": 27,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": true,
-                    "kind": "string",
-                    "lValueRequested": false,
-                    "nodeType": "Literal",
-                    "src": "389:19:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_stringliteral_56541f37aba8911ed7b3fc4c5c74297515444b42d7c1b74ff1c1abc66e2d65cd",
-                      "typeString": "literal_string \"uint256 -> string\""
-                    },
-                    "value": "uint256 -> string"
-                  },
-                  "functionReturnParameters": 26,
-                  "id": 28,
-                  "nodeType": "Return",
-                  "src": "382:26:0"
-                }
-              ]
-            },
-            "functionSelector": "934bc29d",
-            "implemented": true,
-            "kind": "function",
-            "modifiers": [],
-            "name": "exampleFunction",
-            "nameLocation": "311:15:0",
-            "parameters": {
-              "id": 23,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 22,
-                  "mutability": "mutable",
-                  "name": "",
-                  "nameLocation": "-1:-1:-1",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 30,
-                  "src": "327:7:0",
-                  "stateVariable": false,
-                  "storageLocation": "default",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_uint256",
-                    "typeString": "uint256"
-                  },
-                  "typeName": {
-                    "id": 21,
-                    "name": "uint256",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "327:7:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_uint256",
-                      "typeString": "uint256"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "326:9:0"
-            },
-            "returnParameters": {
-              "id": 26,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 25,
-                  "mutability": "mutable",
-                  "name": "",
-                  "nameLocation": "-1:-1:-1",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 30,
-                  "src": "357:13:0",
-                  "stateVariable": false,
-                  "storageLocation": "memory",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_string_memory_ptr",
-                    "typeString": "string"
-                  },
-                  "typeName": {
-                    "id": 24,
-                    "name": "string",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "357:6:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_string_storage_ptr",
-                      "typeString": "string"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "356:15:0"
-            },
-            "scope": 41,
-            "stateMutability": "pure",
-            "virtual": false,
-            "visibility": "public"
-          },
-          {
-            "id": 40,
-            "nodeType": "FunctionDefinition",
-            "src": "421:91:0",
-            "nodes": [],
-            "body": {
-              "id": 39,
-              "nodeType": "Block",
-              "src": "485:27:0",
-              "nodes": [],
-              "statements": [
-                {
-                  "expression": {
-                    "hexValue": "323536",
-                    "id": 37,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": true,
-                    "kind": "number",
-                    "lValueRequested": false,
-                    "nodeType": "Literal",
-                    "src": "502:3:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_rational_256_by_1",
-                      "typeString": "int_const 256"
-                    },
-                    "value": "256"
-                  },
-                  "functionReturnParameters": 36,
-                  "id": 38,
-                  "nodeType": "Return",
-                  "src": "495:10:0"
-                }
-              ]
-            },
-            "functionSelector": "31870cbc",
-            "implemented": true,
-            "kind": "function",
-            "modifiers": [],
-            "name": "exampleFunction",
-            "nameLocation": "430:15:0",
-            "parameters": {
-              "id": 33,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 32,
-                  "mutability": "mutable",
-                  "name": "",
-                  "nameLocation": "-1:-1:-1",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 40,
-                  "src": "446:7:0",
-                  "stateVariable": false,
-                  "storageLocation": "default",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_bytes32",
-                    "typeString": "bytes32"
-                  },
-                  "typeName": {
-                    "id": 31,
-                    "name": "bytes32",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "446:7:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_bytes32",
-                      "typeString": "bytes32"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "445:9:0"
-            },
-            "returnParameters": {
-              "id": 36,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 35,
-                  "mutability": "mutable",
-                  "name": "",
-                  "nameLocation": "-1:-1:-1",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 40,
-                  "src": "476:7:0",
-                  "stateVariable": false,
-                  "storageLocation": "default",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_uint256",
-                    "typeString": "uint256"
-                  },
-                  "typeName": {
-                    "id": 34,
-                    "name": "uint256",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "476:7:0",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_uint256",
-                      "typeString": "uint256"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "475:9:0"
-            },
-            "scope": 41,
-            "stateMutability": "pure",
-            "virtual": false,
-            "visibility": "public"
-          }
-        ],
-        "abstract": false,
-        "baseContracts": [],
-        "canonicalName": "OverloadedContract",
-        "contractDependencies": [],
-        "contractKind": "contract",
-        "fullyImplemented": true,
-        "linearizedBaseContracts": [
-          41
-        ],
-        "name": "OverloadedContract",
-        "nameLocation": "66:18:0",
-        "scope": 42,
-        "usedErrors": [],
-        "usedEvents": [
-          3
-        ]
-      }
-    ],
-    "license": "MIT"
-  },
-  "id": 0
-}
\ No newline at end of file
+{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"exampleFunction","inputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"function","name":"exampleFunction","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"type":"function","name":"exampleFunction","inputs":[{"name":"","type":"string","internalType":"string"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"type":"event","name":"Trigger","inputs":[],"anonymous":false}],"bytecode":{"object":"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","sourceMap":"57:457:2:-:0;;;113:45;;;;;;;;;;142:9;;;;;;;;;;57:457;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"57:457:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;421:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;302:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;164:132;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;421:91;476:7;502:3;495:10;;421:91;;;:::o;302:113::-;357:13;382:26;;;;;;;;;;;;;;;;;;;302:113;;;:::o;164:132::-;239:13;264:25;;;;;;;;;;;;;;;;;;;164:132;;;:::o;7:75:5:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:77::-;1062:7;1091:5;1080:16;;1025:77;;;:::o;1108:118::-;1195:24;1213:5;1195:24;:::i;:::-;1190:3;1183:37;1108:118;;:::o;1232:222::-;1325:4;1363:2;1352:9;1348:18;1340:26;;1376:71;1444:1;1433:9;1429:17;1420:6;1376:71;:::i;:::-;1232:222;;;;:::o;1460:122::-;1533:24;1551:5;1533:24;:::i;:::-;1526:5;1523:35;1513:63;;1572:1;1569;1562:12;1513:63;1460:122;:::o;1588:139::-;1634:5;1672:6;1659:20;1650:29;;1688:33;1715:5;1688:33;:::i;:::-;1588:139;;;;:::o;1733:329::-;1792:6;1841:2;1829:9;1820:7;1816:23;1812:32;1809:119;;;1847:79;;:::i;:::-;1809:119;1967:1;1992:53;2037:7;2028:6;2017:9;2013:22;1992:53;:::i;:::-;1982:63;;1938:117;1733:329;;;;:::o;2068:99::-;2120:6;2154:5;2148:12;2138:22;;2068:99;;;:::o;2173:169::-;2257:11;2291:6;2286:3;2279:19;2331:4;2326:3;2322:14;2307:29;;2173:169;;;;:::o;2348:246::-;2429:1;2439:113;2453:6;2450:1;2447:13;2439:113;;;2538:1;2533:3;2529:11;2523:18;2519:1;2514:3;2510:11;2503:39;2475:2;2472:1;2468:10;2463:15;;2439:113;;;2586:1;2577:6;2572:3;2568:16;2561:27;2410:184;2348:246;;;:::o;2600:102::-;2641:6;2692:2;2688:7;2683:2;2676:5;2672:14;2668:28;2658:38;;2600:102;;;:::o;2708:377::-;2796:3;2824:39;2857:5;2824:39;:::i;:::-;2879:71;2943:6;2938:3;2879:71;:::i;:::-;2872:78;;2959:65;3017:6;3012:3;3005:4;2998:5;2994:16;2959:65;:::i;:::-;3049:29;3071:6;3049:29;:::i;:::-;3044:3;3040:39;3033:46;;2800:285;2708:377;;;;:::o;3091:313::-;3204:4;3242:2;3231:9;3227:18;3219:26;;3291:9;3285:4;3281:20;3277:1;3266:9;3262:17;3255:47;3319:78;3392:4;3383:6;3319:78;:::i;:::-;3311:86;;3091:313;;;;:::o;3410:117::-;3519:1;3516;3509:12;3533:117;3642:1;3639;3632:12;3656:180;3704:77;3701:1;3694:88;3801:4;3798:1;3791:15;3825:4;3822:1;3815:15;3842:281;3925:27;3947:4;3925:27;:::i;:::-;3917:6;3913:40;4055:6;4043:10;4040:22;4019:18;4007:10;4004:34;4001:62;3998:88;;;4066:18;;:::i;:::-;3998:88;4106:10;4102:2;4095:22;3885:238;3842:281;;:::o;4129:129::-;4163:6;4190:20;;:::i;:::-;4180:30;;4219:33;4247:4;4239:6;4219:33;:::i;:::-;4129:129;;;:::o;4264:308::-;4326:4;4416:18;4408:6;4405:30;4402:56;;;4438:18;;:::i;:::-;4402:56;4476:29;4498:6;4476:29;:::i;:::-;4468:37;;4560:4;4554;4550:15;4542:23;;4264:308;;;:::o;4578:146::-;4675:6;4670:3;4665;4652:30;4716:1;4707:6;4702:3;4698:16;4691:27;4578:146;;;:::o;4730:425::-;4808:5;4833:66;4849:49;4891:6;4849:49;:::i;:::-;4833:66;:::i;:::-;4824:75;;4922:6;4915:5;4908:21;4960:4;4953:5;4949:16;4998:3;4989:6;4984:3;4980:16;4977:25;4974:112;;;5005:79;;:::i;:::-;4974:112;5095:54;5142:6;5137:3;5132;5095:54;:::i;:::-;4814:341;4730:425;;;;;:::o;5175:340::-;5231:5;5280:3;5273:4;5265:6;5261:17;5257:27;5247:122;;5288:79;;:::i;:::-;5247:122;5405:6;5392:20;5430:79;5505:3;5497:6;5490:4;5482:6;5478:17;5430:79;:::i;:::-;5421:88;;5237:278;5175:340;;;;:::o;5521:509::-;5590:6;5639:2;5627:9;5618:7;5614:23;5610:32;5607:119;;;5645:79;;:::i;:::-;5607:119;5793:1;5782:9;5778:17;5765:31;5823:18;5815:6;5812:30;5809:117;;;5845:79;;:::i;:::-;5809:117;5950:63;6005:7;5996:6;5985:9;5981:22;5950:63;:::i;:::-;5940:73;;5736:287;5521:509;;;;:::o","linkReferences":{}},"methodIdentifiers":{"exampleFunction(bytes32)":"31870cbc","exampleFunction(string)":"bc2d73ba","exampleFunction(uint256)":"934bc29d"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/OverloadedContract.sol\":\"OverloadedContract\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/OverloadedContract.sol\":{\"keccak256\":\"0xc6734859398f3be8468d6e6c7fd8b03a52243223799ce17d5e4ab9d9aca1fc45\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2c860b9cd7d0a2086e164ce38a2aa24a5b7f681bb575a5a656f732d3742761be\",\"dweb:/ipfs/QmPwazDSTPrNpVrRY2vunso7VXunWp5dn1641TzxK9eZfe\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function","name":"exampleFunction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function","name":"exampleFunction","outputs":[{"internalType":"string","name":"","type":"string"}]},{"inputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function","name":"exampleFunction","outputs":[{"internalType":"string","name":"","type":"string"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":false,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/OverloadedContract.sol":"OverloadedContract"},"evmVersion":"shanghai","libraries":{}},"sources":{"src/OverloadedContract.sol":{"keccak256":"0xc6734859398f3be8468d6e6c7fd8b03a52243223799ce17d5e4ab9d9aca1fc45","urls":["bzz-raw://2c860b9cd7d0a2086e164ce38a2aa24a5b7f681bb575a5a656f732d3742761be","dweb:/ipfs/QmPwazDSTPrNpVrRY2vunso7VXunWp5dn1641TzxK9eZfe"],"license":"MIT"}},"version":1},"id":2}
\ No newline at end of file
diff --git a/tests/contracts/out/RevertingContract.sol/RevertingContract.json b/tests/contracts/out/RevertingContract.sol/RevertingContract.json
index 0a6e468b20d..3fd74e0aa28 100644
--- a/tests/contracts/out/RevertingContract.sol/RevertingContract.json
+++ b/tests/contracts/out/RevertingContract.sol/RevertingContract.json
@@ -1,515 +1 @@
-{
-  "abi": [
-    {
-      "inputs": [],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "anonymous": false,
-      "inputs": [],
-      "name": "Trigger",
-      "type": "event"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "value",
-          "type": "uint256"
-        }
-      ],
-      "name": "inc",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "pure",
-      "type": "function"
-    }
-  ],
-  "bytecode": {
-    "object": "0x608060405234801561001057600080fd5b506040517f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d90600090a1610120806100496000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063812600df14602d575b600080fd5b603c603836600460b2565b604e565b60405190815260200160405180910390f35b6000600a821060a35760405162461bcd60e51b815260206004820152601b60248201527f63616e206f6e6c792068616e646c652076616c756573203c2031300000000000604482015260640160405180910390fd5b60ac82600160ca565b92915050565b60006020828403121560c357600080fd5b5035919050565b8082018082111560ac57634e487b7160e01b600052601160045260246000fdfea26469706673582212205868ebc2db6fd9d69d51d34428219b0d0c42a2138f6a1191da8891e85d408ae164736f6c63430008160033",
-    "sourceMap": "57:259:1:-:0;;;112:45;;;;;;;;;-1:-1:-1;141:9:1;;;;;;;57:259;;;;;;",
-    "linkReferences": {}
-  },
-  "deployedBytecode": {
-    "object": "0x6080604052348015600f57600080fd5b506004361060285760003560e01c8063812600df14602d575b600080fd5b603c603836600460b2565b604e565b60405190815260200160405180910390f35b6000600a821060a35760405162461bcd60e51b815260206004820152601b60248201527f63616e206f6e6c792068616e646c652076616c756573203c2031300000000000604482015260640160405180910390fd5b60ac82600160ca565b92915050565b60006020828403121560c357600080fd5b5035919050565b8082018082111560ac57634e487b7160e01b600052601160045260246000fdfea26469706673582212205868ebc2db6fd9d69d51d34428219b0d0c42a2138f6a1191da8891e85d408ae164736f6c63430008160033",
-    "sourceMap": "57:259:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;163:151;;;;;;:::i;:::-;;:::i;:::-;;;345:25:3;;;333:2;318:18;163:151:1;;;;;;;;212:7;247:2;239:5;:10;231:50;;;;-1:-1:-1;;;231:50:1;;583:2:3;231:50:1;;;565:21:3;622:2;602:18;;;595:30;661:29;641:18;;;634:57;708:18;;231:50:1;;;;;;;;298:9;:5;306:1;298:9;:::i;:::-;291:16;163:151;-1:-1:-1;;163:151:1:o;14:180:3:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:3;;14:180;-1:-1:-1;14:180:3:o;737:222::-;802:9;;;823:10;;;820:133;;;875:10;870:3;866:20;863:1;856:31;910:4;907:1;900:15;938:4;935:1;928:15",
-    "linkReferences": {}
-  },
-  "methodIdentifiers": {
-    "inc(uint256)": "812600df"
-  },
-  "rawMetadata": "{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"inc\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/RevertingContract.sol\":\"RevertingContract\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/RevertingContract.sol\":{\"keccak256\":\"0xb0ccab460539f08d5f40044fee3e45c26590431d6d08734acde070ca01d84e23\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cece4cf2b0d867fb8ef474375f8907df5412056773e20e804e12061d98d057b\",\"dweb:/ipfs/QmeLfvzWjkpA6mCt1FJyNvgKeugzJJTRSBdyDUSBCovyrb\"]}},\"version\":1}",
-  "metadata": {
-    "compiler": {
-      "version": "0.8.22+commit.4fc1097e"
-    },
-    "language": "Solidity",
-    "output": {
-      "abi": [
-        {
-          "inputs": [],
-          "stateMutability": "nonpayable",
-          "type": "constructor"
-        },
-        {
-          "inputs": [],
-          "type": "event",
-          "name": "Trigger",
-          "anonymous": false
-        },
-        {
-          "inputs": [
-            {
-              "internalType": "uint256",
-              "name": "value",
-              "type": "uint256"
-            }
-          ],
-          "stateMutability": "pure",
-          "type": "function",
-          "name": "inc",
-          "outputs": [
-            {
-              "internalType": "uint256",
-              "name": "",
-              "type": "uint256"
-            }
-          ]
-        }
-      ],
-      "devdoc": {
-        "kind": "dev",
-        "methods": {},
-        "version": 1
-      },
-      "userdoc": {
-        "kind": "user",
-        "methods": {},
-        "version": 1
-      }
-    },
-    "settings": {
-      "remappings": [],
-      "optimizer": {
-        "enabled": true,
-        "runs": 200
-      },
-      "metadata": {
-        "bytecodeHash": "ipfs"
-      },
-      "compilationTarget": {
-        "src/RevertingContract.sol": "RevertingContract"
-      },
-      "libraries": {}
-    },
-    "sources": {
-      "src/RevertingContract.sol": {
-        "keccak256": "0xb0ccab460539f08d5f40044fee3e45c26590431d6d08734acde070ca01d84e23",
-        "urls": [
-          "bzz-raw://3cece4cf2b0d867fb8ef474375f8907df5412056773e20e804e12061d98d057b",
-          "dweb:/ipfs/QmeLfvzWjkpA6mCt1FJyNvgKeugzJJTRSBdyDUSBCovyrb"
-        ],
-        "license": "MIT"
-      }
-    },
-    "version": 1
-  },
-  "ast": {
-    "absolutePath": "src/RevertingContract.sol",
-    "id": 62,
-    "exportedSymbols": {
-      "RevertingContract": [
-        61
-      ]
-    },
-    "nodeType": "SourceUnit",
-    "src": "32:285:1",
-    "nodes": [
-      {
-        "id": 32,
-        "nodeType": "PragmaDirective",
-        "src": "32:23:1",
-        "nodes": [],
-        "literals": [
-          "solidity",
-          "^",
-          "0.8",
-          ".0"
-        ]
-      },
-      {
-        "id": 61,
-        "nodeType": "ContractDefinition",
-        "src": "57:259:1",
-        "nodes": [
-          {
-            "id": 34,
-            "nodeType": "EventDefinition",
-            "src": "90:16:1",
-            "nodes": [],
-            "anonymous": false,
-            "eventSelector": "3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d",
-            "name": "Trigger",
-            "nameLocation": "96:7:1",
-            "parameters": {
-              "id": 33,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "103:2:1"
-            }
-          },
-          {
-            "id": 41,
-            "nodeType": "FunctionDefinition",
-            "src": "112:45:1",
-            "nodes": [],
-            "body": {
-              "id": 40,
-              "nodeType": "Block",
-              "src": "126:31:1",
-              "nodes": [],
-              "statements": [
-                {
-                  "eventCall": {
-                    "arguments": [],
-                    "expression": {
-                      "argumentTypes": [],
-                      "id": 37,
-                      "name": "Trigger",
-                      "nodeType": "Identifier",
-                      "overloadedDeclarations": [],
-                      "referencedDeclaration": 34,
-                      "src": "141:7:1",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_function_event_nonpayable$__$returns$__$",
-                        "typeString": "function ()"
-                      }
-                    },
-                    "id": 38,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": false,
-                    "kind": "functionCall",
-                    "lValueRequested": false,
-                    "nameLocations": [],
-                    "names": [],
-                    "nodeType": "FunctionCall",
-                    "src": "141:9:1",
-                    "tryCall": false,
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_tuple$__$",
-                      "typeString": "tuple()"
-                    }
-                  },
-                  "id": 39,
-                  "nodeType": "EmitStatement",
-                  "src": "136:14:1"
-                }
-              ]
-            },
-            "implemented": true,
-            "kind": "constructor",
-            "modifiers": [],
-            "name": "",
-            "nameLocation": "-1:-1:-1",
-            "parameters": {
-              "id": 35,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "123:2:1"
-            },
-            "returnParameters": {
-              "id": 36,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "126:0:1"
-            },
-            "scope": 61,
-            "stateMutability": "nonpayable",
-            "virtual": false,
-            "visibility": "public"
-          },
-          {
-            "id": 60,
-            "nodeType": "FunctionDefinition",
-            "src": "163:151:1",
-            "nodes": [],
-            "body": {
-              "id": 59,
-              "nodeType": "Block",
-              "src": "221:93:1",
-              "nodes": [],
-              "statements": [
-                {
-                  "expression": {
-                    "arguments": [
-                      {
-                        "commonType": {
-                          "typeIdentifier": "t_uint256",
-                          "typeString": "uint256"
-                        },
-                        "id": 51,
-                        "isConstant": false,
-                        "isLValue": false,
-                        "isPure": false,
-                        "lValueRequested": false,
-                        "leftExpression": {
-                          "id": 49,
-                          "name": "value",
-                          "nodeType": "Identifier",
-                          "overloadedDeclarations": [],
-                          "referencedDeclaration": 43,
-                          "src": "239:5:1",
-                          "typeDescriptions": {
-                            "typeIdentifier": "t_uint256",
-                            "typeString": "uint256"
-                          }
-                        },
-                        "nodeType": "BinaryOperation",
-                        "operator": "<",
-                        "rightExpression": {
-                          "hexValue": "3130",
-                          "id": 50,
-                          "isConstant": false,
-                          "isLValue": false,
-                          "isPure": true,
-                          "kind": "number",
-                          "lValueRequested": false,
-                          "nodeType": "Literal",
-                          "src": "247:2:1",
-                          "typeDescriptions": {
-                            "typeIdentifier": "t_rational_10_by_1",
-                            "typeString": "int_const 10"
-                          },
-                          "value": "10"
-                        },
-                        "src": "239:10:1",
-                        "typeDescriptions": {
-                          "typeIdentifier": "t_bool",
-                          "typeString": "bool"
-                        }
-                      },
-                      {
-                        "hexValue": "63616e206f6e6c792068616e646c652076616c756573203c203130",
-                        "id": 52,
-                        "isConstant": false,
-                        "isLValue": false,
-                        "isPure": true,
-                        "kind": "string",
-                        "lValueRequested": false,
-                        "nodeType": "Literal",
-                        "src": "251:29:1",
-                        "typeDescriptions": {
-                          "typeIdentifier": "t_stringliteral_578cd1fc098748633f5d7d46bba428bb3129c1e63324f2b7151699cae5146449",
-                          "typeString": "literal_string \"can only handle values < 10\""
-                        },
-                        "value": "can only handle values < 10"
-                      }
-                    ],
-                    "expression": {
-                      "argumentTypes": [
-                        {
-                          "typeIdentifier": "t_bool",
-                          "typeString": "bool"
-                        },
-                        {
-                          "typeIdentifier": "t_stringliteral_578cd1fc098748633f5d7d46bba428bb3129c1e63324f2b7151699cae5146449",
-                          "typeString": "literal_string \"can only handle values < 10\""
-                        }
-                      ],
-                      "id": 48,
-                      "name": "require",
-                      "nodeType": "Identifier",
-                      "overloadedDeclarations": [
-                        -18,
-                        -18
-                      ],
-                      "referencedDeclaration": -18,
-                      "src": "231:7:1",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$",
-                        "typeString": "function (bool,string memory) pure"
-                      }
-                    },
-                    "id": 53,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": false,
-                    "kind": "functionCall",
-                    "lValueRequested": false,
-                    "nameLocations": [],
-                    "names": [],
-                    "nodeType": "FunctionCall",
-                    "src": "231:50:1",
-                    "tryCall": false,
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_tuple$__$",
-                      "typeString": "tuple()"
-                    }
-                  },
-                  "id": 54,
-                  "nodeType": "ExpressionStatement",
-                  "src": "231:50:1"
-                },
-                {
-                  "expression": {
-                    "commonType": {
-                      "typeIdentifier": "t_uint256",
-                      "typeString": "uint256"
-                    },
-                    "id": 57,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": false,
-                    "lValueRequested": false,
-                    "leftExpression": {
-                      "id": 55,
-                      "name": "value",
-                      "nodeType": "Identifier",
-                      "overloadedDeclarations": [],
-                      "referencedDeclaration": 43,
-                      "src": "298:5:1",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_uint256",
-                        "typeString": "uint256"
-                      }
-                    },
-                    "nodeType": "BinaryOperation",
-                    "operator": "+",
-                    "rightExpression": {
-                      "hexValue": "31",
-                      "id": 56,
-                      "isConstant": false,
-                      "isLValue": false,
-                      "isPure": true,
-                      "kind": "number",
-                      "lValueRequested": false,
-                      "nodeType": "Literal",
-                      "src": "306:1:1",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_rational_1_by_1",
-                        "typeString": "int_const 1"
-                      },
-                      "value": "1"
-                    },
-                    "src": "298:9:1",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_uint256",
-                      "typeString": "uint256"
-                    }
-                  },
-                  "functionReturnParameters": 47,
-                  "id": 58,
-                  "nodeType": "Return",
-                  "src": "291:16:1"
-                }
-              ]
-            },
-            "functionSelector": "812600df",
-            "implemented": true,
-            "kind": "function",
-            "modifiers": [],
-            "name": "inc",
-            "nameLocation": "172:3:1",
-            "parameters": {
-              "id": 44,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 43,
-                  "mutability": "mutable",
-                  "name": "value",
-                  "nameLocation": "184:5:1",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 60,
-                  "src": "176:13:1",
-                  "stateVariable": false,
-                  "storageLocation": "default",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_uint256",
-                    "typeString": "uint256"
-                  },
-                  "typeName": {
-                    "id": 42,
-                    "name": "uint256",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "176:7:1",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_uint256",
-                      "typeString": "uint256"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "175:15:1"
-            },
-            "returnParameters": {
-              "id": 47,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 46,
-                  "mutability": "mutable",
-                  "name": "",
-                  "nameLocation": "-1:-1:-1",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 60,
-                  "src": "212:7:1",
-                  "stateVariable": false,
-                  "storageLocation": "default",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_uint256",
-                    "typeString": "uint256"
-                  },
-                  "typeName": {
-                    "id": 45,
-                    "name": "uint256",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "212:7:1",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_uint256",
-                      "typeString": "uint256"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "211:9:1"
-            },
-            "scope": 61,
-            "stateMutability": "pure",
-            "virtual": false,
-            "visibility": "public"
-          }
-        ],
-        "abstract": false,
-        "baseContracts": [],
-        "canonicalName": "RevertingContract",
-        "contractDependencies": [],
-        "contractKind": "contract",
-        "fullyImplemented": true,
-        "linearizedBaseContracts": [
-          61
-        ],
-        "name": "RevertingContract",
-        "nameLocation": "66:17:1",
-        "scope": 62,
-        "usedErrors": [],
-        "usedEvents": [
-          34
-        ]
-      }
-    ],
-    "license": "MIT"
-  },
-  "id": 1
-}
\ No newline at end of file
+{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"inc","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"event","name":"Trigger","inputs":[],"anonymous":false}],"bytecode":{"object":"0x608060405234801561000f575f80fd5b507f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d60405160405180910390a161024d806100495f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063812600df1461002d575b5f80fd5b610047600480360381019061004291906100ec565b61005d565b6040516100549190610126565b60405180910390f35b5f600a82106100a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161009890610199565b60405180910390fd5b6001826100ae91906101e4565b9050919050565b5f80fd5b5f819050919050565b6100cb816100b9565b81146100d5575f80fd5b50565b5f813590506100e6816100c2565b92915050565b5f60208284031215610101576101006100b5565b5b5f61010e848285016100d8565b91505092915050565b610120816100b9565b82525050565b5f6020820190506101395f830184610117565b92915050565b5f82825260208201905092915050565b7f63616e206f6e6c792068616e646c652076616c756573203c20313000000000005f82015250565b5f610183601b8361013f565b915061018e8261014f565b602082019050919050565b5f6020820190508181035f8301526101b081610177565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101ee826100b9565b91506101f9836100b9565b9250828201905080821115610211576102106101b7565b5b9291505056fea26469706673582212201d5be3aca99e1d2430eee51090e4c236bedcc30e14391ebad9ca024d7255f6e464736f6c63430008160033","sourceMap":"57:259:3:-:0;;;112:45;;;;;;;;;;141:9;;;;;;;;;;57:259;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063812600df1461002d575b5f80fd5b610047600480360381019061004291906100ec565b61005d565b6040516100549190610126565b60405180910390f35b5f600a82106100a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161009890610199565b60405180910390fd5b6001826100ae91906101e4565b9050919050565b5f80fd5b5f819050919050565b6100cb816100b9565b81146100d5575f80fd5b50565b5f813590506100e6816100c2565b92915050565b5f60208284031215610101576101006100b5565b5b5f61010e848285016100d8565b91505092915050565b610120816100b9565b82525050565b5f6020820190506101395f830184610117565b92915050565b5f82825260208201905092915050565b7f63616e206f6e6c792068616e646c652076616c756573203c20313000000000005f82015250565b5f610183601b8361013f565b915061018e8261014f565b602082019050919050565b5f6020820190508181035f8301526101b081610177565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101ee826100b9565b91506101f9836100b9565b9250828201905080821115610211576102106101b7565b5b9291505056fea26469706673582212201d5be3aca99e1d2430eee51090e4c236bedcc30e14391ebad9ca024d7255f6e464736f6c63430008160033","sourceMap":"57:259:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;163:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;212:7;247:2;239:5;:10;231:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;306:1;298:5;:9;;;;:::i;:::-;291:16;;163:151;;;:::o;88:117:5:-;197:1;194;187:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:118::-;1112:24;1130:5;1112:24;:::i;:::-;1107:3;1100:37;1025:118;;:::o;1149:222::-;1242:4;1280:2;1269:9;1265:18;1257:26;;1293:71;1361:1;1350:9;1346:17;1337:6;1293:71;:::i;:::-;1149:222;;;;:::o;1377:169::-;1461:11;1495:6;1490:3;1483:19;1535:4;1530:3;1526:14;1511:29;;1377:169;;;;:::o;1552:177::-;1692:29;1688:1;1680:6;1676:14;1669:53;1552:177;:::o;1735:366::-;1877:3;1898:67;1962:2;1957:3;1898:67;:::i;:::-;1891:74;;1974:93;2063:3;1974:93;:::i;:::-;2092:2;2087:3;2083:12;2076:19;;1735:366;;;:::o;2107:419::-;2273:4;2311:2;2300:9;2296:18;2288:26;;2360:9;2354:4;2350:20;2346:1;2335:9;2331:17;2324:47;2388:131;2514:4;2388:131;:::i;:::-;2380:139;;2107:419;;;:::o;2532:180::-;2580:77;2577:1;2570:88;2677:4;2674:1;2667:15;2701:4;2698:1;2691:15;2718:191;2758:3;2777:20;2795:1;2777:20;:::i;:::-;2772:25;;2811:20;2829:1;2811:20;:::i;:::-;2806:25;;2854:1;2851;2847:9;2840:16;;2875:3;2872:1;2869:10;2866:36;;;2882:18;;:::i;:::-;2866:36;2718:191;;;;:::o","linkReferences":{}},"methodIdentifiers":{"inc(uint256)":"812600df"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"inc\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/RevertingContract.sol\":\"RevertingContract\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/RevertingContract.sol\":{\"keccak256\":\"0xb0ccab460539f08d5f40044fee3e45c26590431d6d08734acde070ca01d84e23\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cece4cf2b0d867fb8ef474375f8907df5412056773e20e804e12061d98d057b\",\"dweb:/ipfs/QmeLfvzWjkpA6mCt1FJyNvgKeugzJJTRSBdyDUSBCovyrb\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"pure","type":"function","name":"inc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":false,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/RevertingContract.sol":"RevertingContract"},"evmVersion":"shanghai","libraries":{}},"sources":{"src/RevertingContract.sol":{"keccak256":"0xb0ccab460539f08d5f40044fee3e45c26590431d6d08734acde070ca01d84e23","urls":["bzz-raw://3cece4cf2b0d867fb8ef474375f8907df5412056773e20e804e12061d98d057b","dweb:/ipfs/QmeLfvzWjkpA6mCt1FJyNvgKeugzJJTRSBdyDUSBCovyrb"],"license":"MIT"}},"version":1},"id":3}
\ No newline at end of file
diff --git a/tests/contracts/out/SimpleContract.sol/SimpleContract.json b/tests/contracts/out/SimpleContract.sol/SimpleContract.json
index 502c9cd7d5f..21deecd6fe9 100644
--- a/tests/contracts/out/SimpleContract.sol/SimpleContract.json
+++ b/tests/contracts/out/SimpleContract.sol/SimpleContract.json
@@ -1,430 +1 @@
-{
-  "abi": [
-    {
-      "inputs": [],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "uint16",
-          "name": "x",
-          "type": "uint16"
-        }
-      ],
-      "name": "Trigger",
-      "type": "event"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint16",
-          "name": "x",
-          "type": "uint16"
-        }
-      ],
-      "name": "emitTrigger",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    }
-  ],
-  "bytecode": {
-    "object": "0x608060405234801561001057600080fd5b50604051600081527f166a7d625edff952ff346d1bca4edef10254353f72916b7fb072d55d0f97b5449060200160405180910390a160d7806100536000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c806316d04e0d14602d575b600080fd5b603c60383660046078565b603e565b005b60405161ffff821681527f166a7d625edff952ff346d1bca4edef10254353f72916b7fb072d55d0f97b5449060200160405180910390a150565b600060208284031215608957600080fd5b813561ffff81168114609a57600080fd5b939250505056fea2646970667358221220c2b4462405693955a38a8477cab1c40e3e03ce26bb5bdf71e0c13e051d80872164736f6c63430008160033",
-    "sourceMap": "57:184:2:-:0;;;117:46;;;;;;;;;-1:-1:-1;146:10:2;;154:1;167:38:3;;146:10:2;;155:2:3;140:18;146:10:2;;;;;;;57:184;;;;;;",
-    "linkReferences": {}
-  },
-  "deployedBytecode": {
-    "object": "0x6080604052348015600f57600080fd5b506004361060285760003560e01c806316d04e0d14602d575b600080fd5b603c60383660046078565b603e565b005b60405161ffff821681527f166a7d625edff952ff346d1bca4edef10254353f72916b7fb072d55d0f97b5449060200160405180910390a150565b600060208284031215608957600080fd5b813561ffff81168114609a57600080fd5b939250505056fea2646970667358221220c2b4462405693955a38a8477cab1c40e3e03ce26bb5bdf71e0c13e051d80872164736f6c63430008160033",
-    "sourceMap": "57:184:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;169:70;;;;;;:::i;:::-;;:::i;:::-;;;222:10;;465:6:3;453:19;;435:38;;222:10:2;;423:2:3;408:18;222:10:2;;;;;;;169:70;:::o;14:272:3:-;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;180:9;167:23;230:6;223:5;219:18;212:5;209:29;199:57;;252:1;249;242:12;199:57;275:5;14:272;-1:-1:-1;;;14:272:3:o",
-    "linkReferences": {}
-  },
-  "methodIdentifiers": {
-    "emitTrigger(uint16)": "16d04e0d"
-  },
-  "rawMetadata": "{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"}],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"}],\"name\":\"emitTrigger\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/SimpleContract.sol\":\"SimpleContract\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/SimpleContract.sol\":{\"keccak256\":\"0xa7c8b39d348362b0e5391dbf3151c976f1a962d8d8ac6a0e033bc8b8809cf298\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2a347eab9c0e8675a91c559e42894506c2a751bf65692549f6867f61e5063d72\",\"dweb:/ipfs/QmWC6R3ThMW7NDVNWXprdLfNQNfnESwpffXZqxPoXtAcUB\"]}},\"version\":1}",
-  "metadata": {
-    "compiler": {
-      "version": "0.8.22+commit.4fc1097e"
-    },
-    "language": "Solidity",
-    "output": {
-      "abi": [
-        {
-          "inputs": [],
-          "stateMutability": "nonpayable",
-          "type": "constructor"
-        },
-        {
-          "inputs": [
-            {
-              "internalType": "uint16",
-              "name": "x",
-              "type": "uint16",
-              "indexed": false
-            }
-          ],
-          "type": "event",
-          "name": "Trigger",
-          "anonymous": false
-        },
-        {
-          "inputs": [
-            {
-              "internalType": "uint16",
-              "name": "x",
-              "type": "uint16"
-            }
-          ],
-          "stateMutability": "nonpayable",
-          "type": "function",
-          "name": "emitTrigger"
-        }
-      ],
-      "devdoc": {
-        "kind": "dev",
-        "methods": {},
-        "version": 1
-      },
-      "userdoc": {
-        "kind": "user",
-        "methods": {},
-        "version": 1
-      }
-    },
-    "settings": {
-      "remappings": [],
-      "optimizer": {
-        "enabled": true,
-        "runs": 200
-      },
-      "metadata": {
-        "bytecodeHash": "ipfs"
-      },
-      "compilationTarget": {
-        "src/SimpleContract.sol": "SimpleContract"
-      },
-      "libraries": {}
-    },
-    "sources": {
-      "src/SimpleContract.sol": {
-        "keccak256": "0xa7c8b39d348362b0e5391dbf3151c976f1a962d8d8ac6a0e033bc8b8809cf298",
-        "urls": [
-          "bzz-raw://2a347eab9c0e8675a91c559e42894506c2a751bf65692549f6867f61e5063d72",
-          "dweb:/ipfs/QmWC6R3ThMW7NDVNWXprdLfNQNfnESwpffXZqxPoXtAcUB"
-        ],
-        "license": "MIT"
-      }
-    },
-    "version": 1
-  },
-  "ast": {
-    "absolutePath": "src/SimpleContract.sol",
-    "id": 87,
-    "exportedSymbols": {
-      "SimpleContract": [
-        86
-      ]
-    },
-    "nodeType": "SourceUnit",
-    "src": "32:210:2",
-    "nodes": [
-      {
-        "id": 63,
-        "nodeType": "PragmaDirective",
-        "src": "32:23:2",
-        "nodes": [],
-        "literals": [
-          "solidity",
-          "^",
-          "0.8",
-          ".0"
-        ]
-      },
-      {
-        "id": 86,
-        "nodeType": "ContractDefinition",
-        "src": "57:184:2",
-        "nodes": [
-          {
-            "id": 67,
-            "nodeType": "EventDefinition",
-            "src": "87:24:2",
-            "nodes": [],
-            "anonymous": false,
-            "eventSelector": "166a7d625edff952ff346d1bca4edef10254353f72916b7fb072d55d0f97b544",
-            "name": "Trigger",
-            "nameLocation": "93:7:2",
-            "parameters": {
-              "id": 66,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 65,
-                  "indexed": false,
-                  "mutability": "mutable",
-                  "name": "x",
-                  "nameLocation": "108:1:2",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 67,
-                  "src": "101:8:2",
-                  "stateVariable": false,
-                  "storageLocation": "default",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_uint16",
-                    "typeString": "uint16"
-                  },
-                  "typeName": {
-                    "id": 64,
-                    "name": "uint16",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "101:6:2",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_uint16",
-                      "typeString": "uint16"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "100:10:2"
-            }
-          },
-          {
-            "id": 75,
-            "nodeType": "FunctionDefinition",
-            "src": "117:46:2",
-            "nodes": [],
-            "body": {
-              "id": 74,
-              "nodeType": "Block",
-              "src": "131:32:2",
-              "nodes": [],
-              "statements": [
-                {
-                  "eventCall": {
-                    "arguments": [
-                      {
-                        "hexValue": "30",
-                        "id": 71,
-                        "isConstant": false,
-                        "isLValue": false,
-                        "isPure": true,
-                        "kind": "number",
-                        "lValueRequested": false,
-                        "nodeType": "Literal",
-                        "src": "154:1:2",
-                        "typeDescriptions": {
-                          "typeIdentifier": "t_rational_0_by_1",
-                          "typeString": "int_const 0"
-                        },
-                        "value": "0"
-                      }
-                    ],
-                    "expression": {
-                      "argumentTypes": [
-                        {
-                          "typeIdentifier": "t_rational_0_by_1",
-                          "typeString": "int_const 0"
-                        }
-                      ],
-                      "id": 70,
-                      "name": "Trigger",
-                      "nodeType": "Identifier",
-                      "overloadedDeclarations": [],
-                      "referencedDeclaration": 67,
-                      "src": "146:7:2",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_function_event_nonpayable$_t_uint16_$returns$__$",
-                        "typeString": "function (uint16)"
-                      }
-                    },
-                    "id": 72,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": false,
-                    "kind": "functionCall",
-                    "lValueRequested": false,
-                    "nameLocations": [],
-                    "names": [],
-                    "nodeType": "FunctionCall",
-                    "src": "146:10:2",
-                    "tryCall": false,
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_tuple$__$",
-                      "typeString": "tuple()"
-                    }
-                  },
-                  "id": 73,
-                  "nodeType": "EmitStatement",
-                  "src": "141:15:2"
-                }
-              ]
-            },
-            "implemented": true,
-            "kind": "constructor",
-            "modifiers": [],
-            "name": "",
-            "nameLocation": "-1:-1:-1",
-            "parameters": {
-              "id": 68,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "128:2:2"
-            },
-            "returnParameters": {
-              "id": 69,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "131:0:2"
-            },
-            "scope": 86,
-            "stateMutability": "nonpayable",
-            "virtual": false,
-            "visibility": "public"
-          },
-          {
-            "id": 85,
-            "nodeType": "FunctionDefinition",
-            "src": "169:70:2",
-            "nodes": [],
-            "body": {
-              "id": 84,
-              "nodeType": "Block",
-              "src": "207:32:2",
-              "nodes": [],
-              "statements": [
-                {
-                  "eventCall": {
-                    "arguments": [
-                      {
-                        "id": 81,
-                        "name": "x",
-                        "nodeType": "Identifier",
-                        "overloadedDeclarations": [],
-                        "referencedDeclaration": 77,
-                        "src": "230:1:2",
-                        "typeDescriptions": {
-                          "typeIdentifier": "t_uint16",
-                          "typeString": "uint16"
-                        }
-                      }
-                    ],
-                    "expression": {
-                      "argumentTypes": [
-                        {
-                          "typeIdentifier": "t_uint16",
-                          "typeString": "uint16"
-                        }
-                      ],
-                      "id": 80,
-                      "name": "Trigger",
-                      "nodeType": "Identifier",
-                      "overloadedDeclarations": [],
-                      "referencedDeclaration": 67,
-                      "src": "222:7:2",
-                      "typeDescriptions": {
-                        "typeIdentifier": "t_function_event_nonpayable$_t_uint16_$returns$__$",
-                        "typeString": "function (uint16)"
-                      }
-                    },
-                    "id": 82,
-                    "isConstant": false,
-                    "isLValue": false,
-                    "isPure": false,
-                    "kind": "functionCall",
-                    "lValueRequested": false,
-                    "nameLocations": [],
-                    "names": [],
-                    "nodeType": "FunctionCall",
-                    "src": "222:10:2",
-                    "tryCall": false,
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_tuple$__$",
-                      "typeString": "tuple()"
-                    }
-                  },
-                  "id": 83,
-                  "nodeType": "EmitStatement",
-                  "src": "217:15:2"
-                }
-              ]
-            },
-            "functionSelector": "16d04e0d",
-            "implemented": true,
-            "kind": "function",
-            "modifiers": [],
-            "name": "emitTrigger",
-            "nameLocation": "178:11:2",
-            "parameters": {
-              "id": 78,
-              "nodeType": "ParameterList",
-              "parameters": [
-                {
-                  "constant": false,
-                  "id": 77,
-                  "mutability": "mutable",
-                  "name": "x",
-                  "nameLocation": "197:1:2",
-                  "nodeType": "VariableDeclaration",
-                  "scope": 85,
-                  "src": "190:8:2",
-                  "stateVariable": false,
-                  "storageLocation": "default",
-                  "typeDescriptions": {
-                    "typeIdentifier": "t_uint16",
-                    "typeString": "uint16"
-                  },
-                  "typeName": {
-                    "id": 76,
-                    "name": "uint16",
-                    "nodeType": "ElementaryTypeName",
-                    "src": "190:6:2",
-                    "typeDescriptions": {
-                      "typeIdentifier": "t_uint16",
-                      "typeString": "uint16"
-                    }
-                  },
-                  "visibility": "internal"
-                }
-              ],
-              "src": "189:10:2"
-            },
-            "returnParameters": {
-              "id": 79,
-              "nodeType": "ParameterList",
-              "parameters": [],
-              "src": "207:0:2"
-            },
-            "scope": 86,
-            "stateMutability": "nonpayable",
-            "virtual": false,
-            "visibility": "public"
-          }
-        ],
-        "abstract": false,
-        "baseContracts": [],
-        "canonicalName": "SimpleContract",
-        "contractDependencies": [],
-        "contractKind": "contract",
-        "fullyImplemented": true,
-        "linearizedBaseContracts": [
-          86
-        ],
-        "name": "SimpleContract",
-        "nameLocation": "66:14:2",
-        "scope": 87,
-        "usedErrors": [],
-        "usedEvents": [
-          67
-        ]
-      }
-    ],
-    "license": "MIT"
-  },
-  "id": 2
-}
\ No newline at end of file
+{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"emitAnotherTrigger","inputs":[{"name":"a","type":"uint256","internalType":"uint256"},{"name":"b","type":"uint256","internalType":"uint256"},{"name":"c","type":"uint256","internalType":"uint256"},{"name":"data","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"emitTrigger","inputs":[{"name":"x","type":"uint16","internalType":"uint16"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"event","name":"AnotherTrigger","inputs":[{"name":"a","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"b","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"c","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"data","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"type":"event","name":"Trigger","inputs":[{"name":"x","type":"uint16","indexed":false,"internalType":"uint16"}],"anonymous":false}],"bytecode":{"object":"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","sourceMap":"57:596:4:-:0;;;308:46;;;;;;;;;;337:10;345:1;337:10;;;;;;:::i;:::-;;;;;;;;57:596;;7:85:5;52:7;81:5;70:16;;7:85;;;:::o;98:89::-;134:7;174:6;167:5;163:18;152:29;;98:89;;;:::o;193:60::-;221:3;242:5;235:12;;193:60;;;:::o;259:156::-;316:9;349:60;366:42;375:32;401:5;375:32;:::i;:::-;366:42;:::i;:::-;349:60;:::i;:::-;336:73;;259:156;;;:::o;421:145::-;515:44;553:5;515:44;:::i;:::-;510:3;503:57;421:145;;:::o;572:236::-;672:4;710:2;699:9;695:18;687:26;;723:78;798:1;787:9;783:17;774:6;723:78;:::i;:::-;572:236;;;;:::o;57:596:4:-;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"57:596:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;360:70;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;474:177;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;360:70;413:10;421:1;413:10;;;;;;:::i;:::-;;;;;;;;360:70;:::o;474:177::-;636:1;633;630;615:29;639:4;615:29;;;;;;:::i;:::-;;;;;;;;474:177;;;;:::o;7:75:5:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:89;370:7;410:6;403:5;399:18;388:29;;334:89;;;:::o;429:120::-;501:23;518:5;501:23;:::i;:::-;494:5;491:34;481:62;;539:1;536;529:12;481:62;429:120;:::o;555:137::-;600:5;638:6;625:20;616:29;;654:32;680:5;654:32;:::i;:::-;555:137;;;;:::o;698:327::-;756:6;805:2;793:9;784:7;780:23;776:32;773:119;;;811:79;;:::i;:::-;773:119;931:1;956:52;1000:7;991:6;980:9;976:22;956:52;:::i;:::-;946:62;;902:116;698:327;;;;:::o;1031:77::-;1068:7;1097:5;1086:16;;1031:77;;;:::o;1114:122::-;1187:24;1205:5;1187:24;:::i;:::-;1180:5;1177:35;1167:63;;1226:1;1223;1216:12;1167:63;1114:122;:::o;1242:139::-;1288:5;1326:6;1313:20;1304:29;;1342:33;1369:5;1342:33;:::i;:::-;1242:139;;;;:::o;1387:117::-;1496:1;1493;1486:12;1510:117;1619:1;1616;1609:12;1633:102;1674:6;1725:2;1721:7;1716:2;1709:5;1705:14;1701:28;1691:38;;1633:102;;;:::o;1741:180::-;1789:77;1786:1;1779:88;1886:4;1883:1;1876:15;1910:4;1907:1;1900:15;1927:281;2010:27;2032:4;2010:27;:::i;:::-;2002:6;1998:40;2140:6;2128:10;2125:22;2104:18;2092:10;2089:34;2086:62;2083:88;;;2151:18;;:::i;:::-;2083:88;2191:10;2187:2;2180:22;1970:238;1927:281;;:::o;2214:129::-;2248:6;2275:20;;:::i;:::-;2265:30;;2304:33;2332:4;2324:6;2304:33;:::i;:::-;2214:129;;;:::o;2349:308::-;2411:4;2501:18;2493:6;2490:30;2487:56;;;2523:18;;:::i;:::-;2487:56;2561:29;2583:6;2561:29;:::i;:::-;2553:37;;2645:4;2639;2635:15;2627:23;;2349:308;;;:::o;2663:146::-;2760:6;2755:3;2750;2737:30;2801:1;2792:6;2787:3;2783:16;2776:27;2663:146;;;:::o;2815:425::-;2893:5;2918:66;2934:49;2976:6;2934:49;:::i;:::-;2918:66;:::i;:::-;2909:75;;3007:6;3000:5;2993:21;3045:4;3038:5;3034:16;3083:3;3074:6;3069:3;3065:16;3062:25;3059:112;;;3090:79;;:::i;:::-;3059:112;3180:54;3227:6;3222:3;3217;3180:54;:::i;:::-;2899:341;2815:425;;;;;:::o;3260:340::-;3316:5;3365:3;3358:4;3350:6;3346:17;3342:27;3332:122;;3373:79;;:::i;:::-;3332:122;3490:6;3477:20;3515:79;3590:3;3582:6;3575:4;3567:6;3563:17;3515:79;:::i;:::-;3506:88;;3322:278;3260:340;;;;:::o;3606:945::-;3702:6;3710;3718;3726;3775:3;3763:9;3754:7;3750:23;3746:33;3743:120;;;3782:79;;:::i;:::-;3743:120;3902:1;3927:53;3972:7;3963:6;3952:9;3948:22;3927:53;:::i;:::-;3917:63;;3873:117;4029:2;4055:53;4100:7;4091:6;4080:9;4076:22;4055:53;:::i;:::-;4045:63;;4000:118;4157:2;4183:53;4228:7;4219:6;4208:9;4204:22;4183:53;:::i;:::-;4173:63;;4128:118;4313:2;4302:9;4298:18;4285:32;4344:18;4336:6;4333:30;4330:117;;;4366:79;;:::i;:::-;4330:117;4471:63;4526:7;4517:6;4506:9;4502:22;4471:63;:::i;:::-;4461:73;;4256:288;3606:945;;;;;;;:::o;4557:115::-;4642:23;4659:5;4642:23;:::i;:::-;4637:3;4630:36;4557:115;;:::o;4678:218::-;4769:4;4807:2;4796:9;4792:18;4784:26;;4820:69;4886:1;4875:9;4871:17;4862:6;4820:69;:::i;:::-;4678:218;;;;:::o;4902:99::-;4954:6;4988:5;4982:12;4972:22;;4902:99;;;:::o;5007:169::-;5091:11;5125:6;5120:3;5113:19;5165:4;5160:3;5156:14;5141:29;;5007:169;;;;:::o;5182:246::-;5263:1;5273:113;5287:6;5284:1;5281:13;5273:113;;;5372:1;5367:3;5363:11;5357:18;5353:1;5348:3;5344:11;5337:39;5309:2;5306:1;5302:10;5297:15;;5273:113;;;5420:1;5411:6;5406:3;5402:16;5395:27;5244:184;5182:246;;;:::o;5434:377::-;5522:3;5550:39;5583:5;5550:39;:::i;:::-;5605:71;5669:6;5664:3;5605:71;:::i;:::-;5598:78;;5685:65;5743:6;5738:3;5731:4;5724:5;5720:16;5685:65;:::i;:::-;5775:29;5797:6;5775:29;:::i;:::-;5770:3;5766:39;5759:46;;5526:285;5434:377;;;;:::o;5817:313::-;5930:4;5968:2;5957:9;5953:18;5945:26;;6017:9;6011:4;6007:20;6003:1;5992:9;5988:17;5981:47;6045:78;6118:4;6109:6;6045:78;:::i;:::-;6037:86;;5817:313;;;;:::o","linkReferences":{}},"methodIdentifiers":{"emitAnotherTrigger(uint256,uint256,uint256,string)":"931919ea","emitTrigger(uint16)":"16d04e0d"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"c\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"AnotherTrigger\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"}],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"c\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"emitAnotherTrigger\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"}],\"name\":\"emitTrigger\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/SimpleContract.sol\":\"SimpleContract\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/SimpleContract.sol\":{\"keccak256\":\"0xda954fc2eb36f5f3658f71e59fdb487c6f8947efa45e5e3fb7038c7faff99de0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e8253c13afee68eee23965caf364c3812ca6065eac5655faf9c20d9f231b9b1d\",\"dweb:/ipfs/QmXPdwfDAMniiwJHPt2WBvaT5gK1LUK3aM81Jq5m3n8UPF\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256","indexed":true},{"internalType":"uint256","name":"b","type":"uint256","indexed":true},{"internalType":"uint256","name":"c","type":"uint256","indexed":true},{"internalType":"string","name":"data","type":"string","indexed":false}],"type":"event","name":"AnotherTrigger","anonymous":false},{"inputs":[{"internalType":"uint16","name":"x","type":"uint16","indexed":false}],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"},{"internalType":"uint256","name":"c","type":"uint256"},{"internalType":"string","name":"data","type":"string"}],"stateMutability":"nonpayable","type":"function","name":"emitAnotherTrigger"},{"inputs":[{"internalType":"uint16","name":"x","type":"uint16"}],"stateMutability":"nonpayable","type":"function","name":"emitTrigger"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":false,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/SimpleContract.sol":"SimpleContract"},"evmVersion":"shanghai","libraries":{}},"sources":{"src/SimpleContract.sol":{"keccak256":"0xda954fc2eb36f5f3658f71e59fdb487c6f8947efa45e5e3fb7038c7faff99de0","urls":["bzz-raw://e8253c13afee68eee23965caf364c3812ca6065eac5655faf9c20d9f231b9b1d","dweb:/ipfs/QmXPdwfDAMniiwJHPt2WBvaT5gK1LUK3aM81Jq5m3n8UPF"],"license":"MIT"}},"version":1},"id":4}
\ No newline at end of file
diff --git a/tests/contracts/src/DeclaredCallsContract.sol b/tests/contracts/src/DeclaredCallsContract.sol
new file mode 100644
index 00000000000..9b53f5f8a9b
--- /dev/null
+++ b/tests/contracts/src/DeclaredCallsContract.sol
@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract DeclaredCallsContract {
+    // Asset struct for testing struct field access
+    struct Asset {
+        address addr; // field 0
+        uint256 amount; // field 1
+        bool active; // field 2
+    }
+
+    // Complex nested struct for advanced testing
+    struct ComplexAsset {
+        Asset base; // field 0
+        string metadata; // field 1
+        uint256[] values; // field 2
+    }
+
+    // Events for testing declared calls
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event AssetTransfer(Asset asset, address to, uint256 blockNumber);
+    event ComplexAssetCreated(ComplexAsset complexAsset, uint256 id);
+
+    // Storage for testing view functions
+    mapping(address => uint256) public balances;
+    mapping(address => string) public metadata;
+    mapping(uint256 => Asset) public assets;
+    mapping(uint256 => address) public assetOwners;
+    uint256 public totalSupply;
+
+    // State variables for testing
+    bool public shouldRevert = false;
+    uint256 public counter = 0;
+
+    constructor() {
+        // Initialize some test data
+        balances[msg.sender] = 1000;
+        balances[address(0x1111111111111111111111111111111111111111)] = 1000;
+        balances[address(0x2222222222222222222222222222222222222222)] = 1000;
+        totalSupply = 3000;
+
+        // Create some test assets
+        assets[1] = Asset({
+            addr: address(0x1111111111111111111111111111111111111111),
+            amount: 100,
+            active: true
+        });
+        assetOwners[1] = msg.sender;
+        metadata[
+            address(0x1111111111111111111111111111111111111111)
+        ] = "Test Asset 1";
+
+        assets[2] = Asset({
+            addr: address(0x2222222222222222222222222222222222222222),
+            amount: 200,
+            active: false
+        });
+        assetOwners[2] = msg.sender;
+        metadata[
+            address(0x2222222222222222222222222222222222222222)
+        ] = "Test Asset 2";
+    }
+
+    // Basic functions for declared calls testing
+    function balanceOf(address account) public view returns (uint256) {
+        return balances[account];
+    }
+
+    function getOwner(address assetAddr) public view returns (address) {
+        // Find asset by address and return owner
+        for (uint256 i = 1; i <= 10; i++) {
+            if (assets[i].addr == assetAddr) {
+                return assetOwners[i];
+            }
+        }
+        return address(0);
+    }
+
+    function getMetadata(
+        address assetAddr
+    ) public view returns (string memory) {
+        return metadata[assetAddr];
+    }
+
+    function getAssetAmount(uint256 assetId) public view returns (uint256) {
+        return assets[assetId].amount;
+    }
+
+    function isAssetActive(uint256 assetId) public view returns (bool) {
+        return assets[assetId].active;
+    }
+
+    // Functions for testing edge cases
+    function alwaysReverts() public pure returns (bool) {
+        if (1 > 0) {
+            revert("This function always reverts");
+        }
+        return true;
+    }
+
+    function conditionalRevert() public view {
+        if (shouldRevert) {
+            revert("Conditional revert triggered");
+        }
+    }
+
+    function incrementCounter() public returns (uint256) {
+        counter++;
+        return counter;
+    }
+
+    // Functions to emit events for testing
+    function emitTransfer(address from, address to, uint256 value) public {
+        balances[from] -= value;
+        balances[to] += value;
+        emit Transfer(from, to, value);
+    }
+
+    function emitAssetTransfer(
+        address assetAddr,
+        uint256 amount,
+        bool active,
+        address to
+    ) public {
+        Asset memory asset = Asset({
+            addr: assetAddr,
+            amount: amount,
+            active: active
+        });
+        emit AssetTransfer(asset, to, block.number);
+    }
+
+    function emitComplexAssetCreated(
+        address baseAddr,
+        uint256 baseAmount,
+        bool baseActive,
+        string memory metadataStr,
+        uint256[] memory values,
+        uint256 id
+    ) public {
+        Asset memory baseAsset = Asset({
+            addr: baseAddr,
+            amount: baseAmount,
+            active: baseActive
+        });
+
+        ComplexAsset memory complexAsset = ComplexAsset({
+            base: baseAsset,
+            metadata: metadataStr,
+            values: values
+        });
+
+        emit ComplexAssetCreated(complexAsset, id);
+    }
+
+    // Utility functions
+    function setShouldRevert(bool _shouldRevert) public {
+        shouldRevert = _shouldRevert;
+    }
+
+    function getConstant() public pure returns (uint256) {
+        return 42;
+    }
+
+    function sum(uint256 a, uint256 b) public pure returns (uint256) {
+        return a + b;
+    }
+
+    // Function that doesn't exist in ABI (for testing invalid function calls)
+    // This will be removed from the ABI manually
+    function hiddenFunction() public pure returns (uint256) {
+        return 999;
+    }
+}
diff --git a/tests/contracts/src/SimpleContract.sol b/tests/contracts/src/SimpleContract.sol
index a949eb21347..998688bba23 100644
--- a/tests/contracts/src/SimpleContract.sol
+++ b/tests/contracts/src/SimpleContract.sol
@@ -4,6 +4,14 @@ pragma solidity ^0.8.0;
 contract SimpleContract {
     event Trigger(uint16 x);
 
+    // New event with three indexed parameters (topics)
+    event AnotherTrigger(
+        uint256 indexed a,
+        uint256 indexed b,
+        uint256 indexed c,
+        string data
+    );
+
     constructor() {
         emit Trigger(0);
     }
@@ -11,4 +19,14 @@ contract SimpleContract {
     function emitTrigger(uint16 x) public {
         emit Trigger(x);
     }
+
+    // Function to emit the new event
+    function emitAnotherTrigger(
+        uint256 a,
+        uint256 b,
+        uint256 c,
+        string memory data
+    ) public {
+        emit AnotherTrigger(a, b, c, data);
+    }
 }
diff --git a/tests/docker-compose.yml b/tests/docker-compose.yml
index 2e6a48f2e41..8bf5f4c62be 100644
--- a/tests/docker-compose.yml
+++ b/tests/docker-compose.yml
@@ -1,7 +1,7 @@
 version: '3'
 services:
   ipfs:
-    image: docker.io/ipfs/kubo:v0.17.0
+    image: docker.io/ipfs/kubo:v0.34.1
     ports:
       - '127.0.0.1:3001:5001'
   postgres:
@@ -20,10 +20,12 @@ services:
       POSTGRES_DB: graph-node
       POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C"
   anvil:
-    image: ghcr.io/foundry-rs/foundry:latest
+    # Pinned to specific version since newer versions do not produce
+    # deterministic block hashes. Unpin once that's fixed upstream
+    image: ghcr.io/foundry-rs/foundry:v1.4.0
     ports:
       - '3021:8545'
-    command: "'anvil --host 0.0.0.0 --gas-limit 100000000000 --base-fee 1 --block-time 5'"
+    command: "'anvil --host 0.0.0.0 --gas-limit 100000000000 --base-fee 1 --timestamp 1743944919 --mnemonic \"test test test test test test test test test test test junk\"'"
 
 # graph-node ports:
 #   json-rpc: 8020
diff --git a/tests/integration-tests/api-version-v0-0-4/package.json b/tests/integration-tests/api-version-v0-0-4/package.json
deleted file mode 100644
index fc4d2fb1c7b..00000000000
--- a/tests/integration-tests/api-version-v0-0-4/package.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "name": "api-version-v0-0-4",
-  "version": "0.1.0",
-  "scripts": {
-    "build-contracts": "../../common/build-contracts.sh",
-    "codegen": "graph codegen --skip-migrations",
-    "test": "yarn build-contracts && truffle test --compile-none --network test",
-    "create:test": "graph create test/api-version-v0-0-4 --node $GRAPH_NODE_ADMIN_URI",
-    "deploy:test": "graph deploy test/api-version-v0-0-4 --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
-  },
-  "note": "Do not update the dependencies below - we want to make sure it's backward comaptible, so we are using an old CLI version on purpose.",
-  "devDependencies": {
-    "@graphprotocol/graph-cli": "0.62.0",
-    "@graphprotocol/graph-ts": "0.31.0",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "@truffle/contract": "^4.3",
-    "@truffle/hdwallet-provider": "^1.2",
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1",
-    "truffle": "^5.2"
-  }
-}
diff --git a/tests/integration-tests/api-version-v0-0-4/schema.graphql b/tests/integration-tests/api-version-v0-0-4/schema.graphql
deleted file mode 100644
index 6c007b3245b..00000000000
--- a/tests/integration-tests/api-version-v0-0-4/schema.graphql
+++ /dev/null
@@ -1,5 +0,0 @@
-# The `id` is the block number and `count` the handler invocations at that block.
-type DataSourceCount @entity {
-  id: ID!
-  count: Int!
-}
diff --git a/tests/integration-tests/api-version-v0-0-4/src/mapping.ts b/tests/integration-tests/api-version-v0-0-4/src/mapping.ts
deleted file mode 100644
index 36b326f6110..00000000000
--- a/tests/integration-tests/api-version-v0-0-4/src/mapping.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import {
-  ethereum,
-  DataSourceContext,
-  dataSource,
-  Address,
-  BigInt,
-} from "@graphprotocol/graph-ts";
-import { Template } from "../generated/templates";
-import { DataSourceCount } from "../generated/schema";
-
-export function handleBlock(block: ethereum.Block): void {
-  let context = new DataSourceContext();
-  context.setBigInt("number", block.number);
-
-  Template.createWithContext(
-    changetype<Address>(Address.fromHexString(
-      "0x2E645469f354BB4F5c8a05B3b30A929361cf77eC"
-    )),
-    context
-  );
-}
-
-export function handleBlockTemplate(block: ethereum.Block): void {
-  let count = DataSourceCount.load(block.number.toString());
-  if (count == null) {
-    count = new DataSourceCount(block.number.toString());
-    count.count = 0;
-  }
-
-  let ctx = dataSource.context();
-  let number = ctx.getBigInt("number");
-  assert(
-    count.count == number.toI32(),
-    "wrong count, found " + BigInt.fromI32(count.count).toString()
-  );
-  count.count += 1;
-  count.save();
-}
diff --git a/tests/integration-tests/api-version-v0-0-4/subgraph.yaml b/tests/integration-tests/api-version-v0-0-4/subgraph.yaml
deleted file mode 100644
index 6326752d966..00000000000
--- a/tests/integration-tests/api-version-v0-0-4/subgraph.yaml
+++ /dev/null
@@ -1,43 +0,0 @@
-specVersion: 0.0.2
-repository: https://github.com/graphprotocol/example-subgraph
-schema:
-  file: ./schema.graphql
-features:
-  - nonFatalErrors
-dataSources:
-  - kind: ethereum/contract
-    name: Contract
-    network: test
-    source:
-      address: "@SimpleContract@"
-      abi: Contract
-    mapping:
-      kind: ethereum/events
-      apiVersion: 0.0.4
-      language: wasm/assemblyscript
-      entities:
-        - Gravatar
-      abis:
-        - name: Contract
-          file: ./abis/Contract.abi
-      blockHandlers:
-        - handler: handleBlock
-      file: ./src/mapping.ts
-templates:
-  - kind: ethereum/contract
-    name: Template
-    network: test
-    source:
-      abi: Contract
-    mapping:
-      kind: ethereum/events
-      apiVersion: 0.0.4
-      language: wasm/assemblyscript
-      entities:
-        - Gravatar
-      abis:
-        - name: Contract
-          file: ./abis/Contract.abi
-      blockHandlers:
-        - handler: handleBlockTemplate
-      file: ./src/mapping.ts
diff --git a/tests/integration-tests/api-version-v0-0-4/test/test.js b/tests/integration-tests/api-version-v0-0-4/test/test.js
deleted file mode 100644
index fd0e2ee2257..00000000000
--- a/tests/integration-tests/api-version-v0-0-4/test/test.js
+++ /dev/null
@@ -1,79 +0,0 @@
-const path = require("path");
-const execSync = require("child_process").execSync;
-const { system, patching } = require("gluegun");
-const { createApolloFetch } = require("apollo-fetch");
-
-const Contract = artifacts.require("./Contract.sol");
-
-const srcDir = path.join(__dirname, "..");
-
-const indexPort = process.env.GRAPH_NODE_INDEX_PORT || 18030;
-
-const fetchSubgraphs = createApolloFetch({
-  uri: `http://localhost:${indexPort}/graphql`,
-});
-
-const exec = (cmd) => {
-  try {
-    return execSync(cmd, { cwd: srcDir, stdio: "inherit" });
-  } catch (e) {
-    throw new Error(`Failed to run command \`${cmd}\``);
-  }
-};
-
-const waitForSubgraphToBeSynced = async () =>
-  new Promise((resolve, reject) => {
-    // Wait for 60s
-    let deadline = Date.now() + 60 * 1000;
-
-    // Function to check if the subgraph is synced
-    const checkSubgraphSynced = async () => {
-      try {
-        let result = await fetchSubgraphs({
-          query: `{ indexingStatuses { synced, health } }`,
-        });
-
-        if (result.data.indexingStatuses[0].synced) {
-          resolve();
-        } else if (result.data.indexingStatuses[0].health != "healthy") {
-          reject(new Error("Subgraph failed"));
-        } else {
-          throw new Error("reject or retry");
-        }
-      } catch (e) {
-        if (Date.now() > deadline) {
-          reject(new Error(`Timed out waiting for the subgraph to sync`));
-        } else {
-          setTimeout(checkSubgraphSynced, 500);
-        }
-      }
-    };
-
-    // Periodically check whether the subgraph has synced
-    setTimeout(checkSubgraphSynced, 0);
-  });
-
-contract("Contract", (accounts) => {
-  // Deploy the subgraph once before all tests
-  before(async () => {
-    // Deploy the contract
-    const contract = await Contract.deployed();
-
-    // Insert its address into subgraph manifest
-    await patching.replace(
-      path.join(srcDir, "subgraph.yaml"),
-      "0x0000000000000000000000000000000000000000",
-      contract.address
-    );
-
-    // Create and deploy the subgraph
-    exec(`yarn codegen`);
-    exec(`yarn create:test`);
-    exec(`yarn deploy:test`);
-  });
-
-  it("subgraph does not fail", async () => {
-    // Wait for the subgraph to be indexed, and not fail
-    await waitForSubgraphToBeSynced();
-  });
-});
diff --git a/tests/integration-tests/api-version-v0-0-4/truffle.js b/tests/integration-tests/api-version-v0-0-4/truffle.js
deleted file mode 100644
index 58130e7d21d..00000000000
--- a/tests/integration-tests/api-version-v0-0-4/truffle.js
+++ /dev/null
@@ -1,22 +0,0 @@
-require("babel-register");
-require("babel-polyfill");
-
-module.exports = {
-  contracts_directory: "../../common",
-  migrations_directory: "../../common",
-  contracts_build_directory: "./truffle_output",
-  networks: {
-    test: {
-      host: "localhost",
-      port: process.env.GANACHE_TEST_PORT || 18545,
-      network_id: "*",
-      gas: "100000000000",
-      gasPrice: "1",
-    },
-  },
-  compilers: {
-    solc: {
-      version: "0.8.2"
-    },
-  },
-};
diff --git a/tests/integration-tests/api-version-v0-0-4/abis/Contract.abi b/tests/integration-tests/base/abis/Contract.abi
similarity index 100%
rename from tests/integration-tests/api-version-v0-0-4/abis/Contract.abi
rename to tests/integration-tests/base/abis/Contract.abi
diff --git a/tests/integration-tests/base/package.json b/tests/integration-tests/base/package.json
new file mode 100644
index 00000000000..43234781f5e
--- /dev/null
+++ b/tests/integration-tests/base/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "base-subgraph",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/base-subgraph --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.34.0"
+  }
+}
diff --git a/tests/integration-tests/base/schema.graphql b/tests/integration-tests/base/schema.graphql
new file mode 100644
index 00000000000..f7034353d73
--- /dev/null
+++ b/tests/integration-tests/base/schema.graphql
@@ -0,0 +1,5 @@
+type BaseData @entity(immutable: true) {
+  id: ID!
+  data: String!
+  blockNumber: BigInt!
+} 
\ No newline at end of file
diff --git a/tests/integration-tests/base/src/mapping.ts b/tests/integration-tests/base/src/mapping.ts
new file mode 100644
index 00000000000..11767070a5b
--- /dev/null
+++ b/tests/integration-tests/base/src/mapping.ts
@@ -0,0 +1,9 @@
+import { ethereum } from '@graphprotocol/graph-ts'
+import { BaseData } from '../generated/schema'
+
+export function handleBlock(block: ethereum.Block): void {
+  let entity = new BaseData(block.number.toString())
+  entity.data = 'from base'
+  entity.blockNumber = block.number
+  entity.save()
+} 
\ No newline at end of file
diff --git a/tests/integration-tests/base/subgraph.yaml b/tests/integration-tests/base/subgraph.yaml
new file mode 100644
index 00000000000..808b446c622
--- /dev/null
+++ b/tests/integration-tests/base/subgraph.yaml
@@ -0,0 +1,25 @@
+specVersion: 0.0.5
+description: Base Subgraph
+repository: https://github.com/graphprotocol/graph-node
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: SimpleContract
+    network: test
+    source:
+      address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
+      abi: SimpleContract
+      startBlock: 0
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - BaseData
+      abis:
+        - name: SimpleContract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlock
+      file: ./src/mapping.ts 
\ No newline at end of file
diff --git a/tests/integration-tests/block-handlers/package.json b/tests/integration-tests/block-handlers/package.json
index 8d6109854b8..1914ac70dcb 100644
--- a/tests/integration-tests/block-handlers/package.json
+++ b/tests/integration-tests/block-handlers/package.json
@@ -1,25 +1,12 @@
 {
   "name": "block-handlers",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
-    "build-contracts": "../../common/build-contracts.sh",
     "codegen": "graph codegen --skip-migrations",
-    "test": "yarn build-contracts && truffle test --compile-none --network test",
-    "create:test": "graph create test/block-handlers --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/block-handlers --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
-    "@graphprotocol/graph-cli": "0.62.0",
-    "@graphprotocol/graph-ts": "0.31.0",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "@truffle/contract": "^4.3",
-    "@truffle/hdwallet-provider": "^1.2",
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1",
-    "truffle": "^5.2"
+    "@graphprotocol/graph-ts": "0.34.0"
   }
 }
diff --git a/tests/integration-tests/declared-calls-basic/abis/Contract.abi b/tests/integration-tests/declared-calls-basic/abis/Contract.abi
new file mode 120000
index 00000000000..469d21b4a48
--- /dev/null
+++ b/tests/integration-tests/declared-calls-basic/abis/Contract.abi
@@ -0,0 +1 @@
+../../../contracts/abis/DeclaredCallsContract.json
\ No newline at end of file
diff --git a/tests/integration-tests/declared-calls-basic/package.json b/tests/integration-tests/declared-calls-basic/package.json
new file mode 100644
index 00000000000..75ffa2b4081
--- /dev/null
+++ b/tests/integration-tests/declared-calls-basic/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "declared-calls-basic",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "build": "graph build --ipfs $IPFS_URI",
+    "codegen": "graph codegen"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.33.0"
+  }
+}
diff --git a/tests/integration-tests/declared-calls-basic/schema.graphql b/tests/integration-tests/declared-calls-basic/schema.graphql
new file mode 100644
index 00000000000..3617a551ec8
--- /dev/null
+++ b/tests/integration-tests/declared-calls-basic/schema.graphql
@@ -0,0 +1,23 @@
+type TransferCall @entity(immutable: true) {
+  id: ID!
+  from: Bytes!
+  to: Bytes!
+  value: BigInt!
+  balanceFromBefore: BigInt!
+  balanceToBefore: BigInt!
+  totalSupply: BigInt!
+  constantValue: BigInt!
+  sumResult: BigInt!
+  metadataFrom: String!
+  revertCallSucceeded: Boolean!
+  blockNumber: BigInt!
+  transactionHash: Bytes!
+}
+
+type CallResult @entity(immutable: true) {
+  id: ID!
+  label: String!
+  success: Boolean!
+  value: String
+  error: String
+}
diff --git a/tests/integration-tests/declared-calls-basic/src/mapping.ts b/tests/integration-tests/declared-calls-basic/src/mapping.ts
new file mode 100644
index 00000000000..fb5f5e52dd7
--- /dev/null
+++ b/tests/integration-tests/declared-calls-basic/src/mapping.ts
@@ -0,0 +1,94 @@
+import { ethereum, log, BigInt } from "@graphprotocol/graph-ts";
+import { Contract, Transfer } from "../generated/Contract/Contract";
+import { TransferCall, CallResult } from "../generated/schema";
+
+export function handleTransfer(event: Transfer): void {
+  let id = event.transaction.hash.toHex() + "-" + event.logIndex.toString();
+  let transferCall = new TransferCall(id);
+
+  transferCall.from = event.params.from;
+  transferCall.to = event.params.to;
+  transferCall.value = event.params.value;
+  transferCall.blockNumber = event.block.number;
+  transferCall.transactionHash = event.transaction.hash;
+
+  // Test declared calls - these should be available before the handler runs
+
+  // Basic successful calls
+  const contract = Contract.bind(event.address);
+  let balanceFromCall = contract.try_balanceOf(event.params.from);
+  if (!balanceFromCall.reverted) {
+    transferCall.balanceFromBefore = balanceFromCall.value;
+    createCallResult(id + "-balance_from", "balance_from", true, balanceFromCall.value.toString(), null);
+  } else {
+    transferCall.balanceFromBefore = BigInt.fromI32(0);
+    createCallResult(id + "-balance_from", "balance_from", false, null, "Call failed");
+  }
+
+  let balanceToCall = contract.try_balanceOf(event.params.to);
+  if (!balanceToCall.reverted) {
+    transferCall.balanceToBefore = balanceToCall.value;
+    createCallResult(id + "-balance_to", "balance_to", true, balanceToCall.value.toString(), null);
+  } else {
+    transferCall.balanceToBefore = BigInt.fromI32(0);
+    createCallResult(id + "-balance_to", "balance_to", false, null, "Call failed");
+  }
+
+  let totalSupplyCall = contract.try_totalSupply();
+  if (!totalSupplyCall.reverted) {
+    transferCall.totalSupply = totalSupplyCall.value;
+    createCallResult(id + "-total_supply", "total_supply", true, totalSupplyCall.value.toString(), null);
+  } else {
+    transferCall.totalSupply = BigInt.fromI32(0);
+    createCallResult(id + "-total_supply", "total_supply", false, null, "Call failed");
+  }
+
+  let constantCall = contract.try_getConstant();
+  if (!constantCall.reverted) {
+    transferCall.constantValue = constantCall.value;
+    createCallResult(id + "-constant_value", "constant_value", true, constantCall.value.toString(), null);
+  } else {
+    transferCall.constantValue = BigInt.fromI32(0);
+    createCallResult(id + "-constant_value", "constant_value", false, null, "Call failed");
+  }
+
+  let sumCall = contract.try_sum(event.params.value, event.params.value);
+  if (!sumCall.reverted) {
+    transferCall.sumResult = sumCall.value;
+    createCallResult(id + "-sum_values", "sum_values", true, sumCall.value.toString(), null);
+  } else {
+    transferCall.sumResult = BigInt.fromI32(0);
+    createCallResult(id + "-sum_values", "sum_values", false, null, "Call failed");
+  }
+
+  let metadataCall = contract.try_getMetadata(event.params.from);
+  if (!metadataCall.reverted) {
+    transferCall.metadataFrom = metadataCall.value.toString();
+    createCallResult(id + "-metadata_from", "metadata_from", true, metadataCall.value.toString(), null);
+  } else {
+    transferCall.metadataFrom = "";
+    createCallResult(id + "-metadata_from", "metadata_from", false, null, "Call failed");
+  }
+
+  // Test call that should revert
+  let revertCall = contract.try_alwaysReverts();
+  transferCall.revertCallSucceeded = !revertCall.reverted;
+  if (!revertCall.reverted) {
+    createCallResult(id + "-will_revert", "will_revert", true, revertCall.value.toString(), null);
+    log.warning("Expected revert call succeeded unexpectedly", []);
+  } else {
+    createCallResult(id + "-will_revert", "will_revert", false, null, "Call reverted as expected");
+    log.info("Revert call failed as expected", []);
+  }
+
+  transferCall.save();
+}
+
+function createCallResult(id: string, label: string, success: boolean, value: string | null, error: string | null): void {
+  let callResult = new CallResult(id);
+  callResult.label = label;
+  callResult.success = success;
+  callResult.value = value;
+  callResult.error = error;
+  callResult.save();
+}
diff --git a/tests/integration-tests/declared-calls-basic/subgraph.yaml b/tests/integration-tests/declared-calls-basic/subgraph.yaml
new file mode 100644
index 00000000000..162157385d7
--- /dev/null
+++ b/tests/integration-tests/declared-calls-basic/subgraph.yaml
@@ -0,0 +1,33 @@
+specVersion: 1.2.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "@DeclaredCallsContract@"
+      abi: Contract
+      startBlock: 1
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      entities:
+        - TransferCall
+        - CallResult
+      eventHandlers:
+        - event: Transfer(indexed address,indexed address,uint256)
+          handler: handleTransfer
+          calls:
+            balance_from: "Contract[event.address].balanceOf(event.params.from)"
+            balance_to: "Contract[event.address].balanceOf(event.params.to)"
+            total_supply: "Contract[event.address].totalSupply()"
+            constant_value: "Contract[event.address].getConstant()"
+            sum_values: "Contract[event.address].sum(event.params.value, event.params.value)"
+            will_revert: "Contract[event.address].alwaysReverts()"
+            metadata_from: "Contract[event.address].getMetadata(event.params.from)"
+      file: ./src/mapping.ts
diff --git a/tests/integration-tests/declared-calls-struct-fields/abis/Contract.abi b/tests/integration-tests/declared-calls-struct-fields/abis/Contract.abi
new file mode 120000
index 00000000000..469d21b4a48
--- /dev/null
+++ b/tests/integration-tests/declared-calls-struct-fields/abis/Contract.abi
@@ -0,0 +1 @@
+../../../contracts/abis/DeclaredCallsContract.json
\ No newline at end of file
diff --git a/tests/integration-tests/declared-calls-struct-fields/package.json b/tests/integration-tests/declared-calls-struct-fields/package.json
new file mode 100644
index 00000000000..480acf52726
--- /dev/null
+++ b/tests/integration-tests/declared-calls-struct-fields/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "declared-calls-struct-fields",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "build": "graph build --ipfs false",
+    "codegen": "graph codegen"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.33.0"
+  }
+}
diff --git a/tests/integration-tests/declared-calls-struct-fields/schema.graphql b/tests/integration-tests/declared-calls-struct-fields/schema.graphql
new file mode 100644
index 00000000000..564e12eeb9d
--- /dev/null
+++ b/tests/integration-tests/declared-calls-struct-fields/schema.graphql
@@ -0,0 +1,45 @@
+type AssetTransferCall @entity(immutable: true) {
+  id: ID!
+  assetAddr: Bytes!
+  assetAmount: BigInt!
+  assetActive: Boolean!
+  to: Bytes!
+  blockNumber: BigInt!
+
+  # Results from named field access
+  owner: Bytes!
+  metadata: String!
+  amountCalc: BigInt!
+
+  # Regular call result
+  recipientBalance: BigInt!
+
+  transactionHash: Bytes!
+}
+
+type ComplexAssetCall @entity(immutable: true) {
+  id: ID!
+  complexAssetId: BigInt!
+  baseAssetAddr: Bytes!
+  baseAssetAmount: BigInt!
+  baseAssetActive: Boolean!
+  metadata: String!
+
+  # Results from nested struct field access
+  baseAssetOwner: Bytes!
+  baseAssetMetadata: String!
+  baseAssetAmountCalc: BigInt!
+
+  blockNumber: BigInt!
+  transactionHash: Bytes!
+}
+
+type StructFieldTest @entity(immutable: true) {
+  id: ID!
+  testType: String!
+  fieldName: String!
+  success: Boolean!
+  result: String
+  error: String
+  blockNumber: BigInt!
+}
diff --git a/tests/integration-tests/declared-calls-struct-fields/src/mapping.ts b/tests/integration-tests/declared-calls-struct-fields/src/mapping.ts
new file mode 100644
index 00000000000..2f0232b4d38
--- /dev/null
+++ b/tests/integration-tests/declared-calls-struct-fields/src/mapping.ts
@@ -0,0 +1,120 @@
+import { ethereum, log, BigInt, Address } from "@graphprotocol/graph-ts";
+import { AssetTransfer, ComplexAssetCreated, Contract } from "../generated/Contract/Contract";
+import { AssetTransferCall, ComplexAssetCall, StructFieldTest } from "../generated/schema";
+
+export function handleAssetTransfer(event: AssetTransfer): void {
+  let id = event.transaction.hash.toHex() + "-" + event.logIndex.toString();
+  let assetTransferCall = new AssetTransferCall(id);
+
+  // Store event data
+  assetTransferCall.assetAddr = event.params.asset.addr;
+  assetTransferCall.assetAmount = event.params.asset.amount;
+  assetTransferCall.assetActive = event.params.asset.active;
+  assetTransferCall.to = event.params.to;
+  assetTransferCall.blockNumber = event.block.number;
+  assetTransferCall.transactionHash = event.transaction.hash;
+
+  // Test struct field access by index; the mapping code uses named fields,
+  // but the underlying calls in the manifest are declared using an index
+  const contract = Contract.bind(event.address);
+  let ownerCall = contract.try_getOwner(event.params.asset.addr);
+  if (!ownerCall.reverted) {
+    assetTransferCall.owner = ownerCall.value;
+    createStructFieldTest(id + "-owner", "asset_owner", "addr", true, ownerCall.value.toString(), null, event.block.number);
+  } else {
+    assetTransferCall.owner = Address.zero();
+    createStructFieldTest(id + "-owner", "asset_owner", "addr", false, null, "Call failed", event.block.number);
+  }
+
+  let metadataCall = contract.try_getMetadata(event.params.asset.addr);
+  if (!metadataCall.reverted) {
+    assetTransferCall.metadata = metadataCall.value.toString();
+    createStructFieldTest(id + "-metadata-by-name", "asset_metadata", "addr", true, metadataCall.value.toString(), null, event.block.number);
+  } else {
+    assetTransferCall.metadata = "";
+    createStructFieldTest(id + "-metadata-by-name", "asset_metadata", "addr", false, null, "Call failed", event.block.number);
+  }
+
+  let amountCalcCall = contract.try_sum(event.params.asset.amount, event.params.asset.amount);
+  if (!amountCalcCall.reverted) {
+    assetTransferCall.amountCalc = amountCalcCall.value;
+    createStructFieldTest(id + "-amount-by-name", "asset_amount", "amount", true, amountCalcCall.value.toString(), null, event.block.number);
+  } else {
+    assetTransferCall.amountCalc = BigInt.fromI32(0);
+    createStructFieldTest(id + "-amount-by-name", "asset_amount", "amount", false, null, "Call failed", event.block.number);
+  }
+
+  // Regular call (not using struct fields)
+  let balanceCall = contract.try_balanceOf(event.params.to)
+  if (!balanceCall.reverted) {
+    assetTransferCall.recipientBalance = balanceCall.value;
+  } else {
+    assetTransferCall.recipientBalance = BigInt.fromI32(0);
+  }
+
+  assetTransferCall.save();
+}
+
+export function handleComplexAssetCreated(event: ComplexAssetCreated): void {
+  let id = event.transaction.hash.toHex() + "-" + event.logIndex.toString();
+  let complexAssetCall = new ComplexAssetCall(id);
+
+  // Store event data
+  complexAssetCall.complexAssetId = event.params.id;
+  complexAssetCall.baseAssetAddr = event.params.complexAsset.base.addr;
+  complexAssetCall.baseAssetAmount = event.params.complexAsset.base.amount;
+  complexAssetCall.baseAssetActive = event.params.complexAsset.base.active;
+  complexAssetCall.metadata = event.params.complexAsset.metadata;
+  complexAssetCall.blockNumber = event.block.number;
+  complexAssetCall.transactionHash = event.transaction.hash;
+
+  // Test nested struct field access
+  const contract = Contract.bind(event.address);
+  let baseOwnerCall = contract.try_getOwner(event.params.complexAsset.base.addr);
+  if (!baseOwnerCall.reverted) {
+    complexAssetCall.baseAssetOwner = baseOwnerCall.value;
+    createStructFieldTest(id + "-base-owner", "base_asset", "base.addr", true, baseOwnerCall.value.toString(), null, event.block.number);
+  } else {
+    complexAssetCall.baseAssetOwner = Address.zero();
+    createStructFieldTest(id + "-base-owner", "base_asset", "base.addr", false, null, "Call failed", event.block.number);
+  }
+
+  let baseMetadataCall = contract.try_getMetadata(event.params.complexAsset.base.addr);
+  if (!baseMetadataCall.reverted) {
+    complexAssetCall.baseAssetMetadata = baseMetadataCall.value.toString();
+    createStructFieldTest(id + "-base-metadata", "base_metadata", "base.addr", true, baseMetadataCall.value.toString(), null, event.block.number);
+  } else {
+    complexAssetCall.baseAssetMetadata = "";
+    createStructFieldTest(id + "-base-metadata", "base_metadata", "base.addr", false, null, "Call failed", event.block.number);
+  }
+
+  let baseAmountCalcCall = contract.try_sum(event.params.complexAsset.base.amount, event.params.id);
+  if (!baseAmountCalcCall.reverted) {
+    complexAssetCall.baseAssetAmountCalc = baseAmountCalcCall.value;
+    createStructFieldTest(id + "-base-amount", "base_amount", "base.amount", true, baseAmountCalcCall.value.toString(), null, event.block.number);
+  } else {
+    complexAssetCall.baseAssetAmountCalc = BigInt.fromI32(0);
+    createStructFieldTest(id + "-base-amount", "base_amount", "base.amount", false, null, "Call failed", event.block.number);
+  }
+
+  complexAssetCall.save();
+}
+
+function createStructFieldTest(
+  id: string,
+  testType: string,
+  fieldName: string,
+  success: boolean,
+  result: string | null,
+  error: string | null,
+  blockNumber: BigInt
+): void {
+  let test = new StructFieldTest(id);
+  test.testType = testType;
+  test.fieldName = fieldName;
+  test.success = success;
+  test.result = result;
+  test.error = error;
+  test.blockNumber = blockNumber;
+  test.save();
+}
diff --git a/tests/integration-tests/declared-calls-struct-fields/subgraph.yaml b/tests/integration-tests/declared-calls-struct-fields/subgraph.yaml
new file mode 100644
index 00000000000..5d8d5767a79
--- /dev/null
+++ b/tests/integration-tests/declared-calls-struct-fields/subgraph.yaml
@@ -0,0 +1,37 @@
+specVersion: 1.4.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "@DeclaredCallsContract@"
+      abi: Contract
+      startBlock: 1
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      entities:
+        - AssetTransferCall
+        - ComplexAssetCall
+        - StructFieldTest
+      eventHandlers:
+        - event: AssetTransfer((address,uint256,bool),address,uint256)
+          handler: handleAssetTransfer
+          calls:
+            asset_owner: "Contract[event.address].getOwner(event.params.asset.0)" # addr
+            asset_metadata: "Contract[event.address].getMetadata(event.params.asset.0)" # addr
+            balance_of_recipient: "Contract[event.address].balanceOf(event.params.to)"
+            asset_amount: "Contract[event.address].sum(event.params.asset.1, event.params.asset.1)" # amount
+        - event: ComplexAssetCreated(((address,uint256,bool),string,uint256[]),uint256)
+          handler: handleComplexAssetCreated
+          calls:
+            base_asset_owner: "Contract[event.address].getOwner(event.params.complexAsset.base.addr)"
+            base_asset_metadata: "Contract[event.address].getMetadata(event.params.complexAsset.base.addr)"
+            base_asset_amount: "Contract[event.address].sum(event.params.complexAsset.base.amount, event.params.id)"
+      file: ./src/mapping.ts
diff --git a/tests/integration-tests/ethereum-api-tests/abis/Contract.abi b/tests/integration-tests/ethereum-api-tests/abis/Contract.abi
new file mode 100644
index 00000000000..02da1a9e7f3
--- /dev/null
+++ b/tests/integration-tests/ethereum-api-tests/abis/Contract.abi
@@ -0,0 +1,33 @@
+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "Trigger",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "emitTrigger",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/tests/integration-tests/ethereum-api-tests/package.json b/tests/integration-tests/ethereum-api-tests/package.json
new file mode 100644
index 00000000000..8bed6a2e310
--- /dev/null
+++ b/tests/integration-tests/ethereum-api-tests/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "ethereum-api-tests",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/block-handlers --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.36.0-alpha-20240422133139-8761ea3"
+  }
+}
diff --git a/tests/integration-tests/ethereum-api-tests/schema.graphql b/tests/integration-tests/ethereum-api-tests/schema.graphql
new file mode 100644
index 00000000000..3391894d855
--- /dev/null
+++ b/tests/integration-tests/ethereum-api-tests/schema.graphql
@@ -0,0 +1,6 @@
+type Foo @entity {
+  id: ID!
+  balance: BigInt!
+  hasCode1: Boolean!
+  hasCode2: Boolean!
+}
diff --git a/tests/integration-tests/ethereum-api-tests/src/mapping.ts b/tests/integration-tests/ethereum-api-tests/src/mapping.ts
new file mode 100644
index 00000000000..8f4b6d87de0
--- /dev/null
+++ b/tests/integration-tests/ethereum-api-tests/src/mapping.ts
@@ -0,0 +1,29 @@
+import { Address, dataSource, ethereum } from "@graphprotocol/graph-ts";
+import { Trigger } from "../generated/Contract/Contract";
+import { Foo } from "../generated/schema";
+
+export function handleTrigger(event: Trigger): void {
+  let entity = Foo.load("initialize");
+
+  // The second address created from the mnemonic provided to anvil in ../../docker-compose.yml
+  let address1 = Address.fromString(
+    "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+  );
+  let address_str = dataSource.context().getString("contract");
+  let address2 = Address.fromString(address_str);
+
+  let balance = ethereum.getBalance(address1);
+
+  let hasCode1 = ethereum.hasCode(address1);
+  let hasCode2 = ethereum.hasCode(address2);
+
+  if (!entity) {
+    entity = new Foo(event.params.x.toString());
+  }
+
+  entity.balance = balance;
+  entity.hasCode1 = hasCode1.inner;
+  entity.hasCode2 = hasCode2.inner;
+
+  entity.save();
+}
diff --git a/tests/integration-tests/ethereum-api-tests/subgraph.yaml b/tests/integration-tests/ethereum-api-tests/subgraph.yaml
new file mode 100644
index 00000000000..def2f97e004
--- /dev/null
+++ b/tests/integration-tests/ethereum-api-tests/subgraph.yaml
@@ -0,0 +1,28 @@
+specVersion: 0.0.8
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "@SimpleContract@"
+      abi: Contract
+      startBlock: 1
+    context:
+      contract:
+        type: String
+        data: "@SimpleContract@"
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      entities:
+        - Call
+      eventHandlers:
+        - event: Trigger(uint16)
+          handler: handleTrigger
+      file: ./src/mapping.ts
diff --git a/tests/integration-tests/ganache-reverts/package.json b/tests/integration-tests/ganache-reverts/package.json
deleted file mode 100644
index 79766e9c554..00000000000
--- a/tests/integration-tests/ganache-reverts/package.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-  "name": "ganache-reverts",
-  "version": "0.1.0",
-  "scripts": {
-    "build-contracts": "../../common/build-contracts.sh",
-    "codegen": "graph codegen --skip-migrations",
-    "test": "yarn build-contracts && truffle test --compile-none --network test",
-    "create:test": "graph create test/ganache-reverts --node $GRAPH_NODE_ADMIN_URI",
-    "deploy:test": "graph deploy test/ganache-reverts --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
-  },
-  "devDependencies": {
-    "@graphprotocol/graph-cli": "0.62.0",
-    "@graphprotocol/graph-ts": "0.31.0",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "@truffle/contract": "^4.3",
-    "@truffle/hdwallet-provider": "^1.2",
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1",
-    "truffle": "^5.2"
-  }
-}
diff --git a/tests/integration-tests/grafted/abis/Contract.abi b/tests/integration-tests/grafted/abis/Contract.abi
new file mode 100644
index 00000000000..02da1a9e7f3
--- /dev/null
+++ b/tests/integration-tests/grafted/abis/Contract.abi
@@ -0,0 +1,33 @@
+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "Trigger",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "emitTrigger",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/tests/integration-tests/grafted/package.json b/tests/integration-tests/grafted/package.json
new file mode 100644
index 00000000000..b6960fd85fe
--- /dev/null
+++ b/tests/integration-tests/grafted/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "grafted-subgraph",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/grafted-subgraph --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.34.0"
+  }
+}
diff --git a/tests/integration-tests/grafted/schema.graphql b/tests/integration-tests/grafted/schema.graphql
new file mode 100644
index 00000000000..b83083fd466
--- /dev/null
+++ b/tests/integration-tests/grafted/schema.graphql
@@ -0,0 +1,5 @@
+type GraftedData @entity(immutable: true) {
+  id: ID!
+  data: String!
+  blockNumber: BigInt!
+} 
\ No newline at end of file
diff --git a/tests/integration-tests/grafted/src/mapping.ts b/tests/integration-tests/grafted/src/mapping.ts
new file mode 100644
index 00000000000..742d5d67c54
--- /dev/null
+++ b/tests/integration-tests/grafted/src/mapping.ts
@@ -0,0 +1,9 @@
+import { ethereum } from '@graphprotocol/graph-ts'
+import { GraftedData } from '../generated/schema'
+
+export function handleBlock(block: ethereum.Block): void {
+  let entity = new GraftedData(block.number.toString())
+  entity.data = 'to grafted'
+  entity.blockNumber = block.number
+  entity.save()
+} 
\ No newline at end of file
diff --git a/tests/integration-tests/grafted/subgraph.yaml b/tests/integration-tests/grafted/subgraph.yaml
new file mode 100644
index 00000000000..6cd33f93006
--- /dev/null
+++ b/tests/integration-tests/grafted/subgraph.yaml
@@ -0,0 +1,30 @@
+specVersion: 0.0.6
+description: Grafted Subgraph
+repository: https://github.com/graphprotocol/graph-node
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: SimpleContract
+    network: test
+    source:
+      address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
+      abi: SimpleContract
+      startBlock: 0
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - GraftedData
+      abis:
+        - name: SimpleContract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlock
+      file: ./src/mapping.ts
+features:
+  - grafting
+graft:
+  base: '@base@'
+  block: 2
diff --git a/tests/integration-tests/host-exports/package.json b/tests/integration-tests/host-exports/package.json
index 6094e20e7ce..c8b5c906fb5 100644
--- a/tests/integration-tests/host-exports/package.json
+++ b/tests/integration-tests/host-exports/package.json
@@ -1,25 +1,12 @@
 {
   "name": "host-exports",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
-    "build-contracts": "../../common/build-contracts.sh",
     "codegen": "graph codegen --skip-migrations",
-    "test": "yarn build-contracts && truffle test --compile-none --network test",
-    "create:test": "graph create test/host-exports --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/host-exports --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
-    "@graphprotocol/graph-cli": "0.62.0",
-    "@graphprotocol/graph-ts": "0.31.0",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "@truffle/contract": "^4.3",
-    "@truffle/hdwallet-provider": "^1.2",
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1",
-    "truffle": "^5.2"
+    "@graphprotocol/graph-ts": "0.34.0"
   }
 }
diff --git a/tests/integration-tests/int8/package.json b/tests/integration-tests/int8/package.json
index 654a0b98866..bd70d90c42f 100644
--- a/tests/integration-tests/int8/package.json
+++ b/tests/integration-tests/int8/package.json
@@ -1,25 +1,12 @@
 {
   "name": "int8",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
-    "build-contracts": "../../common/build-contracts.sh",
     "codegen": "graph codegen --skip-migrations",
-    "test": "yarn build-contracts && truffle test --compile-none --network test",
-    "create:test": "graph create test/int8 --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/int8 --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
-    "@graphprotocol/graph-cli": "0.62.0",
-    "@graphprotocol/graph-ts": "0.31.0",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "@truffle/contract": "^4.3",
-    "@truffle/hdwallet-provider": "^1.2",
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1",
-    "truffle": "^5.2"
+    "@graphprotocol/graph-ts": "0.34.0"
   }
 }
diff --git a/tests/integration-tests/logs-query/abis/Contract.abi b/tests/integration-tests/logs-query/abis/Contract.abi
new file mode 100644
index 00000000000..02da1a9e7f3
--- /dev/null
+++ b/tests/integration-tests/logs-query/abis/Contract.abi
@@ -0,0 +1,33 @@
+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "Trigger",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "emitTrigger",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/tests/integration-tests/logs-query/package.json b/tests/integration-tests/logs-query/package.json
new file mode 100644
index 00000000000..c1a68515054
--- /dev/null
+++ b/tests/integration-tests/logs-query/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "logs-query-subgraph",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/logs-query --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-cli": "0.69.0",
+    "@graphprotocol/graph-ts": "0.34.0"
+  }
+}
diff --git a/tests/integration-tests/logs-query/schema.graphql b/tests/integration-tests/logs-query/schema.graphql
new file mode 100644
index 00000000000..1459e34353b
--- /dev/null
+++ b/tests/integration-tests/logs-query/schema.graphql
@@ -0,0 +1,4 @@
+type Trigger @entity {
+  id: ID!
+  x: Int!
+}
diff --git a/tests/integration-tests/logs-query/src/mapping.ts b/tests/integration-tests/logs-query/src/mapping.ts
new file mode 100644
index 00000000000..8f4d55e6a9f
--- /dev/null
+++ b/tests/integration-tests/logs-query/src/mapping.ts
@@ -0,0 +1,39 @@
+import { Trigger as TriggerEvent } from "../generated/Contract/Contract";
+import { Trigger } from "../generated/schema";
+import { log } from "@graphprotocol/graph-ts";
+
+export function handleTrigger(event: TriggerEvent): void {
+  let entity = new Trigger(event.transaction.hash.toHex());
+  entity.x = event.params.x;
+  entity.save();
+
+  // Generate various log levels and types for testing
+  let x = event.params.x as i32;
+
+  if (x == 0) {
+    log.info("Processing trigger with value zero", []);
+  }
+
+  if (x == 1) {
+    log.error("Error processing trigger", []);
+  }
+
+  if (x == 2) {
+    log.warning("Warning: unusual trigger value", ["hash", event.transaction.hash.toHexString()]);
+  }
+
+  if (x == 3) {
+    log.debug("Debug: trigger details", ["blockNumber", event.block.number.toString()]);
+  }
+
+  if (x == 4) {
+    log.info("Handler execution successful", ["entity_id", entity.id]);
+  }
+
+  if (x == 5) {
+    log.error("Critical timeout error", []);
+  }
+
+  // Log for every event to test general log capture
+  log.info("Trigger event processed", []);
+}
diff --git a/tests/integration-tests/logs-query/subgraph.yaml b/tests/integration-tests/logs-query/subgraph.yaml
new file mode 100644
index 00000000000..be3061d5533
--- /dev/null
+++ b/tests/integration-tests/logs-query/subgraph.yaml
@@ -0,0 +1,26 @@
+specVersion: 0.0.5
+description: Logs Query Test Subgraph
+repository: https://github.com/graphprotocol/graph-node
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
+      abi: Contract
+      startBlock: 0
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - Trigger
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      eventHandlers:
+        - event: Trigger(uint16)
+          handler: handleTrigger
+      file: ./src/mapping.ts
diff --git a/tests/integration-tests/multiple-subgraph-datasources/package.json b/tests/integration-tests/multiple-subgraph-datasources/package.json
new file mode 100644
index 00000000000..62e390226aa
--- /dev/null
+++ b/tests/integration-tests/multiple-subgraph-datasources/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "multiple-subgraph-datasources",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/multiple-subgraph-datasources --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.36.0-alpha-20241129215038-b75cda9"
+  }
+}
diff --git a/tests/integration-tests/multiple-subgraph-datasources/schema.graphql b/tests/integration-tests/multiple-subgraph-datasources/schema.graphql
new file mode 100644
index 00000000000..569588477f6
--- /dev/null
+++ b/tests/integration-tests/multiple-subgraph-datasources/schema.graphql
@@ -0,0 +1,6 @@
+type AggregatedData @entity {
+  id: ID!
+  sourceA: String
+  sourceB: String
+  first: String!
+}
diff --git a/tests/integration-tests/multiple-subgraph-datasources/src/mapping.ts b/tests/integration-tests/multiple-subgraph-datasources/src/mapping.ts
new file mode 100644
index 00000000000..72220584836
--- /dev/null
+++ b/tests/integration-tests/multiple-subgraph-datasources/src/mapping.ts
@@ -0,0 +1,26 @@
+import { dataSource, EntityTrigger, log } from '@graphprotocol/graph-ts'
+import { AggregatedData } from '../generated/schema'
+import { SourceAData } from '../generated/subgraph-SourceA'
+import { SourceBData } from '../generated/subgraph-SourceB'
+
+
+// We know this handler will run first since its defined first in the manifest
+// So we dont need to check if the Aggregated data exists
+export function handleSourceAData(data: SourceAData): void {
+  let aggregated = new AggregatedData(data.id)
+  aggregated.sourceA = data.data
+  aggregated.first = 'sourceA'
+  aggregated.save()
+}
+
+export function handleSourceBData(data: SourceBData): void {
+  let aggregated = AggregatedData.load(data.id)
+  if (!aggregated) {
+    aggregated = new AggregatedData(data.id)
+    aggregated.sourceB = data.data
+    aggregated.first = 'sourceB'
+  } else {
+    aggregated.sourceB = data.data
+  }
+  aggregated.save()
+}
diff --git a/tests/integration-tests/multiple-subgraph-datasources/subgraph.yaml b/tests/integration-tests/multiple-subgraph-datasources/subgraph.yaml
new file mode 100644
index 00000000000..00afb4e60b6
--- /dev/null
+++ b/tests/integration-tests/multiple-subgraph-datasources/subgraph.yaml
@@ -0,0 +1,35 @@
+specVersion: 1.3.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: subgraph
+    name: SourceA
+    network: test
+    source:
+      address: '@source-subgraph-a@'
+      startBlock: 0
+    mapping:
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - AggregatedData
+      handlers:
+        - handler: handleSourceAData
+          entity: SourceAData
+      file: ./src/mapping.ts
+
+  - kind: subgraph
+    name: SourceB
+    network: test
+    source:
+      address: '@source-subgraph-b@'
+      startBlock: 0
+    mapping:
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - AggregatedData
+      handlers:
+        - handler: handleSourceBData
+          entity: SourceBData
+      file: ./src/mapping.ts
diff --git a/tests/integration-tests/non-fatal-errors/package.json b/tests/integration-tests/non-fatal-errors/package.json
index 016ebb6b996..bf2417b6e7f 100644
--- a/tests/integration-tests/non-fatal-errors/package.json
+++ b/tests/integration-tests/non-fatal-errors/package.json
@@ -1,25 +1,12 @@
 {
   "name": "non-fatal-errors",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
-    "build-contracts": "../../common/build-contracts.sh",
     "codegen": "graph codegen --skip-migrations",
-    "test": "yarn build-contracts && truffle test --compile-none --network test",
-    "create:test": "graph create test/non-fatal-errors --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/non-fatal-errors --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
-    "@graphprotocol/graph-cli": "0.62.0",
-    "@graphprotocol/graph-ts": "0.31.0",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "@truffle/contract": "^4.3",
-    "@truffle/hdwallet-provider": "^1.2",
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1",
-    "truffle": "^5.2"
+    "@graphprotocol/graph-ts": "0.34.0"
   }
 }
diff --git a/tests/integration-tests/overloaded-functions/package.json b/tests/integration-tests/overloaded-functions/package.json
index 457d6894d12..d00de20329c 100644
--- a/tests/integration-tests/overloaded-functions/package.json
+++ b/tests/integration-tests/overloaded-functions/package.json
@@ -1,25 +1,12 @@
 {
   "name": "overloaded-contract-functions",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
-    "build-contracts": "../../common/build-contracts.sh",
     "codegen": "graph codegen --skip-migrations",
-    "test": "yarn build-contracts && truffle test --compile-none --network test",
-    "create:test": "graph create test/overloaded-contract-functions --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/overloaded-contract-functions --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
-    "@graphprotocol/graph-cli": "0.62.0",
-    "@graphprotocol/graph-ts": "0.31.0",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "@truffle/contract": "^4.3",
-    "@truffle/hdwallet-provider": "^1.2",
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1",
-    "truffle": "^5.2"
+    "@graphprotocol/graph-ts": "0.34.0"
   }
 }
diff --git a/tests/integration-tests/package.json b/tests/integration-tests/package.json
deleted file mode 100644
index ea25cc3f6f0..00000000000
--- a/tests/integration-tests/package.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "private": true,
-  "workspaces": [
-    "*"
-  ]
-}
diff --git a/tests/integration-tests/poi-for-failed-subgraph/package.json b/tests/integration-tests/poi-for-failed-subgraph/package.json
index 4c7e802f2cb..fc5e9048f43 100644
--- a/tests/integration-tests/poi-for-failed-subgraph/package.json
+++ b/tests/integration-tests/poi-for-failed-subgraph/package.json
@@ -1,25 +1,12 @@
 {
   "name": "poi-for-failed-subgraph",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
-    "build-contracts": "../../common/build-contracts.sh",
     "codegen": "graph codegen --skip-migrations",
-    "test": "yarn build-contracts && truffle test --compile-none --network test",
-    "create:test": "graph create test/poi-for-failed-subgraph --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/poi-for-failed-subgraph --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
-    "@graphprotocol/graph-cli": "0.62.0",
-    "@graphprotocol/graph-ts": "0.31.0",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "@truffle/contract": "^4.3",
-    "@truffle/hdwallet-provider": "^1.2",
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1",
-    "truffle": "^5.2"
+    "@graphprotocol/graph-ts": "0.34.0"
   }
 }
diff --git a/tests/integration-tests/remove-then-update/package.json b/tests/integration-tests/remove-then-update/package.json
index bfb2764db05..d9b4f5fd213 100644
--- a/tests/integration-tests/remove-then-update/package.json
+++ b/tests/integration-tests/remove-then-update/package.json
@@ -1,25 +1,12 @@
 {
   "name": "remove-then-update",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
-    "build-contracts": "../../common/build-contracts.sh",
     "codegen": "graph codegen --skip-migrations",
-    "test": "yarn build-contracts && truffle test --compile-none --network test",
-    "create:test": "graph create test/remove-then-update --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/remove-then-update --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
-    "@graphprotocol/graph-cli": "0.62.0",
-    "@graphprotocol/graph-ts": "0.31.0",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "@truffle/contract": "^4.3",
-    "@truffle/hdwallet-provider": "^1.2",
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1",
-    "truffle": "^5.2"
+    "@graphprotocol/graph-ts": "0.34.0"
   }
 }
diff --git a/tests/integration-tests/ganache-reverts/abis/Contract.abi b/tests/integration-tests/reverted-calls/abis/Contract.abi
similarity index 100%
rename from tests/integration-tests/ganache-reverts/abis/Contract.abi
rename to tests/integration-tests/reverted-calls/abis/Contract.abi
diff --git a/tests/integration-tests/reverted-calls/package.json b/tests/integration-tests/reverted-calls/package.json
new file mode 100644
index 00000000000..ee985b1752a
--- /dev/null
+++ b/tests/integration-tests/reverted-calls/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "reverted-calls",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/ganache-reverts --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.34.0"
+  }
+}
diff --git a/tests/integration-tests/ganache-reverts/schema.graphql b/tests/integration-tests/reverted-calls/schema.graphql
similarity index 100%
rename from tests/integration-tests/ganache-reverts/schema.graphql
rename to tests/integration-tests/reverted-calls/schema.graphql
diff --git a/tests/integration-tests/ganache-reverts/src/mapping.ts b/tests/integration-tests/reverted-calls/src/mapping.ts
similarity index 100%
rename from tests/integration-tests/ganache-reverts/src/mapping.ts
rename to tests/integration-tests/reverted-calls/src/mapping.ts
diff --git a/tests/integration-tests/ganache-reverts/subgraph.yaml b/tests/integration-tests/reverted-calls/subgraph.yaml
similarity index 100%
rename from tests/integration-tests/ganache-reverts/subgraph.yaml
rename to tests/integration-tests/reverted-calls/subgraph.yaml
diff --git a/tests/integration-tests/source-subgraph-a/abis/Contract.abi b/tests/integration-tests/source-subgraph-a/abis/Contract.abi
new file mode 100644
index 00000000000..02da1a9e7f3
--- /dev/null
+++ b/tests/integration-tests/source-subgraph-a/abis/Contract.abi
@@ -0,0 +1,33 @@
+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "Trigger",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "emitTrigger",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/tests/integration-tests/source-subgraph-a/package.json b/tests/integration-tests/source-subgraph-a/package.json
new file mode 100644
index 00000000000..6126ae1235a
--- /dev/null
+++ b/tests/integration-tests/source-subgraph-a/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "source-subgraph-a",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/source-subgraph-a --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.34.0"
+  }
+}
diff --git a/tests/integration-tests/source-subgraph-a/schema.graphql b/tests/integration-tests/source-subgraph-a/schema.graphql
new file mode 100644
index 00000000000..2348c9b5c57
--- /dev/null
+++ b/tests/integration-tests/source-subgraph-a/schema.graphql
@@ -0,0 +1,5 @@
+type SourceAData @entity(immutable: true) {
+  id: ID!
+  data: String!
+  blockNumber: BigInt!
+} 
\ No newline at end of file
diff --git a/tests/integration-tests/source-subgraph-a/src/mapping.ts b/tests/integration-tests/source-subgraph-a/src/mapping.ts
new file mode 100644
index 00000000000..73e17986bf4
--- /dev/null
+++ b/tests/integration-tests/source-subgraph-a/src/mapping.ts
@@ -0,0 +1,9 @@
+import { ethereum } from '@graphprotocol/graph-ts'
+import { SourceAData } from '../generated/schema'
+
+export function handleBlock(block: ethereum.Block): void {
+  let entity = new SourceAData(block.number.toString())
+  entity.data = 'from source A'
+  entity.blockNumber = block.number
+  entity.save()
+} 
\ No newline at end of file
diff --git a/tests/integration-tests/source-subgraph-a/subgraph.yaml b/tests/integration-tests/source-subgraph-a/subgraph.yaml
new file mode 100644
index 00000000000..8ac9b4a9290
--- /dev/null
+++ b/tests/integration-tests/source-subgraph-a/subgraph.yaml
@@ -0,0 +1,25 @@
+specVersion: 1.3.0
+description: Source Subgraph A
+repository: https://github.com/graphprotocol/graph-node
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: SimpleContract
+    network: test
+    source:
+      address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
+      abi: SimpleContract
+      startBlock: 0
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - SourceAData
+      abis:
+        - name: SimpleContract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlock
+      file: ./src/mapping.ts 
\ No newline at end of file
diff --git a/tests/integration-tests/source-subgraph-b/abis/Contract.abi b/tests/integration-tests/source-subgraph-b/abis/Contract.abi
new file mode 100644
index 00000000000..02da1a9e7f3
--- /dev/null
+++ b/tests/integration-tests/source-subgraph-b/abis/Contract.abi
@@ -0,0 +1,33 @@
+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "Trigger",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "emitTrigger",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/tests/integration-tests/source-subgraph-b/package.json b/tests/integration-tests/source-subgraph-b/package.json
new file mode 100644
index 00000000000..e7e72faa5f1
--- /dev/null
+++ b/tests/integration-tests/source-subgraph-b/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "source-subgraph-b",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/source-subgraph-b --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.34.0"
+  }
+}
diff --git a/tests/integration-tests/source-subgraph-b/schema.graphql b/tests/integration-tests/source-subgraph-b/schema.graphql
new file mode 100644
index 00000000000..0b012273112
--- /dev/null
+++ b/tests/integration-tests/source-subgraph-b/schema.graphql
@@ -0,0 +1,5 @@
+type SourceBData @entity(immutable: true) {
+  id: ID!
+  data: String!
+  blockNumber: BigInt!
+} 
\ No newline at end of file
diff --git a/tests/integration-tests/source-subgraph-b/src/mapping.ts b/tests/integration-tests/source-subgraph-b/src/mapping.ts
new file mode 100644
index 00000000000..19186b6caff
--- /dev/null
+++ b/tests/integration-tests/source-subgraph-b/src/mapping.ts
@@ -0,0 +1,9 @@
+import { ethereum } from '@graphprotocol/graph-ts'
+import { SourceBData } from '../generated/schema'
+
+export function handleBlock(block: ethereum.Block): void {
+  let entity = new SourceBData(block.number.toString())
+  entity.data = 'from source B'
+  entity.blockNumber = block.number
+  entity.save()
+} 
\ No newline at end of file
diff --git a/tests/integration-tests/source-subgraph-b/subgraph.yaml b/tests/integration-tests/source-subgraph-b/subgraph.yaml
new file mode 100644
index 00000000000..d8bae8e33fe
--- /dev/null
+++ b/tests/integration-tests/source-subgraph-b/subgraph.yaml
@@ -0,0 +1,25 @@
+specVersion: 1.3.0
+description: Source Subgraph B
+repository: https://github.com/graphprotocol/graph-node
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: SimpleContract
+    network: test
+    source:
+      address: "0x5FbDB2315678afecb367f032d93F642f64180aa3"
+      abi: SimpleContract
+      startBlock: 0
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - SourceBData
+      abis:
+        - name: SimpleContract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlock
+      file: ./src/mapping.ts 
\ No newline at end of file
diff --git a/tests/integration-tests/source-subgraph/abis/Contract.abi b/tests/integration-tests/source-subgraph/abis/Contract.abi
new file mode 100644
index 00000000000..02da1a9e7f3
--- /dev/null
+++ b/tests/integration-tests/source-subgraph/abis/Contract.abi
@@ -0,0 +1,33 @@
+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "Trigger",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "emitTrigger",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/tests/integration-tests/source-subgraph/package.json b/tests/integration-tests/source-subgraph/package.json
new file mode 100644
index 00000000000..a39da7175bc
--- /dev/null
+++ b/tests/integration-tests/source-subgraph/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "source-subgraph",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/source-subgraph --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.36.0-alpha-20241129215038-b75cda9"
+  }
+}
diff --git a/tests/integration-tests/source-subgraph/schema.graphql b/tests/integration-tests/source-subgraph/schema.graphql
new file mode 100644
index 00000000000..886ecac554d
--- /dev/null
+++ b/tests/integration-tests/source-subgraph/schema.graphql
@@ -0,0 +1,18 @@
+type Block @entity(immutable: true) {
+  id: ID!
+  number: BigInt!
+  hash: Bytes!
+}
+
+type Block2 @entity(immutable: true) {
+  id: ID!
+  number: BigInt!
+  hash: Bytes!
+  testMessage: String
+}
+
+type Block3 @entity(immutable: true) {
+  id: Bytes!
+  number: BigInt!
+  testMessage: String
+}
diff --git a/tests/integration-tests/source-subgraph/src/mapping.ts b/tests/integration-tests/source-subgraph/src/mapping.ts
new file mode 100644
index 00000000000..6e4f2018dc8
--- /dev/null
+++ b/tests/integration-tests/source-subgraph/src/mapping.ts
@@ -0,0 +1,31 @@
+import { ethereum, log, store } from '@graphprotocol/graph-ts';
+import { Block, Block2, Block3 } from '../generated/schema';
+
+export function handleBlock(block: ethereum.Block): void {
+  log.info('handleBlock {}', [block.number.toString()]);
+
+  let id = block.number.toString().concat('-v1');
+  let blockEntity = new Block(id);
+  blockEntity.number = block.number;
+  blockEntity.hash = block.hash;
+  blockEntity.save();
+
+  let id2 = block.number.toString().concat('-v2');
+  let blockEntity2 = new Block(id2);
+  blockEntity2.number = block.number;
+  blockEntity2.hash = block.hash;
+  blockEntity2.save();
+
+  let id3 = block.number.toString().concat('-v3');
+  let blockEntity3 = new Block2(id3);
+  blockEntity3.number = block.number;
+  blockEntity3.hash = block.hash;
+  blockEntity3.testMessage = block.number.toString().concat('-message');
+  blockEntity3.save();
+
+  let id4 = block.hash;
+  let blockEntity4 = new Block3(id4);
+  blockEntity4.number = block.number;
+  blockEntity4.testMessage = block.number.toString().concat('-message');
+  blockEntity4.save();
+}
diff --git a/tests/integration-tests/source-subgraph/subgraph.yaml b/tests/integration-tests/source-subgraph/subgraph.yaml
new file mode 100644
index 00000000000..22006e72dda
--- /dev/null
+++ b/tests/integration-tests/source-subgraph/subgraph.yaml
@@ -0,0 +1,23 @@
+specVersion: 1.3.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: BlockHandlerTest
+    network: test
+    source:
+      address: "@SimpleContract@"
+      abi: Contract
+      startBlock: 1
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      entities:
+        - Call
+      blockHandlers:
+        - handler: handleBlock
+      file: ./src/mapping.ts
\ No newline at end of file
diff --git a/tests/integration-tests/subgraph-data-sources/abis/Contract.abi b/tests/integration-tests/subgraph-data-sources/abis/Contract.abi
new file mode 100644
index 00000000000..9d9f56b9263
--- /dev/null
+++ b/tests/integration-tests/subgraph-data-sources/abis/Contract.abi
@@ -0,0 +1,15 @@
+[
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "string",
+                "name": "testCommand",
+                "type": "string"
+            }
+        ],
+        "name": "TestEvent",
+        "type": "event"
+    }
+]
diff --git a/tests/integration-tests/subgraph-data-sources/package.json b/tests/integration-tests/subgraph-data-sources/package.json
new file mode 100644
index 00000000000..8d95dc89bad
--- /dev/null
+++ b/tests/integration-tests/subgraph-data-sources/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "subgraph-data-sources",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/subgraph-data-sources --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.36.0-alpha-20241129215038-b75cda9"
+  }
+}
diff --git a/tests/integration-tests/subgraph-data-sources/schema.graphql b/tests/integration-tests/subgraph-data-sources/schema.graphql
new file mode 100644
index 00000000000..01d0b1b4646
--- /dev/null
+++ b/tests/integration-tests/subgraph-data-sources/schema.graphql
@@ -0,0 +1,12 @@
+type MirrorBlock @entity {
+  id: String!
+  number: BigInt!
+  hash: Bytes!
+  testMessage: String
+}
+
+type MirrorBlockBytes @entity {
+  id: Bytes!
+  number: BigInt!
+  testMessage: String
+}
diff --git a/tests/integration-tests/subgraph-data-sources/src/mapping.ts b/tests/integration-tests/subgraph-data-sources/src/mapping.ts
new file mode 100644
index 00000000000..261d9e2796d
--- /dev/null
+++ b/tests/integration-tests/subgraph-data-sources/src/mapping.ts
@@ -0,0 +1,43 @@
+import { log, store } from '@graphprotocol/graph-ts';
+import { Block, Block2, Block3 } from '../generated/subgraph-Contract';
+import { MirrorBlock, MirrorBlockBytes } from '../generated/schema';
+
+export function handleEntity(block: Block): void {
+  let id = block.id;
+
+  let blockEntity = loadOrCreateMirrorBlock(id);
+  blockEntity.number = block.number;
+  blockEntity.hash = block.hash;
+
+  blockEntity.save();
+}
+
+export function handleEntity2(block: Block2): void {
+  let id = block.id;
+
+  let blockEntity = loadOrCreateMirrorBlock(id);
+  blockEntity.number = block.number;
+  blockEntity.hash = block.hash;
+  blockEntity.testMessage = block.testMessage;
+
+  blockEntity.save();
+}
+
+export function handleEntity3(block: Block3): void {
+  let id = block.id;
+
+  let blockEntity = new MirrorBlockBytes(id);
+  blockEntity.number = block.number;
+  blockEntity.testMessage = block.testMessage;
+
+  blockEntity.save();
+}
+
+export function loadOrCreateMirrorBlock(id: string): MirrorBlock {
+  let block = MirrorBlock.load(id);
+  if (!block) {
+    log.info('Creating new block entity with id: {}', [id]);
+    block = new MirrorBlock(id);
+  }
+  return block;
+}
diff --git a/tests/integration-tests/subgraph-data-sources/subgraph.yaml b/tests/integration-tests/subgraph-data-sources/subgraph.yaml
new file mode 100644
index 00000000000..0ac8574126e
--- /dev/null
+++ b/tests/integration-tests/subgraph-data-sources/subgraph.yaml
@@ -0,0 +1,23 @@
+specVersion: 1.3.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: subgraph
+    name: Contract
+    network: test
+    source:
+      address: '@source-subgraph@'
+      startBlock: 0
+    mapping:
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - Gravatar
+      handlers:
+        - handler: handleEntity
+          entity: Block
+        - handler: handleEntity2
+          entity: Block2
+        - handler: handleEntity3
+          entity: Block3
+      file: ./src/mapping.ts
diff --git a/tests/integration-tests/timestamp/abis/Contract.abi b/tests/integration-tests/timestamp/abis/Contract.abi
new file mode 100644
index 00000000000..02da1a9e7f3
--- /dev/null
+++ b/tests/integration-tests/timestamp/abis/Contract.abi
@@ -0,0 +1,33 @@
+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "Trigger",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "x",
+        "type": "uint16"
+      }
+    ],
+    "name": "emitTrigger",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/tests/integration-tests/timestamp/package.json b/tests/integration-tests/timestamp/package.json
new file mode 100644
index 00000000000..2f518adccde
--- /dev/null
+++ b/tests/integration-tests/timestamp/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "timestamp",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/timestamp --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.34.0"
+  }
+}
diff --git a/tests/integration-tests/timestamp/schema.graphql b/tests/integration-tests/timestamp/schema.graphql
new file mode 100644
index 00000000000..c6a959d8215
--- /dev/null
+++ b/tests/integration-tests/timestamp/schema.graphql
@@ -0,0 +1,4 @@
+type Foo @entity {
+  id: ID!
+  value: Timestamp!
+}
diff --git a/tests/integration-tests/timestamp/src/mapping.ts b/tests/integration-tests/timestamp/src/mapping.ts
new file mode 100644
index 00000000000..e1ad30bdadd
--- /dev/null
+++ b/tests/integration-tests/timestamp/src/mapping.ts
@@ -0,0 +1,11 @@
+import { Trigger } from "../generated/Contract/Contract";
+import { Foo } from "../generated/schema";
+
+export function handleTrigger(event: Trigger): void {
+  let obj = new Foo("0");
+  obj.value = 1710837304040956;
+  obj.save();
+
+  obj = <Foo>Foo.load("0");
+  assert(obj.value == 1710837304040956, "maybe invalid value");
+}
diff --git a/tests/integration-tests/timestamp/subgraph.yaml b/tests/integration-tests/timestamp/subgraph.yaml
new file mode 100644
index 00000000000..476496dcba0
--- /dev/null
+++ b/tests/integration-tests/timestamp/subgraph.yaml
@@ -0,0 +1,23 @@
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "@SimpleContract@"
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      entities:
+        - Call
+      eventHandlers:
+        - event: Trigger(uint16)
+          handler: handleTrigger
+      file: ./src/mapping.ts
diff --git a/tests/integration-tests/topic-filter/abis/Contract.abi b/tests/integration-tests/topic-filter/abis/Contract.abi
new file mode 100644
index 00000000000..bf587421c22
--- /dev/null
+++ b/tests/integration-tests/topic-filter/abis/Contract.abi
@@ -0,0 +1,66 @@
+[
+    { "type": "constructor", "inputs": [], "stateMutability": "nonpayable" },
+    {
+      "type": "function",
+      "name": "emitAnotherTrigger",
+      "inputs": [
+        { "name": "a", "type": "uint256", "internalType": "uint256" },
+        { "name": "b", "type": "uint256", "internalType": "uint256" },
+        { "name": "c", "type": "uint256", "internalType": "uint256" },
+        { "name": "data", "type": "string", "internalType": "string" }
+      ],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "function",
+      "name": "emitTrigger",
+      "inputs": [{ "name": "x", "type": "uint16", "internalType": "uint16" }],
+      "outputs": [],
+      "stateMutability": "nonpayable"
+    },
+    {
+      "type": "event",
+      "name": "AnotherTrigger",
+      "inputs": [
+        {
+          "name": "a",
+          "type": "uint256",
+          "indexed": true,
+          "internalType": "uint256"
+        },
+        {
+          "name": "b",
+          "type": "uint256",
+          "indexed": true,
+          "internalType": "uint256"
+        },
+        {
+          "name": "c",
+          "type": "uint256",
+          "indexed": true,
+          "internalType": "uint256"
+        },
+        {
+          "name": "data",
+          "type": "string",
+          "indexed": false,
+          "internalType": "string"
+        }
+      ],
+      "anonymous": false
+    },
+    {
+      "type": "event",
+      "name": "Trigger",
+      "inputs": [
+        {
+          "name": "x",
+          "type": "uint16",
+          "indexed": false,
+          "internalType": "uint16"
+        }
+      ],
+      "anonymous": false
+    }
+  ]
\ No newline at end of file
diff --git a/tests/integration-tests/topic-filter/package.json b/tests/integration-tests/topic-filter/package.json
new file mode 100644
index 00000000000..90ecd3c1f5f
--- /dev/null
+++ b/tests/integration-tests/topic-filter/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "topic-filter",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/block-handlers --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-ts": "0.35.0"
+  }
+}
diff --git a/tests/integration-tests/topic-filter/schema.graphql b/tests/integration-tests/topic-filter/schema.graphql
new file mode 100644
index 00000000000..01dfa0433dd
--- /dev/null
+++ b/tests/integration-tests/topic-filter/schema.graphql
@@ -0,0 +1,7 @@
+type AnotherTriggerEntity @entity {
+  id: Int8!
+  a: BigInt
+  b: BigInt
+  c: BigInt
+  data: String
+}
diff --git a/tests/integration-tests/topic-filter/src/mapping.ts b/tests/integration-tests/topic-filter/src/mapping.ts
new file mode 100644
index 00000000000..fc15ef5dda0
--- /dev/null
+++ b/tests/integration-tests/topic-filter/src/mapping.ts
@@ -0,0 +1,11 @@
+import { AnotherTrigger } from "../generated/Contract/Contract";
+import { AnotherTriggerEntity } from "../generated/schema";
+
+export function handleAnotherTrigger(event: AnotherTrigger): void {
+  let entity = new AnotherTriggerEntity();
+  entity.a = event.params.a;
+  entity.b = event.params.b;
+  entity.c = event.params.c;
+  entity.data = event.params.data;
+  entity.save();
+}
diff --git a/tests/integration-tests/topic-filter/subgraph.yaml b/tests/integration-tests/topic-filter/subgraph.yaml
new file mode 100644
index 00000000000..6daba2e5f65
--- /dev/null
+++ b/tests/integration-tests/topic-filter/subgraph.yaml
@@ -0,0 +1,27 @@
+specVersion: 1.2.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "@SimpleContract@"
+      abi: Contract
+      startBlock: 1
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.9
+      language: wasm/assemblyscript
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      entities:
+        - Call
+      eventHandlers:
+        - event: AnotherTrigger(indexed uint256,indexed uint256,indexed uint256,string)
+          handler: handleAnotherTrigger
+          topic1: ["0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000003"]
+          topic2: ["0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000003"]
+          topic3: ["0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000003"]
+      file: ./src/mapping.ts
diff --git a/tests/integration-tests/value-roundtrip/package.json b/tests/integration-tests/value-roundtrip/package.json
index ea84e8c5167..f321b0b5810 100644
--- a/tests/integration-tests/value-roundtrip/package.json
+++ b/tests/integration-tests/value-roundtrip/package.json
@@ -1,25 +1,12 @@
 {
   "name": "value-roundtrip",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
-    "build-contracts": "../../common/build-contracts.sh",
     "codegen": "graph codegen --skip-migrations",
-    "test": "yarn build-contracts && truffle test --compile-none --network test",
-    "create:test": "graph create test/value-roundtrip --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/value-roundtrip --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
-    "@graphprotocol/graph-cli": "0.62.0",
-    "@graphprotocol/graph-ts": "0.31.0",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "@truffle/contract": "^4.3",
-    "@truffle/hdwallet-provider": "^1.2",
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1",
-    "truffle": "^5.2"
+    "@graphprotocol/graph-ts": "0.34.0"
   }
 }
diff --git a/tests/integration-tests/yarn.lock b/tests/integration-tests/yarn.lock
deleted file mode 100644
index 355fe8fe139..00000000000
--- a/tests/integration-tests/yarn.lock
+++ /dev/null
@@ -1,13033 +0,0 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
-
-
-"@apollo/client@^3.1.5":
-  version "3.3.11"
-  resolved "https://registry.yarnpkg.com/@apollo/client/-/client-3.3.11.tgz#125051405e83dc899d471d43b79fd6045d92a802"
-  integrity sha512-54+D5FB6RJlQ+g37f432gaexnyvDsG5X6L9VO5kqN54HJlbF8hCf/8CXtAQEHCWodAwZhy6kOLp2RM96829q3A==
-  dependencies:
-    "@graphql-typed-document-node/core" "^3.0.0"
-    "@types/zen-observable" "^0.8.0"
-    "@wry/context" "^0.5.2"
-    "@wry/equality" "^0.3.0"
-    fast-json-stable-stringify "^2.0.0"
-    graphql-tag "^2.12.0"
-    hoist-non-react-statics "^3.3.2"
-    optimism "^0.14.0"
-    prop-types "^15.7.2"
-    symbol-observable "^2.0.0"
-    ts-invariant "^0.6.0"
-    tslib "^1.10.0"
-    zen-observable "^0.8.14"
-
-"@apollo/protobufjs@1.2.2":
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/@apollo/protobufjs/-/protobufjs-1.2.2.tgz#4bd92cd7701ccaef6d517cdb75af2755f049f87c"
-  integrity sha512-vF+zxhPiLtkwxONs6YanSt1EpwpGilThpneExUN5K3tCymuxNnVq2yojTvnpRjv2QfsEIt/n7ozPIIzBLwGIDQ==
-  dependencies:
-    "@protobufjs/aspromise" "^1.1.2"
-    "@protobufjs/base64" "^1.1.2"
-    "@protobufjs/codegen" "^2.0.4"
-    "@protobufjs/eventemitter" "^1.1.0"
-    "@protobufjs/fetch" "^1.1.0"
-    "@protobufjs/float" "^1.0.2"
-    "@protobufjs/inquire" "^1.1.0"
-    "@protobufjs/path" "^1.1.2"
-    "@protobufjs/pool" "^1.1.0"
-    "@protobufjs/utf8" "^1.1.0"
-    "@types/long" "^4.0.0"
-    "@types/node" "^10.1.0"
-    long "^4.0.0"
-
-"@apollographql/apollo-tools@^0.5.0":
-  version "0.5.2"
-  resolved "https://registry.yarnpkg.com/@apollographql/apollo-tools/-/apollo-tools-0.5.2.tgz#01750a655731a198c3634ee819c463254a7c7767"
-  integrity sha512-KxZiw0Us3k1d0YkJDhOpVH5rJ+mBfjXcgoRoCcslbgirjgLotKMzOcx4PZ7YTEvvEROmvG7X3Aon41GvMmyGsw==
-
-"@apollographql/graphql-playground-html@1.6.27":
-  version "1.6.27"
-  resolved "https://registry.yarnpkg.com/@apollographql/graphql-playground-html/-/graphql-playground-html-1.6.27.tgz#bc9ab60e9445aa2a8813b4e94f152fa72b756335"
-  integrity sha512-tea2LweZvn6y6xFV11K0KC8ETjmm52mQrW+ezgB2O/aTQf8JGyFmMcRPFgUaQZeHbWdm8iisDC6EjOKsXu0nfw==
-  dependencies:
-    xss "^1.0.8"
-
-"@apollographql/graphql-upload-8-fork@^8.1.3":
-  version "8.1.3"
-  resolved "https://registry.yarnpkg.com/@apollographql/graphql-upload-8-fork/-/graphql-upload-8-fork-8.1.3.tgz#a0d4e0d5cec8e126d78bd915c264d6b90f5784bc"
-  integrity sha512-ssOPUT7euLqDXcdVv3Qs4LoL4BPtfermW1IOouaqEmj36TpHYDmYDIbKoSQxikd9vtMumFnP87OybH7sC9fJ6g==
-  dependencies:
-    "@types/express" "*"
-    "@types/fs-capacitor" "*"
-    "@types/koa" "*"
-    busboy "^0.3.1"
-    fs-capacitor "^2.0.4"
-    http-errors "^1.7.3"
-    object-path "^0.11.4"
-
-"@ardatan/aggregate-error@0.0.6":
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/@ardatan/aggregate-error/-/aggregate-error-0.0.6.tgz#fe6924771ea40fc98dc7a7045c2e872dc8527609"
-  integrity sha512-vyrkEHG1jrukmzTPtyWB4NLPauUw5bQeg4uhn8f+1SSynmrOcyvlb1GKQjjgoBzElLdfXCRYX8UnBlhklOHYRQ==
-  dependencies:
-    tslib "~2.0.1"
-
-"@babel/code-frame@^7.0.0":
-  version "7.18.6"
-  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.18.6.tgz#3b25d38c89600baa2dcc219edfa88a74eb2c427a"
-  integrity sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==
-  dependencies:
-    "@babel/highlight" "^7.18.6"
-
-"@babel/code-frame@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.12.13.tgz#dcfc826beef65e75c50e21d3837d7d95798dd658"
-  integrity sha512-HV1Cm0Q3ZrpCR93tkWOYiuYIgLxZXZFVG2VgK+MBWjUqZTundupbfx2aXarXuw5Ko5aMcjtJgbSs4vUGBS5v6g==
-  dependencies:
-    "@babel/highlight" "^7.12.13"
-
-"@babel/compat-data@^7.13.0", "@babel/compat-data@^7.13.8":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.13.8.tgz#5b783b9808f15cef71547f1b691f34f8ff6003a6"
-  integrity sha512-EaI33z19T4qN3xLXsGf48M2cDqa6ei9tPZlfLdb2HC+e/cFtREiRd8hdSqDbwdLB0/+gLwqJmCYASH0z2bUdog==
-
-"@babel/core@^7.0.0":
-  version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.13.10.tgz#07de050bbd8193fcd8a3c27918c0890613a94559"
-  integrity sha512-bfIYcT0BdKeAZrovpMqX2Mx5NrgAckGbwT982AkdS5GNfn3KMGiprlBAtmBcFZRUmpaufS6WZFP8trvx8ptFDw==
-  dependencies:
-    "@babel/code-frame" "^7.12.13"
-    "@babel/generator" "^7.13.9"
-    "@babel/helper-compilation-targets" "^7.13.10"
-    "@babel/helper-module-transforms" "^7.13.0"
-    "@babel/helpers" "^7.13.10"
-    "@babel/parser" "^7.13.10"
-    "@babel/template" "^7.12.13"
-    "@babel/traverse" "^7.13.0"
-    "@babel/types" "^7.13.0"
-    convert-source-map "^1.7.0"
-    debug "^4.1.0"
-    gensync "^1.0.0-beta.2"
-    json5 "^2.1.2"
-    lodash "^4.17.19"
-    semver "^6.3.0"
-    source-map "^0.5.0"
-
-"@babel/generator@^7.12.13", "@babel/generator@^7.13.0", "@babel/generator@^7.13.9", "@babel/generator@^7.5.0":
-  version "7.13.9"
-  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.13.9.tgz#3a7aa96f9efb8e2be42d38d80e2ceb4c64d8de39"
-  integrity sha512-mHOOmY0Axl/JCTkxTU6Lf5sWOg/v8nUa+Xkt4zMTftX0wqmb6Sh7J8gvcehBw7q0AhrhAR+FDacKjCZ2X8K+Sw==
-  dependencies:
-    "@babel/types" "^7.13.0"
-    jsesc "^2.5.1"
-    source-map "^0.5.0"
-
-"@babel/helper-annotate-as-pure@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.12.13.tgz#0f58e86dfc4bb3b1fcd7db806570e177d439b6ab"
-  integrity sha512-7YXfX5wQ5aYM/BOlbSccHDbuXXFPxeoUmfWtz8le2yTkTZc+BxsiEnENFoi2SlmA8ewDkG2LgIMIVzzn2h8kfw==
-  dependencies:
-    "@babel/types" "^7.12.13"
-
-"@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.13.10", "@babel/helper-compilation-targets@^7.13.8":
-  version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.10.tgz#1310a1678cb8427c07a753750da4f8ce442bdd0c"
-  integrity sha512-/Xju7Qg1GQO4mHZ/Kcs6Au7gfafgZnwm+a7sy/ow/tV1sHeraRUHbjdat8/UvDor4Tez+siGKDk6zIKtCPKVJA==
-  dependencies:
-    "@babel/compat-data" "^7.13.8"
-    "@babel/helper-validator-option" "^7.12.17"
-    browserslist "^4.14.5"
-    semver "^6.3.0"
-
-"@babel/helper-create-class-features-plugin@^7.13.0":
-  version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.13.10.tgz#073b2bbb925a097643c6fc5770e5f13394e887c9"
-  integrity sha512-YV7r2YxdTUaw84EwNkyrRke/TJHR/UXGiyvACRqvdVJ2/syV2rQuJNnaRLSuYiop8cMRXOgseTGoJCWX0q2fFg==
-  dependencies:
-    "@babel/helper-function-name" "^7.12.13"
-    "@babel/helper-member-expression-to-functions" "^7.13.0"
-    "@babel/helper-optimise-call-expression" "^7.12.13"
-    "@babel/helper-replace-supers" "^7.13.0"
-    "@babel/helper-split-export-declaration" "^7.12.13"
-
-"@babel/helper-define-polyfill-provider@^0.1.5":
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.1.5.tgz#3c2f91b7971b9fc11fe779c945c014065dea340e"
-  integrity sha512-nXuzCSwlJ/WKr8qxzW816gwyT6VZgiJG17zR40fou70yfAcqjoNyTLl/DQ+FExw5Hx5KNqshmN8Ldl/r2N7cTg==
-  dependencies:
-    "@babel/helper-compilation-targets" "^7.13.0"
-    "@babel/helper-module-imports" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/traverse" "^7.13.0"
-    debug "^4.1.1"
-    lodash.debounce "^4.0.8"
-    resolve "^1.14.2"
-    semver "^6.1.2"
-
-"@babel/helper-function-name@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.12.13.tgz#93ad656db3c3c2232559fd7b2c3dbdcbe0eb377a"
-  integrity sha512-TZvmPn0UOqmvi5G4vvw0qZTpVptGkB1GL61R6lKvrSdIxGm5Pky7Q3fpKiIkQCAtRCBUwB0PaThlx9vebCDSwA==
-  dependencies:
-    "@babel/helper-get-function-arity" "^7.12.13"
-    "@babel/template" "^7.12.13"
-    "@babel/types" "^7.12.13"
-
-"@babel/helper-get-function-arity@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.12.13.tgz#bc63451d403a3b3082b97e1d8b3fe5bd4091e583"
-  integrity sha512-DjEVzQNz5LICkzN0REdpD5prGoidvbdYk1BVgRUOINaWJP2t6avB27X1guXK1kXNrX0WMfsrm1A/ZBthYuIMQg==
-  dependencies:
-    "@babel/types" "^7.12.13"
-
-"@babel/helper-member-expression-to-functions@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.13.0.tgz#6aa4bb678e0f8c22f58cdb79451d30494461b091"
-  integrity sha512-yvRf8Ivk62JwisqV1rFRMxiSMDGnN6KH1/mDMmIrij4jztpQNRoHqqMG3U6apYbGRPJpgPalhva9Yd06HlUxJQ==
-  dependencies:
-    "@babel/types" "^7.13.0"
-
-"@babel/helper-module-imports@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.12.13.tgz#ec67e4404f41750463e455cc3203f6a32e93fcb0"
-  integrity sha512-NGmfvRp9Rqxy0uHSSVP+SRIW1q31a7Ji10cLBcqSDUngGentY4FRiHOFZFE1CLU5eiL0oE8reH7Tg1y99TDM/g==
-  dependencies:
-    "@babel/types" "^7.12.13"
-
-"@babel/helper-module-transforms@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.13.0.tgz#42eb4bd8eea68bab46751212c357bfed8b40f6f1"
-  integrity sha512-Ls8/VBwH577+pw7Ku1QkUWIyRRNHpYlts7+qSqBBFCW3I8QteB9DxfcZ5YJpOwH6Ihe/wn8ch7fMGOP1OhEIvw==
-  dependencies:
-    "@babel/helper-module-imports" "^7.12.13"
-    "@babel/helper-replace-supers" "^7.13.0"
-    "@babel/helper-simple-access" "^7.12.13"
-    "@babel/helper-split-export-declaration" "^7.12.13"
-    "@babel/helper-validator-identifier" "^7.12.11"
-    "@babel/template" "^7.12.13"
-    "@babel/traverse" "^7.13.0"
-    "@babel/types" "^7.13.0"
-    lodash "^4.17.19"
-
-"@babel/helper-optimise-call-expression@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.12.13.tgz#5c02d171b4c8615b1e7163f888c1c81c30a2aaea"
-  integrity sha512-BdWQhoVJkp6nVjB7nkFWcn43dkprYauqtk++Py2eaf/GRDFm5BxRqEIZCiHlZUGAVmtwKcsVL1dC68WmzeFmiA==
-  dependencies:
-    "@babel/types" "^7.12.13"
-
-"@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.13.0", "@babel/helper-plugin-utils@^7.8.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.13.0.tgz#806526ce125aed03373bc416a828321e3a6a33af"
-  integrity sha512-ZPafIPSwzUlAoWT8DKs1W2VyF2gOWthGd5NGFMsBcMMol+ZhK+EQY/e6V96poa6PA/Bh+C9plWN0hXO1uB8AfQ==
-
-"@babel/helper-replace-supers@^7.12.13", "@babel/helper-replace-supers@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.13.0.tgz#6034b7b51943094cb41627848cb219cb02be1d24"
-  integrity sha512-Segd5me1+Pz+rmN/NFBOplMbZG3SqRJOBlY+mA0SxAv6rjj7zJqr1AVr3SfzUVTLCv7ZLU5FycOM/SBGuLPbZw==
-  dependencies:
-    "@babel/helper-member-expression-to-functions" "^7.13.0"
-    "@babel/helper-optimise-call-expression" "^7.12.13"
-    "@babel/traverse" "^7.13.0"
-    "@babel/types" "^7.13.0"
-
-"@babel/helper-simple-access@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.12.13.tgz#8478bcc5cacf6aa1672b251c1d2dde5ccd61a6c4"
-  integrity sha512-0ski5dyYIHEfwpWGx5GPWhH35j342JaflmCeQmsPWcrOQDtCN6C1zKAVRFVbK53lPW2c9TsuLLSUDf0tIGJ5hA==
-  dependencies:
-    "@babel/types" "^7.12.13"
-
-"@babel/helper-skip-transparent-expression-wrappers@^7.12.1":
-  version "7.12.1"
-  resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.12.1.tgz#462dc63a7e435ade8468385c63d2b84cce4b3cbf"
-  integrity sha512-Mf5AUuhG1/OCChOJ/HcADmvcHM42WJockombn8ATJG3OnyiSxBK/Mm5x78BQWvmtXZKHgbjdGL2kin/HOLlZGA==
-  dependencies:
-    "@babel/types" "^7.12.1"
-
-"@babel/helper-split-export-declaration@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.12.13.tgz#e9430be00baf3e88b0e13e6f9d4eaf2136372b05"
-  integrity sha512-tCJDltF83htUtXx5NLcaDqRmknv652ZWCHyoTETf1CXYJdPC7nohZohjUgieXhv0hTJdRf2FjDueFehdNucpzg==
-  dependencies:
-    "@babel/types" "^7.12.13"
-
-"@babel/helper-validator-identifier@^7.12.11", "@babel/helper-validator-identifier@^7.18.6":
-  version "7.18.6"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.18.6.tgz#9c97e30d31b2b8c72a1d08984f2ca9b574d7a076"
-  integrity sha512-MmetCkz9ej86nJQV+sFCxoGGrUbU3q02kgLciwkrt9QqEB7cP39oKEY0PakknEO0Gu20SskMRi+AYZ3b1TpN9g==
-
-"@babel/helper-validator-option@^7.12.17":
-  version "7.12.17"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.12.17.tgz#d1fbf012e1a79b7eebbfdc6d270baaf8d9eb9831"
-  integrity sha512-TopkMDmLzq8ngChwRlyjR6raKD6gMSae4JdYDB8bByKreQgG0RBTuKe9LRxW3wFtUnjxOPRKBDwEH6Mg5KeDfw==
-
-"@babel/helpers@^7.13.10":
-  version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.13.10.tgz#fd8e2ba7488533cdeac45cc158e9ebca5e3c7df8"
-  integrity sha512-4VO883+MWPDUVRF3PhiLBUFHoX/bsLTGFpFK/HqvvfBZz2D57u9XzPVNFVBTc0PW/CWR9BXTOKt8NF4DInUHcQ==
-  dependencies:
-    "@babel/template" "^7.12.13"
-    "@babel/traverse" "^7.13.0"
-    "@babel/types" "^7.13.0"
-
-"@babel/highlight@^7.12.13", "@babel/highlight@^7.18.6":
-  version "7.18.6"
-  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.18.6.tgz#81158601e93e2563795adcbfbdf5d64be3f2ecdf"
-  integrity sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==
-  dependencies:
-    "@babel/helper-validator-identifier" "^7.18.6"
-    chalk "^2.0.0"
-    js-tokens "^4.0.0"
-
-"@babel/parser@7.12.16":
-  version "7.12.16"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.12.16.tgz#cc31257419d2c3189d394081635703f549fc1ed4"
-  integrity sha512-c/+u9cqV6F0+4Hpq01jnJO+GLp2DdT63ppz9Xa+6cHaajM9VFzK/iDXiKK65YtpeVwu+ctfS6iqlMqRgQRzeCw==
-
-"@babel/parser@^7.0.0", "@babel/parser@^7.12.13", "@babel/parser@^7.13.0", "@babel/parser@^7.13.10":
-  version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.13.10.tgz#8f8f9bf7b3afa3eabd061f7a5bcdf4fec3c48409"
-  integrity sha512-0s7Mlrw9uTWkYua7xWr99Wpk2bnGa0ANleKfksYAES8LpWH4gW1OUr42vqKNf0us5UQNfru2wPqMqRITzq/SIQ==
-
-"@babel/plugin-proposal-class-properties@^7.0.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.13.0.tgz#146376000b94efd001e57a40a88a525afaab9f37"
-  integrity sha512-KnTDjFNC1g+45ka0myZNvSBFLhNCLN+GeGYLDEA8Oq7MZ6yMgfLoIRh86GRT0FjtJhZw8JyUskP9uvj5pHM9Zg==
-  dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.13.0"
-    "@babel/helper-plugin-utils" "^7.13.0"
-
-"@babel/plugin-proposal-object-rest-spread@^7.0.0":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.13.8.tgz#5d210a4d727d6ce3b18f9de82cc99a3964eed60a"
-  integrity sha512-DhB2EuB1Ih7S3/IRX5AFVgZ16k3EzfRbq97CxAVI1KSYcW+lexV8VZb7G7L8zuPVSdQMRn0kiBpf/Yzu9ZKH0g==
-  dependencies:
-    "@babel/compat-data" "^7.13.8"
-    "@babel/helper-compilation-targets" "^7.13.8"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
-    "@babel/plugin-transform-parameters" "^7.13.0"
-
-"@babel/plugin-syntax-class-properties@^7.0.0":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10"
-  integrity sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-syntax-flow@^7.0.0", "@babel/plugin-syntax-flow@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.12.13.tgz#5df9962503c0a9c918381c929d51d4d6949e7e86"
-  integrity sha512-J/RYxnlSLXZLVR7wTRsozxKT8qbsx1mNKJzXEEjQ0Kjx1ZACcyHgbanNWNCFtc36IzuWhYWPpvJFFoexoOWFmA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-syntax-jsx@^7.0.0", "@babel/plugin-syntax-jsx@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.12.13.tgz#044fb81ebad6698fe62c478875575bcbb9b70f15"
-  integrity sha512-d4HM23Q1K7oq/SLNmG6mRt85l2csmQ0cHRaxRXjKW0YFdEXqlZ5kzFQKH5Uc3rDJECgu+yCRgPkG04Mm98R/1g==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-syntax-object-rest-spread@^7.0.0", "@babel/plugin-syntax-object-rest-spread@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871"
-  integrity sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
-
-"@babel/plugin-transform-arrow-functions@^7.0.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.13.0.tgz#10a59bebad52d637a027afa692e8d5ceff5e3dae"
-  integrity sha512-96lgJagobeVmazXFaDrbmCLQxBysKu7U6Do3mLsx27gf5Dk85ezysrs2BZUpXD703U/Su1xTBDxxar2oa4jAGg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-
-"@babel/plugin-transform-block-scoped-functions@^7.0.0":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.12.13.tgz#a9bf1836f2a39b4eb6cf09967739de29ea4bf4c4"
-  integrity sha512-zNyFqbc3kI/fVpqwfqkg6RvBgFpC4J18aKKMmv7KdQ/1GgREapSJAykLMVNwfRGO3BtHj3YQZl8kxCXPcVMVeg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-block-scoping@^7.0.0":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.12.13.tgz#f36e55076d06f41dfd78557ea039c1b581642e61"
-  integrity sha512-Pxwe0iqWJX4fOOM2kEZeUuAxHMWb9nK+9oh5d11bsLoB0xMg+mkDpt0eYuDZB7ETrY9bbcVlKUGTOGWy7BHsMQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-classes@^7.0.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.13.0.tgz#0265155075c42918bf4d3a4053134176ad9b533b"
-  integrity sha512-9BtHCPUARyVH1oXGcSJD3YpsqRLROJx5ZNP6tN5vnk17N0SVf9WCtf8Nuh1CFmgByKKAIMstitKduoCmsaDK5g==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.12.13"
-    "@babel/helper-function-name" "^7.12.13"
-    "@babel/helper-optimise-call-expression" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-replace-supers" "^7.13.0"
-    "@babel/helper-split-export-declaration" "^7.12.13"
-    globals "^11.1.0"
-
-"@babel/plugin-transform-computed-properties@^7.0.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.13.0.tgz#845c6e8b9bb55376b1fa0b92ef0bdc8ea06644ed"
-  integrity sha512-RRqTYTeZkZAz8WbieLTvKUEUxZlUTdmL5KGMyZj7FnMfLNKV4+r5549aORG/mgojRmFlQMJDUupwAMiF2Q7OUg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-
-"@babel/plugin-transform-destructuring@^7.0.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.13.0.tgz#c5dce270014d4e1ebb1d806116694c12b7028963"
-  integrity sha512-zym5em7tePoNT9s964c0/KU3JPPnuq7VhIxPRefJ4/s82cD+q1mgKfuGRDMCPL0HTyKz4dISuQlCusfgCJ86HA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-
-"@babel/plugin-transform-flow-strip-types@^7.0.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.13.0.tgz#58177a48c209971e8234e99906cb6bd1122addd3"
-  integrity sha512-EXAGFMJgSX8gxWD7PZtW/P6M+z74jpx3wm/+9pn+c2dOawPpBkUX7BrfyPvo6ZpXbgRIEuwgwDb/MGlKvu2pOg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/plugin-syntax-flow" "^7.12.13"
-
-"@babel/plugin-transform-for-of@^7.0.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.13.0.tgz#c799f881a8091ac26b54867a845c3e97d2696062"
-  integrity sha512-IHKT00mwUVYE0zzbkDgNRP6SRzvfGCYsOxIRz8KsiaaHCcT9BWIkO+H9QRJseHBLOGBZkHUdHiqj6r0POsdytg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-
-"@babel/plugin-transform-function-name@^7.0.0":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.12.13.tgz#bb024452f9aaed861d374c8e7a24252ce3a50051"
-  integrity sha512-6K7gZycG0cmIwwF7uMK/ZqeCikCGVBdyP2J5SKNCXO5EOHcqi+z7Jwf8AmyDNcBgxET8DrEtCt/mPKPyAzXyqQ==
-  dependencies:
-    "@babel/helper-function-name" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-literals@^7.0.0":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.12.13.tgz#2ca45bafe4a820197cf315794a4d26560fe4bdb9"
-  integrity sha512-FW+WPjSR7hiUxMcKqyNjP05tQ2kmBCdpEpZHY1ARm96tGQCCBvXKnpjILtDplUnJ/eHZ0lALLM+d2lMFSpYJrQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-member-expression-literals@^7.0.0":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.12.13.tgz#5ffa66cd59b9e191314c9f1f803b938e8c081e40"
-  integrity sha512-kxLkOsg8yir4YeEPHLuO2tXP9R/gTjpuTOjshqSpELUN3ZAg2jfDnKUvzzJxObun38sw3wm4Uu69sX/zA7iRvg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-modules-commonjs@^7.0.0":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.13.8.tgz#7b01ad7c2dcf2275b06fa1781e00d13d420b3e1b"
-  integrity sha512-9QiOx4MEGglfYZ4XOnU79OHr6vIWUakIj9b4mioN8eQIoEh+pf5p/zEB36JpDFWA12nNMiRf7bfoRvl9Rn79Bw==
-  dependencies:
-    "@babel/helper-module-transforms" "^7.13.0"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-simple-access" "^7.12.13"
-    babel-plugin-dynamic-import-node "^2.3.3"
-
-"@babel/plugin-transform-object-super@^7.0.0":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.12.13.tgz#b4416a2d63b8f7be314f3d349bd55a9c1b5171f7"
-  integrity sha512-JzYIcj3XtYspZDV8j9ulnoMPZZnF/Cj0LUxPOjR89BdBVx+zYJI9MdMIlUZjbXDX+6YVeS6I3e8op+qQ3BYBoQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-    "@babel/helper-replace-supers" "^7.12.13"
-
-"@babel/plugin-transform-parameters@^7.0.0", "@babel/plugin-transform-parameters@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.13.0.tgz#8fa7603e3097f9c0b7ca1a4821bc2fb52e9e5007"
-  integrity sha512-Jt8k/h/mIwE2JFEOb3lURoY5C85ETcYPnbuAJ96zRBzh1XHtQZfs62ChZ6EP22QlC8c7Xqr9q+e1SU5qttwwjw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-
-"@babel/plugin-transform-property-literals@^7.0.0":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.12.13.tgz#4e6a9e37864d8f1b3bc0e2dce7bf8857db8b1a81"
-  integrity sha512-nqVigwVan+lR+g8Fj8Exl0UQX2kymtjcWfMOYM1vTYEKujeyv2SkMgazf2qNcK7l4SDiKyTA/nHCPqL4e2zo1A==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-react-display-name@^7.0.0":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.12.13.tgz#c28effd771b276f4647411c9733dbb2d2da954bd"
-  integrity sha512-MprESJzI9O5VnJZrL7gg1MpdqmiFcUv41Jc7SahxYsNP2kDkFqClxxTZq+1Qv4AFCamm+GXMRDQINNn+qrxmiA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-react-jsx@^7.0.0":
-  version "7.12.17"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.12.17.tgz#dd2c1299f5e26de584939892de3cfc1807a38f24"
-  integrity sha512-mwaVNcXV+l6qJOuRhpdTEj8sT/Z0owAVWf9QujTZ0d2ye9X/K+MTOTSizcgKOj18PGnTc/7g1I4+cIUjsKhBcw==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.12.13"
-    "@babel/helper-module-imports" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.12.13"
-    "@babel/plugin-syntax-jsx" "^7.12.13"
-    "@babel/types" "^7.12.17"
-
-"@babel/plugin-transform-runtime@^7.5.5":
-  version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.13.10.tgz#a1e40d22e2bf570c591c9c7e5ab42d6bf1e419e1"
-  integrity sha512-Y5k8ipgfvz5d/76tx7JYbKQTcgFSU6VgJ3kKQv4zGTKr+a9T/KBvfRvGtSFgKDQGt/DBykQixV0vNWKIdzWErA==
-  dependencies:
-    "@babel/helper-module-imports" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    babel-plugin-polyfill-corejs2 "^0.1.4"
-    babel-plugin-polyfill-corejs3 "^0.1.3"
-    babel-plugin-polyfill-regenerator "^0.1.2"
-    semver "^6.3.0"
-
-"@babel/plugin-transform-shorthand-properties@^7.0.0":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.12.13.tgz#db755732b70c539d504c6390d9ce90fe64aff7ad"
-  integrity sha512-xpL49pqPnLtf0tVluuqvzWIgLEhuPpZzvs2yabUHSKRNlN7ScYU7aMlmavOeyXJZKgZKQRBlh8rHbKiJDraTSw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-spread@^7.0.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.13.0.tgz#84887710e273c1815ace7ae459f6f42a5d31d5fd"
-  integrity sha512-V6vkiXijjzYeFmQTr3dBxPtZYLPcUfY34DebOU27jIl2M/Y8Egm52Hw82CSjjPqd54GTlJs5x+CR7HeNr24ckg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.12.1"
-
-"@babel/plugin-transform-template-literals@^7.0.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.13.0.tgz#a36049127977ad94438dee7443598d1cefdf409d"
-  integrity sha512-d67umW6nlfmr1iehCcBv69eSUSySk1EsIS8aTDX4Xo9qajAh6mYtcl4kJrBkGXuxZPEgVr7RVfAvNW6YQkd4Mw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-
-"@babel/runtime@^7.0.0", "@babel/runtime@^7.11.2", "@babel/runtime@^7.5.5", "@babel/runtime@^7.6.3":
-  version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.13.10.tgz#47d42a57b6095f4468da440388fdbad8bebf0d7d"
-  integrity sha512-4QPkjJq6Ns3V/RgpEahRk+AGfL0eO6RHHtTWoNNr5mO49G6B5+X6d6THgWEAvTrznU5xYpbAlVKRYcsCgh/Akw==
-  dependencies:
-    regenerator-runtime "^0.13.4"
-
-"@babel/template@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.12.13.tgz#530265be8a2589dbb37523844c5bcb55947fb327"
-  integrity sha512-/7xxiGA57xMo/P2GVvdEumr8ONhFOhfgq2ihK3h1e6THqzTAkHbkXgB0xI9yeTfIUoH3+oAeHhqm/I43OTbbjA==
-  dependencies:
-    "@babel/code-frame" "^7.12.13"
-    "@babel/parser" "^7.12.13"
-    "@babel/types" "^7.12.13"
-
-"@babel/traverse@7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.12.13.tgz#689f0e4b4c08587ad26622832632735fb8c4e0c0"
-  integrity sha512-3Zb4w7eE/OslI0fTp8c7b286/cQps3+vdLW3UcwC8VSJC6GbKn55aeVVu2QJNuCDoeKyptLOFrPq8WqZZBodyA==
-  dependencies:
-    "@babel/code-frame" "^7.12.13"
-    "@babel/generator" "^7.12.13"
-    "@babel/helper-function-name" "^7.12.13"
-    "@babel/helper-split-export-declaration" "^7.12.13"
-    "@babel/parser" "^7.12.13"
-    "@babel/types" "^7.12.13"
-    debug "^4.1.0"
-    globals "^11.1.0"
-    lodash "^4.17.19"
-
-"@babel/traverse@^7.0.0", "@babel/traverse@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.13.0.tgz#6d95752475f86ee7ded06536de309a65fc8966cc"
-  integrity sha512-xys5xi5JEhzC3RzEmSGrs/b3pJW/o87SypZ+G/PhaE7uqVQNv/jlmVIBXuoh5atqQ434LfXV+sf23Oxj0bchJQ==
-  dependencies:
-    "@babel/code-frame" "^7.12.13"
-    "@babel/generator" "^7.13.0"
-    "@babel/helper-function-name" "^7.12.13"
-    "@babel/helper-split-export-declaration" "^7.12.13"
-    "@babel/parser" "^7.13.0"
-    "@babel/types" "^7.13.0"
-    debug "^4.1.0"
-    globals "^11.1.0"
-    lodash "^4.17.19"
-
-"@babel/types@7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.12.13.tgz#8be1aa8f2c876da11a9cf650c0ecf656913ad611"
-  integrity sha512-oKrdZTld2im1z8bDwTOQvUbxKwE+854zc16qWZQlcTqMN00pWxHQ4ZeOq0yDMnisOpRykH2/5Qqcrk/OlbAjiQ==
-  dependencies:
-    "@babel/helper-validator-identifier" "^7.12.11"
-    lodash "^4.17.19"
-    to-fast-properties "^2.0.0"
-
-"@babel/types@^7.0.0", "@babel/types@^7.12.1", "@babel/types@^7.12.13", "@babel/types@^7.12.17", "@babel/types@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.13.0.tgz#74424d2816f0171b4100f0ab34e9a374efdf7f80"
-  integrity sha512-hE+HE8rnG1Z6Wzo+MhaKE5lM5eMx71T4EHJgku2E3xIfaULhDcxiiRxUYgwX8qwP1BBSlag+TdGOt6JAidIZTA==
-  dependencies:
-    "@babel/helper-validator-identifier" "^7.12.11"
-    lodash "^4.17.19"
-    to-fast-properties "^2.0.0"
-
-"@cspotcode/source-map-support@^0.8.0":
-  version "0.8.1"
-  resolved "https://registry.yarnpkg.com/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz#00629c35a688e05a88b1cda684fb9d5e73f000a1"
-  integrity sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==
-  dependencies:
-    "@jridgewell/trace-mapping" "0.3.9"
-
-"@ethersproject/abi@5.0.0-beta.153":
-  version "5.0.0-beta.153"
-  resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.0.0-beta.153.tgz#43a37172b33794e4562999f6e2d555b7599a8eee"
-  integrity sha512-aXweZ1Z7vMNzJdLpR1CZUAIgnwjrZeUSvN9syCwlBaEBUFJmFY+HHnfuTI5vIhVs/mRkfJVrbEyl51JZQqyjAg==
-  dependencies:
-    "@ethersproject/address" ">=5.0.0-beta.128"
-    "@ethersproject/bignumber" ">=5.0.0-beta.130"
-    "@ethersproject/bytes" ">=5.0.0-beta.129"
-    "@ethersproject/constants" ">=5.0.0-beta.128"
-    "@ethersproject/hash" ">=5.0.0-beta.128"
-    "@ethersproject/keccak256" ">=5.0.0-beta.127"
-    "@ethersproject/logger" ">=5.0.0-beta.129"
-    "@ethersproject/properties" ">=5.0.0-beta.131"
-    "@ethersproject/strings" ">=5.0.0-beta.130"
-
-"@ethersproject/abi@5.0.7":
-  version "5.0.7"
-  resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.0.7.tgz#79e52452bd3ca2956d0e1c964207a58ad1a0ee7b"
-  integrity sha512-Cqktk+hSIckwP/W8O47Eef60VwmoSC/L3lY0+dIBhQPCNn9E4V7rwmm2aFrNRRDJfFlGuZ1khkQUOc3oBX+niw==
-  dependencies:
-    "@ethersproject/address" "^5.0.4"
-    "@ethersproject/bignumber" "^5.0.7"
-    "@ethersproject/bytes" "^5.0.4"
-    "@ethersproject/constants" "^5.0.4"
-    "@ethersproject/hash" "^5.0.4"
-    "@ethersproject/keccak256" "^5.0.3"
-    "@ethersproject/logger" "^5.0.5"
-    "@ethersproject/properties" "^5.0.3"
-    "@ethersproject/strings" "^5.0.4"
-
-"@ethersproject/abstract-provider@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.7.0.tgz#b0a8550f88b6bf9d51f90e4795d48294630cb9ef"
-  integrity sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw==
-  dependencies:
-    "@ethersproject/bignumber" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/networks" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-    "@ethersproject/transactions" "^5.7.0"
-    "@ethersproject/web" "^5.7.0"
-
-"@ethersproject/abstract-signer@^5.0.10", "@ethersproject/abstract-signer@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.7.0.tgz#13f4f32117868452191a4649723cb086d2b596b2"
-  integrity sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ==
-  dependencies:
-    "@ethersproject/abstract-provider" "^5.7.0"
-    "@ethersproject/bignumber" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-
-"@ethersproject/address@>=5.0.0-beta.128":
-  version "5.0.11"
-  resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.0.11.tgz#12022e8c590c33939beb5ab18b401ecf585eac59"
-  integrity sha512-Et4GBdD8/tsBGjCEOKee9upN29qjL5kbRcmJifb4Penmiuh9GARXL2/xpXvEp5EW+EIW/rfCHFJrkYBgoQFQBw==
-  dependencies:
-    "@ethersproject/bignumber" "^5.0.13"
-    "@ethersproject/bytes" "^5.0.9"
-    "@ethersproject/keccak256" "^5.0.7"
-    "@ethersproject/logger" "^5.0.8"
-    "@ethersproject/rlp" "^5.0.7"
-
-"@ethersproject/address@^5.0.4", "@ethersproject/address@^5.0.9", "@ethersproject/address@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.7.0.tgz#19b56c4d74a3b0a46bfdbb6cfcc0a153fc697f37"
-  integrity sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==
-  dependencies:
-    "@ethersproject/bignumber" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/keccak256" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/rlp" "^5.7.0"
-
-"@ethersproject/base64@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/base64/-/base64-5.7.0.tgz#ac4ee92aa36c1628173e221d0d01f53692059e1c"
-  integrity sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-
-"@ethersproject/bignumber@>=5.0.0-beta.130":
-  version "5.0.15"
-  resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.0.15.tgz#b089b3f1e0381338d764ac1c10512f0c93b184ed"
-  integrity sha512-MTADqnyacvdRwtKh7o9ujwNDSM1SDJjYDMYAzjIgjoi9rh6TY4suMbhCa3i2vh3SUXiXSICyTI8ui+NPdrZ9Lw==
-  dependencies:
-    "@ethersproject/bytes" "^5.0.9"
-    "@ethersproject/logger" "^5.0.8"
-    bn.js "^4.4.0"
-
-"@ethersproject/bignumber@^5.0.13", "@ethersproject/bignumber@^5.0.7", "@ethersproject/bignumber@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.7.0.tgz#e2f03837f268ba655ffba03a57853e18a18dc9c2"
-  integrity sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    bn.js "^5.2.1"
-
-"@ethersproject/bytes@>=5.0.0-beta.129":
-  version "5.0.11"
-  resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.0.11.tgz#21118e75b1d00db068984c15530e316021101276"
-  integrity sha512-D51plLYY5qF05AsoVQwIZVLqlBkaTPVHVP/1WmmBIWyHB0cRW0C9kh0kx5Exo51rB63Hk8PfHxc7SmpoaQFEyg==
-  dependencies:
-    "@ethersproject/logger" "^5.0.8"
-
-"@ethersproject/bytes@^5.0.4", "@ethersproject/bytes@^5.0.9", "@ethersproject/bytes@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.7.0.tgz#a00f6ea8d7e7534d6d87f47188af1148d71f155d"
-  integrity sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A==
-  dependencies:
-    "@ethersproject/logger" "^5.7.0"
-
-"@ethersproject/constants@>=5.0.0-beta.128":
-  version "5.0.10"
-  resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.0.10.tgz#eb0c604fbc44c53ba9641eed31a1d0c9e1ebcadc"
-  integrity sha512-OSo8jxkHLDXieCy8bgOFR7lMfgPxEzKvSDdP+WAWHCDM8+orwch0B6wzkTmiQFgryAtIctrBt5glAdJikZ3hGw==
-  dependencies:
-    "@ethersproject/bignumber" "^5.0.13"
-
-"@ethersproject/constants@^5.0.4", "@ethersproject/constants@^5.0.8", "@ethersproject/constants@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.7.0.tgz#df80a9705a7e08984161f09014ea012d1c75295e"
-  integrity sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==
-  dependencies:
-    "@ethersproject/bignumber" "^5.7.0"
-
-"@ethersproject/hash@>=5.0.0-beta.128":
-  version "5.0.12"
-  resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.0.12.tgz#1074599f7509e2ca2bb7a3d4f4e39ab3a796da42"
-  integrity sha512-kn4QN+fhNFbUgX3XZTZUaQixi0oyfIEY+hfW+KtkHu+rq7dV76oAIvaLEEynu1/4npOL38E4X4YI42gGZk+C0Q==
-  dependencies:
-    "@ethersproject/abstract-signer" "^5.0.10"
-    "@ethersproject/address" "^5.0.9"
-    "@ethersproject/bignumber" "^5.0.13"
-    "@ethersproject/bytes" "^5.0.9"
-    "@ethersproject/keccak256" "^5.0.7"
-    "@ethersproject/logger" "^5.0.8"
-    "@ethersproject/properties" "^5.0.7"
-    "@ethersproject/strings" "^5.0.8"
-
-"@ethersproject/hash@^5.0.4":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.7.0.tgz#eb7aca84a588508369562e16e514b539ba5240a7"
-  integrity sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==
-  dependencies:
-    "@ethersproject/abstract-signer" "^5.7.0"
-    "@ethersproject/address" "^5.7.0"
-    "@ethersproject/base64" "^5.7.0"
-    "@ethersproject/bignumber" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/keccak256" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-    "@ethersproject/strings" "^5.7.0"
-
-"@ethersproject/keccak256@>=5.0.0-beta.127":
-  version "5.0.9"
-  resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.0.9.tgz#ca0d86e4af56c13b1ef25e533bde3e96d28f647d"
-  integrity sha512-zhdUTj6RGtCJSgU+bDrWF6cGbvW453LoIC1DSNWrTlXzC7WuH4a+EiPrgc7/kNoRxerKuA/cxYlI8GwNtVtDlw==
-  dependencies:
-    "@ethersproject/bytes" "^5.0.9"
-    js-sha3 "0.5.7"
-
-"@ethersproject/keccak256@^5.0.3", "@ethersproject/keccak256@^5.0.7", "@ethersproject/keccak256@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.7.0.tgz#3186350c6e1cd6aba7940384ec7d6d9db01f335a"
-  integrity sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-    js-sha3 "0.8.0"
-
-"@ethersproject/logger@>=5.0.0-beta.129":
-  version "5.0.10"
-  resolved "https://registry.yarnpkg.com/@ethersproject/logger/-/logger-5.0.10.tgz#fd884688b3143253e0356ef92d5f22d109d2e026"
-  integrity sha512-0y2T2NqykDrbPM3Zw9RSbPkDOxwChAL8detXaom76CfYoGxsOnRP/zTX8OUAV+x9LdwzgbWvWmeXrc0M7SuDZw==
-
-"@ethersproject/logger@^5.0.5", "@ethersproject/logger@^5.0.8", "@ethersproject/logger@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/logger/-/logger-5.7.0.tgz#6ce9ae168e74fecf287be17062b590852c311892"
-  integrity sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==
-
-"@ethersproject/networks@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.7.0.tgz#df72a392f1a63a57f87210515695a31a245845ad"
-  integrity sha512-MG6oHSQHd4ebvJrleEQQ4HhVu8Ichr0RDYEfHzsVAVjHNM+w36x9wp9r+hf1JstMXtseXDtkiVoARAG6M959AA==
-  dependencies:
-    "@ethersproject/logger" "^5.7.0"
-
-"@ethersproject/properties@>=5.0.0-beta.131":
-  version "5.0.9"
-  resolved "https://registry.yarnpkg.com/@ethersproject/properties/-/properties-5.0.9.tgz#d7aae634680760136ea522e25c3ef043ec15b5c2"
-  integrity sha512-ZCjzbHYTw+rF1Pn8FDCEmx3gQttwIHcm/6Xee8g/M3Ga3SfW4tccNMbs5zqnBH0E4RoOPaeNgyg1O68TaF0tlg==
-  dependencies:
-    "@ethersproject/logger" "^5.0.8"
-
-"@ethersproject/properties@^5.0.3", "@ethersproject/properties@^5.0.7", "@ethersproject/properties@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/properties/-/properties-5.7.0.tgz#a6e12cb0439b878aaf470f1902a176033067ed30"
-  integrity sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw==
-  dependencies:
-    "@ethersproject/logger" "^5.7.0"
-
-"@ethersproject/rlp@^5.0.7", "@ethersproject/rlp@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/rlp/-/rlp-5.7.0.tgz#de39e4d5918b9d74d46de93af80b7685a9c21304"
-  integrity sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-
-"@ethersproject/signing-key@^5.0.8", "@ethersproject/signing-key@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.7.0.tgz#06b2df39411b00bc57c7c09b01d1e41cf1b16ab3"
-  integrity sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-    bn.js "^5.2.1"
-    elliptic "6.5.4"
-    hash.js "1.1.7"
-
-"@ethersproject/strings@>=5.0.0-beta.130":
-  version "5.0.10"
-  resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.0.10.tgz#ddce1e9724f4ac4f3f67e0cac0b48748e964bfdb"
-  integrity sha512-KAeoS1tZ9/5ECXiIZA6S6hywbD0so2VmuW+Wfyo5EDXeyZ6Na1nxTPhTnW7voQmjbeYJffCrOc0qLFJeylyg7w==
-  dependencies:
-    "@ethersproject/bytes" "^5.0.9"
-    "@ethersproject/constants" "^5.0.8"
-    "@ethersproject/logger" "^5.0.8"
-
-"@ethersproject/strings@^5.0.4", "@ethersproject/strings@^5.0.8", "@ethersproject/strings@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.7.0.tgz#54c9d2a7c57ae8f1205c88a9d3a56471e14d5ed2"
-  integrity sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/constants" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-
-"@ethersproject/transactions@^5.0.0-beta.135":
-  version "5.0.11"
-  resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.0.11.tgz#b31df5292f47937136a45885d6ee6112477c13df"
-  integrity sha512-ftsRvR9+gQp7L63F6+XmstvsZ4w8GtWvQB08e/zB+oB86Fnhq8+i/tkgpJplSHC8I/qgiCisva+M3u2GVhDFPA==
-  dependencies:
-    "@ethersproject/address" "^5.0.9"
-    "@ethersproject/bignumber" "^5.0.13"
-    "@ethersproject/bytes" "^5.0.9"
-    "@ethersproject/constants" "^5.0.8"
-    "@ethersproject/keccak256" "^5.0.7"
-    "@ethersproject/logger" "^5.0.8"
-    "@ethersproject/properties" "^5.0.7"
-    "@ethersproject/rlp" "^5.0.7"
-    "@ethersproject/signing-key" "^5.0.8"
-
-"@ethersproject/transactions@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.7.0.tgz#91318fc24063e057885a6af13fdb703e1f993d3b"
-  integrity sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ==
-  dependencies:
-    "@ethersproject/address" "^5.7.0"
-    "@ethersproject/bignumber" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/constants" "^5.7.0"
-    "@ethersproject/keccak256" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-    "@ethersproject/rlp" "^5.7.0"
-    "@ethersproject/signing-key" "^5.7.0"
-
-"@ethersproject/web@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.7.0.tgz#40850c05260edad8b54827923bbad23d96aac0bc"
-  integrity sha512-ApHcbbj+muRASVDSCl/tgxaH2LBkRMEYfLOLVa0COipx0+nlu0QKet7U2lEg0vdkh8XRSLf2nd1f1Uk9SrVSGA==
-  dependencies:
-    "@ethersproject/base64" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-    "@ethersproject/strings" "^5.7.0"
-
-"@float-capital/float-subgraph-uncrashable@^0.0.0-alpha.4":
-  version "0.0.0-internal-testing.5"
-  resolved "https://registry.yarnpkg.com/@float-capital/float-subgraph-uncrashable/-/float-subgraph-uncrashable-0.0.0-internal-testing.5.tgz#060f98440f6e410812766c5b040952d2d02e2b73"
-  integrity sha512-yZ0H5e3EpAYKokX/AbtplzlvSxEJY7ZfpvQyDzyODkks0hakAAlDG6fQu1SlDJMWorY7bbq1j7fCiFeTWci6TA==
-  dependencies:
-    "@rescript/std" "9.0.0"
-    graphql "^16.6.0"
-    graphql-import-node "^0.0.5"
-    js-yaml "^4.1.0"
-
-"@graphprotocol/graph-cli@0.62.0":
-  version "0.62.0"
-  resolved "https://registry.yarnpkg.com/@graphprotocol/graph-cli/-/graph-cli-0.62.0.tgz#948d3861d9ff027728097deac5d8751924ec0c8a"
-  integrity sha512-dyjhkCSXbdcul5h1wY2CmorjM4k+tjjzEFs5GFBSSdLC2VodKXEWJo9RzrpFSmRBJzwc7ywDf8Pbmy1cJTCXRA==
-  dependencies:
-    "@float-capital/float-subgraph-uncrashable" "^0.0.0-alpha.4"
-    "@oclif/core" "2.8.6"
-    "@oclif/plugin-autocomplete" "^2.3.6"
-    "@oclif/plugin-not-found" "^2.4.0"
-    "@whatwg-node/fetch" "^0.8.4"
-    assemblyscript "0.19.23"
-    binary-install-raw "0.0.13"
-    chalk "3.0.0"
-    chokidar "3.5.3"
-    debug "4.3.4"
-    docker-compose "0.23.19"
-    dockerode "2.5.8"
-    fs-extra "9.1.0"
-    glob "9.3.5"
-    gluegun "5.1.2"
-    graphql "15.5.0"
-    immutable "4.2.1"
-    ipfs-http-client "55.0.0"
-    jayson "4.0.0"
-    js-yaml "3.14.1"
-    prettier "1.19.1"
-    request "2.88.2"
-    semver "7.4.0"
-    sync-request "6.1.0"
-    tmp-promise "3.0.3"
-    web3-eth-abi "1.7.0"
-    which "2.0.2"
-    yaml "1.10.2"
-
-"@graphprotocol/graph-ts@0.31.0":
-  version "0.31.0"
-  resolved "https://registry.yarnpkg.com/@graphprotocol/graph-ts/-/graph-ts-0.31.0.tgz#730668c0369828b31bef81e8d9bc66b9b48e3480"
-  integrity sha512-xreRVM6ho2BtolyOh2flDkNoGZximybnzUnF53zJVp0+Ed0KnAlO1/KOCUYw06euVI9tk0c9nA2Z/D5SIQV2Rg==
-  dependencies:
-    assemblyscript "0.19.10"
-
-"@graphql-tools/batch-delegate@^6.2.4", "@graphql-tools/batch-delegate@^6.2.6":
-  version "6.2.6"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/batch-delegate/-/batch-delegate-6.2.6.tgz#fbea98dc825f87ef29ea5f3f371912c2a2aa2f2c"
-  integrity sha512-QUoE9pQtkdNPFdJHSnBhZtUfr3M7pIRoXoMR+TG7DK2Y62ISKbT/bKtZEUU1/2v5uqd5WVIvw9dF8gHDSJAsSA==
-  dependencies:
-    "@graphql-tools/delegate" "^6.2.4"
-    dataloader "2.0.0"
-    tslib "~2.0.1"
-
-"@graphql-tools/batch-execute@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/batch-execute/-/batch-execute-7.0.0.tgz#e79d11bd5b39f29172f6ec2eafa71103c6a6c85b"
-  integrity sha512-+ywPfK6N2Ddna6oOa5Qb1Mv7EA8LOwRNOAPP9dL37FEhksJM9pYqPSceUcqMqg7S9b0+Cgr78s408rgvurV3/Q==
-  dependencies:
-    "@graphql-tools/utils" "^7.0.0"
-    dataloader "2.0.0"
-    is-promise "4.0.0"
-    tslib "~2.0.1"
-
-"@graphql-tools/code-file-loader@^6.2.4":
-  version "6.3.1"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/code-file-loader/-/code-file-loader-6.3.1.tgz#42dfd4db5b968acdb453382f172ec684fa0c34ed"
-  integrity sha512-ZJimcm2ig+avgsEOWWVvAaxZrXXhiiSZyYYOJi0hk9wh5BxZcLUNKkTp6EFnZE/jmGUwuos3pIjUD3Hwi3Bwhg==
-  dependencies:
-    "@graphql-tools/graphql-tag-pluck" "^6.5.1"
-    "@graphql-tools/utils" "^7.0.0"
-    tslib "~2.1.0"
-
-"@graphql-tools/delegate@^6.2.4":
-  version "6.2.4"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/delegate/-/delegate-6.2.4.tgz#db553b63eb9512d5eb5bbfdfcd8cb1e2b534699c"
-  integrity sha512-mXe6DfoWmq49kPcDrpKHgC2DSWcD5q0YCaHHoXYPAOlnLH8VMTY8BxcE8y/Do2eyg+GLcwAcrpffVszWMwqw0w==
-  dependencies:
-    "@ardatan/aggregate-error" "0.0.6"
-    "@graphql-tools/schema" "^6.2.4"
-    "@graphql-tools/utils" "^6.2.4"
-    dataloader "2.0.0"
-    is-promise "4.0.0"
-    tslib "~2.0.1"
-
-"@graphql-tools/delegate@^7.0.1", "@graphql-tools/delegate@^7.0.7":
-  version "7.0.10"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/delegate/-/delegate-7.0.10.tgz#f87ac85a2dbd03b5b3aabf347f4479fabe8ceac3"
-  integrity sha512-6Di9ia5ohoDvrHuhj2cak1nJGhIefJmUsd3WKZcJ2nu2yZAFawWMxGvQImqv3N7iyaWKiVhrrK8Roi/JrYhdKg==
-  dependencies:
-    "@ardatan/aggregate-error" "0.0.6"
-    "@graphql-tools/batch-execute" "^7.0.0"
-    "@graphql-tools/schema" "^7.0.0"
-    "@graphql-tools/utils" "^7.1.6"
-    dataloader "2.0.0"
-    is-promise "4.0.0"
-    tslib "~2.1.0"
-
-"@graphql-tools/git-loader@^6.2.4":
-  version "6.2.6"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/git-loader/-/git-loader-6.2.6.tgz#c2226f4b8f51f1c05c9ab2649ba32d49c68cd077"
-  integrity sha512-ooQTt2CaG47vEYPP3CPD+nbA0F+FYQXfzrB1Y1ABN9K3d3O2RK3g8qwslzZaI8VJQthvKwt0A95ZeE4XxteYfw==
-  dependencies:
-    "@graphql-tools/graphql-tag-pluck" "^6.2.6"
-    "@graphql-tools/utils" "^7.0.0"
-    tslib "~2.1.0"
-
-"@graphql-tools/github-loader@^6.2.4":
-  version "6.2.5"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/github-loader/-/github-loader-6.2.5.tgz#460dff6f5bbaa26957a5ea3be4f452b89cc6a44b"
-  integrity sha512-DLuQmYeNNdPo8oWus8EePxWCfCAyUXPZ/p1PWqjrX/NGPyH2ZObdqtDAfRHztljt0F/qkBHbGHCEk2TKbRZTRw==
-  dependencies:
-    "@graphql-tools/graphql-tag-pluck" "^6.2.6"
-    "@graphql-tools/utils" "^7.0.0"
-    cross-fetch "3.0.6"
-    tslib "~2.0.1"
-
-"@graphql-tools/graphql-file-loader@^6.2.4":
-  version "6.2.7"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/graphql-file-loader/-/graphql-file-loader-6.2.7.tgz#d3720f2c4f4bb90eb2a03a7869a780c61945e143"
-  integrity sha512-5k2SNz0W87tDcymhEMZMkd6/vs6QawDyjQXWtqkuLTBF3vxjxPD1I4dwHoxgWPIjjANhXybvulD7E+St/7s9TQ==
-  dependencies:
-    "@graphql-tools/import" "^6.2.6"
-    "@graphql-tools/utils" "^7.0.0"
-    tslib "~2.1.0"
-
-"@graphql-tools/graphql-tag-pluck@^6.2.4", "@graphql-tools/graphql-tag-pluck@^6.2.6", "@graphql-tools/graphql-tag-pluck@^6.5.1":
-  version "6.5.1"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/graphql-tag-pluck/-/graphql-tag-pluck-6.5.1.tgz#5fb227dbb1e19f4b037792b50f646f16a2d4c686"
-  integrity sha512-7qkm82iFmcpb8M6/yRgzjShtW6Qu2OlCSZp8uatA3J0eMl87TxyJoUmL3M3UMMOSundAK8GmoyNVFUrueueV5Q==
-  dependencies:
-    "@babel/parser" "7.12.16"
-    "@babel/traverse" "7.12.13"
-    "@babel/types" "7.12.13"
-    "@graphql-tools/utils" "^7.0.0"
-    tslib "~2.1.0"
-
-"@graphql-tools/import@^6.2.4", "@graphql-tools/import@^6.2.6":
-  version "6.3.0"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/import/-/import-6.3.0.tgz#171472b425ea7cba4a612ad524b96bd206ae71b6"
-  integrity sha512-zmaVhJ3UPjzJSb005Pjn2iWvH+9AYRXI4IUiTi14uPupiXppJP3s7S25Si3+DbHpFwurDF2nWRxBLiFPWudCqw==
-  dependencies:
-    resolve-from "5.0.0"
-    tslib "~2.1.0"
-
-"@graphql-tools/json-file-loader@^6.2.4":
-  version "6.2.6"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/json-file-loader/-/json-file-loader-6.2.6.tgz#830482cfd3721a0799cbf2fe5b09959d9332739a"
-  integrity sha512-CnfwBSY5926zyb6fkDBHnlTblHnHI4hoBALFYXnrg0Ev4yWU8B04DZl/pBRUc459VNgO2x8/mxGIZj2hPJG1EA==
-  dependencies:
-    "@graphql-tools/utils" "^7.0.0"
-    tslib "~2.0.1"
-
-"@graphql-tools/links@^6.2.4":
-  version "6.2.5"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/links/-/links-6.2.5.tgz#b172cadc4b7cbe27bfc1dc787651f92517f583bc"
-  integrity sha512-XeGDioW7F+HK6HHD/zCeF0HRC9s12NfOXAKv1HC0J7D50F4qqMvhdS/OkjzLoBqsgh/Gm8icRc36B5s0rOA9ig==
-  dependencies:
-    "@graphql-tools/utils" "^7.0.0"
-    apollo-link "1.2.14"
-    apollo-upload-client "14.1.2"
-    cross-fetch "3.0.6"
-    form-data "3.0.0"
-    is-promise "4.0.0"
-    tslib "~2.0.1"
-
-"@graphql-tools/load-files@^6.2.4":
-  version "6.3.0"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/load-files/-/load-files-6.3.0.tgz#3957e21e14eb078f68fb4ebe84702f1bdc03ca23"
-  integrity sha512-qDEMz3f5CQz8lIvIhzJVK6Fvd6TMMbhuqded4x5I6zWEetR4AUmwneHWnQkwyIRqDDGgy6VlBw7GToucUkvQag==
-  dependencies:
-    globby "11.0.2"
-    tslib "~2.1.0"
-    unixify "1.0.0"
-
-"@graphql-tools/load@^6.2.4":
-  version "6.2.7"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/load/-/load-6.2.7.tgz#61f7909d37fb1c095e3e8d4f7a6d3b8bb011e26a"
-  integrity sha512-b1qWjki1y/QvGtoqW3x8bcwget7xmMfLGsvGFWOB6m38tDbzVT3GlJViAC0nGPDks9OCoJzAdi5IYEkBaqH5GQ==
-  dependencies:
-    "@graphql-tools/merge" "^6.2.9"
-    "@graphql-tools/utils" "^7.5.0"
-    globby "11.0.2"
-    import-from "3.0.0"
-    is-glob "4.0.1"
-    p-limit "3.1.0"
-    tslib "~2.1.0"
-    unixify "1.0.0"
-    valid-url "1.0.9"
-
-"@graphql-tools/merge@^6.2.4", "@graphql-tools/merge@^6.2.9":
-  version "6.2.10"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/merge/-/merge-6.2.10.tgz#cadb37b1bed786cba1b3c6f728c5476a164e153d"
-  integrity sha512-dM3n37PcslvhOAkCz7Cwk0BfoiSVKXGmCX+VMZkATbXk/0vlxUfNEpVfA5yF4IkP27F04SzFQSaNrbD0W2Rszw==
-  dependencies:
-    "@graphql-tools/schema" "^7.0.0"
-    "@graphql-tools/utils" "^7.5.0"
-    tslib "~2.1.0"
-
-"@graphql-tools/mock@^6.2.4":
-  version "6.2.4"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/mock/-/mock-6.2.4.tgz#205323c51f89dd855d345d130c7713d0420909ea"
-  integrity sha512-O5Zvq/mcDZ7Ptky0IZ4EK9USmxV6FEVYq0Jxv2TI80kvxbCjt0tbEpZ+r1vIt1gZOXlAvadSHYyzWnUPh+1vkQ==
-  dependencies:
-    "@graphql-tools/schema" "^6.2.4"
-    "@graphql-tools/utils" "^6.2.4"
-    tslib "~2.0.1"
-
-"@graphql-tools/module-loader@^6.2.4":
-  version "6.2.7"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/module-loader/-/module-loader-6.2.7.tgz#66ab9468775fac8079ca46ea9896ceea76e4ef69"
-  integrity sha512-ItAAbHvwfznY9h1H9FwHYDstTcm22Dr5R9GZtrWlpwqj0jaJGcBxsMB9jnK9kFqkbtFYEe4E/NsSnxsS4/vViQ==
-  dependencies:
-    "@graphql-tools/utils" "^7.5.0"
-    tslib "~2.1.0"
-
-"@graphql-tools/relay-operation-optimizer@^6.2.4":
-  version "6.3.0"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/relay-operation-optimizer/-/relay-operation-optimizer-6.3.0.tgz#f8c7f6c8aa4a9cf50ab151fbc5db4f4282a79532"
-  integrity sha512-Or3UgRvkY9Fq1AAx7q38oPqFmTepLz7kp6wDHKyR0ceG7AvHv5En22R12mAeISInbhff4Rpwgf6cE8zHRu6bCw==
-  dependencies:
-    "@graphql-tools/utils" "^7.1.0"
-    relay-compiler "10.1.0"
-    tslib "~2.0.1"
-
-"@graphql-tools/resolvers-composition@^6.2.4":
-  version "6.2.6"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/resolvers-composition/-/resolvers-composition-6.2.6.tgz#b369cdf2772a41a7544bf3f16a794501da34c394"
-  integrity sha512-QO0PC5RG0SolOksupOuB4B0tuzEsQFwQrwD9xLHCrJmjaLi66lOKMFzN40IBY5rqg0k/zqPyjII8rtzcNobvIg==
-  dependencies:
-    "@graphql-tools/utils" "^7.0.0"
-    lodash "4.17.21"
-    tslib "~2.1.0"
-
-"@graphql-tools/schema@^6.2.4":
-  version "6.2.4"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/schema/-/schema-6.2.4.tgz#cc4e9f5cab0f4ec48500e666719d99fc5042481d"
-  integrity sha512-rh+14lSY1q8IPbEv2J9x8UBFJ5NrDX9W5asXEUlPp+7vraLp/Tiox4GXdgyA92JhwpYco3nTf5Bo2JDMt1KnAQ==
-  dependencies:
-    "@graphql-tools/utils" "^6.2.4"
-    tslib "~2.0.1"
-
-"@graphql-tools/schema@^7.0.0", "@graphql-tools/schema@^7.1.2":
-  version "7.1.3"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/schema/-/schema-7.1.3.tgz#d816400da51fbac1f0086e35540ab63b5e30e858"
-  integrity sha512-ZY76hmcJlF1iyg3Im0sQ3ASRkiShjgv102vLTVcH22lEGJeCaCyyS/GF1eUHom418S60bS8Th6+autRUxfBiBg==
-  dependencies:
-    "@graphql-tools/utils" "^7.1.2"
-    tslib "~2.1.0"
-
-"@graphql-tools/stitch@^6.2.4":
-  version "6.2.4"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/stitch/-/stitch-6.2.4.tgz#acfa6a577a33c0f02e4940ffff04753b23b87fd6"
-  integrity sha512-0C7PNkS7v7iAc001m7c1LPm5FUB0/DYw+s3OyCii6YYYHY8NwdI0roeOyeDGFJkFubWBQfjc3hoSyueKtU73mw==
-  dependencies:
-    "@graphql-tools/batch-delegate" "^6.2.4"
-    "@graphql-tools/delegate" "^6.2.4"
-    "@graphql-tools/merge" "^6.2.4"
-    "@graphql-tools/schema" "^6.2.4"
-    "@graphql-tools/utils" "^6.2.4"
-    "@graphql-tools/wrap" "^6.2.4"
-    is-promise "4.0.0"
-    tslib "~2.0.1"
-
-"@graphql-tools/url-loader@^6.2.4":
-  version "6.8.1"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/url-loader/-/url-loader-6.8.1.tgz#cbfbe20f1a1bdeb9a4704e37b8286026d228920b"
-  integrity sha512-iE/y9IAu0cZYL7o9IIDdGm5WjxacN25nGgVqjZINYlisW/wyuBxng7DMJBAp6yM6gkxkCpMno1ljA/52MXzVPQ==
-  dependencies:
-    "@graphql-tools/delegate" "^7.0.1"
-    "@graphql-tools/utils" "^7.1.5"
-    "@graphql-tools/wrap" "^7.0.4"
-    "@types/websocket" "1.0.1"
-    cross-fetch "3.0.6"
-    eventsource "1.0.7"
-    extract-files "9.0.0"
-    form-data "4.0.0"
-    graphql-upload "^11.0.0"
-    graphql-ws "4.1.5"
-    is-promise "4.0.0"
-    isomorphic-ws "4.0.1"
-    sse-z "0.3.0"
-    sync-fetch "0.3.0"
-    tslib "~2.1.0"
-    valid-url "1.0.9"
-    ws "7.4.3"
-
-"@graphql-tools/utils@^6.2.4":
-  version "6.2.4"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/utils/-/utils-6.2.4.tgz#38a2314d2e5e229ad4f78cca44e1199e18d55856"
-  integrity sha512-ybgZ9EIJE3JMOtTrTd2VcIpTXtDrn2q6eiYkeYMKRVh3K41+LZa6YnR2zKERTXqTWqhobROwLt4BZbw2O3Aeeg==
-  dependencies:
-    "@ardatan/aggregate-error" "0.0.6"
-    camel-case "4.1.1"
-    tslib "~2.0.1"
-
-"@graphql-tools/utils@^7.0.0", "@graphql-tools/utils@^7.1.0", "@graphql-tools/utils@^7.1.2", "@graphql-tools/utils@^7.1.5", "@graphql-tools/utils@^7.1.6", "@graphql-tools/utils@^7.2.1", "@graphql-tools/utils@^7.5.0":
-  version "7.5.1"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/utils/-/utils-7.5.1.tgz#1c77ca69ffeb428e8ec51e661413bc6a5594268b"
-  integrity sha512-FYhSdJrU5cZ8BRuzCVV+YixLx3mXYVzowpKGPfI7re9/WvQPjlyIcjG+hd0C4u/L9Dxx46nBkiqZxZZknE6/lA==
-  dependencies:
-    "@ardatan/aggregate-error" "0.0.6"
-    camel-case "4.1.2"
-    tslib "~2.1.0"
-
-"@graphql-tools/wrap@^6.2.4":
-  version "6.2.4"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/wrap/-/wrap-6.2.4.tgz#2709817da6e469753735a9fe038c9e99736b2c57"
-  integrity sha512-cyQgpybolF9DjL2QNOvTS1WDCT/epgYoiA8/8b3nwv5xmMBQ6/6nYnZwityCZ7njb7MMyk7HBEDNNlP9qNJDcA==
-  dependencies:
-    "@graphql-tools/delegate" "^6.2.4"
-    "@graphql-tools/schema" "^6.2.4"
-    "@graphql-tools/utils" "^6.2.4"
-    is-promise "4.0.0"
-    tslib "~2.0.1"
-
-"@graphql-tools/wrap@^7.0.4":
-  version "7.0.5"
-  resolved "https://registry.yarnpkg.com/@graphql-tools/wrap/-/wrap-7.0.5.tgz#8659a119abef11754f712b0c202e41a484951e0b"
-  integrity sha512-KCWBXsDfvG46GNUawRltJL4j9BMGoOG7oo3WEyCQP+SByWXiTe5cBF45SLDVQgdjljGNZhZ4Lq/7avIkF7/zDQ==
-  dependencies:
-    "@graphql-tools/delegate" "^7.0.7"
-    "@graphql-tools/schema" "^7.1.2"
-    "@graphql-tools/utils" "^7.2.1"
-    is-promise "4.0.0"
-    tslib "~2.0.1"
-
-"@graphql-typed-document-node/core@^3.0.0":
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/@graphql-typed-document-node/core/-/core-3.1.0.tgz#0eee6373e11418bfe0b5638f654df7a4ca6a3950"
-  integrity sha512-wYn6r8zVZyQJ6rQaALBEln5B1pzxb9shV5Ef97kTvn6yVGrqyXVnDqnU24MXnFubR+rZjBY9NWuxX3FB2sTsjg==
-
-"@gulp-sourcemaps/map-sources@1.X":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@gulp-sourcemaps/map-sources/-/map-sources-1.0.0.tgz#890ae7c5d8c877f6d384860215ace9d7ec945bda"
-  integrity sha1-iQrnxdjId/bThIYCFazp1+yUW9o=
-  dependencies:
-    normalize-path "^2.0.1"
-    through2 "^2.0.3"
-
-"@ipld/dag-cbor@^7.0.0":
-  version "7.0.3"
-  resolved "https://registry.yarnpkg.com/@ipld/dag-cbor/-/dag-cbor-7.0.3.tgz#aa31b28afb11a807c3d627828a344e5521ac4a1e"
-  integrity sha512-1VVh2huHsuohdXC1bGJNE8WR72slZ9XE2T3wbBBq31dm7ZBatmKLLxrB+XAqafxfRFjv08RZmj/W/ZqaM13AuA==
-  dependencies:
-    cborg "^1.6.0"
-    multiformats "^9.5.4"
-
-"@ipld/dag-json@^8.0.1":
-  version "8.0.11"
-  resolved "https://registry.yarnpkg.com/@ipld/dag-json/-/dag-json-8.0.11.tgz#8d30cc2dfacb0aef04d327465d3df91e79e8b6ce"
-  integrity sha512-Pea7JXeYHTWXRTIhBqBlhw7G53PJ7yta3G/sizGEZyzdeEwhZRr0od5IQ0r2ZxOt1Do+2czddjeEPp+YTxDwCA==
-  dependencies:
-    cborg "^1.5.4"
-    multiformats "^9.5.4"
-
-"@ipld/dag-pb@^2.1.3":
-  version "2.1.18"
-  resolved "https://registry.yarnpkg.com/@ipld/dag-pb/-/dag-pb-2.1.18.tgz#12d63e21580e87c75fd1a2c62e375a78e355c16f"
-  integrity sha512-ZBnf2fuX9y3KccADURG5vb9FaOeMjFkCrNysB0PtftME/4iCTjxfaLoNq/IAh5fTqUOMXvryN6Jyka4ZGuMLIg==
-  dependencies:
-    multiformats "^9.5.4"
-
-"@josephg/resolvable@^1.0.0":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@josephg/resolvable/-/resolvable-1.0.1.tgz#69bc4db754d79e1a2f17a650d3466e038d94a5eb"
-  integrity sha512-CtzORUwWTTOTqfVtHaKRJ0I1kNQd1bpn3sUh8I3nJDVY+5/M/Oe1DnEWzPQvqq/xPIIkzzzIP7mfCoAjFRvDhg==
-
-"@jridgewell/resolve-uri@^3.0.3":
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz#c08679063f279615a3326583ba3a90d1d82cc721"
-  integrity sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==
-
-"@jridgewell/sourcemap-codec@^1.4.10":
-  version "1.4.15"
-  resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32"
-  integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==
-
-"@jridgewell/trace-mapping@0.3.9":
-  version "0.3.9"
-  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz#6534fd5933a53ba7cbf3a17615e273a0d1273ff9"
-  integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==
-  dependencies:
-    "@jridgewell/resolve-uri" "^3.0.3"
-    "@jridgewell/sourcemap-codec" "^1.4.10"
-
-"@nodelib/fs.scandir@2.1.4":
-  version "2.1.4"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.4.tgz#d4b3549a5db5de2683e0c1071ab4f140904bbf69"
-  integrity sha512-33g3pMJk3bg5nXbL/+CY6I2eJDzZAni49PfJnL5fghPTggPvBd/pFNSgJsdAgWptuFu7qq/ERvOYFlhvsLTCKA==
-  dependencies:
-    "@nodelib/fs.stat" "2.0.4"
-    run-parallel "^1.1.9"
-
-"@nodelib/fs.stat@2.0.4", "@nodelib/fs.stat@^2.0.2":
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.4.tgz#a3f2dd61bab43b8db8fa108a121cfffe4c676655"
-  integrity sha512-IYlHJA0clt2+Vg7bccq+TzRdJvv19c2INqBSsoOLp1je7xjtr7J26+WXR72MCdvU9q1qTzIWDfhMf+DRvQJK4Q==
-
-"@nodelib/fs.walk@^1.2.3":
-  version "1.2.6"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.6.tgz#cce9396b30aa5afe9e3756608f5831adcb53d063"
-  integrity sha512-8Broas6vTtW4GIXTAHDoE32hnN2M5ykgCpWGbuXHQ15vEMqr23pB76e/GZcYsZCHALv50ktd24qhEyKr6wBtow==
-  dependencies:
-    "@nodelib/fs.scandir" "2.1.4"
-    fastq "^1.6.0"
-
-"@oclif/core@2.8.6":
-  version "2.8.6"
-  resolved "https://registry.yarnpkg.com/@oclif/core/-/core-2.8.6.tgz#7eb6984108f471ad0d719d3c07cde14c47ab17c5"
-  integrity sha512-1QlPaHMhOORySCXkQyzjsIsy2GYTilOw3LkjeHkCgsPJQjAT4IclVytJusWktPbYNys9O+O4V23J44yomQvnBQ==
-  dependencies:
-    "@types/cli-progress" "^3.11.0"
-    ansi-escapes "^4.3.2"
-    ansi-styles "^4.3.0"
-    cardinal "^2.1.1"
-    chalk "^4.1.2"
-    clean-stack "^3.0.1"
-    cli-progress "^3.12.0"
-    debug "^4.3.4"
-    ejs "^3.1.8"
-    fs-extra "^9.1.0"
-    get-package-type "^0.1.0"
-    globby "^11.1.0"
-    hyperlinker "^1.0.0"
-    indent-string "^4.0.0"
-    is-wsl "^2.2.0"
-    js-yaml "^3.14.1"
-    natural-orderby "^2.0.3"
-    object-treeify "^1.1.33"
-    password-prompt "^1.1.2"
-    semver "^7.3.7"
-    string-width "^4.2.3"
-    strip-ansi "^6.0.1"
-    supports-color "^8.1.1"
-    supports-hyperlinks "^2.2.0"
-    ts-node "^10.9.1"
-    tslib "^2.5.0"
-    widest-line "^3.1.0"
-    wordwrap "^1.0.0"
-    wrap-ansi "^7.0.0"
-
-"@oclif/core@^2.15.0":
-  version "2.15.0"
-  resolved "https://registry.yarnpkg.com/@oclif/core/-/core-2.15.0.tgz#f27797b30a77d13279fba88c1698fc34a0bd0d2a"
-  integrity sha512-fNEMG5DzJHhYmI3MgpByTvltBOMyFcnRIUMxbiz2ai8rhaYgaTHMG3Q38HcosfIvtw9nCjxpcQtC8MN8QtVCcA==
-  dependencies:
-    "@types/cli-progress" "^3.11.0"
-    ansi-escapes "^4.3.2"
-    ansi-styles "^4.3.0"
-    cardinal "^2.1.1"
-    chalk "^4.1.2"
-    clean-stack "^3.0.1"
-    cli-progress "^3.12.0"
-    debug "^4.3.4"
-    ejs "^3.1.8"
-    get-package-type "^0.1.0"
-    globby "^11.1.0"
-    hyperlinker "^1.0.0"
-    indent-string "^4.0.0"
-    is-wsl "^2.2.0"
-    js-yaml "^3.14.1"
-    natural-orderby "^2.0.3"
-    object-treeify "^1.1.33"
-    password-prompt "^1.1.2"
-    slice-ansi "^4.0.0"
-    string-width "^4.2.3"
-    strip-ansi "^6.0.1"
-    supports-color "^8.1.1"
-    supports-hyperlinks "^2.2.0"
-    ts-node "^10.9.1"
-    tslib "^2.5.0"
-    widest-line "^3.1.0"
-    wordwrap "^1.0.0"
-    wrap-ansi "^7.0.0"
-
-"@oclif/plugin-autocomplete@^2.3.6":
-  version "2.3.10"
-  resolved "https://registry.yarnpkg.com/@oclif/plugin-autocomplete/-/plugin-autocomplete-2.3.10.tgz#787f6208cdfe10ffc68ad89e9e7f1a7ad0e8987f"
-  integrity sha512-Ow1AR8WtjzlyCtiWWPgzMyT8SbcDJFr47009riLioHa+MHX2BCDtVn2DVnN/E6b9JlPV5ptQpjefoRSNWBesmg==
-  dependencies:
-    "@oclif/core" "^2.15.0"
-    chalk "^4.1.0"
-    debug "^4.3.4"
-
-"@oclif/plugin-not-found@^2.4.0":
-  version "2.4.3"
-  resolved "https://registry.yarnpkg.com/@oclif/plugin-not-found/-/plugin-not-found-2.4.3.tgz#3d24095adb0f3876cb4bcfdfdcb775086cf6d4b5"
-  integrity sha512-nIyaR4y692frwh7wIHZ3fb+2L6XEecQwRDIb4zbEam0TvaVmBQWZoColQyWA84ljFBPZ8XWiQyTz+ixSwdRkqg==
-  dependencies:
-    "@oclif/core" "^2.15.0"
-    chalk "^4"
-    fast-levenshtein "^3.0.0"
-
-"@peculiar/asn1-schema@^2.3.6":
-  version "2.3.6"
-  resolved "https://registry.yarnpkg.com/@peculiar/asn1-schema/-/asn1-schema-2.3.6.tgz#3dd3c2ade7f702a9a94dfb395c192f5fa5d6b922"
-  integrity sha512-izNRxPoaeJeg/AyH8hER6s+H7p4itk+03QCa4sbxI3lNdseQYCuxzgsuNK8bTXChtLTjpJz6NmXKA73qLa3rCA==
-  dependencies:
-    asn1js "^3.0.5"
-    pvtsutils "^1.3.2"
-    tslib "^2.4.0"
-
-"@peculiar/json-schema@^1.1.12":
-  version "1.1.12"
-  resolved "https://registry.yarnpkg.com/@peculiar/json-schema/-/json-schema-1.1.12.tgz#fe61e85259e3b5ba5ad566cb62ca75b3d3cd5339"
-  integrity sha512-coUfuoMeIB7B8/NMekxaDzLhaYmp0HZNPEjYRm9goRou8UZIC3z21s0sL9AWoCw4EG876QyO3kYrc61WNF9B/w==
-  dependencies:
-    tslib "^2.0.0"
-
-"@peculiar/webcrypto@^1.4.0":
-  version "1.4.3"
-  resolved "https://registry.yarnpkg.com/@peculiar/webcrypto/-/webcrypto-1.4.3.tgz#078b3e8f598e847b78683dc3ba65feb5029b93a7"
-  integrity sha512-VtaY4spKTdN5LjJ04im/d/joXuvLbQdgy5Z4DXF4MFZhQ+MTrejbNMkfZBp1Bs3O5+bFqnJgyGdPuZQflvIa5A==
-  dependencies:
-    "@peculiar/asn1-schema" "^2.3.6"
-    "@peculiar/json-schema" "^1.1.12"
-    pvtsutils "^1.3.2"
-    tslib "^2.5.0"
-    webcrypto-core "^1.7.7"
-
-"@protobufjs/aspromise@^1.1.1", "@protobufjs/aspromise@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@protobufjs/aspromise/-/aspromise-1.1.2.tgz#9b8b0cc663d669a7d8f6f5d0893a14d348f30fbf"
-  integrity sha1-m4sMxmPWaafY9vXQiToU00jzD78=
-
-"@protobufjs/base64@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@protobufjs/base64/-/base64-1.1.2.tgz#4c85730e59b9a1f1f349047dbf24296034bb2735"
-  integrity sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==
-
-"@protobufjs/codegen@^2.0.4":
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/@protobufjs/codegen/-/codegen-2.0.4.tgz#7ef37f0d010fb028ad1ad59722e506d9262815cb"
-  integrity sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==
-
-"@protobufjs/eventemitter@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz#355cbc98bafad5978f9ed095f397621f1d066b70"
-  integrity sha1-NVy8mLr61ZePntCV85diHx0Ga3A=
-
-"@protobufjs/fetch@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@protobufjs/fetch/-/fetch-1.1.0.tgz#ba99fb598614af65700c1619ff06d454b0d84c45"
-  integrity sha1-upn7WYYUr2VwDBYZ/wbUVLDYTEU=
-  dependencies:
-    "@protobufjs/aspromise" "^1.1.1"
-    "@protobufjs/inquire" "^1.1.0"
-
-"@protobufjs/float@^1.0.2":
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/@protobufjs/float/-/float-1.0.2.tgz#5e9e1abdcb73fc0a7cb8b291df78c8cbd97b87d1"
-  integrity sha1-Xp4avctz/Ap8uLKR33jIy9l7h9E=
-
-"@protobufjs/inquire@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@protobufjs/inquire/-/inquire-1.1.0.tgz#ff200e3e7cf2429e2dcafc1140828e8cc638f089"
-  integrity sha1-/yAOPnzyQp4tyvwRQIKOjMY48Ik=
-
-"@protobufjs/path@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@protobufjs/path/-/path-1.1.2.tgz#6cc2b20c5c9ad6ad0dccfd21ca7673d8d7fbf68d"
-  integrity sha1-bMKyDFya1q0NzP0hynZz2Nf79o0=
-
-"@protobufjs/pool@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@protobufjs/pool/-/pool-1.1.0.tgz#09fd15f2d6d3abfa9b65bc366506d6ad7846ff54"
-  integrity sha1-Cf0V8tbTq/qbZbw2ZQbWrXhG/1Q=
-
-"@protobufjs/utf8@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@protobufjs/utf8/-/utf8-1.1.0.tgz#a777360b5b39a1a2e5106f8e858f2fd2d060c570"
-  integrity sha1-p3c2C1s5oaLlEG+OhY8v0tBgxXA=
-
-"@redux-saga/core@^1.0.0":
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/@redux-saga/core/-/core-1.1.3.tgz#3085097b57a4ea8db5528d58673f20ce0950f6a4"
-  integrity sha512-8tInBftak8TPzE6X13ABmEtRJGjtK17w7VUs7qV17S8hCO5S3+aUTWZ/DBsBJPdE8Z5jOPwYALyvofgq1Ws+kg==
-  dependencies:
-    "@babel/runtime" "^7.6.3"
-    "@redux-saga/deferred" "^1.1.2"
-    "@redux-saga/delay-p" "^1.1.2"
-    "@redux-saga/is" "^1.1.2"
-    "@redux-saga/symbols" "^1.1.2"
-    "@redux-saga/types" "^1.1.0"
-    redux "^4.0.4"
-    typescript-tuple "^2.2.1"
-
-"@redux-saga/deferred@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@redux-saga/deferred/-/deferred-1.1.2.tgz#59937a0eba71fff289f1310233bc518117a71888"
-  integrity sha512-908rDLHFN2UUzt2jb4uOzj6afpjgJe3MjICaUNO3bvkV/kN/cNeI9PMr8BsFXB/MR8WTAZQq/PlTq8Kww3TBSQ==
-
-"@redux-saga/delay-p@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@redux-saga/delay-p/-/delay-p-1.1.2.tgz#8f515f4b009b05b02a37a7c3d0ca9ddc157bb355"
-  integrity sha512-ojc+1IoC6OP65Ts5+ZHbEYdrohmIw1j9P7HS9MOJezqMYtCDgpkoqB5enAAZrNtnbSL6gVCWPHaoaTY5KeO0/g==
-  dependencies:
-    "@redux-saga/symbols" "^1.1.2"
-
-"@redux-saga/is@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@redux-saga/is/-/is-1.1.2.tgz#ae6c8421f58fcba80faf7cadb7d65b303b97e58e"
-  integrity sha512-OLbunKVsCVNTKEf2cH4TYyNbbPgvmZ52iaxBD4I1fTif4+MTXMa4/Z07L83zW/hTCXwpSZvXogqMqLfex2Tg6w==
-  dependencies:
-    "@redux-saga/symbols" "^1.1.2"
-    "@redux-saga/types" "^1.1.0"
-
-"@redux-saga/symbols@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@redux-saga/symbols/-/symbols-1.1.2.tgz#216a672a487fc256872b8034835afc22a2d0595d"
-  integrity sha512-EfdGnF423glv3uMwLsGAtE6bg+R9MdqlHEzExnfagXPrIiuxwr3bdiAwz3gi+PsrQ3yBlaBpfGLtDG8rf3LgQQ==
-
-"@redux-saga/types@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@redux-saga/types/-/types-1.1.0.tgz#0e81ce56b4883b4b2a3001ebe1ab298b84237204"
-  integrity sha512-afmTuJrylUU/0OtqzaRkbyYFFNgCF73Bvel/sw90pvGrWIZ+vyoIJqA6eMSoA6+nb443kTmulmBtC9NerXboNg==
-
-"@rescript/std@9.0.0":
-  version "9.0.0"
-  resolved "https://registry.yarnpkg.com/@rescript/std/-/std-9.0.0.tgz#df53f3fa5911cb4e85bd66b92e9e58ddf3e4a7e1"
-  integrity sha512-zGzFsgtZ44mgL4Xef2gOy1hrRVdrs9mcxCOOKZrIPsmbZW14yTkaF591GXxpQvjXiHtgZ/iA9qLyWH6oSReIxQ==
-
-"@sindresorhus/is@^0.14.0":
-  version "0.14.0"
-  resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-0.14.0.tgz#9fb3a3cf3132328151f353de4632e01e52102bea"
-  integrity sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==
-
-"@szmarczak/http-timer@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@szmarczak/http-timer/-/http-timer-1.1.2.tgz#b1665e2c461a2cd92f4c1bbf50d5454de0d4b421"
-  integrity sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==
-  dependencies:
-    defer-to-connect "^1.0.1"
-
-"@truffle/abi-utils@^0.1.4", "@truffle/abi-utils@^0.1.5":
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/@truffle/abi-utils/-/abi-utils-0.1.5.tgz#95b39ee0cb6baf777fdbaa2ac6d901ab8b0f8c58"
-  integrity sha512-PvCN/qebM0boK2YycX3sMe6CwoLtB7cpYj2ugHPtcQ+Zpg1hQRGS+GRLeBuQg3RR5X8IxzLb4YPZh5dnJxMZYA==
-  dependencies:
-    change-case "3.0.2"
-    faker "^5.3.1"
-    fast-check "^2.12.1"
-    source-map-support "^0.5.19"
-
-"@truffle/blockchain-utils@^0.0.26":
-  version "0.0.26"
-  resolved "https://registry.yarnpkg.com/@truffle/blockchain-utils/-/blockchain-utils-0.0.26.tgz#f4ea794e0a18c74d73ea10e29a506c9ed0a503ee"
-  integrity sha512-M91NJkfapK1RqdzVwKSSenPEE2cHzAAFwC3aPhA8Y3DznRfzOcck4mDH6eY71sytVCrGaXGm/Wirn3drGSH+qQ==
-  dependencies:
-    source-map-support "^0.5.19"
-
-"@truffle/code-utils@^1.2.23", "@truffle/code-utils@^1.2.24":
-  version "1.2.24"
-  resolved "https://registry.yarnpkg.com/@truffle/code-utils/-/code-utils-1.2.24.tgz#8da82510e416128c45fc154e92410982ab98b426"
-  integrity sha512-IqpbTh4uNQueadv96GBWBaGTYTyOsLKE9Dui1wpiijON6xq2iIcTArej1vMh+nkAd5/AsP+enbBY8mksm6rFBg==
-  dependencies:
-    cbor "^5.1.0"
-    source-map-support "^0.5.19"
-
-"@truffle/codec@^0.10.1":
-  version "0.10.1"
-  resolved "https://registry.yarnpkg.com/@truffle/codec/-/codec-0.10.1.tgz#70df52ddf1c64781a23daaccda24e10bfb9dec9d"
-  integrity sha512-c1lC9Wcp+Z1DLvEYH3dkEtMKnUJx72CirO3kmi0OgFSA5QqTDCtfrVOhAugcb/iMLgqUK05/pexp2whb4oASKA==
-  dependencies:
-    big.js "^5.2.2"
-    bn.js "^5.1.3"
-    cbor "^5.1.0"
-    debug "^4.3.1"
-    lodash.clonedeep "^4.5.0"
-    lodash.escaperegexp "^4.1.2"
-    lodash.partition "^4.6.0"
-    lodash.sum "^4.0.2"
-    semver "^7.3.4"
-    source-map-support "^0.5.19"
-    utf8 "^3.0.0"
-    web3-utils "1.2.9"
-
-"@truffle/config@^1.2.35":
-  version "1.2.35"
-  resolved "https://registry.yarnpkg.com/@truffle/config/-/config-1.2.35.tgz#98a9ae3a964e73c33dcea4dcb172f878fdbb9bdd"
-  integrity sha512-ULTS9t3ldqEV1VBVNWlS9tdWJ0r637ANspzBoQd6S/Ab7CfueQhcIfp29oz6Ahcgjkl4NX+Gu/dG6/Jiys81vg==
-  dependencies:
-    "@truffle/error" "^0.0.12"
-    "@truffle/events" "^0.0.9"
-    "@truffle/provider" "^0.2.26"
-    configstore "^4.0.0"
-    find-up "^2.1.0"
-    lodash.assignin "^4.2.0"
-    lodash.merge "^4.6.2"
-    module "^1.2.5"
-    original-require "^1.0.1"
-    source-map-support "^0.5.19"
-
-"@truffle/contract-schema@^3.3.4":
-  version "3.3.4"
-  resolved "https://registry.yarnpkg.com/@truffle/contract-schema/-/contract-schema-3.3.4.tgz#95f0265cac7de7bcaa0542f5fe671a7896011bfe"
-  integrity sha512-HzscBl/GhZBvPNQeD9l6ewSHSkvNmE+bA0iTVa0Y2mNf5GD5Y3fK2NPyfbOdtckOvLqebvYGEDEPRiXc3BZ05g==
-  dependencies:
-    ajv "^6.10.0"
-    crypto-js "^3.1.9-1"
-    debug "^4.3.1"
-
-"@truffle/contract@^4.3":
-  version "4.3.9"
-  resolved "https://registry.yarnpkg.com/@truffle/contract/-/contract-4.3.9.tgz#caf515df359e72f207edc6f1d4e7b8bca88566a7"
-  integrity sha512-yd6nejsKEReJrPjOdRHkypfsMr337yc43qxu5b4TF2JAf2Kz7ZAWasHhY3j3xRwra3AqNOm4p3njkq8T+mKytg==
-  dependencies:
-    "@truffle/blockchain-utils" "^0.0.26"
-    "@truffle/contract-schema" "^3.3.4"
-    "@truffle/debug-utils" "^5.0.11"
-    "@truffle/error" "^0.0.12"
-    "@truffle/interface-adapter" "^0.4.19"
-    bignumber.js "^7.2.1"
-    ethereum-ens "^0.8.0"
-    ethers "^4.0.32"
-    source-map-support "^0.5.19"
-    web3 "1.2.9"
-    web3-core-helpers "1.2.9"
-    web3-core-promievent "1.2.9"
-    web3-eth-abi "1.2.9"
-    web3-utils "1.2.9"
-
-"@truffle/db@^0.5.3":
-  version "0.5.3"
-  resolved "https://registry.yarnpkg.com/@truffle/db/-/db-0.5.3.tgz#1223ee5c9b9f112abf5883f647d46ae1e45d5dbd"
-  integrity sha512-cNQJgcqC77xAIvFrS9R1XHmppOnlZmVZvcEqHOv0PGzcf0XA+hUkUgiOHFYn5bwTvGxLMrBlBmAnBprKlJYsRg==
-  dependencies:
-    "@truffle/abi-utils" "^0.1.4"
-    "@truffle/code-utils" "^1.2.23"
-    "@truffle/config" "^1.2.35"
-    apollo-server "^2.18.2"
-    debug "^4.3.1"
-    fs-extra "^9.1.0"
-    graphql "^15.3.0"
-    graphql-tag "^2.11.0"
-    graphql-tools "^6.2.4"
-    json-stable-stringify "^1.0.1"
-    jsondown "^1.0.0"
-    pascal-case "^2.0.1"
-    pluralize "^8.0.0"
-    pouchdb "7.1.1"
-    pouchdb-adapter-memory "^7.1.1"
-    pouchdb-adapter-node-websql "^7.0.0"
-    pouchdb-debug "^7.1.1"
-    pouchdb-find "^7.0.0"
-    source-map-support "^0.5.19"
-    web3-utils "1.2.9"
-
-"@truffle/debug-utils@^5.0.11":
-  version "5.0.11"
-  resolved "https://registry.yarnpkg.com/@truffle/debug-utils/-/debug-utils-5.0.11.tgz#297ff83943212bf593a641180e3b28b230acadaa"
-  integrity sha512-KurW9r1DcK9c7/I0H21YWGBKu77gWm5HfBW6T+MjuRh5FGpxZ7GPka8oQkJCAZQuZKaQc9r9BoCQYQx1NX8pIg==
-  dependencies:
-    "@truffle/codec" "^0.10.1"
-    "@trufflesuite/chromafi" "^2.2.2"
-    bn.js "^5.1.3"
-    chalk "^2.4.2"
-    debug "^4.3.1"
-    highlight.js "^10.4.0"
-    highlightjs-solidity "^1.0.21"
-
-"@truffle/debugger@^8.0.17":
-  version "8.0.17"
-  resolved "https://registry.yarnpkg.com/@truffle/debugger/-/debugger-8.0.17.tgz#a13cd3c967bf045e71a00bd711fb371effa06752"
-  integrity sha512-CpxsW3edO0gPygLUmIkhFC4hgONltYuhJIM8jhdYL4KpDe8hRlFjWeiveH++iJX/1ka1A2Wbyk9G/TtCdiLY4Q==
-  dependencies:
-    "@truffle/abi-utils" "^0.1.5"
-    "@truffle/codec" "^0.10.1"
-    "@truffle/source-map-utils" "^1.3.35"
-    bn.js "^5.1.3"
-    debug "^4.3.1"
-    json-pointer "^0.6.0"
-    json-stable-stringify "^1.0.1"
-    lodash.flatten "^4.4.0"
-    lodash.merge "^4.6.2"
-    lodash.sum "^4.0.2"
-    lodash.zipwith "^4.2.0"
-    redux "^3.7.2"
-    redux-cli-logger "^2.0.1"
-    redux-saga "1.0.0"
-    remote-redux-devtools "^0.5.12"
-    reselect-tree "^1.3.4"
-    semver "^7.3.4"
-    source-map-support "^0.5.19"
-    web3 "1.2.9"
-    web3-eth-abi "1.2.9"
-
-"@truffle/error@^0.0.12":
-  version "0.0.12"
-  resolved "https://registry.yarnpkg.com/@truffle/error/-/error-0.0.12.tgz#83e02e6ffe1d154fe274141d90038a91fd1e186d"
-  integrity sha512-kZqqnPR9YDJG7KCDOcN1qH16Qs0oz1PzF0Y93AWdhXuL9S9HYo/RUUeqGKbPpRBEZldQUS8aa4EzfK08u5pu6g==
-
-"@truffle/events@^0.0.9":
-  version "0.0.9"
-  resolved "https://registry.yarnpkg.com/@truffle/events/-/events-0.0.9.tgz#460fc72a04269526cbd8ef54069d474c22b42b23"
-  integrity sha512-o0rS8zkjCzg2vDJymSZyyq1eKdkRbxIFnsnYQl6Bc2StK89C/ZISenxrUe2fbdeq3L9Zq+ds1mSKH/MFK0Ejkg==
-  dependencies:
-    emittery "^0.4.1"
-    ora "^3.4.0"
-
-"@truffle/hdwallet-provider@^1.2":
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/@truffle/hdwallet-provider/-/hdwallet-provider-1.2.2.tgz#7b42f7cb7fc1f80751c573c72ba488e59690f8ea"
-  integrity sha512-gpE5M9c+G7uMR9Nn2xslY0BRdl8hvlrHxBJ451g/V3WnOI5rDQMXezz6VZMn3zvWDiQTPRknx1uUDfWvMuQwqg==
-  dependencies:
-    "@trufflesuite/web3-provider-engine" "15.0.13-1"
-    any-promise "^1.3.0"
-    bindings "^1.5.0"
-    ethereum-cryptography "^0.1.3"
-    ethereum-protocol "^1.0.1"
-    ethereumjs-tx "^1.0.0"
-    ethereumjs-util "^6.1.0"
-    ethereumjs-wallet "^1.0.1"
-    source-map-support "^0.5.19"
-
-"@truffle/interface-adapter@^0.4.19":
-  version "0.4.19"
-  resolved "https://registry.yarnpkg.com/@truffle/interface-adapter/-/interface-adapter-0.4.19.tgz#19248ac88099f8df34f58a3d43a95ba3470dc89a"
-  integrity sha512-+Zz6Fr8+I2wYSS8RM3WBOMzf22QffMQTnlsYsRgRHzv3gYoRA9ZDLb84lFRfmWyw+IdXTo90tjRHEb5krC6uxg==
-  dependencies:
-    bn.js "^5.1.3"
-    ethers "^4.0.32"
-    source-map-support "^0.5.19"
-    web3 "1.2.9"
-
-"@truffle/provider@^0.2.26":
-  version "0.2.26"
-  resolved "https://registry.yarnpkg.com/@truffle/provider/-/provider-0.2.26.tgz#88e31b79973c2427c4a17d9a59411e6fbc810190"
-  integrity sha512-YKPmhB9S9AQkT2ePGtadwjDduxU23DXXy+5zyM5fevw5GCbXSnf+jG6rICXjPkVFjuKBlXuq5JbuERZn43522Q==
-  dependencies:
-    "@truffle/error" "^0.0.12"
-    "@truffle/interface-adapter" "^0.4.19"
-    web3 "1.2.9"
-
-"@truffle/source-map-utils@^1.3.35":
-  version "1.3.35"
-  resolved "https://registry.yarnpkg.com/@truffle/source-map-utils/-/source-map-utils-1.3.35.tgz#aa40422a05e2727254665ee2c23659d01230eb8f"
-  integrity sha512-j3PHac4g/yQwxSB899lkal/YMuIXLNNlDGfCog2QrWqdtK7HJhx6X2tftwqrZzO4JTKc1Cs8KOCPOndx9W2xeQ==
-  dependencies:
-    "@truffle/code-utils" "^1.2.24"
-    "@truffle/codec" "^0.10.1"
-    debug "^4.3.1"
-    json-pointer "^0.6.0"
-    node-interval-tree "^1.3.3"
-    web3-utils "1.2.9"
-
-"@trufflesuite/chromafi@^2.2.2":
-  version "2.2.2"
-  resolved "https://registry.yarnpkg.com/@trufflesuite/chromafi/-/chromafi-2.2.2.tgz#d3fc507aa8504faffc50fb892cedcfe98ff57f77"
-  integrity sha512-mItQwVBsb8qP/vaYHQ1kDt2vJLhjoEXJptT6y6fJGvFophMFhOI/NsTVUa0nJL1nyMeFiS6hSYuNVdpQZzB1gA==
-  dependencies:
-    ansi-mark "^1.0.0"
-    ansi-regex "^3.0.0"
-    array-uniq "^1.0.3"
-    camelcase "^4.1.0"
-    chalk "^2.3.2"
-    cheerio "^1.0.0-rc.2"
-    detect-indent "^5.0.0"
-    he "^1.1.1"
-    highlight.js "^10.4.1"
-    lodash.merge "^4.6.2"
-    min-indent "^1.0.0"
-    strip-ansi "^4.0.0"
-    strip-indent "^2.0.0"
-    super-split "^1.1.0"
-
-"@trufflesuite/eth-json-rpc-filters@^4.1.2-1":
-  version "4.1.2-1"
-  resolved "https://registry.yarnpkg.com/@trufflesuite/eth-json-rpc-filters/-/eth-json-rpc-filters-4.1.2-1.tgz#61ab78c52e98a883e5cf086925b34a30297b1824"
-  integrity sha512-/MChvC5dw2ck9NU1cZmdovCz2VKbOeIyR4tcxDvA5sT+NaL0rA2/R5U0yI7zsbo1zD+pgqav77rQHTzpUdDNJQ==
-  dependencies:
-    "@trufflesuite/eth-json-rpc-middleware" "^4.4.2-0"
-    await-semaphore "^0.1.3"
-    eth-query "^2.1.2"
-    json-rpc-engine "^5.1.3"
-    lodash.flatmap "^4.5.0"
-    safe-event-emitter "^1.0.1"
-
-"@trufflesuite/eth-json-rpc-infura@^4.0.3-0":
-  version "4.0.3-0"
-  resolved "https://registry.yarnpkg.com/@trufflesuite/eth-json-rpc-infura/-/eth-json-rpc-infura-4.0.3-0.tgz#6d22122937cf60ec9d21a02351c101fdc608c4fe"
-  integrity sha512-xaUanOmo0YLqRsL0SfXpFienhdw5bpQ1WEXxMTRi57az4lwpZBv4tFUDvcerdwJrxX9wQqNmgUgd1BrR01dumw==
-  dependencies:
-    "@trufflesuite/eth-json-rpc-middleware" "^4.4.2-1"
-    cross-fetch "^2.1.1"
-    eth-json-rpc-errors "^1.0.1"
-    json-rpc-engine "^5.1.3"
-
-"@trufflesuite/eth-json-rpc-middleware@^4.4.2-0", "@trufflesuite/eth-json-rpc-middleware@^4.4.2-1":
-  version "4.4.2-1"
-  resolved "https://registry.yarnpkg.com/@trufflesuite/eth-json-rpc-middleware/-/eth-json-rpc-middleware-4.4.2-1.tgz#8c3638ed8a7ed89a1e5e71407de068a65bef0df2"
-  integrity sha512-iEy9H8ja7/8aYES5HfrepGBKU9n/Y4OabBJEklVd/zIBlhCCBAWBqkIZgXt11nBXO/rYAeKwYuE3puH3ByYnLA==
-  dependencies:
-    "@trufflesuite/eth-sig-util" "^1.4.2"
-    btoa "^1.2.1"
-    clone "^2.1.1"
-    eth-json-rpc-errors "^1.0.1"
-    eth-query "^2.1.2"
-    ethereumjs-block "^1.6.0"
-    ethereumjs-tx "^1.3.7"
-    ethereumjs-util "^5.1.2"
-    ethereumjs-vm "^2.6.0"
-    fetch-ponyfill "^4.0.0"
-    json-rpc-engine "^5.1.3"
-    json-stable-stringify "^1.0.1"
-    pify "^3.0.0"
-    safe-event-emitter "^1.0.1"
-
-"@trufflesuite/eth-sig-util@^1.4.2":
-  version "1.4.2"
-  resolved "https://registry.yarnpkg.com/@trufflesuite/eth-sig-util/-/eth-sig-util-1.4.2.tgz#b529e2f38ac08e652116f48981132a26242a4f08"
-  integrity sha512-+GyfN6b0LNW77hbQlH3ufZ/1eCON7mMrGym6tdYf7xiNw9Vv3jBO72bmmos1EId2NgBvPMhmYYm6DSLQFTmzrA==
-  dependencies:
-    ethereumjs-abi "^0.6.8"
-    ethereumjs-util "^5.1.1"
-
-"@trufflesuite/web3-provider-engine@15.0.13-1":
-  version "15.0.13-1"
-  resolved "https://registry.yarnpkg.com/@trufflesuite/web3-provider-engine/-/web3-provider-engine-15.0.13-1.tgz#f6a7f7131a2fdc4ab53976318ed13ce83e8e4bcb"
-  integrity sha512-6u3x/iIN5fyj8pib5QTUDmIOUiwAGhaqdSTXdqCu6v9zo2BEwdCqgEJd1uXDh3DBmPRDfiZ/ge8oUPy7LerpHg==
-  dependencies:
-    "@trufflesuite/eth-json-rpc-filters" "^4.1.2-1"
-    "@trufflesuite/eth-json-rpc-infura" "^4.0.3-0"
-    "@trufflesuite/eth-json-rpc-middleware" "^4.4.2-1"
-    "@trufflesuite/eth-sig-util" "^1.4.2"
-    async "^2.5.0"
-    backoff "^2.5.0"
-    clone "^2.0.0"
-    cross-fetch "^2.1.0"
-    eth-block-tracker "^4.4.2"
-    eth-json-rpc-errors "^2.0.2"
-    ethereumjs-block "^1.2.2"
-    ethereumjs-tx "^1.2.0"
-    ethereumjs-util "^5.1.5"
-    ethereumjs-vm "^2.3.4"
-    json-stable-stringify "^1.0.1"
-    promise-to-callback "^1.0.0"
-    readable-stream "^2.2.9"
-    request "^2.85.0"
-    semaphore "^1.0.3"
-    ws "^5.1.1"
-    xhr "^2.2.0"
-    xtend "^4.0.1"
-
-"@tsconfig/node10@^1.0.7":
-  version "1.0.9"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.9.tgz#df4907fc07a886922637b15e02d4cebc4c0021b2"
-  integrity sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==
-
-"@tsconfig/node12@^1.0.7":
-  version "1.0.11"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node12/-/node12-1.0.11.tgz#ee3def1f27d9ed66dac6e46a295cffb0152e058d"
-  integrity sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==
-
-"@tsconfig/node14@^1.0.0":
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node14/-/node14-1.0.3.tgz#e4386316284f00b98435bf40f72f75a09dabf6c1"
-  integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==
-
-"@tsconfig/node16@^1.0.2":
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.4.tgz#0b92dcc0cc1c81f6f306a381f28e31b1a56536e9"
-  integrity sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==
-
-"@types/accepts@*", "@types/accepts@^1.3.5":
-  version "1.3.5"
-  resolved "https://registry.yarnpkg.com/@types/accepts/-/accepts-1.3.5.tgz#c34bec115cfc746e04fe5a059df4ce7e7b391575"
-  integrity sha512-jOdnI/3qTpHABjM5cx1Hc0sKsPoYCp+DP/GJRGtDlPd7fiV9oXGGIcjW/ZOxLIvjGz8MA+uMZI9metHlgqbgwQ==
-  dependencies:
-    "@types/node" "*"
-
-"@types/bn.js@^4.11.3", "@types/bn.js@^4.11.4", "@types/bn.js@^4.11.5":
-  version "4.11.6"
-  resolved "https://registry.yarnpkg.com/@types/bn.js/-/bn.js-4.11.6.tgz#c306c70d9358aaea33cd4eda092a742b9505967c"
-  integrity sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==
-  dependencies:
-    "@types/node" "*"
-
-"@types/bn.js@^5.1.0":
-  version "5.1.0"
-  resolved "https://registry.yarnpkg.com/@types/bn.js/-/bn.js-5.1.0.tgz#32c5d271503a12653c62cf4d2b45e6eab8cebc68"
-  integrity sha512-QSSVYj7pYFN49kW77o2s9xTCwZ8F2xLbjLLSEVh8D2F4JUhZtPAGOFLTD+ffqksBx/u4cE/KImFjyhqCjn/LIA==
-  dependencies:
-    "@types/node" "*"
-
-"@types/body-parser@*":
-  version "1.19.1"
-  resolved "https://registry.yarnpkg.com/@types/body-parser/-/body-parser-1.19.1.tgz#0c0174c42a7d017b818303d4b5d969cb0b75929c"
-  integrity sha512-a6bTJ21vFOGIkwM0kzh9Yr89ziVxq4vYH2fQ6N8AeipEzai/cFK6aGMArIkUeIdRIgpwQa+2bXiLuUJCpSf2Cg==
-  dependencies:
-    "@types/connect" "*"
-    "@types/node" "*"
-
-"@types/body-parser@1.19.0":
-  version "1.19.0"
-  resolved "https://registry.yarnpkg.com/@types/body-parser/-/body-parser-1.19.0.tgz#0685b3c47eb3006ffed117cdd55164b61f80538f"
-  integrity sha512-W98JrE0j2K78swW4ukqMleo8R7h/pFETjM2DQ90MF6XK2i4LO4W3gQ71Lt4w3bfm2EvVSyWHplECvB5sK22yFQ==
-  dependencies:
-    "@types/connect" "*"
-    "@types/node" "*"
-
-"@types/cli-progress@^3.11.0":
-  version "3.11.0"
-  resolved "https://registry.yarnpkg.com/@types/cli-progress/-/cli-progress-3.11.0.tgz#ec79df99b26757c3d1c7170af8422e0fc95eef7e"
-  integrity sha512-XhXhBv1R/q2ahF3BM7qT5HLzJNlIL0wbcGyZVjqOTqAybAnsLisd7gy1UCyIqpL+5Iv6XhlSyzjLCnI2sIdbCg==
-  dependencies:
-    "@types/node" "*"
-
-"@types/concat-stream@^1.6.0":
-  version "1.6.1"
-  resolved "https://registry.yarnpkg.com/@types/concat-stream/-/concat-stream-1.6.1.tgz#24bcfc101ecf68e886aaedce60dfd74b632a1b74"
-  integrity sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==
-  dependencies:
-    "@types/node" "*"
-
-"@types/connect@*", "@types/connect@^3.4.33":
-  version "3.4.35"
-  resolved "https://registry.yarnpkg.com/@types/connect/-/connect-3.4.35.tgz#5fcf6ae445e4021d1fc2219a4873cc73a3bb2ad1"
-  integrity sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ==
-  dependencies:
-    "@types/node" "*"
-
-"@types/content-disposition@*":
-  version "0.5.4"
-  resolved "https://registry.yarnpkg.com/@types/content-disposition/-/content-disposition-0.5.4.tgz#de48cf01c79c9f1560bcfd8ae43217ab028657f8"
-  integrity sha512-0mPF08jn9zYI0n0Q/Pnz7C4kThdSt+6LD4amsrYDDpgBfrVWa3TcCOxKX1zkGgYniGagRv8heN2cbh+CAn+uuQ==
-
-"@types/cookies@*":
-  version "0.7.7"
-  resolved "https://registry.yarnpkg.com/@types/cookies/-/cookies-0.7.7.tgz#7a92453d1d16389c05a5301eef566f34946cfd81"
-  integrity sha512-h7BcvPUogWbKCzBR2lY4oqaZbO3jXZksexYJVFvkrFeLgbZjQkU4x8pRq6eg2MHXQhY0McQdqmmsxRWlVAHooA==
-  dependencies:
-    "@types/connect" "*"
-    "@types/express" "*"
-    "@types/keygrip" "*"
-    "@types/node" "*"
-
-"@types/cors@2.8.10":
-  version "2.8.10"
-  resolved "https://registry.yarnpkg.com/@types/cors/-/cors-2.8.10.tgz#61cc8469849e5bcdd0c7044122265c39cec10cf4"
-  integrity sha512-C7srjHiVG3Ey1nR6d511dtDkCEjxuN9W1HWAEjGq8kpcwmNM6JJkpC0xvabM7BXTG2wDq8Eu33iH9aQKa7IvLQ==
-
-"@types/express-serve-static-core@^4.17.18", "@types/express-serve-static-core@^4.17.21":
-  version "4.17.24"
-  resolved "https://registry.yarnpkg.com/@types/express-serve-static-core/-/express-serve-static-core-4.17.24.tgz#ea41f93bf7e0d59cd5a76665068ed6aab6815c07"
-  integrity sha512-3UJuW+Qxhzwjq3xhwXm2onQcFHn76frIYVbTu+kn24LFxI+dEhdfISDFovPB8VpEgW8oQCTpRuCe+0zJxB7NEA==
-  dependencies:
-    "@types/node" "*"
-    "@types/qs" "*"
-    "@types/range-parser" "*"
-
-"@types/express@*", "@types/express@^4.17.12":
-  version "4.17.13"
-  resolved "https://registry.yarnpkg.com/@types/express/-/express-4.17.13.tgz#a76e2995728999bab51a33fabce1d705a3709034"
-  integrity sha512-6bSZTPaTIACxn48l50SR+axgrqm6qXFIxrdAKaG6PaJk3+zuUr35hBlgT7vOmJcum+OEaIBLtHV/qloEAFITeA==
-  dependencies:
-    "@types/body-parser" "*"
-    "@types/express-serve-static-core" "^4.17.18"
-    "@types/qs" "*"
-    "@types/serve-static" "*"
-
-"@types/form-data@0.0.33":
-  version "0.0.33"
-  resolved "https://registry.yarnpkg.com/@types/form-data/-/form-data-0.0.33.tgz#c9ac85b2a5fd18435b8c85d9ecb50e6d6c893ff8"
-  integrity sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw==
-  dependencies:
-    "@types/node" "*"
-
-"@types/fs-capacitor@*":
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/@types/fs-capacitor/-/fs-capacitor-2.0.0.tgz#17113e25817f584f58100fb7a08eed288b81956e"
-  integrity sha512-FKVPOCFbhCvZxpVAMhdBdTfVfXUpsh15wFHgqOKxh9N9vzWZVuWCSijZ5T4U34XYNnuj2oduh6xcs1i+LPI+BQ==
-  dependencies:
-    "@types/node" "*"
-
-"@types/http-assert@*":
-  version "1.5.3"
-  resolved "https://registry.yarnpkg.com/@types/http-assert/-/http-assert-1.5.3.tgz#ef8e3d1a8d46c387f04ab0f2e8ab8cb0c5078661"
-  integrity sha512-FyAOrDuQmBi8/or3ns4rwPno7/9tJTijVW6aQQjK02+kOQ8zmoNg2XJtAuQhvQcy1ASJq38wirX5//9J1EqoUA==
-
-"@types/http-errors@*":
-  version "1.8.1"
-  resolved "https://registry.yarnpkg.com/@types/http-errors/-/http-errors-1.8.1.tgz#e81ad28a60bee0328c6d2384e029aec626f1ae67"
-  integrity sha512-e+2rjEwK6KDaNOm5Aa9wNGgyS9oSZU/4pfSMMPYNOfjvFI0WVXm29+ITRFr6aKDvvKo7uU1jV68MW4ScsfDi7Q==
-
-"@types/keygrip@*":
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/@types/keygrip/-/keygrip-1.0.2.tgz#513abfd256d7ad0bf1ee1873606317b33b1b2a72"
-  integrity sha512-GJhpTepz2udxGexqos8wgaBx4I/zWIDPh/KOGEwAqtuGDkOUJu5eFvwmdBX4AmB8Odsr+9pHCQqiAqDL/yKMKw==
-
-"@types/koa-compose@*":
-  version "3.2.5"
-  resolved "https://registry.yarnpkg.com/@types/koa-compose/-/koa-compose-3.2.5.tgz#85eb2e80ac50be95f37ccf8c407c09bbe3468e9d"
-  integrity sha512-B8nG/OoE1ORZqCkBVsup/AKcvjdgoHnfi4pZMn5UwAPCbhk/96xyv284eBYW8JlQbQ7zDmnpFr68I/40mFoIBQ==
-  dependencies:
-    "@types/koa" "*"
-
-"@types/koa@*":
-  version "2.13.4"
-  resolved "https://registry.yarnpkg.com/@types/koa/-/koa-2.13.4.tgz#10620b3f24a8027ef5cbae88b393d1b31205726b"
-  integrity sha512-dfHYMfU+z/vKtQB7NUrthdAEiSvnLebvBjwHtfFmpZmB7em2N3WVQdHgnFq+xvyVgxW5jKDmjWfLD3lw4g4uTw==
-  dependencies:
-    "@types/accepts" "*"
-    "@types/content-disposition" "*"
-    "@types/cookies" "*"
-    "@types/http-assert" "*"
-    "@types/http-errors" "*"
-    "@types/keygrip" "*"
-    "@types/koa-compose" "*"
-    "@types/node" "*"
-
-"@types/long@^4.0.0":
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.1.tgz#459c65fa1867dafe6a8f322c4c51695663cc55e9"
-  integrity sha512-5tXH6Bx/kNGd3MgffdmP4dy2Z+G4eaXw0SE81Tq3BNadtnMR5/ySMzX4SLEzHJzSmPNn4HIdpQsBvXMUykr58w==
-
-"@types/long@^4.0.1":
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.2.tgz#b74129719fc8d11c01868010082d483b7545591a"
-  integrity sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==
-
-"@types/mime@^1":
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/@types/mime/-/mime-1.3.2.tgz#93e25bf9ee75fe0fd80b594bc4feb0e862111b5a"
-  integrity sha512-YATxVxgRqNH6nHEIsvg6k2Boc1JHI9ZbH5iWFFv/MTkchz3b1ieGDa5T0a9RznNdI0KhVbdbWSN+KWWrQZRxTw==
-
-"@types/minimatch@^3.0.4":
-  version "3.0.5"
-  resolved "https://registry.yarnpkg.com/@types/minimatch/-/minimatch-3.0.5.tgz#1001cc5e6a3704b83c236027e77f2f58ea010f40"
-  integrity sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ==
-
-"@types/node@*":
-  version "18.7.11"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-18.7.11.tgz#486e72cfccde88da24e1f23ff1b7d8bfb64e6250"
-  integrity sha512-KZhFpSLlmK/sdocfSAjqPETTMd0ug6HIMIAwkwUpU79olnZdQtMxpQP+G1wDzCH7na+FltSIhbaZuKdwZ8RDrw==
-
-"@types/node@>=13.7.0":
-  version "20.2.3"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-20.2.3.tgz#b31eb300610c3835ac008d690de6f87e28f9b878"
-  integrity sha512-pg9d0yC4rVNWQzX8U7xb4olIOFuuVL9za3bzMT2pu2SU0SNEi66i2qrvhE2qt0HvkhuCaWJu7pLNOt/Pj8BIrw==
-
-"@types/node@^10.0.3", "@types/node@^10.1.0":
-  version "10.17.60"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-10.17.60.tgz#35f3d6213daed95da7f0f73e75bcc6980e90597b"
-  integrity sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==
-
-"@types/node@^10.12.18":
-  version "10.17.55"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-10.17.55.tgz#a147f282edec679b894d4694edb5abeb595fecbd"
-  integrity sha512-koZJ89uLZufDvToeWO5BrC4CR4OUfHnUz2qoPs/daQH6qq3IN62QFxCTZ+bKaCE0xaoCAJYE4AXre8AbghCrhg==
-
-"@types/node@^12.12.54":
-  version "12.20.55"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-12.20.55.tgz#c329cbd434c42164f846b909bd6f85b5537f6240"
-  integrity sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==
-
-"@types/node@^12.12.6", "@types/node@^12.6.1":
-  version "12.20.4"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-12.20.4.tgz#73687043dd00fcb6962c60fbf499553a24d6bdf2"
-  integrity sha512-xRCgeE0Q4pT5UZ189TJ3SpYuX/QGl6QIAOAIeDSbAVAd2gX1NxSZup4jNVK7cxIeP8KDSbJgcckun495isP1jQ==
-
-"@types/node@^8.0.0":
-  version "8.10.66"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-8.10.66.tgz#dd035d409df322acc83dff62a602f12a5783bbb3"
-  integrity sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw==
-
-"@types/parse-json@^4.0.0":
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/@types/parse-json/-/parse-json-4.0.0.tgz#2f8bb441434d163b35fb8ffdccd7138927ffb8c0"
-  integrity sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA==
-
-"@types/pbkdf2@^3.0.0":
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/@types/pbkdf2/-/pbkdf2-3.1.0.tgz#039a0e9b67da0cdc4ee5dab865caa6b267bb66b1"
-  integrity sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ==
-  dependencies:
-    "@types/node" "*"
-
-"@types/qs@*", "@types/qs@^6.2.31":
-  version "6.9.7"
-  resolved "https://registry.yarnpkg.com/@types/qs/-/qs-6.9.7.tgz#63bb7d067db107cc1e457c303bc25d511febf6cb"
-  integrity sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw==
-
-"@types/range-parser@*":
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/@types/range-parser/-/range-parser-1.2.4.tgz#cd667bcfdd025213aafb7ca5915a932590acdcdc"
-  integrity sha512-EEhsLsD6UsDM1yFhAvy0Cjr6VwmpMWqFBCb9w07wVugF7w9nfajxLuVmngTIpgS6svCnm6Vaw+MZhoDCKnOfsw==
-
-"@types/secp256k1@^4.0.1":
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/@types/secp256k1/-/secp256k1-4.0.3.tgz#1b8e55d8e00f08ee7220b4d59a6abe89c37a901c"
-  integrity sha512-Da66lEIFeIz9ltsdMZcpQvmrmmoqrfju8pm1BH8WbYjZSwUgCwXLb9C+9XYogwBITnbsSaMdVPb2ekf7TV+03w==
-  dependencies:
-    "@types/node" "*"
-
-"@types/serve-static@*":
-  version "1.13.10"
-  resolved "https://registry.yarnpkg.com/@types/serve-static/-/serve-static-1.13.10.tgz#f5e0ce8797d2d7cc5ebeda48a52c96c4fa47a8d9"
-  integrity sha512-nCkHGI4w7ZgAdNkrEu0bv+4xNV/XDqW+DydknebMOQwkpDGx8G+HTlj7R7ABI8i8nKxVw0wtKPi1D+lPOkh4YQ==
-  dependencies:
-    "@types/mime" "^1"
-    "@types/node" "*"
-
-"@types/ungap__global-this@^0.3.1":
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/@types/ungap__global-this/-/ungap__global-this-0.3.1.tgz#18ce9f657da556037a29d50604335614ce703f4c"
-  integrity sha512-+/DsiV4CxXl6ZWefwHZDXSe1Slitz21tom38qPCaG0DYCS1NnDPIQDTKcmQ/tvK/edJUKkmuIDBJbmKDiB0r/g==
-
-"@types/websocket@1.0.1":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@types/websocket/-/websocket-1.0.1.tgz#039272c196c2c0e4868a0d8a1a27bbb86e9e9138"
-  integrity sha512-f5WLMpezwVxCLm1xQe/kdPpQIOmL0TXYx2O15VYfYzc7hTIdxiOoOvez+McSIw3b7z/1zGovew9YSL7+h4h7/Q==
-  dependencies:
-    "@types/node" "*"
-
-"@types/ws@^7.0.0", "@types/ws@^7.4.4":
-  version "7.4.7"
-  resolved "https://registry.yarnpkg.com/@types/ws/-/ws-7.4.7.tgz#f7c390a36f7a0679aa69de2d501319f4f8d9b702"
-  integrity sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==
-  dependencies:
-    "@types/node" "*"
-
-"@types/zen-observable@^0.8.0":
-  version "0.8.2"
-  resolved "https://registry.yarnpkg.com/@types/zen-observable/-/zen-observable-0.8.2.tgz#808c9fa7e4517274ed555fa158f2de4b4f468e71"
-  integrity sha512-HrCIVMLjE1MOozVoD86622S7aunluLb2PJdPfb3nYiEtohm8mIB/vyv0Fd37AdeMFrTUQXEunw78YloMA3Qilg==
-
-"@ungap/global-this@^0.4.2":
-  version "0.4.4"
-  resolved "https://registry.yarnpkg.com/@ungap/global-this/-/global-this-0.4.4.tgz#8a1b2cfcd3e26e079a847daba879308c924dd695"
-  integrity sha512-mHkm6FvepJECMNthFuIgpAEFmPOk71UyXuIxYfjytvFTnSDBIz7jmViO+LfHI/AjrazWije0PnSP3+/NlwzqtA==
-
-"@whatwg-node/events@^0.0.3":
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/@whatwg-node/events/-/events-0.0.3.tgz#13a65dd4f5893f55280f766e29ae48074927acad"
-  integrity sha512-IqnKIDWfXBJkvy/k6tzskWTc2NK3LcqHlb+KHGCrjOCH4jfQckRX0NAiIcC/vIqQkzLYw2r2CTSwAxcrtcD6lA==
-
-"@whatwg-node/fetch@^0.8.4":
-  version "0.8.8"
-  resolved "https://registry.yarnpkg.com/@whatwg-node/fetch/-/fetch-0.8.8.tgz#48c6ad0c6b7951a73e812f09dd22d75e9fa18cae"
-  integrity sha512-CdcjGC2vdKhc13KKxgsc6/616BQ7ooDIgPeTuAiE8qfCnS0mGzcfCOoZXypQSz73nxI+GWc7ZReIAVhxoE1KCg==
-  dependencies:
-    "@peculiar/webcrypto" "^1.4.0"
-    "@whatwg-node/node-fetch" "^0.3.6"
-    busboy "^1.6.0"
-    urlpattern-polyfill "^8.0.0"
-    web-streams-polyfill "^3.2.1"
-
-"@whatwg-node/node-fetch@^0.3.6":
-  version "0.3.6"
-  resolved "https://registry.yarnpkg.com/@whatwg-node/node-fetch/-/node-fetch-0.3.6.tgz#e28816955f359916e2d830b68a64493124faa6d0"
-  integrity sha512-w9wKgDO4C95qnXZRwZTfCmLWqyRnooGjcIwG0wADWjw9/HN0p7dtvtgSvItZtUyNteEvgTrd8QojNEqV6DAGTA==
-  dependencies:
-    "@whatwg-node/events" "^0.0.3"
-    busboy "^1.6.0"
-    fast-querystring "^1.1.1"
-    fast-url-parser "^1.1.3"
-    tslib "^2.3.1"
-
-"@wry/context@^0.5.2":
-  version "0.5.4"
-  resolved "https://registry.yarnpkg.com/@wry/context/-/context-0.5.4.tgz#b6c28038872e0a0e1ff14eb40b5bf4cab2ab4e06"
-  integrity sha512-/pktJKHUXDr4D6TJqWgudOPJW2Z+Nb+bqk40jufA3uTkLbnCRKdJPiYDIa/c7mfcPH8Hr6O8zjCERpg5Sq04Zg==
-  dependencies:
-    tslib "^1.14.1"
-
-"@wry/equality@^0.1.2":
-  version "0.1.11"
-  resolved "https://registry.yarnpkg.com/@wry/equality/-/equality-0.1.11.tgz#35cb156e4a96695aa81a9ecc4d03787bc17f1790"
-  integrity sha512-mwEVBDUVODlsQQ5dfuLUS5/Tf7jqUKyhKYHmVi4fPB6bDMOfWvUPJmKgS1Z7Za/sOI3vzWt4+O7yCiL/70MogA==
-  dependencies:
-    tslib "^1.9.3"
-
-"@wry/equality@^0.3.0":
-  version "0.3.4"
-  resolved "https://registry.yarnpkg.com/@wry/equality/-/equality-0.3.4.tgz#37f101552b18a046d5c0c06da7b2021b15f72c03"
-  integrity sha512-1gQQhCPenzxw/1HzLlvSIs/59eBHJf9ZDIussjjZhqNSqQuPKQIzN6SWt4kemvlBPDi7RqMuUa03pId7MAE93g==
-  dependencies:
-    tslib "^1.14.1"
-
-"@wry/trie@^0.2.1":
-  version "0.2.2"
-  resolved "https://registry.yarnpkg.com/@wry/trie/-/trie-0.2.2.tgz#99f20f0fcbbcda17006069b155c826cbabfc402f"
-  integrity sha512-OxqBB39x6MfHaa2HpMiRMfhuUnQTddD32Ko020eBeJXq87ivX6xnSSnzKHVbA21p7iqBASz8n/07b6W5wW1BVQ==
-  dependencies:
-    tslib "^1.14.1"
-
-JSONStream@1.3.2:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.2.tgz#c102371b6ec3a7cf3b847ca00c20bb0fce4c6dea"
-  integrity sha512-mn0KSip7N4e0UDPZHnqDsHECo5uGQrixQKnAskOM1BIB8hd7QKbd6il8IPRPudPHOeHiECoCFqhyMaRO9+nWyA==
-  dependencies:
-    jsonparse "^1.2.0"
-    through ">=2.2.7 <3"
-
-JSONStream@^1.3.5:
-  version "1.3.5"
-  resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0"
-  integrity sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==
-  dependencies:
-    jsonparse "^1.2.0"
-    through ">=2.2.7 <3"
-
-abab@^1.0.0:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/abab/-/abab-1.0.4.tgz#5faad9c2c07f60dd76770f71cf025b62a63cfd4e"
-  integrity sha1-X6rZwsB/YN12dw9xzwJbYqY8/U4=
-
-abbrev@1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
-  integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==
-
-abort-controller@3.0.0, abort-controller@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/abort-controller/-/abort-controller-3.0.0.tgz#eaf54d53b62bae4138e809ca225c8439a6efb392"
-  integrity sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==
-  dependencies:
-    event-target-shim "^5.0.0"
-
-abstract-leveldown@^6.2.1:
-  version "6.3.0"
-  resolved "https://registry.yarnpkg.com/abstract-leveldown/-/abstract-leveldown-6.3.0.tgz#d25221d1e6612f820c35963ba4bd739928f6026a"
-  integrity sha512-TU5nlYgta8YrBMNpc9FwQzRbiXsj49gsALsXadbGHt9CROPzX5fB0rWDR5mtdpOOKa5XqRFpbj1QroPAoPzVjQ==
-  dependencies:
-    buffer "^5.5.0"
-    immediate "^3.2.3"
-    level-concat-iterator "~2.0.0"
-    level-supports "~1.0.0"
-    xtend "~4.0.0"
-
-abstract-leveldown@~2.6.0:
-  version "2.6.3"
-  resolved "https://registry.yarnpkg.com/abstract-leveldown/-/abstract-leveldown-2.6.3.tgz#1c5e8c6a5ef965ae8c35dfb3a8770c476b82c4b8"
-  integrity sha512-2++wDf/DYqkPR3o5tbfdhF96EfMApo1GpPfzOsR/ZYXdkSmELlvOOEAl9iKkRsktMPHdGjO4rtkBpf2I7TiTeA==
-  dependencies:
-    xtend "~4.0.0"
-
-abstract-leveldown@~2.7.1:
-  version "2.7.2"
-  resolved "https://registry.yarnpkg.com/abstract-leveldown/-/abstract-leveldown-2.7.2.tgz#87a44d7ebebc341d59665204834c8b7e0932cc93"
-  integrity sha512-+OVvxH2rHVEhWLdbudP6p0+dNMXu8JA1CbhP19T8paTYAcX7oJ4OVjT+ZUVpv7mITxXHqDMej+GdqXBmXkw09w==
-  dependencies:
-    xtend "~4.0.0"
-
-abstract-leveldown@~6.0.0, abstract-leveldown@~6.0.1:
-  version "6.0.3"
-  resolved "https://registry.yarnpkg.com/abstract-leveldown/-/abstract-leveldown-6.0.3.tgz#b4b6159343c74b0c5197b2817854782d8f748c4a"
-  integrity sha512-jzewKKpZbaYUa6HTThnrl+GrJhzjEAeuc7hTVpZdzg7kupXZFoqQDFwyOwLNbmJKJlmzw8yiipMPkDiuKkT06Q==
-  dependencies:
-    level-concat-iterator "~2.0.0"
-    xtend "~4.0.0"
-
-abstract-leveldown@~6.2.1:
-  version "6.2.3"
-  resolved "https://registry.yarnpkg.com/abstract-leveldown/-/abstract-leveldown-6.2.3.tgz#036543d87e3710f2528e47040bc3261b77a9a8eb"
-  integrity sha512-BsLm5vFMRUrrLeCcRc+G0t2qOaTzpoJQLOubq2XM72eNpjF5UdU5o/5NvlNhx95XHcAvcl8OMXr4mlg/fRgUXQ==
-  dependencies:
-    buffer "^5.5.0"
-    immediate "^3.2.3"
-    level-concat-iterator "~2.0.0"
-    level-supports "~1.0.0"
-    xtend "~4.0.0"
-
-accepts@^1.3.5, accepts@~1.3.8:
-  version "1.3.8"
-  resolved "https://registry.yarnpkg.com/accepts/-/accepts-1.3.8.tgz#0bf0be125b67014adcb0b0921e62db7bffe16b2e"
-  integrity sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==
-  dependencies:
-    mime-types "~2.1.34"
-    negotiator "0.6.3"
-
-acorn-globals@^1.0.4:
-  version "1.0.9"
-  resolved "https://registry.yarnpkg.com/acorn-globals/-/acorn-globals-1.0.9.tgz#55bb5e98691507b74579d0513413217c380c54cf"
-  integrity sha1-VbtemGkVB7dFedBRNBMhfDgMVM8=
-  dependencies:
-    acorn "^2.1.0"
-
-acorn-walk@^8.1.1:
-  version "8.2.0"
-  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1"
-  integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==
-
-acorn@4.X:
-  version "4.0.13"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-4.0.13.tgz#105495ae5361d697bd195c825192e1ad7f253787"
-  integrity sha1-EFSVrlNh1pe9GVyCUZLhrX8lN4c=
-
-acorn@^2.1.0, acorn@^2.4.0:
-  version "2.7.0"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-2.7.0.tgz#ab6e7d9d886aaca8b085bc3312b79a198433f0e7"
-  integrity sha1-q259nYhqrKiwhbwzEreaGYQz8Oc=
-
-acorn@^8.4.1:
-  version "8.8.2"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.8.2.tgz#1b2f25db02af965399b9776b0c2c391276d37c4a"
-  integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==
-
-aes-js@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/aes-js/-/aes-js-3.0.0.tgz#e21df10ad6c2053295bcbb8dab40b09dbea87e4d"
-  integrity sha1-4h3xCtbCBTKVvLuNq0Cwnb6ofk0=
-
-aes-js@^3.1.1:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/aes-js/-/aes-js-3.1.2.tgz#db9aabde85d5caabbfc0d4f2a4446960f627146a"
-  integrity sha512-e5pEa2kBnBOgR4Y/p20pskXI74UEz7de8ZGVo58asOtvSVG5YAbJeELPZxOmt+Bnz3rX753YKhfIn4X4l1PPRQ==
-
-ajv@^6.10.0, ajv@^6.12.3:
-  version "6.12.6"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
-  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
-  dependencies:
-    fast-deep-equal "^3.1.1"
-    fast-json-stable-stringify "^2.0.0"
-    json-schema-traverse "^0.4.1"
-    uri-js "^4.2.2"
-
-ansi-colors@4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348"
-  integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==
-
-ansi-colors@^3.2.1:
-  version "3.2.4"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-3.2.4.tgz#e3a3da4bfbae6c86a9c285625de124a234026fbf"
-  integrity sha512-hHUXGagefjN2iRrID63xckIvotOXOojhQKWIPUZ4mNUZ9nLZW+7FMNoE1lOkEhNWYsx/7ysGIuJYCiMAA9FnrA==
-
-ansi-colors@^4.1.1:
-  version "4.1.3"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.3.tgz#37611340eb2243e70cc604cad35d63270d48781b"
-  integrity sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==
-
-ansi-escapes@^3.1.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-3.2.0.tgz#8780b98ff9dbf5638152d1f1fe5c1d7b4442976b"
-  integrity sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==
-
-ansi-escapes@^4.3.2:
-  version "4.3.2"
-  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e"
-  integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==
-  dependencies:
-    type-fest "^0.21.3"
-
-ansi-mark@^1.0.0:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/ansi-mark/-/ansi-mark-1.0.4.tgz#1cd4ba8d57f15f109d6aaf6ec9ca9786c8a4ee6c"
-  integrity sha1-HNS6jVfxXxCdaq9uycqXhsik7mw=
-  dependencies:
-    ansi-regex "^3.0.0"
-    array-uniq "^1.0.3"
-    chalk "^2.3.2"
-    strip-ansi "^4.0.0"
-    super-split "^1.1.0"
-
-ansi-regex@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
-  integrity sha1-w7M6te42DYbg5ijwRorn7yfWVN8=
-
-ansi-regex@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.1.tgz#123d6479e92ad45ad897d4054e3c7ca7db4944e1"
-  integrity sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==
-
-ansi-regex@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-4.1.0.tgz#8b9f8f08cf1acb843756a839ca8c7e3168c51997"
-  integrity sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==
-
-ansi-regex@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
-  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
-
-ansi-styles@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe"
-  integrity sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=
-
-ansi-styles@^3.2.0, ansi-styles@^3.2.1:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
-  integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
-  dependencies:
-    color-convert "^1.9.0"
-
-ansi-styles@^4.0.0, ansi-styles@^4.1.0, ansi-styles@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
-  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
-  dependencies:
-    color-convert "^2.0.1"
-
-ansicolors@~0.3.2:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/ansicolors/-/ansicolors-0.3.2.tgz#665597de86a9ffe3aa9bfbe6cae5c6ea426b4979"
-  integrity sha512-QXu7BPrP29VllRxH8GwB7x5iX5qWKAAMLqKQGWTeLWVlNHNOpVMJ91dsxQAIWXpjuW5wqvxu3Jd/nRjrJ+0pqg==
-
-any-promise@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/any-promise/-/any-promise-1.3.0.tgz#abc6afeedcea52e809cdc0376aed3ce39635d17f"
-  integrity sha1-q8av7tzqUugJzcA3au0845Y10X8=
-
-any-signal@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/any-signal/-/any-signal-2.1.2.tgz#8d48270de0605f8b218cf9abe8e9c6a0e7418102"
-  integrity sha512-B+rDnWasMi/eWcajPcCWSlYc7muXOrcYrqgyzcdKisl2H/WTlQ0gip1KyQfr0ZlxJdsuWCj/LWwQm7fhyhRfIQ==
-  dependencies:
-    abort-controller "^3.0.0"
-    native-abort-controller "^1.0.3"
-
-any-signal@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/any-signal/-/any-signal-3.0.1.tgz#49cae34368187a3472e31de28fb5cb1430caa9a6"
-  integrity sha512-xgZgJtKEa9YmDqXodIgl7Fl1C8yNXr8w6gXjqK3LW4GcEiYT+6AQfJSE/8SPsEpLLmcvbv8YU+qet94UewHxqg==
-
-anymatch@~3.1.1:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.2.tgz#c0557c096af32f106198f4f4e2a383537e378716"
-  integrity sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==
-  dependencies:
-    normalize-path "^3.0.0"
-    picomatch "^2.0.4"
-
-anymatch@~3.1.2:
-  version "3.1.3"
-  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e"
-  integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
-  dependencies:
-    normalize-path "^3.0.0"
-    picomatch "^2.0.4"
-
-apisauce@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/apisauce/-/apisauce-2.0.1.tgz#cf5af56ea6ff5145e6eeb8d4ba471c7e0662b8c4"
-  integrity sha512-mJBw3pKmtfVoP6oifnf7/iRJQtNkVb6GkYsVOXN2pidootj1mhGBtzYHOX9FVBzAz5QV2GMu8IJtiNIgZ44kHQ==
-  dependencies:
-    axios "^0.21.1"
-    ramda "^0.25.0"
-
-apisauce@^2.1.5:
-  version "2.1.6"
-  resolved "https://registry.yarnpkg.com/apisauce/-/apisauce-2.1.6.tgz#94887f335bf3d735305fc895c8a191c9c2608a7f"
-  integrity sha512-MdxR391op/FucS2YQRfB/NMRyCnHEPDd4h17LRIuVYi0BpGmMhpxc0shbOpfs5ahABuBEffNCGal5EcsydbBWg==
-  dependencies:
-    axios "^0.21.4"
-
-apollo-cache-control@^0.14.0:
-  version "0.14.0"
-  resolved "https://registry.yarnpkg.com/apollo-cache-control/-/apollo-cache-control-0.14.0.tgz#95f20c3e03e7994e0d1bd48c59aeaeb575ed0ce7"
-  integrity sha512-qN4BCq90egQrgNnTRMUHikLZZAprf3gbm8rC5Vwmc6ZdLolQ7bFsa769Hqi6Tq/lS31KLsXBLTOsRbfPHph12w==
-  dependencies:
-    apollo-server-env "^3.1.0"
-    apollo-server-plugin-base "^0.13.0"
-
-apollo-datasource@^0.9.0:
-  version "0.9.0"
-  resolved "https://registry.yarnpkg.com/apollo-datasource/-/apollo-datasource-0.9.0.tgz#b0b2913257a6103a5f4c03cb56d78a30e9d850db"
-  integrity sha512-y8H99NExU1Sk4TvcaUxTdzfq2SZo6uSj5dyh75XSQvbpH6gdAXIW9MaBcvlNC7n0cVPsidHmOcHOWxJ/pTXGjA==
-  dependencies:
-    apollo-server-caching "^0.7.0"
-    apollo-server-env "^3.1.0"
-
-apollo-fetch@^0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/apollo-fetch/-/apollo-fetch-0.7.0.tgz#63c255a0ccb1b4c473524d8f9b536d72438bd3e7"
-  integrity sha512-0oHsDW3Zxx+Of1wuqcOXruNj4Kv55WN69tkIjwkCQDEIrgCpgA2scjChFsgflSVMy/1mkTKCY1Mc0TYJhNRzmw==
-  dependencies:
-    cross-fetch "^1.0.0"
-
-apollo-graphql@^0.9.0:
-  version "0.9.5"
-  resolved "https://registry.yarnpkg.com/apollo-graphql/-/apollo-graphql-0.9.5.tgz#9113483ca7f7fa49ee9e9a299c45d30b1cf3bf61"
-  integrity sha512-RGt5k2JeBqrmnwRM0VOgWFiGKlGJMfmiif/4JvdaEqhMJ+xqe/9cfDYzXfn33ke2eWixsAbjEbRfy8XbaN9nTw==
-  dependencies:
-    core-js-pure "^3.10.2"
-    lodash.sortby "^4.7.0"
-    sha.js "^2.4.11"
-
-apollo-link@1.2.14, apollo-link@^1.2.14:
-  version "1.2.14"
-  resolved "https://registry.yarnpkg.com/apollo-link/-/apollo-link-1.2.14.tgz#3feda4b47f9ebba7f4160bef8b977ba725b684d9"
-  integrity sha512-p67CMEFP7kOG1JZ0ZkYZwRDa369w5PIjtMjvrQd/HnIV8FRsHRqLqK+oAZQnFa1DDdZtOtHTi+aMIW6EatC2jg==
-  dependencies:
-    apollo-utilities "^1.3.0"
-    ts-invariant "^0.4.0"
-    tslib "^1.9.3"
-    zen-observable-ts "^0.8.21"
-
-apollo-reporting-protobuf@^0.8.0:
-  version "0.8.0"
-  resolved "https://registry.yarnpkg.com/apollo-reporting-protobuf/-/apollo-reporting-protobuf-0.8.0.tgz#ae9d967934d3d8ed816fc85a0d8068ef45c371b9"
-  integrity sha512-B3XmnkH6Y458iV6OsA7AhfwvTgeZnFq9nPVjbxmLKnvfkEl8hYADtz724uPa0WeBiD7DSFcnLtqg9yGmCkBohg==
-  dependencies:
-    "@apollo/protobufjs" "1.2.2"
-
-apollo-server-caching@^0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/apollo-server-caching/-/apollo-server-caching-0.7.0.tgz#e6d1e68e3bb571cba63a61f60b434fb771c6ff39"
-  integrity sha512-MsVCuf/2FxuTFVhGLK13B+TZH9tBd2qkyoXKKILIiGcZ5CDUEBO14vIV63aNkMkS1xxvK2U4wBcuuNj/VH2Mkw==
-  dependencies:
-    lru-cache "^6.0.0"
-
-apollo-server-core@^2.25.3:
-  version "2.25.3"
-  resolved "https://registry.yarnpkg.com/apollo-server-core/-/apollo-server-core-2.25.3.tgz#1a649fd14b3928f5b6e65f0002b380fcfde56862"
-  integrity sha512-Midow3uZoJ9TjFNeCNSiWElTVZlvmB7G7tG6PPoxIR9Px90/v16Q6EzunDIO0rTJHRC3+yCwZkwtf8w2AcP0sA==
-  dependencies:
-    "@apollographql/apollo-tools" "^0.5.0"
-    "@apollographql/graphql-playground-html" "1.6.27"
-    "@apollographql/graphql-upload-8-fork" "^8.1.3"
-    "@josephg/resolvable" "^1.0.0"
-    "@types/ws" "^7.0.0"
-    apollo-cache-control "^0.14.0"
-    apollo-datasource "^0.9.0"
-    apollo-graphql "^0.9.0"
-    apollo-reporting-protobuf "^0.8.0"
-    apollo-server-caching "^0.7.0"
-    apollo-server-env "^3.1.0"
-    apollo-server-errors "^2.5.0"
-    apollo-server-plugin-base "^0.13.0"
-    apollo-server-types "^0.9.0"
-    apollo-tracing "^0.15.0"
-    async-retry "^1.2.1"
-    fast-json-stable-stringify "^2.0.0"
-    graphql-extensions "^0.15.0"
-    graphql-tag "^2.11.0"
-    graphql-tools "^4.0.8"
-    loglevel "^1.6.7"
-    lru-cache "^6.0.0"
-    sha.js "^2.4.11"
-    subscriptions-transport-ws "^0.9.19"
-    uuid "^8.0.0"
-
-apollo-server-env@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/apollo-server-env/-/apollo-server-env-3.1.0.tgz#0733c2ef50aea596cc90cf40a53f6ea2ad402cd0"
-  integrity sha512-iGdZgEOAuVop3vb0F2J3+kaBVi4caMoxefHosxmgzAbbSpvWehB8Y1QiSyyMeouYC38XNVk5wnZl+jdGSsWsIQ==
-  dependencies:
-    node-fetch "^2.6.1"
-    util.promisify "^1.0.0"
-
-apollo-server-errors@^2.5.0:
-  version "2.5.0"
-  resolved "https://registry.yarnpkg.com/apollo-server-errors/-/apollo-server-errors-2.5.0.tgz#5d1024117c7496a2979e3e34908b5685fe112b68"
-  integrity sha512-lO5oTjgiC3vlVg2RKr3RiXIIQ5pGXBFxYGGUkKDhTud3jMIhs+gel8L8zsEjKaKxkjHhCQAA/bcEfYiKkGQIvA==
-
-apollo-server-express@^2.25.3:
-  version "2.25.3"
-  resolved "https://registry.yarnpkg.com/apollo-server-express/-/apollo-server-express-2.25.3.tgz#33fe0dae27fa71c8710e714efd93451bf2eb105f"
-  integrity sha512-tTFYn0oKH2qqLwVj7Ez2+MiKleXACODiGh5IxsB7VuYCPMAi9Yl8iUSlwTjQUvgCWfReZjnf0vFL2k5YhDlrtQ==
-  dependencies:
-    "@apollographql/graphql-playground-html" "1.6.27"
-    "@types/accepts" "^1.3.5"
-    "@types/body-parser" "1.19.0"
-    "@types/cors" "2.8.10"
-    "@types/express" "^4.17.12"
-    "@types/express-serve-static-core" "^4.17.21"
-    accepts "^1.3.5"
-    apollo-server-core "^2.25.3"
-    apollo-server-types "^0.9.0"
-    body-parser "^1.18.3"
-    cors "^2.8.5"
-    express "^4.17.1"
-    graphql-subscriptions "^1.0.0"
-    graphql-tools "^4.0.8"
-    parseurl "^1.3.2"
-    subscriptions-transport-ws "^0.9.19"
-    type-is "^1.6.16"
-
-apollo-server-plugin-base@^0.13.0:
-  version "0.13.0"
-  resolved "https://registry.yarnpkg.com/apollo-server-plugin-base/-/apollo-server-plugin-base-0.13.0.tgz#3f85751a420d3c4625355b6cb3fbdd2acbe71f13"
-  integrity sha512-L3TMmq2YE6BU6I4Tmgygmd0W55L+6XfD9137k+cWEBFu50vRY4Re+d+fL5WuPkk5xSPKd/PIaqzidu5V/zz8Kg==
-  dependencies:
-    apollo-server-types "^0.9.0"
-
-apollo-server-types@^0.9.0:
-  version "0.9.0"
-  resolved "https://registry.yarnpkg.com/apollo-server-types/-/apollo-server-types-0.9.0.tgz#ccf550b33b07c48c72f104fbe2876232b404848b"
-  integrity sha512-qk9tg4Imwpk732JJHBkhW0jzfG0nFsLqK2DY6UhvJf7jLnRePYsPxWfPiNkxni27pLE2tiNlCwoDFSeWqpZyBg==
-  dependencies:
-    apollo-reporting-protobuf "^0.8.0"
-    apollo-server-caching "^0.7.0"
-    apollo-server-env "^3.1.0"
-
-apollo-server@^2.18.2:
-  version "2.25.3"
-  resolved "https://registry.yarnpkg.com/apollo-server/-/apollo-server-2.25.3.tgz#2e5db9ce5217389625ac5014551dcbdeeedcd1d8"
-  integrity sha512-+eUY2//DLkU7RkJLn6CTl1P89/ZMHuUQnWqv8La2iJ2hLT7Me+nMx+hgHl3LqlT/qDstQ8qA45T85FuCayplmQ==
-  dependencies:
-    apollo-server-core "^2.25.3"
-    apollo-server-express "^2.25.3"
-    express "^4.0.0"
-    graphql-subscriptions "^1.0.0"
-    graphql-tools "^4.0.8"
-    stoppable "^1.1.0"
-
-apollo-tracing@^0.15.0:
-  version "0.15.0"
-  resolved "https://registry.yarnpkg.com/apollo-tracing/-/apollo-tracing-0.15.0.tgz#237fbbbf669aee4370b7e9081b685eabaa8ce84a"
-  integrity sha512-UP0fztFvaZPHDhIB/J+qGuy6hWO4If069MGC98qVs0I8FICIGu4/8ykpX3X3K6RtaQ56EDAWKykCxFv4ScxMeA==
-  dependencies:
-    apollo-server-env "^3.1.0"
-    apollo-server-plugin-base "^0.13.0"
-
-apollo-upload-client@14.1.2:
-  version "14.1.2"
-  resolved "https://registry.yarnpkg.com/apollo-upload-client/-/apollo-upload-client-14.1.2.tgz#7a72b000f1cd67eaf8f12b4bda2796d0898c0dae"
-  integrity sha512-ozaW+4tnVz1rpfwiQwG3RCdCcZ93RV/37ZQbRnObcQ9mjb+zur58sGDPVg9Ef3fiujLmiE/Fe9kdgvIMA3VOjA==
-  dependencies:
-    "@apollo/client" "^3.1.5"
-    "@babel/runtime" "^7.11.2"
-    extract-files "^9.0.0"
-
-apollo-utilities@^1.0.1, apollo-utilities@^1.3.0:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/apollo-utilities/-/apollo-utilities-1.3.4.tgz#6129e438e8be201b6c55b0f13ce49d2c7175c9cf"
-  integrity sha512-pk2hiWrCXMAy2fRPwEyhvka+mqwzeP60Jr1tRYi5xru+3ko94HI9o6lK0CT33/w4RDlxWchmdhDCrvdr+pHCig==
-  dependencies:
-    "@wry/equality" "^0.1.2"
-    fast-json-stable-stringify "^2.0.0"
-    ts-invariant "^0.4.0"
-    tslib "^1.10.0"
-
-app-module-path@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/app-module-path/-/app-module-path-2.2.0.tgz#641aa55dfb7d6a6f0a8141c4b9c0aa50b6c24dd5"
-  integrity sha512-gkco+qxENJV+8vFcDiiFhuoSvRXb2a/QPqpSoWhVz829VNJfOTnELbBmPmNKFxf3xdNnw4DWCkzkDaavcX/1YQ==
-
-aproba@^1.0.3:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/aproba/-/aproba-1.2.0.tgz#6802e6264efd18c790a1b0d517f0f2627bf2c94a"
-  integrity sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==
-
-are-we-there-yet@~1.1.2:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/are-we-there-yet/-/are-we-there-yet-1.1.5.tgz#4b35c2944f062a8bfcda66410760350fe9ddfc21"
-  integrity sha512-5hYdAkZlcG8tOLujVDTgCT+uPX0VnpAH28gWsLfzpXYm7wP6mp5Q/gYyR7YQ0cKVJcXJnl3j2kpBan13PtQf6w==
-  dependencies:
-    delegates "^1.0.0"
-    readable-stream "^2.0.6"
-
-arg@^4.1.0:
-  version "4.1.3"
-  resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
-  integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
-
-argparse@^1.0.7:
-  version "1.0.10"
-  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
-  integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
-  dependencies:
-    sprintf-js "~1.0.2"
-
-argparse@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
-  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
-
-argsarray@0.0.1, argsarray@^0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/argsarray/-/argsarray-0.0.1.tgz#6e7207b4ecdb39b0af88303fa5ae22bda8df61cb"
-  integrity sha1-bnIHtOzbObCviDA/pa4ivajfYcs=
-
-arr-diff@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-2.0.0.tgz#8f3b827f955a8bd669697e4a4256ac3ceae356cf"
-  integrity sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=
-  dependencies:
-    arr-flatten "^1.0.1"
-
-arr-flatten@^1.0.1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1"
-  integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==
-
-array-filter@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/array-filter/-/array-filter-1.0.0.tgz#baf79e62e6ef4c2a4c0b831232daffec251f9d83"
-  integrity sha1-uveeYubvTCpMC4MSMtr/7CUfnYM=
-
-array-flatten@1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/array-flatten/-/array-flatten-1.1.1.tgz#9a5f699051b1e7073328f2a008968b64ea2955d2"
-  integrity sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==
-
-array-union@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
-  integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
-
-array-uniq@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6"
-  integrity sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=
-
-array-unique@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.2.1.tgz#a1d97ccafcbc2625cc70fadceb36a50c58b01a53"
-  integrity sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=
-
-array.prototype.map@^1.0.1:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/array.prototype.map/-/array.prototype.map-1.0.3.tgz#1609623618d3d84134a37d4a220030c2bd18420b"
-  integrity sha512-nNcb30v0wfDyIe26Yif3PcV1JXQp4zEeEfupG7L4SRjnD6HLbO5b2a7eVSba53bOx4YCHYMBHt+Fp4vYstneRA==
-  dependencies:
-    call-bind "^1.0.0"
-    define-properties "^1.1.3"
-    es-abstract "^1.18.0-next.1"
-    es-array-method-boxes-properly "^1.0.0"
-    is-string "^1.0.5"
-
-asap@~2.0.3, asap@~2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/asap/-/asap-2.0.6.tgz#e50347611d7e690943208bbdafebcbc2fb866d46"
-  integrity sha1-5QNHYR1+aQlDIIu9r+vLwvuGbUY=
-
-asn1.js@^5.2.0:
-  version "5.4.1"
-  resolved "https://registry.yarnpkg.com/asn1.js/-/asn1.js-5.4.1.tgz#11a980b84ebb91781ce35b0fdc2ee294e3783f07"
-  integrity sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==
-  dependencies:
-    bn.js "^4.0.0"
-    inherits "^2.0.1"
-    minimalistic-assert "^1.0.0"
-    safer-buffer "^2.1.0"
-
-asn1@~0.2.3:
-  version "0.2.6"
-  resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.6.tgz#0d3a7bb6e64e02a90c0303b31f292868ea09a08d"
-  integrity sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==
-  dependencies:
-    safer-buffer "~2.1.0"
-
-asn1js@^3.0.1, asn1js@^3.0.5:
-  version "3.0.5"
-  resolved "https://registry.yarnpkg.com/asn1js/-/asn1js-3.0.5.tgz#5ea36820443dbefb51cc7f88a2ebb5b462114f38"
-  integrity sha512-FVnvrKJwpt9LP2lAMl8qZswRNm3T4q9CON+bxldk2iwk3FFpuwhx2FfinyitizWHsVYyaY+y5JzDR0rCMV5yTQ==
-  dependencies:
-    pvtsutils "^1.3.2"
-    pvutils "^1.1.3"
-    tslib "^2.4.0"
-
-assemblyscript@0.19.10:
-  version "0.19.10"
-  resolved "https://registry.yarnpkg.com/assemblyscript/-/assemblyscript-0.19.10.tgz#7ede6d99c797a219beb4fa4614c3eab9e6343c8e"
-  integrity sha512-HavcUBXB3mBTRGJcpvaQjmnmaqKHBGREjSPNsIvnAk2f9dj78y4BkMaSSdvBQYWcDDzsHQjyUC8stICFkD1Odg==
-  dependencies:
-    binaryen "101.0.0-nightly.20210723"
-    long "^4.0.0"
-
-assemblyscript@0.19.23:
-  version "0.19.23"
-  resolved "https://registry.yarnpkg.com/assemblyscript/-/assemblyscript-0.19.23.tgz#16ece69f7f302161e2e736a0f6a474e6db72134c"
-  integrity sha512-fwOQNZVTMga5KRsfY80g7cpOl4PsFQczMwHzdtgoqLXaYhkhavufKb0sB0l3T1DUxpAufA0KNhlbpuuhZUwxMA==
-  dependencies:
-    binaryen "102.0.0-nightly.20211028"
-    long "^5.2.0"
-    source-map-support "^0.5.20"
-
-assert-plus@1.0.0, assert-plus@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
-  integrity sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==
-
-astral-regex@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31"
-  integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==
-
-async-eventemitter@^0.2.2:
-  version "0.2.4"
-  resolved "https://registry.yarnpkg.com/async-eventemitter/-/async-eventemitter-0.2.4.tgz#f5e7c8ca7d3e46aab9ec40a292baf686a0bafaca"
-  integrity sha512-pd20BwL7Yt1zwDFy+8MX8F1+WCT8aQeKj0kQnTrH9WaeRETlRamVhD0JtRPmrV4GfOJ2F9CvdQkZeZhnh2TuHw==
-  dependencies:
-    async "^2.4.0"
-
-async-limiter@^1.0.0, async-limiter@~1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/async-limiter/-/async-limiter-1.0.1.tgz#dd379e94f0db8310b08291f9d64c3209766617fd"
-  integrity sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==
-
-async-retry@^1.2.1:
-  version "1.3.3"
-  resolved "https://registry.yarnpkg.com/async-retry/-/async-retry-1.3.3.tgz#0e7f36c04d8478e7a58bdbed80cedf977785f280"
-  integrity sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==
-  dependencies:
-    retry "0.13.1"
-
-async@^1.4.2:
-  version "1.5.2"
-  resolved "https://registry.yarnpkg.com/async/-/async-1.5.2.tgz#ec6a61ae56480c0c3cb241c95618e20892f9672a"
-  integrity sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=
-
-async@^2.0.1, async@^2.1.2, async@^2.4.0, async@^2.5.0:
-  version "2.6.3"
-  resolved "https://registry.yarnpkg.com/async/-/async-2.6.3.tgz#d72625e2344a3656e3a3ad4fa749fa83299d82ff"
-  integrity sha512-zflvls11DCy+dQWzTW2dzuilv8Z5X/pjfmZOWba6TNIVDm+2UDaJmXSOXlasHKfNBs8oo3M0aT50fDEWfKZjXg==
-  dependencies:
-    lodash "^4.17.14"
-
-async@^3.2.3:
-  version "3.2.4"
-  resolved "https://registry.yarnpkg.com/async/-/async-3.2.4.tgz#2d22e00f8cddeb5fde5dd33522b56d1cf569a81c"
-  integrity sha512-iAB+JbDEGXhyIUavoDl9WP/Jj106Kz9DEn1DPgYw5ruDn0e3Wgi3sKFm55sASdGBNOQB8F59d9qQ7deqrHA8wQ==
-
-asynckit@^0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
-  integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==
-
-at-least-node@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/at-least-node/-/at-least-node-1.0.0.tgz#602cd4b46e844ad4effc92a8011a3c46e0238dc2"
-  integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==
-
-atob@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
-  integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
-
-available-typed-arrays@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.2.tgz#6b098ca9d8039079ee3f77f7b783c4480ba513f5"
-  integrity sha512-XWX3OX8Onv97LMk/ftVyBibpGwY5a8SmuxZPzeOxqmuEqUCOM9ZE+uIaD1VNJ5QnvU2UQusvmKbuM1FR8QWGfQ==
-  dependencies:
-    array-filter "^1.0.0"
-
-await-semaphore@^0.1.3:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/await-semaphore/-/await-semaphore-0.1.3.tgz#2b88018cc8c28e06167ae1cdff02504f1f9688d3"
-  integrity sha512-d1W2aNSYcz/sxYO4pMGX9vq65qOTu0P800epMud+6cYYX0QcT7zyqcxec3VWzpgvdXo57UWmVbZpLMjX2m1I7Q==
-
-aws-sign2@~0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8"
-  integrity sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==
-
-aws4@^1.8.0:
-  version "1.11.0"
-  resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.11.0.tgz#d61f46d83b2519250e2784daf5b09479a8b41c59"
-  integrity sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA==
-
-axios@^0.21.1, axios@^0.21.4:
-  version "0.21.4"
-  resolved "https://registry.yarnpkg.com/axios/-/axios-0.21.4.tgz#c67b90dc0568e5c1cf2b0b858c43ba28e2eda575"
-  integrity sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==
-  dependencies:
-    follow-redirects "^1.14.0"
-
-babel-code-frame@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.26.0.tgz#63fd43f7dc1e3bb7ce35947db8fe369a3f58c74b"
-  integrity sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=
-  dependencies:
-    chalk "^1.1.3"
-    esutils "^2.0.2"
-    js-tokens "^3.0.2"
-
-babel-core@^6.26.0:
-  version "6.26.3"
-  resolved "https://registry.yarnpkg.com/babel-core/-/babel-core-6.26.3.tgz#b2e2f09e342d0f0c88e2f02e067794125e75c207"
-  integrity sha512-6jyFLuDmeidKmUEb3NM+/yawG0M2bDZ9Z1qbZP59cyHLz8kYGKYwpJP0UwUKKUiTRNvxfLesJnTedqczP7cTDA==
-  dependencies:
-    babel-code-frame "^6.26.0"
-    babel-generator "^6.26.0"
-    babel-helpers "^6.24.1"
-    babel-messages "^6.23.0"
-    babel-register "^6.26.0"
-    babel-runtime "^6.26.0"
-    babel-template "^6.26.0"
-    babel-traverse "^6.26.0"
-    babel-types "^6.26.0"
-    babylon "^6.18.0"
-    convert-source-map "^1.5.1"
-    debug "^2.6.9"
-    json5 "^0.5.1"
-    lodash "^4.17.4"
-    minimatch "^3.0.4"
-    path-is-absolute "^1.0.1"
-    private "^0.1.8"
-    slash "^1.0.0"
-    source-map "^0.5.7"
-
-babel-generator@6.26.1, babel-generator@^6.26.0:
-  version "6.26.1"
-  resolved "https://registry.yarnpkg.com/babel-generator/-/babel-generator-6.26.1.tgz#1844408d3b8f0d35a404ea7ac180f087a601bd90"
-  integrity sha512-HyfwY6ApZj7BYTcJURpM5tznulaBvyio7/0d4zFOeMPUmfxkCjHocCuoLa2SAGzBI8AREcH3eP3758F672DppA==
-  dependencies:
-    babel-messages "^6.23.0"
-    babel-runtime "^6.26.0"
-    babel-types "^6.26.0"
-    detect-indent "^4.0.0"
-    jsesc "^1.3.0"
-    lodash "^4.17.4"
-    source-map "^0.5.7"
-    trim-right "^1.0.1"
-
-babel-helpers@^6.24.1:
-  version "6.24.1"
-  resolved "https://registry.yarnpkg.com/babel-helpers/-/babel-helpers-6.24.1.tgz#3471de9caec388e5c850e597e58a26ddf37602b2"
-  integrity sha1-NHHenK7DiOXIUOWX5Yom3fN2ArI=
-  dependencies:
-    babel-runtime "^6.22.0"
-    babel-template "^6.24.1"
-
-babel-messages@^6.23.0:
-  version "6.23.0"
-  resolved "https://registry.yarnpkg.com/babel-messages/-/babel-messages-6.23.0.tgz#f3cdf4703858035b2a2951c6ec5edf6c62f2630e"
-  integrity sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=
-  dependencies:
-    babel-runtime "^6.22.0"
-
-babel-plugin-dynamic-import-node@^2.3.3:
-  version "2.3.3"
-  resolved "https://registry.yarnpkg.com/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz#84fda19c976ec5c6defef57f9427b3def66e17a3"
-  integrity sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==
-  dependencies:
-    object.assign "^4.1.0"
-
-babel-plugin-polyfill-corejs2@^0.1.4:
-  version "0.1.10"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.1.10.tgz#a2c5c245f56c0cac3dbddbf0726a46b24f0f81d1"
-  integrity sha512-DO95wD4g0A8KRaHKi0D51NdGXzvpqVLnLu5BTvDlpqUEpTmeEtypgC1xqesORaWmiUOQI14UHKlzNd9iZ2G3ZA==
-  dependencies:
-    "@babel/compat-data" "^7.13.0"
-    "@babel/helper-define-polyfill-provider" "^0.1.5"
-    semver "^6.1.1"
-
-babel-plugin-polyfill-corejs3@^0.1.3:
-  version "0.1.7"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.1.7.tgz#80449d9d6f2274912e05d9e182b54816904befd0"
-  integrity sha512-u+gbS9bbPhZWEeyy1oR/YaaSpod/KDT07arZHb80aTpl8H5ZBq+uN1nN9/xtX7jQyfLdPfoqI4Rue/MQSWJquw==
-  dependencies:
-    "@babel/helper-define-polyfill-provider" "^0.1.5"
-    core-js-compat "^3.8.1"
-
-babel-plugin-polyfill-regenerator@^0.1.2:
-  version "0.1.6"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.1.6.tgz#0fe06a026fe0faa628ccc8ba3302da0a6ce02f3f"
-  integrity sha512-OUrYG9iKPKz8NxswXbRAdSwF0GhRdIEMTloQATJi4bDuFqrXaXcCUT/VGNrr8pBcjMh1RxZ7Xt9cytVJTJfvMg==
-  dependencies:
-    "@babel/helper-define-polyfill-provider" "^0.1.5"
-
-babel-plugin-syntax-trailing-function-commas@^7.0.0-beta.0:
-  version "7.0.0-beta.0"
-  resolved "https://registry.yarnpkg.com/babel-plugin-syntax-trailing-function-commas/-/babel-plugin-syntax-trailing-function-commas-7.0.0-beta.0.tgz#aa213c1435e2bffeb6fca842287ef534ad05d5cf"
-  integrity sha512-Xj9XuRuz3nTSbaTXWv3itLOcxyF4oPD8douBBmj7U9BBC6nEBYfyOJYQMf/8PJAFotC62UY5dFfIGEPr7WswzQ==
-
-babel-polyfill@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-polyfill/-/babel-polyfill-6.26.0.tgz#379937abc67d7895970adc621f284cd966cf2153"
-  integrity sha1-N5k3q8Z9eJWXCtxiHyhM2WbPIVM=
-  dependencies:
-    babel-runtime "^6.26.0"
-    core-js "^2.5.0"
-    regenerator-runtime "^0.10.5"
-
-babel-preset-fbjs@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/babel-preset-fbjs/-/babel-preset-fbjs-3.3.0.tgz#a6024764ea86c8e06a22d794ca8b69534d263541"
-  integrity sha512-7QTLTCd2gwB2qGoi5epSULMHugSVgpcVt5YAeiFO9ABLrutDQzKfGwzxgZHLpugq8qMdg/DhRZDZ5CLKxBkEbw==
-  dependencies:
-    "@babel/plugin-proposal-class-properties" "^7.0.0"
-    "@babel/plugin-proposal-object-rest-spread" "^7.0.0"
-    "@babel/plugin-syntax-class-properties" "^7.0.0"
-    "@babel/plugin-syntax-flow" "^7.0.0"
-    "@babel/plugin-syntax-jsx" "^7.0.0"
-    "@babel/plugin-syntax-object-rest-spread" "^7.0.0"
-    "@babel/plugin-transform-arrow-functions" "^7.0.0"
-    "@babel/plugin-transform-block-scoped-functions" "^7.0.0"
-    "@babel/plugin-transform-block-scoping" "^7.0.0"
-    "@babel/plugin-transform-classes" "^7.0.0"
-    "@babel/plugin-transform-computed-properties" "^7.0.0"
-    "@babel/plugin-transform-destructuring" "^7.0.0"
-    "@babel/plugin-transform-flow-strip-types" "^7.0.0"
-    "@babel/plugin-transform-for-of" "^7.0.0"
-    "@babel/plugin-transform-function-name" "^7.0.0"
-    "@babel/plugin-transform-literals" "^7.0.0"
-    "@babel/plugin-transform-member-expression-literals" "^7.0.0"
-    "@babel/plugin-transform-modules-commonjs" "^7.0.0"
-    "@babel/plugin-transform-object-super" "^7.0.0"
-    "@babel/plugin-transform-parameters" "^7.0.0"
-    "@babel/plugin-transform-property-literals" "^7.0.0"
-    "@babel/plugin-transform-react-display-name" "^7.0.0"
-    "@babel/plugin-transform-react-jsx" "^7.0.0"
-    "@babel/plugin-transform-shorthand-properties" "^7.0.0"
-    "@babel/plugin-transform-spread" "^7.0.0"
-    "@babel/plugin-transform-template-literals" "^7.0.0"
-    babel-plugin-syntax-trailing-function-commas "^7.0.0-beta.0"
-
-babel-register@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-register/-/babel-register-6.26.0.tgz#6ed021173e2fcb486d7acb45c6009a856f647071"
-  integrity sha1-btAhFz4vy0htestFxgCahW9kcHE=
-  dependencies:
-    babel-core "^6.26.0"
-    babel-runtime "^6.26.0"
-    core-js "^2.5.0"
-    home-or-tmp "^2.0.0"
-    lodash "^4.17.4"
-    mkdirp "^0.5.1"
-    source-map-support "^0.4.15"
-
-babel-runtime@^6.22.0, babel-runtime@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-runtime/-/babel-runtime-6.26.0.tgz#965c7058668e82b55d7bfe04ff2337bc8b5647fe"
-  integrity sha1-llxwWGaOgrVde/4E/yM3vItWR/4=
-  dependencies:
-    core-js "^2.4.0"
-    regenerator-runtime "^0.11.0"
-
-babel-template@^6.24.1, babel-template@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-template/-/babel-template-6.26.0.tgz#de03e2d16396b069f46dd9fff8521fb1a0e35e02"
-  integrity sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=
-  dependencies:
-    babel-runtime "^6.26.0"
-    babel-traverse "^6.26.0"
-    babel-types "^6.26.0"
-    babylon "^6.18.0"
-    lodash "^4.17.4"
-
-babel-traverse@6.26.0, babel-traverse@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-traverse/-/babel-traverse-6.26.0.tgz#46a9cbd7edcc62c8e5c064e2d2d8d0f4035766ee"
-  integrity sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=
-  dependencies:
-    babel-code-frame "^6.26.0"
-    babel-messages "^6.23.0"
-    babel-runtime "^6.26.0"
-    babel-types "^6.26.0"
-    babylon "^6.18.0"
-    debug "^2.6.8"
-    globals "^9.18.0"
-    invariant "^2.2.2"
-    lodash "^4.17.4"
-
-babel-types@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-types/-/babel-types-6.26.0.tgz#a3b073f94ab49eb6fa55cd65227a334380632497"
-  integrity sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=
-  dependencies:
-    babel-runtime "^6.26.0"
-    esutils "^2.0.2"
-    lodash "^4.17.4"
-    to-fast-properties "^1.0.3"
-
-babylon@6.18.0, babylon@^6.18.0:
-  version "6.18.0"
-  resolved "https://registry.yarnpkg.com/babylon/-/babylon-6.18.0.tgz#af2f3b88fa6f5c1e4c634d1a0f8eac4f55b395e3"
-  integrity sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==
-
-backo2@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/backo2/-/backo2-1.0.2.tgz#31ab1ac8b129363463e35b3ebb69f4dfcfba7947"
-  integrity sha1-MasayLEpNjRj41s+u2n038+6eUc=
-
-backoff@^2.5.0:
-  version "2.5.0"
-  resolved "https://registry.yarnpkg.com/backoff/-/backoff-2.5.0.tgz#f616eda9d3e4b66b8ca7fca79f695722c5f8e26f"
-  integrity sha1-9hbtqdPktmuMp/ynn2lXIsX44m8=
-  dependencies:
-    precond "0.2"
-
-balanced-match@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
-  integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
-
-base-x@^3.0.2, base-x@^3.0.8:
-  version "3.0.9"
-  resolved "https://registry.yarnpkg.com/base-x/-/base-x-3.0.9.tgz#6349aaabb58526332de9f60995e548a53fe21320"
-  integrity sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==
-  dependencies:
-    safe-buffer "^5.0.1"
-
-base64-js@^1.3.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a"
-  integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
-
-bcrypt-pbkdf@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz#a4301d389b6a43f9b67ff3ca11a3f6637e360e9e"
-  integrity sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==
-  dependencies:
-    tweetnacl "^0.14.3"
-
-big.js@^5.2.2:
-  version "5.2.2"
-  resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
-  integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
-
-bignumber.js@^7.2.1:
-  version "7.2.1"
-  resolved "https://registry.yarnpkg.com/bignumber.js/-/bignumber.js-7.2.1.tgz#80c048759d826800807c4bfd521e50edbba57a5f"
-  integrity sha512-S4XzBk5sMB+Rcb/LNcpzXr57VRTxgAvaAEDAl1AwRx27j00hT84O6OkteE7u8UB3NuaaygCRrEpqox4uDOrbdQ==
-
-bignumber.js@^9.0.0:
-  version "9.1.0"
-  resolved "https://registry.yarnpkg.com/bignumber.js/-/bignumber.js-9.1.0.tgz#8d340146107fe3a6cb8d40699643c302e8773b62"
-  integrity sha512-4LwHK4nfDOraBCtst+wOWIHbu1vhvAPJK8g8nROd4iuc3PSEjWif/qwbkh8jwCJz6yDBvtU4KPynETgrfh7y3A==
-
-bignumber.js@^9.0.1:
-  version "9.0.1"
-  resolved "https://registry.yarnpkg.com/bignumber.js/-/bignumber.js-9.0.1.tgz#8d7ba124c882bfd8e43260c67475518d0689e4e5"
-  integrity sha512-IdZR9mh6ahOBv/hYGiXyVuyCetmGJhtYkqLBpTStdhEGjegpPlUawydyaF3pbIOFynJTpllEs+NP+CS9jKFLjA==
-
-binary-extensions@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.2.0.tgz#75f502eeaf9ffde42fc98829645be4ea76bd9e2d"
-  integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==
-
-binary-install-raw@0.0.13:
-  version "0.0.13"
-  resolved "https://registry.yarnpkg.com/binary-install-raw/-/binary-install-raw-0.0.13.tgz#43a13c6980eb9844e2932eb7a91a56254f55b7dd"
-  integrity sha512-v7ms6N/H7iciuk6QInon3/n2mu7oRX+6knJ9xFPsJ3rQePgAqcR3CRTwUheFd8SLbiq4LL7Z4G/44L9zscdt9A==
-  dependencies:
-    axios "^0.21.1"
-    rimraf "^3.0.2"
-    tar "^6.1.0"
-
-binaryen@101.0.0-nightly.20210723:
-  version "101.0.0-nightly.20210723"
-  resolved "https://registry.yarnpkg.com/binaryen/-/binaryen-101.0.0-nightly.20210723.tgz#b6bb7f3501341727681a03866c0856500eec3740"
-  integrity sha512-eioJNqhHlkguVSbblHOtLqlhtC882SOEPKmNFZaDuz1hzQjolxZ+eu3/kaS10n3sGPONsIZsO7R9fR00UyhEUA==
-
-binaryen@102.0.0-nightly.20211028:
-  version "102.0.0-nightly.20211028"
-  resolved "https://registry.yarnpkg.com/binaryen/-/binaryen-102.0.0-nightly.20211028.tgz#8f1efb0920afd34509e342e37f84313ec936afb2"
-  integrity sha512-GCJBVB5exbxzzvyt8MGDv/MeUjs6gkXDvf4xOIItRBptYl0Tz5sm1o/uG95YK0L0VeG5ajDu3hRtkBP2kzqC5w==
-
-bindings@^1.5.0:
-  version "1.5.0"
-  resolved "https://registry.yarnpkg.com/bindings/-/bindings-1.5.0.tgz#10353c9e945334bc0511a6d90b38fbc7c9c504df"
-  integrity sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==
-  dependencies:
-    file-uri-to-path "1.0.0"
-
-bl@^1.0.0:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/bl/-/bl-1.2.3.tgz#1e8dd80142eac80d7158c9dccc047fb620e035e7"
-  integrity sha512-pvcNpa0UU69UT341rO6AYy4FVAIkUHuZXRIWbq+zHnsVcRzDDjIAhGuuYoi0d//cwIwtt4pkpKycWEfjdV+vww==
-  dependencies:
-    readable-stream "^2.3.5"
-    safe-buffer "^5.1.1"
-
-blakejs@^1.1.0:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/blakejs/-/blakejs-1.2.1.tgz#5057e4206eadb4a97f7c0b6e197a505042fc3814"
-  integrity sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==
-
-blob-to-it@^1.0.1:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/blob-to-it/-/blob-to-it-1.0.4.tgz#f6caf7a4e90b7bb9215fa6a318ed6bd8ad9898cb"
-  integrity sha512-iCmk0W4NdbrWgRRuxOriU8aM5ijeVLI61Zulsmg/lUHNr7pYjoj+U77opLefNagevtrrbMt3JQ5Qip7ar178kA==
-  dependencies:
-    browser-readablestream-to-it "^1.0.3"
-
-bluebird@^3.4.7, bluebird@^3.5.0:
-  version "3.7.2"
-  resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.7.2.tgz#9f229c15be272454ffa973ace0dbee79a1b0c36f"
-  integrity sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==
-
-bn.js@4.11.6:
-  version "4.11.6"
-  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.11.6.tgz#53344adb14617a13f6e8dd2ce28905d1c0ba3215"
-  integrity sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==
-
-bn.js@4.11.8:
-  version "4.11.8"
-  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.11.8.tgz#2cde09eb5ee341f484746bb0309b3253b1b1442f"
-  integrity sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==
-
-bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.11.0, bn.js@^4.11.1, bn.js@^4.11.6, bn.js@^4.11.8, bn.js@^4.11.9, bn.js@^4.4.0:
-  version "4.12.0"
-  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.12.0.tgz#775b3f278efbb9718eec7361f483fb36fbbfea88"
-  integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==
-
-bn.js@^5.0.0, bn.js@^5.1.1, bn.js@^5.1.3:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-5.2.0.tgz#358860674396c6997771a9d051fcc1b57d4ae002"
-  integrity sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==
-
-bn.js@^5.1.2, bn.js@^5.2.0, bn.js@^5.2.1:
-  version "5.2.1"
-  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-5.2.1.tgz#0bc527a6a0d18d0aa8d5b0538ce4a77dccfa7b70"
-  integrity sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==
-
-body-parser@1.20.1, body-parser@^1.16.0, body-parser@^1.18.3:
-  version "1.20.1"
-  resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.1.tgz#b1812a8912c195cd371a3ee5e66faa2338a5c668"
-  integrity sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==
-  dependencies:
-    bytes "3.1.2"
-    content-type "~1.0.4"
-    debug "2.6.9"
-    depd "2.0.0"
-    destroy "1.2.0"
-    http-errors "2.0.0"
-    iconv-lite "0.4.24"
-    on-finished "2.4.1"
-    qs "6.11.0"
-    raw-body "2.5.1"
-    type-is "~1.6.18"
-    unpipe "1.0.0"
-
-boolbase@^1.0.0, boolbase@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/boolbase/-/boolbase-1.0.0.tgz#68dff5fbe60c51eb37725ea9e3ed310dcc1e776e"
-  integrity sha1-aN/1++YMUes3cl6p4+0xDcwed24=
-
-brace-expansion@^1.1.7:
-  version "1.1.11"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
-  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
-  dependencies:
-    balanced-match "^1.0.0"
-    concat-map "0.0.1"
-
-brace-expansion@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae"
-  integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==
-  dependencies:
-    balanced-match "^1.0.0"
-
-braces@^1.8.2:
-  version "1.8.5"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-1.8.5.tgz#ba77962e12dff969d6b76711e914b737857bf6a7"
-  integrity sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=
-  dependencies:
-    expand-range "^1.8.1"
-    preserve "^0.2.0"
-    repeat-element "^1.1.2"
-
-braces@^3.0.1, braces@^3.0.2, braces@~3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
-  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
-  dependencies:
-    fill-range "^7.0.1"
-
-brorand@^1.0.1, brorand@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f"
-  integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=
-
-browser-readablestream-to-it@^1.0.0, browser-readablestream-to-it@^1.0.1, browser-readablestream-to-it@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/browser-readablestream-to-it/-/browser-readablestream-to-it-1.0.3.tgz#ac3e406c7ee6cdf0a502dd55db33bab97f7fba76"
-  integrity sha512-+12sHB+Br8HIh6VAMVEG5r3UXCyESIgDW7kzk3BjIXa43DVqVwL7GC5TW3jeh+72dtcH99pPVpw0X8i0jt+/kw==
-
-browser-stdout@1.3.1:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60"
-  integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
-
-browserify-aes@^1.0.0, browserify-aes@^1.0.4, browserify-aes@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/browserify-aes/-/browserify-aes-1.2.0.tgz#326734642f403dabc3003209853bb70ad428ef48"
-  integrity sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==
-  dependencies:
-    buffer-xor "^1.0.3"
-    cipher-base "^1.0.0"
-    create-hash "^1.1.0"
-    evp_bytestokey "^1.0.3"
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-browserify-cipher@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/browserify-cipher/-/browserify-cipher-1.0.1.tgz#8d6474c1b870bfdabcd3bcfcc1934a10e94f15f0"
-  integrity sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==
-  dependencies:
-    browserify-aes "^1.0.4"
-    browserify-des "^1.0.0"
-    evp_bytestokey "^1.0.0"
-
-browserify-des@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/browserify-des/-/browserify-des-1.0.2.tgz#3af4f1f59839403572f1c66204375f7a7f703e9c"
-  integrity sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==
-  dependencies:
-    cipher-base "^1.0.1"
-    des.js "^1.0.0"
-    inherits "^2.0.1"
-    safe-buffer "^5.1.2"
-
-browserify-rsa@^4.0.0, browserify-rsa@^4.0.1:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/browserify-rsa/-/browserify-rsa-4.1.0.tgz#b2fd06b5b75ae297f7ce2dc651f918f5be158c8d"
-  integrity sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==
-  dependencies:
-    bn.js "^5.0.0"
-    randombytes "^2.0.1"
-
-browserify-sign@^4.0.0:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/browserify-sign/-/browserify-sign-4.2.1.tgz#eaf4add46dd54be3bb3b36c0cf15abbeba7956c3"
-  integrity sha512-/vrA5fguVAKKAVTNJjgSm1tRQDHUU6DbwO9IROu/0WAzC8PKhucDSh18J0RMvVeHAn5puMd+QHC2erPRNf8lmg==
-  dependencies:
-    bn.js "^5.1.1"
-    browserify-rsa "^4.0.1"
-    create-hash "^1.2.0"
-    create-hmac "^1.1.7"
-    elliptic "^6.5.3"
-    inherits "^2.0.4"
-    parse-asn1 "^5.1.5"
-    readable-stream "^3.6.0"
-    safe-buffer "^5.2.0"
-
-browserslist@^4.14.5, browserslist@^4.16.3:
-  version "4.16.3"
-  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.3.tgz#340aa46940d7db878748567c5dea24a48ddf3717"
-  integrity sha512-vIyhWmIkULaq04Gt93txdh+j02yX/JzlyhLYbV3YQCn/zvES3JnY7TifHHvvr1w5hTDluNKMkV05cs4vy8Q7sw==
-  dependencies:
-    caniuse-lite "^1.0.30001181"
-    colorette "^1.2.1"
-    electron-to-chromium "^1.3.649"
-    escalade "^3.1.1"
-    node-releases "^1.1.70"
-
-bs58@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/bs58/-/bs58-4.0.1.tgz#be161e76c354f6f788ae4071f63f34e8c4f0a42a"
-  integrity sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==
-  dependencies:
-    base-x "^3.0.2"
-
-bs58check@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/bs58check/-/bs58check-2.1.2.tgz#53b018291228d82a5aa08e7d796fdafda54aebfc"
-  integrity sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==
-  dependencies:
-    bs58 "^4.0.0"
-    create-hash "^1.1.0"
-    safe-buffer "^5.1.2"
-
-bser@2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/bser/-/bser-2.1.1.tgz#e6787da20ece9d07998533cfd9de6f5c38f4bc05"
-  integrity sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==
-  dependencies:
-    node-int64 "^0.4.0"
-
-btoa@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/btoa/-/btoa-1.2.1.tgz#01a9909f8b2c93f6bf680ba26131eb30f7fa3d73"
-  integrity sha512-SB4/MIGlsiVkMcHmT+pSmIPoNDoHg+7cMzmt3Uxt628MTz2487DKSqK/fuhFBrkuqrYv5UCEnACpF4dTFNKc/g==
-
-buffer-alloc-unsafe@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz#bd7dc26ae2972d0eda253be061dba992349c19f0"
-  integrity sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==
-
-buffer-alloc@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/buffer-alloc/-/buffer-alloc-1.2.0.tgz#890dd90d923a873e08e10e5fd51a57e5b7cce0ec"
-  integrity sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==
-  dependencies:
-    buffer-alloc-unsafe "^1.1.0"
-    buffer-fill "^1.0.0"
-
-buffer-fill@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/buffer-fill/-/buffer-fill-1.0.0.tgz#f8f78b76789888ef39f205cd637f68e702122b2c"
-  integrity sha512-T7zexNBwiiaCOGDg9xNX9PBmjrubblRkENuptryuI64URkXDFum9il/JGL8Lm8wYfAXpredVXXZz7eMHilimiQ==
-
-buffer-from@1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.0.tgz#87fcaa3a298358e0ade6e442cfce840740d1ad04"
-  integrity sha512-c5mRlguI/Pe2dSZmpER62rSCu0ryKmWddzRYsuXc50U2/g8jMOulc31VZMa4mYx31U5xsmSOpDCgH88Vl9cDGQ==
-
-buffer-from@1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
-  integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==
-
-buffer-from@^1.0.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
-  integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
-
-buffer-to-arraybuffer@^0.0.5:
-  version "0.0.5"
-  resolved "https://registry.yarnpkg.com/buffer-to-arraybuffer/-/buffer-to-arraybuffer-0.0.5.tgz#6064a40fa76eb43c723aba9ef8f6e1216d10511a"
-  integrity sha1-YGSkD6dutDxyOrqe+PbhIW0QURo=
-
-buffer-xor@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/buffer-xor/-/buffer-xor-1.0.3.tgz#26e61ed1422fb70dd42e6e36729ed51d855fe8d9"
-  integrity sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==
-
-buffer@^5.0.5, buffer@^5.2.1, buffer@^5.5.0, buffer@^5.6.0, buffer@^5.7.0:
-  version "5.7.1"
-  resolved "https://registry.yarnpkg.com/buffer/-/buffer-5.7.1.tgz#ba62e7c13133053582197160851a8f648e99eed0"
-  integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==
-  dependencies:
-    base64-js "^1.3.1"
-    ieee754 "^1.1.13"
-
-buffer@^6.0.1, buffer@^6.0.3:
-  version "6.0.3"
-  resolved "https://registry.yarnpkg.com/buffer/-/buffer-6.0.3.tgz#2ace578459cc8fbe2a70aaa8f52ee63b6a74c6c6"
-  integrity sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==
-  dependencies:
-    base64-js "^1.3.1"
-    ieee754 "^1.2.1"
-
-bufferutil@^4.0.1:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/bufferutil/-/bufferutil-4.0.3.tgz#66724b756bed23cd7c28c4d306d7994f9943cc6b"
-  integrity sha512-yEYTwGndELGvfXsImMBLop58eaGW+YdONi1fNjTINSY98tmMmFijBG6WXgdkfuLNt4imzQNtIE+eBp1PVpMCSw==
-  dependencies:
-    node-gyp-build "^4.2.0"
-
-busboy@^0.3.1:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/busboy/-/busboy-0.3.1.tgz#170899274c5bf38aae27d5c62b71268cd585fd1b"
-  integrity sha512-y7tTxhGKXcyBxRKAni+awqx8uqaJKrSFSNFSeRG5CsWNdmy2BIK+6VGWEW7TZnIO/533mtMEA4rOevQV815YJw==
-  dependencies:
-    dicer "0.3.0"
-
-busboy@^1.6.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/busboy/-/busboy-1.6.0.tgz#966ea36a9502e43cdb9146962523b92f531f6893"
-  integrity sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==
-  dependencies:
-    streamsearch "^1.1.0"
-
-bytes@3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5"
-  integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==
-
-cacheable-request@^6.0.0:
-  version "6.1.0"
-  resolved "https://registry.yarnpkg.com/cacheable-request/-/cacheable-request-6.1.0.tgz#20ffb8bd162ba4be11e9567d823db651052ca912"
-  integrity sha512-Oj3cAGPCqOZX7Rz64Uny2GYAZNliQSqfbePrgAQ1wKAihYmCUnraBtJtKcGR4xz7wF+LoJC+ssFZvv5BgF9Igg==
-  dependencies:
-    clone-response "^1.0.2"
-    get-stream "^5.1.0"
-    http-cache-semantics "^4.0.0"
-    keyv "^3.0.0"
-    lowercase-keys "^2.0.0"
-    normalize-url "^4.1.0"
-    responselike "^1.0.2"
-
-call-bind@^1.0.0, call-bind@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c"
-  integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==
-  dependencies:
-    function-bind "^1.1.1"
-    get-intrinsic "^1.0.2"
-
-callsites@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
-  integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
-
-camel-case@4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/camel-case/-/camel-case-4.1.1.tgz#1fc41c854f00e2f7d0139dfeba1542d6896fe547"
-  integrity sha512-7fa2WcG4fYFkclIvEmxBbTvmibwF2/agfEBc6q3lOpVu0A13ltLsA+Hr/8Hp6kp5f+G7hKi6t8lys6XxP+1K6Q==
-  dependencies:
-    pascal-case "^3.1.1"
-    tslib "^1.10.0"
-
-camel-case@4.1.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/camel-case/-/camel-case-4.1.2.tgz#9728072a954f805228225a6deea6b38461e1bd5a"
-  integrity sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==
-  dependencies:
-    pascal-case "^3.1.2"
-    tslib "^2.0.3"
-
-camel-case@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/camel-case/-/camel-case-3.0.0.tgz#ca3c3688a4e9cf3a4cda777dc4dcbc713249cf73"
-  integrity sha1-yjw2iKTpzzpM2nd9xNy8cTJJz3M=
-  dependencies:
-    no-case "^2.2.0"
-    upper-case "^1.1.1"
-
-camelcase@^2.0.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-2.1.1.tgz#7c1d16d679a1bbe59ca02cacecfb011e201f5a1f"
-  integrity sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8=
-
-camelcase@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-3.0.0.tgz#32fc4b9fcdaf845fcdf7e73bb97cac2261f0ab0a"
-  integrity sha1-MvxLn82vhF/N9+c7uXysImHwqwo=
-
-camelcase@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-4.1.0.tgz#d545635be1e33c542649c69173e5de6acfae34dd"
-  integrity sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=
-
-camelcase@^5.0.0, camelcase@^5.3.1:
-  version "5.3.1"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
-  integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
-
-caniuse-lite@^1.0.30001181:
-  version "1.0.30001197"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001197.tgz#47ad15b977d2f32b3ec2fe2b087e0c50443771db"
-  integrity sha512-8aE+sqBqtXz4G8g35Eg/XEaFr2N7rd/VQ6eABGBmNtcB8cN6qNJhMi6oSFy4UWWZgqgL3filHT8Nha4meu3tsw==
-
-cardinal@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/cardinal/-/cardinal-2.1.1.tgz#7cc1055d822d212954d07b085dea251cc7bc5505"
-  integrity sha512-JSr5eOgoEymtYHBjNWyjrMqet9Am2miJhlfKNdqLp6zoeAh0KN5dRAcxlecj5mAJrmQomgiOBj35xHLrFjqBpw==
-  dependencies:
-    ansicolors "~0.3.2"
-    redeyed "~2.1.0"
-
-caseless@^0.12.0, caseless@~0.12.0:
-  version "0.12.0"
-  resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
-  integrity sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==
-
-cbor@^5.1.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/cbor/-/cbor-5.2.0.tgz#4cca67783ccd6de7b50ab4ed62636712f287a67c"
-  integrity sha512-5IMhi9e1QU76ppa5/ajP1BmMWZ2FHkhAhjeVKQ/EFCgYSEaeVaoGtL7cxJskf9oCCk+XjzaIdc3IuU/dbA/o2A==
-  dependencies:
-    bignumber.js "^9.0.1"
-    nofilter "^1.0.4"
-
-cborg@^1.5.4, cborg@^1.6.0:
-  version "1.10.2"
-  resolved "https://registry.yarnpkg.com/cborg/-/cborg-1.10.2.tgz#83cd581b55b3574c816f82696307c7512db759a1"
-  integrity sha512-b3tFPA9pUr2zCUiCfRd2+wok2/LBSNUMKOuRRok+WlvvAgEt/PlbgPTsZUcwCOs53IJvLgTp0eotwtosE6njug==
-
-chalk@1.1.3, chalk@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98"
-  integrity sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=
-  dependencies:
-    ansi-styles "^2.2.1"
-    escape-string-regexp "^1.0.2"
-    has-ansi "^2.0.0"
-    strip-ansi "^3.0.0"
-    supports-color "^2.0.0"
-
-chalk@3.0.0, chalk@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-3.0.0.tgz#3f73c2bf526591f574cc492c51e2456349f844e4"
-  integrity sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-chalk@^2.0.0, chalk@^2.0.1, chalk@^2.3.2, chalk@^2.4.2:
-  version "2.4.2"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
-  integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
-  dependencies:
-    ansi-styles "^3.2.1"
-    escape-string-regexp "^1.0.5"
-    supports-color "^5.3.0"
-
-chalk@^4, chalk@^4.0.2, chalk@^4.1.0, chalk@^4.1.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
-  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-chalk@^4.0.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.0.tgz#4e14870a618d9e2edd97dd8345fd9d9dc315646a"
-  integrity sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-change-case@3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/change-case/-/change-case-3.0.2.tgz#fd48746cce02f03f0a672577d1d3a8dc2eceb037"
-  integrity sha512-Mww+SLF6MZ0U6kdg11algyKd5BARbyM4TbFBepwowYSR5ClfQGCGtxNXgykpN0uF/bstWeaGDT4JWaDh8zWAHA==
-  dependencies:
-    camel-case "^3.0.0"
-    constant-case "^2.0.0"
-    dot-case "^2.1.0"
-    header-case "^1.0.0"
-    is-lower-case "^1.1.0"
-    is-upper-case "^1.1.0"
-    lower-case "^1.1.1"
-    lower-case-first "^1.0.0"
-    no-case "^2.3.2"
-    param-case "^2.1.0"
-    pascal-case "^2.0.0"
-    path-case "^2.1.0"
-    sentence-case "^2.1.0"
-    snake-case "^2.1.0"
-    swap-case "^1.1.0"
-    title-case "^2.1.0"
-    upper-case "^1.1.1"
-    upper-case-first "^1.1.0"
-
-checkpoint-store@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/checkpoint-store/-/checkpoint-store-1.1.0.tgz#04e4cb516b91433893581e6d4601a78e9552ea06"
-  integrity sha1-BOTLUWuRQziTWB5tRgGnjpVS6gY=
-  dependencies:
-    functional-red-black-tree "^1.0.1"
-
-cheerio-select-tmp@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/cheerio-select-tmp/-/cheerio-select-tmp-0.1.1.tgz#55bbef02a4771710195ad736d5e346763ca4e646"
-  integrity sha512-YYs5JvbpU19VYJyj+F7oYrIE2BOll1/hRU7rEy/5+v9BzkSo3bK81iAeeQEMI92vRIxz677m72UmJUiVwwgjfQ==
-  dependencies:
-    css-select "^3.1.2"
-    css-what "^4.0.0"
-    domelementtype "^2.1.0"
-    domhandler "^4.0.0"
-    domutils "^2.4.4"
-
-cheerio@0.20.0:
-  version "0.20.0"
-  resolved "https://registry.yarnpkg.com/cheerio/-/cheerio-0.20.0.tgz#5c710f2bab95653272842ba01c6ea61b3545ec35"
-  integrity sha1-XHEPK6uVZTJyhCugHG6mGzVF7DU=
-  dependencies:
-    css-select "~1.2.0"
-    dom-serializer "~0.1.0"
-    entities "~1.1.1"
-    htmlparser2 "~3.8.1"
-    lodash "^4.1.0"
-  optionalDependencies:
-    jsdom "^7.0.2"
-
-cheerio@1.0.0-rc.2:
-  version "1.0.0-rc.2"
-  resolved "https://registry.yarnpkg.com/cheerio/-/cheerio-1.0.0-rc.2.tgz#4b9f53a81b27e4d5dac31c0ffd0cfa03cc6830db"
-  integrity sha1-S59TqBsn5NXawxwP/Qz6A8xoMNs=
-  dependencies:
-    css-select "~1.2.0"
-    dom-serializer "~0.1.0"
-    entities "~1.1.1"
-    htmlparser2 "^3.9.1"
-    lodash "^4.15.0"
-    parse5 "^3.0.1"
-
-cheerio@^1.0.0-rc.2:
-  version "1.0.0-rc.5"
-  resolved "https://registry.yarnpkg.com/cheerio/-/cheerio-1.0.0-rc.5.tgz#88907e1828674e8f9fee375188b27dadd4f0fa2f"
-  integrity sha512-yoqps/VCaZgN4pfXtenwHROTp8NG6/Hlt4Jpz2FEP0ZJQ+ZUkVDd0hAPDNKhj3nakpfPt/CNs57yEtxD1bXQiw==
-  dependencies:
-    cheerio-select-tmp "^0.1.0"
-    dom-serializer "~1.2.0"
-    domhandler "^4.0.0"
-    entities "~2.1.0"
-    htmlparser2 "^6.0.0"
-    parse5 "^6.0.0"
-    parse5-htmlparser2-tree-adapter "^6.0.0"
-
-chokidar@3.4.2:
-  version "3.4.2"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.4.2.tgz#38dc8e658dec3809741eb3ef7bb0a47fe424232d"
-  integrity sha512-IZHaDeBeI+sZJRX7lGcXsdzgvZqKv6sECqsbErJA4mHWfpRrD8B97kSFN4cQz6nGBGiuFia1MKR4d6c1o8Cv7A==
-  dependencies:
-    anymatch "~3.1.1"
-    braces "~3.0.2"
-    glob-parent "~5.1.0"
-    is-binary-path "~2.1.0"
-    is-glob "~4.0.1"
-    normalize-path "~3.0.0"
-    readdirp "~3.4.0"
-  optionalDependencies:
-    fsevents "~2.1.2"
-
-chokidar@3.5.3:
-  version "3.5.3"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.3.tgz#1cf37c8707b932bd1af1ae22c0432e2acd1903bd"
-  integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==
-  dependencies:
-    anymatch "~3.1.2"
-    braces "~3.0.2"
-    glob-parent "~5.1.2"
-    is-binary-path "~2.1.0"
-    is-glob "~4.0.1"
-    normalize-path "~3.0.0"
-    readdirp "~3.6.0"
-  optionalDependencies:
-    fsevents "~2.3.2"
-
-chownr@^1.0.1, chownr@^1.1.4:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/chownr/-/chownr-1.1.4.tgz#6fc9d7b42d32a583596337666e7d08084da2cc6b"
-  integrity sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==
-
-chownr@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/chownr/-/chownr-2.0.0.tgz#15bfbe53d2eab4cf70f18a8cd68ebe5b3cb1dece"
-  integrity sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==
-
-cids@^0.7.1:
-  version "0.7.5"
-  resolved "https://registry.yarnpkg.com/cids/-/cids-0.7.5.tgz#60a08138a99bfb69b6be4ceb63bfef7a396b28b2"
-  integrity sha512-zT7mPeghoWAu+ppn8+BS1tQ5qGmbMfB4AregnQjA/qHY3GC1m1ptI9GkWNlgeu38r7CuRdXB47uY2XgAYt6QVA==
-  dependencies:
-    buffer "^5.5.0"
-    class-is "^1.1.0"
-    multibase "~0.6.0"
-    multicodec "^1.0.0"
-    multihashes "~0.4.15"
-
-cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/cipher-base/-/cipher-base-1.0.4.tgz#8760e4ecc272f4c363532f926d874aae2c1397de"
-  integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==
-  dependencies:
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-class-is@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/class-is/-/class-is-1.1.0.tgz#9d3c0fba0440d211d843cec3dedfa48055005825"
-  integrity sha512-rhjH9AG1fvabIDoGRVH587413LPjTZgmDF9fOFCbFJQV4yuocX1mHxxvXI4g3cGwbVY9wAYIoKlg1N79frJKQw==
-
-clean-stack@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-3.0.1.tgz#155bf0b2221bf5f4fba89528d24c5953f17fe3a8"
-  integrity sha512-lR9wNiMRcVQjSB3a7xXGLuz4cr4wJuuXlaAEbRutGowQTmlp7R72/DOgN21e8jdwblMWl9UOJMJXarX94pzKdg==
-  dependencies:
-    escape-string-regexp "4.0.0"
-
-cli-cursor@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
-  integrity sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=
-  dependencies:
-    restore-cursor "^2.0.0"
-
-cli-cursor@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-3.1.0.tgz#264305a7ae490d1d03bf0c9ba7c925d1753af307"
-  integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==
-  dependencies:
-    restore-cursor "^3.1.0"
-
-cli-progress@^3.12.0:
-  version "3.12.0"
-  resolved "https://registry.yarnpkg.com/cli-progress/-/cli-progress-3.12.0.tgz#807ee14b66bcc086258e444ad0f19e7d42577942"
-  integrity sha512-tRkV3HJ1ASwm19THiiLIXLO7Im7wlTuKnvkYaTkyoAPefqjNg7W7DHKUlGRxy9vxDvbyCYQkQozvptuMkGCg8A==
-  dependencies:
-    string-width "^4.2.3"
-
-cli-spinners@^2.0.0:
-  version "2.5.0"
-  resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-2.5.0.tgz#12763e47251bf951cb75c201dfa58ff1bcb2d047"
-  integrity sha512-PC+AmIuK04E6aeSs/pUccSujsTzBhu4HzC2dL+CfJB/Jcc2qTRbEwZQDfIUpt2Xl8BodYBEq8w4fc0kU2I9DjQ==
-
-cli-spinners@^2.2.0:
-  version "2.7.0"
-  resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-2.7.0.tgz#f815fd30b5f9eaac02db604c7a231ed7cb2f797a"
-  integrity sha512-qu3pN8Y3qHNgE2AFweciB1IfMnmZ/fsNTEE+NOFjmGB2F/7rLhnhzppvpCnN4FovtP26k8lHyy9ptEbNwWFLzw==
-
-cli-table3@0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/cli-table3/-/cli-table3-0.6.0.tgz#b7b1bc65ca8e7b5cef9124e13dc2b21e2ce4faee"
-  integrity sha512-gnB85c3MGC7Nm9I/FkiasNBOKjOiO1RNuXXarQms37q4QMpWdlbBgD/VnOStA2faG1dpXMv31RFApjX1/QdgWQ==
-  dependencies:
-    object-assign "^4.1.0"
-    string-width "^4.2.0"
-  optionalDependencies:
-    colors "^1.1.2"
-
-cli-table3@~0.5.0:
-  version "0.5.1"
-  resolved "https://registry.yarnpkg.com/cli-table3/-/cli-table3-0.5.1.tgz#0252372d94dfc40dbd8df06005f48f31f656f202"
-  integrity sha512-7Qg2Jrep1S/+Q3EceiZtQcDPWxhAvBw+ERf1162v4sikJrvojMHFqXt8QIVha8UlH9rgU0BeWPytZ9/TzYqlUw==
-  dependencies:
-    object-assign "^4.1.0"
-    string-width "^2.1.1"
-  optionalDependencies:
-    colors "^1.1.2"
-
-cliui@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-3.2.0.tgz#120601537a916d29940f934da3b48d585a39213d"
-  integrity sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0=
-  dependencies:
-    string-width "^1.0.1"
-    strip-ansi "^3.0.1"
-    wrap-ansi "^2.0.0"
-
-cliui@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-5.0.0.tgz#deefcfdb2e800784aa34f46fa08e06851c7bbbc5"
-  integrity sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==
-  dependencies:
-    string-width "^3.1.0"
-    strip-ansi "^5.2.0"
-    wrap-ansi "^5.1.0"
-
-cliui@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-6.0.0.tgz#511d702c0c4e41ca156d7d0e96021f23e13225b1"
-  integrity sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==
-  dependencies:
-    string-width "^4.2.0"
-    strip-ansi "^6.0.0"
-    wrap-ansi "^6.2.0"
-
-clone-buffer@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/clone-buffer/-/clone-buffer-1.0.0.tgz#e3e25b207ac4e701af721e2cb5a16792cac3dc58"
-  integrity sha1-4+JbIHrE5wGvch4staFnksrD3Fg=
-
-clone-response@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/clone-response/-/clone-response-1.0.2.tgz#d1dc973920314df67fbeb94223b4ee350239e96b"
-  integrity sha1-0dyXOSAxTfZ/vrlCI7TuNQI56Ws=
-  dependencies:
-    mimic-response "^1.0.0"
-
-clone-stats@^0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/clone-stats/-/clone-stats-0.0.1.tgz#b88f94a82cf38b8791d58046ea4029ad88ca99d1"
-  integrity sha1-uI+UqCzzi4eR1YBG6kAprYjKmdE=
-
-clone@2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/clone/-/clone-2.1.1.tgz#d217d1e961118e3ac9a4b8bba3285553bf647cdb"
-  integrity sha1-0hfR6WERjjrJpLi7oyhVU79kfNs=
-
-clone@^1.0.0, clone@^1.0.2:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/clone/-/clone-1.0.4.tgz#da309cc263df15994c688ca902179ca3c7cd7c7e"
-  integrity sha1-2jCcwmPfFZlMaIypAheco8fNfH4=
-
-clone@^2.0.0, clone@^2.1.1:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/clone/-/clone-2.1.2.tgz#1b7f4b9f591f1e8f83670401600345a02887435f"
-  integrity sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18=
-
-code-point-at@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
-  integrity sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=
-
-color-convert@^1.9.0:
-  version "1.9.3"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
-  integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
-  dependencies:
-    color-name "1.1.3"
-
-color-convert@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
-  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
-  dependencies:
-    color-name "~1.1.4"
-
-color-logger@0.0.3:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/color-logger/-/color-logger-0.0.3.tgz#d9b22dd1d973e166b18bf313f9f481bba4df2018"
-  integrity sha1-2bIt0dlz4Waxi/MT+fSBu6TfIBg=
-
-color-logger@0.0.6:
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/color-logger/-/color-logger-0.0.6.tgz#e56245ef29822657110c7cb75a9cd786cb69ed1b"
-  integrity sha1-5WJF7ymCJlcRDHy3WpzXhstp7Rs=
-
-color-name@1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
-  integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==
-
-color-name@~1.1.4:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
-  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
-
-colorette@^1.2.1:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/colorette/-/colorette-1.2.2.tgz#cbcc79d5e99caea2dbf10eb3a26fd8b3e6acfa94"
-  integrity sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==
-
-colors@1.4.0, colors@^1.1.2, colors@^1.3.3:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/colors/-/colors-1.4.0.tgz#c50491479d4c1bdaed2c9ced32cf7c7dc2360f78"
-  integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==
-
-combined-stream@^1.0.6, combined-stream@^1.0.8, combined-stream@~1.0.6:
-  version "1.0.8"
-  resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
-  integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
-  dependencies:
-    delayed-stream "~1.0.0"
-
-command-exists@^1.2.8:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/command-exists/-/command-exists-1.2.9.tgz#c50725af3808c8ab0260fd60b01fbfa25b954f69"
-  integrity sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==
-
-commander@3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-3.0.2.tgz#6837c3fb677ad9933d1cfba42dd14d5117d6b39e"
-  integrity sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow==
-
-commander@^2.20.3:
-  version "2.20.3"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
-  integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
-
-component-emitter@1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.2.1.tgz#137918d6d78283f7df7a6b7c5a63e140e69425e6"
-  integrity sha1-E3kY1teCg/ffemt8WmPhQOaUJeY=
-
-concat-map@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
-  integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
-
-concat-stream@1.5.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.5.1.tgz#f3b80acf9e1f48e3875c0688b41b6c31602eea1c"
-  integrity sha1-87gKz54fSOOHXAaItBtsMWAu6hw=
-  dependencies:
-    inherits "~2.0.1"
-    readable-stream "~2.0.0"
-    typedarray "~0.0.5"
-
-concat-stream@^1.6.0, concat-stream@^1.6.2, concat-stream@~1.6.2:
-  version "1.6.2"
-  resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34"
-  integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==
-  dependencies:
-    buffer-from "^1.0.0"
-    inherits "^2.0.3"
-    readable-stream "^2.2.2"
-    typedarray "^0.0.6"
-
-configstore@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/configstore/-/configstore-4.0.0.tgz#5933311e95d3687efb592c528b922d9262d227e7"
-  integrity sha512-CmquAXFBocrzaSM8mtGPMM/HiWmyIpr4CcJl/rgY2uCObZ/S7cKU0silxslqJejl+t/T9HS8E0PUNQD81JGUEQ==
-  dependencies:
-    dot-prop "^4.1.0"
-    graceful-fs "^4.1.2"
-    make-dir "^1.0.0"
-    unique-string "^1.0.0"
-    write-file-atomic "^2.0.0"
-    xdg-basedir "^3.0.0"
-
-console-control-strings@^1.0.0, console-control-strings@~1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/console-control-strings/-/console-control-strings-1.1.0.tgz#3d7cf4464db6446ea644bf4b39507f9851008e8e"
-  integrity sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=
-
-constant-case@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/constant-case/-/constant-case-2.0.0.tgz#4175764d389d3fa9c8ecd29186ed6005243b6a46"
-  integrity sha1-QXV2TTidP6nI7NKRhu1gBSQ7akY=
-  dependencies:
-    snake-case "^2.1.0"
-    upper-case "^1.1.1"
-
-content-disposition@0.5.4:
-  version "0.5.4"
-  resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.4.tgz#8b82b4efac82512a02bb0b1dcec9d2c5e8eb5bfe"
-  integrity sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==
-  dependencies:
-    safe-buffer "5.2.1"
-
-content-hash@^2.5.2:
-  version "2.5.2"
-  resolved "https://registry.yarnpkg.com/content-hash/-/content-hash-2.5.2.tgz#bbc2655e7c21f14fd3bfc7b7d4bfe6e454c9e211"
-  integrity sha512-FvIQKy0S1JaWV10sMsA7TRx8bpU+pqPkhbsfvOJAdjRXvYxEckAwQWGwtRjiaJfh+E0DvcWUGqcdjwMGFjsSdw==
-  dependencies:
-    cids "^0.7.1"
-    multicodec "^0.5.5"
-    multihashes "^0.4.15"
-
-content-type@~1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/content-type/-/content-type-1.0.4.tgz#e138cc75e040c727b1966fe5e5f8c9aee256fe3b"
-  integrity sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==
-
-convert-source-map@1.X, convert-source-map@^1.5.1, convert-source-map@^1.7.0:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.7.0.tgz#17a2cb882d7f77d3490585e2ce6c524424a3a442"
-  integrity sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==
-  dependencies:
-    safe-buffer "~5.1.1"
-
-cookie-signature@1.0.6:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/cookie-signature/-/cookie-signature-1.0.6.tgz#e303a882b342cc3ee8ca513a79999734dab3ae2c"
-  integrity sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==
-
-cookie@0.5.0:
-  version "0.5.0"
-  resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.5.0.tgz#d1f5d71adec6558c58f389987c366aa47e994f8b"
-  integrity sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw==
-
-cookiejar@^2.1.1:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/cookiejar/-/cookiejar-2.1.2.tgz#dd8a235530752f988f9a0844f3fc589e3111125c"
-  integrity sha512-Mw+adcfzPxcPeI+0WlvRrr/3lGVO0bD75SxX6811cxSh1Wbxx7xZBGK1eVtDf6si8rg2lhnUjsVLMFMfbRIuwA==
-
-core-js-compat@^3.8.1:
-  version "3.9.1"
-  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.9.1.tgz#4e572acfe90aff69d76d8c37759d21a5c59bb455"
-  integrity sha512-jXAirMQxrkbiiLsCx9bQPJFA6llDadKMpYrBJQJ3/c4/vsPP/fAf29h24tviRlvwUL6AmY5CHLu2GvjuYviQqA==
-  dependencies:
-    browserslist "^4.16.3"
-    semver "7.0.0"
-
-core-js-pure@^3.10.2:
-  version "3.19.1"
-  resolved "https://registry.yarnpkg.com/core-js-pure/-/core-js-pure-3.19.1.tgz#edffc1fc7634000a55ba05e95b3f0fe9587a5aa4"
-  integrity sha512-Q0Knr8Es84vtv62ei6/6jXH/7izKmOrtrxH9WJTHLCMAVeU+8TF8z8Nr08CsH4Ot0oJKzBzJJL9SJBYIv7WlfQ==
-
-core-js@^2.4.0, core-js@^2.5.0:
-  version "2.6.12"
-  resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.6.12.tgz#d9333dfa7b065e347cc5682219d6f690859cc2ec"
-  integrity sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==
-
-core-util-is@1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
-  integrity sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==
-
-core-util-is@~1.0.0:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85"
-  integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==
-
-cors@^2.8.1, cors@^2.8.5:
-  version "2.8.5"
-  resolved "https://registry.yarnpkg.com/cors/-/cors-2.8.5.tgz#eac11da51592dd86b9f06f6e7ac293b3df875d29"
-  integrity sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==
-  dependencies:
-    object-assign "^4"
-    vary "^1"
-
-cosmiconfig@6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-6.0.0.tgz#da4fee853c52f6b1e6935f41c1a2fc50bd4a9982"
-  integrity sha512-xb3ZL6+L8b9JLLCx3ZdoZy4+2ECphCMo2PwqgP1tlfVq6M6YReyzBJtvWWtbDSpNr9hn96pkCiZqUcFEc+54Qg==
-  dependencies:
-    "@types/parse-json" "^4.0.0"
-    import-fresh "^3.1.0"
-    parse-json "^5.0.0"
-    path-type "^4.0.0"
-    yaml "^1.7.2"
-
-cosmiconfig@7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-7.0.1.tgz#714d756522cace867867ccb4474c5d01bbae5d6d"
-  integrity sha512-a1YWNUV2HwGimB7dU2s1wUMurNKjpx60HxBB6xUM8Re+2s1g1IIfJvFR0/iCF+XHdE0GMTKTuLR32UQff4TEyQ==
-  dependencies:
-    "@types/parse-json" "^4.0.0"
-    import-fresh "^3.2.1"
-    parse-json "^5.0.0"
-    path-type "^4.0.0"
-    yaml "^1.10.0"
-
-create-ecdh@^4.0.0:
-  version "4.0.4"
-  resolved "https://registry.yarnpkg.com/create-ecdh/-/create-ecdh-4.0.4.tgz#d6e7f4bffa66736085a0762fd3a632684dabcc4e"
-  integrity sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==
-  dependencies:
-    bn.js "^4.1.0"
-    elliptic "^6.5.3"
-
-create-hash@^1.1.0, create-hash@^1.1.2, create-hash@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/create-hash/-/create-hash-1.2.0.tgz#889078af11a63756bcfb59bd221996be3a9ef196"
-  integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==
-  dependencies:
-    cipher-base "^1.0.1"
-    inherits "^2.0.1"
-    md5.js "^1.3.4"
-    ripemd160 "^2.0.1"
-    sha.js "^2.4.0"
-
-create-hmac@^1.1.0, create-hmac@^1.1.4, create-hmac@^1.1.7:
-  version "1.1.7"
-  resolved "https://registry.yarnpkg.com/create-hmac/-/create-hmac-1.1.7.tgz#69170c78b3ab957147b2b8b04572e47ead2243ff"
-  integrity sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==
-  dependencies:
-    cipher-base "^1.0.3"
-    create-hash "^1.1.0"
-    inherits "^2.0.1"
-    ripemd160 "^2.0.0"
-    safe-buffer "^5.0.1"
-    sha.js "^2.4.8"
-
-create-require@^1.1.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
-  integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==
-
-cross-fetch@3.0.6, cross-fetch@^3.0.4:
-  version "3.0.6"
-  resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-3.0.6.tgz#3a4040bc8941e653e0e9cf17f29ebcd177d3365c"
-  integrity sha512-KBPUbqgFjzWlVcURG+Svp9TlhA5uliYtiNx/0r8nv0pdypeQCRJ9IaSIc3q/x3q8t3F75cHuwxVql1HFGHCNJQ==
-  dependencies:
-    node-fetch "2.6.1"
-
-cross-fetch@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-1.1.1.tgz#dede6865ae30f37eae62ac90ebb7bdac002b05a0"
-  integrity sha512-+VJE04+UfxxmBfcnmAu/lKor53RUCx/1ilOti4p+JgrnLQ4AZZIRoe2OEd76VaHyWQmQxqKnV+TaqjHC4r0HWw==
-  dependencies:
-    node-fetch "1.7.3"
-    whatwg-fetch "2.0.3"
-
-cross-fetch@^2.1.0, cross-fetch@^2.1.1:
-  version "2.2.3"
-  resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-2.2.3.tgz#e8a0b3c54598136e037f8650f8e823ccdfac198e"
-  integrity sha512-PrWWNH3yL2NYIb/7WF/5vFG3DCQiXDOVf8k3ijatbrtnwNuhMWLC7YF7uqf53tbTFDzHIUD8oITw4Bxt8ST3Nw==
-  dependencies:
-    node-fetch "2.1.2"
-    whatwg-fetch "2.0.4"
-
-cross-spawn@7.0.3, cross-spawn@^7.0.0, cross-spawn@^7.0.3:
-  version "7.0.3"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
-  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
-  dependencies:
-    path-key "^3.1.0"
-    shebang-command "^2.0.0"
-    which "^2.0.1"
-
-cross-spawn@^6.0.5:
-  version "6.0.5"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
-  integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
-  dependencies:
-    nice-try "^1.0.4"
-    path-key "^2.0.1"
-    semver "^5.5.0"
-    shebang-command "^1.2.0"
-    which "^1.2.9"
-
-crypto-browserify@3.12.0:
-  version "3.12.0"
-  resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.12.0.tgz#396cf9f3137f03e4b8e532c58f698254e00f80ec"
-  integrity sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==
-  dependencies:
-    browserify-cipher "^1.0.0"
-    browserify-sign "^4.0.0"
-    create-ecdh "^4.0.0"
-    create-hash "^1.1.0"
-    create-hmac "^1.1.0"
-    diffie-hellman "^5.0.0"
-    inherits "^2.0.1"
-    pbkdf2 "^3.0.3"
-    public-encrypt "^4.0.0"
-    randombytes "^2.0.0"
-    randomfill "^1.0.3"
-
-crypto-js@^3.1.9-1:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/crypto-js/-/crypto-js-3.3.0.tgz#846dd1cce2f68aacfa156c8578f926a609b7976b"
-  integrity sha512-DIT51nX0dCfKltpRiXV+/TVZq+Qq2NgF4644+K7Ttnla7zEzqc+kjJyiB96BHNyUTBxyjzRcZYpUdZa+QAqi6Q==
-
-crypto-random-string@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/crypto-random-string/-/crypto-random-string-1.0.0.tgz#a230f64f568310e1498009940790ec99545bca7e"
-  integrity sha1-ojD2T1aDEOFJgAmUB5DsmVRbyn4=
-
-css-select@^3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/css-select/-/css-select-3.1.2.tgz#d52cbdc6fee379fba97fb0d3925abbd18af2d9d8"
-  integrity sha512-qmss1EihSuBNWNNhHjxzxSfJoFBM/lERB/Q4EnsJQQC62R2evJDW481091oAdOr9uh46/0n4nrg0It5cAnj1RA==
-  dependencies:
-    boolbase "^1.0.0"
-    css-what "^4.0.0"
-    domhandler "^4.0.0"
-    domutils "^2.4.3"
-    nth-check "^2.0.0"
-
-css-select@~1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/css-select/-/css-select-1.2.0.tgz#2b3a110539c5355f1cd8d314623e870b121ec858"
-  integrity sha1-KzoRBTnFNV8c2NMUYj6HCxIeyFg=
-  dependencies:
-    boolbase "~1.0.0"
-    css-what "2.1"
-    domutils "1.5.1"
-    nth-check "~1.0.1"
-
-css-what@2.1:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/css-what/-/css-what-2.1.3.tgz#a6d7604573365fe74686c3f311c56513d88285f2"
-  integrity sha512-a+EPoD+uZiNfh+5fxw2nO9QwFa6nJe2Or35fGY6Ipw1R3R4AGz1d1TEZrCegvw2YTmZ0jXirGYlzxxpYSHwpEg==
-
-css-what@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/css-what/-/css-what-4.0.0.tgz#35e73761cab2eeb3d3661126b23d7aa0e8432233"
-  integrity sha512-teijzG7kwYfNVsUh2H/YN62xW3KK9YhXEgSlbxMlcyjPNvdKJqFx5lrwlJgoFP1ZHlB89iGDlo/JyshKeRhv5A==
-
-css@2.X:
-  version "2.2.4"
-  resolved "https://registry.yarnpkg.com/css/-/css-2.2.4.tgz#c646755c73971f2bba6a601e2cf2fd71b1298929"
-  integrity sha512-oUnjmWpy0niI3x/mPL8dVEI1l7MnG3+HHyRPHf+YFSbK+svOhXpmSOcDURUh2aOCgl2grzrOPt1nHLuCVFULLw==
-  dependencies:
-    inherits "^2.0.3"
-    source-map "^0.6.1"
-    source-map-resolve "^0.5.2"
-    urix "^0.1.0"
-
-cssfilter@0.0.10:
-  version "0.0.10"
-  resolved "https://registry.yarnpkg.com/cssfilter/-/cssfilter-0.0.10.tgz#c6d2672632a2e5c83e013e6864a42ce8defd20ae"
-  integrity sha1-xtJnJjKi5cg+AT5oZKQs6N79IK4=
-
-cssom@0.3.x, "cssom@>= 0.3.0 < 0.4.0":
-  version "0.3.8"
-  resolved "https://registry.yarnpkg.com/cssom/-/cssom-0.3.8.tgz#9f1276f5b2b463f2114d3f2c75250af8c1a36f4a"
-  integrity sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==
-
-"cssstyle@>= 0.2.29 < 0.3.0":
-  version "0.2.37"
-  resolved "https://registry.yarnpkg.com/cssstyle/-/cssstyle-0.2.37.tgz#541097234cb2513c83ceed3acddc27ff27987d54"
-  integrity sha1-VBCXI0yyUTyDzu06zdwn/yeYfVQ=
-  dependencies:
-    cssom "0.3.x"
-
-d@1, d@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/d/-/d-1.0.1.tgz#8698095372d58dbee346ffd0c7093f99f8f9eb5a"
-  integrity sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA==
-  dependencies:
-    es5-ext "^0.10.50"
-    type "^1.0.1"
-
-dashdash@^1.12.0:
-  version "1.14.1"
-  resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0"
-  integrity sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==
-  dependencies:
-    assert-plus "^1.0.0"
-
-dataloader@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/dataloader/-/dataloader-2.0.0.tgz#41eaf123db115987e21ca93c005cd7753c55fe6f"
-  integrity sha512-YzhyDAwA4TaQIhM5go+vCLmU0UikghC/t9DTQYZR2M/UvZ1MdOhPezSDZcjj9uqQJOMqjLcpWtyW2iNINdlatQ==
-
-debug-fabulous@0.0.X:
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/debug-fabulous/-/debug-fabulous-0.0.4.tgz#fa071c5d87484685424807421ca4b16b0b1a0763"
-  integrity sha1-+gccXYdIRoVCSAdCHKSxawsaB2M=
-  dependencies:
-    debug "2.X"
-    lazy-debug-legacy "0.0.X"
-    object-assign "4.1.0"
-
-debug@2.6.9, debug@2.X, debug@^2.2.0, debug@^2.6.8, debug@^2.6.9:
-  version "2.6.9"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
-  integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
-  dependencies:
-    ms "2.0.0"
-
-debug@3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"
-  integrity sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==
-  dependencies:
-    ms "2.0.0"
-
-debug@4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.1.1.tgz#3b72260255109c6b589cee050f1d516139664791"
-  integrity sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==
-  dependencies:
-    ms "^2.1.1"
-
-debug@4.3.4, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1, debug@^4.3.4:
-  version "4.3.4"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
-  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
-  dependencies:
-    ms "2.1.2"
-
-debug@^3.1.0, debug@^3.2.6:
-  version "3.2.7"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a"
-  integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
-  dependencies:
-    ms "^2.1.1"
-
-decamelize@^1.1.1, decamelize@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
-  integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=
-
-decode-uri-component@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.0.tgz#eb3913333458775cb84cd1a1fae062106bb87545"
-  integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=
-
-decompress-response@^3.2.0, decompress-response@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/decompress-response/-/decompress-response-3.3.0.tgz#80a4dd323748384bfa248083622aedec982adff3"
-  integrity sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=
-  dependencies:
-    mimic-response "^1.0.0"
-
-deep-extend@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac"
-  integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==
-
-deep-is@~0.1.3:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
-  integrity sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=
-
-defaults@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/defaults/-/defaults-1.0.3.tgz#c656051e9817d9ff08ed881477f3fe4019f3ef7d"
-  integrity sha512-s82itHOnYrN0Ib8r+z7laQz3sdE+4FP3d9Q7VLO7U+KRT+CR0GsWuyHxzdAY82I7cXv0G/twrqomTJLOssO5HA==
-  dependencies:
-    clone "^1.0.2"
-
-defer-to-connect@^1.0.1:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/defer-to-connect/-/defer-to-connect-1.1.3.tgz#331ae050c08dcf789f8c83a7b81f0ed94f4ac591"
-  integrity sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ==
-
-deferred-leveldown@~1.2.1:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/deferred-leveldown/-/deferred-leveldown-1.2.2.tgz#3acd2e0b75d1669924bc0a4b642851131173e1eb"
-  integrity sha512-uukrWD2bguRtXilKt6cAWKyoXrTSMo5m7crUdLfWQmu8kIm88w3QZoUL+6nhpfKVmhHANER6Re3sKoNoZ3IKMA==
-  dependencies:
-    abstract-leveldown "~2.6.0"
-
-deferred-leveldown@~5.0.0:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/deferred-leveldown/-/deferred-leveldown-5.0.1.tgz#1642eb18b535dfb2b6ac4d39fb10a9cbcfd13b09"
-  integrity sha512-BXohsvTedWOLkj2n/TY+yqVlrCWa2Zs8LSxh3uCAgFOru7/pjxKyZAexGa1j83BaKloER4PqUyQ9rGPJLt9bqA==
-  dependencies:
-    abstract-leveldown "~6.0.0"
-    inherits "^2.0.3"
-
-deferred-leveldown@~5.3.0:
-  version "5.3.0"
-  resolved "https://registry.yarnpkg.com/deferred-leveldown/-/deferred-leveldown-5.3.0.tgz#27a997ad95408b61161aa69bd489b86c71b78058"
-  integrity sha512-a59VOT+oDy7vtAbLRCZwWgxu2BaCfd5Hk7wxJd48ei7I+nsg8Orlb9CLG0PMZienk9BSUKgeAqkO2+Lw+1+Ukw==
-  dependencies:
-    abstract-leveldown "~6.2.1"
-    inherits "^2.0.3"
-
-define-properties@^1.1.2, define-properties@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1"
-  integrity sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==
-  dependencies:
-    object-keys "^1.0.12"
-
-delay@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/delay/-/delay-5.0.0.tgz#137045ef1b96e5071060dd5be60bf9334436bd1d"
-  integrity sha512-ReEBKkIfe4ya47wlPYf/gu5ib6yUG0/Aez0JQZQz94kiWtRQvZIQbTiehsnwHvLSWJnQdhVeqYue7Id1dKr0qw==
-
-delayed-stream@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
-  integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==
-
-delegates@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delegates/-/delegates-1.0.0.tgz#84c6e159b81904fdca59a0ef44cd870d31250f9a"
-  integrity sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=
-
-depd@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df"
-  integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==
-
-depd@~1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.2.tgz#9bcd52e14c097763e749b274c4346ed2e560b5a9"
-  integrity sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=
-
-deprecated-decorator@^0.1.6:
-  version "0.1.6"
-  resolved "https://registry.yarnpkg.com/deprecated-decorator/-/deprecated-decorator-0.1.6.tgz#00966317b7a12fe92f3cc831f7583af329b86c37"
-  integrity sha1-AJZjF7ehL+kvPMgx91g68ym4bDc=
-
-des.js@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/des.js/-/des.js-1.0.1.tgz#5382142e1bdc53f85d86d53e5f4aa7deb91e0843"
-  integrity sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==
-  dependencies:
-    inherits "^2.0.1"
-    minimalistic-assert "^1.0.0"
-
-destroy@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.2.0.tgz#4803735509ad8be552934c67df614f94e66fa015"
-  integrity sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==
-
-detect-indent@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-4.0.0.tgz#f76d064352cdf43a1cb6ce619c4ee3a9475de208"
-  integrity sha1-920GQ1LN9Docts5hnE7jqUdd4gg=
-  dependencies:
-    repeating "^2.0.0"
-
-detect-indent@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-5.0.0.tgz#3871cc0a6a002e8c3e5b3cf7f336264675f06b9d"
-  integrity sha1-OHHMCmoALow+Wzz38zYmRnXwa50=
-
-detect-libc@^1.0.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/detect-libc/-/detect-libc-1.0.3.tgz#fa137c4bd698edf55cd5cd02ac559f91a4c4ba9b"
-  integrity sha1-+hN8S9aY7fVc1c0CrFWfkaTEups=
-
-detect-newline@2.X:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-2.1.0.tgz#f41f1c10be4b00e87b5f13da680759f2c5bfd3e2"
-  integrity sha1-9B8cEL5LAOh7XxPaaAdZ8sW/0+I=
-
-dicer@0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/dicer/-/dicer-0.3.0.tgz#eacd98b3bfbf92e8ab5c2fdb71aaac44bb06b872"
-  integrity sha512-MdceRRWqltEG2dZqO769g27N/3PXfcKl04VhYnBlo2YhH7zPi88VebsjTKclaOyiuMaGU72hTfw3VkUitGcVCA==
-  dependencies:
-    streamsearch "0.1.2"
-
-diff@4.0.2, diff@^4.0.1:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
-  integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
-
-diffie-hellman@^5.0.0:
-  version "5.0.3"
-  resolved "https://registry.yarnpkg.com/diffie-hellman/-/diffie-hellman-5.0.3.tgz#40e8ee98f55a2149607146921c63e1ae5f3d2875"
-  integrity sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==
-  dependencies:
-    bn.js "^4.1.0"
-    miller-rabin "^4.0.0"
-    randombytes "^2.0.0"
-
-dir-glob@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
-  integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
-  dependencies:
-    path-type "^4.0.0"
-
-dns-over-http-resolver@^1.2.3:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/dns-over-http-resolver/-/dns-over-http-resolver-1.2.3.tgz#194d5e140a42153f55bb79ac5a64dd2768c36af9"
-  integrity sha512-miDiVSI6KSNbi4SVifzO/reD8rMnxgrlnkrlkugOLQpWQTe2qMdHsZp5DmfKjxNE+/T3VAAYLQUZMv9SMr6+AA==
-  dependencies:
-    debug "^4.3.1"
-    native-fetch "^3.0.0"
-    receptacle "^1.3.2"
-
-docker-compose@0.23.19:
-  version "0.23.19"
-  resolved "https://registry.yarnpkg.com/docker-compose/-/docker-compose-0.23.19.tgz#9947726e2fe67bdfa9e8efe1ff15aa0de2e10eb8"
-  integrity sha512-v5vNLIdUqwj4my80wxFDkNH+4S85zsRuH29SO7dCWVWPCMt/ohZBsGN6g6KXWifT0pzQ7uOxqEKCYCDPJ8Vz4g==
-  dependencies:
-    yaml "^1.10.2"
-
-docker-modem@^1.0.8:
-  version "1.0.9"
-  resolved "https://registry.yarnpkg.com/docker-modem/-/docker-modem-1.0.9.tgz#a1f13e50e6afb6cf3431b2d5e7aac589db6aaba8"
-  integrity sha512-lVjqCSCIAUDZPAZIeyM125HXfNvOmYYInciphNrLrylUtKyW66meAjSPXWchKVzoIYZx69TPnAepVSSkeawoIw==
-  dependencies:
-    JSONStream "1.3.2"
-    debug "^3.2.6"
-    readable-stream "~1.0.26-4"
-    split-ca "^1.0.0"
-
-dockerode@2.5.8:
-  version "2.5.8"
-  resolved "https://registry.yarnpkg.com/dockerode/-/dockerode-2.5.8.tgz#1b661e36e1e4f860e25f56e0deabe9f87f1d0acc"
-  integrity sha512-+7iOUYBeDTScmOmQqpUYQaE7F4vvIt6+gIZNHWhqAQEI887tiPFB9OvXI/HzQYqfUNvukMK+9myLW63oTJPZpw==
-  dependencies:
-    concat-stream "~1.6.2"
-    docker-modem "^1.0.8"
-    tar-fs "~1.16.3"
-
-dom-serializer@0:
-  version "0.2.2"
-  resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-0.2.2.tgz#1afb81f533717175d478655debc5e332d9f9bb51"
-  integrity sha512-2/xPb3ORsQ42nHYiSunXkDjPLBaEj/xTwUO4B7XCZQTRk7EBtTOPaygh10YAAh2OI1Qrp6NWfpAhzswj0ydt9g==
-  dependencies:
-    domelementtype "^2.0.1"
-    entities "^2.0.0"
-
-dom-serializer@^1.0.1, dom-serializer@~1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-1.2.0.tgz#3433d9136aeb3c627981daa385fc7f32d27c48f1"
-  integrity sha512-n6kZFH/KlCrqs/1GHMOd5i2fd/beQHuehKdWvNNffbGHTr/almdhuVvTVFb3V7fglz+nC50fFusu3lY33h12pA==
-  dependencies:
-    domelementtype "^2.0.1"
-    domhandler "^4.0.0"
-    entities "^2.0.0"
-
-dom-serializer@~0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-0.1.1.tgz#1ec4059e284babed36eec2941d4a970a189ce7c0"
-  integrity sha512-l0IU0pPzLWSHBcieZbpOKgkIn3ts3vAh7ZuFyXNwJxJXk/c4Gwj9xaTJwIDVQCXawWD0qb3IzMGH5rglQaO0XA==
-  dependencies:
-    domelementtype "^1.3.0"
-    entities "^1.1.1"
-
-dom-walk@^0.1.0:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/dom-walk/-/dom-walk-0.1.2.tgz#0c548bef048f4d1f2a97249002236060daa3fd84"
-  integrity sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w==
-
-domelementtype@1, domelementtype@^1.3.0, domelementtype@^1.3.1:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/domelementtype/-/domelementtype-1.3.1.tgz#d048c44b37b0d10a7f2a3d5fee3f4333d790481f"
-  integrity sha512-BSKB+TSpMpFI/HOxCNr1O8aMOTZ8hT3pM3GQ0w/mWRmkhEDSFJkkyzz4XQsBV44BChwGkrDfMyjVD0eA2aFV3w==
-
-domelementtype@^2.0.1, domelementtype@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/domelementtype/-/domelementtype-2.1.0.tgz#a851c080a6d1c3d94344aed151d99f669edf585e"
-  integrity sha512-LsTgx/L5VpD+Q8lmsXSHW2WpA+eBlZ9HPf3erD1IoPF00/3JKHZ3BknUVA2QGDNu69ZNmyFmCWBSO45XjYKC5w==
-
-domhandler@2.3:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/domhandler/-/domhandler-2.3.0.tgz#2de59a0822d5027fabff6f032c2b25a2a8abe738"
-  integrity sha1-LeWaCCLVAn+r/28DLCsloqir5zg=
-  dependencies:
-    domelementtype "1"
-
-domhandler@^2.3.0:
-  version "2.4.2"
-  resolved "https://registry.yarnpkg.com/domhandler/-/domhandler-2.4.2.tgz#8805097e933d65e85546f726d60f5eb88b44f803"
-  integrity sha512-JiK04h0Ht5u/80fdLMCEmV4zkNh2BcoMFBmZ/91WtYZ8qVXSKjiw7fXMgFPnHcSZgOo3XdinHvmnDUeMf5R4wA==
-  dependencies:
-    domelementtype "1"
-
-domhandler@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/domhandler/-/domhandler-4.0.0.tgz#01ea7821de996d85f69029e81fa873c21833098e"
-  integrity sha512-KPTbnGQ1JeEMQyO1iYXoagsI6so/C96HZiFyByU3T6iAzpXn8EGEvct6unm1ZGoed8ByO2oirxgwxBmqKF9haA==
-  dependencies:
-    domelementtype "^2.1.0"
-
-domutils@1.5, domutils@1.5.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/domutils/-/domutils-1.5.1.tgz#dcd8488a26f563d61079e48c9f7b7e32373682cf"
-  integrity sha1-3NhIiib1Y9YQeeSMn3t+Mjc2gs8=
-  dependencies:
-    dom-serializer "0"
-    domelementtype "1"
-
-domutils@^1.5.1:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/domutils/-/domutils-1.7.0.tgz#56ea341e834e06e6748af7a1cb25da67ea9f8c2a"
-  integrity sha512-Lgd2XcJ/NjEw+7tFvfKxOzCYKZsdct5lczQ2ZaQY8Djz7pfAD3Gbp8ySJWtreII/vDlMVmxwa6pHmdxIYgttDg==
-  dependencies:
-    dom-serializer "0"
-    domelementtype "1"
-
-domutils@^2.4.3, domutils@^2.4.4:
-  version "2.4.4"
-  resolved "https://registry.yarnpkg.com/domutils/-/domutils-2.4.4.tgz#282739c4b150d022d34699797369aad8d19bbbd3"
-  integrity sha512-jBC0vOsECI4OMdD0GC9mGn7NXPLb+Qt6KW1YDQzeQYRUFKmNG8lh7mO5HiELfr+lLQE7loDVI4QcAxV80HS+RA==
-  dependencies:
-    dom-serializer "^1.0.1"
-    domelementtype "^2.0.1"
-    domhandler "^4.0.0"
-
-dot-case@^2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-2.1.1.tgz#34dcf37f50a8e93c2b3bca8bb7fb9155c7da3bee"
-  integrity sha1-NNzzf1Co6TwrO8qLt/uRVcfaO+4=
-  dependencies:
-    no-case "^2.2.0"
-
-dot-prop@^4.1.0:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-4.2.1.tgz#45884194a71fc2cda71cbb4bceb3a4dd2f433ba4"
-  integrity sha512-l0p4+mIuJIua0mhxGoh4a+iNL9bmeK5DvnSVQa6T0OhrVmaEa1XScX5Etc673FePCJOArq/4Pa2cLGODUWTPOQ==
-  dependencies:
-    is-obj "^1.0.0"
-
-double-ended-queue@2.1.0-0:
-  version "2.1.0-0"
-  resolved "https://registry.yarnpkg.com/double-ended-queue/-/double-ended-queue-2.1.0-0.tgz#103d3527fd31528f40188130c841efdd78264e5c"
-  integrity sha1-ED01J/0xUo9AGIEwyEHv3XgmTlw=
-
-duplexer3@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/duplexer3/-/duplexer3-0.1.4.tgz#ee01dd1cac0ed3cbc7fdbea37dc0a8f1ce002ce2"
-  integrity sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=
-
-duplexify@^3.2.0:
-  version "3.7.1"
-  resolved "https://registry.yarnpkg.com/duplexify/-/duplexify-3.7.1.tgz#2a4df5317f6ccfd91f86d6fd25d8d8a103b88309"
-  integrity sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==
-  dependencies:
-    end-of-stream "^1.0.0"
-    inherits "^2.0.1"
-    readable-stream "^2.0.0"
-    stream-shift "^1.0.0"
-
-ecc-jsbn@~0.1.1:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9"
-  integrity sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==
-  dependencies:
-    jsbn "~0.1.0"
-    safer-buffer "^2.1.0"
-
-ee-first@1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d"
-  integrity sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==
-
-ejs@3.1.6:
-  version "3.1.6"
-  resolved "https://registry.yarnpkg.com/ejs/-/ejs-3.1.6.tgz#5bfd0a0689743bb5268b3550cceeebbc1702822a"
-  integrity sha512-9lt9Zse4hPucPkoP7FHDF0LQAlGyF9JVpnClFLFH3aSSbxmyoqINRpp/9wePWJTUl4KOQwRL72Iw3InHPDkoGw==
-  dependencies:
-    jake "^10.6.1"
-
-ejs@^2.6.1:
-  version "2.7.4"
-  resolved "https://registry.yarnpkg.com/ejs/-/ejs-2.7.4.tgz#48661287573dcc53e366c7a1ae52c3a120eec9ba"
-  integrity sha512-7vmuyh5+kuUyJKePhQfRQBhXV5Ce+RnaeeQArKu1EAMpL3WbgMt5WG6uQZpEVvYSSsxMXRKOewtDk9RaTKXRlA==
-
-ejs@^3.1.8:
-  version "3.1.9"
-  resolved "https://registry.yarnpkg.com/ejs/-/ejs-3.1.9.tgz#03c9e8777fe12686a9effcef22303ca3d8eeb361"
-  integrity sha512-rC+QVNMJWv+MtPgkt0y+0rVEIdbtxVADApW9JXrUVlzHetgcyczP/E7DJmWJ4fJCZF2cPcBk0laWO9ZHMG3DmQ==
-  dependencies:
-    jake "^10.8.5"
-
-electron-fetch@^1.7.2:
-  version "1.9.1"
-  resolved "https://registry.yarnpkg.com/electron-fetch/-/electron-fetch-1.9.1.tgz#e28bfe78d467de3f2dec884b1d72b8b05322f30f"
-  integrity sha512-M9qw6oUILGVrcENMSRRefE1MbHPIz0h79EKIeJWK9v563aT9Qkh8aEHPO1H5vi970wPirNY+jO9OpFoLiMsMGA==
-  dependencies:
-    encoding "^0.1.13"
-
-electron-to-chromium@^1.3.649:
-  version "1.3.683"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.683.tgz#2c9ab53ff5275cf3dd49278af714d0f8975204f7"
-  integrity sha512-8mFfiAesXdEdE0DhkMKO7W9U6VU/9T3VTWwZ+4g84/YMP4kgwgFtQgUxuu7FUMcvSeKSNhFQNU+WZ68BQTLT5A==
-
-elliptic@6.5.3:
-  version "6.5.3"
-  resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.3.tgz#cb59eb2efdaf73a0bd78ccd7015a62ad6e0f93d6"
-  integrity sha512-IMqzv5wNQf+E6aHeIqATs0tOLeOTwj1QKbRcS3jBbYkl5oLAserA8yJTT7/VyHUYG91PRmPyeQDObKLPpeS4dw==
-  dependencies:
-    bn.js "^4.4.0"
-    brorand "^1.0.1"
-    hash.js "^1.0.0"
-    hmac-drbg "^1.0.0"
-    inherits "^2.0.1"
-    minimalistic-assert "^1.0.0"
-    minimalistic-crypto-utils "^1.0.0"
-
-elliptic@6.5.4, elliptic@^6.4.0, elliptic@^6.5.2, elliptic@^6.5.3, elliptic@^6.5.4:
-  version "6.5.4"
-  resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.4.tgz#da37cebd31e79a1367e941b592ed1fbebd58abbb"
-  integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==
-  dependencies:
-    bn.js "^4.11.9"
-    brorand "^1.1.0"
-    hash.js "^1.0.0"
-    hmac-drbg "^1.0.1"
-    inherits "^2.0.4"
-    minimalistic-assert "^1.0.1"
-    minimalistic-crypto-utils "^1.0.1"
-
-emittery@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/emittery/-/emittery-0.4.1.tgz#abe9d3297389ba424ac87e53d1c701962ce7433d"
-  integrity sha512-r4eRSeStEGf6M5SKdrQhhLK5bOwOBxQhIE3YSTnZE3GpKiLfnnhE+tPtrJE79+eDJgm39BM6LSoI8SCx4HbwlQ==
-
-emoji-regex@^7.0.1:
-  version "7.0.3"
-  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-7.0.3.tgz#933a04052860c85e83c122479c4748a8e4c72156"
-  integrity sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==
-
-emoji-regex@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
-  integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
-
-encodeurl@~1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.2.tgz#ad3ff4c86ec2d029322f5a02c3a9a606c95b3f59"
-  integrity sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==
-
-encoding-down@^6.3.0:
-  version "6.3.0"
-  resolved "https://registry.yarnpkg.com/encoding-down/-/encoding-down-6.3.0.tgz#b1c4eb0e1728c146ecaef8e32963c549e76d082b"
-  integrity sha512-QKrV0iKR6MZVJV08QY0wp1e7vF6QbhnbQhb07bwpEyuz4uZiZgPlEGdkCROuFkUwdxlFaiPIhjyarH1ee/3vhw==
-  dependencies:
-    abstract-leveldown "^6.2.1"
-    inherits "^2.0.3"
-    level-codec "^9.0.0"
-    level-errors "^2.0.0"
-
-encoding@^0.1.11, encoding@^0.1.13:
-  version "0.1.13"
-  resolved "https://registry.yarnpkg.com/encoding/-/encoding-0.1.13.tgz#56574afdd791f54a8e9b2785c0582a2d26210fa9"
-  integrity sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==
-  dependencies:
-    iconv-lite "^0.6.2"
-
-end-of-stream@^1.0.0, end-of-stream@^1.1.0:
-  version "1.4.4"
-  resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0"
-  integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
-  dependencies:
-    once "^1.4.0"
-
-end-stream@~0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/end-stream/-/end-stream-0.1.0.tgz#32003f3f438a2b0143168137f8fa6e9866c81ed5"
-  integrity sha1-MgA/P0OKKwFDFoE3+PpumGbIHtU=
-  dependencies:
-    write-stream "~0.4.3"
-
-enquirer@2.3.4:
-  version "2.3.4"
-  resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.4.tgz#c608f2e1134c7f68c1c9ee056de13f9b31076de9"
-  integrity sha512-pkYrrDZumL2VS6VBGDhqbajCM2xpkUNLuKfGPjfKaSIBKYopQbqEFyrOkRMIb2HDR/rO1kGhEt/5twBwtzKBXw==
-  dependencies:
-    ansi-colors "^3.2.1"
-
-enquirer@2.3.6:
-  version "2.3.6"
-  resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d"
-  integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==
-  dependencies:
-    ansi-colors "^4.1.1"
-
-entities@1.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/entities/-/entities-1.0.0.tgz#b2987aa3821347fcde642b24fdfc9e4fb712bf26"
-  integrity sha1-sph6o4ITR/zeZCsk/fyeT7cSvyY=
-
-entities@^1.1.1, entities@~1.1.1:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/entities/-/entities-1.1.2.tgz#bdfa735299664dfafd34529ed4f8522a275fea56"
-  integrity sha512-f2LZMYl1Fzu7YSBKg+RoROelpOaNrcGmE9AZubeDfrCEia483oW4MI4VyFd5VNHIgQ/7qm1I0wUHK1eJnn2y2w==
-
-entities@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/entities/-/entities-2.2.0.tgz#098dc90ebb83d8dffa089d55256b351d34c4da55"
-  integrity sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==
-
-entities@~2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/entities/-/entities-2.1.0.tgz#992d3129cf7df6870b96c57858c249a120f8b8b5"
-  integrity sha512-hCx1oky9PFrJ611mf0ifBLBRW8lUUVRlFolb5gWRfIELabBlbp9xZvrqZLZAs+NxFnbfQoeGd8wDkygjg7U85w==
-
-err-code@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/err-code/-/err-code-3.0.1.tgz#a444c7b992705f2b120ee320b09972eef331c920"
-  integrity sha512-GiaH0KJUewYok+eeY05IIgjtAe4Yltygk9Wqp1V5yVWLdhf0hYZchRjNIT9bb0mSwRcIusT3cx7PJUf3zEIfUA==
-
-errno@~0.1.1:
-  version "0.1.8"
-  resolved "https://registry.yarnpkg.com/errno/-/errno-0.1.8.tgz#8bb3e9c7d463be4976ff888f76b4809ebc2e811f"
-  integrity sha512-dJ6oBr5SQ1VSd9qkk7ByRgb/1SH4JZjCHSW/mr63/QcXO9zLVxvJ6Oy13nio03rxpSnVDDjFor75SjVeZWPW/A==
-  dependencies:
-    prr "~1.0.1"
-
-error-ex@^1.2.0, error-ex@^1.3.1:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
-  integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
-  dependencies:
-    is-arrayish "^0.2.1"
-
-es-abstract@^1.17.0-next.1, es-abstract@^1.18.0-next.1, es-abstract@^1.18.0-next.2:
-  version "1.18.0"
-  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.18.0.tgz#ab80b359eecb7ede4c298000390bc5ac3ec7b5a4"
-  integrity sha512-LJzK7MrQa8TS0ja2w3YNLzUgJCGPdPOV1yVvezjNnS89D+VR08+Szt2mz3YB2Dck/+w5tfIq/RoUAFqJJGM2yw==
-  dependencies:
-    call-bind "^1.0.2"
-    es-to-primitive "^1.2.1"
-    function-bind "^1.1.1"
-    get-intrinsic "^1.1.1"
-    has "^1.0.3"
-    has-symbols "^1.0.2"
-    is-callable "^1.2.3"
-    is-negative-zero "^2.0.1"
-    is-regex "^1.1.2"
-    is-string "^1.0.5"
-    object-inspect "^1.9.0"
-    object-keys "^1.1.1"
-    object.assign "^4.1.2"
-    string.prototype.trimend "^1.0.4"
-    string.prototype.trimstart "^1.0.4"
-    unbox-primitive "^1.0.0"
-
-es-abstract@^1.19.1:
-  version "1.19.1"
-  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.19.1.tgz#d4885796876916959de78edaa0df456627115ec3"
-  integrity sha512-2vJ6tjA/UfqLm2MPs7jxVybLoB8i1t1Jd9R3kISld20sIxPcTbLuggQOUxeWeAvIUkduv/CfMjuh4WmiXr2v9w==
-  dependencies:
-    call-bind "^1.0.2"
-    es-to-primitive "^1.2.1"
-    function-bind "^1.1.1"
-    get-intrinsic "^1.1.1"
-    get-symbol-description "^1.0.0"
-    has "^1.0.3"
-    has-symbols "^1.0.2"
-    internal-slot "^1.0.3"
-    is-callable "^1.2.4"
-    is-negative-zero "^2.0.1"
-    is-regex "^1.1.4"
-    is-shared-array-buffer "^1.0.1"
-    is-string "^1.0.7"
-    is-weakref "^1.0.1"
-    object-inspect "^1.11.0"
-    object-keys "^1.1.1"
-    object.assign "^4.1.2"
-    string.prototype.trimend "^1.0.4"
-    string.prototype.trimstart "^1.0.4"
-    unbox-primitive "^1.0.1"
-
-es-array-method-boxes-properly@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz#873f3e84418de4ee19c5be752990b2e44718d09e"
-  integrity sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==
-
-es-get-iterator@^1.0.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/es-get-iterator/-/es-get-iterator-1.1.2.tgz#9234c54aba713486d7ebde0220864af5e2b283f7"
-  integrity sha512-+DTO8GYwbMCwbywjimwZMHp8AuYXOS2JZFWoi2AlPOS3ebnII9w/NLpNZtA7A0YLaVDw+O7KFCeoIV7OPvM7hQ==
-  dependencies:
-    call-bind "^1.0.2"
-    get-intrinsic "^1.1.0"
-    has-symbols "^1.0.1"
-    is-arguments "^1.1.0"
-    is-map "^2.0.2"
-    is-set "^2.0.2"
-    is-string "^1.0.5"
-    isarray "^2.0.5"
-
-es-to-primitive@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.1.tgz#e55cd4c9cdc188bcefb03b366c736323fc5c898a"
-  integrity sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==
-  dependencies:
-    is-callable "^1.1.4"
-    is-date-object "^1.0.1"
-    is-symbol "^1.0.2"
-
-es5-ext@^0.10.35, es5-ext@^0.10.50:
-  version "0.10.53"
-  resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.53.tgz#93c5a3acfdbef275220ad72644ad02ee18368de1"
-  integrity sha512-Xs2Stw6NiNHWypzRTY1MtaG/uJlwCk8kH81920ma8mvN8Xq1gsfhZvpkImLQArw8AHnv8MT2I45J3c0R8slE+Q==
-  dependencies:
-    es6-iterator "~2.0.3"
-    es6-symbol "~3.1.3"
-    next-tick "~1.0.0"
-
-es6-denodeify@^0.1.1:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/es6-denodeify/-/es6-denodeify-0.1.5.tgz#31d4d5fe9c5503e125460439310e16a2a3f39c1f"
-  integrity sha1-MdTV/pxVA+ElRgQ5MQ4WoqPznB8=
-
-es6-iterator@~2.0.3:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/es6-iterator/-/es6-iterator-2.0.3.tgz#a7de889141a05a94b0854403b2d0a0fbfa98f3b7"
-  integrity sha1-p96IkUGgWpSwhUQDstCg+/qY87c=
-  dependencies:
-    d "1"
-    es5-ext "^0.10.35"
-    es6-symbol "^3.1.1"
-
-es6-promise@^4.0.3:
-  version "4.2.8"
-  resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-4.2.8.tgz#4eb21594c972bc40553d276e510539143db53e0a"
-  integrity sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==
-
-es6-promisify@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/es6-promisify/-/es6-promisify-5.0.0.tgz#5109d62f3e56ea967c4b63505aef08291c8a5203"
-  integrity sha512-C+d6UdsYDk0lMebHNR4S2NybQMMngAOnOwYBQjTOiv0MkoJMP0Myw2mgpDLBcpfCmRLxyFqYhS/CfOENq4SJhQ==
-  dependencies:
-    es6-promise "^4.0.3"
-
-es6-symbol@^3.1.1, es6-symbol@~3.1.3:
-  version "3.1.3"
-  resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.3.tgz#bad5d3c1bcdac28269f4cb331e431c78ac705d18"
-  integrity sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA==
-  dependencies:
-    d "^1.0.1"
-    ext "^1.1.2"
-
-escalade@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40"
-  integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==
-
-escape-html@1.0.3, escape-html@~1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988"
-  integrity sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=
-
-escape-string-regexp@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
-  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
-
-escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
-  integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
-
-escodegen@^1.6.1:
-  version "1.14.3"
-  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.14.3.tgz#4e7b81fba61581dc97582ed78cab7f0e8d63f503"
-  integrity sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==
-  dependencies:
-    esprima "^4.0.1"
-    estraverse "^4.2.0"
-    esutils "^2.0.2"
-    optionator "^0.8.1"
-  optionalDependencies:
-    source-map "~0.6.1"
-
-esdoc@^1.0.4:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/esdoc/-/esdoc-1.1.0.tgz#07d40ebf791764cd537929c29111e20a857624f3"
-  integrity sha512-vsUcp52XJkOWg9m1vDYplGZN2iDzvmjDL5M/Mp8qkoDG3p2s0yIQCIjKR5wfPBaM3eV14a6zhQNYiNTCVzPnxA==
-  dependencies:
-    babel-generator "6.26.1"
-    babel-traverse "6.26.0"
-    babylon "6.18.0"
-    cheerio "1.0.0-rc.2"
-    color-logger "0.0.6"
-    escape-html "1.0.3"
-    fs-extra "5.0.0"
-    ice-cap "0.0.4"
-    marked "0.3.19"
-    minimist "1.2.0"
-    taffydb "2.7.3"
-
-esprima@^4.0.0, esprima@^4.0.1, esprima@~4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
-  integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
-
-estraverse@^4.2.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"
-  integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
-
-esutils@^2.0.2:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
-  integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
-
-etag@~1.8.1:
-  version "1.8.1"
-  resolved "https://registry.yarnpkg.com/etag/-/etag-1.8.1.tgz#41ae2eeb65efa62268aebfea83ac7d79299b0887"
-  integrity sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==
-
-eth-block-tracker@^4.4.2:
-  version "4.4.3"
-  resolved "https://registry.yarnpkg.com/eth-block-tracker/-/eth-block-tracker-4.4.3.tgz#766a0a0eb4a52c867a28328e9ae21353812cf626"
-  integrity sha512-A8tG4Z4iNg4mw5tP1Vung9N9IjgMNqpiMoJ/FouSFwNCGHv2X0mmOYwtQOJzki6XN7r7Tyo01S29p7b224I4jw==
-  dependencies:
-    "@babel/plugin-transform-runtime" "^7.5.5"
-    "@babel/runtime" "^7.5.5"
-    eth-query "^2.1.0"
-    json-rpc-random-id "^1.0.1"
-    pify "^3.0.0"
-    safe-event-emitter "^1.0.1"
-
-eth-ens-namehash@2.0.8, eth-ens-namehash@^2.0.0:
-  version "2.0.8"
-  resolved "https://registry.yarnpkg.com/eth-ens-namehash/-/eth-ens-namehash-2.0.8.tgz#229ac46eca86d52e0c991e7cb2aef83ff0f68bcf"
-  integrity sha1-IprEbsqG1S4MmR58sq74P/D2i88=
-  dependencies:
-    idna-uts46-hx "^2.3.1"
-    js-sha3 "^0.5.7"
-
-eth-json-rpc-errors@^1.0.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/eth-json-rpc-errors/-/eth-json-rpc-errors-1.1.1.tgz#148377ef55155585981c21ff574a8937f9d6991f"
-  integrity sha512-WT5shJ5KfNqHi9jOZD+ID8I1kuYWNrigtZat7GOQkvwo99f8SzAVaEcWhJUv656WiZOAg3P1RiJQANtUmDmbIg==
-  dependencies:
-    fast-safe-stringify "^2.0.6"
-
-eth-json-rpc-errors@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/eth-json-rpc-errors/-/eth-json-rpc-errors-2.0.2.tgz#c1965de0301fe941c058e928bebaba2e1285e3c4"
-  integrity sha512-uBCRM2w2ewusRHGxN8JhcuOb2RN3ueAOYH/0BhqdFmQkZx5lj5+fLKTz0mIVOzd4FG5/kUksCzCD7eTEim6gaA==
-  dependencies:
-    fast-safe-stringify "^2.0.6"
-
-eth-lib@0.2.7:
-  version "0.2.7"
-  resolved "https://registry.yarnpkg.com/eth-lib/-/eth-lib-0.2.7.tgz#2f93f17b1e23aec3759cd4a3fe20c1286a3fc1ca"
-  integrity sha1-L5Pxex4jrsN1nNSj/iDBKGo/wco=
-  dependencies:
-    bn.js "^4.11.6"
-    elliptic "^6.4.0"
-    xhr-request-promise "^0.1.2"
-
-eth-lib@0.2.8, eth-lib@^0.2.8:
-  version "0.2.8"
-  resolved "https://registry.yarnpkg.com/eth-lib/-/eth-lib-0.2.8.tgz#b194058bef4b220ad12ea497431d6cb6aa0623c8"
-  integrity sha512-ArJ7x1WcWOlSpzdoTBX8vkwlkSQ85CjjifSZtV4co64vWxSV8geWfPI9x4SVYu3DSxnX4yWFVTtGL+j9DUFLNw==
-  dependencies:
-    bn.js "^4.11.6"
-    elliptic "^6.4.0"
-    xhr-request-promise "^0.1.2"
-
-eth-lib@^0.1.26:
-  version "0.1.29"
-  resolved "https://registry.yarnpkg.com/eth-lib/-/eth-lib-0.1.29.tgz#0c11f5060d42da9f931eab6199084734f4dbd1d9"
-  integrity sha512-bfttrr3/7gG4E02HoWTDUcDDslN003OlOoBxk9virpAZQ1ja/jDgwkWB8QfJF7ojuEowrqy+lzp9VcJG7/k5bQ==
-  dependencies:
-    bn.js "^4.11.6"
-    elliptic "^6.4.0"
-    nano-json-stream-parser "^0.1.2"
-    servify "^0.1.12"
-    ws "^3.0.0"
-    xhr-request-promise "^0.1.2"
-
-eth-query@^2.1.0, eth-query@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/eth-query/-/eth-query-2.1.2.tgz#d6741d9000106b51510c72db92d6365456a6da5e"
-  integrity sha1-1nQdkAAQa1FRDHLbktY2VFam2l4=
-  dependencies:
-    json-rpc-random-id "^1.0.0"
-    xtend "^4.0.1"
-
-eth-rpc-errors@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/eth-rpc-errors/-/eth-rpc-errors-3.0.0.tgz#d7b22653c70dbf9defd4ef490fd08fe70608ca10"
-  integrity sha512-iPPNHPrLwUlR9xCSYm7HHQjWBasor3+KZfRvwEWxMz3ca0yqnlBeJrnyphkGIXZ4J7AMAaOLmwy4AWhnxOiLxg==
-  dependencies:
-    fast-safe-stringify "^2.0.6"
-
-ethereum-bloom-filters@^1.0.6:
-  version "1.0.10"
-  resolved "https://registry.yarnpkg.com/ethereum-bloom-filters/-/ethereum-bloom-filters-1.0.10.tgz#3ca07f4aed698e75bd134584850260246a5fed8a"
-  integrity sha512-rxJ5OFN3RwjQxDcFP2Z5+Q9ho4eIdEmSc2ht0fCu8Se9nbXjZ7/031uXoUYJ87KHCOdVeiUuwSnoS7hmYAGVHA==
-  dependencies:
-    js-sha3 "^0.8.0"
-
-ethereum-common@0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/ethereum-common/-/ethereum-common-0.2.0.tgz#13bf966131cce1eeade62a1b434249bb4cb120ca"
-  integrity sha512-XOnAR/3rntJgbCdGhqdaLIxDLWKLmsZOGhHdBKadEr6gEnJLH52k93Ou+TUdFaPN3hJc3isBZBal3U/XZ15abA==
-
-ethereum-common@^0.0.18:
-  version "0.0.18"
-  resolved "https://registry.yarnpkg.com/ethereum-common/-/ethereum-common-0.0.18.tgz#2fdc3576f232903358976eb39da783213ff9523f"
-  integrity sha1-L9w1dvIykDNYl26znaeDIT/5Uj8=
-
-ethereum-cryptography@^0.1.3:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz#8d6143cfc3d74bf79bbd8edecdf29e4ae20dd191"
-  integrity sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==
-  dependencies:
-    "@types/pbkdf2" "^3.0.0"
-    "@types/secp256k1" "^4.0.1"
-    blakejs "^1.1.0"
-    browserify-aes "^1.2.0"
-    bs58check "^2.1.2"
-    create-hash "^1.2.0"
-    create-hmac "^1.1.7"
-    hash.js "^1.1.7"
-    keccak "^3.0.0"
-    pbkdf2 "^3.0.17"
-    randombytes "^2.1.0"
-    safe-buffer "^5.1.2"
-    scrypt-js "^3.0.0"
-    secp256k1 "^4.0.1"
-    setimmediate "^1.0.5"
-
-ethereum-ens@^0.8.0:
-  version "0.8.0"
-  resolved "https://registry.yarnpkg.com/ethereum-ens/-/ethereum-ens-0.8.0.tgz#6d0f79acaa61fdbc87d2821779c4e550243d4c57"
-  integrity sha512-a8cBTF4AWw1Q1Y37V1LSCS9pRY4Mh3f8vCg5cbXCCEJ3eno1hbI/+Ccv9SZLISYpqQhaglP3Bxb/34lS4Qf7Bg==
-  dependencies:
-    bluebird "^3.4.7"
-    eth-ens-namehash "^2.0.0"
-    js-sha3 "^0.5.7"
-    pako "^1.0.4"
-    underscore "^1.8.3"
-    web3 "^1.0.0-beta.34"
-
-ethereum-protocol@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/ethereum-protocol/-/ethereum-protocol-1.0.1.tgz#b7d68142f4105e0ae7b5e178cf42f8d4dc4b93cf"
-  integrity sha512-3KLX1mHuEsBW0dKG+c6EOJS1NBNqdCICvZW9sInmZTt5aY0oxmHVggYRE0lJu1tcnMD1K+AKHdLi6U43Awm1Vg==
-
-ethereumjs-abi@^0.6.8:
-  version "0.6.8"
-  resolved "https://registry.yarnpkg.com/ethereumjs-abi/-/ethereumjs-abi-0.6.8.tgz#71bc152db099f70e62f108b7cdfca1b362c6fcae"
-  integrity sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==
-  dependencies:
-    bn.js "^4.11.8"
-    ethereumjs-util "^6.0.0"
-
-ethereumjs-account@^2.0.3:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/ethereumjs-account/-/ethereumjs-account-2.0.5.tgz#eeafc62de544cb07b0ee44b10f572c9c49e00a84"
-  integrity sha512-bgDojnXGjhMwo6eXQC0bY6UK2liSFUSMwwylOmQvZbSl/D7NXQ3+vrGO46ZeOgjGfxXmgIeVNDIiHw7fNZM4VA==
-  dependencies:
-    ethereumjs-util "^5.0.0"
-    rlp "^2.0.0"
-    safe-buffer "^5.1.1"
-
-ethereumjs-block@^1.2.2, ethereumjs-block@^1.6.0:
-  version "1.7.1"
-  resolved "https://registry.yarnpkg.com/ethereumjs-block/-/ethereumjs-block-1.7.1.tgz#78b88e6cc56de29a6b4884ee75379b6860333c3f"
-  integrity sha512-B+sSdtqm78fmKkBq78/QLKJbu/4Ts4P2KFISdgcuZUPDm9x+N7qgBPIIFUGbaakQh8bzuquiRVbdmvPKqbILRg==
-  dependencies:
-    async "^2.0.1"
-    ethereum-common "0.2.0"
-    ethereumjs-tx "^1.2.2"
-    ethereumjs-util "^5.0.0"
-    merkle-patricia-tree "^2.1.2"
-
-ethereumjs-block@~2.2.0:
-  version "2.2.2"
-  resolved "https://registry.yarnpkg.com/ethereumjs-block/-/ethereumjs-block-2.2.2.tgz#c7654be7e22df489fda206139ecd63e2e9c04965"
-  integrity sha512-2p49ifhek3h2zeg/+da6XpdFR3GlqY3BIEiqxGF8j9aSRIgkb7M1Ky+yULBKJOu8PAZxfhsYA+HxUk2aCQp3vg==
-  dependencies:
-    async "^2.0.1"
-    ethereumjs-common "^1.5.0"
-    ethereumjs-tx "^2.1.1"
-    ethereumjs-util "^5.0.0"
-    merkle-patricia-tree "^2.1.2"
-
-ethereumjs-common@^1.1.0, ethereumjs-common@^1.3.2, ethereumjs-common@^1.5.0:
-  version "1.5.2"
-  resolved "https://registry.yarnpkg.com/ethereumjs-common/-/ethereumjs-common-1.5.2.tgz#2065dbe9214e850f2e955a80e650cb6999066979"
-  integrity sha512-hTfZjwGX52GS2jcVO6E2sx4YuFnf0Fhp5ylo4pEPhEffNln7vS59Hr5sLnp3/QCazFLluuBZ+FZ6J5HTp0EqCA==
-
-ethereumjs-tx@^1.0.0, ethereumjs-tx@^1.2.0, ethereumjs-tx@^1.2.2, ethereumjs-tx@^1.3.7:
-  version "1.3.7"
-  resolved "https://registry.yarnpkg.com/ethereumjs-tx/-/ethereumjs-tx-1.3.7.tgz#88323a2d875b10549b8347e09f4862b546f3d89a"
-  integrity sha512-wvLMxzt1RPhAQ9Yi3/HKZTn0FZYpnsmQdbKYfUUpi4j1SEIcbkd9tndVjcPrufY3V7j2IebOpC00Zp2P/Ay2kA==
-  dependencies:
-    ethereum-common "^0.0.18"
-    ethereumjs-util "^5.0.0"
-
-ethereumjs-tx@^2.1.1:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/ethereumjs-tx/-/ethereumjs-tx-2.1.2.tgz#5dfe7688bf177b45c9a23f86cf9104d47ea35fed"
-  integrity sha512-zZEK1onCeiORb0wyCXUvg94Ve5It/K6GD1K+26KfFKodiBiS6d9lfCXlUKGBBdQ+bv7Day+JK0tj1K+BeNFRAw==
-  dependencies:
-    ethereumjs-common "^1.5.0"
-    ethereumjs-util "^6.0.0"
-
-ethereumjs-util@^5.0.0, ethereumjs-util@^5.1.1, ethereumjs-util@^5.1.2, ethereumjs-util@^5.1.5:
-  version "5.2.1"
-  resolved "https://registry.yarnpkg.com/ethereumjs-util/-/ethereumjs-util-5.2.1.tgz#a833f0e5fca7e5b361384dc76301a721f537bf65"
-  integrity sha512-v3kT+7zdyCm1HIqWlLNrHGqHGLpGYIhjeHxQjnDXjLT2FyGJDsd3LWMYUo7pAFRrk86CR3nUJfhC81CCoJNNGQ==
-  dependencies:
-    bn.js "^4.11.0"
-    create-hash "^1.1.2"
-    elliptic "^6.5.2"
-    ethereum-cryptography "^0.1.3"
-    ethjs-util "^0.1.3"
-    rlp "^2.0.0"
-    safe-buffer "^5.1.1"
-
-ethereumjs-util@^6.0.0, ethereumjs-util@^6.1.0:
-  version "6.2.1"
-  resolved "https://registry.yarnpkg.com/ethereumjs-util/-/ethereumjs-util-6.2.1.tgz#fcb4e4dd5ceacb9d2305426ab1a5cd93e3163b69"
-  integrity sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==
-  dependencies:
-    "@types/bn.js" "^4.11.3"
-    bn.js "^4.11.0"
-    create-hash "^1.1.2"
-    elliptic "^6.5.2"
-    ethereum-cryptography "^0.1.3"
-    ethjs-util "0.1.6"
-    rlp "^2.2.3"
-
-ethereumjs-util@^7.0.2:
-  version "7.0.9"
-  resolved "https://registry.yarnpkg.com/ethereumjs-util/-/ethereumjs-util-7.0.9.tgz#2038baeb30f370a3e576ec175bd70bbbb6807d42"
-  integrity sha512-cRqvYYKJoitq6vMKMf8pXeVwvTrX+dRD0JwHaYqm8jvogK14tqIoCWH/KUHcRwnVxVXEYF/o6pup5jRG4V0xzg==
-  dependencies:
-    "@types/bn.js" "^5.1.0"
-    bn.js "^5.1.2"
-    create-hash "^1.1.2"
-    ethereum-cryptography "^0.1.3"
-    ethjs-util "0.1.6"
-    rlp "^2.2.4"
-
-ethereumjs-util@^7.1.0:
-  version "7.1.5"
-  resolved "https://registry.yarnpkg.com/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz#9ecf04861e4fbbeed7465ece5f23317ad1129181"
-  integrity sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==
-  dependencies:
-    "@types/bn.js" "^5.1.0"
-    bn.js "^5.1.2"
-    create-hash "^1.1.2"
-    ethereum-cryptography "^0.1.3"
-    rlp "^2.2.4"
-
-ethereumjs-vm@^2.3.4, ethereumjs-vm@^2.6.0:
-  version "2.6.0"
-  resolved "https://registry.yarnpkg.com/ethereumjs-vm/-/ethereumjs-vm-2.6.0.tgz#76243ed8de031b408793ac33907fb3407fe400c6"
-  integrity sha512-r/XIUik/ynGbxS3y+mvGnbOKnuLo40V5Mj1J25+HEO63aWYREIqvWeRO/hnROlMBE5WoniQmPmhiaN0ctiHaXw==
-  dependencies:
-    async "^2.1.2"
-    async-eventemitter "^0.2.2"
-    ethereumjs-account "^2.0.3"
-    ethereumjs-block "~2.2.0"
-    ethereumjs-common "^1.1.0"
-    ethereumjs-util "^6.0.0"
-    fake-merkle-patricia-tree "^1.0.1"
-    functional-red-black-tree "^1.0.1"
-    merkle-patricia-tree "^2.3.2"
-    rustbn.js "~0.2.0"
-    safe-buffer "^5.1.1"
-
-ethereumjs-wallet@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/ethereumjs-wallet/-/ethereumjs-wallet-1.0.1.tgz#664a4bcacfc1291ca2703de066df1178938dba1c"
-  integrity sha512-3Z5g1hG1das0JWU6cQ9HWWTY2nt9nXCcwj7eXVNAHKbo00XAZO8+NHlwdgXDWrL0SXVQMvTWN8Q/82DRH/JhPw==
-  dependencies:
-    aes-js "^3.1.1"
-    bs58check "^2.1.2"
-    ethereum-cryptography "^0.1.3"
-    ethereumjs-util "^7.0.2"
-    randombytes "^2.0.6"
-    scrypt-js "^3.0.1"
-    utf8 "^3.0.0"
-    uuid "^3.3.2"
-
-ethers@^4.0.32:
-  version "4.0.48"
-  resolved "https://registry.yarnpkg.com/ethers/-/ethers-4.0.48.tgz#330c65b8133e112b0613156e57e92d9009d8fbbe"
-  integrity sha512-sZD5K8H28dOrcidzx9f8KYh8083n5BexIO3+SbE4jK83L85FxtpXZBCQdXb8gkg+7sBqomcLhhkU7UHL+F7I2g==
-  dependencies:
-    aes-js "3.0.0"
-    bn.js "^4.4.0"
-    elliptic "6.5.3"
-    hash.js "1.1.3"
-    js-sha3 "0.5.7"
-    scrypt-js "2.0.4"
-    setimmediate "1.0.4"
-    uuid "2.0.1"
-    xmlhttprequest "1.8.0"
-
-ethjs-unit@0.1.6:
-  version "0.1.6"
-  resolved "https://registry.yarnpkg.com/ethjs-unit/-/ethjs-unit-0.1.6.tgz#c665921e476e87bce2a9d588a6fe0405b2c41699"
-  integrity sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw==
-  dependencies:
-    bn.js "4.11.6"
-    number-to-bn "1.7.0"
-
-ethjs-util@0.1.6, ethjs-util@^0.1.3:
-  version "0.1.6"
-  resolved "https://registry.yarnpkg.com/ethjs-util/-/ethjs-util-0.1.6.tgz#f308b62f185f9fe6237132fb2a9818866a5cd536"
-  integrity sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==
-  dependencies:
-    is-hex-prefixed "1.0.0"
-    strip-hex-prefix "1.0.0"
-
-event-target-shim@^5.0.0:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/event-target-shim/-/event-target-shim-5.0.1.tgz#5d4d3ebdf9583d63a5333ce2deb7480ab2b05789"
-  integrity sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==
-
-eventemitter3@3.1.2, eventemitter3@^3.1.0:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-3.1.2.tgz#2d3d48f9c346698fce83a85d7d664e98535df6e7"
-  integrity sha512-tvtQIeLVHjDkJYnzf2dgVMxfuSGJeM/7UCG17TT4EumTfNtF+0nebF/4zWOIkCreAbtNqhGEboB6BWrwqNaw4Q==
-
-eventemitter3@4.0.4:
-  version "4.0.4"
-  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.4.tgz#b5463ace635a083d018bdc7c917b4c5f10a85384"
-  integrity sha512-rlaVLnVxtxvoyLsQQFBx53YmXHDxRIzzTLbdfxqi4yocpSjAxXwkU0cScM5JgSKMqEhrZpnvQ2D9gjylR0AimQ==
-
-eventemitter3@^4.0.0:
-  version "4.0.7"
-  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
-  integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
-
-events@^3.0.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
-  integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
-
-eventsource@1.0.7:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/eventsource/-/eventsource-1.0.7.tgz#8fbc72c93fcd34088090bc0a4e64f4b5cee6d8d0"
-  integrity sha512-4Ln17+vVT0k8aWq+t/bF5arcS3EpT9gYtW66EPacdj/mAFevznsnyoHLPy2BA8gbIQeIHoPsvwmfBftfcG//BQ==
-  dependencies:
-    original "^1.0.0"
-
-evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz#7fcbdb198dc71959432efe13842684e0525acb02"
-  integrity sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==
-  dependencies:
-    md5.js "^1.3.4"
-    safe-buffer "^5.1.1"
-
-execa@5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd"
-  integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==
-  dependencies:
-    cross-spawn "^7.0.3"
-    get-stream "^6.0.0"
-    human-signals "^2.1.0"
-    is-stream "^2.0.0"
-    merge-stream "^2.0.0"
-    npm-run-path "^4.0.1"
-    onetime "^5.1.2"
-    signal-exit "^3.0.3"
-    strip-final-newline "^2.0.0"
-
-execa@^3.0.0:
-  version "3.4.0"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-3.4.0.tgz#c08ed4550ef65d858fac269ffc8572446f37eb89"
-  integrity sha512-r9vdGQk4bmCuK1yKQu1KTwcT2zwfWdbdaXfCtAh+5nU/4fSX+JAb7vZGvI5naJrQlvONrEB20jeruESI69530g==
-  dependencies:
-    cross-spawn "^7.0.0"
-    get-stream "^5.0.0"
-    human-signals "^1.1.1"
-    is-stream "^2.0.0"
-    merge-stream "^2.0.0"
-    npm-run-path "^4.0.0"
-    onetime "^5.1.0"
-    p-finally "^2.0.0"
-    signal-exit "^3.0.2"
-    strip-final-newline "^2.0.0"
-
-expand-brackets@^0.1.4:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-0.1.5.tgz#df07284e342a807cd733ac5af72411e581d1177b"
-  integrity sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=
-  dependencies:
-    is-posix-bracket "^0.1.0"
-
-expand-range@^1.8.1:
-  version "1.8.2"
-  resolved "https://registry.yarnpkg.com/expand-range/-/expand-range-1.8.2.tgz#a299effd335fe2721ebae8e257ec79644fc85337"
-  integrity sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=
-  dependencies:
-    fill-range "^2.1.0"
-
-express@^4.0.0, express@^4.14.0, express@^4.17.1:
-  version "4.18.2"
-  resolved "https://registry.yarnpkg.com/express/-/express-4.18.2.tgz#3fabe08296e930c796c19e3c516979386ba9fd59"
-  integrity sha512-5/PsL6iGPdfQ/lKM1UuielYgv3BUoJfz1aUwU9vHZ+J7gyvwdQXFEBIEIaxeGf0GIcreATNyBExtalisDbuMqQ==
-  dependencies:
-    accepts "~1.3.8"
-    array-flatten "1.1.1"
-    body-parser "1.20.1"
-    content-disposition "0.5.4"
-    content-type "~1.0.4"
-    cookie "0.5.0"
-    cookie-signature "1.0.6"
-    debug "2.6.9"
-    depd "2.0.0"
-    encodeurl "~1.0.2"
-    escape-html "~1.0.3"
-    etag "~1.8.1"
-    finalhandler "1.2.0"
-    fresh "0.5.2"
-    http-errors "2.0.0"
-    merge-descriptors "1.0.1"
-    methods "~1.1.2"
-    on-finished "2.4.1"
-    parseurl "~1.3.3"
-    path-to-regexp "0.1.7"
-    proxy-addr "~2.0.7"
-    qs "6.11.0"
-    range-parser "~1.2.1"
-    safe-buffer "5.2.1"
-    send "0.18.0"
-    serve-static "1.15.0"
-    setprototypeof "1.2.0"
-    statuses "2.0.1"
-    type-is "~1.6.18"
-    utils-merge "1.0.1"
-    vary "~1.1.2"
-
-ext@^1.1.2:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/ext/-/ext-1.4.0.tgz#89ae7a07158f79d35517882904324077e4379244"
-  integrity sha512-Key5NIsUxdqKg3vIsdw9dSuXpPCQ297y6wBjL30edxwPgt2E44WcWBZey/ZvUc6sERLTxKdyCu4gZFmUbk1Q7A==
-  dependencies:
-    type "^2.0.0"
-
-extend-shallow@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f"
-  integrity sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=
-  dependencies:
-    is-extendable "^0.1.0"
-
-extend@^3.0.0, extend@~3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
-  integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
-
-extglob@^0.3.1:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/extglob/-/extglob-0.3.2.tgz#2e18ff3d2f49ab2765cec9023f011daa8d8349a1"
-  integrity sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=
-  dependencies:
-    is-extglob "^1.0.0"
-
-extract-files@9.0.0, extract-files@^9.0.0:
-  version "9.0.0"
-  resolved "https://registry.yarnpkg.com/extract-files/-/extract-files-9.0.0.tgz#8a7744f2437f81f5ed3250ed9f1550de902fe54a"
-  integrity sha512-CvdFfHkC95B4bBBk36hcEmvdR2awOdhhVUYH6S/zrVj3477zven/fJMYg7121h4T1xHZC+tetUpubpAhxwI7hQ==
-
-extsprintf@1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05"
-  integrity sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==
-
-extsprintf@^1.2.0:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.1.tgz#8d172c064867f235c0c84a596806d279bf4bcc07"
-  integrity sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA==
-
-eyes@^0.1.8:
-  version "0.1.8"
-  resolved "https://registry.yarnpkg.com/eyes/-/eyes-0.1.8.tgz#62cf120234c683785d902348a800ef3e0cc20bc0"
-  integrity sha512-GipyPsXO1anza0AOZdy69Im7hGFCNB7Y/NGjDlZGJ3GJJLtwNSb2vrzYrTYJRrRloVx7pl+bhUaTB8yiccPvFQ==
-
-fake-merkle-patricia-tree@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/fake-merkle-patricia-tree/-/fake-merkle-patricia-tree-1.0.1.tgz#4b8c3acfb520afadf9860b1f14cd8ce3402cddd3"
-  integrity sha1-S4w6z7Ugr635hgsfFM2M40As3dM=
-  dependencies:
-    checkpoint-store "^1.1.0"
-
-faker@^5.3.1:
-  version "5.4.0"
-  resolved "https://registry.yarnpkg.com/faker/-/faker-5.4.0.tgz#f18e55993c6887918182b003d163df14daeb3011"
-  integrity sha512-Y9n/Ky/xZx/Bj8DePvXspUYRtHl/rGQytoIT5LaxmNwSe3wWyOeOXb3lT6Dpipq240PVpeFaGKzScz/5fvff2g==
-
-fast-check@^2.12.1:
-  version "2.13.0"
-  resolved "https://registry.yarnpkg.com/fast-check/-/fast-check-2.13.0.tgz#92a50a6a39b58760d4b0b52b12f98f28a9f020f6"
-  integrity sha512-IOfzKm/SCA+jpUEgAfqAuxHYPmgtmpnnwljQmYPRGrqYczcTKApXKHza/SNxFxYkecWfZilYa0DJdBvqz1bcSw==
-  dependencies:
-    pure-rand "^4.1.1"
-
-fast-decode-uri-component@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/fast-decode-uri-component/-/fast-decode-uri-component-1.0.1.tgz#46f8b6c22b30ff7a81357d4f59abfae938202543"
-  integrity sha512-WKgKWg5eUxvRZGwW8FvfbaH7AXSh2cL+3j5fMGzUMCxWBJ3dV3a7Wz8y2f/uQ0e3B6WmodD3oS54jTQ9HVTIIg==
-
-fast-deep-equal@^3.1.1:
-  version "3.1.3"
-  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
-  integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
-
-fast-fifo@^1.0.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/fast-fifo/-/fast-fifo-1.2.0.tgz#2ee038da2468e8623066dee96958b0c1763aa55a"
-  integrity sha512-NcvQXt7Cky1cNau15FWy64IjuO8X0JijhTBBrJj1YlxlDfRkJXNaK9RFUjwpfDPzMdv7wB38jr53l9tkNLxnWg==
-
-fast-future@~1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/fast-future/-/fast-future-1.0.2.tgz#8435a9aaa02d79248d17d704e76259301d99280a"
-  integrity sha1-hDWpqqAteSSNF9cE52JZMB2ZKAo=
-
-fast-glob@^3.1.1:
-  version "3.2.5"
-  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.5.tgz#7939af2a656de79a4f1901903ee8adcaa7cb9661"
-  integrity sha512-2DtFcgT68wiTTiwZ2hNdJfcHNke9XOfnwmBRWXhmeKM8rF0TGwmC/Qto3S7RoZKp5cilZbxzO5iTNTQsJ+EeDg==
-  dependencies:
-    "@nodelib/fs.stat" "^2.0.2"
-    "@nodelib/fs.walk" "^1.2.3"
-    glob-parent "^5.1.0"
-    merge2 "^1.3.0"
-    micromatch "^4.0.2"
-    picomatch "^2.2.1"
-
-fast-glob@^3.2.9:
-  version "3.2.12"
-  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.12.tgz#7f39ec99c2e6ab030337142da9e0c18f37afae80"
-  integrity sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==
-  dependencies:
-    "@nodelib/fs.stat" "^2.0.2"
-    "@nodelib/fs.walk" "^1.2.3"
-    glob-parent "^5.1.2"
-    merge2 "^1.3.0"
-    micromatch "^4.0.4"
-
-fast-json-stable-stringify@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
-  integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
-
-fast-levenshtein@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-3.0.0.tgz#37b899ae47e1090e40e3fd2318e4d5f0142ca912"
-  integrity sha512-hKKNajm46uNmTlhHSyZkmToAc56uZJwYq7yrciZjqOxnlfQwERDQJmHPUp7m1m9wx8vgOe8IaCKZ5Kv2k1DdCQ==
-  dependencies:
-    fastest-levenshtein "^1.0.7"
-
-fast-levenshtein@~2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
-  integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=
-
-fast-querystring@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/fast-querystring/-/fast-querystring-1.1.1.tgz#f4c56ef56b1a954880cfd8c01b83f9e1a3d3fda2"
-  integrity sha512-qR2r+e3HvhEFmpdHMv//U8FnFlnYjaC6QKDuaXALDkw2kvHO8WDjxH+f/rHGR4Me4pnk8p9JAkRNTjYHAKRn2Q==
-  dependencies:
-    fast-decode-uri-component "^1.0.1"
-
-fast-safe-stringify@^2.0.6:
-  version "2.0.7"
-  resolved "https://registry.yarnpkg.com/fast-safe-stringify/-/fast-safe-stringify-2.0.7.tgz#124aa885899261f68aedb42a7c080de9da608743"
-  integrity sha512-Utm6CdzT+6xsDk2m8S6uL8VHxNwI6Jub+e9NYTcAms28T84pTa25GJQV9j0CY0N1rM8hK4x6grpF2BQf+2qwVA==
-
-fast-url-parser@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/fast-url-parser/-/fast-url-parser-1.1.3.tgz#f4af3ea9f34d8a271cf58ad2b3759f431f0b318d"
-  integrity sha512-5jOCVXADYNuRkKFzNJ0dCCewsZiYo0dz8QNYljkOpFC6r2U4OBmKtvm/Tsuh4w1YYdDqDb31a8TVhBJ2OJKdqQ==
-  dependencies:
-    punycode "^1.3.2"
-
-fastest-levenshtein@^1.0.7:
-  version "1.0.16"
-  resolved "https://registry.yarnpkg.com/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz#210e61b6ff181de91ea9b3d1b84fdedd47e034e5"
-  integrity sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==
-
-fastq@^1.6.0:
-  version "1.11.0"
-  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.11.0.tgz#bb9fb955a07130a918eb63c1f5161cc32a5d0858"
-  integrity sha512-7Eczs8gIPDrVzT+EksYBcupqMyxSHXXrHOLRRxU2/DicV8789MRBRR8+Hc2uWzUupOs4YS4JzBmBxjjCVBxD/g==
-  dependencies:
-    reusify "^1.0.4"
-
-fb-watchman@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/fb-watchman/-/fb-watchman-2.0.1.tgz#fc84fb39d2709cf3ff6d743706157bb5708a8a85"
-  integrity sha512-DkPJKQeY6kKwmuMretBhr7G6Vodr7bFwDYTXIkfG1gjvNpaxBTQV3PbXg6bR1c1UP4jPOX0jHUbbHANL9vRjVg==
-  dependencies:
-    bser "2.1.1"
-
-fbjs-css-vars@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/fbjs-css-vars/-/fbjs-css-vars-1.0.2.tgz#216551136ae02fe255932c3ec8775f18e2c078b8"
-  integrity sha512-b2XGFAFdWZWg0phtAWLHCk836A1Xann+I+Dgd3Gk64MHKZO44FfoD1KxyvbSh0qZsIoXQGGlVztIY+oitJPpRQ==
-
-fbjs@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/fbjs/-/fbjs-3.0.0.tgz#0907067fb3f57a78f45d95f1eacffcacd623c165"
-  integrity sha512-dJd4PiDOFuhe7vk4F80Mba83Vr2QuK86FoxtgPmzBqEJahncp+13YCmfoa53KHCo6OnlXLG7eeMWPfB5CrpVKg==
-  dependencies:
-    cross-fetch "^3.0.4"
-    fbjs-css-vars "^1.0.0"
-    loose-envify "^1.0.0"
-    object-assign "^4.1.0"
-    promise "^7.1.1"
-    setimmediate "^1.0.5"
-    ua-parser-js "^0.7.18"
-
-fetch-cookie@0.10.1:
-  version "0.10.1"
-  resolved "https://registry.yarnpkg.com/fetch-cookie/-/fetch-cookie-0.10.1.tgz#5ea88f3d36950543c87997c27ae2aeafb4b5c4d4"
-  integrity sha512-beB+VEd4cNeVG1PY+ee74+PkuCQnik78pgLi5Ah/7qdUfov8IctU0vLUbBT8/10Ma5GMBeI4wtxhGrEfKNYs2g==
-  dependencies:
-    tough-cookie "^2.3.3 || ^3.0.1 || ^4.0.0"
-
-fetch-cookie@0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/fetch-cookie/-/fetch-cookie-0.7.0.tgz#a6fc137ad8363aa89125864c6451b86ecb7de802"
-  integrity sha512-Mm5pGlT3agW6t71xVM7vMZPIvI7T4FaTuFW4jari6dVzYHFDb3WZZsGpN22r/o3XMdkM0E7sPd1EGeyVbH2Tgg==
-  dependencies:
-    es6-denodeify "^0.1.1"
-    tough-cookie "^2.3.1"
-
-fetch-ponyfill@^4.0.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/fetch-ponyfill/-/fetch-ponyfill-4.1.0.tgz#ae3ce5f732c645eab87e4ae8793414709b239893"
-  integrity sha1-rjzl9zLGReq4fkroeTQUcJsjmJM=
-  dependencies:
-    node-fetch "~1.7.1"
-
-file-uri-to-path@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
-  integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==
-
-filelist@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/filelist/-/filelist-1.0.4.tgz#f78978a1e944775ff9e62e744424f215e58352b5"
-  integrity sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==
-  dependencies:
-    minimatch "^5.0.1"
-
-filename-regex@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/filename-regex/-/filename-regex-2.0.1.tgz#c1c4b9bee3e09725ddb106b75c1e301fe2f18b26"
-  integrity sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=
-
-fill-range@^2.1.0:
-  version "2.2.4"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-2.2.4.tgz#eb1e773abb056dcd8df2bfdf6af59b8b3a936565"
-  integrity sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q==
-  dependencies:
-    is-number "^2.1.0"
-    isobject "^2.0.0"
-    randomatic "^3.0.0"
-    repeat-element "^1.1.2"
-    repeat-string "^1.5.2"
-
-fill-range@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
-  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
-  dependencies:
-    to-regex-range "^5.0.1"
-
-finalhandler@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.2.0.tgz#7d23fe5731b207b4640e4fcd00aec1f9207a7b32"
-  integrity sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==
-  dependencies:
-    debug "2.6.9"
-    encodeurl "~1.0.2"
-    escape-html "~1.0.3"
-    on-finished "2.4.1"
-    parseurl "~1.3.3"
-    statuses "2.0.1"
-    unpipe "~1.0.0"
-
-find-up@5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc"
-  integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
-  dependencies:
-    locate-path "^6.0.0"
-    path-exists "^4.0.0"
-
-find-up@^1.0.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"
-  integrity sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=
-  dependencies:
-    path-exists "^2.0.0"
-    pinkie-promise "^2.0.0"
-
-find-up@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7"
-  integrity sha1-RdG35QbHF93UgndaK3eSCjwMV6c=
-  dependencies:
-    locate-path "^2.0.0"
-
-find-up@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-3.0.0.tgz#49169f1d7993430646da61ecc5ae355c21c97b73"
-  integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==
-  dependencies:
-    locate-path "^3.0.0"
-
-find-up@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
-  integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==
-  dependencies:
-    locate-path "^5.0.0"
-    path-exists "^4.0.0"
-
-first-chunk-stream@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/first-chunk-stream/-/first-chunk-stream-1.0.0.tgz#59bfb50cd905f60d7c394cd3d9acaab4e6ad934e"
-  integrity sha1-Wb+1DNkF9g18OUzT2ayqtOatk04=
-
-flat@^4.1.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/flat/-/flat-4.1.1.tgz#a392059cc382881ff98642f5da4dde0a959f309b"
-  integrity sha512-FmTtBsHskrU6FJ2VxCnsDb84wu9zhmO3cUX2kGFb5tuwhfXxGciiT0oRY+cck35QmG+NmGh5eLz6lLCpWTqwpA==
-  dependencies:
-    is-buffer "~2.0.3"
-
-follow-redirects@^1.12.1:
-  version "1.14.8"
-  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.14.8.tgz#016996fb9a11a100566398b1c6839337d7bfa8fc"
-  integrity sha512-1x0S9UVJHsQprFcEC/qnNzBLcIxsjAV905f/UkQxbclCsoTWlacCNOpQa/anodLl2uaEKFhfWOvM2Qg77+15zA==
-
-follow-redirects@^1.14.0:
-  version "1.15.1"
-  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.1.tgz#0ca6a452306c9b276e4d3127483e29575e207ad5"
-  integrity sha512-yLAMQs+k0b2m7cVxpS1VKJVvoz7SS9Td1zss3XRwXj+ZDH00RJgnuLx7E44wx02kQLrdM3aOOy+FpzS7+8OizA==
-
-for-each@^0.3.3:
-  version "0.3.3"
-  resolved "https://registry.yarnpkg.com/for-each/-/for-each-0.3.3.tgz#69b447e88a0a5d32c3e7084f3f1710034b21376e"
-  integrity sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==
-  dependencies:
-    is-callable "^1.1.3"
-
-for-in@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
-  integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=
-
-for-own@^0.1.4:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/for-own/-/for-own-0.1.5.tgz#5265c681a4f294dabbf17c9509b6763aa84510ce"
-  integrity sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=
-  dependencies:
-    for-in "^1.0.1"
-
-foreach@^2.0.4, foreach@^2.0.5:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/foreach/-/foreach-2.0.5.tgz#0bee005018aeb260d0a3af3ae658dd0136ec1b99"
-  integrity sha1-C+4AUBiusmDQo6865ljdATbsG5k=
-
-forever-agent@~0.6.1:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
-  integrity sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==
-
-form-data@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-3.0.0.tgz#31b7e39c85f1355b7139ee0c647cf0de7f83c682"
-  integrity sha512-CKMFDglpbMi6PyN+brwB9Q/GOw0eAnsrEZDgcsH5Krhz5Od/haKHAX0NmQfha2zPPz0JpWzA7GJHGSnvCRLWsg==
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.8"
-    mime-types "^2.1.12"
-
-form-data@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.0.tgz#93919daeaf361ee529584b9b31664dc12c9fa452"
-  integrity sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.8"
-    mime-types "^2.1.12"
-
-form-data@^2.2.0:
-  version "2.5.1"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.5.1.tgz#f2cbec57b5e59e23716e128fe44d4e5dd23895f4"
-  integrity sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.6"
-    mime-types "^2.1.12"
-
-form-data@~2.3.2:
-  version "2.3.3"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.3.3.tgz#dcce52c05f644f298c6a7ab936bd724ceffbf3a6"
-  integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.6"
-    mime-types "^2.1.12"
-
-forwarded@0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/forwarded/-/forwarded-0.2.0.tgz#2269936428aad4c15c7ebe9779a84bf0b2a81811"
-  integrity sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==
-
-fresh@0.5.2:
-  version "0.5.2"
-  resolved "https://registry.yarnpkg.com/fresh/-/fresh-0.5.2.tgz#3d8cadd90d976569fa835ab1f8e4b23a105605a7"
-  integrity sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==
-
-fs-capacitor@^2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/fs-capacitor/-/fs-capacitor-2.0.4.tgz#5a22e72d40ae5078b4fe64fe4d08c0d3fc88ad3c"
-  integrity sha512-8S4f4WsCryNw2mJJchi46YgB6CR5Ze+4L1h8ewl9tEpL4SJ3ZO+c/bS4BWhB8bK+O3TMqhuZarTitd0S0eh2pA==
-
-fs-capacitor@^6.1.0:
-  version "6.2.0"
-  resolved "https://registry.yarnpkg.com/fs-capacitor/-/fs-capacitor-6.2.0.tgz#fa79ac6576629163cb84561995602d8999afb7f5"
-  integrity sha512-nKcE1UduoSKX27NSZlg879LdQc94OtbOsEmKMN2MBNudXREvijRKx2GEBsTMTfws+BrbkJoEuynbGSVRSpauvw==
-
-fs-constants@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs-constants/-/fs-constants-1.0.0.tgz#6be0de9be998ce16af8afc24497b9ee9b7ccd9ad"
-  integrity sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==
-
-fs-extra@5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-5.0.0.tgz#414d0110cdd06705734d055652c5411260c31abd"
-  integrity sha512-66Pm4RYbjzdyeuqudYqhFiNBbCIuI9kgRqLPSHIlXHidW8NIQtVdkM1yeZ4lXwuhbTETv3EUGMNHAAw6hiundQ==
-  dependencies:
-    graceful-fs "^4.1.2"
-    jsonfile "^4.0.0"
-    universalify "^0.1.0"
-
-fs-extra@9.1.0, fs-extra@^9.1.0:
-  version "9.1.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-9.1.0.tgz#5954460c764a8da2094ba3554bf839e6b9a7c86d"
-  integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==
-  dependencies:
-    at-least-node "^1.0.0"
-    graceful-fs "^4.2.0"
-    jsonfile "^6.0.1"
-    universalify "^2.0.0"
-
-fs-extra@^0.30.0:
-  version "0.30.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-0.30.0.tgz#f233ffcc08d4da7d432daa449776989db1df93f0"
-  integrity sha1-8jP/zAjU2n1DLapEl3aYnbHfk/A=
-  dependencies:
-    graceful-fs "^4.1.2"
-    jsonfile "^2.1.0"
-    klaw "^1.0.0"
-    path-is-absolute "^1.0.0"
-    rimraf "^2.2.8"
-
-fs-extra@^4.0.2:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-4.0.3.tgz#0d852122e5bc5beb453fb028e9c0c9bf36340c94"
-  integrity sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==
-  dependencies:
-    graceful-fs "^4.1.2"
-    jsonfile "^4.0.0"
-    universalify "^0.1.0"
-
-fs-jetpack@4.3.1:
-  version "4.3.1"
-  resolved "https://registry.yarnpkg.com/fs-jetpack/-/fs-jetpack-4.3.1.tgz#cdfd4b64e6bfdec7c7dc55c76b39efaa7853bb20"
-  integrity sha512-dbeOK84F6BiQzk2yqqCVwCPWTxAvVGJ3fMQc6E2wuEohS28mR6yHngbrKuVCK1KHRx/ccByDylqu4H5PCP2urQ==
-  dependencies:
-    minimatch "^3.0.2"
-    rimraf "^2.6.3"
-
-fs-jetpack@^2.2.2:
-  version "2.4.0"
-  resolved "https://registry.yarnpkg.com/fs-jetpack/-/fs-jetpack-2.4.0.tgz#6080c4ab464a019d37a404baeb47f32af8835026"
-  integrity sha512-S/o9Dd7K9A7gicVU32eT8G0kHcmSu0rCVdP79P0MWInKFb8XpTc8Syhoo66k9no+HDshtlh4pUJTws8X+8fdFQ==
-  dependencies:
-    minimatch "^3.0.2"
-    rimraf "^2.6.3"
-
-fs-minipass@^1.2.7:
-  version "1.2.7"
-  resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-1.2.7.tgz#ccff8570841e7fe4265693da88936c55aed7f7c7"
-  integrity sha512-GWSSJGFy4e9GUeCcbIkED+bgAoFyj7XF1mV8rma3QW4NIqX9Kyx79N/PF61H5udOV3aY1IaMLs6pGbH71nlCTA==
-  dependencies:
-    minipass "^2.6.0"
-
-fs-minipass@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-2.1.0.tgz#7f5036fdbf12c63c169190cbe4199c852271f9fb"
-  integrity sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==
-  dependencies:
-    minipass "^3.0.0"
-
-fs.realpath@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
-  integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
-
-fsevents@~2.1.2:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.1.3.tgz#fb738703ae8d2f9fe900c33836ddebee8b97f23e"
-  integrity sha512-Auw9a4AxqWpa9GUfj370BMPzzyncfBABW8Mab7BGWBYDj4Isgq+cDKtx0i6u9jcX9pQDnswsaaOTgTmA5pEjuQ==
-
-fsevents@~2.3.2:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a"
-  integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==
-
-function-bind@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
-  integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
-
-functional-red-black-tree@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327"
-  integrity sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=
-
-gauge@~2.7.3:
-  version "2.7.4"
-  resolved "https://registry.yarnpkg.com/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7"
-  integrity sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=
-  dependencies:
-    aproba "^1.0.3"
-    console-control-strings "^1.0.0"
-    has-unicode "^2.0.0"
-    object-assign "^4.1.0"
-    signal-exit "^3.0.0"
-    string-width "^1.0.1"
-    strip-ansi "^3.0.1"
-    wide-align "^1.1.0"
-
-gensync@^1.0.0-beta.2:
-  version "1.0.0-beta.2"
-  resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
-  integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
-
-get-caller-file@^2.0.1:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
-  integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
-
-get-intrinsic@^1.0.2:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.3.tgz#063c84329ad93e83893c7f4f243ef63ffa351385"
-  integrity sha512-QJVz1Tj7MS099PevUG5jvnt9tSkXN8K14dxQlikJuPt4uD9hHAHjLyLBiLR5zELelBdD9QNRAXZzsJx0WaDL9A==
-  dependencies:
-    function-bind "^1.1.1"
-    has "^1.0.3"
-    has-symbols "^1.0.3"
-
-get-intrinsic@^1.1.0, get-intrinsic@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.1.tgz#15f59f376f855c446963948f0d24cd3637b4abc6"
-  integrity sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==
-  dependencies:
-    function-bind "^1.1.1"
-    has "^1.0.3"
-    has-symbols "^1.0.1"
-
-get-iterator@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/get-iterator/-/get-iterator-1.0.2.tgz#cd747c02b4c084461fac14f48f6b45a80ed25c82"
-  integrity sha512-v+dm9bNVfOYsY1OrhaCrmyOcYoSeVvbt+hHZ0Au+T+p1y+0Uyj9aMaGIeUTT6xdpRbWzDeYKvfOslPhggQMcsg==
-
-get-package-type@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/get-package-type/-/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a"
-  integrity sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==
-
-get-params@^0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/get-params/-/get-params-0.1.2.tgz#bae0dfaba588a0c60d7834c0d8dc2ff60eeef2fe"
-  integrity sha1-uuDfq6WIoMYNeDTA2Nwv9g7u8v4=
-
-get-port@^3.1.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/get-port/-/get-port-3.2.0.tgz#dd7ce7de187c06c8bf353796ac71e099f0980ebc"
-  integrity sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==
-
-get-stream@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-3.0.0.tgz#8e943d1358dc37555054ecbe2edb05aa174ede14"
-  integrity sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=
-
-get-stream@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5"
-  integrity sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==
-  dependencies:
-    pump "^3.0.0"
-
-get-stream@^5.0.0, get-stream@^5.1.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-5.2.0.tgz#4966a1795ee5ace65e706c4b7beb71257d6e22d3"
-  integrity sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==
-  dependencies:
-    pump "^3.0.0"
-
-get-stream@^6.0.0:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
-  integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
-
-get-symbol-description@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/get-symbol-description/-/get-symbol-description-1.0.0.tgz#7fdb81c900101fbd564dd5f1a30af5aadc1e58d6"
-  integrity sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==
-  dependencies:
-    call-bind "^1.0.2"
-    get-intrinsic "^1.1.1"
-
-getpass@^0.1.1:
-  version "0.1.7"
-  resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa"
-  integrity sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==
-  dependencies:
-    assert-plus "^1.0.0"
-
-glob-base@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/glob-base/-/glob-base-0.3.0.tgz#dbb164f6221b1c0b1ccf82aea328b497df0ea3c4"
-  integrity sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=
-  dependencies:
-    glob-parent "^2.0.0"
-    is-glob "^2.0.0"
-
-glob-parent@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-2.0.0.tgz#81383d72db054fcccf5336daa902f182f6edbb28"
-  integrity sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=
-  dependencies:
-    is-glob "^2.0.0"
-
-glob-parent@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-3.1.0.tgz#9e6af6299d8d3bd2bd40430832bd113df906c5ae"
-  integrity sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=
-  dependencies:
-    is-glob "^3.1.0"
-    path-dirname "^1.0.0"
-
-glob-parent@^5.1.0, glob-parent@^5.1.2, glob-parent@~5.1.0, glob-parent@~5.1.2:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
-  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
-  dependencies:
-    is-glob "^4.0.1"
-
-glob-stream@^5.3.2:
-  version "5.3.5"
-  resolved "https://registry.yarnpkg.com/glob-stream/-/glob-stream-5.3.5.tgz#a55665a9a8ccdc41915a87c701e32d4e016fad22"
-  integrity sha1-pVZlqajM3EGRWofHAeMtTgFvrSI=
-  dependencies:
-    extend "^3.0.0"
-    glob "^5.0.3"
-    glob-parent "^3.0.0"
-    micromatch "^2.3.7"
-    ordered-read-streams "^0.3.0"
-    through2 "^0.6.0"
-    to-absolute-glob "^0.1.1"
-    unique-stream "^2.0.2"
-
-glob@7.1.6, glob@^7.1.1:
-  version "7.1.6"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6"
-  integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.0.4"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-glob@9.3.5:
-  version "9.3.5"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-9.3.5.tgz#ca2ed8ca452781a3009685607fdf025a899dfe21"
-  integrity sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    minimatch "^8.0.2"
-    minipass "^4.2.4"
-    path-scurry "^1.6.1"
-
-glob@^5.0.3:
-  version "5.0.15"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-5.0.15.tgz#1bc936b9e02f4a603fcc222ecf7633d30b8b93b1"
-  integrity sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=
-  dependencies:
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "2 || 3"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-glob@^7.1.3:
-  version "7.2.3"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b"
-  integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.1.1"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-global@~4.4.0:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/global/-/global-4.4.0.tgz#3e7b105179006a323ed71aafca3e9c57a5cc6406"
-  integrity sha512-wv/LAoHdRE3BeTGz53FAamhGlPLhlssK45usmGFThIi4XqnBmjKQ16u+RNbP7WvigRZDxUsM0J3gcQ5yicaL0w==
-  dependencies:
-    min-document "^2.19.0"
-    process "^0.11.10"
-
-globals@^11.1.0:
-  version "11.12.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
-  integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
-
-globals@^9.18.0:
-  version "9.18.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-9.18.0.tgz#aa3896b3e69b487f17e31ed2143d69a8e30c2d8a"
-  integrity sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==
-
-globby@11.0.2:
-  version "11.0.2"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-11.0.2.tgz#1af538b766a3b540ebfb58a32b2e2d5897321d83"
-  integrity sha512-2ZThXDvvV8fYFRVIxnrMQBipZQDr7MxKAmQK1vujaj9/7eF0efG7BPUKJ7jP7G5SLF37xKDXvO4S/KKLj/Z0og==
-  dependencies:
-    array-union "^2.1.0"
-    dir-glob "^3.0.1"
-    fast-glob "^3.1.1"
-    ignore "^5.1.4"
-    merge2 "^1.3.0"
-    slash "^3.0.0"
-
-globby@^11.1.0:
-  version "11.1.0"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
-  integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
-  dependencies:
-    array-union "^2.1.0"
-    dir-glob "^3.0.1"
-    fast-glob "^3.2.9"
-    ignore "^5.2.0"
-    merge2 "^1.4.1"
-    slash "^3.0.0"
-
-gluegun@5.1.2:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/gluegun/-/gluegun-5.1.2.tgz#ffa0beda0fb6bbc089a867157b08602beae2c8cf"
-  integrity sha512-Cwx/8S8Z4YQg07a6AFsaGnnnmd8mN17414NcPS3OoDtZRwxgsvwRNJNg69niD6fDa8oNwslCG0xH7rEpRNNE/g==
-  dependencies:
-    apisauce "^2.1.5"
-    app-module-path "^2.2.0"
-    cli-table3 "0.6.0"
-    colors "1.4.0"
-    cosmiconfig "7.0.1"
-    cross-spawn "7.0.3"
-    ejs "3.1.6"
-    enquirer "2.3.6"
-    execa "5.1.1"
-    fs-jetpack "4.3.1"
-    lodash.camelcase "^4.3.0"
-    lodash.kebabcase "^4.1.1"
-    lodash.lowercase "^4.3.0"
-    lodash.lowerfirst "^4.3.1"
-    lodash.pad "^4.5.1"
-    lodash.padend "^4.6.1"
-    lodash.padstart "^4.6.1"
-    lodash.repeat "^4.1.0"
-    lodash.snakecase "^4.1.1"
-    lodash.startcase "^4.4.0"
-    lodash.trim "^4.5.1"
-    lodash.trimend "^4.5.1"
-    lodash.trimstart "^4.5.1"
-    lodash.uppercase "^4.3.0"
-    lodash.upperfirst "^4.3.1"
-    ora "4.0.2"
-    pluralize "^8.0.0"
-    semver "7.3.5"
-    which "2.0.2"
-    yargs-parser "^21.0.0"
-
-gluegun@^4.6.1:
-  version "4.6.1"
-  resolved "https://registry.yarnpkg.com/gluegun/-/gluegun-4.6.1.tgz#f2a65d20378873de87a2143b8c3939ffc9a9e2b6"
-  integrity sha512-Jd5hV1Uku2rjBg59mYA/bnwLwynK7u9A1zmK/LIb/p5d3pzjDCKRjWFuxZXyPwl9rsvKGhJUQxkFo2HEy8crKQ==
-  dependencies:
-    apisauce "^2.0.1"
-    app-module-path "^2.2.0"
-    cli-table3 "~0.5.0"
-    colors "^1.3.3"
-    cosmiconfig "6.0.0"
-    cross-spawn "^7.0.0"
-    ejs "^2.6.1"
-    enquirer "2.3.4"
-    execa "^3.0.0"
-    fs-jetpack "^2.2.2"
-    lodash.camelcase "^4.3.0"
-    lodash.kebabcase "^4.1.1"
-    lodash.lowercase "^4.3.0"
-    lodash.lowerfirst "^4.3.1"
-    lodash.pad "^4.5.1"
-    lodash.padend "^4.6.1"
-    lodash.padstart "^4.6.1"
-    lodash.repeat "^4.1.0"
-    lodash.snakecase "^4.1.1"
-    lodash.startcase "^4.4.0"
-    lodash.trim "^4.5.1"
-    lodash.trimend "^4.5.1"
-    lodash.trimstart "^4.5.1"
-    lodash.uppercase "^4.3.0"
-    lodash.upperfirst "^4.3.1"
-    ora "^4.0.0"
-    pluralize "^8.0.0"
-    ramdasauce "^2.1.0"
-    semver "^7.0.0"
-    which "^2.0.0"
-    yargs-parser "^16.1.0"
-
-got@9.6.0:
-  version "9.6.0"
-  resolved "https://registry.yarnpkg.com/got/-/got-9.6.0.tgz#edf45e7d67f99545705de1f7bbeeeb121765ed85"
-  integrity sha512-R7eWptXuGYxwijs0eV+v3o6+XH1IqVK8dJOEecQfTmkncw9AV4dcw/Dhxi8MdlqPthxxpZyizMzyg8RTmEsG+Q==
-  dependencies:
-    "@sindresorhus/is" "^0.14.0"
-    "@szmarczak/http-timer" "^1.1.2"
-    cacheable-request "^6.0.0"
-    decompress-response "^3.3.0"
-    duplexer3 "^0.1.4"
-    get-stream "^4.1.0"
-    lowercase-keys "^1.0.1"
-    mimic-response "^1.0.1"
-    p-cancelable "^1.0.0"
-    to-readable-stream "^1.0.0"
-    url-parse-lax "^3.0.0"
-
-got@^7.1.0:
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/got/-/got-7.1.0.tgz#05450fd84094e6bbea56f451a43a9c289166385a"
-  integrity sha512-Y5WMo7xKKq1muPsxD+KmrR8DH5auG7fBdDVueZwETwV6VytKyU9OX/ddpq2/1hp1vIPvVb4T81dKQz3BivkNLw==
-  dependencies:
-    decompress-response "^3.2.0"
-    duplexer3 "^0.1.4"
-    get-stream "^3.0.0"
-    is-plain-obj "^1.1.0"
-    is-retry-allowed "^1.0.0"
-    is-stream "^1.0.0"
-    isurl "^1.0.0-alpha5"
-    lowercase-keys "^1.0.0"
-    p-cancelable "^0.3.0"
-    p-timeout "^1.1.1"
-    safe-buffer "^5.0.1"
-    timed-out "^4.0.0"
-    url-parse-lax "^1.0.0"
-    url-to-options "^1.0.1"
-
-graceful-fs@4.X, graceful-fs@^4.0.0, graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.9:
-  version "4.2.6"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.6.tgz#ff040b2b0853b23c3d31027523706f1885d76bee"
-  integrity sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==
-
-graceful-fs@^4.1.6, graceful-fs@^4.2.0:
-  version "4.2.10"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.10.tgz#147d3a006da4ca3ce14728c7aefc287c367d7a6c"
-  integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==
-
-graphql-extensions@^0.15.0:
-  version "0.15.0"
-  resolved "https://registry.yarnpkg.com/graphql-extensions/-/graphql-extensions-0.15.0.tgz#3f291f9274876b0c289fa4061909a12678bd9817"
-  integrity sha512-bVddVO8YFJPwuACn+3pgmrEg6I8iBuYLuwvxiE+lcQQ7POotVZxm2rgGw0PvVYmWWf3DT7nTVDZ5ROh/ALp8mA==
-  dependencies:
-    "@apollographql/apollo-tools" "^0.5.0"
-    apollo-server-env "^3.1.0"
-    apollo-server-types "^0.9.0"
-
-graphql-import-node@^0.0.5:
-  version "0.0.5"
-  resolved "https://registry.yarnpkg.com/graphql-import-node/-/graphql-import-node-0.0.5.tgz#caf76a6cece10858b14f27cce935655398fc1bf0"
-  integrity sha512-OXbou9fqh9/Lm7vwXT0XoRN9J5+WCYKnbiTalgFDvkQERITRmcfncZs6aVABedd5B85yQU5EULS4a5pnbpuI0Q==
-
-graphql-subscriptions@^1.0.0:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/graphql-subscriptions/-/graphql-subscriptions-1.2.1.tgz#2142b2d729661ddf967b7388f7cf1dd4cf2e061d"
-  integrity sha512-95yD/tKi24q8xYa7Q9rhQN16AYj5wPbrb8tmHGM3WRc9EBmWrG/0kkMl+tQG8wcEuE9ibR4zyOM31p5Sdr2v4g==
-  dependencies:
-    iterall "^1.3.0"
-
-graphql-tag@^2.11.0:
-  version "2.12.6"
-  resolved "https://registry.yarnpkg.com/graphql-tag/-/graphql-tag-2.12.6.tgz#d441a569c1d2537ef10ca3d1633b48725329b5f1"
-  integrity sha512-FdSNcu2QQcWnM2VNvSCCDCVS5PpPqpzgFT8+GXzqJuoDd0CBncxCY278u4mhRO7tMgo2JjgJA5aZ+nWSQ/Z+xg==
-  dependencies:
-    tslib "^2.1.0"
-
-graphql-tag@^2.12.0:
-  version "2.12.1"
-  resolved "https://registry.yarnpkg.com/graphql-tag/-/graphql-tag-2.12.1.tgz#b065ef885e4800e4afd0842811b718a205f4aa58"
-  integrity sha512-LPewEE1vzGkHnCO8zdOGogKsHHBdtpGyihow1UuMwp6RnZa0lAS7NcbvltLOuo4pi5diQCPASAXZkQq44ffixA==
-  dependencies:
-    tslib "^1.14.1"
-
-graphql-tools@^4.0.8:
-  version "4.0.8"
-  resolved "https://registry.yarnpkg.com/graphql-tools/-/graphql-tools-4.0.8.tgz#e7fb9f0d43408fb0878ba66b522ce871bafe9d30"
-  integrity sha512-MW+ioleBrwhRjalKjYaLQbr+920pHBgy9vM/n47sswtns8+96sRn5M/G+J1eu7IMeKWiN/9p6tmwCHU7552VJg==
-  dependencies:
-    apollo-link "^1.2.14"
-    apollo-utilities "^1.0.1"
-    deprecated-decorator "^0.1.6"
-    iterall "^1.1.3"
-    uuid "^3.1.0"
-
-graphql-tools@^6.2.4:
-  version "6.2.6"
-  resolved "https://registry.yarnpkg.com/graphql-tools/-/graphql-tools-6.2.6.tgz#557c6d32797a02988f214bd596dec2abd12425dd"
-  integrity sha512-OyhSvK5ALVVD6bFiWjAqv2+lRyvjIRfb6Br5Tkjrv++rxnXDodPH/zhMbDGRw+W3SD5ioGEEz84yO48iPiN7jA==
-  dependencies:
-    "@graphql-tools/batch-delegate" "^6.2.6"
-    "@graphql-tools/code-file-loader" "^6.2.4"
-    "@graphql-tools/delegate" "^6.2.4"
-    "@graphql-tools/git-loader" "^6.2.4"
-    "@graphql-tools/github-loader" "^6.2.4"
-    "@graphql-tools/graphql-file-loader" "^6.2.4"
-    "@graphql-tools/graphql-tag-pluck" "^6.2.4"
-    "@graphql-tools/import" "^6.2.4"
-    "@graphql-tools/json-file-loader" "^6.2.4"
-    "@graphql-tools/links" "^6.2.4"
-    "@graphql-tools/load" "^6.2.4"
-    "@graphql-tools/load-files" "^6.2.4"
-    "@graphql-tools/merge" "^6.2.4"
-    "@graphql-tools/mock" "^6.2.4"
-    "@graphql-tools/module-loader" "^6.2.4"
-    "@graphql-tools/relay-operation-optimizer" "^6.2.4"
-    "@graphql-tools/resolvers-composition" "^6.2.4"
-    "@graphql-tools/schema" "^6.2.4"
-    "@graphql-tools/stitch" "^6.2.4"
-    "@graphql-tools/url-loader" "^6.2.4"
-    "@graphql-tools/utils" "^6.2.4"
-    "@graphql-tools/wrap" "^6.2.4"
-    tslib "~2.0.1"
-
-graphql-upload@^11.0.0:
-  version "11.0.0"
-  resolved "https://registry.yarnpkg.com/graphql-upload/-/graphql-upload-11.0.0.tgz#24b245ff18f353bab6715e8a055db9fd73035e10"
-  integrity sha512-zsrDtu5gCbQFDWsNa5bMB4nf1LpKX9KDgh+f8oL1288ijV4RxeckhVozAjqjXAfRpxOHD1xOESsh6zq8SjdgjA==
-  dependencies:
-    busboy "^0.3.1"
-    fs-capacitor "^6.1.0"
-    http-errors "^1.7.3"
-    isobject "^4.0.0"
-    object-path "^0.11.4"
-
-graphql-ws@4.1.5:
-  version "4.1.5"
-  resolved "https://registry.yarnpkg.com/graphql-ws/-/graphql-ws-4.1.5.tgz#03526b29acb54a424a9fbe300a4bd69ff65a50b3"
-  integrity sha512-yUQ1AjegD1Y9jDS699kyw7Mw+9H+rILm2HoS8N5a5B5YTH93xy3yifFhAJpKGc2wb/8yGdlVy8gTcud0TPqi6Q==
-
-graphql@15.5.0, graphql@^15.3.0:
-  version "15.5.0"
-  resolved "https://registry.yarnpkg.com/graphql/-/graphql-15.5.0.tgz#39d19494dbe69d1ea719915b578bf920344a69d5"
-  integrity sha512-OmaM7y0kaK31NKG31q4YbD2beNYa6jBBKtMFT6gLYJljHLJr42IqJ8KX08u3Li/0ifzTU5HjmoOOrwa5BRLeDA==
-
-graphql@^16.6.0:
-  version "16.6.0"
-  resolved "https://registry.yarnpkg.com/graphql/-/graphql-16.6.0.tgz#c2dcffa4649db149f6282af726c8c83f1c7c5fdb"
-  integrity sha512-KPIBPDlW7NxrbT/eh4qPXz5FiFdL5UbaA0XUNz2Rp3Z3hqBSkbj0GVjwFDztsWVauZUWsbKHgMg++sk8UX0bkw==
-
-growl@1.10.5:
-  version "1.10.5"
-  resolved "https://registry.yarnpkg.com/growl/-/growl-1.10.5.tgz#f2735dc2283674fa67478b10181059355c369e5e"
-  integrity sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==
-
-gulp-sourcemaps@^1.5.2:
-  version "1.12.1"
-  resolved "https://registry.yarnpkg.com/gulp-sourcemaps/-/gulp-sourcemaps-1.12.1.tgz#b437d1f3d980cf26e81184823718ce15ae6597b6"
-  integrity sha1-tDfR89mAzyboEYSCNxjOFa5ll7Y=
-  dependencies:
-    "@gulp-sourcemaps/map-sources" "1.X"
-    acorn "4.X"
-    convert-source-map "1.X"
-    css "2.X"
-    debug-fabulous "0.0.X"
-    detect-newline "2.X"
-    graceful-fs "4.X"
-    source-map "~0.6.0"
-    strip-bom "2.X"
-    through2 "2.X"
-    vinyl "1.X"
-
-har-schema@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/har-schema/-/har-schema-2.0.0.tgz#a94c2224ebcac04782a0d9035521f24735b7ec92"
-  integrity sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==
-
-har-validator@~5.1.3:
-  version "5.1.5"
-  resolved "https://registry.yarnpkg.com/har-validator/-/har-validator-5.1.5.tgz#1f0803b9f8cb20c0fa13822df1ecddb36bde1efd"
-  integrity sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==
-  dependencies:
-    ajv "^6.12.3"
-    har-schema "^2.0.0"
-
-has-ansi@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/has-ansi/-/has-ansi-2.0.0.tgz#34f5049ce1ecdf2b0649af3ef24e45ed35416d91"
-  integrity sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=
-  dependencies:
-    ansi-regex "^2.0.0"
-
-has-bigints@^1.0.0, has-bigints@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.0.1.tgz#64fe6acb020673e3b78db035a5af69aa9d07b113"
-  integrity sha512-LSBS2LjbNBTf6287JEbEzvJgftkF5qFkmCo9hDRpAzKhUOlJ+hx8dd4USs00SgsUNwc4617J9ki5YtEClM2ffA==
-
-has-flag@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
-  integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==
-
-has-flag@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
-  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
-
-has-symbol-support-x@^1.4.1:
-  version "1.4.2"
-  resolved "https://registry.yarnpkg.com/has-symbol-support-x/-/has-symbol-support-x-1.4.2.tgz#1409f98bc00247da45da67cee0a36f282ff26455"
-  integrity sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw==
-
-has-symbols@^1.0.0, has-symbols@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.2.tgz#165d3070c00309752a1236a479331e3ac56f1423"
-  integrity sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==
-
-has-symbols@^1.0.1, has-symbols@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8"
-  integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==
-
-has-to-string-tag-x@^1.2.0:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/has-to-string-tag-x/-/has-to-string-tag-x-1.4.1.tgz#a045ab383d7b4b2012a00148ab0aa5f290044d4d"
-  integrity sha512-vdbKfmw+3LoOYVr+mtxHaX5a96+0f3DljYd8JOqvOLsf5mw2Otda2qCDT9qRqLAhrjyQ0h7ual5nOiASpsGNFw==
-  dependencies:
-    has-symbol-support-x "^1.4.1"
-
-has-tostringtag@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.0.tgz#7e133818a7d394734f941e73c3d3f9291e658b25"
-  integrity sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==
-  dependencies:
-    has-symbols "^1.0.2"
-
-has-unicode@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
-  integrity sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=
-
-has@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
-  integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
-  dependencies:
-    function-bind "^1.1.1"
-
-hash-base@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/hash-base/-/hash-base-3.1.0.tgz#55c381d9e06e1d2997a883b4a3fddfe7f0d3af33"
-  integrity sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==
-  dependencies:
-    inherits "^2.0.4"
-    readable-stream "^3.6.0"
-    safe-buffer "^5.2.0"
-
-hash.js@1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.3.tgz#340dedbe6290187151c1ea1d777a3448935df846"
-  integrity sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==
-  dependencies:
-    inherits "^2.0.3"
-    minimalistic-assert "^1.0.0"
-
-hash.js@1.1.7, hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7:
-  version "1.1.7"
-  resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.7.tgz#0babca538e8d4ee4a0f8988d68866537a003cf42"
-  integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==
-  dependencies:
-    inherits "^2.0.3"
-    minimalistic-assert "^1.0.1"
-
-he@1.2.0, he@^1.1.1:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f"
-  integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
-
-header-case@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/header-case/-/header-case-1.0.1.tgz#9535973197c144b09613cd65d317ef19963bd02d"
-  integrity sha1-lTWXMZfBRLCWE81l0xfvGZY70C0=
-  dependencies:
-    no-case "^2.2.0"
-    upper-case "^1.1.3"
-
-highlight.js@^10.4.0, highlight.js@^10.4.1:
-  version "10.6.0"
-  resolved "https://registry.yarnpkg.com/highlight.js/-/highlight.js-10.6.0.tgz#0073aa71d566906965ba6e1b7be7b2682f5e18b6"
-  integrity sha512-8mlRcn5vk/r4+QcqerapwBYTe+iPL5ih6xrNylxrnBdHQiijDETfXX7VIxC3UiCRiINBJfANBAsPzAvRQj8RpQ==
-
-highlightjs-solidity@^1.0.21:
-  version "1.0.21"
-  resolved "https://registry.yarnpkg.com/highlightjs-solidity/-/highlightjs-solidity-1.0.21.tgz#6d257215b5b635231d4d0c523f2c419bbff6fe42"
-  integrity sha512-ozOtTD986CBIxuIuauzz2lqCOTpd27TbfYm+msMtNSB69mJ0cdFNvZ6rOO5iFtEHtDkVYVEFQywXffG2sX3XTw==
-
-hmac-drbg@^1.0.0, hmac-drbg@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/hmac-drbg/-/hmac-drbg-1.0.1.tgz#d2745701025a6c775a6c545793ed502fc0c649a1"
-  integrity sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=
-  dependencies:
-    hash.js "^1.0.3"
-    minimalistic-assert "^1.0.0"
-    minimalistic-crypto-utils "^1.0.1"
-
-hoist-non-react-statics@^3.3.2:
-  version "3.3.2"
-  resolved "https://registry.yarnpkg.com/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz#ece0acaf71d62c2969c2ec59feff42a4b1a85b45"
-  integrity sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==
-  dependencies:
-    react-is "^16.7.0"
-
-home-or-tmp@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/home-or-tmp/-/home-or-tmp-2.0.0.tgz#e36c3f2d2cae7d746a857e38d18d5f32a7882db8"
-  integrity sha1-42w/LSyufXRqhX440Y1fMqeILbg=
-  dependencies:
-    os-homedir "^1.0.0"
-    os-tmpdir "^1.0.1"
-
-hosted-git-info@^2.1.4:
-  version "2.8.8"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.8.tgz#7539bd4bc1e0e0a895815a2e0262420b12858488"
-  integrity sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg==
-
-htmlparser2@^3.9.1:
-  version "3.10.1"
-  resolved "https://registry.yarnpkg.com/htmlparser2/-/htmlparser2-3.10.1.tgz#bd679dc3f59897b6a34bb10749c855bb53a9392f"
-  integrity sha512-IgieNijUMbkDovyoKObU1DUhm1iwNYE/fuifEoEHfd1oZKZDaONBSkal7Y01shxsM49R4XaMdGez3WnF9UfiCQ==
-  dependencies:
-    domelementtype "^1.3.1"
-    domhandler "^2.3.0"
-    domutils "^1.5.1"
-    entities "^1.1.1"
-    inherits "^2.0.1"
-    readable-stream "^3.1.1"
-
-htmlparser2@^6.0.0:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/htmlparser2/-/htmlparser2-6.0.1.tgz#422521231ef6d42e56bd411da8ba40aa36e91446"
-  integrity sha512-GDKPd+vk4jvSuvCbyuzx/unmXkk090Azec7LovXP8as1Hn8q9p3hbjmDGbUqqhknw0ajwit6LiiWqfiTUPMK7w==
-  dependencies:
-    domelementtype "^2.0.1"
-    domhandler "^4.0.0"
-    domutils "^2.4.4"
-    entities "^2.0.0"
-
-htmlparser2@~3.8.1:
-  version "3.8.3"
-  resolved "https://registry.yarnpkg.com/htmlparser2/-/htmlparser2-3.8.3.tgz#996c28b191516a8be86501a7d79757e5c70c1068"
-  integrity sha1-mWwosZFRaovoZQGn15dX5ccMEGg=
-  dependencies:
-    domelementtype "1"
-    domhandler "2.3"
-    domutils "1.5"
-    entities "1.0"
-    readable-stream "1.1"
-
-http-basic@^8.1.1:
-  version "8.1.3"
-  resolved "https://registry.yarnpkg.com/http-basic/-/http-basic-8.1.3.tgz#a7cabee7526869b9b710136970805b1004261bbf"
-  integrity sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw==
-  dependencies:
-    caseless "^0.12.0"
-    concat-stream "^1.6.2"
-    http-response-object "^3.0.1"
-    parse-cache-control "^1.0.1"
-
-http-cache-semantics@^4.0.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz#49e91c5cbf36c9b94bcfcd71c23d5249ec74e390"
-  integrity sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ==
-
-http-errors@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-2.0.0.tgz#b7774a1486ef73cf7667ac9ae0858c012c57b9d3"
-  integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==
-  dependencies:
-    depd "2.0.0"
-    inherits "2.0.4"
-    setprototypeof "1.2.0"
-    statuses "2.0.1"
-    toidentifier "1.0.1"
-
-http-errors@^1.7.3:
-  version "1.8.0"
-  resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-1.8.0.tgz#75d1bbe497e1044f51e4ee9e704a62f28d336507"
-  integrity sha512-4I8r0C5JDhT5VkvI47QktDW75rNlGVsUf/8hzjCC/wkWI/jdTRmBb9aI7erSG82r1bjKY3F6k28WnsVxB1C73A==
-  dependencies:
-    depd "~1.1.2"
-    inherits "2.0.4"
-    setprototypeof "1.2.0"
-    statuses ">= 1.5.0 < 2"
-    toidentifier "1.0.0"
-
-http-https@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/http-https/-/http-https-1.0.0.tgz#2f908dd5f1db4068c058cd6e6d4ce392c913389b"
-  integrity sha1-L5CN1fHbQGjAWM1ubUzjkskTOJs=
-
-http-response-object@^3.0.1:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/http-response-object/-/http-response-object-3.0.2.tgz#7f435bb210454e4360d074ef1f989d5ea8aa9810"
-  integrity sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA==
-  dependencies:
-    "@types/node" "^10.0.3"
-
-http-signature@~1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.2.0.tgz#9aecd925114772f3d95b65a60abb8f7c18fbace1"
-  integrity sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==
-  dependencies:
-    assert-plus "^1.0.0"
-    jsprim "^1.2.2"
-    sshpk "^1.7.0"
-
-human-signals@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-1.1.1.tgz#c5b1cd14f50aeae09ab6c59fe63ba3395fe4dfa3"
-  integrity sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==
-
-human-signals@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0"
-  integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
-
-hyperlinker@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/hyperlinker/-/hyperlinker-1.0.0.tgz#23dc9e38a206b208ee49bc2d6c8ef47027df0c0e"
-  integrity sha512-Ty8UblRWFEcfSuIaajM34LdPXIhbs1ajEX/BBPv24J+enSVaEVY63xQ6lTO9VRYS5LAoghIG0IDJ+p+IPzKUQQ==
-
-ice-cap@0.0.4:
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/ice-cap/-/ice-cap-0.0.4.tgz#8a6d31ab4cac8d4b56de4fa946df3352561b6e18"
-  integrity sha1-im0xq0ysjUtW3k+pRt8zUlYbbhg=
-  dependencies:
-    cheerio "0.20.0"
-    color-logger "0.0.3"
-
-iconv-lite@0.4.24, iconv-lite@^0.4.4:
-  version "0.4.24"
-  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
-  integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
-  dependencies:
-    safer-buffer ">= 2.1.2 < 3"
-
-iconv-lite@^0.6.2:
-  version "0.6.2"
-  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.6.2.tgz#ce13d1875b0c3a674bd6a04b7f76b01b1b6ded01"
-  integrity sha512-2y91h5OpQlolefMPmUlivelittSWy0rP+oYVpn6A7GwVHNE8AWzoYOBNmlwks3LobaJxgHCYZAnyNo2GgpNRNQ==
-  dependencies:
-    safer-buffer ">= 2.1.2 < 3.0.0"
-
-idna-uts46-hx@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/idna-uts46-hx/-/idna-uts46-hx-2.3.1.tgz#a1dc5c4df37eee522bf66d969cc980e00e8711f9"
-  integrity sha512-PWoF9Keq6laYdIRwwCdhTPl60xRqAloYNMQLiyUnG42VjT53oW07BXIRM+NK7eQjzXjAk2gUvX9caRxlnF9TAA==
-  dependencies:
-    punycode "2.1.0"
-
-ieee754@^1.1.13, ieee754@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352"
-  integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==
-
-ignore-walk@^3.0.1:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/ignore-walk/-/ignore-walk-3.0.3.tgz#017e2447184bfeade7c238e4aefdd1e8f95b1e37"
-  integrity sha512-m7o6xuOaT1aqheYHKf8W6J5pYH85ZI9w077erOzLje3JsB1gkafkAhHHY19dqjulgIZHFm32Cp5uNZgcQqdJKw==
-  dependencies:
-    minimatch "^3.0.4"
-
-ignore@^5.1.4:
-  version "5.1.8"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.1.8.tgz#f150a8b50a34289b33e22f5889abd4d8016f0e57"
-  integrity sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==
-
-ignore@^5.2.0:
-  version "5.2.4"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.4.tgz#a291c0c6178ff1b960befe47fcdec301674a6324"
-  integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==
-
-immediate@3.0.6:
-  version "3.0.6"
-  resolved "https://registry.yarnpkg.com/immediate/-/immediate-3.0.6.tgz#9db1dbd0faf8de6fbe0f5dd5e56bb606280de69b"
-  integrity sha1-nbHb0Pr43m++D13V5Wu2BigN5ps=
-
-immediate@3.3.0, immediate@^3.2.2, immediate@^3.2.3:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/immediate/-/immediate-3.3.0.tgz#1aef225517836bcdf7f2a2de2600c79ff0269266"
-  integrity sha512-HR7EVodfFUdQCTIeySw+WDRFJlPcLOJbXfwwZ7Oom6tjsvZ3bOkCDJHehQC3nxJrv7+f9XecwazynjU8e4Vw3Q==
-
-immediate@~3.2.3:
-  version "3.2.3"
-  resolved "https://registry.yarnpkg.com/immediate/-/immediate-3.2.3.tgz#d140fa8f614659bd6541233097ddaac25cdd991c"
-  integrity sha1-0UD6j2FGWb1lQSMwl92qwlzdmRw=
-
-immutable@4.2.1:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/immutable/-/immutable-4.2.1.tgz#8a4025691018c560a40c67e43d698f816edc44d4"
-  integrity sha512-7WYV7Q5BTs0nlQm7tl92rDYYoyELLKHoDMBKhrxEoiV4mrfVdRz8hzPiYOzH7yWjzoVEamxRuAqhxL2PLRwZYQ==
-
-immutable@~3.7.6:
-  version "3.7.6"
-  resolved "https://registry.yarnpkg.com/immutable/-/immutable-3.7.6.tgz#13b4d3cb12befa15482a26fe1b2ebae640071e4b"
-  integrity sha1-E7TTyxK++hVIKib+Gy665kAHHks=
-
-import-fresh@^3.1.0, import-fresh@^3.2.1:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
-  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
-  dependencies:
-    parent-module "^1.0.0"
-    resolve-from "^4.0.0"
-
-import-from@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/import-from/-/import-from-3.0.0.tgz#055cfec38cd5a27d8057ca51376d7d3bf0891966"
-  integrity sha512-CiuXOFFSzkU5x/CR0+z7T91Iht4CXgfCxVOFRhh2Zyhg5wOpWvvDLQUsWl+gcN+QscYBjez8hDCt85O7RLDttQ==
-  dependencies:
-    resolve-from "^5.0.0"
-
-imurmurhash@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
-  integrity sha1-khi5srkoojixPcT7a21XbyMUU+o=
-
-indent-string@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251"
-  integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
-
-inflight@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
-  integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
-  dependencies:
-    once "^1.3.0"
-    wrappy "1"
-
-inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.1, inherits@~2.0.3:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
-  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
-
-inherits@2.0.3:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
-  integrity sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=
-
-ini@~1.3.0:
-  version "1.3.8"
-  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
-  integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
-
-interface-datastore@^6.0.2:
-  version "6.1.1"
-  resolved "https://registry.yarnpkg.com/interface-datastore/-/interface-datastore-6.1.1.tgz#5150a00de2e7513eaadba58bcafd059cb50004c1"
-  integrity sha512-AmCS+9CT34pp2u0QQVXjKztkuq3y5T+BIciuiHDDtDZucZD8VudosnSdUyXJV6IsRkN5jc4RFDhCk1O6Q3Gxjg==
-  dependencies:
-    interface-store "^2.0.2"
-    nanoid "^3.0.2"
-    uint8arrays "^3.0.0"
-
-interface-store@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/interface-store/-/interface-store-2.0.2.tgz#83175fd2b0c501585ed96db54bb8ba9d55fce34c"
-  integrity sha512-rScRlhDcz6k199EkHqT8NpM87ebN89ICOzILoBHgaG36/WX50N32BnU/kpZgCGPLhARRAWUUX5/cyaIjt7Kipg==
-
-internal-slot@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/internal-slot/-/internal-slot-1.0.3.tgz#7347e307deeea2faac2ac6205d4bc7d34967f59c"
-  integrity sha512-O0DB1JC/sPyZl7cIo78n5dR7eUSwwpYPiXRhTzNxZVAMUuB8vlnRFyLxdrVToks6XPLVnFfbzaVd5WLjhgg+vA==
-  dependencies:
-    get-intrinsic "^1.1.0"
-    has "^1.0.3"
-    side-channel "^1.0.4"
-
-invariant@^2.2.2:
-  version "2.2.4"
-  resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.4.tgz#610f3c92c9359ce1db616e538008d23ff35158e6"
-  integrity sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==
-  dependencies:
-    loose-envify "^1.0.0"
-
-invert-kv@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/invert-kv/-/invert-kv-1.0.0.tgz#104a8e4aaca6d3d8cd157a8ef8bfab2d7a3ffdb6"
-  integrity sha1-EEqOSqym09jNFXqO+L+rLXo//bY=
-
-ip-regex@^4.0.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-4.3.0.tgz#687275ab0f57fa76978ff8f4dddc8a23d5990db5"
-  integrity sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==
-
-ipaddr.js@1.9.1:
-  version "1.9.1"
-  resolved "https://registry.yarnpkg.com/ipaddr.js/-/ipaddr.js-1.9.1.tgz#bff38543eeb8984825079ff3a2a8e6cbd46781b3"
-  integrity sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==
-
-ipfs-core-types@^0.9.0:
-  version "0.9.0"
-  resolved "https://registry.yarnpkg.com/ipfs-core-types/-/ipfs-core-types-0.9.0.tgz#cb201ff7a9470651ba14c4e7fae56661a55bf37e"
-  integrity sha512-VJ8vJSHvI1Zm7/SxsZo03T+zzpsg8pkgiIi5hfwSJlsrJ1E2v68QPlnLshGHUSYw89Oxq0IbETYl2pGTFHTWfg==
-  dependencies:
-    interface-datastore "^6.0.2"
-    multiaddr "^10.0.0"
-    multiformats "^9.4.13"
-
-ipfs-core-utils@^0.13.0:
-  version "0.13.0"
-  resolved "https://registry.yarnpkg.com/ipfs-core-utils/-/ipfs-core-utils-0.13.0.tgz#8f0ec9aaa7c24f6f307e6e76e7bdc1cefd829894"
-  integrity sha512-HP5EafxU4/dLW3U13CFsgqVO5Ika8N4sRSIb/dTg16NjLOozMH31TXV0Grtu2ZWo1T10ahTzMvrfT5f4mhioXw==
-  dependencies:
-    any-signal "^2.1.2"
-    blob-to-it "^1.0.1"
-    browser-readablestream-to-it "^1.0.1"
-    debug "^4.1.1"
-    err-code "^3.0.1"
-    ipfs-core-types "^0.9.0"
-    ipfs-unixfs "^6.0.3"
-    ipfs-utils "^9.0.2"
-    it-all "^1.0.4"
-    it-map "^1.0.4"
-    it-peekable "^1.0.2"
-    it-to-stream "^1.0.0"
-    merge-options "^3.0.4"
-    multiaddr "^10.0.0"
-    multiaddr-to-uri "^8.0.0"
-    multiformats "^9.4.13"
-    nanoid "^3.1.23"
-    parse-duration "^1.0.0"
-    timeout-abort-controller "^2.0.0"
-    uint8arrays "^3.0.0"
-
-ipfs-http-client@55.0.0:
-  version "55.0.0"
-  resolved "https://registry.yarnpkg.com/ipfs-http-client/-/ipfs-http-client-55.0.0.tgz#8b713c5fa318e873b7d7ad099a4eb14320a5b0ce"
-  integrity sha512-GpvEs7C7WL9M6fN/kZbjeh4Y8YN7rY8b18tVWZnKxRsVwM25cIFrRI8CwNt3Ugin9yShieI3i9sPyzYGMrLNnQ==
-  dependencies:
-    "@ipld/dag-cbor" "^7.0.0"
-    "@ipld/dag-json" "^8.0.1"
-    "@ipld/dag-pb" "^2.1.3"
-    abort-controller "^3.0.0"
-    any-signal "^2.1.2"
-    debug "^4.1.1"
-    err-code "^3.0.1"
-    ipfs-core-types "^0.9.0"
-    ipfs-core-utils "^0.13.0"
-    ipfs-utils "^9.0.2"
-    it-first "^1.0.6"
-    it-last "^1.0.4"
-    merge-options "^3.0.4"
-    multiaddr "^10.0.0"
-    multiformats "^9.4.13"
-    native-abort-controller "^1.0.3"
-    parse-duration "^1.0.0"
-    stream-to-it "^0.2.2"
-    uint8arrays "^3.0.0"
-
-ipfs-unixfs@^6.0.3:
-  version "6.0.9"
-  resolved "https://registry.yarnpkg.com/ipfs-unixfs/-/ipfs-unixfs-6.0.9.tgz#f6613b8e081d83faa43ed96e016a694c615a9374"
-  integrity sha512-0DQ7p0/9dRB6XCb0mVCTli33GzIzSVx5udpJuVM47tGcD+W+Bl4LsnoLswd3ggNnNEakMv1FdoFITiEnchXDqQ==
-  dependencies:
-    err-code "^3.0.1"
-    protobufjs "^6.10.2"
-
-ipfs-utils@^9.0.2:
-  version "9.0.14"
-  resolved "https://registry.yarnpkg.com/ipfs-utils/-/ipfs-utils-9.0.14.tgz#24f5fda1f4567685eb32bca2543d518f95fd8704"
-  integrity sha512-zIaiEGX18QATxgaS0/EOQNoo33W0islREABAcxXE8n7y2MGAlB+hdsxXn4J0hGZge8IqVQhW8sWIb+oJz2yEvg==
-  dependencies:
-    any-signal "^3.0.0"
-    browser-readablestream-to-it "^1.0.0"
-    buffer "^6.0.1"
-    electron-fetch "^1.7.2"
-    err-code "^3.0.1"
-    is-electron "^2.2.0"
-    iso-url "^1.1.5"
-    it-all "^1.0.4"
-    it-glob "^1.0.1"
-    it-to-stream "^1.0.0"
-    merge-options "^3.0.4"
-    nanoid "^3.1.20"
-    native-fetch "^3.0.0"
-    node-fetch "^2.6.8"
-    react-native-fetch-api "^3.0.0"
-    stream-to-it "^0.2.2"
-
-is-arguments@^1.0.4, is-arguments@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-arguments/-/is-arguments-1.1.0.tgz#62353031dfbee07ceb34656a6bde59efecae8dd9"
-  integrity sha512-1Ij4lOMPl/xB5kBDn7I+b2ttPMKa8szhEIrXDuXQD/oe3HJLTLhqhgGspwgyGd6MOywBUqVvYicF72lkgDnIHg==
-  dependencies:
-    call-bind "^1.0.0"
-
-is-arrayish@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
-  integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==
-
-is-bigint@^1.0.1:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-bigint/-/is-bigint-1.0.4.tgz#08147a1875bc2b32005d41ccd8291dffc6691df3"
-  integrity sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==
-  dependencies:
-    has-bigints "^1.0.1"
-
-is-binary-path@~2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09"
-  integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
-  dependencies:
-    binary-extensions "^2.0.0"
-
-is-boolean-object@^1.1.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.1.2.tgz#5c6dc200246dd9321ae4b885a114bb1f75f63719"
-  integrity sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==
-  dependencies:
-    call-bind "^1.0.2"
-    has-tostringtag "^1.0.0"
-
-is-buffer@^1.1.5:
-  version "1.1.6"
-  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
-  integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
-
-is-buffer@~2.0.3:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-2.0.5.tgz#ebc252e400d22ff8d77fa09888821a24a658c191"
-  integrity sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==
-
-is-callable@^1.1.3, is-callable@^1.1.4, is-callable@^1.2.4:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.4.tgz#47301d58dd0259407865547853df6d61fe471945"
-  integrity sha512-nsuwtxZfMX67Oryl9LCQ+upnC0Z0BgpwntpS89m1H/TLF0zNfzfLMV/9Wa/6MZsj0acpEjAO0KF1xT6ZdLl95w==
-
-is-callable@^1.2.3:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.3.tgz#8b1e0500b73a1d76c70487636f368e519de8db8e"
-  integrity sha512-J1DcMe8UYTBSrKezuIUTUwjXsho29693unXM2YhJUTR2txK/eG47bvNa/wipPFmZFgr/N6f1GA66dv0mEyTIyQ==
-
-is-core-module@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.2.0.tgz#97037ef3d52224d85163f5597b2b63d9afed981a"
-  integrity sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==
-  dependencies:
-    has "^1.0.3"
-
-is-date-object@^1.0.1:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.5.tgz#0841d5536e724c25597bf6ea62e1bd38298df31f"
-  integrity sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==
-  dependencies:
-    has-tostringtag "^1.0.0"
-
-is-docker@^2.0.0:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa"
-  integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==
-
-is-dotfile@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/is-dotfile/-/is-dotfile-1.0.3.tgz#a6a2f32ffd2dfb04f5ca25ecd0f6b83cf798a1e1"
-  integrity sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=
-
-is-electron@^2.2.0:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/is-electron/-/is-electron-2.2.1.tgz#751b1dd8a74907422faa5c35aaa0cf66d98086e9"
-  integrity sha512-r8EEQQsqT+Gn0aXFx7lTFygYQhILLCB+wn0WCDL5LZRINeLH/Rvw1j2oKodELLXYNImQ3CRlVsY8wW4cGOsyuw==
-
-is-equal-shallow@^0.1.3:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz#2238098fc221de0bcfa5d9eac4c45d638aa1c534"
-  integrity sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=
-  dependencies:
-    is-primitive "^2.0.0"
-
-is-extendable@^0.1.0, is-extendable@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
-  integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=
-
-is-extglob@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0"
-  integrity sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=
-
-is-extglob@^2.1.0, is-extglob@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
-  integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=
-
-is-finite@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-finite/-/is-finite-1.1.0.tgz#904135c77fb42c0641d6aa1bcdbc4daa8da082f3"
-  integrity sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w==
-
-is-fn@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-fn/-/is-fn-1.0.0.tgz#9543d5de7bcf5b08a22ec8a20bae6e286d510d8c"
-  integrity sha1-lUPV3nvPWwiiLsiiC65uKG1RDYw=
-
-is-fullwidth-code-point@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb"
-  integrity sha1-754xOG8DGn8NZDr4L95QxFfvAMs=
-  dependencies:
-    number-is-nan "^1.0.0"
-
-is-fullwidth-code-point@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
-  integrity sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==
-
-is-fullwidth-code-point@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
-  integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
-
-is-function@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-function/-/is-function-1.0.2.tgz#4f097f30abf6efadac9833b17ca5dc03f8144e08"
-  integrity sha512-lw7DUp0aWXYg+CBCN+JKkcE0Q2RayZnSvnZBlwgxHBQhqt5pZNVy4Ri7H9GmmXkdu7LUthszM+Tor1u/2iBcpQ==
-
-is-generator-function@^1.0.7:
-  version "1.0.8"
-  resolved "https://registry.yarnpkg.com/is-generator-function/-/is-generator-function-1.0.8.tgz#dfb5c2b120e02b0a8d9d2c6806cd5621aa922f7b"
-  integrity sha512-2Omr/twNtufVZFr1GhxjOMFPAj2sjc/dKaIqBhvo4qciXfJmITGH6ZGd8eZYNHza8t1y0e01AuqRhJwfWp26WQ==
-
-is-glob@4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.1.tgz#7567dbe9f2f5e2467bc77ab83c4a29482407a5dc"
-  integrity sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==
-  dependencies:
-    is-extglob "^2.1.1"
-
-is-glob@^2.0.0, is-glob@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-2.0.1.tgz#d096f926a3ded5600f3fdfd91198cb0888c2d863"
-  integrity sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=
-  dependencies:
-    is-extglob "^1.0.0"
-
-is-glob@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
-  integrity sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=
-  dependencies:
-    is-extglob "^2.1.0"
-
-is-glob@^4.0.1, is-glob@~4.0.1:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084"
-  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
-  dependencies:
-    is-extglob "^2.1.1"
-
-is-hex-prefixed@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz#7d8d37e6ad77e5d127148913c573e082d777f554"
-  integrity sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==
-
-is-interactive@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-interactive/-/is-interactive-1.0.0.tgz#cea6e6ae5c870a7b0a0004070b7b587e0252912e"
-  integrity sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==
-
-is-ip@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/is-ip/-/is-ip-3.1.0.tgz#2ae5ddfafaf05cb8008a62093cf29734f657c5d8"
-  integrity sha512-35vd5necO7IitFPjd/YBeqwWnyDWbuLH9ZXQdMfDA8TEo7pv5X8yfrvVO3xbJbLUlERCMvf6X0hTUamQxCYJ9Q==
-  dependencies:
-    ip-regex "^4.0.0"
-
-is-lower-case@^1.1.0:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/is-lower-case/-/is-lower-case-1.1.3.tgz#7e147be4768dc466db3bfb21cc60b31e6ad69393"
-  integrity sha1-fhR75HaNxGbbO/shzGCzHmrWk5M=
-  dependencies:
-    lower-case "^1.1.0"
-
-is-map@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/is-map/-/is-map-2.0.2.tgz#00922db8c9bf73e81b7a335827bc2a43f2b91127"
-  integrity sha512-cOZFQQozTha1f4MxLFzlgKYPTyj26picdZTx82hbc/Xf4K/tZOOXSCkMvU4pKioRXGDLJRn0GM7Upe7kR721yg==
-
-is-negative-zero@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.1.tgz#3de746c18dda2319241a53675908d8f766f11c24"
-  integrity sha512-2z6JzQvZRa9A2Y7xC6dQQm4FSTSTNWjKIYYTt4246eMTJmIo0Q+ZyOsU66X8lxK1AbB92dFeglPLrhwpeRKO6w==
-
-is-number-object@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.6.tgz#6a7aaf838c7f0686a50b4553f7e54a96494e89f0"
-  integrity sha512-bEVOqiRcvo3zO1+G2lVMy+gkkEm9Yh7cDMRusKKu5ZJKPUYSJwICTKZrNKHA2EbSP0Tu0+6B/emsYNHZyn6K8g==
-  dependencies:
-    has-tostringtag "^1.0.0"
-
-is-number@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-2.1.0.tgz#01fcbbb393463a548f2f466cce16dece49db908f"
-  integrity sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=
-  dependencies:
-    kind-of "^3.0.2"
-
-is-number@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff"
-  integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==
-
-is-number@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
-  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
-
-is-obj@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f"
-  integrity sha1-PkcprB9f3gJc19g6iW2rn09n2w8=
-
-is-object@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-object/-/is-object-1.0.2.tgz#a56552e1c665c9e950b4a025461da87e72f86fcf"
-  integrity sha512-2rRIahhZr2UWb45fIOuvZGpFtz0TyOZLf32KxBbSoUCeZR495zCKlWUKKUByk3geS2eAs7ZAABt0Y/Rx0GiQGA==
-
-is-plain-obj@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
-  integrity sha1-caUMhCnfync8kqOQpKA7OfzVHT4=
-
-is-plain-obj@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-2.1.0.tgz#45e42e37fccf1f40da8e5f76ee21515840c09287"
-  integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==
-
-is-posix-bracket@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz#3334dc79774368e92f016e6fbc0a88f5cd6e6bc4"
-  integrity sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=
-
-is-primitive@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575"
-  integrity sha1-IHurkWOEmcB7Kt8kCkGochADRXU=
-
-is-promise@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-4.0.0.tgz#42ff9f84206c1991d26debf520dd5c01042dd2f3"
-  integrity sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==
-
-is-regex@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.2.tgz#81c8ebde4db142f2cf1c53fc86d6a45788266251"
-  integrity sha512-axvdhb5pdhEVThqJzYXwMlVuZwC+FF2DpcOhTS+y/8jVq4trxyPgfcwIxIKiyeuLlSQYKkmUaPQJ8ZE4yNKXDg==
-  dependencies:
-    call-bind "^1.0.2"
-    has-symbols "^1.0.1"
-
-is-regex@^1.1.4:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.4.tgz#eef5663cd59fa4c0ae339505323df6854bb15958"
-  integrity sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==
-  dependencies:
-    call-bind "^1.0.2"
-    has-tostringtag "^1.0.0"
-
-is-retry-allowed@^1.0.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/is-retry-allowed/-/is-retry-allowed-1.2.0.tgz#d778488bd0a4666a3be8a1482b9f2baafedea8b4"
-  integrity sha512-RUbUeKwvm3XG2VYamhJL1xFktgjvPzL0Hq8C+6yrWIswDy3BIXGqCxhxkc30N9jqK311gVU137K8Ei55/zVJRg==
-
-is-set@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/is-set/-/is-set-2.0.2.tgz#90755fa4c2562dc1c5d4024760d6119b94ca18ec"
-  integrity sha512-+2cnTEZeY5z/iXGbLhPrOAaK/Mau5k5eXq9j14CpRTftq0pAJu2MwVRSZhyZWBzx3o6X795Lz6Bpb6R0GKf37g==
-
-is-shared-array-buffer@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.1.tgz#97b0c85fbdacb59c9c446fe653b82cf2b5b7cfe6"
-  integrity sha512-IU0NmyknYZN0rChcKhRO1X8LYz5Isj/Fsqh8NJOSf+N/hCOTwy29F32Ik7a+QszE63IdvmwdTPDd6cZ5pg4cwA==
-
-is-stream@^1.0.0, is-stream@^1.0.1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
-  integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ=
-
-is-stream@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
-  integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
-
-is-string@^1.0.5, is-string@^1.0.7:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.7.tgz#0dd12bf2006f255bb58f695110eff7491eebc0fd"
-  integrity sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==
-  dependencies:
-    has-tostringtag "^1.0.0"
-
-is-symbol@^1.0.2, is-symbol@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.4.tgz#a6dac93b635b063ca6872236de88910a57af139c"
-  integrity sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==
-  dependencies:
-    has-symbols "^1.0.2"
-
-is-typed-array@^1.1.3:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/is-typed-array/-/is-typed-array-1.1.5.tgz#f32e6e096455e329eb7b423862456aa213f0eb4e"
-  integrity sha512-S+GRDgJlR3PyEbsX/Fobd9cqpZBuvUS+8asRqYDMLCb2qMzt1oz5m5oxQCxOgUDxiWsOVNi4yaF+/uvdlHlYug==
-  dependencies:
-    available-typed-arrays "^1.0.2"
-    call-bind "^1.0.2"
-    es-abstract "^1.18.0-next.2"
-    foreach "^2.0.5"
-    has-symbols "^1.0.1"
-
-is-typedarray@^1.0.0, is-typedarray@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
-  integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=
-
-is-upper-case@^1.1.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/is-upper-case/-/is-upper-case-1.1.2.tgz#8d0b1fa7e7933a1e58483600ec7d9661cbaf756f"
-  integrity sha1-jQsfp+eTOh5YSDYA7H2WYcuvdW8=
-  dependencies:
-    upper-case "^1.1.0"
-
-is-utf8@^0.2.0:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
-  integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=
-
-is-valid-glob@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/is-valid-glob/-/is-valid-glob-0.3.0.tgz#d4b55c69f51886f9b65c70d6c2622d37e29f48fe"
-  integrity sha1-1LVcafUYhvm2XHDWwmItN+KfSP4=
-
-is-weakref@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-weakref/-/is-weakref-1.0.1.tgz#842dba4ec17fa9ac9850df2d6efbc1737274f2a2"
-  integrity sha512-b2jKc2pQZjaeFYWEf7ScFj+Be1I+PXmlu572Q8coTXZ+LD/QQZ7ShPMst8h16riVgyXTQwUsFEl74mDvc/3MHQ==
-  dependencies:
-    call-bind "^1.0.0"
-
-is-wsl@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz#74a4c76e77ca9fd3f932f290c17ea326cd157271"
-  integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
-  dependencies:
-    is-docker "^2.0.0"
-
-isarray@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-0.0.1.tgz#8a18acfca9a8f4177e09abfc6038939b05d1eedf"
-  integrity sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==
-
-isarray@1.0.0, isarray@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
-  integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=
-
-isarray@^2.0.5:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-2.0.5.tgz#8af1e4c1221244cc62459faf38940d4e644a5723"
-  integrity sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==
-
-isexe@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
-  integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
-
-iso-url@^1.1.5:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/iso-url/-/iso-url-1.2.1.tgz#db96a49d8d9a64a1c889fc07cc525d093afb1811"
-  integrity sha512-9JPDgCN4B7QPkLtYAAOrEuAWvP9rWvR5offAr0/SeF046wIkglqH3VXgYYP6NcsKslH80UIVgmPqNe3j7tG2ng==
-
-isobject@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89"
-  integrity sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=
-  dependencies:
-    isarray "1.0.0"
-
-isobject@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-4.0.0.tgz#3f1c9155e73b192022a80819bacd0343711697b0"
-  integrity sha512-S/2fF5wH8SJA/kmwr6HYhK/RI/OkhD84k8ntalo0iJjZikgq1XFvR5M8NPT1x5F7fBwCG3qHfnzeP/Vh/ZxCUA==
-
-isomorphic-ws@4.0.1, isomorphic-ws@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/isomorphic-ws/-/isomorphic-ws-4.0.1.tgz#55fd4cd6c5e6491e76dc125938dd863f5cd4f2dc"
-  integrity sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w==
-
-isstream@~0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a"
-  integrity sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==
-
-isurl@^1.0.0-alpha5:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/isurl/-/isurl-1.0.0.tgz#b27f4f49f3cdaa3ea44a0a5b7f3462e6edc39d67"
-  integrity sha512-1P/yWsxPlDtn7QeRD+ULKQPaIaN6yF368GZ2vDfv0AL0NwpStafjWCDDdn0k8wgFMWpVAqG7oJhxHnlud42i9w==
-  dependencies:
-    has-to-string-tag-x "^1.2.0"
-    is-object "^1.0.1"
-
-it-all@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/it-all/-/it-all-1.0.6.tgz#852557355367606295c4c3b7eff0136f07749335"
-  integrity sha512-3cmCc6Heqe3uWi3CVM/k51fa/XbMFpQVzFoDsV0IZNHSQDyAXl3c4MjHkFX5kF3922OGj7Myv1nSEUgRtcuM1A==
-
-it-first@^1.0.6:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/it-first/-/it-first-1.0.7.tgz#a4bef40da8be21667f7d23e44dae652f5ccd7ab1"
-  integrity sha512-nvJKZoBpZD/6Rtde6FXqwDqDZGF1sCADmr2Zoc0hZsIvnE449gRFnGctxDf09Bzc/FWnHXAdaHVIetY6lrE0/g==
-
-it-glob@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/it-glob/-/it-glob-1.0.2.tgz#bab9b04d6aaac42884502f3a0bfee84c7a29e15e"
-  integrity sha512-Ch2Dzhw4URfB9L/0ZHyY+uqOnKvBNeS/SMcRiPmJfpHiM0TsUZn+GkpcZxAoF3dJVdPm/PuIk3A4wlV7SUo23Q==
-  dependencies:
-    "@types/minimatch" "^3.0.4"
-    minimatch "^3.0.4"
-
-it-last@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/it-last/-/it-last-1.0.6.tgz#4106232e5905ec11e16de15a0e9f7037eaecfc45"
-  integrity sha512-aFGeibeiX/lM4bX3JY0OkVCFkAw8+n9lkukkLNivbJRvNz8lI3YXv5xcqhFUV2lDJiraEK3OXRDbGuevnnR67Q==
-
-it-map@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/it-map/-/it-map-1.0.6.tgz#6aa547e363eedcf8d4f69d8484b450bc13c9882c"
-  integrity sha512-XT4/RM6UHIFG9IobGlQPFQUrlEKkU4eBUFG3qhWhfAdh1JfF2x11ShCrKCdmZ0OiZppPfoLuzcfA4cey6q3UAQ==
-
-it-peekable@^1.0.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/it-peekable/-/it-peekable-1.0.3.tgz#8ebe933767d9c5aa0ae4ef8e9cb3a47389bced8c"
-  integrity sha512-5+8zemFS+wSfIkSZyf0Zh5kNN+iGyccN02914BY4w/Dj+uoFEoPSvj5vaWn8pNZJNSxzjW0zHRxC3LUb2KWJTQ==
-
-it-to-stream@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/it-to-stream/-/it-to-stream-1.0.0.tgz#6c47f91d5b5df28bda9334c52782ef8e97fe3a4a"
-  integrity sha512-pLULMZMAB/+vbdvbZtebC0nWBTbG581lk6w8P7DfIIIKUfa8FbY7Oi0FxZcFPbxvISs7A9E+cMpLDBc1XhpAOA==
-  dependencies:
-    buffer "^6.0.3"
-    fast-fifo "^1.0.0"
-    get-iterator "^1.0.2"
-    p-defer "^3.0.0"
-    p-fifo "^1.0.0"
-    readable-stream "^3.6.0"
-
-iterall@^1.1.3, iterall@^1.2.1, iterall@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/iterall/-/iterall-1.3.0.tgz#afcb08492e2915cbd8a0884eb93a8c94d0d72fea"
-  integrity sha512-QZ9qOMdF+QLHxy1QIpUHUU1D5pS2CG2P69LF6L6CPjPYA/XMOmKV3PZpawHoAjHNyB0swdVTRxdYT4tbBbxqwg==
-
-iterate-iterator@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/iterate-iterator/-/iterate-iterator-1.0.1.tgz#1693a768c1ddd79c969051459453f082fe82e9f6"
-  integrity sha512-3Q6tudGN05kbkDQDI4CqjaBf4qf85w6W6GnuZDtUVYwKgtC1q8yxYX7CZed7N+tLzQqS6roujWvszf13T+n9aw==
-
-iterate-value@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/iterate-value/-/iterate-value-1.0.2.tgz#935115bd37d006a52046535ebc8d07e9c9337f57"
-  integrity sha512-A6fMAio4D2ot2r/TYzr4yUWrmwNdsN5xL7+HUiyACE4DXm+q8HtPcnFTp+NnW3k4N05tZ7FVYFFb2CR13NxyHQ==
-  dependencies:
-    es-get-iterator "^1.0.2"
-    iterate-iterator "^1.0.1"
-
-jake@^10.6.1, jake@^10.8.5:
-  version "10.8.6"
-  resolved "https://registry.yarnpkg.com/jake/-/jake-10.8.6.tgz#227a96786a1e035214e0ba84b482d6223d41ef04"
-  integrity sha512-G43Ub9IYEFfu72sua6rzooi8V8Gz2lkfk48rW20vEWCGizeaEPlKB1Kh8JIA84yQbiAEfqlPmSpGgCKKxH3rDA==
-  dependencies:
-    async "^3.2.3"
-    chalk "^4.0.2"
-    filelist "^1.0.4"
-    minimatch "^3.1.2"
-
-jayson@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/jayson/-/jayson-4.0.0.tgz#145a0ced46f900934c9b307e1332bcb0c7dbdb17"
-  integrity sha512-v2RNpDCMu45fnLzSk47vx7I+QUaOsox6f5X0CUlabAFwxoP+8MfAY0NQRFwOEYXIxm8Ih5y6OaEa5KYiQMkyAA==
-  dependencies:
-    "@types/connect" "^3.4.33"
-    "@types/node" "^12.12.54"
-    "@types/ws" "^7.4.4"
-    JSONStream "^1.3.5"
-    commander "^2.20.3"
-    delay "^5.0.0"
-    es6-promisify "^5.0.0"
-    eyes "^0.1.8"
-    isomorphic-ws "^4.0.1"
-    json-stringify-safe "^5.0.1"
-    uuid "^8.3.2"
-    ws "^7.4.5"
-
-js-sha3@0.5.7, js-sha3@^0.5.7:
-  version "0.5.7"
-  resolved "https://registry.yarnpkg.com/js-sha3/-/js-sha3-0.5.7.tgz#0d4ffd8002d5333aabaf4a23eed2f6374c9f28e7"
-  integrity sha1-DU/9gALVMzqrr0oj7tL2N0yfKOc=
-
-js-sha3@0.8.0, js-sha3@^0.8.0:
-  version "0.8.0"
-  resolved "https://registry.yarnpkg.com/js-sha3/-/js-sha3-0.8.0.tgz#b9b7a5da73afad7dedd0f8c463954cbde6818840"
-  integrity sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==
-
-"js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
-  integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
-
-js-tokens@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.2.tgz#9866df395102130e38f7f996bceb65443209c25b"
-  integrity sha1-mGbfOVECEw449/mWvOtlRDIJwls=
-
-js-yaml@3.14.0:
-  version "3.14.0"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.0.tgz#a7a34170f26a21bb162424d8adacb4113a69e482"
-  integrity sha512-/4IbIeHcD9VMHFqDR/gQ7EdZdLimOvW2DdcxFjdyyZ9NsbS+ccrXqVWDtab/lRl5AlUqmpBx8EhPaWR+OtY17A==
-  dependencies:
-    argparse "^1.0.7"
-    esprima "^4.0.0"
-
-js-yaml@3.14.1, js-yaml@^3.14.1:
-  version "3.14.1"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
-  integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
-  dependencies:
-    argparse "^1.0.7"
-    esprima "^4.0.0"
-
-js-yaml@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
-  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
-  dependencies:
-    argparse "^2.0.1"
-
-jsan@^3.1.13:
-  version "3.1.13"
-  resolved "https://registry.yarnpkg.com/jsan/-/jsan-3.1.13.tgz#4de8c7bf8d1cfcd020c313d438f930cec4b91d86"
-  integrity sha512-9kGpCsGHifmw6oJet+y8HaCl14y7qgAsxVdV3pCHDySNR3BfDC30zgkssd7x5LRVAT22dnpbe9JdzzmXZnq9/g==
-
-jsbn@~0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
-  integrity sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==
-
-jsdom@^7.0.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/jsdom/-/jsdom-7.2.2.tgz#40b402770c2bda23469096bee91ab675e3b1fc6e"
-  integrity sha1-QLQCdwwr2iNGkJa+6Rq2deOx/G4=
-  dependencies:
-    abab "^1.0.0"
-    acorn "^2.4.0"
-    acorn-globals "^1.0.4"
-    cssom ">= 0.3.0 < 0.4.0"
-    cssstyle ">= 0.2.29 < 0.3.0"
-    escodegen "^1.6.1"
-    nwmatcher ">= 1.3.7 < 2.0.0"
-    parse5 "^1.5.1"
-    request "^2.55.0"
-    sax "^1.1.4"
-    symbol-tree ">= 3.1.0 < 4.0.0"
-    tough-cookie "^2.2.0"
-    webidl-conversions "^2.0.0"
-    whatwg-url-compat "~0.6.5"
-    xml-name-validator ">= 2.0.1 < 3.0.0"
-
-jsesc@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-1.3.0.tgz#46c3fec8c1892b12b0833db9bc7622176dbab34b"
-  integrity sha1-RsP+yMGJKxKwgz25vHYiF226s0s=
-
-jsesc@^2.5.1:
-  version "2.5.2"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
-  integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==
-
-json-buffer@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.0.tgz#5b1f397afc75d677bde8bcfc0e47e1f9a3d9a898"
-  integrity sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg=
-
-json-parse-even-better-errors@^2.3.0:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d"
-  integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==
-
-json-pointer@^0.6.0:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/json-pointer/-/json-pointer-0.6.1.tgz#3c6caa6ac139e2599f5a1659d39852154015054d"
-  integrity sha512-3OvjqKdCBvH41DLpV4iSt6v2XhZXV1bPB4OROuknvUXI7ZQNofieCPkmE26stEJ9zdQuvIxDHCuYhfgxFAAs+Q==
-  dependencies:
-    foreach "^2.0.4"
-
-json-rpc-engine@^5.1.3:
-  version "5.4.0"
-  resolved "https://registry.yarnpkg.com/json-rpc-engine/-/json-rpc-engine-5.4.0.tgz#75758609d849e1dba1e09021ae473f3ab63161e5"
-  integrity sha512-rAffKbPoNDjuRnXkecTjnsE3xLLrb00rEkdgalINhaYVYIxDwWtvYBr9UFbhTvPB1B2qUOLoFd/cV6f4Q7mh7g==
-  dependencies:
-    eth-rpc-errors "^3.0.0"
-    safe-event-emitter "^1.0.1"
-
-json-rpc-random-id@^1.0.0, json-rpc-random-id@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json-rpc-random-id/-/json-rpc-random-id-1.0.1.tgz#ba49d96aded1444dbb8da3d203748acbbcdec8c8"
-  integrity sha1-uknZat7RRE27jaPSA3SKy7zeyMg=
-
-json-schema-traverse@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
-  integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
-
-json-schema@0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.4.0.tgz#f7de4cf6efab838ebaeb3236474cbba5a1930ab5"
-  integrity sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==
-
-json-stable-stringify-without-jsonify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
-  integrity sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=
-
-json-stable-stringify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz#9a759d39c5f2ff503fd5300646ed445f88c4f9af"
-  integrity sha1-mnWdOcXy/1A/1TAGRu1EX4jE+a8=
-  dependencies:
-    jsonify "~0.0.0"
-
-json-stringify-safe@^5.0.1, json-stringify-safe@~5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
-  integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==
-
-json5@^0.5.1:
-  version "0.5.1"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-0.5.1.tgz#1eade7acc012034ad84e2396767ead9fa5495821"
-  integrity sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=
-
-json5@^2.1.2:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3"
-  integrity sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==
-  dependencies:
-    minimist "^1.2.5"
-
-jsondown@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/jsondown/-/jsondown-1.0.0.tgz#c5cc5cda65f515d2376136a104b5f535534f26e3"
-  integrity sha512-p6XxPaq59aXwcdDQV3ISMA5xk+1z6fJuctcwwSdR9iQgbYOcIrnknNrhcMGG+0FaUfKHGkdDpQNaZrovfBoyOw==
-  dependencies:
-    memdown "1.4.1"
-    mkdirp "0.5.1"
-
-jsonfile@^2.1.0:
-  version "2.4.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-2.4.0.tgz#3736a2b428b87bbda0cc83b53fa3d633a35c2ae8"
-  integrity sha1-NzaitCi4e72gzIO1P6PWM6NcKug=
-  optionalDependencies:
-    graceful-fs "^4.1.6"
-
-jsonfile@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb"
-  integrity sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=
-  optionalDependencies:
-    graceful-fs "^4.1.6"
-
-jsonfile@^6.0.1:
-  version "6.1.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae"
-  integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==
-  dependencies:
-    universalify "^2.0.0"
-  optionalDependencies:
-    graceful-fs "^4.1.6"
-
-jsonify@~0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/jsonify/-/jsonify-0.0.0.tgz#2c74b6ee41d93ca51b7b5aaee8f503631d252a73"
-  integrity sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=
-
-jsonparse@^1.2.0:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
-  integrity sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==
-
-jsprim@^1.2.2:
-  version "1.4.2"
-  resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.2.tgz#712c65533a15c878ba59e9ed5f0e26d5b77c5feb"
-  integrity sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==
-  dependencies:
-    assert-plus "1.0.0"
-    extsprintf "1.3.0"
-    json-schema "0.4.0"
-    verror "1.10.0"
-
-keccak@^3.0.0:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/keccak/-/keccak-3.0.2.tgz#4c2c6e8c54e04f2670ee49fa734eb9da152206e0"
-  integrity sha512-PyKKjkH53wDMLGrvmRGSNWgmSxZOUqbnXwKL9tmgbFYA1iAYqW21kfR7mZXV0MlESiefxQQE9X9fTa3X+2MPDQ==
-  dependencies:
-    node-addon-api "^2.0.0"
-    node-gyp-build "^4.2.0"
-    readable-stream "^3.6.0"
-
-keyv@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/keyv/-/keyv-3.1.0.tgz#ecc228486f69991e49e9476485a5be1e8fc5c4d9"
-  integrity sha512-9ykJ/46SN/9KPM/sichzQ7OvXyGDYKGTaDlKMGCAlg2UK8KRy4jb0d8sFc+0Tt0YYnThq8X2RZgCg74RPxgcVA==
-  dependencies:
-    json-buffer "3.0.0"
-
-kind-of@^3.0.2:
-  version "3.2.2"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64"
-  integrity sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=
-  dependencies:
-    is-buffer "^1.1.5"
-
-kind-of@^6.0.0:
-  version "6.0.3"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
-  integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
-
-klaw@^1.0.0:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/klaw/-/klaw-1.3.1.tgz#4088433b46b3b1ba259d78785d8e96f73ba02439"
-  integrity sha1-QIhDO0azsbolnXh4XY6W9zugJDk=
-  optionalDependencies:
-    graceful-fs "^4.1.9"
-
-lazy-debug-legacy@0.0.X:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/lazy-debug-legacy/-/lazy-debug-legacy-0.0.1.tgz#537716c0776e4cf79e3ed1b621f7658c2911b1b1"
-  integrity sha1-U3cWwHduTPeePtG2IfdljCkRsbE=
-
-lazystream@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/lazystream/-/lazystream-1.0.0.tgz#f6995fe0f820392f61396be89462407bb77168e4"
-  integrity sha1-9plf4PggOS9hOWvolGJAe7dxaOQ=
-  dependencies:
-    readable-stream "^2.0.5"
-
-lcid@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/lcid/-/lcid-1.0.0.tgz#308accafa0bc483a3867b4b6f2b9506251d1b835"
-  integrity sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=
-  dependencies:
-    invert-kv "^1.0.0"
-
-level-codec@9.0.1:
-  version "9.0.1"
-  resolved "https://registry.yarnpkg.com/level-codec/-/level-codec-9.0.1.tgz#042f4aa85e56d4328ace368c950811ba802b7247"
-  integrity sha512-ajFP0kJ+nyq4i6kptSM+mAvJKLOg1X5FiFPtLG9M5gCEZyBmgDi3FkDrvlMkEzrUn1cWxtvVmrvoS4ASyO/q+Q==
-
-level-codec@9.0.2, level-codec@^9.0.0:
-  version "9.0.2"
-  resolved "https://registry.yarnpkg.com/level-codec/-/level-codec-9.0.2.tgz#fd60df8c64786a80d44e63423096ffead63d8cbc"
-  integrity sha512-UyIwNb1lJBChJnGfjmO0OR+ezh2iVu1Kas3nvBS/BzGnx79dv6g7unpKIDNPMhfdTEGoc7mC8uAu51XEtX+FHQ==
-  dependencies:
-    buffer "^5.6.0"
-
-level-codec@~7.0.0:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/level-codec/-/level-codec-7.0.1.tgz#341f22f907ce0f16763f24bddd681e395a0fb8a7"
-  integrity sha512-Ua/R9B9r3RasXdRmOtd+t9TCOEIIlts+TN/7XTT2unhDaL6sJn83S3rUyljbr6lVtw49N3/yA0HHjpV6Kzb2aQ==
-
-level-concat-iterator@~2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/level-concat-iterator/-/level-concat-iterator-2.0.1.tgz#1d1009cf108340252cb38c51f9727311193e6263"
-  integrity sha512-OTKKOqeav2QWcERMJR7IS9CUo1sHnke2C0gkSmcR7QuEtFNLLzHQAvnMw8ykvEcv0Qtkg0p7FOwP1v9e5Smdcw==
-
-level-errors@^1.0.3:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/level-errors/-/level-errors-1.1.2.tgz#4399c2f3d3ab87d0625f7e3676e2d807deff404d"
-  integrity sha512-Sw/IJwWbPKF5Ai4Wz60B52yj0zYeqzObLh8k1Tk88jVmD51cJSKWSYpRyhVIvFzZdvsPqlH5wfhp/yxdsaQH4w==
-  dependencies:
-    errno "~0.1.1"
-
-level-errors@^2.0.0, level-errors@~2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/level-errors/-/level-errors-2.0.1.tgz#2132a677bf4e679ce029f517c2f17432800c05c8"
-  integrity sha512-UVprBJXite4gPS+3VznfgDSU8PTRuVX0NXwoWW50KLxd2yw4Y1t2JUR5In1itQnudZqRMT9DlAM3Q//9NCjCFw==
-  dependencies:
-    errno "~0.1.1"
-
-level-errors@~1.0.3:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/level-errors/-/level-errors-1.0.5.tgz#83dbfb12f0b8a2516bdc9a31c4876038e227b859"
-  integrity sha512-/cLUpQduF6bNrWuAC4pwtUKA5t669pCsCi2XbmojG2tFeOr9j6ShtdDCtFFQO1DRt+EVZhx9gPzP9G2bUaG4ig==
-  dependencies:
-    errno "~0.1.1"
-
-level-iterator-stream@~1.3.0:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/level-iterator-stream/-/level-iterator-stream-1.3.1.tgz#e43b78b1a8143e6fa97a4f485eb8ea530352f2ed"
-  integrity sha1-5Dt4sagUPm+pek9IXrjqUwNS8u0=
-  dependencies:
-    inherits "^2.0.1"
-    level-errors "^1.0.3"
-    readable-stream "^1.0.33"
-    xtend "^4.0.0"
-
-level-iterator-stream@~4.0.0:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/level-iterator-stream/-/level-iterator-stream-4.0.2.tgz#7ceba69b713b0d7e22fcc0d1f128ccdc8a24f79c"
-  integrity sha512-ZSthfEqzGSOMWoUGhTXdX9jv26d32XJuHz/5YnuHZzH6wldfWMOVwI9TBtKcya4BKTyTt3XVA0A3cF3q5CY30Q==
-  dependencies:
-    inherits "^2.0.4"
-    readable-stream "^3.4.0"
-    xtend "^4.0.2"
-
-level-js@^4.0.0:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/level-js/-/level-js-4.0.2.tgz#fa51527fa38b87c4d111b0d0334de47fcda38f21"
-  integrity sha512-PeGjZsyMG4O89KHiez1zoMJxStnkM+oBIqgACjoo5PJqFiSUUm3GNod/KcbqN5ktyZa8jkG7I1T0P2u6HN9lIg==
-  dependencies:
-    abstract-leveldown "~6.0.1"
-    immediate "~3.2.3"
-    inherits "^2.0.3"
-    ltgt "^2.1.2"
-    typedarray-to-buffer "~3.1.5"
-
-level-packager@^5.0.0:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/level-packager/-/level-packager-5.1.1.tgz#323ec842d6babe7336f70299c14df2e329c18939"
-  integrity sha512-HMwMaQPlTC1IlcwT3+swhqf/NUO+ZhXVz6TY1zZIIZlIR0YSn8GtAAWmIvKjNY16ZkEg/JcpAuQskxsXqC0yOQ==
-  dependencies:
-    encoding-down "^6.3.0"
-    levelup "^4.3.2"
-
-level-supports@~1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/level-supports/-/level-supports-1.0.1.tgz#2f530a596834c7301622521988e2c36bb77d122d"
-  integrity sha512-rXM7GYnW8gsl1vedTJIbzOrRv85c/2uCMpiiCzO2fndd06U/kUXEEU9evYn4zFggBOg36IsBW8LzqIpETwwQzg==
-  dependencies:
-    xtend "^4.0.2"
-
-level-write-stream@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/level-write-stream/-/level-write-stream-1.0.0.tgz#3f7fbb679a55137c0feb303dee766e12ee13c1dc"
-  integrity sha1-P3+7Z5pVE3wP6zA97nZuEu4Twdw=
-  dependencies:
-    end-stream "~0.1.0"
-
-level-ws@0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/level-ws/-/level-ws-0.0.0.tgz#372e512177924a00424b0b43aef2bb42496d228b"
-  integrity sha1-Ny5RIXeSSgBCSwtDrvK7QkltIos=
-  dependencies:
-    readable-stream "~1.0.15"
-    xtend "~2.1.1"
-
-level@5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/level/-/level-5.0.1.tgz#8528cc1ee37ac413270129a1eab938c610be3ccb"
-  integrity sha512-wcak5OQeA4rURGacqS62R/xNHjCYnJSQDBOlm4KNUGJVE9bWv2B04TclqReYejN+oD65PzD4FsqeWoI5wNC5Lg==
-  dependencies:
-    level-js "^4.0.0"
-    level-packager "^5.0.0"
-    leveldown "^5.0.0"
-    opencollective-postinstall "^2.0.0"
-
-leveldown@5.0.2:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/leveldown/-/leveldown-5.0.2.tgz#c8edc2308c8abf893ffc81e66ab6536111cae92c"
-  integrity sha512-Ib6ygFYBleS8x2gh3C1AkVsdrUShqXpe6jSTnZ6sRycEXKhqVf+xOSkhgSnjidpPzyv0d95LJVFrYQ4NuXAqHA==
-  dependencies:
-    abstract-leveldown "~6.0.0"
-    fast-future "~1.0.2"
-    napi-macros "~1.8.1"
-    node-gyp-build "~3.8.0"
-
-leveldown@^5.0.0:
-  version "5.6.0"
-  resolved "https://registry.yarnpkg.com/leveldown/-/leveldown-5.6.0.tgz#16ba937bb2991c6094e13ac5a6898ee66d3eee98"
-  integrity sha512-iB8O/7Db9lPaITU1aA2txU/cBEXAt4vWwKQRrrWuS6XDgbP4QZGj9BL2aNbwb002atoQ/lIotJkfyzz+ygQnUQ==
-  dependencies:
-    abstract-leveldown "~6.2.1"
-    napi-macros "~2.0.0"
-    node-gyp-build "~4.1.0"
-
-levelup@4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/levelup/-/levelup-4.0.2.tgz#bcb8d28d0a82ee97f1c6d00f20ea6d32c2803c5b"
-  integrity sha512-cx9PmLENwbGA3svWBEbeO2HazpOSOYSXH4VA+ahVpYyurvD+SDSfURl29VBY2qgyk+Vfy2dJd71SBRckj/EZVA==
-  dependencies:
-    deferred-leveldown "~5.0.0"
-    level-errors "~2.0.0"
-    level-iterator-stream "~4.0.0"
-    xtend "~4.0.0"
-
-levelup@4.4.0, levelup@^4.3.2:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/levelup/-/levelup-4.4.0.tgz#f89da3a228c38deb49c48f88a70fb71f01cafed6"
-  integrity sha512-94++VFO3qN95cM/d6eBXvd894oJE0w3cInq9USsyQzzoJxmiYzPAocNcuGCPGGjoXqDVJcr3C1jzt1TSjyaiLQ==
-  dependencies:
-    deferred-leveldown "~5.3.0"
-    level-errors "~2.0.0"
-    level-iterator-stream "~4.0.0"
-    level-supports "~1.0.0"
-    xtend "~4.0.0"
-
-levelup@^1.2.1:
-  version "1.3.9"
-  resolved "https://registry.yarnpkg.com/levelup/-/levelup-1.3.9.tgz#2dbcae845b2bb2b6bea84df334c475533bbd82ab"
-  integrity sha512-VVGHfKIlmw8w1XqpGOAGwq6sZm2WwWLmlDcULkKWQXEA5EopA8OBNJ2Ck2v6bdk8HeEZSbCSEgzXadyQFm76sQ==
-  dependencies:
-    deferred-leveldown "~1.2.1"
-    level-codec "~7.0.0"
-    level-errors "~1.0.3"
-    level-iterator-stream "~1.3.0"
-    prr "~1.0.1"
-    semver "~5.4.1"
-    xtend "~4.0.0"
-
-levn@~0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
-  integrity sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=
-  dependencies:
-    prelude-ls "~1.1.2"
-    type-check "~0.3.2"
-
-lines-and-columns@^1.1.6:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632"
-  integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
-
-linked-list@0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/linked-list/-/linked-list-0.1.0.tgz#798b0ff97d1b92a4fd08480f55aea4e9d49d37bf"
-  integrity sha1-eYsP+X0bkqT9CEgPVa6k6dSdN78=
-
-load-json-file@^1.0.0, load-json-file@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"
-  integrity sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=
-  dependencies:
-    graceful-fs "^4.1.2"
-    parse-json "^2.2.0"
-    pify "^2.0.0"
-    pinkie-promise "^2.0.0"
-    strip-bom "^2.0.0"
-
-locate-path@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e"
-  integrity sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=
-  dependencies:
-    p-locate "^2.0.0"
-    path-exists "^3.0.0"
-
-locate-path@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-3.0.0.tgz#dbec3b3ab759758071b58fe59fc41871af21400e"
-  integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==
-  dependencies:
-    p-locate "^3.0.0"
-    path-exists "^3.0.0"
-
-locate-path@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
-  integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==
-  dependencies:
-    p-locate "^4.1.0"
-
-locate-path@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286"
-  integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
-  dependencies:
-    p-locate "^5.0.0"
-
-lodash-es@^4.2.1:
-  version "4.17.21"
-  resolved "https://registry.yarnpkg.com/lodash-es/-/lodash-es-4.17.21.tgz#43e626c46e6591b7750beb2b50117390c609e3ee"
-  integrity sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==
-
-lodash._reinterpolate@^3.0.0, lodash._reinterpolate@~3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz#0ccf2d89166af03b3663c796538b75ac6e114d9d"
-  integrity sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=
-
-lodash.assign@^4.0.3, lodash.assign@^4.0.6:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.assign/-/lodash.assign-4.2.0.tgz#0d99f3ccd7a6d261d19bdaeb9245005d285808e7"
-  integrity sha1-DZnzzNem0mHRm9rrkkUAXShYCOc=
-
-lodash.assignin@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.assignin/-/lodash.assignin-4.2.0.tgz#ba8df5fb841eb0a3e8044232b0e263a8dc6a28a2"
-  integrity sha1-uo31+4QesKPoBEIysOJjqNxqKKI=
-
-lodash.assigninwith@^4.0.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.assigninwith/-/lodash.assigninwith-4.2.0.tgz#af02c98432ac86d93da695b4be801401971736af"
-  integrity sha1-rwLJhDKshtk9ppW0voAUAZcXNq8=
-
-lodash.camelcase@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz#b28aa6288a2b9fc651035c7711f65ab6190331a6"
-  integrity sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==
-
-lodash.clonedeep@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz#e23f3f9c4f8fbdde872529c1071857a086e5ccef"
-  integrity sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=
-
-lodash.debounce@^4.0.8:
-  version "4.0.8"
-  resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
-  integrity sha1-gteb/zCmfEAF/9XiUVMArZyk168=
-
-lodash.escaperegexp@^4.1.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/lodash.escaperegexp/-/lodash.escaperegexp-4.1.2.tgz#64762c48618082518ac3df4ccf5d5886dae20347"
-  integrity sha1-ZHYsSGGAglGKw99Mz11YhtriA0c=
-
-lodash.flatmap@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.flatmap/-/lodash.flatmap-4.5.0.tgz#ef8cbf408f6e48268663345305c6acc0b778702e"
-  integrity sha1-74y/QI9uSCaGYzRTBcaswLd4cC4=
-
-lodash.flatten@^4.4.0:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/lodash.flatten/-/lodash.flatten-4.4.0.tgz#f31c22225a9632d2bbf8e4addbef240aa765a61f"
-  integrity sha1-8xwiIlqWMtK7+OSt2+8kCqdlph8=
-
-lodash.isequal@^4.0.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.isequal/-/lodash.isequal-4.5.0.tgz#415c4478f2bcc30120c22ce10ed3226f7d3e18e0"
-  integrity sha1-QVxEePK8wwEgwizhDtMib30+GOA=
-
-lodash.kebabcase@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/lodash.kebabcase/-/lodash.kebabcase-4.1.1.tgz#8489b1cb0d29ff88195cceca448ff6d6cc295c36"
-  integrity sha512-N8XRTIMMqqDgSy4VLKPnJ/+hpGZN+PHQiJnSenYqPaVV/NCqEogTnAdZLQiGKhxX+JCs8waWq2t1XHWKOmlY8g==
-
-lodash.keys@^4.0.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.keys/-/lodash.keys-4.2.0.tgz#a08602ac12e4fb83f91fc1fb7a360a4d9ba35205"
-  integrity sha1-oIYCrBLk+4P5H8H7ejYKTZujUgU=
-
-lodash.lowercase@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/lodash.lowercase/-/lodash.lowercase-4.3.0.tgz#46515aced4acb0b7093133333af068e4c3b14e9d"
-  integrity sha512-UcvP1IZYyDKyEL64mmrwoA1AbFu5ahojhTtkOUr1K9dbuxzS9ev8i4TxMMGCqRC9TE8uDaSoufNAXxRPNTseVA==
-
-lodash.lowerfirst@^4.3.1:
-  version "4.3.1"
-  resolved "https://registry.yarnpkg.com/lodash.lowerfirst/-/lodash.lowerfirst-4.3.1.tgz#de3c7b12e02c6524a0059c2f6cb7c5c52655a13d"
-  integrity sha512-UUKX7VhP1/JL54NXg2aq/E1Sfnjjes8fNYTNkPU8ZmsaVeBvPHKdbNaN79Re5XRL01u6wbq3j0cbYZj71Fcu5w==
-
-lodash.merge@^4.6.2:
-  version "4.6.2"
-  resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
-  integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
-
-lodash.pad@^4.5.1:
-  version "4.5.1"
-  resolved "https://registry.yarnpkg.com/lodash.pad/-/lodash.pad-4.5.1.tgz#4330949a833a7c8da22cc20f6a26c4d59debba70"
-  integrity sha512-mvUHifnLqM+03YNzeTBS1/Gr6JRFjd3rRx88FHWUvamVaT9k2O/kXha3yBSOwB9/DTQrSTLJNHvLBBt2FdX7Mg==
-
-lodash.padend@^4.6.1:
-  version "4.6.1"
-  resolved "https://registry.yarnpkg.com/lodash.padend/-/lodash.padend-4.6.1.tgz#53ccba047d06e158d311f45da625f4e49e6f166e"
-  integrity sha512-sOQs2aqGpbl27tmCS1QNZA09Uqp01ZzWfDUoD+xzTii0E7dSQfRKcRetFwa+uXaxaqL+TKm7CgD2JdKP7aZBSw==
-
-lodash.padstart@^4.6.1:
-  version "4.6.1"
-  resolved "https://registry.yarnpkg.com/lodash.padstart/-/lodash.padstart-4.6.1.tgz#d2e3eebff0d9d39ad50f5cbd1b52a7bce6bb611b"
-  integrity sha512-sW73O6S8+Tg66eY56DBk85aQzzUJDtpoXFBgELMd5P/SotAguo+1kYO6RuYgXxA4HJH3LFTFPASX6ET6bjfriw==
-
-lodash.partition@^4.6.0:
-  version "4.6.0"
-  resolved "https://registry.yarnpkg.com/lodash.partition/-/lodash.partition-4.6.0.tgz#a38e46b73469e0420b0da1212e66d414be364ba4"
-  integrity sha1-o45GtzRp4EILDaEhLmbUFL42S6Q=
-
-lodash.repeat@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/lodash.repeat/-/lodash.repeat-4.1.0.tgz#fc7de8131d8c8ac07e4b49f74ffe829d1f2bec44"
-  integrity sha512-eWsgQW89IewS95ZOcr15HHCX6FVDxq3f2PNUIng3fyzsPev9imFQxIYdFZ6crl8L56UR6ZlGDLcEb3RZsCSSqw==
-
-lodash.rest@^4.0.0:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/lodash.rest/-/lodash.rest-4.0.5.tgz#954ef75049262038c96d1fc98b28fdaf9f0772aa"
-  integrity sha1-lU73UEkmIDjJbR/Jiyj9r58Hcqo=
-
-lodash.snakecase@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz#39d714a35357147837aefd64b5dcbb16becd8f8d"
-  integrity sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==
-
-lodash.sortby@^4.7.0:
-  version "4.7.0"
-  resolved "https://registry.yarnpkg.com/lodash.sortby/-/lodash.sortby-4.7.0.tgz#edd14c824e2cc9c1e0b0a1b42bb5210516a42438"
-  integrity sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=
-
-lodash.startcase@^4.4.0:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/lodash.startcase/-/lodash.startcase-4.4.0.tgz#9436e34ed26093ed7ffae1936144350915d9add8"
-  integrity sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==
-
-lodash.sum@^4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/lodash.sum/-/lodash.sum-4.0.2.tgz#ad90e397965d803d4f1ff7aa5b2d0197f3b4637b"
-  integrity sha1-rZDjl5ZdgD1PH/eqWy0Bl/O0Y3s=
-
-lodash.template@4.2.4:
-  version "4.2.4"
-  resolved "https://registry.yarnpkg.com/lodash.template/-/lodash.template-4.2.4.tgz#d053c19e8e74e38d965bf4fb495d80f109e7f7a4"
-  integrity sha1-0FPBno50442WW/T7SV2A8Qnn96Q=
-  dependencies:
-    lodash._reinterpolate "~3.0.0"
-    lodash.assigninwith "^4.0.0"
-    lodash.keys "^4.0.0"
-    lodash.rest "^4.0.0"
-    lodash.templatesettings "^4.0.0"
-    lodash.tostring "^4.0.0"
-
-lodash.templatesettings@^4.0.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.templatesettings/-/lodash.templatesettings-4.2.0.tgz#e481310f049d3cf6d47e912ad09313b154f0fb33"
-  integrity sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==
-  dependencies:
-    lodash._reinterpolate "^3.0.0"
-
-lodash.tostring@^4.0.0:
-  version "4.1.4"
-  resolved "https://registry.yarnpkg.com/lodash.tostring/-/lodash.tostring-4.1.4.tgz#560c27d1f8eadde03c2cce198fef5c031d8298fb"
-  integrity sha1-Vgwn0fjq3eA8LM4Zj+9cAx2CmPs=
-
-lodash.trim@^4.5.1:
-  version "4.5.1"
-  resolved "https://registry.yarnpkg.com/lodash.trim/-/lodash.trim-4.5.1.tgz#36425e7ee90be4aa5e27bcebb85b7d11ea47aa57"
-  integrity sha512-nJAlRl/K+eiOehWKDzoBVrSMhK0K3A3YQsUNXHQa5yIrKBAhsZgSu3KoAFoFT+mEgiyBHddZ0pRk1ITpIp90Wg==
-
-lodash.trimend@^4.5.1:
-  version "4.5.1"
-  resolved "https://registry.yarnpkg.com/lodash.trimend/-/lodash.trimend-4.5.1.tgz#12804437286b98cad8996b79414e11300114082f"
-  integrity sha512-lsD+k73XztDsMBKPKvzHXRKFNMohTjoTKIIo4ADLn5dA65LZ1BqlAvSXhR2rPEC3BgAUQnzMnorqDtqn2z4IHA==
-
-lodash.trimstart@^4.5.1:
-  version "4.5.1"
-  resolved "https://registry.yarnpkg.com/lodash.trimstart/-/lodash.trimstart-4.5.1.tgz#8ff4dec532d82486af59573c39445914e944a7f1"
-  integrity sha512-b/+D6La8tU76L/61/aN0jULWHkT0EeJCmVstPBn/K9MtD2qBW83AsBNrr63dKuWYwVMO7ucv13QNO/Ek/2RKaQ==
-
-lodash.uppercase@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/lodash.uppercase/-/lodash.uppercase-4.3.0.tgz#c404abfd1469f93931f9bb24cf6cc7d57059bc73"
-  integrity sha512-+Nbnxkj7s8K5U8z6KnEYPGUOGp3woZbB7Ecs7v3LkkjLQSm2kP9SKIILitN1ktn2mB/tmM9oSlku06I+/lH7QA==
-
-lodash.upperfirst@^4.3.1:
-  version "4.3.1"
-  resolved "https://registry.yarnpkg.com/lodash.upperfirst/-/lodash.upperfirst-4.3.1.tgz#1365edf431480481ef0d1c68957a5ed99d49f7ce"
-  integrity sha512-sReKOYJIJf74dhJONhU4e0/shzi1trVbSWDOhKYE5XV2O+H7Sb2Dihwuc7xWxVl+DgFPyTqIN3zMfT9cq5iWDg==
-
-lodash.zipwith@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.zipwith/-/lodash.zipwith-4.2.0.tgz#afacf03fd2f384af29e263c3c6bda3b80e3f51fd"
-  integrity sha1-r6zwP9LzhK8p4mPDxr2juA4/Uf0=
-
-lodash@4.17.21, lodash@^4.1.0, lodash@^4.15.0, lodash@^4.17.11, lodash@^4.17.14, lodash@^4.17.19, lodash@^4.17.4, lodash@^4.2.1:
-  version "4.17.21"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
-  integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
-
-log-symbols@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-4.0.0.tgz#69b3cc46d20f448eccdb75ea1fa733d9e821c920"
-  integrity sha512-FN8JBzLx6CzeMrB0tg6pqlGU1wCrXW+ZXGH481kfsBqer0hToTIiHdjH4Mq8xJUbvATujKCvaREGWpGUionraA==
-  dependencies:
-    chalk "^4.0.0"
-
-log-symbols@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-2.2.0.tgz#5740e1c5d6f0dfda4ad9323b5332107ef6b4c40a"
-  integrity sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==
-  dependencies:
-    chalk "^2.0.1"
-
-log-symbols@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-3.0.0.tgz#f3a08516a5dea893336a7dee14d18a1cfdab77c4"
-  integrity sha512-dSkNGuI7iG3mfvDzUuYZyvk5dD9ocYCYzNU6CYDE6+Xqd+gwme6Z00NS3dUh8mq/73HaEtT7m6W+yUPtU6BZnQ==
-  dependencies:
-    chalk "^2.4.2"
-
-loglevel@^1.6.7:
-  version "1.7.1"
-  resolved "https://registry.yarnpkg.com/loglevel/-/loglevel-1.7.1.tgz#005fde2f5e6e47068f935ff28573e125ef72f197"
-  integrity sha512-Hesni4s5UkWkwCGJMQGAh71PaLUmKFM60dHvq0zi/vDhhrzuk+4GgNbTXJ12YYQJn6ZKBDNIjYcuQGKudvqrIw==
-
-long@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/long/-/long-4.0.0.tgz#9a7b71cfb7d361a194ea555241c92f7468d5bf28"
-  integrity sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==
-
-long@^5.2.0:
-  version "5.2.3"
-  resolved "https://registry.yarnpkg.com/long/-/long-5.2.3.tgz#a3ba97f3877cf1d778eccbcb048525ebb77499e1"
-  integrity sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q==
-
-loose-envify@^1.0.0, loose-envify@^1.1.0, loose-envify@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf"
-  integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==
-  dependencies:
-    js-tokens "^3.0.0 || ^4.0.0"
-
-lower-case-first@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/lower-case-first/-/lower-case-first-1.0.2.tgz#e5da7c26f29a7073be02d52bac9980e5922adfa1"
-  integrity sha1-5dp8JvKacHO+AtUrrJmA5ZIq36E=
-  dependencies:
-    lower-case "^1.1.2"
-
-lower-case@^1.1.0, lower-case@^1.1.1, lower-case@^1.1.2:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-1.1.4.tgz#9a2cabd1b9e8e0ae993a4bf7d5875c39c42e8eac"
-  integrity sha1-miyr0bno4K6ZOkv31YdcOcQujqw=
-
-lower-case@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-2.0.2.tgz#6fa237c63dbdc4a82ca0fd882e4722dc5e634e28"
-  integrity sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==
-  dependencies:
-    tslib "^2.0.3"
-
-lowercase-keys@^1.0.0, lowercase-keys@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-1.0.1.tgz#6f9e30b47084d971a7c820ff15a6c5167b74c26f"
-  integrity sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==
-
-lowercase-keys@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-2.0.0.tgz#2603e78b7b4b0006cbca2fbcc8a3202558ac9479"
-  integrity sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==
-
-lru-cache@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
-  integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
-  dependencies:
-    yallist "^4.0.0"
-
-lru-cache@^9.1.1:
-  version "9.1.1"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-9.1.1.tgz#c58a93de58630b688de39ad04ef02ef26f1902f1"
-  integrity sha512-65/Jky17UwSb0BuB9V+MyDpsOtXKmYwzhyl+cOa9XUiI4uV2Ouy/2voFP3+al0BjZbJgMBD8FojMpAf+Z+qn4A==
-
-ltgt@2.2.1, ltgt@^2.1.2, ltgt@~2.2.0:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/ltgt/-/ltgt-2.2.1.tgz#f35ca91c493f7b73da0e07495304f17b31f87ee5"
-  integrity sha1-81ypHEk/e3PaDgdJUwTxezH4fuU=
-
-make-dir@^1.0.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-1.3.0.tgz#79c1033b80515bd6d24ec9933e860ca75ee27f0c"
-  integrity sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==
-  dependencies:
-    pify "^3.0.0"
-
-make-error@^1.1.1:
-  version "1.3.6"
-  resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
-  integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
-
-map-stream@0.0.6:
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/map-stream/-/map-stream-0.0.6.tgz#d2ef4eb811a28644c7a8989985c69c2fdd496827"
-  integrity sha1-0u9OuBGihkTHqJiZhcacL91JaCc=
-
-marked@0.3.19:
-  version "0.3.19"
-  resolved "https://registry.yarnpkg.com/marked/-/marked-0.3.19.tgz#5d47f709c4c9fc3c216b6d46127280f40b39d790"
-  integrity sha512-ea2eGWOqNxPcXv8dyERdSr/6FmzvWwzjMxpfGB/sbMccXoct+xY+YukPD+QTUZwyvK7BZwcr4m21WBOW41pAkg==
-
-math-random@^1.0.1:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/math-random/-/math-random-1.0.4.tgz#5dd6943c938548267016d4e34f057583080c514c"
-  integrity sha512-rUxjysqif/BZQH2yhd5Aaq7vXMSx9NdEsQcyA07uEzIvxgI7zIr33gGsh+RU0/XjmQpCW7RsVof1vlkvQVCK5A==
-
-md5.js@^1.3.4:
-  version "1.3.5"
-  resolved "https://registry.yarnpkg.com/md5.js/-/md5.js-1.3.5.tgz#b5d07b8e3216e3e27cd728d72f70d1e6a342005f"
-  integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==
-  dependencies:
-    hash-base "^3.0.0"
-    inherits "^2.0.1"
-    safe-buffer "^5.1.2"
-
-media-typer@0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
-  integrity sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==
-
-memdown@1.4.1, memdown@^1.0.0:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/memdown/-/memdown-1.4.1.tgz#b4e4e192174664ffbae41361aa500f3119efe215"
-  integrity sha1-tOThkhdGZP+65BNhqlAPMRnv4hU=
-  dependencies:
-    abstract-leveldown "~2.7.1"
-    functional-red-black-tree "^1.0.1"
-    immediate "^3.2.3"
-    inherits "~2.0.1"
-    ltgt "~2.2.0"
-    safe-buffer "~5.1.1"
-
-memorystream@^0.3.1:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/memorystream/-/memorystream-0.3.1.tgz#86d7090b30ce455d63fbae12dda51a47ddcaf9b2"
-  integrity sha1-htcJCzDORV1j+64S3aUaR93K+bI=
-
-merge-descriptors@1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/merge-descriptors/-/merge-descriptors-1.0.1.tgz#b00aaa556dd8b44568150ec9d1b953f3f90cbb61"
-  integrity sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==
-
-merge-options@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/merge-options/-/merge-options-3.0.4.tgz#84709c2aa2a4b24c1981f66c179fe5565cc6dbb7"
-  integrity sha512-2Sug1+knBjkaMsMgf1ctR1Ujx+Ayku4EdJN4Z+C2+JzoeF7A3OZ9KM2GY0CpQS51NR61LTurMJrRKPhSs3ZRTQ==
-  dependencies:
-    is-plain-obj "^2.1.0"
-
-merge-stream@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-1.0.1.tgz#4041202d508a342ba00174008df0c251b8c135e1"
-  integrity sha1-QEEgLVCKNCugAXQAjfDCUbjBNeE=
-  dependencies:
-    readable-stream "^2.0.1"
-
-merge-stream@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
-  integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
-
-merge2@^1.3.0, merge2@^1.4.1:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
-  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
-
-merkle-patricia-tree@^2.1.2, merkle-patricia-tree@^2.3.2:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/merkle-patricia-tree/-/merkle-patricia-tree-2.3.2.tgz#982ca1b5a0fde00eed2f6aeed1f9152860b8208a"
-  integrity sha512-81PW5m8oz/pz3GvsAwbauj7Y00rqm81Tzad77tHBwU7pIAtN+TJnMSOJhxBKflSVYhptMMb9RskhqHqrSm1V+g==
-  dependencies:
-    async "^1.4.2"
-    ethereumjs-util "^5.0.0"
-    level-ws "0.0.0"
-    levelup "^1.2.1"
-    memdown "^1.0.0"
-    readable-stream "^2.0.0"
-    rlp "^2.0.0"
-    semaphore ">=1.0.1"
-
-methods@~1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/methods/-/methods-1.1.2.tgz#5529a4d67654134edcc5266656835b0f851afcee"
-  integrity sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==
-
-micromatch@^2.3.7:
-  version "2.3.11"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-2.3.11.tgz#86677c97d1720b363431d04d0d15293bd38c1565"
-  integrity sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=
-  dependencies:
-    arr-diff "^2.0.0"
-    array-unique "^0.2.1"
-    braces "^1.8.2"
-    expand-brackets "^0.1.4"
-    extglob "^0.3.1"
-    filename-regex "^2.0.0"
-    is-extglob "^1.0.0"
-    is-glob "^2.0.1"
-    kind-of "^3.0.2"
-    normalize-path "^2.0.1"
-    object.omit "^2.0.0"
-    parse-glob "^3.0.4"
-    regex-cache "^0.4.2"
-
-micromatch@^4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.2.tgz#4fcb0999bf9fbc2fcbdd212f6d629b9a56c39259"
-  integrity sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==
-  dependencies:
-    braces "^3.0.1"
-    picomatch "^2.0.5"
-
-micromatch@^4.0.4:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6"
-  integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==
-  dependencies:
-    braces "^3.0.2"
-    picomatch "^2.3.1"
-
-miller-rabin@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/miller-rabin/-/miller-rabin-4.0.1.tgz#f080351c865b0dc562a8462966daa53543c78a4d"
-  integrity sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==
-  dependencies:
-    bn.js "^4.0.0"
-    brorand "^1.0.1"
-
-mime-db@1.46.0:
-  version "1.46.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.46.0.tgz#6267748a7f799594de3cbc8cde91def349661cee"
-  integrity sha512-svXaP8UQRZ5K7or+ZmfNhg2xX3yKDMUzqadsSqi4NCH/KomcH75MAMYAGVlvXn4+b/xOPhS3I2uHKRUzvjY7BQ==
-
-mime-db@1.52.0:
-  version "1.52.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
-  integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
-
-mime-types@^2.1.12, mime-types@~2.1.19, mime-types@~2.1.24, mime-types@~2.1.34:
-  version "2.1.35"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a"
-  integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
-  dependencies:
-    mime-db "1.52.0"
-
-mime-types@^2.1.16:
-  version "2.1.29"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.29.tgz#1d4ab77da64b91f5f72489df29236563754bb1b2"
-  integrity sha512-Y/jMt/S5sR9OaqteJtslsFZKWOIIqMACsJSiHghlCAyhf7jfVYjKBmLiX8OgpWeW+fjJ2b+Az69aPFPkUOY6xQ==
-  dependencies:
-    mime-db "1.46.0"
-
-mime@1.6.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1"
-  integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==
-
-mimic-fn@^1.0.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.2.0.tgz#820c86a39334640e99516928bd03fca88057d022"
-  integrity sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==
-
-mimic-fn@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
-  integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
-
-mimic-response@^1.0.0, mimic-response@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-1.0.1.tgz#4923538878eef42063cb8a3e3b0798781487ab1b"
-  integrity sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==
-
-min-document@^2.19.0:
-  version "2.19.0"
-  resolved "https://registry.yarnpkg.com/min-document/-/min-document-2.19.0.tgz#7bd282e3f5842ed295bb748cdd9f1ffa2c824685"
-  integrity sha1-e9KC4/WELtKVu3SM3Z8f+iyCRoU=
-  dependencies:
-    dom-walk "^0.1.0"
-
-min-indent@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
-  integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==
-
-minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7"
-  integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
-
-minimalistic-crypto-utils@^1.0.0, minimalistic-crypto-utils@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a"
-  integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=
-
-"minimatch@2 || 3", minimatch@3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
-  integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==
-  dependencies:
-    brace-expansion "^1.1.7"
-
-minimatch@^3.0.2, minimatch@^3.0.4, minimatch@^3.1.1, minimatch@^3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
-  integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
-  dependencies:
-    brace-expansion "^1.1.7"
-
-minimatch@^5.0.1:
-  version "5.1.6"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-5.1.6.tgz#1cfcb8cf5522ea69952cd2af95ae09477f122a96"
-  integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==
-  dependencies:
-    brace-expansion "^2.0.1"
-
-minimatch@^8.0.2:
-  version "8.0.4"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-8.0.4.tgz#847c1b25c014d4e9a7f68aaf63dedd668a626229"
-  integrity sha512-W0Wvr9HyFXZRGIDgCicunpQ299OKXs9RgZfaukz4qAW/pJhcpUfupc9c+OObPOFueNy8VSrZgEmDtk6Kh4WzDA==
-  dependencies:
-    brace-expansion "^2.0.1"
-
-minimist@0.0.8:
-  version "0.0.8"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d"
-  integrity sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=
-
-minimist@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284"
-  integrity sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=
-
-minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6:
-  version "1.2.6"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.6.tgz#8637a5b759ea0d6e98702cfb3a9283323c93af44"
-  integrity sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==
-
-minipass@^2.6.0, minipass@^2.9.0:
-  version "2.9.0"
-  resolved "https://registry.yarnpkg.com/minipass/-/minipass-2.9.0.tgz#e713762e7d3e32fed803115cf93e04bca9fcc9a6"
-  integrity sha512-wxfUjg9WebH+CUDX/CdbRlh5SmfZiy/hpkxaRI16Y9W56Pa75sWgd/rvFilSgrauD9NyFymP/+JFV3KwzIsJeg==
-  dependencies:
-    safe-buffer "^5.1.2"
-    yallist "^3.0.0"
-
-minipass@^3.0.0:
-  version "3.3.4"
-  resolved "https://registry.yarnpkg.com/minipass/-/minipass-3.3.4.tgz#ca99f95dd77c43c7a76bf51e6d200025eee0ffae"
-  integrity sha512-I9WPbWHCGu8W+6k1ZiGpPu0GkoKBeorkfKNuAFBNS1HNFJvke82sxvI5bzcCNpWPorkOO5QQ+zomzzwRxejXiw==
-  dependencies:
-    yallist "^4.0.0"
-
-minipass@^4.2.4:
-  version "4.2.8"
-  resolved "https://registry.yarnpkg.com/minipass/-/minipass-4.2.8.tgz#f0010f64393ecfc1d1ccb5f582bcaf45f48e1a3a"
-  integrity sha512-fNzuVyifolSLFL4NzpF+wEF4qrgqaaKX0haXPQEdQ7NKAN+WecoKMHV09YcuL/DHxrUsYQOK3MiuDf7Ip2OXfQ==
-
-"minipass@^5.0.0 || ^6.0.2":
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/minipass/-/minipass-6.0.2.tgz#542844b6c4ce95b202c0995b0a471f1229de4c81"
-  integrity sha512-MzWSV5nYVT7mVyWCwn2o7JH13w2TBRmmSqSRCKzTw+lmft9X4z+3wjvs06Tzijo5z4W/kahUCDpRXTF+ZrmF/w==
-
-minizlib@^1.3.3:
-  version "1.3.3"
-  resolved "https://registry.yarnpkg.com/minizlib/-/minizlib-1.3.3.tgz#2290de96818a34c29551c8a8d301216bd65a861d"
-  integrity sha512-6ZYMOEnmVsdCeTJVE0W9ZD+pVnE8h9Hma/iOwwRDsdQoePpoX56/8B6z3P9VNwppJuBKNRuFDRNRqRWexT9G9Q==
-  dependencies:
-    minipass "^2.9.0"
-
-minizlib@^2.1.1:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/minizlib/-/minizlib-2.1.2.tgz#e90d3466ba209b932451508a11ce3d3632145931"
-  integrity sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==
-  dependencies:
-    minipass "^3.0.0"
-    yallist "^4.0.0"
-
-mkdirp-promise@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/mkdirp-promise/-/mkdirp-promise-5.0.1.tgz#e9b8f68e552c68a9c1713b84883f7a1dd039b8a1"
-  integrity sha1-6bj2jlUsaKnBcTuEiD96HdA5uKE=
-  dependencies:
-    mkdirp "*"
-
-mkdirp@*, mkdirp@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
-  integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
-
-mkdirp@0.5.1:
-  version "0.5.1"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903"
-  integrity sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=
-  dependencies:
-    minimist "0.0.8"
-
-mkdirp@^0.5.0, mkdirp@^0.5.5:
-  version "0.5.5"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def"
-  integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==
-  dependencies:
-    minimist "^1.2.5"
-
-mkdirp@^0.5.1:
-  version "0.5.6"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.6.tgz#7def03d2432dcae4ba1d611445c48396062255f6"
-  integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==
-  dependencies:
-    minimist "^1.2.6"
-
-mocha@8.1.2:
-  version "8.1.2"
-  resolved "https://registry.yarnpkg.com/mocha/-/mocha-8.1.2.tgz#d67fad13300e4f5cd48135a935ea566f96caf827"
-  integrity sha512-I8FRAcuACNMLQn3lS4qeWLxXqLvGf6r2CaLstDpZmMUUSmvW6Cnm1AuHxgbc7ctZVRcfwspCRbDHymPsi3dkJw==
-  dependencies:
-    ansi-colors "4.1.1"
-    browser-stdout "1.3.1"
-    chokidar "3.4.2"
-    debug "4.1.1"
-    diff "4.0.2"
-    escape-string-regexp "4.0.0"
-    find-up "5.0.0"
-    glob "7.1.6"
-    growl "1.10.5"
-    he "1.2.0"
-    js-yaml "3.14.0"
-    log-symbols "4.0.0"
-    minimatch "3.0.4"
-    ms "2.1.2"
-    object.assign "4.1.0"
-    promise.allsettled "1.0.2"
-    serialize-javascript "4.0.0"
-    strip-json-comments "3.0.1"
-    supports-color "7.1.0"
-    which "2.0.2"
-    wide-align "1.1.3"
-    workerpool "6.0.0"
-    yargs "13.3.2"
-    yargs-parser "13.1.2"
-    yargs-unparser "1.6.1"
-
-mock-fs@^4.1.0:
-  version "4.13.0"
-  resolved "https://registry.yarnpkg.com/mock-fs/-/mock-fs-4.13.0.tgz#31c02263673ec3789f90eb7b6963676aa407a598"
-  integrity sha512-DD0vOdofJdoaRNtnWcrXe6RQbpHkPPmtqGq14uRX0F8ZKJ5nv89CVTYl/BZdppDxBDaV0hl75htg3abpEWlPZA==
-
-module@^1.2.5:
-  version "1.2.5"
-  resolved "https://registry.yarnpkg.com/module/-/module-1.2.5.tgz#b503eb06cdc13473f56818426974cde7ec59bf15"
-  integrity sha1-tQPrBs3BNHP1aBhCaXTN5+xZvxU=
-  dependencies:
-    chalk "1.1.3"
-    concat-stream "1.5.1"
-    lodash.template "4.2.4"
-    map-stream "0.0.6"
-    tildify "1.2.0"
-    vinyl-fs "2.4.3"
-    yargs "4.6.0"
-
-ms@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
-  integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==
-
-ms@2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
-  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
-
-ms@2.1.3, ms@^2.1.1:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
-  integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
-
-multiaddr-to-uri@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.yarnpkg.com/multiaddr-to-uri/-/multiaddr-to-uri-8.0.0.tgz#65efe4b1f9de5f6b681aa42ff36a7c8db7625e58"
-  integrity sha512-dq4p/vsOOUdVEd1J1gl+R2GFrXJQH8yjLtz4hodqdVbieg39LvBOdMQRdQnfbg5LSM/q1BYNVf5CBbwZFFqBgA==
-  dependencies:
-    multiaddr "^10.0.0"
-
-multiaddr@^10.0.0:
-  version "10.0.1"
-  resolved "https://registry.yarnpkg.com/multiaddr/-/multiaddr-10.0.1.tgz#0d15848871370860a4d266bb44d93b3dac5d90ef"
-  integrity sha512-G5upNcGzEGuTHkzxezPrrD6CaIHR9uo+7MwqhNVcXTs33IInon4y7nMiGxl2CY5hG7chvYQUQhz5V52/Qe3cbg==
-  dependencies:
-    dns-over-http-resolver "^1.2.3"
-    err-code "^3.0.1"
-    is-ip "^3.1.0"
-    multiformats "^9.4.5"
-    uint8arrays "^3.0.0"
-    varint "^6.0.0"
-
-multibase@^0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/multibase/-/multibase-0.7.0.tgz#1adfc1c50abe05eefeb5091ac0c2728d6b84581b"
-  integrity sha512-TW8q03O0f6PNFTQDvh3xxH03c8CjGaaYrjkl9UQPG6rz53TQzzxJVCIWVjzcbN/Q5Y53Zd0IBQBMVktVgNx4Fg==
-  dependencies:
-    base-x "^3.0.8"
-    buffer "^5.5.0"
-
-multibase@~0.6.0:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/multibase/-/multibase-0.6.1.tgz#b76df6298536cc17b9f6a6db53ec88f85f8cc12b"
-  integrity sha512-pFfAwyTjbbQgNc3G7D48JkJxWtoJoBMaR4xQUOuB8RnCgRqaYmWNFeJTTvrJ2w51bjLq2zTby6Rqj9TQ9elSUw==
-  dependencies:
-    base-x "^3.0.8"
-    buffer "^5.5.0"
-
-multicodec@^0.5.5:
-  version "0.5.7"
-  resolved "https://registry.yarnpkg.com/multicodec/-/multicodec-0.5.7.tgz#1fb3f9dd866a10a55d226e194abba2dcc1ee9ffd"
-  integrity sha512-PscoRxm3f+88fAtELwUnZxGDkduE2HD9Q6GHUOywQLjOGT/HAdhjLDYNZ1e7VR0s0TP0EwZ16LNUTFpoBGivOA==
-  dependencies:
-    varint "^5.0.0"
-
-multicodec@^1.0.0:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/multicodec/-/multicodec-1.0.4.tgz#46ac064657c40380c28367c90304d8ed175a714f"
-  integrity sha512-NDd7FeS3QamVtbgfvu5h7fd1IlbaC4EQ0/pgU4zqE2vdHCmBGsUa0TiM8/TdSeG6BMPC92OOCf8F1ocE/Wkrrg==
-  dependencies:
-    buffer "^5.6.0"
-    varint "^5.0.0"
-
-multiformats@^9.4.13, multiformats@^9.4.2, multiformats@^9.4.5, multiformats@^9.5.4:
-  version "9.9.0"
-  resolved "https://registry.yarnpkg.com/multiformats/-/multiformats-9.9.0.tgz#c68354e7d21037a8f1f8833c8ccd68618e8f1d37"
-  integrity sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg==
-
-multihashes@^0.4.15, multihashes@~0.4.15:
-  version "0.4.21"
-  resolved "https://registry.yarnpkg.com/multihashes/-/multihashes-0.4.21.tgz#dc02d525579f334a7909ade8a122dabb58ccfcb5"
-  integrity sha512-uVSvmeCWf36pU2nB4/1kzYZjsXD9vofZKpgudqkceYY5g2aZZXJ5r9lxuzoRLl1OAp28XljXsEJ/X/85ZsKmKw==
-  dependencies:
-    buffer "^5.5.0"
-    multibase "^0.7.0"
-    varint "^5.0.0"
-
-mute-stream@0.0.8:
-  version "0.0.8"
-  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.8.tgz#1630c42b2251ff81e2a283de96a5497ea92e5e0d"
-  integrity sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==
-
-nan@^2.12.1:
-  version "2.14.2"
-  resolved "https://registry.yarnpkg.com/nan/-/nan-2.14.2.tgz#f5376400695168f4cc694ac9393d0c9585eeea19"
-  integrity sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ==
-
-nano-json-stream-parser@^0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/nano-json-stream-parser/-/nano-json-stream-parser-0.1.2.tgz#0cc8f6d0e2b622b479c40d499c46d64b755c6f5f"
-  integrity sha1-DMj20OK2IrR5xA1JnEbWS3Vcb18=
-
-nanoid@^2.0.0:
-  version "2.1.11"
-  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-2.1.11.tgz#ec24b8a758d591561531b4176a01e3ab4f0f0280"
-  integrity sha512-s/snB+WGm6uwi0WjsZdaVcuf3KJXlfGl2LcxgwkEwJF0D/BWzVWAZW/XY4bFaiR7s0Jk3FPvlnepg1H1b1UwlA==
-
-nanoid@^3.0.2, nanoid@^3.1.20, nanoid@^3.1.23:
-  version "3.3.6"
-  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.6.tgz#443380c856d6e9f9824267d960b4236ad583ea4c"
-  integrity sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==
-
-napi-macros@~1.8.1:
-  version "1.8.2"
-  resolved "https://registry.yarnpkg.com/napi-macros/-/napi-macros-1.8.2.tgz#299265c1d8aa401351ad0675107d751228c03eda"
-  integrity sha512-Tr0DNY4RzTaBG2W2m3l7ZtFuJChTH6VZhXVhkGGjF/4cZTt+i8GcM9ozD+30Lmr4mDoZ5Xx34t2o4GJqYWDGcg==
-
-napi-macros@~2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/napi-macros/-/napi-macros-2.0.0.tgz#2b6bae421e7b96eb687aa6c77a7858640670001b"
-  integrity sha512-A0xLykHtARfueITVDernsAWdtIMbOJgKgcluwENp3AlsKN/PloyO10HtmoqnFAQAcxPkgZN7wdfPfEd0zNGxbg==
-
-native-abort-controller@^1.0.3, native-abort-controller@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/native-abort-controller/-/native-abort-controller-1.0.4.tgz#39920155cc0c18209ff93af5bc90be856143f251"
-  integrity sha512-zp8yev7nxczDJMoP6pDxyD20IU0T22eX8VwN2ztDccKvSZhRaV33yP1BGwKSZfXuqWUzsXopVFjBdau9OOAwMQ==
-
-native-fetch@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/native-fetch/-/native-fetch-3.0.0.tgz#06ccdd70e79e171c365c75117959cf4fe14a09bb"
-  integrity sha512-G3Z7vx0IFb/FQ4JxvtqGABsOTIqRWvgQz6e+erkB+JJD6LrszQtMozEHI4EkmgZQvnGHrpLVzUWk7t4sJCIkVw==
-
-natural-orderby@^2.0.3:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/natural-orderby/-/natural-orderby-2.0.3.tgz#8623bc518ba162f8ff1cdb8941d74deb0fdcc016"
-  integrity sha512-p7KTHxU0CUrcOXe62Zfrb5Z13nLvPhSWR/so3kFulUQU0sgUll2Z0LwpsLN351eOOD+hRGu/F1g+6xDfPeD++Q==
-
-needle@^2.2.1:
-  version "2.6.0"
-  resolved "https://registry.yarnpkg.com/needle/-/needle-2.6.0.tgz#24dbb55f2509e2324b4a99d61f413982013ccdbe"
-  integrity sha512-KKYdza4heMsEfSWD7VPUIz3zX2XDwOyX2d+geb4vrERZMT5RMU6ujjaD+I5Yr54uZxQ2w6XRTAhHBbSCyovZBg==
-  dependencies:
-    debug "^3.2.6"
-    iconv-lite "^0.4.4"
-    sax "^1.2.4"
-
-negotiator@0.6.3:
-  version "0.6.3"
-  resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.3.tgz#58e323a72fedc0d6f9cd4d31fe49f51479590ccd"
-  integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==
-
-next-tick@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.0.0.tgz#ca86d1fe8828169b0120208e3dc8424b9db8342c"
-  integrity sha1-yobR/ogoFpsBICCOPchCS524NCw=
-
-nice-try@^1.0.4:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366"
-  integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==
-
-no-case@^2.2.0, no-case@^2.3.2:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/no-case/-/no-case-2.3.2.tgz#60b813396be39b3f1288a4c1ed5d1e7d28b464ac"
-  integrity sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==
-  dependencies:
-    lower-case "^1.1.1"
-
-no-case@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/no-case/-/no-case-3.0.4.tgz#d361fd5c9800f558551a8369fc0dcd4662b6124d"
-  integrity sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==
-  dependencies:
-    lower-case "^2.0.2"
-    tslib "^2.0.3"
-
-node-addon-api@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/node-addon-api/-/node-addon-api-2.0.2.tgz#432cfa82962ce494b132e9d72a15b29f71ff5d32"
-  integrity sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==
-
-node-fetch@1.7.3, node-fetch@~1.7.1:
-  version "1.7.3"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-1.7.3.tgz#980f6f72d85211a5347c6b2bc18c5b84c3eb47ef"
-  integrity sha512-NhZ4CsKx7cYm2vSrBAr2PvFOe6sWDf0UYLRqA6svUYg7+/TSfVAu49jYC4BvQ4Sms9SZgdqGBgroqfDhJdTyKQ==
-  dependencies:
-    encoding "^0.1.11"
-    is-stream "^1.0.1"
-
-node-fetch@2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.1.2.tgz#ab884e8e7e57e38a944753cec706f788d1768bb5"
-  integrity sha1-q4hOjn5X44qUR1POxwb3iNF2i7U=
-
-node-fetch@2.4.1:
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.4.1.tgz#b2e38f1117b8acbedbe0524f041fb3177188255d"
-  integrity sha512-P9UbpFK87NyqBZzUuDBDz4f6Yiys8xm8j7ACDbi6usvFm6KItklQUKjeoqTrYS/S1k6I8oaOC2YLLDr/gg26Mw==
-
-node-fetch@2.6.0:
-  version "2.6.0"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.0.tgz#e633456386d4aa55863f676a7ab0daa8fdecb0fd"
-  integrity sha512-8dG4H5ujfvFiqDmVu9fQ5bOHUC15JMjMY/Zumv26oOvvVJjM67KF8koCWIabKQ1GJIa9r2mMZscBq/TbdOcmNA==
-
-node-fetch@2.6.1:
-  version "2.6.1"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.1.tgz#045bd323631f76ed2e2b55573394416b639a0052"
-  integrity sha512-V4aYg89jEoVRxRb2fJdAg8FHvI7cEyYdVAh94HH0UIK8oJxUfkjlDQN9RbMx+bEjP7+ggMiFRprSti032Oipxw==
-
-node-fetch@^2.6.1:
-  version "2.6.6"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.6.tgz#1751a7c01834e8e1697758732e9efb6eeadfaf89"
-  integrity sha512-Z8/6vRlTUChSdIgMa51jxQ4lrw/Jy5SOW10ObaA47/RElsAN2c5Pn8bTgFGWn/ibwzXTE8qwr1Yzx28vsecXEA==
-  dependencies:
-    whatwg-url "^5.0.0"
-
-node-fetch@^2.6.8:
-  version "2.6.11"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.11.tgz#cde7fc71deef3131ef80a738919f999e6edfff25"
-  integrity sha512-4I6pdBY1EthSqDmJkiNk3JIT8cswwR9nfeW/cPdUagJYEQG7R95WRH74wpz7ma8Gh/9dI9FP+OU+0E4FvtA55w==
-  dependencies:
-    whatwg-url "^5.0.0"
-
-node-gyp-build@^4.2.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/node-gyp-build/-/node-gyp-build-4.5.0.tgz#7a64eefa0b21112f89f58379da128ac177f20e40"
-  integrity sha512-2iGbaQBV+ITgCz76ZEjmhUKAKVf7xfY1sRl4UiKQspfZMH2h06SyhNsnSVy50cwkFQDGLyif6m/6uFXHkOZ6rg==
-
-node-gyp-build@~3.8.0:
-  version "3.8.0"
-  resolved "https://registry.yarnpkg.com/node-gyp-build/-/node-gyp-build-3.8.0.tgz#0f57efeb1971f404dfcbfab975c284de7c70f14a"
-  integrity sha512-bYbpIHyRqZ7sVWXxGpz8QIRug5JZc/hzZH4GbdT9HTZi6WmKCZ8GLvP8OZ9TTiIBvwPFKgtGrlWQSXDAvYdsPw==
-
-node-gyp-build@~4.1.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/node-gyp-build/-/node-gyp-build-4.1.1.tgz#d7270b5d86717068d114cc57fff352f96d745feb"
-  integrity sha512-dSq1xmcPDKPZ2EED2S6zw/b9NKsqzXRE6dVr8TVQnI3FJOTteUMuqF3Qqs6LZg+mLGYJWqQzMbIjMtJqTv87nQ==
-
-node-int64@^0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b"
-  integrity sha1-h6kGXNs1XTGC2PlM4RGIuCXGijs=
-
-node-interval-tree@^1.3.3:
-  version "1.3.3"
-  resolved "https://registry.yarnpkg.com/node-interval-tree/-/node-interval-tree-1.3.3.tgz#15ffb904cde08270214acace8dc7653e89ae32b7"
-  integrity sha512-K9vk96HdTK5fEipJwxSvIIqwTqr4e3HRJeJrNxBSeVMNSC/JWARRaX7etOLOuTmrRMeOI/K5TCJu3aWIwZiNTw==
-  dependencies:
-    shallowequal "^1.0.2"
-
-node-pre-gyp@^0.11.0:
-  version "0.11.0"
-  resolved "https://registry.yarnpkg.com/node-pre-gyp/-/node-pre-gyp-0.11.0.tgz#db1f33215272f692cd38f03238e3e9b47c5dd054"
-  integrity sha512-TwWAOZb0j7e9eGaf9esRx3ZcLaE5tQ2lvYy1pb5IAaG1a2e2Kv5Lms1Y4hpj+ciXJRofIxxlt5haeQ/2ANeE0Q==
-  dependencies:
-    detect-libc "^1.0.2"
-    mkdirp "^0.5.1"
-    needle "^2.2.1"
-    nopt "^4.0.1"
-    npm-packlist "^1.1.6"
-    npmlog "^4.0.2"
-    rc "^1.2.7"
-    rimraf "^2.6.1"
-    semver "^5.3.0"
-    tar "^4"
-
-node-releases@^1.1.70:
-  version "1.1.71"
-  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.1.71.tgz#cb1334b179896b1c89ecfdd4b725fb7bbdfc7dbb"
-  integrity sha512-zR6HoT6LrLCRBwukmrVbHv0EpEQjksO6GmFcZQQuCAy139BEsoVKPYnf3jongYW83fAa1torLGYwxxky/p28sg==
-
-nofilter@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/nofilter/-/nofilter-1.0.4.tgz#78d6f4b6a613e7ced8b015cec534625f7667006e"
-  integrity sha512-N8lidFp+fCz+TD51+haYdbDGrcBWwuHX40F5+z0qkUjMJ5Tp+rdSuAkMJ9N9eoolDlEVTf6u5icM+cNKkKW2mA==
-
-noop-fn@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/noop-fn/-/noop-fn-1.0.0.tgz#5f33d47f13d2150df93e0cb036699e982f78ffbf"
-  integrity sha1-XzPUfxPSFQ35PgywNmmemC94/78=
-
-nopt@^4.0.1:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/nopt/-/nopt-4.0.3.tgz#a375cad9d02fd921278d954c2254d5aa57e15e48"
-  integrity sha512-CvaGwVMztSMJLOeXPrez7fyfObdZqNUK1cPAEzLHrTybIua9pMdmmPR5YwtfNftIOMv3DPUhFaxsZMNTQO20Kg==
-  dependencies:
-    abbrev "1"
-    osenv "^0.1.4"
-
-normalize-package-data@^2.3.2:
-  version "2.5.0"
-  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8"
-  integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==
-  dependencies:
-    hosted-git-info "^2.1.4"
-    resolve "^1.10.0"
-    semver "2 || 3 || 4 || 5"
-    validate-npm-package-license "^3.0.1"
-
-normalize-path@^2.0.1, normalize-path@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9"
-  integrity sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=
-  dependencies:
-    remove-trailing-separator "^1.0.1"
-
-normalize-path@^3.0.0, normalize-path@~3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
-  integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
-
-normalize-url@^4.1.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-4.5.0.tgz#453354087e6ca96957bd8f5baf753f5982142129"
-  integrity sha512-2s47yzUxdexf1OhyRi4Em83iQk0aPvwTddtFz4hnSSw9dCEsLEGf6SwIO8ss/19S9iBb5sJaOuTvTGDeZI00BQ==
-
-npm-bundled@^1.0.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/npm-bundled/-/npm-bundled-1.1.1.tgz#1edd570865a94cdb1bc8220775e29466c9fb234b"
-  integrity sha512-gqkfgGePhTpAEgUsGEgcq1rqPXA+tv/aVBlgEzfXwA1yiUJF7xtEt3CtVwOjNYQOVknDk0F20w58Fnm3EtG0fA==
-  dependencies:
-    npm-normalize-package-bin "^1.0.1"
-
-npm-normalize-package-bin@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/npm-normalize-package-bin/-/npm-normalize-package-bin-1.0.1.tgz#6e79a41f23fd235c0623218228da7d9c23b8f6e2"
-  integrity sha512-EPfafl6JL5/rU+ot6P3gRSCpPDW5VmIzX959Ob1+ySFUuuYHWHekXpwdUZcKP5C+DS4GEtdJluwBjnsNDl+fSA==
-
-npm-packlist@^1.1.6:
-  version "1.4.8"
-  resolved "https://registry.yarnpkg.com/npm-packlist/-/npm-packlist-1.4.8.tgz#56ee6cc135b9f98ad3d51c1c95da22bbb9b2ef3e"
-  integrity sha512-5+AZgwru5IevF5ZdnFglB5wNlHG1AOOuw28WhUq8/8emhBmLv6jX5by4WJCh7lW0uSYZYS6DXqIsyZVIXRZU9A==
-  dependencies:
-    ignore-walk "^3.0.1"
-    npm-bundled "^1.0.1"
-    npm-normalize-package-bin "^1.0.1"
-
-npm-run-path@^4.0.0, npm-run-path@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
-  integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
-  dependencies:
-    path-key "^3.0.0"
-
-npmlog@^4.0.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/npmlog/-/npmlog-4.1.2.tgz#08a7f2a8bf734604779a9efa4ad5cc717abb954b"
-  integrity sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==
-  dependencies:
-    are-we-there-yet "~1.1.2"
-    console-control-strings "~1.1.0"
-    gauge "~2.7.3"
-    set-blocking "~2.0.0"
-
-nth-check@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/nth-check/-/nth-check-2.0.0.tgz#1bb4f6dac70072fc313e8c9cd1417b5074c0a125"
-  integrity sha512-i4sc/Kj8htBrAiH1viZ0TgU8Y5XqCaV/FziYK6TBczxmeKm3AEFWqqF3195yKudrarqy7Zu80Ra5dobFjn9X/Q==
-  dependencies:
-    boolbase "^1.0.0"
-
-nth-check@~1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/nth-check/-/nth-check-1.0.2.tgz#b2bd295c37e3dd58a3bf0700376663ba4d9cf05c"
-  integrity sha512-WeBOdju8SnzPN5vTUJYxYUxLeXpCaVP5i5e0LF8fg7WORF2Wd7wFX/pk0tYZk7s8T+J7VLy0Da6J1+wCT0AtHg==
-  dependencies:
-    boolbase "~1.0.0"
-
-nullthrows@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/nullthrows/-/nullthrows-1.1.1.tgz#7818258843856ae971eae4208ad7d7eb19a431b1"
-  integrity sha512-2vPPEi+Z7WqML2jZYddDIfy5Dqb0r2fze2zTxNNknZaFpVHU3mFB3R+DWeJWGVx0ecvttSGlJTI+WG+8Z4cDWw==
-
-number-is-nan@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
-  integrity sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=
-
-number-to-bn@1.7.0:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/number-to-bn/-/number-to-bn-1.7.0.tgz#bb3623592f7e5f9e0030b1977bd41a0c53fe1ea0"
-  integrity sha512-wsJ9gfSz1/s4ZsJN01lyonwuxA1tml6X1yBDnfpMglypcBRFZZkus26EdPSlqS5GJfYddVZa22p3VNb3z5m5Ig==
-  dependencies:
-    bn.js "4.11.6"
-    strip-hex-prefix "1.0.0"
-
-"nwmatcher@>= 1.3.7 < 2.0.0":
-  version "1.4.4"
-  resolved "https://registry.yarnpkg.com/nwmatcher/-/nwmatcher-1.4.4.tgz#2285631f34a95f0d0395cd900c96ed39b58f346e"
-  integrity sha512-3iuY4N5dhgMpCUrOVnuAdGrgxVqV2cJpM+XNccjR2DKOB1RUP0aA+wGXEiNziG/UKboFyGBIoKOaNlJxx8bciQ==
-
-oauth-sign@~0.9.0:
-  version "0.9.0"
-  resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455"
-  integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==
-
-object-assign@4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.0.tgz#7a3b3d0e98063d43f4c03f2e8ae6cd51a86883a0"
-  integrity sha1-ejs9DpgGPUP0wD8uiubNUahog6A=
-
-object-assign@^4, object-assign@^4.0.0, object-assign@^4.0.1, object-assign@^4.1.0, object-assign@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
-  integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
-
-object-inspect@^1.11.0:
-  version "1.11.0"
-  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.11.0.tgz#9dceb146cedd4148a0d9e51ab88d34cf509922b1"
-  integrity sha512-jp7ikS6Sd3GxQfZJPyH3cjcbJF6GZPClgdV+EFygjFLQ5FmW/dRUnTd9PQ9k0JhoNDabWFbpF1yCdSWCC6gexg==
-
-object-inspect@^1.9.0:
-  version "1.12.2"
-  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.12.2.tgz#c0641f26394532f28ab8d796ab954e43c009a8ea"
-  integrity sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ==
-
-object-keys@^1.0.11, object-keys@^1.0.12, object-keys@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
-  integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
-
-object-keys@~0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-0.4.0.tgz#28a6aae7428dd2c3a92f3d95f21335dd204e0336"
-  integrity sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=
-
-object-path@^0.11.4:
-  version "0.11.8"
-  resolved "https://registry.yarnpkg.com/object-path/-/object-path-0.11.8.tgz#ed002c02bbdd0070b78a27455e8ae01fc14d4742"
-  integrity sha512-YJjNZrlXJFM42wTBn6zgOJVar9KFJvzx6sTWDte8sWZF//cnjl0BxHNpfZx+ZffXX63A9q0b1zsFiBX4g4X5KA==
-
-object-treeify@^1.1.33:
-  version "1.1.33"
-  resolved "https://registry.yarnpkg.com/object-treeify/-/object-treeify-1.1.33.tgz#f06fece986830a3cba78ddd32d4c11d1f76cdf40"
-  integrity sha512-EFVjAYfzWqWsBMRHPMAXLCDIJnpMhdWAqR7xG6M6a2cs6PMFpl/+Z20w9zDW4vkxOFfddegBKq9Rehd0bxWE7A==
-
-object.assign@4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.0.tgz#968bf1100d7956bb3ca086f006f846b3bc4008da"
-  integrity sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==
-  dependencies:
-    define-properties "^1.1.2"
-    function-bind "^1.1.1"
-    has-symbols "^1.0.0"
-    object-keys "^1.0.11"
-
-object.assign@^4.1.0, object.assign@^4.1.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.2.tgz#0ed54a342eceb37b38ff76eb831a0e788cb63940"
-  integrity sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==
-  dependencies:
-    call-bind "^1.0.0"
-    define-properties "^1.1.3"
-    has-symbols "^1.0.1"
-    object-keys "^1.1.1"
-
-object.getownpropertydescriptors@^2.1.1:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.3.tgz#b223cf38e17fefb97a63c10c91df72ccb386df9e"
-  integrity sha512-VdDoCwvJI4QdC6ndjpqFmoL3/+HxffFBbcJzKi5hwLLqqx3mdbedRpfZDdK0SrOSauj8X4GzBvnDZl4vTN7dOw==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.3"
-    es-abstract "^1.19.1"
-
-object.omit@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/object.omit/-/object.omit-2.0.1.tgz#1a9c744829f39dbb858c76ca3579ae2a54ebd1fa"
-  integrity sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=
-  dependencies:
-    for-own "^0.1.4"
-    is-extendable "^0.1.1"
-
-oboe@2.1.4:
-  version "2.1.4"
-  resolved "https://registry.yarnpkg.com/oboe/-/oboe-2.1.4.tgz#20c88cdb0c15371bb04119257d4fdd34b0aa49f6"
-  integrity sha1-IMiM2wwVNxuwQRklfU/dNLCqSfY=
-  dependencies:
-    http-https "^1.0.0"
-
-oboe@2.1.5:
-  version "2.1.5"
-  resolved "https://registry.yarnpkg.com/oboe/-/oboe-2.1.5.tgz#5554284c543a2266d7a38f17e073821fbde393cd"
-  integrity sha1-VVQoTFQ6ImbXo48X4HOCH73jk80=
-  dependencies:
-    http-https "^1.0.0"
-
-on-finished@2.4.1:
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.4.1.tgz#58c8c44116e54845ad57f14ab10b03533184ac3f"
-  integrity sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==
-  dependencies:
-    ee-first "1.1.1"
-
-once@^1.3.0, once@^1.3.1, once@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
-  integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
-  dependencies:
-    wrappy "1"
-
-onetime@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.1.tgz#067428230fd67443b2794b22bba528b6867962d4"
-  integrity sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=
-  dependencies:
-    mimic-fn "^1.0.0"
-
-onetime@^5.1.0, onetime@^5.1.2:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e"
-  integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
-  dependencies:
-    mimic-fn "^2.1.0"
-
-opencollective-postinstall@^2.0.0:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/opencollective-postinstall/-/opencollective-postinstall-2.0.3.tgz#7a0fff978f6dbfa4d006238fbac98ed4198c3259"
-  integrity sha512-8AV/sCtuzUeTo8gQK5qDZzARrulB3egtLzFgteqB2tcT4Mw7B8Kt7JcDHmltjz6FOAHsvTevk70gZEbhM4ZS9Q==
-
-optimism@^0.14.0:
-  version "0.14.0"
-  resolved "https://registry.yarnpkg.com/optimism/-/optimism-0.14.0.tgz#256fb079a3428585b40a3a8462f907e0abd2fc49"
-  integrity sha512-ygbNt8n4DOCVpkwiLF+IrKKeNHOjtr9aXLWGP9HNJGoblSGsnVbJLstcH6/nE9Xy5ZQtlkSioFQNnthmENW6FQ==
-  dependencies:
-    "@wry/context" "^0.5.2"
-    "@wry/trie" "^0.2.1"
-
-optionator@^0.8.1:
-  version "0.8.3"
-  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.3.tgz#84fa1d036fe9d3c7e21d99884b601167ec8fb495"
-  integrity sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==
-  dependencies:
-    deep-is "~0.1.3"
-    fast-levenshtein "~2.0.6"
-    levn "~0.3.0"
-    prelude-ls "~1.1.2"
-    type-check "~0.3.2"
-    word-wrap "~1.2.3"
-
-ora@4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/ora/-/ora-4.0.2.tgz#0e1e68fd45b135d28648b27cf08081fa6e8a297d"
-  integrity sha512-YUOZbamht5mfLxPmk4M35CD/5DuOkAacxlEUbStVXpBAt4fyhBf+vZHI/HRkI++QUp3sNoeA2Gw4C+hi4eGSig==
-  dependencies:
-    chalk "^2.4.2"
-    cli-cursor "^3.1.0"
-    cli-spinners "^2.2.0"
-    is-interactive "^1.0.0"
-    log-symbols "^3.0.0"
-    strip-ansi "^5.2.0"
-    wcwidth "^1.0.1"
-
-ora@^3.4.0:
-  version "3.4.0"
-  resolved "https://registry.yarnpkg.com/ora/-/ora-3.4.0.tgz#bf0752491059a3ef3ed4c85097531de9fdbcd318"
-  integrity sha512-eNwHudNbO1folBP3JsZ19v9azXWtQZjICdr3Q0TDPIaeBQ3mXLrh54wM+er0+hSp+dWKf+Z8KM58CYzEyIYxYg==
-  dependencies:
-    chalk "^2.4.2"
-    cli-cursor "^2.1.0"
-    cli-spinners "^2.0.0"
-    log-symbols "^2.2.0"
-    strip-ansi "^5.2.0"
-    wcwidth "^1.0.1"
-
-ora@^4.0.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/ora/-/ora-4.1.1.tgz#566cc0348a15c36f5f0e979612842e02ba9dddbc"
-  integrity sha512-sjYP8QyVWBpBZWD6Vr1M/KwknSw6kJOz41tvGMlwWeClHBtYKTbHMki1PsLZnxKpXMPbTKv9b3pjQu3REib96A==
-  dependencies:
-    chalk "^3.0.0"
-    cli-cursor "^3.1.0"
-    cli-spinners "^2.2.0"
-    is-interactive "^1.0.0"
-    log-symbols "^3.0.0"
-    mute-stream "0.0.8"
-    strip-ansi "^6.0.0"
-    wcwidth "^1.0.1"
-
-ordered-read-streams@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/ordered-read-streams/-/ordered-read-streams-0.3.0.tgz#7137e69b3298bb342247a1bbee3881c80e2fd78b"
-  integrity sha1-cTfmmzKYuzQiR6G77jiByA4v14s=
-  dependencies:
-    is-stream "^1.0.1"
-    readable-stream "^2.0.1"
-
-original-require@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/original-require/-/original-require-1.0.1.tgz#0f130471584cd33511c5ec38c8d59213f9ac5e20"
-  integrity sha1-DxMEcVhM0zURxew4yNWSE/msXiA=
-
-original@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/original/-/original-1.0.2.tgz#e442a61cffe1c5fd20a65f3261c26663b303f25f"
-  integrity sha512-hyBVl6iqqUOJ8FqRe+l/gS8H+kKYjrEndd5Pm1MfBtsEKA038HkkdbAl/72EAXGyonD/PFsvmVG+EvcIpliMBg==
-  dependencies:
-    url-parse "^1.4.3"
-
-os-homedir@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3"
-  integrity sha1-/7xJiDNuDoM94MFox+8VISGqf7M=
-
-os-locale@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/os-locale/-/os-locale-1.4.0.tgz#20f9f17ae29ed345e8bde583b13d2009803c14d9"
-  integrity sha1-IPnxeuKe00XoveWDsT0gCYA8FNk=
-  dependencies:
-    lcid "^1.0.0"
-
-os-tmpdir@^1.0.0, os-tmpdir@^1.0.1, os-tmpdir@~1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
-  integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=
-
-osenv@^0.1.4:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/osenv/-/osenv-0.1.5.tgz#85cdfafaeb28e8677f416e287592b5f3f49ea410"
-  integrity sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==
-  dependencies:
-    os-homedir "^1.0.0"
-    os-tmpdir "^1.0.0"
-
-p-cancelable@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/p-cancelable/-/p-cancelable-0.3.0.tgz#b9e123800bcebb7ac13a479be195b507b98d30fa"
-  integrity sha512-RVbZPLso8+jFeq1MfNvgXtCRED2raz/dKpacfTNxsx6pLEpEomM7gah6VeHSYV3+vo0OAi4MkArtQcWWXuQoyw==
-
-p-cancelable@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/p-cancelable/-/p-cancelable-1.1.0.tgz#d078d15a3af409220c886f1d9a0ca2e441ab26cc"
-  integrity sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw==
-
-p-defer@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/p-defer/-/p-defer-3.0.0.tgz#d1dceb4ee9b2b604b1d94ffec83760175d4e6f83"
-  integrity sha512-ugZxsxmtTln604yeYd29EGrNhazN2lywetzpKhfmQjW/VJmhpDmWbiX+h0zL8V91R0UXkhb3KtPmyq9PZw3aYw==
-
-p-fifo@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/p-fifo/-/p-fifo-1.0.0.tgz#e29d5cf17c239ba87f51dde98c1d26a9cfe20a63"
-  integrity sha512-IjoCxXW48tqdtDFz6fqo5q1UfFVjjVZe8TC1QRflvNUJtNfCUhxOUw6MOVZhDPjqhSzc26xKdugsO17gmzd5+A==
-  dependencies:
-    fast-fifo "^1.0.0"
-    p-defer "^3.0.0"
-
-p-finally@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae"
-  integrity sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=
-
-p-finally@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-2.0.1.tgz#bd6fcaa9c559a096b680806f4d657b3f0f240561"
-  integrity sha512-vpm09aKwq6H9phqRQzecoDpD8TmVyGw70qmWlyq5onxY7tqyTTFVvxMykxQSQKILBSFlbXpypIw2T1Ml7+DDtw==
-
-p-limit@3.1.0, p-limit@^3.0.2:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b"
-  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
-  dependencies:
-    yocto-queue "^0.1.0"
-
-p-limit@^1.1.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.3.0.tgz#b86bd5f0c25690911c7590fcbfc2010d54b3ccb8"
-  integrity sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==
-  dependencies:
-    p-try "^1.0.0"
-
-p-limit@^2.0.0, p-limit@^2.2.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
-  integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
-  dependencies:
-    p-try "^2.0.0"
-
-p-locate@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"
-  integrity sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=
-  dependencies:
-    p-limit "^1.1.0"
-
-p-locate@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-3.0.0.tgz#322d69a05c0264b25997d9f40cd8a891ab0064a4"
-  integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==
-  dependencies:
-    p-limit "^2.0.0"
-
-p-locate@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
-  integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==
-  dependencies:
-    p-limit "^2.2.0"
-
-p-locate@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834"
-  integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
-  dependencies:
-    p-limit "^3.0.2"
-
-p-timeout@^1.1.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/p-timeout/-/p-timeout-1.2.1.tgz#5eb3b353b7fce99f101a1038880bb054ebbea386"
-  integrity sha1-XrOzU7f86Z8QGhA4iAuwVOu+o4Y=
-  dependencies:
-    p-finally "^1.0.0"
-
-p-try@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3"
-  integrity sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=
-
-p-try@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
-  integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
-
-pako@^1.0.4:
-  version "1.0.11"
-  resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.11.tgz#6c9599d340d54dfd3946380252a35705a6b992bf"
-  integrity sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==
-
-param-case@^2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/param-case/-/param-case-2.1.1.tgz#df94fd8cf6531ecf75e6bef9a0858fbc72be2247"
-  integrity sha1-35T9jPZTHs915r75oIWPvHK+Ikc=
-  dependencies:
-    no-case "^2.2.0"
-
-parent-module@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2"
-  integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
-  dependencies:
-    callsites "^3.0.0"
-
-parse-asn1@^5.0.0, parse-asn1@^5.1.5:
-  version "5.1.6"
-  resolved "https://registry.yarnpkg.com/parse-asn1/-/parse-asn1-5.1.6.tgz#385080a3ec13cb62a62d39409cb3e88844cdaed4"
-  integrity sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==
-  dependencies:
-    asn1.js "^5.2.0"
-    browserify-aes "^1.0.0"
-    evp_bytestokey "^1.0.0"
-    pbkdf2 "^3.0.3"
-    safe-buffer "^5.1.1"
-
-parse-cache-control@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/parse-cache-control/-/parse-cache-control-1.0.1.tgz#8eeab3e54fa56920fe16ba38f77fa21aacc2d74e"
-  integrity sha512-60zvsJReQPX5/QP0Kzfd/VrpjScIQ7SHBW6bFCYfEP+fp0Eppr1SHhIO5nd1PjZtvclzSzES9D/p5nFJurwfWg==
-
-parse-duration@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/parse-duration/-/parse-duration-1.0.3.tgz#b6681f5edcc2689643b34c09ea63f86f58a35814"
-  integrity sha512-o6NAh12na5VvR6nFejkU0gpQ8jmOY9Y9sTU2ke3L3G/d/3z8jqmbBbeyBGHU73P4JLXfc7tJARygIK3WGIkloA==
-
-parse-glob@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c"
-  integrity sha1-ssN2z7EfNVE7rdFz7wu246OIORw=
-  dependencies:
-    glob-base "^0.3.0"
-    is-dotfile "^1.0.0"
-    is-extglob "^1.0.0"
-    is-glob "^2.0.0"
-
-parse-headers@^2.0.0:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/parse-headers/-/parse-headers-2.0.3.tgz#5e8e7512383d140ba02f0c7aa9f49b4399c92515"
-  integrity sha512-QhhZ+DCCit2Coi2vmAKbq5RGTRcQUOE2+REgv8vdyu7MnYx2eZztegqtTx99TZ86GTIwqiy3+4nQTWZ2tgmdCA==
-
-parse-json@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9"
-  integrity sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=
-  dependencies:
-    error-ex "^1.2.0"
-
-parse-json@^5.0.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd"
-  integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==
-  dependencies:
-    "@babel/code-frame" "^7.0.0"
-    error-ex "^1.3.1"
-    json-parse-even-better-errors "^2.3.0"
-    lines-and-columns "^1.1.6"
-
-parse5-htmlparser2-tree-adapter@^6.0.0:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-6.0.1.tgz#2cdf9ad823321140370d4dbf5d3e92c7c8ddc6e6"
-  integrity sha512-qPuWvbLgvDGilKc5BoicRovlT4MtYT6JfJyBOMDsKoiT+GiuP5qyrPCnR9HcPECIJJmZh5jRndyNThnhhb/vlA==
-  dependencies:
-    parse5 "^6.0.1"
-
-parse5@^1.5.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/parse5/-/parse5-1.5.1.tgz#9b7f3b0de32be78dc2401b17573ccaf0f6f59d94"
-  integrity sha1-m387DeMr543CQBsXVzzK8Pb1nZQ=
-
-parse5@^3.0.1:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/parse5/-/parse5-3.0.3.tgz#042f792ffdd36851551cf4e9e066b3874ab45b5c"
-  integrity sha512-rgO9Zg5LLLkfJF9E6CCmXlSE4UVceloys8JrFqCcHloC3usd/kJCyPDwH2SOlzix2j3xaP9sUX3e8+kvkuleAA==
-  dependencies:
-    "@types/node" "*"
-
-parse5@^6.0.0, parse5@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/parse5/-/parse5-6.0.1.tgz#e1a1c085c569b3dc08321184f19a39cc27f7c30b"
-  integrity sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==
-
-parseurl@^1.3.2, parseurl@~1.3.3:
-  version "1.3.3"
-  resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.3.tgz#9da19e7bee8d12dff0513ed5b76957793bc2e8d4"
-  integrity sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==
-
-pascal-case@^2.0.0, pascal-case@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/pascal-case/-/pascal-case-2.0.1.tgz#2d578d3455f660da65eca18ef95b4e0de912761e"
-  integrity sha1-LVeNNFX2YNpl7KGO+VtODekSdh4=
-  dependencies:
-    camel-case "^3.0.0"
-    upper-case-first "^1.1.0"
-
-pascal-case@^3.1.1, pascal-case@^3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/pascal-case/-/pascal-case-3.1.2.tgz#b48e0ef2b98e205e7c1dae747d0b1508237660eb"
-  integrity sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==
-  dependencies:
-    no-case "^3.0.4"
-    tslib "^2.0.3"
-
-password-prompt@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/password-prompt/-/password-prompt-1.1.2.tgz#85b2f93896c5bd9e9f2d6ff0627fa5af3dc00923"
-  integrity sha512-bpuBhROdrhuN3E7G/koAju0WjVw9/uQOG5Co5mokNj0MiOSBVZS1JTwM4zl55hu0WFmIEFvO9cU9sJQiBIYeIA==
-  dependencies:
-    ansi-escapes "^3.1.0"
-    cross-spawn "^6.0.5"
-
-path-case@^2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/path-case/-/path-case-2.1.1.tgz#94b8037c372d3fe2906e465bb45e25d226e8eea5"
-  integrity sha1-lLgDfDctP+KQbkZbtF4l0ibo7qU=
-  dependencies:
-    no-case "^2.2.0"
-
-path-dirname@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/path-dirname/-/path-dirname-1.0.2.tgz#cc33d24d525e099a5388c0336c6e32b9160609e0"
-  integrity sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=
-
-path-exists@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b"
-  integrity sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=
-  dependencies:
-    pinkie-promise "^2.0.0"
-
-path-exists@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
-  integrity sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=
-
-path-exists@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
-  integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
-
-path-is-absolute@^1.0.0, path-is-absolute@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
-  integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
-
-path-key@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
-  integrity sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw==
-
-path-key@^3.0.0, path-key@^3.1.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
-  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
-
-path-parse@^1.0.6:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
-  integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
-
-path-scurry@^1.6.1:
-  version "1.9.2"
-  resolved "https://registry.yarnpkg.com/path-scurry/-/path-scurry-1.9.2.tgz#90f9d296ac5e37e608028e28a447b11d385b3f63"
-  integrity sha512-qSDLy2aGFPm8i4rsbHd4MNyTcrzHFsLQykrtbuGRknZZCBBVXSv2tSCDN2Cg6Rt/GFRw8GoW9y9Ecw5rIPG1sg==
-  dependencies:
-    lru-cache "^9.1.1"
-    minipass "^5.0.0 || ^6.0.2"
-
-path-to-regexp@0.1.7:
-  version "0.1.7"
-  resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-0.1.7.tgz#df604178005f522f15eb4490e7247a1bfaa67f8c"
-  integrity sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==
-
-path-type@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-1.1.0.tgz#59c44f7ee491da704da415da5a4070ba4f8fe441"
-  integrity sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=
-  dependencies:
-    graceful-fs "^4.1.2"
-    pify "^2.0.0"
-    pinkie-promise "^2.0.0"
-
-path-type@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
-  integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
-
-pbkdf2@^3.0.17:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.1.2.tgz#dd822aa0887580e52f1a039dc3eda108efae3075"
-  integrity sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==
-  dependencies:
-    create-hash "^1.1.2"
-    create-hmac "^1.1.4"
-    ripemd160 "^2.0.1"
-    safe-buffer "^5.0.1"
-    sha.js "^2.4.8"
-
-pbkdf2@^3.0.3:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.1.1.tgz#cb8724b0fada984596856d1a6ebafd3584654b94"
-  integrity sha512-4Ejy1OPxi9f2tt1rRV7Go7zmfDQ+ZectEQz3VGUQhgq62HtIRPDyG/JtnwIxs6x3uNMwo2V7q1fMvKjb+Tnpqg==
-  dependencies:
-    create-hash "^1.1.2"
-    create-hmac "^1.1.4"
-    ripemd160 "^2.0.1"
-    safe-buffer "^5.0.1"
-    sha.js "^2.4.8"
-
-performance-now@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b"
-  integrity sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==
-
-picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
-  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
-
-picomatch@^2.0.5:
-  version "2.2.2"
-  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.2.tgz#21f333e9b6b8eaff02468f5146ea406d345f4dad"
-  integrity sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==
-
-pify@^2.0.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
-  integrity sha1-7RQaasBDqEnqWISY59yosVMw6Qw=
-
-pify@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-3.0.0.tgz#e5a4acd2c101fdf3d9a4d07f0dbc4db49dd28176"
-  integrity sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=
-
-pinkie-promise@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
-  integrity sha1-ITXW36ejWMBprJsXh3YogihFD/o=
-  dependencies:
-    pinkie "^2.0.0"
-
-pinkie@^2.0.0:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
-  integrity sha1-clVrgM+g1IqXToDnckjoDtT3+HA=
-
-pkg-conf@^1.1.2:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/pkg-conf/-/pkg-conf-1.1.3.tgz#378e56d6fd13e88bfb6f4a25df7a83faabddba5b"
-  integrity sha1-N45W1v0T6Iv7b0ol33qD+qvduls=
-  dependencies:
-    find-up "^1.0.0"
-    load-json-file "^1.1.0"
-    object-assign "^4.0.1"
-    symbol "^0.2.1"
-
-pluralize@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.yarnpkg.com/pluralize/-/pluralize-8.0.0.tgz#1a6fa16a38d12a1901e0320fa017051c539ce3b1"
-  integrity sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==
-
-pouchdb-abstract-mapreduce@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-abstract-mapreduce/-/pouchdb-abstract-mapreduce-7.2.2.tgz#dd1b10a83f8d24361dce9aaaab054614b39f766f"
-  integrity sha512-7HWN/2yV2JkwMnGnlp84lGvFtnm0Q55NiBUdbBcaT810+clCGKvhssBCrXnmwShD1SXTwT83aszsgiSfW+SnBA==
-  dependencies:
-    pouchdb-binary-utils "7.2.2"
-    pouchdb-collate "7.2.2"
-    pouchdb-collections "7.2.2"
-    pouchdb-errors "7.2.2"
-    pouchdb-fetch "7.2.2"
-    pouchdb-mapreduce-utils "7.2.2"
-    pouchdb-md5 "7.2.2"
-    pouchdb-utils "7.2.2"
-
-pouchdb-adapter-leveldb-core@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-adapter-leveldb-core/-/pouchdb-adapter-leveldb-core-7.2.2.tgz#e0aa6a476e2607d7ae89f4a803c9fba6e6d05a8a"
-  integrity sha512-K9UGf1Ivwe87mjrMqN+1D07tO/DfU7ariVDrGffuOjvl+3BcvUF25IWrxsBObd4iPOYCH7NVQWRpojhBgxULtQ==
-  dependencies:
-    argsarray "0.0.1"
-    buffer-from "1.1.1"
-    double-ended-queue "2.1.0-0"
-    levelup "4.4.0"
-    pouchdb-adapter-utils "7.2.2"
-    pouchdb-binary-utils "7.2.2"
-    pouchdb-collections "7.2.2"
-    pouchdb-errors "7.2.2"
-    pouchdb-json "7.2.2"
-    pouchdb-md5 "7.2.2"
-    pouchdb-merge "7.2.2"
-    pouchdb-utils "7.2.2"
-    sublevel-pouchdb "7.2.2"
-    through2 "3.0.2"
-
-pouchdb-adapter-memory@^7.1.1:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-adapter-memory/-/pouchdb-adapter-memory-7.2.2.tgz#c0ec2e87928d516ca9d1b5badc7269df6f95e5ea"
-  integrity sha512-9o+zdItPEq7rIrxdkUxgsLNaZkDJAGEqqoYgeYdrHidOCZnlhxhX3g7/R/HcpDKC513iEPqJWDJQSfeT6nVKkw==
-  dependencies:
-    memdown "1.4.1"
-    pouchdb-adapter-leveldb-core "7.2.2"
-    pouchdb-utils "7.2.2"
-
-pouchdb-adapter-node-websql@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pouchdb-adapter-node-websql/-/pouchdb-adapter-node-websql-7.0.0.tgz#64ad88dd45b23578e454bf3032a3a79f9d1e4008"
-  integrity sha512-fNaOMO8bvMrRTSfmH4RSLSpgnKahRcCA7Z0jg732PwRbGvvMdGbreZwvKPPD1fg2tm2ZwwiXWK2G3+oXyoqZYw==
-  dependencies:
-    pouchdb-adapter-websql-core "7.0.0"
-    pouchdb-utils "7.0.0"
-    websql "1.0.0"
-
-pouchdb-adapter-utils@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pouchdb-adapter-utils/-/pouchdb-adapter-utils-7.0.0.tgz#1ac8d34481911e0e9a9bf51024610a2e7351dc80"
-  integrity sha512-UWKPC6jkz6mHUzZefrU7P5X8ZGvBC8LSNZ7BIp0hWvJE6c20cnpDwedTVDpZORcCbVJpDmFOHBYnOqEIblPtbA==
-  dependencies:
-    pouchdb-binary-utils "7.0.0"
-    pouchdb-collections "7.0.0"
-    pouchdb-errors "7.0.0"
-    pouchdb-md5 "7.0.0"
-    pouchdb-merge "7.0.0"
-    pouchdb-utils "7.0.0"
-
-pouchdb-adapter-utils@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-adapter-utils/-/pouchdb-adapter-utils-7.2.2.tgz#c64426447d9044ba31517a18500d6d2d28abd47d"
-  integrity sha512-2CzZkTyTyHZkr3ePiWFMTiD5+56lnembMjaTl8ohwegM0+hYhRyJux0biAZafVxgIL4gnCUC4w2xf6WVztzKdg==
-  dependencies:
-    pouchdb-binary-utils "7.2.2"
-    pouchdb-collections "7.2.2"
-    pouchdb-errors "7.2.2"
-    pouchdb-md5 "7.2.2"
-    pouchdb-merge "7.2.2"
-    pouchdb-utils "7.2.2"
-
-pouchdb-adapter-websql-core@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pouchdb-adapter-websql-core/-/pouchdb-adapter-websql-core-7.0.0.tgz#27b3e404159538e515b2567baa7869f90caac16c"
-  integrity sha512-NyMaH0bl20SdJdOCzd+fwXo8JZ15a48/MAwMcIbXzsRHE4DjFNlRcWAcjUP6uN4Ezc+Gx+r2tkBBMf71mIz1Aw==
-  dependencies:
-    pouchdb-adapter-utils "7.0.0"
-    pouchdb-binary-utils "7.0.0"
-    pouchdb-collections "7.0.0"
-    pouchdb-errors "7.0.0"
-    pouchdb-json "7.0.0"
-    pouchdb-merge "7.0.0"
-    pouchdb-utils "7.0.0"
-
-pouchdb-binary-utils@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pouchdb-binary-utils/-/pouchdb-binary-utils-7.0.0.tgz#cb71a288b09572a231f6bab1b4aed201c4d219a7"
-  integrity sha512-yUktdOPIPvOVouCjJN3uop+bCcpdPwePrLm9eUAZNgEYnUFu0njdx7Q0WRsZ7UJ6l75HinL5ZHk4bnvEt86FLw==
-  dependencies:
-    buffer-from "1.1.0"
-
-pouchdb-binary-utils@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-binary-utils/-/pouchdb-binary-utils-7.2.2.tgz#0690b348052c543b1e67f032f47092ca82bcb10e"
-  integrity sha512-shacxlmyHbUrNfE6FGYpfyAJx7Q0m91lDdEAaPoKZM3SzAmbtB1i+OaDNtYFztXjJl16yeudkDb3xOeokVL3Qw==
-  dependencies:
-    buffer-from "1.1.1"
-
-pouchdb-collate@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-collate/-/pouchdb-collate-7.2.2.tgz#fc261f5ef837c437e3445fb0abc3f125d982c37c"
-  integrity sha512-/SMY9GGasslknivWlCVwXMRMnQ8myKHs4WryQ5535nq1Wj/ehpqWloMwxEQGvZE1Sda3LOm7/5HwLTcB8Our+w==
-
-pouchdb-collections@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pouchdb-collections/-/pouchdb-collections-7.0.0.tgz#fd1f632337dc6301b0ff8649732ca79204e41780"
-  integrity sha512-DaoUr/vU24Q3gM6ghj0va9j/oBanPwkbhkvnqSyC3Dm5dgf5pculNxueLF9PKMo3ycApoWzHMh6N2N8KJbDU2Q==
-
-pouchdb-collections@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-collections/-/pouchdb-collections-7.2.2.tgz#aeed77f33322429e3f59d59ea233b48ff0e68572"
-  integrity sha512-6O9zyAYlp3UdtfneiMYuOCWdUCQNo2bgdjvNsMSacQX+3g8WvIoFQCYJjZZCpTttQGb+MHeRMr8m2U95lhJTew==
-
-pouchdb-debug@^7.1.1:
-  version "7.2.1"
-  resolved "https://registry.yarnpkg.com/pouchdb-debug/-/pouchdb-debug-7.2.1.tgz#f5f869f6113c12ccb97cddf5b0a32b6e0e67e961"
-  integrity sha512-eP3ht/AKavLF2RjTzBM6S9gaI2/apcW6xvaKRQhEdOfiANqerFuksFqHCal3aikVQuDO+cB/cw+a4RyJn/glBw==
-  dependencies:
-    debug "3.1.0"
-
-pouchdb-errors@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pouchdb-errors/-/pouchdb-errors-7.0.0.tgz#4e2a5a8b82af20cbe5f9970ca90b7ec74563caa0"
-  integrity sha512-dTusY8nnTw4HIztCrNl7AoGgwvS1bVf/3/97hDaGc4ytn72V9/4dK8kTqlimi3UpaurohYRnqac0SGXYP8vgXA==
-  dependencies:
-    inherits "2.0.3"
-
-pouchdb-errors@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-errors/-/pouchdb-errors-7.2.2.tgz#80d811d65c766c9d20b755c6e6cc123f8c3c4792"
-  integrity sha512-6GQsiWc+7uPfgEHeavG+7wuzH3JZW29Dnrvz8eVbDFE50kVFxNDVm3EkYHskvo5isG7/IkOx7PV7RPTA3keG3g==
-  dependencies:
-    inherits "2.0.4"
-
-pouchdb-fetch@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-fetch/-/pouchdb-fetch-7.2.2.tgz#492791236d60c899d7e9973f9aca0d7b9cc02230"
-  integrity sha512-lUHmaG6U3zjdMkh8Vob9GvEiRGwJfXKE02aZfjiVQgew+9SLkuOxNw3y2q4d1B6mBd273y1k2Lm0IAziRNxQnA==
-  dependencies:
-    abort-controller "3.0.0"
-    fetch-cookie "0.10.1"
-    node-fetch "2.6.0"
-
-pouchdb-find@^7.0.0:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-find/-/pouchdb-find-7.2.2.tgz#1227afdd761812d508fe0794b3e904518a721089"
-  integrity sha512-BmFeFVQ0kHmDehvJxNZl9OmIztCjPlZlVSdpijuFbk/Fi1EFPU1BAv3kLC+6DhZuOqU/BCoaUBY9sn66pPY2ag==
-  dependencies:
-    pouchdb-abstract-mapreduce "7.2.2"
-    pouchdb-collate "7.2.2"
-    pouchdb-errors "7.2.2"
-    pouchdb-fetch "7.2.2"
-    pouchdb-md5 "7.2.2"
-    pouchdb-selector-core "7.2.2"
-    pouchdb-utils "7.2.2"
-
-pouchdb-json@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pouchdb-json/-/pouchdb-json-7.0.0.tgz#d9860f66f27a359ac6e4b24da4f89b6909f37530"
-  integrity sha512-w0bNRu/7VmmCrFWMYAm62n30wvJJUT2SokyzeTyj3hRohj4GFwTRg1mSZ+iAmxgRKOFE8nzZstLG/WAB4Ymjew==
-  dependencies:
-    vuvuzela "1.0.3"
-
-pouchdb-json@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-json/-/pouchdb-json-7.2.2.tgz#b939be24b91a7322e9a24b8880a6e21514ec5e1f"
-  integrity sha512-3b2S2ynN+aoB7aCNyDZc/4c0IAdx/ir3nsHB+/RrKE9cM3QkQYbnnE3r/RvOD1Xvr6ji/KOCBie+Pz/6sxoaug==
-  dependencies:
-    vuvuzela "1.0.3"
-
-pouchdb-mapreduce-utils@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-mapreduce-utils/-/pouchdb-mapreduce-utils-7.2.2.tgz#13a46a3cc2a3f3b8e24861da26966904f2963146"
-  integrity sha512-rAllb73hIkU8rU2LJNbzlcj91KuulpwQu804/F6xF3fhZKC/4JQMClahk+N/+VATkpmLxp1zWmvmgdlwVU4HtQ==
-  dependencies:
-    argsarray "0.0.1"
-    inherits "2.0.4"
-    pouchdb-collections "7.2.2"
-    pouchdb-utils "7.2.2"
-
-pouchdb-md5@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pouchdb-md5/-/pouchdb-md5-7.0.0.tgz#935dc6bb507a5f3978fb653ca5790331bae67c96"
-  integrity sha512-yaSJKhLA3QlgloKUQeb2hLdT3KmUmPfoYdryfwHZuPTpXIRKTnMQTR9qCIRUszc0ruBpDe53DRslCgNUhAyTNQ==
-  dependencies:
-    pouchdb-binary-utils "7.0.0"
-    spark-md5 "3.0.0"
-
-pouchdb-md5@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-md5/-/pouchdb-md5-7.2.2.tgz#415401acc5a844112d765bd1fb4e5d9f38fb0838"
-  integrity sha512-c/RvLp2oSh8PLAWU5vFBnp6ejJABIdKqboZwRRUrWcfGDf+oyX8RgmJFlYlzMMOh4XQLUT1IoaDV8cwlsuryZw==
-  dependencies:
-    pouchdb-binary-utils "7.2.2"
-    spark-md5 "3.0.1"
-
-pouchdb-merge@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pouchdb-merge/-/pouchdb-merge-7.0.0.tgz#9f476ce7e32aae56904ad770ae8a1dfe14b57547"
-  integrity sha512-tci5u6NpznQhGcPv4ho1h0miky9rs+ds/T9zQ9meQeDZbUojXNaX1Jxsb0uYEQQ+HMqdcQs3Akdl0/u0mgwPGg==
-
-pouchdb-merge@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-merge/-/pouchdb-merge-7.2.2.tgz#940d85a2b532d6a93a6cab4b250f5648511bcc16"
-  integrity sha512-6yzKJfjIchBaS7Tusuk8280WJdESzFfQ0sb4jeMUNnrqs4Cx3b0DIEOYTRRD9EJDM+je7D3AZZ4AT0tFw8gb4A==
-
-pouchdb-selector-core@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-selector-core/-/pouchdb-selector-core-7.2.2.tgz#264d7436a8c8ac3801f39960e79875ef7f3879a0"
-  integrity sha512-XYKCNv9oiNmSXV5+CgR9pkEkTFqxQGWplnVhO3W9P154H08lU0ZoNH02+uf+NjZ2kjse7Q1fxV4r401LEcGMMg==
-  dependencies:
-    pouchdb-collate "7.2.2"
-    pouchdb-utils "7.2.2"
-
-pouchdb-utils@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pouchdb-utils/-/pouchdb-utils-7.0.0.tgz#48bfced6665b8f5a2b2d2317e2aa57635ed1e88e"
-  integrity sha512-1bnoX1KdZYHv9wicDIFdO0PLiVIMzNDUBUZ/yOJZ+6LW6niQCB8aCv09ZztmKfSQcU5nnN3fe656tScBgP6dOQ==
-  dependencies:
-    argsarray "0.0.1"
-    clone-buffer "1.0.0"
-    immediate "3.0.6"
-    inherits "2.0.3"
-    pouchdb-collections "7.0.0"
-    pouchdb-errors "7.0.0"
-    pouchdb-md5 "7.0.0"
-    uuid "3.2.1"
-
-pouchdb-utils@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/pouchdb-utils/-/pouchdb-utils-7.2.2.tgz#c17c4788f1d052b0daf4ef8797bbc4aaa3945aa4"
-  integrity sha512-XmeM5ioB4KCfyB2MGZXu1Bb2xkElNwF1qG+zVFbQsKQij0zvepdOUfGuWvLRHxTOmt4muIuSOmWZObZa3NOgzQ==
-  dependencies:
-    argsarray "0.0.1"
-    clone-buffer "1.0.0"
-    immediate "3.3.0"
-    inherits "2.0.4"
-    pouchdb-collections "7.2.2"
-    pouchdb-errors "7.2.2"
-    pouchdb-md5 "7.2.2"
-    uuid "8.1.0"
-
-pouchdb@7.1.1:
-  version "7.1.1"
-  resolved "https://registry.yarnpkg.com/pouchdb/-/pouchdb-7.1.1.tgz#f5f8dcd1fc440fb76651cb26f6fc5d97a39cd6ce"
-  integrity sha512-8bXWclixNJZqokvxGHRsG19zehSJiaZaz4dVYlhXhhUctz7gMcNTElHjPBzBdZlKKvt9aFDndmXN1VVE53Co8g==
-  dependencies:
-    argsarray "0.0.1"
-    buffer-from "1.1.0"
-    clone-buffer "1.0.0"
-    double-ended-queue "2.1.0-0"
-    fetch-cookie "0.7.0"
-    immediate "3.0.6"
-    inherits "2.0.3"
-    level "5.0.1"
-    level-codec "9.0.1"
-    level-write-stream "1.0.0"
-    leveldown "5.0.2"
-    levelup "4.0.2"
-    ltgt "2.2.1"
-    node-fetch "2.4.1"
-    readable-stream "1.0.33"
-    spark-md5 "3.0.0"
-    through2 "3.0.1"
-    uuid "3.2.1"
-    vuvuzela "1.0.3"
-
-precond@0.2:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/precond/-/precond-0.2.3.tgz#aa9591bcaa24923f1e0f4849d240f47efc1075ac"
-  integrity sha1-qpWRvKokkj8eD0hJ0kD0fvwQdaw=
-
-prelude-ls@~1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
-  integrity sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=
-
-prepend-http@^1.0.1:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-1.0.4.tgz#d4f4562b0ce3696e41ac52d0e002e57a635dc6dc"
-  integrity sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=
-
-prepend-http@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-2.0.0.tgz#e92434bfa5ea8c19f41cdfd401d741a3c819d897"
-  integrity sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=
-
-preserve@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b"
-  integrity sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=
-
-prettier@1.19.1:
-  version "1.19.1"
-  resolved "https://registry.yarnpkg.com/prettier/-/prettier-1.19.1.tgz#f7d7f5ff8a9cd872a7be4ca142095956a60797cb"
-  integrity sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew==
-
-private@^0.1.8:
-  version "0.1.8"
-  resolved "https://registry.yarnpkg.com/private/-/private-0.1.8.tgz#2381edb3689f7a53d653190060fcf822d2f368ff"
-  integrity sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==
-
-process-nextick-args@~1.0.6:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-1.0.7.tgz#150e20b756590ad3f91093f25a4f2ad8bff30ba3"
-  integrity sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=
-
-process-nextick-args@~2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
-  integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
-
-process@^0.11.10:
-  version "0.11.10"
-  resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
-  integrity sha1-czIwDoQBYb2j5podHZGn1LwW8YI=
-
-promise-to-callback@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/promise-to-callback/-/promise-to-callback-1.0.0.tgz#5d2a749010bfb67d963598fcd3960746a68feef7"
-  integrity sha1-XSp0kBC/tn2WNZj805YHRqaP7vc=
-  dependencies:
-    is-fn "^1.0.0"
-    set-immediate-shim "^1.0.1"
-
-promise.allsettled@1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/promise.allsettled/-/promise.allsettled-1.0.2.tgz#d66f78fbb600e83e863d893e98b3d4376a9c47c9"
-  integrity sha512-UpcYW5S1RaNKT6pd+s9jp9K9rlQge1UXKskec0j6Mmuq7UJCvlS2J2/s/yuPN8ehftf9HXMxWlKiPbGGUzpoRg==
-  dependencies:
-    array.prototype.map "^1.0.1"
-    define-properties "^1.1.3"
-    es-abstract "^1.17.0-next.1"
-    function-bind "^1.1.1"
-    iterate-value "^1.0.0"
-
-promise@^7.1.1:
-  version "7.3.1"
-  resolved "https://registry.yarnpkg.com/promise/-/promise-7.3.1.tgz#064b72602b18f90f29192b8b1bc418ffd1ebd3bf"
-  integrity sha512-nolQXZ/4L+bP/UGlkfaIujX9BKxGwmQ9OT4mOt5yvy8iK1h3wqTEJCijzGANTCCl9nWjY41juyAn2K3Q1hLLTg==
-  dependencies:
-    asap "~2.0.3"
-
-promise@^8.0.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/promise/-/promise-8.1.0.tgz#697c25c3dfe7435dd79fcd58c38a135888eaf05e"
-  integrity sha512-W04AqnILOL/sPRXziNicCjSNRruLAuIHEOVBazepu0545DDNGYHz7ar9ZgZ1fMU8/MA4mVxp5rkBWRi6OXIy3Q==
-  dependencies:
-    asap "~2.0.6"
-
-prop-types@^15.7.2:
-  version "15.7.2"
-  resolved "https://registry.yarnpkg.com/prop-types/-/prop-types-15.7.2.tgz#52c41e75b8c87e72b9d9360e0206b99dcbffa6c5"
-  integrity sha512-8QQikdH7//R2vurIJSutZ1smHYTcLpRWEOlHnzcWHmBYrOGUysKwSsrC89BCiFj3CbrfJ/nXFdJepOVrY1GCHQ==
-  dependencies:
-    loose-envify "^1.4.0"
-    object-assign "^4.1.1"
-    react-is "^16.8.1"
-
-protobufjs@^6.10.2:
-  version "6.11.3"
-  resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-6.11.3.tgz#637a527205a35caa4f3e2a9a4a13ddffe0e7af74"
-  integrity sha512-xL96WDdCZYdU7Slin569tFX712BxsxslWwAfAhCYjQKGTq7dAU91Lomy6nLLhh/dyGhk/YH4TwTSRxTzhuHyZg==
-  dependencies:
-    "@protobufjs/aspromise" "^1.1.2"
-    "@protobufjs/base64" "^1.1.2"
-    "@protobufjs/codegen" "^2.0.4"
-    "@protobufjs/eventemitter" "^1.1.0"
-    "@protobufjs/fetch" "^1.1.0"
-    "@protobufjs/float" "^1.0.2"
-    "@protobufjs/inquire" "^1.1.0"
-    "@protobufjs/path" "^1.1.2"
-    "@protobufjs/pool" "^1.1.0"
-    "@protobufjs/utf8" "^1.1.0"
-    "@types/long" "^4.0.1"
-    "@types/node" ">=13.7.0"
-    long "^4.0.0"
-
-proxy-addr@~2.0.7:
-  version "2.0.7"
-  resolved "https://registry.yarnpkg.com/proxy-addr/-/proxy-addr-2.0.7.tgz#f19fe69ceab311eeb94b42e70e8c2070f9ba1025"
-  integrity sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==
-  dependencies:
-    forwarded "0.2.0"
-    ipaddr.js "1.9.1"
-
-prr@~1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/prr/-/prr-1.0.1.tgz#d3fc114ba06995a45ec6893f484ceb1d78f5f476"
-  integrity sha1-0/wRS6BplaRexok/SEzrHXj19HY=
-
-psl@^1.1.28:
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/psl/-/psl-1.9.0.tgz#d0df2a137f00794565fcaf3b2c00cd09f8d5a5a7"
-  integrity sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==
-
-psl@^1.1.33:
-  version "1.8.0"
-  resolved "https://registry.yarnpkg.com/psl/-/psl-1.8.0.tgz#9326f8bcfb013adcc005fdff056acce020e51c24"
-  integrity sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==
-
-public-encrypt@^4.0.0:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/public-encrypt/-/public-encrypt-4.0.3.tgz#4fcc9d77a07e48ba7527e7cbe0de33d0701331e0"
-  integrity sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==
-  dependencies:
-    bn.js "^4.1.0"
-    browserify-rsa "^4.0.0"
-    create-hash "^1.1.0"
-    parse-asn1 "^5.0.0"
-    randombytes "^2.0.1"
-    safe-buffer "^5.1.2"
-
-pump@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/pump/-/pump-1.0.3.tgz#5dfe8311c33bbf6fc18261f9f34702c47c08a954"
-  integrity sha512-8k0JupWme55+9tCVE+FS5ULT3K6AbgqrGa58lTT49RpyfwwcGedHqaC5LlQNdEAumn/wFsu6aPwkuPMioy8kqw==
-  dependencies:
-    end-of-stream "^1.1.0"
-    once "^1.3.1"
-
-pump@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
-  integrity sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==
-  dependencies:
-    end-of-stream "^1.1.0"
-    once "^1.3.1"
-
-punycode@2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.0.tgz#5f863edc89b96db09074bad7947bf09056ca4e7d"
-  integrity sha1-X4Y+3Im5bbCQdLrXlHvwkFbKTn0=
-
-punycode@^1.3.2:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
-  integrity sha512-jmYNElW7yvO7TV33CjSmvSiE2yco3bV2czu/OzDKdMNVZQWfxCblURLhf+47syQRBntjfLdd/H0egrzIG+oaFQ==
-
-punycode@^2.1.0, punycode@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
-  integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
-
-pure-rand@^4.1.1:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/pure-rand/-/pure-rand-4.1.2.tgz#cbad2a3e3ea6df0a8d80d8ba204779b5679a5205"
-  integrity sha512-uLzZpQWfroIqyFWmX/pl0OL2JHJdoU3dbh0dvZ25fChHFJJi56J5oQZhW6QgbT2Llwh1upki84LnTwlZvsungA==
-
-pvtsutils@^1.3.2:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/pvtsutils/-/pvtsutils-1.3.2.tgz#9f8570d132cdd3c27ab7d51a2799239bf8d8d5de"
-  integrity sha512-+Ipe2iNUyrZz+8K/2IOo+kKikdtfhRKzNpQbruF2URmqPtoqAs8g3xS7TJvFF2GcPXjh7DkqMnpVveRFq4PgEQ==
-  dependencies:
-    tslib "^2.4.0"
-
-pvutils@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/pvutils/-/pvutils-1.1.3.tgz#f35fc1d27e7cd3dfbd39c0826d173e806a03f5a3"
-  integrity sha512-pMpnA0qRdFp32b1sJl1wOJNxZLQ2cbQx+k6tjNtZ8CpvVhNqEPRgivZ2WOUev2YMajecdH7ctUPDvEe87nariQ==
-
-qs@6.11.0, qs@^6.4.0:
-  version "6.11.0"
-  resolved "https://registry.yarnpkg.com/qs/-/qs-6.11.0.tgz#fd0d963446f7a65e1367e01abd85429453f0c37a"
-  integrity sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==
-  dependencies:
-    side-channel "^1.0.4"
-
-qs@~6.5.2:
-  version "6.5.3"
-  resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.3.tgz#3aeeffc91967ef6e35c0e488ef46fb296ab76aad"
-  integrity sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==
-
-query-string@^5.0.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/query-string/-/query-string-5.1.1.tgz#a78c012b71c17e05f2e3fa2319dd330682efb3cb"
-  integrity sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw==
-  dependencies:
-    decode-uri-component "^0.2.0"
-    object-assign "^4.1.0"
-    strict-uri-encode "^1.0.0"
-
-querystring@0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.0.tgz#b209849203bb25df820da756e747005878521620"
-  integrity sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=
-
-querystring@^0.2.0:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.1.tgz#40d77615bb09d16902a85c3e38aa8b5ed761c2dd"
-  integrity sha512-wkvS7mL/JMugcup3/rMitHmd9ecIGd2lhFhK9N3UUQ450h66d1r3Y9nvXzQAW1Lq+wyx61k/1pfKS5KuKiyEbg==
-
-querystringify@^2.1.1:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/querystringify/-/querystringify-2.2.0.tgz#3345941b4153cb9d082d8eee4cda2016a9aef7f6"
-  integrity sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==
-
-queue-microtask@^1.2.2:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.2.tgz#abf64491e6ecf0f38a6502403d4cda04f372dfd3"
-  integrity sha512-dB15eXv3p2jDlbOiNLyMabYg1/sXvppd8DP2J3EOCQ0AkuSXCW2tP7mnVouVLJKgUMY6yP0kcQDVpLCN13h4Xg==
-
-ramda@^0.24.1:
-  version "0.24.1"
-  resolved "https://registry.yarnpkg.com/ramda/-/ramda-0.24.1.tgz#c3b7755197f35b8dc3502228262c4c91ddb6b857"
-  integrity sha512-HEm619G8PaZMfkqCa23qiOe7r3R0brPu7ZgOsgKUsnvLhd0qhc/vTjkUovomgPWa5ECBa08fJZixth9LaoBo5w==
-
-ramda@^0.25.0:
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/ramda/-/ramda-0.25.0.tgz#8fdf68231cffa90bc2f9460390a0cb74a29b29a9"
-  integrity sha512-GXpfrYVPwx3K7RQ6aYT8KPS8XViSXUVJT1ONhoKPE9VAleW42YE+U+8VEyGWt41EnEQW7gwecYJriTI0pKoecQ==
-
-ramdasauce@^2.1.0:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/ramdasauce/-/ramdasauce-2.1.3.tgz#acb45ecc7e4fc4d6f39e19989b4a16dff383e9c2"
-  integrity sha512-Ml3CPim4SKwmg5g9UI77lnRSeKr/kQw7YhQ6rfdMcBYy6DMlwmkEwQqjygJ3OhxPR+NfFfpjKl3Tf8GXckaqqg==
-  dependencies:
-    ramda "^0.24.1"
-
-randomatic@^3.0.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/randomatic/-/randomatic-3.1.1.tgz#b776efc59375984e36c537b2f51a1f0aff0da1ed"
-  integrity sha512-TuDE5KxZ0J461RVjrJZCJc+J+zCkTb1MbH9AQUq68sMhOMcy9jLcb3BrZKgp9q9Ncltdg4QVqWrH02W2EFFVYw==
-  dependencies:
-    is-number "^4.0.0"
-    kind-of "^6.0.0"
-    math-random "^1.0.1"
-
-randombytes@^2.0.0, randombytes@^2.0.1, randombytes@^2.0.5, randombytes@^2.0.6, randombytes@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
-  integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
-  dependencies:
-    safe-buffer "^5.1.0"
-
-randomfill@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/randomfill/-/randomfill-1.0.4.tgz#c92196fc86ab42be983f1bf31778224931d61458"
-  integrity sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==
-  dependencies:
-    randombytes "^2.0.5"
-    safe-buffer "^5.1.0"
-
-range-parser@~1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.1.tgz#3cf37023d199e1c24d1a55b84800c2f3e6468031"
-  integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==
-
-raw-body@2.5.1:
-  version "2.5.1"
-  resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-2.5.1.tgz#fe1b1628b181b700215e5fd42389f98b71392857"
-  integrity sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==
-  dependencies:
-    bytes "3.1.2"
-    http-errors "2.0.0"
-    iconv-lite "0.4.24"
-    unpipe "1.0.0"
-
-rc@^1.2.7:
-  version "1.2.8"
-  resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.8.tgz#cd924bf5200a075b83c188cd6b9e211b7fc0d3ed"
-  integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==
-  dependencies:
-    deep-extend "^0.6.0"
-    ini "~1.3.0"
-    minimist "^1.2.0"
-    strip-json-comments "~2.0.1"
-
-react-is@^16.7.0, react-is@^16.8.1:
-  version "16.13.1"
-  resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4"
-  integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
-
-react-native-fetch-api@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/react-native-fetch-api/-/react-native-fetch-api-3.0.0.tgz#81e1bb6562c292521bc4eca52fe1097f4c1ebab5"
-  integrity sha512-g2rtqPjdroaboDKTsJCTlcmtw54E25OjyaunUP0anOZn4Fuo2IKs8BVfe02zVggA/UysbmfSnRJIqtNkAgggNA==
-  dependencies:
-    p-defer "^3.0.0"
-
-read-pkg-up@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02"
-  integrity sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=
-  dependencies:
-    find-up "^1.0.0"
-    read-pkg "^1.0.0"
-
-read-pkg@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-1.1.0.tgz#f5ffaa5ecd29cb31c0474bca7d756b6bb29e3f28"
-  integrity sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=
-  dependencies:
-    load-json-file "^1.0.0"
-    normalize-package-data "^2.3.2"
-    path-type "^1.0.0"
-
-readable-stream@1.0.33:
-  version "1.0.33"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.0.33.tgz#3a360dd66c1b1d7fd4705389860eda1d0f61126c"
-  integrity sha1-OjYN1mwbHX/UcFOJhg7aHQ9hEmw=
-  dependencies:
-    core-util-is "~1.0.0"
-    inherits "~2.0.1"
-    isarray "0.0.1"
-    string_decoder "~0.10.x"
-
-readable-stream@1.1:
-  version "1.1.13"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.1.13.tgz#f6eef764f514c89e2b9e23146a75ba106756d23e"
-  integrity sha1-9u73ZPUUyJ4rniMUanW6EGdW0j4=
-  dependencies:
-    core-util-is "~1.0.0"
-    inherits "~2.0.1"
-    isarray "0.0.1"
-    string_decoder "~0.10.x"
-
-readable-stream@1.1.14, readable-stream@^1.0.33:
-  version "1.1.14"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.1.14.tgz#7cf4c54ef648e3813084c636dd2079e166c081d9"
-  integrity sha1-fPTFTvZI44EwhMY23SB54WbAgdk=
-  dependencies:
-    core-util-is "~1.0.0"
-    inherits "~2.0.1"
-    isarray "0.0.1"
-    string_decoder "~0.10.x"
-
-"readable-stream@2 || 3", readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.6.0:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198"
-  integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
-  dependencies:
-    inherits "^2.0.3"
-    string_decoder "^1.1.1"
-    util-deprecate "^1.0.1"
-
-"readable-stream@>=1.0.33-1 <1.1.0-0", readable-stream@~1.0.15, readable-stream@~1.0.26-4:
-  version "1.0.34"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.0.34.tgz#125820e34bc842d2f2aaafafe4c2916ee32c157c"
-  integrity sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=
-  dependencies:
-    core-util-is "~1.0.0"
-    inherits "~2.0.1"
-    isarray "0.0.1"
-    string_decoder "~0.10.x"
-
-readable-stream@^2.0.0, readable-stream@^2.0.1, readable-stream@^2.0.4, readable-stream@^2.0.5, readable-stream@^2.0.6, readable-stream@^2.2.2, readable-stream@^2.2.9, readable-stream@^2.3.0, readable-stream@^2.3.5, readable-stream@~2.3.6:
-  version "2.3.7"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57"
-  integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==
-  dependencies:
-    core-util-is "~1.0.0"
-    inherits "~2.0.3"
-    isarray "~1.0.0"
-    process-nextick-args "~2.0.0"
-    safe-buffer "~5.1.1"
-    string_decoder "~1.1.1"
-    util-deprecate "~1.0.1"
-
-readable-stream@~0.0.2:
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-0.0.4.tgz#f32d76e3fb863344a548d79923007173665b3b8d"
-  integrity sha1-8y124/uGM0SlSNeZIwBxc2ZbO40=
-
-readable-stream@~2.0.0:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.0.6.tgz#8f90341e68a53ccc928788dacfcd11b36eb9b78e"
-  integrity sha1-j5A0HmilPMySh4jaz80Rs265t44=
-  dependencies:
-    core-util-is "~1.0.0"
-    inherits "~2.0.1"
-    isarray "~1.0.0"
-    process-nextick-args "~1.0.6"
-    string_decoder "~0.10.x"
-    util-deprecate "~1.0.1"
-
-readdirp@~3.4.0:
-  version "3.4.0"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.4.0.tgz#9fdccdf9e9155805449221ac645e8303ab5b9ada"
-  integrity sha512-0xe001vZBnJEK+uKcj8qOhyAKPzIT+gStxWr3LCB0DwcXR5NZJ3IaC+yGnHCYzB/S7ov3m3EEbZI2zeNvX+hGQ==
-  dependencies:
-    picomatch "^2.2.1"
-
-readdirp@~3.6.0:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7"
-  integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
-  dependencies:
-    picomatch "^2.2.1"
-
-receptacle@^1.3.2:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/receptacle/-/receptacle-1.3.2.tgz#a7994c7efafc7a01d0e2041839dab6c4951360d2"
-  integrity sha512-HrsFvqZZheusncQRiEE7GatOAETrARKV/lnfYicIm8lbvp/JQOdADOfhjBd2DajvoszEyxSM6RlAAIZgEoeu/A==
-  dependencies:
-    ms "^2.1.1"
-
-redeyed@~2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/redeyed/-/redeyed-2.1.1.tgz#8984b5815d99cb220469c99eeeffe38913e6cc0b"
-  integrity sha512-FNpGGo1DycYAdnrKFxCMmKYgo/mILAqtRYbkdQD8Ep/Hk2PQ5+aEAEx+IU713RTDmuBaH0c8P5ZozurNu5ObRQ==
-  dependencies:
-    esprima "~4.0.0"
-
-redux-cli-logger@^2.0.1:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/redux-cli-logger/-/redux-cli-logger-2.1.0.tgz#7e546502a4b08c7fac4fe2faee2326a6326cb4a1"
-  integrity sha512-75mVsggAJRSykWy2qxdGI7osocDWvc3RCMeN93hlvS/FxgdRww12NaXslez+W6gBOrSJKO7W16V0IzuISSfCxg==
-  dependencies:
-    colors "^1.1.2"
-
-redux-devtools-core@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/redux-devtools-core/-/redux-devtools-core-0.2.1.tgz#4e43cbe590a1f18c13ee165d2d42e0bc77a164d8"
-  integrity sha512-RAGOxtUFdr/1USAvxrWd+Gq/Euzgw7quCZlO5TgFpDfG7rB5tMhZUrNyBjpzgzL2yMk0eHnPYIGm7NkIfRzHxQ==
-  dependencies:
-    get-params "^0.1.2"
-    jsan "^3.1.13"
-    lodash "^4.17.11"
-    nanoid "^2.0.0"
-    remotedev-serialize "^0.1.8"
-
-redux-devtools-instrument@^1.9.4:
-  version "1.10.0"
-  resolved "https://registry.yarnpkg.com/redux-devtools-instrument/-/redux-devtools-instrument-1.10.0.tgz#036caf79fa1e5f25ec4bae38a9af4f08c69e323a"
-  integrity sha512-X8JRBCzX2ADSMp+iiV7YQ8uoTNyEm0VPFPd4T854coz6lvRiBrFSqAr9YAS2n8Kzxx8CJQotR0QF9wsMM+3DvA==
-  dependencies:
-    lodash "^4.17.19"
-    symbol-observable "^1.2.0"
-
-redux-saga@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/redux-saga/-/redux-saga-1.0.0.tgz#acb8b3ed9180fecbe75f342011d75af3ac11045b"
-  integrity sha512-GvJWs/SzMvEQgeaw6sRMXnS2FghlvEGsHiEtTLpJqc/FHF3I5EE/B+Hq5lyHZ8LSoT2r/X/46uWvkdCnK9WgHA==
-  dependencies:
-    "@redux-saga/core" "^1.0.0"
-
-redux@^3.7.2:
-  version "3.7.2"
-  resolved "https://registry.yarnpkg.com/redux/-/redux-3.7.2.tgz#06b73123215901d25d065be342eb026bc1c8537b"
-  integrity sha512-pNqnf9q1hI5HHZRBkj3bAngGZW/JMCmexDlOxw4XagXY2o1327nHH54LoTjiPJ0gizoqPDRqWyX/00g0hD6w+A==
-  dependencies:
-    lodash "^4.2.1"
-    lodash-es "^4.2.1"
-    loose-envify "^1.1.0"
-    symbol-observable "^1.0.3"
-
-redux@^4.0.4:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/redux/-/redux-4.0.5.tgz#4db5de5816e17891de8a80c424232d06f051d93f"
-  integrity sha512-VSz1uMAH24DM6MF72vcojpYPtrTUu3ByVWfPL1nPfVRb5mZVTve5GnNCUV53QM/BZ66xfWrm0CTWoM+Xlz8V1w==
-  dependencies:
-    loose-envify "^1.4.0"
-    symbol-observable "^1.2.0"
-
-regenerator-runtime@^0.10.5:
-  version "0.10.5"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.10.5.tgz#336c3efc1220adcedda2c9fab67b5a7955a33658"
-  integrity sha1-M2w+/BIgrc7dosn6tntaeVWjNlg=
-
-regenerator-runtime@^0.11.0:
-  version "0.11.1"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz#be05ad7f9bf7d22e056f9726cee5017fbf19e2e9"
-  integrity sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==
-
-regenerator-runtime@^0.13.4:
-  version "0.13.9"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.9.tgz#8925742a98ffd90814988d7566ad30ca3b263b52"
-  integrity sha512-p3VT+cOEgxFsRRA9X4lkI1E+k2/CtnKtU4gcxyaCUreilL/vqI6CdZ3wxVUx3UOUg+gnUOQQcRI7BmSI656MYA==
-
-regex-cache@^0.4.2:
-  version "0.4.4"
-  resolved "https://registry.yarnpkg.com/regex-cache/-/regex-cache-0.4.4.tgz#75bdc58a2a1496cec48a12835bc54c8d562336dd"
-  integrity sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==
-  dependencies:
-    is-equal-shallow "^0.1.3"
-
-relay-compiler@10.1.0:
-  version "10.1.0"
-  resolved "https://registry.yarnpkg.com/relay-compiler/-/relay-compiler-10.1.0.tgz#fb4672cdbe9b54869a3a79759edd8c2d91609cbe"
-  integrity sha512-HPqc3N3tNgEgUH5+lTr5lnLbgnsZMt+MRiyS0uAVNhuPY2It0X1ZJG+9qdA3L9IqKFUNwVn6zTO7RArjMZbARQ==
-  dependencies:
-    "@babel/core" "^7.0.0"
-    "@babel/generator" "^7.5.0"
-    "@babel/parser" "^7.0.0"
-    "@babel/runtime" "^7.0.0"
-    "@babel/traverse" "^7.0.0"
-    "@babel/types" "^7.0.0"
-    babel-preset-fbjs "^3.3.0"
-    chalk "^4.0.0"
-    fb-watchman "^2.0.0"
-    fbjs "^3.0.0"
-    glob "^7.1.1"
-    immutable "~3.7.6"
-    nullthrows "^1.1.1"
-    relay-runtime "10.1.0"
-    signedsource "^1.0.0"
-    yargs "^15.3.1"
-
-relay-runtime@10.1.0:
-  version "10.1.0"
-  resolved "https://registry.yarnpkg.com/relay-runtime/-/relay-runtime-10.1.0.tgz#4753bf36e95e8d862cef33608e3d98b4ed730d16"
-  integrity sha512-bxznLnQ1ST6APN/cFi7l0FpjbZVchWQjjhj9mAuJBuUqNNCh9uV+UTRhpQF7Q8ycsPp19LHTpVyGhYb0ustuRQ==
-  dependencies:
-    "@babel/runtime" "^7.0.0"
-    fbjs "^3.0.0"
-
-remote-redux-devtools@^0.5.12:
-  version "0.5.16"
-  resolved "https://registry.yarnpkg.com/remote-redux-devtools/-/remote-redux-devtools-0.5.16.tgz#95b1a4a1988147ca04f3368f3573b661748b3717"
-  integrity sha512-xZ2D1VRIWzat5nsvcraT6fKEX9Cfi+HbQBCwzNnUAM8Uicm/anOc60XGalcaDPrVmLug7nhDl2nimEa3bL3K9w==
-  dependencies:
-    jsan "^3.1.13"
-    querystring "^0.2.0"
-    redux-devtools-core "^0.2.1"
-    redux-devtools-instrument "^1.9.4"
-    rn-host-detect "^1.1.5"
-    socketcluster-client "^14.2.1"
-
-remotedev-serialize@^0.1.8:
-  version "0.1.9"
-  resolved "https://registry.yarnpkg.com/remotedev-serialize/-/remotedev-serialize-0.1.9.tgz#5e67e05cbca75d408d769d057dc59d0f56cd2c43"
-  integrity sha512-5tFdZg9mSaAWTv6xmQ7HtHjKMLSFQFExEZOtJe10PLsv1wb7cy7kYHtBvTYRro27/3fRGEcQBRNKSaixOpb69w==
-  dependencies:
-    jsan "^3.1.13"
-
-remove-trailing-separator@^1.0.1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef"
-  integrity sha1-wkvOKig62tW8P1jg1IJJuSN52O8=
-
-repeat-element@^1.1.2:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.3.tgz#782e0d825c0c5a3bb39731f84efee6b742e6b1ce"
-  integrity sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g==
-
-repeat-string@^1.5.2:
-  version "1.6.1"
-  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
-  integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc=
-
-repeating@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/repeating/-/repeating-2.0.1.tgz#5214c53a926d3552707527fbab415dbc08d06dda"
-  integrity sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=
-  dependencies:
-    is-finite "^1.0.0"
-
-replace-ext@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/replace-ext/-/replace-ext-0.0.1.tgz#29bbd92078a739f0bcce2b4ee41e837953522924"
-  integrity sha1-KbvZIHinOfC8zitO5B6DeVNSKSQ=
-
-request@2.88.2, request@^2.55.0, request@^2.79.0, request@^2.85.0:
-  version "2.88.2"
-  resolved "https://registry.yarnpkg.com/request/-/request-2.88.2.tgz#d73c918731cb5a87da047e207234146f664d12b3"
-  integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==
-  dependencies:
-    aws-sign2 "~0.7.0"
-    aws4 "^1.8.0"
-    caseless "~0.12.0"
-    combined-stream "~1.0.6"
-    extend "~3.0.2"
-    forever-agent "~0.6.1"
-    form-data "~2.3.2"
-    har-validator "~5.1.3"
-    http-signature "~1.2.0"
-    is-typedarray "~1.0.0"
-    isstream "~0.1.2"
-    json-stringify-safe "~5.0.1"
-    mime-types "~2.1.19"
-    oauth-sign "~0.9.0"
-    performance-now "^2.1.0"
-    qs "~6.5.2"
-    safe-buffer "^5.1.2"
-    tough-cookie "~2.5.0"
-    tunnel-agent "^0.6.0"
-    uuid "^3.3.2"
-
-require-directory@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
-  integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I=
-
-require-from-string@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909"
-  integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==
-
-require-main-filename@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-1.0.1.tgz#97f717b69d48784f5f526a6c5aa8ffdda055a4d1"
-  integrity sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=
-
-require-main-filename@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-2.0.0.tgz#d0b329ecc7cc0f61649f62215be69af54aa8989b"
-  integrity sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==
-
-requires-port@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff"
-  integrity sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=
-
-reselect-tree@^1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/reselect-tree/-/reselect-tree-1.3.4.tgz#449629728e2dc79bf0602571ec8859ac34737089"
-  integrity sha512-1OgNq1IStyJFqIqOoD3k3Ge4SsYCMP9W88VQOfvgyLniVKLfvbYO1Vrl92SyEK5021MkoBX6tWb381VxTDyPBQ==
-  dependencies:
-    debug "^3.1.0"
-    esdoc "^1.0.4"
-    json-pointer "^0.6.0"
-    reselect "^4.0.0"
-    source-map-support "^0.5.3"
-
-reselect@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/reselect/-/reselect-4.0.0.tgz#f2529830e5d3d0e021408b246a206ef4ea4437f7"
-  integrity sha512-qUgANli03jjAyGlnbYVAV5vvnOmJnODyABz51RdBN7M4WaVu8mecZWgyQNkG8Yqe3KRGRt0l4K4B3XVEULC4CA==
-
-resolve-from@5.0.0, resolve-from@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
-  integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
-
-resolve-from@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
-  integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
-
-resolve-url@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
-  integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=
-
-resolve@^1.10.0, resolve@^1.14.2:
-  version "1.20.0"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975"
-  integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==
-  dependencies:
-    is-core-module "^2.2.0"
-    path-parse "^1.0.6"
-
-responselike@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/responselike/-/responselike-1.0.2.tgz#918720ef3b631c5642be068f15ade5a46f4ba1e7"
-  integrity sha1-kYcg7ztjHFZCvgaPFa3lpG9Loec=
-  dependencies:
-    lowercase-keys "^1.0.0"
-
-restore-cursor@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf"
-  integrity sha1-n37ih/gv0ybU/RYpI9YhKe7g368=
-  dependencies:
-    onetime "^2.0.0"
-    signal-exit "^3.0.2"
-
-restore-cursor@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-3.1.0.tgz#39f67c54b3a7a58cea5236d95cf0034239631f7e"
-  integrity sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==
-  dependencies:
-    onetime "^5.1.0"
-    signal-exit "^3.0.2"
-
-retimer@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/retimer/-/retimer-3.0.0.tgz#98b751b1feaf1af13eb0228f8ea68b8f9da530df"
-  integrity sha512-WKE0j11Pa0ZJI5YIk0nflGI7SQsfl2ljihVy7ogh7DeQSeYAUi0ubZ/yEueGtDfUPk6GH5LRw1hBdLq4IwUBWA==
-
-retry@0.13.1:
-  version "0.13.1"
-  resolved "https://registry.yarnpkg.com/retry/-/retry-0.13.1.tgz#185b1587acf67919d63b357349e03537b2484658"
-  integrity sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==
-
-reusify@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
-  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
-
-rimraf@^2.2.8, rimraf@^2.6.1, rimraf@^2.6.3:
-  version "2.7.1"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.7.1.tgz#35797f13a7fdadc566142c29d4f07ccad483e3ec"
-  integrity sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==
-  dependencies:
-    glob "^7.1.3"
-
-rimraf@^3.0.0, rimraf@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
-  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
-  dependencies:
-    glob "^7.1.3"
-
-ripemd160@^2.0.0, ripemd160@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c"
-  integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==
-  dependencies:
-    hash-base "^3.0.0"
-    inherits "^2.0.1"
-
-rlp@^2.0.0, rlp@^2.2.3:
-  version "2.2.6"
-  resolved "https://registry.yarnpkg.com/rlp/-/rlp-2.2.6.tgz#c80ba6266ac7a483ef1e69e8e2f056656de2fb2c"
-  integrity sha512-HAfAmL6SDYNWPUOJNrM500x4Thn4PZsEy5pijPh40U9WfNk0z15hUYzO9xVIMAdIHdFtD8CBDHd75Td1g36Mjg==
-  dependencies:
-    bn.js "^4.11.1"
-
-rlp@^2.2.4:
-  version "2.2.7"
-  resolved "https://registry.yarnpkg.com/rlp/-/rlp-2.2.7.tgz#33f31c4afac81124ac4b283e2bd4d9720b30beaf"
-  integrity sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==
-  dependencies:
-    bn.js "^5.2.0"
-
-rn-host-detect@^1.1.5:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/rn-host-detect/-/rn-host-detect-1.2.0.tgz#8b0396fc05631ec60c1cb8789e5070cdb04d0da0"
-  integrity sha512-btNg5kzHcjZZ7t7mvvV/4wNJ9e3MPgrWivkRgWURzXL0JJ0pwWlU4zrbmdlz3HHzHOxhBhHB4D+/dbMFfu4/4A==
-
-run-parallel@^1.1.9:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
-  integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
-  dependencies:
-    queue-microtask "^1.2.2"
-
-rustbn.js@~0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/rustbn.js/-/rustbn.js-0.2.0.tgz#8082cb886e707155fd1cb6f23bd591ab8d55d0ca"
-  integrity sha512-4VlvkRUuCJvr2J6Y0ImW7NvTCriMi7ErOAqWk1y69vAdoNIzCF3yPmgeNzx+RQTLEDFq5sHfscn1MwHxP9hNfA==
-
-safe-buffer@5.2.1, safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@^5.2.0, safe-buffer@^5.2.1, safe-buffer@~5.2.0:
-  version "5.2.1"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
-  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
-
-safe-buffer@~5.1.0, safe-buffer@~5.1.1:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
-  integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
-
-safe-event-emitter@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/safe-event-emitter/-/safe-event-emitter-1.0.1.tgz#5b692ef22329ed8f69fdce607e50ca734f6f20af"
-  integrity sha512-e1wFe99A91XYYxoQbcq2ZJUWurxEyP8vfz7A7vuUe1s95q8r5ebraVaA1BukYJcpM6V16ugWoD9vngi8Ccu5fg==
-  dependencies:
-    events "^3.0.0"
-
-"safer-buffer@>= 2.1.2 < 3", "safer-buffer@>= 2.1.2 < 3.0.0", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
-  integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
-
-sax@^1.1.4, sax@^1.2.4:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"
-  integrity sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==
-
-sc-channel@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/sc-channel/-/sc-channel-1.2.0.tgz#d9209f3a91e3fa694c66b011ce55c4ad8c3087d9"
-  integrity sha512-M3gdq8PlKg0zWJSisWqAsMmTVxYRTpVRqw4CWAdKBgAfVKumFcTjoCV0hYu7lgUXccCtCD8Wk9VkkE+IXCxmZA==
-  dependencies:
-    component-emitter "1.2.1"
-
-sc-errors@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/sc-errors/-/sc-errors-2.0.1.tgz#3af2d934dfd82116279a4b2c1552c1e021ddcb03"
-  integrity sha512-JoVhq3Ud+3Ujv2SIG7W0XtjRHsrNgl6iXuHHsh0s+Kdt5NwI6N2EGAZD4iteitdDv68ENBkpjtSvN597/wxPSQ==
-
-sc-formatter@^3.0.1:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/sc-formatter/-/sc-formatter-3.0.2.tgz#9abdb14e71873ce7157714d3002477bbdb33c4e6"
-  integrity sha512-9PbqYBpCq+OoEeRQ3QfFIGE6qwjjBcd2j7UjgDlhnZbtSnuGgHdcRklPKYGuYFH82V/dwd+AIpu8XvA1zqTd+A==
-
-scrypt-js@2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/scrypt-js/-/scrypt-js-2.0.4.tgz#32f8c5149f0797672e551c07e230f834b6af5f16"
-  integrity sha512-4KsaGcPnuhtCZQCxFxN3GVYIhKFPTdLd8PLC552XwbMndtD0cjRFAhDuuydXQ0h08ZfPgzqe6EKHozpuH74iDw==
-
-scrypt-js@^3.0.0, scrypt-js@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/scrypt-js/-/scrypt-js-3.0.1.tgz#d314a57c2aef69d1ad98a138a21fe9eafa9ee312"
-  integrity sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==
-
-secp256k1@^4.0.1:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/secp256k1/-/secp256k1-4.0.3.tgz#c4559ecd1b8d3c1827ed2d1b94190d69ce267303"
-  integrity sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA==
-  dependencies:
-    elliptic "^6.5.4"
-    node-addon-api "^2.0.0"
-    node-gyp-build "^4.2.0"
-
-semaphore@>=1.0.1, semaphore@^1.0.3:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/semaphore/-/semaphore-1.1.0.tgz#aaad8b86b20fe8e9b32b16dc2ee682a8cd26a8aa"
-  integrity sha512-O4OZEaNtkMd/K0i6js9SL+gqy0ZCBMgUvlSqHKi4IBdjhe7wB8pwztUk1BbZ1fmrvpwFrPbHzqd2w5pTcJH6LA==
-
-"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.5.0:
-  version "5.7.1"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
-  integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
-
-semver@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.0.0.tgz#5f3ca35761e47e05b206c6daff2cf814f0316b8e"
-  integrity sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==
-
-semver@7.3.5:
-  version "7.3.5"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7"
-  integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==
-  dependencies:
-    lru-cache "^6.0.0"
-
-semver@7.4.0:
-  version "7.4.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.4.0.tgz#8481c92feffc531ab1e012a8ffc15bdd3a0f4318"
-  integrity sha512-RgOxM8Mw+7Zus0+zcLEUn8+JfoLpj/huFTItQy2hsM4khuC1HYRDp0cU482Ewn/Fcy6bCjufD8vAj7voC66KQw==
-  dependencies:
-    lru-cache "^6.0.0"
-
-semver@^6.1.1, semver@^6.1.2, semver@^6.3.0:
-  version "6.3.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
-  integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
-
-semver@^7.0.0:
-  version "7.3.7"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.7.tgz#12c5b649afdbf9049707796e22a4028814ce523f"
-  integrity sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==
-  dependencies:
-    lru-cache "^6.0.0"
-
-semver@^7.3.4:
-  version "7.3.4"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.4.tgz#27aaa7d2e4ca76452f98d3add093a72c943edc97"
-  integrity sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==
-  dependencies:
-    lru-cache "^6.0.0"
-
-semver@^7.3.7:
-  version "7.5.1"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.1.tgz#c90c4d631cf74720e46b21c1d37ea07edfab91ec"
-  integrity sha512-Wvss5ivl8TMRZXXESstBA4uR5iXgEN/VC5/sOcuXdVLzcdkz4HWetIoRfG5gb5X+ij/G9rw9YoGn3QoQ8OCSpw==
-  dependencies:
-    lru-cache "^6.0.0"
-
-semver@~5.4.1:
-  version "5.4.1"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.4.1.tgz#e059c09d8571f0540823733433505d3a2f00b18e"
-  integrity sha512-WfG/X9+oATh81XtllIo/I8gOiY9EXRdv1cQdyykeXK17YcUW3EXUAi2To4pcH6nZtJPr7ZOpM5OMyWJZm+8Rsg==
-
-send@0.18.0:
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/send/-/send-0.18.0.tgz#670167cc654b05f5aa4a767f9113bb371bc706be"
-  integrity sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==
-  dependencies:
-    debug "2.6.9"
-    depd "2.0.0"
-    destroy "1.2.0"
-    encodeurl "~1.0.2"
-    escape-html "~1.0.3"
-    etag "~1.8.1"
-    fresh "0.5.2"
-    http-errors "2.0.0"
-    mime "1.6.0"
-    ms "2.1.3"
-    on-finished "2.4.1"
-    range-parser "~1.2.1"
-    statuses "2.0.1"
-
-sentence-case@^2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/sentence-case/-/sentence-case-2.1.1.tgz#1f6e2dda39c168bf92d13f86d4a918933f667ed4"
-  integrity sha1-H24t2jnBaL+S0T+G1KkYkz9mftQ=
-  dependencies:
-    no-case "^2.2.0"
-    upper-case-first "^1.1.2"
-
-serialize-javascript@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-4.0.0.tgz#b525e1238489a5ecfc42afacc3fe99e666f4b1aa"
-  integrity sha512-GaNA54380uFefWghODBWEGisLZFj00nS5ACs6yHa9nLqlLpVLO8ChDGeKRjZnV4Nh4n0Qi7nhYZD/9fCPzEqkw==
-  dependencies:
-    randombytes "^2.1.0"
-
-serve-static@1.15.0:
-  version "1.15.0"
-  resolved "https://registry.yarnpkg.com/serve-static/-/serve-static-1.15.0.tgz#faaef08cffe0a1a62f60cad0c4e513cff0ac9540"
-  integrity sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==
-  dependencies:
-    encodeurl "~1.0.2"
-    escape-html "~1.0.3"
-    parseurl "~1.3.3"
-    send "0.18.0"
-
-servify@^0.1.12:
-  version "0.1.12"
-  resolved "https://registry.yarnpkg.com/servify/-/servify-0.1.12.tgz#142ab7bee1f1d033b66d0707086085b17c06db95"
-  integrity sha512-/xE6GvsKKqyo1BAY+KxOWXcLpPsUUyji7Qg3bVD7hh1eRze5bR1uYiuDA/k3Gof1s9BTzQZEJK8sNcNGFIzeWw==
-  dependencies:
-    body-parser "^1.16.0"
-    cors "^2.8.1"
-    express "^4.14.0"
-    request "^2.79.0"
-    xhr "^2.3.3"
-
-set-blocking@^2.0.0, set-blocking@~2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
-  integrity sha1-BF+XgtARrppoA93TgrJDkrPYkPc=
-
-set-immediate-shim@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz#4b2b1b27eb808a9f8dcc481a58e5e56f599f3f61"
-  integrity sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=
-
-setimmediate@1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.4.tgz#20e81de622d4a02588ce0c8da8973cbcf1d3138f"
-  integrity sha1-IOgd5iLUoCWIzgyNqJc8vPHTE48=
-
-setimmediate@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
-  integrity sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==
-
-setprototypeof@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.2.0.tgz#66c9a24a73f9fc28cbe66b09fed3d33dcaf1b424"
-  integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==
-
-sha.js@^2.4.0, sha.js@^2.4.11, sha.js@^2.4.8:
-  version "2.4.11"
-  resolved "https://registry.yarnpkg.com/sha.js/-/sha.js-2.4.11.tgz#37a5cf0b81ecbc6943de109ba2960d1b26584ae7"
-  integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==
-  dependencies:
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-shallowequal@^1.0.2:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/shallowequal/-/shallowequal-1.1.0.tgz#188d521de95b9087404fd4dcb68b13df0ae4e7f8"
-  integrity sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==
-
-shebang-command@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
-  integrity sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==
-  dependencies:
-    shebang-regex "^1.0.0"
-
-shebang-command@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
-  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
-  dependencies:
-    shebang-regex "^3.0.0"
-
-shebang-regex@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3"
-  integrity sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==
-
-shebang-regex@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
-  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
-
-side-channel@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.0.4.tgz#efce5c8fdc104ee751b25c58d4290011fa5ea2cf"
-  integrity sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==
-  dependencies:
-    call-bind "^1.0.0"
-    get-intrinsic "^1.0.2"
-    object-inspect "^1.9.0"
-
-signal-exit@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.3.tgz#a1410c2edd8f077b08b4e253c8eacfcaf057461c"
-  integrity sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==
-
-signal-exit@^3.0.2, signal-exit@^3.0.3:
-  version "3.0.7"
-  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9"
-  integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
-
-signedsource@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/signedsource/-/signedsource-1.0.0.tgz#1ddace4981798f93bd833973803d80d52e93ad6a"
-  integrity sha1-HdrOSYF5j5O9gzlzgD2A1S6TrWo=
-
-simple-concat@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/simple-concat/-/simple-concat-1.0.1.tgz#f46976082ba35c2263f1c8ab5edfe26c41c9552f"
-  integrity sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==
-
-simple-get@^2.7.0:
-  version "2.8.2"
-  resolved "https://registry.yarnpkg.com/simple-get/-/simple-get-2.8.2.tgz#5708fb0919d440657326cd5fe7d2599d07705019"
-  integrity sha512-Ijd/rV5o+mSBBs4F/x9oDPtTx9Zb6X9brmnXvMW4J7IR15ngi9q5xxqWBKU744jTZiaXtxaPL7uHG6vtN8kUkw==
-  dependencies:
-    decompress-response "^3.3.0"
-    once "^1.3.1"
-    simple-concat "^1.0.0"
-
-slash@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/slash/-/slash-1.0.0.tgz#c41f2f6c39fc16d1cd17ad4b5d896114ae470d55"
-  integrity sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=
-
-slash@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
-  integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
-
-slice-ansi@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b"
-  integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==
-  dependencies:
-    ansi-styles "^4.0.0"
-    astral-regex "^2.0.0"
-    is-fullwidth-code-point "^3.0.0"
-
-snake-case@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/snake-case/-/snake-case-2.1.0.tgz#41bdb1b73f30ec66a04d4e2cad1b76387d4d6d9f"
-  integrity sha1-Qb2xtz8w7GagTU4srRt2OH1NbZ8=
-  dependencies:
-    no-case "^2.2.0"
-
-socketcluster-client@^14.2.1:
-  version "14.3.1"
-  resolved "https://registry.yarnpkg.com/socketcluster-client/-/socketcluster-client-14.3.1.tgz#bfc3591c0cad2668e7b3512a102f3844f5f2e84d"
-  integrity sha512-Sd/T0K/9UlqTfz+HUuFq90dshA5OBJPQbdkRzGtcKIOm52fkdsBTt0FYpiuzzxv5VrU7PWpRm6KIfNXyPwlLpw==
-  dependencies:
-    buffer "^5.2.1"
-    clone "2.1.1"
-    component-emitter "1.2.1"
-    linked-list "0.1.0"
-    querystring "0.2.0"
-    sc-channel "^1.2.0"
-    sc-errors "^2.0.1"
-    sc-formatter "^3.0.1"
-    uuid "3.2.1"
-    ws "7.1.0"
-
-solc@^0.8.2:
-  version "0.8.2"
-  resolved "https://registry.yarnpkg.com/solc/-/solc-0.8.2.tgz#6033d75c6166fd0feb7fe08eddc198aaf52025da"
-  integrity sha512-fMfcAPaePLfsOY82jqONt0RMh5M8m+pK6QtnMGMUFUm8uEDlUmoqnyLxGVFelosJaVfXhygAB+mTlb+HxiV7DQ==
-  dependencies:
-    command-exists "^1.2.8"
-    commander "3.0.2"
-    follow-redirects "^1.12.1"
-    fs-extra "^0.30.0"
-    js-sha3 "0.8.0"
-    memorystream "^0.3.1"
-    require-from-string "^2.0.0"
-    semver "^5.5.0"
-    tmp "0.0.33"
-
-source-map-resolve@^0.5.2:
-  version "0.5.3"
-  resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.3.tgz#190866bece7553e1f8f267a2ee82c606b5509a1a"
-  integrity sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==
-  dependencies:
-    atob "^2.1.2"
-    decode-uri-component "^0.2.0"
-    resolve-url "^0.2.1"
-    source-map-url "^0.4.0"
-    urix "^0.1.0"
-
-source-map-support@^0.4.15:
-  version "0.4.18"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.4.18.tgz#0286a6de8be42641338594e97ccea75f0a2c585f"
-  integrity sha512-try0/JqxPLF9nOjvSta7tVondkP5dwgyLDjVoyMDlmjugT2lRZ1OfsrYTkCd2hkDnJTKRbO/Rl3orm8vlsUzbA==
-  dependencies:
-    source-map "^0.5.6"
-
-source-map-support@^0.5.19, source-map-support@^0.5.3:
-  version "0.5.19"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
-  integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
-  dependencies:
-    buffer-from "^1.0.0"
-    source-map "^0.6.0"
-
-source-map-support@^0.5.20:
-  version "0.5.21"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f"
-  integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
-  dependencies:
-    buffer-from "^1.0.0"
-    source-map "^0.6.0"
-
-source-map-url@^0.4.0:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.1.tgz#0af66605a745a5a2f91cf1bbf8a7afbc283dec56"
-  integrity sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==
-
-source-map@^0.5.0, source-map@^0.5.6, source-map@^0.5.7:
-  version "0.5.7"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
-  integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
-
-source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.0, source-map@~0.6.1:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
-  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
-
-spark-md5@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/spark-md5/-/spark-md5-3.0.0.tgz#3722227c54e2faf24b1dc6d933cc144e6f71bfef"
-  integrity sha1-NyIifFTi+vJLHcbZM8wUTm9xv+8=
-
-spark-md5@3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/spark-md5/-/spark-md5-3.0.1.tgz#83a0e255734f2ab4e5c466e5a2cfc9ba2aa2124d"
-  integrity sha512-0tF3AGSD1ppQeuffsLDIOWlKUd3lS92tFxcsrh5Pe3ZphhnoK+oXIBTzOAThZCiuINZLvpiLH/1VS1/ANEJVig==
-
-spdx-correct@^3.0.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.1.1.tgz#dece81ac9c1e6713e5f7d1b6f17d468fa53d89a9"
-  integrity sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==
-  dependencies:
-    spdx-expression-parse "^3.0.0"
-    spdx-license-ids "^3.0.0"
-
-spdx-exceptions@^2.1.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz#3f28ce1a77a00372683eade4a433183527a2163d"
-  integrity sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==
-
-spdx-expression-parse@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz#cf70f50482eefdc98e3ce0a6833e4a53ceeba679"
-  integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==
-  dependencies:
-    spdx-exceptions "^2.1.0"
-    spdx-license-ids "^3.0.0"
-
-spdx-license-ids@^3.0.0:
-  version "3.0.7"
-  resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.7.tgz#e9c18a410e5ed7e12442a549fbd8afa767038d65"
-  integrity sha512-U+MTEOO0AiDzxwFvoa4JVnMV6mZlJKk2sBLt90s7G0Gd0Mlknc7kxEn3nuDPNZRta7O2uy8oLcZLVT+4sqNZHQ==
-
-split-ca@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/split-ca/-/split-ca-1.0.1.tgz#6c83aff3692fa61256e0cd197e05e9de157691a6"
-  integrity sha512-Q5thBSxp5t8WPTTJQS59LrGqOZqOsrhDGDVm8azCqIBjSBd7nd9o2PM+mDulQQkh8h//4U6hFZnc/mul8t5pWQ==
-
-sprintf-js@~1.0.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
-  integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==
-
-sqlite3@^4.0.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/sqlite3/-/sqlite3-4.2.0.tgz#49026d665e9fc4f922e56fb9711ba5b4c85c4901"
-  integrity sha512-roEOz41hxui2Q7uYnWsjMOTry6TcNUNmp8audCx18gF10P2NknwdpF+E+HKvz/F2NvPKGGBF4NGc+ZPQ+AABwg==
-  dependencies:
-    nan "^2.12.1"
-    node-pre-gyp "^0.11.0"
-
-sse-z@0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/sse-z/-/sse-z-0.3.0.tgz#e215db7c303d6c4a4199d80cb63811cc28fa55b9"
-  integrity sha512-jfcXynl9oAOS9YJ7iqS2JMUEHOlvrRAD+54CENiWnc4xsuVLQVSgmwf7cwOTcBd/uq3XkQKBGojgvEtVXcJ/8w==
-
-sshpk@^1.7.0:
-  version "1.17.0"
-  resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.17.0.tgz#578082d92d4fe612b13007496e543fa0fbcbe4c5"
-  integrity sha512-/9HIEs1ZXGhSPE8X6Ccm7Nam1z8KcoCqPdI7ecm1N33EzAetWahvQWVqLZtaZQ+IDKX4IyA2o0gBzqIMkAagHQ==
-  dependencies:
-    asn1 "~0.2.3"
-    assert-plus "^1.0.0"
-    bcrypt-pbkdf "^1.0.0"
-    dashdash "^1.12.0"
-    ecc-jsbn "~0.1.1"
-    getpass "^0.1.1"
-    jsbn "~0.1.0"
-    safer-buffer "^2.0.2"
-    tweetnacl "~0.14.0"
-
-statuses@2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/statuses/-/statuses-2.0.1.tgz#55cb000ccf1d48728bd23c685a063998cf1a1b63"
-  integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==
-
-"statuses@>= 1.5.0 < 2":
-  version "1.5.0"
-  resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c"
-  integrity sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=
-
-stoppable@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/stoppable/-/stoppable-1.1.0.tgz#32da568e83ea488b08e4d7ea2c3bcc9d75015d5b"
-  integrity sha512-KXDYZ9dszj6bzvnEMRYvxgeTHU74QBFL54XKtP3nyMuJ81CFYtABZ3bAzL2EdFUaEwJOBOgENyFj3R7oTzDyyw==
-
-stream-shift@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/stream-shift/-/stream-shift-1.0.1.tgz#d7088281559ab2778424279b0877da3c392d5a3d"
-  integrity sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==
-
-stream-to-it@^0.2.2:
-  version "0.2.4"
-  resolved "https://registry.yarnpkg.com/stream-to-it/-/stream-to-it-0.2.4.tgz#d2fd7bfbd4a899b4c0d6a7e6a533723af5749bd0"
-  integrity sha512-4vEbkSs83OahpmBybNJXlJd7d6/RxzkkSdT3I0mnGt79Xd2Kk+e1JqbvAvsQfCeKj3aKb0QIWkyK3/n0j506vQ==
-  dependencies:
-    get-iterator "^1.0.2"
-
-streamsearch@0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/streamsearch/-/streamsearch-0.1.2.tgz#808b9d0e56fc273d809ba57338e929919a1a9f1a"
-  integrity sha1-gIudDlb8Jz2Am6VzOOkpkZoanxo=
-
-streamsearch@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/streamsearch/-/streamsearch-1.1.0.tgz#404dd1e2247ca94af554e841a8ef0eaa238da764"
-  integrity sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==
-
-strict-uri-encode@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz#279b225df1d582b1f54e65addd4352e18faa0713"
-  integrity sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM=
-
-string-width@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3"
-  integrity sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=
-  dependencies:
-    code-point-at "^1.0.0"
-    is-fullwidth-code-point "^1.0.0"
-    strip-ansi "^3.0.0"
-
-"string-width@^1.0.2 || 2", string-width@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
-  integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==
-  dependencies:
-    is-fullwidth-code-point "^2.0.0"
-    strip-ansi "^4.0.0"
-
-string-width@^3.0.0, string-width@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-3.1.0.tgz#22767be21b62af1081574306f69ac51b62203961"
-  integrity sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==
-  dependencies:
-    emoji-regex "^7.0.1"
-    is-fullwidth-code-point "^2.0.0"
-    strip-ansi "^5.1.0"
-
-string-width@^4.0.0, string-width@^4.2.3:
-  version "4.2.3"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
-  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
-  dependencies:
-    emoji-regex "^8.0.0"
-    is-fullwidth-code-point "^3.0.0"
-    strip-ansi "^6.0.1"
-
-string-width@^4.1.0, string-width@^4.2.0:
-  version "4.2.2"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.2.tgz#dafd4f9559a7585cfba529c6a0a4f73488ebd4c5"
-  integrity sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==
-  dependencies:
-    emoji-regex "^8.0.0"
-    is-fullwidth-code-point "^3.0.0"
-    strip-ansi "^6.0.0"
-
-string.prototype.trimend@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz#e75ae90c2942c63504686c18b287b4a0b1a45f80"
-  integrity sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.3"
-
-string.prototype.trimstart@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.4.tgz#b36399af4ab2999b4c9c648bd7a3fb2bb26feeed"
-  integrity sha512-jh6e984OBfvxS50tdY2nRZnoC5/mLFKOREQfw8t5yytkoUsJRNxvI/E39qu1sD0OtWI3OC0XgKSmcWwziwYuZw==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.3"
-
-string_decoder@^1.1.1:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
-  integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
-  dependencies:
-    safe-buffer "~5.2.0"
-
-string_decoder@~0.10.x:
-  version "0.10.31"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-0.10.31.tgz#62e203bc41766c6c28c9fc84301dab1c5310fa94"
-  integrity sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==
-
-string_decoder@~1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"
-  integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
-  dependencies:
-    safe-buffer "~5.1.0"
-
-strip-ansi@^3.0.0, strip-ansi@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
-  integrity sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=
-  dependencies:
-    ansi-regex "^2.0.0"
-
-strip-ansi@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-4.0.0.tgz#a8479022eb1ac368a871389b635262c505ee368f"
-  integrity sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==
-  dependencies:
-    ansi-regex "^3.0.0"
-
-strip-ansi@^5.0.0, strip-ansi@^5.1.0, strip-ansi@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-5.2.0.tgz#8c9a536feb6afc962bdfa5b104a5091c1ad9c0ae"
-  integrity sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==
-  dependencies:
-    ansi-regex "^4.1.0"
-
-strip-ansi@^6.0.0, strip-ansi@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
-  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
-  dependencies:
-    ansi-regex "^5.0.1"
-
-strip-bom-stream@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom-stream/-/strip-bom-stream-1.0.0.tgz#e7144398577d51a6bed0fa1994fa05f43fd988ee"
-  integrity sha1-5xRDmFd9Uaa+0PoZlPoF9D/ZiO4=
-  dependencies:
-    first-chunk-stream "^1.0.0"
-    strip-bom "^2.0.0"
-
-strip-bom@2.X, strip-bom@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-2.0.0.tgz#6219a85616520491f35788bdbf1447a99c7e6b0e"
-  integrity sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=
-  dependencies:
-    is-utf8 "^0.2.0"
-
-strip-final-newline@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad"
-  integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
-
-strip-hex-prefix@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz#0c5f155fef1151373377de9dbb588da05500e36f"
-  integrity sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==
-  dependencies:
-    is-hex-prefixed "1.0.0"
-
-strip-indent@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-2.0.0.tgz#5ef8db295d01e6ed6cbf7aab96998d7822527b68"
-  integrity sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g=
-
-strip-json-comments@3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.0.1.tgz#85713975a91fb87bf1b305cca77395e40d2a64a7"
-  integrity sha512-VTyMAUfdm047mwKl+u79WIdrZxtFtn+nBxHeb844XBQ9uMNTuTHdx2hc5RiAJYqwTj3wc/xe5HLSdJSkJ+WfZw==
-
-strip-json-comments@~2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
-  integrity sha1-PFMZQukIwml8DsNEhYwobHygpgo=
-
-sublevel-pouchdb@7.2.2:
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/sublevel-pouchdb/-/sublevel-pouchdb-7.2.2.tgz#49e46cd37883bf7ff5006d7c5b9bcc7bcc1f422f"
-  integrity sha512-y5uYgwKDgXVyPZceTDGWsSFAhpSddY29l9PJbXqMJLfREdPmQTY8InpatohlEfCXX7s1LGcrfYAhxPFZaJOLnQ==
-  dependencies:
-    inherits "2.0.4"
-    level-codec "9.0.2"
-    ltgt "2.2.1"
-    readable-stream "1.1.14"
-
-subscriptions-transport-ws@^0.9.19:
-  version "0.9.19"
-  resolved "https://registry.yarnpkg.com/subscriptions-transport-ws/-/subscriptions-transport-ws-0.9.19.tgz#10ca32f7e291d5ee8eb728b9c02e43c52606cdcf"
-  integrity sha512-dxdemxFFB0ppCLg10FTtRqH/31FNRL1y1BQv8209MK5I4CwALb7iihQg+7p65lFcIl8MHatINWBLOqpgU4Kyyw==
-  dependencies:
-    backo2 "^1.0.2"
-    eventemitter3 "^3.1.0"
-    iterall "^1.2.1"
-    symbol-observable "^1.0.4"
-    ws "^5.2.0 || ^6.0.0 || ^7.0.0"
-
-super-split@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/super-split/-/super-split-1.1.0.tgz#43b3ba719155f4d43891a32729d59b213d9155fc"
-  integrity sha512-I4bA5mgcb6Fw5UJ+EkpzqXfiuvVGS/7MuND+oBxNFmxu3ugLNrdIatzBLfhFRMVMLxgSsRy+TjIktgkF9RFSNQ==
-
-supports-color@7.1.0:
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.1.0.tgz#68e32591df73e25ad1c4b49108a2ec507962bfd1"
-  integrity sha512-oRSIpR8pxT1Wr2FquTNnGet79b3BWljqOuoW/h4oBhxJ/HUbX5nX6JSruTkvXDCFMwDPvsaTTbvMLKZWSy0R5g==
-  dependencies:
-    has-flag "^4.0.0"
-
-supports-color@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7"
-  integrity sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=
-
-supports-color@^5.3.0:
-  version "5.5.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
-  integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
-  dependencies:
-    has-flag "^3.0.0"
-
-supports-color@^7.0.0, supports-color@^7.1.0:
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
-  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
-  dependencies:
-    has-flag "^4.0.0"
-
-supports-color@^8.1.1:
-  version "8.1.1"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c"
-  integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==
-  dependencies:
-    has-flag "^4.0.0"
-
-supports-hyperlinks@^2.2.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/supports-hyperlinks/-/supports-hyperlinks-2.3.0.tgz#3943544347c1ff90b15effb03fc14ae45ec10624"
-  integrity sha512-RpsAZlpWcDwOPQA22aCH4J0t7L8JmAvsCxfOSEwm7cQs3LshN36QaTkwd70DnBOXDWGssw2eUoc8CaRWT0XunA==
-  dependencies:
-    has-flag "^4.0.0"
-    supports-color "^7.0.0"
-
-swap-case@^1.1.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/swap-case/-/swap-case-1.1.2.tgz#c39203a4587385fad3c850a0bd1bcafa081974e3"
-  integrity sha1-w5IDpFhzhfrTyFCgvRvK+ggZdOM=
-  dependencies:
-    lower-case "^1.1.1"
-    upper-case "^1.1.1"
-
-swarm-js@^0.1.40:
-  version "0.1.40"
-  resolved "https://registry.yarnpkg.com/swarm-js/-/swarm-js-0.1.40.tgz#b1bc7b6dcc76061f6c772203e004c11997e06b99"
-  integrity sha512-yqiOCEoA4/IShXkY3WKwP5PvZhmoOOD8clsKA7EEcRILMkTEYHCQ21HDCAcVpmIxZq4LyZvWeRJ6quIyHk1caA==
-  dependencies:
-    bluebird "^3.5.0"
-    buffer "^5.0.5"
-    eth-lib "^0.1.26"
-    fs-extra "^4.0.2"
-    got "^7.1.0"
-    mime-types "^2.1.16"
-    mkdirp-promise "^5.0.1"
-    mock-fs "^4.1.0"
-    setimmediate "^1.0.5"
-    tar "^4.0.2"
-    xhr-request "^1.0.1"
-
-symbol-observable@^1.0.3, symbol-observable@^1.0.4, symbol-observable@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-1.2.0.tgz#c22688aed4eab3cdc2dfeacbb561660560a00804"
-  integrity sha512-e900nM8RRtGhlV36KGEU9k65K3mPb1WV70OdjfxlG2EAuM1noi/E/BaW/uMhL7bPEssK8QV57vN3esixjUvcXQ==
-
-symbol-observable@^2.0.0:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-2.0.3.tgz#5b521d3d07a43c351055fa43b8355b62d33fd16a"
-  integrity sha512-sQV7phh2WCYAn81oAkakC5qjq2Ml0g8ozqz03wOGnx9dDlG1de6yrF+0RAzSJD8fPUow3PTSMf2SAbOGxb93BA==
-
-"symbol-tree@>= 3.1.0 < 4.0.0":
-  version "3.2.4"
-  resolved "https://registry.yarnpkg.com/symbol-tree/-/symbol-tree-3.2.4.tgz#430637d248ba77e078883951fb9aa0eed7c63fa2"
-  integrity sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==
-
-symbol@^0.2.1:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/symbol/-/symbol-0.2.3.tgz#3b9873b8a901e47c6efe21526a3ac372ef28bbc7"
-  integrity sha1-O5hzuKkB5Hxu/iFSajrDcu8ou8c=
-
-sync-fetch@0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/sync-fetch/-/sync-fetch-0.3.0.tgz#77246da949389310ad978ab26790bb05f88d1335"
-  integrity sha512-dJp4qg+x4JwSEW1HibAuMi0IIrBI3wuQr2GimmqB7OXR50wmwzfdusG+p39R9w3R6aFtZ2mzvxvWKQ3Bd/vx3g==
-  dependencies:
-    buffer "^5.7.0"
-    node-fetch "^2.6.1"
-
-sync-request@6.1.0:
-  version "6.1.0"
-  resolved "https://registry.yarnpkg.com/sync-request/-/sync-request-6.1.0.tgz#e96217565b5e50bbffe179868ba75532fb597e68"
-  integrity sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw==
-  dependencies:
-    http-response-object "^3.0.1"
-    sync-rpc "^1.2.1"
-    then-request "^6.0.0"
-
-sync-rpc@^1.2.1:
-  version "1.3.6"
-  resolved "https://registry.yarnpkg.com/sync-rpc/-/sync-rpc-1.3.6.tgz#b2e8b2550a12ccbc71df8644810529deb68665a7"
-  integrity sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw==
-  dependencies:
-    get-port "^3.1.0"
-
-taffydb@2.7.3:
-  version "2.7.3"
-  resolved "https://registry.yarnpkg.com/taffydb/-/taffydb-2.7.3.tgz#2ad37169629498fca5bc84243096d3cde0ec3a34"
-  integrity sha1-KtNxaWKUmPylvIQkMJbTzeDsOjQ=
-
-tar-fs@~1.16.3:
-  version "1.16.3"
-  resolved "https://registry.yarnpkg.com/tar-fs/-/tar-fs-1.16.3.tgz#966a628841da2c4010406a82167cbd5e0c72d509"
-  integrity sha512-NvCeXpYx7OsmOh8zIOP/ebG55zZmxLE0etfWRbWok+q2Qo8x/vOR/IJT1taADXPe+jsiu9axDb3X4B+iIgNlKw==
-  dependencies:
-    chownr "^1.0.1"
-    mkdirp "^0.5.1"
-    pump "^1.0.0"
-    tar-stream "^1.1.2"
-
-tar-stream@^1.1.2:
-  version "1.6.2"
-  resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-1.6.2.tgz#8ea55dab37972253d9a9af90fdcd559ae435c555"
-  integrity sha512-rzS0heiNf8Xn7/mpdSVVSMAWAoy9bfb1WOTYC78Z0UQKeKa/CWS8FOq0lKGNa8DWKAn9gxjCvMLYc5PGXYlK2A==
-  dependencies:
-    bl "^1.0.0"
-    buffer-alloc "^1.2.0"
-    end-of-stream "^1.0.0"
-    fs-constants "^1.0.0"
-    readable-stream "^2.3.0"
-    to-buffer "^1.1.1"
-    xtend "^4.0.0"
-
-tar@^4, tar@^4.0.2:
-  version "4.4.19"
-  resolved "https://registry.yarnpkg.com/tar/-/tar-4.4.19.tgz#2e4d7263df26f2b914dee10c825ab132123742f3"
-  integrity sha512-a20gEsvHnWe0ygBY8JbxoM4w3SJdhc7ZAuxkLqh+nvNQN2IOt0B5lLgM490X5Hl8FF0dl0tOf2ewFYAlIFgzVA==
-  dependencies:
-    chownr "^1.1.4"
-    fs-minipass "^1.2.7"
-    minipass "^2.9.0"
-    minizlib "^1.3.3"
-    mkdirp "^0.5.5"
-    safe-buffer "^5.2.1"
-    yallist "^3.1.1"
-
-tar@^6.1.0:
-  version "6.1.11"
-  resolved "https://registry.yarnpkg.com/tar/-/tar-6.1.11.tgz#6760a38f003afa1b2ffd0ffe9e9abbd0eab3d621"
-  integrity sha512-an/KZQzQUkZCkuoAA64hM92X0Urb6VpRhAFllDzz44U2mcD5scmT3zBc4VgVpkugF580+DQn8eAFSyoQt0tznA==
-  dependencies:
-    chownr "^2.0.0"
-    fs-minipass "^2.0.0"
-    minipass "^3.0.0"
-    minizlib "^2.1.1"
-    mkdirp "^1.0.3"
-    yallist "^4.0.0"
-
-then-request@^6.0.0:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/then-request/-/then-request-6.0.2.tgz#ec18dd8b5ca43aaee5cb92f7e4c1630e950d4f0c"
-  integrity sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA==
-  dependencies:
-    "@types/concat-stream" "^1.6.0"
-    "@types/form-data" "0.0.33"
-    "@types/node" "^8.0.0"
-    "@types/qs" "^6.2.31"
-    caseless "~0.12.0"
-    concat-stream "^1.6.0"
-    form-data "^2.2.0"
-    http-basic "^8.1.1"
-    http-response-object "^3.0.1"
-    promise "^8.0.0"
-    qs "^6.4.0"
-
-through2-filter@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/through2-filter/-/through2-filter-2.0.0.tgz#60bc55a0dacb76085db1f9dae99ab43f83d622ec"
-  integrity sha1-YLxVoNrLdghdsfna6Zq0P4PWIuw=
-  dependencies:
-    through2 "~2.0.0"
-    xtend "~4.0.0"
-
-through2-filter@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/through2-filter/-/through2-filter-3.0.0.tgz#700e786df2367c2c88cd8aa5be4cf9c1e7831254"
-  integrity sha512-jaRjI2WxN3W1V8/FMZ9HKIBXixtiqs3SQSX4/YGIiP3gL6djW48VoZq9tDqeCWs3MT8YY5wb/zli8VW8snY1CA==
-  dependencies:
-    through2 "~2.0.0"
-    xtend "~4.0.0"
-
-through2@2.X, through2@^2.0.0, through2@^2.0.3, through2@~2.0.0:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd"
-  integrity sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==
-  dependencies:
-    readable-stream "~2.3.6"
-    xtend "~4.0.1"
-
-through2@3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-3.0.1.tgz#39276e713c3302edf9e388dd9c812dd3b825bd5a"
-  integrity sha512-M96dvTalPT3YbYLaKaCuwu+j06D/8Jfib0o/PxbVt6Amhv3dUAtW6rTV1jPgJSBG83I/e04Y6xkVdVhSRhi0ww==
-  dependencies:
-    readable-stream "2 || 3"
-
-through2@3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-3.0.2.tgz#99f88931cfc761ec7678b41d5d7336b5b6a07bf4"
-  integrity sha512-enaDQ4MUyP2W6ZyT6EsMzqBPZaM/avg8iuo+l2d3QCs0J+6RaqkHV/2/lOwDTueBHeJ/2LG9lrLW3d5rWPucuQ==
-  dependencies:
-    inherits "^2.0.4"
-    readable-stream "2 || 3"
-
-through2@^0.6.0:
-  version "0.6.5"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-0.6.5.tgz#41ab9c67b29d57209071410e1d7a7a968cd3ad48"
-  integrity sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=
-  dependencies:
-    readable-stream ">=1.0.33-1 <1.1.0-0"
-    xtend ">=4.0.0 <4.1.0-0"
-
-"through@>=2.2.7 <3":
-  version "2.3.8"
-  resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
-  integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==
-
-tildify@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/tildify/-/tildify-1.2.0.tgz#dcec03f55dca9b7aa3e5b04f21817eb56e63588a"
-  integrity sha1-3OwD9V3Km3qj5bBPIYF+tW5jWIo=
-  dependencies:
-    os-homedir "^1.0.0"
-
-timed-out@^4.0.0, timed-out@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/timed-out/-/timed-out-4.0.1.tgz#f32eacac5a175bea25d7fab565ab3ed8741ef56f"
-  integrity sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=
-
-timeout-abort-controller@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/timeout-abort-controller/-/timeout-abort-controller-2.0.0.tgz#d6a59209132e520413092dd4b4d71eaaf5887feb"
-  integrity sha512-2FAPXfzTPYEgw27bQGTHc0SzrbmnU2eso4qo172zMLZzaGqeu09PFa5B2FCUHM1tflgRqPgn5KQgp6+Vex4uNA==
-  dependencies:
-    abort-controller "^3.0.0"
-    native-abort-controller "^1.0.4"
-    retimer "^3.0.0"
-
-tiny-queue@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/tiny-queue/-/tiny-queue-0.2.1.tgz#25a67f2c6e253b2ca941977b5ef7442ef97a6046"
-  integrity sha1-JaZ/LG4lOyypQZd7XvdELvl6YEY=
-
-title-case@^2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/title-case/-/title-case-2.1.1.tgz#3e127216da58d2bc5becf137ab91dae3a7cd8faa"
-  integrity sha1-PhJyFtpY0rxb7PE3q5Ha46fNj6o=
-  dependencies:
-    no-case "^2.2.0"
-    upper-case "^1.0.3"
-
-tmp-promise@3.0.3:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/tmp-promise/-/tmp-promise-3.0.3.tgz#60a1a1cc98c988674fcbfd23b6e3367bdeac4ce7"
-  integrity sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==
-  dependencies:
-    tmp "^0.2.0"
-
-tmp@0.0.33:
-  version "0.0.33"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
-  integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==
-  dependencies:
-    os-tmpdir "~1.0.2"
-
-tmp@^0.2.0:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.2.1.tgz#8457fc3037dcf4719c251367a1af6500ee1ccf14"
-  integrity sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==
-  dependencies:
-    rimraf "^3.0.0"
-
-to-absolute-glob@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/to-absolute-glob/-/to-absolute-glob-0.1.1.tgz#1cdfa472a9ef50c239ee66999b662ca0eb39937f"
-  integrity sha1-HN+kcqnvUMI57maZm2YsoOs5k38=
-  dependencies:
-    extend-shallow "^2.0.1"
-
-to-buffer@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/to-buffer/-/to-buffer-1.1.1.tgz#493bd48f62d7c43fcded313a03dcadb2e1213a80"
-  integrity sha512-lx9B5iv7msuFYE3dytT+KE5tap+rNYw+K4jVkb9R/asAb+pbBSM17jtunHplhBe6RRJdZx3Pn2Jph24O32mOVg==
-
-to-fast-properties@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-1.0.3.tgz#b83571fa4d8c25b82e231b06e3a3055de4ca1a47"
-  integrity sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=
-
-to-fast-properties@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
-  integrity sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=
-
-to-readable-stream@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/to-readable-stream/-/to-readable-stream-1.0.0.tgz#ce0aa0c2f3df6adf852efb404a783e77c0475771"
-  integrity sha512-Iq25XBt6zD5npPhlLVXGFN3/gyR2/qODcKNNyTMd4vbm39HUaOiAM4PMq0eMVC/Tkxz+Zjdsc55g9yyz+Yq00Q==
-
-to-regex-range@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
-  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
-  dependencies:
-    is-number "^7.0.0"
-
-toidentifier@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.0.tgz#7e1be3470f1e77948bc43d94a3c8f4d7752ba553"
-  integrity sha512-yaOH/Pk/VEhBWWTlhI+qXxDFXlejDGcQipMlyxda9nthulaxLZUNcUqFxokp0vcYnvteJln5FNQDRrxj3YcbVw==
-
-toidentifier@1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.1.tgz#3be34321a88a820ed1bd80dfaa33e479fbb8dd35"
-  integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==
-
-tough-cookie@^2.2.0, tough-cookie@^2.3.1, tough-cookie@~2.5.0:
-  version "2.5.0"
-  resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.5.0.tgz#cd9fb2a0aa1d5a12b473bd9fb96fa3dcff65ade2"
-  integrity sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==
-  dependencies:
-    psl "^1.1.28"
-    punycode "^2.1.1"
-
-"tough-cookie@^2.3.3 || ^3.0.1 || ^4.0.0":
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-4.0.0.tgz#d822234eeca882f991f0f908824ad2622ddbece4"
-  integrity sha512-tHdtEpQCMrc1YLrMaqXXcj6AxhYi/xgit6mZu1+EDWUn+qhUf8wMQoFIy9NXuq23zAwtcB0t/MjACGR18pcRbg==
-  dependencies:
-    psl "^1.1.33"
-    punycode "^2.1.1"
-    universalify "^0.1.2"
-
-tr46@~0.0.1, tr46@~0.0.3:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a"
-  integrity sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=
-
-trim-right@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/trim-right/-/trim-right-1.0.1.tgz#cb2e1203067e0c8de1f614094b9fe45704ea6003"
-  integrity sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=
-
-truffle@^5.2:
-  version "5.2.3"
-  resolved "https://registry.yarnpkg.com/truffle/-/truffle-5.2.3.tgz#6c1585da56b704397017833ea6b62e18303b924f"
-  integrity sha512-iOeOSaCZtQ+TWsEh6yc6Al+RVkWTsJQnceXNYSCYR86QcXssGY5CqDQ2JwIxwAN4YMRf4GZ/LRAPul6qX36b6A==
-  dependencies:
-    "@truffle/debugger" "^8.0.17"
-    app-module-path "^2.2.0"
-    mocha "8.1.2"
-    original-require "^1.0.1"
-  optionalDependencies:
-    "@truffle/db" "^0.5.3"
-
-ts-invariant@^0.4.0:
-  version "0.4.4"
-  resolved "https://registry.yarnpkg.com/ts-invariant/-/ts-invariant-0.4.4.tgz#97a523518688f93aafad01b0e80eb803eb2abd86"
-  integrity sha512-uEtWkFM/sdZvRNNDL3Ehu4WVpwaulhwQszV8mrtcdeE8nN00BV9mAmQ88RkrBhFgl9gMgvjJLAQcZbnPXI9mlA==
-  dependencies:
-    tslib "^1.9.3"
-
-ts-invariant@^0.6.0:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/ts-invariant/-/ts-invariant-0.6.1.tgz#eb4c52b45daaca8367abbfd6cff998ea871d592d"
-  integrity sha512-QQgN33g8E8yrdDuH29HASveLtbzMnRRgWh0i/JNTW4+zcLsdIOnfsgEDi/NKx4UckQyuMFt9Ujm6TWLWQ58Kvg==
-  dependencies:
-    "@types/ungap__global-this" "^0.3.1"
-    "@ungap/global-this" "^0.4.2"
-    tslib "^1.9.3"
-
-ts-node@^10.9.1:
-  version "10.9.1"
-  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.9.1.tgz#e73de9102958af9e1f0b168a6ff320e25adcff4b"
-  integrity sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==
-  dependencies:
-    "@cspotcode/source-map-support" "^0.8.0"
-    "@tsconfig/node10" "^1.0.7"
-    "@tsconfig/node12" "^1.0.7"
-    "@tsconfig/node14" "^1.0.0"
-    "@tsconfig/node16" "^1.0.2"
-    acorn "^8.4.1"
-    acorn-walk "^8.1.1"
-    arg "^4.1.0"
-    create-require "^1.1.0"
-    diff "^4.0.1"
-    make-error "^1.1.1"
-    v8-compile-cache-lib "^3.0.1"
-    yn "3.1.1"
-
-tslib@^1.10.0, tslib@^1.14.1, tslib@^1.9.3:
-  version "1.14.1"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
-  integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
-
-tslib@^2.0.0, tslib@^2.3.1, tslib@^2.4.0, tslib@^2.5.0:
-  version "2.5.2"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.5.2.tgz#1b6f07185c881557b0ffa84b111a0106989e8338"
-  integrity sha512-5svOrSA2w3iGFDs1HibEVBGbDrAY82bFQ3HZ3ixB+88nsbsWQoKqDRb5UBYAUPEzbBn6dAp5gRNXglySbx1MlA==
-
-tslib@^2.0.3, tslib@~2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
-  integrity sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==
-
-tslib@^2.1.0:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.3.1.tgz#e8a335add5ceae51aa261d32a490158ef042ef01"
-  integrity sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw==
-
-tslib@~2.0.1:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.0.3.tgz#8e0741ac45fc0c226e58a17bfc3e64b9bc6ca61c"
-  integrity sha512-uZtkfKblCEQtZKBF6EBXVZeQNl82yqtDQdv+eck8u7tdPxjLu2/lp5/uPW+um2tpuxINHWy3GhiccY7QgEaVHQ==
-
-tunnel-agent@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
-  integrity sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==
-  dependencies:
-    safe-buffer "^5.0.1"
-
-tweetnacl@^0.14.3, tweetnacl@~0.14.0:
-  version "0.14.5"
-  resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
-  integrity sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==
-
-type-check@~0.3.2:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"
-  integrity sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=
-  dependencies:
-    prelude-ls "~1.1.2"
-
-type-fest@^0.21.3:
-  version "0.21.3"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37"
-  integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==
-
-type-is@^1.6.16, type-is@~1.6.18:
-  version "1.6.18"
-  resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.18.tgz#4e552cd05df09467dcbc4ef739de89f2cf37c131"
-  integrity sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==
-  dependencies:
-    media-typer "0.3.0"
-    mime-types "~2.1.24"
-
-type@^1.0.1:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/type/-/type-1.2.0.tgz#848dd7698dafa3e54a6c479e759c4bc3f18847a0"
-  integrity sha512-+5nt5AAniqsCnu2cEQQdpzCAh33kVx8n0VoFidKpB1dVVLAN/F+bgVOqOJqOnEnrhp222clB5p3vUlD+1QAnfg==
-
-type@^2.0.0:
-  version "2.5.0"
-  resolved "https://registry.yarnpkg.com/type/-/type-2.5.0.tgz#0a2e78c2e77907b252abe5f298c1b01c63f0db3d"
-  integrity sha512-180WMDQaIMm3+7hGXWf12GtdniDEy7nYcyFMKJn/eZz/6tSLXrUN9V0wKSbMjej0I1WHWbpREDEKHtqPQa9NNw==
-
-typedarray-to-buffer@^3.1.5, typedarray-to-buffer@~3.1.5:
-  version "3.1.5"
-  resolved "https://registry.yarnpkg.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz#a97ee7a9ff42691b9f783ff1bc5112fe3fca9080"
-  integrity sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==
-  dependencies:
-    is-typedarray "^1.0.0"
-
-typedarray@^0.0.6, typedarray@~0.0.5:
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
-  integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
-
-typescript-compare@^0.0.2:
-  version "0.0.2"
-  resolved "https://registry.yarnpkg.com/typescript-compare/-/typescript-compare-0.0.2.tgz#7ee40a400a406c2ea0a7e551efd3309021d5f425"
-  integrity sha512-8ja4j7pMHkfLJQO2/8tut7ub+J3Lw2S3061eJLFQcvs3tsmJKp8KG5NtpLn7KcY2w08edF74BSVN7qJS0U6oHA==
-  dependencies:
-    typescript-logic "^0.0.0"
-
-typescript-logic@^0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/typescript-logic/-/typescript-logic-0.0.0.tgz#66ebd82a2548f2b444a43667bec120b496890196"
-  integrity sha512-zXFars5LUkI3zP492ls0VskH3TtdeHCqu0i7/duGt60i5IGPIpAHE/DWo5FqJ6EjQ15YKXrt+AETjv60Dat34Q==
-
-typescript-tuple@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/typescript-tuple/-/typescript-tuple-2.2.1.tgz#7d9813fb4b355f69ac55032e0363e8bb0f04dad2"
-  integrity sha512-Zcr0lbt8z5ZdEzERHAMAniTiIKerFCMgd7yjq1fPnDJ43et/k9twIFQMUYff9k5oXcsQ0WpvFcgzK2ZKASoW6Q==
-  dependencies:
-    typescript-compare "^0.0.2"
-
-ua-parser-js@^0.7.18:
-  version "0.7.24"
-  resolved "https://registry.yarnpkg.com/ua-parser-js/-/ua-parser-js-0.7.24.tgz#8d3ecea46ed4f1f1d63ec25f17d8568105dc027c"
-  integrity sha512-yo+miGzQx5gakzVK3QFfN0/L9uVhosXBBO7qmnk7c2iw1IhL212wfA3zbnI54B0obGwC/5NWub/iT9sReMx+Fw==
-
-uint8arrays@^3.0.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/uint8arrays/-/uint8arrays-3.1.1.tgz#2d8762acce159ccd9936057572dade9459f65ae0"
-  integrity sha512-+QJa8QRnbdXVpHYjLoTpJIdCTiw9Ir62nocClWuXIq2JIh4Uta0cQsTSpFL678p2CN8B+XSApwcU+pQEqVpKWg==
-  dependencies:
-    multiformats "^9.4.2"
-
-ultron@~1.1.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/ultron/-/ultron-1.1.1.tgz#9fe1536a10a664a65266a1e3ccf85fd36302bc9c"
-  integrity sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==
-
-unbox-primitive@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.0.tgz#eeacbc4affa28e9b3d36b5eaeccc50b3251b1d3f"
-  integrity sha512-P/51NX+JXyxK/aigg1/ZgyccdAxm5K1+n8+tvqSntjOivPt19gvm1VC49RWYetsiub8WViUchdxl/KWHHB0kzA==
-  dependencies:
-    function-bind "^1.1.1"
-    has-bigints "^1.0.0"
-    has-symbols "^1.0.0"
-    which-boxed-primitive "^1.0.1"
-
-unbox-primitive@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.1.tgz#085e215625ec3162574dc8859abee78a59b14471"
-  integrity sha512-tZU/3NqK3dA5gpE1KtyiJUrEB0lxnGkMFHptJ7q6ewdZ8s12QrODwNbhIJStmJkd1QDXa1NRA8aF2A1zk/Ypyw==
-  dependencies:
-    function-bind "^1.1.1"
-    has-bigints "^1.0.1"
-    has-symbols "^1.0.2"
-    which-boxed-primitive "^1.0.2"
-
-underscore@1.9.1:
-  version "1.9.1"
-  resolved "https://registry.yarnpkg.com/underscore/-/underscore-1.9.1.tgz#06dce34a0e68a7babc29b365b8e74b8925203961"
-  integrity sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==
-
-underscore@^1.8.3:
-  version "1.12.0"
-  resolved "https://registry.yarnpkg.com/underscore/-/underscore-1.12.0.tgz#4814940551fc80587cef7840d1ebb0f16453be97"
-  integrity sha512-21rQzss/XPMjolTiIezSu3JAjgagXKROtNrYFEOWK109qY1Uv2tVjPTZ1ci2HgvQDA16gHYSthQIJfB+XId/rQ==
-
-unique-stream@^2.0.2:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/unique-stream/-/unique-stream-2.3.1.tgz#c65d110e9a4adf9a6c5948b28053d9a8d04cbeac"
-  integrity sha512-2nY4TnBE70yoxHkDli7DMazpWiP7xMdCYqU2nBRO0UB+ZpEkGsSija7MvmvnZFUeC+mrgiUfcHSr3LmRFIg4+A==
-  dependencies:
-    json-stable-stringify-without-jsonify "^1.0.1"
-    through2-filter "^3.0.0"
-
-unique-string@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unique-string/-/unique-string-1.0.0.tgz#9e1057cca851abb93398f8b33ae187b99caec11a"
-  integrity sha1-nhBXzKhRq7kzmPizOuGHuZyuwRo=
-  dependencies:
-    crypto-random-string "^1.0.0"
-
-universalify@^0.1.0, universalify@^0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66"
-  integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==
-
-universalify@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.0.tgz#75a4984efedc4b08975c5aeb73f530d02df25717"
-  integrity sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==
-
-unixify@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unixify/-/unixify-1.0.0.tgz#3a641c8c2ffbce4da683a5c70f03a462940c2090"
-  integrity sha1-OmQcjC/7zk2mg6XHDwOkYpQMIJA=
-  dependencies:
-    normalize-path "^2.1.1"
-
-unpipe@1.0.0, unpipe@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec"
-  integrity sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==
-
-upper-case-first@^1.1.0, upper-case-first@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/upper-case-first/-/upper-case-first-1.1.2.tgz#5d79bedcff14419518fd2edb0a0507c9b6859115"
-  integrity sha1-XXm+3P8UQZUY/S7bCgUHybaFkRU=
-  dependencies:
-    upper-case "^1.1.1"
-
-upper-case@^1.0.3, upper-case@^1.1.0, upper-case@^1.1.1, upper-case@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/upper-case/-/upper-case-1.1.3.tgz#f6b4501c2ec4cdd26ba78be7222961de77621598"
-  integrity sha1-9rRQHC7EzdJrp4vnIilh3ndiFZg=
-
-uri-js@^4.2.2:
-  version "4.4.1"
-  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
-  integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
-  dependencies:
-    punycode "^2.1.0"
-
-urix@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72"
-  integrity sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=
-
-url-parse-lax@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/url-parse-lax/-/url-parse-lax-1.0.0.tgz#7af8f303645e9bd79a272e7a14ac68bc0609da73"
-  integrity sha1-evjzA2Rem9eaJy56FKxovAYJ2nM=
-  dependencies:
-    prepend-http "^1.0.1"
-
-url-parse-lax@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/url-parse-lax/-/url-parse-lax-3.0.0.tgz#16b5cafc07dbe3676c1b1999177823d6503acb0c"
-  integrity sha1-FrXK/Afb42dsGxmZF3gj1lA6yww=
-  dependencies:
-    prepend-http "^2.0.0"
-
-url-parse@^1.4.3:
-  version "1.5.10"
-  resolved "https://registry.yarnpkg.com/url-parse/-/url-parse-1.5.10.tgz#9d3c2f736c1d75dd3bd2be507dcc111f1e2ea9c1"
-  integrity sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==
-  dependencies:
-    querystringify "^2.1.1"
-    requires-port "^1.0.0"
-
-url-set-query@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/url-set-query/-/url-set-query-1.0.0.tgz#016e8cfd7c20ee05cafe7795e892bd0702faa339"
-  integrity sha1-AW6M/Xwg7gXK/neV6JK9BwL6ozk=
-
-url-to-options@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/url-to-options/-/url-to-options-1.0.1.tgz#1505a03a289a48cbd7a434efbaeec5055f5633a9"
-  integrity sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k=
-
-urlpattern-polyfill@^8.0.0:
-  version "8.0.2"
-  resolved "https://registry.yarnpkg.com/urlpattern-polyfill/-/urlpattern-polyfill-8.0.2.tgz#99f096e35eff8bf4b5a2aa7d58a1523d6ebc7ce5"
-  integrity sha512-Qp95D4TPJl1kC9SKigDcqgyM2VDVO4RiJc2d4qe5GrYm+zbIQCWWKAFaJNQ4BhdFeDGwBmAxqJBwWSJDb9T3BQ==
-
-utf-8-validate@^5.0.2:
-  version "5.0.4"
-  resolved "https://registry.yarnpkg.com/utf-8-validate/-/utf-8-validate-5.0.4.tgz#72a1735983ddf7a05a43a9c6b67c5ce1c910f9b8"
-  integrity sha512-MEF05cPSq3AwJ2C7B7sHAA6i53vONoZbMGX8My5auEVm6W+dJ2Jd/TZPyGJ5CH42V2XtbI5FD28HeHeqlPzZ3Q==
-  dependencies:
-    node-gyp-build "^4.2.0"
-
-utf8@3.0.0, utf8@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/utf8/-/utf8-3.0.0.tgz#f052eed1364d696e769ef058b183df88c87f69d1"
-  integrity sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ==
-
-util-deprecate@^1.0.1, util-deprecate@~1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
-  integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
-
-util.promisify@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/util.promisify/-/util.promisify-1.1.1.tgz#77832f57ced2c9478174149cae9b96e9918cd54b"
-  integrity sha512-/s3UsZUrIfa6xDhr7zZhnE9SLQ5RIXyYfiVnMMyMDzOc8WhWN4Nbh36H842OyurKbCDAesZOJaVyvmSl6fhGQw==
-  dependencies:
-    call-bind "^1.0.0"
-    define-properties "^1.1.3"
-    for-each "^0.3.3"
-    has-symbols "^1.0.1"
-    object.getownpropertydescriptors "^2.1.1"
-
-util@^0.12.0:
-  version "0.12.3"
-  resolved "https://registry.yarnpkg.com/util/-/util-0.12.3.tgz#971bb0292d2cc0c892dab7c6a5d37c2bec707888"
-  integrity sha512-I8XkoQwE+fPQEhy9v012V+TSdH2kp9ts29i20TaaDUXsg7x/onePbhFJUExBfv/2ay1ZOp/Vsm3nDlmnFGSAog==
-  dependencies:
-    inherits "^2.0.3"
-    is-arguments "^1.0.4"
-    is-generator-function "^1.0.7"
-    is-typed-array "^1.1.3"
-    safe-buffer "^5.1.2"
-    which-typed-array "^1.1.2"
-
-utils-merge@1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/utils-merge/-/utils-merge-1.0.1.tgz#9f95710f50a267947b2ccc124741c1028427e713"
-  integrity sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==
-
-uuid@2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-2.0.1.tgz#c2a30dedb3e535d72ccf82e343941a50ba8533ac"
-  integrity sha1-wqMN7bPlNdcsz4LjQ5QaULqFM6w=
-
-uuid@3.2.1:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.2.1.tgz#12c528bb9d58d0b9265d9a2f6f0fe8be17ff1f14"
-  integrity sha512-jZnMwlb9Iku/O3smGWvZhauCf6cvvpKi4BKRiliS3cxnI+Gz9j5MEpTz2UFuXiKPJocb7gnsLHwiS05ige5BEA==
-
-uuid@3.3.2:
-  version "3.3.2"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.3.2.tgz#1b4af4955eb3077c501c23872fc6513811587131"
-  integrity sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==
-
-uuid@8.1.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.1.0.tgz#6f1536eb43249f473abc6bd58ff983da1ca30d8d"
-  integrity sha512-CI18flHDznR0lq54xBycOVmphdCYnQLKn8abKn7PXUiKUGdEd+/l9LWNJmugXel4hXq7S+RMNl34ecyC9TntWg==
-
-uuid@^3.1.0, uuid@^3.3.2:
-  version "3.4.0"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.4.0.tgz#b23e4358afa8a202fe7a100af1f5f883f02007ee"
-  integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==
-
-uuid@^8.0.0, uuid@^8.3.2:
-  version "8.3.2"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz#80d5b5ced271bb9af6c445f21a1a04c606cefbe2"
-  integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==
-
-v8-compile-cache-lib@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf"
-  integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==
-
-vali-date@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/vali-date/-/vali-date-1.0.0.tgz#1b904a59609fb328ef078138420934f6b86709a6"
-  integrity sha1-G5BKWWCfsyjvB4E4Qgk09rhnCaY=
-
-valid-url@1.0.9:
-  version "1.0.9"
-  resolved "https://registry.yarnpkg.com/valid-url/-/valid-url-1.0.9.tgz#1c14479b40f1397a75782f115e4086447433a200"
-  integrity sha1-HBRHm0DxOXp1eC8RXkCGRHQzogA=
-
-validate-npm-package-license@^3.0.1:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
-  integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==
-  dependencies:
-    spdx-correct "^3.0.0"
-    spdx-expression-parse "^3.0.0"
-
-varint@^5.0.0:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/varint/-/varint-5.0.2.tgz#5b47f8a947eb668b848e034dcfa87d0ff8a7f7a4"
-  integrity sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow==
-
-varint@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/varint/-/varint-6.0.0.tgz#9881eb0ce8feaea6512439d19ddf84bf551661d0"
-  integrity sha512-cXEIW6cfr15lFv563k4GuVuW/fiwjknytD37jIOLSdSWuOI6WnO/oKwmP2FQTU2l01LP8/M5TSAJpzUaGe3uWg==
-
-vary@^1, vary@~1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/vary/-/vary-1.1.2.tgz#2299f02c6ded30d4a5961b0b9f74524a18f634fc"
-  integrity sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==
-
-verror@1.10.0:
-  version "1.10.0"
-  resolved "https://registry.yarnpkg.com/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400"
-  integrity sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==
-  dependencies:
-    assert-plus "^1.0.0"
-    core-util-is "1.0.2"
-    extsprintf "^1.2.0"
-
-vinyl-fs@2.4.3:
-  version "2.4.3"
-  resolved "https://registry.yarnpkg.com/vinyl-fs/-/vinyl-fs-2.4.3.tgz#3d97e562ebfdd4b66921dea70626b84bde9d2d07"
-  integrity sha1-PZflYuv91LZpId6nBia4S96dLQc=
-  dependencies:
-    duplexify "^3.2.0"
-    glob-stream "^5.3.2"
-    graceful-fs "^4.0.0"
-    gulp-sourcemaps "^1.5.2"
-    is-valid-glob "^0.3.0"
-    lazystream "^1.0.0"
-    lodash.isequal "^4.0.0"
-    merge-stream "^1.0.0"
-    mkdirp "^0.5.0"
-    object-assign "^4.0.0"
-    readable-stream "^2.0.4"
-    strip-bom "^2.0.0"
-    strip-bom-stream "^1.0.0"
-    through2 "^2.0.0"
-    through2-filter "^2.0.0"
-    vali-date "^1.0.0"
-    vinyl "^1.0.0"
-
-vinyl@1.X, vinyl@^1.0.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/vinyl/-/vinyl-1.2.0.tgz#5c88036cf565e5df05558bfc911f8656df218884"
-  integrity sha1-XIgDbPVl5d8FVYv8kR+GVt8hiIQ=
-  dependencies:
-    clone "^1.0.0"
-    clone-stats "^0.0.1"
-    replace-ext "0.0.1"
-
-vuvuzela@1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/vuvuzela/-/vuvuzela-1.0.3.tgz#3be145e58271c73ca55279dd851f12a682114b0b"
-  integrity sha1-O+FF5YJxxzylUnndhR8SpoIRSws=
-
-wcwidth@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/wcwidth/-/wcwidth-1.0.1.tgz#f0b0dcf915bc5ff1528afadb2c0e17b532da2fe8"
-  integrity sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==
-  dependencies:
-    defaults "^1.0.3"
-
-web-streams-polyfill@^3.2.1:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/web-streams-polyfill/-/web-streams-polyfill-3.2.1.tgz#71c2718c52b45fd49dbeee88634b3a60ceab42a6"
-  integrity sha512-e0MO3wdXWKrLbL0DgGnUV7WHVuw9OUvL4hjgnPkIeEvESk74gAITi5G606JtZPp39cd8HA9VQzCIvA49LpPN5Q==
-
-web3-bzz@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-bzz/-/web3-bzz-1.2.9.tgz#25f8a373bc2dd019f47bf80523546f98b93c8790"
-  integrity sha512-ogVQr9jHodu9HobARtvUSmWG22cv2EUQzlPeejGWZ7j5h20HX40EDuWyomGY5VclIj5DdLY76Tmq88RTf/6nxA==
-  dependencies:
-    "@types/node" "^10.12.18"
-    got "9.6.0"
-    swarm-js "^0.1.40"
-    underscore "1.9.1"
-
-web3-bzz@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-bzz/-/web3-bzz-1.3.4.tgz#9be529353c4063bc68395370cb5d8e414c6b6c87"
-  integrity sha512-DBRVQB8FAgoAtZCpp2GAGPCJjgBgsuwOKEasjV044AAZiONpXcKHbkO6G1SgItIixnrJsRJpoGLGw52Byr6FKw==
-  dependencies:
-    "@types/node" "^12.12.6"
-    got "9.6.0"
-    swarm-js "^0.1.40"
-    underscore "1.9.1"
-
-web3-core-helpers@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-core-helpers/-/web3-core-helpers-1.2.9.tgz#6381077c3e01c127018cb9e9e3d1422697123315"
-  integrity sha512-t0WAG3orLCE3lqi77ZoSRNFok3VQWZXTniZigDQjyOJYMAX7BU3F3js8HKbjVnAxlX3tiKoDxI0KBk9F3AxYuw==
-  dependencies:
-    underscore "1.9.1"
-    web3-eth-iban "1.2.9"
-    web3-utils "1.2.9"
-
-web3-core-helpers@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-core-helpers/-/web3-core-helpers-1.3.4.tgz#b8549740bf24d5c71688d89c3cdd802d8d36b4e4"
-  integrity sha512-n7BqDalcTa1stncHMmrnFtyTgDhX5Fy+avNaHCf6qcOP2lwTQC8+mdHVBONWRJ6Yddvln+c8oY/TAaB6PzWK0A==
-  dependencies:
-    underscore "1.9.1"
-    web3-eth-iban "1.3.4"
-    web3-utils "1.3.4"
-
-web3-core-method@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-core-method/-/web3-core-method-1.2.9.tgz#3fb538751029bea570e4f86731e2fa5e4945e462"
-  integrity sha512-bjsIoqP3gs7A/gP8+QeLUCyOKJ8bopteCSNbCX36Pxk6TYfYWNuC6hP+2GzUuqdP3xaZNe+XEElQFUNpR3oyAg==
-  dependencies:
-    "@ethersproject/transactions" "^5.0.0-beta.135"
-    underscore "1.9.1"
-    web3-core-helpers "1.2.9"
-    web3-core-promievent "1.2.9"
-    web3-core-subscriptions "1.2.9"
-    web3-utils "1.2.9"
-
-web3-core-method@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-core-method/-/web3-core-method-1.3.4.tgz#6c2812d96dd6c811b9e6c8a5d25050d2c22b9527"
-  integrity sha512-JxmQrujsAWYRRN77P/RY7XuZDCzxSiiQJrgX/60Lfyf7FF1Y0le4L/UMCi7vUJnuYkbU1Kfl9E0udnqwyPqlvQ==
-  dependencies:
-    "@ethersproject/transactions" "^5.0.0-beta.135"
-    underscore "1.9.1"
-    web3-core-helpers "1.3.4"
-    web3-core-promievent "1.3.4"
-    web3-core-subscriptions "1.3.4"
-    web3-utils "1.3.4"
-
-web3-core-promievent@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-core-promievent/-/web3-core-promievent-1.2.9.tgz#bb1c56aa6fac2f4b3c598510f06554d25c11c553"
-  integrity sha512-0eAUA2zjgXTleSrnc1wdoKQPPIHU6KHf4fAscu4W9kKrR+mqP1KsjYrxY9wUyjNnXxfQ+5M29ipvbiaK8OqdOw==
-  dependencies:
-    eventemitter3 "3.1.2"
-
-web3-core-promievent@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-core-promievent/-/web3-core-promievent-1.3.4.tgz#d166239012d91496cdcbe91d5d54071ea818bc73"
-  integrity sha512-V61dZIeBwogg6hhZZUt0qL9hTp1WDhnsdjP++9fhTDr4vy/Gz8T5vibqT2LLg6lQC8i+Py33yOpMeMNjztaUaw==
-  dependencies:
-    eventemitter3 "4.0.4"
-
-web3-core-requestmanager@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-core-requestmanager/-/web3-core-requestmanager-1.2.9.tgz#dd6d855256c4dd681434fe0867f8cd742fe10503"
-  integrity sha512-1PwKV2m46ALUnIN5VPPgjOj8yMLJhhqZYvYJE34hTN5SErOkwhzx5zScvo5MN7v7KyQGFnpVCZKKGCiEnDmtFA==
-  dependencies:
-    underscore "1.9.1"
-    web3-core-helpers "1.2.9"
-    web3-providers-http "1.2.9"
-    web3-providers-ipc "1.2.9"
-    web3-providers-ws "1.2.9"
-
-web3-core-requestmanager@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-core-requestmanager/-/web3-core-requestmanager-1.3.4.tgz#e105ced735c2b5fcedd5771e0ecf9879ae9c373f"
-  integrity sha512-xriouCrhVnVDYQ04TZXdEREZm0OOJzkSEsoN5bu4JYsA6e/HzROeU+RjDpMUxFMzN4wxmFZ+HWbpPndS3QwMag==
-  dependencies:
-    underscore "1.9.1"
-    util "^0.12.0"
-    web3-core-helpers "1.3.4"
-    web3-providers-http "1.3.4"
-    web3-providers-ipc "1.3.4"
-    web3-providers-ws "1.3.4"
-
-web3-core-subscriptions@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-core-subscriptions/-/web3-core-subscriptions-1.2.9.tgz#335fd7d15dfce5d78b4b7bef05ce4b3d7237b0e4"
-  integrity sha512-Y48TvXPSPxEM33OmXjGVDMzTd0j8X0t2+sDw66haeBS8eYnrEzasWuBZZXDq0zNUsqyxItgBGDn+cszkgEnFqg==
-  dependencies:
-    eventemitter3 "3.1.2"
-    underscore "1.9.1"
-    web3-core-helpers "1.2.9"
-
-web3-core-subscriptions@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-core-subscriptions/-/web3-core-subscriptions-1.3.4.tgz#7b00e92bde21f792620cd02e6e508fcf4f4c31d3"
-  integrity sha512-drVHVDxh54hv7xmjIm44g4IXjfGj022fGw4/meB5R2D8UATFI40F73CdiBlyqk3DysP9njDOLTJFSQvEkLFUOg==
-  dependencies:
-    eventemitter3 "4.0.4"
-    underscore "1.9.1"
-    web3-core-helpers "1.3.4"
-
-web3-core@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-core/-/web3-core-1.2.9.tgz#2cba57aa259b6409db532d21bdf57db8d504fd3e"
-  integrity sha512-fSYv21IP658Ty2wAuU9iqmW7V+75DOYMVZsDH/c14jcF/1VXnedOcxzxSj3vArsCvXZNe6XC5/wAuGZyQwR9RA==
-  dependencies:
-    "@types/bn.js" "^4.11.4"
-    "@types/node" "^12.6.1"
-    bignumber.js "^9.0.0"
-    web3-core-helpers "1.2.9"
-    web3-core-method "1.2.9"
-    web3-core-requestmanager "1.2.9"
-    web3-utils "1.2.9"
-
-web3-core@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-core/-/web3-core-1.3.4.tgz#2cc7ba7f35cc167f7a0a46fd5855f86e51d34ce8"
-  integrity sha512-7OJu46RpCEfTerl+gPvHXANR2RkLqAfW7l2DAvQ7wN0pnCzl9nEfdgW6tMhr31k3TR2fWucwKzCyyxMGzMHeSA==
-  dependencies:
-    "@types/bn.js" "^4.11.5"
-    "@types/node" "^12.12.6"
-    bignumber.js "^9.0.0"
-    web3-core-helpers "1.3.4"
-    web3-core-method "1.3.4"
-    web3-core-requestmanager "1.3.4"
-    web3-utils "1.3.4"
-
-web3-eth-abi@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-eth-abi/-/web3-eth-abi-1.2.9.tgz#14bedd7e4be04fcca35b2ac84af1400574cd8280"
-  integrity sha512-3YwUYbh/DMfDbhMWEebAdjSd5bj3ZQieOjLzWFHU23CaLEqT34sUix1lba+hgUH/EN6A7bKAuKOhR3p0OvTn7Q==
-  dependencies:
-    "@ethersproject/abi" "5.0.0-beta.153"
-    underscore "1.9.1"
-    web3-utils "1.2.9"
-
-web3-eth-abi@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-eth-abi/-/web3-eth-abi-1.3.4.tgz#10f5d8b6080dbb6cbaa1bcef7e0c70573da6566f"
-  integrity sha512-PVSLXJ2dzdXsC+R24llIIEOS6S1KhG5qwNznJjJvXZFe3sqgdSe47eNvwUamZtCBjcrdR/HQr+L/FTxqJSf80Q==
-  dependencies:
-    "@ethersproject/abi" "5.0.7"
-    underscore "1.9.1"
-    web3-utils "1.3.4"
-
-web3-eth-abi@1.7.0:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/web3-eth-abi/-/web3-eth-abi-1.7.0.tgz#4fac9c7d9e5a62b57f8884b37371f515c766f3f4"
-  integrity sha512-heqR0bWxgCJwjWIhq2sGyNj9bwun5+Xox/LdZKe+WMyTSy0cXDXEAgv3XKNkXC4JqdDt/ZlbTEx4TWak4TRMSg==
-  dependencies:
-    "@ethersproject/abi" "5.0.7"
-    web3-utils "1.7.0"
-
-web3-eth-accounts@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-eth-accounts/-/web3-eth-accounts-1.2.9.tgz#7ec422df90fecb5243603ea49dc28726db7bdab6"
-  integrity sha512-jkbDCZoA1qv53mFcRHCinoCsgg8WH+M0YUO1awxmqWXRmCRws1wW0TsuSQ14UThih5Dxolgl+e+aGWxG58LMwg==
-  dependencies:
-    crypto-browserify "3.12.0"
-    eth-lib "^0.2.8"
-    ethereumjs-common "^1.3.2"
-    ethereumjs-tx "^2.1.1"
-    scrypt-js "^3.0.1"
-    underscore "1.9.1"
-    uuid "3.3.2"
-    web3-core "1.2.9"
-    web3-core-helpers "1.2.9"
-    web3-core-method "1.2.9"
-    web3-utils "1.2.9"
-
-web3-eth-accounts@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-eth-accounts/-/web3-eth-accounts-1.3.4.tgz#cf513d78531c13ce079a5e7862820570350e79a5"
-  integrity sha512-gz9ReSmQEjqbYAjpmAx+UZF4CVMbyS4pfjSYWGAnNNI+Xz0f0u0kCIYXQ1UEaE+YeLcYiE+ZlZdgg6YoatO5nA==
-  dependencies:
-    crypto-browserify "3.12.0"
-    eth-lib "0.2.8"
-    ethereumjs-common "^1.3.2"
-    ethereumjs-tx "^2.1.1"
-    scrypt-js "^3.0.1"
-    underscore "1.9.1"
-    uuid "3.3.2"
-    web3-core "1.3.4"
-    web3-core-helpers "1.3.4"
-    web3-core-method "1.3.4"
-    web3-utils "1.3.4"
-
-web3-eth-contract@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-eth-contract/-/web3-eth-contract-1.2.9.tgz#713d9c6d502d8c8f22b696b7ffd8e254444e6bfd"
-  integrity sha512-PYMvJf7EG/HyssUZa+pXrc8IB06K/YFfWYyW4R7ed3sab+9wWUys1TlWxBCBuiBXOokSAyM6H6P6/cKEx8FT8Q==
-  dependencies:
-    "@types/bn.js" "^4.11.4"
-    underscore "1.9.1"
-    web3-core "1.2.9"
-    web3-core-helpers "1.2.9"
-    web3-core-method "1.2.9"
-    web3-core-promievent "1.2.9"
-    web3-core-subscriptions "1.2.9"
-    web3-eth-abi "1.2.9"
-    web3-utils "1.2.9"
-
-web3-eth-contract@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-eth-contract/-/web3-eth-contract-1.3.4.tgz#1ea2dd71be0c4a9cf4772d4f75dbb2fa99751472"
-  integrity sha512-Fvy8ZxUksQY2ePt+XynFfOiSqxgQtMn4m2NJs6VXRl2Inl17qyRi/nIJJVKTcENLocm+GmZ/mxq2eOE5u02nPg==
-  dependencies:
-    "@types/bn.js" "^4.11.5"
-    underscore "1.9.1"
-    web3-core "1.3.4"
-    web3-core-helpers "1.3.4"
-    web3-core-method "1.3.4"
-    web3-core-promievent "1.3.4"
-    web3-core-subscriptions "1.3.4"
-    web3-eth-abi "1.3.4"
-    web3-utils "1.3.4"
-
-web3-eth-ens@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-eth-ens/-/web3-eth-ens-1.2.9.tgz#577b9358c036337833fb2bdc59c11be7f6f731b6"
-  integrity sha512-kG4+ZRgZ8I1WYyOBGI8QVRHfUSbbJjvJAGA1AF/NOW7JXQ+x7gBGeJw6taDWJhSshMoEKWcsgvsiuoG4870YxQ==
-  dependencies:
-    content-hash "^2.5.2"
-    eth-ens-namehash "2.0.8"
-    underscore "1.9.1"
-    web3-core "1.2.9"
-    web3-core-helpers "1.2.9"
-    web3-core-promievent "1.2.9"
-    web3-eth-abi "1.2.9"
-    web3-eth-contract "1.2.9"
-    web3-utils "1.2.9"
-
-web3-eth-ens@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-eth-ens/-/web3-eth-ens-1.3.4.tgz#a7e4bb18481fb0e2ce5bfb3b3da2fbb0ad78cefe"
-  integrity sha512-b0580tQyQwpV2wyacwQiBEfQmjCUln5iPhge3IBIMXaI43BUNtH3lsCL9ERFQeOdweB4o+6rYyNYr6xbRcSytg==
-  dependencies:
-    content-hash "^2.5.2"
-    eth-ens-namehash "2.0.8"
-    underscore "1.9.1"
-    web3-core "1.3.4"
-    web3-core-helpers "1.3.4"
-    web3-core-promievent "1.3.4"
-    web3-eth-abi "1.3.4"
-    web3-eth-contract "1.3.4"
-    web3-utils "1.3.4"
-
-web3-eth-iban@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-eth-iban/-/web3-eth-iban-1.2.9.tgz#4ebf3d8783f34d04c4740dc18938556466399f7a"
-  integrity sha512-RtdVvJE0pyg9dHLy0GzDiqgnLnssSzfz/JYguhC1wsj9+Gnq1M6Diy3NixACWUAp6ty/zafyOaZnNQ+JuH9TjQ==
-  dependencies:
-    bn.js "4.11.8"
-    web3-utils "1.2.9"
-
-web3-eth-iban@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-eth-iban/-/web3-eth-iban-1.3.4.tgz#5eb7a564e0dcf68730d68f48f95dd207cd173d81"
-  integrity sha512-Y7/hLjVvIN/OhaAyZ8L/hxbTqVX6AFTl2RwUXR6EEU9oaLydPcMjAx/Fr8mghUvQS3QJSr+UGubP3W4SkyNiYw==
-  dependencies:
-    bn.js "^4.11.9"
-    web3-utils "1.3.4"
-
-web3-eth-personal@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-eth-personal/-/web3-eth-personal-1.2.9.tgz#9b95eb159b950b83cd8ae15873e1d57711b7a368"
-  integrity sha512-cFiNrktxZ1C/rIdJFzQTvFn3/0zcsR3a+Jf8Y3KxeQDHszQtosjLWptP7bsUmDwEh4hzh0Cy3KpOxlYBWB8bJQ==
-  dependencies:
-    "@types/node" "^12.6.1"
-    web3-core "1.2.9"
-    web3-core-helpers "1.2.9"
-    web3-core-method "1.2.9"
-    web3-net "1.2.9"
-    web3-utils "1.2.9"
-
-web3-eth-personal@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-eth-personal/-/web3-eth-personal-1.3.4.tgz#0d0e0abea3447283d7ee5658ed312990c9bf48dd"
-  integrity sha512-JiTbaktYVk1j+S2EDooXAhw5j/VsdvZfKRmHtXUe/HizPM9ETXmj1+ne4RT6m+950jQ7DJwUF3XU1FKYNtEDwQ==
-  dependencies:
-    "@types/node" "^12.12.6"
-    web3-core "1.3.4"
-    web3-core-helpers "1.3.4"
-    web3-core-method "1.3.4"
-    web3-net "1.3.4"
-    web3-utils "1.3.4"
-
-web3-eth@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-eth/-/web3-eth-1.2.9.tgz#e40e7b88baffc9b487193211c8b424dc944977b3"
-  integrity sha512-sIKO4iE9FEBa/CYUd6GdPd7GXt/wISqxUd8PlIld6+hvMJj02lgO7Z7p5T9mZIJcIZJGvZX81ogx8oJ9yif+Ag==
-  dependencies:
-    underscore "1.9.1"
-    web3-core "1.2.9"
-    web3-core-helpers "1.2.9"
-    web3-core-method "1.2.9"
-    web3-core-subscriptions "1.2.9"
-    web3-eth-abi "1.2.9"
-    web3-eth-accounts "1.2.9"
-    web3-eth-contract "1.2.9"
-    web3-eth-ens "1.2.9"
-    web3-eth-iban "1.2.9"
-    web3-eth-personal "1.2.9"
-    web3-net "1.2.9"
-    web3-utils "1.2.9"
-
-web3-eth@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-eth/-/web3-eth-1.3.4.tgz#7c4607685e66a1c43e3e315e526c959f24f96907"
-  integrity sha512-8OIVMLbvmx+LB5RZ4tDhXuFGWSdNMrCZ4HM0+PywQ08uEcmAcqTMFAn4vdPii+J8gCatZR501r1KdzX3SDLoPw==
-  dependencies:
-    underscore "1.9.1"
-    web3-core "1.3.4"
-    web3-core-helpers "1.3.4"
-    web3-core-method "1.3.4"
-    web3-core-subscriptions "1.3.4"
-    web3-eth-abi "1.3.4"
-    web3-eth-accounts "1.3.4"
-    web3-eth-contract "1.3.4"
-    web3-eth-ens "1.3.4"
-    web3-eth-iban "1.3.4"
-    web3-eth-personal "1.3.4"
-    web3-net "1.3.4"
-    web3-utils "1.3.4"
-
-web3-net@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-net/-/web3-net-1.2.9.tgz#51d248ed1bc5c37713c4ac40c0073d9beacd87d3"
-  integrity sha512-d2mTn8jPlg+SI2hTj2b32Qan6DmtU9ap/IUlJTeQbZQSkTLf0u9suW8Vjwyr4poJYXTurdSshE7OZsPNn30/ZA==
-  dependencies:
-    web3-core "1.2.9"
-    web3-core-method "1.2.9"
-    web3-utils "1.2.9"
-
-web3-net@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-net/-/web3-net-1.3.4.tgz#d76158bf0b4a7b3b14352b4f95472db9efc57a2a"
-  integrity sha512-wVyqgVC3Zt/0uGnBiR3GpnsS8lvOFTDgWZMxAk9C6Guh8aJD9MUc7pbsw5rHrPUVe6S6RUfFJvh/Xq8oMIQgSw==
-  dependencies:
-    web3-core "1.3.4"
-    web3-core-method "1.3.4"
-    web3-utils "1.3.4"
-
-web3-providers-http@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-providers-http/-/web3-providers-http-1.2.9.tgz#e698aa5377e2019c24c5a1e6efa0f51018728934"
-  integrity sha512-F956tCIj60Ttr0UvEHWFIhx+be3He8msoPzyA44/kfzzYoMAsCFRn5cf0zQG6al0znE75g6HlWVSN6s3yAh51A==
-  dependencies:
-    web3-core-helpers "1.2.9"
-    xhr2-cookies "1.1.0"
-
-web3-providers-http@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-providers-http/-/web3-providers-http-1.3.4.tgz#89389e18e27148faa2fef58842740ffadbdda8cc"
-  integrity sha512-aIg/xHXvxpqpFU70sqfp+JC3sGkLfAimRKTUhG4oJZ7U+tTcYTHoxBJj+4A3Id4JAoKiiv0k1/qeyQ8f3rMC3g==
-  dependencies:
-    web3-core-helpers "1.3.4"
-    xhr2-cookies "1.1.0"
-
-web3-providers-ipc@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-providers-ipc/-/web3-providers-ipc-1.2.9.tgz#6159eacfcd7ac31edc470d93ef10814fe874763b"
-  integrity sha512-NQ8QnBleoHA2qTJlqoWu7EJAD/FR5uimf7Ielzk4Z2z+m+6UAuJdJMSuQNj+Umhz9L/Ys6vpS1vHx9NizFl+aQ==
-  dependencies:
-    oboe "2.1.4"
-    underscore "1.9.1"
-    web3-core-helpers "1.2.9"
-
-web3-providers-ipc@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-providers-ipc/-/web3-providers-ipc-1.3.4.tgz#b963518989b1b7847063cdd461ff73b83855834a"
-  integrity sha512-E0CvXEJElr/TIlG1YfJeO3Le5NI/4JZM+1SsEdiPIfBUAJN18oOoum138EBGKv5+YaLKZUtUuJSXWjIIOR/0Ig==
-  dependencies:
-    oboe "2.1.5"
-    underscore "1.9.1"
-    web3-core-helpers "1.3.4"
-
-web3-providers-ws@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-providers-ws/-/web3-providers-ws-1.2.9.tgz#22c2006655ec44b4ad2b41acae62741a6ae7a88c"
-  integrity sha512-6+UpvINeI//dglZoAKStUXqxDOXJy6Iitv2z3dbgInG4zb8tkYl/VBDL80UjUg3ZvzWG0g7EKY2nRPEpON2TFA==
-  dependencies:
-    eventemitter3 "^4.0.0"
-    underscore "1.9.1"
-    web3-core-helpers "1.2.9"
-    websocket "^1.0.31"
-
-web3-providers-ws@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-providers-ws/-/web3-providers-ws-1.3.4.tgz#b94c2e0ec51a0c472abdec53a472b5bf8176bec1"
-  integrity sha512-WBd9hk2fUAdrbA3kUyUk94ZeILtE6txLeoVVvIKAw2bPegx+RjkLyxC1Du0oceKgQ/qQWod8CCzl1E/GgTP+MQ==
-  dependencies:
-    eventemitter3 "4.0.4"
-    underscore "1.9.1"
-    web3-core-helpers "1.3.4"
-    websocket "^1.0.32"
-
-web3-shh@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-shh/-/web3-shh-1.2.9.tgz#c4ba70d6142cfd61341a50752d8cace9a0370911"
-  integrity sha512-PWa8b/EaxaMinFaxy6cV0i0EOi2M7a/ST+9k9nhyhCjVa2vzXuNoBNo2IUOmeZ0WP2UQB8ByJ2+p4htlJaDOjA==
-  dependencies:
-    web3-core "1.2.9"
-    web3-core-method "1.2.9"
-    web3-core-subscriptions "1.2.9"
-    web3-net "1.2.9"
-
-web3-shh@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-shh/-/web3-shh-1.3.4.tgz#b7d29e118f26416c1a74575e585be379cc01a77a"
-  integrity sha512-zoeww5mxLh3xKcqbX85irQbtFe5pc5XwrgjvmdMkhkOdZzPASlWOgqzUFtaPykpLwC3yavVx4jG5RqifweXLUA==
-  dependencies:
-    web3-core "1.3.4"
-    web3-core-method "1.3.4"
-    web3-core-subscriptions "1.3.4"
-    web3-net "1.3.4"
-
-web3-utils@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3-utils/-/web3-utils-1.2.9.tgz#abe11735221627da943971ef1a630868fb9c61f3"
-  integrity sha512-9hcpuis3n/LxFzEVjwnVgvJzTirS2S9/MiNAa7l4WOEoywY+BSNwnRX4MuHnjkh9NY25B6QOjuNG6FNnSjTw1w==
-  dependencies:
-    bn.js "4.11.8"
-    eth-lib "0.2.7"
-    ethereum-bloom-filters "^1.0.6"
-    ethjs-unit "0.1.6"
-    number-to-bn "1.7.0"
-    randombytes "^2.1.0"
-    underscore "1.9.1"
-    utf8 "3.0.0"
-
-web3-utils@1.3.4:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3-utils/-/web3-utils-1.3.4.tgz#9b1aa30d7549f860b573e7bb7e690999e7192198"
-  integrity sha512-/vC2v0MaZNpWooJfpRw63u0Y3ag2gNjAWiLtMSL6QQLmCqCy4SQIndMt/vRyx0uMoeGt1YTwSXEcHjUzOhLg0A==
-  dependencies:
-    bn.js "^4.11.9"
-    eth-lib "0.2.8"
-    ethereum-bloom-filters "^1.0.6"
-    ethjs-unit "0.1.6"
-    number-to-bn "1.7.0"
-    randombytes "^2.1.0"
-    underscore "1.9.1"
-    utf8 "3.0.0"
-
-web3-utils@1.7.0:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/web3-utils/-/web3-utils-1.7.0.tgz#c59f0fd43b2449357296eb54541810b99b1c771c"
-  integrity sha512-O8Tl4Ky40Sp6pe89Olk2FsaUkgHyb5QAXuaKo38ms3CxZZ4d3rPGfjP9DNKGm5+IUgAZBNpF1VmlSmNCqfDI1w==
-  dependencies:
-    bn.js "^4.11.9"
-    ethereum-bloom-filters "^1.0.6"
-    ethereumjs-util "^7.1.0"
-    ethjs-unit "0.1.6"
-    number-to-bn "1.7.0"
-    randombytes "^2.1.0"
-    utf8 "3.0.0"
-
-web3@1.2.9:
-  version "1.2.9"
-  resolved "https://registry.yarnpkg.com/web3/-/web3-1.2.9.tgz#cbcf1c0fba5e213a6dfb1f2c1f4b37062e4ce337"
-  integrity sha512-Mo5aBRm0JrcNpN/g4VOrDzudymfOnHRC3s2VarhYxRA8aWgF5rnhQ0ziySaugpic1gksbXPe105pUWyRqw8HUA==
-  dependencies:
-    web3-bzz "1.2.9"
-    web3-core "1.2.9"
-    web3-eth "1.2.9"
-    web3-eth-personal "1.2.9"
-    web3-net "1.2.9"
-    web3-shh "1.2.9"
-    web3-utils "1.2.9"
-
-web3@^1.0.0-beta.34:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/web3/-/web3-1.3.4.tgz#31e014873360aa5840eb17f9f171190c967cffb7"
-  integrity sha512-D6cMb2EtTMLHgdGbkTPGl/Qi7DAfczR+Lp7iFX3bcu/bsD9V8fZW69hA8v5cRPNGzXUwVQebk3bS17WKR4cD2w==
-  dependencies:
-    web3-bzz "1.3.4"
-    web3-core "1.3.4"
-    web3-eth "1.3.4"
-    web3-eth-personal "1.3.4"
-    web3-net "1.3.4"
-    web3-shh "1.3.4"
-    web3-utils "1.3.4"
-
-webcrypto-core@^1.7.7:
-  version "1.7.7"
-  resolved "https://registry.yarnpkg.com/webcrypto-core/-/webcrypto-core-1.7.7.tgz#06f24b3498463e570fed64d7cab149e5437b162c"
-  integrity sha512-7FjigXNsBfopEj+5DV2nhNpfic2vumtjjgPmeDKk45z+MJwXKKfhPB7118Pfzrmh4jqOMST6Ch37iPAHoImg5g==
-  dependencies:
-    "@peculiar/asn1-schema" "^2.3.6"
-    "@peculiar/json-schema" "^1.1.12"
-    asn1js "^3.0.1"
-    pvtsutils "^1.3.2"
-    tslib "^2.4.0"
-
-webidl-conversions@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-2.0.1.tgz#3bf8258f7d318c7443c36f2e169402a1a6703506"
-  integrity sha1-O/glj30xjHRDw28uFpQCoaZwNQY=
-
-webidl-conversions@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871"
-  integrity sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE=
-
-websocket@^1.0.31, websocket@^1.0.32:
-  version "1.0.33"
-  resolved "https://registry.yarnpkg.com/websocket/-/websocket-1.0.33.tgz#407f763fc58e74a3fa41ca3ae5d78d3f5e3b82a5"
-  integrity sha512-XwNqM2rN5eh3G2CUQE3OHZj+0xfdH42+OFK6LdC2yqiC0YU8e5UK0nYre220T0IyyN031V/XOvtHvXozvJYFWA==
-  dependencies:
-    bufferutil "^4.0.1"
-    debug "^2.2.0"
-    es5-ext "^0.10.50"
-    typedarray-to-buffer "^3.1.5"
-    utf-8-validate "^5.0.2"
-    yaeti "^0.0.6"
-
-websql@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/websql/-/websql-1.0.0.tgz#1bd00b27392893134715d5dd6941fd89e730bab5"
-  integrity sha512-7iZ+u28Ljw5hCnMiq0BCOeSYf0vCFQe/ORY0HgscTiKjQed8WqugpBUggJ2NTnB9fahn1kEnPRX2jf8Px5PhJw==
-  dependencies:
-    argsarray "^0.0.1"
-    immediate "^3.2.2"
-    noop-fn "^1.0.0"
-    sqlite3 "^4.0.0"
-    tiny-queue "^0.2.1"
-
-whatwg-fetch@2.0.3:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/whatwg-fetch/-/whatwg-fetch-2.0.3.tgz#9c84ec2dcf68187ff00bc64e1274b442176e1c84"
-  integrity sha1-nITsLc9oGH/wC8ZOEnS0QhduHIQ=
-
-whatwg-fetch@2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/whatwg-fetch/-/whatwg-fetch-2.0.4.tgz#dde6a5df315f9d39991aa17621853d720b85566f"
-  integrity sha512-dcQ1GWpOD/eEQ97k66aiEVpNnapVj90/+R+SXTPYGHpYBBypfKJEQjLrvMZ7YXbKm21gXd4NcuxUTjiv1YtLng==
-
-whatwg-url-compat@~0.6.5:
-  version "0.6.5"
-  resolved "https://registry.yarnpkg.com/whatwg-url-compat/-/whatwg-url-compat-0.6.5.tgz#00898111af689bb097541cd5a45ca6c8798445bf"
-  integrity sha1-AImBEa9om7CXVBzVpFymyHmERb8=
-  dependencies:
-    tr46 "~0.0.1"
-
-whatwg-url@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d"
-  integrity sha1-lmRU6HZUYuN2RNNib2dCzotwll0=
-  dependencies:
-    tr46 "~0.0.3"
-    webidl-conversions "^3.0.0"
-
-which-boxed-primitive@^1.0.1, which-boxed-primitive@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz#13757bc89b209b049fe5d86430e21cf40a89a8e6"
-  integrity sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==
-  dependencies:
-    is-bigint "^1.0.1"
-    is-boolean-object "^1.1.0"
-    is-number-object "^1.0.4"
-    is-string "^1.0.5"
-    is-symbol "^1.0.3"
-
-which-module@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/which-module/-/which-module-2.0.0.tgz#d9ef07dce77b9902b8a3a8fa4b31c3e3f7e6e87a"
-  integrity sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=
-
-which-typed-array@^1.1.2:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.4.tgz#8fcb7d3ee5adf2d771066fba7cf37e32fe8711ff"
-  integrity sha512-49E0SpUe90cjpoc7BOJwyPHRqSAd12c10Qm2amdEZrJPCY2NDxaW01zHITrem+rnETY3dwrbH3UUrUwagfCYDA==
-  dependencies:
-    available-typed-arrays "^1.0.2"
-    call-bind "^1.0.0"
-    es-abstract "^1.18.0-next.1"
-    foreach "^2.0.5"
-    function-bind "^1.1.1"
-    has-symbols "^1.0.1"
-    is-typed-array "^1.1.3"
-
-which@2.0.2, which@^2.0.0, which@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
-  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
-  dependencies:
-    isexe "^2.0.0"
-
-which@^1.2.9:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
-  integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
-  dependencies:
-    isexe "^2.0.0"
-
-wide-align@1.1.3, wide-align@^1.1.0:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/wide-align/-/wide-align-1.1.3.tgz#ae074e6bdc0c14a431e804e624549c633b000457"
-  integrity sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==
-  dependencies:
-    string-width "^1.0.2 || 2"
-
-widest-line@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/widest-line/-/widest-line-3.1.0.tgz#8292333bbf66cb45ff0de1603b136b7ae1496eca"
-  integrity sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==
-  dependencies:
-    string-width "^4.0.0"
-
-window-size@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/window-size/-/window-size-0.2.0.tgz#b4315bb4214a3d7058ebeee892e13fa24d98b075"
-  integrity sha1-tDFbtCFKPXBY6+7okuE/ok2YsHU=
-
-word-wrap@~1.2.3:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c"
-  integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==
-
-wordwrap@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"
-  integrity sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==
-
-workerpool@6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.0.0.tgz#85aad67fa1a2c8ef9386a1b43539900f61d03d58"
-  integrity sha512-fU2OcNA/GVAJLLyKUoHkAgIhKb0JoCpSjLC/G2vYKxUjVmQwGbRVeoPJ1a8U4pnVofz4AQV5Y/NEw8oKqxEBtA==
-
-wrap-ansi@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-2.1.0.tgz#d8fc3d284dd05794fe84973caecdd1cf824fdd85"
-  integrity sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=
-  dependencies:
-    string-width "^1.0.1"
-    strip-ansi "^3.0.1"
-
-wrap-ansi@^5.1.0:
-  version "5.1.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-5.1.0.tgz#1fd1f67235d5b6d0fee781056001bfb694c03b09"
-  integrity sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==
-  dependencies:
-    ansi-styles "^3.2.0"
-    string-width "^3.0.0"
-    strip-ansi "^5.0.0"
-
-wrap-ansi@^6.2.0:
-  version "6.2.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53"
-  integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==
-  dependencies:
-    ansi-styles "^4.0.0"
-    string-width "^4.1.0"
-    strip-ansi "^6.0.0"
-
-wrap-ansi@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
-  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
-  dependencies:
-    ansi-styles "^4.0.0"
-    string-width "^4.1.0"
-    strip-ansi "^6.0.0"
-
-wrappy@1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
-  integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
-
-write-file-atomic@^2.0.0:
-  version "2.4.3"
-  resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-2.4.3.tgz#1fd2e9ae1df3e75b8d8c367443c692d4ca81f481"
-  integrity sha512-GaETH5wwsX+GcnzhPgKcKjJ6M2Cq3/iZp1WyY/X1CSqrW+jVNM9Y7D8EC2sM4ZG/V8wZlSniJnCKWPmBYAucRQ==
-  dependencies:
-    graceful-fs "^4.1.11"
-    imurmurhash "^0.1.4"
-    signal-exit "^3.0.2"
-
-write-stream@~0.4.3:
-  version "0.4.3"
-  resolved "https://registry.yarnpkg.com/write-stream/-/write-stream-0.4.3.tgz#83cc8c0347d0af6057a93862b4e3ae01de5c81c1"
-  integrity sha1-g8yMA0fQr2BXqThitOOuAd5cgcE=
-  dependencies:
-    readable-stream "~0.0.2"
-
-ws@7.1.0:
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-7.1.0.tgz#0395646c6fcc3ac56abf61ce1a42039637a6bd98"
-  integrity sha512-Swie2C4fs7CkwlHu1glMePLYJJsWjzhl1vm3ZaLplD0h7OMkZyZ6kLTB/OagiU923bZrPFXuDTeEqaEN4NWG4g==
-  dependencies:
-    async-limiter "^1.0.0"
-
-ws@7.4.3:
-  version "7.4.3"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.3.tgz#1f9643de34a543b8edb124bdcbc457ae55a6e5cd"
-  integrity sha512-hr6vCR76GsossIRsr8OLR9acVVm1jyfEWvhbNjtgPOrfvAlKzvyeg/P6r8RuDjRyrcQoPQT7K0DGEPc7Ae6jzA==
-
-ws@^3.0.0:
-  version "3.3.3"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-3.3.3.tgz#f1cf84fe2d5e901ebce94efaece785f187a228f2"
-  integrity sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==
-  dependencies:
-    async-limiter "~1.0.0"
-    safe-buffer "~5.1.0"
-    ultron "~1.1.0"
-
-ws@^5.1.1:
-  version "5.2.2"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-5.2.2.tgz#dffef14866b8e8dc9133582514d1befaf96e980f"
-  integrity sha512-jaHFD6PFv6UgoIVda6qZllptQsMlDEJkTQcybzzXDYM1XO9Y8em691FGMPmM46WGyLU4z9KMgQN+qrux/nhlHA==
-  dependencies:
-    async-limiter "~1.0.0"
-
-"ws@^5.2.0 || ^6.0.0 || ^7.0.0":
-  version "7.5.5"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.5.tgz#8b4bc4af518cfabd0473ae4f99144287b33eb881"
-  integrity sha512-BAkMFcAzl8as1G/hArkxOxq3G7pjUqQ3gzYbLL0/5zNkph70e+lCoxBGnm6AW1+/aiNeV4fnKqZ8m4GZewmH2w==
-
-ws@^7.4.5:
-  version "7.5.9"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.9.tgz#54fa7db29f4c7cec68b1ddd3a89de099942bb591"
-  integrity sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==
-
-xdg-basedir@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/xdg-basedir/-/xdg-basedir-3.0.0.tgz#496b2cc109eca8dbacfe2dc72b603c17c5870ad4"
-  integrity sha1-SWsswQnsqNus/i3HK2A8F8WHCtQ=
-
-xhr-request-promise@^0.1.2:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/xhr-request-promise/-/xhr-request-promise-0.1.3.tgz#2d5f4b16d8c6c893be97f1a62b0ed4cf3ca5f96c"
-  integrity sha512-YUBytBsuwgitWtdRzXDDkWAXzhdGB8bYm0sSzMPZT7Z2MBjMSTHFsyCT1yCRATY+XC69DUrQraRAEgcoCRaIPg==
-  dependencies:
-    xhr-request "^1.1.0"
-
-xhr-request@^1.0.1, xhr-request@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/xhr-request/-/xhr-request-1.1.0.tgz#f4a7c1868b9f198723444d82dcae317643f2e2ed"
-  integrity sha512-Y7qzEaR3FDtL3fP30k9wO/e+FBnBByZeybKOhASsGP30NIkRAAkKD/sCnLvgEfAIEC1rcmK7YG8f4oEnIrrWzA==
-  dependencies:
-    buffer-to-arraybuffer "^0.0.5"
-    object-assign "^4.1.1"
-    query-string "^5.0.1"
-    simple-get "^2.7.0"
-    timed-out "^4.0.1"
-    url-set-query "^1.0.0"
-    xhr "^2.0.4"
-
-xhr2-cookies@1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/xhr2-cookies/-/xhr2-cookies-1.1.0.tgz#7d77449d0999197f155cb73b23df72505ed89d48"
-  integrity sha1-fXdEnQmZGX8VXLc7I99yUF7YnUg=
-  dependencies:
-    cookiejar "^2.1.1"
-
-xhr@^2.0.4, xhr@^2.2.0, xhr@^2.3.3:
-  version "2.6.0"
-  resolved "https://registry.yarnpkg.com/xhr/-/xhr-2.6.0.tgz#b69d4395e792b4173d6b7df077f0fc5e4e2b249d"
-  integrity sha512-/eCGLb5rxjx5e3mF1A7s+pLlR6CGyqWN91fv1JgER5mVWg1MZmlhBvy9kjcsOdRk8RrIujotWyJamfyrp+WIcA==
-  dependencies:
-    global "~4.4.0"
-    is-function "^1.0.1"
-    parse-headers "^2.0.0"
-    xtend "^4.0.0"
-
-"xml-name-validator@>= 2.0.1 < 3.0.0":
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/xml-name-validator/-/xml-name-validator-2.0.1.tgz#4d8b8f1eccd3419aa362061becef515e1e559635"
-  integrity sha1-TYuPHszTQZqjYgYb7O9RXh5VljU=
-
-xmlhttprequest@1.8.0:
-  version "1.8.0"
-  resolved "https://registry.yarnpkg.com/xmlhttprequest/-/xmlhttprequest-1.8.0.tgz#67fe075c5c24fef39f9d65f5f7b7fe75171968fc"
-  integrity sha1-Z/4HXFwk/vOfnWX197f+dRcZaPw=
-
-xss@^1.0.8:
-  version "1.0.10"
-  resolved "https://registry.yarnpkg.com/xss/-/xss-1.0.10.tgz#5cd63a9b147a755a14cb0455c7db8866120eb4d2"
-  integrity sha512-qmoqrRksmzqSKvgqzN0055UFWY7OKx1/9JWeRswwEVX9fCG5jcYRxa/A2DHcmZX6VJvjzHRQ2STeeVcQkrmLSw==
-  dependencies:
-    commander "^2.20.3"
-    cssfilter "0.0.10"
-
-"xtend@>=4.0.0 <4.1.0-0", xtend@^4.0.0, xtend@^4.0.1, xtend@^4.0.2, xtend@~4.0.0, xtend@~4.0.1:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"
-  integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==
-
-xtend@~2.1.1:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/xtend/-/xtend-2.1.2.tgz#6efecc2a4dad8e6962c4901b337ce7ba87b5d28b"
-  integrity sha1-bv7MKk2tjmlixJAbM3znuoe10os=
-  dependencies:
-    object-keys "~0.4.0"
-
-y18n@^3.2.1:
-  version "3.2.2"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-3.2.2.tgz#85c901bd6470ce71fc4bb723ad209b70f7f28696"
-  integrity sha512-uGZHXkHnhF0XeeAPgnKfPv1bgKAYyVvmNL1xlKsPYZPaIHxGti2hHqvOCQv71XMsLxu1QjergkqogUnms5D3YQ==
-
-y18n@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-4.0.1.tgz#8db2b83c31c5d75099bb890b23f3094891e247d4"
-  integrity sha512-wNcy4NvjMYL8gogWWYAO7ZFWFfHcbdbE57tZO8e4cbpj8tfUcwrwqSl3ad8HxpYWCdXcJUCeKKZS62Av1affwQ==
-
-yaeti@^0.0.6:
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/yaeti/-/yaeti-0.0.6.tgz#f26f484d72684cf42bedfb76970aa1608fbf9577"
-  integrity sha1-8m9ITXJoTPQr7ft2lwqhYI+/lXc=
-
-yallist@^3.0.0, yallist@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd"
-  integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==
-
-yallist@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
-  integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
-
-yaml@1.10.2, yaml@^1.10.0, yaml@^1.10.2, yaml@^1.7.2:
-  version "1.10.2"
-  resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.10.2.tgz#2301c5ffbf12b467de8da2333a459e29e7920e4b"
-  integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==
-
-yargs-parser@13.1.2, yargs-parser@^13.1.2:
-  version "13.1.2"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-13.1.2.tgz#130f09702ebaeef2650d54ce6e3e5706f7a4fb38"
-  integrity sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==
-  dependencies:
-    camelcase "^5.0.0"
-    decamelize "^1.2.0"
-
-yargs-parser@^15.0.1:
-  version "15.0.1"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-15.0.1.tgz#54786af40b820dcb2fb8025b11b4d659d76323b3"
-  integrity sha512-0OAMV2mAZQrs3FkNpDQcBk1x5HXb8X4twADss4S0Iuk+2dGnLOE/fRHrsYm542GduMveyA77OF4wrNJuanRCWw==
-  dependencies:
-    camelcase "^5.0.0"
-    decamelize "^1.2.0"
-
-yargs-parser@^16.1.0:
-  version "16.1.0"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-16.1.0.tgz#73747d53ae187e7b8dbe333f95714c76ea00ecf1"
-  integrity sha512-H/V41UNZQPkUMIT5h5hiwg4QKIY1RPvoBV4XcjUbRM8Bk2oKqqyZ0DIEbTFZB0XjbtSPG8SAa/0DxCQmiRgzKg==
-  dependencies:
-    camelcase "^5.0.0"
-    decamelize "^1.2.0"
-
-yargs-parser@^18.1.2:
-  version "18.1.3"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-18.1.3.tgz#be68c4975c6b2abf469236b0c870362fab09a7b0"
-  integrity sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==
-  dependencies:
-    camelcase "^5.0.0"
-    decamelize "^1.2.0"
-
-yargs-parser@^2.4.0:
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-2.4.1.tgz#85568de3cf150ff49fa51825f03a8c880ddcc5c4"
-  integrity sha1-hVaN488VD/SfpRgl8DqMiA3cxcQ=
-  dependencies:
-    camelcase "^3.0.0"
-    lodash.assign "^4.0.6"
-
-yargs-parser@^21.0.0:
-  version "21.1.1"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35"
-  integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==
-
-yargs-unparser@1.6.1:
-  version "1.6.1"
-  resolved "https://registry.yarnpkg.com/yargs-unparser/-/yargs-unparser-1.6.1.tgz#bd4b0ee05b4c94d058929c32cb09e3fce71d3c5f"
-  integrity sha512-qZV14lK9MWsGCmcr7u5oXGH0dbGqZAIxTDrWXZDo5zUr6b6iUmelNKO6x6R1dQT24AH3LgRxJpr8meWy2unolA==
-  dependencies:
-    camelcase "^5.3.1"
-    decamelize "^1.2.0"
-    flat "^4.1.0"
-    is-plain-obj "^1.1.0"
-    yargs "^14.2.3"
-
-yargs@13.3.2:
-  version "13.3.2"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-13.3.2.tgz#ad7ffefec1aa59565ac915f82dccb38a9c31a2dd"
-  integrity sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==
-  dependencies:
-    cliui "^5.0.0"
-    find-up "^3.0.0"
-    get-caller-file "^2.0.1"
-    require-directory "^2.1.1"
-    require-main-filename "^2.0.0"
-    set-blocking "^2.0.0"
-    string-width "^3.0.0"
-    which-module "^2.0.0"
-    y18n "^4.0.0"
-    yargs-parser "^13.1.2"
-
-yargs@4.6.0:
-  version "4.6.0"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-4.6.0.tgz#cb4050c0159bfb6bb649c0f4af550526a84619dc"
-  integrity sha1-y0BQwBWb+2u2ScD0r1UFJqhGGdw=
-  dependencies:
-    camelcase "^2.0.1"
-    cliui "^3.2.0"
-    decamelize "^1.1.1"
-    lodash.assign "^4.0.3"
-    os-locale "^1.4.0"
-    pkg-conf "^1.1.2"
-    read-pkg-up "^1.0.1"
-    require-main-filename "^1.0.1"
-    string-width "^1.0.1"
-    window-size "^0.2.0"
-    y18n "^3.2.1"
-    yargs-parser "^2.4.0"
-
-yargs@^14.2.3:
-  version "14.2.3"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-14.2.3.tgz#1a1c3edced1afb2a2fea33604bc6d1d8d688a414"
-  integrity sha512-ZbotRWhF+lkjijC/VhmOT9wSgyBQ7+zr13+YLkhfsSiTriYsMzkTUFP18pFhWwBeMa5gUc1MzbhrO6/VB7c9Xg==
-  dependencies:
-    cliui "^5.0.0"
-    decamelize "^1.2.0"
-    find-up "^3.0.0"
-    get-caller-file "^2.0.1"
-    require-directory "^2.1.1"
-    require-main-filename "^2.0.0"
-    set-blocking "^2.0.0"
-    string-width "^3.0.0"
-    which-module "^2.0.0"
-    y18n "^4.0.0"
-    yargs-parser "^15.0.1"
-
-yargs@^15.3.1:
-  version "15.4.1"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-15.4.1.tgz#0d87a16de01aee9d8bec2bfbf74f67851730f4f8"
-  integrity sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==
-  dependencies:
-    cliui "^6.0.0"
-    decamelize "^1.2.0"
-    find-up "^4.1.0"
-    get-caller-file "^2.0.1"
-    require-directory "^2.1.1"
-    require-main-filename "^2.0.0"
-    set-blocking "^2.0.0"
-    string-width "^4.2.0"
-    which-module "^2.0.0"
-    y18n "^4.0.0"
-    yargs-parser "^18.1.2"
-
-yn@3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
-  integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
-
-yocto-queue@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
-  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
-
-zen-observable-ts@^0.8.21:
-  version "0.8.21"
-  resolved "https://registry.yarnpkg.com/zen-observable-ts/-/zen-observable-ts-0.8.21.tgz#85d0031fbbde1eba3cd07d3ba90da241215f421d"
-  integrity sha512-Yj3yXweRc8LdRMrCC8nIc4kkjWecPAUVh0TI0OUrWXx6aX790vLcDlWca6I4vsyCGH3LpWxq0dJRcMOFoVqmeg==
-  dependencies:
-    tslib "^1.9.3"
-    zen-observable "^0.8.0"
-
-zen-observable@^0.8.0, zen-observable@^0.8.14:
-  version "0.8.15"
-  resolved "https://registry.yarnpkg.com/zen-observable/-/zen-observable-0.8.15.tgz#96415c512d8e3ffd920afd3889604e30b9eaac15"
-  integrity sha512-PQ2PC7R9rslx84ndNBZB/Dkv8V8fZEpk83RLgXtYd0fwUgEjseMn1Dgajh2x6S8QbZAFa9p2qVCEuYZNgve0dQ==
diff --git a/tests/runner-tests/aggregation-current-bucket/abis/Contract.abi b/tests/runner-tests/aggregation-current-bucket/abis/Contract.abi
new file mode 100644
index 00000000000..9d9f56b9263
--- /dev/null
+++ b/tests/runner-tests/aggregation-current-bucket/abis/Contract.abi
@@ -0,0 +1,15 @@
+[
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "string",
+                "name": "testCommand",
+                "type": "string"
+            }
+        ],
+        "name": "TestEvent",
+        "type": "event"
+    }
+]
diff --git a/tests/runner-tests/aggregation-current-bucket/package.json b/tests/runner-tests/aggregation-current-bucket/package.json
new file mode 100644
index 00000000000..d97282562f1
--- /dev/null
+++ b/tests/runner-tests/aggregation-current-bucket/package.json
@@ -0,0 +1,13 @@
+{
+    "name": "aggregation-current-bucket",
+    "version": "0.0.0",
+    "private": true,
+    "scripts": {
+        "codegen": "graph codegen --skip-migrations",
+        "deploy:test": "graph deploy test/aggregation-current-bucket --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI 2>&1 | sed 's/\u001b[[0-9;]*m//g'"
+    },
+    "devDependencies": {
+        "@graphprotocol/graph-cli": "0.98.1",
+        "@graphprotocol/graph-ts": "0.35.0"
+    }
+}
diff --git a/tests/runner-tests/aggregation-current-bucket/schema.graphql b/tests/runner-tests/aggregation-current-bucket/schema.graphql
new file mode 100644
index 00000000000..2e8e713d72e
--- /dev/null
+++ b/tests/runner-tests/aggregation-current-bucket/schema.graphql
@@ -0,0 +1,19 @@
+type Token @entity(immutable: true) {
+  id: Bytes!
+  name: String!
+  stats: [Stats!]! @derivedFrom(field: "token")
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  amount: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour"], source: "Data") {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  sum: BigDecimal! @aggregate(fn: "sum", arg: "amount")
+}
diff --git a/tests/runner-tests/aggregation-current-bucket/src/mapping.ts b/tests/runner-tests/aggregation-current-bucket/src/mapping.ts
new file mode 100644
index 00000000000..19e2e7750d8
--- /dev/null
+++ b/tests/runner-tests/aggregation-current-bucket/src/mapping.ts
@@ -0,0 +1,21 @@
+import { BigDecimal, Bytes } from "@graphprotocol/graph-ts";
+import { TestEvent } from "../generated/Contract/Contract";
+import { Token, Data } from "../generated/schema";
+
+export function handleTestEvent(event: TestEvent): void {
+  let command = event.params.testCommand;
+  let parts = command.split(":");
+
+  if (parts[0] == "token") {
+    // Format: "token:<hex_id>:<name>"
+    let token = new Token(Bytes.fromHexString(parts[1]));
+    token.name = parts[2];
+    token.save();
+  } else if (parts[0] == "data") {
+    // Format: "data:<token_hex_id>:<amount>"
+    let data = new Data(0);
+    data.token = Bytes.fromHexString(parts[1]);
+    data.amount = BigDecimal.fromString(parts[2]);
+    data.save();
+  }
+}
diff --git a/tests/runner-tests/aggregation-current-bucket/subgraph.yaml b/tests/runner-tests/aggregation-current-bucket/subgraph.yaml
new file mode 100644
index 00000000000..9386681ae18
--- /dev/null
+++ b/tests/runner-tests/aggregation-current-bucket/subgraph.yaml
@@ -0,0 +1,24 @@
+specVersion: 1.1.0
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "0x0000000000000000000000000000000000000000"
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - Token
+        - Data
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      eventHandlers:
+        - event: TestEvent(string)
+          handler: handleTestEvent
+      file: ./src/mapping.ts
diff --git a/tests/runner-tests/api-version/package.json b/tests/runner-tests/api-version/package.json
index a1ffee722b4..b67821fa3d6 100644
--- a/tests/runner-tests/api-version/package.json
+++ b/tests/runner-tests/api-version/package.json
@@ -1,19 +1,17 @@
 {
   "name": "api-version",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
-    "codegen": "graph --version # dummy, we need a  'codegen'",
-    "create:test": "graph create test/api-version --node $GRAPH_NODE_ADMIN_URI",
+    "codegen": "graph --version # dummy, we need a 'codegen'",
     "prepare:0-0-7": "mustache data.0.0.7.json subgraph.template.yaml > subgraph-0.0.7.yaml",
-    "prepare:0-0-8": "mustache data.0.0.8.json  subgraph.template.yaml > subgraph-0.0.8.yaml",
-    "deploy:test-0-0-7": "yarn prepare:0-0-7 && graph codegen --skip-migrations subgraph-0.0.7.yaml && graph deploy test/api-version-0-0-7 subgraph-0.0.7.yaml --version-label 0.0.7 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI",
-    "deploy:test-0-0-8": "yarn prepare:0-0-8 && graph codegen --skip-migrations subgraph-0.0.8.yaml && graph deploy test/api-version-0-0-8 subgraph-0.0.8.yaml --version-label 0.0.8 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+    "prepare:0-0-8": "mustache data.0.0.8.json subgraph.template.yaml > subgraph-0.0.8.yaml",
+    "deploy:test-0-0-7": "pnpm prepare:0-0-7 && graph codegen --skip-migrations subgraph-0.0.7.yaml && graph deploy test/api-version-0-0-7 subgraph-0.0.7.yaml --version-label 0.0.7 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI",
+    "deploy:test-0-0-8": "pnpm prepare:0-0-8 && graph codegen --skip-migrations subgraph-0.0.8.yaml && graph deploy test/api-version-0-0-8 subgraph-0.0.8.yaml --version-label 0.0.8 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
     "@graphprotocol/graph-cli": "0.60.0",
-    "@graphprotocol/graph-ts": "0.31.0"
-  },
-  "dependencies": {
+    "@graphprotocol/graph-ts": "0.31.0",
     "mustache": "^4.2.0"
   }
 }
diff --git a/tests/runner-tests/arweave-file-data-sources/package.json b/tests/runner-tests/arweave-file-data-sources/package.json
index ce7e8298212..f264024b638 100644
--- a/tests/runner-tests/arweave-file-data-sources/package.json
+++ b/tests/runner-tests/arweave-file-data-sources/package.json
@@ -1,9 +1,9 @@
 {
   "name": "arweave-file-data-sources",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
-    "create:test": "graph create test/file-data-sources --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/file-data-sources --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
diff --git a/tests/runner-tests/block-handlers/package.json b/tests/runner-tests/block-handlers/package.json
index 5572e8475a5..0331812e103 100644
--- a/tests/runner-tests/block-handlers/package.json
+++ b/tests/runner-tests/block-handlers/package.json
@@ -1,9 +1,9 @@
 {
   "name": "block-handlers",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
-    "create:test": "graph create test/block-handlers --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/block-handlers --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
diff --git a/tests/runner-tests/data-source-revert/grafted.yaml b/tests/runner-tests/data-source-revert/grafted.yaml
index 9992583098b..16dca790850 100644
--- a/tests/runner-tests/data-source-revert/grafted.yaml
+++ b/tests/runner-tests/data-source-revert/grafted.yaml
@@ -6,7 +6,7 @@ schema:
 graft:
   # This can be overwritten by `updateAndDeploy.js`.
   # Please commit this file when this happens.
-  base: QmcAL39QSKZvRssr2ToCJrav7XK9ggajxvBR7M1NNUCqdh
+  base: QmRfaNu6ymQVUiJVTayqWuT8ftLtvn7iE8kQSSAtTPA2J2
   block: 3
 dataSources:
   - kind: ethereum/contract
diff --git a/tests/runner-tests/data-source-revert/package.json b/tests/runner-tests/data-source-revert/package.json
index a8ed0e1b473..80bdeb280e4 100644
--- a/tests/runner-tests/data-source-revert/package.json
+++ b/tests/runner-tests/data-source-revert/package.json
@@ -1,6 +1,7 @@
 {
   "name": "data-source-revert",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
     "deploy:test": "graph deploy test/data-source-revert --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI",
diff --git a/tests/runner-tests/data-source-revert2/package.json b/tests/runner-tests/data-source-revert2/package.json
index def8ee5bcee..45feeedf629 100644
--- a/tests/runner-tests/data-source-revert2/package.json
+++ b/tests/runner-tests/data-source-revert2/package.json
@@ -1,6 +1,7 @@
 {
   "name": "data-source-revert2",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
     "deploy:test": "graph deploy test/data-source-revert2 --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
diff --git a/tests/runner-tests/data-sources/package.json b/tests/runner-tests/data-sources/package.json
index 2ad34ee407d..118366dd6c5 100644
--- a/tests/runner-tests/data-sources/package.json
+++ b/tests/runner-tests/data-sources/package.json
@@ -1,9 +1,9 @@
 {
   "name": "data-sources",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
-    "create:test": "graph create test/data-sources --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/data-sources --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
diff --git a/tests/runner-tests/derived-loaders/package.json b/tests/runner-tests/derived-loaders/package.json
index b943f9fee3b..d885b871d24 100644
--- a/tests/runner-tests/derived-loaders/package.json
+++ b/tests/runner-tests/derived-loaders/package.json
@@ -1,9 +1,9 @@
 {
   "name": "derived-loaders",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
-    "create:test": "graph create test/derived-loaders --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/derived-loaders --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
diff --git a/tests/runner-tests/dynamic-data-source/package.json b/tests/runner-tests/dynamic-data-source/package.json
index 9e1e0c731e2..2adee43df73 100644
--- a/tests/runner-tests/dynamic-data-source/package.json
+++ b/tests/runner-tests/dynamic-data-source/package.json
@@ -1,9 +1,9 @@
 {
   "name": "dynamic-data-source",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
-    "create:test": "graph create test/dynamic-data-source --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/dynamic-data-source --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
diff --git a/tests/runner-tests/end-block/package.json b/tests/runner-tests/end-block/package.json
index b01a779c4bb..2d20109c509 100644
--- a/tests/runner-tests/end-block/package.json
+++ b/tests/runner-tests/end-block/package.json
@@ -1,9 +1,9 @@
 {
   "name": "end-block",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
-    "create:test": "graph create test/end-block --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/end-block --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
diff --git a/tests/runner-tests/end-block/subgraph.yaml b/tests/runner-tests/end-block/subgraph.yaml
index a20a593e8b8..76ed7ca3cd5 100644
--- a/tests/runner-tests/end-block/subgraph.yaml
+++ b/tests/runner-tests/end-block/subgraph.yaml
@@ -23,4 +23,24 @@ dataSources:
       eventHandlers:
         - event: TestEvent(string)
           handler: handleTestEvent
+      file: ./src/mapping.ts
+  # Datasource without endBlock to keep the subgraph running
+  - kind: ethereum/contract
+    name: Contract2
+    network: test
+    source:
+      address: "0x0000000000000000000000000000000000000001"
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - Gravatar
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      eventHandlers:
+        - event: TestEvent(string)
+          handler: handleTestEvent
       file: ./src/mapping.ts
\ No newline at end of file
diff --git a/tests/runner-tests/fatal-error/package.json b/tests/runner-tests/fatal-error/package.json
index a938a473390..41b7164985f 100644
--- a/tests/runner-tests/fatal-error/package.json
+++ b/tests/runner-tests/fatal-error/package.json
@@ -1,9 +1,9 @@
 {
   "name": "fatal-error",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
-    "create:test": "graph create test/fatal-error --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/fatal-error --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
diff --git a/tests/runner-tests/file-data-sources/abis/Contract.abi b/tests/runner-tests/file-data-sources/abis/Contract.abi
index 9d9f56b9263..6f27d071ad8 100644
--- a/tests/runner-tests/file-data-sources/abis/Contract.abi
+++ b/tests/runner-tests/file-data-sources/abis/Contract.abi
@@ -7,6 +7,12 @@
                 "internalType": "string",
                 "name": "testCommand",
                 "type": "string"
+            },
+            {
+                "indexed": false,
+                "internalType": "string",
+                "name": "data",
+                "type": "string"
             }
         ],
         "name": "TestEvent",
diff --git a/tests/runner-tests/file-data-sources/package.json b/tests/runner-tests/file-data-sources/package.json
index def449bb9a3..e29a94f75d9 100644
--- a/tests/runner-tests/file-data-sources/package.json
+++ b/tests/runner-tests/file-data-sources/package.json
@@ -1,9 +1,9 @@
 {
   "name": "file-data-sources",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
-    "create:test": "graph create test/file-data-sources --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/file-data-sources --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
diff --git a/tests/runner-tests/file-data-sources/schema.graphql b/tests/runner-tests/file-data-sources/schema.graphql
index c715a79c3ba..4b0112f29c0 100644
--- a/tests/runner-tests/file-data-sources/schema.graphql
+++ b/tests/runner-tests/file-data-sources/schema.graphql
@@ -1,15 +1,10 @@
-type IpfsFile @entity {
+type FileEntity @entity {
   id: ID!
   content: String!
+  foo: Foo @relation
 }
 
-type IpfsFile1 @entity {
+type Foo @entity {
   id: ID!
-  content: String!
+  ipfs: FileEntity @derivedFrom(field: "foo")
 }
-
-type SpawnTestEntity @entity {
-  id: ID!
-  content: String!
-  context: String!
-}
\ No newline at end of file
diff --git a/tests/runner-tests/file-data-sources/src/mapping.ts b/tests/runner-tests/file-data-sources/src/mapping.ts
index e24ccd9074e..a7f6ffa70ab 100644
--- a/tests/runner-tests/file-data-sources/src/mapping.ts
+++ b/tests/runner-tests/file-data-sources/src/mapping.ts
@@ -4,130 +4,151 @@ import {
   BigInt,
   Bytes,
   DataSourceContext,
+  store,
+  log,
 } from "@graphprotocol/graph-ts";
 import { TestEvent } from "../generated/Contract/Contract";
-import { IpfsFile, IpfsFile1, SpawnTestEntity } from "../generated/schema";
-
-// CID of `file-data-sources/abis/Contract.abi` after being processed by graph-cli.
-const KNOWN_CID = "QmQ2REmceVtzawp7yrnxLQXgNNCtFHEnig6fL9aqE1kcWq";
+import { FileEntity, Foo } from "../generated/schema";
+
+const ONCHAIN_FROM_OFFCHAIN = "CREATE_ONCHAIN_DATASOURCE_FROM_OFFCHAIN_HANDLER";
+const CREATE_FILE = "CREATE_FILE";
+// const CREATE_FILE_FROM_HANDLE_FILE = "CREATE_FILE_FROM_HANDLE_FILE";
+const CREATE_UNDEFINED_ENTITY = "CREATE_UNDEFINED_ENTITY";
+const CREATE_CONFLICTING_ENTITY = "CREATE_CONFLICTING_ENTITY";
+const SPAWN_FDS_FROM_OFFCHAIN_HANDLER = "SPAWN_FDS_FROM_OFFCHAIN_HANDLER";
+const ACCESS_AND_UPDATE_OFFCHAIN_ENTITY_IN_ONCHAIN_HANDLER =
+  "ACCESS_AND_UPDATE_OFFCHAIN_ENTITY_IN_ONCHAIN_HANDLER";
+const ACCESS_FILE_ENTITY_THROUGH_DERIVED_FIELD =
+  "ACCESS_FILE_ENTITY_THROUGH_DERIVED_FIELD";
+
+const CREATE_FOO = "CREATE_FOO";
+export function handleTestEvent(event: TestEvent): void {
+  if (event.params.testCommand == CREATE_FILE) {
+    dataSource.createWithContext(
+      "File",
+      [event.params.data],
+      new DataSourceContext(),
+    );
+  }
 
-export function handleBlock(block: ethereum.Block): void {
-  let entity = new IpfsFile("onchain");
-  entity.content = "onchain";
-  entity.save();
+  if (event.params.testCommand == SPAWN_FDS_FROM_OFFCHAIN_HANDLER) {
+    let comma_separated_hash = event.params.data;
+    let hash1 = comma_separated_hash.split(",")[0];
+    let hash2 = comma_separated_hash.split(",")[1];
+    let context = new DataSourceContext();
+    context.setString("command", SPAWN_FDS_FROM_OFFCHAIN_HANDLER);
+    context.setString("hash", hash2);
 
-  // This will create the same data source twice, once at block 0 and another at block 2.
-  // The creation at block 2 should be detected as a duplicate and therefore a noop.
-  if (block.number == BigInt.fromI32(0) || block.number == BigInt.fromI32(2)) {
-    dataSource.create("File", [KNOWN_CID]);
+    log.info(
+      "Creating file data source from handleFile, command : {} ,hash1: {}, hash2: {}",
+      [SPAWN_FDS_FROM_OFFCHAIN_HANDLER, hash1, hash2],
+    );
+    dataSource.createWithContext("File", [hash1], context);
   }
 
-  if (block.number == BigInt.fromI32(1)) {
-    let entity = IpfsFile.load("onchain")!;
-    assert(entity.content == "onchain");
-
-    // The test assumes file data sources are processed in the block in which they are created.
-    // So the ds created at block 0 will have been processed.
-    //
-    // Test that onchain data sources cannot read offchain data.
-    assert(IpfsFile.load(KNOWN_CID) == null);
+  if (event.params.testCommand == ONCHAIN_FROM_OFFCHAIN) {
+    let context = new DataSourceContext();
+    context.setString("command", ONCHAIN_FROM_OFFCHAIN);
+    context.setString("address", "0x0000000000000000000000000000000000000000");
+    dataSource.createWithContext("File", [event.params.data], context);
+  }
 
-    // Test that using an invalid CID will be ignored
-    dataSource.create("File", ["hi, I'm not valid"]);
+  if (event.params.testCommand == CREATE_UNDEFINED_ENTITY) {
+    log.info("Creating undefined entity", []);
+    let context = new DataSourceContext();
+    context.setString("command", CREATE_UNDEFINED_ENTITY);
+    dataSource.createWithContext("File", [event.params.data], context);
   }
 
-  // This will invoke File1 data source with same CID, which will be used
-  // to test whether same cid is triggered across different data source.
-  if (block.number == BigInt.fromI32(3)) {
-    // Test that onchain data sources cannot read offchain data (again, but this time more likely to hit the DB than the write queue).
-    assert(IpfsFile.load(KNOWN_CID) == null);
+  if (event.params.testCommand == CREATE_CONFLICTING_ENTITY) {
+    log.info("Creating conflicting entity", []);
+    let entity = new FileEntity(event.params.data);
+    entity.content = "content";
+    entity.save();
+  }
 
-    dataSource.create("File1", [KNOWN_CID]);
+  if (
+    event.params.testCommand ==
+    ACCESS_AND_UPDATE_OFFCHAIN_ENTITY_IN_ONCHAIN_HANDLER
+  ) {
+    let hash = event.params.data;
+    log.info("Creating file data source from handleFile: {}", [hash]);
+    let entity = FileEntity.load(event.params.data);
+    if (entity == null) {
+      log.info("Entity not found", []);
+    } else {
+      // This should never be logged if the entity was created in the offchain handler
+      // Such entities are not accessible in onchain handlers and will return null on load
+      log.info("Updating entity content", []);
+      entity.content = "updated content";
+      entity.save();
+    }
   }
-}
 
-export function handleTestEvent(event: TestEvent): void {
-  let command = event.params.testCommand;
-
-  if (command == "createFile2") {
-    // Will fail the subgraph when processed due to mismatch in the entity type and 'entities'.
-    dataSource.create("File2", [KNOWN_CID]);
-  } else if (command == "saveConflictingEntity") {
-    // Will fail the subgraph because the same entity has been created in a file data source.
-    let entity = new IpfsFile(KNOWN_CID);
-    entity.content = "empty";
+  if (event.params.testCommand == CREATE_FOO) {
+    let entity = new Foo(event.params.data);
     entity.save();
-  } else if (command == "createFile1") {
-    // Will fail the subgraph with a conflict between two entities created by offchain data sources.
-    let context = new DataSourceContext();
-    context.setBytes("hash", event.block.hash);
-    dataSource.createWithContext("File1", [KNOWN_CID], context);
-  } else if (command == "spawnOffChainHandlerTest") {
-    // Used to test the spawning of a file data source from another file data source handler.
-    // `SpawnTestHandler` will spawn a file data source that will be handled by `spawnOffChainHandlerTest`,
-    // which creates another file data source `OffChainDataSource`, which will be handled by `handleSpawnedTest`.
-    let context = new DataSourceContext();
-    context.setString("command", command);
-    dataSource.createWithContext("SpawnTestHandler", [KNOWN_CID], context);
-  } else if (command == "spawnOnChainHandlerTest") {
-    // Used to test the failure of spawning of on-chain data source from a file data source handler.
-    // `SpawnTestHandler` will spawn a file data source that will be handled by `spawnTestHandler`,
-    // which creates an `OnChainDataSource`, which should fail since spawning onchain datasources
-    // from offchain handlers is not allowed.
     let context = new DataSourceContext();
-    context.setString("command", command);
-    dataSource.createWithContext("SpawnTestHandler", [KNOWN_CID], context);
-  } else {
-    assert(false, "Unknown command: " + command);
+    context.setString("command", CREATE_FOO);
+    dataSource.createWithContext("File", [event.params.data], context);
   }
-}
 
-export function handleFile(data: Bytes): void {
-  // Test that offchain data sources cannot read onchain data.
-  assert(IpfsFile.load("onchain") == null);
+  if (event.params.testCommand == ACCESS_FILE_ENTITY_THROUGH_DERIVED_FIELD) {
+    let entity = Foo.load(event.params.data);
+    if (entity == null) {
+      log.info("Entity not found", []);
+    } else {
+      log.info("Accessing file entity through derived field", []);
+      let fileEntity = entity.ipfs.load();
 
-  if (
-    dataSource.stringParam() != "QmVkvoPGi9jvvuxsHDVJDgzPEzagBaWSZRYoRDzU244HjZ"
-  ) {
-    // Test that an offchain data source cannot read from another offchain data source.
-    assert(
-      IpfsFile.load("QmVkvoPGi9jvvuxsHDVJDgzPEzagBaWSZRYoRDzU244HjZ") == null
-    );
+      assert(fileEntity.length == 0, "Expected exactly one file entity");
+    }
   }
+}
 
-  let entity = new IpfsFile(dataSource.stringParam());
-  entity.content = data.toString();
-  entity.save();
+export function handleFile(data: Bytes): void {
+  log.info('handleFile {}', [dataSource.stringParam()]);
+  let context = dataSource.context();
 
-  // Test that an offchain data source can load its own entities
-  let loaded_entity = IpfsFile.load(dataSource.stringParam())!;
-  assert(loaded_entity.content == entity.content);
-}
+  if (!context.isSet('command')) {
+    log.info('Creating FileEntity from handleFile: {} , content : {}', [
+      dataSource.stringParam(),
+      data.toString(),
+    ]);
 
-export function handleFile1(data: Bytes): void {
-  let entity = new IpfsFile1(dataSource.stringParam());
-  entity.content = data.toString();
-  entity.save();
-}
+    let entity = new FileEntity(dataSource.stringParam());
+    entity.content = data.toString();
+    entity.save();
 
-// Used to test spawning a file data source from another file data source handler.
-// This function spawns a file data source that will be handled by `handleSpawnedTest`.
-export function spawnTestHandler(data: Bytes): void {
-  let context = new DataSourceContext();
-  context.setString("file", "fromSpawnTestHandler");
-  let command = dataSource.context().getString("command");
-  if (command == "spawnOffChainHandlerTest") {
-    dataSource.createWithContext("OffChainDataSource", [KNOWN_CID], context);
-  } else if (command == "spawnOnChainHandlerTest") {
-    dataSource.createWithContext("OnChainDataSource", [KNOWN_CID], context);
+    return;
   }
-}
 
-// This is the handler for the data source spawned by `spawnOffChainHandlerTest`.
-export function handleSpawnedTest(data: Bytes): void {
-  let entity = new SpawnTestEntity(dataSource.stringParam());
-  let context = dataSource.context().getString("file");
-  entity.content = data.toString();
-  entity.context = context;
-  entity.save();
-}
+  let contextCommand = context.getString('command');
+
+  if (contextCommand == SPAWN_FDS_FROM_OFFCHAIN_HANDLER) {
+    // Create an entity for THIS file data source too, so that two offchain
+    // triggers in the same block each write an entity. This exercises the
+    // shared VID generator: if VIDs collide the DB will reject the insert.
+    let entity = new FileEntity(dataSource.stringParam());
+    entity.content = data.toString();
+    entity.save();
+
+    let hash = context.getString('hash');
+    log.info('Creating file data source from handleFile: {}', [hash]);
+    dataSource.createWithContext('File', [hash], new DataSourceContext());
+  } else if (contextCommand == ONCHAIN_FROM_OFFCHAIN) {
+    log.info('Creating onchain data source from offchain handler', []);
+    let address = context.getString('address');
+    dataSource.create('OnChainDataSource', [address]);
+  } else if (contextCommand == CREATE_UNDEFINED_ENTITY) {
+    log.info('Creating undefined entity', []);
+    let entity = new Foo(dataSource.stringParam());
+    entity.save();
+  } else if (contextCommand == CREATE_FOO) {
+    log.info('Creating FileEntity with relation to Foo', []);
+    let entity = new FileEntity(dataSource.stringParam());
+    entity.foo = dataSource.stringParam();
+    entity.content = data.toString();
+    entity.save();
+  }
+}
\ No newline at end of file
diff --git a/tests/runner-tests/file-data-sources/subgraph.yaml b/tests/runner-tests/file-data-sources/subgraph.yaml
index c3b251fd1eb..5438b43c9f2 100644
--- a/tests/runner-tests/file-data-sources/subgraph.yaml
+++ b/tests/runner-tests/file-data-sources/subgraph.yaml
@@ -13,14 +13,13 @@ dataSources:
       apiVersion: 0.0.7
       language: wasm/assemblyscript
       entities:
-        - Gravatar
+        - FileEntity
+        - Foo
       abis:
         - name: Contract
           file: ./abis/Contract.abi
-      blockHandlers:
-        - handler: handleBlock
       eventHandlers:
-        - event: TestEvent(string)
+        - event: TestEvent(string,string)
           handler: handleTestEvent
       file: ./src/mapping.ts
 templates:
@@ -38,10 +37,8 @@ templates:
       abis:
         - name: Contract
           file: ./abis/Contract.abi
-      blockHandlers:
-        - handler: handleBlock
       eventHandlers:
-        - event: TestEvent(string)
+        - event: TestEvent(string,string)
           handler: handleTestEvent
       file: ./src/mapping.ts
   - kind: file/ipfs
@@ -51,61 +48,9 @@ templates:
       apiVersion: 0.0.7
       language: wasm/assemblyscript
       entities:
-        - IpfsFile
+        - FileEntity
       abis:
         - name: Contract
           file: ./abis/Contract.abi
       handler: handleFile
       file: ./src/mapping.ts
-  - kind: file/ipfs
-    name: File1
-    mapping:
-      kind: ethereum/events
-      apiVersion: 0.0.7
-      language: wasm/assemblyscript
-      entities:
-        - IpfsFile1
-      abis:
-        - name: Contract
-          file: ./abis/Contract.abi
-      handler: handleFile1
-      file: ./src/mapping.ts
-  - kind: file/ipfs
-    name: File2
-    mapping:
-      kind: ethereum/events
-      apiVersion: 0.0.7
-      language: wasm/assemblyscript
-      entities:
-        - IpfsFile # will trigger an error, should be IpfsFile1
-      abis:
-        - name: Contract
-          file: ./abis/Contract.abi
-      handler: handleFile1
-      file: ./src/mapping.ts
-  - kind: file/ipfs
-    name: SpawnTestHandler
-    mapping:
-      kind: ethereum/events
-      apiVersion: 0.0.7
-      language: wasm/assemblyscript
-      entities:
-        - SpawnTestEntity
-      abis:
-        - name: Contract
-          file: ./abis/Contract.abi
-      handler: spawnTestHandler
-      file: ./src/mapping.ts
-  - kind: file/ipfs
-    name: OffChainDataSource
-    mapping:
-      kind: ethereum/events
-      apiVersion: 0.0.7
-      language: wasm/assemblyscript
-      entities:
-        - SpawnTestEntity
-      abis:
-        - name: Contract
-          file: ./abis/Contract.abi
-      handler: handleSpawnedTest
-      file: ./src/mapping.ts
\ No newline at end of file
diff --git a/tests/runner-tests/file-link-resolver/abis/Contract.abi b/tests/runner-tests/file-link-resolver/abis/Contract.abi
new file mode 100644
index 00000000000..9d9f56b9263
--- /dev/null
+++ b/tests/runner-tests/file-link-resolver/abis/Contract.abi
@@ -0,0 +1,15 @@
+[
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "string",
+                "name": "testCommand",
+                "type": "string"
+            }
+        ],
+        "name": "TestEvent",
+        "type": "event"
+    }
+]
diff --git a/tests/runner-tests/file-link-resolver/package.json b/tests/runner-tests/file-link-resolver/package.json
new file mode 100644
index 00000000000..a1bd68d3f04
--- /dev/null
+++ b/tests/runner-tests/file-link-resolver/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "file-link-resolver",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/file-link-resolver --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-cli": "0.60.0",
+    "@graphprotocol/graph-ts": "0.31.0"
+  }
+}
diff --git a/tests/runner-tests/file-link-resolver/schema.graphql b/tests/runner-tests/file-link-resolver/schema.graphql
new file mode 100644
index 00000000000..2eec3606b65
--- /dev/null
+++ b/tests/runner-tests/file-link-resolver/schema.graphql
@@ -0,0 +1,5 @@
+type Block @entity {
+  id: ID!
+  number: BigInt!
+  hash: Bytes!
+}
\ No newline at end of file
diff --git a/tests/runner-tests/file-link-resolver/src/mapping.ts b/tests/runner-tests/file-link-resolver/src/mapping.ts
new file mode 100644
index 00000000000..ecce2ff9de5
--- /dev/null
+++ b/tests/runner-tests/file-link-resolver/src/mapping.ts
@@ -0,0 +1,11 @@
+import { ethereum, log } from "@graphprotocol/graph-ts";
+import { Block } from "../generated/schema";
+
+export function handleBlock(block: ethereum.Block): void {
+  log.info("Processing block: {}", [block.number.toString()]);
+  
+  let blockEntity = new Block(block.number.toString());
+  blockEntity.number = block.number;
+  blockEntity.hash = block.hash;
+  blockEntity.save();
+}
diff --git a/tests/runner-tests/file-link-resolver/subgraph.yaml b/tests/runner-tests/file-link-resolver/subgraph.yaml
new file mode 100644
index 00000000000..4a50915beb4
--- /dev/null
+++ b/tests/runner-tests/file-link-resolver/subgraph.yaml
@@ -0,0 +1,22 @@
+specVersion: 0.0.8
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "0x0000000000000000000000000000000000000000"
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - Block
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlock
+      file: ./src/mapping.ts
diff --git a/tests/runner-tests/package.json b/tests/runner-tests/package.json
deleted file mode 100644
index ea25cc3f6f0..00000000000
--- a/tests/runner-tests/package.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "private": true,
-  "workspaces": [
-    "*"
-  ]
-}
diff --git a/tests/runner-tests/skip-duplicates/abis/Contract.abi b/tests/runner-tests/skip-duplicates/abis/Contract.abi
new file mode 100644
index 00000000000..9d9f56b9263
--- /dev/null
+++ b/tests/runner-tests/skip-duplicates/abis/Contract.abi
@@ -0,0 +1,15 @@
+[
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "internalType": "string",
+                "name": "testCommand",
+                "type": "string"
+            }
+        ],
+        "name": "TestEvent",
+        "type": "event"
+    }
+]
diff --git a/tests/runner-tests/skip-duplicates/package.json b/tests/runner-tests/skip-duplicates/package.json
new file mode 100644
index 00000000000..da0ba3e3e87
--- /dev/null
+++ b/tests/runner-tests/skip-duplicates/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "skip-duplicates",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/skip-duplicates --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-cli": "0.60.0",
+    "@graphprotocol/graph-ts": "0.31.0"
+  }
+}
diff --git a/tests/runner-tests/skip-duplicates/schema.graphql b/tests/runner-tests/skip-duplicates/schema.graphql
new file mode 100644
index 00000000000..94c5a2862d0
--- /dev/null
+++ b/tests/runner-tests/skip-duplicates/schema.graphql
@@ -0,0 +1,4 @@
+type Ping @entity(immutable: true, skipDuplicates: true) {
+  id: ID!
+  value: String!
+}
diff --git a/tests/runner-tests/skip-duplicates/src/mapping.ts b/tests/runner-tests/skip-duplicates/src/mapping.ts
new file mode 100644
index 00000000000..bf756595b5d
--- /dev/null
+++ b/tests/runner-tests/skip-duplicates/src/mapping.ts
@@ -0,0 +1,8 @@
+import { ethereum } from "@graphprotocol/graph-ts";
+import { Ping } from "../generated/schema";
+
+export function handleBlock(block: ethereum.Block): void {
+  let entity = new Ping("duplicate-entity");
+  entity.value = "ping";
+  entity.save();
+}
diff --git a/tests/runner-tests/skip-duplicates/subgraph.yaml b/tests/runner-tests/skip-duplicates/subgraph.yaml
new file mode 100644
index 00000000000..068301105c2
--- /dev/null
+++ b/tests/runner-tests/skip-duplicates/subgraph.yaml
@@ -0,0 +1,25 @@
+specVersion: 0.0.8
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "0x0000000000000000000000000000000000000000"
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - Ping
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlock
+          filter:
+            kind: polling
+            every: 1
+      file: ./src/mapping.ts
diff --git a/tests/runner-tests/substreams/.gitignore b/tests/runner-tests/substreams/.gitignore
deleted file mode 100644
index 37e5bb836a4..00000000000
--- a/tests/runner-tests/substreams/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-target/
-.idea
-src/pb/
-node_modules/
\ No newline at end of file
diff --git a/tests/runner-tests/substreams/Cargo.lock b/tests/runner-tests/substreams/Cargo.lock
deleted file mode 100644
index e8575b5b430..00000000000
--- a/tests/runner-tests/substreams/Cargo.lock
+++ /dev/null
@@ -1,980 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "aho-corasick"
-version = "0.7.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "anyhow"
-version = "1.0.68"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cb2f989d18dd141ab8ae82f64d1a8cdd37e0840f73a406896cf5e99502fab61"
-
-[[package]]
-name = "arrayvec"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
-
-[[package]]
-name = "autocfg"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
-
-[[package]]
-name = "base64"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
-
-[[package]]
-name = "bigdecimal"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6aaf33151a6429fe9211d1b276eafdf70cdff28b071e76c0b0e1503221ea3744"
-dependencies = [
- "num-bigint",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "byte-slice-cast"
-version = "1.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
-
-[[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
-[[package]]
-name = "bytes"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfb24e866b15a1af2a1b663f10c6b6b8f397a84aadb828f12e5b289ec23a3a3c"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crunchy"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
-dependencies = [
- "block-buffer",
- "crypto-common",
-]
-
-[[package]]
-name = "either"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
-
-[[package]]
-name = "ethabi"
-version = "17.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4966fba78396ff92db3b817ee71143eccd98acf0f876b8d600e585a670c5d1b"
-dependencies = [
- "ethereum-types",
- "hex",
- "once_cell",
- "regex",
- "serde",
- "serde_json",
- "sha3",
- "thiserror",
- "uint",
-]
-
-[[package]]
-name = "ethbloom"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11da94e443c60508eb62cf256243a64da87304c2802ac2528847f79d750007ef"
-dependencies = [
- "crunchy",
- "fixed-hash",
- "impl-rlp",
- "impl-serde",
- "tiny-keccak",
-]
-
-[[package]]
-name = "ethereum-types"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2827b94c556145446fcce834ca86b7abf0c39a805883fe20e72c5bfdb5a0dc6"
-dependencies = [
- "ethbloom",
- "fixed-hash",
- "impl-rlp",
- "impl-serde",
- "primitive-types",
- "uint",
-]
-
-[[package]]
-name = "fastrand"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
-dependencies = [
- "instant",
-]
-
-[[package]]
-name = "fixed-hash"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfcf0ed7fe52a17a03854ec54a9f76d6d84508d1c0e66bc1793301c73fc8493c"
-dependencies = [
- "byteorder",
- "rand",
- "rustc-hex",
- "static_assertions",
-]
-
-[[package]]
-name = "fixedbitset"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "generic-array"
-version = "0.14.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
-dependencies = [
- "typenum",
- "version_check",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
-[[package]]
-name = "heck"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
-
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
-[[package]]
-name = "hex-literal"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
-
-[[package]]
-name = "impl-codec"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba6a270039626615617f3f36d15fc827041df3b78c439da2cadfa47455a77f2f"
-dependencies = [
- "parity-scale-codec",
-]
-
-[[package]]
-name = "impl-rlp"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f28220f89297a075ddc7245cd538076ee98b01f2a9c23a53a4f1105d5a322808"
-dependencies = [
- "rlp",
-]
-
-[[package]]
-name = "impl-serde"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4551f042f3438e64dbd6226b20527fc84a6e1fe65688b58746a2f53623f25f5c"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "impl-trait-for-tuples"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "indexmap"
-version = "1.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
-dependencies = [
- "autocfg",
- "hashbrown",
-]
-
-[[package]]
-name = "instant"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "itoa"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"
-
-[[package]]
-name = "keccak"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3afef3b6eff9ce9d8ff9b3601125eec7f0c8cbac7abd14f355d053fa56c98768"
-dependencies = [
- "cpufeatures",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
-[[package]]
-name = "libc"
-version = "0.2.139"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
-
-[[package]]
-name = "log"
-version = "0.4.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "memchr"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
-
-[[package]]
-name = "multimap"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
-
-[[package]]
-name = "num-bigint"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-integer"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
-dependencies = [
- "autocfg",
- "num-traits",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"
-
-[[package]]
-name = "pad"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2ad9b889f1b12e0b9ee24db044b5129150d5eada288edc800f789928dc8c0e3"
-dependencies = [
- "unicode-width",
-]
-
-[[package]]
-name = "parity-scale-codec"
-version = "3.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ab01d0f889e957861bc65888d5ccbe82c158d0270136ba46820d43837cdf72"
-dependencies = [
- "arrayvec",
- "bitvec",
- "byte-slice-cast",
- "impl-trait-for-tuples",
- "parity-scale-codec-derive",
- "serde",
-]
-
-[[package]]
-name = "parity-scale-codec-derive"
-version = "3.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b26a931f824dd4eca30b3e43bb4f31cd5f0d3a403c5f5ff27106b805bfde7b"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "petgraph"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5014253a1331579ce62aa67443b4a658c5e7dd03d4bc6d302b94474888143"
-dependencies = [
- "fixedbitset",
- "indexmap",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
-
-[[package]]
-name = "prettyplease"
-version = "0.1.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e97e3215779627f01ee256d2fad52f3d95e8e1c11e9fc6fd08f7cd455d5d5c78"
-dependencies = [
- "proc-macro2",
- "syn",
-]
-
-[[package]]
-name = "primitive-types"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e28720988bff275df1f51b171e1b2a18c30d194c4d2b61defdacecd625a5d94a"
-dependencies = [
- "fixed-hash",
- "impl-codec",
- "impl-rlp",
- "impl-serde",
- "uint",
-]
-
-[[package]]
-name = "proc-macro-crate"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eda0fc3b0fb7c975631757e14d9049da17374063edb6ebbcbc54d880d4fe94e9"
-dependencies = [
- "once_cell",
- "thiserror",
- "toml",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.50"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ef7d57beacfaf2d8aee5937dab7b7f28de3cb8b1828479bb5de2a7106f2bae2"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "prost"
-version = "0.11.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd"
-dependencies = [
- "bytes",
- "prost-derive",
-]
-
-[[package]]
-name = "prost-build"
-version = "0.11.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3f8ad728fb08fe212df3c05169e940fbb6d9d16a877ddde14644a983ba2012e"
-dependencies = [
- "bytes",
- "heck",
- "itertools",
- "lazy_static",
- "log",
- "multimap",
- "petgraph",
- "prettyplease",
- "prost",
- "prost-types",
- "regex",
- "syn",
- "tempfile",
- "which",
-]
-
-[[package]]
-name = "prost-derive"
-version = "0.11.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4"
-dependencies = [
- "anyhow",
- "itertools",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "prost-types"
-version = "0.11.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "213622a1460818959ac1181aaeb2dc9c7f63df720db7d788b3e24eacd1983e13"
-dependencies = [
- "prost",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "regex"
-version = "1.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
-
-[[package]]
-name = "remove_dir_all"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "rlp"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb919243f34364b6bd2fc10ef797edbfa75f33c252e7998527479c6d6b47e1ec"
-dependencies = [
- "bytes",
- "rustc-hex",
-]
-
-[[package]]
-name = "rustc-hex"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6"
-
-[[package]]
-name = "ryu"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde"
-
-[[package]]
-name = "serde"
-version = "1.0.152"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.152"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.91"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877c235533714907a8c2464236f5c4b2a17262ef1bd71f38f35ea592c8da6883"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "sha3"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdf0c33fae925bdc080598b84bc15c55e7b9a4a43b3c704da051f977469691c9"
-dependencies = [
- "digest",
- "keccak",
-]
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "substreams"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af972e374502cdfc9998132f5343848d1c58f27a295dc061a89804371f408a46"
-dependencies = [
- "anyhow",
- "bigdecimal",
- "hex",
- "hex-literal",
- "num-bigint",
- "num-traits",
- "pad",
- "prost",
- "prost-build",
- "prost-types",
- "substreams-macro",
- "thiserror",
-]
-
-[[package]]
-name = "substreams-entity-change"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d423d0c12a9284a3d6d4ec288dbc9bfec3d55f9056098ba91a6dcfa64fb3889e"
-dependencies = [
- "base64",
- "prost",
- "prost-types",
- "substreams",
-]
-
-[[package]]
-name = "substreams-ethereum"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78effc18ed321399fe15ec082806e96a58d213f79741d078c1cd26dd6dd53025"
-dependencies = [
- "getrandom",
- "num-bigint",
- "substreams",
- "substreams-ethereum-abigen",
- "substreams-ethereum-core",
- "substreams-ethereum-derive",
-]
-
-[[package]]
-name = "substreams-ethereum-abigen"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97a176f39a6e09553c17a287edacd1854e5686fd20ffea3c9655dfc44d94b35e"
-dependencies = [
- "anyhow",
- "ethabi",
- "heck",
- "hex",
- "prettyplease",
- "proc-macro2",
- "quote",
- "substreams-ethereum-core",
- "syn",
-]
-
-[[package]]
-name = "substreams-ethereum-core"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db4700cfe408b75634a3c6b3a0caf7bddba4879601d2085c811485ea54cbde2d"
-dependencies = [
- "bigdecimal",
- "ethabi",
- "getrandom",
- "num-bigint",
- "prost",
- "prost-build",
- "prost-types",
- "substreams",
-]
-
-[[package]]
-name = "substreams-ethereum-derive"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40d6d278d926fe3f0775d996ee2b5e1dc822c1b4bf4f7bf07c7fbb5bce6c79a9"
-dependencies = [
- "ethabi",
- "heck",
- "hex",
- "num-bigint",
- "proc-macro2",
- "quote",
- "substreams-ethereum-abigen",
- "syn",
-]
-
-[[package]]
-name = "substreams-ethereum-quickstart"
-version = "1.0.0"
-dependencies = [
- "base64",
- "prost",
- "prost-types",
- "substreams",
- "substreams-entity-change",
- "substreams-ethereum",
-]
-
-[[package]]
-name = "substreams-macro"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6521ccd011a4c3f52cd3c31fc7400733e4feba2094e0e0e6354adca25b2b3f37"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "thiserror",
-]
-
-[[package]]
-name = "syn"
-version = "1.0.107"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "tempfile"
-version = "3.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
-dependencies = [
- "cfg-if",
- "fastrand",
- "libc",
- "redox_syscall",
- "remove_dir_all",
- "winapi",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.38"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.38"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "tiny-keccak"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
-dependencies = [
- "crunchy",
-]
-
-[[package]]
-name = "toml"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "typenum"
-version = "1.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
-
-[[package]]
-name = "uint"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76f64bba2c53b04fcab63c01a7d7427eadc821e3bc48c34dc9ba29c501164b52"
-dependencies = [
- "byteorder",
- "crunchy",
- "hex",
- "static_assertions",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"
-
-[[package]]
-name = "unicode-width"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
-
-[[package]]
-name = "version_check"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "which"
-version = "4.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269"
-dependencies = [
- "either",
- "libc",
- "once_cell",
-]
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "wyz"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
diff --git a/tests/runner-tests/substreams/Cargo.toml b/tests/runner-tests/substreams/Cargo.toml
deleted file mode 100644
index 0467917affa..00000000000
--- a/tests/runner-tests/substreams/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "substreams-ethereum-quickstart"
-version = "1.0.0"
-edition = "2021"
-
-[lib]
-name = "substreams"
-crate-type = ["cdylib"]
-
-[dependencies]
-substreams = "0.5"
-substreams-ethereum = "0.9"
-substreams-entity-change = "1.3"
-prost = "0.11"
-prost-types = "0.11"
-base64 = "0.13"
-
-[profile.release]
-lto = true
-opt-level = 's'
-strip = "debuginfo"
diff --git a/tests/runner-tests/substreams/README.md b/tests/runner-tests/substreams/README.md
deleted file mode 100644
index 4d032b875e5..00000000000
--- a/tests/runner-tests/substreams/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Substreams-powered subgraph: tracking contract creation
-
-A basic Substreams-powered subgraph, including the Substreams definition. This example detects new
-contract deployments on Ethereum, tracking the creation block and timestamp. There is a
-demonstration of the Graph Node integration, using `substreams_entity_change` types and helpers.
-
-## Prerequisites
-
-This
-[requires the dependencies necessary for local Substreams development](https://substreams.streamingfast.io/developers-guide/installation-requirements).
-
-## Quickstart
-
-```
-yarn install # install graph-cli
-yarn substreams:prepare # build and package the substreams module
-yarn subgraph:build # build the subgraph
-yarn subgraph:deploy # deploy the subgraph
-```
diff --git a/tests/runner-tests/substreams/package.json b/tests/runner-tests/substreams/package.json
deleted file mode 100644
index 153b6ba1947..00000000000
--- a/tests/runner-tests/substreams/package.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "name": "substreams",
-  "version": "0.1.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/graphprotocol/graph-tooling",
-    "directory": "examples/substreams-powered-subgraph"
-  },
-  "private": true,
-  "scripts": {
-    "codegen": "graph codegen",
-    "deploy": "graph deploy",
-    "create:test": "graph create test/substreams --node $GRAPH_NODE_ADMIN_URI",
-    "deploy:test": "graph deploy test/substreams --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI",
-    "subgraph:build": "graph build",
-    "substreams:build": "cargo build --target wasm32-unknown-unknown --release",
-    "substreams:clean": "rm -rf ./target && rm -rf ./src/pb",
-    "substreams:package": "substreams pack ./substreams.yaml",
-    "substreams:prepare": "yarn substreams:protogen && yarn substreams:build && yarn substreams:package",
-    "substreams:protogen": "substreams protogen ./substreams.yaml --exclude-paths='sf/substreams,google'",
-    "substreams:stream": "substreams run -e mainnet.eth.streamingfast.io:443 substreams.yaml graph_out -s 12292922 -t +10"
-  },
-  "devDependencies": {
-    "@graphprotocol/graph-cli": "0.61.0"
-  }
-}
diff --git a/tests/runner-tests/substreams/proto/example.proto b/tests/runner-tests/substreams/proto/example.proto
deleted file mode 100644
index ac4d80b2452..00000000000
--- a/tests/runner-tests/substreams/proto/example.proto
+++ /dev/null
@@ -1,14 +0,0 @@
-syntax = "proto3";
-
-package example;
-
-message Contracts {
-  repeated Contract contracts = 1;
-}
-
-message Contract {
-    string address = 1;
-    uint64 blockNumber = 2;
-    string timestamp = 3;
-    uint64 ordinal = 4;
-}
\ No newline at end of file
diff --git a/tests/runner-tests/substreams/rust-toolchain.toml b/tests/runner-tests/substreams/rust-toolchain.toml
deleted file mode 100644
index f4d9bf6341c..00000000000
--- a/tests/runner-tests/substreams/rust-toolchain.toml
+++ /dev/null
@@ -1,4 +0,0 @@
-[toolchain]
-channel = "1.72"
-components = ["rustfmt"]
-targets = ["wasm32-unknown-unknown"]
diff --git a/tests/runner-tests/substreams/schema.graphql b/tests/runner-tests/substreams/schema.graphql
deleted file mode 100644
index 7b1c7d114ed..00000000000
--- a/tests/runner-tests/substreams/schema.graphql
+++ /dev/null
@@ -1,9 +0,0 @@
-type Contract @entity {
-  id: ID!
-
-  "The timestamp when the contract was deployed"
-  timestamp: String!
-
-  "The block number of the contract deployment"
-  blockNumber: BigInt!
-}
diff --git a/tests/runner-tests/substreams/src/lib.rs b/tests/runner-tests/substreams/src/lib.rs
deleted file mode 100644
index 0127d9aadd9..00000000000
--- a/tests/runner-tests/substreams/src/lib.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-mod pb;
-
-use pb::example::{Contract, Contracts};
-
-use substreams::Hex;
-use substreams_entity_change::pb::entity::EntityChanges;
-use substreams_entity_change::tables::Tables;
-use substreams_ethereum::pb::eth;
-
-#[substreams::handlers::map]
-fn map_contract(block: eth::v2::Block) -> Result<Contracts, substreams::errors::Error> {
-    let contracts = block
-        .calls()
-        .filter(|view| !view.call.state_reverted)
-        .filter(|view| view.call.call_type == eth::v2::CallType::Create as i32)
-        .map(|view| Contract {
-            address: format!("0x{}", Hex(&view.call.address)),
-            block_number: block.number,
-            timestamp: block.timestamp_seconds().to_string(),
-            ordinal: view.call.begin_ordinal,
-        })
-        .collect();
-
-    Ok(Contracts { contracts })
-}
-
-#[substreams::handlers::map]
-pub fn graph_out(contracts: Contracts) -> Result<EntityChanges, substreams::errors::Error> {
-    // hash map of name to a table
-    let mut tables = Tables::new();
-
-    for contract in contracts.contracts.into_iter() {
-        tables
-            .create_row("Contract", contract.address)
-            .set("timestamp", contract.timestamp)
-            .set("blockNumber", contract.block_number);
-    }
-
-    Ok(tables.to_entity_changes())
-}
diff --git a/tests/runner-tests/substreams/subgraph.yaml b/tests/runner-tests/substreams/subgraph.yaml
deleted file mode 100644
index 377e326c568..00000000000
--- a/tests/runner-tests/substreams/subgraph.yaml
+++ /dev/null
@@ -1,16 +0,0 @@
-specVersion: 0.0.4
-description: Ethereum Contract Tracking Subgraph (powered by Substreams)
-repository: https://github.com/graphprotocol/graph-tooling
-schema:
-  file: schema.graphql
-dataSources:
-  - kind: substreams
-    name: substream_test
-    network: test
-    source:
-      package:
-        moduleName: graph_out
-        file: substreams-test-v1.0.1.spkg
-    mapping:
-      kind: substreams/graph-entities
-      apiVersion: 0.0.6
diff --git a/tests/runner-tests/substreams/substreams-test-v1.0.1.spkg b/tests/runner-tests/substreams/substreams-test-v1.0.1.spkg
deleted file mode 100644
index 641e2786a4a..00000000000
Binary files a/tests/runner-tests/substreams/substreams-test-v1.0.1.spkg and /dev/null differ
diff --git a/tests/runner-tests/substreams/substreams.yaml b/tests/runner-tests/substreams/substreams.yaml
deleted file mode 100644
index 25704378334..00000000000
--- a/tests/runner-tests/substreams/substreams.yaml
+++ /dev/null
@@ -1,33 +0,0 @@
-specVersion: v0.1.0
-package:
-  name: 'substreams_test' # the name to be used in the .spkg
-  version: v1.0.1 # the version to use when creating the .spkg
-
-imports: # dependencies
-  entity: https://github.com/streamingfast/substreams-entity-change/releases/download/v0.2.1/substreams-entity-change-v0.2.1.spkg
-
-protobuf: # specifies custom types for use by Substreams modules
-  files:
-    - example.proto
-  importPaths:
-    - ./proto
-
-binaries:
-  default:
-    type: wasm/rust-v1
-    file: ./target/wasm32-unknown-unknown/release/substreams.wasm
-
-modules: # specify modules with their inputs and outputs.
-  - name: map_contract
-    kind: map
-    inputs:
-      - source: sf.ethereum.type.v2.Block
-    output:
-      type: proto:test.Contracts
-
-  - name: graph_out
-    kind: map
-    inputs:
-      - map: map_contract
-    output:
-      type: proto:substreams.entity.v1.EntityChanges # this type can be consumed by Graph Node
diff --git a/tests/runner-tests/typename/package.json b/tests/runner-tests/typename/package.json
index 67cfbaefd90..047227cdbe7 100644
--- a/tests/runner-tests/typename/package.json
+++ b/tests/runner-tests/typename/package.json
@@ -1,9 +1,9 @@
 {
   "name": "typename",
-  "version": "0.1.0",
+  "version": "0.0.0",
+  "private": true,
   "scripts": {
     "codegen": "graph codegen --skip-migrations",
-    "create:test": "graph create test/typename --node $GRAPH_NODE_ADMIN_URI",
     "deploy:test": "graph deploy test/typename --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
   },
   "devDependencies": {
diff --git a/tests/runner-tests/yarn.lock b/tests/runner-tests/yarn.lock
deleted file mode 100644
index f88aa550f70..00000000000
--- a/tests/runner-tests/yarn.lock
+++ /dev/null
@@ -1,3897 +0,0 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
-
-
-"@babel/code-frame@^7.0.0":
-  version "7.18.6"
-  resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz"
-  integrity sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==
-  dependencies:
-    "@babel/highlight" "^7.18.6"
-
-"@babel/helper-validator-identifier@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.5.tgz#9544ef6a33999343c8740fa51350f30eeaaaf193"
-  integrity sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==
-
-"@babel/highlight@^7.18.6":
-  version "7.22.13"
-  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.22.13.tgz#9cda839e5d3be9ca9e8c26b6dd69e7548f0cbf16"
-  integrity sha512-C/BaXcnnvBCmHTpz/VGZ8jgtE2aYlW4hxDhseJAWZb7gqGM/qtCK6iZUb0TyKFf7BOUsBH7Q7fkRsDRhg1XklQ==
-  dependencies:
-    "@babel/helper-validator-identifier" "^7.22.5"
-    chalk "^2.4.2"
-    js-tokens "^4.0.0"
-
-"@cspotcode/source-map-support@^0.8.0":
-  version "0.8.1"
-  resolved "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz"
-  integrity sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==
-  dependencies:
-    "@jridgewell/trace-mapping" "0.3.9"
-
-"@ethersproject/abi@5.0.7":
-  version "5.0.7"
-  resolved "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.0.7.tgz"
-  integrity sha512-Cqktk+hSIckwP/W8O47Eef60VwmoSC/L3lY0+dIBhQPCNn9E4V7rwmm2aFrNRRDJfFlGuZ1khkQUOc3oBX+niw==
-  dependencies:
-    "@ethersproject/address" "^5.0.4"
-    "@ethersproject/bignumber" "^5.0.7"
-    "@ethersproject/bytes" "^5.0.4"
-    "@ethersproject/constants" "^5.0.4"
-    "@ethersproject/hash" "^5.0.4"
-    "@ethersproject/keccak256" "^5.0.3"
-    "@ethersproject/logger" "^5.0.5"
-    "@ethersproject/properties" "^5.0.3"
-    "@ethersproject/strings" "^5.0.4"
-
-"@ethersproject/abstract-provider@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.7.0.tgz"
-  integrity sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw==
-  dependencies:
-    "@ethersproject/bignumber" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/networks" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-    "@ethersproject/transactions" "^5.7.0"
-    "@ethersproject/web" "^5.7.0"
-
-"@ethersproject/abstract-signer@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.7.0.tgz"
-  integrity sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ==
-  dependencies:
-    "@ethersproject/abstract-provider" "^5.7.0"
-    "@ethersproject/bignumber" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-
-"@ethersproject/address@^5.0.4", "@ethersproject/address@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/address/-/address-5.7.0.tgz"
-  integrity sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==
-  dependencies:
-    "@ethersproject/bignumber" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/keccak256" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/rlp" "^5.7.0"
-
-"@ethersproject/base64@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.7.0.tgz"
-  integrity sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-
-"@ethersproject/bignumber@^5.0.7", "@ethersproject/bignumber@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.7.0.tgz"
-  integrity sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    bn.js "^5.2.1"
-
-"@ethersproject/bytes@^5.0.4", "@ethersproject/bytes@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.7.0.tgz"
-  integrity sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A==
-  dependencies:
-    "@ethersproject/logger" "^5.7.0"
-
-"@ethersproject/constants@^5.0.4", "@ethersproject/constants@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.7.0.tgz"
-  integrity sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==
-  dependencies:
-    "@ethersproject/bignumber" "^5.7.0"
-
-"@ethersproject/hash@^5.0.4":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.7.0.tgz"
-  integrity sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==
-  dependencies:
-    "@ethersproject/abstract-signer" "^5.7.0"
-    "@ethersproject/address" "^5.7.0"
-    "@ethersproject/base64" "^5.7.0"
-    "@ethersproject/bignumber" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/keccak256" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-    "@ethersproject/strings" "^5.7.0"
-
-"@ethersproject/keccak256@^5.0.3", "@ethersproject/keccak256@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.7.0.tgz"
-  integrity sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-    js-sha3 "0.8.0"
-
-"@ethersproject/logger@^5.0.5", "@ethersproject/logger@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.7.0.tgz"
-  integrity sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==
-
-"@ethersproject/networks@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.7.0.tgz"
-  integrity sha512-MG6oHSQHd4ebvJrleEQQ4HhVu8Ichr0RDYEfHzsVAVjHNM+w36x9wp9r+hf1JstMXtseXDtkiVoARAG6M959AA==
-  dependencies:
-    "@ethersproject/logger" "^5.7.0"
-
-"@ethersproject/properties@^5.0.3", "@ethersproject/properties@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.7.0.tgz"
-  integrity sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw==
-  dependencies:
-    "@ethersproject/logger" "^5.7.0"
-
-"@ethersproject/rlp@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.7.0.tgz"
-  integrity sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-
-"@ethersproject/signing-key@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.7.0.tgz"
-  integrity sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-    bn.js "^5.2.1"
-    elliptic "6.5.4"
-    hash.js "1.1.7"
-
-"@ethersproject/strings@^5.0.4", "@ethersproject/strings@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.7.0.tgz"
-  integrity sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==
-  dependencies:
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/constants" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-
-"@ethersproject/transactions@^5.7.0":
-  version "5.7.0"
-  resolved "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.7.0.tgz"
-  integrity sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ==
-  dependencies:
-    "@ethersproject/address" "^5.7.0"
-    "@ethersproject/bignumber" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/constants" "^5.7.0"
-    "@ethersproject/keccak256" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-    "@ethersproject/rlp" "^5.7.0"
-    "@ethersproject/signing-key" "^5.7.0"
-
-"@ethersproject/web@^5.7.0":
-  version "5.7.1"
-  resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.7.1.tgz#de1f285b373149bee5928f4eb7bcb87ee5fbb4ae"
-  integrity sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w==
-  dependencies:
-    "@ethersproject/base64" "^5.7.0"
-    "@ethersproject/bytes" "^5.7.0"
-    "@ethersproject/logger" "^5.7.0"
-    "@ethersproject/properties" "^5.7.0"
-    "@ethersproject/strings" "^5.7.0"
-
-"@float-capital/float-subgraph-uncrashable@^0.0.0-alpha.4":
-  version "0.0.0-internal-testing.5"
-  resolved "https://registry.npmjs.org/@float-capital/float-subgraph-uncrashable/-/float-subgraph-uncrashable-0.0.0-internal-testing.5.tgz"
-  integrity sha512-yZ0H5e3EpAYKokX/AbtplzlvSxEJY7ZfpvQyDzyODkks0hakAAlDG6fQu1SlDJMWorY7bbq1j7fCiFeTWci6TA==
-  dependencies:
-    "@rescript/std" "9.0.0"
-    graphql "^16.6.0"
-    graphql-import-node "^0.0.5"
-    js-yaml "^4.1.0"
-
-"@graphprotocol/graph-cli@0.50.0":
-  version "0.50.0"
-  resolved "https://registry.npmjs.org/@graphprotocol/graph-cli/-/graph-cli-0.50.0.tgz"
-  integrity sha512-Fw46oN06ec1pf//vTPFzmyL0LRD9ed/XXfibQQClyMLfNlYAATZvz930RH3SHb2N4ZLdfKDDkY1SLgtDghtrow==
-  dependencies:
-    "@float-capital/float-subgraph-uncrashable" "^0.0.0-alpha.4"
-    "@oclif/core" "2.8.4"
-    "@whatwg-node/fetch" "^0.8.4"
-    assemblyscript "0.19.23"
-    binary-install-raw "0.0.13"
-    chalk "3.0.0"
-    chokidar "3.5.3"
-    debug "4.3.4"
-    docker-compose "0.23.19"
-    dockerode "2.5.8"
-    fs-extra "9.1.0"
-    glob "9.3.5"
-    gluegun "5.1.2"
-    graphql "15.5.0"
-    immutable "4.2.1"
-    ipfs-http-client "55.0.0"
-    jayson "4.0.0"
-    js-yaml "3.14.1"
-    prettier "1.19.1"
-    request "2.88.2"
-    semver "7.4.0"
-    sync-request "6.1.0"
-    tmp-promise "3.0.3"
-    web3-eth-abi "1.7.0"
-    which "2.0.2"
-    yaml "1.10.2"
-
-"@graphprotocol/graph-cli@0.54.0-alpha-20230727052453-1e0e6e5":
-  version "0.54.0-alpha-20230727052453-1e0e6e5"
-  resolved "https://registry.yarnpkg.com/@graphprotocol/graph-cli/-/graph-cli-0.54.0-alpha-20230727052453-1e0e6e5.tgz#7c36225484d503ab410ea03861d701dc30bc8b1e"
-  integrity sha512-pxZAJvUXHRMtPIoMTSvVyIjqrfMGCtaqWG9qdRDrLMxUKrIuGWniMKntxaFnHPlgz6OQznN9Zt8wV6uScD/4Sg==
-  dependencies:
-    "@float-capital/float-subgraph-uncrashable" "^0.0.0-alpha.4"
-    "@oclif/core" "2.8.6"
-    "@whatwg-node/fetch" "^0.8.4"
-    assemblyscript "0.19.23"
-    binary-install-raw "0.0.13"
-    chalk "3.0.0"
-    chokidar "3.5.3"
-    debug "4.3.4"
-    docker-compose "0.23.19"
-    dockerode "2.5.8"
-    fs-extra "9.1.0"
-    glob "9.3.5"
-    gluegun "5.1.2"
-    graphql "15.5.0"
-    immutable "4.2.1"
-    ipfs-http-client "55.0.0"
-    jayson "4.0.0"
-    js-yaml "3.14.1"
-    prettier "1.19.1"
-    request "2.88.2"
-    semver "7.4.0"
-    sync-request "6.1.0"
-    tmp-promise "3.0.3"
-    web3-eth-abi "1.7.0"
-    which "2.0.2"
-    yaml "1.10.2"
-
-"@graphprotocol/graph-cli@0.60.0":
-  version "0.60.0"
-  resolved "https://registry.yarnpkg.com/@graphprotocol/graph-cli/-/graph-cli-0.60.0.tgz#afcae7a966ad348886f49372d36c4ca6c35b9434"
-  integrity sha512-8tGaQJ0EzAPtkDXCAijFGoVdJXM+pKFlGxjiU31TdG5bS4cIUoSB6yWojVsFFod0yETAwf+giel/0/8sudYsDw==
-  dependencies:
-    "@float-capital/float-subgraph-uncrashable" "^0.0.0-alpha.4"
-    "@oclif/core" "2.8.6"
-    "@oclif/plugin-autocomplete" "^2.3.6"
-    "@oclif/plugin-not-found" "^2.4.0"
-    "@whatwg-node/fetch" "^0.8.4"
-    assemblyscript "0.19.23"
-    binary-install-raw "0.0.13"
-    chalk "3.0.0"
-    chokidar "3.5.3"
-    debug "4.3.4"
-    docker-compose "0.23.19"
-    dockerode "2.5.8"
-    fs-extra "9.1.0"
-    glob "9.3.5"
-    gluegun "5.1.2"
-    graphql "15.5.0"
-    immutable "4.2.1"
-    ipfs-http-client "55.0.0"
-    jayson "4.0.0"
-    js-yaml "3.14.1"
-    prettier "1.19.1"
-    request "2.88.2"
-    semver "7.4.0"
-    sync-request "6.1.0"
-    tmp-promise "3.0.3"
-    web3-eth-abi "1.7.0"
-    which "2.0.2"
-    yaml "1.10.2"
-
-"@graphprotocol/graph-cli@0.61.0":
-  version "0.61.0"
-  resolved "https://registry.yarnpkg.com/@graphprotocol/graph-cli/-/graph-cli-0.61.0.tgz#62b28e599c4a082f561d37594e34de66c4946e70"
-  integrity sha512-gc3+DioZ/K40sQCt6DsNvbqfPTc9ZysuSz3I9MJ++bD6SftaSSweWwfpPysDMzDuxvUAhLAsJ6QjBACPngT2Kw==
-  dependencies:
-    "@float-capital/float-subgraph-uncrashable" "^0.0.0-alpha.4"
-    "@oclif/core" "2.8.6"
-    "@oclif/plugin-autocomplete" "^2.3.6"
-    "@oclif/plugin-not-found" "^2.4.0"
-    "@whatwg-node/fetch" "^0.8.4"
-    assemblyscript "0.19.23"
-    binary-install-raw "0.0.13"
-    chalk "3.0.0"
-    chokidar "3.5.3"
-    debug "4.3.4"
-    docker-compose "0.23.19"
-    dockerode "2.5.8"
-    fs-extra "9.1.0"
-    glob "9.3.5"
-    gluegun "5.1.2"
-    graphql "15.5.0"
-    immutable "4.2.1"
-    ipfs-http-client "55.0.0"
-    jayson "4.0.0"
-    js-yaml "3.14.1"
-    prettier "1.19.1"
-    request "2.88.2"
-    semver "7.4.0"
-    sync-request "6.1.0"
-    tmp-promise "3.0.3"
-    web3-eth-abi "1.7.0"
-    which "2.0.2"
-    yaml "1.10.2"
-
-"@graphprotocol/graph-ts@0.30.0":
-  version "0.30.0"
-  resolved "https://registry.npmjs.org/@graphprotocol/graph-ts/-/graph-ts-0.30.0.tgz"
-  integrity sha512-h5tJqlsZXglGYM0PcBsBOqof4PT0Fr4Z3QBTYN/IjMF3VvRX2A8/bdpqaAnva+2N0uAfXXwRcwcOcW5O35yzXw==
-  dependencies:
-    assemblyscript "0.19.10"
-
-"@graphprotocol/graph-ts@0.31.0":
-  version "0.31.0"
-  resolved "https://registry.yarnpkg.com/@graphprotocol/graph-ts/-/graph-ts-0.31.0.tgz#730668c0369828b31bef81e8d9bc66b9b48e3480"
-  integrity sha512-xreRVM6ho2BtolyOh2flDkNoGZximybnzUnF53zJVp0+Ed0KnAlO1/KOCUYw06euVI9tk0c9nA2Z/D5SIQV2Rg==
-  dependencies:
-    assemblyscript "0.19.10"
-
-"@ipld/dag-cbor@^7.0.0":
-  version "7.0.3"
-  resolved "https://registry.npmjs.org/@ipld/dag-cbor/-/dag-cbor-7.0.3.tgz"
-  integrity sha512-1VVh2huHsuohdXC1bGJNE8WR72slZ9XE2T3wbBBq31dm7ZBatmKLLxrB+XAqafxfRFjv08RZmj/W/ZqaM13AuA==
-  dependencies:
-    cborg "^1.6.0"
-    multiformats "^9.5.4"
-
-"@ipld/dag-json@^8.0.1":
-  version "8.0.11"
-  resolved "https://registry.npmjs.org/@ipld/dag-json/-/dag-json-8.0.11.tgz"
-  integrity sha512-Pea7JXeYHTWXRTIhBqBlhw7G53PJ7yta3G/sizGEZyzdeEwhZRr0od5IQ0r2ZxOt1Do+2czddjeEPp+YTxDwCA==
-  dependencies:
-    cborg "^1.5.4"
-    multiformats "^9.5.4"
-
-"@ipld/dag-pb@^2.1.3":
-  version "2.1.18"
-  resolved "https://registry.npmjs.org/@ipld/dag-pb/-/dag-pb-2.1.18.tgz"
-  integrity sha512-ZBnf2fuX9y3KccADURG5vb9FaOeMjFkCrNysB0PtftME/4iCTjxfaLoNq/IAh5fTqUOMXvryN6Jyka4ZGuMLIg==
-  dependencies:
-    multiformats "^9.5.4"
-
-"@jridgewell/resolve-uri@^3.0.3":
-  version "3.1.1"
-  resolved "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz"
-  integrity sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==
-
-"@jridgewell/sourcemap-codec@^1.4.10":
-  version "1.4.15"
-  resolved "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz"
-  integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==
-
-"@jridgewell/trace-mapping@0.3.9":
-  version "0.3.9"
-  resolved "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz"
-  integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==
-  dependencies:
-    "@jridgewell/resolve-uri" "^3.0.3"
-    "@jridgewell/sourcemap-codec" "^1.4.10"
-
-"@nodelib/fs.scandir@2.1.4":
-  version "2.1.4"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.4.tgz#d4b3549a5db5de2683e0c1071ab4f140904bbf69"
-  integrity sha512-33g3pMJk3bg5nXbL/+CY6I2eJDzZAni49PfJnL5fghPTggPvBd/pFNSgJsdAgWptuFu7qq/ERvOYFlhvsLTCKA==
-  dependencies:
-    "@nodelib/fs.stat" "2.0.4"
-    run-parallel "^1.1.9"
-
-"@nodelib/fs.stat@2.0.4", "@nodelib/fs.stat@^2.0.2":
-  version "2.0.4"
-  resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.4.tgz"
-  integrity sha512-IYlHJA0clt2+Vg7bccq+TzRdJvv19c2INqBSsoOLp1je7xjtr7J26+WXR72MCdvU9q1qTzIWDfhMf+DRvQJK4Q==
-
-"@nodelib/fs.walk@^1.2.3":
-  version "1.2.6"
-  resolved "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.6.tgz"
-  integrity sha512-8Broas6vTtW4GIXTAHDoE32hnN2M5ykgCpWGbuXHQ15vEMqr23pB76e/GZcYsZCHALv50ktd24qhEyKr6wBtow==
-  dependencies:
-    "@nodelib/fs.scandir" "2.1.4"
-    fastq "^1.6.0"
-
-"@oclif/core@2.8.4":
-  version "2.8.4"
-  resolved "https://registry.npmjs.org/@oclif/core/-/core-2.8.4.tgz"
-  integrity sha512-VlFDhoAJ1RDwcpDF46wAlciWTIryapMUViACttY9GwX6Ci6Lud1awe/pC3k4jad5472XshnPQV4bHAl4a/yxpA==
-  dependencies:
-    "@types/cli-progress" "^3.11.0"
-    ansi-escapes "^4.3.2"
-    ansi-styles "^4.3.0"
-    cardinal "^2.1.1"
-    chalk "^4.1.2"
-    clean-stack "^3.0.1"
-    cli-progress "^3.12.0"
-    debug "^4.3.4"
-    ejs "^3.1.8"
-    fs-extra "^9.1.0"
-    get-package-type "^0.1.0"
-    globby "^11.1.0"
-    hyperlinker "^1.0.0"
-    indent-string "^4.0.0"
-    is-wsl "^2.2.0"
-    js-yaml "^3.14.1"
-    natural-orderby "^2.0.3"
-    object-treeify "^1.1.33"
-    password-prompt "^1.1.2"
-    semver "^7.3.7"
-    string-width "^4.2.3"
-    strip-ansi "^6.0.1"
-    supports-color "^8.1.1"
-    supports-hyperlinks "^2.2.0"
-    ts-node "^10.9.1"
-    tslib "^2.5.0"
-    widest-line "^3.1.0"
-    wordwrap "^1.0.0"
-    wrap-ansi "^7.0.0"
-
-"@oclif/core@2.8.6":
-  version "2.8.6"
-  resolved "https://registry.yarnpkg.com/@oclif/core/-/core-2.8.6.tgz#7eb6984108f471ad0d719d3c07cde14c47ab17c5"
-  integrity sha512-1QlPaHMhOORySCXkQyzjsIsy2GYTilOw3LkjeHkCgsPJQjAT4IclVytJusWktPbYNys9O+O4V23J44yomQvnBQ==
-  dependencies:
-    "@types/cli-progress" "^3.11.0"
-    ansi-escapes "^4.3.2"
-    ansi-styles "^4.3.0"
-    cardinal "^2.1.1"
-    chalk "^4.1.2"
-    clean-stack "^3.0.1"
-    cli-progress "^3.12.0"
-    debug "^4.3.4"
-    ejs "^3.1.8"
-    fs-extra "^9.1.0"
-    get-package-type "^0.1.0"
-    globby "^11.1.0"
-    hyperlinker "^1.0.0"
-    indent-string "^4.0.0"
-    is-wsl "^2.2.0"
-    js-yaml "^3.14.1"
-    natural-orderby "^2.0.3"
-    object-treeify "^1.1.33"
-    password-prompt "^1.1.2"
-    semver "^7.3.7"
-    string-width "^4.2.3"
-    strip-ansi "^6.0.1"
-    supports-color "^8.1.1"
-    supports-hyperlinks "^2.2.0"
-    ts-node "^10.9.1"
-    tslib "^2.5.0"
-    widest-line "^3.1.0"
-    wordwrap "^1.0.0"
-    wrap-ansi "^7.0.0"
-
-"@oclif/core@^2.15.0":
-  version "2.15.0"
-  resolved "https://registry.yarnpkg.com/@oclif/core/-/core-2.15.0.tgz#f27797b30a77d13279fba88c1698fc34a0bd0d2a"
-  integrity sha512-fNEMG5DzJHhYmI3MgpByTvltBOMyFcnRIUMxbiz2ai8rhaYgaTHMG3Q38HcosfIvtw9nCjxpcQtC8MN8QtVCcA==
-  dependencies:
-    "@types/cli-progress" "^3.11.0"
-    ansi-escapes "^4.3.2"
-    ansi-styles "^4.3.0"
-    cardinal "^2.1.1"
-    chalk "^4.1.2"
-    clean-stack "^3.0.1"
-    cli-progress "^3.12.0"
-    debug "^4.3.4"
-    ejs "^3.1.8"
-    get-package-type "^0.1.0"
-    globby "^11.1.0"
-    hyperlinker "^1.0.0"
-    indent-string "^4.0.0"
-    is-wsl "^2.2.0"
-    js-yaml "^3.14.1"
-    natural-orderby "^2.0.3"
-    object-treeify "^1.1.33"
-    password-prompt "^1.1.2"
-    slice-ansi "^4.0.0"
-    string-width "^4.2.3"
-    strip-ansi "^6.0.1"
-    supports-color "^8.1.1"
-    supports-hyperlinks "^2.2.0"
-    ts-node "^10.9.1"
-    tslib "^2.5.0"
-    widest-line "^3.1.0"
-    wordwrap "^1.0.0"
-    wrap-ansi "^7.0.0"
-
-"@oclif/plugin-autocomplete@^2.3.6":
-  version "2.3.10"
-  resolved "https://registry.yarnpkg.com/@oclif/plugin-autocomplete/-/plugin-autocomplete-2.3.10.tgz#787f6208cdfe10ffc68ad89e9e7f1a7ad0e8987f"
-  integrity sha512-Ow1AR8WtjzlyCtiWWPgzMyT8SbcDJFr47009riLioHa+MHX2BCDtVn2DVnN/E6b9JlPV5ptQpjefoRSNWBesmg==
-  dependencies:
-    "@oclif/core" "^2.15.0"
-    chalk "^4.1.0"
-    debug "^4.3.4"
-
-"@oclif/plugin-not-found@^2.4.0":
-  version "2.4.3"
-  resolved "https://registry.yarnpkg.com/@oclif/plugin-not-found/-/plugin-not-found-2.4.3.tgz#3d24095adb0f3876cb4bcfdfdcb775086cf6d4b5"
-  integrity sha512-nIyaR4y692frwh7wIHZ3fb+2L6XEecQwRDIb4zbEam0TvaVmBQWZoColQyWA84ljFBPZ8XWiQyTz+ixSwdRkqg==
-  dependencies:
-    "@oclif/core" "^2.15.0"
-    chalk "^4"
-    fast-levenshtein "^3.0.0"
-
-"@peculiar/asn1-schema@^2.3.6":
-  version "2.3.6"
-  resolved "https://registry.npmjs.org/@peculiar/asn1-schema/-/asn1-schema-2.3.6.tgz"
-  integrity sha512-izNRxPoaeJeg/AyH8hER6s+H7p4itk+03QCa4sbxI3lNdseQYCuxzgsuNK8bTXChtLTjpJz6NmXKA73qLa3rCA==
-  dependencies:
-    asn1js "^3.0.5"
-    pvtsutils "^1.3.2"
-    tslib "^2.4.0"
-
-"@peculiar/json-schema@^1.1.12":
-  version "1.1.12"
-  resolved "https://registry.npmjs.org/@peculiar/json-schema/-/json-schema-1.1.12.tgz"
-  integrity sha512-coUfuoMeIB7B8/NMekxaDzLhaYmp0HZNPEjYRm9goRou8UZIC3z21s0sL9AWoCw4EG876QyO3kYrc61WNF9B/w==
-  dependencies:
-    tslib "^2.0.0"
-
-"@peculiar/webcrypto@^1.4.0":
-  version "1.4.3"
-  resolved "https://registry.npmjs.org/@peculiar/webcrypto/-/webcrypto-1.4.3.tgz"
-  integrity sha512-VtaY4spKTdN5LjJ04im/d/joXuvLbQdgy5Z4DXF4MFZhQ+MTrejbNMkfZBp1Bs3O5+bFqnJgyGdPuZQflvIa5A==
-  dependencies:
-    "@peculiar/asn1-schema" "^2.3.6"
-    "@peculiar/json-schema" "^1.1.12"
-    pvtsutils "^1.3.2"
-    tslib "^2.5.0"
-    webcrypto-core "^1.7.7"
-
-"@protobufjs/aspromise@^1.1.1", "@protobufjs/aspromise@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz"
-  integrity sha1-m4sMxmPWaafY9vXQiToU00jzD78=
-
-"@protobufjs/base64@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz"
-  integrity sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==
-
-"@protobufjs/codegen@^2.0.4":
-  version "2.0.4"
-  resolved "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz"
-  integrity sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==
-
-"@protobufjs/eventemitter@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz"
-  integrity sha1-NVy8mLr61ZePntCV85diHx0Ga3A=
-
-"@protobufjs/fetch@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz"
-  integrity sha1-upn7WYYUr2VwDBYZ/wbUVLDYTEU=
-  dependencies:
-    "@protobufjs/aspromise" "^1.1.1"
-    "@protobufjs/inquire" "^1.1.0"
-
-"@protobufjs/float@^1.0.2":
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz"
-  integrity sha1-Xp4avctz/Ap8uLKR33jIy9l7h9E=
-
-"@protobufjs/inquire@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz"
-  integrity sha1-/yAOPnzyQp4tyvwRQIKOjMY48Ik=
-
-"@protobufjs/path@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz"
-  integrity sha1-bMKyDFya1q0NzP0hynZz2Nf79o0=
-
-"@protobufjs/pool@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz"
-  integrity sha1-Cf0V8tbTq/qbZbw2ZQbWrXhG/1Q=
-
-"@protobufjs/utf8@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz"
-  integrity sha1-p3c2C1s5oaLlEG+OhY8v0tBgxXA=
-
-"@rescript/std@9.0.0":
-  version "9.0.0"
-  resolved "https://registry.npmjs.org/@rescript/std/-/std-9.0.0.tgz"
-  integrity sha512-zGzFsgtZ44mgL4Xef2gOy1hrRVdrs9mcxCOOKZrIPsmbZW14yTkaF591GXxpQvjXiHtgZ/iA9qLyWH6oSReIxQ==
-
-"@tsconfig/node10@^1.0.7":
-  version "1.0.9"
-  resolved "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz"
-  integrity sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==
-
-"@tsconfig/node12@^1.0.7":
-  version "1.0.11"
-  resolved "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz"
-  integrity sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==
-
-"@tsconfig/node14@^1.0.0":
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz"
-  integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==
-
-"@tsconfig/node16@^1.0.2":
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz"
-  integrity sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==
-
-"@types/bn.js@^5.1.0":
-  version "5.1.0"
-  resolved "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.0.tgz"
-  integrity sha512-QSSVYj7pYFN49kW77o2s9xTCwZ8F2xLbjLLSEVh8D2F4JUhZtPAGOFLTD+ffqksBx/u4cE/KImFjyhqCjn/LIA==
-  dependencies:
-    "@types/node" "*"
-
-"@types/cli-progress@^3.11.0":
-  version "3.11.0"
-  resolved "https://registry.npmjs.org/@types/cli-progress/-/cli-progress-3.11.0.tgz"
-  integrity sha512-XhXhBv1R/q2ahF3BM7qT5HLzJNlIL0wbcGyZVjqOTqAybAnsLisd7gy1UCyIqpL+5Iv6XhlSyzjLCnI2sIdbCg==
-  dependencies:
-    "@types/node" "*"
-
-"@types/concat-stream@^1.6.0":
-  version "1.6.1"
-  resolved "https://registry.npmjs.org/@types/concat-stream/-/concat-stream-1.6.1.tgz"
-  integrity sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==
-  dependencies:
-    "@types/node" "*"
-
-"@types/connect@^3.4.33":
-  version "3.4.35"
-  resolved "https://registry.npmjs.org/@types/connect/-/connect-3.4.35.tgz"
-  integrity sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ==
-  dependencies:
-    "@types/node" "*"
-
-"@types/form-data@0.0.33":
-  version "0.0.33"
-  resolved "https://registry.npmjs.org/@types/form-data/-/form-data-0.0.33.tgz"
-  integrity sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw==
-  dependencies:
-    "@types/node" "*"
-
-"@types/long@^4.0.1":
-  version "4.0.2"
-  resolved "https://registry.npmjs.org/@types/long/-/long-4.0.2.tgz"
-  integrity sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==
-
-"@types/minimatch@^3.0.4":
-  version "3.0.5"
-  resolved "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.5.tgz"
-  integrity sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ==
-
-"@types/node@*":
-  version "18.7.11"
-  resolved "https://registry.npmjs.org/@types/node/-/node-18.7.11.tgz"
-  integrity sha512-KZhFpSLlmK/sdocfSAjqPETTMd0ug6HIMIAwkwUpU79olnZdQtMxpQP+G1wDzCH7na+FltSIhbaZuKdwZ8RDrw==
-
-"@types/node@>=13.7.0":
-  version "18.16.3"
-  resolved "https://registry.npmjs.org/@types/node/-/node-18.16.3.tgz"
-  integrity sha512-OPs5WnnT1xkCBiuQrZA4+YAV4HEJejmHneyraIaxsbev5yCEr6KMwINNFP9wQeFIw8FWcoTqF3vQsa5CDaI+8Q==
-
-"@types/node@^10.0.3":
-  version "10.17.60"
-  resolved "https://registry.npmjs.org/@types/node/-/node-10.17.60.tgz"
-  integrity sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==
-
-"@types/node@^12.12.54":
-  version "12.20.55"
-  resolved "https://registry.npmjs.org/@types/node/-/node-12.20.55.tgz"
-  integrity sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==
-
-"@types/node@^8.0.0":
-  version "8.10.66"
-  resolved "https://registry.npmjs.org/@types/node/-/node-8.10.66.tgz"
-  integrity sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw==
-
-"@types/parse-json@^4.0.0":
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.0.tgz"
-  integrity sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA==
-
-"@types/pbkdf2@^3.0.0":
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/@types/pbkdf2/-/pbkdf2-3.1.0.tgz"
-  integrity sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ==
-  dependencies:
-    "@types/node" "*"
-
-"@types/qs@^6.2.31":
-  version "6.9.7"
-  resolved "https://registry.npmjs.org/@types/qs/-/qs-6.9.7.tgz"
-  integrity sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw==
-
-"@types/secp256k1@^4.0.1":
-  version "4.0.3"
-  resolved "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.3.tgz"
-  integrity sha512-Da66lEIFeIz9ltsdMZcpQvmrmmoqrfju8pm1BH8WbYjZSwUgCwXLb9C+9XYogwBITnbsSaMdVPb2ekf7TV+03w==
-  dependencies:
-    "@types/node" "*"
-
-"@types/ws@^7.4.4":
-  version "7.4.7"
-  resolved "https://registry.npmjs.org/@types/ws/-/ws-7.4.7.tgz"
-  integrity sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==
-  dependencies:
-    "@types/node" "*"
-
-"@whatwg-node/events@^0.0.3":
-  version "0.0.3"
-  resolved "https://registry.npmjs.org/@whatwg-node/events/-/events-0.0.3.tgz"
-  integrity sha512-IqnKIDWfXBJkvy/k6tzskWTc2NK3LcqHlb+KHGCrjOCH4jfQckRX0NAiIcC/vIqQkzLYw2r2CTSwAxcrtcD6lA==
-
-"@whatwg-node/fetch@^0.8.4":
-  version "0.8.8"
-  resolved "https://registry.npmjs.org/@whatwg-node/fetch/-/fetch-0.8.8.tgz"
-  integrity sha512-CdcjGC2vdKhc13KKxgsc6/616BQ7ooDIgPeTuAiE8qfCnS0mGzcfCOoZXypQSz73nxI+GWc7ZReIAVhxoE1KCg==
-  dependencies:
-    "@peculiar/webcrypto" "^1.4.0"
-    "@whatwg-node/node-fetch" "^0.3.6"
-    busboy "^1.6.0"
-    urlpattern-polyfill "^8.0.0"
-    web-streams-polyfill "^3.2.1"
-
-"@whatwg-node/node-fetch@^0.3.6":
-  version "0.3.6"
-  resolved "https://registry.npmjs.org/@whatwg-node/node-fetch/-/node-fetch-0.3.6.tgz"
-  integrity sha512-w9wKgDO4C95qnXZRwZTfCmLWqyRnooGjcIwG0wADWjw9/HN0p7dtvtgSvItZtUyNteEvgTrd8QojNEqV6DAGTA==
-  dependencies:
-    "@whatwg-node/events" "^0.0.3"
-    busboy "^1.6.0"
-    fast-querystring "^1.1.1"
-    fast-url-parser "^1.1.3"
-    tslib "^2.3.1"
-
-JSONStream@1.3.2:
-  version "1.3.2"
-  resolved "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.2.tgz"
-  integrity sha512-mn0KSip7N4e0UDPZHnqDsHECo5uGQrixQKnAskOM1BIB8hd7QKbd6il8IPRPudPHOeHiECoCFqhyMaRO9+nWyA==
-  dependencies:
-    jsonparse "^1.2.0"
-    through ">=2.2.7 <3"
-
-JSONStream@^1.3.5:
-  version "1.3.5"
-  resolved "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz"
-  integrity sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==
-  dependencies:
-    jsonparse "^1.2.0"
-    through ">=2.2.7 <3"
-
-abort-controller@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz"
-  integrity sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==
-  dependencies:
-    event-target-shim "^5.0.0"
-
-acorn-walk@^8.1.1:
-  version "8.2.0"
-  resolved "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz"
-  integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==
-
-acorn@^8.4.1:
-  version "8.8.2"
-  resolved "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz"
-  integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==
-
-ajv@^6.12.3:
-  version "6.12.6"
-  resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz"
-  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
-  dependencies:
-    fast-deep-equal "^3.1.1"
-    fast-json-stable-stringify "^2.0.0"
-    json-schema-traverse "^0.4.1"
-    uri-js "^4.2.2"
-
-ansi-colors@^4.1.1:
-  version "4.1.3"
-  resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz"
-  integrity sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==
-
-ansi-escapes@^3.1.0:
-  version "3.2.0"
-  resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.2.0.tgz"
-  integrity sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==
-
-ansi-escapes@^4.3.2:
-  version "4.3.2"
-  resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz"
-  integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==
-  dependencies:
-    type-fest "^0.21.3"
-
-ansi-regex@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz"
-  integrity sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==
-
-ansi-regex@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz"
-  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
-
-ansi-styles@^3.2.1:
-  version "3.2.1"
-  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz"
-  integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
-  dependencies:
-    color-convert "^1.9.0"
-
-ansi-styles@^4.0.0, ansi-styles@^4.1.0, ansi-styles@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz"
-  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
-  dependencies:
-    color-convert "^2.0.1"
-
-ansicolors@~0.3.2:
-  version "0.3.2"
-  resolved "https://registry.npmjs.org/ansicolors/-/ansicolors-0.3.2.tgz"
-  integrity sha512-QXu7BPrP29VllRxH8GwB7x5iX5qWKAAMLqKQGWTeLWVlNHNOpVMJ91dsxQAIWXpjuW5wqvxu3Jd/nRjrJ+0pqg==
-
-any-signal@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.npmjs.org/any-signal/-/any-signal-2.1.2.tgz"
-  integrity sha512-B+rDnWasMi/eWcajPcCWSlYc7muXOrcYrqgyzcdKisl2H/WTlQ0gip1KyQfr0ZlxJdsuWCj/LWwQm7fhyhRfIQ==
-  dependencies:
-    abort-controller "^3.0.0"
-    native-abort-controller "^1.0.3"
-
-any-signal@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/any-signal/-/any-signal-3.0.1.tgz"
-  integrity sha512-xgZgJtKEa9YmDqXodIgl7Fl1C8yNXr8w6gXjqK3LW4GcEiYT+6AQfJSE/8SPsEpLLmcvbv8YU+qet94UewHxqg==
-
-anymatch@~3.1.2:
-  version "3.1.3"
-  resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz"
-  integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
-  dependencies:
-    normalize-path "^3.0.0"
-    picomatch "^2.0.4"
-
-apisauce@^2.1.5:
-  version "2.1.6"
-  resolved "https://registry.npmjs.org/apisauce/-/apisauce-2.1.6.tgz"
-  integrity sha512-MdxR391op/FucS2YQRfB/NMRyCnHEPDd4h17LRIuVYi0BpGmMhpxc0shbOpfs5ahABuBEffNCGal5EcsydbBWg==
-  dependencies:
-    axios "^0.21.4"
-
-app-module-path@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/app-module-path/-/app-module-path-2.2.0.tgz"
-  integrity sha512-gkco+qxENJV+8vFcDiiFhuoSvRXb2a/QPqpSoWhVz829VNJfOTnELbBmPmNKFxf3xdNnw4DWCkzkDaavcX/1YQ==
-
-arg@^4.1.0:
-  version "4.1.3"
-  resolved "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz"
-  integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
-
-argparse@^1.0.7:
-  version "1.0.10"
-  resolved "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz"
-  integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
-  dependencies:
-    sprintf-js "~1.0.2"
-
-argparse@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz"
-  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
-
-array-union@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz"
-  integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
-
-asap@~2.0.6:
-  version "2.0.6"
-  resolved "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz"
-  integrity sha1-5QNHYR1+aQlDIIu9r+vLwvuGbUY=
-
-asn1@~0.2.3:
-  version "0.2.6"
-  resolved "https://registry.npmjs.org/asn1/-/asn1-0.2.6.tgz"
-  integrity sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==
-  dependencies:
-    safer-buffer "~2.1.0"
-
-asn1js@^3.0.1, asn1js@^3.0.5:
-  version "3.0.5"
-  resolved "https://registry.npmjs.org/asn1js/-/asn1js-3.0.5.tgz"
-  integrity sha512-FVnvrKJwpt9LP2lAMl8qZswRNm3T4q9CON+bxldk2iwk3FFpuwhx2FfinyitizWHsVYyaY+y5JzDR0rCMV5yTQ==
-  dependencies:
-    pvtsutils "^1.3.2"
-    pvutils "^1.1.3"
-    tslib "^2.4.0"
-
-assemblyscript@0.19.10:
-  version "0.19.10"
-  resolved "https://registry.npmjs.org/assemblyscript/-/assemblyscript-0.19.10.tgz"
-  integrity sha512-HavcUBXB3mBTRGJcpvaQjmnmaqKHBGREjSPNsIvnAk2f9dj78y4BkMaSSdvBQYWcDDzsHQjyUC8stICFkD1Odg==
-  dependencies:
-    binaryen "101.0.0-nightly.20210723"
-    long "^4.0.0"
-
-assemblyscript@0.19.23:
-  version "0.19.23"
-  resolved "https://registry.npmjs.org/assemblyscript/-/assemblyscript-0.19.23.tgz"
-  integrity sha512-fwOQNZVTMga5KRsfY80g7cpOl4PsFQczMwHzdtgoqLXaYhkhavufKb0sB0l3T1DUxpAufA0KNhlbpuuhZUwxMA==
-  dependencies:
-    binaryen "102.0.0-nightly.20211028"
-    long "^5.2.0"
-    source-map-support "^0.5.20"
-
-assert-plus@1.0.0, assert-plus@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz"
-  integrity sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==
-
-astral-regex@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31"
-  integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==
-
-async@^3.2.3:
-  version "3.2.4"
-  resolved "https://registry.npmjs.org/async/-/async-3.2.4.tgz"
-  integrity sha512-iAB+JbDEGXhyIUavoDl9WP/Jj106Kz9DEn1DPgYw5ruDn0e3Wgi3sKFm55sASdGBNOQB8F59d9qQ7deqrHA8wQ==
-
-asynckit@^0.4.0:
-  version "0.4.0"
-  resolved "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz"
-  integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==
-
-at-least-node@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz"
-  integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==
-
-aws-sign2@~0.7.0:
-  version "0.7.0"
-  resolved "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz"
-  integrity sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==
-
-aws4@^1.8.0:
-  version "1.11.0"
-  resolved "https://registry.npmjs.org/aws4/-/aws4-1.11.0.tgz"
-  integrity sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA==
-
-axios@^0.21.1, axios@^0.21.4:
-  version "0.21.4"
-  resolved "https://registry.npmjs.org/axios/-/axios-0.21.4.tgz"
-  integrity sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==
-  dependencies:
-    follow-redirects "^1.14.0"
-
-balanced-match@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz"
-  integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
-
-base-x@^3.0.2:
-  version "3.0.9"
-  resolved "https://registry.npmjs.org/base-x/-/base-x-3.0.9.tgz"
-  integrity sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==
-  dependencies:
-    safe-buffer "^5.0.1"
-
-base64-js@^1.3.1:
-  version "1.5.1"
-  resolved "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz"
-  integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
-
-bcrypt-pbkdf@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz"
-  integrity sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==
-  dependencies:
-    tweetnacl "^0.14.3"
-
-binary-extensions@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz"
-  integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==
-
-binary-install-raw@0.0.13:
-  version "0.0.13"
-  resolved "https://registry.npmjs.org/binary-install-raw/-/binary-install-raw-0.0.13.tgz"
-  integrity sha512-v7ms6N/H7iciuk6QInon3/n2mu7oRX+6knJ9xFPsJ3rQePgAqcR3CRTwUheFd8SLbiq4LL7Z4G/44L9zscdt9A==
-  dependencies:
-    axios "^0.21.1"
-    rimraf "^3.0.2"
-    tar "^6.1.0"
-
-binaryen@101.0.0-nightly.20210723:
-  version "101.0.0-nightly.20210723"
-  resolved "https://registry.npmjs.org/binaryen/-/binaryen-101.0.0-nightly.20210723.tgz"
-  integrity sha512-eioJNqhHlkguVSbblHOtLqlhtC882SOEPKmNFZaDuz1hzQjolxZ+eu3/kaS10n3sGPONsIZsO7R9fR00UyhEUA==
-
-binaryen@102.0.0-nightly.20211028:
-  version "102.0.0-nightly.20211028"
-  resolved "https://registry.npmjs.org/binaryen/-/binaryen-102.0.0-nightly.20211028.tgz"
-  integrity sha512-GCJBVB5exbxzzvyt8MGDv/MeUjs6gkXDvf4xOIItRBptYl0Tz5sm1o/uG95YK0L0VeG5ajDu3hRtkBP2kzqC5w==
-
-bl@^1.0.0:
-  version "1.2.3"
-  resolved "https://registry.npmjs.org/bl/-/bl-1.2.3.tgz"
-  integrity sha512-pvcNpa0UU69UT341rO6AYy4FVAIkUHuZXRIWbq+zHnsVcRzDDjIAhGuuYoi0d//cwIwtt4pkpKycWEfjdV+vww==
-  dependencies:
-    readable-stream "^2.3.5"
-    safe-buffer "^5.1.1"
-
-blakejs@^1.1.0:
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/blakejs/-/blakejs-1.2.1.tgz"
-  integrity sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==
-
-blob-to-it@^1.0.1:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/blob-to-it/-/blob-to-it-1.0.4.tgz"
-  integrity sha512-iCmk0W4NdbrWgRRuxOriU8aM5ijeVLI61Zulsmg/lUHNr7pYjoj+U77opLefNagevtrrbMt3JQ5Qip7ar178kA==
-  dependencies:
-    browser-readablestream-to-it "^1.0.3"
-
-bn.js@4.11.6:
-  version "4.11.6"
-  resolved "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz"
-  integrity sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==
-
-bn.js@^4.11.9:
-  version "4.12.0"
-  resolved "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz"
-  integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==
-
-bn.js@^5.1.2, bn.js@^5.2.0, bn.js@^5.2.1:
-  version "5.2.1"
-  resolved "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz"
-  integrity sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==
-
-brace-expansion@^1.1.7:
-  version "1.1.11"
-  resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz"
-  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
-  dependencies:
-    balanced-match "^1.0.0"
-    concat-map "0.0.1"
-
-brace-expansion@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz"
-  integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==
-  dependencies:
-    balanced-match "^1.0.0"
-
-braces@^3.0.2, braces@~3.0.2:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz"
-  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
-  dependencies:
-    fill-range "^7.0.1"
-
-brorand@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz"
-  integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=
-
-browser-readablestream-to-it@^1.0.0, browser-readablestream-to-it@^1.0.1, browser-readablestream-to-it@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/browser-readablestream-to-it/-/browser-readablestream-to-it-1.0.3.tgz"
-  integrity sha512-+12sHB+Br8HIh6VAMVEG5r3UXCyESIgDW7kzk3BjIXa43DVqVwL7GC5TW3jeh+72dtcH99pPVpw0X8i0jt+/kw==
-
-browserify-aes@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz"
-  integrity sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==
-  dependencies:
-    buffer-xor "^1.0.3"
-    cipher-base "^1.0.0"
-    create-hash "^1.1.0"
-    evp_bytestokey "^1.0.3"
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-bs58@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz"
-  integrity sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==
-  dependencies:
-    base-x "^3.0.2"
-
-bs58check@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.npmjs.org/bs58check/-/bs58check-2.1.2.tgz"
-  integrity sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==
-  dependencies:
-    bs58 "^4.0.0"
-    create-hash "^1.1.0"
-    safe-buffer "^5.1.2"
-
-buffer-alloc-unsafe@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz"
-  integrity sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==
-
-buffer-alloc@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/buffer-alloc/-/buffer-alloc-1.2.0.tgz"
-  integrity sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==
-  dependencies:
-    buffer-alloc-unsafe "^1.1.0"
-    buffer-fill "^1.0.0"
-
-buffer-fill@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/buffer-fill/-/buffer-fill-1.0.0.tgz"
-  integrity sha512-T7zexNBwiiaCOGDg9xNX9PBmjrubblRkENuptryuI64URkXDFum9il/JGL8Lm8wYfAXpredVXXZz7eMHilimiQ==
-
-buffer-from@^1.0.0:
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz"
-  integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
-
-buffer-xor@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz"
-  integrity sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==
-
-buffer@^6.0.1, buffer@^6.0.3:
-  version "6.0.3"
-  resolved "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz"
-  integrity sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==
-  dependencies:
-    base64-js "^1.3.1"
-    ieee754 "^1.2.1"
-
-busboy@^1.6.0:
-  version "1.6.0"
-  resolved "https://registry.npmjs.org/busboy/-/busboy-1.6.0.tgz"
-  integrity sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==
-  dependencies:
-    streamsearch "^1.1.0"
-
-call-bind@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz"
-  integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==
-  dependencies:
-    function-bind "^1.1.1"
-    get-intrinsic "^1.0.2"
-
-callsites@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz"
-  integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
-
-cardinal@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.npmjs.org/cardinal/-/cardinal-2.1.1.tgz"
-  integrity sha512-JSr5eOgoEymtYHBjNWyjrMqet9Am2miJhlfKNdqLp6zoeAh0KN5dRAcxlecj5mAJrmQomgiOBj35xHLrFjqBpw==
-  dependencies:
-    ansicolors "~0.3.2"
-    redeyed "~2.1.0"
-
-caseless@^0.12.0, caseless@~0.12.0:
-  version "0.12.0"
-  resolved "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz"
-  integrity sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==
-
-cborg@^1.5.4, cborg@^1.6.0:
-  version "1.10.1"
-  resolved "https://registry.npmjs.org/cborg/-/cborg-1.10.1.tgz"
-  integrity sha512-et6Qm8MOUY2kCWa5GKk2MlBVoPjHv0hQBmlzI/Z7+5V3VJCeIkGehIB3vWknNsm2kOkAIs6wEKJFJo8luWQQ/w==
-
-chalk@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz"
-  integrity sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-chalk@^2.4.2:
-  version "2.4.2"
-  resolved "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz"
-  integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
-  dependencies:
-    ansi-styles "^3.2.1"
-    escape-string-regexp "^1.0.5"
-    supports-color "^5.3.0"
-
-chalk@^4, chalk@^4.0.2, chalk@^4.1.0, chalk@^4.1.2:
-  version "4.1.2"
-  resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz"
-  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-chokidar@3.5.3:
-  version "3.5.3"
-  resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz"
-  integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==
-  dependencies:
-    anymatch "~3.1.2"
-    braces "~3.0.2"
-    glob-parent "~5.1.2"
-    is-binary-path "~2.1.0"
-    is-glob "~4.0.1"
-    normalize-path "~3.0.0"
-    readdirp "~3.6.0"
-  optionalDependencies:
-    fsevents "~2.3.2"
-
-chownr@^1.0.1:
-  version "1.1.4"
-  resolved "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz"
-  integrity sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==
-
-chownr@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz"
-  integrity sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==
-
-cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz"
-  integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==
-  dependencies:
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-clean-stack@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/clean-stack/-/clean-stack-3.0.1.tgz"
-  integrity sha512-lR9wNiMRcVQjSB3a7xXGLuz4cr4wJuuXlaAEbRutGowQTmlp7R72/DOgN21e8jdwblMWl9UOJMJXarX94pzKdg==
-  dependencies:
-    escape-string-regexp "4.0.0"
-
-cli-cursor@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz"
-  integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==
-  dependencies:
-    restore-cursor "^3.1.0"
-
-cli-progress@^3.12.0:
-  version "3.12.0"
-  resolved "https://registry.npmjs.org/cli-progress/-/cli-progress-3.12.0.tgz"
-  integrity sha512-tRkV3HJ1ASwm19THiiLIXLO7Im7wlTuKnvkYaTkyoAPefqjNg7W7DHKUlGRxy9vxDvbyCYQkQozvptuMkGCg8A==
-  dependencies:
-    string-width "^4.2.3"
-
-cli-spinners@^2.2.0:
-  version "2.7.0"
-  resolved "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.7.0.tgz"
-  integrity sha512-qu3pN8Y3qHNgE2AFweciB1IfMnmZ/fsNTEE+NOFjmGB2F/7rLhnhzppvpCnN4FovtP26k8lHyy9ptEbNwWFLzw==
-
-cli-table3@0.6.0:
-  version "0.6.0"
-  resolved "https://registry.npmjs.org/cli-table3/-/cli-table3-0.6.0.tgz"
-  integrity sha512-gnB85c3MGC7Nm9I/FkiasNBOKjOiO1RNuXXarQms37q4QMpWdlbBgD/VnOStA2faG1dpXMv31RFApjX1/QdgWQ==
-  dependencies:
-    object-assign "^4.1.0"
-    string-width "^4.2.0"
-  optionalDependencies:
-    colors "^1.1.2"
-
-clone@^1.0.2:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz"
-  integrity sha1-2jCcwmPfFZlMaIypAheco8fNfH4=
-
-color-convert@^1.9.0:
-  version "1.9.3"
-  resolved "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz"
-  integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
-  dependencies:
-    color-name "1.1.3"
-
-color-convert@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz"
-  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
-  dependencies:
-    color-name "~1.1.4"
-
-color-name@1.1.3:
-  version "1.1.3"
-  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz"
-  integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==
-
-color-name@~1.1.4:
-  version "1.1.4"
-  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz"
-  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
-
-colors@1.4.0, colors@^1.1.2:
-  version "1.4.0"
-  resolved "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz"
-  integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==
-
-combined-stream@^1.0.6, combined-stream@~1.0.6:
-  version "1.0.8"
-  resolved "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz"
-  integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
-  dependencies:
-    delayed-stream "~1.0.0"
-
-commander@^2.20.3:
-  version "2.20.3"
-  resolved "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz"
-  integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
-
-concat-map@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz"
-  integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
-
-concat-stream@^1.6.0, concat-stream@^1.6.2, concat-stream@~1.6.2:
-  version "1.6.2"
-  resolved "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz"
-  integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==
-  dependencies:
-    buffer-from "^1.0.0"
-    inherits "^2.0.3"
-    readable-stream "^2.2.2"
-    typedarray "^0.0.6"
-
-core-util-is@1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz"
-  integrity sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==
-
-core-util-is@~1.0.0:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz"
-  integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==
-
-cosmiconfig@7.0.1:
-  version "7.0.1"
-  resolved "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.0.1.tgz"
-  integrity sha512-a1YWNUV2HwGimB7dU2s1wUMurNKjpx60HxBB6xUM8Re+2s1g1IIfJvFR0/iCF+XHdE0GMTKTuLR32UQff4TEyQ==
-  dependencies:
-    "@types/parse-json" "^4.0.0"
-    import-fresh "^3.2.1"
-    parse-json "^5.0.0"
-    path-type "^4.0.0"
-    yaml "^1.10.0"
-
-create-hash@^1.1.0, create-hash@^1.1.2, create-hash@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz"
-  integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==
-  dependencies:
-    cipher-base "^1.0.1"
-    inherits "^2.0.1"
-    md5.js "^1.3.4"
-    ripemd160 "^2.0.1"
-    sha.js "^2.4.0"
-
-create-hmac@^1.1.4, create-hmac@^1.1.7:
-  version "1.1.7"
-  resolved "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz"
-  integrity sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==
-  dependencies:
-    cipher-base "^1.0.3"
-    create-hash "^1.1.0"
-    inherits "^2.0.1"
-    ripemd160 "^2.0.0"
-    safe-buffer "^5.0.1"
-    sha.js "^2.4.8"
-
-create-require@^1.1.0:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz"
-  integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==
-
-cross-spawn@7.0.3, cross-spawn@^7.0.3:
-  version "7.0.3"
-  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz"
-  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
-  dependencies:
-    path-key "^3.1.0"
-    shebang-command "^2.0.0"
-    which "^2.0.1"
-
-cross-spawn@^6.0.5:
-  version "6.0.5"
-  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz"
-  integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
-  dependencies:
-    nice-try "^1.0.4"
-    path-key "^2.0.1"
-    semver "^5.5.0"
-    shebang-command "^1.2.0"
-    which "^1.2.9"
-
-dashdash@^1.12.0:
-  version "1.14.1"
-  resolved "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz"
-  integrity sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==
-  dependencies:
-    assert-plus "^1.0.0"
-
-debug@4.3.4, debug@^4.1.1, debug@^4.3.1, debug@^4.3.4:
-  version "4.3.4"
-  resolved "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz"
-  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
-  dependencies:
-    ms "2.1.2"
-
-debug@^3.2.6:
-  version "3.2.7"
-  resolved "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz"
-  integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
-  dependencies:
-    ms "^2.1.1"
-
-defaults@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/defaults/-/defaults-1.0.3.tgz"
-  integrity sha512-s82itHOnYrN0Ib8r+z7laQz3sdE+4FP3d9Q7VLO7U+KRT+CR0GsWuyHxzdAY82I7cXv0G/twrqomTJLOssO5HA==
-  dependencies:
-    clone "^1.0.2"
-
-delay@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/delay/-/delay-5.0.0.tgz"
-  integrity sha512-ReEBKkIfe4ya47wlPYf/gu5ib6yUG0/Aez0JQZQz94kiWtRQvZIQbTiehsnwHvLSWJnQdhVeqYue7Id1dKr0qw==
-
-delayed-stream@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz"
-  integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==
-
-diff@^4.0.1:
-  version "4.0.2"
-  resolved "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz"
-  integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
-
-dir-glob@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz"
-  integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
-  dependencies:
-    path-type "^4.0.0"
-
-dns-over-http-resolver@^1.2.3:
-  version "1.2.3"
-  resolved "https://registry.npmjs.org/dns-over-http-resolver/-/dns-over-http-resolver-1.2.3.tgz"
-  integrity sha512-miDiVSI6KSNbi4SVifzO/reD8rMnxgrlnkrlkugOLQpWQTe2qMdHsZp5DmfKjxNE+/T3VAAYLQUZMv9SMr6+AA==
-  dependencies:
-    debug "^4.3.1"
-    native-fetch "^3.0.0"
-    receptacle "^1.3.2"
-
-docker-compose@0.23.19:
-  version "0.23.19"
-  resolved "https://registry.npmjs.org/docker-compose/-/docker-compose-0.23.19.tgz"
-  integrity sha512-v5vNLIdUqwj4my80wxFDkNH+4S85zsRuH29SO7dCWVWPCMt/ohZBsGN6g6KXWifT0pzQ7uOxqEKCYCDPJ8Vz4g==
-  dependencies:
-    yaml "^1.10.2"
-
-docker-modem@^1.0.8:
-  version "1.0.9"
-  resolved "https://registry.npmjs.org/docker-modem/-/docker-modem-1.0.9.tgz"
-  integrity sha512-lVjqCSCIAUDZPAZIeyM125HXfNvOmYYInciphNrLrylUtKyW66meAjSPXWchKVzoIYZx69TPnAepVSSkeawoIw==
-  dependencies:
-    JSONStream "1.3.2"
-    debug "^3.2.6"
-    readable-stream "~1.0.26-4"
-    split-ca "^1.0.0"
-
-dockerode@2.5.8:
-  version "2.5.8"
-  resolved "https://registry.npmjs.org/dockerode/-/dockerode-2.5.8.tgz"
-  integrity sha512-+7iOUYBeDTScmOmQqpUYQaE7F4vvIt6+gIZNHWhqAQEI887tiPFB9OvXI/HzQYqfUNvukMK+9myLW63oTJPZpw==
-  dependencies:
-    concat-stream "~1.6.2"
-    docker-modem "^1.0.8"
-    tar-fs "~1.16.3"
-
-ecc-jsbn@~0.1.1:
-  version "0.1.2"
-  resolved "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz"
-  integrity sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==
-  dependencies:
-    jsbn "~0.1.0"
-    safer-buffer "^2.1.0"
-
-ejs@3.1.6:
-  version "3.1.6"
-  resolved "https://registry.npmjs.org/ejs/-/ejs-3.1.6.tgz"
-  integrity sha512-9lt9Zse4hPucPkoP7FHDF0LQAlGyF9JVpnClFLFH3aSSbxmyoqINRpp/9wePWJTUl4KOQwRL72Iw3InHPDkoGw==
-  dependencies:
-    jake "^10.6.1"
-
-ejs@^3.1.8:
-  version "3.1.9"
-  resolved "https://registry.npmjs.org/ejs/-/ejs-3.1.9.tgz"
-  integrity sha512-rC+QVNMJWv+MtPgkt0y+0rVEIdbtxVADApW9JXrUVlzHetgcyczP/E7DJmWJ4fJCZF2cPcBk0laWO9ZHMG3DmQ==
-  dependencies:
-    jake "^10.8.5"
-
-electron-fetch@^1.7.2:
-  version "1.9.1"
-  resolved "https://registry.npmjs.org/electron-fetch/-/electron-fetch-1.9.1.tgz"
-  integrity sha512-M9qw6oUILGVrcENMSRRefE1MbHPIz0h79EKIeJWK9v563aT9Qkh8aEHPO1H5vi970wPirNY+jO9OpFoLiMsMGA==
-  dependencies:
-    encoding "^0.1.13"
-
-elliptic@6.5.4, elliptic@^6.5.4:
-  version "6.5.4"
-  resolved "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz"
-  integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==
-  dependencies:
-    bn.js "^4.11.9"
-    brorand "^1.1.0"
-    hash.js "^1.0.0"
-    hmac-drbg "^1.0.1"
-    inherits "^2.0.4"
-    minimalistic-assert "^1.0.1"
-    minimalistic-crypto-utils "^1.0.1"
-
-emoji-regex@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz"
-  integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
-
-encoding@^0.1.13:
-  version "0.1.13"
-  resolved "https://registry.npmjs.org/encoding/-/encoding-0.1.13.tgz"
-  integrity sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==
-  dependencies:
-    iconv-lite "^0.6.2"
-
-end-of-stream@^1.0.0, end-of-stream@^1.1.0:
-  version "1.4.4"
-  resolved "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz"
-  integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
-  dependencies:
-    once "^1.4.0"
-
-enquirer@2.3.6:
-  version "2.3.6"
-  resolved "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz"
-  integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==
-  dependencies:
-    ansi-colors "^4.1.1"
-
-err-code@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/err-code/-/err-code-3.0.1.tgz"
-  integrity sha512-GiaH0KJUewYok+eeY05IIgjtAe4Yltygk9Wqp1V5yVWLdhf0hYZchRjNIT9bb0mSwRcIusT3cx7PJUf3zEIfUA==
-
-error-ex@^1.3.1:
-  version "1.3.2"
-  resolved "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz"
-  integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
-  dependencies:
-    is-arrayish "^0.2.1"
-
-es6-promise@^4.0.3:
-  version "4.2.8"
-  resolved "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.8.tgz"
-  integrity sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==
-
-es6-promisify@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz"
-  integrity sha512-C+d6UdsYDk0lMebHNR4S2NybQMMngAOnOwYBQjTOiv0MkoJMP0Myw2mgpDLBcpfCmRLxyFqYhS/CfOENq4SJhQ==
-  dependencies:
-    es6-promise "^4.0.3"
-
-escape-string-regexp@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz"
-  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
-
-escape-string-regexp@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz"
-  integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
-
-esprima@^4.0.0, esprima@~4.0.0:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz"
-  integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
-
-ethereum-bloom-filters@^1.0.6:
-  version "1.0.10"
-  resolved "https://registry.npmjs.org/ethereum-bloom-filters/-/ethereum-bloom-filters-1.0.10.tgz"
-  integrity sha512-rxJ5OFN3RwjQxDcFP2Z5+Q9ho4eIdEmSc2ht0fCu8Se9nbXjZ7/031uXoUYJ87KHCOdVeiUuwSnoS7hmYAGVHA==
-  dependencies:
-    js-sha3 "^0.8.0"
-
-ethereum-cryptography@^0.1.3:
-  version "0.1.3"
-  resolved "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz"
-  integrity sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==
-  dependencies:
-    "@types/pbkdf2" "^3.0.0"
-    "@types/secp256k1" "^4.0.1"
-    blakejs "^1.1.0"
-    browserify-aes "^1.2.0"
-    bs58check "^2.1.2"
-    create-hash "^1.2.0"
-    create-hmac "^1.1.7"
-    hash.js "^1.1.7"
-    keccak "^3.0.0"
-    pbkdf2 "^3.0.17"
-    randombytes "^2.1.0"
-    safe-buffer "^5.1.2"
-    scrypt-js "^3.0.0"
-    secp256k1 "^4.0.1"
-    setimmediate "^1.0.5"
-
-ethereumjs-util@^7.1.0:
-  version "7.1.5"
-  resolved "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz"
-  integrity sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==
-  dependencies:
-    "@types/bn.js" "^5.1.0"
-    bn.js "^5.1.2"
-    create-hash "^1.1.2"
-    ethereum-cryptography "^0.1.3"
-    rlp "^2.2.4"
-
-ethjs-unit@0.1.6:
-  version "0.1.6"
-  resolved "https://registry.npmjs.org/ethjs-unit/-/ethjs-unit-0.1.6.tgz"
-  integrity sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw==
-  dependencies:
-    bn.js "4.11.6"
-    number-to-bn "1.7.0"
-
-event-target-shim@^5.0.0:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz"
-  integrity sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==
-
-evp_bytestokey@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz"
-  integrity sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==
-  dependencies:
-    md5.js "^1.3.4"
-    safe-buffer "^5.1.1"
-
-execa@5.1.1:
-  version "5.1.1"
-  resolved "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz"
-  integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==
-  dependencies:
-    cross-spawn "^7.0.3"
-    get-stream "^6.0.0"
-    human-signals "^2.1.0"
-    is-stream "^2.0.0"
-    merge-stream "^2.0.0"
-    npm-run-path "^4.0.1"
-    onetime "^5.1.2"
-    signal-exit "^3.0.3"
-    strip-final-newline "^2.0.0"
-
-extend@~3.0.2:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz"
-  integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
-
-extsprintf@1.3.0:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz"
-  integrity sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==
-
-extsprintf@^1.2.0:
-  version "1.4.1"
-  resolved "https://registry.npmjs.org/extsprintf/-/extsprintf-1.4.1.tgz"
-  integrity sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA==
-
-eyes@^0.1.8:
-  version "0.1.8"
-  resolved "https://registry.npmjs.org/eyes/-/eyes-0.1.8.tgz"
-  integrity sha512-GipyPsXO1anza0AOZdy69Im7hGFCNB7Y/NGjDlZGJ3GJJLtwNSb2vrzYrTYJRrRloVx7pl+bhUaTB8yiccPvFQ==
-
-fast-decode-uri-component@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/fast-decode-uri-component/-/fast-decode-uri-component-1.0.1.tgz"
-  integrity sha512-WKgKWg5eUxvRZGwW8FvfbaH7AXSh2cL+3j5fMGzUMCxWBJ3dV3a7Wz8y2f/uQ0e3B6WmodD3oS54jTQ9HVTIIg==
-
-fast-deep-equal@^3.1.1:
-  version "3.1.3"
-  resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz"
-  integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
-
-fast-fifo@^1.0.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.2.0.tgz"
-  integrity sha512-NcvQXt7Cky1cNau15FWy64IjuO8X0JijhTBBrJj1YlxlDfRkJXNaK9RFUjwpfDPzMdv7wB38jr53l9tkNLxnWg==
-
-fast-glob@^3.2.9:
-  version "3.2.12"
-  resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.12.tgz"
-  integrity sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==
-  dependencies:
-    "@nodelib/fs.stat" "^2.0.2"
-    "@nodelib/fs.walk" "^1.2.3"
-    glob-parent "^5.1.2"
-    merge2 "^1.3.0"
-    micromatch "^4.0.4"
-
-fast-json-stable-stringify@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz"
-  integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
-
-fast-levenshtein@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-3.0.0.tgz#37b899ae47e1090e40e3fd2318e4d5f0142ca912"
-  integrity sha512-hKKNajm46uNmTlhHSyZkmToAc56uZJwYq7yrciZjqOxnlfQwERDQJmHPUp7m1m9wx8vgOe8IaCKZ5Kv2k1DdCQ==
-  dependencies:
-    fastest-levenshtein "^1.0.7"
-
-fast-querystring@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/fast-querystring/-/fast-querystring-1.1.1.tgz"
-  integrity sha512-qR2r+e3HvhEFmpdHMv//U8FnFlnYjaC6QKDuaXALDkw2kvHO8WDjxH+f/rHGR4Me4pnk8p9JAkRNTjYHAKRn2Q==
-  dependencies:
-    fast-decode-uri-component "^1.0.1"
-
-fast-url-parser@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.npmjs.org/fast-url-parser/-/fast-url-parser-1.1.3.tgz"
-  integrity sha512-5jOCVXADYNuRkKFzNJ0dCCewsZiYo0dz8QNYljkOpFC6r2U4OBmKtvm/Tsuh4w1YYdDqDb31a8TVhBJ2OJKdqQ==
-  dependencies:
-    punycode "^1.3.2"
-
-fastest-levenshtein@^1.0.7:
-  version "1.0.16"
-  resolved "https://registry.yarnpkg.com/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz#210e61b6ff181de91ea9b3d1b84fdedd47e034e5"
-  integrity sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==
-
-fastq@^1.6.0:
-  version "1.11.0"
-  resolved "https://registry.npmjs.org/fastq/-/fastq-1.11.0.tgz"
-  integrity sha512-7Eczs8gIPDrVzT+EksYBcupqMyxSHXXrHOLRRxU2/DicV8789MRBRR8+Hc2uWzUupOs4YS4JzBmBxjjCVBxD/g==
-  dependencies:
-    reusify "^1.0.4"
-
-filelist@^1.0.1, filelist@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/filelist/-/filelist-1.0.4.tgz"
-  integrity sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==
-  dependencies:
-    minimatch "^5.0.1"
-
-fill-range@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz"
-  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
-  dependencies:
-    to-regex-range "^5.0.1"
-
-follow-redirects@^1.14.0:
-  version "1.15.4"
-  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.4.tgz#cdc7d308bf6493126b17ea2191ea0ccf3e535adf"
-  integrity sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==
-
-forever-agent@~0.6.1:
-  version "0.6.1"
-  resolved "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz"
-  integrity sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==
-
-form-data@^2.2.0:
-  version "2.5.1"
-  resolved "https://registry.npmjs.org/form-data/-/form-data-2.5.1.tgz"
-  integrity sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.6"
-    mime-types "^2.1.12"
-
-form-data@~2.3.2:
-  version "2.3.3"
-  resolved "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz"
-  integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.6"
-    mime-types "^2.1.12"
-
-fs-constants@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz"
-  integrity sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==
-
-fs-extra@9.1.0, fs-extra@^9.1.0:
-  version "9.1.0"
-  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz"
-  integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==
-  dependencies:
-    at-least-node "^1.0.0"
-    graceful-fs "^4.2.0"
-    jsonfile "^6.0.1"
-    universalify "^2.0.0"
-
-fs-jetpack@4.3.1:
-  version "4.3.1"
-  resolved "https://registry.npmjs.org/fs-jetpack/-/fs-jetpack-4.3.1.tgz"
-  integrity sha512-dbeOK84F6BiQzk2yqqCVwCPWTxAvVGJ3fMQc6E2wuEohS28mR6yHngbrKuVCK1KHRx/ccByDylqu4H5PCP2urQ==
-  dependencies:
-    minimatch "^3.0.2"
-    rimraf "^2.6.3"
-
-fs-minipass@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz"
-  integrity sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==
-  dependencies:
-    minipass "^3.0.0"
-
-fs.realpath@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz"
-  integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
-
-fsevents@~2.3.2:
-  version "2.3.2"
-  resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz"
-  integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==
-
-function-bind@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz"
-  integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
-
-get-intrinsic@^1.0.2:
-  version "1.1.3"
-  resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.3.tgz"
-  integrity sha512-QJVz1Tj7MS099PevUG5jvnt9tSkXN8K14dxQlikJuPt4uD9hHAHjLyLBiLR5zELelBdD9QNRAXZzsJx0WaDL9A==
-  dependencies:
-    function-bind "^1.1.1"
-    has "^1.0.3"
-    has-symbols "^1.0.3"
-
-get-iterator@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/get-iterator/-/get-iterator-1.0.2.tgz"
-  integrity sha512-v+dm9bNVfOYsY1OrhaCrmyOcYoSeVvbt+hHZ0Au+T+p1y+0Uyj9aMaGIeUTT6xdpRbWzDeYKvfOslPhggQMcsg==
-
-get-package-type@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz"
-  integrity sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==
-
-get-port@^3.1.0:
-  version "3.2.0"
-  resolved "https://registry.npmjs.org/get-port/-/get-port-3.2.0.tgz"
-  integrity sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==
-
-get-stream@^6.0.0:
-  version "6.0.1"
-  resolved "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz"
-  integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
-
-getpass@^0.1.1:
-  version "0.1.7"
-  resolved "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz"
-  integrity sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==
-  dependencies:
-    assert-plus "^1.0.0"
-
-glob-parent@^5.1.2, glob-parent@~5.1.2:
-  version "5.1.2"
-  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz"
-  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
-  dependencies:
-    is-glob "^4.0.1"
-
-glob@9.3.5:
-  version "9.3.5"
-  resolved "https://registry.npmjs.org/glob/-/glob-9.3.5.tgz"
-  integrity sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    minimatch "^8.0.2"
-    minipass "^4.2.4"
-    path-scurry "^1.6.1"
-
-glob@^7.1.3:
-  version "7.2.3"
-  resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz"
-  integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.1.1"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-globby@^11.1.0:
-  version "11.1.0"
-  resolved "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz"
-  integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
-  dependencies:
-    array-union "^2.1.0"
-    dir-glob "^3.0.1"
-    fast-glob "^3.2.9"
-    ignore "^5.2.0"
-    merge2 "^1.4.1"
-    slash "^3.0.0"
-
-gluegun@5.1.2:
-  version "5.1.2"
-  resolved "https://registry.npmjs.org/gluegun/-/gluegun-5.1.2.tgz"
-  integrity sha512-Cwx/8S8Z4YQg07a6AFsaGnnnmd8mN17414NcPS3OoDtZRwxgsvwRNJNg69niD6fDa8oNwslCG0xH7rEpRNNE/g==
-  dependencies:
-    apisauce "^2.1.5"
-    app-module-path "^2.2.0"
-    cli-table3 "0.6.0"
-    colors "1.4.0"
-    cosmiconfig "7.0.1"
-    cross-spawn "7.0.3"
-    ejs "3.1.6"
-    enquirer "2.3.6"
-    execa "5.1.1"
-    fs-jetpack "4.3.1"
-    lodash.camelcase "^4.3.0"
-    lodash.kebabcase "^4.1.1"
-    lodash.lowercase "^4.3.0"
-    lodash.lowerfirst "^4.3.1"
-    lodash.pad "^4.5.1"
-    lodash.padend "^4.6.1"
-    lodash.padstart "^4.6.1"
-    lodash.repeat "^4.1.0"
-    lodash.snakecase "^4.1.1"
-    lodash.startcase "^4.4.0"
-    lodash.trim "^4.5.1"
-    lodash.trimend "^4.5.1"
-    lodash.trimstart "^4.5.1"
-    lodash.uppercase "^4.3.0"
-    lodash.upperfirst "^4.3.1"
-    ora "4.0.2"
-    pluralize "^8.0.0"
-    semver "7.3.5"
-    which "2.0.2"
-    yargs-parser "^21.0.0"
-
-graceful-fs@^4.1.6, graceful-fs@^4.2.0:
-  version "4.2.11"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3"
-  integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
-
-graphql-import-node@^0.0.5:
-  version "0.0.5"
-  resolved "https://registry.npmjs.org/graphql-import-node/-/graphql-import-node-0.0.5.tgz"
-  integrity sha512-OXbou9fqh9/Lm7vwXT0XoRN9J5+WCYKnbiTalgFDvkQERITRmcfncZs6aVABedd5B85yQU5EULS4a5pnbpuI0Q==
-
-graphql@15.5.0:
-  version "15.5.0"
-  resolved "https://registry.npmjs.org/graphql/-/graphql-15.5.0.tgz"
-  integrity sha512-OmaM7y0kaK31NKG31q4YbD2beNYa6jBBKtMFT6gLYJljHLJr42IqJ8KX08u3Li/0ifzTU5HjmoOOrwa5BRLeDA==
-
-graphql@^16.6.0:
-  version "16.6.0"
-  resolved "https://registry.npmjs.org/graphql/-/graphql-16.6.0.tgz"
-  integrity sha512-KPIBPDlW7NxrbT/eh4qPXz5FiFdL5UbaA0XUNz2Rp3Z3hqBSkbj0GVjwFDztsWVauZUWsbKHgMg++sk8UX0bkw==
-
-har-schema@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz"
-  integrity sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==
-
-har-validator@~5.1.3:
-  version "5.1.5"
-  resolved "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz"
-  integrity sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==
-  dependencies:
-    ajv "^6.12.3"
-    har-schema "^2.0.0"
-
-has-flag@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz"
-  integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==
-
-has-flag@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz"
-  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
-
-has-symbols@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz"
-  integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==
-
-has@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/has/-/has-1.0.3.tgz"
-  integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
-  dependencies:
-    function-bind "^1.1.1"
-
-hash-base@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz"
-  integrity sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==
-  dependencies:
-    inherits "^2.0.4"
-    readable-stream "^3.6.0"
-    safe-buffer "^5.2.0"
-
-hash.js@1.1.7, hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7:
-  version "1.1.7"
-  resolved "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz"
-  integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==
-  dependencies:
-    inherits "^2.0.3"
-    minimalistic-assert "^1.0.1"
-
-hmac-drbg@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz"
-  integrity sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=
-  dependencies:
-    hash.js "^1.0.3"
-    minimalistic-assert "^1.0.0"
-    minimalistic-crypto-utils "^1.0.1"
-
-http-basic@^8.1.1:
-  version "8.1.3"
-  resolved "https://registry.npmjs.org/http-basic/-/http-basic-8.1.3.tgz"
-  integrity sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw==
-  dependencies:
-    caseless "^0.12.0"
-    concat-stream "^1.6.2"
-    http-response-object "^3.0.1"
-    parse-cache-control "^1.0.1"
-
-http-response-object@^3.0.1:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/http-response-object/-/http-response-object-3.0.2.tgz"
-  integrity sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA==
-  dependencies:
-    "@types/node" "^10.0.3"
-
-http-signature@~1.2.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz"
-  integrity sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==
-  dependencies:
-    assert-plus "^1.0.0"
-    jsprim "^1.2.2"
-    sshpk "^1.7.0"
-
-human-signals@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz"
-  integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
-
-hyperlinker@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/hyperlinker/-/hyperlinker-1.0.0.tgz"
-  integrity sha512-Ty8UblRWFEcfSuIaajM34LdPXIhbs1ajEX/BBPv24J+enSVaEVY63xQ6lTO9VRYS5LAoghIG0IDJ+p+IPzKUQQ==
-
-iconv-lite@^0.6.2:
-  version "0.6.2"
-  resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.2.tgz"
-  integrity sha512-2y91h5OpQlolefMPmUlivelittSWy0rP+oYVpn6A7GwVHNE8AWzoYOBNmlwks3LobaJxgHCYZAnyNo2GgpNRNQ==
-  dependencies:
-    safer-buffer ">= 2.1.2 < 3.0.0"
-
-ieee754@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz"
-  integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==
-
-ignore@^5.2.0:
-  version "5.2.4"
-  resolved "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz"
-  integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==
-
-immutable@4.2.1:
-  version "4.2.1"
-  resolved "https://registry.npmjs.org/immutable/-/immutable-4.2.1.tgz"
-  integrity sha512-7WYV7Q5BTs0nlQm7tl92rDYYoyELLKHoDMBKhrxEoiV4mrfVdRz8hzPiYOzH7yWjzoVEamxRuAqhxL2PLRwZYQ==
-
-import-fresh@^3.2.1:
-  version "3.3.0"
-  resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz"
-  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
-  dependencies:
-    parent-module "^1.0.0"
-    resolve-from "^4.0.0"
-
-indent-string@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz"
-  integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
-
-inflight@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz"
-  integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
-  dependencies:
-    once "^1.3.0"
-    wrappy "1"
-
-inherits@2, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.1, inherits@~2.0.3:
-  version "2.0.4"
-  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
-  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
-
-interface-datastore@^6.0.2:
-  version "6.1.1"
-  resolved "https://registry.npmjs.org/interface-datastore/-/interface-datastore-6.1.1.tgz"
-  integrity sha512-AmCS+9CT34pp2u0QQVXjKztkuq3y5T+BIciuiHDDtDZucZD8VudosnSdUyXJV6IsRkN5jc4RFDhCk1O6Q3Gxjg==
-  dependencies:
-    interface-store "^2.0.2"
-    nanoid "^3.0.2"
-    uint8arrays "^3.0.0"
-
-interface-store@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/interface-store/-/interface-store-2.0.2.tgz"
-  integrity sha512-rScRlhDcz6k199EkHqT8NpM87ebN89ICOzILoBHgaG36/WX50N32BnU/kpZgCGPLhARRAWUUX5/cyaIjt7Kipg==
-
-ip-regex@^4.0.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/ip-regex/-/ip-regex-4.3.0.tgz"
-  integrity sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==
-
-ipfs-core-types@^0.9.0:
-  version "0.9.0"
-  resolved "https://registry.npmjs.org/ipfs-core-types/-/ipfs-core-types-0.9.0.tgz"
-  integrity sha512-VJ8vJSHvI1Zm7/SxsZo03T+zzpsg8pkgiIi5hfwSJlsrJ1E2v68QPlnLshGHUSYw89Oxq0IbETYl2pGTFHTWfg==
-  dependencies:
-    interface-datastore "^6.0.2"
-    multiaddr "^10.0.0"
-    multiformats "^9.4.13"
-
-ipfs-core-utils@^0.13.0:
-  version "0.13.0"
-  resolved "https://registry.npmjs.org/ipfs-core-utils/-/ipfs-core-utils-0.13.0.tgz"
-  integrity sha512-HP5EafxU4/dLW3U13CFsgqVO5Ika8N4sRSIb/dTg16NjLOozMH31TXV0Grtu2ZWo1T10ahTzMvrfT5f4mhioXw==
-  dependencies:
-    any-signal "^2.1.2"
-    blob-to-it "^1.0.1"
-    browser-readablestream-to-it "^1.0.1"
-    debug "^4.1.1"
-    err-code "^3.0.1"
-    ipfs-core-types "^0.9.0"
-    ipfs-unixfs "^6.0.3"
-    ipfs-utils "^9.0.2"
-    it-all "^1.0.4"
-    it-map "^1.0.4"
-    it-peekable "^1.0.2"
-    it-to-stream "^1.0.0"
-    merge-options "^3.0.4"
-    multiaddr "^10.0.0"
-    multiaddr-to-uri "^8.0.0"
-    multiformats "^9.4.13"
-    nanoid "^3.1.23"
-    parse-duration "^1.0.0"
-    timeout-abort-controller "^2.0.0"
-    uint8arrays "^3.0.0"
-
-ipfs-http-client@55.0.0:
-  version "55.0.0"
-  resolved "https://registry.npmjs.org/ipfs-http-client/-/ipfs-http-client-55.0.0.tgz"
-  integrity sha512-GpvEs7C7WL9M6fN/kZbjeh4Y8YN7rY8b18tVWZnKxRsVwM25cIFrRI8CwNt3Ugin9yShieI3i9sPyzYGMrLNnQ==
-  dependencies:
-    "@ipld/dag-cbor" "^7.0.0"
-    "@ipld/dag-json" "^8.0.1"
-    "@ipld/dag-pb" "^2.1.3"
-    abort-controller "^3.0.0"
-    any-signal "^2.1.2"
-    debug "^4.1.1"
-    err-code "^3.0.1"
-    ipfs-core-types "^0.9.0"
-    ipfs-core-utils "^0.13.0"
-    ipfs-utils "^9.0.2"
-    it-first "^1.0.6"
-    it-last "^1.0.4"
-    merge-options "^3.0.4"
-    multiaddr "^10.0.0"
-    multiformats "^9.4.13"
-    native-abort-controller "^1.0.3"
-    parse-duration "^1.0.0"
-    stream-to-it "^0.2.2"
-    uint8arrays "^3.0.0"
-
-ipfs-unixfs@^6.0.3:
-  version "6.0.9"
-  resolved "https://registry.npmjs.org/ipfs-unixfs/-/ipfs-unixfs-6.0.9.tgz"
-  integrity sha512-0DQ7p0/9dRB6XCb0mVCTli33GzIzSVx5udpJuVM47tGcD+W+Bl4LsnoLswd3ggNnNEakMv1FdoFITiEnchXDqQ==
-  dependencies:
-    err-code "^3.0.1"
-    protobufjs "^6.10.2"
-
-ipfs-utils@^9.0.2:
-  version "9.0.14"
-  resolved "https://registry.npmjs.org/ipfs-utils/-/ipfs-utils-9.0.14.tgz"
-  integrity sha512-zIaiEGX18QATxgaS0/EOQNoo33W0islREABAcxXE8n7y2MGAlB+hdsxXn4J0hGZge8IqVQhW8sWIb+oJz2yEvg==
-  dependencies:
-    any-signal "^3.0.0"
-    browser-readablestream-to-it "^1.0.0"
-    buffer "^6.0.1"
-    electron-fetch "^1.7.2"
-    err-code "^3.0.1"
-    is-electron "^2.2.0"
-    iso-url "^1.1.5"
-    it-all "^1.0.4"
-    it-glob "^1.0.1"
-    it-to-stream "^1.0.0"
-    merge-options "^3.0.4"
-    nanoid "^3.1.20"
-    native-fetch "^3.0.0"
-    node-fetch "^2.6.8"
-    react-native-fetch-api "^3.0.0"
-    stream-to-it "^0.2.2"
-
-is-arrayish@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz"
-  integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==
-
-is-binary-path@~2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz"
-  integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
-  dependencies:
-    binary-extensions "^2.0.0"
-
-is-docker@^2.0.0:
-  version "2.2.1"
-  resolved "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz"
-  integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==
-
-is-electron@^2.2.0:
-  version "2.2.1"
-  resolved "https://registry.npmjs.org/is-electron/-/is-electron-2.2.1.tgz"
-  integrity sha512-r8EEQQsqT+Gn0aXFx7lTFygYQhILLCB+wn0WCDL5LZRINeLH/Rvw1j2oKodELLXYNImQ3CRlVsY8wW4cGOsyuw==
-
-is-extglob@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz"
-  integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=
-
-is-fullwidth-code-point@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz"
-  integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
-
-is-glob@^4.0.1, is-glob@~4.0.1:
-  version "4.0.3"
-  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz"
-  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
-  dependencies:
-    is-extglob "^2.1.1"
-
-is-hex-prefixed@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz"
-  integrity sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==
-
-is-interactive@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/is-interactive/-/is-interactive-1.0.0.tgz"
-  integrity sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==
-
-is-ip@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/is-ip/-/is-ip-3.1.0.tgz"
-  integrity sha512-35vd5necO7IitFPjd/YBeqwWnyDWbuLH9ZXQdMfDA8TEo7pv5X8yfrvVO3xbJbLUlERCMvf6X0hTUamQxCYJ9Q==
-  dependencies:
-    ip-regex "^4.0.0"
-
-is-number@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz"
-  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
-
-is-plain-obj@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz"
-  integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==
-
-is-stream@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz"
-  integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
-
-is-typedarray@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz"
-  integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=
-
-is-wsl@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz"
-  integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
-  dependencies:
-    is-docker "^2.0.0"
-
-isarray@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz"
-  integrity sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==
-
-isarray@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz"
-  integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=
-
-isexe@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz"
-  integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
-
-iso-url@^1.1.5:
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/iso-url/-/iso-url-1.2.1.tgz"
-  integrity sha512-9JPDgCN4B7QPkLtYAAOrEuAWvP9rWvR5offAr0/SeF046wIkglqH3VXgYYP6NcsKslH80UIVgmPqNe3j7tG2ng==
-
-isomorphic-ws@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/isomorphic-ws/-/isomorphic-ws-4.0.1.tgz"
-  integrity sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w==
-
-isstream@~0.1.2:
-  version "0.1.2"
-  resolved "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz"
-  integrity sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==
-
-it-all@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/it-all/-/it-all-1.0.6.tgz"
-  integrity sha512-3cmCc6Heqe3uWi3CVM/k51fa/XbMFpQVzFoDsV0IZNHSQDyAXl3c4MjHkFX5kF3922OGj7Myv1nSEUgRtcuM1A==
-
-it-first@^1.0.6:
-  version "1.0.7"
-  resolved "https://registry.npmjs.org/it-first/-/it-first-1.0.7.tgz"
-  integrity sha512-nvJKZoBpZD/6Rtde6FXqwDqDZGF1sCADmr2Zoc0hZsIvnE449gRFnGctxDf09Bzc/FWnHXAdaHVIetY6lrE0/g==
-
-it-glob@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/it-glob/-/it-glob-1.0.2.tgz"
-  integrity sha512-Ch2Dzhw4URfB9L/0ZHyY+uqOnKvBNeS/SMcRiPmJfpHiM0TsUZn+GkpcZxAoF3dJVdPm/PuIk3A4wlV7SUo23Q==
-  dependencies:
-    "@types/minimatch" "^3.0.4"
-    minimatch "^3.0.4"
-
-it-last@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/it-last/-/it-last-1.0.6.tgz"
-  integrity sha512-aFGeibeiX/lM4bX3JY0OkVCFkAw8+n9lkukkLNivbJRvNz8lI3YXv5xcqhFUV2lDJiraEK3OXRDbGuevnnR67Q==
-
-it-map@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/it-map/-/it-map-1.0.6.tgz"
-  integrity sha512-XT4/RM6UHIFG9IobGlQPFQUrlEKkU4eBUFG3qhWhfAdh1JfF2x11ShCrKCdmZ0OiZppPfoLuzcfA4cey6q3UAQ==
-
-it-peekable@^1.0.2:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/it-peekable/-/it-peekable-1.0.3.tgz"
-  integrity sha512-5+8zemFS+wSfIkSZyf0Zh5kNN+iGyccN02914BY4w/Dj+uoFEoPSvj5vaWn8pNZJNSxzjW0zHRxC3LUb2KWJTQ==
-
-it-to-stream@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/it-to-stream/-/it-to-stream-1.0.0.tgz"
-  integrity sha512-pLULMZMAB/+vbdvbZtebC0nWBTbG581lk6w8P7DfIIIKUfa8FbY7Oi0FxZcFPbxvISs7A9E+cMpLDBc1XhpAOA==
-  dependencies:
-    buffer "^6.0.3"
-    fast-fifo "^1.0.0"
-    get-iterator "^1.0.2"
-    p-defer "^3.0.0"
-    p-fifo "^1.0.0"
-    readable-stream "^3.6.0"
-
-jake@^10.6.1:
-  version "10.8.6"
-  resolved "https://registry.npmjs.org/jake/-/jake-10.8.6.tgz"
-  integrity sha512-G43Ub9IYEFfu72sua6rzooi8V8Gz2lkfk48rW20vEWCGizeaEPlKB1Kh8JIA84yQbiAEfqlPmSpGgCKKxH3rDA==
-  dependencies:
-    async "^3.2.3"
-    chalk "^4.0.2"
-    filelist "^1.0.4"
-    minimatch "^3.1.2"
-
-jake@^10.8.5:
-  version "10.8.5"
-  resolved "https://registry.npmjs.org/jake/-/jake-10.8.5.tgz"
-  integrity sha512-sVpxYeuAhWt0OTWITwT98oyV0GsXyMlXCF+3L1SuafBVUIr/uILGRB+NqwkzhgXKvoJpDIpQvqkUALgdmQsQxw==
-  dependencies:
-    async "^3.2.3"
-    chalk "^4.0.2"
-    filelist "^1.0.1"
-    minimatch "^3.0.4"
-
-jayson@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/jayson/-/jayson-4.0.0.tgz"
-  integrity sha512-v2RNpDCMu45fnLzSk47vx7I+QUaOsox6f5X0CUlabAFwxoP+8MfAY0NQRFwOEYXIxm8Ih5y6OaEa5KYiQMkyAA==
-  dependencies:
-    "@types/connect" "^3.4.33"
-    "@types/node" "^12.12.54"
-    "@types/ws" "^7.4.4"
-    JSONStream "^1.3.5"
-    commander "^2.20.3"
-    delay "^5.0.0"
-    es6-promisify "^5.0.0"
-    eyes "^0.1.8"
-    isomorphic-ws "^4.0.1"
-    json-stringify-safe "^5.0.1"
-    uuid "^8.3.2"
-    ws "^7.4.5"
-
-js-sha3@0.8.0, js-sha3@^0.8.0:
-  version "0.8.0"
-  resolved "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz"
-  integrity sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==
-
-js-tokens@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz"
-  integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
-
-js-yaml@3.14.1, js-yaml@^3.14.1:
-  version "3.14.1"
-  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz"
-  integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
-  dependencies:
-    argparse "^1.0.7"
-    esprima "^4.0.0"
-
-js-yaml@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz"
-  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
-  dependencies:
-    argparse "^2.0.1"
-
-jsbn@~0.1.0:
-  version "0.1.1"
-  resolved "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz"
-  integrity sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==
-
-json-parse-even-better-errors@^2.3.0:
-  version "2.3.1"
-  resolved "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz"
-  integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==
-
-json-schema-traverse@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz"
-  integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
-
-json-schema@0.4.0:
-  version "0.4.0"
-  resolved "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz"
-  integrity sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==
-
-json-stringify-safe@^5.0.1, json-stringify-safe@~5.0.1:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz"
-  integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==
-
-jsonfile@^6.0.1:
-  version "6.1.0"
-  resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz"
-  integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==
-  dependencies:
-    universalify "^2.0.0"
-  optionalDependencies:
-    graceful-fs "^4.1.6"
-
-jsonparse@^1.2.0:
-  version "1.3.1"
-  resolved "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz"
-  integrity sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==
-
-jsprim@^1.2.2:
-  version "1.4.2"
-  resolved "https://registry.npmjs.org/jsprim/-/jsprim-1.4.2.tgz"
-  integrity sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==
-  dependencies:
-    assert-plus "1.0.0"
-    extsprintf "1.3.0"
-    json-schema "0.4.0"
-    verror "1.10.0"
-
-keccak@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/keccak/-/keccak-3.0.3.tgz#4bc35ad917be1ef54ff246f904c2bbbf9ac61276"
-  integrity sha512-JZrLIAJWuZxKbCilMpNz5Vj7Vtb4scDG3dMXLOsbzBmQGyjwE61BbW7bJkfKKCShXiQZt3T6sBgALRtmd+nZaQ==
-  dependencies:
-    node-addon-api "^2.0.0"
-    node-gyp-build "^4.2.0"
-    readable-stream "^3.6.0"
-
-lines-and-columns@^1.1.6:
-  version "1.2.4"
-  resolved "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz"
-  integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
-
-lodash.camelcase@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz"
-  integrity sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==
-
-lodash.kebabcase@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.npmjs.org/lodash.kebabcase/-/lodash.kebabcase-4.1.1.tgz"
-  integrity sha512-N8XRTIMMqqDgSy4VLKPnJ/+hpGZN+PHQiJnSenYqPaVV/NCqEogTnAdZLQiGKhxX+JCs8waWq2t1XHWKOmlY8g==
-
-lodash.lowercase@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/lodash.lowercase/-/lodash.lowercase-4.3.0.tgz"
-  integrity sha512-UcvP1IZYyDKyEL64mmrwoA1AbFu5ahojhTtkOUr1K9dbuxzS9ev8i4TxMMGCqRC9TE8uDaSoufNAXxRPNTseVA==
-
-lodash.lowerfirst@^4.3.1:
-  version "4.3.1"
-  resolved "https://registry.npmjs.org/lodash.lowerfirst/-/lodash.lowerfirst-4.3.1.tgz"
-  integrity sha512-UUKX7VhP1/JL54NXg2aq/E1Sfnjjes8fNYTNkPU8ZmsaVeBvPHKdbNaN79Re5XRL01u6wbq3j0cbYZj71Fcu5w==
-
-lodash.pad@^4.5.1:
-  version "4.5.1"
-  resolved "https://registry.npmjs.org/lodash.pad/-/lodash.pad-4.5.1.tgz"
-  integrity sha512-mvUHifnLqM+03YNzeTBS1/Gr6JRFjd3rRx88FHWUvamVaT9k2O/kXha3yBSOwB9/DTQrSTLJNHvLBBt2FdX7Mg==
-
-lodash.padend@^4.6.1:
-  version "4.6.1"
-  resolved "https://registry.npmjs.org/lodash.padend/-/lodash.padend-4.6.1.tgz"
-  integrity sha512-sOQs2aqGpbl27tmCS1QNZA09Uqp01ZzWfDUoD+xzTii0E7dSQfRKcRetFwa+uXaxaqL+TKm7CgD2JdKP7aZBSw==
-
-lodash.padstart@^4.6.1:
-  version "4.6.1"
-  resolved "https://registry.npmjs.org/lodash.padstart/-/lodash.padstart-4.6.1.tgz"
-  integrity sha512-sW73O6S8+Tg66eY56DBk85aQzzUJDtpoXFBgELMd5P/SotAguo+1kYO6RuYgXxA4HJH3LFTFPASX6ET6bjfriw==
-
-lodash.repeat@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.npmjs.org/lodash.repeat/-/lodash.repeat-4.1.0.tgz"
-  integrity sha512-eWsgQW89IewS95ZOcr15HHCX6FVDxq3f2PNUIng3fyzsPev9imFQxIYdFZ6crl8L56UR6ZlGDLcEb3RZsCSSqw==
-
-lodash.snakecase@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.npmjs.org/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz"
-  integrity sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==
-
-lodash.startcase@^4.4.0:
-  version "4.4.0"
-  resolved "https://registry.npmjs.org/lodash.startcase/-/lodash.startcase-4.4.0.tgz"
-  integrity sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==
-
-lodash.trim@^4.5.1:
-  version "4.5.1"
-  resolved "https://registry.npmjs.org/lodash.trim/-/lodash.trim-4.5.1.tgz"
-  integrity sha512-nJAlRl/K+eiOehWKDzoBVrSMhK0K3A3YQsUNXHQa5yIrKBAhsZgSu3KoAFoFT+mEgiyBHddZ0pRk1ITpIp90Wg==
-
-lodash.trimend@^4.5.1:
-  version "4.5.1"
-  resolved "https://registry.npmjs.org/lodash.trimend/-/lodash.trimend-4.5.1.tgz"
-  integrity sha512-lsD+k73XztDsMBKPKvzHXRKFNMohTjoTKIIo4ADLn5dA65LZ1BqlAvSXhR2rPEC3BgAUQnzMnorqDtqn2z4IHA==
-
-lodash.trimstart@^4.5.1:
-  version "4.5.1"
-  resolved "https://registry.npmjs.org/lodash.trimstart/-/lodash.trimstart-4.5.1.tgz"
-  integrity sha512-b/+D6La8tU76L/61/aN0jULWHkT0EeJCmVstPBn/K9MtD2qBW83AsBNrr63dKuWYwVMO7ucv13QNO/Ek/2RKaQ==
-
-lodash.uppercase@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/lodash.uppercase/-/lodash.uppercase-4.3.0.tgz"
-  integrity sha512-+Nbnxkj7s8K5U8z6KnEYPGUOGp3woZbB7Ecs7v3LkkjLQSm2kP9SKIILitN1ktn2mB/tmM9oSlku06I+/lH7QA==
-
-lodash.upperfirst@^4.3.1:
-  version "4.3.1"
-  resolved "https://registry.npmjs.org/lodash.upperfirst/-/lodash.upperfirst-4.3.1.tgz"
-  integrity sha512-sReKOYJIJf74dhJONhU4e0/shzi1trVbSWDOhKYE5XV2O+H7Sb2Dihwuc7xWxVl+DgFPyTqIN3zMfT9cq5iWDg==
-
-log-symbols@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/log-symbols/-/log-symbols-3.0.0.tgz"
-  integrity sha512-dSkNGuI7iG3mfvDzUuYZyvk5dD9ocYCYzNU6CYDE6+Xqd+gwme6Z00NS3dUh8mq/73HaEtT7m6W+yUPtU6BZnQ==
-  dependencies:
-    chalk "^2.4.2"
-
-long@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/long/-/long-4.0.0.tgz"
-  integrity sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==
-
-long@^5.2.0:
-  version "5.2.3"
-  resolved "https://registry.npmjs.org/long/-/long-5.2.3.tgz"
-  integrity sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q==
-
-lru-cache@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz"
-  integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
-  dependencies:
-    yallist "^4.0.0"
-
-lru-cache@^9.0.0:
-  version "9.1.2"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-9.1.2.tgz#255fdbc14b75589d6d0e73644ca167a8db506835"
-  integrity sha512-ERJq3FOzJTxBbFjZ7iDs+NiK4VI9Wz+RdrrAB8dio1oV+YvdPzUEE4QNiT2VD51DkIbCYRUUzCRkssXCHqSnKQ==
-
-make-error@^1.1.1:
-  version "1.3.6"
-  resolved "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz"
-  integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
-
-md5.js@^1.3.4:
-  version "1.3.5"
-  resolved "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz"
-  integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==
-  dependencies:
-    hash-base "^3.0.0"
-    inherits "^2.0.1"
-    safe-buffer "^5.1.2"
-
-merge-options@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.npmjs.org/merge-options/-/merge-options-3.0.4.tgz"
-  integrity sha512-2Sug1+knBjkaMsMgf1ctR1Ujx+Ayku4EdJN4Z+C2+JzoeF7A3OZ9KM2GY0CpQS51NR61LTurMJrRKPhSs3ZRTQ==
-  dependencies:
-    is-plain-obj "^2.1.0"
-
-merge-stream@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz"
-  integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
-
-merge2@^1.3.0, merge2@^1.4.1:
-  version "1.4.1"
-  resolved "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz"
-  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
-
-micromatch@^4.0.4:
-  version "4.0.5"
-  resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz"
-  integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==
-  dependencies:
-    braces "^3.0.2"
-    picomatch "^2.3.1"
-
-mime-db@1.52.0:
-  version "1.52.0"
-  resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz"
-  integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
-
-mime-types@^2.1.12, mime-types@~2.1.19:
-  version "2.1.35"
-  resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz"
-  integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
-  dependencies:
-    mime-db "1.52.0"
-
-mimic-fn@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz"
-  integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
-
-minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz"
-  integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
-
-minimalistic-crypto-utils@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz"
-  integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=
-
-minimatch@^3.0.2, minimatch@^3.0.4, minimatch@^3.1.1, minimatch@^3.1.2:
-  version "3.1.2"
-  resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz"
-  integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
-  dependencies:
-    brace-expansion "^1.1.7"
-
-minimatch@^5.0.1:
-  version "5.1.6"
-  resolved "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz"
-  integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==
-  dependencies:
-    brace-expansion "^2.0.1"
-
-minimatch@^8.0.2:
-  version "8.0.4"
-  resolved "https://registry.npmjs.org/minimatch/-/minimatch-8.0.4.tgz"
-  integrity sha512-W0Wvr9HyFXZRGIDgCicunpQ299OKXs9RgZfaukz4qAW/pJhcpUfupc9c+OObPOFueNy8VSrZgEmDtk6Kh4WzDA==
-  dependencies:
-    brace-expansion "^2.0.1"
-
-minimist@^1.2.6:
-  version "1.2.6"
-  resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz"
-  integrity sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==
-
-minipass@^3.0.0:
-  version "3.3.4"
-  resolved "https://registry.npmjs.org/minipass/-/minipass-3.3.4.tgz"
-  integrity sha512-I9WPbWHCGu8W+6k1ZiGpPu0GkoKBeorkfKNuAFBNS1HNFJvke82sxvI5bzcCNpWPorkOO5QQ+zomzzwRxejXiw==
-  dependencies:
-    yallist "^4.0.0"
-
-minipass@^4.2.4:
-  version "4.2.8"
-  resolved "https://registry.npmjs.org/minipass/-/minipass-4.2.8.tgz"
-  integrity sha512-fNzuVyifolSLFL4NzpF+wEF4qrgqaaKX0haXPQEdQ7NKAN+WecoKMHV09YcuL/DHxrUsYQOK3MiuDf7Ip2OXfQ==
-
-minipass@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz"
-  integrity sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==
-
-minizlib@^2.1.1:
-  version "2.1.2"
-  resolved "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz"
-  integrity sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==
-  dependencies:
-    minipass "^3.0.0"
-    yallist "^4.0.0"
-
-mkdirp@^0.5.1:
-  version "0.5.6"
-  resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz"
-  integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==
-  dependencies:
-    minimist "^1.2.6"
-
-mkdirp@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz"
-  integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
-
-ms@2.1.2:
-  version "2.1.2"
-  resolved "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz"
-  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
-
-ms@^2.1.1:
-  version "2.1.3"
-  resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz"
-  integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
-
-multiaddr-to-uri@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.npmjs.org/multiaddr-to-uri/-/multiaddr-to-uri-8.0.0.tgz"
-  integrity sha512-dq4p/vsOOUdVEd1J1gl+R2GFrXJQH8yjLtz4hodqdVbieg39LvBOdMQRdQnfbg5LSM/q1BYNVf5CBbwZFFqBgA==
-  dependencies:
-    multiaddr "^10.0.0"
-
-multiaddr@^10.0.0:
-  version "10.0.1"
-  resolved "https://registry.npmjs.org/multiaddr/-/multiaddr-10.0.1.tgz"
-  integrity sha512-G5upNcGzEGuTHkzxezPrrD6CaIHR9uo+7MwqhNVcXTs33IInon4y7nMiGxl2CY5hG7chvYQUQhz5V52/Qe3cbg==
-  dependencies:
-    dns-over-http-resolver "^1.2.3"
-    err-code "^3.0.1"
-    is-ip "^3.1.0"
-    multiformats "^9.4.5"
-    uint8arrays "^3.0.0"
-    varint "^6.0.0"
-
-multiformats@^9.4.13, multiformats@^9.4.2, multiformats@^9.4.5, multiformats@^9.5.4:
-  version "9.9.0"
-  resolved "https://registry.npmjs.org/multiformats/-/multiformats-9.9.0.tgz"
-  integrity sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg==
-
-mustache@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/mustache/-/mustache-4.2.0.tgz#e5892324d60a12ec9c2a73359edca52972bf6f64"
-  integrity sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==
-
-nanoid@^3.0.2, nanoid@^3.1.20, nanoid@^3.1.23:
-  version "3.3.6"
-  resolved "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz"
-  integrity sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==
-
-native-abort-controller@^1.0.3, native-abort-controller@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/native-abort-controller/-/native-abort-controller-1.0.4.tgz"
-  integrity sha512-zp8yev7nxczDJMoP6pDxyD20IU0T22eX8VwN2ztDccKvSZhRaV33yP1BGwKSZfXuqWUzsXopVFjBdau9OOAwMQ==
-
-native-fetch@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/native-fetch/-/native-fetch-3.0.0.tgz"
-  integrity sha512-G3Z7vx0IFb/FQ4JxvtqGABsOTIqRWvgQz6e+erkB+JJD6LrszQtMozEHI4EkmgZQvnGHrpLVzUWk7t4sJCIkVw==
-
-natural-orderby@^2.0.3:
-  version "2.0.3"
-  resolved "https://registry.npmjs.org/natural-orderby/-/natural-orderby-2.0.3.tgz"
-  integrity sha512-p7KTHxU0CUrcOXe62Zfrb5Z13nLvPhSWR/so3kFulUQU0sgUll2Z0LwpsLN351eOOD+hRGu/F1g+6xDfPeD++Q==
-
-nice-try@^1.0.4:
-  version "1.0.5"
-  resolved "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz"
-  integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==
-
-node-addon-api@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/node-addon-api/-/node-addon-api-2.0.2.tgz"
-  integrity sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==
-
-node-fetch@^2.6.8:
-  version "2.6.9"
-  resolved "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.9.tgz"
-  integrity sha512-DJm/CJkZkRjKKj4Zi4BsKVZh3ValV5IR5s7LVZnW+6YMh0W1BfNA8XSs6DLMGYlId5F3KnA70uu2qepcR08Qqg==
-  dependencies:
-    whatwg-url "^5.0.0"
-
-node-gyp-build@^4.2.0:
-  version "4.5.0"
-  resolved "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.5.0.tgz"
-  integrity sha512-2iGbaQBV+ITgCz76ZEjmhUKAKVf7xfY1sRl4UiKQspfZMH2h06SyhNsnSVy50cwkFQDGLyif6m/6uFXHkOZ6rg==
-
-normalize-path@^3.0.0, normalize-path@~3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz"
-  integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
-
-npm-run-path@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz"
-  integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
-  dependencies:
-    path-key "^3.0.0"
-
-number-to-bn@1.7.0:
-  version "1.7.0"
-  resolved "https://registry.npmjs.org/number-to-bn/-/number-to-bn-1.7.0.tgz"
-  integrity sha512-wsJ9gfSz1/s4ZsJN01lyonwuxA1tml6X1yBDnfpMglypcBRFZZkus26EdPSlqS5GJfYddVZa22p3VNb3z5m5Ig==
-  dependencies:
-    bn.js "4.11.6"
-    strip-hex-prefix "1.0.0"
-
-oauth-sign@~0.9.0:
-  version "0.9.0"
-  resolved "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz"
-  integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==
-
-object-assign@^4.1.0:
-  version "4.1.1"
-  resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz"
-  integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
-
-object-inspect@^1.9.0:
-  version "1.12.2"
-  resolved "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.2.tgz"
-  integrity sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ==
-
-object-treeify@^1.1.33:
-  version "1.1.33"
-  resolved "https://registry.npmjs.org/object-treeify/-/object-treeify-1.1.33.tgz"
-  integrity sha512-EFVjAYfzWqWsBMRHPMAXLCDIJnpMhdWAqR7xG6M6a2cs6PMFpl/+Z20w9zDW4vkxOFfddegBKq9Rehd0bxWE7A==
-
-once@^1.3.0, once@^1.3.1, once@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz"
-  integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
-  dependencies:
-    wrappy "1"
-
-onetime@^5.1.0, onetime@^5.1.2:
-  version "5.1.2"
-  resolved "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz"
-  integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
-  dependencies:
-    mimic-fn "^2.1.0"
-
-ora@4.0.2:
-  version "4.0.2"
-  resolved "https://registry.npmjs.org/ora/-/ora-4.0.2.tgz"
-  integrity sha512-YUOZbamht5mfLxPmk4M35CD/5DuOkAacxlEUbStVXpBAt4fyhBf+vZHI/HRkI++QUp3sNoeA2Gw4C+hi4eGSig==
-  dependencies:
-    chalk "^2.4.2"
-    cli-cursor "^3.1.0"
-    cli-spinners "^2.2.0"
-    is-interactive "^1.0.0"
-    log-symbols "^3.0.0"
-    strip-ansi "^5.2.0"
-    wcwidth "^1.0.1"
-
-p-defer@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/p-defer/-/p-defer-3.0.0.tgz"
-  integrity sha512-ugZxsxmtTln604yeYd29EGrNhazN2lywetzpKhfmQjW/VJmhpDmWbiX+h0zL8V91R0UXkhb3KtPmyq9PZw3aYw==
-
-p-fifo@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/p-fifo/-/p-fifo-1.0.0.tgz"
-  integrity sha512-IjoCxXW48tqdtDFz6fqo5q1UfFVjjVZe8TC1QRflvNUJtNfCUhxOUw6MOVZhDPjqhSzc26xKdugsO17gmzd5+A==
-  dependencies:
-    fast-fifo "^1.0.0"
-    p-defer "^3.0.0"
-
-parent-module@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz"
-  integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
-  dependencies:
-    callsites "^3.0.0"
-
-parse-cache-control@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/parse-cache-control/-/parse-cache-control-1.0.1.tgz"
-  integrity sha512-60zvsJReQPX5/QP0Kzfd/VrpjScIQ7SHBW6bFCYfEP+fp0Eppr1SHhIO5nd1PjZtvclzSzES9D/p5nFJurwfWg==
-
-parse-duration@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/parse-duration/-/parse-duration-1.0.3.tgz"
-  integrity sha512-o6NAh12na5VvR6nFejkU0gpQ8jmOY9Y9sTU2ke3L3G/d/3z8jqmbBbeyBGHU73P4JLXfc7tJARygIK3WGIkloA==
-
-parse-json@^5.0.0:
-  version "5.2.0"
-  resolved "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz"
-  integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==
-  dependencies:
-    "@babel/code-frame" "^7.0.0"
-    error-ex "^1.3.1"
-    json-parse-even-better-errors "^2.3.0"
-    lines-and-columns "^1.1.6"
-
-password-prompt@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/password-prompt/-/password-prompt-1.1.2.tgz"
-  integrity sha512-bpuBhROdrhuN3E7G/koAju0WjVw9/uQOG5Co5mokNj0MiOSBVZS1JTwM4zl55hu0WFmIEFvO9cU9sJQiBIYeIA==
-  dependencies:
-    ansi-escapes "^3.1.0"
-    cross-spawn "^6.0.5"
-
-path-is-absolute@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz"
-  integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
-
-path-key@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz"
-  integrity sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw==
-
-path-key@^3.0.0, path-key@^3.1.0:
-  version "3.1.1"
-  resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz"
-  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
-
-path-scurry@^1.6.1:
-  version "1.7.0"
-  resolved "https://registry.npmjs.org/path-scurry/-/path-scurry-1.7.0.tgz"
-  integrity sha512-UkZUeDjczjYRE495+9thsgcVgsaCPkaw80slmfVFgllxY+IO8ubTsOpFVjDPROBqJdHfVPUFRHPBV/WciOVfWg==
-  dependencies:
-    lru-cache "^9.0.0"
-    minipass "^5.0.0"
-
-path-type@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz"
-  integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
-
-pbkdf2@^3.0.17:
-  version "3.1.2"
-  resolved "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.2.tgz"
-  integrity sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==
-  dependencies:
-    create-hash "^1.1.2"
-    create-hmac "^1.1.4"
-    ripemd160 "^2.0.1"
-    safe-buffer "^5.0.1"
-    sha.js "^2.4.8"
-
-performance-now@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz"
-  integrity sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==
-
-picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
-  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
-
-pluralize@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.npmjs.org/pluralize/-/pluralize-8.0.0.tgz"
-  integrity sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==
-
-prettier@1.19.1:
-  version "1.19.1"
-  resolved "https://registry.npmjs.org/prettier/-/prettier-1.19.1.tgz"
-  integrity sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew==
-
-process-nextick-args@~2.0.0:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz"
-  integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
-
-promise@^8.0.0:
-  version "8.1.0"
-  resolved "https://registry.npmjs.org/promise/-/promise-8.1.0.tgz"
-  integrity sha512-W04AqnILOL/sPRXziNicCjSNRruLAuIHEOVBazepu0545DDNGYHz7ar9ZgZ1fMU8/MA4mVxp5rkBWRi6OXIy3Q==
-  dependencies:
-    asap "~2.0.6"
-
-protobufjs@^6.10.2:
-  version "6.11.3"
-  resolved "https://registry.npmjs.org/protobufjs/-/protobufjs-6.11.3.tgz"
-  integrity sha512-xL96WDdCZYdU7Slin569tFX712BxsxslWwAfAhCYjQKGTq7dAU91Lomy6nLLhh/dyGhk/YH4TwTSRxTzhuHyZg==
-  dependencies:
-    "@protobufjs/aspromise" "^1.1.2"
-    "@protobufjs/base64" "^1.1.2"
-    "@protobufjs/codegen" "^2.0.4"
-    "@protobufjs/eventemitter" "^1.1.0"
-    "@protobufjs/fetch" "^1.1.0"
-    "@protobufjs/float" "^1.0.2"
-    "@protobufjs/inquire" "^1.1.0"
-    "@protobufjs/path" "^1.1.2"
-    "@protobufjs/pool" "^1.1.0"
-    "@protobufjs/utf8" "^1.1.0"
-    "@types/long" "^4.0.1"
-    "@types/node" ">=13.7.0"
-    long "^4.0.0"
-
-psl@^1.1.28:
-  version "1.9.0"
-  resolved "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz"
-  integrity sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==
-
-pump@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/pump/-/pump-1.0.3.tgz"
-  integrity sha512-8k0JupWme55+9tCVE+FS5ULT3K6AbgqrGa58lTT49RpyfwwcGedHqaC5LlQNdEAumn/wFsu6aPwkuPMioy8kqw==
-  dependencies:
-    end-of-stream "^1.1.0"
-    once "^1.3.1"
-
-punycode@^1.3.2:
-  version "1.4.1"
-  resolved "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz"
-  integrity sha512-jmYNElW7yvO7TV33CjSmvSiE2yco3bV2czu/OzDKdMNVZQWfxCblURLhf+47syQRBntjfLdd/H0egrzIG+oaFQ==
-
-punycode@^2.1.0, punycode@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz"
-  integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
-
-pvtsutils@^1.3.2:
-  version "1.3.2"
-  resolved "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.2.tgz"
-  integrity sha512-+Ipe2iNUyrZz+8K/2IOo+kKikdtfhRKzNpQbruF2URmqPtoqAs8g3xS7TJvFF2GcPXjh7DkqMnpVveRFq4PgEQ==
-  dependencies:
-    tslib "^2.4.0"
-
-pvutils@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.npmjs.org/pvutils/-/pvutils-1.1.3.tgz"
-  integrity sha512-pMpnA0qRdFp32b1sJl1wOJNxZLQ2cbQx+k6tjNtZ8CpvVhNqEPRgivZ2WOUev2YMajecdH7ctUPDvEe87nariQ==
-
-qs@^6.4.0:
-  version "6.11.2"
-  resolved "https://registry.yarnpkg.com/qs/-/qs-6.11.2.tgz#64bea51f12c1f5da1bc01496f48ffcff7c69d7d9"
-  integrity sha512-tDNIz22aBzCDxLtVH++VnTfzxlfeK5CbqohpSqpJgj1Wg/cQbStNAz3NuqCs5vV+pjBsK4x4pN9HlVh7rcYRiA==
-  dependencies:
-    side-channel "^1.0.4"
-
-qs@~6.5.2:
-  version "6.5.3"
-  resolved "https://registry.npmjs.org/qs/-/qs-6.5.3.tgz"
-  integrity sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==
-
-queue-microtask@^1.2.2:
-  version "1.2.2"
-  resolved "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.2.tgz"
-  integrity sha512-dB15eXv3p2jDlbOiNLyMabYg1/sXvppd8DP2J3EOCQ0AkuSXCW2tP7mnVouVLJKgUMY6yP0kcQDVpLCN13h4Xg==
-
-randombytes@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz"
-  integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
-  dependencies:
-    safe-buffer "^5.1.0"
-
-react-native-fetch-api@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/react-native-fetch-api/-/react-native-fetch-api-3.0.0.tgz"
-  integrity sha512-g2rtqPjdroaboDKTsJCTlcmtw54E25OjyaunUP0anOZn4Fuo2IKs8BVfe02zVggA/UysbmfSnRJIqtNkAgggNA==
-  dependencies:
-    p-defer "^3.0.0"
-
-readable-stream@^2.2.2, readable-stream@^2.3.0, readable-stream@^2.3.5:
-  version "2.3.7"
-  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz"
-  integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==
-  dependencies:
-    core-util-is "~1.0.0"
-    inherits "~2.0.3"
-    isarray "~1.0.0"
-    process-nextick-args "~2.0.0"
-    safe-buffer "~5.1.1"
-    string_decoder "~1.1.1"
-    util-deprecate "~1.0.1"
-
-readable-stream@^3.6.0:
-  version "3.6.0"
-  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz"
-  integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
-  dependencies:
-    inherits "^2.0.3"
-    string_decoder "^1.1.1"
-    util-deprecate "^1.0.1"
-
-readable-stream@~1.0.26-4:
-  version "1.0.34"
-  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz"
-  integrity sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=
-  dependencies:
-    core-util-is "~1.0.0"
-    inherits "~2.0.1"
-    isarray "0.0.1"
-    string_decoder "~0.10.x"
-
-readdirp@~3.6.0:
-  version "3.6.0"
-  resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz"
-  integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
-  dependencies:
-    picomatch "^2.2.1"
-
-receptacle@^1.3.2:
-  version "1.3.2"
-  resolved "https://registry.npmjs.org/receptacle/-/receptacle-1.3.2.tgz"
-  integrity sha512-HrsFvqZZheusncQRiEE7GatOAETrARKV/lnfYicIm8lbvp/JQOdADOfhjBd2DajvoszEyxSM6RlAAIZgEoeu/A==
-  dependencies:
-    ms "^2.1.1"
-
-redeyed@~2.1.0:
-  version "2.1.1"
-  resolved "https://registry.npmjs.org/redeyed/-/redeyed-2.1.1.tgz"
-  integrity sha512-FNpGGo1DycYAdnrKFxCMmKYgo/mILAqtRYbkdQD8Ep/Hk2PQ5+aEAEx+IU713RTDmuBaH0c8P5ZozurNu5ObRQ==
-  dependencies:
-    esprima "~4.0.0"
-
-request@2.88.2:
-  version "2.88.2"
-  resolved "https://registry.npmjs.org/request/-/request-2.88.2.tgz"
-  integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==
-  dependencies:
-    aws-sign2 "~0.7.0"
-    aws4 "^1.8.0"
-    caseless "~0.12.0"
-    combined-stream "~1.0.6"
-    extend "~3.0.2"
-    forever-agent "~0.6.1"
-    form-data "~2.3.2"
-    har-validator "~5.1.3"
-    http-signature "~1.2.0"
-    is-typedarray "~1.0.0"
-    isstream "~0.1.2"
-    json-stringify-safe "~5.0.1"
-    mime-types "~2.1.19"
-    oauth-sign "~0.9.0"
-    performance-now "^2.1.0"
-    qs "~6.5.2"
-    safe-buffer "^5.1.2"
-    tough-cookie "~2.5.0"
-    tunnel-agent "^0.6.0"
-    uuid "^3.3.2"
-
-resolve-from@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz"
-  integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
-
-restore-cursor@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz"
-  integrity sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==
-  dependencies:
-    onetime "^5.1.0"
-    signal-exit "^3.0.2"
-
-retimer@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/retimer/-/retimer-3.0.0.tgz"
-  integrity sha512-WKE0j11Pa0ZJI5YIk0nflGI7SQsfl2ljihVy7ogh7DeQSeYAUi0ubZ/yEueGtDfUPk6GH5LRw1hBdLq4IwUBWA==
-
-reusify@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz"
-  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
-
-rimraf@^2.6.3:
-  version "2.7.1"
-  resolved "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz"
-  integrity sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==
-  dependencies:
-    glob "^7.1.3"
-
-rimraf@^3.0.0, rimraf@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz"
-  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
-  dependencies:
-    glob "^7.1.3"
-
-ripemd160@^2.0.0, ripemd160@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz"
-  integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==
-  dependencies:
-    hash-base "^3.0.0"
-    inherits "^2.0.1"
-
-rlp@^2.2.4:
-  version "2.2.7"
-  resolved "https://registry.npmjs.org/rlp/-/rlp-2.2.7.tgz"
-  integrity sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==
-  dependencies:
-    bn.js "^5.2.0"
-
-run-parallel@^1.1.9:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz"
-  integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
-  dependencies:
-    queue-microtask "^1.2.2"
-
-safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@^5.2.0, safe-buffer@~5.2.0:
-  version "5.2.1"
-  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz"
-  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
-
-safe-buffer@~5.1.0, safe-buffer@~5.1.1:
-  version "5.1.2"
-  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz"
-  integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
-
-"safer-buffer@>= 2.1.2 < 3.0.0", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
-  version "2.1.2"
-  resolved "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz"
-  integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
-
-scrypt-js@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/scrypt-js/-/scrypt-js-3.0.1.tgz"
-  integrity sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==
-
-secp256k1@^4.0.1:
-  version "4.0.3"
-  resolved "https://registry.npmjs.org/secp256k1/-/secp256k1-4.0.3.tgz"
-  integrity sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA==
-  dependencies:
-    elliptic "^6.5.4"
-    node-addon-api "^2.0.0"
-    node-gyp-build "^4.2.0"
-
-semver@7.3.5:
-  version "7.3.5"
-  resolved "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz"
-  integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==
-  dependencies:
-    lru-cache "^6.0.0"
-
-semver@7.4.0:
-  version "7.4.0"
-  resolved "https://registry.npmjs.org/semver/-/semver-7.4.0.tgz"
-  integrity sha512-RgOxM8Mw+7Zus0+zcLEUn8+JfoLpj/huFTItQy2hsM4khuC1HYRDp0cU482Ewn/Fcy6bCjufD8vAj7voC66KQw==
-  dependencies:
-    lru-cache "^6.0.0"
-
-semver@^5.5.0:
-  version "5.7.1"
-  resolved "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz"
-  integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
-
-semver@^7.3.7:
-  version "7.5.0"
-  resolved "https://registry.npmjs.org/semver/-/semver-7.5.0.tgz"
-  integrity sha512-+XC0AD/R7Q2mPSRuy2Id0+CGTZ98+8f+KvwirxOKIEyid+XSx6HbC63p+O4IndTHuX5Z+JxQ0TghCkO5Cg/2HA==
-  dependencies:
-    lru-cache "^6.0.0"
-
-setimmediate@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz"
-  integrity sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==
-
-sha.js@^2.4.0, sha.js@^2.4.8:
-  version "2.4.11"
-  resolved "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz"
-  integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==
-  dependencies:
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-shebang-command@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz"
-  integrity sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==
-  dependencies:
-    shebang-regex "^1.0.0"
-
-shebang-command@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz"
-  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
-  dependencies:
-    shebang-regex "^3.0.0"
-
-shebang-regex@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz"
-  integrity sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==
-
-shebang-regex@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz"
-  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
-
-side-channel@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz"
-  integrity sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==
-  dependencies:
-    call-bind "^1.0.0"
-    get-intrinsic "^1.0.2"
-    object-inspect "^1.9.0"
-
-signal-exit@^3.0.2, signal-exit@^3.0.3:
-  version "3.0.7"
-  resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz"
-  integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
-
-slash@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz"
-  integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
-
-slice-ansi@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b"
-  integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==
-  dependencies:
-    ansi-styles "^4.0.0"
-    astral-regex "^2.0.0"
-    is-fullwidth-code-point "^3.0.0"
-
-source-map-support@^0.5.20:
-  version "0.5.21"
-  resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz"
-  integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
-  dependencies:
-    buffer-from "^1.0.0"
-    source-map "^0.6.0"
-
-source-map@^0.6.0:
-  version "0.6.1"
-  resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz"
-  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
-
-split-ca@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/split-ca/-/split-ca-1.0.1.tgz"
-  integrity sha512-Q5thBSxp5t8WPTTJQS59LrGqOZqOsrhDGDVm8azCqIBjSBd7nd9o2PM+mDulQQkh8h//4U6hFZnc/mul8t5pWQ==
-
-sprintf-js@~1.0.2:
-  version "1.0.3"
-  resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz"
-  integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==
-
-sshpk@^1.7.0:
-  version "1.17.0"
-  resolved "https://registry.npmjs.org/sshpk/-/sshpk-1.17.0.tgz"
-  integrity sha512-/9HIEs1ZXGhSPE8X6Ccm7Nam1z8KcoCqPdI7ecm1N33EzAetWahvQWVqLZtaZQ+IDKX4IyA2o0gBzqIMkAagHQ==
-  dependencies:
-    asn1 "~0.2.3"
-    assert-plus "^1.0.0"
-    bcrypt-pbkdf "^1.0.0"
-    dashdash "^1.12.0"
-    ecc-jsbn "~0.1.1"
-    getpass "^0.1.1"
-    jsbn "~0.1.0"
-    safer-buffer "^2.0.2"
-    tweetnacl "~0.14.0"
-
-stream-to-it@^0.2.2:
-  version "0.2.4"
-  resolved "https://registry.npmjs.org/stream-to-it/-/stream-to-it-0.2.4.tgz"
-  integrity sha512-4vEbkSs83OahpmBybNJXlJd7d6/RxzkkSdT3I0mnGt79Xd2Kk+e1JqbvAvsQfCeKj3aKb0QIWkyK3/n0j506vQ==
-  dependencies:
-    get-iterator "^1.0.2"
-
-streamsearch@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.npmjs.org/streamsearch/-/streamsearch-1.1.0.tgz"
-  integrity sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==
-
-string-width@^4.0.0, string-width@^4.2.3:
-  version "4.2.3"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
-  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
-  dependencies:
-    emoji-regex "^8.0.0"
-    is-fullwidth-code-point "^3.0.0"
-    strip-ansi "^6.0.1"
-
-string-width@^4.1.0, string-width@^4.2.0:
-  version "4.2.2"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz"
-  integrity sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==
-  dependencies:
-    emoji-regex "^8.0.0"
-    is-fullwidth-code-point "^3.0.0"
-    strip-ansi "^6.0.0"
-
-string_decoder@^1.1.1:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz"
-  integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
-  dependencies:
-    safe-buffer "~5.2.0"
-
-string_decoder@~0.10.x:
-  version "0.10.31"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz"
-  integrity sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==
-
-string_decoder@~1.1.1:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz"
-  integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
-  dependencies:
-    safe-buffer "~5.1.0"
-
-strip-ansi@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz"
-  integrity sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==
-  dependencies:
-    ansi-regex "^4.1.0"
-
-strip-ansi@^6.0.0, strip-ansi@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
-  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
-  dependencies:
-    ansi-regex "^5.0.1"
-
-strip-final-newline@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz"
-  integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
-
-strip-hex-prefix@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz"
-  integrity sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==
-  dependencies:
-    is-hex-prefixed "1.0.0"
-
-supports-color@^5.3.0:
-  version "5.5.0"
-  resolved "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz"
-  integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
-  dependencies:
-    has-flag "^3.0.0"
-
-supports-color@^7.0.0, supports-color@^7.1.0:
-  version "7.2.0"
-  resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz"
-  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
-  dependencies:
-    has-flag "^4.0.0"
-
-supports-color@^8.1.1:
-  version "8.1.1"
-  resolved "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz"
-  integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==
-  dependencies:
-    has-flag "^4.0.0"
-
-supports-hyperlinks@^2.2.0:
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-2.3.0.tgz"
-  integrity sha512-RpsAZlpWcDwOPQA22aCH4J0t7L8JmAvsCxfOSEwm7cQs3LshN36QaTkwd70DnBOXDWGssw2eUoc8CaRWT0XunA==
-  dependencies:
-    has-flag "^4.0.0"
-    supports-color "^7.0.0"
-
-sync-request@6.1.0:
-  version "6.1.0"
-  resolved "https://registry.npmjs.org/sync-request/-/sync-request-6.1.0.tgz"
-  integrity sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw==
-  dependencies:
-    http-response-object "^3.0.1"
-    sync-rpc "^1.2.1"
-    then-request "^6.0.0"
-
-sync-rpc@^1.2.1:
-  version "1.3.6"
-  resolved "https://registry.npmjs.org/sync-rpc/-/sync-rpc-1.3.6.tgz"
-  integrity sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw==
-  dependencies:
-    get-port "^3.1.0"
-
-tar-fs@~1.16.3:
-  version "1.16.3"
-  resolved "https://registry.npmjs.org/tar-fs/-/tar-fs-1.16.3.tgz"
-  integrity sha512-NvCeXpYx7OsmOh8zIOP/ebG55zZmxLE0etfWRbWok+q2Qo8x/vOR/IJT1taADXPe+jsiu9axDb3X4B+iIgNlKw==
-  dependencies:
-    chownr "^1.0.1"
-    mkdirp "^0.5.1"
-    pump "^1.0.0"
-    tar-stream "^1.1.2"
-
-tar-stream@^1.1.2:
-  version "1.6.2"
-  resolved "https://registry.npmjs.org/tar-stream/-/tar-stream-1.6.2.tgz"
-  integrity sha512-rzS0heiNf8Xn7/mpdSVVSMAWAoy9bfb1WOTYC78Z0UQKeKa/CWS8FOq0lKGNa8DWKAn9gxjCvMLYc5PGXYlK2A==
-  dependencies:
-    bl "^1.0.0"
-    buffer-alloc "^1.2.0"
-    end-of-stream "^1.0.0"
-    fs-constants "^1.0.0"
-    readable-stream "^2.3.0"
-    to-buffer "^1.1.1"
-    xtend "^4.0.0"
-
-tar@^6.1.0:
-  version "6.1.11"
-  resolved "https://registry.npmjs.org/tar/-/tar-6.1.11.tgz"
-  integrity sha512-an/KZQzQUkZCkuoAA64hM92X0Urb6VpRhAFllDzz44U2mcD5scmT3zBc4VgVpkugF580+DQn8eAFSyoQt0tznA==
-  dependencies:
-    chownr "^2.0.0"
-    fs-minipass "^2.0.0"
-    minipass "^3.0.0"
-    minizlib "^2.1.1"
-    mkdirp "^1.0.3"
-    yallist "^4.0.0"
-
-then-request@^6.0.0:
-  version "6.0.2"
-  resolved "https://registry.npmjs.org/then-request/-/then-request-6.0.2.tgz"
-  integrity sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA==
-  dependencies:
-    "@types/concat-stream" "^1.6.0"
-    "@types/form-data" "0.0.33"
-    "@types/node" "^8.0.0"
-    "@types/qs" "^6.2.31"
-    caseless "~0.12.0"
-    concat-stream "^1.6.0"
-    form-data "^2.2.0"
-    http-basic "^8.1.1"
-    http-response-object "^3.0.1"
-    promise "^8.0.0"
-    qs "^6.4.0"
-
-"through@>=2.2.7 <3":
-  version "2.3.8"
-  resolved "https://registry.npmjs.org/through/-/through-2.3.8.tgz"
-  integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==
-
-timeout-abort-controller@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/timeout-abort-controller/-/timeout-abort-controller-2.0.0.tgz"
-  integrity sha512-2FAPXfzTPYEgw27bQGTHc0SzrbmnU2eso4qo172zMLZzaGqeu09PFa5B2FCUHM1tflgRqPgn5KQgp6+Vex4uNA==
-  dependencies:
-    abort-controller "^3.0.0"
-    native-abort-controller "^1.0.4"
-    retimer "^3.0.0"
-
-tmp-promise@3.0.3:
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/tmp-promise/-/tmp-promise-3.0.3.tgz"
-  integrity sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==
-  dependencies:
-    tmp "^0.2.0"
-
-tmp@^0.2.0:
-  version "0.2.1"
-  resolved "https://registry.npmjs.org/tmp/-/tmp-0.2.1.tgz"
-  integrity sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==
-  dependencies:
-    rimraf "^3.0.0"
-
-to-buffer@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.npmjs.org/to-buffer/-/to-buffer-1.1.1.tgz"
-  integrity sha512-lx9B5iv7msuFYE3dytT+KE5tap+rNYw+K4jVkb9R/asAb+pbBSM17jtunHplhBe6RRJdZx3Pn2Jph24O32mOVg==
-
-to-regex-range@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz"
-  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
-  dependencies:
-    is-number "^7.0.0"
-
-tough-cookie@~2.5.0:
-  version "2.5.0"
-  resolved "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz"
-  integrity sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==
-  dependencies:
-    psl "^1.1.28"
-    punycode "^2.1.1"
-
-tr46@~0.0.3:
-  version "0.0.3"
-  resolved "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz"
-  integrity sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=
-
-ts-node@^10.9.1:
-  version "10.9.1"
-  resolved "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz"
-  integrity sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==
-  dependencies:
-    "@cspotcode/source-map-support" "^0.8.0"
-    "@tsconfig/node10" "^1.0.7"
-    "@tsconfig/node12" "^1.0.7"
-    "@tsconfig/node14" "^1.0.0"
-    "@tsconfig/node16" "^1.0.2"
-    acorn "^8.4.1"
-    acorn-walk "^8.1.1"
-    arg "^4.1.0"
-    create-require "^1.1.0"
-    diff "^4.0.1"
-    make-error "^1.1.1"
-    v8-compile-cache-lib "^3.0.1"
-    yn "3.1.1"
-
-tslib@^2.0.0, tslib@^2.3.1, tslib@^2.4.0, tslib@^2.5.0:
-  version "2.5.0"
-  resolved "https://registry.npmjs.org/tslib/-/tslib-2.5.0.tgz"
-  integrity sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg==
-
-tunnel-agent@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz"
-  integrity sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==
-  dependencies:
-    safe-buffer "^5.0.1"
-
-tweetnacl@^0.14.3, tweetnacl@~0.14.0:
-  version "0.14.5"
-  resolved "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz"
-  integrity sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==
-
-type-fest@^0.21.3:
-  version "0.21.3"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz"
-  integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==
-
-typedarray@^0.0.6:
-  version "0.0.6"
-  resolved "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz"
-  integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
-
-uint8arrays@^3.0.0:
-  version "3.1.1"
-  resolved "https://registry.npmjs.org/uint8arrays/-/uint8arrays-3.1.1.tgz"
-  integrity sha512-+QJa8QRnbdXVpHYjLoTpJIdCTiw9Ir62nocClWuXIq2JIh4Uta0cQsTSpFL678p2CN8B+XSApwcU+pQEqVpKWg==
-  dependencies:
-    multiformats "^9.4.2"
-
-universalify@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz"
-  integrity sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==
-
-uri-js@^4.2.2:
-  version "4.4.1"
-  resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz"
-  integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
-  dependencies:
-    punycode "^2.1.0"
-
-urlpattern-polyfill@^8.0.0:
-  version "8.0.2"
-  resolved "https://registry.npmjs.org/urlpattern-polyfill/-/urlpattern-polyfill-8.0.2.tgz"
-  integrity sha512-Qp95D4TPJl1kC9SKigDcqgyM2VDVO4RiJc2d4qe5GrYm+zbIQCWWKAFaJNQ4BhdFeDGwBmAxqJBwWSJDb9T3BQ==
-
-utf8@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/utf8/-/utf8-3.0.0.tgz"
-  integrity sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ==
-
-util-deprecate@^1.0.1, util-deprecate@~1.0.1:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz"
-  integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
-
-uuid@^3.3.2:
-  version "3.4.0"
-  resolved "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz"
-  integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==
-
-uuid@^8.3.2:
-  version "8.3.2"
-  resolved "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz"
-  integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==
-
-v8-compile-cache-lib@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz"
-  integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==
-
-varint@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.npmjs.org/varint/-/varint-6.0.0.tgz"
-  integrity sha512-cXEIW6cfr15lFv563k4GuVuW/fiwjknytD37jIOLSdSWuOI6WnO/oKwmP2FQTU2l01LP8/M5TSAJpzUaGe3uWg==
-
-verror@1.10.0:
-  version "1.10.0"
-  resolved "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz"
-  integrity sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==
-  dependencies:
-    assert-plus "^1.0.0"
-    core-util-is "1.0.2"
-    extsprintf "^1.2.0"
-
-wcwidth@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz"
-  integrity sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==
-  dependencies:
-    defaults "^1.0.3"
-
-web-streams-polyfill@^3.2.1:
-  version "3.2.1"
-  resolved "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.2.1.tgz"
-  integrity sha512-e0MO3wdXWKrLbL0DgGnUV7WHVuw9OUvL4hjgnPkIeEvESk74gAITi5G606JtZPp39cd8HA9VQzCIvA49LpPN5Q==
-
-web3-eth-abi@1.7.0:
-  version "1.7.0"
-  resolved "https://registry.npmjs.org/web3-eth-abi/-/web3-eth-abi-1.7.0.tgz"
-  integrity sha512-heqR0bWxgCJwjWIhq2sGyNj9bwun5+Xox/LdZKe+WMyTSy0cXDXEAgv3XKNkXC4JqdDt/ZlbTEx4TWak4TRMSg==
-  dependencies:
-    "@ethersproject/abi" "5.0.7"
-    web3-utils "1.7.0"
-
-web3-utils@1.7.0:
-  version "1.7.0"
-  resolved "https://registry.npmjs.org/web3-utils/-/web3-utils-1.7.0.tgz"
-  integrity sha512-O8Tl4Ky40Sp6pe89Olk2FsaUkgHyb5QAXuaKo38ms3CxZZ4d3rPGfjP9DNKGm5+IUgAZBNpF1VmlSmNCqfDI1w==
-  dependencies:
-    bn.js "^4.11.9"
-    ethereum-bloom-filters "^1.0.6"
-    ethereumjs-util "^7.1.0"
-    ethjs-unit "0.1.6"
-    number-to-bn "1.7.0"
-    randombytes "^2.1.0"
-    utf8 "3.0.0"
-
-webcrypto-core@^1.7.7:
-  version "1.7.7"
-  resolved "https://registry.npmjs.org/webcrypto-core/-/webcrypto-core-1.7.7.tgz"
-  integrity sha512-7FjigXNsBfopEj+5DV2nhNpfic2vumtjjgPmeDKk45z+MJwXKKfhPB7118Pfzrmh4jqOMST6Ch37iPAHoImg5g==
-  dependencies:
-    "@peculiar/asn1-schema" "^2.3.6"
-    "@peculiar/json-schema" "^1.1.12"
-    asn1js "^3.0.1"
-    pvtsutils "^1.3.2"
-    tslib "^2.4.0"
-
-webidl-conversions@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz"
-  integrity sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE=
-
-whatwg-url@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz"
-  integrity sha1-lmRU6HZUYuN2RNNib2dCzotwll0=
-  dependencies:
-    tr46 "~0.0.3"
-    webidl-conversions "^3.0.0"
-
-which@2.0.2, which@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz"
-  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
-  dependencies:
-    isexe "^2.0.0"
-
-which@^1.2.9:
-  version "1.3.1"
-  resolved "https://registry.npmjs.org/which/-/which-1.3.1.tgz"
-  integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
-  dependencies:
-    isexe "^2.0.0"
-
-widest-line@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/widest-line/-/widest-line-3.1.0.tgz"
-  integrity sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==
-  dependencies:
-    string-width "^4.0.0"
-
-wordwrap@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz"
-  integrity sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==
-
-wrap-ansi@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz"
-  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
-  dependencies:
-    ansi-styles "^4.0.0"
-    string-width "^4.1.0"
-    strip-ansi "^6.0.0"
-
-wrappy@1:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
-  integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
-
-ws@^7.4.5:
-  version "7.5.9"
-  resolved "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz"
-  integrity sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==
-
-xtend@^4.0.0:
-  version "4.0.2"
-  resolved "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz"
-  integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==
-
-yallist@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz"
-  integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
-
-yaml@1.10.2, yaml@^1.10.0, yaml@^1.10.2:
-  version "1.10.2"
-  resolved "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz"
-  integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==
-
-yargs-parser@^21.0.0:
-  version "21.1.1"
-  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz"
-  integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==
-
-yn@3.1.1:
-  version "3.1.1"
-  resolved "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz"
-  integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
diff --git a/tests/src/config.rs b/tests/src/config.rs
index 331ecfba485..e35fbb6bf0d 100644
--- a/tests/src/config.rs
+++ b/tests/src/config.rs
@@ -1,3 +1,4 @@
+use std::sync::OnceLock;
 use std::time::{Duration, Instant};
 use std::{fs, path::PathBuf};
 
@@ -13,6 +14,15 @@ use crate::status;
 
 lazy_static! {
     pub static ref CONFIG: Config = Config::default();
+    static ref DEV_MODE: OnceLock<bool> = OnceLock::new();
+}
+
+pub fn set_dev_mode(val: bool) {
+    DEV_MODE.set(val).expect("DEV_MODE already set");
+}
+
+pub fn dev_mode() -> bool {
+    *DEV_MODE.get().unwrap_or(&false)
 }
 
 #[derive(Clone, Debug)]
@@ -61,7 +71,6 @@ impl EthConfig {
 pub struct GraphNodePorts {
     pub http: u16,
     pub index: u16,
-    pub ws: u16,
     pub admin: u16,
     pub metrics: u16,
 }
@@ -70,7 +79,6 @@ impl Default for GraphNodePorts {
     fn default() -> Self {
         Self {
             http: 3030,
-            ws: 3031,
             admin: 3032,
             index: 3033,
             metrics: 3034,
@@ -119,6 +127,33 @@ impl GraphNodeConfig {
             }
         }
     }
+
+    pub fn from_env() -> Self {
+        if dev_mode() {
+            Self::gnd()
+        } else {
+            Self::default()
+        }
+    }
+
+    fn gnd() -> Self {
+        let bin = fs::canonicalize("../target/debug/gnd")
+            .expect("failed to infer `graph-node` program location. (Was it built already?)");
+
+        // Allow overriding IPFS port via environment variable
+        let ipfs_port = std::env::var("IPFS_TEST_PORT")
+            .ok()
+            .and_then(|p| p.parse().ok())
+            .unwrap_or(3001);
+        let ipfs_uri = format!("http://localhost:{}", ipfs_port);
+
+        Self {
+            bin,
+            ports: GraphNodePorts::default(),
+            ipfs_uri,
+            log_file: TestFile::new("integration-tests/graph-node.log"),
+        }
+    }
 }
 
 impl Default for GraphNodeConfig {
@@ -126,10 +161,17 @@ impl Default for GraphNodeConfig {
         let bin = fs::canonicalize("../target/debug/graph-node")
             .expect("failed to infer `graph-node` program location. (Was it built already?)");
 
+        // Allow overriding IPFS port via environment variable
+        let ipfs_port = std::env::var("IPFS_TEST_PORT")
+            .ok()
+            .and_then(|p| p.parse().ok())
+            .unwrap_or(3001);
+        let ipfs_uri = format!("http://localhost:{}", ipfs_port);
+
         Self {
             bin,
             ports: GraphNodePorts::default(),
-            ipfs_uri: "http://localhost:3001".to_string(),
+            ipfs_uri,
             log_file: TestFile::new("integration-tests/graph-node.log"),
         }
     }
@@ -147,26 +189,77 @@ pub struct Config {
 
 impl Config {
     pub async fn spawn_graph_node(&self) -> anyhow::Result<Child> {
+        self.spawn_graph_node_with_args(&[]).await
+    }
+
+    pub async fn spawn_graph_node_with_args(
+        &self,
+        additional_args: &[&str],
+    ) -> anyhow::Result<Child> {
         let ports = &self.graph_node.ports;
 
+        // Generate a TOML config file so we can include [log_store]
+        let log_dir = "/tmp/integration-test-logs";
+        std::fs::create_dir_all(log_dir).ok();
+        let config_content = format!(
+            r#"
+[store]
+[store.primary]
+connection = "{db_url}"
+pool_size = 10
+
+[deployment]
+[[deployment.rule]]
+store = "primary"
+indexers = ["default"]
+
+[chains]
+ingestor = "default"
+
+[chains.test]
+shard = "primary"
+provider = [
+  {{ label = "test", url = "{eth_url}", features = ["archive", "traces"] }}
+]
+
+[log_store]
+backend = "file"
+directory = "{log_dir}"
+retention_hours = 0
+"#,
+            db_url = self.db.url(),
+            eth_url = self.eth.url(),
+            log_dir = log_dir,
+        );
+        let config_path = std::env::temp_dir().join("graph-node-integration-test.toml");
+        std::fs::write(&config_path, &config_content)?;
+
+        let config_path_str = config_path.to_string_lossy().to_string();
+        let http_port = ports.http.to_string();
+        let index_port = ports.index.to_string();
+        let admin_port = ports.admin.to_string();
+        let metrics_port = ports.metrics.to_string();
+
         let args = [
-            "--postgres-url",
-            &self.db.url(),
-            "--ethereum-rpc",
-            &self.eth.network_url(),
+            "--config",
+            &config_path_str,
             "--ipfs",
             &self.graph_node.ipfs_uri,
             "--http-port",
-            &ports.http.to_string(),
+            &http_port,
             "--index-node-port",
-            &ports.index.to_string(),
-            "--ws-port",
-            &ports.ws.to_string(),
+            &index_port,
             "--admin-port",
-            &ports.admin.to_string(),
+            &admin_port,
             "--metrics-port",
-            &ports.metrics.to_string(),
+            &metrics_port,
         ];
+
+        let args = args
+            .iter()
+            .chain(additional_args.iter())
+            .cloned()
+            .collect::<Vec<_>>();
         let stdout = self.graph_node.log_file.create();
         let stderr = stdout.try_clone()?;
         status!(
@@ -178,8 +271,9 @@ impl Config {
         command
             .stdout(stdout)
             .stderr(stderr)
-            .args(args)
-            .env("GRAPH_STORE_WRITE_BATCH_DURATION", "5");
+            .args(args.clone())
+            .env("GRAPH_STORE_WRITE_BATCH_DURATION", "5")
+            .env("ETHEREUM_REORG_THRESHOLD", "0");
 
         status!(
             "graph-node",
@@ -214,7 +308,6 @@ impl Config {
         let setup = format!(
             r#"
         create extension pg_trgm;
-        create extension pg_stat_statements;
         create extension btree_gist;
         create extension postgres_fdw;
         grant usage on foreign data wrapper postgres_fdw to "{}";
@@ -224,14 +317,14 @@ impl Config {
 
         let template_uri = self.db.template_url();
 
-        let conn = PgConnection::establish(&template_uri)
+        let mut conn = PgConnection::establish(&template_uri)
             .expect("Failed to connect to template1 to reset database");
         conn.batch_execute(&drop_db)
             .expect("Failed to drop old database");
         conn.batch_execute(&create_db)
             .expect("Failed to create new database");
 
-        let conn = PgConnection::establish(&self.db.url())
+        let mut conn = PgConnection::establish(&self.db.url())
             .expect("Failed to connect to graph-node database");
         conn.batch_execute(&setup)
             .expect("Failed to reset Postgres database");
@@ -240,28 +333,43 @@ impl Config {
 
 impl Default for Config {
     fn default() -> Self {
-        let graph_cli =
-            std::env::var("GRAPH_CLI").unwrap_or_else(|_| "node_modules/.bin/graph".to_string());
+        let graph_cli = std::env::var("GRAPH_CLI").unwrap_or_else(|_| {
+            fs::canonicalize("../target/debug/gnd")
+                .expect("failed to infer gnd location. (Was it built already?)")
+                .to_string_lossy()
+                .into_owned()
+        });
         let num_parallel_tests = std::env::var("N_CONCURRENT_TESTS")
             .map(|x| x.parse().expect("N_CONCURRENT_TESTS must be a number"))
             .unwrap_or(1000);
+
+        // Allow overriding ports via environment variables
+        let postgres_port = std::env::var("POSTGRES_TEST_PORT")
+            .ok()
+            .and_then(|p| p.parse().ok())
+            .unwrap_or(3011);
+        let eth_port = std::env::var("ETHEREUM_TEST_PORT")
+            .ok()
+            .and_then(|p| p.parse().ok())
+            .unwrap_or(3021);
+
         Config {
             db: DbConfig {
                 host: "localhost".to_string(),
-                port: 3011,
+                port: postgres_port,
                 user: "graph-node".to_string(),
                 password: "let-me-in".to_string(),
                 name: "graph-node".to_string(),
             },
             eth: EthConfig {
                 network: "test".to_string(),
-                port: 3021,
+                port: eth_port,
                 host: "localhost".to_string(),
             },
-            graph_node: GraphNodeConfig::default(),
+            graph_node: GraphNodeConfig::from_env(),
             graph_cli,
             num_parallel_tests,
-            timeout: Duration::from_secs(120),
+            timeout: Duration::from_secs(600),
         }
     }
 }
diff --git a/tests/src/contract.rs b/tests/src/contract.rs
index 5b57bf9dcb0..82fc89fec87 100644
--- a/tests/src/contract.rs
+++ b/tests/src/contract.rs
@@ -1,52 +1,81 @@
-use std::str::FromStr;
-
 use graph::prelude::{
-    lazy_static,
-    serde_json::{self, Value},
-    web3::{
-        api::{Eth, Namespace},
-        contract::{tokens::Tokenize, Contract as Web3Contract, Options},
-        transports::Http,
-        types::{Address, TransactionReceipt},
+    alloy::{
+        contract::{ContractInstance, Interface},
+        dyn_abi::DynSolValue,
+        json_abi::JsonAbi,
+        network::{Ethereum, TransactionBuilder},
+        primitives::{Address, Bytes, U256},
+        providers::{Provider, ProviderBuilder, WalletProvider, ext::AnvilApi},
+        rpc::types::{Block, TransactionReceipt, TransactionRequest},
+        signers::local::PrivateKeySigner,
     },
+    hex, lazy_static,
+    serde_json::{self, Value},
 };
-// web3 version 0.18 does not expose this; once the graph crate updates to
-// version 0.19, we can use web3::signing::SecretKey from the graph crate
-use secp256k1::SecretKey;
 
-use crate::{error, helpers::TestFile, status, CONFIG};
+use crate::{CONFIG, error, helpers::TestFile, status};
 
 // `FROM` and `FROM_KEY` are the address and private key of the first
 // account that anvil prints on startup
 lazy_static! {
-    static ref FROM: Address =
-        Address::from_str("0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266").unwrap();
-    static ref FROM_KEY: SecretKey = {
-        SecretKey::from_str("ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80")
-            .unwrap()
-    };
+    static ref FROM: Address = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+        .parse()
+        .unwrap();
+    static ref FROM_KEY: PrivateKeySigner =
+        "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+            .parse()
+            .unwrap();
     static ref CONTRACTS: Vec<Contract> = {
         vec![
             Contract {
                 name: "SimpleContract".to_string(),
-                address: Address::from_str("0x5fbdb2315678afecb367f032d93f642f64180aa3").unwrap(),
+                address: "0x5fbdb2315678afecb367f032d93f642f64180aa3"
+                    .parse()
+                    .unwrap(),
             },
             Contract {
                 name: "LimitedContract".to_string(),
-                address: Address::from_str("0xb7f8bc63bbcad18155201308c8f3540b07f84f5e").unwrap(),
+                address: "0x0b306bf915c4d645ff596e518faf3f9669b97016"
+                    .parse()
+                    .unwrap(),
             },
             Contract {
                 name: "RevertingContract".to_string(),
-                address: Address::from_str("0xa51c1fc2f0d1a1b8494ed1fe312d7c3a78ed91c0").unwrap(),
+                address: "0x959922be3caee4b8cd9a407cc3ac1c251c2007b1"
+                    .parse()
+                    .unwrap(),
             },
             Contract {
                 name: "OverloadedContract".to_string(),
-                address: Address::from_str("0x0dcd1bf9a1b36ce34237eeafef220932846bcd82").unwrap(),
+                address: "0x9a9f2ccfde556a7e9ff0848998aa4a0cfd8863ae"
+                    .parse()
+                    .unwrap(),
+            },
+            Contract {
+                name: "DeclaredCallsContract".to_string(),
+                address: "0x68b1d87f95878fe05b998f19b66f4baba5de1aed"
+                    .parse()
+                    .unwrap(),
             },
         ]
     };
 }
 
+/// Helper function to create a DynSolValue::Uint from a u64 value
+pub fn uint(val: u64, bits: usize) -> DynSolValue {
+    DynSolValue::Uint(U256::from(val), bits)
+}
+
+/// Helper function to create a DynSolValue::Address
+pub fn addr(a: Address) -> DynSolValue {
+    DynSolValue::Address(a)
+}
+
+/// Helper function to create a DynSolValue::String
+pub fn string(s: &str) -> DynSolValue {
+    DynSolValue::String(s.to_string())
+}
+
 #[derive(Debug, Clone)]
 pub struct Contract {
     pub name: String,
@@ -54,58 +83,74 @@ pub struct Contract {
 }
 
 impl Contract {
-    fn eth() -> Eth<Http> {
-        let web3 = Http::new(&CONFIG.eth.url()).unwrap();
-        Eth::new(web3)
+    fn provider() -> impl Provider<Ethereum> + WalletProvider + Clone {
+        ProviderBuilder::new()
+            .wallet(FROM_KEY.clone())
+            .connect_http(CONFIG.eth.url().parse().unwrap())
     }
 
     async fn exists(&self) -> bool {
-        let eth = Self::eth();
-        let bytes = eth.code(self.address, None).await.unwrap();
-        !bytes.0.is_empty()
+        let bytes = self.code().await;
+        !bytes.is_empty()
     }
 
-    fn code_and_abi(name: &str) -> anyhow::Result<(String, Vec<u8>)> {
-        let src = TestFile::new(&format!("contracts/src/{}.sol", name));
+    pub async fn code(&self) -> Bytes {
+        let provider = Self::provider();
+        provider.get_code_at(self.address).await.unwrap()
+    }
+
+    fn code_and_abi(name: &str) -> anyhow::Result<(Bytes, JsonAbi)> {
         let bin = TestFile::new(&format!("contracts/out/{}.sol/{}.json", name, name));
-        if src.newer(&bin) {
-            println!(
-                "The source {} is newer than the compiled contract {}. Please recompile.",
-                src, bin
-            );
-        }
 
         let json: Value = serde_json::from_reader(bin.reader()?).unwrap();
-        let abi = serde_json::to_string(&json["abi"]).unwrap();
-        let code = json["bytecode"]["object"].as_str().unwrap();
-        Ok((code.to_string(), abi.as_bytes().to_vec()))
+        let abi: JsonAbi = serde_json::from_value(json["abi"].clone())?;
+        let code_hex = json["bytecode"]["object"].as_str().unwrap();
+        let code = Bytes::from(hex::decode(code_hex.trim_start_matches("0x"))?);
+        Ok((code, abi))
     }
 
     pub async fn deploy(name: &str) -> anyhow::Result<Self> {
-        let eth = Self::eth();
-        let (code, abi) = Self::code_and_abi(name)?;
-        let contract = Web3Contract::deploy(eth, &abi)
-            .unwrap()
-            .confirmations(1)
-            .execute(code, (), FROM.to_owned())
-            .await
-            .unwrap();
+        let provider = Self::provider();
+        let (code, _abi) = Self::code_and_abi(name)?;
+
+        let deploy_tx = TransactionRequest::default().with_deploy_code(code);
+
+        let receipt = provider
+            .send_transaction(deploy_tx)
+            .await?
+            .with_required_confirmations(1)
+            .get_receipt()
+            .await?;
+
+        let address = receipt
+            .contract_address
+            .ok_or_else(|| anyhow::anyhow!("No contract address in receipt"))?;
 
         Ok(Self {
             name: name.to_string(),
-            address: contract.address(),
+            address,
         })
     }
 
-    async fn call(&self, func: &str, params: impl Tokenize) -> anyhow::Result<TransactionReceipt> {
-        let eth = Self::eth();
+    pub async fn call(
+        &self,
+        func: &str,
+        params: &[DynSolValue],
+    ) -> anyhow::Result<TransactionReceipt> {
+        let provider = Self::provider();
         let (_, abi) = Self::code_and_abi(&self.name)?;
-        let contract = Web3Contract::from_json(eth, self.address, &abi)?;
-        let options = Options::default();
+
+        let interface = Interface::new(abi);
+        let contract = ContractInstance::new(self.address, provider, interface);
+
         let receipt = contract
-            .signed_call_with_confirmations(func, params, options, 1, &*FROM_KEY)
-            .await
-            .unwrap();
+            .function(func, params)?
+            .send()
+            .await?
+            .with_required_confirmations(1)
+            .get_receipt()
+            .await?;
+
         Ok(receipt)
     }
 
@@ -141,8 +186,77 @@ impl Contract {
                 // Some tests want 10 calls to `emitTrigger` in place
                 if contract.name == "SimpleContract" {
                     status!("contracts", "Calling SimpleContract.emitTrigger 10 times");
-                    for i in 1..=10 {
-                        contract.call("emitTrigger", (i as u16,)).await.unwrap();
+                    for i in 1u64..=10 {
+                        contract.call("emitTrigger", &[uint(i, 16)]).await.unwrap();
+                    }
+                }
+                // Declared calls tests need a Transfer
+                if contract.name == "DeclaredCallsContract" {
+                    status!("contracts", "Emitting transfers from DeclaredCallsContract");
+                    let addr1: Address = "0x1111111111111111111111111111111111111111"
+                        .parse()
+                        .unwrap();
+                    let addr2: Address = "0x2222222222222222222222222222222222222222"
+                        .parse()
+                        .unwrap();
+                    let addr3: Address = "0x3333333333333333333333333333333333333333"
+                        .parse()
+                        .unwrap();
+                    let addr4: Address = "0x4444444444444444444444444444444444444444"
+                        .parse()
+                        .unwrap();
+
+                    contract
+                        .call(
+                            "emitTransfer",
+                            &[addr(addr1), addr(addr2), uint(100u64, 256)],
+                        )
+                        .await
+                        .unwrap();
+
+                    // Emit an asset transfer event to trigger struct field declared calls
+                    contract
+                        .call(
+                            "emitAssetTransfer",
+                            &[
+                                addr(addr1),
+                                uint(150u64, 256),
+                                DynSolValue::Bool(true),
+                                addr(addr3),
+                            ],
+                        )
+                        .await
+                        .unwrap();
+
+                    // Also emit a complex asset event for nested struct testing
+                    let values =
+                        DynSolValue::Array(vec![uint(1u64, 256), uint(2u64, 256), uint(3u64, 256)]);
+                    contract
+                        .call(
+                            "emitComplexAssetCreated",
+                            &[
+                                addr(addr4),
+                                uint(250u64, 256),
+                                DynSolValue::Bool(true),
+                                string("Complex Asset Metadata"),
+                                values,
+                                uint(99u64, 256),
+                            ],
+                        )
+                        .await
+                        .unwrap();
+                }
+                // The topic-filter test needs some events emitted
+                if contract.name == "SimpleContract" {
+                    status!("contracts", "Emitting anotherTrigger from SimpleContract");
+                    let args = &[
+                        [uint(1, 256), uint(2, 256), uint(3, 256), string("abc")],
+                        [uint(1, 256), uint(1, 256), uint(1, 256), string("abc")],
+                        [uint(4, 256), uint(2, 256), uint(3, 256), string("abc")],
+                        [uint(4, 256), uint(4, 256), uint(3, 256), string("abc")],
+                    ];
+                    for arg in args {
+                        contract.call("emitAnotherTrigger", arg).await.unwrap();
                     }
                 }
             } else {
@@ -157,4 +271,49 @@ impl Contract {
         }
         Ok(contracts)
     }
+
+    pub async fn latest_block() -> Option<Block> {
+        let provider = Self::provider();
+        provider
+            .get_block_by_number(Default::default())
+            .await
+            .ok()
+            .flatten()
+    }
+
+    /// Mine the specified number of empty blocks using Anvil's evm_mine RPC.
+    pub async fn mine_blocks(count: u64) -> anyhow::Result<u64> {
+        let provider = Self::provider();
+
+        for _ in 0..count {
+            provider
+                .evm_mine(None)
+                .await
+                .map_err(|e| anyhow::anyhow!("Failed to mine block: {}", e))?;
+        }
+
+        let block = provider
+            .get_block_number()
+            .await
+            .map_err(|e| anyhow::anyhow!("Failed to get block number: {}", e))?;
+
+        Ok(block)
+    }
+
+    /// Ensure the blockchain has reached at least the specified block number.
+    /// Mines empty blocks if needed.
+    pub async fn ensure_block(target_block: u64) -> anyhow::Result<()> {
+        let provider = Self::provider();
+        let current = provider
+            .get_block_number()
+            .await
+            .map_err(|e| anyhow::anyhow!("Failed to get block number: {}", e))?;
+
+        if current < target_block {
+            let blocks_needed = target_block - current;
+            Self::mine_blocks(blocks_needed).await?;
+        }
+
+        Ok(())
+    }
 }
diff --git a/tests/src/fixture/ethereum.rs b/tests/src/fixture/ethereum.rs
index b59d10c9e31..bba946a9ae9 100644
--- a/tests/src/fixture/ethereum.rs
+++ b/tests/src/fixture/ethereum.rs
@@ -3,18 +3,26 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 use super::{
-    test_ptr, CommonChainConfig, MutexBlockStreamBuilder, NoopAdapterSelector, NoopRuntimeAdapter,
-    StaticBlockRefetcher, StaticStreamBuilder, Stores, TestChain,
+    CommonChainConfig, MutexBlockStreamBuilder, NoopAdapterSelector, NoopRuntimeAdapterBuilder,
+    StaticBlockRefetcher, StaticStreamBuilder, Stores, TestChain, test_ptr,
 };
+use graph::abi;
+use graph::blockchain::block_stream::BlockWithTriggers;
+use graph::blockchain::block_stream::{EntityOperationKind, EntitySourceOperation};
 use graph::blockchain::client::ChainClient;
-use graph::blockchain::{BlockPtr, TriggersAdapterSelector};
+use graph::blockchain::{BlockPtr, Trigger, TriggersAdapterSelector};
 use graph::cheap_clone::CheapClone;
-use graph::prelude::ethabi::ethereum_types::H256;
-use graph::prelude::web3::types::{Address, Log, Transaction, H160};
-use graph::prelude::{ethabi, tiny_keccak, LightEthereumBlock, ENV_VARS};
-use graph::{blockchain::block_stream::BlockWithTriggers, prelude::ethabi::ethereum_types::U64};
+use graph::data_source::subgraph;
+use graph::prelude::alloy::primitives::{Address, B256, U256, keccak256};
+use graph::prelude::alloy::rpc::types::BlockTransactions;
+use graph::prelude::{
+    DeploymentHash, ENV_VARS, Entity, LightEthereumBlock, create_dummy_transaction,
+    create_minimal_block_for_test,
+};
+use graph::schema::EntityType;
+use graph_chain_ethereum::network::EthereumNetworkAdapters;
 use graph_chain_ethereum::trigger::LogRef;
-use graph_chain_ethereum::Chain;
+use graph_chain_ethereum::{Chain, chain::ChainSettings};
 use graph_chain_ethereum::{
     chain::BlockFinality,
     trigger::{EthereumBlockTriggerType, EthereumTrigger},
@@ -36,7 +44,6 @@ pub async fn chain(
         mock_registry,
         chain_store,
         firehose_endpoints,
-        node_id,
     } = CommonChainConfig::new(test_name, stores).await;
 
     let client = Arc::new(ChainClient::<Chain>::new_firehose(firehose_endpoints));
@@ -44,10 +51,11 @@ pub async fn chain(
     let static_block_stream = Arc::new(StaticStreamBuilder { chain: blocks });
     let block_stream_builder = Arc::new(MutexBlockStreamBuilder(Mutex::new(static_block_stream)));
 
+    let eth_adapters = Arc::new(EthereumNetworkAdapters::empty_for_testing());
+
     let chain = Chain::new(
         logger_factory,
         stores.network_name.clone(),
-        node_id,
         mock_registry,
         chain_store.cheap_clone(),
         chain_store,
@@ -56,11 +64,12 @@ pub async fn chain(
         block_stream_builder.clone(),
         Arc::new(StaticBlockRefetcher { x: PhantomData }),
         triggers_adapter,
-        Arc::new(NoopRuntimeAdapter { x: PhantomData }),
-        ENV_VARS.reorg_threshold,
-        ENV_VARS.ingestor_polling_interval,
+        Arc::new(NoopRuntimeAdapterBuilder {}),
+        eth_adapters,
+        ENV_VARS.reorg_threshold(),
         // We assume the tested chain is always ingestible for now
         true,
+        Arc::new(ChainSettings::from_env_defaults()),
     );
 
     TestChain {
@@ -71,13 +80,15 @@ pub async fn chain(
 
 pub fn genesis() -> BlockWithTriggers<graph_chain_ethereum::Chain> {
     let ptr = test_ptr(0);
+
+    let block = create_minimal_block_for_test(ptr.number as u64, ptr.hash.as_b256());
+
     BlockWithTriggers::<graph_chain_ethereum::Chain> {
-        block: BlockFinality::Final(Arc::new(LightEthereumBlock {
-            hash: Some(H256::from_slice(ptr.hash.as_slice())),
-            number: Some(U64::from(ptr.number)),
-            ..Default::default()
-        })),
-        trigger_data: vec![EthereumTrigger::Block(ptr, EthereumBlockTriggerType::End)],
+        block: BlockFinality::Final(Arc::new(LightEthereumBlock::new(block))),
+        trigger_data: vec![Trigger::Chain(EthereumTrigger::Block(
+            ptr,
+            EthereumBlockTriggerType::End,
+        ))],
     }
 }
 
@@ -93,7 +104,7 @@ pub fn generate_empty_blocks_for_range(
         let parent_ptr = blocks.last().map(|b| b.ptr()).unwrap_or(parent_ptr.clone());
         let ptr = BlockPtr {
             number: i,
-            hash: H256::from_low_u64_be(i as u64 + add_to_hash).into(),
+            hash: B256::from(U256::from(i as u64 + add_to_hash)).into(),
         };
         blocks.push(empty_block(parent_ptr, ptr));
     }
@@ -105,51 +116,119 @@ pub fn empty_block(parent_ptr: BlockPtr, ptr: BlockPtr) -> BlockWithTriggers<Cha
     assert!(ptr != parent_ptr);
     assert!(ptr.number > parent_ptr.number);
 
-    // A 0x000.. transaction is used so `push_test_log` can use it
-    let transactions = vec![Transaction {
-        hash: H256::zero(),
-        block_hash: Some(H256::from_slice(ptr.hash.as_slice())),
-        block_number: Some(ptr.number.into()),
-        transaction_index: Some(0.into()),
-        from: Some(H160::zero()),
-        to: Some(H160::zero()),
-        ..Default::default()
-    }];
+    let dummy_txn =
+        create_dummy_transaction(ptr.number as u64, ptr.hash.as_b256(), Some(0), B256::ZERO);
+    let transactions = BlockTransactions::Full(vec![dummy_txn]);
+    let alloy_block = create_minimal_block_for_test(ptr.number as u64, ptr.hash.as_b256())
+        .map_header(|mut header| {
+            // Ensure the parent hash matches the given parent_ptr so that parent_ptr() lookups succeed
+            header.inner.parent_hash = parent_ptr.hash.as_b256();
+            header
+        })
+        .with_transactions(transactions);
 
     BlockWithTriggers::<graph_chain_ethereum::Chain> {
-        block: BlockFinality::Final(Arc::new(LightEthereumBlock {
-            hash: Some(H256::from_slice(ptr.hash.as_slice())),
-            number: Some(U64::from(ptr.number)),
-            parent_hash: H256::from_slice(parent_ptr.hash.as_slice()),
-            transactions,
-            ..Default::default()
-        })),
-        trigger_data: vec![EthereumTrigger::Block(ptr, EthereumBlockTriggerType::End)],
+        block: BlockFinality::Final(Arc::new(LightEthereumBlock::new(alloy_block))),
+        trigger_data: vec![Trigger::Chain(EthereumTrigger::Block(
+            ptr,
+            EthereumBlockTriggerType::End,
+        ))],
     }
 }
 
 pub fn push_test_log(block: &mut BlockWithTriggers<Chain>, payload: impl Into<String>) {
+    use graph::prelude::alloy::{self, primitives::LogData, rpc::types::Log};
+
     let log = Arc::new(Log {
-        address: Address::zero(),
-        topics: vec![tiny_keccak::keccak256(b"TestEvent(string)").into()],
-        data: ethabi::encode(&[ethabi::Token::String(payload.into())]).into(),
-        block_hash: Some(H256::from_slice(block.ptr().hash.as_slice())),
-        block_number: Some(block.ptr().number.into()),
-        transaction_hash: Some(H256::from_low_u64_be(0)),
-        transaction_index: Some(0.into()),
-        log_index: Some(0.into()),
-        transaction_log_index: Some(0.into()),
-        log_type: None,
-        removed: None,
+        inner: alloy::primitives::Log {
+            address: Address::ZERO,
+            data: LogData::new_unchecked(
+                vec![keccak256(b"TestEvent(string)")],
+                abi::DynSolValue::String(payload.into()).abi_encode().into(),
+            ),
+        },
+        block_hash: Some(B256::from_slice(block.ptr().hash.as_slice())),
+        block_number: Some(block.ptr().number as u64),
+        transaction_hash: Some(B256::from(U256::from(0))),
+        transaction_index: Some(0),
+        log_index: Some(0),
+        block_timestamp: None,
+        removed: false,
     });
+
+    block
+        .trigger_data
+        .push(Trigger::Chain(EthereumTrigger::Log(LogRef::FullLog(
+            log, None,
+        ))))
+}
+
+pub fn push_test_subgraph_trigger(
+    block: &mut BlockWithTriggers<Chain>,
+    source: DeploymentHash,
+    entity: Entity,
+    entity_type: EntityType,
+    entity_op: EntityOperationKind,
+    vid: i64,
+    source_idx: u32,
+) {
+    let entity = EntitySourceOperation {
+        entity,
+        entity_type,
+        entity_op,
+        vid,
+    };
+
     block
         .trigger_data
-        .push(EthereumTrigger::Log(LogRef::FullLog(log, None)))
+        .push(Trigger::Subgraph(subgraph::TriggerData {
+            source,
+            entity,
+            source_idx,
+        }));
+}
+
+pub fn push_test_command(
+    block: &mut BlockWithTriggers<Chain>,
+    test_command: impl Into<String>,
+    data: impl Into<String>,
+) {
+    use graph::prelude::alloy::{self, primitives::LogData, rpc::types::Log};
+
+    let log = Arc::new(Log {
+        inner: alloy::primitives::Log {
+            address: Address::ZERO,
+            data: LogData::new_unchecked(
+                vec![keccak256(b"TestEvent(string,string)")],
+                abi::DynSolValue::Tuple(vec![
+                    abi::DynSolValue::String(test_command.into()),
+                    abi::DynSolValue::String(data.into()),
+                ])
+                .abi_encode_params()
+                .into(),
+            ),
+        },
+        block_hash: Some(block.ptr().hash.as_b256()),
+        block_number: Some(block.ptr().number as u64),
+        transaction_hash: Some(B256::from(U256::from(0))),
+        transaction_index: Some(0),
+        log_index: Some(0),
+        block_timestamp: None,
+        removed: false,
+    });
+
+    block
+        .trigger_data
+        .push(Trigger::Chain(EthereumTrigger::Log(LogRef::FullLog(
+            log, None,
+        ))))
 }
 
 pub fn push_test_polling_trigger(block: &mut BlockWithTriggers<Chain>) {
-    block.trigger_data.push(EthereumTrigger::Block(
-        block.ptr(),
-        EthereumBlockTriggerType::End,
-    ))
+    block
+        .trigger_data
+        .push(Trigger::Chain(EthereumTrigger::Block(
+            block.ptr(),
+            EthereumBlockTriggerType::End,
+        )))
 }
diff --git a/tests/src/fixture/mod.rs b/tests/src/fixture/mod.rs
index 1aaecee7605..90949c81be2 100644
--- a/tests/src/fixture/mod.rs
+++ b/tests/src/fixture/mod.rs
@@ -1,56 +1,65 @@
 pub mod ethereum;
-pub mod substreams;
 
-use std::collections::HashMap;
+use std::collections::{BTreeSet, HashMap};
 use std::marker::PhantomData;
+use std::path::PathBuf;
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
 
 use anyhow::Error;
 use async_stream::stream;
-use futures::{Stream, StreamExt};
+use async_trait::async_trait;
+use graph::amp;
 use graph::blockchain::block_stream::{
-    BlockRefetcher, BlockStream, BlockStreamBuilder, BlockStreamEvent, BlockWithTriggers,
-    FirehoseCursor,
+    BlockRefetcher, BlockStream, BlockStreamBuilder, BlockStreamError, BlockStreamEvent,
+    BlockWithTriggers, FirehoseCursor,
 };
 use graph::blockchain::{
     Block, BlockHash, BlockPtr, Blockchain, BlockchainMap, ChainIdentifier, RuntimeAdapter,
-    TriggersAdapter, TriggersAdapterSelector,
+    TriggerFilterWrapper, TriggersAdapter, TriggersAdapterSelector,
 };
 use graph::cheap_clone::CheapClone;
-use graph::components::link_resolver::{ArweaveClient, ArweaveResolver, FileSizeLimit};
+use graph::components::link_resolver::{
+    ArweaveClient, ArweaveClientError, ArweaveResolver, FileLinkResolver, FileSizeLimit,
+    LinkResolverContext,
+};
 use graph::components::metrics::MetricsRegistry;
-use graph::components::store::{BlockStore, DeploymentLocator};
-use graph::components::subgraph::Settings;
+use graph::components::network_provider::ChainName;
+use graph::components::store::{DeploymentLocator, EthereumCallCache, SourceableStore};
+use graph::components::subgraph::{Settings, SubgraphInstanceManager as _};
 use graph::data::graphql::load_manager::LoadManager;
 use graph::data::query::{Query, QueryTarget};
 use graph::data::subgraph::schema::{SubgraphError, SubgraphHealth};
+use graph::data_source::DataSource;
 use graph::endpoint::EndpointMetrics;
 use graph::env::EnvVars;
 use graph::firehose::{FirehoseEndpoint, FirehoseEndpoints, SubgraphLimit};
-use graph::ipfs_client::IpfsClient;
-use graph::prelude::ethabi::ethereum_types::H256;
+use graph::futures03::{Stream, StreamExt};
+use graph::http_body_util::Full;
+use graph::hyper::Request;
+use graph::hyper::body::Bytes;
+use graph::ipfs::{IpfsClient, IpfsMetrics};
+use graph::prelude::alloy::primitives::B256;
+use graph::prelude::alloy::primitives::U256;
 use graph::prelude::serde_json::{self, json};
 use graph::prelude::{
-    async_trait, lazy_static, r, ApiVersion, BigInt, BlockNumber, DeploymentHash,
-    GraphQlRunner as _, LoggerFactory, NodeId, QueryError, SubgraphAssignmentProvider,
-    SubgraphCountMetric, SubgraphName, SubgraphRegistrar, SubgraphStore as _,
-    SubgraphVersionSwitchingMode, TriggerProcessor,
+    ApiVersion, BigInt, BlockNumber, DeploymentHash, GraphQlRunner as _, IpfsResolver,
+    LinkResolver, LoggerFactory, NodeId, QueryError, SubgraphCountMetric, SubgraphName,
+    SubgraphRegistrar, SubgraphStore as _, SubgraphVersionSwitchingMode, TriggerProcessor,
+    lazy_static, q, r,
 };
-use graph::schema::InputSchema;
 use graph_chain_ethereum::Chain;
+use graph_chain_ethereum::chain::RuntimeAdapterBuilder;
+use graph_chain_ethereum::network::EthereumNetworkAdapters;
 use graph_core::polling_monitor::{arweave_service, ipfs_service};
-use graph_core::{
-    LinkResolver, SubgraphAssignmentProvider as IpfsSubgraphAssignmentProvider,
-    SubgraphInstanceManager, SubgraphRegistrar as IpfsSubgraphRegistrar, SubgraphTriggerProcessor,
-};
+use graph_node::config::Opt;
 use graph_node::manager::PanicSubscriptionManager;
 use graph_node::{config::Config, store_builder::StoreBuilder};
 use graph_runtime_wasm::RuntimeHostBuilder;
 use graph_server_index_node::IndexNodeService;
 use graph_store_postgres::{ChainHeadUpdateListener, ChainStore, Store, SubgraphStore};
 use serde::Deserialize;
-use slog::{crit, debug, info, o, Discard, Logger};
+use slog::{Discard, Logger, crit, debug, info, o};
 use std::env::VarError;
 use std::pin::Pin;
 use std::sync::Arc;
@@ -65,7 +74,7 @@ pub fn test_ptr(n: BlockNumber) -> BlockPtr {
 
 // Set n as the low bits and `reorg_n` as the high bits of the hash.
 pub fn test_ptr_reorged(n: BlockNumber, reorg_n: u32) -> BlockPtr {
-    let mut hash = H256::from_low_u64_be(n as u64);
+    let mut hash = B256::from(U256::from(n as u64));
     hash[0..4].copy_from_slice(&reorg_n.to_be_bytes());
     BlockPtr {
         hash: hash.into(),
@@ -73,14 +82,13 @@ pub fn test_ptr_reorged(n: BlockNumber, reorg_n: u32) -> BlockPtr {
     }
 }
 
-type GraphQlRunner = graph_graphql::prelude::GraphQlRunner<Store, PanicSubscriptionManager>;
+type GraphQlRunner = graph_graphql::prelude::GraphQlRunner<Store>;
 
 struct CommonChainConfig {
     logger_factory: LoggerFactory,
     mock_registry: Arc<MetricsRegistry>,
     chain_store: Arc<ChainStore>,
     firehose_endpoints: FirehoseEndpoints,
-    node_id: NodeId,
 }
 
 impl CommonChainConfig {
@@ -89,25 +97,24 @@ impl CommonChainConfig {
         let mock_registry = Arc::new(MetricsRegistry::mock());
         let logger_factory = LoggerFactory::new(logger.cheap_clone(), None, mock_registry.clone());
         let chain_store = stores.chain_store.cheap_clone();
-        let node_id = NodeId::new(NODE_ID).unwrap();
-
-        let firehose_endpoints: FirehoseEndpoints = vec![Arc::new(FirehoseEndpoint::new(
-            "",
-            "https://example.com",
-            None,
-            true,
-            false,
-            SubgraphLimit::Unlimited,
-            Arc::new(EndpointMetrics::mock()),
-        ))]
-        .into();
+
+        let firehose_endpoints =
+            FirehoseEndpoints::for_testing(vec![Arc::new(FirehoseEndpoint::new(
+                "",
+                "https://example.com",
+                None,
+                None,
+                true,
+                false,
+                SubgraphLimit::Unlimited,
+                Arc::new(EndpointMetrics::mock()),
+            ))]);
 
         Self {
             logger_factory,
             mock_registry,
             chain_store,
             firehose_endpoints,
-            node_id,
         }
     }
 }
@@ -128,19 +135,6 @@ impl TestChainTrait<Chain> for TestChain<Chain> {
     }
 }
 
-pub struct TestChainSubstreams {
-    pub chain: Arc<graph_chain_substreams::Chain>,
-    pub block_stream_builder: Arc<graph_chain_substreams::BlockStreamBuilder>,
-}
-
-impl TestChainTrait<graph_chain_substreams::Chain> for TestChainSubstreams {
-    fn set_block_stream(&self, _blocks: Vec<BlockWithTriggers<graph_chain_substreams::Chain>>) {}
-
-    fn chain(&self) -> Arc<graph_chain_substreams::Chain> {
-        self.chain.clone()
-    }
-}
-
 pub trait TestChainTrait<C: Blockchain> {
     fn set_block_stream(&self, blocks: Vec<BlockWithTriggers<C>>);
 
@@ -149,21 +143,22 @@ pub trait TestChainTrait<C: Blockchain> {
 
 pub struct TestContext {
     pub logger: Logger,
-    pub provider: Arc<
-        IpfsSubgraphAssignmentProvider<
-            SubgraphInstanceManager<graph_store_postgres::SubgraphStore>,
-        >,
-    >,
+    pub provider: Arc<graph_core::subgraph_provider::SubgraphProvider>,
     pub store: Arc<SubgraphStore>,
     pub deployment: DeploymentLocator,
     pub subgraph_name: SubgraphName,
-    pub instance_manager: SubgraphInstanceManager<graph_store_postgres::SubgraphStore>,
+    pub instance_manager: Arc<
+        graph_core::subgraph::SubgraphInstanceManager<
+            graph_store_postgres::SubgraphStore,
+            amp::FlightClient,
+        >,
+    >,
     pub link_resolver: Arc<dyn graph::components::link_resolver::LinkResolver>,
     pub arweave_resolver: Arc<dyn ArweaveResolver>,
     pub env_vars: Arc<EnvVars>,
-    pub ipfs: IpfsClient,
+    pub ipfs: Arc<dyn IpfsClient>,
     graphql_runner: Arc<GraphQlRunner>,
-    indexing_status_service: Arc<IndexNodeService<GraphQlRunner, graph_store_postgres::Store>>,
+    indexing_status_service: Arc<IndexNodeService<graph_store_postgres::Store, amp::FlightClient>>,
 }
 
 #[derive(Deserialize)]
@@ -195,44 +190,28 @@ impl TestContext {
     pub async fn runner(
         &self,
         stop_block: BlockPtr,
-    ) -> graph_core::SubgraphRunner<
+    ) -> graph_core::subgraph::SubgraphRunner<
         graph_chain_ethereum::Chain,
         RuntimeHostBuilder<graph_chain_ethereum::Chain>,
     > {
         let (logger, deployment, raw) = self.get_runner_context().await;
-        let tp: Box<dyn TriggerProcessor<_, _>> = Box::new(SubgraphTriggerProcessor {});
+        let tp: Box<dyn TriggerProcessor<_, _>> =
+            Box::new(graph_core::subgraph::SubgraphTriggerProcessor {});
 
-        self.instance_manager
-            .build_subgraph_runner(
-                logger,
-                self.env_vars.cheap_clone(),
-                deployment,
-                raw,
-                Some(stop_block.block_number()),
-                tp,
-            )
-            .await
-            .unwrap()
-    }
-
-    pub async fn runner_substreams(
-        &self,
-        stop_block: BlockPtr,
-    ) -> graph_core::SubgraphRunner<
-        graph_chain_substreams::Chain,
-        RuntimeHostBuilder<graph_chain_substreams::Chain>,
-    > {
-        let (logger, deployment, raw) = self.get_runner_context().await;
-        let tp: Box<dyn TriggerProcessor<_, _>> = Box::new(SubgraphTriggerProcessor {});
+        let deployment_status_metric = self
+            .instance_manager
+            .new_deployment_status_metric(&deployment);
 
         self.instance_manager
-            .build_subgraph_runner(
+            .build_subgraph_runner_inner(
                 logger,
                 self.env_vars.cheap_clone(),
                 deployment,
                 raw,
                 Some(stop_block.block_number()),
                 tp,
+                deployment_status_metric,
+                true,
             )
             .await
             .unwrap()
@@ -245,7 +224,10 @@ impl TestContext {
         // Stolen from the IPFS provider, there's prolly a nicer way to re-use it
         let file_bytes = self
             .link_resolver
-            .cat(&logger, &deployment.hash.to_ipfs_link())
+            .cat(
+                &LinkResolverContext::new(&deployment.hash, &logger),
+                &deployment.hash.to_ipfs_link(),
+            )
             .await
             .unwrap();
 
@@ -256,12 +238,14 @@ impl TestContext {
 
     pub async fn start_and_sync_to(&self, stop_block: BlockPtr) {
         // In case the subgraph has been previously started.
-        self.provider.stop(self.deployment.clone()).await.unwrap();
+        self.provider
+            .stop_subgraph(self.deployment.cheap_clone())
+            .await;
 
         self.provider
-            .start(self.deployment.clone(), Some(stop_block.number))
-            .await
-            .expect("unable to start subgraph");
+            .cheap_clone()
+            .start_subgraph(self.deployment.cheap_clone(), Some(stop_block.number))
+            .await;
 
         debug!(self.logger, "TEST: syncing to {}", stop_block.number);
 
@@ -277,12 +261,14 @@ impl TestContext {
 
     pub async fn start_and_sync_to_error(&self, stop_block: BlockPtr) -> SubgraphError {
         // In case the subgraph has been previously started.
-        self.provider.stop(self.deployment.clone()).await.unwrap();
+        self.provider
+            .stop_subgraph(self.deployment.cheap_clone())
+            .await;
 
         self.provider
-            .start(self.deployment.clone(), None)
-            .await
-            .expect("unable to start subgraph");
+            .cheap_clone()
+            .start_subgraph(self.deployment.cheap_clone(), None)
+            .await;
 
         wait_for_sync(
             &self.logger,
@@ -296,11 +282,7 @@ impl TestContext {
 
     pub async fn query(&self, query: &str) -> Result<Option<r::Value>, Vec<QueryError>> {
         let target = QueryTarget::Deployment(self.deployment.hash.clone(), ApiVersion::default());
-        let query = Query::new(
-            graphql_parser::parse_query(query).unwrap().into_static(),
-            None,
-            false,
-        );
+        let query = Query::new(q::parse_query(query).unwrap().into_static(), None, false);
         let query_res = self.graphql_runner.clone().run_query(query, target).await;
         query_res.first().unwrap().duplicate().to_result()
     }
@@ -324,7 +306,7 @@ impl TestContext {
             &self.subgraph_name
         );
         let body = json!({ "query": query }).to_string();
-        let req = hyper::Request::new(body.into());
+        let req: Request<Full<Bytes>> = Request::new(body.into());
         let res = self.indexing_status_service.handle_graphql_query(req).await;
         let value = res
             .unwrap()
@@ -339,23 +321,33 @@ impl TestContext {
         query_res.indexing_status_for_current_version
     }
 
-    pub fn rewind(&self, block_ptr_to: BlockPtr) {
+    pub async fn rewind(&self, block_ptr_to: BlockPtr) {
         self.store
-            .rewind(self.deployment.hash.clone(), block_ptr_to)
+            .rewind(self.deployment.id.into(), block_ptr_to)
+            .await
             .unwrap()
     }
 }
 
 impl Drop for TestContext {
     fn drop(&mut self) {
-        if let Err(e) = cleanup(&self.store, &self.subgraph_name, &self.deployment.hash) {
-            crit!(self.logger, "error cleaning up test subgraph"; "error" => e.to_string());
-        }
+        // Using drop to clean up the subgraph after the test is too clever
+        // by half and should really be done with an explicit method,
+        // something like `TestContext::cleanup(self)`.
+        let store = self.store.cheap_clone();
+        let subgraph_name = self.subgraph_name.clone();
+        let deployment_hash = self.deployment.hash.clone();
+        let logger = self.logger.cheap_clone();
+        graph::spawn(async move {
+            if let Err(e) = cleanup(&store, &subgraph_name, &deployment_hash).await {
+                crit!(logger, "error cleaning up test subgraph"; "error" => e.to_string());
+            }
+        });
     }
 }
 
 pub struct Stores {
-    network_name: String,
+    network_name: ChainName,
     chain_head_listener: Arc<ChainHeadUpdateListener>,
     pub network_store: Arc<Store>,
     chain_store: Arc<ChainStore>,
@@ -368,10 +360,12 @@ graph::prelude::lazy_static! {
 }
 
 fn test_logger(test_name: &str) -> Logger {
-    graph::log::logger(true).new(o!("test" => test_name.to_string()))
+    crate::output::test_logger(test_name)
 }
 
+#[allow(clippy::await_holding_lock)]
 pub async fn stores(test_name: &str, store_config_path: &str) -> Stores {
+    graph::tls::install_default_crypto_provider();
     let _mutex_guard = STORE_MUTEX.lock().unwrap();
 
     let config = {
@@ -385,7 +379,7 @@ pub async fn stores(test_name: &str, store_config_path: &str) -> Stores {
             Err(e) => panic!("{}", e.to_string()),
         };
         let config = config.replace("$THEGRAPH_STORE_POSTGRES_DIESEL_URL", &db_url);
-        Config::from_str(&config, "default").expect("failed to create configuration")
+        Config::from_str(&config, &Opt::default()).expect("failed to create configuration")
     };
 
     let logger = test_logger(test_name);
@@ -394,22 +388,27 @@ pub async fn stores(test_name: &str, store_config_path: &str) -> Stores {
     let store_builder =
         StoreBuilder::new(&logger, &node_id, &config, None, mock_registry.clone()).await;
 
-    let network_name: String = config.chains.chains.iter().next().unwrap().0.to_string();
+    let network_name: ChainName = config
+        .chains
+        .chains
+        .iter()
+        .next()
+        .unwrap()
+        .0
+        .as_str()
+        .into();
     let chain_head_listener = store_builder.chain_head_update_listener();
-    let network_identifiers = vec![(
-        network_name.clone(),
-        ChainIdentifier {
-            net_version: "".into(),
-            genesis_block_hash: test_ptr(0).hash,
-        },
-    )]
-    .into_iter()
-    .collect();
-    let network_store = store_builder.network_store(network_identifiers);
+    let network_identifiers: Vec<ChainName> = vec![network_name.clone()].into_iter().collect();
+    let network_store = store_builder.network_store(network_identifiers).await;
+    let ident = ChainIdentifier {
+        net_version: "".into(),
+        genesis_block_hash: test_ptr(0).hash,
+    };
     let chain_store = network_store
         .block_store()
-        .chain_store(network_name.as_ref())
-        .unwrap_or_else(|| panic!("No chain store for {}", &network_name));
+        .create_chain_store(&network_name, ident)
+        .await
+        .unwrap_or_else(|_| panic!("No chain store for {}", &network_name));
 
     Stores {
         network_name,
@@ -426,12 +425,98 @@ pub struct TestInfo {
     pub hash: DeploymentHash,
 }
 
+#[derive(Debug)]
+pub struct StaticArweaveResolver {
+    content: HashMap<String, Vec<u8>>,
+}
+
+impl StaticArweaveResolver {
+    pub fn new(content: HashMap<String, Vec<u8>>) -> Self {
+        Self { content }
+    }
+}
+
+#[async_trait]
+impl ArweaveResolver for StaticArweaveResolver {
+    async fn get(
+        &self,
+        file: &graph::data_source::offchain::Base64,
+    ) -> Result<Vec<u8>, ArweaveClientError> {
+        self.get_with_limit(file, &FileSizeLimit::Unlimited).await
+    }
+
+    async fn get_with_limit(
+        &self,
+        file: &graph::data_source::offchain::Base64,
+        _limit: &FileSizeLimit,
+    ) -> Result<Vec<u8>, ArweaveClientError> {
+        self.content
+            .get(file.as_str())
+            .cloned()
+            .ok_or(ArweaveClientError::UnableToCheckFileSize)
+    }
+}
+
 pub async fn setup<C: Blockchain>(
     test_info: &TestInfo,
     stores: &Stores,
     chain: &impl TestChainTrait<C>,
     graft_block: Option<BlockPtr>,
     env_vars: Option<EnvVars>,
+) -> TestContext {
+    setup_inner(test_info, stores, chain, graft_block, env_vars, None, None).await
+}
+
+pub async fn setup_with_file_link_resolver<C: Blockchain>(
+    test_info: &TestInfo,
+    stores: &Stores,
+    chain: &impl TestChainTrait<C>,
+    graft_block: Option<BlockPtr>,
+    env_vars: Option<EnvVars>,
+) -> TestContext {
+    let mut base_dir = PathBuf::from(test_info.test_dir.clone());
+    base_dir.push("build");
+    let link_resolver = Arc::new(FileLinkResolver::with_base_dir(base_dir));
+    setup_inner(
+        test_info,
+        stores,
+        chain,
+        graft_block,
+        env_vars,
+        Some(link_resolver),
+        None,
+    )
+    .await
+}
+
+pub async fn setup_with_arweave_resolver<C: Blockchain>(
+    test_info: &TestInfo,
+    stores: &Stores,
+    chain: &impl TestChainTrait<C>,
+    graft_block: Option<BlockPtr>,
+    env_vars: Option<EnvVars>,
+    arweave_resolver: Arc<dyn ArweaveResolver>,
+) -> TestContext {
+    setup_inner(
+        test_info,
+        stores,
+        chain,
+        graft_block,
+        env_vars,
+        None,
+        Some(arweave_resolver),
+    )
+    .await
+}
+
+pub async fn setup_inner<C: Blockchain>(
+    test_info: &TestInfo,
+    stores: &Stores,
+    chain: &impl TestChainTrait<C>,
+    graft_block: Option<BlockPtr>,
+    env_vars: Option<EnvVars>,
+    link_resolver: Option<Arc<dyn LinkResolver>>,
+    arweave_resolver: Option<Arc<dyn ArweaveResolver>>,
 ) -> TestContext {
     let env_vars = Arc::new(match env_vars {
         Some(ev) => ev,
@@ -445,29 +530,43 @@ pub async fn setup<C: Blockchain>(
 
     // Make sure we're starting from a clean state.
     let subgraph_store = stores.network_store.subgraph_store();
-    cleanup(&subgraph_store, &test_info.subgraph_name, &test_info.hash).unwrap();
+    cleanup(&subgraph_store, &test_info.subgraph_name, &test_info.hash)
+        .await
+        .unwrap();
 
     let mut blockchain_map = BlockchainMap::new();
     blockchain_map.insert(stores.network_name.clone(), chain.chain());
 
     let static_filters = env_vars.experimental_static_filters;
 
-    let ipfs = IpfsClient::localhost();
-    let link_resolver = Arc::new(LinkResolver::new(
-        vec![ipfs.cheap_clone()],
-        Default::default(),
-    ));
+    let ipfs_client: Arc<dyn IpfsClient> = Arc::new(
+        graph::ipfs::IpfsRpcClient::new_unchecked(
+            graph::ipfs::ServerAddress::test_rpc_api(),
+            IpfsMetrics::new(&mock_registry),
+            &logger,
+        )
+        .unwrap(),
+    );
+
+    let link_resolver = match link_resolver {
+        Some(link_resolver) => link_resolver,
+        None => Arc::new(IpfsResolver::new(
+            ipfs_client.cheap_clone(),
+            Default::default(),
+        )),
+    };
+
     let ipfs_service = ipfs_service(
-        ipfs.cheap_clone(),
-        env_vars.mappings.max_ipfs_file_bytes as u64,
+        ipfs_client.cheap_clone(),
+        env_vars.mappings.max_ipfs_file_bytes,
         env_vars.mappings.ipfs_timeout,
         env_vars.mappings.ipfs_request_limit,
     );
 
-    let arweave_resolver = Arc::new(ArweaveClient::default());
+    let arweave_resolver: Arc<dyn ArweaveResolver> =
+        arweave_resolver.unwrap_or_else(|| Arc::new(ArweaveClient::default()));
     let arweave_service = arweave_service(
         arweave_resolver.cheap_clone(),
-        env_vars.mappings.ipfs_timeout,
         env_vars.mappings.ipfs_request_limit,
         match env_vars.mappings.max_ipfs_file_bytes {
             0 => FileSizeLimit::Unlimited,
@@ -477,7 +576,8 @@ pub async fn setup<C: Blockchain>(
     let sg_count = Arc::new(SubgraphCountMetric::new(mock_registry.cheap_clone()));
 
     let blockchain_map = Arc::new(blockchain_map);
-    let subgraph_instance_manager = SubgraphInstanceManager::new(
+
+    let subgraph_instance_manager = Arc::new(graph_core::subgraph::SubgraphInstanceManager::new(
         &logger_factory,
         env_vars.cheap_clone(),
         subgraph_store.clone(),
@@ -487,48 +587,59 @@ pub async fn setup<C: Blockchain>(
         link_resolver.cheap_clone(),
         ipfs_service,
         arweave_service,
+        None,
         static_filters,
+    ));
+
+    let mut subgraph_instance_managers =
+        graph_core::subgraph_provider::SubgraphInstanceManagers::new();
+
+    subgraph_instance_managers.add(
+        graph_core::subgraph_provider::SubgraphProcessingKind::Trigger,
+        subgraph_instance_manager.cheap_clone(),
     );
 
+    let subgraph_provider = Arc::new(graph_core::subgraph_provider::SubgraphProvider::new(
+        &logger_factory,
+        sg_count.cheap_clone(),
+        subgraph_store.clone(),
+        link_resolver.cheap_clone(),
+        tokio_util::sync::CancellationToken::new(),
+        subgraph_instance_managers,
+    ));
+
     // Graphql runner
-    let subscription_manager = Arc::new(PanicSubscriptionManager {});
     let load_manager = LoadManager::new(&logger, Vec::new(), Vec::new(), mock_registry.clone());
     let graphql_runner = Arc::new(GraphQlRunner::new(
         &logger,
         stores.network_store.clone(),
-        subscription_manager.clone(),
         Arc::new(load_manager),
         mock_registry.clone(),
+        Arc::new(graph::components::log_store::NoOpLogStore),
     ));
 
     let indexing_status_service = Arc::new(IndexNodeService::new(
         logger.cheap_clone(),
         blockchain_map.cheap_clone(),
-        graphql_runner.cheap_clone(),
         stores.network_store.cheap_clone(),
         link_resolver.cheap_clone(),
-    ));
-
-    // Create IPFS-based subgraph provider
-    let subgraph_provider = Arc::new(IpfsSubgraphAssignmentProvider::new(
-        &logger_factory,
-        link_resolver.cheap_clone(),
-        subgraph_instance_manager.clone(),
-        sg_count,
+        None,
     ));
 
     let panicking_subscription_manager = Arc::new(PanicSubscriptionManager {});
 
-    let subgraph_registrar = Arc::new(IpfsSubgraphRegistrar::new(
+    let subgraph_registrar = Arc::new(graph_core::subgraph::SubgraphRegistrar::new(
         &logger_factory,
         link_resolver.cheap_clone(),
-        subgraph_provider.clone(),
+        subgraph_provider.cheap_clone(),
         subgraph_store.clone(),
         panicking_subscription_manager,
+        Option::<Arc<amp::FlightClient>>::None,
         blockchain_map.clone(),
         node_id.clone(),
         SubgraphVersionSwitchingMode::Instant,
         Arc::new(Settings::default()),
+        Arc::new(graph::components::network_provider::AmpChainNames::default()),
     ));
 
     SubgraphRegistrar::create_subgraph(
@@ -547,12 +658,11 @@ pub async fn setup<C: Blockchain>(
         None,
         graft_block,
         None,
+        false,
     )
     .await
     .expect("failed to create subgraph version");
 
-    let arweave_resolver = Arc::new(ArweaveClient::default());
-
     TestContext {
         logger: logger_factory.subgraph_logger(&deployment),
         provider: subgraph_provider,
@@ -564,20 +674,20 @@ pub async fn setup<C: Blockchain>(
         link_resolver,
         env_vars,
         indexing_status_service,
-        ipfs,
+        ipfs: ipfs_client,
         arweave_resolver,
     }
 }
 
-pub fn cleanup(
+pub async fn cleanup(
     subgraph_store: &SubgraphStore,
     name: &SubgraphName,
     hash: &DeploymentHash,
 ) -> Result<(), Error> {
-    let locators = subgraph_store.locators(hash)?;
-    subgraph_store.remove_subgraph(name.clone())?;
+    let locators = subgraph_store.locators(hash).await?;
+    subgraph_store.remove_subgraph(name.clone()).await?;
     for locator in locators {
-        subgraph_store.remove_deployment(locator.id.into())?;
+        subgraph_store.remove_deployment(locator.id.into()).await?;
     }
     Ok(())
 }
@@ -630,7 +740,7 @@ pub async fn wait_for_sync(
             }
         };
         info!(logger, "TEST: sync status: {:?}", block_ptr);
-        let status = store.status_for_id(deployment.id);
+        let status = store.status_for_id(deployment.id).await;
 
         if let Some(fatal_error) = status.fatal_error {
             return Err(fatal_error);
@@ -696,28 +806,29 @@ impl<C: Blockchain> BlockStreamBuilder<C> for MutexBlockStreamBuilder<C> {
             .await
     }
 
-    async fn build_substreams(
-        &self,
-        _chain: &C,
-        _schema: InputSchema,
-        _deployment: DeploymentLocator,
-        _block_cursor: FirehoseCursor,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<C::TriggerFilter>,
-    ) -> anyhow::Result<Box<dyn BlockStream<C>>> {
-        unimplemented!();
-    }
-
     async fn build_polling(
         &self,
-        _chain: &C,
-        _deployment: DeploymentLocator,
-        _start_blocks: Vec<BlockNumber>,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<<C as Blockchain>::TriggerFilter>,
-        _unified_api_version: graph::data::subgraph::UnifiedMappingApiVersion,
+        chain: &C,
+        deployment: DeploymentLocator,
+        start_blocks: Vec<BlockNumber>,
+        source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
+        subgraph_current_block: Option<BlockPtr>,
+        filter: Arc<TriggerFilterWrapper<C>>,
+        unified_api_version: graph::data::subgraph::UnifiedMappingApiVersion,
     ) -> anyhow::Result<Box<dyn BlockStream<C>>> {
-        unimplemented!("only firehose mode should be used for tests")
+        let builder = self.0.lock().unwrap().clone();
+
+        builder
+            .build_polling(
+                chain,
+                deployment,
+                start_blocks,
+                source_subgraph_stores,
+                subgraph_current_block,
+                filter,
+                unified_api_version,
+            )
+            .await
     }
 }
 
@@ -735,18 +846,6 @@ impl<C: Blockchain> BlockStreamBuilder<C> for StaticStreamBuilder<C>
 where
     C::TriggerData: Clone,
 {
-    async fn build_substreams(
-        &self,
-        _chain: &C,
-        _schema: InputSchema,
-        _deployment: DeploymentLocator,
-        _block_cursor: FirehoseCursor,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<C::TriggerFilter>,
-    ) -> anyhow::Result<Box<dyn BlockStream<C>>> {
-        unimplemented!()
-    }
-
     async fn build_firehose(
         &self,
         _chain: &C,
@@ -775,16 +874,27 @@ where
         _chain: &C,
         _deployment: DeploymentLocator,
         _start_blocks: Vec<graph::prelude::BlockNumber>,
-        _subgraph_current_block: Option<graph::blockchain::BlockPtr>,
-        _filter: Arc<C::TriggerFilter>,
+        _source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
+        subgraph_current_block: Option<graph::blockchain::BlockPtr>,
+        _filter: Arc<TriggerFilterWrapper<C>>,
         _unified_api_version: graph::data::subgraph::UnifiedMappingApiVersion,
     ) -> anyhow::Result<Box<dyn BlockStream<C>>> {
-        unimplemented!("only firehose mode should be used for tests")
+        let current_idx = subgraph_current_block.map(|current_block| {
+            self.chain
+                .iter()
+                .enumerate()
+                .find(|(_, b)| b.ptr() == current_block)
+                .unwrap()
+                .0
+        });
+        Ok(Box::new(StaticStream {
+            stream: Box::pin(stream_events(self.chain.clone(), current_idx)),
+        }))
     }
 }
 
 struct StaticStream<C: Blockchain> {
-    stream: Pin<Box<dyn Stream<Item = Result<BlockStreamEvent<C>, Error>> + Send>>,
+    stream: Pin<Box<dyn Stream<Item = Result<BlockStreamEvent<C>, BlockStreamError>> + Send>>,
 }
 
 impl<C: Blockchain> BlockStream<C> for StaticStream<C> {
@@ -794,7 +904,7 @@ impl<C: Blockchain> BlockStream<C> for StaticStream<C> {
 }
 
 impl<C: Blockchain> Stream for StaticStream<C> {
-    type Item = Result<BlockStreamEvent<C>, Error>;
+    type Item = Result<BlockStreamEvent<C>, BlockStreamError>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         self.stream.poll_next_unpin(cx)
@@ -804,7 +914,7 @@ impl<C: Blockchain> Stream for StaticStream<C> {
 fn stream_events<C: Blockchain>(
     blocks: Vec<BlockWithTriggers<C>>,
     current_idx: Option<usize>,
-) -> impl Stream<Item = Result<BlockStreamEvent<C>, Error>>
+) -> impl Stream<Item = Result<BlockStreamEvent<C>, BlockStreamError>>
 where
     C::TriggerData: Clone,
 {
@@ -858,14 +968,24 @@ struct NoopRuntimeAdapter<C> {
 }
 
 impl<C: Blockchain> RuntimeAdapter<C> for NoopRuntimeAdapter<C> {
-    fn host_fns(
-        &self,
-        _ds: &<C as Blockchain>::DataSource,
-    ) -> Result<Vec<graph::blockchain::HostFn>, Error> {
+    fn host_fns(&self, _ds: &DataSource<C>) -> Result<Vec<graph::blockchain::HostFn>, Error> {
         Ok(vec![])
     }
 }
 
+struct NoopRuntimeAdapterBuilder {}
+
+impl RuntimeAdapterBuilder for NoopRuntimeAdapterBuilder {
+    fn build(
+        &self,
+        _: Arc<EthereumNetworkAdapters>,
+        _: Arc<dyn EthereumCallCache + 'static>,
+        _: Arc<ChainIdentifier>,
+    ) -> Arc<dyn graph::blockchain::RuntimeAdapter<graph_chain_ethereum::Chain> + 'static> {
+        Arc::new(NoopRuntimeAdapter { x: PhantomData })
+    }
+}
+
 pub struct NoopAdapterSelector<C> {
     pub x: PhantomData<C>,
     pub triggers_in_block_sleep: Duration,
@@ -926,16 +1046,29 @@ impl<C: Blockchain> TriggersAdapter<C> for MockTriggersAdapter<C> {
         &self,
         _ptr: BlockPtr,
         _offset: BlockNumber,
+        _root: Option<BlockHash>,
     ) -> Result<Option<<C as Blockchain>::Block>, Error> {
         todo!()
     }
 
+    async fn load_block_ptrs_by_numbers(
+        &self,
+        _logger: Logger,
+        _block_numbers: BTreeSet<BlockNumber>,
+    ) -> Result<Vec<C::Block>, Error> {
+        unimplemented!()
+    }
+
+    async fn chain_head_ptr(&self) -> Result<Option<BlockPtr>, Error> {
+        todo!()
+    }
+
     async fn scan_triggers(
         &self,
         _from: BlockNumber,
         _to: BlockNumber,
-        _filter: &<C as Blockchain>::TriggerFilter,
-    ) -> Result<Vec<BlockWithTriggers<C>>, Error> {
+        _filter: &C::TriggerFilter,
+    ) -> Result<(Vec<BlockWithTriggers<C>>, BlockNumber), Error> {
         todo!()
     }
 
diff --git a/tests/src/fixture/substreams.rs b/tests/src/fixture/substreams.rs
deleted file mode 100644
index f40943b8914..00000000000
--- a/tests/src/fixture/substreams.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use std::sync::Arc;
-
-use super::{CommonChainConfig, Stores, TestChainSubstreams};
-
-pub async fn chain(test_name: &str, stores: &Stores) -> TestChainSubstreams {
-    let CommonChainConfig {
-        logger_factory,
-        mock_registry,
-        chain_store,
-        firehose_endpoints,
-        ..
-    } = CommonChainConfig::new(test_name, stores).await;
-
-    let block_stream_builder = Arc::new(graph_chain_substreams::BlockStreamBuilder::new());
-
-    let chain = Arc::new(graph_chain_substreams::Chain::new(
-        logger_factory,
-        firehose_endpoints,
-        mock_registry,
-        chain_store,
-        block_stream_builder.clone(),
-    ));
-
-    TestChainSubstreams {
-        chain,
-        block_stream_builder,
-    }
-}
diff --git a/tests/src/helpers.rs b/tests/src/helpers.rs
index 4a59c1df7ef..50403d46eea 100644
--- a/tests/src/helpers.rs
+++ b/tests/src/helpers.rs
@@ -1,11 +1,12 @@
 use std::fs::File;
-use std::io::BufReader;
+use std::io::{BufReader, Write};
 use std::path::PathBuf;
 use std::process::Command;
 
-use anyhow::{bail, Context};
+use crate::output::OutputConfig;
+use anyhow::{Context, bail};
 use graph::itertools::Itertools;
-use graph::prelude::serde_json::{json, Value};
+use graph::prelude::serde_json::{Value, json};
 use graph::prelude::{reqwest, serde_json};
 
 /// Parses stdout bytes into a prefixed String
@@ -80,14 +81,20 @@ pub fn run_cmd(command: &mut Command) -> String {
         .output()
         .context(format!("failed to run {}", program))
         .unwrap();
-    println!(
+
+    let mut out = OutputConfig::get();
+    writeln!(
+        out,
         "stdout:\n{}",
         pretty_output(&output.stdout, &format!("[{}:stdout] ", program))
-    );
-    println!(
+    )
+    .unwrap();
+    writeln!(
+        out,
         "stderr:\n{}",
         pretty_output(&output.stderr, &format!("[{}:stderr] ", program))
-    );
+    )
+    .unwrap();
 
     String::from_utf8(output.stdout).unwrap()
 }
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index c89168d7003..860f6da714d 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -4,6 +4,9 @@ pub mod fixture;
 pub mod helpers;
 #[macro_use]
 pub mod macros;
+pub mod output;
+pub mod recipe;
 pub mod subgraph;
 
-pub use config::{Config, DbConfig, EthConfig, CONFIG};
+pub use config::{CONFIG, Config, DbConfig, EthConfig};
+pub use output::OutputConfig;
diff --git a/tests/src/output.rs b/tests/src/output.rs
new file mode 100644
index 00000000000..fece1947528
--- /dev/null
+++ b/tests/src/output.rs
@@ -0,0 +1,142 @@
+//! Output configuration for runner tests.
+//!
+//! When running locally, verbose output (slog logs, command stdout/stderr) is redirected
+//! to `tests/runner-tests.log` while progress messages appear on the console.
+//! In CI (detected via `GITHUB_ACTIONS` env var), all output goes to the console.
+
+use slog::{Drain, Logger, o};
+use std::fs::File;
+use std::io::{self, Write};
+use std::path::PathBuf;
+use std::sync::{Mutex, OnceLock};
+
+/// Log file name relative to the `tests` crate root.
+const LOG_FILE_NAME: &str = "runner-tests.log";
+
+/// Global output configuration, initialized once.
+static OUTPUT_CONFIG: OnceLock<OutputConfig> = OnceLock::new();
+
+/// Output configuration for runner tests.
+pub struct OutputConfig {
+    /// Log file handle (None in CI mode).
+    log_file: Option<Mutex<File>>,
+    /// Absolute path to log file (None in CI mode).
+    log_file_path: Option<PathBuf>,
+    /// Whether running in CI.
+    is_ci: bool,
+}
+
+impl OutputConfig {
+    /// Initialize the global output configuration.
+    ///
+    /// In CI (when `GITHUB_ACTIONS` is set), output goes to stdout.
+    /// Locally, verbose output is redirected to the log file.
+    ///
+    /// Prints the log file path at startup (local only).
+    pub fn init() -> &'static Self {
+        OUTPUT_CONFIG.get_or_init(|| {
+            let is_ci = std::env::var("GITHUB_ACTIONS").is_ok();
+
+            if is_ci {
+                OutputConfig {
+                    log_file: None,
+                    log_file_path: None,
+                    is_ci,
+                }
+            } else {
+                let cwd = std::env::current_dir()
+                    .expect("Failed to get current directory")
+                    .canonicalize()
+                    .expect("Failed to canonicalize current directory");
+                let log_file_path = cwd.join(LOG_FILE_NAME);
+
+                let file = File::create(&log_file_path).unwrap_or_else(|e| {
+                    panic!(
+                        "Failed to create log file {}: {}",
+                        log_file_path.display(),
+                        e
+                    )
+                });
+
+                let config = OutputConfig {
+                    log_file: Some(Mutex::new(file)),
+                    log_file_path: Some(log_file_path),
+                    is_ci,
+                };
+
+                // Print log file path at startup
+                config.print_log_file_info();
+
+                config
+            }
+        })
+    }
+
+    /// Get the global output configuration, initializing if needed.
+    pub fn get() -> &'static Self {
+        Self::init()
+    }
+
+    /// Print the log file path to console.
+    pub fn print_log_file_info(&self) {
+        if let Some(ref path) = self.log_file_path {
+            println!("Runner test logs: {}", path.display());
+        }
+    }
+
+    /// Returns true if running in CI.
+    pub fn is_ci(&self) -> bool {
+        self.is_ci
+    }
+}
+
+impl Write for &OutputConfig {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        if let Some(ref file_mutex) = self.log_file {
+            file_mutex.lock().unwrap().write(buf)
+        } else {
+            io::stdout().write(buf)
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        if let Some(ref file_mutex) = self.log_file {
+            file_mutex.lock().unwrap().flush()
+        } else {
+            io::stdout().flush()
+        }
+    }
+}
+
+/// Create a slog logger for a test, respecting the output configuration.
+///
+/// In CI, logs go to stdout. Locally, logs go to the log file.
+pub fn test_logger(test_name: &str) -> Logger {
+    let output = OutputConfig::get();
+
+    if output.is_ci {
+        // CI: use default logger that writes to stdout
+        graph::log::logger(true).new(o!("test" => test_name.to_string()))
+    } else {
+        // Local: write to log file
+        let decorator = slog_term::PlainDecorator::new(LogFileWriter);
+        let drain = slog_term::FullFormat::new(decorator).build().fuse();
+        let drain = slog_async::Async::new(drain).build().fuse();
+        Logger::root(drain, o!("test" => test_name.to_string()))
+    }
+}
+
+/// A writer that forwards to the OutputConfig log file.
+struct LogFileWriter;
+
+impl io::Write for LogFileWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let mut output = OutputConfig::get();
+        output.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        let mut output = OutputConfig::get();
+        output.flush()
+    }
+}
diff --git a/tests/src/recipe.rs b/tests/src/recipe.rs
new file mode 100644
index 00000000000..d1d424ad190
--- /dev/null
+++ b/tests/src/recipe.rs
@@ -0,0 +1,127 @@
+use crate::{
+    fixture::{Stores, TestInfo, stores},
+    helpers::run_cmd,
+};
+use graph::prelude::{DeploymentHash, SubgraphName};
+use graph::{ipfs, prelude::MetricsRegistry};
+use std::process::Command;
+pub struct RunnerTestRecipe {
+    pub stores: Stores,
+    pub test_info: TestInfo,
+}
+
+impl RunnerTestRecipe {
+    pub async fn new(test_name: &str, subgraph_name: &str) -> Self {
+        let subgraph_name = SubgraphName::new(subgraph_name).unwrap();
+        let test_dir = format!("./runner-tests/{}", subgraph_name);
+
+        let (stores, hash) = tokio::join!(
+            stores(test_name, "./runner-tests/config.simple.toml"),
+            build_subgraph(&test_dir, None)
+        );
+
+        Self {
+            stores,
+            test_info: TestInfo {
+                test_dir,
+                test_name: test_name.to_string(),
+                subgraph_name,
+                hash,
+            },
+        }
+    }
+
+    /// Builds a new test subgraph with a custom deploy command.
+    pub async fn new_with_custom_cmd(name: &str, subgraph_name: &str, deploy_cmd: &str) -> Self {
+        let subgraph_name = SubgraphName::new(subgraph_name).unwrap();
+        let test_dir = format!("./runner-tests/{}", subgraph_name);
+
+        let (stores, hash) = tokio::join!(
+            stores(name, "./runner-tests/config.simple.toml"),
+            build_subgraph(&test_dir, Some(deploy_cmd))
+        );
+
+        Self {
+            stores,
+            test_info: TestInfo {
+                test_dir,
+                test_name: name.to_string(),
+                subgraph_name,
+                hash,
+            },
+        }
+    }
+
+    pub async fn new_with_file_link_resolver(
+        name: &str,
+        subgraph_name: &str,
+        manifest: &str,
+    ) -> Self {
+        let subgraph_name = SubgraphName::new(subgraph_name).unwrap();
+        let test_dir = format!("./runner-tests/{}", subgraph_name);
+
+        let stores = stores(name, "./runner-tests/config.simple.toml").await;
+        build_subgraph(&test_dir, None).await;
+        let hash = DeploymentHash::new(manifest).unwrap();
+        Self {
+            stores,
+            test_info: TestInfo {
+                test_dir,
+                test_name: name.to_string(),
+                subgraph_name,
+                hash,
+            },
+        }
+    }
+}
+
+/// deploy_cmd is the command to run to deploy the subgraph. If it is None, the
+/// default `pnpm deploy:test` is used.
+async fn build_subgraph(dir: &str, deploy_cmd: Option<&str>) -> DeploymentHash {
+    build_subgraph_with_pnpm_cmd(dir, deploy_cmd.unwrap_or("deploy:test")).await
+}
+
+async fn build_subgraph_with_pnpm_cmd(dir: &str, pnpm_cmd: &str) -> DeploymentHash {
+    build_subgraph_with_pnpm_cmd_and_arg(dir, pnpm_cmd, None).await
+}
+
+pub async fn build_subgraph_with_pnpm_cmd_and_arg(
+    dir: &str,
+    pnpm_cmd: &str,
+    arg: Option<&str>,
+) -> DeploymentHash {
+    // Test that IPFS is up.
+    ipfs::IpfsRpcClient::new(
+        ipfs::ServerAddress::test_rpc_api(),
+        ipfs::IpfsMetrics::new(&MetricsRegistry::mock()),
+        &graph::log::discard(),
+    )
+    .await
+    .expect("Could not connect to IPFS, make sure it's running at port 5001");
+
+    // Run codegen.
+    run_cmd(Command::new("pnpm").arg("codegen").current_dir(dir));
+
+    let mut args = vec![pnpm_cmd];
+    args.extend(arg);
+
+    // Run `deploy` for the side effect of uploading to IPFS, the graph node url
+    // is fake and the actual deploy call is meant to fail.
+    let deploy_output = run_cmd(
+        Command::new("pnpm")
+            .args(&args)
+            .env("IPFS_URI", ipfs::ServerAddress::test_rpc_api().to_string())
+            .env("GRAPH_NODE_ADMIN_URI", "http://localhost:0")
+            .current_dir(dir),
+    );
+
+    // Hack to extract deployment id from `graph deploy` output.
+    const ID_PREFIX: &str = "Build completed: ";
+    let Some(mut line) = deploy_output.lines().find(|line| line.contains(ID_PREFIX)) else {
+        panic!("No deployment id found, graph deploy probably had an error")
+    };
+    if !line.starts_with(ID_PREFIX) {
+        line = &line[5..line.len() - 5]; // workaround for colored output
+    }
+    DeploymentHash::new(line.trim_start_matches(ID_PREFIX)).unwrap()
+}
diff --git a/tests/src/subgraph.rs b/tests/src/subgraph.rs
index bfa66fc60dd..43c970fbd40 100644
--- a/tests/src/subgraph.rs
+++ b/tests/src/subgraph.rs
@@ -1,18 +1,20 @@
 use std::{
+    fs,
     io::{Read as _, Write as _},
     time::{Duration, Instant},
 };
 
-use anyhow::anyhow;
+use anyhow::{anyhow, bail};
 
 use graph::prelude::serde_json::{self, Value};
 use serde::Deserialize;
+use serde_yaml;
 use tokio::{process::Command, time::sleep};
 
 use crate::{
-    contract::Contract,
-    helpers::{graphql_query, graphql_query_with_vars, run_checked, TestFile},
     CONFIG,
+    contract::Contract,
+    helpers::{TestFile, graphql_query, graphql_query_with_vars, run_checked},
 };
 
 #[derive(Clone, Debug)]
@@ -24,7 +26,7 @@ pub struct Subgraph {
 }
 
 impl Subgraph {
-    fn dir(name: &str) -> TestFile {
+    pub fn dir(name: &str) -> TestFile {
         TestFile::new(&format!("integration-tests/{name}"))
     }
 
@@ -45,13 +47,74 @@ impl Subgraph {
         Ok(())
     }
 
-    /// Deploy the subgraph by running the required `graph` commands
-    pub async fn deploy(name: &str, contracts: &[Contract]) -> anyhow::Result<String> {
+    /// Patch source subgraph placeholders in the manifest with their deployment hashes.
+    /// This must be called after `patch()` since it reads from `subgraph.yaml.patched`.
+    pub fn patch_sources(dir: &TestFile, sources: &[(String, String)]) -> anyhow::Result<()> {
+        if sources.is_empty() {
+            return Ok(());
+        }
+
+        let patched_path = dir.path.join("subgraph.yaml.patched");
+        let mut content = fs::read_to_string(&patched_path)?;
+
+        for (placeholder, deployment_hash) in sources {
+            let repl = format!("@{}@", placeholder);
+            content = content.replace(&repl, deployment_hash);
+        }
+
+        fs::write(&patched_path, content)?;
+        Ok(())
+    }
+
+    /// Prepare the subgraph for deployment by patching contracts and checking for subgraph datasources
+    pub async fn prepare(
+        name: &str,
+        contracts: &[Contract],
+        sources: Option<&[(String, String)]>,
+    ) -> anyhow::Result<(TestFile, String, bool)> {
         let dir = Self::dir(name);
         let name = format!("test/{name}");
 
         Self::patch(&dir, contracts).await?;
 
+        // Patch source subgraph placeholders if provided
+        if let Some(sources) = sources {
+            Self::patch_sources(&dir, sources)?;
+        }
+
+        // Check if subgraph has subgraph datasources
+        let yaml_content = fs::read_to_string(dir.path.join("subgraph.yaml.patched"))?;
+        let yaml: serde_yaml::Value = serde_yaml::from_str(&yaml_content)?;
+        let has_subgraph_datasource = yaml["dataSources"]
+            .as_sequence()
+            .and_then(|ds| ds.iter().find(|d| d["kind"].as_str() == Some("subgraph")))
+            .is_some();
+
+        Ok((dir, name, has_subgraph_datasource))
+    }
+
+    /// Deploy the subgraph by running the required `graph` commands.
+    /// If `sources` is provided, the deployment hashes will be used to patch
+    /// source subgraph placeholders (e.g., `@source-subgraph@`) in the manifest.
+    pub async fn deploy(
+        name: &str,
+        contracts: &[Contract],
+        sources: Option<&[(String, String)]>,
+    ) -> anyhow::Result<String> {
+        let (dir, name, has_subgraph_datasource) = Self::prepare(name, contracts, sources).await?;
+
+        // graph codegen subgraph.yaml
+        let mut prog = Command::new(&CONFIG.graph_cli);
+        let mut cmd = prog.arg("codegen").arg("subgraph.yaml.patched");
+
+        if has_subgraph_datasource {
+            cmd = cmd.arg(format!("--ipfs={}", CONFIG.graph_node.ipfs_uri));
+        }
+
+        cmd = cmd.current_dir(&dir.path);
+
+        run_checked(cmd).await?;
+
         // graph create --node <node> <name>
         let mut prog = Command::new(&CONFIG.graph_cli);
         let cmd = prog
@@ -60,15 +123,15 @@ impl Subgraph {
             .arg(CONFIG.graph_node.admin_uri())
             .arg(&name)
             .current_dir(&dir.path);
-        run_checked(cmd).await?;
 
-        // graph codegen subgraph.yaml
-        let mut prog = Command::new(&CONFIG.graph_cli);
-        let cmd = prog
-            .arg("codegen")
-            .arg("subgraph.yaml.patched")
-            .current_dir(&dir.path);
-        run_checked(cmd).await?;
+        for _ in 0..10 {
+            match run_checked(cmd).await {
+                Ok(_) => break,
+                Err(_) => {
+                    tokio::time::sleep(Duration::from_millis(100)).await;
+                }
+            }
+        }
 
         // graph deploy --node <node> --version-label v0.0.1 --ipfs <ipfs> <name> subgraph.yaml
         let mut prog = Command::new(&CONFIG.graph_cli);
@@ -92,10 +155,10 @@ impl Subgraph {
     pub async fn wait_ready(name: &str) -> anyhow::Result<Subgraph> {
         let start = Instant::now();
         while start.elapsed() <= CONFIG.timeout {
-            if let Some(subgraph) = Self::status(&name).await? {
-                if subgraph.synced || !subgraph.healthy {
-                    return Ok(subgraph);
-                }
+            if let Some(subgraph) = Self::status(name).await?
+                && (subgraph.synced || !subgraph.healthy)
+            {
+                return Ok(subgraph);
             }
             sleep(Duration::from_millis(2000)).await;
         }
@@ -142,8 +205,43 @@ impl Subgraph {
     }
 
     /// Make a GraphQL query to the index node API
-    pub async fn index_with_vars(&self, text: &str, vars: Value) -> anyhow::Result<Value> {
+    pub async fn query_with_vars(text: &str, vars: Value) -> anyhow::Result<Value> {
         let endpoint = CONFIG.graph_node.index_node_uri();
         graphql_query_with_vars(&endpoint, text, vars).await
     }
+
+    /// Poll the subgraph's data API until the `query` returns non-empty
+    /// results for any of the specified `keys`. The `keys` must be the
+    /// toplevel entries in the GraphQL `query`. The return value is a
+    /// vector of vectors, where each inner vector contains the results for
+    /// one of the specified `keys`, in the order in which they appear in
+    /// `keys`.
+    pub async fn polling_query(
+        &self,
+        query: &str,
+        keys: &[&str],
+    ) -> anyhow::Result<Vec<Vec<Value>>> {
+        let start = Instant::now();
+        loop {
+            let resp = self.query(query).await?;
+
+            if let Some(errors) = resp.get("errors") {
+                bail!("GraphQL errors: {:?}", errors);
+            }
+            let data = resp["data"].as_object().unwrap();
+            let values = keys
+                .iter()
+                .map(|key| data[*key].as_array().unwrap().clone())
+                .collect::<Vec<_>>();
+
+            if !values.iter().all(|item| item.is_empty()) {
+                break Ok(values);
+            }
+
+            if start.elapsed() > Duration::from_secs(30) {
+                bail!("Timed out waiting for declared calls to be indexed");
+            }
+            sleep(Duration::from_millis(100)).await;
+        }
+    }
 }
diff --git a/tests/tests/file_link_resolver.rs b/tests/tests/file_link_resolver.rs
new file mode 100644
index 00000000000..0fdab778a3b
--- /dev/null
+++ b/tests/tests/file_link_resolver.rs
@@ -0,0 +1,64 @@
+use graph::object;
+use graph_tests::{
+    fixture::{
+        self,
+        ethereum::{chain, empty_block, genesis},
+        test_ptr,
+    },
+    recipe::RunnerTestRecipe,
+};
+
+#[graph::test]
+async fn file_link_resolver() -> anyhow::Result<()> {
+    unsafe {
+        std::env::set_var("GRAPH_NODE_DISABLE_DEPLOYMENT_HASH_VALIDATION", "true");
+    }
+    let RunnerTestRecipe { stores, test_info } = RunnerTestRecipe::new_with_file_link_resolver(
+        "file_link_resolver",
+        "file-link-resolver",
+        "subgraph.yaml",
+    )
+    .await;
+
+    let blocks = {
+        let block_0 = genesis();
+        let block_1 = empty_block(block_0.ptr(), test_ptr(1));
+        let block_2 = empty_block(block_1.ptr(), test_ptr(2));
+        let block_3 = empty_block(block_2.ptr(), test_ptr(3));
+
+        vec![block_0, block_1, block_2, block_3]
+    };
+
+    let chain = chain(&test_info.test_name, blocks, &stores, None).await;
+
+    let ctx = fixture::setup_with_file_link_resolver(&test_info, &stores, &chain, None, None).await;
+    ctx.start_and_sync_to(test_ptr(3)).await;
+    let query = r#"{ blocks(first: 4, orderBy: number) { id, hash } }"#;
+    let query_res = ctx.query(query).await.unwrap();
+
+    assert_eq!(
+        query_res,
+        Some(object! {
+            blocks: vec![
+                object! {
+                    id: test_ptr(0).number.to_string(),
+                    hash: format!("0x{}", test_ptr(0).hash_hex()),
+                },
+                object! {
+                    id: test_ptr(1).number.to_string(),
+                    hash: format!("0x{}", test_ptr(1).hash_hex()),
+                },
+                object! {
+                    id: test_ptr(2).number.to_string(),
+                    hash: format!("0x{}", test_ptr(2).hash_hex()),
+                },
+                object! {
+                    id: test_ptr(3).number.to_string(),
+                    hash: format!("0x{}", test_ptr(3).hash_hex()),
+                },
+            ]
+        })
+    );
+
+    Ok(())
+}
diff --git a/tests/tests/gnd_cli_tests.rs b/tests/tests/gnd_cli_tests.rs
new file mode 100644
index 00000000000..1bbeb88cbc8
--- /dev/null
+++ b/tests/tests/gnd_cli_tests.rs
@@ -0,0 +1,173 @@
+//! Integration tests that verify `gnd` works as a drop-in replacement for `graph-cli`.
+//!
+//! These tests run a subset of the integration tests using `gnd` instead of `graph-cli`
+//! for the deployment workflow (codegen, create, deploy).
+//!
+//! # How it works
+//!
+//! The integration test infrastructure uses `CONFIG.graph_cli` for deployment commands.
+//! By setting the `GRAPH_CLI` environment variable to point to the `gnd` binary,
+//! the tests use `gnd codegen`, `gnd create`, and `gnd deploy` instead of the
+//! corresponding `graph` commands.
+//!
+//! # Prerequisites
+//!
+//! - Build the gnd binary: `cargo build -p gnd`
+//! - Start integration test services: `nix run .#integration`
+//!   - PostgreSQL on localhost:3011
+//!   - IPFS on localhost:3001
+//!   - Anvil on localhost:3021
+//!
+//! # Running
+//!
+//! ```bash
+//! just test-gnd-cli
+//! ```
+
+use std::path::PathBuf;
+
+use anyhow::anyhow;
+use graph::futures03::StreamExt;
+use graph_tests::contract::Contract;
+use graph_tests::{CONFIG, error, status};
+
+mod integration_tests;
+
+use integration_tests::{
+    TestCase, TestResult, stop_graph_node, test_block_handlers, test_int8, test_value_roundtrip,
+};
+
+/// Get the path to the gnd binary
+fn gnd_binary_path() -> PathBuf {
+    // The gnd binary should be at target/debug/gnd relative to the workspace root
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    PathBuf::from(manifest_dir)
+        .parent()
+        .unwrap()
+        .join("target")
+        .join("debug")
+        .join("gnd")
+}
+
+/// Verify the gnd binary exists before running tests
+fn verify_gnd_binary() -> anyhow::Result<PathBuf> {
+    let gnd_path = gnd_binary_path();
+    if !gnd_path.exists() {
+        return Err(anyhow!(
+            "gnd binary not found at {}. Run `cargo build -p gnd` first.",
+            gnd_path.display()
+        ));
+    }
+    Ok(gnd_path)
+}
+
+/// The main test entrypoint for gnd CLI integration tests.
+///
+/// This test sets `GRAPH_CLI` to point to the gnd binary, then runs a subset
+/// of integration tests to verify gnd works as a drop-in replacement.
+#[graph::test]
+async fn gnd_cli_tests() -> anyhow::Result<()> {
+    // Verify gnd binary exists
+    let gnd_path = verify_gnd_binary()?;
+    status!("gnd-cli", "Using gnd binary at {}", gnd_path.display());
+
+    // Set GRAPH_CLI to point to gnd - this is already set via the environment
+    // when running `just test-gnd-cli`, but we verify it here
+    let graph_cli =
+        std::env::var("GRAPH_CLI").unwrap_or_else(|_| gnd_path.to_string_lossy().to_string());
+    status!("gnd-cli", "GRAPH_CLI={}", graph_cli);
+
+    // Verify the configured CLI is actually gnd
+    if !graph_cli.contains("gnd") {
+        return Err(anyhow!(
+            "GRAPH_CLI ({}) does not point to gnd binary. Set GRAPH_CLI=../target/debug/gnd",
+            graph_cli
+        ));
+    }
+
+    let test_name_to_run = std::env::var("TEST_CASE").ok();
+
+    // Run a subset of integration tests that exercise the core deployment workflow
+    // These tests cover:
+    // - codegen: Generate AssemblyScript types from schema and ABIs
+    // - create: Register subgraph name with Graph Node
+    // - deploy: Deploy subgraph to Graph Node
+    let cases = vec![
+        TestCase::new("block-handlers", test_block_handlers),
+        TestCase::new("value-roundtrip", test_value_roundtrip),
+        TestCase::new("int8", test_int8),
+    ];
+
+    // Filter the test cases if a specific test name is provided
+    let cases_to_run: Vec<_> = if let Some(test_name) = test_name_to_run {
+        cases
+            .into_iter()
+            .filter(|case| case.name == test_name)
+            .collect()
+    } else {
+        cases
+    };
+
+    if cases_to_run.is_empty() {
+        status!("gnd-cli", "No test cases to run");
+        return Ok(());
+    }
+
+    status!(
+        "gnd-cli",
+        "Running {} test case(s) with gnd as CLI",
+        cases_to_run.len()
+    );
+
+    let contracts = Contract::deploy_all().await?;
+
+    status!("setup", "Resetting database");
+    CONFIG.reset_database();
+
+    // Spawn graph-node
+    status!("graph-node", "Starting graph-node");
+    let mut graph_node_child_command = CONFIG.spawn_graph_node().await?;
+
+    let stream = tokio_stream::iter(cases_to_run)
+        .map(|case| case.run(&contracts))
+        .buffered(CONFIG.num_parallel_tests);
+
+    let mut results: Vec<TestResult> = stream.collect::<Vec<_>>().await;
+    results.sort_by_key(|result| result.name.clone());
+
+    // Stop graph-node and read its output
+    let graph_node_res = stop_graph_node(&mut graph_node_child_command).await;
+
+    status!(
+        "graph-node",
+        "graph-node logs are in {}",
+        CONFIG.graph_node.log_file.path.display()
+    );
+
+    match graph_node_res {
+        Ok(_) => {
+            status!("graph-node", "Stopped graph-node");
+        }
+        Err(e) => {
+            error!("graph-node", "Failed to stop graph-node: {}", e);
+        }
+    }
+
+    println!("\n\n{:=<60}", "");
+    println!("gnd CLI Test Results:");
+    println!("{:-<60}", "");
+    for result in &results {
+        result.print();
+    }
+    println!("\n");
+
+    if results.iter().any(|result| !result.success()) {
+        Err(anyhow!("Some gnd CLI tests failed"))
+    } else {
+        status!(
+            "gnd-cli",
+            "All tests passed - gnd works as drop-in replacement!"
+        );
+        Ok(())
+    }
+}
diff --git a/tests/tests/gnd_tests.rs b/tests/tests/gnd_tests.rs
new file mode 100644
index 00000000000..f1dbde81a53
--- /dev/null
+++ b/tests/tests/gnd_tests.rs
@@ -0,0 +1,145 @@
+use anyhow::anyhow;
+use graph::futures03::StreamExt;
+use graph_tests::config::set_dev_mode;
+use graph_tests::contract::Contract;
+use graph_tests::subgraph::Subgraph;
+use graph_tests::{CONFIG, error, status};
+
+mod integration_tests;
+
+use integration_tests::{
+    TestCase, TestResult, stop_graph_node, subgraph_data_sources, test_block_handlers,
+    test_multiple_subgraph_datasources,
+};
+
+/// The main test entrypoint.
+#[graph::test]
+async fn gnd_tests() -> anyhow::Result<()> {
+    set_dev_mode(true);
+
+    let test_name_to_run = std::env::var("TEST_CASE").ok();
+
+    let cases = vec![
+        TestCase::new("block-handlers", test_block_handlers),
+        TestCase::new_with_source_subgraphs(
+            "subgraph-data-sources",
+            subgraph_data_sources,
+            vec!["QmWi3H11QFE2PiWx6WcQkZYZdA5UasaBptUJqGn54MFux5:source-subgraph"],
+        ),
+        TestCase::new_with_source_subgraphs(
+            "multiple-subgraph-datasources",
+            test_multiple_subgraph_datasources,
+            vec![
+                "QmYHp1bPEf7EoYBpEtJUpZv1uQHYQfWE4AhvR6frjB1Huj:source-subgraph-a",
+                "QmYBEzastJi7bsa722ac78tnZa6xNnV9vvweerY4kVyJtq:source-subgraph-b",
+            ],
+        ),
+    ];
+
+    // Filter the test cases if a specific test name is provided
+    let cases_to_run: Vec<_> = if let Some(test_name) = test_name_to_run {
+        cases
+            .into_iter()
+            .filter(|case| case.name == test_name)
+            .collect()
+    } else {
+        cases
+    };
+
+    let contracts = Contract::deploy_all().await?;
+
+    status!("setup", "Resetting database");
+    CONFIG.reset_database();
+
+    for i in cases_to_run.iter() {
+        i.prepare(&contracts).await?;
+    }
+    status!("setup", "Prepared all cases");
+
+    let manifests = cases_to_run
+        .iter()
+        .map(|case| {
+            Subgraph::dir(&case.name)
+                .path
+                .join("subgraph.yaml")
+                .to_str()
+                .unwrap()
+                .to_string()
+        })
+        .collect::<Vec<_>>()
+        .join(",");
+
+    let aliases = cases_to_run
+        .iter()
+        .filter_map(|case| case.source_subgraph.as_ref())
+        .flatten()
+        .filter_map(|source_subgraph| {
+            source_subgraph.alias().map(|alias| {
+                let manifest_path = Subgraph::dir(source_subgraph.test_name())
+                    .path
+                    .join("subgraph.yaml")
+                    .to_str()
+                    .unwrap()
+                    .to_string();
+                format!("{}:{}", alias, manifest_path)
+            })
+        })
+        .collect::<Vec<_>>();
+
+    let aliases_str = aliases.join(",");
+    let args = if aliases.is_empty() {
+        vec!["--manifests", &manifests]
+    } else {
+        vec!["--manifests", &manifests, "--sources", &aliases_str]
+    };
+
+    // Spawn graph-node.
+    status!("graph-node", "Starting graph-node");
+
+    let mut graph_node_child_command = CONFIG.spawn_graph_node_with_args(&args).await?;
+
+    let num_sources = aliases.len();
+
+    let stream = tokio_stream::iter(cases_to_run)
+        .enumerate()
+        .map(|(index, case)| {
+            let subgraph_name = format!("subgraph-{}", num_sources + index);
+            case.check_health_and_test(subgraph_name)
+        })
+        .buffered(CONFIG.num_parallel_tests);
+
+    let mut results: Vec<TestResult> = stream.collect::<Vec<_>>().await;
+    results.sort_by_key(|result| result.name.clone());
+
+    // Stop graph-node and read its output.
+    let graph_node_res = stop_graph_node(&mut graph_node_child_command).await;
+
+    status!(
+        "graph-node",
+        "graph-node logs are in {}",
+        CONFIG.graph_node.log_file.path.display()
+    );
+
+    match graph_node_res {
+        Ok(_) => {
+            status!("graph-node", "Stopped graph-node");
+        }
+        Err(e) => {
+            error!("graph-node", "Failed to stop graph-node: {}", e);
+        }
+    }
+
+    println!("\n\n{:=<60}", "");
+    println!("Test results:");
+    println!("{:-<60}", "");
+    for result in &results {
+        result.print();
+    }
+    println!("\n");
+
+    if results.iter().any(|result| !result.success()) {
+        Err(anyhow!("Some tests failed"))
+    } else {
+        Ok(())
+    }
+}
diff --git a/tests/tests/integration_tests.rs b/tests/tests/integration_tests.rs
index fe742b11813..4f3457cda41 100644
--- a/tests/tests/integration_tests.rs
+++ b/tests/tests/integration_tests.rs
@@ -9,43 +9,57 @@
 //! tasks are really worth parallelizing, and applying this trick
 //! indiscriminately will only result in messy code and diminishing returns.
 
+use std::collections::HashMap;
 use std::future::Future;
 use std::pin::Pin;
 use std::time::{Duration, Instant};
 
-use anyhow::{anyhow, bail, Context};
-use futures::StreamExt;
-use graph::prelude::serde_json::{json, Value};
+use anyhow::{Context, Result, anyhow, bail};
+use graph::components::subgraph::{
+    ProofOfIndexing, ProofOfIndexingEvent, ProofOfIndexingFinisher, ProofOfIndexingVersion,
+};
+use graph::data::store::Id;
+use graph::entity;
+use graph::futures03::StreamExt;
+use graph::itertools::Itertools;
+use graph::prelude::serde_json::{Value, json};
+use graph::prelude::{BlockPtr, DeploymentHash, alloy::primitives::Address, hex};
+use graph::schema::InputSchema;
+use graph::slog::{Discard, Logger, o};
 use graph_tests::contract::Contract;
-use graph_tests::helpers::{run_checked, TestFile};
 use graph_tests::subgraph::Subgraph;
-use graph_tests::{error, status, CONFIG};
-use tokio::process::{Child, Command};
+use graph_tests::{CONFIG, error, status};
+use tokio::process::Child;
 use tokio::task::JoinError;
 use tokio::time::sleep;
 
+const SUBGRAPH_LAST_GRAFTING_BLOCK: i32 = 3;
+
 type TestFn = Box<
-    dyn FnOnce(Subgraph) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + Send>> + Sync + Send,
+    dyn FnOnce(TestContext) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + Send>>
+        + Sync
+        + Send,
 >;
 
-enum TestStatus {
+pub struct TestContext {
+    pub subgraph: Subgraph,
+}
+
+pub enum TestStatus {
     Ok,
     Err(anyhow::Error),
     Panic(JoinError),
 }
 
-struct TestResult {
-    name: String,
-    subgraph: Option<Subgraph>,
-    status: TestStatus,
+pub struct TestResult {
+    pub name: String,
+    pub subgraph: Option<Subgraph>,
+    pub status: TestStatus,
 }
 
 impl TestResult {
-    fn success(&self) -> bool {
-        match self.status {
-            TestStatus::Ok => true,
-            _ => false,
-        }
+    pub fn success(&self) -> bool {
+        matches!(self.status, TestStatus::Ok)
     }
 
     fn print_subgraph(&self) {
@@ -54,7 +68,7 @@ impl TestResult {
         }
     }
 
-    fn print(&self) {
+    pub fn print(&self) {
         // ANSI escape sequences; see the comment in macros.rs about better colorization
         const GREEN: &str = "\x1b[1;32m";
         const RED: &str = "\x1b[1;31m";
@@ -84,43 +98,148 @@ impl TestResult {
     }
 }
 
-struct TestCase {
-    name: String,
-    test: TestFn,
+#[derive(Debug, Clone)]
+pub enum SourceSubgraph {
+    Subgraph(String),
+    WithAlias((String, String)), // (alias, test_name)
+}
+
+impl SourceSubgraph {
+    fn new(s: &str) -> Self {
+        if let Some((alias, subgraph)) = s.split_once(':') {
+            Self::WithAlias((alias.to_string(), subgraph.to_string()))
+        } else {
+            Self::Subgraph(s.to_string())
+        }
+    }
+
+    pub fn test_name(&self) -> &str {
+        match self {
+            Self::Subgraph(name) => name,
+            Self::WithAlias((_, name)) => name,
+        }
+    }
+
+    #[allow(dead_code)] // Used by gnd_tests.rs
+    pub fn alias(&self) -> Option<&str> {
+        match self {
+            Self::Subgraph(_) => None,
+            Self::WithAlias((alias, _)) => Some(alias),
+        }
+    }
+}
+
+pub struct TestCase {
+    pub name: String,
+    pub test: TestFn,
+    pub source_subgraph: Option<Vec<SourceSubgraph>>,
 }
 
 impl TestCase {
-    fn new<T>(name: &str, test: fn(Subgraph) -> T) -> Self
+    pub fn new<T>(name: &str, test: fn(TestContext) -> T) -> Self
     where
         T: Future<Output = Result<(), anyhow::Error>> + Send + 'static,
     {
-        fn force_boxed<T>(f: fn(Subgraph) -> T) -> TestFn
-        where
-            T: Future<Output = Result<(), anyhow::Error>> + Send + 'static,
-        {
-            Box::new(move |sg| Box::pin(f(sg)))
-        }
-
         Self {
             name: name.to_string(),
-            test: force_boxed(test),
+            test: Box::new(move |ctx| Box::pin(test(ctx))),
+            source_subgraph: None,
         }
     }
 
-    async fn run(self, contracts: &[Contract]) -> TestResult {
+    fn new_with_grafting<T>(name: &str, test: fn(TestContext) -> T, base_subgraph: &str) -> Self
+    where
+        T: Future<Output = Result<(), anyhow::Error>> + Send + 'static,
+    {
+        let mut test_case = Self::new(name, test);
+        test_case.source_subgraph = Some(vec![SourceSubgraph::new(base_subgraph)]);
+        test_case
+    }
+
+    pub fn new_with_source_subgraphs<T>(
+        name: &str,
+        test: fn(TestContext) -> T,
+        source_subgraphs: Vec<&str>,
+    ) -> Self
+    where
+        T: Future<Output = Result<(), anyhow::Error>> + Send + 'static,
+    {
+        let mut test_case = Self::new(name, test);
+        test_case.source_subgraph = Some(
+            source_subgraphs
+                .into_iter()
+                .map(SourceSubgraph::new)
+                .collect(),
+        );
+        test_case
+    }
+
+    async fn deploy_and_wait(
+        &self,
+        subgraph_name: &str,
+        contracts: &[Contract],
+    ) -> Result<Subgraph> {
         status!(&self.name, "Deploying subgraph");
-        let subgraph_name = match Subgraph::deploy(&self.name, contracts).await {
+        let subgraph_name = match Subgraph::deploy(subgraph_name, contracts, None).await {
             Ok(name) => name,
             Err(e) => {
                 error!(&self.name, "Deploy failed");
-                return TestResult {
-                    name: self.name.clone(),
-                    subgraph: None,
-                    status: TestStatus::Err(e.context("Deploy failed")),
-                };
+                return Err(anyhow!(e.context("Deploy failed")));
             }
         };
+
         status!(&self.name, "Waiting for subgraph to become ready");
+        let subgraph = match Subgraph::wait_ready(&subgraph_name).await {
+            Ok(subgraph) => subgraph,
+            Err(e) => {
+                error!(&self.name, "Subgraph never synced or failed");
+                return Err(anyhow!(e.context("Subgraph never synced or failed")));
+            }
+        };
+
+        if subgraph.healthy {
+            status!(&self.name, "Subgraph ({}) is synced", subgraph.deployment);
+        } else {
+            status!(&self.name, "Subgraph ({}) has failed", subgraph.deployment);
+        }
+
+        Ok(subgraph)
+    }
+
+    #[allow(dead_code)] // Used by gnd_tests.rs
+    pub async fn prepare(&self, contracts: &[Contract]) -> anyhow::Result<String> {
+        // If a subgraph has subgraph datasources, prepare them first and collect their deployment hashes
+        let source_mappings = if let Some(_subgraphs) = &self.source_subgraph {
+            match self.prepare_multiple_sources(contracts).await {
+                Ok(mappings) => Some(mappings),
+                Err(e) => {
+                    error!(&self.name, "source subgraph deployment failed: {:?}", e);
+                    return Err(e);
+                }
+            }
+        } else {
+            None
+        };
+
+        status!(&self.name, "Preparing subgraph");
+        let (_, subgraph_name, _) =
+            match Subgraph::prepare(&self.name, contracts, source_mappings.as_deref()).await {
+                Ok(name) => name,
+                Err(e) => {
+                    error!(&self.name, "Prepare failed: {:?}", e);
+                    return Err(e);
+                }
+            };
+
+        Ok(subgraph_name)
+    }
+
+    pub async fn check_health_and_test(self, subgraph_name: String) -> TestResult {
+        status!(
+            &self.name,
+            "Waiting for subgraph ({}) to become ready",
+            subgraph_name
+        );
         let subgraph = match Subgraph::wait_ready(&subgraph_name).await {
             Ok(subgraph) => subgraph,
             Err(e) => {
@@ -132,15 +251,20 @@ impl TestCase {
                 };
             }
         };
+
         if subgraph.healthy {
             status!(&self.name, "Subgraph ({}) is synced", subgraph.deployment);
         } else {
             status!(&self.name, "Subgraph ({}) has failed", subgraph.deployment);
         }
 
+        let ctx = TestContext {
+            subgraph: subgraph.clone(),
+        };
+
         status!(&self.name, "Starting test");
         let subgraph2 = subgraph.clone();
-        let res = tokio::spawn(async move { (self.test)(subgraph).await }).await;
+        let res = tokio::spawn(async move { (self.test)(ctx).await }).await;
         let status = match res {
             Ok(Ok(())) => {
                 status!(&self.name, "Test succeeded");
@@ -161,23 +285,78 @@ impl TestCase {
             status,
         }
     }
-}
 
-#[derive(Debug)]
-struct Output {
-    stdout: Option<String>,
-    stderr: Option<String>,
-}
+    pub async fn run(self, contracts: &[Contract]) -> TestResult {
+        // If a subgraph has subgraph datasources, deploy them first and collect their deployment hashes
+        let source_mappings = if let Some(_subgraphs) = &self.source_subgraph {
+            match self.deploy_multiple_sources(contracts).await {
+                Ok(mappings) => Some(mappings),
+                Err(e) => {
+                    error!(&self.name, "source subgraph deployment failed");
+                    return TestResult {
+                        name: self.name.clone(),
+                        subgraph: None,
+                        status: TestStatus::Err(e),
+                    };
+                }
+            }
+        } else {
+            None
+        };
+
+        status!(&self.name, "Deploying subgraph");
+        let subgraph_name =
+            match Subgraph::deploy(&self.name, contracts, source_mappings.as_deref()).await {
+                Ok(name) => name,
+                Err(e) => {
+                    error!(&self.name, "Deploy failed");
+                    return TestResult {
+                        name: self.name.clone(),
+                        subgraph: None,
+                        status: TestStatus::Err(e.context("Deploy failed")),
+                    };
+                }
+            };
 
-impl std::fmt::Display for Output {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if let Some(ref stdout) = self.stdout {
-            write!(f, "{}", stdout)?;
+        self.check_health_and_test(subgraph_name).await
+    }
+
+    async fn prepare_multiple_sources(
+        &self,
+        contracts: &[Contract],
+    ) -> Result<Vec<(String, String)>> {
+        let mut mappings = Vec::new();
+        if let Some(sources) = &self.source_subgraph {
+            for source in sources {
+                // Source subgraphs don't have their own sources, so pass None
+                let _ = Subgraph::prepare(source.test_name(), contracts, None).await?;
+                // If the source has an alias (pre-known IPFS hash), use it for the mapping
+                if let Some(alias) = source.alias() {
+                    mappings.push((source.test_name().to_string(), alias.to_string()));
+                }
+            }
         }
-        if let Some(ref stderr) = self.stderr {
-            write!(f, "{}", stderr)?
+        Ok(mappings)
+    }
+
+    async fn deploy_multiple_sources(
+        &self,
+        contracts: &[Contract],
+    ) -> Result<Vec<(String, String)>> {
+        let mut mappings = Vec::new();
+        if let Some(sources) = &self.source_subgraph {
+            for source in sources {
+                let subgraph = self.deploy_and_wait(source.test_name(), contracts).await?;
+                status!(
+                    source.test_name(),
+                    "Source subgraph deployed with hash {}",
+                    subgraph.deployment
+                );
+                // Use the test_name as the placeholder key
+                mappings.push((source.test_name().to_string(), subgraph.deployment.clone()));
+            }
         }
-        Ok(())
+        Ok(mappings)
     }
 }
 
@@ -221,7 +400,8 @@ pub async fn query_succeeds(
 * the `cases` variable in `integration_tests`.
 */
 
-async fn test_int8(subgraph: Subgraph) -> anyhow::Result<()> {
+pub async fn test_int8(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
     assert!(subgraph.healthy);
 
     let resp = subgraph
@@ -248,7 +428,41 @@ async fn test_int8(subgraph: Subgraph) -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn test_block_handlers(subgraph: Subgraph) -> anyhow::Result<()> {
+/*
+* Actual tests. For a new test, add a new function here and add an entry to
+* the `cases` variable in `integration_tests`.
+*/
+
+pub async fn test_timestamp(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+
+    let resp = subgraph
+        .query(
+            "{
+        foos_0: foos(orderBy: id, block: { number: 0 }) { id }
+        foos(orderBy: id) { id value }
+      }",
+        )
+        .await?;
+
+    let exp = json!({
+        "foos_0": [],
+        "foos": [
+          {
+            "id": "0",
+            "value": "1710837304040956",
+          },
+        ],
+    });
+    assert_eq!(None, resp.get("errors"));
+    assert_eq!(exp, resp["data"]);
+
+    Ok(())
+}
+
+pub async fn test_block_handlers(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
     assert!(subgraph.healthy);
 
     // test non-filtered blockHandler
@@ -347,9 +561,8 @@ async fn test_block_handlers(subgraph: Subgraph) -> anyhow::Result<()> {
     .await?;
 
     // test subgraphFeatures endpoint returns handlers correctly
-    let subgraph_features = subgraph
-        .index_with_vars(
-            "query GetSubgraphFeatures($deployment: String!) {
+    let subgraph_features = Subgraph::query_with_vars(
+        "query GetSubgraphFeatures($deployment: String!) {
           subgraphFeatures(subgraphId: $deployment) {
             specVersion
             apiVersion
@@ -359,9 +572,9 @@ async fn test_block_handlers(subgraph: Subgraph) -> anyhow::Result<()> {
             handlers
           }
         }",
-            json!({ "deployment": subgraph.deployment }),
-        )
-        .await?;
+        json!({ "deployment": subgraph.deployment }),
+    )
+    .await?;
     let handlers = &subgraph_features["data"]["subgraphFeatures"]["handlers"];
     assert!(
         handlers.is_array(),
@@ -385,7 +598,105 @@ async fn test_block_handlers(subgraph: Subgraph) -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn test_ganache_reverts(subgraph: Subgraph) -> anyhow::Result<()> {
+async fn test_eth_api(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+
+    let expected_response = json!({
+        "foo": {
+            "id": "1",
+            "balance": "10000000000000000000000",
+            "hasCode1": false,
+            "hasCode2": true,
+        }
+    });
+
+    query_succeeds(
+        "Balance should be right",
+        &subgraph,
+        "{ foo(id: \"1\") { id balance hasCode1 hasCode2 } }",
+        expected_response,
+    )
+    .await?;
+
+    Ok(())
+}
+
+pub async fn subgraph_data_sources(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+    let expected_response = json!({
+        "mirrorBlocks": [
+            { "id": "1-v1", "number": "1", "testMessage": null },
+            { "id": "1-v2", "number": "1", "testMessage": null },
+            { "id": "1-v3", "number": "1", "testMessage": "1-message" },
+            { "id": "2-v1", "number": "2", "testMessage": null },
+            { "id": "2-v2", "number": "2", "testMessage": null },
+            { "id": "2-v3", "number": "2", "testMessage": "2-message" },
+            { "id": "3-v1", "number": "3", "testMessage": null },
+            { "id": "3-v2", "number": "3", "testMessage": null },
+            { "id": "3-v3", "number": "3", "testMessage": "3-message" },
+        ]
+    });
+
+    query_succeeds(
+        "Query all blocks with testMessage",
+        &subgraph,
+        "{ mirrorBlocks(where: {number_lte: 3}, orderBy: number) { id, number, testMessage } }",
+        expected_response,
+    )
+    .await?;
+
+    let expected_response = json!({
+        "mirrorBlock": { "id": "1-v3", "number": "1", "testMessage": "1-message" },
+    });
+
+    query_succeeds(
+        "Query specific block with testMessage",
+        &subgraph,
+        "{ mirrorBlock(id: \"1-v3\") { id, number, testMessage } }",
+        expected_response,
+    )
+    .await?;
+
+    Ok(())
+}
+
+async fn test_topic_filters(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+
+    // Events we need are already emitted from Contract::deploy_all
+
+    let exp = json!({
+        "anotherTriggerEntities": [
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "data": "abc",
+            },
+            {
+                "a": "1",
+                "b": "1",
+                "c": "1",
+                "data": "abc",
+            },
+        ],
+    });
+    query_succeeds(
+        "all overloads of the contract function are called",
+        &subgraph,
+        "{ anotherTriggerEntities(orderBy: id) {  a b c data } }",
+        exp,
+    )
+    .await?;
+
+    Ok(())
+}
+
+async fn test_reverted_calls_are_indexed(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
     assert!(subgraph.healthy);
 
     let exp = json!({
@@ -413,12 +724,14 @@ async fn test_ganache_reverts(subgraph: Subgraph) -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn test_host_exports(subgraph: Subgraph) -> anyhow::Result<()> {
+async fn test_host_exports(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
     assert!(subgraph.healthy);
     Ok(())
 }
 
-async fn test_non_fatal_errors(subgraph: Subgraph) -> anyhow::Result<()> {
+async fn test_non_fatal_errors(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
     assert!(!subgraph.healthy);
 
     let query = "query GetSubgraphFeatures($deployment: String!) {
@@ -432,9 +745,8 @@ async fn test_non_fatal_errors(subgraph: Subgraph) -> anyhow::Result<()> {
         }
       }";
 
-    let resp = subgraph
-        .index_with_vars(query, json!({ "deployment" : subgraph.deployment }))
-        .await?;
+    let resp =
+        Subgraph::query_with_vars(query, json!({ "deployment" : subgraph.deployment })).await?;
     let subgraph_features = &resp["data"]["subgraphFeatures"];
     let exp = json!({
       "specVersion": "0.0.4",
@@ -462,7 +774,8 @@ async fn test_non_fatal_errors(subgraph: Subgraph) -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn test_overloaded_functions(subgraph: Subgraph) -> anyhow::Result<()> {
+async fn test_overloaded_functions(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
     // all overloads of the contract function are called
     assert!(subgraph.healthy);
 
@@ -492,7 +805,8 @@ async fn test_overloaded_functions(subgraph: Subgraph) -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn test_value_roundtrip(subgraph: Subgraph) -> anyhow::Result<()> {
+pub async fn test_value_roundtrip(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
     assert!(subgraph.healthy);
 
     let exp = json!({
@@ -510,7 +824,8 @@ async fn test_value_roundtrip(subgraph: Subgraph) -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn test_remove_then_update(subgraph: Subgraph) -> anyhow::Result<()> {
+async fn test_remove_then_update(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
     assert!(subgraph.healthy);
 
     let exp = json!({
@@ -528,7 +843,217 @@ async fn test_remove_then_update(subgraph: Subgraph) -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn test_poi_for_failed_subgraph(subgraph: Subgraph) -> anyhow::Result<()> {
+async fn test_subgraph_grafting(ctx: TestContext) -> anyhow::Result<()> {
+    async fn get_block_hash(block_number: i32) -> Option<String> {
+        const FETCH_BLOCK_HASH: &str = r#"
+        query blockHashFromNumber($network: String!, $blockNumber: Int!) {
+            hash: blockHashFromNumber(
+              network: $network,
+              blockNumber: $blockNumber,
+            ) } "#;
+        let vars = json!({
+            "network": "test",
+            "blockNumber": block_number
+        });
+
+        let resp = Subgraph::query_with_vars(FETCH_BLOCK_HASH, vars)
+            .await
+            .unwrap();
+        assert_eq!(None, resp.get("errors"));
+        resp["data"]["hash"].as_str().map(|s| s.to_owned())
+    }
+
+    let subgraph = ctx.subgraph;
+
+    assert!(subgraph.healthy);
+
+    // Fetch block hashes from the chain
+    let mut block_hashes: Vec<String> = Vec::new();
+    for i in 1..4 {
+        let hash = get_block_hash(i)
+            .await
+            .ok_or_else(|| anyhow!("Failed to get block hash for block {}", i))?;
+        block_hashes.push(hash);
+    }
+
+    // The deployment hash is dynamic (depends on the base subgraph's hash)
+    let deployment_hash = DeploymentHash::new(&subgraph.deployment).unwrap();
+
+    // Compute the expected POIs using the actual block hashes
+    let expected_pois = compute_expected_pois(&deployment_hash, &block_hashes);
+
+    for i in 1..4 {
+        let block_hash = &block_hashes[(i - 1) as usize];
+
+        const FETCH_POI: &str = r#"
+        query proofOfIndexing($subgraph: String!, $blockNumber: Int!, $blockHash: String!, $indexer: String!) {
+            proofOfIndexing(
+              subgraph: $subgraph,
+              blockNumber: $blockNumber,
+              blockHash: $blockHash,
+              indexer: $indexer
+            ) } "#;
+
+        let zero_addr = "0000000000000000000000000000000000000000";
+        let vars = json!({
+            "subgraph": subgraph.deployment,
+            "blockNumber": i,
+            "blockHash": block_hash,
+            "indexer": zero_addr,
+        });
+        let resp = Subgraph::query_with_vars(FETCH_POI, vars).await?;
+        assert_eq!(None, resp.get("errors"));
+        assert!(resp["data"]["proofOfIndexing"].is_string());
+        let poi = resp["data"]["proofOfIndexing"].as_str().unwrap();
+        // Check the expected value of the POI. The transition from the old legacy
+        // hashing to the new one is done in the block #2 anything before that
+        // should not change as the legacy code will not be updated. Any change
+        // after that might indicate a change in the way new POI is now calculated.
+        // Change on the block #2 would mean a change in the transitioning
+        // from the old to the new algorithm hence would be reflected only
+        // subgraphs that are grafting from pre 0.0.5 to 0.0.6 or newer.
+        assert_eq!(
+            poi,
+            expected_pois[(i - 1) as usize],
+            "POI mismatch for block {}",
+            i
+        );
+    }
+
+    Ok(())
+}
+
+/// Compute the expected POI values for the grafted subgraph.
+///
+/// The grafted subgraph:
+/// - Spec version 0.0.6 (uses Fast POI algorithm)
+/// - Grafts from base subgraph at block 2
+/// - Creates GraftedData entities starting from block 3
+///
+/// The base subgraph:
+/// - Spec version 0.0.5 (uses Legacy POI algorithm)
+/// - Creates BaseData entities for each block
+///
+/// POI algorithm transition:
+/// - Blocks 0-2: Legacy POI digests (from base subgraph)
+/// - Block 3+: Fast POI algorithm with transition from Legacy
+fn compute_expected_pois(deployment_hash: &DeploymentHash, block_hashes: &[String]) -> Vec<String> {
+    let logger = Logger::root(Discard, o!());
+    let causality_region = "ethereum/test";
+
+    // Create schemas for the entity types
+    let base_schema = InputSchema::parse_latest(
+        "type BaseData @entity(immutable: true) { id: ID!, data: String!, blockNumber: BigInt! }",
+        deployment_hash.clone(),
+    )
+    .unwrap();
+
+    let grafted_schema = InputSchema::parse_latest(
+        "type GraftedData @entity(immutable: true) { id: ID!, data: String!, blockNumber: BigInt! }",
+        deployment_hash.clone(),
+    )
+    .unwrap();
+
+    // Compute POI digests at each block checkpoint
+    // Store the accumulated state after each block so we can compute POI at any block
+    let mut db_at_block: HashMap<i32, HashMap<Id, Vec<u8>>> = HashMap::new();
+    let mut db: HashMap<Id, Vec<u8>> = HashMap::new();
+
+    // Process blocks 0-3:
+    // - Blocks 0-2: Legacy POI (from base subgraph, creates BaseData entities)
+    // - Block 3: Fast POI (grafted subgraph starts here, creates GraftedData entity)
+    //
+    // The base subgraph starts from block 0 (genesis block triggers handlers in Anvil).
+    //
+    // The grafted subgraph:
+    // - spec version 0.0.6 → uses Fast POI algorithm
+    // - grafts from base subgraph at block 2
+    // - inherits POI digests from base for blocks 0-2
+    // - transitions from Legacy to Fast at block 3
+    for block_i in 0..=3i32 {
+        let version = if block_i <= 2 {
+            ProofOfIndexingVersion::Legacy
+        } else {
+            ProofOfIndexingVersion::Fast
+        };
+
+        let mut stream = ProofOfIndexing::new(block_i, version);
+
+        if block_i <= 2 {
+            // Base subgraph creates BaseData
+            let id_str = block_i.to_string();
+            let entity = entity! {
+                base_schema =>
+                    id: &id_str,
+                    data: "from base",
+                    blockNumber: graph::prelude::Value::BigInt(block_i.into()),
+            };
+
+            let event = ProofOfIndexingEvent::SetEntity {
+                entity_type: "BaseData",
+                id: &id_str,
+                data: &entity,
+            };
+            stream.write(&logger, causality_region, &event);
+        } else {
+            // Grafted subgraph creates GraftedData
+            let id_str = block_i.to_string();
+            let entity = entity! {
+                grafted_schema =>
+                    id: &id_str,
+                    data: "to grafted",
+                    blockNumber: graph::prelude::Value::BigInt(block_i.into()),
+            };
+
+            let event = ProofOfIndexingEvent::SetEntity {
+                entity_type: "GraftedData",
+                id: &id_str,
+                data: &entity,
+            };
+            stream.write(&logger, causality_region, &event);
+        }
+
+        for (name, region) in stream.take() {
+            let prev = db.get(&name);
+            let update = region.pause(prev.map(|v| &v[..]));
+            db.insert(name, update);
+        }
+
+        db_at_block.insert(block_i, db.clone());
+    }
+
+    // Compute POI for blocks 1, 2, 3
+    let mut pois = Vec::new();
+    for (block_idx, block_hash_hex) in block_hashes.iter().enumerate() {
+        let block_number = (block_idx + 1) as i32;
+
+        // Get the POI version for this block - grafted subgraph uses Fast (spec 0.0.6)
+        let version = ProofOfIndexingVersion::Fast;
+
+        let block_hash_bytes = hex::decode(block_hash_hex).unwrap();
+        let block_ptr = BlockPtr::from((block_hash_bytes, block_number as u64));
+
+        // Use zero address to match the test query's indexer parameter
+        let indexer = Some(Address::ZERO);
+        let mut finisher =
+            ProofOfIndexingFinisher::new(&block_ptr, deployment_hash, &indexer, version);
+
+        if let Some(db_state) = db_at_block.get(&block_number) {
+            for (name, region) in db_state.iter() {
+                finisher.add_causality_region(name, region);
+            }
+        }
+
+        let poi_bytes = finisher.finish();
+        let poi = format!("0x{}", hex::encode(poi_bytes));
+        pois.push(poi);
+    }
+
+    pois
+}
+
+async fn test_poi_for_failed_subgraph(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
     const INDEXING_STATUS: &str = r#"
     query statuses($subgraphName: String!) {
         statuses: indexingStatusesForSubgraphName(subgraphName: $subgraphName) {
@@ -560,9 +1085,9 @@ async fn test_poi_for_failed_subgraph(subgraph: Subgraph) -> anyhow::Result<()>
     }
 
     async fn fetch_status(subgraph: &Subgraph) -> anyhow::Result<Status> {
-        let resp = subgraph
-            .index_with_vars(INDEXING_STATUS, json!({ "subgraphName": subgraph.name }))
-            .await?;
+        let resp =
+            Subgraph::query_with_vars(INDEXING_STATUS, json!({ "subgraphName": subgraph.name }))
+                .await?;
         assert_eq!(None, resp.get("errors"));
         let statuses = &resp["data"]["statuses"];
         assert_eq!(1, statuses.as_array().unwrap().len());
@@ -608,9 +1133,74 @@ async fn test_poi_for_failed_subgraph(subgraph: Subgraph) -> anyhow::Result<()>
         "blockNumber": block_number,
         "blockHash": status.latest_block["hash"],
     });
-    let resp = subgraph.index_with_vars(FETCH_POI, vars).await?;
+    let resp = Subgraph::query_with_vars(FETCH_POI, vars).await?;
     assert_eq!(None, resp.get("errors"));
     assert!(resp["data"]["proofOfIndexing"].is_string());
+
+    // Test that _logs query works on failed subgraphs (critical for debugging!)
+    // Wait a moment for logs to be written
+    sleep(Duration::from_secs(2)).await;
+
+    let query = r#"{
+            _logs(first: 100) {
+                id
+                timestamp
+                level
+                text
+            }
+        }"#
+    .to_string();
+
+    let resp = subgraph.query(&query).await?;
+
+    // Should not have GraphQL errors when querying logs on failed subgraph
+    assert!(
+        resp.get("errors").is_none(),
+        "Expected no errors when querying _logs on failed subgraph, got: {:?}",
+        resp.get("errors")
+    );
+
+    let logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // The critical assertion: _logs query works on failed subgraphs
+    // This enables debugging even when the subgraph has crashed
+    println!(
+        "Successfully queried _logs on failed subgraph, found {} log entries",
+        logs.len()
+    );
+
+    // Print a sample of logs to see what's available (for documentation/debugging)
+    if !logs.is_empty() {
+        println!("Sample logs from failed subgraph:");
+        for (i, log) in logs.iter().take(5).enumerate() {
+            println!(
+                "  Log {}: level={:?}, text={:?}",
+                i + 1,
+                log["level"].as_str(),
+                log["text"].as_str()
+            );
+        }
+    }
+
+    // Verify we can also filter by level on failed subgraphs
+    let query = r#"{
+            _logs(level: ERROR, first: 100) {
+                level
+                text
+            }
+        }"#
+    .to_string();
+
+    let resp = subgraph.query(&query).await?;
+    assert!(
+        resp.get("errors").is_none(),
+        "Expected no errors when filtering _logs by level on failed subgraph"
+    );
+
+    println!("✓ _logs query works on failed subgraphs - critical for debugging!");
+
     Ok(())
 }
 
@@ -619,13 +1209,549 @@ async fn test_missing(_sg: Subgraph) -> anyhow::Result<()> {
     Err(anyhow!("This test is missing"))
 }
 
+pub async fn test_multiple_subgraph_datasources(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+
+    // Test querying data aggregated from multiple sources
+    let exp = json!({
+        "aggregatedDatas": [
+            {
+                "id": "0",
+                "sourceA": "from source A",
+                "sourceB": "from source B",
+                "first": "sourceA"
+            },
+        ]
+    });
+
+    query_succeeds(
+        "should aggregate data from multiple sources",
+        &subgraph,
+        "{ aggregatedDatas(first: 1) { id sourceA sourceB first } }",
+        exp,
+    )
+    .await?;
+
+    Ok(())
+}
+
+/// Test the declared calls functionality as of spec version 1.2.0.
+/// Note that we don't have a way to test that the actual call is made as
+/// a declared call since graph-node does not expose that information
+/// to mappings. This test assures though that the declared call machinery
+/// does not have any errors.
+async fn test_declared_calls_basic(ctx: TestContext) -> anyhow::Result<()> {
+    #[track_caller]
+    fn assert_call_result(call_results: &[Value], label: &str, exp_success: bool, exp_value: &str) {
+        let Some(call_result) = call_results.iter().find(|c| c["label"] == json!(label)) else {
+            panic!(
+                "Expected call result with label '{}', but none found",
+                label
+            );
+        };
+        let Some(act_success) = call_result["success"].as_bool() else {
+            panic!(
+                "Expected call result with label '{}' to have a boolean 'success' field, but got: {:?}",
+                label, call_result["success"]
+            );
+        };
+
+        if exp_success {
+            assert!(
+                act_success,
+                "Expected call result with label '{}' to be successful",
+                label
+            );
+            let Some(act_value) = call_result["value"].as_str() else {
+                panic!(
+                    "Expected call result with label '{}' to have a string 'value' field, but got: {:?}",
+                    label, call_result["value"]
+                );
+            };
+            assert_eq!(
+                exp_value, act_value,
+                "Expected call result with label '{}' to have value '{}', but got '{}'",
+                label, exp_value, act_value
+            );
+        } else {
+            assert!(
+                !act_success,
+                "Expected call result with label '{}' to have failed",
+                label
+            );
+        }
+    }
+
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+
+    // Query the results
+    const QUERY: &str = "{
+        transferCalls(first: 1, orderBy: blockNumber) {
+            id
+            from
+            to
+            value
+            balanceFromBefore
+            balanceToBefore
+            totalSupply
+            constantValue
+            sumResult
+            metadataFrom
+            revertCallSucceeded
+        }
+        callResults(orderBy: label) {
+            label
+            success
+            value
+            error
+        }
+    }";
+
+    let Some((transfer_calls, call_results)) = subgraph
+        .polling_query(QUERY, &["transferCalls", "callResults"])
+        .await?
+        .into_iter()
+        .collect_tuple()
+    else {
+        panic!("Expected exactly two arrays from polling_query")
+    };
+
+    // Validate basic functionality
+    assert!(
+        !transfer_calls.is_empty(),
+        "Should have at least one transfer call"
+    );
+    assert!(!call_results.is_empty(), "Should have call results");
+
+    let transfer_call = &transfer_calls[0];
+
+    // Validate declared calls worked
+    assert_eq!(
+        transfer_call["constantValue"],
+        json!("42"),
+        "Constant value should be 42"
+    );
+    assert_eq!(
+        transfer_call["sumResult"],
+        json!("200"),
+        "Sum result should be 200 (100 + 100)"
+    );
+    assert_eq!(
+        transfer_call["revertCallSucceeded"],
+        json!(false),
+        "Revert call should have failed"
+    );
+    assert_eq!(
+        transfer_call["totalSupply"],
+        json!("3000"),
+        "Total supply should be 3000"
+    );
+
+    assert_call_result(&call_results, "balance_from", true, "900");
+    assert_call_result(&call_results, "balance_to", true, "1100");
+    assert_call_result(&call_results, "constant_value", true, "42");
+    assert_call_result(&call_results, "metadata_from", true, "Test Asset 1");
+    assert_call_result(&call_results, "sum_values", true, "200");
+    assert_call_result(&call_results, "total_supply", true, "3000");
+    assert_call_result(&call_results, "will_revert", false, "*ignored*");
+
+    Ok(())
+}
+
+async fn test_declared_calls_struct_fields(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+
+    // Wait a moment for indexing
+    sleep(Duration::from_secs(2)).await;
+
+    // Query the results
+    const QUERY: &str = "{
+        assetTransferCalls(first: 1, orderBy: blockNumber) {
+            id
+            assetAddr
+            assetAmount
+            assetActive
+            owner
+            metadata
+            amountCalc
+        }
+        complexAssetCalls(first: 1, orderBy: blockNumber) {
+            id
+            baseAssetAddr
+            baseAssetAmount
+            baseAssetOwner
+            baseAssetMetadata
+            baseAssetAmountCalc
+        }
+        structFieldTests(orderBy: testType) {
+            testType
+            fieldName
+            success
+            result
+            error
+        }
+    }";
+
+    let Some((asset_transfers, complex_assets, struct_tests)) = subgraph
+        .polling_query(
+            QUERY,
+            &[
+                "assetTransferCalls",
+                "complexAssetCalls",
+                "structFieldTests",
+            ],
+        )
+        .await?
+        .into_iter()
+        .collect_tuple()
+    else {
+        panic!("Expected exactly three arrays from polling_query")
+    };
+
+    // Validate struct field access
+    assert!(
+        !asset_transfers.is_empty(),
+        "Should have asset transfer calls"
+    );
+    assert!(
+        !complex_assets.is_empty(),
+        "Should have complex asset calls"
+    );
+    assert!(!struct_tests.is_empty(), "Should have struct field tests");
+
+    let asset_transfer = &asset_transfers[0];
+
+    // Validate struct field values
+    assert_eq!(
+        asset_transfer["assetAddr"],
+        json!("0x1111111111111111111111111111111111111111")
+    );
+    assert_eq!(asset_transfer["assetAmount"], json!("150"));
+    assert_eq!(asset_transfer["assetActive"], json!(true));
+    assert_eq!(asset_transfer["amountCalc"], json!("300")); // 150 + 150
+
+    // Validate complex asset (nested struct access)
+    let complex_asset = &complex_assets[0];
+    assert_eq!(
+        complex_asset["baseAssetAddr"],
+        json!("0x4444444444444444444444444444444444444444")
+    );
+    assert_eq!(complex_asset["baseAssetAmount"], json!("250"));
+    assert_eq!(complex_asset["baseAssetAmountCalc"], json!("349")); // 250 + 99
+
+    // Validate that struct field tests include both successful calls
+    let successful_tests: Vec<_> = struct_tests
+        .iter()
+        .filter(|t| t["success"] == json!(true))
+        .collect();
+    assert!(
+        !successful_tests.is_empty(),
+        "Should have successful struct field tests"
+    );
+
+    Ok(())
+}
+
+async fn test_logs_query(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+
+    // Wait a moment for logs to be written
+    sleep(Duration::from_secs(2)).await;
+
+    // Test 1: Query all logs
+    let query = r#"{
+            _logs(first: 100) {
+                id
+                timestamp
+                level
+                text
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+
+    let logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // We should have logs from the subgraph (user logs + system logs)
+    assert!(
+        !logs.is_empty(),
+        "Expected to have logs, got none. Response: {:?}",
+        resp
+    );
+
+    // Test 2: Filter by ERROR level
+    let query = r#"{
+            _logs(level: ERROR, first: 100) {
+                level
+                text
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+    let error_logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // Check that we have error logs and they're all ERROR level
+    for log in error_logs {
+        assert_eq!(
+            log["level"].as_str(),
+            Some("ERROR"),
+            "Expected ERROR level, got: {:?}",
+            log
+        );
+    }
+
+    // Test 3: Search for specific text
+    let query = r#"{
+            _logs(search: "timeout", first: 100) {
+                id
+                text
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+    let timeout_logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // If we have timeout logs, verify they contain the word "timeout"
+    for log in timeout_logs {
+        let text = log["text"]
+            .as_str()
+            .context("Expected text field to be a string")?;
+        assert!(
+            text.to_lowercase().contains("timeout"),
+            "Expected log to contain 'timeout', got: {}",
+            text
+        );
+    }
+
+    // Test 4: Pagination
+    let query = r#"{
+            _logs(first: 2, skip: 0) {
+                id
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+    let first_page = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    let query = r#"{
+            _logs(first: 2, skip: 2) {
+                id
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+    let second_page = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // If we have enough logs, verify pages are different
+    if first_page.len() == 2 && !second_page.is_empty() {
+        let first_ids: Vec<_> = first_page.iter().map(|l| &l["id"]).collect();
+        let second_ids: Vec<_> = second_page.iter().map(|l| &l["id"]).collect();
+
+        // Verify no overlap between pages
+        for id in &second_ids {
+            assert!(
+                !first_ids.contains(id),
+                "Log ID {:?} appears in both pages",
+                id
+            );
+        }
+    }
+
+    // Test 5: Query with arguments field to verify structured logging
+    let query = r#"{
+            _logs(first: 10) {
+                text
+                arguments {
+                    key
+                    value
+                }
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+    let logs_with_args = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // Verify arguments field is present (even if empty for some logs)
+    for log in logs_with_args {
+        assert!(
+            log.get("arguments").is_some(),
+            "Expected arguments field to exist in log: {:?}",
+            log
+        );
+    }
+
+    // Test 6: Verify that combining _logs with regular entity queries returns a validation error
+    let query = r#"{
+            _logs(first: 10) {
+                id
+                text
+            }
+            triggers {
+                id
+                x
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+
+    // Should have errors, not data
+    assert!(
+        resp.get("errors").is_some(),
+        "Expected errors when combining _logs with entity queries, got: {:?}",
+        resp
+    );
+
+    // Verify the error message mentions the validation issue
+    let errors = resp["errors"]
+        .as_array()
+        .context("Expected errors to be an array")?;
+    assert!(
+        !errors.is_empty(),
+        "Expected at least one error in response"
+    );
+
+    let error_msg = errors[0]["message"]
+        .as_str()
+        .context("Expected error message to be a string")?;
+    assert!(
+        error_msg.contains("_logs") && error_msg.contains("cannot be combined"),
+        "Expected validation error about _logs combination, got: {}",
+        error_msg
+    );
+
+    // Test 7: Field selection - verify only requested fields are returned
+    let query = r#"{
+            _logs(first: 1) {
+                id
+                timestamp
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+
+    let logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    if !logs.is_empty() {
+        let log = &logs[0];
+
+        // Verify requested fields are present
+        assert!(log.get("id").is_some(), "Expected id field to be present");
+        assert!(
+            log.get("timestamp").is_some(),
+            "Expected timestamp field to be present"
+        );
+
+        // Verify non-requested fields are NOT present
+        assert!(
+            log.get("text").is_none(),
+            "Expected text field to NOT be present (field selection bug)"
+        );
+        assert!(
+            log.get("level").is_none(),
+            "Expected level field to NOT be present (field selection bug)"
+        );
+        assert!(
+            log.get("subgraphId").is_none(),
+            "Expected subgraphId field to NOT be present (field selection bug)"
+        );
+        assert!(
+            log.get("arguments").is_none(),
+            "Expected arguments field to NOT be present (field selection bug)"
+        );
+        assert!(
+            log.get("meta").is_none(),
+            "Expected meta field to NOT be present (field selection bug)"
+        );
+
+        println!("✓ Field selection works correctly - only requested fields returned");
+    }
+
+    // Test 8: Order direction - ascending
+    let query = r#"{
+            _logs(first: 10, orderDirection: asc) {
+                id
+                timestamp
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+
+    let logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // Verify ascending order (each timestamp >= previous)
+    if logs.len() > 1 {
+        for i in 1..logs.len() {
+            let prev_ts = logs[i - 1]["timestamp"].as_str().unwrap();
+            let curr_ts = logs[i]["timestamp"].as_str().unwrap();
+            assert!(
+                curr_ts >= prev_ts,
+                "Expected ascending order, but {} came before {}",
+                prev_ts,
+                curr_ts
+            );
+        }
+        println!("✓ Ascending order works correctly");
+    }
+
+    // Test 9: Order direction - descending (explicit)
+    let query = r#"{
+            _logs(first: 10, orderDirection: desc) {
+                id
+                timestamp
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+
+    let logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // Verify descending order (each timestamp <= previous)
+    if logs.len() > 1 {
+        for i in 1..logs.len() {
+            let prev_ts = logs[i - 1]["timestamp"].as_str().unwrap();
+            let curr_ts = logs[i]["timestamp"].as_str().unwrap();
+            assert!(
+                curr_ts <= prev_ts,
+                "Expected descending order, but {} came before {}",
+                prev_ts,
+                curr_ts
+            );
+        }
+        println!("✓ Descending order works correctly");
+    }
+
+    Ok(())
+}
+
 /// The main test entrypoint.
-#[tokio::test]
+#[graph::test]
 async fn integration_tests() -> anyhow::Result<()> {
-    // Test "api-version-v0-0-4" was commented out in the original; what's
-    // up with that?
+    let test_name_to_run = std::env::var("TEST_CASE").ok();
+
     let cases = vec![
-        TestCase::new("ganache-reverts", test_ganache_reverts),
+        TestCase::new("reverted-calls", test_reverted_calls_are_indexed),
         TestCase::new("host-exports", test_host_exports),
         TestCase::new("non-fatal-errors", test_non_fatal_errors),
         TestCase::new("overloaded-functions", test_overloaded_functions),
@@ -634,21 +1760,60 @@ async fn integration_tests() -> anyhow::Result<()> {
         TestCase::new("value-roundtrip", test_value_roundtrip),
         TestCase::new("int8", test_int8),
         TestCase::new("block-handlers", test_block_handlers),
+        TestCase::new("timestamp", test_timestamp),
+        TestCase::new("ethereum-api-tests", test_eth_api),
+        TestCase::new("topic-filter", test_topic_filters),
+        TestCase::new_with_grafting("grafted", test_subgraph_grafting, "base"),
+        TestCase::new_with_source_subgraphs(
+            "subgraph-data-sources",
+            subgraph_data_sources,
+            vec!["source-subgraph"],
+        ),
+        TestCase::new_with_source_subgraphs(
+            "multiple-subgraph-datasources",
+            test_multiple_subgraph_datasources,
+            vec!["source-subgraph-a", "source-subgraph-b"],
+        ),
+        TestCase::new("declared-calls-basic", test_declared_calls_basic),
+        TestCase::new(
+            "declared-calls-struct-fields",
+            test_declared_calls_struct_fields,
+        ),
+        TestCase::new("logs-query", test_logs_query),
     ];
 
+    // Filter the test cases if a specific test name is provided
+    let cases_to_run: Vec<_> = if let Some(ref test_name) = test_name_to_run {
+        cases
+            .into_iter()
+            .filter(|case| case.name == *test_name)
+            .collect()
+    } else {
+        cases
+    };
+
+    // Mine empty blocks to reach the required block number for grafting tests.
+    // This ensures deterministic block hashes for blocks 1-3 before any
+    // contract deployments occur.
+    status!(
+        "setup",
+        "Mining blocks to reach block {}",
+        SUBGRAPH_LAST_GRAFTING_BLOCK
+    );
+    Contract::ensure_block(SUBGRAPH_LAST_GRAFTING_BLOCK as u64)
+        .await
+        .context("Failed to mine initial blocks for grafting test")?;
+
     let contracts = Contract::deploy_all().await?;
 
     status!("setup", "Resetting database");
     CONFIG.reset_database();
 
-    status!("setup", "Initializing yarn workspace");
-    yarn_workspace().await?;
-
     // Spawn graph-node.
     status!("graph-node", "Starting graph-node");
     let mut graph_node_child_command = CONFIG.spawn_graph_node().await?;
 
-    let stream = tokio_stream::iter(cases)
+    let stream = tokio_stream::iter(cases_to_run)
         .map(|case| case.run(&contracts))
         .buffered(CONFIG.num_parallel_tests);
 
@@ -688,17 +1853,8 @@ async fn integration_tests() -> anyhow::Result<()> {
     }
 }
 
-async fn stop_graph_node(child: &mut Child) -> anyhow::Result<()> {
+pub async fn stop_graph_node(child: &mut Child) -> anyhow::Result<()> {
     child.kill().await.context("Failed to kill graph-node")?;
 
     Ok(())
 }
-
-async fn yarn_workspace() -> anyhow::Result<()> {
-    // We shouldn't really have to do this since we use the bundled version
-    // of graph-cli, but that gets very unhappy if the workspace isn't
-    // initialized
-    let wsp = TestFile::new("integration-tests");
-    run_checked(Command::new("yarn").arg("install").current_dir(&wsp.path)).await?;
-    Ok(())
-}
diff --git a/tests/tests/runner_tests.rs b/tests/tests/runner_tests.rs
index b0a23fb88ff..1d44657c441 100644
--- a/tests/tests/runner_tests.rs
+++ b/tests/tests/runner_tests.rs
@@ -1,85 +1,42 @@
+use std::collections::HashMap;
 use std::marker::PhantomData;
-use std::process::Command;
 use std::str::FromStr;
-use std::sync::atomic::{self, AtomicBool};
 use std::sync::Arc;
+use std::sync::atomic::{self, AtomicBool};
 use std::time::Duration;
 
 use assert_json_diff::assert_json_eq;
 use graph::blockchain::block_stream::BlockWithTriggers;
 use graph::blockchain::{Block, BlockPtr, Blockchain};
+use graph::components::subgraph::SubgraphInstanceManager as _;
 use graph::data::store::scalar::Bytes;
 use graph::data::subgraph::schema::{SubgraphError, SubgraphHealth};
 use graph::data::value::Word;
 use graph::data_source::CausalityRegion;
-use graph::env::EnvVars;
-use graph::ipfs_client::IpfsClient;
+use graph::env::{EnvVars, TEST_WITH_NO_REORG};
+use graph::ipfs::test_utils::add_files_to_local_ipfs_node_for_testing;
 use graph::object;
-use graph::prelude::ethabi::ethereum_types::H256;
-use graph::prelude::web3::types::Address;
-use graph::prelude::{
-    hex, CheapClone, DeploymentHash, SubgraphAssignmentProvider, SubgraphName, SubgraphStore,
-};
+use graph::prelude::alloy::primitives::{Address, B256, U256};
+use graph::prelude::{CheapClone, SubgraphName, SubgraphStore, hex};
 use graph_tests::fixture::ethereum::{
-    chain, empty_block, generate_empty_blocks_for_range, genesis, push_test_log,
+    chain, empty_block, generate_empty_blocks_for_range, genesis, push_test_command, push_test_log,
     push_test_polling_trigger,
 };
 
-use graph_tests::fixture::substreams::chain as substreams_chain;
-use graph_tests::fixture::{
-    self, stores, test_ptr, test_ptr_reorged, MockAdapterSelector, NoopAdapterSelector, Stores,
-    TestChainTrait, TestContext, TestInfo,
+use graph::blockchain::Trigger;
+use graph::prelude::alloy::rpc::types::BlockTransactions;
+use graph::prelude::{LightEthereumBlock, create_dummy_transaction, create_minimal_block_for_test};
+use graph_chain_ethereum::{
+    chain::BlockFinality,
+    trigger::{EthereumBlockTriggerType, EthereumTrigger},
 };
-use graph_tests::helpers::run_cmd;
-use slog::{o, Discard, Logger};
-
-struct RunnerTestRecipe {
-    pub stores: Stores,
-    pub test_info: TestInfo,
-}
-
-impl RunnerTestRecipe {
-    async fn new(test_name: &str, subgraph_name: &str) -> Self {
-        let subgraph_name = SubgraphName::new(subgraph_name).unwrap();
-        let test_dir = format!("./runner-tests/{}", subgraph_name);
 
-        let (stores, hash) = tokio::join!(
-            stores(test_name, "./runner-tests/config.simple.toml"),
-            build_subgraph(&test_dir, None)
-        );
-
-        Self {
-            stores,
-            test_info: TestInfo {
-                test_dir,
-                test_name: test_name.to_string(),
-                subgraph_name,
-                hash,
-            },
-        }
-    }
-
-    /// Builds a new test subgraph with a custom deploy command.
-    async fn new_with_custom_cmd(name: &str, subgraph_name: &str, deploy_cmd: &str) -> Self {
-        let subgraph_name = SubgraphName::new(subgraph_name).unwrap();
-        let test_dir = format!("./runner-tests/{}", subgraph_name);
-
-        let (stores, hash) = tokio::join!(
-            stores(name, "./runner-tests/config.simple.toml"),
-            build_subgraph(&test_dir, Some(deploy_cmd))
-        );
-
-        Self {
-            stores,
-            test_info: TestInfo {
-                test_dir,
-                test_name: name.to_string(),
-                subgraph_name,
-                hash,
-            },
-        }
-    }
-}
+use graph_tests::fixture::{
+    self, MockAdapterSelector, NoopAdapterSelector, StaticArweaveResolver, TestChainTrait,
+    TestContext, TestInfo, test_ptr, test_ptr_reorged,
+};
+use graph_tests::recipe::{RunnerTestRecipe, build_subgraph_with_pnpm_cmd_and_arg};
+use slog::{Discard, Logger, o};
 
 fn assert_eq_ignore_backtrace(err: &SubgraphError, expected: &SubgraphError) {
     let equal = {
@@ -88,14 +45,14 @@ fn assert_eq_ignore_backtrace(err: &SubgraphError, expected: &SubgraphError) {
             || err.handler != expected.handler
             || err.deterministic != expected.deterministic
         {
-            false;
-        }
-
-        // Ignore any WASM backtrace in the error message
-        let split_err: Vec<&str> = err.message.split("\\twasm backtrace:").collect();
-        let split_expected: Vec<&str> = expected.message.split("\\twasm backtrace:").collect();
+            false
+        } else {
+            // Ignore any WASM backtrace in the error message
+            let split_err: Vec<&str> = err.message.split("\\twasm backtrace:").collect();
+            let split_expected: Vec<&str> = expected.message.split("\\twasm backtrace:").collect();
 
-        split_err.get(0) == split_expected.get(0)
+            split_err.first() == split_expected.first()
+        }
     };
 
     if !equal {
@@ -106,8 +63,10 @@ fn assert_eq_ignore_backtrace(err: &SubgraphError, expected: &SubgraphError) {
     }
 }
 
-#[tokio::test]
+#[graph::test]
 async fn data_source_revert() -> anyhow::Result<()> {
+    *TEST_WITH_NO_REORG.lock().unwrap() = true;
+
     let RunnerTestRecipe { stores, test_info } =
         RunnerTestRecipe::new("data_source_revert", "data-source-revert").await;
 
@@ -116,7 +75,7 @@ async fn data_source_revert() -> anyhow::Result<()> {
         let block1 = empty_block(block0.ptr(), test_ptr(1));
         let block1_reorged_ptr = BlockPtr {
             number: 1,
-            hash: H256::from_low_u64_be(12).into(),
+            hash: B256::from(U256::from(12)).into(),
         };
         let block1_reorged = empty_block(block0.ptr(), block1_reorged_ptr.clone());
         let block2 = empty_block(block1_reorged_ptr, test_ptr(2));
@@ -133,9 +92,8 @@ async fn data_source_revert() -> anyhow::Result<()> {
     base_ctx.start_and_sync_to(stop_block).await;
     base_ctx
         .provider
-        .stop(base_ctx.deployment.clone())
-        .await
-        .unwrap();
+        .stop_subgraph(base_ctx.deployment.clone())
+        .await;
 
     // Test loading data sources from DB.
     let stop_block = test_ptr(3);
@@ -143,7 +101,7 @@ async fn data_source_revert() -> anyhow::Result<()> {
 
     // Test grafted version
     let subgraph_name = SubgraphName::new("data-source-revert-grafted").unwrap();
-    let hash = build_subgraph_with_yarn_cmd_and_arg(
+    let hash = build_subgraph_with_pnpm_cmd_and_arg(
         "./runner-tests/data-source-revert",
         "deploy:test-grafted",
         Some(&test_info.hash),
@@ -178,6 +136,8 @@ async fn data_source_revert() -> anyhow::Result<()> {
     // since it uses the same deployment id.
     data_source_long_revert().await.unwrap();
 
+    *TEST_WITH_NO_REORG.lock().unwrap() = false;
+
     Ok(())
 }
 
@@ -225,7 +185,7 @@ async fn data_source_long_revert() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[graph::test]
 async fn typename() -> anyhow::Result<()> {
     let RunnerTestRecipe { stores, test_info } =
         RunnerTestRecipe::new("typename", "typename").await;
@@ -235,7 +195,7 @@ async fn typename() -> anyhow::Result<()> {
         let block_1 = empty_block(block_0.ptr(), test_ptr(1));
         let block_1_reorged_ptr = BlockPtr {
             number: 1,
-            hash: H256::from_low_u64_be(12).into(),
+            hash: B256::from(U256::from(12)).into(),
         };
         let block_1_reorged = empty_block(block_0.ptr(), block_1_reorged_ptr);
         let block_2 = empty_block(block_1_reorged.ptr(), test_ptr(2));
@@ -253,7 +213,7 @@ async fn typename() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[graph::test]
 async fn api_version_0_0_7() {
     let RunnerTestRecipe { stores, test_info } = RunnerTestRecipe::new_with_custom_cmd(
         "api_version_0_0_7",
@@ -281,7 +241,7 @@ async fn api_version_0_0_7() {
     ctx.start_and_sync_to(stop_block).await;
 
     let query_res = ctx
-        .query(&format!(r#"{{ testResults{{ id, message }} }}"#,))
+        .query(r#"{ testResults{ id, message } }"#)
         .await
         .unwrap();
 
@@ -295,7 +255,7 @@ async fn api_version_0_0_7() {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn api_version_0_0_8() {
     let RunnerTestRecipe { stores, test_info } = RunnerTestRecipe::new_with_custom_cmd(
         "api_version_0_0_8",
@@ -329,7 +289,7 @@ async fn api_version_0_0_8() {
     assert_eq_ignore_backtrace(&err, &expected_err);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn derived_loaders() {
     let RunnerTestRecipe { stores, test_info } =
         RunnerTestRecipe::new("derived_loaders", "derived-loaders").await;
@@ -365,9 +325,7 @@ async fn derived_loaders() {
     // Where the test cases are documented in the code.
 
     let query_res = ctx
-    .query(&format!(
-        r#"{{ testResult(id:"1_0", block: {{ number: 1 }} ){{ id barDerived{{id value value2}} bBarDerived{{id value value2}} }} }}"#,
-    ))
+    .query(r#"{ testResult(id:"1_0", block: { number: 1 } ){ id barDerived{id value value2} bBarDerived{id value value2} } }"#)
     .await
     .unwrap();
 
@@ -415,9 +373,7 @@ async fn derived_loaders() {
     );
 
     let query_res = ctx
-    .query(&format!(
-        r#"{{ testResult(id:"1_1", block: {{ number: 1 }} ){{ id barDerived{{id value value2}} bBarDerived{{id value value2}} }} }}"#,
-    ))
+    .query(r#"{ testResult(id:"1_1", block: { number: 1 } ){ id barDerived{id value value2} bBarDerived{id value value2} } }"#)
     .await
     .unwrap();
 
@@ -455,9 +411,7 @@ async fn derived_loaders() {
     );
 
     let query_res = ctx.query(
-    &format!(
-        r#"{{ testResult(id:"2_0" ){{ id barDerived{{id value value2}} bBarDerived{{id value value2}} }} }}"#
-    )
+    r#"{ testResult(id:"2_0" ){ id barDerived{id value value2} bBarDerived{id value value2} } }"#
 )
 .await
 .unwrap();
@@ -485,29 +439,7 @@ async fn derived_loaders() {
     );
 }
 
-// This PR https://github.com/graphprotocol/graph-node/pull/4787
-// changed the way TriggerFilters were built
-// A bug was introduced in the PR which resulted in filters for substreams not being included
-// This test tests that the TriggerFilter is built correctly for substreams
-#[tokio::test]
-async fn substreams_trigger_filter_construction() -> anyhow::Result<()> {
-    let RunnerTestRecipe { stores, test_info } =
-        RunnerTestRecipe::new("substreams", "substreams").await;
-
-    let chain = substreams_chain(&test_info.test_name, &stores).await;
-    let ctx = fixture::setup(&test_info, &stores, &chain, None, None).await;
-
-    let runner = ctx.runner_substreams(test_ptr(0)).await;
-    let filter = runner.build_filter_for_test();
-
-    assert_eq!(filter.module_name(), "graph_out");
-    assert_eq!(filter.modules().as_ref().unwrap().modules.len(), 2);
-    assert_eq!(filter.start_block().unwrap(), 0);
-    assert_eq!(filter.data_sources_len(), 1);
-    Ok(())
-}
-
-#[tokio::test]
+#[graph::test]
 async fn end_block() -> anyhow::Result<()> {
     let RunnerTestRecipe { stores, test_info } =
         RunnerTestRecipe::new("end_block", "end-block").await;
@@ -524,13 +456,17 @@ async fn end_block() -> anyhow::Result<()> {
     ) {
         let runner = ctx.runner(block_ptr.clone()).await;
         let runner = runner.run_for_test(false).await.unwrap();
-        let filter = runner.context().filter.as_ref().unwrap();
-        let addresses = filter.log().contract_addresses().collect::<Vec<_>>();
+        let filter = runner.build_filter_for_test();
+        let addresses = filter
+            .chain_filter
+            .log()
+            .contract_addresses()
+            .collect::<Vec<_>>();
 
         if should_contain_addr {
-            assert!(addresses.contains(&addr));
+            assert!(addresses.contains(addr));
         } else {
-            assert!(!addresses.contains(&addr));
+            assert!(!addresses.contains(addr));
         };
     }
 
@@ -580,7 +516,7 @@ async fn end_block() -> anyhow::Result<()> {
 
     // Simulate a chain reorg and ensure the filter rebuilds accurately post-reorg.
     {
-        ctx.rewind(test_ptr(6));
+        ctx.rewind(test_ptr(6)).await;
 
         let mut blocks = blocks[0..8].to_vec().clone();
 
@@ -601,10 +537,10 @@ async fn end_block() -> anyhow::Result<()> {
         // Verify that after the reorg, the last Block entity still reflects block number 8, but with a different hash.
         let query_res = ctx
             .query(
-                r#"{ 
-                blocks(first: 1, orderBy: number, orderDirection: desc) { 
-                    number 
-                    hash 
+                r#"{
+                blocks(first: 1, orderBy: number, orderDirection: desc) {
+                    number
+                    hash
                 }
             }"#,
             )
@@ -627,24 +563,56 @@ async fn end_block() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[graph::test]
 async fn file_data_sources() {
     let RunnerTestRecipe { stores, test_info } =
-        RunnerTestRecipe::new("file_data_sources", "file-data-sources").await;
+        RunnerTestRecipe::new("file-data-sourcess", "file-data-sources").await;
+
+    async fn add_content_to_ipfs(content: &str) -> String {
+        add_files_to_local_ipfs_node_for_testing([content.as_bytes().to_vec()])
+            .await
+            .unwrap()[0]
+            .hash
+            .to_owned()
+    }
+
+    let hash_1 = add_content_to_ipfs("EXAMPLE_1").await;
+    let hash_2 = add_content_to_ipfs("EXAMPLE_2").await;
+    let hash_3 = add_content_to_ipfs("EXAMPLE_3").await;
+    let hash_4 = add_content_to_ipfs("EXAMPLE_4").await;
+
+    //concatenate hash2 and hash3
+    let hash_2_comma_3 = format!("{},{}", hash_2, hash_3);
 
     let blocks = {
         let block_0 = genesis();
-        let block_1 = empty_block(block_0.ptr(), test_ptr(1));
-        let block_2 = empty_block(block_1.ptr(), test_ptr(2));
-        let block_3 = empty_block(block_2.ptr(), test_ptr(3));
+        let mut block_1 = empty_block(block_0.ptr(), test_ptr(1));
+        push_test_command(&mut block_1, "CREATE_FILE", &hash_1);
+        let mut block_2 = empty_block(block_1.ptr(), test_ptr(2));
+        push_test_command(&mut block_2, "CREATE_FILE", &hash_1);
+
+        let mut block_3 = empty_block(block_2.ptr(), test_ptr(3));
+        push_test_command(
+            &mut block_3,
+            "SPAWN_FDS_FROM_OFFCHAIN_HANDLER",
+            &hash_2_comma_3,
+        );
+
         let block_4 = empty_block(block_3.ptr(), test_ptr(4));
+
         let mut block_5 = empty_block(block_4.ptr(), test_ptr(5));
-        push_test_log(&mut block_5, "spawnOffChainHandlerTest");
-        let block_6 = empty_block(block_5.ptr(), test_ptr(6));
-        let mut block_7 = empty_block(block_6.ptr(), test_ptr(7));
-        push_test_log(&mut block_7, "createFile2");
+        push_test_command(
+            &mut block_5,
+            "CREATE_ONCHAIN_DATASOURCE_FROM_OFFCHAIN_HANDLER",
+            &hash_3,
+        );
+
+        let mut block_6 = empty_block(block_5.ptr(), test_ptr(6));
+
+        push_test_command(&mut block_6, "CREATE_UNDEFINED_ENTITY", &hash_4);
+
         vec![
-            block_0, block_1, block_2, block_3, block_4, block_5, block_6, block_7,
+            block_0, block_1, block_2, block_3, block_4, block_5, block_6,
         ]
     };
 
@@ -665,178 +633,220 @@ async fn file_data_sources() {
     )
     .await;
     let ctx = fixture::setup(&test_info, &stores, &chain, None, None).await;
-    ctx.start_and_sync_to(test_ptr(1)).await;
 
-    // CID of `file-data-sources/abis/Contract.abi` after being processed by graph-cli.
-    let id = "QmQ2REmceVtzawp7yrnxLQXgNNCtFHEnig6fL9aqE1kcWq";
-    let content_bytes = ctx.ipfs.cat_all(id, Duration::from_secs(10)).await.unwrap();
-    let content = String::from_utf8(content_bytes.into()).unwrap();
-    let query_res = ctx
-        .query(&format!(r#"{{ ipfsFile(id: "{id}") {{ id, content }} }}"#,))
-        .await
-        .unwrap();
-
-    assert_json_eq!(
-        query_res,
-        Some(object! { ipfsFile: object!{ id: id, content: content.clone() } })
-    );
-
-    // assert whether duplicate data sources are created.
-    ctx.start_and_sync_to(test_ptr(2)).await;
+    {
+        ctx.start_and_sync_to(test_ptr(1)).await;
 
-    let store = ctx.store.cheap_clone();
-    let writable = store
-        .writable(ctx.logger.clone(), ctx.deployment.id, Arc::new(Vec::new()))
-        .await
-        .unwrap();
-    let datasources = writable.load_dynamic_data_sources(vec![]).await.unwrap();
-    assert!(datasources.len() == 1);
+        let content = "EXAMPLE_1";
+        let query_res = ctx
+            .query(&format!(
+                r#"{{ fileEntity(id: "{}") {{ id, content }} }}"#,
+                hash_1.clone()
+            ))
+            .await
+            .unwrap();
 
-    ctx.start_and_sync_to(test_ptr(3)).await;
+        let store = ctx.store.cheap_clone();
+        let writable = store
+            .writable(ctx.logger.clone(), ctx.deployment.id, Arc::new(Vec::new()))
+            .await
+            .unwrap();
+        let datasources = writable.load_dynamic_data_sources(vec![]).await.unwrap();
+        assert!(datasources.len() == 1);
 
-    let query_res = ctx
-        .query(&format!(r#"{{ ipfsFile1(id: "{id}") {{ id, content }} }}"#,))
-        .await
-        .unwrap();
+        assert_json_eq!(
+            query_res,
+            Some(object! { fileEntity: object!{ id: hash_1.clone(), content: content } })
+        );
+    }
 
-    assert_json_eq!(
-        query_res,
-        Some(object! { ipfsFile1: object!{ id: id , content: content.clone() } })
-    );
+    // Should not create duplicate datasource
+    {
+        ctx.start_and_sync_to(test_ptr(2)).await;
 
-    ctx.start_and_sync_to(test_ptr(4)).await;
-    let writable = ctx
-        .store
-        .clone()
-        .writable(ctx.logger.clone(), ctx.deployment.id, Arc::new(Vec::new()))
-        .await
-        .unwrap();
-    let data_sources = writable.load_dynamic_data_sources(vec![]).await.unwrap();
-    assert!(data_sources.len() == 2);
-
-    let mut causality_region = CausalityRegion::ONCHAIN;
-    for data_source in data_sources {
-        assert!(data_source.done_at.is_some());
-        assert!(data_source.causality_region == causality_region.next());
-        causality_region = causality_region.next();
+        let store = ctx.store.cheap_clone();
+        let writable = store
+            .writable(ctx.logger.clone(), ctx.deployment.id, Arc::new(Vec::new()))
+            .await
+            .unwrap();
+        let datasources = writable.load_dynamic_data_sources(vec![]).await.unwrap();
+        assert!(datasources.len() == 1);
     }
 
-    ctx.start_and_sync_to(test_ptr(5)).await;
-    let writable = ctx
-        .store
-        .clone()
-        .writable(ctx.logger.clone(), ctx.deployment.id, Arc::new(Vec::new()))
-        .await
-        .unwrap();
-    let data_sources = writable.load_dynamic_data_sources(vec![]).await.unwrap();
-    assert!(data_sources.len() == 4);
+    // Create a File data source from a same type of file data source handler.
+    // Both hash_2 and hash_3 handlers create entities in the same block,
+    // exercising the shared VID generator: colliding VIDs would cause a DB
+    // constraint violation.
+    {
+        ctx.start_and_sync_to(test_ptr(4)).await;
 
-    ctx.start_and_sync_to(test_ptr(6)).await;
-    let query_res = ctx
-        .query(&format!(
-            r#"{{ spawnTestEntity(id: "{id}") {{ id, content, context }} }}"#,
-        ))
-        .await
-        .unwrap();
+        let query_res = ctx
+            .query(&format!(
+                r#"{{ fileEntity(id: "{}") {{ id, content }} }}"#,
+                hash_2.clone()
+            ))
+            .await
+            .unwrap();
+        assert_json_eq!(
+            query_res,
+            Some(object! { fileEntity: object!{ id: hash_2.clone(), content: "EXAMPLE_2" } })
+        );
 
-    assert_json_eq!(
-        query_res,
-        Some(
-            object! { spawnTestEntity: object!{ id: id , content: content.clone(), context: "fromSpawnTestHandler" } }
-        )
-    );
+        let query_res = ctx
+            .query(&format!(
+                r#"{{ fileEntity(id: "{}") {{ id, content }} }}"#,
+                hash_3.clone()
+            ))
+            .await
+            .unwrap();
+        assert_json_eq!(
+            query_res,
+            Some(object! { fileEntity: object!{ id: hash_3.clone(), content: "EXAMPLE_3" } })
+        );
+    }
 
-    let stop_block = test_ptr(7);
-    let err = ctx.start_and_sync_to_error(stop_block.clone()).await;
-    let message = "entity type `IpfsFile1` is not on the 'entities' list for data source `File2`. \
-                   Hint: Add `IpfsFile1` to the 'entities' list, which currently is: `IpfsFile`."
-        .to_string();
-    let expected_err = SubgraphError {
-        subgraph_id: ctx.deployment.hash.clone(),
-        message,
-        block_ptr: Some(stop_block),
-        handler: None,
-        deterministic: false,
-    };
-    assert_eq_ignore_backtrace(&err, &expected_err);
+    // Should not allow creating on-chain data source from off-chain data source handler
+    {
+        let err = ctx.start_and_sync_to_error(test_ptr(5)).await;
+        let message =
+            "Attempted to create on-chain data source in offchain data source handler.".to_string();
+        assert!(err.to_string().contains(&message));
+    }
 
-    // Unfail the subgraph to test a conflict between an onchain and offchain entity
+    // Should not allow creating conflicting entity. ie: Entity created in offchain handler cannot be created in onchain handler
     {
-        ctx.rewind(test_ptr(6));
+        ctx.rewind(test_ptr(4)).await;
 
-        // Replace block number 7 with one that contains a different event
         let mut blocks = blocks.clone();
-        blocks.pop();
-        let block_7_1_ptr = test_ptr_reorged(7, 1);
-        let mut block_7_1 = empty_block(test_ptr(6), block_7_1_ptr.clone());
-        push_test_log(&mut block_7_1, "saveConflictingEntity");
-        blocks.push(block_7_1);
+        blocks.retain(|block| block.block.number() <= 4);
+
+        let mut block_5 = empty_block(test_ptr(4), test_ptr(5));
+        push_test_command(&mut block_5, "CREATE_CONFLICTING_ENTITY", &hash_1);
+        blocks.push(block_5.clone());
 
         chain.set_block_stream(blocks);
 
-        // Errors in the store pipeline can be observed by using the runner directly.
-        let runner = ctx.runner(block_7_1_ptr.clone()).await;
+        let message = "writing FileEntity entities at block 5 failed: conflicting key value violates exclusion constraint \"file_entity_id_block_range_excl\" Query: insert 1 rows with ids [QmYiiCtcXmSHXN3m2nyqLaTM7zi81KjVdZ9WXkcrCKrkjr@[5, ∞)]";
+
+        let runner = ctx.runner(block_5.ptr()).await;
         let err = runner
             .run()
             .await
             .err()
             .unwrap_or_else(|| panic!("subgraph ran successfully but an error was expected"));
 
-        let message =
-            "store error: conflicting key value violates exclusion constraint \"ipfs_file_id_block_range_excl\""
-                .to_string();
         assert_eq!(err.to_string(), message);
     }
 
-    // Unfail the subgraph to test a conflict between an onchain and offchain entity
+    // Should not allow accessing entities created in offchain handlers in onchain handlers
     {
-        // Replace block number 7 with one that contains a different event
+        ctx.rewind(test_ptr(4)).await;
+
         let mut blocks = blocks.clone();
-        blocks.pop();
-        let block_7_2_ptr = test_ptr_reorged(7, 2);
-        let mut block_7_2 = empty_block(test_ptr(6), block_7_2_ptr.clone());
-        push_test_log(&mut block_7_2, "createFile1");
-        blocks.push(block_7_2);
+        blocks.retain(|block| block.block.number() <= 4);
+
+        let mut block_5 = empty_block(test_ptr(4), test_ptr(5));
+        push_test_command(
+            &mut block_5,
+            "ACCESS_AND_UPDATE_OFFCHAIN_ENTITY_IN_ONCHAIN_HANDLER",
+            &hash_1,
+        );
+        blocks.push(block_5.clone());
 
         chain.set_block_stream(blocks);
 
-        // Errors in the store pipeline can be observed by using the runner directly.
-        let err = ctx
-            .runner(block_7_2_ptr.clone())
+        ctx.start_and_sync_to(block_5.ptr()).await;
+
+        let content = "EXAMPLE_1";
+        let query_res = ctx
+            .query(&format!(
+                r#"{{ fileEntity(id: "{}") {{ id, content }} }}"#,
+                hash_1.clone()
+            ))
             .await
-            .run()
+            .unwrap();
+        assert_json_eq!(
+            query_res,
+            Some(object! { fileEntity: object!{ id: hash_1.clone(), content: content } })
+        );
+    }
+
+    // Prevent access to entities created by offchain handlers when using derived loaders in onchain handlers.
+    {
+        ctx.rewind(test_ptr(4)).await;
+
+        let mut blocks = blocks.clone();
+        blocks.retain(|block| block.block.number() <= 4);
+
+        let hash_5 = add_content_to_ipfs("EXAMPLE_5").await;
+
+        let mut block_5 = empty_block(test_ptr(4), test_ptr(5));
+        push_test_command(&mut block_5, "CREATE_FOO", &hash_5);
+        blocks.push(block_5.clone());
+
+        let mut block_6 = empty_block(block_5.ptr(), test_ptr(6));
+        push_test_command(
+            &mut block_6,
+            "ACCESS_FILE_ENTITY_THROUGH_DERIVED_FIELD",
+            &hash_5,
+        );
+        blocks.push(block_6.clone());
+
+        chain.set_block_stream(blocks);
+
+        ctx.start_and_sync_to(block_5.ptr()).await;
+
+        let query_res = ctx
+            .query(&format!(
+                r#"{{ foo(id: "{}") {{ id, ipfs {{ id, content }} }} }}"#,
+                hash_5.clone(),
+            ))
             .await
-            .err()
-            .unwrap_or_else(|| panic!("subgraph ran successfully but an error was expected"));
+            .unwrap();
+        let content = "EXAMPLE_5";
+        assert_json_eq!(
+            query_res,
+            Some(
+                object! { foo: object!{ id: hash_5.clone(), ipfs: object!{id: hash_5.clone(), content: content}} }
+            )
+        );
 
-        let message =
-            "store error: conflicting key value violates exclusion constraint \"ipfs_file_1_id_block_range_excl\""
-                .to_string();
-        assert_eq!(err.to_string(), message);
+        ctx.start_and_sync_to(block_6.ptr()).await;
     }
 
+    // Should not allow creating entity that is not declared in the manifest for the offchain datasource
     {
-        ctx.rewind(test_ptr(6));
-        // Replace block number 7 with one that contains a different event
+        ctx.rewind(test_ptr(4)).await;
+
         let mut blocks = blocks.clone();
-        blocks.pop();
-        let block_7_3_ptr = test_ptr_reorged(7, 1);
-        let mut block_7_3 = empty_block(test_ptr(6), block_7_3_ptr.clone());
-        push_test_log(&mut block_7_3, "spawnOnChainHandlerTest");
-        blocks.push(block_7_3);
+        blocks.retain(|block| block.block.number() <= 4);
+
+        let mut block_5 = empty_block(test_ptr(4), test_ptr(5));
+        push_test_command(&mut block_5, "CREATE_UNDEFINED_ENTITY", &hash_1);
+        blocks.push(block_5.clone());
 
         chain.set_block_stream(blocks);
 
-        // Errors in the store pipeline can be observed by using the runner directly.
-        let err = ctx.start_and_sync_to_error(block_7_3_ptr).await;
-        let message =
-            "Attempted to create on-chain data source in offchain data source handler. This is not yet supported. at block #7 (0000000100000000000000000000000000000000000000000000000000000007)"
-                .to_string();
-        assert_eq!(err.to_string(), message);
+        let err = ctx.start_and_sync_to_error(block_5.ptr()).await;
+        let err_msg = err.to_string();
+
+        // Don't check exact wasm hex offsets since they change with any
+        // modification to the wasm binary.
+        assert!(
+            err_msg
+                .contains("entity type `Foo` is not on the 'entities' list for data source `File`"),
+            "unexpected error: {err_msg}"
+        );
+        assert!(
+            err_msg.contains(
+                "Hint: Add `Foo` to the 'entities' list, which currently is: `FileEntity`"
+            ),
+            "unexpected error: {err_msg}"
+        );
     }
 }
 
-#[tokio::test]
+#[graph::test]
 async fn block_handlers() {
     let RunnerTestRecipe { stores, test_info } =
         RunnerTestRecipe::new("block_handlers", "block-handlers").await;
@@ -960,7 +970,7 @@ async fn block_handlers() {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn template_static_filters_false_positives() {
     let RunnerTestRecipe { stores, test_info } = RunnerTestRecipe::new(
         "template_static_filters_false_positives",
@@ -996,11 +1006,11 @@ async fn template_static_filters_false_positives() {
     // a change in the POI infrastructure. Or the subgraph id changed.
     assert_eq!(
         hex::encode(poi.unwrap()),
-        "c72af01a19a4e35a35778821a354b7a781062a9320ac8796ea65b115cb9844bf"
+        "8e5cfe3f014586cf0f02277c306ac66f11da52b632b937bd74229cce1374d9d5"
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn parse_data_source_context() {
     let RunnerTestRecipe { stores, test_info } =
         RunnerTestRecipe::new("parse_data_source_context", "data-sources").await;
@@ -1028,7 +1038,7 @@ async fn parse_data_source_context() {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn retry_create_ds() {
     let RunnerTestRecipe { stores, test_info } =
         RunnerTestRecipe::new("retry_create_ds", "data-source-revert2").await;
@@ -1038,7 +1048,7 @@ async fn retry_create_ds() {
         let block1 = empty_block(block0.ptr(), test_ptr(1));
         let block1_reorged_ptr = BlockPtr {
             number: 1,
-            hash: H256::from_low_u64_be(12).into(),
+            hash: B256::from(U256::from(12)).into(),
         };
         let block1_reorged = empty_block(block0.ptr(), block1_reorged_ptr);
         let block2 = empty_block(block1_reorged.ptr(), test_ptr(2));
@@ -1085,7 +1095,7 @@ async fn retry_create_ds() {
     assert_eq!(runner.context().hosts_len(), 2);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn fatal_error() -> anyhow::Result<()> {
     let RunnerTestRecipe { stores, test_info } =
         RunnerTestRecipe::new("fatal_error", "fatal-error").await;
@@ -1142,7 +1152,7 @@ async fn fatal_error() -> anyhow::Result<()> {
     assert!(poi2 != poi100);
 
     // Test that rewind unfails the subgraph.
-    ctx.rewind(test_ptr(1));
+    ctx.rewind(test_ptr(1)).await;
     let status = ctx.indexing_status().await;
     assert!(status.health == SubgraphHealth::Healthy);
     assert!(status.fatal_error.is_none());
@@ -1150,7 +1160,7 @@ async fn fatal_error() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[tokio::test]
+#[graph::test]
 async fn arweave_file_data_sources() {
     let RunnerTestRecipe { stores, test_info } =
         RunnerTestRecipe::new("arweave_file_data_sources", "arweave-file-data-sources").await;
@@ -1165,23 +1175,22 @@ async fn arweave_file_data_sources() {
     // HASH used in the mappings.
     let id = "8APeQ5lW0-csTcBaGdPBDLAL2ci2AT9pTn2tppGPU_8";
 
-    // This test assumes the file data sources will be processed in the same block in which they are
-    // created. But the test might fail due to a race condition if for some reason it takes longer
-    // than expected to fetch the file from arweave. The sleep here will conveniently happen after the
-    // data source is added to the offchain monitor but before the monitor is checked, in an an
-    // attempt to ensure the monitor has enough time to fetch the file.
-    let adapter_selector = NoopAdapterSelector {
-        x: PhantomData,
-        triggers_in_block_sleep: Duration::from_millis(1500),
-    };
-    let chain = chain(
-        &test_info.test_name,
-        blocks.clone(),
+    // Use a mock arweave resolver to avoid real network calls and eliminate the
+    // race condition that caused this test to be flaky.
+    let arweave_content: HashMap<String, Vec<u8>> =
+        HashMap::from([(id.to_string(), b"test arweave content".to_vec())]);
+    let arweave_resolver = Arc::new(StaticArweaveResolver::new(arweave_content));
+
+    let chain = chain(&test_info.test_name, blocks.clone(), &stores, None).await;
+    let ctx = fixture::setup_with_arweave_resolver(
+        &test_info,
         &stores,
-        Some(Arc::new(adapter_selector)),
+        &chain,
+        None,
+        None,
+        arweave_resolver,
     )
     .await;
-    let ctx = fixture::setup(&test_info, &stores, &chain, None, None).await;
     ctx.start_and_sync_to(test_ptr(2)).await;
 
     let store = ctx.store.cheap_clone();
@@ -1193,14 +1202,14 @@ async fn arweave_file_data_sources() {
     assert_eq!(datasources.len(), 1);
     let ds = datasources.first().unwrap();
     assert_ne!(ds.causality_region, CausalityRegion::ONCHAIN);
-    assert_eq!(ds.done_at.is_some(), true);
+    assert!(ds.done_at.is_some());
     assert_eq!(
         ds.param.as_ref().unwrap(),
         &Bytes::from(Word::from(id).as_bytes())
     );
 
     let content_bytes = ctx.arweave_resolver.get(&Word::from(id)).await.unwrap();
-    let content = String::from_utf8(content_bytes.into()).unwrap();
+    let content = String::from_utf8(content_bytes).unwrap();
     let query_res = ctx
         .query(&format!(r#"{{ file(id: "{id}") {{ id, content }} }}"#,))
         .await
@@ -1212,60 +1221,274 @@ async fn arweave_file_data_sources() {
     );
 }
 
-/// deploy_cmd is the command to run to deploy the subgraph. If it is None, the
-/// default `yarn deploy:test` is used.
-async fn build_subgraph(dir: &str, deploy_cmd: Option<&str>) -> DeploymentHash {
-    build_subgraph_with_yarn_cmd(dir, deploy_cmd.unwrap_or("deploy:test")).await
-}
+#[graph::test]
+async fn aggregation_current_bucket() {
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("aggregation_current_bucket", "aggregation-current-bucket").await;
+
+    // Helper to create a block with a specific timestamp (seconds since epoch)
+    fn empty_block_with_timestamp(
+        parent_ptr: BlockPtr,
+        ptr: BlockPtr,
+        timestamp: u64,
+    ) -> BlockWithTriggers<graph_chain_ethereum::Chain> {
+        let dummy_txn =
+            create_dummy_transaction(ptr.number as u64, ptr.hash.as_b256(), Some(0), B256::ZERO);
+        let transactions = BlockTransactions::Full(vec![dummy_txn]);
+        let alloy_block = create_minimal_block_for_test(ptr.number as u64, ptr.hash.as_b256())
+            .map_header(|mut header| {
+                header.inner.parent_hash = parent_ptr.hash.as_b256();
+                header.inner.timestamp = timestamp;
+                header
+            })
+            .with_transactions(transactions);
+
+        BlockWithTriggers::<graph_chain_ethereum::Chain> {
+            block: BlockFinality::Final(Arc::new(LightEthereumBlock::new(alloy_block))),
+            trigger_data: vec![Trigger::Chain(EthereumTrigger::Block(
+                ptr,
+                EthereumBlockTriggerType::End,
+            ))],
+        }
+    }
 
-async fn build_subgraph_with_yarn_cmd(dir: &str, yarn_cmd: &str) -> DeploymentHash {
-    build_subgraph_with_yarn_cmd_and_arg(dir, yarn_cmd, None).await
-}
+    // Block layout:
+    // Block 0: genesis (timestamp 0)
+    // Block 1: timestamp 3601 (hour 1, +1s) — create tokens
+    // Block 2: timestamp 3660 (hour 1, +1 min) — create data: TOKEN_A=10, TOKEN_B=20
+    // Block 3: timestamp 3720 (hour 1, +2 min) — create data: TOKEN_A=30, TOKEN_B=40
+    // Block 4: timestamp 7201 (hour 2, +1s, triggers hour-1 rollup) — create data: TOKEN_A=5, TOKEN_B=15
+    // Block 5: timestamp 7261 (hour 2, +1 min +1s) — create data: TOKEN_A=7, TOKEN_B=25
+    //
+    // Expected results:
+    // Hour 1 (rolled up): TOKEN_A sum=40, TOKEN_B sum=60
+    // Hour 2 (current):   TOKEN_A sum=12, TOKEN_B sum=40
+
+    let block_0 = genesis();
+
+    let mut block_1 = empty_block_with_timestamp(block_0.ptr(), test_ptr(1), 3601);
+    push_test_log(&mut block_1, "token:0xaa:TokenA");
+    push_test_log(&mut block_1, "token:0xbb:TokenB");
+
+    let mut block_2 = empty_block_with_timestamp(block_1.ptr(), test_ptr(2), 3660);
+    push_test_log(&mut block_2, "data:0xaa:10");
+    push_test_log(&mut block_2, "data:0xbb:20");
+
+    let mut block_3 = empty_block_with_timestamp(block_2.ptr(), test_ptr(3), 3720);
+    push_test_log(&mut block_3, "data:0xaa:30");
+    push_test_log(&mut block_3, "data:0xbb:40");
+
+    let mut block_4 = empty_block_with_timestamp(block_3.ptr(), test_ptr(4), 7201);
+    push_test_log(&mut block_4, "data:0xaa:5");
+    push_test_log(&mut block_4, "data:0xbb:15");
+
+    let mut block_5 = empty_block_with_timestamp(block_4.ptr(), test_ptr(5), 7261);
+    push_test_log(&mut block_5, "data:0xaa:7");
+    push_test_log(&mut block_5, "data:0xbb:25");
+
+    let blocks = vec![block_0, block_1, block_2, block_3, block_4, block_5];
+    let chain = chain(&test_info.test_name, blocks, &stores, None).await;
+    let ctx = fixture::setup(&test_info, &stores, &chain, None, None).await;
 
-async fn build_subgraph_with_yarn_cmd_and_arg(
-    dir: &str,
-    yarn_cmd: &str,
-    arg: Option<&str>,
-) -> DeploymentHash {
-    // Test that IPFS is up.
-    IpfsClient::localhost()
-        .test()
+    ctx.start_and_sync_to(test_ptr(5)).await;
+
+    // Query 1: Root query with current: include
+    // Expect 4 rows: hour-1 TOKEN_A(sum=40), hour-1 TOKEN_B(sum=60),
+    //                hour-2 TOKEN_A(sum=12), hour-2 TOKEN_B(sum=40)
+    let query_res = ctx
+        .query(
+            r#"{
+                stats_collection(interval: "hour", current: include, orderBy: timestamp, orderDirection: asc) {
+                    token { id }
+                    sum
+                }
+            }"#,
+        )
         .await
-        .expect("Could not connect to IPFS, make sure it's running at port 5001");
+        .unwrap();
+
+    assert_eq!(
+        query_res,
+        Some(object! {
+            stats_collection: vec![
+                object! { token: object! { id: "0xaa" }, sum: "40" },
+                object! { token: object! { id: "0xbb" }, sum: "60" },
+                object! { token: object! { id: "0xaa" }, sum: "12" },
+                object! { token: object! { id: "0xbb" }, sum: "40" },
+            ]
+        })
+    );
+
+    // Query 2: Root query with current: exclude (only rolled-up data)
+    // Expect 2 rows: hour-1 TOKEN_A(sum=40), hour-1 TOKEN_B(sum=60)
+    let query_res = ctx
+        .query(
+            r#"{
+                stats_collection(interval: "hour", current: exclude, orderBy: timestamp, orderDirection: asc) {
+                    token { id }
+                    sum
+                }
+            }"#,
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(
+        query_res,
+        Some(object! {
+            stats_collection: vec![
+                object! { token: object! { id: "0xaa" }, sum: "40" },
+                object! { token: object! { id: "0xbb" }, sum: "60" },
+            ]
+        })
+    );
 
-    // Make sure dependencies are present.
+    // Query 3: Nested query with current: include
+    // Each token should have 2 stats entries (hour-1 rolled-up + hour-2 current)
+    let query_res = ctx
+        .query(
+            r#"{
+                tokens(orderBy: id) {
+                    id
+                    stats(interval: "hour", current: include, orderBy: timestamp, orderDirection: asc) {
+                        sum
+                    }
+                }
+            }"#,
+        )
+        .await
+        .unwrap();
 
-    run_cmd(
-        Command::new("yarn")
-            .arg("install")
-            .arg("--mutex")
-            .arg("file:.yarn-mutex")
-            .current_dir("./runner-tests/"),
+    assert_eq!(
+        query_res,
+        Some(object! {
+            tokens: vec![
+                object! {
+                    id: "0xaa",
+                    stats: vec![
+                        object! { sum: "40" },
+                        object! { sum: "12" },
+                    ]
+                },
+                object! {
+                    id: "0xbb",
+                    stats: vec![
+                        object! { sum: "60" },
+                        object! { sum: "40" },
+                    ]
+                },
+            ]
+        })
     );
+}
+
+#[graph::test]
+async fn skip_duplicates() {
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("skip_duplicates", "skip-duplicates").await;
 
-    // Run codegen.
-    run_cmd(Command::new("yarn").arg("codegen").current_dir(dir));
+    let blocks = {
+        let block_0 = genesis();
+        let mut block_1 = empty_block(block_0.ptr(), test_ptr(1));
+        push_test_polling_trigger(&mut block_1);
+        let mut block_2 = empty_block(block_1.ptr(), test_ptr(2));
+        push_test_polling_trigger(&mut block_2);
+        let mut block_3 = empty_block(block_2.ptr(), test_ptr(3));
+        push_test_polling_trigger(&mut block_3);
+        let mut block_4 = empty_block(block_3.ptr(), test_ptr(4));
+        push_test_polling_trigger(&mut block_4);
+        vec![block_0, block_1, block_2, block_3, block_4]
+    };
 
-    let mut args = vec![yarn_cmd];
-    args.extend(arg);
+    let stop_block = blocks.last().unwrap().block.ptr();
+    let chain = chain(&test_info.test_name, blocks, &stores, None).await;
+    let ctx = fixture::setup(&test_info, &stores, &chain, None, None).await;
+
+    ctx.start_and_sync_to(stop_block).await;
 
-    // Run `deploy` for the side effect of uploading to IPFS, the graph node url
-    // is fake and the actual deploy call is meant to fail.
-    let deploy_output = run_cmd(
-        Command::new("yarn")
-            .args(&args)
-            .env("IPFS_URI", "http://127.0.0.1:5001")
-            .env("GRAPH_NODE_ADMIN_URI", "http://localhost:0")
-            .current_dir(dir),
+    let query_res = ctx
+        .query(r#"{ ping(id: "duplicate-entity") { id, value } }"#)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        query_res,
+        Some(object! {
+            ping: object! { id: "duplicate-entity", value: "ping" }
+        })
     );
+}
 
-    // Hack to extract deployment id from `graph deploy` output.
-    const ID_PREFIX: &str = "Build completed: ";
-    let Some(mut line) = deploy_output.lines().find(|line| line.contains(ID_PREFIX)) else {
-        panic!("No deployment id found, graph deploy probably had an error")
+/// Test that the unfail mechanism retries until the deployment head reaches
+/// the error block. This is a regression test for issue #6205.
+///
+/// Scenario:
+/// 1. Sync to block 1
+/// 2. Inject non-deterministic error at block 3 (ahead of head)
+/// 3. Run runner to block 3
+/// 4. At blocks 1-2: unfail returns BehindErrorBlock, keeps trying
+/// 5. At block 3: unfail succeeds, health → Healthy
+#[graph::test]
+async fn non_deterministic_unfail_retries_until_error_block() -> anyhow::Result<()> {
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("non_deterministic_unfail_retries", "end-block").await;
+
+    let blocks = {
+        let block_0 = genesis();
+        let mut block_1 = empty_block(block_0.ptr(), test_ptr(1));
+        let mut block_2 = empty_block(block_1.ptr(), test_ptr(2));
+        let mut block_3 = empty_block(block_2.ptr(), test_ptr(3));
+
+        // Add triggers to exercise normal block processing.
+        push_test_log(&mut block_1, "a");
+        push_test_log(&mut block_2, "b");
+        push_test_log(&mut block_3, "c");
+
+        vec![block_0, block_1, block_2, block_3]
     };
-    if !line.starts_with(ID_PREFIX) {
-        line = &line[5..line.len() - 5]; // workaround for colored output
-    }
-    DeploymentHash::new(line.trim_start_matches(ID_PREFIX)).unwrap()
+
+    let chain = chain(&test_info.test_name, blocks, &stores, None).await;
+    let ctx = fixture::setup(&test_info, &stores, &chain, None, None).await;
+
+    // Advance head to block 1.
+    ctx.start_and_sync_to(test_ptr(1)).await;
+
+    // Inject non-deterministic fatal error at block 3 (ahead of current head).
+    let writable = ctx
+        .store
+        .clone()
+        .writable(ctx.logger.clone(), ctx.deployment.id, Arc::new(vec![]))
+        .await
+        .unwrap();
+
+    writable
+        .fail_subgraph(SubgraphError {
+            subgraph_id: ctx.deployment.hash.clone(),
+            message: "injected transient error".to_string(),
+            block_ptr: Some(test_ptr(3)),
+            handler: None,
+            deterministic: false,
+        })
+        .await
+        .unwrap();
+
+    writable.flush().await.unwrap();
+
+    // Precondition: deployment is failed with non-deterministic error.
+    let status = ctx.indexing_status().await;
+    assert!(status.health == SubgraphHealth::Failed);
+    assert!(!status.fatal_error.as_ref().unwrap().deterministic);
+
+    // Run runner to block 3. The unfail mechanism should:
+    // - Return BehindErrorBlock at blocks 1-2 (keep trying)
+    // - Return Unfailed at block 3 (success)
+    let stop_block = test_ptr(3);
+    let _runner = ctx.runner(stop_block).await.run_for_test(false).await?;
+
+    // Postcondition: deployment is healthy, no fatal error.
+    let status = ctx.indexing_status().await;
+    assert!(status.health == SubgraphHealth::Healthy);
+    assert!(status.fatal_error.is_none());
+
+    Ok(())
 }